Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

Rev

Blame | Last modification | View Log | Download | RSS feed

  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.