[deliverable/binutils-gdb.git] / gdb / remote-vxsparc.c

/* sparc-dependent portions of the RPC protocol
   used with a VxWorks target 

   Contributed by Wind River Systems.

   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 <stdio.h>
#include "defs.h"

#include "vx-share/regPacket.h"
#include "frame.h"
#include "inferior.h"
#include "target.h"
#include "gdbcore.h"
#include "command.h"
#include "symtab.h"
#include "symfile.h"
#include "regcache.h"

#include "gdb_string.h"
#include <errno.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/time.h>
#include <sys/socket.h>

#ifdef _AIX			/* IBM claims "void *malloc()" not char * */
#define malloc bogon_malloc
#endif

#include <rpc/rpc.h>
#include <sys/time.h>		/* UTek's <rpc/rpc.h> doesn't #incl this */
#include <netdb.h>
#include "vx-share/ptrace.h"
#include "vx-share/xdr_ptrace.h"
#include "vx-share/xdr_ld.h"
#include "vx-share/xdr_rdb.h"
#include "vx-share/dbgRpcLib.h"

/* get rid of value.h if possible */
#include <value.h>
#include <symtab.h>

/* Flag set if target has fpu */

extern int target_has_fp;

/* sparc floating point format descriptor, from "sparc-tdep.c."  */

extern struct ext_format ext_format_sparc;

/* Generic register read/write routines in remote-vx.c.  */

extern void net_read_registers ();
extern void net_write_registers ();

/* Read a register or registers from the VxWorks target.
   REGNO is the register to read, or -1 for all; currently,
   it is ignored.  FIXME look at regno to improve efficiency.  */

void
vx_read_register (int regno)
{
  char sparc_greg_packet[SPARC_GREG_PLEN];
  char sparc_fpreg_packet[SPARC_FPREG_PLEN];
  CORE_ADDR sp;

  /* Get general-purpose registers.  When copying values into
     registers [], don't assume that a location in registers []
     is properly aligned for the target data type.  */

  net_read_registers (sparc_greg_packet, SPARC_GREG_PLEN, PTRACE_GETREGS);

  /* Now copy the register values into registers[].
     Note that this code depends on the ordering of the REGNUMs
     as defined in "tm-sparc.h".  */

  bcopy (&sparc_greg_packet[SPARC_R_G0],
	 &deprecated_registers[REGISTER_BYTE (G0_REGNUM)],
	 32 * SPARC_GREG_SIZE);
  bcopy (&sparc_greg_packet[SPARC_R_Y],
	 &deprecated_registers[REGISTER_BYTE (Y_REGNUM)], 6 * SPARC_GREG_SIZE);

  /* Now write the local and in registers to the register window spill
     area in the frame.  VxWorks does not do this for the active frame
     automatically; it greatly simplifies debugging.  */

  sp = extract_unsigned_integer (&deprecated_registers[REGISTER_BYTE (SP_REGNUM)],
				 REGISTER_RAW_SIZE (SP_REGNUM));
  write_memory (sp, &deprecated_registers[REGISTER_BYTE (L0_REGNUM)],
		16 * REGISTER_RAW_SIZE (L0_REGNUM));

  /* If the target has floating point registers, fetch them.
     Otherwise, zero the floating point register values in
     registers[] for good measure, even though we might not
     need to.  */

  if (target_has_fp)
    {
      net_read_registers (sparc_fpreg_packet, SPARC_FPREG_PLEN,
			  PTRACE_GETFPREGS);
      bcopy (&sparc_fpreg_packet[SPARC_R_FP0],
	     &deprecated_registers[REGISTER_BYTE (FP0_REGNUM)],
	     32 * SPARC_FPREG_SIZE);
      bcopy (&sparc_fpreg_packet[SPARC_R_FSR],
	     &deprecated_registers[REGISTER_BYTE (FPS_REGNUM)],
	     1 * SPARC_FPREG_SIZE);
    }
  else
    {
      bzero (&deprecated_registers[REGISTER_BYTE (FP0_REGNUM)],
	     32 * SPARC_FPREG_SIZE);
      bzero (&deprecated_registers[REGISTER_BYTE (FPS_REGNUM)],
	     1 * SPARC_FPREG_SIZE);
    }

  /* Mark the register cache valid.  */

  deprecated_registers_fetched ();
}

