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

/* Low level Unix child interface to ptrace, for GDB when running under Unix.
   Copyright 1988, 1989, 1990, 1991, 1992 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., 675 Mass Ave, Cambridge, MA 02139, USA.  */

#include "defs.h"
#include "frame.h"
#include "inferior.h"
#include "target.h"

#ifdef USG
#include <sys/types.h>
#endif

#include <sys/param.h>
#include <sys/dir.h>
#include <signal.h>
#include <sys/ioctl.h>
#ifndef USG
#ifdef PTRACE_IN_WRONG_PLACE
#include <ptrace.h>
#else
#include <sys/ptrace.h>
#endif
#endif

#if !defined (PT_KILL)
#define PT_KILL 8
#define PT_STEP 9
#define PT_CONTINUE 7
#define PT_READ_U 3
#define PT_WRITE_U 6
#define PT_READ_I 1
#define	PT_READ_D 2
#define PT_WRITE_I 4
#define PT_WRITE_D 5
#endif /* No PT_KILL.  */

#ifndef PT_ATTACH
#define PT_ATTACH PTRACE_ATTACH
#endif
#ifndef PT_DETACH
#define PT_DETACH PTRACE_DETACH
#endif

#include "gdbcore.h"
#ifndef	NO_SYS_FILE
#include <sys/file.h>
#endif
#include <sys/stat.h>

#if !defined (FETCH_INFERIOR_REGISTERS)
#include <sys/user.h>		/* Probably need to poke the user structure */
#if defined (KERNEL_U_ADDR_BSD)
#include <a.out.h>		/* For struct nlist */
#endif /* KERNEL_U_ADDR_BSD.  */
#endif /* !FETCH_INFERIOR_REGISTERS */

\f
/* This function simply calls ptrace with the given arguments.  
   It exists so that all calls to ptrace are isolated in this 
   machine-dependent file. */
int
call_ptrace (request, pid, addr, data)
     int request, pid;
     PTRACE_ARG3_TYPE addr;
     int data;
{
  return ptrace (request, pid, addr, data);
}

#ifdef DEBUG_PTRACE
/* For the rest of the file, use an extra level of indirection */
/* This lets us breakpoint usefully on call_ptrace. */
#define ptrace call_ptrace
#endif

/* This is used when GDB is exiting.  It gives less chance of error.*/

void
kill_inferior_fast ()
{
  if (inferior_pid == 0)
    return;
  ptrace (PT_KILL, inferior_pid, (PTRACE_ARG3_TYPE) 0, 0);
  wait ((int *)0);
}

void
kill_inferior ()
{
  kill_inferior_fast ();
  target_mourn_inferior ();
}

/* Resume execution of the inferior process.
   If STEP is nonzero, single-step it.
   If SIGNAL is nonzero, give it that signal.  */

void
child_resume (step, signal)
     int step;
     int signal;
{
  errno = 0;

  /* An address of (PTRACE_ARG3_TYPE)1 tells ptrace to continue from where
     it was.  (If GDB wanted it to start some other way, we have already
     written a new PC value to the child.)  */

  if (step)
#ifdef NO_SINGLE_STEP
    single_step (signal);
#else    
    ptrace (PT_STEP, inferior_pid, (PTRACE_ARG3_TYPE) 1, signal);
#endif
  else
#ifdef AIX_BUGGY_PTRACE_CONTINUE
    AIX_BUGGY_PTRACE_CONTINUE;
#else
    ptrace (PT_CONTINUE, inferior_pid, (PTRACE_ARG3_TYPE) 1, signal);
#endif

  if (errno)
    perror_with_name ("ptrace");
}
\f
#ifdef ATTACH_DETACH
/* Nonzero if we are debugging an attached process rather than
   an inferior.  */
extern int attach_flag;

/* Start debugging the process whose number is PID.  */
int
attach (pid)
     int pid;
{
  errno = 0;
  ptrace (PT_ATTACH, pid, (PTRACE_ARG3_TYPE) 0, 0);
  if (errno)
    perror_with_name ("ptrace");
  attach_flag = 1;
  return pid;
}

/* Stop debugging the process whose number is PID
   and continue it with signal number SIGNAL.
   SIGNAL = 0 means just continue it.  */

