* config/tc-sparc.c (initial_architecture,can_bump_v9_p): Deleted.

[binutils.git] / gdb / infptrace.c

diff --git a/gdb/infptrace.c b/gdb/infptrace.c
index f97d2c32f9805e9818380782900890f78dd4af4e..9f6e7fb2d78b99bcee56c7e39234d9ca42a8d62c 100644 (file)
--- a/gdb/infptrace.c
+++ b/gdb/infptrace.c
@@ -1,5 +1,5 @@
 /* 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, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996 Free Software Foundation, Inc.

 
 This file is part of GDB.
 
 
 This file is part of GDB.
 


@@ -15,14 +15,13 @@ 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
 
 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.  */
+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 "nm.h"
+#include "gdb_string.h"

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


@@ -33,23 +32,41 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 #include <signal.h>
 #include <sys/ioctl.h>
 
 #include <signal.h>
 #include <sys/ioctl.h>
 

+#ifndef NO_PTRACE_H

 #ifdef PTRACE_IN_WRONG_PLACE
 #include <ptrace.h>
 #else
 #include <sys/ptrace.h>
 #endif
 #ifdef PTRACE_IN_WRONG_PLACE
 #include <ptrace.h>
 #else
 #include <sys/ptrace.h>
 #endif

+#endif /* NO_PTRACE_H */

 
 

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


@@ -62,7 +79,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 */


@@ -81,10 +103,16 @@ call_ptrace (request, pid, addr, data)
      PTRACE_ARG3_TYPE addr;
      int data;
 {
      PTRACE_ARG3_TYPE addr;
      int data;
 {

-  return ptrace (request, pid, addr, 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
+#endif
+                );

 }
 
 }
 

-#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
 /* For the rest of the file, use an extra level of indirection */
 /* This lets us breakpoint usefully on call_ptrace. */
 #define ptrace call_ptrace


@@ -96,24 +124,36 @@ kill_inferior ()
   if (inferior_pid == 0)
     return;
   /* ptrace PT_KILL only works if process is stopped!!!  So stop it with
   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.  */
+     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);
   ptrace (PT_KILL, inferior_pid, (PTRACE_ARG3_TYPE) 0, 0);
   wait ((int *)0);
   target_mourn_inferior ();
 }
 
   kill (inferior_pid, SIGKILL);
   ptrace (PT_KILL, inferior_pid, (PTRACE_ARG3_TYPE) 0, 0);
   wait ((int *)0);
   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
      written a new PC value to the child.)
   /* 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.)


@@ -124,19 +164,19 @@ child_resume (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,     inferior_pid, (PTRACE_ARG3_TYPE) 1, signal);
+    ptrace (PT_STEP,     pid, (PTRACE_ARG3_TYPE) 1,
+           target_signal_to_host (signal));

   else
   else

-    ptrace (PT_CONTINUE, inferior_pid, (PTRACE_ARG3_TYPE) 1, signal);
+    ptrace (PT_CONTINUE, pid, (PTRACE_ARG3_TYPE) 1,
+           target_signal_to_host (signal));

 
   if (errno)
     perror_with_name ("ptrace");
 }
 
   if (errno)
     perror_with_name ("ptrace");
 }

+#endif /* CHILD_RESUME */
+

 \f
 #ifdef ATTACH_DETACH
 \f
 #ifdef ATTACH_DETACH

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

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


@@ -166,17 +206,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";


