[deliverable/binutils-gdb.git] / gdb / core.c

/* Work with core dump and executable files, for GDB.
   Copyright (C) 1986, 1987, 1989 Free Software Foundation, Inc.

This file is part of GDB.

GDB 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 1, or (at your option)
any later version.

GDB 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 GDB; see the file COPYING.  If not, write to
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */

#include <stdio.h>
#include <errno.h>
#include <signal.h>
#include "defs.h"
#include "param.h"
#include "frame.h"  /* required by inferior.h */
#include "inferior.h"
#include "symtab.h"
#include "command.h"
#include "bfd.h"
#include "target.h"
#include "gdbcore.h"

extern int xfer_memory ();
extern void child_attach (), child_create_inferior ();

extern int sys_nerr;
extern char *sys_errlist[];
extern char *sys_siglist[];

extern char registers[];

/* Hook for `exec_file_command' command to call.  */

void (*exec_file_display_hook) () = NULL;

struct section_table *core_sections, *core_sections_end;

/* Binary file diddling handle for the core file.  */

bfd *core_bfd = NULL;

/* Forward decl */
extern struct target_ops core_ops;

\f
/* Discard all vestiges of any previous core file
   and mark data and stack spaces as empty.  */

/* ARGSUSED */
void
core_close (quitting)
     int quitting;
{
  if (core_bfd) {
    free (bfd_get_filename (core_bfd));
    bfd_close (core_bfd);
    core_bfd = NULL;
#ifdef CLEAR_SOLIB
    CLEAR_SOLIB ();
#endif
  }
}

/* This routine opens and sets up the core file bfd */

void
core_open (filename, from_tty)
     char *filename;
     int from_tty;
{
  char *p;
  int siggy;
  struct cleanup *old_chain;
  char *temp;
  bfd *temp_bfd;
  int ontop;

  target_preopen (from_tty);
  if (!filename)
    {
      error (core_bfd? 
       "No core file specified.  (Use `detach' to stop debugging a core file.)"
     : "No core file specified.");
    }

  filename = tilde_expand (filename);
  if (filename[0] != '/') {
    temp = concat (current_directory, "/", filename);
    free (filename);
    filename = temp;
  }

  old_chain = make_cleanup (free, filename);
  temp_bfd = bfd_openr (filename, NULL);
  if (temp_bfd == NULL)
    {
      perror_with_name (filename);
    }

  if (!bfd_check_format (temp_bfd, bfd_core))
    {
      bfd_close (temp_bfd);
      error ("\"%s\" does not appear to be a core dump", filename);
    }

  /* Looks semi-reasonable.  Toss the old core file and work on the new.  */

  discard_cleanups (old_chain);		/* Don't free filename any more */
  unpush_target (&core_ops);
  core_bfd = temp_bfd;
  old_chain = make_cleanup (core_close, core_bfd);

  validate_files ();

  /* Find the data section */
  if (build_section_table (core_bfd, &core_sections, &core_sections_end))
    error ("Can't find sections in `%s': %s", bfd_get_filename(core_bfd),
	   bfd_errmsg (bfd_error));

  ontop = !push_target (&core_ops);
  make_cleanup (unpush_target, &core_ops);

  p = bfd_core_file_failing_command (core_bfd);
  if (p)
    printf ("Core file invoked as `%s'.\n", p);

  siggy = bfd_core_file_failing_signal (core_bfd);
  if (siggy > 0)
    printf ("Program terminated with signal %d, %s.\n", siggy,
	    siggy < NSIG ? sys_siglist[siggy] : "(undocumented)");

  if (ontop) {
    /* Fetch all registers from core file */
    target_fetch_registers (-1);
    /* Add symbols for any shared libraries that were in use */
#ifdef SOLIB_ADD
    SOLIB_ADD (NULL, from_tty);
#endif
    /* Now, set up the frame cache, and print the top of stack */
    set_current_frame ( create_new_frame (read_register (FP_REGNUM),
					  read_pc ()));
    select_frame (get_current_frame (), 0);
    print_sel_frame (0);	/* Print the top frame and source line */
  } else {
    printf (
"Warning: you won't be able to access this core file until you terminate\n\
your %s; do ``info files''\n", current_target->to_longname);
  }

  discard_cleanups (old_chain);
}

