binutils-gdb/gdb/state.c

/* Support for dumping and reloading various pieces of GDB's internal state.
   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 provides support for dumping and then later reloading various
   portions of gdb's internal state.  It was originally implemented to
   support a need for mapping in an image of gdb's symbol table from an
   external file, where this image was created by an external program, such
   as an incremental linker.  However, it was generalized to enable future
   support for dumping and reloading various other useful pieces of gdb's
   internal state.

   State files have a fairly simple form which is intended to be easily
   extensible.  The basic format is:

	<file-header> <state-data> <form-tree>

   Where:

        file-header	A simple file-header containing a magic number
			so that gdb (and other readers) can quickly
			determine what kind of file this is, and a file
			offset to the root of the form-tree.

	state-data	The "raw" state-data that is referenced by nodes
			in the form-tree.

	form-tree	A tree of arbitrarily sized nodes containing
			information about gdb's internal state, and
			possibly referencing data in the state-data section
			of the file.  Resembles DWARF in some respects.

   When writing a state file, a hole is left for the file-header at the
   beginning of the file, the state data is written immediately after the
   file header (while storing the file offsets and sizes back into the
   internal form-tree along the way), the form-tree itself is written
   at the end of the file, and then the file header is written by seeking
   back to the beginning of the file.  This order is required because
   the form tree contains file offsets and sizes in the state data portion
   of the file, and the file header contains the file offset to the start
   of the form tree.

   Readers simply open the file, validate the magic number, seek to the
   root of the form-tree, and walk the tree looking for the information that
   they are interested in (and ignoring things that they aren't, or don't
   understand).

   */


#include <stdio.h>
#include "defs.h"
#include "symtab.h"
#include "bfd.h"
#include "symfile.h"
#include "state.h"

#ifndef SEEK_SET
#define SEEK_SET 0
#endif

#ifndef SEEK_END
#define SEEK_END 2
#endif

/* Inside the state file, the form-tree consists of a series of
   form-tree entries (FTE's).  The parent/child/sibling relationships
   are implied by the ordering and by an explicit sibling reference
   in FTE's that have siblings.

   Specifically, given two sequential FTE's, say A and B, if B immediately
   follows A, and A does not have a sibling reference to B, then B is
   the first child of A.  Otherwise B must be a sibling of A and A must
   have a sibling reference for it.

   Each FTE is simply an array of long integers, with at least three
   members.  This form was chosen over a packed data form for simplicity
   in access, not having to worry about the relative sizes of the different
   integers (short, int, long), and not having to worry about alignment
   constraints.  Also in the name of simplicity, every FTE has a sibling
   reference slot reserved for it, even if there are no siblings.

   The first value in an FTE is the size of the FTE in bytes, including
   the size value itself.  The second entry contains a tag which indicates
   the type of the FTE.  The third entry is a sibling reference, which either
   refers to a valid sibling node or is zero.  Following is zero or more
   attributes, each of which consists of one or more long values. */

/* Tag names and codes. */

#define TAG_padding	0x0000		/* Padding */
#define TAG_objfile	0x0001		/* Dumped objfile */

/* Form names, codes, and macros. */

#define FORM_ABSREF	0x01		/* Next long is absolute file offset */
#define FORM_RELREF	0x02		/* Next long is relative file offset */
#define FORM_IVAL	0x03		/* Next long is int value */
#define FORM_ADDR	0x04		/* Next long is mem addr */

#define FORM_MASK	0xFF
#define FORM_X(atr)	((atr) & FORM_MASK)

/* Attribute names and codes. */

#define AT_sibling	(0x0100 | FORM_RELREF)	/* Reference to sibling node */
#define AT_name		(0x0200 | FORM_ABSREF)	/* Reference to a string */
#define AT_offset	(0x0300 | FORM_ABSREF)	/* Reference to generic data */
#define AT_size		(0x0400 | FORM_IVAL)
#define AT_addr		(0x0500 | FORM_ADDR)
#define AT_aux_addr	(0x0600 | FORM_ADDR)

/* */

static void
load_symbols PARAMS ((FILE *));

static void
dump_state_command PARAMS ((char *, int));

static void
load_state_command PARAMS ((char *, int));

#ifdef HAVE_MMAP

static void
write_header PARAMS ((sfd *));

