524 lines
15 KiB
C
524 lines
15 KiB
C
/* GDB routines for manipulating objfiles.
|
|
Copyright 1992 Free Software Foundation, Inc.
|
|
Contributed by Cygnus Support, using pieces from other GDB modules.
|
|
|
|
This file is part of GDB.
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
|
|
|
|
/* This file contains support routines for creating, manipulating, and
|
|
destroying objfile structures. */
|
|
|
|
#include "defs.h"
|
|
#include "bfd.h" /* Binary File Description */
|
|
#include "symtab.h"
|
|
#include "symfile.h"
|
|
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <fcntl.h>
|
|
#include <obstack.h>
|
|
|
|
/* Prototypes for local functions */
|
|
|
|
static int
|
|
open_mapped_file PARAMS ((char *basefile, long mtime, int mapped));
|
|
|
|
static CORE_ADDR
|
|
map_to_address PARAMS ((void));
|
|
|
|
/* Externally visible variables that are owned by this module. */
|
|
|
|
struct objfile *object_files; /* Linked list of all objfiles */
|
|
int mapped_symbol_files; /* Try to use mapped symbol files */
|
|
|
|
/* Allocate a new objfile struct, fill it in as best we can, and return it.
|
|
It is also linked into the list of all known object files. */
|
|
|
|
struct objfile *
|
|
allocate_objfile (abfd, filename, mapped)
|
|
bfd *abfd;
|
|
char *filename;
|
|
int mapped;
|
|
{
|
|
struct objfile *objfile = NULL;
|
|
int fd;
|
|
void *md;
|
|
CORE_ADDR mapto;
|
|
|
|
mapped |= mapped_symbol_files;
|
|
|
|
#if !defined(NO_MMALLOC) && defined(HAVE_MMAP)
|
|
|
|
/* If we can support mapped symbol files, try to open/reopen the mapped file
|
|
that corresponds to the file from which we wish to read symbols. If the
|
|
objfile is to be mapped, we must malloc the structure itself using the
|
|
mmap version, and arrange that all memory allocation for the objfile uses
|
|
the mmap routines. If we are reusing an existing mapped file, from which
|
|
we get our objfile pointer, we have to make sure that we update the
|
|
pointers to the alloc/free functions in the obstack, in case these
|
|
functions have moved within the current gdb. */
|
|
|
|
fd = open_mapped_file (filename, bfd_get_mtime (abfd), mapped);
|
|
if (fd >= 0)
|
|
{
|
|
if (((mapto = map_to_address ()) == NULL) ||
|
|
((md = mmalloc_attach (fd, (void *) mapto)) == NULL))
|
|
{
|
|
close (fd);
|
|
}
|
|
else if ((objfile = (struct objfile *) mmalloc_getkey (md, 0)) != NULL)
|
|
{
|
|
objfile -> md = md;
|
|
/* Update pointers to functions to *our* copies */
|
|
obstack_chunkfun (&objfile -> psymbol_obstack, xmmalloc);
|
|
obstack_freefun (&objfile -> psymbol_obstack, mfree);
|
|
obstack_chunkfun (&objfile -> symbol_obstack, xmmalloc);
|
|
obstack_freefun (&objfile -> symbol_obstack, mfree);
|
|
obstack_chunkfun (&objfile -> type_obstack, xmmalloc);
|
|
obstack_freefun (&objfile -> type_obstack, mfree);
|
|
/* Update memory corruption handler function addresses */
|
|
init_malloc (objfile -> md);
|
|
}
|
|
else
|
|
{
|
|
objfile = (struct objfile *) xmmalloc (md, sizeof (struct objfile));
|
|
(void) memset (objfile, 0, sizeof (struct objfile));
|
|
objfile -> md = md;
|
|
objfile -> flags |= OBJF_MAPPED;
|
|
mmalloc_setkey (objfile -> md, 0, objfile);
|
|
obstack_full_begin (&objfile -> psymbol_obstack, 0, 0,
|
|
xmmalloc, mfree, objfile -> md,
|
|
OBSTACK_MMALLOC_LIKE);
|
|
obstack_full_begin (&objfile -> symbol_obstack, 0, 0,
|
|
xmmalloc, mfree, objfile -> md,
|
|
OBSTACK_MMALLOC_LIKE);
|
|
obstack_full_begin (&objfile -> type_obstack, 0, 0,
|
|
xmmalloc, mfree, objfile -> md,
|
|
OBSTACK_MMALLOC_LIKE);
|
|
/* Set up to detect internal memory corruption */
|
|
init_malloc (objfile -> md);
|
|
}
|
|
}
|
|
|
|
if (mapped && (objfile == NULL))
|
|
{
|
|
warning ("symbol table for '%s' will not be mapped", filename);
|
|
}
|
|
|
|
#else /* defined(NO_MMALLOC) || !defined(HAVE_MMAP) */
|
|
|
|
if (mapped)
|
|
{
|
|
warning ("this version of gdb does not support mapped symbol tables.");
|
|
|
|
/* Turn off the global flag so we don't try to do mapped symbol tables
|
|
any more, which shuts up gdb unless the user specifically gives the
|
|
"mapped" keyword again. */
|
|
|
|
mapped_symbol_files = 0;
|
|
}
|
|
|
|
#endif /* !defined(NO_MMALLOC) && defined(HAVE_MMAP) */
|
|
|
|
/* If we don't support mapped symbol files, didn't ask for the file to be
|
|
mapped, or failed to open the mapped file for some reason, then revert
|
|
back to an unmapped objfile. */
|
|
|
|
if (objfile == NULL)
|
|
{
|
|
objfile = (struct objfile *) xmalloc (sizeof (struct objfile));
|
|
(void) memset (objfile, 0, sizeof (struct objfile));
|
|
objfile -> md = NULL;
|
|
obstack_full_begin (&objfile -> psymbol_obstack, 0, 0, xmalloc, free,
|
|
(void *) 0, 0);
|
|
obstack_full_begin (&objfile -> symbol_obstack, 0, 0, xmalloc, free,
|
|
(void *) 0, 0);
|
|
obstack_full_begin (&objfile -> type_obstack, 0, 0, xmalloc, free,
|
|
(void *) 0, 0);
|
|
|
|
}
|
|
|
|
/* Now, malloc a fresh copy of the filename string. */
|
|
|
|
objfile -> name = xmmalloc (objfile -> md, strlen (filename) + 1);
|
|
strcpy (objfile -> name, filename);
|
|
|
|
objfile -> obfd = abfd;
|
|
|
|
objfile -> mtime = bfd_get_mtime (abfd);
|
|
|
|
/* Push this file onto the head of the linked list of other such files. */
|
|
|
|
objfile -> next = object_files;
|
|
object_files = objfile;
|
|
|
|
return (objfile);
|
|
}
|
|
|
|
|
|
/* Destroy an objfile and all the symtabs and psymtabs under it. Note
|
|
that as much as possible is allocated on the symbol_obstack and
|
|
psymbol_obstack, so that the memory can be efficiently freed. */
|
|
|
|
void
|
|
free_objfile (objfile)
|
|
struct objfile *objfile;
|
|
{
|
|
struct objfile *ofp;
|
|
|
|
if (objfile -> name)
|
|
{
|
|
mfree (objfile -> md, objfile -> name);
|
|
}
|
|
if (objfile -> obfd)
|
|
{
|
|
bfd_close (objfile -> obfd);
|
|
}
|
|
|
|
/* Remove it from the chain of all objfiles. */
|
|
|
|
if (object_files == objfile)
|
|
{
|
|
object_files = objfile -> next;
|
|
}
|
|
else
|
|
{
|
|
for (ofp = object_files; ofp; ofp = ofp -> next)
|
|
{
|
|
if (ofp -> next == objfile)
|
|
{
|
|
ofp -> next = objfile -> next;
|
|
}
|
|
}
|
|
}
|
|
|
|
obstack_free (&objfile -> psymbol_obstack, 0);
|
|
obstack_free (&objfile -> symbol_obstack, 0);
|
|
obstack_free (&objfile -> type_obstack, 0);
|
|
|
|
#if 0 /* FIXME!! */
|
|
|
|
/* Before the symbol table code was redone to make it easier to
|
|
selectively load and remove information particular to a specific
|
|
linkage unit, gdb used to do these things whenever the monolithic
|
|
symbol table was blown away. How much still needs to be done
|
|
is unknown, but we play it safe for now and keep each action until
|
|
it is shown to be no longer needed. */
|
|
|
|
clear_symtab_users_once ();
|
|
#if defined (CLEAR_SOLIB)
|
|
CLEAR_SOLIB ();
|
|
#endif
|
|
clear_pc_function_cache ();
|
|
|
|
#endif
|
|
|
|
/* The last thing we do is free the objfile struct itself */
|
|
|
|
mfree (objfile -> md, objfile);
|
|
}
|
|
|
|
|
|
/* Free all the object files at once. */
|
|
|
|
void
|
|
free_all_objfiles ()
|
|
{
|
|
struct objfile *objfile, *temp;
|
|
|
|
ALL_OBJFILES_SAFE (objfile, temp)
|
|
{
|
|
free_objfile (objfile);
|
|
}
|
|
}
|
|
|
|
/* Many places in gdb want to test just to see if we have any partial
|
|
symbols available. This function returns zero if none are currently
|
|
available, nonzero otherwise. */
|
|
|
|
int
|
|
have_partial_symbols ()
|
|
{
|
|
struct objfile *ofp;
|
|
int havethem = 0;
|
|
|
|
for (ofp = object_files; ofp; ofp = ofp -> next)
|
|
{
|
|
if (ofp -> psymtabs != NULL)
|
|
{
|
|
havethem++;
|
|
break;
|
|
}
|
|
}
|
|
return (havethem);
|
|
}
|
|
|
|
/* Many places in gdb want to test just to see if we have any full
|
|
symbols available. This function returns zero if none are currently
|
|
available, nonzero otherwise. */
|
|
|
|
int
|
|
have_full_symbols ()
|
|
{
|
|
struct objfile *ofp;
|
|
int havethem = 0;
|
|
|
|
for (ofp = object_files; ofp; ofp = ofp -> next)
|
|
{
|
|
if (ofp -> symtabs != NULL)
|
|
{
|
|
havethem++;
|
|
break;
|
|
}
|
|
}
|
|
return (havethem);
|
|
}
|
|
|
|
/* Many places in gdb want to test just to see if we have any minimal
|
|
symbols available. This function returns zero if none are currently
|
|
available, nonzero otherwise. */
|
|
|
|
int
|
|
have_minimal_symbols ()
|
|
{
|
|
struct objfile *ofp;
|
|
int havethem = 0;
|
|
|
|
for (ofp = object_files; ofp; ofp = ofp -> next)
|
|
{
|
|
if (ofp -> msymbols != NULL)
|
|
{
|
|
havethem++;
|
|
break;
|
|
}
|
|
}
|
|
return (havethem);
|
|
}
|
|
|
|
/* Call the function specified by FUNC for each currently available objfile,
|
|
for as long as this function continues to return NULL. If the function
|
|
ever returns non-NULL, then the iteration over the objfiles is terminated,
|
|
and the result is returned to the caller. The function called has full
|
|
control over the form and content of the information returned via the
|
|
non-NULL result, which may be as simple as a pointer to the objfile that
|
|
the iteration terminated on, or as complex as a pointer to a private
|
|
structure containing multiple results. */
|
|
|
|
PTR
|
|
iterate_over_objfiles (func, arg1, arg2, arg3)
|
|
PTR (*func) PARAMS ((struct objfile *, PTR, PTR, PTR));
|
|
PTR arg1;
|
|
PTR arg2;
|
|
PTR arg3;
|
|
{
|
|
register struct objfile *objfile;
|
|
PTR result = NULL;
|
|
|
|
for (objfile = object_files;
|
|
objfile != NULL && result == NULL;
|
|
objfile = objfile -> next)
|
|
{
|
|
result = (*func)(objfile, arg1, arg2, arg3);
|
|
}
|
|
return (result);
|
|
}
|
|
|
|
/* Call the function specified by FUNC for each currently available symbol
|
|
table, for as long as this function continues to return NULL. If the
|
|
function ever returns non-NULL, then the iteration over the symbol tables
|
|
is terminated, and the result is returned to the caller. The function
|
|
called has full control over the form and content of the information
|
|
returned via the non-NULL result, which may be as simple as a pointer
|
|
to the symtab that the iteration terminated on, or as complex as a
|
|
pointer to a private structure containing multiple results. */
|
|
|
|
PTR
|
|
iterate_over_symtabs (func, arg1, arg2, arg3)
|
|
PTR (*func) PARAMS ((struct objfile *, struct symtab *, PTR, PTR, PTR));
|
|
PTR arg1;
|
|
PTR arg2;
|
|
PTR arg3;
|
|
{
|
|
register struct objfile *objfile;
|
|
register struct symtab *symtab;
|
|
PTR result = NULL;
|
|
|
|
for (objfile = object_files;
|
|
objfile != NULL && result == NULL;
|
|
objfile = objfile -> next)
|
|
{
|
|
for (symtab = objfile -> symtabs;
|
|
symtab != NULL && result == NULL;
|
|
symtab = symtab -> next)
|
|
{
|
|
result = (*func)(objfile, symtab, arg1, arg2, arg3);
|
|
}
|
|
}
|
|
return (result);
|
|
}
|
|
|
|
/* Call the function specified by FUNC for each currently available partial
|
|
symbol table, for as long as this function continues to return NULL. If
|
|
the function ever returns non-NULL, then the iteration over the partial
|
|
symbol tables is terminated, and the result is returned to the caller.
|
|
|
|
The function called has full control over the form and content of the
|
|
information returned via the non-NULL result, which may be as simple as a
|
|
pointer to the partial symbol table that the iteration terminated on, or
|
|
as complex as a pointer to a private structure containing multiple
|
|
results. */
|
|
|
|
PTR
|
|
iterate_over_psymtabs (func, arg1, arg2, arg3)
|
|
PTR (*func) PARAMS ((struct objfile *, struct partial_symtab *,
|
|
PTR, PTR, PTR));
|
|
PTR arg1;
|
|
PTR arg2;
|
|
PTR arg3;
|
|
{
|
|
register struct objfile *objfile;
|
|
register struct partial_symtab *psymtab;
|
|
PTR result = NULL;
|
|
|
|
for (objfile = object_files;
|
|
objfile != NULL && result == NULL;
|
|
objfile = objfile -> next)
|
|
{
|
|
for (psymtab = objfile -> psymtabs;
|
|
psymtab != NULL && result == NULL;
|
|
psymtab = psymtab -> next)
|
|
{
|
|
result = (*func)(objfile, psymtab, arg1, arg2, arg3);
|
|
}
|
|
}
|
|
return (result);
|
|
}
|
|
|
|
|
|
/* Look for a mapped symbol file that corresponds to BASEFILE and is more
|
|
recent than MTIME. If MAPPED is nonzero, the user has asked that gdb
|
|
use a mapped symbol file for this base file, so create a new one if
|
|
one does not currently exist.
|
|
|
|
If found, then return an open file descriptor for the file, otherwise
|
|
return -1.
|
|
|
|
This routine is responsible for implementing the policy that generates
|
|
the name of the mapped symbol file from the name of a file containing
|
|
symbols that gdb would like to read. */
|
|
|
|
static int
|
|
open_mapped_file (basefile, mtime, mapped)
|
|
char *basefile;
|
|
long mtime;
|
|
int mapped;
|
|
{
|
|
int fd;
|
|
char *symfilename;
|
|
struct stat sbuf;
|
|
|
|
/* For now, all we do is look in the local directory for a file with
|
|
the name of the base file and an extension of ".syms" */
|
|
|
|
symfilename = concat ("./", basename (basefile), ".syms", (char *) NULL);
|
|
|
|
/* Check to see if the desired file already exists and is more recent than
|
|
the corresponding base file (specified by the passed MTIME parameter).
|
|
The open will fail if the file does not already exist. */
|
|
|
|
if ((fd = open (symfilename, O_RDWR)) >= 0)
|
|
{
|
|
if (fstat (fd, &sbuf) != 0)
|
|
{
|
|
close (fd);
|
|
perror_with_name (symfilename);
|
|
}
|
|
else if (sbuf.st_mtime > mtime)
|
|
{
|
|
return (fd);
|
|
}
|
|
else
|
|
{
|
|
close (fd);
|
|
fd = -1;
|
|
}
|
|
}
|
|
|
|
/* Either the file does not already exist, or the base file has changed
|
|
since it was created. In either case, if the user has specified use of
|
|
a mapped file, then create a new mapped file, truncating any existing
|
|
one.
|
|
|
|
In the case where there is an existing file, but it is out of date, and
|
|
the user did not specify mapped, the existing file is just silently
|
|
ignored. Perhaps we should warn about this case (FIXME?).
|
|
|
|
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 (mapped)
|
|
{
|
|
fd = open (symfilename, O_RDWR | O_CREAT | O_TRUNC, 0666);
|
|
}
|
|
|
|
return (fd);
|
|
}
|
|
|
|
/* Return the base address at which we would like the next objfile's
|
|
mapped data to start.
|
|
|
|
For now, we use the kludge that the configuration specifies a base
|
|
address to which it is safe to map the first mmalloc heap, and an
|
|
increment to add to this address for each successive heap. There are
|
|
a lot of issues to deal with here to make this work reasonably, including:
|
|
|
|
Avoid memory collisions with existing mapped address spaces
|
|
|
|
Reclaim address spaces when their mmalloc heaps are unmapped
|
|
|
|
When mmalloc heaps are shared between processes they have to be
|
|
mapped at the same addresses in each
|
|
|
|
Once created, a mmalloc heap that is to be mapped back in must be
|
|
mapped at the original address. I.E. each objfile will expect to
|
|
be remapped at it's original address. This becomes a problem if
|
|
the desired address is already in use.
|
|
|
|
etc, etc, etc.
|
|
|
|
*/
|
|
|
|
|
|
static CORE_ADDR
|
|
map_to_address ()
|
|
{
|
|
|
|
#if defined(MMAP_BASE_ADDRESS) && defined (MMAP_INCREMENT)
|
|
|
|
static CORE_ADDR next = MMAP_BASE_ADDRESS;
|
|
CORE_ADDR mapto = next;
|
|
|
|
next += MMAP_INCREMENT;
|
|
return (mapto);
|
|
|
|
#else
|
|
|
|
return (0);
|
|
|
|
#endif
|
|
|
|
}
|