/* Native support code for HPUX PA-RISC.
|
/* Native support code for HPUX PA-RISC.
|
Copyright 1986, 1987, 1989, 1990, 1991, 1992, 1993, 1998, 1999
|
Copyright 1986, 1987, 1989, 1990, 1991, 1992, 1993, 1998, 1999
|
Free Software Foundation, Inc.
|
Free Software Foundation, Inc.
|
|
|
Contributed by the Center for Software Science at the
|
Contributed by the Center for Software Science at the
|
University of Utah (pa-gdb-bugs@cs.utah.edu).
|
University of Utah (pa-gdb-bugs@cs.utah.edu).
|
|
|
This file is part of GDB.
|
This file is part of GDB.
|
|
|
This program is free software; you can redistribute it and/or modify
|
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
|
it under the terms of the GNU General Public License as published by
|
the Free Software Foundation; either version 2 of the License, or
|
the Free Software Foundation; either version 2 of the License, or
|
(at your option) any later version.
|
(at your option) any later version.
|
|
|
This program is distributed in the hope that it will be useful,
|
This program is distributed in the hope that it will be useful,
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
GNU General Public License for more details.
|
GNU General Public License for more details.
|
|
|
You should have received a copy of the GNU General Public License
|
You should have received a copy of the GNU General Public License
|
along with this program; if not, write to the Free Software
|
along with this program; if not, write to the Free Software
|
Foundation, Inc., 59 Temple Place - Suite 330,
|
Foundation, Inc., 59 Temple Place - Suite 330,
|
Boston, MA 02111-1307, USA. */
|
Boston, MA 02111-1307, USA. */
|
|
|
|
|
#include "defs.h"
|
#include "defs.h"
|
#include "inferior.h"
|
#include "inferior.h"
|
#include "target.h"
|
#include "target.h"
|
#include <sys/ptrace.h>
|
#include <sys/ptrace.h>
|
#include "gdbcore.h"
|
#include "gdbcore.h"
|
#include "gdb_wait.h"
|
#include "gdb_wait.h"
|
#include <signal.h>
|
#include <signal.h>
|
|
|
extern CORE_ADDR text_end;
|
extern CORE_ADDR text_end;
|
|
|
static void fetch_register PARAMS ((int));
|
static void fetch_register PARAMS ((int));
|
|
|
void
|
void
|
fetch_inferior_registers (regno)
|
fetch_inferior_registers (regno)
|
int regno;
|
int regno;
|
{
|
{
|
if (regno == -1)
|
if (regno == -1)
|
for (regno = 0; regno < NUM_REGS; regno++)
|
for (regno = 0; regno < NUM_REGS; regno++)
|
fetch_register (regno);
|
fetch_register (regno);
|
else
|
else
|
fetch_register (regno);
|
fetch_register (regno);
|
}
|
}
|
|
|
/* Our own version of the offsetof macro, since we can't assume ANSI C. */
|
/* Our own version of the offsetof macro, since we can't assume ANSI C. */
|
#define HPPAH_OFFSETOF(type, member) ((int) (&((type *) 0)->member))
|
#define HPPAH_OFFSETOF(type, member) ((int) (&((type *) 0)->member))
|
|
|
/* Store our register values back into the inferior.
|
/* Store our register values back into the inferior.
|
If REGNO is -1, do this for all registers.
|
If REGNO is -1, do this for all registers.
|
Otherwise, REGNO specifies which register (so we can save time). */
|
Otherwise, REGNO specifies which register (so we can save time). */
|
|
|
void
|
void
|
store_inferior_registers (regno)
|
store_inferior_registers (regno)
|
int regno;
|
int regno;
|
{
|
{
|
register unsigned int regaddr;
|
register unsigned int regaddr;
|
char buf[80];
|
char buf[80];
|
register int i;
|
register int i;
|
unsigned int offset = U_REGS_OFFSET;
|
unsigned int offset = U_REGS_OFFSET;
|
int scratch;
|
int scratch;
|
|
|
if (regno >= 0)
|
if (regno >= 0)
|
{
|
{
|
unsigned int addr, len, offset;
|
unsigned int addr, len, offset;
|
|
|
if (CANNOT_STORE_REGISTER (regno))
|
if (CANNOT_STORE_REGISTER (regno))
|
return;
|
return;
|
|
|
offset = 0;
|
offset = 0;
|
len = REGISTER_RAW_SIZE (regno);
|
len = REGISTER_RAW_SIZE (regno);
|
|
|
/* Requests for register zero actually want the save_state's
|
/* Requests for register zero actually want the save_state's
|
ss_flags member. As RM says: "Oh, what a hack!" */
|
ss_flags member. As RM says: "Oh, what a hack!" */
|
if (regno == 0)
|
if (regno == 0)
|
{
|
{
|
save_state_t ss;
|
save_state_t ss;
|
addr = HPPAH_OFFSETOF (save_state_t, ss_flags);
|
addr = HPPAH_OFFSETOF (save_state_t, ss_flags);
|
len = sizeof (ss.ss_flags);
|
len = sizeof (ss.ss_flags);
|
|
|
/* Note that ss_flags is always an int, no matter what
|
/* Note that ss_flags is always an int, no matter what
|
REGISTER_RAW_SIZE(0) says. Assuming all HP-UX PA machines
|
REGISTER_RAW_SIZE(0) says. Assuming all HP-UX PA machines
|
are big-endian, put it at the least significant end of the
|
are big-endian, put it at the least significant end of the
|
value, and zap the rest of the buffer. */
|
value, and zap the rest of the buffer. */
|
offset = REGISTER_RAW_SIZE (0) - len;
|
offset = REGISTER_RAW_SIZE (0) - len;
|
}
|
}
|
|
|
/* Floating-point registers come from the ss_fpblock area. */
|
/* Floating-point registers come from the ss_fpblock area. */
|
else if (regno >= FP0_REGNUM)
|
else if (regno >= FP0_REGNUM)
|
addr = (HPPAH_OFFSETOF (save_state_t, ss_fpblock)
|
addr = (HPPAH_OFFSETOF (save_state_t, ss_fpblock)
|
+ (REGISTER_BYTE (regno) - REGISTER_BYTE (FP0_REGNUM)));
|
+ (REGISTER_BYTE (regno) - REGISTER_BYTE (FP0_REGNUM)));
|
|
|
/* Wide registers come from the ss_wide area.
|
/* Wide registers come from the ss_wide area.
|
I think it's more PC to test (ss_flags & SS_WIDEREGS) to select
|
I think it's more PC to test (ss_flags & SS_WIDEREGS) to select
|
between ss_wide and ss_narrow than to use the raw register size.
|
between ss_wide and ss_narrow than to use the raw register size.
|
But checking ss_flags would require an extra ptrace call for
|
But checking ss_flags would require an extra ptrace call for
|
every register reference. Bleah. */
|
every register reference. Bleah. */
|
else if (len == 8)
|
else if (len == 8)
|
addr = (HPPAH_OFFSETOF (save_state_t, ss_wide)
|
addr = (HPPAH_OFFSETOF (save_state_t, ss_wide)
|
+ REGISTER_BYTE (regno));
|
+ REGISTER_BYTE (regno));
|
|
|
/* Narrow registers come from the ss_narrow area. Note that
|
/* Narrow registers come from the ss_narrow area. Note that
|
ss_narrow starts with gr1, not gr0. */
|
ss_narrow starts with gr1, not gr0. */
|
else if (len == 4)
|
else if (len == 4)
|
addr = (HPPAH_OFFSETOF (save_state_t, ss_narrow)
|
addr = (HPPAH_OFFSETOF (save_state_t, ss_narrow)
|
+ (REGISTER_BYTE (regno) - REGISTER_BYTE (1)));
|
+ (REGISTER_BYTE (regno) - REGISTER_BYTE (1)));
|
else
|
else
|
internal_error ("hppah-nat.c (write_register): unexpected register size");
|
internal_error ("hppah-nat.c (write_register): unexpected register size");
|
|
|
#ifdef GDB_TARGET_IS_HPPA_20W
|
#ifdef GDB_TARGET_IS_HPPA_20W
|
/* Unbelieveable. The PC head and tail must be written in 64bit hunks
|
/* Unbelieveable. The PC head and tail must be written in 64bit hunks
|
or we will get an error. Worse yet, the oddball ptrace/ttrace
|
or we will get an error. Worse yet, the oddball ptrace/ttrace
|
layering will not allow us to perform a 64bit register store.
|
layering will not allow us to perform a 64bit register store.
|
|
|
What a crock. */
|
What a crock. */
|
if (regno == PCOQ_HEAD_REGNUM || regno == PCOQ_TAIL_REGNUM && len == 8)
|
if (regno == PCOQ_HEAD_REGNUM || regno == PCOQ_TAIL_REGNUM && len == 8)
|
{
|
{
|
CORE_ADDR temp;
|
CORE_ADDR temp;
|
|
|
temp = *(CORE_ADDR *)®isters[REGISTER_BYTE (regno)];
|
temp = *(CORE_ADDR *)®isters[REGISTER_BYTE (regno)];
|
|
|
/* Set the priv level (stored in the low two bits of the PC. */
|
/* Set the priv level (stored in the low two bits of the PC. */
|
temp |= 0x3;
|
temp |= 0x3;
|
|
|
ttrace_write_reg_64 (inferior_pid, (CORE_ADDR)addr, (CORE_ADDR)&temp);
|
ttrace_write_reg_64 (inferior_pid, (CORE_ADDR)addr, (CORE_ADDR)&temp);
|
|
|
/* If we fail to write the PC, give a true error instead of
|
/* If we fail to write the PC, give a true error instead of
|
just a warning. */
|
just a warning. */
|
if (errno != 0)
|
if (errno != 0)
|
{
|
{
|
char *err = safe_strerror (errno);
|
char *err = safe_strerror (errno);
|
char *msg = alloca (strlen (err) + 128);
|
char *msg = alloca (strlen (err) + 128);
|
sprintf (msg, "writing `%s' register: %s",
|
sprintf (msg, "writing `%s' register: %s",
|
REGISTER_NAME (regno), err);
|
REGISTER_NAME (regno), err);
|
perror_with_name (msg);
|
perror_with_name (msg);
|
}
|
}
|
return;
|
return;
|
}
|
}
|
|
|
/* Another crock. HPUX complains if you write a nonzero value to
|
/* Another crock. HPUX complains if you write a nonzero value to
|
the high part of IPSW. What will it take for HP to catch a
|
the high part of IPSW. What will it take for HP to catch a
|
clue about building sensible interfaces? */
|
clue about building sensible interfaces? */
|
if (regno == IPSW_REGNUM && len == 8)
|
if (regno == IPSW_REGNUM && len == 8)
|
*(int *)®isters[REGISTER_BYTE (regno)] = 0;
|
*(int *)®isters[REGISTER_BYTE (regno)] = 0;
|
#endif
|
#endif
|
|
|
for (i = 0; i < len; i += sizeof (int))
|
for (i = 0; i < len; i += sizeof (int))
|
{
|
{
|
errno = 0;
|
errno = 0;
|
call_ptrace (PT_WUREGS, inferior_pid, (PTRACE_ARG3_TYPE) addr + i,
|
call_ptrace (PT_WUREGS, inferior_pid, (PTRACE_ARG3_TYPE) addr + i,
|
*(int *) ®isters[REGISTER_BYTE (regno) + i]);
|
*(int *) ®isters[REGISTER_BYTE (regno) + i]);
|
if (errno != 0)
|
if (errno != 0)
|
{
|
{
|
/* Warning, not error, in case we are attached; sometimes
|
/* Warning, not error, in case we are attached; sometimes
|
the kernel doesn't let us at the registers. */
|
the kernel doesn't let us at the registers. */
|
char *err = safe_strerror (errno);
|
char *err = safe_strerror (errno);
|
char *msg = alloca (strlen (err) + 128);
|
char *msg = alloca (strlen (err) + 128);
|
sprintf (msg, "writing `%s' register: %s",
|
sprintf (msg, "writing `%s' register: %s",
|
REGISTER_NAME (regno), err);
|
REGISTER_NAME (regno), err);
|
/* If we fail to write the PC, give a true error instead of
|
/* If we fail to write the PC, give a true error instead of
|
just a warning. */
|
just a warning. */
|
if (regno == PCOQ_HEAD_REGNUM || regno == PCOQ_TAIL_REGNUM)
|
if (regno == PCOQ_HEAD_REGNUM || regno == PCOQ_TAIL_REGNUM)
|
perror_with_name (msg);
|
perror_with_name (msg);
|
else
|
else
|
warning (msg);
|
warning (msg);
|
return;
|
return;
|
}
|
}
|
}
|
}
|
}
|
}
|
else
|
else
|
for (regno = 0; regno < NUM_REGS; regno++)
|
for (regno = 0; regno < NUM_REGS; regno++)
|
store_inferior_registers (regno);
|
store_inferior_registers (regno);
|
}
|
}
|
|
|
|
|
/* Fetch a register's value from the process's U area. */
|
/* Fetch a register's value from the process's U area. */
|
static void
|
static void
|
fetch_register (regno)
|
fetch_register (regno)
|
int regno;
|
int regno;
|
{
|
{
|
char buf[MAX_REGISTER_RAW_SIZE];
|
char buf[MAX_REGISTER_RAW_SIZE];
|
unsigned int addr, len, offset;
|
unsigned int addr, len, offset;
|
int i;
|
int i;
|
|
|
offset = 0;
|
offset = 0;
|
len = REGISTER_RAW_SIZE (regno);
|
len = REGISTER_RAW_SIZE (regno);
|
|
|
/* Requests for register zero actually want the save_state's
|
/* Requests for register zero actually want the save_state's
|
ss_flags member. As RM says: "Oh, what a hack!" */
|
ss_flags member. As RM says: "Oh, what a hack!" */
|
if (regno == 0)
|
if (regno == 0)
|
{
|
{
|
save_state_t ss;
|
save_state_t ss;
|
addr = HPPAH_OFFSETOF (save_state_t, ss_flags);
|
addr = HPPAH_OFFSETOF (save_state_t, ss_flags);
|
len = sizeof (ss.ss_flags);
|
len = sizeof (ss.ss_flags);
|
|
|
/* Note that ss_flags is always an int, no matter what
|
/* Note that ss_flags is always an int, no matter what
|
REGISTER_RAW_SIZE(0) says. Assuming all HP-UX PA machines
|
REGISTER_RAW_SIZE(0) says. Assuming all HP-UX PA machines
|
are big-endian, put it at the least significant end of the
|
are big-endian, put it at the least significant end of the
|
value, and zap the rest of the buffer. */
|
value, and zap the rest of the buffer. */
|
offset = REGISTER_RAW_SIZE (0) - len;
|
offset = REGISTER_RAW_SIZE (0) - len;
|
memset (buf, 0, sizeof (buf));
|
memset (buf, 0, sizeof (buf));
|
}
|
}
|
|
|
/* Floating-point registers come from the ss_fpblock area. */
|
/* Floating-point registers come from the ss_fpblock area. */
|
else if (regno >= FP0_REGNUM)
|
else if (regno >= FP0_REGNUM)
|
addr = (HPPAH_OFFSETOF (save_state_t, ss_fpblock)
|
addr = (HPPAH_OFFSETOF (save_state_t, ss_fpblock)
|
+ (REGISTER_BYTE (regno) - REGISTER_BYTE (FP0_REGNUM)));
|
+ (REGISTER_BYTE (regno) - REGISTER_BYTE (FP0_REGNUM)));
|
|
|
/* Wide registers come from the ss_wide area.
|
/* Wide registers come from the ss_wide area.
|
I think it's more PC to test (ss_flags & SS_WIDEREGS) to select
|
I think it's more PC to test (ss_flags & SS_WIDEREGS) to select
|
between ss_wide and ss_narrow than to use the raw register size.
|
between ss_wide and ss_narrow than to use the raw register size.
|
But checking ss_flags would require an extra ptrace call for
|
But checking ss_flags would require an extra ptrace call for
|
every register reference. Bleah. */
|
every register reference. Bleah. */
|
else if (len == 8)
|
else if (len == 8)
|
addr = (HPPAH_OFFSETOF (save_state_t, ss_wide)
|
addr = (HPPAH_OFFSETOF (save_state_t, ss_wide)
|
+ REGISTER_BYTE (regno));
|
+ REGISTER_BYTE (regno));
|
|
|
/* Narrow registers come from the ss_narrow area. Note that
|
/* Narrow registers come from the ss_narrow area. Note that
|
ss_narrow starts with gr1, not gr0. */
|
ss_narrow starts with gr1, not gr0. */
|
else if (len == 4)
|
else if (len == 4)
|
addr = (HPPAH_OFFSETOF (save_state_t, ss_narrow)
|
addr = (HPPAH_OFFSETOF (save_state_t, ss_narrow)
|
+ (REGISTER_BYTE (regno) - REGISTER_BYTE (1)));
|
+ (REGISTER_BYTE (regno) - REGISTER_BYTE (1)));
|
|
|
else
|
else
|
internal_error ("hppa-nat.c (fetch_register): unexpected register size");
|
internal_error ("hppa-nat.c (fetch_register): unexpected register size");
|
|
|
for (i = 0; i < len; i += sizeof (int))
|
for (i = 0; i < len; i += sizeof (int))
|
{
|
{
|
errno = 0;
|
errno = 0;
|
/* Copy an int from the U area to buf. Fill the least
|
/* Copy an int from the U area to buf. Fill the least
|
significant end if len != raw_size. */
|
significant end if len != raw_size. */
|
* (int *) &buf[offset + i] =
|
* (int *) &buf[offset + i] =
|
call_ptrace (PT_RUREGS, inferior_pid,
|
call_ptrace (PT_RUREGS, inferior_pid,
|
(PTRACE_ARG3_TYPE) addr + i, 0);
|
(PTRACE_ARG3_TYPE) addr + i, 0);
|
if (errno != 0)
|
if (errno != 0)
|
{
|
{
|
/* Warning, not error, in case we are attached; sometimes
|
/* Warning, not error, in case we are attached; sometimes
|
the kernel doesn't let us at the registers. */
|
the kernel doesn't let us at the registers. */
|
char *err = safe_strerror (errno);
|
char *err = safe_strerror (errno);
|
char *msg = alloca (strlen (err) + 128);
|
char *msg = alloca (strlen (err) + 128);
|
sprintf (msg, "reading `%s' register: %s",
|
sprintf (msg, "reading `%s' register: %s",
|
REGISTER_NAME (regno), err);
|
REGISTER_NAME (regno), err);
|
warning (msg);
|
warning (msg);
|
return;
|
return;
|
}
|
}
|
}
|
}
|
|
|
/* If we're reading an address from the instruction address queue,
|
/* If we're reading an address from the instruction address queue,
|
mask out the bottom two bits --- they contain the privilege
|
mask out the bottom two bits --- they contain the privilege
|
level. */
|
level. */
|
if (regno == PCOQ_HEAD_REGNUM || regno == PCOQ_TAIL_REGNUM)
|
if (regno == PCOQ_HEAD_REGNUM || regno == PCOQ_TAIL_REGNUM)
|
buf[len - 1] &= ~0x3;
|
buf[len - 1] &= ~0x3;
|
|
|
supply_register (regno, buf);
|
supply_register (regno, buf);
|
}
|
}
|
|
|
|
|
/* Copy LEN bytes to or from inferior's memory starting at MEMADDR
|
/* Copy LEN bytes to or from inferior's memory starting at MEMADDR
|
to debugger memory starting at MYADDR. Copy to inferior if
|
to debugger memory starting at MYADDR. Copy to inferior if
|
WRITE is nonzero.
|
WRITE is nonzero.
|
|
|
Returns the length copied, which is either the LEN argument or zero.
|
Returns the length copied, which is either the LEN argument or zero.
|
This xfer function does not do partial moves, since child_ops
|
This xfer function does not do partial moves, since child_ops
|
doesn't allow memory operations to cross below us in the target stack
|
doesn't allow memory operations to cross below us in the target stack
|
anyway. */
|
anyway. */
|
|
|
int
|
int
|
child_xfer_memory (memaddr, myaddr, len, write, target)
|
child_xfer_memory (memaddr, myaddr, len, write, target)
|
CORE_ADDR memaddr;
|
CORE_ADDR memaddr;
|
char *myaddr;
|
char *myaddr;
|
int len;
|
int len;
|
int write;
|
int write;
|
struct target_ops *target; /* ignored */
|
struct target_ops *target; /* ignored */
|
{
|
{
|
register int i;
|
register int i;
|
/* Round starting address down to longword boundary. */
|
/* Round starting address down to longword boundary. */
|
register CORE_ADDR addr = memaddr & - (CORE_ADDR)(sizeof (int));
|
register CORE_ADDR addr = memaddr & - (CORE_ADDR)(sizeof (int));
|
/* Round ending address up; get number of longwords that makes. */
|
/* Round ending address up; get number of longwords that makes. */
|
register int count
|
register int count
|
= (((memaddr + len) - addr) + sizeof (int) - 1) / sizeof (int);
|
= (((memaddr + len) - addr) + sizeof (int) - 1) / sizeof (int);
|
|
|
/* Allocate buffer of that many longwords.
|
/* Allocate buffer of that many longwords.
|
Note -- do not use alloca to allocate this buffer since there is no
|
Note -- do not use alloca to allocate this buffer since there is no
|
guarantee of when the buffer will actually be deallocated.
|
guarantee of when the buffer will actually be deallocated.
|
|
|
This routine can be called over and over with the same call chain;
|
This routine can be called over and over with the same call chain;
|
this (in effect) would pile up all those alloca requests until a call
|
this (in effect) would pile up all those alloca requests until a call
|
to alloca was made from a point higher than this routine in the
|
to alloca was made from a point higher than this routine in the
|
call chain. */
|
call chain. */
|
register int *buffer = (int *) xmalloc (count * sizeof (int));
|
register int *buffer = (int *) xmalloc (count * sizeof (int));
|
|
|
if (write)
|
if (write)
|
{
|
{
|
/* Fill start and end extra bytes of buffer with existing memory data. */
|
/* Fill start and end extra bytes of buffer with existing memory data. */
|
if (addr != memaddr || len < (int) sizeof (int))
|
if (addr != memaddr || len < (int) sizeof (int))
|
{
|
{
|
/* Need part of initial word -- fetch it. */
|
/* Need part of initial word -- fetch it. */
|
buffer[0] = call_ptrace (addr < text_end ? PT_RIUSER : PT_RDUSER,
|
buffer[0] = call_ptrace (addr < text_end ? PT_RIUSER : PT_RDUSER,
|
inferior_pid, (PTRACE_ARG3_TYPE) addr, 0);
|
inferior_pid, (PTRACE_ARG3_TYPE) addr, 0);
|
}
|
}
|
|
|
if (count > 1) /* FIXME, avoid if even boundary */
|
if (count > 1) /* FIXME, avoid if even boundary */
|
{
|
{
|
buffer[count - 1]
|
buffer[count - 1]
|
= call_ptrace (addr < text_end ? PT_RIUSER : PT_RDUSER,
|
= call_ptrace (addr < text_end ? PT_RIUSER : PT_RDUSER,
|
inferior_pid,
|
inferior_pid,
|
(PTRACE_ARG3_TYPE) (addr
|
(PTRACE_ARG3_TYPE) (addr
|
+ (count - 1) * sizeof (int)),
|
+ (count - 1) * sizeof (int)),
|
0);
|
0);
|
}
|
}
|
|
|
/* Copy data to be written over corresponding part of buffer */
|
/* Copy data to be written over corresponding part of buffer */
|
memcpy ((char *) buffer + (memaddr & (sizeof (int) - 1)), myaddr, len);
|
memcpy ((char *) buffer + (memaddr & (sizeof (int) - 1)), myaddr, len);
|
|
|
/* Write the entire buffer. */
|
/* Write the entire buffer. */
|
for (i = 0; i < count; i++, addr += sizeof (int))
|
for (i = 0; i < count; i++, addr += sizeof (int))
|
{
|
{
|
int pt_status;
|
int pt_status;
|
int pt_request;
|
int pt_request;
|
/* The HP-UX kernel crashes if you use PT_WDUSER to write into the
|
/* 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
|
text segment. FIXME -- does it work to write into the data
|
segment using WIUSER, or do these idiots really expect us to
|
segment using WIUSER, or do these idiots really expect us to
|
figure out which segment the address is in, so we can use a
|
figure out which segment the address is in, so we can use a
|
separate system call for it??! */
|
separate system call for it??! */
|
errno = 0;
|
errno = 0;
|
pt_request = (addr < text_end) ? PT_WIUSER : PT_WDUSER;
|
pt_request = (addr < text_end) ? PT_WIUSER : PT_WDUSER;
|
pt_status = call_ptrace (pt_request,
|
pt_status = call_ptrace (pt_request,
|
inferior_pid,
|
inferior_pid,
|
(PTRACE_ARG3_TYPE) addr,
|
(PTRACE_ARG3_TYPE) addr,
|
buffer[i]);
|
buffer[i]);
|
|
|
/* Did we fail? Might we've guessed wrong about which
|
/* Did we fail? Might we've guessed wrong about which
|
segment this address resides in? Try the other request,
|
segment this address resides in? Try the other request,
|
and see if that works... */
|
and see if that works... */
|
if ((pt_status == -1) && errno)
|
if ((pt_status == -1) && errno)
|
{
|
{
|
errno = 0;
|
errno = 0;
|
pt_request = (pt_request == PT_WIUSER) ? PT_WDUSER : PT_WIUSER;
|
pt_request = (pt_request == PT_WIUSER) ? PT_WDUSER : PT_WIUSER;
|
pt_status = call_ptrace (pt_request,
|
pt_status = call_ptrace (pt_request,
|
inferior_pid,
|
inferior_pid,
|
(PTRACE_ARG3_TYPE) addr,
|
(PTRACE_ARG3_TYPE) addr,
|
buffer[i]);
|
buffer[i]);
|
|
|
/* No, we still fail. Okay, time to punt. */
|
/* No, we still fail. Okay, time to punt. */
|
if ((pt_status == -1) && errno)
|
if ((pt_status == -1) && errno)
|
{
|
{
|
free (buffer);
|
free (buffer);
|
return 0;
|
return 0;
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
else
|
else
|
{
|
{
|
/* Read all the longwords */
|
/* Read all the longwords */
|
for (i = 0; i < count; i++, addr += sizeof (int))
|
for (i = 0; i < count; i++, addr += sizeof (int))
|
{
|
{
|
errno = 0;
|
errno = 0;
|
buffer[i] = call_ptrace (addr < text_end ? PT_RIUSER : PT_RDUSER,
|
buffer[i] = call_ptrace (addr < text_end ? PT_RIUSER : PT_RDUSER,
|
inferior_pid, (PTRACE_ARG3_TYPE) addr, 0);
|
inferior_pid, (PTRACE_ARG3_TYPE) addr, 0);
|
if (errno)
|
if (errno)
|
{
|
{
|
free (buffer);
|
free (buffer);
|
return 0;
|
return 0;
|
}
|
}
|
QUIT;
|
QUIT;
|
}
|
}
|
|
|
/* Copy appropriate bytes out of the buffer. */
|
/* Copy appropriate bytes out of the buffer. */
|
memcpy (myaddr, (char *) buffer + (memaddr & (sizeof (int) - 1)), len);
|
memcpy (myaddr, (char *) buffer + (memaddr & (sizeof (int) - 1)), len);
|
}
|
}
|
free (buffer);
|
free (buffer);
|
return len;
|
return len;
|
}
|
}
|
|
|
|
|
void
|
void
|
child_post_follow_inferior_by_clone ()
|
child_post_follow_inferior_by_clone ()
|
{
|
{
|
int status;
|
int status;
|
|
|
/* This function is used when following both the parent and child
|
/* This function is used when following both the parent and child
|
of a fork. In this case, the debugger clones itself. The original
|
of a fork. In this case, the debugger clones itself. The original
|
debugger follows the parent, the clone follows the child. The
|
debugger follows the parent, the clone follows the child. The
|
original detaches from the child, delivering a SIGSTOP to it to
|
original detaches from the child, delivering a SIGSTOP to it to
|
keep it from running away until the clone can attach itself.
|
keep it from running away until the clone can attach itself.
|
|
|
At this point, the clone has attached to the child. Because of
|
At this point, the clone has attached to the child. Because of
|
the SIGSTOP, we must now deliver a SIGCONT to the child, or it
|
the SIGSTOP, we must now deliver a SIGCONT to the child, or it
|
won't behave properly. */
|
won't behave properly. */
|
status = kill (inferior_pid, SIGCONT);
|
status = kill (inferior_pid, SIGCONT);
|
}
|
}
|
|
|
|
|
void
|
void
|
child_post_follow_vfork (parent_pid, followed_parent, child_pid, followed_child)
|
child_post_follow_vfork (parent_pid, followed_parent, child_pid, followed_child)
|
int parent_pid;
|
int parent_pid;
|
int followed_parent;
|
int followed_parent;
|
int child_pid;
|
int child_pid;
|
int followed_child;
|
int followed_child;
|
{
|
{
|
/* Are we a debugger that followed the parent of a vfork? If so,
|
/* Are we a debugger that followed the parent of a vfork? If so,
|
then recall that the child's vfork event was delivered to us
|
then recall that the child's vfork event was delivered to us
|
first. And, that the parent was suspended by the OS until the
|
first. And, that the parent was suspended by the OS until the
|
child's exec or exit events were received.
|
child's exec or exit events were received.
|
|
|
Upon receiving that child vfork, then, we were forced to remove
|
Upon receiving that child vfork, then, we were forced to remove
|
all breakpoints in the child and continue it so that it could
|
all breakpoints in the child and continue it so that it could
|
reach the exec or exit point.
|
reach the exec or exit point.
|
|
|
But also recall that the parent and child of a vfork share the
|
But also recall that the parent and child of a vfork share the
|
same address space. Thus, removing bp's in the child also
|
same address space. Thus, removing bp's in the child also
|
removed them from the parent.
|
removed them from the parent.
|
|
|
Now that the child has safely exec'd or exited, we must restore
|
Now that the child has safely exec'd or exited, we must restore
|
the parent's breakpoints before we continue it. Else, we may
|
the parent's breakpoints before we continue it. Else, we may
|
cause it run past expected stopping points. */
|
cause it run past expected stopping points. */
|
if (followed_parent)
|
if (followed_parent)
|
{
|
{
|
reattach_breakpoints (parent_pid);
|
reattach_breakpoints (parent_pid);
|
}
|
}
|
|
|
/* Are we a debugger that followed the child of a vfork? If so,
|
/* Are we a debugger that followed the child of a vfork? If so,
|
then recall that we don't actually acquire control of the child
|
then recall that we don't actually acquire control of the child
|
until after it has exec'd or exited. */
|
until after it has exec'd or exited. */
|
if (followed_child)
|
if (followed_child)
|
{
|
{
|
/* If the child has exited, then there's nothing for us to do.
|
/* If the child has exited, then there's nothing for us to do.
|
In the case of an exec event, we'll let that be handled by
|
In the case of an exec event, we'll let that be handled by
|
the normal mechanism that notices and handles exec events, in
|
the normal mechanism that notices and handles exec events, in
|
resume(). */
|
resume(). */
|
}
|
}
|
}
|
}
|
|
|
/* Format a process id, given PID. Be sure to terminate
|
/* Format a process id, given PID. Be sure to terminate
|
this with a null--it's going to be printed via a "%s". */
|
this with a null--it's going to be printed via a "%s". */
|
char *
|
char *
|
child_pid_to_str (pid)
|
child_pid_to_str (pid)
|
pid_t pid;
|
pid_t pid;
|
{
|
{
|
/* Static because address returned */
|
/* Static because address returned */
|
static char buf[30];
|
static char buf[30];
|
|
|
/* Extra NULLs for paranoia's sake */
|
/* Extra NULLs for paranoia's sake */
|
sprintf (buf, "process %d\0\0\0\0", pid);
|
sprintf (buf, "process %d\0\0\0\0", pid);
|
|
|
return buf;
|
return buf;
|
}
|
}
|
|
|
/* Format a thread id, given TID. Be sure to terminate
|
/* Format a thread id, given TID. Be sure to terminate
|
this with a null--it's going to be printed via a "%s".
|
this with a null--it's going to be printed via a "%s".
|
|
|
Note: This is a core-gdb tid, not the actual system tid.
|
Note: This is a core-gdb tid, not the actual system tid.
|
See infttrace.c for details. */
|
See infttrace.c for details. */
|
char *
|
char *
|
hppa_tid_to_str (tid)
|
hppa_tid_to_str (tid)
|
pid_t tid;
|
pid_t tid;
|
{
|
{
|
/* Static because address returned */
|
/* Static because address returned */
|
static char buf[30];
|
static char buf[30];
|
|
|
/* Extra NULLs for paranoia's sake */
|
/* Extra NULLs for paranoia's sake */
|
sprintf (buf, "system thread %d\0\0\0\0", tid);
|
sprintf (buf, "system thread %d\0\0\0\0", tid);
|
|
|
return buf;
|
return buf;
|
}
|
}
|
|
|
#if !defined (GDB_NATIVE_HPUX_11)
|
#if !defined (GDB_NATIVE_HPUX_11)
|
|
|
/* The following code is a substitute for the infttrace.c versions used
|
/* The following code is a substitute for the infttrace.c versions used
|
with ttrace() in HPUX 11. */
|
with ttrace() in HPUX 11. */
|
|
|
/* This value is an arbitrary integer. */
|
/* This value is an arbitrary integer. */
|
#define PT_VERSION 123456
|
#define PT_VERSION 123456
|
|
|
/* This semaphore is used to coordinate the child and parent processes
|
/* This semaphore is used to coordinate the child and parent processes
|
after a fork(), and before an exec() by the child. See
|
after a fork(), and before an exec() by the child. See
|
parent_attach_all for details. */
|
parent_attach_all for details. */
|
|
|
typedef struct
|
typedef struct
|
{
|
{
|
int parent_channel[2]; /* Parent "talks" to [1], child "listens" to [0] */
|
int parent_channel[2]; /* Parent "talks" to [1], child "listens" to [0] */
|
int child_channel[2]; /* Child "talks" to [1], parent "listens" to [0] */
|
int child_channel[2]; /* Child "talks" to [1], parent "listens" to [0] */
|
}
|
}
|
startup_semaphore_t;
|
startup_semaphore_t;
|
|
|
#define SEM_TALK (1)
|
#define SEM_TALK (1)
|
#define SEM_LISTEN (0)
|
#define SEM_LISTEN (0)
|
|
|
static startup_semaphore_t startup_semaphore;
|
static startup_semaphore_t startup_semaphore;
|
|
|
extern int parent_attach_all PARAMS ((int, PTRACE_ARG3_TYPE, int));
|
extern int parent_attach_all PARAMS ((int, PTRACE_ARG3_TYPE, int));
|
|
|
#ifdef PT_SETTRC
|
#ifdef PT_SETTRC
|
/* This function causes the caller's process to be traced by its
|
/* This function causes the caller's process to be traced by its
|
parent. This is intended to be called after GDB forks itself,
|
parent. This is intended to be called after GDB forks itself,
|
and before the child execs the target.
|
and before the child execs the target.
|
|
|
Note that HP-UX ptrace is rather funky in how this is done.
|
Note that HP-UX ptrace is rather funky in how this is done.
|
If the parent wants to get the initial exec event of a child,
|
If the parent wants to get the initial exec event of a child,
|
it must set the ptrace event mask of the child to include execs.
|
it must set the ptrace event mask of the child to include execs.
|
(The child cannot do this itself.) This must be done after the
|
(The child cannot do this itself.) This must be done after the
|
child is forked, but before it execs.
|
child is forked, but before it execs.
|
|
|
To coordinate the parent and child, we implement a semaphore using
|
To coordinate the parent and child, we implement a semaphore using
|
pipes. After SETTRC'ing itself, the child tells the parent that
|
pipes. After SETTRC'ing itself, the child tells the parent that
|
it is now traceable by the parent, and waits for the parent's
|
it is now traceable by the parent, and waits for the parent's
|
acknowledgement. The parent can then set the child's event mask,
|
acknowledgement. The parent can then set the child's event mask,
|
and notify the child that it can now exec.
|
and notify the child that it can now exec.
|
|
|
(The acknowledgement by parent happens as a result of a call to
|
(The acknowledgement by parent happens as a result of a call to
|
child_acknowledge_created_inferior.) */
|
child_acknowledge_created_inferior.) */
|
|
|
int
|
int
|
parent_attach_all (pid, addr, data)
|
parent_attach_all (pid, addr, data)
|
int pid;
|
int pid;
|
PTRACE_ARG3_TYPE addr;
|
PTRACE_ARG3_TYPE addr;
|
int data;
|
int data;
|
{
|
{
|
int pt_status = 0;
|
int pt_status = 0;
|
|
|
/* We need a memory home for a constant. */
|
/* We need a memory home for a constant. */
|
int tc_magic_child = PT_VERSION;
|
int tc_magic_child = PT_VERSION;
|
int tc_magic_parent = 0;
|
int tc_magic_parent = 0;
|
|
|
/* The remainder of this function is only useful for HPUX 10.0 and
|
/* The remainder of this function is only useful for HPUX 10.0 and
|
later, as it depends upon the ability to request notification
|
later, as it depends upon the ability to request notification
|
of specific kinds of events by the kernel. */
|
of specific kinds of events by the kernel. */
|
#if defined(PT_SET_EVENT_MASK)
|
#if defined(PT_SET_EVENT_MASK)
|
|
|
/* Notify the parent that we're potentially ready to exec(). */
|
/* Notify the parent that we're potentially ready to exec(). */
|
write (startup_semaphore.child_channel[SEM_TALK],
|
write (startup_semaphore.child_channel[SEM_TALK],
|
&tc_magic_child,
|
&tc_magic_child,
|
sizeof (tc_magic_child));
|
sizeof (tc_magic_child));
|
|
|
/* Wait for acknowledgement from the parent. */
|
/* Wait for acknowledgement from the parent. */
|
read (startup_semaphore.parent_channel[SEM_LISTEN],
|
read (startup_semaphore.parent_channel[SEM_LISTEN],
|
&tc_magic_parent,
|
&tc_magic_parent,
|
sizeof (tc_magic_parent));
|
sizeof (tc_magic_parent));
|
if (tc_magic_child != tc_magic_parent)
|
if (tc_magic_child != tc_magic_parent)
|
warning ("mismatched semaphore magic");
|
warning ("mismatched semaphore magic");
|
|
|
/* Discard our copy of the semaphore. */
|
/* Discard our copy of the semaphore. */
|
(void) close (startup_semaphore.parent_channel[SEM_LISTEN]);
|
(void) close (startup_semaphore.parent_channel[SEM_LISTEN]);
|
(void) close (startup_semaphore.parent_channel[SEM_TALK]);
|
(void) close (startup_semaphore.parent_channel[SEM_TALK]);
|
(void) close (startup_semaphore.child_channel[SEM_LISTEN]);
|
(void) close (startup_semaphore.child_channel[SEM_LISTEN]);
|
(void) close (startup_semaphore.child_channel[SEM_TALK]);
|
(void) close (startup_semaphore.child_channel[SEM_TALK]);
|
#endif
|
#endif
|
|
|
return 0;
|
return 0;
|
}
|
}
|
#endif
|
#endif
|
|
|
int
|
int
|
hppa_require_attach (pid)
|
hppa_require_attach (pid)
|
int pid;
|
int pid;
|
{
|
{
|
int pt_status;
|
int pt_status;
|
CORE_ADDR pc;
|
CORE_ADDR pc;
|
CORE_ADDR pc_addr;
|
CORE_ADDR pc_addr;
|
unsigned int regs_offset;
|
unsigned int regs_offset;
|
|
|
/* Are we already attached? There appears to be no explicit way to
|
/* Are we already attached? There appears to be no explicit way to
|
answer this via ptrace, so we try something which should be
|
answer this via ptrace, so we try something which should be
|
innocuous if we are attached. If that fails, then we assume
|
innocuous if we are attached. If that fails, then we assume
|
we're not attached, and so attempt to make it so. */
|
we're not attached, and so attempt to make it so. */
|
|
|
errno = 0;
|
errno = 0;
|
regs_offset = U_REGS_OFFSET;
|
regs_offset = U_REGS_OFFSET;
|
pc_addr = register_addr (PC_REGNUM, regs_offset);
|
pc_addr = register_addr (PC_REGNUM, regs_offset);
|
pc = call_ptrace (PT_READ_U, pid, (PTRACE_ARG3_TYPE) pc_addr, 0);
|
pc = call_ptrace (PT_READ_U, pid, (PTRACE_ARG3_TYPE) pc_addr, 0);
|
|
|
if (errno)
|
if (errno)
|
{
|
{
|
errno = 0;
|
errno = 0;
|
pt_status = call_ptrace (PT_ATTACH, pid, (PTRACE_ARG3_TYPE) 0, 0);
|
pt_status = call_ptrace (PT_ATTACH, pid, (PTRACE_ARG3_TYPE) 0, 0);
|
|
|
if (errno)
|
if (errno)
|
return -1;
|
return -1;
|
|
|
/* Now we really are attached. */
|
/* Now we really are attached. */
|
errno = 0;
|
errno = 0;
|
}
|
}
|
attach_flag = 1;
|
attach_flag = 1;
|
return pid;
|
return pid;
|
}
|
}
|
|
|
int
|
int
|
hppa_require_detach (pid, signal)
|
hppa_require_detach (pid, signal)
|
int pid;
|
int pid;
|
int signal;
|
int signal;
|
{
|
{
|
errno = 0;
|
errno = 0;
|
call_ptrace (PT_DETACH, pid, (PTRACE_ARG3_TYPE) 1, signal);
|
call_ptrace (PT_DETACH, pid, (PTRACE_ARG3_TYPE) 1, signal);
|
errno = 0; /* Ignore any errors. */
|
errno = 0; /* Ignore any errors. */
|
return pid;
|
return pid;
|
}
|
}
|
|
|
/* Since ptrace doesn't support memory page-protection events, which
|
/* Since ptrace doesn't support memory page-protection events, which
|
are used to implement "hardware" watchpoints on HP-UX, these are
|
are used to implement "hardware" watchpoints on HP-UX, these are
|
dummy versions, which perform no useful work. */
|
dummy versions, which perform no useful work. */
|
|
|
void
|
void
|
hppa_enable_page_protection_events (pid)
|
hppa_enable_page_protection_events (pid)
|
int pid;
|
int pid;
|
{
|
{
|
}
|
}
|
|
|
void
|
void
|
hppa_disable_page_protection_events (pid)
|
hppa_disable_page_protection_events (pid)
|
int pid;
|
int pid;
|
{
|
{
|
}
|
}
|
|
|
int
|
int
|
hppa_insert_hw_watchpoint (pid, start, len, type)
|
hppa_insert_hw_watchpoint (pid, start, len, type)
|
int pid;
|
int pid;
|
CORE_ADDR start;
|
CORE_ADDR start;
|
LONGEST len;
|
LONGEST len;
|
int type;
|
int type;
|
{
|
{
|
error ("Hardware watchpoints not implemented on this platform.");
|
error ("Hardware watchpoints not implemented on this platform.");
|
}
|
}
|
|
|
int
|
int
|
hppa_remove_hw_watchpoint (pid, start, len, type)
|
hppa_remove_hw_watchpoint (pid, start, len, type)
|
int pid;
|
int pid;
|
CORE_ADDR start;
|
CORE_ADDR start;
|
LONGEST len;
|
LONGEST len;
|
enum bptype type;
|
enum bptype type;
|
{
|
{
|
error ("Hardware watchpoints not implemented on this platform.");
|
error ("Hardware watchpoints not implemented on this platform.");
|
}
|
}
|
|
|
int
|
int
|
hppa_can_use_hw_watchpoint (type, cnt, ot)
|
hppa_can_use_hw_watchpoint (type, cnt, ot)
|
enum bptype type;
|
enum bptype type;
|
int cnt;
|
int cnt;
|
enum bptype ot;
|
enum bptype ot;
|
{
|
{
|
return 0;
|
return 0;
|
}
|
}
|
|
|
int
|
int
|
hppa_range_profitable_for_hw_watchpoint (pid, start, len)
|
hppa_range_profitable_for_hw_watchpoint (pid, start, len)
|
int pid;
|
int pid;
|
CORE_ADDR start;
|
CORE_ADDR start;
|
LONGEST len;
|
LONGEST len;
|
{
|
{
|
error ("Hardware watchpoints not implemented on this platform.");
|
error ("Hardware watchpoints not implemented on this platform.");
|
}
|
}
|
|
|
char *
|
char *
|
hppa_pid_or_tid_to_str (id)
|
hppa_pid_or_tid_to_str (id)
|
pid_t id;
|
pid_t id;
|
{
|
{
|
/* In the ptrace world, there are only processes. */
|
/* In the ptrace world, there are only processes. */
|
return child_pid_to_str (id);
|
return child_pid_to_str (id);
|
}
|
}
|
|
|
/* This function has no meaning in a non-threaded world. Thus, we
|
/* This function has no meaning in a non-threaded world. Thus, we
|
return 0 (FALSE). See the use of "hppa_prepare_to_proceed" in
|
return 0 (FALSE). See the use of "hppa_prepare_to_proceed" in
|
hppa-tdep.c. */
|
hppa-tdep.c. */
|
|
|
pid_t
|
pid_t
|
hppa_switched_threads (pid)
|
hppa_switched_threads (pid)
|
pid_t pid;
|
pid_t pid;
|
{
|
{
|
return (pid_t) 0;
|
return (pid_t) 0;
|
}
|
}
|
|
|
void
|
void
|
hppa_ensure_vforking_parent_remains_stopped (pid)
|
hppa_ensure_vforking_parent_remains_stopped (pid)
|
int pid;
|
int pid;
|
{
|
{
|
/* This assumes that the vforked parent is presently stopped, and
|
/* This assumes that the vforked parent is presently stopped, and
|
that the vforked child has just delivered its first exec event.
|
that the vforked child has just delivered its first exec event.
|
Calling kill() this way will cause the SIGTRAP to be delivered as
|
Calling kill() this way will cause the SIGTRAP to be delivered as
|
soon as the parent is resumed, which happens as soon as the
|
soon as the parent is resumed, which happens as soon as the
|
vforked child is resumed. See wait_for_inferior for the use of
|
vforked child is resumed. See wait_for_inferior for the use of
|
this function. */
|
this function. */
|
kill (pid, SIGTRAP);
|
kill (pid, SIGTRAP);
|
}
|
}
|
|
|
int
|
int
|
hppa_resume_execd_vforking_child_to_get_parent_vfork ()
|
hppa_resume_execd_vforking_child_to_get_parent_vfork ()
|
{
|
{
|
return 1; /* Yes, the child must be resumed. */
|
return 1; /* Yes, the child must be resumed. */
|
}
|
}
|
|
|
void
|
void
|
require_notification_of_events (pid)
|
require_notification_of_events (pid)
|
int pid;
|
int pid;
|
{
|
{
|
#if defined(PT_SET_EVENT_MASK)
|
#if defined(PT_SET_EVENT_MASK)
|
int pt_status;
|
int pt_status;
|
ptrace_event_t ptrace_events;
|
ptrace_event_t ptrace_events;
|
int nsigs;
|
int nsigs;
|
int signum;
|
int signum;
|
|
|
/* Instruct the kernel as to the set of events we wish to be
|
/* Instruct the kernel as to the set of events we wish to be
|
informed of. (This support does not exist before HPUX 10.0.
|
informed of. (This support does not exist before HPUX 10.0.
|
We'll assume if PT_SET_EVENT_MASK has not been defined by
|
We'll assume if PT_SET_EVENT_MASK has not been defined by
|
<sys/ptrace.h>, then we're being built on pre-10.0.) */
|
<sys/ptrace.h>, then we're being built on pre-10.0.) */
|
memset (&ptrace_events, 0, sizeof (ptrace_events));
|
memset (&ptrace_events, 0, sizeof (ptrace_events));
|
|
|
/* Note: By default, all signals are visible to us. If we wish
|
/* Note: By default, all signals are visible to us. If we wish
|
the kernel to keep certain signals hidden from us, we do it
|
the kernel to keep certain signals hidden from us, we do it
|
by calling sigdelset (ptrace_events.pe_signals, signal) for
|
by calling sigdelset (ptrace_events.pe_signals, signal) for
|
each such signal here, before doing PT_SET_EVENT_MASK. */
|
each such signal here, before doing PT_SET_EVENT_MASK. */
|
/* RM: The above comment is no longer true. We start with ignoring
|
/* RM: The above comment is no longer true. We start with ignoring
|
all signals, and then add the ones we are interested in. We could
|
all signals, and then add the ones we are interested in. We could
|
do it the other way: start by looking at all signals and then
|
do it the other way: start by looking at all signals and then
|
deleting the ones that we aren't interested in, except that
|
deleting the ones that we aren't interested in, except that
|
multiple gdb signals may be mapped to the same host signal
|
multiple gdb signals may be mapped to the same host signal
|
(eg. TARGET_SIGNAL_IO and TARGET_SIGNAL_POLL both get mapped to
|
(eg. TARGET_SIGNAL_IO and TARGET_SIGNAL_POLL both get mapped to
|
signal 22 on HPUX 10.20) We want to be notified if we are
|
signal 22 on HPUX 10.20) We want to be notified if we are
|
interested in either signal. */
|
interested in either signal. */
|
sigfillset (&ptrace_events.pe_signals);
|
sigfillset (&ptrace_events.pe_signals);
|
|
|
/* RM: Let's not bother with signals we don't care about */
|
/* RM: Let's not bother with signals we don't care about */
|
nsigs = (int) TARGET_SIGNAL_LAST;
|
nsigs = (int) TARGET_SIGNAL_LAST;
|
for (signum = nsigs; signum > 0; signum--)
|
for (signum = nsigs; signum > 0; signum--)
|
{
|
{
|
if ((signal_stop_state (signum)) ||
|
if ((signal_stop_state (signum)) ||
|
(signal_print_state (signum)) ||
|
(signal_print_state (signum)) ||
|
(!signal_pass_state (signum)))
|
(!signal_pass_state (signum)))
|
{
|
{
|
if (target_signal_to_host_p (signum))
|
if (target_signal_to_host_p (signum))
|
sigdelset (&ptrace_events.pe_signals,
|
sigdelset (&ptrace_events.pe_signals,
|
target_signal_to_host (signum));
|
target_signal_to_host (signum));
|
}
|
}
|
}
|
}
|
|
|
ptrace_events.pe_set_event = 0;
|
ptrace_events.pe_set_event = 0;
|
|
|
ptrace_events.pe_set_event |= PTRACE_SIGNAL;
|
ptrace_events.pe_set_event |= PTRACE_SIGNAL;
|
ptrace_events.pe_set_event |= PTRACE_EXEC;
|
ptrace_events.pe_set_event |= PTRACE_EXEC;
|
ptrace_events.pe_set_event |= PTRACE_FORK;
|
ptrace_events.pe_set_event |= PTRACE_FORK;
|
ptrace_events.pe_set_event |= PTRACE_VFORK;
|
ptrace_events.pe_set_event |= PTRACE_VFORK;
|
/* ??rehrauer: Add this one when we're prepared to catch it...
|
/* ??rehrauer: Add this one when we're prepared to catch it...
|
ptrace_events.pe_set_event |= PTRACE_EXIT;
|
ptrace_events.pe_set_event |= PTRACE_EXIT;
|
*/
|
*/
|
|
|
errno = 0;
|
errno = 0;
|
pt_status = call_ptrace (PT_SET_EVENT_MASK,
|
pt_status = call_ptrace (PT_SET_EVENT_MASK,
|
pid,
|
pid,
|
(PTRACE_ARG3_TYPE) & ptrace_events,
|
(PTRACE_ARG3_TYPE) & ptrace_events,
|
sizeof (ptrace_events));
|
sizeof (ptrace_events));
|
if (errno)
|
if (errno)
|
perror_with_name ("ptrace");
|
perror_with_name ("ptrace");
|
if (pt_status < 0)
|
if (pt_status < 0)
|
return;
|
return;
|
#endif
|
#endif
|
}
|
}
|
|
|
void
|
void
|
require_notification_of_exec_events (pid)
|
require_notification_of_exec_events (pid)
|
int pid;
|
int pid;
|
{
|
{
|
#if defined(PT_SET_EVENT_MASK)
|
#if defined(PT_SET_EVENT_MASK)
|
int pt_status;
|
int pt_status;
|
ptrace_event_t ptrace_events;
|
ptrace_event_t ptrace_events;
|
|
|
/* Instruct the kernel as to the set of events we wish to be
|
/* Instruct the kernel as to the set of events we wish to be
|
informed of. (This support does not exist before HPUX 10.0.
|
informed of. (This support does not exist before HPUX 10.0.
|
We'll assume if PT_SET_EVENT_MASK has not been defined by
|
We'll assume if PT_SET_EVENT_MASK has not been defined by
|
<sys/ptrace.h>, then we're being built on pre-10.0.) */
|
<sys/ptrace.h>, then we're being built on pre-10.0.) */
|
memset (&ptrace_events, 0, sizeof (ptrace_events));
|
memset (&ptrace_events, 0, sizeof (ptrace_events));
|
|
|
/* Note: By default, all signals are visible to us. If we wish
|
/* Note: By default, all signals are visible to us. If we wish
|
the kernel to keep certain signals hidden from us, we do it
|
the kernel to keep certain signals hidden from us, we do it
|
by calling sigdelset (ptrace_events.pe_signals, signal) for
|
by calling sigdelset (ptrace_events.pe_signals, signal) for
|
each such signal here, before doing PT_SET_EVENT_MASK. */
|
each such signal here, before doing PT_SET_EVENT_MASK. */
|
sigemptyset (&ptrace_events.pe_signals);
|
sigemptyset (&ptrace_events.pe_signals);
|
|
|
ptrace_events.pe_set_event = 0;
|
ptrace_events.pe_set_event = 0;
|
|
|
ptrace_events.pe_set_event |= PTRACE_EXEC;
|
ptrace_events.pe_set_event |= PTRACE_EXEC;
|
/* ??rehrauer: Add this one when we're prepared to catch it...
|
/* ??rehrauer: Add this one when we're prepared to catch it...
|
ptrace_events.pe_set_event |= PTRACE_EXIT;
|
ptrace_events.pe_set_event |= PTRACE_EXIT;
|
*/
|
*/
|
|
|
errno = 0;
|
errno = 0;
|
pt_status = call_ptrace (PT_SET_EVENT_MASK,
|
pt_status = call_ptrace (PT_SET_EVENT_MASK,
|
pid,
|
pid,
|
(PTRACE_ARG3_TYPE) & ptrace_events,
|
(PTRACE_ARG3_TYPE) & ptrace_events,
|
sizeof (ptrace_events));
|
sizeof (ptrace_events));
|
if (errno)
|
if (errno)
|
perror_with_name ("ptrace");
|
perror_with_name ("ptrace");
|
if (pt_status < 0)
|
if (pt_status < 0)
|
return;
|
return;
|
#endif
|
#endif
|
}
|
}
|
|
|
/* This function is called by the parent process, with pid being the
|
/* This function is called by the parent process, with pid being the
|
ID of the child process, after the debugger has forked. */
|
ID of the child process, after the debugger has forked. */
|
|
|
void
|
void
|
child_acknowledge_created_inferior (pid)
|
child_acknowledge_created_inferior (pid)
|
int pid;
|
int pid;
|
{
|
{
|
/* We need a memory home for a constant. */
|
/* We need a memory home for a constant. */
|
int tc_magic_parent = PT_VERSION;
|
int tc_magic_parent = PT_VERSION;
|
int tc_magic_child = 0;
|
int tc_magic_child = 0;
|
|
|
/* The remainder of this function is only useful for HPUX 10.0 and
|
/* The remainder of this function is only useful for HPUX 10.0 and
|
later, as it depends upon the ability to request notification
|
later, as it depends upon the ability to request notification
|
of specific kinds of events by the kernel. */
|
of specific kinds of events by the kernel. */
|
#if defined(PT_SET_EVENT_MASK)
|
#if defined(PT_SET_EVENT_MASK)
|
/* Wait for the child to tell us that it has forked. */
|
/* Wait for the child to tell us that it has forked. */
|
read (startup_semaphore.child_channel[SEM_LISTEN],
|
read (startup_semaphore.child_channel[SEM_LISTEN],
|
&tc_magic_child,
|
&tc_magic_child,
|
sizeof (tc_magic_child));
|
sizeof (tc_magic_child));
|
|
|
/* Notify the child that it can exec.
|
/* Notify the child that it can exec.
|
|
|
In the infttrace.c variant of this function, we set the child's
|
In the infttrace.c variant of this function, we set the child's
|
event mask after the fork but before the exec. In the ptrace
|
event mask after the fork but before the exec. In the ptrace
|
world, it seems we can't set the event mask until after the exec. */
|
world, it seems we can't set the event mask until after the exec. */
|
write (startup_semaphore.parent_channel[SEM_TALK],
|
write (startup_semaphore.parent_channel[SEM_TALK],
|
&tc_magic_parent,
|
&tc_magic_parent,
|
sizeof (tc_magic_parent));
|
sizeof (tc_magic_parent));
|
|
|
/* We'd better pause a bit before trying to set the event mask,
|
/* We'd better pause a bit before trying to set the event mask,
|
though, to ensure that the exec has happened. We don't want to
|
though, to ensure that the exec has happened. We don't want to
|
wait() on the child, because that'll screw up the upper layers
|
wait() on the child, because that'll screw up the upper layers
|
of gdb's execution control that expect to see the exec event.
|
of gdb's execution control that expect to see the exec event.
|
|
|
After an exec, the child is no longer executing gdb code. Hence,
|
After an exec, the child is no longer executing gdb code. Hence,
|
we can't have yet another synchronization via the pipes. We'll
|
we can't have yet another synchronization via the pipes. We'll
|
just sleep for a second, and hope that's enough delay... */
|
just sleep for a second, and hope that's enough delay... */
|
sleep (1);
|
sleep (1);
|
|
|
/* Instruct the kernel as to the set of events we wish to be
|
/* Instruct the kernel as to the set of events we wish to be
|
informed of. */
|
informed of. */
|
require_notification_of_exec_events (pid);
|
require_notification_of_exec_events (pid);
|
|
|
/* Discard our copy of the semaphore. */
|
/* Discard our copy of the semaphore. */
|
(void) close (startup_semaphore.parent_channel[SEM_LISTEN]);
|
(void) close (startup_semaphore.parent_channel[SEM_LISTEN]);
|
(void) close (startup_semaphore.parent_channel[SEM_TALK]);
|
(void) close (startup_semaphore.parent_channel[SEM_TALK]);
|
(void) close (startup_semaphore.child_channel[SEM_LISTEN]);
|
(void) close (startup_semaphore.child_channel[SEM_LISTEN]);
|
(void) close (startup_semaphore.child_channel[SEM_TALK]);
|
(void) close (startup_semaphore.child_channel[SEM_TALK]);
|
#endif
|
#endif
|
}
|
}
|
|
|
void
|
void
|
child_post_startup_inferior (pid)
|
child_post_startup_inferior (pid)
|
int pid;
|
int pid;
|
{
|
{
|
require_notification_of_events (pid);
|
require_notification_of_events (pid);
|
}
|
}
|
|
|
void
|
void
|
child_post_attach (pid)
|
child_post_attach (pid)
|
int pid;
|
int pid;
|
{
|
{
|
require_notification_of_events (pid);
|
require_notification_of_events (pid);
|
}
|
}
|
|
|
int
|
int
|
child_insert_fork_catchpoint (pid)
|
child_insert_fork_catchpoint (pid)
|
int pid;
|
int pid;
|
{
|
{
|
/* This request is only available on HPUX 10.0 and later. */
|
/* This request is only available on HPUX 10.0 and later. */
|
#if !defined(PT_SET_EVENT_MASK)
|
#if !defined(PT_SET_EVENT_MASK)
|
error ("Unable to catch forks prior to HPUX 10.0");
|
error ("Unable to catch forks prior to HPUX 10.0");
|
#else
|
#else
|
/* Enable reporting of fork events from the kernel. */
|
/* Enable reporting of fork events from the kernel. */
|
/* ??rehrauer: For the moment, we're always enabling these events,
|
/* ??rehrauer: For the moment, we're always enabling these events,
|
and just ignoring them if there's no catchpoint to catch them. */
|
and just ignoring them if there's no catchpoint to catch them. */
|
return 0;
|
return 0;
|
#endif
|
#endif
|
}
|
}
|
|
|
int
|
int
|
child_remove_fork_catchpoint (pid)
|
child_remove_fork_catchpoint (pid)
|
int pid;
|
int pid;
|
{
|
{
|
/* This request is only available on HPUX 10.0 and later. */
|
/* This request is only available on HPUX 10.0 and later. */
|
#if !defined(PT_SET_EVENT_MASK)
|
#if !defined(PT_SET_EVENT_MASK)
|
error ("Unable to catch forks prior to HPUX 10.0");
|
error ("Unable to catch forks prior to HPUX 10.0");
|
#else
|
#else
|
/* Disable reporting of fork events from the kernel. */
|
/* Disable reporting of fork events from the kernel. */
|
/* ??rehrauer: For the moment, we're always enabling these events,
|
/* ??rehrauer: For the moment, we're always enabling these events,
|
and just ignoring them if there's no catchpoint to catch them. */
|
and just ignoring them if there's no catchpoint to catch them. */
|
return 0;
|
return 0;
|
#endif
|
#endif
|
}
|
}
|
|
|
int
|
int
|
child_insert_vfork_catchpoint (pid)
|
child_insert_vfork_catchpoint (pid)
|
int pid;
|
int pid;
|
{
|
{
|
/* This request is only available on HPUX 10.0 and later. */
|
/* This request is only available on HPUX 10.0 and later. */
|
#if !defined(PT_SET_EVENT_MASK)
|
#if !defined(PT_SET_EVENT_MASK)
|
error ("Unable to catch vforks prior to HPUX 10.0");
|
error ("Unable to catch vforks prior to HPUX 10.0");
|
#else
|
#else
|
/* Enable reporting of vfork events from the kernel. */
|
/* Enable reporting of vfork events from the kernel. */
|
/* ??rehrauer: For the moment, we're always enabling these events,
|
/* ??rehrauer: For the moment, we're always enabling these events,
|
and just ignoring them if there's no catchpoint to catch them. */
|
and just ignoring them if there's no catchpoint to catch them. */
|
return 0;
|
return 0;
|
#endif
|
#endif
|
}
|
}
|
|
|
int
|
int
|
child_remove_vfork_catchpoint (pid)
|
child_remove_vfork_catchpoint (pid)
|
int pid;
|
int pid;
|
{
|
{
|
/* This request is only available on HPUX 10.0 and later. */
|
/* This request is only available on HPUX 10.0 and later. */
|
#if !defined(PT_SET_EVENT_MASK)
|
#if !defined(PT_SET_EVENT_MASK)
|
error ("Unable to catch vforks prior to HPUX 10.0");
|
error ("Unable to catch vforks prior to HPUX 10.0");
|
#else
|
#else
|
/* Disable reporting of vfork events from the kernel. */
|
/* Disable reporting of vfork events from the kernel. */
|
/* ??rehrauer: For the moment, we're always enabling these events,
|
/* ??rehrauer: For the moment, we're always enabling these events,
|
and just ignoring them if there's no catchpoint to catch them. */
|
and just ignoring them if there's no catchpoint to catch them. */
|
return 0;
|
return 0;
|
#endif
|
#endif
|
}
|
}
|
|
|
int
|
int
|
child_has_forked (pid, childpid)
|
child_has_forked (pid, childpid)
|
int pid;
|
int pid;
|
int *childpid;
|
int *childpid;
|
{
|
{
|
/* This request is only available on HPUX 10.0 and later. */
|
/* This request is only available on HPUX 10.0 and later. */
|
#if !defined(PT_GET_PROCESS_STATE)
|
#if !defined(PT_GET_PROCESS_STATE)
|
*childpid = 0;
|
*childpid = 0;
|
return 0;
|
return 0;
|
#else
|
#else
|
int pt_status;
|
int pt_status;
|
ptrace_state_t ptrace_state;
|
ptrace_state_t ptrace_state;
|
|
|
errno = 0;
|
errno = 0;
|
pt_status = call_ptrace (PT_GET_PROCESS_STATE,
|
pt_status = call_ptrace (PT_GET_PROCESS_STATE,
|
pid,
|
pid,
|
(PTRACE_ARG3_TYPE) & ptrace_state,
|
(PTRACE_ARG3_TYPE) & ptrace_state,
|
sizeof (ptrace_state));
|
sizeof (ptrace_state));
|
if (errno)
|
if (errno)
|
perror_with_name ("ptrace");
|
perror_with_name ("ptrace");
|
if (pt_status < 0)
|
if (pt_status < 0)
|
return 0;
|
return 0;
|
|
|
if (ptrace_state.pe_report_event & PTRACE_FORK)
|
if (ptrace_state.pe_report_event & PTRACE_FORK)
|
{
|
{
|
*childpid = ptrace_state.pe_other_pid;
|
*childpid = ptrace_state.pe_other_pid;
|
return 1;
|
return 1;
|
}
|
}
|
|
|
return 0;
|
return 0;
|
#endif
|
#endif
|
}
|
}
|
|
|
int
|
int
|
child_has_vforked (pid, childpid)
|
child_has_vforked (pid, childpid)
|
int pid;
|
int pid;
|
int *childpid;
|
int *childpid;
|
{
|
{
|
/* This request is only available on HPUX 10.0 and later. */
|
/* This request is only available on HPUX 10.0 and later. */
|
#if !defined(PT_GET_PROCESS_STATE)
|
#if !defined(PT_GET_PROCESS_STATE)
|
*childpid = 0;
|
*childpid = 0;
|
return 0;
|
return 0;
|
|
|
#else
|
#else
|
int pt_status;
|
int pt_status;
|
ptrace_state_t ptrace_state;
|
ptrace_state_t ptrace_state;
|
|
|
errno = 0;
|
errno = 0;
|
pt_status = call_ptrace (PT_GET_PROCESS_STATE,
|
pt_status = call_ptrace (PT_GET_PROCESS_STATE,
|
pid,
|
pid,
|
(PTRACE_ARG3_TYPE) & ptrace_state,
|
(PTRACE_ARG3_TYPE) & ptrace_state,
|
sizeof (ptrace_state));
|
sizeof (ptrace_state));
|
if (errno)
|
if (errno)
|
perror_with_name ("ptrace");
|
perror_with_name ("ptrace");
|
if (pt_status < 0)
|
if (pt_status < 0)
|
return 0;
|
return 0;
|
|
|
if (ptrace_state.pe_report_event & PTRACE_VFORK)
|
if (ptrace_state.pe_report_event & PTRACE_VFORK)
|
{
|
{
|
*childpid = ptrace_state.pe_other_pid;
|
*childpid = ptrace_state.pe_other_pid;
|
return 1;
|
return 1;
|
}
|
}
|
|
|
return 0;
|
return 0;
|
#endif
|
#endif
|
}
|
}
|
|
|
int
|
int
|
child_can_follow_vfork_prior_to_exec ()
|
child_can_follow_vfork_prior_to_exec ()
|
{
|
{
|
/* ptrace doesn't allow this. */
|
/* ptrace doesn't allow this. */
|
return 0;
|
return 0;
|
}
|
}
|
|
|
int
|
int
|
child_insert_exec_catchpoint (pid)
|
child_insert_exec_catchpoint (pid)
|
int pid;
|
int pid;
|
{
|
{
|
/* This request is only available on HPUX 10.0 and later. */
|
/* This request is only available on HPUX 10.0 and later. */
|
#if !defined(PT_SET_EVENT_MASK)
|
#if !defined(PT_SET_EVENT_MASK)
|
error ("Unable to catch execs prior to HPUX 10.0");
|
error ("Unable to catch execs prior to HPUX 10.0");
|
|
|
#else
|
#else
|
/* Enable reporting of exec events from the kernel. */
|
/* Enable reporting of exec events from the kernel. */
|
/* ??rehrauer: For the moment, we're always enabling these events,
|
/* ??rehrauer: For the moment, we're always enabling these events,
|
and just ignoring them if there's no catchpoint to catch them. */
|
and just ignoring them if there's no catchpoint to catch them. */
|
return 0;
|
return 0;
|
#endif
|
#endif
|
}
|
}
|
|
|
int
|
int
|
child_remove_exec_catchpoint (pid)
|
child_remove_exec_catchpoint (pid)
|
int pid;
|
int pid;
|
{
|
{
|
/* This request is only available on HPUX 10.0 and later. */
|
/* This request is only available on HPUX 10.0 and later. */
|
#if !defined(PT_SET_EVENT_MASK)
|
#if !defined(PT_SET_EVENT_MASK)
|
error ("Unable to catch execs prior to HPUX 10.0");
|
error ("Unable to catch execs prior to HPUX 10.0");
|
|
|
#else
|
#else
|
/* Disable reporting of exec events from the kernel. */
|
/* Disable reporting of exec events from the kernel. */
|
/* ??rehrauer: For the moment, we're always enabling these events,
|
/* ??rehrauer: For the moment, we're always enabling these events,
|
and just ignoring them if there's no catchpoint to catch them. */
|
and just ignoring them if there's no catchpoint to catch them. */
|
return 0;
|
return 0;
|
#endif
|
#endif
|
}
|
}
|
|
|
int
|
int
|
child_has_execd (pid, execd_pathname)
|
child_has_execd (pid, execd_pathname)
|
int pid;
|
int pid;
|
char **execd_pathname;
|
char **execd_pathname;
|
{
|
{
|
/* This request is only available on HPUX 10.0 and later. */
|
/* This request is only available on HPUX 10.0 and later. */
|
#if !defined(PT_GET_PROCESS_STATE)
|
#if !defined(PT_GET_PROCESS_STATE)
|
*execd_pathname = NULL;
|
*execd_pathname = NULL;
|
return 0;
|
return 0;
|
|
|
#else
|
#else
|
int pt_status;
|
int pt_status;
|
ptrace_state_t ptrace_state;
|
ptrace_state_t ptrace_state;
|
|
|
errno = 0;
|
errno = 0;
|
pt_status = call_ptrace (PT_GET_PROCESS_STATE,
|
pt_status = call_ptrace (PT_GET_PROCESS_STATE,
|
pid,
|
pid,
|
(PTRACE_ARG3_TYPE) & ptrace_state,
|
(PTRACE_ARG3_TYPE) & ptrace_state,
|
sizeof (ptrace_state));
|
sizeof (ptrace_state));
|
if (errno)
|
if (errno)
|
perror_with_name ("ptrace");
|
perror_with_name ("ptrace");
|
if (pt_status < 0)
|
if (pt_status < 0)
|
return 0;
|
return 0;
|
|
|
if (ptrace_state.pe_report_event & PTRACE_EXEC)
|
if (ptrace_state.pe_report_event & PTRACE_EXEC)
|
{
|
{
|
char *exec_file = target_pid_to_exec_file (pid);
|
char *exec_file = target_pid_to_exec_file (pid);
|
*execd_pathname = savestring (exec_file, strlen (exec_file));
|
*execd_pathname = savestring (exec_file, strlen (exec_file));
|
return 1;
|
return 1;
|
}
|
}
|
|
|
return 0;
|
return 0;
|
#endif
|
#endif
|
}
|
}
|
|
|
int
|
int
|
child_reported_exec_events_per_exec_call ()
|
child_reported_exec_events_per_exec_call ()
|
{
|
{
|
return 2; /* ptrace reports the event twice per call. */
|
return 2; /* ptrace reports the event twice per call. */
|
}
|
}
|
|
|
int
|
int
|
child_has_syscall_event (pid, kind, syscall_id)
|
child_has_syscall_event (pid, kind, syscall_id)
|
int pid;
|
int pid;
|
enum target_waitkind *kind;
|
enum target_waitkind *kind;
|
int *syscall_id;
|
int *syscall_id;
|
{
|
{
|
/* This request is only available on HPUX 10.30 and later, via
|
/* This request is only available on HPUX 10.30 and later, via
|
the ttrace interface. */
|
the ttrace interface. */
|
|
|
*kind = TARGET_WAITKIND_SPURIOUS;
|
*kind = TARGET_WAITKIND_SPURIOUS;
|
*syscall_id = -1;
|
*syscall_id = -1;
|
return 0;
|
return 0;
|
}
|
}
|
|
|
char *
|
char *
|
child_pid_to_exec_file (pid)
|
child_pid_to_exec_file (pid)
|
int pid;
|
int pid;
|
{
|
{
|
static char exec_file_buffer[1024];
|
static char exec_file_buffer[1024];
|
int pt_status;
|
int pt_status;
|
CORE_ADDR top_of_stack;
|
CORE_ADDR top_of_stack;
|
char four_chars[4];
|
char four_chars[4];
|
int name_index;
|
int name_index;
|
int i;
|
int i;
|
int saved_inferior_pid;
|
int saved_inferior_pid;
|
boolean done;
|
boolean done;
|
|
|
#ifdef PT_GET_PROCESS_PATHNAME
|
#ifdef PT_GET_PROCESS_PATHNAME
|
/* As of 10.x HP-UX, there's an explicit request to get the pathname. */
|
/* As of 10.x HP-UX, there's an explicit request to get the pathname. */
|
pt_status = call_ptrace (PT_GET_PROCESS_PATHNAME,
|
pt_status = call_ptrace (PT_GET_PROCESS_PATHNAME,
|
pid,
|
pid,
|
(PTRACE_ARG3_TYPE) exec_file_buffer,
|
(PTRACE_ARG3_TYPE) exec_file_buffer,
|
sizeof (exec_file_buffer) - 1);
|
sizeof (exec_file_buffer) - 1);
|
if (pt_status == 0)
|
if (pt_status == 0)
|
return exec_file_buffer;
|
return exec_file_buffer;
|
#endif
|
#endif
|
|
|
/* It appears that this request is broken prior to 10.30.
|
/* It appears that this request is broken prior to 10.30.
|
If it fails, try a really, truly amazingly gross hack
|
If it fails, try a really, truly amazingly gross hack
|
that DDE uses, of pawing through the process' data
|
that DDE uses, of pawing through the process' data
|
segment to find the pathname. */
|
segment to find the pathname. */
|
|
|
top_of_stack = 0x7b03a000;
|
top_of_stack = 0x7b03a000;
|
name_index = 0;
|
name_index = 0;
|
done = 0;
|
done = 0;
|
|
|
/* On the chance that pid != inferior_pid, set inferior_pid
|
/* On the chance that pid != inferior_pid, set inferior_pid
|
to pid, so that (grrrr!) implicit uses of inferior_pid get
|
to pid, so that (grrrr!) implicit uses of inferior_pid get
|
the right id. */
|
the right id. */
|
|
|
saved_inferior_pid = inferior_pid;
|
saved_inferior_pid = inferior_pid;
|
inferior_pid = pid;
|
inferior_pid = pid;
|
|
|
/* Try to grab a null-terminated string. */
|
/* Try to grab a null-terminated string. */
|
while (!done)
|
while (!done)
|
{
|
{
|
if (target_read_memory (top_of_stack, four_chars, 4) != 0)
|
if (target_read_memory (top_of_stack, four_chars, 4) != 0)
|
{
|
{
|
inferior_pid = saved_inferior_pid;
|
inferior_pid = saved_inferior_pid;
|
return NULL;
|
return NULL;
|
}
|
}
|
for (i = 0; i < 4; i++)
|
for (i = 0; i < 4; i++)
|
{
|
{
|
exec_file_buffer[name_index++] = four_chars[i];
|
exec_file_buffer[name_index++] = four_chars[i];
|
done = (four_chars[i] == '\0');
|
done = (four_chars[i] == '\0');
|
if (done)
|
if (done)
|
break;
|
break;
|
}
|
}
|
top_of_stack += 4;
|
top_of_stack += 4;
|
}
|
}
|
|
|
if (exec_file_buffer[0] == '\0')
|
if (exec_file_buffer[0] == '\0')
|
{
|
{
|
inferior_pid = saved_inferior_pid;
|
inferior_pid = saved_inferior_pid;
|
return NULL;
|
return NULL;
|
}
|
}
|
|
|
inferior_pid = saved_inferior_pid;
|
inferior_pid = saved_inferior_pid;
|
return exec_file_buffer;
|
return exec_file_buffer;
|
}
|
}
|
|
|
void
|
void
|
pre_fork_inferior ()
|
pre_fork_inferior ()
|
{
|
{
|
int status;
|
int status;
|
|
|
status = pipe (startup_semaphore.parent_channel);
|
status = pipe (startup_semaphore.parent_channel);
|
if (status < 0)
|
if (status < 0)
|
{
|
{
|
warning ("error getting parent pipe for startup semaphore");
|
warning ("error getting parent pipe for startup semaphore");
|
return;
|
return;
|
}
|
}
|
|
|
status = pipe (startup_semaphore.child_channel);
|
status = pipe (startup_semaphore.child_channel);
|
if (status < 0)
|
if (status < 0)
|
{
|
{
|
warning ("error getting child pipe for startup semaphore");
|
warning ("error getting child pipe for startup semaphore");
|
return;
|
return;
|
}
|
}
|
}
|
}
|
|
|
|
|
/* Check to see if the given thread is alive.
|
/* Check to see if the given thread is alive.
|
|
|
This is a no-op, as ptrace doesn't support threads, so we just
|
This is a no-op, as ptrace doesn't support threads, so we just
|
return "TRUE". */
|
return "TRUE". */
|
|
|
int
|
int
|
child_thread_alive (pid)
|
child_thread_alive (pid)
|
int pid;
|
int pid;
|
{
|
{
|
return 1;
|
return 1;
|
}
|
}
|
|
|
#endif /* ! GDB_NATIVE_HPUX_11 */
|
#endif /* ! GDB_NATIVE_HPUX_11 */
|
|
|
