Replace <sys/dir.h> (and <dirent.h>) with "gdb_dirent.h".

[deliverable/binutils-gdb.git] / gdb / infptrace.c

diff --git a/gdb/infptrace.c b/gdb/infptrace.c
index 52461579cbb16f2017d9f21fcbfb8485e9f48687..0a74b5d63a4892692930dbfaffe06679688f0eb5 100644 (file)
--- a/gdb/infptrace.c
+++ b/gdb/infptrace.c
@@ -1,50 +1,78 @@
 /* Low level Unix child interface to ptrace, for GDB when running under Unix.
 /* Low level Unix child interface to ptrace, for GDB when running under Unix.

-   Copyright 1988, 1989, 1990, 1991, 1992 Free Software Foundation, Inc.
+   Copyright 1988, 89, 90, 91, 92, 93, 94, 95, 96, 1998 
+   Free Software Foundation, Inc.

 
 

-This file is part of GDB.
+   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 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.
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.

 
 

-You should have received a copy of the GNU General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
+   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 "frame.h"
 #include "inferior.h"
 #include "target.h"
 
 #include "defs.h"
 #include "frame.h"
 #include "inferior.h"
 #include "target.h"

+#include "gdb_string.h"
+
+#include "gdb_wait.h"
+
+#include "command.h"

 
 #ifdef USG
 #include <sys/types.h>
 #endif
 
 #include <sys/param.h>
 
 #ifdef USG
 #include <sys/types.h>
 #endif
 
 #include <sys/param.h>

-#include <sys/dir.h>
+#include "gdb_dirent.h"

 #include <signal.h>
 #include <sys/ioctl.h>
 #include <signal.h>
 #include <sys/ioctl.h>

-#ifndef USG
+
+#ifdef HAVE_PTRACE_H
+#include <ptrace.h>
+#else
+#ifdef HAVE_SYS_PTRACE_H

 #include <sys/ptrace.h>
 #endif
 #include <sys/ptrace.h>
 #endif

+#endif

 
 

+#if !defined (PT_READ_I)
+#define PT_READ_I      1       /* Read word from text space */
+#endif
+#if !defined (PT_READ_D)
+#define        PT_READ_D       2       /* Read word from data space */
+#endif
+#if !defined (PT_READ_U)
+#define PT_READ_U      3       /* Read word from kernel user struct */
+#endif
+#if !defined (PT_WRITE_I)
+#define PT_WRITE_I     4       /* Write word to text space */
+#endif
+#if !defined (PT_WRITE_D)
+#define PT_WRITE_D     5       /* Write word to data space */
+#endif
+#if !defined (PT_WRITE_U)
+#define PT_WRITE_U     6       /* Write word to kernel user struct */
+#endif
+#if !defined (PT_CONTINUE)
+#define PT_CONTINUE    7       /* Continue after signal */
+#endif
+#if !defined (PT_STEP)
+#define PT_STEP                9       /* Set flag for single stepping */
+#endif

 #if !defined (PT_KILL)
 #if !defined (PT_KILL)

-#define PT_KILL 8
-#define PT_STEP 9
-#define PT_CONTINUE 7
-#define PT_READ_U 3
-#define PT_WRITE_U 6
-#define PT_READ_I 1
-#define        PT_READ_D 2
-#define PT_WRITE_I 4
-#define PT_WRITE_D 5
-#endif /* No PT_KILL.  */
+#define PT_KILL                8       /* Send child a SIGKILL signal */
+#endif

 
 #ifndef PT_ATTACH
 #define PT_ATTACH PTRACE_ATTACH
 
 #ifndef PT_ATTACH
 #define PT_ATTACH PTRACE_ATTACH


@@ -57,7 +85,12 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 #ifndef        NO_SYS_FILE
 #include <sys/file.h>
 #endif
 #ifndef        NO_SYS_FILE
 #include <sys/file.h>
 #endif

