[deliverable/binutils-gdb.git] / gdb / sun3-nat.c

/* Host-dependent code for Sun-3 for GDB, the GNU debugger.
   Copyright 1986, 1987, 1989, 1991, 1992, 1993, 1996, 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.  */

#include "defs.h"
#include "inferior.h"
#include "gdbcore.h"
#include "regcache.h"

#include <sys/ptrace.h>
#define KERNEL			/* To get floating point reg definitions */
#include <machine/reg.h>

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

void
fetch_inferior_registers (int regno)
{
  struct regs inferior_registers;
  struct fp_status inferior_fp_registers;

  registers_fetched ();

  ptrace (PTRACE_GETREGS, PIDGET (inferior_ptid),
	  (PTRACE_ARG3_TYPE) & inferior_registers);

  if (FP0_REGNUM >= 0)
    ptrace (PTRACE_GETFPREGS, PIDGET (inferior_ptid),
	    (PTRACE_ARG3_TYPE) & inferior_fp_registers);

  memcpy (registers, &inferior_registers, 16 * 4);
  if (FP0_REGNUM >= 0)
    memcpy (&registers[REGISTER_BYTE (FP0_REGNUM)], &inferior_fp_registers,
	    sizeof inferior_fp_registers.fps_regs);

  *(int *) &registers[REGISTER_BYTE (PS_REGNUM)] = inferior_registers.r_ps;
  *(int *) &registers[REGISTER_BYTE (PC_REGNUM)] = inferior_registers.r_pc;
  if (FP0_REGNUM >= 0)
    memcpy (&registers[REGISTER_BYTE (FPC_REGNUM)],
	    &inferior_fp_registers.fps_control,
	    sizeof inferior_fp_registers - 
	    sizeof inferior_fp_registers.fps_regs);
}

/* Store our register values back into the inferior.
   If REGNO is -1, do this for all registers.
   Otherwise, REGNO specifies which register (so we can save time).  */

void
store_inferior_registers (int regno)
{
  struct regs inferior_registers;
  struct fp_status inferior_fp_registers;

  memcpy (&inferior_registers, registers, 16 * 4);
  if (FP0_REGNUM >= 0)
    memcpy (&inferior_fp_registers, &registers[REGISTER_BYTE (FP0_REGNUM)],
	    sizeof inferior_fp_registers.fps_regs);

  inferior_registers.r_ps = *(int *) &registers[REGISTER_BYTE (PS_REGNUM)];
  inferior_registers.r_pc = *(int *) &registers[REGISTER_BYTE (PC_REGNUM)];

  if (FP0_REGNUM >= 0)
    memcpy (&inferior_fp_registers.fps_control,
	    &registers[REGISTER_BYTE (FPC_REGNUM)],
	    sizeof inferior_fp_registers - 
	    sizeof inferior_fp_registers.fps_regs);

  ptrace (PTRACE_SETREGS, PIDGET (inferior_ptid),
	  (PTRACE_ARG3_TYPE) & inferior_registers);
  if (FP0_REGNUM >= 0)
    ptrace (PTRACE_SETFPREGS, PIDGET (inferior_ptid),
	    (PTRACE_ARG3_TYPE) & inferior_fp_registers);
}


/* All of this stuff is only relevant if both host and target are sun3.  */

/* Provide registers to GDB from a core file.

   CORE_REG_SECT points to an array of bytes, which were obtained from
   a core file which BFD thinks might contain register contents. 
   CORE_REG_SIZE is its size.

   WHICH says which register set corelow suspects this is:
     0 --- the general-purpose register set
     2 --- the floating-point register set

   REG_ADDR isn't used.  */

static void
fetch_core_registers (char *core_reg_sect, unsigned core_reg_size,
		      int which, CORE_ADDR reg_addr)
{
  struct regs *regs = (struct regs *) core_reg_sect;

  if (which == 0)
    {
      if (core_reg_size < sizeof (struct regs))
	  error ("Can't find registers in core file");

      memcpy (registers, (char *) regs, 16 * 4);
      supply_register (PS_REGNUM, (char *) &regs->r_ps);
      supply_register (PC_REGNUM, (char *) &regs->r_pc);

    }
  else if (which == 2)
    {

#define fpustruct  ((struct fpu *) core_reg_sect)

      if (core_reg_size >= sizeof (struct fpu))
	{
	  if (FP0_REGNUM >= 0)
	    {
	      memcpy (&registers[REGISTER_BYTE (FP0_REGNUM)],
		      fpustruct->f_fpstatus.fps_regs,
		      sizeof fpustruct->f_fpstatus.fps_regs);
	      memcpy (&registers[REGISTER_BYTE (FPC_REGNUM)],
		      &fpustruct->f_fpstatus.fps_control,
		      sizeof fpustruct->f_fpstatus -
		      sizeof fpustruct->f_fpstatus.fps_regs);
	    }
	}
      else
	fprintf_unfiltered (gdb_stderr, 
			    "Couldn't read float regs from core file\n");
    }
}
\f

/* Register that we are able to handle sun3 core file formats.
   FIXME: is this really bfd_target_unknown_flavour? */

