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 0013e91b97ce0292ed490cf3aaeb0c32523d2ec7..0a74b5d63a4892692930dbfaffe06679688f0eb5 100644 (file)
--- a/gdb/infptrace.c
+++ b/gdb/infptrace.c
@@ -1,22 +1,23 @@
 /* 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, 1993, 1994, 1995
+   Copyright 1988, 89, 90, 91, 92, 93, 94, 95, 96, 1998 

    Free Software Foundation, Inc.
 
    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 "defs.h"
 #include "frame.h"


@@ -24,37 +25,54 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 #include "target.h"
 #include "gdb_string.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 NO_PTRACE_H
-#ifdef PTRACE_IN_WRONG_PLACE
+#ifdef HAVE_PTRACE_H

 #include <ptrace.h>
 #else
 #include <ptrace.h>
 #else

+#ifdef HAVE_SYS_PTRACE_H

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

-#endif /* NO_PTRACE_H */
-
-#if !defined (PT_KILL)
-#define PT_KILL 8

 #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)
 #if !defined (PT_STEP)

-#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_STEP.  */
+#define PT_STEP                9       /* Set flag for single stepping */
+#endif
+#if !defined (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


@@ -81,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. */


@@ -91,34 +137,114 @@ call_ptrace (request, pid, addr, data)
      PTRACE_ARG3_TYPE addr;
      int data;
 {
      PTRACE_ARG3_TYPE addr;
      int data;
 {

-  return ptrace (request, pid, addr, data
-#if defined (FIVE_ARG_PTRACE)
-                /* Deal with HPUX 8.0 braindamage.  We never use the
-                   calls which require the fifth argument.  */
-                , 0
+  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
 #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;

 }
 
 }
 

+

 #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
 
 #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
 

+/* Wait for a process to finish, possibly running a target-specific
+   hook before returning.  */
+
+int
+ptrace_wait (pid, status)
+     int pid;
+     int *status;
+{
+  int wstate;
+
+  wstate = wait (status);
+  target_post_wait (wstate, *status);
+  return wstate;
+}
+

 void
 kill_inferior ()
 {
 void
 kill_inferior ()
 {

+  int status;
+

   if (inferior_pid == 0)
     return;
   if (inferior_pid == 0)
     return;

-  /* ptrace PT_KILL only works if process is stopped!!!  So stop it with
-     a real signal first, if we can.  FIXME: This is bogus.  When the inferior
-     is not stopped, GDB should just be waiting for it.  Either the following
-     line is unecessary, or there is some problem elsewhere in GDB which
-     causes us to get here when the inferior is not stopped.  */
-  kill (inferior_pid, SIGKILL);
+
+  /* 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 (PT_KILL, inferior_pid, (PTRACE_ARG3_TYPE) 0, 0);

-  wait ((int *)0);
+  ptrace_wait (0, &status);

   target_mourn_inferior ();
 }
 
   target_mourn_inferior ();
 }
 


@@ -152,18 +278,25 @@ child_resume (pid, step, signal)
      instructions), so we don't have to worry about that here.  */
 
   if (step)
      instructions), so we don't have to worry about that here.  */
 
   if (step)

-    ptrace (PT_STEP,     pid, (PTRACE_ARG3_TYPE) 1,
-           target_signal_to_host (signal));
+    {
+      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
     ptrace (PT_CONTINUE, pid, (PTRACE_ARG3_TYPE) 1,
            target_signal_to_host (signal));
 
   if (errno)
   else
     ptrace (PT_CONTINUE, pid, (PTRACE_ARG3_TYPE) 1,
            target_signal_to_host (signal));
 
   if (errno)

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

 }
 #endif /* CHILD_RESUME */
 }
 #endif /* CHILD_RESUME */

-

 \f
 \f

+

 #ifdef ATTACH_DETACH
 /* Start debugging the process whose number is PID.  */
 int
 #ifdef ATTACH_DETACH
 /* Start debugging the process whose number is PID.  */
 int


@@ -217,7 +350,7 @@ _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.  */
 }
 


