/* 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 flags));
+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
member. */
struct objfile *
-allocate_objfile (abfd, flags)
- bfd *abfd;
- int flags;
+allocate_objfile (bfd *abfd, int flags)
{
struct objfile *objfile = NULL;
struct objfile *last_one = NULL;
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);
}
}
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;
}
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;
/* 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_SECTION_OFFSETS);
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;
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, flags)
- char *symsfilename;
- long mtime;
- int flags;
+open_existing_mapped_file (char *symsfilename, long mtime, int flags)
{
int fd = -1;
struct stat sbuf;
/bin for example). */
static int
-open_mapped_file (filename, mtime, flags)
- char *filename;
- long mtime;
- int flags;
+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);
+ 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;
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;
return zero. */
int
-is_in_import_list (name, objfile)
- char *name;
- struct objfile *objfile;
+is_in_import_list (char *name, struct objfile *objfile)
{
register int i;
projects / deliverable / binutils-gdb.git / blobdiff