void
detach (signal)
     int signal;
{
  errno = 0;
  ptrace (PT_DETACH, inferior_pid, (PTRACE_ARG3_TYPE) 1, signal);
  if (errno)
    perror_with_name ("ptrace");
  attach_flag = 0;
}
#endif /* ATTACH_DETACH */
\f
#if !defined (FETCH_INFERIOR_REGISTERS)

/* KERNEL_U_ADDR is the amount to subtract from u.u_ar0
   to get the offset in the core file of the register values.  */
#if defined (KERNEL_U_ADDR_BSD)
/* Get kernel_u_addr using BSD-style nlist().  */
CORE_ADDR kernel_u_addr;

void
_initialize_kernel_u_addr ()
{
  struct nlist names[2];

  names[0].n_un.n_name = "_u";
  names[1].n_un.n_name = NULL;
  if (nlist ("/vmunix", names) == 0)
    kernel_u_addr = names[0].n_value;
  else
    fatal ("Unable to get kernel u area address.");
}
#endif /* KERNEL_U_ADDR_BSD.  */

#if defined (KERNEL_U_ADDR_HPUX)
/* Get kernel_u_addr using HPUX-style nlist().  */
CORE_ADDR kernel_u_addr;

struct hpnlist {      
        char *          n_name;
        long            n_value;  
        unsigned char   n_type;   
        unsigned char   n_length;  
        short           n_almod;   
        short           n_unused;
};
static struct hpnlist nl[] = {{ "_u", -1, }, { (char *) 0, }};

/* read the value of the u area from the hp-ux kernel */
void _initialize_kernel_u_addr ()
{
    nlist ("/hp-ux", &nl);
    kernel_u_addr = nl[0].n_value;
}
#endif /* KERNEL_U_ADDR_HPUX.  */

#if !defined (offsetof)
#define offsetof(TYPE, MEMBER) ((unsigned long) &((TYPE *)0)->MEMBER)
#endif

/* U_REGS_OFFSET is the offset of the registers within the u area.  */
#if !defined (U_REGS_OFFSET)
#define U_REGS_OFFSET \
  ptrace (PT_READ_U, inferior_pid, \
	  (PTRACE_ARG3_TYPE) (offsetof (struct user, u_ar0)), 0) \
    - KERNEL_U_ADDR
#endif

/* Registers we shouldn't try to fetch.  */
#if !defined (CANNOT_FETCH_REGISTER)
#define CANNOT_FETCH_REGISTER(regno) 0
#endif

/* Fetch one register.  */

static void
fetch_register (regno)
     int regno;
{
  register unsigned int regaddr;
  char buf[MAX_REGISTER_RAW_SIZE];
  char mess[128];				/* For messages */
  register int i;

  /* Offset of registers within the u area.  */
  unsigned int offset;

  if (CANNOT_FETCH_REGISTER (regno))
    {
      bzero (buf, REGISTER_RAW_SIZE (regno));	/* Supply zeroes */
      supply_register (regno, buf);
      return;
    }

  offset = U_REGS_OFFSET;

  regaddr = register_addr (regno, offset);
  for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (int))
    {
      errno = 0;
      *(int *) &buf[i] = ptrace (PT_READ_U, inferior_pid,
				 (PTRACE_ARG3_TYPE) regaddr, 0);
      regaddr += sizeof (int);
      if (errno != 0)
	{
	  sprintf (mess, "reading register %s (#%d)", reg_names[regno], regno);
	  perror_with_name (mess);
	}
    }
  supply_register (regno, buf);
}


/* Fetch all registers, or just one, from the child process.  */

void
fetch_inferior_registers (regno)
     int regno;
{
  if (regno == -1)
    for (regno = 0; regno < NUM_REGS; regno++)
      fetch_register (regno);
  else
    fetch_register (regno);
}

/* Registers we shouldn't try to store.  */
#if !defined (CANNOT_STORE_REGISTER)
#define CANNOT_STORE_REGISTER(regno) 0
#endif

