path: root/gdb/objfiles.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

}