static struct core_fns sun3_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_sun3 (void)
{
  add_core_fns (&sun3_core_fns);
}
Commit	Line	Data
	1	/* Host-dependent code for Sun-3 for GDB, the GNU debugger.
	2	Copyright 1986, 1987, 1989, 1991, 1992, 1993, 1996, 1999, 2000, 2001
	3	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	#include "defs.h"
	23	#include "inferior.h"
	24	#include "gdbcore.h"
	25	#include "regcache.h"
	26
	27	#include <sys/ptrace.h>
	28	#define KERNEL /* To get floating point reg definitions */
	29	#include <machine/reg.h>
	30
	31	static void fetch_core_registers (char *, unsigned, int, CORE_ADDR);
	32
	33	void
	34	fetch_inferior_registers (int regno)
	35	{
	36	struct regs inferior_registers;
	37	struct fp_status inferior_fp_registers;
	38
	39	registers_fetched ();
	40
	41	ptrace (PTRACE_GETREGS, PIDGET (inferior_ptid),
	42	(PTRACE_ARG3_TYPE) & inferior_registers);
	43
	44	if (FP0_REGNUM >= 0)
	45	ptrace (PTRACE_GETFPREGS, PIDGET (inferior_ptid),
	46	(PTRACE_ARG3_TYPE) & inferior_fp_registers);
	47
	48	memcpy (registers, &inferior_registers, 16 * 4);
	49	if (FP0_REGNUM >= 0)
	50	memcpy (&registers[REGISTER_BYTE (FP0_REGNUM)], &inferior_fp_registers,
	51	sizeof inferior_fp_registers.fps_regs);
	52
	53	(int ) &registers[REGISTER_BYTE (PS_REGNUM)] = inferior_registers.r_ps;
	54	(int ) &registers[REGISTER_BYTE (PC_REGNUM)] = inferior_registers.r_pc;
	55	if (FP0_REGNUM >= 0)
	56	memcpy (&registers[REGISTER_BYTE (FPC_REGNUM)],
	57	&inferior_fp_registers.fps_control,
	58	sizeof inferior_fp_registers -
	59	sizeof inferior_fp_registers.fps_regs);
	60	}
	61
	62	/* Store our register values back into the inferior.
	63	If REGNO is -1, do this for all registers.
	64	Otherwise, REGNO specifies which register (so we can save time). */
	65
	66	void
	67	store_inferior_registers (int regno)
	68	{
	69	struct regs inferior_registers;
	70	struct fp_status inferior_fp_registers;
	71
	72	memcpy (&inferior_registers, registers, 16 * 4);
	73	if (FP0_REGNUM >= 0)
	74	memcpy (&inferior_fp_registers, &registers[REGISTER_BYTE (FP0_REGNUM)],
	75	sizeof inferior_fp_registers.fps_regs);
	76
	77	inferior_registers.r_ps = (int ) &registers[REGISTER_BYTE (PS_REGNUM)];
	78	inferior_registers.r_pc = (int ) &registers[REGISTER_BYTE (PC_REGNUM)];
	79
	80	if (FP0_REGNUM >= 0)
	81	memcpy (&inferior_fp_registers.fps_control,
	82	&registers[REGISTER_BYTE (FPC_REGNUM)],
	83	sizeof inferior_fp_registers -
	84	sizeof inferior_fp_registers.fps_regs);
	85
	86	ptrace (PTRACE_SETREGS, PIDGET (inferior_ptid),
	87	(PTRACE_ARG3_TYPE) & inferior_registers);
	88	if (FP0_REGNUM >= 0)
	89	ptrace (PTRACE_SETFPREGS, PIDGET (inferior_ptid),
	90	(PTRACE_ARG3_TYPE) & inferior_fp_registers);
	91	}
	92
	93
	94	/* All of this stuff is only relevant if both host and target are sun3. */
	95
	96	/* Provide registers to GDB from a core file.
	97
	98	CORE_REG_SECT points to an array of bytes, which were obtained from
	99	a core file which BFD thinks might contain register contents.
	100	CORE_REG_SIZE is its size.
	101
	102	WHICH says which register set corelow suspects this is:
	103	0 --- the general-purpose register set
	104	2 --- the floating-point register set
	105
	106	REG_ADDR isn't used. */
	107
	108	static void
	109	fetch_core_registers (char *core_reg_sect, unsigned core_reg_size,
	110	int which, CORE_ADDR reg_addr)
	111	{
	112	struct regs regs = (struct regs ) core_reg_sect;
	113
	114	if (which == 0)
	115	{
	116	if (core_reg_size < sizeof (struct regs))
	117	error ("Can't find registers in core file");
	118
	119	memcpy (registers, (char ) regs, 16 4);
	120	supply_register (PS_REGNUM, (char *) &regs->r_ps);
	121	supply_register (PC_REGNUM, (char *) &regs->r_pc);
	122
	123	}
	124	else if (which == 2)
	125	{
	126
	127	#define fpustruct ((struct fpu *) core_reg_sect)
	128
	129	if (core_reg_size >= sizeof (struct fpu))
	130	{
	131	if (FP0_REGNUM >= 0)
	132	{
	133	memcpy (&registers[REGISTER_BYTE (FP0_REGNUM)],
	134	fpustruct->f_fpstatus.fps_regs,
	135	sizeof fpustruct->f_fpstatus.fps_regs);
	136	memcpy (&registers[REGISTER_BYTE (FPC_REGNUM)],
	137	&fpustruct->f_fpstatus.fps_control,
	138	sizeof fpustruct->f_fpstatus -
	139	sizeof fpustruct->f_fpstatus.fps_regs);
	140	}
	141	}
	142	else
	143	fprintf_unfiltered (gdb_stderr,
	144	"Couldn't read float regs from core file\n");
	145	}
	146	}
	147	\f
	148
	149	/* Register that we are able to handle sun3 core file formats.
	150	FIXME: is this really bfd_target_unknown_flavour? */
	151
	152	static struct core_fns sun3_core_fns =
	153	{
	154	bfd_target_unknown_flavour, /* core_flavour */
	155	default_check_format, /* check_format */
	156	default_core_sniffer, /* core_sniffer */
	157	fetch_core_registers, /* core_read_registers */
	158	NULL /* next */
	159	};
	160
	161	void
	162	_initialize_core_sun3 (void)
	163	{
	164	add_core_fns (&sun3_core_fns);
	165	}