-#include <sys/stat.h>
+#if 0
+/* Don't think this is used anymore.  On the sequent (not sure whether it's
+   dynix or ptx or both), it is included unconditionally by sys/user.h and
+   not protected against multiple inclusion.  */
+#include "gdb_stat.h"
+#endif

 
 #if !defined (FETCH_INFERIOR_REGISTERS)
 #include <sys/user.h>          /* Probably need to poke the user structure */
 
 #if !defined (FETCH_INFERIOR_REGISTERS)
 #include <sys/user.h>          /* Probably need to poke the user structure */


@@ -66,7 +99,35 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 #endif /* KERNEL_U_ADDR_BSD.  */
 #endif /* !FETCH_INFERIOR_REGISTERS */
 
 #endif /* KERNEL_U_ADDR_BSD.  */
 #endif /* !FETCH_INFERIOR_REGISTERS */
 

+#if !defined (CHILD_XFER_MEMORY)
+static void udot_info PARAMS ((char *, int));
+#endif
+
+#if !defined (FETCH_INFERIOR_REGISTERS)
+static void fetch_register PARAMS ((int));
+static void store_register PARAMS ((int));
+#endif
+
+/*
+ * Some systems (Linux) may have threads implemented as pseudo-processes, 
+ * in which case we may be tracing more than one process at a time.
+ * In that case, inferior_pid will contain the main process ID and the 
+ * individual thread (process) id mashed together.  These macros are 
+ * used to separate them out.  The definitions may be overridden in tm.h
+ *
+ * NOTE: default definitions here are for systems with no threads.
+ * Useful definitions MUST be provided in tm.h
+ */
+
+#if !defined (PIDGET)  /* Default definition for PIDGET/TIDGET.  */
+#define PIDGET(PID)    PID
+#define TIDGET(PID)    0
+#endif
+
+void _initialize_kernel_u_addr PARAMS ((void));
+void _initialize_infptrace PARAMS ((void));

 \f
 \f

+

 /* This function simply calls ptrace with the given arguments.  
    It exists so that all calls to ptrace are isolated in this 
    machine-dependent file. */
 /* This function simply calls ptrace with the given arguments.  
    It exists so that all calls to ptrace are isolated in this 
    machine-dependent file. */


