X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=binutils%2Fdwarf.c;h=b4738ebb8d3c9ce41456c78b4661732120189b01;hb=d367307b93e5589245d1f2c8bbcfe709404540a8;hp=2500a49011bf5f1879ca4171cb66d190d55fec95;hpb=82b1b41bcdc6d01fdbd94b246e24a8a8f8c2bddd;p=deliverable%2Fbinutils-gdb.git diff --git a/binutils/dwarf.c b/binutils/dwarf.c index 2500a49011..b4738ebb8d 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-2019 Free Software Foundation, Inc. This file is part of GNU Binutils. @@ -28,15 +28,20 @@ #include "dwarf2.h" #include "dwarf.h" #include "gdb/gdb-index.h" +#include "filenames.h" +#include "safe-ctype.h" +#include + +#undef MAX +#undef MIN +#define MAX(a, b) ((a) > (b) ? (a) : (b)) +#define MIN(a, b) ((a) < (b) ? (a) : (b)) static const char *regname (unsigned int regno, int row); static int have_frame_base; static int need_base_address; -static unsigned int last_pointer_size = 0; -static int warned_about_missing_comp_units = FALSE; - static unsigned int num_debug_info_entries = 0; static unsigned int alloc_num_debug_info_entries = 0; static debug_info *debug_information = NULL; @@ -44,7 +49,28 @@ static debug_info *debug_information = NULL; that the .debug_info section could not be loaded/parsed. */ #define DEBUG_INFO_UNAVAILABLE (unsigned int) -1 -int eh_addr_size; +/* A .debug_info section can contain multiple links to separate + DWO object files. We use these structures to record these links. */ +typedef enum dwo_type +{ + DWO_NAME, + DWO_DIR, + DWO_ID +} dwo_type; + +typedef struct dwo_info +{ + dwo_type type; + const char * value; + struct dwo_info * next; +} dwo_info; + +static dwo_info * first_dwo_info = NULL; +static bfd_boolean need_dwo_info; + +separate_info * first_separate_info = NULL; + +unsigned int eh_addr_size; int do_debug_info; int do_debug_abbrevs; @@ -65,18 +91,23 @@ int do_trace_aranges; int do_debug_addr; int do_debug_cu_index; int do_wide; +int do_debug_links; +int do_follow_links; int dwarf_cutoff_level = -1; unsigned long dwarf_start_die; int dwarf_check = 0; +/* Convenient constant, to avoid having to cast -1 to dwarf_vma when + testing whether e.g. a locview list is present. */ +static const dwarf_vma vm1 = -1; + /* Collection of CU/TU section sets from .debug_cu_index and .debug_tu_index sections. For version 1 package files, each set is stored in SHNDX_POOL 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,13 +130,13 @@ 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 #define FLAG_DEBUG_LINES_DECODED 2 -static int +static unsigned int size_of_encoded_value (int encoding) { switch (encoding & 0x7) @@ -200,7 +231,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); @@ -212,7 +243,10 @@ dwarf_vmatoa_1 (const char *fmtch, dwarf_vma value, unsigned num_bytes) { char fmt[32]; - sprintf (fmt, "%%%s%s", DWARF_VMA_FMT, fmtch); + if (fmtch) + sprintf (fmt, "%%%s%s", DWARF_VMA_FMT, fmtch); + else + sprintf (fmt, "%%%s", DWARF_VMA_FMT); snprintf (ret, sizeof (buf[0].place), fmt, value); return ret; } @@ -234,6 +268,26 @@ print_dwarf_vma (dwarf_vma value, unsigned num_bytes) printf ("%s ", dwarf_vmatoa_1 (NULL, value, num_bytes)); } +/* Print a view number in hexadecimal value, with the same width + print_dwarf_vma would have printed it with the same num_bytes. + Print blanks for zero view, unless force is nonzero. */ + +static void +print_dwarf_view (dwarf_vma value, unsigned num_bytes, int force) +{ + int len; + if (!num_bytes) + len = 4; + else + len = num_bytes * 2; + + assert (value == (unsigned long) value); + if (value || force) + printf ("v%0*lx ", len - 1, (unsigned long) value); + else + printf ("%*s", len + 1, ""); +} + /* Format a 64-bit value, given as two 32-bit values, in hex. For reentrancy, this uses a buffer provided by the caller. */ @@ -281,13 +335,18 @@ read_leb128 (unsigned char *data, shift += 7; if ((byte & 0x80) == 0) break; + + /* PR 17512: file: 0ca183b8. + FIXME: Should we signal this error somehow ? */ + if (shift >= sizeof (result) * 8) + break; } if (length_return != NULL) *length_return = num_read; if (sign && (shift < 8 * sizeof (result)) && (byte & 0x40)) - result |= (dwarf_vma) -1 << shift; + result |= -((dwarf_vma) 1 << shift); return result; } @@ -309,11 +368,54 @@ 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 (%s) " \ + "too large for containing variable\n"), \ + __FILE__, __LINE__, dwarf_vmatoa ("u", _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 (%s) " \ + "too large for containing variable\n"), \ + __FILE__, __LINE__, dwarf_vmatoa ("d", _val)); \ + start += length_return; \ + } \ + while (0) + +/* Read AMOUNT bytes from PTR and store them in VAL as an unsigned value. + Checks to make sure that the read will not reach or pass END + and that VAL is big enough to hold AMOUNT bytes. */ #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 (ngettext ("internal error: attempt to read %d byte " \ + "of data in to %d sized variable", \ + "internal error: attempt to read %d bytes " \ + "of data in to %d sized variable", \ + amount), \ + amount, (int) sizeof (VAL)); \ + amount = sizeof (VAL); \ + } \ if (((PTR) + amount) >= (END)) \ { \ if ((PTR) < (END)) \ @@ -328,6 +430,7 @@ read_uleb128 (unsigned char * data, } \ while (0) +/* Like SAFE_BYTE_GET, but also increments PTR by AMOUNT. */ #define SAFE_BYTE_GET_AND_INC(VAL, PTR, AMOUNT, END) \ do \ { \ @@ -336,6 +439,7 @@ read_uleb128 (unsigned char * data, } \ while (0) +/* Like SAFE_BYTE_GET, but reads a signed value. */ #define SAFE_SIGNED_BYTE_GET(VAL, PTR, AMOUNT, END) \ do \ { \ @@ -354,6 +458,7 @@ read_uleb128 (unsigned char * data, } \ while (0) +/* Like SAFE_SIGNED_BYTE_GET, but also increments PTR by AMOUNT. */ #define SAFE_SIGNED_BYTE_GET_AND_INC(VAL, PTR, AMOUNT, END) \ do \ { \ @@ -379,6 +484,7 @@ read_uleb128 (unsigned char * data, typedef struct State_Machine_Registers { dwarf_vma address; + unsigned int view; unsigned int file; unsigned int line; unsigned int column; @@ -386,8 +492,8 @@ typedef struct State_Machine_Registers int basic_block; unsigned char op_index; unsigned char end_sequence; -/* This variable hold the number of the last entry seen - in the File Table. */ + /* This variable hold the number of the last entry seen + in the File Table. */ unsigned int last_file_entry; } SMR; @@ -397,6 +503,7 @@ static void reset_state_machine (int is_stmt) { state_machine_regs.address = 0; + state_machine_regs.view = 0; state_machine_regs.op_index = 0; state_machine_regs.file = 1; state_machine_regs.line = 1; @@ -446,11 +553,16 @@ process_extended_line_op (unsigned char * data, case DW_LNE_set_address: /* PR 17512: file: 002-100480-0.004. */ if (len - bytes_read - 1 > 8) - warn (_("Length (%d) of DW_LNE_set_address op is too long\n"), - len - bytes_read - 1); - SAFE_BYTE_GET (adr, data, len - bytes_read - 1, end); + { + warn (_("Length (%d) of DW_LNE_set_address op is too long\n"), + len - bytes_read - 1); + adr = 0; + } + else + SAFE_BYTE_GET (adr, data, len - bytes_read - 1, end); printf (_("set Address to 0x%s\n"), dwarf_vmatoa ("x", adr)); state_machine_regs.address = adr; + state_machine_regs.view = 0; state_machine_regs.op_index = 0; break; @@ -459,18 +571,23 @@ 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")); + warn (_("DW_LNE_define_file: Bad opcode length\n")); break; case DW_LNE_set_discriminator: @@ -511,68 +628,68 @@ process_extended_line_op (unsigned char * data, break; case DW_LNE_HP_source_file_correlation: { - unsigned char *edata = data + len - bytes_read - 1; - - printf ("DW_LNE_HP_source_file_correlation\n"); - - while (data < edata) - { - unsigned int opc; - - opc = read_uleb128 (data, & bytes_read, edata); - data += bytes_read; - - switch (opc) - { - case DW_LNE_HP_SFC_formfeed: - printf (" DW_LNE_HP_SFC_formfeed\n"); - break; - case DW_LNE_HP_SFC_set_listing_line: - printf (" DW_LNE_HP_SFC_set_listing_line (%s)\n", - dwarf_vmatoa ("u", - read_uleb128 (data, & bytes_read, edata))); - data += bytes_read; - break; - case DW_LNE_HP_SFC_associate: - printf (" DW_LNE_HP_SFC_associate "); - printf ("(%s", - dwarf_vmatoa ("u", - read_uleb128 (data, & bytes_read, edata))); - data += bytes_read; - printf (",%s", - dwarf_vmatoa ("u", - read_uleb128 (data, & bytes_read, edata))); - data += bytes_read; - printf (",%s)\n", - dwarf_vmatoa ("u", - read_uleb128 (data, & bytes_read, edata))); - data += bytes_read; - break; - default: - printf (_(" UNKNOWN DW_LNE_HP_SFC opcode (%u)\n"), opc); - data = edata; - break; - } - } + unsigned char *edata = data + len - bytes_read - 1; + + printf ("DW_LNE_HP_source_file_correlation\n"); + + while (data < edata) + { + unsigned int opc; + + opc = read_uleb128 (data, & bytes_read, edata); + data += bytes_read; + + switch (opc) + { + case DW_LNE_HP_SFC_formfeed: + printf (" DW_LNE_HP_SFC_formfeed\n"); + break; + case DW_LNE_HP_SFC_set_listing_line: + printf (" DW_LNE_HP_SFC_set_listing_line (%s)\n", + dwarf_vmatoa ("u", + read_uleb128 (data, & bytes_read, edata))); + data += bytes_read; + break; + case DW_LNE_HP_SFC_associate: + printf (" DW_LNE_HP_SFC_associate "); + printf ("(%s", + dwarf_vmatoa ("u", + read_uleb128 (data, & bytes_read, edata))); + data += bytes_read; + printf (",%s", + dwarf_vmatoa ("u", + read_uleb128 (data, & bytes_read, edata))); + data += bytes_read; + printf (",%s)\n", + dwarf_vmatoa ("u", + read_uleb128 (data, & bytes_read, edata))); + data += bytes_read; + break; + default: + printf (_(" UNKNOWN DW_LNE_HP_SFC opcode (%u)\n"), opc); + data = edata; + break; + } + } } break; default: { - unsigned int rlen = len - bytes_read - 1; - - if (op_code >= DW_LNE_lo_user - /* The test against DW_LNW_hi_user is redundant due to - the limited range of the unsigned char data type used - for op_code. */ - /*&& op_code <= DW_LNE_hi_user*/) - printf (_("user defined: ")); - else - printf (_("UNKNOWN: ")); - printf (_("length %d ["), rlen); - for (; rlen; rlen--) - printf (" %02x", *data++); - printf ("]\n"); + unsigned int rlen = len - bytes_read - 1; + + if (op_code >= DW_LNE_lo_user + /* The test against DW_LNW_hi_user is redundant due to + the limited range of the unsigned char data type used + for op_code. */ + /*&& op_code <= DW_LNE_hi_user*/) + printf (_("user defined: ")); + else + printf (_("UNKNOWN: ")); + printf (_("length %d ["), rlen); + for (; rlen; rlen--) + printf (" %02x", *data++); + printf ("]\n"); } break; } @@ -584,23 +701,61 @@ 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 * fetch_indexed_string (dwarf_vma idx, struct cu_tu_set *this_set, - dwarf_vma offset_size, int dwo) + dwarf_vma offset_size, bfd_boolean dwo) { enum dwarf_section_display_enum str_sec_idx = dwo ? str_dwo : str; enum dwarf_section_display_enum idx_sec_idx = dwo ? str_index_dwo : str_index; @@ -608,6 +763,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 ? _("") @@ -615,7 +771,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)); @@ -628,14 +784,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 * @@ -649,7 +813,7 @@ fetch_indexed_value (dwarf_vma offset, dwarf_vma bytes) if (offset + bytes > section->size) { warn (_("Offset into section %s too big: %s\n"), - section->name, dwarf_vmatoa ("x", offset)); + section->name, dwarf_vmatoa ("x", offset)); return ""; } @@ -664,6 +828,7 @@ typedef struct abbrev_attr { unsigned long attribute; unsigned long form; + bfd_signed_vma implicit_const; struct abbrev_attr *next; } abbrev_attr; @@ -733,7 +898,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; @@ -744,6 +910,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) @@ -796,6 +963,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; @@ -807,7 +976,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); } @@ -821,13 +998,16 @@ process_abbrev_section (unsigned char *start, unsigned char *end) static const char * get_TAG_name (unsigned long tag) { - const char *name = get_DW_TAG_name ((unsigned int)tag); + const char *name = get_DW_TAG_name ((unsigned int) tag); if (name == NULL) { static char buffer[100]; - snprintf (buffer, sizeof (buffer), _("Unknown TAG value: %lx"), tag); + if (tag >= DW_TAG_lo_user && tag <= DW_TAG_hi_user) + snprintf (buffer, sizeof (buffer), _("User TAG value: %#lx"), tag); + else + snprintf (buffer, sizeof (buffer), _("Unknown TAG value: %#lx"), tag); return buffer; } @@ -854,14 +1034,30 @@ get_FORM_name (unsigned long form) return name; } +static const char * +get_IDX_name (unsigned long idx) +{ + const char *name = get_DW_IDX_name ((unsigned int) idx); + + if (name == NULL) + { + static char buffer[100]; + + snprintf (buffer, sizeof (buffer), _("Unknown IDX value: %lx"), idx); + return buffer; + } + + return name; +} + 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; @@ -1197,21 +1393,21 @@ decode_location_expression (unsigned char * data, printf ("DW_OP_push_object_address"); break; case DW_OP_call2: - /* XXX: Strictly speaking for 64-bit DWARF3 files + /* FIXME: Strictly speaking for 64-bit DWARF3 files this ought to be an 8-byte wide computation. */ SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 2, end); printf ("DW_OP_call2: <0x%s>", dwarf_vmatoa ("x", svalue + cu_offset)); break; case DW_OP_call4: - /* XXX: Strictly speaking for 64-bit DWARF3 files + /* FIXME: Strictly speaking for 64-bit DWARF3 files this ought to be an 8-byte wide computation. */ SAFE_SIGNED_BYTE_GET_AND_INC (svalue, data, 4, end); printf ("DW_OP_call4: <0x%s>", dwarf_vmatoa ("x", svalue + cu_offset)); break; case DW_OP_call_ref: - /* XXX: Strictly speaking for 64-bit DWARF3 files + /* FIXME: Strictly speaking for 64-bit DWARF3 files this ought to be an 8-byte wide computation. */ if (dwarf_version == -1) { @@ -1254,7 +1450,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. */ @@ -1278,12 +1474,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 + /* FIXME: 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; } @@ -1295,19 +1495,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)) @@ -1317,40 +1521,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: @@ -1358,16 +1577,35 @@ decode_location_expression (unsigned char * data, printf ("DW_OP_GNU_parameter_ref: <0x%s>", dwarf_vmatoa ("x", cu_offset + uvalue)); break; - case DW_OP_GNU_addr_index: - uvalue = read_uleb128 (data, &bytes_read, end); - data += bytes_read; - printf ("DW_OP_GNU_addr_index <0x%s>", dwarf_vmatoa ("x", uvalue)); - break; - case DW_OP_GNU_const_index: - uvalue = read_uleb128 (data, &bytes_read, end); - data += bytes_read; - printf ("DW_OP_GNU_const_index <0x%s>", dwarf_vmatoa ("x", uvalue)); - break; + case DW_OP_GNU_addr_index: + uvalue = read_uleb128 (data, &bytes_read, end); + data += bytes_read; + printf ("DW_OP_GNU_addr_index <0x%s>", dwarf_vmatoa ("x", uvalue)); + break; + case DW_OP_GNU_const_index: + uvalue = read_uleb128 (data, &bytes_read, end); + data += bytes_read; + printf ("DW_OP_GNU_const_index <0x%s>", dwarf_vmatoa ("x", uvalue)); + break; + case DW_OP_GNU_variable_value: + /* FIXME: Strictly speaking for 64-bit DWARF3 files + this ought to be an 8-byte wide computation. */ + if (dwarf_version == -1) + { + printf (_("(DW_OP_GNU_variable_value in frame info)")); + /* No way to tell where the next op is, so just bail. */ + return need_frame_base; + } + if (dwarf_version == 2) + { + SAFE_BYTE_GET_AND_INC (uvalue, data, pointer_size, end); + } + else + { + SAFE_BYTE_GET_AND_INC (uvalue, data, offset_size, end); + } + printf ("DW_OP_GNU_variable_value: <0x%s>", dwarf_vmatoa ("x", uvalue)); + break; /* HP extensions. */ case DW_OP_HP_is_value: @@ -1407,9 +1645,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; } @@ -1482,19 +1720,133 @@ add64 (dwarf_vma * high_bits, dwarf_vma * low_bits, dwarf_vma inc) * low_bits = tmp; } +static const char * +fetch_alt_indirect_string (dwarf_vma offset) +{ + separate_info * i; + + if (! do_follow_links) + return ""; + + if (first_separate_info == NULL) + return _(""); + + for (i = first_separate_info; i != NULL; i = i->next) + { + struct dwarf_section * section; + const char * ret; + + if (! load_debug_section (separate_debug_str, i->handle)) + continue; + + section = &debug_displays [separate_debug_str].section; + + if (section->start == NULL) + continue; + + if (offset >= section->size) + continue; + + ret = (const char *) (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) + return _(""); + + return ret; + } + + warn (_("DW_FORM_GNU_strp_alt offset (%s) too big or no string sections available\n"), + dwarf_vmatoa ("x", offset)); + return _(""); +} + +static const char * +get_AT_name (unsigned long attribute) +{ + const char *name; + + if (attribute == 0) + return "DW_AT value: 0"; + + /* One value is shared by the MIPS and HP extensions: */ + if (attribute == DW_AT_MIPS_fde) + return "DW_AT_MIPS_fde or DW_AT_HP_unmodifiable"; + + name = get_DW_AT_name (attribute); + + if (name == NULL) + { + static char buffer[100]; + + snprintf (buffer, sizeof (buffer), _("Unknown AT value: %lx"), + attribute); + return buffer; + } + + return name; +} + +static void +add_dwo_info (const char * field, dwo_type type) +{ + dwo_info * dwinfo = xmalloc (sizeof * dwinfo); + + dwinfo->type = type; + dwinfo->value = field; + dwinfo->next = first_dwo_info; + first_dwo_info = dwinfo; +} + +static void +add_dwo_name (const char * name) +{ + add_dwo_info (name, DWO_NAME); +} + +static void +add_dwo_dir (const char * dir) +{ + add_dwo_info (dir, DWO_DIR); +} + +static void +add_dwo_id (const char * id) +{ + add_dwo_info (id, DWO_ID); +} + +static void +free_dwo_info (void) +{ + dwo_info * dwinfo; + dwo_info * next; + + for (dwinfo = first_dwo_info; dwinfo != NULL; dwinfo = next) + { + next = dwinfo->next; + free (dwinfo); + } + first_dwo_info = NULL; +} + static unsigned char * -read_and_display_attr_value (unsigned long attribute, - unsigned long form, - unsigned char * data, - unsigned char * end, - dwarf_vma cu_offset, - dwarf_vma pointer_size, - dwarf_vma offset_size, - int dwarf_version, - debug_info * debug_info_p, - int do_loc, - struct dwarf_section * section, - struct cu_tu_set * this_set) +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, + dwarf_vma pointer_size, + dwarf_vma offset_size, + int dwarf_version, + debug_info * debug_info_p, + int do_loc, + struct dwarf_section * section, + struct cu_tu_set * this_set, + char delimiter) { dwarf_vma uvalue = 0; unsigned char *block_start = NULL; @@ -1527,6 +1879,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: @@ -1573,12 +1926,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; @@ -1589,12 +1947,13 @@ 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)); + /* FIXME: Follow the reference... */ break; case DW_FORM_ref1: @@ -1602,14 +1961,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: @@ -1619,7 +1978,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: @@ -1634,7 +1998,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))); } @@ -1650,9 +2014,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; @@ -1666,8 +2056,12 @@ read_and_display_attr_value (unsigned long attribute, uvalue = 0; block_start = end; } + /* FIXME: Testing "(block_start + uvalue) < block_start" miscompiles with + gcc 4.8.3 running on an x86_64 host in 32-bit mode. So we pre-compute + block_start + uvalue here. */ + data = block_start + uvalue; /* PR 17512: file: 008-103549-0.001:0.1. */ - if (block_start + uvalue > end) + if (block_start + uvalue > end || data < block_start) { warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue); uvalue = end - block_start; @@ -1675,7 +2069,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: @@ -1687,7 +2081,8 @@ read_and_display_attr_value (unsigned long attribute, uvalue = 0; block_start = end; } - if (block_start + uvalue > end) + data = block_start + uvalue; + if (block_start + uvalue > end || data < block_start) { warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue); uvalue = end - block_start; @@ -1695,7 +2090,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: @@ -1707,7 +2102,8 @@ read_and_display_attr_value (unsigned long attribute, uvalue = 0; block_start = end; } - if (block_start + uvalue > end) + data = block_start + uvalue; + if (block_start + uvalue > end || data < block_start) { warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue); uvalue = end - block_start; @@ -1715,7 +2111,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: @@ -1728,7 +2124,10 @@ read_and_display_attr_value (unsigned long attribute, uvalue = 0; block_start = end; } - if (block_start + uvalue > end) + data = block_start + uvalue; + if (block_start + uvalue > end + /* PR 17531: file: 5b5f0592. */ + || data < block_start) { warn (_("Corrupt attribute block length: %lx\n"), (long) uvalue); uvalue = end - block_start; @@ -1736,32 +2135,42 @@ 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"), - dwarf_vmatoa ("x", uvalue), - fetch_indexed_string (uvalue, this_set, offset_size, dwo)); - } + { + const char * suffix = strrchr (section->name, '.'); + bfd_boolean dwo = (suffix && strcmp (suffix, ".dwo") == 0) ? TRUE : FALSE; + + printf (_("%c(indexed string: 0x%s): %s"), delimiter, + dwarf_vmatoa ("x", uvalue), + fetch_indexed_string (uvalue, this_set, offset_size, dwo)); + } break; case DW_FORM_GNU_strp_alt: if (!do_loc) - printf (_(" (alt indirect string, offset: 0x%s)"), - dwarf_vmatoa ("x", uvalue)); + { + printf (_("%c(alt indirect string, offset: 0x%s) %s"), delimiter, + dwarf_vmatoa ("x", uvalue), + fetch_alt_indirect_string (uvalue)); + } break; case DW_FORM_indirect: @@ -1775,7 +2184,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; @@ -1783,9 +2192,9 @@ read_and_display_attr_value (unsigned long attribute, case DW_FORM_GNU_addr_index: if (!do_loc) - printf (_(" (addr_index: 0x%s): %s"), - dwarf_vmatoa ("x", uvalue), - fetch_indexed_value (uvalue * pointer_size, pointer_size)); + printf (_("%c(addr_index: 0x%s): %s"), delimiter, + dwarf_vmatoa ("x", uvalue), + fetch_indexed_value (uvalue * pointer_size, pointer_size)); break; default: @@ -1801,7 +2210,9 @@ 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_GNU_locviews: case DW_AT_string_length: case DW_AT_return_addr: case DW_AT_data_member_location: @@ -1809,11 +2220,15 @@ 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 + if ((dwarf_version < 4 && (form == DW_FORM_data4 || form == DW_FORM_data8)) || form == DW_FORM_sec_offset) { @@ -1825,18 +2240,44 @@ read_and_display_attr_value (unsigned long attribute, { lmax += 1024; debug_info_p->loc_offsets = (dwarf_vma *) - xcrealloc (debug_info_p->loc_offsets, - lmax, sizeof (*debug_info_p->loc_offsets)); + xcrealloc (debug_info_p->loc_offsets, + lmax, sizeof (*debug_info_p->loc_offsets)); + debug_info_p->loc_views = (dwarf_vma *) + xcrealloc (debug_info_p->loc_views, + lmax, sizeof (*debug_info_p->loc_views)); debug_info_p->have_frame_base = (int *) - xcrealloc (debug_info_p->have_frame_base, - lmax, sizeof (*debug_info_p->have_frame_base)); + xcrealloc (debug_info_p->have_frame_base, + lmax, sizeof (*debug_info_p->have_frame_base)); debug_info_p->max_loc_offsets = lmax; } if (this_set != NULL) - uvalue += this_set->section_offsets [DW_SECT_LOC]; - debug_info_p->loc_offsets [num] = uvalue; + uvalue += this_set->section_offsets [DW_SECT_LOC]; debug_info_p->have_frame_base [num] = have_frame_base; - debug_info_p->num_loc_offsets++; + if (attribute != DW_AT_GNU_locviews) + { + /* Corrupt DWARF info can produce more offsets than views. + See PR 23062 for an example. */ + if (debug_info_p->num_loc_offsets + > debug_info_p->num_loc_views) + warn (_("More location offset attributes than DW_AT_GNU_locview attributes\n")); + else + { + debug_info_p->loc_offsets [num] = uvalue; + debug_info_p->num_loc_offsets++; + } + } + else + { + assert (debug_info_p->num_loc_views <= num); + num = debug_info_p->num_loc_views; + if (num > debug_info_p->num_loc_offsets) + warn (_("More DW_AT_GNU_locview attributes than location offset attributes\n")); + else + { + debug_info_p->loc_views [num] = uvalue; + debug_info_p->num_loc_views++; + } + } } break; @@ -1846,15 +2287,15 @@ read_and_display_attr_value (unsigned long attribute, break; case DW_AT_GNU_addr_base: - debug_info_p->addr_base = uvalue; + debug_info_p->addr_base = uvalue; break; case DW_AT_GNU_ranges_base: - debug_info_p->ranges_base = uvalue; + debug_info_p->ranges_base = uvalue; break; case DW_AT_ranges: - if ((dwarf_version < 4 + if ((dwarf_version < 4 && (form == DW_FORM_data4 || form == DW_FORM_data8)) || form == DW_FORM_sec_offset) { @@ -1866,8 +2307,8 @@ read_and_display_attr_value (unsigned long attribute, { lmax += 1024; debug_info_p->range_lists = (dwarf_vma *) - xcrealloc (debug_info_p->range_lists, - lmax, sizeof (*debug_info_p->range_lists)); + xcrealloc (debug_info_p->range_lists, + lmax, sizeof (*debug_info_p->range_lists)); debug_info_p->max_range_lists = lmax; } debug_info_p->range_lists [num] = uvalue; @@ -1875,6 +2316,66 @@ read_and_display_attr_value (unsigned long attribute, } break; + case DW_AT_GNU_dwo_name: + case DW_AT_dwo_name: + if (need_dwo_info) + switch (form) + { + case DW_FORM_strp: + add_dwo_name ((const char *) fetch_indirect_string (uvalue)); + break; + case DW_FORM_GNU_str_index: + add_dwo_name (fetch_indexed_string (uvalue, this_set, offset_size, FALSE)); + break; + case DW_FORM_string: + add_dwo_name ((const char *) orig_data); + break; + default: + warn (_("Unsupported form (%s) for attribute %s\n"), + get_FORM_name (form), get_AT_name (attribute)); + break; + } + break; + + case DW_AT_comp_dir: + /* FIXME: Also extract a build-id in a CU/TU. */ + if (need_dwo_info) + switch (form) + { + case DW_FORM_strp: + add_dwo_dir ((const char *) fetch_indirect_string (uvalue)); + break; + case DW_FORM_line_strp: + add_dwo_dir ((const char *) fetch_indirect_line_string (uvalue)); + break; + case DW_FORM_GNU_str_index: + add_dwo_dir (fetch_indexed_string (uvalue, this_set, offset_size, FALSE)); + break; + case DW_FORM_string: + add_dwo_dir ((const char *) orig_data); + break; + default: + warn (_("Unsupported form (%s) for attribute %s\n"), + get_FORM_name (form), get_AT_name (attribute)); + break; + } + break; + + case DW_AT_GNU_dwo_id: + if (need_dwo_info) + switch (form) + { + case DW_FORM_data8: + /* FIXME: Record the length of the ID as well ? */ + add_dwo_id ((const char *) (data - 8)); + break; + default: + warn (_("Unsupported form (%s) for attribute %s\n"), + get_FORM_name (form), get_AT_name (attribute)); + break; + } + break; + default: break; } @@ -1938,10 +2439,22 @@ read_and_display_attr_value (unsigned long attribute, /* DWARF 4 values. */ case DW_LANG_Python: printf ("(Python)"); break; /* DWARF 5 values. */ + case DW_LANG_OpenCL: printf ("(OpenCL)"); break; case DW_LANG_Go: printf ("(Go)"); break; + case DW_LANG_Modula3: printf ("(Modula 3)"); break; + case DW_LANG_Haskell: printf ("(Haskell)"); break; + case DW_LANG_C_plus_plus_03: printf ("(C++03)"); break; case DW_LANG_C_plus_plus_11: printf ("(C++11)"); break; + case DW_LANG_OCaml: printf ("(OCaml)"); break; + case DW_LANG_Rust: printf ("(Rust)"); break; case DW_LANG_C11: printf ("(C11)"); break; + case DW_LANG_Swift: printf ("(Swift)"); break; + case DW_LANG_Julia: printf ("(Julia)"); break; + case DW_LANG_Dylan: printf ("(Dylan)"); break; case DW_LANG_C_plus_plus_14: printf ("(C++14)"); break; + case DW_LANG_Fortran03: printf ("(Fortran 03)"); break; + case DW_LANG_Fortran08: printf ("(Fortran 08)"); break; + case DW_LANG_RenderScript: printf ("(RenderScript)"); break; /* MIPS extension. */ case DW_LANG_Mips_Assembler: printf ("(MIPS assembler)"); break; /* UPC extension. */ @@ -1978,6 +2491,12 @@ read_and_display_attr_value (unsigned long attribute, case DW_ATE_edited: printf ("(edited)"); break; case DW_ATE_signed_fixed: printf ("(signed_fixed)"); break; case DW_ATE_unsigned_fixed: printf ("(unsigned_fixed)"); break; + /* DWARF 4 values: */ + case DW_ATE_UTF: printf ("(unicode string)"); break; + /* DWARF 5 values: */ + case DW_ATE_UCS: printf ("(UCS)"); break; + case DW_ATE_ASCII: printf ("(ASCII)"); break; + /* HP extensions: */ case DW_ATE_HP_float80: printf ("(HP_float80)"); break; case DW_ATE_HP_complex_float80: printf ("(HP_complex_float80)"); break; @@ -2021,6 +2540,22 @@ read_and_display_attr_value (unsigned long attribute, } break; + case DW_AT_endianity: + printf ("\t"); + switch (uvalue) + { + case DW_END_default: printf ("(default)"); break; + case DW_END_big: printf ("(big)"); break; + case DW_END_little: printf ("(little)"); break; + default: + if (uvalue >= DW_END_lo_user && uvalue <= DW_END_hi_user) + printf (_("(user specified)")); + else + printf (_("(unknown endianity)")); + break; + } + break; + case DW_AT_virtuality: printf ("\t"); switch (uvalue) @@ -2051,6 +2586,10 @@ read_and_display_attr_value (unsigned long attribute, case DW_CC_normal: printf ("(normal)"); break; case DW_CC_program: printf ("(program)"); break; case DW_CC_nocall: printf ("(nocall)"); break; + case DW_CC_pass_by_reference: printf ("(pass by ref)"); break; + case DW_CC_pass_by_value: printf ("(pass by value)"); break; + case DW_CC_GNU_renesas_sh: printf ("(Rensas SH)"); break; + case DW_CC_GNU_borland_fastcall_i386: printf ("(Borland fastcall i386)"); break; default: if (uvalue >= DW_CC_lo_user && uvalue <= DW_CC_hi_user) @@ -2064,28 +2603,68 @@ read_and_display_attr_value (unsigned long attribute, printf ("\t"); switch (uvalue) { + case 255: case -1: printf (_("(undefined)")); break; case 0: printf ("(row major)"); break; case 1: printf ("(column major)"); break; } break; - case DW_AT_frame_base: - have_frame_base = 1; - case DW_AT_location: - case DW_AT_string_length: - case DW_AT_return_addr: - case DW_AT_data_member_location: + case DW_AT_decimal_sign: + printf ("\t"); + switch (uvalue) + { + case DW_DS_unsigned: printf (_("(unsigned)")); break; + case DW_DS_leading_overpunch: printf (_("(leading overpunch)")); break; + case DW_DS_trailing_overpunch: printf (_("(trailing overpunch)")); break; + case DW_DS_leading_separate: printf (_("(leading separate)")); break; + case DW_DS_trailing_separate: printf (_("(trailing separate)")); break; + default: printf (_("(unrecognised)")); break; + } + break; + + case DW_AT_defaulted: + printf ("\t"); + switch (uvalue) + { + case DW_DEFAULTED_no: printf (_("(no)")); break; + case DW_DEFAULTED_in_class: printf (_("(in class)")); break; + case DW_DEFAULTED_out_of_class: printf (_("(out of class)")); break; + default: printf (_("(unrecognised)")); break; + } + break; + + case DW_AT_discr_list: + printf ("\t"); + switch (uvalue) + { + case DW_DSC_label: printf (_("(label)")); break; + case DW_DSC_range: printf (_("(range)")); break; + default: printf (_("(unrecognised)")); break; + } + break; + + 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: + case DW_AT_data_member_location: case DW_AT_vtable_elem_location: 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)) + && (form == DW_FORM_data4 || form == DW_FORM_data8)) || form == DW_FORM_sec_offset) printf (_(" (location list)")); /* Fall through. */ @@ -2112,11 +2691,27 @@ read_and_display_attr_value (unsigned long attribute, } break; + case DW_AT_data_bit_offset: + case DW_AT_byte_size: + case DW_AT_bit_size: + case DW_AT_string_length_byte_size: + case DW_AT_string_length_bit_size: + case DW_AT_bit_stride: + if (form == DW_FORM_exprloc) + { + printf ("\t("); + (void) decode_location_expression (block_start, pointer_size, + offset_size, dwarf_version, + uvalue, cu_offset, section); + printf (")"); + } + break; + case DW_AT_import: { if (form == DW_FORM_ref_sig8 || form == DW_FORM_GNU_ref_alt) - break; + break; if (form == DW_FORM_ref1 || form == DW_FORM_ref2 @@ -2125,7 +2720,7 @@ read_and_display_attr_value (unsigned long attribute, uvalue += cu_offset; if (uvalue >= section->size) - warn (_("Offset %s used as value for DW_AT_import attribute of DIE at offset %lx is too big.\n"), + warn (_("Offset %s used as value for DW_AT_import attribute of DIE at offset 0x%lx is too big.\n"), dwarf_vmatoa ("x", uvalue), (unsigned long) (orig_data - section->start)); else @@ -2159,68 +2754,115 @@ read_and_display_attr_value (unsigned long attribute, return data; } -static const char * -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, + dwarf_vma pointer_size, + dwarf_vma offset_size, + int dwarf_version, + debug_info * debug_info_p, + int do_loc, + struct dwarf_section * section, + struct cu_tu_set * this_set) { - const char *name; + if (!do_loc) + printf (" %-18s:", get_AT_name (attribute)); + 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, ' '); + if (!do_loc) + printf ("\n"); + return data; +} - if (attribute == 0) - return "DW_AT value: 0"; +/* Like load_debug_section, but if the ordinary call fails, and we are + following debug links, then attempt to load the requested section + from one of the separate debug info files. */ - /* One value is shared by the MIPS and HP extensions: */ - if (attribute == DW_AT_MIPS_fde) - return "DW_AT_MIPS_fde or DW_AT_HP_unmodifiable"; +static bfd_boolean +load_debug_section_with_follow (enum dwarf_section_display_enum sec_enum, + void * handle) +{ + if (load_debug_section (sec_enum, handle)) + { + if (debug_displays[sec_enum].section.filename == NULL) + { + /* See if we can associate a filename with this section. */ + separate_info * i; - name = get_DW_AT_name (attribute); + for (i = first_separate_info; i != NULL; i = i->next) + if (i->handle == handle) + { + debug_displays[sec_enum].section.filename = i->filename; + break; + } + } - if (name == NULL) + return TRUE; + } + + if (do_follow_links) { - static char buffer[100]; + separate_info * i; - snprintf (buffer, sizeof (buffer), _("Unknown AT value: %lx"), - attribute); - return buffer; + for (i = first_separate_info; i != NULL; i = i->next) + { + if (load_debug_section (sec_enum, i->handle)) + { + debug_displays[sec_enum].section.filename = i->filename; + + /* FIXME: We should check to see if any of the remaining debug info + files also contain this section, and, umm, do something about it. */ + return TRUE; + } + } } - return name; + return FALSE; } -static unsigned char * -read_and_display_attr (unsigned long attribute, - unsigned long form, - unsigned char * data, - unsigned char * end, - dwarf_vma cu_offset, - dwarf_vma pointer_size, - dwarf_vma offset_size, - int dwarf_version, - debug_info * debug_info_p, - int do_loc, - struct dwarf_section * section, - struct cu_tu_set * this_set) +static void +introduce (struct dwarf_section * section, bfd_boolean raw) { - if (!do_loc) - printf (" %-18s:", get_AT_name (attribute)); - data = read_and_display_attr_value (attribute, form, data, end, - cu_offset, pointer_size, offset_size, - dwarf_version, debug_info_p, - do_loc, section, this_set); - if (!do_loc) - printf ("\n"); - return data; + if (raw) + { + if (do_follow_links && section->filename) + printf (_("Raw dump of debug contents of section %s (loaded from %s):\n\n"), + section->name, section->filename); + else + printf (_("Raw dump of debug contents of section %s:\n\n"), section->name); + } + else + { + if (do_follow_links && section->filename) + printf (_("Contents of the %s section (loaded from %s):\n\n"), + section->name, section->filename); + else + printf (_("Contents of the %s section:\n\n"), section->name); + } } - -/* Process the contents of a .debug_info section. If do_loc is non-zero - then we are scanning for location lists and we do not want to display - anything to the user. If do_types is non-zero, we are processing - a .debug_types section instead of a .debug_info section. */ - -static int -process_debug_info (struct dwarf_section *section, - void *file, - enum dwarf_section_display_enum abbrev_sec, - int do_loc, - int do_types) + +/* Process the contents of a .debug_info section. + If do_loc is TRUE then we are scanning for location lists and dwo tags + and we do not want to display anything to the user. + If do_types is TRUE, we are processing a .debug_types section instead of + a .debug_info section. + The information displayed is restricted by the values in DWARF_START_DIE + and DWARF_CUTOFF_LEVEL. + Returns TRUE upon success. Otherwise an error or warning message is + printed and FALSE is returned. */ + +static bfd_boolean +process_debug_info (struct dwarf_section * section, + void * file, + enum dwarf_section_display_enum abbrev_sec, + bfd_boolean do_loc, + bfd_boolean do_types) { unsigned char *start = section->start; unsigned char *end = start + section->size; @@ -2252,61 +2894,70 @@ process_debug_info (struct dwarf_section *section, { warn (_("Reserved length value (0x%s) found in section %s\n"), dwarf_vmatoa ("x", length), section->name); - return 0; + return FALSE; } else section_begin += length + 4; /* Negative values are illegal, they may even cause infinite looping. This can happen if we can't accurately apply - relocations to an object file. */ - if ((signed long) length <= 0) + relocations to an object file, or if the file is corrupt. */ + if ((signed long) length <= 0 || section_begin < start) { warn (_("Corrupt unit length (0x%s) found in section %s\n"), dwarf_vmatoa ("x", length), section->name); - return 0; + return FALSE; } } if (num_units == 0) { error (_("No comp units in %s section ?\n"), section->name); - return 0; + return FALSE; } /* Then allocate an array to hold the information. */ debug_information = (debug_info *) cmalloc (num_units, - sizeof (* debug_information)); + sizeof (* debug_information)); if (debug_information == NULL) { error (_("Not enough memory for a debug info array of %u entries\n"), num_units); alloc_num_debug_info_entries = num_debug_info_entries = 0; - return 0; + return FALSE; } + + /* PR 17531: file: 92ca3797. + We cannot rely upon the debug_information array being initialised + before it is used. A corrupt file could easily contain references + to a unit for which information has not been made available. So + we ensure that the array is zeroed here. */ + memset (debug_information, 0, num_units * sizeof (*debug_information)); + alloc_num_debug_info_entries = num_units; } if (!do_loc) { - if (dwarf_start_die == 0) - printf (_("Contents of the %s section:\n\n"), section->name); - - load_debug_section (str, file); - load_debug_section (str_dwo, file); - load_debug_section (str_index, file); - load_debug_section (str_index_dwo, file); - load_debug_section (debug_addr, file); + load_debug_section_with_follow (str, file); + load_debug_section_with_follow (line_str, file); + load_debug_section_with_follow (str_dwo, file); + load_debug_section_with_follow (str_index, file); + load_debug_section_with_follow (str_index_dwo, file); + load_debug_section_with_follow (debug_addr, file); } - load_debug_section (abbrev_sec, file); + load_debug_section_with_follow (abbrev_sec, file); if (debug_displays [abbrev_sec].section.start == NULL) { warn (_("Unable to locate %s section!\n"), - debug_displays [abbrev_sec].section.name); - return 0; + debug_displays [abbrev_sec].section.uncompressed_name); + return FALSE; } + if (!do_loc && dwarf_start_die == 0) + introduce (section, FALSE); + for (section_begin = start, unit = 0; start < end; unit++) { DWARF2_Internal_CompUnit compunit; @@ -2314,8 +2965,9 @@ process_debug_info (struct dwarf_section *section, unsigned char *tags; int level, last_level, saved_level; dwarf_vma cu_offset; + unsigned long sec_off; unsigned int offset_size; - int initial_length_size; + unsigned int initial_length_size; dwarf_vma signature_high = 0; dwarf_vma signature_low = 0; dwarf_vma type_offset = 0; @@ -2345,6 +2997,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) @@ -2358,7 +3024,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) { @@ -2368,11 +3036,19 @@ process_debug_info (struct dwarf_section *section, } if (do_types) - { + { SAFE_BYTE_GET64 (hdrptr, &signature_high, &signature_low, end); hdrptr += 8; SAFE_BYTE_GET_AND_INC (type_offset, hdrptr, offset_size, end); - } + } + + if (dwarf_start_die > (cu_offset + compunit.cu_length + + initial_length_size)) + { + start = section_begin + cu_offset + compunit.cu_length + + initial_length_size; + continue; + } if ((do_loc || do_debug_loc || do_debug_ranges) && num_debug_info_entries == 0 @@ -2437,21 +3113,22 @@ process_debug_info (struct dwarf_section *section, } } - if (cu_offset + compunit.cu_length + initial_length_size - > section->size) + sec_off = cu_offset + initial_length_size; + if (sec_off + compunit.cu_length < sec_off + || sec_off + compunit.cu_length > section->size) { - warn (_("Debug info is corrupted, length of CU at %s" - " extends beyond end of section (length = %s)\n"), - dwarf_vmatoa ("x", cu_offset), + warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"), + section->name, + (unsigned long) cu_offset, dwarf_vmatoa ("x", compunit.cu_length)); + num_units = unit; break; } + tags = hdrptr; start += compunit.cu_length + initial_length_size; - 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"), @@ -2459,6 +3136,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. */ @@ -2466,6 +3152,12 @@ process_debug_info (struct dwarf_section *section, warn (_("Debug info is corrupted, abbrev offset (%lx) is larger than abbrev section size (%lx)\n"), (unsigned long) compunit.cu_abbrev_offset, (unsigned long) abbrev_size); + /* PR 17531: file:4bcd9ce9. */ + else if ((abbrev_base + abbrev_size) + > debug_displays [abbrev_sec].section.size) + warn (_("Debug info is corrupted, abbrev size (%lx) is larger than abbrev section size (%lx)\n"), + (unsigned long) abbrev_base + abbrev_size, + (unsigned long) debug_displays [abbrev_sec].section.size); else process_abbrev_section (((unsigned char *) debug_displays [abbrev_sec].section.start @@ -2527,7 +3219,7 @@ process_debug_info (struct dwarf_section *section, } } if (dwarf_start_die != 0 && level < saved_level) - return 1; + return TRUE; continue; } @@ -2565,9 +3257,9 @@ process_debug_info (struct dwarf_section *section, printf ("\n"); fflush (stdout); } - warn (_("DIE at offset %lx refers to abbreviation number %lu which does not exist\n"), + warn (_("DIE at offset 0x%lx refers to abbreviation number %lu which does not exist\n"), die_offset, abbrev_number); - return 0; + return FALSE; } if (!do_loc && do_printing) @@ -2579,7 +3271,8 @@ process_debug_info (struct dwarf_section *section, need_base_address = 0; break; case DW_TAG_compile_unit: - need_base_address = 1; + need_base_address = 1; + need_dwo_info = do_loc; break; case DW_TAG_entry_point: case DW_TAG_subprogram: @@ -2589,38 +3282,64 @@ process_debug_info (struct dwarf_section *section, break; } + debug_info *debug_info_p = + (debug_information && unit < alloc_num_debug_info_entries) + ? debug_information + unit : NULL; + + assert (!debug_info_p + || (debug_info_p->num_loc_offsets + == debug_info_p->num_loc_views)); + for (attr = entry->first_attr; attr && attr->attribute; attr = attr->next) { - debug_info *arg; - if (! do_loc && do_printing) /* Show the offset from where the tag was extracted. */ printf (" <%lx>", (unsigned long)(tags - section_begin)); - - if (debug_information && unit < alloc_num_debug_info_entries) - arg = debug_information + unit; - else - arg = NULL; - tags = read_and_display_attr (attr->attribute, attr->form, + attr->implicit_const, tags, end, cu_offset, compunit.cu_pointer_size, offset_size, compunit.cu_version, - arg, + debug_info_p, do_loc || ! do_printing, section, this_set); } - if (entry->children) - ++level; - } + /* If a locview attribute appears before a location one, + make sure we don't associate it with an earlier + loclist. */ + if (debug_info_p) + switch (debug_info_p->num_loc_offsets - debug_info_p->num_loc_views) + { + case 1: + debug_info_p->loc_views [debug_info_p->num_loc_views] = vm1; + debug_info_p->num_loc_views++; + assert (debug_info_p->num_loc_views + == debug_info_p->num_loc_offsets); + break; + + case 0: + break; + + case -1: + warn(_("DIE has locviews without loclist\n")); + debug_info_p->num_loc_views--; + break; + + default: + assert (0); + } + + if (entry->children) + ++level; + } } /* Set num_debug_info_entries here so that it can be used to check if @@ -2629,7 +3348,7 @@ process_debug_info (struct dwarf_section *section, && num_debug_info_entries == 0 && ! do_types) { - if (num_units > alloc_num_debug_info_entries) + if (num_units > alloc_num_debug_info_entries) num_debug_info_entries = alloc_num_debug_info_entries; else num_debug_info_entries = num_units; @@ -2638,7 +3357,7 @@ process_debug_info (struct dwarf_section *section, if (!do_loc) printf ("\n"); - return 1; + return TRUE; } /* Locate and scan the .debug_info section in the file and record the pointer @@ -2650,11 +3369,6 @@ process_debug_info (struct dwarf_section *section, static unsigned int load_debug_info (void * file) { - /* Reset the last pointer size so that we can issue correct error - messages if we are displaying the contents of more than one section. */ - last_pointer_size = 0; - warned_about_missing_comp_units = FALSE; - /* If we have already tried and failed to load the .debug_info section then do not bother to repeat the task. */ if (num_debug_info_entries == DEBUG_INFO_UNAVAILABLE) @@ -2665,15 +3379,15 @@ 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)) + if (load_debug_section_with_follow (info, file) + && process_debug_info (&debug_displays [info].section, file, abbrev, TRUE, FALSE)) return num_debug_info_entries; - if (load_debug_section (info_dwo, file) + if (load_debug_section_with_follow (info_dwo, file) && process_debug_info (&debug_displays [info_dwo].section, file, - abbrev_dwo, 1, 0)) + abbrev_dwo, TRUE, FALSE)) return num_debug_info_entries; num_debug_info_entries = DEBUG_INFO_UNAVAILABLE; @@ -2693,8 +3407,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). */ @@ -2707,29 +3421,31 @@ 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; } if (linfo->li_length + initial_length_size > section->size) { - /* If the length is just a bias against the initial_length_size then - this means that the field has a relocation against it which has not - been applied. (Ie we are dealing with an object file, not a linked - binary). Do not complain but instead assume that the rest of the - section applies to this particular header. */ - if (linfo->li_length == - initial_length_size) + /* If the length field has a relocation against it, then we should + not complain if it is inaccurate (and probably negative). This + happens in object files when the .debug_line section is actually + 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) - linfo->li_offset_size)) { - linfo->li_length = section->size - initial_length_size; + linfo->li_length = (end - data) - initial_length_size; } else { - warn (_("The line info appears to be corrupt - the section is too small\n")); + warn (_("The length field (0x%lx) in the debug_line header is wrong - the section is too small\n"), + (long) linfo->li_length); return NULL; } } @@ -2739,13 +3455,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) @@ -2767,7 +3500,7 @@ read_debug_line_header (struct dwarf_section * section, SAFE_BYTE_GET_AND_INC (linfo->li_opcode_base, hdrptr, 1, end); * end_of_sequence = data + linfo->li_length + initial_length_size; - /* PR 17512: file:002-117414-0.004. */ + /* PR 17512: file:002-117414-0.004. */ if (* end_of_sequence > end) { warn (_("Line length %s extends beyond end of section\n"), @@ -2779,15 +3512,150 @@ 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, + bfd_boolean is_dir) +{ + 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) + { + if (is_dir) + warn (_("Corrupt directory format table entry\n")); + else + warn (_("Corrupt file name format table entry\n")); + return data; + } + } + + data_count = read_uleb128 (data, & bytes_read, end); + data += bytes_read; + if (data == end) + { + if (is_dir) + warn (_("Corrupt directory list\n")); + else + warn (_("Corrupt file name list\n")); + return data; + } + + if (data_count == 0) + { + if (is_dir) + printf (_("\n The Directory Table is empty.\n")); + else + printf (_("\n The File Name Table is empty.\n")); + return data; + } + + if (is_dir) + printf (_("\n The Directory Table (offset 0x%lx):\n"), + (long) (data - start)); + else + printf (_("\n The File Name Table (offset 0x%lx):\n"), + (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) + { + if (is_dir) + warn (_("Corrupt directory entries list\n")); + else + warn (_("Corrupt file name entries list\n")); + return data; + } + putchar ('\n'); + } + return data; +} + static int -display_debug_lines_raw (struct dwarf_section *section, - unsigned char *data, - unsigned char *end) +display_debug_lines_raw (struct dwarf_section * section, + unsigned char * data, + unsigned char * end, + void * file) { unsigned char *start = section->start; + int verbose_view = 0; - printf (_("Raw dump of debug contents of section %s:\n\n"), - section->name); + introduce (section, TRUE); while (data < end) { @@ -2795,7 +3663,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.") @@ -2819,7 +3686,7 @@ display_debug_lines_raw (struct dwarf_section *section, /* PR 17531: file: 0522b371. */ if (linfo.li_line_range == 0) { - warn (_("Partial .debug_line. section encountered without a prior full .debug_line section")); + warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n")); return 0; } reset_state_machine (linfo.li_default_is_stmt); @@ -2835,7 +3702,7 @@ display_debug_lines_raw (struct dwarf_section *section, printf (_(" Offset: 0x%lx\n"), (long)(data - start)); printf (_(" Length: %ld\n"), (long) linfo.li_length); printf (_(" DWARF Version: %d\n"), linfo.li_version); - printf (_(" Prologue Length: %d\n"), linfo.li_prologue_length); + printf (_(" Prologue Length: %d\n"), (int) linfo.li_prologue_length); printf (_(" Minimum Instruction Length: %d\n"), linfo.li_min_insn_length); if (linfo.li_version >= 4) printf (_(" Maximum Ops per Instruction: %d\n"), linfo.li_max_ops_per_insn); @@ -2850,7 +3717,7 @@ display_debug_lines_raw (struct dwarf_section *section, warn (_("Line range of 0 is invalid, using 1 instead\n")); linfo.li_line_range = 1; } - + reset_state_machine (linfo.li_default_is_stmt); /* Display the contents of the Opcodes table. */ @@ -2866,72 +3733,90 @@ display_debug_lines_raw (struct dwarf_section *section, printf (_("\n Opcodes:\n")); for (i = 1; i < linfo.li_opcode_base; i++) - printf (_(" Opcode %d has %d args\n"), i, standard_opcodes[i - 1]); + printf (ngettext (" Opcode %d has %d arg\n", + " Opcode %d has %d args\n", + standard_opcodes[i - 1]), + i, standard_opcodes[i - 1]); /* 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_with_follow (line_str, file); - while (data < end && *data != 0) + data = display_formatted_table (data, start, end, &linfo, section, + TRUE); + data = display_formatted_table (data, start, end, &linfo, section, + FALSE); + } + 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; } @@ -2962,30 +3847,45 @@ display_debug_lines_raw (struct dwarf_section *section, { uladv *= linfo.li_min_insn_length; state_machine_regs.address += uladv; + if (uladv) + state_machine_regs.view = 0; printf (_(" Special opcode %d: " - "advance Address by %s to 0x%s"), + "advance Address by %s to 0x%s%s"), op_code, dwarf_vmatoa ("u", uladv), - dwarf_vmatoa ("x", state_machine_regs.address)); + dwarf_vmatoa ("x", state_machine_regs.address), + verbose_view && uladv + ? _(" (reset view)") : ""); } else { - state_machine_regs.address - += ((state_machine_regs.op_index + uladv) + unsigned addrdelta + = ((state_machine_regs.op_index + uladv) / linfo.li_max_ops_per_insn) * linfo.li_min_insn_length; + + state_machine_regs.address += addrdelta; state_machine_regs.op_index = (state_machine_regs.op_index + uladv) % linfo.li_max_ops_per_insn; + if (addrdelta) + state_machine_regs.view = 0; printf (_(" Special opcode %d: " - "advance Address by %s to 0x%s[%d]"), + "advance Address by %s to 0x%s[%d]%s"), op_code, dwarf_vmatoa ("u", uladv), dwarf_vmatoa ("x", state_machine_regs.address), - state_machine_regs.op_index); + state_machine_regs.op_index, + verbose_view && addrdelta + ? _(" (reset view)") : ""); } adv = (op_code % linfo.li_line_range) + linfo.li_line_base; state_machine_regs.line += adv; - printf (_(" and Line by %s to %d\n"), + printf (_(" and Line by %s to %d"), dwarf_vmatoa ("d", adv), state_machine_regs.line); + if (verbose_view || state_machine_regs.view) + printf (_(" (view %u)\n"), state_machine_regs.view); + else + putchar ('\n'); + state_machine_regs.view++; } else switch (op_code) { @@ -2994,7 +3894,12 @@ display_debug_lines_raw (struct dwarf_section *section, break; case DW_LNS_copy: - printf (_(" Copy\n")); + printf (_(" Copy")); + if (verbose_view || state_machine_regs.view) + printf (_(" (view %u)\n"), state_machine_regs.view); + else + putchar ('\n'); + state_machine_regs.view++; break; case DW_LNS_advance_pc: @@ -3004,23 +3909,33 @@ display_debug_lines_raw (struct dwarf_section *section, { uladv *= linfo.li_min_insn_length; state_machine_regs.address += uladv; - printf (_(" Advance PC by %s to 0x%s\n"), + if (uladv) + state_machine_regs.view = 0; + printf (_(" Advance PC by %s to 0x%s%s\n"), dwarf_vmatoa ("u", uladv), - dwarf_vmatoa ("x", state_machine_regs.address)); + dwarf_vmatoa ("x", state_machine_regs.address), + verbose_view && uladv + ? _(" (reset view)") : ""); } else { - state_machine_regs.address - += ((state_machine_regs.op_index + uladv) - / linfo.li_max_ops_per_insn) + unsigned addrdelta + = ((state_machine_regs.op_index + uladv) + / linfo.li_max_ops_per_insn) * linfo.li_min_insn_length; + state_machine_regs.address + += addrdelta; state_machine_regs.op_index = (state_machine_regs.op_index + uladv) % linfo.li_max_ops_per_insn; - printf (_(" Advance PC by %s to 0x%s[%d]\n"), + if (addrdelta) + state_machine_regs.view = 0; + printf (_(" Advance PC by %s to 0x%s[%d]%s\n"), dwarf_vmatoa ("u", uladv), dwarf_vmatoa ("x", state_machine_regs.address), - state_machine_regs.op_index); + state_machine_regs.op_index, + verbose_view && addrdelta + ? _(" (reset view)") : ""); } break; @@ -3067,23 +3982,33 @@ display_debug_lines_raw (struct dwarf_section *section, { uladv *= linfo.li_min_insn_length; state_machine_regs.address += uladv; - printf (_(" Advance PC by constant %s to 0x%s\n"), + if (uladv) + state_machine_regs.view = 0; + printf (_(" Advance PC by constant %s to 0x%s%s\n"), dwarf_vmatoa ("u", uladv), - dwarf_vmatoa ("x", state_machine_regs.address)); + dwarf_vmatoa ("x", state_machine_regs.address), + verbose_view && uladv + ? _(" (reset view)") : ""); } else { - state_machine_regs.address - += ((state_machine_regs.op_index + uladv) - / linfo.li_max_ops_per_insn) + unsigned addrdelta + = ((state_machine_regs.op_index + uladv) + / linfo.li_max_ops_per_insn) * linfo.li_min_insn_length; + state_machine_regs.address + += addrdelta; state_machine_regs.op_index = (state_machine_regs.op_index + uladv) % linfo.li_max_ops_per_insn; - printf (_(" Advance PC by constant %s to 0x%s[%d]\n"), + if (addrdelta) + state_machine_regs.view = 0; + printf (_(" Advance PC by constant %s to 0x%s[%d]%s\n"), dwarf_vmatoa ("u", uladv), dwarf_vmatoa ("x", state_machine_regs.address), - state_machine_regs.op_index); + state_machine_regs.op_index, + verbose_view && addrdelta + ? _(" (reset view)") : ""); } break; @@ -3094,6 +4019,7 @@ display_debug_lines_raw (struct dwarf_section *section, printf (_(" Advance PC by fixed size amount %s to 0x%s\n"), dwarf_vmatoa ("u", uladv), dwarf_vmatoa ("x", state_machine_regs.address)); + /* Do NOT reset view. */ break; case DW_LNS_set_prologue_end: @@ -3143,14 +4069,14 @@ typedef struct /* Output a decoded representation of the .debug_line section. */ static int -display_debug_lines_decoded (struct dwarf_section *section, - unsigned char *data, - unsigned char *end) +display_debug_lines_decoded (struct dwarf_section * section, + unsigned char * data, + unsigned char * end, + void * fileptr) { static DWARF2_Internal_LineInfo saved_linfo; - printf (_("Decoded dump of debug contents of section %s:\n\n"), - section->name); + introduce (section, FALSE); while (data < end) { @@ -3162,13 +4088,13 @@ 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. These are full debug_line sections. */ && strcmp (section->name, ".debug_line.dwo") != 0) - { + { /* See comment in display_debug_lines_raw(). */ end_of_sequence = end; standard_opcodes = NULL; @@ -3176,13 +4102,13 @@ display_debug_lines_decoded (struct dwarf_section *section, /* PR 17531: file: 0522b371. */ if (linfo.li_line_range == 0) { - warn (_("Partial .debug_line. section encountered without a prior full .debug_line section")); + warn (_("Partial .debug_line. section encountered without a prior full .debug_line section\n")); return 0; } reset_state_machine (linfo.li_default_is_stmt); - } + } else - { + { unsigned char *hdrptr; if ((hdrptr = read_debug_line_header (section, data, end, & linfo, @@ -3202,117 +4128,328 @@ 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) { - unsigned char *ptr_directory_table = data; - - while (*data != 0) - { - data += strnlen ((char *) data, end - data) + 1; - n_directories++; - } - - /* 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++; - } + warn (_("opcode base of %d extends beyond end of section\n"), + linfo.li_opcode_base); + return 0; } - /* Skip the NUL at the end of the table. */ - data++; - /* Traverse the File Name table just to count the entries. */ - if (*data != 0) + if (linfo.li_version >= 5) { - unsigned char *ptr_file_name_table = data; + unsigned char *format_start, format_count, *format; + dwarf_vma formati, entryi; + unsigned int bytes_read; - while (*data != 0) - { - unsigned int bytes_read; + load_debug_section_with_follow (line_str, fileptr); - /* Skip Name, directory index, last modification time and length - of file. */ - data += strnlen ((char *) data, end - data) + 1; + /* 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) + { + warn (_("Corrupt directories list\n")); + break; + } + + directory_table = (unsigned char **) + xmalloc (n_directories * sizeof (unsigned char *)); + + for (entryi = 0; entryi < n_directories; entryi++) + { + unsigned char **pathp = &directory_table[entryi]; + + 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; + } + } + + /* Skip files 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_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; + } + + /* Go through the file table again to save the strings. */ + file_table = (File_Entry *) xmalloc (n_files * sizeof (File_Entry)); - printf (_("File name Line number Starting address\n")); + 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 View Stmt\n")); saved_linfo = linfo; } /* This loop iterates through the Dwarf Line Number Program. */ while (data < end_of_sequence) - { + { unsigned char op_code; - int adv; - unsigned long int uladv; - unsigned int bytes_read; - int is_special_opcode = 0; + int xop; + int adv; + unsigned long int uladv; + unsigned int bytes_read; + int is_special_opcode = 0; - op_code = *data++; + op_code = *data++; + xop = op_code; - if (op_code >= linfo.li_opcode_base) + if (op_code >= linfo.li_opcode_base) { op_code -= linfo.li_opcode_base; uladv = (op_code / linfo.li_line_range); @@ -3320,23 +4457,30 @@ display_debug_lines_decoded (struct dwarf_section *section, { uladv *= linfo.li_min_insn_length; state_machine_regs.address += uladv; + if (uladv) + state_machine_regs.view = 0; } else { - state_machine_regs.address - += ((state_machine_regs.op_index + uladv) - / linfo.li_max_ops_per_insn) + unsigned addrdelta + = ((state_machine_regs.op_index + uladv) + / linfo.li_max_ops_per_insn) * linfo.li_min_insn_length; + state_machine_regs.address + += addrdelta; state_machine_regs.op_index = (state_machine_regs.op_index + uladv) % linfo.li_max_ops_per_insn; + if (addrdelta) + state_machine_regs.view = 0; } - adv = (op_code % linfo.li_line_range) + linfo.li_line_base; - state_machine_regs.line += adv; - is_special_opcode = 1; - } - else switch (op_code) + adv = (op_code % linfo.li_line_range) + linfo.li_line_base; + state_machine_regs.line += adv; + is_special_opcode = 1; + /* Increment view after printing this row. */ + } + else switch (op_code) { case DW_LNS_extended_op: { @@ -3355,11 +4499,13 @@ display_debug_lines_decoded (struct dwarf_section *section, } ext_op_code_len += bytes_read; ext_op_code = *op_code_data++; + xop = ext_op_code; + xop = -xop; switch (ext_op_code) { case DW_LNE_end_sequence: - reset_state_machine (linfo.li_default_is_stmt); + /* Reset stuff after printing this row. */ break; case DW_LNE_set_address: SAFE_BYTE_GET_AND_INC (state_machine_regs.address, @@ -3367,6 +4513,7 @@ display_debug_lines_decoded (struct dwarf_section *section, ext_op_code_len - bytes_read - 1, end); state_machine_regs.op_index = 0; + state_machine_regs.view = 0; break; case DW_LNE_define_file: { @@ -3409,6 +4556,7 @@ display_debug_lines_decoded (struct dwarf_section *section, break; } case DW_LNS_copy: + /* Increment view after printing this row. */ break; case DW_LNS_advance_pc: @@ -3418,16 +4566,22 @@ display_debug_lines_decoded (struct dwarf_section *section, { uladv *= linfo.li_min_insn_length; state_machine_regs.address += uladv; + if (uladv) + state_machine_regs.view = 0; } else { - state_machine_regs.address - += ((state_machine_regs.op_index + uladv) - / linfo.li_max_ops_per_insn) + unsigned addrdelta + = ((state_machine_regs.op_index + uladv) + / linfo.li_max_ops_per_insn) * linfo.li_min_insn_length; + state_machine_regs.address + += addrdelta; state_machine_regs.op_index = (state_machine_regs.op_index + uladv) % linfo.li_max_ops_per_insn; + if (addrdelta) + state_machine_regs.view = 0; } break; @@ -3442,20 +4596,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: @@ -3480,16 +4650,22 @@ display_debug_lines_decoded (struct dwarf_section *section, { uladv *= linfo.li_min_insn_length; state_machine_regs.address += uladv; + if (uladv) + state_machine_regs.view = 0; } else { - state_machine_regs.address - += ((state_machine_regs.op_index + uladv) - / linfo.li_max_ops_per_insn) + unsigned addrdelta + = ((state_machine_regs.op_index + uladv) + / linfo.li_max_ops_per_insn) * linfo.li_min_insn_length; + state_machine_regs.address + += addrdelta; state_machine_regs.op_index = (state_machine_regs.op_index + uladv) % linfo.li_max_ops_per_insn; + if (addrdelta) + state_machine_regs.view = 0; } break; @@ -3497,6 +4673,7 @@ display_debug_lines_decoded (struct dwarf_section *section, SAFE_BYTE_GET_AND_INC (uladv, data, 2, end); state_machine_regs.address += uladv; state_machine_regs.op_index = 0; + /* Do NOT reset view. */ break; case DW_LNS_set_prologue_end: @@ -3526,68 +4703,92 @@ display_debug_lines_decoded (struct dwarf_section *section, break; } - /* Only Special opcodes, DW_LNS_copy and DW_LNE_end_sequence adds a row - to the DWARF address/line matrix. */ - if ((is_special_opcode) || (op_code == DW_LNE_end_sequence) - || (op_code == DW_LNS_copy)) - { - const unsigned int MAX_FILENAME_LENGTH = 35; - char *fileName; - char *newFileName = NULL; - size_t fileNameLength; + /* Only Special opcodes, DW_LNS_copy and DW_LNE_end_sequence adds a row + to the DWARF address/line matrix. */ + if ((is_special_opcode) || (xop == -DW_LNE_end_sequence) + || (xop == DW_LNS_copy)) + { + const unsigned int MAX_FILENAME_LENGTH = 35; + char *fileName; + char *newFileName = NULL; + 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); - if ((fileNameLength > MAX_FILENAME_LENGTH) && (!do_wide)) - { - newFileName = (char *) xmalloc (MAX_FILENAME_LENGTH + 1); - /* Truncate file name */ - strncpy (newFileName, - fileName + fileNameLength - MAX_FILENAME_LENGTH, - MAX_FILENAME_LENGTH + 1); - } - else - { - newFileName = (char *) xmalloc (fileNameLength + 1); - strncpy (newFileName, fileName, fileNameLength + 1); - } - - if (!do_wide || (fileNameLength <= MAX_FILENAME_LENGTH)) - { + if ((fileNameLength > MAX_FILENAME_LENGTH) && (!do_wide)) + { + newFileName = (char *) xmalloc (MAX_FILENAME_LENGTH + 1); + /* Truncate file name */ + strncpy (newFileName, + fileName + fileNameLength - MAX_FILENAME_LENGTH, + MAX_FILENAME_LENGTH + 1); + } + else + { + newFileName = (char *) xmalloc (fileNameLength + 1); + strncpy (newFileName, fileName, fileNameLength + 1); + } + + if (!do_wide || (fileNameLength <= MAX_FILENAME_LENGTH)) + { if (linfo.li_max_ops_per_insn == 1) - printf ("%-35s %11d %#18" DWARF_VMA_FMT "x\n", + printf ("%-35s %11d %#18" DWARF_VMA_FMT "x", newFileName, state_machine_regs.line, state_machine_regs.address); else - printf ("%-35s %11d %#18" DWARF_VMA_FMT "x[%d]\n", + printf ("%-35s %11d %#18" DWARF_VMA_FMT "x[%d]", newFileName, state_machine_regs.line, state_machine_regs.address, state_machine_regs.op_index); - } - else - { + } + else + { if (linfo.li_max_ops_per_insn == 1) - printf ("%s %11d %#18" DWARF_VMA_FMT "x\n", + printf ("%s %11d %#18" DWARF_VMA_FMT "x", newFileName, state_machine_regs.line, state_machine_regs.address); else - printf ("%s %11d %#18" DWARF_VMA_FMT "x[%d]\n", + printf ("%s %11d %#18" DWARF_VMA_FMT "x[%d]", newFileName, state_machine_regs.line, state_machine_regs.address, state_machine_regs.op_index); - } + } - if (op_code == DW_LNE_end_sequence) - printf ("\n"); + if (state_machine_regs.view) + printf (" %6u", state_machine_regs.view); + else + printf (" "); - free (newFileName); - } - } + if (state_machine_regs.is_stmt) + printf (" x"); + + putchar ('\n'); + state_machine_regs.view++; + + if (xop == -DW_LNE_end_sequence) + { + reset_state_machine (linfo.li_default_is_stmt); + putchar ('\n'); + } + + free (newFileName); + } + } if (file_table) { @@ -3610,7 +4811,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; @@ -3621,10 +4822,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; @@ -3679,20 +4880,18 @@ display_debug_pubnames_worker (struct dwarf_section *section, we test for that later on. */ load_debug_info (file); - printf (_("Contents of the %s section:\n\n"), section->name); + introduce (section, FALSE); while (start < end) { unsigned char *data; - unsigned long offset; + unsigned long sec_off; unsigned int offset_size, initial_length_size; - data = start; - - SAFE_BYTE_GET_AND_INC (names.pn_length, data, 4, end); + SAFE_BYTE_GET_AND_INC (names.pn_length, start, 4, end); if (names.pn_length == 0xffffffff) { - SAFE_BYTE_GET_AND_INC (names.pn_length, data, 8, end); + SAFE_BYTE_GET_AND_INC (names.pn_length, start, 8, end); offset_size = 8; initial_length_size = 12; } @@ -3702,6 +4901,20 @@ display_debug_pubnames_worker (struct dwarf_section *section, initial_length_size = 4; } + sec_off = start - section->start; + if (sec_off + names.pn_length < sec_off + || sec_off + names.pn_length > section->size) + { + warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"), + section->name, + sec_off - initial_length_size, + dwarf_vmatoa ("x", names.pn_length)); + break; + } + + data = start; + start += names.pn_length; + SAFE_BYTE_GET_AND_INC (names.pn_version, data, 2, end); SAFE_BYTE_GET_AND_INC (names.pn_offset, data, offset_size, end); @@ -3713,15 +4926,6 @@ display_debug_pubnames_worker (struct dwarf_section *section, SAFE_BYTE_GET_AND_INC (names.pn_size, data, offset_size, end); - /* PR 17531: file: 7615b6b2. */ - if ((dwarf_signed_vma) names.pn_length < 0) - { - warn (_("Negative length for public name: 0x%lx\n"), (long) names.pn_length); - start = end; - } - else - start += names.pn_length + initial_length_size; - printf (_(" Length: %ld\n"), (long) names.pn_length); printf (_(" Version: %d\n"), @@ -3749,50 +4953,51 @@ display_debug_pubnames_worker (struct dwarf_section *section, else printf (_("\n Offset\tName\n")); - do + while (1) { bfd_size_type maxprint; + dwarf_vma offset; SAFE_BYTE_GET (offset, data, offset_size, end); - if (offset != 0) + if (offset == 0) + break; + + data += offset_size; + if (data >= end) + break; + maxprint = (end - data) - 1; + + if (is_gnu) { - data += offset_size; - if (data >= end) - break; - maxprint = (end - data) - 1; - - if (is_gnu) - { - unsigned int kind_data; - gdb_index_symbol_kind kind; - const char *kind_name; - int is_static; - - SAFE_BYTE_GET (kind_data, data, 1, end); - data++; - maxprint --; - /* GCC computes the kind as the upper byte in the CU index - word, and then right shifts it by the CU index size. - Left shift KIND to where the gdb-index.h accessor macros - can use it. */ - kind_data <<= GDB_INDEX_CU_BITSIZE; - kind = GDB_INDEX_SYMBOL_KIND_VALUE (kind_data); - kind_name = get_gdb_index_symbol_kind_name (kind); - is_static = GDB_INDEX_SYMBOL_STATIC_VALUE (kind_data); - printf (" %-6lx %s,%-10s %.*s\n", - offset, is_static ? _("s") : _("g"), - kind_name, (int) maxprint, data); - } - else - printf (" %-6lx\t%.*s\n", offset, (int) maxprint, data); + unsigned int kind_data; + gdb_index_symbol_kind kind; + const char *kind_name; + int is_static; - data += strnlen ((char *) data, maxprint) + 1; - if (data >= end) - break; + SAFE_BYTE_GET (kind_data, data, 1, end); + data++; + maxprint --; + /* GCC computes the kind as the upper byte in the CU index + word, and then right shifts it by the CU index size. + Left shift KIND to where the gdb-index.h accessor macros + can use it. */ + kind_data <<= GDB_INDEX_CU_BITSIZE; + kind = GDB_INDEX_SYMBOL_KIND_VALUE (kind_data); + kind_name = get_gdb_index_symbol_kind_name (kind); + is_static = GDB_INDEX_SYMBOL_STATIC_VALUE (kind_data); + printf (" %-6lx %s,%-10s %.*s\n", + (unsigned long) offset, is_static ? _("s") : _("g"), + kind_name, (int) maxprint, data); } + else + printf (" %-6lx\t%.*s\n", + (unsigned long) offset, (int) maxprint, data); + + data += strnlen ((char *) data, maxprint) + 1; + if (data >= end) + break; } - while (offset != 0); } printf ("\n"); @@ -3821,7 +5026,7 @@ display_debug_macinfo (struct dwarf_section *section, unsigned int bytes_read; enum dwarf_macinfo_record_type op; - printf (_("Contents of the %s section:\n\n"), section->name); + introduce (section, FALSE); while (curr < end) { @@ -3925,7 +5130,8 @@ get_line_filename_and_dirname (dwarf_vma line_offset, offset_size = 4; initial_length_size = 4; } - if (length + initial_length_size > section->size) + if (length + initial_length_size < length + || length + initial_length_size > section->size) return NULL; SAFE_BYTE_GET_AND_INC (version, hdrptr, 2, end); @@ -3941,13 +5147,21 @@ get_line_filename_and_dirname (dwarf_vma line_offset, return NULL; hdrptr += opcode_base - 1; + if (hdrptr >= end) + return NULL; + dirtable = hdrptr; /* Skip over dirname table. */ while (*hdrptr != '\0') - hdrptr += strnlen ((char *) hdrptr, end - hdrptr) + 1; + { + hdrptr += strnlen ((char *) hdrptr, end - hdrptr) + 1; + if (hdrptr >= end) + return NULL; + } hdrptr++; /* Skip the NUL at the end of the table. */ + /* Now skip over preceding filename table entries. */ - for (; *hdrptr != '\0' && fileidx > 1; fileidx--) + for (; hdrptr < end && *hdrptr != '\0' && fileidx > 1; fileidx--) { hdrptr += strnlen ((char *) hdrptr, end - hdrptr) + 1; read_uleb128 (hdrptr, &bytes_read, end); @@ -3957,16 +5171,19 @@ get_line_filename_and_dirname (dwarf_vma line_offset, read_uleb128 (hdrptr, &bytes_read, end); hdrptr += bytes_read; } - if (hdrptr == end || *hdrptr == '\0') + if (hdrptr >= end || *hdrptr == '\0') return NULL; + file_name = hdrptr; hdrptr += strnlen ((char *) hdrptr, end - hdrptr) + 1; + if (hdrptr >= end) + return NULL; diridx = read_uleb128 (hdrptr, &bytes_read, end); if (diridx == 0) return file_name; - for (; *dirtable != '\0' && diridx > 1; diridx--) + for (; dirtable < end && *dirtable != '\0' && diridx > 1; diridx--) dirtable += strnlen ((char *) dirtable, end - dirtable) + 1; - if (*dirtable == '\0') + if (dirtable >= end || *dirtable == '\0') return NULL; *dir_name = dirtable; return file_name; @@ -3982,10 +5199,10 @@ display_debug_macro (struct dwarf_section *section, unsigned char *extended_op_buf[256]; unsigned int bytes_read; - load_debug_section (str, file); - load_debug_section (line, file); + load_debug_section_with_follow (str, file); + load_debug_section_with_follow (line, file); - printf (_("Contents of the %s section:\n\n"), section->name); + introduce (section, FALSE); while (curr < end) { @@ -3996,9 +5213,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; } @@ -4035,10 +5252,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; @@ -4091,7 +5308,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; @@ -4102,87 +5319,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; @@ -4201,20 +5418,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 (","); } @@ -4225,7 +5443,7 @@ display_debug_macro (struct dwarf_section *section, } printf ("\n"); - } + } return 1; } @@ -4238,7 +5456,7 @@ display_debug_abbrev (struct dwarf_section *section, unsigned char *start = section->start; unsigned char *end = start + section->size; - printf (_("Contents of the %s section:\n\n"), section->name); + introduce (section, FALSE); do { @@ -4264,9 +5482,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); @@ -4276,17 +5499,74 @@ 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 view pair list starting at *VSTART_PTR and ending at + VLISTEND within SECTION. */ + +static void +display_view_pair_list (struct dwarf_section *section, + unsigned char **vstart_ptr, + unsigned int debug_info_entry, + unsigned char *vlistend) +{ + unsigned char *vstart = *vstart_ptr; + unsigned char *section_end = section->start + section->size; + unsigned int pointer_size = debug_information [debug_info_entry].pointer_size; + + if (vlistend < section_end) + section_end = vlistend; + + putchar ('\n'); + + while (vstart < section_end) + { + dwarf_vma off = vstart - section->start; + dwarf_vma vbegin, vend; + + unsigned int bytes_read; + vbegin = read_uleb128 (vstart, &bytes_read, section_end); + vstart += bytes_read; + if (vstart == section_end) + { + vstart -= bytes_read; + break; + } + + vend = read_uleb128 (vstart, &bytes_read, section_end); + vstart += bytes_read; + + printf (" %8.8lx ", (unsigned long) off); + + print_dwarf_view (vbegin, pointer_size, 1); + print_dwarf_view (vend, pointer_size, 1); + printf (_("location view pair\n")); + } + + putchar ('\n'); + *vstart_ptr = vstart; +} + /* 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, - int has_frame_base) + unsigned char **start_ptr, + unsigned int debug_info_entry, + dwarf_vma offset, + dwarf_vma base_address, + unsigned char **vstart_ptr, + int has_frame_base) { - unsigned char *start = *start_ptr; + unsigned char *start = *start_ptr, *vstart = *vstart_ptr; unsigned char *section_end = section->start + section->size; unsigned long cu_offset; unsigned int pointer_size; @@ -4304,12 +5584,12 @@ display_loc_list (struct dwarf_section *section, 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"), @@ -4319,73 +5599,101 @@ display_loc_list (struct dwarf_section *section, while (1) { + dwarf_vma off = offset + (start - *start_ptr); + dwarf_vma vbegin = vm1, vend = vm1; + if (start + 2 * pointer_size > section_end) - { - warn (_("Location list starting at offset 0x%lx is not terminated.\n"), - offset); - break; - } - - printf (" %8.8lx ", offset + (start - *start_ptr)); - - /* 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. */ + { + 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) - { - printf (_("\n")); - break; - } + { + /* 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 (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; - } + 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 (vstart) + { + unsigned int bytes_read; + + off = offset + (vstart - *start_ptr); + + vbegin = read_uleb128 (vstart, &bytes_read, section_end); + vstart += bytes_read; + print_dwarf_view (vbegin, pointer_size, 1); + + vend = read_uleb128 (vstart, &bytes_read, section_end); + vstart += bytes_read; + print_dwarf_view (vend, pointer_size, 1); + + printf (_("views at %8.8lx for:\n %*s "), + (unsigned long) off, 8, ""); + } if (start + 2 > section_end) - { - warn (_("Location list starting at offset 0x%lx is not terminated.\n"), - offset); - break; - } + { + 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"), - offset); - break; - } + { + 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); + pointer_size, + offset_size, + dwarf_version, + length, + cu_offset, section); putchar (')'); if (need_frame_base && !has_frame_base) - printf (_(" [without DW_AT_frame_base]")); + printf (_(" [without DW_AT_frame_base]")); - if (begin == end) - fputs (_(" (start == end)"), stdout); - else if (begin > end) - fputs (_(" (start > end)"), stdout); + if (begin == end && vbegin == vend) + fputs (_(" (start == end)"), stdout); + else if (begin > end || (begin == end && vbegin > vend)) + fputs (_(" (start > end)"), stdout); putchar ('\n'); @@ -4393,31 +5701,194 @@ display_loc_list (struct dwarf_section *section, } *start_ptr = start; + *vstart_ptr = vstart; } -/* Print a .debug_addr table index in decimal, surrounded by square brackets, - right-adjusted in a field of length LEN, and followed by a space. */ +/* Display a location list from a normal (ie, non-dwo) .debug_loclists section. */ static void -print_addr_index (unsigned int idx, unsigned int len) +display_loclists_list (struct dwarf_section *section, + unsigned char **start_ptr, + unsigned int debug_info_entry, + dwarf_vma offset, + dwarf_vma base_address, + unsigned char **vstart_ptr, + int has_frame_base) { - static char buf[15]; - snprintf (buf, sizeof (buf), "[%d]", idx); - printf ("%*s ", len, buf); -} - + unsigned char *start = *start_ptr, *vstart = *vstart_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, vbegin = -1; + dwarf_vma end = -1, vend = -1; + dwarf_vma length; + int need_frame_base; + + if (debug_info_entry >= num_debug_info_entries) + { + warn (_("No debug information available for " + "loclists lists of entry: %u\n"), + debug_info_entry); + return; + } + + cu_offset = debug_information [debug_info_entry].cu_offset; + pointer_size = debug_information [debug_info_entry].pointer_size; + offset_size = debug_information [debug_info_entry].offset_size; + dwarf_version = debug_information [debug_info_entry].dwarf_version; + + if (pointer_size < 2 || pointer_size > 8) + { + warn (_("Invalid pointer size (%d) in debug info for entry %d\n"), + pointer_size, debug_info_entry); + return; + } + + while (1) + { + dwarf_vma off = offset + (start - *start_ptr); + enum dwarf_location_list_entry_type llet; + + if (start + 1 > section_end) + { + warn (_("Location list starting at offset 0x%lx is not terminated.\n"), + (unsigned long) offset); + break; + } + + printf (" %8.8lx ", (unsigned long) off); + + SAFE_BYTE_GET_AND_INC (llet, start, 1, section_end); + + if (vstart && llet == DW_LLE_offset_pair) + { + off = offset + (vstart - *start_ptr); + + vbegin = read_uleb128 (vstart, &bytes_read, section_end); + vstart += bytes_read; + print_dwarf_view (vbegin, pointer_size, 1); + + vend = read_uleb128 (vstart, &bytes_read, section_end); + vstart += bytes_read; + print_dwarf_view (vend, pointer_size, 1); + + printf (_("views at %8.8lx for:\n %*s "), + (unsigned long) off, 8, ""); + } + + switch (llet) + { + case DW_LLE_end_of_list: + printf (_("\n")); + break; + case DW_LLE_offset_pair: + begin = read_uleb128 (start, &bytes_read, section_end); + start += bytes_read; + end = read_uleb128 (start, &bytes_read, section_end); + start += bytes_read; + break; + case DW_LLE_base_address: + SAFE_BYTE_GET_AND_INC (base_address, start, pointer_size, + section_end); + print_dwarf_vma (base_address, pointer_size); + printf (_("(base address)\n")); + break; +#ifdef DW_LLE_view_pair + case DW_LLE_view_pair: + if (vstart) + printf (_("View pair entry in loclist with locviews attribute\n")); + vbegin = read_uleb128 (start, &bytes_read, section_end); + start += bytes_read; + print_dwarf_view (vbegin, pointer_size, 1); + + vend = read_uleb128 (start, &bytes_read, section_end); + start += bytes_read; + print_dwarf_view (vend, pointer_size, 1); + + printf (_("views for:\n")); + continue; +#endif + default: + error (_("Invalid location list entry type %d\n"), llet); + return; + } + if (llet == DW_LLE_end_of_list) + break; + if (llet != DW_LLE_offset_pair) + continue; + + if (start + 2 > section_end) + { + warn (_("Location list starting at offset 0x%lx is not terminated.\n"), + (unsigned long) offset); + break; + } + + length = read_uleb128 (start, &bytes_read, section_end); + start += bytes_read; + + print_dwarf_vma (begin + base_address, pointer_size); + print_dwarf_vma (end + base_address, pointer_size); + + putchar ('('); + need_frame_base = decode_location_expression (start, + pointer_size, + offset_size, + dwarf_version, + length, + cu_offset, section); + putchar (')'); + + if (need_frame_base && !has_frame_base) + printf (_(" [without DW_AT_frame_base]")); + + if (begin == end && vbegin == vend) + fputs (_(" (start == end)"), stdout); + else if (begin > end || (begin == end && vbegin > vend)) + fputs (_(" (start > end)"), stdout); + + putchar ('\n'); + + start += length; + vbegin = vend = -1; + } + + if (vbegin != vm1 || vend != vm1) + printf (_("Trailing view pair not used in a range")); + + *start_ptr = start; + *vstart_ptr = vstart; +} + +/* Print a .debug_addr table index in decimal, surrounded by square brackets, + right-adjusted in a field of length LEN, and followed by a space. */ + +static void +print_addr_index (unsigned int idx, unsigned int len) +{ + static char buf[15]; + snprintf (buf, sizeof (buf), "[%d]", idx); + printf ("%*s ", len, buf); +} + /* Display a location list from a .dwo section. It uses address indexes rather than embedded addresses. This code closely follows display_loc_list, but the two are sufficiently different that combining things is very ugly. */ static void display_loc_list_dwo (struct dwarf_section *section, - unsigned char **start_ptr, - unsigned int debug_info_entry, - unsigned long offset, - int has_frame_base) + unsigned char **start_ptr, + unsigned int debug_info_entry, + dwarf_vma offset, + unsigned char **vstart_ptr, + int has_frame_base) { - unsigned char *start = *start_ptr; + unsigned char *start = *start_ptr, *vstart = *vstart_ptr; unsigned char *section_end = section->start + section->size; unsigned long cu_offset; unsigned int pointer_size; @@ -4450,82 +5921,113 @@ 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); - break; - } + { + warn (_("Location list starting at offset 0x%lx is not terminated.\n"), + (unsigned long) offset); + break; + } SAFE_BYTE_GET_AND_INC (entry_type, start, 1, section_end); + + if (vstart) + switch (entry_type) + { + default: + break; + + case 2: + case 3: + case 4: + { + dwarf_vma view; + dwarf_vma off = offset + (vstart - *start_ptr); + + view = read_uleb128 (vstart, &bytes_read, section_end); + vstart += bytes_read; + print_dwarf_view (view, 8, 1); + + view = read_uleb128 (vstart, &bytes_read, section_end); + vstart += bytes_read; + print_dwarf_view (view, 8, 1); + + printf (_("views at %8.8lx for:\n %*s "), + (unsigned long) off, 8, ""); + + } + break; + } + switch (entry_type) - { - case 0: /* A terminating entry. */ - *start_ptr = start; - printf (_("\n")); - return; - case 1: /* A base-address entry. */ - idx = read_uleb128 (start, &bytes_read, section_end); - start += bytes_read; - print_addr_index (idx, 8); - printf (" "); - printf (_("(base address selection entry)\n")); - continue; - case 2: /* A start/end entry. */ - idx = read_uleb128 (start, &bytes_read, section_end); - start += bytes_read; - print_addr_index (idx, 8); - idx = read_uleb128 (start, &bytes_read, section_end); - start += bytes_read; - print_addr_index (idx, 8); - break; - case 3: /* A start/length entry. */ - idx = read_uleb128 (start, &bytes_read, section_end); - start += bytes_read; - print_addr_index (idx, 8); - SAFE_BYTE_GET_AND_INC (idx, start, 4, section_end); - printf ("%08x ", idx); - break; - case 4: /* An offset pair entry. */ - SAFE_BYTE_GET_AND_INC (idx, start, 4, section_end); - printf ("%08x ", idx); - SAFE_BYTE_GET_AND_INC (idx, start, 4, section_end); - printf ("%08x ", idx); - break; - default: - warn (_("Unknown location list entry type 0x%x.\n"), entry_type); - *start_ptr = start; - return; - } + { + case 0: /* A terminating entry. */ + *start_ptr = start; + *vstart_ptr = vstart; + printf (_("\n")); + return; + case 1: /* A base-address entry. */ + idx = read_uleb128 (start, &bytes_read, section_end); + start += bytes_read; + print_addr_index (idx, 8); + printf ("%*s", 9 + (vstart ? 2 * 6 : 0), ""); + printf (_("(base address selection entry)\n")); + continue; + case 2: /* A start/end entry. */ + idx = read_uleb128 (start, &bytes_read, section_end); + start += bytes_read; + print_addr_index (idx, 8); + idx = read_uleb128 (start, &bytes_read, section_end); + start += bytes_read; + print_addr_index (idx, 8); + break; + case 3: /* A start/length entry. */ + idx = read_uleb128 (start, &bytes_read, section_end); + start += bytes_read; + print_addr_index (idx, 8); + SAFE_BYTE_GET_AND_INC (idx, start, 4, section_end); + printf ("%08x ", idx); + break; + case 4: /* An offset pair entry. */ + SAFE_BYTE_GET_AND_INC (idx, start, 4, section_end); + printf ("%08x ", idx); + SAFE_BYTE_GET_AND_INC (idx, start, 4, section_end); + printf ("%08x ", idx); + break; + default: + warn (_("Unknown location list entry type 0x%x.\n"), entry_type); + *start_ptr = start; + *vstart_ptr = vstart; + return; + } if (start + 2 > section_end) - { - warn (_("Location list starting at offset 0x%lx is not terminated.\n"), - offset); - break; - } + { + 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"), - offset); - break; - } + { + warn (_("Location list starting at offset 0x%lx is not terminated.\n"), + (unsigned long) offset); + break; + } putchar ('('); need_frame_base = decode_location_expression (start, - pointer_size, - offset_size, - dwarf_version, - length, - cu_offset, section); + pointer_size, + offset_size, + dwarf_version, + length, + cu_offset, section); putchar (')'); if (need_frame_base && !has_frame_base) - printf (_(" [without DW_AT_frame_base]")); + printf (_(" [without DW_AT_frame_base]")); putchar ('\n'); @@ -4533,11 +6035,13 @@ display_loc_list_dwo (struct dwarf_section *section, } *start_ptr = start; + *vstart_ptr = vstart; } -/* Sort array of indexes in ascending order of loc_offsets[idx]. */ +/* Sort array of indexes in ascending order of loc_offsets[idx] and + loc_views. */ -static dwarf_vma *loc_offsets; +static dwarf_vma *loc_offsets, *loc_views; static int loc_offsets_compar (const void *ap, const void *bp) @@ -4545,30 +6049,41 @@ loc_offsets_compar (const void *ap, const void *bp) dwarf_vma a = loc_offsets[*(const unsigned int *) ap]; dwarf_vma b = loc_offsets[*(const unsigned int *) bp]; - return (a > b) - (b > a); + int ret = (a > b) - (b > a); + if (ret) + return ret; + + a = loc_views[*(const unsigned int *) ap]; + b = loc_views[*(const unsigned int *) bp]; + + ret = (a > b) - (b > a); + + return ret; } static int display_debug_loc (struct dwarf_section *section, void *file) { - unsigned char *start = section->start; + unsigned char *start = section->start, *vstart = NULL; unsigned long bytes; unsigned char *section_begin = start; unsigned int num_loc_list = 0; unsigned long last_offset = 0; + unsigned long last_view = 0; unsigned int first = 0; unsigned int i; unsigned int j; - unsigned int k; int seen_first_offset = 0; int locs_sorted = 1; - unsigned char *next; + unsigned char *next = start, *vnext = vstart; unsigned int *array = NULL; const char *suffix = strrchr (section->name, '.'); - int is_dwo = 0; + bfd_boolean is_dwo = FALSE; + int is_loclists = strstr (section->name, "debug_loclists") != NULL; + dwarf_vma expected_start = 0; if (suffix && strcmp (suffix, ".dwo") == 0) - is_dwo = 1; + is_dwo = TRUE; bytes = section->size; @@ -4578,6 +6093,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"), @@ -4603,6 +6163,7 @@ display_debug_loc (struct dwarf_section *section, void *file) { /* This is the first location list. */ last_offset = debug_information [i].loc_offsets [0]; + last_view = debug_information [i].loc_views [0]; first = i; seen_first_offset = 1; j = 1; @@ -4613,12 +6174,15 @@ display_debug_loc (struct dwarf_section *section, void *file) for (; j < num; j++) { if (last_offset > - debug_information [i].loc_offsets [j]) + debug_information [i].loc_offsets [j] + || (last_offset == debug_information [i].loc_offsets [j] + && last_view > debug_information [i].loc_views [j])) { locs_sorted = 0; break; } last_offset = debug_information [i].loc_offsets [j]; + last_view = debug_information [i].loc_views [j]; } } } @@ -4627,21 +6191,28 @@ 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 + && debug_information [first].loc_views [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])); if (!locs_sorted) array = (unsigned int *) xcmalloc (num_loc_list, sizeof (unsigned int)); - printf (_("Contents of the %s section:\n\n"), section->name); - printf (_(" Offset Begin End Expression\n")); + + introduce (section, FALSE); + + if (reloc_at (section, 0)) + printf (_(" Warning: This section has relocations - addresses seen here may not be accurate.\n\n")); + + printf (_(" Offset Begin End Expression\n")); seen_first_offset = 0; for (i = first; i < num_debug_info_entries; i++) { - unsigned long offset; - unsigned long base_address; + dwarf_vma offset, voffset; + dwarf_vma base_address; + unsigned int k; int has_frame_base; if (!locs_sorted) @@ -4649,55 +6220,112 @@ display_debug_loc (struct dwarf_section *section, void *file) for (k = 0; k < debug_information [i].num_loc_offsets; k++) array[k] = k; loc_offsets = debug_information [i].loc_offsets; + loc_views = debug_information [i].loc_views; qsort (array, debug_information [i].num_loc_offsets, sizeof (*array), loc_offsets_compar); } + int adjacent_view_loclists = 1; for (k = 0; k < debug_information [i].num_loc_offsets; k++) { j = locs_sorted ? k : array[k]; if (k - && debug_information [i].loc_offsets [locs_sorted + && (debug_information [i].loc_offsets [locs_sorted ? k - 1 : array [k - 1]] - == debug_information [i].loc_offsets [j]) + == debug_information [i].loc_offsets [j]) + && (debug_information [i].loc_views [locs_sorted + ? k - 1 : array [k - 1]] + == debug_information [i].loc_views [j])) continue; has_frame_base = debug_information [i].have_frame_base [j]; offset = debug_information [i].loc_offsets [j]; next = section_begin + offset; + voffset = debug_information [i].loc_views [j]; + if (voffset != vm1) + vnext = section_begin + voffset; + else + vnext = NULL; base_address = debug_information [i].base_address; - if (!seen_first_offset) + if (vnext && vnext < next) + { + vstart = vnext; + display_view_pair_list (section, &vstart, i, next); + if (start == vnext) + start = vstart; + } + + if (!seen_first_offset || !adjacent_view_loclists) seen_first_offset = 1; else { if (start < next) warn (_("There is a hole [0x%lx - 0x%lx] in .debug_loc section.\n"), (unsigned long) (start - section_begin), - (unsigned long) (next - section_begin)); + (unsigned long) offset); else if (start > next) warn (_("There is an overlap [0x%lx - 0x%lx] in .debug_loc section.\n"), (unsigned long) (start - section_begin), - (unsigned long) (next - section_begin)); + (unsigned long) offset); } start = next; + vstart = vnext; 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); - else - display_loc_list (section, &start, i, offset, base_address, - has_frame_base); + if (vnext && voffset >= bytes) + { + warn (_("View Offset 0x%lx is bigger than .debug_loc section size.\n"), + (unsigned long) voffset); + continue; + } + + if (!is_loclists) + { + if (is_dwo) + display_loc_list_dwo (section, &start, i, offset, + &vstart, has_frame_base); + else + display_loc_list (section, &start, i, offset, base_address, + &vstart, has_frame_base); + } + else + { + if (is_dwo) + warn (_("DWO is not yet supported.\n")); + else + display_loclists_list (section, &start, i, offset, base_address, + &vstart, has_frame_base); + } + + /* FIXME: this arrangement is quite simplistic. Nothing + requires locview lists to be adjacent to corresponding + loclists, and a single loclist could be augmented by + different locview lists, and vice-versa, unlikely as it + is that it would make sense to do so. Hopefully we'll + have view pair support built into loclists before we ever + need to address all these possibilities. */ + if (adjacent_view_loclists && vnext + && vnext != start && vstart != next) + { + adjacent_view_loclists = 0; + warn (_("Hole and overlap detection requires adjacent view lists and loclists.\n")); + } + + if (vnext && vnext == start) + display_view_pair_list (section, &start, i, vstart); } } if (start < section->start + section->size) - warn (_("There are %ld unused bytes at the end of section %s\n"), + warn (ngettext ("There is %ld unused byte at the end of section %s\n", + "There are %ld unused bytes at the end of section %s\n", + (long) (section->start + section->size - start)), (long) (section->start + section->size - start), section->name); putchar ('\n'); free (array); @@ -4718,7 +6346,7 @@ display_debug_str (struct dwarf_section *section, return 0; } - printf (_("Contents of the %s section:\n\n"), section->name); + introduce (section, FALSE); while (bytes) { @@ -4765,19 +6393,19 @@ display_debug_str (struct dwarf_section *section, static int display_debug_info (struct dwarf_section *section, void *file) { - return process_debug_info (section, file, section->abbrev_sec, 0, 0); + return process_debug_info (section, file, section->abbrev_sec, FALSE, FALSE); } static int display_debug_types (struct dwarf_section *section, void *file) { - return process_debug_info (section, file, section->abbrev_sec, 0, 1); + return process_debug_info (section, file, section->abbrev_sec, FALSE, TRUE); } static int display_trace_info (struct dwarf_section *section, void *file) { - return process_debug_info (section, file, section->abbrev_sec, 0, 0); + return process_debug_info (section, file, section->abbrev_sec, FALSE, TRUE); } static int @@ -4787,7 +6415,7 @@ display_debug_aranges (struct dwarf_section *section, unsigned char *start = section->start; unsigned char *end = start + section->size; - printf (_("Contents of the %s section:\n\n"), section->name); + introduce (section, FALSE); /* It does not matter if this load fails, we test for that later on. */ @@ -4800,6 +6428,7 @@ display_debug_aranges (struct dwarf_section *section, unsigned char *addr_ranges; dwarf_vma length; dwarf_vma address; + unsigned long sec_off; unsigned char address_size; int excess; unsigned int offset_size; @@ -4820,6 +6449,17 @@ display_debug_aranges (struct dwarf_section *section, initial_length_size = 4; } + sec_off = hdrptr - section->start; + if (sec_off + arange.ar_length < sec_off + || sec_off + arange.ar_length > section->size) + { + warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"), + section->name, + sec_off - initial_length_size, + dwarf_vmatoa ("x", arange.ar_length)); + break; + } + SAFE_BYTE_GET_AND_INC (arange.ar_version, hdrptr, 2, end); SAFE_BYTE_GET_AND_INC (arange.ar_info_offset, hdrptr, offset_size, end); @@ -4834,7 +6474,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; } @@ -4900,15 +6545,15 @@ display_debug_aranges (struct dwarf_section *section, static int comp_addr_base (const void * v0, const void * v1) { - debug_info * info0 = (debug_info *) v0; - debug_info * info1 = (debug_info *) v1; + debug_info *info0 = *(debug_info **) v0; + debug_info *info1 = *(debug_info **) v1; return info0->addr_base - info1->addr_base; } /* Display the debug_addr section. */ static int display_debug_addr (struct dwarf_section *section, - void *file) + void *file) { debug_info **debug_addr_info; unsigned char *entry; @@ -4929,42 +6574,53 @@ display_debug_addr (struct dwarf_section *section, return 0; } - printf (_("Contents of the %s section:\n\n"), section->name); + introduce (section, FALSE); - debug_addr_info = (debug_info **) xmalloc ((num_debug_info_entries + 1) - * sizeof (debug_info *)); + /* PR 17531: file: cf38d01b. + We use xcalloc because a corrupt file may not have initialised all of the + fields in the debug_info structure, which means that the sort below might + try to move uninitialised data. */ + debug_addr_info = (debug_info **) xcalloc ((num_debug_info_entries + 1), + sizeof (debug_info *)); count = 0; for (i = 0; i < num_debug_info_entries; i++) if (debug_information [i].addr_base != DEBUG_INFO_UNAVAILABLE) - debug_addr_info [count++] = debug_information + i; + { + /* PR 17531: file: cf38d01b. */ + if (debug_information[i].addr_base >= section->size) + warn (_("Corrupt address base (%lx) found in debug section %u\n"), + (unsigned long) debug_information[i].addr_base, i); + else + debug_addr_info [count++] = debug_information + i; + } /* Add a sentinel to make iteration convenient. */ debug_addr_info [count] = (debug_info *) xmalloc (sizeof (debug_info)); debug_addr_info [count]->addr_base = section->size; - qsort (debug_addr_info, count, sizeof (debug_info *), comp_addr_base); + for (i = 0; i < count; i++) { unsigned int idx; unsigned int address_size = debug_addr_info [i]->pointer_size; printf (_(" For compilation unit at offset 0x%s:\n"), - dwarf_vmatoa ("x", debug_addr_info [i]->cu_offset)); + dwarf_vmatoa ("x", debug_addr_info [i]->cu_offset)); printf (_("\tIndex\tAddress\n")); entry = section->start + debug_addr_info [i]->addr_base; end = section->start + debug_addr_info [i + 1]->addr_base; idx = 0; while (entry < end) - { - dwarf_vma base = byte_get (entry, address_size); - printf (_("\t%d:\t"), idx); - print_dwarf_vma (base, address_size); - printf ("\n"); - entry += address_size; - idx++; - } + { + dwarf_vma base = byte_get (entry, address_size); + printf (_("\t%d:\t"), idx); + print_dwarf_vma (base, address_size); + printf ("\n"); + entry += address_size; + idx++; + } } printf ("\n"); @@ -4973,9 +6629,10 @@ display_debug_addr (struct dwarf_section *section, } /* Display the .debug_str_offsets and .debug_str_offsets.dwo sections. */ + static int display_debug_str_offsets (struct dwarf_section *section, - void *file ATTRIBUTE_UNUSED) + void *file ATTRIBUTE_UNUSED) { if (section->size == 0) { @@ -4993,7 +6650,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; @@ -5006,12 +6663,133 @@ 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) @@ -5023,6 +6801,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) { @@ -5030,6 +6811,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"), @@ -5044,7 +6897,7 @@ display_debug_ranges (struct dwarf_section *section, if (num_range_list == 0) { /* This can happen when the file was compiled with -gsplit-debug - which removes references to range lists from the primary .o file. */ + which removes references to range lists from the primary .o file. */ printf (_("No range lists in .debug_info section.\n")); return 1; } @@ -5071,9 +6924,10 @@ 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); + + introduce (section, FALSE); - printf (_("Contents of the %s section:\n\n"), section->name); printf (_(" Offset Begin End\n")); for (i = 0; i < num_range_list; i++) @@ -5081,11 +6935,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; @@ -5094,10 +6948,17 @@ 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; } - + + if (next < section_begin || next >= finish) + { + warn (_("Corrupt offset (%#8.8lx) in range entry %u\n"), + (unsigned long) offset, i); + continue; + } + if (dwarf_check != 0 && i > 0) { if (start < next) @@ -5113,52 +6974,12 @@ display_debug_ranges (struct dwarf_section *section, (unsigned long) (next - section_begin), section->name); } } + 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'); @@ -5180,8 +7001,8 @@ typedef struct Frame_Chunk int data_factor; dwarf_vma pc_begin; dwarf_vma pc_range; - int cfa_reg; - int cfa_offset; + unsigned int cfa_reg; + dwarf_vma cfa_offset; unsigned int ra; unsigned char fde_encoding; unsigned char cfa_exp; @@ -5229,9 +7050,9 @@ frame_need_space (Frame_Chunk *fc, unsigned int reg) } fc->col_type = (short int *) xcrealloc (fc->col_type, fc->ncols, - sizeof (short int)); + sizeof (short int)); fc->col_offset = (int *) xcrealloc (fc->col_offset, fc->ncols, sizeof (int)); - /* PR 17512: file:002-10025-0.005. */ + /* PR 17512: file:002-10025-0.005. */ if (fc->col_type == NULL || fc->col_offset == NULL) { error (_("Out of memory allocating %u columns in dwarf frame arrays\n"), @@ -5273,6 +7094,27 @@ static const char *const dwarf_regnames_i386[] = "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7" /* 93 - 100 */ }; +static const char *const dwarf_regnames_iamcu[] = +{ + "eax", "ecx", "edx", "ebx", /* 0 - 3 */ + "esp", "ebp", "esi", "edi", /* 4 - 7 */ + "eip", "eflags", NULL, /* 8 - 10 */ + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 11 - 18 */ + NULL, NULL, /* 19 - 20 */ + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 21 - 28 */ + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 29 - 36 */ + NULL, NULL, NULL, /* 37 - 39 */ + "es", "cs", "ss", "ds", "fs", "gs", NULL, NULL, /* 40 - 47 */ + "tr", "ldtr", /* 48 - 49 */ + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 50 - 57 */ + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 58 - 65 */ + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 66 - 73 */ + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 74 - 81 */ + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 82 - 89 */ + NULL, NULL, NULL, /* 90 - 92 */ + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL /* 93 - 100 */ +}; + void init_dwarf_regnames_i386 (void) { @@ -5280,6 +7122,13 @@ init_dwarf_regnames_i386 (void) dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_i386); } +void +init_dwarf_regnames_iamcu (void) +{ + dwarf_regnames = dwarf_regnames_iamcu; + dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_iamcu); +} + static const char *const dwarf_regnames_x86_64[] = { "rax", "rdx", "rcx", "rbx", @@ -5321,18 +7170,22 @@ init_dwarf_regnames_x86_64 (void) static const char *const dwarf_regnames_aarch64[] = { - "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7", - "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15", + "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7", + "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15", "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23", "x24", "x25", "x26", "x27", "x28", "x29", "x30", "sp", NULL, "elr", NULL, NULL, NULL, NULL, NULL, NULL, - NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, - NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, - NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, - "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7", - "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15", + NULL, NULL, NULL, NULL, NULL, NULL, "vg", "ffr", + "p0", "p1", "p2", "p3", "p4", "p5", "p6", "p7", + "p8", "p9", "p10", "p11", "p12", "p13", "p14", "p15", + "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7", + "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15", "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23", "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31", + "z0", "z1", "z2", "z3", "z4", "z5", "z6", "z7", + "z8", "z9", "z10", "z11", "z12", "z13", "z14", "z15", + "z16", "z17", "z18", "z19", "z20", "z21", "z22", "z23", + "z24", "z25", "z26", "z27", "z28", "z29", "z30", "z31", }; void @@ -5342,16 +7195,64 @@ 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); +} + +static const char *const dwarf_regnames_riscv[] = +{ + "zero", "ra", "sp", "gp", "tp", "t0", "t1", "t2", /* 0 - 7 */ + "s0", "s1", "a0", "a1", "a2", "a3", "a4", "a5", /* 8 - 15 */ + "a6", "a7", "s2", "s3", "s4", "s5", "s6", "s7", /* 16 - 23 */ + "s8", "s9", "s10", "s11", "t3", "t4", "t5", "t6", /* 24 - 31 */ + "ft0", "ft1", "ft2", "ft3", "ft4", "ft5", "ft6", "ft7", /* 32 - 39 */ + "fs0", "fs1", /* 40 - 41 */ + "fa0", "fa1", "fa2", "fa3", "fa4", "fa5", "fa6", "fa7", /* 42 - 49 */ + "fs2", "fs3", "fs4", "fs5", "fs6", "fs7", "fs8", "fs9", /* 50 - 57 */ + "fs10", "fs11", /* 58 - 59 */ + "ft8", "ft9", "ft10", "ft11" /* 60 - 63 */ +}; + +void +init_dwarf_regnames_riscv (void) +{ + dwarf_regnames = dwarf_regnames_riscv; + dwarf_regnames_count = ARRAY_SIZE (dwarf_regnames_riscv); +} + void init_dwarf_regnames (unsigned int e_machine) { switch (e_machine) { case EM_386: - case EM_486: init_dwarf_regnames_i386 (); break; + case EM_IAMCU: + init_dwarf_regnames_iamcu (); + break; + case EM_X86_64: case EM_L1OM: case EM_K1OM: @@ -5362,6 +7263,14 @@ init_dwarf_regnames (unsigned int e_machine) init_dwarf_regnames_aarch64 (); break; + case EM_S390: + init_dwarf_regnames_s390 (); + break; + + case EM_RISCV: + init_dwarf_regnames_riscv (); + break; + default: break; } @@ -5371,6 +7280,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) @@ -5391,7 +7301,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) @@ -5406,7 +7316,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)); } @@ -5418,7 +7328,7 @@ frame_display_row (Frame_Chunk *fc, int *need_col_headers, unsigned int *max_reg if (fc->cfa_exp) strcpy (tmp, "exp"); else - sprintf (tmp, "%s%+d", regname (fc->cfa_reg, 1), fc->cfa_offset); + sprintf (tmp, "%s%+d", regname (fc->cfa_reg, 1), (int) fc->cfa_offset); printf ("%-8s ", tmp); for (r = 0; r < fc->ncols; r++) @@ -5459,19 +7369,17 @@ 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, Frame_Chunk **p_cie, int *p_version, - unsigned long *p_aug_len, unsigned char **p_aug) + bfd_size_type *p_aug_len, unsigned char **p_aug) { int version; Frame_Chunk *fc; unsigned int length_return; unsigned char *augmentation_data = NULL; - unsigned long augmentation_data_len = 0; + bfd_size_type augmentation_data_len = 0; * p_cie = NULL; /* PR 17512: file: 001-228113-0.004. */ @@ -5495,7 +7403,7 @@ read_cie (unsigned char *start, unsigned char *end, if (start == end) { warn (_("No terminator for augmentation name\n")); - return start; + goto fail; } if (strcmp (fc->augmentation, "eh") == 0) @@ -5504,7 +7412,20 @@ read_cie (unsigned char *start, unsigned char *end, if (version >= 4) { GET (fc->ptr_size, 1); + if (fc->ptr_size < 1 || fc->ptr_size > 8) + { + warn (_("Invalid pointer size (%d) in CIE data\n"), fc->ptr_size); + goto fail; + } + GET (fc->segment_size, 1); + /* PR 17512: file: e99d2804. */ + if (fc->segment_size > 8 || fc->segment_size + fc->ptr_size > 8) + { + warn (_("Invalid segment size (%d) in CIE data\n"), fc->segment_size); + goto fail; + } + eh_addr_size = fc->ptr_size; } else @@ -5512,28 +7433,32 @@ 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) + if (augmentation_data_len > (bfd_size_type) (end - start)) { - warn (_("Augmentation data too long: 0x%lx"), augmentation_data_len); - return end; + warn (_("Augmentation data too long: 0x%s, expected at most %#lx\n"), + dwarf_vmatoa ("x", augmentation_data_len), + (unsigned long) (end - start)); + goto fail; } + start += augmentation_data_len; } if (augmentation_data_len) @@ -5541,19 +7466,12 @@ read_cie (unsigned char *start, unsigned char *end, unsigned char *p; unsigned char *q; unsigned char *qend; - + p = (unsigned char *) fc->augmentation + 1; q = augmentation_data; qend = q + augmentation_data_len; - /* PR 17531: file: 015adfaa. */ - if (qend < q) - { - warn (_("Negative augmentation data length: 0x%lx"), augmentation_data_len); - augmentation_data_len = 0; - } - - while (p < end && q < augmentation_data + augmentation_data_len) + while (p < end && q < qend) { if (*p == 'L') q++; @@ -5563,6 +7481,8 @@ read_cie (unsigned char *start, unsigned char *end, fc->fde_encoding = *q++; else if (*p == 'S') ; + else if (*p == 'B') + ; else break; p++; @@ -5580,6 +7500,48 @@ read_cie (unsigned char *start, unsigned char *end, *p_aug = augmentation_data; } return start; + + fail: + free (fc->col_offset); + free (fc->col_type); + free (fc); + return end; +} + +/* Prints out the contents on the DATA array formatted as unsigned bytes. + If do_wide is not enabled, then formats the output to fit into 80 columns. + PRINTED contains the number of characters already written to the current + output line. */ + +static void +display_data (bfd_size_type printed, + const unsigned char * data, + const bfd_size_type len) +{ + if (do_wide || len < ((80 - printed) / 3)) + for (printed = 0; printed < len; ++printed) + printf (" %02x", data[printed]); + else + { + for (printed = 0; printed < len; ++printed) + { + if (printed % (80 / 3) == 0) + putchar ('\n'); + printf (" %02x", data[printed]); + } + } +} + +/* Prints out the contents on the augmentation data array. + If do_wide is not enabled, then formats the output to fit into 80 columns. */ + +static void +display_augmentation_data (const unsigned char * data, const bfd_size_type len) +{ + bfd_size_type i; + + i = printf (_(" Augmentation data: ")); + display_data (i, data, len); } static int @@ -5589,16 +7551,16 @@ display_debug_frames (struct dwarf_section *section, unsigned char *start = section->start; unsigned char *end = start + section->size; unsigned char *section_start = start; - Frame_Chunk *chunks = 0, *forward_refs = 0; - Frame_Chunk *remembered_state = 0; + Frame_Chunk *chunks = NULL, *forward_refs = NULL; + Frame_Chunk *remembered_state = NULL; Frame_Chunk *rs; - int is_eh = strcmp (section->name, ".eh_frame") == 0; + bfd_boolean is_eh = strcmp (section->name, ".eh_frame") == 0; unsigned int length_return; unsigned int max_regs = 0; const char *bad_reg = _("bad register: "); - int saved_eh_addr_size = eh_addr_size; + unsigned int saved_eh_addr_size = eh_addr_size; - printf (_("Contents of the %s section:\n"), section->name); + introduce (section, FALSE); while (start < end) { @@ -5610,10 +7572,11 @@ display_debug_frames (struct dwarf_section *section, Frame_Chunk *cie; int need_col_headers = 1; unsigned char *augmentation_data = NULL; - unsigned long augmentation_data_len = 0; + bfd_size_type augmentation_data_len = 0; 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; @@ -5703,16 +7666,8 @@ display_debug_frames (struct dwarf_section *section, printf (" Return address column: %d\n", fc->ra); if (augmentation_data_len) - { - unsigned long i; + display_augmentation_data (augmentation_data, augmentation_data_len); - printf (" Augmentation data: "); - for (i = 0; i < augmentation_data_len; ++i) - /* FIXME: If do_wide is FALSE, then we should - add carriage returns at 80 columns... */ - printf (" %02x", augmentation_data[i]); - putchar ('\n'); - } putchar ('\n'); } } @@ -5845,7 +7800,15 @@ display_debug_frames (struct dwarf_section *section, segment_selector = 0; if (fc->segment_size) - SAFE_BYTE_GET_AND_INC (segment_selector, start, fc->segment_size, end); + { + if (fc->segment_size > sizeof (segment_selector)) + { + /* PR 17512: file: 9e196b3e. */ + warn (_("Probably corrupt segment size: %d - using 4 instead\n"), fc->segment_size); + fc->segment_size = 4; + } + SAFE_BYTE_GET_AND_INC (segment_selector, start, fc->segment_size, end); + } fc->pc_begin = get_encoded_value (&start, fc->fde_encoding, section, end); @@ -5857,14 +7820,16 @@ 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. */ - if (start >= end || ((signed long) augmentation_data_len) < 0) + /* PR 17512 file: 722-8446-0.004 and PR 22386. */ + if (start >= end + || ((bfd_signed_vma) augmentation_data_len) < 0 + || augmentation_data > start) { - warn (_("Corrupt augmentation data length: %lx\n"), - augmentation_data_len); + warn (_("Corrupt augmentation data length: 0x%s\n"), + dwarf_vmatoa ("x", augmentation_data_len)); start = end; augmentation_data = NULL; augmentation_data_len = 0; @@ -5886,12 +7851,7 @@ display_debug_frames (struct dwarf_section *section, if (! do_debug_frames_interp && augmentation_data_len) { - unsigned long i; - - printf (" Augmentation data: "); - for (i = 0; i < augmentation_data_len; ++i) - printf (" %02x", augmentation_data[i]); - putchar ('\n'); + display_augmentation_data (augmentation_data, augmentation_data_len); putchar ('\n'); } } @@ -5913,6 +7873,7 @@ display_debug_frames (struct dwarf_section *section, { unsigned int reg, op, opa; unsigned long temp; + unsigned char * new_start; op = *start++; opa = op & 0x3f; @@ -5926,7 +7887,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; @@ -5948,84 +7909,92 @@ 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 (); - if (start + temp < start) + READ_ULEB (temp); + new_start = start + temp; + if (new_start < start) { warn (_("Corrupt CFA_def expression value: %lu\n"), temp); start = block_end; } else - start += temp; + start = new_start; break; case DW_CFA_expression: case DW_CFA_val_expression: - reg = LEB (); - temp = LEB (); - if (start + temp < start) + READ_ULEB (reg); + READ_ULEB (temp); + new_start = start + temp; + if (new_start < start) { - /* PR 17512: file:306-192417-0.005. */ + /* PR 17512: file:306-192417-0.005. */ warn (_("Corrupt CFA expression value: %lu\n"), temp); start = block_end; } else - start += temp; + start = new_start; if (frame_need_space (fc, reg) >= 0) fc->col_type[reg] = DW_CFA_undefined; 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; @@ -6036,14 +8005,21 @@ 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. */ while (start < block_end) { + unsigned char * tmp; unsigned op, opa; - unsigned long ul, reg, roffs; - long 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 = ""; @@ -6053,6 +8029,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) @@ -6063,14 +8043,14 @@ display_debug_frames (struct dwarf_section *section, else printf (" DW_CFA_advance_loc: %d to %s\n", opa * fc->code_factor, - dwarf_vmatoa_1 (NULL, + dwarf_vmatoa_1 (NULL, fc->pc_begin + opa * fc->code_factor, fc->ptr_size)); fc->pc_begin += opa * fc->code_factor; 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') @@ -6085,19 +8065,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; @@ -6151,8 +8137,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') @@ -6167,12 +8153,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') @@ -6183,14 +8169,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]; @@ -6198,7 +8191,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') @@ -6212,7 +8205,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') @@ -6226,8 +8219,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') @@ -6247,13 +8240,13 @@ display_debug_frames (struct dwarf_section *section, if (! do_debug_frames_interp) printf (" DW_CFA_remember_state\n"); rs = (Frame_Chunk *) xmalloc (sizeof (Frame_Chunk)); - rs->cfa_offset = fc->cfa_offset; + rs->cfa_offset = fc->cfa_offset; rs->cfa_reg = fc->cfa_reg; rs->ra = fc->ra; rs->cfa_exp = fc->cfa_exp; rs->ncols = fc->ncols; rs->col_type = (short int *) xcmalloc (rs->ncols, - sizeof (* rs->col_type)); + sizeof (* rs->col_type)); rs->col_offset = (int *) xcmalloc (rs->ncols, sizeof (* rs->col_offset)); memcpy (rs->col_type, fc->col_type, rs->ncols * sizeof (* fc->col_type)); memcpy (rs->col_offset, fc->col_offset, rs->ncols * sizeof (* fc->col_offset)); @@ -6270,11 +8263,11 @@ display_debug_frames (struct dwarf_section *section, remembered_state = rs->next; fc->cfa_offset = rs->cfa_offset; fc->cfa_reg = rs->cfa_reg; - fc->ra = rs->ra; - fc->cfa_exp = rs->cfa_exp; + fc->ra = rs->ra; + fc->cfa_exp = rs->cfa_exp; if (frame_need_space (fc, rs->ncols - 1) < 0) { - warn (_("Invalid column number in saved frame state")); + warn (_("Invalid column number in saved frame state\n")); fc->ncols = 0; break; } @@ -6290,16 +8283,16 @@ display_debug_frames (struct dwarf_section *section, break; case DW_CFA_def_cfa: - fc->cfa_reg = LEB (); - fc->cfa_offset = LEB (); + READ_ULEB (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", - regname (fc->cfa_reg, 0), fc->cfa_offset); + regname (fc->cfa_reg, 0), (int) fc->cfa_offset); break; case DW_CFA_def_cfa_register: - fc->cfa_reg = LEB (); + READ_ULEB (fc->cfa_reg); fc->cfa_exp = 0; if (! do_debug_frames_interp) printf (" DW_CFA_def_cfa_register: %s\n", @@ -6307,9 +8300,9 @@ 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", fc->cfa_offset); + printf (" DW_CFA_def_cfa_offset: %d\n", (int) fc->cfa_offset); break; case DW_CFA_nop: @@ -6318,8 +8311,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; @@ -6336,13 +8329,14 @@ 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. */ /* PR 17512: file: 98c02eb4. */ - if (start >= block_end || start + ul > block_end || start + ul < start) + tmp = start + ul; + if (start >= block_end || tmp > block_end || tmp < start) { printf (_(" DW_CFA_expression: \n"), ul); break; @@ -6357,15 +8351,16 @@ display_debug_frames (struct dwarf_section *section, } if (*reg_prefix == '\0') fc->col_type[reg] = DW_CFA_expression; - start += ul; + start = tmp; 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; - if (start >= block_end || start + ul > block_end || start + ul < start) + tmp = start + ul; + if (start >= block_end || tmp > block_end || tmp < start) { printf (" DW_CFA_val_expression: \n", ul); break; @@ -6380,18 +8375,18 @@ display_debug_frames (struct dwarf_section *section, } if (*reg_prefix == '\0') fc->col_type[reg] = DW_CFA_val_expression; - start += ul; + start = tmp; 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') printf (" DW_CFA_offset_extended_sf: %s%s at cfa%+ld\n", reg_prefix, regname (reg, 0), - l * fc->data_factor); + (long)(l * fc->data_factor)); if (*reg_prefix == '\0') { fc->col_type[reg] = DW_CFA_offset; @@ -6400,14 +8395,14 @@ 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), - l * fc->data_factor); + (long)(l * fc->data_factor)); if (*reg_prefix == '\0') { fc->col_type[reg] = DW_CFA_val_offset; @@ -6416,20 +8411,20 @@ display_debug_frames (struct dwarf_section *section, break; case DW_CFA_def_cfa_sf: - fc->cfa_reg = LEB (); - fc->cfa_offset = SLEB (); + READ_ULEB (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) printf (" DW_CFA_def_cfa_sf: %s ofs %d\n", - regname (fc->cfa_reg, 0), fc->cfa_offset); + regname (fc->cfa_reg, 0), (int) fc->cfa_offset); break; case DW_CFA_def_cfa_offset_sf: - fc->cfa_offset = SLEB (); - fc->cfa_offset = fc->cfa_offset * fc->data_factor; + 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", fc->cfa_offset); + printf (" DW_CFA_def_cfa_offset_sf: %d\n", (int) fc->cfa_offset); break; case DW_CFA_MIPS_advance_loc8: @@ -6451,20 +8446,21 @@ 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') printf (" DW_CFA_GNU_negative_offset_extended: %s%s at cfa%+ld\n", reg_prefix, regname (reg, 0), - l * fc->data_factor); + (long)(l * fc->data_factor)); if (*reg_prefix == '\0') { fc->col_type[reg] = DW_CFA_offset; @@ -6481,22 +8477,493 @@ display_debug_frames (struct dwarf_section *section, } } - if (do_debug_frames_interp) - frame_display_row (fc, &need_col_headers, &max_regs); + /* 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; + eh_addr_size = saved_eh_addr_size; + } + + printf ("\n"); + + while (remembered_state != NULL) + { + rs = remembered_state; + remembered_state = rs->next; + free (rs->col_type); + free (rs->col_offset); + rs->next = NULL; /* Paranoia. */ + free (rs); + } + + while (chunks != NULL) + { + rs = chunks; + chunks = rs->next; + free (rs->col_type); + free (rs->col_offset); + rs->next = NULL; /* Paranoia. */ + free (rs); + } + + while (forward_refs != NULL) + { + rs = forward_refs; + forward_refs = rs->next; + free (rs->col_type); + free (rs->col_offset); + rs->next = NULL; /* Paranoia. */ + free (rs); + } + + return 1; +} + +#undef GET + +static int +display_debug_names (struct dwarf_section *section, void *file) +{ + unsigned char *hdrptr = section->start; + dwarf_vma unit_length; + unsigned char *unit_start; + const unsigned char *const section_end = section->start + section->size; + unsigned char *unit_end; + + introduce (section, FALSE); + + load_debug_section_with_follow (str, file); + + for (; hdrptr < section_end; hdrptr = unit_end) + { + unsigned int offset_size; + uint16_t dwarf_version, padding; + uint32_t comp_unit_count, local_type_unit_count, foreign_type_unit_count; + uint32_t bucket_count, name_count, abbrev_table_size; + uint32_t augmentation_string_size; + unsigned int i; + unsigned long sec_off; + bfd_boolean augmentation_printable; + const char *augmentation_string; + + unit_start = hdrptr; + + /* Get and check the length of the block. */ + SAFE_BYTE_GET_AND_INC (unit_length, hdrptr, 4, section_end); + + if (unit_length == 0xffffffff) + { + /* This section is 64-bit DWARF. */ + SAFE_BYTE_GET_AND_INC (unit_length, hdrptr, 8, section_end); + offset_size = 8; + } + else + offset_size = 4; + unit_end = hdrptr + unit_length; + + sec_off = hdrptr - section->start; + if (sec_off + unit_length < sec_off + || sec_off + unit_length > section->size) + { + warn (_("Debug info is corrupted, %s header at %#lx has length %s\n"), + section->name, + (unsigned long) (unit_start - section->start), + dwarf_vmatoa ("x", unit_length)); + return 0; + } + + /* Get and check the version number. */ + SAFE_BYTE_GET_AND_INC (dwarf_version, hdrptr, 2, unit_end); + printf (_("Version %ld\n"), (long) dwarf_version); + + /* Prior versions did not exist, and future versions may not be + backwards compatible. */ + if (dwarf_version != 5) + { + warn (_("Only DWARF version 5 .debug_names " + "is currently supported.\n")); + return 0; + } + + SAFE_BYTE_GET_AND_INC (padding, hdrptr, 2, unit_end); + if (padding != 0) + warn (_("Padding field of .debug_names must be 0 (found 0x%x)\n"), + padding); + + SAFE_BYTE_GET_AND_INC (comp_unit_count, hdrptr, 4, unit_end); + if (comp_unit_count == 0) + warn (_("Compilation unit count must be >= 1 in .debug_names\n")); + + SAFE_BYTE_GET_AND_INC (local_type_unit_count, hdrptr, 4, unit_end); + SAFE_BYTE_GET_AND_INC (foreign_type_unit_count, hdrptr, 4, unit_end); + SAFE_BYTE_GET_AND_INC (bucket_count, hdrptr, 4, unit_end); + SAFE_BYTE_GET_AND_INC (name_count, hdrptr, 4, unit_end); + SAFE_BYTE_GET_AND_INC (abbrev_table_size, hdrptr, 4, unit_end); + + SAFE_BYTE_GET_AND_INC (augmentation_string_size, hdrptr, 4, unit_end); + if (augmentation_string_size % 4 != 0) + { + warn (_("Augmentation string length %u must be rounded up " + "to a multiple of 4 in .debug_names.\n"), + augmentation_string_size); + augmentation_string_size += (-augmentation_string_size) & 3; + } + + printf (_("Augmentation string:")); + + augmentation_printable = TRUE; + augmentation_string = (const char *) hdrptr; + + for (i = 0; i < augmentation_string_size; i++) + { + unsigned char uc; + + SAFE_BYTE_GET_AND_INC (uc, hdrptr, 1, unit_end); + printf (" %02x", uc); + + if (uc != 0 && !ISPRINT (uc)) + augmentation_printable = FALSE; + } + + if (augmentation_printable) + { + printf (" (\""); + for (i = 0; + i < augmentation_string_size && augmentation_string[i]; + ++i) + putchar (augmentation_string[i]); + printf ("\")"); + } + putchar ('\n'); + + printf (_("CU table:\n")); + for (i = 0; i < comp_unit_count; i++) + { + uint64_t cu_offset; + + SAFE_BYTE_GET_AND_INC (cu_offset, hdrptr, offset_size, unit_end); + printf (_("[%3u] 0x%lx\n"), i, (unsigned long) cu_offset); + } + putchar ('\n'); + + printf (_("TU table:\n")); + for (i = 0; i < local_type_unit_count; i++) + { + uint64_t tu_offset; + + SAFE_BYTE_GET_AND_INC (tu_offset, hdrptr, offset_size, unit_end); + printf (_("[%3u] 0x%lx\n"), i, (unsigned long) tu_offset); + } + putchar ('\n'); + + printf (_("Foreign TU table:\n")); + for (i = 0; i < foreign_type_unit_count; i++) + { + uint64_t signature; + + SAFE_BYTE_GET_AND_INC (signature, hdrptr, 8, unit_end); + printf (_("[%3u] "), i); + print_dwarf_vma (signature, 8); + putchar ('\n'); + } + putchar ('\n'); + + const uint32_t *const hash_table_buckets = (uint32_t *) hdrptr; + hdrptr += bucket_count * sizeof (uint32_t); + const uint32_t *const hash_table_hashes = (uint32_t *) hdrptr; + hdrptr += name_count * sizeof (uint32_t); + unsigned char *const name_table_string_offsets = hdrptr; + hdrptr += name_count * offset_size; + unsigned char *const name_table_entry_offsets = hdrptr; + hdrptr += name_count * offset_size; + unsigned char *const abbrev_table = hdrptr; + hdrptr += abbrev_table_size; + const unsigned char *const abbrev_table_end = hdrptr; + unsigned char *const entry_pool = hdrptr; + if (hdrptr > unit_end) + { + warn (_("Entry pool offset (0x%lx) exceeds unit size 0x%lx " + "for unit 0x%lx in the debug_names\n"), + (long) (hdrptr - section->start), + (long) (unit_end - section->start), + (long) (unit_start - section->start)); + return 0; + } + + size_t buckets_filled = 0; + size_t bucketi; + for (bucketi = 0; bucketi < bucket_count; bucketi++) + { + const uint32_t bucket = hash_table_buckets[bucketi]; + + if (bucket != 0) + ++buckets_filled; + } + printf (ngettext ("Used %zu of %lu bucket.\n", + "Used %zu of %lu buckets.\n", + bucket_count), + buckets_filled, (unsigned long) bucket_count); + + uint32_t hash_prev = 0; + size_t hash_clash_count = 0; + size_t longest_clash = 0; + size_t this_length = 0; + size_t hashi; + for (hashi = 0; hashi < name_count; hashi++) + { + const uint32_t hash_this = hash_table_hashes[hashi]; + + if (hashi > 0) + { + if (hash_prev % bucket_count == hash_this % bucket_count) + { + ++hash_clash_count; + ++this_length; + longest_clash = MAX (longest_clash, this_length); + } + else + this_length = 0; + } + hash_prev = hash_this; + } + printf (_("Out of %lu items there are %zu bucket clashes" + " (longest of %zu entries).\n"), + (unsigned long) name_count, hash_clash_count, longest_clash); + assert (name_count == buckets_filled + hash_clash_count); + + struct abbrev_lookup_entry + { + dwarf_vma abbrev_tag; + unsigned char *abbrev_lookup_ptr; + }; + struct abbrev_lookup_entry *abbrev_lookup = NULL; + size_t abbrev_lookup_used = 0; + size_t abbrev_lookup_allocated = 0; + + unsigned char *abbrevptr = abbrev_table; + for (;;) + { + unsigned int bytes_read; + const dwarf_vma abbrev_tag = read_uleb128 (abbrevptr, &bytes_read, + abbrev_table_end); + abbrevptr += bytes_read; + if (abbrev_tag == 0) + break; + if (abbrev_lookup_used == abbrev_lookup_allocated) + { + abbrev_lookup_allocated = MAX (0x100, + abbrev_lookup_allocated * 2); + abbrev_lookup = xrealloc (abbrev_lookup, + (abbrev_lookup_allocated + * sizeof (*abbrev_lookup))); + } + assert (abbrev_lookup_used < abbrev_lookup_allocated); + struct abbrev_lookup_entry *entry; + for (entry = abbrev_lookup; + entry < abbrev_lookup + abbrev_lookup_used; + entry++) + if (entry->abbrev_tag == abbrev_tag) + { + warn (_("Duplicate abbreviation tag %lu " + "in unit 0x%lx in the debug_names\n"), + (long) abbrev_tag, (long) (unit_start - section->start)); + break; + } + entry = &abbrev_lookup[abbrev_lookup_used++]; + entry->abbrev_tag = abbrev_tag; + entry->abbrev_lookup_ptr = abbrevptr; + + /* Skip DWARF tag. */ + read_uleb128 (abbrevptr, &bytes_read, abbrev_table_end); + abbrevptr += bytes_read; + for (;;) + { + const dwarf_vma xindex = read_uleb128 (abbrevptr, + &bytes_read, + abbrev_table_end); + abbrevptr += bytes_read; + const dwarf_vma form = read_uleb128 (abbrevptr, &bytes_read, + abbrev_table_end); + abbrevptr += bytes_read; + if (xindex == 0 && form == 0) + break; + } + } + + printf (_("\nSymbol table:\n")); + uint32_t namei; + for (namei = 0; namei < name_count; ++namei) + { + uint64_t string_offset, entry_offset; + + SAFE_BYTE_GET (string_offset, + name_table_string_offsets + namei * offset_size, + offset_size, unit_end); + SAFE_BYTE_GET (entry_offset, + name_table_entry_offsets + namei * offset_size, + offset_size, unit_end); + + printf ("[%3u] #%08x %s:", namei, hash_table_hashes[namei], + fetch_indirect_string (string_offset)); + + unsigned char *entryptr = entry_pool + entry_offset; + + // We need to scan first whether there is a single or multiple + // entries. TAGNO is -2 for the first entry, it is -1 for the + // initial tag read of the second entry, then it becomes 0 for the + // first entry for real printing etc. + int tagno = -2; + /* Initialize it due to a false compiler warning. */ + dwarf_vma second_abbrev_tag = -1; + for (;;) + { + unsigned int bytes_read; + const dwarf_vma abbrev_tag = read_uleb128 (entryptr, &bytes_read, + unit_end); + entryptr += bytes_read; + if (tagno == -1) + { + second_abbrev_tag = abbrev_tag; + tagno = 0; + entryptr = entry_pool + entry_offset; + continue; + } + if (abbrev_tag == 0) + break; + if (tagno >= 0) + printf ("%s<%lu>", + (tagno == 0 && second_abbrev_tag == 0 ? " " : "\n\t"), + (unsigned long) abbrev_tag); + + const struct abbrev_lookup_entry *entry; + for (entry = abbrev_lookup; + entry < abbrev_lookup + abbrev_lookup_used; + entry++) + if (entry->abbrev_tag == abbrev_tag) + break; + if (entry >= abbrev_lookup + abbrev_lookup_used) + { + warn (_("Undefined abbreviation tag %lu " + "in unit 0x%lx in the debug_names\n"), + (long) abbrev_tag, + (long) (unit_start - section->start)); + break; + } + abbrevptr = entry->abbrev_lookup_ptr; + const dwarf_vma dwarf_tag = read_uleb128 (abbrevptr, &bytes_read, + abbrev_table_end); + abbrevptr += bytes_read; + if (tagno >= 0) + printf (" %s", get_TAG_name (dwarf_tag)); + for (;;) + { + const dwarf_vma xindex = read_uleb128 (abbrevptr, + &bytes_read, + abbrev_table_end); + abbrevptr += bytes_read; + const dwarf_vma form = read_uleb128 (abbrevptr, &bytes_read, + abbrev_table_end); + abbrevptr += bytes_read; + if (xindex == 0 && form == 0) + break; + + if (tagno >= 0) + printf (" %s", get_IDX_name (xindex)); + entryptr = read_and_display_attr_value (0, form, 0, entryptr, + unit_end, 0, 0, + offset_size, + dwarf_version, NULL, + (tagno < 0), NULL, + NULL, '='); + } + ++tagno; + } + if (tagno <= 0) + printf (_(" ")); + putchar ('\n'); + } + + free (abbrev_lookup); + } + + return 1; +} + +static int +display_debug_links (struct dwarf_section * section, + void * file ATTRIBUTE_UNUSED) +{ + const unsigned char * filename; + unsigned int filelen; + + introduce (section, FALSE); + + /* The .gnu_debuglink section is formatted as: + (c-string) Filename. + (padding) If needed to reach a 4 byte boundary. + (uint32_t) CRC32 value. + + The .gun_debugaltlink section is formatted as: + (c-string) Filename. + (binary) Build-ID. */ + + filename = section->start; + filelen = strnlen ((const char *) filename, section->size); + if (filelen == section->size) + { + warn (_("The debuglink filename is corrupt/missing\n")); + return 0; + } + + printf (_(" Separate debug info file: %s\n"), filename); + + if (const_strneq (section->name, ".gnu_debuglink")) + { + unsigned int crc32; + unsigned int crc_offset; + + crc_offset = filelen + 1; + crc_offset = (crc_offset + 3) & ~3; + if (crc_offset + 4 > section->size) + { + warn (_("CRC offset missing/truncated\n")); + return 0; + } + + crc32 = byte_get (filename + crc_offset, 4); - start = block_end; - eh_addr_size = saved_eh_addr_size; + printf (_(" CRC value: %#x\n"), crc32); + + if (crc_offset + 4 < section->size) + { + warn (_("There are %#lx extraneous bytes at the end of the section\n"), + (long)(section->size - (crc_offset + 4))); + return 0; + } } + else /* const_strneq (section->name, ".gnu_debugaltlink") */ + { + const unsigned char * build_id = section->start + filelen + 1; + bfd_size_type build_id_len = section->size - (filelen + 1); + bfd_size_type printed; - printf ("\n"); + /* FIXME: Should we support smaller build-id notes ? */ + if (build_id_len < 0x14) + { + warn (_("Build-ID is too short (%#lx bytes)\n"), (long) build_id_len); + return 0; + } + + printed = printf (_(" Build-ID (%#lx bytes):"), (long) build_id_len); + display_data (printed, build_id, build_id_len); + putchar ('\n'); + } + putchar ('\n'); return 1; } -#undef GET -#undef LEB -#undef SLEB - static int display_gdb_index (struct dwarf_section *section, void *file ATTRIBUTE_UNUSED) @@ -6513,7 +8980,7 @@ display_gdb_index (struct dwarf_section *section, /* The documentation for the format of this file is in gdb/dwarf2read.c. */ - printf (_("Contents of the %s section:\n"), section->name); + introduce (section, FALSE); if (section->size < 6 * sizeof (uint32_t)) { @@ -6582,7 +9049,7 @@ display_gdb_index (struct dwarf_section *section, /* PR 17531: file: 18a47d3d. */ if (symbol_table_offset < address_table_offset) { - warn (_("Symbol table offset (%xl) is less then Address table offset (%x)\n"), + warn (_("Symbol table offset (%x) is less then Address table offset (%x)\n"), symbol_table_offset, address_table_offset); return 0; } @@ -6604,12 +9071,12 @@ 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. %x"), address_table_size); + warn (_("Address table extends beyond end of section.\n")); return 0; } - + printf (_("\nCU table:\n")); for (i = 0; i < cu_list_elements; i += 2) { @@ -6659,10 +9126,11 @@ display_gdb_index (struct dwarf_section *section, || cu_vector_offset != 0) { unsigned int j; + unsigned char * adr; + adr = constant_pool + name_offset; /* PR 17531: file: 5b7b07ad. */ - if (constant_pool + name_offset < constant_pool - || constant_pool + name_offset >= section->start + section->size) + if (adr < constant_pool || adr >= section->start + section->size) { printf (_("[%3u] "), i, name_offset); warn (_("Corrupt name offset of 0x%x found for symbol table slot %d\n"), @@ -6673,20 +9141,21 @@ display_gdb_index (struct dwarf_section *section, (int) (section->size - (constant_pool_offset + name_offset)), constant_pool + name_offset); - if (constant_pool + cu_vector_offset < constant_pool - || constant_pool + cu_vector_offset >= section->start + section->size) + adr = constant_pool + cu_vector_offset; + if (adr < constant_pool || adr >= section->start + section->size - 3) { printf (_("\n"), cu_vector_offset); warn (_("Corrupt CU vector offset of 0x%x found for symbol table slot %d\n"), cu_vector_offset, i); continue; } - else - num_cus = byte_get_little_endian (constant_pool + cu_vector_offset, 4); + num_cus = byte_get_little_endian (adr, 4); + + adr = constant_pool + cu_vector_offset + 4 + num_cus * 4; if (num_cus * 4 < num_cus - || constant_pool + cu_vector_offset + 4 + num_cus * 4 >= - section->start + section->size) + || adr >= section->start + section->size + || adr < constant_pool) { printf ("\n", num_cus); warn (_("Invalid number of CUs (0x%x) for symbol table slot %d\n"), @@ -6696,6 +9165,7 @@ display_gdb_index (struct dwarf_section *section, if (num_cus > 1) printf ("\n"); + for (j = 0; j < num_cus; ++j) { int is_static; @@ -6794,7 +9264,7 @@ get_DW_SECT_short_name (unsigned int dw_sect) case DW_SECT_MACRO: return "macro"; default: - break; + break; } snprintf (buf, sizeof (buf), "%d", dw_sect); @@ -6832,7 +9302,7 @@ process_cu_tu_index (struct dwarf_section *section, int do_display) /* PR 17512: file: 002-376-0.004. */ if (section->size < 24) { - warn (_("Section %s is too small to contain a CU/TU header"), + warn (_("Section %s is too small to contain a CU/TU header\n"), section->name); return 0; } @@ -6844,22 +9314,29 @@ process_cu_tu_index (struct dwarf_section *section, int do_display) SAFE_BYTE_GET (nslots, phdr + 12, 4, limit); phash = phdr + 16; - pindex = phash + nslots * 8; - ppool = pindex + nslots * 4; + pindex = phash + (size_t) nslots * 8; + ppool = pindex + (size_t) nslots * 4; if (do_display) { - printf (_("Contents of the %s section:\n\n"), section->name); - printf (_(" Version: %d\n"), version); + introduce (section, FALSE); + + printf (_(" Version: %u\n"), version); if (version >= 2) - printf (_(" Number of columns: %d\n"), ncols); - printf (_(" Number of used entries: %d\n"), nused); - printf (_(" Number of slots: %d\n\n"), nslots); + printf (_(" Number of columns: %u\n"), ncols); + printf (_(" Number of used entries: %u\n"), nused); + printf (_(" Number of slots: %u\n\n"), nslots); } - if (ppool > limit) + /* PR 17531: file: 45d69832. */ + if ((size_t) nslots * 8 / 8 != nslots + || phash < phdr || phash > limit + || pindex < phash || pindex > limit + || ppool < pindex || ppool > limit) { - warn (_("Section %s too small for %d hash table entries\n"), + warn (ngettext ("Section %s is too small for %u slot\n", + "Section %s is too small for %u slots\n", + nslots), section->name, nslots); return 0; } @@ -6878,6 +9355,13 @@ process_cu_tu_index (struct dwarf_section *section, int do_display) { SAFE_BYTE_GET (j, pindex, 4, limit); shndx_list = ppool + j * 4; + /* PR 17531: file: 705e010d. */ + if (shndx_list < ppool) + { + warn (_("Section index pool located before start of section\n")); + return 0; + } + if (do_display) printf (_(" [%3d] Signature: 0x%s Sections: "), i, dwarf_vmatoa64 (signature_high, signature_low, @@ -6914,9 +9398,9 @@ process_cu_tu_index (struct dwarf_section *section, int do_display) unsigned int dw_sect; unsigned char *ph = phash; unsigned char *pi = pindex; - unsigned char *poffsets = ppool + ncols * 4; - unsigned char *psizes = poffsets + nused * ncols * 4; - unsigned char *pend = psizes + nused * ncols * 4; + unsigned char *poffsets = ppool + (size_t) ncols * 4; + unsigned char *psizes = poffsets + (size_t) nused * ncols * 4; + unsigned char *pend = psizes + (size_t) nused * ncols * 4; bfd_boolean is_tu_index; struct cu_tu_set *this_set = NULL; unsigned int row; @@ -6924,7 +9408,14 @@ process_cu_tu_index (struct dwarf_section *section, int do_display) is_tu_index = strcmp (section->name, ".debug_tu_index") == 0; - if (pend > limit) + /* PR 17531: file: 0dd159bf. + Check for integer overflow (can occur when size_t is 32-bit) + with overlarge ncols or nused values. */ + if ((size_t) ncols * 4 / 4 != ncols + || (size_t) nused * ncols * 4 / ((size_t) ncols * 4) != nused + || poffsets < ppool || poffsets > limit + || psizes < poffsets || psizes > limit + || pend < psizes || pend > limit) { warn (_("Section %s too small for offset and size tables\n"), section->name); @@ -6942,13 +9433,13 @@ process_cu_tu_index (struct dwarf_section *section, int do_display) if (is_tu_index) { tu_count = nused; - tu_sets = xcmalloc (nused, sizeof (struct cu_tu_set)); + tu_sets = xcalloc2 (nused, sizeof (struct cu_tu_set)); this_set = tu_sets; } else { cu_count = nused; - cu_sets = xcmalloc (nused, sizeof (struct cu_tu_set)); + cu_sets = xcalloc2 (nused, sizeof (struct cu_tu_set)); this_set = cu_sets; } } @@ -6979,9 +9470,27 @@ process_cu_tu_index (struct dwarf_section *section, int do_display) } if (!do_display) - memcpy (&this_set[row - 1].signature, ph, sizeof (uint64_t)); + { + size_t num_copy = sizeof (uint64_t); + + /* PR 23064: Beware of buffer overflow. */ + if (ph + num_copy < limit) + memcpy (&this_set[row - 1].signature, ph, num_copy); + else + { + warn (_("Signature (%p) extends beyond end of space in section\n"), ph); + return 0; + } + } prow = poffsets + (row - 1) * ncols * 4; + /* PR 17531: file: b8ce60a8. */ + if (prow < poffsets || prow > limit) + { + warn (_("Row index (%u) * num columns (%u) > space remaining in section\n"), + row, ncols); + return 0; + } if (do_display) printf (_(" [%3d] 0x%s"), @@ -7014,12 +9523,12 @@ process_cu_tu_index (struct dwarf_section *section, int do_display) ph = phash; pi = pindex; if (do_display) - { + { printf ("\n"); printf (_(" Size table\n")); printf (" slot %-16s ", is_tu_index ? _("signature") : _("dwo_id")); - } + } for (j = 0; j < ncols; j++) { @@ -7081,21 +9590,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 (cu_tu_indexes_read == -1) + { + cu_tu_indexes_read = TRUE; + + if (load_debug_section_with_follow (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)) - process_cu_tu_index (&debug_displays [dwp_tu_index].section, 0); + if (load_debug_section_with_follow (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. */ @@ -7105,7 +9620,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++) @@ -7140,8 +9656,10 @@ display_debug_not_supported (struct dwarf_section *section, return 1; } -/* Like malloc, but takes two parameters. +/* Like malloc, but takes two parameters like calloc. + Verifies that the first parameter is not too large. Note: does *not* initialise the allocated memory to zero. */ + void * cmalloc (size_t nmemb, size_t size) { @@ -7152,30 +9670,556 @@ cmalloc (size_t nmemb, size_t size) return xmalloc (nmemb * size); } -/* Like xmalloc, but takes two parameters. +/* Like xmalloc, but takes two parameters like calloc. + Verifies that the first parameter is not too large. Note: does *not* initialise the allocated memory to zero. */ + void * xcmalloc (size_t nmemb, size_t size) { /* Check for overflow. */ if (nmemb >= ~(size_t) 0 / size) - return NULL; + { + fprintf (stderr, + _("Attempt to allocate an array with an excessive number of elements: 0x%lx\n"), + (long) nmemb); + xexit (1); + } return xmalloc (nmemb * size); } /* Like xrealloc, but takes three parameters. + Verifies that the second parameter is not too large. Note: does *not* initialise any new memory to zero. */ + void * xcrealloc (void *ptr, size_t nmemb, size_t size) { /* Check for overflow. */ if (nmemb >= ~(size_t) 0 / size) - return NULL; + { + error (_("Attempt to re-allocate an array with an excessive number of elements: 0x%lx\n"), + (long) nmemb); + xexit (1); + } return xrealloc (ptr, nmemb * size); } +/* Like xcalloc, but verifies that the first parameter is not too large. */ + +void * +xcalloc2 (size_t nmemb, size_t size) +{ + /* Check for overflow. */ + if (nmemb >= ~(size_t) 0 / size) + { + error (_("Attempt to allocate a zero'ed array with an excessive number of elements: 0x%lx\n"), + (long) nmemb); + xexit (1); + } + + return xcalloc (nmemb, size); +} + +static unsigned long +calc_gnu_debuglink_crc32 (unsigned long crc, + const unsigned char * buf, + bfd_size_type len) +{ + static const unsigned long crc32_table[256] = + { + 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, + 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, + 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, + 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de, + 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856, + 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9, + 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, + 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, + 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, + 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a, + 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599, + 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, + 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, + 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, + 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e, + 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01, + 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed, + 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950, + 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, + 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, + 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, + 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5, + 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010, + 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f, + 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, + 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, + 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615, + 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8, + 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344, + 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb, + 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, + 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, + 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, + 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c, + 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef, + 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236, + 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, + 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, + 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c, + 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713, + 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b, + 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242, + 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, + 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, + 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278, + 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7, + 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66, + 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9, + 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, + 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, + 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, + 0x2d02ef8d + }; + const unsigned char *end; + + crc = ~crc & 0xffffffff; + for (end = buf + len; buf < end; ++ buf) + crc = crc32_table[(crc ^ *buf) & 0xff] ^ (crc >> 8); + return ~crc & 0xffffffff; +} + +typedef bfd_boolean (* check_func_type) (const char *, void *); +typedef const char * (* parse_func_type) (struct dwarf_section *, void *); + +static bfd_boolean +check_gnu_debuglink (const char * pathname, void * crc_pointer) +{ + static unsigned char buffer [8 * 1024]; + FILE * f; + bfd_size_type count; + unsigned long crc = 0; + void * sep_data; + + sep_data = open_debug_file (pathname); + if (sep_data == NULL) + return FALSE; + + /* Yes - we are opening the file twice... */ + f = fopen (pathname, "rb"); + if (f == NULL) + { + /* Paranoia: This should never happen. */ + close_debug_file (sep_data); + warn (_("Unable to reopen separate debug info file: %s\n"), pathname); + return FALSE; + } + + while ((count = fread (buffer, 1, sizeof (buffer), f)) > 0) + crc = calc_gnu_debuglink_crc32 (crc, buffer, count); + + fclose (f); + + if (crc != * (unsigned long *) crc_pointer) + { + close_debug_file (sep_data); + warn (_("Separate debug info file %s found, but CRC does not match - ignoring\n"), + pathname); + return FALSE; + } + + return TRUE; +} + +static const char * +parse_gnu_debuglink (struct dwarf_section * section, void * data) +{ + const char * name; + unsigned int crc_offset; + unsigned long * crc32 = (unsigned long *) data; + + /* The name is first. + The CRC value is stored after the filename, aligned up to 4 bytes. */ + name = (const char *) section->start; + + + crc_offset = strnlen (name, section->size) + 1; + crc_offset = (crc_offset + 3) & ~3; + if (crc_offset + 4 > section->size) + return NULL; + + * crc32 = byte_get (section->start + crc_offset, 4); + return name; +} + +static bfd_boolean +check_gnu_debugaltlink (const char * filename, void * data ATTRIBUTE_UNUSED) +{ + void * sep_data = open_debug_file (filename); + + if (sep_data == NULL) + return FALSE; + + /* FIXME: We should now extract the build-id in the separate file + and check it... */ + + return TRUE; +} + +typedef struct build_id_data +{ + bfd_size_type len; + const unsigned char * data; +} Build_id_data; + +static const char * +parse_gnu_debugaltlink (struct dwarf_section * section, void * data) +{ + const char * name; + bfd_size_type namelen; + bfd_size_type id_len; + Build_id_data * build_id_data; + + /* The name is first. + The build-id follows immediately, with no padding, up to the section's end. */ + + name = (const char *) section->start; + namelen = strnlen (name, section->size) + 1; + if (namelen >= section->size) + return NULL; + + id_len = section->size - namelen; + if (id_len < 0x14) + return NULL; + + build_id_data = calloc (1, sizeof * build_id_data); + if (build_id_data == NULL) + return NULL; + + build_id_data->len = id_len; + build_id_data->data = section->start + namelen; + + * (Build_id_data **) data = build_id_data; + + return name; +} + +static void +add_separate_debug_file (const char * filename, void * handle) +{ + separate_info * i = xmalloc (sizeof * i); + + i->filename = filename; + i->handle = handle; + i->next = first_separate_info; + first_separate_info = i; +} + +static void * +load_separate_debug_info (const char * main_filename, + struct dwarf_section * xlink, + parse_func_type parse_func, + check_func_type check_func, + void * func_data) +{ + const char * separate_filename; + char * debug_filename; + char * canon_dir; + size_t canon_dirlen; + size_t dirlen; + + if ((separate_filename = parse_func (xlink, func_data)) == NULL) + { + warn (_("Corrupt debuglink section: %s\n"), + xlink->name ? xlink->name : xlink->uncompressed_name); + return FALSE; + } + + /* Attempt to locate the separate file. + This should duplicate the logic in bfd/opncls.c:find_separate_debug_file(). */ + + canon_dir = lrealpath (main_filename); + + for (canon_dirlen = strlen (canon_dir); canon_dirlen > 0; canon_dirlen--) + if (IS_DIR_SEPARATOR (canon_dir[canon_dirlen - 1])) + break; + canon_dir[canon_dirlen] = '\0'; + +#ifndef DEBUGDIR +#define DEBUGDIR "/lib/debug" +#endif +#ifndef EXTRA_DEBUG_ROOT1 +#define EXTRA_DEBUG_ROOT1 "/usr/lib/debug" +#endif +#ifndef EXTRA_DEBUG_ROOT2 +#define EXTRA_DEBUG_ROOT2 "/usr/lib/debug/usr" +#endif + + debug_filename = (char *) malloc (strlen (DEBUGDIR) + 1 + + canon_dirlen + + strlen (".debug/") +#ifdef EXTRA_DEBUG_ROOT1 + + strlen (EXTRA_DEBUG_ROOT1) +#endif +#ifdef EXTRA_DEBUG_ROOT2 + + strlen (EXTRA_DEBUG_ROOT2) +#endif + + strlen (separate_filename) + + 1); + if (debug_filename == NULL) + { + warn (_("Out of memory")); + free (canon_dir); + return NULL; + } + + /* First try in the current directory. */ + sprintf (debug_filename, "%s", separate_filename); + if (check_func (debug_filename, func_data)) + goto found; + + /* Then try in a subdirectory called .debug. */ + sprintf (debug_filename, ".debug/%s", separate_filename); + if (check_func (debug_filename, func_data)) + goto found; + + /* Then try in the same directory as the original file. */ + sprintf (debug_filename, "%s%s", canon_dir, separate_filename); + if (check_func (debug_filename, func_data)) + goto found; + + /* And the .debug subdirectory of that directory. */ + sprintf (debug_filename, "%s.debug/%s", canon_dir, separate_filename); + if (check_func (debug_filename, func_data)) + goto found; + +#ifdef EXTRA_DEBUG_ROOT1 + /* Try the first extra debug file root. */ + sprintf (debug_filename, "%s/%s", EXTRA_DEBUG_ROOT1, separate_filename); + if (check_func (debug_filename, func_data)) + goto found; + + /* Try the first extra debug file root. */ + sprintf (debug_filename, "%s/%s/%s", EXTRA_DEBUG_ROOT1, canon_dir, separate_filename); + if (check_func (debug_filename, func_data)) + goto found; +#endif + +#ifdef EXTRA_DEBUG_ROOT2 + /* Try the second extra debug file root. */ + sprintf (debug_filename, "%s/%s", EXTRA_DEBUG_ROOT2, separate_filename); + if (check_func (debug_filename, func_data)) + goto found; +#endif + + /* Then try in the global debug_filename directory. */ + strcpy (debug_filename, DEBUGDIR); + dirlen = strlen (DEBUGDIR) - 1; + if (dirlen > 0 && DEBUGDIR[dirlen] != '/') + strcat (debug_filename, "/"); + strcat (debug_filename, (const char *) separate_filename); + + if (check_func (debug_filename, func_data)) + goto found; + + /* Failed to find the file. */ + warn (_("could not find separate debug file '%s'\n"), separate_filename); + warn (_("tried: %s\n"), debug_filename); + +#ifdef EXTRA_DEBUG_ROOT2 + sprintf (debug_filename, "%s/%s", EXTRA_DEBUG_ROOT2, separate_filename); + warn (_("tried: %s\n"), debug_filename); +#endif + +#ifdef EXTRA_DEBUG_ROOT1 + sprintf (debug_filename, "%s/%s/%s", EXTRA_DEBUG_ROOT1, canon_dir, separate_filename); + warn (_("tried: %s\n"), debug_filename); + + sprintf (debug_filename, "%s/%s", EXTRA_DEBUG_ROOT1, separate_filename); + warn (_("tried: %s\n"), debug_filename); +#endif + + sprintf (debug_filename, "%s.debug/%s", canon_dir, separate_filename); + warn (_("tried: %s\n"), debug_filename); + + sprintf (debug_filename, "%s%s", canon_dir, separate_filename); + warn (_("tried: %s\n"), debug_filename); + + sprintf (debug_filename, ".debug/%s", separate_filename); + warn (_("tried: %s\n"), debug_filename); + + sprintf (debug_filename, "%s", separate_filename); + warn (_("tried: %s\n"), debug_filename); + + free (canon_dir); + free (debug_filename); + return NULL; + + found: + free (canon_dir); + + void * debug_handle; + + /* Now open the file.... */ + if ((debug_handle = open_debug_file (debug_filename)) == NULL) + { + warn (_("failed to open separate debug file: %s\n"), debug_filename); + free (debug_filename); + return FALSE; + } + + /* FIXME: We do not check to see if there are any other separate debug info + files that would also match. */ + + printf (_("%s: Found separate debug info file: %s\n\n"), main_filename, debug_filename); + add_separate_debug_file (debug_filename, debug_handle); + + /* Do not free debug_filename - it might be referenced inside + the structure returned by open_debug_file(). */ + return debug_handle; +} + +/* Attempt to load a separate dwarf object file. */ + +static void * +load_dwo_file (const char * main_filename, const char * name, const char * dir, const char * id ATTRIBUTE_UNUSED) +{ + char * separate_filename; + void * separate_handle; + + /* FIXME: Skip adding / if dwo_dir ends in /. */ + separate_filename = concat (dir, "/", name, NULL); + if (separate_filename == NULL) + { + warn (_("Out of memory allocating dwo filename\n")); + return NULL; + } + + if ((separate_handle = open_debug_file (separate_filename)) == NULL) + { + warn (_("Unable to load dwo file: %s\n"), separate_filename); + free (separate_filename); + return NULL; + } + + /* FIXME: We should check the dwo_id. */ + + printf (_("%s: Found separate debug object file: %s\n\n"), main_filename, separate_filename); + add_separate_debug_file (separate_filename, separate_handle); + /* Note - separate_filename will be freed in free_debug_memory(). */ + return separate_handle; +} + +/* Load the separate debug info file(s) attached to FILE, if any exist. + Returns TRUE if any were found, FALSE otherwise. + If TRUE is returned then the linked list starting at first_separate_info + will be populated with open file handles. */ + +bfd_boolean +load_separate_debug_files (void * file, const char * filename) +{ + /* Skip this operation if we are not interested in debug links. */ + if (! do_follow_links && ! do_debug_links) + return FALSE; + + /* See if there are any dwo links. */ + if (load_debug_section (str, file) + && load_debug_section (abbrev, file) + && load_debug_section (info, file)) + { + free_dwo_info (); + + if (process_debug_info (& debug_displays[info].section, file, abbrev, TRUE, FALSE)) + { + bfd_boolean introduced = FALSE; + dwo_info * dwinfo; + const char * dir = NULL; + const char * id = NULL; + + for (dwinfo = first_dwo_info; dwinfo != NULL; dwinfo = dwinfo->next) + { + switch (dwinfo->type) + { + case DWO_NAME: + if (do_debug_links) + { + if (! introduced) + { + printf (_("The %s section contains link(s) to dwo file(s):\n\n"), + debug_displays [info].section.uncompressed_name); + introduced = TRUE; + } + + printf (_(" Name: %s\n"), dwinfo->value); + printf (_(" Directory: %s\n"), dir ? dir : _("")); + if (id != NULL) + display_data (printf (_(" ID: ")), (unsigned char *) id, 8); + else + printf (_(" ID: \n")); + printf ("\n\n"); + } + + if (do_follow_links) + load_dwo_file (filename, dwinfo->value, dir, id); + break; + + case DWO_DIR: + dir = dwinfo->value; + break; + + case DWO_ID: + id = dwinfo->value; + break; + + default: + error (_("Unexpected DWO INFO type")); + break; + } + } + } + } + + if (! do_follow_links) + /* The other debug links will be displayed by display_debug_links() + so we do not need to do any further processing here. */ + return FALSE; + + /* FIXME: We do not check for the presence of both link sections in the same file. */ + /* FIXME: We do not check the separate debug info file to see if it too contains debuglinks. */ + /* FIXME: We do not check for the presence of multiple, same-name debuglink sections. */ + /* FIXME: We do not check for the presence of a dwo link as well as a debuglink. */ + + if (load_debug_section (gnu_debugaltlink, file)) + { + Build_id_data * build_id_data; + + load_separate_debug_info (filename, + & debug_displays[gnu_debugaltlink].section, + parse_gnu_debugaltlink, + check_gnu_debugaltlink, + & build_id_data); + } + + if (load_debug_section (gnu_debuglink, file)) + { + unsigned long crc32; + + load_separate_debug_info (filename, + & debug_displays[gnu_debuglink].section, + parse_gnu_debuglink, + check_gnu_debuglink, + & crc32); + } + + if (first_separate_info != NULL) + return TRUE; + + do_follow_links = 0; + return FALSE; +} + void free_debug_memory (void) { @@ -7205,6 +10249,20 @@ free_debug_memory (void) debug_information = NULL; alloc_num_debug_info_entries = num_debug_info_entries = 0; } + + separate_info * d; + separate_info * next; + + for (d = first_separate_info; d != NULL; d = next) + { + close_debug_file (d->handle); + free ((void *) d->filename); + next = d->next; + free ((void *) d); + } + first_separate_info = NULL; + + free_dwo_info (); } void @@ -7227,17 +10285,19 @@ dwarf_select_sections_by_names (const char *names) { "aranges", & do_debug_aranges, 1 }, { "cu_index", & do_debug_cu_index, 1 }, { "decodedline", & do_debug_lines, FLAG_DEBUG_LINES_DECODED }, + { "follow-links", & do_follow_links, 1 }, { "frames", & do_debug_frames, 1 }, { "frames-interp", & do_debug_frames_interp, 1 }, /* The special .gdb_index section. */ { "gdb_index", & do_gdb_index, 1 }, { "info", & do_debug_info, 1 }, { "line", & do_debug_lines, FLAG_DEBUG_LINES_RAW }, /* For backwards compatibility. */ + { "links", & do_debug_links, 1 }, { "loc", & do_debug_loc, 1 }, { "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 }, @@ -7296,58 +10356,30 @@ dwarf_select_sections_by_letters (const char *letters) while (letters[lindex]) switch (letters[lindex++]) { - case 'i': - do_debug_info = 1; - break; - - case 'a': - do_debug_abbrevs = 1; - break; - - case 'l': - do_debug_lines |= FLAG_DEBUG_LINES_RAW; - break; - - case 'L': - do_debug_lines |= FLAG_DEBUG_LINES_DECODED; - break; - - case 'p': - do_debug_pubnames = 1; - break; - - case 't': - do_debug_pubtypes = 1; - break; - - case 'r': - do_debug_aranges = 1; - break; - - case 'R': - do_debug_ranges = 1; - break; - - case 'F': - do_debug_frames_interp = 1; - case 'f': - do_debug_frames = 1; - break; - - case 'm': - do_debug_macinfo = 1; - break; - - case 's': - do_debug_str = 1; - break; - - case 'o': - do_debug_loc = 1; - break; + case 'A': do_debug_addr = 1; break; + case 'a': do_debug_abbrevs = 1; break; + case 'c': do_debug_cu_index = 1; break; + case 'F': do_debug_frames_interp = 1; /* Fall through. */ + case 'f': do_debug_frames = 1; break; + case 'g': do_gdb_index = 1; break; + case 'i': do_debug_info = 1; break; + case 'K': do_follow_links = 1; break; + case 'k': do_debug_links = 1; break; + case 'l': do_debug_lines |= FLAG_DEBUG_LINES_RAW; break; + case 'L': do_debug_lines |= FLAG_DEBUG_LINES_DECODED; break; + case 'm': do_debug_macinfo = 1; break; + case 'o': do_debug_loc = 1; break; + case 'p': do_debug_pubnames = 1; break; + case 'R': do_debug_ranges = 1; break; + case 'r': do_debug_aranges = 1; break; + case 's': do_debug_str = 1; break; + case 'T': do_trace_aranges = 1; break; + case 't': do_debug_pubtypes = 1; break; + case 'U': do_trace_info = 1; break; + case 'u': do_trace_abbrevs = 1; break; default: - warn (_("Unrecognized debug option '%s'\n"), optarg); + warn (_("Unrecognized debug option '%s'\n"), letters); break; } } @@ -7372,80 +10404,64 @@ dwarf_select_sections_all (void) do_trace_aranges = 1; do_debug_addr = 1; do_debug_cu_index = 1; + do_follow_links = 1; + do_debug_links = 1; } +#define NO_ABBREVS NULL, NULL, NULL, 0, 0, 0, NULL, 0, NULL +#define ABBREV(N) NULL, NULL, NULL, 0, 0, N, NULL, 0, NULL + +/* N.B. The order here must match the order in section_display_enum. */ + struct dwarf_section_display debug_displays[] = { - { { ".debug_abbrev", ".zdebug_abbrev", NULL, NULL, 0, 0, 0, NULL }, - display_debug_abbrev, &do_debug_abbrevs, 0 }, - { { ".debug_aranges", ".zdebug_aranges", NULL, NULL, 0, 0, 0, NULL }, - display_debug_aranges, &do_debug_aranges, 1 }, - { { ".debug_frame", ".zdebug_frame", NULL, NULL, 0, 0, 0, NULL }, - display_debug_frames, &do_debug_frames, 1 }, - { { ".debug_info", ".zdebug_info", NULL, NULL, 0, 0, abbrev, NULL }, - display_debug_info, &do_debug_info, 1 }, - { { ".debug_line", ".zdebug_line", NULL, NULL, 0, 0, 0, NULL }, - display_debug_lines, &do_debug_lines, 1 }, - { { ".debug_pubnames", ".zdebug_pubnames", NULL, NULL, 0, 0, 0, NULL }, - display_debug_pubnames, &do_debug_pubnames, 0 }, - { { ".debug_gnu_pubnames", ".zdebug_gnu_pubnames", NULL, NULL, 0, 0, 0, NULL }, - display_debug_gnu_pubnames, &do_debug_pubnames, 0 }, - { { ".eh_frame", "", NULL, NULL, 0, 0, 0, NULL }, - display_debug_frames, &do_debug_frames, 1 }, - { { ".debug_macinfo", ".zdebug_macinfo", NULL, NULL, 0, 0, 0, NULL }, - display_debug_macinfo, &do_debug_macinfo, 0 }, - { { ".debug_macro", ".zdebug_macro", NULL, NULL, 0, 0, 0, NULL }, - display_debug_macro, &do_debug_macinfo, 1 }, - { { ".debug_str", ".zdebug_str", NULL, NULL, 0, 0, 0, NULL }, - display_debug_str, &do_debug_str, 0 }, - { { ".debug_loc", ".zdebug_loc", NULL, NULL, 0, 0, 0, NULL }, - display_debug_loc, &do_debug_loc, 1 }, - { { ".debug_pubtypes", ".zdebug_pubtypes", NULL, NULL, 0, 0, 0, NULL }, - display_debug_pubnames, &do_debug_pubtypes, 0 }, - { { ".debug_gnu_pubtypes", ".zdebug_gnu_pubtypes", NULL, NULL, 0, 0, 0, NULL }, - display_debug_gnu_pubnames, &do_debug_pubtypes, 0 }, - { { ".debug_ranges", ".zdebug_ranges", NULL, NULL, 0, 0, 0, NULL }, - display_debug_ranges, &do_debug_ranges, 1 }, - { { ".debug_static_func", ".zdebug_static_func", NULL, NULL, 0, 0, 0, NULL }, - display_debug_not_supported, NULL, 0 }, - { { ".debug_static_vars", ".zdebug_static_vars", NULL, NULL, 0, 0, 0, NULL }, - display_debug_not_supported, NULL, 0 }, - { { ".debug_types", ".zdebug_types", NULL, NULL, 0, 0, abbrev, NULL }, - display_debug_types, &do_debug_info, 1 }, - { { ".debug_weaknames", ".zdebug_weaknames", NULL, NULL, 0, 0, 0, NULL }, - display_debug_not_supported, NULL, 0 }, - { { ".gdb_index", "", NULL, NULL, 0, 0, 0, NULL }, - display_gdb_index, &do_gdb_index, 0 }, - { { ".trace_info", "", NULL, NULL, 0, 0, trace_abbrev, NULL }, - display_trace_info, &do_trace_info, 1 }, - { { ".trace_abbrev", "", NULL, NULL, 0, 0, 0, NULL }, - display_debug_abbrev, &do_trace_abbrevs, 0 }, - { { ".trace_aranges", "", NULL, NULL, 0, 0, 0, NULL }, - display_debug_aranges, &do_trace_aranges, 0 }, - { { ".debug_info.dwo", ".zdebug_info.dwo", NULL, NULL, 0, 0, abbrev_dwo, NULL }, - display_debug_info, &do_debug_info, 1 }, - { { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo", NULL, NULL, 0, 0, 0, NULL }, - display_debug_abbrev, &do_debug_abbrevs, 0 }, - { { ".debug_types.dwo", ".zdebug_types.dwo", NULL, NULL, 0, 0, abbrev_dwo, NULL }, - display_debug_types, &do_debug_info, 1 }, - { { ".debug_line.dwo", ".zdebug_line.dwo", NULL, NULL, 0, 0, 0, NULL }, - display_debug_lines, &do_debug_lines, 1 }, - { { ".debug_loc.dwo", ".zdebug_loc.dwo", NULL, NULL, 0, 0, 0, NULL }, - display_debug_loc, &do_debug_loc, 1 }, - { { ".debug_macro.dwo", ".zdebug_macro.dwo", NULL, NULL, 0, 0, 0, NULL }, - display_debug_macro, &do_debug_macinfo, 1 }, - { { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo", NULL, NULL, 0, 0, 0, NULL }, - display_debug_macinfo, &do_debug_macinfo, 0 }, - { { ".debug_str.dwo", ".zdebug_str.dwo", NULL, NULL, 0, 0, 0, NULL }, - display_debug_str, &do_debug_str, 1 }, - { { ".debug_str_offsets", ".zdebug_str_offsets", NULL, NULL, 0, 0, 0, NULL }, - display_debug_str_offsets, NULL, 0 }, - { { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo", NULL, NULL, 0, 0, 0, NULL }, - display_debug_str_offsets, NULL, 0 }, - { { ".debug_addr", ".zdebug_addr", NULL, NULL, 0, 0, 0, NULL }, - display_debug_addr, &do_debug_addr, 1 }, - { { ".debug_cu_index", "", NULL, NULL, 0, 0, 0, NULL }, - display_cu_index, &do_debug_cu_index, 0 }, - { { ".debug_tu_index", "", NULL, NULL, 0, 0, 0, NULL }, - display_cu_index, &do_debug_cu_index, 0 }, + { { ".debug_abbrev", ".zdebug_abbrev", NO_ABBREVS }, display_debug_abbrev, &do_debug_abbrevs, FALSE }, + { { ".debug_aranges", ".zdebug_aranges", NO_ABBREVS }, display_debug_aranges, &do_debug_aranges, TRUE }, + { { ".debug_frame", ".zdebug_frame", NO_ABBREVS }, display_debug_frames, &do_debug_frames, TRUE }, + { { ".debug_info", ".zdebug_info", ABBREV (abbrev)}, display_debug_info, &do_debug_info, TRUE }, + { { ".debug_line", ".zdebug_line", NO_ABBREVS }, display_debug_lines, &do_debug_lines, TRUE }, + { { ".debug_pubnames", ".zdebug_pubnames", NO_ABBREVS }, display_debug_pubnames, &do_debug_pubnames, FALSE }, + { { ".debug_gnu_pubnames", ".zdebug_gnu_pubnames", NO_ABBREVS }, display_debug_gnu_pubnames, &do_debug_pubnames, FALSE }, + { { ".eh_frame", "", NO_ABBREVS }, display_debug_frames, &do_debug_frames, TRUE }, + { { ".debug_macinfo", ".zdebug_macinfo", NO_ABBREVS }, display_debug_macinfo, &do_debug_macinfo, FALSE }, + { { ".debug_macro", ".zdebug_macro", NO_ABBREVS }, display_debug_macro, &do_debug_macinfo, TRUE }, + { { ".debug_str", ".zdebug_str", NO_ABBREVS }, display_debug_str, &do_debug_str, FALSE }, + { { ".debug_line_str", ".zdebug_line_str", NO_ABBREVS }, display_debug_str, &do_debug_str, FALSE }, + { { ".debug_loc", ".zdebug_loc", NO_ABBREVS }, display_debug_loc, &do_debug_loc, TRUE }, + { { ".debug_loclists", ".zdebug_loclists", NO_ABBREVS }, display_debug_loc, &do_debug_loc, TRUE }, + { { ".debug_pubtypes", ".zdebug_pubtypes", NO_ABBREVS }, display_debug_pubnames, &do_debug_pubtypes, FALSE }, + { { ".debug_gnu_pubtypes", ".zdebug_gnu_pubtypes", NO_ABBREVS }, display_debug_gnu_pubnames, &do_debug_pubtypes, FALSE }, + { { ".debug_ranges", ".zdebug_ranges", NO_ABBREVS }, display_debug_ranges, &do_debug_ranges, TRUE }, + { { ".debug_rnglists", ".zdebug_rnglists", NO_ABBREVS }, display_debug_ranges, &do_debug_ranges, TRUE }, + { { ".debug_static_func", ".zdebug_static_func", NO_ABBREVS }, display_debug_not_supported, NULL, FALSE }, + { { ".debug_static_vars", ".zdebug_static_vars", NO_ABBREVS }, display_debug_not_supported, NULL, FALSE }, + { { ".debug_types", ".zdebug_types", ABBREV (abbrev) }, display_debug_types, &do_debug_info, TRUE }, + { { ".debug_weaknames", ".zdebug_weaknames", NO_ABBREVS }, display_debug_not_supported, NULL, FALSE }, + { { ".gdb_index", "", NO_ABBREVS }, display_gdb_index, &do_gdb_index, FALSE }, + { { ".debug_names", "", NO_ABBREVS }, display_debug_names, &do_gdb_index, FALSE }, + { { ".trace_info", "", ABBREV (trace_abbrev) }, display_trace_info, &do_trace_info, TRUE }, + { { ".trace_abbrev", "", NO_ABBREVS }, display_debug_abbrev, &do_trace_abbrevs, FALSE }, + { { ".trace_aranges", "", NO_ABBREVS }, display_debug_aranges, &do_trace_aranges, FALSE }, + { { ".debug_info.dwo", ".zdebug_info.dwo", ABBREV (abbrev_dwo) }, display_debug_info, &do_debug_info, TRUE }, + { { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo", NO_ABBREVS }, display_debug_abbrev, &do_debug_abbrevs, FALSE }, + { { ".debug_types.dwo", ".zdebug_types.dwo", ABBREV (abbrev_dwo) }, display_debug_types, &do_debug_info, TRUE }, + { { ".debug_line.dwo", ".zdebug_line.dwo", NO_ABBREVS }, display_debug_lines, &do_debug_lines, TRUE }, + { { ".debug_loc.dwo", ".zdebug_loc.dwo", NO_ABBREVS }, display_debug_loc, &do_debug_loc, TRUE }, + { { ".debug_macro.dwo", ".zdebug_macro.dwo", NO_ABBREVS }, display_debug_macro, &do_debug_macinfo, TRUE }, + { { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo", NO_ABBREVS }, display_debug_macinfo, &do_debug_macinfo, FALSE }, + { { ".debug_str.dwo", ".zdebug_str.dwo", NO_ABBREVS }, display_debug_str, &do_debug_str, TRUE }, + { { ".debug_str_offsets", ".zdebug_str_offsets", NO_ABBREVS }, display_debug_str_offsets, NULL, FALSE }, + { { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo", NO_ABBREVS }, display_debug_str_offsets, NULL, FALSE }, + { { ".debug_addr", ".zdebug_addr", NO_ABBREVS }, display_debug_addr, &do_debug_addr, TRUE }, + { { ".debug_cu_index", "", NO_ABBREVS }, display_cu_index, &do_debug_cu_index, FALSE }, + { { ".debug_tu_index", "", NO_ABBREVS }, display_cu_index, &do_debug_cu_index, FALSE }, + { { ".gnu_debuglink", "", NO_ABBREVS }, display_debug_links, &do_debug_links, FALSE }, + { { ".gnu_debugaltlink", "", NO_ABBREVS }, display_debug_links, &do_debug_links, FALSE }, + /* Separate debug info files can containt their own .debug_str section, + and this might be in *addition* to a .debug_str section already present + in the main file. Hence we need to have two entries for .debug_str. */ + { { ".debug_str", ".zdebug_str", NO_ABBREVS }, display_debug_str, &do_debug_str, FALSE }, }; + +/* A static assertion. */ +extern int debug_displays_assert[ARRAY_SIZE (debug_displays) == max ? 1 : -1];