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),
+ obfd (abfd),
+ psymbol_cache (psymbol_bcache_init ())
{
- struct objfile *objfile;
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);
+ per_bfd = get_objfile_bfd_data (this, abfd);
- /* 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;
+ terminate_minimal_symbol_table (this);
/* 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. */
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);
+ observer_notify_free_objfile (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);
+ free_objfile_per_bfd_storage (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
{
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);
+ psymbol_bcache_free (psymbol_cache);
+ 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. */
ALL_OBJFILES_SAFE (objfile, temp)
{
- free_objfile (objfile);
+ delete objfile;
}
clear_symtab_users (0);
}
be soon. */
if (!(objf->flags & OBJF_USERLOADED) && (objf->flags & OBJF_SHARED))
- free_objfile (objf);
+ delete objf;
}
}
return NULL;
}
-/* Provide a prototype to silence -Wmissing-prototypes. */
-extern initialize_file_ftype _initialize_objfiles;
-
void
_initialize_objfiles (void)
{