ruby-changes:52865
From: naruse <ko1@a...>
Date: Mon, 15 Oct 2018 01:59:21 +0900 (JST)
Subject: [ruby-changes:52865] naruse:r65077 (trunk): Read debug_info to show inline functions in backtrace
naruse 2018-10-15 01:59:15 +0900 (Mon, 15 Oct 2018) New Revision: 65077 https://svn.ruby-lang.org/cgi-bin/viewvc.cgi?view=revision&revision=65077 Log: Read debug_info to show inline functions in backtrace Modified files: trunk/addr2line.c Index: addr2line.c =================================================================== --- addr2line.c (revision 65076) +++ addr2line.c (revision 65077) @@ -113,7 +113,7 @@ void *alloca(); https://github.com/ruby/ruby/blob/trunk/addr2line.c#L113 PRINTF_ARGS(static int kprintf(const char *fmt, ...), 1, 2); -typedef struct { +typedef struct line_info { const char *dirname; const char *filename; const char *path; /* object path */ @@ -122,15 +122,35 @@ typedef struct { https://github.com/ruby/ruby/blob/trunk/addr2line.c#L122 uintptr_t base_addr; uintptr_t saddr; const char *sname; /* function name */ + + struct line_info *next; } line_info_t; -typedef struct obj_info obj_info_t; -struct obj_info { + +struct dwarf_section { + ElfW(Shdr) *shdr; + char *ptr; + size_t size; +}; + +typedef struct obj_info { const char *path; /* object path */ - void *mapped; + char *mapped; size_t mapped_size; - void *uncompressed_debug_line; + void *uncompressed; uintptr_t base_addr; - obj_info_t *next; + struct dwarf_section debug_abbrev; + struct dwarf_section debug_info; + struct dwarf_section debug_line; + struct dwarf_section debug_ranges; + struct dwarf_section debug_str; + struct obj_info *next; +} obj_info_t; +#define obj_dwarf_section_at(obj,n) (&obj->debug_abbrev + n) +#define DWARF_SECTION_COUNT 5 + +struct debug_section_definition { + const char *name; + struct dwarf_section *dwarf; }; /* Avoid consuming stack as this module may be used from signal handler */ @@ -194,8 +214,7 @@ get_nth_dirname(unsigned long dir, char https://github.com/ruby/ruby/blob/trunk/addr2line.c#L214 } static void -fill_filename(int file, char *include_directories, char *filenames, - line_info_t *line) +fill_filename(int file, char *include_directories, char *filenames, line_info_t *line) { int i; char *p = filenames; @@ -485,40 +504,1013 @@ follow_debuglink(const char *debuglink, https://github.com/ruby/ruby/blob/trunk/addr2line.c#L504 fill_lines(num_traces, traces, 0, objp, lines, offset); } -#ifdef SUPPORT_COMPRESSED_DEBUG_LINE -static int -parse_compressed_debug_line(int num_traces, void **traces, - char *debug_line, unsigned long size, - obj_info_t *obj, line_info_t *lines, int offset) +enum +{ + DW_TAG_inlined_subroutine = 0x1d, + DW_TAG_subprogram = 0x2e, +}; + +/* Attributes encodings */ +enum +{ + DW_AT_sibling = 0x01, + DW_AT_location = 0x02, + DW_AT_name = 0x03, + /* Reserved 0x04 */ + /* Reserved 0x05 */ + /* Reserved 0x06 */ + /* Reserved 0x07 */ + /* Reserved 0x08 */ + DW_AT_ordering = 0x09, + /* Reserved 0x0a */ + DW_AT_byte_size = 0x0b, + /* Reserved 0x0c */ + DW_AT_bit_size = 0x0d, + /* Reserved 0x0e */ + /* Reserved 0x0f */ + DW_AT_stmt_list = 0x10, + DW_AT_low_pc = 0x11, + DW_AT_high_pc = 0x12, + DW_AT_language = 0x13, + /* Reserved 0x14 */ + DW_AT_discr = 0x15, + DW_AT_discr_value = 0x16, + DW_AT_visibility = 0x17, + DW_AT_import = 0x18, + DW_AT_string_length = 0x19, + DW_AT_common_reference = 0x1a, + DW_AT_comp_dir = 0x1b, + DW_AT_const_value = 0x1c, + DW_AT_containing_type = 0x1d, + DW_AT_default_value = 0x1e, + /* Reserved 0x1f */ + DW_AT_inline = 0x20, + DW_AT_is_optional = 0x21, + DW_AT_lower_bound = 0x22, + /* Reserved 0x23 */ + /* Reserved 0x24 */ + DW_AT_producer = 0x25, + /* Reserved 0x26 */ + DW_AT_prototyped = 0x27, + /* Reserved 0x28 */ + /* Reserved 0x29 */ + DW_AT_return_addr = 0x2a, + /* Reserved 0x2b */ + DW_AT_start_scope = 0x2c, + /* Reserved 0x2d */ + DW_AT_bit_stride = 0x2e, + DW_AT_upper_bound = 0x2f, + /* Reserved 0x30 */ + DW_AT_abstract_origin = 0x31, + DW_AT_accessibility = 0x32, + DW_AT_address_class = 0x33, + DW_AT_artificial = 0x34, + DW_AT_base_types = 0x35, + DW_AT_calling_convention = 0x36, + DW_AT_count = 0x37, + DW_AT_data_member_location = 0x38, + DW_AT_decl_column = 0x39, + DW_AT_decl_file = 0x3a, + DW_AT_decl_line = 0x3b, + DW_AT_declaration = 0x3c, + DW_AT_discr_list = 0x3d, + DW_AT_encoding = 0x3e, + DW_AT_external = 0x3f, + DW_AT_frame_base = 0x40, + DW_AT_friend = 0x41, + DW_AT_identifier_case = 0x42, + /* Reserved 0x43 */ + DW_AT_namelist_item = 0x44, + DW_AT_priority = 0x45, + DW_AT_segment = 0x46, + DW_AT_specification = 0x47, + DW_AT_static_link = 0x48, + DW_AT_type = 0x49, + DW_AT_use_location = 0x4a, + DW_AT_variable_parameter = 0x4b, + DW_AT_virtuality = 0x4c, + DW_AT_vtable_elem_location = 0x4d, + DW_AT_allocated = 0x4e, + DW_AT_associated = 0x4f, + DW_AT_data_location = 0x50, + DW_AT_byte_stride = 0x51, + DW_AT_entry_pc = 0x52, + DW_AT_use_UTF8 = 0x53, + DW_AT_extension = 0x54, + DW_AT_ranges = 0x55, + DW_AT_trampoline = 0x56, + DW_AT_call_column = 0x57, + DW_AT_call_file = 0x58, + DW_AT_call_line = 0x59, + DW_AT_description = 0x5a, + DW_AT_binary_scale = 0x5b, + DW_AT_decimal_scale = 0x5c, + DW_AT_small = 0x5d, + DW_AT_decimal_sign = 0x5e, + DW_AT_digit_count = 0x5f, + DW_AT_picture_string = 0x60, + DW_AT_mutable = 0x61, + DW_AT_threads_scaled = 0x62, + DW_AT_explicit = 0x63, + DW_AT_object_pointer = 0x64, + DW_AT_endianity = 0x65, + DW_AT_elemental = 0x66, + DW_AT_pure = 0x67, + DW_AT_recursive = 0x68, + DW_AT_signature = 0x69, + DW_AT_main_subprogram = 0x6a, + DW_AT_data_bit_offset = 0x6b, + DW_AT_const_expr = 0x6c, + DW_AT_enum_class = 0x6d, + DW_AT_linkage_name = 0x6e, + DW_AT_string_length_bit_size = 0x6f, + DW_AT_string_length_byte_size = 0x70, + DW_AT_rank = 0x71, + DW_AT_str_offsets_base = 0x72, + DW_AT_addr_base = 0x73, + DW_AT_rnglists_base = 0x74, + /* Reserved 0x75 */ + DW_AT_dwo_name = 0x76, + DW_AT_reference = 0x77, + DW_AT_rvalue_reference = 0x78, + DW_AT_macros = 0x79, + DW_AT_call_all_calls = 0x7a, + DW_AT_call_all_source_calls = 0x7b, + DW_AT_call_all_tail_calls = 0x7c, + DW_AT_call_return_pc = 0x7d, + DW_AT_call_value = 0x7e, + DW_AT_call_origin = 0x7f, + DW_AT_call_parameter = 0x80, + DW_AT_call_pc = 0x81, + DW_AT_call_tail_call = 0x82, + DW_AT_call_target = 0x83, + DW_AT_call_target_clobbered = 0x84, + DW_AT_call_data_location = 0x85, + DW_AT_call_data_value = 0x86, + DW_AT_noreturn = 0x87, + DW_AT_alignment = 0x88, + DW_AT_export_symbols = 0x89, + DW_AT_deleted = 0x8a, + DW_AT_defaulted = 0x8b, + DW_AT_loclists_base = 0x8c, + DW_AT_lo_user = 0x2000, + DW_AT_hi_user = 0x3fff +}; + +/* Attribute form encodings */ +enum +{ + DW_FORM_addr = 0x01, + /* Reserved 0x02 */ + DW_FORM_block2 = 0x03, + DW_FORM_block4 = 0x04, + DW_FORM_data2 = 0x05, + DW_FORM_data4 = 0x06, + DW_FORM_data8 = 0x07, + DW_FORM_string = 0x08, + DW_FORM_block = 0x09, + DW_FORM_block1 = 0x0a, + DW_FORM_data1 = 0x0b, + DW_FORM_flag = 0x0c, + DW_FORM_sdata = 0x0d, + DW_FORM_strp = 0x0e, + DW_FORM_udata = 0x0f, + DW_FORM_ref_addr = 0x10, + DW_FORM_ref1 = 0x11, + DW_FORM_ref2 = 0x12, + DW_FORM_ref4 = 0x13, + DW_FORM_ref8 = 0x14, + DW_FORM_ref_udata = 0x15, + DW_FORM_indirect = 0x16, + DW_FORM_sec_offset = 0x17, + DW_FORM_exprloc = 0x18, + DW_FORM_flag_present = 0x19, + DW_FORM_strx = 0x1a, + DW_FORM_addrx = 0x1b, + DW_FORM_ref_sup4 = 0x1c, + DW_FORM_strp_sup = 0x1d, + DW_FORM_data16 = 0x1e, + DW_FORM_line_strp = 0x1f, + DW_FORM_ref_sig8 = 0x20, + DW_FORM_implicit_const = 0x21, + DW_FORM_loclistx = 0x22, + DW_FORM_rnglistx = 0x23, + DW_FORM_ref_sup8 = 0x24, + DW_FORM_strx1 = 0x25, + DW_FORM_strx2 = 0x26, + DW_FORM_strx3 = 0x27, + DW_FORM_strx4 = 0x28, + DW_FORM_addrx1 = 0x29, + DW_FORM_addrx2 = 0x2a, + DW_FORM_addrx3 = 0x2b, + DW_FORM_addrx4 = 0x2c +}; + +enum { + VAL_none = 0, + VAL_cstr = 1, + VAL_data = 2, + VAL_uint = 3, + VAL_int = 4 +}; + +typedef struct { + uint32_t unit_length; + uint16_t version; + uint32_t debug_abbrev_offset; + uint8_t address_size; +} __attribute__((packed)) DW_CompilationUnitHeader32; + +typedef struct { + uint32_t initial_length; /* 0xffffffff */ + uint64_t unit_length; + uint16_t version; + uint64_t debug_abbrev_offset; + uint8_t address_size; +} __attribute__((packed)) DW_CompilationUnitHeader64; + +# define ABBREV_TABLE_SIZE 256 +typedef struct { + obj_info_t *obj; + char *file; + char *current_cu; + char *debug_line_cu_end; + char *debug_line_files; + char *debug_line_directories; + char *p; + char *pend; + char *q0; + char *q; + int format; /* 32 or 64 */; + uint8_t address_size; + int level; + char *abbrev_table[ABBREV_TABLE_SIZE]; +} DebugInfoReader; + +typedef struct { + ptrdiff_t pos; + int tag; + int has_children; +} DIE; + +typedef struct { + union { + char *ptr; + uint64_t uint64; + int64_t int64; + } as; + uint64_t off; + uint64_t at; + uint64_t form; + size_t size; + int type; +} DebugInfoValue; + +/* TODO: Big Endian */ +#define MERGE_2INTS(a,b,sz) (((uint64_t)(b)<<sz)|(a)) + +static uint16_t +get_uint16(const uint8_t *p) +{ + return (uint16_t)MERGE_2INTS(p[0],p[1],8); +} + +static uint32_t +get_uint32(const uint8_t *p) +{ + return (uint32_t)MERGE_2INTS(get_uint16(p),get_uint16(p+2),16); +} + +static uint64_t +get_uint64(const uint8_t *p) +{ + return MERGE_2INTS(get_uint32(p),get_uint32(p+4),32); +} + +static uint8_t +read_uint8(char **ptr) { + const unsigned char *p = (const unsigned char *)*ptr; + *ptr = (char *)(p + 1); + return *p; +} + +static uint16_t +read_uint16(char **ptr) { + const unsigned char *p = (const unsigned char *)*ptr; + *ptr = (char *)(p + 2); + return get_uint16(p); +} + +static uint32_t +read_uint24(char **ptr) { + const unsigned char *p = (const unsigned char *)*ptr; + *ptr = (char *)(p + 3); + return (*p << 16) | get_uint16(p+1); +} + +static uint32_t +read_uint32(char **ptr) { + const unsigned char *p = (const unsigned char *)*ptr; + *ptr = (char *)(p + 4); + return get_uint32(p); +} + +static uint64_t +read_uint64(char **ptr) { + const unsigned char *p = (const unsigned char *)*ptr; + *ptr = (char *)(p + 8); + return get_uint64(p); +} + +uint64_t +read_uint(DebugInfoReader *reader) { + uint64_t v; + if (reader->format == 32) { + v = read_uint32(&reader->p); + } else { /* 64 bit */ + v = read_uint64(&reader->p); + } + return v; +} + +uint64_t +read_uleb128(DebugInfoReader *reader) +{ + return uleb128(&reader->p); +} + +int64_t +read_sleb128(DebugInfoReader *reader) +{ + return sleb128(&reader->p); +} + +static void +debug_info_reader_init(DebugInfoReader *reader, obj_info_t *obj) +{ + reader->file = obj->mapped; + reader->obj = obj; + reader->p = obj->debug_info.ptr; + reader->pend = obj->debug_info.ptr + obj->debug_info.size; + reader->debug_line_cu_end = obj->debug_line.ptr; +} + +static void +di_read_debug_abbrev_cu(DebugInfoReader *reader) +{ + uint64_t prev = 0; + char *p = reader->q0; + for (;;) { + uint64_t abbrev_number = uleb128(&p); + if (abbrev_number <= prev) break; + if (abbrev_number < ABBREV_TABLE_SIZE) { + reader->abbrev_table[abbrev_number] = p; + } + prev = abbrev_number; + uleb128(&p); /* tag */ + p++; /* has_children */ + /* skip content */ + for (;;) { + uint64_t at = uleb128(&p); + uint64_t form = uleb128(&p); + if (!at && !form) break; + } + } +} + +static void +di_read_debug_line_cu(DebugInfoReader *reader) +{ + char *p; + unsigned long unit_length; + unsigned int opcode_base; + + p = reader->debug_line_cu_end; + + unit_length = *(unsigned int *)p; + p += sizeof(unsigned int); + if (unit_length == 0xffffffff) { + unit_length = *(unsigned long *)p; + p += sizeof(unsigned long); + } + + reader->debug_line_cu_end = p + unit_length; + p += 2; + p += sizeof(unsigned int); + p += 4; + opcode_base = *(unsigned char *)p++; + + /* standard_opcode_lengths = (unsigned char *)p - 1; */ + p += opcode_base - 1; + + reader->debug_line_directories = p; + + /* skip include directories */ + while (*p) { + p = memchr(p, '\0', reader->debug_line_cu_end - p); + if (!p) { + fprintf(stderr, "Wrongly reached the end of Directory Table at %tx", + reader->debug_line_directories - reader->obj->debug_line.ptr); + abort(); + } + p++; + } + p++; + reader->debug_line_files = p; +} + + +static void +di_read_cu(DebugInfoReader *reader) +{ + DW_CompilationUnitHeader32 *hdr32 = (DW_CompilationUnitHeader32 *)reader->p; + reader->current_cu = reader->p; + if (hdr32->unit_length == 0xffffffff) { + DW_CompilationUnitHeader64 *hdr = (DW_CompilationUnitHeader64 *)hdr32; + reader->p += 23; + reader->q0 = reader->obj->debug_abbrev.ptr + hdr->debug_abbrev_offset; + reader->address_size = hdr->address_size; + reader->format = 64; + } else { + DW_CompilationUnitHeader32 *hdr = hdr32; + reader->p += 11; + reader->q0 = reader->obj->debug_abbrev.ptr + hdr->debug_abbrev_offset; + reader->address_size = hdr->address_size; + reader->format = 32; + } + reader->level = 0; + di_read_debug_abbrev_cu(reader); + di_read_debug_line_cu(reader); +} + +static void +set_uint_value(DebugInfoValue *v, uint64_t n) +{ + v->as.uint64 = n; + v->type = VAL_uint; +} + +static void +set_int_value(DebugInfoValue *v, int64_t n) +{ + v->as.int64 = n; + v->type = VAL_int; +} + +static void +set_cstr_value(DebugInfoValue *v, char *s) +{ + v->as.ptr = s; + v->off = 0; + v->type = VAL_cstr; +} + +static void +set_cstrp_value(DebugInfoValue *v, char *s, uint64_t off) +{ + v->as.ptr = s; + v->off = off; + v->type = VAL_cstr; +} + +static void +set_data_value(DebugInfoValue *v, char *s) +{ + v->as.ptr = s; + v->type = VAL_data; +} + +static const char * +get_cstr_value(DebugInfoValue *v) +{ + if (v->as.ptr) { + return v->as.ptr + v->off; + } else { + return NULL; + } +} + +static void +debug_info_reader_read_value(DebugInfoReader *reader, uint64_t form, DebugInfoValue *v) +{ + switch (form) { + case DW_FORM_addr: + if (reader->address_size == 4) { + set_uint_value(v, read_uint32(&reader->p)); + } else if (reader->address_size == 8) { + set_uint_value(v, read_uint64(&reader->p)); + } else { + fprintf(stderr,"unknown address_size:%d", reader->address_size); + abort(); + } + break; + case DW_FORM_block2: + v->size = read_uint16(&reader->p); + set_data_value(v, reader->p); + reader->p += v->size; + break; + case DW_FORM_block4: + v->size = read_uint32(&reader->p); + set_data_value(v, reader->p); + reader->p += v->size; + break; + case DW_FORM_data2: + set_uint_value(v, read_uint16(&reader->p)); + break; + case DW_FORM_data4: + set_uint_value(v, read_uint32(&reader->p)); + break; + case DW_FORM_data8: + set_uint_value(v, read_uint64(&reader->p)); + break; + case DW_FORM_string: + v->size = strlen(reader->p); + set_cstr_value(v, reader->p); + reader->p += v->size + 1; + break; + case DW_FORM_block: + v->size = uleb128(&reader->p); + set_data_value(v, reader->p); + reader->p += v->size; + break; + case DW_FORM_block1: + v->size = read_uint8(&reader->p); + set_data_value(v, reader->p); + reader->p += v->size; + break; + case DW_FORM_data1: + set_uint_value(v, read_uint8(&reader->p)); + break; + case DW_FORM_flag: + set_uint_value(v, read_uint8(&reader->p)); + break; + case DW_FORM_sdata: + set_int_value(v, read_sleb128(reader)); + break; + case DW_FORM_strp: + set_cstrp_value(v, reader->obj->debug_str.ptr, read_uint(reader)); + break; + case DW_FORM_udata: + set_uint_value(v, read_uleb128(reader)); + break; + case DW_FORM_ref_addr: + if (reader->address_size == 4) { + set_uint_value(v, read_uint32(&reader->p)); + } else if (reader->address_size == 8) { + set_uint_value(v, read_uint64(&reader->p)); + } else { + fprintf(stderr,"unknown address_size:%d", reader->address_size); + abort(); + } + break; + case DW_FORM_ref1: + set_uint_value(v, read_uint8(&reader->p)); + break; + case DW_FORM_ref2: + set_uint_value(v, read_uint16(&reader->p)); + break; + case DW_FORM_ref4: + set_uint_value(v, read_uint32(&reader->p)); + break; + case DW_FORM_ref8: + set_uint_value(v, read_uint64(&reader->p)); + break; + case DW_FORM_ref_udata: + set_uint_value(v, uleb128(&reader->p)); + break; + case DW_FORM_indirect: + /* TODO: read the refered value */ + set_uint_value(v, uleb128(&reader->p)); + break; + case DW_FORM_sec_offset: + set_uint_value(v, read_uint(reader)); /* offset */ + /* addrptr: debug_addr */ + /* lineptr: debug_line */ + /* loclist: debug_loclists */ + /* loclistptr: debug_loclists */ + /* macptr: debug_macro */ + /* rnglist: debug_rnglists */ + /* rnglistptr: debug_rnglists */ + /* stroffsetsptr: debug_str_offsets */ + break; + case DW_FORM_exprloc: + v->size = read_uleb128(reader); + set_data_value(v, reader->p); + reader->p += v->size; + break; + case DW_FORM_flag_present: + set_uint_value(v, 1); + break; + case DW_FORM_strx: + set_uint_value(v, uleb128(&reader->p)); + break; + case DW_FORM_addrx: + /* TODO: read .debug_addr */ + set_uint_value(v, uleb128(&reader->p)); + break; + case DW_FORM_ref_sup4: + set_uint_value(v, read_uint32(&reader->p)); + break; + case DW_FORM_strp_sup: + set_uint_value(v, read_uint(reader)); + //*p = reader->sup_file + reader->sup_str->sh_offset + ret; + break; + case DW_FORM_data16: + v->size = 16; + set_data_value(v, reader->p); + reader->p += v->size; + break; + case DW_FORM_line_strp: + set_uint_value(v, read_uint(reader)); + //*p = reader->file + reader->line->sh_offset + ret; + break; + case DW_FORM_ref_sig8: + set_uint_value(v, read_uint64(&reader->p)); + break; + case DW_FORM_implicit_const: + set_int_value(v, sleb128(&reader->q)); + break; + case DW_FORM_loclistx: + set_uint_value(v, read_uleb128(reader)); + break; + case DW_FORM_rnglistx: + set_uint_value(v, read_uleb128(reader)); + break; + case DW_FORM_ref_sup8: + set_uint_value(v, read_uint64(&reader->p)); + break; + case DW_FORM_strx1: + set_uint_value(v, read_uint8(&reader->p)); + break; + case DW_FORM_strx2: + set_uint_value(v, read_uint16(&reader->p)); + break; + case DW_FORM_strx3: + set_uint_value(v, read_uint24(&reader->p)); + break; + case DW_FORM_strx4: + set_uint_value(v, read_uint32(&reader->p)); + break; + case DW_FORM_addrx1: + set_uint_value(v, read_uint8(&reader->p)); + break; + case DW_FORM_a (... truncated) -- ML: ruby-changes@q... Info: http://www.atdot.net/~ko1/quickml/