This is the mail archive of the
gdb-patches@sources.redhat.com
mailing list for the GDB project.
Re: [RFA] dwarf2read global state cleanups, continued
On Tue, Jan 27, 2004 at 11:48:05AM -0500, Jim Blandy wrote:
>
> Daniel Jacobowitz <drow@mvista.com> writes:
> > Next I'm going to work on inter-CU references for the partial symbols, then
> > eventually full symbols. Is this patch OK?
>
> If you've tested it, and there are no regressions, please commit this.
I developed merge conflicts... I've retested and checked in the
attached.
--
Daniel Jacobowitz
MontaVista Software Debian GNU/Linux Developer
2004-01-27 Daniel Jacobowitz <drow@mvista.com>
* dwarf2read.c: Update calls to changed and renamed functions, and
references to moved variables.
(struct dwarf2_cu): Add first_fn, last_fn, cached_fn,
language, language_defn, list_in_scope, and ftypes members.
(cu_first_fn, cu_last_fn, cu_cached_fn, cu_language)
(cu_language_defn, list_in_scope, ftypes, cu_header_offset)
(baseaddr): Remove globals.
(dwarf_attr): Renamed to dwarf2_attr. Add CU argument.
(set_cu_language, die_is_declaration, die_specification)
(determine_prefix, determin_prefix_aux, class_name, namespace_name)
(dwarf2_linkage_name, dwarf2_name, dwarf2_extension)
(dwarf2_get_ref_die_offset, dwarf2_fundamental_type)
(initialize_cu_func_list, add_to_cu_func_list): Add CU argument.
(dwarf2_build_psymtabs_hard): Add local baseaddr. Initialize
cu.list_in_scope. Don't initialize cu_header_offset.
(add_partial_symbol): Add local baseaddr.
(psymtab_to_symtab_1): Add local baseaddr. Use
objfile->section_offsets for consistency. Don't initialize
cu_header_offset; do initialize cu.header.offset and
cu.list_in_scope.
(read_file_scope, read_func_scope, read_lexical_block_scope)
(dwarf_decode_lines, new_symbol): Add local baseaddr.
Index: dwarf2read.c
===================================================================
RCS file: /cvs/src/src/gdb/dwarf2read.c,v
retrieving revision 1.126
diff -u -p -r1.126 dwarf2read.c
--- dwarf2read.c 26 Jan 2004 20:36:31 -0000 1.126
+++ dwarf2read.c 27 Jan 2004 20:38:04 -0000
@@ -231,6 +231,34 @@ struct dwarf2_cu
should be moved to the dwarf2_cu structure; for instance the abbrevs
hash table. */
struct comp_unit_head header;
+
+ struct function_range *first_fn, *last_fn, *cached_fn;
+
+ /* The language we are debugging. */
+ enum language language;
+ const struct language_defn *language_defn;
+
+ /* The generic symbol table building routines have separate lists for
+ file scope symbols and all all other scopes (local scopes). So
+ we need to select the right one to pass to add_symbol_to_list().
+ We do it by keeping a pointer to the correct list in list_in_scope.
+
+ FIXME: The original dwarf code just treated the file scope as the
+ first local scope, and all other local scopes as nested local
+ scopes, and worked fine. Check to see if we really need to
+ distinguish these in buildsym.c. */
+ struct pending **list_in_scope;
+
+ /* Maintain an array of referenced fundamental types for the current
+ compilation unit being read. For DWARF version 1, we have to construct
+ the fundamental types on the fly, since no information about the
+ fundamental types is supplied. Each such fundamental type is created by
+ calling a language dependent routine to create the type, and then a
+ pointer to that type is then placed in the array at the index specified
+ by it's FT_<TYPENAME> value. The array has a fixed size set by the
+ FT_NUM_MEMBERS compile time constant, which is the number of predefined
+ fundamental types gdb knows how to construct. */
+ struct type *ftypes[FT_NUM_MEMBERS]; /* Fundamental types */
};
/* The line number information for a compilation unit (found in the
@@ -360,8 +388,6 @@ struct function_range
struct function_range *next;
};
-static struct function_range *cu_first_fn, *cu_last_fn, *cu_cached_fn;
-
/* Get at parts of an attribute structure */
#define DW_STRING(attr) ((attr)->u.str)
@@ -391,19 +417,11 @@ static struct die_info *die_ref_table[RE
/* Obstack for allocating temporary storage used during symbol reading. */
static struct obstack dwarf2_tmp_obstack;
-/* Offset to the first byte of the current compilation unit header,
- for resolving relative reference dies. */
-static unsigned int cu_header_offset;
-
/* Allocate fields for structs, unions and enums in this size. */
#ifndef DW_FIELD_ALLOC_CHUNK
#define DW_FIELD_ALLOC_CHUNK 4
#endif
-/* The language we are debugging. */
-static enum language cu_language;
-static const struct language_defn *cu_language_defn;
-
/* Actually data from the sections. */
static char *dwarf_info_buffer;
static char *dwarf_abbrev_buffer;
@@ -416,17 +434,6 @@ static char *dwarf_loc_buffer;
/* A zeroed version of a partial die for initialization purposes. */
static struct partial_die_info zeroed_partial_die;
-/* The generic symbol table building routines have separate lists for
- file scope symbols and all all other scopes (local scopes). So
- we need to select the right one to pass to add_symbol_to_list().
- We do it by keeping a pointer to the correct list in list_in_scope.
-
- FIXME: The original dwarf code just treated the file scope as the first
- local scope, and all other local scopes as nested local scopes, and worked
- fine. Check to see if we really need to distinguish these
- in buildsym.c. */
-static struct pending **list_in_scope = &file_symbols;
-
/* FIXME: decode_locdesc sets these variables to describe the location
to the caller. These ought to be a structure or something. If
none of the flags are set, the object lives at the address returned
@@ -436,11 +443,6 @@ static int isreg; /* Object lives in re
decode_locdesc's return value is
the register number. */
-/* This value is added to each symbol value. FIXME: Generalize to
- the section_offsets structure used by dbxread (once this is done,
- pass the appropriate section number to end_symtab). */
-static CORE_ADDR baseaddr; /* Add to each symbol value */
-
/* We put a pointer to this structure in the read_symtab_private field
of the psymtab.
The complete dwarf information for an objfile is kept in the
@@ -525,17 +527,6 @@ struct dwarf2_pinfo
#define DWARF_LOC_BUFFER(p) (PST_PRIVATE(p)->dwarf_loc_buffer)
#define DWARF_LOC_SIZE(p) (PST_PRIVATE(p)->dwarf_loc_size)
-/* Maintain an array of referenced fundamental types for the current
- compilation unit being read. For DWARF version 1, we have to construct
- the fundamental types on the fly, since no information about the
- fundamental types is supplied. Each such fundamental type is created by
- calling a language dependent routine to create the type, and then a
- pointer to that type is then placed in the array at the index specified
- by it's FT_<TYPENAME> value. The array has a fixed size set by the
- FT_NUM_MEMBERS compile time constant, which is the number of predefined
- fundamental types gdb knows how to construct. */
-static struct type *ftypes[FT_NUM_MEMBERS]; /* Fundamental types */
-
/* FIXME: We might want to set this from BFD via bfd_arch_bits_per_byte,
but this would require a corresponding change in unpack_field_as_long
and friends. */
@@ -730,13 +721,15 @@ static unsigned long read_unsigned_leb12
static long read_signed_leb128 (bfd *, char *, unsigned int *);
-static void set_cu_language (unsigned int);
+static void set_cu_language (unsigned int, struct dwarf2_cu *);
-static struct attribute *dwarf_attr (struct die_info *, unsigned int);
+static struct attribute *dwarf2_attr (struct die_info *, unsigned int,
+ struct dwarf2_cu *);
-static int die_is_declaration (struct die_info *);
+static int die_is_declaration (struct die_info *, struct dwarf2_cu *cu);
-static struct die_info *die_specification (struct die_info *die);
+static struct die_info *die_specification (struct die_info *die,
+ struct dwarf2_cu *);
static void free_line_header (struct line_header *lh);
@@ -772,13 +765,13 @@ static struct type *tag_type_to_type (st
static void read_type_die (struct die_info *, struct dwarf2_cu *);
-static char *determine_prefix (struct die_info *die);
+static char *determine_prefix_aux (struct die_info *die, struct dwarf2_cu *);
-static char *determine_prefix_aux (struct die_info *die);
+static char *determine_prefix_aux (struct die_info *die, struct dwarf2_cu *);
static char *typename_concat (const char *prefix, const char *suffix);
-static char *class_name (struct die_info *die);
+static char *class_name (struct die_info *die, struct dwarf2_cu *);
static void read_typedef (struct die_info *, struct dwarf2_cu *);
@@ -819,7 +812,7 @@ static void read_common_block (struct di
static void read_namespace (struct die_info *die, struct dwarf2_cu *);
static const char *namespace_name (struct die_info *die,
- int *is_anonymous);
+ int *is_anonymous, struct dwarf2_cu *);
static void read_enumeration (struct die_info *, struct dwarf2_cu *);
@@ -862,11 +855,12 @@ static struct cleanup *make_cleanup_free
static void process_die (struct die_info *, struct dwarf2_cu *);
-static char *dwarf2_linkage_name (struct die_info *);
+static char *dwarf2_linkage_name (struct die_info *, struct dwarf2_cu *);
-static char *dwarf2_name (struct die_info *die);
+static char *dwarf2_name (struct die_info *die, struct dwarf2_cu *);
-static struct die_info *dwarf2_extension (struct die_info *die);
+static struct die_info *dwarf2_extension (struct die_info *die,
+ struct dwarf2_cu *);
static char *dwarf_tag_name (unsigned int);
@@ -896,13 +890,15 @@ static void store_in_ref_table (unsigned
static void dwarf2_empty_hash_tables (void);
-static unsigned int dwarf2_get_ref_die_offset (struct attribute *);
+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 type *dwarf2_fundamental_type (struct objfile *, int);
+static struct type *dwarf2_fundamental_type (struct objfile *, int,
+ struct dwarf2_cu *);
/* memory allocation interface */
@@ -914,9 +910,10 @@ static struct abbrev_info *dwarf_alloc_a
static struct die_info *dwarf_alloc_die (void);
-static void initialize_cu_func_list (void);
+static void initialize_cu_func_list (struct dwarf2_cu *);
-static void add_to_cu_func_list (const char *, CORE_ADDR, CORE_ADDR);
+static void add_to_cu_func_list (const char *, CORE_ADDR, CORE_ADDR,
+ struct dwarf2_cu *);
static void dwarf_decode_macros (struct line_header *, unsigned int,
char *, bfd *, struct dwarf2_cu *);
@@ -1154,7 +1151,7 @@ dwarf2_build_psymtabs_hard (struct objfi
struct partial_die_info comp_unit_die;
struct partial_symtab *pst;
struct cleanup *back_to;
- CORE_ADDR lowpc, highpc;
+ CORE_ADDR lowpc, highpc, baseaddr;
info_ptr = dwarf_info_buffer;
abbrev_ptr = dwarf_abbrev_buffer;
@@ -1238,6 +1235,8 @@ dwarf2_build_psymtabs_hard (struct objfi
cu.header.first_die_ptr = info_ptr;
cu.header.cu_head_ptr = beg_of_comp_unit;
+ cu.list_in_scope = &file_symbols;
+
/* Read the abbrevs for this compilation unit into a table */
dwarf2_read_abbrevs (abfd, &cu);
make_cleanup (dwarf2_empty_abbrev_table, cu.header.dwarf2_abbrevs);
@@ -1247,7 +1246,7 @@ dwarf2_build_psymtabs_hard (struct objfi
&cu);
/* Set the language we're debugging */
- set_cu_language (comp_unit_die.language);
+ set_cu_language (comp_unit_die.language, &cu);
/* Allocate a new partial symbol table structure */
pst = start_psymtab_common (objfile, objfile->section_offsets,
@@ -1258,7 +1257,6 @@ dwarf2_build_psymtabs_hard (struct objfi
pst->read_symtab_private = (char *)
obstack_alloc (&objfile->psymbol_obstack, sizeof (struct dwarf2_pinfo));
- cu_header_offset = beg_of_comp_unit - dwarf_info_buffer;
DWARF_INFO_BUFFER (pst) = dwarf_info_buffer;
DWARF_INFO_OFFSET (pst) = beg_of_comp_unit - dwarf_info_buffer;
DWARF_ABBREV_BUFFER (pst) = dwarf_abbrev_buffer;
@@ -1448,6 +1446,9 @@ add_partial_symbol (struct partial_die_i
CORE_ADDR addr = 0;
char *actual_name = pdi->name;
const struct partial_symbol *psym = NULL;
+ CORE_ADDR baseaddr;
+
+ baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
/* If we're not in the global namespace and if the namespace name
isn't encoded in a mangled actual_name, add it. */
@@ -1471,7 +1472,7 @@ add_partial_symbol (struct partial_die_i
VAR_DOMAIN, LOC_BLOCK,
&objfile->global_psymbols,
0, pdi->lowpc + baseaddr,
- cu_language, objfile);
+ cu->language, objfile);
}
else
{
@@ -1481,7 +1482,7 @@ add_partial_symbol (struct partial_die_i
VAR_DOMAIN, LOC_BLOCK,
&objfile->static_psymbols,
0, pdi->lowpc + baseaddr,
- cu_language, objfile);
+ cu->language, objfile);
}
break;
case DW_TAG_variable:
@@ -1507,7 +1508,7 @@ add_partial_symbol (struct partial_die_i
VAR_DOMAIN, LOC_STATIC,
&objfile->global_psymbols,
0, addr + baseaddr,
- cu_language, objfile);
+ cu->language, objfile);
}
else
{
@@ -1521,7 +1522,7 @@ add_partial_symbol (struct partial_die_i
VAR_DOMAIN, LOC_STATIC,
&objfile->static_psymbols,
0, addr + baseaddr,
- cu_language, objfile);
+ cu->language, objfile);
}
break;
case DW_TAG_typedef:
@@ -1530,7 +1531,7 @@ add_partial_symbol (struct partial_die_i
add_psymbol_to_list (actual_name, strlen (actual_name),
VAR_DOMAIN, LOC_TYPEDEF,
&objfile->static_psymbols,
- 0, (CORE_ADDR) 0, cu_language, objfile);
+ 0, (CORE_ADDR) 0, cu->language, objfile);
break;
case DW_TAG_class_type:
case DW_TAG_structure_type:
@@ -1544,27 +1545,27 @@ add_partial_symbol (struct partial_die_i
return;
add_psymbol_to_list (actual_name, strlen (actual_name),
STRUCT_DOMAIN, LOC_TYPEDEF,
- cu_language == language_cplus
+ cu->language == language_cplus
? &objfile->global_psymbols
: &objfile->static_psymbols,
- 0, (CORE_ADDR) 0, cu_language, objfile);
+ 0, (CORE_ADDR) 0, cu->language, objfile);
- if (cu_language == language_cplus)
+ if (cu->language == language_cplus)
{
/* For C++, these implicitly act as typedefs as well. */
add_psymbol_to_list (actual_name, strlen (actual_name),
VAR_DOMAIN, LOC_TYPEDEF,
&objfile->global_psymbols,
- 0, (CORE_ADDR) 0, cu_language, objfile);
+ 0, (CORE_ADDR) 0, cu->language, objfile);
}
break;
case DW_TAG_enumerator:
add_psymbol_to_list (actual_name, strlen (actual_name),
VAR_DOMAIN, LOC_CONST,
- cu_language == language_cplus
+ cu->language == language_cplus
? &objfile->static_psymbols
: &objfile->global_psymbols,
- 0, (CORE_ADDR) 0, cu_language, objfile);
+ 0, (CORE_ADDR) 0, cu->language, objfile);
break;
default:
break;
@@ -1576,7 +1577,7 @@ add_partial_symbol (struct partial_die_i
(otherwise we'll have psym == NULL), and if we actually had a
mangled name to begin with. */
- if (cu_language == language_cplus
+ if (cu->language == language_cplus
&& namespace == NULL
&& psym != NULL
&& SYMBOL_CPLUS_DEMANGLED_NAME (psym) != NULL)
@@ -1639,7 +1640,7 @@ add_partial_namespace (struct partial_di
add_psymbol_to_list (full_name, strlen (full_name),
VAR_DOMAIN, LOC_TYPEDEF,
&objfile->global_psymbols,
- 0, 0, cu_language, objfile);
+ 0, 0, cu->language, objfile);
/* Now scan partial symbols in that namespace. */
@@ -1659,7 +1660,7 @@ add_partial_structure (struct partial_di
bfd *abfd = cu->objfile->obfd;
char *actual_class_name = NULL;
- if (cu_language == language_cplus
+ if (cu->language == language_cplus
&& namespace == NULL
&& struct_pdi->name != NULL
&& struct_pdi->has_children)
@@ -1701,7 +1702,7 @@ add_partial_structure (struct partial_di
}
add_partial_symbol (struct_pdi, cu, namespace);
- xfree(actual_class_name);
+ xfree (actual_class_name);
return locate_pdi_sibling (struct_pdi, info_ptr, abfd, cu);
}
@@ -1810,6 +1811,7 @@ psymtab_to_symtab_1 (struct partial_symt
struct symtab *symtab;
struct cleanup *back_to;
struct attribute *attr;
+ CORE_ADDR baseaddr;
/* Set local variables from the partial symbol table info. */
offset = DWARF_INFO_OFFSET (pst);
@@ -1826,9 +1828,8 @@ psymtab_to_symtab_1 (struct partial_symt
dwarf_ranges_size = DWARF_RANGES_SIZE (pst);
dwarf_loc_buffer = DWARF_LOC_BUFFER (pst);
dwarf_loc_size = DWARF_LOC_SIZE (pst);
- baseaddr = ANOFFSET (pst->section_offsets, SECT_OFF_TEXT (objfile));
- cu_header_offset = offset;
info_ptr = dwarf_info_buffer + offset;
+ baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
/* We're in the global namespace. */
processing_current_prefix = "";
@@ -1848,6 +1849,10 @@ psymtab_to_symtab_1 (struct partial_symt
dwarf2_read_abbrevs (abfd, &cu);
make_cleanup (dwarf2_empty_abbrev_table, cu.header.dwarf2_abbrevs);
+ cu.header.offset = offset;
+
+ cu.list_in_scope = &file_symbols;
+
dies = read_comp_unit (info_ptr, abfd, &cu);
make_cleanup_free_die_list (dies);
@@ -1861,7 +1866,7 @@ psymtab_to_symtab_1 (struct partial_symt
cu.header.base_known = 0;
cu.header.base_address = 0;
- attr = dwarf_attr (dies, DW_AT_entry_pc);
+ attr = dwarf2_attr (dies, DW_AT_entry_pc, &cu);
if (attr)
{
cu.header.base_address = DW_ADDR (attr);
@@ -1869,7 +1874,7 @@ psymtab_to_symtab_1 (struct partial_symt
}
else
{
- attr = dwarf_attr (dies, DW_AT_low_pc);
+ attr = dwarf2_attr (dies, DW_AT_low_pc, &cu);
if (attr)
{
cu.header.base_address = DW_ADDR (attr);
@@ -1891,9 +1896,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;
@@ -1955,7 +1960,7 @@ process_die (struct die_info *die, struc
break;
case DW_TAG_base_type:
read_base_type (die, cu);
- if (dwarf_attr (die, DW_AT_name))
+ if (dwarf2_attr (die, DW_AT_name, cu))
{
/* Add a typedef symbol for the base type definition. */
new_symbol (die, die->type, cu);
@@ -1963,7 +1968,7 @@ process_die (struct die_info *die, struc
break;
case DW_TAG_subrange_type:
read_subrange_type (die, cu);
- if (dwarf_attr (die, DW_AT_name))
+ if (dwarf2_attr (die, DW_AT_name, cu))
{
/* Add a typedef symbol for the base type definition. */
new_symbol (die, die->type, cu);
@@ -1996,9 +2001,9 @@ process_die (struct die_info *die, struc
}
static void
-initialize_cu_func_list (void)
+initialize_cu_func_list (struct dwarf2_cu *cu)
{
- cu_first_fn = cu_last_fn = cu_cached_fn = NULL;
+ cu->first_fn = cu->last_fn = cu->cached_fn = NULL;
}
static void
@@ -2015,6 +2020,9 @@ read_file_scope (struct die_info *die, s
struct die_info *child_die;
bfd *abfd = objfile->obfd;
struct line_header *line_header = 0;
+ CORE_ADDR baseaddr;
+
+ baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
get_scope_pc_bounds (die, &lowpc, &highpc, cu);
@@ -2025,12 +2033,12 @@ read_file_scope (struct die_info *die, s
lowpc += baseaddr;
highpc += baseaddr;
- attr = dwarf_attr (die, DW_AT_name);
+ attr = dwarf2_attr (die, DW_AT_name, cu);
if (attr)
{
name = DW_STRING (attr);
}
- attr = dwarf_attr (die, DW_AT_comp_dir);
+ attr = dwarf2_attr (die, DW_AT_comp_dir, cu);
if (attr)
{
comp_dir = DW_STRING (attr);
@@ -2052,10 +2060,10 @@ read_file_scope (struct die_info *die, s
objfile->ei.deprecated_entry_file_highpc = highpc;
}
- attr = dwarf_attr (die, DW_AT_language);
+ attr = dwarf2_attr (die, DW_AT_language, cu);
if (attr)
{
- set_cu_language (DW_UNSND (attr));
+ set_cu_language (DW_UNSND (attr), cu);
}
/* We assume that we're processing GCC output. */
@@ -2070,12 +2078,12 @@ read_file_scope (struct die_info *die, s
/* The compilation unit may be in a different language or objfile,
zero out all remembered fundamental types. */
- memset (ftypes, 0, FT_NUM_MEMBERS * sizeof (struct type *));
+ memset (cu->ftypes, 0, FT_NUM_MEMBERS * sizeof (struct type *));
start_symtab (name, comp_dir, lowpc);
record_debugformat ("DWARF 2");
- initialize_cu_func_list ();
+ initialize_cu_func_list (cu);
/* Process all dies in compilation unit. */
if (die->child != NULL)
@@ -2089,7 +2097,7 @@ read_file_scope (struct die_info *die, s
}
/* Decode line number information if present. */
- attr = dwarf_attr (die, DW_AT_stmt_list);
+ attr = dwarf2_attr (die, DW_AT_stmt_list, cu);
if (attr)
{
unsigned int line_offset = DW_UNSND (attr);
@@ -2106,7 +2114,7 @@ read_file_scope (struct die_info *die, s
refers to information in the line number info statement program
header, so we can only read it if we've read the header
successfully. */
- attr = dwarf_attr (die, DW_AT_macro_info);
+ attr = dwarf2_attr (die, DW_AT_macro_info, cu);
if (attr && line_header)
{
unsigned int macro_offset = DW_UNSND (attr);
@@ -2117,7 +2125,8 @@ read_file_scope (struct die_info *die, s
}
static void
-add_to_cu_func_list (const char *name, CORE_ADDR lowpc, CORE_ADDR highpc)
+add_to_cu_func_list (const char *name, CORE_ADDR lowpc, CORE_ADDR highpc,
+ struct dwarf2_cu *cu)
{
struct function_range *thisfn;
@@ -2129,12 +2138,12 @@ add_to_cu_func_list (const char *name, C
thisfn->seen_line = 0;
thisfn->next = NULL;
- if (cu_last_fn == NULL)
- cu_first_fn = thisfn;
+ if (cu->last_fn == NULL)
+ cu->first_fn = thisfn;
else
- cu_last_fn->next = thisfn;
+ cu->last_fn->next = thisfn;
- cu_last_fn = thisfn;
+ cu->last_fn = thisfn;
}
static void
@@ -2149,8 +2158,11 @@ read_func_scope (struct die_info *die, s
char *name;
const char *previous_prefix = processing_current_prefix;
struct cleanup *back_to = NULL;
+ CORE_ADDR baseaddr;
- name = dwarf2_linkage_name (die);
+ baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
+
+ name = dwarf2_linkage_name (die, cu);
/* Ignore functions with missing or empty names and functions with
missing or invalid low and high pc attributes. */
@@ -2185,7 +2197,7 @@ read_func_scope (struct die_info *die, s
if (spec_die != NULL)
{
- char *specification_prefix = determine_prefix (spec_die);
+ char *specification_prefix = determine_prefix (spec_die, cu);
processing_current_prefix = specification_prefix;
back_to = make_cleanup (xfree, specification_prefix);
}
@@ -2195,7 +2207,7 @@ read_func_scope (struct die_info *die, s
highpc += baseaddr;
/* Record the function range for dwarf_decode_lines. */
- add_to_cu_func_list (name, lowpc, highpc);
+ add_to_cu_func_list (name, lowpc, highpc, cu);
if (objfile->ei.entry_point >= lowpc &&
objfile->ei.entry_point < highpc)
@@ -2209,7 +2221,7 @@ read_func_scope (struct die_info *die, s
/* If there is a location expression for DW_AT_frame_base, record
it. */
- attr = dwarf_attr (die, DW_AT_frame_base);
+ attr = dwarf2_attr (die, DW_AT_frame_base, cu);
if (attr)
/* FIXME: cagney/2004-01-26: The DW_AT_frame_base's location
expression is being recorded directly in the function's symbol
@@ -2222,7 +2234,7 @@ read_func_scope (struct die_info *die, s
frame-base has-a location expression. */
dwarf2_symbol_mark_computed (attr, new->name, cu);
- list_in_scope = &local_symbols;
+ cu->list_in_scope = &local_symbols;
if (die->child != NULL)
{
@@ -2249,7 +2261,7 @@ read_func_scope (struct die_info *die, s
/* If we've finished processing a top-level function, subsequent
symbols go in the file symbol list. */
if (outermost_context_p ())
- list_in_scope = &file_symbols;
+ cu->list_in_scope = &file_symbols;
processing_current_prefix = previous_prefix;
if (back_to != NULL)
@@ -2266,6 +2278,9 @@ read_lexical_block_scope (struct die_inf
struct context_stack *new;
CORE_ADDR lowpc, highpc;
struct die_info *child_die;
+ CORE_ADDR baseaddr;
+
+ baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
/* Ignore blocks with missing or invalid low and high pc attributes. */
/* ??? Perhaps consider discontiguous blocks defined by DW_AT_ranges
@@ -2312,11 +2327,11 @@ dwarf2_get_pc_bounds (struct die_info *d
CORE_ADDR high = 0;
int ret = 0;
- attr = dwarf_attr (die, DW_AT_high_pc);
+ attr = dwarf2_attr (die, DW_AT_high_pc, cu);
if (attr)
{
high = DW_ADDR (attr);
- attr = dwarf_attr (die, DW_AT_low_pc);
+ attr = dwarf2_attr (die, DW_AT_low_pc, cu);
if (attr)
low = DW_ADDR (attr);
else
@@ -2328,7 +2343,7 @@ dwarf2_get_pc_bounds (struct die_info *d
}
else
{
- attr = dwarf_attr (die, DW_AT_ranges);
+ attr = dwarf2_attr (die, DW_AT_ranges, cu);
if (attr != NULL)
{
unsigned int addr_size = cu_header->addr_size;
@@ -2547,18 +2562,18 @@ dwarf2_add_field (struct field_info *fip
new_field->accessibility = DW_ACCESS_private;
new_field->virtuality = DW_VIRTUALITY_none;
- attr = dwarf_attr (die, DW_AT_accessibility);
+ attr = dwarf2_attr (die, DW_AT_accessibility, cu);
if (attr)
new_field->accessibility = DW_UNSND (attr);
if (new_field->accessibility != DW_ACCESS_public)
fip->non_public_fields = 1;
- attr = dwarf_attr (die, DW_AT_virtuality);
+ attr = dwarf2_attr (die, DW_AT_virtuality, cu);
if (attr)
new_field->virtuality = DW_UNSND (attr);
fp = &new_field->field;
- if (die->tag == DW_TAG_member && ! die_is_declaration (die))
+ if (die->tag == DW_TAG_member && ! die_is_declaration (die, cu))
{
/* Data member other than a C++ static data member. */
@@ -2568,7 +2583,7 @@ dwarf2_add_field (struct field_info *fip
FIELD_STATIC_KIND (*fp) = 0;
/* Get bit size of field (zero if none). */
- attr = dwarf_attr (die, DW_AT_bit_size);
+ attr = dwarf2_attr (die, DW_AT_bit_size, cu);
if (attr)
{
FIELD_BITSIZE (*fp) = DW_UNSND (attr);
@@ -2579,7 +2594,7 @@ dwarf2_add_field (struct field_info *fip
}
/* Get bit offset of field. */
- attr = dwarf_attr (die, DW_AT_data_member_location);
+ attr = dwarf2_attr (die, DW_AT_data_member_location, cu);
if (attr)
{
FIELD_BITPOS (*fp) =
@@ -2587,7 +2602,7 @@ dwarf2_add_field (struct field_info *fip
}
else
FIELD_BITPOS (*fp) = 0;
- attr = dwarf_attr (die, DW_AT_bit_offset);
+ attr = dwarf2_attr (die, DW_AT_bit_offset, cu);
if (attr)
{
if (BITS_BIG_ENDIAN)
@@ -2610,7 +2625,7 @@ dwarf2_add_field (struct field_info *fip
int anonymous_size;
int bit_offset = DW_UNSND (attr);
- attr = dwarf_attr (die, DW_AT_byte_size);
+ attr = dwarf2_attr (die, DW_AT_byte_size, cu);
if (attr)
{
/* The size of the anonymous object containing
@@ -2632,7 +2647,7 @@ dwarf2_add_field (struct field_info *fip
}
/* Get name of field. */
- attr = dwarf_attr (die, DW_AT_name);
+ attr = dwarf2_attr (die, DW_AT_name, cu);
if (attr && DW_STRING (attr))
fieldname = DW_STRING (attr);
fp->name = obsavestring (fieldname, strlen (fieldname),
@@ -2640,7 +2655,7 @@ dwarf2_add_field (struct field_info *fip
/* Change accessibility for artificial fields (e.g. virtual table
pointer or virtual base class pointer) to private. */
- if (dwarf_attr (die, DW_AT_artificial))
+ if (dwarf2_attr (die, DW_AT_artificial, cu))
{
new_field->accessibility = DW_ACCESS_private;
fip->non_public_fields = 1;
@@ -2658,14 +2673,14 @@ dwarf2_add_field (struct field_info *fip
char *physname;
/* Get name of field. */
- attr = dwarf_attr (die, DW_AT_name);
+ attr = dwarf2_attr (die, DW_AT_name, cu);
if (attr && DW_STRING (attr))
fieldname = DW_STRING (attr);
else
return;
/* Get physical name. */
- physname = dwarf2_linkage_name (die);
+ physname = dwarf2_linkage_name (die, cu);
SET_FIELD_PHYSNAME (*fp, obsavestring (physname, strlen (physname),
&objfile->type_obstack));
@@ -2676,7 +2691,7 @@ dwarf2_add_field (struct field_info *fip
else if (die->tag == DW_TAG_inheritance)
{
/* C++ base class field. */
- attr = dwarf_attr (die, DW_AT_data_member_location);
+ attr = dwarf2_attr (die, DW_AT_data_member_location, cu);
if (attr)
FIELD_BITPOS (*fp) = (decode_locdesc (DW_BLOCK (attr), cu)
* bits_per_byte);
@@ -2791,14 +2806,14 @@ dwarf2_add_member_fn (struct field_info
struct nextfnfield *new_fnfield;
/* Get name of member function. */
- attr = dwarf_attr (die, DW_AT_name);
+ attr = dwarf2_attr (die, DW_AT_name, cu);
if (attr && DW_STRING (attr))
fieldname = DW_STRING (attr);
else
return;
/* Get the mangled name. */
- physname = dwarf2_linkage_name (die);
+ physname = dwarf2_linkage_name (die, cu);
/* Look up member function name in fieldlist. */
for (i = 0; i < fip->nfnfields; i++)
@@ -2868,14 +2883,14 @@ dwarf2_add_member_fn (struct field_info
physname);
/* Get fcontext from DW_AT_containing_type if present. */
- if (dwarf_attr (die, DW_AT_containing_type) != NULL)
+ if (dwarf2_attr (die, DW_AT_containing_type, cu) != NULL)
fnp->fcontext = die_containing_type (die, cu);
/* dwarf2 doesn't have stubbed physical names, so the setting of is_const
and is_volatile is irrelevant, as it is needed by gdb_mangle_name only. */
/* Get accessibility. */
- attr = dwarf_attr (die, DW_AT_accessibility);
+ attr = dwarf2_attr (die, DW_AT_accessibility, cu);
if (attr)
{
switch (DW_UNSND (attr))
@@ -2890,12 +2905,12 @@ dwarf2_add_member_fn (struct field_info
}
/* Check for artificial methods. */
- attr = dwarf_attr (die, DW_AT_artificial);
+ attr = dwarf2_attr (die, DW_AT_artificial, cu);
if (attr && DW_UNSND (attr) != 0)
fnp->is_artificial = 1;
/* Get index in virtual function table if it is a virtual member function. */
- attr = dwarf_attr (die, DW_AT_vtable_elem_location);
+ attr = dwarf2_attr (die, DW_AT_vtable_elem_location, cu);
if (attr)
{
/* Support the .debug_loc offsets */
@@ -2982,18 +2997,18 @@ read_structure_scope (struct die_info *d
type = alloc_type (objfile);
INIT_CPLUS_SPECIFIC (type);
- attr = dwarf_attr (die, DW_AT_name);
+ attr = dwarf2_attr (die, DW_AT_name, cu);
if (attr && DW_STRING (attr))
{
name = DW_STRING (attr);
- if (cu_language == language_cplus)
+ if (cu->language == language_cplus)
{
- struct die_info *spec_die = die_specification (die);
+ struct die_info *spec_die = die_specification (die, cu);
if (spec_die != NULL)
{
- char *specification_prefix = determine_prefix (spec_die);
+ char *specification_prefix = determine_prefix (spec_die, cu);
processing_current_prefix = specification_prefix;
back_to = make_cleanup (xfree, specification_prefix);
}
@@ -3018,7 +3033,7 @@ read_structure_scope (struct die_info *d
{
TYPE_TAG_NAME (type) = obsavestring (name, strlen (name),
&objfile->type_obstack);
- need_to_update_name = (cu_language == language_cplus);
+ need_to_update_name = (cu->language == language_cplus);
}
}
@@ -3037,7 +3052,7 @@ read_structure_scope (struct die_info *d
TYPE_CODE (type) = TYPE_CODE_CLASS;
}
- attr = dwarf_attr (die, DW_AT_byte_size);
+ attr = dwarf2_attr (die, DW_AT_byte_size, cu);
if (attr)
{
TYPE_LENGTH (type) = DW_UNSND (attr);
@@ -3052,7 +3067,7 @@ read_structure_scope (struct die_info *d
type within the structure itself. */
die->type = type;
- if (die->child != NULL && ! die_is_declaration (die))
+ if (die->child != NULL && ! die_is_declaration (die, cu))
{
struct field_info fi;
struct die_info *child_die;
@@ -3102,7 +3117,7 @@ read_structure_scope (struct die_info *d
name. */
char *actual_class_name
= class_name_from_physname (dwarf2_linkage_name
- (child_die));
+ (child_die, cu));
if (actual_class_name != NULL
&& strcmp (actual_class_name, name) != 0)
{
@@ -3138,7 +3153,7 @@ read_structure_scope (struct die_info *d
class itself) which contains the vtable pointer for the current
class from the DW_AT_containing_type attribute. */
- if (dwarf_attr (die, DW_AT_containing_type) != NULL)
+ if (dwarf2_attr (die, DW_AT_containing_type, cu) != NULL)
{
struct type *t = die_containing_type (die, cu);
@@ -3219,7 +3234,7 @@ read_enumeration (struct die_info *die,
type = alloc_type (objfile);
TYPE_CODE (type) = TYPE_CODE_ENUM;
- attr = dwarf_attr (die, DW_AT_name);
+ attr = dwarf2_attr (die, DW_AT_name, cu);
if (attr && DW_STRING (attr))
{
const char *name = DW_STRING (attr);
@@ -3239,7 +3254,7 @@ read_enumeration (struct die_info *die,
}
}
- attr = dwarf_attr (die, DW_AT_byte_size);
+ attr = dwarf2_attr (die, DW_AT_byte_size, cu);
if (attr)
{
TYPE_LENGTH (type) = DW_UNSND (attr);
@@ -3262,7 +3277,7 @@ read_enumeration (struct die_info *die,
}
else
{
- attr = dwarf_attr (child_die, DW_AT_name);
+ attr = dwarf2_attr (child_die, DW_AT_name, cu);
if (attr)
{
sym = new_symbol (child_die, type, cu);
@@ -3334,7 +3349,7 @@ read_array_type (struct die_info *die, s
arrays with unspecified length. */
if (die->child == NULL)
{
- index_type = dwarf2_fundamental_type (objfile, FT_INTEGER);
+ index_type = dwarf2_fundamental_type (objfile, FT_INTEGER, cu);
range_type = create_range_type (NULL, index_type, 0, -1);
die->type = create_array_type (NULL, element_type, range_type);
return;
@@ -3378,7 +3393,7 @@ read_array_type (struct die_info *die, s
custom vendor extension. The main difference between a regular
array and the vector variant is that vectors are passed by value
to functions. */
- attr = dwarf_attr (die, DW_AT_GNU_vector);
+ attr = dwarf2_attr (die, DW_AT_GNU_vector, cu);
if (attr)
TYPE_FLAGS (type) |= TYPE_FLAG_VECTOR;
@@ -3398,7 +3413,7 @@ read_common_block (struct die_info *die,
struct symbol *sym;
CORE_ADDR base = (CORE_ADDR) 0;
- attr = dwarf_attr (die, DW_AT_location);
+ attr = dwarf2_attr (die, DW_AT_location, cu);
if (attr)
{
/* Support the .debug_loc offsets */
@@ -3422,7 +3437,7 @@ read_common_block (struct die_info *die,
while (child_die && child_die->tag)
{
sym = new_symbol (child_die, NULL, cu);
- attr = dwarf_attr (child_die, DW_AT_data_member_location);
+ attr = dwarf2_attr (child_die, DW_AT_data_member_location, cu);
if (attr)
{
SYMBOL_VALUE_ADDRESS (sym) =
@@ -3445,7 +3460,7 @@ read_namespace (struct die_info *die, st
int is_anonymous;
struct die_info *current_die;
- name = namespace_name (die, &is_anonymous);
+ name = namespace_name (die, &is_anonymous, cu);
/* Now build the name of the current namespace. */
@@ -3470,7 +3485,7 @@ read_namespace (struct die_info *die, st
before. Also, add a using directive if it's an anonymous
namespace. */
- if (dwarf2_extension (die) == NULL)
+ if (dwarf2_extension (die, cu) == NULL)
{
struct type *type;
@@ -3508,7 +3523,7 @@ read_namespace (struct die_info *die, st
namespace. */
static const char *
-namespace_name (struct die_info *die, int *is_anonymous)
+namespace_name (struct die_info *die, int *is_anonymous, struct dwarf2_cu *cu)
{
struct die_info *current_die;
const char *name = NULL;
@@ -3517,9 +3532,9 @@ namespace_name (struct die_info *die, in
for (current_die = die;
current_die != NULL;
- current_die = dwarf2_extension (die))
+ current_die = dwarf2_extension (die, cu))
{
- name = dwarf2_name (current_die);
+ name = dwarf2_name (current_die, cu);
if (name != NULL)
break;
}
@@ -3552,13 +3567,13 @@ read_tag_pointer_type (struct die_info *
type = lookup_pointer_type (die_type (die, cu));
- attr_byte_size = dwarf_attr (die, DW_AT_byte_size);
+ attr_byte_size = dwarf2_attr (die, DW_AT_byte_size, cu);
if (attr_byte_size)
byte_size = DW_UNSND (attr_byte_size);
else
byte_size = cu_header->addr_size;
- attr_address_class = dwarf_attr (die, DW_AT_address_class);
+ attr_address_class = dwarf2_attr (die, DW_AT_address_class, cu);
if (attr_address_class)
addr_class = DW_UNSND (attr_address_class);
else
@@ -3630,7 +3645,7 @@ read_tag_reference_type (struct die_info
}
type = lookup_reference_type (die_type (die, cu));
- attr = dwarf_attr (die, DW_AT_byte_size);
+ attr = dwarf2_attr (die, DW_AT_byte_size, cu);
if (attr)
{
TYPE_LENGTH (type) = DW_UNSND (attr);
@@ -3688,7 +3703,7 @@ read_tag_string_type (struct die_info *d
return;
}
- attr = dwarf_attr (die, DW_AT_string_length);
+ attr = dwarf2_attr (die, DW_AT_string_length, cu);
if (attr)
{
length = DW_UNSND (attr);
@@ -3696,7 +3711,7 @@ read_tag_string_type (struct die_info *d
else
{
/* check for the DW_AT_byte_size attribute */
- attr = dwarf_attr (die, DW_AT_byte_size);
+ attr = dwarf2_attr (die, DW_AT_byte_size, cu);
if (attr)
{
length = DW_UNSND (attr);
@@ -3706,9 +3721,9 @@ read_tag_string_type (struct die_info *d
length = 1;
}
}
- index_type = dwarf2_fundamental_type (objfile, FT_INTEGER);
+ index_type = dwarf2_fundamental_type (objfile, FT_INTEGER, cu);
range_type = create_range_type (NULL, index_type, 1, length);
- if (cu_language == language_fortran)
+ if (cu->language == language_fortran)
{
/* Need to create a unique string type for bounds
information */
@@ -3716,7 +3731,7 @@ read_tag_string_type (struct die_info *d
}
else
{
- char_type = dwarf2_fundamental_type (objfile, FT_CHAR);
+ char_type = dwarf2_fundamental_type (objfile, FT_CHAR, cu);
type = create_string_type (char_type, range_type);
}
die->type = type;
@@ -3749,9 +3764,9 @@ read_subroutine_type (struct die_info *d
ftype = lookup_function_type (type);
/* All functions in C++ have prototypes. */
- attr = dwarf_attr (die, DW_AT_prototyped);
+ attr = dwarf2_attr (die, DW_AT_prototyped, cu);
if ((attr && (DW_UNSND (attr) != 0))
- || cu_language == language_cplus)
+ || cu->language == language_cplus)
TYPE_FLAGS (ftype) |= TYPE_FLAG_PROTOTYPED;
if (die->child != NULL)
@@ -3788,7 +3803,7 @@ read_subroutine_type (struct die_info *d
parameter for non-static member functions (which is the
this pointer) as artificial. We pass this information
to dwarf2_add_member_fn via TYPE_FIELD_ARTIFICIAL. */
- attr = dwarf_attr (child_die, DW_AT_artificial);
+ attr = dwarf2_attr (child_die, DW_AT_artificial, cu);
if (attr)
TYPE_FIELD_ARTIFICIAL (ftype, iparams) = DW_UNSND (attr);
else
@@ -3812,7 +3827,7 @@ read_typedef (struct die_info *die, stru
if (!die->type)
{
- attr = dwarf_attr (die, DW_AT_name);
+ attr = dwarf2_attr (die, DW_AT_name, cu);
if (attr && DW_STRING (attr))
{
name = DW_STRING (attr);
@@ -3839,17 +3854,17 @@ read_base_type (struct die_info *die, st
return;
}
- attr = dwarf_attr (die, DW_AT_encoding);
+ attr = dwarf2_attr (die, DW_AT_encoding, cu);
if (attr)
{
encoding = DW_UNSND (attr);
}
- attr = dwarf_attr (die, DW_AT_byte_size);
+ attr = dwarf2_attr (die, DW_AT_byte_size, cu);
if (attr)
{
size = DW_UNSND (attr);
}
- attr = dwarf_attr (die, DW_AT_name);
+ attr = dwarf2_attr (die, DW_AT_name, cu);
if (attr && DW_STRING (attr))
{
enum type_code code = TYPE_CODE_INT;
@@ -3886,18 +3901,19 @@ read_base_type (struct die_info *die, st
}
type = init_type (code, size, type_flags, DW_STRING (attr), objfile);
if (encoding == DW_ATE_address)
- TYPE_TARGET_TYPE (type) = dwarf2_fundamental_type (objfile, FT_VOID);
+ TYPE_TARGET_TYPE (type) = dwarf2_fundamental_type (objfile, FT_VOID,
+ cu);
else if (encoding == DW_ATE_complex_float)
{
if (size == 32)
TYPE_TARGET_TYPE (type)
- = dwarf2_fundamental_type (objfile, FT_EXT_PREC_FLOAT);
+ = dwarf2_fundamental_type (objfile, FT_EXT_PREC_FLOAT, cu);
else if (size == 16)
TYPE_TARGET_TYPE (type)
- = dwarf2_fundamental_type (objfile, FT_DBL_PREC_FLOAT);
+ = dwarf2_fundamental_type (objfile, FT_DBL_PREC_FLOAT, cu);
else if (size == 8)
TYPE_TARGET_TYPE (type)
- = dwarf2_fundamental_type (objfile, FT_FLOAT);
+ = dwarf2_fundamental_type (objfile, FT_FLOAT, cu);
}
}
else
@@ -3933,17 +3949,17 @@ read_subrange_type (struct die_info *die
if (TYPE_CODE (base_type) == TYPE_CODE_VOID)
base_type = alloc_type (NULL);
- if (cu_language == language_fortran)
+ if (cu->language == language_fortran)
{
/* FORTRAN implies a lower bound of 1, if not given. */
low = 1;
}
- attr = dwarf_attr (die, DW_AT_lower_bound);
+ attr = dwarf2_attr (die, DW_AT_lower_bound, cu);
if (attr)
low = dwarf2_get_attr_constant_value (attr, 0);
- attr = dwarf_attr (die, DW_AT_upper_bound);
+ attr = dwarf2_attr (die, DW_AT_upper_bound, cu);
if (attr)
{
if (attr->form == DW_FORM_block1)
@@ -3967,11 +3983,11 @@ read_subrange_type (struct die_info *die
range_type = create_range_type (NULL, base_type, low, high);
- attr = dwarf_attr (die, DW_AT_name);
+ attr = dwarf2_attr (die, DW_AT_name, cu);
if (attr && DW_STRING (attr))
TYPE_NAME (range_type) = DW_STRING (attr);
- attr = dwarf_attr (die, DW_AT_byte_size);
+ attr = dwarf2_attr (die, DW_AT_byte_size, cu);
if (attr)
TYPE_LENGTH (range_type) = DW_UNSND (attr);
@@ -4348,7 +4364,7 @@ read_partial_die (struct partial_die_inf
complaint (&symfile_complaints, "ignoring absolute DW_AT_sibling");
else
part_die->sibling =
- dwarf_info_buffer + dwarf2_get_ref_die_offset (&attr);
+ dwarf_info_buffer + dwarf2_get_ref_die_offset (&attr, cu);
break;
default:
break;
@@ -4363,7 +4379,8 @@ read_partial_die (struct partial_die_inf
struct partial_die_info spec_die;
char *spec_ptr;
- spec_ptr = dwarf_info_buffer + dwarf2_get_ref_die_offset (&spec_attr);
+ spec_ptr = dwarf_info_buffer
+ + dwarf2_get_ref_die_offset (&spec_attr, cu);
read_partial_die (&spec_die, abfd, spec_ptr, cu);
if (spec_die.name)
{
@@ -4897,27 +4914,27 @@ read_signed_leb128 (bfd *abfd, char *buf
}
static void
-set_cu_language (unsigned int lang)
+set_cu_language (unsigned int lang, struct dwarf2_cu *cu)
{
switch (lang)
{
case DW_LANG_C89:
case DW_LANG_C:
- cu_language = language_c;
+ cu->language = language_c;
break;
case DW_LANG_C_plus_plus:
- cu_language = language_cplus;
+ cu->language = language_cplus;
break;
case DW_LANG_Fortran77:
case DW_LANG_Fortran90:
case DW_LANG_Fortran95:
- cu_language = language_fortran;
+ cu->language = language_fortran;
break;
case DW_LANG_Mips_Assembler:
- cu_language = language_asm;
+ cu->language = language_asm;
break;
case DW_LANG_Java:
- cu_language = language_java;
+ cu->language = language_java;
break;
case DW_LANG_Ada83:
case DW_LANG_Ada95:
@@ -4926,16 +4943,16 @@ set_cu_language (unsigned int lang)
case DW_LANG_Pascal83:
case DW_LANG_Modula2:
default:
- cu_language = language_minimal;
+ cu->language = language_minimal;
break;
}
- cu_language_defn = language_def (cu_language);
+ cu->language_defn = language_def (cu->language);
}
/* Return the named attribute or NULL if not there. */
static struct attribute *
-dwarf_attr (struct die_info *die, unsigned int name)
+dwarf2_attr (struct die_info *die, unsigned int name, struct dwarf2_cu *cu)
{
unsigned int i;
struct attribute *spec = NULL;
@@ -4953,34 +4970,34 @@ dwarf_attr (struct die_info *die, unsign
if (spec)
{
struct die_info *ref_die =
- follow_die_ref (dwarf2_get_ref_die_offset (spec));
+ follow_die_ref (dwarf2_get_ref_die_offset (spec, cu));
if (ref_die)
- return dwarf_attr (ref_die, name);
+ return dwarf2_attr (ref_die, name, cu);
}
return NULL;
}
static int
-die_is_declaration (struct die_info *die)
+die_is_declaration (struct die_info *die, struct dwarf2_cu *cu)
{
- return (dwarf_attr (die, DW_AT_declaration)
- && ! dwarf_attr (die, DW_AT_specification));
+ return (dwarf2_attr (die, DW_AT_declaration, cu)
+ && ! dwarf2_attr (die, DW_AT_specification, cu));
}
/* Return the die giving the specification for DIE, if there is
one. */
static struct die_info *
-die_specification (struct die_info *die)
+die_specification (struct die_info *die, struct dwarf2_cu *cu)
{
- struct attribute *spec_attr = dwarf_attr (die, DW_AT_specification);
+ struct attribute *spec_attr = dwarf2_attr (die, DW_AT_specification, cu);
if (spec_attr == NULL)
return NULL;
else
- return follow_die_ref (dwarf2_get_ref_die_offset (spec_attr));
+ return follow_die_ref (dwarf2_get_ref_die_offset (spec_attr, cu));
}
/* Free the line_header structure *LH, and any arrays and strings it
@@ -5174,26 +5191,26 @@ dwarf_decode_line_header (unsigned int o
addresses passed to record_line. */
static CORE_ADDR
-check_cu_functions (CORE_ADDR address)
+check_cu_functions (CORE_ADDR address, struct dwarf2_cu *cu)
{
struct function_range *fn;
/* Find the function_range containing address. */
- if (!cu_first_fn)
+ if (!cu->first_fn)
return address;
- if (!cu_cached_fn)
- cu_cached_fn = cu_first_fn;
+ if (!cu->cached_fn)
+ cu->cached_fn = cu->first_fn;
- fn = cu_cached_fn;
+ fn = cu->cached_fn;
while (fn)
if (fn->lowpc <= address && fn->highpc > address)
goto found;
else
fn = fn->next;
- fn = cu_first_fn;
- while (fn && fn != cu_cached_fn)
+ fn = cu->first_fn;
+ while (fn && fn != cu->cached_fn)
if (fn->lowpc <= address && fn->highpc > address)
goto found;
else
@@ -5224,6 +5241,10 @@ dwarf_decode_lines (struct line_header *
char *line_end;
unsigned int bytes_read;
unsigned char op_code, extended_op, adj_opcode;
+ CORE_ADDR baseaddr;
+ struct objfile *objfile = cu->objfile;
+
+ baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
line_ptr = lh->statement_program_start;
line_end = lh->statement_program_end;
@@ -5269,7 +5290,7 @@ dwarf_decode_lines (struct line_header *
line += lh->line_base + (adj_opcode % lh->line_range);
/* append row to matrix using current values */
record_line (current_subfile, line,
- check_cu_functions (address));
+ check_cu_functions (address, cu));
basic_block = 1;
}
else switch (op_code)
@@ -5316,7 +5337,7 @@ dwarf_decode_lines (struct line_header *
break;
case DW_LNS_copy:
record_line (current_subfile, line,
- check_cu_functions (address));
+ check_cu_functions (address, cu));
basic_block = 0;
break;
case DW_LNS_advance_pc:
@@ -5497,9 +5518,12 @@ new_symbol (struct die_info *die, struct
char *name;
struct attribute *attr = NULL;
struct attribute *attr2 = NULL;
+ CORE_ADDR baseaddr;
+
+ baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
if (die->tag != DW_TAG_namespace)
- name = dwarf2_linkage_name (die);
+ name = dwarf2_linkage_name (die, cu);
else
name = TYPE_NAME (type);
@@ -5511,7 +5535,7 @@ new_symbol (struct die_info *die, struct
memset (sym, 0, sizeof (struct symbol));
/* Cache this symbol's name and the name's demangled form (if any). */
- SYMBOL_LANGUAGE (sym) = cu_language;
+ SYMBOL_LANGUAGE (sym) = cu->language;
SYMBOL_SET_NAMES (sym, name, strlen (name), objfile);
/* Default assumptions.
@@ -5522,7 +5546,7 @@ new_symbol (struct die_info *die, struct
SYMBOL_TYPE (sym) = type;
else
SYMBOL_TYPE (sym) = die_type (die, cu);
- attr = dwarf_attr (die, DW_AT_decl_line);
+ attr = dwarf2_attr (die, DW_AT_decl_line, cu);
if (attr)
{
SYMBOL_LINE (sym) = DW_UNSND (attr);
@@ -5530,7 +5554,7 @@ new_symbol (struct die_info *die, struct
switch (die->tag)
{
case DW_TAG_label:
- attr = dwarf_attr (die, DW_AT_low_pc);
+ attr = dwarf2_attr (die, DW_AT_low_pc, cu);
if (attr)
{
SYMBOL_VALUE_ADDRESS (sym) = DW_ADDR (attr) + baseaddr;
@@ -5541,14 +5565,14 @@ new_symbol (struct die_info *die, struct
/* SYMBOL_BLOCK_VALUE (sym) will be filled in later by
finish_block. */
SYMBOL_CLASS (sym) = LOC_BLOCK;
- attr2 = dwarf_attr (die, DW_AT_external);
+ attr2 = dwarf2_attr (die, DW_AT_external, cu);
if (attr2 && (DW_UNSND (attr2) != 0))
{
add_symbol_to_list (sym, &global_symbols);
}
else
{
- add_symbol_to_list (sym, list_in_scope);
+ add_symbol_to_list (sym, cu->list_in_scope);
}
break;
case DW_TAG_variable:
@@ -5560,26 +5584,26 @@ new_symbol (struct die_info *die, struct
TARGET_INT_BIT / HOST_CHAR_BIT, 0,
"<variable, no debug info>",
objfile);
- attr = dwarf_attr (die, DW_AT_const_value);
+ attr = dwarf2_attr (die, DW_AT_const_value, cu);
if (attr)
{
dwarf2_const_value (attr, sym, cu);
- attr2 = dwarf_attr (die, DW_AT_external);
+ attr2 = dwarf2_attr (die, DW_AT_external, cu);
if (attr2 && (DW_UNSND (attr2) != 0))
add_symbol_to_list (sym, &global_symbols);
else
- add_symbol_to_list (sym, list_in_scope);
+ add_symbol_to_list (sym, cu->list_in_scope);
break;
}
- attr = dwarf_attr (die, DW_AT_location);
+ attr = dwarf2_attr (die, DW_AT_location, cu);
if (attr)
{
var_decode_location (attr, sym, cu);
- attr2 = dwarf_attr (die, DW_AT_external);
+ attr2 = dwarf2_attr (die, DW_AT_external, cu);
if (attr2 && (DW_UNSND (attr2) != 0))
add_symbol_to_list (sym, &global_symbols);
else
- add_symbol_to_list (sym, list_in_scope);
+ add_symbol_to_list (sym, cu->list_in_scope);
}
else
{
@@ -5589,9 +5613,9 @@ new_symbol (struct die_info *die, struct
The address of the variable will then be determined from
the minimal symbol table whenever the variable is
referenced. */
- attr2 = dwarf_attr (die, DW_AT_external);
+ attr2 = dwarf2_attr (die, DW_AT_external, cu);
if (attr2 && (DW_UNSND (attr2) != 0)
- && dwarf_attr (die, DW_AT_type) != NULL)
+ && dwarf2_attr (die, DW_AT_type, cu) != NULL)
{
SYMBOL_CLASS (sym) = LOC_UNRESOLVED;
add_symbol_to_list (sym, &global_symbols);
@@ -5599,7 +5623,7 @@ new_symbol (struct die_info *die, struct
}
break;
case DW_TAG_formal_parameter:
- attr = dwarf_attr (die, DW_AT_location);
+ attr = dwarf2_attr (die, DW_AT_location, cu);
if (attr)
{
var_decode_location (attr, sym, cu);
@@ -5607,12 +5631,12 @@ new_symbol (struct die_info *die, struct
if (SYMBOL_CLASS (sym) == LOC_COMPUTED)
SYMBOL_CLASS (sym) = LOC_COMPUTED_ARG;
}
- attr = dwarf_attr (die, DW_AT_const_value);
+ attr = dwarf2_attr (die, DW_AT_const_value, cu);
if (attr)
{
dwarf2_const_value (attr, sym, cu);
}
- add_symbol_to_list (sym, list_in_scope);
+ add_symbol_to_list (sym, cu->list_in_scope);
break;
case DW_TAG_unspecified_parameters:
/* From varargs functions; gdb doesn't seem to have any
@@ -5631,7 +5655,7 @@ new_symbol (struct die_info *die, struct
read_structure_scope, and the correct name is saved in
the type. */
- if (cu_language == language_cplus)
+ if (cu->language == language_cplus)
{
struct type *type = SYMBOL_TYPE (sym);
@@ -5658,16 +5682,16 @@ new_symbol (struct die_info *die, struct
struct pending **list_to_add;
- list_to_add = (list_in_scope == &file_symbols
- && cu_language == language_cplus
- ? &global_symbols : list_in_scope);
+ list_to_add = (cu->list_in_scope == &file_symbols
+ && cu->language == language_cplus
+ ? &global_symbols : cu->list_in_scope);
add_symbol_to_list (sym, list_to_add);
/* The semantics of C++ state that "struct foo { ... }" also
defines a typedef for "foo". Synthesize a typedef symbol so
that "ptype foo" works as expected. */
- if (cu_language == language_cplus)
+ if (cu->language == language_cplus)
{
struct symbol *typedef_sym = (struct symbol *)
obstack_alloc (&objfile->symbol_obstack,
@@ -5694,13 +5718,13 @@ new_symbol (struct die_info *die, struct
}
SYMBOL_CLASS (sym) = LOC_TYPEDEF;
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
- add_symbol_to_list (sym, list_in_scope);
+ add_symbol_to_list (sym, cu->list_in_scope);
break;
case DW_TAG_base_type:
case DW_TAG_subrange_type:
SYMBOL_CLASS (sym) = LOC_TYPEDEF;
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
- add_symbol_to_list (sym, list_in_scope);
+ add_symbol_to_list (sym, cu->list_in_scope);
break;
case DW_TAG_enumerator:
if (processing_has_namespace_info
@@ -5711,7 +5735,7 @@ new_symbol (struct die_info *die, struct
"::",
name);
}
- attr = dwarf_attr (die, DW_AT_const_value);
+ attr = dwarf2_attr (die, DW_AT_const_value, cu);
if (attr)
{
dwarf2_const_value (attr, sym, cu);
@@ -5722,9 +5746,9 @@ new_symbol (struct die_info *die, struct
struct pending **list_to_add;
- list_to_add = (list_in_scope == &file_symbols
- && cu_language == language_cplus
- ? &global_symbols : list_in_scope);
+ list_to_add = (cu->list_in_scope == &file_symbols
+ && cu->language == language_cplus
+ ? &global_symbols : cu->list_in_scope);
add_symbol_to_list (sym, list_to_add);
}
@@ -5859,15 +5883,15 @@ die_type (struct die_info *die, struct d
struct die_info *type_die;
unsigned int ref;
- type_attr = dwarf_attr (die, DW_AT_type);
+ type_attr = dwarf2_attr (die, DW_AT_type, cu);
if (!type_attr)
{
/* A missing DW_AT_type represents a void type. */
- return dwarf2_fundamental_type (cu->objfile, FT_VOID);
+ return dwarf2_fundamental_type (cu->objfile, FT_VOID, cu);
}
else
{
- ref = dwarf2_get_ref_die_offset (type_attr);
+ ref = dwarf2_get_ref_die_offset (type_attr, cu);
type_die = follow_die_ref (ref);
if (!type_die)
{
@@ -5897,10 +5921,10 @@ die_containing_type (struct die_info *di
struct die_info *type_die = NULL;
unsigned int ref;
- type_attr = dwarf_attr (die, DW_AT_containing_type);
+ type_attr = dwarf2_attr (die, DW_AT_containing_type, cu);
if (type_attr)
{
- ref = dwarf2_get_ref_die_offset (type_attr);
+ ref = dwarf2_get_ref_die_offset (type_attr, cu);
type_die = follow_die_ref (ref);
if (!type_die)
{
@@ -5961,7 +5985,7 @@ tag_type_to_type (struct die_info *die,
static void
read_type_die (struct die_info *die, struct dwarf2_cu *cu)
{
- char *prefix = determine_prefix (die);
+ char *prefix = determine_prefix (die, cu);
const char *old_prefix = processing_current_prefix;
struct cleanup *back_to = make_cleanup (xfree, prefix);
processing_current_prefix = prefix;
@@ -6028,9 +6052,9 @@ read_type_die (struct die_info *die, str
DW_AT_specification. */
static char *
-determine_prefix (struct die_info *die)
+determine_prefix (struct die_info *die, struct dwarf2_cu *cu)
{
- char *prefix = determine_prefix_aux (die);
+ char *prefix = determine_prefix_aux (die, cu);
return prefix ? prefix : xstrdup ("");
}
@@ -6040,11 +6064,11 @@ determine_prefix (struct die_info *die)
result. */
static char *
-determine_prefix_aux (struct die_info *die)
+determine_prefix_aux (struct die_info *die, struct dwarf2_cu *cu)
{
struct die_info *parent;
- if (cu_language != language_cplus)
+ if (cu->language != language_cplus)
return NULL;
parent = die->parent;
@@ -6055,7 +6079,7 @@ determine_prefix_aux (struct die_info *d
}
else
{
- char *parent_prefix = determine_prefix_aux (parent);
+ char *parent_prefix = determine_prefix_aux (parent, cu);
char *retval;
switch (parent->tag) {
@@ -6064,7 +6088,7 @@ determine_prefix_aux (struct die_info *d
int dummy;
retval = typename_concat (parent_prefix,
- namespace_name (parent, &dummy));
+ namespace_name (parent, &dummy, cu));
}
break;
case DW_TAG_class_type:
@@ -6072,10 +6096,10 @@ determine_prefix_aux (struct die_info *d
{
if (parent_prefix != NULL)
{
- const char *parent_name = dwarf2_name (parent);
+ const char *parent_name = dwarf2_name (parent, cu);
if (parent_name != NULL)
- retval = typename_concat (parent_prefix, dwarf2_name (parent));
+ retval = typename_concat (parent_prefix, dwarf2_name (parent, cu));
else
/* FIXME: carlton/2003-11-10: I'm not sure what the
best thing to do here is. */
@@ -6083,7 +6107,7 @@ determine_prefix_aux (struct die_info *d
"<<anonymous class>>");
}
else
- retval = class_name (parent);
+ retval = class_name (parent, cu);
}
break;
default:
@@ -6122,7 +6146,7 @@ typename_concat (const char *prefix, con
by DIE. */
static char *
-class_name (struct die_info *die)
+class_name (struct die_info *die, struct dwarf2_cu *cu)
{
struct die_info *child;
const char *name;
@@ -6130,10 +6154,10 @@ class_name (struct die_info *die)
for (child = die->child; child != NULL; child = sibling_die (child))
{
if (child->tag == DW_TAG_subprogram)
- return class_name_from_physname (dwarf2_linkage_name (child));
+ return class_name_from_physname (dwarf2_linkage_name (child, cu));
}
- name = dwarf2_name (die);
+ name = dwarf2_name (die, cu);
if (name != NULL)
return xstrdup (name);
else
@@ -6151,69 +6175,69 @@ dwarf_base_type (int encoding, int size,
switch (encoding)
{
case DW_ATE_address:
- type = dwarf2_fundamental_type (objfile, FT_VOID);
+ type = dwarf2_fundamental_type (objfile, FT_VOID, cu);
return type;
case DW_ATE_boolean:
- type = dwarf2_fundamental_type (objfile, FT_BOOLEAN);
+ type = dwarf2_fundamental_type (objfile, FT_BOOLEAN, cu);
return type;
case DW_ATE_complex_float:
if (size == 16)
{
- type = dwarf2_fundamental_type (objfile, FT_DBL_PREC_COMPLEX);
+ type = dwarf2_fundamental_type (objfile, FT_DBL_PREC_COMPLEX, cu);
}
else
{
- type = dwarf2_fundamental_type (objfile, FT_COMPLEX);
+ type = dwarf2_fundamental_type (objfile, FT_COMPLEX, cu);
}
return type;
case DW_ATE_float:
if (size == 8)
{
- type = dwarf2_fundamental_type (objfile, FT_DBL_PREC_FLOAT);
+ type = dwarf2_fundamental_type (objfile, FT_DBL_PREC_FLOAT, cu);
}
else
{
- type = dwarf2_fundamental_type (objfile, FT_FLOAT);
+ type = dwarf2_fundamental_type (objfile, FT_FLOAT, cu);
}
return type;
case DW_ATE_signed:
switch (size)
{
case 1:
- type = dwarf2_fundamental_type (objfile, FT_SIGNED_CHAR);
+ type = dwarf2_fundamental_type (objfile, FT_SIGNED_CHAR, cu);
break;
case 2:
- type = dwarf2_fundamental_type (objfile, FT_SIGNED_SHORT);
+ type = dwarf2_fundamental_type (objfile, FT_SIGNED_SHORT, cu);
break;
default:
case 4:
- type = dwarf2_fundamental_type (objfile, FT_SIGNED_INTEGER);
+ type = dwarf2_fundamental_type (objfile, FT_SIGNED_INTEGER, cu);
break;
}
return type;
case DW_ATE_signed_char:
- type = dwarf2_fundamental_type (objfile, FT_SIGNED_CHAR);
+ type = dwarf2_fundamental_type (objfile, FT_SIGNED_CHAR, cu);
return type;
case DW_ATE_unsigned:
switch (size)
{
case 1:
- type = dwarf2_fundamental_type (objfile, FT_UNSIGNED_CHAR);
+ type = dwarf2_fundamental_type (objfile, FT_UNSIGNED_CHAR, cu);
break;
case 2:
- type = dwarf2_fundamental_type (objfile, FT_UNSIGNED_SHORT);
+ type = dwarf2_fundamental_type (objfile, FT_UNSIGNED_SHORT, cu);
break;
default:
case 4:
- type = dwarf2_fundamental_type (objfile, FT_UNSIGNED_INTEGER);
+ type = dwarf2_fundamental_type (objfile, FT_UNSIGNED_INTEGER, cu);
break;
}
return type;
case DW_ATE_unsigned_char:
- type = dwarf2_fundamental_type (objfile, FT_UNSIGNED_CHAR);
+ type = dwarf2_fundamental_type (objfile, FT_UNSIGNED_CHAR, cu);
return type;
default:
- type = dwarf2_fundamental_type (objfile, FT_SIGNED_INTEGER);
+ type = dwarf2_fundamental_type (objfile, FT_SIGNED_INTEGER, cu);
return type;
}
}
@@ -6262,14 +6286,14 @@ sibling_die (struct die_info *die)
/* Get linkage name of a die, return NULL if not found. */
static char *
-dwarf2_linkage_name (struct die_info *die)
+dwarf2_linkage_name (struct die_info *die, struct dwarf2_cu *cu)
{
struct attribute *attr;
- attr = dwarf_attr (die, DW_AT_MIPS_linkage_name);
+ attr = dwarf2_attr (die, DW_AT_MIPS_linkage_name, cu);
if (attr && DW_STRING (attr))
return DW_STRING (attr);
- attr = dwarf_attr (die, DW_AT_name);
+ attr = dwarf2_attr (die, DW_AT_name, cu);
if (attr && DW_STRING (attr))
return DW_STRING (attr);
return NULL;
@@ -6278,11 +6302,11 @@ dwarf2_linkage_name (struct die_info *di
/* Get name of a die, return NULL if not found. */
static char *
-dwarf2_name (struct die_info *die)
+dwarf2_name (struct die_info *die, struct dwarf2_cu *cu)
{
struct attribute *attr;
- attr = dwarf_attr (die, DW_AT_name);
+ attr = dwarf2_attr (die, DW_AT_name, cu);
if (attr && DW_STRING (attr))
return DW_STRING (attr);
return NULL;
@@ -6292,17 +6316,17 @@ dwarf2_name (struct die_info *die)
is none. */
static struct die_info *
-dwarf2_extension (struct die_info *die)
+dwarf2_extension (struct die_info *die, struct dwarf2_cu *cu)
{
struct attribute *attr;
struct die_info *extension_die;
unsigned int ref;
- attr = dwarf_attr (die, DW_AT_extension);
+ attr = dwarf2_attr (die, DW_AT_extension, cu);
if (attr == NULL)
return NULL;
- ref = dwarf2_get_ref_die_offset (attr);
+ ref = dwarf2_get_ref_die_offset (attr, cu);
extension_die = follow_die_ref (ref);
if (!extension_die)
{
@@ -7215,7 +7239,7 @@ dwarf2_empty_hash_tables (void)
}
static unsigned int
-dwarf2_get_ref_die_offset (struct attribute *attr)
+dwarf2_get_ref_die_offset (struct attribute *attr, struct dwarf2_cu *cu)
{
unsigned int result = 0;
@@ -7229,7 +7253,7 @@ dwarf2_get_ref_die_offset (struct attrib
case DW_FORM_ref4:
case DW_FORM_ref8:
case DW_FORM_ref_udata:
- result = cu_header_offset + DW_UNSND (attr);
+ result = cu->header.offset + DW_UNSND (attr);
break;
default:
complaint (&symfile_complaints,
@@ -7281,7 +7305,8 @@ follow_die_ref (unsigned int offset)
}
static struct type *
-dwarf2_fundamental_type (struct objfile *objfile, int typeid)
+dwarf2_fundamental_type (struct objfile *objfile, int typeid,
+ struct dwarf2_cu *cu)
{
if (typeid < 0 || typeid >= FT_NUM_MEMBERS)
{
@@ -7293,12 +7318,12 @@ dwarf2_fundamental_type (struct objfile
one is not found, create and install one appropriate for the
current language and the current target machine. */
- if (ftypes[typeid] == NULL)
+ if (cu->ftypes[typeid] == NULL)
{
- ftypes[typeid] = cu_language_defn->la_fund_type (objfile, typeid);
+ cu->ftypes[typeid] = cu->language_defn->la_fund_type (objfile, typeid);
}
- return (ftypes[typeid]);
+ return (cu->ftypes[typeid]);
}
/* Decode simple location descriptions.