{
public:
- cutu_reader (struct dwarf2_per_cu_data *this_cu,
+ cutu_reader (dwarf2_per_cu_data *this_cu,
+ dwarf2_per_objfile *per_objfile,
struct abbrev_table *abbrev_table,
int use_existing_cu,
bool skip_partial);
explicit cutu_reader (struct dwarf2_per_cu_data *this_cu,
+ dwarf2_per_objfile *per_objfile,
struct dwarf2_cu *parent_cu = nullptr,
struct dwo_file *dwo_file = nullptr);
struct dwarf2_cu *cu);
static dwarf2_psymtab *create_partial_symtab
- (struct dwarf2_per_cu_data *per_cu, const char *name);
+ (dwarf2_per_cu_data *per_cu, dwarf2_per_objfile *per_objfile,
+ const char *name);
static void build_type_psymtabs_reader (const struct die_reader_specs *reader,
const gdb_byte *info_ptr,
const struct attribute *,
struct dwarf2_cu *);
-static void load_full_type_unit (struct dwarf2_per_cu_data *per_cu);
+static void load_full_type_unit (dwarf2_per_cu_data *per_cu,
+ dwarf2_per_objfile *per_objfile);
-static void read_signatured_type (struct signatured_type *);
+static void read_signatured_type (signatured_type *sig_type,
+ dwarf2_per_objfile *per_objfile);
static int attr_to_dynamic_prop (const struct attribute *attr,
struct die_info *die, struct dwarf2_cu *cu,
static int create_all_type_units (struct dwarf2_per_objfile *dwarf2_per_objfile);
-static void load_full_comp_unit (struct dwarf2_per_cu_data *, bool,
- enum language);
+static void load_full_comp_unit (dwarf2_per_cu_data *per_cu,
+ dwarf2_per_objfile *per_objfile,
+ bool skip_partial,
+ enum language pretend_language);
static void process_full_comp_unit (struct dwarf2_per_cu_data *,
enum language);
dwarf2_per_bfd::dwarf2_per_bfd (bfd *obfd, const dwarf2_debug_sections *names,
bool can_copy_)
- : can_copy (can_copy_)
+ : obfd (obfd),
+ can_copy (can_copy_)
{
if (names == NULL)
names = &dwarf2_elf_names;
/* See dwarf2read.h. */
struct dwz_file *
-dwarf2_get_dwz_file (struct dwarf2_per_objfile *dwarf2_per_objfile)
+dwarf2_get_dwz_file (dwarf2_per_bfd *per_bfd)
{
const char *filename;
bfd_size_type buildid_len_arg;
size_t buildid_len;
bfd_byte *buildid;
- if (dwarf2_per_objfile->per_bfd->dwz_file != NULL)
- return dwarf2_per_objfile->per_bfd->dwz_file.get ();
+ if (per_bfd->dwz_file != NULL)
+ return per_bfd->dwz_file.get ();
bfd_set_error (bfd_error_no_error);
gdb::unique_xmalloc_ptr<char> data
- (bfd_get_alt_debug_link_info (dwarf2_per_objfile->objfile->obfd,
+ (bfd_get_alt_debug_link_info (per_bfd->obfd,
&buildid_len_arg, &buildid));
if (data == NULL)
{
if (!IS_ABSOLUTE_PATH (filename))
{
gdb::unique_xmalloc_ptr<char> abs
- = gdb_realpath (objfile_name (dwarf2_per_objfile->objfile));
+ = gdb_realpath (bfd_get_filename (per_bfd->obfd));
abs_storage = ldirname (abs.get ()) + SLASH_STRING + filename;
filename = abs_storage.c_str ();
if (dwz_bfd == nullptr)
{
gdb::unique_xmalloc_ptr<char> alt_filename;
- const char *origname = dwarf2_per_objfile->objfile->original_name;
+ const char *origname = bfd_get_filename (per_bfd->obfd);
scoped_fd fd (debuginfod_debuginfo_query (buildid,
buildid_len,
if (dwz_bfd == NULL)
error (_("could not find '.gnu_debugaltlink' file for %s"),
- objfile_name (dwarf2_per_objfile->objfile));
+ bfd_get_filename (per_bfd->obfd));
std::unique_ptr<struct dwz_file> result
(new struct dwz_file (std::move (dwz_bfd)));
bfd_map_over_sections (result->dwz_bfd.get (), locate_dwz_sections,
result.get ());
- gdb_bfd_record_inclusion (dwarf2_per_objfile->objfile->obfd,
- result->dwz_bfd.get ());
- dwarf2_per_objfile->per_bfd->dwz_file = std::move (result);
- return dwarf2_per_objfile->per_bfd->dwz_file.get ();
+ gdb_bfd_record_inclusion (per_bfd->obfd, result->dwz_bfd.get ());
+ per_bfd->dwz_file = std::move (result);
+ return per_bfd->dwz_file.get ();
}
\f
/* DWARF quick_symbols_functions support. */
delete_file_name_entry, xcalloc, xfree));
}
-/* Read in PER_CU->CU. This function is unrelated to symtabs, symtab would
- have to be created afterwards. You should call age_cached_comp_units after
- processing PER_CU->CU. dw2_setup must have been already called. */
+/* Read in CU (dwarf2_cu object) for PER_CU in the context of PER_OBJFILE. This
+ function is unrelated to symtabs, symtab would have to be created afterwards.
+ You should call age_cached_comp_units after processing the CU. */
static void
-load_cu (struct dwarf2_per_cu_data *per_cu, bool skip_partial)
+load_cu (dwarf2_per_cu_data *per_cu, dwarf2_per_objfile *per_objfile,
+ bool skip_partial)
{
if (per_cu->is_debug_types)
- load_full_type_unit (per_cu);
+ load_full_type_unit (per_cu, per_objfile);
else
- load_full_comp_unit (per_cu, skip_partial, language_minimal);
+ load_full_comp_unit (per_cu, per_objfile, skip_partial, language_minimal);
if (per_cu->cu == NULL)
return; /* Dummy CU. */
if (!dwarf2_per_objfile->symtab_set_p (per_cu))
{
queue_comp_unit (per_cu, language_minimal);
- load_cu (per_cu, skip_partial);
+ load_cu (per_cu, dwarf2_per_objfile, skip_partial);
/* If we just loaded a CU from a DWO, and we're working with an index
that may badly handle TUs, load all the TUs in that DWO as well.
dwarf2_per_bfd::allocate_per_cu ()
{
dwarf2_per_cu_data *result = OBSTACK_ZALLOC (&obstack, dwarf2_per_cu_data);
+ result->per_bfd = this;
result->index = m_num_psymtabs++;
return result;
}
dwarf2_per_bfd::allocate_signatured_type ()
{
signatured_type *result = OBSTACK_ZALLOC (&obstack, signatured_type);
+ result->per_cu.per_bfd = this;
result->per_cu.index = m_num_psymtabs++;
return result;
}
if (dwz_elements == 0)
return;
- dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
+ dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile->per_bfd);
create_cus_from_index_list (dwarf2_per_objfile, dwz_list, dwz_elements,
&dwz->info, 1);
}
/* If there is a .dwz file, read it so we can get its CU list as
well. */
- dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
+ dwz = dwarf2_get_dwz_file (dwarf2_per_objfile->per_bfd);
if (dwz != NULL)
{
struct mapped_index dwz_map;
{
struct dwarf2_cu *cu = reader->cu;
struct dwarf2_per_cu_data *this_cu = cu->per_cu;
- struct dwarf2_per_objfile *dwarf2_per_objfile
- = cu->per_cu->dwarf2_per_objfile;
+ struct dwarf2_per_objfile *dwarf2_per_objfile = cu->per_objfile;
struct dwarf2_per_cu_data *lh_cu;
struct attribute *attr;
void **slot;
table for THIS_CU. */
static struct quick_file_names *
-dw2_get_file_names (struct dwarf2_per_cu_data *this_cu)
+dw2_get_file_names (dwarf2_per_cu_data *this_cu,
+ dwarf2_per_objfile *per_objfile)
{
/* This should never be called for TUs. */
gdb_assert (! this_cu->is_debug_types);
if (this_cu->v.quick->no_file_data)
return NULL;
- cutu_reader reader (this_cu);
+ cutu_reader reader (this_cu, per_objfile);
if (!reader.dummy_p)
dw2_get_file_names_reader (&reader, reader.info_ptr, reader.comp_unit_die);
if (dwarf2_per_objfile->symtab_set_p (per_cu))
continue;
- quick_file_names *file_data = dw2_get_file_names (per_cu);
+ quick_file_names *file_data
+ = dw2_get_file_names (per_cu, dwarf2_per_objfile);
if (file_data == NULL)
continue;
if (dwarf2_per_objfile->symtab_set_p (per_cu))
continue;
- quick_file_names *file_data = dw2_get_file_names (per_cu);
+ quick_file_names *file_data
+ = dw2_get_file_names (per_cu, dwarf2_per_objfile);
if (file_data == NULL)
continue;
if (dwarf2_per_objfile->symtab_set_p (per_cu))
continue;
- quick_file_names *file_data = dw2_get_file_names (per_cu);
+ quick_file_names *file_data
+ = dw2_get_file_names (per_cu, dwarf2_per_objfile);
if (file_data == NULL)
continue;
if (dwarf2_per_objfile->symtab_set_p (per_cu))
continue;
- quick_file_names *file_data = dw2_get_file_names (per_cu);
+ quick_file_names *file_data
+ = dw2_get_file_names (per_cu, dwarf2_per_objfile);
if (file_data == NULL)
continue;
if (dwz_map.cu_count == 0)
return;
- dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
+ dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile->per_bfd);
create_cus_from_debug_names_list (dwarf2_per_objfile, dwz_map, dwz->info,
true /* is_dwz */);
}
/* If there is a .dwz file, read it so we can get its CU list as
well. */
- dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
+ dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile->per_bfd);
if (dwz != NULL)
{
if (!read_debug_names_from_section (objfile,
get_abbrev_section_for_cu (struct dwarf2_per_cu_data *this_cu)
{
struct dwarf2_section_info *abbrev;
- struct dwarf2_per_objfile *dwarf2_per_objfile = this_cu->dwarf2_per_objfile;
+ dwarf2_per_bfd *per_bfd = this_cu->per_bfd;
if (this_cu->is_dwz)
- abbrev = &dwarf2_get_dwz_file (dwarf2_per_objfile)->abbrev;
+ abbrev = &dwarf2_get_dwz_file (per_bfd)->abbrev;
else
- abbrev = &dwarf2_per_objfile->per_bfd->abbrev;
+ abbrev = &per_bfd->abbrev;
return abbrev;
}
struct signatured_type *sig_entry,
struct dwo_unit *dwo_entry)
{
+ dwarf2_per_bfd *per_bfd = dwarf2_per_objfile->per_bfd;
+
/* Make sure we're not clobbering something we don't expect to. */
gdb_assert (! sig_entry->per_cu.queued);
gdb_assert (sig_entry->per_cu.cu == NULL);
- if (dwarf2_per_objfile->per_bfd->using_index)
+ if (per_bfd->using_index)
{
gdb_assert (sig_entry->per_cu.v.quick != NULL);
gdb_assert (!dwarf2_per_objfile->symtab_set_p (&sig_entry->per_cu));
sig_entry->per_cu.length = dwo_entry->length;
sig_entry->per_cu.reading_dwo_directly = 1;
sig_entry->per_cu.dwarf2_per_objfile = dwarf2_per_objfile;
+ sig_entry->per_cu.per_bfd = per_bfd;
sig_entry->type_offset_in_tu = dwo_entry->type_offset_in_tu;
sig_entry->dwo_unit = dwo_entry;
}
static struct signatured_type *
lookup_dwo_signatured_type (struct dwarf2_cu *cu, ULONGEST sig)
{
- struct dwarf2_per_objfile *dwarf2_per_objfile
- = cu->per_cu->dwarf2_per_objfile;
+ struct dwarf2_per_objfile *dwarf2_per_objfile = cu->per_objfile;
struct dwo_file *dwo_file;
struct dwo_unit find_dwo_entry, *dwo_entry;
struct signatured_type find_sig_entry, *sig_entry;
static struct signatured_type *
lookup_dwp_signatured_type (struct dwarf2_cu *cu, ULONGEST sig)
{
- struct dwarf2_per_objfile *dwarf2_per_objfile
- = cu->per_cu->dwarf2_per_objfile;
+ struct dwarf2_per_objfile *dwarf2_per_objfile = cu->per_objfile;
struct dwp_file *dwp_file = get_dwp_file (dwarf2_per_objfile);
struct dwo_unit *dwo_entry;
struct signatured_type find_sig_entry, *sig_entry;
static struct signatured_type *
lookup_signatured_type (struct dwarf2_cu *cu, ULONGEST sig)
{
- struct dwarf2_per_objfile *dwarf2_per_objfile
- = cu->per_cu->dwarf2_per_objfile;
+ struct dwarf2_per_objfile *dwarf2_per_objfile = cu->per_objfile;
if (cu->dwo_unit
&& dwarf2_per_objfile->per_bfd->using_index)
if (!signature.has_value ())
error (_("Dwarf Error: missing dwo_id for dwo_name %s"
" [in module %s]"),
- dwo_name, objfile_name (this_cu->dwarf2_per_objfile->objfile));
+ dwo_name, bfd_get_filename (this_cu->per_bfd->obfd));
dwo_unit = lookup_dwo_comp_unit (this_cu, dwo_name, comp_dir,
*signature);
}
If USE_EXISTING_CU is non-zero, and THIS_CU->cu is non-NULL, then use it.
Otherwise, a new CU is allocated with xmalloc. */
-cutu_reader::cutu_reader (struct dwarf2_per_cu_data *this_cu,
+cutu_reader::cutu_reader (dwarf2_per_cu_data *this_cu,
+ dwarf2_per_objfile *dwarf2_per_objfile,
struct abbrev_table *abbrev_table,
int use_existing_cu,
bool skip_partial)
: die_reader_specs {},
m_this_cu (this_cu)
{
- struct dwarf2_per_objfile *dwarf2_per_objfile = this_cu->dwarf2_per_objfile;
struct objfile *objfile = dwarf2_per_objfile->objfile;
struct dwarf2_section_info *section = this_cu->section;
bfd *abfd = section->get_bfd_owner ();
gdb_assert (!dummy_p);
if (m_new_cu != NULL)
{
- struct dwarf2_per_objfile *dwarf2_per_objfile
- = m_this_cu->dwarf2_per_objfile;
+ /* We know that m_this_cu->cu is set, since we are in the process of
+ parsing the CU. */
+ gdb_assert (m_this_cu->cu != nullptr);
+ dwarf2_per_objfile *dwarf2_per_objfile = m_this_cu->cu->per_objfile;
+
/* Link this CU into read_in_chain. */
m_this_cu->cu->read_in_chain = dwarf2_per_objfile->per_bfd->read_in_chain;
dwarf2_per_objfile->per_bfd->read_in_chain = m_this_cu;
When parent_cu is passed, it is used to provide a default value for
str_offsets_base and addr_base from the parent. */
-cutu_reader::cutu_reader (struct dwarf2_per_cu_data *this_cu,
+cutu_reader::cutu_reader (dwarf2_per_cu_data *this_cu,
+ dwarf2_per_objfile *dwarf2_per_objfile,
struct dwarf2_cu *parent_cu,
struct dwo_file *dwo_file)
: die_reader_specs {},
m_this_cu (this_cu)
{
- struct dwarf2_per_objfile *dwarf2_per_objfile = this_cu->dwarf2_per_objfile;
struct objfile *objfile = dwarf2_per_objfile->objfile;
struct dwarf2_section_info *section = this_cu->section;
bfd *abfd = section->get_bfd_owner ();
static struct type_unit_group *
create_type_unit_group (struct dwarf2_cu *cu, sect_offset line_offset_struct)
{
- struct dwarf2_per_objfile *dwarf2_per_objfile
- = cu->per_cu->dwarf2_per_objfile;
+ struct dwarf2_per_objfile *dwarf2_per_objfile = cu->per_objfile;
+ dwarf2_per_bfd *per_bfd = dwarf2_per_objfile->per_bfd;
struct dwarf2_per_cu_data *per_cu;
struct type_unit_group *tu_group;
struct type_unit_group);
per_cu = &tu_group->per_cu;
per_cu->dwarf2_per_objfile = dwarf2_per_objfile;
+ per_cu->per_bfd = per_bfd;
- if (dwarf2_per_objfile->per_bfd->using_index)
+ if (per_bfd->using_index)
{
- per_cu->v.quick = OBSTACK_ZALLOC (&dwarf2_per_objfile->per_bfd->obstack,
+ per_cu->v.quick = OBSTACK_ZALLOC (&per_bfd->obstack,
struct dwarf2_per_cu_quick_data);
}
else
else
name = string_printf ("<type_units_at_0x%x>", line_offset);
- pst = create_partial_symtab (per_cu, name.c_str ());
+ pst = create_partial_symtab (per_cu, dwarf2_per_objfile, name.c_str ());
pst->anonymous = true;
}
static struct type_unit_group *
get_type_unit_group (struct dwarf2_cu *cu, const struct attribute *stmt_list)
{
- struct dwarf2_per_objfile *dwarf2_per_objfile
- = cu->per_cu->dwarf2_per_objfile;
+ struct dwarf2_per_objfile *dwarf2_per_objfile = cu->per_objfile;
struct tu_stats *tu_stats = &dwarf2_per_objfile->per_bfd->tu_stats;
struct type_unit_group *tu_group;
void **slot;
dirname, textlow, texthigh. */
static dwarf2_psymtab *
-create_partial_symtab (struct dwarf2_per_cu_data *per_cu, const char *name)
+create_partial_symtab (dwarf2_per_cu_data *per_cu,
+ dwarf2_per_objfile *per_objfile,
+ const char *name)
{
- struct objfile *objfile = per_cu->dwarf2_per_objfile->objfile;
+ struct objfile *objfile = per_objfile->objfile;
dwarf2_psymtab *pst;
pst = new dwarf2_psymtab (name, objfile, per_cu);
enum language pretend_language)
{
struct dwarf2_cu *cu = reader->cu;
- struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+ dwarf2_per_objfile *per_objfile = cu->per_objfile;
+ struct objfile *objfile = per_objfile->objfile;
struct gdbarch *gdbarch = objfile->arch ();
struct dwarf2_per_cu_data *per_cu = cu->per_cu;
CORE_ADDR baseaddr;
filename = debug_filename.get ();
}
- pst = create_partial_symtab (per_cu, filename);
+ pst = create_partial_symtab (per_cu, per_objfile, filename);
/* This must be done before calling dwarf2_build_include_psymtabs. */
pst->dirname = dwarf2_string_attr (comp_unit_die, DW_AT_comp_dir, cu);
Process compilation unit THIS_CU for a psymtab. */
static void
-process_psymtab_comp_unit (struct dwarf2_per_cu_data *this_cu,
+process_psymtab_comp_unit (dwarf2_per_cu_data *this_cu,
+ dwarf2_per_objfile *per_objfile,
bool want_partial_unit,
enum language pretend_language)
{
if (this_cu->cu != NULL)
free_one_cached_comp_unit (this_cu);
- cutu_reader reader (this_cu, NULL, 0, false);
+ cutu_reader reader (this_cu, per_objfile, NULL, 0, false);
switch (reader.comp_unit_die->tag)
{
const gdb_byte *info_ptr,
struct die_info *type_unit_die)
{
- struct dwarf2_per_objfile *dwarf2_per_objfile
- = reader->cu->per_cu->dwarf2_per_objfile;
+ struct dwarf2_per_objfile *dwarf2_per_objfile = reader->cu->per_objfile;
struct objfile *objfile = dwarf2_per_objfile->objfile;
struct dwarf2_cu *cu = reader->cu;
struct dwarf2_per_cu_data *per_cu = cu->per_cu;
tu_group->tus->push_back (sig_type);
prepare_one_comp_unit (cu, type_unit_die, language_minimal);
- pst = create_partial_symtab (per_cu, "");
+ pst = create_partial_symtab (per_cu, dwarf2_per_objfile, "");
pst->anonymous = true;
first_die = load_partial_dies (reader, info_ptr, 1);
++tu_stats->nr_uniq_abbrev_tables;
}
- cutu_reader reader (&tu.sig_type->per_cu, abbrev_table.get (),
- 0, false);
+ cutu_reader reader (&tu.sig_type->per_cu, dwarf2_per_objfile,
+ abbrev_table.get (), 0, false);
if (!reader.dummy_p)
build_type_psymtabs_reader (&reader, reader.info_ptr,
reader.comp_unit_die);
*slot = entry;
/* This does the job that build_type_psymtabs_1 would have done. */
- cutu_reader reader (&entry->per_cu, NULL, 0, false);
+ cutu_reader reader (&entry->per_cu, dwarf2_per_objfile, NULL, 0, false);
if (!reader.dummy_p)
build_type_psymtabs_reader (&reader, reader.info_ptr,
reader.comp_unit_die);
if (per_cu->v.psymtab != NULL)
/* In case a forward DW_TAG_imported_unit has read the CU already. */
continue;
- process_psymtab_comp_unit (per_cu, false, language_minimal);
+ process_psymtab_comp_unit (per_cu, dwarf2_per_objfile, false,
+ language_minimal);
}
/* This has to wait until we read the CUs, we need the list of DWOs. */
This is also used when rereading a primary CU with load_all_dies. */
static void
-load_partial_comp_unit (struct dwarf2_per_cu_data *this_cu)
+load_partial_comp_unit (dwarf2_per_cu_data *this_cu,
+ dwarf2_per_objfile *per_objfile)
{
- cutu_reader reader (this_cu, NULL, 1, false);
+ cutu_reader reader (this_cu, per_objfile, NULL, 1, false);
if (!reader.dummy_p)
{
read_comp_units_from_section (dwarf2_per_objfile, &dwarf2_per_objfile->per_bfd->info,
&dwarf2_per_objfile->per_bfd->abbrev, 0);
- dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
+ dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile->per_bfd);
if (dwz != NULL)
read_comp_units_from_section (dwarf2_per_objfile, &dwz->info, &dwz->abbrev,
1);
{
error (_("Dwarf Error: DW_TAG_imported_unit is not"
" supported in type units [in module %s]"),
- objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
+ objfile_name (cu->per_objfile->objfile));
}
per_cu = dwarf2_find_containing_comp_unit
- (pdi->d.sect_off, pdi->is_dwz,
- cu->per_cu->dwarf2_per_objfile);
+ (pdi->d.sect_off, pdi->is_dwz, cu->per_objfile);
/* Go read the partial unit, if needed. */
if (per_cu->v.psymtab == NULL)
- process_psymtab_comp_unit (per_cu, true, cu->language);
+ process_psymtab_comp_unit (per_cu, cu->per_objfile, true,
+ cu->language);
cu->per_cu->imported_symtabs_push (per_cu);
}
static void
add_partial_symbol (struct partial_die_info *pdi, struct dwarf2_cu *cu)
{
- struct dwarf2_per_objfile *dwarf2_per_objfile
- = cu->per_cu->dwarf2_per_objfile;
+ struct dwarf2_per_objfile *dwarf2_per_objfile = cu->per_objfile;
struct objfile *objfile = dwarf2_per_objfile->objfile;
struct gdbarch *gdbarch = objfile->arch ();
CORE_ADDR addr = 0;
*highpc = pdi->highpc;
if (set_addrmap)
{
- struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+ struct objfile *objfile = cu->per_objfile->objfile;
struct gdbarch *gdbarch = objfile->arch ();
CORE_ADDR baseaddr;
CORE_ADDR this_highpc;
const gdb_byte *info_ptr, unsigned int *bytes_read)
{
dwarf2_cu *cu = reader.cu;
- bfd *abfd = cu->per_cu->dwarf2_per_objfile->objfile->obfd;
+ bfd *abfd = cu->per_objfile->objfile->obfd;
unsigned int abbrev_number
= read_unsigned_leb128 (abfd, info_ptr, bytes_read);
enum language pretend_language)
{
per_cu->queued = 1;
- per_cu->dwarf2_per_objfile->per_bfd->queue.emplace (per_cu, pretend_language);
+ per_cu->per_bfd->queue.emplace (per_cu, pretend_language);
}
/* If PER_CU is not yet queued, add it to the queue.
/* We may arrive here during partial symbol reading, if we need full
DIEs to process an unusual case (e.g. template arguments). Do
not queue PER_CU, just tell our caller to load its DIEs. */
- if (per_cu->dwarf2_per_objfile->per_bfd->reading_partial_symbols)
+ if (per_cu->per_bfd->reading_partial_symbols)
{
if (per_cu->cu == NULL || per_cu->cu->dies == NULL)
return 1;
/* Load the DIEs associated with PER_CU into memory. */
static void
-load_full_comp_unit (struct dwarf2_per_cu_data *this_cu,
+load_full_comp_unit (dwarf2_per_cu_data *this_cu,
+ dwarf2_per_objfile *per_objfile,
bool skip_partial,
enum language pretend_language)
{
gdb_assert (! this_cu->is_debug_types);
- cutu_reader reader (this_cu, NULL, 1, skip_partial);
+ cutu_reader reader (this_cu, per_objfile, NULL, 1, skip_partial);
if (reader.dummy_p)
return;
package_name = std::move (this_package_name);
else
{
- struct objfile *objfile
- = cu->per_cu->dwarf2_per_objfile->objfile;
+ struct objfile *objfile = cu->per_objfile->objfile;
if (strcmp (package_name.get (), this_package_name.get ()) != 0)
complaint (_("Symtab %s has objects from two different Go packages: %s and %s"),
(symbol_symtab (sym) != NULL
if (package_name != NULL)
{
- struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+ struct objfile *objfile = cu->per_objfile->objfile;
const char *saved_package_name = objfile->intern (package_name.get ());
struct type *type = init_type (objfile, TYPE_CODE_MODULE, 0,
saved_package_name);
{
gdb_assert (cu->language == language_rust);
for (type *type_ : cu->rust_unions)
- quirk_rust_enum (type_, cu->per_cu->dwarf2_per_objfile->objfile);
+ quirk_rust_enum (type_, cu->per_objfile->objfile);
/* We don't need this any more. */
cu->rust_unions.clear ();
}
{
error (_("Dwarf Error: DW_TAG_imported_unit is not"
" supported in type units [in module %s]"),
- objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
+ objfile_name (cu->per_objfile->objfile));
}
attr = dwarf2_attr (die, DW_AT_import, cu);
{
sect_offset sect_off = attr->get_ref_die_offset ();
bool is_dwz = (attr->form == DW_FORM_GNU_ref_alt || cu->per_cu->is_dwz);
+ dwarf2_per_objfile *per_objfile = cu->per_objfile;
dwarf2_per_cu_data *per_cu
- = dwarf2_find_containing_comp_unit (sect_off, is_dwz,
- cu->per_cu->dwarf2_per_objfile);
+ = dwarf2_find_containing_comp_unit (sect_off, is_dwz, per_objfile);
/* We're importing a C++ compilation unit with tag DW_TAG_compile_unit
into another compilation unit, at root level. Regard this as a hint,
/* If necessary, add it to the queue and load its DIEs. */
if (maybe_queue_comp_unit (cu, per_cu, cu->language))
- load_full_comp_unit (per_cu, false, cu->language);
+ load_full_comp_unit (per_cu, per_objfile, false, cu->language);
cu->per_cu->imported_symtabs_push (per_cu);
}
struct die_info *die, struct dwarf2_cu *cu,
int physname)
{
- struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+ struct objfile *objfile = cu->per_objfile->objfile;
if (name == NULL)
name = dwarf2_name (die, cu);
static const char *
dwarf2_physname (const char *name, struct die_info *die, struct dwarf2_cu *cu)
{
- struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+ struct objfile *objfile = cu->per_objfile->objfile;
const char *retval, *mangled = NULL, *canon = NULL;
int need_copy = 1;
static void
read_import_statement (struct die_info *die, struct dwarf2_cu *cu)
{
- struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+ struct objfile *objfile = cu->per_objfile->objfile;
struct attribute *import_attr;
struct die_info *imported_die, *child_die;
struct dwarf2_cu *imported_cu;
handle_DW_AT_stmt_list (struct die_info *die, struct dwarf2_cu *cu,
const char *comp_dir, CORE_ADDR lowpc) /* ARI: editCase function */
{
- struct dwarf2_per_objfile *dwarf2_per_objfile
- = cu->per_cu->dwarf2_per_objfile;
+ struct dwarf2_per_objfile *dwarf2_per_objfile = cu->per_objfile;
struct attribute *attr;
struct line_header line_header_local;
hashval_t line_header_local_hash;
static void
read_file_scope (struct die_info *die, struct dwarf2_cu *cu)
{
- struct dwarf2_per_objfile *dwarf2_per_objfile
- = cu->per_cu->dwarf2_per_objfile;
+ struct dwarf2_per_objfile *dwarf2_per_objfile = cu->per_objfile;
struct objfile *objfile = dwarf2_per_objfile->objfile;
struct gdbarch *gdbarch = objfile->arch ();
CORE_ADDR lowpc = ((CORE_ADDR) -1);
dwarf2_section_info §ion, htab_up &cus_htab)
{
struct objfile *objfile = dwarf2_per_objfile->objfile;
+ dwarf2_per_bfd *per_bfd = dwarf2_per_objfile->per_bfd;
const gdb_byte *info_ptr, *end_ptr;
section.read (objfile);
memset (&per_cu, 0, sizeof (per_cu));
per_cu.dwarf2_per_objfile = dwarf2_per_objfile;
+ per_cu.per_bfd = per_bfd;
per_cu.is_debug_types = 0;
per_cu.sect_off = sect_offset (info_ptr - section.buffer);
per_cu.section = §ion;
- cutu_reader reader (&per_cu, cu, &dwo_file);
+ cutu_reader reader (&per_cu, dwarf2_per_objfile, cu, &dwo_file);
if (!reader.dummy_p)
create_dwo_cu_reader (&reader, reader.info_ptr, reader.comp_unit_die,
&dwo_file, &read_unit);
if (cus_htab == NULL)
cus_htab = allocate_dwo_unit_table ();
- dwo_unit = OBSTACK_ZALLOC (&dwarf2_per_objfile->per_bfd->obstack,
+ dwo_unit = OBSTACK_ZALLOC (&per_bfd->obstack,
struct dwo_unit);
*dwo_unit = read_unit;
slot = htab_find_slot (cus_htab.get (), dwo_unit, INSERT);
queue_and_load_dwo_tu (void **slot, void *info)
{
struct dwo_unit *dwo_unit = (struct dwo_unit *) *slot;
- struct dwarf2_per_cu_data *per_cu = (struct dwarf2_per_cu_data *) info;
+ dwarf2_cu *cu = (dwarf2_cu *) info;
ULONGEST signature = dwo_unit->signature;
- struct signatured_type *sig_type =
- lookup_dwo_signatured_type (per_cu->cu, signature);
+ signatured_type *sig_type = lookup_dwo_signatured_type (cu, signature);
if (sig_type != NULL)
{
/* We pass NULL for DEPENDENT_CU because we don't yet know if there's
a real dependency of PER_CU on SIG_TYPE. That is detected later
while processing PER_CU. */
- if (maybe_queue_comp_unit (NULL, sig_cu, per_cu->cu->language))
- load_full_type_unit (sig_cu);
- per_cu->imported_symtabs_push (sig_cu);
+ if (maybe_queue_comp_unit (NULL, sig_cu, cu->language))
+ load_full_type_unit (sig_cu, cu->per_objfile);
+ cu->per_cu->imported_symtabs_push (sig_cu);
}
return 1;
dwo_file = dwo_unit->dwo_file;
if (dwo_file->tus != NULL)
htab_traverse_noresize (dwo_file->tus.get (), queue_and_load_dwo_tu,
- per_cu);
+ per_cu->cu);
}
/* Read in various DIEs. */
static void
read_func_scope (struct die_info *die, struct dwarf2_cu *cu)
{
- struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+ struct objfile *objfile = cu->per_objfile->objfile;
struct gdbarch *gdbarch = objfile->arch ();
struct context_stack *newobj;
CORE_ADDR lowpc;
static void
read_lexical_block_scope (struct die_info *die, struct dwarf2_cu *cu)
{
- struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+ struct objfile *objfile = cu->per_objfile->objfile;
struct gdbarch *gdbarch = objfile->arch ();
CORE_ADDR lowpc, highpc;
struct die_info *child_die;
static void
read_call_site_scope (struct die_info *die, struct dwarf2_cu *cu)
{
- dwarf2_per_objfile *per_objfile = cu->per_cu->dwarf2_per_objfile;
+ dwarf2_per_objfile *per_objfile = cu->per_objfile;
struct objfile *objfile = per_objfile->objfile;
struct gdbarch *gdbarch = objfile->arch ();
CORE_ADDR pc, baseaddr;
struct die_info *target_die;
target_die = follow_die_ref (die, attr, &target_cu);
- gdb_assert (target_cu->per_cu->dwarf2_per_objfile->objfile == objfile);
+ gdb_assert (target_cu->per_objfile->objfile == objfile);
if (die_is_declaration (target_die, target_cu))
{
const char *target_physname;
if (containing_type != NULL)
{
- struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+ struct objfile *objfile = cu->per_objfile->objfile;
storage = new (&objfile->objfile_obstack) rust_vtable_symbol;
storage->concrete_type = containing_type;
struct dwarf2_cu *origin_cu = cu;
struct die_info *origin_die
= follow_die_ref (die, abstract_origin, &origin_cu);
- dwarf2_per_objfile *dpo = cu->per_cu->dwarf2_per_objfile;
- dpo->per_bfd->abstract_to_concrete[origin_die->sect_off].push_back (die->sect_off);
+ dwarf2_per_objfile *per_objfile = cu->per_objfile;
+ per_objfile->per_bfd->abstract_to_concrete
+ [origin_die->sect_off].push_back (die->sect_off);
}
}
dwarf2_rnglists_process (unsigned offset, struct dwarf2_cu *cu,
Callback &&callback)
{
- struct dwarf2_per_objfile *dwarf2_per_objfile
- = cu->per_cu->dwarf2_per_objfile;
+ struct dwarf2_per_objfile *dwarf2_per_objfile = cu->per_objfile;
struct objfile *objfile = dwarf2_per_objfile->objfile;
bfd *obfd = objfile->obfd;
/* Base address selection entry. */
dwarf2_ranges_process (unsigned offset, struct dwarf2_cu *cu,
Callback &&callback)
{
- struct dwarf2_per_objfile *dwarf2_per_objfile
- = cu->per_cu->dwarf2_per_objfile;
- struct objfile *objfile = dwarf2_per_objfile->objfile;
+ dwarf2_per_objfile *per_objfile = cu->per_objfile;
+ struct objfile *objfile = per_objfile->objfile;
struct comp_unit_head *cu_header = &cu->header;
bfd *obfd = objfile->obfd;
unsigned int addr_size = cu_header->addr_size;
base = cu->base_address;
- dwarf2_per_objfile->per_bfd->ranges.read (objfile);
- if (offset >= dwarf2_per_objfile->per_bfd->ranges.size)
+ per_objfile->per_bfd->ranges.read (objfile);
+ if (offset >= per_objfile->per_bfd->ranges.size)
{
complaint (_("Offset %d out of bounds for DW_AT_ranges attribute"),
offset);
return 0;
}
- buffer = dwarf2_per_objfile->per_bfd->ranges.buffer + offset;
+ buffer = per_objfile->per_bfd->ranges.buffer + offset;
baseaddr = objfile->text_section_offset ();
/* A not-uncommon case of bad debug info.
Don't pollute the addrmap with bad data. */
if (range_beginning + baseaddr == 0
- && !dwarf2_per_objfile->per_bfd->has_section_at_zero)
+ && !per_objfile->per_bfd->has_section_at_zero)
{
complaint (_(".debug_ranges entry has start address of zero"
" [in module %s]"), objfile_name (objfile));
CORE_ADDR *high_return, struct dwarf2_cu *cu,
dwarf2_psymtab *ranges_pst)
{
- struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+ struct objfile *objfile = cu->per_objfile->objfile;
struct gdbarch *gdbarch = objfile->arch ();
const CORE_ADDR baseaddr = objfile->text_section_offset ();
int low_set = 0;
CORE_ADDR *highpc, struct dwarf2_cu *cu,
dwarf2_psymtab *pst)
{
- struct dwarf2_per_objfile *dwarf2_per_objfile
- = cu->per_cu->dwarf2_per_objfile;
+ struct dwarf2_per_objfile *dwarf2_per_objfile = cu->per_objfile;
struct attribute *attr;
struct attribute *attr_high;
CORE_ADDR low = 0;
dwarf2_record_block_ranges (struct die_info *die, struct block *block,
CORE_ADDR baseaddr, struct dwarf2_cu *cu)
{
- struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+ struct objfile *objfile = cu->per_objfile->objfile;
struct gdbarch *gdbarch = objfile->arch ();
struct attribute *attr;
struct attribute *attr_high;
SET_FIELD_BITPOS (*field, offset * bits_per_byte);
else
{
- struct objfile *objfile
- = cu->per_cu->dwarf2_per_objfile->objfile;
+ dwarf2_per_objfile *per_objfile = cu->per_objfile;
+ struct objfile *objfile = per_objfile->objfile;
struct dwarf2_locexpr_baton *dlbaton
= XOBNEW (&objfile->objfile_obstack,
struct dwarf2_locexpr_baton);
of the field, not the value. This is why
is_reference is set to false here. */
dlbaton->is_reference = false;
- dlbaton->per_objfile = cu->per_cu->dwarf2_per_objfile;
+ dlbaton->per_objfile = per_objfile;
dlbaton->per_cu = cu->per_cu;
SET_FIELD_DWARF_BLOCK (*field, dlbaton);
dwarf2_add_field (struct field_info *fip, struct die_info *die,
struct dwarf2_cu *cu)
{
- struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+ struct objfile *objfile = cu->per_objfile->objfile;
struct gdbarch *gdbarch = objfile->arch ();
struct nextfield *new_field;
struct attribute *attr;
for (int i = 0; i < fip->fields.size (); ++i)
offset_map[fip->fields[i].offset] = i;
- struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+ struct objfile *objfile = cu->per_objfile->objfile;
gdb::array_view<variant_part> parts
= create_variant_parts (&objfile->objfile_obstack, offset_map, fip,
fip->variant_parts);
dwarf2_add_member_fn (struct field_info *fip, struct die_info *die,
struct type *type, struct dwarf2_cu *cu)
{
- struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+ struct objfile *objfile = cu->per_objfile->objfile;
struct attribute *attr;
int i;
struct fnfieldlist *flp = nullptr;
complaint (_("DW_AT_alignment must have constant form"
" - DIE at %s [in module %s]"),
sect_offset_str (die->sect_off),
- objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
+ objfile_name (cu->per_objfile->objfile));
return 0;
}
complaint (_("DW_AT_alignment value must not be negative"
" - DIE at %s [in module %s]"),
sect_offset_str (die->sect_off),
- objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
+ objfile_name (cu->per_objfile->objfile));
return 0;
}
align = val;
complaint (_("DW_AT_alignment value must not be zero"
" - DIE at %s [in module %s]"),
sect_offset_str (die->sect_off),
- objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
+ objfile_name (cu->per_objfile->objfile));
return 0;
}
if ((align & (align - 1)) != 0)
complaint (_("DW_AT_alignment value must be a power of 2"
" - DIE at %s [in module %s]"),
sect_offset_str (die->sect_off),
- objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
+ objfile_name (cu->per_objfile->objfile));
return 0;
}
complaint (_("DW_AT_alignment value too large"
" - DIE at %s [in module %s]"),
sect_offset_str (die->sect_off),
- objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
+ objfile_name (cu->per_objfile->objfile));
}
/* Check if the given VALUE is a valid enum dwarf_calling_convention
static struct type *
read_structure_type (struct die_info *die, struct dwarf2_cu *cu)
{
- struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+ struct objfile *objfile = cu->per_objfile->objfile;
struct type *type;
struct attribute *attr;
const char *name;
complaint (_("nested DW_TAG_variant_part seen "
"- DIE at %s [in module %s]"),
sect_offset_str (die->sect_off),
- objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
+ objfile_name (cu->per_objfile->objfile));
return;
}
else
complaint (_("DW_AT_discr does not have DIE reference form"
" - DIE at %s [in module %s]"),
sect_offset_str (die->sect_off),
- objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
+ objfile_name (cu->per_objfile->objfile));
}
for (die_info *child_die = die->child;
complaint (_("saw DW_TAG_variant outside DW_TAG_variant_part "
"- DIE at %s [in module %s]"),
sect_offset_str (die->sect_off),
- objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
+ objfile_name (cu->per_objfile->objfile));
return;
}
if (fi->current_variant_part->processing_variant)
complaint (_("nested DW_TAG_variant seen "
"- DIE at %s [in module %s]"),
sect_offset_str (die->sect_off),
- objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
+ objfile_name (cu->per_objfile->objfile));
return;
}
static void
process_structure_scope (struct die_info *die, struct dwarf2_cu *cu)
{
- struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+ struct objfile *objfile = cu->per_objfile->objfile;
struct die_info *child_die;
struct type *type;
static struct type *
read_enumeration_type (struct die_info *die, struct dwarf2_cu *cu)
{
- struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+ struct objfile *objfile = cu->per_objfile->objfile;
struct type *type;
struct attribute *attr;
const char *name;
static struct type *
read_array_type (struct die_info *die, struct dwarf2_cu *cu)
{
- struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+ struct objfile *objfile = cu->per_objfile->objfile;
struct die_info *child_die;
struct type *type;
struct type *element_type, *range_type, *index_type;
complaint (_("unable to read array DW_AT_byte_stride "
" - DIE at %s [in module %s]"),
sect_offset_str (die->sect_off),
- objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
+ objfile_name (cu->per_objfile->objfile));
/* Ignore this attribute. We will likely not be able to print
arrays of this type correctly, but there is little we can do
to help if we cannot read the attribute's value. */
struct attribute *member_loc,
struct dwarf2_cu *cu)
{
- dwarf2_per_objfile *per_objfile = cu->per_cu->dwarf2_per_objfile;
+ dwarf2_per_objfile *per_objfile = cu->per_objfile;
struct objfile *objfile = per_objfile->objfile;
struct dwarf2_locexpr_baton *baton;
gdb_byte *ptr;
if (die->child != NULL)
{
- struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+ struct objfile *objfile = cu->per_objfile->objfile;
struct die_info *child_die;
size_t n_entries = 0, size;
struct common_block *common_block;
static struct type *
read_namespace_type (struct die_info *die, struct dwarf2_cu *cu)
{
- struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+ struct objfile *objfile = cu->per_objfile->objfile;
const char *previous_prefix, *name;
int is_anonymous;
struct type *type;
static void
read_namespace (struct die_info *die, struct dwarf2_cu *cu)
{
- struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+ struct objfile *objfile = cu->per_objfile->objfile;
int is_anonymous;
/* Add a symbol associated to this if we haven't seen the namespace
static struct type *
read_module_type (struct die_info *die, struct dwarf2_cu *cu)
{
- struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+ struct objfile *objfile = cu->per_objfile->objfile;
const char *module_name;
struct type *type;
static struct type *
read_tag_pointer_type (struct die_info *die, struct dwarf2_cu *cu)
{
- struct gdbarch *gdbarch
- = cu->per_cu->dwarf2_per_objfile->objfile->arch ();
+ struct gdbarch *gdbarch = cu->per_objfile->objfile->arch ();
struct comp_unit_head *cu_header = &cu->header;
struct type *type;
struct attribute *attr_byte_size;
complaint (_("Invalid DW_AT_alignment"
" - DIE at %s [in module %s]"),
sect_offset_str (die->sect_off),
- objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
+ objfile_name (cu->per_objfile->objfile));
}
else
{
type = lookup_methodptr_type (to_type);
else if (check_typedef (to_type)->code () == TYPE_CODE_FUNC)
{
- struct type *new_type
- = alloc_type (cu->per_cu->dwarf2_per_objfile->objfile);
+ struct type *new_type = alloc_type (cu->per_objfile->objfile);
smash_to_method_type (new_type, domain, TYPE_TARGET_TYPE (to_type),
to_type->fields (), to_type->num_fields (),
static struct type *
read_tag_string_type (struct die_info *die, struct dwarf2_cu *cu)
{
- struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+ struct objfile *objfile = cu->per_objfile->objfile;
struct gdbarch *gdbarch = objfile->arch ();
struct type *type, *range_type, *index_type, *char_type;
struct attribute *attr;
static struct type *
read_subroutine_type (struct die_info *die, struct dwarf2_cu *cu)
{
- struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+ struct objfile *objfile = cu->per_objfile->objfile;
struct type *type; /* Type that this function returns. */
struct type *ftype; /* Function that returns above type. */
struct attribute *attr;
static struct type *
read_typedef (struct die_info *die, struct dwarf2_cu *cu)
{
- struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+ struct objfile *objfile = cu->per_objfile->objfile;
const char *name = NULL;
struct type *this_type, *target_type;
static struct type *
read_base_type (struct die_info *die, struct dwarf2_cu *cu)
{
- struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+ struct objfile *objfile = cu->per_objfile->objfile;
struct type *type;
struct attribute *attr;
int encoding = 0, bits = 0;
if (name == nullptr)
{
struct obstack *obstack
- = &cu->per_cu->dwarf2_per_objfile->objfile->objfile_obstack;
+ = &cu->per_objfile->objfile->objfile_obstack;
name = obconcat (obstack, "_Complex ", type->name (),
nullptr);
}
struct type *default_type)
{
struct dwarf2_property_baton *baton;
- dwarf2_per_objfile *per_objfile = cu->per_cu->dwarf2_per_objfile;
+ dwarf2_per_objfile *per_objfile = cu->per_objfile;
struct objfile *objfile = per_objfile->objfile;
struct obstack *obstack = &objfile->objfile_obstack;
complaint (_("Missing DW_AT_lower_bound "
"- DIE at %s [in module %s]"),
sect_offset_str (die->sect_off),
- objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
+ objfile_name (cu->per_objfile->objfile));
struct attribute *attr_ub, *attr_count;
attr = attr_ub = dwarf2_attr (die, DW_AT_upper_bound, cu);
complaint (_("Unresolved DW_AT_upper_bound "
"- DIE at %s [in module %s]"),
sect_offset_str (die->sect_off),
- objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
+ objfile_name (cu->per_objfile->objfile));
if (attr_count != NULL)
complaint (_("Unresolved DW_AT_count "
"- DIE at %s [in module %s]"),
sect_offset_str (die->sect_off),
- objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
+ objfile_name (cu->per_objfile->objfile));
}
}
complaint (_("Found DW_AT_bit_stride and DW_AT_byte_stride "
"- DIE at %s [in module %s]"),
sect_offset_str (die->sect_off),
- objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
+ objfile_name (cu->per_objfile->objfile));
attr_bit_stride = nullptr;
}
else
{
struct type *type;
- type = init_type (cu->per_cu->dwarf2_per_objfile->objfile, TYPE_CODE_VOID,0,
- NULL);
+ type = init_type (cu->per_objfile->objfile, TYPE_CODE_VOID, 0, NULL);
type->set_name (dwarf2_name (die, cu));
/* In Ada, an unspecified type is typically used when the description
const gdb_byte *info_ptr, int building_psymtab)
{
struct dwarf2_cu *cu = reader->cu;
- struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+ struct objfile *objfile = cu->per_objfile->objfile;
struct partial_die_info *parent_die, *last_die, *first_die = NULL;
unsigned int bytes_read;
unsigned int load_all = 0;
const struct abbrev_info &abbrev, const gdb_byte *info_ptr)
{
struct dwarf2_cu *cu = reader->cu;
- struct dwarf2_per_objfile *dwarf2_per_objfile
- = cu->per_cu->dwarf2_per_objfile;
+ struct dwarf2_per_objfile *dwarf2_per_objfile = cu->per_objfile;
unsigned int i;
int has_low_pc_attr = 0;
int has_high_pc_attr = 0;
static const struct cu_partial_die_info
find_partial_die (sect_offset sect_off, int offset_in_dwz, struct dwarf2_cu *cu)
{
- struct dwarf2_per_objfile *dwarf2_per_objfile
- = cu->per_cu->dwarf2_per_objfile;
+ struct dwarf2_per_objfile *dwarf2_per_objfile = cu->per_objfile;
struct objfile *objfile = dwarf2_per_objfile->objfile;
struct dwarf2_per_cu_data *per_cu = NULL;
struct partial_die_info *pd = NULL;
dwarf2_per_objfile);
if (per_cu->cu == NULL || per_cu->cu->partial_dies == NULL)
- load_partial_comp_unit (per_cu);
+ load_partial_comp_unit (per_cu, cu->per_objfile);
per_cu->cu->last_used = 0;
pd = per_cu->cu->find_partial_die (sect_off);
DIEs alone (which can still be in use, e.g. in scan_partial_symbols),
and clobber THIS_CU->cu->partial_dies with the hash table for the new
set. */
- load_partial_comp_unit (per_cu);
+ load_partial_comp_unit (per_cu, cu->per_objfile);
pd = per_cu->cu->find_partial_die (sect_off);
}
child_pdi->linkage_name));
if (actual_class_name != NULL)
{
- struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+ struct objfile *objfile = cu->per_objfile->objfile;
struct_pdi->name = objfile->intern (actual_class_name.get ());
}
break;
children, see if we can determine the namespace from their linkage
name. */
if (cu->language == language_cplus
- && !cu->per_cu->dwarf2_per_objfile->per_bfd->types.empty ()
+ && !cu->per_objfile->per_bfd->types.empty ()
&& die_parent == NULL
&& has_children
&& (tag == DW_TAG_class_type
else
base = demangled.get ();
- struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+ struct objfile *objfile = cu->per_objfile->objfile;
name = objfile->intern (base);
}
}
static CORE_ADDR
read_loclist_index (struct dwarf2_cu *cu, ULONGEST loclist_index)
{
- struct dwarf2_per_objfile *dwarf2_per_objfile
- = cu->per_cu->dwarf2_per_objfile;
+ struct dwarf2_per_objfile *dwarf2_per_objfile = cu->per_objfile;
struct objfile *objfile = dwarf2_per_objfile->objfile;
bfd *abfd = objfile->obfd;
ULONGEST loclist_base = lookup_loclist_base (cu);
bool *need_reprocess)
{
struct dwarf2_cu *cu = reader->cu;
- struct dwarf2_per_objfile *dwarf2_per_objfile
- = cu->per_cu->dwarf2_per_objfile;
+ struct dwarf2_per_objfile *dwarf2_per_objfile = cu->per_objfile;
struct objfile *objfile = dwarf2_per_objfile->objfile;
bfd *abfd = reader->abfd;
struct comp_unit_head *cu_header = &cu->header;
/* FALLTHROUGH */
case DW_FORM_GNU_strp_alt:
{
- struct dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
+ dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile->per_bfd);
LONGEST str_offset = cu_header->read_offset (abfd, info_ptr,
&bytes_read);
static CORE_ADDR
read_addr_index (struct dwarf2_cu *cu, unsigned int addr_index)
{
- return read_addr_index_1 (cu->per_cu->dwarf2_per_objfile, addr_index,
+ return read_addr_index_1 (cu->per_objfile, addr_index,
cu->addr_base, cu->header.addr_size);
}
read_addr_index_from_leb128 (struct dwarf2_cu *cu, const gdb_byte *info_ptr,
unsigned int *bytes_read)
{
- bfd *abfd = cu->per_cu->dwarf2_per_objfile->objfile->obfd;
+ bfd *abfd = cu->per_objfile->objfile->obfd;
unsigned int addr_index = read_unsigned_leb128 (abfd, info_ptr, bytes_read);
return read_addr_index (cu, addr_index);
}
else
{
- cutu_reader reader (per_cu, NULL, 0, false);
+ cutu_reader reader (per_cu, dwarf2_per_objfile, NULL, 0, false);
addr_base = reader.cu->addr_base;
addr_size = reader.cu->header.addr_size;
}
struct dwarf2_section_info *str_offsets_section,
ULONGEST str_offsets_base, ULONGEST str_index)
{
- struct dwarf2_per_objfile *dwarf2_per_objfile
- = cu->per_cu->dwarf2_per_objfile;
+ struct dwarf2_per_objfile *dwarf2_per_objfile = cu->per_objfile;
struct objfile *objfile = dwarf2_per_objfile->objfile;
const char *objf_name = objfile_name (objfile);
bfd *abfd = objfile->obfd;
static const char *
read_stub_str_index (struct dwarf2_cu *cu, ULONGEST str_index)
{
- struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+ struct objfile *objfile = cu->per_objfile->objfile;
const char *objf_name = objfile_name (objfile);
static const char form_name[] = "DW_FORM_GNU_str_index";
static const char str_offsets_attr_name[] = "DW_AT_str_offsets";
(long) cu->header.offset_size, objf_name);
return read_str_index (cu,
- &cu->per_cu->dwarf2_per_objfile->per_bfd->str,
- &cu->per_cu->dwarf2_per_objfile->per_bfd->str_offsets,
+ &cu->per_objfile->per_bfd->str,
+ &cu->per_objfile->per_bfd->str_offsets,
*cu->str_offsets_base, str_index);
}
complaint (_("string type expected for attribute %s for "
"DIE at %s in module %s"),
dwarf_attr_name (name), sect_offset_str (die->sect_off),
- objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
+ objfile_name (cu->per_objfile->objfile));
}
return str;
get_debug_line_section (struct dwarf2_cu *cu)
{
struct dwarf2_section_info *section;
- struct dwarf2_per_objfile *dwarf2_per_objfile
- = cu->per_cu->dwarf2_per_objfile;
+ struct dwarf2_per_objfile *dwarf2_per_objfile = cu->per_objfile;
/* For TUs in DWO files, the DW_AT_stmt_list attribute lives in the
DWO file. */
section = &cu->dwo_unit->dwo_file->sections.line;
else if (cu->per_cu->is_dwz)
{
- struct dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
+ dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile->per_bfd);
section = &dwz->line;
}
dwarf_decode_line_header (sect_offset sect_off, struct dwarf2_cu *cu)
{
struct dwarf2_section_info *section;
- struct dwarf2_per_objfile *dwarf2_per_objfile
- = cu->per_cu->dwarf2_per_objfile;
+ struct dwarf2_per_objfile *dwarf2_per_objfile = cu->per_objfile;
section = get_debug_line_section (cu);
section->read (dwarf2_per_objfile->objfile);
/* This line table is for a function which has been
GCd by the linker. Ignore it. PR gdb/12528 */
- struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+ struct objfile *objfile = cu->per_objfile->objfile;
long line_offset = line_ptr - get_debug_line_section (cu)->buffer;
complaint (_(".debug_line address at offset 0x%lx is 0 [in module %s]"),
unsigned int bytes_read, extended_len;
unsigned char op_code, extended_op;
CORE_ADDR baseaddr;
- struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+ struct objfile *objfile = cu->per_objfile->objfile;
bfd *abfd = objfile->obfd;
struct gdbarch *gdbarch = objfile->arch ();
/* True if we're recording line info (as opposed to building partial
struct dwarf2_cu *cu, dwarf2_psymtab *pst,
CORE_ADDR lowpc, int decode_mapping)
{
- struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+ struct objfile *objfile = cu->per_objfile->objfile;
const int decode_for_pst_p = (pst != NULL);
if (decode_mapping)
var_decode_location (struct attribute *attr, struct symbol *sym,
struct dwarf2_cu *cu)
{
- struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+ struct objfile *objfile = cu->per_objfile->objfile;
struct comp_unit_head *cu_header = &cu->header;
/* NOTE drow/2003-01-30: There used to be a comment and some special
new_symbol (struct die_info *die, struct type *type, struct dwarf2_cu *cu,
struct symbol *space)
{
- struct dwarf2_per_objfile *dwarf2_per_objfile
- = cu->per_cu->dwarf2_per_objfile;
+ struct dwarf2_per_objfile *dwarf2_per_objfile = cu->per_objfile;
struct objfile *objfile = dwarf2_per_objfile->objfile;
struct gdbarch *gdbarch = objfile->arch ();
struct symbol *sym = NULL;
dwarf2_const_value_data (const struct attribute *attr, struct obstack *obstack,
struct dwarf2_cu *cu, LONGEST *value, int bits)
{
- struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+ struct objfile *objfile = cu->per_objfile->objfile;
enum bfd_endian byte_order = bfd_big_endian (objfile->obfd) ?
BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE;
LONGEST l = DW_UNSND (attr);
LONGEST *value, const gdb_byte **bytes,
struct dwarf2_locexpr_baton **baton)
{
- dwarf2_per_objfile *per_objfile = cu->per_cu->dwarf2_per_objfile;
+ dwarf2_per_objfile *per_objfile = cu->per_objfile;
struct objfile *objfile = per_objfile->objfile;
struct comp_unit_head *cu_header = &cu->header;
struct dwarf_block *blk;
dwarf2_const_value (const struct attribute *attr, struct symbol *sym,
struct dwarf2_cu *cu)
{
- struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+ struct objfile *objfile = cu->per_objfile->objfile;
LONGEST value;
const gdb_byte *bytes;
struct dwarf2_locexpr_baton *baton;
type_attr = dwarf2_attr (die, DW_AT_type, cu);
if (!type_attr)
{
- struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+ struct objfile *objfile = cu->per_objfile->objfile;
/* A missing DW_AT_type represents a void type. */
return objfile_type (objfile)->builtin_void;
}
die_containing_type (struct die_info *die, struct dwarf2_cu *cu)
{
struct attribute *type_attr;
- struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+ struct objfile *objfile = cu->per_objfile->objfile;
type_attr = dwarf2_attr (die, DW_AT_containing_type, cu);
if (!type_attr)
static struct type *
build_error_marker_type (struct dwarf2_cu *cu, struct die_info *die)
{
- struct dwarf2_per_objfile *dwarf2_per_objfile
- = cu->per_cu->dwarf2_per_objfile;
+ struct dwarf2_per_objfile *dwarf2_per_objfile = cu->per_objfile;
struct objfile *objfile = dwarf2_per_objfile->objfile;
char *saved;
lookup_die_type (struct die_info *die, const struct attribute *attr,
struct dwarf2_cu *cu)
{
- struct dwarf2_per_objfile *dwarf2_per_objfile
- = cu->per_cu->dwarf2_per_objfile;
+ struct dwarf2_per_objfile *dwarf2_per_objfile = cu->per_objfile;
struct objfile *objfile = dwarf2_per_objfile->objfile;
struct type *this_type;
struct die_info *spec_die;
struct dwarf2_cu *spec_cu;
struct die_info *child;
- struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+ struct objfile *objfile = cu->per_objfile->objfile;
spec_cu = cu;
spec_die = die_specification (die, &spec_cu);
if (base == NULL || base == DW_STRING (attr) || base[-1] != ':')
return "";
- struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+ struct objfile *objfile = cu->per_objfile->objfile;
return obstack_strndup (&objfile->per_bfd->storage_obstack,
DW_STRING (attr),
&base[-1] - DW_STRING (attr));
static const char *
determine_prefix (struct die_info *die, struct dwarf2_cu *cu)
{
- struct dwarf2_per_objfile *dwarf2_per_objfile
- = cu->per_cu->dwarf2_per_objfile;
+ struct dwarf2_per_objfile *dwarf2_per_objfile = cu->per_objfile;
struct die_info *parent, *spec_die;
struct dwarf2_cu *spec_cu;
struct type *parent_type;
dwarf2_name (struct die_info *die, struct dwarf2_cu *cu)
{
struct attribute *attr;
- struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+ struct objfile *objfile = cu->per_objfile->objfile;
attr = dwarf2_attr (die, DW_AT_name, cu);
if ((!attr || !DW_STRING (attr))
{
dump_die_for_error (src_die);
error (_("Dwarf Error: Expected reference attribute [in module %s]"),
- objfile_name ((*ref_cu)->per_cu->dwarf2_per_objfile->objfile));
+ objfile_name ((*ref_cu)->per_objfile->objfile));
}
return die;
{
struct die_info temp_die;
struct dwarf2_cu *target_cu, *cu = *ref_cu;
- struct dwarf2_per_objfile *dwarf2_per_objfile
- = cu->per_cu->dwarf2_per_objfile;
+ struct dwarf2_per_objfile *dwarf2_per_objfile = cu->per_objfile;
gdb_assert (cu->per_cu != NULL);
/* If necessary, add it to the queue and load its DIEs. */
if (maybe_queue_comp_unit (cu, per_cu, cu->language))
- load_full_comp_unit (per_cu, false, cu->language);
+ load_full_comp_unit (per_cu, dwarf2_per_objfile, false, cu->language);
target_cu = per_cu->cu;
}
{
/* We're loading full DIEs during partial symbol reading. */
gdb_assert (dwarf2_per_objfile->per_bfd->reading_partial_symbols);
- load_full_comp_unit (cu->per_cu, false, language_minimal);
+ load_full_comp_unit (cu->per_cu, dwarf2_per_objfile, false,
+ language_minimal);
}
*ref_cu = target_cu;
error (_("Dwarf Error: Cannot find DIE at %s referenced from DIE "
"at %s [in module %s]"),
sect_offset_str (sect_off), sect_offset_str (src_die->sect_off),
- objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
+ objfile_name (cu->per_objfile->objfile));
return die;
}
struct objfile *objfile = dwarf2_per_objfile->objfile;
if (per_cu->cu == NULL)
- load_cu (per_cu, false);
+ load_cu (per_cu, dwarf2_per_objfile, false);
cu = per_cu->cu;
if (cu == NULL)
{
struct objfile *objfile = per_cu->dwarf2_per_objfile->objfile;
if (per_cu->cu == NULL)
- load_cu (per_cu, false);
+ load_cu (per_cu, per_cu->dwarf2_per_objfile, false);
cu = per_cu->cu;
if (cu == NULL)
{
struct die_info *die;
if (per_cu->cu == NULL)
- load_cu (per_cu, false);
+ load_cu (per_cu, per_cu->dwarf2_per_objfile, false);
cu = per_cu->cu;
if (!cu)
return NULL;
/* If necessary, add it to the queue and load its DIEs. */
if (maybe_queue_comp_unit (*ref_cu, &sig_type->per_cu, language_minimal))
- read_signatured_type (sig_type);
+ read_signatured_type (sig_type, (*ref_cu)->per_objfile);
sig_cu = sig_type->per_cu.cu;
gdb_assert (sig_cu != NULL);
to_underlying (temp_die.sect_off));
if (die)
{
- struct dwarf2_per_objfile *dwarf2_per_objfile
- = (*ref_cu)->per_cu->dwarf2_per_objfile;
+ struct dwarf2_per_objfile *dwarf2_per_objfile = (*ref_cu)->per_objfile;
/* For .gdb_index version 7 keep track of included TUs.
http://sourceware.org/bugzilla/show_bug.cgi?id=15021. */
error (_("Dwarf Error: Cannot find signatured DIE %s referenced"
" from DIE at %s [in module %s]"),
hex_string (signature), sect_offset_str (src_die->sect_off),
- objfile_name ((*ref_cu)->per_cu->dwarf2_per_objfile->objfile));
+ objfile_name ((*ref_cu)->per_objfile->objfile));
}
die = follow_die_sig_1 (src_die, sig_type, ref_cu);
error (_("Dwarf Error: Problem reading signatured DIE %s referenced"
" from DIE at %s [in module %s]"),
hex_string (signature), sect_offset_str (src_die->sect_off),
- objfile_name ((*ref_cu)->per_cu->dwarf2_per_objfile->objfile));
+ objfile_name ((*ref_cu)->per_objfile->objfile));
}
return die;
get_signatured_type (struct die_info *die, ULONGEST signature,
struct dwarf2_cu *cu)
{
- struct dwarf2_per_objfile *dwarf2_per_objfile
- = cu->per_cu->dwarf2_per_objfile;
+ struct dwarf2_per_objfile *dwarf2_per_objfile = cu->per_objfile;
struct signatured_type *sig_type;
struct dwarf2_cu *type_cu;
struct die_info *type_die;
}
else
{
- struct dwarf2_per_objfile *dwarf2_per_objfile
- = cu->per_cu->dwarf2_per_objfile;
+ struct dwarf2_per_objfile *dwarf2_per_objfile = cu->per_objfile;
complaint (_("Dwarf Error: DW_AT_signature has bad form %s in DIE"
" at %s [in module %s]"),
/* Load the DIEs associated with type unit PER_CU into memory. */
static void
-load_full_type_unit (struct dwarf2_per_cu_data *per_cu)
+load_full_type_unit (dwarf2_per_cu_data *per_cu,
+ dwarf2_per_objfile *per_objfile)
{
struct signatured_type *sig_type;
gdb_assert (per_cu->cu == NULL);
- read_signatured_type (sig_type);
+ read_signatured_type (sig_type, per_objfile);
gdb_assert (per_cu->cu != NULL);
}
read in the real type from the DWO file as well. */
static void
-read_signatured_type (struct signatured_type *sig_type)
+read_signatured_type (signatured_type *sig_type,
+ dwarf2_per_objfile *per_objfile)
{
struct dwarf2_per_cu_data *per_cu = &sig_type->per_cu;
gdb_assert (per_cu->is_debug_types);
gdb_assert (per_cu->cu == NULL);
- cutu_reader reader (per_cu, NULL, 0, false);
+ cutu_reader reader (per_cu, per_objfile, NULL, 0, false);
if (!reader.dummy_p)
{
static CORE_ADDR
decode_locdesc (struct dwarf_block *blk, struct dwarf2_cu *cu, bool *computed)
{
- struct objfile *objfile = cu->per_cu->dwarf2_per_objfile->objfile;
+ struct objfile *objfile = cu->per_objfile->objfile;
size_t i;
size_t size = blk->size;
const gdb_byte *data = blk->data;
dwarf_decode_macros (struct dwarf2_cu *cu, unsigned int offset,
int section_is_gnu)
{
- struct dwarf2_per_objfile *dwarf2_per_objfile
- = cu->per_cu->dwarf2_per_objfile;
+ struct dwarf2_per_objfile *dwarf2_per_objfile = cu->per_objfile;
struct objfile *objfile = dwarf2_per_objfile->objfile;
const struct line_header *lh = cu->line_header;
unsigned int offset_size = cu->header.offset_size;
static struct dwarf2_section_info *
cu_debug_loc_section (struct dwarf2_cu *cu)
{
- struct dwarf2_per_objfile *dwarf2_per_objfile
- = cu->per_cu->dwarf2_per_objfile;
+ struct dwarf2_per_objfile *dwarf2_per_objfile = cu->per_objfile;
if (cu->dwo_unit)
{
struct dwarf2_loclist_baton *baton,
const struct attribute *attr)
{
- struct dwarf2_per_objfile *dwarf2_per_objfile
- = cu->per_cu->dwarf2_per_objfile;
+ struct dwarf2_per_objfile *dwarf2_per_objfile = cu->per_objfile;
struct dwarf2_section_info *section = cu_debug_loc_section (cu);
section->read (dwarf2_per_objfile->objfile);
dwarf2_symbol_mark_computed (const struct attribute *attr, struct symbol *sym,
struct dwarf2_cu *cu, int is_block)
{
- struct dwarf2_per_objfile *dwarf2_per_objfile
- = cu->per_cu->dwarf2_per_objfile;
+ struct dwarf2_per_objfile *dwarf2_per_objfile = cu->per_objfile;
struct objfile *objfile = dwarf2_per_objfile->objfile;
struct dwarf2_section_info *section = cu_debug_loc_section (cu);
static struct type *
set_die_type (struct die_info *die, struct type *type, struct dwarf2_cu *cu)
{
- struct dwarf2_per_objfile *dwarf2_per_objfile
- = cu->per_cu->dwarf2_per_objfile;
+ struct dwarf2_per_objfile *dwarf2_per_objfile = cu->per_objfile;
struct dwarf2_per_cu_offset_and_type **slot, ofs;
struct objfile *objfile = dwarf2_per_objfile->objfile;
struct attribute *attr;
projects / deliverable / binutils-gdb.git / blobdiff