@@ -76,70 +137,167 @@ call_ptrace (request, pid, addr, data)
      PTRACE_ARG3_TYPE addr;
      int data;
 {
      PTRACE_ARG3_TYPE addr;
      int data;
 {

-  return ptrace (request, pid, addr, data);
+  int pt_status = 0;
+
+#if 0
+  int saved_errno;
+
+  printf ("call_ptrace(request=%d, pid=%d, addr=0x%x, data=0x%x)",
+         request, pid, addr, data);
+#endif
+#if defined(PT_SETTRC)
+  /* If the parent can be told to attach to us, try to do it.  */
+  if (request == PT_SETTRC)
+    {
+      errno = 0;
+#if !defined (FIVE_ARG_PTRACE)
+      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 0
+      printf (" = %d\n", pt_status);
+#endif
+      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
+
+#if 0
+  saved_errno = errno;
+  errno = 0;
+#endif
+#if !defined (FIVE_ARG_PTRACE)
+  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 0
+  if (errno)
+    printf (" [errno = %d]", errno);
+
+  errno = saved_errno;
+  printf (" = 0x%x\n", pt_status);
+#endif
+  return pt_status;

 }
 
 }
 

-#ifdef DEBUG_PTRACE
+
+#if defined (DEBUG_PTRACE) || defined (FIVE_ARG_PTRACE)

 /* For the rest of the file, use an extra level of indirection */
 /* This lets us breakpoint usefully on call_ptrace. */
 #define ptrace call_ptrace
 #endif
 
 /* For the rest of the file, use an extra level of indirection */
 /* This lets us breakpoint usefully on call_ptrace. */
 #define ptrace call_ptrace
 #endif
 

-/* This is used when GDB is exiting.  It gives less chance of error.*/
+/* Wait for a process to finish, possibly running a target-specific
+   hook before returning.  */

 
 

-void
-kill_inferior_fast ()
+int
+ptrace_wait (pid, status)
+     int pid;
+     int *status;

 {
 {

-  if (inferior_pid == 0)
-    return;
-  ptrace (PT_KILL, inferior_pid, (PTRACE_ARG3_TYPE) 0, 0);
-  wait ((int *)0);
+  int wstate;
+
+  wstate = wait (status);
+  target_post_wait (wstate, *status);
+  return wstate;

 }
 
 void
 kill_inferior ()
 {
 }
 
 void
 kill_inferior ()
 {

-  kill_inferior_fast ();
+  int status;
+
+  if (inferior_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.  */
+  ptrace (PT_KILL, inferior_pid, (PTRACE_ARG3_TYPE) 0, 0);
+  ptrace_wait (0, &status);

   target_mourn_inferior ();
 }
 
   target_mourn_inferior ();
 }
 

+#ifndef CHILD_RESUME
+

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

-child_resume (step, signal)
+child_resume (pid, step, signal)
+     int pid;

      int step;
      int step;

-     int signal;
+     enum target_signal signal;

 {
   errno = 0;
 
 {
   errno = 0;
 

+  if (pid == -1)
+    /* Resume all threads.  */
+    /* I think this only gets used in the non-threaded case, where "resume
+       all threads" and "resume inferior_pid" are the same.  */
+    pid = inferior_pid;
+

   /* An address of (PTRACE_ARG3_TYPE)1 tells ptrace to continue from where
      it was.  (If GDB wanted it to start some other way, we have already
   /* An address of (PTRACE_ARG3_TYPE)1 tells ptrace to continue from where
      it was.  (If GDB wanted it to start some other way, we have already

-     written a new PC value to the child.)  */
+     written a new PC value to the child.)
+
+     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.  */

 
   if (step)
 
   if (step)

-#ifdef NO_SINGLE_STEP
-    single_step (signal);
-#else    
-    ptrace (PT_STEP, inferior_pid, (PTRACE_ARG3_TYPE) 1, signal);
-#endif
+    {
+      if (SOFTWARE_SINGLE_STEP_P)
+       abort ();               /* Make sure this doesn't happen. */
+      else
+       ptrace (PT_STEP, pid, (PTRACE_ARG3_TYPE) 1,
+               target_signal_to_host (signal));
+    }

   else
   else

-#ifdef AIX_BUGGY_PTRACE_CONTINUE
-    AIX_BUGGY_PTRACE_CONTINUE;
-#else
-    ptrace (PT_CONTINUE, inferior_pid, (PTRACE_ARG3_TYPE) 1, signal);
-#endif
+    ptrace (PT_CONTINUE, pid, (PTRACE_ARG3_TYPE) 1,
+           target_signal_to_host (signal));

 
   if (errno)
 
   if (errno)

-    perror_with_name ("ptrace");
+    {
+      perror_with_name ("ptrace");
+    }

 }
 }

+#endif /* CHILD_RESUME */

 \f
 \f

-#ifdef ATTACH_DETACH
-/* Nonzero if we are debugging an attached process rather than
-   an inferior.  */
-extern int attach_flag;

 
 

+#ifdef ATTACH_DETACH

 /* Start debugging the process whose number is PID.  */
 int
 attach (pid)
 /* Start debugging the process whose number is PID.  */
 int
 attach (pid)


@@ -169,17 +327,22 @@ detach (signal)
 }
 #endif /* ATTACH_DETACH */
 \f
 }
 #endif /* ATTACH_DETACH */
 \f

-#if !defined (FETCH_INFERIOR_REGISTERS)
+/* Default the type of the ptrace transfer to int.  */
+#ifndef PTRACE_XFER_TYPE
+#define PTRACE_XFER_TYPE int
+#endif

 
 /* KERNEL_U_ADDR is the amount to subtract from u.u_ar0
    to get the offset in the core file of the register values.  */
 
 /* KERNEL_U_ADDR is the amount to subtract from u.u_ar0
    to get the offset in the core file of the register values.  */

-#if defined (KERNEL_U_ADDR_BSD)
+#if defined (KERNEL_U_ADDR_BSD) && !defined (FETCH_INFERIOR_REGISTERS)

 /* Get kernel_u_addr using BSD-style nlist().  */
 CORE_ADDR kernel_u_addr;
 /* Get kernel_u_addr using BSD-style nlist().  */
 CORE_ADDR kernel_u_addr;