/* 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 (regno)
     int regno;
{
  register unsigned int regaddr;
  char buf[80];
  extern char registers[];
  register int i;

  unsigned int offset = U_REGS_OFFSET;

  if (regno >= 0)
    {
      regaddr = register_addr (regno, offset);
      for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof(int))
	{
	  errno = 0;
	  ptrace (PT_WRITE_U, inferior_pid, (PTRACE_ARG3_TYPE) regaddr,
		  *(int *) &registers[REGISTER_BYTE (regno) + i]);
	  if (errno != 0)
	    {
	      sprintf (buf, "writing register number %d(%d)", regno, i);
	      perror_with_name (buf);
	    }
	  regaddr += sizeof(int);
	}
    }
  else
    {
      for (regno = 0; regno < NUM_REGS; regno++)
	{
	  if (CANNOT_STORE_REGISTER (regno))
	    continue;
	  regaddr = register_addr (regno, offset);
	  for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof(int))
	    {
	      errno = 0;
	      ptrace (PT_WRITE_U, inferior_pid, (PTRACE_ARG3_TYPE) regaddr,
		      *(int *) &registers[REGISTER_BYTE (regno) + i]);
	      if (errno != 0)
		{
		  sprintf (buf, "writing register number %d(%d)", regno, i);
		  perror_with_name (buf);
		}
	      regaddr += sizeof(int);
	    }
	}
    }
}
#endif /* !defined (FETCH_INFERIOR_REGISTERS).  */
\f
/* NOTE! I tried using PTRACE_READDATA, etc., to read and write memory
   in the NEW_SUN_PTRACE case.
   It ought to be straightforward.  But it appears that writing did
   not write the data that I specified.  I cannot understand where
   it got the data that it actually did write.  */

/* Copy LEN bytes to or from inferior's memory starting at MEMADDR
   to debugger memory starting at MYADDR.   Copy to inferior if
   WRITE is nonzero.
  
   Returns the length copied, which is either the LEN argument or zero.
   This xfer function does not do partial moves, since child_ops
   doesn't allow memory operations to cross below us in the target stack
   anyway.  */

int
child_xfer_memory (memaddr, myaddr, len, write, target)
     CORE_ADDR memaddr;
     char *myaddr;
     int len;
     int write;
     struct target_ops *target;		/* ignored */
{
  register int i;
  /* Round starting address down to longword boundary.  */
  register CORE_ADDR addr = memaddr & - sizeof (int);
  /* Round ending address up; get number of longwords that makes.  */
  register int count
    = (((memaddr + len) - addr) + sizeof (int) - 1) / sizeof (int);
  /* Allocate buffer of that many longwords.  */
  register int *buffer = (int *) alloca (count * sizeof (int));

  if (write)
    {
      /* Fill start and end extra bytes of buffer with existing memory data.  */

      if (addr != memaddr || len < (int)sizeof (int)) {
	/* Need part of initial word -- fetch it.  */
        buffer[0] = ptrace (PT_READ_I, inferior_pid, (PTRACE_ARG3_TYPE) addr,
			    0);
      }

      if (count > 1)		/* FIXME, avoid if even boundary */
	{
	  buffer[count - 1]
	    = ptrace (PT_READ_I, inferior_pid,
		      (PTRACE_ARG3_TYPE) (addr + (count - 1) * sizeof (int)),
		      0);
	}

      /* Copy data to be written over corresponding part of buffer */

      memcpy ((char *) buffer + (memaddr & (sizeof (int) - 1)), myaddr, len);

      /* Write the entire buffer.  */

      for (i = 0; i < count; i++, addr += sizeof (int))
	{
	  errno = 0;
	  ptrace (PT_WRITE_D, inferior_pid, (PTRACE_ARG3_TYPE) addr,
		  buffer[i]);
	  if (errno)
	    {
	      /* Using the appropriate one (I or D) is necessary for
		 Gould NP1, at least.  */
	      errno = 0;
	      ptrace (PT_WRITE_I, inferior_pid, (PTRACE_ARG3_TYPE) addr,
		      buffer[i]);
	    }
	  if (errno)
	    return 0;
	}
    }
  else
    {
      /* Read all the longwords */
      for (i = 0; i < count; i++, addr += sizeof (int))
	{
	  errno = 0;
	  buffer[i] = ptrace (PT_READ_I, inferior_pid,
			      (PTRACE_ARG3_TYPE) addr, 0);
	  if (errno)
	    return 0;
	  QUIT;
	}

      /* Copy appropriate bytes out of the buffer.  */
      memcpy (myaddr, (char *) buffer + (memaddr & (sizeof (int) - 1)), len);
    }
  return len;
}
Commit	Line	Data
bd5635a1	1	/* Low level Unix child interface to ptrace, for GDB when running under Unix.
ee0613d1	2	Copyright 1988, 1989, 1990, 1991, 1992 Free Software Foundation, Inc.
bd5635a1 RP	3
	4	This file is part of GDB.
	5
b6de2014	6	This program is free software; you can redistribute it and/or modify
bd5635a1	7	it under the terms of the GNU General Public License as published by
b6de2014 JG	8	the Free Software Foundation; either version 2 of the License, or
b6de2014 JG	9	(at your option) any later version.
bd5635a1	10
b6de2014	11	This program is distributed in the hope that it will be useful,
bd5635a1 RP	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
b6de2014 JG	17	along with this program; if not, write to the Free Software
b6de2014 JG	18	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
bd5635a1	19
bd5635a1	20	#include "defs.h"
bd5635a1 RP	21	#include "frame.h"
	22	#include "inferior.h"
	23	#include "target.h"
	24
	25	#ifdef USG
	26	#include <sys/types.h>
	27	#endif
	28
	29	#include <sys/param.h>
	30	#include <sys/dir.h>
	31	#include <signal.h>
	32	#include <sys/ioctl.h>
8ffd75c8	33	#ifndef USG
a0f9783e SG	34	#ifdef PTRACE_IN_WRONG_PLACE
	35	#include <ptrace.h>
	36	#else
bd5635a1	37	#include <sys/ptrace.h>
8ffd75c8	38	#endif
a0f9783e	39	#endif
8ffd75c8	40
bd5635a1 RP	41	#if !defined (PT_KILL)
	42	#define PT_KILL 8
	43	#define PT_STEP 9
	44	#define PT_CONTINUE 7
	45	#define PT_READ_U 3
	46	#define PT_WRITE_U 6
	47	#define PT_READ_I 1
8ffd75c8	48	#define PT_READ_D 2
bd5635a1	49	#define PT_WRITE_I 4
8ffd75c8	50	#define PT_WRITE_D 5
bd5635a1 RP	51	#endif /* No PT_KILL. */
	52
	53	#ifndef PT_ATTACH
	54	#define PT_ATTACH PTRACE_ATTACH
	55	#endif
	56	#ifndef PT_DETACH
	57	#define PT_DETACH PTRACE_DETACH
	58	#endif
	59
	60	#include "gdbcore.h"
