llvm/lib/BinaryFormat/Dwarf.cpp

   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 Optional<unsigned> llvm::dwarf::LanguageLowerBound(dwarf::SourceLanguage Lang) {
 369   switch (Lang) {
 370   default:
 371     return None;
 372 #define HANDLE_DW_LANG(ID, NAME, LOWER_BOUND, VERSION, VENDOR)                 \
 373   case DW_LANG_##NAME:                                                         \
 374     return LOWER_BOUND;
 375 #include "llvm/BinaryFormat/Dwarf.def"
 376   }
 377 }
 378
 379 StringRef llvm::dwarf::CaseString(unsigned Case) {
 380   switch (Case) {
 381   case DW_ID_case_sensitive:
 382     return "DW_ID_case_sensitive";
 383   case DW_ID_up_case:
 384     return "DW_ID_up_case";
 385   case DW_ID_down_case:
 386     return "DW_ID_down_case";
 387   case DW_ID_case_insensitive:
 388     return "DW_ID_case_insensitive";
 389   }
 390   return StringRef();
 391 }
 392
 393 StringRef llvm::dwarf::ConventionString(unsigned CC) {
 394   switch (CC) {
 395   default:
 396     return StringRef();
 397 #define HANDLE_DW_CC(ID, NAME)                                                 \
 398   case DW_CC_##NAME:                                                           \
 399     return "DW_CC_" #NAME;
 400 #include "llvm/BinaryFormat/Dwarf.def"
 401   }
 402 }
 403
 404 unsigned llvm::dwarf::getCallingConvention(StringRef CCString) {
 405   return StringSwitch<unsigned>(CCString)
 406 #define HANDLE_DW_CC(ID, NAME) .Case("DW_CC_" #NAME, DW_CC_##NAME)
 407 #include "llvm/BinaryFormat/Dwarf.def"
 408       .Default(0);
 409 }
 410
 411 StringRef llvm::dwarf::InlineCodeString(unsigned Code) {
 412   switch (Code) {
 413   case DW_INL_not_inlined:
 414     return "DW_INL_not_inlined";
 415   case DW_INL_inlined:
 416     return "DW_INL_inlined";
 417   case DW_INL_declared_not_inlined:
 418     return "DW_INL_declared_not_inlined";
 419   case DW_INL_declared_inlined:
 420     return "DW_INL_declared_inlined";
 421   }
 422   return StringRef();
 423 }
 424
 425 StringRef llvm::dwarf::ArrayOrderString(unsigned Order) {
 426   switch (Order) {
 427   case DW_ORD_row_major:
 428     return "DW_ORD_row_major";
 429   case DW_ORD_col_major:
 430     return "DW_ORD_col_major";
 431   }
 432   return StringRef();
 433 }
 434
 435 StringRef llvm::dwarf::LNStandardString(unsigned Standard) {
 436   switch (Standard) {
 437   default:
 438     return StringRef();
 439 #define HANDLE_DW_LNS(ID, NAME)                                                \
 440   case DW_LNS_##NAME:                                                          \
 441     return "DW_LNS_" #NAME;
 442 #include "llvm/BinaryFormat/Dwarf.def"
 443   }
 444 }
 445
 446 StringRef llvm::dwarf::LNExtendedString(unsigned Encoding) {
 447   switch (Encoding) {
 448   default:
 449     return StringRef();
 450 #define HANDLE_DW_LNE(ID, NAME)                                                \
 451   case DW_LNE_##NAME:                                                          \
 452     return "DW_LNE_" #NAME;
 453 #include "llvm/BinaryFormat/Dwarf.def"
 454   }
 455 }
 456
 457 StringRef llvm::dwarf::MacinfoString(unsigned Encoding) {
 458   switch (Encoding) {
 459   // Macinfo Type Encodings
 460   case DW_MACINFO_define:
 461     return "DW_MACINFO_define";
 462   case DW_MACINFO_undef:
 463     return "DW_MACINFO_undef";
 464   case DW_MACINFO_start_file:
 465     return "DW_MACINFO_start_file";
 466   case DW_MACINFO_end_file:
 467     return "DW_MACINFO_end_file";
 468   case DW_MACINFO_vendor_ext:
 469     return "DW_MACINFO_vendor_ext";
 470   case DW_MACINFO_invalid:
 471     return "DW_MACINFO_invalid";
 472   }
 473   return StringRef();
 474 }
 475
 476 unsigned llvm::dwarf::getMacinfo(StringRef MacinfoString) {
 477   return StringSwitch<unsigned>(MacinfoString)
 478       .Case("DW_MACINFO_define", DW_MACINFO_define)
 479       .Case("DW_MACINFO_undef", DW_MACINFO_undef)
 480       .Case("DW_MACINFO_start_file", DW_MACINFO_start_file)
 481       .Case("DW_MACINFO_end_file", DW_MACINFO_end_file)
 482       .Case("DW_MACINFO_vendor_ext", DW_MACINFO_vendor_ext)
 483       .Default(DW_MACINFO_invalid);
 484 }
 485
 486 StringRef llvm::dwarf::MacroString(unsigned Encoding) {
 487   switch (Encoding) {
 488   default:
 489     return StringRef();
 490 #define HANDLE_DW_MACRO(ID, NAME)                                              \
 491   case DW_MACRO_##NAME:                                                        \
 492     return "DW_MACRO_" #NAME;
 493 #include "llvm/BinaryFormat/Dwarf.def"
 494   }
 495 }
 496
 497 StringRef llvm::dwarf::GnuMacroString(unsigned Encoding) {
 498   switch (Encoding) {
 499   default:
 500     return StringRef();
 501 #define HANDLE_DW_MACRO_GNU(ID, NAME)                                          \
 502   case DW_MACRO_GNU_##NAME:                                                    \
 503     return "DW_MACRO_GNU_" #NAME;
 504 #include "llvm/BinaryFormat/Dwarf.def"
 505   }
 506 }
 507
 508 unsigned llvm::dwarf::getMacro(StringRef MacroString) {
 509   return StringSwitch<unsigned>(MacroString)
 510 #define HANDLE_DW_MACRO(ID, NAME) .Case("DW_MACRO_" #NAME, ID)
 511 #include "llvm/BinaryFormat/Dwarf.def"
 512       .Default(DW_MACINFO_invalid);
 513 }
 514 StringRef llvm::dwarf::RangeListEncodingString(unsigned Encoding) {
 515   switch (Encoding) {
 516   default:
 517     return StringRef();
 518 #define HANDLE_DW_RLE(ID, NAME)                                                \
 519   case DW_RLE_##NAME:                                                          \
 520     return "DW_RLE_" #NAME;
 521 #include "llvm/BinaryFormat/Dwarf.def"
 522   }
 523 }
 524
 525 StringRef llvm::dwarf::LocListEncodingString(unsigned Encoding) {
 526   switch (Encoding) {
 527   default:
 528     return StringRef();
 529 #define HANDLE_DW_LLE(ID, NAME)                                                \
 530   case DW_LLE_##NAME:                                                          \
 531     return "DW_LLE_" #NAME;
 532 #include "llvm/BinaryFormat/Dwarf.def"
 533   }
 534 }
 535
 536 StringRef llvm::dwarf::CallFrameString(unsigned Encoding,
 537     Triple::ArchType Arch) {
 538   assert(Arch != llvm::Triple::ArchType::UnknownArch);
 539 #define SELECT_AARCH64 (Arch == llvm::Triple::aarch64_be || Arch == llvm::Triple::aarch64)
 540 #define SELECT_MIPS64 Arch == llvm::Triple::mips64
 541 #define SELECT_SPARC (Arch == llvm::Triple::sparc || Arch == llvm::Triple::sparcv9)
 542 #define SELECT_X86 (Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64)
 543 #define HANDLE_DW_CFA(ID, NAME)
 544 #define HANDLE_DW_CFA_PRED(ID, NAME, PRED) \
 545   if (ID == Encoding && PRED) \
 546     return "DW_CFA_" #NAME;
 547 #include "llvm/BinaryFormat/Dwarf.def"
 548
 549   switch (Encoding) {
 550   default:
 551     return StringRef();
 552 #define HANDLE_DW_CFA_PRED(ID, NAME, PRED)
 553 #define HANDLE_DW_CFA(ID, NAME)                                                \
 554   case DW_CFA_##NAME:                                                          \
 555     return "DW_CFA_" #NAME;
 556 #include "llvm/BinaryFormat/Dwarf.def"
 557
 558 #undef SELECT_X86
 559 #undef SELECT_SPARC
 560 #undef SELECT_MIPS64
 561 #undef SELECT_AARCH64
 562   }
 563 }
 564
 565 StringRef llvm::dwarf::ApplePropertyString(unsigned Prop) {
 566   switch (Prop) {
 567   default:
 568     return StringRef();
 569 #define HANDLE_DW_APPLE_PROPERTY(ID, NAME)                                     \
 570   case DW_APPLE_PROPERTY_##NAME:                                               \
 571     return "DW_APPLE_PROPERTY_" #NAME;
 572 #include "llvm/BinaryFormat/Dwarf.def"
 573   }
 574 }
 575
 576 StringRef llvm::dwarf::UnitTypeString(unsigned UT) {
 577   switch (UT) {
 578   default:
 579     return StringRef();
 580 #define HANDLE_DW_UT(ID, NAME)                                                 \
 581   case DW_UT_##NAME:                                                           \
 582     return "DW_UT_" #NAME;
 583 #include "llvm/BinaryFormat/Dwarf.def"
 584   }
 585 }
 586
 587 StringRef llvm::dwarf::AtomTypeString(unsigned AT) {
 588   switch (AT) {
 589   case dwarf::DW_ATOM_null:
 590     return "DW_ATOM_null";
 591   case dwarf::DW_ATOM_die_offset:
 592     return "DW_ATOM_die_offset";
 593   case DW_ATOM_cu_offset:
 594     return "DW_ATOM_cu_offset";
 595   case DW_ATOM_die_tag:
 596     return "DW_ATOM_die_tag";
 597   case DW_ATOM_type_flags:
 598   case DW_ATOM_type_type_flags:
 599     return "DW_ATOM_type_flags";
 600   case DW_ATOM_qual_name_hash:
 601     return "DW_ATOM_qual_name_hash";
 602   }
 603   return StringRef();
 604 }
 605
 606 StringRef llvm::dwarf::GDBIndexEntryKindString(GDBIndexEntryKind Kind) {
 607   switch (Kind) {
 608   case GIEK_NONE:
 609     return "NONE";
 610   case GIEK_TYPE:
 611     return "TYPE";
 612   case GIEK_VARIABLE:
 613     return "VARIABLE";
 614   case GIEK_FUNCTION:
 615     return "FUNCTION";
 616   case GIEK_OTHER:
 617     return "OTHER";
 618   case GIEK_UNUSED5:
 619     return "UNUSED5";
 620   case GIEK_UNUSED6:
 621     return "UNUSED6";
 622   case GIEK_UNUSED7:
 623     return "UNUSED7";
 624   }
 625   llvm_unreachable("Unknown GDBIndexEntryKind value");
 626 }
 627
 628 StringRef
 629 llvm::dwarf::GDBIndexEntryLinkageString(GDBIndexEntryLinkage Linkage) {
 630   switch (Linkage) {
 631   case GIEL_EXTERNAL:
 632     return "EXTERNAL";
 633   case GIEL_STATIC:
 634     return "STATIC";
 635   }
 636   llvm_unreachable("Unknown GDBIndexEntryLinkage value");
 637 }
 638
 639 StringRef llvm::dwarf::AttributeValueString(uint16_t Attr, unsigned Val) {
 640   switch (Attr) {
 641   case DW_AT_accessibility:
 642     return AccessibilityString(Val);
 643   case DW_AT_virtuality:
 644     return VirtualityString(Val);
 645   case DW_AT_language:
 646     return LanguageString(Val);
 647   case DW_AT_encoding:
 648     return AttributeEncodingString(Val);
 649   case DW_AT_decimal_sign:
 650     return DecimalSignString(Val);
 651   case DW_AT_endianity:
 652     return EndianityString(Val);
 653   case DW_AT_visibility:
 654     return VisibilityString(Val);
 655   case DW_AT_identifier_case:
 656     return CaseString(Val);
 657   case DW_AT_calling_convention:
 658     return ConventionString(Val);
 659   case DW_AT_inline:
 660     return InlineCodeString(Val);
 661   case DW_AT_ordering:
 662     return ArrayOrderString(Val);
 663   case DW_AT_APPLE_runtime_class:
 664     return LanguageString(Val);
 665   case DW_AT_defaulted:
 666     return DefaultedMemberString(Val);
 667   }
 668
 669   return StringRef();
 670 }
 671
 672 StringRef llvm::dwarf::AtomValueString(uint16_t Atom, unsigned Val) {
 673   switch (Atom) {
 674   case DW_ATOM_null:
 675     return "NULL";
 676   case DW_ATOM_die_tag:
 677     return TagString(Val);
 678   }
 679
 680   return StringRef();
 681 }
 682
 683 StringRef llvm::dwarf::IndexString(unsigned Idx) {
 684   switch (Idx) {
 685   default:
 686     return StringRef();
 687 #define HANDLE_DW_IDX(ID, NAME)                                                \
 688   case DW_IDX_##NAME:                                                          \
 689     return "DW_IDX_" #NAME;
 690 #include "llvm/BinaryFormat/Dwarf.def"
 691   }
 692 }
 693
 694 Optional<uint8_t> llvm::dwarf::getFixedFormByteSize(dwarf::Form Form,
 695                                                     FormParams Params) {
 696   switch (Form) {
 697   case DW_FORM_addr:
 698     if (Params)
 699       return Params.AddrSize;
 700     return None;
 701
 702   case DW_FORM_block:          // ULEB128 length L followed by L bytes.
 703   case DW_FORM_block1:         // 1 byte length L followed by L bytes.
 704   case DW_FORM_block2:         // 2 byte length L followed by L bytes.
 705   case DW_FORM_block4:         // 4 byte length L followed by L bytes.
 706   case DW_FORM_string:         // C-string with null terminator.
 707   case DW_FORM_sdata:          // SLEB128.
 708   case DW_FORM_udata:          // ULEB128.
 709   case DW_FORM_ref_udata:      // ULEB128.
 710   case DW_FORM_indirect:       // ULEB128.
 711   case DW_FORM_exprloc:        // ULEB128 length L followed by L bytes.
 712   case DW_FORM_strx:           // ULEB128.
 713   case DW_FORM_addrx:          // ULEB128.
 714   case DW_FORM_loclistx:       // ULEB128.
 715   case DW_FORM_rnglistx:       // ULEB128.
 716   case DW_FORM_GNU_addr_index: // ULEB128.
 717   case DW_FORM_GNU_str_index:  // ULEB128.
 718     return None;
 719
 720   case DW_FORM_ref_addr:
 721     if (Params)
 722       return Params.getRefAddrByteSize();
 723     return None;
 724
 725   case DW_FORM_flag:
 726   case DW_FORM_data1:
 727   case DW_FORM_ref1:
 728   case DW_FORM_strx1:
 729   case DW_FORM_addrx1:
 730     return 1;
 731
 732   case DW_FORM_data2:
 733   case DW_FORM_ref2:
 734   case DW_FORM_strx2:
 735   case DW_FORM_addrx2:
 736     return 2;
 737
 738   case DW_FORM_strx3:
 739     return 3;
 740
 741   case DW_FORM_data4:
 742   case DW_FORM_ref4:
 743   case DW_FORM_ref_sup4:
 744   case DW_FORM_strx4:
 745   case DW_FORM_addrx4:
 746     return 4;
 747
 748   case DW_FORM_strp:
 749   case DW_FORM_GNU_ref_alt:
 750   case DW_FORM_GNU_strp_alt:
 751   case DW_FORM_line_strp:
 752   case DW_FORM_sec_offset:
 753   case DW_FORM_strp_sup:
 754     if (Params)
 755       return Params.getDwarfOffsetByteSize();
 756     return None;
 757
 758   case DW_FORM_data8:
 759   case DW_FORM_ref8:
 760   case DW_FORM_ref_sig8:
 761   case DW_FORM_ref_sup8:
 762     return 8;
 763
 764   case DW_FORM_flag_present:
 765     return 0;
 766
 767   case DW_FORM_data16:
 768     return 16;
 769
 770   case DW_FORM_implicit_const:
 771     // The implicit value is stored in the abbreviation as a SLEB128, and
 772     // there no data in debug info.
 773     return 0;
 774
 775   default:
 776     break;
 777   }
 778   return None;
 779 }
 780
 781 bool llvm::dwarf::isValidFormForVersion(Form F, unsigned Version,
 782                                         bool ExtensionsOk) {
 783   if (FormVendor(F) == DWARF_VENDOR_DWARF) {
 784     unsigned FV = FormVersion(F);
 785     return FV > 0 && FV <= Version;
 786   }
 787   return ExtensionsOk;
 788 }
 789
 790 StringRef llvm::dwarf::FormatString(DwarfFormat Format) {
 791   switch (Format) {
 792   case DWARF32:
 793     return "DWARF32";
 794   case DWARF64:
 795     return "DWARF64";
 796   }
 797   return StringRef();
 798 }
 799
 800 StringRef llvm::dwarf::FormatString(bool IsDWARF64) {
 801   return FormatString(IsDWARF64 ? DWARF64 : DWARF32);
 802 }
 803
 804 StringRef llvm::dwarf::RLEString(unsigned RLE) {
 805   switch (RLE) {
 806   default:
 807     return StringRef();
 808 #define HANDLE_DW_RLE(ID, NAME)                                                \
 809   case DW_RLE_##NAME:                                                          \
 810     return "DW_RLE_" #NAME;
 811 #include "llvm/BinaryFormat/Dwarf.def"
 812   }
 813 }
 814
 815 constexpr char llvm::dwarf::EnumTraits<Attribute>::Type[];
 816 constexpr char llvm::dwarf::EnumTraits<Form>::Type[];
 817 constexpr char llvm::dwarf::EnumTraits<Index>::Type[];
 818 constexpr char llvm::dwarf::EnumTraits<Tag>::Type[];
 819 constexpr char llvm::dwarf::EnumTraits<LineNumberOps>::Type[];
 820 constexpr char llvm::dwarf::EnumTraits<LocationAtom>::Type[];