/* GDB routines for manipulating objfiles.
- Copyright 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
+ Copyright 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001
+ Free Software Foundation, Inc.
Contributed by Cygnus Support, using pieces from other GDB modules.
This file is part of GDB.
#if defined(USE_MMALLOC) && defined(HAVE_MMAP)
-static int
-open_existing_mapped_file PARAMS ((char *, long, int));
+#include "mmalloc.h"
-static int
-open_mapped_file PARAMS ((char *filename, long mtime, int mapped));
+static int open_existing_mapped_file (char *, long, int);
-static PTR
- map_to_file PARAMS ((int));
+static int open_mapped_file (char *filename, long mtime, int flags);
+
+static PTR map_to_file (int);
#endif /* defined(USE_MMALLOC) && defined(HAVE_MMAP) */
-static void
-add_to_objfile_sections PARAMS ((bfd *, sec_ptr, PTR));
+static void add_to_objfile_sections (bfd *, sec_ptr, PTR);
/* Externally visible variables that are owned by this module.
See declarations in objfile.h for more info. */
the end of the table (objfile->sections_end). */
static void
-add_to_objfile_sections (abfd, asect, objfile_p_char)
- bfd *abfd;
- sec_ptr asect;
- PTR objfile_p_char;
+add_to_objfile_sections (bfd *abfd, sec_ptr asect, PTR objfile_p_char)
{
struct objfile *objfile = (struct objfile *) objfile_p_char;
struct obj_section section;
we are building the table, we're pretty much hosed. */
int
-build_objfile_section_table (objfile)
- struct objfile *objfile;
+build_objfile_section_table (struct objfile *objfile)
{
/* objfile->sections can be already set when reading a mapped symbol
file. I believe that we do need to rebuild the section table in
return (0);
}
-/* Given a pointer to an initialized bfd (ABFD) and a flag that indicates
- whether or not an objfile is to be mapped (MAPPED), 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.
-
- USER_LOADED is simply recorded in the objfile. This record offers a way for
- run_command to remove old objfile entries which are no longer valid (i.e.,
- are associated with an old inferior), but to preserve ones that the user
- explicitly loaded via the add-symbol-file command.
+/* 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.
- IS_SOLIB is also simply recorded in the objfile. */
+ The FLAGS word contains various bits (OBJF_*) that can be taken as
+ requests for specific operations, like trying to open a mapped
+ version of the objfile (OBJF_MAPPED). Other bits like
+ OBJF_SHARED are simply copied through to the new objfile flags
+ member. */
struct objfile *
-allocate_objfile (abfd, mapped, user_loaded, is_solib)
- bfd *abfd;
- int mapped;
- int user_loaded;
- int is_solib;
+allocate_objfile (bfd *abfd, int flags)
{
struct objfile *objfile = NULL;
struct objfile *last_one = NULL;
- mapped |= mapped_symbol_files;
+ if (mapped_symbol_files)
+ flags |= OBJF_MAPPED;
#if defined(USE_MMALLOC) && defined(HAVE_MMAP)
if (abfd != NULL)
int fd;
fd = open_mapped_file (bfd_get_filename (abfd), bfd_get_mtime (abfd),
- mapped);
+ flags);
if (fd >= 0)
{
PTR md;
objfile->mmfd = fd;
/* Update pointers to functions to *our* copies */
obstack_chunkfun (&objfile->psymbol_cache.cache, xmmalloc);
- obstack_freefun (&objfile->psymbol_cache.cache, mfree);
+ obstack_freefun (&objfile->psymbol_cache.cache, xmfree);
obstack_chunkfun (&objfile->psymbol_obstack, xmmalloc);
- obstack_freefun (&objfile->psymbol_obstack, mfree);
+ obstack_freefun (&objfile->psymbol_obstack, xmfree);
obstack_chunkfun (&objfile->symbol_obstack, xmmalloc);
- obstack_freefun (&objfile->symbol_obstack, mfree);
+ obstack_freefun (&objfile->symbol_obstack, xmfree);
obstack_chunkfun (&objfile->type_obstack, xmmalloc);
- obstack_freefun (&objfile->type_obstack, mfree);
+ obstack_freefun (&objfile->type_obstack, xmfree);
/* If already in objfile list, unlink it. */
unlink_objfile (objfile);
/* Forget things specific to a particular gdb, may have changed. */
objfile->flags |= OBJF_MAPPED;
mmalloc_setkey (objfile->md, 0, objfile);
obstack_specify_allocation_with_arg (&objfile->psymbol_cache.cache,
- 0, 0, xmmalloc, mfree,
+ 0, 0, xmmalloc, xmfree,
objfile->md);
obstack_specify_allocation_with_arg (&objfile->psymbol_obstack,
- 0, 0, xmmalloc, mfree,
+ 0, 0, xmmalloc, xmfree,
objfile->md);
obstack_specify_allocation_with_arg (&objfile->symbol_obstack,
- 0, 0, xmmalloc, mfree,
+ 0, 0, xmmalloc, xmfree,
objfile->md);
obstack_specify_allocation_with_arg (&objfile->type_obstack,
- 0, 0, xmmalloc, mfree,
+ 0, 0, xmmalloc, xmfree,
objfile->md);
}
}
- if (mapped && (objfile == NULL))
+ if ((flags & OBJF_MAPPED) && (objfile == NULL))
{
warning ("symbol table for '%s' will not be mapped",
bfd_get_filename (abfd));
+ flags &= ~OBJF_MAPPED;
}
}
#else /* !defined(USE_MMALLOC) || !defined(HAVE_MMAP) */
- if (mapped)
+ if (flags & OBJF_MAPPED)
{
warning ("mapped symbol tables are not supported on this machine; missing or broken mmap().");
"mapped" keyword again. */
mapped_symbol_files = 0;
+ flags &= ~OBJF_MAPPED;
}
#endif /* defined(USE_MMALLOC) && defined(HAVE_MMAP) */
memset (objfile, 0, sizeof (struct objfile));
objfile->md = NULL;
obstack_specify_allocation (&objfile->psymbol_cache.cache, 0, 0,
- xmalloc, free);
+ xmalloc, xfree);
obstack_specify_allocation (&objfile->psymbol_obstack, 0, 0, xmalloc,
- free);
+ xfree);
obstack_specify_allocation (&objfile->symbol_obstack, 0, 0, xmalloc,
- free);
+ xfree);
obstack_specify_allocation (&objfile->type_obstack, 0, 0, xmalloc,
- free);
+ xfree);
+ flags &= ~OBJF_MAPPED;
}
/* Update the per-objfile information that comes from the bfd, ensuring
objfile->obfd = abfd;
if (objfile->name != NULL)
{
- mfree (objfile->md, objfile->name);
+ xmfree (objfile->md, objfile->name);
}
if (abfd != NULL)
{
}
}
+ /* 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;
+
/* Add this file onto the tail of the linked list of other such files. */
objfile->next = NULL;
last_one->next = objfile;
}
- /* Record whether this objfile was created because the user explicitly
- caused it (e.g., used the add-symbol-file command).
- */
- objfile->user_loaded = user_loaded;
-
- /* Record whether this objfile definitely represents a solib. */
- objfile->is_solib = is_solib;
+ /* Save passed in flag bits. */
+ objfile->flags |= flags;
return (objfile);
}
/* Put OBJFILE at the front of the list. */
void
-objfile_to_front (objfile)
- struct objfile *objfile;
+objfile_to_front (struct objfile *objfile)
{
struct objfile **objp;
for (objp = &object_files; *objp != NULL; objp = &((*objp)->next))
between the OBJFILE and the list. */
void
-unlink_objfile (objfile)
- struct objfile *objfile;
+unlink_objfile (struct objfile *objfile)
{
struct objfile **objpp;
{
*objpp = (*objpp)->next;
objfile->next = NULL;
- break;
+ return;
}
}
+
+ internal_error (__FILE__, __LINE__,
+ "unlink_objfile: objfile already unlinked");
}
we free objects in the reusable area. */
void
-free_objfile (objfile)
- struct objfile *objfile;
+free_objfile (struct objfile *objfile)
{
/* First do any symbol file specific actions required when we are
finished with a particular symbol file. Note that if the objfile
if (!bfd_close (objfile->obfd))
warning ("cannot close \"%s\": %s",
name, bfd_errmsg (bfd_get_error ()));
- free (name);
+ xfree (name);
}
/* Remove it from the chain of all objfiles. */
is unknown, but we play it safe for now and keep each action until
it is shown to be no longer needed. */
-#if defined (CLEAR_SOLIB)
- CLEAR_SOLIB ();
- /* CLEAR_SOLIB closes the bfd's for any shared libraries. But
- the to_sections for a core file might refer to those bfd's. So
- detach any core file. */
- {
- struct target_ops *t = find_core_target ();
- if (t != NULL)
- (t->to_detach) (NULL, 0);
- }
-#endif
/* I *think* all our callers call clear_symtab_users. If so, no need
to call this here. */
clear_pc_function_cache ();
/* The last thing we do is free the objfile struct itself for the
- non-reusable case, or detach from the mapped file for the reusable
- case. Note that the mmalloc_detach or the mfree is the last thing
- we can do with this objfile. */
+ non-reusable case, or detach from the mapped file for the
+ reusable case. Note that the mmalloc_detach or the xmfree() is
+ the last thing we can do with this objfile. */
#if defined(USE_MMALLOC) && defined(HAVE_MMAP)
{
if (objfile->name != NULL)
{
- mfree (objfile->md, objfile->name);
+ xmfree (objfile->md, objfile->name);
}
if (objfile->global_psymbols.list)
- mfree (objfile->md, objfile->global_psymbols.list);
+ xmfree (objfile->md, objfile->global_psymbols.list);
if (objfile->static_psymbols.list)
- mfree (objfile->md, objfile->static_psymbols.list);
+ xmfree (objfile->md, objfile->static_psymbols.list);
/* Free the obstacks for non-reusable objfiles */
- obstack_free (&objfile->psymbol_cache.cache, 0);
+ free_bcache (&objfile->psymbol_cache);
obstack_free (&objfile->psymbol_obstack, 0);
obstack_free (&objfile->symbol_obstack, 0);
obstack_free (&objfile->type_obstack, 0);
- mfree (objfile->md, objfile);
+ xmfree (objfile->md, objfile);
objfile = NULL;
}
}
+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);
+}
/* Free all the object files at once and clean up their users. */
void
-free_all_objfiles ()
+free_all_objfiles (void)
{
struct objfile *objfile, *temp;
/* Relocate OBJFILE to NEW_OFFSETS. There should be OBJFILE->NUM_SECTIONS
entries in new_offsets. */
void
-objfile_relocate (objfile, new_offsets)
- struct objfile *objfile;
- struct section_offsets *new_offsets;
+objfile_relocate (struct objfile *objfile, struct section_offsets *new_offsets)
{
- struct section_offsets *delta = (struct section_offsets *)
- alloca (sizeof (struct section_offsets)
- + objfile->num_sections * sizeof (delta->offsets));
+ struct section_offsets *delta =
+ (struct section_offsets *) alloca (SIZEOF_SECTION_OFFSETS);
{
int i;
int something_changed = 0;
for (i = 0; i < objfile->num_sections; ++i)
{
- ANOFFSET (delta, i) =
+ delta->offsets[i] =
ANOFFSET (new_offsets, i) - ANOFFSET (objfile->section_offsets, i);
if (ANOFFSET (delta, i) != 0)
something_changed = 1;
for (i = 0; i < BLOCKVECTOR_NBLOCKS (bv); ++i)
{
struct block *b;
+ struct symbol *sym;
int j;
b = BLOCKVECTOR_BLOCK (bv, i);
BLOCK_START (b) += ANOFFSET (delta, s->block_line_section);
BLOCK_END (b) += ANOFFSET (delta, s->block_line_section);
- for (j = 0; j < BLOCK_NSYMS (b); ++j)
+ ALL_BLOCK_SYMBOLS (b, j, sym)
{
- struct symbol *sym = BLOCK_SYM (b, j);
+ fixup_symbol_section (sym, objfile);
+
/* The RS6000 code from which this was taken skipped
any symbols in STRUCT_NAMESPACE or UNDEF_NAMESPACE.
But I'm leaving out that test, on the theory that
else if (SYMBOL_CLASS (sym) == LOC_CONST
&& SYMBOL_NAMESPACE (sym) == LABEL_NAMESPACE
- && STRCMP (SYMBOL_NAME (sym), MIPS_EFI_SYMBOL_NAME) == 0)
+ && strcmp (SYMBOL_NAME (sym), MIPS_EFI_SYMBOL_NAME) == 0)
ecoff_relocate_efi (sym, ANOFFSET (delta,
s->block_line_section));
#endif
ALL_OBJFILE_PSYMTABS (objfile, p)
{
- p->textlow += ANOFFSET (delta, SECT_OFF_TEXT);
- p->texthigh += ANOFFSET (delta, SECT_OFF_TEXT);
+ p->textlow += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
+ p->texthigh += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
}
}
for (psym = objfile->global_psymbols.list;
psym < objfile->global_psymbols.next;
psym++)
- if (SYMBOL_SECTION (*psym) >= 0)
- SYMBOL_VALUE_ADDRESS (*psym) += ANOFFSET (delta,
- SYMBOL_SECTION (*psym));
+ {
+ fixup_psymbol_section (*psym, objfile);
+ if (SYMBOL_SECTION (*psym) >= 0)
+ SYMBOL_VALUE_ADDRESS (*psym) += ANOFFSET (delta,
+ SYMBOL_SECTION (*psym));
+ }
for (psym = objfile->static_psymbols.list;
psym < objfile->static_psymbols.next;
psym++)
- if (SYMBOL_SECTION (*psym) >= 0)
- SYMBOL_VALUE_ADDRESS (*psym) += ANOFFSET (delta,
- SYMBOL_SECTION (*psym));
+ {
+ fixup_psymbol_section (*psym, objfile);
+ if (SYMBOL_SECTION (*psym) >= 0)
+ SYMBOL_VALUE_ADDRESS (*psym) += ANOFFSET (delta,
+ SYMBOL_SECTION (*psym));
+ }
}
{
{
int i;
for (i = 0; i < objfile->num_sections; ++i)
- ANOFFSET (objfile->section_offsets, i) = ANOFFSET (new_offsets, i);
+ (objfile->section_offsets)->offsets[i] = ANOFFSET (new_offsets, i);
}
+ if (objfile->ei.entry_point != ~(CORE_ADDR) 0)
+ {
+ /* Relocate ei.entry_point with its section offset, use SECT_OFF_TEXT
+ only as a fallback. */
+ struct obj_section *s;
+ s = find_pc_section (objfile->ei.entry_point);
+ if (s)
+ objfile->ei.entry_point += ANOFFSET (delta, s->the_bfd_section->index);
+ else
+ objfile->ei.entry_point += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
+ }
+
{
struct obj_section *s;
bfd *abfd;
ALL_OBJFILE_OSECTIONS (objfile, s)
{
- flagword flags;
-
- flags = bfd_get_section_flags (abfd, s->the_bfd_section);
-
- if (flags & SEC_CODE)
- {
- s->addr += ANOFFSET (delta, SECT_OFF_TEXT);
- s->endaddr += ANOFFSET (delta, SECT_OFF_TEXT);
- }
- else if (flags & (SEC_DATA | SEC_LOAD))
- {
- s->addr += ANOFFSET (delta, SECT_OFF_DATA);
- s->endaddr += ANOFFSET (delta, SECT_OFF_DATA);
- }
- else if (flags & SEC_ALLOC)
- {
- s->addr += ANOFFSET (delta, SECT_OFF_BSS);
- s->endaddr += ANOFFSET (delta, SECT_OFF_BSS);
- }
+ int idx = s->the_bfd_section->index;
+
+ s->addr += ANOFFSET (delta, idx);
+ s->endaddr += ANOFFSET (delta, idx);
}
}
- if (objfile->ei.entry_point != ~(CORE_ADDR) 0)
- objfile->ei.entry_point += ANOFFSET (delta, SECT_OFF_TEXT);
-
if (objfile->ei.entry_func_lowpc != INVALID_ENTRY_LOWPC)
{
- objfile->ei.entry_func_lowpc += ANOFFSET (delta, SECT_OFF_TEXT);
- objfile->ei.entry_func_highpc += ANOFFSET (delta, SECT_OFF_TEXT);
+ objfile->ei.entry_func_lowpc += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
+ objfile->ei.entry_func_highpc += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
}
if (objfile->ei.entry_file_lowpc != INVALID_ENTRY_LOWPC)
{
- objfile->ei.entry_file_lowpc += ANOFFSET (delta, SECT_OFF_TEXT);
- objfile->ei.entry_file_highpc += ANOFFSET (delta, SECT_OFF_TEXT);
+ objfile->ei.entry_file_lowpc += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
+ objfile->ei.entry_file_highpc += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
}
if (objfile->ei.main_func_lowpc != INVALID_ENTRY_LOWPC)
{
- objfile->ei.main_func_lowpc += ANOFFSET (delta, SECT_OFF_TEXT);
- objfile->ei.main_func_highpc += ANOFFSET (delta, SECT_OFF_TEXT);
+ objfile->ei.main_func_lowpc += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
+ objfile->ei.main_func_highpc += ANOFFSET (delta, SECT_OFF_TEXT (objfile));
}
/* Relocate breakpoints as necessary, after things are relocated. */
available, nonzero otherwise. */
int
-have_partial_symbols ()
+have_partial_symbols (void)
{
struct objfile *ofp;
available, nonzero otherwise. */
int
-have_full_symbols ()
+have_full_symbols (void)
{
struct objfile *ofp;
command.
*/
void
-objfile_purge_solibs ()
+objfile_purge_solibs (void)
{
struct objfile *objf;
struct objfile *temp;
/* We assume that the solib package has been purged already, or will
be soon.
*/
- if (!objf->user_loaded && objf->is_solib)
+ if (!(objf->flags & OBJF_USERLOADED) && (objf->flags & OBJF_SHARED))
free_objfile (objf);
}
}
available, nonzero otherwise. */
int
-have_minimal_symbols ()
+have_minimal_symbols (void)
{
struct objfile *ofp;
Otherwise, returns the open file descriptor. */
static int
-open_existing_mapped_file (symsfilename, mtime, mapped)
- char *symsfilename;
- long mtime;
- int mapped;
+open_existing_mapped_file (char *symsfilename, long mtime, int flags)
{
int fd = -1;
struct stat sbuf;
{
if (sbuf.st_mtime < mtime)
{
- if (!mapped)
+ if (!(flags & OBJF_MAPPED))
{
warning ("mapped symbol file `%s' is out of date, ignored it",
symsfilename);
/bin for example). */
static int
-open_mapped_file (filename, mtime, mapped)
- char *filename;
- long mtime;
- int mapped;
+open_mapped_file (char *filename, long mtime, int flags)
{
int fd;
char *symsfilename;
/* First try to open an existing file in the current directory, and
then try the directory where the symbol file is located. */
- symsfilename = concat ("./", basename (filename), ".syms", (char *) NULL);
- if ((fd = open_existing_mapped_file (symsfilename, mtime, mapped)) < 0)
+ symsfilename = concat ("./", lbasename (filename), ".syms", (char *) NULL);
+ if ((fd = open_existing_mapped_file (symsfilename, mtime, flags)) < 0)
{
- free (symsfilename);
+ xfree (symsfilename);
symsfilename = concat (filename, ".syms", (char *) NULL);
- fd = open_existing_mapped_file (symsfilename, mtime, mapped);
+ fd = open_existing_mapped_file (symsfilename, mtime, flags);
}
/* If we don't have an open file by now, then either the file does not
By default the file is rw for everyone, with the user's umask taking
care of turning off the permissions the user wants off. */
- if ((fd < 0) && mapped)
+ if ((fd < 0) && (flags & OBJF_MAPPED))
{
- free (symsfilename);
- symsfilename = concat ("./", basename (filename), ".syms",
+ xfree (symsfilename);
+ symsfilename = concat ("./", lbasename (filename), ".syms",
(char *) NULL);
if ((fd = open (symsfilename, O_RDWR | O_CREAT | O_TRUNC, 0666)) < 0)
{
}
}
- free (symsfilename);
+ xfree (symsfilename);
return (fd);
}
static PTR
-map_to_file (fd)
- int fd;
+map_to_file (int fd)
{
PTR md;
CORE_ADDR mapto;
contains a pointer to the bfd struct sec section. */
struct obj_section *
-find_pc_sect_section (pc, section)
- CORE_ADDR pc;
- struct sec *section;
+find_pc_sect_section (CORE_ADDR pc, struct sec *section)
{
struct obj_section *s;
struct objfile *objfile;
ALL_OBJSECTIONS (objfile, s)
-#if defined(HPUXHPPA)
- if ((section == 0 || section == s->the_bfd_section) &&
- s->addr <= pc && pc <= s->endaddr)
-#else
if ((section == 0 || section == s->the_bfd_section) &&
s->addr <= pc && pc < s->endaddr)
-#endif
return (s);
return (NULL);
Backward compatibility, no section. */
struct obj_section *
-find_pc_section (pc)
- CORE_ADDR pc;
+find_pc_section (CORE_ADDR pc)
{
return find_pc_sect_section (pc, find_pc_mapped_section (pc));
}
a trampoline. */
int
-in_plt_section (pc, name)
- CORE_ADDR pc;
- char *name;
+in_plt_section (CORE_ADDR pc, char *name)
{
struct obj_section *s;
int retval = 0;
&& STREQ (s->the_bfd_section->name, ".plt"));
return (retval);
}
+
+/* Return nonzero if NAME is in the import list of OBJFILE. Else
+ return zero. */
+
+int
+is_in_import_list (char *name, struct objfile *objfile)
+{
+ register int i;
+
+ if (!objfile || !name || !*name)
+ return 0;
+
+ for (i = 0; i < objfile->import_list_size; i++)
+ if (objfile->import_list[i] && STREQ (name, objfile->import_list[i]))
+ return 1;
+ return 0;
+}
+
projects / binutils.git / blobdiff