[deliverable/binutils-gdb.git] / gdb / hppahpux-xdep.c

/* Machine-dependent code which would otherwise be in infptrace.c,
   for GDB, the GNU debugger.  This code is for the HP PA-RISC cpu.
   Copyright 1986, 1987, 1989, 1990, 1991, 1992 Free Software Foundation, Inc.

   Contributed by the Center for Software Science at the
   University of Utah (pa-gdb-bugs@cs.utah.edu).

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>

#include <sys/ptrace.h>


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

#include "gdbcore.h"
#include <sys/user.h>		/* After a.out.h  */
#include <sys/file.h>
#include <sys/stat.h>
\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, 0);
}

#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_EXIT, inferior_pid, (PTRACE_ARG3_TYPE) 0, 0, 0); /* PT_EXIT = PT_KILL ? */
  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)
    ptrace (PT_SINGLE, inferior_pid, (PTRACE_ARG3_TYPE) 1, signal, 0);
  else
    ptrace (PT_CONTIN, inferior_pid, (PTRACE_ARG3_TYPE) 1, signal, 0);

  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, 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, 0);
  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;

#include <a.out.gnu.h>		/* For struct nlist */

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 ()
{
    struct user u;
    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, 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_RUREGS, inferior_pid,
				 (PTRACE_ARG3_TYPE) regaddr, 0, 0);
      regaddr += sizeof (int);
      if (errno != 0)
	{
	  sprintf (mess, "reading register %s (#%d)", reg_names[regno], regno);
	  perror_with_name (mess);
	}
    }
  if (regno == PCOQ_HEAD_REGNUM || regno == PCOQ_TAIL_REGNUM)
    buf[3] &= ~0x3;
  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_WUAREA, inferior_pid, (PTRACE_ARG3_TYPE) regaddr,
		  *(int *) &registers[REGISTER_BYTE (regno) + i], 0);
	  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_WUAREA, inferior_pid, (PTRACE_ARG3_TYPE) regaddr,
		      *(int *) &registers[REGISTER_BYTE (regno) + i], 0);
	      if (errno != 0)
		{
		  sprintf (buf, "writing register number %d(%d)", regno, i);
		  perror_with_name (buf);
		}
	      regaddr += sizeof(int);
	    }
	}
    }
  return;
}
#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_RIUSER, inferior_pid,
			    (PTRACE_ARG3_TYPE) addr, 0, 0);
      }

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

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

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

      /* Write the entire buffer.  */

      for (i = 0; i < count; i++, addr += sizeof (int))
	{
#if 0
/* The HP-UX kernel crashes if you use PT_WDUSER to write into the text
   segment.  FIXME -- does it work to write into the data segment using
   WIUSER, or do these idiots really expect us to figure out which segment
   the address is in, so we can use a separate system call for it??!  */
	  errno = 0;
	  ptrace (PT_WDUSER, inferior_pid, (PTRACE_ARG3_TYPE) addr,
		  buffer[i], 0);
	  if (errno)
#endif
	    {
	      /* Using the appropriate one (I or D) is necessary for
		 Gould NP1, at least.  */
	      errno = 0;
	      ptrace (PT_WIUSER, inferior_pid, (PTRACE_ARG3_TYPE) addr,
		      buffer[i], 0);
	    }
	  if (errno)
	    return 0;
	}
    }
  else
    {
      /* Read all the longwords */
      for (i = 0; i < count; i++, addr += sizeof (int))
	{
	  errno = 0;
	  buffer[i] = ptrace (PT_RIUSER, inferior_pid,
			      (PTRACE_ARG3_TYPE) addr, 0, 0);
	  if (errno)
	    return 0;
	  QUIT;
	}

      /* Copy appropriate bytes out of the buffer.  */
      bcopy ((char *) buffer + (memaddr & (sizeof (int) - 1)), myaddr, len);
    }
  return len;
}


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