From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 9449 invoked by alias); 5 Sep 2004 14:11:06 -0000 Mailing-List: contact gdb-patches-help@sources.redhat.com; run by ezmlm Precedence: bulk List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sources.redhat.com Received: (qmail 9440 invoked from network); 5 Sep 2004 14:11:05 -0000 Received: from unknown (HELO mx1.redhat.com) (66.187.233.31) by sourceware.org with SMTP; 5 Sep 2004 14:11:05 -0000 Received: from int-mx1.corp.redhat.com (int-mx1.corp.redhat.com [172.16.52.254]) by mx1.redhat.com (8.12.10/8.12.10) with ESMTP id i85EB0S2009907 for ; Sun, 5 Sep 2004 10:11:05 -0400 Received: from localhost.redhat.com (porkchop.devel.redhat.com [172.16.58.2]) by int-mx1.corp.redhat.com (8.11.6/8.11.6) with ESMTP id i85EAn302530; Sun, 5 Sep 2004 10:10:49 -0400 Received: from gnu.org (localhost [127.0.0.1]) by localhost.redhat.com (Postfix) with ESMTP id 0171928D2; Sun, 5 Sep 2004 10:10:40 -0400 (EDT) Message-ID: <413B1E60.9060506@gnu.org> Date: Sun, 05 Sep 2004 14:11:00 -0000 From: Andrew Cagney User-Agent: Mozilla/5.0 (X11; U; NetBSD macppc; en-GB; rv:1.4.1) Gecko/20040831 MIME-Version: 1.0 To: gdb-patches@sources.redhat.com Subject: [patch/rfc] Implement ptrace target vector inheritance Content-Type: multipart/mixed; boundary="------------010005000104010805020306" X-SW-Source: 2004-09/txt/msg00093.txt.bz2 This is a multi-part message in MIME format. --------------010005000104010805020306 Content-Type: text/plain; charset=us-ascii; format=flowed Content-Transfer-Encoding: 7bit Content-length: 796 Hello, This came from an thread between myself and MarkK (I can't find the url). The current native code constructs its target vector using a convoluted combination of #ifdefs and global functions. This patch replaces all that with what is effectively a runtime inheritance structure: inf-ptrace is-a inf-child is-a target I've updated/tested NetBSD/PPC, with a tweak to nbsdppc-nat. that further extends the above with: nbsdppc-nat is-a inf-ptrace there were no regressions. The intent is for all natives to eventually migrate to this. Comments? Right now I'm more interested in high-level stuff - the idea and the strategy. I'm sure the implementation will evolve as more natives come on board, and as I eliminate a few remaining globals. I'll leave this for a week, Andrew --------------010005000104010805020306 Content-Type: text/plain; name="diffs" Content-Transfer-Encoding: 7bit Content-Disposition: inline; filename="diffs" Content-length: 45871 2004-09-04 Andrew Cagney * ppcnbsd-nat.c: Include "inf-ptrace.h". (ppcnbsd_fetch_inferior_registers): Rename fetch_inferior_registers. (ppcnbsd_store_inferior_registers): Rename store_inferior_registers. (_initialize_ppcnbsd_nat): Create and add a NetBSD/PPC ptrace target. * config/powerpc/nbsd.mh (NATDEPFILES): Replace infptrace.o and inftarg.o with inf-ptrace.o and inf-child.o * inf-ptrace.h, inf-ptrace.c, inf-child.h, inf-child.c: New files. * Makefile.in: Update dependencies. Index: inf-child.c =================================================================== RCS file: inf-child.c diff -N inf-child.c --- /dev/null 1 Jan 1970 00:00:00 -0000 +++ inf-child.c 5 Sep 2004 13:46:02 -0000 @@ -0,0 +1,241 @@ +/* Default child (native) target interface, for GDB when running under + Unix. + + Copyright 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, + 1998, 1999, 2000, 2001, 2002, 2004 Free Software Foundation, Inc. + + 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 "regcache.h" +#include "memattr.h" +#include "symtab.h" +#include "target.h" +#include "inferior.h" + +/* Fetch register REGNUM from the inferior. If REGNUM is -1, do this + for all registers. */ + +static void +inf_child_fetch_inferior_registers (int regnum) +{ + if (regnum == -1) + { + for (regnum = 0; regnum < NUM_REGS; regnum++) + regcache_raw_supply (current_regcache, regnum, NULL); + } + else + regcache_raw_supply (current_regcache, regnum, NULL); +} + +/* Store register REGNUM back into the inferior. If REGNUM is -1, do + this for all registers (including the floating point registers). */ + +static void +inf_child_store_inferior_registers (int regnum) +{ +} + +void +inf_child_post_wait (ptid_t ptid, int wait_status) +{ + /* This version of Unix doesn't require a meaningful "post wait" + operation. + */ +} + +static void +inf_child_post_attach (int pid) +{ + /* This version of Unix doesn't require a meaningful "post attach" + operation by a debugger. */ +} + +/* Get ready to modify the registers array. On machines which store + individual registers, this doesn't need to do anything. On + machines which store all the registers in one fell swoop, this + makes sure that registers contains all the registers from the + program being debugged. */ + +static void +inf_child_prepare_to_store (void) +{ +} + +static void +inf_child_open (char *arg, int from_tty) +{ + error ("Use the \"run\" command to start a Unix child process."); +} + +static void +inf_child_post_startup_inferior (ptid_t ptid) +{ + /* This version of Unix doesn't require a meaningful "post startup + inferior" operation by a debugger. */ +} + +static void +inf_child_acknowledge_created_inferior (int pid) +{ + /* This version of Unix doesn't require a meaningful "acknowledge + created inferior" operation by a debugger. */ +} + +static int +inf_child_insert_fork_catchpoint (int pid) +{ + /* This version of Unix doesn't support notification of fork + events. */ + return 0; +} + +static int +inf_child_remove_fork_catchpoint (int pid) +{ + /* This version of Unix doesn't support notification of fork + events. */ + return 0; +} + +static int +inf_child_insert_vfork_catchpoint (int pid) +{ + /* This version of Unix doesn't support notification of vfork + events. */ + return 0; +} + +static int +inf_child_remove_vfork_catchpoint (int pid) +{ + /* This version of Unix doesn't support notification of vfork + events. */ + return 0; +} + +static int +inf_child_follow_fork (int follow_child) +{ + /* This version of Unix doesn't support following fork or vfork + events. */ + return 0; +} + +static int +inf_child_insert_exec_catchpoint (int pid) +{ + /* This version of Unix doesn't support notification of exec + events. */ + return 0; +} + +static int +inf_child_remove_exec_catchpoint (int pid) +{ + /* This version of Unix doesn't support notification of exec + events. */ + return 0; +} + +static int +inf_child_reported_exec_events_per_exec_call (void) +{ + /* This version of Unix doesn't support notification of exec + events. */ + return 1; +} + +static int +inf_child_can_run (void) +{ + return 1; +} + +static struct symtab_and_line * +inf_child_enable_exception_callback (enum exception_event_kind kind, + int enable) +{ + return (struct symtab_and_line *) NULL; +} + +static struct exception_event_record * +inf_child_get_current_exception_event (void) +{ + return (struct exception_event_record *) NULL; +} + +static char * +inf_child_pid_to_exec_file (int pid) +{ + /* This version of Unix doesn't support translation of a process ID + to the filename of the executable file. */ + return NULL; +} + +static char * +inf_child_core_file_to_sym_file (char *core) +{ + /* The target stratum for a running executable need not support this + operation. */ + return NULL; +} + +struct target_ops * +inf_child_target (void) +{ + struct target_ops *t = XZALLOC (struct target_ops); + t->to_shortname = "child"; + t->to_longname = "Unix child process"; + t->to_doc = "Unix child process (started by the \"run\" command)."; + t->to_open = inf_child_open; + t->to_post_attach = inf_child_post_attach; + t->to_post_wait = inf_child_post_wait; + t->to_prepare_to_store = inf_child_prepare_to_store; + t->to_insert_breakpoint = memory_insert_breakpoint; + t->to_remove_breakpoint = memory_remove_breakpoint; + t->to_terminal_init = terminal_init_inferior; + t->to_terminal_inferior = terminal_inferior; + t->to_terminal_ours_for_output = terminal_ours_for_output; + t->to_terminal_save_ours = terminal_save_ours; + t->to_terminal_ours = terminal_ours; + t->to_terminal_info = child_terminal_info; + t->to_post_startup_inferior = inf_child_post_startup_inferior; + t->to_acknowledge_created_inferior = inf_child_acknowledge_created_inferior; + t->to_insert_fork_catchpoint = inf_child_insert_fork_catchpoint; + t->to_remove_fork_catchpoint = inf_child_remove_fork_catchpoint; + t->to_insert_vfork_catchpoint = inf_child_insert_vfork_catchpoint; + t->to_remove_vfork_catchpoint = inf_child_remove_vfork_catchpoint; + t->to_follow_fork = inf_child_follow_fork; + t->to_insert_exec_catchpoint = inf_child_insert_exec_catchpoint; + t->to_remove_exec_catchpoint = inf_child_remove_exec_catchpoint; + t->to_reported_exec_events_per_exec_call = + inf_child_reported_exec_events_per_exec_call; + t->to_can_run = inf_child_can_run; + t->to_enable_exception_callback = inf_child_enable_exception_callback; + t->to_get_current_exception_event = inf_child_get_current_exception_event; + t->to_pid_to_exec_file = inf_child_pid_to_exec_file; + t->to_stratum = process_stratum; + t->to_has_all_memory = 1; + t->to_has_memory = 1; + t->to_has_stack = 1; + t->to_has_registers = 1; + t->to_has_execution = 1; + t->to_magic = OPS_MAGIC; + return t; +} Index: inf-child.h =================================================================== RCS file: inf-child.h diff -N inf-child.h --- /dev/null 1 Jan 1970 00:00:00 -0000 +++ inf-child.h 5 Sep 2004 13:46:02 -0000 @@ -0,0 +1,30 @@ +/* Low level Unix child interface, for GDB when running under Unix. + + Copyright 2004 Free Software Foundation, Inc. + + 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. */ + +#ifndef INF_CHILD_H +#define INF_CHILD_H + +/* Create a prototype child target. The client can override it with + local methods. */ + +extern struct target_ops *inf_child_target (void); + +#endif Index: inf-loop.c =================================================================== RCS file: /cvs/src/src/gdb/inf-loop.c,v retrieving revision 1.1.1.3 diff -p -u -r1.1.1.3 inf-loop.c --- inf-loop.c 7 Dec 1999 03:56:01 -0000 1.1.1.3 +++ inf-loop.c 5 Sep 2004 13:46:02 -0000 @@ -21,7 +21,7 @@ #include "defs.h" #include "inferior.h" /* For fetch_inferior_event. */ -#include "target.h" /* For enum inferior_event_type. */ +#include "target.h" /* For enum inferior_event_type. */ #include "event-loop.h" #include "event-top.h" #include "inf-loop.h" @@ -41,7 +41,7 @@ inferior_event_handler_wrapper (gdb_clie otherwise it assumes that all is OK, and goes on reading data from the fd. This however may not always be what we want to do. */ void -inferior_event_handler (enum inferior_event_type event_type, +inferior_event_handler (enum inferior_event_type event_type, gdb_client_data client_data) { switch (event_type) @@ -56,10 +56,10 @@ inferior_event_handler (enum inferior_ev case INF_REG_EVENT: /* Use catch errors for now, until the inner layers of - fetch_inferior_event (i.e. readchar) can return meaningful - error status. If an error occurs while getting an event from - the target, just get rid of the target. */ - if (!catch_errors (fetch_inferior_event_wrapper, + fetch_inferior_event (i.e. readchar) can return meaningful + error status. If an error occurs while getting an event from + the target, just get rid of the target. */ + if (!catch_errors (fetch_inferior_event_wrapper, client_data, "", RETURN_MASK_ALL)) { target_async (NULL, 0); @@ -84,10 +84,10 @@ inferior_event_handler (enum inferior_ev do_all_intermediate_continuations (); break; - case INF_QUIT_REQ: + case INF_QUIT_REQ: /* FIXME: ezannoni 1999-10-04. This call should really be a - target vector entry, so that it can be used for any kind of - targets. */ + target vector entry, so that it can be used for any kind of + targets. */ async_remote_interrupt_twice (NULL); break; @@ -98,7 +98,7 @@ inferior_event_handler (enum inferior_ev } } -static int +static int fetch_inferior_event_wrapper (gdb_client_data client_data) { fetch_inferior_event (client_data); @@ -113,7 +113,7 @@ static void complete_execution (void) { target_executing = 0; - + /* Unregister the inferior from the event loop. This is done so that when the inferior is not running we don't get distracted by spurious inferior output. */ Index: inf-loop.h =================================================================== RCS file: /cvs/src/src/gdb/inf-loop.h,v retrieving revision 1.1.1.2 diff -p -u -r1.1.1.2 inf-loop.h --- inf-loop.h 12 Oct 1999 04:37:22 -0000 1.1.1.2 +++ inf-loop.h 5 Sep 2004 13:46:02 -0000 @@ -22,8 +22,8 @@ #ifndef INF_LOOP_H #define INF_LOOP_H -extern void inferior_event_handler (enum inferior_event_type event_type, - void* client_data); +extern void inferior_event_handler (enum inferior_event_type event_type, + void *client_data); extern void inferior_event_handler_wrapper (void *client_data); #endif /* #ifndef INF_LOOP_H */ Index: inf-ptrace.c =================================================================== RCS file: inf-ptrace.c diff -N inf-ptrace.c --- /dev/null 1 Jan 1970 00:00:00 -0000 +++ inf-ptrace.c 5 Sep 2004 13:46:02 -0000 @@ -0,0 +1,870 @@ +/* Low level Unix child interface to ptrace, for GDB when running under Unix. + + Copyright 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, + 1998, 1999, 2000, 2001, 2002, 2004 Free Software Foundation, Inc. + + 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 "observer.h" +#include "gdb_ptrace.h" +#include "inflow.h" +#include "inferior.h" +#include "regcache.h" +#include "command.h" +#include "gdbcore.h" +#include "inf-child.h" +#include "gdbcmd.h" + +#include +#include + +/* HACK: Save the ptrace ops returned by ptrace_target. */ +static struct target_ops *ptrace_ops_hack; + +/* Debug me? */ +static int debug_inf_ptrace = 0; + +/* 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 (int request, int pid, PTRACE_ARG3_TYPE addr, int data) +{ + int pt_status = 0; + int saved_errno; + + if (debug_inf_ptrace) + fprintf_unfiltered (gdb_stdlog, + "call_ptrace(request=%d, pid=%d, addr=0x%lx, data=0x%x)", + request, pid, (long) addr, data); + +#if defined(PT_SETTRC) + /* If the parent can be told to attach to us, try to do it. */ + if (request == PT_SETTRC) + { + errno = 0; +#ifndef PTRACE_TYPE_ARG5 + pt_status = ptrace (PT_SETTRC, pid, addr, data); +#else + /* Deal with HPUX 8.0 braindamage. We never use the + calls which require the fifth argument. */ + pt_status = ptrace (PT_SETTRC, pid, addr, data, 0); +#endif + if (errno) + perror_with_name ("ptrace"); + if (debug_inf_ptrace) + fprintf_unfiltered (gdb_stdlog, " = %d\n", pt_status); + if (pt_status < 0) + return pt_status; + else + return parent_attach_all (pid, addr, data); + } +#endif + +#if defined(PT_CONTIN1) + /* On HPUX, PT_CONTIN1 is a form of continue that preserves pending + signals. If it's available, use it. */ + if (request == PT_CONTINUE) + request = PT_CONTIN1; +#endif + +#if defined(PT_SINGLE1) + /* On HPUX, PT_SINGLE1 is a form of step that preserves pending + signals. If it's available, use it. */ + if (request == PT_STEP) + request = PT_SINGLE1; +#endif + + errno = 0; +#ifndef PTRACE_TYPE_ARG5 + pt_status = ptrace (request, pid, addr, data); +#else + /* Deal with HPUX 8.0 braindamage. We never use the + calls which require the fifth argument. */ + pt_status = ptrace (request, pid, addr, data, 0); +#endif + + if (debug_inf_ptrace && errno) + { + saved_errno = errno; + fprintf_unfiltered (gdb_stdlog, " [errno = %d]", errno); + fprintf_unfiltered (gdb_stdlog, " = 0x%x\n", pt_status); + errno = saved_errno; + } + + return pt_status; +} + +/* Wait for a process to finish, possibly running a target-specific + hook before returning. */ + +int +ptrace_wait (ptid_t ptid, int *status) +{ + int wstate; + + wstate = wait (status); + target_post_wait (pid_to_ptid (wstate), *status); + return wstate; +} + +static void +inf_ptrace_kill_inferior (void) +{ + int status; + int pid = PIDGET (inferior_ptid); + + if (pid == 0) + return; + + /* This once used to call "kill" to kill the inferior just in case + the inferior was still running. As others have noted in the past + (kingdon) there shouldn't be any way to get here if the inferior + is still running -- else there's a major problem elsewere in gdb + and it needs to be fixed. + + The kill call causes problems under hpux10, so it's been removed; + if this causes problems we'll deal with them as they arise. */ + call_ptrace (PT_KILL, pid, (PTRACE_TYPE_ARG3) 0, 0); + ptrace_wait (null_ptid, &status); + target_mourn_inferior (); +} + +/* Resume execution of the inferior process. If STEP is nonzero, + single-step it. If SIGNAL is nonzero, give it that signal. */ + +static void +inf_ptrace_resume (ptid_t ptid, int step, enum target_signal signal) +{ + int request = PT_CONTINUE; + int pid = PIDGET (ptid); + + if (pid == -1) + /* Resume all threads. */ + /* I think this only gets used in the non-threaded case, where + "resume all threads" and "resume inferior_ptid" are the + same. */ + pid = PIDGET (inferior_ptid); + + if (step) + { + /* If this system does not support PT_STEP, a higher level + function will have called single_step() to transmute the step + request into a continue request (by setting breakpoints on + all possible successor instructions), so we don't have to + worry about that here. */ + request = PT_STEP; + } + + /* An address of (PTRACE_TYPE_ARG3)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. */ + errno = 0; + ptrace (request, pid, (PTRACE_TYPE_ARG3) 1, target_signal_to_host (signal)); + if (errno != 0) + perror_with_name ("ptrace"); +} + +/* Start debugging the process whose number is PID. */ + +int +attach (int pid) +{ +#ifdef PT_ATTACH + errno = 0; + ptrace (PT_ATTACH, pid, (PTRACE_TYPE_ARG3) 0, 0); + if (errno != 0) + perror_with_name ("ptrace"); + attach_flag = 1; + return pid; +#else + error ("This system does not support attaching to a process"); +#endif +} + +/* Stop debugging the process whose number is PID and continue it with + signal number SIGNAL. SIGNAL = 0 means just continue it. */ + +void +detach (int signal) +{ +#ifdef PT_DETACH + int pid = PIDGET (inferior_ptid); + + errno = 0; + ptrace (PT_DETACH, pid, (PTRACE_TYPE_ARG3) 1, signal); + if (errno != 0) + perror_with_name ("ptrace"); + attach_flag = 0; +#else + error ("This system does not support detaching from a process"); +#endif +} + +/* Set an upper limit on alloca. */ +#define GDB_MAX_ALLOCA 0x1000 + +/* 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. TARGET is ignored. + + Returns the length copied, which is either the LEN argument or + zero. This xfer function does not do partial moves, since + ptrace_ops_hack doesn't allow memory operations to cross below us in the + target stack anyway. */ + +int +inf_ptrace_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write, + struct mem_attrib *attrib, struct target_ops *target) +{ + int i; + /* Round starting address down to longword boundary. */ + CORE_ADDR addr = memaddr & -(CORE_ADDR) sizeof (PTRACE_TYPE_RET); + /* Round ending address up; get number of longwords that makes. */ + int count = ((((memaddr + len) - addr) + sizeof (PTRACE_TYPE_RET) - 1) + / sizeof (PTRACE_TYPE_RET)); + int alloc = count * sizeof (PTRACE_TYPE_RET); + PTRACE_TYPE_RET *buffer; + struct cleanup *old_chain = NULL; + +#ifdef PT_IO + /* OpenBSD 3.1, NetBSD 1.6 and FreeBSD 5.0 have a new PT_IO request + that promises to be much more efficient in reading and writing + data in the traced process's address space. */ + + { + struct ptrace_io_desc piod; + + /* NOTE: We assume that there are no distinct address spaces for + instruction and data. */ + piod.piod_op = write ? PIOD_WRITE_D : PIOD_READ_D; + piod.piod_offs = (void *) memaddr; + piod.piod_addr = myaddr; + piod.piod_len = len; + + if (ptrace (PT_IO, PIDGET (inferior_ptid), (caddr_t) & piod, 0) == -1) + { + /* If the PT_IO request is somehow not supported, fallback on + using PT_WRITE_D/PT_READ_D. Otherwise we will return zero + to indicate failure. */ + if (errno != EINVAL) + return 0; + } + else + { + /* Return the actual number of bytes read or written. */ + return piod.piod_len; + } + } +#endif + + /* Allocate buffer of that many longwords. */ + if (len < GDB_MAX_ALLOCA) + { + buffer = (PTRACE_TYPE_RET *) alloca (alloc); + } + else + { + buffer = (PTRACE_TYPE_RET *) xmalloc (alloc); + old_chain = make_cleanup (xfree, buffer); + } + + if (write) + { + /* Fill start and end extra bytes of buffer with existing memory + data. */ + if (addr != memaddr || len < (int) sizeof (PTRACE_TYPE_RET)) + { + /* Need part of initial word -- fetch it. */ + buffer[0] = ptrace (PT_READ_I, PIDGET (inferior_ptid), + (PTRACE_TYPE_ARG3) addr, 0); + } + + if (count > 1) /* FIXME, avoid if even boundary. */ + { + buffer[count - 1] = + ptrace (PT_READ_I, PIDGET (inferior_ptid), + ((PTRACE_TYPE_ARG3) + (addr + (count - 1) * sizeof (PTRACE_TYPE_RET))), 0); + } + + /* Copy data to be written over corresponding part of buffer. */ + memcpy ((char *) buffer + (memaddr & (sizeof (PTRACE_TYPE_RET) - 1)), + myaddr, len); + + /* Write the entire buffer. */ + for (i = 0; i < count; i++, addr += sizeof (PTRACE_TYPE_RET)) + { + errno = 0; + ptrace (PT_WRITE_D, PIDGET (inferior_ptid), + (PTRACE_TYPE_ARG3) 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, PIDGET (inferior_ptid), + (PTRACE_TYPE_ARG3) addr, buffer[i]); + } + if (errno) + return 0; + } + } + else + { + /* Read all the longwords. */ + for (i = 0; i < count; i++, addr += sizeof (PTRACE_TYPE_RET)) + { + errno = 0; + buffer[i] = ptrace (PT_READ_I, PIDGET (inferior_ptid), + (PTRACE_TYPE_ARG3) addr, 0); + if (errno) + return 0; + QUIT; + } + + /* Copy appropriate bytes out of the buffer. */ + memcpy (myaddr, + (char *) buffer + (memaddr & (sizeof (PTRACE_TYPE_RET) - 1)), + len); + } + + if (old_chain != NULL) + do_cleanups (old_chain); + return len; +} + +/* Wait for child to do something. Return pid of child, or -1 in case + of error; store status through argument pointer OURSTATUS. */ + +static ptid_t +inf_ptrace_wait (ptid_t ptid, struct target_waitstatus *ourstatus) +{ + int save_errno; + int status; + char *execd_pathname = NULL; + int exit_status; + int related_pid; + int syscall_id; + enum target_waitkind kind; + int pid; + + do + { + set_sigint_trap (); /* Causes SIGINT to be passed on to the + attached process. */ + set_sigio_trap (); + + pid = ptrace_wait (inferior_ptid, &status); + + save_errno = errno; + + clear_sigio_trap (); + + clear_sigint_trap (); + + if (pid == -1) + { + if (save_errno == EINTR) + continue; + + fprintf_unfiltered (gdb_stderr, + "Child process unexpectedly missing: %s.\n", + safe_strerror (save_errno)); + + /* Claim it exited with unknown signal. */ + ourstatus->kind = TARGET_WAITKIND_SIGNALLED; + ourstatus->value.sig = TARGET_SIGNAL_UNKNOWN; + return pid_to_ptid (-1); + } + + /* Did it exit? + */ + if (target_has_exited (pid, status, &exit_status)) + { + /* ??rehrauer: For now, ignore this. */ + continue; + } + + if (!target_thread_alive (pid_to_ptid (pid))) + { + ourstatus->kind = TARGET_WAITKIND_SPURIOUS; + return pid_to_ptid (pid); + } + } + while (pid != PIDGET (inferior_ptid)); /* Some other child died or stopped */ + + store_waitstatus (ourstatus, status); + return pid_to_ptid (pid); +} + +void +inf_ptrace_post_wait (ptid_t ptid, int wait_status) +{ + /* This version of Unix doesn't require a meaningful "post wait" + operation. + */ +} + +/* Check to see if the given thread is alive. + + FIXME: Is kill() ever the right way to do this? I doubt it, but + for now we're going to try and be compatable with the old thread + code. */ + +static int +inf_ptrace_thread_alive (ptid_t ptid) +{ + pid_t pid = PIDGET (ptid); + + return (kill (pid, 0) != -1); +} + +/* Attach to process PID, then initialize for debugging it. */ + +static void +inf_ptrace_attach (char *args, int from_tty) +{ + char *exec_file; + int pid; + char *dummy; + + if (!args) + error_no_arg ("process-id to attach"); + + dummy = args; + pid = strtol (args, &dummy, 0); + /* Some targets don't set errno on errors, grrr! */ + if ((pid == 0) && (args == dummy)) + error ("Illegal process-id: %s\n", args); + + if (pid == getpid ()) /* Trying to masturbate? */ + error ("I refuse to debug myself!"); + + if (from_tty) + { + exec_file = (char *) get_exec_file (0); + + if (exec_file) + printf_unfiltered ("Attaching to program: %s, %s\n", exec_file, + target_pid_to_str (pid_to_ptid (pid))); + else + printf_unfiltered ("Attaching to %s\n", + target_pid_to_str (pid_to_ptid (pid))); + + gdb_flush (gdb_stdout); + } + + attach (pid); + + inferior_ptid = pid_to_ptid (pid); + push_target (ptrace_ops_hack); +} + +static void +inf_ptrace_post_attach (int pid) +{ + /* This version of Unix doesn't require a meaningful "post attach" + operation by a debugger. */ +} + +/* Take a program previously attached to and detaches it. The program + resumes execution and will no longer stop on signals, etc. We'd + better not have left any breakpoints in the program or it'll die + when it hits one. For this to work, it may be necessary for the + process to have been previously attached. It *might* work if the + program was started via the normal ptrace (PTRACE_TRACEME). */ + +static void +inf_ptrace_detach (char *args, int from_tty) +{ + int siggnal = 0; + int pid = PIDGET (inferior_ptid); + + if (from_tty) + { + char *exec_file = get_exec_file (0); + if (exec_file == 0) + exec_file = ""; + printf_unfiltered ("Detaching from program: %s, %s\n", exec_file, + target_pid_to_str (pid_to_ptid (pid))); + gdb_flush (gdb_stdout); + } + if (args) + siggnal = atoi (args); + + detach (siggnal); + + inferior_ptid = null_ptid; + unpush_target (ptrace_ops_hack); +} + +/* Get ready to modify the registers array. On machines which store + individual registers, this doesn't need to do anything. On + machines which store all the registers in one fell swoop, this + makes sure that registers contains all the registers from the + program being debugged. */ + +static void +inf_ptrace_prepare_to_store (void) +{ +} + +/* Print status information about what we're accessing. */ + +static void +inf_ptrace_files_info (struct target_ops *ignore) +{ + printf_unfiltered ("\tUsing the running image of %s %s.\n", + attach_flag ? "attached" : "child", + target_pid_to_str (inferior_ptid)); +} + +static void +inf_ptrace_open (char *arg, int from_tty) +{ + error ("Use the \"run\" command to start a Unix child process."); +} + +/* Stub function which causes the inferior that runs it, to be ptrace-able + by its parent process. */ + +static void +inf_ptrace_me (void) +{ + /* "Trace me, Dr. Memory!" */ + call_ptrace (0, 0, (PTRACE_TYPE_ARG3) 0, 0); +} + +/* Stub function which causes the GDB that runs it, to start ptrace-ing + the child process. */ + +static void +inf_ptrace_him (int pid) +{ + push_target (ptrace_ops_hack); + + /* On some targets, there must be some explicit synchronization + between the parent and child processes after the debugger + forks, and before the child execs the debuggee program. This + call basically gives permission for the child to exec. + */ + + target_acknowledge_created_inferior (pid); + + /* START_INFERIOR_TRAPS_EXPECTED is defined in inferior.h, + * and will be 1 or 2 depending on whether we're starting + * without or with a shell. + */ + startup_inferior (START_INFERIOR_TRAPS_EXPECTED); + + /* On some targets, there must be some explicit actions taken after + the inferior has been started up. + */ + target_post_startup_inferior (pid_to_ptid (pid)); +} + +/* Start an inferior Unix child process and sets inferior_ptid to its + pid. EXEC_FILE is the file to run. ALLARGS is a string containing + the arguments to the program. ENV is the environment vector to + pass. Errors reported with error(). */ + +static void +inf_ptrace_create_inferior (char *exec_file, char *allargs, char **env, + int from_tty) +{ + fork_inferior (exec_file, allargs, env, inf_ptrace_me, inf_ptrace_him, + NULL, NULL); + /* We are at the first instruction we care about. */ + observer_notify_inferior_created (¤t_target, from_tty); + /* Pedal to the metal... */ + proceed ((CORE_ADDR) -1, TARGET_SIGNAL_0, 0); +} + +static void +inf_ptrace_post_startup_inferior (ptid_t ptid) +{ + /* This version of Unix doesn't require a meaningful "post startup inferior" + operation by a debugger. + */ +} + +static void +inf_ptrace_acknowledge_created_inferior (int pid) +{ + /* This version of Unix doesn't require a meaningful "acknowledge created inferior" + operation by a debugger. + */ +} + +static int +inf_ptrace_insert_fork_catchpoint (int pid) +{ + /* This version of Unix doesn't support notification of fork events. */ + return 0; +} + +static int +inf_ptrace_remove_fork_catchpoint (int pid) +{ + /* This version of Unix doesn't support notification of fork events. */ + return 0; +} + +static int +inf_ptrace_insert_vfork_catchpoint (int pid) +{ + /* This version of Unix doesn't support notification of vfork events. */ + return 0; +} + +static int +inf_ptrace_remove_vfork_catchpoint (int pid) +{ + /* This version of Unix doesn't support notification of vfork events. */ + return 0; +} + +static int +inf_ptrace_follow_fork (int follow_child) +{ + /* This version of Unix doesn't support following fork or vfork events. */ + return 0; +} + +static int +inf_ptrace_insert_exec_catchpoint (int pid) +{ + /* This version of Unix doesn't support notification of exec events. */ + return 0; +} + +static int +inf_ptrace_remove_exec_catchpoint (int pid) +{ + /* This version of Unix doesn't support notification of exec events. */ + return 0; +} + +static int +inf_ptrace_reported_exec_events_per_exec_call (void) +{ + /* This version of Unix doesn't support notification of exec events. + */ + return 1; +} + +static int +inf_ptrace_has_exited (int pid, int wait_status, int *exit_status) +{ + if (WIFEXITED (wait_status)) + { + *exit_status = WEXITSTATUS (wait_status); + return 1; + } + + if (WIFSIGNALED (wait_status)) + { + *exit_status = 0; /* ?? Don't know what else to say here. */ + return 1; + } + + /* ?? Do we really need to consult the event state, too? Assume the + wait_state alone suffices. + */ + return 0; +} + +static void +inf_ptrace_mourn_inferior (void) +{ + unpush_target (ptrace_ops_hack); + generic_mourn_inferior (); +} + +static int +inf_ptrace_can_run (void) +{ + return 1; +} + +/* Send a SIGINT to the process group. This acts just like the user + typed a ^C on the controlling terminal. + + XXX - This may not be correct for all systems. Some may want to + use killpg() instead of kill (-pgrp). */ + +static void +inf_ptrace_stop (void) +{ + kill (-inferior_process_group, SIGINT); +} + +/* Perform a partial transfer to/from the specified object. For + memory transfers, fall back to the old memory xfer functions. */ + +static LONGEST +inf_ptrace_xfer_partial (struct target_ops *ops, enum target_object object, + const char *annex, void *readbuf, + const void *writebuf, ULONGEST offset, LONGEST len) +{ + switch (object) + { + case TARGET_OBJECT_MEMORY: + if (readbuf) + return inf_ptrace_xfer_memory (offset, readbuf, len, 0 /*write */ , + NULL, ops); + if (writebuf) + return inf_ptrace_xfer_memory (offset, readbuf, len, 1 /*write */ , + NULL, ops); + return -1; + + case TARGET_OBJECT_UNWIND_TABLE: + return -1; + + case TARGET_OBJECT_AUXV: + return -1; + + case TARGET_OBJECT_WCOOKIE: + return -1; + + default: + return -1; + } +} + +static char * +inf_ptrace_pid_to_str (ptid_t ptid) +{ + return normal_pid_to_str (ptid); +} + +struct target_ops * +inf_ptrace_target (void) +{ + struct target_ops *t = inf_child_target (); + t->to_open = inf_ptrace_open; + t->to_attach = inf_ptrace_attach; + t->to_post_attach = inf_ptrace_post_attach; + t->to_detach = inf_ptrace_detach; + t->to_resume = inf_ptrace_resume; + t->to_wait = inf_ptrace_wait; + t->to_post_wait = inf_ptrace_post_wait; + t->to_prepare_to_store = inf_ptrace_prepare_to_store; + t->to_xfer_memory = inf_ptrace_xfer_memory; + t->to_xfer_partial = inf_ptrace_xfer_partial; + t->to_files_info = inf_ptrace_files_info; + t->to_kill = inf_ptrace_kill_inferior; + t->to_create_inferior = inf_ptrace_create_inferior; + t->to_post_startup_inferior = inf_ptrace_post_startup_inferior; + t->to_acknowledge_created_inferior = + inf_ptrace_acknowledge_created_inferior; + t->to_insert_fork_catchpoint = inf_ptrace_insert_fork_catchpoint; + t->to_remove_fork_catchpoint = inf_ptrace_remove_fork_catchpoint; + t->to_insert_vfork_catchpoint = inf_ptrace_insert_vfork_catchpoint; + t->to_remove_vfork_catchpoint = inf_ptrace_remove_vfork_catchpoint; + t->to_follow_fork = inf_ptrace_follow_fork; + t->to_insert_exec_catchpoint = inf_ptrace_insert_exec_catchpoint; + t->to_remove_exec_catchpoint = inf_ptrace_remove_exec_catchpoint; + t->to_reported_exec_events_per_exec_call = + inf_ptrace_reported_exec_events_per_exec_call; + t->to_has_exited = inf_ptrace_has_exited; + t->to_mourn_inferior = inf_ptrace_mourn_inferior; + t->to_can_run = inf_ptrace_can_run; + t->to_thread_alive = inf_ptrace_thread_alive; + t->to_pid_to_str = inf_ptrace_pid_to_str; + t->to_stop = inf_ptrace_stop; + t->to_stratum = process_stratum; + t->to_has_all_memory = 1; + t->to_has_memory = 1; + t->to_has_stack = 1; + t->to_has_registers = 1; + t->to_has_execution = 1; + t->to_magic = OPS_MAGIC; + ptrace_ops_hack = t; + return t; +} + +#if defined (KERNEL_U_SIZE) +/* Adding support for this command is easy. Typically you just add a + routine, called "kernel_u_size" that returns the size of the user + struct, to the appropriate *-nat.c file and then add to the native + config file "#define KERNEL_U_SIZE kernel_u_size()" */ +static void +udot_info (char *dummy1, int dummy2) +{ + long udot_off; /* Offset into user struct */ + int udot_val; /* Value from user struct at udot_off */ + char mess[128]; /* For messages */ + + if (!target_has_execution) + error ("The program is not being run."); + + for (udot_off = 0; udot_off < KERNEL_U_SIZE; udot_off += sizeof (udot_val)) + { + if ((udot_off % 24) == 0) + { + if (udot_off > 0) + { + printf_filtered ("\n"); + } + printf_filtered ("%s:", paddr (udot_off)); + } + udot_val = ptrace (PT_READ_U, PIDGET (inferior_ptid), + (PTRACE_TYPE_ARG3) udot_off, 0); + if (errno != 0) + { + sprintf (mess, "\nreading user struct at offset 0x%s", + paddr_nz (udot_off)); + perror_with_name (mess); + } + /* Avoid using nonportable (?) "*" in print specs */ + printf_filtered (sizeof (int) == 4 ? " 0x%08x" : " 0x%16x", udot_val); + } + printf_filtered ("\n"); + +} +#endif + +extern void _initialize_infptrace (void); + +void +_initialize_inf_ptrace (void) +{ +#if defined (KERNEL_U_AREA) + add_info ("udot", udot_info, + "Print contents of kernel ``struct user'' for current child."); +#endif + add_setshow_zinteger_cmd ("inf-ptrace", class_maintenance, &debug_inf_ptrace, "\ +Set ptrace target debugging.\n", "\ +Show ptrace target debugging.\n", "\ +When non-zero, target debugging is enabled. Higher numbers are more\n\ +verbose. Changes do not take effect until the next \"run\" or \"target\"\n\ +command.", " +Ptrace target debugging is %s.", + NULL, NULL, &setdebuglist, &showdebuglist); + +} Index: inf-ptrace.h =================================================================== RCS file: inf-ptrace.h diff -N inf-ptrace.h --- /dev/null 1 Jan 1970 00:00:00 -0000 +++ inf-ptrace.h 5 Sep 2004 13:46:02 -0000 @@ -0,0 +1,31 @@ +/* Low level Unix child interface to ptrace, for GDB when running + under Unix. + + Copyright 2004 Free Software Foundation, Inc. + + 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. */ + +#ifndef INF_PTRACE_H +#define INF_PTRACE_H + +/* Create a prototype ptrace target. The client can override it with + local methods. */ + +extern struct target_ops *inf_ptrace_target (void); + +#endif Index: ppcnbsd-nat.c =================================================================== RCS file: /cvs/src/src/gdb/ppcnbsd-nat.c,v retrieving revision 1.17 diff -p -u -r1.17 ppcnbsd-nat.c --- ppcnbsd-nat.c 14 Aug 2004 23:37:04 -0000 1.17 +++ ppcnbsd-nat.c 5 Sep 2004 13:46:02 -0000 @@ -35,6 +35,8 @@ #include "ppc-tdep.h" #include "ppcnbsd-tdep.h" +#include "inf-ptrace.h" + /* Returns true if PT_GETREGS fetches this register. */ static int getregs_supplies (int regno) @@ -73,8 +75,8 @@ getfpregs_supplies (int regno) || regno == tdep->ppc_fpscr_regnum); } -void -fetch_inferior_registers (int regno) +static void +ppcnbsd_fetch_inferior_registers (int regno) { if (regno == -1 || getregs_supplies (regno)) { @@ -103,8 +105,8 @@ fetch_inferior_registers (int regno) } } -void -store_inferior_registers (int regno) +static void +ppcnbsd_store_inferior_registers (int regno) { if (regno == -1 || getregs_supplies (regno)) { @@ -177,6 +179,12 @@ void _initialize_ppcnbsd_nat (void); void _initialize_ppcnbsd_nat (void) { + struct target_ops *t; /* Support debugging kernel virtual memory images. */ bsd_kvm_add_target (ppcnbsd_supply_pcb); + /* Add in local overrides. */ + t = inf_ptrace_target (); + t->to_fetch_registers = ppcnbsd_fetch_inferior_registers; + t->to_store_registers = ppcnbsd_store_inferior_registers; + add_target (t); } Index: config/powerpc/nbsd.mh =================================================================== RCS file: /cvs/src/src/gdb/config/powerpc/nbsd.mh,v retrieving revision 1.13 diff -p -u -r1.13 nbsd.mh --- config/powerpc/nbsd.mh 3 Sep 2004 19:08:20 -0000 1.13 +++ config/powerpc/nbsd.mh 5 Sep 2004 13:46:03 -0000 @@ -1,5 +1,5 @@ # Host: PowerPC, running NetBSD -NATDEPFILES= fork-child.o infptrace.o inftarg.o ppcnbsd-nat.o bsd-kvm.o +NATDEPFILES= fork-child.o inf-child.o inf-ptrace.o ppcnbsd-nat.o bsd-kvm.o NAT_FILE= config/nm-nbsd.h LOADLIBES= -lkvm Index: Makefile.in =================================================================== RCS file: /cvs/src/src/gdb/Makefile.in,v retrieving revision 1.613 diff -p -u -r1.613 Makefile.in --- Makefile.in 1 Sep 2004 18:00:27 -0000 1.613 +++ Makefile.in 5 Sep 2004 13:46:02 -0000 @@ -703,9 +703,11 @@ i386_tdep_h = i386-tdep.h i387_tdep_h = i387-tdep.h ia64_tdep_h = ia64-tdep.h infcall_h = infcall.h +inf_child_h = inf-child.h inferior_h = inferior.h $(breakpoint_h) $(target_h) $(frame_h) inf_loop_h = inf-loop.h inflow_h = inflow.h $(terminal_h) +inf_ptrace_h = inf-ptrace.h infttrace_h = infttrace.h interps_h = interps.h jv_lang_h = jv-lang.h @@ -1718,11 +1720,11 @@ breakpoint.o: breakpoint.c $(defs_h) $(s $(command_h) $(inferior_h) $(gdbthread_h) $(target_h) $(language_h) \ $(gdb_string_h) $(demangle_h) $(annotate_h) $(symfile_h) \ $(objfiles_h) $(source_h) $(linespec_h) $(completer_h) $(gdb_h) \ - $(ui_out_h) $(cli_script_h) $(gdb_assert_h) $(block_h) \ - $(gdb_events_h) $(observer_h) $(solist_h) + $(ui_out_h) $(cli_script_h) $(gdb_assert_h) $(block_h) $(solist_h) \ + $(observer_h) $(gdb_events_h) bsd-kvm.o: bsd-kvm.c $(defs_h) $(cli_cmds_h) $(command_h) $(frame_h) \ - $(regcache_h) $(target_h) $(value_h) $(gdb_assert_h) $(readline_h) \ - $(bsd_kvm_h) + $(regcache_h) $(target_h) $(value_h) $(gdbcore_h) $(gdb_assert_h) \ + $(readline_h) $(bsd_kvm_h) buildsym.o: buildsym.c $(defs_h) $(bfd_h) $(gdb_obstack_h) $(symtab_h) \ $(symfile_h) $(objfiles_h) $(gdbtypes_h) $(gdb_assert_h) \ $(complaints_h) $(gdb_string_h) $(expression_h) $(language_h) \ @@ -2038,6 +2040,8 @@ infcall.o: infcall.c $(defs_h) $(breakpo $(inferior_h) $(gdb_assert_h) $(block_h) $(gdbcore_h) $(language_h) \ $(objfiles_h) $(gdbcmd_h) $(command_h) $(gdb_string_h) $(infcall_h) \ $(dummy_frame_h) +inf-child.o: inf-child.c $(defs_h) $(regcache_h) $(memattr_h) $(symtab_h) \ + $(target_h) $(inferior_h) infcmd.o: infcmd.c $(defs_h) $(gdb_string_h) $(symtab_h) $(gdbtypes_h) \ $(frame_h) $(inferior_h) $(environ_h) $(value_h) $(gdbcmd_h) \ $(symfile_h) $(gdbcore_h) $(target_h) $(language_h) $(symfile_h) \ @@ -2049,6 +2053,9 @@ inf-loop.o: inf-loop.c $(defs_h) $(infer inflow.o: inflow.c $(defs_h) $(frame_h) $(inferior_h) $(command_h) \ $(serial_h) $(terminal_h) $(target_h) $(gdbthread_h) $(gdb_string_h) \ $(inflow_h) +inf-ptrace.o: inf-ptrace.c $(defs_h) $(observer_h) $(gdb_ptrace_h) \ + $(inflow_h) $(inferior_h) $(regcache_h) $(command_h) $(gdbcore_h) \ + $(inf_child_h) $(gdbcmd_h) infptrace.o: infptrace.c $(defs_h) $(command_h) $(frame_h) $(gdbcore_h) \ $(inferior_h) $(regcache_h) $(target_h) $(gdb_assert_h) \ $(gdb_wait_h) $(gdb_string_h) $(gdb_dirent_h) $(gdb_ptrace_h) @@ -2207,7 +2214,8 @@ mips-tdep.o: mips-tdep.c $(defs_h) $(gdb $(target_h) $(arch_utils_h) $(regcache_h) $(osabi_h) $(mips_tdep_h) \ $(block_h) $(reggroups_h) $(opcode_mips_h) $(elf_mips_h) \ $(elf_bfd_h) $(symcat_h) $(sim_regno_h) $(dis_asm_h) \ - $(frame_unwind_h) $(frame_base_h) $(trad_frame_h) $(infcall_h) + $(frame_unwind_h) $(frame_base_h) $(trad_frame_h) $(infcall_h) \ + $(floatformat_h) mipsv4-nat.o: mipsv4-nat.c $(defs_h) $(inferior_h) $(gdbcore_h) $(target_h) \ $(regcache_h) $(gregset_h) mn10300-tdep.o: mn10300-tdep.c $(defs_h) $(frame_h) $(inferior_h) \ @@ -2282,8 +2290,8 @@ ppc-linux-tdep.o: ppc-linux-tdep.c $(def $(objfiles_h) $(regcache_h) $(value_h) $(osabi_h) $(regset_h) \ $(solib_svr4_h) $(ppc_tdep_h) $(trad_frame_h) $(frame_unwind_h) ppcnbsd-nat.o: ppcnbsd-nat.c $(defs_h) $(inferior_h) $(gdb_assert_h) \ - $(ppc_tdep_h) $(ppcnbsd_tdep_h) $(gdbcore.h) $(regcache_h) \ - $(bsd_kvm_h) + $(gdbcore_h) $(regcache_h) $(bsd_kvm_h) $(ppc_tdep_h) \ + $(ppcnbsd_tdep_h) $(inf_ptrace_h) ppcnbsd-tdep.o: ppcnbsd-tdep.c $(defs_h) $(gdbcore_h) $(regcache_h) \ $(target_h) $(breakpoint_h) $(value_h) $(osabi_h) $(ppc_tdep_h) \ $(ppcnbsd_tdep_h) $(nbsd_tdep_h) $(tramp_frame_h) $(trad_frame_h) \ @@ -2451,8 +2459,8 @@ solib-aix5.o: solib-aix5.c $(defs_h) $(g solib.o: solib.c $(defs_h) $(gdb_string_h) $(symtab_h) $(bfd_h) $(symfile_h) \ $(objfiles_h) $(gdbcore_h) $(command_h) $(target_h) $(frame_h) \ $(gdb_regex_h) $(inferior_h) $(environ_h) $(language_h) $(gdbcmd_h) \ - $(completer_h) $(filenames_h) $(exec_h) $(solist_h) $(readline_h) \ - $(observer_h) + $(completer_h) $(filenames_h) $(exec_h) $(solist_h) $(observer_h) \ + $(readline_h) solib-frv.o: solib-frv.c $(defs_h) $(gdb_string_h) $(inferior_h) \ $(gdbcore_h) $(solist_h) $(frv_tdep_h) $(objfiles_h) $(symtab_h) \ $(language_h) $(command_h) $(gdbcmd_h) $(elf_frv_h) @@ -2639,9 +2647,9 @@ varobj.o: varobj.c $(defs_h) $(value_h) $(language_h) $(wrapper_h) $(gdbcmd_h) $(gdb_string_h) $(varobj_h) vaxbsd-nat.o: vaxbsd-nat.c $(defs_h) $(inferior_h) $(regcache_h) \ $(vax_tdep_h) $(bsd_kvm_h) +vax-nat.o: vax-nat.c $(defs_h) $(inferior_h) $(gdb_assert_h) $(vax_tdep_h) vaxnbsd-tdep.o: vaxnbsd-tdep.c $(defs_h) $(arch_utils_h) $(osabi_h) \ $(vax_tdep_h) $(solib_svr4_h) $(gdb_string_h) -vax-nat.o: vax-nat.c $(defs_h) $(inferior_h) $(gdb_assert_h) $(vax_tdep_h) vax-tdep.o: vax-tdep.c $(defs_h) $(arch_utils_h) $(dis_asm_h) $(frame_h) \ $(frame_base_h) $(frame_unwind_h) $(gdbcore_h) $(gdbtypes_h) \ $(osabi_h) $(regcache_h) $(regset_h) $(trad_frame_h) $(value_h) \ --------------010005000104010805020306--