void
core_detach (args, from_tty)
     char *args;
     int from_tty;
{
  if (args)
    error ("Too many arguments");
  unpush_target (&core_ops);
  if (from_tty)
    printf ("No core file now.\n");
}

/* Backward compatability with old way of specifying core files.  */

void
core_file_command (filename, from_tty)
     char *filename;
     int from_tty;
{
  dont_repeat ();			/* Either way, seems bogus. */
  if (!filename)
    core_detach (filename, from_tty);
  else
    core_open (filename, from_tty);
}

\f
/* Call this to specify the hook for exec_file_command to call back.
   This is called from the x-window display code.  */

void
specify_exec_file_hook (hook)
     void (*hook) ();
{
  exec_file_display_hook = hook;
}

/* The exec file must be closed before running an inferior.
   If it is needed again after the inferior dies, it must
   be reopened.  */

void
close_exec_file ()
{
#ifdef FIXME
  if (exec_bfd)
    bfd_tempclose (exec_bfd);
#endif
}

void
reopen_exec_file ()
{
#ifdef FIXME
  if (exec_bfd)
    bfd_reopen (exec_bfd);
#endif
}
\f
/* If we have both a core file and an exec file,
   print a warning if they don't go together.
   This should really check that the core file came
   from that exec file, but I don't know how to do it.  */

void
validate_files ()
{
  if (exec_bfd && core_bfd)
    {
      if (core_file_matches_executable_p (core_bfd, exec_bfd))
	printf ("Warning: core file does not match specified executable file.\n");
      else if (bfd_get_mtime(exec_bfd) > bfd_get_mtime(core_bfd))
	printf ("Warning: exec file is newer than core file.\n");
    }
}

/* Return the name of the executable file as a string.
   ERR nonzero means get error if there is none specified;
   otherwise return 0 in that case.  */

char *
get_exec_file (err)
     int err;
{
  if (exec_bfd) return bfd_get_filename(exec_bfd);
  if (!err)     return NULL;

  error ("No executable file specified.\n\
Use the \"file\" or \"exec-file\" command.");
  return NULL;
}

static void
core_files_info ()
{
  struct section_table *p;

  printf ("\tCore file `%s'.\n", bfd_get_filename(core_bfd));

  for (p = core_sections; p < core_sections_end; p++)
    printf("\tcore file  from 0x%08x to 0x%08x is %s\n",
	p->addr, p->endaddr,
	bfd_section_name (core_bfd, p->sec_ptr));
}
\f
void
memory_error (status, memaddr)
     int status;
     CORE_ADDR memaddr;
{

  if (status == EIO)
    {
      /* Actually, address between memaddr and memaddr + len
	 was out of bounds. */
      error ("Cannot access memory: address 0x%x out of bounds.", memaddr);
    }
  else
    {
      if (status >= sys_nerr || status < 0)
	error ("Error accessing memory address 0x%x: unknown error (%d).",
	       memaddr, status);
      else
	error ("Error accessing memory address 0x%x: %s.",
	       memaddr, sys_errlist[status]);
    }
}

/* Same as target_read_memory, but report an error if can't read.  */
void
read_memory (memaddr, myaddr, len)
     CORE_ADDR memaddr;
     char *myaddr;
     int len;
{
  int status;
  status = target_read_memory (memaddr, myaddr, len);
  if (status != 0)
    memory_error (status, memaddr);
}

/* Same as target_write_memory, but report an error if can't write.  */
void
write_memory (memaddr, myaddr, len)
     CORE_ADDR memaddr;
     char *myaddr;
     int len;
{
  int status;

  status = target_write_memory (memaddr, myaddr, len);
  if (status != 0)
    memory_error (status, memaddr);
}

/* Read an integer from debugged memory, given address and number of bytes.  */

