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