ee0613d1	61	#ifndef NO_SYS_FILE
bd5635a1	62	#include <sys/file.h>
ee0613d1	63	#endif
bd5635a1	64	#include <sys/stat.h>
44ff4c96 JG	65
	66	#if !defined (FETCH_INFERIOR_REGISTERS)
	67	#include <sys/user.h> /* Probably need to poke the user structure */
	68	#if defined (KERNEL_U_ADDR_BSD)
	69	#include <a.out.h> /* For struct nlist */
	70	#endif /* KERNEL_U_ADDR_BSD. */
	71	#endif /* !FETCH_INFERIOR_REGISTERS */
e676a15f	72
bd5635a1 RP	73	\f
	74	/* This function simply calls ptrace with the given arguments.
	75	It exists so that all calls to ptrace are isolated in this
	76	machine-dependent file. */
	77	int
	78	call_ptrace (request, pid, addr, data)
e676a15f FF	79	int request, pid;
	80	PTRACE_ARG3_TYPE addr;
	81	int data;
bd5635a1 RP	82	{
	83	return ptrace (request, pid, addr, data);
	84	}
	85
	86	#ifdef DEBUG_PTRACE
	87	/* For the rest of the file, use an extra level of indirection */
	88	/* This lets us breakpoint usefully on call_ptrace. */
	89	#define ptrace call_ptrace
	90	#endif
	91
	92	/* This is used when GDB is exiting. It gives less chance of error.*/
	93
	94	void
	95	kill_inferior_fast ()
	96	{
	97	if (inferior_pid == 0)
	98	return;
e676a15f	99	ptrace (PT_KILL, inferior_pid, (PTRACE_ARG3_TYPE) 0, 0);
bd5635a1 RP	100	wait ((int *)0);
	101	}
	102
	103	void
