X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;ds=sidebyside;f=gdb%2Fdwarf2read.c;h=57a2e65246132cf8ce37143d5212ef9c8abae4fc;hb=9bda4a968f56cb61b832cdbdabf09a84eab140ab;hp=7e87ed9adde38402d707ac2bd7c3757ba87847a6;hpb=73be47f57c32f50d4695a4b672af9263b5313cbb;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/dwarf2read.c b/gdb/dwarf2read.c index 7e87ed9add..57a2e65246 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" @@ -72,8 +72,6 @@ #include "build-id.h" #include -#include "gdb_string.h" -#include "gdb_assert.h" #include typedef struct symbol *symbolp; @@ -235,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; @@ -262,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 @@ -513,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 @@ -615,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, @@ -1225,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; @@ -1489,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 *); @@ -1612,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); @@ -1710,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 *); @@ -1937,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" @@ -2430,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; } @@ -2637,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) { @@ -2663,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]; } @@ -2764,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 *)); @@ -2853,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, @@ -3034,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. */ @@ -3279,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, char *); + qfn->num_file_names, const char *); if (qfn->real_names[index] == NULL) qfn->real_names[index] = gdb_realpath (qfn->file_names[index]); @@ -3294,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. */ @@ -3370,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. */ @@ -3448,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. @@ -3467,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); @@ -3512,16 +3534,24 @@ dw2_symtab_iter_next (struct dw2_symtab_iterator *iter) 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) @@ -3584,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); @@ -3615,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; @@ -3688,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); } @@ -3710,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. */ @@ -3751,8 +3781,8 @@ dw2_map_matching_symbols (struct objfile *objfile, 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) { @@ -3787,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; @@ -3849,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 @@ -3867,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); @@ -3878,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) { @@ -3910,7 +3952,7 @@ dw2_expand_symtabs_matching 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); } @@ -3946,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) @@ -3990,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) { @@ -4004,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; @@ -4087,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); @@ -4169,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 @@ -4177,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; } } @@ -4639,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 *)); @@ -4651,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. */ @@ -4662,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); @@ -4697,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; @@ -4732,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) @@ -4785,21 +4863,30 @@ 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_unit_in_dwp (dwp_file, NULL, @@ -4807,19 +4894,9 @@ lookup_dwp_signatured_type (struct dwarf2_cu *cu, ULONGEST sig) 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 (objfile)); - return sig_entry; } @@ -4881,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 @@ -4905,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; @@ -5140,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; @@ -5163,11 +5247,26 @@ 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 (use_existing_cu && this_cu->cu != NULL) + { + 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 */, @@ -5184,26 +5283,29 @@ init_tu_and_read_dwo_dies (struct dwarf2_per_cu_data *this_cu, int keep, /* 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); } @@ -5263,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; } @@ -5280,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 @@ -5294,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); } @@ -5451,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. @@ -5470,7 +5568,6 @@ 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) @@ -5478,6 +5575,7 @@ init_cutu_and_read_dies_no_follow (struct dwarf2_per_cu_data *this_cu, struct objfile *objfile = dwarf2_per_objfile->objfile; struct dwarf2_section_info *section = this_cu->section; 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; @@ -5492,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); @@ -5539,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. @@ -5694,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. */ @@ -6136,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 @@ -6152,37 +6217,105 @@ build_type_psymtab_dependencies (void **slot, void *info) gdb_assert (len > 0); gdb_assert (IS_TYPE_UNIT_GROUP (per_cu)); - pst->number_of_dependencies = len; - pst->dependencies = obstack_alloc (&objfile->objfile_obstack, - len * sizeof (struct psymtab *)); - for (i = 0; - VEC_iterate (sig_type_ptr, tu_group->tus, i, iter); - ++i) + pst->number_of_dependencies = len; + pst->dependencies = obstack_alloc (&objfile->objfile_obstack, + len * sizeof (struct psymtab *)); + for (i = 0; + VEC_iterate (sig_type_ptr, tu_group->tus, i, iter); + ++i) + { + gdb_assert (iter->per_cu.is_debug_types); + pst->dependencies[i] = iter->per_cu.v.psymtab; + iter->type_unit_group = tu_group; + } + + VEC_free (sig_type_ptr, tu_group->tus); + + return 1; +} + +/* Subroutine of dwarf2_build_psymtabs_hard to simplify it. + Build partial symbol tables for the .debug_types comp-units. */ + +static void +build_type_psymtabs (struct objfile *objfile) +{ + if (! create_all_type_units (objfile)) + return; + + build_type_psymtabs_1 (); +} + +/* 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) { - gdb_assert (iter->per_cu.is_debug_types); - pst->dependencies[i] = iter->per_cu.v.psymtab; - iter->type_unit_group = tu_group; + htab_traverse_noresize (dwo_file->tus, + process_skeletonless_type_unit, info); } - VEC_free (sig_type_ptr, tu_group->tus); - return 1; } -/* Subroutine of dwarf2_build_psymtabs_hard to simplify it. - Build partial symbol tables for the .debug_types comp-units. */ +/* 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 -build_type_psymtabs (struct objfile *objfile) +process_skeletonless_type_units (struct objfile *objfile) { - if (! create_all_type_units (objfile)) - return; - - build_type_unit_groups (build_type_psymtabs_reader, NULL); - - /* 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); + /* 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. */ @@ -6204,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; @@ -6257,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, @@ -6488,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; } @@ -6759,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, @@ -6766,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: @@ -6836,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) @@ -7024,6 +7185,8 @@ skip_one_die (const struct die_reader_specs *reader, const gdb_byte *info_ptr, 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; } @@ -7580,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; @@ -7961,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: @@ -8032,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 @@ -8049,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. */ @@ -8074,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: @@ -8175,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 (); @@ -8351,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); } } @@ -8372,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. @@ -8487,12 +8684,73 @@ dwarf2_physname (const char *name, struct die_info *die, struct dwarf2_cu *cu) retval = canon; if (need_copy) - retval = obstack_copy0 (&objfile->objfile_obstack, retval, strlen (retval)); + 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; + + d = follow_die_ref (d, attr, &imported_cu); + if (d->tag != DW_TAG_imported_declaration) + break; + } + + 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; + } + + if (attr != NULL) + { + 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; + } + } + } + + return 0; +} + /* Read the import statement specified by the given die and record it. */ static void @@ -9162,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); @@ -10011,6 +10267,8 @@ lookup_dwo_unit_in_dwp (struct dwp_file *dwp_file, const char *comp_dir, 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. */ @@ -10058,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; } @@ -10424,10 +10688,12 @@ open_and_init_dwp_file (void) if (dwp_file->cus->version != dwp_file->tus->version) { /* Technically speaking, we should try to limp along, but this is - pretty bizarre. */ - error (_("Dwarf Error: DWP file CU version %d doesn't match" - " TU version %d [in DWP file %s]"), - dwp_file->cus->version, dwp_file->tus->version, dwp_name); + 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; @@ -10575,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 (objfile)); + { + /* 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; } @@ -10831,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); } @@ -11097,7 +11381,7 @@ read_call_site_scope (struct die_info *die, struct dwarf2_cu *cu) 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, @@ -11538,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. */ @@ -11709,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); } @@ -12613,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) @@ -12705,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; @@ -12944,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. */ @@ -12975,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) { @@ -12993,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); } @@ -13017,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) @@ -13035,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) { @@ -13074,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 @@ -13118,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); @@ -13126,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); } @@ -13172,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 @@ -13560,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) { @@ -13728,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) { @@ -13743,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); @@ -13779,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); } @@ -13835,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); @@ -14152,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 * @@ -14160,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; @@ -14177,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, 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; } } @@ -14293,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) @@ -14595,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, @@ -14686,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) @@ -14853,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); @@ -15084,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; @@ -15099,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. */ @@ -15159,6 +15605,8 @@ read_partial_die (const struct die_reader_specs *reader, 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; } @@ -15183,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 @@ -15378,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); @@ -15464,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); } } @@ -15658,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; } @@ -16194,12 +16637,12 @@ dwarf2_read_addr_index (struct dwarf2_per_cu_data *per_cu, 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 (objfile); + const char *objf_name = objfile_name (objfile); bfd *abfd = objfile->obfd; + 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; @@ -16212,15 +16655,15 @@ read_str_index (const struct die_reader_specs *reader, if (str_section->buffer == NULL) error (_("%s used without .debug_str.dwo section" " in CU at offset 0x%lx [in module %s]"), - form_name, (long) cu->header.offset.sect_off, dwo_name); + 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]"), - form_name, (long) cu->header.offset.sect_off, dwo_name); + 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]"), - form_name, (long) cu->header.offset.sect_off, dwo_name); + 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) @@ -16230,7 +16673,7 @@ read_str_index (const struct die_reader_specs *reader, 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]"), - form_name, (long) cu->header.offset.sect_off, dwo_name); + form_name, (long) cu->header.offset.sect_off, objf_name); return (const char *) (str_section->buffer + str_offset); } @@ -16682,7 +17125,9 @@ psymtab_include_file_name (const struct line_header *lh, int file_index, include_name = "hello.c" dir_name = "." DW_AT_comp_dir = comp_dir = "/tmp" - DW_AT_name = "./hello.c" */ + DW_AT_name = "./hello.c" + + */ if (dir_name != NULL) { @@ -16729,22 +17174,47 @@ noop_record_line (struct subfile *subfile, int line, CORE_ADDR pc) return; } +/* Use P_RECORD_LINE to record line number LINE beginning at address ADDRESS + in the line table of subfile SUBFILE. */ + +static void +dwarf_record_line (struct gdbarch *gdbarch, struct subfile *subfile, + unsigned int line, CORE_ADDR address, + record_line_ftype p_record_line) +{ + CORE_ADDR addr = gdbarch_addr_bits_remove (gdbarch, address); + + (*p_record_line) (current_subfile, line, addr); +} + +/* Subroutine of dwarf_decode_lines_1 to simplify it. + Mark the end of a set of line number records. + The arguments are the same as for dwarf_record_line. + If SUBFILE is NULL the request is ignored. */ + +static void +dwarf_finish_line (struct gdbarch *gdbarch, struct subfile *subfile, + CORE_ADDR address, record_line_ftype p_record_line) +{ + if (subfile != NULL) + dwarf_record_line (gdbarch, subfile, 0, address, p_record_line); +} + /* Subroutine of dwarf_decode_lines to simplify it. Process the line number information in LH. */ 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; unsigned int bytes_read, extended_len; - unsigned char op_code, extended_op, adj_opcode; + unsigned char op_code, extended_op; CORE_ADDR baseaddr; 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; @@ -16761,11 +17231,8 @@ 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; if (!decode_for_pst_p && lh->num_file_names >= file) @@ -16796,7 +17263,9 @@ dwarf_decode_lines_1 (struct line_header *lh, const char *comp_dir, if (op_code >= lh->opcode_base) { - /* Special operand. */ + /* Special opcode. */ + unsigned char adj_opcode; + adj_opcode = op_code - lh->opcode_base; address += (((op_index + (adj_opcode / lh->line_range)) / lh->maximum_ops_per_instruction) @@ -16815,17 +17284,15 @@ dwarf_decode_lines_1 (struct line_header *lh, const char *comp_dir, { if (last_subfile != current_subfile) { - addr = gdbarch_addr_bits_remove (gdbarch, address); - if (last_subfile) - (*p_record_line) (last_subfile, 0, addr); + dwarf_finish_line (gdbarch, last_subfile, + address, p_record_line); last_subfile = current_subfile; } /* Append row to matrix using current values. */ - addr = gdbarch_addr_bits_remove (gdbarch, address); - (*p_record_line) (current_subfile, line, addr); + dwarf_record_line (gdbarch, current_subfile, + line, address, p_record_line); } } - basic_block = 0; } else switch (op_code) { @@ -16858,6 +17325,8 @@ dwarf_decode_lines_1 (struct line_header *lh, const char *comp_dir, "[in module %s]"), line_offset, objfile_name (objfile)); p_record_line = noop_record_line; + /* Note: p_record_line is left as noop_record_line + until we see DW_LNE_end_sequence. */ } op_index = 0; @@ -16914,16 +17383,14 @@ dwarf_decode_lines_1 (struct line_header *lh, const char *comp_dir, { if (last_subfile != current_subfile) { - addr = gdbarch_addr_bits_remove (gdbarch, address); - if (last_subfile) - (*p_record_line) (last_subfile, 0, addr); + dwarf_finish_line (gdbarch, last_subfile, + address, p_record_line); last_subfile = current_subfile; } - addr = gdbarch_addr_bits_remove (gdbarch, address); - (*p_record_line) (current_subfile, line, addr); + dwarf_record_line (gdbarch, current_subfile, + line, address, p_record_line); } } - basic_block = 0; break; case DW_LNS_advance_pc: { @@ -16968,14 +17435,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 @@ -17018,8 +17484,8 @@ dwarf_decode_lines_1 (struct line_header *lh, const char *comp_dir, lh->file_names[file - 1].included_p = 1; if (!decode_for_pst_p) { - addr = gdbarch_addr_bits_remove (gdbarch, address); - (*p_record_line) (current_subfile, 0, addr); + dwarf_finish_line (gdbarch, current_subfile, address, + p_record_line); } } } @@ -17057,7 +17523,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) { @@ -17329,9 +17795,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; @@ -17584,10 +18049,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; @@ -18137,7 +18608,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); } @@ -18183,7 +18654,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)); } @@ -18333,6 +18804,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); } @@ -18514,8 +18994,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); @@ -18538,7 +19019,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); @@ -21213,6 +21694,8 @@ set_die_type (struct die_info *die, struct type *type, struct dwarf2_cu *cu) { struct dwarf2_per_cu_offset_and_type **slot, ofs; struct objfile *objfile = cu->objfile; + struct attribute *attr; + struct dynamic_prop prop; /* For Ada types, make sure that the gnat-specific data is always initialized (if not already set). There are a few types where @@ -21227,6 +21710,15 @@ set_die_type (struct die_info *die, struct type *type, struct dwarf2_cu *cu) && !HAVE_GNAT_AUX_INFO (type)) INIT_GNAT_SPECIFIC (type); + /* Read DW_AT_data_location and set in type. */ + attr = dwarf2_attr (die, DW_AT_data_location, cu); + if (attr_to_dynamic_prop (attr, die, cu, &prop)) + { + TYPE_DATA_LOCATION (type) + = obstack_alloc (&objfile->objfile_obstack, sizeof (prop)); + *TYPE_DATA_LOCATION (type) = prop; + } + if (dwarf2_per_objfile->die_type_hash == NULL) { dwarf2_per_objfile->die_type_hash = @@ -21382,7 +21874,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