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