Dwarf.h revision 360784
1//===-- llvm/BinaryFormat/Dwarf.h ---Dwarf Constants-------------*- 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/// \file 10/// This file contains constants used for implementing Dwarf 11/// debug support. 12/// 13/// For details on the Dwarf specfication see the latest DWARF Debugging 14/// Information Format standard document on http://www.dwarfstd.org. This 15/// file often includes support for non-released standard features. 16// 17//===----------------------------------------------------------------------===// 18 19#ifndef LLVM_BINARYFORMAT_DWARF_H 20#define LLVM_BINARYFORMAT_DWARF_H 21 22#include "llvm/ADT/Optional.h" 23#include "llvm/Support/Compiler.h" 24#include "llvm/Support/DataTypes.h" 25#include "llvm/Support/ErrorHandling.h" 26#include "llvm/Support/Format.h" 27#include "llvm/Support/FormatVariadicDetails.h" 28#include "llvm/ADT/Triple.h" 29 30namespace llvm { 31class StringRef; 32 33namespace dwarf { 34 35//===----------------------------------------------------------------------===// 36// DWARF constants as gleaned from the DWARF Debugging Information Format V.5 37// reference manual http://www.dwarfstd.org/. 38// 39 40// Do not mix the following two enumerations sets. DW_TAG_invalid changes the 41// enumeration base type. 42 43enum LLVMConstants : uint32_t { 44 // LLVM mock tags (see also llvm/BinaryFormat/Dwarf.def). 45 DW_TAG_invalid = ~0U, // Tag for invalid results. 46 DW_VIRTUALITY_invalid = ~0U, // Virtuality for invalid results. 47 DW_MACINFO_invalid = ~0U, // Macinfo type for invalid results. 48 49 // Special values for an initial length field. 50 DW_LENGTH_lo_reserved = 0xfffffff0, // Lower bound of the reserved range. 51 DW_LENGTH_DWARF64 = 0xffffffff, // Indicator of 64-bit DWARF format. 52 DW_LENGTH_hi_reserved = 0xffffffff, // Upper bound of the reserved range. 53 54 // Other constants. 55 DWARF_VERSION = 4, // Default dwarf version we output. 56 DW_PUBTYPES_VERSION = 2, // Section version number for .debug_pubtypes. 57 DW_PUBNAMES_VERSION = 2, // Section version number for .debug_pubnames. 58 DW_ARANGES_VERSION = 2, // Section version number for .debug_aranges. 59 // Identifiers we use to distinguish vendor extensions. 60 DWARF_VENDOR_DWARF = 0, // Defined in v2 or later of the DWARF standard. 61 DWARF_VENDOR_APPLE = 1, 62 DWARF_VENDOR_BORLAND = 2, 63 DWARF_VENDOR_GNU = 3, 64 DWARF_VENDOR_GOOGLE = 4, 65 DWARF_VENDOR_LLVM = 5, 66 DWARF_VENDOR_MIPS = 6, 67 DWARF_VENDOR_WASM = 7 68}; 69 70/// Constants that define the DWARF format as 32 or 64 bit. 71enum DwarfFormat : uint8_t { DWARF32, DWARF64 }; 72 73/// Special ID values that distinguish a CIE from a FDE in DWARF CFI. 74/// Not inside an enum because a 64-bit value is needed. 75/// @{ 76const uint32_t DW_CIE_ID = UINT32_MAX; 77const uint64_t DW64_CIE_ID = UINT64_MAX; 78/// @} 79 80/// Identifier of an invalid DIE offset in the .debug_info section. 81const uint32_t DW_INVALID_OFFSET = UINT32_MAX; 82 83enum Tag : uint16_t { 84#define HANDLE_DW_TAG(ID, NAME, VERSION, VENDOR, KIND) DW_TAG_##NAME = ID, 85#include "llvm/BinaryFormat/Dwarf.def" 86 DW_TAG_lo_user = 0x4080, 87 DW_TAG_hi_user = 0xffff, 88 DW_TAG_user_base = 0x1000 ///< Recommended base for user tags. 89}; 90 91inline bool isType(Tag T) { 92 switch (T) { 93 default: 94 return false; 95#define HANDLE_DW_TAG(ID, NAME, VERSION, VENDOR, KIND) \ 96 case DW_TAG_##NAME: \ 97 return (KIND == DW_KIND_TYPE); 98#include "llvm/BinaryFormat/Dwarf.def" 99 } 100} 101 102/// Attributes. 103enum Attribute : uint16_t { 104#define HANDLE_DW_AT(ID, NAME, VERSION, VENDOR) DW_AT_##NAME = ID, 105#include "llvm/BinaryFormat/Dwarf.def" 106 DW_AT_lo_user = 0x2000, 107 DW_AT_hi_user = 0x3fff, 108}; 109 110enum Form : uint16_t { 111#define HANDLE_DW_FORM(ID, NAME, VERSION, VENDOR) DW_FORM_##NAME = ID, 112#include "llvm/BinaryFormat/Dwarf.def" 113 DW_FORM_lo_user = 0x1f00, ///< Not specified by DWARF. 114}; 115 116enum LocationAtom { 117#define HANDLE_DW_OP(ID, NAME, VERSION, VENDOR) DW_OP_##NAME = ID, 118#include "llvm/BinaryFormat/Dwarf.def" 119 DW_OP_lo_user = 0xe0, 120 DW_OP_hi_user = 0xff, 121 DW_OP_LLVM_fragment = 0x1000, ///< Only used in LLVM metadata. 122 DW_OP_LLVM_convert = 0x1001, ///< Only used in LLVM metadata. 123 DW_OP_LLVM_tag_offset = 0x1002, ///< Only used in LLVM metadata. 124 DW_OP_LLVM_entry_value = 0x1003, ///< Only used in LLVM metadata. 125}; 126 127enum TypeKind : uint8_t { 128#define HANDLE_DW_ATE(ID, NAME, VERSION, VENDOR) DW_ATE_##NAME = ID, 129#include "llvm/BinaryFormat/Dwarf.def" 130 DW_ATE_lo_user = 0x80, 131 DW_ATE_hi_user = 0xff 132}; 133 134enum DecimalSignEncoding { 135 // Decimal sign attribute values 136 DW_DS_unsigned = 0x01, 137 DW_DS_leading_overpunch = 0x02, 138 DW_DS_trailing_overpunch = 0x03, 139 DW_DS_leading_separate = 0x04, 140 DW_DS_trailing_separate = 0x05 141}; 142 143enum EndianityEncoding { 144 // Endianity attribute values 145#define HANDLE_DW_END(ID, NAME) DW_END_##NAME = ID, 146#include "llvm/BinaryFormat/Dwarf.def" 147 DW_END_lo_user = 0x40, 148 DW_END_hi_user = 0xff 149}; 150 151enum AccessAttribute { 152 // Accessibility codes 153 DW_ACCESS_public = 0x01, 154 DW_ACCESS_protected = 0x02, 155 DW_ACCESS_private = 0x03 156}; 157 158enum VisibilityAttribute { 159 // Visibility codes 160 DW_VIS_local = 0x01, 161 DW_VIS_exported = 0x02, 162 DW_VIS_qualified = 0x03 163}; 164 165enum VirtualityAttribute { 166#define HANDLE_DW_VIRTUALITY(ID, NAME) DW_VIRTUALITY_##NAME = ID, 167#include "llvm/BinaryFormat/Dwarf.def" 168 DW_VIRTUALITY_max = 0x02 169}; 170 171enum DefaultedMemberAttribute { 172#define HANDLE_DW_DEFAULTED(ID, NAME) DW_DEFAULTED_##NAME = ID, 173#include "llvm/BinaryFormat/Dwarf.def" 174 DW_DEFAULTED_max = 0x02 175}; 176 177enum SourceLanguage { 178#define HANDLE_DW_LANG(ID, NAME, LOWER_BOUND, VERSION, VENDOR) \ 179 DW_LANG_##NAME = ID, 180#include "llvm/BinaryFormat/Dwarf.def" 181 DW_LANG_lo_user = 0x8000, 182 DW_LANG_hi_user = 0xffff 183}; 184 185inline bool isCPlusPlus(SourceLanguage S) { 186 // Deliberately enumerate all the language options so we get a warning when 187 // new language options are added (-Wswitch) that'll hopefully help keep this 188 // switch up-to-date when new C++ versions are added. 189 switch (S) { 190 case DW_LANG_C_plus_plus: 191 case DW_LANG_C_plus_plus_03: 192 case DW_LANG_C_plus_plus_11: 193 case DW_LANG_C_plus_plus_14: 194 return true; 195 case DW_LANG_C89: 196 case DW_LANG_C: 197 case DW_LANG_Ada83: 198 case DW_LANG_Cobol74: 199 case DW_LANG_Cobol85: 200 case DW_LANG_Fortran77: 201 case DW_LANG_Fortran90: 202 case DW_LANG_Pascal83: 203 case DW_LANG_Modula2: 204 case DW_LANG_Java: 205 case DW_LANG_C99: 206 case DW_LANG_Ada95: 207 case DW_LANG_Fortran95: 208 case DW_LANG_PLI: 209 case DW_LANG_ObjC: 210 case DW_LANG_ObjC_plus_plus: 211 case DW_LANG_UPC: 212 case DW_LANG_D: 213 case DW_LANG_Python: 214 case DW_LANG_OpenCL: 215 case DW_LANG_Go: 216 case DW_LANG_Modula3: 217 case DW_LANG_Haskell: 218 case DW_LANG_OCaml: 219 case DW_LANG_Rust: 220 case DW_LANG_C11: 221 case DW_LANG_Swift: 222 case DW_LANG_Julia: 223 case DW_LANG_Dylan: 224 case DW_LANG_Fortran03: 225 case DW_LANG_Fortran08: 226 case DW_LANG_RenderScript: 227 case DW_LANG_BLISS: 228 case DW_LANG_Mips_Assembler: 229 case DW_LANG_GOOGLE_RenderScript: 230 case DW_LANG_BORLAND_Delphi: 231 case DW_LANG_lo_user: 232 case DW_LANG_hi_user: 233 return false; 234 } 235 llvm_unreachable("Invalid source language"); 236} 237 238enum CaseSensitivity { 239 // Identifier case codes 240 DW_ID_case_sensitive = 0x00, 241 DW_ID_up_case = 0x01, 242 DW_ID_down_case = 0x02, 243 DW_ID_case_insensitive = 0x03 244}; 245 246enum CallingConvention { 247// Calling convention codes 248#define HANDLE_DW_CC(ID, NAME) DW_CC_##NAME = ID, 249#include "llvm/BinaryFormat/Dwarf.def" 250 DW_CC_lo_user = 0x40, 251 DW_CC_hi_user = 0xff 252}; 253 254enum InlineAttribute { 255 // Inline codes 256 DW_INL_not_inlined = 0x00, 257 DW_INL_inlined = 0x01, 258 DW_INL_declared_not_inlined = 0x02, 259 DW_INL_declared_inlined = 0x03 260}; 261 262enum ArrayDimensionOrdering { 263 // Array ordering 264 DW_ORD_row_major = 0x00, 265 DW_ORD_col_major = 0x01 266}; 267 268enum DiscriminantList { 269 // Discriminant descriptor values 270 DW_DSC_label = 0x00, 271 DW_DSC_range = 0x01 272}; 273 274/// Line Number Standard Opcode Encodings. 275enum LineNumberOps : uint8_t { 276#define HANDLE_DW_LNS(ID, NAME) DW_LNS_##NAME = ID, 277#include "llvm/BinaryFormat/Dwarf.def" 278}; 279 280/// Line Number Extended Opcode Encodings. 281enum LineNumberExtendedOps { 282#define HANDLE_DW_LNE(ID, NAME) DW_LNE_##NAME = ID, 283#include "llvm/BinaryFormat/Dwarf.def" 284 DW_LNE_lo_user = 0x80, 285 DW_LNE_hi_user = 0xff 286}; 287 288enum LineNumberEntryFormat { 289#define HANDLE_DW_LNCT(ID, NAME) DW_LNCT_##NAME = ID, 290#include "llvm/BinaryFormat/Dwarf.def" 291 DW_LNCT_lo_user = 0x2000, 292 DW_LNCT_hi_user = 0x3fff, 293}; 294 295enum MacinfoRecordType { 296 // Macinfo Type Encodings 297 DW_MACINFO_define = 0x01, 298 DW_MACINFO_undef = 0x02, 299 DW_MACINFO_start_file = 0x03, 300 DW_MACINFO_end_file = 0x04, 301 DW_MACINFO_vendor_ext = 0xff 302}; 303 304/// DWARF v5 macro information entry type encodings. 305enum MacroEntryType { 306#define HANDLE_DW_MACRO(ID, NAME) DW_MACRO_##NAME = ID, 307#include "llvm/BinaryFormat/Dwarf.def" 308 DW_MACRO_lo_user = 0xe0, 309 DW_MACRO_hi_user = 0xff 310}; 311 312/// DWARF v5 range list entry encoding values. 313enum RnglistEntries { 314#define HANDLE_DW_RLE(ID, NAME) DW_RLE_##NAME = ID, 315#include "llvm/BinaryFormat/Dwarf.def" 316}; 317 318/// DWARF v5 loc list entry encoding values. 319enum LoclistEntries { 320#define HANDLE_DW_LLE(ID, NAME) DW_LLE_##NAME = ID, 321#include "llvm/BinaryFormat/Dwarf.def" 322}; 323 324/// Call frame instruction encodings. 325enum CallFrameInfo { 326#define HANDLE_DW_CFA(ID, NAME) DW_CFA_##NAME = ID, 327#define HANDLE_DW_CFA_PRED(ID, NAME, ARCH) DW_CFA_##NAME = ID, 328#include "llvm/BinaryFormat/Dwarf.def" 329 DW_CFA_extended = 0x00, 330 331 DW_CFA_lo_user = 0x1c, 332 DW_CFA_hi_user = 0x3f 333}; 334 335enum Constants { 336 // Children flag 337 DW_CHILDREN_no = 0x00, 338 DW_CHILDREN_yes = 0x01, 339 340 DW_EH_PE_absptr = 0x00, 341 DW_EH_PE_omit = 0xff, 342 DW_EH_PE_uleb128 = 0x01, 343 DW_EH_PE_udata2 = 0x02, 344 DW_EH_PE_udata4 = 0x03, 345 DW_EH_PE_udata8 = 0x04, 346 DW_EH_PE_sleb128 = 0x09, 347 DW_EH_PE_sdata2 = 0x0A, 348 DW_EH_PE_sdata4 = 0x0B, 349 DW_EH_PE_sdata8 = 0x0C, 350 DW_EH_PE_signed = 0x08, 351 DW_EH_PE_pcrel = 0x10, 352 DW_EH_PE_textrel = 0x20, 353 DW_EH_PE_datarel = 0x30, 354 DW_EH_PE_funcrel = 0x40, 355 DW_EH_PE_aligned = 0x50, 356 DW_EH_PE_indirect = 0x80 357}; 358 359/// Constants for the DW_APPLE_PROPERTY_attributes attribute. 360/// Keep this list in sync with clang's DeclSpec.h ObjCPropertyAttributeKind! 361enum ApplePropertyAttributes { 362#define HANDLE_DW_APPLE_PROPERTY(ID, NAME) DW_APPLE_PROPERTY_##NAME = ID, 363#include "llvm/BinaryFormat/Dwarf.def" 364}; 365 366/// Constants for unit types in DWARF v5. 367enum UnitType : unsigned char { 368#define HANDLE_DW_UT(ID, NAME) DW_UT_##NAME = ID, 369#include "llvm/BinaryFormat/Dwarf.def" 370 DW_UT_lo_user = 0x80, 371 DW_UT_hi_user = 0xff 372}; 373 374enum Index { 375#define HANDLE_DW_IDX(ID, NAME) DW_IDX_##NAME = ID, 376#include "llvm/BinaryFormat/Dwarf.def" 377 DW_IDX_lo_user = 0x2000, 378 DW_IDX_hi_user = 0x3fff 379}; 380 381inline bool isUnitType(uint8_t UnitType) { 382 switch (UnitType) { 383 case DW_UT_compile: 384 case DW_UT_type: 385 case DW_UT_partial: 386 case DW_UT_skeleton: 387 case DW_UT_split_compile: 388 case DW_UT_split_type: 389 return true; 390 default: 391 return false; 392 } 393} 394 395inline bool isUnitType(dwarf::Tag T) { 396 switch (T) { 397 case DW_TAG_compile_unit: 398 case DW_TAG_type_unit: 399 case DW_TAG_partial_unit: 400 case DW_TAG_skeleton_unit: 401 return true; 402 default: 403 return false; 404 } 405} 406 407// Constants for the DWARF v5 Accelerator Table Proposal 408enum AcceleratorTable { 409 // Data layout descriptors. 410 DW_ATOM_null = 0u, /// Marker as the end of a list of atoms. 411 DW_ATOM_die_offset = 1u, // DIE offset in the debug_info section. 412 DW_ATOM_cu_offset = 2u, // Offset of the compile unit header that contains the 413 // item in question. 414 DW_ATOM_die_tag = 3u, // A tag entry. 415 DW_ATOM_type_flags = 4u, // Set of flags for a type. 416 417 DW_ATOM_type_type_flags = 5u, // Dsymutil type extension. 418 DW_ATOM_qual_name_hash = 6u, // Dsymutil qualified hash extension. 419 420 // DW_ATOM_type_flags values. 421 422 // Always set for C++, only set for ObjC if this is the @implementation for a 423 // class. 424 DW_FLAG_type_implementation = 2u, 425 426 // Hash functions. 427 428 // Daniel J. Bernstein hash. 429 DW_hash_function_djb = 0u 430}; 431 432// Constants for the GNU pubnames/pubtypes extensions supporting gdb index. 433enum GDBIndexEntryKind { 434 GIEK_NONE, 435 GIEK_TYPE, 436 GIEK_VARIABLE, 437 GIEK_FUNCTION, 438 GIEK_OTHER, 439 GIEK_UNUSED5, 440 GIEK_UNUSED6, 441 GIEK_UNUSED7 442}; 443 444enum GDBIndexEntryLinkage { GIEL_EXTERNAL, GIEL_STATIC }; 445 446/// \defgroup DwarfConstantsDumping Dwarf constants dumping functions 447/// 448/// All these functions map their argument's value back to the 449/// corresponding enumerator name or return an empty StringRef if the value 450/// isn't known. 451/// 452/// @{ 453StringRef TagString(unsigned Tag); 454StringRef ChildrenString(unsigned Children); 455StringRef AttributeString(unsigned Attribute); 456StringRef FormEncodingString(unsigned Encoding); 457StringRef OperationEncodingString(unsigned Encoding); 458StringRef AttributeEncodingString(unsigned Encoding); 459StringRef DecimalSignString(unsigned Sign); 460StringRef EndianityString(unsigned Endian); 461StringRef AccessibilityString(unsigned Access); 462StringRef DefaultedMemberString(unsigned DefaultedEncodings); 463StringRef VisibilityString(unsigned Visibility); 464StringRef VirtualityString(unsigned Virtuality); 465StringRef LanguageString(unsigned Language); 466StringRef CaseString(unsigned Case); 467StringRef ConventionString(unsigned Convention); 468StringRef InlineCodeString(unsigned Code); 469StringRef ArrayOrderString(unsigned Order); 470StringRef LNStandardString(unsigned Standard); 471StringRef LNExtendedString(unsigned Encoding); 472StringRef MacinfoString(unsigned Encoding); 473StringRef RangeListEncodingString(unsigned Encoding); 474StringRef LocListEncodingString(unsigned Encoding); 475StringRef CallFrameString(unsigned Encoding, Triple::ArchType Arch); 476StringRef ApplePropertyString(unsigned); 477StringRef UnitTypeString(unsigned); 478StringRef AtomTypeString(unsigned Atom); 479StringRef GDBIndexEntryKindString(GDBIndexEntryKind Kind); 480StringRef GDBIndexEntryLinkageString(GDBIndexEntryLinkage Linkage); 481StringRef IndexString(unsigned Idx); 482/// @} 483 484/// \defgroup DwarfConstantsParsing Dwarf constants parsing functions 485/// 486/// These functions map their strings back to the corresponding enumeration 487/// value or return 0 if there is none, except for these exceptions: 488/// 489/// \li \a getTag() returns \a DW_TAG_invalid on invalid input. 490/// \li \a getVirtuality() returns \a DW_VIRTUALITY_invalid on invalid input. 491/// \li \a getMacinfo() returns \a DW_MACINFO_invalid on invalid input. 492/// 493/// @{ 494unsigned getTag(StringRef TagString); 495unsigned getOperationEncoding(StringRef OperationEncodingString); 496unsigned getVirtuality(StringRef VirtualityString); 497unsigned getLanguage(StringRef LanguageString); 498unsigned getCallingConvention(StringRef LanguageString); 499unsigned getAttributeEncoding(StringRef EncodingString); 500unsigned getMacinfo(StringRef MacinfoString); 501/// @} 502 503/// \defgroup DwarfConstantsVersioning Dwarf version for constants 504/// 505/// For constants defined by DWARF, returns the DWARF version when the constant 506/// was first defined. For vendor extensions, if there is a version-related 507/// policy for when to emit it, returns a version number for that policy. 508/// Otherwise returns 0. 509/// 510/// @{ 511unsigned TagVersion(Tag T); 512unsigned AttributeVersion(Attribute A); 513unsigned FormVersion(Form F); 514unsigned OperationVersion(LocationAtom O); 515unsigned AttributeEncodingVersion(TypeKind E); 516unsigned LanguageVersion(SourceLanguage L); 517/// @} 518 519/// \defgroup DwarfConstantsVendor Dwarf "vendor" for constants 520/// 521/// These functions return an identifier describing "who" defined the constant, 522/// either the DWARF standard itself or the vendor who defined the extension. 523/// 524/// @{ 525unsigned TagVendor(Tag T); 526unsigned AttributeVendor(Attribute A); 527unsigned FormVendor(Form F); 528unsigned OperationVendor(LocationAtom O); 529unsigned AttributeEncodingVendor(TypeKind E); 530unsigned LanguageVendor(SourceLanguage L); 531/// @} 532 533Optional<unsigned> LanguageLowerBound(SourceLanguage L); 534 535/// A helper struct providing information about the byte size of DW_FORM 536/// values that vary in size depending on the DWARF version, address byte 537/// size, or DWARF32/DWARF64. 538struct FormParams { 539 uint16_t Version; 540 uint8_t AddrSize; 541 DwarfFormat Format; 542 543 /// The definition of the size of form DW_FORM_ref_addr depends on the 544 /// version. In DWARF v2 it's the size of an address; after that, it's the 545 /// size of a reference. 546 uint8_t getRefAddrByteSize() const { 547 if (Version == 2) 548 return AddrSize; 549 return getDwarfOffsetByteSize(); 550 } 551 552 /// The size of a reference is determined by the DWARF 32/64-bit format. 553 uint8_t getDwarfOffsetByteSize() const { 554 switch (Format) { 555 case DwarfFormat::DWARF32: 556 return 4; 557 case DwarfFormat::DWARF64: 558 return 8; 559 } 560 llvm_unreachable("Invalid Format value"); 561 } 562 563 explicit operator bool() const { return Version && AddrSize; } 564}; 565 566/// Get the byte size of the unit length field depending on the DWARF format. 567inline uint8_t getUnitLengthFieldByteSize(DwarfFormat Format) { 568 switch (Format) { 569 case DwarfFormat::DWARF32: 570 return 4; 571 case DwarfFormat::DWARF64: 572 return 12; 573 } 574 llvm_unreachable("Invalid Format value"); 575} 576 577/// Get the fixed byte size for a given form. 578/// 579/// If the form has a fixed byte size, then an Optional with a value will be 580/// returned. If the form is always encoded using a variable length storage 581/// format (ULEB or SLEB numbers or blocks) then None will be returned. 582/// 583/// \param Form DWARF form to get the fixed byte size for. 584/// \param Params DWARF parameters to help interpret forms. 585/// \returns Optional<uint8_t> value with the fixed byte size or None if 586/// \p Form doesn't have a fixed byte size. 587Optional<uint8_t> getFixedFormByteSize(dwarf::Form Form, FormParams Params); 588 589/// Tells whether the specified form is defined in the specified version, 590/// or is an extension if extensions are allowed. 591bool isValidFormForVersion(Form F, unsigned Version, bool ExtensionsOk = true); 592 593/// Returns the symbolic string representing Val when used as a value 594/// for attribute Attr. 595StringRef AttributeValueString(uint16_t Attr, unsigned Val); 596 597/// Returns the symbolic string representing Val when used as a value 598/// for atom Atom. 599StringRef AtomValueString(uint16_t Atom, unsigned Val); 600 601/// Describes an entry of the various gnu_pub* debug sections. 602/// 603/// The gnu_pub* kind looks like: 604/// 605/// 0-3 reserved 606/// 4-6 symbol kind 607/// 7 0 == global, 1 == static 608/// 609/// A gdb_index descriptor includes the above kind, shifted 24 bits up with the 610/// offset of the cu within the debug_info section stored in those 24 bits. 611struct PubIndexEntryDescriptor { 612 GDBIndexEntryKind Kind; 613 GDBIndexEntryLinkage Linkage; 614 PubIndexEntryDescriptor(GDBIndexEntryKind Kind, GDBIndexEntryLinkage Linkage) 615 : Kind(Kind), Linkage(Linkage) {} 616 /* implicit */ PubIndexEntryDescriptor(GDBIndexEntryKind Kind) 617 : Kind(Kind), Linkage(GIEL_EXTERNAL) {} 618 explicit PubIndexEntryDescriptor(uint8_t Value) 619 : Kind( 620 static_cast<GDBIndexEntryKind>((Value & KIND_MASK) >> KIND_OFFSET)), 621 Linkage(static_cast<GDBIndexEntryLinkage>((Value & LINKAGE_MASK) >> 622 LINKAGE_OFFSET)) {} 623 uint8_t toBits() const { 624 return Kind << KIND_OFFSET | Linkage << LINKAGE_OFFSET; 625 } 626 627private: 628 enum { 629 KIND_OFFSET = 4, 630 KIND_MASK = 7 << KIND_OFFSET, 631 LINKAGE_OFFSET = 7, 632 LINKAGE_MASK = 1 << LINKAGE_OFFSET 633 }; 634}; 635 636template <typename Enum> struct EnumTraits : public std::false_type {}; 637 638template <> struct EnumTraits<Attribute> : public std::true_type { 639 static constexpr char Type[3] = "AT"; 640 static constexpr StringRef (*StringFn)(unsigned) = &AttributeString; 641}; 642 643template <> struct EnumTraits<Form> : public std::true_type { 644 static constexpr char Type[5] = "FORM"; 645 static constexpr StringRef (*StringFn)(unsigned) = &FormEncodingString; 646}; 647 648template <> struct EnumTraits<Index> : public std::true_type { 649 static constexpr char Type[4] = "IDX"; 650 static constexpr StringRef (*StringFn)(unsigned) = &IndexString; 651}; 652 653template <> struct EnumTraits<Tag> : public std::true_type { 654 static constexpr char Type[4] = "TAG"; 655 static constexpr StringRef (*StringFn)(unsigned) = &TagString; 656}; 657} // End of namespace dwarf 658 659/// Dwarf constants format_provider 660/// 661/// Specialization of the format_provider template for dwarf enums. Unlike the 662/// dumping functions above, these format unknown enumerator values as 663/// DW_TYPE_unknown_1234 (e.g. DW_TAG_unknown_ffff). 664template <typename Enum> 665struct format_provider< 666 Enum, typename std::enable_if<dwarf::EnumTraits<Enum>::value>::type> { 667 static void format(const Enum &E, raw_ostream &OS, StringRef Style) { 668 StringRef Str = dwarf::EnumTraits<Enum>::StringFn(E); 669 if (Str.empty()) { 670 OS << "DW_" << dwarf::EnumTraits<Enum>::Type << "_unknown_" 671 << llvm::format("%x", E); 672 } else 673 OS << Str; 674 } 675}; 676} // End of namespace llvm 677 678#endif 679