static void
write_formtree PARAMS ((sfd *));

static void
write_objfile_state PARAMS ((sfd *));

static void
free_subtree PARAMS ((struct formnode *));

static void
size_subtree PARAMS ((struct formnode *));

#endif

struct formnode *formtree = NULL;

/* ARGSUSED */
static void
load_symbols (statefile)
     FILE *statefile;
{

#if 0
  /* Discard old symbols.  FIXME: This is essentially symbol_file_command's
     body when there is no name.  Make it a common function that is
     called from each place. */

  if (symfile_objfile)
    {
      free_objfile (symfile_objfile);
    }
  symfile_objfile = NULL;
#endif

#if 0 && defined (HAVE_MMAP)
  if (mtop > mbase)
    {
      warning ("internal error: mbase (%08x) != mtop (%08x)",
	       mbase, mtop);
      munmap (mbase, mtop - mbase);
    }
#endif	/* HAVE_MMAP */

  /* Getting new symbols may change our opinion about what is frameless. */

  reinit_frame_cache ();

}

#ifdef HAVE_MMAP

/* Allocate a form node */

static struct formnode *
alloc_formnode ()
{
  struct formnode *fnp;

  fnp = (struct formnode *) xmalloc (sizeof (struct formnode));
  (void) memset (fnp, 0, sizeof (struct formnode));
  fnp -> sibling = formtree;
  formtree = fnp;
  return (fnp);
}

/* Recursively walk a form-tree from the specified node, freeing
   nodes from the bottom up.  The concept is pretty simple, just free
   all the child nodes, then all the sibling nodes, then the node
   itself. */

static void
free_subtree (fnp)
     struct formnode *fnp;
{
  if (fnp != NULL)
    {
      free_subtree (fnp -> child);
      free_subtree (fnp -> sibling);
      if (fnp -> nodedata != NULL)
	{
	  free (fnp -> nodedata);
	}
      free (fnp);
    }
}

/* Recursively walk a form-tree from the specified node, computing the
   size of each subtree from the bottom up.

   At each node, the file space that will be consumed by the subtree
   rooted in that node is the sum of all the subtrees rooted in each
   child node plus the size of the node itself.

   Thus for each node, we size the child subtrees, add to that our
   size, contribute this size towards the size of any parent node, and
   then ask any of our siblings to do the same.

   Also, once we know the size of any subtree rooted at this node, we
   can initialize the offset to the sibling node (if any).

   Since every form-tree node must have valid nodedata at this point,
   we detect and report a warning for any node that doesn't. */

static void
size_subtree (fnp)
     struct formnode *fnp;
{
  long *lp;

  if (fnp != NULL)
    {
      if (fnp -> nodedata == NULL)
	{
	  warning ("internal error -- empty form node");
	}
      else
	{
	  size_subtree (fnp -> child);
	  fnp -> treesize += *(long *) fnp -> nodedata;
	  if (fnp -> parent != NULL)
	    {
	      fnp -> parent -> treesize += fnp -> treesize;
	    }
	  if (fnp -> sibling)
	    {
	      size_subtree (fnp -> sibling);
	      lp = (long *) (fnp -> nodedata + 2 * sizeof (long));
	      *lp = fnp -> treesize;
	    }
	}
    }
}

/* Recursively walk a form-tree from the specified node, writing
   nodes from the top down. */

static void
write_subtree (fnp, asfd)
     struct formnode *fnp;
     sfd *asfd;
{
  if (fnp != NULL)
    {
      if (fnp -> nodedata != NULL)
	{
	  fwrite (fnp -> nodedata, *(long *) fnp -> nodedata, 1, asfd -> fp);
	}
      write_subtree (fnp -> child, asfd);
      write_subtree (fnp -> sibling, asfd);
    }
}

/* Free the entire current formtree.  Called via do_cleanups, regardless
   of whether there is an error or not. */

static void
free_formtree ()
{
  free_subtree (formtree);
  formtree = NULL;
}

/* Write out the file header.  Generally this is done last, even though
   it is located at the start of the file, since we need to have file
   offset to where the annotated form tree was written, and it's size. */

static void
write_header (asfd)
     sfd *asfd;
{
  fseek (asfd -> fp, 0L, SEEK_SET);
  fwrite ((char *) &asfd -> hdr, sizeof (asfd -> hdr), 1, asfd -> fp);
}

