1 //===-- llvm/BinaryFormat/Dwarf.cpp - Dwarf Framework ------------*- C++-*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // This file contains support for generic dwarf information. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #include "llvm/BinaryFormat/Dwarf.h" 14 #include "llvm/ADT/StringSwitch.h" 15 #include "llvm/ADT/Triple.h" 16 #include "llvm/Support/ErrorHandling.h" 17 18 using namespace llvm; 19 using namespace dwarf; 20 21 StringRef llvm::dwarf::TagString(unsigned Tag) { 22 switch (Tag) { 23 default: 24 return StringRef(); 25 #define HANDLE_DW_TAG(ID, NAME, VERSION, VENDOR) \ 26 case DW_TAG_##NAME: \ 27 return "DW_TAG_" #NAME; 28 #include "llvm/BinaryFormat/Dwarf.def" 29 } 30 } 31 32 unsigned llvm::dwarf::getTag(StringRef TagString) { 33 return StringSwitch<unsigned>(TagString) 34 #define HANDLE_DW_TAG(ID, NAME, VERSION, VENDOR) \ 35 .Case("DW_TAG_" #NAME, DW_TAG_##NAME) 36 #include "llvm/BinaryFormat/Dwarf.def" 37 .Default(DW_TAG_invalid); 38 } 39 40 unsigned llvm::dwarf::TagVersion(dwarf::Tag Tag) { 41 switch (Tag) { 42 default: 43 return 0; 44 #define HANDLE_DW_TAG(ID, NAME, VERSION, VENDOR) \ 45 case DW_TAG_##NAME: \ 46 return VERSION; 47 #include "llvm/BinaryFormat/Dwarf.def" 48 } 49 } 50 51 unsigned llvm::dwarf::TagVendor(dwarf::Tag Tag) { 52 switch (Tag) { 53 default: 54 return 0; 55 #define HANDLE_DW_TAG(ID, NAME, VERSION, VENDOR) \ 56 case DW_TAG_##NAME: \ 57 return DWARF_VENDOR_##VENDOR; 58 #include "llvm/BinaryFormat/Dwarf.def" 59 } 60 } 61 62 StringRef llvm::dwarf::ChildrenString(unsigned Children) { 63 switch (Children) { 64 case DW_CHILDREN_no: 65 return "DW_CHILDREN_no"; 66 case DW_CHILDREN_yes: 67 return "DW_CHILDREN_yes"; 68 } 69 return StringRef(); 70 } 71 72 StringRef llvm::dwarf::AttributeString(unsigned Attribute) { 73 switch (Attribute) { 74 default: 75 return StringRef(); 76 #define HANDLE_DW_AT(ID, NAME, VERSION, VENDOR) \ 77 case DW_AT_##NAME: \ 78 return "DW_AT_" #NAME; 79 #include "llvm/BinaryFormat/Dwarf.def" 80 } 81 } 82 83 unsigned llvm::dwarf::AttributeVersion(dwarf::Attribute Attribute) { 84 switch (Attribute) { 85 default: 86 return 0; 87 #define HANDLE_DW_AT(ID, NAME, VERSION, VENDOR) \ 88 case DW_AT_##NAME: \ 89 return VERSION; 90 #include "llvm/BinaryFormat/Dwarf.def" 91 } 92 } 93 94 unsigned llvm::dwarf::AttributeVendor(dwarf::Attribute Attribute) { 95 switch (Attribute) { 96 default: 97 return 0; 98 #define HANDLE_DW_AT(ID, NAME, VERSION, VENDOR) \ 99 case DW_AT_##NAME: \ 100 return DWARF_VENDOR_##VENDOR; 101 #include "llvm/BinaryFormat/Dwarf.def" 102 } 103 } 104 105 StringRef llvm::dwarf::FormEncodingString(unsigned Encoding) { 106 switch (Encoding) { 107 default: 108 return StringRef(); 109 #define HANDLE_DW_FORM(ID, NAME, VERSION, VENDOR) \ 110 case DW_FORM_##NAME: \ 111 return "DW_FORM_" #NAME; 112 #include "llvm/BinaryFormat/Dwarf.def" 113 } 114 } 115 116 unsigned llvm::dwarf::FormVersion(dwarf::Form Form) { 117 switch (Form) { 118 default: 119 return 0; 120 #define HANDLE_DW_FORM(ID, NAME, VERSION, VENDOR) \ 121 case DW_FORM_##NAME: \ 122 return VERSION; 123 #include "llvm/BinaryFormat/Dwarf.def" 124 } 125 } 126 127 unsigned llvm::dwarf::FormVendor(dwarf::Form Form) { 128 switch (Form) { 129 default: 130 return 0; 131 #define HANDLE_DW_FORM(ID, NAME, VERSION, VENDOR) \ 132 case DW_FORM_##NAME: \ 133 return DWARF_VENDOR_##VENDOR; 134 #include "llvm/BinaryFormat/Dwarf.def" 135 } 136 } 137 138 StringRef llvm::dwarf::OperationEncodingString(unsigned Encoding) { 139 switch (Encoding) { 140 default: 141 return StringRef(); 142 #define HANDLE_DW_OP(ID, NAME, VERSION, VENDOR) \ 143 case DW_OP_##NAME: \ 144 return "DW_OP_" #NAME; 145 #include "llvm/BinaryFormat/Dwarf.def" 146 case DW_OP_LLVM_fragment: 147 return "DW_OP_LLVM_fragment"; 148 } 149 } 150 151 unsigned llvm::dwarf::getOperationEncoding(StringRef OperationEncodingString) { 152 return StringSwitch<unsigned>(OperationEncodingString) 153 #define HANDLE_DW_OP(ID, NAME, VERSION, VENDOR) \ 154 .Case("DW_OP_" #NAME, DW_OP_##NAME) 155 #include "llvm/BinaryFormat/Dwarf.def" 156 .Case("DW_OP_LLVM_fragment", DW_OP_LLVM_fragment) 157 .Default(0); 158 } 159 160 unsigned llvm::dwarf::OperationVersion(dwarf::LocationAtom Op) { 161 switch (Op) { 162 default: 163 return 0; 164 #define HANDLE_DW_OP(ID, NAME, VERSION, VENDOR) \ 165 case DW_OP_##NAME: \ 166 return VERSION; 167 #include "llvm/BinaryFormat/Dwarf.def" 168 } 169 } 170 171 unsigned llvm::dwarf::OperationVendor(dwarf::LocationAtom Op) { 172 switch (Op) { 173 default: 174 return 0; 175 #define HANDLE_DW_OP(ID, NAME, VERSION, VENDOR) \ 176 case DW_OP_##NAME: \ 177 return DWARF_VENDOR_##VENDOR; 178 #include "llvm/BinaryFormat/Dwarf.def" 179 } 180 } 181 182 StringRef llvm::dwarf::AttributeEncodingString(unsigned Encoding) { 183 switch (Encoding) { 184 default: 185 return StringRef(); 186 #define HANDLE_DW_ATE(ID, NAME, VERSION, VENDOR) \ 187 case DW_ATE_##NAME: \ 188 return "DW_ATE_" #NAME; 189 #include "llvm/BinaryFormat/Dwarf.def" 190 } 191 } 192 193 unsigned llvm::dwarf::getAttributeEncoding(StringRef EncodingString) { 194 return StringSwitch<unsigned>(EncodingString) 195 #define HANDLE_DW_ATE(ID, NAME, VERSION, VENDOR) \ 196 .Case("DW_ATE_" #NAME, DW_ATE_##NAME) 197 #include "llvm/BinaryFormat/Dwarf.def" 198 .Default(0); 199 } 200 201 unsigned llvm::dwarf::AttributeEncodingVersion(dwarf::TypeKind ATE) { 202 switch (ATE) { 203 default: 204 return 0; 205 #define HANDLE_DW_ATE(ID, NAME, VERSION, VENDOR) \ 206 case DW_ATE_##NAME: \ 207 return VERSION; 208 #include "llvm/BinaryFormat/Dwarf.def" 209 } 210 } 211 212 unsigned llvm::dwarf::AttributeEncodingVendor(dwarf::TypeKind ATE) { 213 switch (ATE) { 214 default: 215 return 0; 216 #define HANDLE_DW_ATE(ID, NAME, VERSION, VENDOR) \ 217 case DW_ATE_##NAME: \ 218 return DWARF_VENDOR_##VENDOR; 219 #include "llvm/BinaryFormat/Dwarf.def" 220 } 221 } 222 223 StringRef llvm::dwarf::DecimalSignString(unsigned Sign) { 224 switch (Sign) { 225 case DW_DS_unsigned: 226 return "DW_DS_unsigned"; 227 case DW_DS_leading_overpunch: 228 return "DW_DS_leading_overpunch"; 229 case DW_DS_trailing_overpunch: 230 return "DW_DS_trailing_overpunch"; 231 case DW_DS_leading_separate: 232 return "DW_DS_leading_separate"; 233 case DW_DS_trailing_separate: 234 return "DW_DS_trailing_separate"; 235 } 236 return StringRef(); 237 } 238 239 StringRef llvm::dwarf::EndianityString(unsigned Endian) { 240 switch (Endian) { 241 case DW_END_default: 242 return "DW_END_default"; 243 case DW_END_big: 244 return "DW_END_big"; 245 case DW_END_little: 246 return "DW_END_little"; 247 case DW_END_lo_user: 248 return "DW_END_lo_user"; 249 case DW_END_hi_user: 250 return "DW_END_hi_user"; 251 } 252 return StringRef(); 253 } 254 255 StringRef llvm::dwarf::AccessibilityString(unsigned Access) { 256 switch (Access) { 257 // Accessibility codes 258 case DW_ACCESS_public: 259 return "DW_ACCESS_public"; 260 case DW_ACCESS_protected: 261 return "DW_ACCESS_protected"; 262 case DW_ACCESS_private: 263 return "DW_ACCESS_private"; 264 } 265 return StringRef(); 266 } 267 268 StringRef llvm::dwarf::VisibilityString(unsigned Visibility) { 269 switch (Visibility) { 270 case DW_VIS_local: 271 return "DW_VIS_local"; 272 case DW_VIS_exported: 273 return "DW_VIS_exported"; 274 case DW_VIS_qualified: 275 return "DW_VIS_qualified"; 276 } 277 return StringRef(); 278 } 279 280 StringRef llvm::dwarf::VirtualityString(unsigned Virtuality) { 281 switch (Virtuality) { 282 default: 283 return StringRef(); 284 #define HANDLE_DW_VIRTUALITY(ID, NAME) \ 285 case DW_VIRTUALITY_##NAME: \ 286 return "DW_VIRTUALITY_" #NAME; 287 #include "llvm/BinaryFormat/Dwarf.def" 288 } 289 } 290 291 unsigned llvm::dwarf::getVirtuality(StringRef VirtualityString) { 292 return StringSwitch<unsigned>(VirtualityString) 293 #define HANDLE_DW_VIRTUALITY(ID, NAME) \ 294 .Case("DW_VIRTUALITY_" #NAME, DW_VIRTUALITY_##NAME) 295 #include "llvm/BinaryFormat/Dwarf.def" 296 .Default(DW_VIRTUALITY_invalid); 297 } 298 299 StringRef llvm::dwarf::LanguageString(unsigned Language) { 300 switch (Language) { 301 default: 302 return StringRef(); 303 #define HANDLE_DW_LANG(ID, NAME, LOWER_BOUND, VERSION, VENDOR) \ 304 case DW_LANG_##NAME: \ 305 return "DW_LANG_" #NAME; 306 #include "llvm/BinaryFormat/Dwarf.def" 307 } 308 } 309 310 unsigned llvm::dwarf::getLanguage(StringRef LanguageString) { 311 return StringSwitch<unsigned>(LanguageString) 312 #define HANDLE_DW_LANG(ID, NAME, LOWER_BOUND, VERSION, VENDOR) \ 313 .Case("DW_LANG_" #NAME, DW_LANG_##NAME) 314 #include "llvm/BinaryFormat/Dwarf.def" 315 .Default(0); 316 } 317 318 unsigned llvm::dwarf::LanguageVersion(dwarf::SourceLanguage Lang) { 319 switch (Lang) { 320 default: 321 return 0; 322 #define HANDLE_DW_LANG(ID, NAME, LOWER_BOUND, VERSION, VENDOR) \ 323 case DW_LANG_##NAME: \ 324 return VERSION; 325 #include "llvm/BinaryFormat/Dwarf.def" 326 } 327 } 328 329 unsigned llvm::dwarf::LanguageVendor(dwarf::SourceLanguage Lang) { 330 switch (Lang) { 331 default: 332 return 0; 333 #define HANDLE_DW_LANG(ID, NAME, LOWER_BOUND, VERSION, VENDOR) \ 334 case DW_LANG_##NAME: \ 335 return DWARF_VENDOR_##VENDOR; 336 #include "llvm/BinaryFormat/Dwarf.def" 337 } 338 } 339 340 Optional<unsigned> llvm::dwarf::LanguageLowerBound(dwarf::SourceLanguage Lang) { 341 switch (Lang) { 342 default: 343 return None; 344 #define HANDLE_DW_LANG(ID, NAME, LOWER_BOUND, VERSION, VENDOR) \ 345 case DW_LANG_##NAME: \ 346 return LOWER_BOUND; 347 #include "llvm/BinaryFormat/Dwarf.def" 348 } 349 } 350 351 StringRef llvm::dwarf::CaseString(unsigned Case) { 352 switch (Case) { 353 case DW_ID_case_sensitive: 354 return "DW_ID_case_sensitive"; 355 case DW_ID_up_case: 356 return "DW_ID_up_case"; 357 case DW_ID_down_case: 358 return "DW_ID_down_case"; 359 case DW_ID_case_insensitive: 360 return "DW_ID_case_insensitive"; 361 } 362 return StringRef(); 363 } 364 365 StringRef llvm::dwarf::ConventionString(unsigned CC) { 366 switch (CC) { 367 default: 368 return StringRef(); 369 #define HANDLE_DW_CC(ID, NAME) \ 370 case DW_CC_##NAME: \ 371 return "DW_CC_" #NAME; 372 #include "llvm/BinaryFormat/Dwarf.def" 373 } 374 } 375 376 unsigned llvm::dwarf::getCallingConvention(StringRef CCString) { 377 return StringSwitch<unsigned>(CCString) 378 #define HANDLE_DW_CC(ID, NAME) .Case("DW_CC_" #NAME, DW_CC_##NAME) 379 #include "llvm/BinaryFormat/Dwarf.def" 380 .Default(0); 381 } 382 383 StringRef llvm::dwarf::InlineCodeString(unsigned Code) { 384 switch (Code) { 385 case DW_INL_not_inlined: 386 return "DW_INL_not_inlined"; 387 case DW_INL_inlined: 388 return "DW_INL_inlined"; 389 case DW_INL_declared_not_inlined: 390 return "DW_INL_declared_not_inlined"; 391 case DW_INL_declared_inlined: 392 return "DW_INL_declared_inlined"; 393 } 394 return StringRef(); 395 } 396 397 StringRef llvm::dwarf::ArrayOrderString(unsigned Order) { 398 switch (Order) { 399 case DW_ORD_row_major: 400 return "DW_ORD_row_major"; 401 case DW_ORD_col_major: 402 return "DW_ORD_col_major"; 403 } 404 return StringRef(); 405 } 406 407 StringRef llvm::dwarf::LNStandardString(unsigned Standard) { 408 switch (Standard) { 409 default: 410 return StringRef(); 411 #define HANDLE_DW_LNS(ID, NAME) \ 412 case DW_LNS_##NAME: \ 413 return "DW_LNS_" #NAME; 414 #include "llvm/BinaryFormat/Dwarf.def" 415 } 416 } 417 418 StringRef llvm::dwarf::LNExtendedString(unsigned Encoding) { 419 switch (Encoding) { 420 default: 421 return StringRef(); 422 #define HANDLE_DW_LNE(ID, NAME) \ 423 case DW_LNE_##NAME: \ 424 return "DW_LNE_" #NAME; 425 #include "llvm/BinaryFormat/Dwarf.def" 426 } 427 } 428 429 StringRef llvm::dwarf::MacinfoString(unsigned Encoding) { 430 switch (Encoding) { 431 // Macinfo Type Encodings 432 case DW_MACINFO_define: 433 return "DW_MACINFO_define"; 434 case DW_MACINFO_undef: 435 return "DW_MACINFO_undef"; 436 case DW_MACINFO_start_file: 437 return "DW_MACINFO_start_file"; 438 case DW_MACINFO_end_file: 439 return "DW_MACINFO_end_file"; 440 case DW_MACINFO_vendor_ext: 441 return "DW_MACINFO_vendor_ext"; 442 case DW_MACINFO_invalid: 443 return "DW_MACINFO_invalid"; 444 } 445 return StringRef(); 446 } 447 448 unsigned llvm::dwarf::getMacinfo(StringRef MacinfoString) { 449 return StringSwitch<unsigned>(MacinfoString) 450 .Case("DW_MACINFO_define", DW_MACINFO_define) 451 .Case("DW_MACINFO_undef", DW_MACINFO_undef) 452 .Case("DW_MACINFO_start_file", DW_MACINFO_start_file) 453 .Case("DW_MACINFO_end_file", DW_MACINFO_end_file) 454 .Case("DW_MACINFO_vendor_ext", DW_MACINFO_vendor_ext) 455 .Default(DW_MACINFO_invalid); 456 } 457 458 StringRef llvm::dwarf::RangeListEncodingString(unsigned Encoding) { 459 switch (Encoding) { 460 default: 461 return StringRef(); 462 #define HANDLE_DW_RLE(ID, NAME) \ 463 case DW_RLE_##NAME: \ 464 return "DW_RLE_" #NAME; 465 #include "llvm/BinaryFormat/Dwarf.def" 466 } 467 } 468 469 StringRef llvm::dwarf::CallFrameString(unsigned Encoding, 470 Triple::ArchType Arch) { 471 assert(Arch != llvm::Triple::ArchType::UnknownArch); 472 #define SELECT_AARCH64 (Arch == llvm::Triple::aarch64_be || Arch == llvm::Triple::aarch64) 473 #define SELECT_MIPS64 Arch == llvm::Triple::mips64 474 #define SELECT_SPARC (Arch == llvm::Triple::sparc || Arch == llvm::Triple::sparcv9) 475 #define SELECT_X86 (Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64) 476 #define HANDLE_DW_CFA(ID, NAME) 477 #define HANDLE_DW_CFA_PRED(ID, NAME, PRED) \ 478 if (ID == Encoding && PRED) \ 479 return "DW_CFA_" #NAME; 480 #include "llvm/BinaryFormat/Dwarf.def" 481 482 switch (Encoding) { 483 default: 484 return StringRef(); 485 #define HANDLE_DW_CFA_PRED(ID, NAME, PRED) 486 #define HANDLE_DW_CFA(ID, NAME) \ 487 case DW_CFA_##NAME: \ 488 return "DW_CFA_" #NAME; 489 #include "llvm/BinaryFormat/Dwarf.def" 490 491 #undef SELECT_X86 492 #undef SELECT_SPARC 493 #undef SELECT_MIPS64 494 #undef SELECT_AARCH64 495 } 496 } 497 498 StringRef llvm::dwarf::ApplePropertyString(unsigned Prop) { 499 switch (Prop) { 500 default: 501 return StringRef(); 502 #define HANDLE_DW_APPLE_PROPERTY(ID, NAME) \ 503 case DW_APPLE_PROPERTY_##NAME: \ 504 return "DW_APPLE_PROPERTY_" #NAME; 505 #include "llvm/BinaryFormat/Dwarf.def" 506 } 507 } 508 509 StringRef llvm::dwarf::UnitTypeString(unsigned UT) { 510 switch (UT) { 511 default: 512 return StringRef(); 513 #define HANDLE_DW_UT(ID, NAME) \ 514 case DW_UT_##NAME: \ 515 return "DW_UT_" #NAME; 516 #include "llvm/BinaryFormat/Dwarf.def" 517 } 518 } 519 520 StringRef llvm::dwarf::AtomTypeString(unsigned AT) { 521 switch (AT) { 522 case dwarf::DW_ATOM_null: 523 return "DW_ATOM_null"; 524 case dwarf::DW_ATOM_die_offset: 525 return "DW_ATOM_die_offset"; 526 case DW_ATOM_cu_offset: 527 return "DW_ATOM_cu_offset"; 528 case DW_ATOM_die_tag: 529 return "DW_ATOM_die_tag"; 530 case DW_ATOM_type_flags: 531 case DW_ATOM_type_type_flags: 532 return "DW_ATOM_type_flags"; 533 case DW_ATOM_qual_name_hash: 534 return "DW_ATOM_qual_name_hash"; 535 } 536 return StringRef(); 537 } 538 539 StringRef llvm::dwarf::GDBIndexEntryKindString(GDBIndexEntryKind Kind) { 540 switch (Kind) { 541 case GIEK_NONE: 542 return "NONE"; 543 case GIEK_TYPE: 544 return "TYPE"; 545 case GIEK_VARIABLE: 546 return "VARIABLE"; 547 case GIEK_FUNCTION: 548 return "FUNCTION"; 549 case GIEK_OTHER: 550 return "OTHER"; 551 case GIEK_UNUSED5: 552 return "UNUSED5"; 553 case GIEK_UNUSED6: 554 return "UNUSED6"; 555 case GIEK_UNUSED7: 556 return "UNUSED7"; 557 } 558 llvm_unreachable("Unknown GDBIndexEntryKind value"); 559 } 560 561 StringRef 562 llvm::dwarf::GDBIndexEntryLinkageString(GDBIndexEntryLinkage Linkage) { 563 switch (Linkage) { 564 case GIEL_EXTERNAL: 565 return "EXTERNAL"; 566 case GIEL_STATIC: 567 return "STATIC"; 568 } 569 llvm_unreachable("Unknown GDBIndexEntryLinkage value"); 570 } 571 572 StringRef llvm::dwarf::AttributeValueString(uint16_t Attr, unsigned Val) { 573 switch (Attr) { 574 case DW_AT_accessibility: 575 return AccessibilityString(Val); 576 case DW_AT_virtuality: 577 return VirtualityString(Val); 578 case DW_AT_language: 579 return LanguageString(Val); 580 case DW_AT_encoding: 581 return AttributeEncodingString(Val); 582 case DW_AT_decimal_sign: 583 return DecimalSignString(Val); 584 case DW_AT_endianity: 585 return EndianityString(Val); 586 case DW_AT_visibility: 587 return VisibilityString(Val); 588 case DW_AT_identifier_case: 589 return CaseString(Val); 590 case DW_AT_calling_convention: 591 return ConventionString(Val); 592 case DW_AT_inline: 593 return InlineCodeString(Val); 594 case DW_AT_ordering: 595 return ArrayOrderString(Val); 596 case DW_AT_APPLE_runtime_class: 597 return LanguageString(Val); 598 } 599 600 return StringRef(); 601 } 602 603 StringRef llvm::dwarf::AtomValueString(uint16_t Atom, unsigned Val) { 604 switch (Atom) { 605 case DW_ATOM_null: 606 return "NULL"; 607 case DW_ATOM_die_tag: 608 return TagString(Val); 609 } 610 611 return StringRef(); 612 } 613 614 StringRef llvm::dwarf::IndexString(unsigned Idx) { 615 switch (Idx) { 616 default: 617 return StringRef(); 618 #define HANDLE_DW_IDX(ID, NAME) \ 619 case DW_IDX_##NAME: \ 620 return "DW_IDX_" #NAME; 621 #include "llvm/BinaryFormat/Dwarf.def" 622 } 623 } 624 625 Optional<uint8_t> llvm::dwarf::getFixedFormByteSize(dwarf::Form Form, 626 FormParams Params) { 627 switch (Form) { 628 case DW_FORM_addr: 629 if (Params) 630 return Params.AddrSize; 631 return None; 632 633 case DW_FORM_block: // ULEB128 length L followed by L bytes. 634 case DW_FORM_block1: // 1 byte length L followed by L bytes. 635 case DW_FORM_block2: // 2 byte length L followed by L bytes. 636 case DW_FORM_block4: // 4 byte length L followed by L bytes. 637 case DW_FORM_string: // C-string with null terminator. 638 case DW_FORM_sdata: // SLEB128. 639 case DW_FORM_udata: // ULEB128. 640 case DW_FORM_ref_udata: // ULEB128. 641 case DW_FORM_indirect: // ULEB128. 642 case DW_FORM_exprloc: // ULEB128 length L followed by L bytes. 643 case DW_FORM_strx: // ULEB128. 644 case DW_FORM_addrx: // ULEB128. 645 case DW_FORM_loclistx: // ULEB128. 646 case DW_FORM_rnglistx: // ULEB128. 647 case DW_FORM_GNU_addr_index: // ULEB128. 648 case DW_FORM_GNU_str_index: // ULEB128. 649 return None; 650 651 case DW_FORM_ref_addr: 652 if (Params) 653 return Params.getRefAddrByteSize(); 654 return None; 655 656 case DW_FORM_flag: 657 case DW_FORM_data1: 658 case DW_FORM_ref1: 659 case DW_FORM_strx1: 660 case DW_FORM_addrx1: 661 return 1; 662 663 case DW_FORM_data2: 664 case DW_FORM_ref2: 665 case DW_FORM_strx2: 666 case DW_FORM_addrx2: 667 return 2; 668 669 case DW_FORM_strx3: 670 return 3; 671 672 case DW_FORM_data4: 673 case DW_FORM_ref4: 674 case DW_FORM_ref_sup4: 675 case DW_FORM_strx4: 676 case DW_FORM_addrx4: 677 return 4; 678 679 case DW_FORM_strp: 680 case DW_FORM_GNU_ref_alt: 681 case DW_FORM_GNU_strp_alt: 682 case DW_FORM_line_strp: 683 case DW_FORM_sec_offset: 684 case DW_FORM_strp_sup: 685 if (Params) 686 return Params.getDwarfOffsetByteSize(); 687 return None; 688 689 case DW_FORM_data8: 690 case DW_FORM_ref8: 691 case DW_FORM_ref_sig8: 692 case DW_FORM_ref_sup8: 693 return 8; 694 695 case DW_FORM_flag_present: 696 return 0; 697 698 case DW_FORM_data16: 699 return 16; 700 701 case DW_FORM_implicit_const: 702 // The implicit value is stored in the abbreviation as a SLEB128, and 703 // there no data in debug info. 704 return 0; 705 706 default: 707 break; 708 } 709 return None; 710 } 711 712 bool llvm::dwarf::isValidFormForVersion(Form F, unsigned Version, 713 bool ExtensionsOk) { 714 if (FormVendor(F) == DWARF_VENDOR_DWARF) { 715 unsigned FV = FormVersion(F); 716 return FV > 0 && FV <= Version; 717 } 718 return ExtensionsOk; 719 } 720 721 constexpr char llvm::dwarf::EnumTraits<Attribute>::Type[]; 722 constexpr char llvm::dwarf::EnumTraits<Form>::Type[]; 723 constexpr char llvm::dwarf::EnumTraits<Index>::Type[]; 724 constexpr char llvm::dwarf::EnumTraits<Tag>::Type[]; 725