ee0613d1	104	kill_inferior ()
bd5635a1 RP	105	{
	106	kill_inferior_fast ();
	107	target_mourn_inferior ();
	108	}
	109
	110	/* Resume execution of the inferior process.
	111	If STEP is nonzero, single-step it.
	112	If SIGNAL is nonzero, give it that signal. */
	113
	114	void
	115	child_resume (step, signal)
	116	int step;
	117	int signal;
	118	{
	119	errno = 0;
d11c44f1	120
e676a15f FF	121	/* An address of (PTRACE_ARG3_TYPE)1 tells ptrace to continue from where
	122	it was. (If GDB wanted it to start some other way, we have already
	123	written a new PC value to the child.) */
d11c44f1	124
bd5635a1	125	if (step)
e676a15f FF	126	#ifdef NO_SINGLE_STEP
	127	single_step (signal);
	128	#else
	129	ptrace (PT_STEP, inferior_pid, (PTRACE_ARG3_TYPE) 1, signal);
	130	#endif
bd5635a1	131	else
e676a15f FF	132	#ifdef AIX_BUGGY_PTRACE_CONTINUE
	133	AIX_BUGGY_PTRACE_CONTINUE;
	134	#else
	135	ptrace (PT_CONTINUE, inferior_pid, (PTRACE_ARG3_TYPE) 1, signal);
	136	#endif
d11c44f1	137
bd5635a1 RP	138	if (errno)
	139	perror_with_name ("ptrace");
	140	}
	141	\f
	142	#ifdef ATTACH_DETACH
	143	/* Nonzero if we are debugging an attached process rather than
	144	an inferior. */
	145	extern int attach_flag;
	146
	147	/* Start debugging the process whose number is PID. */
	148	int
	149	attach (pid)
	150	int pid;
	151	{
	152	errno = 0;
e676a15f	153	ptrace (PT_ATTACH, pid, (PTRACE_ARG3_TYPE) 0, 0);
bd5635a1 RP	154	if (errno)
	155	perror_with_name ("ptrace");
	156	attach_flag = 1;
	157	return pid;
	158	}
	159
	160	/* Stop debugging the process whose number is PID
	161	and continue it with signal number SIGNAL.
	162	SIGNAL = 0 means just continue it. */
	163
	164	void
	165	detach (signal)
	166	int signal;
	167	{
	168	errno = 0;
e676a15f	169	ptrace (PT_DETACH, inferior_pid, (PTRACE_ARG3_TYPE) 1, signal);
bd5635a1 RP	170	if (errno)
	171	perror_with_name ("ptrace");
	172	attach_flag = 0;
	173	}
	174	#endif /* ATTACH_DETACH */
	175	\f
	176	#if !defined (FETCH_INFERIOR_REGISTERS)
	177
	178	/* KERNEL_U_ADDR is the amount to subtract from u.u_ar0
	179	to get the offset in the core file of the register values. */
	180	#if defined (KERNEL_U_ADDR_BSD)
	181	/* Get kernel_u_addr using BSD-style nlist(). */
	182	CORE_ADDR kernel_u_addr;
	183
	184	void
	185	_initialize_kernel_u_addr ()
	186	{
	187	struct nlist names[2];
	188
	189	names[0].n_un.n_name = "_u";
	190	names[1].n_un.n_name = NULL;
	191	if (nlist ("/vmunix", names) == 0)
	192	kernel_u_addr = names[0].n_value;
	193	else
	194	fatal ("Unable to get kernel u area address.");
	195	}
	196	#endif /* KERNEL_U_ADDR_BSD. */
	197
	198	#if defined (KERNEL_U_ADDR_HPUX)
	199	/* Get kernel_u_addr using HPUX-style nlist(). */
	200	CORE_ADDR kernel_u_addr;
	201
	202	struct hpnlist {
	203	char * n_name;
	204	long n_value;
	205	unsigned char n_type;
	206	unsigned char n_length;
	207	short n_almod;
	208	short n_unused;
	209	};
	210	static struct hpnlist nl[] = {{ "_u", -1, }, { (char *) 0, }};
	211
	212	/* read the value of the u area from the hp-ux kernel */
	213	void _initialize_kernel_u_addr ()
	214	{
bd5635a1 RP	215	nlist ("/hp-ux", &nl);
	216	kernel_u_addr = nl[0].n_value;
	217	}
	218	#endif /* KERNEL_U_ADDR_HPUX. */
	219
	220	#if !defined (offsetof)
	221	#define offsetof(TYPE, MEMBER) ((unsigned long) &((TYPE *)0)->MEMBER)
	222	#endif
	223
	224	/* U_REGS_OFFSET is the offset of the registers within the u area. */
	225	#if !defined (U_REGS_OFFSET)
	226	#define U_REGS_OFFSET \
	227	ptrace (PT_READ_U, inferior_pid, \
e676a15f FF	228	(PTRACE_ARG3_TYPE) (offsetof (struct user, u_ar0)), 0) \
e676a15f FF	229	- KERNEL_U_ADDR
bd5635a1 RP	230	#endif
bd5635a1 RP	231
44ff4c96 JG	232	/* Registers we shouldn't try to fetch. */
	233	#if !defined (CANNOT_FETCH_REGISTER)
	234	#define CANNOT_FETCH_REGISTER(regno) 0
	235	#endif
	236
