This is the mail archive of the
gdb-patches@sources.redhat.com
mailing list for the GDB project.
Re: [rfa/dwarf] Support for attributes pointing to a different CU
- From: Daniel Jacobowitz <drow at false dot org>
- To: Jim Blandy <jimb at redhat dot com>
- Cc: gdb-patches at sources dot redhat dot com
- Date: Thu, 23 Sep 2004 20:34:13 -0400
- Subject: Re: [rfa/dwarf] Support for attributes pointing to a different CU
- References: <20040923045723.GA11871@nevyn.them.org> <vt2u0tobpf1.fsf@zenia.home>
On Thu, Sep 23, 2004 at 05:17:54PM -0500, Jim Blandy wrote:
>
> Daniel Jacobowitz <drow@false.org> writes:
> > This is the last logical piece I could break out of the intercu support.
> > We're almost there. Only things left after this are dependence tracking
> > and the queueing of multiple full CUs - 400 lines or so.
> >
> > The core change of this patch is in follow_die_ref. Instead of taking an
> > offset and returning a DIE, it now takes an attribute and the CU in which
> > the attribute was found, and returns a DIE and the CU in which the DIE
> > was found.
> >
> > The bulky text change of this patch is in dwarf2_attr. It divides into two
> > interfaces: anywhere that we are prepared to find a reference to another
> > DIE, we need to call dwarf2_attr_with_cu instead. Then, any further
> > operations on the returned reference need to be sure to use the returned CU.
> > The reason for this is a little subtle - we're returning a reference. If
> > the reference is, for example, DW_FORM_ref4, then it's an offset within some
> > particular CU. If the attribute containing this reference was found by
> > chasing DW_AT_specification, and DW_AT_specification was DW_FORM_ref_addr,
> > then the return value of dwarf2_attr_with_cu is a relative offset to a
> > different CU than the caller passed in. So if we are going to follow the
> > reference, we need to know the compilation unit in which it resides.
>
> I may be missing something, but it seems to me some of this effort is
> necessary because we hold some die references as CU-relative, and
> others as .debug_info relative, depending on the form the attribute
> happened to use. Wouldn't it be a simplification to have
> read_attribute_value always store all DW_FORM_ref* attributes as
> DW_ADDR offsets from the beginning of .debug_info? Then dwarf2_attr's
> interface could remain unchanged, and we could drop all the spec_cu
> variables carrying the CU to the next call to
> dwarf2_get_ref_die_offset. Then, dwarf2_get_ref_die_offset could be
> deleted altogether, and its calls replaced with uses of DW_ADDR.
>
> (This change wasn't possible in the past because we didn't pass a CU
> to dwarf2_attr.)
Actually, it doesn't matter - dwarf2_attr doesn't need the CU for this
anyway. This suggestion killed basically all of the previous patch;
there's not enough to bother breaking apart, so I'm including it with
the final bits. Here they are.
The die_ref_table moves from global into the dwarf2_cu structure.
I apply your suggestion to partial DIE following, resulting in the
deletion of a bunch of one of my previous patches. I also apply it to
full DIE reference following. This results in a certain amount of
shuffling of deck chairs.
There's a little bit of new code to make sure that, during full symbol
reading, we can get at the psymtab from the per_cu structure.
psymtab_to_symtab_1 is broken into two halves, to load the DIEs and to
generate symbols from them. If we're in inter-compilation-unit mode,
we read all the DIEs we'll need before we process any of them. New CUs
are loaded by adding them to the queue in read_full_die when we
encounter a reference pointing at them. When this happens, we also
record the dependency of the first CU on the second, so that it is not
flushed from cache before the CU that references it - we need to do
this so that references to other CUs don't trigger loading of the CU at
an unexpected time, breaking the load-then-process invariant.
The breaking up into two halves also results in a certain amount of
deck shuffling, because cu becomes a pointer instead of a stack
variable. The only interesting bit in what used to be
psymtab_to_symtab_1 is the hunk at old line 2372 in the diff.
I've tried to make it as clear as possible. If you see anything you'd
prefer as a separate patch, let me know.
OK?
--
Daniel Jacobowitz
2004-09-23 Daniel Jacobowitz <dan@debian.org>
* dwarf2read.c (REF_HASH_SIZE): Move earlier.
(die_ref_table): Remove.
(struct dwarf2_cu): Add DIES, DEPENDENCIES, and DIE_REF_TABLE.
(struct dwarf2_per_cu_data): Add PSYMTAB.
(struct dwarf2_queue_item, dwarf2_queue): New.
(find_partial_die): Remove third argument.
(type_at_offset): Remove dead code.
(make_cleanup_free_die_list, dwarf2_empty_hash_tables): Remove.
(store_in_ref_table): Add CU argument.
(follow_die_ref): Take DIE, attribute, and CU arguments. Handle
inter-compilation-unit references.
(dwarf2_find_comp_unit_psymtab): New function.
(load_full_comp_unit, process_full_comp_unit): New functions, based
on psymtab_to_symtab_1.
(psymtab_to_symtab_1): Use them.
(dwarf2_add_dependence): New function.
(dwarf2_build_psymtabs_hard): Set the psymtab in per_cu.
(partial_die_parent_scope, guess_structure_name): Update for changes
to find_partial_die.
(dwarf2_psymtab_to_symtab): Initialize dwarf2_per_objfile here.
(queue_comp_unit, process_queue, dwarf2_release_queue): New.
(read_subrange_type): Add a comment.
(read_comp_unit): Don't call dwarf2_empty_hash_tables.
(read_die_and_children): Update call to store_in_ref_table.
(do_free_die_list_cleanup): Remove.
(fixup_partial_die): Update for changes to find_partial_die.
(read_full_die): Handle queueing absolute references.
(read_attribute_value): Use DW_ADDR for all DW_FORM_ref* forms.
(dwarf2_attr, die_specification, die_type)
(die_containing_type, dwarf2_extension): Update calls to
follow_die_ref.
(dump_die): Update DW_FORM_ref* handling.
(dwarf2_get_ref_die_offset): Likewise.
(free_one_comp_unit): Release the dies list.
(dwarf2_mark_helper): New function.
(dwarf2_mark): Use it.
--- src/gdb/dwarf2read.c 2004-09-23 18:58:04.000000000 -0400
+++ src/gdb/dwarf2read.c 2004-09-23 20:25:21.000000000 -0400
@@ -258,6 +258,11 @@ struct comp_unit_head
int base_known;
};
+/* Fixed size for the DIE hash table. */
+#ifndef REF_HASH_SIZE
+#define REF_HASH_SIZE 1021
+#endif
+
/* Internal state when decoding a particular compilation unit. */
struct dwarf2_cu
{
@@ -325,6 +330,17 @@ struct dwarf2_cu
/* How many compilation units ago was this CU last referenced? */
int last_used;
+ /* A hash table of die offsets for following references. */
+ struct die_info *die_ref_table[REF_HASH_SIZE];
+
+ /* Full DIEs if read in. */
+ struct die_info *dies;
+
+ /* A set of pointers to dwarf2_per_cu_data objects for compilation
+ units referenced by this one. Only set during full symbol processing;
+ partial symbol tables do not have dependencies. */
+ htab_t dependencies;
+
/* Mark used when releasing cached dies. */
unsigned int mark : 1;
@@ -360,6 +376,11 @@ struct dwarf2_per_cu_data
it. */
htab_t type_hash;
+
+ /* The partial symbol table associated with this compilation unit. This
+ is set opportunistically during partial symbol reading, and guaranteed
+ initialized before full DIEs are read in. */
+ struct partial_symtab *psymtab;
};
/* The line number information for a compilation unit (found in the
@@ -551,13 +572,6 @@ struct dwarf_block
#define ATTR_ALLOC_CHUNK 4
#endif
-/* A hash table of die offsets for following references. */
-#ifndef REF_HASH_SIZE
-#define REF_HASH_SIZE 1021
-#endif
-
-static struct die_info *die_ref_table[REF_HASH_SIZE];
-
/* Allocate fields for structs, unions and enums in this size. */
#ifndef DW_FIELD_ALLOC_CHUNK
#define DW_FIELD_ALLOC_CHUNK 4
@@ -641,6 +655,17 @@ struct field_info
int nfnfields;
};
+/* One item on the queue of compilation units to read in full symbols
+ for. */
+struct dwarf2_queue_item
+{
+ struct dwarf2_per_cu_data *per_cu;
+ struct dwarf2_queue_item *next;
+};
+
+/* The current queue. */
+static struct dwarf2_queue_item *dwarf2_queue;
+
/* Loaded secondary compilation units are kept in memory until they
have not been referenced for the processing of this many
compilation units. Set this to zero to disable caching. Cache
@@ -755,8 +780,7 @@ static char *read_partial_die (struct pa
bfd *, char *, struct dwarf2_cu *);
static struct partial_die_info *find_partial_die (unsigned long,
- struct dwarf2_cu *,
- struct dwarf2_cu **);
+ struct dwarf2_cu *);
static void fixup_partial_die (struct partial_die_info *,
struct dwarf2_cu *);
@@ -844,10 +868,6 @@ static struct type *die_type (struct die
static struct type *die_containing_type (struct die_info *,
struct dwarf2_cu *);
-#if 0
-static struct type *type_at_offset (unsigned int, struct objfile *);
-#endif
-
static struct type *tag_type_to_type (struct die_info *, struct dwarf2_cu *);
static void read_type_die (struct die_info *, struct dwarf2_cu *);
@@ -944,8 +964,6 @@ static struct die_info *read_die_and_sib
static void free_die_list (struct die_info *);
-static struct cleanup *make_cleanup_free_die_list (struct die_info *);
-
static void process_die (struct die_info *, struct dwarf2_cu *);
static char *dwarf2_linkage_name (struct die_info *, struct dwarf2_cu *);
@@ -979,16 +997,17 @@ static void dump_die (struct die_info *)
static void dump_die_list (struct die_info *);
-static void store_in_ref_table (unsigned int, struct die_info *);
-
-static void dwarf2_empty_hash_tables (void);
+static void store_in_ref_table (unsigned int, struct die_info *,
+ struct dwarf2_cu *);
static unsigned int dwarf2_get_ref_die_offset (struct attribute *,
struct dwarf2_cu *);
static int dwarf2_get_attr_constant_value (struct attribute *, int);
-static struct die_info *follow_die_ref (unsigned int);
+static struct die_info *follow_die_ref (struct die_info *,
+ struct attribute *,
+ struct dwarf2_cu *);
static struct type *dwarf2_fundamental_type (struct objfile *, int,
struct dwarf2_cu *);
@@ -1034,6 +1053,9 @@ static struct dwarf2_per_cu_data *dwarf2
static struct dwarf2_per_cu_data *dwarf2_find_comp_unit
(unsigned long offset, struct objfile *objfile);
+static struct partial_symtab *dwarf2_find_comp_unit_psymtab
+ (unsigned int offset, struct objfile *objfile);
+
static void free_one_comp_unit (void *);
static void free_cached_comp_units (void *);
@@ -1045,13 +1067,20 @@ static void free_one_cached_comp_unit (v
static void set_die_type (struct die_info *, struct type *,
struct dwarf2_cu *);
-#if 0
static void reset_die_and_siblings_types (struct die_info *,
struct dwarf2_cu *);
-#endif
static void create_all_comp_units (struct objfile *);
+static struct dwarf2_cu *load_full_comp_unit (struct partial_symtab *,
+ struct dwarf2_per_cu_data *);
+
+static void process_full_comp_unit (struct partial_symtab *,
+ struct dwarf2_cu *);
+
+static void dwarf2_add_dependence (struct dwarf2_cu *,
+ struct dwarf2_per_cu_data *);
+
static void dwarf2_mark (struct dwarf2_cu *);
static void dwarf2_clear_marks (struct dwarf2_per_cu_data *);
@@ -1486,6 +1515,8 @@ dwarf2_build_psymtabs_hard (struct objfi
in free_stack_comp_unit when we finish with this
compilation unit. */
per_cu->cu = &cu;
+
+ per_cu->psymtab = pst;
}
else
cu.per_cu = NULL;
@@ -1778,15 +1809,13 @@ partial_die_parent_scope (struct partial
{
char *grandparent_scope;
struct partial_die_info *parent, *real_pdi;
- struct dwarf2_cu *spec_cu;
/* We need to look at our parent DIE; if we have a DW_AT_specification,
then this means the parent of the specification DIE. */
real_pdi = pdi;
- spec_cu = cu;
while (real_pdi->has_specification)
- real_pdi = find_partial_die (real_pdi->spec_offset, spec_cu, &spec_cu);
+ real_pdi = find_partial_die (real_pdi->spec_offset, cu);
parent = real_pdi->die_parent;
if (parent == NULL)
@@ -1797,7 +1826,7 @@ partial_die_parent_scope (struct partial
fixup_partial_die (parent, cu);
- grandparent_scope = partial_die_parent_scope (parent, spec_cu);
+ grandparent_scope = partial_die_parent_scope (parent, cu);
if (parent->tag == DW_TAG_namespace
|| parent->tag == DW_TAG_structure_type
@@ -2071,16 +2100,14 @@ guess_structure_name (struct partial_die
struct partial_die_info *child_pdi = struct_pdi->die_child;
struct partial_die_info *real_pdi;
- struct dwarf2_cu *spec_cu;
/* If this DIE (this DIE's specification, if any) has a parent, then
we should not do this. We'll prepend the parent's fully qualified
name when we create the partial symbol. */
real_pdi = struct_pdi;
- spec_cu = cu;
while (real_pdi->has_specification)
- real_pdi = find_partial_die (real_pdi->spec_offset, spec_cu, &spec_cu);
+ real_pdi = find_partial_die (real_pdi->spec_offset, cu);
if (real_pdi->die_parent != NULL)
return;
@@ -2321,6 +2348,10 @@ dwarf2_psymtab_to_symtab (struct partial
gdb_flush (gdb_stdout);
}
+ /* Restore our global data. */
+ dwarf2_per_objfile = objfile_data (pst->objfile,
+ dwarf2_objfile_data_key);
+
psymtab_to_symtab_1 (pst);
/* Finish up the debug error message. */
@@ -2330,21 +2361,115 @@ dwarf2_psymtab_to_symtab (struct partial
}
}
+/* Add PER_CU to the queue. */
+
+static void
+queue_comp_unit (struct dwarf2_per_cu_data *per_cu)
+{
+ struct dwarf2_queue_item *item;
+
+ per_cu->queued = 1;
+ item = xmalloc (sizeof (*item));
+ item->per_cu = per_cu;
+ item->next = dwarf2_queue;
+ dwarf2_queue = item;
+}
+
+/* Process the queue. */
+
+static void
+process_queue (struct objfile *objfile)
+{
+ struct dwarf2_queue_item *item, *last;
+
+ /* Initially, there is just one item on the queue. Load its DIEs,
+ and the DIEs of any other compilation units it requires,
+ transitively. */
+
+ while (dwarf2_queue->per_cu->cu == NULL)
+ {
+ item = dwarf2_queue;
+ while (item && item->per_cu->cu == NULL)
+ {
+ if (item->per_cu->psymtab == NULL)
+ item->per_cu->psymtab
+ = dwarf2_find_comp_unit_psymtab (item->per_cu->offset, objfile);
+ load_full_comp_unit (item->per_cu->psymtab, item->per_cu);
+
+ item->per_cu->cu->read_in_chain = dwarf2_per_objfile->read_in_chain;
+ dwarf2_per_objfile->read_in_chain = item->per_cu;
+
+ item = item->next;
+ }
+ }
+
+ /* We have now queued everything we will need, and loaded DIEs for
+ all queued CUs. For any that have already been read in, reset
+ the TYPE field in each DIE. */
+ item = dwarf2_queue;
+ while (item)
+ {
+ if (item->per_cu->psymtab->readin)
+ {
+ reset_die_and_siblings_types (item->per_cu->cu->dies,
+ item->per_cu->cu);
+ item->per_cu->queued = 0;
+ }
+ item = item->next;
+ }
+
+ /* Now everything left on the queue needs to be read in. Process
+ them, one at a time, removing from the queue as we finish. */
+ item = dwarf2_queue;
+ while (item)
+ {
+ if (!item->per_cu->psymtab->readin)
+ {
+ process_full_comp_unit (item->per_cu->psymtab,
+ item->per_cu->cu);
+ item->per_cu->queued = 0;
+ }
+ last = item;
+ dwarf2_queue = item = last->next;
+ xfree (last);
+ }
+}
+
+/* Free all allocated queue entries. This function only releases anything if
+ an error was thrown; if the queue was processed then it would have been
+ freed as we went along. */
+
+static void
+dwarf2_release_queue (void *dummy)
+{
+ struct dwarf2_queue_item *item, *last;
+
+ item = dwarf2_queue;
+ while (item)
+ {
+ /* Anything still marked queued is likely to be in an
+ inconsistent state, so discard it. */
+ if (item->per_cu->queued)
+ {
+ if (item->per_cu->cu != NULL)
+ free_one_cached_comp_unit (item->per_cu->cu);
+ item->per_cu->queued = 0;
+ }
+
+ last = item;
+ item = item->next;
+ xfree (last);
+ }
+
+ dwarf2_queue = NULL;
+}
+
+/* Read in full symbols for PST, and anything it depends on. */
+
static void
psymtab_to_symtab_1 (struct partial_symtab *pst)
{
- struct objfile *objfile = pst->objfile;
- bfd *abfd = objfile->obfd;
- struct dwarf2_cu cu;
- struct die_info *dies;
- unsigned long offset;
- CORE_ADDR lowpc, highpc;
- struct die_info *child_die;
- char *info_ptr;
- struct symtab *symtab;
struct cleanup *back_to;
- struct attribute *attr;
- CORE_ADDR baseaddr;
int i;
for (i = 0; i < pst->number_of_dependencies; i++)
@@ -2372,40 +2497,126 @@ psymtab_to_symtab_1 (struct partial_symt
return;
}
- dwarf2_per_objfile = objfile_data (pst->objfile, dwarf2_objfile_data_key);
+ back_to = make_cleanup (null_cleanup, NULL);
+
+ if (dwarf2_per_objfile->all_comp_units == NULL)
+ {
+ struct dwarf2_cu *cu;
+ cu = load_full_comp_unit (pst, NULL);
+ make_cleanup (free_one_comp_unit, cu);
+ process_full_comp_unit (pst, cu);
+ }
+ else
+ {
+ struct dwarf2_per_cu_data *per_cu;
+ unsigned long offset;
+
+ offset = DWARF_INFO_OFFSET (pst);
+ per_cu = dwarf2_find_comp_unit (offset, pst->objfile);
+
+ per_cu->psymtab = pst;
+
+ make_cleanup (dwarf2_release_queue, NULL);
+
+ queue_comp_unit (per_cu);
+
+ process_queue (pst->objfile);
+
+ /* Age the cache, releasing compilation units that have not
+ been used recently. */
+ age_cached_comp_units ();
+ }
+
+ do_cleanups (back_to);
+}
+
+/* Load the DIEs associated with PST and PER_CU into memory. */
+
+static struct dwarf2_cu *
+load_full_comp_unit (struct partial_symtab *pst,
+ struct dwarf2_per_cu_data *per_cu)
+{
+ bfd *abfd = pst->objfile->obfd;
+ struct dwarf2_cu *cu;
+ unsigned long offset;
+ char *info_ptr;
+ struct cleanup *back_to, *free_cu_cleanup;
+ struct attribute *attr;
+ CORE_ADDR baseaddr;
/* Set local variables from the partial symbol table info. */
offset = DWARF_INFO_OFFSET (pst);
info_ptr = dwarf2_per_objfile->info_buffer + offset;
- baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
-
- /* We're in the global namespace. */
- processing_current_prefix = "";
- memset (&cu, 0, sizeof (struct dwarf2_cu));
- obstack_init (&cu.comp_unit_obstack);
- back_to = make_cleanup (free_stack_comp_unit, &cu);
+ cu = xmalloc (sizeof (struct dwarf2_cu));
+ memset (cu, 0, sizeof (struct dwarf2_cu));
- buildsym_init ();
- make_cleanup (really_free_pendings, NULL);
+ /* If an error occurs while loading, release our storage. */
+ free_cu_cleanup = make_cleanup (free_one_comp_unit, cu);
- cu.objfile = objfile;
+ cu->objfile = pst->objfile;
/* read in the comp_unit header */
- info_ptr = read_comp_unit_head (&cu.header, info_ptr, abfd);
+ info_ptr = read_comp_unit_head (&cu->header, info_ptr, abfd);
/* Read the abbrevs for this compilation unit */
- dwarf2_read_abbrevs (abfd, &cu);
- make_cleanup (dwarf2_free_abbrev_table, &cu);
+ dwarf2_read_abbrevs (abfd, cu);
+ back_to = make_cleanup (dwarf2_free_abbrev_table, cu);
+
+ cu->header.offset = offset;
+
+ cu->per_cu = per_cu;
+ if (cu->per_cu)
+ per_cu->cu = cu;
+
+ /* We use this obstack for block values in dwarf_alloc_block. */
+ obstack_init (&cu->comp_unit_obstack);
+
+ cu->dies = read_comp_unit (info_ptr, abfd, cu);
+
+ /* We try not to read any attributes in this function, because not
+ all objfiles needed for references have been loaded yet, and symbol
+ table processing isn't initialized. But we have to set the CU language,
+ or we won't be able to build types correctly. */
+ attr = dwarf2_attr (cu->dies, DW_AT_language, cu);
+ if (attr)
+ set_cu_language (DW_UNSND (attr), cu);
+ else
+ set_cu_language (language_minimal, cu);
+
+ do_cleanups (back_to);
- cu.header.offset = offset;
+ /* We've successfully allocated this compilation unit. Let our caller
+ clean it up when finished with it. */
+ discard_cleanups (free_cu_cleanup);
- cu.list_in_scope = &file_symbols;
+ return cu;
+}
- dies = read_comp_unit (info_ptr, abfd, &cu);
+/* Generate full symbol information for PST and CU, whose DIEs have
+ already been loaded into memory. */
- make_cleanup_free_die_list (dies);
+static void
+process_full_comp_unit (struct partial_symtab *pst, struct dwarf2_cu *cu)
+{
+ struct objfile *objfile = pst->objfile;
+ bfd *abfd = objfile->obfd;
+ CORE_ADDR lowpc, highpc;
+ struct symtab *symtab;
+ struct cleanup *back_to;
+ struct attribute *attr;
+ CORE_ADDR baseaddr;
+
+ baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
+
+ /* We're in the global namespace. */
+ processing_current_prefix = "";
+
+ buildsym_init ();
+ back_to = make_cleanup (really_free_pendings, NULL);
+
+ cu->list_in_scope = &file_symbols;
/* Find the base address of the compilation unit for range lists and
location lists. It will normally be specified by DW_AT_low_pc.
@@ -2413,32 +2624,32 @@ psymtab_to_symtab_1 (struct partial_symt
DW_AT_entry_pc. It's been removed, but GCC still uses this for
compilation units with discontinuous ranges. */
- cu.header.base_known = 0;
- cu.header.base_address = 0;
+ cu->header.base_known = 0;
+ cu->header.base_address = 0;
- attr = dwarf2_attr (dies, DW_AT_entry_pc, &cu);
+ attr = dwarf2_attr (cu->dies, DW_AT_entry_pc, cu);
if (attr)
{
- cu.header.base_address = DW_ADDR (attr);
- cu.header.base_known = 1;
+ cu->header.base_address = DW_ADDR (attr);
+ cu->header.base_known = 1;
}
else
{
- attr = dwarf2_attr (dies, DW_AT_low_pc, &cu);
+ attr = dwarf2_attr (cu->dies, DW_AT_low_pc, cu);
if (attr)
{
- cu.header.base_address = DW_ADDR (attr);
- cu.header.base_known = 1;
+ cu->header.base_address = DW_ADDR (attr);
+ cu->header.base_known = 1;
}
}
/* Do line number decoding in read_file_scope () */
- process_die (dies, &cu);
+ process_die (cu->dies, cu);
/* Some compilers don't define a DW_AT_high_pc attribute for the
compilation unit. If the DW_AT_high_pc is missing, synthesize
it, by scanning the DIE's below the compilation unit. */
- get_scope_pc_bounds (dies, &lowpc, &highpc, &cu);
+ get_scope_pc_bounds (cu->dies, &lowpc, &highpc, cu);
symtab = end_symtab (highpc + baseaddr, objfile, SECT_OFF_TEXT (objfile));
@@ -2446,9 +2657,9 @@ psymtab_to_symtab_1 (struct partial_symt
If the compilation is from a C file generated by language preprocessors,
do not set the language if it was already deduced by start_subfile. */
if (symtab != NULL
- && !(cu.language == language_c && symtab->language != language_c))
+ && !(cu->language == language_c && symtab->language != language_c))
{
- symtab->language = cu.language;
+ symtab->language = cu->language;
}
pst->symtab = symtab;
pst->readin = 1;
@@ -4610,6 +4821,9 @@ read_subrange_type (struct die_info *die
low = 1;
}
+ /* 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, 0);
@@ -4655,10 +4869,6 @@ read_subrange_type (struct die_info *die
static struct die_info *
read_comp_unit (char *info_ptr, bfd *abfd, struct dwarf2_cu *cu)
{
- /* Reset die reference table; we are
- building new ones now. */
- dwarf2_empty_hash_tables ();
-
return read_die_and_children (info_ptr, abfd, cu, &info_ptr, NULL);
}
@@ -4679,7 +4889,7 @@ read_die_and_children (char *info_ptr, b
int has_children;
cur_ptr = read_full_die (&die, abfd, info_ptr, cu, &has_children);
- store_in_ref_table (die->offset, die);
+ store_in_ref_table (die->offset, die, cu);
if (has_children)
{
@@ -4758,19 +4968,6 @@ free_die_list (struct die_info *dies)
}
}
-static void
-do_free_die_list_cleanup (void *dies)
-{
- free_die_list (dies);
-}
-
-static struct cleanup *
-make_cleanup_free_die_list (struct die_info *dies)
-{
- return make_cleanup (do_free_die_list_cleanup, dies);
-}
-
-
/* Read the contents of the section at OFFSET and of size SIZE from the
object file specified by OBJFILE into the objfile_obstack and return it. */
@@ -5310,17 +5507,13 @@ find_partial_die_in_comp_unit (unsigned
/* Find a partial DIE at OFFSET, which may or may not be in CU. */
static struct partial_die_info *
-find_partial_die (unsigned long offset, struct dwarf2_cu *cu,
- struct dwarf2_cu **target_cu)
+find_partial_die (unsigned long offset, struct dwarf2_cu *cu)
{
struct dwarf2_per_cu_data *per_cu;
if (offset >= cu->header.offset
&& offset < cu->header.offset + cu->header.length)
- {
- *target_cu = cu;
- return find_partial_die_in_comp_unit (offset, cu);
- }
+ return find_partial_die_in_comp_unit (offset, cu);
per_cu = dwarf2_find_containing_comp_unit (offset, cu->objfile);
@@ -5339,7 +5532,6 @@ find_partial_die (unsigned long offset,
}
per_cu->cu->last_used = 0;
- *target_cu = per_cu->cu;
return find_partial_die_in_comp_unit (offset, per_cu->cu);
}
@@ -5356,11 +5548,10 @@ fixup_partial_die (struct partial_die_in
if (part_die->name == NULL && part_die->has_specification)
{
struct partial_die_info *spec_die;
- struct dwarf2_cu *spec_cu;
- spec_die = find_partial_die (part_die->spec_offset, cu, &spec_cu);
+ spec_die = find_partial_die (part_die->spec_offset, cu);
- fixup_partial_die (spec_die, spec_cu);
+ fixup_partial_die (spec_die, cu);
if (spec_die->name)
{
@@ -5434,6 +5625,38 @@ read_full_die (struct die_info **diep, b
{
info_ptr = read_attribute (&die->attrs[i], &abbrev->attrs[i],
abfd, info_ptr, cu);
+
+ /* If this attribute is an absolute reference to a different
+ compilation unit, make sure that compilation unit is loaded
+ also. */
+ if (die->attrs[i].form == DW_FORM_ref_addr
+ && (DW_ADDR (&die->attrs[i]) < cu->header.offset
+ || (DW_ADDR (&die->attrs[i])
+ >= cu->header.offset + cu->header.length)))
+ {
+ struct dwarf2_per_cu_data *per_cu;
+ per_cu = dwarf2_find_containing_comp_unit (DW_ADDR (&die->attrs[i]),
+ cu->objfile);
+
+ /* Mark the dependence relation so that we don't flush PER_CU
+ too early. */
+ dwarf2_add_dependence (cu, per_cu);
+
+ /* If it's already on the queue, we have nothing to do. */
+ if (per_cu->queued)
+ continue;
+
+ /* If the compilation unit is already loaded, just mark it as
+ used. */
+ if (per_cu->cu != NULL)
+ {
+ per_cu->cu->last_used = 0;
+ continue;
+ }
+
+ /* Add it to the queue. */
+ queue_comp_unit (per_cu);
+ }
}
*diep = die;
@@ -5530,23 +5753,24 @@ read_attribute_value (struct attribute *
info_ptr += bytes_read;
break;
case DW_FORM_ref1:
- DW_UNSND (attr) = read_1_byte (abfd, info_ptr);
+ DW_ADDR (attr) = cu->header.offset + read_1_byte (abfd, info_ptr);
info_ptr += 1;
break;
case DW_FORM_ref2:
- DW_UNSND (attr) = read_2_bytes (abfd, info_ptr);
+ DW_ADDR (attr) = cu->header.offset + read_2_bytes (abfd, info_ptr);
info_ptr += 2;
break;
case DW_FORM_ref4:
- DW_UNSND (attr) = read_4_bytes (abfd, info_ptr);
+ DW_ADDR (attr) = cu->header.offset + read_4_bytes (abfd, info_ptr);
info_ptr += 4;
break;
case DW_FORM_ref8:
- DW_UNSND (attr) = read_8_bytes (abfd, info_ptr);
+ DW_ADDR (attr) = cu->header.offset + read_8_bytes (abfd, info_ptr);
info_ptr += 8;
break;
case DW_FORM_ref_udata:
- DW_UNSND (attr) = read_unsigned_leb128 (abfd, info_ptr, &bytes_read);
+ DW_ADDR (attr) = (cu->header.offset
+ + read_unsigned_leb128 (abfd, info_ptr, &bytes_read));
info_ptr += bytes_read;
break;
case DW_FORM_indirect:
@@ -5954,21 +6178,14 @@ dwarf2_attr (struct die_info *die, unsig
for (i = 0; i < die->num_attrs; ++i)
{
if (die->attrs[i].name == name)
- {
- return &die->attrs[i];
- }
+ return &die->attrs[i];
if (die->attrs[i].name == DW_AT_specification
|| die->attrs[i].name == DW_AT_abstract_origin)
spec = &die->attrs[i];
}
- if (spec)
- {
- struct die_info *ref_die =
- follow_die_ref (dwarf2_get_ref_die_offset (spec, cu));
- if (ref_die)
- return dwarf2_attr (ref_die, name, cu);
- }
+ if (spec)
+ return dwarf2_attr (follow_die_ref (die, spec, cu), name, cu);
return NULL;
}
@@ -6010,7 +6227,7 @@ die_specification (struct die_info *die,
if (spec_attr == NULL)
return NULL;
else
- return follow_die_ref (dwarf2_get_ref_die_offset (spec_attr, cu));
+ return follow_die_ref (die, spec_attr, cu);
}
/* Free the line_header structure *LH, and any arrays and strings it
@@ -6941,7 +7158,6 @@ die_type (struct die_info *die, struct d
struct type *type;
struct attribute *type_attr;
struct die_info *type_die;
- unsigned int ref;
type_attr = dwarf2_attr (die, DW_AT_type, cu);
if (!type_attr)
@@ -6950,16 +7166,8 @@ die_type (struct die_info *die, struct d
return dwarf2_fundamental_type (cu->objfile, FT_VOID, cu);
}
else
- {
- ref = dwarf2_get_ref_die_offset (type_attr, cu);
- type_die = follow_die_ref (ref);
- if (!type_die)
- {
- error ("Dwarf Error: Cannot find referent at offset %d [in module %s]",
- ref, cu->objfile->name);
- return NULL;
- }
- }
+ type_die = follow_die_ref (die, type_attr, cu);
+
type = tag_type_to_type (type_die, cu);
if (!type)
{
@@ -6979,19 +7187,11 @@ die_containing_type (struct die_info *di
struct type *type = NULL;
struct attribute *type_attr;
struct die_info *type_die = NULL;
- unsigned int ref;
type_attr = dwarf2_attr (die, DW_AT_containing_type, cu);
if (type_attr)
{
- ref = dwarf2_get_ref_die_offset (type_attr, cu);
- type_die = follow_die_ref (ref);
- if (!type_die)
- {
- error ("Dwarf Error: Cannot find referent at offset %d [in module %s]", ref,
- cu->objfile->name);
- return NULL;
- }
+ type_die = follow_die_ref (die, type_attr, cu);
type = tag_type_to_type (type_die, cu);
}
if (!type)
@@ -7004,24 +7204,6 @@ die_containing_type (struct die_info *di
return type;
}
-#if 0
-static struct type *
-type_at_offset (unsigned int offset, struct dwarf2_cu *cu)
-{
- struct die_info *die;
- struct type *type;
-
- die = follow_die_ref (offset);
- if (!die)
- {
- error ("Dwarf Error: Cannot find type referent at offset %d.", offset);
- return NULL;
- }
- type = tag_type_to_type (die, cu);
- return type;
-}
-#endif
-
static struct type *
tag_type_to_type (struct die_info *die, struct dwarf2_cu *cu)
{
@@ -7375,21 +7557,12 @@ static struct die_info *
dwarf2_extension (struct die_info *die, struct dwarf2_cu *cu)
{
struct attribute *attr;
- struct die_info *extension_die;
- unsigned int ref;
attr = dwarf2_attr (die, DW_AT_extension, cu);
if (attr == NULL)
return NULL;
- ref = dwarf2_get_ref_die_offset (attr, cu);
- extension_die = follow_die_ref (ref);
- if (!extension_die)
- {
- error ("Dwarf Error: Cannot find referent at offset %d.", ref);
- }
-
- return extension_die;
+ return follow_die_ref (die, attr, cu);
}
/* Convert a DIE tag into its string name. */
@@ -8226,13 +8399,16 @@ dump_die (struct die_info *die)
case DW_FORM_block1:
fprintf_unfiltered (gdb_stderr, "block: size %d", DW_BLOCK (&die->attrs[i])->size);
break;
+ case DW_FORM_ref1:
+ case DW_FORM_ref2:
+ case DW_FORM_ref4:
+ fprintf_unfiltered (gdb_stderr, "constant ref: %ld (adjusted)",
+ (long) (DW_ADDR (&die->attrs[i])));
+ break;
case DW_FORM_data1:
case DW_FORM_data2:
case DW_FORM_data4:
case DW_FORM_data8:
- case DW_FORM_ref1:
- case DW_FORM_ref2:
- case DW_FORM_ref4:
case DW_FORM_udata:
case DW_FORM_sdata:
fprintf_unfiltered (gdb_stderr, "constant: %ld", DW_UNSND (&die->attrs[i]));
@@ -8276,22 +8452,16 @@ dump_die_list (struct die_info *die)
}
static void
-store_in_ref_table (unsigned int offset, struct die_info *die)
+store_in_ref_table (unsigned int offset, struct die_info *die,
+ struct dwarf2_cu *cu)
{
int h;
struct die_info *old;
h = (offset % REF_HASH_SIZE);
- old = die_ref_table[h];
+ old = cu->die_ref_table[h];
die->next_ref = old;
- die_ref_table[h] = die;
-}
-
-
-static void
-dwarf2_empty_hash_tables (void)
-{
- memset (die_ref_table, 0, sizeof (die_ref_table));
+ cu->die_ref_table[h] = die;
}
static unsigned int
@@ -8302,14 +8472,12 @@ dwarf2_get_ref_die_offset (struct attrib
switch (attr->form)
{
case DW_FORM_ref_addr:
- result = DW_ADDR (attr);
- break;
case DW_FORM_ref1:
case DW_FORM_ref2:
case DW_FORM_ref4:
case DW_FORM_ref8:
case DW_FORM_ref_udata:
- result = cu->header.offset + DW_UNSND (attr);
+ result = DW_ADDR (attr);
break;
default:
complaint (&symfile_complaints,
@@ -8342,21 +8510,41 @@ dwarf2_get_attr_constant_value (struct a
}
static struct die_info *
-follow_die_ref (unsigned int offset)
+follow_die_ref (struct die_info *src_die, struct attribute *attr,
+ struct dwarf2_cu *cu)
{
struct die_info *die;
+ unsigned int offset;
int h;
+ struct die_info temp_die;
+ struct dwarf2_cu *target_cu;
+
+ offset = dwarf2_get_ref_die_offset (attr, cu);
+
+ if (DW_ADDR (attr) < cu->header.offset
+ || DW_ADDR (attr) >= cu->header.offset + cu->header.length)
+ {
+ struct dwarf2_per_cu_data *per_cu;
+ per_cu = dwarf2_find_containing_comp_unit (DW_ADDR (attr),
+ cu->objfile);
+ target_cu = per_cu->cu;
+ }
+ else
+ target_cu = cu;
h = (offset % REF_HASH_SIZE);
- die = die_ref_table[h];
+ die = target_cu->die_ref_table[h];
while (die)
{
if (die->offset == offset)
- {
- return die;
- }
+ return die;
die = die->next_ref;
}
+
+ error ("Dwarf Error: Cannot find DIE at 0x%lx referenced from DIE "
+ "at 0x%lx [in module %s]",
+ (long) src_die->offset, (long) offset, cu->objfile->name);
+
return NULL;
}
@@ -9138,6 +9326,26 @@ dwarf2_find_comp_unit (unsigned long off
return this_cu;
}
+/* Return the partial_symtab associated with the compilation unit at OFFSET
+ in OBJFILE. Most compilation units will have this field initialized when
+ partial symbols are read, but any initial compilation units (before we
+ created the per_cu structures) will not. */
+static struct partial_symtab *
+dwarf2_find_comp_unit_psymtab (unsigned int offset, struct objfile *objfile)
+{
+ struct partial_symtab *pst;
+
+ ALL_PSYMTABS (objfile, pst)
+ {
+ if (DWARF_INFO_OFFSET (pst) == offset)
+ return pst;
+ }
+
+ internal_error (__FILE__, __LINE__,
+ "could not find partial symtab for offset %d",
+ offset);
+}
+
/* Release one cached compilation unit, CU. We unlink it from the tree
of compilation units, but we don't remove it from the read_in_chain;
the caller is responsible for that. */
@@ -9152,6 +9360,8 @@ free_one_comp_unit (void *data)
cu->per_cu = NULL;
obstack_free (&cu->comp_unit_obstack, NULL);
+ if (cu->dies)
+ free_die_list (cu->dies);
xfree (cu);
}
@@ -9332,8 +9542,6 @@ set_die_type (struct die_info *die, stru
**slot = ofs;
}
-#if 0
-
/* Find the type for DIE in TYPE_HASH, or return NULL if DIE does not
have a saved type. */
@@ -9369,17 +9577,56 @@ reset_die_and_siblings_types (struct die
}
}
-#endif
+/* Set the mark field in CU and in every other compilation unit in the
+ cache that we must keep because we are keeping CU. */
+
+/* Add a dependence relationship from CU to REF_PER_CU. */
+
+static void
+dwarf2_add_dependence (struct dwarf2_cu *cu,
+ struct dwarf2_per_cu_data *ref_per_cu)
+{
+ void **slot;
+
+ if (cu->dependencies == NULL)
+ cu->dependencies
+ = htab_create_alloc_ex (5, htab_hash_pointer, htab_eq_pointer,
+ NULL, &cu->comp_unit_obstack,
+ hashtab_obstack_allocate,
+ dummy_obstack_deallocate);
+
+ slot = htab_find_slot (cu->dependencies, ref_per_cu, INSERT);
+ if (*slot == NULL)
+ *slot = ref_per_cu;
+}
/* Set the mark field in CU and in every other compilation unit in the
cache that we must keep because we are keeping CU. */
+static int
+dwarf2_mark_helper (void **slot, void *data)
+{
+ struct dwarf2_per_cu_data *per_cu;
+
+ per_cu = (struct dwarf2_per_cu_data *) *slot;
+ if (per_cu->cu->mark)
+ return 1;
+ per_cu->cu->mark = 1;
+
+ if (per_cu->cu->dependencies != NULL)
+ htab_traverse (per_cu->cu->dependencies, dwarf2_mark_helper, NULL);
+
+ return 1;
+}
+
static void
dwarf2_mark (struct dwarf2_cu *cu)
{
if (cu->mark)
return;
cu->mark = 1;
+ if (cu->dependencies != NULL)
+ htab_traverse (cu->dependencies, dwarf2_mark_helper, NULL);
}
static void