X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=binutils%2Fdwarf.c;h=e792a17018cc908bdc2af1ca397822cfad0e0260;hb=d292364e95fc9c8230b678d9026f285850074c02;hp=91f95ff06824a975da4f645bd482081bf35e47d6;hpb=e98fdf1ab07243fe467caadd0d033b44b8ca20c7;p=deliverable%2Fbinutils-gdb.git diff --git a/binutils/dwarf.c b/binutils/dwarf.c index 91f95ff068..e792a17018 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-2017 Free Software Foundation, Inc. + Copyright (C) 2005-2019 Free Software Foundation, Inc. This file is part of GNU Binutils. @@ -28,6 +28,8 @@ #include "dwarf2.h" #include "dwarf.h" #include "gdb/gdb-index.h" +#include "filenames.h" +#include "safe-ctype.h" #include #undef MAX @@ -47,6 +49,27 @@ static debug_info *debug_information = NULL; that the .debug_info section could not be loaded/parsed. */ #define DEBUG_INFO_UNAVAILABLE (unsigned int) -1 +/* 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; @@ -68,6 +91,8 @@ 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; @@ -374,13 +399,20 @@ read_uleb128 (unsigned char * data, } \ 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 \ { \ unsigned int amount = (AMOUNT); \ if (sizeof (VAL) < amount) \ { \ - error (_("internal error: attempt to read %d bytes of data in to %d sized variable"),\ + 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); \ } \ @@ -398,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 \ { \ @@ -406,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 \ { \ @@ -424,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 \ { \ @@ -720,7 +755,7 @@ fetch_indirect_line_string (dwarf_vma offset) 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; @@ -963,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; } @@ -1355,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) { @@ -1438,7 +1476,7 @@ decode_location_expression (unsigned char * data, 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) { @@ -1549,6 +1587,25 @@ decode_location_expression (unsigned char * data, 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: @@ -1663,20 +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, - 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) +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; @@ -1783,6 +1953,7 @@ read_and_display_attr_value (unsigned long attribute, case DW_FORM_GNU_ref_alt: if (!do_loc) printf ("%c", delimiter, dwarf_vmatoa ("x",uvalue)); + /* FIXME: Follow the reference... */ break; case DW_FORM_ref1: @@ -1984,8 +2155,8 @@ read_and_display_attr_value (unsigned long attribute, case DW_FORM_GNU_str_index: if (!do_loc) { - const char *suffix = strrchr (section->name, '.'); - int dwo = (suffix && strcmp (suffix, ".dwo") == 0) ? 1 : 0; + 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), @@ -1995,8 +2166,11 @@ read_and_display_attr_value (unsigned long attribute, case DW_FORM_GNU_strp_alt: if (!do_loc) - printf (_("%c(alt indirect string, offset: 0x%s)"), delimiter, - 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: @@ -2081,19 +2255,28 @@ read_and_display_attr_value (unsigned long attribute, debug_info_p->have_frame_base [num] = have_frame_base; if (attribute != DW_AT_GNU_locviews) { - debug_info_p->loc_offsets [num] = uvalue; - debug_info_p->num_loc_offsets++; - assert (debug_info_p->num_loc_offsets - - debug_info_p->num_loc_views <= 1); + /* 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; - debug_info_p->loc_views [num] = uvalue; - debug_info_p->num_loc_views++; - assert (debug_info_p->num_loc_views - - debug_info_p->num_loc_offsets <= 1); + 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; @@ -2133,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; } @@ -2196,12 +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. */ @@ -2238,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; @@ -2246,8 +2505,6 @@ read_and_display_attr_value (unsigned long attribute, case DW_ATE_HP_floathpintel: printf ("(HP_floathpintel)"); break; case DW_ATE_HP_imaginary_float80: printf ("(HP_imaginary_float80)"); break; case DW_ATE_HP_imaginary_float128: printf ("(HP_imaginary_float128)"); break; - /* DWARF 4 values: */ - case DW_ATE_UTF: printf ("(unicode string)"); break; default: if (uvalue >= DW_ATE_lo_user @@ -2283,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) @@ -2313,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) @@ -2326,12 +2603,47 @@ 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_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. */ @@ -2379,6 +2691,22 @@ 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 @@ -2426,46 +2754,20 @@ read_and_display_attr_value (unsigned long attribute, return data; } -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 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) +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) { if (!do_loc) printf (" %-18s:", get_AT_name (attribute)); @@ -2478,17 +2780,89 @@ read_and_display_attr (unsigned long attribute, return data; } -/* 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. */ +/* 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. */ -static int -process_debug_info (struct dwarf_section *section, - void *file, - enum dwarf_section_display_enum abbrev_sec, - int do_loc, - int do_types) +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; + + for (i = first_separate_info; i != NULL; i = i->next) + if (i->handle == handle) + { + debug_displays[sec_enum].section.filename = i->filename; + break; + } + } + + return TRUE; + } + + if (do_follow_links) + { + separate_info * i; + + 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 FALSE; +} + +static void +introduce (struct dwarf_section * section, bfd_boolean raw) +{ + 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 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; @@ -2520,7 +2894,7 @@ 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; @@ -2532,14 +2906,14 @@ process_debug_info (struct dwarf_section *section, { 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. */ @@ -2550,8 +2924,9 @@ process_debug_info (struct dwarf_section *section, 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 @@ -2564,25 +2939,25 @@ process_debug_info (struct dwarf_section *section, 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 (line_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; @@ -2667,6 +3042,14 @@ process_debug_info (struct dwarf_section *section, 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 && ! do_types) @@ -2836,7 +3219,7 @@ process_debug_info (struct dwarf_section *section, } } if (dwarf_start_die != 0 && level < saved_level) - return 1; + return TRUE; continue; } @@ -2876,7 +3259,7 @@ process_debug_info (struct dwarf_section *section, } 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) @@ -2888,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: @@ -2913,7 +3297,6 @@ process_debug_info (struct dwarf_section *section, if (! do_loc && do_printing) /* Show the offset from where the tag was extracted. */ printf (" <%lx>", (unsigned long)(tags - section_begin)); - tags = read_and_display_attr (attr->attribute, attr->form, attr->implicit_const, @@ -2974,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 @@ -2998,13 +3381,13 @@ load_debug_info (void * file) /* If this is a DWARF package file, load the CU and TU indexes. */ (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; @@ -3130,10 +3513,12 @@ read_debug_line_header (struct dwarf_section * section, } static unsigned char * -display_formatted_table (unsigned char *data, - unsigned char *start, unsigned char *end, - const DWARF2_Internal_LineInfo *linfo, - struct dwarf_section *section, const char *what) +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; @@ -3149,7 +3534,10 @@ display_formatted_table (unsigned char *data, data += bytes_read; if (data == end) { - warn (_("Corrupt %s format table entry\n"), what); + if (is_dir) + warn (_("Corrupt directory format table entry\n")); + else + warn (_("Corrupt file name format table entry\n")); return data; } } @@ -3158,18 +3546,28 @@ display_formatted_table (unsigned char *data, data += bytes_read; if (data == end) { - warn (_("Corrupt %s list\n"), what); + if (is_dir) + warn (_("Corrupt directory list\n")); + else + warn (_("Corrupt file name list\n")); return data; } if (data_count == 0) { - printf (_("\n The %s Table is empty.\n"), what); + if (is_dir) + printf (_("\n The Directory Table is empty.\n")); + else + printf (_("\n The File Name Table is empty.\n")); return data; } - printf (_("\n The %s Table (offset 0x%lx):\n"), what, - (long)(data - start)); + 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. */ @@ -3237,7 +3635,10 @@ display_formatted_table (unsigned char *data, } if (data == end) { - warn (_("Corrupt %s entries list\n"), what); + if (is_dir) + warn (_("Corrupt directory entries list\n")); + else + warn (_("Corrupt file name entries list\n")); return data; } putchar ('\n'); @@ -3246,15 +3647,15 @@ display_formatted_table (unsigned char *data, } static int -display_debug_lines_raw (struct dwarf_section *section, - unsigned char *data, - unsigned char *end, void *file) +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) { @@ -3332,19 +3733,22 @@ 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 (linfo.li_version >= 5) { - load_debug_section (line_str, file); + load_debug_section_with_follow (line_str, file); data = display_formatted_table (data, start, end, &linfo, section, - _("Directory")); + TRUE); data = display_formatted_table (data, start, end, &linfo, section, - _("File name")); + FALSE); } else { @@ -3665,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, void *fileptr) +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) { @@ -3738,7 +4142,7 @@ display_debug_lines_decoded (struct dwarf_section *section, dwarf_vma formati, entryi; unsigned int bytes_read; - load_debug_section (line_str, fileptr); + load_debug_section_with_follow (line_str, fileptr); /* Skip directories format. */ SAFE_BYTE_GET_AND_INC (format_count, data, 1, end); @@ -4028,7 +4432,7 @@ display_debug_lines_decoded (struct dwarf_section *section, printf ("%s:\n", file_table[0].name); } - printf (_("File name Line number Starting address View\n")); + printf (_("File name Line number Starting address View Stmt\n")); saved_linfo = linfo; } @@ -4366,9 +4770,14 @@ display_debug_lines_decoded (struct dwarf_section *section, } if (state_machine_regs.view) - printf (" %6u\n", state_machine_regs.view); + printf (" %6u", state_machine_regs.view); else - putchar ('\n'); + printf (" "); + + if (state_machine_regs.is_stmt) + printf (" x"); + + putchar ('\n'); state_machine_regs.view++; if (xop == -DW_LNE_end_sequence) @@ -4471,7 +4880,7 @@ 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) { @@ -4617,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) { @@ -4790,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) { @@ -5047,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 { @@ -5669,12 +6078,12 @@ display_debug_loc (struct dwarf_section *section, void *file) 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; @@ -5790,9 +6199,12 @@ display_debug_loc (struct dwarf_section *section, void *file) if (!locs_sorted) array = (unsigned int *) xcmalloc (num_loc_list, sizeof (unsigned int)); - printf (_("Contents of the %s section:\n\n"), section->name); + + 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; @@ -5911,7 +6323,9 @@ display_debug_loc (struct dwarf_section *section, void *file) } 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); @@ -5932,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) { @@ -5979,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 @@ -6001,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. */ @@ -6131,8 +6545,8 @@ 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; } @@ -6160,7 +6574,7 @@ display_debug_addr (struct dwarf_section *section, return 0; } - printf (_("Contents of the %s section:\n\n"), section->name); + introduce (section, FALSE); /* PR 17531: file: cf38d01b. We use xcalloc because a corrupt file may not have initialised all of the @@ -6215,6 +6629,7 @@ 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) @@ -6269,6 +6684,7 @@ display_debug_ranges_list (unsigned char *start, unsigned char *finish, break; SAFE_SIGNED_BYTE_GET_AND_INC (end, start, pointer_size, finish); + printf (" %8.8lx ", offset); if (begin == 0 && end == 0) @@ -6510,7 +6926,8 @@ display_debug_ranges (struct dwarf_section *section, warn (_("Range lists in %s section start at 0x%lx\n"), section->name, (unsigned long) range_entries[0].ranges_offset); - printf (_("Contents of the %s section:\n\n"), section->name); + introduce (section, FALSE); + printf (_(" Offset Begin End\n")); for (i = 0; i < num_range_list; i++) @@ -6535,10 +6952,17 @@ display_debug_ranges (struct dwarf_section *section, continue; } - if (dwarf_check != 0 && i > 0) + if (next < section_begin || next >= finish) { - if (start < next) - warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"), + warn (_("Corrupt offset (%#8.8lx) in range entry %u\n"), + (unsigned long) offset, i); + continue; + } + + if (dwarf_check != 0 && i > 0) + { + if (start < next) + warn (_("There is a hole [0x%lx - 0x%lx] in %s section.\n"), (unsigned long) (start - section_begin), (unsigned long) (next - section_begin), section->name); else if (start > next) @@ -6550,6 +6974,7 @@ display_debug_ranges (struct dwarf_section *section, (unsigned long) (next - section_begin), section->name); } } + start = next; last_start = next; @@ -6576,7 +7001,7 @@ typedef struct Frame_Chunk int data_factor; dwarf_vma pc_begin; dwarf_vma pc_range; - int cfa_reg; + unsigned int cfa_reg; dwarf_vma cfa_offset; unsigned int ra; unsigned char fde_encoding; @@ -6750,13 +7175,17 @@ static const char *const dwarf_regnames_aarch64[] = "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, + 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 @@ -6790,6 +7219,27 @@ init_dwarf_regnames_s390 (void) 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) { @@ -6817,6 +7267,10 @@ init_dwarf_regnames (unsigned int e_machine) init_dwarf_regnames_s390 (); break; + case EM_RISCV: + init_dwarf_regnames_riscv (); + break; + default: break; } @@ -6919,13 +7373,13 @@ frame_display_row (Frame_Chunk *fc, int *need_col_headers, unsigned int *max_reg 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. */ @@ -6949,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) @@ -6961,7 +7415,7 @@ read_cie (unsigned char *start, unsigned char *end, if (fc->ptr_size < 1 || fc->ptr_size > 8) { warn (_("Invalid pointer size (%d) in CIE data\n"), fc->ptr_size); - return end; + goto fail; } GET (fc->segment_size, 1); @@ -6969,7 +7423,7 @@ read_cie (unsigned char *start, unsigned char *end, if (fc->segment_size > 8 || fc->segment_size + fc->ptr_size > 8) { warn (_("Invalid segment size (%d) in CIE data\n"), fc->segment_size); - return end; + goto fail; } eh_addr_size = fc->ptr_size; @@ -6979,8 +7433,10 @@ read_cie (unsigned char *start, unsigned char *end, fc->ptr_size = eh_addr_size; fc->segment_size = 0; } + READ_ULEB (fc->code_factor); READ_SLEB (fc->data_factor); + if (version == 1) { GET (fc->ra, 1); @@ -6995,11 +7451,12 @@ read_cie (unsigned char *start, unsigned char *end, READ_ULEB (augmentation_data_len); augmentation_data = start; /* PR 17512: file: 11042-2589-0.004. */ - if (augmentation_data_len > (size_t) (end - start)) + if (augmentation_data_len > (bfd_size_type) (end - start)) { - warn (_("Augmentation data too long: %#lx, expected at most %#lx\n"), - augmentation_data_len, (unsigned long) (end - start)); - 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; } @@ -7024,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++; @@ -7041,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 @@ -7050,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: "); unsigned int saved_eh_addr_size = eh_addr_size; - printf (_("Contents of the %s section:\n"), section->name); + introduce (section, FALSE); while (start < end) { @@ -7071,7 +7572,7 @@ 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; @@ -7165,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'); } } @@ -7329,16 +7822,18 @@ display_debug_frames (struct dwarf_section *section, { 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 (augmentation_data_len > (bfd_size_type) (end - start)) { - warn (_("Corrupt augmentation data length: %lx\n"), - augmentation_data_len); + warn (_("Augmentation data too long: 0x%s, " + "expected at most %#lx\n"), + dwarf_vmatoa ("x", augmentation_data_len), + (unsigned long) (end - start)); start = end; augmentation_data = NULL; augmentation_data_len = 0; } + start += augmentation_data_len; } printf ("\n%08lx %s %s FDE cie=%08lx pc=", @@ -7356,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'); } } @@ -7793,7 +8283,7 @@ display_debug_frames (struct dwarf_section *section, break; case DW_CFA_def_cfa: - READ_SLEB (fc->cfa_reg); + READ_ULEB (fc->cfa_reg); READ_ULEB (fc->cfa_offset); fc->cfa_exp = 0; if (! do_debug_frames_interp) @@ -7802,7 +8292,7 @@ display_debug_frames (struct dwarf_section *section, break; case DW_CFA_def_cfa_register: - READ_SLEB (fc->cfa_reg); + READ_ULEB (fc->cfa_reg); fc->cfa_exp = 0; if (! do_debug_frames_interp) printf (" DW_CFA_def_cfa_register: %s\n", @@ -7921,7 +8411,7 @@ display_debug_frames (struct dwarf_section *section, break; case DW_CFA_def_cfa_sf: - READ_SLEB (fc->cfa_reg); + READ_ULEB (fc->cfa_reg); READ_ULEB (fc->cfa_offset); fc->cfa_offset = fc->cfa_offset * fc->data_factor; fc->cfa_exp = 0; @@ -7997,6 +8487,36 @@ display_debug_frames (struct dwarf_section *section, 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; } @@ -8011,9 +8531,9 @@ display_debug_names (struct dwarf_section *section, void *file) const unsigned char *const section_end = section->start + section->size; unsigned char *unit_end; - printf (_("Contents of the %s section:\n"), section->name); + introduce (section, FALSE); - load_debug_section (str, file); + load_debug_section_with_follow (str, file); for (; hdrptr < section_end; hdrptr = unit_end) { @@ -8024,6 +8544,8 @@ display_debug_names (struct dwarf_section *section, void *file) uint32_t augmentation_string_size; unsigned int i; unsigned long sec_off; + bfd_boolean augmentation_printable; + const char *augmentation_string; unit_start = hdrptr; @@ -8087,15 +8609,32 @@ display_debug_names (struct dwarf_section *section, void *file) 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'); putchar ('\n'); printf (_("CU table:\n")); @@ -8161,8 +8700,10 @@ display_debug_names (struct dwarf_section *section, void *file) if (bucket != 0) ++buckets_filled; } - printf (_("Used %zu of %lu buckets.\n"), buckets_filled, - (unsigned long) bucket_count); + 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; @@ -8349,6 +8890,80 @@ display_debug_names (struct dwarf_section *section, void *file) 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); + + 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; + + /* 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; +} + static int display_gdb_index (struct dwarf_section *section, void *file ATTRIBUTE_UNUSED) @@ -8365,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)) { @@ -8699,30 +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; - - /* PR 17531: file: 45d69832. */ - if (pindex < phash || ppool < phdr || (pindex == phash && nslots != 0)) - { - warn (_("Section %s is too small for %d slots\n"), - section->name, nslots); - return 0; - } + 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 || ppool < phdr) - { - warn (_("Section %s too small for %d hash table entries\n"), + /* PR 17531: file: 45d69832. */ + if ((size_t) nslots * 8 / 8 != nslots + || phash < phdr || phash > limit + || pindex < phash || pindex > limit + || ppool < pindex || ppool > limit) + { + 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; } @@ -8784,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; @@ -8795,14 +9409,13 @@ process_cu_tu_index (struct dwarf_section *section, int do_display) is_tu_index = strcmp (section->name, ".debug_tu_index") == 0; /* PR 17531: file: 0dd159bf. - Check for wraparound with an overlarge ncols value. */ - if (poffsets < ppool || (unsigned int) ((poffsets - ppool) / 4) != ncols) - { - warn (_("Overlarge number of columns: %x\n"), ncols); - return 0; - } - - if (pend > limit) + 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); @@ -8857,7 +9470,18 @@ 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. */ @@ -8977,11 +9601,11 @@ load_cu_tu_indexes (void *file) { cu_tu_indexes_read = TRUE; - if (load_debug_section (dwp_cu_index, file)) + 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)) + 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; } @@ -9035,6 +9659,7 @@ display_debug_not_supported (struct dwarf_section *section, /* 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) { @@ -9048,6 +9673,7 @@ cmalloc (size_t nmemb, size_t size) /* 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) { @@ -9066,15 +9692,15 @@ xcmalloc (size_t nmemb, size_t 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) { - fprintf (stderr, - _("Attempt to re-allocate an array with an excessive number of elements: 0x%lx\n"), - (long) nmemb); + error (_("Attempt to re-allocate an array with an excessive number of elements: 0x%lx\n"), + (long) nmemb); xexit (1); } @@ -9082,21 +9708,518 @@ xcrealloc (void *ptr, size_t nmemb, size_t 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) { - fprintf (stderr, - _("Attempt to allocate a zero'ed array with an excessive number of elements: 0x%lx\n"), - (long) nmemb); + 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) { @@ -9126,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 @@ -9148,12 +10285,14 @@ 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 }, @@ -9217,56 +10356,27 @@ 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; - /* Fall through. */ - 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"), letters); @@ -9294,90 +10404,63 @@ 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, 0, NULL }, - display_debug_abbrev, &do_debug_abbrevs, FALSE }, - { { ".debug_aranges", ".zdebug_aranges", NULL, NULL, 0, 0, 0, NULL, 0, NULL }, - display_debug_aranges, &do_debug_aranges, TRUE }, - { { ".debug_frame", ".zdebug_frame", NULL, NULL, 0, 0, 0, NULL, 0, NULL }, - display_debug_frames, &do_debug_frames, TRUE }, - { { ".debug_info", ".zdebug_info", NULL, NULL, 0, 0, abbrev, NULL, 0, NULL }, - display_debug_info, &do_debug_info, TRUE }, - { { ".debug_line", ".zdebug_line", NULL, NULL, 0, 0, 0, NULL, 0, NULL }, - display_debug_lines, &do_debug_lines, TRUE }, - { { ".debug_pubnames", ".zdebug_pubnames", NULL, NULL, 0, 0, 0, NULL, 0, NULL }, - display_debug_pubnames, &do_debug_pubnames, FALSE }, - { { ".debug_gnu_pubnames", ".zdebug_gnu_pubnames", NULL, NULL, 0, 0, 0, NULL, 0, NULL }, - display_debug_gnu_pubnames, &do_debug_pubnames, FALSE }, - { { ".eh_frame", "", NULL, NULL, 0, 0, 0, NULL, 0, NULL }, - display_debug_frames, &do_debug_frames, TRUE }, - { { ".debug_macinfo", ".zdebug_macinfo", NULL, NULL, 0, 0, 0, NULL, 0, NULL }, - display_debug_macinfo, &do_debug_macinfo, FALSE }, - { { ".debug_macro", ".zdebug_macro", NULL, NULL, 0, 0, 0, NULL, 0, NULL }, - display_debug_macro, &do_debug_macinfo, TRUE }, - { { ".debug_str", ".zdebug_str", NULL, NULL, 0, 0, 0, NULL, 0, NULL }, - display_debug_str, &do_debug_str, FALSE }, - { { ".debug_line_str", ".zdebug_line_str", NULL, NULL, 0, 0, 0, NULL, 0, NULL }, - display_debug_str, &do_debug_str, FALSE }, - { { ".debug_loc", ".zdebug_loc", NULL, NULL, 0, 0, 0, NULL, 0, NULL }, - display_debug_loc, &do_debug_loc, TRUE }, - { { ".debug_loclists", ".zdebug_loclists", NULL, NULL, 0, 0, 0, NULL, 0, NULL }, - display_debug_loc, &do_debug_loc, TRUE }, - { { ".debug_pubtypes", ".zdebug_pubtypes", NULL, NULL, 0, 0, 0, NULL, 0, NULL }, - display_debug_pubnames, &do_debug_pubtypes, FALSE }, - { { ".debug_gnu_pubtypes", ".zdebug_gnu_pubtypes", NULL, NULL, 0, 0, 0, NULL, 0, NULL }, - display_debug_gnu_pubnames, &do_debug_pubtypes, FALSE }, - { { ".debug_ranges", ".zdebug_ranges", NULL, NULL, 0, 0, 0, NULL, 0, NULL }, - display_debug_ranges, &do_debug_ranges, TRUE }, - { { ".debug_rnglists", ".zdebug_rnglists", NULL, NULL, 0, 0, 0, NULL, 0, NULL }, - display_debug_ranges, &do_debug_ranges, TRUE }, - { { ".debug_static_func", ".zdebug_static_func", NULL, NULL, 0, 0, 0, NULL, 0, NULL }, - display_debug_not_supported, NULL, FALSE }, - { { ".debug_static_vars", ".zdebug_static_vars", NULL, NULL, 0, 0, 0, NULL, 0, NULL }, - display_debug_not_supported, NULL, FALSE }, - { { ".debug_types", ".zdebug_types", NULL, NULL, 0, 0, abbrev, NULL, 0, NULL }, - display_debug_types, &do_debug_info, TRUE }, - { { ".debug_weaknames", ".zdebug_weaknames", NULL, NULL, 0, 0, 0, NULL, 0, NULL }, - display_debug_not_supported, NULL, FALSE }, - { { ".gdb_index", "", NULL, NULL, 0, 0, 0, NULL, 0, NULL }, - display_gdb_index, &do_gdb_index, FALSE }, - { { ".debug_names", "", NULL, NULL, 0, 0, 0, NULL, 0, NULL }, - display_debug_names, &do_gdb_index, FALSE }, - { { ".trace_info", "", NULL, NULL, 0, 0, trace_abbrev, NULL, 0, NULL }, - display_trace_info, &do_trace_info, TRUE }, - { { ".trace_abbrev", "", NULL, NULL, 0, 0, 0, NULL, 0, NULL }, - display_debug_abbrev, &do_trace_abbrevs, FALSE }, - { { ".trace_aranges", "", NULL, NULL, 0, 0, 0, NULL, 0, NULL }, - display_debug_aranges, &do_trace_aranges, FALSE }, - { { ".debug_info.dwo", ".zdebug_info.dwo", NULL, NULL, 0, 0, abbrev_dwo, NULL, 0, NULL }, - display_debug_info, &do_debug_info, TRUE }, - { { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo", NULL, NULL, 0, 0, 0, NULL, 0, NULL }, - display_debug_abbrev, &do_debug_abbrevs, FALSE }, - { { ".debug_types.dwo", ".zdebug_types.dwo", NULL, NULL, 0, 0, abbrev_dwo, NULL, 0, NULL }, - display_debug_types, &do_debug_info, TRUE }, - { { ".debug_line.dwo", ".zdebug_line.dwo", NULL, NULL, 0, 0, 0, NULL, 0, NULL }, - display_debug_lines, &do_debug_lines, TRUE }, - { { ".debug_loc.dwo", ".zdebug_loc.dwo", NULL, NULL, 0, 0, 0, NULL, 0, NULL }, - display_debug_loc, &do_debug_loc, TRUE }, - { { ".debug_macro.dwo", ".zdebug_macro.dwo", NULL, NULL, 0, 0, 0, NULL, 0, NULL }, - display_debug_macro, &do_debug_macinfo, TRUE }, - { { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo", NULL, NULL, 0, 0, 0, NULL, 0, NULL }, - display_debug_macinfo, &do_debug_macinfo, FALSE }, - { { ".debug_str.dwo", ".zdebug_str.dwo", NULL, NULL, 0, 0, 0, NULL, 0, NULL }, - display_debug_str, &do_debug_str, TRUE }, - { { ".debug_str_offsets", ".zdebug_str_offsets", NULL, NULL, 0, 0, 0, NULL, 0, NULL }, - display_debug_str_offsets, NULL, FALSE }, - { { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo", NULL, NULL, 0, 0, 0, NULL, 0, NULL }, - display_debug_str_offsets, NULL, FALSE }, - { { ".debug_addr", ".zdebug_addr", NULL, NULL, 0, 0, 0, NULL, 0, NULL }, - display_debug_addr, &do_debug_addr, TRUE }, - { { ".debug_cu_index", "", NULL, NULL, 0, 0, 0, NULL, 0, NULL }, - display_cu_index, &do_debug_cu_index, FALSE }, - { { ".debug_tu_index", "", NULL, NULL, 0, 0, 0, NULL, 0, NULL }, - display_cu_index, &do_debug_cu_index, FALSE }, + { { ".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. */