[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 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_STEP, inferior_pid, (PTRACE_ARG3_TYPE) 1, signal);
  else
    ptrace (PT_CONTINUE, inferior_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 RP	257
	258	/* Resume execution of the inferior process.
	259	If STEP is nonzero, single-step it.
	260	If SIGNAL is nonzero, give it that signal. */
	261
	262	void
	263	child_resume (step, signal)
	264	int step;
	265	int signal;
	266	{
	267	errno = 0;
	268
	269	/* An address of (PTRACE_ARG3_TYPE) 1 tells ptrace to continue from where
	270	it was. (If GDB wanted it to start some other way, we have already
	271	written a new PC value to the child.) */
	272
	273	if (step)
	274	ptrace (PT_STEP, inferior_pid, (PTRACE_ARG3_TYPE) 1, signal);
	275	else
	276	ptrace (PT_CONTINUE, inferior_pid, (PTRACE_ARG3_TYPE) 1, signal);
	277
	278	if (errno)
	279	perror_with_name ("ptrace");
	280	}
	281
	282	/* NOTE! I tried using PTRACE_READDATA, etc., to read and write memory
	283	in the NEW_SUN_PTRACE case.
	284	It ought to be straightforward. But it appears that writing did
	285	not write the data that I specified. I cannot understand where
	286	it got the data that it actually did write. */
	287
	288	/* Copy LEN bytes to or from inferior's memory starting at MEMADDR
	289	to debugger memory starting at MYADDR. Copy to inferior if
	290	WRITE is nonzero.
	291
	292	Returns the length copied, which is either the LEN argument or zero.
	293	This xfer function does not do partial moves, since child_ops
	294	doesn't allow memory operations to cross below us in the target stack
	295	anyway. */
	296
	297	int
	298	child_xfer_memory (memaddr, myaddr, len, write, target)
	299	CORE_ADDR memaddr;
	300	char *myaddr;
	301	int len;
	302	int write;
	303	struct target_ops target; / ignored */
	304	{
	305	register int i;
	306	/* Round starting address down to longword boundary. */
	307	register CORE_ADDR addr = memaddr & - sizeof (int);
	308	/* Round ending address up; get number of longwords that makes. */
	309	register int count
	310	= (((memaddr + len) - addr) + sizeof (int) - 1) / sizeof (int);
	311	/* Allocate buffer of that many longwords. */
	312	register int buffer = (int ) alloca (count * sizeof (int));
	313
	314	if (write)
	315	{
	316	/* Fill start and end extra bytes of buffer with existing memory data. */
	317
	318	if (addr != memaddr \|\| len < (int)sizeof (int)) {
	319	/* Need part of initial word -- fetch it. */
	320	buffer[0] = ptrace (PT_READ_I, inferior_pid, (PTRACE_ARG3_TYPE) addr,
321	0);
322	}
323
324	if (count > 1) /* FIXME, avoid if even boundary */
325	{
326	buffer[count - 1]
327	= ptrace (PT_READ_I, inferior_pid,
328	(PTRACE_ARG3_TYPE) (addr + (count - 1) * sizeof (int)),
329	0);
330	}
331
332	/* Copy data to be written over corresponding part of buffer */
333
334	bcopy (myaddr, (char *) buffer + (memaddr & (sizeof (int) - 1)), len);
335
336	/* Write the entire buffer. */
337
338	for (i = 0; i < count; i++, addr += sizeof (int))
339	{
340	errno = 0;
341	ptrace (PT_WRITE_D, inferior_pid, (PTRACE_ARG3_TYPE) addr,
342	buffer[i]);
343	if (errno)
344	{
345	/* Using the appropriate one (I or D) is necessary for
346	Gould NP1, at least. */
347	errno = 0;
348	ptrace (PT_WRITE_I, inferior_pid, (PTRACE_ARG3_TYPE) addr,
349	buffer[i]);
350	}
351	if (errno)
352	return 0;
353	}
354	}
355	else
356	{
357	/* Read all the longwords */
358	for (i = 0; i < count; i++, addr += sizeof (int))
359	{
360	errno = 0;
361	buffer[i] = ptrace (PT_READ_I, inferior_pid,
362	(PTRACE_ARG3_TYPE) addr, 0);
363	if (errno)
364	return 0;
365	QUIT;
366	}
367
368	/* Copy appropriate bytes out of the buffer. */
369	bcopy ((char *) buffer + (memaddr & (sizeof (int) - 1)), myaddr, len);
370	}
371	return len;
372	}
373