tools/llvm-readobj/ARMAttributeParser.cpp

   1 //===--- ARMAttributeParser.cpp - ARM Attribute Information Printer -------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "ARMAttributeParser.h"
  11 #include "StreamWriter.h"
  12 #include "llvm/ADT/STLExtras.h"
  13 #include "llvm/ADT/StringExtras.h"
  14 #include "llvm/Support/LEB128.h"
  15
  16 using namespace llvm;
  17 using namespace llvm::ARMBuildAttrs;
  18
  19
  20 static const EnumEntry<unsigned> TagNames[] = {
  21   { "Tag_File", ARMBuildAttrs::File },
  22   { "Tag_Section", ARMBuildAttrs::Section },
  23   { "Tag_Symbol", ARMBuildAttrs::Symbol },
  24 };
  25
  26 namespace llvm {
  27 #define ATTRIBUTE_HANDLER(Attr_)                                                \
  28   { ARMBuildAttrs::Attr_, &ARMAttributeParser::Attr_ }
  29
  30 const ARMAttributeParser::DisplayHandler
  31 ARMAttributeParser::DisplayRoutines[] = {
  32   { ARMBuildAttrs::CPU_raw_name, &ARMAttributeParser::StringAttribute, },
  33   { ARMBuildAttrs::CPU_name, &ARMAttributeParser::StringAttribute },
  34   ATTRIBUTE_HANDLER(CPU_arch),
  35   ATTRIBUTE_HANDLER(CPU_arch_profile),
  36   ATTRIBUTE_HANDLER(ARM_ISA_use),
  37   ATTRIBUTE_HANDLER(THUMB_ISA_use),
  38   ATTRIBUTE_HANDLER(FP_arch),
  39   ATTRIBUTE_HANDLER(WMMX_arch),
  40   ATTRIBUTE_HANDLER(Advanced_SIMD_arch),
  41   ATTRIBUTE_HANDLER(PCS_config),
  42   ATTRIBUTE_HANDLER(ABI_PCS_R9_use),
  43   ATTRIBUTE_HANDLER(ABI_PCS_RW_data),
  44   ATTRIBUTE_HANDLER(ABI_PCS_RO_data),
  45   ATTRIBUTE_HANDLER(ABI_PCS_GOT_use),
  46   ATTRIBUTE_HANDLER(ABI_PCS_wchar_t),
  47   ATTRIBUTE_HANDLER(ABI_FP_rounding),
  48   ATTRIBUTE_HANDLER(ABI_FP_denormal),
  49   ATTRIBUTE_HANDLER(ABI_FP_exceptions),
  50   ATTRIBUTE_HANDLER(ABI_FP_user_exceptions),
  51   ATTRIBUTE_HANDLER(ABI_FP_number_model),
  52   ATTRIBUTE_HANDLER(ABI_align_needed),
  53   ATTRIBUTE_HANDLER(ABI_align_preserved),
  54   ATTRIBUTE_HANDLER(ABI_enum_size),
  55   ATTRIBUTE_HANDLER(ABI_HardFP_use),
  56   ATTRIBUTE_HANDLER(ABI_VFP_args),
  57   ATTRIBUTE_HANDLER(ABI_WMMX_args),
  58   ATTRIBUTE_HANDLER(ABI_optimization_goals),
  59   ATTRIBUTE_HANDLER(ABI_FP_optimization_goals),
  60   ATTRIBUTE_HANDLER(compatibility),
  61   ATTRIBUTE_HANDLER(CPU_unaligned_access),
  62   ATTRIBUTE_HANDLER(FP_HP_extension),
  63   ATTRIBUTE_HANDLER(ABI_FP_16bit_format),
  64   ATTRIBUTE_HANDLER(MPextension_use),
  65   ATTRIBUTE_HANDLER(DIV_use),
  66   ATTRIBUTE_HANDLER(T2EE_use),
  67   ATTRIBUTE_HANDLER(Virtualization_use),
  68   ATTRIBUTE_HANDLER(nodefaults)
  69 };
  70
  71 #undef ATTRIBUTE_HANDLER
  72
  73 uint64_t ARMAttributeParser::ParseInteger(const uint8_t *Data,
  74                                           uint32_t &Offset) {
  75   unsigned Length;
  76   uint64_t Value = decodeULEB128(Data + Offset, &Length);
  77   Offset = Offset + Length;
  78   return Value;
  79 }
  80
  81 StringRef ARMAttributeParser::ParseString(const uint8_t *Data,
  82                                           uint32_t &Offset) {
  83   const char *String = reinterpret_cast<const char*>(Data + Offset);
  84   size_t Length = std::strlen(String);
  85   Offset = Offset + Length + 1;
  86   return StringRef(String, Length);
  87 }
  88
  89 void ARMAttributeParser::IntegerAttribute(AttrType Tag, const uint8_t *Data,
  90                                           uint32_t &Offset) {
  91   SW.printNumber(ARMBuildAttrs::AttrTypeAsString(Tag),
  92                  ParseInteger(Data, Offset));
  93 }
  94
  95 void ARMAttributeParser::StringAttribute(AttrType Tag, const uint8_t *Data,
  96                                          uint32_t &Offset) {
  97   StringRef TagName = ARMBuildAttrs::AttrTypeAsString(Tag, /*TagPrefix*/false);
  98
  99   DictScope AS(SW, "Attribute");
 100   SW.printNumber("Tag", Tag);
 101   if (!TagName.empty())
 102     SW.printString("TagName", TagName);
 103   SW.printString("Value", ParseString(Data, Offset));
 104 }
 105
 106 void ARMAttributeParser::PrintAttribute(unsigned Tag, unsigned Value,
 107                                         StringRef ValueDesc) {
 108   StringRef TagName = ARMBuildAttrs::AttrTypeAsString(Tag, /*TagPrefix*/false);
 109
 110   DictScope AS(SW, "Attribute");
 111   SW.printNumber("Tag", Tag);
 112   SW.printNumber("Value", Value);
 113   if (!TagName.empty())
 114     SW.printString("TagName", TagName);
 115   if (!ValueDesc.empty())
 116     SW.printString("Description", ValueDesc);
 117 }
 118
 119 void ARMAttributeParser::CPU_arch(AttrType Tag, const uint8_t *Data,
 120                                   uint32_t &Offset) {
 121   static const char *const Strings[] = {
 122     "Pre-v4", "ARM v4", "ARM v4T", "ARM v5T", "ARM v5TE", "ARM v5TEJ", "ARM v6",
 123     "ARM v6KZ", "ARM v6T2", "ARM v6K", "ARM v7", "ARM v6-M", "ARM v6S-M",
 124     "ARM v7E-M", "ARM v8"
 125   };
 126
 127   uint64_t Value = ParseInteger(Data, Offset);
 128   StringRef ValueDesc =
 129     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
 130   PrintAttribute(Tag, Value, ValueDesc);
 131 }
 132
 133 void ARMAttributeParser::CPU_arch_profile(AttrType Tag, const uint8_t *Data,
 134                                           uint32_t &Offset) {
 135   uint64_t Encoded = ParseInteger(Data, Offset);
 136
 137   StringRef Profile;
 138   switch (Encoded) {
 139   default:  Profile = "Unknown"; break;
 140   case 'A': Profile = "Application"; break;
 141   case 'R': Profile = "Real-time"; break;
 142   case 'M': Profile = "Microcontroller"; break;
 143   case 'S': Profile = "Classic"; break;
 144   case 0: Profile = "None"; break;
 145   }
 146
 147   PrintAttribute(Tag, Encoded, Profile);
 148 }
 149
 150 void ARMAttributeParser::ARM_ISA_use(AttrType Tag, const uint8_t *Data,
 151                                      uint32_t &Offset) {
 152   static const char *const Strings[] = { "Not Permitted", "Permitted" };
 153
 154   uint64_t Value = ParseInteger(Data, Offset);
 155   StringRef ValueDesc =
 156     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
 157   PrintAttribute(Tag, Value, ValueDesc);
 158 }
 159
 160 void ARMAttributeParser::THUMB_ISA_use(AttrType Tag, const uint8_t *Data,
 161                                        uint32_t &Offset) {
 162   static const char *const Strings[] = { "Not Permitted", "Thumb-1", "Thumb-2" };
 163
 164   uint64_t Value = ParseInteger(Data, Offset);
 165   StringRef ValueDesc =
 166     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
 167   PrintAttribute(Tag, Value, ValueDesc);
 168 }
 169
 170 void ARMAttributeParser::FP_arch(AttrType Tag, const uint8_t *Data,
 171                                  uint32_t &Offset) {
 172   static const char *const Strings[] = {
 173     "Not Permitted", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4",
 174     "VFPv4-D16", "ARMv8-a FP", "ARMv8-a FP-D16"
 175   };
 176
 177   uint64_t Value = ParseInteger(Data, Offset);
 178   StringRef ValueDesc =
 179     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
 180   PrintAttribute(Tag, Value, ValueDesc);
 181 }
 182
 183 void ARMAttributeParser::WMMX_arch(AttrType Tag, const uint8_t *Data,
 184                                    uint32_t &Offset) {
 185   static const char *const Strings[] = { "Not Permitted", "WMMXv1", "WMMXv2" };
 186
 187   uint64_t Value = ParseInteger(Data, Offset);
 188   StringRef ValueDesc =
 189     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
 190   PrintAttribute(Tag, Value, ValueDesc);
 191 }
 192
 193 void ARMAttributeParser::Advanced_SIMD_arch(AttrType Tag, const uint8_t *Data,
 194                                             uint32_t &Offset) {
 195   static const char *const Strings[] = {
 196     "Not Permitted", "NEONv1", "NEONv2+FMA", "ARMv8-a NEON", "ARMv8.1-a NEON"
 197   };
 198
 199   uint64_t Value = ParseInteger(Data, Offset);
 200   StringRef ValueDesc =
 201     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
 202   PrintAttribute(Tag, Value, ValueDesc);
 203 }
 204
 205 void ARMAttributeParser::PCS_config(AttrType Tag, const uint8_t *Data,
 206                                     uint32_t &Offset) {
 207   static const char *const Strings[] = {
 208     "None", "Bare Platform", "Linux Application", "Linux DSO", "Palm OS 2004",
 209     "Reserved (Palm OS)", "Symbian OS 2004", "Reserved (Symbian OS)"
 210   };
 211
 212   uint64_t Value = ParseInteger(Data, Offset);
 213   StringRef ValueDesc =
 214     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
 215   PrintAttribute(Tag, Value, ValueDesc);
 216 }
 217
 218 void ARMAttributeParser::ABI_PCS_R9_use(AttrType Tag, const uint8_t *Data,
 219                                         uint32_t &Offset) {
 220   static const char *const Strings[] = { "v6", "Static Base", "TLS", "Unused" };
 221
 222   uint64_t Value = ParseInteger(Data, Offset);
 223   StringRef ValueDesc =
 224     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
 225   PrintAttribute(Tag, Value, ValueDesc);
 226 }
 227
 228 void ARMAttributeParser::ABI_PCS_RW_data(AttrType Tag, const uint8_t *Data,
 229                                          uint32_t &Offset) {
 230   static const char *const Strings[] = {
 231     "Absolute", "PC-relative", "SB-relative", "Not Permitted"
 232   };
 233
 234   uint64_t Value = ParseInteger(Data, Offset);
 235   StringRef ValueDesc =
 236     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
 237   PrintAttribute(Tag, Value, ValueDesc);
 238 }
 239
 240 void ARMAttributeParser::ABI_PCS_RO_data(AttrType Tag, const uint8_t *Data,
 241                                          uint32_t &Offset) {
 242   static const char *const Strings[] = {
 243     "Absolute", "PC-relative", "Not Permitted"
 244   };
 245
 246   uint64_t Value = ParseInteger(Data, Offset);
 247   StringRef ValueDesc =
 248     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
 249   PrintAttribute(Tag, Value, ValueDesc);
 250 }
 251
 252 void ARMAttributeParser::ABI_PCS_GOT_use(AttrType Tag, const uint8_t *Data,
 253                                          uint32_t &Offset) {
 254   static const char *const Strings[] = {
 255     "Not Permitted", "Direct", "GOT-Indirect"
 256   };
 257
 258   uint64_t Value = ParseInteger(Data, Offset);
 259   StringRef ValueDesc =
 260     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
 261   PrintAttribute(Tag, Value, ValueDesc);
 262 }
 263
 264 void ARMAttributeParser::ABI_PCS_wchar_t(AttrType Tag, const uint8_t *Data,
 265                                          uint32_t &Offset) {
 266   static const char *const Strings[] = {
 267     "Not Permitted", "Unknown", "2-byte", "Unknown", "4-byte"
 268   };
 269
 270   uint64_t Value = ParseInteger(Data, Offset);
 271   StringRef ValueDesc =
 272     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
 273   PrintAttribute(Tag, Value, ValueDesc);
 274 }
 275
 276 void ARMAttributeParser::ABI_FP_rounding(AttrType Tag, const uint8_t *Data,
 277                                          uint32_t &Offset) {
 278   static const char *const Strings[] = { "IEEE-754", "Runtime" };
 279
 280   uint64_t Value = ParseInteger(Data, Offset);
 281   StringRef ValueDesc =
 282     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
 283   PrintAttribute(Tag, Value, ValueDesc);
 284 }
 285
 286 void ARMAttributeParser::ABI_FP_denormal(AttrType Tag, const uint8_t *Data,
 287                                          uint32_t &Offset) {
 288   static const char *const Strings[] = {
 289     "Unsupported", "IEEE-754", "Sign Only"
 290   };
 291
 292   uint64_t Value = ParseInteger(Data, Offset);
 293   StringRef ValueDesc =
 294     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
 295   PrintAttribute(Tag, Value, ValueDesc);
 296 }
 297
 298 void ARMAttributeParser::ABI_FP_exceptions(AttrType Tag, const uint8_t *Data,
 299                                            uint32_t &Offset) {
 300   static const char *const Strings[] = { "Not Permitted", "IEEE-754" };
 301
 302   uint64_t Value = ParseInteger(Data, Offset);
 303   StringRef ValueDesc =
 304     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
 305   PrintAttribute(Tag, Value, ValueDesc);
 306 }
 307
 308 void ARMAttributeParser::ABI_FP_user_exceptions(AttrType Tag,
 309                                                 const uint8_t *Data,
 310                                                 uint32_t &Offset) {
 311   static const char *const Strings[] = { "Not Permitted", "IEEE-754" };
 312
 313   uint64_t Value = ParseInteger(Data, Offset);
 314   StringRef ValueDesc =
 315     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
 316   PrintAttribute(Tag, Value, ValueDesc);
 317 }
 318
 319 void ARMAttributeParser::ABI_FP_number_model(AttrType Tag, const uint8_t *Data,
 320                                              uint32_t &Offset) {
 321   static const char *const Strings[] = {
 322     "Not Permitted", "Finite Only", "RTABI", "IEEE-754"
 323   };
 324
 325   uint64_t Value = ParseInteger(Data, Offset);
 326   StringRef ValueDesc =
 327     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
 328   PrintAttribute(Tag, Value, ValueDesc);
 329 }
 330
 331 void ARMAttributeParser::ABI_align_needed(AttrType Tag, const uint8_t *Data,
 332                                           uint32_t &Offset) {
 333   static const char *const Strings[] = {
 334     "Not Permitted", "8-byte alignment", "4-byte alignment", "Reserved"
 335   };
 336
 337   uint64_t Value = ParseInteger(Data, Offset);
 338
 339   std::string Description;
 340   if (Value < array_lengthof(Strings))
 341     Description = std::string(Strings[Value]);
 342   else if (Value <= 12)
 343     Description = std::string("8-byte alignment, ") + utostr(1 << Value)
 344                 + std::string("-byte extended alignment");
 345   else
 346     Description = "Invalid";
 347
 348   PrintAttribute(Tag, Value, Description);
 349 }
 350
 351 void ARMAttributeParser::ABI_align_preserved(AttrType Tag, const uint8_t *Data,
 352                                              uint32_t &Offset) {
 353   static const char *const Strings[] = {
 354     "Not Required", "8-byte data alignment", "8-byte data and code alignment",
 355     "Reserved"
 356   };
 357
 358   uint64_t Value = ParseInteger(Data, Offset);
 359
 360   std::string Description;
 361   if (Value < array_lengthof(Strings))
 362     Description = std::string(Strings[Value]);
 363   else if (Value <= 12)
 364     Description = std::string("8-byte stack alignment, ") + utostr(1 << Value)
 365                 + std::string("-byte data alignment");
 366   else
 367     Description = "Invalid";
 368
 369   PrintAttribute(Tag, Value, Description);
 370 }
 371
 372 void ARMAttributeParser::ABI_enum_size(AttrType Tag, const uint8_t *Data,
 373                                        uint32_t &Offset) {
 374   static const char *const Strings[] = {
 375     "Not Permitted", "Packed", "Int32", "External Int32"
 376   };
 377
 378   uint64_t Value = ParseInteger(Data, Offset);
 379   StringRef ValueDesc =
 380     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
 381   PrintAttribute(Tag, Value, ValueDesc);
 382 }
 383
 384 void ARMAttributeParser::ABI_HardFP_use(AttrType Tag, const uint8_t *Data,
 385                                         uint32_t &Offset) {
 386   static const char *const Strings[] = {
 387     "Tag_FP_arch", "Single-Precision", "Reserved", "Tag_FP_arch (deprecated)"
 388   };
 389
 390   uint64_t Value = ParseInteger(Data, Offset);
 391   StringRef ValueDesc =
 392     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
 393   PrintAttribute(Tag, Value, ValueDesc);
 394 }
 395
 396 void ARMAttributeParser::ABI_VFP_args(AttrType Tag, const uint8_t *Data,
 397                                       uint32_t &Offset) {
 398   static const char *const Strings[] = {
 399     "AAPCS", "AAPCS VFP", "Custom", "Not Permitted"
 400   };
 401
 402   uint64_t Value = ParseInteger(Data, Offset);
 403   StringRef ValueDesc =
 404     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
 405   PrintAttribute(Tag, Value, ValueDesc);
 406 }
 407
 408 void ARMAttributeParser::ABI_WMMX_args(AttrType Tag, const uint8_t *Data,
 409                                        uint32_t &Offset) {
 410   static const char *const Strings[] = { "AAPCS", "iWMMX", "Custom" };
 411
 412   uint64_t Value = ParseInteger(Data, Offset);
 413   StringRef ValueDesc =
 414     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
 415   PrintAttribute(Tag, Value, ValueDesc);
 416 }
 417
 418 void ARMAttributeParser::ABI_optimization_goals(AttrType Tag,
 419                                                 const uint8_t *Data,
 420                                                 uint32_t &Offset) {
 421   static const char *const Strings[] = {
 422     "None", "Speed", "Aggressive Speed", "Size", "Aggressive Size", "Debugging",
 423     "Best Debugging"
 424   };
 425
 426   uint64_t Value = ParseInteger(Data, Offset);
 427   StringRef ValueDesc =
 428     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
 429   PrintAttribute(Tag, Value, ValueDesc);
 430 }
 431
 432 void ARMAttributeParser::ABI_FP_optimization_goals(AttrType Tag,
 433                                                    const uint8_t *Data,
 434                                                    uint32_t &Offset) {
 435   static const char *const Strings[] = {
 436     "None", "Speed", "Aggressive Speed", "Size", "Aggressive Size", "Accuracy",
 437     "Best Accuracy"
 438   };
 439
 440   uint64_t Value = ParseInteger(Data, Offset);
 441   StringRef ValueDesc =
 442     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
 443   PrintAttribute(Tag, Value, ValueDesc);
 444 }
 445
 446 void ARMAttributeParser::compatibility(AttrType Tag, const uint8_t *Data,
 447                                        uint32_t &Offset) {
 448   uint64_t Integer = ParseInteger(Data, Offset);
 449   StringRef String = ParseString(Data, Offset);
 450
 451   DictScope AS(SW, "Attribute");
 452   SW.printNumber("Tag", Tag);
 453   SW.startLine() << "Value: " << Integer << ", " << String << '\n';
 454   SW.printString("TagName", AttrTypeAsString(Tag, /*TagPrefix*/false));
 455   switch (Integer) {
 456   case 0:
 457     SW.printString("Description", StringRef("No Specific Requirements"));
 458     break;
 459   case 1:
 460     SW.printString("Description", StringRef("AEABI Conformant"));
 461     break;
 462   default:
 463     SW.printString("Description", StringRef("AEABI Non-Conformant"));
 464     break;
 465   }
 466 }
 467
 468 void ARMAttributeParser::CPU_unaligned_access(AttrType Tag, const uint8_t *Data,
 469                                               uint32_t &Offset) {
 470   static const char *const Strings[] = { "Not Permitted", "v6-style" };
 471
 472   uint64_t Value = ParseInteger(Data, Offset);
 473   StringRef ValueDesc =
 474     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
 475   PrintAttribute(Tag, Value, ValueDesc);
 476 }
 477
 478 void ARMAttributeParser::FP_HP_extension(AttrType Tag, const uint8_t *Data,
 479                                          uint32_t &Offset) {
 480   static const char *const Strings[] = { "If Available", "Permitted" };
 481
 482   uint64_t Value = ParseInteger(Data, Offset);
 483   StringRef ValueDesc =
 484     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
 485   PrintAttribute(Tag, Value, ValueDesc);
 486 }
 487
 488 void ARMAttributeParser::ABI_FP_16bit_format(AttrType Tag, const uint8_t *Data,
 489                                              uint32_t &Offset) {
 490   static const char *const Strings[] = { "Not Permitted", "IEEE-754", "VFPv3" };
 491
 492   uint64_t Value = ParseInteger(Data, Offset);
 493   StringRef ValueDesc =
 494     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
 495   PrintAttribute(Tag, Value, ValueDesc);
 496 }
 497
 498 void ARMAttributeParser::MPextension_use(AttrType Tag, const uint8_t *Data,
 499                                          uint32_t &Offset) {
 500   static const char *const Strings[] = { "Not Permitted", "Permitted" };
 501
 502   uint64_t Value = ParseInteger(Data, Offset);
 503   StringRef ValueDesc =
 504     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
 505   PrintAttribute(Tag, Value, ValueDesc);
 506 }
 507
 508 void ARMAttributeParser::DIV_use(AttrType Tag, const uint8_t *Data,
 509                                  uint32_t &Offset) {
 510   static const char *const Strings[] = {
 511     "If Available", "Not Permitted", "Permitted"
 512   };
 513
 514   uint64_t Value = ParseInteger(Data, Offset);
 515   StringRef ValueDesc =
 516     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
 517   PrintAttribute(Tag, Value, ValueDesc);
 518 }
 519
 520 void ARMAttributeParser::T2EE_use(AttrType Tag, const uint8_t *Data,
 521                                   uint32_t &Offset) {
 522   static const char *const Strings[] = { "Not Permitted", "Permitted" };
 523
 524   uint64_t Value = ParseInteger(Data, Offset);
 525   StringRef ValueDesc =
 526     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
 527   PrintAttribute(Tag, Value, ValueDesc);
 528 }
 529
 530 void ARMAttributeParser::Virtualization_use(AttrType Tag, const uint8_t *Data,
 531                                             uint32_t &Offset) {
 532   static const char *const Strings[] = {
 533     "Not Permitted", "TrustZone", "Virtualization Extensions",
 534     "TrustZone + Virtualization Extensions"
 535   };
 536
 537   uint64_t Value = ParseInteger(Data, Offset);
 538   StringRef ValueDesc =
 539     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
 540   PrintAttribute(Tag, Value, ValueDesc);
 541 }
 542
 543 void ARMAttributeParser::nodefaults(AttrType Tag, const uint8_t *Data,
 544                                     uint32_t &Offset) {
 545   uint64_t Value = ParseInteger(Data, Offset);
 546   PrintAttribute(Tag, Value, "Unspecified Tags UNDEFINED");
 547 }
 548
 549 void ARMAttributeParser::ParseIndexList(const uint8_t *Data, uint32_t &Offset,
 550                                         SmallVectorImpl<uint8_t> &IndexList) {
 551   for (;;) {
 552     unsigned Length;
 553     uint64_t Value = decodeULEB128(Data + Offset, &Length);
 554     Offset = Offset + Length;
 555     if (Value == 0)
 556       break;
 557     IndexList.push_back(Value);
 558   }
 559 }
 560
 561 void ARMAttributeParser::ParseAttributeList(const uint8_t *Data,
 562                                             uint32_t &Offset, uint32_t Length) {
 563   while (Offset < Length) {
 564     unsigned Length;
 565     uint64_t Tag = decodeULEB128(Data + Offset, &Length);
 566     Offset += Length;
 567
 568     bool Handled = false;
 569     for (unsigned AHI = 0, AHE = array_lengthof(DisplayRoutines);
 570          AHI != AHE && !Handled; ++AHI) {
 571       if (DisplayRoutines[AHI].Attribute == Tag) {
 572         (this->*DisplayRoutines[AHI].Routine)(ARMBuildAttrs::AttrType(Tag),
 573                                               Data, Offset);
 574         Handled = true;
 575         break;
 576       }
 577     }
 578     if (!Handled) {
 579       if (Tag < 32) {
 580         errs() << "unhandled AEABI Tag " << Tag
 581                << " (" << ARMBuildAttrs::AttrTypeAsString(Tag) << ")\n";
 582         continue;
 583       }
 584
 585       if (Tag % 2 == 0)
 586         IntegerAttribute(ARMBuildAttrs::AttrType(Tag), Data, Offset);
 587       else
 588         StringAttribute(ARMBuildAttrs::AttrType(Tag), Data, Offset);
 589     }
 590   }
 591 }
 592
 593 void ARMAttributeParser::ParseSubsection(const uint8_t *Data, uint32_t Length) {
 594   uint32_t Offset = sizeof(uint32_t); /* SectionLength */
 595
 596   SW.printNumber("SectionLength", Length);
 597
 598   const char *VendorName = reinterpret_cast<const char*>(Data + Offset);
 599   size_t VendorNameLength = std::strlen(VendorName);
 600   SW.printString("Vendor", StringRef(VendorName, VendorNameLength));
 601   Offset = Offset + VendorNameLength + 1;
 602
 603   if (StringRef(VendorName, VendorNameLength).lower() != "aeabi")
 604     return;
 605
 606   while (Offset < Length) {
 607     /// Tag_File | Tag_Section | Tag_Symbol   uleb128:byte-size
 608     uint8_t Tag = Data[Offset];
 609     SW.printEnum("Tag", Tag, makeArrayRef(TagNames));
 610     Offset = Offset + sizeof(Tag);
 611
 612     uint32_t Size =
 613       *reinterpret_cast<const support::ulittle32_t*>(Data + Offset);
 614     SW.printNumber("Size", Size);
 615     Offset = Offset + sizeof(Size);
 616
 617     if (Size > Length) {
 618       errs() << "subsection length greater than section length\n";
 619       return;
 620     }
 621
 622     StringRef ScopeName, IndexName;
 623     SmallVector<uint8_t, 8> Indicies;
 624     switch (Tag) {
 625     case ARMBuildAttrs::File:
 626       ScopeName = "FileAttributes";
 627       break;
 628     case ARMBuildAttrs::Section:
 629       ScopeName = "SectionAttributes";
 630       IndexName = "Sections";
 631       ParseIndexList(Data, Offset, Indicies);
 632       break;
 633     case ARMBuildAttrs::Symbol:
 634       ScopeName = "SymbolAttributes";
 635       IndexName = "Symbols";
 636       ParseIndexList(Data, Offset, Indicies);
 637       break;
 638     default:
 639       errs() << "unrecognised tag: 0x" << utohexstr(Tag) << '\n';
 640       return;
 641     }
 642
 643     DictScope ASS(SW, ScopeName);
 644
 645     if (!Indicies.empty())
 646       SW.printList(IndexName, Indicies);
 647
 648     ParseAttributeList(Data, Offset, Length);
 649   }
 650 }
 651
 652 void ARMAttributeParser::Parse(ArrayRef<uint8_t> Section) {
 653   size_t Offset = 1;
 654   unsigned SectionNumber = 0;
 655
 656   while (Offset < Section.size()) {
 657     uint32_t SectionLength =
 658       *reinterpret_cast<const support::ulittle32_t*>(Section.data() + Offset);
 659
 660     SW.startLine() << "Section " << ++SectionNumber << " {\n";
 661     SW.indent();
 662
 663     ParseSubsection(Section.data() + Offset, SectionLength);
 664     Offset = Offset + SectionLength;
 665
 666     SW.unindent();
 667     SW.startLine() << "}\n";
 668   }
 669 }
 670 }
 671