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