Modified Files:

[binutils.git] / gdb / infptrace.c

diff --git a/gdb/infptrace.c b/gdb/infptrace.c
index e9fa66d855529caecb60ee3b3359708e7418d627..011224e4ae980174411619564c76e0e7d266468f 100644 (file)
--- a/gdb/infptrace.c
+++ b/gdb/infptrace.c
@@ -30,12 +30,20 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 #include <sys/dir.h>
 #include <signal.h>
 #include <sys/ioctl.h>
 #include <sys/dir.h>
 #include <signal.h>
 #include <sys/ioctl.h>

-#ifndef USG
+
+#ifndef NO_PTRACE_H
+#ifdef PTRACE_IN_WRONG_PLACE
+#include <ptrace.h>
+#else

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

+#endif /* NO_PTRACE_H */

 
 #if !defined (PT_KILL)
 #define PT_KILL 8
 
 #if !defined (PT_KILL)
 #define PT_KILL 8

+#endif
+
+#if !defined (PT_STEP)

 #define PT_STEP 9
 #define PT_CONTINUE 7
 #define PT_READ_U 3
 #define PT_STEP 9
 #define PT_CONTINUE 7
 #define PT_READ_U 3


@@ -44,7 +52,7 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 #define        PT_READ_D 2
 #define PT_WRITE_I 4
 #define PT_WRITE_D 5
 #define        PT_READ_D 2
 #define PT_WRITE_I 4
 #define PT_WRITE_D 5

-#endif /* No PT_KILL.  */
+#endif /* No PT_STEP.  */

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


@@ -57,7 +65,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

+#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 <sys/stat.h>
 #include <sys/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 */


@@ -76,30 +89,31 @@ 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
 #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.*/
-

 void
 void

-kill_inferior_fast ()
+kill_inferior ()

 {
   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.  */
+  kill (inferior_pid, SIGKILL);

   ptrace (PT_KILL, inferior_pid, (PTRACE_ARG3_TYPE) 0, 0);
   wait ((int *)0);
   ptrace (PT_KILL, inferior_pid, (PTRACE_ARG3_TYPE) 0, 0);
   wait ((int *)0);

-}
-
-void
-kill_inferior ()
-{
-  kill_inferior_fast ();

   target_mourn_inferior ();
 }
 
   target_mourn_inferior ();
 }
 


@@ -108,38 +122,46 @@ kill_inferior ()
    If SIGNAL is nonzero, give it that signal.  */
 
 void
    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.  */
+#ifdef PIDGET
+    /* This is for Lynx, and should be cleaned up by having Lynx be
+       a separate debugging target, with its own target_resume function.  */
+    pid = PIDGET (inferior_pid);
+#else
+    /* 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;
+#endif
+

   /* 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
+    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)
     perror_with_name ("ptrace");
 }
 \f
 #ifdef ATTACH_DETACH
 
   if (errno)
     perror_with_name ("ptrace");
 }
 \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)


@@ -169,17 +191,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";


@@ -188,30 +215,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)


@@ -246,7 +253,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;
     }


@@ -254,12 +261,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);


@@ -298,7 +305,6 @@ store_inferior_registers (regno)
 {
   register unsigned int regaddr;
   char buf[80];
 {
   register unsigned int regaddr;
   char buf[80];

-  extern char registers[];

   register int i;
 
   unsigned int offset = U_REGS_OFFSET;
   register int i;
 
   unsigned int offset = U_REGS_OFFSET;


@@ -306,17 +312,17 @@ store_inferior_registers (regno)
   if (regno >= 0)
     {
       regaddr = register_addr (regno, 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


@@ -326,23 +332,25 @@ store_inferior_registers (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


@@ -368,18 +376,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);


@@ -389,18 +399,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 */
 

-      (void) 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,


@@ -420,7 +432,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,


@@ -431,8 +443,10 @@ child_xfer_memory (memaddr, myaddr, len, write, target)
        }
 
       /* Copy appropriate bytes out of the buffer.  */
        }
 
       /* Copy appropriate bytes out of the buffer.  */

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

     }
   return len;
 }
     }
   return len;
 }

+#endif /* !defined (CHILD_XFER_MEMORY).  */