long
read_memory_integer (memaddr, len)
     CORE_ADDR memaddr;
     int len;
{
  char cbuf;
  short sbuf;
  int ibuf;
  long lbuf;

  if (len == sizeof (char))
    {
      read_memory (memaddr, &cbuf, len);
      return cbuf;
    }
  if (len == sizeof (short))
    {
      read_memory (memaddr, (char *)&sbuf, len);
      SWAP_TARGET_AND_HOST (&sbuf, sizeof (short));
      return sbuf;
    }
  if (len == sizeof (int))
    {
      read_memory (memaddr, (char *)&ibuf, len);
      SWAP_TARGET_AND_HOST (&ibuf, sizeof (int));
      return ibuf;
    }
  if (len == sizeof (lbuf))
    {
      read_memory (memaddr, (char *)&lbuf, len);
      SWAP_TARGET_AND_HOST (&lbuf, sizeof (lbuf));
      return lbuf;
    }
  error ("Cannot handle integers of %d bytes.", len);
  return -1;	/* for lint */
}
\f
/* Read or write the core file.

   Args are address within core file, address within gdb address-space,
   length, and a flag indicating whether to read or write.

   Result is a length:

	0:    We cannot handle this address and length.
	> 0:  We have handled N bytes starting at this address.
	      (If N == length, we did it all.)  We might be able
	      to handle more bytes beyond this length, but no
	      promises.
	< 0:  We cannot handle this address, but if somebody
	      else handles (-N) bytes, we can start from there.

   The actual work is done by xfer_memory in exec.c, which we share
   in common with exec_xfer_memory().  */

static int
core_xfer_memory (memaddr, myaddr, len, write)
     CORE_ADDR memaddr;
     char *myaddr;
     int len;
     int write;
{
  int res;
  res = xfer_memory (memaddr, myaddr, len, write,
		      core_bfd, core_sections, core_sections_end);
#ifdef SOLIB_XFER_MEMORY
  if (res == 0)
    res = SOLIB_XFER_MEMORY (memaddr, myaddr, len, write);
#endif
  return res;
}
\f
/* Get the registers out of a core file.  This is the machine-
   independent part.  Fetch_core_registers is the machine-dependent
   part, typically implemented in the xm-file for each architecture.  */

/* We just get all the registers, so we don't use regno.  */
/* ARGSUSED */
static void
get_core_registers (regno)
     int regno;
{
  sec_ptr reg_sec;
  unsigned size;
  char *the_regs;

  reg_sec = bfd_get_section_by_name (core_bfd, ".reg");
  size = bfd_section_size (core_bfd, reg_sec);
  the_regs = alloca (size);
  if (bfd_get_section_contents (core_bfd, reg_sec, the_regs,
				(unsigned)0, size))
    {
      fetch_core_registers (the_regs, size, 0);
    }
  else
    {
      fprintf (stderr, "Couldn't fetch registers from core file: %s\n",
	       bfd_errmsg (bfd_error));
    }

  /* Now do it again for the float registers, if they exist.  */
  reg_sec = bfd_get_section_by_name (core_bfd, ".reg2");
  if (reg_sec) {
    size = bfd_section_size (core_bfd, reg_sec);
    the_regs = alloca (size);
    if (bfd_get_section_contents (core_bfd, reg_sec, the_regs,
				  (unsigned)0, size))
      {
	fetch_core_registers (the_regs, size, 2);
      }
    else
      {
	fprintf (stderr, "Couldn't fetch register set 2 from core file: %s\n",
		 bfd_errmsg (bfd_error));
      }
  }
  registers_fetched();
}
\f
struct target_ops core_ops = {
	"core", "Local core dump file",
	"Use a core file as a target.  Specify the filename of the core file.",
	core_open, core_close,
	child_attach, core_detach, 0, 0, /* resume, wait */
	get_core_registers, 
	0, 0, 0, 0, /* store_regs, prepare_to_store, conv_to, conv_from */
	core_xfer_memory, core_files_info,
	0, 0, /* core_insert_breakpoint, core_remove_breakpoint, */
	0, 0, 0, 0, 0, /* terminal stuff */
	0, 0, 0, 0, 0, /* kill, load, add_syms, call fn, lookup sym */
	child_create_inferior, 0, /* mourn_inferior */
	core_stratum, 0, /* next */
	0, 1, 1, 1, 0,	/* all mem, mem, stack, regs, exec */
	OPS_MAGIC,		/* Always the last thing */
};

