-/* 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);
-
-}
-
-\f
-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 */
-
-}
projects / deliverable / binutils-gdb.git / blobdiff