+#endif /* KERNEL_U_ADDR_BSD.  */

 
 void
 _initialize_kernel_u_addr ()
 {
 
 void
 _initialize_kernel_u_addr ()
 {

+#if defined (KERNEL_U_ADDR_BSD) && !defined (FETCH_INFERIOR_REGISTERS)

   struct nlist names[2];
 
   names[0].n_un.n_name = "_u";
   struct nlist names[2];
 
   names[0].n_un.n_name = "_u";


@@ -187,31 +350,11 @@ _initialize_kernel_u_addr ()
   if (nlist ("/vmunix", names) == 0)
     kernel_u_addr = names[0].n_value;
   else
   if (nlist ("/vmunix", names) == 0)
     kernel_u_addr = names[0].n_value;
   else

-    fatal ("Unable to get kernel u area address.");
-}
+    internal_error ("Unable to get kernel u area address.");

 #endif /* KERNEL_U_ADDR_BSD.  */
 #endif /* KERNEL_U_ADDR_BSD.  */

-
-#if defined (KERNEL_U_ADDR_HPUX)
-/* Get kernel_u_addr using HPUX-style nlist().  */
-CORE_ADDR kernel_u_addr;
-
-struct hpnlist {      
-        char *          n_name;
-        long            n_value;  
-        unsigned char   n_type;   
-        unsigned char   n_length;  
-        short           n_almod;   
-        short           n_unused;
-};
-static struct hpnlist nl[] = {{ "_u", -1, }, { (char *) 0, }};
-
-/* read the value of the u area from the hp-ux kernel */
-void _initialize_kernel_u_addr ()
-{
-    nlist ("/hp-ux", &nl);
-    kernel_u_addr = nl[0].n_value;

 }
 }

-#endif /* KERNEL_U_ADDR_HPUX.  */
+
+#if !defined (FETCH_INFERIOR_REGISTERS)

 
 #if !defined (offsetof)
 #define offsetof(TYPE, MEMBER) ((unsigned long) &((TYPE *)0)->MEMBER)
 
 #if !defined (offsetof)
 #define offsetof(TYPE, MEMBER) ((unsigned long) &((TYPE *)0)->MEMBER)


@@ -236,33 +379,38 @@ static void
 fetch_register (regno)
      int regno;
 {
 fetch_register (regno)
      int regno;
 {

-  register unsigned int regaddr;
-  char buf[MAX_REGISTER_RAW_SIZE];
-  char mess[128];                              /* For messages */
+  /* This isn't really an address.  But ptrace thinks of it as one.  */
+  CORE_ADDR regaddr;
+  char mess[128];              /* For messages */

   register int i;
   register int i;

-
-  /* Offset of registers within the u area.  */
-  unsigned int offset;
+  unsigned int offset;         /* Offset of registers within the u area.  */
+  char buf[MAX_REGISTER_RAW_SIZE];
+  int tid;

 
   if (CANNOT_FETCH_REGISTER (regno))
     {
 
   if (CANNOT_FETCH_REGISTER (regno))
     {

-      bzero (buf, REGISTER_RAW_SIZE (regno));  /* Supply zeroes */
+      memset (buf, '\0', REGISTER_RAW_SIZE (regno));   /* Supply zeroes */

       supply_register (regno, buf);
       return;
     }
 
       supply_register (regno, buf);
       return;
     }
 

+  /* Overload thread id onto process id */
+  if ((tid = TIDGET (inferior_pid)) == 0)
+    tid = inferior_pid;                /* no thread id, just use process id */
+

   offset = U_REGS_OFFSET;
 
   regaddr = register_addr (regno, offset);
   offset = U_REGS_OFFSET;
 
   regaddr = register_addr (regno, offset);

-  for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (int))
+  for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (PTRACE_XFER_TYPE))

     {
       errno = 0;
     {
       errno = 0;

-      *(int *) &buf[i] = ptrace (PT_READ_U, inferior_pid,
-                                (PTRACE_ARG3_TYPE) regaddr, 0);
-      regaddr += sizeof (int);
+      *(PTRACE_XFER_TYPE *) & buf[i] = ptrace (PT_READ_U, tid,
+                                              (PTRACE_ARG3_TYPE) regaddr, 0);
+      regaddr += sizeof (PTRACE_XFER_TYPE);

       if (errno != 0)
        {
       if (errno != 0)
        {

-         sprintf (mess, "reading register %s (#%d)", reg_names[regno], regno);
+         sprintf (mess, "reading register %s (#%d)", 
+                  REGISTER_NAME (regno), regno);

          perror_with_name (mess);
        }
     }
          perror_with_name (mess);
        }
     }