/* Write out the annotated form tree.  We should already have written out
   the state data, and noted the file offsets and sizes in each node of
   the form tree that references part of the state data.

   The form tree can be written anywhere in the file where there is room
   for it.  Since there is always room at the end of the file, we write
   it there.  We also need to record the file offset to the start of the
   form tree, and it's size, for future use when writing the file header.

   In order to compute the sibling references, we need to know, at
   each node, how much space will be consumed when all of that node's
   children nodes have been written.  Thus we walk the tree, computing
   the sizes of the subtrees from the bottom up.  At any node, the
   offset from the start of that node to the start of the sibling node
   is simply the size of the node plus the size of the subtree rooted
   in that node. */

static void
write_formtree (asfd)
     sfd *asfd;
{
  size_subtree (formtree);
  fseek (asfd -> fp, 0L, SEEK_END);
  asfd -> hdr.sf_ftoff = ftell (asfd -> fp);
  write_subtree (formtree, asfd);
  asfd -> hdr.sf_ftsize = ftell (asfd -> fp) - asfd -> hdr.sf_ftoff;
}

/* Note that we currently only support having one objfile with dumpable
   state. */

static void
write_objfile_state (asfd)
     sfd *asfd;
{
  struct objfile *objfile;
  struct formnode *fnp;
  PTR base;
  PTR breakval;
  long *lp;
  unsigned int ftesize;
  long ftebuf[64];
  long foffset;

  /* First walk through the objfile list looking for the first objfile
     that is dumpable. */

  for (objfile = object_files; objfile != NULL; objfile = objfile -> next)
    {
      if (objfile -> flags & OBJF_DUMPABLE)
	{
	  break;
	}
    }

  if (objfile == NULL)
    {
      warning ("no dumpable objfile was found");
    }
  else
    {
      fnp = alloc_formnode ();
      lp = ftebuf;

      lp++;			/* Skip FTE size slot, filled in at the end. */
      *lp++ = TAG_objfile;	/* This is an objfile FTE */
      *lp++ = 0;		/* Zero the sibling reference slot. */

      /* Build an AT_name attribute for the objfile's name, and write
	 the name into the state data. */

      *lp++ = AT_name;
      *lp++ = (long) ftell (asfd -> fp);
      fwrite (objfile -> name, strlen (objfile -> name) + 1, 1, asfd -> fp);

      /* Build an AT_addr attribute for the virtual address to which the
	 objfile data is mapped (and needs to be remapped when read in). */

      base = mmap_base ();
      *lp++ = AT_addr;
      *lp++ = (long) base;

      /* Build an AT_aux_addr attribute for the address of the objfile
	 structure itself, within the dumpable data.  When we read the objfile
	 back in, we use this address as the pointer the "struct objfile". */

      *lp++ = AT_aux_addr;
      *lp++ = (long) objfile;

      /* Reposition in state file to next paging boundry so we can mmap the
	 dumpable objfile data when we reload it. */

      foffset = (long) mmap_page_align ((PTR) ftell (asfd -> fp));
      fseek (asfd -> fp, foffset, SEEK_SET);

      /* Build an AT_offset attribute for the offset in the state file to
	 the start of the dumped objfile data. */

      *lp++ = AT_offset;
      *lp++ = (long) ftell (asfd -> fp);

      /* Build an AT_size attribute for the size of the dumped objfile data. */

      breakval = mmap_sbrk (0);
      *lp++ = AT_size;
      *lp++ = breakval - base;

      /* Write the dumpable data. */ 

      fwrite ((char *) base, breakval - base, 1, asfd -> fp);

      /* Now finish up the FTE by filling in the size slot based on
	 how much of the ftebuf we have used, allocate some memory for
	 it hung off the form tree node, and copy it there. */

      ftebuf[0] = (lp - ftebuf) * sizeof (ftebuf[0]);
      fnp -> nodedata = (char *) xmalloc (ftebuf[0]);
      memcpy (fnp -> nodedata, ftebuf, ftebuf[0]);
    }
}