@@ -248,12 +381,11 @@ fetch_register (regno)
 {
   /* This isn't really an address.  But ptrace thinks of it as one.  */
   CORE_ADDR regaddr;
 {
   /* This isn't really an address.  But ptrace thinks of it as one.  */
   CORE_ADDR regaddr;

-  char buf[MAX_REGISTER_RAW_SIZE];
-  char mess[128];                              /* For messages */
+  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))
     {


@@ -262,18 +394,23 @@ fetch_register (regno)
       return;
     }
 
       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);
   for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (PTRACE_XFER_TYPE))
     {
       errno = 0;
   offset = U_REGS_OFFSET;
 
   regaddr = register_addr (regno, offset);
   for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (PTRACE_XFER_TYPE))
     {
       errno = 0;

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

       regaddr += sizeof (PTRACE_XFER_TYPE);
       if (errno != 0)
        {
       regaddr += sizeof (PTRACE_XFER_TYPE);
       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);
        }
     }


@@ -281,22 +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;
 {

-  int numregs;
-
-  if (regno == -1)
+  if (regno >= 0)

     {
     {

-      numregs = ARCH_NUM_REGS;
-      for (regno = 0; regno < numregs; regno++)
-        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.  */


@@ -304,57 +444,63 @@ 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;
 {
   /* This isn't really an address.  But ptrace thinks of it as one.  */
   CORE_ADDR regaddr;
      int regno;
 {
   /* This isn't really an address.  But ptrace thinks of it as one.  */
   CORE_ADDR regaddr;

-  char buf[80];
-  register int i, numregs;
+  char mess[128];              /* For messages */
+  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(PTRACE_XFER_TYPE))
+      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,
-                 *(PTRACE_XFER_TYPE *) &registers[REGISTER_BYTE (regno) + i]);
-         if (errno != 0)
-           {
-             sprintf (buf, "writing register number %d(%d)", regno, i);
-             perror_with_name (buf);
-           }
-         regaddr += sizeof(PTRACE_XFER_TYPE);
+         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
     {

-      numregs = ARCH_NUM_REGS;
-      for (regno = 0; regno < numregs; 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(PTRACE_XFER_TYPE))
-           {
-             errno = 0;
-             ptrace (PT_WRITE_U, inferior_pid, (PTRACE_ARG3_TYPE) regaddr,
-                     *(PTRACE_XFER_TYPE *) &registers[REGISTER_BYTE (regno) + i]);
-             if (errno != 0)
-               {
-                 sprintf (buf, "writing register number %d(%d)", regno, i);
-                 perror_with_name (buf);
-               }
-             regaddr += sizeof(PTRACE_XFER_TYPE);
-           }
+         store_register (regno);

        }
     }
 }
        }
     }
 }


@@ -371,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


@@ -383,33 +529,34 @@ 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 (PTRACE_XFER_TYPE);
+  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 (PTRACE_XFER_TYPE) - 1)
-      / sizeof (PTRACE_XFER_TYPE);
+  = (((memaddr + len) - addr) + sizeof (PTRACE_XFER_TYPE) - 1)
+  / sizeof (PTRACE_XFER_TYPE);

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

-    = (PTRACE_XFER_TYPE *) alloca (count * sizeof (PTRACE_XFER_TYPE));
+  = (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 (PTRACE_XFER_TYPE)) {
-       /* 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,
+         buffer[count - 1] 
+           = ptrace (PT_READ_I, PIDGET (inferior_pid),

                      ((PTRACE_ARG3_TYPE)
                       (addr + (count - 1) * sizeof (PTRACE_XFER_TYPE))),
                      0);
                      ((PTRACE_ARG3_TYPE)
                       (addr + (count - 1) * sizeof (PTRACE_XFER_TYPE))),
                      0);


@@ -426,19 +573,22 @@ child_xfer_memory (memaddr, myaddr, len, write, target)
       for (i = 0; i < count; i++, addr += sizeof (PTRACE_XFER_TYPE))
        {
          errno = 0;
       for (i = 0; i < count; i++, addr += sizeof (PTRACE_XFER_TYPE))
        {
          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
     {
     }
   else
     {


@@ -446,7 +596,7 @@ child_xfer_memory (memaddr, myaddr, len, write, target)
       for (i = 0; i < count; i++, addr += sizeof (PTRACE_XFER_TYPE))
        {
          errno = 0;
       for (i = 0; i < count; i++, addr += sizeof (PTRACE_XFER_TYPE))
        {
          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;


@@ -460,4 +610,65 @@ child_xfer_memory (memaddr, myaddr, len, write, target)
     }
   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).  */
 #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
+}