@@ -270,17 +418,25 @@ fetch_register (regno)
 }
 
 
 }
 
 

-/* Fetch all registers, or just one, from the child process.  */
+/* Fetch register values from the inferior.
+   If REGNO is negative, do this for all registers.
+   Otherwise, REGNO specifies which register (so we can save time). */

 
 void
 fetch_inferior_registers (regno)
      int regno;
 {
 
 void
 fetch_inferior_registers (regno)
      int regno;
 {

-  if (regno == -1)
-    for (regno = 0; regno < NUM_REGS; regno++)
+  if (regno >= 0)
+    {

       fetch_register (regno);
       fetch_register (regno);

+    }

   else
   else

-    fetch_register (regno);
+    {
+      for (regno = 0; regno < ARCH_NUM_REGS; regno++)
+       {
+         fetch_register (regno);
+       }
+    }

 }
 
 /* Registers we shouldn't try to store.  */
 }
 
 /* Registers we shouldn't try to store.  */


@@ -288,61 +444,70 @@ fetch_inferior_registers (regno)
 #define CANNOT_STORE_REGISTER(regno) 0
 #endif
 
 #define CANNOT_STORE_REGISTER(regno) 0
 #endif
 

-/* Store our register values back into the inferior.
-   If REGNO is -1, do this for all registers.
-   Otherwise, REGNO specifies which register (so we can save time).  */
+/* Store one register. */

 
 

-void
-store_inferior_registers (regno)
+static void
+store_register (regno)

      int regno;
 {
      int regno;
 {

-  register unsigned int regaddr;
-  char buf[80];
-  extern char registers[];
+  /* This isn't really an address.  But ptrace thinks of it as one.  */
+  CORE_ADDR regaddr;
+  char mess[128];              /* For messages */

   register int i;
   register int i;

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

 
 

-  unsigned int offset = U_REGS_OFFSET;
+  if (CANNOT_STORE_REGISTER (regno))
+    {
+      return;
+    }

 
 

-  if (regno >= 0)
+  /* Overload thread id onto process id */
+  if ((tid = TIDGET (inferior_pid)) == 0)
+    tid = inferior_pid;                /* no thread id, just use process id */
+
+  offset = U_REGS_OFFSET;
+
+  regaddr = register_addr (regno, offset);
+  for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (PTRACE_XFER_TYPE))

     {
     {

-      regaddr = register_addr (regno, offset);
-      for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof(int))
+      errno = 0;
+      ptrace (PT_WRITE_U, tid, (PTRACE_ARG3_TYPE) regaddr,
+             *(PTRACE_XFER_TYPE *) & registers[REGISTER_BYTE (regno) + i]);
+      regaddr += sizeof (PTRACE_XFER_TYPE);
+      if (errno != 0)

        {
        {

-         errno = 0;
-         ptrace (PT_WRITE_U, inferior_pid, (PTRACE_ARG3_TYPE) regaddr,
-                 *(int *) &registers[REGISTER_BYTE (regno) + i]);
-         if (errno != 0)
-           {
-             sprintf (buf, "writing register number %d(%d)", regno, i);
-             perror_with_name (buf);
-           }
-         regaddr += sizeof(int);
+         sprintf (mess, "writing register %s (#%d)", 
+                  REGISTER_NAME (regno), regno);
+         perror_with_name (mess);

        }
     }
        }
     }

