diff --git a/binutils/ChangeLog b/binutils/ChangeLog index 11464e5feb..c39385c49a 100644 --- a/binutils/ChangeLog +++ b/binutils/ChangeLog @@ -1,3 +1,34 @@ +2017-02-23 Jan Kratochvil + + * dwarf.c (fetch_indirect_line_string): New function. + (abbrev_attr): New field implicit_const. + (add_abbrev_attr): New parameter implicit_const. + (process_abbrev_section): Support DW_FORM_implicit_const. + (decode_location_expression): Support DW_OP_entry_value. + (read_and_display_attr_value): Add parameter implicit_const. Support + DW_FORM_line_strp and DW_FORM_implicit_const. + (read_and_display_attr): Add parameter implicit_const. + (process_debug_info): Support line_str and DWARF-5. + (read_debug_line_header): Support DWARF-5. + (display_formatted_table): New function. + (display_debug_lines_raw): New parameter file. Support DWARF-5. + (display_debug_lines_decoded): New parameter fileptr. Support DWARF-5. + (display_debug_lines): Pass file parameter. + (display_debug_macro): Update read_and_display_attr_value caller. + (display_debug_abbrev): Support DW_FORM_implicit_const. + (display_loclists_list): New function. + (display_loc_list): Support .debug_loclists. + (display_debug_ranges_list): New function from display_debug_ranges. + (display_debug_rnglists_list): New function. + (display_debug_ranges): Support .debug_rnglists. + (debug_displays): Add .debug_line_str, .debug_loclists and + .debug_rnglists. + * dwarf.h: Include dwarf2.h + (DWARF2_Internal_LineInfo): Add li_offset_size. + (DWARF2_Internal_CompUnit): Add cu_unit_type. + (enum dwarf_section_display_enum): Add line_str. + * readelf.c (process_section_headers): Add rnglists and loclists. + 2017-02-23 Jan Kratochvil * dwarf.c (display_block): Add parameter delimiter. diff --git a/binutils/dwarf.c b/binutils/dwarf.c index d27313fff4..420ae5d681 100644 --- a/binutils/dwarf.c +++ b/binutils/dwarf.c @@ -611,6 +611,24 @@ fetch_indirect_string (dwarf_vma offset) return (const unsigned char *) section->start + offset; } +static const unsigned char * +fetch_indirect_line_string (dwarf_vma offset) +{ + struct dwarf_section *section = &debug_displays [line_str].section; + + if (section->start == NULL) + return (const unsigned char *) _(""); + + if (offset > section->size) + { + warn (_("DW_FORM_line_strp offset too big: %s\n"), + dwarf_vmatoa ("x", offset)); + return (const unsigned char *) _(""); + } + + return (const unsigned char *) section->start + offset; +} + static const char * fetch_indexed_string (dwarf_vma idx, struct cu_tu_set *this_set, dwarf_vma offset_size, int dwo) @@ -677,6 +695,7 @@ typedef struct abbrev_attr { unsigned long attribute; unsigned long form; + bfd_signed_vma implicit_const; struct abbrev_attr *next; } abbrev_attr; @@ -746,7 +765,8 @@ add_abbrev (unsigned long number, unsigned long tag, int children) } static void -add_abbrev_attr (unsigned long attribute, unsigned long form) +add_abbrev_attr (unsigned long attribute, unsigned long form, + bfd_signed_vma implicit_const) { abbrev_attr *attr; @@ -757,6 +777,7 @@ add_abbrev_attr (unsigned long attribute, unsigned long form) attr->attribute = attribute; attr->form = form; + attr->implicit_const = implicit_const; attr->next = NULL; if (last_abbrev->first_attr == NULL) @@ -809,6 +830,8 @@ process_abbrev_section (unsigned char *start, unsigned char *end) do { unsigned long form; + /* Initialize it due to a false compiler warning. */ + bfd_signed_vma implicit_const = -1; attribute = read_uleb128 (start, & bytes_read, end); start += bytes_read; @@ -820,7 +843,15 @@ process_abbrev_section (unsigned char *start, unsigned char *end) if (start == end) break; - add_abbrev_attr (attribute, form); + if (form == DW_FORM_implicit_const) + { + implicit_const = read_sleb128 (start, & bytes_read, end); + start += bytes_read; + if (start == end) + break; + } + + add_abbrev_attr (attribute, form, implicit_const); } while (attribute != 0); } @@ -1314,13 +1345,15 @@ decode_location_expression (unsigned char * data, &bytes_read, end))); data += bytes_read; break; + case DW_OP_entry_value: case DW_OP_GNU_entry_value: uvalue = read_uleb128 (data, &bytes_read, end); data += bytes_read; /* PR 17531: file: 0cc9cd00. */ if (uvalue > (dwarf_vma) (end - data)) uvalue = end - data; - printf ("DW_OP_GNU_entry_value: ("); + printf ("%s: (", (op == DW_OP_entry_value ? "DW_OP_entry_value" + : "DW_OP_GNU_entry_value")); if (decode_location_expression (data, pointer_size, offset_size, dwarf_version, uvalue, cu_offset, section)) @@ -1498,6 +1531,7 @@ add64 (dwarf_vma * high_bits, dwarf_vma * low_bits, dwarf_vma inc) static unsigned char * read_and_display_attr_value (unsigned long attribute, unsigned long form, + dwarf_signed_vma implicit_const, unsigned char * data, unsigned char * end, dwarf_vma cu_offset, @@ -1540,6 +1574,7 @@ read_and_display_attr_value (unsigned long attribute, break; case DW_FORM_strp: + case DW_FORM_line_strp: case DW_FORM_sec_offset: case DW_FORM_GNU_ref_alt: case DW_FORM_GNU_strp_alt: @@ -1587,8 +1622,13 @@ read_and_display_attr_value (unsigned long attribute, data += bytes_read; if (!do_loc) printf ("%c%s", delimiter, get_FORM_name (form)); - return read_and_display_attr_value (attribute, form, data, end, - cu_offset, pointer_size, + if (form == DW_FORM_implicit_const) + { + implicit_const = read_sleb128 (data, & bytes_read, end); + data += bytes_read; + } + return read_and_display_attr_value (attribute, form, implicit_const, data, + end, cu_offset, pointer_size, offset_size, dwarf_version, debug_info_p, do_loc, section, this_set, delimiter); @@ -1635,6 +1675,11 @@ read_and_display_attr_value (unsigned long attribute, printf ("%c%s", delimiter, dwarf_vmatoa ("d", uvalue)); break; + case DW_FORM_implicit_const: + if (!do_loc) + printf ("%c%s", delimiter, dwarf_vmatoa ("d", implicit_const)); + break; + case DW_FORM_ref8: case DW_FORM_data8: if (!do_loc) @@ -1768,6 +1813,13 @@ read_and_display_attr_value (unsigned long attribute, fetch_indirect_string (uvalue)); break; + case DW_FORM_line_strp: + if (!do_loc) + printf (_("%c(indirect line string, offset: 0x%s): %s"), delimiter, + dwarf_vmatoa ("x", uvalue), + fetch_indirect_line_string (uvalue)); + break; + case DW_FORM_GNU_str_index: if (!do_loc) { @@ -2216,6 +2268,7 @@ get_AT_name (unsigned long attribute) static unsigned char * read_and_display_attr (unsigned long attribute, unsigned long form, + dwarf_signed_vma implicit_const, unsigned char * data, unsigned char * end, dwarf_vma cu_offset, @@ -2229,7 +2282,7 @@ read_and_display_attr (unsigned long attribute, { if (!do_loc) printf (" %-18s:", get_AT_name (attribute)); - data = read_and_display_attr_value (attribute, form, data, end, + data = read_and_display_attr_value (attribute, form, implicit_const, data, end, cu_offset, pointer_size, offset_size, dwarf_version, debug_info_p, do_loc, section, this_set, ' '); @@ -2328,6 +2381,7 @@ process_debug_info (struct dwarf_section *section, printf (_("Contents of the %s section:\n\n"), section->name); load_debug_section (str, file); + load_debug_section (line_str, file); load_debug_section (str_dwo, file); load_debug_section (str_index, file); load_debug_section (str_index_dwo, file); @@ -2380,6 +2434,20 @@ process_debug_info (struct dwarf_section *section, this_set = find_cu_tu_set_v2 (cu_offset, do_types); + if (compunit.cu_version < 5) + { + compunit.cu_unit_type = DW_UT_compile; + /* Initialize it due to a false compiler warning. */ + compunit.cu_pointer_size = -1; + } + else + { + SAFE_BYTE_GET_AND_INC (compunit.cu_unit_type, hdrptr, 1, end); + do_types = (compunit.cu_unit_type == DW_UT_type); + + SAFE_BYTE_GET_AND_INC (compunit.cu_pointer_size, hdrptr, 1, end); + } + SAFE_BYTE_GET_AND_INC (compunit.cu_abbrev_offset, hdrptr, offset_size, end); if (this_set == NULL) @@ -2393,7 +2461,9 @@ process_debug_info (struct dwarf_section *section, abbrev_size = this_set->section_sizes [DW_SECT_ABBREV]; } - SAFE_BYTE_GET_AND_INC (compunit.cu_pointer_size, hdrptr, 1, end); + if (compunit.cu_version < 5) + SAFE_BYTE_GET_AND_INC (compunit.cu_pointer_size, hdrptr, 1, end); + /* PR 17512: file: 001-108546-0.001:0.1. */ if (compunit.cu_pointer_size < 2 || compunit.cu_pointer_size > 8) { @@ -2492,9 +2562,7 @@ process_debug_info (struct dwarf_section *section, start = end; } - if (compunit.cu_version != 2 - && compunit.cu_version != 3 - && compunit.cu_version != 4) + if (compunit.cu_version < 2 || compunit.cu_version > 5) { warn (_("CU at offset %s contains corrupt or " "unsupported version number: %d.\n"), @@ -2502,6 +2570,15 @@ process_debug_info (struct dwarf_section *section, continue; } + if (compunit.cu_unit_type != DW_UT_compile + && compunit.cu_unit_type != DW_UT_type) + { + warn (_("CU at offset %s contains corrupt or " + "unsupported unit type: %d.\n"), + dwarf_vmatoa ("x", cu_offset), compunit.cu_unit_type); + continue; + } + free_abbrevs (); /* Process the abbrevs used by this compilation unit. */ @@ -2655,6 +2732,7 @@ process_debug_info (struct dwarf_section *section, tags = read_and_display_attr (attr->attribute, attr->form, + attr->implicit_const, tags, end, cu_offset, @@ -2742,8 +2820,8 @@ read_debug_line_header (struct dwarf_section * section, unsigned char ** end_of_sequence) { unsigned char *hdrptr; - unsigned int offset_size; unsigned int initial_length_size; + unsigned char address_size, segment_selector_size; /* Extract information from the Line Number Program Header. (section 6.2.4 in the Dwarf3 doc). */ @@ -2756,12 +2834,12 @@ read_debug_line_header (struct dwarf_section * section, { /* This section is 64-bit DWARF 3. */ SAFE_BYTE_GET_AND_INC (linfo->li_length, hdrptr, 8, end); - offset_size = 8; + linfo->li_offset_size = 8; initial_length_size = 12; } else { - offset_size = 4; + linfo->li_offset_size = 4; initial_length_size = 4; } @@ -2773,7 +2851,7 @@ read_debug_line_header (struct dwarf_section * section, comprised of several different .debug_line.* sections, (some of which may be removed by linker garbage collection), and a relocation is used to compute the correct length once that is done. */ - if (reloc_at (section, (hdrptr - section->start) - offset_size)) + if (reloc_at (section, (hdrptr - section->start) - linfo->li_offset_size)) { linfo->li_length = (end - data) - initial_length_size; } @@ -2790,13 +2868,30 @@ read_debug_line_header (struct dwarf_section * section, if (linfo->li_version != 2 && linfo->li_version != 3 - && linfo->li_version != 4) + && linfo->li_version != 4 + && linfo->li_version != 5) { - warn (_("Only DWARF version 2, 3 and 4 line info is currently supported.\n")); + warn (_("Only DWARF version 2, 3, 4 and 5 line info " + "is currently supported.\n")); return NULL; } - SAFE_BYTE_GET_AND_INC (linfo->li_prologue_length, hdrptr, offset_size, end); + if (linfo->li_version >= 5) + { + SAFE_BYTE_GET_AND_INC (address_size, hdrptr, 1, end); + + SAFE_BYTE_GET_AND_INC (segment_selector_size, hdrptr, 1, end); + if (segment_selector_size != 0) + { + warn (_("The %s section contains " + "unsupported segment selector size: %d.\n"), + section->name, segment_selector_size); + return 0; + } + } + + SAFE_BYTE_GET_AND_INC (linfo->li_prologue_length, hdrptr, + linfo->li_offset_size, end); SAFE_BYTE_GET_AND_INC (linfo->li_min_insn_length, hdrptr, 1, end); if (linfo->li_version >= 4) @@ -2830,10 +2925,126 @@ read_debug_line_header (struct dwarf_section * section, return hdrptr; } +static unsigned char * +display_formatted_table (unsigned char *data, + unsigned char *start, unsigned char *end, + const DWARF2_Internal_LineInfo *linfo, + struct dwarf_section *section, const char *what) +{ + unsigned char *format_start, format_count, *format, formati; + dwarf_vma data_count, datai; + unsigned int bytes_read, namepass, last_entry = 0; + + SAFE_BYTE_GET_AND_INC (format_count, data, 1, end); + format_start = data; + for (formati = 0; formati < format_count; formati++) + { + read_uleb128 (data, & bytes_read, end); + data += bytes_read; + read_uleb128 (data, & bytes_read, end); + data += bytes_read; + if (data == end) + { + warn (_("Corrupt %s entry format table entry\n"), what); + return data; + } + } + + data_count = read_uleb128 (data, & bytes_read, end); + data += bytes_read; + if (data == end) + { + warn (_("Corrupt %s list\n"), what); + return data; + } + + if (data_count == 0) + { + printf (_("\n The %s Table is empty.\n"), what); + return data; + } + + printf (_("\n The %s Table (offset 0x%lx):\n"), what, + (long)(data - start)); + + printf (_(" Entry")); + /* Delay displaying name as the last entry for better screen layout. */ + for (namepass = 0; namepass < 2; namepass++) + { + format = format_start; + for (formati = 0; formati < format_count; formati++) + { + dwarf_vma content_type; + + content_type = read_uleb128 (format, & bytes_read, end); + format += bytes_read; + if ((content_type == DW_LNCT_path) == (namepass == 1)) + switch (content_type) + { + case DW_LNCT_path: + printf (_("\tName")); + break; + case DW_LNCT_directory_index: + printf (_("\tDir")); + break; + case DW_LNCT_timestamp: + printf (_("\tTime")); + break; + case DW_LNCT_size: + printf (_("\tSize")); + break; + case DW_LNCT_MD5: + printf (_("\tMD5")); + break; + default: + printf (_("\t(Unknown format content type %s)"), + dwarf_vmatoa ("u", content_type)); + } + read_uleb128 (format, & bytes_read, end); + format += bytes_read; + } + } + putchar ('\n'); + + for (datai = 0; datai < data_count; datai++) + { + unsigned char *datapass = data; + + printf (" %d", last_entry++); + /* Delay displaying name as the last entry for better screen layout. */ + for (namepass = 0; namepass < 2; namepass++) + { + format = format_start; + data = datapass; + for (formati = 0; formati < format_count; formati++) + { + dwarf_vma content_type, form; + + content_type = read_uleb128 (format, & bytes_read, end); + format += bytes_read; + form = read_uleb128 (format, & bytes_read, end); + format += bytes_read; + data = read_and_display_attr_value (0, form, 0, data, end, 0, 0, + linfo->li_offset_size, + linfo->li_version, NULL, + ((content_type == DW_LNCT_path) != (namepass == 1)), + section, NULL, '\t'); + } + } + if (data == end) + { + warn (_("Corrupt %s entries list\n"), what); + return data; + } + putchar ('\n'); + } + return data; +} + static int display_debug_lines_raw (struct dwarf_section *section, unsigned char *data, - unsigned char *end) + unsigned char *end, void *file) { unsigned char *start = section->start; @@ -2846,7 +3057,6 @@ display_debug_lines_raw (struct dwarf_section *section, DWARF2_Internal_LineInfo linfo; unsigned char *standard_opcodes; unsigned char *end_of_sequence; - unsigned int last_dir_entry = 0; int i; if (const_strneq (section->name, ".debug_line.") @@ -2922,67 +3132,82 @@ display_debug_lines_raw (struct dwarf_section *section, /* Display the contents of the Directory table. */ data = standard_opcodes + linfo.li_opcode_base - 1; - if (*data == 0) - printf (_("\n The Directory Table is empty.\n")); + if (linfo.li_version >= 5) + { + load_debug_section (line_str, file); + + data = display_formatted_table (data, start, end, &linfo, section, + _("Directory")); + data = display_formatted_table (data, start, end, &linfo, section, + _("File name")); + } else { - printf (_("\n The Directory Table (offset 0x%lx):\n"), - (long)(data - start)); - - while (data < end && *data != 0) + if (*data == 0) + printf (_("\n The Directory Table is empty.\n")); + else { - printf (" %d\t%.*s\n", ++last_dir_entry, (int) (end - data), data); + unsigned int last_dir_entry = 0; - data += strnlen ((char *) data, end - data) + 1; + printf (_("\n The Directory Table (offset 0x%lx):\n"), + (long)(data - start)); + + while (data < end && *data != 0) + { + printf (" %d\t%.*s\n", ++last_dir_entry, (int) (end - data), data); + + data += strnlen ((char *) data, end - data) + 1; + } + + /* PR 17512: file: 002-132094-0.004. */ + if (data >= end - 1) + break; } - /* PR 17512: file: 002-132094-0.004. */ - if (data >= end - 1) - break; - } + /* Skip the NUL at the end of the table. */ + data++; - /* Skip the NUL at the end of the table. */ - data++; - - /* Display the contents of the File Name table. */ - if (*data == 0) - printf (_("\n The File Name Table is empty.\n")); - else - { - printf (_("\n The File Name Table (offset 0x%lx):\n"), - (long)(data - start)); - printf (_(" Entry\tDir\tTime\tSize\tName\n")); - - while (data < end && *data != 0) + /* Display the contents of the File Name table. */ + if (*data == 0) + printf (_("\n The File Name Table is empty.\n")); + else { - unsigned char *name; - unsigned int bytes_read; + printf (_("\n The File Name Table (offset 0x%lx):\n"), + (long)(data - start)); + printf (_(" Entry\tDir\tTime\tSize\tName\n")); - printf (" %d\t", ++state_machine_regs.last_file_entry); - name = data; - data += strnlen ((char *) data, end - data) + 1; - - printf ("%s\t", - dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end))); - data += bytes_read; - printf ("%s\t", - dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end))); - data += bytes_read; - printf ("%s\t", - dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end))); - data += bytes_read; - printf ("%.*s\n", (int)(end - name), name); - - if (data == end) + while (data < end && *data != 0) { - warn (_("Corrupt file name table entry\n")); - break; + unsigned char *name; + unsigned int bytes_read; + + printf (" %d\t", ++state_machine_regs.last_file_entry); + name = data; + data += strnlen ((char *) data, end - data) + 1; + + printf ("%s\t", + dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end))); + data += bytes_read; + printf ("%s\t", + dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end))); + data += bytes_read; + printf ("%s\t", + dwarf_vmatoa ("u", read_uleb128 (data, & bytes_read, end))); + data += bytes_read; + printf ("%.*s\n", (int)(end - name), name); + + if (data == end) + { + warn (_("Corrupt file name table entry\n")); + break; + } } } + + /* Skip the NUL at the end of the table. */ + data++; } - /* Skip the NUL at the end of the table. */ - data++; putchar ('\n'); saved_linfo = linfo; } @@ -3196,7 +3421,7 @@ typedef struct static int display_debug_lines_decoded (struct dwarf_section *section, unsigned char *data, - unsigned char *end) + unsigned char *end, void *fileptr) { static DWARF2_Internal_LineInfo saved_linfo; @@ -3213,7 +3438,7 @@ display_debug_lines_decoded (struct dwarf_section *section, File_Entry *file_table = NULL; unsigned int n_files = 0; unsigned char **directory_table = NULL; - unsigned int n_directories = 0; + dwarf_vma n_directories = 0; if (const_strneq (section->name, ".debug_line.") /* Note: the following does not apply to .debug_line.dwo sections. @@ -3261,129 +3486,304 @@ display_debug_lines_decoded (struct dwarf_section *section, return 0; } - if (*data != 0) + if (linfo.li_version >= 5) { - unsigned char *ptr_directory_table = data; + unsigned char *format_start, format_count, *format; + dwarf_vma formati, entryi; + unsigned int bytes_read; - while (data < end && *data != 0) + load_debug_section (line_str, fileptr); + + /* Skip directories format. */ + SAFE_BYTE_GET_AND_INC (format_count, data, 1, end); + format_start = data; + for (formati = 0; formati < format_count; formati++) { - data += strnlen ((char *) data, end - data) + 1; - n_directories++; + read_uleb128 (data, & bytes_read, end); + data += bytes_read; + read_uleb128 (data, & bytes_read, end); + data += bytes_read; } - /* PR 20440 */ - if (data >= end) + n_directories = read_uleb128 (data, & bytes_read, end); + data += bytes_read; + if (data == end) { - warn (_("directory table ends unexpectedly\n")); - n_directories = 0; + warn (_("Corrupt directories list\n")); break; } - /* Go through the directory table again to save the directories. */ directory_table = (unsigned char **) xmalloc (n_directories * sizeof (unsigned char *)); - i = 0; - while (*ptr_directory_table != 0) + for (entryi = 0; entryi < n_directories; entryi++) { - directory_table[i] = ptr_directory_table; - ptr_directory_table += strnlen ((char *) ptr_directory_table, - ptr_directory_table - end) + 1; - i++; - } - } - /* Skip the NUL at the end of the table. */ - data++; + unsigned char **pathp = &directory_table[entryi]; - /* Traverse the File Name table just to count the entries. */ - if (data < end && *data != 0) - { - unsigned char *ptr_file_name_table = data; + format = format_start; + for (formati = 0; formati < format_count; formati++) + { + dwarf_vma content_type, form; + dwarf_vma uvalue; - while (data < end && *data != 0) - { - unsigned int bytes_read; - - /* Skip Name, directory index, last modification time and length - of file. */ - data += strnlen ((char *) data, end - data) + 1; - read_uleb128 (data, & bytes_read, end); - data += bytes_read; - read_uleb128 (data, & bytes_read, end); - data += bytes_read; - read_uleb128 (data, & bytes_read, end); - data += bytes_read; - - n_files++; + content_type = read_uleb128 (format, & bytes_read, end); + format += bytes_read; + form = read_uleb128 (format, & bytes_read, end); + format += bytes_read; + if (data == end) + { + warn (_("Corrupt directories list\n")); + break; + } + switch (content_type) + { + case DW_LNCT_path: + switch (form) + { + case DW_FORM_string: + *pathp = data; + break; + case DW_FORM_line_strp: + SAFE_BYTE_GET (uvalue, data, linfo.li_offset_size, + end); + /* Remove const by the cast. */ + *pathp = (unsigned char *) + fetch_indirect_line_string (uvalue); + break; + } + break; + } + data = read_and_display_attr_value (0, form, 0, data, end, + 0, 0, + linfo.li_offset_size, + linfo.li_version, + NULL, 1, section, + NULL, '\t'); + } + if (data == end) + { + warn (_("Corrupt directories list\n")); + break; + } } - if (data >= end) + /* Skip files format. */ + SAFE_BYTE_GET_AND_INC (format_count, data, 1, end); + format_start = data; + for (formati = 0; formati < format_count; formati++) { - warn (_("file table ends unexpectedly\n")); - n_files = 0; + read_uleb128 (data, & bytes_read, end); + data += bytes_read; + read_uleb128 (data, & bytes_read, end); + data += bytes_read; + } + + n_files = read_uleb128 (data, & bytes_read, end); + data += bytes_read; + if (data == end) + { + warn (_("Corrupt file name list\n")); break; } - /* Go through the file table again to save the strings. */ - file_table = (File_Entry *) xmalloc (n_files * sizeof (File_Entry)); + file_table = (File_Entry *) xcalloc (1, n_files + * sizeof (File_Entry)); - i = 0; - while (*ptr_file_name_table != 0) + for (entryi = 0; entryi < n_files; entryi++) { - unsigned int bytes_read; + File_Entry *file = &file_table[entryi]; - file_table[i].name = ptr_file_name_table; - ptr_file_name_table += strnlen ((char *) ptr_file_name_table, - end - ptr_file_name_table) + 1; - - /* We are not interested in directory, time or size. */ - file_table[i].directory_index = read_uleb128 (ptr_file_name_table, - & bytes_read, end); - ptr_file_name_table += bytes_read; - file_table[i].modification_date = read_uleb128 (ptr_file_name_table, - & bytes_read, end); - ptr_file_name_table += bytes_read; - file_table[i].length = read_uleb128 (ptr_file_name_table, & bytes_read, end); - ptr_file_name_table += bytes_read; - i++; - } - i = 0; - - /* Print the Compilation Unit's name and a header. */ - if (directory_table == NULL) - { - printf (_("CU: %s:\n"), file_table[0].name); - printf (_("File name Line number Starting address\n")); - } - else - { - unsigned int ix = file_table[0].directory_index; - const char *directory; - - if (ix == 0) - directory = "."; - /* PR 20439 */ - else if (n_directories == 0) - directory = _(""); - else if (ix > n_directories) + format = format_start; + for (formati = 0; formati < format_count; formati++) { - warn (_("directory index %u > number of directories %u\n"), ix, n_directories); - directory = _(""); + dwarf_vma content_type, form; + dwarf_vma uvalue; + + content_type = read_uleb128 (format, & bytes_read, end); + format += bytes_read; + form = read_uleb128 (format, & bytes_read, end); + format += bytes_read; + if (data == end) + { + warn (_("Corrupt file name list\n")); + break; + } + switch (content_type) + { + case DW_LNCT_path: + switch (form) + { + case DW_FORM_string: + file->name = data; + break; + case DW_FORM_line_strp: + SAFE_BYTE_GET (uvalue, data, linfo.li_offset_size, + end); + /* Remove const by the cast. */ + file->name = (unsigned char *) + fetch_indirect_line_string (uvalue); + break; + } + break; + case DW_LNCT_directory_index: + switch (form) + { + case DW_FORM_data1: + SAFE_BYTE_GET (file->directory_index, data, 1, + end); + break; + case DW_FORM_data2: + SAFE_BYTE_GET (file->directory_index, data, 2, + end); + break; + case DW_FORM_udata: + file->directory_index = read_uleb128 (data, NULL, + end); + break; + } + break; + } + data = read_and_display_attr_value (0, form, 0, data, end, + 0, 0, + linfo.li_offset_size, + linfo.li_version, + NULL, 1, section, + NULL, '\t'); + } + if (data == end) + { + warn (_("Corrupt file name list\n")); + break; } - else - directory = (char *) directory_table[ix - 1]; - - if (do_wide || strlen (directory) < 76) - printf (_("CU: %s/%s:\n"), directory, file_table[0].name); - else - printf ("%s:\n", file_table[0].name); - - printf (_("File name Line number Starting address\n")); } } + else + { + if (*data != 0) + { + unsigned char *ptr_directory_table = data; - /* Skip the NUL at the end of the table. */ - data++; + while (data < end && *data != 0) + { + data += strnlen ((char *) data, end - data) + 1; + n_directories++; + } + + /* PR 20440 */ + if (data >= end) + { + warn (_("directory table ends unexpectedly\n")); + n_directories = 0; + break; + } + + /* Go through the directory table again to save the directories. */ + directory_table = (unsigned char **) + xmalloc (n_directories * sizeof (unsigned char *)); + + i = 0; + while (*ptr_directory_table != 0) + { + directory_table[i] = ptr_directory_table; + ptr_directory_table += strnlen ((char *) ptr_directory_table, + ptr_directory_table - end) + 1; + i++; + } + } + /* Skip the NUL at the end of the table. */ + data++; + + /* Traverse the File Name table just to count the entries. */ + if (data < end && *data != 0) + { + unsigned char *ptr_file_name_table = data; + + while (data < end && *data != 0) + { + unsigned int bytes_read; + + /* Skip Name, directory index, last modification time and length + of file. */ + data += strnlen ((char *) data, end - data) + 1; + read_uleb128 (data, & bytes_read, end); + data += bytes_read; + read_uleb128 (data, & bytes_read, end); + data += bytes_read; + read_uleb128 (data, & bytes_read, end); + data += bytes_read; + + n_files++; + } + + if (data >= end) + { + warn (_("file table ends unexpectedly\n")); + n_files = 0; + break; + } + + /* Go through the file table again to save the strings. */ + file_table = (File_Entry *) xmalloc (n_files * sizeof (File_Entry)); + + i = 0; + while (*ptr_file_name_table != 0) + { + unsigned int bytes_read; + + file_table[i].name = ptr_file_name_table; + ptr_file_name_table += strnlen ((char *) ptr_file_name_table, + end - ptr_file_name_table) + 1; + + /* We are not interested in directory, time or size. */ + file_table[i].directory_index = read_uleb128 (ptr_file_name_table, + & bytes_read, end); + ptr_file_name_table += bytes_read; + file_table[i].modification_date = read_uleb128 (ptr_file_name_table, + & bytes_read, end); + ptr_file_name_table += bytes_read; + file_table[i].length = read_uleb128 (ptr_file_name_table, & bytes_read, end); + ptr_file_name_table += bytes_read; + i++; + } + i = 0; + } + + /* Skip the NUL at the end of the table. */ + data++; + } + + /* Print the Compilation Unit's name and a header. */ + if (directory_table == NULL) + { + printf (_("CU: %s:\n"), file_table[0].name); + printf (_("File name Line number Starting address\n")); + } + else + { + unsigned int ix = file_table[0].directory_index; + const char *directory; + + if (ix == 0) + directory = "."; + /* PR 20439 */ + else if (n_directories == 0) + directory = _(""); + else if (ix > n_directories) + { + warn (_("directory index %u > number of directories %s\n"), + ix, dwarf_vmatoa ("u", n_directories)); + directory = _(""); + } + else + directory = (char *) directory_table[ix - 1]; + + if (do_wide || strlen (directory) < 76) + printf (_("CU: %s/%s:\n"), directory, file_table[0].name); + else + printf ("%s:\n", file_table[0].name); + + printf (_("File name Line number Starting address\n")); + } saved_linfo = linfo; } @@ -3550,7 +3950,8 @@ display_debug_lines_decoded (struct dwarf_section *section, /* PR 20439 */ else if (dir > n_directories) { - warn (_("directory index %u > number of directories %u\n"), dir, n_directories); + warn (_("directory index %u > number of directories %s\n"), + dir, dwarf_vmatoa ("u", n_directories)); printf (_("\n \n"), dir); } else @@ -3722,7 +4123,7 @@ display_debug_lines_decoded (struct dwarf_section *section, } static int -display_debug_lines (struct dwarf_section *section, void *file ATTRIBUTE_UNUSED) +display_debug_lines (struct dwarf_section *section, void *file) { unsigned char *data = section->start; unsigned char *end = data + section->size; @@ -3733,10 +4134,10 @@ display_debug_lines (struct dwarf_section *section, void *file ATTRIBUTE_UNUSED) do_debug_lines |= FLAG_DEBUG_LINES_RAW; if (do_debug_lines & FLAG_DEBUG_LINES_RAW) - retValRaw = display_debug_lines_raw (section, data, end); + retValRaw = display_debug_lines_raw (section, data, end, file); if (do_debug_lines & FLAG_DEBUG_LINES_DECODED) - retValDecoded = display_debug_lines_decoded (section, data, end); + retValDecoded = display_debug_lines_decoded (section, data, end, file); if (!retValRaw || !retValDecoded) return 0; @@ -4326,9 +4727,10 @@ display_debug_macro (struct dwarf_section *section, { int val; + /* DW_FORM_implicit_const is not expected here. */ SAFE_BYTE_GET_AND_INC (val, desc, 1, end); curr - = read_and_display_attr_value (0, val, + = read_and_display_attr_value (0, val, 0, curr, end, 0, 0, offset_size, version, NULL, 0, NULL, NULL, ' '); @@ -4381,9 +4783,14 @@ display_debug_abbrev (struct dwarf_section *section, entry->children ? _("has children") : _("no children")); for (attr = entry->first_attr; attr; attr = attr->next) - printf (" %-18s %s\n", - get_AT_name (attr->attribute), - get_FORM_name (attr->form)); + { + printf (" %-18s %s", + get_AT_name (attr->attribute), + get_FORM_name (attr->form)); + if (attr->form == DW_FORM_implicit_const) + printf (": %" BFD_VMA_FMT "d", attr->implicit_const); + putchar ('\n'); + } } } while (start); @@ -4531,6 +4938,129 @@ display_loc_list (struct dwarf_section *section, *start_ptr = start; } +/* Display a location list from a normal (ie, non-dwo) .debug_loclists section. */ + +static void +display_loclists_list (struct dwarf_section *section, + unsigned char **start_ptr, + unsigned int debug_info_entry, + dwarf_vma offset, + dwarf_vma base_address, + int has_frame_base) +{ + unsigned char *start = *start_ptr; + unsigned char *section_end = section->start + section->size; + unsigned long cu_offset; + unsigned int pointer_size; + unsigned int offset_size; + int dwarf_version; + unsigned int bytes_read; + + dwarf_vma begin; + dwarf_vma end; + dwarf_vma length; + int need_frame_base; + + if (debug_info_entry >= num_debug_info_entries) + { + warn (_("No debug information available for " + "loclists lists of entry: %u\n"), + debug_info_entry); + return; + } + + cu_offset = debug_information [debug_info_entry].cu_offset; + pointer_size = debug_information [debug_info_entry].pointer_size; + offset_size = debug_information [debug_info_entry].offset_size; + dwarf_version = debug_information [debug_info_entry].dwarf_version; + + if (pointer_size < 2 || pointer_size > 8) + { + warn (_("Invalid pointer size (%d) in debug info for entry %d\n"), + pointer_size, debug_info_entry); + return; + } + + while (1) + { + dwarf_vma off = offset + (start - *start_ptr); + enum dwarf_location_list_entry_type llet; + + if (start + 1 > section_end) + { + warn (_("Location list starting at offset 0x%lx is not terminated.\n"), + (unsigned long) offset); + break; + } + + printf (" %8.8lx ", (unsigned long) off); + + SAFE_BYTE_GET_AND_INC (llet, start, 1, section_end); + + switch (llet) + { + case DW_LLE_end_of_list: + printf (_("\n")); + break; + case DW_LLE_offset_pair: + begin = read_uleb128 (start, &bytes_read, section_end); + start += bytes_read; + end = read_uleb128 (start, &bytes_read, section_end); + start += bytes_read; + break; + case DW_LLE_base_address: + SAFE_BYTE_GET_AND_INC (base_address, start, pointer_size, + section_end); + print_dwarf_vma (base_address, pointer_size); + printf (_("(base address)\n")); + break; + default: + error (_("Invalid location list entry type %d\n"), llet); + return; + } + if (llet == DW_LLE_end_of_list) + break; + if (llet != DW_LLE_offset_pair) + continue; + + if (start + 2 > section_end) + { + warn (_("Location list starting at offset 0x%lx is not terminated.\n"), + (unsigned long) offset); + break; + } + + length = read_uleb128 (start, &bytes_read, section_end); + start += bytes_read; + + print_dwarf_vma (begin + base_address, pointer_size); + print_dwarf_vma (end + base_address, pointer_size); + + putchar ('('); + need_frame_base = decode_location_expression (start, + pointer_size, + offset_size, + dwarf_version, + length, + cu_offset, section); + putchar (')'); + + if (need_frame_base && !has_frame_base) + printf (_(" [without DW_AT_frame_base]")); + + if (begin == end) + fputs (_(" (start == end)"), stdout); + else if (begin > end) + fputs (_(" (start > end)"), stdout); + + putchar ('\n'); + + start += length; + } + + *start_ptr = start; +} + /* Print a .debug_addr table index in decimal, surrounded by square brackets, right-adjusted in a field of length LEN, and followed by a space. */ @@ -4701,6 +5231,8 @@ display_debug_loc (struct dwarf_section *section, void *file) unsigned int *array = NULL; const char *suffix = strrchr (section->name, '.'); int is_dwo = 0; + int is_loclists = strstr (section->name, "debug_loclists") != NULL; + dwarf_vma expected_start = 0; if (suffix && strcmp (suffix, ".dwo") == 0) is_dwo = 1; @@ -4713,6 +5245,51 @@ display_debug_loc (struct dwarf_section *section, void *file) return 0; } + if (is_loclists) + { + unsigned char *hdrptr = section_begin; + dwarf_vma ll_length; + unsigned short ll_version; + unsigned char *end = section_begin + section->size; + unsigned char address_size, segment_selector_size; + uint32_t offset_entry_count; + + SAFE_BYTE_GET_AND_INC (ll_length, hdrptr, 4, end); + if (ll_length == 0xffffffff) + SAFE_BYTE_GET_AND_INC (ll_length, hdrptr, 8, end); + + SAFE_BYTE_GET_AND_INC (ll_version, hdrptr, 2, end); + if (ll_version != 5) + { + warn (_("The %s section contains corrupt or " + "unsupported version number: %d.\n"), + section->name, ll_version); + return 0; + } + + SAFE_BYTE_GET_AND_INC (address_size, hdrptr, 1, end); + + SAFE_BYTE_GET_AND_INC (segment_selector_size, hdrptr, 1, end); + if (segment_selector_size != 0) + { + warn (_("The %s section contains " + "unsupported segment selector size: %d.\n"), + section->name, segment_selector_size); + return 0; + } + + SAFE_BYTE_GET_AND_INC (offset_entry_count, hdrptr, 4, end); + if (offset_entry_count != 0) + { + warn (_("The %s section contains " + "unsupported offset entry count: %d.\n"), + section->name, offset_entry_count); + return 0; + } + + expected_start = hdrptr - section_begin; + } + if (load_debug_info (file) == 0) { warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"), @@ -4762,7 +5339,7 @@ display_debug_loc (struct dwarf_section *section, void *file) error (_("No location lists in .debug_info section!\n")); if (debug_information [first].num_loc_offsets > 0 - && debug_information [first].loc_offsets [0] != 0) + && debug_information [first].loc_offsets [0] != expected_start) warn (_("Location lists in %s section start at 0x%s\n"), section->name, dwarf_vmatoa ("x", debug_information [first].loc_offsets [0])); @@ -4826,11 +5403,23 @@ display_debug_loc (struct dwarf_section *section, void *file) continue; } - if (is_dwo) - display_loc_list_dwo (section, &start, i, offset, has_frame_base); + if (!is_loclists) + { + if (is_dwo) + display_loc_list_dwo (section, &start, i, offset, + has_frame_base); + else + display_loc_list (section, &start, i, offset, base_address, + has_frame_base); + } else - display_loc_list (section, &start, i, offset, base_address, - has_frame_base); + { + if (is_dwo) + warn (_("DWO is not yet supported.\n")); + else + display_loclists_list (section, &start, i, offset, base_address, + has_frame_base); + } } } @@ -5172,6 +5761,125 @@ range_entry_compar (const void *ap, const void *bp) return (a > b) - (b > a); } +static void +display_debug_ranges_list (unsigned char *start, unsigned char *finish, + unsigned int pointer_size, unsigned long offset, + unsigned long base_address) +{ + while (start < finish) + { + dwarf_vma begin; + dwarf_vma end; + + SAFE_BYTE_GET_AND_INC (begin, start, pointer_size, finish); + if (start >= finish) + break; + SAFE_SIGNED_BYTE_GET_AND_INC (end, start, pointer_size, finish); + + printf (" %8.8lx ", offset); + + if (begin == 0 && end == 0) + { + printf (_("\n")); + break; + } + + /* Check base address specifiers. */ + if (is_max_address (begin, pointer_size) + && !is_max_address (end, pointer_size)) + { + base_address = end; + print_dwarf_vma (begin, pointer_size); + print_dwarf_vma (end, pointer_size); + printf ("(base address)\n"); + continue; + } + + print_dwarf_vma (begin + base_address, pointer_size); + print_dwarf_vma (end + base_address, pointer_size); + + if (begin == end) + fputs (_("(start == end)"), stdout); + else if (begin > end) + fputs (_("(start > end)"), stdout); + + putchar ('\n'); + } +} + +static void +display_debug_rnglists_list (unsigned char *start, unsigned char *finish, + unsigned int pointer_size, unsigned long offset, + unsigned long base_address) +{ + unsigned char *next = start; + + while (1) + { + unsigned long off = offset + (start - next); + enum dwarf_range_list_entry rlet; + dwarf_vma begin, length, end; + unsigned int bytes_read; + + if (start + 1 > finish) + { + warn (_("Range list starting at offset 0x%lx is not terminated.\n"), + offset); + break; + } + + printf (" %8.8lx ", off); + + SAFE_BYTE_GET_AND_INC (rlet, start, 1, finish); + + switch (rlet) + { + case DW_RLE_end_of_list: + printf (_("\n")); + break; + case DW_RLE_base_address: + SAFE_BYTE_GET_AND_INC (base_address, start, pointer_size, finish); + print_dwarf_vma (base_address, pointer_size); + printf (_("(base address)\n")); + break; + case DW_RLE_start_length: + SAFE_BYTE_GET_AND_INC (begin, start, pointer_size, finish); + length = read_uleb128 (start, &bytes_read, finish); + start += bytes_read; + end = begin + length; + break; + case DW_RLE_offset_pair: + begin = read_uleb128 (start, &bytes_read, finish); + start += bytes_read; + end = read_uleb128 (start, &bytes_read, finish); + start += bytes_read; + break; + case DW_RLE_start_end: + SAFE_BYTE_GET_AND_INC (begin, start, pointer_size, finish); + SAFE_BYTE_GET_AND_INC (end, start, pointer_size, finish); + break; + default: + error (_("Invalid range list entry type %d\n"), rlet); + rlet = DW_RLE_end_of_list; + break; + } + if (rlet == DW_RLE_end_of_list) + break; + if (rlet == DW_RLE_base_address) + continue; + + print_dwarf_vma (begin + base_address, pointer_size); + print_dwarf_vma (end + base_address, pointer_size); + + if (begin == end) + fputs (_("(start == end)"), stdout); + else if (begin > end) + fputs (_("(start > end)"), stdout); + + putchar ('\n'); + } +} + static int display_debug_ranges (struct dwarf_section *section, void *file ATTRIBUTE_UNUSED) @@ -5183,6 +5891,9 @@ display_debug_ranges (struct dwarf_section *section, unsigned char *finish = start + bytes; unsigned int num_range_list, i; struct range_entry *range_entries, *range_entry_fill; + int is_rnglists = strstr (section->name, "debug_rnglists") != NULL; + /* Initialize it due to a false compiler warning. */ + unsigned char address_size = 0; if (bytes == 0) { @@ -5190,6 +5901,78 @@ display_debug_ranges (struct dwarf_section *section, return 0; } + if (is_rnglists) + { + dwarf_vma initial_length; + unsigned int initial_length_size; + unsigned char segment_selector_size; + unsigned int offset_size, offset_entry_count; + unsigned short version; + + /* Get and check the length of the block. */ + SAFE_BYTE_GET_AND_INC (initial_length, start, 4, finish); + + if (initial_length == 0xffffffff) + { + /* This section is 64-bit DWARF 3. */ + SAFE_BYTE_GET_AND_INC (initial_length, start, 8, finish); + offset_size = 8; + initial_length_size = 12; + } + else + { + offset_size = 4; + initial_length_size = 4; + } + + if (initial_length + initial_length_size > section->size) + { + /* If the length field has a relocation against it, then we should + not complain if it is inaccurate (and probably negative). + It is copied from .debug_line handling code. */ + if (reloc_at (section, (start - section->start) - offset_size)) + { + initial_length = (finish - start) - initial_length_size; + } + else + { + warn (_("The length field (0x%lx) in the debug_rnglists header is wrong - the section is too small\n"), + (long) initial_length); + return 0; + } + } + + /* Get and check the version number. */ + SAFE_BYTE_GET_AND_INC (version, start, 2, finish); + + if (version != 5) + { + warn (_("Only DWARF version 5 debug_rnglists info " + "is currently supported.\n")); + return 0; + } + + SAFE_BYTE_GET_AND_INC (address_size, start, 1, finish); + + SAFE_BYTE_GET_AND_INC (segment_selector_size, start, 1, finish); + if (segment_selector_size != 0) + { + warn (_("The %s section contains " + "unsupported segment selector size: %d.\n"), + section->name, segment_selector_size); + return 0; + } + + SAFE_BYTE_GET_AND_INC (offset_entry_count, start, 4, finish); + if (offset_entry_count != 0) + { + warn (_("The %s section contains " + "unsupported offset entry count: %u.\n"), + section->name, offset_entry_count); + return 0; + } + } + if (load_debug_info (file) == 0) { warn (_("Unable to load/parse the .debug_info section, so cannot interpret the %s section.\n"), @@ -5245,7 +6028,7 @@ display_debug_ranges (struct dwarf_section *section, unsigned char *next; dwarf_vma base_address; - pointer_size = debug_info_p->pointer_size; + pointer_size = (is_rnglists ? address_size : debug_info_p->pointer_size); offset = range_entry->ranges_offset; next = section_begin + offset; base_address = debug_info_p->base_address; @@ -5276,45 +6059,8 @@ display_debug_ranges (struct dwarf_section *section, start = next; last_start = next; - while (start < finish) - { - dwarf_vma begin; - dwarf_vma end; - - SAFE_BYTE_GET_AND_INC (begin, start, pointer_size, finish); - if (start >= finish) - break; - SAFE_SIGNED_BYTE_GET_AND_INC (end, start, pointer_size, finish); - - printf (" %8.8lx ", (unsigned long) offset); - - if (begin == 0 && end == 0) - { - printf (_("\n")); - break; - } - - /* Check base address specifiers. */ - if (is_max_address (begin, pointer_size) - && !is_max_address (end, pointer_size)) - { - base_address = end; - print_dwarf_vma (begin, pointer_size); - print_dwarf_vma (end, pointer_size); - printf ("(base address)\n"); - continue; - } - - print_dwarf_vma (begin + base_address, pointer_size); - print_dwarf_vma (end + base_address, pointer_size); - - if (begin == end) - fputs (_("(start == end)"), stdout); - else if (begin > end) - fputs (_("(start > end)"), stdout); - - putchar ('\n'); - } + (is_rnglists ? display_debug_rnglists_list : display_debug_ranges_list) + (start, finish, pointer_size, offset, base_address); } putchar ('\n'); @@ -7731,14 +8477,20 @@ struct dwarf_section_display debug_displays[] = display_debug_macro, &do_debug_macinfo, TRUE }, { { ".debug_str", ".zdebug_str", NULL, NULL, 0, 0, 0, NULL, 0, NULL }, display_debug_str, &do_debug_str, FALSE }, + { { ".debug_line_str", ".zdebug_line_str", NULL, NULL, 0, 0, 0, NULL, 0, NULL }, + display_debug_str, &do_debug_str, FALSE }, { { ".debug_loc", ".zdebug_loc", NULL, NULL, 0, 0, 0, NULL, 0, NULL }, display_debug_loc, &do_debug_loc, TRUE }, + { { ".debug_loclists", ".zdebug_loclists", NULL, NULL, 0, 0, 0, NULL, 0, NULL }, + display_debug_loc, &do_debug_loc, TRUE }, { { ".debug_pubtypes", ".zdebug_pubtypes", NULL, NULL, 0, 0, 0, NULL, 0, NULL }, display_debug_pubnames, &do_debug_pubtypes, FALSE }, { { ".debug_gnu_pubtypes", ".zdebug_gnu_pubtypes", NULL, NULL, 0, 0, 0, NULL, 0, NULL }, display_debug_gnu_pubnames, &do_debug_pubtypes, FALSE }, { { ".debug_ranges", ".zdebug_ranges", NULL, NULL, 0, 0, 0, NULL, 0, NULL }, display_debug_ranges, &do_debug_ranges, TRUE }, + { { ".debug_rnglists", ".zdebug_rnglists", NULL, NULL, 0, 0, 0, NULL, 0, NULL }, + display_debug_ranges, &do_debug_ranges, TRUE }, { { ".debug_static_func", ".zdebug_static_func", NULL, NULL, 0, 0, 0, NULL, 0, NULL }, display_debug_not_supported, NULL, FALSE }, { { ".debug_static_vars", ".zdebug_static_vars", NULL, NULL, 0, 0, 0, NULL, 0, NULL }, diff --git a/binutils/dwarf.h b/binutils/dwarf.h index 30562beca0..cf9f3312a9 100644 --- a/binutils/dwarf.h +++ b/binutils/dwarf.h @@ -18,6 +18,8 @@ Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */ +#include "dwarf2.h" /* for enum dwarf_unit_type */ + typedef unsigned HOST_WIDEST_INT dwarf_vma; typedef HOST_WIDEST_INT dwarf_signed_vma; typedef unsigned HOST_WIDEST_INT dwarf_size_type; @@ -34,6 +36,7 @@ typedef struct int li_line_base; unsigned char li_line_range; unsigned char li_opcode_base; + unsigned int li_offset_size; } DWARF2_Internal_LineInfo; @@ -54,6 +57,7 @@ typedef struct unsigned short cu_version; dwarf_vma cu_abbrev_offset; unsigned char cu_pointer_size; + enum dwarf_unit_type cu_unit_type; } DWARF2_Internal_CompUnit; @@ -83,6 +87,7 @@ enum dwarf_section_display_enum macinfo, macro, str, + line_str, loc, pubtypes, gnu_pubtypes, diff --git a/binutils/readelf.c b/binutils/readelf.c index eca066b272..9caa4da824 100644 --- a/binutils/readelf.c +++ b/binutils/readelf.c @@ -5962,11 +5962,13 @@ process_section_headers (FILE * file) || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes")) || (do_debug_aranges && const_strneq (name, "aranges")) || (do_debug_ranges && const_strneq (name, "ranges")) + || (do_debug_ranges && const_strneq (name, "rnglists")) || (do_debug_frames && const_strneq (name, "frame")) || (do_debug_macinfo && const_strneq (name, "macinfo")) || (do_debug_macinfo && const_strneq (name, "macro")) || (do_debug_str && const_strneq (name, "str")) || (do_debug_loc && const_strneq (name, "loc")) + || (do_debug_loc && const_strneq (name, "loclists")) || (do_debug_addr && const_strneq (name, "addr")) || (do_debug_cu_index && const_strneq (name, "cu_index")) || (do_debug_cu_index && const_strneq (name, "tu_index"))