X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=binutils%2Fdwarf.c;h=5195f8d6b597821c0539fd8eb7d4448e6c33e114;hb=9785fc2a4d220322ce6cd1d79e768345ea5234d2;hp=9f1baea831227940575eb286f8a3c7f3466e0ca5;hpb=c4e0beacd71d4a65cfbe27466ae3d0403c39ead5;p=deliverable%2Fbinutils-gdb.git diff --git a/binutils/dwarf.c b/binutils/dwarf.c index 9f1baea831..5195f8d6b5 100644 --- a/binutils/dwarf.c +++ b/binutils/dwarf.c @@ -1,5 +1,5 @@ /* dwarf.c -- display DWARF contents of a BFD binary file - Copyright (C) 2005-2015 Free Software Foundation, Inc. + Copyright (C) 2005-2017 Free Software Foundation, Inc. This file is part of GNU Binutils. @@ -76,7 +76,6 @@ int dwarf_check = 0; as a zero-terminated list of section indexes comprising one set of debug sections from a .dwo file. */ -static int cu_tu_indexes_read = 0; static unsigned int *shndx_pool = NULL; static unsigned int shndx_pool_size = 0; static unsigned int shndx_pool_used = 0; @@ -99,7 +98,7 @@ static int tu_count = 0; static struct cu_tu_set *cu_sets = NULL; static struct cu_tu_set *tu_sets = NULL; -static void load_cu_tu_indexes (void *file); +static bfd_boolean load_cu_tu_indexes (void *); /* Values for do_debug_lines. */ #define FLAG_DEBUG_LINES_RAW 1 @@ -200,7 +199,7 @@ dwarf_vmatoa_1 (const char *fmtch, dwarf_vma value, unsigned num_bytes) if (num_bytes) { - /* Printf does not have a way of specifiying a maximum field width for an + /* Printf does not have a way of specifying a maximum field width for an integer value, so we print the full value into a buffer and then select the precision we need. */ snprintf (ret, sizeof (buf[0].place), DWARF_VMA_FMT_LONG, value); @@ -314,11 +313,45 @@ read_uleb128 (unsigned char * data, return read_leb128 (data, length_return, FALSE, end); } +#define SKIP_ULEB() read_uleb128 (start, & length_return, end); start += length_return +#define SKIP_SLEB() read_sleb128 (start, & length_return, end); start += length_return + +#define READ_ULEB(var) \ + do \ + { \ + dwarf_vma _val; \ + \ + (var) = _val = read_uleb128 (start, &length_return, end); \ + if ((var) != _val) \ + error (_("Internal error: %s%d: LEB value (%#" DWARF_VMA_FMT "x) too large for containing variable\n"), \ + __FILE__, __LINE__, _val); \ + start += length_return; \ + } \ + while (0) + +#define READ_SLEB(var) \ + do \ + { \ + dwarf_signed_vma _val; \ + \ + (var) = _val = read_sleb128 (start, &length_return, end); \ + if ((var) != _val) \ + error (_("Internal error: %s%d: LEB value (%#" DWARF_VMA_FMT "x) too large for containing variable\n"), \ + __FILE__, __LINE__, _val); \ + start += length_return; \ + } \ + while (0) + #define SAFE_BYTE_GET(VAL, PTR, AMOUNT, END) \ do \ { \ - int dummy [sizeof (VAL) < (AMOUNT) ? -1 : 1] ATTRIBUTE_UNUSED ; \ unsigned int amount = (AMOUNT); \ + if (sizeof (VAL) < amount) \ + { \ + error (_("internal error: attempt to read %d bytes of data in to %d sized variable"),\ + amount, (int) sizeof (VAL)); \ + amount = sizeof (VAL); \ + } \ if (((PTR) + amount) >= (END)) \ { \ if ((PTR) < (END)) \ @@ -468,15 +501,20 @@ process_extended_line_op (unsigned char * data, 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\n", name); + { + size_t l; + + name = data; + l = strnlen ((char *) data, end - data); + data += len + 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\n", (int) l, name); + } if (((unsigned int) (data - orig_data) != len) || data == end) warn (_("DW_LNE_define_file: Bad opcode length\n")); @@ -593,18 +631,56 @@ static const unsigned char * fetch_indirect_string (dwarf_vma offset) { struct dwarf_section *section = &debug_displays [str].section; + const unsigned char * ret; if (section->start == NULL) return (const unsigned char *) _(""); - if (offset > section->size) + if (offset >= section->size) { warn (_("DW_FORM_strp offset too big: %s\n"), dwarf_vmatoa ("x", offset)); return (const unsigned char *) _(""); } - return (const unsigned char *) section->start + offset; + ret = section->start + offset; + /* Unfortunately we cannot rely upon the .debug_str section ending with a + NUL byte. Since our caller is expecting to receive a well formed C + string we test for the lack of a terminating byte here. */ + if (strnlen ((const char *) ret, section->size - offset) + == section->size - offset) + ret = (const unsigned char *) + _(""); + + return ret; +} + +static const unsigned char * +fetch_indirect_line_string (dwarf_vma offset) +{ + struct dwarf_section *section = &debug_displays [line_str].section; + const unsigned char * ret; + + 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 *) _(""); + } + + ret = section->start + offset; + /* Unfortunately we cannot rely upon the .debug_line_str section ending + with a NUL byte. Since our caller is expecting to receive a well formed + C string we test for the lack of a terminating byte here. */ + if (strnlen ((const char *) ret, section->size - offset) + == section->size - offset) + ret = (const unsigned char *) + _(""); + + return ret; } static const char * @@ -617,6 +693,7 @@ fetch_indexed_string (dwarf_vma idx, struct cu_tu_set *this_set, struct dwarf_section *str_section = &debug_displays [str_sec_idx].section; dwarf_vma index_offset = idx * offset_size; dwarf_vma str_offset; + const char * ret; if (index_section->start == NULL) return (dwo ? _("") @@ -624,7 +701,7 @@ fetch_indexed_string (dwarf_vma idx, struct cu_tu_set *this_set, if (this_set != NULL) index_offset += this_set->section_offsets [DW_SECT_STR_OFFSETS]; - if (index_offset > index_section->size) + if (index_offset >= index_section->size) { warn (_("DW_FORM_GNU_str_index offset too big: %s\n"), dwarf_vmatoa ("x", index_offset)); @@ -637,14 +714,22 @@ fetch_indexed_string (dwarf_vma idx, struct cu_tu_set *this_set, str_offset = byte_get (index_section->start + index_offset, offset_size); str_offset -= str_section->address; - if (str_offset > str_section->size) + if (str_offset >= str_section->size) { warn (_("DW_FORM_GNU_str_index indirect offset too big: %s\n"), dwarf_vmatoa ("x", str_offset)); return _(""); } - return (const char *) str_section->start + str_offset; + ret = (const char *) str_section->start + str_offset; + /* Unfortunately we cannot rely upon str_section ending with a NUL byte. + Since our caller is expecting to receive a well formed C string we test + for the lack of a terminating byte here. */ + if (strnlen (ret, str_section->size - str_offset) + == str_section->size - str_offset) + ret = (const char *) _(""); + + return ret; } static const char * @@ -673,6 +758,7 @@ typedef struct abbrev_attr { unsigned long attribute; unsigned long form; + bfd_signed_vma implicit_const; struct abbrev_attr *next; } abbrev_attr; @@ -742,7 +828,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; @@ -753,6 +840,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) @@ -805,6 +893,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; @@ -816,7 +906,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); } @@ -866,11 +964,11 @@ get_FORM_name (unsigned long form) static unsigned char * display_block (unsigned char *data, dwarf_vma length, - const unsigned char * const end) + const unsigned char * const end, char delimiter) { dwarf_vma maxlen; - printf (_(" %s byte block: "), dwarf_vmatoa ("u", length)); + printf (_("%c%s byte block: "), delimiter, dwarf_vmatoa ("u", length)); if (data > end) return (unsigned char *) end; @@ -1263,7 +1361,7 @@ decode_location_expression (unsigned char * data, printf ("DW_OP_implicit_value"); uvalue = read_uleb128 (data, &bytes_read, end); data += bytes_read; - data = display_block (data, uvalue, end); + data = display_block (data, uvalue, end, ' '); break; /* GNU extensions. */ @@ -1287,12 +1385,16 @@ decode_location_expression (unsigned char * data, print_dwarf_vma (addr, pointer_size); } break; + case DW_OP_implicit_pointer: case DW_OP_GNU_implicit_pointer: /* XXX: Strictly speaking for 64-bit DWARF3 files this ought to be an 8-byte wide computation. */ if (dwarf_version == -1) { - printf (_("(DW_OP_GNU_implicit_pointer in frame info)")); + printf (_("(%s in frame info)"), + (op == DW_OP_implicit_pointer + ? "DW_OP_implicit_pointer" + : "DW_OP_GNU_implicit_pointer")); /* No way to tell where the next op is, so just bail. */ return need_frame_base; } @@ -1304,19 +1406,23 @@ decode_location_expression (unsigned char * data, { SAFE_BYTE_GET_AND_INC (uvalue, data, offset_size, end); } - printf ("DW_OP_GNU_implicit_pointer: <0x%s> %s", + printf ("%s: <0x%s> %s", + (op == DW_OP_implicit_pointer + ? "DW_OP_implicit_pointer" : "DW_OP_GNU_implicit_pointer"), dwarf_vmatoa ("x", uvalue), dwarf_vmatoa ("d", read_sleb128 (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)) @@ -1326,40 +1432,55 @@ decode_location_expression (unsigned char * data, if (data > end) data = end; break; + case DW_OP_const_type: case DW_OP_GNU_const_type: uvalue = read_uleb128 (data, &bytes_read, end); data += bytes_read; - printf ("DW_OP_GNU_const_type: <0x%s> ", + printf ("%s: <0x%s> ", + (op == DW_OP_const_type ? "DW_OP_const_type" + : "DW_OP_GNU_const_type"), dwarf_vmatoa ("x", cu_offset + uvalue)); SAFE_BYTE_GET_AND_INC (uvalue, data, 1, end); - data = display_block (data, uvalue, end); + data = display_block (data, uvalue, end, ' '); break; + case DW_OP_regval_type: case DW_OP_GNU_regval_type: uvalue = read_uleb128 (data, &bytes_read, end); data += bytes_read; - printf ("DW_OP_GNU_regval_type: %s (%s)", + printf ("%s: %s (%s)", + (op == DW_OP_regval_type ? "DW_OP_regval_type" + : "DW_OP_GNU_regval_type"), dwarf_vmatoa ("u", uvalue), regname (uvalue, 1)); uvalue = read_uleb128 (data, &bytes_read, end); data += bytes_read; printf (" <0x%s>", dwarf_vmatoa ("x", cu_offset + uvalue)); break; + case DW_OP_deref_type: case DW_OP_GNU_deref_type: SAFE_BYTE_GET_AND_INC (uvalue, data, 1, end); - printf ("DW_OP_GNU_deref_type: %ld", (long) uvalue); + printf ("%s: %ld", + (op == DW_OP_deref_type ? "DW_OP_deref_type" + : "DW_OP_GNU_deref_type"), + (long) uvalue); uvalue = read_uleb128 (data, &bytes_read, end); data += bytes_read; printf (" <0x%s>", dwarf_vmatoa ("x", cu_offset + uvalue)); break; + case DW_OP_convert: case DW_OP_GNU_convert: uvalue = read_uleb128 (data, &bytes_read, end); data += bytes_read; - printf ("DW_OP_GNU_convert <0x%s>", + printf ("%s <0x%s>", + (op == DW_OP_convert ? "DW_OP_convert" : "DW_OP_GNU_convert"), dwarf_vmatoa ("x", uvalue ? cu_offset + uvalue : 0)); break; + case DW_OP_reinterpret: case DW_OP_GNU_reinterpret: uvalue = read_uleb128 (data, &bytes_read, end); data += bytes_read; - printf ("DW_OP_GNU_reinterpret <0x%s>", + printf ("%s <0x%s>", + (op == DW_OP_reinterpret ? "DW_OP_reinterpret" + : "DW_OP_GNU_reinterpret"), dwarf_vmatoa ("x", uvalue ? cu_offset + uvalue : 0)); break; case DW_OP_GNU_parameter_ref: @@ -1416,9 +1537,9 @@ decode_location_expression (unsigned char * data, default: if (op >= DW_OP_lo_user && op <= DW_OP_hi_user) - printf (_("(User defined location op)")); + printf (_("(User defined location op 0x%x)"), op); else - printf (_("(Unknown location op)")); + printf (_("(Unknown location op 0x%x)"), op); /* No way to tell where the next op is, so just bail. */ return need_frame_base; } @@ -1494,6 +1615,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, @@ -1503,7 +1625,7 @@ read_and_display_attr_value (unsigned long attribute, debug_info * debug_info_p, int do_loc, struct dwarf_section * section, - struct cu_tu_set * this_set) + struct cu_tu_set * this_set, char delimiter) { dwarf_vma uvalue = 0; unsigned char *block_start = NULL; @@ -1536,6 +1658,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: @@ -1582,12 +1705,17 @@ read_and_display_attr_value (unsigned long attribute, form = read_uleb128 (data, & bytes_read, end); data += bytes_read; if (!do_loc) - printf (" %s", get_FORM_name (form)); - return read_and_display_attr_value (attribute, form, data, end, - cu_offset, pointer_size, + printf ("%c%s", delimiter, get_FORM_name (form)); + 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); + section, this_set, delimiter); case DW_FORM_GNU_addr_index: uvalue = read_uleb128 (data, & bytes_read, end); data += bytes_read; @@ -1598,12 +1726,12 @@ read_and_display_attr_value (unsigned long attribute, { case DW_FORM_ref_addr: if (!do_loc) - printf (" <0x%s>", dwarf_vmatoa ("x",uvalue)); + printf ("%c<0x%s>", delimiter, dwarf_vmatoa ("x",uvalue)); break; case DW_FORM_GNU_ref_alt: if (!do_loc) - printf (" ", dwarf_vmatoa ("x",uvalue)); + printf ("%c", delimiter, dwarf_vmatoa ("x",uvalue)); break; case DW_FORM_ref1: @@ -1611,14 +1739,14 @@ read_and_display_attr_value (unsigned long attribute, case DW_FORM_ref4: case DW_FORM_ref_udata: if (!do_loc) - printf (" <0x%s>", dwarf_vmatoa ("x", uvalue + cu_offset)); + printf ("%c<0x%s>", delimiter, dwarf_vmatoa ("x", uvalue + cu_offset)); break; case DW_FORM_data4: case DW_FORM_addr: case DW_FORM_sec_offset: if (!do_loc) - printf (" 0x%s", dwarf_vmatoa ("x", uvalue)); + printf ("%c0x%s", delimiter, dwarf_vmatoa ("x", uvalue)); break; case DW_FORM_flag_present: @@ -1628,7 +1756,12 @@ read_and_display_attr_value (unsigned long attribute, case DW_FORM_sdata: case DW_FORM_udata: if (!do_loc) - printf (" %s", dwarf_vmatoa ("d", uvalue)); + 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: @@ -1643,7 +1776,7 @@ read_and_display_attr_value (unsigned long attribute, utmp = uvalue; if (form == DW_FORM_ref8) add64 (& high_bits, & utmp, cu_offset); - printf (" 0x%s", + printf ("%c0x%s", delimiter, dwarf_vmatoa64 (high_bits, utmp, buf, sizeof (buf))); } @@ -1659,9 +1792,35 @@ read_and_display_attr_value (unsigned long attribute, data += 8; break; + case DW_FORM_data16: + if (!do_loc) + { + dwarf_vma left_high_bits, left_low_bits; + dwarf_vma right_high_bits, right_low_bits; + + SAFE_BYTE_GET64 (data, &left_high_bits, &left_low_bits, end); + SAFE_BYTE_GET64 (data + 8, &right_high_bits, &right_low_bits, end); + if (byte_get == byte_get_little_endian) + { + /* Swap them. */ + left_high_bits ^= right_high_bits; + right_high_bits ^= left_high_bits; + left_high_bits ^= right_high_bits; + left_low_bits ^= right_low_bits; + right_low_bits ^= left_low_bits; + left_low_bits ^= right_low_bits; + } + printf (" 0x%08" DWARF_VMA_FMT "x%08" DWARF_VMA_FMT "x" + "%08" DWARF_VMA_FMT "x%08" DWARF_VMA_FMT "x", + left_high_bits, left_low_bits, right_high_bits, + right_low_bits); + } + data += 16; + break; + case DW_FORM_string: if (!do_loc) - printf (" %.*s", (int) (end - data), data); + printf ("%c%.*s", delimiter, (int) (end - data), data); data += strnlen ((char *) data, end - data) + 1; break; @@ -1688,7 +1847,7 @@ read_and_display_attr_value (unsigned long attribute, if (do_loc) data = block_start + uvalue; else - data = display_block (block_start, uvalue, end); + data = display_block (block_start, uvalue, end, delimiter); break; case DW_FORM_block1: @@ -1709,7 +1868,7 @@ read_and_display_attr_value (unsigned long attribute, if (do_loc) data = block_start + uvalue; else - data = display_block (block_start, uvalue, end); + data = display_block (block_start, uvalue, end, delimiter); break; case DW_FORM_block2: @@ -1730,7 +1889,7 @@ read_and_display_attr_value (unsigned long attribute, if (do_loc) data = block_start + uvalue; else - data = display_block (block_start, uvalue, end); + data = display_block (block_start, uvalue, end, delimiter); break; case DW_FORM_block4: @@ -1754,23 +1913,30 @@ read_and_display_attr_value (unsigned long attribute, if (do_loc) data = block_start + uvalue; else - data = display_block (block_start, uvalue, end); + data = display_block (block_start, uvalue, end, delimiter); break; case DW_FORM_strp: if (!do_loc) - printf (_(" (indirect string, offset: 0x%s): %s"), + printf (_("%c(indirect string, offset: 0x%s): %s"), delimiter, dwarf_vmatoa ("x", uvalue), 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) { const char *suffix = strrchr (section->name, '.'); int dwo = (suffix && strcmp (suffix, ".dwo") == 0) ? 1 : 0; - printf (_(" (indexed string: 0x%s): %s"), + printf (_("%c(indexed string: 0x%s): %s"), delimiter, dwarf_vmatoa ("x", uvalue), fetch_indexed_string (uvalue, this_set, offset_size, dwo)); } @@ -1778,7 +1944,7 @@ read_and_display_attr_value (unsigned long attribute, case DW_FORM_GNU_strp_alt: if (!do_loc) - printf (_(" (alt indirect string, offset: 0x%s)"), + printf (_("%c(alt indirect string, offset: 0x%s)"), delimiter, dwarf_vmatoa ("x", uvalue)); break; @@ -1793,7 +1959,7 @@ read_and_display_attr_value (unsigned long attribute, char buf[64]; SAFE_BYTE_GET64 (data, &high_bits, &uvalue, end); - printf (" signature: 0x%s", + printf ("%csignature: 0x%s", delimiter, dwarf_vmatoa64 (high_bits, uvalue, buf, sizeof (buf))); } data += 8; @@ -1801,7 +1967,7 @@ read_and_display_attr_value (unsigned long attribute, case DW_FORM_GNU_addr_index: if (!do_loc) - printf (_(" (addr_index: 0x%s): %s"), + printf (_("%c(addr_index: 0x%s): %s"), delimiter, dwarf_vmatoa ("x", uvalue), fetch_indexed_value (uvalue * pointer_size, pointer_size)); break; @@ -1819,6 +1985,7 @@ read_and_display_attr_value (unsigned long attribute, { case DW_AT_frame_base: have_frame_base = 1; + /* Fall through. */ case DW_AT_location: case DW_AT_string_length: case DW_AT_return_addr: @@ -1827,9 +1994,13 @@ read_and_display_attr_value (unsigned long attribute, case DW_AT_segment: case DW_AT_static_link: case DW_AT_use_location: + case DW_AT_call_value: case DW_AT_GNU_call_site_value: + case DW_AT_call_data_value: case DW_AT_GNU_call_site_data_value: + case DW_AT_call_target: case DW_AT_GNU_call_site_target: + case DW_AT_call_target_clobbered: case DW_AT_GNU_call_site_target_clobbered: if ((dwarf_version < 4 && (form == DW_FORM_data4 || form == DW_FORM_data8)) @@ -2094,6 +2265,7 @@ read_and_display_attr_value (unsigned long attribute, case DW_AT_frame_base: have_frame_base = 1; + /* Fall through. */ case DW_AT_location: case DW_AT_string_length: case DW_AT_return_addr: @@ -2102,9 +2274,13 @@ read_and_display_attr_value (unsigned long attribute, case DW_AT_segment: case DW_AT_static_link: case DW_AT_use_location: + case DW_AT_call_value: case DW_AT_GNU_call_site_value: + case DW_AT_call_data_value: case DW_AT_GNU_call_site_data_value: + case DW_AT_call_target: case DW_AT_GNU_call_site_target: + case DW_AT_call_target_clobbered: case DW_AT_GNU_call_site_target_clobbered: if ((dwarf_version < 4 && (form == DW_FORM_data4 || form == DW_FORM_data8)) @@ -2210,6 +2386,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, @@ -2223,10 +2400,10 @@ 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); + do_loc, section, this_set, ' '); if (!do_loc) printf ("\n"); return data; @@ -2322,6 +2499,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); @@ -2374,6 +2552,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) @@ -2387,7 +2579,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) { @@ -2486,9 +2680,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"), @@ -2496,6 +2688,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. */ @@ -2649,6 +2850,7 @@ process_debug_info (struct dwarf_section *section, tags = read_and_display_attr (attr->attribute, attr->form, + attr->implicit_const, tags, end, cu_offset, @@ -2708,7 +2910,7 @@ load_debug_info (void * file) return num_debug_info_entries; /* If this is a DWARF package file, load the CU and TU indexes. */ - load_cu_tu_indexes (file); + (void) load_cu_tu_indexes (file); if (load_debug_section (info, file) && process_debug_info (&debug_displays [info].section, file, abbrev, 1, 0)) @@ -2736,8 +2938,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). */ @@ -2750,12 +2952,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; } @@ -2767,7 +2969,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; } @@ -2784,13 +2986,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) @@ -2824,10 +3043,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; @@ -2840,7 +3175,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.") @@ -2916,67 +3250,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")); - else + if (linfo.li_version >= 5) { - printf (_("\n The Directory Table (offset 0x%lx):\n"), - (long)(data - start)); + load_debug_section (line_str, file); - while (data < end && *data != 0) + data = display_formatted_table (data, start, end, &linfo, section, + _("Directory")); + data = display_formatted_table (data, start, end, &linfo, section, + _("File name")); + } + else + { + if (*data == 0) + printf (_("\n The Directory Table is empty.\n")); + else { - printf (" %d\t%.*s\n", ++last_dir_entry, (int) (end - data), data); - - data += strnlen ((char *) data, end - data) + 1; - } + unsigned int last_dir_entry = 0; - /* PR 17512: file: 002-132094-0.004. */ - if (data >= end - 1) - break; - } + printf (_("\n The Directory Table (offset 0x%lx):\n"), + (long)(data - start)); - /* Skip the NUL at the end of the table. */ - data++; + while (data < end && *data != 0) + { + printf (" %d\t%.*s\n", ++last_dir_entry, (int) (end - data), 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")); + data += strnlen ((char *) data, end - data) + 1; + } - while (data < end && *data != 0) - { - unsigned char *name; - unsigned int bytes_read; + /* PR 17512: file: 002-132094-0.004. */ + if (data >= end - 1) + break; + } - printf (" %d\t", ++state_machine_regs.last_file_entry); - name = data; - data += strnlen ((char *) data, end - data) + 1; + /* Skip the NUL at the end of the table. */ + data++; - 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); + /* 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")); - 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; } @@ -3190,7 +3539,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; @@ -3207,7 +3556,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. @@ -3247,102 +3596,311 @@ display_debug_lines_decoded (struct dwarf_section *section, /* Traverse the Directory table just to count entries. */ data = standard_opcodes + linfo.li_opcode_base - 1; - if (*data != 0) + /* PR 20440 */ + if (data >= end) + { + warn (_("opcode base of %d extends beyond end of section\n"), + linfo.li_opcode_base); + return 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 != 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++) + { + read_uleb128 (data, & bytes_read, end); + data += bytes_read; + read_uleb128 (data, & bytes_read, end); + data += bytes_read; + } + + n_directories = read_uleb128 (data, & bytes_read, end); + data += bytes_read; + if (data == end) { - data += strnlen ((char *) data, end - data) + 1; - n_directories++; + 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 != 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; + + 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; + } + } - while (*data != 0) + /* Skip files format. */ + SAFE_BYTE_GET_AND_INC (format_count, data, 1, end); + format_start = data; + for (formati = 0; formati < format_count; formati++) { - 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++; + 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_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; + File_Entry *file = &file_table[entryi]; - /* Print the Compilation Unit's name and a header. */ - if (directory_table == NULL) + format = format_start; + for (formati = 0; formati < format_count; formati++) + { + 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 + { + if (*data != 0) { - printf (_("CU: %s:\n"), file_table[0].name); - printf (_("File name Line number Starting address\n")); + unsigned char *ptr_directory_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++; + } } - else + /* 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 int ix = file_table[0].directory_index; - const char *directory = ix ? (char *)directory_table[ix - 1] : "."; + unsigned char *ptr_file_name_table = data; - if (do_wide || strlen (directory) < 76) - printf (_("CU: %s/%s:\n"), directory, file_table[0].name); - else - printf ("%s:\n", file_table[0].name); + 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; + } - printf (_("File name Line number Starting address\n")); + /* 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++; } - /* Skip the NUL at the end of the table. */ - data++; + /* Print the Compilation Unit's name and a header. */ + if (file_table == NULL) + ; + else if (directory_table == NULL) + printf (_("CU: %s:\n"), file_table[0].name); + 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; } @@ -3487,20 +4045,36 @@ display_debug_lines_decoded (struct dwarf_section *section, data += bytes_read; state_machine_regs.file = adv; - if (file_table == NULL) - printf (_("\n [Use file table entry %d]\n"), state_machine_regs.file - 1); - else if (file_table[state_machine_regs.file - 1].directory_index == 0) - /* If directory index is 0, that means current directory. */ - printf ("\n./%s:[++]\n", - file_table[state_machine_regs.file - 1].name); - else if (directory_table == NULL) - printf (_("\n [Use directory table entry %d]\n"), - file_table[state_machine_regs.file - 1].directory_index - 1); - else - /* The directory index starts counting at 1. */ - printf ("\n%s/%s:\n", - directory_table[file_table[state_machine_regs.file - 1].directory_index - 1], - file_table[state_machine_regs.file - 1].name); + { + unsigned file = state_machine_regs.file - 1; + unsigned dir; + + if (file_table == NULL || n_files == 0) + printf (_("\n [Use file table entry %d]\n"), file); + /* PR 20439 */ + else if (file >= n_files) + { + warn (_("file index %u > number of files %u\n"), file + 1, n_files); + printf (_("\n "), file); + } + else if ((dir = file_table[file].directory_index) == 0) + /* If directory index is 0, that means current directory. */ + printf ("\n./%s:[++]\n", file_table[file].name); + else if (directory_table == NULL || n_directories == 0) + printf (_("\n [Use file %s in directory table entry %d]\n"), + file_table[file].name, dir); + /* PR 20439 */ + else if (dir > n_directories) + { + warn (_("directory index %u > number of directories %s\n"), + dir, dwarf_vmatoa ("u", n_directories)); + printf (_("\n \n"), dir); + } + else + printf ("\n%s/%s:\n", + /* The directory index starts counting at 1. */ + directory_table[dir - 1], file_table[file].name); + } break; case DW_LNS_set_column: @@ -3582,9 +4156,19 @@ display_debug_lines_decoded (struct dwarf_section *section, size_t fileNameLength; if (file_table) - fileName = (char *) file_table[state_machine_regs.file - 1].name; + { + unsigned indx = state_machine_regs.file - 1; + /* PR 20439 */ + if (indx >= n_files) + { + warn (_("corrupt file index %u encountered\n"), indx); + fileName = _(""); + } + else + fileName = (char *) file_table[indx].name; + } else - fileName = ""; + fileName = _(""); fileNameLength = strlen (fileName); @@ -3655,7 +4239,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; @@ -3666,10 +4250,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; @@ -4046,9 +4630,9 @@ display_debug_macro (struct dwarf_section *section, unsigned char **extended_ops = NULL; SAFE_BYTE_GET_AND_INC (version, curr, 2, end); - if (version != 4) + if (version != 4 && version != 5) { - error (_("Only GNU extension to DWARF 4 of %s is currently supported.\n"), + error (_("Only GNU extension to DWARF 4 or 5 of %s is currently supported.\n"), section->name); return 0; } @@ -4085,10 +4669,10 @@ display_debug_macro (struct dwarf_section *section, nargs = read_uleb128 (curr, &bytes_read, end); curr += bytes_read; if (nargs == 0) - printf (_(" DW_MACRO_GNU_%02x has no arguments\n"), op); + printf (_(" DW_MACRO_%02x has no arguments\n"), op); else { - printf (_(" DW_MACRO_GNU_%02x arguments: "), op); + printf (_(" DW_MACRO_%02x arguments: "), op); for (n = 0; n < nargs; n++) { unsigned int form; @@ -4141,7 +4725,7 @@ display_debug_macro (struct dwarf_section *section, switch (op) { - case DW_MACRO_GNU_start_file: + case DW_MACRO_start_file: { unsigned int filenum; unsigned char *file_name = NULL, *dir_name = NULL; @@ -4152,87 +4736,87 @@ display_debug_macro (struct dwarf_section *section, curr += bytes_read; if ((flags & 2) == 0) - error (_("DW_MACRO_GNU_start_file used, but no .debug_line offset provided.\n")); + error (_("DW_MACRO_start_file used, but no .debug_line offset provided.\n")); else file_name = get_line_filename_and_dirname (line_offset, filenum, &dir_name); if (file_name == NULL) - printf (_(" DW_MACRO_GNU_start_file - lineno: %d filenum: %d\n"), + printf (_(" DW_MACRO_start_file - lineno: %d filenum: %d\n"), lineno, filenum); else - printf (_(" DW_MACRO_GNU_start_file - lineno: %d filenum: %d filename: %s%s%s\n"), + printf (_(" DW_MACRO_start_file - lineno: %d filenum: %d filename: %s%s%s\n"), lineno, filenum, dir_name != NULL ? (const char *) dir_name : "", dir_name != NULL ? "/" : "", file_name); } break; - case DW_MACRO_GNU_end_file: - printf (_(" DW_MACRO_GNU_end_file\n")); + case DW_MACRO_end_file: + printf (_(" DW_MACRO_end_file\n")); break; - case DW_MACRO_GNU_define: + case DW_MACRO_define: lineno = read_uleb128 (curr, &bytes_read, end); curr += bytes_read; string = curr; curr += strnlen ((char *) string, end - string) + 1; - printf (_(" DW_MACRO_GNU_define - lineno : %d macro : %s\n"), + printf (_(" DW_MACRO_define - lineno : %d macro : %s\n"), lineno, string); break; - case DW_MACRO_GNU_undef: + case DW_MACRO_undef: lineno = read_uleb128 (curr, &bytes_read, end); curr += bytes_read; string = curr; curr += strnlen ((char *) string, end - string) + 1; - printf (_(" DW_MACRO_GNU_undef - lineno : %d macro : %s\n"), + printf (_(" DW_MACRO_undef - lineno : %d macro : %s\n"), lineno, string); break; - case DW_MACRO_GNU_define_indirect: + case DW_MACRO_define_strp: lineno = read_uleb128 (curr, &bytes_read, end); curr += bytes_read; SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end); string = fetch_indirect_string (offset); - printf (_(" DW_MACRO_GNU_define_indirect - lineno : %d macro : %s\n"), + printf (_(" DW_MACRO_define_strp - lineno : %d macro : %s\n"), lineno, string); break; - case DW_MACRO_GNU_undef_indirect: + case DW_MACRO_undef_strp: lineno = read_uleb128 (curr, &bytes_read, end); curr += bytes_read; SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end); string = fetch_indirect_string (offset); - printf (_(" DW_MACRO_GNU_undef_indirect - lineno : %d macro : %s\n"), + printf (_(" DW_MACRO_undef_strp - lineno : %d macro : %s\n"), lineno, string); break; - case DW_MACRO_GNU_transparent_include: + case DW_MACRO_import: SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end); - printf (_(" DW_MACRO_GNU_transparent_include - offset : 0x%lx\n"), + printf (_(" DW_MACRO_import - offset : 0x%lx\n"), (unsigned long) offset); break; - case DW_MACRO_GNU_define_indirect_alt: + case DW_MACRO_define_sup: lineno = read_uleb128 (curr, &bytes_read, end); curr += bytes_read; SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end); - printf (_(" DW_MACRO_GNU_define_indirect_alt - lineno : %d macro offset : 0x%lx\n"), + printf (_(" DW_MACRO_define_sup - lineno : %d macro offset : 0x%lx\n"), lineno, (unsigned long) offset); break; - case DW_MACRO_GNU_undef_indirect_alt: + case DW_MACRO_undef_sup: lineno = read_uleb128 (curr, &bytes_read, end); curr += bytes_read; SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end); - printf (_(" DW_MACRO_GNU_undef_indirect_alt - lineno : %d macro offset : 0x%lx\n"), + printf (_(" DW_MACRO_undef_sup - lineno : %d macro offset : 0x%lx\n"), lineno, (unsigned long) offset); break; - case DW_MACRO_GNU_transparent_include_alt: + case DW_MACRO_import_sup: SAFE_BYTE_GET_AND_INC (offset, curr, offset_size, end); - printf (_(" DW_MACRO_GNU_transparent_include_alt - offset : 0x%lx\n"), + printf (_(" DW_MACRO_import_sup - offset : 0x%lx\n"), (unsigned long) offset); break; @@ -4251,20 +4835,21 @@ display_debug_macro (struct dwarf_section *section, desc += bytes_read; if (nargs == 0) { - printf (_(" DW_MACRO_GNU_%02x\n"), op); + printf (_(" DW_MACRO_%02x\n"), op); break; } - printf (_(" DW_MACRO_GNU_%02x -"), op); + printf (_(" DW_MACRO_%02x -"), op); for (n = 0; n < nargs; n++) { 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); + NULL, ' '); if (n != nargs - 1) printf (","); } @@ -4314,9 +4899,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); @@ -4326,14 +4916,24 @@ display_debug_abbrev (struct dwarf_section *section, return 1; } +/* Return true when ADDR is the maximum address, when addresses are + POINTER_SIZE bytes long. */ + +static bfd_boolean +is_max_address (dwarf_vma addr, unsigned int pointer_size) +{ + dwarf_vma mask = ~(~(dwarf_vma) 1 << (pointer_size * 8 - 1)); + return ((addr & mask) == mask); +} + /* Display a location list from a normal (ie, non-dwo) .debug_loc section. */ static void display_loc_list (struct dwarf_section *section, unsigned char **start_ptr, unsigned int debug_info_entry, - unsigned long offset, - unsigned long base_address, + dwarf_vma offset, + dwarf_vma base_address, int has_frame_base) { unsigned char *start = *start_ptr; @@ -4343,14 +4943,145 @@ display_loc_list (struct dwarf_section *section, unsigned int offset_size; int dwarf_version; - dwarf_vma begin; - dwarf_vma end; - unsigned short length; + dwarf_vma begin; + dwarf_vma end; + unsigned short length; + int need_frame_base; + + if (debug_info_entry >= num_debug_info_entries) + { + warn (_("No debug information available for loc 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); + + if (start + 2 * pointer_size > 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 (begin, start, pointer_size, section_end); + SAFE_BYTE_GET_AND_INC (end, start, pointer_size, section_end); + + if (begin == 0 && end == 0) + { + /* PR 18374: In a object file we can have a location list that + starts with a begin and end of 0 because there are relocations + that need to be applied to the addresses. Actually applying + the relocations now does not help as they will probably resolve + to 0, since the object file has not been fully linked. Real + end of list markers will not have any relocations against them. */ + if (! reloc_at (section, off) + && ! reloc_at (section, off + pointer_size)) + { + 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; + } + + if (start + 2 > section_end) + { + warn (_("Location list starting at offset 0x%lx is not terminated.\n"), + (unsigned long) offset); + break; + } + + SAFE_BYTE_GET_AND_INC (length, start, 2, section_end); + + if (start + length > section_end) + { + warn (_("Location list starting at offset 0x%lx is not terminated.\n"), + (unsigned long) offset); + break; + } + + 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; +} + +/* 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; + + /* Initialize it due to a false compiler warning. */ + dwarf_vma begin = -1; + dwarf_vma end = -1; + dwarf_vma length; int need_frame_base; if (debug_info_entry >= num_debug_info_entries) { - warn (_("No debug information available for loc lists of entry: %u\n"), + warn (_("No debug information available for " + "loclists lists of entry: %u\n"), debug_info_entry); return; } @@ -4369,65 +5100,55 @@ display_loc_list (struct dwarf_section *section, while (1) { - unsigned long off = offset + (start - *start_ptr); + dwarf_vma off = offset + (start - *start_ptr); + enum dwarf_location_list_entry_type llet; - if (start + 2 * pointer_size > section_end) + if (start + 1 > section_end) { warn (_("Location list starting at offset 0x%lx is not terminated.\n"), - offset); + (unsigned long) offset); break; } - printf (" %8.8lx ", off); - - /* Note: we use sign extension here in order to be sure that we can detect - the -1 escape value. Sign extension into the top 32 bits of a 32-bit - address will not affect the values that we display since we always show - hex values, and always the bottom 32-bits. */ - SAFE_BYTE_GET_AND_INC (begin, start, pointer_size, section_end); - SAFE_BYTE_GET_AND_INC (end, start, pointer_size, section_end); + printf (" %8.8lx ", (unsigned long) off); - if (begin == 0 && end == 0) - { - /* PR 18374: In a object file we can have a location list that - starts with a begin and end of 0 because there are relocations - that need to be applied to the addresses. Actually applying - the relocations now does not help as they will probably resolve - to 0, since the object file has not been fully linked. Real - end of list markers will not have any relocations against them. */ - if (! reloc_at (section, off) - && ! reloc_at (section, off + pointer_size)) - { - printf (_("\n")); - break; - } - } + SAFE_BYTE_GET_AND_INC (llet, start, 1, section_end); - /* Check base address specifiers. */ - if (begin == (dwarf_vma) -1 && end != (dwarf_vma) -1) + switch (llet) { - base_address = end; - print_dwarf_vma (begin, pointer_size); - print_dwarf_vma (end, pointer_size); + 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")); - continue; + 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"), - offset); + (unsigned long) offset); break; } - SAFE_BYTE_GET_AND_INC (length, start, 2, section_end); - - if (start + length > section_end) - { - warn (_("Location list starting at offset 0x%lx is not terminated.\n"), - 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); @@ -4476,7 +5197,7 @@ static void display_loc_list_dwo (struct dwarf_section *section, unsigned char **start_ptr, unsigned int debug_info_entry, - unsigned long offset, + dwarf_vma offset, int has_frame_base) { unsigned char *start = *start_ptr; @@ -4512,12 +5233,12 @@ display_loc_list_dwo (struct dwarf_section *section, while (1) { - printf (" %8.8lx ", offset + (start - *start_ptr)); + printf (" %8.8lx ", (unsigned long) (offset + (start - *start_ptr))); if (start >= section_end) { warn (_("Location list starting at offset 0x%lx is not terminated.\n"), - offset); + (unsigned long) offset); break; } @@ -4565,7 +5286,7 @@ display_loc_list_dwo (struct dwarf_section *section, if (start + 2 > section_end) { warn (_("Location list starting at offset 0x%lx is not terminated.\n"), - offset); + (unsigned long) offset); break; } @@ -4573,7 +5294,7 @@ display_loc_list_dwo (struct dwarf_section *section, if (start + length > section_end) { warn (_("Location list starting at offset 0x%lx is not terminated.\n"), - offset); + (unsigned long) offset); break; } @@ -4627,6 +5348,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; @@ -4639,6 +5362,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"), @@ -4688,7 +5456,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])); @@ -4703,8 +5471,8 @@ display_debug_loc (struct dwarf_section *section, void *file) seen_first_offset = 0; for (i = first; i < num_debug_info_entries; i++) { - unsigned long offset; - unsigned long base_address; + dwarf_vma offset; + dwarf_vma base_address; unsigned int k; int has_frame_base; @@ -4748,15 +5516,27 @@ display_debug_loc (struct dwarf_section *section, void *file) if (offset >= bytes) { warn (_("Offset 0x%lx is bigger than .debug_loc section size.\n"), - offset); + (unsigned long) offset); 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); + } } } @@ -4898,7 +5678,12 @@ display_debug_aranges (struct dwarf_section *section, if (arange.ar_version != 2 && arange.ar_version != 3) { - warn (_("Only DWARF 2 and 3 aranges are currently supported.\n")); + /* PR 19872: A version number of 0 probably means that there is + padding at the end of the .debug_aranges section. Gold puts + it there when performing an incremental link, for example. + So do not generate a warning in this case. */ + if (arange.ar_version) + warn (_("Only DWARF 2 and 3 aranges are currently supported.\n")); break; } @@ -5074,7 +5859,7 @@ display_debug_str_offsets (struct dwarf_section *section, struct range_entry { /* The debug_information[x].range_lists[y] value. */ - unsigned long ranges_offset; + dwarf_vma ranges_offset; /* Original debug_information to find parameters of the data. */ debug_info *debug_info_p; @@ -5087,12 +5872,132 @@ range_entry_compar (const void *ap, const void *bp) { const struct range_entry *a_re = (const struct range_entry *) ap; const struct range_entry *b_re = (const struct range_entry *) bp; - const unsigned long a = a_re->ranges_offset; - const unsigned long b = b_re->ranges_offset; + const dwarf_vma a = a_re->ranges_offset; + const dwarf_vma b = b_re->ranges_offset; 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; + /* Initialize it due to a false compiler warning. */ + dwarf_vma begin = -1, length, end = -1; + 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) @@ -5104,6 +6009,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) { @@ -5111,6 +6019,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"), @@ -5152,7 +6132,7 @@ display_debug_ranges (struct dwarf_section *section, if (dwarf_check != 0 && range_entries[0].ranges_offset != 0) warn (_("Range lists in %s section start at 0x%lx\n"), - section->name, range_entries[0].ranges_offset); + section->name, (unsigned long) range_entries[0].ranges_offset); printf (_("Contents of the %s section:\n\n"), section->name); printf (_(" Offset Begin End\n")); @@ -5162,11 +6142,11 @@ display_debug_ranges (struct dwarf_section *section, struct range_entry *range_entry = &range_entries[i]; debug_info *debug_info_p = range_entry->debug_info_p; unsigned int pointer_size; - unsigned long offset; + dwarf_vma offset; unsigned char *next; - unsigned long base_address; + 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; @@ -5175,7 +6155,7 @@ display_debug_ranges (struct dwarf_section *section, if (pointer_size < 2 || pointer_size > 8) { warn (_("Corrupt pointer size (%d) in debug entry at offset %8.8lx\n"), - pointer_size, offset); + pointer_size, (unsigned long) offset); continue; } @@ -5197,49 +6177,8 @@ display_debug_ranges (struct dwarf_section *section, start = next; last_start = next; - while (start < finish) - { - dwarf_vma begin; - dwarf_vma end; - - /* Note: we use sign extension here in order to be sure that - we can detect the -1 escape value. Sign extension into the - top 32 bits of a 32-bit address will not affect the values - that we display since we always show hex values, and always - the bottom 32-bits. */ - 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 (begin == (dwarf_vma) -1 && end != (dwarf_vma) -1) - { - 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'); @@ -5451,6 +6390,30 @@ init_dwarf_regnames_aarch64 (void) dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_aarch64); } +static const char *const dwarf_regnames_s390[] = +{ + /* Avoid saying "r5 (r5)", so omit the names of r0-r15. */ + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, + "f0", "f2", "f4", "f6", "f1", "f3", "f5", "f7", + "f8", "f10", "f12", "f14", "f9", "f11", "f13", "f15", + "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7", + "cr8", "cr9", "cr10", "cr11", "cr12", "cr13", "cr14", "cr15", + "a0", "a1", "a2", "a3", "a4", "a5", "a6", "a7", + "a8", "a9", "a10", "a11", "a12", "a13", "a14", "a15", + "pswm", "pswa", + NULL, NULL, + "v16", "v18", "v20", "v22", "v17", "v19", "v21", "v23", + "v24", "v26", "v28", "v30", "v25", "v27", "v29", "v31", +}; + +void +init_dwarf_regnames_s390 (void) +{ + dwarf_regnames = dwarf_regnames_s390; + dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_s390); +} + void init_dwarf_regnames (unsigned int e_machine) { @@ -5474,6 +6437,10 @@ init_dwarf_regnames (unsigned int e_machine) init_dwarf_regnames_aarch64 (); break; + case EM_S390: + init_dwarf_regnames_s390 (); + break; + default: break; } @@ -5483,6 +6450,7 @@ static const char * regname (unsigned int regno, int row) { static char reg[64]; + if (dwarf_regnames && regno < dwarf_regnames_count && dwarf_regnames [regno] != NULL) @@ -5503,7 +6471,7 @@ frame_display_row (Frame_Chunk *fc, int *need_col_headers, unsigned int *max_reg unsigned int r; char tmp[100]; - if (*max_regs < fc->ncols) + if (*max_regs != fc->ncols) *max_regs = fc->ncols; if (*need_col_headers) @@ -5518,7 +6486,7 @@ frame_display_row (Frame_Chunk *fc, int *need_col_headers, unsigned int *max_reg if (fc->col_type[r] != DW_CFA_unreferenced) { if (r == fc->ra) - printf ("ra "); + printf ("ra "); else printf ("%-5s ", regname (r, 1)); } @@ -5571,8 +6539,6 @@ frame_display_row (Frame_Chunk *fc, int *need_col_headers, unsigned int *max_reg } #define GET(VAR, N) SAFE_BYTE_GET_AND_INC (VAR, start, N, end) -#define LEB() read_uleb128 (start, & length_return, end); start += length_return -#define SLEB() read_sleb128 (start, & length_return, end); start += length_return static unsigned char * read_cie (unsigned char *start, unsigned char *end, @@ -5637,26 +6603,27 @@ read_cie (unsigned char *start, unsigned char *end, fc->ptr_size = eh_addr_size; fc->segment_size = 0; } - fc->code_factor = LEB (); - fc->data_factor = SLEB (); + READ_ULEB (fc->code_factor); + READ_SLEB (fc->data_factor); if (version == 1) { GET (fc->ra, 1); } else { - fc->ra = LEB (); + READ_ULEB (fc->ra); } if (fc->augmentation[0] == 'z') { - augmentation_data_len = LEB (); + READ_ULEB (augmentation_data_len); augmentation_data = start; start += augmentation_data_len; /* PR 17512: file: 11042-2589-0.004. */ if (start > end) { - warn (_("Augmentation data too long: 0x%lx\n"), augmentation_data_len); + warn (_("Augmentation data too long: %#lx, expected at most %#lx\n"), + augmentation_data_len, (long)((end - start) + augmentation_data_len)); return end; } } @@ -5739,6 +6706,7 @@ display_debug_frames (struct dwarf_section *section, unsigned int encoded_ptr_size = saved_eh_addr_size; unsigned int offset_size; unsigned int initial_length_size; + bfd_boolean all_nops; saved_start = start; @@ -5990,7 +6958,7 @@ display_debug_frames (struct dwarf_section *section, if (cie->augmentation[0] == 'z') { - augmentation_data_len = LEB (); + READ_ULEB (augmentation_data_len); augmentation_data = start; start += augmentation_data_len; /* PR 17512: file: 722-8446-0.004. */ @@ -6060,7 +7028,7 @@ display_debug_frames (struct dwarf_section *section, case DW_CFA_advance_loc: break; case DW_CFA_offset: - LEB (); + SKIP_ULEB (); if (frame_need_space (fc, opa) >= 0) fc->col_type[opa] = DW_CFA_undefined; break; @@ -6082,41 +7050,44 @@ display_debug_frames (struct dwarf_section *section, break; case DW_CFA_offset_extended: case DW_CFA_val_offset: - reg = LEB (); LEB (); + READ_ULEB (reg); + SKIP_ULEB (); if (frame_need_space (fc, reg) >= 0) fc->col_type[reg] = DW_CFA_undefined; break; case DW_CFA_restore_extended: - reg = LEB (); + READ_ULEB (reg); if (frame_need_space (fc, reg) >= 0) fc->col_type[reg] = DW_CFA_undefined; break; case DW_CFA_undefined: - reg = LEB (); + READ_ULEB (reg); if (frame_need_space (fc, reg) >= 0) fc->col_type[reg] = DW_CFA_undefined; break; case DW_CFA_same_value: - reg = LEB (); + READ_ULEB (reg); if (frame_need_space (fc, reg) >= 0) fc->col_type[reg] = DW_CFA_undefined; break; case DW_CFA_register: - reg = LEB (); LEB (); + READ_ULEB (reg); + SKIP_ULEB (); if (frame_need_space (fc, reg) >= 0) fc->col_type[reg] = DW_CFA_undefined; break; case DW_CFA_def_cfa: - LEB (); LEB (); + SKIP_ULEB (); + SKIP_ULEB (); break; case DW_CFA_def_cfa_register: - LEB (); + SKIP_ULEB (); break; case DW_CFA_def_cfa_offset: - LEB (); + SKIP_ULEB (); break; case DW_CFA_def_cfa_expression: - temp = LEB (); + READ_ULEB (temp); new_start = start + temp; if (new_start < start) { @@ -6128,8 +7099,8 @@ display_debug_frames (struct dwarf_section *section, break; case DW_CFA_expression: case DW_CFA_val_expression: - reg = LEB (); - temp = LEB (); + READ_ULEB (reg); + READ_ULEB (temp); new_start = start + temp; if (new_start < start) { @@ -6144,24 +7115,27 @@ display_debug_frames (struct dwarf_section *section, break; case DW_CFA_offset_extended_sf: case DW_CFA_val_offset_sf: - reg = LEB (); SLEB (); + READ_ULEB (reg); + SKIP_SLEB (); if (frame_need_space (fc, reg) >= 0) fc->col_type[reg] = DW_CFA_undefined; break; case DW_CFA_def_cfa_sf: - LEB (); SLEB (); + SKIP_ULEB (); + SKIP_SLEB (); break; case DW_CFA_def_cfa_offset_sf: - SLEB (); + SKIP_SLEB (); break; case DW_CFA_MIPS_advance_loc8: start += 8; break; case DW_CFA_GNU_args_size: - LEB (); + SKIP_ULEB (); break; case DW_CFA_GNU_negative_offset_extended: - reg = LEB (); LEB (); + READ_ULEB (reg); + SKIP_ULEB (); if (frame_need_space (fc, reg) >= 0) fc->col_type[reg] = DW_CFA_undefined; break; @@ -6172,6 +7146,8 @@ display_debug_frames (struct dwarf_section *section, start = tmp; } + all_nops = TRUE; + /* Now we know what registers are used, make a second pass over the chunk, this time actually printing out the info. */ @@ -6179,8 +7155,12 @@ display_debug_frames (struct dwarf_section *section, { unsigned char * tmp; unsigned op, opa; - unsigned long ul, reg, roffs; - dwarf_vma l; + unsigned long ul, roffs; + /* Note: It is tempting to use an unsigned long for 'reg' but there + are various functions, notably frame_space_needed() that assume that + reg is an unsigned int. */ + unsigned int reg; + dwarf_signed_vma l; dwarf_vma ofs; dwarf_vma vma; const char *reg_prefix = ""; @@ -6190,6 +7170,10 @@ display_debug_frames (struct dwarf_section *section, if (op & 0xc0) op &= 0xc0; + /* Make a note if something other than DW_CFA_nop happens. */ + if (op != DW_CFA_nop) + all_nops = FALSE; + /* Warning: if you add any more cases to this switch, be sure to add them to the corresponding switch above. */ switch (op) @@ -6207,7 +7191,7 @@ display_debug_frames (struct dwarf_section *section, break; case DW_CFA_offset: - roffs = LEB (); + READ_ULEB (roffs); if (opa >= (unsigned int) fc->ncols) reg_prefix = bad_reg; if (! do_debug_frames_interp || *reg_prefix != '\0') @@ -6222,19 +7206,25 @@ display_debug_frames (struct dwarf_section *section, break; case DW_CFA_restore: - if (opa >= (unsigned int) cie->ncols - || opa >= (unsigned int) fc->ncols) + if (opa >= (unsigned int) fc->ncols) reg_prefix = bad_reg; if (! do_debug_frames_interp || *reg_prefix != '\0') printf (" DW_CFA_restore: %s%s\n", reg_prefix, regname (opa, 0)); - if (*reg_prefix == '\0') + if (*reg_prefix != '\0') + break; + + if (opa >= (unsigned int) cie->ncols + || (do_debug_frames_interp + && cie->col_type[opa] == DW_CFA_unreferenced)) + { + fc->col_type[opa] = DW_CFA_undefined; + fc->col_offset[opa] = 0; + } + else { fc->col_type[opa] = cie->col_type[opa]; fc->col_offset[opa] = cie->col_offset[opa]; - if (do_debug_frames_interp - && fc->col_type[opa] == DW_CFA_unreferenced) - fc->col_type[opa] = DW_CFA_undefined; } break; @@ -6288,8 +7278,8 @@ display_debug_frames (struct dwarf_section *section, break; case DW_CFA_offset_extended: - reg = LEB (); - roffs = LEB (); + READ_ULEB (reg); + READ_ULEB (roffs); if (reg >= (unsigned int) fc->ncols) reg_prefix = bad_reg; if (! do_debug_frames_interp || *reg_prefix != '\0') @@ -6304,12 +7294,12 @@ display_debug_frames (struct dwarf_section *section, break; case DW_CFA_val_offset: - reg = LEB (); - roffs = LEB (); + READ_ULEB (reg); + READ_ULEB (roffs); if (reg >= (unsigned int) fc->ncols) reg_prefix = bad_reg; if (! do_debug_frames_interp || *reg_prefix != '\0') - printf (" DW_CFA_val_offset: %s%s at cfa%+ld\n", + printf (" DW_CFA_val_offset: %s%s is cfa%+ld\n", reg_prefix, regname (reg, 0), roffs * fc->data_factor); if (*reg_prefix == '\0') @@ -6320,14 +7310,21 @@ display_debug_frames (struct dwarf_section *section, break; case DW_CFA_restore_extended: - reg = LEB (); - if (reg >= (unsigned int) cie->ncols - || reg >= (unsigned int) fc->ncols) + READ_ULEB (reg); + if (reg >= (unsigned int) fc->ncols) reg_prefix = bad_reg; if (! do_debug_frames_interp || *reg_prefix != '\0') printf (" DW_CFA_restore_extended: %s%s\n", reg_prefix, regname (reg, 0)); - if (*reg_prefix == '\0') + if (*reg_prefix != '\0') + break; + + if (reg >= (unsigned int) cie->ncols) + { + fc->col_type[reg] = DW_CFA_undefined; + fc->col_offset[reg] = 0; + } + else { fc->col_type[reg] = cie->col_type[reg]; fc->col_offset[reg] = cie->col_offset[reg]; @@ -6335,7 +7332,7 @@ display_debug_frames (struct dwarf_section *section, break; case DW_CFA_undefined: - reg = LEB (); + READ_ULEB (reg); if (reg >= (unsigned int) fc->ncols) reg_prefix = bad_reg; if (! do_debug_frames_interp || *reg_prefix != '\0') @@ -6349,7 +7346,7 @@ display_debug_frames (struct dwarf_section *section, break; case DW_CFA_same_value: - reg = LEB (); + READ_ULEB (reg); if (reg >= (unsigned int) fc->ncols) reg_prefix = bad_reg; if (! do_debug_frames_interp || *reg_prefix != '\0') @@ -6363,8 +7360,8 @@ display_debug_frames (struct dwarf_section *section, break; case DW_CFA_register: - reg = LEB (); - roffs = LEB (); + READ_ULEB (reg); + READ_ULEB (roffs); if (reg >= (unsigned int) fc->ncols) reg_prefix = bad_reg; if (! do_debug_frames_interp || *reg_prefix != '\0') @@ -6427,8 +7424,8 @@ display_debug_frames (struct dwarf_section *section, break; case DW_CFA_def_cfa: - fc->cfa_reg = LEB (); - fc->cfa_offset = LEB (); + READ_SLEB (fc->cfa_reg); + READ_ULEB (fc->cfa_offset); fc->cfa_exp = 0; if (! do_debug_frames_interp) printf (" DW_CFA_def_cfa: %s ofs %d\n", @@ -6436,7 +7433,7 @@ display_debug_frames (struct dwarf_section *section, break; case DW_CFA_def_cfa_register: - fc->cfa_reg = LEB (); + READ_SLEB (fc->cfa_reg); fc->cfa_exp = 0; if (! do_debug_frames_interp) printf (" DW_CFA_def_cfa_register: %s\n", @@ -6444,7 +7441,7 @@ display_debug_frames (struct dwarf_section *section, break; case DW_CFA_def_cfa_offset: - fc->cfa_offset = LEB (); + READ_ULEB (fc->cfa_offset); if (! do_debug_frames_interp) printf (" DW_CFA_def_cfa_offset: %d\n", (int) fc->cfa_offset); break; @@ -6455,8 +7452,8 @@ display_debug_frames (struct dwarf_section *section, break; case DW_CFA_def_cfa_expression: - ul = LEB (); - if (start >= block_end || start + ul > block_end || start + ul < start) + READ_ULEB (ul); + if (start >= block_end || ul > (unsigned long) (block_end - start)) { printf (_(" DW_CFA_def_cfa_expression: \n"), ul); break; @@ -6473,8 +7470,8 @@ display_debug_frames (struct dwarf_section *section, break; case DW_CFA_expression: - reg = LEB (); - ul = LEB (); + READ_ULEB (reg); + READ_ULEB (ul); if (reg >= (unsigned int) fc->ncols) reg_prefix = bad_reg; /* PR 17512: file: 069-133014-0.006. */ @@ -6499,8 +7496,8 @@ display_debug_frames (struct dwarf_section *section, break; case DW_CFA_val_expression: - reg = LEB (); - ul = LEB (); + READ_ULEB (reg); + READ_ULEB (ul); if (reg >= (unsigned int) fc->ncols) reg_prefix = bad_reg; tmp = start + ul; @@ -6523,8 +7520,8 @@ display_debug_frames (struct dwarf_section *section, break; case DW_CFA_offset_extended_sf: - reg = LEB (); - l = SLEB (); + READ_ULEB (reg); + READ_SLEB (l); if (frame_need_space (fc, reg) < 0) reg_prefix = bad_reg; if (! do_debug_frames_interp || *reg_prefix != '\0') @@ -6539,12 +7536,12 @@ display_debug_frames (struct dwarf_section *section, break; case DW_CFA_val_offset_sf: - reg = LEB (); - l = SLEB (); + READ_ULEB (reg); + READ_SLEB (l); if (frame_need_space (fc, reg) < 0) reg_prefix = bad_reg; if (! do_debug_frames_interp || *reg_prefix != '\0') - printf (" DW_CFA_val_offset_sf: %s%s at cfa%+ld\n", + printf (" DW_CFA_val_offset_sf: %s%s is cfa%+ld\n", reg_prefix, regname (reg, 0), (long)(l * fc->data_factor)); if (*reg_prefix == '\0') @@ -6555,8 +7552,8 @@ display_debug_frames (struct dwarf_section *section, break; case DW_CFA_def_cfa_sf: - fc->cfa_reg = LEB (); - fc->cfa_offset = SLEB (); + READ_SLEB (fc->cfa_reg); + READ_ULEB (fc->cfa_offset); fc->cfa_offset = fc->cfa_offset * fc->data_factor; fc->cfa_exp = 0; if (! do_debug_frames_interp) @@ -6565,7 +7562,7 @@ display_debug_frames (struct dwarf_section *section, break; case DW_CFA_def_cfa_offset_sf: - fc->cfa_offset = SLEB (); + READ_ULEB (fc->cfa_offset); fc->cfa_offset *= fc->data_factor; if (! do_debug_frames_interp) printf (" DW_CFA_def_cfa_offset_sf: %d\n", (int) fc->cfa_offset); @@ -6590,14 +7587,15 @@ display_debug_frames (struct dwarf_section *section, break; case DW_CFA_GNU_args_size: - ul = LEB (); + READ_ULEB (ul); if (! do_debug_frames_interp) printf (" DW_CFA_GNU_args_size: %ld\n", ul); break; case DW_CFA_GNU_negative_offset_extended: - reg = LEB (); - l = - LEB (); + READ_ULEB (reg); + READ_SLEB (l); + l = - l; if (frame_need_space (fc, reg) < 0) reg_prefix = bad_reg; if (! do_debug_frames_interp || *reg_prefix != '\0') @@ -6620,7 +7618,8 @@ display_debug_frames (struct dwarf_section *section, } } - if (do_debug_frames_interp) + /* Interpret the CFA - as long as it is not completely full of NOPs. */ + if (do_debug_frames_interp && ! all_nops) frame_display_row (fc, &need_col_headers, &max_regs); start = block_end; @@ -6633,8 +7632,6 @@ display_debug_frames (struct dwarf_section *section, } #undef GET -#undef LEB -#undef SLEB static int display_gdb_index (struct dwarf_section *section, @@ -6743,7 +7740,7 @@ display_gdb_index (struct dwarf_section *section, symbol_table = start + symbol_table_offset; constant_pool = start + constant_pool_offset; - if (address_table + address_table_size * (2 + 8 + 4) > section->start + section->size) + if (address_table + address_table_size > section->start + section->size) { warn (_("Address table extends beyond end of section.\n")); return 0; @@ -7253,21 +8250,27 @@ process_cu_tu_index (struct dwarf_section *section, int do_display) section sets that we can use to associate a .debug_info.dwo section with its associated .debug_abbrev.dwo section in a .dwp file. */ -static void +static bfd_boolean load_cu_tu_indexes (void *file) { + static int cu_tu_indexes_read = -1; /* Tri-state variable. */ + /* If we have already loaded (or tried to load) the CU and TU indexes then do not bother to repeat the task. */ - if (cu_tu_indexes_read) - return; - - if (load_debug_section (dwp_cu_index, file)) - process_cu_tu_index (&debug_displays [dwp_cu_index].section, 0); - - if (load_debug_section (dwp_tu_index, file)) - process_cu_tu_index (&debug_displays [dwp_tu_index].section, 0); + if (cu_tu_indexes_read == -1) + { + cu_tu_indexes_read = TRUE; + + if (load_debug_section (dwp_cu_index, file)) + if (! process_cu_tu_index (&debug_displays [dwp_cu_index].section, 0)) + cu_tu_indexes_read = FALSE; + + if (load_debug_section (dwp_tu_index, file)) + if (! process_cu_tu_index (&debug_displays [dwp_tu_index].section, 0)) + cu_tu_indexes_read = FALSE; + } - cu_tu_indexes_read = 1; + return (bfd_boolean) cu_tu_indexes_read; } /* Find the set of sections that includes section SHNDX. */ @@ -7277,7 +8280,8 @@ find_cu_tu_set (void *file, unsigned int shndx) { unsigned int i; - load_cu_tu_indexes (file); + if (! load_cu_tu_indexes (file)) + return NULL; /* Find SHNDX in the shndx pool. */ for (i = 0; i < shndx_pool_used; i++) @@ -7438,7 +8442,7 @@ dwarf_select_sections_by_names (const char *names) { "macro", & do_debug_macinfo, 1 }, { "pubnames", & do_debug_pubnames, 1 }, { "pubtypes", & do_debug_pubtypes, 1 }, - /* This entry is for compatability + /* This entry is for compatibility with earlier versions of readelf. */ { "ranges", & do_debug_aranges, 1 }, { "rawline", & do_debug_lines, FLAG_DEBUG_LINES_RAW }, @@ -7531,6 +8535,7 @@ dwarf_select_sections_by_letters (const char *letters) case 'F': do_debug_frames_interp = 1; + /* Fall through. */ case 'f': do_debug_frames = 1; break; @@ -7599,14 +8604,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 }, @@ -7650,3 +8661,6 @@ struct dwarf_section_display debug_displays[] = { { ".debug_tu_index", "", NULL, NULL, 0, 0, 0, NULL, 0, NULL }, display_cu_index, &do_debug_cu_index, FALSE }, }; + +/* A static assertion. */ +extern int debug_displays_assert[ARRAY_SIZE (debug_displays) == max ? 1 : -1];