void
_initialize_core()
{

  add_com ("core-file", class_files, core_file_command,
	   "Use FILE as core dump for examining memory and registers.\n\
No arg means have no core file.  This command has been superseded by the\n\
`target core' and `detach' commands.");
  add_target (&core_ops);
}
Commit	Line	Data
dd3b648e RP	1	/* Work with core dump and executable files, for GDB.
	2	Copyright (C) 1986, 1987, 1989 Free Software Foundation, Inc.
	3
	4	This file is part of GDB.
	5
	6	GDB is free software; you can redistribute it and/or modify
	7	it under the terms of the GNU General Public License as published by
	8	the Free Software Foundation; either version 1, or (at your option)
	9	any later version.
	10
	11	GDB is distributed in the hope that it will be useful,
	12	but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	GNU General Public License for more details.
	15
	16	You should have received a copy of the GNU General Public License
	17	along with GDB; see the file COPYING. If not, write to
	18	the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
	19
	20	#include <stdio.h>
	21	#include <errno.h>
	22	#include <signal.h>
	23	#include "defs.h"
	24	#include "param.h"
	25	#include "frame.h" /* required by inferior.h */
	26	#include "inferior.h"
	27	#include "symtab.h"
	28	#include "command.h"
	29	#include "bfd.h"
	30	#include "target.h"
	31	#include "gdbcore.h"
	32
	33	extern int xfer_memory ();
	34	extern void child_attach (), child_create_inferior ();
	35
	36	extern int sys_nerr;
	37	extern char *sys_errlist[];
	38	extern char *sys_siglist[];
	39
	40	extern char registers[];
	41
	42	/* Hook for `exec_file_command' command to call. */
	43
	44	void (*exec_file_display_hook) () = NULL;
	45
	46	struct section_table core_sections, core_sections_end;
	47
	48	/* Binary file diddling handle for the core file. */
	49
	50	bfd *core_bfd = NULL;
	51
	52	/* Forward decl */
	53	extern struct target_ops core_ops;
	54
	55	\f
	56	/* Discard all vestiges of any previous core file
	57	and mark data and stack spaces as empty. */
	58
