X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fdwarf2read.c;h=756d65baf291f6730f7c6ccfce408de6deda8e8a;hb=0ad93d4feb33a43ea32301721fc370a243b08940;hp=a9c4d781bbe85b5fd5d591aab84c22484eca953f;hpb=4390d890b50a4796599cc23f91dfab6e7c33c5e4;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/dwarf2read.c b/gdb/dwarf2read.c index a9c4d781bb..756d65baf2 100644 --- a/gdb/dwarf2read.c +++ b/gdb/dwarf2read.c @@ -1,6 +1,6 @@ /* DWARF 2 debugging format support for GDB. - Copyright (C) 1994-2013 Free Software Foundation, Inc. + Copyright (C) 1994-2014 Free Software Foundation, Inc. Adapted by Gary Funck (gary@intrepid.com), Intrepid Technology, Inc. with support from Florida State University (under contract @@ -56,7 +56,7 @@ #include "jv-lang.h" #include "psympriv.h" #include "exceptions.h" -#include "gdb_stat.h" +#include #include "completer.h" #include "vec.h" #include "c-lang.h" @@ -69,18 +69,18 @@ #include "f-lang.h" #include "source.h" #include "filestuff.h" +#include "build-id.h" #include -#include "gdb_string.h" -#include "gdb_assert.h" #include typedef struct symbol *symbolp; DEF_VEC_P (symbolp); -/* When non-zero, print basic high level tracing messages. +/* When == 1, print basic high level tracing messages. + When > 1, be more verbose. This is in contrast to the low level DIE reading of dwarf2_die_debug. */ -static int dwarf2_read_debug = 0; +static unsigned int dwarf2_read_debug = 0; /* When non-zero, dump DIEs after they are read in. */ static unsigned int dwarf2_die_debug = 0; @@ -100,13 +100,44 @@ static int dwarf2_loclist_index; static int dwarf2_locexpr_block_index; static int dwarf2_loclist_block_index; +/* A descriptor for dwarf sections. + + S.ASECTION, SIZE are typically initialized when the objfile is first + scanned. BUFFER, READIN are filled in later when the section is read. + If the section contained compressed data then SIZE is updated to record + the uncompressed size of the section. + + DWP file format V2 introduces a wrinkle that is easiest to handle by + creating the concept of virtual sections contained within a real section. + In DWP V2 the sections of the input DWO files are concatenated together + into one section, but section offsets are kept relative to the original + input section. + If this is a virtual dwp-v2 section, S.CONTAINING_SECTION is a backlink to + the real section this "virtual" section is contained in, and BUFFER,SIZE + describe the virtual section. */ + struct dwarf2_section_info { - asection *asection; + union + { + /* If this is a real section, the bfd section. */ + asection *asection; + /* If this is a virtual section, pointer to the containing ("real") + section. */ + struct dwarf2_section_info *containing_section; + } s; + /* Pointer to section data, only valid if readin. */ const gdb_byte *buffer; + /* The size of the section, real or virtual. */ bfd_size_type size; + /* If this is a virtual section, the offset in the real section. + Only valid if is_virtual. */ + bfd_size_type virtual_offset; /* True if we have tried to read this section. */ - int readin; + char readin; + /* True if this is a virtual section, False otherwise. + This specifies which of s.asection and s.containing_section to use. */ + char is_virtual; }; typedef struct dwarf2_section_info dwarf2_section_info_def; @@ -202,17 +233,14 @@ struct dwarf2_per_objfile /* The number of .debug_types-related CUs. */ int n_type_units; + /* The number of elements allocated in all_type_units. + If there are skeleton-less TUs, we add them to all_type_units lazily. */ + int n_allocated_type_units; + /* The .debug_types-related CUs (TUs). This is stored in malloc space because we may realloc it. */ struct signatured_type **all_type_units; - /* The number of entries in all_type_unit_groups. */ - int n_type_unit_groups; - - /* Table of type unit groups. - This exists to make it easy to iterate over all CUs and TU groups. */ - struct type_unit_group **all_type_unit_groups; - /* Table of struct type_unit_group objects. The hash key is the DW_AT_stmt_list value. */ htab_t type_unit_groups; @@ -229,6 +257,7 @@ struct dwarf2_per_objfile int nr_symtabs; int nr_symtab_sharers; int nr_stmt_less_type_units; + int nr_all_type_units_reallocs; } tu_stats; /* A chain of compilation units that are currently read in, so that @@ -480,12 +509,12 @@ struct dwarf2_cu /* The DW_AT_addr_base attribute if present, zero otherwise (zero is a valid value though). - Note this value comes from the stub CU/TU's DIE. */ + Note this value comes from the Fission stub CU/TU's DIE. */ ULONGEST addr_base; /* The DW_AT_ranges_base attribute if present, zero otherwise (zero is a valid value though). - Note this value comes from the stub CU/TU's DIE. + Note this value comes from the Fission stub CU/TU's DIE. Also note that the value is zero in the non-DWO case so this value can be used without needing to know whether DWO files are in use or not. N.B. This does not apply to DW_AT_ranges appearing in @@ -582,8 +611,8 @@ struct dwarf2_per_cu_data However we can enter this file with just a "per_cu" handle. */ struct objfile *objfile; - /* When using partial symbol tables, the 'psymtab' field is active. - Otherwise the 'quick' field is active. */ + /* When dwarf2_per_objfile->using_index is true, the 'quick' field + is active. Otherwise, the 'psymtab' field is active. */ union { /* The partial symbol table associated with this compilation unit, @@ -710,7 +739,7 @@ struct type_unit_group struct symtab **symtabs; }; -/* These sections are what may appear in a DWO file. */ +/* These sections are what may appear in a (real or virtual) DWO file. */ struct dwo_sections { @@ -741,7 +770,7 @@ struct dwo_unit /* The section this CU/TU lives in, in the DWO file. */ struct dwarf2_section_info *section; - /* Same as dwarf2_per_cu_data:{offset,length} but for the DWO section. */ + /* Same as dwarf2_per_cu_data:{offset,length} but in the DWO section. */ sect_offset offset; unsigned int length; @@ -749,9 +778,25 @@ struct dwo_unit cu_offset type_offset_in_tu; }; +/* include/dwarf2.h defines the DWP section codes. + It defines a max value but it doesn't define a min value, which we + use for error checking, so provide one. */ + +enum dwp_v2_section_ids +{ + DW_SECT_MIN = 1 +}; + /* Data for one DWO file. - This includes virtual DWO files that have been packaged into a - DWP file. */ + + This includes virtual DWO files (a virtual DWO file is a DWO file as it + appears in a DWP file). DWP files don't really have DWO files per se - + comdat folding of types "loses" the DWO file they came from, and from + a high level view DWP files appear to contain a mass of random types. + However, to maintain consistency with the non-DWP case we pretend DWP + files contain virtual DWO files, and we assign each TU with one virtual + DWO file (generally based on the line and abbrev section offsets - + a heuristic that seems to work in practice). */ struct dwo_file { @@ -768,7 +813,9 @@ struct dwo_file This is unused(NULL) for virtual DWO files where we use dwp_file.dbfd. */ bfd *dbfd; - /* Section info for this file. */ + /* The sections that make up this DWO file. + Remember that for virtual DWO files in DWP V2, these are virtual + sections (for lack of a better name). */ struct dwo_sections sections; /* The CU in the file. @@ -787,16 +834,33 @@ struct dwo_file struct dwp_sections { + /* These are used by both DWP version 1 and 2. */ struct dwarf2_section_info str; struct dwarf2_section_info cu_index; struct dwarf2_section_info tu_index; - /* The .debug_info.dwo, .debug_types.dwo, and other sections are referenced - by section number. We don't need to record them here. */ + + /* These are only used by DWP version 2 files. + In DWP version 1 the .debug_info.dwo, .debug_types.dwo, and other + sections are referenced by section number, and are not recorded here. + In DWP version 2 there is at most one copy of all these sections, each + section being (effectively) comprised of the concatenation of all of the + individual sections that exist in the version 1 format. + To keep the code simple we treat each of these concatenated pieces as a + section itself (a virtual section?). */ + struct dwarf2_section_info abbrev; + struct dwarf2_section_info info; + struct dwarf2_section_info line; + struct dwarf2_section_info loc; + struct dwarf2_section_info macinfo; + struct dwarf2_section_info macro; + struct dwarf2_section_info str_offsets; + struct dwarf2_section_info types; }; -/* These sections are what may appear in a virtual DWO file. */ +/* These sections are what may appear in a virtual DWO file in DWP version 1. + A virtual DWO file is a DWO file as it appears in a DWP file. */ -struct virtual_dwo_sections +struct virtual_v1_dwo_sections { struct dwarf2_section_info abbrev; struct dwarf2_section_info line; @@ -809,12 +873,66 @@ struct virtual_dwo_sections struct dwarf2_section_info info_or_types; }; +/* Similar to virtual_v1_dwo_sections, but for DWP version 2. + In version 2, the sections of the DWO files are concatenated together + and stored in one section of that name. Thus each ELF section contains + several "virtual" sections. */ + +struct virtual_v2_dwo_sections +{ + bfd_size_type abbrev_offset; + bfd_size_type abbrev_size; + + bfd_size_type line_offset; + bfd_size_type line_size; + + bfd_size_type loc_offset; + bfd_size_type loc_size; + + bfd_size_type macinfo_offset; + bfd_size_type macinfo_size; + + bfd_size_type macro_offset; + bfd_size_type macro_size; + + bfd_size_type str_offsets_offset; + bfd_size_type str_offsets_size; + + /* Each DWP hash table entry records one CU or one TU. + That is recorded here, and copied to dwo_unit.section. */ + bfd_size_type info_or_types_offset; + bfd_size_type info_or_types_size; +}; + /* Contents of DWP hash tables. */ struct dwp_hash_table { + uint32_t version, nr_columns; uint32_t nr_units, nr_slots; - const gdb_byte *hash_table, *unit_table, *section_pool; + const gdb_byte *hash_table, *unit_table; + union + { + struct + { + const gdb_byte *indices; + } v1; + struct + { + /* This is indexed by column number and gives the id of the section + in that column. */ +#define MAX_NR_V2_DWO_SECTIONS \ + (1 /* .debug_info or .debug_types */ \ + + 1 /* .debug_abbrev */ \ + + 1 /* .debug_line */ \ + + 1 /* .debug_loc */ \ + + 1 /* .debug_str_offsets */ \ + + 1 /* .debug_macro or .debug_macinfo */) + int section_ids[MAX_NR_V2_DWO_SECTIONS]; + const gdb_byte *offsets; + const gdb_byte *sizes; + } v2; + } section_pool; }; /* Data for one DWP file. */ @@ -824,22 +942,27 @@ struct dwp_file /* Name of the file. */ const char *name; + /* File format version. */ + int version; + /* The bfd. */ bfd *dbfd; /* Section info for this file. */ struct dwp_sections sections; - /* Table of CUs in the file. */ + /* Table of CUs in the file. */ const struct dwp_hash_table *cus; /* Table of TUs in the file. */ const struct dwp_hash_table *tus; - /* Table of loaded CUs/TUs. Each entry is a struct dwo_unit *. */ - htab_t loaded_cutus; + /* Tables of loaded CUs/TUs. Each entry is a struct dwo_unit *. */ + htab_t loaded_cus; + htab_t loaded_tus; - /* Table to map ELF section numbers to their sections. */ + /* Table to map ELF section numbers to their sections. + This is only needed for the DWP V1 file format. */ unsigned int num_sections; asection **elf_sections; }; @@ -867,7 +990,7 @@ struct dwz_file struct die_reader_specs { - /* die_section->asection->owner. */ + /* The bfd of die_section. */ bfd* abfd; /* The CU of the DIE we are parsing. */ @@ -1098,6 +1221,9 @@ struct die_info type derived from this DIE. */ unsigned char building_fullname : 1; + /* True if this die is in process. PR 16581. */ + unsigned char in_process : 1; + /* Abbrev number */ unsigned int abbrev; @@ -1238,6 +1364,10 @@ show_dwarf2_max_cache_age (struct ui_file *file, int from_tty, /* local function prototypes */ +static const char *get_section_name (const struct dwarf2_section_info *); + +static const char *get_section_file_name (const struct dwarf2_section_info *); + static void dwarf2_locate_sections (bfd *, asection *, void *); static void dwarf2_find_base_address (struct die_info *die, @@ -1358,7 +1488,7 @@ static CORE_ADDR read_addr_index_from_leb128 (struct dwarf2_cu *, unsigned int *); static const char *read_str_index (const struct die_reader_specs *reader, - struct dwarf2_cu *cu, ULONGEST str_index); + ULONGEST str_index); static void set_cu_language (unsigned int, struct dwarf2_cu *); @@ -1481,6 +1611,8 @@ static void read_module (struct die_info *die, struct dwarf2_cu *cu); static void read_import_statement (struct die_info *die, struct dwarf2_cu *); +static int read_namespace_alias (struct die_info *die, struct dwarf2_cu *cu); + static struct type *read_module_type (struct die_info *die, struct dwarf2_cu *cu); @@ -1579,11 +1711,6 @@ static void load_full_type_unit (struct dwarf2_per_cu_data *per_cu); static void read_signatured_type (struct signatured_type *); -static struct type_unit_group *get_type_unit_group - (struct dwarf2_cu *, const struct attribute *); - -static void build_type_unit_groups (die_reader_func_ftype *, void *); - /* memory allocation interface */ static struct dwarf_block *dwarf_alloc_block (struct dwarf2_cu *); @@ -1699,9 +1826,9 @@ static htab_t allocate_signatured_type_table (struct objfile *objfile); static htab_t allocate_dwo_unit_table (struct objfile *objfile); -static struct dwo_unit *lookup_dwo_in_dwp - (struct dwp_file *dwp_file, const struct dwp_hash_table *htab, - const char *comp_dir, ULONGEST signature, int is_debug_types); +static struct dwo_unit *lookup_dwo_unit_in_dwp + (struct dwp_file *dwp_file, const char *comp_dir, + ULONGEST signature, int is_debug_types); static struct dwp_file *get_dwp_file (void); @@ -1764,8 +1891,8 @@ dwarf2_section_buffer_overflow_complaint (struct dwarf2_section_info *section) complaint (&symfile_complaints, _("debug info runs off end of %s section" " [in module %s]"), - section->asection->name, - bfd_get_filename (section->asection->owner)); + get_section_name (section), + get_section_file_name (section)); } static void @@ -1806,6 +1933,36 @@ byte_swap (offset_type value) #define MAYBE_SWAP(V) (V) #endif /* WORDS_BIGENDIAN */ +/* Read the given attribute value as an address, taking the attribute's + form into account. */ + +static CORE_ADDR +attr_value_as_address (struct attribute *attr) +{ + CORE_ADDR addr; + + if (attr->form != DW_FORM_addr && attr->form != DW_FORM_GNU_addr_index) + { + /* Aside from a few clearly defined exceptions, attributes that + contain an address must always be in DW_FORM_addr form. + Unfortunately, some compilers happen to be violating this + requirement by encoding addresses using other forms, such + as DW_FORM_data4 for example. For those broken compilers, + we try to do our best, without any guarantee of success, + to interpret the address correctly. It would also be nice + to generate a complaint, but that would require us to maintain + a list of legitimate cases where a non-address form is allowed, + as well as update callers to pass in at least the CU's DWARF + version. This is more overhead than what we're willing to + expand for a pretty rare case. */ + addr = DW_UNSND (attr); + } + else + addr = DW_ADDR (attr); + + return addr; +} + /* The suffix for an index file. */ #define INDEX_SUFFIX ".gdb-index" @@ -1833,8 +1990,92 @@ dwarf2_has_info (struct objfile *objfile, (void *) names); dwarf2_per_objfile->objfile = objfile; } - return (dwarf2_per_objfile->info.asection != NULL - && dwarf2_per_objfile->abbrev.asection != NULL); + return (!dwarf2_per_objfile->info.is_virtual + && dwarf2_per_objfile->info.s.asection != NULL + && !dwarf2_per_objfile->abbrev.is_virtual + && dwarf2_per_objfile->abbrev.s.asection != NULL); +} + +/* Return the containing section of virtual section SECTION. */ + +static struct dwarf2_section_info * +get_containing_section (const struct dwarf2_section_info *section) +{ + gdb_assert (section->is_virtual); + return section->s.containing_section; +} + +/* Return the bfd owner of SECTION. */ + +static struct bfd * +get_section_bfd_owner (const struct dwarf2_section_info *section) +{ + if (section->is_virtual) + { + section = get_containing_section (section); + gdb_assert (!section->is_virtual); + } + return section->s.asection->owner; +} + +/* Return the bfd section of SECTION. + Returns NULL if the section is not present. */ + +static asection * +get_section_bfd_section (const struct dwarf2_section_info *section) +{ + if (section->is_virtual) + { + section = get_containing_section (section); + gdb_assert (!section->is_virtual); + } + return section->s.asection; +} + +/* Return the name of SECTION. */ + +static const char * +get_section_name (const struct dwarf2_section_info *section) +{ + asection *sectp = get_section_bfd_section (section); + + gdb_assert (sectp != NULL); + return bfd_section_name (get_section_bfd_owner (section), sectp); +} + +/* Return the name of the file SECTION is in. */ + +static const char * +get_section_file_name (const struct dwarf2_section_info *section) +{ + bfd *abfd = get_section_bfd_owner (section); + + return bfd_get_filename (abfd); +} + +/* Return the id of SECTION. + Returns 0 if SECTION doesn't exist. */ + +static int +get_section_id (const struct dwarf2_section_info *section) +{ + asection *sectp = get_section_bfd_section (section); + + if (sectp == NULL) + return 0; + return sectp->id; +} + +/* Return the flags of SECTION. + SECTION (or containing section if this is a virtual section) must exist. */ + +static int +get_section_flags (const struct dwarf2_section_info *section) +{ + asection *sectp = get_section_bfd_section (section); + + gdb_assert (sectp != NULL); + return bfd_get_section_flags (sectp->owner, sectp); } /* When loading sections, we look either for uncompressed section or for @@ -1873,57 +2114,57 @@ dwarf2_locate_sections (bfd *abfd, asection *sectp, void *vnames) } else if (section_is_p (sectp->name, &names->info)) { - dwarf2_per_objfile->info.asection = sectp; + dwarf2_per_objfile->info.s.asection = sectp; dwarf2_per_objfile->info.size = bfd_get_section_size (sectp); } else if (section_is_p (sectp->name, &names->abbrev)) { - dwarf2_per_objfile->abbrev.asection = sectp; + dwarf2_per_objfile->abbrev.s.asection = sectp; dwarf2_per_objfile->abbrev.size = bfd_get_section_size (sectp); } else if (section_is_p (sectp->name, &names->line)) { - dwarf2_per_objfile->line.asection = sectp; + dwarf2_per_objfile->line.s.asection = sectp; dwarf2_per_objfile->line.size = bfd_get_section_size (sectp); } else if (section_is_p (sectp->name, &names->loc)) { - dwarf2_per_objfile->loc.asection = sectp; + dwarf2_per_objfile->loc.s.asection = sectp; dwarf2_per_objfile->loc.size = bfd_get_section_size (sectp); } else if (section_is_p (sectp->name, &names->macinfo)) { - dwarf2_per_objfile->macinfo.asection = sectp; + dwarf2_per_objfile->macinfo.s.asection = sectp; dwarf2_per_objfile->macinfo.size = bfd_get_section_size (sectp); } else if (section_is_p (sectp->name, &names->macro)) { - dwarf2_per_objfile->macro.asection = sectp; + dwarf2_per_objfile->macro.s.asection = sectp; dwarf2_per_objfile->macro.size = bfd_get_section_size (sectp); } else if (section_is_p (sectp->name, &names->str)) { - dwarf2_per_objfile->str.asection = sectp; + dwarf2_per_objfile->str.s.asection = sectp; dwarf2_per_objfile->str.size = bfd_get_section_size (sectp); } else if (section_is_p (sectp->name, &names->addr)) { - dwarf2_per_objfile->addr.asection = sectp; + dwarf2_per_objfile->addr.s.asection = sectp; dwarf2_per_objfile->addr.size = bfd_get_section_size (sectp); } else if (section_is_p (sectp->name, &names->frame)) { - dwarf2_per_objfile->frame.asection = sectp; + dwarf2_per_objfile->frame.s.asection = sectp; dwarf2_per_objfile->frame.size = bfd_get_section_size (sectp); } else if (section_is_p (sectp->name, &names->eh_frame)) { - dwarf2_per_objfile->eh_frame.asection = sectp; + dwarf2_per_objfile->eh_frame.s.asection = sectp; dwarf2_per_objfile->eh_frame.size = bfd_get_section_size (sectp); } else if (section_is_p (sectp->name, &names->ranges)) { - dwarf2_per_objfile->ranges.asection = sectp; + dwarf2_per_objfile->ranges.s.asection = sectp; dwarf2_per_objfile->ranges.size = bfd_get_section_size (sectp); } else if (section_is_p (sectp->name, &names->types)) @@ -1931,7 +2172,7 @@ dwarf2_locate_sections (bfd *abfd, asection *sectp, void *vnames) struct dwarf2_section_info type_section; memset (&type_section, 0, sizeof (type_section)); - type_section.asection = sectp; + type_section.s.asection = sectp; type_section.size = bfd_get_section_size (sectp); VEC_safe_push (dwarf2_section_info_def, dwarf2_per_objfile->types, @@ -1939,7 +2180,7 @@ dwarf2_locate_sections (bfd *abfd, asection *sectp, void *vnames) } else if (section_is_p (sectp->name, &names->gdb_index)) { - dwarf2_per_objfile->gdb_index.asection = sectp; + dwarf2_per_objfile->gdb_index.s.asection = sectp; dwarf2_per_objfile->gdb_index.size = bfd_get_section_size (sectp); } @@ -1952,24 +2193,25 @@ dwarf2_locate_sections (bfd *abfd, asection *sectp, void *vnames) or not present. */ static int -dwarf2_section_empty_p (struct dwarf2_section_info *info) +dwarf2_section_empty_p (const struct dwarf2_section_info *section) { - return info->asection == NULL || info->size == 0; + if (section->is_virtual) + return section->size == 0; + return section->s.asection == NULL || section->size == 0; } /* Read the contents of the section INFO. OBJFILE is the main object file, but not necessarily the file where - the section comes from. E.g., for DWO files INFO->asection->owner - is the bfd of the DWO file. + the section comes from. E.g., for DWO files the bfd of INFO is the bfd + of the DWO file. If the section is compressed, uncompress it before returning. */ static void dwarf2_read_section (struct objfile *objfile, struct dwarf2_section_info *info) { - asection *sectp = info->asection; + asection *sectp; bfd *abfd; gdb_byte *buf, *retbuf; - unsigned char header[4]; if (info->readin) return; @@ -1979,7 +2221,32 @@ dwarf2_read_section (struct objfile *objfile, struct dwarf2_section_info *info) if (dwarf2_section_empty_p (info)) return; - abfd = sectp->owner; + sectp = get_section_bfd_section (info); + + /* If this is a virtual section we need to read in the real one first. */ + if (info->is_virtual) + { + struct dwarf2_section_info *containing_section = + get_containing_section (info); + + gdb_assert (sectp != NULL); + if ((sectp->flags & SEC_RELOC) != 0) + { + error (_("Dwarf Error: DWP format V2 with relocations is not" + " supported in section %s [in module %s]"), + get_section_name (info), get_section_file_name (info)); + } + dwarf2_read_section (objfile, containing_section); + /* Other code should have already caught virtual sections that don't + fit. */ + gdb_assert (info->virtual_offset + info->size + <= containing_section->size); + /* If the real section is empty or there was a problem reading the + section we shouldn't get here. */ + gdb_assert (containing_section->buffer != NULL); + info->buffer = containing_section->buffer + info->virtual_offset; + return; + } /* If the section has relocations, we must read it ourselves. Otherwise we attach it to the BFD. */ @@ -2003,10 +2270,16 @@ dwarf2_read_section (struct objfile *objfile, struct dwarf2_section_info *info) return; } + abfd = get_section_bfd_owner (info); + gdb_assert (abfd != NULL); + if (bfd_seek (abfd, sectp->filepos, SEEK_SET) != 0 || bfd_bread (buf, info->size, abfd) != info->size) - error (_("Dwarf Error: Can't read DWARF data from '%s'"), - bfd_get_filename (abfd)); + { + error (_("Dwarf Error: Can't read DWARF data" + " in section %s [in module %s]"), + bfd_section_name (abfd, sectp), bfd_get_filename (abfd)); + } } /* A helper function that returns the size of a section in a safe way. @@ -2061,7 +2334,7 @@ dwarf2_get_section_info (struct objfile *objfile, dwarf2_read_section (objfile, info); - *sectp = info->asection; + *sectp = get_section_bfd_section (info); *bufp = info->buffer; *sizep = info->size; } @@ -2077,32 +2350,32 @@ locate_dwz_sections (bfd *abfd, asection *sectp, void *arg) is ELF-only (at the time of writing). */ if (section_is_p (sectp->name, &dwarf2_elf_names.abbrev)) { - dwz_file->abbrev.asection = sectp; + dwz_file->abbrev.s.asection = sectp; dwz_file->abbrev.size = bfd_get_section_size (sectp); } else if (section_is_p (sectp->name, &dwarf2_elf_names.info)) { - dwz_file->info.asection = sectp; + dwz_file->info.s.asection = sectp; dwz_file->info.size = bfd_get_section_size (sectp); } else if (section_is_p (sectp->name, &dwarf2_elf_names.str)) { - dwz_file->str.asection = sectp; + dwz_file->str.s.asection = sectp; dwz_file->str.size = bfd_get_section_size (sectp); } else if (section_is_p (sectp->name, &dwarf2_elf_names.line)) { - dwz_file->line.asection = sectp; + dwz_file->line.s.asection = sectp; dwz_file->line.size = bfd_get_section_size (sectp); } else if (section_is_p (sectp->name, &dwarf2_elf_names.macro)) { - dwz_file->macro.asection = sectp; + dwz_file->macro.s.asection = sectp; dwz_file->macro.size = bfd_get_section_size (sectp); } else if (section_is_p (sectp->name, &dwarf2_elf_names.gdb_index)) { - dwz_file->gdb_index.asection = sectp; + dwz_file->gdb_index.s.asection = sectp; dwz_file->gdb_index.size = bfd_get_section_size (sectp); } } @@ -2119,14 +2392,16 @@ dwarf2_get_dwz_file (void) struct cleanup *cleanup; const char *filename; struct dwz_file *result; - unsigned long buildid; + bfd_size_type buildid_len_arg; + size_t buildid_len; + bfd_byte *buildid; if (dwarf2_per_objfile->dwz_file != NULL) return dwarf2_per_objfile->dwz_file; bfd_set_error (bfd_error_no_error); data = bfd_get_alt_debug_link_info (dwarf2_per_objfile->objfile->obfd, - &buildid); + &buildid_len_arg, &buildid); if (data == NULL) { if (bfd_get_error () == bfd_error_no_error) @@ -2135,11 +2410,14 @@ dwarf2_get_dwz_file (void) bfd_errmsg (bfd_get_error ())); } cleanup = make_cleanup (xfree, data); + make_cleanup (xfree, buildid); + + buildid_len = (size_t) buildid_len_arg; filename = (const char *) data; if (!IS_ABSOLUTE_PATH (filename)) { - char *abs = gdb_realpath (dwarf2_per_objfile->objfile->name); + char *abs = gdb_realpath (objfile_name (dwarf2_per_objfile->objfile)); char *rel; make_cleanup (xfree, abs); @@ -2151,20 +2429,25 @@ dwarf2_get_dwz_file (void) filename = rel; } - /* The format is just a NUL-terminated file name, followed by the - build-id. For now, though, we ignore the build-id. */ + /* First try the file name given in the section. If that doesn't + work, try to use the build-id instead. */ dwz_bfd = gdb_bfd_open (filename, gnutarget, -1); - if (dwz_bfd == NULL) - error (_("could not read '%s': %s"), filename, - bfd_errmsg (bfd_get_error ())); - - if (!bfd_check_format (dwz_bfd, bfd_object)) + if (dwz_bfd != NULL) { - gdb_bfd_unref (dwz_bfd); - error (_("file '%s' was not usable: %s"), filename, - bfd_errmsg (bfd_get_error ())); + if (!build_id_verify (dwz_bfd, buildid_len, buildid)) + { + gdb_bfd_unref (dwz_bfd); + dwz_bfd = NULL; + } } + if (dwz_bfd == NULL) + dwz_bfd = build_id_to_debug_bfd (buildid_len, buildid); + + if (dwz_bfd == NULL) + error (_("could not find '.gnu_debugaltlink' file for %s"), + objfile_name (dwarf2_per_objfile->objfile)); + result = OBSTACK_ZALLOC (&dwarf2_per_objfile->objfile->objfile_obstack, struct dwz_file); result->dwz_bfd = dwz_bfd; @@ -2173,6 +2456,7 @@ dwarf2_get_dwz_file (void) do_cleanups (cleanup); + gdb_bfd_record_inclusion (dwarf2_per_objfile->objfile->obfd, dwz_bfd); dwarf2_per_objfile->dwz_file = result; return result; } @@ -2380,21 +2664,21 @@ dw2_instantiate_symtab (struct dwarf2_per_cu_data *per_cu) return per_cu->v.quick->symtab; } -/* Return the CU given its index. +/* Return the CU/TU given its index. This is intended for loops like: for (i = 0; i < (dwarf2_per_objfile->n_comp_units + dwarf2_per_objfile->n_type_units); ++i) { - struct dwarf2_per_cu_data *per_cu = dw2_get_cu (i); + struct dwarf2_per_cu_data *per_cu = dw2_get_cutu (i); ...; } */ static struct dwarf2_per_cu_data * -dw2_get_cu (int index) +dw2_get_cutu (int index) { if (index >= dwarf2_per_objfile->n_comp_units) { @@ -2406,30 +2690,14 @@ dw2_get_cu (int index) return dwarf2_per_objfile->all_comp_units[index]; } -/* Return the primary CU given its index. - The difference between this function and dw2_get_cu is in the handling - of type units (TUs). Here we return the type_unit_group object. - - This is intended for loops like: - - for (i = 0; i < (dwarf2_per_objfile->n_comp_units - + dwarf2_per_objfile->n_type_unit_groups); ++i) - { - struct dwarf2_per_cu_data *per_cu = dw2_get_primary_cu (i); - - ...; - } -*/ +/* Return the CU given its index. + This differs from dw2_get_cutu in that it's for when you know INDEX + refers to a CU. */ static struct dwarf2_per_cu_data * -dw2_get_primary_cu (int index) +dw2_get_cu (int index) { - if (index >= dwarf2_per_objfile->n_comp_units) - { - index -= dwarf2_per_objfile->n_comp_units; - gdb_assert (index < dwarf2_per_objfile->n_type_unit_groups); - return &dwarf2_per_objfile->all_type_unit_groups[index]->per_cu; - } + gdb_assert (index >= 0 && index < dwarf2_per_objfile->n_comp_units); return dwarf2_per_objfile->all_comp_units[index]; } @@ -2507,7 +2775,9 @@ create_signatured_type_table_from_index (struct objfile *objfile, offset_type i; htab_t sig_types_hash; - dwarf2_per_objfile->n_type_units = elements / 3; + dwarf2_per_objfile->n_type_units + = dwarf2_per_objfile->n_allocated_type_units + = elements / 3; dwarf2_per_objfile->all_type_units = xmalloc (dwarf2_per_objfile->n_type_units * sizeof (struct signatured_type *)); @@ -2596,7 +2866,7 @@ create_addrmap_from_index (struct objfile *objfile, struct mapped_index *index) } addrmap_set_empty (mutable_map, lo + baseaddr, hi + baseaddr - 1, - dw2_get_cu (cu_index)); + dw2_get_cutu (cu_index)); } objfile->psymtabs_addrmap = addrmap_create_fixed (mutable_map, @@ -2731,7 +3001,7 @@ read_index_from_section (struct objfile *objfile, /* Older elfutils strip versions could keep the section in the main executable while splitting it for the separate debug info file. */ - if ((bfd_get_file_flags (section->asection) & SEC_HAS_CONTENTS) == 0) + if ((get_section_flags (section) & SEC_HAS_CONTENTS) == 0) return 0; dwarf2_read_section (objfile, section); @@ -2777,9 +3047,12 @@ to use the section anyway."), return 0; } /* Version 7 indices generated by gold refer to the CU for a symbol instead - of the TU (for symbols coming from TUs). It's just a performance bug, and - we can't distinguish gdb-generated indices from gold-generated ones, so - nothing to do here. */ + of the TU (for symbols coming from TUs), + http://sourceware.org/bugzilla/show_bug.cgi?id=15021. + Plus gold-generated indices can have duplicate entries for global symbols, + http://sourceware.org/bugzilla/show_bug.cgi?id=15646. + These are just performance bugs, and we can't distinguish gdb-generated + indices from gold-generated ones, so issue no warning here. */ /* Indexes with higher version than the one supported by GDB may be no longer backward compatible. */ @@ -2831,7 +3104,7 @@ dwarf2_read_index (struct objfile *objfile) offset_type cu_list_elements, types_list_elements, dwz_list_elements = 0; struct dwz_file *dwz; - if (!read_index_from_section (objfile, objfile->name, + if (!read_index_from_section (objfile, objfile_name (objfile), use_deprecated_index_sections, &dwarf2_per_objfile->gdb_index, &local_map, &cu_list, &cu_list_elements, @@ -3022,7 +3295,7 @@ dw2_get_real_path (struct objfile *objfile, { if (qfn->real_names == NULL) qfn->real_names = OBSTACK_CALLOC (&objfile->objfile_obstack, - qfn->num_file_names, sizeof (char *)); + qfn->num_file_names, const char *); if (qfn->real_names[index] == NULL) qfn->real_names[index] = gdb_realpath (qfn->file_names[index]); @@ -3037,7 +3310,7 @@ dw2_find_last_source_symtab (struct objfile *objfile) dw2_setup (objfile); index = dwarf2_per_objfile->n_comp_units - 1; - return dw2_instantiate_symtab (dw2_get_cu (index)); + return dw2_instantiate_symtab (dw2_get_cutu (index)); } /* Traversal function for dw2_forget_cached_source_info. */ @@ -3113,7 +3386,7 @@ dw2_map_symtabs_matching_filename (struct objfile *objfile, const char *name, for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i) { int j; - struct dwarf2_per_cu_data *per_cu = dw2_get_primary_cu (i); + struct dwarf2_per_cu_data *per_cu = dw2_get_cu (i); struct quick_file_names *file_data; /* We only need to look at symtabs not already expanded. */ @@ -3191,6 +3464,11 @@ struct dw2_symtab_iterator int next; /* The number of elements in VEC, or zero if there is no match. */ int length; + /* Have we seen a global version of the symbol? + If so we can ignore all further global instances. + This is to work around gold/15646, inefficient gold-generated + indices. */ + int global_seen; }; /* Initialize the index symtab iterator ITER. @@ -3210,6 +3488,7 @@ dw2_symtab_iter_init (struct dw2_symtab_iterator *iter, iter->block_index = block_index; iter->domain = domain; iter->next = 0; + iter->global_seen = 0; if (find_slot_in_mapped_hash (index, name, &iter->vec)) iter->length = MAYBE_SWAP (*iter->vec); @@ -3250,20 +3529,29 @@ dw2_symtab_iter_next (struct dw2_symtab_iterator *iter) { complaint (&symfile_complaints, _(".gdb_index entry has bad CU index" - " [in module %s]"), dwarf2_per_objfile->objfile->name); + " [in module %s]"), + objfile_name (dwarf2_per_objfile->objfile)); continue; } - per_cu = dw2_get_cu (cu_index); + per_cu = dw2_get_cutu (cu_index); /* Skip if already read in. */ if (per_cu->v.quick->symtab) continue; - if (attrs_valid - && iter->want_specific_block - && want_static != is_static) - continue; + /* Check static vs global. */ + if (attrs_valid) + { + if (iter->want_specific_block + && want_static != is_static) + continue; + /* Work around gold/15646. */ + if (!is_static && iter->global_seen) + continue; + if (!is_static) + iter->global_seen = 1; + } /* Only check the symbol's kind if it has one. */ if (attrs_valid) @@ -3326,7 +3614,7 @@ dw2_lookup_symbol (struct objfile *objfile, int block_index, information (but NAME might contain it). */ if (stab->primary) { - struct blockvector *bv = BLOCKVECTOR (stab); + const struct blockvector *bv = BLOCKVECTOR (stab); struct block *block = BLOCKVECTOR_BLOCK (bv, block_index); sym = lookup_block_symbol (block, name, domain); @@ -3357,7 +3645,7 @@ dw2_print_stats (struct objfile *objfile) count = 0; for (i = 0; i < total; ++i) { - struct dwarf2_per_cu_data *per_cu = dw2_get_cu (i); + struct dwarf2_per_cu_data *per_cu = dw2_get_cutu (i); if (!per_cu->v.quick->symtab) ++count; @@ -3430,7 +3718,7 @@ dw2_expand_all_symtabs (struct objfile *objfile) for (i = 0; i < (dwarf2_per_objfile->n_comp_units + dwarf2_per_objfile->n_type_units); ++i) { - struct dwarf2_per_cu_data *per_cu = dw2_get_cu (i); + struct dwarf2_per_cu_data *per_cu = dw2_get_cutu (i); dw2_instantiate_symtab (per_cu); } @@ -3452,7 +3740,7 @@ dw2_expand_symtabs_with_fullname (struct objfile *objfile, for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i) { int j; - struct dwarf2_per_cu_data *per_cu = dw2_get_cu (i); + struct dwarf2_per_cu_data *per_cu = dw2_get_cutu (i); struct quick_file_names *file_data; /* We only need to look at symtabs not already expanded. */ @@ -3477,8 +3765,9 @@ dw2_expand_symtabs_with_fullname (struct objfile *objfile, } static void -dw2_map_matching_symbols (const char * name, domain_enum namespace, - struct objfile *objfile, int global, +dw2_map_matching_symbols (struct objfile *objfile, + const char * name, domain_enum namespace, + int global, int (*callback) (struct block *, struct symbol *, void *), void *data, symbol_compare_ftype *match, @@ -3492,8 +3781,8 @@ dw2_map_matching_symbols (const char * name, domain_enum namespace, static void dw2_expand_symtabs_matching (struct objfile *objfile, - int (*file_matcher) (const char *, void *, int basenames), - int (*name_matcher) (const char *, void *), + expand_symtabs_file_matcher_ftype *file_matcher, + expand_symtabs_symbol_matcher_ftype *symbol_matcher, enum search_domain kind, void *data) { @@ -3528,7 +3817,7 @@ dw2_expand_symtabs_matching for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i) { int j; - struct dwarf2_per_cu_data *per_cu = dw2_get_primary_cu (i); + struct dwarf2_per_cu_data *per_cu = dw2_get_cu (i); struct quick_file_names *file_data; void **slot; @@ -3590,13 +3879,14 @@ dw2_expand_symtabs_matching offset_type idx = 2 * iter; const char *name; offset_type *vec, vec_len, vec_idx; + int global_seen = 0; if (index->symbol_table[idx] == 0 && index->symbol_table[idx + 1] == 0) continue; name = index->constant_pool + MAYBE_SWAP (index->symbol_table[idx]); - if (! (*name_matcher) (name, data)) + if (! (*symbol_matcher) (name, data)) continue; /* The name was matched, now expand corresponding CUs that were @@ -3608,6 +3898,8 @@ dw2_expand_symtabs_matching { struct dwarf2_per_cu_data *per_cu; offset_type cu_index_and_attrs = MAYBE_SWAP (vec[vec_idx + 1]); + /* This value is only valid for index versions >= 7. */ + int is_static = GDB_INDEX_SYMBOL_STATIC_VALUE (cu_index_and_attrs); gdb_index_symbol_kind symbol_kind = GDB_INDEX_SYMBOL_KIND_VALUE (cu_index_and_attrs); int cu_index = GDB_INDEX_CU_VALUE (cu_index_and_attrs); @@ -3619,6 +3911,15 @@ dw2_expand_symtabs_matching (index->version >= 7 && symbol_kind != GDB_INDEX_SYMBOL_KIND_NONE); + /* Work around gold/15646. */ + if (attrs_valid) + { + if (!is_static && global_seen) + continue; + if (!is_static) + global_seen = 1; + } + /* Only check the symbol's kind if it has one. */ if (attrs_valid) { @@ -3647,11 +3948,11 @@ dw2_expand_symtabs_matching { complaint (&symfile_complaints, _(".gdb_index entry has bad CU index" - " [in module %s]"), objfile->name); + " [in module %s]"), objfile_name (objfile)); continue; } - per_cu = dw2_get_cu (cu_index); + per_cu = dw2_get_cutu (cu_index); if (file_matcher == NULL || per_cu->v.quick->mark) dw2_instantiate_symtab (per_cu); } @@ -3687,7 +3988,7 @@ recursively_find_pc_sect_symtab (struct symtab *symtab, CORE_ADDR pc) static struct symtab * dw2_find_pc_sect_symtab (struct objfile *objfile, - struct minimal_symbol *msymbol, + struct bound_minimal_symbol msymbol, CORE_ADDR pc, struct obj_section *section, int warn_if_readin) @@ -3731,7 +4032,7 @@ dw2_map_symbol_filenames (struct objfile *objfile, symbol_filename_ftype *fun, for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i) { - struct dwarf2_per_cu_data *per_cu = dw2_get_cu (i); + struct dwarf2_per_cu_data *per_cu = dw2_get_cutu (i); if (per_cu->v.quick->symtab) { @@ -3745,7 +4046,7 @@ dw2_map_symbol_filenames (struct objfile *objfile, symbol_filename_ftype *fun, for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i) { int j; - struct dwarf2_per_cu_data *per_cu = dw2_get_primary_cu (i); + struct dwarf2_per_cu_data *per_cu = dw2_get_cu (i); struct quick_file_names *file_data; void **slot; @@ -3828,7 +4129,7 @@ dwarf2_initialize_objfile (struct objfile *objfile) for (i = 0; i < (dwarf2_per_objfile->n_comp_units + dwarf2_per_objfile->n_type_units); ++i) { - struct dwarf2_per_cu_data *per_cu = dw2_get_cu (i); + struct dwarf2_per_cu_data *per_cu = dw2_get_cutu (i); per_cu->v.quick = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwarf2_per_cu_quick_data); @@ -3910,7 +4211,7 @@ dwarf2_find_base_address (struct die_info *die, struct dwarf2_cu *cu) attr = dwarf2_attr (die, DW_AT_entry_pc, cu); if (attr) { - cu->base_address = DW_ADDR (attr); + cu->base_address = attr_value_as_address (attr); cu->base_known = 1; } else @@ -3918,7 +4219,7 @@ dwarf2_find_base_address (struct die_info *die, struct dwarf2_cu *cu) attr = dwarf2_attr (die, DW_AT_low_pc, cu); if (attr) { - cu->base_address = DW_ADDR (attr); + cu->base_address = attr_value_as_address (attr); cu->base_known = 1; } } @@ -3980,8 +4281,8 @@ error_check_comp_unit_head (struct comp_unit_head *header, struct dwarf2_section_info *section, struct dwarf2_section_info *abbrev_section) { - bfd *abfd = section->asection->owner; - const char *filename = bfd_get_filename (abfd); + bfd *abfd = get_section_bfd_owner (section); + const char *filename = get_section_file_name (section); if (header->version != 2 && header->version != 3 && header->version != 4) error (_("Dwarf Error: wrong version in compilation unit header " @@ -4017,7 +4318,7 @@ read_and_check_comp_unit_head (struct comp_unit_head *header, int is_debug_types_section) { const gdb_byte *beg_of_comp_unit = info_ptr; - bfd *abfd = section->asection->owner; + bfd *abfd = get_section_bfd_owner (section); header->offset.sect_off = beg_of_comp_unit - section->buffer; @@ -4047,7 +4348,7 @@ read_and_check_type_unit_head (struct comp_unit_head *header, cu_offset *type_offset_in_tu) { const gdb_byte *beg_of_comp_unit = info_ptr; - bfd *abfd = section->asection->owner; + bfd *abfd = get_section_bfd_owner (section); header->offset.sect_off = beg_of_comp_unit - section->buffer; @@ -4076,7 +4377,7 @@ static sect_offset read_abbrev_offset (struct dwarf2_section_info *section, sect_offset offset) { - bfd *abfd = section->asection->owner; + bfd *abfd = get_section_bfd_owner (section); const gdb_byte *info_ptr; unsigned int length, initial_length_size, offset_size; sect_offset abbrev_offset; @@ -4228,7 +4529,7 @@ create_debug_types_hash_table (struct dwo_file *dwo_file, if (dwarf2_read_debug) fprintf_unfiltered (gdb_stdlog, "Reading .debug_types%s for %s:\n", dwo_file ? ".dwo" : "", - bfd_get_filename (abbrev_section->asection->owner)); + get_section_file_name (abbrev_section)); for (ix = 0; VEC_iterate (dwarf2_section_info_def, types, ix, section); @@ -4236,7 +4537,6 @@ create_debug_types_hash_table (struct dwo_file *dwo_file, { bfd *abfd; const gdb_byte *info_ptr, *end_ptr; - struct dwarf2_section_info *abbrev_section; dwarf2_read_section (objfile, section); info_ptr = section->buffer; @@ -4245,13 +4545,8 @@ create_debug_types_hash_table (struct dwo_file *dwo_file, continue; /* We can't set abfd until now because the section may be empty or - not present, in which case section->asection will be NULL. */ - abfd = section->asection->owner; - - if (dwo_file) - abbrev_section = &dwo_file->sections.abbrev; - else - abbrev_section = &dwarf2_per_objfile->abbrev; + not present, in which case the bfd is unknown. */ + abfd = get_section_bfd_owner (section); /* We don't use init_cutu_and_read_dies_simple, or some such, here because we don't need to read any dies: the signature is in the @@ -4354,7 +4649,7 @@ create_debug_types_hash_table (struct dwo_file *dwo_file, } *slot = dwo_file ? (void *) dwo_tu : (void *) sig_type; - if (dwarf2_read_debug) + if (dwarf2_read_debug > 1) fprintf_unfiltered (gdb_stdlog, " offset 0x%x, signature %s\n", offset.sect_off, hex_string (signature)); @@ -4386,7 +4681,9 @@ create_all_type_units (struct objfile *objfile) dwarf2_per_objfile->signatured_types = types_htab; - dwarf2_per_objfile->n_type_units = htab_elements (types_htab); + dwarf2_per_objfile->n_type_units + = dwarf2_per_objfile->n_allocated_type_units + = htab_elements (types_htab); dwarf2_per_objfile->all_type_units = xmalloc (dwarf2_per_objfile->n_type_units * sizeof (struct signatured_type *)); @@ -4398,6 +4695,55 @@ create_all_type_units (struct objfile *objfile) return 1; } +/* Add an entry for signature SIG to dwarf2_per_objfile->signatured_types. + If SLOT is non-NULL, it is the entry to use in the hash table. + Otherwise we find one. */ + +static struct signatured_type * +add_type_unit (ULONGEST sig, void **slot) +{ + struct objfile *objfile = dwarf2_per_objfile->objfile; + int n_type_units = dwarf2_per_objfile->n_type_units; + struct signatured_type *sig_type; + + gdb_assert (n_type_units <= dwarf2_per_objfile->n_allocated_type_units); + ++n_type_units; + if (n_type_units > dwarf2_per_objfile->n_allocated_type_units) + { + if (dwarf2_per_objfile->n_allocated_type_units == 0) + dwarf2_per_objfile->n_allocated_type_units = 1; + dwarf2_per_objfile->n_allocated_type_units *= 2; + dwarf2_per_objfile->all_type_units + = xrealloc (dwarf2_per_objfile->all_type_units, + dwarf2_per_objfile->n_allocated_type_units + * sizeof (struct signatured_type *)); + ++dwarf2_per_objfile->tu_stats.nr_all_type_units_reallocs; + } + dwarf2_per_objfile->n_type_units = n_type_units; + + sig_type = OBSTACK_ZALLOC (&objfile->objfile_obstack, + struct signatured_type); + dwarf2_per_objfile->all_type_units[n_type_units - 1] = sig_type; + sig_type->signature = sig; + sig_type->per_cu.is_debug_types = 1; + if (dwarf2_per_objfile->using_index) + { + sig_type->per_cu.v.quick = + OBSTACK_ZALLOC (&objfile->objfile_obstack, + struct dwarf2_per_cu_quick_data); + } + + if (slot == NULL) + { + slot = htab_find_slot (dwarf2_per_objfile->signatured_types, + sig_type, INSERT); + } + gdb_assert (*slot == NULL); + *slot = sig_type; + /* The rest of sig_type must be filled in by the caller. */ + return sig_type; +} + /* Subroutine of lookup_dwo_signatured_type and lookup_dwp_signatured_type. Fill in SIG_ENTRY with DWO_ENTRY. */ @@ -4409,8 +4755,13 @@ fill_in_sig_entry_from_dwo_entry (struct objfile *objfile, /* Make sure we're not clobbering something we don't expect to. */ gdb_assert (! sig_entry->per_cu.queued); gdb_assert (sig_entry->per_cu.cu == NULL); - gdb_assert (sig_entry->per_cu.v.quick != NULL); - gdb_assert (sig_entry->per_cu.v.quick->symtab == NULL); + if (dwarf2_per_objfile->using_index) + { + gdb_assert (sig_entry->per_cu.v.quick != NULL); + gdb_assert (sig_entry->per_cu.v.quick->symtab == NULL); + } + else + gdb_assert (sig_entry->per_cu.v.psymtab == NULL); gdb_assert (sig_entry->signature == dwo_entry->signature); gdb_assert (sig_entry->type_offset_in_section.sect_off == 0); gdb_assert (sig_entry->type_unit_group == NULL); @@ -4444,33 +4795,45 @@ lookup_dwo_signatured_type (struct dwarf2_cu *cu, ULONGEST sig) struct dwo_file *dwo_file; struct dwo_unit find_dwo_entry, *dwo_entry; struct signatured_type find_sig_entry, *sig_entry; + void **slot; gdb_assert (cu->dwo_unit && dwarf2_per_objfile->using_index); - /* Note: cu->dwo_unit is the dwo_unit that references this TU, not the - dwo_unit of the TU itself. */ - dwo_file = cu->dwo_unit->dwo_file; + /* If TU skeletons have been removed then we may not have read in any + TUs yet. */ + if (dwarf2_per_objfile->signatured_types == NULL) + { + dwarf2_per_objfile->signatured_types + = allocate_signatured_type_table (objfile); + } /* We only ever need to read in one copy of a signatured type. - Just use the global signatured_types array. If this is the first time - we're reading this type, replace the recorded data from .gdb_index with - this TU. */ + Use the global signatured_types array to do our own comdat-folding + of types. If this is the first time we're reading this TU, and + the TU has an entry in .gdb_index, replace the recorded data from + .gdb_index with this TU. */ - if (dwarf2_per_objfile->signatured_types == NULL) - return NULL; find_sig_entry.signature = sig; - sig_entry = htab_find (dwarf2_per_objfile->signatured_types, &find_sig_entry); - if (sig_entry == NULL) - return NULL; + slot = htab_find_slot (dwarf2_per_objfile->signatured_types, + &find_sig_entry, INSERT); + sig_entry = *slot; /* We can get here with the TU already read, *or* in the process of being - read. Don't reassign it if that's the case. Also note that if the TU is - already being read, it may not have come from a DWO, the program may be - a mix of Fission-compiled code and non-Fission-compiled code. */ - /* Have we already tried to read this TU? */ - if (sig_entry->per_cu.tu_read) + read. Don't reassign the global entry to point to this DWO if that's + the case. Also note that if the TU is already being read, it may not + have come from a DWO, the program may be a mix of Fission-compiled + code and non-Fission-compiled code. */ + + /* Have we already tried to read this TU? + Note: sig_entry can be NULL if the skeleton TU was removed (thus it + needn't exist in the global table yet). */ + if (sig_entry != NULL && sig_entry->per_cu.tu_read) return sig_entry; + /* Note: cu->dwo_unit is the dwo_unit that references this TU, not the + dwo_unit of the TU itself. */ + dwo_file = cu->dwo_unit->dwo_file; + /* Ok, this is the first time we're reading this TU. */ if (dwo_file->tus == NULL) return NULL; @@ -4479,51 +4842,19 @@ lookup_dwo_signatured_type (struct dwarf2_cu *cu, ULONGEST sig) if (dwo_entry == NULL) return NULL; + /* If the global table doesn't have an entry for this TU, add one. */ + if (sig_entry == NULL) + sig_entry = add_type_unit (sig, slot); + fill_in_sig_entry_from_dwo_entry (objfile, sig_entry, dwo_entry); sig_entry->per_cu.tu_read = 1; return sig_entry; } -/* Subroutine of lookup_dwp_signatured_type. - Add an entry for signature SIG to dwarf2_per_objfile->signatured_types. */ - -static struct signatured_type * -add_type_unit (ULONGEST sig) -{ - struct objfile *objfile = dwarf2_per_objfile->objfile; - int n_type_units = dwarf2_per_objfile->n_type_units; - struct signatured_type *sig_type; - void **slot; - - ++n_type_units; - dwarf2_per_objfile->all_type_units = - xrealloc (dwarf2_per_objfile->all_type_units, - n_type_units * sizeof (struct signatured_type *)); - dwarf2_per_objfile->n_type_units = n_type_units; - sig_type = OBSTACK_ZALLOC (&objfile->objfile_obstack, - struct signatured_type); - dwarf2_per_objfile->all_type_units[n_type_units - 1] = sig_type; - sig_type->signature = sig; - sig_type->per_cu.is_debug_types = 1; - sig_type->per_cu.v.quick = - OBSTACK_ZALLOC (&objfile->objfile_obstack, - struct dwarf2_per_cu_quick_data); - slot = htab_find_slot (dwarf2_per_objfile->signatured_types, - sig_type, INSERT); - gdb_assert (*slot == NULL); - *slot = sig_type; - /* The rest of sig_type must be filled in by the caller. */ - return sig_type; -} - /* Subroutine of lookup_signatured_type. Look up the type for signature SIG, and if we can't find SIG in .gdb_index - then try the DWP file. - Normally this "can't happen", but if there's a bug in signature - generation and/or the DWP file is built incorrectly, it can happen. - Using the type directly from the DWP file means we don't have the stub - which has some useful attributes (e.g., DW_AT_comp_dir), but they're - not critical. [Eventually the stub may go away for type units anyway.] */ + then try the DWP file. If the TU stub (skeleton) has been removed then + it won't be in .gdb_index. */ static struct signatured_type * lookup_dwp_signatured_type (struct dwarf2_cu *cu, ULONGEST sig) @@ -4532,41 +4863,40 @@ lookup_dwp_signatured_type (struct dwarf2_cu *cu, ULONGEST sig) struct dwp_file *dwp_file = get_dwp_file (); struct dwo_unit *dwo_entry; struct signatured_type find_sig_entry, *sig_entry; + void **slot; gdb_assert (cu->dwo_unit && dwarf2_per_objfile->using_index); gdb_assert (dwp_file != NULL); - if (dwarf2_per_objfile->signatured_types != NULL) + /* If TU skeletons have been removed then we may not have read in any + TUs yet. */ + if (dwarf2_per_objfile->signatured_types == NULL) { - find_sig_entry.signature = sig; - sig_entry = htab_find (dwarf2_per_objfile->signatured_types, - &find_sig_entry); - if (sig_entry != NULL) - return sig_entry; + dwarf2_per_objfile->signatured_types + = allocate_signatured_type_table (objfile); } - /* This is the "shouldn't happen" case. - Try the DWP file and hope for the best. */ + find_sig_entry.signature = sig; + slot = htab_find_slot (dwarf2_per_objfile->signatured_types, + &find_sig_entry, INSERT); + sig_entry = *slot; + + /* Have we already tried to read this TU? + Note: sig_entry can be NULL if the skeleton TU was removed (thus it + needn't exist in the global table yet). */ + if (sig_entry != NULL) + return sig_entry; + if (dwp_file->tus == NULL) return NULL; - dwo_entry = lookup_dwo_in_dwp (dwp_file, dwp_file->tus, NULL, - sig, 1 /* is_debug_types */); + dwo_entry = lookup_dwo_unit_in_dwp (dwp_file, NULL, + sig, 1 /* is_debug_types */); if (dwo_entry == NULL) return NULL; - sig_entry = add_type_unit (sig); + sig_entry = add_type_unit (sig, slot); fill_in_sig_entry_from_dwo_entry (objfile, sig_entry, dwo_entry); - /* The caller will signal a complaint if we return NULL. - Here we don't return NULL but we still want to complain. */ - complaint (&symfile_complaints, - _("Bad type signature %s referenced by %s at 0x%x," - " coping by using copy in DWP [in module %s]"), - hex_string (sig), - cu->per_cu->is_debug_types ? "TU" : "CU", - cu->per_cu->offset.sect_off, - objfile->name); - return sig_entry; } @@ -4610,7 +4940,7 @@ init_cu_die_reader (struct die_reader_specs *reader, struct dwo_file *dwo_file) { gdb_assert (section->readin && section->buffer != NULL); - reader->abfd = section->asection->owner; + reader->abfd = get_section_bfd_owner (section); reader->cu = cu; reader->dwo_file = dwo_file; reader->die_section = section; @@ -4628,8 +4958,8 @@ init_cu_die_reader (struct die_reader_specs *reader, from it to the DIE in the DWO. If NULL we are skipping the stub. STUB_COMP_DIR is similar to STUB_COMP_UNIT_DIE: When reading a TU directly from the DWO file, bypassing the stub, it contains the DW_AT_comp_dir - attribute of the referencing CU. Exactly one of STUB_COMP_UNIT_DIE and - COMP_DIR must be non-NULL. + attribute of the referencing CU. At most one of STUB_COMP_UNIT_DIE and + STUB_COMP_DIR may be non-NULL. *RESULT_READER,*RESULT_INFO_PTR,*RESULT_COMP_UNIT_DIE,*RESULT_HAS_CHILDREN are filled in with the info of the DIE from the DWO file. ABBREV_TABLE_PROVIDED is non-zero if the caller of init_cutu_and_read_dies @@ -4652,23 +4982,23 @@ read_cutu_die_from_dwo (struct dwarf2_per_cu_data *this_cu, struct dwarf2_section_info *section; bfd *abfd; const gdb_byte *begin_info_ptr, *info_ptr; - const char *comp_dir_string; ULONGEST signature; /* Or dwo_id. */ struct attribute *comp_dir, *stmt_list, *low_pc, *high_pc, *ranges; int i,num_extra_attrs; struct dwarf2_section_info *dwo_abbrev_section; struct attribute *attr; - struct attribute comp_dir_attr; struct die_info *comp_unit_die; - /* Both can't be provided. */ - gdb_assert (! (stub_comp_unit_die && stub_comp_dir)); + /* At most one of these may be provided. */ + gdb_assert ((stub_comp_unit_die != NULL) + (stub_comp_dir != NULL) <= 1); /* These attributes aren't processed until later: DW_AT_stmt_list, DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges. - However, the attribute is found in the stub which we won't have later. - In order to not impose this complication on the rest of the code, - we read them here and copy them to the DWO CU/TU die. */ + DW_AT_comp_dir is used now, to find the DWO file, but it is also + referenced later. However, these attributes are found in the stub + which we won't have later. In order to not impose this complication + on the rest of the code, we read them here and copy them to the + DWO CU/TU die. */ stmt_list = NULL; low_pc = NULL; @@ -4716,7 +5046,7 @@ read_cutu_die_from_dwo (struct dwarf2_per_cu_data *this_cu, cu->dwo_unit = dwo_unit; section = dwo_unit->section; dwarf2_read_section (objfile, section); - abfd = section->asection->owner; + abfd = get_section_bfd_owner (section); begin_info_ptr = info_ptr = section->buffer + dwo_unit->offset.sect_off; dwo_abbrev_section = &dwo_unit->dwo_file->sections.abbrev; init_cu_die_reader (result_reader, cu, section, dwo_unit->dwo_file); @@ -4812,7 +5142,7 @@ read_cutu_die_from_dwo (struct dwarf2_per_cu_data *this_cu, { fprintf_unfiltered (gdb_stdlog, "Read die from %s@0x%x of %s:\n", - bfd_section_name (abfd, section->asection), + get_section_name (section), (unsigned) (begin_info_ptr - section->buffer), bfd_get_filename (abfd)); dump_die (comp_unit_die, dwarf2_die_debug); @@ -4877,7 +5207,7 @@ lookup_dwo_unit (struct dwarf2_per_cu_data *this_cu, if (! attr) error (_("Dwarf Error: missing dwo_id for dwo_name %s" " [in module %s]"), - dwo_name, this_cu->objfile->name); + dwo_name, objfile_name (this_cu->objfile)); signature = DW_UNSND (attr); dwo_unit = lookup_dwo_comp_unit (this_cu, dwo_name, comp_dir, signature); @@ -4887,16 +5217,23 @@ lookup_dwo_unit (struct dwarf2_per_cu_data *this_cu, } /* Subroutine of init_cutu_and_read_dies to simplify it. - Read a TU directly from a DWO file, bypassing the stub. */ + See it for a description of the parameters. + Read a TU directly from a DWO file, bypassing the stub. + + Note: This function could be a little bit simpler if we shared cleanups + with our caller, init_cutu_and_read_dies. That's generally a fragile thing + to do, so we keep this function self-contained. Or we could move this + into our caller, but it's complex enough already. */ static void -init_tu_and_read_dwo_dies (struct dwarf2_per_cu_data *this_cu, int keep, +init_tu_and_read_dwo_dies (struct dwarf2_per_cu_data *this_cu, + int use_existing_cu, int keep, die_reader_func_ftype *die_reader_func, void *data) { struct dwarf2_cu *cu; struct signatured_type *sig_type; - struct cleanup *cleanups, *free_cu_cleanup; + struct cleanup *cleanups, *free_cu_cleanup = NULL; struct die_reader_specs reader; const gdb_byte *info_ptr; struct die_info *comp_unit_die; @@ -4910,47 +5247,65 @@ init_tu_and_read_dwo_dies (struct dwarf2_per_cu_data *this_cu, int keep, cleanups = make_cleanup (null_cleanup, NULL); - gdb_assert (this_cu->cu == NULL); - cu = xmalloc (sizeof (*cu)); - init_one_comp_unit (cu, this_cu); - /* If an error occurs while loading, release our storage. */ - free_cu_cleanup = make_cleanup (free_heap_comp_unit, cu); - - if (read_cutu_die_from_dwo (this_cu, sig_type->dwo_unit, - 0 /* abbrev_table_provided */, - NULL /* stub_comp_unit_die */, - sig_type->dwo_unit->dwo_file->comp_dir, - &reader, &info_ptr, - &comp_unit_die, &has_children) == 0) + if (use_existing_cu && this_cu->cu != NULL) { - /* Dummy die. */ - do_cleanups (cleanups); + gdb_assert (this_cu->cu->dwo_unit == sig_type->dwo_unit); + cu = this_cu->cu; + /* There's no need to do the rereading_dwo_cu handling that + init_cutu_and_read_dies does since we don't read the stub. */ + } + else + { + /* If !use_existing_cu, this_cu->cu must be NULL. */ + gdb_assert (this_cu->cu == NULL); + cu = xmalloc (sizeof (*cu)); + init_one_comp_unit (cu, this_cu); + /* If an error occurs while loading, release our storage. */ + free_cu_cleanup = make_cleanup (free_heap_comp_unit, cu); + } + + /* A future optimization, if needed, would be to use an existing + abbrev table. When reading DWOs with skeletonless TUs, all the TUs + could share abbrev tables. */ + + if (read_cutu_die_from_dwo (this_cu, sig_type->dwo_unit, + 0 /* abbrev_table_provided */, + NULL /* stub_comp_unit_die */, + sig_type->dwo_unit->dwo_file->comp_dir, + &reader, &info_ptr, + &comp_unit_die, &has_children) == 0) + { + /* Dummy die. */ + do_cleanups (cleanups); return; } /* All the "real" work is done here. */ die_reader_func (&reader, info_ptr, comp_unit_die, has_children, data); - /* This duplicates some code in init_cutu_and_read_dies, + /* This duplicates the code in init_cutu_and_read_dies, but the alternative is making the latter more complex. This function is only for the special case of using DWO files directly: no point in overly complicating the general case just to handle this. */ - if (keep) + if (free_cu_cleanup != NULL) { - /* We've successfully allocated this compilation unit. Let our - caller clean it up when finished with it. */ - discard_cleanups (free_cu_cleanup); + if (keep) + { + /* We've successfully allocated this compilation unit. Let our + caller clean it up when finished with it. */ + discard_cleanups (free_cu_cleanup); - /* We can only discard free_cu_cleanup and all subsequent cleanups. - So we have to manually free the abbrev table. */ - dwarf2_free_abbrev_table (cu); + /* We can only discard free_cu_cleanup and all subsequent cleanups. + So we have to manually free the abbrev table. */ + dwarf2_free_abbrev_table (cu); - /* Link this CU into read_in_chain. */ - this_cu->cu->read_in_chain = dwarf2_per_objfile->read_in_chain; - dwarf2_per_objfile->read_in_chain = this_cu; + /* Link this CU into read_in_chain. */ + this_cu->cu->read_in_chain = dwarf2_per_objfile->read_in_chain; + dwarf2_per_objfile->read_in_chain = this_cu; + } + else + do_cleanups (free_cu_cleanup); } - else - do_cleanups (free_cu_cleanup); do_cleanups (cleanups); } @@ -4980,7 +5335,7 @@ init_cutu_and_read_dies (struct dwarf2_per_cu_data *this_cu, { struct objfile *objfile = dwarf2_per_objfile->objfile; struct dwarf2_section_info *section = this_cu->section; - bfd *abfd = section->asection->owner; + bfd *abfd = get_section_bfd_owner (section); struct dwarf2_cu *cu; const gdb_byte *begin_info_ptr, *info_ptr; struct die_reader_specs reader; @@ -5010,8 +5365,8 @@ init_cutu_and_read_dies (struct dwarf2_per_cu_data *this_cu, /* Narrow down the scope of possibilities to have to understand. */ gdb_assert (this_cu->is_debug_types); gdb_assert (abbrev_table == NULL); - gdb_assert (!use_existing_cu); - init_tu_and_read_dwo_dies (this_cu, keep, die_reader_func, data); + init_tu_and_read_dwo_dies (this_cu, use_existing_cu, keep, + die_reader_func, data); return; } @@ -5027,7 +5382,6 @@ init_cutu_and_read_dies (struct dwarf2_per_cu_data *this_cu, if (use_existing_cu && this_cu->cu != NULL) { cu = this_cu->cu; - /* If this CU is from a DWO file we need to start over, we need to refetch the attributes from the skeleton CU. This could be optimized by retrieving those attributes from when we @@ -5041,10 +5395,8 @@ init_cutu_and_read_dies (struct dwarf2_per_cu_data *this_cu, { /* If !use_existing_cu, this_cu->cu must be NULL. */ gdb_assert (this_cu->cu == NULL); - cu = xmalloc (sizeof (*cu)); init_one_comp_unit (cu, this_cu); - /* If an error occurs while loading, release our storage. */ free_cu_cleanup = make_cleanup (free_heap_comp_unit, cu); } @@ -5198,10 +5550,9 @@ init_cutu_and_read_dies (struct dwarf2_per_cu_data *this_cu, do_cleanups (cleanups); } -/* Read CU/TU THIS_CU in section SECTION, - but do not follow DW_AT_GNU_dwo_name if present. - DWOP_FILE, if non-NULL, is the DWO/DWP file to read (the caller is assumed - to have already done the lookup to find the DWO/DWP file). +/* Read CU/TU THIS_CU but do not follow DW_AT_GNU_dwo_name if present. + DWO_FILE, if non-NULL, is the DWO file to read (the caller is assumed + to have already done the lookup to find the DWO file). The caller is required to fill in THIS_CU->section, THIS_CU->offset, and THIS_CU->is_debug_types, but nothing else. @@ -5217,14 +5568,14 @@ init_cutu_and_read_dies (struct dwarf2_per_cu_data *this_cu, static void init_cutu_and_read_dies_no_follow (struct dwarf2_per_cu_data *this_cu, - struct dwarf2_section_info *abbrev_section, struct dwo_file *dwo_file, die_reader_func_ftype *die_reader_func, void *data) { struct objfile *objfile = dwarf2_per_objfile->objfile; struct dwarf2_section_info *section = this_cu->section; - bfd *abfd = section->asection->owner; + bfd *abfd = get_section_bfd_owner (section); + struct dwarf2_section_info *abbrev_section; struct dwarf2_cu cu; const gdb_byte *begin_info_ptr, *info_ptr; struct die_reader_specs reader; @@ -5239,6 +5590,10 @@ init_cutu_and_read_dies_no_follow (struct dwarf2_per_cu_data *this_cu, gdb_assert (this_cu->cu == NULL); + abbrev_section = (dwo_file != NULL + ? &dwo_file->sections.abbrev + : get_abbrev_section_for_cu (this_cu)); + /* This is cheap if the section is already read in. */ dwarf2_read_section (objfile, section); @@ -5286,10 +5641,7 @@ init_cutu_and_read_dies_simple (struct dwarf2_per_cu_data *this_cu, die_reader_func_ftype *die_reader_func, void *data) { - init_cutu_and_read_dies_no_follow (this_cu, - get_abbrev_section_for_cu (this_cu), - NULL, - die_reader_func, data); + init_cutu_and_read_dies_no_follow (this_cu, NULL, die_reader_func, data); } /* Type Unit Groups. @@ -5441,191 +5793,6 @@ get_type_unit_group (struct dwarf2_cu *cu, const struct attribute *stmt_list) return tu_group; } - -/* Struct used to sort TUs by their abbreviation table offset. */ - -struct tu_abbrev_offset -{ - struct signatured_type *sig_type; - sect_offset abbrev_offset; -}; - -/* Helper routine for build_type_unit_groups, passed to qsort. */ - -static int -sort_tu_by_abbrev_offset (const void *ap, const void *bp) -{ - const struct tu_abbrev_offset * const *a = ap; - const struct tu_abbrev_offset * const *b = bp; - unsigned int aoff = (*a)->abbrev_offset.sect_off; - unsigned int boff = (*b)->abbrev_offset.sect_off; - - return (aoff > boff) - (aoff < boff); -} - -/* A helper function to add a type_unit_group to a table. */ - -static int -add_type_unit_group_to_table (void **slot, void *datum) -{ - struct type_unit_group *tu_group = *slot; - struct type_unit_group ***datap = datum; - - **datap = tu_group; - ++*datap; - - return 1; -} - -/* Efficiently read all the type units, calling init_cutu_and_read_dies on - each one passing FUNC,DATA. - - The efficiency is because we sort TUs by the abbrev table they use and - only read each abbrev table once. In one program there are 200K TUs - sharing 8K abbrev tables. - - The main purpose of this function is to support building the - dwarf2_per_objfile->type_unit_groups table. - TUs typically share the DW_AT_stmt_list of the CU they came from, so we - can collapse the search space by grouping them by stmt_list. - The savings can be significant, in the same program from above the 200K TUs - share 8K stmt_list tables. - - FUNC is expected to call get_type_unit_group, which will create the - struct type_unit_group if necessary and add it to - dwarf2_per_objfile->type_unit_groups. */ - -static void -build_type_unit_groups (die_reader_func_ftype *func, void *data) -{ - struct objfile *objfile = dwarf2_per_objfile->objfile; - struct tu_stats *tu_stats = &dwarf2_per_objfile->tu_stats; - struct cleanup *cleanups; - struct abbrev_table *abbrev_table; - sect_offset abbrev_offset; - struct tu_abbrev_offset *sorted_by_abbrev; - struct type_unit_group **iter; - int i; - - /* It's up to the caller to not call us multiple times. */ - gdb_assert (dwarf2_per_objfile->type_unit_groups == NULL); - - if (dwarf2_per_objfile->n_type_units == 0) - return; - - /* TUs typically share abbrev tables, and there can be way more TUs than - abbrev tables. Sort by abbrev table to reduce the number of times we - read each abbrev table in. - Alternatives are to punt or to maintain a cache of abbrev tables. - This is simpler and efficient enough for now. - - Later we group TUs by their DW_AT_stmt_list value (as this defines the - symtab to use). Typically TUs with the same abbrev offset have the same - stmt_list value too so in practice this should work well. - - The basic algorithm here is: - - sort TUs by abbrev table - for each TU with same abbrev table: - read abbrev table if first user - read TU top level DIE - [IWBN if DWO skeletons had DW_AT_stmt_list] - call FUNC */ - - if (dwarf2_read_debug) - fprintf_unfiltered (gdb_stdlog, "Building type unit groups ...\n"); - - /* Sort in a separate table to maintain the order of all_type_units - for .gdb_index: TU indices directly index all_type_units. */ - sorted_by_abbrev = XNEWVEC (struct tu_abbrev_offset, - dwarf2_per_objfile->n_type_units); - for (i = 0; i < dwarf2_per_objfile->n_type_units; ++i) - { - struct signatured_type *sig_type = dwarf2_per_objfile->all_type_units[i]; - - sorted_by_abbrev[i].sig_type = sig_type; - sorted_by_abbrev[i].abbrev_offset = - read_abbrev_offset (sig_type->per_cu.section, - sig_type->per_cu.offset); - } - cleanups = make_cleanup (xfree, sorted_by_abbrev); - qsort (sorted_by_abbrev, dwarf2_per_objfile->n_type_units, - sizeof (struct tu_abbrev_offset), sort_tu_by_abbrev_offset); - - /* Note: In the .gdb_index case, get_type_unit_group may have already been - called any number of times, so we don't reset tu_stats here. */ - - abbrev_offset.sect_off = ~(unsigned) 0; - abbrev_table = NULL; - make_cleanup (abbrev_table_free_cleanup, &abbrev_table); - - for (i = 0; i < dwarf2_per_objfile->n_type_units; ++i) - { - const struct tu_abbrev_offset *tu = &sorted_by_abbrev[i]; - - /* Switch to the next abbrev table if necessary. */ - if (abbrev_table == NULL - || tu->abbrev_offset.sect_off != abbrev_offset.sect_off) - { - if (abbrev_table != NULL) - { - abbrev_table_free (abbrev_table); - /* Reset to NULL in case abbrev_table_read_table throws - an error: abbrev_table_free_cleanup will get called. */ - abbrev_table = NULL; - } - abbrev_offset = tu->abbrev_offset; - abbrev_table = - abbrev_table_read_table (&dwarf2_per_objfile->abbrev, - abbrev_offset); - ++tu_stats->nr_uniq_abbrev_tables; - } - - init_cutu_and_read_dies (&tu->sig_type->per_cu, abbrev_table, 0, 0, - func, data); - } - - /* type_unit_groups can be NULL if there is an error in the debug info. - Just create an empty table so the rest of gdb doesn't have to watch - for this error case. */ - if (dwarf2_per_objfile->type_unit_groups == NULL) - { - dwarf2_per_objfile->type_unit_groups = - allocate_type_unit_groups_table (); - dwarf2_per_objfile->n_type_unit_groups = 0; - } - - /* Create a vector of pointers to primary type units to make it easy to - iterate over them and CUs. See dw2_get_primary_cu. */ - dwarf2_per_objfile->n_type_unit_groups = - htab_elements (dwarf2_per_objfile->type_unit_groups); - dwarf2_per_objfile->all_type_unit_groups = - obstack_alloc (&objfile->objfile_obstack, - dwarf2_per_objfile->n_type_unit_groups - * sizeof (struct type_unit_group *)); - iter = &dwarf2_per_objfile->all_type_unit_groups[0]; - htab_traverse_noresize (dwarf2_per_objfile->type_unit_groups, - add_type_unit_group_to_table, &iter); - gdb_assert (iter - &dwarf2_per_objfile->all_type_unit_groups[0] - == dwarf2_per_objfile->n_type_unit_groups); - - do_cleanups (cleanups); - - if (dwarf2_read_debug) - { - fprintf_unfiltered (gdb_stdlog, "Done building type unit groups:\n"); - fprintf_unfiltered (gdb_stdlog, " %d TUs\n", - dwarf2_per_objfile->n_type_units); - fprintf_unfiltered (gdb_stdlog, " %d uniq abbrev tables\n", - tu_stats->nr_uniq_abbrev_tables); - fprintf_unfiltered (gdb_stdlog, " %d symtabs from stmt_list entries\n", - tu_stats->nr_symtabs); - fprintf_unfiltered (gdb_stdlog, " %d symtab sharers\n", - tu_stats->nr_symtab_sharers); - fprintf_unfiltered (gdb_stdlog, " %d type units without a stmt_list\n", - tu_stats->nr_stmt_less_type_units); - } -} /* Partial symbol tables. */ @@ -5883,6 +6050,157 @@ build_type_psymtabs_reader (const struct die_reader_specs *reader, sort_pst_symbols (objfile, pst); } +/* Struct used to sort TUs by their abbreviation table offset. */ + +struct tu_abbrev_offset +{ + struct signatured_type *sig_type; + sect_offset abbrev_offset; +}; + +/* Helper routine for build_type_psymtabs_1, passed to qsort. */ + +static int +sort_tu_by_abbrev_offset (const void *ap, const void *bp) +{ + const struct tu_abbrev_offset * const *a = ap; + const struct tu_abbrev_offset * const *b = bp; + unsigned int aoff = (*a)->abbrev_offset.sect_off; + unsigned int boff = (*b)->abbrev_offset.sect_off; + + return (aoff > boff) - (aoff < boff); +} + +/* Efficiently read all the type units. + This does the bulk of the work for build_type_psymtabs. + + The efficiency is because we sort TUs by the abbrev table they use and + only read each abbrev table once. In one program there are 200K TUs + sharing 8K abbrev tables. + + The main purpose of this function is to support building the + dwarf2_per_objfile->type_unit_groups table. + TUs typically share the DW_AT_stmt_list of the CU they came from, so we + can collapse the search space by grouping them by stmt_list. + The savings can be significant, in the same program from above the 200K TUs + share 8K stmt_list tables. + + FUNC is expected to call get_type_unit_group, which will create the + struct type_unit_group if necessary and add it to + dwarf2_per_objfile->type_unit_groups. */ + +static void +build_type_psymtabs_1 (void) +{ + struct objfile *objfile = dwarf2_per_objfile->objfile; + struct tu_stats *tu_stats = &dwarf2_per_objfile->tu_stats; + struct cleanup *cleanups; + struct abbrev_table *abbrev_table; + sect_offset abbrev_offset; + struct tu_abbrev_offset *sorted_by_abbrev; + struct type_unit_group **iter; + int i; + + /* It's up to the caller to not call us multiple times. */ + gdb_assert (dwarf2_per_objfile->type_unit_groups == NULL); + + if (dwarf2_per_objfile->n_type_units == 0) + return; + + /* TUs typically share abbrev tables, and there can be way more TUs than + abbrev tables. Sort by abbrev table to reduce the number of times we + read each abbrev table in. + Alternatives are to punt or to maintain a cache of abbrev tables. + This is simpler and efficient enough for now. + + Later we group TUs by their DW_AT_stmt_list value (as this defines the + symtab to use). Typically TUs with the same abbrev offset have the same + stmt_list value too so in practice this should work well. + + The basic algorithm here is: + + sort TUs by abbrev table + for each TU with same abbrev table: + read abbrev table if first user + read TU top level DIE + [IWBN if DWO skeletons had DW_AT_stmt_list] + call FUNC */ + + if (dwarf2_read_debug) + fprintf_unfiltered (gdb_stdlog, "Building type unit groups ...\n"); + + /* Sort in a separate table to maintain the order of all_type_units + for .gdb_index: TU indices directly index all_type_units. */ + sorted_by_abbrev = XNEWVEC (struct tu_abbrev_offset, + dwarf2_per_objfile->n_type_units); + for (i = 0; i < dwarf2_per_objfile->n_type_units; ++i) + { + struct signatured_type *sig_type = dwarf2_per_objfile->all_type_units[i]; + + sorted_by_abbrev[i].sig_type = sig_type; + sorted_by_abbrev[i].abbrev_offset = + read_abbrev_offset (sig_type->per_cu.section, + sig_type->per_cu.offset); + } + cleanups = make_cleanup (xfree, sorted_by_abbrev); + qsort (sorted_by_abbrev, dwarf2_per_objfile->n_type_units, + sizeof (struct tu_abbrev_offset), sort_tu_by_abbrev_offset); + + abbrev_offset.sect_off = ~(unsigned) 0; + abbrev_table = NULL; + make_cleanup (abbrev_table_free_cleanup, &abbrev_table); + + for (i = 0; i < dwarf2_per_objfile->n_type_units; ++i) + { + const struct tu_abbrev_offset *tu = &sorted_by_abbrev[i]; + + /* Switch to the next abbrev table if necessary. */ + if (abbrev_table == NULL + || tu->abbrev_offset.sect_off != abbrev_offset.sect_off) + { + if (abbrev_table != NULL) + { + abbrev_table_free (abbrev_table); + /* Reset to NULL in case abbrev_table_read_table throws + an error: abbrev_table_free_cleanup will get called. */ + abbrev_table = NULL; + } + abbrev_offset = tu->abbrev_offset; + abbrev_table = + abbrev_table_read_table (&dwarf2_per_objfile->abbrev, + abbrev_offset); + ++tu_stats->nr_uniq_abbrev_tables; + } + + init_cutu_and_read_dies (&tu->sig_type->per_cu, abbrev_table, 0, 0, + build_type_psymtabs_reader, NULL); + } + + do_cleanups (cleanups); +} + +/* Print collected type unit statistics. */ + +static void +print_tu_stats (void) +{ + struct tu_stats *tu_stats = &dwarf2_per_objfile->tu_stats; + + fprintf_unfiltered (gdb_stdlog, "Type unit statistics:\n"); + fprintf_unfiltered (gdb_stdlog, " %d TUs\n", + dwarf2_per_objfile->n_type_units); + fprintf_unfiltered (gdb_stdlog, " %d uniq abbrev tables\n", + tu_stats->nr_uniq_abbrev_tables); + fprintf_unfiltered (gdb_stdlog, " %d symtabs from stmt_list entries\n", + tu_stats->nr_symtabs); + fprintf_unfiltered (gdb_stdlog, " %d symtab sharers\n", + tu_stats->nr_symtab_sharers); + fprintf_unfiltered (gdb_stdlog, " %d type units without a stmt_list\n", + tu_stats->nr_stmt_less_type_units); + fprintf_unfiltered (gdb_stdlog, " %d all_type_units reallocs\n", + tu_stats->nr_all_type_units_reallocs); +} + /* Traversal function for build_type_psymtabs. */ static int @@ -5925,11 +6243,79 @@ build_type_psymtabs (struct objfile *objfile) if (! create_all_type_units (objfile)) return; - build_type_unit_groups (build_type_psymtabs_reader, NULL); + build_type_psymtabs_1 (); +} - /* Now that all TUs have been processed we can fill in the dependencies. */ - htab_traverse_noresize (dwarf2_per_objfile->type_unit_groups, - build_type_psymtab_dependencies, NULL); +/* Traversal function for process_skeletonless_type_unit. + Read a TU in a DWO file and build partial symbols for it. */ + +static int +process_skeletonless_type_unit (void **slot, void *info) +{ + struct dwo_unit *dwo_unit = (struct dwo_unit *) *slot; + struct objfile *objfile = info; + struct signatured_type find_entry, *entry; + + /* If this TU doesn't exist in the global table, add it and read it in. */ + + if (dwarf2_per_objfile->signatured_types == NULL) + { + dwarf2_per_objfile->signatured_types + = allocate_signatured_type_table (objfile); + } + + find_entry.signature = dwo_unit->signature; + slot = htab_find_slot (dwarf2_per_objfile->signatured_types, &find_entry, + INSERT); + /* If we've already seen this type there's nothing to do. What's happening + is we're doing our own version of comdat-folding here. */ + if (*slot != NULL) + return 1; + + /* This does the job that create_all_type_units would have done for + this TU. */ + entry = add_type_unit (dwo_unit->signature, slot); + fill_in_sig_entry_from_dwo_entry (objfile, entry, dwo_unit); + *slot = entry; + + /* This does the job that build_type_psymtabs_1 would have done. */ + init_cutu_and_read_dies (&entry->per_cu, NULL, 0, 0, + build_type_psymtabs_reader, NULL); + + return 1; +} + +/* Traversal function for process_skeletonless_type_units. */ + +static int +process_dwo_file_for_skeletonless_type_units (void **slot, void *info) +{ + struct dwo_file *dwo_file = (struct dwo_file *) *slot; + + if (dwo_file->tus != NULL) + { + htab_traverse_noresize (dwo_file->tus, + process_skeletonless_type_unit, info); + } + + return 1; +} + +/* Scan all TUs of DWO files, verifying we've processed them. + This is needed in case a TU was emitted without its skeleton. + Note: This can't be done until we know what all the DWO files are. */ + +static void +process_skeletonless_type_units (struct objfile *objfile) +{ + /* Skeletonless TUs in DWP files without .gdb_index is not supported yet. */ + if (get_dwp_file () == NULL + && dwarf2_per_objfile->dwo_files != NULL) + { + htab_traverse_noresize (dwarf2_per_objfile->dwo_files, + process_dwo_file_for_skeletonless_type_units, + objfile); + } } /* A cleanup function that clears objfile's psymtabs_addrmap field. */ @@ -5951,7 +6337,7 @@ set_partial_user (struct objfile *objfile) for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i) { - struct dwarf2_per_cu_data *per_cu = dw2_get_cu (i); + struct dwarf2_per_cu_data *per_cu = dw2_get_cutu (i); struct partial_symtab *pst = per_cu->v.psymtab; int j; @@ -5980,7 +6366,7 @@ dwarf2_build_psymtabs_hard (struct objfile *objfile) if (dwarf2_read_debug) { fprintf_unfiltered (gdb_stdlog, "Building psymtabs of objfile %s ...\n", - objfile->name); + objfile_name (objfile)); } dwarf2_per_objfile->reading_partial_symbols = 1; @@ -6004,11 +6390,24 @@ dwarf2_build_psymtabs_hard (struct objfile *objfile) for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i) { - struct dwarf2_per_cu_data *per_cu = dw2_get_cu (i); + struct dwarf2_per_cu_data *per_cu = dw2_get_cutu (i); process_psymtab_comp_unit (per_cu, 0, language_minimal); } + /* This has to wait until we read the CUs, we need the list of DWOs. */ + process_skeletonless_type_units (objfile); + + /* Now that all TUs have been processed we can fill in the dependencies. */ + if (dwarf2_per_objfile->type_unit_groups != NULL) + { + htab_traverse_noresize (dwarf2_per_objfile->type_unit_groups, + build_type_psymtab_dependencies, NULL); + } + + if (dwarf2_read_debug) + print_tu_stats (); + set_partial_user (objfile); objfile->psymtabs_addrmap = addrmap_create_fixed (objfile->psymtabs_addrmap, @@ -6019,7 +6418,7 @@ dwarf2_build_psymtabs_hard (struct objfile *objfile) if (dwarf2_read_debug) fprintf_unfiltered (gdb_stdlog, "Done building psymtabs of %s\n", - objfile->name); + objfile_name (objfile)); } /* die_reader_func for load_partial_comp_unit. */ @@ -6061,11 +6460,12 @@ read_comp_units_from_section (struct objfile *objfile, struct dwarf2_per_cu_data ***all_comp_units) { const gdb_byte *info_ptr; - bfd *abfd = section->asection->owner; + bfd *abfd = get_section_bfd_owner (section); if (dwarf2_read_debug) fprintf_unfiltered (gdb_stdlog, "Reading %s for %s\n", - section->asection->name, bfd_get_filename (abfd)); + get_section_name (section), + get_section_file_name (section)); dwarf2_read_section (objfile, section); @@ -6219,7 +6619,7 @@ scan_partial_symbols (struct partial_die_info *first_die, CORE_ADDR *lowpc, { error (_("Dwarf Error: DW_TAG_imported_unit is not" " supported in type units [in module %s]"), - cu->objfile->name); + objfile_name (cu->objfile)); } per_cu = dwarf2_find_containing_comp_unit (pdi->d.offset, @@ -6234,6 +6634,9 @@ scan_partial_symbols (struct partial_die_info *first_die, CORE_ADDR *lowpc, cu->per_cu->imported_symtabs, per_cu); } break; + case DW_TAG_imported_declaration: + add_partial_symbol (pdi, cu); + break; default: break; } @@ -6505,6 +6908,7 @@ add_partial_symbol (struct partial_die_info *pdi, struct dwarf2_cu *cu) &objfile->static_psymbols, 0, (CORE_ADDR) 0, cu->language, objfile); break; + case DW_TAG_imported_declaration: case DW_TAG_namespace: add_psymbol_to_list (actual_name, strlen (actual_name), built_actual_name != NULL, @@ -6512,6 +6916,13 @@ add_partial_symbol (struct partial_die_info *pdi, struct dwarf2_cu *cu) &objfile->global_psymbols, 0, (CORE_ADDR) 0, cu->language, objfile); break; + case DW_TAG_module: + add_psymbol_to_list (actual_name, strlen (actual_name), + built_actual_name != NULL, + MODULE_DOMAIN, LOC_TYPEDEF, + &objfile->global_psymbols, + 0, (CORE_ADDR) 0, cu->language, objfile); + break; case DW_TAG_class_type: case DW_TAG_interface_type: case DW_TAG_structure_type: @@ -6582,6 +6993,10 @@ static void add_partial_module (struct partial_die_info *pdi, CORE_ADDR *lowpc, CORE_ADDR *highpc, int need_pc, struct dwarf2_cu *cu) { + /* Add a symbol for the namespace. */ + + add_partial_symbol (pdi, cu); + /* Now scan partial symbols in that module. */ if (pdi->has_children) @@ -6763,7 +7178,18 @@ skip_one_die (const struct die_reader_specs *reader, const gdb_byte *info_ptr, complaint (&symfile_complaints, _("ignoring absolute DW_AT_sibling")); else - return buffer + dwarf2_get_ref_die_offset (&attr).sect_off; + { + unsigned int off = dwarf2_get_ref_die_offset (&attr).sect_off; + const gdb_byte *sibling_ptr = buffer + off; + + if (sibling_ptr < info_ptr) + complaint (&symfile_complaints, + _("DW_AT_sibling points backwards")); + else if (sibling_ptr > reader->buffer_end) + dwarf2_section_buffer_overflow_complaint (reader->die_section); + else + return sibling_ptr; + } } /* If it isn't DW_AT_sibling, skip this attribute. */ @@ -7011,7 +7437,7 @@ process_queue (void) { fprintf_unfiltered (gdb_stdlog, "Expanding one or more symtabs of objfile %s ...\n", - dwarf2_per_objfile->objfile->name); + objfile_name (dwarf2_per_objfile->objfile)); } /* The queue starts out with one item, but following a DIE reference @@ -7023,6 +7449,7 @@ process_queue (void) : (item->per_cu->v.psymtab && !item->per_cu->v.psymtab->readin)) { struct dwarf2_per_cu_data *per_cu = item->per_cu; + unsigned int debug_print_threshold; char buf[100]; if (per_cu->is_debug_types) @@ -7031,12 +7458,19 @@ process_queue (void) (struct signatured_type *) per_cu; sprintf (buf, "TU %s at offset 0x%x", - hex_string (sig_type->signature), per_cu->offset.sect_off); + hex_string (sig_type->signature), + per_cu->offset.sect_off); + /* There can be 100s of TUs. + Only print them in verbose mode. */ + debug_print_threshold = 2; } else - sprintf (buf, "CU at offset 0x%x", per_cu->offset.sect_off); + { + sprintf (buf, "CU at offset 0x%x", per_cu->offset.sect_off); + debug_print_threshold = 1; + } - if (dwarf2_read_debug) + if (dwarf2_read_debug >= debug_print_threshold) fprintf_unfiltered (gdb_stdlog, "Expanding symtab of %s\n", buf); if (per_cu->is_debug_types) @@ -7044,7 +7478,7 @@ process_queue (void) else process_full_comp_unit (per_cu, item->pretend_language); - if (dwarf2_read_debug) + if (dwarf2_read_debug >= debug_print_threshold) fprintf_unfiltered (gdb_stdlog, "Done expanding %s\n", buf); } @@ -7058,7 +7492,7 @@ process_queue (void) if (dwarf2_read_debug) { fprintf_unfiltered (gdb_stdlog, "Done expanding symtabs of %s.\n", - dwarf2_per_objfile->objfile->name); + objfile_name (dwarf2_per_objfile->objfile)); } } @@ -7298,7 +7732,7 @@ fixup_go_packaging (struct dwarf2_cu *cu) _("Symtab %s has objects from two different Go packages: %s and %s"), (SYMBOL_SYMTAB (sym) ? symtab_to_filename_for_display (SYMBOL_SYMTAB (sym)) - : cu->objfile->name), + : objfile_name (cu->objfile)), this_package_name, package_name); xfree (this_package_name); } @@ -7309,9 +7743,10 @@ fixup_go_packaging (struct dwarf2_cu *cu) if (package_name != NULL) { struct objfile *objfile = cu->objfile; - const char *saved_package_name = obstack_copy0 (&objfile->objfile_obstack, - package_name, - strlen (package_name)); + const char *saved_package_name + = obstack_copy0 (&objfile->per_bfd->storage_obstack, + package_name, + strlen (package_name)); struct type *type = init_type (TYPE_CODE_MODULE, 0, 0, saved_package_name, objfile); struct symbol *sym; @@ -7666,7 +8101,7 @@ process_imported_unit_die (struct die_info *die, struct dwarf2_cu *cu) { error (_("Dwarf Error: DW_TAG_imported_unit is not" " supported in type units [in module %s]"), - cu->objfile->name); + objfile_name (cu->objfile)); } attr = dwarf2_attr (die, DW_AT_import, cu); @@ -7690,11 +8125,29 @@ process_imported_unit_die (struct die_info *die, struct dwarf2_cu *cu) } } +/* Reset the in_process bit of a die. */ + +static void +reset_die_in_process (void *arg) +{ + struct die_info *die = arg; + + die->in_process = 0; +} + /* Process a die and its children. */ static void process_die (struct die_info *die, struct dwarf2_cu *cu) { + struct cleanup *in_process; + + /* We should only be processing those not already in process. */ + gdb_assert (!die->in_process); + + die->in_process = 1; + in_process = make_cleanup (reset_die_in_process,die); + switch (die->tag) { case DW_TAG_padding: @@ -7761,6 +8214,10 @@ process_die (struct die_info *die, struct dwarf2_cu *cu) read_module (die, cu); break; case DW_TAG_imported_declaration: + cu->processing_has_namespace_info = 1; + if (read_namespace_alias (die, cu)) + break; + /* The declaration is not a global namespace alias: fall through. */ case DW_TAG_imported_module: cu->processing_has_namespace_info = 1; if (die->child != NULL && (die->tag == DW_TAG_imported_declaration @@ -7778,6 +8235,8 @@ process_die (struct die_info *die, struct dwarf2_cu *cu) new_symbol (die, NULL, cu); break; } + + do_cleanups (in_process); } /* DWARF name computation. */ @@ -7803,6 +8262,7 @@ die_needs_namespace (struct die_info *die, struct dwarf2_cu *cu) case DW_TAG_enumerator: case DW_TAG_subprogram: case DW_TAG_member: + case DW_TAG_imported_declaration: return 1; case DW_TAG_variable: @@ -7904,6 +8364,8 @@ dwarf2_compute_name (const char *name, long length; const char *prefix; struct ui_file *buf; + char *intermediate_name; + const char *canonical_name = NULL; prefix = determine_prefix (die, cu); buf = mem_fileopen (); @@ -8080,19 +8542,25 @@ dwarf2_compute_name (const char *name, } } - name = ui_file_obsavestring (buf, &objfile->objfile_obstack, - &length); + intermediate_name = ui_file_xstrdup (buf, &length); ui_file_delete (buf); if (cu->language == language_cplus) - { - const char *cname - = dwarf2_canonicalize_name (name, cu, - &objfile->objfile_obstack); + canonical_name + = dwarf2_canonicalize_name (intermediate_name, cu, + &objfile->per_bfd->storage_obstack); + + /* If we only computed INTERMEDIATE_NAME, or if + INTERMEDIATE_NAME is already canonical, then we need to + copy it to the appropriate obstack. */ + if (canonical_name == NULL || canonical_name == intermediate_name) + name = obstack_copy0 (&objfile->per_bfd->storage_obstack, + intermediate_name, + strlen (intermediate_name)); + else + name = canonical_name; - if (cname != NULL) - name = cname; - } + xfree (intermediate_name); } } @@ -8101,7 +8569,7 @@ dwarf2_compute_name (const char *name, /* Return the fully qualified name of DIE, based on its DW_AT_name. If scope qualifiers are appropriate they will be added. The result - will be allocated on the objfile_obstack, or NULL if the DIE does + will be allocated on the storage_obstack, or NULL if the DIE does not have a name. NAME may either be from a previous call to dwarf2_name or NULL. @@ -8194,31 +8662,93 @@ dwarf2_physname (const char *name, struct die_info *die, struct dwarf2_cu *cu) compute DW_AT_linkage_name incorrectly. But in such case GDB would need to be bug-to-bug compatible. */ - complaint (&symfile_complaints, - _("Computed physname <%s> does not match demangled <%s> " - "(from linkage <%s>) - DIE at 0x%x [in module %s]"), - physname, canon, mangled, die->offset.sect_off, objfile->name); + complaint (&symfile_complaints, + _("Computed physname <%s> does not match demangled <%s> " + "(from linkage <%s>) - DIE at 0x%x [in module %s]"), + physname, canon, mangled, die->offset.sect_off, + objfile_name (objfile)); + + /* Prefer DW_AT_linkage_name (in the CANON form) - when it + is available here - over computed PHYSNAME. It is safer + against both buggy GDB and buggy compilers. */ + + retval = canon; + } + else + { + retval = physname; + need_copy = 0; + } + } + else + retval = canon; + + if (need_copy) + retval = obstack_copy0 (&objfile->per_bfd->storage_obstack, + retval, strlen (retval)); + + do_cleanups (back_to); + return retval; +} + +/* Inspect DIE in CU for a namespace alias. If one exists, record + a new symbol for it. + + Returns 1 if a namespace alias was recorded, 0 otherwise. */ + +static int +read_namespace_alias (struct die_info *die, struct dwarf2_cu *cu) +{ + struct attribute *attr; + + /* If the die does not have a name, this is not a namespace + alias. */ + attr = dwarf2_attr (die, DW_AT_name, cu); + if (attr != NULL) + { + int num; + struct die_info *d = die; + struct dwarf2_cu *imported_cu = cu; + + /* If the compiler has nested DW_AT_imported_declaration DIEs, + keep inspecting DIEs until we hit the underlying import. */ +#define MAX_NESTED_IMPORTED_DECLARATIONS 100 + for (num = 0; num < MAX_NESTED_IMPORTED_DECLARATIONS; ++num) + { + attr = dwarf2_attr (d, DW_AT_import, cu); + if (attr == NULL) + break; - /* Prefer DW_AT_linkage_name (in the CANON form) - when it - is available here - over computed PHYSNAME. It is safer - against both buggy GDB and buggy compilers. */ + d = follow_die_ref (d, attr, &imported_cu); + if (d->tag != DW_TAG_imported_declaration) + break; + } - retval = canon; + if (num == MAX_NESTED_IMPORTED_DECLARATIONS) + { + complaint (&symfile_complaints, + _("DIE at 0x%x has too many recursively imported " + "declarations"), d->offset.sect_off); + return 0; } - else + + if (attr != NULL) { - retval = physname; - need_copy = 0; + struct type *type; + sect_offset offset = dwarf2_get_ref_die_offset (attr); + + type = get_die_type_at_offset (offset, cu->per_cu); + if (type != NULL && TYPE_CODE (type) == TYPE_CODE_NAMESPACE) + { + /* This declaration is a global namespace alias. Add + a symbol for it whose type is the aliased namespace. */ + new_symbol (die, type, cu); + return 1; + } } } - else - retval = canon; - - if (need_copy) - retval = obstack_copy0 (&objfile->objfile_obstack, retval, strlen (retval)); - do_cleanups (back_to); - return retval; + return 0; } /* Read the import statement specified by the given die and record it. */ @@ -8326,7 +8856,7 @@ read_import_statement (struct die_info *die, struct dwarf2_cu *cu) complaint (&symfile_complaints, _("child DW_TAG_imported_declaration expected " "- DIE at 0x%x [in module %s]"), - child_die->offset.sect_off, objfile->name); + child_die->offset.sect_off, objfile_name (objfile)); continue; } @@ -8347,7 +8877,7 @@ read_import_statement (struct die_info *die, struct dwarf2_cu *cu) complaint (&symfile_complaints, _("child DW_TAG_imported_declaration has unknown " "imported name - DIE at 0x%x [in module %s]"), - child_die->offset.sect_off, objfile->name); + child_die->offset.sect_off, objfile_name (objfile)); continue; } @@ -8865,13 +9395,13 @@ create_dwo_cu (struct dwo_file *dwo_file) /* We can't set abfd until now because the section may be empty or not present, in which case section->asection will be NULL. */ - abfd = section->asection->owner; + abfd = get_section_bfd_owner (section); if (dwarf2_read_debug) { fprintf_unfiltered (gdb_stdlog, "Reading %s for %s:\n", - bfd_section_name (abfd, section->asection), - bfd_get_filename (abfd)); + get_section_name (section), + get_section_file_name (section)); } create_dwo_cu_data.dwo_file = dwo_file; @@ -8890,9 +9420,7 @@ create_dwo_cu (struct dwo_file *dwo_file) per_cu.offset.sect_off = info_ptr - section->buffer; per_cu.section = section; - init_cutu_and_read_dies_no_follow (&per_cu, - &dwo_file->sections.abbrev, - dwo_file, + init_cutu_and_read_dies_no_follow (&per_cu, dwo_file, create_dwo_cu_reader, &create_dwo_cu_data); @@ -8905,7 +9433,7 @@ create_dwo_cu (struct dwo_file *dwo_file) { complaint (&symfile_complaints, _("Multiple CUs in DWO file %s [in module %s]"), - dwo_file->dwo_name, objfile->name); + dwo_file->dwo_name, objfile_name (objfile)); break; } @@ -8939,10 +9467,6 @@ create_dwo_cu (struct dwo_file *dwo_file) Numbers are recorded using the byte order of the application binary. - We assume that N and M will not exceed 2^32 - 1. - - The size of the hash table, M, must be 2^k such that 2^k > 3*N/2. - The hash table begins at offset 16 in the section, and consists of an array of M 64-bit slots. Each slot contains a 64-bit signature (using the byte order of the application binary). Unused slots in the hash table are 0. @@ -8955,6 +9479,89 @@ create_dwo_cu (struct dwo_file *dwo_file) table contains a 32-bit index into the pool of section numbers. For unused hash table slots, the corresponding entry in the parallel table will be 0. + The pool of section numbers begins immediately following the hash table + (at offset 16 + 12 * M from the beginning of the section). The pool of + section numbers consists of an array of 32-bit words (using the byte order + of the application binary). Each item in the array is indexed starting + from 0. The hash table entry provides the index of the first section + number in the set. Additional section numbers in the set follow, and the + set is terminated by a 0 entry (section number 0 is not used in ELF). + + In each set of section numbers, the .debug_info.dwo or .debug_types.dwo + section must be the first entry in the set, and the .debug_abbrev.dwo must + be the second entry. Other members of the set may follow in any order. + + --- + + DWP Version 2: + + DWP Version 2 combines all the .debug_info, etc. sections into one, + and the entries in the index tables are now offsets into these sections. + CU offsets begin at 0. TU offsets begin at the size of the .debug_info + section. + + Index Section Contents: + Header + Hash Table of Signatures dwp_hash_table.hash_table + Parallel Table of Indices dwp_hash_table.unit_table + Table of Section Offsets dwp_hash_table.v2.{section_ids,offsets} + Table of Section Sizes dwp_hash_table.v2.sizes + + The index section header consists of: + + V, 32 bit version number + L, 32 bit number of columns in the table of section offsets + N, 32 bit number of compilation units or type units in the index + M, 32 bit number of slots in the hash table + + Numbers are recorded using the byte order of the application binary. + + The hash table has the same format as version 1. + The parallel table of indices has the same format as version 1, + except that the entries are origin-1 indices into the table of sections + offsets and the table of section sizes. + + The table of offsets begins immediately following the parallel table + (at offset 16 + 12 * M from the beginning of the section). The table is + a two-dimensional array of 32-bit words (using the byte order of the + application binary), with L columns and N+1 rows, in row-major order. + Each row in the array is indexed starting from 0. The first row provides + a key to the remaining rows: each column in this row provides an identifier + for a debug section, and the offsets in the same column of subsequent rows + refer to that section. The section identifiers are: + + DW_SECT_INFO 1 .debug_info.dwo + DW_SECT_TYPES 2 .debug_types.dwo + DW_SECT_ABBREV 3 .debug_abbrev.dwo + DW_SECT_LINE 4 .debug_line.dwo + DW_SECT_LOC 5 .debug_loc.dwo + DW_SECT_STR_OFFSETS 6 .debug_str_offsets.dwo + DW_SECT_MACINFO 7 .debug_macinfo.dwo + DW_SECT_MACRO 8 .debug_macro.dwo + + The offsets provided by the CU and TU index sections are the base offsets + for the contributions made by each CU or TU to the corresponding section + in the package file. Each CU and TU header contains an abbrev_offset + field, used to find the abbreviations table for that CU or TU within the + contribution to the .debug_abbrev.dwo section for that CU or TU, and should + be interpreted as relative to the base offset given in the index section. + Likewise, offsets into .debug_line.dwo from DW_AT_stmt_list attributes + should be interpreted as relative to the base offset for .debug_line.dwo, + and offsets into other debug sections obtained from DWARF attributes should + also be interpreted as relative to the corresponding base offset. + + The table of sizes begins immediately following the table of offsets. + Like the table of offsets, it is a two-dimensional array of 32-bit words, + with L columns and N rows, in row-major order. Each row in the array is + indexed starting from 1 (row 0 is shared by the two tables). + + --- + + Hash table lookup is handled the same in version 1 and 2: + + We assume that N and M will not exceed 2^32 - 1. + The size of the hash table, M, must be 2^k such that 2^k > 3*N/2. + Given a 64-bit compilation unit signature or a type signature S, an entry in the hash table is located as follows: @@ -8970,19 +9577,7 @@ create_dwo_cu (struct dwo_file *dwo_file) 4) Let H = (H + H') modulo M. Repeat at Step 3. Because M > N and H' and M are relatively prime, the search is guaranteed - to stop at an unused slot or find the match. - - The pool of section numbers begins immediately following the hash table - (at offset 16 + 12 * M from the beginning of the section). The pool of - section numbers consists of an array of 32-bit words (using the byte order - of the application binary). Each item in the array is indexed starting - from 0. The hash table entry provides the index of the first section - number in the set. Additional section numbers in the set follow, and the - set is terminated by a 0 entry (section number 0 is not used in ELF). - - In each set of section numbers, the .debug_info.dwo or .debug_types.dwo - section must be the first entry in the set, and the .debug_abbrev.dwo must - be the second entry. Other members of the set may follow in any order. */ + to stop at an unused slot or find the match. */ /* Create a hash table to map DWO IDs to their CU/TU entry in .debug_{info,types}.dwo in DWP_FILE. @@ -8996,7 +9591,7 @@ create_dwp_hash_table (struct dwp_file *dwp_file, int is_debug_types) bfd *dbfd = dwp_file->dbfd; const gdb_byte *index_ptr, *index_end; struct dwarf2_section_info *index; - uint32_t version, nr_units, nr_slots; + uint32_t version, nr_columns, nr_units, nr_slots; struct dwp_hash_table *htab; if (is_debug_types) @@ -9012,13 +9607,18 @@ create_dwp_hash_table (struct dwp_file *dwp_file, int is_debug_types) index_end = index_ptr + index->size; version = read_4_bytes (dbfd, index_ptr); - index_ptr += 8; /* Skip the unused word. */ + index_ptr += 4; + if (version == 2) + nr_columns = read_4_bytes (dbfd, index_ptr); + else + nr_columns = 0; + index_ptr += 4; nr_units = read_4_bytes (dbfd, index_ptr); index_ptr += 4; nr_slots = read_4_bytes (dbfd, index_ptr); index_ptr += 4; - if (version != 1) + if (version != 1 && version != 2) { error (_("Dwarf Error: unsupported DWP file version (%s)" " [in module %s]"), @@ -9032,11 +9632,106 @@ create_dwp_hash_table (struct dwp_file *dwp_file, int is_debug_types) } htab = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwp_hash_table); + htab->version = version; + htab->nr_columns = nr_columns; htab->nr_units = nr_units; htab->nr_slots = nr_slots; htab->hash_table = index_ptr; htab->unit_table = htab->hash_table + sizeof (uint64_t) * nr_slots; - htab->section_pool = htab->unit_table + sizeof (uint32_t) * nr_slots; + + /* Exit early if the table is empty. */ + if (nr_slots == 0 || nr_units == 0 + || (version == 2 && nr_columns == 0)) + { + /* All must be zero. */ + if (nr_slots != 0 || nr_units != 0 + || (version == 2 && nr_columns != 0)) + { + complaint (&symfile_complaints, + _("Empty DWP but nr_slots,nr_units,nr_columns not" + " all zero [in modules %s]"), + dwp_file->name); + } + return htab; + } + + if (version == 1) + { + htab->section_pool.v1.indices = + htab->unit_table + sizeof (uint32_t) * nr_slots; + /* It's harder to decide whether the section is too small in v1. + V1 is deprecated anyway so we punt. */ + } + else + { + const gdb_byte *ids_ptr = htab->unit_table + sizeof (uint32_t) * nr_slots; + int *ids = htab->section_pool.v2.section_ids; + /* Reverse map for error checking. */ + int ids_seen[DW_SECT_MAX + 1]; + int i; + + if (nr_columns < 2) + { + error (_("Dwarf Error: bad DWP hash table, too few columns" + " in section table [in module %s]"), + dwp_file->name); + } + if (nr_columns > MAX_NR_V2_DWO_SECTIONS) + { + error (_("Dwarf Error: bad DWP hash table, too many columns" + " in section table [in module %s]"), + dwp_file->name); + } + memset (ids, 255, (DW_SECT_MAX + 1) * sizeof (int32_t)); + memset (ids_seen, 255, (DW_SECT_MAX + 1) * sizeof (int32_t)); + for (i = 0; i < nr_columns; ++i) + { + int id = read_4_bytes (dbfd, ids_ptr + i * sizeof (uint32_t)); + + if (id < DW_SECT_MIN || id > DW_SECT_MAX) + { + error (_("Dwarf Error: bad DWP hash table, bad section id %d" + " in section table [in module %s]"), + id, dwp_file->name); + } + if (ids_seen[id] != -1) + { + error (_("Dwarf Error: bad DWP hash table, duplicate section" + " id %d in section table [in module %s]"), + id, dwp_file->name); + } + ids_seen[id] = i; + ids[i] = id; + } + /* Must have exactly one info or types section. */ + if (((ids_seen[DW_SECT_INFO] != -1) + + (ids_seen[DW_SECT_TYPES] != -1)) + != 1) + { + error (_("Dwarf Error: bad DWP hash table, missing/duplicate" + " DWO info/types section [in module %s]"), + dwp_file->name); + } + /* Must have an abbrev section. */ + if (ids_seen[DW_SECT_ABBREV] == -1) + { + error (_("Dwarf Error: bad DWP hash table, missing DWO abbrev" + " section [in module %s]"), + dwp_file->name); + } + htab->section_pool.v2.offsets = ids_ptr + sizeof (uint32_t) * nr_columns; + htab->section_pool.v2.sizes = + htab->section_pool.v2.offsets + (sizeof (uint32_t) + * nr_units * nr_columns); + if ((htab->section_pool.v2.sizes + (sizeof (uint32_t) + * nr_units * nr_columns)) + > index_end) + { + error (_("Dwarf Error: DWP index section is corrupt (too small)" + " [in module %s]"), + dwp_file->name); + } + } return htab; } @@ -9045,71 +9740,71 @@ create_dwp_hash_table (struct dwp_file *dwp_file, int is_debug_types) This function is like the other "locate" section routines that are passed to bfd_map_over_sections, but in this context the sections to - read comes from the DWP hash table, not the full ELF section table. + read comes from the DWP V1 hash table, not the full ELF section table. The result is non-zero for success, or zero if an error was found. */ static int -locate_virtual_dwo_sections (asection *sectp, - struct virtual_dwo_sections *sections) +locate_v1_virtual_dwo_sections (asection *sectp, + struct virtual_v1_dwo_sections *sections) { const struct dwop_section_names *names = &dwop_section_names; if (section_is_p (sectp->name, &names->abbrev_dwo)) { /* There can be only one. */ - if (sections->abbrev.asection != NULL) + if (sections->abbrev.s.asection != NULL) return 0; - sections->abbrev.asection = sectp; + sections->abbrev.s.asection = sectp; sections->abbrev.size = bfd_get_section_size (sectp); } else if (section_is_p (sectp->name, &names->info_dwo) || section_is_p (sectp->name, &names->types_dwo)) { /* There can be only one. */ - if (sections->info_or_types.asection != NULL) + if (sections->info_or_types.s.asection != NULL) return 0; - sections->info_or_types.asection = sectp; + sections->info_or_types.s.asection = sectp; sections->info_or_types.size = bfd_get_section_size (sectp); } else if (section_is_p (sectp->name, &names->line_dwo)) { /* There can be only one. */ - if (sections->line.asection != NULL) + if (sections->line.s.asection != NULL) return 0; - sections->line.asection = sectp; + sections->line.s.asection = sectp; sections->line.size = bfd_get_section_size (sectp); } else if (section_is_p (sectp->name, &names->loc_dwo)) { /* There can be only one. */ - if (sections->loc.asection != NULL) + if (sections->loc.s.asection != NULL) return 0; - sections->loc.asection = sectp; + sections->loc.s.asection = sectp; sections->loc.size = bfd_get_section_size (sectp); } else if (section_is_p (sectp->name, &names->macinfo_dwo)) { /* There can be only one. */ - if (sections->macinfo.asection != NULL) + if (sections->macinfo.s.asection != NULL) return 0; - sections->macinfo.asection = sectp; + sections->macinfo.s.asection = sectp; sections->macinfo.size = bfd_get_section_size (sectp); } else if (section_is_p (sectp->name, &names->macro_dwo)) { /* There can be only one. */ - if (sections->macro.asection != NULL) + if (sections->macro.s.asection != NULL) return 0; - sections->macro.asection = sectp; + sections->macro.s.asection = sectp; sections->macro.size = bfd_get_section_size (sectp); } else if (section_is_p (sectp->name, &names->str_offsets_dwo)) { /* There can be only one. */ - if (sections->str_offsets.asection != NULL) + if (sections->str_offsets.s.asection != NULL) return 0; - sections->str_offsets.asection = sectp; + sections->str_offsets.s.asection = sectp; sections->str_offsets.size = bfd_get_section_size (sectp); } else @@ -9121,113 +9816,314 @@ locate_virtual_dwo_sections (asection *sectp, return 1; } -/* Create a dwo_unit object for the DWO with signature SIGNATURE. - HTAB is the hash table from the DWP file. - SECTION_INDEX is the index of the DWO in HTAB. - COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU. */ +/* Create a dwo_unit object for the DWO unit with signature SIGNATURE. + UNIT_INDEX is the index of the DWO unit in the DWP hash table. + COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU. + This is for DWP version 1 files. */ + +static struct dwo_unit * +create_dwo_unit_in_dwp_v1 (struct dwp_file *dwp_file, + uint32_t unit_index, + const char *comp_dir, + ULONGEST signature, int is_debug_types) +{ + struct objfile *objfile = dwarf2_per_objfile->objfile; + const struct dwp_hash_table *dwp_htab = + is_debug_types ? dwp_file->tus : dwp_file->cus; + bfd *dbfd = dwp_file->dbfd; + const char *kind = is_debug_types ? "TU" : "CU"; + struct dwo_file *dwo_file; + struct dwo_unit *dwo_unit; + struct virtual_v1_dwo_sections sections; + void **dwo_file_slot; + char *virtual_dwo_name; + struct dwarf2_section_info *cutu; + struct cleanup *cleanups; + int i; + + gdb_assert (dwp_file->version == 1); + + if (dwarf2_read_debug) + { + fprintf_unfiltered (gdb_stdlog, "Reading %s %s/%s in DWP V1 file: %s\n", + kind, + pulongest (unit_index), hex_string (signature), + dwp_file->name); + } + + /* Fetch the sections of this DWO unit. + Put a limit on the number of sections we look for so that bad data + doesn't cause us to loop forever. */ + +#define MAX_NR_V1_DWO_SECTIONS \ + (1 /* .debug_info or .debug_types */ \ + + 1 /* .debug_abbrev */ \ + + 1 /* .debug_line */ \ + + 1 /* .debug_loc */ \ + + 1 /* .debug_str_offsets */ \ + + 1 /* .debug_macro or .debug_macinfo */ \ + + 1 /* trailing zero */) + + memset (§ions, 0, sizeof (sections)); + cleanups = make_cleanup (null_cleanup, 0); + + for (i = 0; i < MAX_NR_V1_DWO_SECTIONS; ++i) + { + asection *sectp; + uint32_t section_nr = + read_4_bytes (dbfd, + dwp_htab->section_pool.v1.indices + + (unit_index + i) * sizeof (uint32_t)); + + if (section_nr == 0) + break; + if (section_nr >= dwp_file->num_sections) + { + error (_("Dwarf Error: bad DWP hash table, section number too large" + " [in module %s]"), + dwp_file->name); + } + + sectp = dwp_file->elf_sections[section_nr]; + if (! locate_v1_virtual_dwo_sections (sectp, §ions)) + { + error (_("Dwarf Error: bad DWP hash table, invalid section found" + " [in module %s]"), + dwp_file->name); + } + } + + if (i < 2 + || dwarf2_section_empty_p (§ions.info_or_types) + || dwarf2_section_empty_p (§ions.abbrev)) + { + error (_("Dwarf Error: bad DWP hash table, missing DWO sections" + " [in module %s]"), + dwp_file->name); + } + if (i == MAX_NR_V1_DWO_SECTIONS) + { + error (_("Dwarf Error: bad DWP hash table, too many DWO sections" + " [in module %s]"), + dwp_file->name); + } + + /* It's easier for the rest of the code if we fake a struct dwo_file and + have dwo_unit "live" in that. At least for now. + + The DWP file can be made up of a random collection of CUs and TUs. + However, for each CU + set of TUs that came from the same original DWO + file, we can combine them back into a virtual DWO file to save space + (fewer struct dwo_file objects to allocate). Remember that for really + large apps there can be on the order of 8K CUs and 200K TUs, or more. */ + + virtual_dwo_name = + xstrprintf ("virtual-dwo/%d-%d-%d-%d", + get_section_id (§ions.abbrev), + get_section_id (§ions.line), + get_section_id (§ions.loc), + get_section_id (§ions.str_offsets)); + make_cleanup (xfree, virtual_dwo_name); + /* Can we use an existing virtual DWO file? */ + dwo_file_slot = lookup_dwo_file_slot (virtual_dwo_name, comp_dir); + /* Create one if necessary. */ + if (*dwo_file_slot == NULL) + { + if (dwarf2_read_debug) + { + fprintf_unfiltered (gdb_stdlog, "Creating virtual DWO: %s\n", + virtual_dwo_name); + } + dwo_file = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_file); + dwo_file->dwo_name = obstack_copy0 (&objfile->objfile_obstack, + virtual_dwo_name, + strlen (virtual_dwo_name)); + dwo_file->comp_dir = comp_dir; + dwo_file->sections.abbrev = sections.abbrev; + dwo_file->sections.line = sections.line; + dwo_file->sections.loc = sections.loc; + dwo_file->sections.macinfo = sections.macinfo; + dwo_file->sections.macro = sections.macro; + dwo_file->sections.str_offsets = sections.str_offsets; + /* The "str" section is global to the entire DWP file. */ + dwo_file->sections.str = dwp_file->sections.str; + /* The info or types section is assigned below to dwo_unit, + there's no need to record it in dwo_file. + Also, we can't simply record type sections in dwo_file because + we record a pointer into the vector in dwo_unit. As we collect more + types we'll grow the vector and eventually have to reallocate space + for it, invalidating all copies of pointers into the previous + contents. */ + *dwo_file_slot = dwo_file; + } + else + { + if (dwarf2_read_debug) + { + fprintf_unfiltered (gdb_stdlog, "Using existing virtual DWO: %s\n", + virtual_dwo_name); + } + dwo_file = *dwo_file_slot; + } + do_cleanups (cleanups); + + dwo_unit = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_unit); + dwo_unit->dwo_file = dwo_file; + dwo_unit->signature = signature; + dwo_unit->section = obstack_alloc (&objfile->objfile_obstack, + sizeof (struct dwarf2_section_info)); + *dwo_unit->section = sections.info_or_types; + /* dwo_unit->{offset,length,type_offset_in_tu} are set later. */ + + return dwo_unit; +} + +/* Subroutine of create_dwo_unit_in_dwp_v2 to simplify it. + Given a pointer to the containing section SECTION, and OFFSET,SIZE of the + piece within that section used by a TU/CU, return a virtual section + of just that piece. */ + +static struct dwarf2_section_info +create_dwp_v2_section (struct dwarf2_section_info *section, + bfd_size_type offset, bfd_size_type size) +{ + struct dwarf2_section_info result; + asection *sectp; + + gdb_assert (section != NULL); + gdb_assert (!section->is_virtual); + + memset (&result, 0, sizeof (result)); + result.s.containing_section = section; + result.is_virtual = 1; + + if (size == 0) + return result; + + sectp = get_section_bfd_section (section); + + /* Flag an error if the piece denoted by OFFSET,SIZE is outside the + bounds of the real section. This is a pretty-rare event, so just + flag an error (easier) instead of a warning and trying to cope. */ + if (sectp == NULL + || offset + size > bfd_get_section_size (sectp)) + { + bfd *abfd = sectp->owner; + + error (_("Dwarf Error: Bad DWP V2 section info, doesn't fit" + " in section %s [in module %s]"), + sectp ? bfd_section_name (abfd, sectp) : "", + objfile_name (dwarf2_per_objfile->objfile)); + } + + result.virtual_offset = offset; + result.size = size; + return result; +} + +/* Create a dwo_unit object for the DWO unit with signature SIGNATURE. + UNIT_INDEX is the index of the DWO unit in the DWP hash table. + COMP_DIR is the DW_AT_comp_dir attribute of the referencing CU. + This is for DWP version 2 files. */ static struct dwo_unit * -create_dwo_in_dwp (struct dwp_file *dwp_file, - const struct dwp_hash_table *htab, - uint32_t section_index, - const char *comp_dir, - ULONGEST signature, int is_debug_types) +create_dwo_unit_in_dwp_v2 (struct dwp_file *dwp_file, + uint32_t unit_index, + const char *comp_dir, + ULONGEST signature, int is_debug_types) { struct objfile *objfile = dwarf2_per_objfile->objfile; + const struct dwp_hash_table *dwp_htab = + is_debug_types ? dwp_file->tus : dwp_file->cus; bfd *dbfd = dwp_file->dbfd; const char *kind = is_debug_types ? "TU" : "CU"; struct dwo_file *dwo_file; struct dwo_unit *dwo_unit; - struct virtual_dwo_sections sections; + struct virtual_v2_dwo_sections sections; void **dwo_file_slot; char *virtual_dwo_name; struct dwarf2_section_info *cutu; struct cleanup *cleanups; int i; + gdb_assert (dwp_file->version == 2); + if (dwarf2_read_debug) { - fprintf_unfiltered (gdb_stdlog, "Reading %s %s/%s in DWP file: %s\n", + fprintf_unfiltered (gdb_stdlog, "Reading %s %s/%s in DWP V2 file: %s\n", kind, - pulongest (section_index), hex_string (signature), + pulongest (unit_index), hex_string (signature), dwp_file->name); } - /* Fetch the sections of this DWO. - Put a limit on the number of sections we look for so that bad data - doesn't cause us to loop forever. */ - -#define MAX_NR_DWO_SECTIONS \ - (1 /* .debug_info or .debug_types */ \ - + 1 /* .debug_abbrev */ \ - + 1 /* .debug_line */ \ - + 1 /* .debug_loc */ \ - + 1 /* .debug_str_offsets */ \ - + 1 /* .debug_macro */ \ - + 1 /* .debug_macinfo */ \ - + 1 /* trailing zero */) + /* Fetch the section offsets of this DWO unit. */ memset (§ions, 0, sizeof (sections)); cleanups = make_cleanup (null_cleanup, 0); - for (i = 0; i < MAX_NR_DWO_SECTIONS; ++i) + for (i = 0; i < dwp_htab->nr_columns; ++i) { - asection *sectp; - uint32_t section_nr = - read_4_bytes (dbfd, - htab->section_pool - + (section_index + i) * sizeof (uint32_t)); - - if (section_nr == 0) - break; - if (section_nr >= dwp_file->num_sections) - { - error (_("Dwarf Error: bad DWP hash table, section number too large" - " [in module %s]"), - dwp_file->name); - } + uint32_t offset = read_4_bytes (dbfd, + dwp_htab->section_pool.v2.offsets + + (((unit_index - 1) * dwp_htab->nr_columns + + i) + * sizeof (uint32_t))); + uint32_t size = read_4_bytes (dbfd, + dwp_htab->section_pool.v2.sizes + + (((unit_index - 1) * dwp_htab->nr_columns + + i) + * sizeof (uint32_t))); - sectp = dwp_file->elf_sections[section_nr]; - if (! locate_virtual_dwo_sections (sectp, §ions)) + switch (dwp_htab->section_pool.v2.section_ids[i]) { - error (_("Dwarf Error: bad DWP hash table, invalid section found" - " [in module %s]"), - dwp_file->name); + case DW_SECT_INFO: + case DW_SECT_TYPES: + sections.info_or_types_offset = offset; + sections.info_or_types_size = size; + break; + case DW_SECT_ABBREV: + sections.abbrev_offset = offset; + sections.abbrev_size = size; + break; + case DW_SECT_LINE: + sections.line_offset = offset; + sections.line_size = size; + break; + case DW_SECT_LOC: + sections.loc_offset = offset; + sections.loc_size = size; + break; + case DW_SECT_STR_OFFSETS: + sections.str_offsets_offset = offset; + sections.str_offsets_size = size; + break; + case DW_SECT_MACINFO: + sections.macinfo_offset = offset; + sections.macinfo_size = size; + break; + case DW_SECT_MACRO: + sections.macro_offset = offset; + sections.macro_size = size; + break; } } - if (i < 2 - || sections.info_or_types.asection == NULL - || sections.abbrev.asection == NULL) - { - error (_("Dwarf Error: bad DWP hash table, missing DWO sections" - " [in module %s]"), - dwp_file->name); - } - if (i == MAX_NR_DWO_SECTIONS) - { - error (_("Dwarf Error: bad DWP hash table, too many DWO sections" - " [in module %s]"), - dwp_file->name); - } - /* It's easier for the rest of the code if we fake a struct dwo_file and have dwo_unit "live" in that. At least for now. The DWP file can be made up of a random collection of CUs and TUs. However, for each CU + set of TUs that came from the same original DWO - file, we want to combine them back into a virtual DWO file to save space - (fewer struct dwo_file objects to allocated). Remember that for really + file, we can combine them back into a virtual DWO file to save space + (fewer struct dwo_file objects to allocate). Remember that for really large apps there can be on the order of 8K CUs and 200K TUs, or more. */ virtual_dwo_name = - xstrprintf ("virtual-dwo/%d-%d-%d-%d", - sections.abbrev.asection ? sections.abbrev.asection->id : 0, - sections.line.asection ? sections.line.asection->id : 0, - sections.loc.asection ? sections.loc.asection->id : 0, - (sections.str_offsets.asection - ? sections.str_offsets.asection->id - : 0)); + xstrprintf ("virtual-dwo/%ld-%ld-%ld-%ld", + (long) (sections.abbrev_size ? sections.abbrev_offset : 0), + (long) (sections.line_size ? sections.line_offset : 0), + (long) (sections.loc_size ? sections.loc_offset : 0), + (long) (sections.str_offsets_size + ? sections.str_offsets_offset : 0)); make_cleanup (xfree, virtual_dwo_name); /* Can we use an existing virtual DWO file? */ dwo_file_slot = lookup_dwo_file_slot (virtual_dwo_name, comp_dir); @@ -9244,20 +10140,34 @@ create_dwo_in_dwp (struct dwp_file *dwp_file, virtual_dwo_name, strlen (virtual_dwo_name)); dwo_file->comp_dir = comp_dir; - dwo_file->sections.abbrev = sections.abbrev; - dwo_file->sections.line = sections.line; - dwo_file->sections.loc = sections.loc; - dwo_file->sections.macinfo = sections.macinfo; - dwo_file->sections.macro = sections.macro; - dwo_file->sections.str_offsets = sections.str_offsets; + dwo_file->sections.abbrev = + create_dwp_v2_section (&dwp_file->sections.abbrev, + sections.abbrev_offset, sections.abbrev_size); + dwo_file->sections.line = + create_dwp_v2_section (&dwp_file->sections.line, + sections.line_offset, sections.line_size); + dwo_file->sections.loc = + create_dwp_v2_section (&dwp_file->sections.loc, + sections.loc_offset, sections.loc_size); + dwo_file->sections.macinfo = + create_dwp_v2_section (&dwp_file->sections.macinfo, + sections.macinfo_offset, sections.macinfo_size); + dwo_file->sections.macro = + create_dwp_v2_section (&dwp_file->sections.macro, + sections.macro_offset, sections.macro_size); + dwo_file->sections.str_offsets = + create_dwp_v2_section (&dwp_file->sections.str_offsets, + sections.str_offsets_offset, + sections.str_offsets_size); /* The "str" section is global to the entire DWP file. */ dwo_file->sections.str = dwp_file->sections.str; - /* The info or types section is assigned later to dwo_unit, + /* The info or types section is assigned below to dwo_unit, there's no need to record it in dwo_file. Also, we can't simply record type sections in dwo_file because we record a pointer into the vector in dwo_unit. As we collect more types we'll grow the vector and eventually have to reallocate space - for it, invalidating all the pointers into the current copy. */ + for it, invalidating all copies of pointers into the previous + contents. */ *dwo_file_slot = dwo_file; } else @@ -9276,22 +10186,27 @@ create_dwo_in_dwp (struct dwp_file *dwp_file, dwo_unit->signature = signature; dwo_unit->section = obstack_alloc (&objfile->objfile_obstack, sizeof (struct dwarf2_section_info)); - *dwo_unit->section = sections.info_or_types; - /* offset, length, type_offset_in_tu are set later. */ + *dwo_unit->section = create_dwp_v2_section (is_debug_types + ? &dwp_file->sections.types + : &dwp_file->sections.info, + sections.info_or_types_offset, + sections.info_or_types_size); + /* dwo_unit->{offset,length,type_offset_in_tu} are set later. */ return dwo_unit; } -/* Lookup the DWO with SIGNATURE in DWP_FILE. */ +/* Lookup the DWO unit with SIGNATURE in DWP_FILE. + Returns NULL if the signature isn't found. */ static struct dwo_unit * -lookup_dwo_in_dwp (struct dwp_file *dwp_file, - const struct dwp_hash_table *htab, - const char *comp_dir, - ULONGEST signature, int is_debug_types) +lookup_dwo_unit_in_dwp (struct dwp_file *dwp_file, const char *comp_dir, + ULONGEST signature, int is_debug_types) { + const struct dwp_hash_table *dwp_htab = + is_debug_types ? dwp_file->tus : dwp_file->cus; bfd *dbfd = dwp_file->dbfd; - uint32_t mask = htab->nr_slots - 1; + uint32_t mask = dwp_htab->nr_slots - 1; uint32_t hash = signature & mask; uint32_t hash2 = ((signature >> 32) & mask) | 1; unsigned int i; @@ -9300,25 +10215,39 @@ lookup_dwo_in_dwp (struct dwp_file *dwp_file, memset (&find_dwo_cu, 0, sizeof (find_dwo_cu)); find_dwo_cu.signature = signature; - slot = htab_find_slot (dwp_file->loaded_cutus, &find_dwo_cu, INSERT); + slot = htab_find_slot (is_debug_types + ? dwp_file->loaded_tus + : dwp_file->loaded_cus, + &find_dwo_cu, INSERT); if (*slot != NULL) return *slot; /* Use a for loop so that we don't loop forever on bad debug info. */ - for (i = 0; i < htab->nr_slots; ++i) + for (i = 0; i < dwp_htab->nr_slots; ++i) { ULONGEST signature_in_table; signature_in_table = - read_8_bytes (dbfd, htab->hash_table + hash * sizeof (uint64_t)); + read_8_bytes (dbfd, dwp_htab->hash_table + hash * sizeof (uint64_t)); if (signature_in_table == signature) { - uint32_t section_index = - read_4_bytes (dbfd, htab->unit_table + hash * sizeof (uint32_t)); + uint32_t unit_index = + read_4_bytes (dbfd, + dwp_htab->unit_table + hash * sizeof (uint32_t)); - *slot = create_dwo_in_dwp (dwp_file, htab, section_index, - comp_dir, signature, is_debug_types); + if (dwp_file->version == 1) + { + *slot = create_dwo_unit_in_dwp_v1 (dwp_file, unit_index, + comp_dir, signature, + is_debug_types); + } + else + { + *slot = create_dwo_unit_in_dwp_v2 (dwp_file, unit_index, + comp_dir, signature, + is_debug_types); + } return *slot; } if (signature_in_table == 0) @@ -9338,6 +10267,8 @@ lookup_dwo_in_dwp (struct dwp_file *dwp_file, If IS_DWP is TRUE, we're opening a DWP file, otherwise a DWO file. SEARCH_CWD is true if the current directory is to be searched. It will be searched before debug-file-directory. + If successful, the file is added to the bfd include table of the + objfile's bfd (see gdb_bfd_record_inclusion). If unable to find/open the file, return NULL. NOTE: This function is derived from symfile_bfd_open. */ @@ -9385,6 +10316,12 @@ try_open_dwop_file (const char *file_name, int is_dwp, int search_cwd) return NULL; } + /* Success. Record the bfd as having been included by the objfile's bfd. + This is important because things like demangled_names_hash lives in the + objfile's per_bfd space and may have references to things like symbol + names that live in the DWO/DWP file's per_bfd space. PR 16426. */ + gdb_bfd_record_inclusion (dwarf2_per_objfile->objfile->obfd, sym_bfd); + return sym_bfd; } @@ -9437,42 +10374,42 @@ dwarf2_locate_dwo_sections (bfd *abfd, asection *sectp, void *dwo_sections_ptr) if (section_is_p (sectp->name, &names->abbrev_dwo)) { - dwo_sections->abbrev.asection = sectp; + dwo_sections->abbrev.s.asection = sectp; dwo_sections->abbrev.size = bfd_get_section_size (sectp); } else if (section_is_p (sectp->name, &names->info_dwo)) { - dwo_sections->info.asection = sectp; + dwo_sections->info.s.asection = sectp; dwo_sections->info.size = bfd_get_section_size (sectp); } else if (section_is_p (sectp->name, &names->line_dwo)) { - dwo_sections->line.asection = sectp; + dwo_sections->line.s.asection = sectp; dwo_sections->line.size = bfd_get_section_size (sectp); } else if (section_is_p (sectp->name, &names->loc_dwo)) { - dwo_sections->loc.asection = sectp; + dwo_sections->loc.s.asection = sectp; dwo_sections->loc.size = bfd_get_section_size (sectp); } else if (section_is_p (sectp->name, &names->macinfo_dwo)) { - dwo_sections->macinfo.asection = sectp; + dwo_sections->macinfo.s.asection = sectp; dwo_sections->macinfo.size = bfd_get_section_size (sectp); } else if (section_is_p (sectp->name, &names->macro_dwo)) { - dwo_sections->macro.asection = sectp; + dwo_sections->macro.s.asection = sectp; dwo_sections->macro.size = bfd_get_section_size (sectp); } else if (section_is_p (sectp->name, &names->str_dwo)) { - dwo_sections->str.asection = sectp; + dwo_sections->str.s.asection = sectp; dwo_sections->str.size = bfd_get_section_size (sectp); } else if (section_is_p (sectp->name, &names->str_offsets_dwo)) { - dwo_sections->str_offsets.asection = sectp; + dwo_sections->str_offsets.s.asection = sectp; dwo_sections->str_offsets.size = bfd_get_section_size (sectp); } else if (section_is_p (sectp->name, &names->types_dwo)) @@ -9480,7 +10417,7 @@ dwarf2_locate_dwo_sections (bfd *abfd, asection *sectp, void *dwo_sections_ptr) struct dwarf2_section_info type_section; memset (&type_section, 0, sizeof (type_section)); - type_section.asection = sectp; + type_section.s.asection = sectp; type_section.size = bfd_get_section_size (sectp); VEC_safe_push (dwarf2_section_info_def, dwo_sections->types, &type_section); @@ -9530,38 +10467,100 @@ open_and_init_dwo_file (struct dwarf2_per_cu_data *per_cu, } /* This function is mapped across the sections and remembers the offset and - size of each of the DWP debugging sections we are interested in. */ + size of each of the DWP debugging sections common to version 1 and 2 that + we are interested in. */ static void -dwarf2_locate_dwp_sections (bfd *abfd, asection *sectp, void *dwp_file_ptr) +dwarf2_locate_common_dwp_sections (bfd *abfd, asection *sectp, + void *dwp_file_ptr) { struct dwp_file *dwp_file = dwp_file_ptr; const struct dwop_section_names *names = &dwop_section_names; unsigned int elf_section_nr = elf_section_data (sectp)->this_idx; /* Record the ELF section number for later lookup: this is what the - .debug_cu_index,.debug_tu_index tables use. */ + .debug_cu_index,.debug_tu_index tables use in DWP V1. */ gdb_assert (elf_section_nr < dwp_file->num_sections); dwp_file->elf_sections[elf_section_nr] = sectp; /* Look for specific sections that we need. */ if (section_is_p (sectp->name, &names->str_dwo)) { - dwp_file->sections.str.asection = sectp; + dwp_file->sections.str.s.asection = sectp; dwp_file->sections.str.size = bfd_get_section_size (sectp); } else if (section_is_p (sectp->name, &names->cu_index)) { - dwp_file->sections.cu_index.asection = sectp; + dwp_file->sections.cu_index.s.asection = sectp; dwp_file->sections.cu_index.size = bfd_get_section_size (sectp); } else if (section_is_p (sectp->name, &names->tu_index)) { - dwp_file->sections.tu_index.asection = sectp; + dwp_file->sections.tu_index.s.asection = sectp; dwp_file->sections.tu_index.size = bfd_get_section_size (sectp); } } +/* This function is mapped across the sections and remembers the offset and + size of each of the DWP version 2 debugging sections that we are interested + in. This is split into a separate function because we don't know if we + have version 1 or 2 until we parse the cu_index/tu_index sections. */ + +static void +dwarf2_locate_v2_dwp_sections (bfd *abfd, asection *sectp, void *dwp_file_ptr) +{ + struct dwp_file *dwp_file = dwp_file_ptr; + const struct dwop_section_names *names = &dwop_section_names; + unsigned int elf_section_nr = elf_section_data (sectp)->this_idx; + + /* Record the ELF section number for later lookup: this is what the + .debug_cu_index,.debug_tu_index tables use in DWP V1. */ + gdb_assert (elf_section_nr < dwp_file->num_sections); + dwp_file->elf_sections[elf_section_nr] = sectp; + + /* Look for specific sections that we need. */ + if (section_is_p (sectp->name, &names->abbrev_dwo)) + { + dwp_file->sections.abbrev.s.asection = sectp; + dwp_file->sections.abbrev.size = bfd_get_section_size (sectp); + } + else if (section_is_p (sectp->name, &names->info_dwo)) + { + dwp_file->sections.info.s.asection = sectp; + dwp_file->sections.info.size = bfd_get_section_size (sectp); + } + else if (section_is_p (sectp->name, &names->line_dwo)) + { + dwp_file->sections.line.s.asection = sectp; + dwp_file->sections.line.size = bfd_get_section_size (sectp); + } + else if (section_is_p (sectp->name, &names->loc_dwo)) + { + dwp_file->sections.loc.s.asection = sectp; + dwp_file->sections.loc.size = bfd_get_section_size (sectp); + } + else if (section_is_p (sectp->name, &names->macinfo_dwo)) + { + dwp_file->sections.macinfo.s.asection = sectp; + dwp_file->sections.macinfo.size = bfd_get_section_size (sectp); + } + else if (section_is_p (sectp->name, &names->macro_dwo)) + { + dwp_file->sections.macro.s.asection = sectp; + dwp_file->sections.macro.size = bfd_get_section_size (sectp); + } + else if (section_is_p (sectp->name, &names->str_offsets_dwo)) + { + dwp_file->sections.str_offsets.s.asection = sectp; + dwp_file->sections.str_offsets.size = bfd_get_section_size (sectp); + } + else if (section_is_p (sectp->name, &names->types_dwo)) + { + dwp_file->sections.types.s.asection = sectp; + dwp_file->sections.types.size = bfd_get_section_size (sectp); + } +} + /* Hash function for dwp_file loaded CUs/TUs. */ static hashval_t @@ -9646,10 +10645,21 @@ open_and_init_dwp_file (void) bfd *dbfd; struct cleanup *cleanups; - dwp_name = xstrprintf ("%s.dwp", dwarf2_per_objfile->objfile->name); + /* Try to find first .dwp for the binary file before any symbolic links + resolving. */ + dwp_name = xstrprintf ("%s.dwp", objfile->original_name); cleanups = make_cleanup (xfree, dwp_name); dbfd = open_dwp_file (dwp_name); + if (dbfd == NULL + && strcmp (objfile->original_name, objfile_name (objfile)) != 0) + { + /* Try to find .dwp for the binary file after gdb_realpath resolving. */ + dwp_name = xstrprintf ("%s.dwp", objfile_name (objfile)); + make_cleanup (xfree, dwp_name); + dbfd = open_dwp_file (dwp_name); + } + if (dbfd == NULL) { if (dwarf2_read_debug) @@ -9668,13 +10678,30 @@ open_and_init_dwp_file (void) OBSTACK_CALLOC (&objfile->objfile_obstack, dwp_file->num_sections, asection *); - bfd_map_over_sections (dbfd, dwarf2_locate_dwp_sections, dwp_file); + bfd_map_over_sections (dbfd, dwarf2_locate_common_dwp_sections, dwp_file); dwp_file->cus = create_dwp_hash_table (dwp_file, 0); dwp_file->tus = create_dwp_hash_table (dwp_file, 1); - dwp_file->loaded_cutus = allocate_dwp_loaded_cutus_table (objfile); + /* The DWP file version is stored in the hash table. Oh well. */ + if (dwp_file->cus->version != dwp_file->tus->version) + { + /* Technically speaking, we should try to limp along, but this is + pretty bizarre. We use pulongest here because that's the established + portability solution (e.g, we cannot use %u for uint32_t). */ + error (_("Dwarf Error: DWP file CU version %s doesn't match" + " TU version %s [in DWP file %s]"), + pulongest (dwp_file->cus->version), + pulongest (dwp_file->tus->version), dwp_name); + } + dwp_file->version = dwp_file->cus->version; + + if (dwp_file->version == 2) + bfd_map_over_sections (dbfd, dwarf2_locate_v2_dwp_sections, dwp_file); + + dwp_file->loaded_cus = allocate_dwp_loaded_cutus_table (objfile); + dwp_file->loaded_tus = allocate_dwp_loaded_cutus_table (objfile); if (dwarf2_read_debug) { @@ -9742,8 +10769,8 @@ lookup_dwo_cutu (struct dwarf2_per_cu_data *this_unit, if (dwp_htab != NULL) { struct dwo_unit *dwo_cutu = - lookup_dwo_in_dwp (dwp_file, dwp_htab, comp_dir, - signature, is_debug_types); + lookup_dwo_unit_in_dwp (dwp_file, comp_dir, + signature, is_debug_types); if (dwo_cutu != NULL) { @@ -9814,11 +10841,25 @@ lookup_dwo_cutu (struct dwarf2_per_cu_data *this_unit, /* This is a warning and not a complaint because it can be caused by pilot error (e.g., user accidentally deleting the DWO). */ - warning (_("Could not find DWO %s %s(%s) referenced by %s at offset 0x%x" - " [in module %s]"), - kind, dwo_name, hex_string (signature), - this_unit->is_debug_types ? "TU" : "CU", - this_unit->offset.sect_off, objfile->name); + { + /* Print the name of the DWP file if we looked there, helps the user + better diagnose the problem. */ + char *dwp_text = NULL; + struct cleanup *cleanups; + + if (dwp_file != NULL) + dwp_text = xstrprintf (" [in DWP file %s]", lbasename (dwp_file->name)); + cleanups = make_cleanup (xfree, dwp_text); + + warning (_("Could not find DWO %s %s(%s)%s referenced by %s at offset 0x%x" + " [in module %s]"), + kind, dwo_name, hex_string (signature), + dwp_text != NULL ? dwp_text : "", + this_unit->is_debug_types ? "TU" : "CU", + this_unit->offset.sect_off, objfile_name (objfile)); + + do_cleanups (cleanups); + } return NULL; } @@ -10070,8 +11111,12 @@ inherit_abstract_dies (struct die_info *die, struct dwarf2_cu *cu) if (offsetp >= offsets_end || offsetp->sect_off > origin_child_die->offset.sect_off) { - /* Found that ORIGIN_CHILD_DIE is really not referenced. */ - process_die (origin_child_die, origin_cu); + /* Found that ORIGIN_CHILD_DIE is really not referenced. + Check whether we're already processing ORIGIN_CHILD_DIE. + This can happen with mutually referenced abstract_origins. + PR 16581. */ + if (!origin_child_die->in_process) + process_die (origin_child_die, origin_cu); } origin_child_die = sibling_die (origin_child_die); } @@ -10333,10 +11378,10 @@ read_call_site_scope (struct die_info *die, struct dwarf2_cu *cu) complaint (&symfile_complaints, _("missing DW_AT_low_pc for DW_TAG_GNU_call_site " "DIE 0x%x [in module %s]"), - die->offset.sect_off, objfile->name); + die->offset.sect_off, objfile_name (objfile)); return; } - pc = DW_ADDR (attr) + baseaddr; + pc = attr_value_as_address (attr) + baseaddr; if (cu->call_site_htab == NULL) cu->call_site_htab = htab_create_alloc_ex (16, core_addr_hash, core_addr_eq, @@ -10349,7 +11394,8 @@ read_call_site_scope (struct die_info *die, struct dwarf2_cu *cu) complaint (&symfile_complaints, _("Duplicate PC %s for DW_TAG_GNU_call_site " "DIE 0x%x [in module %s]"), - paddress (gdbarch, pc), die->offset.sect_off, objfile->name); + paddress (gdbarch, pc), die->offset.sect_off, + objfile_name (objfile)); return; } @@ -10364,7 +11410,8 @@ read_call_site_scope (struct die_info *die, struct dwarf2_cu *cu) complaint (&symfile_complaints, _("Tag %d is not DW_TAG_GNU_call_site_parameter in " "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"), - child_die->tag, child_die->offset.sect_off, objfile->name); + child_die->tag, child_die->offset.sect_off, + objfile_name (objfile)); continue; } @@ -10422,7 +11469,7 @@ read_call_site_scope (struct die_info *die, struct dwarf2_cu *cu) complaint (&symfile_complaints, _("Cannot find function owning DW_TAG_GNU_call_site " "DIE 0x%x [in module %s]"), - die->offset.sect_off, objfile->name); + die->offset.sect_off, objfile_name (objfile)); } } @@ -10468,7 +11515,7 @@ read_call_site_scope (struct die_info *die, struct dwarf2_cu *cu) complaint (&symfile_complaints, _("DW_AT_GNU_call_site_target target DIE has invalid " "physname, for referencing DIE 0x%x [in module %s]"), - die->offset.sect_off, objfile->name); + die->offset.sect_off, objfile_name (objfile)); else SET_FIELD_PHYSNAME (call_site->target, target_physname); } @@ -10481,7 +11528,7 @@ read_call_site_scope (struct die_info *die, struct dwarf2_cu *cu) complaint (&symfile_complaints, _("DW_AT_GNU_call_site_target target DIE has invalid " "low pc, for referencing DIE 0x%x [in module %s]"), - die->offset.sect_off, objfile->name); + die->offset.sect_off, objfile_name (objfile)); else SET_FIELD_PHYSADDR (call_site->target, lowpc + baseaddr); } @@ -10490,7 +11537,7 @@ read_call_site_scope (struct die_info *die, struct dwarf2_cu *cu) complaint (&symfile_complaints, _("DW_TAG_GNU_call_site DW_AT_GNU_call_site_target is neither " "block nor reference, for DIE 0x%x [in module %s]"), - die->offset.sect_off, objfile->name); + die->offset.sect_off, objfile_name (objfile)); call_site->per_cu = cu->per_cu; @@ -10531,7 +11578,7 @@ read_call_site_scope (struct die_info *die, struct dwarf2_cu *cu) _("DW_AT_abstract_origin offset is not in CU for " "DW_TAG_GNU_call_site child DIE 0x%x " "[in module %s]"), - child_die->offset.sect_off, objfile->name); + child_die->offset.sect_off, objfile_name (objfile)); continue; } parameter->u.param_offset.cu_off = (offset.sect_off @@ -10542,7 +11589,7 @@ read_call_site_scope (struct die_info *die, struct dwarf2_cu *cu) complaint (&symfile_complaints, _("No DW_FORM_block* DW_AT_location for " "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"), - child_die->offset.sect_off, objfile->name); + child_die->offset.sect_off, objfile_name (objfile)); continue; } else @@ -10562,7 +11609,7 @@ read_call_site_scope (struct die_info *die, struct dwarf2_cu *cu) "for DW_FORM_block* DW_AT_location is supported for " "DW_TAG_GNU_call_site child DIE 0x%x " "[in module %s]"), - child_die->offset.sect_off, objfile->name); + child_die->offset.sect_off, objfile_name (objfile)); continue; } } @@ -10573,7 +11620,7 @@ read_call_site_scope (struct die_info *die, struct dwarf2_cu *cu) complaint (&symfile_complaints, _("No DW_FORM_block* DW_AT_GNU_call_site_value for " "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"), - child_die->offset.sect_off, objfile->name); + child_die->offset.sect_off, objfile_name (objfile)); continue; } parameter->value = DW_BLOCK (attr)->data; @@ -10591,7 +11638,7 @@ read_call_site_scope (struct die_info *die, struct dwarf2_cu *cu) complaint (&symfile_complaints, _("No DW_FORM_block* DW_AT_GNU_call_site_data_value for " "DW_TAG_GNU_call_site child DIE 0x%x [in module %s]"), - child_die->offset.sect_off, objfile->name); + child_die->offset.sect_off, objfile_name (objfile)); else { parameter->data_value = DW_BLOCK (attr)->data; @@ -10713,7 +11760,7 @@ dwarf2_ranges_read (unsigned offset, CORE_ADDR *low_return, { complaint (&symfile_complaints, _(".debug_ranges entry has start address of zero" - " [in module %s]"), objfile->name); + " [in module %s]"), objfile_name (objfile)); continue; } @@ -10775,12 +11822,10 @@ dwarf2_get_pc_bounds (struct die_info *die, CORE_ADDR *lowpc, attr = dwarf2_attr (die, DW_AT_low_pc, cu); if (attr) { - low = DW_ADDR (attr); - if (attr_high->form == DW_FORM_addr - || attr_high->form == DW_FORM_GNU_addr_index) - high = DW_ADDR (attr_high); - else - high = low + DW_UNSND (attr_high); + low = attr_value_as_address (attr); + high = attr_value_as_address (attr_high); + if (cu->header.version >= 4 && attr_form_is_constant (attr_high)) + high += low; } else /* Found high w/o low attribute. */ @@ -10946,13 +11991,11 @@ dwarf2_record_block_ranges (struct die_info *die, struct block *block, attr = dwarf2_attr (die, DW_AT_low_pc, cu); if (attr) { - CORE_ADDR low = DW_ADDR (attr); - CORE_ADDR high; - if (attr_high->form == DW_FORM_addr - || attr_high->form == DW_FORM_GNU_addr_index) - high = DW_ADDR (attr_high); - else - high = low + DW_UNSND (attr_high); + CORE_ADDR low = attr_value_as_address (attr); + CORE_ADDR high = attr_value_as_address (attr_high); + + if (cu->header.version >= 4 && attr_form_is_constant (attr_high)) + high += low; record_block_range (block, baseaddr + low, baseaddr + high - 1); } @@ -11054,7 +12097,7 @@ dwarf2_record_block_ranges (struct die_info *die, struct block *block, { complaint (&symfile_complaints, _(".debug_ranges entry has start address of zero" - " [in module %s]"), objfile->name); + " [in module %s]"), objfile_name (objfile)); continue; } @@ -11850,19 +12893,14 @@ producer_is_icc (struct dwarf2_cu *cu) /* Called when we find the DIE that starts a structure or union scope (definition) to create a type for the structure or union. Fill in the type's name and general properties; the members will not be - processed until process_structure_scope. + processed until process_structure_scope. A symbol table entry for + the type will also not be done until process_structure_scope (assuming + the type has a name). NOTE: we need to call these functions regardless of whether or not the DIE has a DW_AT_name attribute, since it might be an anonymous structure or union. This gets the type entered into our set of - user defined types. - - However, if the structure is incomplete (an opaque struct/union) - then suppress creating a symbol table entry for it since gdb only - wants to find the one with the complete definition. Note that if - it is complete, we just call new_symbol, which does it's own - checking about whether the struct/union is anonymous or not (and - suppresses creating a symbol table entry itself). */ + user defined types. */ static struct type * read_structure_type (struct die_info *die, struct dwarf2_cu *cu) @@ -11942,10 +12980,11 @@ read_structure_type (struct die_info *die, struct dwarf2_cu *cu) TYPE_LENGTH (type) = 0; } - if (producer_is_icc (cu)) + if (producer_is_icc (cu) && (TYPE_LENGTH (type) == 0)) { /* ICC does not output the required DW_AT_declaration on incomplete types, but gives them a size of zero. */ + TYPE_STUB (type) = 1; } else TYPE_STUB_SUPPORTED (type) = 1; @@ -12181,6 +13220,69 @@ process_structure_scope (struct die_info *die, struct dwarf2_cu *cu) new_symbol (die, type, cu); } +/* Assuming DIE is an enumeration type, and TYPE is its associated type, + update TYPE using some information only available in DIE's children. */ + +static void +update_enumeration_type_from_children (struct die_info *die, + struct type *type, + struct dwarf2_cu *cu) +{ + struct obstack obstack; + struct die_info *child_die = die->child; + int unsigned_enum = 1; + int flag_enum = 1; + ULONGEST mask = 0; + struct cleanup *old_chain; + + obstack_init (&obstack); + old_chain = make_cleanup_obstack_free (&obstack); + + while (child_die != NULL && child_die->tag) + { + struct attribute *attr; + LONGEST value; + const gdb_byte *bytes; + struct dwarf2_locexpr_baton *baton; + const char *name; + if (child_die->tag != DW_TAG_enumerator) + continue; + + attr = dwarf2_attr (child_die, DW_AT_const_value, cu); + if (attr == NULL) + continue; + + name = dwarf2_name (child_die, cu); + if (name == NULL) + name = ""; + + dwarf2_const_value_attr (attr, type, name, &obstack, cu, + &value, &bytes, &baton); + if (value < 0) + { + unsigned_enum = 0; + flag_enum = 0; + } + else if ((mask & value) != 0) + flag_enum = 0; + else + mask |= value; + + /* If we already know that the enum type is neither unsigned, nor + a flag type, no need to look at the rest of the enumerates. */ + if (!unsigned_enum && !flag_enum) + break; + child_die = sibling_die (child_die); + } + + if (unsigned_enum) + TYPE_UNSIGNED (type) = 1; + if (flag_enum) + TYPE_FLAG_ENUM (type) = 1; + + do_cleanups (old_chain); +} + /* Given a DW_AT_enumeration_type die, set its type. We do not complete the type's fields yet, or create any symbols. */ @@ -12212,6 +13314,14 @@ read_enumeration_type (struct die_info *die, struct dwarf2_cu *cu) if (name != NULL) TYPE_TAG_NAME (type) = name; + attr = dwarf2_attr (die, DW_AT_type, cu); + if (attr != NULL) + { + struct type *underlying_type = die_type (die, cu); + + TYPE_TARGET_TYPE (type) = underlying_type; + } + attr = dwarf2_attr (die, DW_AT_byte_size, cu); if (attr) { @@ -12230,6 +13340,27 @@ read_enumeration_type (struct die_info *die, struct dwarf2_cu *cu) if (die_is_declaration (die, cu)) TYPE_STUB (type) = 1; + /* Finish the creation of this type by using the enum's children. + We must call this even when the underlying type has been provided + so that we can determine if we're looking at a "flag" enum. */ + update_enumeration_type_from_children (die, type, cu); + + /* If this type has an underlying type that is not a stub, then we + may use its attributes. We always use the "unsigned" attribute + in this situation, because ordinarily we guess whether the type + is unsigned -- but the guess can be wrong and the underlying type + can tell us the reality. However, we defer to a local size + attribute if one exists, because this lets the compiler override + the underlying type if needed. */ + if (TYPE_TARGET_TYPE (type) != NULL && !TYPE_STUB (TYPE_TARGET_TYPE (type))) + { + TYPE_UNSIGNED (type) = TYPE_UNSIGNED (TYPE_TARGET_TYPE (type)); + if (TYPE_LENGTH (type) == 0) + TYPE_LENGTH (type) = TYPE_LENGTH (TYPE_TARGET_TYPE (type)); + } + + TYPE_DECLARED_CLASS (type) = dwarf2_flag_true_p (die, DW_AT_enum_class, cu); + return set_die_type (die, type, cu); } @@ -12254,10 +13385,7 @@ process_enumeration_scope (struct die_info *die, struct dwarf2_cu *cu) struct symbol *sym; struct field *fields = NULL; int num_fields = 0; - int unsigned_enum = 1; const char *name; - int flag_enum = 1; - ULONGEST mask = 0; child_die = die->child; while (child_die && child_die->tag) @@ -12272,15 +13400,6 @@ process_enumeration_scope (struct die_info *die, struct dwarf2_cu *cu) if (name) { sym = new_symbol (child_die, this_type, cu); - if (SYMBOL_VALUE (sym) < 0) - { - unsigned_enum = 0; - flag_enum = 0; - } - else if ((mask & SYMBOL_VALUE (sym)) != 0) - flag_enum = 0; - else - mask |= SYMBOL_VALUE (sym); if ((num_fields % DW_FIELD_ALLOC_CHUNK) == 0) { @@ -12311,10 +13430,6 @@ process_enumeration_scope (struct die_info *die, struct dwarf2_cu *cu) sizeof (struct field) * num_fields); xfree (fields); } - if (unsigned_enum) - TYPE_UNSIGNED (this_type) = 1; - if (flag_enum) - TYPE_FLAG_ENUM (this_type) = 1; } /* If we are reading an enum from a .debug_types unit, and the enum @@ -12355,6 +13470,7 @@ read_array_type (struct die_info *die, struct dwarf2_cu *cu) int ndim = 0; struct cleanup *back_to; const char *name; + unsigned int bit_stride = 0; element_type = die_type (die, cu); @@ -12363,13 +13479,22 @@ read_array_type (struct die_info *die, struct dwarf2_cu *cu) if (type) return type; + attr = dwarf2_attr (die, DW_AT_byte_stride, cu); + if (attr != NULL) + bit_stride = DW_UNSND (attr) * 8; + + attr = dwarf2_attr (die, DW_AT_bit_stride, cu); + if (attr != NULL) + bit_stride = DW_UNSND (attr); + /* Irix 6.2 native cc creates array types without children for arrays with unspecified length. */ if (die->child == NULL) { index_type = objfile_type (objfile)->builtin_int; - range_type = create_range_type (NULL, index_type, 0, -1); - type = create_array_type (NULL, element_type, range_type); + range_type = create_static_range_type (NULL, index_type, 0, -1); + type = create_array_type_with_stride (NULL, element_type, range_type, + bit_stride); return set_die_type (die, type, cu); } @@ -12409,12 +13534,14 @@ read_array_type (struct die_info *die, struct dwarf2_cu *cu) int i = 0; while (i < ndim) - type = create_array_type (NULL, type, range_types[i++]); + type = create_array_type_with_stride (NULL, type, range_types[i++], + bit_stride); } else { while (ndim-- > 0) - type = create_array_type (NULL, type, range_types[ndim]); + type = create_array_type_with_stride (NULL, type, range_types[ndim], + bit_stride); } /* Understand Dwarf2 support for vector types (like they occur on @@ -12661,7 +13788,8 @@ read_common_block (struct die_info *die, struct dwarf2_cu *cu) _("Variable in common block has " "DW_AT_data_member_location " "- DIE at 0x%x [in module %s]"), - child_die->offset.sect_off, cu->objfile->name); + child_die->offset.sect_off, + objfile_name (cu->objfile)); if (attr_form_is_section_offset (member_loc)) dwarf2_complex_location_expr_complaint (); @@ -12796,6 +13924,10 @@ static void read_module (struct die_info *die, struct dwarf2_cu *cu) { struct die_info *child_die = die->child; + struct type *type; + + type = read_type_die (die, cu); + new_symbol (die, type, cu); while (child_die && child_die->tag) { @@ -12964,6 +14096,36 @@ read_tag_reference_type (struct die_info *die, struct dwarf2_cu *cu) return set_die_type (die, type, cu); } +/* Add the given cv-qualifiers to the element type of the array. GCC + outputs DWARF type qualifiers that apply to an array, not the + element type. But GDB relies on the array element type to carry + the cv-qualifiers. This mimics section 6.7.3 of the C99 + specification. */ + +static struct type * +add_array_cv_type (struct die_info *die, struct dwarf2_cu *cu, + struct type *base_type, int cnst, int voltl) +{ + struct type *el_type, *inner_array; + + base_type = copy_type (base_type); + inner_array = base_type; + + while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array)) == TYPE_CODE_ARRAY) + { + TYPE_TARGET_TYPE (inner_array) = + copy_type (TYPE_TARGET_TYPE (inner_array)); + inner_array = TYPE_TARGET_TYPE (inner_array); + } + + el_type = TYPE_TARGET_TYPE (inner_array); + cnst |= TYPE_CONST (el_type); + voltl |= TYPE_VOLATILE (el_type); + TYPE_TARGET_TYPE (inner_array) = make_cv_type (cnst, voltl, el_type, NULL); + + return set_die_type (die, base_type, cu); +} + static struct type * read_tag_const_type (struct die_info *die, struct dwarf2_cu *cu) { @@ -12979,25 +14141,7 @@ read_tag_const_type (struct die_info *die, struct dwarf2_cu *cu) /* In case the const qualifier is applied to an array type, the element type is so qualified, not the array type (section 6.7.3 of C99). */ if (TYPE_CODE (base_type) == TYPE_CODE_ARRAY) - { - struct type *el_type, *inner_array; - - base_type = copy_type (base_type); - inner_array = base_type; - - while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array)) == TYPE_CODE_ARRAY) - { - TYPE_TARGET_TYPE (inner_array) = - copy_type (TYPE_TARGET_TYPE (inner_array)); - inner_array = TYPE_TARGET_TYPE (inner_array); - } - - el_type = TYPE_TARGET_TYPE (inner_array); - TYPE_TARGET_TYPE (inner_array) = - make_cv_type (1, TYPE_VOLATILE (el_type), el_type, NULL); - - return set_die_type (die, base_type, cu); - } + return add_array_cv_type (die, cu, base_type, 1, 0); cv_type = make_cv_type (1, TYPE_VOLATILE (base_type), base_type, 0); return set_die_type (die, cv_type, cu); @@ -13015,6 +14159,12 @@ read_tag_volatile_type (struct die_info *die, struct dwarf2_cu *cu) if (cv_type) return cv_type; + /* In case the volatile qualifier is applied to an array type, the + element type is so qualified, not the array type (section 6.7.3 + of C99). */ + if (TYPE_CODE (base_type) == TYPE_CODE_ARRAY) + return add_array_cv_type (die, cu, base_type, 0, 1); + cv_type = make_cv_type (TYPE_CONST (base_type), 1, base_type, 0); return set_die_type (die, cv_type, cu); } @@ -13071,7 +14221,7 @@ read_tag_string_type (struct die_info *die, struct dwarf2_cu *cu) } index_type = objfile_type (objfile)->builtin_int; - range_type = create_range_type (NULL, index_type, 1, length); + range_type = create_static_range_type (NULL, index_type, 1, length); char_type = language_string_char_type (cu->language_defn, gdbarch); type = create_string_type (NULL, char_type, range_type); @@ -13285,7 +14435,7 @@ read_typedef (struct die_info *die, struct dwarf2_cu *cu) complaint (&symfile_complaints, _("Self-referential DW_TAG_typedef " "- DIE at 0x%x [in module %s]"), - die->offset.sect_off, objfile->name); + die->offset.sect_off, objfile_name (objfile)); TYPE_TARGET_TYPE (this_type) = NULL; } return this_type; @@ -13388,6 +14538,84 @@ read_base_type (struct die_info *die, struct dwarf2_cu *cu) return set_die_type (die, type, cu); } +/* Parse dwarf attribute if it's a block, reference or constant and put the + resulting value of the attribute into struct bound_prop. + Returns 1 if ATTR could be resolved into PROP, 0 otherwise. */ + +static int +attr_to_dynamic_prop (const struct attribute *attr, struct die_info *die, + struct dwarf2_cu *cu, struct dynamic_prop *prop) +{ + struct dwarf2_property_baton *baton; + struct obstack *obstack = &cu->objfile->objfile_obstack; + + if (attr == NULL || prop == NULL) + return 0; + + if (attr_form_is_block (attr)) + { + baton = obstack_alloc (obstack, sizeof (*baton)); + baton->referenced_type = NULL; + baton->locexpr.per_cu = cu->per_cu; + baton->locexpr.size = DW_BLOCK (attr)->size; + baton->locexpr.data = DW_BLOCK (attr)->data; + prop->data.baton = baton; + prop->kind = PROP_LOCEXPR; + gdb_assert (prop->data.baton != NULL); + } + else if (attr_form_is_ref (attr)) + { + struct dwarf2_cu *target_cu = cu; + struct die_info *target_die; + struct attribute *target_attr; + + target_die = follow_die_ref (die, attr, &target_cu); + target_attr = dwarf2_attr (target_die, DW_AT_location, target_cu); + if (target_attr == NULL) + return 0; + + if (attr_form_is_section_offset (target_attr)) + { + baton = obstack_alloc (obstack, sizeof (*baton)); + baton->referenced_type = die_type (target_die, target_cu); + fill_in_loclist_baton (cu, &baton->loclist, target_attr); + prop->data.baton = baton; + prop->kind = PROP_LOCLIST; + gdb_assert (prop->data.baton != NULL); + } + else if (attr_form_is_block (target_attr)) + { + baton = obstack_alloc (obstack, sizeof (*baton)); + baton->referenced_type = die_type (target_die, target_cu); + baton->locexpr.per_cu = cu->per_cu; + baton->locexpr.size = DW_BLOCK (target_attr)->size; + baton->locexpr.data = DW_BLOCK (target_attr)->data; + prop->data.baton = baton; + prop->kind = PROP_LOCEXPR; + gdb_assert (prop->data.baton != NULL); + } + else + { + dwarf2_invalid_attrib_class_complaint ("DW_AT_location", + "dynamic property"); + return 0; + } + } + else if (attr_form_is_constant (attr)) + { + prop->data.const_val = dwarf2_get_attr_constant_value (attr, 0); + prop->kind = PROP_CONST; + } + else + { + dwarf2_invalid_attrib_class_complaint (dwarf_form_name (attr->form), + dwarf2_name (die, cu)); + return 0; + } + + return 1; +} + /* Read the given DW_AT_subrange DIE. */ static struct type * @@ -13396,8 +14624,9 @@ read_subrange_type (struct die_info *die, struct dwarf2_cu *cu) struct type *base_type, *orig_base_type; struct type *range_type; struct attribute *attr; - LONGEST low, high; + struct dynamic_prop low, high; int low_default_is_valid; + int high_bound_is_count = 0; const char *name; LONGEST negative_mask; @@ -13413,81 +14642,60 @@ read_subrange_type (struct die_info *die, struct dwarf2_cu *cu) if (range_type) return range_type; + low.kind = PROP_CONST; + high.kind = PROP_CONST; + high.data.const_val = 0; + /* Set LOW_DEFAULT_IS_VALID if current language and DWARF version allow omitting DW_AT_lower_bound. */ switch (cu->language) { case language_c: case language_cplus: - low = 0; + low.data.const_val = 0; low_default_is_valid = 1; break; case language_fortran: - low = 1; + low.data.const_val = 1; low_default_is_valid = 1; break; case language_d: case language_java: case language_objc: - low = 0; + low.data.const_val = 0; low_default_is_valid = (cu->header.version >= 4); break; case language_ada: case language_m2: case language_pascal: - low = 1; + low.data.const_val = 1; low_default_is_valid = (cu->header.version >= 4); break; default: - low = 0; + low.data.const_val = 0; low_default_is_valid = 0; break; } - /* FIXME: For variable sized arrays either of these could be - a variable rather than a constant value. We'll allow it, - but we don't know how to handle it. */ attr = dwarf2_attr (die, DW_AT_lower_bound, cu); if (attr) - low = dwarf2_get_attr_constant_value (attr, low); + attr_to_dynamic_prop (attr, die, cu, &low); else if (!low_default_is_valid) complaint (&symfile_complaints, _("Missing DW_AT_lower_bound " "- DIE at 0x%x [in module %s]"), - die->offset.sect_off, cu->objfile->name); + die->offset.sect_off, objfile_name (cu->objfile)); attr = dwarf2_attr (die, DW_AT_upper_bound, cu); - if (attr) - { - if (attr_form_is_block (attr) || attr_form_is_ref (attr)) - { - /* GCC encodes arrays with unspecified or dynamic length - with a DW_FORM_block1 attribute or a reference attribute. - FIXME: GDB does not yet know how to handle dynamic - arrays properly, treat them as arrays with unspecified - length for now. - - FIXME: jimb/2003-09-22: GDB does not really know - how to handle arrays of unspecified length - either; we just represent them as zero-length - arrays. Choose an appropriate upper bound given - the lower bound we've computed above. */ - high = low - 1; - } - else - high = dwarf2_get_attr_constant_value (attr, 1); - } - else + if (!attr_to_dynamic_prop (attr, die, cu, &high)) { attr = dwarf2_attr (die, DW_AT_count, cu); - if (attr) - { - int count = dwarf2_get_attr_constant_value (attr, 1); - high = low + count - 1; - } - else + if (attr_to_dynamic_prop (attr, die, cu, &high)) { - /* Unspecified array length. */ - high = low - 1; + /* If bounds are constant do the final calculation here. */ + if (low.kind == PROP_CONST && high.kind == PROP_CONST) + high.data.const_val = low.data.const_val + high.data.const_val - 1; + else + high_bound_is_count = 1; } } @@ -13529,24 +14737,30 @@ read_subrange_type (struct die_info *die, struct dwarf2_cu *cu) } } + /* Normally, the DWARF producers are expected to use a signed + constant form (Eg. DW_FORM_sdata) to express negative bounds. + But this is unfortunately not always the case, as witnessed + with GCC, for instance, where the ambiguous DW_FORM_dataN form + is used instead. To work around that ambiguity, we treat + the bounds as signed, and thus sign-extend their values, when + the base type is signed. */ negative_mask = (LONGEST) -1 << (TYPE_LENGTH (base_type) * TARGET_CHAR_BIT - 1); - if (!TYPE_UNSIGNED (base_type) && (low & negative_mask)) - low |= negative_mask; - if (!TYPE_UNSIGNED (base_type) && (high & negative_mask)) - high |= negative_mask; + if (low.kind == PROP_CONST + && !TYPE_UNSIGNED (base_type) && (low.data.const_val & negative_mask)) + low.data.const_val |= negative_mask; + if (high.kind == PROP_CONST + && !TYPE_UNSIGNED (base_type) && (high.data.const_val & negative_mask)) + high.data.const_val |= negative_mask; - range_type = create_range_type (NULL, orig_base_type, low, high); + range_type = create_range_type (NULL, orig_base_type, &low, &high); - /* Mark arrays with dynamic length at least as an array of unspecified - length. GDB could check the boundary but before it gets implemented at - least allow accessing the array elements. */ - if (attr && attr_form_is_block (attr)) - TYPE_HIGH_BOUND_UNDEFINED (range_type) = 1; + if (high_bound_is_count) + TYPE_RANGE_DATA (range_type)->flag_upper_bound_is_count = 1; /* Ada expects an empty array on no boundary attributes. */ if (attr == NULL && cu->language != language_ada) - TYPE_HIGH_BOUND_UNDEFINED (range_type) = 1; + TYPE_HIGH_BOUND_KIND (range_type) = PROP_UNDEFINED; name = dwarf2_name (die, cu); if (name) @@ -13668,8 +14882,7 @@ read_die_and_siblings (const struct die_reader_specs *reader, { fprintf_unfiltered (gdb_stdlog, "Read die from %s@0x%x of %s:\n", - bfd_section_name (reader->abfd, - reader->die_section->asection), + get_section_name (reader->die_section), (unsigned) (info_ptr - reader->die_section->buffer), bfd_get_filename (reader->abfd)); dump_die (die, dwarf2_die_debug); @@ -13751,8 +14964,7 @@ read_full_die (const struct die_reader_specs *reader, { fprintf_unfiltered (gdb_stdlog, "Read die from %s@0x%x of %s:\n", - bfd_section_name (reader->abfd, - reader->die_section->asection), + get_section_name (reader->die_section), (unsigned) (info_ptr - reader->die_section->buffer), bfd_get_filename (reader->abfd)); dump_die (*diep, dwarf2_die_debug); @@ -13824,7 +15036,7 @@ abbrev_table_read_table (struct dwarf2_section_info *section, sect_offset offset) { struct objfile *objfile = dwarf2_per_objfile->objfile; - bfd *abfd = section->asection->owner; + bfd *abfd = get_section_bfd_owner (section); struct abbrev_table *abbrev_table; const gdb_byte *abbrev_ptr; struct abbrev_info *cur_abbrev; @@ -13833,7 +15045,7 @@ abbrev_table_read_table (struct dwarf2_section_info *section, struct attr_abbrev *cur_attrs; unsigned int allocated_attrs; - abbrev_table = XMALLOC (struct abbrev_table); + abbrev_table = XNEW (struct abbrev_table); abbrev_table->offset = offset; obstack_init (&abbrev_table->abbrev_obstack); abbrev_table->abbrevs = obstack_alloc (&abbrev_table->abbrev_obstack, @@ -13924,7 +15136,7 @@ abbrev_table_free (struct abbrev_table *abbrev_table) /* Same as abbrev_table_free but as a cleanup. We pass in a pointer to the pointer to the table so that we can set the pointer to NULL when we're done. It also simplifies - build_type_unit_groups. */ + build_type_psymtabs_1. */ static void abbrev_table_free_cleanup (void *table_ptr) @@ -14091,7 +15303,8 @@ load_partial_dies (const struct die_reader_specs *reader, && abbrev->tag != DW_TAG_namespace && abbrev->tag != DW_TAG_module && abbrev->tag != DW_TAG_member - && abbrev->tag != DW_TAG_imported_unit) + && abbrev->tag != DW_TAG_imported_unit + && abbrev->tag != DW_TAG_imported_declaration) { /* Otherwise we skip to the next sibling, if any. */ info_ptr = skip_one_die (reader, info_ptr + bytes_read, abbrev); @@ -14145,7 +15358,7 @@ load_partial_dies (const struct die_reader_specs *reader, complaint (&symfile_complaints, _("DW_TAG_typedef has childen - GCC PR debug/47510 bug " "- DIE at 0x%x [in module %s]"), - part_die->offset.sect_off, objfile->name); + part_die->offset.sect_off, objfile_name (objfile)); /* If we're at the second level, and we're an enumerator, and our parent has no specification (meaning possibly lives in a @@ -14322,7 +15535,7 @@ read_partial_die (const struct die_reader_specs *reader, default: part_die->name = dwarf2_canonicalize_name (DW_STRING (&attr), cu, - &objfile->objfile_obstack); + &objfile->per_bfd->storage_obstack); break; } break; @@ -14337,18 +15550,13 @@ read_partial_die (const struct die_reader_specs *reader, break; case DW_AT_low_pc: has_low_pc_attr = 1; - part_die->lowpc = DW_ADDR (&attr); + part_die->lowpc = attr_value_as_address (&attr); break; case DW_AT_high_pc: has_high_pc_attr = 1; - if (attr.form == DW_FORM_addr - || attr.form == DW_FORM_GNU_addr_index) - part_die->highpc = DW_ADDR (&attr); - else - { - high_pc_relative = 1; - part_die->highpc = DW_UNSND (&attr); - } + part_die->highpc = attr_value_as_address (&attr); + if (cu->header.version >= 4 && attr_form_is_constant (&attr)) + high_pc_relative = 1; break; case DW_AT_location: /* Support the .debug_loc offsets. */ @@ -14390,7 +15598,18 @@ read_partial_die (const struct die_reader_specs *reader, complaint (&symfile_complaints, _("ignoring absolute DW_AT_sibling")); else - part_die->sibling = buffer + dwarf2_get_ref_die_offset (&attr).sect_off; + { + unsigned int off = dwarf2_get_ref_die_offset (&attr).sect_off; + const gdb_byte *sibling_ptr = buffer + off; + + if (sibling_ptr < info_ptr) + complaint (&symfile_complaints, + _("DW_AT_sibling points backwards")); + else if (sibling_ptr > reader->buffer_end) + dwarf2_section_buffer_overflow_complaint (reader->die_section); + else + part_die->sibling = sibling_ptr; + } break; case DW_AT_byte_size: part_die->has_byte_size = 1; @@ -14412,13 +15631,7 @@ read_partial_die (const struct die_reader_specs *reader, practice. */ if (DW_UNSND (&attr) == DW_CC_program && cu->language == language_fortran) - { - set_main_name (part_die->name); - - /* As this DIE has a static linkage the name would be difficult - to look up later. */ - language_of_main = language_fortran; - } + set_objfile_main_name (objfile, part_die->name, language_fortran); break; case DW_AT_inline: if (DW_UNSND (&attr) == DW_INL_inlined @@ -14461,7 +15674,7 @@ read_partial_die (const struct die_reader_specs *reader, _("DW_AT_low_pc %s is zero " "for DIE at 0x%x [in module %s]"), paddress (gdbarch, part_die->lowpc), - part_die->offset.sect_off, objfile->name); + part_die->offset.sect_off, objfile_name (objfile)); } /* dwarf2_get_pc_bounds has also the strict low < high requirement. */ else if (part_die->lowpc >= part_die->highpc) @@ -14473,7 +15686,7 @@ read_partial_die (const struct die_reader_specs *reader, "for DIE at 0x%x [in module %s]"), paddress (gdbarch, part_die->lowpc), paddress (gdbarch, part_die->highpc), - part_die->offset.sect_off, objfile->name); + part_die->offset.sect_off, objfile_name (objfile)); } else part_die->has_pc_info = 1; @@ -14607,7 +15820,7 @@ guess_partial_die_structure_name (struct partial_die_info *struct_pdi, if (actual_class_name != NULL) { struct_pdi->name - = obstack_copy0 (&cu->objfile->objfile_obstack, + = obstack_copy0 (&cu->objfile->per_bfd->storage_obstack, actual_class_name, strlen (actual_class_name)); xfree (actual_class_name); @@ -14693,8 +15906,9 @@ fixup_partial_die (struct partial_die_info *part_die, else base = demangled; - part_die->name = obstack_copy0 (&cu->objfile->objfile_obstack, - base, strlen (base)); + part_die->name + = obstack_copy0 (&cu->objfile->per_bfd->storage_obstack, + base, strlen (base)); xfree (demangled); } } @@ -14887,7 +16101,7 @@ read_attribute_value (const struct die_reader_specs *reader, ULONGEST str_index = read_unsigned_leb128 (abfd, info_ptr, &bytes_read); - DW_STRING (attr) = read_str_index (reader, cu, str_index); + DW_STRING (attr) = read_str_index (reader, str_index); DW_STRING_IS_CANONICAL (attr) = 0; info_ptr += bytes_read; } @@ -15307,11 +16521,11 @@ read_addr_index_1 (unsigned int addr_index, ULONGEST addr_base, int addr_size) dwarf2_read_section (objfile, &dwarf2_per_objfile->addr); if (dwarf2_per_objfile->addr.buffer == NULL) error (_("DW_FORM_addr_index used without .debug_addr section [in module %s]"), - objfile->name); + objfile_name (objfile)); if (addr_base + addr_index * addr_size >= dwarf2_per_objfile->addr.size) error (_("DW_FORM_addr_index pointing outside of " ".debug_addr section [in module %s]"), - objfile->name); + objfile_name (objfile)); info_ptr = (dwarf2_per_objfile->addr.buffer + addr_base + addr_index * addr_size); if (addr_size == 4) @@ -15419,44 +16633,48 @@ dwarf2_read_addr_index (struct dwarf2_per_cu_data *per_cu, return read_addr_index_1 (addr_index, addr_base, addr_size); } -/* Given a DW_AT_str_index, fetch the string. */ +/* Given a DW_FORM_GNU_str_index, fetch the string. + This is only used by the Fission support. */ static const char * -read_str_index (const struct die_reader_specs *reader, - struct dwarf2_cu *cu, ULONGEST str_index) +read_str_index (const struct die_reader_specs *reader, ULONGEST str_index) { struct objfile *objfile = dwarf2_per_objfile->objfile; - const char *dwo_name = objfile->name; + const char *objf_name = objfile_name (objfile); bfd *abfd = objfile->obfd; - struct dwo_sections *sections = &reader->dwo_file->sections; + struct dwarf2_cu *cu = reader->cu; + struct dwarf2_section_info *str_section = &reader->dwo_file->sections.str; + struct dwarf2_section_info *str_offsets_section = + &reader->dwo_file->sections.str_offsets; const gdb_byte *info_ptr; ULONGEST str_offset; + static const char form_name[] = "DW_FORM_GNU_str_index"; - dwarf2_read_section (objfile, §ions->str); - dwarf2_read_section (objfile, §ions->str_offsets); - if (sections->str.buffer == NULL) - error (_("DW_FORM_str_index used without .debug_str.dwo section" + dwarf2_read_section (objfile, str_section); + dwarf2_read_section (objfile, str_offsets_section); + if (str_section->buffer == NULL) + error (_("%s used without .debug_str.dwo section" " in CU at offset 0x%lx [in module %s]"), - (long) cu->header.offset.sect_off, dwo_name); - if (sections->str_offsets.buffer == NULL) - error (_("DW_FORM_str_index used without .debug_str_offsets.dwo section" + form_name, (long) cu->header.offset.sect_off, objf_name); + if (str_offsets_section->buffer == NULL) + error (_("%s used without .debug_str_offsets.dwo section" " in CU at offset 0x%lx [in module %s]"), - (long) cu->header.offset.sect_off, dwo_name); - if (str_index * cu->header.offset_size >= sections->str_offsets.size) - error (_("DW_FORM_str_index pointing outside of .debug_str_offsets.dwo" + form_name, (long) cu->header.offset.sect_off, objf_name); + if (str_index * cu->header.offset_size >= str_offsets_section->size) + error (_("%s pointing outside of .debug_str_offsets.dwo" " section in CU at offset 0x%lx [in module %s]"), - (long) cu->header.offset.sect_off, dwo_name); - info_ptr = (sections->str_offsets.buffer + form_name, (long) cu->header.offset.sect_off, objf_name); + info_ptr = (str_offsets_section->buffer + str_index * cu->header.offset_size); if (cu->header.offset_size == 4) str_offset = bfd_get_32 (abfd, info_ptr); else str_offset = bfd_get_64 (abfd, info_ptr); - if (str_offset >= sections->str.size) - error (_("Offset from DW_FORM_str_index pointing outside of" + if (str_offset >= str_section->size) + error (_("Offset from %s pointing outside of" " .debug_str.dwo section in CU at offset 0x%lx [in module %s]"), - (long) cu->header.offset.sect_off, dwo_name); - return (const char *) (sections->str.buffer + str_offset); + form_name, (long) cu->header.offset.sect_off, objf_name); + return (const char *) (str_section->buffer + str_offset); } /* Return the length of an LEB128 number in BUF. */ @@ -15758,7 +16976,7 @@ dwarf_decode_line_header (unsigned int offset, struct dwarf2_cu *cu) /* We can't do this until we know the section is non-empty. Only then do we know we have such a section. */ - abfd = section->asection->owner; + abfd = get_section_bfd_owner (section); /* Make sure that at least there's room for the total_length field. That could be 12 bytes long, but we're just going to fudge that. */ @@ -15959,7 +17177,7 @@ noop_record_line (struct subfile *subfile, int line, CORE_ADDR pc) static void dwarf_decode_lines_1 (struct line_header *lh, const char *comp_dir, - struct dwarf2_cu *cu, struct partial_symtab *pst) + struct dwarf2_cu *cu, const int decode_for_pst_p) { const gdb_byte *line_ptr, *extended_end; const gdb_byte *line_end; @@ -15969,7 +17187,6 @@ dwarf_decode_lines_1 (struct line_header *lh, const char *comp_dir, struct objfile *objfile = cu->objfile; bfd *abfd = objfile->obfd; struct gdbarch *gdbarch = get_objfile_arch (objfile); - const int decode_for_pst_p = (pst != NULL); struct subfile *last_subfile = NULL; void (*p_record_line) (struct subfile *subfile, int line, CORE_ADDR pc) = record_line; @@ -15986,9 +17203,7 @@ dwarf_decode_lines_1 (struct line_header *lh, const char *comp_dir, CORE_ADDR address = 0; unsigned int file = 1; unsigned int line = 1; - unsigned int column = 0; int is_stmt = lh->default_is_stmt; - int basic_block = 0; int end_sequence = 0; CORE_ADDR addr; unsigned char op_index = 0; @@ -16021,7 +17236,8 @@ dwarf_decode_lines_1 (struct line_header *lh, const char *comp_dir, if (op_code >= lh->opcode_base) { - /* Special operand. */ + /* Special opcode. */ + adj_opcode = op_code - lh->opcode_base; address += (((op_index + (adj_opcode / lh->line_range)) / lh->maximum_ops_per_instruction) @@ -16050,7 +17266,6 @@ dwarf_decode_lines_1 (struct line_header *lh, const char *comp_dir, (*p_record_line) (current_subfile, line, addr); } } - basic_block = 0; } else switch (op_code) { @@ -16081,7 +17296,7 @@ dwarf_decode_lines_1 (struct line_header *lh, const char *comp_dir, complaint (&symfile_complaints, _(".debug_line address at offset 0x%lx is 0 " "[in module %s]"), - line_offset, objfile->name); + line_offset, objfile_name (objfile)); p_record_line = noop_record_line; } @@ -16148,7 +17363,6 @@ dwarf_decode_lines_1 (struct line_header *lh, const char *comp_dir, (*p_record_line) (current_subfile, line, addr); } } - basic_block = 0; break; case DW_LNS_advance_pc: { @@ -16193,14 +17407,13 @@ dwarf_decode_lines_1 (struct line_header *lh, const char *comp_dir, } break; case DW_LNS_set_column: - column = read_unsigned_leb128 (abfd, line_ptr, &bytes_read); + (void) read_unsigned_leb128 (abfd, line_ptr, &bytes_read); line_ptr += bytes_read; break; case DW_LNS_negate_stmt: is_stmt = (!is_stmt); break; case DW_LNS_set_basic_block: - basic_block = 1; break; /* Add to the address register of the state machine the address increment value corresponding to special opcode @@ -16282,7 +17495,7 @@ dwarf_decode_lines (struct line_header *lh, const char *comp_dir, struct subfile *first_subfile = current_subfile; if (want_line_info) - dwarf_decode_lines_1 (lh, comp_dir, cu, pst); + dwarf_decode_lines_1 (lh, comp_dir, cu, decode_for_pst_p); if (decode_for_pst_p) { @@ -16554,9 +17767,8 @@ new_symbol_full (struct die_info *die, struct type *type, struct dwarf2_cu *cu, case DW_TAG_label: attr = dwarf2_attr (die, DW_AT_low_pc, cu); if (attr) - { - SYMBOL_VALUE_ADDRESS (sym) = DW_ADDR (attr) + baseaddr; - } + SYMBOL_VALUE_ADDRESS (sym) + = attr_value_as_address (attr) + baseaddr; SYMBOL_TYPE (sym) = objfile_type (objfile)->builtin_core_addr; SYMBOL_DOMAIN (sym) = LABEL_DOMAIN; SYMBOL_ACLASS_INDEX (sym) = LOC_LABEL; @@ -16809,10 +18021,16 @@ new_symbol_full (struct die_info *die, struct type *type, struct dwarf2_cu *cu, ? &global_symbols : cu->list_in_scope); } break; + case DW_TAG_imported_declaration: case DW_TAG_namespace: SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF; list_to_add = &global_symbols; break; + case DW_TAG_module: + SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF; + SYMBOL_DOMAIN (sym) = MODULE_DOMAIN; + list_to_add = &global_symbols; + break; case DW_TAG_common_block: SYMBOL_ACLASS_INDEX (sym) = LOC_COMMON_BLOCK; SYMBOL_DOMAIN (sym) = COMMON_BLOCK_DOMAIN; @@ -17108,7 +18326,7 @@ die_containing_type (struct die_info *die, struct dwarf2_cu *cu) type_attr = dwarf2_attr (die, DW_AT_containing_type, cu); if (!type_attr) error (_("Dwarf Error: Problem turning containing type into gdb type " - "[in module %s]"), cu->objfile->name); + "[in module %s]"), objfile_name (cu->objfile)); return lookup_die_type (die, type_attr, cu); } @@ -17122,7 +18340,7 @@ build_error_marker_type (struct dwarf2_cu *cu, struct die_info *die) char *message, *saved; message = xstrprintf (_(""), - objfile->name, + objfile_name (objfile), cu->header.offset.sect_off, die->offset.sect_off); saved = obstack_copy0 (&objfile->objfile_obstack, @@ -17176,7 +18394,7 @@ lookup_die_type (struct die_info *die, const struct attribute *attr, _("Dwarf Error: Bad type attribute %s in DIE" " at 0x%x [in module %s]"), dwarf_attr_name (attr->name), die->offset.sect_off, - objfile->name); + objfile_name (objfile)); return build_error_marker_type (cu, die); } @@ -17362,7 +18580,7 @@ guess_full_die_structure_name (struct die_info *die, struct dwarf2_cu *cu) && actual_name[actual_name_len - die_name_len - 1] == ':') name = - obstack_copy0 (&cu->objfile->objfile_obstack, + obstack_copy0 (&cu->objfile->per_bfd->storage_obstack, actual_name, actual_name_len - die_name_len - 2); } @@ -17408,7 +18626,7 @@ anonymous_struct_prefix (struct die_info *die, struct dwarf2_cu *cu) if (base == NULL || base == DW_STRING (attr) || base[-1] != ':') return ""; - return obstack_copy0 (&cu->objfile->objfile_obstack, + return obstack_copy0 (&cu->objfile->per_bfd->storage_obstack, DW_STRING (attr), &base[-1] - DW_STRING (attr)); } @@ -17558,6 +18776,15 @@ determine_prefix (struct die_info *die, struct dwarf2_cu *cu) return name; } return ""; + case DW_TAG_enumeration_type: + parent_type = read_type_die (parent, cu); + if (TYPE_DECLARED_CLASS (parent_type)) + { + if (TYPE_TAG_NAME (parent_type) != NULL) + return TYPE_TAG_NAME (parent_type); + return ""; + } + /* Fall through. */ default: return determine_prefix (parent, cu); } @@ -17739,8 +18966,9 @@ dwarf2_name (struct die_info *die, struct dwarf2_cu *cu) char *base; /* FIXME: we already did this for the partial symbol... */ - DW_STRING (attr) = obstack_copy0 (&cu->objfile->objfile_obstack, - demangled, strlen (demangled)); + DW_STRING (attr) + = obstack_copy0 (&cu->objfile->per_bfd->storage_obstack, + demangled, strlen (demangled)); DW_STRING_IS_CANONICAL (attr) = 1; xfree (demangled); @@ -17763,7 +18991,7 @@ dwarf2_name (struct die_info *die, struct dwarf2_cu *cu) { DW_STRING (attr) = dwarf2_canonicalize_name (DW_STRING (attr), cu, - &cu->objfile->objfile_obstack); + &cu->objfile->per_bfd->storage_obstack); DW_STRING_IS_CANONICAL (attr) = 1; } return DW_STRING (attr); @@ -18089,7 +19317,7 @@ follow_die_ref_or_sig (struct die_info *src_die, const struct attribute *attr, { dump_die_for_error (src_die); error (_("Dwarf Error: Expected reference attribute [in module %s]"), - (*ref_cu)->objfile->name); + objfile_name ((*ref_cu)->objfile)); } return die; @@ -18164,7 +19392,8 @@ follow_die_ref (struct die_info *src_die, const struct attribute *attr, if (!die) error (_("Dwarf Error: Cannot find DIE at 0x%x referenced from DIE " "at 0x%x [in module %s]"), - offset.sect_off, src_die->offset.sect_off, cu->objfile->name); + offset.sect_off, src_die->offset.sect_off, + objfile_name (cu->objfile)); return die; } @@ -18193,7 +19422,7 @@ dwarf2_fetch_die_loc_sect_off (sect_offset offset, die = follow_die_offset (offset, per_cu->is_dwz, &cu); if (!die) error (_("Dwarf Error: Cannot find DIE at 0x%x referenced in module %s"), - offset.sect_off, per_cu->objfile->name); + offset.sect_off, objfile_name (per_cu->objfile)); attr = dwarf2_attr (die, DW_AT_location, cu); if (!attr) @@ -18221,7 +19450,7 @@ dwarf2_fetch_die_loc_sect_off (sect_offset offset, if (!attr_form_is_block (attr)) error (_("Dwarf Error: DIE at 0x%x referenced in module %s " "is neither DW_FORM_block* nor DW_FORM_exprloc"), - offset.sect_off, per_cu->objfile->name); + offset.sect_off, objfile_name (per_cu->objfile)); retval.data = DW_BLOCK (attr)->data; retval.size = DW_BLOCK (attr)->size; @@ -18294,7 +19523,7 @@ dwarf2_fetch_constant_bytes (sect_offset offset, die = follow_die_offset (offset, per_cu->is_dwz, &cu); if (!die) error (_("Dwarf Error: Cannot find DIE at 0x%x referenced in module %s"), - offset.sect_off, per_cu->objfile->name); + offset.sect_off, objfile_name (per_cu->objfile)); attr = dwarf2_attr (die, DW_AT_const_value, cu); @@ -18478,7 +19707,7 @@ follow_die_sig (struct die_info *src_die, const struct attribute *attr, error (_("Dwarf Error: Cannot find signatured DIE %s referenced" " from DIE at 0x%x [in module %s]"), hex_string (signature), src_die->offset.sect_off, - (*ref_cu)->objfile->name); + objfile_name ((*ref_cu)->objfile)); } die = follow_die_sig_1 (src_die, sig_type, ref_cu); @@ -18488,7 +19717,7 @@ follow_die_sig (struct die_info *src_die, const struct attribute *attr, error (_("Dwarf Error: Problem reading signatured DIE %s referenced" " from DIE at 0x%x [in module %s]"), hex_string (signature), src_die->offset.sect_off, - (*ref_cu)->objfile->name); + objfile_name ((*ref_cu)->objfile)); } return die; @@ -18515,7 +19744,7 @@ get_signatured_type (struct die_info *die, ULONGEST signature, _("Dwarf Error: Cannot find signatured DIE %s referenced" " from DIE at 0x%x [in module %s]"), hex_string (signature), die->offset.sect_off, - dwarf2_per_objfile->objfile->name); + objfile_name (dwarf2_per_objfile->objfile)); return build_error_marker_type (cu, die); } @@ -18537,7 +19766,7 @@ get_signatured_type (struct die_info *die, ULONGEST signature, _("Dwarf Error: Cannot build signatured type %s" " referenced from DIE at 0x%x [in module %s]"), hex_string (signature), die->offset.sect_off, - dwarf2_per_objfile->objfile->name); + objfile_name (dwarf2_per_objfile->objfile)); type = build_error_marker_type (cu, die); } } @@ -18547,7 +19776,7 @@ get_signatured_type (struct die_info *die, ULONGEST signature, _("Dwarf Error: Problem reading signatured DIE %s referenced" " from DIE at 0x%x [in module %s]"), hex_string (signature), die->offset.sect_off, - dwarf2_per_objfile->objfile->name); + objfile_name (dwarf2_per_objfile->objfile)); type = build_error_marker_type (cu, die); } sig_type->type = type; @@ -18580,7 +19809,7 @@ get_DW_AT_signature_type (struct die_info *die, const struct attribute *attr, _("Dwarf Error: DW_AT_signature has bad form %s in DIE" " at 0x%x [in module %s]"), dwarf_form_name (attr->form), die->offset.sect_off, - dwarf2_per_objfile->objfile->name); + objfile_name (dwarf2_per_objfile->objfile)); return build_error_marker_type (cu, die); } } @@ -19285,8 +20514,7 @@ skip_form_bytes (bfd *abfd, const gdb_byte *bytes, const gdb_byte *buffer_end, complain: complaint (&symfile_complaints, _("invalid form 0x%x in `%s'"), - form, - section->asection->name); + form, get_section_name (section)); return NULL; } } @@ -19616,8 +20844,8 @@ dwarf_decode_macro_bytes (bfd *abfd, dwarf2_read_section (dwarf2_per_objfile->objfile, &dwz->macro); - include_bfd = dwz->macro.asection->owner; include_section = &dwz->macro; + include_bfd = get_section_bfd_owner (include_section); include_mac_end = dwz->macro.buffer + dwz->macro.size; is_dwz = 1; } @@ -19726,7 +20954,7 @@ dwarf_decode_macros (struct dwarf2_cu *cu, unsigned int offset, complaint (&symfile_complaints, _("missing %s section"), section_name); return; } - abfd = section->asection->owner; + abfd = get_section_bfd_owner (section); /* First pass: Find the name of the base filename. This filename is needed in order to process all macros whose definition @@ -20607,7 +21835,8 @@ static struct cmd_list_element *show_dwarf2_cmdlist; static void set_dwarf2_cmd (char *args, int from_tty) { - help_list (set_dwarf2_cmdlist, "maintenance set dwarf2 ", -1, gdb_stdout); + help_list (set_dwarf2_cmdlist, "maintenance set dwarf2 ", all_commands, + gdb_stdout); } static void @@ -21350,10 +22579,10 @@ write_psymtabs_to_index (struct objfile *objfile, const char *dir) if (!objfile->psymtabs || !objfile->psymtabs_addrmap) return; - if (stat (objfile->name, &st) < 0) - perror_with_name (objfile->name); + if (stat (objfile_name (objfile), &st) < 0) + perror_with_name (objfile_name (objfile)); - filename = concat (dir, SLASH_STRING, lbasename (objfile->name), + filename = concat (dir, SLASH_STRING, lbasename (objfile_name (objfile)), INDEX_SUFFIX, (char *) NULL); cleanup = make_cleanup (xfree, filename); @@ -21527,7 +22756,7 @@ save_gdb_index_command (char *arg, int from_tty) struct stat st; /* If the objfile does not correspond to an actual file, skip it. */ - if (stat (objfile->name, &st) < 0) + if (stat (objfile_name (objfile), &st) < 0) continue; dwarf2_per_objfile = objfile_data (objfile, dwarf2_objfile_data_key); @@ -21542,7 +22771,7 @@ save_gdb_index_command (char *arg, int from_tty) if (except.reason < 0) exception_fprintf (gdb_stderr, except, _("Error while writing index for `%s': "), - objfile->name); + objfile_name (objfile)); } } } @@ -21616,11 +22845,12 @@ conversational style, when possible."), &set_dwarf2_cmdlist, &show_dwarf2_cmdlist); - add_setshow_boolean_cmd ("dwarf2-read", no_class, &dwarf2_read_debug, _("\ + add_setshow_zuinteger_cmd ("dwarf2-read", no_class, &dwarf2_read_debug, _("\ Set debugging of the dwarf2 reader."), _("\ Show debugging of the dwarf2 reader."), _("\ -When enabled, debugging messages are printed during dwarf2 reading\n\ -and symtab expansion."), +When enabled (non-zero), debugging messages are printed during dwarf2\n\ +reading and symtab expansion. A value of 1 (one) provides basic\n\ +information. A value greater than 1 provides more verbose information."), NULL, NULL, &setdebuglist, &showdebuglist);