/* GDB routines for manipulating objfiles.
- Copyright (C) 1992-2014 Free Software Foundation, Inc.
+ Copyright (C) 1992-2019 Free Software Foundation, Inc.
Contributed by Cygnus Support, using pieces from other GDB modules.
#include "addrmap.h"
#include "arch-utils.h"
#include "exec.h"
-#include "observer.h"
+#include "observable.h"
#include "complaints.h"
#include "psymtab.h"
#include "solist.h"
#include "gdb_bfd.h"
#include "btrace.h"
+#include "common/pathstuff.h"
+
+#include <vector>
/* Keep a registry of per-objfile data-pointers required by other GDB
modules. */
static void
objfiles_pspace_data_cleanup (struct program_space *pspace, void *arg)
{
- struct objfile_pspace_info *info = arg;
+ struct objfile_pspace_info *info = (struct objfile_pspace_info *) arg;
xfree (info->sections);
xfree (info);
{
struct objfile_pspace_info *info;
- info = program_space_data (pspace, objfiles_pspace_data);
+ info = ((struct objfile_pspace_info *)
+ program_space_data (pspace, objfiles_pspace_data));
if (info == NULL)
{
info = XCNEW (struct objfile_pspace_info);
static const struct bfd_data *objfiles_bfd_data;
+objfile_per_bfd_storage::~objfile_per_bfd_storage ()
+{
+}
+
/* Create the per-BFD storage object for OBJFILE. If ABFD is not
NULL, and it already has a per-BFD storage object, use that.
- Otherwise, allocate a new per-BFD storage object. If ABFD is not
- NULL, the object is allocated on the BFD; otherwise it is allocated
- on OBJFILE's obstack. Note that it is not safe to call this
- multiple times for a given OBJFILE -- it can only be called when
- allocating or re-initializing OBJFILE. */
+ Otherwise, allocate a new per-BFD storage object. Note that it is
+ not safe to call this multiple times for a given OBJFILE -- it can
+ only be called when allocating or re-initializing OBJFILE. */
static struct objfile_per_bfd_storage *
get_objfile_bfd_data (struct objfile *objfile, struct bfd *abfd)
struct objfile_per_bfd_storage *storage = NULL;
if (abfd != NULL)
- storage = bfd_data (abfd, objfiles_bfd_data);
+ storage = ((struct objfile_per_bfd_storage *)
+ bfd_data (abfd, objfiles_bfd_data));
if (storage == NULL)
{
+ storage = new objfile_per_bfd_storage;
/* If the object requires gdb to do relocations, we simply fall
back to not sharing data across users. These cases are rare
enough that this seems reasonable. */
if (abfd != NULL && !gdb_bfd_requires_relocations (abfd))
- {
- storage = bfd_zalloc (abfd, sizeof (struct objfile_per_bfd_storage));
- set_bfd_data (abfd, objfiles_bfd_data, storage);
- }
- else
- storage = OBSTACK_ZALLOC (&objfile->objfile_obstack,
- struct objfile_per_bfd_storage);
+ set_bfd_data (abfd, objfiles_bfd_data, storage);
/* Look up the gdbarch associated with the BFD. */
if (abfd != NULL)
storage->gdbarch = gdbarch_from_bfd (abfd);
-
- obstack_init (&storage->storage_obstack);
- storage->filename_cache = bcache_xmalloc (NULL, NULL);
- storage->macro_cache = bcache_xmalloc (NULL, NULL);
- storage->language_of_main = language_unknown;
}
return storage;
}
-/* Free STORAGE. */
-
-static void
-free_objfile_per_bfd_storage (struct objfile_per_bfd_storage *storage)
-{
- bcache_xfree (storage->filename_cache);
- bcache_xfree (storage->macro_cache);
- if (storage->demangled_names_hash)
- htab_delete (storage->demangled_names_hash);
- obstack_free (&storage->storage_obstack, 0);
-}
-
-/* A wrapper for free_objfile_per_bfd_storage that can be passed as a
+/* A deleter for objfile_per_bfd_storage that can be passed as a
cleanup function to the BFD registry. */
static void
objfile_bfd_data_free (struct bfd *unused, void *d)
{
- free_objfile_per_bfd_storage (d);
+ delete (struct objfile_per_bfd_storage *) d;
}
/* See objfiles.h. */
if (objfile->per_bfd->name_of_main == NULL
|| strcmp (objfile->per_bfd->name_of_main, name) != 0)
objfile->per_bfd->name_of_main
- = obstack_copy0 (&objfile->per_bfd->storage_obstack, name, strlen (name));
+ = (const char *) obstack_copy0 (&objfile->per_bfd->storage_obstack, name,
+ strlen (name));
objfile->per_bfd->language_of_main = lang;
}
+/* Helper structure to map blocks to static link properties in hash tables. */
+
+struct static_link_htab_entry
+{
+ const struct block *block;
+ const struct dynamic_prop *static_link;
+};
+
+/* Return a hash code for struct static_link_htab_entry *P. */
+
+static hashval_t
+static_link_htab_entry_hash (const void *p)
+{
+ const struct static_link_htab_entry *e
+ = (const struct static_link_htab_entry *) p;
+
+ return htab_hash_pointer (e->block);
+}
+
+/* Return whether P1 an P2 (pointers to struct static_link_htab_entry) are
+ mappings for the same block. */
+
+static int
+static_link_htab_entry_eq (const void *p1, const void *p2)
+{
+ const struct static_link_htab_entry *e1
+ = (const struct static_link_htab_entry *) p1;
+ const struct static_link_htab_entry *e2
+ = (const struct static_link_htab_entry *) p2;
+
+ return e1->block == e2->block;
+}
+
+/* Register STATIC_LINK as the static link for BLOCK, which is part of OBJFILE.
+ Must not be called more than once for each BLOCK. */
+
+void
+objfile_register_static_link (struct objfile *objfile,
+ const struct block *block,
+ const struct dynamic_prop *static_link)
+{
+ void **slot;
+ struct static_link_htab_entry lookup_entry;
+ struct static_link_htab_entry *entry;
+
+ if (objfile->static_links == NULL)
+ objfile->static_links.reset (htab_create_alloc
+ (1, &static_link_htab_entry_hash, static_link_htab_entry_eq, NULL,
+ xcalloc, xfree));
+
+ /* Create a slot for the mapping, make sure it's the first mapping for this
+ block and then create the mapping itself. */
+ lookup_entry.block = block;
+ slot = htab_find_slot (objfile->static_links.get (), &lookup_entry, INSERT);
+ gdb_assert (*slot == NULL);
+
+ entry = XOBNEW (&objfile->objfile_obstack, static_link_htab_entry);
+ entry->block = block;
+ entry->static_link = static_link;
+ *slot = (void *) entry;
+}
+
+/* Look for a static link for BLOCK, which is part of OBJFILE. Return NULL if
+ none was found. */
+
+const struct dynamic_prop *
+objfile_lookup_static_link (struct objfile *objfile,
+ const struct block *block)
+{
+ struct static_link_htab_entry *entry;
+ struct static_link_htab_entry lookup_entry;
+
+ if (objfile->static_links == NULL)
+ return NULL;
+ lookup_entry.block = block;
+ entry = ((struct static_link_htab_entry *)
+ htab_find (objfile->static_links.get (), &lookup_entry));
+ if (entry == NULL)
+ return NULL;
+
+ gdb_assert (entry->block == block);
+ return entry->static_link;
+}
+
\f
/* Called via bfd_map_over_sections to build up the section table that
add_to_objfile_sections (struct bfd *abfd, struct bfd_section *asect,
void *objfilep)
{
- add_to_objfile_sections_full (abfd, asect, objfilep, 0);
+ add_to_objfile_sections_full (abfd, asect, (struct objfile *) objfilep, 0);
}
/* Builds a section table for OBJFILE.
add_to_objfile_sections_full (objfile->obfd, bfd_ind_section_ptr, objfile, 1);
}
-/* Given a pointer to an initialized bfd (ABFD) and some flag bits
- allocate a new objfile struct, fill it in as best we can, link it
- into the list of all known objfiles, and return a pointer to the
- new objfile struct.
+/* Given a pointer to an initialized bfd (ABFD) and some flag bits,
+ initialize the new objfile as best we can and link it into the list
+ of all known objfiles.
NAME should contain original non-canonicalized filename or other
identifier as entered by user. If there is no better source use
requests for specific operations. Other bits like OBJF_SHARED are
simply copied through to the new objfile flags member. */
-/* NOTE: carlton/2003-02-04: This function is called with args NULL, 0
- by jv-lang.c, to create an artificial objfile used to hold
- information about dynamically-loaded Java classes. Unfortunately,
- that branch of this function doesn't get tested very frequently, so
- it's prone to breakage. (E.g. at one time the name was set to NULL
- in that situation, which broke a loop over all names in the dynamic
- library loader.) If you change this function, please try to leave
- things in a consistent state even if abfd is NULL. */
-
-struct objfile *
-allocate_objfile (bfd *abfd, const char *name, int flags)
+objfile::objfile (bfd *abfd, const char *name, objfile_flags flags_)
+ : flags (flags_),
+ pspace (current_program_space),
+ partial_symtabs (new psymtab_storage ()),
+ obfd (abfd)
{
- struct objfile *objfile;
- char *expanded_name;
+ const char *expanded_name;
- objfile = (struct objfile *) xzalloc (sizeof (struct objfile));
- objfile->psymbol_cache = psymbol_bcache_init ();
/* We could use obstack_specify_allocation here instead, but
gdb_obstack.h specifies the alloc/dealloc functions. */
- obstack_init (&objfile->objfile_obstack);
+ obstack_init (&objfile_obstack);
- objfile_alloc_data (objfile);
+ objfile_alloc_data (this);
+ gdb::unique_xmalloc_ptr<char> name_holder;
if (name == NULL)
{
gdb_assert (abfd == NULL);
gdb_assert ((flags & OBJF_NOT_FILENAME) != 0);
- expanded_name = xstrdup ("<<anonymous objfile>>");
+ expanded_name = "<<anonymous objfile>>";
}
- else if ((flags & OBJF_NOT_FILENAME) != 0)
- expanded_name = xstrdup (name);
+ else if ((flags & OBJF_NOT_FILENAME) != 0
+ || is_target_filename (name))
+ expanded_name = name;
else
- expanded_name = gdb_abspath (name);
- objfile->original_name = obstack_copy0 (&objfile->objfile_obstack,
- expanded_name,
- strlen (expanded_name));
- xfree (expanded_name);
-
- /* Update the per-objfile information that comes from the bfd, ensuring
- that any data that is reference is saved in the per-objfile data
- region. */
+ {
+ name_holder = gdb_abspath (name);
+ expanded_name = name_holder.get ();
+ }
+ original_name
+ = (char *) obstack_copy0 (&objfile_obstack,
+ expanded_name,
+ strlen (expanded_name));
/* Update the per-objfile information that comes from the bfd, ensuring
that any data that is reference is saved in the per-objfile data
region. */
- objfile->obfd = abfd;
gdb_bfd_ref (abfd);
if (abfd != NULL)
{
- objfile->mtime = bfd_get_mtime (abfd);
+ mtime = bfd_get_mtime (abfd);
/* Build section table. */
- build_objfile_section_table (objfile);
+ build_objfile_section_table (this);
}
- objfile->per_bfd = get_objfile_bfd_data (objfile, abfd);
- objfile->pspace = current_program_space;
-
- terminate_minimal_symbol_table (objfile);
-
- /* Initialize the section indexes for this objfile, so that we can
- later detect if they are used w/o being properly assigned to. */
-
- objfile->sect_index_text = -1;
- objfile->sect_index_data = -1;
- objfile->sect_index_bss = -1;
- objfile->sect_index_rodata = -1;
+ per_bfd = get_objfile_bfd_data (this, abfd);
/* Add this file onto the tail of the linked list of other such files. */
- objfile->next = NULL;
if (object_files == NULL)
- object_files = objfile;
+ object_files = this;
else
{
struct objfile *last_one;
for (last_one = object_files;
last_one->next;
last_one = last_one->next);
- last_one->next = objfile;
+ last_one->next = this;
}
- /* Save passed in flag bits. */
- objfile->flags |= flags;
-
/* Rebuild section map next time we need it. */
- get_objfile_pspace_data (objfile->pspace)->new_objfiles_available = 1;
-
- return objfile;
+ get_objfile_pspace_data (pspace)->new_objfiles_available = 1;
}
/* Retrieve the gdbarch associated with OBJFILE. */
return retval;
}
-/* Iterator on PARENT and every separate debug objfile of PARENT.
- The usage pattern is:
- for (objfile = parent;
- objfile;
- objfile = objfile_separate_debug_iterate (parent, objfile))
- ...
-*/
-
-struct objfile *
-objfile_separate_debug_iterate (const struct objfile *parent,
- const struct objfile *objfile)
+separate_debug_iterator &
+separate_debug_iterator::operator++ ()
{
+ gdb_assert (m_objfile != nullptr);
+
struct objfile *res;
/* If any, return the first child. */
- res = objfile->separate_debug_objfile;
- if (res)
- return res;
+ res = m_objfile->separate_debug_objfile;
+ if (res != nullptr)
+ {
+ m_objfile = res;
+ return *this;
+ }
/* Common case where there is no separate debug objfile. */
- if (objfile == parent)
- return NULL;
+ if (m_objfile == m_parent)
+ {
+ m_objfile = nullptr;
+ return *this;
+ }
/* Return the brother if any. Note that we don't iterate on brothers of
the parents. */
- res = objfile->separate_debug_objfile_link;
- if (res)
- return res;
+ res = m_objfile->separate_debug_objfile_link;
+ if (res != nullptr)
+ {
+ m_objfile = res;
+ return *this;
+ }
- for (res = objfile->separate_debug_objfile_backlink;
- res != parent;
+ for (res = m_objfile->separate_debug_objfile_backlink;
+ res != m_parent;
res = res->separate_debug_objfile_backlink)
{
- gdb_assert (res != NULL);
- if (res->separate_debug_objfile_link)
- return res->separate_debug_objfile_link;
+ gdb_assert (res != nullptr);
+ if (res->separate_debug_objfile_link != nullptr)
+ {
+ m_objfile = res->separate_debug_objfile_link;
+ return *this;
+ }
}
- return NULL;
+ m_objfile = nullptr;
+ return *this;
}
/* Put one object file before a specified on in the global list.
This can be used to make sure an object file is destroyed before
- another when using ALL_OBJFILES_SAFE to free all objfiles. */
+ another when using objfiles_safe to free all objfiles. */
void
put_objfile_before (struct objfile *objfile, struct objfile *before_this)
{
parent->separate_debug_objfile = objfile;
/* Put the separate debug object before the normal one, this is so that
- usage of the ALL_OBJFILES_SAFE macro will stay safe. */
+ usage of objfiles_safe will stay safe. */
put_objfile_before (objfile, parent);
}
for (child = objfile->separate_debug_objfile; child;)
{
struct objfile *next_child = child->separate_debug_objfile_link;
- free_objfile (child);
+ delete child;
child = next_child;
}
}
/* Destroy an objfile and all the symtabs and psymtabs under it. */
-void
-free_objfile (struct objfile *objfile)
+objfile::~objfile ()
{
/* First notify observers that this objfile is about to be freed. */
- observer_notify_free_objfile (objfile);
+ gdb::observers::free_objfile.notify (this);
/* Free all separate debug objfiles. */
- free_objfile_separate_debug (objfile);
+ free_objfile_separate_debug (this);
- if (objfile->separate_debug_objfile_backlink)
+ if (separate_debug_objfile_backlink)
{
/* We freed the separate debug file, make sure the base objfile
doesn't reference it. */
struct objfile *child;
- child = objfile->separate_debug_objfile_backlink->separate_debug_objfile;
+ child = separate_debug_objfile_backlink->separate_debug_objfile;
- if (child == objfile)
+ if (child == this)
{
- /* OBJFILE is the first child. */
- objfile->separate_debug_objfile_backlink->separate_debug_objfile =
- objfile->separate_debug_objfile_link;
+ /* THIS is the first child. */
+ separate_debug_objfile_backlink->separate_debug_objfile =
+ separate_debug_objfile_link;
}
else
{
- /* Find OBJFILE in the list. */
+ /* Find THIS in the list. */
while (1)
{
- if (child->separate_debug_objfile_link == objfile)
+ if (child->separate_debug_objfile_link == this)
{
child->separate_debug_objfile_link =
- objfile->separate_debug_objfile_link;
+ separate_debug_objfile_link;
break;
}
child = child->separate_debug_objfile_link;
}
}
}
-
+
/* Remove any references to this objfile in the global value
lists. */
- preserve_values (objfile);
+ preserve_values (this);
/* It still may reference data modules have associated with the objfile and
the symbol file data. */
- forget_cached_source_info_for_objfile (objfile);
+ forget_cached_source_info_for_objfile (this);
- breakpoint_free_objfile (objfile);
- btrace_free_objfile (objfile);
+ breakpoint_free_objfile (this);
+ btrace_free_objfile (this);
/* First do any symbol file specific actions required when we are
finished with a particular symbol file. Note that if the objfile
freeing things which are valid only during this particular gdb
execution, or leaving them to be reused during the next one. */
- if (objfile->sf != NULL)
- {
- (*objfile->sf->sym_finish) (objfile);
- }
+ if (sf != NULL)
+ (*sf->sym_finish) (this);
/* Discard any data modules have associated with the objfile. The function
- still may reference objfile->obfd. */
- objfile_free_data (objfile);
+ still may reference obfd. */
+ objfile_free_data (this);
- if (objfile->obfd)
- gdb_bfd_unref (objfile->obfd);
+ if (obfd)
+ gdb_bfd_unref (obfd);
else
- free_objfile_per_bfd_storage (objfile->per_bfd);
+ delete per_bfd;
/* Remove it from the chain of all objfiles. */
- unlink_objfile (objfile);
+ unlink_objfile (this);
- if (objfile == symfile_objfile)
+ if (this == symfile_objfile)
symfile_objfile = NULL;
/* Before the symbol table code was redone to make it easier to
for example), so we need to call this here. */
clear_pc_function_cache ();
- /* Clear globals which might have pointed into a removed objfile.
- FIXME: It's not clear which of these are supposed to persist
- between expressions and which ought to be reset each time. */
- expression_context_block = NULL;
- innermost_block = NULL;
-
/* Check to see if the current_source_symtab belongs to this objfile,
and if so, call clear_current_source_symtab_and_line. */
{
struct symtab_and_line cursal = get_current_source_symtab_and_line ();
- if (cursal.symtab && SYMTAB_OBJFILE (cursal.symtab) == objfile)
+ if (cursal.symtab && SYMTAB_OBJFILE (cursal.symtab) == this)
clear_current_source_symtab_and_line ();
}
- if (objfile->global_psymbols.list)
- xfree (objfile->global_psymbols.list);
- if (objfile->static_psymbols.list)
- xfree (objfile->static_psymbols.list);
/* Free the obstacks for non-reusable objfiles. */
- psymbol_bcache_free (objfile->psymbol_cache);
- obstack_free (&objfile->objfile_obstack, 0);
+ obstack_free (&objfile_obstack, 0);
/* Rebuild section map next time we need it. */
- get_objfile_pspace_data (objfile->pspace)->section_map_dirty = 1;
-
- /* The last thing we do is free the objfile struct itself. */
- xfree (objfile);
-}
-
-static void
-do_free_objfile_cleanup (void *obj)
-{
- free_objfile (obj);
-}
-
-struct cleanup *
-make_cleanup_free_objfile (struct objfile *obj)
-{
- return make_cleanup (do_free_objfile_cleanup, obj);
+ get_objfile_pspace_data (pspace)->section_map_dirty = 1;
}
/* Free all the object files at once and clean up their users. */
void
free_all_objfiles (void)
{
- struct objfile *objfile, *temp;
struct so_list *so;
- /* Any objfile referencewould become stale. */
+ /* Any objfile reference would become stale. */
for (so = master_so_list (); so; so = so->next)
gdb_assert (so->objfile == NULL);
- ALL_OBJFILES_SAFE (objfile, temp)
- {
- free_objfile (objfile);
- }
+ for (objfile *objfile : current_program_space->objfiles_safe ())
+ delete objfile;
clear_symtab_users (0);
}
\f
objfile_relocate1 (struct objfile *objfile,
const struct section_offsets *new_offsets)
{
- struct obj_section *s;
struct section_offsets *delta =
((struct section_offsets *)
alloca (SIZEOF_N_SECTION_OFFSETS (objfile->num_sections)));
- int i;
int something_changed = 0;
- for (i = 0; i < objfile->num_sections; ++i)
+ for (int i = 0; i < objfile->num_sections; ++i)
{
delta->offsets[i] =
ANOFFSET (new_offsets, i) - ANOFFSET (objfile->section_offsets, i);
/* OK, get all the symtabs. */
{
- struct symtab *s;
-
- ALL_OBJFILE_SYMTABS (objfile, s)
- {
- struct linetable *l;
- const struct blockvector *bv;
- int i;
-
- /* First the line table. */
- l = LINETABLE (s);
- if (l)
- {
- for (i = 0; i < l->nitems; ++i)
- l->item[i].pc += ANOFFSET (delta, s->block_line_section);
- }
-
- /* Don't relocate a shared blockvector more than once. */
- if (!s->primary)
- continue;
-
- bv = BLOCKVECTOR (s);
- if (BLOCKVECTOR_MAP (bv))
- addrmap_relocate (BLOCKVECTOR_MAP (bv),
- ANOFFSET (delta, s->block_line_section));
-
- for (i = 0; i < BLOCKVECTOR_NBLOCKS (bv); ++i)
- {
- struct block *b;
- struct symbol *sym;
- struct dict_iterator iter;
-
- b = BLOCKVECTOR_BLOCK (bv, i);
- BLOCK_START (b) += ANOFFSET (delta, s->block_line_section);
- BLOCK_END (b) += ANOFFSET (delta, s->block_line_section);
+ for (compunit_symtab *cust : objfile->compunits ())
+ {
+ for (symtab *s : compunit_filetabs (cust))
+ {
+ struct linetable *l;
+
+ /* First the line table. */
+ l = SYMTAB_LINETABLE (s);
+ if (l)
+ {
+ for (int i = 0; i < l->nitems; ++i)
+ l->item[i].pc += ANOFFSET (delta,
+ COMPUNIT_BLOCK_LINE_SECTION
+ (cust));
+ }
+ }
+ }
- /* We only want to iterate over the local symbols, not any
- symbols in included symtabs. */
- ALL_DICT_SYMBOLS (BLOCK_DICT (b), iter, sym)
- {
- relocate_one_symbol (sym, objfile, delta);
- }
- }
- }
+ for (compunit_symtab *cust : objfile->compunits ())
+ {
+ const struct blockvector *bv = COMPUNIT_BLOCKVECTOR (cust);
+ int block_line_section = COMPUNIT_BLOCK_LINE_SECTION (cust);
+
+ if (BLOCKVECTOR_MAP (bv))
+ addrmap_relocate (BLOCKVECTOR_MAP (bv),
+ ANOFFSET (delta, block_line_section));
+
+ for (int i = 0; i < BLOCKVECTOR_NBLOCKS (bv); ++i)
+ {
+ struct block *b;
+ struct symbol *sym;
+ struct mdict_iterator miter;
+
+ b = BLOCKVECTOR_BLOCK (bv, i);
+ BLOCK_START (b) += ANOFFSET (delta, block_line_section);
+ BLOCK_END (b) += ANOFFSET (delta, block_line_section);
+
+ if (BLOCK_RANGES (b) != nullptr)
+ for (int j = 0; j < BLOCK_NRANGES (b); j++)
+ {
+ BLOCK_RANGE_START (b, j)
+ += ANOFFSET (delta, block_line_section);
+ BLOCK_RANGE_END (b, j) += ANOFFSET (delta,
+ block_line_section);
+ }
+
+ /* We only want to iterate over the local symbols, not any
+ symbols in included symtabs. */
+ ALL_DICT_SYMBOLS (BLOCK_MULTIDICT (b), miter, sym)
+ {
+ relocate_one_symbol (sym, objfile, delta);
+ }
+ }
+ }
}
+ /* This stores relocated addresses and so must be cleared. This
+ will cause it to be recreated on demand. */
+ objfile->psymbol_map.clear ();
+
/* Relocate isolated symbols. */
{
struct symbol *iter;
relocate_one_symbol (iter, objfile, delta);
}
- if (objfile->psymtabs_addrmap)
- addrmap_relocate (objfile->psymtabs_addrmap,
- ANOFFSET (delta, SECT_OFF_TEXT (objfile)));
-
- if (objfile->sf)
- objfile->sf->qf->relocate (objfile, new_offsets, delta);
-
{
int i;
get_objfile_pspace_data (objfile->pspace)->section_map_dirty = 1;
/* Update the table in exec_ops, used to read memory. */
+ struct obj_section *s;
ALL_OBJFILE_OSECTIONS (objfile, s)
{
int idx = s - objfile->sections;
objfile_relocate (struct objfile *objfile,
const struct section_offsets *new_offsets)
{
- struct objfile *debug_objfile;
int changed = 0;
changed |= objfile_relocate1 (objfile, new_offsets);
- for (debug_objfile = objfile->separate_debug_objfile;
- debug_objfile;
- debug_objfile = objfile_separate_debug_iterate (objfile, debug_objfile))
+ for (struct objfile *debug_objfile : objfile->separate_debug_objfiles ())
{
- struct section_addr_info *objfile_addrs;
- struct section_offsets *new_debug_offsets;
- struct cleanup *my_cleanups;
+ if (debug_objfile == objfile)
+ continue;
- objfile_addrs = build_section_addr_info_from_objfile (objfile);
- my_cleanups = make_cleanup (xfree, objfile_addrs);
+ section_addr_info objfile_addrs
+ = build_section_addr_info_from_objfile (objfile);
/* Here OBJFILE_ADDRS contain the correct absolute addresses, the
relative ones must be already created according to debug_objfile. */
- addr_info_make_relative (objfile_addrs, debug_objfile->obfd);
+ addr_info_make_relative (&objfile_addrs, debug_objfile->obfd);
gdb_assert (debug_objfile->num_sections
== gdb_bfd_count_sections (debug_objfile->obfd));
- new_debug_offsets =
- xmalloc (SIZEOF_N_SECTION_OFFSETS (debug_objfile->num_sections));
- make_cleanup (xfree, new_debug_offsets);
- relative_addr_info_to_section_offsets (new_debug_offsets,
+ std::vector<struct section_offsets>
+ new_debug_offsets (SIZEOF_N_SECTION_OFFSETS (debug_objfile->num_sections));
+ relative_addr_info_to_section_offsets (new_debug_offsets.data (),
debug_objfile->num_sections,
objfile_addrs);
- changed |= objfile_relocate1 (debug_objfile, new_debug_offsets);
-
- do_cleanups (my_cleanups);
+ changed |= objfile_relocate1 (debug_objfile, new_debug_offsets.data ());
}
/* Relocate breakpoints as necessary, after things are relocated. */
void
objfile_rebase (struct objfile *objfile, CORE_ADDR slide)
{
- struct objfile *debug_objfile;
int changed = 0;
- changed |= objfile_rebase1 (objfile, slide);
-
- for (debug_objfile = objfile->separate_debug_objfile;
- debug_objfile;
- debug_objfile = objfile_separate_debug_iterate (objfile, debug_objfile))
+ for (struct objfile *debug_objfile : objfile->separate_debug_objfiles ())
changed |= objfile_rebase1 (debug_objfile, slide);
/* Relocate breakpoints as necessary, after things are relocated. */
int
objfile_has_full_symbols (struct objfile *objfile)
{
- return objfile->symtabs != NULL;
+ return objfile->compunit_symtabs != NULL;
}
/* Return non-zero if OBJFILE has full or partial symbols, either directly
int
objfile_has_symbols (struct objfile *objfile)
{
- struct objfile *o;
-
- for (o = objfile; o; o = objfile_separate_debug_iterate (objfile, o))
+ for (struct objfile *o : objfile->separate_debug_objfiles ())
if (objfile_has_partial_symbols (o) || objfile_has_full_symbols (o))
return 1;
return 0;
int
have_partial_symbols (void)
{
- struct objfile *ofp;
-
- ALL_OBJFILES (ofp)
- {
- if (objfile_has_partial_symbols (ofp))
- return 1;
- }
+ for (objfile *ofp : current_program_space->objfiles ())
+ {
+ if (objfile_has_partial_symbols (ofp))
+ return 1;
+ }
return 0;
}
int
have_full_symbols (void)
{
- struct objfile *ofp;
-
- ALL_OBJFILES (ofp)
- {
- if (objfile_has_full_symbols (ofp))
- return 1;
- }
+ for (objfile *ofp : current_program_space->objfiles ())
+ {
+ if (objfile_has_full_symbols (ofp))
+ return 1;
+ }
return 0;
}
void
objfile_purge_solibs (void)
{
- struct objfile *objf;
- struct objfile *temp;
-
- ALL_OBJFILES_SAFE (objf, temp)
- {
- /* We assume that the solib package has been purged already, or will
- be soon. */
+ for (objfile *objf : current_program_space->objfiles_safe ())
+ {
+ /* We assume that the solib package has been purged already, or will
+ be soon. */
- if (!(objf->flags & OBJF_USERLOADED) && (objf->flags & OBJF_SHARED))
- free_objfile (objf);
- }
+ if (!(objf->flags & OBJF_USERLOADED) && (objf->flags & OBJF_SHARED))
+ delete objf;
+ }
}
int
have_minimal_symbols (void)
{
- struct objfile *ofp;
-
- ALL_OBJFILES (ofp)
- {
- if (ofp->per_bfd->minimal_symbol_count > 0)
- {
- return 1;
- }
- }
+ for (objfile *ofp : current_program_space->objfiles ())
+ {
+ if (ofp->per_bfd->minimal_symbol_count > 0)
+ {
+ return 1;
+ }
+ }
return 0;
}
{
/* Sort on sequence number of the objfile in the chain. */
- const struct objfile *objfile;
-
- ALL_OBJFILES (objfile)
+ for (objfile *objfile : current_program_space->objfiles ())
if (objfile == objfile1)
return -1;
else if (objfile == objfile2)
struct gdbarch *const gdbarch = get_objfile_arch (objf1);
- complaint (&symfile_complaints,
- _("unexpected overlap between:\n"
+ complaint (_("unexpected overlap between:\n"
" (A) section `%s' from `%s' [%s, %s)\n"
" (B) section `%s' from `%s' [%s, %s).\n"
"Will ignore section B"),
struct objfile_pspace_info *pspace_info;
int alloc_size, map_size, i;
struct obj_section *s, **map;
- struct objfile *objfile;
pspace_info = get_objfile_pspace_data (pspace);
gdb_assert (pspace_info->section_map_dirty != 0
xfree (map);
alloc_size = 0;
- ALL_PSPACE_OBJFILES (pspace, objfile)
+ for (objfile *objfile : pspace->objfiles ())
ALL_OBJFILE_OSECTIONS (objfile, s)
if (insert_section_p (objfile->obfd, s->the_bfd_section))
alloc_size += 1;
return;
}
- map = xmalloc (alloc_size * sizeof (*map));
+ map = XNEWVEC (struct obj_section *, alloc_size);
i = 0;
- ALL_PSPACE_OBJFILES (pspace, objfile)
+ for (objfile *objfile : pspace->objfiles ())
ALL_OBJFILE_OSECTIONS (objfile, s)
if (insert_section_p (objfile->obfd, s->the_bfd_section))
map[i++] = s;
if (map_size < alloc_size)
/* Some sections were eliminated. Trim excess space. */
- map = xrealloc (map, map_size * sizeof (*map));
+ map = XRESIZEVEC (struct obj_section *, map, map_size);
else
gdb_assert (alloc_size == map_size);
/* Return non-zero if PC is in a section called NAME. */
int
-pc_in_section (CORE_ADDR pc, char *name)
+pc_in_section (CORE_ADDR pc, const char *name)
{
struct obj_section *s;
int retval = 0;
/* See comments in objfiles.h. */
-void
+scoped_restore_tmpl<int>
inhibit_section_map_updates (struct program_space *pspace)
{
- get_objfile_pspace_data (pspace)->inhibit_updates = 1;
-}
-
-/* See comments in objfiles.h. */
-
-void
-resume_section_map_updates (struct program_space *pspace)
-{
- get_objfile_pspace_data (pspace)->inhibit_updates = 0;
-}
-
-/* See comments in objfiles.h. */
-
-void
-resume_section_map_updates_cleanup (void *arg)
-{
- resume_section_map_updates (arg);
+ return scoped_restore_tmpl<int>
+ (&get_objfile_pspace_data (pspace)->inhibit_updates, 1);
}
/* Return 1 if ADDR maps into one of the sections of OBJFILE and 0
shared_objfile_contains_address_p (struct program_space *pspace,
CORE_ADDR address)
{
- struct objfile *objfile;
-
- ALL_PSPACE_OBJFILES (pspace, objfile)
+ for (objfile *objfile : pspace->objfiles ())
{
if ((objfile->flags & OBJF_SHARED) != 0
&& is_addr_in_objfile (address, objfile))
}
/* The default implementation for the "iterate_over_objfiles_in_search_order"
- gdbarch method. It is equivalent to use the ALL_OBJFILES macro,
+ gdbarch method. It is equivalent to use the objfiles iterable,
searching the objfiles in the order they are stored internally,
ignoring CURRENT_OBJFILE.
void *cb_data, struct objfile *current_objfile)
{
int stop = 0;
- struct objfile *objfile;
- ALL_OBJFILES (objfile)
+ for (objfile *objfile : current_program_space->objfiles ())
{
stop = cb (objfile, cb_data);
if (stop)
}
}
-/* Return canonical name for OBJFILE. */
+/* See objfiles.h. */
const char *
objfile_name (const struct objfile *objfile)
return objfile->original_name;
}
-/* Provide a prototype to silence -Wmissing-prototypes. */
-extern initialize_file_ftype _initialize_objfiles;
+/* See objfiles.h. */
+
+const char *
+objfile_filename (const struct objfile *objfile)
+{
+ if (objfile->obfd != NULL)
+ return bfd_get_filename (objfile->obfd);
+
+ return NULL;
+}
+
+/* See objfiles.h. */
+
+const char *
+objfile_debug_name (const struct objfile *objfile)
+{
+ return lbasename (objfile->original_name);
+}
+
+/* See objfiles.h. */
+
+const char *
+objfile_flavour_name (struct objfile *objfile)
+{
+ if (objfile->obfd != NULL)
+ return bfd_flavour_name (bfd_get_flavour (objfile->obfd));
+ return NULL;
+}
void
_initialize_objfiles (void)