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

/* Extract registers from a "standard" core file, for GDB.
   Copyright 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998,
   1999, 2000, 2001 Free Software Foundation, Inc.

   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., 59 Temple Place - Suite 330,
   Boston, MA 02111-1307, USA.  */

/* Typically used on systems that have a.out format executables.
   corefile.c is supposed to contain the more machine-independent
   aspects of reading registers from core files, while this file is
   more machine specific.  */

#include "defs.h"

#ifdef HAVE_PTRACE_H
#include <ptrace.h>
#else
#ifdef HAVE_SYS_PTRACE_H
#include <sys/ptrace.h>
#endif
#endif

#include <sys/types.h>
#include <sys/param.h>
#include "gdbcore.h"
#include "value.h"
#include "regcache.h"

/* These are needed on various systems to expand REGISTER_U_ADDR.  */
#include "gdb_dirent.h"
#include <sys/file.h>
#include "gdb_stat.h"
#include <sys/user.h>

#ifndef CORE_REGISTER_ADDR
#define CORE_REGISTER_ADDR(regno, regptr) register_addr(regno, regptr)
#endif /* CORE_REGISTER_ADDR */

#ifdef NEED_SYS_CORE_H
#include <sys/core.h>
#endif

static void fetch_core_registers (char *, unsigned, int, CORE_ADDR);

void _initialize_core_aout (void);

/* Extract the register values out of the core file and store
   them where `read_register' will find them.

   CORE_REG_SECT points to the register values themselves, read into memory.
   CORE_REG_SIZE is the size of that area.
   WHICH says which set of registers we are handling (0 = int, 2 = float
   on machines where they are discontiguous).
   REG_ADDR is the offset from u.u_ar0 to the register values relative to
   core_reg_sect.  This is used with old-fashioned core files to
   locate the registers in a large upage-plus-stack ".reg" section.
   Original upage address X is at location core_reg_sect+x+reg_addr.
 */

static void
fetch_core_registers (char *core_reg_sect, unsigned core_reg_size, int which,
		      CORE_ADDR reg_addr)
{
  int regno;
  CORE_ADDR addr;
  int bad_reg = -1;
  CORE_ADDR reg_ptr = -reg_addr;	/* Original u.u_ar0 is -reg_addr. */
  int numregs = NUM_REGS;

  /* If u.u_ar0 was an absolute address in the core file, relativize it now,
     so we can use it as an offset into core_reg_sect.  When we're done,
     "register 0" will be at core_reg_sect+reg_ptr, and we can use
     CORE_REGISTER_ADDR to offset to the other registers.  If this is a modern
     core file without a upage, reg_ptr will be zero and this is all a big
     NOP.  */
  if (reg_ptr > core_reg_size)
    reg_ptr -= KERNEL_U_ADDR;

  for (regno = 0; regno < numregs; regno++)
    {
      addr = CORE_REGISTER_ADDR (regno, reg_ptr);
      if (addr >= core_reg_size
	  && bad_reg < 0)
	bad_reg = regno;
      else
	regcache_raw_supply (current_regcache, regno, core_reg_sect + addr);
    }

  if (bad_reg >= 0)
    error (_("Register %s not found in core file."), REGISTER_NAME (bad_reg));
}


#ifdef REGISTER_U_ADDR

/* Return the address in the core dump or inferior of register REGNO.
   BLOCKEND is the address of the end of the user structure.  */

CORE_ADDR
register_addr (int regno, CORE_ADDR blockend)
{
  CORE_ADDR addr;

  if (regno < 0 || regno >= NUM_REGS)
    error (_("Invalid register number %d."), regno);

  REGISTER_U_ADDR (addr, blockend, regno);

  return addr;
}

#endif /* REGISTER_U_ADDR */
\f

/* Register that we are able to handle aout (trad-core) file formats.  */

static struct core_fns aout_core_fns =
{
  bfd_target_unknown_flavour,		/* core_flavour */
  default_check_format,			/* check_format */
  default_core_sniffer,			/* core_sniffer */
  fetch_core_registers,			/* core_read_registers */
  NULL					/* next */
};

