struct mapped_index_base
{
+ mapped_index_base () = default;
+ DISABLE_COPY_AND_ASSIGN (mapped_index_base);
+
/* The name_component table (a sorted vector). See name_component's
description above. */
std::vector<name_component> name_components;
};
/* Index data format version. */
- int version;
-
- /* The total length of the buffer. */
- off_t total_size;
+ int version = 0;
/* The address table data. */
gdb::array_view<const gdb_byte> address_table;
gdb::array_view<symbol_table_slot> symbol_table;
/* A pointer to the constant pool. */
- const char *constant_pool;
+ const char *constant_pool = nullptr;
bool symbol_name_slot_invalid (offset_type idx) const override
{
struct dwp_file
{
+ dwp_file (const char *name_, gdb_bfd_ref_ptr &&abfd)
+ : name (name_),
+ dbfd (std::move (abfd))
+ {
+ }
+
/* Name of the file. */
const char *name;
/* File format version. */
- int version;
+ int version = 0;
/* The bfd. */
- bfd *dbfd;
+ gdb_bfd_ref_ptr dbfd;
/* Section info for this file. */
- struct dwp_sections sections;
+ struct dwp_sections sections {};
/* Table of CUs in the file. */
- const struct dwp_hash_table *cus;
+ const struct dwp_hash_table *cus = nullptr;
/* Table of TUs in the file. */
- const struct dwp_hash_table *tus;
+ const struct dwp_hash_table *tus = nullptr;
/* Tables of loaded CUs/TUs. Each entry is a struct dwo_unit *. */
- htab_t loaded_cus;
- htab_t loaded_tus;
+ htab_t loaded_cus {};
+ htab_t loaded_tus {};
/* Table to map ELF section numbers to their sections.
This is only needed for the DWP V1 file format. */
- unsigned int num_sections;
- asection **elf_sections;
+ unsigned int num_sections = 0;
+ asection **elf_sections = nullptr;
};
/* This represents a '.dwz' file. */
struct dwz_file
{
+ dwz_file (gdb_bfd_ref_ptr &&bfd)
+ : dwz_bfd (std::move (bfd))
+ {
+ }
+
/* A dwz file can only contain a few sections. */
- struct dwarf2_section_info abbrev;
- struct dwarf2_section_info info;
- struct dwarf2_section_info str;
- struct dwarf2_section_info line;
- struct dwarf2_section_info macro;
- struct dwarf2_section_info gdb_index;
- struct dwarf2_section_info debug_names;
+ struct dwarf2_section_info abbrev {};
+ struct dwarf2_section_info info {};
+ struct dwarf2_section_info str {};
+ struct dwarf2_section_info line {};
+ struct dwarf2_section_info macro {};
+ struct dwarf2_section_info gdb_index {};
+ struct dwarf2_section_info debug_names {};
/* The dwz's BFD. */
- bfd *dwz_bfd;
+ gdb_bfd_ref_ptr dwz_bfd;
};
/* Struct used to pass misc. parameters to read_die_and_children, et
static int create_all_type_units (struct dwarf2_per_objfile *dwarf2_per_objfile);
-static void load_full_comp_unit (struct dwarf2_per_cu_data *,
+static void load_full_comp_unit (struct dwarf2_per_cu_data *, bool,
enum language);
static void process_full_comp_unit (struct dwarf2_per_cu_data *,
static void init_cutu_and_read_dies
(struct dwarf2_per_cu_data *this_cu, struct abbrev_table *abbrev_table,
- int use_existing_cu, int keep,
+ int use_existing_cu, int keep, bool skip_partial,
die_reader_func_ftype *die_reader_func, void *data);
static void init_cutu_and_read_dies_simple
static void
dwarf2_statement_list_fits_in_line_number_section_complaint (void)
{
- complaint (&symfile_complaints,
- _("statement list doesn't fit in .debug_line section"));
+ complaint (_("statement list doesn't fit in .debug_line section"));
}
static void
dwarf2_debug_line_missing_file_complaint (void)
{
- complaint (&symfile_complaints,
- _(".debug_line section has line data without a file"));
+ complaint (_(".debug_line section has line data without a file"));
}
static void
dwarf2_debug_line_missing_end_sequence_complaint (void)
{
- complaint (&symfile_complaints,
- _(".debug_line section has line "
+ complaint (_(".debug_line section has line "
"program sequence without an end"));
}
static void
dwarf2_complex_location_expr_complaint (void)
{
- complaint (&symfile_complaints, _("location expression too complex"));
+ complaint (_("location expression too complex"));
}
static void
dwarf2_const_value_length_mismatch_complaint (const char *arg1, int arg2,
int arg3)
{
- complaint (&symfile_complaints,
- _("const value length mismatch for '%s', got %d, expected %d"),
+ complaint (_("const value length mismatch for '%s', got %d, expected %d"),
arg1, arg2, arg3);
}
static void
dwarf2_section_buffer_overflow_complaint (struct dwarf2_section_info *section)
{
- complaint (&symfile_complaints,
- _("debug info runs off end of %s section"
+ complaint (_("debug info runs off end of %s section"
" [in module %s]"),
get_section_name (section),
get_section_file_name (section));
static void
dwarf2_macro_malformed_definition_complaint (const char *arg1)
{
- complaint (&symfile_complaints,
- _("macro debug info contains a "
+ complaint (_("macro debug info contains a "
"malformed macro definition:\n`%s'"),
arg1);
}
static void
dwarf2_invalid_attrib_class_complaint (const char *arg1, const char *arg2)
{
- complaint (&symfile_complaints,
- _("invalid attribute class or form for '%s' in '%s'"),
+ complaint (_("invalid attribute class or form for '%s' in '%s'"),
arg1, arg2);
}
if (line_header_hash)
htab_delete (line_header_hash);
- for (int ix = 0; ix < n_comp_units; ++ix)
- VEC_free (dwarf2_per_cu_ptr, all_comp_units[ix]->imported_symtabs);
+ for (dwarf2_per_cu_data *per_cu : all_comp_units)
+ VEC_free (dwarf2_per_cu_ptr, per_cu->imported_symtabs);
- for (int ix = 0; ix < n_type_units; ++ix)
- VEC_free (dwarf2_per_cu_ptr,
- all_type_units[ix]->per_cu.imported_symtabs);
- xfree (all_type_units);
+ for (signatured_type *sig_type : all_type_units)
+ VEC_free (dwarf2_per_cu_ptr, sig_type->per_cu.imported_symtabs);
VEC_free (dwarf2_section_info_def, types);
if (dwo_files != NULL)
free_dwo_files (dwo_files, objfile);
- if (dwp_file != NULL)
- gdb_bfd_unref (dwp_file->dbfd);
-
- if (dwz_file != NULL && dwz_file->dwz_bfd)
- gdb_bfd_unref (dwz_file->dwz_bfd);
-
- if (index_table != NULL)
- index_table->~mapped_index ();
/* Everything else should be on the objfile obstack. */
}
dwarf2_get_dwz_file (struct dwarf2_per_objfile *dwarf2_per_objfile)
{
const char *filename;
- struct dwz_file *result;
bfd_size_type buildid_len_arg;
size_t buildid_len;
bfd_byte *buildid;
if (dwarf2_per_objfile->dwz_file != NULL)
- return dwarf2_per_objfile->dwz_file;
+ return dwarf2_per_objfile->dwz_file.get ();
bfd_set_error (bfd_error_no_error);
gdb::unique_xmalloc_ptr<char> data
error (_("could not find '.gnu_debugaltlink' file for %s"),
objfile_name (dwarf2_per_objfile->objfile));
- result = OBSTACK_ZALLOC (&dwarf2_per_objfile->objfile->objfile_obstack,
- struct dwz_file);
- result->dwz_bfd = dwz_bfd.release ();
+ std::unique_ptr<struct dwz_file> result
+ (new struct dwz_file (std::move (dwz_bfd)));
- bfd_map_over_sections (result->dwz_bfd, locate_dwz_sections, result);
+ 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);
- dwarf2_per_objfile->dwz_file = result;
- return result;
+ gdb_bfd_record_inclusion (dwarf2_per_objfile->objfile->obfd,
+ result->dwz_bfd.get ());
+ dwarf2_per_objfile->dwz_file = std::move (result);
+ return dwarf2_per_objfile->dwz_file.get ();
}
\f
/* DWARF quick_symbols_functions support. */
processing PER_CU->CU. dw2_setup must have been already called. */
static void
-load_cu (struct dwarf2_per_cu_data *per_cu)
+load_cu (struct dwarf2_per_cu_data *per_cu, bool skip_partial)
{
if (per_cu->is_debug_types)
load_full_type_unit (per_cu);
else
- load_full_comp_unit (per_cu, language_minimal);
+ load_full_comp_unit (per_cu, skip_partial, language_minimal);
if (per_cu->cu == NULL)
return; /* Dummy CU. */
/* Read in the symbols for PER_CU. */
static void
-dw2_do_instantiate_symtab (struct dwarf2_per_cu_data *per_cu)
+dw2_do_instantiate_symtab (struct dwarf2_per_cu_data *per_cu, bool skip_partial)
{
struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
: (per_cu->v.psymtab == NULL || !per_cu->v.psymtab->readin))
{
queue_comp_unit (per_cu, language_minimal);
- load_cu (per_cu);
+ load_cu (per_cu, 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.
table. */
static struct compunit_symtab *
-dw2_instantiate_symtab (struct dwarf2_per_cu_data *per_cu)
+dw2_instantiate_symtab (struct dwarf2_per_cu_data *per_cu, bool skip_partial)
{
struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
{
free_cached_comp_units freer (dwarf2_per_objfile);
scoped_restore decrementer = increment_reading_symtab ();
- dw2_do_instantiate_symtab (per_cu);
+ dw2_do_instantiate_symtab (per_cu, skip_partial);
process_cu_includes (dwarf2_per_objfile);
}
return per_cu->v.quick->compunit_symtab;
}
-/* Return the CU/TU given its index.
+/* See declaration. */
- This is intended for loops like:
+dwarf2_per_cu_data *
+dwarf2_per_objfile::get_cutu (int index)
+{
+ if (index >= this->all_comp_units.size ())
+ {
+ index -= this->all_comp_units.size ();
+ gdb_assert (index < this->all_type_units.size ());
+ return &this->all_type_units[index]->per_cu;
+ }
- for (i = 0; i < (dwarf2_per_objfile->n_comp_units
- + dwarf2_per_objfile->n_type_units); ++i)
- {
- struct dwarf2_per_cu_data *per_cu = dw2_get_cutu (i);
+ return this->all_comp_units[index];
+}
- ...;
- }
-*/
+/* See declaration. */
-static struct dwarf2_per_cu_data *
-dw2_get_cutu (struct dwarf2_per_objfile *dwarf2_per_objfile,
- int index)
+dwarf2_per_cu_data *
+dwarf2_per_objfile::get_cu (int index)
{
- if (index >= dwarf2_per_objfile->n_comp_units)
- {
- index -= dwarf2_per_objfile->n_comp_units;
- gdb_assert (index < dwarf2_per_objfile->n_type_units);
- return &dwarf2_per_objfile->all_type_units[index]->per_cu;
- }
+ gdb_assert (index >= 0 && index < this->all_comp_units.size ());
- return dwarf2_per_objfile->all_comp_units[index];
+ return this->all_comp_units[index];
}
-/* Return the CU given its index.
- This differs from dw2_get_cutu in that it's for when you know INDEX
- refers to a CU. */
+/* See declaration. */
-static struct dwarf2_per_cu_data *
-dw2_get_cu (struct dwarf2_per_objfile *dwarf2_per_objfile, int index)
+signatured_type *
+dwarf2_per_objfile::get_tu (int index)
{
- gdb_assert (index >= 0 && index < dwarf2_per_objfile->n_comp_units);
+ gdb_assert (index >= 0 && index < this->all_type_units.size ());
- return dwarf2_per_objfile->all_comp_units[index];
+ return this->all_type_units[index];
}
/* Return a new dwarf2_per_cu_data allocated on OBJFILE's
CUs. */
static void
-create_cus_from_index_list (struct objfile *objfile,
+create_cus_from_index_list (struct dwarf2_per_objfile *dwarf2_per_objfile,
const gdb_byte *cu_list, offset_type n_elements,
struct dwarf2_section_info *section,
- int is_dwz,
- int base_offset)
+ int is_dwz)
{
- offset_type i;
- struct dwarf2_per_objfile *dwarf2_per_objfile
- = get_dwarf2_per_objfile (objfile);
-
- for (i = 0; i < n_elements; i += 2)
+ for (offset_type i = 0; i < n_elements; i += 2)
{
gdb_static_assert (sizeof (ULONGEST) >= 8);
ULONGEST length = extract_unsigned_integer (cu_list + 8, 8, BFD_ENDIAN_LITTLE);
cu_list += 2 * 8;
- dwarf2_per_objfile->all_comp_units[base_offset + i / 2]
+ dwarf2_per_cu_data *per_cu
= create_cu_from_index_list (dwarf2_per_objfile, section, is_dwz,
sect_off, length);
+ dwarf2_per_objfile->all_comp_units.push_back (per_cu);
}
}
the CU objects for this objfile. */
static void
-create_cus_from_index (struct objfile *objfile,
+create_cus_from_index (struct dwarf2_per_objfile *dwarf2_per_objfile,
const gdb_byte *cu_list, offset_type cu_list_elements,
const gdb_byte *dwz_list, offset_type dwz_elements)
{
- struct dwz_file *dwz;
- struct dwarf2_per_objfile *dwarf2_per_objfile
- = get_dwarf2_per_objfile (objfile);
-
- dwarf2_per_objfile->n_comp_units = (cu_list_elements + dwz_elements) / 2;
- dwarf2_per_objfile->all_comp_units =
- XOBNEWVEC (&objfile->objfile_obstack, struct dwarf2_per_cu_data *,
- dwarf2_per_objfile->n_comp_units);
+ gdb_assert (dwarf2_per_objfile->all_comp_units.empty ());
+ dwarf2_per_objfile->all_comp_units.reserve
+ ((cu_list_elements + dwz_elements) / 2);
- create_cus_from_index_list (objfile, cu_list, cu_list_elements,
- &dwarf2_per_objfile->info, 0, 0);
+ create_cus_from_index_list (dwarf2_per_objfile, cu_list, cu_list_elements,
+ &dwarf2_per_objfile->info, 0);
if (dwz_elements == 0)
return;
- dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
- create_cus_from_index_list (objfile, dwz_list, dwz_elements, &dwz->info, 1,
- cu_list_elements / 2);
+ dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
+ create_cus_from_index_list (dwarf2_per_objfile, dwz_list, dwz_elements,
+ &dwz->info, 1);
}
/* Create the signatured type hash table from the index. */
static void
-create_signatured_type_table_from_index (struct objfile *objfile,
- struct dwarf2_section_info *section,
- const gdb_byte *bytes,
- offset_type elements)
+create_signatured_type_table_from_index
+ (struct dwarf2_per_objfile *dwarf2_per_objfile,
+ struct dwarf2_section_info *section,
+ const gdb_byte *bytes,
+ offset_type elements)
{
- offset_type i;
- htab_t sig_types_hash;
- struct dwarf2_per_objfile *dwarf2_per_objfile
- = get_dwarf2_per_objfile (objfile);
+ struct objfile *objfile = dwarf2_per_objfile->objfile;
- dwarf2_per_objfile->n_type_units
- = dwarf2_per_objfile->n_allocated_type_units
- = elements / 3;
- dwarf2_per_objfile->all_type_units =
- XNEWVEC (struct signatured_type *, dwarf2_per_objfile->n_type_units);
+ gdb_assert (dwarf2_per_objfile->all_type_units.empty ());
+ dwarf2_per_objfile->all_type_units.reserve (elements / 3);
- sig_types_hash = allocate_signatured_type_table (objfile);
+ htab_t sig_types_hash = allocate_signatured_type_table (objfile);
- for (i = 0; i < elements; i += 3)
+ for (offset_type i = 0; i < elements; i += 3)
{
struct signatured_type *sig_type;
ULONGEST signature;
slot = htab_find_slot (sig_types_hash, sig_type, INSERT);
*slot = sig_type;
- dwarf2_per_objfile->all_type_units[i / 3] = sig_type;
+ dwarf2_per_objfile->all_type_units.push_back (sig_type);
}
dwarf2_per_objfile->signatured_types = sig_types_hash;
dwarf2_read_section (objfile, section);
dwarf2_read_section (objfile, abbrev_section);
- dwarf2_per_objfile->n_type_units
- = dwarf2_per_objfile->n_allocated_type_units
- = map.tu_count;
- dwarf2_per_objfile->all_type_units
- = XNEWVEC (struct signatured_type *, dwarf2_per_objfile->n_type_units);
+ gdb_assert (dwarf2_per_objfile->all_type_units.empty ());
+ dwarf2_per_objfile->all_type_units.reserve (map.tu_count);
htab_t sig_types_hash = allocate_signatured_type_table (objfile);
slot = htab_find_slot (sig_types_hash, sig_type, INSERT);
*slot = sig_type;
- dwarf2_per_objfile->all_type_units[i] = sig_type;
+ dwarf2_per_objfile->all_type_units.push_back (sig_type);
}
dwarf2_per_objfile->signatured_types = sig_types_hash;
if (lo > hi)
{
- complaint (&symfile_complaints,
- _(".gdb_index address table has invalid range (%s - %s)"),
+ complaint (_(".gdb_index address table has invalid range (%s - %s)"),
hex_string (lo), hex_string (hi));
continue;
}
- if (cu_index >= dwarf2_per_objfile->n_comp_units)
+ if (cu_index >= dwarf2_per_objfile->all_comp_units.size ())
{
- complaint (&symfile_complaints,
- _(".gdb_index address table has invalid CU number %u"),
+ complaint (_(".gdb_index address table has invalid CU number %u"),
(unsigned) cu_index);
continue;
}
lo = gdbarch_adjust_dwarf2_addr (gdbarch, lo + baseaddr);
hi = gdbarch_adjust_dwarf2_addr (gdbarch, hi + baseaddr);
addrmap_set_empty (mutable_map, lo, hi - 1,
- dw2_get_cutu (dwarf2_per_objfile, cu_index));
+ dwarf2_per_objfile->get_cu (cu_index));
}
objfile->psymtabs_addrmap = addrmap_create_fixed (mutable_map,
dwarf2_per_cu_data *,
gdb::hash_enum<sect_offset>>
debug_info_offset_to_per_cu;
- for (int cui = 0; cui < dwarf2_per_objfile->n_comp_units; ++cui)
+ for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
{
- dwarf2_per_cu_data *per_cu = dw2_get_cutu (dwarf2_per_objfile, cui);
const auto insertpair
= debug_info_offset_to_per_cu.emplace (per_cu->sect_off, per_cu);
if (!insertpair.second)
/* A helper function that reads the .gdb_index from SECTION and fills
in MAP. FILENAME is the name of the file containing the section;
- it is used for error reporting. DEPRECATED_OK is nonzero if it is
+ it is used for error reporting. DEPRECATED_OK is true if it is
ok to use deprecated sections.
CU_LIST, CU_LIST_ELEMENTS, TYPES_LIST, and TYPES_LIST_ELEMENTS are
Returns 1 if all went well, 0 otherwise. */
-static int
-read_index_from_section (struct objfile *objfile,
- const char *filename,
- int deprecated_ok,
- struct dwarf2_section_info *section,
- struct mapped_index *map,
- const gdb_byte **cu_list,
- offset_type *cu_list_elements,
- const gdb_byte **types_list,
- offset_type *types_list_elements)
+static bool
+read_gdb_index_from_section (struct objfile *objfile,
+ const char *filename,
+ bool deprecated_ok,
+ struct dwarf2_section_info *section,
+ struct mapped_index *map,
+ const gdb_byte **cu_list,
+ offset_type *cu_list_elements,
+ const gdb_byte **types_list,
+ offset_type *types_list_elements)
{
const gdb_byte *addr;
offset_type version;
return 0;
map->version = version;
- map->total_size = section->size;
metadata = (offset_type *) (addr + sizeof (offset_type));
elements of all the CUs and return 1. Otherwise, return 0. */
static int
-dwarf2_read_index (struct objfile *objfile)
+dwarf2_read_gdb_index (struct dwarf2_per_objfile *dwarf2_per_objfile)
{
- struct mapped_index local_map, *map;
const gdb_byte *cu_list, *types_list, *dwz_list = NULL;
offset_type cu_list_elements, types_list_elements, dwz_list_elements = 0;
struct dwz_file *dwz;
- struct dwarf2_per_objfile *dwarf2_per_objfile
- = get_dwarf2_per_objfile (objfile);
+ struct objfile *objfile = dwarf2_per_objfile->objfile;
- if (!read_index_from_section (objfile, objfile_name (objfile),
- use_deprecated_index_sections,
- &dwarf2_per_objfile->gdb_index, &local_map,
- &cu_list, &cu_list_elements,
- &types_list, &types_list_elements))
+ std::unique_ptr<struct mapped_index> map (new struct mapped_index);
+ if (!read_gdb_index_from_section (objfile, objfile_name (objfile),
+ use_deprecated_index_sections,
+ &dwarf2_per_objfile->gdb_index, map.get (),
+ &cu_list, &cu_list_elements,
+ &types_list, &types_list_elements))
return 0;
/* Don't use the index if it's empty. */
- if (local_map.symbol_table.empty ())
+ if (map->symbol_table.empty ())
return 0;
/* If there is a .dwz file, read it so we can get its CU list as
const gdb_byte *dwz_types_ignore;
offset_type dwz_types_elements_ignore;
- if (!read_index_from_section (objfile, bfd_get_filename (dwz->dwz_bfd),
- 1,
- &dwz->gdb_index, &dwz_map,
- &dwz_list, &dwz_list_elements,
- &dwz_types_ignore,
- &dwz_types_elements_ignore))
+ if (!read_gdb_index_from_section (objfile,
+ bfd_get_filename (dwz->dwz_bfd), 1,
+ &dwz->gdb_index, &dwz_map,
+ &dwz_list, &dwz_list_elements,
+ &dwz_types_ignore,
+ &dwz_types_elements_ignore))
{
warning (_("could not read '.gdb_index' section from %s; skipping"),
bfd_get_filename (dwz->dwz_bfd));
}
}
- create_cus_from_index (objfile, cu_list, cu_list_elements, dwz_list,
- dwz_list_elements);
+ create_cus_from_index (dwarf2_per_objfile, cu_list, cu_list_elements,
+ dwz_list, dwz_list_elements);
if (types_list_elements)
{
section = VEC_index (dwarf2_section_info_def,
dwarf2_per_objfile->types, 0);
- create_signatured_type_table_from_index (objfile, section, types_list,
- types_list_elements);
+ create_signatured_type_table_from_index (dwarf2_per_objfile, section,
+ types_list, types_list_elements);
}
- create_addrmap_from_index (dwarf2_per_objfile, &local_map);
-
- map = XOBNEW (&objfile->objfile_obstack, struct mapped_index);
- map = new (map) mapped_index ();
- *map = local_map;
+ create_addrmap_from_index (dwarf2_per_objfile, map.get ());
- dwarf2_per_objfile->index_table = map;
+ dwarf2_per_objfile->index_table = std::move (map);
dwarf2_per_objfile->using_index = 1;
dwarf2_per_objfile->quick_file_names_table =
- create_quick_file_names_table (dwarf2_per_objfile->n_comp_units);
+ create_quick_file_names_table (dwarf2_per_objfile->all_comp_units.size ());
return 1;
}
{
struct dwarf2_per_objfile *dwarf2_per_objfile
= get_dwarf2_per_objfile (objfile);
- int index = dwarf2_per_objfile->n_comp_units - 1;
- dwarf2_per_cu_data *dwarf_cu = dw2_get_cutu (dwarf2_per_objfile, index);
- compunit_symtab *cust = dw2_instantiate_symtab (dwarf_cu);
+ dwarf2_per_cu_data *dwarf_cu = dwarf2_per_objfile->all_comp_units.back ();
+ compunit_symtab *cust = dw2_instantiate_symtab (dwarf_cu, false);
if (cust == NULL)
return NULL;
/* This may expand more than one symtab, and we want to iterate over
all of them. */
- dw2_instantiate_symtab (per_cu);
+ dw2_instantiate_symtab (per_cu, false);
return iterate_over_some_symtabs (name, real_path, objfile->compunit_symtabs,
last_made, callback);
/* The rule is CUs specify all the files, including those used by
any TU, so there's no need to scan TUs here. */
- for (int i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
+ for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
{
- int j;
- struct dwarf2_per_cu_data *per_cu = dw2_get_cu (dwarf2_per_objfile, i);
- struct quick_file_names *file_data;
-
/* We only need to look at symtabs not already expanded. */
if (per_cu->v.quick->compunit_symtab)
continue;
- file_data = dw2_get_file_names (per_cu);
+ quick_file_names *file_data = dw2_get_file_names (per_cu);
if (file_data == NULL)
continue;
- for (j = 0; j < file_data->num_file_names; ++j)
+ for (int j = 0; j < file_data->num_file_names; ++j)
{
const char *this_name = file_data->file_names[j];
const char *this_real_name;
iter->next = 0;
iter->global_seen = 0;
- mapped_index *index = dwarf2_per_objfile->index_table;
+ mapped_index *index = dwarf2_per_objfile->index_table.get ();
/* index is NULL if OBJF_READNOW. */
if (index != NULL && find_slot_in_mapped_hash (index, name, &iter->vec))
offset_type cu_index_and_attrs =
MAYBE_SWAP (iter->vec[iter->next + 1]);
offset_type cu_index = GDB_INDEX_CU_VALUE (cu_index_and_attrs);
- struct dwarf2_per_cu_data *per_cu;
int want_static = iter->block_index != GLOBAL_BLOCK;
/* This value is only valid for index versions >= 7. */
int is_static = GDB_INDEX_SYMBOL_STATIC_VALUE (cu_index_and_attrs);
&& symbol_kind != GDB_INDEX_SYMBOL_KIND_NONE);
/* Don't crash on bad data. */
- if (cu_index >= (dwarf2_per_objfile->n_comp_units
- + dwarf2_per_objfile->n_type_units))
+ if (cu_index >= (dwarf2_per_objfile->all_comp_units.size ()
+ + dwarf2_per_objfile->all_type_units.size ()))
{
- complaint (&symfile_complaints,
- _(".gdb_index entry has bad CU index"
+ complaint (_(".gdb_index entry has bad CU index"
" [in module %s]"),
objfile_name (dwarf2_per_objfile->objfile));
continue;
}
- per_cu = dw2_get_cutu (dwarf2_per_objfile, cu_index);
+ dwarf2_per_cu_data *per_cu = dwarf2_per_objfile->get_cutu (cu_index);
/* Skip if already read in. */
if (per_cu->v.quick->compunit_symtab)
while ((per_cu = dw2_symtab_iter_next (&iter)) != NULL)
{
struct symbol *sym, *with_opaque = NULL;
- struct compunit_symtab *stab = dw2_instantiate_symtab (per_cu);
+ struct compunit_symtab *stab = dw2_instantiate_symtab (per_cu, false);
const struct blockvector *bv = COMPUNIT_BLOCKVECTOR (stab);
struct block *block = BLOCKVECTOR_BLOCK (bv, block_index);
{
struct dwarf2_per_objfile *dwarf2_per_objfile
= get_dwarf2_per_objfile (objfile);
- int total = dwarf2_per_objfile->n_comp_units + dwarf2_per_objfile->n_type_units;
+ int total = (dwarf2_per_objfile->all_comp_units.size ()
+ + dwarf2_per_objfile->all_type_units.size ());
int count = 0;
for (int i = 0; i < total; ++i)
{
- struct dwarf2_per_cu_data *per_cu = dw2_get_cutu (dwarf2_per_objfile, i);
+ dwarf2_per_cu_data *per_cu = dwarf2_per_objfile->get_cutu (i);
if (!per_cu->v.quick->compunit_symtab)
++count;
func_name);
while ((per_cu = dw2_symtab_iter_next (&iter)) != NULL)
- dw2_instantiate_symtab (per_cu);
+ dw2_instantiate_symtab (per_cu, false);
}
{
struct dwarf2_per_objfile *dwarf2_per_objfile
= get_dwarf2_per_objfile (objfile);
- int total_units = (dwarf2_per_objfile->n_comp_units
- + dwarf2_per_objfile->n_type_units);
+ int total_units = (dwarf2_per_objfile->all_comp_units.size ()
+ + dwarf2_per_objfile->all_type_units.size ());
for (int i = 0; i < total_units; ++i)
{
- struct dwarf2_per_cu_data *per_cu
- = dw2_get_cutu (dwarf2_per_objfile, i);
+ dwarf2_per_cu_data *per_cu = dwarf2_per_objfile->get_cutu (i);
- dw2_instantiate_symtab (per_cu);
+ /* We don't want to directly expand a partial CU, because if we
+ read it with the wrong language, then assertion failures can
+ be triggered later on. See PR symtab/23010. So, tell
+ dw2_instantiate_symtab to skip partial CUs -- any important
+ partial CU will be read via DW_TAG_imported_unit anyway. */
+ dw2_instantiate_symtab (per_cu, true);
}
}
There can be an order of magnitude (or more) more type units
than comp units, and we avoid them if we can. */
- for (int i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
+ for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
{
- int j;
- struct dwarf2_per_cu_data *per_cu = dw2_get_cutu (dwarf2_per_objfile, i);
- struct quick_file_names *file_data;
-
/* We only need to look at symtabs not already expanded. */
if (per_cu->v.quick->compunit_symtab)
continue;
- file_data = dw2_get_file_names (per_cu);
+ quick_file_names *file_data = dw2_get_file_names (per_cu);
if (file_data == NULL)
continue;
- for (j = 0; j < file_data->num_file_names; ++j)
+ for (int j = 0; j < file_data->num_file_names; ++j)
{
const char *this_fullname = file_data->file_names[j];
if (filename_cmp (this_fullname, fullname) == 0)
{
- dw2_instantiate_symtab (per_cu);
+ dw2_instantiate_symtab (per_cu, false);
break;
}
}
DISABLE_COPY_AND_ASSIGN (mock_mapped_index);
/* Return the number of names in the symbol table. */
- virtual size_t symbol_name_count () const
+ size_t symbol_name_count () const override
{
return m_symbol_table.size ();
}
/* Get the name of the symbol at IDX in the symbol table. */
- virtual const char *symbol_name_at (offset_type idx) const
+ const char *symbol_name_at (offset_type idx) const override
{
return m_symbol_table[idx];
}
bool symtab_was_null
= (per_cu->v.quick->compunit_symtab == NULL);
- dw2_instantiate_symtab (per_cu);
+ dw2_instantiate_symtab (per_cu, false);
if (expansion_notify != NULL
&& symtab_was_null
vec_len = MAYBE_SWAP (vec[0]);
for (vec_idx = 0; vec_idx < vec_len; ++vec_idx)
{
- struct dwarf2_per_cu_data *per_cu;
offset_type cu_index_and_attrs = MAYBE_SWAP (vec[vec_idx + 1]);
/* This value is only valid for index versions >= 7. */
int is_static = GDB_INDEX_SYMBOL_STATIC_VALUE (cu_index_and_attrs);
}
/* Don't crash on bad data. */
- if (cu_index >= (dwarf2_per_objfile->n_comp_units
- + dwarf2_per_objfile->n_type_units))
+ if (cu_index >= (dwarf2_per_objfile->all_comp_units.size ()
+ + dwarf2_per_objfile->all_type_units.size ()))
{
- complaint (&symfile_complaints,
- _(".gdb_index entry has bad CU index"
+ complaint (_(".gdb_index entry has bad CU index"
" [in module %s]"),
objfile_name (dwarf2_per_objfile->objfile));
continue;
}
- per_cu = dw2_get_cutu (dwarf2_per_objfile, cu_index);
+ dwarf2_per_cu_data *per_cu = dwarf2_per_objfile->get_cutu (cu_index);
dw2_expand_symtabs_matching_one (per_cu, file_matcher,
expansion_notify);
}
/* The rule is CUs specify all the files, including those used by
any TU, so there's no need to scan TUs here. */
- for (int i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
+ for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
{
- int j;
- struct dwarf2_per_cu_data *per_cu = dw2_get_cu (dwarf2_per_objfile, i);
- struct quick_file_names *file_data;
- void **slot;
-
QUIT;
per_cu->v.quick->mark = 0;
if (per_cu->v.quick->compunit_symtab)
continue;
- file_data = dw2_get_file_names (per_cu);
+ quick_file_names *file_data = dw2_get_file_names (per_cu);
if (file_data == NULL)
continue;
continue;
}
- for (j = 0; j < file_data->num_file_names; ++j)
+ for (int j = 0; j < file_data->num_file_names; ++j)
{
const char *this_real_name;
}
}
- slot = htab_find_slot (per_cu->v.quick->mark
- ? visited_found.get ()
- : visited_not_found.get (),
- file_data, INSERT);
+ void **slot = htab_find_slot (per_cu->v.quick->mark
+ ? visited_found.get ()
+ : visited_not_found.get (),
+ file_data, INSERT);
*slot = file_data;
}
}
paddress (get_objfile_arch (objfile), pc));
result
- = recursively_find_pc_sect_compunit_symtab (dw2_instantiate_symtab (data),
+ = recursively_find_pc_sect_compunit_symtab (dw2_instantiate_symtab (data,
+ false),
pc);
gdb_assert (result != NULL);
return result;
by any TU, so there's no need to scan TUs here. We can
ignore file names coming from already-expanded CUs. */
- for (int i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
+ for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
{
- dwarf2_per_cu_data *per_cu = dw2_get_cutu (dwarf2_per_objfile, i);
-
if (per_cu->v.quick->compunit_symtab)
{
void **slot = htab_find_slot (visited.get (),
}
}
- for (int i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
+ for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
{
- dwarf2_per_cu_data *per_cu = dw2_get_cu (dwarf2_per_objfile, i);
- struct quick_file_names *file_data;
- void **slot;
-
/* We only need to look at symtabs not already expanded. */
if (per_cu->v.quick->compunit_symtab)
continue;
- file_data = dw2_get_file_names (per_cu);
+ quick_file_names *file_data = dw2_get_file_names (per_cu);
if (file_data == NULL)
continue;
- slot = htab_find_slot (visited.get (), file_data, INSERT);
+ void **slot = htab_find_slot (visited.get (), file_data, INSERT);
if (*slot)
{
/* Already visited. */
create_cus_from_debug_names_list (struct dwarf2_per_objfile *dwarf2_per_objfile,
const mapped_debug_names &map,
dwarf2_section_info §ion,
- bool is_dwz, int base_offset)
+ bool is_dwz)
{
sect_offset sect_off_prev;
for (uint32_t i = 0; i <= map.cu_count; ++i)
if (i >= 1)
{
const ULONGEST length = sect_off_next - sect_off_prev;
- dwarf2_per_objfile->all_comp_units[base_offset + (i - 1)]
+ dwarf2_per_cu_data *per_cu
= create_cu_from_index_list (dwarf2_per_objfile, §ion, is_dwz,
sect_off_prev, length);
+ dwarf2_per_objfile->all_comp_units.push_back (per_cu);
}
sect_off_prev = sect_off_next;
}
const mapped_debug_names &map,
const mapped_debug_names &dwz_map)
{
- struct objfile *objfile = dwarf2_per_objfile->objfile;
-
- dwarf2_per_objfile->n_comp_units = map.cu_count + dwz_map.cu_count;
- dwarf2_per_objfile->all_comp_units
- = XOBNEWVEC (&objfile->objfile_obstack, struct dwarf2_per_cu_data *,
- dwarf2_per_objfile->n_comp_units);
+ gdb_assert (dwarf2_per_objfile->all_comp_units.empty ());
+ dwarf2_per_objfile->all_comp_units.reserve (map.cu_count + dwz_map.cu_count);
create_cus_from_debug_names_list (dwarf2_per_objfile, map,
dwarf2_per_objfile->info,
- false /* is_dwz */,
- 0 /* base_offset */);
+ false /* is_dwz */);
if (dwz_map.cu_count == 0)
return;
dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
create_cus_from_debug_names_list (dwarf2_per_objfile, dwz_map, dwz->info,
- true /* is_dwz */,
- map.cu_count /* base_offset */);
+ true /* is_dwz */);
}
/* Read .debug_names. If everything went ok, initialize the "quick"
static bool
dwarf2_read_debug_names (struct dwarf2_per_objfile *dwarf2_per_objfile)
{
- mapped_debug_names local_map (dwarf2_per_objfile);
+ std::unique_ptr<mapped_debug_names> map
+ (new mapped_debug_names (dwarf2_per_objfile));
mapped_debug_names dwz_map (dwarf2_per_objfile);
struct objfile *objfile = dwarf2_per_objfile->objfile;
if (!read_debug_names_from_section (objfile, objfile_name (objfile),
&dwarf2_per_objfile->debug_names,
- local_map))
+ *map))
return false;
/* Don't use the index if it's empty. */
- if (local_map.name_count == 0)
+ if (map->name_count == 0)
return false;
/* If there is a .dwz file, read it so we can get its CU list as
}
}
- create_cus_from_debug_names (dwarf2_per_objfile, local_map, dwz_map);
+ create_cus_from_debug_names (dwarf2_per_objfile, *map, dwz_map);
- if (local_map.tu_count != 0)
+ if (map->tu_count != 0)
{
/* We can only handle a single .debug_types when we have an
index. */
dwarf2_per_objfile->types, 0);
create_signatured_type_table_from_debug_names
- (dwarf2_per_objfile, local_map, section, &dwarf2_per_objfile->abbrev);
+ (dwarf2_per_objfile, *map, section, &dwarf2_per_objfile->abbrev);
}
create_addrmap_from_aranges (dwarf2_per_objfile,
&dwarf2_per_objfile->debug_aranges);
- dwarf2_per_objfile->debug_names_table.reset
- (new mapped_debug_names (dwarf2_per_objfile));
- *dwarf2_per_objfile->debug_names_table = std::move (local_map);
+ dwarf2_per_objfile->debug_names_table = std::move (map);
dwarf2_per_objfile->using_index = 1;
dwarf2_per_objfile->quick_file_names_table =
- create_quick_file_names_table (dwarf2_per_objfile->n_comp_units);
+ create_quick_file_names_table (dwarf2_per_objfile->all_comp_units.size ());
return true;
}
--namei;
if (namei >= map.name_count)
{
- complaint (&symfile_complaints,
- _("Wrong .debug_names with name index %u but name_count=%u "
+ complaint (_("Wrong .debug_names with name index %u but name_count=%u "
"[in module %s]"),
namei, map.name_count,
objfile_name (map.dwarf2_per_objfile->objfile));
#if 0 /* An expensive sanity check. */
if (namei_full_hash != dwarf5_djb_hash (namei_string))
{
- complaint (&symfile_complaints,
- _("Wrong .debug_names hash for string at index %u "
+ complaint (_("Wrong .debug_names hash for string at index %u "
"[in module %s]"),
namei, objfile_name (dwarf2_per_objfile->objfile));
return NULL;
{
if (namei >= map.name_count)
{
- complaint (&symfile_complaints,
- _("Wrong .debug_names with name index %u but name_count=%u "
+ complaint (_("Wrong .debug_names with name index %u but name_count=%u "
"[in module %s]"),
namei, map.name_count,
objfile_name (map.dwarf2_per_objfile->objfile));
const auto indexval_it = m_map.abbrev_map.find (abbrev);
if (indexval_it == m_map.abbrev_map.cend ())
{
- complaint (&symfile_complaints,
- _("Wrong .debug_names undefined abbrev code %s "
+ complaint (_("Wrong .debug_names undefined abbrev code %s "
"[in module %s]"),
pulongest (abbrev), objfile_name (objfile));
return NULL;
m_addr += bytes_read;
break;
default:
- complaint (&symfile_complaints,
- _("Unsupported .debug_names form %s [in module %s]"),
+ complaint (_("Unsupported .debug_names form %s [in module %s]"),
dwarf_form_name (attr.form),
objfile_name (objfile));
return NULL;
{
case DW_IDX_compile_unit:
/* Don't crash on bad data. */
- if (ull >= dwarf2_per_objfile->n_comp_units)
+ if (ull >= dwarf2_per_objfile->all_comp_units.size ())
{
- complaint (&symfile_complaints,
- _(".debug_names entry has bad CU index %s"
+ complaint (_(".debug_names entry has bad CU index %s"
" [in module %s]"),
pulongest (ull),
objfile_name (dwarf2_per_objfile->objfile));
continue;
}
- per_cu = dw2_get_cutu (dwarf2_per_objfile, ull);
+ per_cu = dwarf2_per_objfile->get_cutu (ull);
break;
case DW_IDX_type_unit:
/* Don't crash on bad data. */
- if (ull >= dwarf2_per_objfile->n_type_units)
+ if (ull >= dwarf2_per_objfile->all_type_units.size ())
{
- complaint (&symfile_complaints,
- _(".debug_names entry has bad TU index %s"
+ complaint (_(".debug_names entry has bad TU index %s"
" [in module %s]"),
pulongest (ull),
objfile_name (dwarf2_per_objfile->objfile));
continue;
}
- per_cu = dw2_get_cutu (dwarf2_per_objfile,
- dwarf2_per_objfile->n_comp_units + ull);
+ per_cu = &dwarf2_per_objfile->get_tu (ull)->per_cu;
break;
case DW_IDX_GNU_internal:
if (!m_map.augmentation_is_gdb)
while ((per_cu = iter.next ()) != NULL)
{
struct symbol *sym, *with_opaque = NULL;
- struct compunit_symtab *stab = dw2_instantiate_symtab (per_cu);
+ struct compunit_symtab *stab = dw2_instantiate_symtab (per_cu, false);
const struct blockvector *bv = COMPUNIT_BLOCKVECTOR (stab);
struct block *block = BLOCKVECTOR_BLOCK (bv, block_index);
struct dwarf2_per_cu_data *per_cu;
while ((per_cu = iter.next ()) != NULL)
- dw2_instantiate_symtab (per_cu);
+ dw2_instantiate_symtab (per_cu, false);
}
}
expanded anyway. */
if ((objfile->flags & OBJF_READNOW))
{
- int i;
-
dwarf2_per_objfile->using_index = 1;
create_all_comp_units (dwarf2_per_objfile);
create_all_type_units (dwarf2_per_objfile);
- dwarf2_per_objfile->quick_file_names_table =
- create_quick_file_names_table (dwarf2_per_objfile->n_comp_units);
+ dwarf2_per_objfile->quick_file_names_table
+ = create_quick_file_names_table
+ (dwarf2_per_objfile->all_comp_units.size ());
- for (i = 0; i < (dwarf2_per_objfile->n_comp_units
- + dwarf2_per_objfile->n_type_units); ++i)
+ for (int i = 0; i < (dwarf2_per_objfile->all_comp_units.size ()
+ + dwarf2_per_objfile->all_type_units.size ()); ++i)
{
- dwarf2_per_cu_data *per_cu = dw2_get_cutu (dwarf2_per_objfile, i);
+ dwarf2_per_cu_data *per_cu = dwarf2_per_objfile->get_cutu (i);
per_cu->v.quick = OBSTACK_ZALLOC (&objfile->objfile_obstack,
struct dwarf2_per_cu_quick_data);
return true;
}
- if (dwarf2_read_index (objfile))
+ if (dwarf2_read_gdb_index (dwarf2_per_objfile))
{
*index_kind = dw_index_kind::GDB_INDEX;
return true;
cu_header->offset_size = (bytes_read == 4) ? 4 : 8;
info_ptr += bytes_read;
cu_header->version = read_2_bytes (abfd, info_ptr);
+ if (cu_header->version < 2 || cu_header->version > 5)
+ error (_("Dwarf Error: wrong version in compilation unit header "
+ "(is %d, should be 2, 3, 4 or 5) [in module %s]"),
+ cu_header->version, filename);
info_ptr += 2;
if (cu_header->version < 5)
switch (section_kind)
{
const char *filename = get_section_file_name (section);
- if (header->version < 2 || header->version > 5)
- error (_("Dwarf Error: wrong version in compilation unit header "
- "(is %d, should be 2, 3, 4 or 5) [in module %s]"), header->version,
- filename);
-
if (to_underlying (header->abbrev_sect_off)
>= dwarf2_section_size (dwarf2_per_objfile->objfile, abbrev_section))
error (_("Dwarf Error: bad offset (%s) in compilation unit header "
add_signatured_type_cu_to_table (void **slot, void *datum)
{
struct signatured_type *sigt = (struct signatured_type *) *slot;
- struct signatured_type ***datap = (struct signatured_type ***) datum;
+ std::vector<signatured_type *> *all_type_units
+ = (std::vector<signatured_type *> *) datum;
- **datap = sigt;
- ++*datap;
+ all_type_units->push_back (sigt);
return 1;
}
dup_sect_off = dup_tu->per_cu.sect_off;
}
- complaint (&symfile_complaints,
- _("debug type entry at offset %s is duplicate to"
+ complaint (_("debug type entry at offset %s is duplicate to"
" the entry at offset %s, signature %s"),
sect_offset_str (sect_off), sect_offset_str (dup_sect_off),
hex_string (header.signature));
create_all_type_units (struct dwarf2_per_objfile *dwarf2_per_objfile)
{
htab_t types_htab = NULL;
- struct signatured_type **iter;
create_debug_type_hash_table (dwarf2_per_objfile, NULL,
&dwarf2_per_objfile->info, types_htab,
dwarf2_per_objfile->signatured_types = types_htab;
- dwarf2_per_objfile->n_type_units
- = dwarf2_per_objfile->n_allocated_type_units
- = htab_elements (types_htab);
- 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_type_units);
+ gdb_assert (dwarf2_per_objfile->all_type_units.empty ());
+ dwarf2_per_objfile->all_type_units.reserve (htab_elements (types_htab));
+
+ htab_traverse_noresize (types_htab, add_signatured_type_cu_to_table,
+ &dwarf2_per_objfile->all_type_units);
return 1;
}
void **slot)
{
struct objfile *objfile = dwarf2_per_objfile->objfile;
- int n_type_units = dwarf2_per_objfile->n_type_units;
- struct signatured_type *sig_type;
- gdb_assert (n_type_units <= dwarf2_per_objfile->n_allocated_type_units);
- ++n_type_units;
- if (n_type_units > dwarf2_per_objfile->n_allocated_type_units)
- {
- if (dwarf2_per_objfile->n_allocated_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
- = 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;
+ if (dwarf2_per_objfile->all_type_units.size ()
+ == dwarf2_per_objfile->all_type_units.capacity ())
+ ++dwarf2_per_objfile->tu_stats.nr_all_type_units_reallocs;
+
+ signatured_type *sig_type = OBSTACK_ZALLOC (&objfile->objfile_obstack,
+ struct signatured_type);
- sig_type = OBSTACK_ZALLOC (&objfile->objfile_obstack,
- struct signatured_type);
- dwarf2_per_objfile->all_type_units[n_type_units - 1] = sig_type;
+ dwarf2_per_objfile->all_type_units.push_back (sig_type);
sig_type->signature = sig;
sig_type->per_cu.is_debug_types = 1;
if (dwarf2_per_objfile->using_index)
init_cutu_and_read_dies (struct dwarf2_per_cu_data *this_cu,
struct abbrev_table *abbrev_table,
int use_existing_cu, int keep,
+ bool skip_partial,
die_reader_func_ftype *die_reader_func,
void *data)
{
init_cu_die_reader (&reader, cu, section, NULL, abbrev_table);
info_ptr = read_full_die (&reader, &comp_unit_die, info_ptr, &has_children);
+ if (skip_partial && comp_unit_die->tag == DW_TAG_partial_unit)
+ return;
+
/* If we are in a DWO stub, process it and then read in the "real" CU/TU
from the DWO file. read_cutu_die_from_dwo will allocate the abbreviation
table from the DWO file and pass the ownership over to us. It will be
if (has_children)
{
- complaint (&symfile_complaints,
- _("compilation unit with DW_AT_GNU_dwo_name"
+ complaint (_("compilation unit with DW_AT_GNU_dwo_name"
" has children (offset %s) [in module %s]"),
sect_offset_str (this_cu->sect_off),
bfd_get_filename (abfd));
free_one_cached_comp_unit (this_cu);
if (this_cu->is_debug_types)
- init_cutu_and_read_dies (this_cu, NULL, 0, 0, build_type_psymtabs_reader,
- NULL);
+ init_cutu_and_read_dies (this_cu, NULL, 0, 0, false,
+ build_type_psymtabs_reader, NULL);
else
{
process_psymtab_comp_unit_data info;
info.want_partial_unit = want_partial_unit;
info.pretend_language = pretend_language;
- init_cutu_and_read_dies (this_cu, NULL, 0, 0,
+ init_cutu_and_read_dies (this_cu, NULL, 0, 0, false,
process_psymtab_comp_unit_reader, &info);
}
struct tu_abbrev_offset
{
- struct signatured_type *sig_type;
+ tu_abbrev_offset (signatured_type *sig_type_, sect_offset abbrev_offset_)
+ : sig_type (sig_type_), abbrev_offset (abbrev_offset_)
+ {}
+
+ signatured_type *sig_type;
sect_offset abbrev_offset;
};
struct tu_stats *tu_stats = &dwarf2_per_objfile->tu_stats;
abbrev_table_up abbrev_table;
sect_offset abbrev_offset;
- int i;
/* It's up to the caller to not call us multiple times. */
gdb_assert (dwarf2_per_objfile->type_unit_groups == NULL);
- if (dwarf2_per_objfile->n_type_units == 0)
+ if (dwarf2_per_objfile->all_type_units.empty ())
return;
/* TUs typically share abbrev tables, and there can be way more TUs than
/* Sort in a separate table to maintain the order of all_type_units
for .gdb_index: TU indices directly index all_type_units. */
- std::vector<struct tu_abbrev_offset> sorted_by_abbrev
- (dwarf2_per_objfile->n_type_units);
- for (i = 0; i < dwarf2_per_objfile->n_type_units; ++i)
- {
- struct signatured_type *sig_type = dwarf2_per_objfile->all_type_units[i];
+ std::vector<tu_abbrev_offset> sorted_by_abbrev;
+ sorted_by_abbrev.reserve (dwarf2_per_objfile->all_type_units.size ());
+
+ for (signatured_type *sig_type : dwarf2_per_objfile->all_type_units)
+ sorted_by_abbrev.emplace_back
+ (sig_type, read_abbrev_offset (dwarf2_per_objfile,
+ sig_type->per_cu.section,
+ sig_type->per_cu.sect_off));
- sorted_by_abbrev[i].sig_type = sig_type;
- sorted_by_abbrev[i].abbrev_offset =
- read_abbrev_offset (dwarf2_per_objfile,
- sig_type->per_cu.section,
- sig_type->per_cu.sect_off);
- }
std::sort (sorted_by_abbrev.begin (), sorted_by_abbrev.end (),
sort_tu_by_abbrev_offset);
abbrev_offset = (sect_offset) ~(unsigned) 0;
- for (i = 0; i < dwarf2_per_objfile->n_type_units; ++i)
+ for (const tu_abbrev_offset &tu : sorted_by_abbrev)
{
- const struct tu_abbrev_offset *tu = &sorted_by_abbrev[i];
-
/* Switch to the next abbrev table if necessary. */
if (abbrev_table == NULL
- || tu->abbrev_offset != abbrev_offset)
+ || tu.abbrev_offset != abbrev_offset)
{
- abbrev_offset = tu->abbrev_offset;
+ abbrev_offset = tu.abbrev_offset;
abbrev_table =
abbrev_table_read_table (dwarf2_per_objfile,
&dwarf2_per_objfile->abbrev,
++tu_stats->nr_uniq_abbrev_tables;
}
- init_cutu_and_read_dies (&tu->sig_type->per_cu, abbrev_table.get (),
- 0, 0, build_type_psymtabs_reader, NULL);
+ init_cutu_and_read_dies (&tu.sig_type->per_cu, abbrev_table.get (),
+ 0, 0, false, build_type_psymtabs_reader, NULL);
}
}
struct tu_stats *tu_stats = &dwarf2_per_objfile->tu_stats;
fprintf_unfiltered (gdb_stdlog, "Type unit statistics:\n");
- fprintf_unfiltered (gdb_stdlog, " %d TUs\n",
- dwarf2_per_objfile->n_type_units);
+ fprintf_unfiltered (gdb_stdlog, " %zu TUs\n",
+ dwarf2_per_objfile->all_type_units.size ());
fprintf_unfiltered (gdb_stdlog, " %d uniq abbrev tables\n",
tu_stats->nr_uniq_abbrev_tables);
fprintf_unfiltered (gdb_stdlog, " %d symtabs from stmt_list entries\n",
*slot = entry;
/* This does the job that build_type_psymtabs_1 would have done. */
- init_cutu_and_read_dies (&entry->per_cu, NULL, 0, 0,
+ init_cutu_and_read_dies (&entry->per_cu, NULL, 0, 0, false,
build_type_psymtabs_reader, NULL);
return 1;
static void
set_partial_user (struct dwarf2_per_objfile *dwarf2_per_objfile)
{
- int i;
-
- for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
+ for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
{
- struct dwarf2_per_cu_data *per_cu = dw2_get_cutu (dwarf2_per_objfile, i);
struct partial_symtab *pst = per_cu->v.psymtab;
- int j;
if (pst == NULL)
continue;
- for (j = 0; j < pst->number_of_dependencies; ++j)
+ for (int j = 0; j < pst->number_of_dependencies; ++j)
{
/* Set the 'user' field only if it is not already set. */
if (pst->dependencies[j]->user == NULL)
static void
dwarf2_build_psymtabs_hard (struct dwarf2_per_objfile *dwarf2_per_objfile)
{
- int i;
struct objfile *objfile = dwarf2_per_objfile->objfile;
if (dwarf_read_debug)
= make_scoped_restore (&objfile->psymtabs_addrmap,
addrmap_create_mutable (&temp_obstack));
- for (i = 0; i < dwarf2_per_objfile->n_comp_units; ++i)
- {
- struct dwarf2_per_cu_data *per_cu = dw2_get_cutu (dwarf2_per_objfile, i);
-
- process_psymtab_comp_unit (per_cu, 0, language_minimal);
- }
+ for (dwarf2_per_cu_data *per_cu : dwarf2_per_objfile->all_comp_units)
+ process_psymtab_comp_unit (per_cu, 0, language_minimal);
/* This has to wait until we read the CUs, we need the list of DWOs. */
process_skeletonless_type_units (dwarf2_per_objfile);
static void
load_partial_comp_unit (struct dwarf2_per_cu_data *this_cu)
{
- init_cutu_and_read_dies (this_cu, NULL, 1, 1,
+ init_cutu_and_read_dies (this_cu, NULL, 1, 1, false,
load_partial_comp_unit_reader, NULL);
}
read_comp_units_from_section (struct dwarf2_per_objfile *dwarf2_per_objfile,
struct dwarf2_section_info *section,
struct dwarf2_section_info *abbrev_section,
- unsigned int is_dwz,
- int *n_allocated,
- int *n_comp_units,
- struct dwarf2_per_cu_data ***all_comp_units)
+ unsigned int is_dwz)
{
const gdb_byte *info_ptr;
struct objfile *objfile = dwarf2_per_objfile->objfile;
this_cu->dwarf2_per_objfile = dwarf2_per_objfile;
this_cu->section = section;
- if (*n_comp_units == *n_allocated)
- {
- *n_allocated *= 2;
- *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;
+ dwarf2_per_objfile->all_comp_units.push_back (this_cu);
info_ptr = info_ptr + this_cu->length;
}
static void
create_all_comp_units (struct dwarf2_per_objfile *dwarf2_per_objfile)
{
- int n_allocated;
- int n_comp_units;
- struct dwarf2_per_cu_data **all_comp_units;
- struct dwz_file *dwz;
- struct objfile *objfile = dwarf2_per_objfile->objfile;
-
- n_comp_units = 0;
- n_allocated = 10;
- all_comp_units = XNEWVEC (struct dwarf2_per_cu_data *, n_allocated);
-
+ gdb_assert (dwarf2_per_objfile->all_comp_units.empty ());
read_comp_units_from_section (dwarf2_per_objfile, &dwarf2_per_objfile->info,
- &dwarf2_per_objfile->abbrev, 0,
- &n_allocated, &n_comp_units, &all_comp_units);
+ &dwarf2_per_objfile->abbrev, 0);
- dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
+ dwz_file *dwz = dwarf2_get_dwz_file (dwarf2_per_objfile);
if (dwz != NULL)
read_comp_units_from_section (dwarf2_per_objfile, &dwz->info, &dwz->abbrev,
- 1, &n_allocated, &n_comp_units,
- &all_comp_units);
-
- 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);
- dwarf2_per_objfile->n_comp_units = n_comp_units;
+ 1);
}
/* Process all loaded DIEs for compilation unit CU, starting at
/* FIXME drow/2004-04-01: What should we be doing with
function-local names? For partial symbols, we should probably be
ignoring them. */
- complaint (&symfile_complaints,
- _("unhandled containing DIE tag %d for DIE at %s"),
+ complaint (_("unhandled containing DIE tag %d for DIE at %s"),
parent->tag, sect_offset_str (pdi->sect_off));
parent->scope = grandparent_scope;
}
while (pdi)
{
if (pdi->tag != DW_TAG_enumerator || pdi->name == NULL)
- complaint (&symfile_complaints, _("malformed enumerator DIE ignored"));
+ complaint (_("malformed enumerator DIE ignored"));
else
add_partial_symbol (pdi, cu);
pdi = pdi->die_sibling;
{
read_attribute (reader, &attr, &abbrev->attrs[i], info_ptr);
if (attr.form == DW_FORM_ref_addr)
- complaint (&symfile_complaints,
- _("ignoring absolute DW_AT_sibling"));
+ complaint (_("ignoring absolute DW_AT_sibling"));
else
{
sect_offset off = dwarf2_get_ref_die_offset (&attr);
const gdb_byte *sibling_ptr = buffer + to_underlying (off);
if (sibling_ptr < info_ptr)
- complaint (&symfile_complaints,
- _("DW_AT_sibling points backwards"));
+ complaint (_("DW_AT_sibling points backwards"));
else if (sibling_ptr > reader->buffer_end)
dwarf2_section_buffer_overflow_complaint (reader->die_section);
else
return;
}
- dw2_do_instantiate_symtab (per_cu);
+ dw2_do_instantiate_symtab (per_cu, false);
}
/* Trivial hash function for die_info: the hash value of a DIE
static void
load_full_comp_unit (struct dwarf2_per_cu_data *this_cu,
+ bool skip_partial,
enum language pretend_language)
{
gdb_assert (! this_cu->is_debug_types);
- init_cutu_and_read_dies (this_cu, NULL, 1, 1,
+ init_cutu_and_read_dies (this_cu, NULL, 1, 1, skip_partial,
load_full_comp_unit_reader, &pretend_language);
}
return;
gdb_assert (cu->language == language_cplus);
- for (struct delayed_method_info &mi : cu->method_list)
+ for (const delayed_method_info &mi : cu->method_list)
{
const char *physname;
struct fn_fieldlist *fn_flp
struct objfile *objfile
= cu->per_cu->dwarf2_per_objfile->objfile;
if (strcmp (package_name, this_package_name) != 0)
- complaint (&symfile_complaints,
- _("Symtab %s has objects from two different Go packages: %s and %s"),
+ complaint (_("Symtab %s has objects from two different Go packages: %s and %s"),
(symbol_symtab (sym) != NULL
? symtab_to_filename_for_display
(symbol_symtab (sym))
saved_package_name);
struct symbol *sym;
- TYPE_TAG_NAME (type) = TYPE_NAME (type);
-
sym = allocate_symbol (objfile);
SYMBOL_SET_LANGUAGE (sym, language_go, &objfile->objfile_obstack);
SYMBOL_SET_NAMES (sym, saved_package_name,
|| (TYPE_FIELD_LOC_KIND (field_type, index)
!= FIELD_LOC_KIND_BITPOS))
{
- complaint (&symfile_complaints,
- _("Could not parse Rust enum encoding string \"%s\""
+ complaint (_("Could not parse Rust enum encoding string \"%s\""
"[in module %s]"),
TYPE_FIELD_NAME (type, 0),
objfile_name (objfile));
TYPE_FIELDS (union_type)
= (struct field *) TYPE_ZALLOC (type, 3 * sizeof (struct field));
TYPE_LENGTH (union_type) = TYPE_LENGTH (type);
+ set_type_align (union_type, TYPE_RAW_ALIGN (type));
/* Put the discriminant must at index 0. */
TYPE_FIELD_TYPE (union_type, 0) = field_type;
TYPE_CODE (union_type) = TYPE_CODE_UNION;
TYPE_NFIELDS (union_type) = TYPE_NFIELDS (type);
TYPE_LENGTH (union_type) = TYPE_LENGTH (type);
+ set_type_align (union_type, TYPE_RAW_ALIGN (type));
TYPE_FIELDS (union_type) = TYPE_FIELDS (type);
struct type *field_type = TYPE_FIELD_TYPE (union_type, 0);
{
disr_type = TYPE_FIELD_TYPE (type, i);
- if (TYPE_NFIELDS (disr_type) == 0)
+ if (TYPE_CODE (disr_type) != TYPE_CODE_STRUCT)
+ {
+ /* All fields of a true enum will be structs. */
+ return;
+ }
+ else if (TYPE_NFIELDS (disr_type) == 0)
{
/* Could be data-less variant, so keep going. */
+ disr_type = nullptr;
}
else if (strcmp (TYPE_FIELD_NAME (disr_type, 0),
"RUST$ENUM$DISR") != 0)
TYPE_CODE (union_type) = TYPE_CODE_UNION;
TYPE_NFIELDS (union_type) = 1 + TYPE_NFIELDS (type);
TYPE_LENGTH (union_type) = TYPE_LENGTH (type);
+ set_type_align (union_type, TYPE_RAW_ALIGN (type));
TYPE_FIELDS (union_type)
= (struct field *) TYPE_ZALLOC (union_type,
(TYPE_NFIELDS (union_type)
if (iter != discriminant_map.end ())
disc->discriminants[i] = iter->second;
- /* Remove the discriminant field. */
+ /* Remove the discriminant field, if it exists. */
struct type *sub_type = TYPE_FIELD_TYPE (union_type, i);
- --TYPE_NFIELDS (sub_type);
- ++TYPE_FIELDS (sub_type);
+ if (TYPE_NFIELDS (sub_type) > 0)
+ {
+ --TYPE_NFIELDS (sub_type);
+ ++TYPE_FIELDS (sub_type);
+ }
TYPE_FIELD_NAME (union_type, i) = variant_name;
TYPE_NAME (sub_type)
= rust_fully_qualify (&objfile->objfile_obstack,
rust_union_quirks (struct dwarf2_cu *cu)
{
gdb_assert (cu->language == language_rust);
- for (struct type *type : cu->rust_unions)
- quirk_rust_enum (type, cu->per_cu->dwarf2_per_objfile->objfile);
+ for (type *type_ : cu->rust_unions)
+ quirk_rust_enum (type_, cu->per_cu->dwarf2_per_objfile->objfile);
+ /* We don't need this any more. */
+ cu->rust_unions.clear ();
}
/* Return the symtab for PER_CU. This works properly regardless of
static void
process_cu_includes (struct dwarf2_per_objfile *dwarf2_per_objfile)
{
- int ix;
- struct dwarf2_per_cu_data *iter;
-
- for (ix = 0;
- VEC_iterate (dwarf2_per_cu_ptr, dwarf2_per_objfile->just_read_cus,
- ix, iter);
- ++ix)
+ for (dwarf2_per_cu_data *iter : dwarf2_per_objfile->just_read_cus)
{
if (! iter->is_debug_types)
compute_compunit_symtab_includes (iter);
}
- VEC_free (dwarf2_per_cu_ptr, dwarf2_per_objfile->just_read_cus);
+ dwarf2_per_objfile->just_read_cus.clear ();
}
/* Generate full symbol information for PER_CU, whose DIEs have
}
/* Push it for inclusion processing later. */
- VEC_safe_push (dwarf2_per_cu_ptr, dwarf2_per_objfile->just_read_cus, per_cu);
+ dwarf2_per_objfile->just_read_cus.push_back (per_cu);
}
/* Generate full symbol information for type unit PER_CU, whose DIEs have
/* 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, cu->language);
+ load_full_comp_unit (per_cu, false, cu->language);
VEC_safe_push (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs,
per_cu);
cu->processing_has_namespace_info = 1;
if (read_namespace_alias (die, cu))
break;
- /* The declaration is not a global namespace alias: fall through. */
+ /* The declaration is not a global namespace alias. */
+ /* Fall through. */
case DW_TAG_imported_module:
cu->processing_has_namespace_info = 1;
if (die->child != NULL && (die->tag == DW_TAG_imported_declaration
|| cu->language != language_fortran))
- complaint (&symfile_complaints, _("Tag '%s' has unexpected children"),
+ complaint (_("Tag '%s' has unexpected children"),
dwarf_tag_name (die->tag));
read_import_statement (die, cu);
break;
attr = dwarf2_attr (child, DW_AT_type, cu);
if (attr == NULL)
{
- complaint (&symfile_complaints,
- _("template parameter missing DW_AT_type"));
+ complaint (_("template parameter missing DW_AT_type"));
buf.puts ("UNKNOWN_TYPE");
continue;
}
if (child->tag == DW_TAG_template_type_param)
{
- c_print_type (type, "", &buf, -1, 0, &type_print_raw_options);
+ c_print_type (type, "", &buf, -1, 0, cu->language,
+ &type_print_raw_options);
continue;
}
attr = dwarf2_attr (child, DW_AT_const_value, cu);
if (attr == NULL)
{
- complaint (&symfile_complaints,
- _("template parameter missing "
+ complaint (_("template parameter missing "
"DW_AT_const_value"));
buf.puts ("UNKNOWN_VALUE");
continue;
compute DW_AT_linkage_name incorrectly. But in such case
GDB would need to be bug-to-bug compatible. */
- complaint (&symfile_complaints,
- _("Computed physname <%s> does not match demangled <%s> "
+ complaint (_("Computed physname <%s> does not match demangled <%s> "
"(from linkage <%s>) - DIE at %s [in module %s]"),
physname, canon, mangled, sect_offset_str (die->sect_off),
objfile_name (objfile));
if (num == MAX_NESTED_IMPORTED_DECLARATIONS)
{
- complaint (&symfile_complaints,
- _("DIE at %s has too many recursively imported "
+ complaint (_("DIE at %s has too many recursively imported "
"declarations"), sect_offset_str (d->sect_off));
return 0;
}
static struct using_direct **
using_directives (enum language language)
{
- if (language == language_ada && context_stack_depth == 0)
- return &global_using_directives;
+ if (language == language_ada && outermost_context_p ())
+ return get_global_using_directives ();
else
- return &local_using_directives;
+ return get_local_using_directives ();
}
/* Read the import statement specified by the given die and record it. */
import_attr = dwarf2_attr (die, DW_AT_import, cu);
if (import_attr == NULL)
{
- complaint (&symfile_complaints, _("Tag '%s' has no DW_AT_import"),
+ complaint (_("Tag '%s' has no DW_AT_import"),
dwarf_tag_name (die->tag));
return;
}
if (child_die->tag != DW_TAG_imported_declaration)
{
- complaint (&symfile_complaints,
- _("child DW_TAG_imported_declaration expected "
+ complaint (_("child DW_TAG_imported_declaration expected "
"- DIE at %s [in module %s]"),
sect_offset_str (child_die->sect_off),
objfile_name (objfile));
import_attr = dwarf2_attr (child_die, DW_AT_import, cu);
if (import_attr == NULL)
{
- complaint (&symfile_complaints, _("Tag '%s' has no DW_AT_import"),
+ complaint (_("Tag '%s' has no DW_AT_import"),
dwarf_tag_name (child_die->tag));
continue;
}
imported_name = dwarf2_name (imported_die, imported_cu);
if (imported_name == NULL)
{
- complaint (&symfile_complaints,
- _("child DW_TAG_imported_declaration has unknown "
+ complaint (_("child DW_TAG_imported_declaration has unknown "
"imported name - DIE at %s [in module %s]"),
sect_offset_str (child_die->sect_off),
objfile_name (objfile));
if (attr && cu->line_header)
{
if (dwarf2_attr (die, DW_AT_macro_info, cu))
- complaint (&symfile_complaints,
- _("CU refers to both DW_AT_macros and DW_AT_macro_info"));
+ complaint (_("CU refers to both DW_AT_macros and DW_AT_macro_info"));
dwarf_decode_macros (cu, DW_UNSND (attr), 1);
}
attr = dwarf2_attr (comp_unit_die, DW_AT_GNU_dwo_id, cu);
if (attr == NULL)
{
- complaint (&symfile_complaints,
- _("Dwarf Error: debug entry at offset %s is missing"
+ complaint (_("Dwarf Error: debug entry at offset %s is missing"
" its dwo_id [in module %s]"),
sect_offset_str (sect_off), dwo_file->dwo_name);
return;
const struct dwo_unit *dup_cu = (const struct dwo_unit *)*slot;
sect_offset dup_sect_off = dup_cu->sect_off;
- complaint (&symfile_complaints,
- _("debug cu entry at offset %s is duplicate to"
+ complaint (_("debug cu entry at offset %s is duplicate to"
" the entry at offset %s, signature %s"),
sect_offset_str (sect_off), sect_offset_str (dup_sect_off),
hex_string (dwo_unit->signature));
struct dwp_file *dwp_file, int is_debug_types)
{
struct objfile *objfile = dwarf2_per_objfile->objfile;
- bfd *dbfd = dwp_file->dbfd;
+ bfd *dbfd = dwp_file->dbfd.get ();
const gdb_byte *index_ptr, *index_end;
struct dwarf2_section_info *index;
uint32_t version, nr_columns, nr_units, nr_slots;
if (nr_slots != 0 || nr_units != 0
|| (version == 2 && nr_columns != 0))
{
- complaint (&symfile_complaints,
- _("Empty DWP but nr_slots,nr_units,nr_columns not"
+ complaint (_("Empty DWP but nr_slots,nr_units,nr_columns not"
" all zero [in modules %s]"),
dwp_file->name);
}
struct objfile *objfile = dwarf2_per_objfile->objfile;
const struct dwp_hash_table *dwp_htab =
is_debug_types ? dwp_file->tus : dwp_file->cus;
- bfd *dbfd = dwp_file->dbfd;
+ bfd *dbfd = dwp_file->dbfd.get ();
const char *kind = is_debug_types ? "TU" : "CU";
struct dwo_file *dwo_file;
struct dwo_unit *dwo_unit;
struct objfile *objfile = dwarf2_per_objfile->objfile;
const struct dwp_hash_table *dwp_htab =
is_debug_types ? dwp_file->tus : dwp_file->cus;
- bfd *dbfd = dwp_file->dbfd;
+ bfd *dbfd = dwp_file->dbfd.get ();
const char *kind = is_debug_types ? "TU" : "CU";
struct dwo_file *dwo_file;
struct dwo_unit *dwo_unit;
{
const struct dwp_hash_table *dwp_htab =
is_debug_types ? dwp_file->tus : dwp_file->cus;
- bfd *dbfd = dwp_file->dbfd;
+ bfd *dbfd = dwp_file->dbfd.get ();
uint32_t mask = dwp_htab->nr_slots - 1;
uint32_t hash = signature & mask;
uint32_t hash2 = ((signature >> 32) & mask) | 1;
By convention the name of the DWP file is ${objfile}.dwp.
The result is NULL if it can't be found. */
-static struct dwp_file *
+static std::unique_ptr<struct dwp_file>
open_and_init_dwp_file (struct dwarf2_per_objfile *dwarf2_per_objfile)
{
struct objfile *objfile = dwarf2_per_objfile->objfile;
- struct dwp_file *dwp_file;
/* Try to find first .dwp for the binary file before any symbolic links
resolving. */
{
if (dwarf_read_debug)
fprintf_unfiltered (gdb_stdlog, "DWP file not found: %s\n", dwp_name.c_str ());
- return NULL;
+ return std::unique_ptr<dwp_file> ();
}
- dwp_file = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwp_file);
- dwp_file->name = bfd_get_filename (dbfd.get ());
- dwp_file->dbfd = dbfd.release ();
+
+ const char *name = bfd_get_filename (dbfd.get ());
+ std::unique_ptr<struct dwp_file> dwp_file
+ (new struct dwp_file (name, std::move (dbfd)));
/* +1: section 0 is unused */
dwp_file->num_sections = bfd_count_sections (dwp_file->dbfd) + 1;
OBSTACK_CALLOC (&objfile->objfile_obstack,
dwp_file->num_sections, asection *);
- bfd_map_over_sections (dwp_file->dbfd, dwarf2_locate_common_dwp_sections,
- dwp_file);
+ bfd_map_over_sections (dwp_file->dbfd.get (),
+ dwarf2_locate_common_dwp_sections,
+ dwp_file.get ());
- dwp_file->cus = create_dwp_hash_table (dwarf2_per_objfile, dwp_file, 0);
+ dwp_file->cus = create_dwp_hash_table (dwarf2_per_objfile, dwp_file.get (),
+ 0);
- dwp_file->tus = create_dwp_hash_table (dwarf2_per_objfile, dwp_file, 1);
+ dwp_file->tus = create_dwp_hash_table (dwarf2_per_objfile, dwp_file.get (),
+ 1);
/* The DWP file version is stored in the hash table. Oh well. */
if (dwp_file->cus && dwp_file->tus
dwp_file->version = 2;
if (dwp_file->version == 2)
- bfd_map_over_sections (dwp_file->dbfd, dwarf2_locate_v2_dwp_sections,
- dwp_file);
+ bfd_map_over_sections (dwp_file->dbfd.get (),
+ dwarf2_locate_v2_dwp_sections,
+ dwp_file.get ());
dwp_file->loaded_cus = allocate_dwp_loaded_cutus_table (objfile);
dwp_file->loaded_tus = allocate_dwp_loaded_cutus_table (objfile);
= open_and_init_dwp_file (dwarf2_per_objfile);
dwarf2_per_objfile->dwp_checked = 1;
}
- return dwarf2_per_objfile->dwp_file;
+ return dwarf2_per_objfile->dwp_file.get ();
}
/* Subroutine of lookup_dwo_comp_unit, lookup_dwo_type_unit.
if (die->tag != origin_die->tag
&& !(die->tag == DW_TAG_inlined_subroutine
&& origin_die->tag == DW_TAG_subprogram))
- complaint (&symfile_complaints,
- _("DIE %s and its abstract origin %s have different tags"),
+ complaint (_("DIE %s and its abstract origin %s have different tags"),
sect_offset_str (die->sect_off),
sect_offset_str (origin_die->sect_off));
if (child_die->tag != child_origin_die->tag
&& !(child_die->tag == DW_TAG_inlined_subroutine
&& child_origin_die->tag == DW_TAG_subprogram))
- complaint (&symfile_complaints,
- _("Child DIE %s and its abstract origin %s have "
+ complaint (_("Child DIE %s and its abstract origin %s have "
"different tags"),
sect_offset_str (child_die->sect_off),
sect_offset_str (child_origin_die->sect_off));
if (child_origin_die->parent != origin_die)
- complaint (&symfile_complaints,
- _("Child DIE %s and its abstract origin %s have "
+ complaint (_("Child DIE %s and its abstract origin %s have "
"different parents"),
sect_offset_str (child_die->sect_off),
sect_offset_str (child_origin_die->sect_off));
sect_offset *offsets_end = offsets.data () + offsets.size ();
for (offsetp = offsets.data () + 1; offsetp < offsets_end; offsetp++)
if (offsetp[-1] == *offsetp)
- complaint (&symfile_complaints,
- _("Multiple children of DIE %s refer "
+ complaint (_("Multiple children of DIE %s refer "
"to DIE %s as their abstract origin"),
sect_offset_str (die->sect_off), sect_offset_str (*offsetp));
illegal according to the DWARF standard. */
if (name == NULL)
{
- complaint (&symfile_complaints,
- _("missing name for subprogram DIE at %s"),
+ complaint (_("missing name for subprogram DIE at %s"),
sect_offset_str (die->sect_off));
return;
}
{
attr = dwarf2_attr (die, DW_AT_external, cu);
if (!attr || !DW_UNSND (attr))
- complaint (&symfile_complaints,
- _("cannot get low and high bounds "
+ complaint (_("cannot get low and high bounds "
"for subprogram DIE at %s"),
sect_offset_str (die->sect_off));
return;
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;
- local_using_directives = newobj->local_using_directives;
+ set_local_using_directives (newobj->local_using_directives);
/* If we've finished processing a top-level function, subsequent
symbols go in the file symbol list. */
inherit_abstract_dies (die, cu);
newobj = pop_context ();
- if (local_symbols != NULL || local_using_directives != NULL)
+ if (local_symbols != NULL || (*get_local_using_directives ()) != NULL)
{
struct block *block
= finish_block (0, &local_symbols, newobj->old_blocks, NULL,
dwarf2_record_block_ranges (die, block, baseaddr, cu);
}
local_symbols = newobj->locals;
- local_using_directives = newobj->local_using_directives;
+ set_local_using_directives (newobj->local_using_directives);
}
/* Read in DW_TAG_call_site and insert it to CU->call_site_htab. */
}
if (!attr)
{
- complaint (&symfile_complaints,
- _("missing DW_AT_call_return_pc for DW_TAG_call_site "
+ complaint (_("missing DW_AT_call_return_pc for DW_TAG_call_site "
"DIE %s [in module %s]"),
sect_offset_str (die->sect_off), objfile_name (objfile));
return;
slot = htab_find_slot (cu->call_site_htab, &call_site_local, INSERT);
if (*slot != NULL)
{
- complaint (&symfile_complaints,
- _("Duplicate PC %s for DW_TAG_call_site "
+ complaint (_("Duplicate PC %s for DW_TAG_call_site "
"DIE %s [in module %s]"),
paddress (gdbarch, pc), sect_offset_str (die->sect_off),
objfile_name (objfile));
if (child_die->tag != DW_TAG_call_site_parameter
&& child_die->tag != DW_TAG_GNU_call_site_parameter)
{
- complaint (&symfile_complaints,
- _("Tag %d is not DW_TAG_call_site_parameter in "
+ complaint (_("Tag %d is not DW_TAG_call_site_parameter in "
"DW_TAG_call_site child DIE %s [in module %s]"),
child_die->tag, sect_offset_str (child_die->sect_off),
objfile_name (objfile));
TYPE_TAIL_CALL_LIST (func_type) = call_site;
}
else
- complaint (&symfile_complaints,
- _("Cannot find function owning DW_TAG_call_site "
+ complaint (_("Cannot find function owning DW_TAG_call_site "
"DIE %s [in module %s]"),
sect_offset_str (die->sect_off), objfile_name (objfile));
}
if (target_physname == NULL)
target_physname = dwarf2_physname (NULL, target_die, target_cu);
if (target_physname == NULL)
- complaint (&symfile_complaints,
- _("DW_AT_call_target target DIE has invalid "
+ complaint (_("DW_AT_call_target target DIE has invalid "
"physname, for referencing DIE %s [in module %s]"),
sect_offset_str (die->sect_off), objfile_name (objfile));
else
/* DW_AT_entry_pc should be preferred. */
if (dwarf2_get_pc_bounds (target_die, &lowpc, NULL, target_cu, NULL)
<= PC_BOUNDS_INVALID)
- complaint (&symfile_complaints,
- _("DW_AT_call_target target DIE has invalid "
+ complaint (_("DW_AT_call_target target DIE has invalid "
"low pc, for referencing DIE %s [in module %s]"),
sect_offset_str (die->sect_off), objfile_name (objfile));
else
}
}
else
- complaint (&symfile_complaints,
- _("DW_TAG_call_site DW_AT_call_target is neither "
+ complaint (_("DW_TAG_call_site DW_AT_call_target is neither "
"block nor reference, for DIE %s [in module %s]"),
sect_offset_str (die->sect_off), objfile_name (objfile));
/* As DW_OP_GNU_parameter_ref uses CU-relative offset this
binding can be done only inside one CU. Such referenced DIE
therefore cannot be even moved to DW_TAG_partial_unit. */
- complaint (&symfile_complaints,
- _("DW_AT_call_parameter offset is not in CU for "
+ complaint (_("DW_AT_call_parameter offset is not in CU for "
"DW_TAG_call_site child DIE %s [in module %s]"),
sect_offset_str (child_die->sect_off),
objfile_name (objfile));
}
else if (loc == NULL || origin != NULL || !attr_form_is_block (loc))
{
- complaint (&symfile_complaints,
- _("No DW_FORM_block* DW_AT_location for "
+ complaint (_("No DW_FORM_block* DW_AT_location for "
"DW_TAG_call_site child DIE %s [in module %s]"),
sect_offset_str (child_die->sect_off), objfile_name (objfile));
continue;
parameter->kind = CALL_SITE_PARAMETER_FB_OFFSET;
else
{
- complaint (&symfile_complaints,
- _("Only single DW_OP_reg or DW_OP_fbreg is supported "
+ complaint (_("Only single DW_OP_reg or DW_OP_fbreg is supported "
"for DW_FORM_block* DW_AT_location is supported for "
"DW_TAG_call_site child DIE %s "
"[in module %s]"),
attr = dwarf2_attr (child_die, DW_AT_GNU_call_site_value, cu);
if (!attr_form_is_block (attr))
{
- complaint (&symfile_complaints,
- _("No DW_FORM_block* DW_AT_call_value for "
+ complaint (_("No DW_FORM_block* DW_AT_call_value for "
"DW_TAG_call_site child DIE %s [in module %s]"),
sect_offset_str (child_die->sect_off),
objfile_name (objfile));
if (attr)
{
if (!attr_form_is_block (attr))
- complaint (&symfile_complaints,
- _("No DW_FORM_block* DW_AT_call_data_value for "
+ complaint (_("No DW_FORM_block* DW_AT_call_data_value for "
"DW_TAG_call_site child DIE %s [in module %s]"),
sect_offset_str (child_die->sect_off),
objfile_name (objfile));
dwarf2_read_section (objfile, &dwarf2_per_objfile->rnglists);
if (offset >= dwarf2_per_objfile->rnglists.size)
{
- complaint (&symfile_complaints,
- _("Offset %d out of bounds for DW_AT_ranges attribute"),
+ complaint (_("Offset %d out of bounds for DW_AT_ranges attribute"),
offset);
return false;
}
buffer += bytes_read;
break;
default:
- complaint (&symfile_complaints,
- _("Invalid .debug_rnglists data (no base address)"));
+ complaint (_("Invalid .debug_rnglists data (no base address)"));
return false;
}
if (rlet == DW_RLE_end_of_list || overflow)
{
/* We have no valid base address for the ranges
data. */
- complaint (&symfile_complaints,
- _("Invalid .debug_rnglists data (no base address)"));
+ complaint (_("Invalid .debug_rnglists data (no base address)"));
return false;
}
if (range_beginning > range_end)
{
/* Inverted range entries are invalid. */
- complaint (&symfile_complaints,
- _("Invalid .debug_rnglists data (inverted range)"));
+ complaint (_("Invalid .debug_rnglists data (inverted range)"));
return false;
}
if (range_beginning + baseaddr == 0
&& !dwarf2_per_objfile->has_section_at_zero)
{
- complaint (&symfile_complaints,
- _(".debug_rnglists entry has start address of zero"
+ complaint (_(".debug_rnglists entry has start address of zero"
" [in module %s]"), objfile_name (objfile));
continue;
}
if (overflow)
{
- complaint (&symfile_complaints,
- _("Offset %d is not terminated "
+ complaint (_("Offset %d is not terminated "
"for DW_AT_ranges attribute"),
offset);
return false;
dwarf2_read_section (objfile, &dwarf2_per_objfile->ranges);
if (offset >= dwarf2_per_objfile->ranges.size)
{
- complaint (&symfile_complaints,
- _("Offset %d out of bounds for DW_AT_ranges attribute"),
+ complaint (_("Offset %d out of bounds for DW_AT_ranges attribute"),
offset);
return 0;
}
{
/* We have no valid base address for the ranges
data. */
- complaint (&symfile_complaints,
- _("Invalid .debug_ranges data (no base address)"));
+ complaint (_("Invalid .debug_ranges data (no base address)"));
return 0;
}
if (range_beginning > range_end)
{
/* Inverted range entries are invalid. */
- complaint (&symfile_complaints,
- _("Invalid .debug_ranges data (inverted range)"));
+ complaint (_("Invalid .debug_ranges data (inverted range)"));
return 0;
}
if (range_beginning + baseaddr == 0
&& !dwarf2_per_objfile->has_section_at_zero)
{
- complaint (&symfile_complaints,
- _(".debug_ranges entry has start address of zero"
+ complaint (_(".debug_ranges entry has start address of zero"
" [in module %s]"), objfile_name (objfile));
continue;
}
SET_FIELD_BITPOS (*fp, offset * bits_per_byte);
FIELD_BITSIZE (*fp) = 0;
FIELD_TYPE (*fp) = die_type (die, cu);
- FIELD_NAME (*fp) = type_name_no_tag (fp->type);
+ FIELD_NAME (*fp) = TYPE_NAME (fp->type);
}
else if (die->tag == DW_TAG_variant_part)
{
fp.is_protected = 1;
break;
default:
- complaint (&symfile_complaints,
- _("Unhandled DW_AT_accessibility value (%x)"), accessibility);
+ complaint (_("Unhandled DW_AT_accessibility value (%x)"), accessibility);
}
if (die->tag == DW_TAG_typedef)
default:
/* Unknown accessibility. Complain and treat it as public. */
{
- complaint (&symfile_complaints, _("unsupported accessibility %d"),
+ complaint (_("unsupported accessibility %d"),
field.accessibility);
}
break;
fnp->voffset = VOFFSET_STATIC;
}
else
- complaint (&symfile_complaints, _("member function type missing for '%s'"),
+ complaint (_("member function type missing for '%s'"),
dwarf2_full_name (fieldname, die, cu));
/* Get fcontext from DW_AT_containing_type if present. */
if (TYPE_NFIELDS (this_type) == 0
|| !TYPE_FIELD_ARTIFICIAL (this_type, 0))
{
- complaint (&symfile_complaints,
- _("cannot determine context for virtual member "
+ complaint (_("cannot determine context for virtual member "
"function \"%s\" (offset %s)"),
fieldname, sect_offset_str (die->sect_off));
}
if (attr && DW_UNSND (attr))
{
/* GCC does this, as of 2008-08-25; PR debug/37237. */
- complaint (&symfile_complaints,
- _("Member function \"%s\" (offset %s) is virtual "
+ complaint (_("Member function \"%s\" (offset %s) is virtual "
"but the vtable offset is not specified"),
fieldname, sect_offset_str (die->sect_off));
ALLOCATE_CPLUS_STRUCT_TYPE (type);
smash_to_methodptr_type (type, new_type);
}
+/* If the DIE has a DW_AT_alignment attribute, return its value, doing
+ appropriate error checking and issuing complaints if there is a
+ problem. */
+
+static ULONGEST
+get_alignment (struct dwarf2_cu *cu, struct die_info *die)
+{
+ struct attribute *attr = dwarf2_attr (die, DW_AT_alignment, cu);
+
+ if (attr == nullptr)
+ return 0;
+
+ if (!attr_form_is_constant (attr))
+ {
+ 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));
+ return 0;
+ }
+
+ ULONGEST align;
+ if (attr->form == DW_FORM_sdata)
+ {
+ LONGEST val = DW_SND (attr);
+ if (val < 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));
+ return 0;
+ }
+ align = val;
+ }
+ else
+ align = DW_UNSND (attr);
+
+ if (align == 0)
+ {
+ 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));
+ 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));
+ return 0;
+ }
+
+ return align;
+}
+
+/* If the DIE has a DW_AT_alignment attribute, use its value to set
+ the alignment for TYPE. */
+
+static void
+maybe_set_alignment (struct dwarf2_cu *cu, struct die_info *die,
+ struct type *type)
+{
+ if (!set_type_align (type, get_alignment (cu, die)))
+ 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));
+}
/* Called when we find the DIE that starts a structure or union scope
(definition) to create a type for the structure or union. Fill in
if (get_die_type (die, cu) != NULL)
return get_die_type (die, cu);
- TYPE_TAG_NAME (type) = full_name;
- if (die->tag == DW_TAG_structure_type
- || die->tag == DW_TAG_class_type)
- TYPE_NAME (type) = TYPE_TAG_NAME (type);
+ TYPE_NAME (type) = full_name;
}
else
{
/* The name is already allocated along with this objfile, so
we don't need to duplicate it for the type. */
- TYPE_TAG_NAME (type) = name;
- if (die->tag == DW_TAG_class_type)
- TYPE_NAME (type) = TYPE_TAG_NAME (type);
+ TYPE_NAME (type) = name;
}
}
TYPE_LENGTH (type) = 0;
}
+ maybe_set_alignment (cu, die, type);
+
if (producer_is_icc_lt_14 (cu) && (TYPE_LENGTH (type) == 0))
{
/* ICC<14 does not output the required DW_AT_declaration on
/* We don't handle this but we might as well report it if we see
it. */
if (dwarf2_attr (child_die, DW_AT_discr_list, cu) != nullptr)
- complaint (&symfile_complaints,
- _("DW_AT_discr_list is not supported yet"
+ complaint (_("DW_AT_discr_list is not supported yet"
" - DIE at %s [in module %s]"),
sect_offset_str (child_die->sect_off),
objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));
}
else
{
- complaint (&symfile_complaints,
- _("DW_AT_discr does not have DIE reference form"
+ 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));
/* Complain if virtual function table field not found. */
if (i < TYPE_N_BASECLASSES (t))
- complaint (&symfile_complaints,
- _("virtual function table pointer "
+ complaint (_("virtual function table pointer "
"not found when defining class '%s'"),
- TYPE_TAG_NAME (type) ? TYPE_TAG_NAME (type) :
- "");
+ TYPE_NAME (type) ? TYPE_NAME (type) : "");
}
else
{
TYPE_CODE (type) = TYPE_CODE_ENUM;
name = dwarf2_full_name (NULL, die, cu);
if (name != NULL)
- TYPE_TAG_NAME (type) = name;
+ TYPE_NAME (type) = name;
attr = dwarf2_attr (die, DW_AT_type, cu);
if (attr != NULL)
TYPE_LENGTH (type) = 0;
}
+ maybe_set_alignment (cu, die, type);
+
/* The enumeration DIE can be incomplete. In Ada, any type can be
declared as private in the package spec, and then defined only
inside the package body. Such types are known as Taft Amendment
TYPE_UNSIGNED (type) = TYPE_UNSIGNED (TYPE_TARGET_TYPE (type));
if (TYPE_LENGTH (type) == 0)
TYPE_LENGTH (type) = TYPE_LENGTH (TYPE_TARGET_TYPE (type));
+ if (TYPE_RAW_ALIGN (type) == 0
+ && TYPE_RAW_ALIGN (TYPE_TARGET_TYPE (type)) != 0)
+ set_type_align (type, TYPE_RAW_ALIGN (TYPE_TARGET_TYPE (type)));
}
TYPE_DECLARED_CLASS (type) = dwarf2_flag_true_p (die, DW_AT_enum_class, cu);
stride_ok = attr_to_dynamic_prop (attr, die, cu, byte_stride_prop);
if (!stride_ok)
{
- complaint (&symfile_complaints,
- _("unable to read array DW_AT_byte_stride "
+ 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));
if (DW_UNSND (attr) >= TYPE_LENGTH (type))
TYPE_LENGTH (type) = DW_UNSND (attr);
else
- complaint (&symfile_complaints,
- _("DW_AT_byte_size for array type smaller "
+ complaint (_("DW_AT_byte_size for array type smaller "
"than the total size of elements"));
}
if (name)
TYPE_NAME (type) = name;
+ maybe_set_alignment (cu, die, type);
+
/* Install the type in the die. */
set_die_type (die, type, cu);
if (attr)
TYPE_LENGTH (set_type) = DW_UNSND (attr);
+ maybe_set_alignment (cu, die, set_type);
+
return set_die_type (die, set_type, cu);
}
not specified by DWARF. It seems to have been
emitted by gfortran at least as recently as:
http://gcc.gnu.org/bugzilla/show_bug.cgi?id=23057. */
- complaint (&symfile_complaints,
- _("Variable in common block has "
+ complaint (_("Variable in common block has "
"DW_AT_data_member_location "
"- DIE at %s [in module %s]"),
sect_offset_str (child_die->sect_off),
/* Create the type. */
type = init_type (objfile, TYPE_CODE_NAMESPACE, 0, name);
- TYPE_TAG_NAME (type) = TYPE_NAME (type);
return set_die_type (die, type, cu);
}
module_name = dwarf2_name (die, cu);
if (!module_name)
- complaint (&symfile_complaints,
- _("DW_TAG_module has no name, offset %s"),
+ complaint (_("DW_TAG_module has no name, offset %s"),
sect_offset_str (die->sect_off));
type = init_type (objfile, TYPE_CODE_MODULE, 0, module_name);
- /* determine_prefix uses TYPE_TAG_NAME. */
- TYPE_TAG_NAME (type) = TYPE_NAME (type);
-
return set_die_type (die, type, cu);
}
else
addr_class = DW_ADDR_none;
- /* If the pointer size or address class is different than the
- default, create a type variant marked as such and set the
- length accordingly. */
- if (TYPE_LENGTH (type) != byte_size || addr_class != DW_ADDR_none)
+ ULONGEST alignment = get_alignment (cu, die);
+
+ /* If the pointer size, alignment, or address class is different
+ than the default, create a type variant marked as such and set
+ the length accordingly. */
+ if (TYPE_LENGTH (type) != byte_size
+ || (alignment != 0 && TYPE_RAW_ALIGN (type) != 0
+ && alignment != TYPE_RAW_ALIGN (type))
+ || addr_class != DW_ADDR_none)
{
if (gdbarch_address_class_type_flags_p (gdbarch))
{
}
else if (TYPE_LENGTH (type) != byte_size)
{
- complaint (&symfile_complaints,
- _("invalid pointer size %d"), byte_size);
+ complaint (_("invalid pointer size %d"), byte_size);
+ }
+ else if (TYPE_RAW_ALIGN (type) != alignment)
+ {
+ 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));
}
else
{
}
TYPE_LENGTH (type) = byte_size;
+ set_type_align (type, alignment);
return set_die_type (die, type, cu);
}
{
TYPE_LENGTH (type) = cu_header->addr_size;
}
+ maybe_set_alignment (cu, die, type);
return set_die_type (die, type, cu);
}
{
/* Self-referential typedefs are, it seems, not allowed by the DWARF
spec and cause infinite loops in GDB. */
- complaint (&symfile_complaints,
- _("Self-referential DW_TAG_typedef "
+ complaint (_("Self-referential DW_TAG_typedef "
"- DIE at %s [in module %s]"),
sect_offset_str (die->sect_off), objfile_name (objfile));
TYPE_TARGET_TYPE (this_type) = NULL;
name = dwarf2_name (die, cu);
if (!name)
{
- complaint (&symfile_complaints,
- _("DW_AT_name missing from DW_TAG_base_type"));
+ complaint (_("DW_AT_name missing from DW_TAG_base_type"));
}
switch (encoding)
type = builtin_type (arch)->builtin_char32;
else
{
- complaint (&symfile_complaints,
- _("unsupported DW_ATE_UTF bit size: '%d'"),
+ complaint (_("unsupported DW_ATE_UTF bit size: '%d'"),
bits);
type = init_integer_type (objfile, bits, 1, name);
}
break;
default:
- complaint (&symfile_complaints, _("unsupported DW_AT_encoding: '%s'"),
+ complaint (_("unsupported DW_AT_encoding: '%s'"),
dwarf_type_encoding_name (encoding));
type = init_type (objfile, TYPE_CODE_ERROR, bits, name);
break;
if (name && strcmp (name, "char") == 0)
TYPE_NOSIGN (type) = 1;
+ maybe_set_alignment (cu, die, type);
+
return set_die_type (die, type, cu);
}
if (attr)
attr_to_dynamic_prop (attr, die, cu, &low);
else if (!low_default_is_valid)
- complaint (&symfile_complaints, _("Missing DW_AT_lower_bound "
+ 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));
if (attr)
TYPE_LENGTH (range_type) = DW_UNSND (attr);
+ maybe_set_alignment (cu, die, range_type);
+
set_die_type (die, range_type, cu);
/* set_die_type should be already done. */
/* The exception for DW_TAG_typedef with has_children above is
a workaround of GCC PR debug/47510. In the case of this complaint
- type_name_no_tag_or_error will error on such types later.
+ type_name_or_error will error on such types later.
GDB skipped children of DW_TAG_typedef by the shortcut above and then
it could not find the child DIEs referenced later, this is checked
above. In correct DWARF DW_TAG_typedef should have no children. */
if (pdi.tag == DW_TAG_typedef && pdi.has_children)
- complaint (&symfile_complaints,
- _("DW_TAG_typedef has childen - GCC PR debug/47510 bug "
+ complaint (_("DW_TAG_typedef has childen - GCC PR debug/47510 bug "
"- DIE at %s [in module %s]"),
sect_offset_str (pdi.sect_off), objfile_name (objfile));
&& parent_die->has_specification == 0)
{
if (pdi.name == NULL)
- complaint (&symfile_complaints,
- _("malformed enumerator DIE ignored"));
+ complaint (_("malformed enumerator DIE ignored"));
else if (building_psymtab)
add_psymbol_to_list (pdi.name, strlen (pdi.name), 0,
VAR_DOMAIN, LOC_CONST,
/* Ignore absolute siblings, they might point outside of
the current compile unit. */
if (attr.form == DW_FORM_ref_addr)
- complaint (&symfile_complaints,
- _("ignoring absolute DW_AT_sibling"));
+ complaint (_("ignoring absolute DW_AT_sibling"));
else
{
const gdb_byte *buffer = reader->buffer;
const gdb_byte *sibling_ptr = buffer + to_underlying (off);
if (sibling_ptr < info_ptr)
- complaint (&symfile_complaints,
- _("DW_AT_sibling points backwards"));
+ complaint (_("DW_AT_sibling points backwards"));
else if (sibling_ptr > reader->buffer_end)
dwarf2_section_buffer_overflow_complaint (reader->die_section);
else
struct objfile *objfile = dwarf2_per_objfile->objfile;
struct gdbarch *gdbarch = get_objfile_arch (objfile);
- complaint (&symfile_complaints,
- _("DW_AT_low_pc %s is zero "
+ complaint (_("DW_AT_low_pc %s is zero "
"for DIE at %s [in module %s]"),
paddress (gdbarch, lowpc),
sect_offset_str (sect_off),
struct objfile *objfile = dwarf2_per_objfile->objfile;
struct gdbarch *gdbarch = get_objfile_arch (objfile);
- complaint (&symfile_complaints,
- _("DW_AT_low_pc %s is not < DW_AT_high_pc %s "
+ complaint (_("DW_AT_low_pc %s is not < DW_AT_high_pc %s "
"for DIE at %s [in module %s]"),
paddress (gdbarch, lowpc),
paddress (gdbarch, highpc),
&& DW_UNSND (attr) >= 0xffffffff)
{
complaint
- (&symfile_complaints,
- _("Suspicious DW_AT_byte_size value treated as zero instead of %s"),
+ (_("Suspicious DW_AT_byte_size value treated as zero instead of %s"),
hex_string (DW_UNSND (attr)));
DW_UNSND (attr) = 0;
}
|| cu_header->initial_length_size == 12);
if (cu_header->initial_length_size != *bytes_read)
- complaint (&symfile_complaints,
- _("intermixed 32-bit and 64-bit DWARF sections"));
+ complaint (_("intermixed 32-bit and 64-bit DWARF sections"));
*offset_size = (*bytes_read == 4) ? 4 : 8;
return length;
/* Note: We can't use init_cutu_and_read_dies_simple here,
we need addr_base. */
- init_cutu_and_read_dies (per_cu, NULL, 0, 0,
+ init_cutu_and_read_dies (per_cu, NULL, 0, 0, false,
dwarf2_read_addr_index_reader, &aidata);
addr_base = aidata.addr_base;
addr_size = aidata.addr_size;
|| attr->form == DW_FORM_GNU_strp_alt)
str = DW_STRING (attr);
else
- complaint (&symfile_complaints,
- _("string type expected for attribute %s for "
+ 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));
case DW_LNCT_MD5:
break;
default:
- complaint (&symfile_complaints,
- _("Unknown format content type %s"),
+ complaint (_("Unknown format content type %s"),
pulongest (content_type));
}
}
if (section->buffer == NULL)
{
if (cu->dwo_unit && cu->per_cu->is_debug_types)
- complaint (&symfile_complaints, _("missing .debug_line.dwo section"));
+ complaint (_("missing .debug_line.dwo section"));
else
- complaint (&symfile_complaints, _("missing .debug_line section"));
+ complaint (_("missing .debug_line section"));
return 0;
}
{
/* This is a version we don't understand. The format could have
changed in ways we don't handle properly so just punt. */
- complaint (&symfile_complaints,
- _("unsupported version in .debug_line section"));
+ complaint (_("unsupported version in .debug_line section"));
return NULL;
}
if (lh->version >= 5)
line_ptr += 1;
if (segment_selector_size != 0)
{
- complaint (&symfile_complaints,
- _("unsupported segment selector size %u "
+ complaint (_("unsupported segment selector size %u "
"in .debug_line section"),
segment_selector_size);
return NULL;
if (lh->maximum_ops_per_instruction == 0)
{
lh->maximum_ops_per_instruction = 1;
- complaint (&symfile_complaints,
- _("invalid maximum_ops_per_instruction "
+ complaint (_("invalid maximum_ops_per_instruction "
"in `.debug_line' section"));
}
lh->statement_program_start = line_ptr;
if (line_ptr > (section->buffer + section->size))
- complaint (&symfile_complaints,
- _("line number info header doesn't "
+ complaint (_("line number info header doesn't "
"fit in `.debug_line' section"));
return lh;
we're processing the end of a sequence. */
void record_line (bool end_sequence);
- /* Check address and if invalid nop-out the rest of the lines in this
- sequence. */
+ /* Check ADDRESS is zero and less than UNRELOCATED_LOWPC and if true
+ nop-out rest of the lines in this sequence. */
void check_line_address (struct dwarf2_cu *cu,
const gdb_byte *line_ptr,
- CORE_ADDR lowpc, CORE_ADDR address);
+ CORE_ADDR unrelocated_lowpc, CORE_ADDR address);
void handle_set_discriminator (unsigned int discriminator)
{
void
lnp_state_machine::check_line_address (struct dwarf2_cu *cu,
const gdb_byte *line_ptr,
- CORE_ADDR lowpc, CORE_ADDR address)
+ CORE_ADDR unrelocated_lowpc, CORE_ADDR address)
{
- /* If address < lowpc then it's not a usable value, it's outside the
- pc range of the CU. However, we restrict the test to only address
- values of zero to preserve GDB's previous behaviour which is to
- handle the specific case of a function being GC'd by the linker. */
+ /* If ADDRESS < UNRELOCATED_LOWPC then it's not a usable value, it's outside
+ the pc range of the CU. However, we restrict the test to only ADDRESS
+ values of zero to preserve GDB's previous behaviour which is to handle
+ the specific case of a function being GC'd by the linker. */
- if (address == 0 && address < lowpc)
+ if (address == 0 && address < unrelocated_lowpc)
{
/* 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;
long line_offset = line_ptr - get_debug_line_section (cu)->buffer;
- complaint (&symfile_complaints,
- _(".debug_line address at offset 0x%lx is 0 [in module %s]"),
+ complaint (_(".debug_line address at offset 0x%lx is 0 [in module %s]"),
line_offset, objfile_name (objfile));
m_record_line_callback = noop_record_line;
/* Note: record_line_callback is left as noop_record_line until
line_ptr += bytes_read;
state_machine.check_line_address (cu, line_ptr,
- lowpc, address);
+ lowpc - baseaddr, address);
state_machine.handle_set_address (baseaddr, address);
}
break;
}
break;
default:
- complaint (&symfile_complaints,
- _("mangled .debug_line section"));
+ complaint (_("mangled .debug_line section"));
return;
}
/* Make sure that we parsed the extended op correctly. If e.g.
we may have read the wrong number of bytes. */
if (line_ptr != extended_end)
{
- complaint (&symfile_complaints,
- _("mangled .debug_line section"));
+ complaint (_("mangled .debug_line section"));
return;
}
break;
record_debugformat ("DWARF 2");
record_producer (cu->producer);
- /* We assume that we're processing GCC output. */
- processing_gcc_compilation = 2;
-
cu->processing_has_namespace_info = 0;
return cust;
fe = NULL;
if (fe == NULL)
- complaint (&symfile_complaints,
- _("file index out of range"));
+ complaint (_("file index out of range"));
else
symbol_set_symtab (sym, fe->symtab);
}
when we do not have enough information to show inlined frames;
pretend it's a local variable in that case so that the user can
still see it. */
- if (context_stack_depth > 0
+ if (!outermost_context_p ()
&& context_stack[context_stack_depth - 1].name != NULL)
SYMBOL_IS_ARGUMENT (sym) = 1;
attr = dwarf2_attr (die, DW_AT_location, cu);
trash data, but since we must specifically ignore things
we don't recognize, there is nothing else we should do at
this point. */
- complaint (&symfile_complaints, _("unsupported tag: '%s'"),
+ complaint (_("unsupported tag: '%s'"),
dwarf_tag_name (die->tag));
break;
}
break;
default:
- complaint (&symfile_complaints,
- _("unsupported const value attribute form: '%s'"),
+ complaint (_("unsupported const value attribute form: '%s'"),
dwarf_form_name (attr->form));
*value = 0;
break;
}
else
{
- complaint (&symfile_complaints,
- _("Dwarf Error: Bad type attribute %s in DIE"
+ complaint (_("Dwarf Error: Bad type attribute %s in DIE"
" at %s [in module %s]"),
dwarf_attr_name (attr->name), sect_offset_str (die->sect_off),
objfile_name (objfile));
this_type = read_tag_atomic_type (die, cu);
break;
default:
- complaint (&symfile_complaints,
- _("unexpected tag in read_type_die: '%s'"),
+ complaint (_("unexpected tag in read_type_die: '%s'"),
dwarf_tag_name (die->tag));
break;
}
doesn't allow it), and break the loop here. */
name = dwarf2_name (die, cu);
parent_name = dwarf2_name (parent, cu);
- complaint (&symfile_complaints,
- _("template param type '%s' defined within parent '%s'"),
+ complaint (_("template param type '%s' defined within parent '%s'"),
name ? name : "<unknown>",
parent_name ? parent_name : "<unknown>");
return "";
DW_TAG_namespace DIEs with a name of "::" for the global namespace.
Work around this problem here. */
if (cu->language == language_cplus
- && strcmp (TYPE_TAG_NAME (parent_type), "::") == 0)
+ && strcmp (TYPE_NAME (parent_type), "::") == 0)
return "";
/* We give a name to even anonymous namespaces. */
- return TYPE_TAG_NAME (parent_type);
+ return TYPE_NAME (parent_type);
case DW_TAG_class_type:
case DW_TAG_interface_type:
case DW_TAG_structure_type:
case DW_TAG_union_type:
case DW_TAG_module:
parent_type = read_type_die (parent, cu);
- if (TYPE_TAG_NAME (parent_type) != NULL)
- return TYPE_TAG_NAME (parent_type);
+ if (TYPE_NAME (parent_type) != NULL)
+ return TYPE_NAME (parent_type);
else
/* An anonymous structure is only allowed non-static data
members; no typedefs, no member functions, et cetera.
parent_type = read_type_die (parent, cu);
if (TYPE_DECLARED_CLASS (parent_type))
{
- if (TYPE_TAG_NAME (parent_type) != NULL)
- return TYPE_TAG_NAME (parent_type);
+ if (TYPE_NAME (parent_type) != NULL)
+ return TYPE_NAME (parent_type);
return "";
}
/* Fall through. */
if (attr_form_is_ref (attr))
return (sect_offset) DW_UNSND (attr);
- complaint (&symfile_complaints,
- _("unsupported die ref attribute form: '%s'"),
+ complaint (_("unsupported die ref attribute form: '%s'"),
dwarf_form_name (attr->form));
return {};
}
else
{
/* For DW_FORM_data16 see attr_form_is_constant. */
- complaint (&symfile_complaints,
- _("Attribute value is not a constant (%s)"),
+ complaint (_("Attribute value is not a constant (%s)"),
dwarf_form_name (attr->form));
return default_value;
}
/* 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, cu->language);
+ load_full_comp_unit (per_cu, false, cu->language);
target_cu = per_cu->cu;
}
{
/* We're loading full DIEs during partial symbol reading. */
gdb_assert (dwarf2_per_objfile->reading_partial_symbols);
- load_full_comp_unit (cu->per_cu, language_minimal);
+ load_full_comp_unit (cu->per_cu, false, language_minimal);
}
*ref_cu = target_cu;
struct die_info *die;
struct attribute *attr;
struct dwarf2_locexpr_baton retval;
- struct objfile *objfile = per_cu->dwarf2_per_objfile->objfile;
- struct dwarf2_per_objfile *dwarf2_per_objfile
- = get_dwarf2_per_objfile (objfile);
+ struct dwarf2_per_objfile *dwarf2_per_objfile = per_cu->dwarf2_per_objfile;
+ struct objfile *objfile = dwarf2_per_objfile->objfile;
if (per_cu->cu == NULL)
- load_cu (per_cu);
+ load_cu (per_cu, 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);
+ load_cu (per_cu, false);
cu = per_cu->cu;
if (cu == NULL)
{
break;
default:
- complaint (&symfile_complaints,
- _("unsupported const value attribute form: '%s'"),
+ complaint (_("unsupported const value attribute form: '%s'"),
dwarf_form_name (attr->form));
break;
}
struct die_info *die;
if (per_cu->cu == NULL)
- load_cu (per_cu);
+ load_cu (per_cu, false);
cu = per_cu->cu;
if (!cu)
return NULL;
the debug info. */
if (sig_type == NULL)
{
- complaint (&symfile_complaints,
- _("Dwarf Error: Cannot find signatured DIE %s referenced"
+ complaint (_("Dwarf Error: Cannot find signatured DIE %s referenced"
" from DIE at %s [in module %s]"),
hex_string (signature), sect_offset_str (die->sect_off),
objfile_name (dwarf2_per_objfile->objfile));
type = read_type_die (type_die, type_cu);
if (type == NULL)
{
- complaint (&symfile_complaints,
- _("Dwarf Error: Cannot build signatured type %s"
+ complaint (_("Dwarf Error: Cannot build signatured type %s"
" referenced from DIE at %s [in module %s]"),
hex_string (signature), sect_offset_str (die->sect_off),
objfile_name (dwarf2_per_objfile->objfile));
}
else
{
- complaint (&symfile_complaints,
- _("Dwarf Error: Problem reading signatured DIE %s referenced"
+ complaint (_("Dwarf Error: Problem reading signatured DIE %s referenced"
" from DIE at %s [in module %s]"),
hex_string (signature), sect_offset_str (die->sect_off),
objfile_name (dwarf2_per_objfile->objfile));
struct dwarf2_per_objfile *dwarf2_per_objfile
= cu->per_cu->dwarf2_per_objfile;
- complaint (&symfile_complaints,
- _("Dwarf Error: DW_AT_signature has bad form %s in DIE"
+ complaint (_("Dwarf Error: DW_AT_signature has bad form %s in DIE"
" at %s [in module %s]"),
dwarf_form_name (attr->form), sect_offset_str (die->sect_off),
objfile_name (dwarf2_per_objfile->objfile));
gdb_assert (per_cu->is_debug_types);
gdb_assert (per_cu->cu == NULL);
- init_cutu_and_read_dies (per_cu, NULL, 0, 1,
+ init_cutu_and_read_dies (per_cu, NULL, 0, 1, false,
read_signatured_type_reader, NULL);
sig_type->per_cu.tu_read = 1;
}
const char *name = get_DW_OP_name (op);
if (name)
- complaint (&symfile_complaints, _("unsupported stack op: '%s'"),
+ complaint (_("unsupported stack op: '%s'"),
name);
else
- complaint (&symfile_complaints, _("unsupported stack op: '%02x'"),
+ complaint (_("unsupported stack op: '%02x'"),
op);
}
outside of the allocated space. Also enforce minimum>0. */
if (stacki >= ARRAY_SIZE (stack) - 1)
{
- complaint (&symfile_complaints,
- _("location description stack overflow"));
+ complaint (_("location description stack overflow"));
return 0;
}
if (stacki <= 0)
{
- complaint (&symfile_complaints,
- _("location description stack underflow"));
+ complaint (_("location description stack underflow"));
return 0;
}
}
xsnprintf (fake_name, sizeof (fake_name),
"<bad macro file number %d>", file);
- complaint (&symfile_complaints,
- _("bad file number in macro information (%d)"),
+ complaint (_("bad file number in macro information (%d)"),
file);
return xstrdup (fake_name);
{
if (*p == ' ')
{
- complaint (&symfile_complaints,
- _("macro definition contains spaces "
+ complaint (_("macro definition contains spaces "
"in formal argument list:\n`%s'"),
body);
default:
{
- complaint (&symfile_complaints,
- _("invalid form 0x%x in `%s'"),
+ complaint (_("invalid form 0x%x in `%s'"),
form, get_section_name (section));
return NULL;
}
if (opcode_definitions[opcode] == NULL)
{
- complaint (&symfile_complaints,
- _("unrecognized DW_MACFINO opcode 0x%x"),
+ complaint (_("unrecognized DW_MACFINO opcode 0x%x"),
opcode);
return NULL;
}
version = read_2_bytes (abfd, mac_ptr);
if (version != 4 && version != 5)
{
- complaint (&symfile_complaints,
- _("unrecognized version `%d' in .debug_macro section"),
+ complaint (_("unrecognized version `%d' in .debug_macro section"),
version);
return NULL;
}
if (! current_file)
{
/* DWARF violation as no main source is present. */
- complaint (&symfile_complaints,
- _("debug info with no main source gives macro %s "
+ complaint (_("debug info with no main source gives macro %s "
"on line %d: %s"),
is_define ? _("definition") : _("undefinition"),
line, body);
}
if ((line == 0 && !at_commandline)
|| (line != 0 && at_commandline))
- complaint (&symfile_complaints,
- _("debug info gives %s macro %s with %s line %d: %s"),
+ complaint (_("debug info gives %s macro %s with %s line %d: %s"),
at_commandline ? _("command-line") : _("in-file"),
is_define ? _("definition") : _("undefinition"),
line == 0 ? _("zero") : _("non-zero"), line, body);
if ((line == 0 && !at_commandline)
|| (line != 0 && at_commandline))
- complaint (&symfile_complaints,
- _("debug info gives source %d included "
+ complaint (_("debug info gives source %d included "
"from %s at %s line %d"),
file, at_commandline ? _("command-line") : _("file"),
line == 0 ? _("zero") : _("non-zero"), line);
case DW_MACRO_end_file:
if (! current_file)
- complaint (&symfile_complaints,
- _("macro debug info has an unmatched "
+ complaint (_("macro debug info has an unmatched "
"`close_file' directive"));
else
{
= (enum dwarf_macro_record_type) read_1_byte (abfd,
mac_ptr);
if (next_type != 0)
- complaint (&symfile_complaints,
- _("no terminating 0-type entry for "
+ complaint (_("no terminating 0-type entry for "
"macros in `.debug_macinfo' section"));
return;
{
/* This has actually happened; see
http://sourceware.org/bugzilla/show_bug.cgi?id=13568. */
- complaint (&symfile_complaints,
- _("recursive DW_MACRO_import in "
+ complaint (_("recursive DW_MACRO_import in "
".debug_macro section"));
}
else
dwarf2_read_section (objfile, section);
if (section->buffer == NULL)
{
- complaint (&symfile_complaints, _("missing %s section"), section_name);
+ complaint (_("missing %s section"), section_name);
return;
}
abfd = get_section_bfd_owner (section);
fill_in_loclist_baton (cu, baton, attr);
if (cu->base_known == 0)
- complaint (&symfile_complaints,
- _("Location list used without "
+ complaint (_("Location list used without "
"specifying the CU base address."));
SYMBOL_ACLASS_INDEX (sym) = (is_block
const sect_offset *cu_off;
low = 0;
- high = dwarf2_per_objfile->n_comp_units - 1;
+ high = dwarf2_per_objfile->all_comp_units.size () - 1;
while (high > low)
{
struct dwarf2_per_cu_data *mid_cu;
else
{
this_cu = dwarf2_per_objfile->all_comp_units[low];
- if (low == dwarf2_per_objfile->n_comp_units - 1
+ if (low == dwarf2_per_objfile->all_comp_units.size () - 1
&& sect_off >= this_cu->sect_off + this_cu->length)
error (_("invalid dwarf2 offset %s"), sect_offset_str (sect_off));
gdb_assert (sect_off < this_cu->sect_off + this_cu->length);
}
}
-/* Release all extra memory associated with OBJFILE. */
+/* Cleanup function for the dwarf2_per_objfile data. */
-void
-dwarf2_free_objfile (struct objfile *objfile)
+static void
+dwarf2_free_objfile (struct objfile *objfile, void *datum)
{
struct dwarf2_per_objfile *dwarf2_per_objfile
- = get_dwarf2_per_objfile (objfile);
+ = static_cast<struct dwarf2_per_objfile *> (datum);
delete dwarf2_per_objfile;
}
}
else if (attr != NULL)
{
- complaint (&symfile_complaints,
- _("DW_AT_allocated has the wrong form (%s) at DIE %s"),
+ complaint (_("DW_AT_allocated has the wrong form (%s) at DIE %s"),
(attr != NULL ? dwarf_form_name (attr->form) : "n/a"),
sect_offset_str (die->sect_off));
}
}
else if (attr != NULL)
{
- complaint (&symfile_complaints,
- _("DW_AT_associated has the wrong form (%s) at DIE %s"),
+ complaint (_("DW_AT_associated has the wrong form (%s) at DIE %s"),
(attr != NULL ? dwarf_form_name (attr->form) : "n/a"),
sect_offset_str (die->sect_off));
}
slot = (struct dwarf2_per_cu_offset_and_type **)
htab_find_slot (dwarf2_per_objfile->die_type_hash, &ofs, INSERT);
if (*slot)
- complaint (&symfile_complaints,
- _("A problem internal to GDB: DIE %s has type already set"),
+ complaint (_("A problem internal to GDB: DIE %s has type already set"),
sect_offset_str (die->sect_off));
*slot = XOBNEW (&objfile->objfile_obstack,
struct dwarf2_per_cu_offset_and_type);
void
_initialize_dwarf2_read (void)
{
-
- dwarf2_objfile_data_key = register_objfile_data ();
+ dwarf2_objfile_data_key
+ = register_objfile_data_with_cleanup (nullptr, dwarf2_free_objfile);
add_prefix_cmd ("dwarf", class_maintenance, set_dwarf_cmd, _("\
Set DWARF specific variables.\n\
projects / deliverable / binutils-gdb.git / blobdiff