diff --git a/contrib/elftoolchain/libdwarf/Version.map b/contrib/elftoolchain/libdwarf/Version.map index 669f70e44dac..6714457e7ede 100644 --- a/contrib/elftoolchain/libdwarf/Version.map +++ b/contrib/elftoolchain/libdwarf/Version.map @@ -1,239 +1,240 @@ /* $Id: Version.map 3085 2014-09-02 22:08:23Z kaiwang27 $ */ R1.0 { global: dwarf_add_AT_comp_dir; dwarf_add_AT_const_value_signedint; dwarf_add_AT_const_value_string; dwarf_add_AT_const_value_unsignedint; dwarf_add_AT_dataref; dwarf_add_AT_flag; dwarf_add_AT_location_expr; dwarf_add_AT_name; dwarf_add_AT_producer; dwarf_add_AT_ref_address; dwarf_add_AT_reference; dwarf_add_AT_signed_const; dwarf_add_AT_string; dwarf_add_AT_targ_address; dwarf_add_AT_targ_address_b; dwarf_add_AT_unsigned_const; dwarf_add_arange; dwarf_add_arange_b; dwarf_add_die_to_debug; dwarf_add_directory_decl; dwarf_add_expr_addr; dwarf_add_expr_addr_b; dwarf_add_expr_gen; dwarf_add_fde_inst; dwarf_add_file_decl; dwarf_add_frame_cie; dwarf_add_frame_fde; dwarf_add_frame_fde_b; dwarf_add_funcname; dwarf_add_line_entry; dwarf_add_pubname; dwarf_add_typename; dwarf_add_varname; dwarf_add_weakname; dwarf_arrayorder; dwarf_attr; dwarf_attrlist; dwarf_attroffset; dwarf_attrval_flag; dwarf_attrval_signed; dwarf_attrval_string; dwarf_attrval_unsigned; dwarf_bitoffset; dwarf_bitsize; dwarf_bytesize; dwarf_child; dwarf_dealloc; dwarf_def_macro; dwarf_die_CU_offset; dwarf_die_CU_offset_range; dwarf_die_abbrev_code; dwarf_die_link; dwarf_diename; dwarf_dieoffset; dwarf_elf_init; dwarf_end_macro_file; dwarf_errmsg_; dwarf_expand_frame_instructions; dwarf_expr_current_offset; dwarf_expr_into_block; dwarf_fde_cfa_offset; dwarf_fde_cie_list_dealloc; dwarf_find_macro_value_start; dwarf_finish; dwarf_formaddr; dwarf_formblock; dwarf_formexprloc; dwarf_formflag; dwarf_formref; dwarf_formsdata; dwarf_formsig8; dwarf_formstring; dwarf_formudata; dwarf_func_cu_offset; dwarf_func_die_offset; dwarf_func_name_offsets; dwarf_funcname; dwarf_funcs_dealloc; dwarf_get_ACCESS_name; dwarf_get_ATE_name; dwarf_get_AT_name; dwarf_get_CC_name; dwarf_get_CFA_name; dwarf_get_CHILDREN_name; dwarf_get_DSC_name; dwarf_get_DS_name; dwarf_get_EH_name; dwarf_get_END_name; dwarf_get_FORM_name; dwarf_get_ID_name; dwarf_get_INL_name; dwarf_get_LANG_name; dwarf_get_LNE_name; dwarf_get_LNS_name; dwarf_get_MACINFO_name; dwarf_get_OP_name; dwarf_get_ORD_name; dwarf_get_TAG_name; + dwarf_get_UT_name; dwarf_get_VIRTUALITY_name; dwarf_get_VIS_name; dwarf_get_abbrev; dwarf_get_abbrev_children_flag; dwarf_get_abbrev_code; dwarf_get_abbrev_entry; dwarf_get_abbrev_tag; dwarf_get_address_size; dwarf_get_arange; dwarf_get_arange_cu_header_offset; dwarf_get_arange_info; dwarf_get_aranges; dwarf_get_cie_index; dwarf_get_cie_info; dwarf_get_cie_of_fde; dwarf_get_cu_die_offset; dwarf_get_cu_die_offset_given_cu_header_offset; dwarf_get_cu_die_offset_given_cu_header_offset_b; dwarf_get_die_infotypes_flag; dwarf_get_elf; dwarf_get_fde_at_pc; dwarf_get_fde_info_for_all_regs3; dwarf_get_fde_info_for_all_regs; dwarf_get_fde_info_for_cfa_reg3; dwarf_get_fde_info_for_reg3; dwarf_get_fde_info_for_reg; dwarf_get_fde_instr_bytes; dwarf_get_fde_list; dwarf_get_fde_list_eh; dwarf_get_fde_n; dwarf_get_fde_range; dwarf_get_form_class; dwarf_get_funcs; dwarf_get_globals; dwarf_get_loclist_entry; dwarf_get_macro_details; dwarf_get_pubtypes; dwarf_get_ranges; dwarf_get_ranges_a; dwarf_get_relocation_info; dwarf_get_relocation_info_count; dwarf_get_section_bytes; dwarf_get_section_max_offsets; dwarf_get_section_max_offsets_b; dwarf_get_str; dwarf_get_types; dwarf_get_vars; dwarf_get_weaks; dwarf_global_cu_offset; dwarf_global_die_offset; dwarf_global_formref; dwarf_global_name_offsets; dwarf_globals_dealloc; dwarf_globname; dwarf_hasattr; dwarf_hasform; dwarf_highpc; dwarf_highpc_b; dwarf_init; dwarf_line_srcfileno; dwarf_lineaddr; dwarf_linebeginstatement; dwarf_lineblock; dwarf_lineendsequence; dwarf_lineno; dwarf_lineoff; dwarf_linesrc; dwarf_lne_end_sequence; dwarf_lne_set_address; dwarf_loclist; dwarf_loclist_from_expr; dwarf_loclist_from_expr_a; dwarf_loclist_from_expr_b; dwarf_loclist_n; dwarf_lowpc; dwarf_new_die; dwarf_new_expr; dwarf_new_fde; dwarf_next_cu_header; dwarf_next_cu_header_b; dwarf_next_cu_header_c; dwarf_next_types_section; dwarf_object_finish; dwarf_object_init; dwarf_offdie; dwarf_offdie_b; dwarf_producer_finish; dwarf_producer_init; dwarf_producer_init_b; dwarf_producer_set_isa; dwarf_pubtype_cu_offset; dwarf_pubtype_die_offset; dwarf_pubtype_name_offsets; dwarf_pubtypename; dwarf_pubtypes_dealloc; dwarf_ranges_dealloc; dwarf_reset_section_bytes; dwarf_set_frame_cfa_value; dwarf_set_frame_rule_initial_value; dwarf_set_frame_rule_table_size; dwarf_set_frame_same_value; dwarf_set_frame_undefined_value; dwarf_set_reloc_application; dwarf_seterrarg; dwarf_seterrhand; dwarf_siblingof; dwarf_siblingof_b; dwarf_srcfiles; dwarf_srclang; dwarf_srclines; dwarf_srclines_dealloc; dwarf_start_macro_file; dwarf_tag; dwarf_transform_to_disk_form; dwarf_type_cu_offset; dwarf_type_die_offset; dwarf_type_name_offsets; dwarf_typename; dwarf_types_dealloc; dwarf_undef_macro; dwarf_var_cu_offset; dwarf_var_die_offset; dwarf_var_name_offsets; dwarf_varname; dwarf_vars_dealloc; dwarf_vendor_ext; dwarf_weak_cu_offset; dwarf_weak_die_offset; dwarf_weak_name_offsets; dwarf_weakname; dwarf_weaks_dealloc; dwarf_whatattr; dwarf_whatform; dwarf_whatform_direct; local: *; }; diff --git a/contrib/elftoolchain/libdwarf/dwarf.h b/contrib/elftoolchain/libdwarf/dwarf.h index 8f3733566527..99e934078e7d 100644 --- a/contrib/elftoolchain/libdwarf/dwarf.h +++ b/contrib/elftoolchain/libdwarf/dwarf.h @@ -1,652 +1,735 @@ /*- * Copyright (c) 2007 John Birrell (jb@freebsd.org) * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright *notice, this list of conditions and the following disclaimer. * 2. 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. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. * * $Id: dwarf.h 3749 2019-06-28 01:10:44Z emaste $ */ #ifndef _DWARF_H_ #define _DWARF_H_ #define DW_TAG_array_type 0x01 #define DW_TAG_class_type 0x02 #define DW_TAG_entry_point 0x03 #define DW_TAG_enumeration_type 0x04 #define DW_TAG_formal_parameter 0x05 #define DW_TAG_imported_declaration 0x08 #define DW_TAG_label 0x0a #define DW_TAG_lexical_block 0x0b #define DW_TAG_member 0x0d #define DW_TAG_pointer_type 0x0f #define DW_TAG_reference_type 0x10 #define DW_TAG_compile_unit 0x11 #define DW_TAG_string_type 0x12 #define DW_TAG_structure_type 0x13 #define DW_TAG_subroutine_type 0x15 #define DW_TAG_typedef 0x16 #define DW_TAG_union_type 0x17 #define DW_TAG_unspecified_parameters 0x18 #define DW_TAG_variant 0x19 #define DW_TAG_common_block 0x1a #define DW_TAG_common_inclusion 0x1b #define DW_TAG_inheritance 0x1c #define DW_TAG_inlined_subroutine 0x1d #define DW_TAG_module 0x1e #define DW_TAG_ptr_to_member_type 0x1f #define DW_TAG_set_type 0x20 #define DW_TAG_subrange_type 0x21 #define DW_TAG_with_stmt 0x22 #define DW_TAG_access_declaration 0x23 #define DW_TAG_base_type 0x24 #define DW_TAG_catch_block 0x25 #define DW_TAG_const_type 0x26 #define DW_TAG_constant 0x27 #define DW_TAG_enumerator 0x28 #define DW_TAG_friend 0x2a #define DW_TAG_namelist 0x2b #define DW_TAG_namelist_item 0x2c #define DW_TAG_packed_type 0x2d #define DW_TAG_subprogram 0x2e #define DW_TAG_template_type_parameter 0x2f #define DW_TAG_template_type_param 0x2f #define DW_TAG_template_value_parameter 0x30 #define DW_TAG_template_value_param 0x30 #define DW_TAG_thrown_type 0x31 #define DW_TAG_try_block 0x32 #define DW_TAG_variant_part 0x33 #define DW_TAG_variable 0x34 #define DW_TAG_volatile_type 0x35 #define DW_TAG_dwarf_procedure 0x36 #define DW_TAG_restrict_type 0x37 #define DW_TAG_interface_type 0x38 #define DW_TAG_namespace 0x39 #define DW_TAG_imported_module 0x3a #define DW_TAG_unspecified_type 0x3b #define DW_TAG_partial_unit 0x3c #define DW_TAG_imported_unit 0x3d #define DW_TAG_condition 0x3f #define DW_TAG_shared_type 0x40 #define DW_TAG_type_unit 0x41 #define DW_TAG_rvalue_reference_type 0x42 #define DW_TAG_template_alias 0x43 +#define DW_TAG_coarray_type 0x44 +#define DW_TAG_generic_subrange 0x45 +#define DW_TAG_dynamic_type 0x46 +#define DW_TAG_atomic_type 0x47 +#define DW_TAG_call_site 0x48 +#define DW_TAG_call_site_parameter 0x49 +#define DW_TAG_skeleton_unit 0x4a +#define DW_TAG_immutable_type 0x4b #define DW_TAG_lo_user 0x4080 #define DW_TAG_hi_user 0xffff /* GNU extensions. */ #define DW_TAG_format_label 0x4101 #define DW_TAG_function_template 0x4102 #define DW_TAG_class_template 0x4103 #define DW_TAG_GNU_BINCL 0x4104 #define DW_TAG_GNU_EINCL 0x4105 #define DW_TAG_GNU_template_template_parameter 0x4106 #define DW_TAG_GNU_template_template_param 0x4106 #define DW_TAG_GNU_template_parameter_pack 0x4107 #define DW_TAG_GNU_formal_parameter_pack 0x4108 #define DW_TAG_GNU_call_site 0x4109 #define DW_TAG_GNU_call_site_parameter 0x410a #define DW_CHILDREN_no 0x00 #define DW_CHILDREN_yes 0x01 #define DW_AT_sibling 0x01 #define DW_AT_location 0x02 #define DW_AT_name 0x03 #define DW_AT_ordering 0x09 #define DW_AT_subscr_data 0x0a #define DW_AT_byte_size 0x0b #define DW_AT_bit_offset 0x0c #define DW_AT_bit_size 0x0d #define DW_AT_element_list 0x0f #define DW_AT_stmt_list 0x10 #define DW_AT_low_pc 0x11 #define DW_AT_high_pc 0x12 #define DW_AT_language 0x13 #define DW_AT_member 0x14 #define DW_AT_discr 0x15 #define DW_AT_discr_value 0x16 #define DW_AT_visibility 0x17 #define DW_AT_import 0x18 #define DW_AT_string_length 0x19 #define DW_AT_common_reference 0x1a #define DW_AT_comp_dir 0x1b #define DW_AT_const_value 0x1c #define DW_AT_containing_type 0x1d #define DW_AT_default_value 0x1e #define DW_AT_inline 0x20 #define DW_AT_is_optional 0x21 #define DW_AT_lower_bound 0x22 #define DW_AT_producer 0x25 #define DW_AT_prototyped 0x27 #define DW_AT_return_addr 0x2a #define DW_AT_start_scope 0x2c #define DW_AT_bit_stride 0x2e #define DW_AT_stride_size 0x2e #define DW_AT_upper_bound 0x2f #define DW_AT_abstract_origin 0x31 #define DW_AT_accessibility 0x32 #define DW_AT_address_class 0x33 #define DW_AT_artificial 0x34 #define DW_AT_base_types 0x35 #define DW_AT_calling_convention 0x36 #define DW_AT_count 0x37 #define DW_AT_data_member_location 0x38 #define DW_AT_decl_column 0x39 #define DW_AT_decl_file 0x3a #define DW_AT_decl_line 0x3b #define DW_AT_declaration 0x3c #define DW_AT_discr_list 0x3d #define DW_AT_encoding 0x3e #define DW_AT_external 0x3f #define DW_AT_frame_base 0x40 #define DW_AT_friend 0x41 #define DW_AT_identifier_case 0x42 #define DW_AT_macro_info 0x43 #define DW_AT_namelist_item 0x44 #define DW_AT_priority 0x45 #define DW_AT_segment 0x46 #define DW_AT_specification 0x47 #define DW_AT_static_link 0x48 #define DW_AT_type 0x49 #define DW_AT_use_location 0x4a #define DW_AT_variable_parameter 0x4b #define DW_AT_virtuality 0x4c #define DW_AT_vtable_elem_location 0x4d #define DW_AT_allocated 0x4e #define DW_AT_associated 0x4f #define DW_AT_data_location 0x50 #define DW_AT_byte_stride 0x51 #define DW_AT_entry_pc 0x52 #define DW_AT_use_UTF8 0x53 #define DW_AT_extension 0x54 #define DW_AT_ranges 0x55 #define DW_AT_trampoline 0x56 #define DW_AT_call_column 0x57 #define DW_AT_call_file 0x58 #define DW_AT_call_line 0x59 #define DW_AT_description 0x5a #define DW_AT_binary_scale 0x5b #define DW_AT_decimal_scale 0x5c #define DW_AT_small 0x5d #define DW_AT_decimal_sign 0x5e #define DW_AT_digit_count 0x5f #define DW_AT_picture_string 0x60 #define DW_AT_mutable 0x61 #define DW_AT_threads_scaled 0x62 #define DW_AT_explicit 0x63 #define DW_AT_object_pointer 0x64 #define DW_AT_endianity 0x65 #define DW_AT_elemental 0x66 #define DW_AT_pure 0x67 #define DW_AT_recursive 0x68 #define DW_AT_signature 0x69 #define DW_AT_main_subprogram 0x6a #define DW_AT_data_bit_offset 0x6b #define DW_AT_const_expr 0x6c #define DW_AT_enum_class 0x6d #define DW_AT_linkage_name 0x6e +#define DW_AT_string_length_bit_size 0x6f +#define DW_AT_string_length_byte_size 0x70 +#define DW_AT_rank 0x71 +#define DW_AT_str_offsets_base 0x72 +#define DW_AT_addr_base 0x73 +#define DW_AT_rnglists_base 0x74 +#define DW_AT_dwo_name 0x76 +#define DW_AT_reference 0x77 +#define DW_AT_rvalue_reference 0x78 +#define DW_AT_macros 0x79 +#define DW_AT_call_all_calls 0x7a +#define DW_AT_call_all_source_calls 0x7b +#define DW_AT_call_all_tail_calls 0x7c +#define DW_AT_call_return_pc 0x7d +#define DW_AT_call_value 0x7e +#define DW_AT_call_origin 0x7f +#define DW_AT_call_parameter 0x80 +#define DW_AT_call_pc 0x81 +#define DW_AT_call_tail_call 0x82 +#define DW_AT_call_target 0x83 +#define DW_AT_call_target_clobbered 0x84 +#define DW_AT_call_data_location 0x85 +#define DW_AT_call_data_value 0x86 +#define DW_AT_noreturn 0x87 +#define DW_AT_alignment 0x88 +#define DW_AT_export_symbols 0x89 +#define DW_AT_deleted 0x8a +#define DW_AT_defaulted 0x8b +#define DW_AT_loclists_base 0x8c #define DW_AT_lo_user 0x2000 #define DW_AT_hi_user 0x3fff /* SGI/MIPS extensions. */ #define DW_AT_MIPS_fde 0x2001 #define DW_AT_MIPS_loop_begin 0x2002 #define DW_AT_MIPS_tail_loop_begin 0x2003 #define DW_AT_MIPS_epilog_begin 0x2004 #define DW_AT_MIPS_loop_unroll_factor 0x2005 #define DW_AT_MIPS_software_pipeline_depth 0x2006 #define DW_AT_MIPS_linkage_name 0x2007 #define DW_AT_MIPS_stride 0x2008 #define DW_AT_MIPS_abstract_name 0x2009 #define DW_AT_MIPS_clone_origin 0x200a #define DW_AT_MIPS_has_inlines 0x200b #define DW_AT_MIPS_stride_byte 0x200c #define DW_AT_MIPS_stride_elem 0x200d #define DW_AT_MIPS_ptr_dopetype 0x200e #define DW_AT_MIPS_allocatable_dopetype 0x200f #define DW_AT_MIPS_assumed_shape_dopetype 0x2010 #define DW_AT_MIPS_assumed_size 0x2011 /* GNU extensions. */ #define DW_AT_sf_names 0x2101 #define DW_AT_src_info 0x2102 #define DW_AT_mac_info 0x2103 #define DW_AT_src_coords 0x2104 #define DW_AT_body_begin 0x2105 #define DW_AT_body_end 0x2106 #define DW_AT_GNU_vector 0x2107 #define DW_AT_GNU_guarded_by 0x2108 #define DW_AT_GNU_pt_guarded_by 0x2109 #define DW_AT_GNU_guarded 0x210a #define DW_AT_GNU_pt_guarded 0x210b #define DW_AT_GNU_locks_excluded 0x210c #define DW_AT_GNU_exclusive_locks_required 0x210d #define DW_AT_GNU_shared_locks_required 0x210e #define DW_AT_GNU_odr_signature 0x210f #define DW_AT_GNU_template_name 0x2110 #define DW_AT_GNU_call_site_value 0x2111 #define DW_AT_GNU_call_site_data_value 0x2112 #define DW_AT_GNU_call_site_target 0x2113 #define DW_AT_GNU_call_site_target_clobbered 0x2114 #define DW_AT_GNU_tail_call 0x2115 #define DW_AT_GNU_all_tail_call_sites 0x2116 #define DW_AT_GNU_all_call_sites 0x2117 #define DW_AT_GNU_all_source_call_sites 0x2118 /* Apple extensions. */ #define DW_AT_APPLE_optimized 0x3fe1 #define DW_AT_APPLE_flags 0x3fe2 #define DW_AT_APPLE_isa 0x3fe3 #define DW_AT_APPLE_block 0x3fe4 #define DW_AT_APPLE_major_runtime_vers 0x3fe5 #define DW_AT_APPLE_runtime_class 0x3fe6 #define DW_AT_APPLE_omit_frame_ptr 0x3fe7 #define DW_AT_APPLE_property_name 0x3fe8 #define DW_AT_APPLE_property_getter 0x3fe9 #define DW_AT_APPLE_property_setter 0x3fea #define DW_AT_APPLE_property_attribute 0x3feb #define DW_AT_APPLE_objc_complete_type 0x3fec #define DW_AT_APPLE_property 0x3fed #define DW_FORM_addr 0x01 #define DW_FORM_block2 0x03 #define DW_FORM_block4 0x04 #define DW_FORM_data2 0x05 #define DW_FORM_data4 0x06 #define DW_FORM_data8 0x07 #define DW_FORM_string 0x08 #define DW_FORM_block 0x09 #define DW_FORM_block1 0x0a #define DW_FORM_data1 0x0b #define DW_FORM_flag 0x0c #define DW_FORM_sdata 0x0d #define DW_FORM_strp 0x0e #define DW_FORM_udata 0x0f #define DW_FORM_ref_addr 0x10 #define DW_FORM_ref1 0x11 #define DW_FORM_ref2 0x12 #define DW_FORM_ref4 0x13 #define DW_FORM_ref8 0x14 #define DW_FORM_ref_udata 0x15 #define DW_FORM_indirect 0x16 #define DW_FORM_sec_offset 0x17 #define DW_FORM_exprloc 0x18 #define DW_FORM_flag_present 0x19 +#define DW_FORM_strx 0x1a +#define DW_FORM_addrx 0x1b +#define DW_FORM_ref_sup4 0x1c +#define DW_FORM_strp_sup 0x1d +#define DW_FORM_data16 0x1e +#define DW_FORM_line_strp 0x1f #define DW_FORM_ref_sig8 0x20 +#define DW_FORM_implicit_const 0x21 +#define DW_FORM_loclistx 0x22 +#define DW_FORM_rnglistx 0x23 +#define DW_FORM_ref_sup8 0x24 +#define DW_FORM_ref_strx1 0x25 +#define DW_FORM_ref_strx2 0x26 +#define DW_FORM_ref_strx3 0x27 +#define DW_FORM_ref_strx4 0x28 +#define DW_FORM_ref_addrx1 0x29 +#define DW_FORM_ref_addrx2 0x2a +#define DW_FORM_ref_addrx3 0x2b +#define DW_FORM_ref_addrx4 0x2c #define DW_FORM_GNU_ref_alt 0x1f20 #define DW_FORM_GNU_strp_alt 0x1f21 #define DW_OP_addr 0x03 #define DW_OP_deref 0x06 #define DW_OP_const1u 0x08 #define DW_OP_const1s 0x09 #define DW_OP_const2u 0x0a #define DW_OP_const2s 0x0b #define DW_OP_const4u 0x0c #define DW_OP_const4s 0x0d #define DW_OP_const8u 0x0e #define DW_OP_const8s 0x0f #define DW_OP_constu 0x10 #define DW_OP_consts 0x11 #define DW_OP_dup 0x12 #define DW_OP_drop 0x13 #define DW_OP_over 0x14 #define DW_OP_pick 0x15 #define DW_OP_swap 0x16 #define DW_OP_rot 0x17 #define DW_OP_xderef 0x18 #define DW_OP_abs 0x19 #define DW_OP_and 0x1a #define DW_OP_div 0x1b #define DW_OP_minus 0x1c #define DW_OP_mod 0x1d #define DW_OP_mul 0x1e #define DW_OP_neg 0x1f #define DW_OP_not 0x20 #define DW_OP_or 0x21 #define DW_OP_plus 0x22 #define DW_OP_plus_uconst 0x23 #define DW_OP_shl 0x24 #define DW_OP_shr 0x25 #define DW_OP_shra 0x26 #define DW_OP_xor 0x27 #define DW_OP_bra 0x28 #define DW_OP_eq 0x29 #define DW_OP_ge 0x2a #define DW_OP_gt 0x2b #define DW_OP_le 0x2c #define DW_OP_lt 0x2d #define DW_OP_ne 0x2e #define DW_OP_skip 0x2f #define DW_OP_lit0 0x30 #define DW_OP_lit1 0x31 #define DW_OP_lit2 0x32 #define DW_OP_lit3 0x33 #define DW_OP_lit4 0x34 #define DW_OP_lit5 0x35 #define DW_OP_lit6 0x36 #define DW_OP_lit7 0x37 #define DW_OP_lit8 0x38 #define DW_OP_lit9 0x39 #define DW_OP_lit10 0x3a #define DW_OP_lit11 0x3b #define DW_OP_lit12 0x3c #define DW_OP_lit13 0x3d #define DW_OP_lit14 0x3e #define DW_OP_lit15 0x3f #define DW_OP_lit16 0x40 #define DW_OP_lit17 0x41 #define DW_OP_lit18 0x42 #define DW_OP_lit19 0x43 #define DW_OP_lit20 0x44 #define DW_OP_lit21 0x45 #define DW_OP_lit22 0x46 #define DW_OP_lit23 0x47 #define DW_OP_lit24 0x48 #define DW_OP_lit25 0x49 #define DW_OP_lit26 0x4a #define DW_OP_lit27 0x4b #define DW_OP_lit28 0x4c #define DW_OP_lit29 0x4d #define DW_OP_lit30 0x4e #define DW_OP_lit31 0x4f #define DW_OP_reg0 0x50 #define DW_OP_reg1 0x51 #define DW_OP_reg2 0x52 #define DW_OP_reg3 0x53 #define DW_OP_reg4 0x54 #define DW_OP_reg5 0x55 #define DW_OP_reg6 0x56 #define DW_OP_reg7 0x57 #define DW_OP_reg8 0x58 #define DW_OP_reg9 0x59 #define DW_OP_reg10 0x5a #define DW_OP_reg11 0x5b #define DW_OP_reg12 0x5c #define DW_OP_reg13 0x5d #define DW_OP_reg14 0x5e #define DW_OP_reg15 0x5f #define DW_OP_reg16 0x60 #define DW_OP_reg17 0x61 #define DW_OP_reg18 0x62 #define DW_OP_reg19 0x63 #define DW_OP_reg20 0x64 #define DW_OP_reg21 0x65 #define DW_OP_reg22 0x66 #define DW_OP_reg23 0x67 #define DW_OP_reg24 0x68 #define DW_OP_reg25 0x69 #define DW_OP_reg26 0x6a #define DW_OP_reg27 0x6b #define DW_OP_reg28 0x6c #define DW_OP_reg29 0x6d #define DW_OP_reg30 0x6e #define DW_OP_reg31 0x6f #define DW_OP_breg0 0x70 #define DW_OP_breg1 0x71 #define DW_OP_breg2 0x72 #define DW_OP_breg3 0x73 #define DW_OP_breg4 0x74 #define DW_OP_breg5 0x75 #define DW_OP_breg6 0x76 #define DW_OP_breg7 0x77 #define DW_OP_breg8 0x78 #define DW_OP_breg9 0x79 #define DW_OP_breg10 0x7a #define DW_OP_breg11 0x7b #define DW_OP_breg12 0x7c #define DW_OP_breg13 0x7d #define DW_OP_breg14 0x7e #define DW_OP_breg15 0x7f #define DW_OP_breg16 0x80 #define DW_OP_breg17 0x81 #define DW_OP_breg18 0x82 #define DW_OP_breg19 0x83 #define DW_OP_breg20 0x84 #define DW_OP_breg21 0x85 #define DW_OP_breg22 0x86 #define DW_OP_breg23 0x87 #define DW_OP_breg24 0x88 #define DW_OP_breg25 0x89 #define DW_OP_breg26 0x8a #define DW_OP_breg27 0x8b #define DW_OP_breg28 0x8c #define DW_OP_breg29 0x8d #define DW_OP_breg30 0x8e #define DW_OP_breg31 0x8f #define DW_OP_regx 0x90 #define DW_OP_fbreg 0x91 #define DW_OP_bregx 0x92 #define DW_OP_piece 0x93 #define DW_OP_deref_size 0x94 #define DW_OP_xderef_size 0x95 #define DW_OP_nop 0x96 #define DW_OP_push_object_address 0x97 #define DW_OP_call2 0x98 #define DW_OP_call4 0x99 #define DW_OP_call_ref 0x9a #define DW_OP_form_tls_address 0x9b #define DW_OP_call_frame_cfa 0x9c #define DW_OP_bit_piece 0x9d #define DW_OP_implicit_value 0x9e #define DW_OP_stack_value 0x9f +#define DW_OP_implicit_pointer 0xa0 +#define DW_OP_addrx 0xa1 +#define DW_OP_constx 0xa2 +#define DW_OP_entry_value 0xa3 +#define DW_OP_const_type 0xa4 +#define DW_OP_regval_type 0xa5 +#define DW_OP_deref_type 0xa6 +#define DW_OP_xderef_type 0xa7 +#define DW_OP_convert 0xa8 +#define DW_OP_reinterpret 0xa9 #define DW_OP_lo_user 0xe0 #define DW_OP_hi_user 0xff /* GNU extensions. */ #define DW_OP_GNU_push_tls_address 0xe0 #define DW_OP_GNU_uninit 0xf0 #define DW_OP_GNU_encoded_addr 0xf1 #define DW_OP_GNU_implicit_pointer 0xf2 #define DW_OP_GNU_entry_value 0xf3 #define DW_OP_GNU_const_type 0xf4 #define DW_OP_GNU_regval_type 0xf5 #define DW_OP_GNU_deref_type 0xf6 #define DW_OP_GNU_convert 0xf7 #define DW_OP_GNU_reinterpret 0xf9 #define DW_OP_GNU_parameter_ref 0xfa #define DW_OP_GNU_addr_index 0xfb #define DW_OP_GNU_const_index 0xfc #define DW_ATE_address 0x1 #define DW_ATE_boolean 0x2 #define DW_ATE_complex_float 0x3 #define DW_ATE_float 0x4 #define DW_ATE_signed 0x5 #define DW_ATE_signed_char 0x6 #define DW_ATE_unsigned 0x7 #define DW_ATE_unsigned_char 0x8 #define DW_ATE_imaginary_float 0x9 #define DW_ATE_packed_decimal 0xa #define DW_ATE_numeric_string 0xb #define DW_ATE_edited 0xc #define DW_ATE_signed_fixed 0xd #define DW_ATE_unsigned_fixed 0xe #define DW_ATE_decimal_float 0xf +#define DW_ATE_UTF 0x10 +#define DW_ATE_UCS 0x11 +#define DW_ATE_ASCII 0x12 #define DW_ATE_lo_user 0x80 #define DW_ATE_hi_user 0xff #define DW_ACCESS_public 0x01 #define DW_ACCESS_protected 0x02 #define DW_ACCESS_private 0x03 #define DW_END_default 0x00 #define DW_END_big 0x01 #define DW_END_little 0x02 #define DW_END_lo_user 0x40 #define DW_END_high_user 0xff #define DW_VIS_local 0x01 #define DW_VIS_exported 0x02 #define DW_VIS_qualified 0x03 #define DW_VIRTUALITY_none 0x00 #define DW_VIRTUALITY_virtual 0x01 #define DW_VIRTUALITY_pure_virtual 0x02 #define DW_LANG_C89 0x0001 #define DW_LANG_C 0x0002 #define DW_LANG_Ada83 0x0003 #define DW_LANG_C_plus_plus 0x0004 #define DW_LANG_Cobol74 0x0005 #define DW_LANG_Cobol85 0x0006 #define DW_LANG_Fortran77 0x0007 #define DW_LANG_Fortran90 0x0008 #define DW_LANG_Pascal83 0x0009 #define DW_LANG_Modula2 0x000a #define DW_LANG_Java 0x000b #define DW_LANG_C99 0x000c #define DW_LANG_Ada95 0x000d #define DW_LANG_Fortran95 0x000e #define DW_LANG_PLI 0x000f #define DW_LANG_ObjC 0x0010 #define DW_LANG_ObjC_plus_plus 0x0011 #define DW_LANG_UPC 0x0012 #define DW_LANG_D 0x0013 #define DW_LANG_Python 0x0014 #define DW_LANG_OpenCL 0x0015 #define DW_LANG_Go 0x0016 #define DW_LANG_Modula3 0x0017 #define DW_LANG_Haskell 0x0018 #define DW_LANG_C_plus_plus_03 0x0019 #define DW_LANG_C_plus_plus_11 0x001a #define DW_LANG_OCaml 0x001b #define DW_LANG_Rust 0x001c #define DW_LANG_C11 0x001d #define DW_LANG_Swift 0x001e #define DW_LANG_Julia 0x001f #define DW_LANG_Dylan 0x0020 #define DW_LANG_C_plus_plus_14 0x0021 #define DW_LANG_Fortran03 0x0022 #define DW_LANG_Fortran08 0x0023 #define DW_LANG_RenderScript 0x0024 #define DW_LANG_BLISS 0x0025 #define DW_LANG_lo_user 0x8000 #define DW_LANG_Mips_Assembler 0x8001 #define DW_LANG_hi_user 0xffff #define DW_ID_case_sensitive 0x00 #define DW_ID_up_case 0x01 #define DW_ID_down_case 0x02 #define DW_ID_case_insensitive 0x03 #define DW_CC_normal 0x01 #define DW_CC_program 0x02 #define DW_CC_nocall 0x03 +#define DW_CC_pass_by_reference 0x04 +#define DW_CC_pass_by_value 0x05 #define DW_CC_lo_user 0x40 #define DW_CC_hi_user 0xff #define DW_INL_not_inlined 0x00 #define DW_INL_inlined 0x01 #define DW_INL_declared_not_inlined 0x02 #define DW_INL_declared_inlined 0x03 #define DW_ORD_row_major 0x00 #define DW_ORD_col_major 0x01 #define DW_DS_unsigned 0x01 #define DW_DS_leading_overpunch 0x02 #define DW_DS_trailing_overpunch 0x03 #define DW_DS_leading_separate 0x04 #define DW_DS_trailing_separate 0x05 #define DW_DSC_label 0x00 #define DW_DSC_range 0x01 #define DW_LNS_copy 0x01 #define DW_LNS_advance_pc 0x02 #define DW_LNS_advance_line 0x03 #define DW_LNS_set_file 0x04 #define DW_LNS_set_column 0x05 #define DW_LNS_negate_stmt 0x06 #define DW_LNS_set_basic_block 0x07 #define DW_LNS_const_add_pc 0x08 #define DW_LNS_fixed_advance_pc 0x09 #define DW_LNS_set_prologue_end 0x0a #define DW_LNS_set_epilogue_begin 0x0b #define DW_LNS_set_isa 0x0c #define DW_LNE_end_sequence 0x01 #define DW_LNE_set_address 0x02 #define DW_LNE_define_file 0x03 #define DW_LNE_lo_user 0x80 #define DW_LNE_hi_user 0xff #define DW_MACINFO_define 0x01 #define DW_MACINFO_undef 0x02 #define DW_MACINFO_start_file 0x03 #define DW_MACINFO_end_file 0x04 #define DW_MACINFO_vendor_ext 0xff #define DW_CFA_advance_loc 0x40 #define DW_CFA_offset 0x80 #define DW_CFA_restore 0xc0 #define DW_CFA_extended 0 #define DW_CFA_nop 0x00 #define DW_CFA_set_loc 0x01 #define DW_CFA_advance_loc1 0x02 #define DW_CFA_advance_loc2 0x03 #define DW_CFA_advance_loc4 0x04 #define DW_CFA_offset_extended 0x05 #define DW_CFA_restore_extended 0x06 #define DW_CFA_undefined 0x07 #define DW_CFA_same_value 0x08 #define DW_CFA_register 0x09 #define DW_CFA_remember_state 0x0a #define DW_CFA_restore_state 0x0b #define DW_CFA_def_cfa 0x0c #define DW_CFA_def_cfa_register 0x0d #define DW_CFA_def_cfa_offset 0x0e #define DW_CFA_def_cfa_expression 0x0f #define DW_CFA_expression 0x10 #define DW_CFA_offset_extended_sf 0x11 #define DW_CFA_def_cfa_sf 0x12 #define DW_CFA_def_cfa_offset_sf 0x13 #define DW_CFA_val_offset 0x14 #define DW_CFA_val_offset_sf 0x15 #define DW_CFA_val_expression 0x16 #define DW_CFA_lo_user 0x1c #define DW_CFA_high_user 0x3f /* * LSB(Linux Standard Base) extension to DWARF2. */ #define DW_EH_PE_absptr 0x00 #define DW_EH_PE_uleb128 0x01 #define DW_EH_PE_udata2 0x02 #define DW_EH_PE_udata4 0x03 #define DW_EH_PE_udata8 0x04 #define DW_EH_PE_sleb128 0x09 #define DW_EH_PE_sdata2 0x0a #define DW_EH_PE_sdata4 0x0b #define DW_EH_PE_sdata8 0x0c #define DW_EH_PE_pcrel 0x10 #define DW_EH_PE_textrel 0x20 #define DW_EH_PE_datarel 0x30 #define DW_EH_PE_funcrel 0x40 #define DW_EH_PE_aligned 0x50 #define DW_EH_PE_omit 0xff +/* + * Compilation unit types. DWARF5 only. + */ + +#define DW_UT_compile 0x01 +#define DW_UT_type 0x02 +#define DW_UT_partial 0x03 +#define DW_UT_skeleton 0x04 +#define DW_UT_split_compile 0x05 +#define DW_UT_split_type 0x06 +#define DW_UT_lo_user 0x80 +#define DW_UT_hi_user 0xff + #endif /* !_DWARF_H_ */ diff --git a/contrib/elftoolchain/libdwarf/dwarf_dump.c b/contrib/elftoolchain/libdwarf/dwarf_dump.c index fe61bffc6a17..e847d8e443f2 100644 --- a/contrib/elftoolchain/libdwarf/dwarf_dump.c +++ b/contrib/elftoolchain/libdwarf/dwarf_dump.c @@ -1,1482 +1,1648 @@ /*- * Copyright (c) 2007 John Birrell (jb@freebsd.org) * Copyright (c) 2009 Kai Wang * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. 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. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. */ #include "_libdwarf.h" ELFTC_VCSID("$Id: dwarf_dump.c 3749 2019-06-28 01:10:44Z emaste $"); int dwarf_get_ACCESS_name(unsigned access, const char **s) { assert(s != NULL); switch (access) { case DW_ACCESS_public: *s = "DW_ACCESS_public"; break; case DW_ACCESS_protected: *s = "DW_ACCESS_protected"; break; case DW_ACCESS_private: *s = "DW_ACCESS_private"; break; default: return (DW_DLV_NO_ENTRY); } return (DW_DLV_OK); } int dwarf_get_AT_name(unsigned attr, const char **s) { assert(s != NULL); switch (attr) { case DW_AT_abstract_origin: *s = "DW_AT_abstract_origin"; break; case DW_AT_accessibility: *s = "DW_AT_accessibility"; break; case DW_AT_address_class: *s = "DW_AT_address_class"; break; case DW_AT_artificial: *s = "DW_AT_artificial"; break; case DW_AT_allocated: *s = "DW_AT_allocated"; break; case DW_AT_associated: *s = "DW_AT_associated"; break; case DW_AT_base_types: *s = "DW_AT_base_types"; break; case DW_AT_binary_scale: *s = "DW_AT_binary_scale"; break; case DW_AT_bit_offset: *s = "DW_AT_bit_offset"; break; case DW_AT_bit_size: *s = "DW_AT_bit_size"; break; case DW_AT_bit_stride: *s = "DW_AT_bit_stride"; break; case DW_AT_byte_size: *s = "DW_AT_byte_size"; break; case DW_AT_byte_stride: *s = "DW_AT_byte_stride"; break; case DW_AT_calling_convention: *s = "DW_AT_calling_convention"; break; case DW_AT_common_reference: *s = "DW_AT_common_reference"; break; case DW_AT_comp_dir: *s = "DW_AT_comp_dir"; break; case DW_AT_const_expr: *s = "DW_AT_const_expr"; break; case DW_AT_const_value: *s = "DW_AT_const_value"; break; case DW_AT_containing_type: *s = "DW_AT_containing_type"; break; case DW_AT_count: *s = "DW_AT_count"; break; case DW_AT_call_column: *s = "DW_AT_call_column"; break; case DW_AT_call_file: *s = "DW_AT_call_file"; break; case DW_AT_call_line: *s = "DW_AT_call_line"; break; case DW_AT_data_bit_offset: *s = "DW_AT_data_bit_offset"; break; case DW_AT_data_location: *s = "DW_AT_data_location"; break; case DW_AT_data_member_location: *s = "DW_AT_data_member_location"; break; case DW_AT_decl_column: *s = "DW_AT_decl_column"; break; case DW_AT_decl_file: *s = "DW_AT_decl_file"; break; case DW_AT_decl_line: *s = "DW_AT_decl_line"; break; case DW_AT_declaration: *s = "DW_AT_declaration"; break; case DW_AT_default_value: *s = "DW_AT_default_value"; break; case DW_AT_decimal_scale: *s = "DW_AT_decimal_scale"; break; case DW_AT_decimal_sign: *s = "DW_AT_decimal_sign"; break; case DW_AT_description: *s = "DW_AT_description"; break; case DW_AT_digit_count: *s = "DW_AT_digit_count"; break; case DW_AT_discr: *s = "DW_AT_discr"; break; case DW_AT_discr_list: *s = "DW_AT_discr_list"; break; case DW_AT_discr_value: *s = "DW_AT_discr_value"; break; case DW_AT_element_list: *s = "DW_AT_element_list"; break; case DW_AT_encoding: *s = "DW_AT_encoding"; break; case DW_AT_enum_class: *s = "DW_AT_enum_class"; break; case DW_AT_external: *s = "DW_AT_external"; break; case DW_AT_entry_pc: *s = "DW_AT_entry_pc"; break; case DW_AT_extension: *s = "DW_AT_extension"; break; case DW_AT_explicit: *s = "DW_AT_explicit"; break; case DW_AT_endianity: *s = "DW_AT_endianity"; break; case DW_AT_elemental: *s = "DW_AT_elemental"; break; case DW_AT_frame_base: *s = "DW_AT_frame_base"; break; case DW_AT_friend: *s = "DW_AT_friend"; break; case DW_AT_high_pc: *s = "DW_AT_high_pc"; break; case DW_AT_hi_user: *s = "DW_AT_hi_user"; break; case DW_AT_identifier_case: *s = "DW_AT_identifier_case"; break; case DW_AT_import: *s = "DW_AT_import"; break; case DW_AT_inline: *s = "DW_AT_inline"; break; case DW_AT_is_optional: *s = "DW_AT_is_optional"; break; case DW_AT_language: *s = "DW_AT_language"; break; case DW_AT_linkage_name: *s = "DW_AT_linkage_name"; break; case DW_AT_lo_user: *s = "DW_AT_lo_user"; break; case DW_AT_location: *s = "DW_AT_location"; break; case DW_AT_low_pc: *s = "DW_AT_low_pc"; break; case DW_AT_lower_bound: *s = "DW_AT_lower_bound"; break; case DW_AT_macro_info: *s = "DW_AT_macro_info"; break; case DW_AT_main_subprogram: *s = "DW_AT_main_subprogram"; break; case DW_AT_mutable: *s = "DW_AT_mutable"; break; case DW_AT_member: *s = "DW_AT_member"; break; case DW_AT_name: *s = "DW_AT_name"; break; case DW_AT_namelist_item: *s = "DW_AT_namelist_item"; break; case DW_AT_ordering: *s = "DW_AT_ordering"; break; case DW_AT_object_pointer: *s = "DW_AT_object_pointer"; break; case DW_AT_priority: *s = "DW_AT_priority"; break; case DW_AT_producer: *s = "DW_AT_producer"; break; case DW_AT_prototyped: *s = "DW_AT_prototyped"; break; case DW_AT_picture_string: *s = "DW_AT_picture_string"; break; case DW_AT_pure: *s = "DW_AT_pure"; break; case DW_AT_return_addr: *s = "DW_AT_return_addr"; break; case DW_AT_ranges: *s = "DW_AT_ranges"; break; case DW_AT_recursive: *s = "DW_AT_recursive"; break; case DW_AT_segment: *s = "DW_AT_segment"; break; case DW_AT_sibling: *s = "DW_AT_sibling"; break; case DW_AT_signature: *s = "DW_AT_signature"; break; case DW_AT_specification: *s = "DW_AT_specification"; break; case DW_AT_start_scope: *s = "DW_AT_start_scope"; break; case DW_AT_static_link: *s = "DW_AT_static_link"; break; case DW_AT_stmt_list: *s = "DW_AT_stmt_list"; break; case DW_AT_string_length: *s = "DW_AT_string_length"; break; case DW_AT_subscr_data: *s = "DW_AT_subscr_data"; break; case DW_AT_small: *s = "DW_AT_small"; break; case DW_AT_type: *s = "DW_AT_type"; break; case DW_AT_trampoline: *s = "DW_AT_trampoline"; break; case DW_AT_threads_scaled: *s = "DW_AT_threads_scaled"; break; case DW_AT_upper_bound: *s = "DW_AT_upper_bound"; break; case DW_AT_use_location: *s = "DW_AT_use_location"; break; case DW_AT_use_UTF8: *s = "DW_AT_use_UTF8"; break; case DW_AT_variable_parameter: *s = "DW_AT_variable_parameter"; break; case DW_AT_virtuality: *s = "DW_AT_virtuality"; break; case DW_AT_visibility: *s = "DW_AT_visibility"; break; case DW_AT_vtable_elem_location: *s = "DW_AT_vtable_elem_location"; break; + case DW_AT_string_length_bit_size: + *s = "DW_AT_string_length_bit_size"; break; + case DW_AT_string_length_byte_size: + *s = "DW_AT_string_length_byte_size"; break; + case DW_AT_rank: + *s = "DW_AT_rank"; break; + case DW_AT_str_offsets_base: + *s = "DW_AT_str_offsets_base"; break; + case DW_AT_addr_base: + *s = "DW_AT_addr_base"; break; + case DW_AT_rnglists_base: + *s = "DW_AT_rnglists_base"; break; + case DW_AT_dwo_name: + *s = "DW_AT_dwo_name"; break; + case DW_AT_reference: + *s = "DW_AT_reference"; break; + case DW_AT_rvalue_reference: + *s = "DW_AT_rvalue_reference"; break; + case DW_AT_macros: + *s = "DW_AT_macros"; break; + case DW_AT_call_all_calls: + *s = "DW_AT_call_all_calls"; break; + case DW_AT_call_all_source_calls: + *s = "DW_AT_call_all_source_calls"; break; + case DW_AT_call_all_tail_calls: + *s = "DW_AT_call_all_tail_calls"; break; + case DW_AT_call_return_pc: + *s = "DW_AT_call_return_pc"; break; + case DW_AT_call_value: + *s = "DW_AT_call_value"; break; + case DW_AT_call_origin: + *s = "DW_AT_call_origin"; break; + case DW_AT_call_parameter: + *s = "DW_AT_call_parameter"; break; + case DW_AT_call_pc: + *s = "DW_AT_call_pc"; break; + case DW_AT_call_tail_call: + *s = "DW_AT_call_tail_call"; break; + case DW_AT_call_target: + *s = "DW_AT_call_target"; break; + case DW_AT_call_target_clobbered: + *s = "DW_AT_call_target_clobbered"; break; + case DW_AT_call_data_location: + *s = "DW_AT_call_data_location"; break; + case DW_AT_call_data_value: + *s = "DW_AT_call_data_value"; break; + case DW_AT_noreturn: + *s = "DW_AT_noreturn"; break; + case DW_AT_alignment: + *s = "DW_AT_alignment"; break; + case DW_AT_export_symbols: + *s = "DW_AT_export_symbols"; break; + case DW_AT_deleted: + *s = "DW_AT_deleted"; break; + case DW_AT_defaulted: + *s = "DW_AT_defaulted"; break; + case DW_AT_loclists_base: + *s = "DW_AT_loclists_base"; break; case DW_AT_sf_names: *s = "DW_AT_sf_names"; break; case DW_AT_src_info: *s = "DW_AT_src_info"; break; case DW_AT_mac_info: *s = "DW_AT_mac_info"; break; case DW_AT_src_coords: *s = "DW_AT_src_coords"; break; case DW_AT_body_begin: *s = "DW_AT_body_begin"; break; case DW_AT_body_end: *s = "DW_AT_body_end"; break; case DW_AT_MIPS_fde: *s = "DW_AT_MIPS_fde"; break; case DW_AT_MIPS_loop_begin: *s = "DW_AT_MIPS_loop_begin"; break; case DW_AT_MIPS_tail_loop_begin: *s = "DW_AT_MIPS_tail_loop_begin"; break; case DW_AT_MIPS_epilog_begin: *s = "DW_AT_MIPS_epilog_begin"; break; case DW_AT_MIPS_loop_unroll_factor: *s = "DW_AT_MIPS_loop_unroll_factor"; break; case DW_AT_MIPS_software_pipeline_depth: *s = "DW_AT_MIPS_software_pipeline_depth"; break; case DW_AT_MIPS_linkage_name: *s = "DW_AT_MIPS_linkage_name"; break; case DW_AT_MIPS_stride: *s = "DW_AT_MIPS_stride"; break; case DW_AT_MIPS_abstract_name: *s = "DW_AT_MIPS_abstract_name"; break; case DW_AT_MIPS_clone_origin: *s = "DW_AT_MIPS_clone_origin"; break; case DW_AT_MIPS_has_inlines: *s = "DW_AT_MIPS_has_inlines"; break; case DW_AT_MIPS_stride_byte: *s = "DW_AT_MIPS_stride_byte"; break; case DW_AT_MIPS_stride_elem: *s = "DW_AT_MIPS_stride_elem"; break; case DW_AT_MIPS_ptr_dopetype: *s = "DW_AT_MIPS_ptr_dopetype"; break; case DW_AT_MIPS_allocatable_dopetype: *s = "DW_AT_MIPS_allocatable_dopetype"; break; case DW_AT_MIPS_assumed_shape_dopetype: *s = "DW_AT_MIPS_assumed_shape_dopetype"; break; case DW_AT_MIPS_assumed_size: *s = "DW_AT_MIPS_assumed_size"; break; case DW_AT_GNU_vector: *s = "DW_AT_GNU_vector"; break; case DW_AT_GNU_guarded_by: *s = "DW_AT_GNU_guarded_by"; break; case DW_AT_GNU_pt_guarded_by: *s = "DW_AT_GNU_pt_guarded_by"; break; case DW_AT_GNU_guarded: *s = "DW_AT_GNU_guarded"; break; case DW_AT_GNU_pt_guarded: *s = "DW_AT_GNU_pt_guarded"; break; case DW_AT_GNU_locks_excluded: *s = "DW_AT_GNU_locks_excluded"; break; case DW_AT_GNU_exclusive_locks_required: *s = "DW_AT_GNU_exclusive_locks_required"; break; case DW_AT_GNU_shared_locks_required: *s = "DW_AT_GNU_shared_locks_required"; break; case DW_AT_GNU_odr_signature: *s = "DW_AT_GNU_odr_signature"; break; case DW_AT_GNU_template_name: *s = "DW_AT_GNU_template_name"; break; case DW_AT_GNU_call_site_value: *s = "DW_AT_GNU_call_site_value"; break; case DW_AT_GNU_call_site_data_value: *s = "DW_AT_GNU_call_site_data_value"; break; case DW_AT_GNU_call_site_target: *s = "DW_AT_GNU_call_site_target"; break; case DW_AT_GNU_call_site_target_clobbered: *s = "DW_AT_GNU_call_site_target_clobbered"; break; case DW_AT_GNU_tail_call: *s = "DW_AT_GNU_tail_call"; break; case DW_AT_GNU_all_tail_call_sites: *s = "DW_AT_GNU_all_tail_call_sites"; break; case DW_AT_GNU_all_call_sites: *s = "DW_AT_GNU_all_call_sites"; break; case DW_AT_GNU_all_source_call_sites: *s = "DW_AT_GNU_all_source_call_sites"; break; case DW_AT_APPLE_optimized: *s = "DW_AT_APPLE_optimized"; break; case DW_AT_APPLE_flags: *s = "DW_AT_APPLE_flags"; break; case DW_AT_APPLE_isa: *s = "DW_AT_APPLE_isa"; break; case DW_AT_APPLE_block: *s = "DW_AT_APPLE_block"; break; case DW_AT_APPLE_major_runtime_vers: *s = "DW_AT_APPLE_major_runtime_vers"; break; case DW_AT_APPLE_runtime_class: *s = "DW_AT_APPLE_runtime_class"; break; case DW_AT_APPLE_omit_frame_ptr: *s = "DW_AT_APPLE_omit_frame_ptr"; break; case DW_AT_APPLE_property_name: *s = "DW_AT_APPLE_property_name"; break; case DW_AT_APPLE_property_getter: *s = "DW_AT_APPLE_property_getter"; break; case DW_AT_APPLE_property_setter: *s = "DW_AT_APPLE_property_setter"; break; case DW_AT_APPLE_property_attribute: *s = "DW_AT_APPLE_property_attribute"; break; case DW_AT_APPLE_objc_complete_type: *s = "DW_AT_APPLE_objc_complete_type"; break; case DW_AT_APPLE_property: *s = "DW_AT_APPLE_property"; break; default: return (DW_DLV_NO_ENTRY); } return (DW_DLV_OK); } int dwarf_get_ATE_name(unsigned ate, const char **s) { assert(s != NULL); - switch(ate) { + switch (ate) { case DW_ATE_address: *s = "DW_ATE_address"; break; case DW_ATE_boolean: *s = "DW_ATE_boolean"; break; case DW_ATE_complex_float: *s = "DW_ATE_complex_float"; break; case DW_ATE_float: *s = "DW_ATE_float"; break; case DW_ATE_signed: *s = "DW_ATE_signed"; break; case DW_ATE_signed_char: *s = "DW_ATE_signed_char"; break; case DW_ATE_unsigned: *s = "DW_ATE_unsigned"; break; case DW_ATE_unsigned_char: *s = "DW_ATE_unsigned_char"; break; case DW_ATE_imaginary_float: *s = "DW_ATE_imaginary_float"; break; case DW_ATE_packed_decimal: *s = "DW_ATE_packed_decimal"; break; case DW_ATE_numeric_string: *s = "DW_ATE_numeric_string"; break; case DW_ATE_edited: *s = "DW_ATE_edited"; break; case DW_ATE_signed_fixed: *s = "DW_ATE_signed_fixed"; break; case DW_ATE_unsigned_fixed: *s = "DW_ATE_unsigned_fixed"; break; case DW_ATE_decimal_float: *s = "DW_ATE_decimal_float"; break; + case DW_ATE_UTF: + *s = "DW_ATE_UTF"; break; + case DW_ATE_UCS: + *s = "DW_ATE_UCS"; break; + case DW_ATE_ASCII: + *s = "DW_ATE_ASCII"; break; case DW_ATE_lo_user: *s = "DW_ATE_lo_user"; break; case DW_ATE_hi_user: *s = "DW_ATE_hi_user"; break; default: return (DW_DLV_NO_ENTRY); } return (DW_DLV_OK); } int dwarf_get_CC_name(unsigned cc, const char **s) { assert(s != NULL); switch (cc) { case DW_CC_normal: *s = "DW_CC_normal"; break; case DW_CC_program: *s = "DW_CC_program"; break; case DW_CC_nocall: *s = "DW_CC_nocall"; break; + case DW_CC_pass_by_reference: + *s = "DW_CC_pass_by_reference"; break; + case DW_CC_pass_by_value: + *s = "DW_CC_pass_by_value"; break; case DW_CC_lo_user: *s = "DW_CC_lo_user"; break; case DW_CC_hi_user: *s = "DW_CC_hi_user"; break; default: return (DW_DLV_NO_ENTRY); } return (DW_DLV_OK); } int dwarf_get_CFA_name(unsigned cfa, const char **s) { assert(s != NULL); switch (cfa) { case DW_CFA_advance_loc: *s = "DW_CFA_advance_loc"; break; case DW_CFA_offset: *s = "DW_CFA_offset"; break; case DW_CFA_restore: *s = "DW_CFA_restore"; break; case DW_CFA_nop: *s = "DW_CFA_nop"; break; case DW_CFA_set_loc: *s = "DW_CFA_set_loc"; break; case DW_CFA_advance_loc1: *s = "DW_CFA_advance_loc1"; break; case DW_CFA_advance_loc2: *s = "DW_CFA_advance_loc2"; break; case DW_CFA_advance_loc4: *s = "DW_CFA_advance_loc4"; break; case DW_CFA_offset_extended: *s = "DW_CFA_offset_extended"; break; case DW_CFA_restore_extended: *s = "DW_CFA_restore_extended"; break; case DW_CFA_undefined: *s = "DW_CFA_undefined"; break; case DW_CFA_same_value: *s = "DW_CFA_same_value"; break; case DW_CFA_register: *s = "DW_CFA_register"; break; case DW_CFA_remember_state: *s = "DW_CFA_remember_state"; break; case DW_CFA_restore_state: *s = "DW_CFA_restore_state"; break; case DW_CFA_def_cfa: *s = "DW_CFA_def_cfa"; break; case DW_CFA_def_cfa_register: *s = "DW_CFA_def_cfa_register"; break; case DW_CFA_def_cfa_offset: *s = "DW_CFA_def_cfa_offset"; break; case DW_CFA_def_cfa_expression: *s = "DW_CFA_def_cfa_expression"; break; case DW_CFA_expression: *s = "DW_CFA_expression"; break; case DW_CFA_offset_extended_sf: *s = "DW_CFA_offset_extended_sf"; break; case DW_CFA_def_cfa_sf: *s = "DW_CFA_def_cfa_sf"; break; case DW_CFA_def_cfa_offset_sf: *s = "DW_CFA_def_cfa_offset_sf"; break; case DW_CFA_val_offset: *s = "DW_CFA_val_offset"; break; case DW_CFA_val_offset_sf: *s = "DW_CFA_val_offset_sf"; break; case DW_CFA_val_expression: *s = "DW_CFA_val_expression"; break; case DW_CFA_lo_user: *s = "DW_CFA_lo_user"; break; case DW_CFA_high_user: *s = "DW_CFA_high_user"; break; default: return (DW_DLV_NO_ENTRY); } return (DW_DLV_OK); } int dwarf_get_CHILDREN_name(unsigned children, const char **s) { assert(s != NULL); switch (children) { case DW_CHILDREN_no: *s = "DW_CHILDREN_no"; break; case DW_CHILDREN_yes: *s = "DW_CHILDREN_yes"; break; default: return (DW_DLV_NO_ENTRY); } return (DW_DLV_OK); } int dwarf_get_FORM_name(unsigned form, const char **s) { assert(s != NULL); switch (form) { case DW_FORM_addr: *s = "DW_FORM_addr"; break; case DW_FORM_block: *s = "DW_FORM_block"; break; case DW_FORM_block1: *s = "DW_FORM_block1"; break; case DW_FORM_block2: *s = "DW_FORM_block2"; break; case DW_FORM_block4: *s = "DW_FORM_block4"; break; case DW_FORM_data1: *s = "DW_FORM_data1"; break; case DW_FORM_data2: *s = "DW_FORM_data2"; break; case DW_FORM_data4: *s = "DW_FORM_data4"; break; case DW_FORM_data8: *s = "DW_FORM_data8"; break; case DW_FORM_exprloc: *s = "DW_FORM_exprloc"; break; case DW_FORM_flag: *s = "DW_FORM_flag"; break; case DW_FORM_flag_present: *s = "DW_FORM_flag_present"; break; case DW_FORM_indirect: *s = "DW_FORM_indirect"; break; case DW_FORM_ref1: *s = "DW_FORM_ref1"; break; case DW_FORM_ref2: *s = "DW_FORM_ref2"; break; case DW_FORM_ref4: *s = "DW_FORM_ref4"; break; case DW_FORM_ref8: *s = "DW_FORM_ref8"; break; case DW_FORM_ref_addr: *s = "DW_FORM_ref_addr"; break; case DW_FORM_ref_sig8: *s = "DW_FORM_ref_sig8"; break; case DW_FORM_ref_udata: *s = "DW_FORM_ref_udata"; break; case DW_FORM_sdata: *s = "DW_FORM_sdata"; break; case DW_FORM_sec_offset: *s = "DW_FORM_sec_offset"; break; case DW_FORM_string: *s = "DW_FORM_string"; break; case DW_FORM_strp: *s = "DW_FORM_strp"; break; case DW_FORM_udata: *s = "DW_FORM_udata"; break; + case DW_FORM_strx: + *s = "DW_FORM_strx"; break; + case DW_FORM_addrx: + *s = "DW_FORM_addrx"; break; + case DW_FORM_ref_sup4: + *s = "DW_FORM_ref_sup4"; break; + case DW_FORM_strp_sup: + *s = "DW_FORM_strp_sup"; break; + case DW_FORM_data16: + *s = "DW_FORM_data16"; break; + case DW_FORM_line_strp: + *s = "DW_FORM_line_strp"; break; + case DW_FORM_implicit_const: + *s = "DW_FORM_implicit_const"; break; + case DW_FORM_loclistx: + *s = "DW_FORM_loclistx"; break; + case DW_FORM_rnglistx: + *s = "DW_FORM_rnglistx"; break; + case DW_FORM_ref_sup8: + *s = "DW_FORM_ref_sup8"; break; + case DW_FORM_ref_strx1: + *s = "DW_FORM_ref_strx1"; break; + case DW_FORM_ref_strx2: + *s = "DW_FORM_ref_strx2"; break; + case DW_FORM_ref_strx3: + *s = "DW_FORM_ref_strx3"; break; + case DW_FORM_ref_strx4: + *s = "DW_FORM_ref_strx4"; break; + case DW_FORM_ref_addrx1: + *s = "DW_FORM_ref_addrx1"; break; + case DW_FORM_ref_addrx2: + *s = "DW_FORM_ref_addrx2"; break; + case DW_FORM_ref_addrx3: + *s = "DW_FORM_ref_addrx3"; break; + case DW_FORM_ref_addrx4: + *s = "DW_FORM_ref_addrx4"; break; default: return (DW_DLV_NO_ENTRY); } return (DW_DLV_OK); } int dwarf_get_DS_name(unsigned ds, const char **s) { assert(s != NULL); switch (ds) { case DW_DS_unsigned: *s = "DW_DS_unsigned"; break; case DW_DS_leading_overpunch: *s = "DW_DS_leading_overpunch"; break; case DW_DS_trailing_overpunch: *s = "DW_DS_trailing_overpunch"; break; case DW_DS_leading_separate: *s = "DW_DS_leading_separate"; break; case DW_DS_trailing_separate: *s = "DW_DS_trailing_separate"; break; default: return (DW_DLV_NO_ENTRY); } return (DW_DLV_OK); } int dwarf_get_DSC_name(unsigned dsc, const char **s) { assert(s != NULL); switch (dsc) { case DW_DSC_label: *s = "DW_DSC_label"; break; case DW_DSC_range: *s = "DW_DSC_range"; break; default: return (DW_DLV_NO_ENTRY); } return (DW_DLV_OK); } int dwarf_get_EH_name(unsigned eh, const char **s) { assert(s != NULL); switch (eh) { case DW_EH_PE_absptr: *s = "DW_EH_PE_absptr"; break; case DW_EH_PE_uleb128: *s = "DW_EH_PE_uleb128"; break; case DW_EH_PE_udata2: *s = "DW_EH_PE_udata2"; break; case DW_EH_PE_udata4: *s = "DW_EH_PE_udata4"; break; case DW_EH_PE_udata8: *s = "DW_EH_PE_udata8"; break; case DW_EH_PE_sleb128: *s = "DW_EH_PE_sleb128"; break; case DW_EH_PE_sdata2: *s = "DW_EH_PE_sdata2"; break; case DW_EH_PE_sdata4: *s = "DW_EH_PE_sdata4"; break; case DW_EH_PE_sdata8: *s = "DW_EH_PE_sdata8"; break; case DW_EH_PE_pcrel: *s = "DW_EH_PE_pcrel"; break; case DW_EH_PE_textrel: *s = "DW_EH_PE_textrel"; break; case DW_EH_PE_datarel: *s = "DW_EH_PE_datarel"; break; case DW_EH_PE_funcrel: *s = "DW_EH_PE_funcrel"; break; case DW_EH_PE_aligned: *s = "DW_EH_PE_aligned"; break; case DW_EH_PE_omit: *s = "DW_EH_PE_omit"; break; default: return (DW_DLV_NO_ENTRY); } return (DW_DLV_OK); } int dwarf_get_END_name(unsigned end, const char **s) { assert(s != NULL); switch (end) { case DW_END_default: *s = "DW_END_default"; break; case DW_END_big: *s = "DW_END_big"; break; case DW_END_little: *s = "DW_END_little"; break; case DW_END_lo_user: *s = "DW_END_lo_user"; break; case DW_END_high_user: *s = "DW_END_high_user"; break; default: return (DW_DLV_NO_ENTRY); } return (DW_DLV_OK); } int dwarf_get_ID_name(unsigned id, const char **s) { assert(s != NULL); switch (id) { case DW_ID_case_sensitive: *s = "DW_ID_case_sensitive"; break; case DW_ID_up_case: *s = "DW_ID_up_case"; break; case DW_ID_down_case: *s = "DW_ID_down_case"; break; case DW_ID_case_insensitive: *s = "DW_ID_case_insensitive"; break; default: return (DW_DLV_NO_ENTRY); } return (DW_DLV_OK); } int dwarf_get_INL_name(unsigned inl, const char **s) { assert(s != NULL); switch (inl) { case DW_INL_not_inlined: *s = "DW_INL_not_inlined"; break; case DW_INL_inlined: *s = "DW_INL_inlined"; break; case DW_INL_declared_not_inlined: *s = "DW_INL_declared_not_inlined"; break; case DW_INL_declared_inlined: *s = "DW_INL_declared_inlined"; break; default: return (DW_DLV_NO_ENTRY); } return (DW_DLV_OK); } int dwarf_get_LANG_name(unsigned lang, const char **s) { assert(s != NULL); switch (lang) { case DW_LANG_C89: *s = "DW_LANG_C89"; break; case DW_LANG_C: *s = "DW_LANG_C"; break; case DW_LANG_Ada83: *s = "DW_LANG_Ada83"; break; case DW_LANG_C_plus_plus: *s = "DW_LANG_C_plus_plus"; break; case DW_LANG_Cobol74: *s = "DW_LANG_Cobol74"; break; case DW_LANG_Cobol85: *s = "DW_LANG_Cobol85"; break; case DW_LANG_Fortran77: *s = "DW_LANG_Fortran77"; break; case DW_LANG_Fortran90: *s = "DW_LANG_Fortran90"; break; case DW_LANG_Pascal83: *s = "DW_LANG_Pascal83"; break; case DW_LANG_Modula2: *s = "DW_LANG_Modula2"; break; case DW_LANG_Java: *s = "DW_LANG_Java"; break; case DW_LANG_C99: *s = "DW_LANG_C99"; break; case DW_LANG_Ada95: *s = "DW_LANG_Ada95"; break; case DW_LANG_Fortran95: *s = "DW_LANG_Fortran95"; break; case DW_LANG_PLI: *s = "DW_LANG_PLI"; break; case DW_LANG_ObjC: *s = "DW_LANG_ObjC"; break; case DW_LANG_ObjC_plus_plus: *s = "DW_LANG_ObjC_plus_plus"; break; case DW_LANG_UPC: *s = "DW_LANG_UPC"; break; case DW_LANG_D: *s = "DW_LANG_D"; break; case DW_LANG_Python: *s = "DW_LANG_Python"; break; case DW_LANG_OpenCL: *s = "DW_LANG_OpenCL"; break; case DW_LANG_Go: *s = "DW_LANG_Go"; break; case DW_LANG_Modula3: *s = "DW_LANG_Modula3"; break; case DW_LANG_Haskell: *s = "DW_LANG_Haskell"; break; case DW_LANG_C_plus_plus_03: *s = "DW_LANG_C_plus_plus_03"; break; case DW_LANG_C_plus_plus_11: *s = "DW_LANG_C_plus_plus_11"; break; case DW_LANG_OCaml: *s = "DW_LANG_OCaml"; break; case DW_LANG_Rust: *s = "DW_LANG_Rust"; break; case DW_LANG_C11: *s = "DW_LANG_C11"; break; case DW_LANG_Swift: *s = "DW_LANG_Swift"; break; case DW_LANG_Julia: *s = "DW_LANG_Julia"; break; case DW_LANG_Dylan: *s = "DW_LANG_Dylan"; break; case DW_LANG_C_plus_plus_14: *s = "DW_LANG_C_plus_plus_14"; break; case DW_LANG_Fortran03: *s = "DW_LANG_Fortran03"; break; case DW_LANG_Fortran08: *s = "DW_LANG_Fortran08"; break; case DW_LANG_RenderScript: *s = "DW_LANG_RenderScript"; break; case DW_LANG_BLISS: *s = "DW_LANG_BLISS"; break; case DW_LANG_lo_user: *s = "DW_LANG_lo_user"; break; case DW_LANG_Mips_Assembler: *s = "DW_LANG_Mips_Assembler"; break; case DW_LANG_hi_user: *s = "DW_LANG_hi_user"; break; default: return (DW_DLV_NO_ENTRY); } return (DW_DLV_OK); } int dwarf_get_LNE_name(unsigned lne, const char **s) { assert(s != NULL); switch (lne) { case DW_LNE_end_sequence: *s = "DW_LNE_end_sequence"; break; case DW_LNE_set_address: *s = "DW_LNE_set_address"; break; case DW_LNE_define_file: *s = "DW_LNE_define_file"; break; case DW_LNE_lo_user: *s = "DW_LNE_lo_user"; break; case DW_LNE_hi_user: *s = "DW_LNE_hi_user"; break; default: return (DW_DLV_NO_ENTRY); } return (DW_DLV_OK); } int dwarf_get_LNS_name(unsigned lns, const char **s) { assert(s != NULL); switch (lns) { case DW_LNS_copy: *s = "DW_LNS_copy"; break; case DW_LNS_advance_pc: *s = "DW_LNS_advance_pc"; break; case DW_LNS_advance_line: *s = "DW_LNS_advance_line"; break; case DW_LNS_set_file: *s = "DW_LNS_set_file"; break; case DW_LNS_set_column: *s = "DW_LNS_set_column"; break; case DW_LNS_negate_stmt: *s = "DW_LNS_negate_stmt"; break; case DW_LNS_set_basic_block: *s = "DW_LNS_set_basic_block"; break; case DW_LNS_const_add_pc: *s = "DW_LNS_const_add_pc"; break; case DW_LNS_fixed_advance_pc: *s = "DW_LNS_fixed_advance_pc"; break; case DW_LNS_set_prologue_end: *s = "DW_LNS_set_prologue_end"; break; case DW_LNS_set_epilogue_begin: *s = "DW_LNS_set_epilogue_begin"; break; case DW_LNS_set_isa: *s = "DW_LNS_set_isa"; break; default: return (DW_DLV_NO_ENTRY); } return (DW_DLV_OK); } int dwarf_get_MACINFO_name(unsigned mi, const char **s) { assert(s != NULL); switch (mi) { case DW_MACINFO_define: *s = "DW_MACINFO_define"; break; case DW_MACINFO_undef: *s = "DW_MACINFO_undef"; break; case DW_MACINFO_start_file: *s = "DW_MACINFO_start_file"; break; case DW_MACINFO_end_file: *s = "DW_MACINFO_end_file"; break; case DW_MACINFO_vendor_ext: *s = "DW_MACINFO_vendor_ext"; break; default: return (DW_DLV_NO_ENTRY); } return (DW_DLV_OK); } int dwarf_get_OP_name(unsigned op, const char **s) { assert(s != NULL); switch (op) { case DW_OP_deref: *s = "DW_OP_deref"; break; case DW_OP_reg0: *s = "DW_OP_reg0"; break; case DW_OP_reg1: *s = "DW_OP_reg1"; break; case DW_OP_reg2: *s = "DW_OP_reg2"; break; case DW_OP_reg3: *s = "DW_OP_reg3"; break; case DW_OP_reg4: *s = "DW_OP_reg4"; break; case DW_OP_reg5: *s = "DW_OP_reg5"; break; case DW_OP_reg6: *s = "DW_OP_reg6"; break; case DW_OP_reg7: *s = "DW_OP_reg7"; break; case DW_OP_reg8: *s = "DW_OP_reg8"; break; case DW_OP_reg9: *s = "DW_OP_reg9"; break; case DW_OP_reg10: *s = "DW_OP_reg10"; break; case DW_OP_reg11: *s = "DW_OP_reg11"; break; case DW_OP_reg12: *s = "DW_OP_reg12"; break; case DW_OP_reg13: *s = "DW_OP_reg13"; break; case DW_OP_reg14: *s = "DW_OP_reg14"; break; case DW_OP_reg15: *s = "DW_OP_reg15"; break; case DW_OP_reg16: *s = "DW_OP_reg16"; break; case DW_OP_reg17: *s = "DW_OP_reg17"; break; case DW_OP_reg18: *s = "DW_OP_reg18"; break; case DW_OP_reg19: *s = "DW_OP_reg19"; break; case DW_OP_reg20: *s = "DW_OP_reg20"; break; case DW_OP_reg21: *s = "DW_OP_reg21"; break; case DW_OP_reg22: *s = "DW_OP_reg22"; break; case DW_OP_reg23: *s = "DW_OP_reg23"; break; case DW_OP_reg24: *s = "DW_OP_reg24"; break; case DW_OP_reg25: *s = "DW_OP_reg25"; break; case DW_OP_reg26: *s = "DW_OP_reg26"; break; case DW_OP_reg27: *s = "DW_OP_reg27"; break; case DW_OP_reg28: *s = "DW_OP_reg28"; break; case DW_OP_reg29: *s = "DW_OP_reg29"; break; case DW_OP_reg30: *s = "DW_OP_reg30"; break; case DW_OP_reg31: *s = "DW_OP_reg31"; break; case DW_OP_lit0: *s = "DW_OP_lit0"; break; case DW_OP_lit1: *s = "DW_OP_lit1"; break; case DW_OP_lit2: *s = "DW_OP_lit2"; break; case DW_OP_lit3: *s = "DW_OP_lit3"; break; case DW_OP_lit4: *s = "DW_OP_lit4"; break; case DW_OP_lit5: *s = "DW_OP_lit5"; break; case DW_OP_lit6: *s = "DW_OP_lit6"; break; case DW_OP_lit7: *s = "DW_OP_lit7"; break; case DW_OP_lit8: *s = "DW_OP_lit8"; break; case DW_OP_lit9: *s = "DW_OP_lit9"; break; case DW_OP_lit10: *s = "DW_OP_lit10"; break; case DW_OP_lit11: *s = "DW_OP_lit11"; break; case DW_OP_lit12: *s = "DW_OP_lit12"; break; case DW_OP_lit13: *s = "DW_OP_lit13"; break; case DW_OP_lit14: *s = "DW_OP_lit14"; break; case DW_OP_lit15: *s = "DW_OP_lit15"; break; case DW_OP_lit16: *s = "DW_OP_lit16"; break; case DW_OP_lit17: *s = "DW_OP_lit17"; break; case DW_OP_lit18: *s = "DW_OP_lit18"; break; case DW_OP_lit19: *s = "DW_OP_lit19"; break; case DW_OP_lit20: *s = "DW_OP_lit20"; break; case DW_OP_lit21: *s = "DW_OP_lit21"; break; case DW_OP_lit22: *s = "DW_OP_lit22"; break; case DW_OP_lit23: *s = "DW_OP_lit23"; break; case DW_OP_lit24: *s = "DW_OP_lit24"; break; case DW_OP_lit25: *s = "DW_OP_lit25"; break; case DW_OP_lit26: *s = "DW_OP_lit26"; break; case DW_OP_lit27: *s = "DW_OP_lit27"; break; case DW_OP_lit28: *s = "DW_OP_lit28"; break; case DW_OP_lit29: *s = "DW_OP_lit29"; break; case DW_OP_lit30: *s = "DW_OP_lit30"; break; case DW_OP_lit31: *s = "DW_OP_lit31"; break; case DW_OP_dup: *s = "DW_OP_dup"; break; case DW_OP_drop: *s = "DW_OP_drop"; break; case DW_OP_over: *s = "DW_OP_over"; break; case DW_OP_swap: *s = "DW_OP_swap"; break; case DW_OP_rot: *s = "DW_OP_rot"; break; case DW_OP_xderef: *s = "DW_OP_xderef"; break; case DW_OP_abs: *s = "DW_OP_abs"; break; case DW_OP_and: *s = "DW_OP_and"; break; case DW_OP_div: *s = "DW_OP_div"; break; case DW_OP_minus: *s = "DW_OP_minus"; break; case DW_OP_mod: *s = "DW_OP_mod"; break; case DW_OP_mul: *s = "DW_OP_mul"; break; case DW_OP_neg: *s = "DW_OP_neg"; break; case DW_OP_not: *s = "DW_OP_not"; break; case DW_OP_or: *s = "DW_OP_or"; break; case DW_OP_plus: *s = "DW_OP_plus"; break; case DW_OP_shl: *s = "DW_OP_shl"; break; case DW_OP_shr: *s = "DW_OP_shr"; break; case DW_OP_shra: *s = "DW_OP_shra"; break; case DW_OP_xor: *s = "DW_OP_xor"; break; case DW_OP_eq: *s = "DW_OP_eq"; break; case DW_OP_ge: *s = "DW_OP_ge"; break; case DW_OP_gt: *s = "DW_OP_gt"; break; case DW_OP_le: *s = "DW_OP_le"; break; case DW_OP_lt: *s = "DW_OP_lt"; break; case DW_OP_ne: *s = "DW_OP_ne"; break; case DW_OP_nop: *s = "DW_OP_nop"; break; case DW_OP_const1u: *s = "DW_OP_const1u"; break; case DW_OP_const1s: *s = "DW_OP_const1s"; break; case DW_OP_pick: *s = "DW_OP_pick"; break; case DW_OP_deref_size: *s = "DW_OP_deref_size"; break; case DW_OP_xderef_size: *s = "DW_OP_xderef_size"; break; case DW_OP_const2u: *s = "DW_OP_const2u"; break; case DW_OP_const2s: *s = "DW_OP_const2s"; break; case DW_OP_bra: *s = "DW_OP_bra"; break; case DW_OP_skip: *s = "DW_OP_skip"; break; case DW_OP_const4u: *s = "DW_OP_const4u"; break; case DW_OP_const4s: *s = "DW_OP_const4s"; break; case DW_OP_const8u: *s = "DW_OP_const8u"; break; case DW_OP_const8s: *s = "DW_OP_const8s"; break; case DW_OP_constu: *s = "DW_OP_constu"; break; case DW_OP_plus_uconst: *s = "DW_OP_plus_uconst"; break; case DW_OP_regx: *s = "DW_OP_regx"; break; case DW_OP_piece: *s = "DW_OP_piece"; break; case DW_OP_consts: *s = "DW_OP_consts"; break; case DW_OP_breg0: *s = "DW_OP_breg0"; break; case DW_OP_breg1: *s = "DW_OP_breg1"; break; case DW_OP_breg2: *s = "DW_OP_breg2"; break; case DW_OP_breg3: *s = "DW_OP_breg3"; break; case DW_OP_breg4: *s = "DW_OP_breg4"; break; case DW_OP_breg5: *s = "DW_OP_breg5"; break; case DW_OP_breg6: *s = "DW_OP_breg6"; break; case DW_OP_breg7: *s = "DW_OP_breg7"; break; case DW_OP_breg8: *s = "DW_OP_breg8"; break; case DW_OP_breg9: *s = "DW_OP_breg9"; break; case DW_OP_breg10: *s = "DW_OP_breg10"; break; case DW_OP_breg11: *s = "DW_OP_breg11"; break; case DW_OP_breg12: *s = "DW_OP_breg12"; break; case DW_OP_breg13: *s = "DW_OP_breg13"; break; case DW_OP_breg14: *s = "DW_OP_breg14"; break; case DW_OP_breg15: *s = "DW_OP_breg15"; break; case DW_OP_breg16: *s = "DW_OP_breg16"; break; case DW_OP_breg17: *s = "DW_OP_breg17"; break; case DW_OP_breg18: *s = "DW_OP_breg18"; break; case DW_OP_breg19: *s = "DW_OP_breg19"; break; case DW_OP_breg20: *s = "DW_OP_breg20"; break; case DW_OP_breg21: *s = "DW_OP_breg21"; break; case DW_OP_breg22: *s = "DW_OP_breg22"; break; case DW_OP_breg23: *s = "DW_OP_breg23"; break; case DW_OP_breg24: *s = "DW_OP_breg24"; break; case DW_OP_breg25: *s = "DW_OP_breg25"; break; case DW_OP_breg26: *s = "DW_OP_breg26"; break; case DW_OP_breg27: *s = "DW_OP_breg27"; break; case DW_OP_breg28: *s = "DW_OP_breg28"; break; case DW_OP_breg29: *s = "DW_OP_breg29"; break; case DW_OP_breg30: *s = "DW_OP_breg30"; break; case DW_OP_breg31: *s = "DW_OP_breg31"; break; case DW_OP_fbreg: *s = "DW_OP_fbreg"; break; case DW_OP_bregx: *s = "DW_OP_bregx"; break; case DW_OP_addr: *s = "DW_OP_addr"; break; case DW_OP_push_object_address: *s = "DW_OP_push_object_address"; break; case DW_OP_call2: *s = "DW_OP_call2"; break; case DW_OP_call4: *s = "DW_OP_call4"; break; case DW_OP_call_ref: *s = "DW_OP_call_ref"; break; case DW_OP_form_tls_address: *s = "DW_OP_form_tls_address"; break; case DW_OP_call_frame_cfa: *s = "DW_OP_call_frame_cfa"; break; case DW_OP_bit_piece: *s = "DW_OP_bit_piece"; break; case DW_OP_implicit_value: *s = "DW_OP_implicit_value"; break; case DW_OP_stack_value: *s = "DW_OP_stack_value"; break; + case DW_OP_implicit_pointer: + *s = "DW_OP_implicit_pointer"; break; + case DW_OP_addrx: + *s = "DW_OP_addrx"; break; + case DW_OP_constx: + *s = "DW_OP_constx"; break; + case DW_OP_entry_value: + *s = "DW_OP_entry_value"; break; + case DW_OP_const_type: + *s = "DW_OP_const_type"; break; + case DW_OP_regval_type: + *s = "DW_OP_regval_type"; break; + case DW_OP_deref_type: + *s = "DW_OP_deref_type"; break; + case DW_OP_xderef_type: + *s = "DW_OP_xderef_type"; break; + case DW_OP_convert: + *s = "DW_OP_convert"; break; + case DW_OP_reinterpret: + *s = "DW_OP_reinterpret"; break; case DW_OP_GNU_push_tls_address: *s = "DW_OP_GNU_push_tls_address"; break; case DW_OP_GNU_uninit: *s = "DW_OP_GNU_uninit"; break; case DW_OP_GNU_encoded_addr: *s = "DW_OP_GNU_encoded_addr"; break; case DW_OP_GNU_implicit_pointer: *s = "DW_OP_GNU_implicit_pointer"; break; case DW_OP_GNU_entry_value: *s = "DW_OP_GNU_entry_value"; break; case DW_OP_GNU_const_type: *s = "DW_OP_GNU_const_type"; break; case DW_OP_GNU_regval_type: *s = "DW_OP_GNU_regval_type"; break; case DW_OP_GNU_deref_type: *s = "DW_OP_GNU_deref_type"; break; case DW_OP_GNU_convert: *s = "DW_OP_GNU_convert"; break; case DW_OP_GNU_reinterpret: *s = "DW_OP_GNU_reinterpret"; break; case DW_OP_GNU_parameter_ref: *s = "DW_OP_GNU_parameter_ref"; break; case DW_OP_GNU_addr_index: *s = "DW_OP_GNU_addr_index"; break; case DW_OP_GNU_const_index: *s = "DW_OP_GNU_const_index"; break; default: return (DW_DLV_NO_ENTRY); } return (DW_DLV_OK); } int dwarf_get_ORD_name(unsigned ord, const char **s) { assert(s != NULL); switch (ord) { case DW_ORD_row_major: *s = "DW_ORD_row_major"; break; case DW_ORD_col_major: *s = "DW_ORD_col_major"; break; default: return (DW_DLV_NO_ENTRY); } return (DW_DLV_OK); } int dwarf_get_TAG_name(unsigned tag, const char **s) { assert(s != NULL); switch (tag) { case DW_TAG_access_declaration: *s = "DW_TAG_access_declaration"; break; case DW_TAG_array_type: *s = "DW_TAG_array_type"; break; case DW_TAG_base_type: *s = "DW_TAG_base_type"; break; case DW_TAG_catch_block: *s = "DW_TAG_catch_block"; break; case DW_TAG_class_type: *s = "DW_TAG_class_type"; break; case DW_TAG_common_block: *s = "DW_TAG_common_block"; break; case DW_TAG_common_inclusion: *s = "DW_TAG_common_inclusion"; break; case DW_TAG_compile_unit: *s = "DW_TAG_compile_unit"; break; case DW_TAG_condition: *s = "DW_TAG_condition"; break; case DW_TAG_const_type: *s = "DW_TAG_const_type"; break; case DW_TAG_constant: *s = "DW_TAG_constant"; break; case DW_TAG_dwarf_procedure: *s = "DW_TAG_dwarf_procedure"; break; case DW_TAG_entry_point: *s = "DW_TAG_entry_point"; break; case DW_TAG_enumeration_type: *s = "DW_TAG_enumeration_type"; break; case DW_TAG_enumerator: *s = "DW_TAG_enumerator"; break; case DW_TAG_formal_parameter: *s = "DW_TAG_formal_parameter"; break; case DW_TAG_friend: *s = "DW_TAG_friend"; break; case DW_TAG_imported_declaration: *s = "DW_TAG_imported_declaration"; break; case DW_TAG_imported_module: *s = "DW_TAG_imported_module"; break; case DW_TAG_imported_unit: *s = "DW_TAG_imported_unit"; break; case DW_TAG_inheritance: *s = "DW_TAG_inheritance"; break; case DW_TAG_inlined_subroutine: *s = "DW_TAG_inlined_subroutine"; break; case DW_TAG_interface_type: *s = "DW_TAG_interface_type"; break; case DW_TAG_label: *s = "DW_TAG_label"; break; case DW_TAG_lexical_block: *s = "DW_TAG_lexical_block"; break; case DW_TAG_member: *s = "DW_TAG_member"; break; case DW_TAG_module: *s = "DW_TAG_module"; break; case DW_TAG_namelist: *s = "DW_TAG_namelist"; break; case DW_TAG_namelist_item: *s = "DW_TAG_namelist_item"; break; case DW_TAG_namespace: *s = "DW_TAG_namespace"; break; case DW_TAG_packed_type: *s = "DW_TAG_packed_type"; break; case DW_TAG_partial_unit: *s = "DW_TAG_partial_unit"; break; case DW_TAG_pointer_type: *s = "DW_TAG_pointer_type"; break; case DW_TAG_ptr_to_member_type: *s = "DW_TAG_ptr_to_member_type"; break; case DW_TAG_reference_type: *s = "DW_TAG_reference_type"; break; case DW_TAG_restrict_type: *s = "DW_TAG_restrict_type"; break; case DW_TAG_rvalue_reference_type: *s = "DW_TAG_rvalue_reference_type"; break; case DW_TAG_set_type: *s = "DW_TAG_set_type"; break; case DW_TAG_shared_type: *s = "DW_TAG_shared_type"; break; case DW_TAG_string_type: *s = "DW_TAG_string_type"; break; case DW_TAG_structure_type: *s = "DW_TAG_structure_type"; break; case DW_TAG_subprogram: *s = "DW_TAG_subprogram"; break; case DW_TAG_subrange_type: *s = "DW_TAG_subrange_type"; break; case DW_TAG_subroutine_type: *s = "DW_TAG_subroutine_type"; break; case DW_TAG_template_alias: *s = "DW_TAG_template_alias"; break; case DW_TAG_template_type_parameter: *s = "DW_TAG_template_type_parameter"; break; case DW_TAG_template_value_parameter: *s = "DW_TAG_template_value_parameter"; break; case DW_TAG_thrown_type: *s = "DW_TAG_thrown_type"; break; case DW_TAG_try_block: *s = "DW_TAG_try_block"; break; case DW_TAG_type_unit: *s = "DW_TAG_type_unit"; break; case DW_TAG_typedef: *s = "DW_TAG_typedef"; break; case DW_TAG_union_type: *s = "DW_TAG_union_type"; break; case DW_TAG_unspecified_parameters: *s = "DW_TAG_unspecified_parameters"; break; case DW_TAG_unspecified_type: *s = "DW_TAG_unspecified_type"; break; case DW_TAG_variable: *s = "DW_TAG_variable"; break; case DW_TAG_variant: *s = "DW_TAG_variant"; break; case DW_TAG_variant_part: *s = "DW_TAG_variant_part"; break; case DW_TAG_volatile_type: *s = "DW_TAG_volatile_type"; break; case DW_TAG_with_stmt: *s = "DW_TAG_with_stmt"; break; + case DW_TAG_coarray_type: + *s = "DW_TAG_coarray_type"; break; + case DW_TAG_generic_subrange: + *s = "DW_TAG_generic_subrange"; break; + case DW_TAG_dynamic_type: + *s = "DW_TAG_dynamic_type"; break; + case DW_TAG_atomic_type: + *s = "DW_TAG_atomic_type"; break; + case DW_TAG_call_site: + *s = "DW_TAG_call_site"; break; + case DW_TAG_call_site_parameter: + *s = "DW_TAG_call_site_parameter"; break; + case DW_TAG_skeleton_unit: + *s = "DW_TAG_skeleton_unit"; break; + case DW_TAG_immutable_type: + *s = "DW_TAG_immutable_type"; break; case DW_TAG_format_label: *s = "DW_TAG_format_label"; break; case DW_TAG_function_template: *s = "DW_TAG_function_template"; break; case DW_TAG_class_template: *s = "DW_TAG_class_template"; break; case DW_TAG_GNU_BINCL: *s = "DW_TAG_GNU_BINCL"; break; case DW_TAG_GNU_EINCL: *s = "DW_TAG_GNU_EINCL"; break; case DW_TAG_GNU_template_template_param: *s = "DW_TAG_GNU_template_template_param"; break; case DW_TAG_GNU_template_parameter_pack: *s = "DW_TAG_GNU_template_parameter_pack"; break; case DW_TAG_GNU_formal_parameter_pack: *s = "DW_TAG_GNU_formal_parameter_pack"; break; case DW_TAG_GNU_call_site: *s = "DW_TAG_GNU_call_site"; break; case DW_TAG_GNU_call_site_parameter: *s = "DW_TAG_GNU_call_site_parameter"; break; default: return (DW_DLV_NO_ENTRY); } return (DW_DLV_OK); } +int +dwarf_get_UT_name(unsigned unit_type, const char **s) +{ + + assert(s != NULL); + + switch (unit_type) { + case DW_UT_compile: + *s = "DW_UT_compile"; break; + case DW_UT_type: + *s = "DW_UT_type"; break; + case DW_UT_partial: + *s = "DW_UT_partial"; break; + case DW_UT_skeleton: + *s = "DW_UT_skeleton"; break; + case DW_UT_split_compile: + *s = "DW_UT_split_compile"; break; + case DW_UT_split_type: + *s = "DW_UT_split_type"; break; + default: + return (DW_DLV_NO_ENTRY); + } + + return (DW_DLV_OK); +} + int dwarf_get_VIRTUALITY_name(unsigned vir, const char **s) { assert(s != NULL); switch (vir) { case DW_VIRTUALITY_none: *s = "DW_VIRTUALITY_none"; break; case DW_VIRTUALITY_virtual: *s = "DW_VIRTUALITY_virtual"; break; case DW_VIRTUALITY_pure_virtual: *s = "DW_VIRTUALITY_pure_virtual"; break; default: return (DW_DLV_NO_ENTRY); } return (DW_DLV_OK); } int dwarf_get_VIS_name(unsigned vis, const char **s) { assert(s != NULL); switch (vis) { case DW_VIS_local: *s = "DW_VIS_local"; break; case DW_VIS_exported: *s = "DW_VIS_exported"; break; case DW_VIS_qualified: *s = "DW_VIS_qualified"; break; default: return (DW_DLV_NO_ENTRY); } return (DW_DLV_OK); } diff --git a/contrib/elftoolchain/libdwarf/dwarf_get_AT_name.3 b/contrib/elftoolchain/libdwarf/dwarf_get_AT_name.3 index f84202664557..4beb430f6006 100644 --- a/contrib/elftoolchain/libdwarf/dwarf_get_AT_name.3 +++ b/contrib/elftoolchain/libdwarf/dwarf_get_AT_name.3 @@ -1,260 +1,269 @@ .\" Copyright (c) 2011 Kai Wang .\" All rights reserved. .\" .\" Redistribution and use in source and binary forms, with or without .\" modification, are permitted provided that the following conditions .\" are met: .\" 1. Redistributions of source code must retain the above copyright .\" notice, this list of conditions and the following disclaimer. .\" 2. 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. .\" .\" THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. .\" .\" $Id: dwarf_get_AT_name.3 3644 2018-10-15 19:55:01Z jkoshy $ .\" -.Dd April 22, 2011 +.Dd January 30, 2023 .Dt DWARF_GET_AT_NAME 3 .Os .Sh NAME .Nm dwarf_get_ACCESS_name , .Nm dwarf_get_AT_name , .Nm dwarf_get_ATE_name , .Nm dwarf_get_CC_name , .Nm dwarf_get_CFA_name , .Nm dwarf_get_CHILDREN_name , .Nm dwarf_get_DS_name , .Nm dwarf_get_DSC_name , .Nm dwarf_get_EH_name , .Nm dwarf_get_END_name , .Nm dwarf_get_FORM_name , .Nm dwarf_get_ID_name , .Nm dwarf_get_INL_name , .Nm dwarf_get_LANG_name , .Nm dwarf_get_LNE_name , .Nm dwarf_get_LNS_name , .Nm dwarf_get_MACINFO_name , .Nm dwarf_get_OP_name , .Nm dwarf_get_ORD_name , .Nm dwarf_get_TAG_name , +.Nm dwarf_get_UT_name , .Nm dwarf_get_VIRTUALITY_name , .Nm dwarf_get_VIS_name .Nd retrieve the symbolic names of DWARF constants .Sh LIBRARY .Lb libdwarf .Sh SYNOPSIS .In libdwarf.h .Ft int .Fo dwarf_get_ACCESS_name .Fa "unsigned val" .Fa "char **str" .Fc .Ft int .Fo dwarf_get_AT_name .Fa "unsigned val" .Fa "char **str" .Fc .Ft int .Fo dwarf_get_ATE_name .Fa "unsigned val" .Fa "char **str" .Fc .Ft int .Fo dwarf_get_CC_name .Fa "unsigned val" .Fa "char **str" .Fc .Ft int .Fo dwarf_get_CFA_name .Fa "unsigned val" .Fa "char **str" .Fc .Ft int .Fo dwarf_get_CHILDREN_name .Fa "unsigned val" .Fa "char **str" .Fc .Ft int .Fo dwarf_get_DS_name .Fa "unsigned val" .Fa "char **str" .Fc .Ft int .Fo dwarf_get_DSC_name .Fa "unsigned val" .Fa "char **str" .Fc .Ft int .Fo dwarf_get_EH_name .Fa "unsigned val" .Fa "char **str" .Fc .Ft int .Fo dwarf_get_END_name .Fa "unsigned val" .Fa "char **str" .Fc .Ft int .Fo dwarf_get_FORM_name .Fa "unsigned val" .Fa "char **str" .Fc .Ft int .Fo dwarf_get_ID_name .Fa "unsigned val" .Fa "char **str" .Fc .Ft int .Fo dwarf_get_INL_name .Fa "unsigned val" .Fa "char **str" .Fc .Ft int .Fo dwarf_get_LANG_name .Fa "unsigned val" .Fa "char **str" .Fc .Ft int .Fo dwarf_get_LNE_name .Fa "unsigned val" .Fa "char **str" .Fc .Ft int .Fo dwarf_get_LNS_name .Fa "unsigned val" .Fa "char **str" .Fc .Ft int .Fo dwarf_get_MACINFO_name .Fa "unsigned val" .Fa "char **str" .Fc .Ft int .Fo dwarf_get_OP_name .Fa "unsigned val" .Fa "char **str" .Fc .Ft int .Fo dwarf_get_ORD_name .Fa "unsigned val" .Fa "char **str" .Fc .Ft int .Fo dwarf_get_TAG_name .Fa "unsigned val" .Fa "char **str" .Fc .Ft int +.Fo dwarf_get_UT_name +.Fa "unsigned unit_type" +.Fa "const char **str" +.Fc +.Ft int .Fo dwarf_get_VIRTUALITY_name .Fa "unsigned val" .Fa "char **str" .Fc .Ft int .Fo dwarf_get_VIS_name .Fa "unsigned val" .Fa "char **str" .Fc .Sh DESCRIPTION These functions return the symbolic name of a numeric DWARF constant. .Pp Argument .Ar val specifies the numeric value whose symbolic name is desired. .Pp Argument .Ar str should point to a location which will hold the returned NUL-terminated string containing the symbolic name of the specified value. .Pp The list of functions and the DWARF constants that they accept are: .Pp .Bl -tag -width ".Fn dwarf_get_VIRTUALITY_name" -compact .It Fn dwarf_get_ACCESS_name .Dv DW_ACCESS_* constants. .It Fn dwarf_get_AT_name .Dv DW_AT_* constants. .It Fn dwarf_get_ATE_name .Dv DW_ATE_* constants. .It Fn dwarf_get_CC_name .Dv DW_CC_* constants. .It Fn dwarf_get_CFA_name .Dv DW_CFA_* constants. .It Fn dwarf_get_CHILDREN_name .Dv DW_CHILDREN_* constants. .It Fn dwarf_get_DS_name .Dv DW_DS_* constants. .It Fn dwarf_get_DSC_name .Dv DW_DSC_* constants. .It Fn dwarf_get_EH_name .Dv DW_EH_PE_* constants. .It Fn dwarf_get_END_name .Dv DW_END_* constants. .It Fn dwarf_get_FORM_name .Dv DW_FORM_* constants. .It Fn dwarf_get_ID_name .Dv DW_ID_* constants. .It Fn dwarf_get_INL_name .Dv DW_INL_* constants. .It Fn dwarf_get_LANG_name .Dv DW_LANG_* constants. .It Fn dwarf_get_LNE_name .Dv DW_LNE_* constants. .It Fn dwarf_get_LNS_name .Dv DW_LNS_* constants. .It Fn dwarf_get_MACINFO_name .Dv DW_MACINFO_* constants. .It Fn dwarf_get_OP_name .Dv DW_OP_* constants. .It Fn dwarf_get_ORD_name .Dv DW_ORD_* constants. .It Fn dwarf_get_TAG_name .Dv DW_TAG_* constants. +.It Fn dwarf_get_UT_name +.Dv DW_UT_* +constants. .It Fn dwarf_get_VIRTUALITY_name .Dv DW_VIRTUALITY_* constants. .It Fn dwarf_get_VIS_name .Dv DW_VIS_* constants. .El .Sh RETURN VALUES These functions return .Dv DW_DLV_OK on success. If the DWARF constant denoted by argument .Ar val is not recognized, these function return .Dv DW_DLV_NO_ENTRY . .Sh SEE ALSO .Xr dwarf 3 diff --git a/contrib/elftoolchain/libdwarf/libdwarf.h b/contrib/elftoolchain/libdwarf/libdwarf.h index 6ec8f99c56a1..75ebb56d288e 100644 --- a/contrib/elftoolchain/libdwarf/libdwarf.h +++ b/contrib/elftoolchain/libdwarf/libdwarf.h @@ -1,841 +1,842 @@ /*- * Copyright (c) 2007 John Birrell (jb@freebsd.org) * Copyright (c) 2009-2011,2014 Kai Wang * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. 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. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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. * * $Id: libdwarf.h 3578 2017-09-14 02:21:28Z emaste $ */ #ifndef _LIBDWARF_H_ #define _LIBDWARF_H_ #include typedef int Dwarf_Bool; typedef uint64_t Dwarf_Off; typedef uint64_t Dwarf_Unsigned; typedef uint16_t Dwarf_Half; typedef uint8_t Dwarf_Small; typedef int64_t Dwarf_Signed; typedef uint64_t Dwarf_Addr; typedef void *Dwarf_Ptr; typedef struct _Dwarf_Abbrev *Dwarf_Abbrev; typedef struct _Dwarf_Arange *Dwarf_Arange; typedef struct _Dwarf_ArangeSet *Dwarf_ArangeSet; typedef struct _Dwarf_Attribute *Dwarf_Attribute; typedef struct _Dwarf_Attribute *Dwarf_P_Attribute; typedef struct _Dwarf_AttrDef *Dwarf_AttrDef; typedef struct _Dwarf_Cie *Dwarf_Cie; typedef struct _Dwarf_Cie *Dwarf_P_Cie; typedef struct _Dwarf_Debug *Dwarf_Debug; typedef struct _Dwarf_Debug *Dwarf_P_Debug; typedef struct _Dwarf_Die *Dwarf_Die; typedef struct _Dwarf_Die *Dwarf_P_Die; typedef struct _Dwarf_Fde *Dwarf_Fde; typedef struct _Dwarf_Fde *Dwarf_P_Fde; typedef struct _Dwarf_FrameSec *Dwarf_FrameSec; typedef struct _Dwarf_Line *Dwarf_Line; typedef struct _Dwarf_LineFile *Dwarf_LineFile; typedef struct _Dwarf_LineInfo *Dwarf_LineInfo; typedef struct _Dwarf_MacroSet *Dwarf_MacroSet; typedef struct _Dwarf_NamePair *Dwarf_NamePair; typedef struct _Dwarf_NamePair *Dwarf_Func; typedef struct _Dwarf_NamePair *Dwarf_Global; typedef struct _Dwarf_NamePair *Dwarf_Type; typedef struct _Dwarf_NamePair *Dwarf_Var; typedef struct _Dwarf_NamePair *Dwarf_Weak; typedef struct _Dwarf_NameTbl *Dwarf_NameTbl; typedef struct _Dwarf_NameSec *Dwarf_NameSec; typedef struct _Dwarf_P_Expr *Dwarf_P_Expr; typedef struct _Dwarf_Rangelist *Dwarf_Rangelist; typedef enum { DW_OBJECT_MSB, DW_OBJECT_LSB } Dwarf_Endianness; typedef struct { Dwarf_Addr addr; Dwarf_Unsigned size; const char *name; } Dwarf_Obj_Access_Section; typedef struct { int (*get_section_info)(void *_obj, Dwarf_Half _index, Dwarf_Obj_Access_Section *_ret_section, int *_error); Dwarf_Endianness (*get_byte_order)(void *_obj); Dwarf_Small (*get_length_size)(void *_obj); Dwarf_Small (*get_pointer_size)(void *_obj); Dwarf_Unsigned (*get_section_count)(void *_obj); int (*load_section)(void *_obj, Dwarf_Half _index, Dwarf_Small **_ret_data, int *_error); } Dwarf_Obj_Access_Methods; typedef struct { void *object; const Dwarf_Obj_Access_Methods *methods; } Dwarf_Obj_Access_Interface; typedef int (*Dwarf_Callback_Func)(char *_name, int _size, Dwarf_Unsigned _type, Dwarf_Unsigned _flags, Dwarf_Unsigned _link, Dwarf_Unsigned _info, int *_index, int *_error); typedef int (*Dwarf_Callback_Func_b)(char *_name, int _size, Dwarf_Unsigned _type, Dwarf_Unsigned _flags, Dwarf_Unsigned _link, Dwarf_Unsigned _info, Dwarf_Unsigned *_index, int *_error); typedef Dwarf_Unsigned Dwarf_Tag; typedef struct { Dwarf_Small lr_atom; Dwarf_Unsigned lr_number; Dwarf_Unsigned lr_number2; Dwarf_Unsigned lr_offset; } Dwarf_Loc; typedef struct { Dwarf_Addr ld_lopc; Dwarf_Addr ld_hipc; Dwarf_Half ld_cents; Dwarf_Loc *ld_s; } Dwarf_Locdesc; typedef struct { char signature[8]; } Dwarf_Sig8; typedef struct { Dwarf_Unsigned bl_len; Dwarf_Ptr bl_data; } Dwarf_Block; enum Dwarf_Ranges_Entry_Type { DW_RANGES_ENTRY, DW_RANGES_ADDRESS_SELECTION, DW_RANGES_END }; typedef struct { Dwarf_Unsigned dwr_addr1; Dwarf_Unsigned dwr_addr2; enum Dwarf_Ranges_Entry_Type dwr_type; } Dwarf_Ranges; enum Dwarf_Form_Class { DW_FORM_CLASS_UNKNOWN, DW_FORM_CLASS_ADDRESS, DW_FORM_CLASS_BLOCK, DW_FORM_CLASS_CONSTANT, DW_FORM_CLASS_EXPRLOC, DW_FORM_CLASS_FLAG, DW_FORM_CLASS_LINEPTR, DW_FORM_CLASS_LOCLISTPTR, DW_FORM_CLASS_MACPTR, DW_FORM_CLASS_RANGELISTPTR, DW_FORM_CLASS_REFERENCE, DW_FORM_CLASS_STRING }; #ifndef DW_FRAME_HIGHEST_NORMAL_REGISTER #define DW_FRAME_HIGHEST_NORMAL_REGISTER 63 #endif #define DW_FRAME_RA_COL (DW_FRAME_HIGHEST_NORMAL_REGISTER + 1) #define DW_FRAME_STATIC_LINK (DW_FRAME_HIGHEST_NORMAL_REGISTER + 2) #ifndef DW_FRAME_LAST_REG_NUM #define DW_FRAME_LAST_REG_NUM (DW_FRAME_HIGHEST_NORMAL_REGISTER + 3) #endif #ifndef DW_FRAME_REG_INITIAL_VALUE #define DW_FRAME_REG_INITIAL_VALUE DW_FRAME_SAME_VAL #endif #define DW_FRAME_UNDEFINED_VAL 1034 #define DW_FRAME_SAME_VAL 1035 #define DW_FRAME_CFA_COL3 1436 #define DW_EXPR_OFFSET 0 #define DW_EXPR_VAL_OFFSET 1 #define DW_EXPR_EXPRESSION 2 #define DW_EXPR_VAL_EXPRESSION 3 /* * Frame operation only for DWARF 2. */ #define DW_FRAME_CFA_COL 0 typedef struct { Dwarf_Small fp_base_op; Dwarf_Small fp_extended_op; Dwarf_Half fp_register; Dwarf_Signed fp_offset; Dwarf_Off fp_instr_offset; } Dwarf_Frame_Op; #ifndef DW_REG_TABLE_SIZE #define DW_REG_TABLE_SIZE 66 #endif typedef struct { struct { Dwarf_Small dw_offset_relevant; Dwarf_Half dw_regnum; Dwarf_Addr dw_offset; } rules[DW_REG_TABLE_SIZE]; } Dwarf_Regtable; /* * Frame operation for DWARF 3 and DWARF 2. */ typedef struct { Dwarf_Small fp_base_op; Dwarf_Small fp_extended_op; Dwarf_Half fp_register; Dwarf_Unsigned fp_offset_or_block_len; Dwarf_Small *fp_expr_block; Dwarf_Off fp_instr_offset; } Dwarf_Frame_Op3; typedef struct { Dwarf_Small dw_offset_relevant; Dwarf_Small dw_value_type; Dwarf_Half dw_regnum; Dwarf_Unsigned dw_offset_or_block_len; Dwarf_Ptr dw_block_ptr; } Dwarf_Regtable_Entry3; typedef struct { Dwarf_Regtable_Entry3 rt3_cfa_rule; Dwarf_Half rt3_reg_table_size; Dwarf_Regtable_Entry3 *rt3_rules; } Dwarf_Regtable3; typedef struct { Dwarf_Off dmd_offset; Dwarf_Small dmd_type; Dwarf_Signed dmd_lineno; Dwarf_Signed dmd_fileindex; char *dmd_macro; } Dwarf_Macro_Details; /* * Symbols denoting allocation types, for use with dwarf_dealloc(3). */ enum Dwarf_Allocation_Type { DW_DLA_ABBREV, DW_DLA_ADDR, DW_DLA_ARANGE, DW_DLA_ATTR, DW_DLA_BLOCK, DW_DLA_BOUNDS, DW_DLA_CIE, DW_DLA_DEBUG, DW_DLA_DIE, DW_DLA_ELLIST, DW_DLA_ERROR, DW_DLA_FDE, DW_DLA_FRAME_BLOCK, DW_DLA_FRAME_OP, DW_DLA_FUNC, DW_DLA_GLOBAL, DW_DLA_LINE, DW_DLA_LINEBUF, DW_DLA_LIST, DW_DLA_LOC, DW_DLA_LOCDESC, DW_DLA_LOC_BLOCK, DW_DLA_RANGES, DW_DLA_STRING, DW_DLA_SUBSCR, DW_DLA_TYPE, DW_DLA_TYPENAME, DW_DLA_VAR, DW_DLA_WEAK }; /* * Relocation Type. */ enum Dwarf_Rel_Type { dwarf_drt_none = 0, dwarf_drt_data_reloc, dwarf_drt_segment_rel, dwarf_drt_first_of_length_pair, dwarf_drt_second_of_length_pair }; /* * Relocation Entry. */ typedef struct Dwarf_Relocation_Data_s { unsigned char drd_type; unsigned char drd_length; Dwarf_Unsigned drd_offset; Dwarf_Unsigned drd_symbol_index; } *Dwarf_Relocation_Data; #define DWARF_DRD_BUFFER_VERSION 2 /* * Error numbers which are specific to this implementation. */ enum { DW_DLE_NONE, /* No error. */ DW_DLE_ERROR, /* An error! */ DW_DLE_ARGUMENT, /* Invalid argument. */ DW_DLE_DEBUG_INFO_NULL, /* Debug info NULL. */ DW_DLE_NO_ENTRY, /* No entry. */ DW_DLE_MEMORY, /* Insufficient memory. */ DW_DLE_ELF, /* ELF error. */ DW_DLE_CU_LENGTH_ERROR, /* Invalid compilation unit data. */ DW_DLE_VERSION_STAMP_ERROR, /* Invalid version. */ DW_DLE_DEBUG_ABBREV_NULL, /* Abbrev not found. */ DW_DLE_DIE_NO_CU_CONTEXT, /* No current compilation unit. */ DW_DLE_LOC_EXPR_BAD, /* Invalid location expression. */ DW_DLE_EXPR_LENGTH_BAD, /* Invalid DWARF expression. */ DW_DLE_DEBUG_LOC_SECTION_SHORT, /* Loclist section too short. */ DW_DLE_ATTR_FORM_BAD, /* Invalid attribute form. */ DW_DLE_DEBUG_LINE_LENGTH_BAD, /* Line info section too short. */ DW_DLE_LINE_FILE_NUM_BAD, /* Invalid file number. */ DW_DLE_DIR_INDEX_BAD, /* Invalid dir index. */ DW_DLE_DEBUG_FRAME_LENGTH_BAD, /* Frame section too short. */ DW_DLE_NO_CIE_FOR_FDE, /* CIE not found for certain FDE. */ DW_DLE_FRAME_AUGMENTATION_UNKNOWN, /* Unknown CIE augmentation. */ DW_DLE_FRAME_INSTR_EXEC_ERROR, /* Frame instruction exec error. */ DW_DLE_FRAME_VERSION_BAD, /* Invalid frame section version. */ DW_DLE_FRAME_TABLE_COL_BAD, /* Invalid table column. */ DW_DLE_DF_REG_NUM_TOO_HIGH, /* Insufficient regtable space. */ DW_DLE_PC_NOT_IN_FDE_RANGE, /* PC requested not in the FDE range. */ DW_DLE_ARANGE_OFFSET_BAD, /* Invalid arange offset. */ DW_DLE_DEBUG_MACRO_INCONSISTENT,/* Invalid macinfo data. */ DW_DLE_ELF_SECT_ERR, /* Application callback failed. */ DW_DLE_NUM /* Max error number. */ }; /* * Mapping of SGI libdwarf error codes for comptibility. */ #define DW_DLE_DBG_ALLOC DW_DLE_MEMORY #define DW_DLE_ALLOC_FAIL DW_DLE_MEMORY #define DW_DLE_SECT_ALLOC DW_DLE_MEMORY #define DW_DLE_FILE_ENTRY_ALLOC DW_DLE_MEMORY #define DW_DLE_LINE_ALLOC DW_DLE_MEMORY #define DW_DLE_FPGM_ALLOC DW_DLE_MEMORY #define DW_DLE_INCDIR_ALLOC DW_DLE_MEMORY #define DW_DLE_STRING_ALLOC DW_DLE_MEMORY #define DW_DLE_CHUNK_ALLOC DW_DLE_MEMORY #define DW_DLE_CIE_ALLOC DW_DLE_MEMORY #define DW_DLE_FDE_ALLOC DW_DLE_MEMORY #define DW_DLE_CIE_OFFS_ALLOC DW_DLE_MEMORY #define DW_DLE_DIE_ALLOC DW_DLE_MEMORY #define DW_DLE_ATTR_ALLOC DW_DLE_MEMORY #define DW_DLE_ABBREV_ALLOC DW_DLE_MEMORY #define DW_DLE_ADDR_ALLOC DW_DLE_MEMORY #define DW_DLE_REL_ALLOC DW_DLE_MEMORY #define DW_DLE_MACINFO_MALLOC_FAIL DW_DLE_MEMORY #define DW_DLE_DEBUG_MACRO_MALLOC_SPACE DW_DLE_MEMORY #define DW_DLE_DF_ALLOC_FAIL DW_DLE_MEMORY #define DW_DLE_RELOC_SECTION_MALLOC_FAIL DW_DLE_MEMORY #define DW_DLE_DBG_NULL DW_DLE_ARGUMENT #define DW_DLE_DIE_NULL DW_DLE_ARGUMENT #define DW_DLE_FDE_NULL DW_DLE_ARGUMENT #define DW_DLE_CIE_NULL DW_DLE_ARGUMENT #define DW_DLE_ATTR_NULL DW_DLE_ARGUMENT #define DW_DLE_GLOBAL_NULL DW_DLE_ARGUMENT #define DW_DLE_ARANGES_NULL DW_DLE_ARGUMENT #define DW_DLE_ARANGE_NULL DW_DLE_ARGUMENT #define DW_DLE_EXPR_NULL DW_DLE_ARGUMENT #define DW_DLE_FUNC_NULL DW_DLE_ARGUMENT #define DW_DLE_TYPE_NULL DW_DLE_ARGUMENT #define DW_DLE_VAR_NULL DW_DLE_ARGUMENT #define DW_DLE_WEAK_NULL DW_DLE_ARGUMENT #define DW_DLE_ELF_BEGIN_ERROR DW_DLE_ELF #define DW_DLE_ELF_GETEHDR_ERROR DW_DLE_ELF #define DW_DLE_ELF_GETSHDR_ERROR DW_DLE_ELF #define DW_DLE_ELF_STRPTR_ERROR DW_DLE_ELF #define DW_DLE_ELF_SECT_ERROR DW_DLE_ELF #define DW_DLE_ELF_GETIDENT_ERROR DW_DLE_ELF typedef struct _Dwarf_Error { int err_error; /* DWARF error. */ int err_elferror; /* ELF error. */ const char *err_func; /* Function name where error occurred. */ int err_line; /* Line number where error occurred. */ char err_msg[1024]; /* Formatted error message. */ } Dwarf_Error; /* * Dwarf error handler. */ typedef void (*Dwarf_Handler)(Dwarf_Error, Dwarf_Ptr); #define dwarf_errno(error) error.err_error #define dwarf_errmsg(error) dwarf_errmsg_(&error) /* * Return values which have to be compatible with other * implementations of libdwarf. */ #define DW_DLV_NO_ENTRY -1 #define DW_DLV_OK 0 #define DW_DLV_ERROR 1 #define DW_DLV_BADADDR NULL #define DW_DLV_NOCOUNT ((Dwarf_Signed) -1) /* * Access modes. */ #define DW_DLC_READ 0x0001 #define DW_DLC_WRITE 0x0002 #define DW_DLC_RDWR 0x0004 /* * Flags used by libdwarf producer. */ #define DW_DLC_SIZE_64 0x40000000 #define DW_DLC_SIZE_32 0x20000000 #define DW_DLC_OFFSET_SIZE_64 0x10000000 #define DW_DLC_ISA_MIPS 0x80000000 #define DW_DLC_ISA_IA64 0x01000000 #define DW_DLC_STREAM_RELOCATIONS 0x02000000 #define DW_DLC_SYMBOLIC_RELOCATIONS 0x04000000 #define DW_DLC_TARGET_BIGENDIAN 0x08000000 #define DW_DLC_TARGET_LITTLEENDIAN 0x00100000 /* * Instruction set architectures supported by this implementation. */ enum Dwarf_ISA { DW_ISA_ARM, DW_ISA_IA64, DW_ISA_MIPS, DW_ISA_PPC, DW_ISA_SPARC, DW_ISA_X86, DW_ISA_X86_64, DW_ISA_AARCH64, DW_ISA_RISCV, DW_ISA_MAX }; /* Function prototype definitions. */ #ifdef __cplusplus extern "C" { #endif Dwarf_P_Attribute dwarf_add_AT_comp_dir(Dwarf_P_Die, char *, Dwarf_Error *); Dwarf_P_Attribute dwarf_add_AT_const_value_signedint(Dwarf_P_Die, Dwarf_Signed, Dwarf_Error *); Dwarf_P_Attribute dwarf_add_AT_const_value_string(Dwarf_P_Die, char *, Dwarf_Error *); Dwarf_P_Attribute dwarf_add_AT_const_value_unsignedint(Dwarf_P_Die, Dwarf_Unsigned, Dwarf_Error *); Dwarf_P_Attribute dwarf_add_AT_dataref(Dwarf_P_Debug, Dwarf_P_Die, Dwarf_Half, Dwarf_Unsigned, Dwarf_Unsigned, Dwarf_Error *); Dwarf_P_Attribute dwarf_add_AT_flag(Dwarf_P_Debug, Dwarf_P_Die, Dwarf_Half, Dwarf_Small, Dwarf_Error *); Dwarf_P_Attribute dwarf_add_AT_location_expr(Dwarf_P_Debug, Dwarf_P_Die, Dwarf_Half, Dwarf_P_Expr, Dwarf_Error *); Dwarf_P_Attribute dwarf_add_AT_name(Dwarf_P_Die, char *, Dwarf_Error *); Dwarf_P_Attribute dwarf_add_AT_producer(Dwarf_P_Die, char *, Dwarf_Error *); Dwarf_P_Attribute dwarf_add_AT_ref_address(Dwarf_P_Debug, Dwarf_P_Die, Dwarf_Half, Dwarf_Unsigned, Dwarf_Unsigned, Dwarf_Error *); Dwarf_P_Attribute dwarf_add_AT_reference(Dwarf_P_Debug, Dwarf_P_Die, Dwarf_Half, Dwarf_P_Die, Dwarf_Error *); Dwarf_P_Attribute dwarf_add_AT_signed_const(Dwarf_P_Debug, Dwarf_P_Die, Dwarf_Half, Dwarf_Signed, Dwarf_Error *); Dwarf_P_Attribute dwarf_add_AT_string(Dwarf_P_Debug, Dwarf_P_Die, Dwarf_Half, char *, Dwarf_Error *); Dwarf_P_Attribute dwarf_add_AT_targ_address(Dwarf_P_Debug, Dwarf_P_Die, Dwarf_Half, Dwarf_Unsigned, Dwarf_Signed, Dwarf_Error *); Dwarf_P_Attribute dwarf_add_AT_targ_address_b(Dwarf_P_Debug, Dwarf_P_Die, Dwarf_Half, Dwarf_Unsigned, Dwarf_Unsigned, Dwarf_Error *); Dwarf_P_Attribute dwarf_add_AT_unsigned_const(Dwarf_P_Debug, Dwarf_P_Die, Dwarf_Half, Dwarf_Unsigned, Dwarf_Error *); Dwarf_Unsigned dwarf_add_arange(Dwarf_P_Debug, Dwarf_Addr, Dwarf_Unsigned, Dwarf_Signed, Dwarf_Error *); Dwarf_Unsigned dwarf_add_arange_b(Dwarf_P_Debug, Dwarf_Addr, Dwarf_Unsigned, Dwarf_Unsigned, Dwarf_Unsigned, Dwarf_Addr, Dwarf_Error *); Dwarf_Unsigned dwarf_add_die_to_debug(Dwarf_P_Debug, Dwarf_P_Die, Dwarf_Error *); Dwarf_Unsigned dwarf_add_directory_decl(Dwarf_P_Debug, char *, Dwarf_Error *); Dwarf_Unsigned dwarf_add_expr_addr(Dwarf_P_Expr, Dwarf_Unsigned, Dwarf_Signed, Dwarf_Error *); Dwarf_Unsigned dwarf_add_expr_addr_b(Dwarf_P_Expr, Dwarf_Unsigned, Dwarf_Unsigned, Dwarf_Error *); Dwarf_Unsigned dwarf_add_expr_gen(Dwarf_P_Expr, Dwarf_Small, Dwarf_Unsigned, Dwarf_Unsigned, Dwarf_Error *); Dwarf_P_Fde dwarf_add_fde_inst(Dwarf_P_Fde, Dwarf_Small, Dwarf_Unsigned, Dwarf_Unsigned, Dwarf_Error *); Dwarf_Unsigned dwarf_add_file_decl(Dwarf_P_Debug, char *, Dwarf_Unsigned, Dwarf_Unsigned, Dwarf_Unsigned, Dwarf_Error *); Dwarf_Unsigned dwarf_add_frame_cie(Dwarf_P_Debug, char *, Dwarf_Small, Dwarf_Small, Dwarf_Small, Dwarf_Ptr, Dwarf_Unsigned, Dwarf_Error *); Dwarf_Unsigned dwarf_add_frame_fde(Dwarf_P_Debug, Dwarf_P_Fde, Dwarf_P_Die, Dwarf_Unsigned, Dwarf_Addr, Dwarf_Unsigned, Dwarf_Unsigned, Dwarf_Error *); Dwarf_Unsigned dwarf_add_frame_fde_b(Dwarf_P_Debug, Dwarf_P_Fde, Dwarf_P_Die, Dwarf_Unsigned, Dwarf_Addr, Dwarf_Unsigned, Dwarf_Unsigned, Dwarf_Unsigned, Dwarf_Addr, Dwarf_Error *); Dwarf_Unsigned dwarf_add_funcname(Dwarf_P_Debug, Dwarf_P_Die, char *, Dwarf_Error *); Dwarf_Unsigned dwarf_add_line_entry(Dwarf_P_Debug, Dwarf_Unsigned, Dwarf_Addr, Dwarf_Unsigned, Dwarf_Signed, Dwarf_Bool, Dwarf_Bool, Dwarf_Error *); Dwarf_Unsigned dwarf_add_pubname(Dwarf_P_Debug, Dwarf_P_Die, char *, Dwarf_Error *); Dwarf_Unsigned dwarf_add_typename(Dwarf_P_Debug, Dwarf_P_Die, char *, Dwarf_Error *); Dwarf_Unsigned dwarf_add_varname(Dwarf_P_Debug, Dwarf_P_Die, char *, Dwarf_Error *); Dwarf_Unsigned dwarf_add_weakname(Dwarf_P_Debug, Dwarf_P_Die, char *, Dwarf_Error *); int dwarf_arrayorder(Dwarf_Die, Dwarf_Unsigned *, Dwarf_Error *); int dwarf_attr(Dwarf_Die, Dwarf_Half, Dwarf_Attribute *, Dwarf_Error *); int dwarf_attrlist(Dwarf_Die, Dwarf_Attribute **, Dwarf_Signed *, Dwarf_Error *); int dwarf_attroffset(Dwarf_Attribute, Dwarf_Off *, Dwarf_Error *); int dwarf_attrval_flag(Dwarf_Die, Dwarf_Half, Dwarf_Bool *, Dwarf_Error *); int dwarf_attrval_signed(Dwarf_Die, Dwarf_Half, Dwarf_Signed *, Dwarf_Error *); int dwarf_attrval_string(Dwarf_Die, Dwarf_Half, const char **, Dwarf_Error *); int dwarf_attrval_unsigned(Dwarf_Die, Dwarf_Half, Dwarf_Unsigned *, Dwarf_Error *); int dwarf_bitoffset(Dwarf_Die, Dwarf_Unsigned *, Dwarf_Error *); int dwarf_bitsize(Dwarf_Die, Dwarf_Unsigned *, Dwarf_Error *); int dwarf_bytesize(Dwarf_Die, Dwarf_Unsigned *, Dwarf_Error *); int dwarf_child(Dwarf_Die, Dwarf_Die *, Dwarf_Error *); void dwarf_dealloc(Dwarf_Debug, Dwarf_Ptr, Dwarf_Unsigned); int dwarf_def_macro(Dwarf_P_Debug, Dwarf_Unsigned, char *, char *, Dwarf_Error *); int dwarf_die_CU_offset(Dwarf_Die, Dwarf_Off *, Dwarf_Error *); int dwarf_die_CU_offset_range(Dwarf_Die, Dwarf_Off *, Dwarf_Off *, Dwarf_Error *); int dwarf_die_abbrev_code(Dwarf_Die); Dwarf_P_Die dwarf_die_link(Dwarf_P_Die, Dwarf_P_Die, Dwarf_P_Die, Dwarf_P_Die, Dwarf_P_Die, Dwarf_Error *); int dwarf_diename(Dwarf_Die, char **, Dwarf_Error *); int dwarf_dieoffset(Dwarf_Die, Dwarf_Off *, Dwarf_Error *); int dwarf_elf_init(Elf *, int, Dwarf_Handler, Dwarf_Ptr, Dwarf_Debug *, Dwarf_Error *); int dwarf_end_macro_file(Dwarf_P_Debug, Dwarf_Error *); const char *dwarf_errmsg_(Dwarf_Error *); int dwarf_expand_frame_instructions(Dwarf_Cie, Dwarf_Ptr, Dwarf_Unsigned, Dwarf_Frame_Op **, Dwarf_Signed *, Dwarf_Error *); Dwarf_Unsigned dwarf_expr_current_offset(Dwarf_P_Expr, Dwarf_Error *); Dwarf_Addr dwarf_expr_into_block(Dwarf_P_Expr, Dwarf_Unsigned *, Dwarf_Error *); Dwarf_P_Fde dwarf_fde_cfa_offset(Dwarf_P_Fde, Dwarf_Unsigned, Dwarf_Signed, Dwarf_Error *); void dwarf_fde_cie_list_dealloc(Dwarf_Debug, Dwarf_Cie *, Dwarf_Signed, Dwarf_Fde *, Dwarf_Signed); char *dwarf_find_macro_value_start(char *); int dwarf_finish(Dwarf_Debug, Dwarf_Error *); int dwarf_formaddr(Dwarf_Attribute, Dwarf_Addr *, Dwarf_Error *); int dwarf_formblock(Dwarf_Attribute, Dwarf_Block **, Dwarf_Error *); int dwarf_formexprloc(Dwarf_Attribute, Dwarf_Unsigned *, Dwarf_Ptr *, Dwarf_Error *); int dwarf_formflag(Dwarf_Attribute, Dwarf_Bool *, Dwarf_Error *); int dwarf_formref(Dwarf_Attribute, Dwarf_Off *, Dwarf_Error *); int dwarf_formsdata(Dwarf_Attribute, Dwarf_Signed *, Dwarf_Error *); int dwarf_formsig8(Dwarf_Attribute, Dwarf_Sig8 *, Dwarf_Error *); int dwarf_formstring(Dwarf_Attribute, char **, Dwarf_Error *); int dwarf_formudata(Dwarf_Attribute, Dwarf_Unsigned *, Dwarf_Error *); int dwarf_func_cu_offset(Dwarf_Func, Dwarf_Off *, Dwarf_Error *); int dwarf_func_die_offset(Dwarf_Func, Dwarf_Off *, Dwarf_Error *); int dwarf_func_name_offsets(Dwarf_Func, char **, Dwarf_Off *, Dwarf_Off *, Dwarf_Error *); int dwarf_funcname(Dwarf_Func, char **, Dwarf_Error *); void dwarf_funcs_dealloc(Dwarf_Debug, Dwarf_Func *, Dwarf_Signed); int dwarf_get_ACCESS_name(unsigned, const char **); int dwarf_get_ATE_name(unsigned, const char **); int dwarf_get_AT_name(unsigned, const char **); int dwarf_get_CC_name(unsigned, const char **); int dwarf_get_CFA_name(unsigned, const char **); int dwarf_get_CHILDREN_name(unsigned, const char **); int dwarf_get_DSC_name(unsigned, const char **); int dwarf_get_DS_name(unsigned, const char **); int dwarf_get_EH_name(unsigned, const char **); int dwarf_get_END_name(unsigned, const char **); int dwarf_get_FORM_name(unsigned, const char **); int dwarf_get_ID_name(unsigned, const char **); int dwarf_get_INL_name(unsigned, const char **); int dwarf_get_LANG_name(unsigned, const char **); int dwarf_get_LNE_name(unsigned, const char **); int dwarf_get_LNS_name(unsigned, const char **); int dwarf_get_MACINFO_name(unsigned, const char **); int dwarf_get_OP_name(unsigned, const char **); int dwarf_get_ORD_name(unsigned, const char **); int dwarf_get_TAG_name(unsigned, const char **); +int dwarf_get_UT_name(unsigned, const char **); int dwarf_get_VIRTUALITY_name(unsigned, const char **); int dwarf_get_VIS_name(unsigned, const char **); int dwarf_get_abbrev(Dwarf_Debug, Dwarf_Unsigned, Dwarf_Abbrev *, Dwarf_Unsigned *, Dwarf_Unsigned *, Dwarf_Error *); int dwarf_get_abbrev_children_flag(Dwarf_Abbrev, Dwarf_Signed *, Dwarf_Error *); int dwarf_get_abbrev_code(Dwarf_Abbrev, Dwarf_Unsigned *, Dwarf_Error *); int dwarf_get_abbrev_entry(Dwarf_Abbrev, Dwarf_Signed, Dwarf_Half *, Dwarf_Signed *, Dwarf_Off *, Dwarf_Error *); int dwarf_get_abbrev_tag(Dwarf_Abbrev, Dwarf_Half *, Dwarf_Error *); int dwarf_get_address_size(Dwarf_Debug, Dwarf_Half *, Dwarf_Error *); int dwarf_get_arange(Dwarf_Arange *, Dwarf_Unsigned, Dwarf_Addr, Dwarf_Arange *, Dwarf_Error *); int dwarf_get_arange_cu_header_offset(Dwarf_Arange, Dwarf_Off *, Dwarf_Error *); int dwarf_get_arange_info(Dwarf_Arange, Dwarf_Addr *, Dwarf_Unsigned *, Dwarf_Off *, Dwarf_Error *); int dwarf_get_aranges(Dwarf_Debug, Dwarf_Arange **, Dwarf_Signed *, Dwarf_Error *); int dwarf_get_cie_index(Dwarf_Cie, Dwarf_Signed *, Dwarf_Error *); int dwarf_get_cie_info(Dwarf_Cie, Dwarf_Unsigned *, Dwarf_Small *, char **, Dwarf_Unsigned *, Dwarf_Unsigned *, Dwarf_Half *, Dwarf_Ptr *, Dwarf_Unsigned *, Dwarf_Error *); int dwarf_get_cie_of_fde(Dwarf_Fde, Dwarf_Cie *, Dwarf_Error *); int dwarf_get_cu_die_offset(Dwarf_Arange, Dwarf_Off *, Dwarf_Error *); int dwarf_get_cu_die_offset_given_cu_header_offset(Dwarf_Debug, Dwarf_Off, Dwarf_Off *, Dwarf_Error *); int dwarf_get_cu_die_offset_given_cu_header_offset_b(Dwarf_Debug, Dwarf_Off, Dwarf_Bool, Dwarf_Off *, Dwarf_Error *); Dwarf_Bool dwarf_get_die_infotypes_flag(Dwarf_Die); int dwarf_get_elf(Dwarf_Debug, Elf **, Dwarf_Error *); int dwarf_get_fde_at_pc(Dwarf_Fde *, Dwarf_Addr, Dwarf_Fde *, Dwarf_Addr *, Dwarf_Addr *, Dwarf_Error *); int dwarf_get_fde_info_for_all_regs(Dwarf_Fde, Dwarf_Addr, Dwarf_Regtable *, Dwarf_Addr *, Dwarf_Error *); int dwarf_get_fde_info_for_all_regs3(Dwarf_Fde, Dwarf_Addr, Dwarf_Regtable3 *, Dwarf_Addr *, Dwarf_Error *); int dwarf_get_fde_info_for_cfa_reg3(Dwarf_Fde, Dwarf_Addr, Dwarf_Small *, Dwarf_Signed *, Dwarf_Signed *, Dwarf_Signed *, Dwarf_Ptr *, Dwarf_Addr *, Dwarf_Error *); int dwarf_get_fde_info_for_reg(Dwarf_Fde, Dwarf_Half, Dwarf_Addr, Dwarf_Signed *, Dwarf_Signed *, Dwarf_Signed *, Dwarf_Addr *, Dwarf_Error *); int dwarf_get_fde_info_for_reg3(Dwarf_Fde, Dwarf_Half, Dwarf_Addr, Dwarf_Small *, Dwarf_Signed *, Dwarf_Signed *, Dwarf_Signed *, Dwarf_Ptr *, Dwarf_Addr *, Dwarf_Error *); int dwarf_get_fde_instr_bytes(Dwarf_Fde, Dwarf_Ptr *, Dwarf_Unsigned *, Dwarf_Error *); int dwarf_get_fde_list(Dwarf_Debug, Dwarf_Cie **, Dwarf_Signed *, Dwarf_Fde **, Dwarf_Signed *, Dwarf_Error *); int dwarf_get_fde_list_eh(Dwarf_Debug, Dwarf_Cie **, Dwarf_Signed *, Dwarf_Fde **, Dwarf_Signed *, Dwarf_Error *); int dwarf_get_fde_n(Dwarf_Fde *, Dwarf_Unsigned, Dwarf_Fde *, Dwarf_Error *); int dwarf_get_fde_range(Dwarf_Fde, Dwarf_Addr *, Dwarf_Unsigned *, Dwarf_Ptr *, Dwarf_Unsigned *, Dwarf_Off *, Dwarf_Signed *, Dwarf_Off *, Dwarf_Error *); enum Dwarf_Form_Class dwarf_get_form_class(Dwarf_Half, Dwarf_Half, Dwarf_Half, Dwarf_Half); int dwarf_get_funcs(Dwarf_Debug, Dwarf_Func **, Dwarf_Signed *, Dwarf_Error *); int dwarf_get_globals(Dwarf_Debug, Dwarf_Global **, Dwarf_Signed *, Dwarf_Error *); int dwarf_get_loclist_entry(Dwarf_Debug, Dwarf_Unsigned, Dwarf_Addr *, Dwarf_Addr *, Dwarf_Ptr *, Dwarf_Unsigned *, Dwarf_Unsigned *, Dwarf_Error *); int dwarf_get_macro_details(Dwarf_Debug, Dwarf_Off, Dwarf_Unsigned, Dwarf_Signed *, Dwarf_Macro_Details **, Dwarf_Error *); int dwarf_get_pubtypes(Dwarf_Debug, Dwarf_Type **, Dwarf_Signed *, Dwarf_Error *); int dwarf_get_ranges(Dwarf_Debug, Dwarf_Off, Dwarf_Ranges **, Dwarf_Signed *, Dwarf_Unsigned *, Dwarf_Error *); int dwarf_get_ranges_a(Dwarf_Debug, Dwarf_Off, Dwarf_Die, Dwarf_Ranges **, Dwarf_Signed *, Dwarf_Unsigned *, Dwarf_Error *); int dwarf_get_relocation_info(Dwarf_P_Debug, Dwarf_Signed *, Dwarf_Signed *, Dwarf_Unsigned *, Dwarf_Relocation_Data *, Dwarf_Error *); int dwarf_get_relocation_info_count(Dwarf_P_Debug, Dwarf_Unsigned *, int *, Dwarf_Error *); Dwarf_Ptr dwarf_get_section_bytes(Dwarf_P_Debug, Dwarf_Signed, Dwarf_Signed *, Dwarf_Unsigned *, Dwarf_Error *); int dwarf_get_section_max_offsets(Dwarf_Debug, Dwarf_Unsigned *, Dwarf_Unsigned *, Dwarf_Unsigned *, Dwarf_Unsigned *, Dwarf_Unsigned *, Dwarf_Unsigned *, Dwarf_Unsigned *, Dwarf_Unsigned *, Dwarf_Unsigned *, Dwarf_Unsigned *, Dwarf_Unsigned *); int dwarf_get_section_max_offsets_b(Dwarf_Debug, Dwarf_Unsigned *, Dwarf_Unsigned *, Dwarf_Unsigned *, Dwarf_Unsigned *, Dwarf_Unsigned *, Dwarf_Unsigned *, Dwarf_Unsigned *, Dwarf_Unsigned *, Dwarf_Unsigned *, Dwarf_Unsigned *, Dwarf_Unsigned *, Dwarf_Unsigned *); int dwarf_get_str(Dwarf_Debug, Dwarf_Off, char **, Dwarf_Signed *, Dwarf_Error *); int dwarf_get_types(Dwarf_Debug, Dwarf_Type **, Dwarf_Signed *, Dwarf_Error *); int dwarf_get_vars(Dwarf_Debug, Dwarf_Var **, Dwarf_Signed *, Dwarf_Error *); int dwarf_get_weaks(Dwarf_Debug, Dwarf_Weak **, Dwarf_Signed *, Dwarf_Error *); int dwarf_global_cu_offset(Dwarf_Global, Dwarf_Off *, Dwarf_Error *); int dwarf_global_die_offset(Dwarf_Global, Dwarf_Off *, Dwarf_Error *); int dwarf_global_formref(Dwarf_Attribute, Dwarf_Off *, Dwarf_Error *); int dwarf_global_name_offsets(Dwarf_Global, char **, Dwarf_Off *, Dwarf_Off *, Dwarf_Error *); void dwarf_globals_dealloc(Dwarf_Debug, Dwarf_Global *, Dwarf_Signed); int dwarf_globname(Dwarf_Global, char **, Dwarf_Error *); int dwarf_hasattr(Dwarf_Die, Dwarf_Half, Dwarf_Bool *, Dwarf_Error *); int dwarf_hasform(Dwarf_Attribute, Dwarf_Half, Dwarf_Bool *, Dwarf_Error *); int dwarf_highpc(Dwarf_Die, Dwarf_Addr *, Dwarf_Error *); int dwarf_highpc_b(Dwarf_Die, Dwarf_Addr *, Dwarf_Half *, enum Dwarf_Form_Class *, Dwarf_Error *); int dwarf_init(int, int, Dwarf_Handler, Dwarf_Ptr, Dwarf_Debug *, Dwarf_Error *); int dwarf_line_srcfileno(Dwarf_Line, Dwarf_Unsigned *, Dwarf_Error *); int dwarf_lineaddr(Dwarf_Line, Dwarf_Addr *, Dwarf_Error *); int dwarf_linebeginstatement(Dwarf_Line, Dwarf_Bool *, Dwarf_Error *); int dwarf_lineblock(Dwarf_Line, Dwarf_Bool *, Dwarf_Error *); int dwarf_lineendsequence(Dwarf_Line, Dwarf_Bool *, Dwarf_Error *); int dwarf_lineno(Dwarf_Line, Dwarf_Unsigned *, Dwarf_Error *); int dwarf_lineoff(Dwarf_Line, Dwarf_Signed *, Dwarf_Error *); int dwarf_linesrc(Dwarf_Line, char **, Dwarf_Error *); Dwarf_Unsigned dwarf_lne_end_sequence(Dwarf_P_Debug, Dwarf_Addr, Dwarf_Error *); Dwarf_Unsigned dwarf_lne_set_address(Dwarf_P_Debug, Dwarf_Addr, Dwarf_Unsigned, Dwarf_Error *); int dwarf_loclist(Dwarf_Attribute, Dwarf_Locdesc **, Dwarf_Signed *, Dwarf_Error *); int dwarf_loclist_from_expr(Dwarf_Debug, Dwarf_Ptr, Dwarf_Unsigned, Dwarf_Locdesc **, Dwarf_Signed *, Dwarf_Error *); int dwarf_loclist_from_expr_a(Dwarf_Debug, Dwarf_Ptr, Dwarf_Unsigned, Dwarf_Half, Dwarf_Locdesc **, Dwarf_Signed *, Dwarf_Error *); int dwarf_loclist_from_expr_b(Dwarf_Debug, Dwarf_Ptr, Dwarf_Unsigned, Dwarf_Half, Dwarf_Half, Dwarf_Small, Dwarf_Locdesc **, Dwarf_Signed *, Dwarf_Error *); int dwarf_loclist_n(Dwarf_Attribute, Dwarf_Locdesc ***, Dwarf_Signed *, Dwarf_Error *); int dwarf_lowpc(Dwarf_Die, Dwarf_Addr *, Dwarf_Error *); Dwarf_P_Die dwarf_new_die(Dwarf_P_Debug, Dwarf_Tag, Dwarf_P_Die, Dwarf_P_Die, Dwarf_P_Die, Dwarf_P_Die, Dwarf_Error *); Dwarf_P_Expr dwarf_new_expr(Dwarf_P_Debug, Dwarf_Error *); Dwarf_P_Fde dwarf_new_fde(Dwarf_P_Debug, Dwarf_Error *); int dwarf_next_cu_header(Dwarf_Debug, Dwarf_Unsigned *, Dwarf_Half *, Dwarf_Off *, Dwarf_Half *, Dwarf_Unsigned *, Dwarf_Error *); int dwarf_next_cu_header_b(Dwarf_Debug, Dwarf_Unsigned *, Dwarf_Half *, Dwarf_Off *, Dwarf_Half *, Dwarf_Half *, Dwarf_Half *, Dwarf_Unsigned *, Dwarf_Error *); int dwarf_next_cu_header_c(Dwarf_Debug, Dwarf_Bool, Dwarf_Unsigned *, Dwarf_Half *, Dwarf_Off *, Dwarf_Half *, Dwarf_Half *, Dwarf_Half *, Dwarf_Sig8 *, Dwarf_Unsigned *, Dwarf_Unsigned *, Dwarf_Error *); int dwarf_next_types_section(Dwarf_Debug, Dwarf_Error *); int dwarf_object_finish(Dwarf_Debug, Dwarf_Error *); int dwarf_object_init(Dwarf_Obj_Access_Interface *, Dwarf_Handler, Dwarf_Ptr, Dwarf_Debug *, Dwarf_Error *); int dwarf_offdie(Dwarf_Debug, Dwarf_Off, Dwarf_Die *, Dwarf_Error *); int dwarf_offdie_b(Dwarf_Debug, Dwarf_Off, Dwarf_Bool, Dwarf_Die *, Dwarf_Error *); Dwarf_Unsigned dwarf_producer_finish(Dwarf_P_Debug, Dwarf_Error *); Dwarf_P_Debug dwarf_producer_init(Dwarf_Unsigned, Dwarf_Callback_Func, Dwarf_Handler, Dwarf_Ptr, Dwarf_Error *); Dwarf_P_Debug dwarf_producer_init_b(Dwarf_Unsigned, Dwarf_Callback_Func_b, Dwarf_Handler, Dwarf_Ptr, Dwarf_Error *); int dwarf_producer_set_isa(Dwarf_P_Debug, enum Dwarf_ISA, Dwarf_Error *); int dwarf_pubtype_cu_offset(Dwarf_Type, Dwarf_Off *, Dwarf_Error *); int dwarf_pubtype_die_offset(Dwarf_Type, Dwarf_Off *, Dwarf_Error *); int dwarf_pubtype_name_offsets(Dwarf_Type, char **, Dwarf_Off *, Dwarf_Off *, Dwarf_Error *); int dwarf_pubtypename(Dwarf_Type, char **, Dwarf_Error *); void dwarf_pubtypes_dealloc(Dwarf_Debug, Dwarf_Type *, Dwarf_Signed); void dwarf_ranges_dealloc(Dwarf_Debug, Dwarf_Ranges *, Dwarf_Signed); void dwarf_reset_section_bytes(Dwarf_P_Debug); Dwarf_Half dwarf_set_frame_cfa_value(Dwarf_Debug, Dwarf_Half); Dwarf_Half dwarf_set_frame_rule_initial_value(Dwarf_Debug, Dwarf_Half); Dwarf_Half dwarf_set_frame_rule_table_size(Dwarf_Debug, Dwarf_Half); Dwarf_Half dwarf_set_frame_same_value(Dwarf_Debug, Dwarf_Half); Dwarf_Half dwarf_set_frame_undefined_value(Dwarf_Debug, Dwarf_Half); int dwarf_set_reloc_application(int); Dwarf_Ptr dwarf_seterrarg(Dwarf_Debug, Dwarf_Ptr); Dwarf_Handler dwarf_seterrhand(Dwarf_Debug, Dwarf_Handler); int dwarf_siblingof(Dwarf_Debug, Dwarf_Die, Dwarf_Die *, Dwarf_Error *); int dwarf_siblingof_b(Dwarf_Debug, Dwarf_Die, Dwarf_Die *, Dwarf_Bool, Dwarf_Error *); int dwarf_srcfiles(Dwarf_Die, char ***, Dwarf_Signed *, Dwarf_Error *); int dwarf_srclang(Dwarf_Die, Dwarf_Unsigned *, Dwarf_Error *); int dwarf_srclines(Dwarf_Die, Dwarf_Line **, Dwarf_Signed *, Dwarf_Error *); void dwarf_srclines_dealloc(Dwarf_Debug, Dwarf_Line *, Dwarf_Signed); int dwarf_start_macro_file(Dwarf_P_Debug, Dwarf_Unsigned, Dwarf_Unsigned, Dwarf_Error *); int dwarf_tag(Dwarf_Die, Dwarf_Half *, Dwarf_Error *); Dwarf_Signed dwarf_transform_to_disk_form(Dwarf_P_Debug, Dwarf_Error *); int dwarf_type_cu_offset(Dwarf_Type, Dwarf_Off *, Dwarf_Error *); int dwarf_type_die_offset(Dwarf_Type, Dwarf_Off *, Dwarf_Error *); int dwarf_type_name_offsets(Dwarf_Type, char **, Dwarf_Off *, Dwarf_Off *, Dwarf_Error *); int dwarf_typename(Dwarf_Type, char **, Dwarf_Error *); void dwarf_types_dealloc(Dwarf_Debug, Dwarf_Type *, Dwarf_Signed); int dwarf_undef_macro(Dwarf_P_Debug, Dwarf_Unsigned, char *, Dwarf_Error *); int dwarf_var_cu_offset(Dwarf_Var, Dwarf_Off *, Dwarf_Error *); int dwarf_var_die_offset(Dwarf_Var, Dwarf_Off *, Dwarf_Error *); int dwarf_var_name_offsets(Dwarf_Var, char **, Dwarf_Off *, Dwarf_Off *, Dwarf_Error *); int dwarf_varname(Dwarf_Var, char **, Dwarf_Error *); void dwarf_vars_dealloc(Dwarf_Debug, Dwarf_Var *, Dwarf_Signed); int dwarf_vendor_ext(Dwarf_P_Debug, Dwarf_Unsigned, char *, Dwarf_Error *); int dwarf_weak_cu_offset(Dwarf_Weak, Dwarf_Off *, Dwarf_Error *); int dwarf_weak_die_offset(Dwarf_Weak, Dwarf_Off *, Dwarf_Error *); int dwarf_weak_name_offsets(Dwarf_Weak, char **, Dwarf_Off *, Dwarf_Off *, Dwarf_Error *); int dwarf_weakname(Dwarf_Weak, char **, Dwarf_Error *); void dwarf_weaks_dealloc(Dwarf_Debug, Dwarf_Weak *, Dwarf_Signed); int dwarf_whatattr(Dwarf_Attribute, Dwarf_Half *, Dwarf_Error *); int dwarf_whatform(Dwarf_Attribute, Dwarf_Half *, Dwarf_Error *); int dwarf_whatform_direct(Dwarf_Attribute, Dwarf_Half *, Dwarf_Error *); #ifdef __cplusplus } #endif #endif /* !_LIBDWARF_H_ */ diff --git a/lib/libdwarf/Makefile b/lib/libdwarf/Makefile index a3ef95b2572a..eb8254fd4dd1 100644 --- a/lib/libdwarf/Makefile +++ b/lib/libdwarf/Makefile @@ -1,359 +1,360 @@ # $FreeBSD$ .include PACKAGE=lib${LIB} ELFTCDIR=${SRCTOP}/contrib/elftoolchain SRCDIR= ${ELFTCDIR}/libdwarf .PATH: ${SRCDIR} LIB= dwarf SRCS= \ dwarf_abbrev.c \ dwarf_arange.c \ dwarf_attr.c \ dwarf_attrval.c \ dwarf_cu.c \ dwarf_dealloc.c \ dwarf_die.c \ dwarf_dump.c \ dwarf_errmsg.c \ dwarf_finish.c \ dwarf_form.c \ dwarf_frame.c \ dwarf_funcs.c \ dwarf_init.c \ dwarf_lineno.c \ dwarf_loclist.c \ dwarf_macinfo.c \ dwarf_pro_arange.c \ dwarf_pro_attr.c \ dwarf_pro_die.c \ dwarf_pro_expr.c \ dwarf_pro_finish.c \ dwarf_pro_frame.c \ dwarf_pro_funcs.c \ dwarf_pro_init.c \ dwarf_pro_lineno.c \ dwarf_pro_macinfo.c \ dwarf_pro_pubnames.c \ dwarf_pro_reloc.c \ dwarf_pro_sections.c \ dwarf_pro_types.c \ dwarf_pro_vars.c \ dwarf_pro_weaks.c \ dwarf_pubnames.c \ dwarf_pubtypes.c \ dwarf_ranges.c \ dwarf_reloc.c \ dwarf_sections.c \ dwarf_seterror.c \ dwarf_str.c \ dwarf_types.c \ dwarf_vars.c \ dwarf_weaks.c \ libdwarf.c \ libdwarf_abbrev.c \ libdwarf_arange.c \ libdwarf_attr.c \ libdwarf_die.c \ libdwarf_error.c \ libdwarf_elf_access.c \ libdwarf_elf_init.c \ libdwarf_frame.c \ libdwarf_info.c \ libdwarf_init.c \ libdwarf_lineno.c \ libdwarf_loc.c \ libdwarf_loclist.c \ libdwarf_macinfo.c \ libdwarf_nametbl.c \ libdwarf_ranges.c \ libdwarf_reloc.c \ libdwarf_rw.c \ libdwarf_sections.c \ libdwarf_str.c INCS= dwarf.h libdwarf.h # This same hack is in lib/libelf/Makefile and usr.bin/readelf/Makefile # We need to link against the correct version of these files. One # solution is to include ../../sys in the include path. This causes # problems when a header file in sys depends on a file in another # part of the tree, e.g. a machine dependent header. # SRCS+= sys/elf32.h sys/elf64.h sys/elf_common.h GENSRCS= dwarf_pubnames.c dwarf_pubtypes.c dwarf_weaks.c \ dwarf_funcs.c dwarf_vars.c dwarf_types.c \ dwarf_pro_pubnames.c dwarf_pro_weaks.c \ dwarf_pro_funcs.c dwarf_pro_types.c \ dwarf_pro_vars.c CLEANFILES= ${GENSRCS} CLEANDIRS= sys CFLAGS+= -I. -I${SRCDIR} -I${ELFTCDIR}/common -I${ELFTCDIR}/libelf sys/elf32.h sys/elf64.h sys/elf_common.h: ${SRCTOP}/sys/${.TARGET} .NOMETA mkdir -p ${.OBJDIR}/sys ln -sf ${.ALLSRC} ${.TARGET} LIBADD+= elf z SHLIB_MAJOR= 4 MAN= dwarf.3 \ dwarf_add_arange.3 \ dwarf_add_AT_comp_dir.3 \ dwarf_add_AT_const_value_string.3 \ dwarf_add_AT_dataref.3 \ dwarf_add_AT_flag.3 \ dwarf_add_AT_location_expr.3 \ dwarf_add_AT_name.3 \ dwarf_add_AT_producer.3 \ dwarf_add_AT_ref_address.3 \ dwarf_add_AT_reference.3 \ dwarf_add_AT_signed_const.3 \ dwarf_add_AT_string.3 \ dwarf_add_AT_targ_address.3 \ dwarf_add_die_to_debug.3 \ dwarf_add_directory_decl.3 \ dwarf_add_expr_addr.3 \ dwarf_add_expr_gen.3 \ dwarf_add_fde_inst.3 \ dwarf_add_file_decl.3 \ dwarf_add_frame_cie.3 \ dwarf_add_frame_fde.3 \ dwarf_add_funcname.3 \ dwarf_add_line_entry.3 \ dwarf_add_pubname.3 \ dwarf_add_typename.3 \ dwarf_add_varname.3 \ dwarf_add_weakname.3 \ dwarf_attr.3 \ dwarf_attrlist.3 \ dwarf_attroffset.3 \ dwarf_attrval_signed.3 \ dwarf_child.3 \ dwarf_dealloc.3 \ dwarf_def_macro.3 \ dwarf_die_abbrev_code.3 \ dwarf_die_link.3 \ dwarf_diename.3 \ dwarf_dieoffset.3 \ dwarf_end_macro_file.3 \ dwarf_errmsg.3 \ dwarf_errno.3 \ dwarf_expand_frame_instructions.3 \ dwarf_expr_current_offset.3 \ dwarf_expr_into_block.3 \ dwarf_fde_cfa_offset.3 \ dwarf_find_macro_value_start.3 \ dwarf_finish.3 \ dwarf_formaddr.3 \ dwarf_formblock.3 \ dwarf_formexprloc.3 \ dwarf_formflag.3 \ dwarf_formref.3 \ dwarf_formsig8.3 \ dwarf_formstring.3 \ dwarf_formudata.3 \ dwarf_get_abbrev.3 \ dwarf_get_abbrev_children_flag.3 \ dwarf_get_abbrev_code.3 \ dwarf_get_abbrev_entry.3 \ dwarf_get_abbrev_tag.3 \ dwarf_get_address_size.3 \ dwarf_get_arange.3 \ dwarf_get_arange_info.3 \ dwarf_get_aranges.3 \ dwarf_get_AT_name.3 \ dwarf_get_cie_index.3 \ dwarf_get_cie_info.3 \ dwarf_get_cie_of_fde.3 \ dwarf_get_cu_die_offset.3 \ dwarf_get_die_infotypes_flag.3 \ dwarf_get_elf.3 \ dwarf_get_fde_at_pc.3 \ dwarf_get_fde_info_for_all_regs.3 \ dwarf_get_fde_info_for_all_regs3.3 \ dwarf_get_fde_info_for_cfa_reg3.3 \ dwarf_get_fde_info_for_reg.3 \ dwarf_get_fde_info_for_reg3.3 \ dwarf_get_fde_instr_bytes.3 \ dwarf_get_fde_list.3 \ dwarf_get_fde_n.3 \ dwarf_get_fde_range.3 \ dwarf_get_form_class.3 \ dwarf_get_funcs.3 \ dwarf_get_globals.3 \ dwarf_get_loclist_entry.3 \ dwarf_get_macro_details.3 \ dwarf_get_pubtypes.3 \ dwarf_get_ranges.3 \ dwarf_get_relocation_info.3 \ dwarf_get_relocation_info_count.3 \ dwarf_get_section_bytes.3 \ dwarf_get_section_max_offsets.3 \ dwarf_get_str.3 \ dwarf_get_types.3 \ dwarf_get_vars.3 \ dwarf_get_weaks.3 \ dwarf_hasattr.3 \ dwarf_hasform.3 \ dwarf_highpc.3 \ dwarf_init.3 \ dwarf_lineno.3 \ dwarf_lne_end_sequence.3 \ dwarf_lne_set_address.3 \ dwarf_loclist.3 \ dwarf_loclist_from_expr.3 \ dwarf_new_die.3 \ dwarf_new_expr.3 \ dwarf_new_fde.3 \ dwarf_next_cu_header.3 \ dwarf_next_types_section.3 \ dwarf_object_init.3 \ dwarf_producer_init.3 \ dwarf_producer_set_isa.3 \ dwarf_reset_section_bytes.3 \ dwarf_seterrarg.3 \ dwarf_set_frame_cfa_value.3 \ dwarf_set_reloc_application.3 \ dwarf_srcfiles.3 \ dwarf_srclines.3 \ dwarf_start_macro_file.3 \ dwarf_tag.3 \ dwarf_transform_to_disk_form.3 \ dwarf_undef_macro.3 \ dwarf_vendor_ext.3 \ dwarf_whatattr.3 MLINKS+= \ dwarf_add_AT_const_value_string.3 dwarf_add_AT_const_value_signedint.3 \ dwarf_add_AT_const_value_string.3 dwarf_add_AT_const_value_unsignedint.3 \ dwarf_add_AT_signed_const.3 dwarf_add_AT_unsigned_const.3 \ dwarf_add_AT_targ_address.3 dwarf_add_AT_targ_address_b.3 \ dwarf_add_arange.3 dwarf_add_arange_b.3 \ dwarf_add_expr_addr.3 dwarf_add_expr_addr_b.3 \ dwarf_add_frame_fde.3 dwarf_add_frame_fde_b.3 \ dwarf_attrval_signed.3 dwarf_attrval_flag.3 \ dwarf_attrval_signed.3 dwarf_attrval_string.3 \ dwarf_attrval_signed.3 dwarf_attrval_unsigned.3 \ dwarf_child.3 dwarf_offdie.3 \ dwarf_child.3 dwarf_offdie_b.3 \ dwarf_child.3 dwarf_siblingof.3 \ dwarf_child.3 dwarf_siblingof_b.3 \ dwarf_dealloc.3 dwarf_fde_cie_list_dealloc.3 \ dwarf_dealloc.3 dwarf_funcs_dealloc.3 \ dwarf_dealloc.3 dwarf_globals_dealloc.3 \ dwarf_dealloc.3 dwarf_pubtypes_dealloc.3 \ dwarf_dealloc.3 dwarf_types_dealloc.3 \ dwarf_dealloc.3 dwarf_vars_dealloc.3 \ dwarf_dealloc.3 dwarf_weaks_dealloc.3 \ dwarf_dealloc.3 dwarf_ranges_dealloc.3 \ dwarf_dealloc.3 dwarf_srclines_dealloc.3 \ dwarf_init.3 dwarf_elf_init.3 \ dwarf_dieoffset.3 dwarf_die_CU_offset.3 \ dwarf_dieoffset.3 dwarf_die_CU_offset_range.3 \ dwarf_dieoffset.3 dwarf_get_cu_die_offset_given_cu_header_offset.3 \ dwarf_dieoffset.3 dwarf_get_cu_die_offset_given_cu_header_offset_b.3 \ dwarf_finish.3 dwarf_object_finish.3 \ dwarf_formref.3 dwarf_global_formref.3 \ dwarf_formudata.3 dwarf_formsdata.3 \ dwarf_get_AT_name.3 dwarf_get_ACCESS_name.3 \ dwarf_get_AT_name.3 dwarf_get_ATE_name.3 \ dwarf_get_AT_name.3 dwarf_get_CC_name.3 \ dwarf_get_AT_name.3 dwarf_get_CFA_name.3 \ dwarf_get_AT_name.3 dwarf_get_CHILDREN_name.3 \ dwarf_get_AT_name.3 dwarf_get_DS_name.3 \ dwarf_get_AT_name.3 dwarf_get_DSC_name.3 \ dwarf_get_AT_name.3 dwarf_get_EH_name.3 \ dwarf_get_AT_name.3 dwarf_get_END_name.3 \ dwarf_get_AT_name.3 dwarf_get_FORM_name.3 \ dwarf_get_AT_name.3 dwarf_get_ID_name.3 \ dwarf_get_AT_name.3 dwarf_get_INL_name.3 \ dwarf_get_AT_name.3 dwarf_get_LANG_name.3 \ dwarf_get_AT_name.3 dwarf_get_LNE_name.3 \ dwarf_get_AT_name.3 dwarf_get_LNS_name.3 \ dwarf_get_AT_name.3 dwarf_get_MACINFO_name.3 \ dwarf_get_AT_name.3 dwarf_get_OP_name.3 \ dwarf_get_AT_name.3 dwarf_get_ORD_name.3 \ dwarf_get_AT_name.3 dwarf_get_TAG_name.3 \ + dwarf_get_AT_name.3 dwarf_get_UT_name.3 \ dwarf_get_AT_name.3 dwarf_get_VIRTUALITY_name.3 \ dwarf_get_AT_name.3 dwarf_get_VIS_name.3 \ dwarf_get_cu_die_offset.3 dwarf_get_arange_cu_header_offset.3 \ dwarf_get_fde_list.3 dwarf_get_fde_list_eh.3 \ dwarf_get_funcs.3 dwarf_func_die_offset.3 \ dwarf_get_funcs.3 dwarf_func_cu_offset.3 \ dwarf_get_funcs.3 dwarf_func_name_offsets.3 \ dwarf_get_funcs.3 dwarf_funcname.3 \ dwarf_get_globals.3 dwarf_global_die_offset.3 \ dwarf_get_globals.3 dwarf_global_cu_offset.3 \ dwarf_get_globals.3 dwarf_global_name_offsets.3 \ dwarf_get_globals.3 dwarf_globname.3 \ dwarf_get_pubtypes.3 dwarf_pubtype_die_offset.3 \ dwarf_get_pubtypes.3 dwarf_pubtype_cu_offset.3 \ dwarf_get_pubtypes.3 dwarf_pubtype_name_offsets.3 \ dwarf_get_pubtypes.3 dwarf_pubtypename.3 \ dwarf_get_ranges.3 dwarf_get_ranges_a.3 \ dwarf_get_section_max_offsets.3 dwarf_get_section_max_offsets_b.3 \ dwarf_get_types.3 dwarf_type_die_offset.3 \ dwarf_get_types.3 dwarf_type_cu_offset.3 \ dwarf_get_types.3 dwarf_type_name_offsets.3 \ dwarf_get_types.3 dwarf_typename.3 \ dwarf_get_vars.3 dwarf_var_die_offset.3 \ dwarf_get_vars.3 dwarf_var_cu_offset.3 \ dwarf_get_vars.3 dwarf_var_name_offsets.3 \ dwarf_get_vars.3 dwarf_varname.3 \ dwarf_get_weaks.3 dwarf_weak_die_offset.3 \ dwarf_get_weaks.3 dwarf_weak_cu_offset.3 \ dwarf_get_weaks.3 dwarf_weak_name_offsets.3 \ dwarf_get_weaks.3 dwarf_weakname.3 \ dwarf_hasform.3 dwarf_whatform.3 \ dwarf_hasform.3 dwarf_whatform_direct.3 \ dwarf_highpc.3 dwarf_arrayorder.3 \ dwarf_highpc.3 dwarf_bitoffset.3 \ dwarf_highpc.3 dwarf_bitsize.3 \ dwarf_highpc.3 dwarf_bytesize.3 \ dwarf_highpc.3 dwarf_highpc_b.3 \ dwarf_highpc.3 dwarf_lowpc.3 \ dwarf_highpc.3 dwarf_srclang.3 \ dwarf_lineno.3 dwarf_lineaddr.3 \ dwarf_lineno.3 dwarf_linebeginstatement.3 \ dwarf_lineno.3 dwarf_lineblock.3 \ dwarf_lineno.3 dwarf_lineendsequence.3 \ dwarf_lineno.3 dwarf_lineoff.3 \ dwarf_lineno.3 dwarf_linesrc.3 \ dwarf_lineno.3 dwarf_line_srcfileno.3 \ dwarf_loclist.3 dwarf_loclist_n.3 \ dwarf_loclist_from_expr.3 dwarf_loclist_from_expr_a.3 \ dwarf_loclist_from_expr.3 dwarf_loclist_from_expr_b.3 \ dwarf_next_cu_header.3 dwarf_next_cu_header_b.3 \ dwarf_next_cu_header.3 dwarf_next_cu_header_c.3 \ dwarf_producer_init.3 dwarf_producer_init_b.3 \ dwarf_seterrarg.3 dwarf_seterrhand.3 \ dwarf_set_frame_cfa_value.3 dwarf_set_frame_rule_initial_value.3 \ dwarf_set_frame_cfa_value.3 dwarf_set_frame_rule_table_size.3 \ dwarf_set_frame_cfa_value.3 dwarf_set_frame_same_value.3 \ dwarf_set_frame_cfa_value.3 dwarf_set_frame_undefined_value.3 dwarf_pubnames.c: dwarf_nametbl.m4 dwarf_pubnames.m4 dwarf_pubtypes.c: dwarf_nametbl.m4 dwarf_pubtypes.m4 dwarf_weaks.c: dwarf_nametbl.m4 dwarf_weaks.m4 dwarf_funcs.c: dwarf_nametbl.m4 dwarf_funcs.m4 dwarf_vars.c: dwarf_nametbl.m4 dwarf_vars.m4 dwarf_types.c: dwarf_nametbl.m4 dwarf_types.m4 dwarf_pro_pubnames.c: dwarf_pro_nametbl.m4 dwarf_pro_pubnames.m4 dwarf_pro_weaks.c: dwarf_pro_nametbl.m4 dwarf_pro_weaks.m4 dwarf_pro_funcs.c: dwarf_pro_nametbl.m4 dwarf_pro_funcs.m4 dwarf_pro_types.c: dwarf_pro_nametbl.m4 dwarf_pro_types.m4 dwarf_pro_vars.c: dwarf_pro_nametbl.m4 dwarf_pro_vars.m4 .include # Keep the .SUFFIXES line after the include of bsd.lib.mk .SUFFIXES: .m4 .c .m4.c: m4 -D SRCDIR=${SRCDIR} ${M4FLAGS} ${.IMPSRC} > ${.TARGET}