void
_initialize_core_aout (void)
{
  deprecated_add_core_fns (&aout_core_fns);
}
Commit	Line	Data
	1	/* Extract registers from a "standard" core file, for GDB.
	2	Copyright 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998,
	3	1999, 2000, 2001 Free Software Foundation, Inc.
	4
	5	This file is part of GDB.
	6
	7	This program is free software; you can redistribute it and/or modify
	8	it under the terms of the GNU General Public License as published by
	9	the Free Software Foundation; either version 2 of the License, or
	10	(at your option) any later version.
	11
	12	This program is distributed in the hope that it will be useful,
	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	GNU General Public License for more details.
	16
	17	You should have received a copy of the GNU General Public License
	18	along with this program; if not, write to the Free Software
	19	Foundation, Inc., 59 Temple Place - Suite 330,
	20	Boston, MA 02111-1307, USA. */
	21
	22	/* Typically used on systems that have a.out format executables.
	23	corefile.c is supposed to contain the more machine-independent
	24	aspects of reading registers from core files, while this file is
	25	more machine specific. */
	26
	27	#include "defs.h"
	28
	29	#ifdef HAVE_PTRACE_H
	30	#include <ptrace.h>
	31	#else
	32	#ifdef HAVE_SYS_PTRACE_H
	33	#include <sys/ptrace.h>
	34	#endif
	35	#endif
	36
	37	#include <sys/types.h>
	38	#include <sys/param.h>
	39	#include "gdbcore.h"
	40	#include "value.h"
	41	#include "regcache.h"
	42
	43	/* These are needed on various systems to expand REGISTER_U_ADDR. */
	44	#include "gdb_dirent.h"
	45	#include <sys/file.h>
	46	#include "gdb_stat.h"
	47	#include <sys/user.h>
	48
	49	#ifndef CORE_REGISTER_ADDR
	50	#define CORE_REGISTER_ADDR(regno, regptr) register_addr(regno, regptr)
	51	#endif /* CORE_REGISTER_ADDR */
	52
	53	#ifdef NEED_SYS_CORE_H
	54	#include <sys/core.h>
	55	#endif
	56
	57	static void fetch_core_registers (char *, unsigned, int, CORE_ADDR);
	58
	59	void _initialize_core_aout (void);
	60
	61	/* Extract the register values out of the core file and store
	62	them where `read_register' will find them.
	63
	64	CORE_REG_SECT points to the register values themselves, read into memory.
	65	CORE_REG_SIZE is the size of that area.
	66	WHICH says which set of registers we are handling (0 = int, 2 = float
	67	on machines where they are discontiguous).
	68	REG_ADDR is the offset from u.u_ar0 to the register values relative to
	69	core_reg_sect. This is used with old-fashioned core files to
	70	locate the registers in a large upage-plus-stack ".reg" section.
	71	Original upage address X is at location core_reg_sect+x+reg_addr.
	72	*/
	73
	74	static void
	75	fetch_core_registers (char *core_reg_sect, unsigned core_reg_size, int which,
	76	CORE_ADDR reg_addr)
	77	{
	78	int regno;
	79	CORE_ADDR addr;
	80	int bad_reg = -1;
	81	CORE_ADDR reg_ptr = -reg_addr; /* Original u.u_ar0 is -reg_addr. */
	82	int numregs = NUM_REGS;
	83
	84	/* If u.u_ar0 was an absolute address in the core file, relativize it now,
	85	so we can use it as an offset into core_reg_sect. When we're done,
	86	"register 0" will be at core_reg_sect+reg_ptr, and we can use
	87	CORE_REGISTER_ADDR to offset to the other registers. If this is a modern
	88	core file without a upage, reg_ptr will be zero and this is all a big
	89	NOP. */
	90	if (reg_ptr > core_reg_size)
	91	reg_ptr -= KERNEL_U_ADDR;
	92
	93	for (regno = 0; regno < numregs; regno++)
	94	{
	95	addr = CORE_REGISTER_ADDR (regno, reg_ptr);
	96	if (addr >= core_reg_size
	97	&& bad_reg < 0)
	98	bad_reg = regno;
	99	else
	100	regcache_raw_supply (current_regcache, regno, core_reg_sect + addr);
	101	}
	102
	103	if (bad_reg >= 0)
	104	error (_("Register %s not found in core file."), REGISTER_NAME (bad_reg));
	105	}
	106
	107
	108	#ifdef REGISTER_U_ADDR
	109
	110	/* Return the address in the core dump or inferior of register REGNO.
	111	BLOCKEND is the address of the end of the user structure. */
	112
	113	CORE_ADDR
	114	register_addr (int regno, CORE_ADDR blockend)
	115	{
	116	CORE_ADDR addr;
	117
	118	if (regno < 0 \|\| regno >= NUM_REGS)
	119	error (_("Invalid register number %d."), regno);
	120
	121	REGISTER_U_ADDR (addr, blockend, regno);
	122
	123	return addr;
	124	}
	125
	126	#endif /* REGISTER_U_ADDR */
	127	\f
	128
	129	/* Register that we are able to handle aout (trad-core) file formats. */
	130
	131	static struct core_fns aout_core_fns =
	132	{
	133	bfd_target_unknown_flavour, /* core_flavour */
	134	default_check_format, /* check_format */
	135	default_core_sniffer, /* core_sniffer */
	136	fetch_core_registers, /* core_read_registers */
	137	NULL /* next */
	138	};
	139
	140	void
	141	_initialize_core_aout (void)
	142	{
	143	deprecated_add_core_fns (&aout_core_fns);
	144	}