/* GDB routines for manipulating objfiles.
- Copyright (C) 1992-2017 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>
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)
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
- = ((struct objfile_per_bfd_storage *)
- bfd_alloc (abfd, sizeof (struct objfile_per_bfd_storage)));
- set_bfd_data (abfd, objfiles_bfd_data, storage);
- }
- else
- {
- storage = (objfile_per_bfd_storage *)
- obstack_alloc (&objfile->objfile_obstack,
- sizeof (objfile_per_bfd_storage));
- }
-
- /* objfile_per_bfd_storage is not trivially constructible, must
- call the ctor manually. */
- storage = new (storage) 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);
- storage->~objfile_per_bfd_storage ();
-}
-
-/* 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 ((struct objfile_per_bfd_storage *) d);
+ delete (struct objfile_per_bfd_storage *) d;
}
/* See objfiles.h. */
slot = htab_find_slot (objfile->static_links, &lookup_entry, INSERT);
gdb_assert (*slot == NULL);
- entry = (struct static_link_htab_entry *) obstack_alloc
- (&objfile->objfile_obstack, sizeof (*entry));
+ entry = XOBNEW (&objfile->objfile_obstack, static_link_htab_entry);
entry->block = block;
entry->static_link = static_link;
*slot = (void *) entry;
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. */
-struct objfile *
-allocate_objfile (bfd *abfd, const char *name, objfile_flags 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 = XCNEW (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)
name_holder = gdb_abspath (name);
expanded_name = name_holder.get ();
}
- objfile->original_name
- = (char *) obstack_copy0 (&objfile->objfile_obstack,
+ original_name
+ = (char *) obstack_copy0 (&objfile_obstack,
expanded_name,
strlen (expanded_name));
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;
+ get_objfile_pspace_data (pspace)->section_map_dirty = 1;
/* Free the map for static links. There's no need to free static link
themselves since they were allocated on the objstack. */
- if (objfile->static_links != NULL)
- htab_delete (objfile->static_links);
-
- /* The last thing we do is free the objfile struct itself. */
- xfree (objfile);
-}
-
-static void
-do_free_objfile_cleanup (void *obj)
-{
- free_objfile ((struct objfile *) obj);
-}
-
-struct cleanup *
-make_cleanup_free_objfile (struct objfile *obj)
-{
- return make_cleanup (do_free_objfile_cleanup, obj);
+ if (static_links != NULL)
+ htab_delete (static_links);
}
/* 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 compunit_symtab *cust;
- struct symtab *s;
-
- ALL_OBJFILE_FILETABS (objfile, cust, s)
- {
- struct linetable *l;
- int i;
-
- /* First the line table. */
- l = SYMTAB_LINETABLE (s);
- if (l)
- {
- for (i = 0; i < l->nitems; ++i)
- l->item[i].pc += ANOFFSET (delta,
- COMPUNIT_BLOCK_LINE_SECTION
- (cust));
- }
- }
-
- ALL_OBJFILE_COMPUNITS (objfile, cust)
- {
- 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 (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, block_line_section);
- BLOCK_END (b) += ANOFFSET (delta, 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 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));
objfile_addrs);
changed |= objfile_relocate1 (debug_objfile, new_debug_offsets.data ());
-
- do_cleanups (my_cleanups);
}
/* 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_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;
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;
/* 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 ((struct program_space *) 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 NULL;
}
-/* Provide a prototype to silence -Wmissing-prototypes. */
-extern initialize_file_ftype _initialize_objfiles;
-
void
_initialize_objfiles (void)
{
projects / thirdparty / binutils-gdb.git / blobdiff