bd5635a1	237	/* Fetch one register. */
44ff4c96	238
bd5635a1 RP	239	static void
	240	fetch_register (regno)
	241	int regno;
	242	{
	243	register unsigned int regaddr;
	244	char buf[MAX_REGISTER_RAW_SIZE];
44ff4c96	245	char mess[128]; /* For messages */
bd5635a1 RP	246	register int i;
	247
	248	/* Offset of registers within the u area. */
44ff4c96 JG	249	unsigned int offset;
	250
	251	if (CANNOT_FETCH_REGISTER (regno))
	252	{
	253	bzero (buf, REGISTER_RAW_SIZE (regno)); /* Supply zeroes */
	254	supply_register (regno, buf);
	255	return;
	256	}
	257
	258	offset = U_REGS_OFFSET;
bd5635a1 RP	259
	260	regaddr = register_addr (regno, offset);
	261	for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (int))
	262	{
44ff4c96	263	errno = 0;
e676a15f FF	264	(int ) &buf[i] = ptrace (PT_READ_U, inferior_pid,
e676a15f FF	265	(PTRACE_ARG3_TYPE) regaddr, 0);
bd5635a1	266	regaddr += sizeof (int);
44ff4c96 JG	267	if (errno != 0)
	268	{
	269	sprintf (mess, "reading register %s (#%d)", reg_names[regno], regno);
	270	perror_with_name (mess);
	271	}
bd5635a1 RP	272	}
	273	supply_register (regno, buf);
	274	}
	275
44ff4c96	276
5594d534	277	/* Fetch all registers, or just one, from the child process. */
bd5635a1	278
5594d534	279	void
bd5635a1 RP	280	fetch_inferior_registers (regno)
	281	int regno;
	282	{
	283	if (regno == -1)
	284	for (regno = 0; regno < NUM_REGS; regno++)
	285	fetch_register (regno);
	286	else
	287	fetch_register (regno);
bd5635a1 RP	288	}
	289
	290	/* Registers we shouldn't try to store. */
	291	#if !defined (CANNOT_STORE_REGISTER)
	292	#define CANNOT_STORE_REGISTER(regno) 0
	293	#endif
	294
	295	/* Store our register values back into the inferior.
	296	If REGNO is -1, do this for all registers.
	297	Otherwise, REGNO specifies which register (so we can save time). */
	298
e676a15f	299	void
bd5635a1 RP	300	store_inferior_registers (regno)
	301	int regno;
	302	{
	303	register unsigned int regaddr;
	304	char buf[80];
	305	extern char registers[];
	306	register int i;
bd5635a1 RP	307
	308	unsigned int offset = U_REGS_OFFSET;
	309
	310	if (regno >= 0)
	311	{
	312	regaddr = register_addr (regno, offset);
	313	for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof(int))
	314	{
	315	errno = 0;
e676a15f	316	ptrace (PT_WRITE_U, inferior_pid, (PTRACE_ARG3_TYPE) regaddr,
bd5635a1 RP	317	(int ) &registers[REGISTER_BYTE (regno) + i]);
	318	if (errno != 0)
	319	{
	320	sprintf (buf, "writing register number %d(%d)", regno, i);
	321	perror_with_name (buf);
bd5635a1 RP	322	}
	323	regaddr += sizeof(int);
	324	}
	325	}
	326	else
	327	{
	328	for (regno = 0; regno < NUM_REGS; regno++)
	329	{
	330	if (CANNOT_STORE_REGISTER (regno))
	331	continue;
	332	regaddr = register_addr (regno, offset);
	333	for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof(int))
	334	{
	335	errno = 0;
e676a15f	336	ptrace (PT_WRITE_U, inferior_pid, (PTRACE_ARG3_TYPE) regaddr,
bd5635a1 RP	337	(int ) &registers[REGISTER_BYTE (regno) + i]);
	338	if (errno != 0)
	339	{
	340	sprintf (buf, "writing register number %d(%d)", regno, i);
	341	perror_with_name (buf);
bd5635a1 RP	342	}
	343	regaddr += sizeof(int);
	344	}
	345	}
	346	}
