X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fdwarf2read.c;h=13cd12fb341861cbabcd31d27d465756c93a04cd;hb=fa760f46b50745385bf9a738e55064e7b32430db;hp=37b7dc457d096c0872bd7a92c62f1c61ce06c628;hpb=ff54693587a755045017346e094ff7fec4f6aac8;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/dwarf2read.c b/gdb/dwarf2read.c index 37b7dc457d..13cd12fb34 100644 --- a/gdb/dwarf2read.c +++ b/gdb/dwarf2read.c @@ -202,7 +202,8 @@ struct dwarf2_per_objfile /* The number of .debug_types-related CUs. */ int n_type_units; - /* The .debug_types-related CUs (TUs). */ + /* 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. */ @@ -551,6 +552,22 @@ struct dwarf2_per_cu_data /* Non-zero if this CU is from the .dwz file. */ unsigned int is_dwz : 1; + /* Non-zero if reading a TU directly from a DWO file, bypassing the stub. + This flag is only valid if is_debug_types is true. + We can't read a CU directly from a DWO file: There are required + attributes in the stub. */ + unsigned int reading_dwo_directly : 1; + + /* Non-zero if the TU has been read. + This is used to assist the "Stay in DWO Optimization" for Fission: + When reading a DWO, it's faster to read TUs from the DWO instead of + fetching them from random other DWOs (due to comdat folding). + If the TU has already been read, the optimization is unnecessary + (and unwise - we don't want to change where gdb thinks the TU lives + "midflight"). + This flag is only valid if is_debug_types is true. */ + unsigned int tu_read : 1; + /* The section this CU/TU lives in. If the DIE refers to a DWO file, this is always the original die, not the DWO file. */ @@ -630,6 +647,10 @@ struct signatured_type The first time we encounter this type we fully read it in and install it in the symbol tables. Subsequent times we only need the type. */ struct type *type; + + /* Containing DWO unit. + This field is valid iff per_cu.reading_dwo_directly. */ + struct dwo_unit *dwo_unit; }; typedef struct signatured_type *sig_type_ptr; @@ -802,7 +823,7 @@ struct dwp_file /* Name of the file. */ const char *name; - /* The bfd, when the file is open. Otherwise this is NULL. */ + /* The bfd. */ bfd *dbfd; /* Section info for this file. */ @@ -863,6 +884,9 @@ struct die_reader_specs /* The end of the buffer. */ const gdb_byte *buffer_end; + + /* The value of the DW_AT_comp_dir attribute. */ + const char *comp_dir; }; /* Type of function passed to init_cutu_and_read_dies, et.al. */ @@ -1438,10 +1462,10 @@ static struct symbol *new_symbol (struct die_info *, struct type *, static struct symbol *new_symbol_full (struct die_info *, struct type *, struct dwarf2_cu *, struct symbol *); -static void dwarf2_const_value (struct attribute *, struct symbol *, +static void dwarf2_const_value (const struct attribute *, struct symbol *, struct dwarf2_cu *); -static void dwarf2_const_value_attr (struct attribute *attr, +static void dwarf2_const_value_attr (const struct attribute *attr, struct type *type, const char *name, struct obstack *obstack, @@ -1462,7 +1486,7 @@ static void set_descriptive_type (struct type *, struct die_info *, static struct type *die_containing_type (struct die_info *, struct dwarf2_cu *); -static struct type *lookup_die_type (struct die_info *, struct attribute *, +static struct type *lookup_die_type (struct die_info *, const struct attribute *, struct dwarf2_cu *); static struct type *read_type_die (struct die_info *, struct dwarf2_cu *); @@ -1594,29 +1618,27 @@ static void dump_die_1 (struct ui_file *, int level, int max_level, static void store_in_ref_table (struct die_info *, struct dwarf2_cu *); -static int is_ref_attr (struct attribute *); - -static sect_offset dwarf2_get_ref_die_offset (struct attribute *); +static sect_offset dwarf2_get_ref_die_offset (const struct attribute *); -static LONGEST dwarf2_get_attr_constant_value (struct attribute *, int); +static LONGEST dwarf2_get_attr_constant_value (const struct attribute *, int); static struct die_info *follow_die_ref_or_sig (struct die_info *, - struct attribute *, + const struct attribute *, struct dwarf2_cu **); static struct die_info *follow_die_ref (struct die_info *, - struct attribute *, + const struct attribute *, struct dwarf2_cu **); static struct die_info *follow_die_sig (struct die_info *, - struct attribute *, + const struct attribute *, struct dwarf2_cu **); static struct type *get_signatured_type (struct die_info *, ULONGEST, struct dwarf2_cu *); static struct type *get_DW_AT_signature_type (struct die_info *, - struct attribute *, + const struct attribute *, struct dwarf2_cu *); static void load_full_type_unit (struct dwarf2_per_cu_data *per_cu); @@ -1624,7 +1646,7 @@ 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 *, struct attribute *); + (struct dwarf2_cu *, const struct attribute *); static void build_type_unit_groups (die_reader_func_ftype *, void *); @@ -1637,17 +1659,19 @@ static struct die_info *dwarf_alloc_die (struct dwarf2_cu *, int); static void dwarf_decode_macros (struct dwarf2_cu *, unsigned int, const char *, int); -static int attr_form_is_block (struct attribute *); +static int attr_form_is_block (const struct attribute *); + +static int attr_form_is_section_offset (const struct attribute *); -static int attr_form_is_section_offset (struct attribute *); +static int attr_form_is_constant (const struct attribute *); -static int attr_form_is_constant (struct attribute *); +static int attr_form_is_ref (const struct attribute *); static void fill_in_loclist_baton (struct dwarf2_cu *cu, struct dwarf2_loclist_baton *baton, - struct attribute *attr); + const struct attribute *attr); -static void dwarf2_symbol_mark_computed (struct attribute *attr, +static void dwarf2_symbol_mark_computed (const struct attribute *attr, struct symbol *sym, struct dwarf2_cu *cu, int is_block); @@ -1745,6 +1769,12 @@ 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 dwp_file *get_dwp_file (void); + static struct dwo_unit *lookup_dwo_comp_unit (struct dwarf2_per_cu_data *, const char *, const char *, ULONGEST); @@ -2079,29 +2109,33 @@ locate_dwz_sections (bfd *abfd, asection *sectp, void *arg) } } -/* Open the separate '.dwz' debug file, if needed. Error if the file - cannot be found. */ +/* Open the separate '.dwz' debug file, if needed. Return NULL if + there is no .gnu_debugaltlink section in the file. Error if there + is such a section but the file cannot be found. */ static struct dwz_file * dwarf2_get_dwz_file (void) { - bfd *abfd, *dwz_bfd; - asection *section; - gdb_byte *data; + bfd *dwz_bfd; + char *data; struct cleanup *cleanup; const char *filename; struct dwz_file *result; + unsigned long buildid; if (dwarf2_per_objfile->dwz_file != NULL) return dwarf2_per_objfile->dwz_file; - abfd = dwarf2_per_objfile->objfile->obfd; - section = bfd_get_section_by_name (abfd, ".gnu_debugaltlink"); - if (section == NULL) - error (_("could not find '.gnu_debugaltlink' section")); - if (!bfd_malloc_and_get_section (abfd, section, &data)) - error (_("could not read '.gnu_debugaltlink' section: %s"), - bfd_errmsg (bfd_get_error ())); + bfd_set_error (bfd_error_no_error); + data = bfd_get_alt_debug_link_info (dwarf2_per_objfile->objfile->obfd, + &buildid); + if (data == NULL) + { + if (bfd_get_error () == bfd_error_no_error) + return NULL; + error (_("could not read '.gnu_debugaltlink' section: %s"), + bfd_errmsg (bfd_get_error ())); + } cleanup = make_cleanup (xfree, data); filename = (const char *) data; @@ -2466,9 +2500,8 @@ create_signatured_type_table_from_index (struct objfile *objfile, dwarf2_per_objfile->n_type_units = elements / 3; dwarf2_per_objfile->all_type_units - = obstack_alloc (&objfile->objfile_obstack, - dwarf2_per_objfile->n_type_units - * sizeof (struct signatured_type *)); + = xmalloc (dwarf2_per_objfile->n_type_units + * sizeof (struct signatured_type *)); sig_types_hash = allocate_signatured_type_table (objfile); @@ -2780,6 +2813,7 @@ dwarf2_read_index (struct objfile *objfile) struct mapped_index local_map, *map; const gdb_byte *cu_list, *types_list, *dwz_list = NULL; offset_type cu_list_elements, types_list_elements, dwz_list_elements = 0; + struct dwz_file *dwz; if (!read_index_from_section (objfile, objfile->name, use_deprecated_index_sections, @@ -2794,9 +2828,9 @@ dwarf2_read_index (struct objfile *objfile) /* If there is a .dwz file, read it so we can get its CU list as well. */ - if (bfd_get_section_by_name (objfile->obfd, ".gnu_debugaltlink") != NULL) + dwz = dwarf2_get_dwz_file (); + if (dwz != NULL) { - struct dwz_file *dwz = dwarf2_get_dwz_file (); struct mapped_index dwz_map; const gdb_byte *dwz_types_ignore; offset_type dwz_types_elements_ignore; @@ -3180,7 +3214,7 @@ dw2_symtab_iter_next (struct dw2_symtab_iterator *iter) offset_type cu_index_and_attrs = MAYBE_SWAP (iter->vec[iter->next + 1]); offset_type cu_index = GDB_INDEX_CU_VALUE (cu_index_and_attrs); - struct dwarf2_per_cu_data *per_cu = dw2_get_cu (cu_index); + struct dwarf2_per_cu_data *per_cu; int want_static = iter->block_index != GLOBAL_BLOCK; /* This value is only valid for index versions >= 7. */ int is_static = GDB_INDEX_SYMBOL_STATIC_VALUE (cu_index_and_attrs); @@ -3194,6 +3228,18 @@ dw2_symtab_iter_next (struct dw2_symtab_iterator *iter) (iter->index->version >= 7 && symbol_kind != GDB_INDEX_SYMBOL_KIND_NONE); + /* Don't crash on bad data. */ + if (cu_index >= (dwarf2_per_objfile->n_comp_units + + dwarf2_per_objfile->n_type_units)) + { + complaint (&symfile_complaints, + _(".gdb_index entry has bad CU index" + " [in module %s]"), dwarf2_per_objfile->objfile->name); + continue; + } + + per_cu = dw2_get_cu (cu_index); + /* Skip if already read in. */ if (per_cu->v.quick->symtab) continue; @@ -3311,8 +3357,9 @@ dw2_dump (struct objfile *objfile) } static void -dw2_relocate (struct objfile *objfile, struct section_offsets *new_offsets, - struct section_offsets *delta) +dw2_relocate (struct objfile *objfile, + const struct section_offsets *new_offsets, + const struct section_offsets *delta) { /* There's nothing to relocate here. */ } @@ -3398,80 +3445,6 @@ dw2_expand_symtabs_with_fullname (struct objfile *objfile, } } -/* A helper function for dw2_find_symbol_file that finds the primary - file name for a given CU. This is a die_reader_func. */ - -static void -dw2_get_primary_filename_reader (const struct die_reader_specs *reader, - const gdb_byte *info_ptr, - struct die_info *comp_unit_die, - int has_children, - void *data) -{ - const char **result_ptr = data; - struct dwarf2_cu *cu = reader->cu; - struct attribute *attr; - - attr = dwarf2_attr (comp_unit_die, DW_AT_name, cu); - if (attr == NULL) - *result_ptr = NULL; - else - *result_ptr = DW_STRING (attr); -} - -static const char * -dw2_find_symbol_file (struct objfile *objfile, const char *name) -{ - struct dwarf2_per_cu_data *per_cu; - offset_type *vec; - const char *filename; - - dw2_setup (objfile); - - /* index_table is NULL if OBJF_READNOW. */ - if (!dwarf2_per_objfile->index_table) - { - struct symtab *s; - - ALL_OBJFILE_PRIMARY_SYMTABS (objfile, s) - { - struct blockvector *bv = BLOCKVECTOR (s); - const struct block *block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK); - struct symbol *sym = lookup_block_symbol (block, name, VAR_DOMAIN); - - if (sym) - { - /* Only file extension of returned filename is recognized. */ - return SYMBOL_SYMTAB (sym)->filename; - } - } - return NULL; - } - - if (!find_slot_in_mapped_hash (dwarf2_per_objfile->index_table, - name, &vec)) - return NULL; - - /* Note that this just looks at the very first one named NAME -- but - actually we are looking for a function. find_main_filename - should be rewritten so that it doesn't require a custom hook. It - could just use the ordinary symbol tables. */ - /* vec[0] is the length, which must always be >0. */ - per_cu = dw2_get_cu (GDB_INDEX_CU_VALUE (MAYBE_SWAP (vec[1]))); - - if (per_cu->v.quick->symtab != NULL) - { - /* Only file extension of returned filename is recognized. */ - return per_cu->v.quick->symtab->filename; - } - - init_cutu_and_read_dies (per_cu, NULL, 0, 0, - dw2_get_primary_filename_reader, &filename); - - /* Only file extension of returned filename is recognized. */ - return filename; -} - static void dw2_map_matching_symbols (const char * name, domain_enum namespace, struct objfile *objfile, int global, @@ -3607,15 +3580,16 @@ dw2_expand_symtabs_matching 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); - - /* Don't crash on bad data. */ - if (cu_index >= (dwarf2_per_objfile->n_comp_units - + dwarf2_per_objfile->n_type_units)) - continue; - - /* Only check the symbol's kind if it has one. - Indices prior to version 7 don't record it. */ - if (index->version >= 7) + /* Only check the symbol attributes if they're present. + Indices prior to version 7 don't record them, + and indices >= 7 may elide them for certain symbols + (gold does this). */ + int attrs_valid = + (index->version >= 7 + && symbol_kind != GDB_INDEX_SYMBOL_KIND_NONE); + + /* Only check the symbol's kind if it has one. */ + if (attrs_valid) { switch (kind) { @@ -3636,6 +3610,16 @@ dw2_expand_symtabs_matching } } + /* Don't crash on bad data. */ + if (cu_index >= (dwarf2_per_objfile->n_comp_units + + dwarf2_per_objfile->n_type_units)) + { + complaint (&symfile_complaints, + _(".gdb_index entry has bad CU index" + " [in module %s]"), objfile->name); + continue; + } + per_cu = dw2_get_cu (cu_index); if (file_matcher == NULL || per_cu->v.quick->mark) dw2_instantiate_symtab (per_cu); @@ -3784,7 +3768,6 @@ const struct quick_symbol_functions dwarf2_gdb_index_functions = dw2_expand_symtabs_for_function, dw2_expand_all_symtabs, dw2_expand_symtabs_with_fullname, - dw2_find_symbol_file, dw2_map_matching_symbols, dw2_expand_symtabs_matching, dw2_find_pc_sect_symtab, @@ -4374,9 +4357,8 @@ create_all_type_units (struct objfile *objfile) dwarf2_per_objfile->n_type_units = htab_elements (types_htab); dwarf2_per_objfile->all_type_units - = obstack_alloc (&objfile->objfile_obstack, - dwarf2_per_objfile->n_type_units - * sizeof (struct signatured_type *)); + = xmalloc (dwarf2_per_objfile->n_type_units + * sizeof (struct signatured_type *)); iter = &dwarf2_per_objfile->all_type_units[0]; htab_traverse_noresize (types_htab, add_signatured_type_cu_to_table, &iter); gdb_assert (iter - &dwarf2_per_objfile->all_type_units[0] @@ -4385,20 +4367,204 @@ create_all_type_units (struct objfile *objfile) return 1; } +/* Subroutine of lookup_dwo_signatured_type and lookup_dwp_signatured_type. + Fill in SIG_ENTRY with DWO_ENTRY. */ + +static void +fill_in_sig_entry_from_dwo_entry (struct objfile *objfile, + struct signatured_type *sig_entry, + struct dwo_unit *dwo_entry) +{ + /* 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); + 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); + gdb_assert (sig_entry->dwo_unit == NULL); + + sig_entry->per_cu.section = dwo_entry->section; + sig_entry->per_cu.offset = dwo_entry->offset; + sig_entry->per_cu.length = dwo_entry->length; + sig_entry->per_cu.reading_dwo_directly = 1; + sig_entry->per_cu.objfile = objfile; + sig_entry->type_offset_in_tu = dwo_entry->type_offset_in_tu; + sig_entry->dwo_unit = dwo_entry; +} + +/* Subroutine of lookup_signatured_type. + If we haven't read the TU yet, create the signatured_type data structure + for a TU to be read in directly from a DWO file, bypassing the stub. + This is the "Stay in DWO Optimization": When there is no DWP file and we're + using .gdb_index, then when reading a CU we want to stay in the DWO file + containing that CU. Otherwise we could end up reading several other DWO + files (due to comdat folding) to process the transitive closure of all the + mentioned TUs, and that can be slow. The current DWO file will have every + type signature that it needs. + We only do this for .gdb_index because in the psymtab case we already have + to read all the DWOs to build the type unit groups. */ + +static struct signatured_type * +lookup_dwo_signatured_type (struct dwarf2_cu *cu, ULONGEST sig) +{ + struct objfile *objfile = dwarf2_per_objfile->objfile; + struct dwo_file *dwo_file; + struct dwo_unit find_dwo_entry, *dwo_entry; + struct signatured_type find_sig_entry, *sig_entry; + + 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; + + /* 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. */ + + 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; + + /* 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) + return sig_entry; + + /* Ok, this is the first time we're reading this TU. */ + if (dwo_file->tus == NULL) + return NULL; + find_dwo_entry.signature = sig; + dwo_entry = htab_find (dwo_file->tus, &find_dwo_entry); + if (dwo_entry == NULL) + return NULL; + + fill_in_sig_entry_from_dwo_entry (objfile, sig_entry, dwo_entry); + 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.] */ + +static struct signatured_type * +lookup_dwp_signatured_type (struct dwarf2_cu *cu, ULONGEST sig) +{ + struct objfile *objfile = dwarf2_per_objfile->objfile; + struct dwp_file *dwp_file = get_dwp_file (); + struct dwo_unit *dwo_entry; + struct signatured_type find_sig_entry, *sig_entry; + + gdb_assert (cu->dwo_unit && dwarf2_per_objfile->using_index); + gdb_assert (dwp_file != NULL); + + 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; + } + + /* This is the "shouldn't happen" case. + Try the DWP file and hope for the best. */ + if (dwp_file->tus == NULL) + return NULL; + dwo_entry = lookup_dwo_in_dwp (dwp_file, dwp_file->tus, NULL, + sig, 1 /* is_debug_types */); + if (dwo_entry == NULL) + return NULL; + + sig_entry = add_type_unit (sig); + 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; +} + /* Lookup a signature based type for DW_FORM_ref_sig8. Returns NULL if signature SIG is not present in the table. It is up to the caller to complain about this. */ static struct signatured_type * -lookup_signatured_type (ULONGEST sig) +lookup_signatured_type (struct dwarf2_cu *cu, ULONGEST sig) { - struct signatured_type find_entry, *entry; + if (cu->dwo_unit + && dwarf2_per_objfile->using_index) + { + /* We're in a DWO/DWP file, and we're using .gdb_index. + These cases require special processing. */ + if (get_dwp_file () == NULL) + return lookup_dwo_signatured_type (cu, sig); + else + return lookup_dwp_signatured_type (cu, sig); + } + else + { + struct signatured_type find_entry, *entry; - if (dwarf2_per_objfile->signatured_types == NULL) - return NULL; - find_entry.signature = sig; - entry = htab_find (dwarf2_per_objfile->signatured_types, &find_entry); - return entry; + if (dwarf2_per_objfile->signatured_types == NULL) + return NULL; + find_entry.signature = sig; + entry = htab_find (dwarf2_per_objfile->signatured_types, &find_entry); + return entry; + } } /* Low level DIE reading support. */ @@ -4418,6 +4584,7 @@ init_cu_die_reader (struct die_reader_specs *reader, reader->die_section = section; reader->buffer = section->buffer; reader->buffer_end = section->buffer + section->size; + reader->comp_dir = NULL; } /* Subroutine of init_cutu_and_read_dies to simplify it. @@ -4427,6 +4594,10 @@ init_cu_die_reader (struct die_reader_specs *reader, STUB_COMP_UNIT_DIE is for the stub DIE, we copy over certain attributes 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. *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 @@ -4438,6 +4609,7 @@ read_cutu_die_from_dwo (struct dwarf2_per_cu_data *this_cu, struct dwo_unit *dwo_unit, int abbrev_table_provided, struct die_info *stub_comp_unit_die, + const char *stub_comp_dir, struct die_reader_specs *result_reader, const gdb_byte **result_info_ptr, struct die_info **result_comp_unit_die, @@ -4454,8 +4626,12 @@ read_cutu_die_from_dwo (struct dwarf2_per_cu_data *this_cu, 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)); + /* 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. @@ -4493,6 +4669,16 @@ read_cutu_die_from_dwo (struct dwarf2_per_cu_data *this_cu, if (attr) cu->ranges_base = DW_UNSND (attr); } + else if (stub_comp_dir != NULL) + { + /* Reconstruct the comp_dir attribute to simplify the code below. */ + comp_dir = (struct attribute *) + obstack_alloc (&cu->comp_unit_obstack, sizeof (*comp_dir)); + comp_dir->name = DW_AT_comp_dir; + comp_dir->form = DW_FORM_string; + DW_STRING_IS_CANONICAL (comp_dir) = 0; + DW_STRING (comp_dir) = stub_comp_dir; + } /* Set up for reading the DWO CU/TU. */ cu->dwo_unit = dwo_unit; @@ -4514,7 +4700,16 @@ read_cutu_die_from_dwo (struct dwarf2_per_cu_data *this_cu, info_ptr, &header_signature, &type_offset_in_tu); - gdb_assert (sig_type->signature == header_signature); + /* This is not an assert because it can be caused by bad debug info. */ + if (sig_type->signature != header_signature) + { + error (_("Dwarf Error: signature mismatch %s vs %s while reading" + " TU at offset 0x%x [in module %s]"), + hex_string (sig_type->signature), + hex_string (header_signature), + dwo_unit->offset.sect_off, + bfd_get_filename (abfd)); + } gdb_assert (dwo_unit->offset.sect_off == cu->header.offset.sect_off); /* For DWOs coming from DWP files, we don't know the CU length nor the type's offset in the TU until now. */ @@ -4591,6 +4786,13 @@ read_cutu_die_from_dwo (struct dwarf2_per_cu_data *this_cu, dump_die (comp_unit_die, dwarf2_die_debug); } + /* Save the comp_dir attribute. If there is no DWP file then we'll read + TUs by skipping the stub and going directly to the entry in the DWO file. + However, skipping the stub means we won't get DW_AT_comp_dir, so we have + to get it via circuitous means. Blech. */ + if (comp_dir != NULL) + result_reader->comp_dir = DW_STRING (comp_dir); + /* Skip dummy compilation units. */ if (info_ptr >= begin_info_ptr + dwo_unit->length || peek_abbrev_code (abfd, info_ptr) == 0) @@ -4602,7 +4804,7 @@ read_cutu_die_from_dwo (struct dwarf2_per_cu_data *this_cu, /* Subroutine of init_cutu_and_read_dies to simplify it. Look up the DWO unit specified by COMP_UNIT_DIE of THIS_CU. - If the specified DWO unit cannot be found an error is thrown. */ + Returns NULL if the specified DWO unit cannot be found. */ static struct dwo_unit * lookup_dwo_unit (struct dwarf2_per_cu_data *this_cu, @@ -4614,6 +4816,8 @@ lookup_dwo_unit (struct dwarf2_per_cu_data *this_cu, struct dwo_unit *dwo_unit; const char *comp_dir, *dwo_name; + gdb_assert (cu != NULL); + /* Yeah, we look dwo_name up again, but it simplifies the code. */ attr = dwarf2_attr (comp_unit_die, DW_AT_GNU_dwo_name, cu); gdb_assert (attr != NULL); @@ -4647,15 +4851,76 @@ lookup_dwo_unit (struct dwarf2_per_cu_data *this_cu, signature); } - if (dwo_unit == NULL) + return dwo_unit; +} + +/* Subroutine of init_cutu_and_read_dies to simplify it. + Read a TU directly from a DWO file, bypassing the stub. */ + +static void +init_tu_and_read_dwo_dies (struct dwarf2_per_cu_data *this_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 die_reader_specs reader; + const gdb_byte *info_ptr; + struct die_info *comp_unit_die; + int has_children; + + /* Verify we can do the following downcast, and that we have the + data we need. */ + gdb_assert (this_cu->is_debug_types && this_cu->reading_dwo_directly); + sig_type = (struct signatured_type *) this_cu; + gdb_assert (sig_type->dwo_unit != NULL); + + 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) + { + /* 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, + 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) { - error (_("Dwarf Error: CU at offset 0x%x references unknown DWO" - " with ID %s [in module %s]"), - this_cu->offset.sect_off, hex_string (signature), - this_cu->objfile->name); + /* 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); + + /* 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); - return dwo_unit; + do_cleanups (cleanups); } /* Initialize a CU (or TU) and read its DIEs. @@ -4695,7 +4960,7 @@ init_cutu_and_read_dies (struct dwarf2_per_cu_data *this_cu, struct dwarf2_section_info *abbrev_section; /* Non-zero if CU currently points to a DWO file and we need to reread it. When this happens we need to reread the skeleton die - before we can reread the DWO file. */ + before we can reread the DWO file (this only applies to CUs, not TUs). */ int rereading_dwo_cu = 0; if (dwarf2_die_debug) @@ -4706,6 +4971,18 @@ init_cutu_and_read_dies (struct dwarf2_per_cu_data *this_cu, if (use_existing_cu) gdb_assert (keep); + /* If we're reading a TU directly from a DWO file, including a virtual DWO + file (instead of going through the stub), short-circuit all of this. */ + if (this_cu->reading_dwo_directly) + { + /* 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); + return; + } + cleanups = make_cleanup (null_cleanup, NULL); /* This is cheap if the section is already read in. */ @@ -4831,21 +5108,35 @@ init_cutu_and_read_dies (struct dwarf2_per_cu_data *this_cu, struct die_info *dwo_comp_unit_die; if (has_children) - error (_("Dwarf Error: compilation unit with DW_AT_GNU_dwo_name" - " has children (offset 0x%x) [in module %s]"), - this_cu->offset.sect_off, bfd_get_filename (abfd)); + { + complaint (&symfile_complaints, + _("compilation unit with DW_AT_GNU_dwo_name" + " has children (offset 0x%x) [in module %s]"), + this_cu->offset.sect_off, bfd_get_filename (abfd)); + } dwo_unit = lookup_dwo_unit (this_cu, comp_unit_die); - if (read_cutu_die_from_dwo (this_cu, dwo_unit, - abbrev_table != NULL, - comp_unit_die, - &reader, &info_ptr, - &dwo_comp_unit_die, &has_children) == 0) + if (dwo_unit != NULL) { - /* Dummy die. */ - do_cleanups (cleanups); - return; + if (read_cutu_die_from_dwo (this_cu, dwo_unit, + abbrev_table != NULL, + comp_unit_die, NULL, + &reader, &info_ptr, + &dwo_comp_unit_die, &has_children) == 0) + { + /* Dummy die. */ + do_cleanups (cleanups); + return; + } + comp_unit_die = dwo_comp_unit_die; + } + else + { + /* Yikes, we couldn't find the rest of the DIE, we only have + the stub. A complaint has already been logged. There's + not much more we can do except pass on the stub DIE to + die_reader_func. We don't want to throw an error on bad + debug info. */ } - comp_unit_die = dwo_comp_unit_die; } /* All of the above is setup for this call. Yikes. */ @@ -5063,7 +5354,7 @@ create_type_unit_group (struct dwarf2_cu *cu, sect_offset line_offset_struct) STMT_LIST is a DW_AT_stmt_list attribute. */ static struct type_unit_group * -get_type_unit_group (struct dwarf2_cu *cu, struct attribute *stmt_list) +get_type_unit_group (struct dwarf2_cu *cu, const struct attribute *stmt_list) { struct tu_stats *tu_stats = &dwarf2_per_objfile->tu_stats; struct type_unit_group *tu_group; @@ -5262,6 +5553,16 @@ build_type_unit_groups (die_reader_func_ftype *func, void *data) 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 = @@ -5765,6 +6066,7 @@ create_all_comp_units (struct objfile *objfile) int n_allocated; int n_comp_units; struct dwarf2_per_cu_data **all_comp_units; + struct dwz_file *dwz; n_comp_units = 0; n_allocated = 10; @@ -5774,14 +6076,11 @@ create_all_comp_units (struct objfile *objfile) read_comp_units_from_section (objfile, &dwarf2_per_objfile->info, 0, &n_allocated, &n_comp_units, &all_comp_units); - if (bfd_get_section_by_name (objfile->obfd, ".gnu_debugaltlink") != NULL) - { - struct dwz_file *dwz = dwarf2_get_dwz_file (); - - read_comp_units_from_section (objfile, &dwz->info, 1, - &n_allocated, &n_comp_units, - &all_comp_units); - } + dwz = dwarf2_get_dwz_file (); + if (dwz != NULL) + read_comp_units_from_section (objfile, &dwz->info, 1, + &n_allocated, &n_comp_units, + &all_comp_units); dwarf2_per_objfile->all_comp_units = obstack_alloc (&objfile->objfile_obstack, @@ -6669,14 +6968,21 @@ process_queue (void) : (item->per_cu->v.psymtab && !item->per_cu->v.psymtab->readin)) { struct dwarf2_per_cu_data *per_cu = item->per_cu; + char buf[100]; - if (dwarf2_read_debug) + if (per_cu->is_debug_types) { - fprintf_unfiltered (gdb_stdlog, - "Expanding symtab of %s at offset 0x%x\n", - per_cu->is_debug_types ? "TU" : "CU", - per_cu->offset.sect_off); + struct signatured_type *sig_type = + (struct signatured_type *) per_cu; + + sprintf (buf, "TU %s at offset 0x%x", + hex_string (sig_type->signature), per_cu->offset.sect_off); } + else + sprintf (buf, "CU at offset 0x%x", per_cu->offset.sect_off); + + if (dwarf2_read_debug) + fprintf_unfiltered (gdb_stdlog, "Expanding symtab of %s\n", buf); if (per_cu->is_debug_types) process_full_type_unit (per_cu, item->pretend_language); @@ -6684,12 +6990,7 @@ process_queue (void) process_full_comp_unit (per_cu, item->pretend_language); if (dwarf2_read_debug) - { - fprintf_unfiltered (gdb_stdlog, - "Done expanding %s at offset 0x%x\n", - per_cu->is_debug_types ? "TU" : "CU", - per_cu->offset.sect_off); - } + fprintf_unfiltered (gdb_stdlog, "Done expanding %s\n", buf); } item->per_cu->queued = 0; @@ -6993,12 +7294,14 @@ get_symtab (struct dwarf2_per_cu_data *per_cu) included by PER_CU. */ static void -recursively_compute_inclusions (VEC (dwarf2_per_cu_ptr) **result, - htab_t all_children, - struct dwarf2_per_cu_data *per_cu) +recursively_compute_inclusions (VEC (symtab_ptr) **result, + htab_t all_children, htab_t all_type_symtabs, + struct dwarf2_per_cu_data *per_cu, + struct symtab *immediate_parent) { void **slot; int ix; + struct symtab *symtab; struct dwarf2_per_cu_data *iter; slot = htab_find_slot (all_children, per_cu, INSERT); @@ -7010,13 +7313,37 @@ recursively_compute_inclusions (VEC (dwarf2_per_cu_ptr) **result, *slot = per_cu; /* Only add a CU if it has a symbol table. */ - if (get_symtab (per_cu) != NULL) - VEC_safe_push (dwarf2_per_cu_ptr, *result, per_cu); + symtab = get_symtab (per_cu); + if (symtab != NULL) + { + /* If this is a type unit only add its symbol table if we haven't + seen it yet (type unit per_cu's can share symtabs). */ + if (per_cu->is_debug_types) + { + slot = htab_find_slot (all_type_symtabs, symtab, INSERT); + if (*slot == NULL) + { + *slot = symtab; + VEC_safe_push (symtab_ptr, *result, symtab); + if (symtab->user == NULL) + symtab->user = immediate_parent; + } + } + else + { + VEC_safe_push (symtab_ptr, *result, symtab); + if (symtab->user == NULL) + symtab->user = immediate_parent; + } + } for (ix = 0; VEC_iterate (dwarf2_per_cu_ptr, per_cu->imported_symtabs, ix, iter); ++ix) - recursively_compute_inclusions (result, all_children, iter); + { + recursively_compute_inclusions (result, all_children, + all_type_symtabs, iter, symtab); + } } /* Compute the symtab 'includes' fields for the symtab related to @@ -7030,9 +7357,10 @@ compute_symtab_includes (struct dwarf2_per_cu_data *per_cu) if (!VEC_empty (dwarf2_per_cu_ptr, per_cu->imported_symtabs)) { int ix, len; - struct dwarf2_per_cu_data *iter; - VEC (dwarf2_per_cu_ptr) *result_children = NULL; - htab_t all_children; + struct dwarf2_per_cu_data *per_cu_iter; + struct symtab *symtab_iter; + VEC (symtab_ptr) *result_symtabs = NULL; + htab_t all_children, all_type_symtabs; struct symtab *symtab = get_symtab (per_cu); /* If we don't have a symtab, we can just skip this case. */ @@ -7041,28 +7369,33 @@ compute_symtab_includes (struct dwarf2_per_cu_data *per_cu) all_children = htab_create_alloc (1, htab_hash_pointer, htab_eq_pointer, NULL, xcalloc, xfree); + all_type_symtabs = htab_create_alloc (1, htab_hash_pointer, htab_eq_pointer, + NULL, xcalloc, xfree); for (ix = 0; VEC_iterate (dwarf2_per_cu_ptr, per_cu->imported_symtabs, - ix, iter); + ix, per_cu_iter); ++ix) - recursively_compute_inclusions (&result_children, all_children, iter); + { + recursively_compute_inclusions (&result_symtabs, all_children, + all_type_symtabs, per_cu_iter, + symtab); + } - /* Now we have a transitive closure of all the included CUs, and - for .gdb_index version 7 the included TUs, so we can convert it - to a list of symtabs. */ - len = VEC_length (dwarf2_per_cu_ptr, result_children); + /* Now we have a transitive closure of all the included symtabs. */ + len = VEC_length (symtab_ptr, result_symtabs); symtab->includes = obstack_alloc (&dwarf2_per_objfile->objfile->objfile_obstack, (len + 1) * sizeof (struct symtab *)); for (ix = 0; - VEC_iterate (dwarf2_per_cu_ptr, result_children, ix, iter); + VEC_iterate (symtab_ptr, result_symtabs, ix, symtab_iter); ++ix) - symtab->includes[ix] = get_symtab (iter); + symtab->includes[ix] = symtab_iter; symtab->includes[len] = NULL; - VEC_free (dwarf2_per_cu_ptr, result_children); + VEC_free (symtab_ptr, result_symtabs); htab_delete (all_children); + htab_delete (all_type_symtabs); } } @@ -8053,7 +8386,7 @@ find_file_and_directory (struct die_info *die, struct dwarf2_cu *cu, static void handle_DW_AT_stmt_list (struct die_info *die, struct dwarf2_cu *cu, - const char *comp_dir) + const char *comp_dir) /* ARI: editCase function */ { struct attribute *attr; @@ -8313,9 +8646,12 @@ static hashval_t hash_dwo_file (const void *item) { const struct dwo_file *dwo_file = item; + hashval_t hash; - return (htab_hash_string (dwo_file->dwo_name) - + htab_hash_string (dwo_file->comp_dir)); + hash = htab_hash_string (dwo_file->dwo_name); + if (dwo_file->comp_dir != NULL) + hash += htab_hash_string (dwo_file->comp_dir); + return hash; } static int @@ -8324,8 +8660,11 @@ eq_dwo_file (const void *item_lhs, const void *item_rhs) const struct dwo_file *lhs = item_lhs; const struct dwo_file *rhs = item_rhs; - return (strcmp (lhs->dwo_name, rhs->dwo_name) == 0 - && strcmp (lhs->comp_dir, rhs->comp_dir) == 0); + if (strcmp (lhs->dwo_name, rhs->dwo_name) != 0) + return 0; + if (lhs->comp_dir == NULL || rhs->comp_dir == NULL) + return lhs->comp_dir == rhs->comp_dir; + return strcmp (lhs->comp_dir, rhs->comp_dir) == 0; } /* Allocate a hash table for DWO files. */ @@ -8528,62 +8867,67 @@ create_dwo_cu (struct dwo_file *dwo_file) /* DWP file .debug_{cu,tu}_index section format: [ref: http://gcc.gnu.org/wiki/DebugFissionDWP] + DWP Version 1: + Both index sections have the same format, and serve to map a 64-bit signature to a set of section numbers. Each section begins with a header, followed by a hash table of 64-bit signatures, a parallel table of 32-bit indexes, and a pool of 32-bit section numbers. The index sections will be aligned at 8-byte boundaries in the file. - The index section header contains two unsigned 32-bit values (using the - byte order of the application binary): + The index section header consists of: + + V, 32 bit version number + -, 32 bits unused + N, 32 bit number of compilation units or type units in the index + M, 32 bit number of slots in the hash table - N, the number of compilation units or type units in the index - M, the number of slots in the hash table + Numbers are recorded using the byte order of the application binary. - (We assume that N and M will not exceed 2^32 - 1.) + 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 size of the hash table, M, must be 2^k such that 2^k > 3*N/2. - The hash table begins at offset 8 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. - (We rely on the extreme unlikeliness of a signature being exactly 0.) + 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. + (We rely on the extreme unlikeliness of a signature being exactly 0.) - The parallel table begins immediately after the hash table - (at offset 8 + 8 * M from the beginning of the section), and consists of an - array of 32-bit indexes (using the byte order of the application binary), - corresponding 1-1 with slots in the hash table. Each entry in the parallel - 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 parallel table begins immediately after the hash table + (at offset 16 + 8 * M from the beginning of the section), and consists of an + array of 32-bit indexes (using the byte order of the application binary), + corresponding 1-1 with slots in the hash table. Each entry in the parallel + 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. - Given a 64-bit compilation unit signature or a type signature S, an entry - in the hash table is located as follows: + Given a 64-bit compilation unit signature or a type signature S, an entry + in the hash table is located as follows: - 1) Calculate a primary hash H = S & MASK(k), where MASK(k) is a mask with - the low-order k bits all set to 1. + 1) Calculate a primary hash H = S & MASK(k), where MASK(k) is a mask with + the low-order k bits all set to 1. - 2) Calculate a secondary hash H' = (((S >> 32) & MASK(k)) | 1). + 2) Calculate a secondary hash H' = (((S >> 32) & MASK(k)) | 1). - 3) If the hash table entry at index H matches the signature, use that - entry. If the hash table entry at index H is unused (all zeroes), - terminate the search: the signature is not present in the table. + 3) If the hash table entry at index H matches the signature, use that + entry. If the hash table entry at index H is unused (all zeroes), + terminate the search: the signature is not present in the table. - 4) Let H = (H + H') modulo M. Repeat at Step 3. + 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. + 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 8 + 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). + 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. */ + 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. */ /* Create a hash table to map DWO IDs to their CU/TU entry in .debug_{info,types}.dwo in DWP_FILE. @@ -8621,15 +8965,15 @@ create_dwp_hash_table (struct dwp_file *dwp_file, int is_debug_types) if (version != 1) { - error (_("Dwarf Error: unsupported DWP file version (%u)" + error (_("Dwarf Error: unsupported DWP file version (%s)" " [in module %s]"), - version, dwp_file->name); + pulongest (version), dwp_file->name); } if (nr_slots != (nr_slots & -nr_slots)) { - error (_("Dwarf Error: number of slots in DWP hash table (%u)" + error (_("Dwarf Error: number of slots in DWP hash table (%s)" " is not power of 2 [in module %s]"), - nr_slots, dwp_file->name); + pulongest (nr_slots), dwp_file->name); } htab = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwp_hash_table); @@ -8748,9 +9092,9 @@ create_dwo_in_dwp (struct dwp_file *dwp_file, if (dwarf2_read_debug) { - fprintf_unfiltered (gdb_stdlog, "Reading %s %u/%s in DWP file: %s\n", + fprintf_unfiltered (gdb_stdlog, "Reading %s %s/%s in DWP file: %s\n", kind, - section_index, hex_string (signature), + pulongest (section_index), hex_string (signature), dwp_file->name); } @@ -8937,31 +9281,47 @@ lookup_dwo_in_dwp (struct dwp_file *dwp_file, preliminary analysis. Return a newly initialized bfd *, which includes a canonicalized copy of FILE_NAME. If IS_DWP is TRUE, we're opening a DWP file, otherwise a DWO file. - In case of trouble, return NULL. + SEARCH_CWD is true if the current directory is to be searched. + It will be searched before debug-file-directory. + If unable to find/open the file, return NULL. NOTE: This function is derived from symfile_bfd_open. */ static bfd * -try_open_dwop_file (const char *file_name, int is_dwp) +try_open_dwop_file (const char *file_name, int is_dwp, int search_cwd) { bfd *sym_bfd; int desc, flags; char *absolute_name; + /* Blech. OPF_TRY_CWD_FIRST also disables searching the path list if + FILE_NAME contains a '/'. So we can't use it. Instead prepend "." + to debug_file_directory. */ + char *search_path; + static const char dirname_separator_string[] = { DIRNAME_SEPARATOR, '\0' }; - flags = OPF_TRY_CWD_FIRST; + if (search_cwd) + { + if (*debug_file_directory != '\0') + search_path = concat (".", dirname_separator_string, + debug_file_directory, NULL); + else + search_path = xstrdup ("."); + } + else + search_path = xstrdup (debug_file_directory); + + flags = 0; if (is_dwp) flags |= OPF_SEARCH_IN_PATH; - desc = openp (debug_file_directory, flags, file_name, + desc = openp (search_path, flags, file_name, O_RDONLY | O_BINARY, &absolute_name); + xfree (search_path); if (desc < 0) return NULL; sym_bfd = gdb_bfd_open (absolute_name, gnutarget, desc); - if (!sym_bfd) - { - xfree (absolute_name); - return NULL; - } xfree (absolute_name); + if (sym_bfd == NULL) + return NULL; bfd_set_cacheable (sym_bfd, 1); if (!bfd_check_format (sym_bfd, bfd_object)) @@ -8986,7 +9346,7 @@ open_dwo_file (const char *file_name, const char *comp_dir) bfd *abfd; if (IS_ABSOLUTE_PATH (file_name)) - return try_open_dwop_file (file_name, 0 /*is_dwp*/); + return try_open_dwop_file (file_name, 0 /*is_dwp*/, 0 /*search_cwd*/); /* Before trying the search path, try DWO_NAME in COMP_DIR. */ @@ -8996,7 +9356,7 @@ open_dwo_file (const char *file_name, const char *comp_dir) /* NOTE: If comp_dir is a relative path, this will also try the search path, which seems useful. */ - abfd = try_open_dwop_file (path_to_try, 0 /*is_dwp*/); + abfd = try_open_dwop_file (path_to_try, 0 /*is_dwp*/, 1 /*search_cwd*/); xfree (path_to_try); if (abfd != NULL) return abfd; @@ -9008,7 +9368,7 @@ open_dwo_file (const char *file_name, const char *comp_dir) if (*debug_file_directory == '\0') return NULL; - return try_open_dwop_file (file_name, 0 /*is_dwp*/); + return try_open_dwop_file (file_name, 0 /*is_dwp*/, 1 /*search_cwd*/); } /* This function is mapped across the sections and remembers the offset and @@ -9192,7 +9552,30 @@ allocate_dwp_loaded_cutus_table (struct objfile *objfile) static bfd * open_dwp_file (const char *file_name) { - return try_open_dwop_file (file_name, 1 /*is_dwp*/); + bfd *abfd; + + abfd = try_open_dwop_file (file_name, 1 /*is_dwp*/, 1 /*search_cwd*/); + if (abfd != NULL) + return abfd; + + /* Work around upstream bug 15652. + http://sourceware.org/bugzilla/show_bug.cgi?id=15652 + [Whether that's a "bug" is debatable, but it is getting in our way.] + We have no real idea where the dwp file is, because gdb's realpath-ing + of the executable's path may have discarded the needed info. + [IWBN if the dwp file name was recorded in the executable, akin to + .gnu_debuglink, but that doesn't exist yet.] + Strip the directory from FILE_NAME and search again. */ + if (*debug_file_directory != '\0') + { + /* Don't implicitly search the current directory here. + If the user wants to search "." to handle this case, + it must be added to debug-file-directory. */ + return try_open_dwop_file (lbasename (file_name), 1 /*is_dwp*/, + 0 /*search_cwd*/); + } + + return NULL; } /* Initialize the use of the DWP file for the current objfile. @@ -9220,8 +9603,7 @@ open_and_init_dwp_file (void) return NULL; } dwp_file = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwp_file); - dwp_file->name = obstack_copy0 (&objfile->objfile_obstack, - dwp_name, strlen (dwp_name)); + dwp_file->name = bfd_get_filename (dbfd); dwp_file->dbfd = dbfd; do_cleanups (cleanups); @@ -9243,9 +9625,9 @@ open_and_init_dwp_file (void) { fprintf_unfiltered (gdb_stdlog, "DWP file found: %s\n", dwp_file->name); fprintf_unfiltered (gdb_stdlog, - " %u CUs, %u TUs\n", - dwp_file->cus ? dwp_file->cus->nr_units : 0, - dwp_file->tus ? dwp_file->tus->nr_units : 0); + " %s CUs, %s TUs\n", + pulongest (dwp_file->cus ? dwp_file->cus->nr_units : 0), + pulongest (dwp_file->tus ? dwp_file->tus->nr_units : 0)); } return dwp_file; @@ -9291,7 +9673,10 @@ lookup_dwo_cutu (struct dwarf2_per_cu_data *this_unit, struct dwo_file *dwo_file; struct dwp_file *dwp_file; - /* Have we already read SIGNATURE from a DWP file? */ + /* First see if there's a DWP file. + If we have a DWP file but didn't find the DWO inside it, don't + look for the original DWO file. It makes gdb behave differently + depending on whether one is debugging in the build tree. */ dwp_file = get_dwp_file (); if (dwp_file != NULL) @@ -9318,45 +9703,47 @@ lookup_dwo_cutu (struct dwarf2_per_cu_data *this_unit, } } } - - /* Have we already seen DWO_NAME? */ - - dwo_file_slot = lookup_dwo_file_slot (dwo_name, comp_dir); - if (*dwo_file_slot == NULL) - { - /* Read in the file and build a table of the DWOs it contains. */ - *dwo_file_slot = open_and_init_dwo_file (this_unit, dwo_name, comp_dir); - } - /* NOTE: This will be NULL if unable to open the file. */ - dwo_file = *dwo_file_slot; - - if (dwo_file != NULL) + else { - struct dwo_unit *dwo_cutu = NULL; - - if (is_debug_types && dwo_file->tus) - { - struct dwo_unit find_dwo_cutu; + /* No DWP file, look for the DWO file. */ - memset (&find_dwo_cutu, 0, sizeof (find_dwo_cutu)); - find_dwo_cutu.signature = signature; - dwo_cutu = htab_find (dwo_file->tus, &find_dwo_cutu); - } - else if (!is_debug_types && dwo_file->cu) + dwo_file_slot = lookup_dwo_file_slot (dwo_name, comp_dir); + if (*dwo_file_slot == NULL) { - if (signature == dwo_file->cu->signature) - dwo_cutu = dwo_file->cu; + /* Read in the file and build a table of the CUs/TUs it contains. */ + *dwo_file_slot = open_and_init_dwo_file (this_unit, dwo_name, comp_dir); } + /* NOTE: This will be NULL if unable to open the file. */ + dwo_file = *dwo_file_slot; - if (dwo_cutu != NULL) + if (dwo_file != NULL) { - if (dwarf2_read_debug) + struct dwo_unit *dwo_cutu = NULL; + + if (is_debug_types && dwo_file->tus) + { + struct dwo_unit find_dwo_cutu; + + memset (&find_dwo_cutu, 0, sizeof (find_dwo_cutu)); + find_dwo_cutu.signature = signature; + dwo_cutu = htab_find (dwo_file->tus, &find_dwo_cutu); + } + else if (!is_debug_types && dwo_file->cu) + { + if (signature == dwo_file->cu->signature) + dwo_cutu = dwo_file->cu; + } + + if (dwo_cutu != NULL) { - fprintf_unfiltered (gdb_stdlog, "DWO %s %s(%s) found: @%s\n", - kind, dwo_name, hex_string (signature), - host_address_to_string (dwo_cutu)); + if (dwarf2_read_debug) + { + fprintf_unfiltered (gdb_stdlog, "DWO %s %s(%s) found: @%s\n", + kind, dwo_name, hex_string (signature), + host_address_to_string (dwo_cutu)); + } + return dwo_cutu; } - return dwo_cutu; } } @@ -9370,10 +9757,13 @@ lookup_dwo_cutu (struct dwarf2_per_cu_data *this_unit, kind, dwo_name, hex_string (signature)); } - complaint (&symfile_complaints, - _("Could not find DWO %s referenced by CU at offset 0x%x" - " [in module %s]"), - kind, this_unit->offset.sect_off, objfile->name); + /* 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); return NULL; } @@ -9949,7 +10339,7 @@ read_call_site_scope (struct die_info *die, struct dwarf2_cu *cu) SET_FIELD_DWARF_BLOCK (call_site->target, dlbaton); } - else if (is_ref_attr (attr)) + else if (attr_form_is_ref (attr)) { struct dwarf2_cu *target_cu = cu; struct die_info *target_die; @@ -10022,7 +10412,7 @@ read_call_site_scope (struct die_info *die, struct dwarf2_cu *cu) loc = dwarf2_attr (child_die, DW_AT_location, cu); origin = dwarf2_attr (child_die, DW_AT_abstract_origin, cu); - if (loc == NULL && origin != NULL && is_ref_attr (origin)) + if (loc == NULL && origin != NULL && attr_form_is_ref (origin)) { sect_offset offset; @@ -10477,7 +10867,7 @@ dwarf2_record_block_ranges (struct die_info *die, struct block *block, address range list in the .debug_ranges section. */ unsigned long offset = (DW_UNSND (attr) + (need_ranges_base ? cu->ranges_base : 0)); - const gdb_byte *buffer = dwarf2_per_objfile->ranges.buffer + offset; + const gdb_byte *buffer; /* For some target architectures, but not others, the read_address function sign-extends the addresses it returns. @@ -10496,7 +10886,7 @@ dwarf2_record_block_ranges (struct die_info *die, struct block *block, CORE_ADDR base = cu->base_address; int base_known = cu->base_known; - gdb_assert (dwarf2_per_objfile->ranges.readin); + dwarf2_read_section (objfile, &dwarf2_per_objfile->ranges); if (offset >= dwarf2_per_objfile->ranges.size) { complaint (&symfile_complaints, @@ -10504,6 +10894,7 @@ dwarf2_record_block_ranges (struct die_info *die, struct block *block, offset); return; } + buffer = dwarf2_per_objfile->ranges.buffer + offset; for (;;) { @@ -12583,6 +12974,38 @@ read_tag_string_type (struct die_info *die, struct dwarf2_cu *cu) return set_die_type (die, type, cu); } +/* Assuming that DIE corresponds to a function, returns nonzero + if the function is prototyped. */ + +static int +prototyped_function_p (struct die_info *die, struct dwarf2_cu *cu) +{ + struct attribute *attr; + + attr = dwarf2_attr (die, DW_AT_prototyped, cu); + if (attr && (DW_UNSND (attr) != 0)) + return 1; + + /* The DWARF standard implies that the DW_AT_prototyped attribute + is only meaninful for C, but the concept also extends to other + languages that allow unprototyped functions (Eg: Objective C). + For all other languages, assume that functions are always + prototyped. */ + if (cu->language != language_c + && cu->language != language_objc + && cu->language != language_opencl) + return 1; + + /* RealView does not emit DW_AT_prototyped. We can not distinguish + prototyped and unprototyped functions; default to prototyped, + since that is more common in modern code (and RealView warns + about unprototyped functions). */ + if (producer_is_realview (cu->producer)) + return 1; + + return 0; +} + /* Handle DIES due to C code like: struct foo @@ -12610,18 +13033,7 @@ read_subroutine_type (struct die_info *die, struct dwarf2_cu *cu) ftype = lookup_function_type (type); - /* All functions in C++, Pascal and Java have prototypes. */ - attr = dwarf2_attr (die, DW_AT_prototyped, cu); - if ((attr && (DW_UNSND (attr) != 0)) - || cu->language == language_cplus - || cu->language == language_java - || cu->language == language_pascal) - TYPE_PROTOTYPED (ftype) = 1; - else if (producer_is_realview (cu->producer)) - /* RealView does not emit DW_AT_prototyped. We can not - distinguish prototyped and unprototyped functions; default to - prototyped, since that is more common in modern code (and - RealView warns about unprototyped functions). */ + if (prototyped_function_p (die, cu)) TYPE_PROTOTYPED (ftype) = 1; /* Store the calling convention in the type if it's available in @@ -12942,7 +13354,7 @@ read_subrange_type (struct die_info *die, struct dwarf2_cu *cu) attr = dwarf2_attr (die, DW_AT_upper_bound, cu); if (attr) { - if (attr_form_is_block (attr) || is_ref_attr (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. @@ -13437,7 +13849,8 @@ dwarf2_free_abbrev_table (void *ptr_to_cu) { struct dwarf2_cu *cu = ptr_to_cu; - abbrev_table_free (cu->abbrev_table); + if (cu->abbrev_table != NULL) + abbrev_table_free (cu->abbrev_table); /* Set this to NULL so that we SEGV if we try to read it later, and also because free_comp_unit verifies this is NULL. */ cu->abbrev_table = NULL; @@ -14382,7 +14795,7 @@ read_attribute_value (const struct die_reader_specs *reader, } /* Super hack. */ - if (cu->per_cu->is_dwz && is_ref_attr (attr)) + if (cu->per_cu->is_dwz && attr_form_is_ref (attr)) attr->form = DW_FORM_GNU_ref_alt; /* We have seen instances where the compiler tried to emit a byte @@ -14966,6 +15379,7 @@ set_cu_language (unsigned int lang, struct dwarf2_cu *cu) case DW_LANG_C89: case DW_LANG_C99: case DW_LANG_C: + case DW_LANG_UPC: cu->language = language_c; break; case DW_LANG_C_plus_plus: @@ -15265,6 +15679,7 @@ dwarf_decode_line_header (unsigned int offset, struct dwarf2_cu *cu) if (line_ptr + lh->total_length > (section->buffer + section->size)) { dwarf2_statement_list_fits_in_line_number_section_complaint (); + do_cleanups (back_to); return 0; } lh->statement_program_end = line_ptr + lh->total_length; @@ -16345,8 +16760,7 @@ new_symbol (struct die_info *die, struct type *type, struct dwarf2_cu *cu) because that is the interpretation long in use by GCC. */ static gdb_byte * -dwarf2_const_value_data (struct attribute *attr, struct type *type, - const char *name, struct obstack *obstack, +dwarf2_const_value_data (const struct attribute *attr, struct obstack *obstack, struct dwarf2_cu *cu, LONGEST *value, int bits) { struct objfile *objfile = cu->objfile; @@ -16378,7 +16792,7 @@ dwarf2_const_value_data (struct attribute *attr, struct type *type, expression. */ static void -dwarf2_const_value_attr (struct attribute *attr, struct type *type, +dwarf2_const_value_attr (const struct attribute *attr, struct type *type, const char *name, struct obstack *obstack, struct dwarf2_cu *cu, LONGEST *value, const gdb_byte **bytes, @@ -16408,13 +16822,12 @@ dwarf2_const_value_attr (struct attribute *attr, struct type *type, /* Symbols of this form are reasonably rare, so we just piggyback on the existing location code rather than writing a new implementation of symbol_computed_ops. */ - *baton = obstack_alloc (&objfile->objfile_obstack, - sizeof (struct dwarf2_locexpr_baton)); + *baton = obstack_alloc (obstack, sizeof (struct dwarf2_locexpr_baton)); (*baton)->per_cu = cu->per_cu; gdb_assert ((*baton)->per_cu); (*baton)->size = 2 + cu_header->addr_size; - data = obstack_alloc (&objfile->objfile_obstack, (*baton)->size); + data = obstack_alloc (obstack, (*baton)->size); (*baton)->data = data; data[0] = DW_OP_addr; @@ -16449,20 +16862,16 @@ dwarf2_const_value_attr (struct attribute *attr, struct type *type, converted to host endianness, so we just need to sign- or zero-extend it as appropriate. */ case DW_FORM_data1: - *bytes = dwarf2_const_value_data (attr, type, name, - obstack, cu, value, 8); + *bytes = dwarf2_const_value_data (attr, obstack, cu, value, 8); break; case DW_FORM_data2: - *bytes = dwarf2_const_value_data (attr, type, name, - obstack, cu, value, 16); + *bytes = dwarf2_const_value_data (attr, obstack, cu, value, 16); break; case DW_FORM_data4: - *bytes = dwarf2_const_value_data (attr, type, name, - obstack, cu, value, 32); + *bytes = dwarf2_const_value_data (attr, obstack, cu, value, 32); break; case DW_FORM_data8: - *bytes = dwarf2_const_value_data (attr, type, name, - obstack, cu, value, 64); + *bytes = dwarf2_const_value_data (attr, obstack, cu, value, 64); break; case DW_FORM_sdata: @@ -16486,7 +16895,7 @@ dwarf2_const_value_attr (struct attribute *attr, struct type *type, /* Copy constant value from an attribute to a symbol. */ static void -dwarf2_const_value (struct attribute *attr, struct symbol *sym, +dwarf2_const_value (const struct attribute *attr, struct symbol *sym, struct dwarf2_cu *cu) { struct objfile *objfile = cu->objfile; @@ -16625,7 +17034,7 @@ build_error_marker_type (struct dwarf2_cu *cu, struct die_info *die) If there is no type substitute an error marker. */ static struct type * -lookup_die_type (struct die_info *die, struct attribute *attr, +lookup_die_type (struct die_info *die, const struct attribute *attr, struct dwarf2_cu *cu) { struct objfile *objfile = cu->objfile; @@ -16645,7 +17054,7 @@ lookup_die_type (struct die_info *die, struct attribute *attr, per_cu = dwarf2_find_containing_comp_unit (offset, 1, cu->objfile); this_type = get_die_type_at_offset (offset, per_cu); } - else if (is_ref_attr (attr)) + else if (attr_form_is_ref (attr)) { sect_offset offset = dwarf2_get_ref_die_offset (attr); @@ -16674,7 +17083,7 @@ lookup_die_type (struct die_info *die, struct attribute *attr, struct die_info *type_die = NULL; struct dwarf2_cu *type_cu = cu; - if (is_ref_attr (attr)) + if (attr_form_is_ref (attr)) type_die = follow_die_ref (die, attr, &type_cu); if (type_die == NULL) return build_error_marker_type (cu, die); @@ -17517,36 +17926,15 @@ store_in_ref_table (struct die_info *die, struct dwarf2_cu *cu) *slot = die; } -/* DW_ADDR is always stored already as sect_offset; despite for the forms - besides DW_FORM_ref_addr it is stored as cu_offset in the DWARF file. */ - -static int -is_ref_attr (struct attribute *attr) -{ - switch (attr->form) - { - case DW_FORM_ref_addr: - case DW_FORM_ref1: - case DW_FORM_ref2: - case DW_FORM_ref4: - case DW_FORM_ref8: - case DW_FORM_ref_udata: - case DW_FORM_GNU_ref_alt: - return 1; - default: - return 0; - } -} - /* Return DIE offset of ATTR. Return 0 with complaint if ATTR is not of the required kind. */ static sect_offset -dwarf2_get_ref_die_offset (struct attribute *attr) +dwarf2_get_ref_die_offset (const struct attribute *attr) { sect_offset retval = { DW_UNSND (attr) }; - if (is_ref_attr (attr)) + if (attr_form_is_ref (attr)) return retval; retval.sect_off = 0; @@ -17560,7 +17948,7 @@ dwarf2_get_ref_die_offset (struct attribute *attr) * the value held by the attribute is not constant. */ static LONGEST -dwarf2_get_attr_constant_value (struct attribute *attr, int default_value) +dwarf2_get_attr_constant_value (const struct attribute *attr, int default_value) { if (attr->form == DW_FORM_sdata) return DW_SND (attr); @@ -17584,12 +17972,12 @@ dwarf2_get_attr_constant_value (struct attribute *attr, int default_value) On exit *REF_CU is the CU of the result. */ static struct die_info * -follow_die_ref_or_sig (struct die_info *src_die, struct attribute *attr, +follow_die_ref_or_sig (struct die_info *src_die, const struct attribute *attr, struct dwarf2_cu **ref_cu) { struct die_info *die; - if (is_ref_attr (attr)) + if (attr_form_is_ref (attr)) die = follow_die_ref (src_die, attr, ref_cu); else if (attr->form == DW_FORM_ref_sig8) die = follow_die_sig (src_die, attr, ref_cu); @@ -17658,7 +18046,7 @@ follow_die_offset (sect_offset offset, int offset_in_dwz, On exit *REF_CU is the CU of the result. */ static struct die_info * -follow_die_ref (struct die_info *src_die, struct attribute *attr, +follow_die_ref (struct die_info *src_die, const struct attribute *attr, struct dwarf2_cu **ref_cu) { sect_offset offset = dwarf2_get_ref_die_offset (attr); @@ -17755,6 +18143,150 @@ dwarf2_fetch_die_loc_cu_off (cu_offset offset_in_cu, return dwarf2_fetch_die_loc_sect_off (offset, per_cu, get_frame_pc, baton); } +/* Write a constant of a given type as target-ordered bytes into + OBSTACK. */ + +static const gdb_byte * +write_constant_as_bytes (struct obstack *obstack, + enum bfd_endian byte_order, + struct type *type, + ULONGEST value, + LONGEST *len) +{ + gdb_byte *result; + + *len = TYPE_LENGTH (type); + result = obstack_alloc (obstack, *len); + store_unsigned_integer (result, *len, byte_order, value); + + return result; +} + +/* If the DIE at OFFSET in PER_CU has a DW_AT_const_value, return a + pointer to the constant bytes and set LEN to the length of the + data. If memory is needed, allocate it on OBSTACK. If the DIE + does not have a DW_AT_const_value, return NULL. */ + +const gdb_byte * +dwarf2_fetch_constant_bytes (sect_offset offset, + struct dwarf2_per_cu_data *per_cu, + struct obstack *obstack, + LONGEST *len) +{ + struct dwarf2_cu *cu; + struct die_info *die; + struct attribute *attr; + const gdb_byte *result = NULL; + struct type *type; + LONGEST value; + enum bfd_endian byte_order; + + dw2_setup (per_cu->objfile); + + if (per_cu->cu == NULL) + load_cu (per_cu); + cu = per_cu->cu; + + 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); + + + attr = dwarf2_attr (die, DW_AT_const_value, cu); + if (attr == NULL) + return NULL; + + byte_order = (bfd_big_endian (per_cu->objfile->obfd) + ? BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE); + + switch (attr->form) + { + case DW_FORM_addr: + case DW_FORM_GNU_addr_index: + { + gdb_byte *tem; + + *len = cu->header.addr_size; + tem = obstack_alloc (obstack, *len); + store_unsigned_integer (tem, *len, byte_order, DW_ADDR (attr)); + result = tem; + } + break; + case DW_FORM_string: + case DW_FORM_strp: + case DW_FORM_GNU_str_index: + case DW_FORM_GNU_strp_alt: + /* DW_STRING is already allocated on the objfile obstack, point + directly to it. */ + result = (const gdb_byte *) DW_STRING (attr); + *len = strlen (DW_STRING (attr)); + break; + case DW_FORM_block1: + case DW_FORM_block2: + case DW_FORM_block4: + case DW_FORM_block: + case DW_FORM_exprloc: + result = DW_BLOCK (attr)->data; + *len = DW_BLOCK (attr)->size; + break; + + /* The DW_AT_const_value attributes are supposed to carry the + symbol's value "represented as it would be on the target + architecture." By the time we get here, it's already been + converted to host endianness, so we just need to sign- or + zero-extend it as appropriate. */ + case DW_FORM_data1: + type = die_type (die, cu); + result = dwarf2_const_value_data (attr, obstack, cu, &value, 8); + if (result == NULL) + result = write_constant_as_bytes (obstack, byte_order, + type, value, len); + break; + case DW_FORM_data2: + type = die_type (die, cu); + result = dwarf2_const_value_data (attr, obstack, cu, &value, 16); + if (result == NULL) + result = write_constant_as_bytes (obstack, byte_order, + type, value, len); + break; + case DW_FORM_data4: + type = die_type (die, cu); + result = dwarf2_const_value_data (attr, obstack, cu, &value, 32); + if (result == NULL) + result = write_constant_as_bytes (obstack, byte_order, + type, value, len); + break; + case DW_FORM_data8: + type = die_type (die, cu); + result = dwarf2_const_value_data (attr, obstack, cu, &value, 64); + if (result == NULL) + result = write_constant_as_bytes (obstack, byte_order, + type, value, len); + break; + + case DW_FORM_sdata: + type = die_type (die, cu); + result = write_constant_as_bytes (obstack, byte_order, + type, DW_SND (attr), len); + break; + + case DW_FORM_udata: + type = die_type (die, cu); + result = write_constant_as_bytes (obstack, byte_order, + type, DW_UNSND (attr), len); + break; + + default: + complaint (&symfile_complaints, + _("unsupported const value attribute form: '%s'"), + dwarf_form_name (attr->form)); + break; + } + + return result; +} + /* Return the type of the DIE at DIE_OFFSET in the CU named by PER_CU. */ @@ -17826,7 +18358,7 @@ follow_die_sig_1 (struct die_info *src_die, struct signatured_type *sig_type, If the referenced type cannot be found an error is thrown. */ static struct die_info * -follow_die_sig (struct die_info *src_die, struct attribute *attr, +follow_die_sig (struct die_info *src_die, const struct attribute *attr, struct dwarf2_cu **ref_cu) { ULONGEST signature = DW_SIGNATURE (attr); @@ -17835,7 +18367,7 @@ follow_die_sig (struct die_info *src_die, struct attribute *attr, gdb_assert (attr->form == DW_FORM_ref_sig8); - sig_type = lookup_signatured_type (signature); + sig_type = lookup_signatured_type (*ref_cu, signature); /* sig_type will be NULL if the signatured type is missing from the debug info. */ if (sig_type == NULL) @@ -17871,7 +18403,7 @@ get_signatured_type (struct die_info *die, ULONGEST signature, struct die_info *type_die; struct type *type; - sig_type = lookup_signatured_type (signature); + sig_type = lookup_signatured_type (cu, signature); /* sig_type will be NULL if the signatured type is missing from the debug info. */ if (sig_type == NULL) @@ -17924,11 +18456,11 @@ get_signatured_type (struct die_info *die, ULONGEST signature, reading in and processing the type unit if necessary. */ static struct type * -get_DW_AT_signature_type (struct die_info *die, struct attribute *attr, - struct dwarf2_cu *cu) +get_DW_AT_signature_type (struct die_info *die, const struct attribute *attr, + struct dwarf2_cu *cu) /* ARI: editCase function */ { /* Yes, DW_AT_signature can use a non-ref_sig8 reference. */ - if (is_ref_attr (attr)) + if (attr_form_is_ref (attr)) { struct dwarf2_cu *type_cu = cu; struct die_info *type_die = follow_die_ref (die, attr, &type_cu); @@ -18024,6 +18556,7 @@ read_signatured_type (struct signatured_type *sig_type) init_cutu_and_read_dies (per_cu, NULL, 0, 1, read_signatured_type_reader, NULL); + sig_type->per_cu.tu_read = 1; } /* Decode simple location descriptions. @@ -19239,7 +19772,7 @@ dwarf_decode_macros (struct dwarf2_cu *cu, unsigned int offset, if so return true else false. */ static int -attr_form_is_block (struct attribute *attr) +attr_form_is_block (const struct attribute *attr) { return (attr == NULL ? 0 : attr->form == DW_FORM_block1 @@ -19259,7 +19792,7 @@ attr_form_is_block (struct attribute *attr) of them. */ static int -attr_form_is_section_offset (struct attribute *attr) +attr_form_is_section_offset (const struct attribute *attr) { return (attr->form == DW_FORM_data4 || attr->form == DW_FORM_data8 @@ -19280,7 +19813,7 @@ attr_form_is_section_offset (struct attribute *attr) taken as section offsets, not constants. */ static int -attr_form_is_constant (struct attribute *attr) +attr_form_is_constant (const struct attribute *attr) { switch (attr->form) { @@ -19296,6 +19829,28 @@ attr_form_is_constant (struct attribute *attr) } } + +/* DW_ADDR is always stored already as sect_offset; despite for the forms + besides DW_FORM_ref_addr it is stored as cu_offset in the DWARF file. */ + +static int +attr_form_is_ref (const struct attribute *attr) +{ + switch (attr->form) + { + case DW_FORM_ref_addr: + case DW_FORM_ref1: + case DW_FORM_ref2: + case DW_FORM_ref4: + case DW_FORM_ref8: + case DW_FORM_ref_udata: + case DW_FORM_GNU_ref_alt: + return 1; + default: + return 0; + } +} + /* Return the .debug_loc section to use for CU. For DWO files use .debug_loc.dwo. */ @@ -19312,7 +19867,7 @@ cu_debug_loc_section (struct dwarf2_cu *cu) static void fill_in_loclist_baton (struct dwarf2_cu *cu, struct dwarf2_loclist_baton *baton, - struct attribute *attr) + const struct attribute *attr) { struct dwarf2_section_info *section = cu_debug_loc_section (cu); @@ -19329,7 +19884,7 @@ fill_in_loclist_baton (struct dwarf2_cu *cu, } static void -dwarf2_symbol_mark_computed (struct attribute *attr, struct symbol *sym, +dwarf2_symbol_mark_computed (const struct attribute *attr, struct symbol *sym, struct dwarf2_cu *cu, int is_block) { struct objfile *objfile = dwarf2_per_objfile->objfile; @@ -19969,13 +20524,17 @@ dwarf2_per_objfile_free (struct objfile *objfile, void *d) struct dwarf2_per_objfile *data = d; int ix; - for (ix = 0; ix < dwarf2_per_objfile->n_comp_units; ++ix) - VEC_free (dwarf2_per_cu_ptr, - dwarf2_per_objfile->all_comp_units[ix]->imported_symtabs); + /* Make sure we don't accidentally use dwarf2_per_objfile while + cleaning up. */ + dwarf2_per_objfile = NULL; - for (ix = 0; ix < dwarf2_per_objfile->n_type_units; ++ix) + for (ix = 0; ix < data->n_comp_units; ++ix) + VEC_free (dwarf2_per_cu_ptr, data->all_comp_units[ix]->imported_symtabs); + + for (ix = 0; ix < data->n_type_units; ++ix) VEC_free (dwarf2_per_cu_ptr, - dwarf2_per_objfile->all_type_units[ix]->per_cu.imported_symtabs); + data->all_type_units[ix]->per_cu.imported_symtabs); + xfree (data->all_type_units); VEC_free (dwarf2_section_info_def, data->types); @@ -20747,6 +21306,12 @@ write_psymtabs_to_index (struct objfile *objfile, const char *dir) struct psymtab_cu_index_map *map; void **slot; + /* CU of a shared file from 'dwz -m' may be unused by this main file. + It may be referenced from a local scope but in such case it does not + need to be present in .gdb_index. */ + if (psymtab == NULL) + continue; + if (psymtab->user == NULL) recursively_write_psymbols (objfile, psymtab, symtab, psyms_seen, i);