+}
+
+/* Store our register values back into the inferior.
+   If REGNO is negative, do this for all registers.
+   Otherwise, REGNO specifies which register (so we can save time).  */
+
+void
+store_inferior_registers (regno)
+     int regno;
+{
+  if (regno >= 0)
+    {
+      store_register (regno);
+    }

   else
     {
   else
     {

-      for (regno = 0; regno < NUM_REGS; regno++)
+      for (regno = 0; regno < ARCH_NUM_REGS; regno++)

        {
        {

-         if (CANNOT_STORE_REGISTER (regno))
-           continue;
-         regaddr = register_addr (regno, offset);
-         for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof(int))
-           {
-             errno = 0;
-             ptrace (PT_WRITE_U, inferior_pid, (PTRACE_ARG3_TYPE) regaddr,
-                     *(int *) &registers[REGISTER_BYTE (regno) + i]);
-             if (errno != 0)
-               {
-                 sprintf (buf, "writing register number %d(%d)", regno, i);
-                 perror_with_name (buf);
-               }
-             regaddr += sizeof(int);
-           }
+         store_register (regno);

        }
     }
 }
 #endif /* !defined (FETCH_INFERIOR_REGISTERS).  */
 \f
        }
     }
 }
 #endif /* !defined (FETCH_INFERIOR_REGISTERS).  */
 \f

+
+#if !defined (CHILD_XFER_MEMORY)

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


