#include <ctype.h>
#include "gdb_bfd.h"
#include "f-lang.h"
+#include "source.h"
#include <fcntl.h>
#include "gdb_string.h"
/* When non-zero, do not reject deprecated .gdb_index sections. */
static int use_deprecated_index_sections = 0;
-/* When set, the file that we're processing is known to have debugging
- info for C++ namespaces. GCC 3.3.x did not produce this information,
- but later versions do. */
-
-static int processing_has_namespace_info;
-
static const struct objfile_data *dwarf2_objfile_data_key;
struct dwarf2_section_info
unsigned int producer_is_gxx_lt_4_6 : 1;
unsigned int producer_is_gcc_lt_4_3 : 1;
unsigned int producer_is_icc : 1;
+
+ /* When set, the file that we're processing is known to have
+ debugging info for C++ namespaces. GCC 3.3.x did not produce
+ this information, but later versions do. */
+
+ unsigned int processing_has_namespace_info : 1;
};
/* Persistent data held for a compilation unit, even when not
struct dwarf2_per_cu_quick_data *quick;
} v;
- union
- {
- /* The CUs we import using DW_TAG_imported_unit. This is filled in
- while reading psymtabs, used to compute the psymtab dependencies,
- and then cleared. Then it is filled in again while reading full
- symbols, and only deleted when the objfile is destroyed. */
- VEC (dwarf2_per_cu_ptr) *imported_symtabs;
-
- /* Type units are grouped by their DW_AT_stmt_list entry so that they
- can share them. If this is a TU, this points to the containing
- symtab. */
- struct type_unit_group *type_unit_group;
- } s;
+ /* The CUs we import using DW_TAG_imported_unit. This is filled in
+ while reading psymtabs, used to compute the psymtab dependencies,
+ and then cleared. Then it is filled in again while reading full
+ symbols, and only deleted when the objfile is destroyed.
+
+ This is also used to work around a difference between the way gold
+ generates .gdb_index version <=7 and the way gdb does. Arguably this
+ is a gold bug. For symbols coming from TUs, gold records in the index
+ the CU that includes the TU instead of the TU itself. This breaks
+ dw2_lookup_symbol: It assumes that if the index says symbol X lives
+ in CU/TU Y, then one need only expand Y and a subsequent lookup in Y
+ will find X. Alas TUs live in their own symtab, so after expanding CU Y
+ we need to look in TU Z to find X. Fortunately, this is akin to
+ DW_TAG_imported_unit, so we just use the same mechanism: For
+ .gdb_index version <=7 this also records the TUs that the CU referred
+ to. Concurrently with this change gdb was modified to emit version 8
+ indices so we only pay a price for gold generated indices. */
+ VEC (dwarf2_per_cu_ptr) *imported_symtabs;
+
+ /* Type units are grouped by their DW_AT_stmt_list entry so that they
+ can share them. If this is a TU, this points to the containing
+ symtab. */
+ struct type_unit_group *type_unit_group;
};
/* Entry in the signatured_types hash table. */
/* The name of this DIE. Normally the value of DW_AT_name, but
sometimes a default name for unnamed DIEs. */
- char *name;
+ const char *name;
/* The linkage name, if present. */
const char *linkage_name;
/* The scope to prepend to our children. This is generally
allocated on the comp_unit_obstack, so will disappear
when this compilation unit leaves the cache. */
- char *scope;
+ const char *scope;
/* Some data associated with the partial DIE. The tag determines
which field is live. */
union
{
- char *str;
+ const char *str;
struct dwarf_block *blk;
ULONGEST unsnd;
LONGEST snd;
to the head of the member function field chain. */
struct fnfieldlist
{
- char *name;
+ const char *name;
int length;
struct nextfnfield *head;
}
static void dwarf2_start_subfile (char *, const char *, const char *);
static void dwarf2_start_symtab (struct dwarf2_cu *,
- char *, char *, CORE_ADDR);
+ const char *, const char *, CORE_ADDR);
static struct symbol *new_symbol (struct die_info *, struct type *,
struct dwarf2_cu *);
static void process_die (struct die_info *, struct dwarf2_cu *);
-static char *dwarf2_canonicalize_name (char *, struct dwarf2_cu *,
- struct obstack *);
+static const char *dwarf2_canonicalize_name (const char *, struct dwarf2_cu *,
+ struct obstack *);
-static char *dwarf2_name (struct die_info *die, struct dwarf2_cu *);
+static const char *dwarf2_name (struct die_info *die, struct dwarf2_cu *);
-static const char *dwarf2_full_name (char *name,
+static const char *dwarf2_full_name (const char *name,
struct die_info *die,
struct dwarf2_cu *cu);
static struct die_info *dwarf_alloc_die (struct dwarf2_cu *, int);
static void dwarf_decode_macros (struct dwarf2_cu *, unsigned int,
- char *, int);
+ const char *, int);
static int attr_form_is_block (struct attribute *);
static void find_file_and_directory (struct die_info *die,
struct dwarf2_cu *cu,
- char **name, char **comp_dir);
+ const char **name, const char **comp_dir);
static char *file_full_name (int file, struct line_header *lh,
const char *comp_dir);
/* The suffix for an index file. */
#define INDEX_SUFFIX ".gdb-index"
-static const char *dwarf2_physname (char *name, struct die_info *die,
+static const char *dwarf2_physname (const char *name, struct die_info *die,
struct dwarf2_cu *cu);
/* Try to locate the sections we need for DWARF 2 debugging
}
return 0;
}
+ /* Version 7 indices generated by gold refer to the CU for a symbol instead
+ of the TU (for symbols coming from TUs). It's just a performance bug, and
+ we can't distinguish gdb-generated indices from gold-generated ones, so
+ nothing to do here. */
+
/* Indexes with higher version than the one supported by GDB may be no
longer backward compatible. */
- if (version > 7)
+ if (version > 8)
return 0;
map->version = version;
struct line_header *lh;
struct attribute *attr;
int i;
- char *name, *comp_dir;
+ const char *name, *comp_dir;
void **slot;
struct quick_file_names *qfn;
unsigned int line_offset;
DWO file. */
if (this_cu->is_debug_types)
{
- struct type_unit_group *tu_group = this_cu->s.type_unit_group;
+ struct type_unit_group *tu_group = this_cu->type_unit_group;
init_cutu_and_read_dies (tu_group->t.first_tu, NULL, 0, 0,
dw2_get_file_names_reader, tu_group);
static int
dw2_map_expand_apply (struct objfile *objfile,
struct dwarf2_per_cu_data *per_cu,
- const char *name,
- const char *full_path, const char *real_path,
+ const char *name, const char *real_path,
int (*callback) (struct symtab *, void *),
void *data)
{
all of them. */
dw2_instantiate_symtab (per_cu);
- return iterate_over_some_symtabs (name, full_path, real_path, callback, data,
+ return iterate_over_some_symtabs (name, real_path, callback, data,
objfile->symtabs, last_made);
}
static int
dw2_map_symtabs_matching_filename (struct objfile *objfile, const char *name,
- const char *full_path, const char *real_path,
+ const char *real_path,
int (*callback) (struct symtab *, void *),
void *data)
{
int i;
const char *name_basename = lbasename (name);
- int is_abs = IS_ABSOLUTE_PATH (name);
dw2_setup (objfile);
{
const char *this_name = file_data->file_names[j];
- if (FILENAME_CMP (name, this_name) == 0
- || (!is_abs && compare_filenames_for_search (this_name, name)))
+ if (compare_filenames_for_search (this_name, name))
{
- if (dw2_map_expand_apply (objfile, per_cu,
- name, full_path, real_path,
+ if (dw2_map_expand_apply (objfile, per_cu, name, real_path,
callback, data))
return 1;
}
&& FILENAME_CMP (lbasename (this_name), name_basename) != 0)
continue;
- if (full_path != NULL)
- {
- const char *this_real_name = dw2_get_real_path (objfile,
- file_data, j);
-
- if (this_real_name != NULL
- && (FILENAME_CMP (full_path, this_real_name) == 0
- || (!is_abs
- && compare_filenames_for_search (this_real_name,
- name))))
- {
- if (dw2_map_expand_apply (objfile, per_cu,
- name, full_path, real_path,
- callback, data))
- return 1;
- }
- }
-
if (real_path != NULL)
{
const char *this_real_name = dw2_get_real_path (objfile,
file_data, j);
+ gdb_assert (IS_ABSOLUTE_PATH (real_path));
+ gdb_assert (IS_ABSOLUTE_PATH (name));
if (this_real_name != NULL
- && (FILENAME_CMP (real_path, this_real_name) == 0
- || (!is_abs
- && compare_filenames_for_search (this_real_name,
- name))))
+ && FILENAME_CMP (real_path, this_real_name) == 0)
{
- if (dw2_map_expand_apply (objfile, per_cu,
- name, full_path, real_path,
+ if (dw2_map_expand_apply (objfile, per_cu, name, real_path,
callback, data))
return 1;
}
}
static void
-dw2_expand_symtabs_with_filename (struct objfile *objfile,
- const char *filename)
+dw2_expand_symtabs_with_fullname (struct objfile *objfile,
+ const char *fullname)
{
int i;
for (j = 0; j < file_data->num_file_names; ++j)
{
- const char *this_name = file_data->file_names[j];
- if (FILENAME_CMP (this_name, filename) == 0)
+ const char *this_fullname = file_data->file_names[j];
+
+ if (filename_cmp (this_fullname, fullname) == 0)
{
dw2_instantiate_symtab (per_cu);
break;
struct symbol *sym = lookup_block_symbol (block, name, VAR_DOMAIN);
if (sym)
- return SYMBOL_SYMTAB (sym)->filename;
+ {
+ /* Only file extension of returned filename is recognized. */
+ return SYMBOL_SYMTAB (sym)->filename;
+ }
}
return NULL;
}
per_cu = dw2_get_cu (GDB_INDEX_CU_VALUE (MAYBE_SWAP (vec[1])));
if (per_cu->v.quick->symtab != NULL)
- return per_cu->v.quick->symtab->filename;
+ {
+ /* Only file extension of returned filename is recognized. */
+ return per_cu->v.quick->symtab->filename;
+ }
init_cutu_and_read_dies (per_cu, NULL, 0, 0,
dw2_get_primary_filename_reader, &filename);
+ /* Only file extension of returned filename is recognized. */
return filename;
}
static void
dw2_expand_symtabs_matching
(struct objfile *objfile,
- int (*file_matcher) (const char *, void *),
+ int (*file_matcher) (const char *, void *, int basenames),
int (*name_matcher) (const char *, void *),
enum search_domain kind,
void *data)
for (j = 0; j < file_data->num_file_names; ++j)
{
- if (file_matcher (file_data->file_names[j], data))
+ if (file_matcher (file_data->file_names[j], data, 0))
{
per_cu->v.quick->mark = 1;
break;
dw2_relocate,
dw2_expand_symtabs_for_function,
dw2_expand_all_symtabs,
- dw2_expand_symtabs_with_filename,
+ dw2_expand_symtabs_with_fullname,
dw2_find_symbol_file,
dw2_map_matching_symbols,
dw2_expand_symtabs_matching,
{
struct partial_symtab *subpst = allocate_psymtab (name, objfile);
+ if (!IS_ABSOLUTE_PATH (subpst->filename))
+ {
+ /* It shares objfile->objfile_obstack. */
+ subpst->dirname = pst->dirname;
+ }
+
subpst->section_offsets = pst->section_offsets;
subpst->textlow = 0;
subpst->texthigh = 0;
attr = dwarf2_attr (comp_unit_die, DW_AT_GNU_dwo_name, cu);
if (attr)
{
- char *dwo_name = DW_STRING (attr);
+ const char *dwo_name = DW_STRING (attr);
const char *comp_dir_string;
struct dwo_unit *dwo_unit;
ULONGEST signature; /* Or dwo_id. */
(objfile->static_psymbols.list + pst->statics_offset);
sort_pst_symbols (objfile, pst);
- if (!VEC_empty (dwarf2_per_cu_ptr, cu->per_cu->s.imported_symtabs))
+ if (!VEC_empty (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs))
{
int i;
- int len = VEC_length (dwarf2_per_cu_ptr, cu->per_cu->s.imported_symtabs);
+ int len = VEC_length (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs);
struct dwarf2_per_cu_data *iter;
/* Fill in 'dependencies' here; we fill in 'users' in a
pst->dependencies = obstack_alloc (&objfile->objfile_obstack,
len * sizeof (struct symtab *));
for (i = 0;
- VEC_iterate (dwarf2_per_cu_ptr, cu->per_cu->s.imported_symtabs,
+ VEC_iterate (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs,
i, iter);
++i)
pst->dependencies[i] = iter->v.psymtab;
- VEC_free (dwarf2_per_cu_ptr, cu->per_cu->s.imported_symtabs);
+ VEC_free (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs);
}
/* Get the list of files included in the current compilation unit,
per_cu = &tu_group->per_cu;
per_cu->objfile = objfile;
per_cu->is_debug_types = 1;
- per_cu->s.type_unit_group = tu_group;
+ per_cu->type_unit_group = tu_group;
if (dwarf2_per_objfile->using_index)
{
++i)
{
pst->dependencies[i] = iter->v.psymtab;
- iter->s.type_unit_group = tu_group;
+ iter->type_unit_group = tu_group;
}
VEC_free (dwarf2_per_cu_ptr, tu_group->t.tus);
process_psymtab_comp_unit (per_cu, 1);
VEC_safe_push (dwarf2_per_cu_ptr,
- cu->per_cu->s.imported_symtabs, per_cu);
+ cu->per_cu->imported_symtabs, per_cu);
}
break;
default:
compilation unit CU. The result will be allocated on CU's
comp_unit_obstack, or a copy of the already allocated PDI->NAME
field. NULL is returned if no prefix is necessary. */
-static char *
+static const char *
partial_die_parent_scope (struct partial_die_info *pdi,
struct dwarf2_cu *cu)
{
- char *grandparent_scope;
+ const char *grandparent_scope;
struct partial_die_info *parent, *real_pdi;
/* We need to look at our parent DIE; if we have a DW_AT_specification,
partial_die_full_name (struct partial_die_info *pdi,
struct dwarf2_cu *cu)
{
- char *parent_scope;
+ const char *parent_scope;
/* If this is a template instantiation, we can not work out the
template arguments from partial DIEs. So, unfortunately, we have
{
struct objfile *objfile = cu->objfile;
CORE_ADDR addr = 0;
- char *actual_name = NULL;
+ const char *actual_name = NULL;
CORE_ADDR baseaddr;
- int built_actual_name = 0;
+ char *built_actual_name;
baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
- actual_name = partial_die_full_name (pdi, cu);
- if (actual_name)
- built_actual_name = 1;
+ built_actual_name = partial_die_full_name (pdi, cu);
+ if (built_actual_name != NULL)
+ actual_name = built_actual_name;
if (actual_name == NULL)
actual_name = pdi->name;
/* prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
mst_text, objfile); */
add_psymbol_to_list (actual_name, strlen (actual_name),
- built_actual_name,
+ built_actual_name != NULL,
VAR_DOMAIN, LOC_BLOCK,
&objfile->global_psymbols,
0, pdi->lowpc + baseaddr,
/* prim_record_minimal_symbol (actual_name, pdi->lowpc + baseaddr,
mst_file_text, objfile); */
add_psymbol_to_list (actual_name, strlen (actual_name),
- built_actual_name,
+ built_actual_name != NULL,
VAR_DOMAIN, LOC_BLOCK,
&objfile->static_psymbols,
0, pdi->lowpc + baseaddr,
else
list = &objfile->static_psymbols;
add_psymbol_to_list (actual_name, strlen (actual_name),
- built_actual_name, VAR_DOMAIN, LOC_STATIC,
+ built_actual_name != NULL, VAR_DOMAIN, LOC_STATIC,
list, 0, 0, cu->language, objfile);
}
break;
if (pdi->d.locdesc || pdi->has_type)
add_psymbol_to_list (actual_name, strlen (actual_name),
- built_actual_name,
+ built_actual_name != NULL,
VAR_DOMAIN, LOC_STATIC,
&objfile->global_psymbols,
0, addr + baseaddr,
/* Static Variable. Skip symbols without location descriptors. */
if (pdi->d.locdesc == NULL)
{
- if (built_actual_name)
- xfree (actual_name);
+ xfree (built_actual_name);
return;
}
/* prim_record_minimal_symbol (actual_name, addr + baseaddr,
mst_file_data, objfile); */
add_psymbol_to_list (actual_name, strlen (actual_name),
- built_actual_name,
+ built_actual_name != NULL,
VAR_DOMAIN, LOC_STATIC,
&objfile->static_psymbols,
0, addr + baseaddr,
case DW_TAG_base_type:
case DW_TAG_subrange_type:
add_psymbol_to_list (actual_name, strlen (actual_name),
- built_actual_name,
+ built_actual_name != NULL,
VAR_DOMAIN, LOC_TYPEDEF,
&objfile->static_psymbols,
0, (CORE_ADDR) 0, cu->language, objfile);
break;
case DW_TAG_namespace:
add_psymbol_to_list (actual_name, strlen (actual_name),
- built_actual_name,
+ built_actual_name != NULL,
VAR_DOMAIN, LOC_TYPEDEF,
&objfile->global_psymbols,
0, (CORE_ADDR) 0, cu->language, objfile);
and that has a DW_AT_declaration attribute." */
if (!pdi->has_byte_size && pdi->is_declaration)
{
- if (built_actual_name)
- xfree (actual_name);
+ xfree (built_actual_name);
return;
}
/* NOTE: carlton/2003-10-07: See comment in new_symbol about
static vs. global. */
add_psymbol_to_list (actual_name, strlen (actual_name),
- built_actual_name,
+ built_actual_name != NULL,
STRUCT_DOMAIN, LOC_TYPEDEF,
(cu->language == language_cplus
|| cu->language == language_java)
break;
case DW_TAG_enumerator:
add_psymbol_to_list (actual_name, strlen (actual_name),
- built_actual_name,
+ built_actual_name != NULL,
VAR_DOMAIN, LOC_CONST,
(cu->language == language_cplus
|| cu->language == language_java)
break;
}
- if (built_actual_name)
- xfree (actual_name);
+ xfree (built_actual_name);
}
/* Read a partial die corresponding to a namespace; also, add a symbol
const char *physname;
struct fn_fieldlist *fn_flp
= &TYPE_FN_FIELDLIST (mi->type, mi->fnfield_index);
- physname = dwarf2_physname ((char *) mi->name, mi->die, cu);
+ physname = dwarf2_physname (mi->name, mi->die, cu);
fn_flp->fn_fields[mi->index].physname = physname ? physname : "";
}
}
complaint (&symfile_complaints,
_("Symtab %s has objects from two different Go packages: %s and %s"),
(SYMBOL_SYMTAB (sym)
- ? SYMBOL_SYMTAB (sym)->filename
+ ? symtab_to_filename_for_display (SYMBOL_SYMTAB (sym))
: cu->objfile->name),
this_package_name, package_name);
xfree (this_package_name);
if (package_name != NULL)
{
struct objfile *objfile = cu->objfile;
+ const char *saved_package_name = obstack_copy0 (&objfile->objfile_obstack,
+ package_name,
+ strlen (package_name));
struct type *type = init_type (TYPE_CODE_MODULE, 0, 0,
- package_name, objfile);
+ saved_package_name, objfile);
struct symbol *sym;
TYPE_TAG_NAME (type) = TYPE_NAME (type);
sym = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct symbol);
SYMBOL_SET_LANGUAGE (sym, language_go);
- SYMBOL_SET_NAMES (sym, package_name, strlen (package_name), 1, objfile);
+ SYMBOL_SET_NAMES (sym, saved_package_name,
+ strlen (saved_package_name), 0, objfile);
/* This is not VAR_DOMAIN because we want a way to ensure a lookup of,
e.g., "main" finds the "main" module and not C's main(). */
SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
VEC_safe_push (dwarf2_per_cu_ptr, *result, per_cu);
for (ix = 0;
- VEC_iterate (dwarf2_per_cu_ptr, per_cu->s.imported_symtabs, ix, iter);
+ VEC_iterate (dwarf2_per_cu_ptr, per_cu->imported_symtabs, ix, iter);
++ix)
recursively_compute_inclusions (result, all_children, iter);
}
{
gdb_assert (! per_cu->is_debug_types);
- if (!VEC_empty (dwarf2_per_cu_ptr, per_cu->s.imported_symtabs))
+ if (!VEC_empty (dwarf2_per_cu_ptr, per_cu->imported_symtabs))
{
int ix, len;
struct dwarf2_per_cu_data *iter;
NULL, xcalloc, xfree);
for (ix = 0;
- VEC_iterate (dwarf2_per_cu_ptr, per_cu->s.imported_symtabs,
+ VEC_iterate (dwarf2_per_cu_ptr, per_cu->imported_symtabs,
ix, iter);
++ix)
recursively_compute_inclusions (&result_children, all_children, iter);
- /* Now we have a transitive closure of all the included CUs, so
- we can convert it to a list of symtabs. */
+ /* Now we have a transitive closure of all the included CUs, and
+ for .gdb_index version 7 the included TUs, so we can convert it
+ to a list of symtabs. */
len = VEC_length (dwarf2_per_cu_ptr, result_children);
symtab->includes
= obstack_alloc (&dwarf2_per_objfile->objfile->objfile_obstack,
static_block
= end_symtab_get_static_block (highpc + baseaddr, objfile, 0,
- per_cu->s.imported_symtabs != NULL);
+ per_cu->imported_symtabs != NULL);
/* If the comp unit has DW_AT_ranges, it may have discontiguous ranges.
Also, DW_AT_ranges may record ranges not belonging to any child DIEs
If this is the first TU to use this symtab, complete the construction
of it with end_expandable_symtab. Otherwise, complete the addition of
this TU's symbols to the existing symtab. */
- if (per_cu->s.type_unit_group->primary_symtab == NULL)
+ if (per_cu->type_unit_group->primary_symtab == NULL)
{
symtab = end_expandable_symtab (0, objfile, SECT_OFF_TEXT (objfile));
- per_cu->s.type_unit_group->primary_symtab = symtab;
+ per_cu->type_unit_group->primary_symtab = symtab;
if (symtab != NULL)
{
else
{
augment_type_symtab (objfile,
- per_cu->s.type_unit_group->primary_symtab);
- symtab = per_cu->s.type_unit_group->primary_symtab;
+ per_cu->type_unit_group->primary_symtab);
+ symtab = per_cu->type_unit_group->primary_symtab;
}
if (dwarf2_per_objfile->using_index)
if (maybe_queue_comp_unit (cu, per_cu, cu->language))
load_full_comp_unit (per_cu, cu->language);
- VEC_safe_push (dwarf2_per_cu_ptr, cu->per_cu->s.imported_symtabs,
+ VEC_safe_push (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs,
per_cu);
}
}
case DW_TAG_common_inclusion:
break;
case DW_TAG_namespace:
- processing_has_namespace_info = 1;
+ cu->processing_has_namespace_info = 1;
read_namespace (die, cu);
break;
case DW_TAG_module:
- processing_has_namespace_info = 1;
+ cu->processing_has_namespace_info = 1;
read_module (die, cu);
break;
case DW_TAG_imported_declaration:
case DW_TAG_imported_module:
- processing_has_namespace_info = 1;
+ cu->processing_has_namespace_info = 1;
if (die->child != NULL && (die->tag == DW_TAG_imported_declaration
|| cu->language != language_fortran))
complaint (&symfile_complaints, _("Tag '%s' has unexpected children"),
The result is allocated on the objfile_obstack and canonicalized. */
static const char *
-dwarf2_compute_name (char *name, struct die_info *die, struct dwarf2_cu *cu,
+dwarf2_compute_name (const char *name,
+ struct die_info *die, struct dwarf2_cu *cu,
int physname)
{
struct objfile *objfile = cu->objfile;
if (cu->language == language_cplus)
{
- char *cname
+ const char *cname
= dwarf2_canonicalize_name (name, cu,
&objfile->objfile_obstack);
The output string will be canonicalized (if C++/Java). */
static const char *
-dwarf2_full_name (char *name, struct die_info *die, struct dwarf2_cu *cu)
+dwarf2_full_name (const char *name, struct die_info *die, struct dwarf2_cu *cu)
{
return dwarf2_compute_name (name, die, cu, 0);
}
The output string will be canonicalized (if C++/Java). */
static const char *
-dwarf2_physname (char *name, struct die_info *die, struct dwarf2_cu *cu)
+dwarf2_physname (const char *name, struct die_info *die, struct dwarf2_cu *cu)
{
struct objfile *objfile = cu->objfile;
struct attribute *attr;
retval = canon;
if (need_copy)
- retval = obsavestring (retval, strlen (retval),
- &objfile->objfile_obstack);
+ retval = obstack_copy0 (&objfile->objfile_obstack, retval, strlen (retval));
do_cleanups (back_to);
return retval;
VEC (const_char_ptr) *excludes = NULL;
struct cleanup *cleanups;
- char *temp;
-
import_attr = dwarf2_attr (die, DW_AT_import, cu);
if (import_attr == NULL)
{
canonical_name = imported_name_prefix;
}
else if (strlen (imported_name_prefix) > 0)
- {
- temp = alloca (strlen (imported_name_prefix)
- + 2 + strlen (imported_name) + 1);
- strcpy (temp, imported_name_prefix);
- strcat (temp, "::");
- strcat (temp, imported_name);
- canonical_name = temp;
- }
+ canonical_name = obconcat (&objfile->objfile_obstack,
+ imported_name_prefix, "::", imported_name,
+ (char *) NULL);
else
canonical_name = imported_name;
import_alias,
imported_declaration,
excludes,
+ 0,
&objfile->objfile_obstack);
do_cleanups (cleanups);
static void
find_file_and_directory (struct die_info *die, struct dwarf2_cu *cu,
- char **name, char **comp_dir)
+ const char **name, const char **comp_dir)
{
struct attribute *attr;
else if (producer_is_gcc_lt_4_3 (cu) && *name != NULL
&& IS_ABSOLUTE_PATH (*name))
{
- *comp_dir = ldirname (*name);
- if (*comp_dir != NULL)
- make_cleanup (xfree, *comp_dir);
+ char *d = ldirname (*name);
+
+ *comp_dir = d;
+ if (d != NULL)
+ make_cleanup (xfree, d);
}
if (*comp_dir != NULL)
{
CORE_ADDR lowpc = ((CORE_ADDR) -1);
CORE_ADDR highpc = ((CORE_ADDR) 0);
struct attribute *attr;
- char *name = NULL;
- char *comp_dir = NULL;
+ const char *name = NULL;
+ const char *comp_dir = NULL;
struct die_info *child_die;
bfd *abfd = objfile->obfd;
CORE_ADDR baseaddr;
/* If we're using .gdb_index (includes -readnow) then
per_cu->s.type_unit_group may not have been set up yet. */
- if (per_cu->s.type_unit_group == NULL)
- per_cu->s.type_unit_group = get_type_unit_group (cu, attr);
- tu_group = per_cu->s.type_unit_group;
+ if (per_cu->type_unit_group == NULL)
+ per_cu->type_unit_group = get_type_unit_group (cu, attr);
+ tu_group = per_cu->type_unit_group;
/* If we've already processed this stmt_list there's no real need to
do it again, we could fake it and just recreate the part we need
int ix;
struct dwarf2_section_info *section;
- gdb_assert (dwo_file->dbfd != objfile->obfd);
gdb_bfd_unref (dwo_file->dbfd);
VEC_free (dwarf2_section_info_def, dwo_file->sections.types);
CORE_ADDR highpc;
struct die_info *child_die;
struct attribute *attr, *call_line, *call_file;
- char *name;
+ const char *name;
CORE_ADDR baseaddr;
struct block *block;
int inlined_func = (die->tag == DW_TAG_inlined_subroutine);
lowpc, highpc, objfile);
/* For C++, set the block's scope. */
- if (cu->language == language_cplus || cu->language == language_fortran)
- cp_set_block_scope (new->name, block, &objfile->objfile_obstack,
- determine_prefix (die, cu),
- processing_has_namespace_info);
+ if ((cu->language == language_cplus || cu->language == language_fortran)
+ && cu->processing_has_namespace_info)
+ block_set_scope (block, determine_prefix (die, cu),
+ &objfile->objfile_obstack);
/* If we have address ranges, record them. */
dwarf2_record_block_ranges (die, block, baseaddr, cu);
"physname, for referencing DIE 0x%x [in module %s]"),
die->offset.sect_off, objfile->name);
else
- SET_FIELD_PHYSNAME (call_site->target, (char *) target_physname);
+ SET_FIELD_PHYSNAME (call_site->target, target_physname);
}
else
{
struct nextfield *new_field;
struct attribute *attr;
struct field *fp;
- char *fieldname = "";
+ const char *fieldname = "";
/* Allocate a new field list entry and link it in. */
new_field = (struct nextfield *) xmalloc (sizeof (struct nextfield));
struct fnfieldlist *flp;
int i;
struct fn_field *fnp;
- char *fieldname;
+ const char *fieldname;
struct nextfnfield *new_fnfield;
struct type *this_type;
enum dwarf_access_attribute accessibility;
struct objfile *objfile = cu->objfile;
struct type *type;
struct attribute *attr;
- char *name;
+ const char *name;
/* If the definition of this type lives in .debug_types, read that type.
Don't follow DW_AT_specification though, that will take us back up
if (cu->language == language_cplus
|| cu->language == language_java)
{
- char *full_name = (char *) dwarf2_full_name (name, die, cu);
+ const char *full_name = dwarf2_full_name (name, die, cu);
/* dwarf2_full_name might have already finished building the DIE's
type. If so, there is no need to continue. */
{
/* The name is already allocated along with this objfile, so
we don't need to duplicate it for the type. */
- TYPE_TAG_NAME (type) = (char *) name;
+ TYPE_TAG_NAME (type) = name;
if (die->tag == DW_TAG_class_type)
TYPE_NAME (type) = TYPE_TAG_NAME (type);
}
TYPE_CODE (type) = TYPE_CODE_ENUM;
name = dwarf2_full_name (NULL, die, cu);
if (name != NULL)
- TYPE_TAG_NAME (type) = (char *) name;
+ TYPE_TAG_NAME (type) = name;
attr = dwarf2_attr (die, DW_AT_byte_size, cu);
if (attr)
struct field *fields = NULL;
int num_fields = 0;
int unsigned_enum = 1;
- char *name;
+ const char *name;
int flag_enum = 1;
ULONGEST mask = 0;
struct attribute *attr;
int ndim = 0;
struct cleanup *back_to;
- char *name;
+ const char *name;
element_type = die_type (die, cu);
/* Create the type. */
type = init_type (TYPE_CODE_NAMESPACE, 0, 0, NULL,
objfile);
- TYPE_NAME (type) = (char *) name;
+ TYPE_NAME (type) = name;
TYPE_TAG_NAME (type) = TYPE_NAME (type);
return set_die_type (die, type, cu);
const char *previous_prefix = determine_prefix (die, cu);
cp_add_using_directive (previous_prefix, TYPE_NAME (type), NULL,
- NULL, NULL, &objfile->objfile_obstack);
+ NULL, NULL, 0, &objfile->objfile_obstack);
}
}
read_module_type (struct die_info *die, struct dwarf2_cu *cu)
{
struct objfile *objfile = cu->objfile;
- char *module_name;
+ const char *module_name;
struct type *type;
module_name = dwarf2_name (die, cu);
if (TYPE_CODE (check_typedef (to_type)) == TYPE_CODE_METHOD)
type = lookup_methodptr_type (to_type);
+ else if (TYPE_CODE (check_typedef (to_type)) == TYPE_CODE_FUNC)
+ {
+ struct type *new_type = alloc_type (cu->objfile);
+
+ smash_to_method_type (new_type, domain, TYPE_TARGET_TYPE (to_type),
+ TYPE_FIELDS (to_type), TYPE_NFIELDS (to_type),
+ TYPE_VARARGS (to_type));
+ type = lookup_methodptr_type (new_type);
+ }
else
type = lookup_memberptr_type (to_type, domain);
name = dwarf2_full_name (NULL, die, cu);
this_type = init_type (TYPE_CODE_TYPEDEF, 0,
TYPE_FLAG_TARGET_STUB, NULL, objfile);
- TYPE_NAME (this_type) = (char *) name;
+ TYPE_NAME (this_type) = name;
set_die_type (die, this_type, cu);
target_type = die_type (die, cu);
if (target_type != this_type)
struct type *type;
struct attribute *attr;
int encoding = 0, size = 0;
- char *name;
+ const char *name;
enum type_code code = TYPE_CODE_INT;
int type_flags = 0;
struct type *target_type = NULL;
struct attribute *attr;
LONGEST low, high;
int low_default_is_valid;
- char *name;
+ const char *name;
LONGEST negative_mask;
base_type = die_type (die, cu);
if (actual_class_name != NULL)
{
struct_pdi->name
- = obsavestring (actual_class_name,
- strlen (actual_class_name),
- &cu->objfile->objfile_obstack);
+ = obstack_copy0 (&cu->objfile->objfile_obstack,
+ actual_class_name,
+ strlen (actual_class_name));
xfree (actual_class_name);
}
break;
else
base = demangled;
- part_die->name = obsavestring (base, strlen (base),
- &cu->objfile->objfile_obstack);
+ part_die->name = obstack_copy0 (&cu->objfile->objfile_obstack,
+ base, strlen (base));
xfree (demangled);
}
}
static void
dwarf2_start_symtab (struct dwarf2_cu *cu,
- char *name, char *comp_dir, CORE_ADDR low_pc)
+ const char *name, const char *comp_dir, CORE_ADDR low_pc)
{
start_symtab (name, comp_dir, low_pc);
record_debugformat ("DWARF 2");
/* We assume that we're processing GCC output. */
processing_gcc_compilation = 2;
- processing_has_namespace_info = 0;
+ cu->processing_has_namespace_info = 0;
}
static void
{
struct objfile *objfile = cu->objfile;
struct symbol *sym = NULL;
- char *name;
+ const char *name;
struct attribute *attr = NULL;
struct attribute *attr2 = NULL;
CORE_ADDR baseaddr;
if (cu->language == language_fortran
&& symbol_get_demangled_name (&(sym->ginfo)) == NULL)
symbol_set_demangled_name (&(sym->ginfo),
- (char *) dwarf2_full_name (name, die, cu),
+ dwarf2_full_name (name, die, cu),
NULL);
/* Default assumptions.
list_to_add = &global_symbols;
break;
case DW_TAG_common_block:
- SYMBOL_CLASS (sym) = LOC_STATIC;
+ SYMBOL_CLASS (sym) = LOC_COMMON_BLOCK;
SYMBOL_DOMAIN (sym) = COMMON_BLOCK_DOMAIN;
add_symbol_to_list (sym, cu->list_in_scope);
break;
/* For the benefit of old versions of GCC, check for anonymous
namespaces based on the demangled name. */
- if (!processing_has_namespace_info
+ if (!cu->processing_has_namespace_info
&& cu->language == language_cplus)
cp_scan_for_anonymous_namespaces (sym, objfile);
}
if (actual_name != NULL)
{
- char *die_name = dwarf2_name (die, cu);
+ const char *die_name = dwarf2_name (die, cu);
if (die_name != NULL
&& strcmp (die_name, actual_name) != 0)
&& actual_name[actual_name_len
- die_name_len - 1] == ':')
name =
- obsavestring (actual_name,
- actual_name_len - die_name_len - 2,
- &cu->objfile->objfile_obstack);
+ obstack_copy0 (&cu->objfile->objfile_obstack,
+ actual_name,
+ actual_name_len - die_name_len - 2);
}
}
xfree (actual_name);
if (base == NULL || base == DW_STRING (attr) || base[-1] != ':')
return "";
- return obsavestring (DW_STRING (attr), &base[-1] - DW_STRING (attr),
- &cu->objfile->objfile_obstack);
+ return obstack_copy0 (&cu->objfile->objfile_obstack,
+ DW_STRING (attr), &base[-1] - DW_STRING (attr));
}
/* Return the name of the namespace/class that DIE is defined within,
/* Get name of a die, return NULL if not found. */
-static char *
-dwarf2_canonicalize_name (char *name, struct dwarf2_cu *cu,
+static const char *
+dwarf2_canonicalize_name (const char *name, struct dwarf2_cu *cu,
struct obstack *obstack)
{
if (name && cu->language == language_cplus)
if (canon_name != NULL)
{
if (strcmp (canon_name, name) != 0)
- name = obsavestring (canon_name, strlen (canon_name),
- obstack);
+ name = obstack_copy0 (obstack, canon_name, strlen (canon_name));
xfree (canon_name);
}
}
/* Get name of a die, return NULL if not found. */
-static char *
+static const char *
dwarf2_name (struct die_info *die, struct dwarf2_cu *cu)
{
struct attribute *attr;
char *base;
/* FIXME: we already did this for the partial symbol... */
- DW_STRING (attr) = obsavestring (demangled, strlen (demangled),
- &cu->objfile->objfile_obstack);
+ DW_STRING (attr) = obstack_copy0 (&cu->objfile->objfile_obstack,
+ demangled, strlen (demangled));
DW_STRING_IS_CANONICAL (attr) = 1;
xfree (demangled);
temp_die.offset.sect_off);
if (die)
{
+ /* For .gdb_index version 7 keep track of included TUs.
+ http://sourceware.org/bugzilla/show_bug.cgi?id=15021. */
+ if (dwarf2_per_objfile->index_table != NULL
+ && dwarf2_per_objfile->index_table->version <= 7)
+ {
+ VEC_safe_push (dwarf2_per_cu_ptr,
+ (*ref_cu)->per_cu->imported_symtabs,
+ sig_cu->per_cu);
+ }
+
*ref_cu = sig_cu;
return die;
}
static void
dwarf_decode_macro_bytes (bfd *abfd, gdb_byte *mac_ptr, gdb_byte *mac_end,
struct macro_source_file *current_file,
- struct line_header *lh, char *comp_dir,
+ struct line_header *lh, const char *comp_dir,
struct dwarf2_section_info *section,
int section_is_gnu, int section_is_dwz,
unsigned int offset_size,
static void
dwarf_decode_macros (struct dwarf2_cu *cu, unsigned int offset,
- char *comp_dir, int section_is_gnu)
+ const char *comp_dir, int section_is_gnu)
{
struct objfile *objfile = dwarf2_per_objfile->objfile;
struct line_header *lh = cu->line_header;
for (ix = 0; ix < dwarf2_per_objfile->n_comp_units; ++ix)
VEC_free (dwarf2_per_cu_ptr,
- dwarf2_per_objfile->all_comp_units[ix]->s.imported_symtabs);
+ dwarf2_per_objfile->all_comp_units[ix]->imported_symtabs);
+
+ for (ix = 0; ix < dwarf2_per_objfile->n_type_units; ++ix)
+ VEC_free (dwarf2_per_cu_ptr,
+ dwarf2_per_objfile->all_type_units[ix]->per_cu.imported_symtabs);
VEC_free (dwarf2_section_info_def, data->types);
total_len = size_of_contents;
/* The version number. */
- val = MAYBE_SWAP (7);
+ val = MAYBE_SWAP (8);
obstack_grow (&contents, &val, sizeof (val));
/* The offset of the CU list from the start of the file. */
projects / deliverable / binutils-gdb.git / blobdiff