gcc -Wall lint.

[binutils.git] / gdb / lynx-nat.c

diff --git a/gdb/lynx-nat.c b/gdb/lynx-nat.c
index 394fd6883eef86b40a3a8abc17002ba3211b6a68..0a62229987083f06c64066b62605c6888bc2e6ec 100644 (file)
--- a/gdb/lynx-nat.c
+++ b/gdb/lynx-nat.c
@@ -537,6 +537,11 @@ fetch_inferior_registers (regno)
    If REGNO is -1, do this for all registers.
    Otherwise, REGNO specifies which register (so we can save time).  */
 
+/* Registers we shouldn't try to store.  */
+#if !defined (CANNOT_STORE_REGISTER)
+#define CANNOT_STORE_REGISTER(regno) 0
+#endif
+
 void
 store_inferior_registers (regno)
      int regno;
@@ -592,25 +597,19 @@ child_wait (pid, ourstatus)
 {
   int save_errno;
   int thread;
-  int status;
+  union wait status;
 
   while (1)
     {
       int sig;
 
-      if (attach_flag)
-       set_sigint_trap();      /* Causes SIGINT to be passed on to the
+      set_sigint_trap();       /* Causes SIGINT to be passed on to the
                                   attached process. */
       pid = wait (&status);
-#ifdef SPARC
-/* Swap halves of status so that the rest of GDB can understand it */
-      status = (status << 16) | ((unsigned)status >> 16);
-#endif
 
       save_errno = errno;
 
-      if (attach_flag)
-       clear_sigint_trap();
+      clear_sigint_trap();
 
       if (pid == -1)
        {
@@ -627,8 +626,7 @@ child_wait (pid, ourstatus)
       if (pid != PIDGET (inferior_pid))        /* Some other process?!? */
        continue;
 
-/*      thread = WIFTID (status);*/
-      thread = status >> 16;
+      thread = status.w_tid;   /* Get thread id from status */
 
       /* Initial thread value can only be acquired via wait, so we have to
         resort to this hack.  */
@@ -641,12 +639,93 @@ child_wait (pid, ourstatus)
 
       pid = BUILDPID (pid, thread);
 
-      store_waitstatus (ourstatus, status);
+      if (WIFSTOPPED(status)
+         && WSTOPSIG(status) == SIGTRAP
+         && !in_thread_list (pid))
+       {
+         int realsig;
+
+         realsig = ptrace (PTRACE_GETTRACESIG, pid, (PTRACE_ARG3_TYPE)0, 0);
+
+         if (realsig == SIGNEWTHREAD)
+           {
+             /* Simply ignore new thread notification, as we can't do anything
+                useful with such threads.  All ptrace calls at this point just
+                fail for no apparent reason.  The thread will eventually get a
+                real signal when it becomes real.  */
+             child_resume (pid, 0, TARGET_SIGNAL_0);
+             continue;
+           }
+       }
+
+#ifdef SPARC
+      /* SPARC Lynx uses an byte reversed wait status; we must use the
+        host macros to access it.  These lines just a copy of
+        store_waitstatus.  We can't use CHILD_SPECIAL_WAITSTATUS
+        because target.c can't include the Lynx <sys/wait.h>.  */
+      if (WIFEXITED (status))
+       {
+         ourstatus->kind = TARGET_WAITKIND_EXITED;
+         ourstatus->value.integer = WEXITSTATUS (status);
+       }
+      else if (!WIFSTOPPED (status))
+       {
+         ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
+         ourstatus->value.sig =
+           target_signal_from_host (WTERMSIG (status));
+       }
+      else
+       {
+         ourstatus->kind = TARGET_WAITKIND_STOPPED;
+         ourstatus->value.sig =
+           target_signal_from_host (WSTOPSIG (status));
+       }
+#else
+      store_waitstatus (ourstatus, status.w_status);
+#endif
 
       return pid;
     }
 }
 
+/* Resume execution of the inferior process.
+   If STEP is nonzero, single-step it.
+   If SIGNAL is nonzero, give it that signal.  */
+
+void
+child_resume (pid, step, signal)
+     int pid;
+     int step;
+     enum target_signal signal;
+{
+  int func;
+
+  errno = 0;
+
+  if (pid == -1)
+    {
+      /* Resume all threads.  */
+
+      pid = inferior_pid;
+    }
+
+  func = step ? PTRACE_SINGLESTEP_ONE : PTRACE_CONT;
+
+  /* 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.)
+
+     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.  */
+
+  ptrace (func, pid, (PTRACE_ARG3_TYPE) 1, target_signal_to_host (signal));
+
+  if (errno)
+    perror_with_name ("ptrace");
+}
+
 /* Convert a Lynx process ID to a string.  Returns the string in a static
    buffer.  */
 
@@ -685,8 +764,9 @@ fetch_core_registers (core_reg_sect, core_reg_size, which, reg_addr)
   unsigned int regno;
 
   for (regno = 0; regno < NUM_REGS; regno++)
-    supply_register (regno, core_reg_sect + offsetof (st_t, ec)
-                    + regmap[regno]);
+    if (regmap[regno] != -1)
+      supply_register (regno, core_reg_sect + offsetof (st_t, ec)
+                      + regmap[regno]);
 
 #ifdef SPARC
 /* Fetching this register causes all of the I & L regs to be read from the