/* DWARF 2 debugging format support for GDB.
- Copyright (C) 1994-2015 Free Software Foundation, Inc.
+ Copyright (C) 1994-2016 Free Software Foundation, Inc.
Adapted by Gary Funck (gary@intrepid.com), Intrepid Technology,
Inc. with support from Florida State University (under contract
#include "block.h"
#include "addrmap.h"
#include "typeprint.h"
-#include "jv-lang.h"
#include "psympriv.h"
#include <sys/stat.h>
#include "completer.h"
#include "source.h"
#include "filestuff.h"
#include "build-id.h"
+#include "namespace.h"
#include <fcntl.h>
#include <sys/types.h>
+#include <algorithm>
typedef struct symbol *symbolp;
DEF_VEC_P (symbolp);
union
{
/* If this is a real section, the bfd section. */
- asection *asection;
+ asection *section;
/* If this is a virtual section, pointer to the containing ("real")
section. */
struct dwarf2_section_info *containing_section;
/* True if we have tried to read this section. */
char readin;
/* True if this is a virtual section, False otherwise.
- This specifies which of s.asection and s.containing_section to use. */
+ This specifies which of s.section and s.containing_section to use. */
char is_virtual;
};
unsigned int has_pc_info : 1;
unsigned int may_be_inlined : 1;
+ /* This DIE has been marked DW_AT_main_subprogram. */
+ unsigned int main_subprogram : 1;
+
/* Flag set if the SCOPE field of this structure has been
computed. */
unsigned int scope_set : 1;
static struct attribute *dwarf2_attr_no_follow (struct die_info *,
unsigned int);
+static const char *dwarf2_string_attr (struct die_info *die, unsigned int name,
+ struct dwarf2_cu *cu);
+
static int dwarf2_flag_true_p (struct die_info *die, unsigned name,
struct dwarf2_cu *cu);
static int dwarf2_ranges_read (unsigned, CORE_ADDR *, CORE_ADDR *,
struct dwarf2_cu *, struct partial_symtab *);
-static int dwarf2_get_pc_bounds (struct die_info *,
- CORE_ADDR *, CORE_ADDR *, struct dwarf2_cu *,
- struct partial_symtab *);
+/* How dwarf2_get_pc_bounds constructed its *LOWPC and *HIGHPC return
+ values. Keep the items ordered with increasing constraints compliance. */
+enum pc_bounds_kind
+{
+ /* No attribute DW_AT_low_pc, DW_AT_high_pc or DW_AT_ranges was found. */
+ PC_BOUNDS_NOT_PRESENT,
+
+ /* Some of the attributes DW_AT_low_pc, DW_AT_high_pc or DW_AT_ranges
+ were present but they do not form a valid range of PC addresses. */
+ PC_BOUNDS_INVALID,
+
+ /* Discontiguous range was found - that is DW_AT_ranges was found. */
+ PC_BOUNDS_RANGES,
+
+ /* Contiguous range was found - DW_AT_low_pc and DW_AT_high_pc were found. */
+ PC_BOUNDS_HIGH_LOW,
+};
+
+static enum pc_bounds_kind dwarf2_get_pc_bounds (struct die_info *,
+ CORE_ADDR *, CORE_ADDR *,
+ struct dwarf2_cu *,
+ struct partial_symtab *);
static void get_scope_pc_bounds (struct die_info *,
CORE_ADDR *, CORE_ADDR *,
static void read_module (struct die_info *die, struct dwarf2_cu *cu);
+static struct using_direct **using_directives (enum language);
+
static void read_import_statement (struct die_info *die, struct dwarf2_cu *);
static int read_namespace_alias (struct die_info *die, struct dwarf2_cu *cu);
static void read_signatured_type (struct signatured_type *);
+static int attr_to_dynamic_prop (const struct attribute *attr,
+ struct die_info *die, struct dwarf2_cu *cu,
+ struct dynamic_prop *prop);
+
/* memory allocation interface */
static struct dwarf_block *dwarf_alloc_block (struct dwarf2_cu *);
static hashval_t
line_header_hash_voidp (const void *item)
{
- const struct line_header *ofs = item;
+ const struct line_header *ofs = (const struct line_header *) item;
return line_header_hash (ofs);
}
static int
line_header_eq_voidp (const void *item_lhs, const void *item_rhs)
{
- const struct line_header *ofs_lhs = item_lhs;
- const struct line_header *ofs_rhs = item_rhs;
+ const struct line_header *ofs_lhs = (const struct line_header *) item_lhs;
+ const struct line_header *ofs_rhs = (const struct line_header *) item_rhs;
return (ofs_lhs->offset.sect_off == ofs_rhs->offset.sect_off
&& ofs_lhs->offset_in_dwz == ofs_rhs->offset_in_dwz);
dwarf2_has_info (struct objfile *objfile,
const struct dwarf2_debug_sections *names)
{
- dwarf2_per_objfile = objfile_data (objfile, dwarf2_objfile_data_key);
+ dwarf2_per_objfile = ((struct dwarf2_per_objfile *)
+ objfile_data (objfile, dwarf2_objfile_data_key));
if (!dwarf2_per_objfile)
{
/* Initialize per-objfile state. */
struct dwarf2_per_objfile *data
- = obstack_alloc (&objfile->objfile_obstack, sizeof (*data));
+ = XOBNEW (&objfile->objfile_obstack, struct dwarf2_per_objfile);
memset (data, 0, sizeof (*data));
set_objfile_data (objfile, dwarf2_objfile_data_key, data);
dwarf2_per_objfile->objfile = objfile;
}
return (!dwarf2_per_objfile->info.is_virtual
- && dwarf2_per_objfile->info.s.asection != NULL
+ && dwarf2_per_objfile->info.s.section != NULL
&& !dwarf2_per_objfile->abbrev.is_virtual
- && dwarf2_per_objfile->abbrev.s.asection != NULL);
+ && dwarf2_per_objfile->abbrev.s.section != NULL);
}
/* Return the containing section of virtual section SECTION. */
section = get_containing_section (section);
gdb_assert (!section->is_virtual);
}
- return section->s.asection->owner;
+ return section->s.section->owner;
}
/* Return the bfd section of SECTION.
section = get_containing_section (section);
gdb_assert (!section->is_virtual);
}
- return section->s.asection;
+ return section->s.section;
}
/* Return the name of SECTION. */
}
else if (section_is_p (sectp->name, &names->info))
{
- dwarf2_per_objfile->info.s.asection = sectp;
+ dwarf2_per_objfile->info.s.section = sectp;
dwarf2_per_objfile->info.size = bfd_get_section_size (sectp);
}
else if (section_is_p (sectp->name, &names->abbrev))
{
- dwarf2_per_objfile->abbrev.s.asection = sectp;
+ dwarf2_per_objfile->abbrev.s.section = sectp;
dwarf2_per_objfile->abbrev.size = bfd_get_section_size (sectp);
}
else if (section_is_p (sectp->name, &names->line))
{
- dwarf2_per_objfile->line.s.asection = sectp;
+ dwarf2_per_objfile->line.s.section = sectp;
dwarf2_per_objfile->line.size = bfd_get_section_size (sectp);
}
else if (section_is_p (sectp->name, &names->loc))
{
- dwarf2_per_objfile->loc.s.asection = sectp;
+ dwarf2_per_objfile->loc.s.section = sectp;
dwarf2_per_objfile->loc.size = bfd_get_section_size (sectp);
}
else if (section_is_p (sectp->name, &names->macinfo))
{
- dwarf2_per_objfile->macinfo.s.asection = sectp;
+ dwarf2_per_objfile->macinfo.s.section = sectp;
dwarf2_per_objfile->macinfo.size = bfd_get_section_size (sectp);
}
else if (section_is_p (sectp->name, &names->macro))
{
- dwarf2_per_objfile->macro.s.asection = sectp;
+ dwarf2_per_objfile->macro.s.section = sectp;
dwarf2_per_objfile->macro.size = bfd_get_section_size (sectp);
}
else if (section_is_p (sectp->name, &names->str))
{
- dwarf2_per_objfile->str.s.asection = sectp;
+ dwarf2_per_objfile->str.s.section = sectp;
dwarf2_per_objfile->str.size = bfd_get_section_size (sectp);
}
else if (section_is_p (sectp->name, &names->addr))
{
- dwarf2_per_objfile->addr.s.asection = sectp;
+ dwarf2_per_objfile->addr.s.section = sectp;
dwarf2_per_objfile->addr.size = bfd_get_section_size (sectp);
}
else if (section_is_p (sectp->name, &names->frame))
{
- dwarf2_per_objfile->frame.s.asection = sectp;
+ dwarf2_per_objfile->frame.s.section = sectp;
dwarf2_per_objfile->frame.size = bfd_get_section_size (sectp);
}
else if (section_is_p (sectp->name, &names->eh_frame))
{
- dwarf2_per_objfile->eh_frame.s.asection = sectp;
+ dwarf2_per_objfile->eh_frame.s.section = sectp;
dwarf2_per_objfile->eh_frame.size = bfd_get_section_size (sectp);
}
else if (section_is_p (sectp->name, &names->ranges))
{
- dwarf2_per_objfile->ranges.s.asection = sectp;
+ dwarf2_per_objfile->ranges.s.section = sectp;
dwarf2_per_objfile->ranges.size = bfd_get_section_size (sectp);
}
else if (section_is_p (sectp->name, &names->types))
struct dwarf2_section_info type_section;
memset (&type_section, 0, sizeof (type_section));
- type_section.s.asection = sectp;
+ type_section.s.section = sectp;
type_section.size = bfd_get_section_size (sectp);
VEC_safe_push (dwarf2_section_info_def, dwarf2_per_objfile->types,
}
else if (section_is_p (sectp->name, &names->gdb_index))
{
- dwarf2_per_objfile->gdb_index.s.asection = sectp;
+ dwarf2_per_objfile->gdb_index.s.section = sectp;
dwarf2_per_objfile->gdb_index.size = bfd_get_section_size (sectp);
}
{
if (section->is_virtual)
return section->size == 0;
- return section->s.asection == NULL || section->size == 0;
+ return section->s.section == NULL || section->size == 0;
}
/* Read the contents of the section INFO.
return;
}
- buf = obstack_alloc (&objfile->objfile_obstack, info->size);
+ buf = (gdb_byte *) obstack_alloc (&objfile->objfile_obstack, info->size);
info->buffer = buf;
/* When debugging .o files, we may need to apply relocations; see
bfd_size_type *sizep)
{
struct dwarf2_per_objfile *data
- = objfile_data (objfile, dwarf2_objfile_data_key);
+ = (struct dwarf2_per_objfile *) objfile_data (objfile,
+ dwarf2_objfile_data_key);
struct dwarf2_section_info *info;
/* We may see an objfile without any DWARF, in which case we just
static void
locate_dwz_sections (bfd *abfd, asection *sectp, void *arg)
{
- struct dwz_file *dwz_file = arg;
+ struct dwz_file *dwz_file = (struct dwz_file *) arg;
/* Note that we only support the standard ELF names, because .dwz
is ELF-only (at the time of writing). */
if (section_is_p (sectp->name, &dwarf2_elf_names.abbrev))
{
- dwz_file->abbrev.s.asection = sectp;
+ dwz_file->abbrev.s.section = sectp;
dwz_file->abbrev.size = bfd_get_section_size (sectp);
}
else if (section_is_p (sectp->name, &dwarf2_elf_names.info))
{
- dwz_file->info.s.asection = sectp;
+ dwz_file->info.s.section = sectp;
dwz_file->info.size = bfd_get_section_size (sectp);
}
else if (section_is_p (sectp->name, &dwarf2_elf_names.str))
{
- dwz_file->str.s.asection = sectp;
+ dwz_file->str.s.section = sectp;
dwz_file->str.size = bfd_get_section_size (sectp);
}
else if (section_is_p (sectp->name, &dwarf2_elf_names.line))
{
- dwz_file->line.s.asection = sectp;
+ dwz_file->line.s.section = sectp;
dwz_file->line.size = bfd_get_section_size (sectp);
}
else if (section_is_p (sectp->name, &dwarf2_elf_names.macro))
{
- dwz_file->macro.s.asection = sectp;
+ dwz_file->macro.s.section = sectp;
dwz_file->macro.size = bfd_get_section_size (sectp);
}
else if (section_is_p (sectp->name, &dwarf2_elf_names.gdb_index))
{
- dwz_file->gdb_index.s.asection = sectp;
+ dwz_file->gdb_index.s.section = sectp;
dwz_file->gdb_index.size = bfd_get_section_size (sectp);
}
}
static hashval_t
hash_file_name_entry (const void *e)
{
- const struct quick_file_names *file_data = e;
+ const struct quick_file_names *file_data
+ = (const struct quick_file_names *) e;
return hash_stmt_list_entry (&file_data->hash);
}
static int
eq_file_name_entry (const void *a, const void *b)
{
- const struct quick_file_names *ea = a;
- const struct quick_file_names *eb = b;
+ const struct quick_file_names *ea = (const struct quick_file_names *) a;
+ const struct quick_file_names *eb = (const struct quick_file_names *) b;
return eq_stmt_list_entry (&ea->hash, &eb->hash);
}
static void
delete_file_name_entry (void *e)
{
- struct quick_file_names *file_data = e;
+ struct quick_file_names *file_data = (struct quick_file_names *) e;
int i;
for (i = 0; i < file_data->num_file_names; ++i)
struct dwz_file *dwz;
dwarf2_per_objfile->n_comp_units = (cu_list_elements + dwz_elements) / 2;
- dwarf2_per_objfile->all_comp_units
- = obstack_alloc (&objfile->objfile_obstack,
- dwarf2_per_objfile->n_comp_units
- * sizeof (struct dwarf2_per_cu_data *));
+ dwarf2_per_objfile->all_comp_units =
+ XOBNEWVEC (&objfile->objfile_obstack, struct dwarf2_per_cu_data *,
+ dwarf2_per_objfile->n_comp_units);
create_cus_from_index_list (objfile, cu_list, cu_list_elements,
&dwarf2_per_objfile->info, 0, 0);
dwarf2_per_objfile->n_type_units
= dwarf2_per_objfile->n_allocated_type_units
= elements / 3;
- dwarf2_per_objfile->all_type_units
- = xmalloc (dwarf2_per_objfile->n_type_units
- * sizeof (struct signatured_type *));
+ dwarf2_per_objfile->all_type_units =
+ XNEWVEC (struct signatured_type *, dwarf2_per_objfile->n_type_units);
sig_types_hash = allocate_signatured_type_table (objfile);
int (*cmp) (const char *, const char *);
if (current_language->la_language == language_cplus
- || current_language->la_language == language_java
|| current_language->la_language == language_fortran
|| current_language->la_language == language_d)
{
create_addrmap_from_index (objfile, &local_map);
- map = obstack_alloc (&objfile->objfile_obstack, sizeof (struct mapped_index));
+ map = XOBNEW (&objfile->objfile_obstack, struct mapped_index);
*map = local_map;
dwarf2_per_objfile->index_table = map;
static void
dw2_setup (struct objfile *objfile)
{
- dwarf2_per_objfile = objfile_data (objfile, dwarf2_objfile_data_key);
+ dwarf2_per_objfile = ((struct dwarf2_per_objfile *)
+ objfile_data (objfile, dwarf2_objfile_data_key));
gdb_assert (dwarf2_per_objfile);
}
&find_entry, INSERT);
if (*slot != NULL)
{
- lh_cu->v.quick->file_names = *slot;
+ lh_cu->v.quick->file_names = (struct quick_file_names *) *slot;
return;
}
return;
}
- qfn = obstack_alloc (&objfile->objfile_obstack, sizeof (*qfn));
+ qfn = XOBNEW (&objfile->objfile_obstack, struct quick_file_names);
qfn->hash.dwo_unit = cu->dwo_unit;
qfn->hash.line_offset.sect_off = line_offset;
gdb_assert (slot != NULL);
find_file_and_directory (comp_unit_die, cu, &name, &comp_dir);
qfn->num_file_names = lh->num_file_names;
- qfn->file_names = obstack_alloc (&objfile->objfile_obstack,
- lh->num_file_names * sizeof (char *));
+ qfn->file_names =
+ XOBNEWVEC (&objfile->objfile_obstack, const char *, lh->num_file_names);
for (i = 0; i < lh->num_file_names; ++i)
qfn->file_names[i] = file_full_name (i + 1, lh, comp_dir);
qfn->real_names = NULL;
if (!objfile->psymtabs_addrmap)
return NULL;
- data = addrmap_find (objfile->psymtabs_addrmap, pc);
+ data = (struct dwarf2_per_cu_data *) addrmap_find (objfile->psymtabs_addrmap,
+ pc);
if (!data)
return NULL;
struct dwarf2_section_info *section,
struct dwarf2_section_info *abbrev_section)
{
- bfd *abfd = get_section_bfd_owner (section);
const char *filename = get_section_file_name (section);
if (header->version != 2 && header->version != 3 && header->version != 4)
{
bfd *abfd = get_section_bfd_owner (section);
const gdb_byte *info_ptr;
- unsigned int length, initial_length_size, offset_size;
+ unsigned int initial_length_size, offset_size;
sect_offset abbrev_offset;
dwarf2_read_section (dwarf2_per_objfile->objfile, section);
info_ptr = section->buffer + offset.sect_off;
- length = read_initial_length (abfd, info_ptr, &initial_length_size);
+ read_initial_length (abfd, info_ptr, &initial_length_size);
offset_size = initial_length_size == 4 ? 4 : 8;
info_ptr += initial_length_size + 2 /*version*/;
abbrev_offset.sect_off = read_offset_1 (abfd, info_ptr, offset_size);
subpst->textlow = 0;
subpst->texthigh = 0;
- subpst->dependencies = (struct partial_symtab **)
- obstack_alloc (&objfile->objfile_obstack,
- sizeof (struct partial_symtab *));
+ subpst->dependencies
+ = XOBNEW (&objfile->objfile_obstack, struct partial_symtab *);
subpst->dependencies[0] = pst;
subpst->number_of_dependencies = 1;
static hashval_t
hash_signatured_type (const void *item)
{
- const struct signatured_type *sig_type = item;
+ const struct signatured_type *sig_type
+ = (const struct signatured_type *) item;
/* This drops the top 32 bits of the signature, but is ok for a hash. */
return sig_type->signature;
static int
eq_signatured_type (const void *item_lhs, const void *item_rhs)
{
- const struct signatured_type *lhs = item_lhs;
- const struct signatured_type *rhs = item_rhs;
+ const struct signatured_type *lhs = (const struct signatured_type *) item_lhs;
+ const struct signatured_type *rhs = (const struct signatured_type *) item_rhs;
return lhs->signature == rhs->signature;
}
static int
add_signatured_type_cu_to_table (void **slot, void *datum)
{
- struct signatured_type *sigt = *slot;
- struct signatured_type ***datap = datum;
+ struct signatured_type *sigt = (struct signatured_type *) *slot;
+ struct signatured_type ***datap = (struct signatured_type ***) datum;
**datap = sigt;
++*datap;
if (dwo_file)
{
- const struct dwo_unit *dup_tu = *slot;
+ const struct dwo_unit *dup_tu
+ = (const struct dwo_unit *) *slot;
dup_offset = dup_tu->offset;
}
else
{
- const struct signatured_type *dup_tu = *slot;
+ const struct signatured_type *dup_tu
+ = (const struct signatured_type *) *slot;
dup_offset = dup_tu->per_cu.offset;
}
dwarf2_per_objfile->n_type_units
= dwarf2_per_objfile->n_allocated_type_units
= htab_elements (types_htab);
- dwarf2_per_objfile->all_type_units
- = xmalloc (dwarf2_per_objfile->n_type_units
- * sizeof (struct signatured_type *));
+ dwarf2_per_objfile->all_type_units =
+ XNEWVEC (struct signatured_type *, dwarf2_per_objfile->n_type_units);
iter = &dwarf2_per_objfile->all_type_units[0];
htab_traverse_noresize (types_htab, add_signatured_type_cu_to_table, &iter);
gdb_assert (iter - &dwarf2_per_objfile->all_type_units[0]
dwarf2_per_objfile->n_allocated_type_units = 1;
dwarf2_per_objfile->n_allocated_type_units *= 2;
dwarf2_per_objfile->all_type_units
- = xrealloc (dwarf2_per_objfile->all_type_units,
- dwarf2_per_objfile->n_allocated_type_units
- * sizeof (struct signatured_type *));
+ = XRESIZEVEC (struct signatured_type *,
+ dwarf2_per_objfile->all_type_units,
+ dwarf2_per_objfile->n_allocated_type_units);
++dwarf2_per_objfile->tu_stats.nr_all_type_units_reallocs;
}
dwarf2_per_objfile->n_type_units = n_type_units;
find_sig_entry.signature = sig;
slot = htab_find_slot (dwarf2_per_objfile->signatured_types,
&find_sig_entry, INSERT);
- sig_entry = *slot;
+ sig_entry = (struct signatured_type *) *slot;
/* We can get here with the TU already read, *or* in the process of being
read. Don't reassign the global entry to point to this DWO if that's
if (dwo_file->tus == NULL)
return NULL;
find_dwo_entry.signature = sig;
- dwo_entry = htab_find (dwo_file->tus, &find_dwo_entry);
+ dwo_entry = (struct dwo_unit *) htab_find (dwo_file->tus, &find_dwo_entry);
if (dwo_entry == NULL)
return NULL;
find_sig_entry.signature = sig;
slot = htab_find_slot (dwarf2_per_objfile->signatured_types,
&find_sig_entry, INSERT);
- sig_entry = *slot;
+ sig_entry = (struct signatured_type *) *slot;
/* Have we already tried to read this TU?
Note: sig_entry can be NULL if the skeleton TU was removed (thus it
if (dwarf2_per_objfile->signatured_types == NULL)
return NULL;
find_entry.signature = sig;
- entry = htab_find (dwarf2_per_objfile->signatured_types, &find_entry);
+ entry = ((struct signatured_type *)
+ htab_find (dwarf2_per_objfile->signatured_types, &find_entry));
return entry;
}
}
else if (stub_comp_dir != NULL)
{
/* Reconstruct the comp_dir attribute to simplify the code below. */
- comp_dir = (struct attribute *)
- obstack_alloc (&cu->comp_unit_obstack, sizeof (*comp_dir));
+ comp_dir = XOBNEW (&cu->comp_unit_obstack, struct attribute);
comp_dir->name = DW_AT_comp_dir;
comp_dir->form = DW_FORM_string;
DW_STRING_IS_CANONICAL (comp_dir) = 0;
gdb_assert (cu != NULL);
/* Yeah, we look dwo_name up again, but it simplifies the code. */
- attr = dwarf2_attr (comp_unit_die, DW_AT_GNU_dwo_name, cu);
- gdb_assert (attr != NULL);
- dwo_name = DW_STRING (attr);
- comp_dir = NULL;
- attr = dwarf2_attr (comp_unit_die, DW_AT_comp_dir, cu);
- if (attr)
- comp_dir = DW_STRING (attr);
+ dwo_name = dwarf2_string_attr (comp_unit_die, DW_AT_GNU_dwo_name, cu);
+ comp_dir = dwarf2_string_attr (comp_unit_die, DW_AT_comp_dir, cu);
if (this_cu->is_debug_types)
{
{
/* If !use_existing_cu, this_cu->cu must be NULL. */
gdb_assert (this_cu->cu == NULL);
- cu = xmalloc (sizeof (*cu));
+ cu = XNEW (struct dwarf2_cu);
init_one_comp_unit (cu, this_cu);
/* If an error occurs while loading, release our storage. */
free_cu_cleanup = make_cleanup (free_heap_comp_unit, cu);
{
/* If !use_existing_cu, this_cu->cu must be NULL. */
gdb_assert (this_cu->cu == NULL);
- cu = xmalloc (sizeof (*cu));
+ cu = XNEW (struct dwarf2_cu);
init_one_comp_unit (cu, this_cu);
/* If an error occurs while loading, release our storage. */
free_cu_cleanup = make_cleanup (free_heap_comp_unit, cu);
static hashval_t
hash_type_unit_group (const void *item)
{
- const struct type_unit_group *tu_group = item;
+ const struct type_unit_group *tu_group
+ = (const struct type_unit_group *) item;
return hash_stmt_list_entry (&tu_group->hash);
}
static int
eq_type_unit_group (const void *item_lhs, const void *item_rhs)
{
- const struct type_unit_group *lhs = item_lhs;
- const struct type_unit_group *rhs = item_rhs;
+ const struct type_unit_group *lhs = (const struct type_unit_group *) item_lhs;
+ const struct type_unit_group *rhs = (const struct type_unit_group *) item_rhs;
return eq_stmt_list_entry (&lhs->hash, &rhs->hash);
}
&type_unit_group_for_lookup, INSERT);
if (*slot != NULL)
{
- tu_group = *slot;
+ tu_group = (struct type_unit_group *) *slot;
gdb_assert (tu_group != NULL);
}
else
struct objfile *objfile = cu->objfile;
struct gdbarch *gdbarch = get_objfile_arch (objfile);
struct dwarf2_per_cu_data *per_cu = cu->per_cu;
- struct attribute *attr;
CORE_ADDR baseaddr;
CORE_ADDR best_lowpc = 0, best_highpc = 0;
struct partial_symtab *pst;
- int has_pc_info;
+ enum pc_bounds_kind cu_bounds_kind;
const char *filename;
- struct process_psymtab_comp_unit_data *info = data;
+ struct process_psymtab_comp_unit_data *info
+ = (struct process_psymtab_comp_unit_data *) data;
if (comp_unit_die->tag == DW_TAG_partial_unit && !info->want_partial_unit)
return;
cu->list_in_scope = &file_symbols;
/* Allocate a new partial symbol table structure. */
- attr = dwarf2_attr (comp_unit_die, DW_AT_name, cu);
- if (attr == NULL || !DW_STRING (attr))
+ filename = dwarf2_string_attr (comp_unit_die, DW_AT_name, cu);
+ if (filename == NULL)
filename = "";
- else
- filename = DW_STRING (attr);
pst = create_partial_symtab (per_cu, filename);
/* This must be done before calling dwarf2_build_include_psymtabs. */
- attr = dwarf2_attr (comp_unit_die, DW_AT_comp_dir, cu);
- if (attr != NULL)
- pst->dirname = DW_STRING (attr);
+ pst->dirname = dwarf2_string_attr (comp_unit_die, DW_AT_comp_dir, cu);
baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
/* Possibly set the default values of LOWPC and HIGHPC from
`DW_AT_ranges'. */
- has_pc_info = dwarf2_get_pc_bounds (comp_unit_die, &best_lowpc,
- &best_highpc, cu, pst);
- if (has_pc_info == 1 && best_lowpc < best_highpc)
+ cu_bounds_kind = dwarf2_get_pc_bounds (comp_unit_die, &best_lowpc,
+ &best_highpc, cu, pst);
+ if (cu_bounds_kind == PC_BOUNDS_HIGH_LOW && best_lowpc < best_highpc)
/* Store the contiguous range if it is not empty; it can be empty for
CUs with no code. */
addrmap_set_empty (objfile->psymtabs_addrmap,
first_die = load_partial_dies (reader, info_ptr, 1);
scan_partial_symbols (first_die, &lowpc, &highpc,
- ! has_pc_info, cu);
+ cu_bounds_kind <= PC_BOUNDS_INVALID, cu);
/* If we didn't find a lowpc, set it to highpc to avoid
complaints from `maint check'. */
/* If the compilation unit didn't have an explicit address range,
then use the information extracted from its child dies. */
- if (! has_pc_info)
+ if (cu_bounds_kind <= PC_BOUNDS_INVALID)
{
best_lowpc = lowpc;
best_highpc = highpc;
pst->textlow = gdbarch_adjust_dwarf2_addr (gdbarch, best_lowpc + baseaddr);
pst->texthigh = gdbarch_adjust_dwarf2_addr (gdbarch, best_highpc + baseaddr);
- pst->n_global_syms = objfile->global_psymbols.next -
- (objfile->global_psymbols.list + pst->globals_offset);
- pst->n_static_syms = objfile->static_psymbols.next -
- (objfile->static_psymbols.list + pst->statics_offset);
- sort_pst_symbols (objfile, pst);
+ end_psymtab_common (objfile, pst);
if (!VEC_empty (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs))
{
/* Fill in 'dependencies' here; we fill in 'users' in a
post-pass. */
pst->number_of_dependencies = len;
- pst->dependencies = obstack_alloc (&objfile->objfile_obstack,
- len * sizeof (struct symtab *));
+ pst->dependencies =
+ XOBNEWVEC (&objfile->objfile_obstack, struct partial_symtab *, len);
for (i = 0;
VEC_iterate (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs,
i, iter);
highpc = (CORE_ADDR) 0;
scan_partial_symbols (first_die, &lowpc, &highpc, 0, cu);
- pst->n_global_syms = objfile->global_psymbols.next -
- (objfile->global_psymbols.list + pst->globals_offset);
- pst->n_static_syms = objfile->static_psymbols.next -
- (objfile->static_psymbols.list + pst->statics_offset);
- sort_pst_symbols (objfile, pst);
+ end_psymtab_common (objfile, pst);
}
/* Struct used to sort TUs by their abbreviation table offset. */
static int
sort_tu_by_abbrev_offset (const void *ap, const void *bp)
{
- const struct tu_abbrev_offset * const *a = ap;
- const struct tu_abbrev_offset * const *b = bp;
+ const struct tu_abbrev_offset * const *a
+ = (const struct tu_abbrev_offset * const*) ap;
+ const struct tu_abbrev_offset * const *b
+ = (const struct tu_abbrev_offset * const*) bp;
unsigned int aoff = (*a)->abbrev_offset.sect_off;
unsigned int boff = (*b)->abbrev_offset.sect_off;
static void
build_type_psymtabs_1 (void)
{
- struct objfile *objfile = dwarf2_per_objfile->objfile;
struct tu_stats *tu_stats = &dwarf2_per_objfile->tu_stats;
struct cleanup *cleanups;
struct abbrev_table *abbrev_table;
sect_offset abbrev_offset;
struct tu_abbrev_offset *sorted_by_abbrev;
- struct type_unit_group **iter;
int i;
/* It's up to the caller to not call us multiple times. */
gdb_assert (IS_TYPE_UNIT_GROUP (per_cu));
pst->number_of_dependencies = len;
- pst->dependencies = obstack_alloc (&objfile->objfile_obstack,
- len * sizeof (struct psymtab *));
+ pst->dependencies =
+ XOBNEWVEC (&objfile->objfile_obstack, struct partial_symtab *, len);
for (i = 0;
VEC_iterate (sig_type_ptr, tu_group->tus, i, iter);
++i)
process_skeletonless_type_unit (void **slot, void *info)
{
struct dwo_unit *dwo_unit = (struct dwo_unit *) *slot;
- struct objfile *objfile = info;
+ struct objfile *objfile = (struct objfile *) info;
struct signatured_type find_entry, *entry;
/* If this TU doesn't exist in the global table, add it and read it in. */
static void
psymtabs_addrmap_cleanup (void *o)
{
- struct objfile *objfile = o;
+ struct objfile *objfile = (struct objfile *) o;
objfile->psymtabs_addrmap = NULL;
}
length = read_initial_length (abfd, info_ptr, &initial_length_size);
/* Save the compilation unit for later lookup. */
- this_cu = obstack_alloc (&objfile->objfile_obstack,
- sizeof (struct dwarf2_per_cu_data));
+ this_cu = XOBNEW (&objfile->objfile_obstack, struct dwarf2_per_cu_data);
memset (this_cu, 0, sizeof (*this_cu));
this_cu->offset = offset;
this_cu->length = length + initial_length_size;
if (*n_comp_units == *n_allocated)
{
*n_allocated *= 2;
- *all_comp_units = xrealloc (*all_comp_units,
- *n_allocated
- * sizeof (struct dwarf2_per_cu_data *));
+ *all_comp_units = XRESIZEVEC (struct dwarf2_per_cu_data *,
+ *all_comp_units, *n_allocated);
}
(*all_comp_units)[*n_comp_units] = this_cu;
++*n_comp_units;
n_comp_units = 0;
n_allocated = 10;
- all_comp_units = xmalloc (n_allocated
- * sizeof (struct dwarf2_per_cu_data *));
+ all_comp_units = XNEWVEC (struct dwarf2_per_cu_data *, n_allocated);
read_comp_units_from_section (objfile, &dwarf2_per_objfile->info, 0,
&n_allocated, &n_comp_units, &all_comp_units);
&n_allocated, &n_comp_units,
&all_comp_units);
- dwarf2_per_objfile->all_comp_units
- = obstack_alloc (&objfile->objfile_obstack,
- n_comp_units * sizeof (struct dwarf2_per_cu_data *));
+ dwarf2_per_objfile->all_comp_units = XOBNEWVEC (&objfile->objfile_obstack,
+ struct dwarf2_per_cu_data *,
+ n_comp_units);
memcpy (dwarf2_per_objfile->all_comp_units, all_comp_units,
n_comp_units * sizeof (struct dwarf2_per_cu_data *));
xfree (all_comp_units);
{
add_partial_symbol (pdi, cu);
}
+ if (cu->language == language_rust && pdi->has_children)
+ scan_partial_symbols (pdi->die_child, lowpc, highpc,
+ set_addrmap, cu);
break;
case DW_TAG_enumeration_type:
if (!pdi->is_declaration)
/* Functions used to compute the fully scoped name of a partial DIE.
Normally, this is simple. For C++, the parent DIE's fully scoped
- name is concatenated with "::" and the partial DIE's name. For
- Java, the same thing occurs except that "." is used instead of "::".
+ name is concatenated with "::" and the partial DIE's name.
Enumerators are an exception; they use the scope of their parent
enumeration type, i.e. the name of the enumeration type is not
prepended to the enumerator.
struct dwarf2_cu *ref_cu = cu;
/* DW_FORM_ref_addr is using section offset. */
- attr.name = 0;
+ attr.name = (enum dwarf_attribute) 0;
attr.form = DW_FORM_ref_addr;
attr.u.unsnd = pdi->offset.sect_off;
die = follow_die_ref (NULL, &attr, &ref_cu);
of the global scope. But in Ada, we want to be able to access
nested procedures globally. So all Ada subprograms are stored
in the global scope. */
- /* prim_record_minimal_symbol (actual_name, addr, mst_text,
- objfile); */
add_psymbol_to_list (actual_name, strlen (actual_name),
built_actual_name != NULL,
VAR_DOMAIN, LOC_BLOCK,
&objfile->global_psymbols,
- 0, addr, cu->language, objfile);
+ addr, cu->language, objfile);
}
else
{
- /* prim_record_minimal_symbol (actual_name, addr, mst_file_text,
- objfile); */
add_psymbol_to_list (actual_name, strlen (actual_name),
built_actual_name != NULL,
VAR_DOMAIN, LOC_BLOCK,
&objfile->static_psymbols,
- 0, addr, cu->language, objfile);
+ addr, cu->language, objfile);
}
+
+ if (pdi->main_subprogram && actual_name != NULL)
+ set_objfile_main_name (objfile, actual_name, cu->language);
break;
case DW_TAG_constant:
{
list = &objfile->static_psymbols;
add_psymbol_to_list (actual_name, strlen (actual_name),
built_actual_name != NULL, VAR_DOMAIN, LOC_STATIC,
- list, 0, 0, cu->language, objfile);
+ list, 0, cu->language, objfile);
}
break;
case DW_TAG_variable:
built_actual_name != NULL,
VAR_DOMAIN, LOC_STATIC,
&objfile->global_psymbols,
- 0, addr + baseaddr,
+ addr + baseaddr,
cu->language, objfile);
}
else
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 != NULL,
VAR_DOMAIN, LOC_STATIC,
&objfile->static_psymbols,
- 0,
has_loc ? addr + baseaddr : (CORE_ADDR) 0,
cu->language, objfile);
}
built_actual_name != NULL,
VAR_DOMAIN, LOC_TYPEDEF,
&objfile->static_psymbols,
- 0, (CORE_ADDR) 0, cu->language, objfile);
+ 0, cu->language, objfile);
break;
case DW_TAG_imported_declaration:
case DW_TAG_namespace:
built_actual_name != NULL,
VAR_DOMAIN, LOC_TYPEDEF,
&objfile->global_psymbols,
- 0, (CORE_ADDR) 0, cu->language, objfile);
+ 0, cu->language, objfile);
break;
case DW_TAG_module:
add_psymbol_to_list (actual_name, strlen (actual_name),
built_actual_name != NULL,
MODULE_DOMAIN, LOC_TYPEDEF,
&objfile->global_psymbols,
- 0, (CORE_ADDR) 0, cu->language, objfile);
+ 0, cu->language, objfile);
break;
case DW_TAG_class_type:
case DW_TAG_interface_type:
add_psymbol_to_list (actual_name, strlen (actual_name),
built_actual_name != NULL,
STRUCT_DOMAIN, LOC_TYPEDEF,
- (cu->language == language_cplus
- || cu->language == language_java)
+ cu->language == language_cplus
? &objfile->global_psymbols
: &objfile->static_psymbols,
- 0, (CORE_ADDR) 0, cu->language, objfile);
+ 0, cu->language, objfile);
break;
case DW_TAG_enumerator:
add_psymbol_to_list (actual_name, strlen (actual_name),
built_actual_name != NULL,
VAR_DOMAIN, LOC_CONST,
- (cu->language == language_cplus
- || cu->language == language_java)
+ cu->language == language_cplus
? &objfile->global_psymbols
: &objfile->static_psymbols,
- 0, (CORE_ADDR) 0, cu->language, objfile);
+ 0, cu->language, objfile);
break;
default:
break;
struct dwarf2_cu *cu = reader->cu;
const gdb_byte *buffer = reader->buffer;
const gdb_byte *buffer_end = reader->buffer_end;
- const gdb_byte *start_info_ptr = info_ptr;
unsigned int form, i;
for (i = 0; i < abbrev->num_attrs; i++)
}
/* Restore our global data. */
- dwarf2_per_objfile = objfile_data (objfile, dwarf2_objfile_data_key);
+ dwarf2_per_objfile
+ = (struct dwarf2_per_objfile *) objfile_data (objfile,
+ dwarf2_objfile_data_key);
/* If this psymtab is constructed from a debug-only objfile, the
has_section_at_zero flag will not necessarily be correct. We
if (objfile->separate_debug_objfile_backlink)
{
struct dwarf2_per_objfile *dpo_backlink
- = objfile_data (objfile->separate_debug_objfile_backlink,
- dwarf2_objfile_data_key);
+ = ((struct dwarf2_per_objfile *)
+ objfile_data (objfile->separate_debug_objfile_backlink,
+ dwarf2_objfile_data_key));
dwarf2_per_objfile->has_section_at_zero
= dpo_backlink->has_section_at_zero;
struct dwarf2_queue_item *item;
per_cu->queued = 1;
- item = xmalloc (sizeof (*item));
+ item = XNEW (struct dwarf2_queue_item);
item->per_cu = per_cu;
item->pretend_language = pretend_language;
item->next = NULL;
psymtab_to_symtab_1 (pst->dependencies[i]);
}
- per_cu = pst->read_symtab_private;
+ per_cu = (struct dwarf2_per_cu_data *) pst->read_symtab_private;
if (per_cu == NULL)
{
static hashval_t
die_hash (const void *item)
{
- const struct die_info *die = item;
+ const struct die_info *die = (const struct die_info *) item;
return die->offset.sect_off;
}
static int
die_eq (const void *item_lhs, const void *item_rhs)
{
- const struct die_info *die_lhs = item_lhs;
- const struct die_info *die_rhs = item_rhs;
+ const struct die_info *die_lhs = (const struct die_info *) item_lhs;
+ const struct die_info *die_rhs = (const struct die_info *) item_rhs;
return die_lhs->offset.sect_off == die_rhs->offset.sect_off;
}
void *data)
{
struct dwarf2_cu *cu = reader->cu;
- enum language *language_ptr = data;
+ enum language *language_ptr = (enum language *) data;
gdb_assert (cu->die_hash == NULL);
cu->die_hash =
{
struct objfile *objfile = cu->objfile;
const char *saved_package_name
- = obstack_copy0 (&objfile->per_bfd->storage_obstack,
- package_name,
- strlen (package_name));
- struct type *type = init_type (TYPE_CODE_MODULE, 0, 0,
- saved_package_name, objfile);
+ = (const char *) obstack_copy0 (&objfile->per_bfd->storage_obstack,
+ package_name,
+ strlen (package_name));
+ struct type *type = init_type (objfile, TYPE_CODE_MODULE, 0,
+ saved_package_name);
struct symbol *sym;
TYPE_TAG_NAME (type) = TYPE_NAME (type);
/* Now we have a transitive closure of all the included symtabs. */
len = VEC_length (compunit_symtab_ptr, result_symtabs);
cust->includes
- = obstack_alloc (&dwarf2_per_objfile->objfile->objfile_obstack,
- (len + 1) * sizeof (struct compunit_symtab *));
+ = XOBNEWVEC (&dwarf2_per_objfile->objfile->objfile_obstack,
+ struct compunit_symtab *, len + 1);
for (ix = 0;
VEC_iterate (compunit_symtab_ptr, result_symtabs, ix,
compunit_symtab_iter);
compilation is from a C file generated by language preprocessors, do
not set the language if it was already deduced by start_subfile. */
if (!(cu->language == language_c
- && COMPUNIT_FILETABS (cust)->language != language_c))
+ && COMPUNIT_FILETABS (cust)->language != language_unknown))
COMPUNIT_FILETABS (cust)->language = cu->language;
/* GCC-4.0 has started to support -fvar-tracking. GCC-3.x still can
if (attr != NULL)
{
struct dwarf2_per_cu_data *per_cu;
- struct symtab *imported_symtab;
sect_offset offset;
int is_dwz;
static void
reset_die_in_process (void *arg)
{
- struct die_info *die = arg;
+ struct die_info *die = (struct die_info *) arg;
die->in_process = 0;
}
/* Compute the fully qualified name of DIE in CU. If PHYSNAME is nonzero,
compute the physname for the object, which include a method's:
- - formal parameters (C++/Java),
+ - formal parameters (C++),
- receiver type (Go),
- - return type (Java).
The term "physname" is a bit confusing.
For C++, for example, it is the demangled name.
if (name == NULL)
name = dwarf2_name (die, cu);
- /* For Fortran GDB prefers DW_AT_*linkage_name if present but otherwise
- compute it by typename_concat inside GDB. */
+ /* For Fortran GDB prefers DW_AT_*linkage_name for the physname if present
+ but otherwise compute it by typename_concat inside GDB.
+ FIXME: Actually this is not really true, or at least not always true.
+ It's all very confusing. SYMBOL_SET_NAMES doesn't try to demangle
+ Fortran names because there is no mangling standard. So new_symbol_full
+ will set the demangled name to the result of dwarf2_full_name, and it is
+ the demangled name that GDB uses if it exists. */
if (cu->language == language_ada
|| (cu->language == language_fortran && physname))
{
to be able to reference. Ideally, we want the user to be able
to reference this entity using either natural or linkage name,
but we haven't started looking at this enhancement yet. */
- struct attribute *attr;
+ const char *linkage_name;
- attr = dwarf2_attr (die, DW_AT_linkage_name, cu);
- if (attr == NULL)
- attr = dwarf2_attr (die, DW_AT_MIPS_linkage_name, cu);
- if (attr && DW_STRING (attr))
- return DW_STRING (attr);
+ linkage_name = dwarf2_string_attr (die, DW_AT_linkage_name, cu);
+ if (linkage_name == NULL)
+ linkage_name = dwarf2_string_attr (die, DW_AT_MIPS_linkage_name, cu);
+ if (linkage_name != NULL)
+ return linkage_name;
}
/* These are the only languages we know how to qualify names in. */
if (name != NULL
- && (cu->language == language_cplus || cu->language == language_java
- || cu->language == language_fortran || cu->language == language_d))
+ && (cu->language == language_cplus
+ || cu->language == language_fortran || cu->language == language_d
+ || cu->language == language_rust))
{
if (die_needs_namespace (die, cu))
{
long length;
const char *prefix;
struct ui_file *buf;
- char *intermediate_name;
const char *canonical_name = NULL;
prefix = determine_prefix (die, cu);
}
}
- /* For Java and C++ methods, append formal parameter type
+ /* For C++ methods, append formal parameter type
information, if PHYSNAME. */
if (physname && die->tag == DW_TAG_subprogram
- && (cu->language == language_cplus
- || cu->language == language_java))
+ && cu->language == language_cplus)
{
struct type *type = read_type_die (die, cu);
c_type_print_args (type, buf, 1, cu->language,
&type_print_raw_options);
- if (cu->language == language_java)
- {
- /* For java, we must append the return type to method
- names. */
- if (die->tag == DW_TAG_subprogram)
- java_print_type (TYPE_TARGET_TYPE (type), "", buf,
- 0, 0, &type_print_raw_options);
- }
- else if (cu->language == language_cplus)
+ if (cu->language == language_cplus)
{
/* Assume that an artificial first parameter is
"this", but do not crash if it is not. RealView
}
}
- intermediate_name = ui_file_xstrdup (buf, &length);
+ std::string intermediate_name = ui_file_as_string (buf);
ui_file_delete (buf);
if (cu->language == language_cplus)
canonical_name
- = dwarf2_canonicalize_name (intermediate_name, cu,
+ = dwarf2_canonicalize_name (intermediate_name.c_str (), cu,
&objfile->per_bfd->storage_obstack);
/* If we only computed INTERMEDIATE_NAME, or if
INTERMEDIATE_NAME is already canonical, then we need to
copy it to the appropriate obstack. */
- if (canonical_name == NULL || canonical_name == intermediate_name)
- name = obstack_copy0 (&objfile->per_bfd->storage_obstack,
- intermediate_name,
- strlen (intermediate_name));
+ if (canonical_name == NULL || canonical_name == intermediate_name.c_str ())
+ name = ((const char *)
+ obstack_copy0 (&objfile->per_bfd->storage_obstack,
+ intermediate_name.c_str (),
+ intermediate_name.length ()));
else
name = canonical_name;
-
- xfree (intermediate_name);
}
}
not have a name. NAME may either be from a previous call to
dwarf2_name or NULL.
- The output string will be canonicalized (if C++/Java). */
+ The output string will be canonicalized (if C++). */
static const char *
dwarf2_full_name (const char *name, struct die_info *die, struct dwarf2_cu *cu)
allocated on the objfile_objstack or NULL if the DIE does not have a
name.
- The output string will be canonicalized (if C++/Java). */
+ The output string will be canonicalized (if C++). */
static const char *
dwarf2_physname (const char *name, struct die_info *die, struct dwarf2_cu *cu)
{
struct objfile *objfile = cu->objfile;
- struct attribute *attr;
const char *retval, *mangled = NULL, *canon = NULL;
struct cleanup *back_to;
int need_copy = 1;
back_to = make_cleanup (null_cleanup, NULL);
- attr = dwarf2_attr (die, DW_AT_linkage_name, cu);
- if (!attr)
- attr = dwarf2_attr (die, DW_AT_MIPS_linkage_name, cu);
+ mangled = dwarf2_string_attr (die, DW_AT_linkage_name, cu);
+ if (mangled == NULL)
+ mangled = dwarf2_string_attr (die, DW_AT_MIPS_linkage_name, cu);
+
+ /* rustc emits invalid values for DW_AT_linkage_name. Ignore these.
+ See https://github.com/rust-lang/rust/issues/32925. */
+ if (cu->language == language_rust && mangled != NULL
+ && strchr (mangled, '{') != NULL)
+ mangled = NULL;
/* DW_AT_linkage_name is missing in some cases - depend on what GDB
has computed. */
- if (attr && DW_STRING (attr))
+ if (mangled != NULL)
{
char *demangled;
- mangled = DW_STRING (attr);
-
/* Use DMGL_RET_DROP for C++ template functions to suppress their return
type. It is easier for GDB users to search for such functions as
`name(params)' than `long name(params)'. In such case the minimal
else
{
demangled = gdb_demangle (mangled,
- (DMGL_PARAMS | DMGL_ANSI
- | (cu->language == language_java
- ? DMGL_JAVA | DMGL_RET_POSTFIX
- : DMGL_RET_DROP)));
+ (DMGL_PARAMS | DMGL_ANSI | DMGL_RET_DROP));
}
if (demangled)
{
retval = canon;
if (need_copy)
- retval = obstack_copy0 (&objfile->per_bfd->storage_obstack,
- retval, strlen (retval));
+ retval = ((const char *)
+ obstack_copy0 (&objfile->per_bfd->storage_obstack,
+ retval, strlen (retval)));
do_cleanups (back_to);
return retval;
return 0;
}
+/* Return the using directives repository (global or local?) to use in the
+ current context for LANGUAGE.
+
+ For Ada, imported declarations can materialize renamings, which *may* be
+ global. However it is impossible (for now?) in DWARF to distinguish
+ "external" imported declarations and "static" ones. As all imported
+ declarations seem to be static in all other languages, make them all CU-wide
+ global only in Ada. */
+
+static struct using_direct **
+using_directives (enum language language)
+{
+ if (language == language_ada && context_stack_depth == 0)
+ return &global_using_directives;
+ else
+ return &local_using_directives;
+}
+
/* Read the import statement specified by the given die and record it. */
static void
process_die (child_die, cu);
}
- cp_add_using_directive (import_prefix,
- canonical_name,
- import_alias,
- imported_declaration,
- excludes,
- 0,
- &objfile->objfile_obstack);
+ add_using_directive (using_directives (cu->language),
+ import_prefix,
+ canonical_name,
+ import_alias,
+ imported_declaration,
+ excludes,
+ 0,
+ &objfile->objfile_obstack);
do_cleanups (cleanups);
}
static void
free_cu_line_header (void *arg)
{
- struct dwarf2_cu *cu = arg;
+ struct dwarf2_cu *cu = (struct dwarf2_cu *) arg;
free_line_header (cu->line_header);
cu->line_header = NULL;
find_file_and_directory (struct die_info *die, struct dwarf2_cu *cu,
const char **name, const char **comp_dir)
{
- struct attribute *attr;
-
- *name = NULL;
- *comp_dir = NULL;
-
/* Find the filename. Do not use dwarf2_name here, since the filename
is not a source language identifier. */
- attr = dwarf2_attr (die, DW_AT_name, cu);
- if (attr)
- {
- *name = DW_STRING (attr);
- }
+ *name = dwarf2_string_attr (die, DW_AT_name, cu);
+ *comp_dir = dwarf2_string_attr (die, DW_AT_comp_dir, cu);
- attr = dwarf2_attr (die, DW_AT_comp_dir, cu);
- if (attr)
- *comp_dir = DW_STRING (attr);
- else if (producer_is_gcc_lt_4_3 (cu) && *name != NULL
- && IS_ABSOLUTE_PATH (*name))
+ if (*comp_dir == NULL
+ && producer_is_gcc_lt_4_3 (cu) && *name != NULL
+ && IS_ABSOLUTE_PATH (*name))
{
char *d = ldirname (*name);
{
/* Irix 6.2 native cc prepends <machine>.: to the compilation
directory, get rid of it. */
- char *cp = strchr (*comp_dir, ':');
+ const char *cp = strchr (*comp_dir, ':');
if (cp && cp != *comp_dir && cp[-1] == '.' && cp[1] == '/')
*comp_dir = cp + 1;
if (die->tag == DW_TAG_partial_unit && slot != NULL)
{
gdb_assert (*slot != NULL);
- cu->line_header = *slot;
+ cu->line_header = (struct line_header *) *slot;
return;
}
}
const char *name = NULL;
const char *comp_dir = NULL;
struct die_info *child_die;
- bfd *abfd = objfile->obfd;
CORE_ADDR baseaddr;
baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
static void
setup_type_unit_groups (struct die_info *die, struct dwarf2_cu *cu)
{
- struct objfile *objfile = dwarf2_per_objfile->objfile;
struct dwarf2_per_cu_data *per_cu = cu->per_cu;
struct type_unit_group *tu_group;
int first_time;
{
struct compunit_symtab *cust = dwarf2_start_symtab (cu, "", NULL, 0);
+ /* Note: We don't assign tu_group->compunit_symtab yet because we're
+ still initializing it, and our caller (a few levels up)
+ process_full_type_unit still needs to know if this is the first
+ time. */
+
tu_group->num_symtabs = lh->num_file_names;
tu_group->symtabs = XNEWVEC (struct symtab *, lh->num_file_names);
static hashval_t
hash_dwo_file (const void *item)
{
- const struct dwo_file *dwo_file = item;
+ const struct dwo_file *dwo_file = (const struct dwo_file *) item;
hashval_t hash;
hash = htab_hash_string (dwo_file->dwo_name);
static int
eq_dwo_file (const void *item_lhs, const void *item_rhs)
{
- const struct dwo_file *lhs = item_lhs;
- const struct dwo_file *rhs = item_rhs;
+ const struct dwo_file *lhs = (const struct dwo_file *) item_lhs;
+ const struct dwo_file *rhs = (const struct dwo_file *) item_rhs;
if (strcmp (lhs->dwo_name, rhs->dwo_name) != 0)
return 0;
static hashval_t
hash_dwo_unit (const void *item)
{
- const struct dwo_unit *dwo_unit = item;
+ const struct dwo_unit *dwo_unit = (const struct dwo_unit *) item;
/* This drops the top 32 bits of the id, but is ok for a hash. */
return dwo_unit->signature;
static int
eq_dwo_unit (const void *item_lhs, const void *item_rhs)
{
- const struct dwo_unit *lhs = item_lhs;
- const struct dwo_unit *rhs = item_rhs;
+ const struct dwo_unit *lhs = (const struct dwo_unit *) item_lhs;
+ const struct dwo_unit *rhs = (const struct dwo_unit *) item_rhs;
/* The signature is assumed to be unique within the DWO file.
So while object file CU dwo_id's always have the value zero,
void *datap)
{
struct dwarf2_cu *cu = reader->cu;
- struct objfile *objfile = dwarf2_per_objfile->objfile;
sect_offset offset = cu->per_cu->offset;
struct dwarf2_section_info *section = cu->per_cu->section;
- struct create_dwo_cu_data *data = datap;
+ struct create_dwo_cu_data *data = (struct create_dwo_cu_data *) datap;
struct dwo_file *dwo_file = data->dwo_file;
struct dwo_unit *dwo_unit = &data->dwo_unit;
struct attribute *attr;
{
struct objfile *objfile = dwarf2_per_objfile->objfile;
struct dwarf2_section_info *section = &dwo_file->sections.info;
- bfd *abfd;
- htab_t cu_htab;
const gdb_byte *info_ptr, *end_ptr;
struct create_dwo_cu_data create_dwo_cu_data;
struct dwo_unit *dwo_unit;
if (info_ptr == NULL)
return NULL;
- /* We can't set abfd until now because the section may be empty or
- not present, in which case section->asection will be NULL. */
- abfd = get_section_bfd_owner (section);
-
if (dwarf_read_debug)
{
fprintf_unfiltered (gdb_stdlog, "Reading %s for %s:\n",
if (section_is_p (sectp->name, &names->abbrev_dwo))
{
/* There can be only one. */
- if (sections->abbrev.s.asection != NULL)
+ if (sections->abbrev.s.section != NULL)
return 0;
- sections->abbrev.s.asection = sectp;
+ sections->abbrev.s.section = sectp;
sections->abbrev.size = bfd_get_section_size (sectp);
}
else if (section_is_p (sectp->name, &names->info_dwo)
|| section_is_p (sectp->name, &names->types_dwo))
{
/* There can be only one. */
- if (sections->info_or_types.s.asection != NULL)
+ if (sections->info_or_types.s.section != NULL)
return 0;
- sections->info_or_types.s.asection = sectp;
+ sections->info_or_types.s.section = sectp;
sections->info_or_types.size = bfd_get_section_size (sectp);
}
else if (section_is_p (sectp->name, &names->line_dwo))
{
/* There can be only one. */
- if (sections->line.s.asection != NULL)
+ if (sections->line.s.section != NULL)
return 0;
- sections->line.s.asection = sectp;
+ sections->line.s.section = sectp;
sections->line.size = bfd_get_section_size (sectp);
}
else if (section_is_p (sectp->name, &names->loc_dwo))
{
/* There can be only one. */
- if (sections->loc.s.asection != NULL)
+ if (sections->loc.s.section != NULL)
return 0;
- sections->loc.s.asection = sectp;
+ sections->loc.s.section = sectp;
sections->loc.size = bfd_get_section_size (sectp);
}
else if (section_is_p (sectp->name, &names->macinfo_dwo))
{
/* There can be only one. */
- if (sections->macinfo.s.asection != NULL)
+ if (sections->macinfo.s.section != NULL)
return 0;
- sections->macinfo.s.asection = sectp;
+ sections->macinfo.s.section = sectp;
sections->macinfo.size = bfd_get_section_size (sectp);
}
else if (section_is_p (sectp->name, &names->macro_dwo))
{
/* There can be only one. */
- if (sections->macro.s.asection != NULL)
+ if (sections->macro.s.section != NULL)
return 0;
- sections->macro.s.asection = sectp;
+ sections->macro.s.section = sectp;
sections->macro.size = bfd_get_section_size (sectp);
}
else if (section_is_p (sectp->name, &names->str_offsets_dwo))
{
/* There can be only one. */
- if (sections->str_offsets.s.asection != NULL)
+ if (sections->str_offsets.s.section != NULL)
return 0;
- sections->str_offsets.s.asection = sectp;
+ sections->str_offsets.s.section = sectp;
sections->str_offsets.size = bfd_get_section_size (sectp);
}
else
struct virtual_v1_dwo_sections sections;
void **dwo_file_slot;
char *virtual_dwo_name;
- struct dwarf2_section_info *cutu;
struct cleanup *cleanups;
int i;
virtual_dwo_name);
}
dwo_file = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_file);
- dwo_file->dwo_name = obstack_copy0 (&objfile->objfile_obstack,
- virtual_dwo_name,
- strlen (virtual_dwo_name));
+ dwo_file->dwo_name
+ = (const char *) obstack_copy0 (&objfile->objfile_obstack,
+ virtual_dwo_name,
+ strlen (virtual_dwo_name));
dwo_file->comp_dir = comp_dir;
dwo_file->sections.abbrev = sections.abbrev;
dwo_file->sections.line = sections.line;
fprintf_unfiltered (gdb_stdlog, "Using existing virtual DWO: %s\n",
virtual_dwo_name);
}
- dwo_file = *dwo_file_slot;
+ dwo_file = (struct dwo_file *) *dwo_file_slot;
}
do_cleanups (cleanups);
dwo_unit = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_unit);
dwo_unit->dwo_file = dwo_file;
dwo_unit->signature = signature;
- dwo_unit->section = obstack_alloc (&objfile->objfile_obstack,
- sizeof (struct dwarf2_section_info));
+ dwo_unit->section =
+ XOBNEW (&objfile->objfile_obstack, struct dwarf2_section_info);
*dwo_unit->section = sections.info_or_types;
/* dwo_unit->{offset,length,type_offset_in_tu} are set later. */
struct virtual_v2_dwo_sections sections;
void **dwo_file_slot;
char *virtual_dwo_name;
- struct dwarf2_section_info *cutu;
struct cleanup *cleanups;
int i;
virtual_dwo_name);
}
dwo_file = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_file);
- dwo_file->dwo_name = obstack_copy0 (&objfile->objfile_obstack,
- virtual_dwo_name,
- strlen (virtual_dwo_name));
+ dwo_file->dwo_name
+ = (const char *) obstack_copy0 (&objfile->objfile_obstack,
+ virtual_dwo_name,
+ strlen (virtual_dwo_name));
dwo_file->comp_dir = comp_dir;
dwo_file->sections.abbrev =
create_dwp_v2_section (&dwp_file->sections.abbrev,
fprintf_unfiltered (gdb_stdlog, "Using existing virtual DWO: %s\n",
virtual_dwo_name);
}
- dwo_file = *dwo_file_slot;
+ dwo_file = (struct dwo_file *) *dwo_file_slot;
}
do_cleanups (cleanups);
dwo_unit = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_unit);
dwo_unit->dwo_file = dwo_file;
dwo_unit->signature = signature;
- dwo_unit->section = obstack_alloc (&objfile->objfile_obstack,
- sizeof (struct dwarf2_section_info));
+ dwo_unit->section =
+ XOBNEW (&objfile->objfile_obstack, struct dwarf2_section_info);
*dwo_unit->section = create_dwp_v2_section (is_debug_types
? &dwp_file->sections.types
: &dwp_file->sections.info,
uint32_t hash2 = ((signature >> 32) & mask) | 1;
unsigned int i;
void **slot;
- struct dwo_unit find_dwo_cu, *dwo_cu;
+ struct dwo_unit find_dwo_cu;
memset (&find_dwo_cu, 0, sizeof (find_dwo_cu));
find_dwo_cu.signature = signature;
&find_dwo_cu, INSERT);
if (*slot != NULL)
- return *slot;
+ return (struct dwo_unit *) *slot;
/* Use a for loop so that we don't loop forever on bad debug info. */
for (i = 0; i < dwp_htab->nr_slots; ++i)
comp_dir, signature,
is_debug_types);
}
- return *slot;
+ return (struct dwo_unit *) *slot;
}
if (signature_in_table == 0)
return NULL;
{
if (*debug_file_directory != '\0')
search_path = concat (".", dirname_separator_string,
- debug_file_directory, NULL);
+ debug_file_directory, (char *) NULL);
else
search_path = xstrdup (".");
}
if (comp_dir != NULL)
{
- char *path_to_try = concat (comp_dir, SLASH_STRING, file_name, NULL);
+ char *path_to_try = concat (comp_dir, SLASH_STRING,
+ file_name, (char *) NULL);
/* NOTE: If comp_dir is a relative path, this will also try the
search path, which seems useful. */
static void
dwarf2_locate_dwo_sections (bfd *abfd, asection *sectp, void *dwo_sections_ptr)
{
- struct dwo_sections *dwo_sections = dwo_sections_ptr;
+ struct dwo_sections *dwo_sections = (struct dwo_sections *) dwo_sections_ptr;
const struct dwop_section_names *names = &dwop_section_names;
if (section_is_p (sectp->name, &names->abbrev_dwo))
{
- dwo_sections->abbrev.s.asection = sectp;
+ dwo_sections->abbrev.s.section = sectp;
dwo_sections->abbrev.size = bfd_get_section_size (sectp);
}
else if (section_is_p (sectp->name, &names->info_dwo))
{
- dwo_sections->info.s.asection = sectp;
+ dwo_sections->info.s.section = sectp;
dwo_sections->info.size = bfd_get_section_size (sectp);
}
else if (section_is_p (sectp->name, &names->line_dwo))
{
- dwo_sections->line.s.asection = sectp;
+ dwo_sections->line.s.section = sectp;
dwo_sections->line.size = bfd_get_section_size (sectp);
}
else if (section_is_p (sectp->name, &names->loc_dwo))
{
- dwo_sections->loc.s.asection = sectp;
+ dwo_sections->loc.s.section = sectp;
dwo_sections->loc.size = bfd_get_section_size (sectp);
}
else if (section_is_p (sectp->name, &names->macinfo_dwo))
{
- dwo_sections->macinfo.s.asection = sectp;
+ dwo_sections->macinfo.s.section = sectp;
dwo_sections->macinfo.size = bfd_get_section_size (sectp);
}
else if (section_is_p (sectp->name, &names->macro_dwo))
{
- dwo_sections->macro.s.asection = sectp;
+ dwo_sections->macro.s.section = sectp;
dwo_sections->macro.size = bfd_get_section_size (sectp);
}
else if (section_is_p (sectp->name, &names->str_dwo))
{
- dwo_sections->str.s.asection = sectp;
+ dwo_sections->str.s.section = sectp;
dwo_sections->str.size = bfd_get_section_size (sectp);
}
else if (section_is_p (sectp->name, &names->str_offsets_dwo))
{
- dwo_sections->str_offsets.s.asection = sectp;
+ dwo_sections->str_offsets.s.section = sectp;
dwo_sections->str_offsets.size = bfd_get_section_size (sectp);
}
else if (section_is_p (sectp->name, &names->types_dwo))
struct dwarf2_section_info type_section;
memset (&type_section, 0, sizeof (type_section));
- type_section.s.asection = sectp;
+ type_section.s.section = sectp;
type_section.size = bfd_get_section_size (sectp);
VEC_safe_push (dwarf2_section_info_def, dwo_sections->types,
&type_section);
dwarf2_locate_common_dwp_sections (bfd *abfd, asection *sectp,
void *dwp_file_ptr)
{
- struct dwp_file *dwp_file = dwp_file_ptr;
+ struct dwp_file *dwp_file = (struct dwp_file *) dwp_file_ptr;
const struct dwop_section_names *names = &dwop_section_names;
unsigned int elf_section_nr = elf_section_data (sectp)->this_idx;
/* Look for specific sections that we need. */
if (section_is_p (sectp->name, &names->str_dwo))
{
- dwp_file->sections.str.s.asection = sectp;
+ dwp_file->sections.str.s.section = sectp;
dwp_file->sections.str.size = bfd_get_section_size (sectp);
}
else if (section_is_p (sectp->name, &names->cu_index))
{
- dwp_file->sections.cu_index.s.asection = sectp;
+ dwp_file->sections.cu_index.s.section = sectp;
dwp_file->sections.cu_index.size = bfd_get_section_size (sectp);
}
else if (section_is_p (sectp->name, &names->tu_index))
{
- dwp_file->sections.tu_index.s.asection = sectp;
+ dwp_file->sections.tu_index.s.section = sectp;
dwp_file->sections.tu_index.size = bfd_get_section_size (sectp);
}
}
static void
dwarf2_locate_v2_dwp_sections (bfd *abfd, asection *sectp, void *dwp_file_ptr)
{
- struct dwp_file *dwp_file = dwp_file_ptr;
+ struct dwp_file *dwp_file = (struct dwp_file *) dwp_file_ptr;
const struct dwop_section_names *names = &dwop_section_names;
unsigned int elf_section_nr = elf_section_data (sectp)->this_idx;
/* Look for specific sections that we need. */
if (section_is_p (sectp->name, &names->abbrev_dwo))
{
- dwp_file->sections.abbrev.s.asection = sectp;
+ dwp_file->sections.abbrev.s.section = sectp;
dwp_file->sections.abbrev.size = bfd_get_section_size (sectp);
}
else if (section_is_p (sectp->name, &names->info_dwo))
{
- dwp_file->sections.info.s.asection = sectp;
+ dwp_file->sections.info.s.section = sectp;
dwp_file->sections.info.size = bfd_get_section_size (sectp);
}
else if (section_is_p (sectp->name, &names->line_dwo))
{
- dwp_file->sections.line.s.asection = sectp;
+ dwp_file->sections.line.s.section = sectp;
dwp_file->sections.line.size = bfd_get_section_size (sectp);
}
else if (section_is_p (sectp->name, &names->loc_dwo))
{
- dwp_file->sections.loc.s.asection = sectp;
+ dwp_file->sections.loc.s.section = sectp;
dwp_file->sections.loc.size = bfd_get_section_size (sectp);
}
else if (section_is_p (sectp->name, &names->macinfo_dwo))
{
- dwp_file->sections.macinfo.s.asection = sectp;
+ dwp_file->sections.macinfo.s.section = sectp;
dwp_file->sections.macinfo.size = bfd_get_section_size (sectp);
}
else if (section_is_p (sectp->name, &names->macro_dwo))
{
- dwp_file->sections.macro.s.asection = sectp;
+ dwp_file->sections.macro.s.section = sectp;
dwp_file->sections.macro.size = bfd_get_section_size (sectp);
}
else if (section_is_p (sectp->name, &names->str_offsets_dwo))
{
- dwp_file->sections.str_offsets.s.asection = sectp;
+ dwp_file->sections.str_offsets.s.section = sectp;
dwp_file->sections.str_offsets.size = bfd_get_section_size (sectp);
}
else if (section_is_p (sectp->name, &names->types_dwo))
{
- dwp_file->sections.types.s.asection = sectp;
+ dwp_file->sections.types.s.section = sectp;
dwp_file->sections.types.size = bfd_get_section_size (sectp);
}
}
static hashval_t
hash_dwp_loaded_cutus (const void *item)
{
- const struct dwo_unit *dwo_unit = item;
+ const struct dwo_unit *dwo_unit = (const struct dwo_unit *) item;
/* This drops the top 32 bits of the signature, but is ok for a hash. */
return dwo_unit->signature;
static int
eq_dwp_loaded_cutus (const void *a, const void *b)
{
- const struct dwo_unit *dua = a;
- const struct dwo_unit *dub = b;
+ const struct dwo_unit *dua = (const struct dwo_unit *) a;
+ const struct dwo_unit *dub = (const struct dwo_unit *) b;
return dua->signature == dub->signature;
}
struct dwp_file *dwp_file;
char *dwp_name;
bfd *dbfd;
- struct cleanup *cleanups;
+ struct cleanup *cleanups = make_cleanup (null_cleanup, 0);
/* Try to find first .dwp for the binary file before any symbolic links
resolving. */
- dwp_name = xstrprintf ("%s.dwp", objfile->original_name);
- cleanups = make_cleanup (xfree, dwp_name);
+
+ /* If the objfile is a debug file, find the name of the real binary
+ file and get the name of dwp file from there. */
+ if (objfile->separate_debug_objfile_backlink != NULL)
+ {
+ struct objfile *backlink = objfile->separate_debug_objfile_backlink;
+ const char *backlink_basename = lbasename (backlink->original_name);
+ char *debug_dirname = ldirname (objfile->original_name);
+
+ make_cleanup (xfree, debug_dirname);
+ dwp_name = xstrprintf ("%s%s%s.dwp", debug_dirname,
+ SLASH_STRING, backlink_basename);
+ }
+ else
+ dwp_name = xstrprintf ("%s.dwp", objfile->original_name);
+ make_cleanup (xfree, dwp_name);
dbfd = open_dwp_file (dwp_name);
if (dbfd == NULL
*dwo_file_slot = open_and_init_dwo_file (this_unit, dwo_name, comp_dir);
}
/* NOTE: This will be NULL if unable to open the file. */
- dwo_file = *dwo_file_slot;
+ dwo_file = (struct dwo_file *) *dwo_file_slot;
if (dwo_file != NULL)
{
memset (&find_dwo_cutu, 0, sizeof (find_dwo_cutu));
find_dwo_cutu.signature = signature;
- dwo_cutu = htab_find (dwo_file->tus, &find_dwo_cutu);
+ dwo_cutu
+ = (struct dwo_unit *) htab_find (dwo_file->tus, &find_dwo_cutu);
}
else if (!is_debug_types && dwo_file->cu)
{
static void
free_dwo_file (struct dwo_file *dwo_file, struct objfile *objfile)
{
- int ix;
- struct dwarf2_section_info *section;
/* Note: dbfd is NULL for virtual DWO files. */
gdb_bfd_unref (dwo_file->dbfd);
child_die = sibling_die (child_die);
die_children_count++;
}
- offsets = xmalloc (sizeof (*offsets) * die_children_count);
+ offsets = XNEWVEC (sect_offset, die_children_count);
cleanups = make_cleanup (xfree, offsets);
offsets_end = offsets;
}
/* Ignore functions with missing or invalid low and high pc attributes. */
- if (!dwarf2_get_pc_bounds (die, &lowpc, &highpc, cu, NULL))
+ if (dwarf2_get_pc_bounds (die, &lowpc, &highpc, cu, NULL)
+ <= PC_BOUNDS_INVALID)
{
attr = dwarf2_attr (die, DW_AT_external, cu);
if (!attr || !DW_UNSND (attr))
if (attr)
dwarf2_symbol_mark_computed (attr, newobj->name, cu, 1);
+ /* If there is a location for the static link, record it. */
+ newobj->static_link = NULL;
+ attr = dwarf2_attr (die, DW_AT_static_link, cu);
+ if (attr)
+ {
+ newobj->static_link
+ = XOBNEW (&objfile->objfile_obstack, struct dynamic_prop);
+ attr_to_dynamic_prop (attr, die, cu, newobj->static_link);
+ }
+
cu->list_in_scope = &local_symbols;
if (die->child != NULL)
newobj = pop_context ();
/* Make a block for the local symbols within. */
block = finish_block (newobj->name, &local_symbols, newobj->old_blocks,
- lowpc, highpc);
+ newobj->static_link, lowpc, highpc);
/* For C++, set the block's scope. */
if ((cu->language == language_cplus
|| cu->language == language_fortran
- || cu->language == language_d)
+ || cu->language == language_d
+ || cu->language == language_rust)
&& cu->processing_has_namespace_info)
block_set_scope (block, determine_prefix (die, cu),
&objfile->objfile_obstack);
templ_func->n_template_arguments = VEC_length (symbolp, template_args);
templ_func->template_arguments
- = obstack_alloc (&objfile->objfile_obstack,
- (templ_func->n_template_arguments
- * sizeof (struct symbol *)));
+ = XOBNEWVEC (&objfile->objfile_obstack, struct symbol *,
+ templ_func->n_template_arguments);
memcpy (templ_func->template_arguments,
VEC_address (symbolp, template_args),
(templ_func->n_template_arguments * sizeof (struct symbol *)));
when we finish processing a function scope, we may need to go
back to building a containing block's symbol lists. */
local_symbols = newobj->locals;
- using_directives = newobj->using_directives;
+ local_using_directives = newobj->local_using_directives;
/* If we've finished processing a top-level function, subsequent
symbols go in the file symbol list. */
as multiple lexical blocks? Handling children in a sane way would
be nasty. Might be easier to properly extend generic blocks to
describe ranges. */
- if (!dwarf2_get_pc_bounds (die, &lowpc, &highpc, cu, NULL))
- return;
+ switch (dwarf2_get_pc_bounds (die, &lowpc, &highpc, cu, NULL))
+ {
+ case PC_BOUNDS_NOT_PRESENT:
+ /* DW_TAG_lexical_block has no attributes, process its children as if
+ there was no wrapping by that DW_TAG_lexical_block.
+ GCC does no longer produces such DWARF since GCC r224161. */
+ for (child_die = die->child;
+ child_die != NULL && child_die->tag;
+ child_die = sibling_die (child_die))
+ process_die (child_die, cu);
+ return;
+ case PC_BOUNDS_INVALID:
+ return;
+ }
lowpc = gdbarch_adjust_dwarf2_addr (gdbarch, lowpc + baseaddr);
highpc = gdbarch_adjust_dwarf2_addr (gdbarch, highpc + baseaddr);
inherit_abstract_dies (die, cu);
newobj = pop_context ();
- if (local_symbols != NULL || using_directives != NULL)
+ if (local_symbols != NULL || local_using_directives != NULL)
{
struct block *block
- = finish_block (0, &local_symbols, newobj->old_blocks,
+ = finish_block (0, &local_symbols, newobj->old_blocks, NULL,
newobj->start_addr, highpc);
/* Note that recording ranges after traversing children, as we
dwarf2_record_block_ranges (die, block, baseaddr, cu);
}
local_symbols = newobj->locals;
- using_directives = newobj->using_directives;
+ local_using_directives = newobj->local_using_directives;
}
/* Read in DW_TAG_GNU_call_site and insert it to CU->call_site_htab. */
nparams++;
}
- call_site = obstack_alloc (&objfile->objfile_obstack,
- (sizeof (*call_site)
- + (sizeof (*call_site->parameter)
- * (nparams - 1))));
+ call_site
+ = ((struct call_site *)
+ obstack_alloc (&objfile->objfile_obstack,
+ sizeof (*call_site)
+ + (sizeof (*call_site->parameter) * (nparams - 1))));
*slot = call_site;
memset (call_site, 0, sizeof (*call_site) - sizeof (*call_site->parameter));
call_site->pc = pc;
{
struct dwarf2_locexpr_baton *dlbaton;
- dlbaton = obstack_alloc (&objfile->objfile_obstack, sizeof (*dlbaton));
+ dlbaton = XOBNEW (&objfile->objfile_obstack, struct dwarf2_locexpr_baton);
dlbaton->data = DW_BLOCK (attr)->data;
dlbaton->size = DW_BLOCK (attr)->size;
dlbaton->per_cu = cu->per_cu;
gdb_assert (target_cu->objfile == objfile);
if (die_is_declaration (target_die, target_cu))
{
- const char *target_physname = NULL;
- struct attribute *target_attr;
+ const char *target_physname;
/* Prefer the mangled name; otherwise compute the demangled one. */
- target_attr = dwarf2_attr (target_die, DW_AT_linkage_name, target_cu);
- if (target_attr == NULL)
- target_attr = dwarf2_attr (target_die, DW_AT_MIPS_linkage_name,
- target_cu);
- if (target_attr != NULL && DW_STRING (target_attr) != NULL)
- target_physname = DW_STRING (target_attr);
- else
+ target_physname = dwarf2_string_attr (target_die,
+ DW_AT_linkage_name,
+ target_cu);
+ if (target_physname == NULL)
+ target_physname = dwarf2_string_attr (target_die,
+ DW_AT_MIPS_linkage_name,
+ target_cu);
+ if (target_physname == NULL)
target_physname = dwarf2_physname (NULL, target_die, target_cu);
if (target_physname == NULL)
complaint (&symfile_complaints,
CORE_ADDR lowpc;
/* DW_AT_entry_pc should be preferred. */
- if (!dwarf2_get_pc_bounds (target_die, &lowpc, NULL, target_cu, NULL))
+ if (dwarf2_get_pc_bounds (target_die, &lowpc, NULL, target_cu, NULL)
+ <= PC_BOUNDS_INVALID)
complaint (&symfile_complaints,
_("DW_AT_GNU_call_site_target target DIE has invalid "
"low pc, for referencing DIE 0x%x [in module %s]"),
int found_base;
unsigned int dummy;
const gdb_byte *buffer;
- CORE_ADDR marker;
int low_set;
CORE_ADDR low = 0;
CORE_ADDR high = 0;
}
buffer = dwarf2_per_objfile->ranges.buffer + offset;
- /* Read in the largest possible address. */
- marker = read_address (obfd, buffer, cu, &dummy);
- if ((marker & mask) == mask)
- {
- /* If we found the largest possible address, then
- read the base address. */
- base = read_address (obfd, buffer + addr_size, cu, &dummy);
- buffer += 2 * addr_size;
- offset += 2 * addr_size;
- found_base = 1;
- }
-
low_set = 0;
baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
the base address. Check for a base address here. */
if ((range_beginning & mask) == mask)
{
- /* If we found the largest possible address, then
- read the base address. */
- base = read_address (obfd, buffer + addr_size, cu, &dummy);
+ /* If we found the largest possible address, then we already
+ have the base address in range_end. */
+ base = range_end;
found_base = 1;
continue;
}
return 1;
}
-/* Get low and high pc attributes from a die. Return 1 if the attributes
- are present and valid, otherwise, return 0. Return -1 if the range is
- discontinuous, i.e. derived from DW_AT_ranges information. */
+/* Get low and high pc attributes from a die. See enum pc_bounds_kind
+ definition for the return value. *LOWPC and *HIGHPC are set iff
+ neither PC_BOUNDS_NOT_PRESENT nor PC_BOUNDS_INVALID are returned. */
-static int
+static enum pc_bounds_kind
dwarf2_get_pc_bounds (struct die_info *die, CORE_ADDR *lowpc,
CORE_ADDR *highpc, struct dwarf2_cu *cu,
struct partial_symtab *pst)
struct attribute *attr_high;
CORE_ADDR low = 0;
CORE_ADDR high = 0;
- int ret = 0;
+ enum pc_bounds_kind ret;
attr_high = dwarf2_attr (die, DW_AT_high_pc, cu);
if (attr_high)
}
else
/* Found high w/o low attribute. */
- return 0;
+ return PC_BOUNDS_INVALID;
/* Found consecutive range of addresses. */
- ret = 1;
+ ret = PC_BOUNDS_HIGH_LOW;
}
else
{
/* Value of the DW_AT_ranges attribute is the offset in the
.debug_ranges section. */
if (!dwarf2_ranges_read (ranges_offset, &low, &high, cu, pst))
- return 0;
+ return PC_BOUNDS_INVALID;
/* Found discontinuous range of addresses. */
- ret = -1;
+ ret = PC_BOUNDS_RANGES;
}
+ else
+ return PC_BOUNDS_NOT_PRESENT;
}
/* read_partial_die has also the strict LOW < HIGH requirement. */
if (high <= low)
- return 0;
+ return PC_BOUNDS_INVALID;
/* When using the GNU linker, .gnu.linkonce. sections are used to
eliminate duplicate copies of functions and vtables and such.
If this is a discarded function, mark the pc bounds as invalid,
so that GDB will ignore it. */
if (low == 0 && !dwarf2_per_objfile->has_section_at_zero)
- return 0;
+ return PC_BOUNDS_INVALID;
*lowpc = low;
if (highpc)
CORE_ADDR low, high;
struct die_info *child = die->child;
- if (dwarf2_get_pc_bounds (die, &low, &high, cu, NULL))
+ if (dwarf2_get_pc_bounds (die, &low, &high, cu, NULL) >= PC_BOUNDS_RANGES)
{
- *lowpc = min (*lowpc, low);
- *highpc = max (*highpc, high);
+ *lowpc = std::min (*lowpc, low);
+ *highpc = std::max (*highpc, high);
}
/* If the language does not allow nested subprograms (either inside
CORE_ADDR best_high = (CORE_ADDR) 0;
CORE_ADDR current_low, current_high;
- if (dwarf2_get_pc_bounds (die, ¤t_low, ¤t_high, cu, NULL))
+ if (dwarf2_get_pc_bounds (die, ¤t_low, ¤t_high, cu, NULL)
+ >= PC_BOUNDS_RANGES)
{
best_low = current_low;
best_high = current_high;
if (current_low != ((CORE_ADDR) -1))
{
- best_low = min (best_low, current_low);
- best_high = max (best_high, current_high);
+ best_low = std::min (best_low, current_low);
+ best_high = std::max (best_high, current_high);
}
break;
default:
static void
check_producer (struct dwarf2_cu *cu)
{
- const char *cs;
int major, minor;
if (cu->producer == NULL)
const char *fieldname = "";
/* Allocate a new field list entry and link it in. */
- new_field = (struct nextfield *) xmalloc (sizeof (struct nextfield));
+ new_field = XNEW (struct nextfield);
make_cleanup (xfree, new_field);
memset (new_field, 0, sizeof (struct nextfield));
- bit_offset - FIELD_BITSIZE (*fp)));
}
}
+ attr = dwarf2_attr (die, DW_AT_data_bit_offset, cu);
+ if (attr != NULL)
+ SET_FIELD_BITPOS (*fp, (FIELD_BITPOS (*fp)
+ + dwarf2_get_attr_constant_value (attr, 0)));
/* Get name of field. */
fieldname = dwarf2_name (die, cu);
dwarf2_add_typedef (struct field_info *fip, struct die_info *die,
struct dwarf2_cu *cu)
{
- struct objfile *objfile = cu->objfile;
struct typedef_field_list *new_field;
- struct attribute *attr;
struct typedef_field *fp;
- char *fieldname = "";
/* Allocate a new field list entry and link it in. */
- new_field = xzalloc (sizeof (*new_field));
+ new_field = XCNEW (struct typedef_field_list);
make_cleanup (xfree, new_field);
gdb_assert (die->tag == DW_TAG_typedef);
unsigned char *pointer;
ALLOCATE_CPLUS_STRUCT_TYPE (type);
- pointer = TYPE_ALLOC (type, num_bytes);
+ pointer = (unsigned char *) TYPE_ALLOC (type, num_bytes);
TYPE_FIELD_VIRTUAL_BITS (type) = pointer;
B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type), fip->nbaseclasses);
TYPE_N_BASECLASSES (type) = fip->nbaseclasses;
/* Create a new member function field and chain it to the field list
entry. */
- new_fnfield = (struct nextfnfield *) xmalloc (sizeof (struct nextfnfield));
+ new_fnfield = XNEW (struct nextfnfield);
make_cleanup (xfree, new_fnfield);
memset (new_fnfield, 0, sizeof (struct nextfnfield));
new_fnfield->next = flp->head;
fnp = &new_fnfield->fnfield;
/* Delay processing of the physname until later. */
- if (cu->language == language_cplus || cu->language == language_java)
+ if (cu->language == language_cplus)
{
add_to_method_list (type, i, flp->length - 1, fieldname,
die, cu);
&& DW_BLOCK (attr)->data[0] == DW_OP_deref_size
&& DW_BLOCK (attr)->data[1] == cu->header.addr_size))
{
- struct dwarf_block blk;
- int offset;
-
- offset = (DW_BLOCK (attr)->data[0] == DW_OP_deref
- ? 1 : 2);
- blk.size = DW_BLOCK (attr)->size - offset;
- blk.data = DW_BLOCK (attr)->data + offset;
fnp->voffset = decode_locdesc (DW_BLOCK (attr), cu);
if ((fnp->voffset % cu->header.addr_size) != 0)
dwarf2_complex_location_expr_complaint ();
static const char vptr[] = "_vptr";
static const char vtable[] = "vtable";
- /* Look for the C++ and Java forms of the vtable. */
- if ((cu->language == language_java
- && startswith (name, vtable))
- || (startswith (name, vptr)
- && is_cplus_marker (name[sizeof (vptr) - 1])))
+ /* Look for the C++ form of the vtable. */
+ if (startswith (name, vptr) && is_cplus_marker (name[sizeof (vptr) - 1]))
return 1;
return 0;
if (name != NULL)
{
if (cu->language == language_cplus
- || cu->language == language_java
- || cu->language == language_d)
+ || cu->language == language_d
+ || cu->language == language_rust)
{
const char *full_name = dwarf2_full_name (name, die, cu);
attr = dwarf2_attr (die, DW_AT_byte_size, cu);
if (attr)
{
- TYPE_LENGTH (type) = DW_UNSND (attr);
+ if (attr_form_is_constant (attr))
+ TYPE_LENGTH (type) = DW_UNSND (attr);
+ else
+ {
+ /* For the moment, dynamic type sizes are not supported
+ by GDB's struct type. The actual size is determined
+ on-demand when resolving the type of a given object,
+ so set the type's length to zero for now. Otherwise,
+ we record an expression as the length, and that expression
+ could lead to a very large value, which could eventually
+ lead to us trying to allocate that much memory when creating
+ a value of that type. */
+ TYPE_LENGTH (type) = 0;
+ }
}
else
{
}
else if (child_die->tag == DW_TAG_subprogram)
{
- /* C++ member function. */
- dwarf2_add_member_fn (&fi, child_die, type, cu);
+ /* Rust doesn't have member functions in the C++ sense.
+ However, it does emit ordinary functions as children
+ of a struct DIE. */
+ if (cu->language == language_rust)
+ read_func_scope (child_die, cu);
+ else
+ {
+ /* C++ member function. */
+ dwarf2_add_member_fn (&fi, child_die, type, cu);
+ }
}
else if (child_die->tag == DW_TAG_inheritance)
{
TYPE_N_TEMPLATE_ARGUMENTS (type)
= VEC_length (symbolp, template_args);
TYPE_TEMPLATE_ARGUMENTS (type)
- = obstack_alloc (&objfile->objfile_obstack,
- (TYPE_N_TEMPLATE_ARGUMENTS (type)
- * sizeof (struct symbol *)));
+ = XOBNEWVEC (&objfile->objfile_obstack,
+ struct symbol *,
+ TYPE_N_TEMPLATE_ARGUMENTS (type));
memcpy (TYPE_TEMPLATE_ARGUMENTS (type),
VEC_address (symbolp, template_args),
(TYPE_N_TEMPLATE_ARGUMENTS (type)
ALLOCATE_CPLUS_STRUCT_TYPE (type);
TYPE_TYPEDEF_FIELD_ARRAY (type)
- = TYPE_ALLOC (type, sizeof (TYPE_TYPEDEF_FIELD (type, 0)) * i);
+ = ((struct typedef_field *)
+ TYPE_ALLOC (type, sizeof (TYPE_TYPEDEF_FIELD (type, 0)) * i));
TYPE_TYPEDEF_FIELD_COUNT (type) = i;
/* Reverse the list order to keep the debug info elements order. */
}
do_cleanups (back_to);
-
- if (HAVE_CPLUS_STRUCT (type))
- TYPE_CPLUS_REALLY_JAVA (type) = cu->language == language_java;
}
quirk_gcc_member_function_pointer (type, objfile);
gdb_assert (attr_form_is_block (member_loc)
|| attr_form_is_constant (member_loc));
- baton = obstack_alloc (&objfile->objfile_obstack,
- sizeof (struct dwarf2_locexpr_baton));
+ baton = XOBNEW (&objfile->objfile_obstack, struct dwarf2_locexpr_baton);
baton->per_cu = cu->per_cu;
gdb_assert (baton->per_cu);
else
baton->size += DW_BLOCK (member_loc)->size;
- ptr = obstack_alloc (&objfile->objfile_obstack, baton->size);
+ ptr = (gdb_byte *) obstack_alloc (&objfile->objfile_obstack, baton->size);
baton->data = ptr;
*ptr++ = DW_OP_call4;
size = (sizeof (struct common_block)
+ (n_entries - 1) * sizeof (struct symbol *));
- common_block = obstack_alloc (&objfile->objfile_obstack, size);
+ common_block
+ = (struct common_block *) obstack_alloc (&objfile->objfile_obstack,
+ size);
memset (common_block->contents, 0, n_entries * sizeof (struct symbol *));
common_block->n_entries = 0;
previous_prefix, name, 0, cu);
/* Create the type. */
- type = init_type (TYPE_CODE_NAMESPACE, 0, 0, NULL,
- objfile);
- TYPE_NAME (type) = name;
+ type = init_type (objfile, TYPE_CODE_NAMESPACE, 0, name);
TYPE_TAG_NAME (type) = TYPE_NAME (type);
return set_die_type (die, type, cu);
}
-/* Read a C++ namespace. */
+/* Read a namespace scope. */
static void
read_namespace (struct die_info *die, struct dwarf2_cu *cu)
{
const char *previous_prefix = determine_prefix (die, cu);
- cp_add_using_directive (previous_prefix, TYPE_NAME (type), NULL,
- NULL, NULL, 0, &objfile->objfile_obstack);
+ add_using_directive (using_directives (cu->language),
+ previous_prefix, TYPE_NAME (type), NULL,
+ NULL, NULL, 0, &objfile->objfile_obstack);
}
}
complaint (&symfile_complaints,
_("DW_TAG_module has no name, offset 0x%x"),
die->offset.sect_off);
- type = init_type (TYPE_CODE_MODULE, 0, 0, module_name, objfile);
+ type = init_type (objfile, TYPE_CODE_MODULE, 0, module_name);
/* determine_prefix uses TYPE_TAG_NAME. */
TYPE_TAG_NAME (type) = TYPE_NAME (type);
{
/* We don't use dwarf2_name here so that we can detect the absence
of a name -> anonymous namespace. */
- struct attribute *attr = dwarf2_attr (die, DW_AT_name, cu);
+ name = dwarf2_string_attr (die, DW_AT_name, cu);
- if (attr != NULL)
- name = DW_STRING (attr);
if (name != NULL)
break;
}
if (attr)
TYPE_FIELD_ARTIFICIAL (ftype, iparams) = DW_UNSND (attr);
else
- {
- TYPE_FIELD_ARTIFICIAL (ftype, iparams) = 0;
-
- /* GCC/43521: In java, the formal parameter
- "this" is sometimes not marked with DW_AT_artificial. */
- if (cu->language == language_java)
- {
- const char *name = dwarf2_name (child_die, cu);
-
- if (name && !strcmp (name, "this"))
- TYPE_FIELD_ARTIFICIAL (ftype, iparams) = 1;
- }
- }
+ TYPE_FIELD_ARTIFICIAL (ftype, iparams) = 0;
arg_type = die_type (child_die, cu);
/* RealView does not mark THIS as const, which the testsuite
struct type *this_type, *target_type;
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) = name;
+ this_type = init_type (objfile, TYPE_CODE_TYPEDEF, 0, name);
+ TYPE_TARGET_STUB (this_type) = 1;
set_die_type (die, this_type, cu);
target_type = die_type (die, cu);
if (target_type != this_type)
return this_type;
}
+/* Allocate a floating-point type of size BITS and name NAME. Pass NAME_HINT
+ (which may be different from NAME) to the architecture back-end to allow
+ it to guess the correct format if necessary. */
+
+static struct type *
+dwarf2_init_float_type (struct objfile *objfile, int bits, const char *name,
+ const char *name_hint)
+{
+ struct gdbarch *gdbarch = get_objfile_arch (objfile);
+ const struct floatformat **format;
+ struct type *type;
+
+ format = gdbarch_floatformat_for_type (gdbarch, name_hint, bits);
+ if (format)
+ type = init_float_type (objfile, bits, name, format);
+ else
+ type = init_type (objfile, TYPE_CODE_ERROR, bits / TARGET_CHAR_BIT, name);
+
+ return type;
+}
+
/* Find a representation of a given base type and install
it in the TYPE field of the die. */
struct objfile *objfile = cu->objfile;
struct type *type;
struct attribute *attr;
- int encoding = 0, size = 0;
+ int encoding = 0, bits = 0;
const char *name;
- enum type_code code = TYPE_CODE_INT;
- int type_flags = 0;
- struct type *target_type = NULL;
attr = dwarf2_attr (die, DW_AT_encoding, cu);
if (attr)
attr = dwarf2_attr (die, DW_AT_byte_size, cu);
if (attr)
{
- size = DW_UNSND (attr);
+ bits = DW_UNSND (attr) * TARGET_CHAR_BIT;
}
name = dwarf2_name (die, cu);
if (!name)
{
case DW_ATE_address:
/* Turn DW_ATE_address into a void * pointer. */
- code = TYPE_CODE_PTR;
- type_flags |= TYPE_FLAG_UNSIGNED;
- target_type = init_type (TYPE_CODE_VOID, 1, 0, NULL, objfile);
+ type = init_type (objfile, TYPE_CODE_VOID, 1, NULL);
+ type = init_pointer_type (objfile, bits, name, type);
break;
case DW_ATE_boolean:
- code = TYPE_CODE_BOOL;
- type_flags |= TYPE_FLAG_UNSIGNED;
+ type = init_boolean_type (objfile, bits, 1, name);
break;
case DW_ATE_complex_float:
- code = TYPE_CODE_COMPLEX;
- target_type = init_type (TYPE_CODE_FLT, size / 2, 0, NULL, objfile);
+ type = dwarf2_init_float_type (objfile, bits / 2, NULL, name);
+ type = init_complex_type (objfile, name, type);
break;
case DW_ATE_decimal_float:
- code = TYPE_CODE_DECFLOAT;
+ type = init_decfloat_type (objfile, bits, name);
break;
case DW_ATE_float:
- code = TYPE_CODE_FLT;
+ type = dwarf2_init_float_type (objfile, bits, name, name);
break;
case DW_ATE_signed:
+ type = init_integer_type (objfile, bits, 0, name);
break;
case DW_ATE_unsigned:
- type_flags |= TYPE_FLAG_UNSIGNED;
if (cu->language == language_fortran
&& name
&& startswith (name, "character("))
- code = TYPE_CODE_CHAR;
+ type = init_character_type (objfile, bits, 1, name);
+ else
+ type = init_integer_type (objfile, bits, 1, name);
break;
case DW_ATE_signed_char:
if (cu->language == language_ada || cu->language == language_m2
|| cu->language == language_pascal
|| cu->language == language_fortran)
- code = TYPE_CODE_CHAR;
+ type = init_character_type (objfile, bits, 0, name);
+ else
+ type = init_integer_type (objfile, bits, 0, name);
break;
case DW_ATE_unsigned_char:
if (cu->language == language_ada || cu->language == language_m2
|| cu->language == language_pascal
- || cu->language == language_fortran)
- code = TYPE_CODE_CHAR;
- type_flags |= TYPE_FLAG_UNSIGNED;
+ || cu->language == language_fortran
+ || cu->language == language_rust)
+ type = init_character_type (objfile, bits, 1, name);
+ else
+ type = init_integer_type (objfile, bits, 1, name);
break;
case DW_ATE_UTF:
/* We just treat this as an integer and then recognize the
type by name elsewhere. */
+ type = init_integer_type (objfile, bits, 0, name);
break;
default:
complaint (&symfile_complaints, _("unsupported DW_AT_encoding: '%s'"),
dwarf_type_encoding_name (encoding));
+ type = init_type (objfile, TYPE_CODE_ERROR,
+ bits / TARGET_CHAR_BIT, name);
break;
}
- type = init_type (code, size, type_flags, NULL, objfile);
- TYPE_NAME (type) = name;
- TYPE_TARGET_TYPE (type) = target_type;
-
if (name && strcmp (name, "char") == 0)
TYPE_NOSIGN (type) = 1;
if (attr_form_is_block (attr))
{
- baton = obstack_alloc (obstack, sizeof (*baton));
+ baton = XOBNEW (obstack, struct dwarf2_property_baton);
baton->referenced_type = NULL;
baton->locexpr.per_cu = cu->per_cu;
baton->locexpr.size = DW_BLOCK (attr)->size;
case DW_AT_location:
if (attr_form_is_section_offset (target_attr))
{
- baton = obstack_alloc (obstack, sizeof (*baton));
+ baton = XOBNEW (obstack, struct dwarf2_property_baton);
baton->referenced_type = die_type (target_die, target_cu);
fill_in_loclist_baton (cu, &baton->loclist, target_attr);
prop->data.baton = baton;
}
else if (attr_form_is_block (target_attr))
{
- baton = obstack_alloc (obstack, sizeof (*baton));
+ baton = XOBNEW (obstack, struct dwarf2_property_baton);
baton->referenced_type = die_type (target_die, target_cu);
baton->locexpr.per_cu = cu->per_cu;
baton->locexpr.size = DW_BLOCK (target_attr)->size;
&offset))
return 0;
- baton = obstack_alloc (obstack, sizeof (*baton));
+ baton = XOBNEW (obstack, struct dwarf2_property_baton);
baton->referenced_type = read_type_die (target_die->parent,
target_cu);
baton->offset_info.offset = offset;
low_default_is_valid = 1;
break;
case language_d:
- case language_java:
case language_objc:
+ case language_rust:
low.data.const_val = 0;
low_default_is_valid = (cu->header.version >= 4);
break;
the bounds as signed, and thus sign-extend their values, when
the base type is signed. */
negative_mask =
- (LONGEST) -1 << (TYPE_LENGTH (base_type) * TARGET_CHAR_BIT - 1);
+ -((LONGEST) 1 << (TYPE_LENGTH (base_type) * TARGET_CHAR_BIT - 1));
if (low.kind == PROP_CONST
&& !TYPE_UNSIGNED (base_type) && (low.data.const_val & negative_mask))
low.data.const_val |= negative_mask;
/* For now, we only support the C meaning of an unspecified type: void. */
- type = init_type (TYPE_CODE_VOID, 0, 0, NULL, cu->objfile);
+ type = init_type (cu->objfile, TYPE_CODE_VOID, 0, NULL);
TYPE_NAME (type) = dwarf2_name (die, cu);
return set_die_type (die, type, cu);
{
struct abbrev_info *abbrev;
- abbrev = (struct abbrev_info *)
- obstack_alloc (&abbrev_table->abbrev_obstack, sizeof (struct abbrev_info));
+ abbrev = XOBNEW (&abbrev_table->abbrev_obstack, struct abbrev_info);
memset (abbrev, 0, sizeof (struct abbrev_info));
+
return abbrev;
}
abbrev_table = XNEW (struct abbrev_table);
abbrev_table->offset = offset;
obstack_init (&abbrev_table->abbrev_obstack);
- abbrev_table->abbrevs = obstack_alloc (&abbrev_table->abbrev_obstack,
- (ABBREV_HASH_SIZE
- * sizeof (struct abbrev_info *)));
+ abbrev_table->abbrevs =
+ XOBNEWVEC (&abbrev_table->abbrev_obstack, struct abbrev_info *,
+ ABBREV_HASH_SIZE);
memset (abbrev_table->abbrevs, 0,
ABBREV_HASH_SIZE * sizeof (struct abbrev_info *));
abbrev_ptr += bytes_read;
allocated_attrs = ATTR_ALLOC_CHUNK;
- cur_attrs = xmalloc (allocated_attrs * sizeof (struct attr_abbrev));
+ cur_attrs = XNEWVEC (struct attr_abbrev, allocated_attrs);
/* Loop until we reach an abbrev number of 0. */
while (abbrev_number)
{
allocated_attrs += ATTR_ALLOC_CHUNK;
cur_attrs
- = xrealloc (cur_attrs, (allocated_attrs
- * sizeof (struct attr_abbrev)));
+ = XRESIZEVEC (struct attr_abbrev, cur_attrs, allocated_attrs);
}
cur_attrs[cur_abbrev->num_attrs].name
abbrev_ptr += bytes_read;
}
- cur_abbrev->attrs = obstack_alloc (&abbrev_table->abbrev_obstack,
- (cur_abbrev->num_attrs
- * sizeof (struct attr_abbrev)));
+ cur_abbrev->attrs =
+ XOBNEWVEC (&abbrev_table->abbrev_obstack, struct attr_abbrev,
+ cur_abbrev->num_attrs);
memcpy (cur_abbrev->attrs, cur_attrs,
cur_abbrev->num_attrs * sizeof (struct attr_abbrev));
static void
abbrev_table_free_cleanup (void *table_ptr)
{
- struct abbrev_table **abbrev_table_ptr = table_ptr;
+ struct abbrev_table **abbrev_table_ptr = (struct abbrev_table **) table_ptr;
if (*abbrev_table_ptr != NULL)
abbrev_table_free (*abbrev_table_ptr);
static void
dwarf2_free_abbrev_table (void *ptr_to_cu)
{
- struct dwarf2_cu *cu = ptr_to_cu;
+ struct dwarf2_cu *cu = (struct dwarf2_cu *) ptr_to_cu;
if (cu->abbrev_table != NULL)
abbrev_table_free (cu->abbrev_table);
hashtab_obstack_allocate,
dummy_obstack_deallocate);
- part_die = obstack_alloc (&cu->comp_unit_obstack,
- sizeof (struct partial_die_info));
+ part_die = XOBNEW (&cu->comp_unit_obstack, struct partial_die_info);
while (1)
{
add_psymbol_to_list (part_die->name, strlen (part_die->name), 0,
VAR_DOMAIN, LOC_TYPEDEF,
&objfile->static_psymbols,
- 0, (CORE_ADDR) 0, cu->language, objfile);
+ 0, cu->language, objfile);
info_ptr = locate_pdi_sibling (reader, part_die, info_ptr);
continue;
}
else if (building_psymtab)
add_psymbol_to_list (part_die->name, strlen (part_die->name), 0,
VAR_DOMAIN, LOC_CONST,
- (cu->language == language_cplus
- || cu->language == language_java)
+ cu->language == language_cplus
? &objfile->global_psymbols
: &objfile->static_psymbols,
- 0, (CORE_ADDR) 0, cu->language, objfile);
+ 0, cu->language, objfile);
info_ptr = locate_pdi_sibling (reader, part_die, info_ptr);
continue;
*slot = part_die;
}
- part_die = obstack_alloc (&cu->comp_unit_obstack,
- sizeof (struct partial_die_info));
+ part_die = XOBNEW (&cu->comp_unit_obstack, struct partial_die_info);
/* For some DIEs we want to follow their children (if any). For C
we have no reason to follow the children of structures; for other
to describe functions' calling conventions.
However, because it's a necessary piece of information in
- Fortran, and because DW_CC_program is the only piece of debugging
- information whose definition refers to a 'main program' at all,
- several compilers have begun marking Fortran main programs with
- DW_CC_program --- even when those functions use the standard
- calling conventions.
-
- So until DWARF specifies a way to provide this information and
- compilers pick up the new representation, we'll support this
- practice. */
+ Fortran, and before DWARF 4 DW_CC_program was the only
+ piece of debugging information whose definition refers to
+ a 'main program' at all, several compilers marked Fortran
+ main programs with DW_CC_program --- even when those
+ functions use the standard calling conventions.
+
+ Although DWARF now specifies a way to provide this
+ information, we support this practice for backward
+ compatibility. */
if (DW_UNSND (&attr) == DW_CC_program
&& cu->language == language_fortran)
- set_objfile_main_name (objfile, part_die->name, language_fortran);
+ part_die->main_subprogram = 1;
break;
case DW_AT_inline:
if (DW_UNSND (&attr) == DW_INL_inlined
}
break;
+ case DW_AT_main_subprogram:
+ part_die->main_subprogram = DW_UNSND (&attr);
+ break;
+
default:
break;
}
struct partial_die_info part_die;
part_die.offset = offset;
- lookup_die = htab_find_with_hash (cu->partial_dies, &part_die,
- offset.sect_off);
+ lookup_die = ((struct partial_die_info *)
+ htab_find_with_hash (cu->partial_dies, &part_die,
+ offset.sect_off));
return lookup_die;
}
if (actual_class_name != NULL)
{
struct_pdi->name
- = obstack_copy0 (&cu->objfile->per_bfd->storage_obstack,
- actual_class_name,
- strlen (actual_class_name));
+ = ((const char *)
+ obstack_copy0 (&cu->objfile->per_bfd->storage_obstack,
+ actual_class_name,
+ strlen (actual_class_name)));
xfree (actual_class_name);
}
break;
base = demangled;
part_die->name
- = obstack_copy0 (&cu->objfile->per_bfd->storage_obstack,
- base, strlen (base));
+ = ((const char *)
+ obstack_copy0 (&cu->objfile->per_bfd->storage_obstack,
+ base, strlen (base)));
xfree (demangled);
}
}
{
ULONGEST result;
unsigned int num_read;
- int i, shift;
+ int shift;
unsigned char byte;
result = 0;
shift = 0;
num_read = 0;
- i = 0;
while (1)
{
byte = bfd_get_8 (abfd, buf);
unsigned int *bytes_read_ptr)
{
LONGEST result;
- int i, shift, num_read;
+ int shift, num_read;
unsigned char byte;
result = 0;
shift = 0;
num_read = 0;
- i = 0;
while (1)
{
byte = bfd_get_8 (abfd, buf);
case DW_LANG_UPC:
cu->language = language_c;
break;
+ case DW_LANG_Java:
case DW_LANG_C_plus_plus:
case DW_LANG_C_plus_plus_11:
case DW_LANG_C_plus_plus_14:
case DW_LANG_Mips_Assembler:
cu->language = language_asm;
break;
- case DW_LANG_Java:
- cu->language = language_java;
- break;
case DW_LANG_Ada83:
case DW_LANG_Ada95:
cu->language = language_ada;
case DW_LANG_ObjC:
cu->language = language_objc;
break;
+ case DW_LANG_Rust:
+ case DW_LANG_Rust_old:
+ cu->language = language_rust;
+ break;
case DW_LANG_Cobol74:
case DW_LANG_Cobol85:
default:
return NULL;
}
+/* Return the string associated with a string-typed attribute, or NULL if it
+ is either not found or is of an incorrect type. */
+
+static const char *
+dwarf2_string_attr (struct die_info *die, unsigned int name, struct dwarf2_cu *cu)
+{
+ struct attribute *attr;
+ const char *str = NULL;
+
+ attr = dwarf2_attr (die, name, cu);
+
+ if (attr != NULL)
+ {
+ if (attr->form == DW_FORM_strp || attr->form == DW_FORM_string
+ || attr->form == DW_FORM_GNU_strp_alt)
+ str = DW_STRING (attr);
+ else
+ complaint (&symfile_complaints,
+ _("string type expected for attribute %s for "
+ "DIE at 0x%x in module %s"),
+ dwarf_attr_name (name), die->offset.sect_off,
+ objfile_name (cu->objfile));
+ }
+
+ return str;
+}
+
/* Return non-zero iff the attribute NAME is defined for the given DIE,
and holds a non-zero value. This function should only be used for
DW_FORM_flag or DW_FORM_flag_present attributes. */
static void
free_line_header_voidp (void *arg)
{
- struct line_header *lh = arg;
+ struct line_header *lh = (struct line_header *) arg;
free_line_header (lh);
}
if (lh->include_dirs_size == 0)
{
lh->include_dirs_size = 1; /* for testing */
- lh->include_dirs = xmalloc (lh->include_dirs_size
- * sizeof (*lh->include_dirs));
+ lh->include_dirs = XNEWVEC (const char *, lh->include_dirs_size);
}
else if (lh->num_include_dirs >= lh->include_dirs_size)
{
lh->include_dirs_size *= 2;
- lh->include_dirs = xrealloc (lh->include_dirs,
- (lh->include_dirs_size
- * sizeof (*lh->include_dirs)));
+ lh->include_dirs = XRESIZEVEC (const char *, lh->include_dirs,
+ lh->include_dirs_size);
}
lh->include_dirs[lh->num_include_dirs++] = include_dir;
if (lh->file_names_size == 0)
{
lh->file_names_size = 1; /* for testing */
- lh->file_names = xmalloc (lh->file_names_size
- * sizeof (*lh->file_names));
+ lh->file_names = XNEWVEC (struct file_entry, lh->file_names_size);
}
else if (lh->num_file_names >= lh->file_names_size)
{
lh->file_names_size *= 2;
- lh->file_names = xrealloc (lh->file_names,
- (lh->file_names_size
- * sizeof (*lh->file_names)));
+ lh->file_names
+ = XRESIZEVEC (struct file_entry, lh->file_names, lh->file_names_size);
}
fe = &lh->file_names[lh->num_file_names++];
return 0;
}
- lh = xmalloc (sizeof (*lh));
+ lh = XNEW (struct line_header);
memset (lh, 0, sizeof (*lh));
back_to = make_cleanup ((make_cleanup_ftype *) free_line_header,
(void *) lh);
line_ptr += 1;
lh->opcode_base = read_1_byte (abfd, line_ptr);
line_ptr += 1;
- lh->standard_opcode_lengths
- = xmalloc (lh->opcode_base * sizeof (lh->standard_opcode_lengths[0]));
+ lh->standard_opcode_lengths = XNEWVEC (unsigned char, lh->opcode_base);
lh->standard_opcode_lengths[0] = 1; /* This should never be used anyway. */
for (i = 1; i < lh->opcode_base; ++i)
if (cu->language == language_fortran && die->parent
&& die->parent->tag == DW_TAG_module
&& cu->producer
- && startswith (cu->producer, "GNU Fortran "))
+ && startswith (cu->producer, "GNU Fortran"))
SYMBOL_ACLASS_INDEX (sym) = LOC_UNRESOLVED;
/* A variable with DW_AT_external is never static,
SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
{
- /* NOTE: carlton/2003-11-10: C++ and Java class symbols shouldn't
+ /* NOTE: carlton/2003-11-10: C++ class symbols shouldn't
really ever be static objects: otherwise, if you try
to, say, break of a class's method and you're in a file
which doesn't mention that class, it won't work unless
if (!suppress_add)
{
list_to_add = (cu->list_in_scope == &file_symbols
- && (cu->language == language_cplus
- || cu->language == language_java)
+ && cu->language == language_cplus
? &global_symbols : cu->list_in_scope);
/* The semantics of C++ state that "struct foo {
- ... }" also defines a typedef for "foo". A Java
- class declaration also defines a typedef for the
- class. */
+ ... }" also defines a typedef for "foo". */
if (cu->language == language_cplus
- || cu->language == language_java
|| cu->language == language_ada
- || cu->language == language_d)
+ || cu->language == language_d
+ || cu->language == language_rust)
{
/* The symbol's name is already allocated along
with this objfile, so we don't need to
DW_TAG_class_type, etc. block. */
list_to_add = (cu->list_in_scope == &file_symbols
- && (cu->language == language_cplus
- || cu->language == language_java)
+ && cu->language == language_cplus
? &global_symbols : cu->list_in_scope);
}
break;
*value = l;
else
{
- gdb_byte *bytes = obstack_alloc (obstack, bits / 8);
+ gdb_byte *bytes = (gdb_byte *) obstack_alloc (obstack, bits / 8);
store_unsigned_integer (bytes, bits / 8, byte_order, l);
return bytes;
}
/* Symbols of this form are reasonably rare, so we just
piggyback on the existing location code rather than writing
a new implementation of symbol_computed_ops. */
- *baton = obstack_alloc (obstack, sizeof (struct dwarf2_locexpr_baton));
+ *baton = XOBNEW (obstack, struct dwarf2_locexpr_baton);
(*baton)->per_cu = cu->per_cu;
gdb_assert ((*baton)->per_cu);
(*baton)->size = 2 + cu_header->addr_size;
- data = obstack_alloc (obstack, (*baton)->size);
+ data = (gdb_byte *) obstack_alloc (obstack, (*baton)->size);
(*baton)->data = data;
data[0] = DW_OP_addr;
struct dwarf2_cu *cu)
{
struct objfile *objfile = cu->objfile;
- struct comp_unit_head *cu_header = &cu->header;
LONGEST value;
const gdb_byte *bytes;
struct dwarf2_locexpr_baton *baton;
objfile_name (objfile),
cu->header.offset.sect_off,
die->offset.sect_off);
- saved = obstack_copy0 (&objfile->objfile_obstack,
- message, strlen (message));
+ saved = (char *) obstack_copy0 (&objfile->objfile_obstack,
+ message, strlen (message));
xfree (message);
- return init_type (TYPE_CODE_ERROR, 0, 0, saved, objfile);
+ return init_type (objfile, TYPE_CODE_ERROR, 0, saved);
}
/* Look up the type of DIE in CU using its type attribute ATTR.
{
if (child->tag == DW_TAG_subprogram)
{
- struct attribute *attr;
+ const char *linkage_name;
- attr = dwarf2_attr (child, DW_AT_linkage_name, cu);
- if (attr == NULL)
- attr = dwarf2_attr (child, DW_AT_MIPS_linkage_name, cu);
- if (attr != NULL)
+ linkage_name = dwarf2_string_attr (child, DW_AT_linkage_name, cu);
+ if (linkage_name == NULL)
+ linkage_name = dwarf2_string_attr (child, DW_AT_MIPS_linkage_name,
+ cu);
+ if (linkage_name != NULL)
{
char *actual_name
= language_class_name_from_physname (cu->language_defn,
- DW_STRING (attr));
+ linkage_name);
char *name = NULL;
if (actual_name != NULL)
if (actual_name_len > die_name_len + 2
&& actual_name[actual_name_len
- die_name_len - 1] == ':')
- name =
- obstack_copy0 (&cu->objfile->per_bfd->storage_obstack,
- actual_name,
- actual_name_len - die_name_len - 2);
+ name = (char *) obstack_copy0 (
+ &cu->objfile->per_bfd->storage_obstack,
+ actual_name, actual_name_len - die_name_len - 2);
}
}
xfree (actual_name);
anonymous_struct_prefix (struct die_info *die, struct dwarf2_cu *cu)
{
struct attribute *attr;
- char *base;
+ const char *base;
if (die->tag != DW_TAG_class_type && die->tag != DW_TAG_interface_type
&& die->tag != DW_TAG_structure_type && die->tag != DW_TAG_union_type)
return NULL;
- attr = dwarf2_attr (die, DW_AT_name, cu);
- if (attr != NULL && DW_STRING (attr) != NULL)
+ if (dwarf2_string_attr (die, DW_AT_name, cu) != NULL)
return NULL;
attr = dwarf2_attr (die, DW_AT_linkage_name, cu);
if (base == NULL || base == DW_STRING (attr) || base[-1] != ':')
return "";
- return obstack_copy0 (&cu->objfile->per_bfd->storage_obstack,
- DW_STRING (attr), &base[-1] - DW_STRING (attr));
+ return (char *) obstack_copy0 (&cu->objfile->per_bfd->storage_obstack,
+ DW_STRING (attr),
+ &base[-1] - DW_STRING (attr));
}
/* Return the name of the namespace/class that DIE is defined within,
struct type *parent_type;
char *retval;
- if (cu->language != language_cplus && cu->language != language_java
- && cu->language != language_fortran && cu->language != language_d)
+ if (cu->language != language_cplus
+ && cu->language != language_fortran && cu->language != language_d
+ && cu->language != language_rust)
return "";
retval = anonymous_struct_prefix (die, cu);
if (suffix == NULL || suffix[0] == '\0'
|| prefix == NULL || prefix[0] == '\0')
sep = "";
- else if (cu->language == language_java)
- sep = ".";
else if (cu->language == language_d)
{
/* For D, the 'main' function could be defined in any module, but it
if (obs == NULL)
{
char *retval
- = xmalloc (strlen (prefix) + MAX_SEP_LEN + strlen (suffix) + 1);
+ = ((char *)
+ xmalloc (strlen (prefix) + MAX_SEP_LEN + strlen (suffix) + 1));
strcpy (retval, lead);
strcat (retval, prefix);
{
if (name && cu->language == language_cplus)
{
- char *canon_name = cp_canonicalize_string (name);
+ std::string canon_name = cp_canonicalize_string (name);
- if (canon_name != NULL)
+ if (!canon_name.empty ())
{
- if (strcmp (canon_name, name) != 0)
- name = obstack_copy0 (obstack, canon_name, strlen (canon_name));
- xfree (canon_name);
+ if (canon_name != name)
+ name = (const char *) obstack_copy0 (obstack,
+ canon_name.c_str (),
+ canon_name.length ());
}
}
return DW_STRING (attr);
return CP_ANONYMOUS_NAMESPACE_STR;
- case DW_TAG_subprogram:
- /* Java constructors will all be named "<init>", so return
- the class name when we see this special case. */
- if (cu->language == language_java
- && DW_STRING (attr) != NULL
- && strcmp (DW_STRING (attr), "<init>") == 0)
- {
- struct dwarf2_cu *spec_cu = cu;
- struct die_info *spec_die;
-
- /* GCJ will output '<init>' for Java constructor names.
- For this special case, return the name of the parent class. */
-
- /* GCJ may output subprogram DIEs with AT_specification set.
- If so, use the name of the specified DIE. */
- spec_die = die_specification (die, &spec_cu);
- if (spec_die != NULL)
- return dwarf2_name (spec_die, spec_cu);
-
- do
- {
- die = die->parent;
- if (die->tag == DW_TAG_class_type)
- return dwarf2_name (die, cu);
- }
- while (die->tag != DW_TAG_compile_unit
- && die->tag != DW_TAG_partial_unit);
- }
- break;
-
case DW_TAG_class_type:
case DW_TAG_interface_type:
case DW_TAG_structure_type:
if (demangled)
{
- char *base;
+ const char *base;
/* FIXME: we already did this for the partial symbol... */
DW_STRING (attr)
- = obstack_copy0 (&cu->objfile->per_bfd->storage_obstack,
- demangled, strlen (demangled));
+ = ((const char *)
+ obstack_copy0 (&cu->objfile->per_bfd->storage_obstack,
+ demangled, strlen (demangled)));
DW_STRING_IS_CANONICAL (attr) = 1;
xfree (demangled);
*ref_cu = target_cu;
temp_die.offset = offset;
- return htab_find_with_hash (target_cu->die_hash, &temp_die, offset.sect_off);
+ return (struct die_info *) htab_find_with_hash (target_cu->die_hash,
+ &temp_die, offset.sect_off);
}
/* Follow reference attribute ATTR of SRC_DIE.
gdb_byte *result;
*len = TYPE_LENGTH (type);
- result = obstack_alloc (obstack, *len);
+ result = (gdb_byte *) obstack_alloc (obstack, *len);
store_unsigned_integer (result, *len, byte_order, value);
return result;
gdb_byte *tem;
*len = cu->header.addr_size;
- tem = obstack_alloc (obstack, *len);
+ tem = (gdb_byte *) obstack_alloc (obstack, *len);
store_unsigned_integer (tem, *len, byte_order, DW_ADDR (attr));
result = tem;
}
follow_die_sig_1 (struct die_info *src_die, struct signatured_type *sig_type,
struct dwarf2_cu **ref_cu)
{
- struct objfile *objfile = (*ref_cu)->objfile;
struct die_info temp_die;
struct dwarf2_cu *sig_cu;
struct die_info *die;
gdb_assert (sig_cu != NULL);
gdb_assert (sig_type->type_offset_in_section.sect_off != 0);
temp_die.offset = sig_type->type_offset_in_section;
- die = htab_find_with_hash (sig_cu->die_hash, &temp_die,
- temp_die.offset.sect_off);
+ die = (struct die_info *) htab_find_with_hash (sig_cu->die_hash, &temp_die,
+ temp_die.offset.sect_off);
if (die)
{
/* For .gdb_index version 7 keep track of included TUs.
break;
case DW_OP_GNU_push_tls_address:
+ case DW_OP_form_tls_address:
/* The top of the stack has the offset from the beginning
of the thread control block at which the variable is located. */
/* Nothing should follow this operator, so the top of stack would
static struct dwarf_block *
dwarf_alloc_block (struct dwarf2_cu *cu)
{
- struct dwarf_block *blk;
-
- blk = (struct dwarf_block *)
- obstack_alloc (&cu->comp_unit_obstack, sizeof (struct dwarf_block));
- return (blk);
+ return XOBNEW (&cu->comp_unit_obstack, struct dwarf_block);
}
static struct die_info *
|| lh->include_dirs == NULL)
return xstrdup (fe->name);
return concat (lh->include_dirs[fe->dir_index - 1], SLASH_STRING,
- fe->name, NULL);
+ fe->name, (char *) NULL);
}
else
{
if (IS_ABSOLUTE_PATH (relative) || comp_dir == NULL)
return relative;
- return reconcat (relative, comp_dir, SLASH_STRING, relative, NULL);
+ return reconcat (relative, comp_dir, SLASH_STRING,
+ relative, (char *) NULL);
}
else
return file_file_name (file, lh);
static char *
copy_string (const char *buf, int len)
{
- char *s = xmalloc (len + 1);
+ char *s = (char *) xmalloc (len + 1);
memcpy (s, buf, len);
s[len] = '\0';
char *name = copy_string (body, p - body);
int argc = 0;
int argv_size = 1;
- char **argv = xmalloc (argv_size * sizeof (*argv));
+ char **argv = XNEWVEC (char *, argv_size);
p++;
if (argc >= argv_size)
{
argv_size *= 2;
- argv = xrealloc (argv, argv_size * sizeof (*argv));
+ argv = XRESIZEVEC (char *, argv, argv_size);
}
argv[argc++] = copy_string (arg_start, p - arg_start);
void **slot;
bfd *include_bfd = abfd;
struct dwarf2_section_info *include_section = section;
- struct dwarf2_section_info alt_section;
const gdb_byte *include_mac_end = mac_end;
int is_dwz = section_is_dwz;
const gdb_byte *new_mac_ptr;
if (!section_is_gnu)
{
unsigned int bytes_read;
- int constant;
- constant = read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
+ /* This reads the constant, but since we don't recognize
+ any vendor extensions, we ignore it. */
+ read_unsigned_leb128 (abfd, mac_ptr, &bytes_read);
mac_ptr += bytes_read;
read_direct_string (abfd, mac_ptr, &bytes_read);
mac_ptr += bytes_read;
{
struct dwarf2_loclist_baton *baton;
- baton = obstack_alloc (&objfile->objfile_obstack,
- sizeof (struct dwarf2_loclist_baton));
+ baton = XOBNEW (&objfile->objfile_obstack, struct dwarf2_loclist_baton);
fill_in_loclist_baton (cu, baton, attr);
{
struct dwarf2_locexpr_baton *baton;
- baton = obstack_alloc (&objfile->objfile_obstack,
- sizeof (struct dwarf2_locexpr_baton));
+ baton = XOBNEW (&objfile->objfile_obstack, struct dwarf2_locexpr_baton);
baton->per_cu = cu->per_cu;
gdb_assert (baton->per_cu);
cu->language_defn = language_def (cu->language);
}
- attr = dwarf2_attr (comp_unit_die, DW_AT_producer, cu);
- if (attr)
- cu->producer = DW_STRING (attr);
+ cu->producer = dwarf2_string_attr (comp_unit_die, DW_AT_producer, cu);
}
/* Release one cached compilation unit, CU. We unlink it from the tree
static void
free_heap_comp_unit (void *data)
{
- struct dwarf2_cu *cu = data;
+ struct dwarf2_cu *cu = (struct dwarf2_cu *) data;
gdb_assert (cu->per_cu != NULL);
cu->per_cu->cu = NULL;
static void
free_stack_comp_unit (void *data)
{
- struct dwarf2_cu *cu = data;
+ struct dwarf2_cu *cu = (struct dwarf2_cu *) data;
gdb_assert (cu->per_cu != NULL);
cu->per_cu->cu = NULL;
void
dwarf2_free_objfile (struct objfile *objfile)
{
- dwarf2_per_objfile = objfile_data (objfile, dwarf2_objfile_data_key);
+ dwarf2_per_objfile
+ = (struct dwarf2_per_objfile *) objfile_data (objfile,
+ dwarf2_objfile_data_key);
if (dwarf2_per_objfile == NULL)
return;
static hashval_t
per_cu_offset_and_type_hash (const void *item)
{
- const struct dwarf2_per_cu_offset_and_type *ofs = item;
+ const struct dwarf2_per_cu_offset_and_type *ofs
+ = (const struct dwarf2_per_cu_offset_and_type *) item;
return (uintptr_t) ofs->per_cu + ofs->offset.sect_off;
}
static int
per_cu_offset_and_type_eq (const void *item_lhs, const void *item_rhs)
{
- const struct dwarf2_per_cu_offset_and_type *ofs_lhs = item_lhs;
- const struct dwarf2_per_cu_offset_and_type *ofs_rhs = item_rhs;
+ const struct dwarf2_per_cu_offset_and_type *ofs_lhs
+ = (const struct dwarf2_per_cu_offset_and_type *) item_lhs;
+ const struct dwarf2_per_cu_offset_and_type *ofs_rhs
+ = (const struct dwarf2_per_cu_offset_and_type *) item_rhs;
return (ofs_lhs->per_cu == ofs_rhs->per_cu
&& ofs_lhs->offset.sect_off == ofs_rhs->offset.sect_off);
&& !HAVE_GNAT_AUX_INFO (type))
INIT_GNAT_SPECIFIC (type);
+ /* Read DW_AT_allocated and set in type. */
+ attr = dwarf2_attr (die, DW_AT_allocated, cu);
+ if (attr_form_is_block (attr))
+ {
+ if (attr_to_dynamic_prop (attr, die, cu, &prop))
+ add_dyn_prop (DYN_PROP_ALLOCATED, prop, type, objfile);
+ }
+ else if (attr != NULL)
+ {
+ complaint (&symfile_complaints,
+ _("DW_AT_allocated has the wrong form (%s) at DIE 0x%x"),
+ (attr != NULL ? dwarf_form_name (attr->form) : "n/a"),
+ die->offset.sect_off);
+ }
+
+ /* Read DW_AT_associated and set in type. */
+ attr = dwarf2_attr (die, DW_AT_associated, cu);
+ if (attr_form_is_block (attr))
+ {
+ if (attr_to_dynamic_prop (attr, die, cu, &prop))
+ add_dyn_prop (DYN_PROP_ASSOCIATED, prop, type, objfile);
+ }
+ else if (attr != NULL)
+ {
+ complaint (&symfile_complaints,
+ _("DW_AT_associated has the wrong form (%s) at DIE 0x%x"),
+ (attr != NULL ? dwarf_form_name (attr->form) : "n/a"),
+ die->offset.sect_off);
+ }
+
/* Read DW_AT_data_location and set in type. */
attr = dwarf2_attr (die, DW_AT_data_location, cu);
if (attr_to_dynamic_prop (attr, die, cu, &prop))
complaint (&symfile_complaints,
_("A problem internal to GDB: DIE 0x%x has type already set"),
die->offset.sect_off);
- *slot = obstack_alloc (&objfile->objfile_obstack, sizeof (**slot));
+ *slot = XOBNEW (&objfile->objfile_obstack,
+ struct dwarf2_per_cu_offset_and_type);
**slot = ofs;
return type;
}
ofs.per_cu = per_cu;
ofs.offset = offset;
- slot = htab_find (dwarf2_per_objfile->die_type_hash, &ofs);
+ slot = ((struct dwarf2_per_cu_offset_and_type *)
+ htab_find (dwarf2_per_objfile->die_type_hash, &ofs));
if (slot)
return slot->type;
else
static hashval_t
partial_die_hash (const void *item)
{
- const struct partial_die_info *part_die = item;
+ const struct partial_die_info *part_die
+ = (const struct partial_die_info *) item;
return part_die->offset.sect_off;
}
static int
partial_die_eq (const void *item_lhs, const void *item_rhs)
{
- const struct partial_die_info *part_die_lhs = item_lhs;
- const struct partial_die_info *part_die_rhs = item_rhs;
+ const struct partial_die_info *part_die_lhs
+ = (const struct partial_die_info *) item_lhs;
+ const struct partial_die_info *part_die_rhs
+ = (const struct partial_die_info *) item_rhs;
return part_die_lhs->offset.sect_off == part_die_rhs->offset.sect_off;
}
static void
dwarf2_per_objfile_free (struct objfile *objfile, void *d)
{
- struct dwarf2_per_objfile *data = d;
+ struct dwarf2_per_objfile *data = (struct dwarf2_per_objfile *) d;
int ix;
/* Make sure we don't accidentally use dwarf2_per_objfile while
static hashval_t
hash_strtab_entry (const void *e)
{
- const struct strtab_entry *entry = e;
+ const struct strtab_entry *entry = (const struct strtab_entry *) e;
return mapped_index_string_hash (INT_MAX, entry->str);
}
static int
eq_strtab_entry (const void *a, const void *b)
{
- const struct strtab_entry *ea = a;
- const struct strtab_entry *eb = b;
+ const struct strtab_entry *ea = (const struct strtab_entry *) a;
+ const struct strtab_entry *eb = (const struct strtab_entry *) b;
return !strcmp (ea->str, eb->str);
}
entry.str = str;
slot = htab_find_slot (table, &entry, INSERT);
if (*slot)
- result = *slot;
+ result = (struct strtab_entry *) *slot;
else
{
result = XNEW (struct strtab_entry);
static hashval_t
hash_symtab_entry (const void *e)
{
- const struct symtab_index_entry *entry = e;
+ const struct symtab_index_entry *entry
+ = (const struct symtab_index_entry *) e;
return iterative_hash (VEC_address (offset_type, entry->cu_indices),
sizeof (offset_type) * VEC_length (offset_type,
entry->cu_indices),
static int
eq_symtab_entry (const void *a, const void *b)
{
- const struct symtab_index_entry *ea = a;
- const struct symtab_index_entry *eb = b;
+ const struct symtab_index_entry *ea = (const struct symtab_index_entry *) a;
+ const struct symtab_index_entry *eb = (const struct symtab_index_entry *) b;
int len = VEC_length (offset_type, ea->cu_indices);
if (len != VEC_length (offset_type, eb->cu_indices))
return 0;
static void
delete_symtab_entry (void *p)
{
- struct symtab_index_entry *entry = p;
+ struct symtab_index_entry *entry = (struct symtab_index_entry *) p;
VEC_free (offset_type, entry->cu_indices);
xfree (entry);
}
static void
cleanup_mapped_symtab (void *p)
{
- struct mapped_symtab *symtab = p;
+ struct mapped_symtab *symtab = (struct mapped_symtab *) p;
/* The contents of the array are freed when the other hash table is
destroyed. */
xfree (symtab->data);
}
else
{
- struct symtab_index_entry *old_entry = *slot;
+ struct symtab_index_entry *old_entry
+ = (struct symtab_index_entry *) *slot;
entry->index_offset = old_entry->index_offset;
entry = old_entry;
}
static hashval_t
hash_psymtab_cu_index (const void *item)
{
- const struct psymtab_cu_index_map *map = item;
+ const struct psymtab_cu_index_map *map
+ = (const struct psymtab_cu_index_map *) item;
return htab_hash_pointer (map->psymtab);
}
static int
eq_psymtab_cu_index (const void *item_lhs, const void *item_rhs)
{
- const struct psymtab_cu_index_map *lhs = item_lhs;
- const struct psymtab_cu_index_map *rhs = item_rhs;
+ const struct psymtab_cu_index_map *lhs
+ = (const struct psymtab_cu_index_map *) item_lhs;
+ const struct psymtab_cu_index_map *rhs
+ = (const struct psymtab_cu_index_map *) item_rhs;
return lhs->psymtab == rhs->psymtab;
}
static int
add_address_entry_worker (void *datap, CORE_ADDR start_addr, void *obj)
{
- struct addrmap_index_data *data = datap;
- struct partial_symtab *pst = obj;
+ struct addrmap_index_data *data = (struct addrmap_index_data *) datap;
+ struct partial_symtab *pst = (struct partial_symtab *) obj;
if (data->previous_valid)
add_address_entry (data->objfile, data->addr_obstack,
{
struct psymtab_cu_index_map find_map, *map;
find_map.psymtab = pst;
- map = htab_find (data->cu_index_htab, &find_map);
+ map = ((struct psymtab_cu_index_map *)
+ htab_find (data->cu_index_htab, &find_map));
gdb_assert (map != NULL);
data->previous_cu_index = map->cu_index;
data->previous_valid = 1;
static void
unlink_if_set (void *p)
{
- char **filename = p;
+ char **filename = (char **) p;
if (*filename)
unlink (*filename);
}
static int
write_one_signatured_type (void **slot, void *d)
{
- struct signatured_type_index_data *info = d;
+ struct signatured_type_index_data *info
+ = (struct signatured_type_index_data *) d;
struct signatured_type *entry = (struct signatured_type *) *slot;
struct partial_symtab *psymtab = entry->per_cu.v.psymtab;
gdb_byte val[8];
eq_psymtab_cu_index,
NULL, xcalloc, xfree);
make_cleanup_htab_delete (cu_index_htab);
- psymtab_cu_index_map = (struct psymtab_cu_index_map *)
- xmalloc (sizeof (struct psymtab_cu_index_map)
- * dwarf2_per_objfile->n_comp_units);
+ psymtab_cu_index_map = XNEWVEC (struct psymtab_cu_index_map,
+ dwarf2_per_objfile->n_comp_units);
make_cleanup (xfree, psymtab_cu_index_map);
/* The CU list is already sorted, so we don't need to do additional
if (stat (objfile_name (objfile), &st) < 0)
continue;
- dwarf2_per_objfile = objfile_data (objfile, dwarf2_objfile_data_key);
+ dwarf2_per_objfile
+ = (struct dwarf2_per_objfile *) objfile_data (objfile,
+ dwarf2_objfile_data_key);
if (dwarf2_per_objfile)
{
projects / deliverable / binutils-gdb.git / blobdiff