static void
load_state_command (arg_string, from_tty)
     char *arg_string;
     int from_tty;
{
  char *filename;
  char **argv;
  FILE *fp;
  struct cleanup *cleanups;
  
  dont_repeat ();

  if (arg_string == NULL)
    {
      error ("load-state takes a file name and optional state specifiers");
    }
  else if ((argv = buildargv (arg_string)) == NULL)
    {
      fatal ("virtual memory exhausted.", 0);
    }
  cleanups = make_cleanup (freeargv, argv);

  filename = tilde_expand (*argv);
  make_cleanup (free, filename);

  if ((fp = fopen (filename, "r")) == NULL)
    {
      perror_with_name (filename);
    }
  make_cleanup (fclose, fp);
  immediate_quit++;

  while (*++argv != NULL)
    {
      if (strcmp (*argv, "symbols") == 0)
	{
	  if (from_tty
	      && !query ("load symbol table state from file \"%s\"? ",
			 filename))
	    {
	      error ("Not confirmed.");
	    }
	  load_symbols (fp);
	}
      else
	{
	  error ("unknown state specifier '%s'", *argv);
	}
    }
  immediate_quit--;
  do_cleanups (cleanups);
}

/* ARGSUSED */
static void
dump_state_command (arg_string, from_tty)
     char *arg_string;
     int from_tty;
{
  char *filename;
  char **argv;
  sfd *asfd;
  struct cleanup *cleanups;
  
  dont_repeat ();

  if (arg_string == NULL)
    {
      error ("dump-state takes a file name and state specifiers");
    }
  else if ((argv = buildargv (arg_string)) == NULL)
    {
      fatal ("virtual memory exhausted.", 0);
    }
  cleanups = make_cleanup (freeargv, argv);

  filename = tilde_expand (*argv);
  make_cleanup (free, filename);

  /* Now attempt to create a fresh state file. */

  if ((asfd = sfd_fopen (filename, "w")) == NULL)
    {
      perror_with_name (filename);
    }
  make_cleanup (sfd_fclose, asfd);
  make_cleanup (free_formtree, NULL);
  immediate_quit++;

  /* Now that we have an open and initialized state file, seek to the
     proper offset to start writing state data and the process the
     arguments.  For each argument, write the state data and initialize
     a form-tree node for each piece of state data. */

  fseek (asfd -> fp, sizeof (sf_hdr), SEEK_SET);
  while (*++argv != NULL)
    {
      if (strcmp (*argv, "objfile") == 0)
	{
	  write_objfile_state (asfd);
	}
      else
	{
	  error ("unknown state specifier '%s'", *argv);
	}

    }

  /* We have written any state data.  All that is left to do now is
     write the form-tree and the file header. */

  write_formtree (asfd);
  write_header (asfd);

  immediate_quit--;
  do_cleanups (cleanups);
}

static char *
find_fte_by_walk (thisfte, endfte, tag)
     char *thisfte;
     char *endfte;
     long tag;
{
  char *found = NULL;
  char *nextfte;
  long thistag;
  long thissize;
  long siboffset;

  while (thisfte < endfte)
    {
      if ((thistag = *(long *)(thisfte + sizeof (long))) == tag)
	{
	  found = thisfte;
	  break;
	}
      else
	{
	  thissize =  *(long *)(thisfte);
	  siboffset = *(long *)(thisfte + (2 * sizeof (long)));
	  nextfte = thisfte + (siboffset != 0 ? siboffset : thissize);
	  found = find_fte_by_walk (thisfte + thissize, nextfte, tag);
	  thisfte = nextfte;
	}
    }
  return (found);
}

/* Walk the form-tree looking for a specific FTE type.  Returns the first
   one found that matches the specified tag. */

static char *
find_fte (asfd, tag)
     sfd *asfd;
     long tag;
{
  char *ftbase;
  char *ftend;
  char *ftep;
  char *found = NULL;

  if (fseek (asfd -> fp, asfd -> hdr.sf_ftoff, SEEK_SET) == 0)
    {
      ftbase = xmalloc (asfd -> hdr.sf_ftsize);
      ftend = ftbase + asfd -> hdr.sf_ftsize;
      if (fread (ftbase, asfd -> hdr.sf_ftsize, 1, asfd -> fp) == 1)
	{
	  ftep = find_fte_by_walk (ftbase, ftend, tag);
	  if (ftep != NULL)
	    {
	      found = xmalloc (*(long *)ftep);
	      memcpy (found, ftep, (int) *(long *)ftep);
	    }
	}
      free (ftbase);
    }
  return (found);
}

