Index: kernel/generic/include/debug/constants.h =================================================================== --- kernel/generic/include/debug/constants.h (revision 63ed840d02da9329fdc2a112bbfd6767024f1b49) +++ kernel/generic/include/debug/constants.h (revision 3e05a6914c2f7b39feb950dafa664c07aadc5ff1) @@ -31,19 +31,219 @@ enum { - DW_SECT_INFO = 1, // .debug_info.dwo - DW_SECT_ABBREV = 3, // .debug_abbrev.dwo - DW_SECT_LINE = 4, // .debug_line.dwo - DW_SECT_LOCLISTS = 5, // .debug_loclists.dwo - DW_SECT_STR_OFFSETS = 6, // .debug_str_offsets.dwo - DW_SECT_MACRO = 7, // .debug_macro.dwo - DW_SECT_RNGLISTS = 8, // .debug_rnglists.dwo -}; - -// ^(DW_[^ ]*) [‡† ]*([^ ]*).* - -#define CVAL(name, value) name = value, - -enum { -#include "constants/dw_ut.inc" + DW_SECT_INFO = 1, // .debug_info.dwo + DW_SECT_ABBREV = 3, // .debug_abbrev.dwo + DW_SECT_LINE = 4, // .debug_line.dwo + DW_SECT_LOCLISTS = 5, // .debug_loclists.dwo + DW_SECT_STR_OFFSETS = 6, // .debug_str_offsets.dwo + DW_SECT_MACRO = 7, // .debug_macro.dwo + DW_SECT_RNGLISTS = 8, // .debug_rnglists.dwo + + DW_SECT_MAX, +}; + +enum { + DW_ACCESS_public = 0x01, + DW_ACCESS_protected = 0x02, + DW_ACCESS_private = 0x03, + + DW_ACCESS_MAX, +}; + +enum { + DW_AT_sibling = 0x01, + DW_AT_location = 0x02, + DW_AT_name = 0x03, + DW_AT_reserved_0x04 = 0x04, + DW_AT_fund_type = 0x05, + DW_AT_mod_fund_type = 0x06, + DW_AT_user_def_type = 0x07, + DW_AT_mod_u_d_type = 0x08, + DW_AT_ordering = 0x09, + DW_AT_subscr_data = 0x0a, + DW_AT_byte_size = 0x0b, + DW_AT_bit_offset = 0x0c, + DW_AT_bit_size = 0x0d, + DW_AT_reserved_0x0e = 0x0e, + DW_AT_unused8 = 0x0f, + DW_AT_stmt_list = 0x10, + DW_AT_low_pc = 0x11, + DW_AT_high_pc = 0x12, + DW_AT_language = 0x13, + DW_AT_member = 0x14, + DW_AT_discr = 0x15, + DW_AT_discr_value = 0x16, + DW_AT_visibility = 0x17, + DW_AT_import = 0x18, + DW_AT_string_length = 0x19, + DW_AT_common_reference = 0x1a, + DW_AT_comp_dir = 0x1b, + DW_AT_const_value = 0x1c, + DW_AT_containing_type = 0x1d, + DW_AT_default_value = 0x1e, + DW_AT_reserved_0x1f = 0x1f, + DW_AT_inline = 0x20, + DW_AT_is_optional = 0x21, + DW_AT_lower_bound = 0x22, + DW_AT_reserved_0x23 = 0x23, + DW_AT_reserved_0x24 = 0x24, + DW_AT_producer = 0x25, + DW_AT_reserved_0x26 = 0x26, + DW_AT_prototyped = 0x27, + DW_AT_reserved_0x28 = 0x28, + DW_AT_reserved_0x29 = 0x29, + DW_AT_return_addr = 0x2a, + DW_AT_reserved_0x2b = 0x2b, + DW_AT_start_scope = 0x2c, + DW_AT_reserved_0x2d = 0x2d, + DW_AT_bit_stride = 0x2e, + DW_AT_upper_bound = 0x2f, + DW_AT_virtual = 0x30, + DW_AT_abstract_origin = 0x31, + DW_AT_accessibility = 0x32, + DW_AT_address_class = 0x33, + DW_AT_artificial = 0x34, + DW_AT_base_types = 0x35, + DW_AT_calling_convention = 0x36, + DW_AT_count = 0x37, + DW_AT_data_member_location = 0x38, + DW_AT_decl_column = 0x39, + DW_AT_decl_file = 0x3a, + DW_AT_decl_line = 0x3b, + DW_AT_declaration = 0x3c, + DW_AT_discr_list = 0x3d, + DW_AT_encoding = 0x3e, + DW_AT_external = 0x3f, + DW_AT_frame_base = 0x40, + DW_AT_friend = 0x41, + DW_AT_identifier_case = 0x42, + DW_AT_macro_info = 0x43, + DW_AT_namelist_item = 0x44, + DW_AT_priority = 0x45, + DW_AT_segment = 0x46, + DW_AT_specification = 0x47, + DW_AT_static_link = 0x48, + DW_AT_type = 0x49, + DW_AT_use_location = 0x4a, + DW_AT_variable_parameter = 0x4b, + DW_AT_virtuality = 0x4c, + DW_AT_vtable_elem_location = 0x4d, + DW_AT_allocated = 0x4e, + DW_AT_associated = 0x4f, + DW_AT_data_location = 0x50, + DW_AT_byte_stride = 0x51, + DW_AT_entry_pc = 0x52, + DW_AT_use_UTF8 = 0x53, + DW_AT_extension = 0x54, + DW_AT_ranges = 0x55, + DW_AT_trampoline = 0x56, + DW_AT_call_column = 0x57, + DW_AT_call_file = 0x58, + DW_AT_call_line = 0x59, + DW_AT_description = 0x5a, + DW_AT_binary_scale = 0x5b, + DW_AT_decimal_scale = 0x5c, + DW_AT_small = 0x5d, + DW_AT_decimal_sign = 0x5e, + DW_AT_digit_count = 0x5f, + DW_AT_picture_string = 0x60, + DW_AT_mutable = 0x61, + DW_AT_threads_scaled = 0x62, + DW_AT_explicit = 0x63, + DW_AT_object_pointer = 0x64, + DW_AT_endianity = 0x65, + DW_AT_elemental = 0x66, + DW_AT_pure = 0x67, + DW_AT_recursive = 0x68, + DW_AT_signature = 0x69, + DW_AT_main_subprogram = 0x6a, + DW_AT_data_bit_offset = 0x6b, + DW_AT_const_expr = 0x6c, + DW_AT_enum_class = 0x6d, + DW_AT_linkage_name = 0x6e, + DW_AT_string_length_bit_size = 0x6f, + DW_AT_string_length_byte_size = 0x70, + DW_AT_rank = 0x71, + DW_AT_str_offsets_base = 0x72, + DW_AT_addr_base = 0x73, + DW_AT_rnglists_base = 0x74, + DW_AT_dwo_id = 0x75, + DW_AT_dwo_name = 0x76, + DW_AT_reference = 0x77, + DW_AT_rvalue_reference = 0x78, + DW_AT_macros = 0x79, + DW_AT_call_all_calls = 0x7a, + DW_AT_call_all_source_calls = 0x7b, + DW_AT_call_all_tail_calls = 0x7c, + DW_AT_call_return_pc = 0x7d, + DW_AT_call_value = 0x7e, + DW_AT_call_origin = 0x7f, + DW_AT_call_parameter = 0x80, + DW_AT_call_pc = 0x81, + DW_AT_call_tail_call = 0x82, + DW_AT_call_target = 0x83, + DW_AT_call_target_clobbered = 0x84, + DW_AT_call_data_location = 0x85, + DW_AT_call_data_value = 0x86, + DW_AT_noreturn = 0x87, + DW_AT_alignment = 0x88, + DW_AT_export_symbols = 0x89, + DW_AT_deleted = 0x8a, + DW_AT_defaulted = 0x8b, + DW_AT_loclists_base = 0x8c, + + DW_AT_MAX, + + DW_AT_lo_user = 0x2000, + DW_AT_hi_user = 0x3fff, +}; + +enum { + DW_ATE_address = 0x01, + DW_ATE_boolean = 0x02, + DW_ATE_complex_float = 0x03, + DW_ATE_float = 0x04, + DW_ATE_signed = 0x05, + DW_ATE_signed_char = 0x06, + DW_ATE_unsigned = 0x07, + DW_ATE_unsigned_char = 0x08, + DW_ATE_imaginary_float = 0x09, + DW_ATE_packed_decimal = 0x0a, + DW_ATE_numeric_string = 0x0b, + DW_ATE_edited = 0x0c, + DW_ATE_signed_fixed = 0x0d, + DW_ATE_unsigned_fixed = 0x0e, + DW_ATE_decimal_float = 0x0f, + DW_ATE_UTF = 0x10, + DW_ATE_UCS = 0x11, + DW_ATE_ASCII = 0x12, + + DW_ATE_MAX, + + DW_ATE_lo_user = 0x80, + DW_ATE_hi_user = 0xff, +}; + +enum { + DW_CC_normal = 0x01, + DW_CC_program = 0x02, + DW_CC_nocall = 0x03, + DW_CC_pass_by_reference = 0x04, + DW_CC_pass_by_value = 0x05, + + DW_CC_MAX, + + DW_CC_lo_user = 0x40, + DW_CC_hi_user = 0xff, +}; + +enum { + DW_UT_compile = 1, + DW_UT_type = 2, + DW_UT_partial = 3, + DW_UT_skeleton = 4, + DW_UT_split_compile = 5, + DW_UT_split_type = 6, + + DW_UT_MAX, DW_UT_lo_user = 0x80, @@ -52,5 +252,81 @@ enum { -#include "constants/dw_tag.inc" + DW_TAG_array_type = 0x01, + DW_TAG_class_type = 0x02, + DW_TAG_entry_point = 0x03, + DW_TAG_enumeration_type = 0x04, + DW_TAG_formal_parameter = 0x05, + DW_TAG_global_subroutine = 0x06, + DW_TAG_global_variable = 0x07, + DW_TAG_imported_declaration = 0x08, + DW_TAG_reserved_0x09 = 0x09, + DW_TAG_label = 0x0a, + DW_TAG_lexical_block = 0x0b, + DW_TAG_local_variable = 0x0c, + DW_TAG_member = 0x0d, + DW_TAG_reserved_0x0e = 0x0e, + DW_TAG_pointer_type = 0x0f, + DW_TAG_reference_type = 0x10, + DW_TAG_compile_unit = 0x11, + DW_TAG_string_type = 0x12, + DW_TAG_structure_type = 0x13, + DW_TAG_subroutine = 0x14, + DW_TAG_subroutine_type = 0x15, + DW_TAG_typedef = 0x16, + DW_TAG_union_type = 0x17, + DW_TAG_unspecified_parameters = 0x18, + DW_TAG_variant = 0x19, + DW_TAG_common_block = 0x1a, + DW_TAG_common_inclusion = 0x1b, + DW_TAG_inheritance = 0x1c, + DW_TAG_inlined_subroutine = 0x1d, + DW_TAG_module = 0x1e, + DW_TAG_ptr_to_member_type = 0x1f, + DW_TAG_set_type = 0x20, + DW_TAG_subrange_type = 0x21, + DW_TAG_with_stmt = 0x22, + DW_TAG_access_declaration = 0x23, + DW_TAG_base_type = 0x24, + DW_TAG_catch_block = 0x25, + DW_TAG_const_type = 0x26, + DW_TAG_constant = 0x27, + DW_TAG_enumerator = 0x28, + DW_TAG_file_type = 0x29, + DW_TAG_friend = 0x2a, + DW_TAG_namelist = 0x2b, + DW_TAG_namelist_item = 0x2c, + DW_TAG_packed_type = 0x2d, + DW_TAG_subprogram = 0x2e, + DW_TAG_template_type_parameter = 0x2f, + DW_TAG_template_value_parameter = 0x30, + DW_TAG_thrown_type = 0x31, + DW_TAG_try_block = 0x32, + DW_TAG_variant_part = 0x33, + DW_TAG_variable = 0x34, + DW_TAG_volatile_type = 0x35, + DW_TAG_dwarf_procedure = 0x36, + DW_TAG_restrict_type = 0x37, + DW_TAG_interface_type = 0x38, + DW_TAG_namespace = 0x39, + DW_TAG_imported_module = 0x3a, + DW_TAG_unspecified_type = 0x3b, + DW_TAG_partial_unit = 0x3c, + DW_TAG_imported_unit = 0x3d, + DW_TAG_mutable_type = 0x3e, + DW_TAG_condition = 0x3f, + DW_TAG_shared_type = 0x40, + DW_TAG_type_unit = 0x41, + DW_TAG_rvalue_reference_type = 0x42, + DW_TAG_template_alias = 0x43, + DW_TAG_coarray_type = 0x44, + DW_TAG_generic_subrange = 0x45, + DW_TAG_dynamic_type = 0x46, + DW_TAG_atomic_type = 0x47, + DW_TAG_call_site = 0x48, + DW_TAG_call_site_parameter = 0x49, + DW_TAG_skeleton_unit = 0x4a, + DW_TAG_immutable_type = 0x4b, + + DW_TAG_MAX, DW_TAG_lo_user = 0x4080, @@ -59,16 +335,224 @@ enum { -#include "constants/dw_at.inc" - - DW_AT_lo_user = 0x2000, - DW_AT_hi_user = 0x3fff, -}; - -enum { -#include "constants/dw_form.inc" -}; - -enum { -#include "constants/dw_op.inc" + DW_FORM_addr = 0x01, + DW_FORM_reserved_0x02 = 0x02, + DW_FORM_block2 = 0x03, + DW_FORM_block4 = 0x04, + DW_FORM_data2 = 0x05, + DW_FORM_data4 = 0x06, + DW_FORM_data8 = 0x07, + DW_FORM_string = 0x08, + DW_FORM_block = 0x09, + DW_FORM_block1 = 0x0a, + DW_FORM_data1 = 0x0b, + DW_FORM_flag = 0x0c, + DW_FORM_sdata = 0x0d, + DW_FORM_strp = 0x0e, + DW_FORM_udata = 0x0f, + DW_FORM_ref_addr = 0x10, + DW_FORM_ref1 = 0x11, + DW_FORM_ref2 = 0x12, + DW_FORM_ref4 = 0x13, + DW_FORM_ref8 = 0x14, + DW_FORM_ref_udata = 0x15, + DW_FORM_indirect = 0x16, + DW_FORM_sec_offset = 0x17, + DW_FORM_exprloc = 0x18, + DW_FORM_flag_present = 0x19, + DW_FORM_strx = 0x1a, + DW_FORM_addrx = 0x1b, + DW_FORM_ref_sup4 = 0x1c, + DW_FORM_strp_sup = 0x1d, + DW_FORM_data16 = 0x1e, + DW_FORM_line_strp = 0x1f, + DW_FORM_ref_sig8 = 0x20, + DW_FORM_implicit_const = 0x21, + DW_FORM_loclistx = 0x22, + DW_FORM_rnglistx = 0x23, + DW_FORM_ref_sup8 = 0x24, + DW_FORM_strx1 = 0x25, + DW_FORM_strx2 = 0x26, + DW_FORM_strx3 = 0x27, + DW_FORM_strx4 = 0x28, + DW_FORM_addrx1 = 0x29, + DW_FORM_addrx2 = 0x2a, + DW_FORM_addrx3 = 0x2b, + DW_FORM_addrx4 = 0x2c, + + DW_FORM_MAX, +}; + +enum { + DW_OP_reg = 0x01, + DW_OP_basereg = 0x02, + DW_OP_addr = 0x03, + DW_OP_const = 0x04, + DW_OP_deref2 = 0x05, + DW_OP_deref = 0x06, + DW_OP_add = 0x07, + DW_OP_const1u = 0x08, + DW_OP_const1s = 0x09, + DW_OP_const2u = 0x0a, + DW_OP_const2s = 0x0b, + DW_OP_const4u = 0x0c, + DW_OP_const4s = 0x0d, + DW_OP_const8u = 0x0e, + DW_OP_const8s = 0x0f, + DW_OP_constu = 0x10, + DW_OP_consts = 0x11, + DW_OP_dup = 0x12, + DW_OP_drop = 0x13, + DW_OP_over = 0x14, + DW_OP_pick = 0x15, + DW_OP_swap = 0x16, + DW_OP_rot = 0x17, + DW_OP_xderef = 0x18, + DW_OP_abs = 0x19, + DW_OP_and = 0x1a, + DW_OP_div = 0x1b, + DW_OP_minus = 0x1c, + DW_OP_mod = 0x1d, + DW_OP_mul = 0x1e, + DW_OP_neg = 0x1f, + DW_OP_not = 0x20, + DW_OP_or = 0x21, + DW_OP_plus = 0x22, + DW_OP_plus_uconst = 0x23, + DW_OP_shl = 0x24, + DW_OP_shr = 0x25, + DW_OP_shra = 0x26, + DW_OP_xor = 0x27, + DW_OP_bra = 0x28, + DW_OP_eq = 0x29, + DW_OP_ge = 0x2a, + DW_OP_gt = 0x2b, + DW_OP_le = 0x2c, + DW_OP_lt = 0x2d, + DW_OP_ne = 0x2e, + DW_OP_skip = 0x2f, + DW_OP_lit0 = 0x30, + DW_OP_lit1 = 0x31, + DW_OP_lit2 = 0x32, + DW_OP_lit3 = 0x33, + DW_OP_lit4 = 0x34, + DW_OP_lit5 = 0x35, + DW_OP_lit6 = 0x36, + DW_OP_lit7 = 0x37, + DW_OP_lit8 = 0x38, + DW_OP_lit9 = 0x39, + DW_OP_lit10 = 0x3a, + DW_OP_lit11 = 0x3b, + DW_OP_lit12 = 0x3c, + DW_OP_lit13 = 0x3d, + DW_OP_lit14 = 0x3e, + DW_OP_lit15 = 0x3f, + DW_OP_lit16 = 0x40, + DW_OP_lit17 = 0x41, + DW_OP_lit18 = 0x42, + DW_OP_lit19 = 0x43, + DW_OP_lit20 = 0x44, + DW_OP_lit21 = 0x45, + DW_OP_lit22 = 0x46, + DW_OP_lit23 = 0x47, + DW_OP_lit24 = 0x48, + DW_OP_lit25 = 0x49, + DW_OP_lit26 = 0x4a, + DW_OP_lit27 = 0x4b, + DW_OP_lit28 = 0x4c, + DW_OP_lit29 = 0x4d, + DW_OP_lit30 = 0x4e, + DW_OP_lit31 = 0x4f, + DW_OP_reg0 = 0x50, + DW_OP_reg1 = 0x51, + DW_OP_reg2 = 0x52, + DW_OP_reg3 = 0x53, + DW_OP_reg4 = 0x54, + DW_OP_reg5 = 0x55, + DW_OP_reg6 = 0x56, + DW_OP_reg7 = 0x57, + DW_OP_reg8 = 0x58, + DW_OP_reg9 = 0x59, + DW_OP_reg10 = 0x5a, + DW_OP_reg11 = 0x5b, + DW_OP_reg12 = 0x5c, + DW_OP_reg13 = 0x5d, + DW_OP_reg14 = 0x5e, + DW_OP_reg15 = 0x5f, + DW_OP_reg16 = 0x60, + DW_OP_reg17 = 0x61, + DW_OP_reg18 = 0x62, + DW_OP_reg19 = 0x63, + DW_OP_reg20 = 0x64, + DW_OP_reg21 = 0x65, + DW_OP_reg22 = 0x66, + DW_OP_reg23 = 0x67, + DW_OP_reg24 = 0x68, + DW_OP_reg25 = 0x69, + DW_OP_reg26 = 0x6a, + DW_OP_reg27 = 0x6b, + DW_OP_reg28 = 0x6c, + DW_OP_reg29 = 0x6d, + DW_OP_reg30 = 0x6e, + DW_OP_reg31 = 0x6f, + DW_OP_breg0 = 0x70, + DW_OP_breg1 = 0x71, + DW_OP_breg2 = 0x72, + DW_OP_breg3 = 0x73, + DW_OP_breg4 = 0x74, + DW_OP_breg5 = 0x75, + DW_OP_breg6 = 0x76, + DW_OP_breg7 = 0x77, + DW_OP_breg8 = 0x78, + DW_OP_breg9 = 0x79, + DW_OP_breg10 = 0x7a, + DW_OP_breg11 = 0x7b, + DW_OP_breg12 = 0x7c, + DW_OP_breg13 = 0x7d, + DW_OP_breg14 = 0x7e, + DW_OP_breg15 = 0x7f, + DW_OP_breg16 = 0x80, + DW_OP_breg17 = 0x81, + DW_OP_breg18 = 0x82, + DW_OP_breg19 = 0x83, + DW_OP_breg20 = 0x84, + DW_OP_breg21 = 0x85, + DW_OP_breg22 = 0x86, + DW_OP_breg23 = 0x87, + DW_OP_breg24 = 0x88, + DW_OP_breg25 = 0x89, + DW_OP_breg26 = 0x8a, + DW_OP_breg27 = 0x8b, + DW_OP_breg28 = 0x8c, + DW_OP_breg29 = 0x8d, + DW_OP_breg30 = 0x8e, + DW_OP_breg31 = 0x8f, + DW_OP_regx = 0x90, + DW_OP_fbreg = 0x91, + DW_OP_bregx = 0x92, + DW_OP_piece = 0x93, + DW_OP_deref_size = 0x94, + DW_OP_xderef_size = 0x95, + DW_OP_nop = 0x96, + DW_OP_push_object_address = 0x97, + DW_OP_call2 = 0x98, + DW_OP_call4 = 0x99, + DW_OP_call_ref = 0x9a, + DW_OP_form_tls_address = 0x9b, + DW_OP_call_frame_cfa = 0x9c, + DW_OP_bit_piece = 0x9d, + DW_OP_implicit_value = 0x9e, + DW_OP_stack_value = 0x9f, + DW_OP_implicit_pointer = 0xa0, + DW_OP_addrx = 0xa1, + DW_OP_constx = 0xa2, + DW_OP_entry_value = 0xa3, + DW_OP_const_type = 0xa4, + DW_OP_regval_type = 0xa5, + DW_OP_deref_type = 0xa6, + DW_OP_xderef_type = 0xa7, + DW_OP_convert = 0xa8, + DW_OP_reinterpret = 0xa9, + + DW_OP_MAX, DW_OP_lo_user = 0xe0, @@ -77,20 +561,33 @@ enum { -#include "constants/dw_lle.inc" -}; - -enum { -#include "constants/dw_ate.inc" - - DW_ATE_lo_user = 0x80, - DW_ATE_hi_user = 0xff, -}; - -enum { -#include "constants/dw_ds.inc" -}; - -enum { -#include "constants/dw_end.inc" + DW_LLE_end_of_list = 0x00, + DW_LLE_base_addressx = 0x01, + DW_LLE_startx_endx = 0x02, + DW_LLE_startx_length = 0x03, + DW_LLE_offset_pair = 0x04, + DW_LLE_default_location = 0x05, + DW_LLE_base_address = 0x06, + DW_LLE_start_end = 0x07, + DW_LLE_start_length = 0x08, + + DW_LLE_MAX, +}; + +enum { + DW_DS_unsigned = 0x01, + DW_DS_leading_overpunch = 0x02, + DW_DS_trailing_overpunch = 0x03, + DW_DS_leading_separate = 0x04, + DW_DS_trailing_separate = 0x05, + + DW_DS_MAX, +}; + +enum { + DW_END_default = 0x00, + DW_END_big = 0x01, + DW_END_little = 0x02, + + DW_END_MAX, DW_END_lo_user = 0x40, @@ -99,17 +596,59 @@ enum { -#include "constants/dw_access.inc" -}; - -enum { -#include "constants/dw_vis.inc" -}; - -enum { -#include "constants/dw_virtuality.inc" -}; - -enum { -#include "constants/dw_lang.inc" + DW_VIS_local = 0x01, + DW_VIS_exported = 0x02, + DW_VIS_qualified = 0x03, + + DW_VIS_MAX, +}; + +enum { + DW_VIRTUALITY_none = 0x00, + DW_VIRTUALITY_virtual = 0x01, + DW_VIRTUALITY_pure_virtual = 0x02, + + DW_VIRTUALITY_MAX, +}; + +enum { + DW_LANG_C89 = 0x01, + DW_LANG_C = 0x02, + DW_LANG_Ada83 = 0x03, + DW_LANG_C_plus_plus = 0x04, + DW_LANG_Cobol74 = 0x05, + DW_LANG_Cobol85 = 0x06, + DW_LANG_Fortran77 = 0x07, + DW_LANG_Fortran90 = 0x08, + DW_LANG_Pascal83 = 0x09, + DW_LANG_Modula2 = 0x0a, + DW_LANG_Java = 0x0b, + DW_LANG_C99 = 0x0c, + DW_LANG_Ada95 = 0x0d, + DW_LANG_Fortran95 = 0x0e, + DW_LANG_PLI = 0x0f, + DW_LANG_ObjC = 0x10, + DW_LANG_ObjC_plus_plus = 0x11, + DW_LANG_UPC = 0x12, + DW_LANG_D = 0x13, + DW_LANG_Python = 0x14, + DW_LANG_OpenCL = 0x15, + DW_LANG_Go = 0x16, + DW_LANG_Modula3 = 0x17, + DW_LANG_Haskell = 0x18, + DW_LANG_C_plus_plus_03 = 0x19, + DW_LANG_C_plus_plus_11 = 0x1a, + DW_LANG_OCaml = 0x1b, + DW_LANG_Rust = 0x1c, + DW_LANG_C11 = 0x1d, + DW_LANG_Swift = 0x1e, + DW_LANG_Julia = 0x1f, + DW_LANG_Dylan = 0x20, + DW_LANG_C_plus_plus_14 = 0x21, + DW_LANG_Fortran03 = 0x22, + DW_LANG_Fortran08 = 0x23, + DW_LANG_RenderScript = 0x24, + DW_LANG_BLISS = 0x25, + + DW_LANG_MAX, DW_LANG_lo_user = 0x8000, @@ -122,20 +661,36 @@ enum { -#include "constants/dw_id.inc" -}; - -enum { -#include "constants/dw_cc.inc" - - DW_CC_lo_user = 0x40, - DW_CC_hi_user = 0xff, -}; - -enum { -#include "constants/dw_lns.inc" -}; - -enum { -#include "constants/dw_lne.inc" + DW_ID_case_sensitive = 0x00, + DW_ID_up_case = 0x01, + DW_ID_down_case = 0x02, + DW_ID_case_insensitive = 0x03, + + DW_ID_MAX, +}; + +enum { + DW_LNS_copy = 0x01, + DW_LNS_advance_pc = 0x02, + DW_LNS_advance_line = 0x03, + DW_LNS_set_file = 0x04, + DW_LNS_set_column = 0x05, + DW_LNS_negate_stmt = 0x06, + DW_LNS_set_basic_block = 0x07, + DW_LNS_const_add_pc = 0x08, + DW_LNS_fixed_advance_pc = 0x09, + DW_LNS_set_prologue_end = 0x0a, + DW_LNS_set_epilogue_begin = 0x0b, + DW_LNS_set_isa = 0x0c, + + DW_LNS_MAX, +}; + +enum { + DW_LNE_end_sequence = 0x01, + DW_LNE_set_address = 0x02, + DW_LNE_define_file = 0x03, + DW_LNE_set_discriminator = 0x04, + + DW_LNE_MAX, DW_LNE_lo_user = 0x80, @@ -144,5 +699,11 @@ enum { -#include "constants/dw_lnct.inc" + DW_LNCT_path = 0x1, + DW_LNCT_directory_index = 0x2, + DW_LNCT_timestamp = 0x3, + DW_LNCT_size = 0x4, + DW_LNCT_MD5 = 0x5, + + DW_LNCT_MAX, DW_LNCT_lo_user = 0x2000, @@ -150,24 +711,116 @@ }; -#undef CVAL - -typedef unsigned dw_ut_t; -typedef unsigned dw_tag_t; -typedef unsigned dw_at_t; -typedef unsigned dw_form_t; -typedef unsigned dw_op_t; -typedef unsigned dw_lle_t; -typedef unsigned dw_ate_t; -typedef unsigned dw_ds_t; -typedef unsigned dw_end_t; -typedef unsigned dw_access_t; -typedef unsigned dw_vis_t; -typedef unsigned dw_virtuality_t; -typedef unsigned dw_lang_t; -typedef unsigned dw_id_t; -typedef unsigned dw_cc_t; -typedef unsigned dw_lns_t; -typedef unsigned dw_lne_t; -typedef unsigned dw_lnct_t; +enum { + DW_INL_not_inlined = 0x00, + DW_INL_inlined = 0x01, + DW_INL_declared_not_inlined = 0x02, + DW_INL_declared_inlined = 0x03, + + DW_INL_MAX, +}; + +enum { + DW_ORD_row_major = 0x00, + DW_ORD_col_major = 0x01, + + DW_ORD_MAX, +}; + +enum { + DW_DSC_label = 0x00, + DW_DSC_range = 0x01, + + DW_DSC_MAX, +}; + +enum { + DW_IDX_compile_unit = 1, + DW_IDX_type_unit = 2, + DW_IDX_die_offset = 3, + DW_IDX_parent = 4, + DW_IDX_type_hash = 5, + + DW_IDX_MAX, + + DW_IDX_lo_user = 0x2000, + DW_IDX_hi_user = 0x3fff, +}; + +enum { + DW_DEFAULTED_no = 0x00, + DW_DEFAULTED_in_class = 0x01, + DW_DEFAULTED_out_of_class = 0x02, + + DW_DEFAULTED_MAX, +}; + +enum { + DW_MACRO_define = 0x01, + DW_MACRO_undef = 0x02, + DW_MACRO_start_file = 0x03, + DW_MACRO_end_file = 0x04, + DW_MACRO_define_strp = 0x05, + DW_MACRO_undef_strp = 0x06, + DW_MACRO_import = 0x07, + DW_MACRO_define_sup = 0x08, + DW_MACRO_undef_sup = 0x09, + DW_MACRO_import_sup = 0x0a, + DW_MACRO_define_strx = 0x0b, + DW_MACRO_undef_strx = 0x0c, + + DW_MACRO_MAX, + + DW_MACRO_lo_user = 0xe0, + DW_MACRO_hi_user = 0xff, +}; + +enum { + DW_CFA_nop = 0, + DW_CFA_set_loc = 0x01, + DW_CFA_advance_loc1 = 0x02, + DW_CFA_advance_loc2 = 0x03, + DW_CFA_advance_loc4 = 0x04, + DW_CFA_offset_extended = 0x05, + DW_CFA_restore_extended = 0x06, + DW_CFA_undefined = 0x07, + DW_CFA_same_value = 0x08, + DW_CFA_register = 0x09, + DW_CFA_remember_state = 0x0a, + DW_CFA_restore_state = 0x0b, + DW_CFA_def_cfa = 0x0c, + DW_CFA_def_cfa_register = 0x0d, + DW_CFA_def_cfa_offset = 0x0e, + DW_CFA_def_cfa_expression = 0x0f, + DW_CFA_expression = 0x10, + DW_CFA_offset_extended_sf = 0x11, + DW_CFA_def_cfa_sf = 0x12, + DW_CFA_def_cfa_offset_sf = 0x13, + DW_CFA_val_offset = 0x14, + DW_CFA_val_offset_sf = 0x15, + DW_CFA_val_expression = 0x16, + + DW_CFA_MAX, + + DW_CFA_lo_user = 0x1c, + DW_CFA_hi_user = 0x3f, + + /* These hold extra data in the 6 low-order bits. */ + DW_CFA_advance_loc = 0x40, + DW_CFA_offset = 0x80, + DW_CFA_restore = 0xc0, +}; + +enum { + DW_RLE_end_of_list = 0x00, + DW_RLE_base_addressx = 0x01, + DW_RLE_startx_endx = 0x02, + DW_RLE_startx_length = 0x03, + DW_RLE_offset_pair = 0x04, + DW_RLE_base_address = 0x05, + DW_RLE_start_end = 0x06, + DW_RLE_start_length = 0x07, + + DW_RLE_MAX, +}; #endif /* DWARFS_CONSTANTS_H_ */ Index: kernel/generic/include/debug/constants/dw_access.inc =================================================================== --- kernel/generic/include/debug/constants/dw_access.inc (revision 63ed840d02da9329fdc2a112bbfd6767024f1b49) +++ (revision ) @@ -1,3 +1,0 @@ -CVAL(DW_ACCESS_public, 0x01) -CVAL(DW_ACCESS_protected, 0x02) -CVAL(DW_ACCESS_private, 0x03) Index: kernel/generic/include/debug/constants/dw_at.inc =================================================================== --- kernel/generic/include/debug/constants/dw_at.inc (revision 63ed840d02da9329fdc2a112bbfd6767024f1b49) +++ (revision ) @@ -1,121 +1,0 @@ -CVAL(DW_AT_sibling, 0x01) -CVAL(DW_AT_location, 0x02) -CVAL(DW_AT_name, 0x03) -CVAL(DW_AT_ordering, 0x09) -CVAL(DW_AT_byte_size, 0x0b) -CVAL(DW_AT_bit_offset, 0x0c) -CVAL(DW_AT_bit_size, 0x0d) -CVAL(DW_AT_stmt_list, 0x10) -CVAL(DW_AT_low_pc, 0x11) -CVAL(DW_AT_high_pc, 0x12) -CVAL(DW_AT_language, 0x13) -CVAL(DW_AT_discr, 0x15) -CVAL(DW_AT_discr_value, 0x16) -CVAL(DW_AT_visibility, 0x17) -CVAL(DW_AT_import, 0x18) -CVAL(DW_AT_string_length, 0x19) -CVAL(DW_AT_common_reference, 0x1a) -CVAL(DW_AT_comp_dir, 0x1b) -CVAL(DW_AT_const_value, 0x1c) -CVAL(DW_AT_containing_type, 0x1d) -CVAL(DW_AT_default_value, 0x1e) -CVAL(DW_AT_inline, 0x20) -CVAL(DW_AT_is_optional, 0x21) -CVAL(DW_AT_lower_bound, 0x22) -CVAL(DW_AT_producer, 0x25) -CVAL(DW_AT_prototyped, 0x27) -CVAL(DW_AT_return_addr, 0x2a) -CVAL(DW_AT_start_scope, 0x2c) -CVAL(DW_AT_bit_stride, 0x2e) -CVAL(DW_AT_upper_bound, 0x2f) -CVAL(DW_AT_abstract_origin, 0x31) -CVAL(DW_AT_accessibility, 0x32) -CVAL(DW_AT_address_class, 0x33) -CVAL(DW_AT_artificial, 0x34) -CVAL(DW_AT_base_types, 0x35) -CVAL(DW_AT_calling_convention, 0x36) -CVAL(DW_AT_count, 0x37) -CVAL(DW_AT_data_member_location, 0x38) -CVAL(DW_AT_decl_column, 0x39) -CVAL(DW_AT_decl_file, 0x3a) -CVAL(DW_AT_decl_line, 0x3b) -CVAL(DW_AT_declaration, 0x3c) -CVAL(DW_AT_discr_list, 0x3d) -CVAL(DW_AT_encoding, 0x3e) -CVAL(DW_AT_external, 0x3f) -CVAL(DW_AT_frame_base, 0x40) -CVAL(DW_AT_friend, 0x41) -CVAL(DW_AT_identifier_case, 0x42) -CVAL(DW_AT_macro_info, 0x43) -CVAL(DW_AT_namelist_item, 0x44) -CVAL(DW_AT_priority, 0x45) -CVAL(DW_AT_segment, 0x46) -CVAL(DW_AT_specification, 0x47) -CVAL(DW_AT_static_link, 0x48) -CVAL(DW_AT_type, 0x49) -CVAL(DW_AT_use_location, 0x4a) -CVAL(DW_AT_variable_parameter, 0x4b) -CVAL(DW_AT_virtuality, 0x4c) -CVAL(DW_AT_vtable_elem_location, 0x4d) -CVAL(DW_AT_allocated, 0x4e) -CVAL(DW_AT_associated, 0x4f) -CVAL(DW_AT_data_location, 0x50) -CVAL(DW_AT_byte_stride, 0x51) -CVAL(DW_AT_entry_pc, 0x52) -CVAL(DW_AT_use_UTF8, 0x53) -CVAL(DW_AT_extension, 0x54) -CVAL(DW_AT_ranges, 0x55) -CVAL(DW_AT_trampoline, 0x56) -CVAL(DW_AT_call_column, 0x57) -CVAL(DW_AT_call_file, 0x58) -CVAL(DW_AT_call_line, 0x59) -CVAL(DW_AT_description, 0x5a) -CVAL(DW_AT_binary_scale, 0x5b) -CVAL(DW_AT_decimal_scale, 0x5c) -CVAL(DW_AT_small, 0x5d) -CVAL(DW_AT_decimal_sign, 0x5e) -CVAL(DW_AT_digit_count, 0x5f) -CVAL(DW_AT_picture_string, 0x60) -CVAL(DW_AT_mutable, 0x61) -CVAL(DW_AT_threads_scaled, 0x62) -CVAL(DW_AT_explicit, 0x63) -CVAL(DW_AT_object_pointer, 0x64) -CVAL(DW_AT_endianity, 0x65) -CVAL(DW_AT_elemental, 0x66) -CVAL(DW_AT_pure, 0x67) -CVAL(DW_AT_recursive, 0x68) -CVAL(DW_AT_signature, 0x69) -CVAL(DW_AT_main_subprogram, 0x6a) -CVAL(DW_AT_data_bit_offset, 0x6b) -CVAL(DW_AT_const_expr, 0x6c) -CVAL(DW_AT_enum_class, 0x6d) -CVAL(DW_AT_linkage_name, 0x6e) -CVAL(DW_AT_string_length_bit_size, 0x6f) -CVAL(DW_AT_string_length_byte_size, 0x70) -CVAL(DW_AT_rank, 0x71) -CVAL(DW_AT_str_offsets_base, 0x72) -CVAL(DW_AT_addr_base, 0x73) -CVAL(DW_AT_rnglists_base, 0x74) -CVAL(DW_AT_dwo_name, 0x76) -CVAL(DW_AT_reference, 0x77) -CVAL(DW_AT_rvalue_reference, 0x78) -CVAL(DW_AT_macros, 0x79) -CVAL(DW_AT_call_all_calls, 0x7a) -CVAL(DW_AT_call_all_source_calls, 0x7b) -CVAL(DW_AT_call_all_tail_calls, 0x7c) -CVAL(DW_AT_call_return_pc, 0x7d) -CVAL(DW_AT_call_value, 0x7e) -CVAL(DW_AT_call_origin, 0x7f) -CVAL(DW_AT_call_parameter, 0x80) -CVAL(DW_AT_call_pc, 0x81) -CVAL(DW_AT_call_tail_call, 0x82) -CVAL(DW_AT_call_target, 0x83) -CVAL(DW_AT_call_target_clobbered, 0x84) -CVAL(DW_AT_call_data_location, 0x85) -CVAL(DW_AT_call_data_value, 0x86) -CVAL(DW_AT_noreturn, 0x87) -CVAL(DW_AT_alignment, 0x88) -CVAL(DW_AT_export_symbols, 0x89) -CVAL(DW_AT_deleted, 0x8a) -CVAL(DW_AT_defaulted, 0x8b) -CVAL(DW_AT_loclists_base, 0x8c) Index: kernel/generic/include/debug/constants/dw_ate.inc =================================================================== --- kernel/generic/include/debug/constants/dw_ate.inc (revision 63ed840d02da9329fdc2a112bbfd6767024f1b49) +++ (revision ) @@ -1,18 +1,0 @@ -CVAL(DW_ATE_address, 0x01) -CVAL(DW_ATE_boolean, 0x02) -CVAL(DW_ATE_complex_float, 0x03) -CVAL(DW_ATE_float, 0x04) -CVAL(DW_ATE_signed, 0x05) -CVAL(DW_ATE_signed_char, 0x06) -CVAL(DW_ATE_unsigned, 0x07) -CVAL(DW_ATE_unsigned_char, 0x08) -CVAL(DW_ATE_imaginary_float, 0x09) -CVAL(DW_ATE_packed_decimal, 0x0a) -CVAL(DW_ATE_numeric_string, 0x0b) -CVAL(DW_ATE_edited, 0x0c) -CVAL(DW_ATE_signed_fixed, 0x0d) -CVAL(DW_ATE_unsigned_fixed, 0x0e) -CVAL(DW_ATE_decimal_float, 0x0f) -CVAL(DW_ATE_UTF, 0x10) -CVAL(DW_ATE_UCS, 0x11) -CVAL(DW_ATE_ASCII, 0x12) Index: kernel/generic/include/debug/constants/dw_cc.inc =================================================================== --- kernel/generic/include/debug/constants/dw_cc.inc (revision 63ed840d02da9329fdc2a112bbfd6767024f1b49) +++ (revision ) @@ -1,5 +1,0 @@ -CVAL(DW_CC_normal, 0x01) -CVAL(DW_CC_program, 0x02) -CVAL(DW_CC_nocall, 0x03) -CVAL(DW_CC_pass_by_reference, 0x04) -CVAL(DW_CC_pass_by_value, 0x05) Index: kernel/generic/include/debug/constants/dw_ds.inc =================================================================== --- kernel/generic/include/debug/constants/dw_ds.inc (revision 63ed840d02da9329fdc2a112bbfd6767024f1b49) +++ (revision ) @@ -1,5 +1,0 @@ -CVAL(DW_DS_unsigned, 0x01) -CVAL(DW_DS_leading_overpunch, 0x02) -CVAL(DW_DS_trailing_overpunch, 0x03) -CVAL(DW_DS_leading_separate, 0x04) -CVAL(DW_DS_trailing_separate, 0x05) Index: kernel/generic/include/debug/constants/dw_end.inc =================================================================== --- kernel/generic/include/debug/constants/dw_end.inc (revision 63ed840d02da9329fdc2a112bbfd6767024f1b49) +++ (revision ) @@ -1,3 +1,0 @@ -CVAL(DW_END_default, 0x00) -CVAL(DW_END_big, 0x01) -CVAL(DW_END_little, 0x02) Index: kernel/generic/include/debug/constants/dw_form.inc =================================================================== --- kernel/generic/include/debug/constants/dw_form.inc (revision 63ed840d02da9329fdc2a112bbfd6767024f1b49) +++ (revision ) @@ -1,43 +1,0 @@ -CVAL(DW_FORM_addr, 0x01) -CVAL(DW_FORM_block2, 0x03) -CVAL(DW_FORM_block4, 0x04) -CVAL(DW_FORM_data2, 0x05) -CVAL(DW_FORM_data4, 0x06) -CVAL(DW_FORM_data8, 0x07) -CVAL(DW_FORM_string, 0x08) -CVAL(DW_FORM_block, 0x09) -CVAL(DW_FORM_block1, 0x0a) -CVAL(DW_FORM_data1, 0x0b) -CVAL(DW_FORM_flag, 0x0c) -CVAL(DW_FORM_sdata, 0x0d) -CVAL(DW_FORM_strp, 0x0e) -CVAL(DW_FORM_udata, 0x0f) -CVAL(DW_FORM_ref_addr, 0x10) -CVAL(DW_FORM_ref1, 0x11) -CVAL(DW_FORM_ref2, 0x12) -CVAL(DW_FORM_ref4, 0x13) -CVAL(DW_FORM_ref8, 0x14) -CVAL(DW_FORM_ref_udata, 0x15) -CVAL(DW_FORM_indirect, 0x16) -CVAL(DW_FORM_sec_offset, 0x17) -CVAL(DW_FORM_exprloc, 0x18) -CVAL(DW_FORM_flag_present, 0x19) -CVAL(DW_FORM_strx, 0x1a) -CVAL(DW_FORM_addrx, 0x1b) -CVAL(DW_FORM_ref_sup4, 0x1c) -CVAL(DW_FORM_strp_sup, 0x1d) -CVAL(DW_FORM_data16, 0x1e) -CVAL(DW_FORM_line_strp, 0x1f) -CVAL(DW_FORM_ref_sig8, 0x20) -CVAL(DW_FORM_implicit_const, 0x21) -CVAL(DW_FORM_loclistx, 0x22) -CVAL(DW_FORM_rnglistx, 0x23) -CVAL(DW_FORM_ref_sup8, 0x24) -CVAL(DW_FORM_strx1, 0x25) -CVAL(DW_FORM_strx2, 0x26) -CVAL(DW_FORM_strx3, 0x27) -CVAL(DW_FORM_strx4, 0x28) -CVAL(DW_FORM_addrx1, 0x29) -CVAL(DW_FORM_addrx2, 0x2a) -CVAL(DW_FORM_addrx3, 0x2b) -CVAL(DW_FORM_addrx4, 0x2c) Index: kernel/generic/include/debug/constants/dw_id.inc =================================================================== --- kernel/generic/include/debug/constants/dw_id.inc (revision 63ed840d02da9329fdc2a112bbfd6767024f1b49) +++ (revision ) @@ -1,4 +1,0 @@ -CVAL(DW_ID_case_sensitive, 0x00) -CVAL(DW_ID_up_case, 0x01) -CVAL(DW_ID_down_case, 0x02) -CVAL(DW_ID_case_insensitive, 0x03) Index: kernel/generic/include/debug/constants/dw_lang.inc =================================================================== --- kernel/generic/include/debug/constants/dw_lang.inc (revision 63ed840d02da9329fdc2a112bbfd6767024f1b49) +++ (revision ) @@ -1,37 +1,0 @@ -CVAL(DW_LANG_C89, 0x0001) -CVAL(DW_LANG_C, 0x0002) -CVAL(DW_LANG_Ada83, 0x0003) -CVAL(DW_LANG_C_plus_plus, 0x0004) -CVAL(DW_LANG_Cobol74, 0x0005) -CVAL(DW_LANG_Cobol85, 0x0006) -CVAL(DW_LANG_Fortran77, 0x0007) -CVAL(DW_LANG_Fortran90, 0x0008) -CVAL(DW_LANG_Pascal83, 0x0009) -CVAL(DW_LANG_Modula2, 0x000a) -CVAL(DW_LANG_Java, 0x000b) -CVAL(DW_LANG_C99, 0x000c) -CVAL(DW_LANG_Ada95, 0x000d) -CVAL(DW_LANG_Fortran95, 0x000e) -CVAL(DW_LANG_PLI, 0x000f) -CVAL(DW_LANG_ObjC, 0x0010) -CVAL(DW_LANG_ObjC_plus_plus, 0x0011) -CVAL(DW_LANG_UPC, 0x0012) -CVAL(DW_LANG_D, 0x0013) -CVAL(DW_LANG_Python, 0x0014) -CVAL(DW_LANG_OpenCL, 0x0015) -CVAL(DW_LANG_Go, 0x0016) -CVAL(DW_LANG_Modula3, 0x0017) -CVAL(DW_LANG_Haskell, 0x0018) -CVAL(DW_LANG_C_plus_plus_03, 0x0019) -CVAL(DW_LANG_C_plus_plus_11, 0x001a) -CVAL(DW_LANG_OCaml, 0x001b) -CVAL(DW_LANG_Rust, 0x001c) -CVAL(DW_LANG_C11, 0x001d) -CVAL(DW_LANG_Swift, 0x001e) -CVAL(DW_LANG_Julia, 0x001f) -CVAL(DW_LANG_Dylan, 0x0020) -CVAL(DW_LANG_C_plus_plus_14, 0x0021) -CVAL(DW_LANG_Fortran03, 0x0022) -CVAL(DW_LANG_Fortran08, 0x0023) -CVAL(DW_LANG_RenderScript, 0x0024) -CVAL(DW_LANG_BLISS, 0x0025) Index: kernel/generic/include/debug/constants/dw_lle.inc =================================================================== --- kernel/generic/include/debug/constants/dw_lle.inc (revision 63ed840d02da9329fdc2a112bbfd6767024f1b49) +++ (revision ) @@ -1,9 +1,0 @@ -CVAL(DW_LLE_end_of_list, 0x00) -CVAL(DW_LLE_base_addressx, 0x01) -CVAL(DW_LLE_startx_endx, 0x02) -CVAL(DW_LLE_startx_length, 0x03) -CVAL(DW_LLE_offset_pair, 0x04) -CVAL(DW_LLE_default_location, 0x05) -CVAL(DW_LLE_base_address, 0x06) -CVAL(DW_LLE_start_end, 0x07) -CVAL(DW_LLE_start_length, 0x08) Index: kernel/generic/include/debug/constants/dw_lnct.inc =================================================================== --- kernel/generic/include/debug/constants/dw_lnct.inc (revision 63ed840d02da9329fdc2a112bbfd6767024f1b49) +++ (revision ) @@ -1,5 +1,0 @@ -CVAL(DW_LNCT_path, 0x1) -CVAL(DW_LNCT_directory_index, 0x2) -CVAL(DW_LNCT_timestamp, 0x3) -CVAL(DW_LNCT_size, 0x4) -CVAL(DW_LNCT_MD5, 0x5) Index: kernel/generic/include/debug/constants/dw_lne.inc =================================================================== --- kernel/generic/include/debug/constants/dw_lne.inc (revision 63ed840d02da9329fdc2a112bbfd6767024f1b49) +++ (revision ) @@ -1,3 +1,0 @@ -CVAL(DW_LNE_end_sequence, 0x01) -CVAL(DW_LNE_set_address, 0x02) -CVAL(DW_LNE_set_discriminator, 0x04) Index: kernel/generic/include/debug/constants/dw_lns.inc =================================================================== --- kernel/generic/include/debug/constants/dw_lns.inc (revision 63ed840d02da9329fdc2a112bbfd6767024f1b49) +++ (revision ) @@ -1,12 +1,0 @@ -CVAL(DW_LNS_copy, 0x01) -CVAL(DW_LNS_advance_pc, 0x02) -CVAL(DW_LNS_advance_line, 0x03) -CVAL(DW_LNS_set_file, 0x04) -CVAL(DW_LNS_set_column, 0x05) -CVAL(DW_LNS_negate_stmt, 0x06) -CVAL(DW_LNS_set_basic_block, 0x07) -CVAL(DW_LNS_const_add_pc, 0x08) -CVAL(DW_LNS_fixed_advance_pc, 0x09) -CVAL(DW_LNS_set_prologue_end, 0x0a) -CVAL(DW_LNS_set_epilogue_begin, 0x0b) -CVAL(DW_LNS_set_isa, 0x0c) Index: kernel/generic/include/debug/constants/dw_op.inc =================================================================== --- kernel/generic/include/debug/constants/dw_op.inc (revision 63ed840d02da9329fdc2a112bbfd6767024f1b49) +++ (revision ) @@ -1,164 +1,0 @@ -CVAL(DW_OP_addr, 0x03) -CVAL(DW_OP_deref, 0x06) -CVAL(DW_OP_const1u, 0x08) -CVAL(DW_OP_const1s, 0x09) -CVAL(DW_OP_const2u, 0x0a) -CVAL(DW_OP_const2s, 0x0b) -CVAL(DW_OP_const4u, 0x0c) -CVAL(DW_OP_const4s, 0x0d) -CVAL(DW_OP_const8u, 0x0e) -CVAL(DW_OP_const8s, 0x0f) -CVAL(DW_OP_constu, 0x10) -CVAL(DW_OP_consts, 0x11) -CVAL(DW_OP_dup, 0x12) -CVAL(DW_OP_drop, 0x13) -CVAL(DW_OP_over, 0x14) -CVAL(DW_OP_pick, 0x15) -CVAL(DW_OP_swap, 0x16) -CVAL(DW_OP_rot, 0x17) -CVAL(DW_OP_xderef, 0x18) -CVAL(DW_OP_abs, 0x19) -CVAL(DW_OP_and, 0x1a) -CVAL(DW_OP_div, 0x1b) -CVAL(DW_OP_minus, 0x1c) -CVAL(DW_OP_mod, 0x1d) -CVAL(DW_OP_mul, 0x1e) -CVAL(DW_OP_neg, 0x1f) -CVAL(DW_OP_not, 0x20) -CVAL(DW_OP_or, 0x21) -CVAL(DW_OP_plus, 0x22) -CVAL(DW_OP_plus_uconst, 0x23) -CVAL(DW_OP_shl, 0x24) -CVAL(DW_OP_shr, 0x25) -CVAL(DW_OP_shra, 0x26) -CVAL(DW_OP_xor, 0x27) -CVAL(DW_OP_bra, 0x28) -CVAL(DW_OP_eq, 0x29) -CVAL(DW_OP_ge, 0x2a) -CVAL(DW_OP_gt, 0x2b) -CVAL(DW_OP_le, 0x2c) -CVAL(DW_OP_lt, 0x2d) -CVAL(DW_OP_ne, 0x2e) -CVAL(DW_OP_skip, 0x2f) -CVAL(DW_OP_lit0, 0x30) -CVAL(DW_OP_lit1, 0x31) -CVAL(DW_OP_lit2, 0x32) -CVAL(DW_OP_lit3, 0x33) -CVAL(DW_OP_lit4, 0x34) -CVAL(DW_OP_lit5, 0x35) -CVAL(DW_OP_lit6, 0x36) -CVAL(DW_OP_lit7, 0x37) -CVAL(DW_OP_lit8, 0x38) -CVAL(DW_OP_lit9, 0x39) -CVAL(DW_OP_lit10, 0x3a) -CVAL(DW_OP_lit11, 0x3b) -CVAL(DW_OP_lit12, 0x3c) -CVAL(DW_OP_lit13, 0x3d) -CVAL(DW_OP_lit14, 0x3e) -CVAL(DW_OP_lit15, 0x3f) -CVAL(DW_OP_lit16, 0x40) -CVAL(DW_OP_lit17, 0x41) -CVAL(DW_OP_lit18, 0x42) -CVAL(DW_OP_lit19, 0x43) -CVAL(DW_OP_lit20, 0x44) -CVAL(DW_OP_lit21, 0x45) -CVAL(DW_OP_lit22, 0x46) -CVAL(DW_OP_lit23, 0x47) -CVAL(DW_OP_lit24, 0x48) -CVAL(DW_OP_lit25, 0x49) -CVAL(DW_OP_lit26, 0x4a) -CVAL(DW_OP_lit27, 0x4b) -CVAL(DW_OP_lit28, 0x4c) -CVAL(DW_OP_lit29, 0x4d) -CVAL(DW_OP_lit30, 0x4e) -CVAL(DW_OP_lit31, 0x4f) -CVAL(DW_OP_reg0, 0x50) -CVAL(DW_OP_reg1, 0x51) -CVAL(DW_OP_reg2, 0x52) -CVAL(DW_OP_reg3, 0x53) -CVAL(DW_OP_reg4, 0x54) -CVAL(DW_OP_reg5, 0x55) -CVAL(DW_OP_reg6, 0x56) -CVAL(DW_OP_reg7, 0x57) -CVAL(DW_OP_reg8, 0x58) -CVAL(DW_OP_reg9, 0x59) -CVAL(DW_OP_reg10, 0x5a) -CVAL(DW_OP_reg11, 0x5b) -CVAL(DW_OP_reg12, 0x5c) -CVAL(DW_OP_reg13, 0x5d) -CVAL(DW_OP_reg14, 0x5e) -CVAL(DW_OP_reg15, 0x5f) -CVAL(DW_OP_reg16, 0x60) -CVAL(DW_OP_reg17, 0x61) -CVAL(DW_OP_reg18, 0x62) -CVAL(DW_OP_reg19, 0x63) -CVAL(DW_OP_reg20, 0x64) -CVAL(DW_OP_reg21, 0x65) -CVAL(DW_OP_reg22, 0x66) -CVAL(DW_OP_reg23, 0x67) -CVAL(DW_OP_reg24, 0x68) -CVAL(DW_OP_reg25, 0x69) -CVAL(DW_OP_reg26, 0x6a) -CVAL(DW_OP_reg27, 0x6b) -CVAL(DW_OP_reg28, 0x6c) -CVAL(DW_OP_reg29, 0x6d) -CVAL(DW_OP_reg30, 0x6e) -CVAL(DW_OP_reg31, 0x6f) -CVAL(DW_OP_breg0, 0x70) -CVAL(DW_OP_breg1, 0x71) -CVAL(DW_OP_breg2, 0x72) -CVAL(DW_OP_breg3, 0x73) -CVAL(DW_OP_breg4, 0x74) -CVAL(DW_OP_breg5, 0x75) -CVAL(DW_OP_breg6, 0x76) -CVAL(DW_OP_breg7, 0x77) -CVAL(DW_OP_breg8, 0x78) -CVAL(DW_OP_breg9, 0x79) -CVAL(DW_OP_breg10, 0x7a) -CVAL(DW_OP_breg11, 0x7b) -CVAL(DW_OP_breg12, 0x7c) -CVAL(DW_OP_breg13, 0x7d) -CVAL(DW_OP_breg14, 0x7e) -CVAL(DW_OP_breg15, 0x7f) -CVAL(DW_OP_breg16, 0x80) -CVAL(DW_OP_breg17, 0x81) -CVAL(DW_OP_breg18, 0x82) -CVAL(DW_OP_breg19, 0x83) -CVAL(DW_OP_breg20, 0x84) -CVAL(DW_OP_breg21, 0x85) -CVAL(DW_OP_breg22, 0x86) -CVAL(DW_OP_breg23, 0x87) -CVAL(DW_OP_breg24, 0x88) -CVAL(DW_OP_breg25, 0x89) -CVAL(DW_OP_breg26, 0x8a) -CVAL(DW_OP_breg27, 0x8b) -CVAL(DW_OP_breg28, 0x8c) -CVAL(DW_OP_breg29, 0x8d) -CVAL(DW_OP_breg30, 0x8e) -CVAL(DW_OP_breg31, 0x8f) -CVAL(DW_OP_regx, 0x90) -CVAL(DW_OP_fbreg, 0x91) -CVAL(DW_OP_bregx, 0x92) -CVAL(DW_OP_piece, 0x93) -CVAL(DW_OP_deref_size, 0x94) -CVAL(DW_OP_xderef_size, 0x95) -CVAL(DW_OP_nop, 0x96) -CVAL(DW_OP_push_object_address, 0x97) -CVAL(DW_OP_call2, 0x98) -CVAL(DW_OP_call4, 0x99) -CVAL(DW_OP_call_ref, 0x9a) -CVAL(DW_OP_form_tls_address, 0x9b) -CVAL(DW_OP_call_frame_cfa, 0x9c) -CVAL(DW_OP_bit_piece, 0x9d) -CVAL(DW_OP_implicit_value, 0x9e) -CVAL(DW_OP_stack_value, 0x9f) -CVAL(DW_OP_implicit_pointer, 0xa0) -CVAL(DW_OP_addrx, 0xa1) -CVAL(DW_OP_constx, 0xa2) -CVAL(DW_OP_entry_value, 0xa3) -CVAL(DW_OP_const_type, 0xa4) -CVAL(DW_OP_regval_type, 0xa5) -CVAL(DW_OP_deref_type, 0xa6) -CVAL(DW_OP_xderef_type, 0xa7) -CVAL(DW_OP_convert, 0xa8) -CVAL(DW_OP_reinterpret, 0xa9) Index: kernel/generic/include/debug/constants/dw_tag.inc =================================================================== --- kernel/generic/include/debug/constants/dw_tag.inc (revision 63ed840d02da9329fdc2a112bbfd6767024f1b49) +++ (revision ) @@ -1,75 +1,0 @@ -CVAL(DW_TAG_array_type, 0x01) -CVAL(DW_TAG_class_type, 0x02) -CVAL(DW_TAG_entry_point, 0x03) -CVAL(DW_TAG_enumeration_type, 0x04) -CVAL(DW_TAG_formal_parameter, 0x05) -CVAL(DW_TAG_global_subroutine, 0x06) -CVAL(DW_TAG_global_variable, 0x07) -CVAL(DW_TAG_imported_declaration, 0x08) -// Reserved 0x09 -CVAL(DW_TAG_label, 0x0a) -CVAL(DW_TAG_lexical_block, 0x0b) -CVAL(DW_TAG_local_variable, 0x0c) -CVAL(DW_TAG_member, 0x0d) -// Reserved 0x0e -CVAL(DW_TAG_pointer_type, 0x0f) -CVAL(DW_TAG_reference_type, 0x10) -CVAL(DW_TAG_compile_unit, 0x11) -CVAL(DW_TAG_string_type, 0x12) -CVAL(DW_TAG_structure_type, 0x13) -CVAL(DW_TAG_subroutine, 0x14) -CVAL(DW_TAG_subroutine_type, 0x15) -CVAL(DW_TAG_typedef, 0x16) -CVAL(DW_TAG_union_type, 0x17) -CVAL(DW_TAG_unspecified_parameters, 0x18) -CVAL(DW_TAG_variant, 0x19) -CVAL(DW_TAG_common_block, 0x1a) -CVAL(DW_TAG_common_inclusion, 0x1b) -CVAL(DW_TAG_inheritance, 0x1c) -CVAL(DW_TAG_inlined_subroutine, 0x1d) -CVAL(DW_TAG_module, 0x1e) -CVAL(DW_TAG_ptr_to_member_type, 0x1f) -CVAL(DW_TAG_set_type, 0x20) -CVAL(DW_TAG_subrange_type, 0x21) -CVAL(DW_TAG_with_stmt, 0x22) -CVAL(DW_TAG_access_declaration, 0x23) -CVAL(DW_TAG_base_type, 0x24) -CVAL(DW_TAG_catch_block, 0x25) -CVAL(DW_TAG_const_type, 0x26) -CVAL(DW_TAG_constant, 0x27) -CVAL(DW_TAG_enumerator, 0x28) -CVAL(DW_TAG_file_type, 0x29) -CVAL(DW_TAG_friend, 0x2a) -CVAL(DW_TAG_namelist, 0x2b) -CVAL(DW_TAG_namelist_item, 0x2c) -CVAL(DW_TAG_packed_type, 0x2d) -CVAL(DW_TAG_subprogram, 0x2e) -CVAL(DW_TAG_template_type_parameter, 0x2f) -CVAL(DW_TAG_template_value_parameter, 0x30) -CVAL(DW_TAG_thrown_type, 0x31) -CVAL(DW_TAG_try_block, 0x32) -CVAL(DW_TAG_variant_part, 0x33) -CVAL(DW_TAG_variable, 0x34) -CVAL(DW_TAG_volatile_type, 0x35) -CVAL(DW_TAG_dwarf_procedure, 0x36) -CVAL(DW_TAG_restrict_type, 0x37) -CVAL(DW_TAG_interface_type, 0x38) -CVAL(DW_TAG_namespace, 0x39) -CVAL(DW_TAG_imported_module, 0x3a) -CVAL(DW_TAG_unspecified_type, 0x3b) -CVAL(DW_TAG_partial_unit, 0x3c) -CVAL(DW_TAG_imported_unit, 0x3d) -CVAL(DW_TAG_mutable_type, 0x3e) -CVAL(DW_TAG_condition, 0x3f) -CVAL(DW_TAG_shared_type, 0x40) -CVAL(DW_TAG_type_unit, 0x41) -CVAL(DW_TAG_rvalue_reference_type, 0x42) -CVAL(DW_TAG_template_alias, 0x43) -CVAL(DW_TAG_coarray_type, 0x44) -CVAL(DW_TAG_generic_subrange, 0x45) -CVAL(DW_TAG_dynamic_type, 0x46) -CVAL(DW_TAG_atomic_type, 0x47) -CVAL(DW_TAG_call_site, 0x48) -CVAL(DW_TAG_call_site_parameter, 0x49) -CVAL(DW_TAG_skeleton_unit, 0x4a) -CVAL(DW_TAG_immutable_type, 0x4b) Index: kernel/generic/include/debug/constants/dw_ut.inc =================================================================== --- kernel/generic/include/debug/constants/dw_ut.inc (revision 63ed840d02da9329fdc2a112bbfd6767024f1b49) +++ (revision ) @@ -1,6 +1,0 @@ -CVAL(DW_UT_compile, 1) -CVAL(DW_UT_type, 2) -CVAL(DW_UT_partial, 3) -CVAL(DW_UT_skeleton, 4) -CVAL(DW_UT_split_compile, 5) -CVAL(DW_UT_split_type, 6) Index: kernel/generic/include/debug/constants/dw_virtuality.inc =================================================================== --- kernel/generic/include/debug/constants/dw_virtuality.inc (revision 63ed840d02da9329fdc2a112bbfd6767024f1b49) +++ (revision ) @@ -1,3 +1,0 @@ -CVAL(DW_VIRTUALITY_none, 0x00) -CVAL(DW_VIRTUALITY_virtual, 0x01) -CVAL(DW_VIRTUALITY_pure_virtual, 0x02) Index: kernel/generic/include/debug/constants/dw_vis.inc =================================================================== --- kernel/generic/include/debug/constants/dw_vis.inc (revision 63ed840d02da9329fdc2a112bbfd6767024f1b49) +++ (revision ) @@ -1,3 +1,0 @@ -CVAL(DW_VIS_local, 0x01) -CVAL(DW_VIS_exported, 0x02) -CVAL(DW_VIS_qualified, 0x03) Index: kernel/generic/include/debug/names.h =================================================================== --- kernel/generic/include/debug/names.h (revision 63ed840d02da9329fdc2a112bbfd6767024f1b49) +++ kernel/generic/include/debug/names.h (revision 3e05a6914c2f7b39feb950dafa664c07aadc5ff1) @@ -27,31 +27,35 @@ */ -#ifndef DWARFS_NAMES_H_ -#define DWARFS_NAMES_H_ +#ifndef DEBUG_DWARF_NAMES_H_ +#define DEBUG_DWARF_NAMES_H_ -#define D_(infix) \ - typedef unsigned dw_##infix##_t; \ - extern const char *dw_##infix##_name(dw_##infix##_t) +#include -D_(ut); -D_(tag); -D_(at); -D_(form); -D_(op); -D_(lle); -D_(ate); -D_(ds); -D_(end); -D_(access); -D_(vis); -D_(virtuality); -D_(lang); -D_(id); -D_(cc); -D_(lns); -D_(lne); -D_(lnct); +extern const char *dw_access_name(dw_access_t); +extern const char *dw_at_name(dw_at_t); +extern const char *dw_ate_name(dw_ate_t); +extern const char *dw_cc_name(dw_cc_t); +extern const char *dw_cfa_name(dw_cfa_t); +extern const char *dw_defaulted_name(dw_defaulted_t); +extern const char *dw_ds_name(dw_ds_t); +extern const char *dw_dsc_name(dw_dsc_t); +extern const char *dw_end_name(dw_end_t); +extern const char *dw_form_name(dw_form_t); +extern const char *dw_id_name(dw_id_t); +extern const char *dw_idx_name(dw_idx_t); +extern const char *dw_inl_name(dw_inl_t); +extern const char *dw_lang_name(dw_lang_t); +extern const char *dw_lle_name(dw_lle_t); +extern const char *dw_lnct_name(dw_lnct_t); +extern const char *dw_lne_name(dw_lne_t); +extern const char *dw_lns_name(dw_lns_t); +extern const char *dw_macro_name(dw_macro_t); +extern const char *dw_op_name(dw_op_t); +extern const char *dw_ord_name(dw_ord_t); +extern const char *dw_rle_name(dw_rle_t); +extern const char *dw_tag_name(dw_tag_t); +extern const char *dw_ut_name(dw_ut_t); +extern const char *dw_virtuality_name(dw_virtuality_t); +extern const char *dw_vis_name(dw_vis_t); -#undef D_ - -#endif /* DWARFS_NAMES_H_ */ +#endif /* DEBUG_DWARF_NAMES_H_ */ Index: kernel/generic/include/debug/types.h =================================================================== --- kernel/generic/include/debug/types.h (revision 3e05a6914c2f7b39feb950dafa664c07aadc5ff1) +++ kernel/generic/include/debug/types.h (revision 3e05a6914c2f7b39feb950dafa664c07aadc5ff1) @@ -0,0 +1,61 @@ +/* + * Copyright (c) 2023 Jiří Zárevúcky + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef DEBUG_DWARF_TYPES_H_ +#define DEBUG_DWARF_TYPES_H_ + +typedef unsigned dw_access_t; +typedef unsigned dw_at_t; +typedef unsigned dw_ate_t; +typedef unsigned dw_cc_t; +typedef unsigned dw_cfa_t; +typedef unsigned dw_defaulted_t; +typedef unsigned dw_ds_t; +typedef unsigned dw_dsc_t; +typedef unsigned dw_end_t; +typedef unsigned dw_form_t; +typedef unsigned dw_id_t; +typedef unsigned dw_idx_t; +typedef unsigned dw_idx_t; +typedef unsigned dw_inl_t; +typedef unsigned dw_lang_t; +typedef unsigned dw_lle_t; +typedef unsigned dw_lnct_t; +typedef unsigned dw_lne_t; +typedef unsigned dw_lns_t; +typedef unsigned dw_macro_t; +typedef unsigned dw_op_t; +typedef unsigned dw_ord_t; +typedef unsigned dw_rle_t; +typedef unsigned dw_sect_t; +typedef unsigned dw_tag_t; +typedef unsigned dw_ut_t; +typedef unsigned dw_virtuality_t; +typedef unsigned dw_vis_t; + +#endif /* DEBUG_DWARF_TYPES_H_ */ Index: kernel/generic/src/debug/names.c =================================================================== --- kernel/generic/src/debug/names.c (revision 63ed840d02da9329fdc2a112bbfd6767024f1b49) +++ kernel/generic/src/debug/names.c (revision 3e05a6914c2f7b39feb950dafa664c07aadc5ff1) @@ -27,110 +27,775 @@ */ +#include +#include #include -#include -#include -#include - -#define CVAL(name, value) [value] = #name, + +#define ENTRY(name) [name] = #name + +static const char *const dw_access_names[] = { + ENTRY(DW_ACCESS_public), + ENTRY(DW_ACCESS_protected), + ENTRY(DW_ACCESS_private), +}; + +_Static_assert(DW_ACCESS_MAX == DW_ACCESS_private + 1); + +static const char *const dw_at_names[] = { + ENTRY(DW_AT_sibling), + ENTRY(DW_AT_location), + ENTRY(DW_AT_name), + ENTRY(DW_AT_reserved_0x04), + ENTRY(DW_AT_fund_type), + ENTRY(DW_AT_mod_fund_type), + ENTRY(DW_AT_user_def_type), + ENTRY(DW_AT_mod_u_d_type), + ENTRY(DW_AT_ordering), + ENTRY(DW_AT_subscr_data), + ENTRY(DW_AT_byte_size), + ENTRY(DW_AT_bit_offset), + ENTRY(DW_AT_bit_size), + ENTRY(DW_AT_reserved_0x0e), + ENTRY(DW_AT_unused8), + ENTRY(DW_AT_stmt_list), + ENTRY(DW_AT_low_pc), + ENTRY(DW_AT_high_pc), + ENTRY(DW_AT_language), + ENTRY(DW_AT_member), + ENTRY(DW_AT_discr), + ENTRY(DW_AT_discr_value), + ENTRY(DW_AT_visibility), + ENTRY(DW_AT_import), + ENTRY(DW_AT_string_length), + ENTRY(DW_AT_common_reference), + ENTRY(DW_AT_comp_dir), + ENTRY(DW_AT_const_value), + ENTRY(DW_AT_containing_type), + ENTRY(DW_AT_default_value), + ENTRY(DW_AT_reserved_0x1f), + ENTRY(DW_AT_inline), + ENTRY(DW_AT_is_optional), + ENTRY(DW_AT_lower_bound), + ENTRY(DW_AT_reserved_0x23), + ENTRY(DW_AT_reserved_0x24), + ENTRY(DW_AT_producer), + ENTRY(DW_AT_reserved_0x26), + ENTRY(DW_AT_prototyped), + ENTRY(DW_AT_reserved_0x28), + ENTRY(DW_AT_reserved_0x29), + ENTRY(DW_AT_return_addr), + ENTRY(DW_AT_reserved_0x2b), + ENTRY(DW_AT_start_scope), + ENTRY(DW_AT_reserved_0x2d), + ENTRY(DW_AT_bit_stride), + ENTRY(DW_AT_upper_bound), + ENTRY(DW_AT_virtual), + ENTRY(DW_AT_abstract_origin), + ENTRY(DW_AT_accessibility), + ENTRY(DW_AT_address_class), + ENTRY(DW_AT_artificial), + ENTRY(DW_AT_base_types), + ENTRY(DW_AT_calling_convention), + ENTRY(DW_AT_count), + ENTRY(DW_AT_data_member_location), + ENTRY(DW_AT_decl_column), + ENTRY(DW_AT_decl_file), + ENTRY(DW_AT_decl_line), + ENTRY(DW_AT_declaration), + ENTRY(DW_AT_discr_list), + ENTRY(DW_AT_encoding), + ENTRY(DW_AT_external), + ENTRY(DW_AT_frame_base), + ENTRY(DW_AT_friend), + ENTRY(DW_AT_identifier_case), + ENTRY(DW_AT_macro_info), + ENTRY(DW_AT_namelist_item), + ENTRY(DW_AT_priority), + ENTRY(DW_AT_segment), + ENTRY(DW_AT_specification), + ENTRY(DW_AT_static_link), + ENTRY(DW_AT_type), + ENTRY(DW_AT_use_location), + ENTRY(DW_AT_variable_parameter), + ENTRY(DW_AT_virtuality), + ENTRY(DW_AT_vtable_elem_location), + ENTRY(DW_AT_allocated), + ENTRY(DW_AT_associated), + ENTRY(DW_AT_data_location), + ENTRY(DW_AT_byte_stride), + ENTRY(DW_AT_entry_pc), + ENTRY(DW_AT_use_UTF8), + ENTRY(DW_AT_extension), + ENTRY(DW_AT_ranges), + ENTRY(DW_AT_trampoline), + ENTRY(DW_AT_call_column), + ENTRY(DW_AT_call_file), + ENTRY(DW_AT_call_line), + ENTRY(DW_AT_description), + ENTRY(DW_AT_binary_scale), + ENTRY(DW_AT_decimal_scale), + ENTRY(DW_AT_small), + ENTRY(DW_AT_decimal_sign), + ENTRY(DW_AT_digit_count), + ENTRY(DW_AT_picture_string), + ENTRY(DW_AT_mutable), + ENTRY(DW_AT_threads_scaled), + ENTRY(DW_AT_explicit), + ENTRY(DW_AT_object_pointer), + ENTRY(DW_AT_endianity), + ENTRY(DW_AT_elemental), + ENTRY(DW_AT_pure), + ENTRY(DW_AT_recursive), + ENTRY(DW_AT_signature), + ENTRY(DW_AT_main_subprogram), + ENTRY(DW_AT_data_bit_offset), + ENTRY(DW_AT_const_expr), + ENTRY(DW_AT_enum_class), + ENTRY(DW_AT_linkage_name), + ENTRY(DW_AT_string_length_bit_size), + ENTRY(DW_AT_string_length_byte_size), + ENTRY(DW_AT_rank), + ENTRY(DW_AT_str_offsets_base), + ENTRY(DW_AT_addr_base), + ENTRY(DW_AT_rnglists_base), + ENTRY(DW_AT_dwo_id), + ENTRY(DW_AT_dwo_name), + ENTRY(DW_AT_reference), + ENTRY(DW_AT_rvalue_reference), + ENTRY(DW_AT_macros), + ENTRY(DW_AT_call_all_calls), + ENTRY(DW_AT_call_all_source_calls), + ENTRY(DW_AT_call_all_tail_calls), + ENTRY(DW_AT_call_return_pc), + ENTRY(DW_AT_call_value), + ENTRY(DW_AT_call_origin), + ENTRY(DW_AT_call_parameter), + ENTRY(DW_AT_call_pc), + ENTRY(DW_AT_call_tail_call), + ENTRY(DW_AT_call_target), + ENTRY(DW_AT_call_target_clobbered), + ENTRY(DW_AT_call_data_location), + ENTRY(DW_AT_call_data_value), + ENTRY(DW_AT_noreturn), + ENTRY(DW_AT_alignment), + ENTRY(DW_AT_export_symbols), + ENTRY(DW_AT_deleted), + ENTRY(DW_AT_defaulted), + ENTRY(DW_AT_loclists_base), +}; + +_Static_assert(DW_AT_MAX == DW_AT_loclists_base + 1); + +static const char *const dw_ate_names[] = { + ENTRY(DW_ATE_address), + ENTRY(DW_ATE_boolean), + ENTRY(DW_ATE_complex_float), + ENTRY(DW_ATE_float), + ENTRY(DW_ATE_signed), + ENTRY(DW_ATE_signed_char), + ENTRY(DW_ATE_unsigned), + ENTRY(DW_ATE_unsigned_char), + ENTRY(DW_ATE_imaginary_float), + ENTRY(DW_ATE_packed_decimal), + ENTRY(DW_ATE_numeric_string), + ENTRY(DW_ATE_edited), + ENTRY(DW_ATE_signed_fixed), + ENTRY(DW_ATE_unsigned_fixed), + ENTRY(DW_ATE_decimal_float), + ENTRY(DW_ATE_UTF), + ENTRY(DW_ATE_UCS), + ENTRY(DW_ATE_ASCII), +}; + +_Static_assert(DW_ATE_MAX == DW_ATE_ASCII + 1); + +static const char *const dw_cc_names[] = { + ENTRY(DW_CC_normal), + ENTRY(DW_CC_program), + ENTRY(DW_CC_nocall), + ENTRY(DW_CC_pass_by_reference), + ENTRY(DW_CC_pass_by_value), +}; + +_Static_assert(DW_CC_MAX == DW_CC_pass_by_value + 1); static const char *const dw_ut_names[] = { -#include -}; + ENTRY(DW_UT_compile), + ENTRY(DW_UT_type), + ENTRY(DW_UT_partial), + ENTRY(DW_UT_skeleton), + ENTRY(DW_UT_split_compile), + ENTRY(DW_UT_split_type), +}; + +_Static_assert(DW_UT_MAX == DW_UT_split_type + 1); static const char *const dw_tag_names[] = { -#include -}; - -static const char *const dw_at_names[] = { -#include -}; + ENTRY(DW_TAG_array_type), + ENTRY(DW_TAG_class_type), + ENTRY(DW_TAG_entry_point), + ENTRY(DW_TAG_enumeration_type), + ENTRY(DW_TAG_formal_parameter), + ENTRY(DW_TAG_global_subroutine), + ENTRY(DW_TAG_global_variable), + ENTRY(DW_TAG_imported_declaration), + ENTRY(DW_TAG_reserved_0x09), + ENTRY(DW_TAG_label), + ENTRY(DW_TAG_lexical_block), + ENTRY(DW_TAG_local_variable), + ENTRY(DW_TAG_member), + ENTRY(DW_TAG_reserved_0x0e), + ENTRY(DW_TAG_pointer_type), + ENTRY(DW_TAG_reference_type), + ENTRY(DW_TAG_compile_unit), + ENTRY(DW_TAG_string_type), + ENTRY(DW_TAG_structure_type), + ENTRY(DW_TAG_subroutine), + ENTRY(DW_TAG_subroutine_type), + ENTRY(DW_TAG_typedef), + ENTRY(DW_TAG_union_type), + ENTRY(DW_TAG_unspecified_parameters), + ENTRY(DW_TAG_variant), + ENTRY(DW_TAG_common_block), + ENTRY(DW_TAG_common_inclusion), + ENTRY(DW_TAG_inheritance), + ENTRY(DW_TAG_inlined_subroutine), + ENTRY(DW_TAG_module), + ENTRY(DW_TAG_ptr_to_member_type), + ENTRY(DW_TAG_set_type), + ENTRY(DW_TAG_subrange_type), + ENTRY(DW_TAG_with_stmt), + ENTRY(DW_TAG_access_declaration), + ENTRY(DW_TAG_base_type), + ENTRY(DW_TAG_catch_block), + ENTRY(DW_TAG_const_type), + ENTRY(DW_TAG_constant), + ENTRY(DW_TAG_enumerator), + ENTRY(DW_TAG_file_type), + ENTRY(DW_TAG_friend), + ENTRY(DW_TAG_namelist), + ENTRY(DW_TAG_namelist_item), + ENTRY(DW_TAG_packed_type), + ENTRY(DW_TAG_subprogram), + ENTRY(DW_TAG_template_type_parameter), + ENTRY(DW_TAG_template_value_parameter), + ENTRY(DW_TAG_thrown_type), + ENTRY(DW_TAG_try_block), + ENTRY(DW_TAG_variant_part), + ENTRY(DW_TAG_variable), + ENTRY(DW_TAG_volatile_type), + ENTRY(DW_TAG_dwarf_procedure), + ENTRY(DW_TAG_restrict_type), + ENTRY(DW_TAG_interface_type), + ENTRY(DW_TAG_namespace), + ENTRY(DW_TAG_imported_module), + ENTRY(DW_TAG_unspecified_type), + ENTRY(DW_TAG_partial_unit), + ENTRY(DW_TAG_imported_unit), + ENTRY(DW_TAG_mutable_type), + ENTRY(DW_TAG_condition), + ENTRY(DW_TAG_shared_type), + ENTRY(DW_TAG_type_unit), + ENTRY(DW_TAG_rvalue_reference_type), + ENTRY(DW_TAG_template_alias), + ENTRY(DW_TAG_coarray_type), + ENTRY(DW_TAG_generic_subrange), + ENTRY(DW_TAG_dynamic_type), + ENTRY(DW_TAG_atomic_type), + ENTRY(DW_TAG_call_site), + ENTRY(DW_TAG_call_site_parameter), + ENTRY(DW_TAG_skeleton_unit), + ENTRY(DW_TAG_immutable_type), +}; + +_Static_assert(DW_TAG_MAX == DW_TAG_immutable_type + 1); static const char *const dw_form_names[] = { -#include -}; + ENTRY(DW_FORM_addr), + ENTRY(DW_FORM_reserved_0x02), + ENTRY(DW_FORM_block2), + ENTRY(DW_FORM_block4), + ENTRY(DW_FORM_data2), + ENTRY(DW_FORM_data4), + ENTRY(DW_FORM_data8), + ENTRY(DW_FORM_string), + ENTRY(DW_FORM_block), + ENTRY(DW_FORM_block1), + ENTRY(DW_FORM_data1), + ENTRY(DW_FORM_flag), + ENTRY(DW_FORM_sdata), + ENTRY(DW_FORM_strp), + ENTRY(DW_FORM_udata), + ENTRY(DW_FORM_ref_addr), + ENTRY(DW_FORM_ref1), + ENTRY(DW_FORM_ref2), + ENTRY(DW_FORM_ref4), + ENTRY(DW_FORM_ref8), + ENTRY(DW_FORM_ref_udata), + ENTRY(DW_FORM_indirect), + ENTRY(DW_FORM_sec_offset), + ENTRY(DW_FORM_exprloc), + ENTRY(DW_FORM_flag_present), + ENTRY(DW_FORM_strx), + ENTRY(DW_FORM_addrx), + ENTRY(DW_FORM_ref_sup4), + ENTRY(DW_FORM_strp_sup), + ENTRY(DW_FORM_data16), + ENTRY(DW_FORM_line_strp), + ENTRY(DW_FORM_ref_sig8), + ENTRY(DW_FORM_implicit_const), + ENTRY(DW_FORM_loclistx), + ENTRY(DW_FORM_rnglistx), + ENTRY(DW_FORM_ref_sup8), + ENTRY(DW_FORM_strx1), + ENTRY(DW_FORM_strx2), + ENTRY(DW_FORM_strx3), + ENTRY(DW_FORM_strx4), + ENTRY(DW_FORM_addrx1), + ENTRY(DW_FORM_addrx2), + ENTRY(DW_FORM_addrx3), + ENTRY(DW_FORM_addrx4), +}; + +_Static_assert(DW_FORM_MAX == DW_FORM_addrx4 + 1); static const char *const dw_op_names[] = { -#include -}; + ENTRY(DW_OP_reg), + ENTRY(DW_OP_basereg), + ENTRY(DW_OP_addr), + ENTRY(DW_OP_const), + ENTRY(DW_OP_deref2), + ENTRY(DW_OP_deref), + ENTRY(DW_OP_add), + ENTRY(DW_OP_const1u), + ENTRY(DW_OP_const1s), + ENTRY(DW_OP_const2u), + ENTRY(DW_OP_const2s), + ENTRY(DW_OP_const4u), + ENTRY(DW_OP_const4s), + ENTRY(DW_OP_const8u), + ENTRY(DW_OP_const8s), + ENTRY(DW_OP_constu), + ENTRY(DW_OP_consts), + ENTRY(DW_OP_dup), + ENTRY(DW_OP_drop), + ENTRY(DW_OP_over), + ENTRY(DW_OP_pick), + ENTRY(DW_OP_swap), + ENTRY(DW_OP_rot), + ENTRY(DW_OP_xderef), + ENTRY(DW_OP_abs), + ENTRY(DW_OP_and), + ENTRY(DW_OP_div), + ENTRY(DW_OP_minus), + ENTRY(DW_OP_mod), + ENTRY(DW_OP_mul), + ENTRY(DW_OP_neg), + ENTRY(DW_OP_not), + ENTRY(DW_OP_or), + ENTRY(DW_OP_plus), + ENTRY(DW_OP_plus_uconst), + ENTRY(DW_OP_shl), + ENTRY(DW_OP_shr), + ENTRY(DW_OP_shra), + ENTRY(DW_OP_xor), + ENTRY(DW_OP_bra), + ENTRY(DW_OP_eq), + ENTRY(DW_OP_ge), + ENTRY(DW_OP_gt), + ENTRY(DW_OP_le), + ENTRY(DW_OP_lt), + ENTRY(DW_OP_ne), + ENTRY(DW_OP_skip), + ENTRY(DW_OP_lit0), + ENTRY(DW_OP_lit1), + ENTRY(DW_OP_lit2), + ENTRY(DW_OP_lit3), + ENTRY(DW_OP_lit4), + ENTRY(DW_OP_lit5), + ENTRY(DW_OP_lit6), + ENTRY(DW_OP_lit7), + ENTRY(DW_OP_lit8), + ENTRY(DW_OP_lit9), + ENTRY(DW_OP_lit10), + ENTRY(DW_OP_lit11), + ENTRY(DW_OP_lit12), + ENTRY(DW_OP_lit13), + ENTRY(DW_OP_lit14), + ENTRY(DW_OP_lit15), + ENTRY(DW_OP_lit16), + ENTRY(DW_OP_lit17), + ENTRY(DW_OP_lit18), + ENTRY(DW_OP_lit19), + ENTRY(DW_OP_lit20), + ENTRY(DW_OP_lit21), + ENTRY(DW_OP_lit22), + ENTRY(DW_OP_lit23), + ENTRY(DW_OP_lit24), + ENTRY(DW_OP_lit25), + ENTRY(DW_OP_lit26), + ENTRY(DW_OP_lit27), + ENTRY(DW_OP_lit28), + ENTRY(DW_OP_lit29), + ENTRY(DW_OP_lit30), + ENTRY(DW_OP_lit31), + ENTRY(DW_OP_reg0), + ENTRY(DW_OP_reg1), + ENTRY(DW_OP_reg2), + ENTRY(DW_OP_reg3), + ENTRY(DW_OP_reg4), + ENTRY(DW_OP_reg5), + ENTRY(DW_OP_reg6), + ENTRY(DW_OP_reg7), + ENTRY(DW_OP_reg8), + ENTRY(DW_OP_reg9), + ENTRY(DW_OP_reg10), + ENTRY(DW_OP_reg11), + ENTRY(DW_OP_reg12), + ENTRY(DW_OP_reg13), + ENTRY(DW_OP_reg14), + ENTRY(DW_OP_reg15), + ENTRY(DW_OP_reg16), + ENTRY(DW_OP_reg17), + ENTRY(DW_OP_reg18), + ENTRY(DW_OP_reg19), + ENTRY(DW_OP_reg20), + ENTRY(DW_OP_reg21), + ENTRY(DW_OP_reg22), + ENTRY(DW_OP_reg23), + ENTRY(DW_OP_reg24), + ENTRY(DW_OP_reg25), + ENTRY(DW_OP_reg26), + ENTRY(DW_OP_reg27), + ENTRY(DW_OP_reg28), + ENTRY(DW_OP_reg29), + ENTRY(DW_OP_reg30), + ENTRY(DW_OP_reg31), + ENTRY(DW_OP_breg0), + ENTRY(DW_OP_breg1), + ENTRY(DW_OP_breg2), + ENTRY(DW_OP_breg3), + ENTRY(DW_OP_breg4), + ENTRY(DW_OP_breg5), + ENTRY(DW_OP_breg6), + ENTRY(DW_OP_breg7), + ENTRY(DW_OP_breg8), + ENTRY(DW_OP_breg9), + ENTRY(DW_OP_breg10), + ENTRY(DW_OP_breg11), + ENTRY(DW_OP_breg12), + ENTRY(DW_OP_breg13), + ENTRY(DW_OP_breg14), + ENTRY(DW_OP_breg15), + ENTRY(DW_OP_breg16), + ENTRY(DW_OP_breg17), + ENTRY(DW_OP_breg18), + ENTRY(DW_OP_breg19), + ENTRY(DW_OP_breg20), + ENTRY(DW_OP_breg21), + ENTRY(DW_OP_breg22), + ENTRY(DW_OP_breg23), + ENTRY(DW_OP_breg24), + ENTRY(DW_OP_breg25), + ENTRY(DW_OP_breg26), + ENTRY(DW_OP_breg27), + ENTRY(DW_OP_breg28), + ENTRY(DW_OP_breg29), + ENTRY(DW_OP_breg30), + ENTRY(DW_OP_breg31), + ENTRY(DW_OP_regx), + ENTRY(DW_OP_fbreg), + ENTRY(DW_OP_bregx), + ENTRY(DW_OP_piece), + ENTRY(DW_OP_deref_size), + ENTRY(DW_OP_xderef_size), + ENTRY(DW_OP_nop), + ENTRY(DW_OP_push_object_address), + ENTRY(DW_OP_call2), + ENTRY(DW_OP_call4), + ENTRY(DW_OP_call_ref), + ENTRY(DW_OP_form_tls_address), + ENTRY(DW_OP_call_frame_cfa), + ENTRY(DW_OP_bit_piece), + ENTRY(DW_OP_implicit_value), + ENTRY(DW_OP_stack_value), + ENTRY(DW_OP_implicit_pointer), + ENTRY(DW_OP_addrx), + ENTRY(DW_OP_constx), + ENTRY(DW_OP_entry_value), + ENTRY(DW_OP_const_type), + ENTRY(DW_OP_regval_type), + ENTRY(DW_OP_deref_type), + ENTRY(DW_OP_xderef_type), + ENTRY(DW_OP_convert), + ENTRY(DW_OP_reinterpret), +}; + +_Static_assert(DW_OP_MAX == DW_OP_reinterpret + 1); static const char *const dw_lle_names[] = { -#include -}; - -static const char *const dw_ate_names[] = { -#include -}; + ENTRY(DW_LLE_end_of_list), + ENTRY(DW_LLE_base_addressx), + ENTRY(DW_LLE_startx_endx), + ENTRY(DW_LLE_startx_length), + ENTRY(DW_LLE_offset_pair), + ENTRY(DW_LLE_default_location), + ENTRY(DW_LLE_base_address), + ENTRY(DW_LLE_start_end), + ENTRY(DW_LLE_start_length), +}; + +_Static_assert(DW_LLE_MAX == DW_LLE_start_length + 1); static const char *const dw_ds_names[] = { -#include -}; + ENTRY(DW_DS_unsigned), + ENTRY(DW_DS_leading_overpunch), + ENTRY(DW_DS_trailing_overpunch), + ENTRY(DW_DS_leading_separate), + ENTRY(DW_DS_trailing_separate), +}; + +_Static_assert(DW_DS_MAX == DW_DS_trailing_separate + 1); static const char *const dw_end_names[] = { -#include -}; - -static const char *const dw_access_names[] = { -#include -}; + ENTRY(DW_END_default), + ENTRY(DW_END_big), + ENTRY(DW_END_little), +}; + +_Static_assert(DW_END_MAX == DW_END_little + 1); static const char *const dw_vis_names[] = { -#include -}; + ENTRY(DW_VIS_local), + ENTRY(DW_VIS_exported), + ENTRY(DW_VIS_qualified), +}; + +_Static_assert(DW_VIS_MAX == DW_VIS_qualified + 1); static const char *const dw_virtuality_names[] = { -#include -}; + ENTRY(DW_VIRTUALITY_none), + ENTRY(DW_VIRTUALITY_virtual), + ENTRY(DW_VIRTUALITY_pure_virtual), +}; + +_Static_assert(DW_VIRTUALITY_MAX == DW_VIRTUALITY_pure_virtual + 1); static const char *const dw_lang_names[] = { -#include -}; + ENTRY(DW_LANG_C89), + ENTRY(DW_LANG_C), + ENTRY(DW_LANG_Ada83), + ENTRY(DW_LANG_C_plus_plus), + ENTRY(DW_LANG_Cobol74), + ENTRY(DW_LANG_Cobol85), + ENTRY(DW_LANG_Fortran77), + ENTRY(DW_LANG_Fortran90), + ENTRY(DW_LANG_Pascal83), + ENTRY(DW_LANG_Modula2), + ENTRY(DW_LANG_Java), + ENTRY(DW_LANG_C99), + ENTRY(DW_LANG_Ada95), + ENTRY(DW_LANG_Fortran95), + ENTRY(DW_LANG_PLI), + ENTRY(DW_LANG_ObjC), + ENTRY(DW_LANG_ObjC_plus_plus), + ENTRY(DW_LANG_UPC), + ENTRY(DW_LANG_D), + ENTRY(DW_LANG_Python), + ENTRY(DW_LANG_OpenCL), + ENTRY(DW_LANG_Go), + ENTRY(DW_LANG_Modula3), + ENTRY(DW_LANG_Haskell), + ENTRY(DW_LANG_C_plus_plus_03), + ENTRY(DW_LANG_C_plus_plus_11), + ENTRY(DW_LANG_OCaml), + ENTRY(DW_LANG_Rust), + ENTRY(DW_LANG_C11), + ENTRY(DW_LANG_Swift), + ENTRY(DW_LANG_Julia), + ENTRY(DW_LANG_Dylan), + ENTRY(DW_LANG_C_plus_plus_14), + ENTRY(DW_LANG_Fortran03), + ENTRY(DW_LANG_Fortran08), + ENTRY(DW_LANG_RenderScript), + ENTRY(DW_LANG_BLISS), +}; + +_Static_assert(DW_LANG_MAX == DW_LANG_BLISS + 1); static const char *const dw_id_names[] = { -#include -}; - -static const char *const dw_cc_names[] = { -#include -}; + ENTRY(DW_ID_case_sensitive), + ENTRY(DW_ID_up_case), + ENTRY(DW_ID_down_case), + ENTRY(DW_ID_case_insensitive), +}; + +_Static_assert(DW_ID_MAX == DW_ID_case_insensitive + 1); static const char *const dw_lns_names[] = { -#include -}; + ENTRY(DW_LNS_copy), + ENTRY(DW_LNS_advance_pc), + ENTRY(DW_LNS_advance_line), + ENTRY(DW_LNS_set_file), + ENTRY(DW_LNS_set_column), + ENTRY(DW_LNS_negate_stmt), + ENTRY(DW_LNS_set_basic_block), + ENTRY(DW_LNS_const_add_pc), + ENTRY(DW_LNS_fixed_advance_pc), + ENTRY(DW_LNS_set_prologue_end), + ENTRY(DW_LNS_set_epilogue_begin), + ENTRY(DW_LNS_set_isa), +}; + +_Static_assert(DW_LNS_MAX == DW_LNS_set_isa + 1); static const char *const dw_lne_names[] = { -#include -}; + ENTRY(DW_LNE_end_sequence), + ENTRY(DW_LNE_set_address), + ENTRY(DW_LNE_define_file), + ENTRY(DW_LNE_set_discriminator), +}; + +_Static_assert(DW_LNE_MAX == DW_LNE_set_discriminator + 1); static const char *const dw_lnct_names[] = { -#include -}; - -#undef CVAL - -#define D_(infix) \ - const char *dw_##infix##_name(dw_##infix##_t val) { \ - if (val >= sizeof(dw_##infix##_names) / sizeof(const char *)) \ - return NULL; \ - return dw_##infix##_names[val]; \ - } - -D_(ut); -D_(tag); -D_(at); -D_(form); -D_(op); -D_(lle); -D_(ate); -D_(ds); -D_(end); -D_(access); -D_(vis); -D_(virtuality); -D_(lang); -D_(id); -D_(cc); -D_(lns); -D_(lne); -D_(lnct); - -#undef D_ + ENTRY(DW_LNCT_path), + ENTRY(DW_LNCT_directory_index), + ENTRY(DW_LNCT_timestamp), + ENTRY(DW_LNCT_size), + ENTRY(DW_LNCT_MD5), +}; + +_Static_assert(DW_LNCT_MAX == DW_LNCT_MD5 + 1); + +static const char *const dw_inl_names[] = { + ENTRY(DW_INL_not_inlined), + ENTRY(DW_INL_inlined), + ENTRY(DW_INL_declared_not_inlined), + ENTRY(DW_INL_declared_inlined), +}; + +_Static_assert(DW_INL_MAX == DW_INL_declared_inlined + 1); + +static const char *const dw_ord_names[] = { + ENTRY(DW_ORD_row_major), + ENTRY(DW_ORD_col_major), +}; + +_Static_assert(DW_ORD_MAX == DW_ORD_col_major + 1); + +static const char *const dw_dsc_names[] = { + ENTRY(DW_DSC_label), + ENTRY(DW_DSC_range), +}; + +_Static_assert(DW_DSC_MAX == DW_DSC_range + 1); + +static const char *const dw_idx_names[] = { + ENTRY(DW_IDX_compile_unit), + ENTRY(DW_IDX_type_unit), + ENTRY(DW_IDX_die_offset), + ENTRY(DW_IDX_parent), + ENTRY(DW_IDX_type_hash), +}; + +_Static_assert(DW_IDX_MAX == DW_IDX_type_hash + 1); + +static const char *const dw_defaulted_names[] = { + ENTRY(DW_DEFAULTED_no), + ENTRY(DW_DEFAULTED_in_class), + ENTRY(DW_DEFAULTED_out_of_class), +}; + +_Static_assert(DW_DEFAULTED_MAX == DW_DEFAULTED_out_of_class + 1); + +static const char *const dw_macro_names[] = { + ENTRY(DW_MACRO_define), + ENTRY(DW_MACRO_undef), + ENTRY(DW_MACRO_start_file), + ENTRY(DW_MACRO_end_file), + ENTRY(DW_MACRO_define_strp), + ENTRY(DW_MACRO_undef_strp), + ENTRY(DW_MACRO_import), + ENTRY(DW_MACRO_define_sup), + ENTRY(DW_MACRO_undef_sup), + ENTRY(DW_MACRO_import_sup), + ENTRY(DW_MACRO_define_strx), + ENTRY(DW_MACRO_undef_strx), +}; + +_Static_assert(DW_MACRO_MAX == DW_MACRO_undef_strx + 1); + +static const char *const dw_cfa_names[] = { + ENTRY(DW_CFA_nop), + ENTRY(DW_CFA_set_loc), + ENTRY(DW_CFA_advance_loc1), + ENTRY(DW_CFA_advance_loc2), + ENTRY(DW_CFA_advance_loc4), + ENTRY(DW_CFA_offset_extended), + ENTRY(DW_CFA_restore_extended), + ENTRY(DW_CFA_undefined), + ENTRY(DW_CFA_same_value), + ENTRY(DW_CFA_register), + ENTRY(DW_CFA_remember_state), + ENTRY(DW_CFA_restore_state), + ENTRY(DW_CFA_def_cfa), + ENTRY(DW_CFA_def_cfa_register), + ENTRY(DW_CFA_def_cfa_offset), + ENTRY(DW_CFA_def_cfa_expression), + ENTRY(DW_CFA_expression), + ENTRY(DW_CFA_offset_extended_sf), + ENTRY(DW_CFA_def_cfa_sf), + ENTRY(DW_CFA_def_cfa_offset_sf), + ENTRY(DW_CFA_val_offset), + ENTRY(DW_CFA_val_offset_sf), + ENTRY(DW_CFA_val_expression), +}; + +_Static_assert(DW_CFA_MAX == DW_CFA_val_expression + 1); + +static const char *const dw_rle_names[] = { + ENTRY(DW_RLE_end_of_list), + ENTRY(DW_RLE_base_addressx), + ENTRY(DW_RLE_startx_endx), + ENTRY(DW_RLE_startx_length), + ENTRY(DW_RLE_offset_pair), + ENTRY(DW_RLE_base_address), + ENTRY(DW_RLE_start_end), + ENTRY(DW_RLE_start_length), +}; + +_Static_assert(DW_RLE_MAX == DW_RLE_start_length + 1); + +#define NAME_FUNC(prefix) \ + const char *prefix##_name(prefix##_t val) \ + { \ + if (val >= sizeof(prefix##_names) / sizeof(const char *)) return NULL; \ + return prefix##_names[val]; \ + } + +NAME_FUNC(dw_access); +NAME_FUNC(dw_at); +NAME_FUNC(dw_ate); +NAME_FUNC(dw_cc); +NAME_FUNC(dw_cfa); +NAME_FUNC(dw_defaulted); +NAME_FUNC(dw_ds); +NAME_FUNC(dw_dsc); +NAME_FUNC(dw_end); +NAME_FUNC(dw_form); +NAME_FUNC(dw_id); +NAME_FUNC(dw_idx); +NAME_FUNC(dw_inl); +NAME_FUNC(dw_lang); +NAME_FUNC(dw_lle); +NAME_FUNC(dw_lnct); +NAME_FUNC(dw_lne); +NAME_FUNC(dw_lns); +NAME_FUNC(dw_macro); +NAME_FUNC(dw_op); +NAME_FUNC(dw_ord); +NAME_FUNC(dw_rle); +NAME_FUNC(dw_tag); +NAME_FUNC(dw_ut); +NAME_FUNC(dw_virtuality); +NAME_FUNC(dw_vis);