@@ -185,30 +230,10 @@ _initialize_kernel_u_addr ()
     kernel_u_addr = names[0].n_value;
   else
     fatal ("Unable to get kernel u area address.");
     kernel_u_addr = names[0].n_value;
   else
     fatal ("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)


@@ -233,7 +258,8 @@ static void
 fetch_register (regno)
      int regno;
 {
 fetch_register (regno)
      int regno;
 {

-  register unsigned int 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 */
   register int i;
   char buf[MAX_REGISTER_RAW_SIZE];
   char mess[128];                              /* For messages */
   register int i;


@@ -243,7 +269,7 @@ fetch_register (regno)
 
   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;
     }


@@ -251,12 +277,12 @@ fetch_register (regno)
   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, inferior_pid,
+                                             (PTRACE_ARG3_TYPE) regaddr, 0);
+      regaddr += sizeof (PTRACE_XFER_TYPE);

       if (errno != 0)
        {
          sprintf (mess, "reading register %s (#%d)", reg_names[regno], regno);
       if (errno != 0)
        {
          sprintf (mess, "reading register %s (#%d)", reg_names[regno], regno);


@@ -273,9 +299,14 @@ void
 fetch_inferior_registers (regno)
      int regno;
 {
 fetch_inferior_registers (regno)
      int regno;
 {

+  int numregs;
+

   if (regno == -1)
   if (regno == -1)

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

   else
     fetch_register (regno);
 }
   else
     fetch_register (regno);
 }


@@ -293,53 +324,56 @@ void
 store_inferior_registers (regno)
      int regno;
 {
 store_inferior_registers (regno)
      int regno;
 {

-  register unsigned int regaddr;
+  /* This isn't really an address.  But ptrace thinks of it as one.  */
+  CORE_ADDR regaddr;

   char buf[80];
   char buf[80];

-  extern char registers[];
-  register int i;
+  register int i, numregs;

 
   unsigned int offset = U_REGS_OFFSET;
 
   if (regno >= 0)
     {
       regaddr = register_addr (regno, offset);
 
   unsigned int offset = U_REGS_OFFSET;
 
   if (regno >= 0)
     {
       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;
          ptrace (PT_WRITE_U, inferior_pid, (PTRACE_ARG3_TYPE) regaddr,
        {
          errno = 0;
          ptrace (PT_WRITE_U, inferior_pid, (PTRACE_ARG3_TYPE) regaddr,

-                 *(int *) &registers[REGISTER_BYTE (regno) + i]);
+                 *(PTRACE_XFER_TYPE *) &registers[REGISTER_BYTE (regno) + i]);

          if (errno != 0)
            {
              sprintf (buf, "writing register number %d(%d)", regno, i);
              perror_with_name (buf);
            }
          if (errno != 0)
            {
              sprintf (buf, "writing register number %d(%d)", regno, i);
              perror_with_name (buf);
            }

-         regaddr += sizeof(int);
+         regaddr += sizeof(PTRACE_XFER_TYPE);

        }
     }
   else
     {
        }
     }
   else
     {

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

        {
          if (CANNOT_STORE_REGISTER (regno))
            continue;
          regaddr = register_addr (regno, offset);
        {
          if (CANNOT_STORE_REGISTER (regno))
            continue;
          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;
              ptrace (PT_WRITE_U, inferior_pid, (PTRACE_ARG3_TYPE) regaddr,
            {
              errno = 0;
              ptrace (PT_WRITE_U, inferior_pid, (PTRACE_ARG3_TYPE) regaddr,

-                     *(int *) &registers[REGISTER_BYTE (regno) + i]);
+                     *(PTRACE_XFER_TYPE *) &registers[REGISTER_BYTE (regno) + i]);

              if (errno != 0)
                {
                  sprintf (buf, "writing register number %d(%d)", regno, i);
                  perror_with_name (buf);
                }
              if (errno != 0)
                {
                  sprintf (buf, "writing register number %d(%d)", regno, i);
                  perror_with_name (buf);
                }

-             regaddr += sizeof(int);
+             regaddr += sizeof(PTRACE_XFER_TYPE);

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


@@ -365,18 +399,20 @@ child_xfer_memory (memaddr, myaddr, len, write, target)
 {
   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)) {
+      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);
        /* Need part of initial word -- fetch it.  */
         buffer[0] = ptrace (PT_READ_I, inferior_pid, (PTRACE_ARG3_TYPE) addr,
                            0);


@@ -386,17 +422,20 @@ child_xfer_memory (memaddr, myaddr, len, write, target)
        {
          buffer[count - 1]
            = ptrace (PT_READ_I, inferior_pid,
        {
          buffer[count - 1]
            = ptrace (PT_READ_I, inferior_pid,

-                     (PTRACE_ARG3_TYPE) (addr + (count - 1) * sizeof (int)),
+                     ((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 */
 

-      memcpy ((char *) buffer + (memaddr & (sizeof (int) - 1)), myaddr, 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;
          ptrace (PT_WRITE_D, inferior_pid, (PTRACE_ARG3_TYPE) addr,
        {
          errno = 0;
          ptrace (PT_WRITE_D, inferior_pid, (PTRACE_ARG3_TYPE) addr,


@@ -416,7 +455,7 @@ child_xfer_memory (memaddr, myaddr, len, write, target)
   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;
          buffer[i] = ptrace (PT_READ_I, inferior_pid,
        {
          errno = 0;
          buffer[i] = ptrace (PT_READ_I, inferior_pid,


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

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

     }
   return len;
 }
     }
   return len;
 }

+
+\f
+static void
+udot_info ()
+{
+  int 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.");
+     }
+
+#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
+}
+\f
+void
+_initialize_infptrace ()
+{
+  add_info ("udot", udot_info,
+           "Print contents of kernel ``struct user'' for current child.");
+
+}
+#endif /* !defined (CHILD_XFER_MEMORY).  */