contrib/llvm/lib/BinaryFormat/Dwarf.cpp

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