[RFA] dwarf2read global state cleanups, continued

Daniel Jacobowitz
2004-01-19T15:25:07Z

This patch removes every remaining static variable which is specific to a
particular compilation unit, as opposed to an entire objfile. This will
allow intra-objfile inter-cu reference support. The only remaining headache
I know of is the struct pending's from buildsym; I will probably end up
context switching them into the dwarf2_cu structure, ugh.

Notes about the patch:
- baseaddr can be rematerialized from cu->objfile everywhere it is used,
so it becomes a local variable.
- cu_header_offset was already cu.header.offset. It needed to be
initialized for the full symtab case, and caused a cascade of new
cu parameters. I had to change every call to dwarf_attr, so I
took the chance to make it dwarf2_attr while I was there.
- Every other variable moved from file scope into the dwarf2_cu.

Next I'm going to work on inter-CU references for the partial symbols, then
eventually full symbols. Is this patch OK?

--
Daniel Jacobowitz
MontaVista Software Debian GNU/Linux Developer

2004-01-19 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, 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.122
diff -u -p -r1.122 dwarf2read.c
--- dwarf2read.c 17 Jan 2004 05:35:47 -0000 1.122
+++ dwarf2read.c 19 Jan 2004 15:08:54 -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,11 +765,11 @@ 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 (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 *);

@@ -813,7 +806,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 *);

@@ -856,11 +849,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);

@@ -890,13 +884,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 */

@@ -908,9 +904,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 *);
@@ -1148,7 +1145,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;
@@ -1232,6 +1229,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);
@@ -1241,7 +1240,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,
@@ -1252,7 +1251,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;
@@ -1442,6 +1440,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. */
@@ -1465,7 +1466,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
{
@@ -1475,7 +1476,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:
@@ -1501,7 +1502,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
{
@@ -1515,7 +1516,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:
@@ -1524,7 +1525,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:
@@ -1538,27 +1539,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;
@@ -1570,7 +1571,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)
@@ -1633,7 +1634,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. */

@@ -1653,7 +1654,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)
@@ -1695,7 +1696,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);
}
@@ -1804,6 +1805,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);
@@ -1820,9 +1822,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 = "";
@@ -1842,6 +1843,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);
@@ -1855,7 +1860,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);
@@ -1863,7 +1868,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);
@@ -1904,9 +1909,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;
@@ -1968,7 +1973,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);
@@ -1976,7 +1981,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);
@@ -2009,9 +2014,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
@@ -2028,7 +2033,10 @@ 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));
+
if (!dwarf2_get_pc_bounds (die, &lowpc, &highpc, cu))
{
if (die->child != NULL)
@@ -2058,12 +2066,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);
@@ -2085,10 +2093,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. */
@@ -2103,12 +2111,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)
@@ -2122,7 +2130,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);
@@ -2139,7 +2147,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);
@@ -2150,7 +2158,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;

@@ -2162,12 +2171,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
@@ -2180,8 +2189,11 @@ read_func_scope (struct die_info *die, s
struct die_info *child_die;
struct attribute *attr;
char *name;
+ 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. */
@@ -2192,7 +2204,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)
@@ -2206,11 +2218,11 @@ 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)
dwarf2_symbol_mark_computed (attr, new->name, cu);

- list_in_scope = &local_symbols;
+ cu->list_in_scope = &local_symbols;

if (die->child != NULL)
{
@@ -2237,7 +2249,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;
}

/* Process all the DIES contained within a lexical block scope. Start
@@ -2250,6 +2262,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
@@ -2296,11 +2311,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
@@ -2312,7 +2327,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;
@@ -2469,18 +2484,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. */

@@ -2490,7 +2505,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);
@@ -2501,7 +2516,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) =
@@ -2509,7 +2524,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)
@@ -2532,7 +2547,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
@@ -2554,7 +2569,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),
@@ -2562,7 +2577,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;
@@ -2580,14 +2595,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));
@@ -2598,7 +2613,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);
@@ -2713,14 +2728,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++)
@@ -2790,14 +2805,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))
@@ -2812,12 +2827,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 */
@@ -2904,18 +2919,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);
}
@@ -2940,7 +2955,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);
}
}