/* Store a register or registers into the VxWorks target.
   REGNO is the register to store, or -1 for all; currently,
   it is ignored.  FIXME look at regno to improve efficiency.  */

void
vx_write_register (int regno)
{
  char sparc_greg_packet[SPARC_GREG_PLEN];
  char sparc_fpreg_packet[SPARC_FPREG_PLEN];
  int in_gp_regs;
  int in_fp_regs;
  CORE_ADDR sp;

  /* Store general purpose registers.  When copying values from
     registers [], don't assume that a location in registers []
     is properly aligned for the target data type.  */

  in_gp_regs = 1;
  in_fp_regs = 1;
  if (regno >= 0)
    {
      if ((G0_REGNUM <= regno && regno <= I7_REGNUM)
	  || (Y_REGNUM <= regno && regno <= NPC_REGNUM))
	in_fp_regs = 0;
      else
	in_gp_regs = 0;
    }
  if (in_gp_regs)
    {
      bcopy (&deprecated_registers[REGISTER_BYTE (G0_REGNUM)],
	     &sparc_greg_packet[SPARC_R_G0], 32 * SPARC_GREG_SIZE);
      bcopy (&deprecated_registers[REGISTER_BYTE (Y_REGNUM)],
	     &sparc_greg_packet[SPARC_R_Y], 6 * SPARC_GREG_SIZE);

      net_write_registers (sparc_greg_packet, SPARC_GREG_PLEN, PTRACE_SETREGS);

      /* If this is a local or in register, or we're storing all
         registers, update the register window spill area.  */

      if (regno < 0 || (L0_REGNUM <= regno && regno <= I7_REGNUM))
	{
	  sp = extract_unsigned_integer (&deprecated_registers[REGISTER_BYTE (SP_REGNUM)],
					 REGISTER_RAW_SIZE (SP_REGNUM));
	  write_memory (sp, &deprecated_registers[REGISTER_BYTE (L0_REGNUM)],
			16 * REGISTER_RAW_SIZE (L0_REGNUM));
	}
    }

  /* Store floating point registers if the target has them.  */

  if (in_fp_regs && target_has_fp)
    {
      bcopy (&deprecated_registers[REGISTER_BYTE (FP0_REGNUM)],
	     &sparc_fpreg_packet[SPARC_R_FP0], 32 * SPARC_FPREG_SIZE);
      bcopy (&deprecated_registers[REGISTER_BYTE (FPS_REGNUM)],
	     &sparc_fpreg_packet[SPARC_R_FSR], 1 * SPARC_FPREG_SIZE);

      net_write_registers (sparc_fpreg_packet, SPARC_FPREG_PLEN,
			   PTRACE_SETFPREGS);
    }
}
Commit	Line	Data
c906108c SS	1	/* sparc-dependent portions of the RPC protocol
	2	used with a VxWorks target
	3
c5aa993b	4	Contributed by Wind River Systems.
c906108c	5
c5aa993b	6	This file is part of GDB.
c906108c	7
c5aa993b JM	8	This program is free software; you can redistribute it and/or modify
	9	it under the terms of the GNU General Public License as published by
	10	the Free Software Foundation; either version 2 of the License, or
	11	(at your option) any later version.
c906108c	12
c5aa993b JM	13	This program is distributed in the hope that it will be useful,
	14	but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	GNU General Public License for more details.
c906108c	17
c5aa993b JM	18	You should have received a copy of the GNU General Public License
	19	along with this program; if not, write to the Free Software
	20	Foundation, Inc., 59 Temple Place - Suite 330,
	21	Boston, MA 02111-1307, USA. */
c906108c SS	22
	23	#include <stdio.h>
	24	#include "defs.h"
	25
c5aa993b	26	#include "vx-share/regPacket.h"
c906108c SS	27	#include "frame.h"
c906108c SS	28	#include "inferior.h"
c906108c SS	29	#include "target.h"
	30	#include "gdbcore.h"
	31	#include "command.h"
	32	#include "symtab.h"
