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, KIND) \ 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, KIND) \ 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, KIND) \ 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, KIND) \ 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_convert: 147 return "DW_OP_LLVM_convert"; 148 case DW_OP_LLVM_fragment: 149 return "DW_OP_LLVM_fragment"; 150 case DW_OP_LLVM_tag_offset: 151 return "DW_OP_LLVM_tag_offset"; 152 case DW_OP_LLVM_entry_value: 153 return "DW_OP_LLVM_entry_value"; 154 case DW_OP_LLVM_implicit_pointer: 155 return "DW_OP_LLVM_implicit_pointer"; 156 case DW_OP_LLVM_arg: 157 return "DW_OP_LLVM_arg"; 158 } 159 } 160 161 unsigned llvm::dwarf::getOperationEncoding(StringRef OperationEncodingString) { 162 return StringSwitch<unsigned>(OperationEncodingString) 163 #define HANDLE_DW_OP(ID, NAME, VERSION, VENDOR) \ 164 .Case("DW_OP_" #NAME, DW_OP_##NAME) 165 #include "llvm/BinaryFormat/Dwarf.def" 166 .Case("DW_OP_LLVM_convert", DW_OP_LLVM_convert) 167 .Case("DW_OP_LLVM_fragment", DW_OP_LLVM_fragment) 168 .Case("DW_OP_LLVM_tag_offset", DW_OP_LLVM_tag_offset) 169 .Case("DW_OP_LLVM_entry_value", DW_OP_LLVM_entry_value) 170 .Case("DW_OP_LLVM_implicit_pointer", DW_OP_LLVM_implicit_pointer) 171 .Case("DW_OP_LLVM_arg", DW_OP_LLVM_arg) 172 .Default(0); 173 } 174 175 unsigned llvm::dwarf::OperationVersion(dwarf::LocationAtom Op) { 176 switch (Op) { 177 default: 178 return 0; 179 #define HANDLE_DW_OP(ID, NAME, VERSION, VENDOR) \ 180 case DW_OP_##NAME: \ 181 return VERSION; 182 #include "llvm/BinaryFormat/Dwarf.def" 183 } 184 } 185 186 unsigned llvm::dwarf::OperationVendor(dwarf::LocationAtom Op) { 187 switch (Op) { 188 default: 189 return 0; 190 #define HANDLE_DW_OP(ID, NAME, VERSION, VENDOR) \ 191 case DW_OP_##NAME: \ 192 return DWARF_VENDOR_##VENDOR; 193 #include "llvm/BinaryFormat/Dwarf.def" 194 } 195 } 196 197 StringRef llvm::dwarf::AttributeEncodingString(unsigned Encoding) { 198 switch (Encoding) { 199 default: 200 return StringRef(); 201 #define HANDLE_DW_ATE(ID, NAME, VERSION, VENDOR) \ 202 case DW_ATE_##NAME: \ 203 return "DW_ATE_" #NAME; 204 #include "llvm/BinaryFormat/Dwarf.def" 205 } 206 } 207 208 unsigned llvm::dwarf::getAttributeEncoding(StringRef EncodingString) { 209 return StringSwitch<unsigned>(EncodingString) 210 #define HANDLE_DW_ATE(ID, NAME, VERSION, VENDOR) \ 211 .Case("DW_ATE_" #NAME, DW_ATE_##NAME) 212 #include "llvm/BinaryFormat/Dwarf.def" 213 .Default(0); 214 } 215 216 unsigned llvm::dwarf::AttributeEncodingVersion(dwarf::TypeKind ATE) { 217 switch (ATE) { 218 default: 219 return 0; 220 #define HANDLE_DW_ATE(ID, NAME, VERSION, VENDOR) \ 221 case DW_ATE_##NAME: \ 222 return VERSION; 223 #include "llvm/BinaryFormat/Dwarf.def" 224 } 225 } 226 227 unsigned llvm::dwarf::AttributeEncodingVendor(dwarf::TypeKind ATE) { 228 switch (ATE) { 229 default: 230 return 0; 231 #define HANDLE_DW_ATE(ID, NAME, VERSION, VENDOR) \ 232 case DW_ATE_##NAME: \ 233 return DWARF_VENDOR_##VENDOR; 234 #include "llvm/BinaryFormat/Dwarf.def" 235 } 236 } 237 238 StringRef llvm::dwarf::DecimalSignString(unsigned Sign) { 239 switch (Sign) { 240 case DW_DS_unsigned: 241 return "DW_DS_unsigned"; 242 case DW_DS_leading_overpunch: 243 return "DW_DS_leading_overpunch"; 244 case DW_DS_trailing_overpunch: 245 return "DW_DS_trailing_overpunch"; 246 case DW_DS_leading_separate: 247 return "DW_DS_leading_separate"; 248 case DW_DS_trailing_separate: 249 return "DW_DS_trailing_separate"; 250 } 251 return StringRef(); 252 } 253 254 StringRef llvm::dwarf::EndianityString(unsigned Endian) { 255 switch (Endian) { 256 case DW_END_default: 257 return "DW_END_default"; 258 case DW_END_big: 259 return "DW_END_big"; 260 case DW_END_little: 261 return "DW_END_little"; 262 case DW_END_lo_user: 263 return "DW_END_lo_user"; 264 case DW_END_hi_user: 265 return "DW_END_hi_user"; 266 } 267 return StringRef(); 268 } 269 270 StringRef llvm::dwarf::AccessibilityString(unsigned Access) { 271 switch (Access) { 272 // Accessibility codes 273 case DW_ACCESS_public: 274 return "DW_ACCESS_public"; 275 case DW_ACCESS_protected: 276 return "DW_ACCESS_protected"; 277 case DW_ACCESS_private: 278 return "DW_ACCESS_private"; 279 } 280 return StringRef(); 281 } 282 283 StringRef llvm::dwarf::DefaultedMemberString(unsigned DefaultedEncodings) { 284 switch (DefaultedEncodings) { 285 // Defaulted Member Encodings codes 286 case DW_DEFAULTED_no: 287 return "DW_DEFAULTED_no"; 288 case DW_DEFAULTED_in_class: 289 return "DW_DEFAULTED_in_class"; 290 case DW_DEFAULTED_out_of_class: 291 return "DW_DEFAULTED_out_of_class"; 292 } 293 return StringRef(); 294 } 295 296 StringRef llvm::dwarf::VisibilityString(unsigned Visibility) { 297 switch (Visibility) { 298 case DW_VIS_local: 299 return "DW_VIS_local"; 300 case DW_VIS_exported: 301 return "DW_VIS_exported"; 302 case DW_VIS_qualified: 303 return "DW_VIS_qualified"; 304 } 305 return StringRef(); 306 } 307 308 StringRef llvm::dwarf::VirtualityString(unsigned Virtuality) { 309 switch (Virtuality) { 310 default: 311 return StringRef(); 312 #define HANDLE_DW_VIRTUALITY(ID, NAME) \ 313 case DW_VIRTUALITY_##NAME: \ 314 return "DW_VIRTUALITY_" #NAME; 315 #include "llvm/BinaryFormat/Dwarf.def" 316 } 317 } 318 319 unsigned llvm::dwarf::getVirtuality(StringRef VirtualityString) { 320 return StringSwitch<unsigned>(VirtualityString) 321 #define HANDLE_DW_VIRTUALITY(ID, NAME) \ 322 .Case("DW_VIRTUALITY_" #NAME, DW_VIRTUALITY_##NAME) 323 #include "llvm/BinaryFormat/Dwarf.def" 324 .Default(DW_VIRTUALITY_invalid); 325 } 326 327 StringRef llvm::dwarf::LanguageString(unsigned Language) { 328 switch (Language) { 329 default: 330 return StringRef(); 331 #define HANDLE_DW_LANG(ID, NAME, LOWER_BOUND, VERSION, VENDOR) \ 332 case DW_LANG_##NAME: \ 333 return "DW_LANG_" #NAME; 334 #include "llvm/BinaryFormat/Dwarf.def" 335 } 336 } 337 338 unsigned llvm::dwarf::getLanguage(StringRef LanguageString) { 339 return StringSwitch<unsigned>(LanguageString) 340 #define HANDLE_DW_LANG(ID, NAME, LOWER_BOUND, VERSION, VENDOR) \ 341 .Case("DW_LANG_" #NAME, DW_LANG_##NAME) 342 #include "llvm/BinaryFormat/Dwarf.def" 343 .Default(0); 344 } 345 346 unsigned llvm::dwarf::LanguageVersion(dwarf::SourceLanguage Lang) { 347 switch (Lang) { 348 default: 349 return 0; 350 #define HANDLE_DW_LANG(ID, NAME, LOWER_BOUND, VERSION, VENDOR) \ 351 case DW_LANG_##NAME: \ 352 return VERSION; 353 #include "llvm/BinaryFormat/Dwarf.def" 354 } 355 } 356 357 unsigned llvm::dwarf::LanguageVendor(dwarf::SourceLanguage Lang) { 358 switch (Lang) { 359 default: 360 return 0; 361 #define HANDLE_DW_LANG(ID, NAME, LOWER_BOUND, VERSION, VENDOR) \ 362 case DW_LANG_##NAME: \ 363 return DWARF_VENDOR_##VENDOR; 364 #include "llvm/BinaryFormat/Dwarf.def" 365 } 366 } 367 368 std::optional<unsigned> 369 llvm::dwarf::LanguageLowerBound(dwarf::SourceLanguage Lang) { 370 switch (Lang) { 371 default: 372 return std::nullopt; 373 #define HANDLE_DW_LANG(ID, NAME, LOWER_BOUND, VERSION, VENDOR) \ 374 case DW_LANG_##NAME: \ 375 return LOWER_BOUND; 376 #include "llvm/BinaryFormat/Dwarf.def" 377 } 378 } 379 380 StringRef llvm::dwarf::CaseString(unsigned Case) { 381 switch (Case) { 382 case DW_ID_case_sensitive: 383 return "DW_ID_case_sensitive"; 384 case DW_ID_up_case: 385 return "DW_ID_up_case"; 386 case DW_ID_down_case: 387 return "DW_ID_down_case"; 388 case DW_ID_case_insensitive: 389 return "DW_ID_case_insensitive"; 390 } 391 return StringRef(); 392 } 393 394 StringRef llvm::dwarf::ConventionString(unsigned CC) { 395 switch (CC) { 396 default: 397 return StringRef(); 398 #define HANDLE_DW_CC(ID, NAME) \ 399 case DW_CC_##NAME: \ 400 return "DW_CC_" #NAME; 401 #include "llvm/BinaryFormat/Dwarf.def" 402 } 403 } 404 405 unsigned llvm::dwarf::getCallingConvention(StringRef CCString) { 406 return StringSwitch<unsigned>(CCString) 407 #define HANDLE_DW_CC(ID, NAME) .Case("DW_CC_" #NAME, DW_CC_##NAME) 408 #include "llvm/BinaryFormat/Dwarf.def" 409 .Default(0); 410 } 411 412 StringRef llvm::dwarf::InlineCodeString(unsigned Code) { 413 switch (Code) { 414 case DW_INL_not_inlined: 415 return "DW_INL_not_inlined"; 416 case DW_INL_inlined: 417 return "DW_INL_inlined"; 418 case DW_INL_declared_not_inlined: 419 return "DW_INL_declared_not_inlined"; 420 case DW_INL_declared_inlined: 421 return "DW_INL_declared_inlined"; 422 } 423 return StringRef(); 424 } 425 426 StringRef llvm::dwarf::ArrayOrderString(unsigned Order) { 427 switch (Order) { 428 case DW_ORD_row_major: 429 return "DW_ORD_row_major"; 430 case DW_ORD_col_major: 431 return "DW_ORD_col_major"; 432 } 433 return StringRef(); 434 } 435 436 StringRef llvm::dwarf::LNStandardString(unsigned Standard) { 437 switch (Standard) { 438 default: 439 return StringRef(); 440 #define HANDLE_DW_LNS(ID, NAME) \ 441 case DW_LNS_##NAME: \ 442 return "DW_LNS_" #NAME; 443 #include "llvm/BinaryFormat/Dwarf.def" 444 } 445 } 446 447 StringRef llvm::dwarf::LNExtendedString(unsigned Encoding) { 448 switch (Encoding) { 449 default: 450 return StringRef(); 451 #define HANDLE_DW_LNE(ID, NAME) \ 452 case DW_LNE_##NAME: \ 453 return "DW_LNE_" #NAME; 454 #include "llvm/BinaryFormat/Dwarf.def" 455 } 456 } 457 458 StringRef llvm::dwarf::MacinfoString(unsigned Encoding) { 459 switch (Encoding) { 460 // Macinfo Type Encodings 461 case DW_MACINFO_define: 462 return "DW_MACINFO_define"; 463 case DW_MACINFO_undef: 464 return "DW_MACINFO_undef"; 465 case DW_MACINFO_start_file: 466 return "DW_MACINFO_start_file"; 467 case DW_MACINFO_end_file: 468 return "DW_MACINFO_end_file"; 469 case DW_MACINFO_vendor_ext: 470 return "DW_MACINFO_vendor_ext"; 471 case DW_MACINFO_invalid: 472 return "DW_MACINFO_invalid"; 473 } 474 return StringRef(); 475 } 476 477 unsigned llvm::dwarf::getMacinfo(StringRef MacinfoString) { 478 return StringSwitch<unsigned>(MacinfoString) 479 .Case("DW_MACINFO_define", DW_MACINFO_define) 480 .Case("DW_MACINFO_undef", DW_MACINFO_undef) 481 .Case("DW_MACINFO_start_file", DW_MACINFO_start_file) 482 .Case("DW_MACINFO_end_file", DW_MACINFO_end_file) 483 .Case("DW_MACINFO_vendor_ext", DW_MACINFO_vendor_ext) 484 .Default(DW_MACINFO_invalid); 485 } 486 487 StringRef llvm::dwarf::MacroString(unsigned Encoding) { 488 switch (Encoding) { 489 default: 490 return StringRef(); 491 #define HANDLE_DW_MACRO(ID, NAME) \ 492 case DW_MACRO_##NAME: \ 493 return "DW_MACRO_" #NAME; 494 #include "llvm/BinaryFormat/Dwarf.def" 495 } 496 } 497 498 StringRef llvm::dwarf::GnuMacroString(unsigned Encoding) { 499 switch (Encoding) { 500 default: 501 return StringRef(); 502 #define HANDLE_DW_MACRO_GNU(ID, NAME) \ 503 case DW_MACRO_GNU_##NAME: \ 504 return "DW_MACRO_GNU_" #NAME; 505 #include "llvm/BinaryFormat/Dwarf.def" 506 } 507 } 508 509 unsigned llvm::dwarf::getMacro(StringRef MacroString) { 510 return StringSwitch<unsigned>(MacroString) 511 #define HANDLE_DW_MACRO(ID, NAME) .Case("DW_MACRO_" #NAME, ID) 512 #include "llvm/BinaryFormat/Dwarf.def" 513 .Default(DW_MACINFO_invalid); 514 } 515 StringRef llvm::dwarf::RangeListEncodingString(unsigned Encoding) { 516 switch (Encoding) { 517 default: 518 return StringRef(); 519 #define HANDLE_DW_RLE(ID, NAME) \ 520 case DW_RLE_##NAME: \ 521 return "DW_RLE_" #NAME; 522 #include "llvm/BinaryFormat/Dwarf.def" 523 } 524 } 525 526 StringRef llvm::dwarf::LocListEncodingString(unsigned Encoding) { 527 switch (Encoding) { 528 default: 529 return StringRef(); 530 #define HANDLE_DW_LLE(ID, NAME) \ 531 case DW_LLE_##NAME: \ 532 return "DW_LLE_" #NAME; 533 #include "llvm/BinaryFormat/Dwarf.def" 534 } 535 } 536 537 StringRef llvm::dwarf::CallFrameString(unsigned Encoding, 538 Triple::ArchType Arch) { 539 assert(Arch != llvm::Triple::ArchType::UnknownArch); 540 #define SELECT_AARCH64 (Arch == llvm::Triple::aarch64_be || Arch == llvm::Triple::aarch64) 541 #define SELECT_MIPS64 Arch == llvm::Triple::mips64 542 #define SELECT_SPARC (Arch == llvm::Triple::sparc || Arch == llvm::Triple::sparcv9) 543 #define SELECT_X86 (Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64) 544 #define HANDLE_DW_CFA(ID, NAME) 545 #define HANDLE_DW_CFA_PRED(ID, NAME, PRED) \ 546 if (ID == Encoding && PRED) \ 547 return "DW_CFA_" #NAME; 548 #include "llvm/BinaryFormat/Dwarf.def" 549 550 switch (Encoding) { 551 default: 552 return StringRef(); 553 #define HANDLE_DW_CFA_PRED(ID, NAME, PRED) 554 #define HANDLE_DW_CFA(ID, NAME) \ 555 case DW_CFA_##NAME: \ 556 return "DW_CFA_" #NAME; 557 #include "llvm/BinaryFormat/Dwarf.def" 558 559 #undef SELECT_X86 560 #undef SELECT_SPARC 561 #undef SELECT_MIPS64 562 #undef SELECT_AARCH64 563 } 564 } 565 566 StringRef llvm::dwarf::ApplePropertyString(unsigned Prop) { 567 switch (Prop) { 568 default: 569 return StringRef(); 570 #define HANDLE_DW_APPLE_PROPERTY(ID, NAME) \ 571 case DW_APPLE_PROPERTY_##NAME: \ 572 return "DW_APPLE_PROPERTY_" #NAME; 573 #include "llvm/BinaryFormat/Dwarf.def" 574 } 575 } 576 577 StringRef llvm::dwarf::UnitTypeString(unsigned UT) { 578 switch (UT) { 579 default: 580 return StringRef(); 581 #define HANDLE_DW_UT(ID, NAME) \ 582 case DW_UT_##NAME: \ 583 return "DW_UT_" #NAME; 584 #include "llvm/BinaryFormat/Dwarf.def" 585 } 586 } 587 588 StringRef llvm::dwarf::AtomTypeString(unsigned AT) { 589 switch (AT) { 590 case dwarf::DW_ATOM_null: 591 return "DW_ATOM_null"; 592 case dwarf::DW_ATOM_die_offset: 593 return "DW_ATOM_die_offset"; 594 case DW_ATOM_cu_offset: 595 return "DW_ATOM_cu_offset"; 596 case DW_ATOM_die_tag: 597 return "DW_ATOM_die_tag"; 598 case DW_ATOM_type_flags: 599 case DW_ATOM_type_type_flags: 600 return "DW_ATOM_type_flags"; 601 case DW_ATOM_qual_name_hash: 602 return "DW_ATOM_qual_name_hash"; 603 } 604 return StringRef(); 605 } 606 607 StringRef llvm::dwarf::GDBIndexEntryKindString(GDBIndexEntryKind Kind) { 608 switch (Kind) { 609 case GIEK_NONE: 610 return "NONE"; 611 case GIEK_TYPE: 612 return "TYPE"; 613 case GIEK_VARIABLE: 614 return "VARIABLE"; 615 case GIEK_FUNCTION: 616 return "FUNCTION"; 617 case GIEK_OTHER: 618 return "OTHER"; 619 case GIEK_UNUSED5: 620 return "UNUSED5"; 621 case GIEK_UNUSED6: 622 return "UNUSED6"; 623 case GIEK_UNUSED7: 624 return "UNUSED7"; 625 } 626 llvm_unreachable("Unknown GDBIndexEntryKind value"); 627 } 628 629 StringRef 630 llvm::dwarf::GDBIndexEntryLinkageString(GDBIndexEntryLinkage Linkage) { 631 switch (Linkage) { 632 case GIEL_EXTERNAL: 633 return "EXTERNAL"; 634 case GIEL_STATIC: 635 return "STATIC"; 636 } 637 llvm_unreachable("Unknown GDBIndexEntryLinkage value"); 638 } 639 640 StringRef llvm::dwarf::AttributeValueString(uint16_t Attr, unsigned Val) { 641 switch (Attr) { 642 case DW_AT_accessibility: 643 return AccessibilityString(Val); 644 case DW_AT_virtuality: 645 return VirtualityString(Val); 646 case DW_AT_language: 647 return LanguageString(Val); 648 case DW_AT_encoding: 649 return AttributeEncodingString(Val); 650 case DW_AT_decimal_sign: 651 return DecimalSignString(Val); 652 case DW_AT_endianity: 653 return EndianityString(Val); 654 case DW_AT_visibility: 655 return VisibilityString(Val); 656 case DW_AT_identifier_case: 657 return CaseString(Val); 658 case DW_AT_calling_convention: 659 return ConventionString(Val); 660 case DW_AT_inline: 661 return InlineCodeString(Val); 662 case DW_AT_ordering: 663 return ArrayOrderString(Val); 664 case DW_AT_APPLE_runtime_class: 665 return LanguageString(Val); 666 case DW_AT_defaulted: 667 return DefaultedMemberString(Val); 668 } 669 670 return StringRef(); 671 } 672 673 StringRef llvm::dwarf::AtomValueString(uint16_t Atom, unsigned Val) { 674 switch (Atom) { 675 case DW_ATOM_null: 676 return "NULL"; 677 case DW_ATOM_die_tag: 678 return TagString(Val); 679 } 680 681 return StringRef(); 682 } 683 684 StringRef llvm::dwarf::IndexString(unsigned Idx) { 685 switch (Idx) { 686 default: 687 return StringRef(); 688 #define HANDLE_DW_IDX(ID, NAME) \ 689 case DW_IDX_##NAME: \ 690 return "DW_IDX_" #NAME; 691 #include "llvm/BinaryFormat/Dwarf.def" 692 } 693 } 694 695 std::optional<uint8_t> llvm::dwarf::getFixedFormByteSize(dwarf::Form Form, 696 FormParams Params) { 697 switch (Form) { 698 case DW_FORM_addr: 699 if (Params) 700 return Params.AddrSize; 701 return std::nullopt; 702 703 case DW_FORM_block: // ULEB128 length L followed by L bytes. 704 case DW_FORM_block1: // 1 byte length L followed by L bytes. 705 case DW_FORM_block2: // 2 byte length L followed by L bytes. 706 case DW_FORM_block4: // 4 byte length L followed by L bytes. 707 case DW_FORM_string: // C-string with null terminator. 708 case DW_FORM_sdata: // SLEB128. 709 case DW_FORM_udata: // ULEB128. 710 case DW_FORM_ref_udata: // ULEB128. 711 case DW_FORM_indirect: // ULEB128. 712 case DW_FORM_exprloc: // ULEB128 length L followed by L bytes. 713 case DW_FORM_strx: // ULEB128. 714 case DW_FORM_addrx: // ULEB128. 715 case DW_FORM_loclistx: // ULEB128. 716 case DW_FORM_rnglistx: // ULEB128. 717 case DW_FORM_GNU_addr_index: // ULEB128. 718 case DW_FORM_GNU_str_index: // ULEB128. 719 return std::nullopt; 720 721 case DW_FORM_ref_addr: 722 if (Params) 723 return Params.getRefAddrByteSize(); 724 return std::nullopt; 725 726 case DW_FORM_flag: 727 case DW_FORM_data1: 728 case DW_FORM_ref1: 729 case DW_FORM_strx1: 730 case DW_FORM_addrx1: 731 return 1; 732 733 case DW_FORM_data2: 734 case DW_FORM_ref2: 735 case DW_FORM_strx2: 736 case DW_FORM_addrx2: 737 return 2; 738 739 case DW_FORM_strx3: 740 return 3; 741 742 case DW_FORM_data4: 743 case DW_FORM_ref4: 744 case DW_FORM_ref_sup4: 745 case DW_FORM_strx4: 746 case DW_FORM_addrx4: 747 return 4; 748 749 case DW_FORM_strp: 750 case DW_FORM_GNU_ref_alt: 751 case DW_FORM_GNU_strp_alt: 752 case DW_FORM_line_strp: 753 case DW_FORM_sec_offset: 754 case DW_FORM_strp_sup: 755 if (Params) 756 return Params.getDwarfOffsetByteSize(); 757 return std::nullopt; 758 759 case DW_FORM_data8: 760 case DW_FORM_ref8: 761 case DW_FORM_ref_sig8: 762 case DW_FORM_ref_sup8: 763 return 8; 764 765 case DW_FORM_flag_present: 766 return 0; 767 768 case DW_FORM_data16: 769 return 16; 770 771 case DW_FORM_implicit_const: 772 // The implicit value is stored in the abbreviation as a SLEB128, and 773 // there no data in debug info. 774 return 0; 775 776 default: 777 break; 778 } 779 return std::nullopt; 780 } 781 782 bool llvm::dwarf::isValidFormForVersion(Form F, unsigned Version, 783 bool ExtensionsOk) { 784 if (FormVendor(F) == DWARF_VENDOR_DWARF) { 785 unsigned FV = FormVersion(F); 786 return FV > 0 && FV <= Version; 787 } 788 return ExtensionsOk; 789 } 790 791 StringRef llvm::dwarf::FormatString(DwarfFormat Format) { 792 switch (Format) { 793 case DWARF32: 794 return "DWARF32"; 795 case DWARF64: 796 return "DWARF64"; 797 } 798 return StringRef(); 799 } 800 801 StringRef llvm::dwarf::FormatString(bool IsDWARF64) { 802 return FormatString(IsDWARF64 ? DWARF64 : DWARF32); 803 } 804 805 StringRef llvm::dwarf::RLEString(unsigned RLE) { 806 switch (RLE) { 807 default: 808 return StringRef(); 809 #define HANDLE_DW_RLE(ID, NAME) \ 810 case DW_RLE_##NAME: \ 811 return "DW_RLE_" #NAME; 812 #include "llvm/BinaryFormat/Dwarf.def" 813 } 814 } 815 816 constexpr char llvm::dwarf::EnumTraits<Attribute>::Type[]; 817 constexpr char llvm::dwarf::EnumTraits<Form>::Type[]; 818 constexpr char llvm::dwarf::EnumTraits<Index>::Type[]; 819 constexpr char llvm::dwarf::EnumTraits<Tag>::Type[]; 820 constexpr char llvm::dwarf::EnumTraits<LineNumberOps>::Type[]; 821 constexpr char llvm::dwarf::EnumTraits<LocationAtom>::Type[]; 822