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

/* Machine-dependent hooks for the unix child process stratum.  This
   code is for the HP PA-RISC cpu.

   Copyright 1986, 1987, 1989, 1990, 1991, 1992, 1993 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 "inferior.h"
#include "target.h"
#include <sys/ptrace.h>

#ifdef FIVE_ARG_PTRACE

/* Deal with HPUX 8.0 braindamage.  */
#define ptrace(a,b,c,d) ptrace(a,b,c,d,0)

#endif

#ifndef PT_ATTACH
#define PT_ATTACH PTRACE_ATTACH
#endif

#ifndef PT_DETACH
#define PT_DETACH PTRACE_DETACH
#endif

/* 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

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

#ifdef ATTACH_DETACH

/* 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


/* 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) \
    - KERNEL_U_ADDR
#endif

/* Fetch one register.  */

static void
fetch_register (regno)
     int regno;
{
  register unsigned int regaddr;
  char buf[MAX_REGISTER_RAW_SIZE];
  register int i;

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

  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);
      regaddr += sizeof (int);
      if (errno != 0)
	{
	  /* Warning, not error, in case we are attached; sometimes the
	     kernel doesn't let us at the registers.  */
	  char *err = safe_strerror (errno);
	  char *msg = alloca (strlen (err) + 128);
	  sprintf (msg, "reading register %s: %s", reg_names[regno], err);
	  warning (msg);
	  goto error_exit;
	}
    }
  supply_register (regno, buf);
 error_exit:;
}

/* 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);
}

/* 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;
  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_WUREGS, inferior_pid, (PTRACE_ARG3_TYPE) regaddr,
		  *(int *) &registers[REGISTER_BYTE (regno) + i]);
	  if (errno != 0)
	    {
	      char *err = safe_strerror (errno);
	      char *msg = alloca (strlen (err) + 128);
	      sprintf (msg, "writing register %s: %s", reg_names[regno], err);
	      warning (msg);
	    }
	  regaddr += sizeof(int);
	}
    }
  else
    {
      for (regno = 0; regno < NUM_REGS; regno++)
	{
	  if (CANNOT_STORE_REGISTER (regno))
	    continue;
	  store_inferior_registers (regno);
	}
    }
  return;
}

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

void
child_resume (pid, step, signal)
     int pid;
     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_STEP, pid, (PTRACE_ARG3_TYPE) 1, signal);
  else
    ptrace (PT_CONTINUE, pid, (PTRACE_ARG3_TYPE) 1, signal);

  if (errno)
    perror_with_name ("ptrace");
}

/* 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 */

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