72367fb4	33	#include "symfile.h"
4e052eda	34	#include "regcache.h"
c906108c SS	35
	36	#include "gdb_string.h"
	37	#include <errno.h>
c906108c SS	38	#include <fcntl.h>
	39	#include <sys/types.h>
	40	#include <sys/time.h>
	41	#include <sys/socket.h>
	42
c5aa993b	43	#ifdef _AIX /* IBM claims "void malloc()" not char */
c906108c SS	44	#define malloc bogon_malloc
	45	#endif
	46
	47	#include <rpc/rpc.h>
	48	#include <sys/time.h> /* UTek's <rpc/rpc.h> doesn't #incl this */
	49	#include <netdb.h>
	50	#include "vx-share/ptrace.h"
	51	#include "vx-share/xdr_ptrace.h"
	52	#include "vx-share/xdr_ld.h"
	53	#include "vx-share/xdr_rdb.h"
	54	#include "vx-share/dbgRpcLib.h"
	55
	56	/* get rid of value.h if possible */
	57	#include <value.h>
	58	#include <symtab.h>
	59
	60	/* Flag set if target has fpu */
	61
	62	extern int target_has_fp;
	63
	64	/* sparc floating point format descriptor, from "sparc-tdep.c." */
	65
	66	extern struct ext_format ext_format_sparc;
	67
	68	/* Generic register read/write routines in remote-vx.c. */
	69
	70	extern void net_read_registers ();
	71	extern void net_write_registers ();
	72
	73	/* Read a register or registers from the VxWorks target.
	74	REGNO is the register to read, or -1 for all; currently,
	75	it is ignored. FIXME look at regno to improve efficiency. */
	76
	77	void
fba45db2	78	vx_read_register (int regno)
c906108c SS	79	{
	80	char sparc_greg_packet[SPARC_GREG_PLEN];
	81	char sparc_fpreg_packet[SPARC_FPREG_PLEN];
	82	CORE_ADDR sp;
	83
	84	/* Get general-purpose registers. When copying values into
	85	registers [], don't assume that a location in registers []
	86	is properly aligned for the target data type. */
	87
	88	net_read_registers (sparc_greg_packet, SPARC_GREG_PLEN, PTRACE_GETREGS);
	89
	90	/* Now copy the register values into registers[].
	91	Note that this code depends on the ordering of the REGNUMs
	92	as defined in "tm-sparc.h". */
	93
	94	bcopy (&sparc_greg_packet[SPARC_R_G0],
524d7c18 AC	95	&deprecated_registers[REGISTER_BYTE (G0_REGNUM)],
524d7c18 AC	96	32 * SPARC_GREG_SIZE);
c906108c	97	bcopy (&sparc_greg_packet[SPARC_R_Y],
524d7c18	98	&deprecated_registers[REGISTER_BYTE (Y_REGNUM)], 6 * SPARC_GREG_SIZE);
c906108c	99
43bd9a9e AC	100	/* Now write the local and in registers to the register window spill
	101	area in the frame. VxWorks does not do this for the active frame
	102	automatically; it greatly simplifies debugging. */
c906108c	103
7c0b4a20 AC	104	sp = extract_unsigned_integer (&deprecated_registers[REGISTER_BYTE (SP_REGNUM)],
7c0b4a20 AC	105	REGISTER_RAW_SIZE (SP_REGNUM));
524d7c18	106	write_memory (sp, &deprecated_registers[REGISTER_BYTE (L0_REGNUM)],
c906108c SS	107	16 * REGISTER_RAW_SIZE (L0_REGNUM));
	108
	109	/* If the target has floating point registers, fetch them.
	110	Otherwise, zero the floating point register values in
	111	registers[] for good measure, even though we might not
	112	need to. */
	113
	114	if (target_has_fp)
	115	{
	116	net_read_registers (sparc_fpreg_packet, SPARC_FPREG_PLEN,
c5aa993b JM	117	PTRACE_GETFPREGS);
c5aa993b JM	118	bcopy (&sparc_fpreg_packet[SPARC_R_FP0],
524d7c18 AC	119	&deprecated_registers[REGISTER_BYTE (FP0_REGNUM)],
524d7c18 AC	120	32 * SPARC_FPREG_SIZE);
c906108c	121	bcopy (&sparc_fpreg_packet[SPARC_R_FSR],
524d7c18 AC	122	&deprecated_registers[REGISTER_BYTE (FPS_REGNUM)],
524d7c18 AC	123	1 * SPARC_FPREG_SIZE);
c906108c SS	124	}
c906108c SS	125	else
c5aa993b	126	{
524d7c18 AC	127	bzero (&deprecated_registers[REGISTER_BYTE (FP0_REGNUM)],
	128	32 * SPARC_FPREG_SIZE);
	129	bzero (&deprecated_registers[REGISTER_BYTE (FPS_REGNUM)],
	130	1 * SPARC_FPREG_SIZE);
c906108c SS	131	}
	132
	133	/* Mark the register cache valid. */
	134
2b9e5f3f	135	deprecated_registers_fetched ();
c906108c SS	136	}
	137
	138	/* Store a register or registers into the VxWorks target.
	139	REGNO is the register to store, or -1 for all; currently,
	140	it is ignored. FIXME look at regno to improve efficiency. */
	141
	142	void
