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