struct objfile *
objfile_from_statefile (asfd)
     sfd *asfd;
{
  struct objfile *objfile = NULL;
  char *ftep;
  long *thisattr;
  long *endattr;
  PTR base;
  long foffset;
  long mapsize;

  ftep = find_fte (asfd, TAG_objfile);
  thisattr = (long *) (ftep + 3 * sizeof (long));
  endattr = (long *) (ftep + *(long *)ftep);
  while (thisattr < endattr)
    {
      switch (*thisattr++)
	{
	  case AT_name:
	    /* Ignore for now */
	    thisattr++;
	    break;
	  case AT_addr:
	    base = (PTR) *thisattr++;
	    break;
	  case AT_aux_addr:
	    objfile = (struct objfile *) *thisattr++;
	    break;
	  case AT_offset:
	    foffset = *thisattr++;
	    break;
	  case AT_size:
	    mapsize = *thisattr++;
	    break;
	}
    }
  if (mmap_remap (base, mapsize, (int) fileno (asfd -> fp), foffset) != base)
    {
      print_sys_errmsg (asfd -> filename, errno);
      error ("mapping failed");
    }

  return (objfile);
}

#else

struct objfile *
objfile_from_statefile (asfd)
     sfd *asfd;
{
  error ("this version of gdb doesn't support reloading symtabs from state files");
}

#endif	/* HAVE_MMAP */

/* Close a state file, freeing all memory that was used by the state
   file descriptor, closing the raw file pointer, etc. */

void
sfd_fclose (asfd)
     sfd *asfd;
{
  if (asfd != NULL)
    {
      if (asfd -> fp != NULL)
	{
	  fclose (asfd -> fp);
	}
      if (asfd -> filename != NULL)
	{
	  free (asfd -> filename);
	}
      free (asfd);
    }
}

/* Given the name of a possible statefile, and flags to use to open it,
   try to open the file and prepare it for use.

   If the flags contain 'r', then we want to read an existing state
   file, so attempt to read in the state file header and determine if this
   is a valid state file.  If not, return NULL.

   Returns a pointer to a properly initialized state file descriptor if
   successful. */

sfd *
sfd_fopen (name, flags)
     char *name;
     char *flags;
{
  int success = 0;
  sfd *asfd;

  asfd = (sfd *) xmalloc (sizeof (sfd));
  (void) memset (asfd, 0, sizeof (sfd));
  asfd -> filename = xmalloc (strlen (name) + 1);
  (void) strcpy (asfd -> filename, name);

  if ((asfd -> fp = fopen (asfd -> filename, flags)) != NULL)
    {
      /* We have the file, now see if we are reading an existing file
	 or writing to a new file.  We don't currently support "rw". */
      if (strchr (flags, 'r') != NULL)
	{
	  if (fread ((char *) &asfd -> hdr, sizeof (asfd -> hdr), 1,
		     asfd -> fp) == 1)
	    {
	      if (SF_GOOD_MAGIC (asfd))
		{
		  success = 1;
		}
	    }
	}
      else
	{
	  /* This is a new state file.  Initialize various things. */
	  asfd -> hdr.sf_mag0 = SF_MAG0;
	  asfd -> hdr.sf_mag1 = SF_MAG1;
	  asfd -> hdr.sf_mag2 = SF_MAG2;
	  asfd -> hdr.sf_mag3 = SF_MAG3;
	  success = 1;
	}
    }

  if (!success)
    {
      sfd_fclose (asfd);
      asfd = NULL;
    }
  return (asfd);
  
}


void
_initialize_state ()
{

#ifdef HAVE_MMAP

  add_com ("load-state", class_support, load_state_command,
   "Load some saved gdb state from FILE.\n\
Select and load some portion of gdb's saved state from the specified file.\n\
The dump-state command may be used to save various portions of gdb's\n\
internal state.");

  add_com ("dump-state", class_support, dump_state_command,
   "Dump some of gdb's state to FILE.\n\
Select and dump some portion of gdb's internal state to the specified file.\n\
The load-state command may be used to reload various portions of gdb's\n\
internal state from the file.");

#endif	/* HAVE_MMAP */

}