fba45db2	143	vx_write_register (int regno)
c906108c SS	144	{
	145	char sparc_greg_packet[SPARC_GREG_PLEN];
	146	char sparc_fpreg_packet[SPARC_FPREG_PLEN];
	147	int in_gp_regs;
	148	int in_fp_regs;
	149	CORE_ADDR sp;
	150
	151	/* Store general purpose registers. When copying values from
	152	registers [], don't assume that a location in registers []
	153	is properly aligned for the target data type. */
	154
	155	in_gp_regs = 1;
	156	in_fp_regs = 1;
	157	if (regno >= 0)
	158	{
	159	if ((G0_REGNUM <= regno && regno <= I7_REGNUM)
c5aa993b	160	\|\| (Y_REGNUM <= regno && regno <= NPC_REGNUM))
c906108c SS	161	in_fp_regs = 0;
	162	else
	163	in_gp_regs = 0;
	164	}
	165	if (in_gp_regs)
	166	{
524d7c18	167	bcopy (&deprecated_registers[REGISTER_BYTE (G0_REGNUM)],
c906108c	168	&sparc_greg_packet[SPARC_R_G0], 32 * SPARC_GREG_SIZE);
524d7c18	169	bcopy (&deprecated_registers[REGISTER_BYTE (Y_REGNUM)],
c906108c SS	170	&sparc_greg_packet[SPARC_R_Y], 6 * SPARC_GREG_SIZE);
	171
	172	net_write_registers (sparc_greg_packet, SPARC_GREG_PLEN, PTRACE_SETREGS);
	173
	174	/* If this is a local or in register, or we're storing all
	175	registers, update the register window spill area. */
	176
	177	if (regno < 0 \|\| (L0_REGNUM <= regno && regno <= I7_REGNUM))
c5aa993b	178	{
7c0b4a20 AC	179	sp = extract_unsigned_integer (&deprecated_registers[REGISTER_BYTE (SP_REGNUM)],
7c0b4a20 AC	180	REGISTER_RAW_SIZE (SP_REGNUM));
524d7c18	181	write_memory (sp, &deprecated_registers[REGISTER_BYTE (L0_REGNUM)],
c906108c SS	182	16 * REGISTER_RAW_SIZE (L0_REGNUM));
	183	}
	184	}
	185
	186	/* Store floating point registers if the target has them. */
	187
	188	if (in_fp_regs && target_has_fp)
	189	{
524d7c18	190	bcopy (&deprecated_registers[REGISTER_BYTE (FP0_REGNUM)],
c906108c	191	&sparc_fpreg_packet[SPARC_R_FP0], 32 * SPARC_FPREG_SIZE);
524d7c18	192	bcopy (&deprecated_registers[REGISTER_BYTE (FPS_REGNUM)],
c906108c SS	193	&sparc_fpreg_packet[SPARC_R_FSR], 1 * SPARC_FPREG_SIZE);
	194
	195	net_write_registers (sparc_fpreg_packet, SPARC_FPREG_PLEN,
c5aa993b	196	PTRACE_SETFPREGS);
c906108c SS	197	}
c906108c SS	198	}