@@ -2959,7 +2974,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);
@@ -2974,7 +2989,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;
@@ -3024,7 +3039,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)
{
@@ -3060,7 +3075,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);

@@ -3141,7 +3156,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);
@@ -3161,7 +3176,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);
@@ -3184,7 +3199,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);
@@ -3256,7 +3271,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;
@@ -3300,7 +3315,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;

@@ -3320,7 +3335,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 */
@@ -3344,7 +3359,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) =
@@ -3367,7 +3382,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. */

@@ -3392,7 +3407,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;

@@ -3430,7 +3445,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;
@@ -3439,9 +3454,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;
}
@@ -3474,13 +3489,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
@@ -3552,7 +3567,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);
@@ -3610,7 +3625,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);
@@ -3618,7 +3633,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);
@@ -3628,9 +3643,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 */
@@ -3638,7 +3653,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;
@@ -3671,9 +3686,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)
@@ -3710,7 +3725,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
@@ -3734,7 +3749,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);
@@ -3761,17 +3776,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;
@@ -3808,18 +3823,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
@@ -3855,17 +3871,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)
@@ -3889,11 +3905,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);

@@ -4270,7 +4286,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;
@@ -4285,7 +4301,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)
{
@@ -4819,27 +4836,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:
@@ -4848,16 +4865,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;
@@ -4875,34 +4892,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
@@ -5096,26 +5113,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
@@ -5146,6 +5163,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;
@@ -5191,7 +5212,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)
@@ -5238,7 +5259,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:
@@ -5419,9 +5440,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);

@@ -5433,7 +5457,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.
@@ -5444,7 +5468,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);
@@ -5452,7 +5476,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;
@@ -5463,14 +5487,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:
@@ -5482,26 +5506,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
{
@@ -5511,9 +5535,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);
@@ -5521,7 +5545,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);
@@ -5529,12 +5553,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
@@ -5553,7 +5577,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);

@@ -5580,16 +5604,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,
@@ -5616,13 +5640,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
@@ -5633,7 +5657,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);
@@ -5644,9 +5668,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);
}
@@ -5781,15 +5805,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)
{
@@ -5819,10 +5843,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)
{
@@ -5883,7 +5907,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;
@@ -5947,11 +5971,11 @@ read_type_die (struct die_info *die, str
result. */

static char *
-determine_prefix (struct die_info *die)
+determine_prefix (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;
@@ -5962,7 +5986,7 @@ determine_prefix (struct die_info *die)
}
else
{
- char *parent_prefix = determine_prefix (parent);
+ char *parent_prefix = determine_prefix (parent, cu);
char *retval;

switch (parent->tag) {
@@ -5971,7 +5995,7 @@ determine_prefix (struct die_info *die)
int dummy;

retval = typename_concat (parent_prefix,
- namespace_name (parent, &dummy));
+ namespace_name (parent, &dummy, cu));
}
break;
case DW_TAG_class_type:
@@ -5979,10 +6003,10 @@ determine_prefix (struct die_info *die)
{
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. */
@@ -5990,7 +6014,7 @@ determine_prefix (struct die_info *die)
"<<anonymous class>>");
}
else
- retval = class_name (parent);
+ retval = class_name (parent, cu);
}
break;
default:
@@ -6029,7 +6053,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;
@@ -6037,10 +6061,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
@@ -6058,69 +6082,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;
}
}
@@ -6169,14 +6193,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;
@@ -6185,11 +6209,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;
@@ -6199,17 +6223,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)
{
@@ -7122,7 +7146,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;

@@ -7136,7 +7160,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,
@@ -7188,7 +7212,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)
{
@@ -7200,12 +7225,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.