[binutils.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 ([email protected]).

   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 "defs.h"
#include "inferior.h"
#include "target.h"
#include <sys/ptrace.h>

/* Use an extra level of indirection for ptrace calls.
   This lets us breakpoint usefully on call_ptrace.   It also
   allows us to pass an extra argument to ptrace without
   using an ANSI-C specific macro.  */

#define ptrace call_ptrace

#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", REGISTER_NAME (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;
  char buf[80];
  register int i;
  unsigned int offset = U_REGS_OFFSET;
  int scratch;

  if (regno >= 0)
    {
      if (CANNOT_STORE_REGISTER (regno))
	return;
      regaddr = register_addr (regno, offset);
      errno = 0;
      if (regno == PCOQ_HEAD_REGNUM || regno == PCOQ_TAIL_REGNUM)
	{
	  scratch = *(int *) &registers[REGISTER_BYTE (regno)] | 0x3;
	  ptrace (PT_WUREGS, inferior_pid, (PTRACE_ARG3_TYPE) regaddr,
		  scratch);
	  if (errno != 0)
	    {
	      /* Error, even if attached.  Failing to write these two
	         registers is pretty serious.  */
	      sprintf (buf, "writing register number %d", regno);
	      perror_with_name (buf);
	    }
	}
      else
	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)
	      {
		/* 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, "writing register %s: %s",
			 REGISTER_NAME (regno), err);
		warning (msg);
		return;
	      }
	    regaddr += sizeof (int);
	  }
    }
  else
    for (regno = 0; regno < NUM_REGS; regno++)
      store_inferior_registers (regno);
}

/* PT_PROT is specific to the PA BSD kernel and isn't documented
   anywhere (except here).  

   PT_PROT allows one to enable/disable the data memory break bit
   for pages of memory in an inferior process.  This bit is used
   to cause "Data memory break traps" to occur when the appropriate
   page is written to.

   The arguments are as follows:

   PT_PROT -- The ptrace action to perform.

   INFERIOR_PID -- The pid of the process who's page table entries
   will be modified.

   PT_ARGS -- The *address* of a 3 word block of memory which has
   additional information:

   word 0 -- The start address to watch.  This should be a page-aligned
   address.

   word 1 -- The ending address to watch.  Again, this should be a 
   page aligned address.

   word 2 -- Nonzero to enable the data memory break bit on the
   given address range or zero to disable the data memory break
   bit on the given address range.

   This call may fail if the given addresses are not valid in the inferior
   process.  This most often happens when restarting a program which
   as watchpoints inserted on heap or stack memory.  */

#define PT_PROT 21

int
hppa_set_watchpoint (addr, len, flag)
     int addr, len, flag;
{
  int pt_args[3];
  pt_args[0] = addr;
  pt_args[1] = addr + len;
  pt_args[2] = flag;

  /* Mask off the lower 12 bits since we want to work on a page basis.  */
  pt_args[0] >>= 12;
  pt_args[1] >>= 12;

  /* Rounding adjustments.  */
  pt_args[1] -= pt_args[0];
  pt_args[1]++;

  /* Put the lower 12 bits back as zero.  */
  pt_args[0] <<= 12;
  pt_args[1] <<= 12;

  /* Do it.  */
  return ptrace (PT_PROT, inferior_pid, (PTRACE_ARG3_TYPE) pt_args, 0);
}
Commit	Line	Data
c906108c SS	1	/* Machine-dependent hooks for the unix child process stratum. This
	2	code is for the HP PA-RISC cpu.
	3
	4	Copyright 1986, 1987, 1989, 1990, 1991, 1992, 1993 Free Software Foundation, Inc.
	5
	6	Contributed by the Center for Software Science at the
	7	University of Utah ([email protected]).
	8
c5aa993b	9	This file is part of GDB.
c906108c	10
c5aa993b JM	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.
c906108c	15
c5aa993b JM	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.
c906108c	20
c5aa993b JM	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., 59 Temple Place - Suite 330,
	24	Boston, MA 02111-1307, USA. */
c906108c SS	25
	26	#include "defs.h"
	27	#include "inferior.h"
	28	#include "target.h"
	29	#include <sys/ptrace.h>
	30
	31	/* Use an extra level of indirection for ptrace calls.
	32	This lets us breakpoint usefully on call_ptrace. It also
	33	allows us to pass an extra argument to ptrace without
	34	using an ANSI-C specific macro. */
	35
	36	#define ptrace call_ptrace
	37
	38	#if !defined (offsetof)
	39	#define offsetof(TYPE, MEMBER) ((unsigned long) &((TYPE *)0)->MEMBER)
	40	#endif
	41
	42	/* U_REGS_OFFSET is the offset of the registers within the u area. */
	43	#if !defined (U_REGS_OFFSET)
	44	#define U_REGS_OFFSET \
	45	ptrace (PT_READ_U, inferior_pid, \
	46	(PTRACE_ARG3_TYPE) (offsetof (struct user, u_ar0)), 0) \
	47	- KERNEL_U_ADDR
	48	#endif
	49
	50	/* Fetch one register. */
	51
	52	static void
	53	fetch_register (regno)
	54	int regno;
	55	{
	56	register unsigned int regaddr;
	57	char buf[MAX_REGISTER_RAW_SIZE];
	58	register int i;
	59
	60	/* Offset of registers within the u area. */
	61	unsigned int offset;
	62
	63	offset = U_REGS_OFFSET;
	64
	65	regaddr = register_addr (regno, offset);
	66	for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (int))
	67	{
	68	errno = 0;
	69	(int ) &buf[i] = ptrace (PT_RUREGS, inferior_pid,
	70	(PTRACE_ARG3_TYPE) regaddr, 0);
	71	regaddr += sizeof (int);
	72	if (errno != 0)
	73	{
	74	/* Warning, not error, in case we are attached; sometimes the
	75	kernel doesn't let us at the registers. */
	76	char *err = safe_strerror (errno);
	77	char *msg = alloca (strlen (err) + 128);
	78	sprintf (msg, "reading register %s: %s", REGISTER_NAME (regno), err);
	79	warning (msg);
	80	goto error_exit;
	81	}
	82	}
	83	supply_register (regno, buf);
c5aa993b	84	error_exit:;
c906108c SS	85	}
	86
	87	/* Fetch all registers, or just one, from the child process. */
	88
	89	void
	90	fetch_inferior_registers (regno)
	91	int regno;
	92	{
	93	if (regno == -1)
	94	for (regno = 0; regno < NUM_REGS; regno++)
	95	fetch_register (regno);
	96	else
	97	fetch_register (regno);
	98	}
	99
	100	/* Store our register values back into the inferior.
	101	If REGNO is -1, do this for all registers.
	102	Otherwise, REGNO specifies which register (so we can save time). */
	103
	104	void
	105	store_inferior_registers (regno)
	106	int regno;
	107	{
	108	register unsigned int regaddr;
	109	char buf[80];
c906108c SS	110	register int i;
	111	unsigned int offset = U_REGS_OFFSET;
	112	int scratch;
	113
	114	if (regno >= 0)
	115	{
	116	if (CANNOT_STORE_REGISTER (regno))
	117	return;
	118	regaddr = register_addr (regno, offset);
	119	errno = 0;
	120	if (regno == PCOQ_HEAD_REGNUM \|\| regno == PCOQ_TAIL_REGNUM)
c5aa993b JM	121	{
	122	scratch = (int ) &registers[REGISTER_BYTE (regno)] \| 0x3;
	123	ptrace (PT_WUREGS, inferior_pid, (PTRACE_ARG3_TYPE) regaddr,
	124	scratch);
	125	if (errno != 0)
	126	{
c906108c	127	/* Error, even if attached. Failing to write these two
c5aa993b JM	128	registers is pretty serious. */
	129	sprintf (buf, "writing register number %d", regno);
	130	perror_with_name (buf);
	131	}
	132	}
c906108c	133	else
c5aa993b	134	for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (int))
c906108c SS	135	{
	136	errno = 0;
	137	ptrace (PT_WUREGS, inferior_pid, (PTRACE_ARG3_TYPE) regaddr,
	138	(int ) &registers[REGISTER_BYTE (regno) + i]);
	139	if (errno != 0)
	140	{
	141	/* Warning, not error, in case we are attached; sometimes the
	142	kernel doesn't let us at the registers. */
	143	char *err = safe_strerror (errno);
	144	char *msg = alloca (strlen (err) + 128);
	145	sprintf (msg, "writing register %s: %s",
	146	REGISTER_NAME (regno), err);
	147	warning (msg);
	148	return;
	149	}
c5aa993b	150	regaddr += sizeof (int);
c906108c SS	151	}
	152	}
	153	else
	154	for (regno = 0; regno < NUM_REGS; regno++)
	155	store_inferior_registers (regno);
	156	}
	157
	158	/* PT_PROT is specific to the PA BSD kernel and isn't documented
	159	anywhere (except here).
	160
	161	PT_PROT allows one to enable/disable the data memory break bit
	162	for pages of memory in an inferior process. This bit is used
	163	to cause "Data memory break traps" to occur when the appropriate
	164	page is written to.
	165
	166	The arguments are as follows:
	167
c5aa993b JM	168	PT_PROT -- The ptrace action to perform.
	169
	170	INFERIOR_PID -- The pid of the process who's page table entries
	171	will be modified.
c906108c	172
c5aa993b JM	173	PT_ARGS -- The address of a 3 word block of memory which has
c5aa993b JM	174	additional information:
c906108c	175
c5aa993b JM	176	word 0 -- The start address to watch. This should be a page-aligned
c5aa993b JM	177	address.
c906108c	178
c5aa993b JM	179	word 1 -- The ending address to watch. Again, this should be a
c5aa993b JM	180	page aligned address.
c906108c	181
c5aa993b JM	182	word 2 -- Nonzero to enable the data memory break bit on the
	183	given address range or zero to disable the data memory break
	184	bit on the given address range.
c906108c	185
c5aa993b JM	186	This call may fail if the given addresses are not valid in the inferior
	187	process. This most often happens when restarting a program which
	188	as watchpoints inserted on heap or stack memory. */
c906108c	189
c906108c SS	190	#define PT_PROT 21
	191
	192	int
	193	hppa_set_watchpoint (addr, len, flag)
	194	int addr, len, flag;
	195	{
	196	int pt_args[3];
	197	pt_args[0] = addr;
	198	pt_args[1] = addr + len;
	199	pt_args[2] = flag;
	200
	201	/* Mask off the lower 12 bits since we want to work on a page basis. */
c5aa993b JM	202	pt_args[0] >>= 12;
c5aa993b JM	203	pt_args[1] >>= 12;
c906108c SS	204
c906108c SS	205	/* Rounding adjustments. */
c5aa993b JM	206	pt_args[1] -= pt_args[0];
c5aa993b JM	207	pt_args[1]++;
c906108c SS	208
c906108c SS	209	/* Put the lower 12 bits back as zero. */
c5aa993b JM	210	pt_args[0] <<= 12;
c5aa993b JM	211	pt_args[1] <<= 12;
c906108c SS	212
	213	/* Do it. */
	214	return ptrace (PT_PROT, inferior_pid, (PTRACE_ARG3_TYPE) pt_args, 0);
	215	}