* infptrace.c (child_resume): Don't try to step if

        NO_SINGLE_STEP is defined.

Date: Tue, 3 Feb 1998 16:28:11 -0500
From: "Gordon W. Ross" <gwr@mc.com>
To: bug-gdb@prep.ai.mit.edu
Subject: gdb/infptrace.c

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index e1b43916a9bdad9e3073517c484c5f16654746ec..02052aecc594c75ee664ec96e5529581be642862 100644 (file)
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,8 @@
+Tue Feb  3 16:12:32 1998  Gordon W. Ross (gwr@mc.com)
+
+       * infptrace.c (child_resume): Don't try to step if 
+       NO_SINGLE_STEP is defined.
+
 Mon Feb  2 19:06:13 1998  Jason Molenda  (crash@bugshack.cygnus.com)
 
        * Makefile.in (VERSION): Bump to 4.16.2.

diff --git a/gdb/infptrace.c b/gdb/infptrace.c
index 28210e49e39f97eb1907117984325640b0466425..3ed7a71967fde6400536262d8665b9316c36fd4b 100644 (file)
--- a/gdb/infptrace.c
+++ b/gdb/infptrace.c
@@ -95,6 +95,15 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 #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
+
 \f
 /* This function simply calls ptrace with the given arguments.  
    It exists so that all calls to ptrace are isolated in this 
@@ -125,12 +134,15 @@ kill_inferior ()
 {
   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);
   wait ((int *)0);
   target_mourn_inferior ();
@@ -166,8 +178,14 @@ child_resume (pid, step, signal)
      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));
+    {
+#ifdef NO_SINGLE_STEP
+      abort();  /* Make sure this doesn't happen. */
+#else
+      ptrace (PT_STEP,     pid, (PTRACE_ARG3_TYPE) 1,
+             target_signal_to_host (signal));
+#endif          /* NO_SINGLE_STEP */
+    }
   else
     ptrace (PT_CONTINUE, pid, (PTRACE_ARG3_TYPE) 1,
            target_signal_to_host (signal));
@@ -262,12 +280,10 @@ fetch_register (regno)
 {
   /* 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;
-
-  /* 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];
 
   if (CANNOT_FETCH_REGISTER (regno))
     {
@@ -295,22 +311,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;
 {
-  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
-    fetch_register (regno);
+    {
+      for (regno = 0; regno < ARCH_NUM_REGS; regno++)
+       {
+         fetch_register (regno);
+       }
+    }
 }
 
 /* Registers we shouldn't try to store.  */
@@ -318,57 +337,57 @@ fetch_inferior_registers (regno)
 #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;
-  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.  */
+
+  if (CANNOT_STORE_REGISTER (regno))
+    {
+      return;
+    }
 
-  unsigned int offset = U_REGS_OFFSET;
+  offset = U_REGS_OFFSET;
 
-  if (regno >= 0)
+  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, inferior_pid, (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)", reg_names[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
     {
-      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);
        }
     }
 }
@@ -477,11 +496,15 @@ child_xfer_memory (memaddr, myaddr, len, write, target)
 
 \f
 static void
-udot_info ()
+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)
      {