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 672