@@ -352,7 +517,7 @@ store_inferior_registers (regno)
 /* 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.
 /* Copy LEN bytes to or from inferior's memory starting at MEMADDR
    to debugger memory starting at MYADDR.   Copy to inferior if
    WRITE is nonzero.

-  
+

    Returns the length copied, which is either the LEN argument or zero.
    This xfer function does not do partial moves, since child_ops
    doesn't allow memory operations to cross below us in the target stack
    Returns the length copied, which is either the LEN argument or zero.
    This xfer function does not do partial moves, since child_ops
    doesn't allow memory operations to cross below us in the target stack


@@ -364,65 +529,74 @@ child_xfer_memory (memaddr, myaddr, len, write, target)
      char *myaddr;
      int len;
      int write;
      char *myaddr;
      int len;
      int write;

-     struct target_ops *target;                /* ignored */
+     struct target_ops *target;        /* ignored */

 {
   register int i;
   /* Round starting address down to longword boundary.  */
 {
   register int i;
   /* Round starting address down to longword boundary.  */

-  register CORE_ADDR addr = memaddr & - sizeof (int);
+  register CORE_ADDR addr = memaddr & -sizeof (PTRACE_XFER_TYPE);

   /* Round ending address up; get number of longwords that makes.  */
   register int count
   /* Round ending address up; get number of longwords that makes.  */
   register int count

-    = (((memaddr + len) - addr) + sizeof (int) - 1) / sizeof (int);
+  = (((memaddr + len) - addr) + sizeof (PTRACE_XFER_TYPE) - 1)
+  / sizeof (PTRACE_XFER_TYPE);

   /* Allocate buffer of that many longwords.  */
   /* Allocate buffer of that many longwords.  */

-  register int *buffer = (int *) alloca (count * sizeof (int));
+  register PTRACE_XFER_TYPE *buffer
+  = (PTRACE_XFER_TYPE *) alloca (count * sizeof (PTRACE_XFER_TYPE));

 
   if (write)
     {
       /* Fill start and end extra bytes of buffer with existing memory data.  */
 
 
   if (write)
     {
       /* Fill start and end extra bytes of buffer with existing memory data.  */
 

-      if (addr != memaddr || len < (int)sizeof (int)) {
-       /* Need part of initial word -- fetch it.  */
-        buffer[0] = ptrace (PT_READ_I, inferior_pid, (PTRACE_ARG3_TYPE) addr,
-                           0);
-      }
+      if (addr != memaddr || len < (int) sizeof (PTRACE_XFER_TYPE))
+       {
+         /* Need part of initial word -- fetch it.  */
+         buffer[0] = ptrace (PT_READ_I, PIDGET (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]
-           = ptrace (PT_READ_I, inferior_pid,
-                     (PTRACE_ARG3_TYPE) (addr + (count - 1) * sizeof (int)),
+         buffer[count - 1] 
+           = ptrace (PT_READ_I, PIDGET (inferior_pid),
+                     ((PTRACE_ARG3_TYPE)
+                      (addr + (count - 1) * sizeof (PTRACE_XFER_TYPE))),

                      0);
        }
 
       /* Copy data to be written over corresponding part of buffer */
 
                      0);
        }
 
       /* Copy data to be written over corresponding part of buffer */
 

-      bcopy (myaddr, (char *) buffer + (memaddr & (sizeof (int) - 1)), len);
+      memcpy ((char *) buffer + (memaddr & (sizeof (PTRACE_XFER_TYPE) - 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 (PTRACE_XFER_TYPE))

        {
          errno = 0;
        {
          errno = 0;

-         ptrace (PT_WRITE_D, inferior_pid, (PTRACE_ARG3_TYPE) addr,
-                 buffer[i]);
+         ptrace (PT_WRITE_D, PIDGET (inferior_pid), 
+                 (PTRACE_ARG3_TYPE) addr, buffer[i]);

          if (errno)
            {
              /* Using the appropriate one (I or D) is necessary for
          if (errno)
            {
              /* Using the appropriate one (I or D) is necessary for

-                Gould NP1, at least.  */
+                Gould NP1, at least.  */

              errno = 0;
              errno = 0;

-             ptrace (PT_WRITE_I, inferior_pid, (PTRACE_ARG3_TYPE) addr,
-                     buffer[i]);
+             ptrace (PT_WRITE_I, PIDGET (inferior_pid), 
+                     (PTRACE_ARG3_TYPE) addr, buffer[i]);

            }
          if (errno)
            return 0;
        }
            }
          if (errno)
            return 0;
        }

+#ifdef CLEAR_INSN_CACHE
+      CLEAR_INSN_CACHE ();
+#endif

     }
   else
     {
       /* Read all the longwords */
     }
   else
     {
       /* Read all the longwords */

-      for (i = 0; i < count; i++, addr += sizeof (int))
+      for (i = 0; i < count; i++, addr += sizeof (PTRACE_XFER_TYPE))

        {
          errno = 0;
        {
          errno = 0;

-         buffer[i] = ptrace (PT_READ_I, inferior_pid,
+         buffer[i] = ptrace (PT_READ_I, PIDGET (inferior_pid),

                              (PTRACE_ARG3_TYPE) addr, 0);
          if (errno)
            return 0;
                              (PTRACE_ARG3_TYPE) addr, 0);
          if (errno)
            return 0;


@@ -430,7 +604,71 @@ child_xfer_memory (memaddr, myaddr, len, write, target)
        }
 
       /* Copy appropriate bytes out of the buffer.  */
        }
 
       /* Copy appropriate bytes out of the buffer.  */

-      bcopy ((char *) buffer + (memaddr & (sizeof (int) - 1)), myaddr, len);
+      memcpy (myaddr,
+             (char *) buffer + (memaddr & (sizeof (PTRACE_XFER_TYPE) - 1)),
+             len);

     }
   return len;
 }
     }
   return len;
 }

+\f
+
+static void
+udot_info (dummy1, dummy2)
+     char *dummy1;
+     int dummy2;
+{
+#if defined (KERNEL_U_SIZE)
+  int udot_off;                        /* Offset into user struct */
+  int udot_val;                        /* Value from user struct at udot_off */
+  char mess[128];              /* For messages */
+#endif
+
+  if (!target_has_execution)
+    {
+      error ("The program is not being run.");
+    }
+
+#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()" */
+  error ("Don't know how large ``struct user'' is in this version of gdb.");
+
+#else
+
+  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 ("%04x:", udot_off);
+       }
+      udot_val = ptrace (PT_READ_U, inferior_pid, (PTRACE_ARG3_TYPE) udot_off, 0);
+      if (errno != 0)
+       {
+         sprintf (mess, "\nreading user struct at offset 0x%x", 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
+}
+#endif /* !defined (CHILD_XFER_MEMORY).  */
+\f
+
+void
+_initialize_infptrace ()
+{
+#if !defined (CHILD_XFER_MEMORY)
+  add_info ("udot", udot_info,
+           "Print contents of kernel ``struct user'' for current child.");
+#endif
+}