lib/Support/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 "llvm/Support/ARMAttributeParser.h"
  11 #include "llvm/ADT/STLExtras.h"
  12 #include "llvm/ADT/StringExtras.h"
  13 #include "llvm/Support/LEB128.h"
  14 #include "llvm/Support/ScopedPrinter.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(DSP_extension),
  67   ATTRIBUTE_HANDLER(T2EE_use),
  68   ATTRIBUTE_HANDLER(Virtualization_use),
  69   ATTRIBUTE_HANDLER(nodefaults)
  70 };
  71
  72 #undef ATTRIBUTE_HANDLER
  73
  74 uint64_t ARMAttributeParser::ParseInteger(const uint8_t *Data,
  75                                           uint32_t &Offset) {
  76   unsigned Length;
  77   uint64_t Value = decodeULEB128(Data + Offset, &Length);
  78   Offset = Offset + Length;
  79   return Value;
  80 }
  81
  82 StringRef ARMAttributeParser::ParseString(const uint8_t *Data,
  83                                           uint32_t &Offset) {
  84   const char *String = reinterpret_cast<const char*>(Data + Offset);
  85   size_t Length = std::strlen(String);
  86   Offset = Offset + Length + 1;
  87   return StringRef(String, Length);
  88 }
  89
  90 void ARMAttributeParser::IntegerAttribute(AttrType Tag, const uint8_t *Data,
  91                                           uint32_t &Offset) {
  92
  93   uint64_t Value = ParseInteger(Data, Offset);
  94   Attributes.insert(std::make_pair(Tag, Value));
  95
  96   if (SW)
  97     SW->printNumber(ARMBuildAttrs::AttrTypeAsString(Tag), Value);
  98 }
  99
 100 void ARMAttributeParser::StringAttribute(AttrType Tag, const uint8_t *Data,
 101                                          uint32_t &Offset) {
 102   StringRef TagName = ARMBuildAttrs::AttrTypeAsString(Tag, /*TagPrefix*/false);
 103   StringRef ValueDesc = ParseString(Data, Offset);
 104
 105   if (SW) {
 106     DictScope AS(*SW, "Attribute");
 107     SW->printNumber("Tag", Tag);
 108     if (!TagName.empty())
 109       SW->printString("TagName", TagName);
 110     SW->printString("Value", ValueDesc);
 111   }
 112 }
 113
 114 void ARMAttributeParser::PrintAttribute(unsigned Tag, unsigned Value,
 115                                         StringRef ValueDesc) {
 116   Attributes.insert(std::make_pair(Tag, Value));
 117
 118   if (SW) {
 119     StringRef TagName = ARMBuildAttrs::AttrTypeAsString(Tag,
 120                                                         /*TagPrefix*/false);
 121     DictScope AS(*SW, "Attribute");
 122     SW->printNumber("Tag", Tag);
 123     SW->printNumber("Value", Value);
 124     if (!TagName.empty())
 125       SW->printString("TagName", TagName);
 126     if (!ValueDesc.empty())
 127       SW->printString("Description", ValueDesc);
 128   }
 129 }
 130
 131 void ARMAttributeParser::CPU_arch(AttrType Tag, const uint8_t *Data,
 132                                   uint32_t &Offset) {
 133   static const char *const Strings[] = {
 134     "Pre-v4", "ARM v4", "ARM v4T", "ARM v5T", "ARM v5TE", "ARM v5TEJ", "ARM v6",
 135     "ARM v6KZ", "ARM v6T2", "ARM v6K", "ARM v7", "ARM v6-M", "ARM v6S-M",
 136     "ARM v7E-M", "ARM v8"
 137   };
 138
 139   uint64_t Value = ParseInteger(Data, Offset);
 140   StringRef ValueDesc =
 141     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
 142   PrintAttribute(Tag, Value, ValueDesc);
 143 }
 144
 145 void ARMAttributeParser::CPU_arch_profile(AttrType Tag, const uint8_t *Data,
 146                                           uint32_t &Offset) {
 147   uint64_t Encoded = ParseInteger(Data, Offset);
 148
 149   StringRef Profile;
 150   switch (Encoded) {
 151   default:  Profile = "Unknown"; break;
 152   case 'A': Profile = "Application"; break;
 153   case 'R': Profile = "Real-time"; break;
 154   case 'M': Profile = "Microcontroller"; break;
 155   case 'S': Profile = "Classic"; break;
 156   case 0: Profile = "None"; break;
 157   }
 158
 159   PrintAttribute(Tag, Encoded, Profile);
 160 }
 161
 162 void ARMAttributeParser::ARM_ISA_use(AttrType Tag, const uint8_t *Data,
 163                                      uint32_t &Offset) {
 164   static const char *const Strings[] = { "Not Permitted", "Permitted" };
 165
 166   uint64_t Value = ParseInteger(Data, Offset);
 167   StringRef ValueDesc =
 168     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
 169   PrintAttribute(Tag, Value, ValueDesc);
 170 }
 171
 172 void ARMAttributeParser::THUMB_ISA_use(AttrType Tag, const uint8_t *Data,
 173                                        uint32_t &Offset) {
 174   static const char *const Strings[] = { "Not Permitted", "Thumb-1", "Thumb-2" };
 175
 176   uint64_t Value = ParseInteger(Data, Offset);
 177   StringRef ValueDesc =
 178     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
 179   PrintAttribute(Tag, Value, ValueDesc);
 180 }
 181
 182 void ARMAttributeParser::FP_arch(AttrType Tag, const uint8_t *Data,
 183                                  uint32_t &Offset) {
 184   static const char *const Strings[] = {
 185     "Not Permitted", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4",
 186     "VFPv4-D16", "ARMv8-a FP", "ARMv8-a FP-D16"
 187   };
 188
 189   uint64_t Value = ParseInteger(Data, Offset);
 190   StringRef ValueDesc =
 191     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
 192   PrintAttribute(Tag, Value, ValueDesc);
 193 }
 194
 195 void ARMAttributeParser::WMMX_arch(AttrType Tag, const uint8_t *Data,
 196                                    uint32_t &Offset) {
 197   static const char *const Strings[] = { "Not Permitted", "WMMXv1", "WMMXv2" };
 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::Advanced_SIMD_arch(AttrType Tag, const uint8_t *Data,
 206                                             uint32_t &Offset) {
 207   static const char *const Strings[] = {
 208     "Not Permitted", "NEONv1", "NEONv2+FMA", "ARMv8-a NEON", "ARMv8.1-a NEON"
 209   };
 210
 211   uint64_t Value = ParseInteger(Data, Offset);
 212   StringRef ValueDesc =
 213     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
 214   PrintAttribute(Tag, Value, ValueDesc);
 215 }
 216
 217 void ARMAttributeParser::PCS_config(AttrType Tag, const uint8_t *Data,
 218                                     uint32_t &Offset) {
 219   static const char *const Strings[] = {
 220     "None", "Bare Platform", "Linux Application", "Linux DSO", "Palm OS 2004",
 221     "Reserved (Palm OS)", "Symbian OS 2004", "Reserved (Symbian OS)"
 222   };
 223
 224   uint64_t Value = ParseInteger(Data, Offset);
 225   StringRef ValueDesc =
 226     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
 227   PrintAttribute(Tag, Value, ValueDesc);
 228 }
 229
 230 void ARMAttributeParser::ABI_PCS_R9_use(AttrType Tag, const uint8_t *Data,
 231                                         uint32_t &Offset) {
 232   static const char *const Strings[] = { "v6", "Static Base", "TLS", "Unused" };
 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_RW_data(AttrType Tag, const uint8_t *Data,
 241                                          uint32_t &Offset) {
 242   static const char *const Strings[] = {
 243     "Absolute", "PC-relative", "SB-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_RO_data(AttrType Tag, const uint8_t *Data,
 253                                          uint32_t &Offset) {
 254   static const char *const Strings[] = {
 255     "Absolute", "PC-relative", "Not Permitted"
 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_GOT_use(AttrType Tag, const uint8_t *Data,
 265                                          uint32_t &Offset) {
 266   static const char *const Strings[] = {
 267     "Not Permitted", "Direct", "GOT-Indirect"
 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_PCS_wchar_t(AttrType Tag, const uint8_t *Data,
 277                                          uint32_t &Offset) {
 278   static const char *const Strings[] = {
 279     "Not Permitted", "Unknown", "2-byte", "Unknown", "4-byte"
 280   };
 281
 282   uint64_t Value = ParseInteger(Data, Offset);
 283   StringRef ValueDesc =
 284     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
 285   PrintAttribute(Tag, Value, ValueDesc);
 286 }
 287
 288 void ARMAttributeParser::ABI_FP_rounding(AttrType Tag, const uint8_t *Data,
 289                                          uint32_t &Offset) {
 290   static const char *const Strings[] = { "IEEE-754", "Runtime" };
 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_denormal(AttrType Tag, const uint8_t *Data,
 299                                          uint32_t &Offset) {
 300   static const char *const Strings[] = {
 301     "Unsupported", "IEEE-754", "Sign Only"
 302   };
 303
 304   uint64_t Value = ParseInteger(Data, Offset);
 305   StringRef ValueDesc =
 306     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
 307   PrintAttribute(Tag, Value, ValueDesc);
 308 }
 309
 310 void ARMAttributeParser::ABI_FP_exceptions(AttrType Tag, const uint8_t *Data,
 311                                            uint32_t &Offset) {
 312   static const char *const Strings[] = { "Not Permitted", "IEEE-754" };
 313
 314   uint64_t Value = ParseInteger(Data, Offset);
 315   StringRef ValueDesc =
 316     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
 317   PrintAttribute(Tag, Value, ValueDesc);
 318 }
 319
 320 void ARMAttributeParser::ABI_FP_user_exceptions(AttrType Tag,
 321                                                 const uint8_t *Data,
 322                                                 uint32_t &Offset) {
 323   static const char *const Strings[] = { "Not Permitted", "IEEE-754" };
 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_FP_number_model(AttrType Tag, const uint8_t *Data,
 332                                              uint32_t &Offset) {
 333   static const char *const Strings[] = {
 334     "Not Permitted", "Finite Only", "RTABI", "IEEE-754"
 335   };
 336
 337   uint64_t Value = ParseInteger(Data, Offset);
 338   StringRef ValueDesc =
 339     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
 340   PrintAttribute(Tag, Value, ValueDesc);
 341 }
 342
 343 void ARMAttributeParser::ABI_align_needed(AttrType Tag, const uint8_t *Data,
 344                                           uint32_t &Offset) {
 345   static const char *const Strings[] = {
 346     "Not Permitted", "8-byte alignment", "4-byte alignment", "Reserved"
 347   };
 348
 349   uint64_t Value = ParseInteger(Data, Offset);
 350
 351   std::string Description;
 352   if (Value < array_lengthof(Strings))
 353     Description = std::string(Strings[Value]);
 354   else if (Value <= 12)
 355     Description = std::string("8-byte alignment, ") + utostr(1ULL << Value)
 356                 + std::string("-byte extended alignment");
 357   else
 358     Description = "Invalid";
 359
 360   PrintAttribute(Tag, Value, Description);
 361 }
 362
 363 void ARMAttributeParser::ABI_align_preserved(AttrType Tag, const uint8_t *Data,
 364                                              uint32_t &Offset) {
 365   static const char *const Strings[] = {
 366     "Not Required", "8-byte data alignment", "8-byte data and code alignment",
 367     "Reserved"
 368   };
 369
 370   uint64_t Value = ParseInteger(Data, Offset);
 371
 372   std::string Description;
 373   if (Value < array_lengthof(Strings))
 374     Description = std::string(Strings[Value]);
 375   else if (Value <= 12)
 376     Description = std::string("8-byte stack alignment, ") +
 377                   utostr(1ULL << Value) + std::string("-byte data alignment");
 378   else
 379     Description = "Invalid";
 380
 381   PrintAttribute(Tag, Value, Description);
 382 }
 383
 384 void ARMAttributeParser::ABI_enum_size(AttrType Tag, const uint8_t *Data,
 385                                        uint32_t &Offset) {
 386   static const char *const Strings[] = {
 387     "Not Permitted", "Packed", "Int32", "External Int32"
 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_HardFP_use(AttrType Tag, const uint8_t *Data,
 397                                         uint32_t &Offset) {
 398   static const char *const Strings[] = {
 399     "Tag_FP_arch", "Single-Precision", "Reserved", "Tag_FP_arch (deprecated)"
 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_VFP_args(AttrType Tag, const uint8_t *Data,
 409                                       uint32_t &Offset) {
 410   static const char *const Strings[] = {
 411     "AAPCS", "AAPCS VFP", "Custom", "Not Permitted"
 412   };
 413
 414   uint64_t Value = ParseInteger(Data, Offset);
 415   StringRef ValueDesc =
 416     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
 417   PrintAttribute(Tag, Value, ValueDesc);
 418 }
 419
 420 void ARMAttributeParser::ABI_WMMX_args(AttrType Tag, const uint8_t *Data,
 421                                        uint32_t &Offset) {
 422   static const char *const Strings[] = { "AAPCS", "iWMMX", "Custom" };
 423
 424   uint64_t Value = ParseInteger(Data, Offset);
 425   StringRef ValueDesc =
 426     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
 427   PrintAttribute(Tag, Value, ValueDesc);
 428 }
 429
 430 void ARMAttributeParser::ABI_optimization_goals(AttrType Tag,
 431                                                 const uint8_t *Data,
 432                                                 uint32_t &Offset) {
 433   static const char *const Strings[] = {
 434     "None", "Speed", "Aggressive Speed", "Size", "Aggressive Size", "Debugging",
 435     "Best Debugging"
 436   };
 437
 438   uint64_t Value = ParseInteger(Data, Offset);
 439   StringRef ValueDesc =
 440     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
 441   PrintAttribute(Tag, Value, ValueDesc);
 442 }
 443
 444 void ARMAttributeParser::ABI_FP_optimization_goals(AttrType Tag,
 445                                                    const uint8_t *Data,
 446                                                    uint32_t &Offset) {
 447   static const char *const Strings[] = {
 448     "None", "Speed", "Aggressive Speed", "Size", "Aggressive Size", "Accuracy",
 449     "Best Accuracy"
 450   };
 451
 452   uint64_t Value = ParseInteger(Data, Offset);
 453   StringRef ValueDesc =
 454     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
 455   PrintAttribute(Tag, Value, ValueDesc);
 456 }
 457
 458 void ARMAttributeParser::compatibility(AttrType Tag, const uint8_t *Data,
 459                                        uint32_t &Offset) {
 460   uint64_t Integer = ParseInteger(Data, Offset);
 461   StringRef String = ParseString(Data, Offset);
 462
 463   if (SW) {
 464     DictScope AS(*SW, "Attribute");
 465     SW->printNumber("Tag", Tag);
 466     SW->startLine() << "Value: " << Integer << ", " << String << '\n';
 467     SW->printString("TagName", AttrTypeAsString(Tag, /*TagPrefix*/false));
 468     switch (Integer) {
 469     case 0:
 470       SW->printString("Description", StringRef("No Specific Requirements"));
 471       break;
 472     case 1:
 473       SW->printString("Description", StringRef("AEABI Conformant"));
 474       break;
 475     default:
 476       SW->printString("Description", StringRef("AEABI Non-Conformant"));
 477       break;
 478     }
 479   }
 480 }
 481
 482 void ARMAttributeParser::CPU_unaligned_access(AttrType Tag, const uint8_t *Data,
 483                                               uint32_t &Offset) {
 484   static const char *const Strings[] = { "Not Permitted", "v6-style" };
 485
 486   uint64_t Value = ParseInteger(Data, Offset);
 487   StringRef ValueDesc =
 488     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
 489   PrintAttribute(Tag, Value, ValueDesc);
 490 }
 491
 492 void ARMAttributeParser::FP_HP_extension(AttrType Tag, const uint8_t *Data,
 493                                          uint32_t &Offset) {
 494   static const char *const Strings[] = { "If Available", "Permitted" };
 495
 496   uint64_t Value = ParseInteger(Data, Offset);
 497   StringRef ValueDesc =
 498     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
 499   PrintAttribute(Tag, Value, ValueDesc);
 500 }
 501
 502 void ARMAttributeParser::ABI_FP_16bit_format(AttrType Tag, const uint8_t *Data,
 503                                              uint32_t &Offset) {
 504   static const char *const Strings[] = { "Not Permitted", "IEEE-754", "VFPv3" };
 505
 506   uint64_t Value = ParseInteger(Data, Offset);
 507   StringRef ValueDesc =
 508     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
 509   PrintAttribute(Tag, Value, ValueDesc);
 510 }
 511
 512 void ARMAttributeParser::MPextension_use(AttrType Tag, const uint8_t *Data,
 513                                          uint32_t &Offset) {
 514   static const char *const Strings[] = { "Not Permitted", "Permitted" };
 515
 516   uint64_t Value = ParseInteger(Data, Offset);
 517   StringRef ValueDesc =
 518     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
 519   PrintAttribute(Tag, Value, ValueDesc);
 520 }
 521
 522 void ARMAttributeParser::DIV_use(AttrType Tag, const uint8_t *Data,
 523                                  uint32_t &Offset) {
 524   static const char *const Strings[] = {
 525     "If Available", "Not Permitted", "Permitted"
 526   };
 527
 528   uint64_t Value = ParseInteger(Data, Offset);
 529   StringRef ValueDesc =
 530     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
 531   PrintAttribute(Tag, Value, ValueDesc);
 532 }
 533
 534 void ARMAttributeParser::DSP_extension(AttrType Tag, const uint8_t *Data,
 535                                        uint32_t &Offset) {
 536   static const char *const Strings[] = { "Not Permitted", "Permitted" };
 537
 538   uint64_t Value = ParseInteger(Data, Offset);
 539   StringRef ValueDesc =
 540     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
 541   PrintAttribute(Tag, Value, ValueDesc);
 542 }
 543
 544 void ARMAttributeParser::T2EE_use(AttrType Tag, const uint8_t *Data,
 545                                   uint32_t &Offset) {
 546   static const char *const Strings[] = { "Not Permitted", "Permitted" };
 547
 548   uint64_t Value = ParseInteger(Data, Offset);
 549   StringRef ValueDesc =
 550     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
 551   PrintAttribute(Tag, Value, ValueDesc);
 552 }
 553
 554 void ARMAttributeParser::Virtualization_use(AttrType Tag, const uint8_t *Data,
 555                                             uint32_t &Offset) {
 556   static const char *const Strings[] = {
 557     "Not Permitted", "TrustZone", "Virtualization Extensions",
 558     "TrustZone + Virtualization Extensions"
 559   };
 560
 561   uint64_t Value = ParseInteger(Data, Offset);
 562   StringRef ValueDesc =
 563     (Value < array_lengthof(Strings)) ? Strings[Value] : nullptr;
 564   PrintAttribute(Tag, Value, ValueDesc);
 565 }
 566
 567 void ARMAttributeParser::nodefaults(AttrType Tag, const uint8_t *Data,
 568                                     uint32_t &Offset) {
 569   uint64_t Value = ParseInteger(Data, Offset);
 570   PrintAttribute(Tag, Value, "Unspecified Tags UNDEFINED");
 571 }
 572
 573 void ARMAttributeParser::ParseIndexList(const uint8_t *Data, uint32_t &Offset,
 574                                         SmallVectorImpl<uint8_t> &IndexList) {
 575   for (;;) {
 576     unsigned Length;
 577     uint64_t Value = decodeULEB128(Data + Offset, &Length);
 578     Offset = Offset + Length;
 579     if (Value == 0)
 580       break;
 581     IndexList.push_back(Value);
 582   }
 583 }
 584
 585 void ARMAttributeParser::ParseAttributeList(const uint8_t *Data,
 586                                             uint32_t &Offset, uint32_t Length) {
 587   while (Offset < Length) {
 588     unsigned Length;
 589     uint64_t Tag = decodeULEB128(Data + Offset, &Length);
 590     Offset += Length;
 591
 592     bool Handled = false;
 593     for (unsigned AHI = 0, AHE = array_lengthof(DisplayRoutines);
 594          AHI != AHE && !Handled; ++AHI) {
 595       if (uint64_t(DisplayRoutines[AHI].Attribute) == Tag) {
 596         (this->*DisplayRoutines[AHI].Routine)(ARMBuildAttrs::AttrType(Tag),
 597                                               Data, Offset);
 598         Handled = true;
 599         break;
 600       }
 601     }
 602     if (!Handled) {
 603       if (Tag < 32) {
 604         errs() << "unhandled AEABI Tag " << Tag
 605                << " (" << ARMBuildAttrs::AttrTypeAsString(Tag) << ")\n";
 606         continue;
 607       }
 608
 609       if (Tag % 2 == 0)
 610         IntegerAttribute(ARMBuildAttrs::AttrType(Tag), Data, Offset);
 611       else
 612         StringAttribute(ARMBuildAttrs::AttrType(Tag), Data, Offset);
 613     }
 614   }
 615 }
 616
 617 void ARMAttributeParser::ParseSubsection(const uint8_t *Data, uint32_t Length) {
 618   uint32_t Offset = sizeof(uint32_t); /* SectionLength */
 619
 620   const char *VendorName = reinterpret_cast<const char*>(Data + Offset);
 621   size_t VendorNameLength = std::strlen(VendorName);
 622   Offset = Offset + VendorNameLength + 1;
 623
 624   if (SW) {
 625     SW->printNumber("SectionLength", Length);
 626     SW->printString("Vendor", StringRef(VendorName, VendorNameLength));
 627   }
 628
 629   if (StringRef(VendorName, VendorNameLength).lower() != "aeabi") {
 630     return;
 631   }
 632
 633   while (Offset < Length) {
 634     /// Tag_File | Tag_Section | Tag_Symbol   uleb128:byte-size
 635     uint8_t Tag = Data[Offset];
 636     Offset = Offset + sizeof(Tag);
 637
 638     uint32_t Size =
 639       *reinterpret_cast<const support::ulittle32_t*>(Data + Offset);
 640     Offset = Offset + sizeof(Size);
 641
 642     if (SW) {
 643       SW->printEnum("Tag", Tag, makeArrayRef(TagNames));
 644       SW->printNumber("Size", Size);
 645     }
 646
 647     if (Size > Length) {
 648       errs() << "subsection length greater than section length\n";
 649       return;
 650     }
 651
 652     StringRef ScopeName, IndexName;
 653     SmallVector<uint8_t, 8> Indicies;
 654     switch (Tag) {
 655     case ARMBuildAttrs::File:
 656       ScopeName = "FileAttributes";
 657       break;
 658     case ARMBuildAttrs::Section:
 659       ScopeName = "SectionAttributes";
 660       IndexName = "Sections";
 661       ParseIndexList(Data, Offset, Indicies);
 662       break;
 663     case ARMBuildAttrs::Symbol:
 664       ScopeName = "SymbolAttributes";
 665       IndexName = "Symbols";
 666       ParseIndexList(Data, Offset, Indicies);
 667       break;
 668     default:
 669       errs() << "unrecognised tag: 0x" << Twine::utohexstr(Tag) << '\n';
 670       return;
 671     }
 672
 673     if (SW) {
 674       DictScope ASS(*SW, ScopeName);
 675       if (!Indicies.empty())
 676         SW->printList(IndexName, Indicies);
 677       ParseAttributeList(Data, Offset, Length);
 678     } else {
 679       ParseAttributeList(Data, Offset, Length);
 680     }
 681   }
 682 }
 683
 684 void ARMAttributeParser::Parse(ArrayRef<uint8_t> Section, bool isLittle) {
 685   size_t Offset = 1;
 686   unsigned SectionNumber = 0;
 687
 688   while (Offset < Section.size()) {
 689     uint32_t SectionLength = isLittle ?
 690       support::endian::read32le(Section.data() + Offset) :
 691       support::endian::read32be(Section.data() + Offset);
 692
 693     if (SW) {
 694       SW->startLine() << "Section " << ++SectionNumber << " {\n";
 695       SW->indent();
 696     }
 697
 698     ParseSubsection(Section.data() + Offset, SectionLength);
 699     Offset = Offset + SectionLength;
 700
 701     if (SW) {
 702       SW->unindent();
 703       SW->startLine() << "}\n";
 704     }
 705   }
 706 }
 707 }