// Copyright (c) 2013 Austin T. Clements. All rights reserved. // Use of this source code is governed by an MIT license // that can be found in the LICENSE file. #ifndef _DWARFPP_DW_HH_ #define _DWARFPP_DW_HH_ #include #include DWARFPP_BEGIN_NAMESPACE // Integer representations (Section 7.26) typedef std::int8_t sbyte; typedef std::uint8_t ubyte; typedef std::uint16_t uhalf; typedef std::uint32_t uword; // Section offsets and lengths typedef std::uint64_t section_offset; typedef std::uint64_t section_length; // A target machine address. Targets may use smaller addresses; this // represents the largest supported address type. typedef std::uint64_t taddr; // DIE tags (Section 7, figure 18). typedef, friend, and namespace // have a trailing underscore because they are reserved words. enum class DW_TAG { array_type = 0x01, class_type = 0x02, entry_point = 0x03, enumeration_type = 0x04, formal_parameter = 0x05, imported_declaration = 0x08, label = 0x0a, lexical_block = 0x0b, member = 0x0d, pointer_type = 0x0f, reference_type = 0x10, compile_unit = 0x11, string_type = 0x12, structure_type = 0x13, subroutine_type = 0x15, typedef_ = 0x16, union_type = 0x17, unspecified_parameters = 0x18, variant = 0x19, common_block = 0x1a, common_inclusion = 0x1b, inheritance = 0x1c, inlined_subroutine = 0x1d, module = 0x1e, ptr_to_member_type = 0x1f, set_type = 0x20, subrange_type = 0x21, with_stmt = 0x22, access_declaration = 0x23, base_type = 0x24, catch_block = 0x25, const_type = 0x26, constant = 0x27, enumerator = 0x28, file_type = 0x29, friend_ = 0x2a, namelist = 0x2b, namelist_item = 0x2c, packed_type = 0x2d, subprogram = 0x2e, template_type_parameter = 0x2f, template_value_parameter = 0x30, thrown_type = 0x31, try_block = 0x32, variant_part = 0x33, variable = 0x34, volatile_type = 0x35, dwarf_procedure = 0x36, restrict_type = 0x37, interface_type = 0x38, namespace_ = 0x39, imported_module = 0x3a, unspecified_type = 0x3b, partial_unit = 0x3c, imported_unit = 0x3d, condition = 0x3f, shared_type = 0x40, type_unit = 0x41, rvalue_reference_type = 0x42, template_alias = 0x43, lo_user = 0x4080, hi_user = 0xffff, }; std::string to_string(DW_TAG v); // Child determination (Section 7, figure 19). enum class DW_CHILDREN : ubyte { no = 0x00, yes = 0x01, }; std::string to_string(DW_CHILDREN v); // Attribute names (Section 7, figure 20). inline, friend, mutable, // and explicit have a trailing underscore because they are reserved // words. enum class DW_AT { sibling = 0x01,// reference location = 0x02,// exprloc, loclistptr name = 0x03,// string ordering = 0x09,// constant byte_size = 0x0b,// constant, exprloc, reference bit_offset = 0x0c,// constant, exprloc, reference bit_size = 0x0d,// constant, exprloc, reference stmt_list = 0x10,// lineptr low_pc = 0x11,// address high_pc = 0x12,// address, constant language = 0x13,// constant discr = 0x15,// reference discr_value = 0x16,// constant visibility = 0x17,// constant import = 0x18,// reference string_length = 0x19,// exprloc, loclistptr common_reference = 0x1a,// reference comp_dir = 0x1b,// string const_value = 0x1c,// block, constant, string containing_type = 0x1d,// reference default_value = 0x1e,// reference inline_ = 0x20,// constant is_optional = 0x21,// flag lower_bound = 0x22,// constant, exprloc, reference producer = 0x25,// string prototyped = 0x27,// flag return_addr = 0x2a,// exprloc, loclistptr start_scope = 0x2c,// constant, rangelistptr bit_stride = 0x2e,// constant, exprloc, reference upper_bound = 0x2f,// constant, exprloc, reference abstract_origin = 0x31,// reference accessibility = 0x32,// constant address_class = 0x33,// constant artificial = 0x34,// flag base_types = 0x35,// reference calling_convention = 0x36,// constant count = 0x37,// constant, exprloc, reference data_member_location = 0x38,// constant, exprloc, loclistptr decl_column = 0x39,// constant decl_file = 0x3a,// constant decl_line = 0x3b,// constant declaration = 0x3c,// flag discr_list = 0x3d,// block encoding = 0x3e,// constant external = 0x3f,// flag frame_base = 0x40,// exprloc, loclistptr friend_ = 0x41,// reference identifier_case = 0x42,// constant macro_info = 0x43,// macptr namelist_item = 0x44,// reference priority = 0x45,// reference segment = 0x46,// exprloc, loclistptr specification = 0x47,// reference static_link = 0x48,// exprloc, loclistptr type = 0x49,// reference use_location = 0x4a,// exprloc, loclistptr variable_parameter = 0x4b,// flag virtuality = 0x4c,// constant vtable_elem_location = 0x4d,// exprloc, loclistptr // DWARF 3 allocated = 0x4e,// constant, exprloc, reference associated = 0x4f,// constant, exprloc, reference data_location = 0x50,// exprloc byte_stride = 0x51,// constant, exprloc, reference entry_pc = 0x52,// address use_UTF8 = 0x53,// flag extension = 0x54,// reference ranges = 0x55,// rangelistptr trampoline = 0x56,// address, flag, reference, string call_column = 0x57,// constant call_file = 0x58,// constant call_line = 0x59,// constant description = 0x5a,// string binary_scale = 0x5b,// constant decimal_scale = 0x5c,// constant small = 0x5d,// reference decimal_sign = 0x5e,// constant digit_count = 0x5f,// constant picture_string = 0x60,// string mutable_ = 0x61,// flag threads_scaled = 0x62,// flag explicit_ = 0x63,// flag object_pointer = 0x64,// reference endianity = 0x65,// constant elemental = 0x66,// flag pure = 0x67,// flag recursive = 0x68,// flag // DWARF 4 signature = 0x69,// reference main_subprogram = 0x6a,// flag data_bit_offset = 0x6b,// constant const_expr = 0x6c,// flag enum_class = 0x6d,// flag linkage_name = 0x6e,// string lo_user = 0x2000, hi_user = 0x3fff, }; std::string to_string(DW_AT v); // Attribute form encodings (Section 7, figure 21) enum class DW_FORM { addr = 0x01,// address block2 = 0x03,// block block4 = 0x04,// block data2 = 0x05,// constant data4 = 0x06,// constant data8 = 0x07,// constant string = 0x08,// string block = 0x09,// block block1 = 0x0a,// block data1 = 0x0b,// constant flag = 0x0c,// flag sdata = 0x0d,// constant strp = 0x0e,// string udata = 0x0f,// constant ref_addr = 0x10,// reference ref1 = 0x11,// reference ref2 = 0x12,// reference ref4 = 0x13,// reference ref8 = 0x14,// reference ref_udata = 0x15,// reference indirect = 0x16,// (Section 7.5.3) // DWARF 4 sec_offset = 0x17,// lineptr, loclistptr, macptr, rangelistptr exprloc = 0x18,// exprloc flag_present = 0x19,// flag ref_sig8 = 0x20,// reference implicit_const = 0x21, loclistx = 0x22, rnglistx = 0x23, ref_sup8 = 0x24, strx1 = 0x25, strx2 = 0x26, strx3 = 0x27, strx4 = 0x28, addrx1 = 0x29, addrx2 = 0x2a, addrx4 = 0x2c, addrx3 = 0x2b, }; std::string to_string(DW_FORM v); // DWARF operation encodings (Section 7.7.1 and figure 24) enum class DW_OP : ubyte { addr = 0x03,// [constant address (size target specific)] deref = 0x06, const1u = 0x08,// [1-byte constant] const1s = 0x09,// [1-byte constant] const2u = 0x0a,// [2-byte constant] const2s = 0x0b,// [2-byte constant] const4u = 0x0c,// [4-byte constant] const4s = 0x0d,// [4-byte constant] const8u = 0x0e,// [8-byte constant] const8s = 0x0f,// [8-byte constant] constu = 0x10,// [ULEB128 constant] consts = 0x11,// [SLEB128 constant] dup = 0x12, drop = 0x13, over = 0x14, pick = 0x15,// [1-byte stack index] swap = 0x16, rot = 0x17, xderef = 0x18, abs = 0x19, and_ = 0x1a, div = 0x1b, minus = 0x1c, mod = 0x1d, mul = 0x1e, neg = 0x1f, not_ = 0x20, or_ = 0x21, plus = 0x22, plus_uconst = 0x23,// [ULEB128 addend] shl = 0x24, shr = 0x25, shra = 0x26, xor_ = 0x27, skip = 0x2f,// [signed 2-byte constant] bra = 0x28,// [signed 2-byte constant] eq = 0x29, ge = 0x2a, gt = 0x2b, le = 0x2c, lt = 0x2d, ne = 0x2e, // Literals 0..31 = (lit0 + literal) lit0 = 0x30, lit31 = 0x4f, // Registers 0..31 = (reg0 + regnum) reg0 = 0x50, reg31 = 0x6f, // Base register 0..31 = (breg0 + regnum) breg0 = 0x70,// [SLEB128 offset] breg31 = 0x8f,// [SLEB128 offset] regx = 0x90,// [ULEB128 register] fbreg = 0x91,// [SLEB128 offset] bregx = 0x92,// [ULEB128 register, SLEB128 offset] piece = 0x93,// [ULEB128 size of piece addressed] deref_size = 0x94,// [1-byte size of data retrieved] xderef_size = 0x95,// [1-byte size of data retrieved] nop = 0x96, // DWARF 3 push_object_address = 0x97, call2 = 0x98,// [2-byte offset of DIE] call4 = 0x99,// [4-byte offset of DIE] call_ref = 0x9a,// [4- or 8-byte offset of DIE] form_tls_address = 0x9b, call_frame_cfa = 0x9c, bit_piece = 0x9d,// [ULEB128 size, ULEB128 offset] // DWARF 4 implicit_value = 0x9e,// [ULEB128 size, block of that size] stack_value = 0x9f, lo_user = 0xe0, hi_user = 0xff, }; std::string to_string(DW_OP v); // DW_AT::encoding constants (DWARF4 section 7.8 figure 25) enum class DW_ATE { address = 0x01, boolean = 0x02, complex_float = 0x03, float_ = 0x04, signed_ = 0x05, signed_char = 0x06, unsigned_ = 0x07, unsigned_char = 0x08, imaginary_float = 0x09, packed_decimal = 0x0a, numeric_string = 0x0b, edited = 0x0c, signed_fixed = 0x0d, unsigned_fixed = 0x0e, decimal_float = 0x0f, // DWARF 4 UTF = 0x10, lo_user = 0x80, hi_user = 0xff, }; std::string to_string(DW_ATE v); // DW_AT::decimal_sign constants (DWARF4 section 7.8 figure 26) enum class DW_DS { unsigned_ = 0x01, leading_overpunch = 0x02, trailing_overpunch = 0x03, leading_separate = 0x04, trailing_separate = 0x05, }; std::string to_string(DW_DS v); // DW_AT::endianity constants (DWARF4 section 7.8 figure 27) enum class DW_END { default_ = 0x00, big = 0x01, little = 0x02, lo_user = 0x40, hi_user = 0xff, }; std::string to_string(DW_END v); // DW_AT::accessibility constants (DWARF4 section 7.9 figure 28) enum class DW_ACCESS { public_ = 0x01, protected_ = 0x02, private_ = 0x03, }; std::string to_string(DW_ACCESS v); // DW_AT::visibility constants (DWARF4 section 7.10 figure 29) enum class DW_VIS { local = 0x01, exported = 0x02, qualified = 0x03, }; std::string to_string(DW_VIS v); // DW_AT::virtuality constants (DWARF4 section 7.11 figure 30) enum class DW_VIRTUALITY { none = 0x00, virtual_ = 0x01, pure_virtual = 0x02, }; std::string to_string(DW_VIRTUALITY v); // DW_AT::language constants (DWARF4 section 7.12 figure 31) enum class DW_LANG { C89 = 0x0001,// Lower bound 0 C = 0x0002,// Lower bound 0 Ada83 = 0x0003,// Lower bound 1 C_plus_plus = 0x0004,// Lower bound 0 Cobol74 = 0x0005,// Lower bound 1 Cobol85 = 0x0006,// Lower bound 1 Fortran77 = 0x0007,// Lower bound 1 Fortran90 = 0x0008,// Lower bound 1 Pascal83 = 0x0009,// Lower bound 1 Modula2 = 0x000a,// Lower bound 1 Java = 0x000b,// Lower bound 0 C99 = 0x000c,// Lower bound 0 Ada95 = 0x000d,// Lower bound 1 Fortran95 = 0x000e,// Lower bound 1 PLI = 0x000f,// Lower bound 1 ObjC = 0x0010,// Lower bound 0 ObjC_plus_plus = 0x0011,// Lower bound 0 UPC = 0x0012,// Lower bound 0 D = 0x0013,// Lower bound 0 Python = 0x0014,// Lower bound 0 lo_user = 0x8000, hi_user = 0xffff, }; std::string to_string(DW_LANG v); // DW_AT::identifier_case constants (DWARF4 section 7.14 figure 32) enum class DW_ID { case_sensitive = 0x00, up_case = 0x01, down_case = 0x02, case_insensitive = 0x03, }; std::string to_string(DW_ID v); // DW_AT::calling_convention constants (DWARF4 section 7.15 figure 33) enum class DW_CC { normal = 0x01, program = 0x02, nocall = 0x03, lo_user = 0x40, hi_user = 0xff, }; std::string to_string(DW_CC v); // DW_AT::inline constants (DWARF4 section 7.16 figure 34) enum class DW_INL { not_inlined = 0x00, inlined = 0x01, declared_not_inlined = 0x02, declared_inlined = 0x03, }; std::string to_string(DW_INL v); // DW_AT::ordering constants (DWARF4 section 7.17 figure 35) enum class DW_ORD { row_major = 0x00, col_major = 0x01, }; std::string to_string(DW_ORD v); // DW_AT::discr_list constants (DWARF4 section 7.18 figure 36) enum class DW_DSC { label = 0x00, range = 0x01, }; std::string to_string(DW_DSC v); // Line number standard opcodes (DWARF4 section 7.21 figure 37) enum class DW_LNS { copy = 0x01, advance_pc = 0x02, advance_line = 0x03, set_file = 0x04, set_column = 0x05, negate_stmt = 0x06, set_basic_block = 0x07, const_add_pc = 0x08, fixed_advance_pc = 0x09, // DWARF 3 set_prologue_end = 0x0a, set_epilogue_begin = 0x0b, set_isa = 0x0c, }; std::string to_string(DW_LNS v); // Line number extended opcodes (DWARF4 section 7.21 figure 38) enum class DW_LNE { end_sequence = 0x01, set_address = 0x02, define_file = 0x03, // DWARF 4 set_discriminator = 0x04, // DWARF 3 lo_user = 0x80, hi_user = 0xff, }; std::string to_string(DW_LNE v); DWARFPP_END_NAMESPACE #endif