e1ce8aa5	59	/* ARGSUSED */
dd3b648e RP	60	void
	61	core_close (quitting)
	62	int quitting;
	63	{
	64	if (core_bfd) {
	65	free (bfd_get_filename (core_bfd));
	66	bfd_close (core_bfd);
	67	core_bfd = NULL;
d0237a54 JK	68	#ifdef CLEAR_SOLIB
	69	CLEAR_SOLIB ();
	70	#endif
dd3b648e RP	71	}
	72	}
	73
	74	/* This routine opens and sets up the core file bfd */
	75
	76	void
	77	core_open (filename, from_tty)
	78	char *filename;
	79	int from_tty;
	80	{
	81	char *p;
	82	int siggy;
	83	struct cleanup *old_chain;
	84	char *temp;
	85	bfd *temp_bfd;
	86	int ontop;
	87
f2fc6e7a	88	target_preopen (from_tty);
dd3b648e RP	89	if (!filename)
	90	{
	91	error (core_bfd?
	92	"No core file specified. (Use `detach' to stop debugging a core file.)"
	93	: "No core file specified.");
	94	}
	95
	96	filename = tilde_expand (filename);
	97	if (filename[0] != '/') {
	98	temp = concat (current_directory, "/", filename);
	99	free (filename);
	100	filename = temp;
	101	}
	102
	103	old_chain = make_cleanup (free, filename);
	104	temp_bfd = bfd_openr (filename, NULL);
	105	if (temp_bfd == NULL)
	106	{
	107	perror_with_name (filename);
	108	}
	109
	110	if (!bfd_check_format (temp_bfd, bfd_core))
	111	{
	112	bfd_close (temp_bfd);
	113	error ("\"%s\" does not appear to be a core dump", filename);
	114	}
	115
	116	/* Looks semi-reasonable. Toss the old core file and work on the new. */
	117
	118	discard_cleanups (old_chain); /* Don't free filename any more */
	119	unpush_target (&core_ops);
	120	core_bfd = temp_bfd;
	121	old_chain = make_cleanup (core_close, core_bfd);
	122
	123	validate_files ();
	124
	125	/* Find the data section */
	126	if (build_section_table (core_bfd, &core_sections, &core_sections_end))
	127	error ("Can't find sections in `%s': %s", bfd_get_filename(core_bfd),
	128	bfd_errmsg (bfd_error));
	129
	130	ontop = !push_target (&core_ops);
269c3011	131	make_cleanup (unpush_target, &core_ops);
dd3b648e RP	132
	133	p = bfd_core_file_failing_command (core_bfd);
	134	if (p)
	135	printf ("Core file invoked as `%s'.\n", p);
	136
	137	siggy = bfd_core_file_failing_signal (core_bfd);
	138	if (siggy > 0)
	139	printf ("Program terminated with signal %d, %s.\n", siggy,
	140	siggy < NSIG ? sys_siglist[siggy] : "(undocumented)");
	141
	142	if (ontop) {
	143	/* Fetch all registers from core file */
	144	target_fetch_registers (-1);
5594d534	145	/* Add symbols for any shared libraries that were in use */
d0237a54 JK	146	#ifdef SOLIB_ADD
	147	SOLIB_ADD (NULL, from_tty);
	148	#endif
5594d534 JG	149	/* Now, set up the frame cache, and print the top of stack */
	150	set_current_frame ( create_new_frame (read_register (FP_REGNUM),
	151	read_pc ()));
	152	select_frame (get_current_frame (), 0);
dd3b648e RP	153	print_sel_frame (0); /* Print the top frame and source line */
	154	} else {
	155	printf (
	156	"Warning: you won't be able to access this core file until you terminate\n\
	157	your %s; do ``info files''\n", current_target->to_longname);
	158	}
	159
	160	discard_cleanups (old_chain);
	161	}
	162
	163	void
	164	core_detach (args, from_tty)
	165	char *args;
	166	int from_tty;
	167	{
dd3b648e RP	168	if (args)
dd3b648e RP	169	error ("Too many arguments");
3f2e006b	170	unpush_target (&core_ops);
dd3b648e RP	171	if (from_tty)
	172	printf ("No core file now.\n");
	173	}
	174
	175	/* Backward compatability with old way of specifying core files. */
	176
	177	void
	178	core_file_command (filename, from_tty)
	179	char *filename;
	180	int from_tty;
	181	{
3f2e006b	182	dont_repeat (); /* Either way, seems bogus. */
dd3b648e RP	183	if (!filename)
	184	core_detach (filename, from_tty);
	185	else
	186	core_open (filename, from_tty);
	187	}
	188
	189	\f
	190	/* Call this to specify the hook for exec_file_command to call back.
	191	This is called from the x-window display code. */
	192
	193	void
	194	specify_exec_file_hook (hook)
	195	void (*hook) ();
	196	{
	197	exec_file_display_hook = hook;
	198	}
	199
	200	/* The exec file must be closed before running an inferior.
	201	If it is needed again after the inferior dies, it must
	202	be reopened. */
	203
	204	void
	205	close_exec_file ()
	206	{
	207	#ifdef FIXME
	208	if (exec_bfd)
	209	bfd_tempclose (exec_bfd);
	210	#endif
	211	}
	212
	213	void
	214	reopen_exec_file ()
	215	{
	216	#ifdef FIXME
	217	if (exec_bfd)
	218	bfd_reopen (exec_bfd);
	219	#endif
	220	}
	221	\f
	222	/* If we have both a core file and an exec file,
	223	print a warning if they don't go together.
	224	This should really check that the core file came
	225	from that exec file, but I don't know how to do it. */
	226
	227	void
	228	validate_files ()
	229	{
	230	if (exec_bfd && core_bfd)
	231	{
	232	if (core_file_matches_executable_p (core_bfd, exec_bfd))
	233	printf ("Warning: core file does not match specified executable file.\n");
	234	else if (bfd_get_mtime(exec_bfd) > bfd_get_mtime(core_bfd))
	235	printf ("Warning: exec file is newer than core file.\n");
	236	}
	237	}
	238
	239	/* Return the name of the executable file as a string.
	240	ERR nonzero means get error if there is none specified;
	241	otherwise return 0 in that case. */
	242
	243	char *
	244	get_exec_file (err)
	245	int err;
	246	{
247	if (exec_bfd) return bfd_get_filename(exec_bfd);
248	if (!err) return NULL;
249
250	error ("No executable file specified.\n\
251	Use the \"file\" or \"exec-file\" command.");
252	return NULL;
253	}
254
255	static void
256	core_files_info ()
257	{
258	struct section_table *p;
259
260	printf ("\tCore file `%s'.\n", bfd_get_filename(core_bfd));
261
262	for (p = core_sections; p < core_sections_end; p++)
263	printf("\tcore file from 0x%08x to 0x%08x is %s\n",
264	p->addr, p->endaddr,
265	bfd_section_name (core_bfd, p->sec_ptr));
266	}
267	\f
268	void
269	memory_error (status, memaddr)
270	int status;
271	CORE_ADDR memaddr;
272	{
273
274	if (status == EIO)
275	{
276	/* Actually, address between memaddr and memaddr + len
277	was out of bounds. */
278	error ("Cannot access memory: address 0x%x out of bounds.", memaddr);
279	}
280	else
281	{
282	if (status >= sys_nerr \|\| status < 0)
283	error ("Error accessing memory address 0x%x: unknown error (%d).",
284	memaddr, status);
285	else
286	error ("Error accessing memory address 0x%x: %s.",
287	memaddr, sys_errlist[status]);
288	}
289	}
290
291	/* Same as target_read_memory, but report an error if can't read. */
292	void
293	read_memory (memaddr, myaddr, len)
294	CORE_ADDR memaddr;
295	char *myaddr;
296	int len;
297	{
298	int status;
299	status = target_read_memory (memaddr, myaddr, len);
300	if (status != 0)
301	memory_error (status, memaddr);
302	}
303
304	/* Same as target_write_memory, but report an error if can't write. */
305	void
306	write_memory (memaddr, myaddr, len)
307	CORE_ADDR memaddr;
308	char *myaddr;
309	int len;
310	{
311	int status;
312
313	status = target_write_memory (memaddr, myaddr, len);
314	if (status != 0)
315	memory_error (status, memaddr);
316	}
317
318	/* Read an integer from debugged memory, given address and number of bytes. */
319
320	long
321	read_memory_integer (memaddr, len)
322	CORE_ADDR memaddr;
323	int len;
324	{
325	char cbuf;
326	short sbuf;
327	int ibuf;
328	long lbuf;
329
330	if (len == sizeof (char))
331	{
332	read_memory (memaddr, &cbuf, len);
333	return cbuf;
334	}
335	if (len == sizeof (short))
336	{
337	read_memory (memaddr, (char *)&sbuf, len);
338	SWAP_TARGET_AND_HOST (&sbuf, sizeof (short));
339	return sbuf;
340	}
341	if (len == sizeof (int))
342	{
343	read_memory (memaddr, (char *)&ibuf, len);
344	SWAP_TARGET_AND_HOST (&ibuf, sizeof (int));
345	return ibuf;
346	}
347	if (len == sizeof (lbuf))
348	{
349	read_memory (memaddr, (char *)&lbuf, len);
350	SWAP_TARGET_AND_HOST (&lbuf, sizeof (lbuf));
351	return lbuf;
352	}
353	error ("Cannot handle integers of %d bytes.", len);
354	return -1; /* for lint */
355	}
356	\f
357	/* Read or write the core file.
358
359	Args are address within core file, address within gdb address-space,
360	length, and a flag indicating whether to read or write.
361
362	Result is a length:
363
364	0: We cannot handle this address and length.
365	> 0: We have handled N bytes starting at this address.
366	(If N == length, we did it all.) We might be able
367	to handle more bytes beyond this length, but no
368	promises.
369	< 0: We cannot handle this address, but if somebody
370	else handles (-N) bytes, we can start from there.
371
372	The actual work is done by xfer_memory in exec.c, which we share
373	in common with exec_xfer_memory(). */
374
375	static int
376	core_xfer_memory (memaddr, myaddr, len, write)
377	CORE_ADDR memaddr;
378	char *myaddr;
379	int len;
380	int write;
381	{
d0237a54 JK	382	int res;
d0237a54 JK	383	res = xfer_memory (memaddr, myaddr, len, write,
dd3b648e	384	core_bfd, core_sections, core_sections_end);
d0237a54 JK	385	#ifdef SOLIB_XFER_MEMORY
	386	if (res == 0)
	387	res = SOLIB_XFER_MEMORY (memaddr, myaddr, len, write);
	388	#endif
	389	return res;
dd3b648e RP	390	}
	391	\f
	392	/* Get the registers out of a core file. This is the machine-
	393	independent part. Fetch_core_registers is the machine-dependent
	394	part, typically implemented in the xm-file for each architecture. */
	395