bd5635a1 RP	347	}
	348	#endif /* !defined (FETCH_INFERIOR_REGISTERS). */
	349	\f
	350	/* NOTE! I tried using PTRACE_READDATA, etc., to read and write memory
	351	in the NEW_SUN_PTRACE case.
	352	It ought to be straightforward. But it appears that writing did
	353	not write the data that I specified. I cannot understand where
	354	it got the data that it actually did write. */
	355
	356	/* Copy LEN bytes to or from inferior's memory starting at MEMADDR
	357	to debugger memory starting at MYADDR. Copy to inferior if
	358	WRITE is nonzero.
	359
	360	Returns the length copied, which is either the LEN argument or zero.
	361	This xfer function does not do partial moves, since child_ops
	362	doesn't allow memory operations to cross below us in the target stack
	363	anyway. */
	364
	365	int
b6de2014	366	child_xfer_memory (memaddr, myaddr, len, write, target)
bd5635a1 RP	367	CORE_ADDR memaddr;
	368	char *myaddr;
	369	int len;
	370	int write;
ee0613d1	371	struct target_ops target; / ignored */
bd5635a1 RP	372	{
	373	register int i;
	374	/* Round starting address down to longword boundary. */
	375	register CORE_ADDR addr = memaddr & - sizeof (int);
	376	/* Round ending address up; get number of longwords that makes. */
	377	register int count
	378	= (((memaddr + len) - addr) + sizeof (int) - 1) / sizeof (int);
	379	/* Allocate buffer of that many longwords. */
	380	register int buffer = (int ) alloca (count * sizeof (int));
	381
	382	if (write)
	383	{
	384	/* Fill start and end extra bytes of buffer with existing memory data. */
	385
	386	if (addr != memaddr \|\| len < (int)sizeof (int)) {
	387	/* Need part of initial word -- fetch it. */
e676a15f FF	388	buffer[0] = ptrace (PT_READ_I, inferior_pid, (PTRACE_ARG3_TYPE) addr,
e676a15f FF	389	0);
bd5635a1 RP	390	}
	391
	392	if (count > 1) /* FIXME, avoid if even boundary */
	393	{
	394	buffer[count - 1]
	395	= ptrace (PT_READ_I, inferior_pid,
e676a15f FF	396	(PTRACE_ARG3_TYPE) (addr + (count - 1) * sizeof (int)),
e676a15f FF	397	0);
bd5635a1 RP	398	}
	399
	400	/* Copy data to be written over corresponding part of buffer */
	401
a0f9783e	402	memcpy ((char *) buffer + (memaddr & (sizeof (int) - 1)), myaddr, len);
bd5635a1 RP	403
	404	/* Write the entire buffer. */
	405
	406	for (i = 0; i < count; i++, addr += sizeof (int))
	407	{
	408	errno = 0;
e676a15f FF	409	ptrace (PT_WRITE_D, inferior_pid, (PTRACE_ARG3_TYPE) addr,
e676a15f FF	410	buffer[i]);
bd5635a1 RP	411	if (errno)
	412	{
	413	/* Using the appropriate one (I or D) is necessary for
	414	Gould NP1, at least. */
	415	errno = 0;
e676a15f FF	416	ptrace (PT_WRITE_I, inferior_pid, (PTRACE_ARG3_TYPE) addr,
e676a15f FF	417	buffer[i]);
bd5635a1 RP	418	}
	419	if (errno)
	420	return 0;
	421	}
	422	}
	423	else
	424	{
	425	/* Read all the longwords */
	426	for (i = 0; i < count; i++, addr += sizeof (int))
	427	{
	428	errno = 0;
e676a15f FF	429	buffer[i] = ptrace (PT_READ_I, inferior_pid,
e676a15f FF	430	(PTRACE_ARG3_TYPE) addr, 0);
bd5635a1 RP	431	if (errno)
	432	return 0;
	433	QUIT;
	434	}
	435
	436	/* Copy appropriate bytes out of the buffer. */
a0f9783e	437	memcpy (myaddr, (char *) buffer + (memaddr & (sizeof (int) - 1)), len);
bd5635a1 RP	438	}
	439	return len;
	440	}