777 lines
20 KiB
C
777 lines
20 KiB
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 */
|
||
|
||
}
|