e1ce8aa5 JK	396	/* We just get all the registers, so we don't use regno. */
e1ce8aa5 JK	397	/* ARGSUSED */
5594d534	398	static void
dd3b648e RP	399	get_core_registers (regno)
	400	int regno;
	401	{
	402	sec_ptr reg_sec;
	403	unsigned size;
	404	char *the_regs;
	405
	406	reg_sec = bfd_get_section_by_name (core_bfd, ".reg");
	407	size = bfd_section_size (core_bfd, reg_sec);
	408	the_regs = alloca (size);
	409	if (bfd_get_section_contents (core_bfd, reg_sec, the_regs,
	410	(unsigned)0, size))
	411	{
	412	fetch_core_registers (the_regs, size, 0);
	413	}
	414	else
	415	{
	416	fprintf (stderr, "Couldn't fetch registers from core file: %s\n",
	417	bfd_errmsg (bfd_error));
	418	}
	419
	420	/* Now do it again for the float registers, if they exist. */
	421	reg_sec = bfd_get_section_by_name (core_bfd, ".reg2");
	422	if (reg_sec) {
	423	size = bfd_section_size (core_bfd, reg_sec);
	424	the_regs = alloca (size);
	425	if (bfd_get_section_contents (core_bfd, reg_sec, the_regs,
	426	(unsigned)0, size))
	427	{
	428	fetch_core_registers (the_regs, size, 2);
	429	}
	430	else
	431	{
	432	fprintf (stderr, "Couldn't fetch register set 2 from core file: %s\n",
	433	bfd_errmsg (bfd_error));
	434	}
	435	}
	436	registers_fetched();
dd3b648e RP	437	}
	438	\f
	439	struct target_ops core_ops = {
	440	"core", "Local core dump file",
f2fc6e7a	441	"Use a core file as a target. Specify the filename of the core file.",
dd3b648e RP	442	core_open, core_close,
	443	child_attach, core_detach, 0, 0, /* resume, wait */
	444	get_core_registers,
	445	0, 0, 0, 0, /* store_regs, prepare_to_store, conv_to, conv_from */
	446	core_xfer_memory, core_files_info,
	447	0, 0, /* core_insert_breakpoint, core_remove_breakpoint, */
	448	0, 0, 0, 0, 0, /* terminal stuff */
	449	0, 0, 0, 0, 0, /* kill, load, add_syms, call fn, lookup sym */
	450	child_create_inferior, 0, /* mourn_inferior */
	451	core_stratum, 0, /* next */
	452	0, 1, 1, 1, 0, /* all mem, mem, stack, regs, exec */
	453	OPS_MAGIC, /* Always the last thing */
	454	};
	455
	456	void
	457	_initialize_core()
	458	{
	459
	460	add_com ("core-file", class_files, core_file_command,
	461	"Use FILE as core dump for examining memory and registers.\n\
	462	No arg means have no core file. This command has been superseded by the\n\
	463	`target core' and `detach' commands.");
	464	add_target (&core_ops);
	465	}