import gdb-1999-05-10

1 files changed, 377 insertions, 280 deletions

diff --git a/gdb/infrun.c b/gdb/infrun.c
index d1a2d9b..7851ef8 100644
--- a/gdb/infrun.c
+++ b/gdb/infrun.c
@@ -1050,103 +1050,148 @@ delete_breakpoint_current_contents (arg)
     }
 }
 
-/* Wait for control to return from inferior to debugger.
-   If inferior gets a signal, we may decide to start it up again
-   instead of returning.  That is why there is a loop in this function.
-   When this function actually returns it means the inferior
-   should be left stopped and GDB should read more commands.  */
-
 /* This enum encodes possible reasons for doing a target_wait, so that
    wfi can call target_wait in one place.  (Ultimately the call will be
    moved out of the infinite loop entirely.) */
 
-enum wfi_states {
-  wfi_normal_state,
-  wfi_thread_hop_state,
-  wfi_nullified_state,
-  wfi_nonstep_watch_state
+enum infwait_states {
+  infwait_normal_state,
+  infwait_thread_hop_state,
+  infwait_nullified_state,
+  infwait_nonstep_watch_state
 };
 
-void
-wait_for_inferior ()
-{
-  struct cleanup *old_cleanups;
-  struct target_waitstatus w;
+/* This structure contains what used to be local variables in
+   wait_for_inferior.  Probably many of them can return to being
+   locals in handle_inferior_event.  */
+
+struct execution_control_state {
+  struct target_waitstatus ws;
+  struct target_waitstatus *wp;
   int another_trap;
-  int random_signal = 0;
+  int random_signal;
   CORE_ADDR stop_func_start;
   CORE_ADDR stop_func_end;
   char *stop_func_name;
-  CORE_ADDR tmp;
   struct symtab_and_line sal;
-  int remove_breakpoints_on_following_step = 0;
+  int remove_breakpoints_on_following_step;
   int current_line;
   struct symtab *current_symtab;
-  int handling_longjmp = 0;	/* FIXME */
+  int handling_longjmp;	/* FIXME */
   int pid;
   int saved_inferior_pid;
-  int update_step_sp = 0;
-  int stepping_through_solib_after_catch = 0;
-  bpstat stepping_through_solib_catchpoints = NULL;
-  int enable_hw_watchpoints_after_wait = 0;
-  int stepping_through_sigtramp = 0;
+  int update_step_sp;
+  int stepping_through_solib_after_catch;
+  bpstat stepping_through_solib_catchpoints;
+  int enable_hw_watchpoints_after_wait;
+  int stepping_through_sigtramp;
   int new_thread_event;
-  int stepped_after_stopped_by_watchpoint;
   struct target_waitstatus tmpstatus;
-  enum wfi_states wfi_state;
+  enum infwait_states infwait_state;
   int waiton_pid;
-  struct target_waitstatus *wp;
+  int wait_some_more;
+};
+
+void init_execution_control_state PARAMS ((struct execution_control_state *ecs));
+
+void handle_inferior_event PARAMS ((struct execution_control_state *ecs));
+
+/* Wait for control to return from inferior to debugger.
+   If inferior gets a signal, we may decide to start it up again
+   instead of returning.  That is why there is a loop in this function.
+   When this function actually returns it means the inferior
+   should be left stopped and GDB should read more commands.  */
+
+void
+wait_for_inferior ()
+{
+  struct cleanup *old_cleanups;
+  struct execution_control_state ecss;
+  struct execution_control_state *ecs;
 
   old_cleanups = make_cleanup (delete_breakpoint_current_contents,
 			       &step_resume_breakpoint);
   make_cleanup (delete_breakpoint_current_contents,
 		&through_sigtramp_breakpoint);
-  sal = find_pc_line (prev_pc, 0);
-  current_line = sal.line;
-  current_symtab = sal.symtab;
-
-  /* Are we stepping?  */
-#define CURRENTLY_STEPPING() \
-  ((through_sigtramp_breakpoint == NULL \
-    && !handling_longjmp \
-    && ((step_range_end && step_resume_breakpoint == NULL) \
-	|| trap_expected)) \
-   || stepping_through_solib_after_catch \
-   || bpstat_should_step ())
-  ;
+
+  /* wfi still stays in a loop, so it's OK just to take the address of
+     a local to get the ecs pointer.  */
+  ecs = &ecss;
+
+  /* Fill in with reasonable starting values.  */
+  init_execution_control_state (ecs);
+
   thread_step_needed = 0;
 
   /* We'll update this if & when we switch to a new thread. */
   if (may_switch_from_inferior_pid)
     switched_from_inferior_pid = inferior_pid;
 
-  wfi_state = wfi_normal_state;
+  overlay_cache_invalid = 1;
+
+  /* We have to invalidate the registers BEFORE calling target_wait
+     because they can be loaded from the target while in target_wait.
+     This makes remote debugging a bit more efficient for those
+     targets that provide critical registers as part of their normal
+     status mechanism. */
+
+  registers_changed ();
 
   while (1)
     {
-      if (wfi_state == wfi_normal_state)
-	{
-	  overlay_cache_invalid = 1;
+      if (target_wait_hook)
+	ecs->pid = target_wait_hook (ecs->waiton_pid, ecs->wp);
+      else
+	ecs->pid = target_wait (ecs->waiton_pid, ecs->wp);
 
-	  /* We have to invalidate the registers BEFORE calling
-	     target_wait because they can be loaded from the target
-	     while in target_wait.  This makes remote debugging a bit
-	     more efficient for those targets that provide critical
-	     registers as part of their normal status mechanism. */
+      /* Now figure out what to do with the result of the result.  */
+      handle_inferior_event (ecs);
 
-	  registers_changed ();
-	  waiton_pid = -1;
-	  wp = &w;
-	}
+      if (!ecs->wait_some_more)
+	break;
+    }
+  do_cleanups (old_cleanups);
+}
 
-      if (target_wait_hook)
-	pid = target_wait_hook (waiton_pid, wp);
-      else
-	pid = target_wait (waiton_pid, wp);
+/* Prepare an execution control state for looping through a
+   wait_for_inferior-type loop.  */
+
+void
+init_execution_control_state (ecs)
+     struct execution_control_state *ecs;
+{
+  ecs->random_signal = 0;
+  ecs->remove_breakpoints_on_following_step = 0;
+  ecs->handling_longjmp = 0;	/* FIXME */
+  ecs->update_step_sp = 0;
+  ecs->stepping_through_solib_after_catch = 0;
+  ecs->stepping_through_solib_catchpoints = NULL;
+  ecs->enable_hw_watchpoints_after_wait = 0;
+  ecs->stepping_through_sigtramp = 0;
+  ecs->sal = find_pc_line (prev_pc, 0);
+  ecs->current_line = ecs->sal.line;
+  ecs->current_symtab = ecs->sal.symtab;
+  ecs->infwait_state = infwait_normal_state;
+  ecs->waiton_pid = -1;
+  ecs->wp = &(ecs->ws);
+}
+
+/* Given an execution control state that has been freshly filled in
+   by an event from the inferior, figure out what it means and take
+   appropriate action.  */
 
-      switch (wfi_state)
+void
+handle_inferior_event (ecs)
+     struct execution_control_state *ecs;
+{
+  CORE_ADDR tmp;
+  int stepped_after_stopped_by_watchpoint;
+
+  /* Keep this extra brace for now, minimizes diffs.  */
+  {
+      switch (ecs->infwait_state)
 	{
-	case wfi_normal_state:
+	case infwait_normal_state:
 	  /* Since we've done a wait, we have a new event.  Don't
 	     carry over any expectations about needing to step over a
 	     breakpoint. */
@@ -1154,32 +1199,32 @@ wait_for_inferior ()
 
 	  /* See comments where a TARGET_WAITKIND_SYSCALL_RETURN event
 	     is serviced in this loop, below. */
-	  if (enable_hw_watchpoints_after_wait)
+	  if (ecs->enable_hw_watchpoints_after_wait)
 	    {
 	      TARGET_ENABLE_HW_WATCHPOINTS (inferior_pid);
-	      enable_hw_watchpoints_after_wait = 0;
+	      ecs->enable_hw_watchpoints_after_wait = 0;
 	    }
 	  stepped_after_stopped_by_watchpoint = 0;
 	  break;
 
-	case wfi_thread_hop_state:
+	case infwait_thread_hop_state:
 	  insert_breakpoints ();
 
 	  /* We need to restart all the threads now,
 	   * unles we're running in scheduler-locked mode. 
-	   * FIXME: shouldn't we look at CURRENTLY_STEPPING ()?
+	   * FIXME: shouldn't we look at currently_stepping ()?
 	   */
 	  if (scheduler_mode == schedlock_on)
-	    target_resume (pid, 0, TARGET_SIGNAL_0);
+	    target_resume (ecs->pid, 0, TARGET_SIGNAL_0);
 	  else
 	    target_resume (-1, 0, TARGET_SIGNAL_0);
-	  wfi_state = wfi_normal_state;
-	  continue;
+	  ecs->infwait_state = infwait_normal_state;
+	  goto wfi_continue;
 
-	case wfi_nullified_state:
+	case infwait_nullified_state:
 	  break;
 
-	case wfi_nonstep_watch_state:
+	case infwait_nonstep_watch_state:
 	  insert_breakpoints ();
 
 	  /* FIXME-maybe: is this cleaner than setting a flag?  Does it
@@ -1188,21 +1233,21 @@ wait_for_inferior ()
 	  stepped_after_stopped_by_watchpoint = 1;
 	  break;
 	}
-      wfi_state = wfi_normal_state;
+      ecs->infwait_state = infwait_normal_state;
 
       flush_cached_frames ();
 
       /* If it's a new process, add it to the thread database */
 
-      new_thread_event = ((pid != inferior_pid) && !in_thread_list (pid));
+      ecs->new_thread_event = ((ecs->pid != inferior_pid) && !in_thread_list (ecs->pid));
 
-      if (w.kind != TARGET_WAITKIND_EXITED
-	  && w.kind != TARGET_WAITKIND_SIGNALLED
-	  && new_thread_event)
+      if (ecs->ws.kind != TARGET_WAITKIND_EXITED
+	  && ecs->ws.kind != TARGET_WAITKIND_SIGNALLED
+	  && ecs->new_thread_event)
 	{
-	  add_thread (pid);
+	  add_thread (ecs->pid);
 
-	  printf_filtered ("[New %s]\n", target_pid_or_tid_to_str (pid));
+	  printf_filtered ("[New %s]\n", target_pid_or_tid_to_str (ecs->pid));
 
 #if 0
 	  /* NOTE: This block is ONLY meant to be invoked in case of a
@@ -1225,11 +1270,11 @@ wait_for_inferior ()
 	     make progress.  */
 
 	  target_resume (-1, 0, TARGET_SIGNAL_0);
-	  continue;
+	  goto wfi_continue;
 #endif
 	}
 
-      switch (w.kind)
+      switch (ecs->ws.kind)
 	{
 	case TARGET_WAITKIND_LOADED:
 	  /* Ignore gracefully during startup of the inferior, as it
@@ -1260,18 +1305,18 @@ wait_for_inferior ()
 	    }
 #endif
 	  resume (0, TARGET_SIGNAL_0);
-	  continue;
+	  goto wfi_continue;
 
 	case TARGET_WAITKIND_SPURIOUS:
 	  resume (0, TARGET_SIGNAL_0);
-	  continue;
+	  goto wfi_continue;
 
 	case TARGET_WAITKIND_EXITED:
 	  target_terminal_ours ();	/* Must do this before mourn anyway */
-	  annotate_exited (w.value.integer);
-	  if (w.value.integer)
+	  annotate_exited (ecs->ws.value.integer);
+	  if (ecs->ws.value.integer)
 	    printf_filtered ("\nProgram exited with code 0%o.\n",
-			     (unsigned int) w.value.integer);
+			     (unsigned int) ecs->ws.value.integer);
 	  else
 	    printf_filtered ("\nProgram exited normally.\n");
 
@@ -1279,7 +1324,7 @@ wait_for_inferior ()
 	     that the user can inspect this again later.  */
 	  set_internalvar (lookup_internalvar ("_exitcode"),
 			   value_from_longest (builtin_type_int,
-					       (LONGEST) w.value.integer));
+					       (LONGEST) ecs->ws.value.integer));
 	  gdb_flush (gdb_stdout);
 	  target_mourn_inferior ();
 	  singlestep_breakpoints_inserted_p = 0;	/*SOFTWARE_SINGLE_STEP_P*/
@@ -1288,7 +1333,7 @@ wait_for_inferior ()
 
 	case TARGET_WAITKIND_SIGNALLED:
 	  stop_print_frame = 0;
-	  stop_signal = w.value.sig;
+	  stop_signal = ecs->ws.value.sig;
 	  target_terminal_ours ();	/* Must do this before mourn anyway */
 	  annotate_signalled ();
 
@@ -1318,38 +1363,38 @@ wait_for_inferior ()
            the above cases end in a continue or goto. */
 	case TARGET_WAITKIND_FORKED:
 	  stop_signal = TARGET_SIGNAL_TRAP;
-	  pending_follow.kind = w.kind;
+	  pending_follow.kind = ecs->ws.kind;
 
 	  /* Ignore fork events reported for the parent; we're only
              interested in reacting to forks of the child.  Note that
              we expect the child's fork event to be available if we
              waited for it now. */
-	  if (inferior_pid == pid)
+	  if (inferior_pid == ecs->pid)
 	    {
 	      pending_follow.fork_event.saw_parent_fork = 1;
-	      pending_follow.fork_event.parent_pid = pid;
-	      pending_follow.fork_event.child_pid = w.value.related_pid;
-	      continue;
+	      pending_follow.fork_event.parent_pid = ecs->pid;
+	      pending_follow.fork_event.child_pid = ecs->ws.value.related_pid;
+	      goto wfi_continue;
 	    }
 	  else
 	    {
 	      pending_follow.fork_event.saw_child_fork = 1;
-	      pending_follow.fork_event.child_pid = pid;
-	      pending_follow.fork_event.parent_pid = w.value.related_pid;
+	      pending_follow.fork_event.child_pid = ecs->pid;
+	      pending_follow.fork_event.parent_pid = ecs->ws.value.related_pid;
 	    }
 
-	  stop_pc = read_pc_pid (pid);
-	  saved_inferior_pid = inferior_pid;
-	  inferior_pid = pid;
+	  stop_pc = read_pc_pid (ecs->pid);
+	  ecs->saved_inferior_pid = inferior_pid;
+	  inferior_pid = ecs->pid;
 	  stop_bpstat = bpstat_stop_status
 	    (&stop_pc,
 	     (DECR_PC_AFTER_BREAK ? 
 	      (prev_pc != stop_pc - DECR_PC_AFTER_BREAK
-	       && CURRENTLY_STEPPING ())
+	       && currently_stepping (ecs))
 	      : 0)
 	    );
-	  random_signal = !bpstat_explains_signal (stop_bpstat);
-	  inferior_pid = saved_inferior_pid;
+	  ecs->random_signal = !bpstat_explains_signal (stop_bpstat);
+	  inferior_pid = ecs->saved_inferior_pid;
 	  goto process_event_stop_test;
 
 	  /* If this a platform which doesn't allow a debugger to touch a
@@ -1361,7 +1406,7 @@ wait_for_inferior ()
            little choice. */
 	case TARGET_WAITKIND_VFORKED:
 	  stop_signal = TARGET_SIGNAL_TRAP;
-	  pending_follow.kind = w.kind;
+	  pending_follow.kind = ecs->ws.kind;
 
 	  /* Is this a vfork of the parent?  If so, then give any
              vfork catchpoints a chance to trigger now.  (It's
@@ -1369,11 +1414,11 @@ wait_for_inferior ()
              it execs, and the child has not yet exec'd.  We probably
              should warn the user to that effect when the catchpoint
              triggers...) */
-	  if (pid == inferior_pid)
+	  if (ecs->pid == inferior_pid)
 	    {
 	      pending_follow.fork_event.saw_parent_fork = 1;
-	      pending_follow.fork_event.parent_pid = pid;
-	      pending_follow.fork_event.child_pid = w.value.related_pid;
+	      pending_follow.fork_event.parent_pid = ecs->pid;
+	      pending_follow.fork_event.child_pid = ecs->ws.value.related_pid;
 	    }
 
 	  /* If we've seen the child's vfork event but cannot really touch
@@ -1382,14 +1427,14 @@ wait_for_inferior ()
 	  else
 	    {
 	      pending_follow.fork_event.saw_child_fork = 1;
-	      pending_follow.fork_event.child_pid = pid;
-	      pending_follow.fork_event.parent_pid = w.value.related_pid;
+	      pending_follow.fork_event.child_pid = ecs->pid;
+	      pending_follow.fork_event.parent_pid = ecs->ws.value.related_pid;
 	      target_post_startup_inferior (pending_follow.fork_event.child_pid);
 	      follow_vfork_when_exec = !target_can_follow_vfork_prior_to_exec ();
 	      if (follow_vfork_when_exec)
 		{
-		  target_resume (pid, 0, TARGET_SIGNAL_0);
-		  continue;
+		  target_resume (ecs->pid, 0, TARGET_SIGNAL_0);
+		  goto wfi_continue;
 		}
 	    }
 
@@ -1398,10 +1443,10 @@ wait_for_inferior ()
 	    (&stop_pc,
 	     (DECR_PC_AFTER_BREAK ? 
 	      (prev_pc != stop_pc - DECR_PC_AFTER_BREAK
-	       && CURRENTLY_STEPPING ())
+	       && currently_stepping (ecs))
 	      : 0)
 	     );
-	  random_signal = !bpstat_explains_signal (stop_bpstat);
+	  ecs->random_signal = !bpstat_explains_signal (stop_bpstat);
 	  goto process_event_stop_test;
 
 	case TARGET_WAITKIND_EXECD:
@@ -1416,14 +1461,14 @@ wait_for_inferior ()
 	      inferior_ignoring_leading_exec_events--;
 	      if (pending_follow.kind == TARGET_WAITKIND_VFORKED)
 		ENSURE_VFORKING_PARENT_REMAINS_STOPPED (pending_follow.fork_event.parent_pid);
-	      target_resume (pid, 0, TARGET_SIGNAL_0);
-	      continue;
+	      target_resume (ecs->pid, 0, TARGET_SIGNAL_0);
+	      goto wfi_continue;
 	    }
 	  inferior_ignoring_leading_exec_events =
 	    target_reported_exec_events_per_exec_call () - 1;
 
-	  pending_follow.execd_pathname = savestring (w.value.execd_pathname,
-					   strlen (w.value.execd_pathname));
+	  pending_follow.execd_pathname = savestring (ecs->ws.value.execd_pathname,
+					   strlen (ecs->ws.value.execd_pathname));
 
 	  /* Did inferior_pid exec, or did a (possibly not-yet-followed)
              child of a vfork exec?
@@ -1449,9 +1494,9 @@ wait_for_inferior ()
                  the parent vfork event is delivered.  A single-step
                  suffices. */
 	      if (RESUME_EXECD_VFORKING_CHILD_TO_GET_PARENT_VFORK ())
-		target_resume (pid, 1, TARGET_SIGNAL_0);
+		target_resume (ecs->pid, 1, TARGET_SIGNAL_0);
 	      /* We expect the parent vfork event to be available now. */
-	      continue;
+	      goto wfi_continue;
 	    }
 
 	  /* This causes the eventpoints and symbol table to be reset.  Must
@@ -1459,18 +1504,18 @@ wait_for_inferior ()
 	  follow_exec (inferior_pid, pending_follow.execd_pathname);
 	  free (pending_follow.execd_pathname);
 
-	  stop_pc = read_pc_pid (pid);
-	  saved_inferior_pid = inferior_pid;
-	  inferior_pid = pid;
+	  stop_pc = read_pc_pid (ecs->pid);
+	  ecs->saved_inferior_pid = inferior_pid;
+	  inferior_pid = ecs->pid;
 	  stop_bpstat = bpstat_stop_status
 	    (&stop_pc,
 	     (DECR_PC_AFTER_BREAK ? 
 	      (prev_pc != stop_pc - DECR_PC_AFTER_BREAK
-	       && CURRENTLY_STEPPING ())
+	       && currently_stepping (ecs))
 	      : 0)
 	     );
-	  random_signal = !bpstat_explains_signal (stop_bpstat);
-	  inferior_pid = saved_inferior_pid;
+	  ecs->random_signal = !bpstat_explains_signal (stop_bpstat);
+	  inferior_pid = ecs->saved_inferior_pid;
 	  goto process_event_stop_test;
 
 	  /* These syscall events are returned on HP-UX, as part of its
@@ -1497,7 +1542,7 @@ wait_for_inferior ()
 	      TARGET_DISABLE_HW_WATCHPOINTS (inferior_pid);
 	    }
 	  resume (0, TARGET_SIGNAL_0);
-	  continue;
+	  goto wfi_continue;
 
 	  /* Before examining the threads further, step this thread to
 	   get it entirely out of the syscall.  (We get notice of the
@@ -1510,22 +1555,22 @@ wait_for_inferior ()
 	   the thread (this causes the next wait on the thread to hang).
 
 	   Nor can we enable them after stepping until we've done a wait.
-	   Thus, we simply set the flag enable_hw_watchpoints_after_wait
+	   Thus, we simply set the flag ecs->enable_hw_watchpoints_after_wait
 	   here, which will be serviced immediately after the target
 	   is waited on. */
 	case TARGET_WAITKIND_SYSCALL_RETURN:
-	  target_resume (pid, 1, TARGET_SIGNAL_0);
+	  target_resume (ecs->pid, 1, TARGET_SIGNAL_0);
 
 	  if (number_of_threads_in_syscalls > 0)
 	    {
 	      number_of_threads_in_syscalls--;
-	      enable_hw_watchpoints_after_wait =
+	      ecs->enable_hw_watchpoints_after_wait =
 		(number_of_threads_in_syscalls == 0);
 	    }
-	  continue;
+	  goto wfi_continue;
 
 	case TARGET_WAITKIND_STOPPED:
-	  stop_signal = w.value.sig;
+	  stop_signal = ecs->ws.value.sig;
 	  break;
 	}
 
@@ -1536,13 +1581,13 @@ wait_for_inferior ()
       /* At this point, all threads are stopped (happens automatically in
          either the OS or the native code).  Therefore we need to continue
          all threads in order to make progress.  */
-      if (new_thread_event)
+      if (ecs->new_thread_event)
 	{
 	  target_resume (-1, 0, TARGET_SIGNAL_0);
-	  continue;
+	  goto wfi_continue;
 	}
 
-      stop_pc = read_pc_pid (pid);
+      stop_pc = read_pc_pid (ecs->pid);
 
       /* See if a thread hit a thread-specific breakpoint that was meant for
 	 another thread.  If so, then step that thread past the breakpoint,
@@ -1551,19 +1596,19 @@ wait_for_inferior ()
       if (stop_signal == TARGET_SIGNAL_TRAP)
 	{
 	  if (SOFTWARE_SINGLE_STEP_P && singlestep_breakpoints_inserted_p)
-	    random_signal = 0;
+	    ecs->random_signal = 0;
 	  else if (breakpoints_inserted
 		   && breakpoint_here_p (stop_pc - DECR_PC_AFTER_BREAK))
 	    {
-	      random_signal = 0;
+	      ecs->random_signal = 0;
 	      if (!breakpoint_thread_match (stop_pc - DECR_PC_AFTER_BREAK,
-					    pid))
+					    ecs->pid))
 		{
 		  int remove_status;
 
 		  /* Saw a breakpoint, but it was hit by the wrong thread.
 		       Just continue. */
-		  write_pc_pid (stop_pc - DECR_PC_AFTER_BREAK, pid);
+		  write_pc_pid (stop_pc - DECR_PC_AFTER_BREAK, ecs->pid);
 
 		  remove_status = remove_breakpoints ();
 		  /* Did we fail to remove breakpoints?  If so, try
@@ -1575,29 +1620,29 @@ wait_for_inferior ()
                        then either :-) or execs. */
 		  if (remove_status != 0)
 		    {
-		      write_pc_pid (stop_pc - DECR_PC_AFTER_BREAK + 4, pid);
+		      write_pc_pid (stop_pc - DECR_PC_AFTER_BREAK + 4, ecs->pid);
 		    }
 		  else
 		    {		/* Single step */
-		      target_resume (pid, 1, TARGET_SIGNAL_0);
+		      target_resume (ecs->pid, 1, TARGET_SIGNAL_0);
 		      /* FIXME: What if a signal arrives instead of the
 			   single-step happening?  */
 
-		      waiton_pid = pid;
-		      wp = &w;
-		      wfi_state = wfi_thread_hop_state;
-		      continue;
+		      ecs->waiton_pid = ecs->pid;
+		      ecs->wp = &(ecs->ws);
+		      ecs->infwait_state = infwait_thread_hop_state;
+		      goto wfi_continue;
 		    }
 
 		    /* We need to restart all the threads now,
 		     * unles we're running in scheduler-locked mode. 
-		     * FIXME: shouldn't we look at CURRENTLY_STEPPING ()?
+		     * FIXME: shouldn't we look at currently_stepping ()?
 		     */
 		    if (scheduler_mode == schedlock_on)
-		      target_resume (pid, 0, TARGET_SIGNAL_0);
+		      target_resume (ecs->pid, 0, TARGET_SIGNAL_0);
 		    else
 		      target_resume (-1, 0, TARGET_SIGNAL_0);
-		    continue;
+		    goto wfi_continue;
 		}
 	      else
 		{
@@ -1610,7 +1655,7 @@ wait_for_inferior ()
 	    }
 	}
       else
-	random_signal = 1;
+	ecs->random_signal = 1;
 
       /* See if something interesting happened to the non-current thread.  If
          so, then switch to that thread, and eventually give control back to
@@ -1619,14 +1664,14 @@ wait_for_inferior ()
          Note that if there's any kind of pending follow (i.e., of a fork,
          vfork or exec), we don't want to do this now.  Rather, we'll let
          the next resume handle it. */
-      if ((pid != inferior_pid) &&
+      if ((ecs->pid != inferior_pid) &&
 	  (pending_follow.kind == TARGET_WAITKIND_SPURIOUS))
 	{
 	  int printed = 0;
 
 	  /* If it's a random signal for a non-current thread, notify user
 	     if he's expressed an interest. */
-	  if (random_signal
+	  if (ecs->random_signal
 	      && signal_print[stop_signal])
 	    {
 /* ??rehrauer: I don't understand the rationale for this code.  If the
@@ -1662,8 +1707,8 @@ wait_for_inferior ()
 	      if (signal_program[stop_signal] == 0)
 		stop_signal = TARGET_SIGNAL_0;
 
-	      target_resume (pid, 0, stop_signal);
-	      continue;
+	      target_resume (ecs->pid, 0, stop_signal);
+	      goto wfi_continue;
 	    }
 
 	  /* It's a SIGTRAP or a signal we're interested in.  Switch threads,
@@ -1675,16 +1720,16 @@ wait_for_inferior ()
 			     trap_expected, step_resume_breakpoint,
 			     through_sigtramp_breakpoint,
 			     step_range_start, step_range_end,
-			     step_frame_address, handling_longjmp,
-			     another_trap,
-			     stepping_through_solib_after_catch,
-			     stepping_through_solib_catchpoints,
-			     stepping_through_sigtramp);
+			     step_frame_address, ecs->handling_longjmp,
+			     ecs->another_trap,
+			     ecs->stepping_through_solib_after_catch,
+			     ecs->stepping_through_solib_catchpoints,
+			     ecs->stepping_through_sigtramp);
 
 	  if (may_switch_from_inferior_pid)
 	    switched_from_inferior_pid = inferior_pid;
 
-	  inferior_pid = pid;
+	  inferior_pid = ecs->pid;
 
 	  /* Load infrun state for the new thread.  */
 	  load_infrun_state (inferior_pid, &prev_pc,
@@ -1692,16 +1737,16 @@ wait_for_inferior ()
 			     &trap_expected, &step_resume_breakpoint,
 			     &through_sigtramp_breakpoint,
 			     &step_range_start, &step_range_end,
-			     &step_frame_address, &handling_longjmp,
-			     &another_trap,
-			     &stepping_through_solib_after_catch,
-			     &stepping_through_solib_catchpoints,
-			     &stepping_through_sigtramp);
+			     &step_frame_address, &ecs->handling_longjmp,
+			     &ecs->another_trap,
+			     &ecs->stepping_through_solib_after_catch,
+			     &ecs->stepping_through_solib_catchpoints,
+			     &ecs->stepping_through_sigtramp);
 
 	  if (context_hook)
-	    context_hook (pid_to_thread_id (pid));
+	    context_hook (pid_to_thread_id (ecs->pid));
 
-	  printf_filtered ("[Switching to %s]\n", target_pid_to_str (pid));
+	  printf_filtered ("[Switching to %s]\n", target_pid_to_str (ecs->pid));
 	  flush_cached_frames ();
 	}
 
@@ -1716,35 +1761,35 @@ wait_for_inferior ()
 	 it so that the user won't be confused when GDB appears to be ready
 	 to execute it. */
 
-      /*      if (INSTRUCTION_NULLIFIED && CURRENTLY_STEPPING ()) */
+      /*      if (INSTRUCTION_NULLIFIED && currently_stepping (ecs)) */
       if (INSTRUCTION_NULLIFIED)
 	{
 	  registers_changed ();
-	  target_resume (pid, 1, TARGET_SIGNAL_0);
+	  target_resume (ecs->pid, 1, TARGET_SIGNAL_0);
 
 	  /* We may have received a signal that we want to pass to
 	     the inferior; therefore, we must not clobber the waitstatus
-	     in W. */
+	     in WS. */
 
-	  wfi_state = wfi_nullified_state;
-	  waiton_pid = pid;
-	  wp = &tmpstatus;
-	  continue;
+	  ecs->infwait_state = infwait_nullified_state;
+	  ecs->waiton_pid = ecs->pid;
+	  ecs->wp = &(ecs->tmpstatus);
+	  goto wfi_continue;
 	}
 
       /* It may not be necessary to disable the watchpoint to stop over
 	 it.  For example, the PA can (with some kernel cooperation)
 	 single step over a watchpoint without disabling the watchpoint.  */
-      if (HAVE_STEPPABLE_WATCHPOINT && STOPPED_BY_WATCHPOINT (w))
+      if (HAVE_STEPPABLE_WATCHPOINT && STOPPED_BY_WATCHPOINT (ecs->ws))
 	{
 	  resume (1, 0);
-	  continue;
+	  goto wfi_continue;
 	}
 
       /* It is far more common to need to disable a watchpoint to step
 	 the inferior over it.  FIXME.  What else might a debug
 	 register or page protection watchpoint scheme need here?  */
-      if (HAVE_NONSTEPPABLE_WATCHPOINT && STOPPED_BY_WATCHPOINT (w))
+      if (HAVE_NONSTEPPABLE_WATCHPOINT && STOPPED_BY_WATCHPOINT (ecs->ws))
 	{
 	  /* At this point, we are stopped at an instruction which has
 	     attempted to write to a piece of memory under control of
@@ -1767,32 +1812,32 @@ wait_for_inferior ()
 
 	  remove_breakpoints ();
 	  registers_changed ();
-	  target_resume (pid, 1, TARGET_SIGNAL_0);	/* Single step */
+	  target_resume (ecs->pid, 1, TARGET_SIGNAL_0);  /* Single step */
 
-	  waiton_pid = pid;
-	  wp = &w;
-	  wfi_state = wfi_nonstep_watch_state;
-	  continue;
+	  ecs->waiton_pid = ecs->pid;
+	  ecs->wp = &(ecs->ws);
+	  ecs->infwait_state = infwait_nonstep_watch_state;
+	  goto wfi_continue;
 	}
 
       /* It may be possible to simply continue after a watchpoint.  */
       if (HAVE_CONTINUABLE_WATCHPOINT)
-	STOPPED_BY_WATCHPOINT (w);
+	STOPPED_BY_WATCHPOINT (ecs->ws);
 
-      stop_func_start = 0;
-      stop_func_end = 0;
-      stop_func_name = 0;
+      ecs->stop_func_start = 0;
+      ecs->stop_func_end = 0;
+      ecs->stop_func_name = 0;
       /* Don't care about return value; stop_func_start and stop_func_name
 	 will both be 0 if it doesn't work.  */
-      find_pc_partial_function (stop_pc, &stop_func_name, &stop_func_start,
-				&stop_func_end);
-      stop_func_start += FUNCTION_START_OFFSET;
-      another_trap = 0;
+      find_pc_partial_function (stop_pc, &ecs->stop_func_name,
+				&ecs->stop_func_start, &ecs->stop_func_end);
+      ecs->stop_func_start += FUNCTION_START_OFFSET;
+      ecs->another_trap = 0;
       bpstat_clear (&stop_bpstat);
       stop_step = 0;
       stop_stack_dummy = 0;
       stop_print_frame = 1;
-      random_signal = 0;
+      ecs->random_signal = 0;
       stopped_by_random_signal = 0;
       breakpoints_failed = 0;
 
@@ -1800,8 +1845,8 @@ wait_for_inferior ()
 	 The alternatives are:
 	 1) break; to really stop and return to the debugger,
 	 2) drop through to start up again
-	 (set another_trap to 1 to single step once)
-	 3) set random_signal to 1, and the decision between 1 and 2
+	 (set ecs->another_trap to 1 to single step once)
+	 3) set ecs->random_signal to 1, and the decision between 1 and 2
 	 will be made according to the signal handling tables.  */
 
       /* First, distinguish signals caused by the debugger from signals
@@ -1821,10 +1866,10 @@ wait_for_inferior ()
 	  if (stop_signal == TARGET_SIGNAL_TRAP && stop_after_trap)
 	    {
 	      stop_print_frame = 0;
-	      break;
+	      goto wfi_break;
 	    }
 	  if (stop_soon_quietly)
-	    break;
+	    goto wfi_break;
 
 	  /* Don't even think about breakpoints
 	     if just proceeded over a breakpoint.
@@ -1852,7 +1897,7 @@ wait_for_inferior ()
 		    without an intervening stop in sigtramp, which is
 		    detected by a new stack pointer value below
 		    any usual function calling stack adjustments.  */
-		  (CURRENTLY_STEPPING ()
+		  (currently_stepping (ecs)
 		   && prev_pc != stop_pc - DECR_PC_AFTER_BREAK
 		   && !(step_range_end
 			&& INNER_THAN (read_sp (), (step_sp - 16)))) :
@@ -1864,7 +1909,7 @@ wait_for_inferior ()
 	    }
 
 	  if (stop_signal == TARGET_SIGNAL_TRAP)
-	    random_signal
+	    ecs->random_signal
 	      = !(bpstat_explains_signal (stop_bpstat)
 		  || trap_expected
 		  || (!CALL_DUMMY_BREAKPOINT_OFFSET_P
@@ -1874,7 +1919,7 @@ wait_for_inferior ()
 
 	  else
 	    {
-	      random_signal
+	      ecs->random_signal
 		= !(bpstat_explains_signal (stop_bpstat)
 		    /* End of a stack dummy.  Some systems (e.g. Sony
 		       news) give another signal besides SIGTRAP, so
@@ -1883,7 +1928,7 @@ wait_for_inferior ()
 			&& PC_IN_CALL_DUMMY (stop_pc, read_sp (),
 					     FRAME_FP (get_current_frame ())))
 		);
-	      if (!random_signal)
+	      if (!ecs->random_signal)
 		stop_signal = TARGET_SIGNAL_TRAP;
 	    }
 	}
@@ -1893,14 +1938,14 @@ wait_for_inferior ()
          (unexpected) signal. */
 
       else
-	random_signal = 1;
+	ecs->random_signal = 1;
       /* If a fork, vfork or exec event was seen, then there are two
          possible responses we can make:
 
-         1. If a catchpoint triggers for the event (random_signal == 0),
+         1. If a catchpoint triggers for the event (ecs->random_signal == 0),
             then we must stop now and issue a prompt.  We will resume
             the inferior when the user tells us to.
-         2. If no catchpoint triggers for the event (random_signal == 1),
+         2. If no catchpoint triggers for the event (ecs->random_signal == 1),
             then we must resume the inferior now and keep checking.
 
          In either case, we must take appropriate steps to "follow" the
@@ -1911,27 +1956,27 @@ wait_for_inferior ()
          In either case, setting pending_follow causes the next resume()
          to take the appropriate following action. */
     process_event_stop_test:
-      if (w.kind == TARGET_WAITKIND_FORKED)
+      if (ecs->ws.kind == TARGET_WAITKIND_FORKED)
 	{
-	  if (random_signal)	/* I.e., no catchpoint triggered for this. */
+	  if (ecs->random_signal)	/* I.e., no catchpoint triggered for this. */
 	    {
 	      trap_expected = 1;
 	      stop_signal = TARGET_SIGNAL_0;
 	      goto keep_going;
 	    }
 	}
-      else if (w.kind == TARGET_WAITKIND_VFORKED)
+      else if (ecs->ws.kind == TARGET_WAITKIND_VFORKED)
 	{
-	  if (random_signal)	/* I.e., no catchpoint triggered for this. */
+	  if (ecs->random_signal)	/* I.e., no catchpoint triggered for this. */
 	    {
 	      stop_signal = TARGET_SIGNAL_0;
 	      goto keep_going;
 	    }
 	}
-      else if (w.kind == TARGET_WAITKIND_EXECD)
+      else if (ecs->ws.kind == TARGET_WAITKIND_EXECD)
 	{
-	  pending_follow.kind = w.kind;
-	  if (random_signal)	/* I.e., no catchpoint triggered for this. */
+	  pending_follow.kind = ecs->ws.kind;
+	  if (ecs->random_signal)	/* I.e., no catchpoint triggered for this. */
 	    {
 	      trap_expected = 1;
 	      stop_signal = TARGET_SIGNAL_0;
@@ -1942,7 +1987,7 @@ wait_for_inferior ()
       /* For the program's own signals, act according to
 	 the signal handling tables.  */
 
-      if (random_signal)
+      if (ecs->random_signal)
 	{
 	  /* Signal not for debugging purposes.  */
 	  int printed = 0;
@@ -1966,7 +2011,7 @@ wait_for_inferior ()
 	      gdb_flush (gdb_stdout);
 	    }
 	  if (signal_stop[stop_signal])
-	    break;
+	    goto wfi_break;
 	  /* If not going to stop, give terminal back
 	     if we took it away.  */
 	  else if (printed)
@@ -2038,7 +2083,7 @@ wait_for_inferior ()
 	    else
 #endif /* 0 */
 	      set_longjmp_resume_breakpoint (jmp_buf_pc, NULL);
-	    handling_longjmp = 1;	/* FIXME */
+	    ecs->handling_longjmp = 1;	/* FIXME */
 	    goto keep_going;
 
 	  case BPSTAT_WHAT_CLEAR_LONGJMP_RESUME:
@@ -2051,12 +2096,12 @@ wait_for_inferior ()
 		&& (INNER_THAN (FRAME_FP (get_current_frame ()),
 				step_frame_address)))
 	      {
-		another_trap = 1;
+		ecs->another_trap = 1;
 		goto keep_going;
 	      }
 #endif /* 0 */
 	    disable_longjmp_breakpoint ();
-	    handling_longjmp = 0;	/* FIXME */
+	    ecs->handling_longjmp = 0;	/* FIXME */
 	    if (what.main_action == BPSTAT_WHAT_CLEAR_LONGJMP_RESUME)
 	      break;
 	    /* else fallthrough */
@@ -2068,7 +2113,7 @@ wait_for_inferior ()
 		remove_breakpoints ();
 	      }
 	    breakpoints_inserted = 0;
-	    another_trap = 1;
+	    ecs->another_trap = 1;
 	    /* Still need to check other stuff, at least the case
 	       where we are stepping and step out of the right range.  */
 	    break;
@@ -2121,7 +2166,7 @@ wait_for_inferior ()
 	    /* If were waiting for a trap, hitting the step_resume_break
 	       doesn't count as getting it.  */
 	    if (trap_expected)
-	      another_trap = 1;
+	      ecs->another_trap = 1;
 	    break;
 
 	  case BPSTAT_WHAT_CHECK_SHLIBS:
@@ -2185,18 +2230,18 @@ wait_for_inferior ()
                      friends) until we reach non-dld code.  At that point,
                      we can stop stepping. */
 		  bpstat_get_triggered_catchpoints (stop_bpstat,
-				       &stepping_through_solib_catchpoints);
-		  stepping_through_solib_after_catch = 1;
+				       &ecs->stepping_through_solib_catchpoints);
+		  ecs->stepping_through_solib_after_catch = 1;
 
 		  /* Be sure to lift all breakpoints, so the inferior does
                      actually step past this point... */
-		  another_trap = 1;
+		  ecs->another_trap = 1;
 		  break;
 		}
 	      else
 		{
 		  /* We want to step over this breakpoint, then keep going.  */
-		  another_trap = 1;
+		  ecs->another_trap = 1;
 		  break;
 		}
 	    }
@@ -2220,22 +2265,22 @@ wait_for_inferior ()
       /* Are we stepping to get the inferior out of the dynamic
          linker's hook (and possibly the dld itself) after catching
          a shlib event? */
-      if (stepping_through_solib_after_catch)
+      if (ecs->stepping_through_solib_after_catch)
 	{
 #if defined(SOLIB_ADD)
 	  /* Have we reached our destination?  If not, keep going. */
-	  if (SOLIB_IN_DYNAMIC_LINKER (pid, stop_pc))
+	  if (SOLIB_IN_DYNAMIC_LINKER (ecs->pid, stop_pc))
 	    {
-	      another_trap = 1;
+	      ecs->another_trap = 1;
 	      goto keep_going;
 	    }
 #endif
 	  /* Else, stop and report the catchpoint(s) whose triggering
              caused us to begin stepping. */
-	  stepping_through_solib_after_catch = 0;
+	  ecs->stepping_through_solib_after_catch = 0;
 	  bpstat_clear (&stop_bpstat);
-	  stop_bpstat = bpstat_copy (stepping_through_solib_catchpoints);
-	  bpstat_clear (&stepping_through_solib_catchpoints);
+	  stop_bpstat = bpstat_copy (ecs->stepping_through_solib_catchpoints);
+	  bpstat_clear (&ecs->stepping_through_solib_catchpoints);
 	  stop_print_frame = 1;
 	  goto stop_stepping;
 	}
@@ -2260,7 +2305,7 @@ wait_for_inferior ()
 #ifdef HP_OS_BUG
 	      trap_expected_after_continue = 1;
 #endif
-	      break;
+	      goto wfi_break;
 	    }
 	}
       
@@ -2303,10 +2348,10 @@ wait_for_inferior ()
       /* We can't update step_sp every time through the loop, because
 	 reading the stack pointer would slow down stepping too much.
 	 But we can update it every time we leave the step range.  */
-      update_step_sp = 1;
+      ecs->update_step_sp = 1;
 
       /* Did we just take a signal?  */
-      if (IN_SIGTRAMP (stop_pc, stop_func_name)
+      if (IN_SIGTRAMP (stop_pc, ecs->stop_func_name)
 	  && !IN_SIGTRAMP (prev_pc, prev_func_name)
 	  && INNER_THAN (read_sp (), step_sp))
 	{
@@ -2365,13 +2410,13 @@ wait_for_inferior ()
                    code, anyway, so it's OK instead to just
                    single-step out.  Note: assuming such trampolines
                    don't exhibit recursion on any platform... */
-		find_pc_partial_function (stop_pc, &stop_func_name,
-					  &stop_func_start,
-					  &stop_func_end);
+		find_pc_partial_function (stop_pc, &ecs->stop_func_name,
+					  &ecs->stop_func_start,
+					  &ecs->stop_func_end);
 		/* Readjust stepping range */
-		step_range_start = stop_func_start;
-		step_range_end = stop_func_end;
-		stepping_through_sigtramp = 1;
+		step_range_start = ecs->stop_func_start;
+		step_range_end = ecs->stop_func_end;
+		ecs->stepping_through_sigtramp = 1;
 	      }
 	  }
 
@@ -2384,15 +2429,15 @@ wait_for_inferior ()
 	       range?  */
 	    step_range_end = (step_range_start = prev_pc) + 1;
 
-	  remove_breakpoints_on_following_step = 1;
+	  ecs->remove_breakpoints_on_following_step = 1;
 	  goto keep_going;
 	}
 
-      if (stop_pc == stop_func_start	/* Quick test */
-	  || (in_prologue (stop_pc, stop_func_start) &&
-	      !IN_SOLIB_RETURN_TRAMPOLINE (stop_pc, stop_func_name))
-	  || IN_SOLIB_CALL_TRAMPOLINE (stop_pc, stop_func_name)
-	  || stop_func_name == 0)
+      if (stop_pc == ecs->stop_func_start	/* Quick test */
+	  || (in_prologue (stop_pc, ecs->stop_func_start) &&
+	      !IN_SOLIB_RETURN_TRAMPOLINE (stop_pc, ecs->stop_func_name))
+	  || IN_SOLIB_CALL_TRAMPOLINE (stop_pc, ecs->stop_func_name)
+	  || ecs->stop_func_name == 0)
 	{
 	  /* It's a subroutine call.  */
 
@@ -2402,7 +2447,7 @@ wait_for_inferior ()
 		 supposed to be stepping at the assembly language level
 		 ("stepi").  Just stop.  */
 	      stop_step = 1;
-	      break;
+	      goto wfi_break;
 	    }
 
 	  if (step_over_calls > 0 || IGNORE_HELPER_CALL (stop_pc))
@@ -2416,7 +2461,7 @@ wait_for_inferior ()
 	     the end of, if we do step into it.  */
 	  tmp = SKIP_TRAMPOLINE_CODE (stop_pc);
 	  if (tmp != 0)
-	    stop_func_start = tmp;
+	    ecs->stop_func_start = tmp;
 	  else
 	    {
 	      tmp = DYNAMIC_TRAMPOLINE_NEXTPC (stop_pc);
@@ -2444,7 +2489,7 @@ wait_for_inferior ()
 	  {
 	    struct symtab_and_line tmp_sal;
 
-	    tmp_sal = find_pc_line (stop_func_start, 0);
+	    tmp_sal = find_pc_line (ecs->stop_func_start, 0);
 	    if (tmp_sal.line != 0)
 	      goto step_into_function;
 	  }
@@ -2491,10 +2536,10 @@ wait_for_inferior ()
                e.g.) and the frame address is likely to be incorrect.
                No danger of sigtramp recursion.  */
 
-	    if (stepping_through_sigtramp)
+	    if (ecs->stepping_through_sigtramp)
 	      {
 		step_resume_breakpoint->frame = (CORE_ADDR) NULL;
-		stepping_through_sigtramp = 0;
+		ecs->stepping_through_sigtramp = 0;
 	      }
 	    else if (!IN_SOLIB_DYNSYM_RESOLVE_CODE (sr_sal.pc))
 	      step_resume_breakpoint->frame = step_frame_address;
@@ -2512,9 +2557,9 @@ wait_for_inferior ()
 
 	    s = find_pc_symtab (stop_pc);
 	    if (s && s->language != language_asm)
-	      stop_func_start = SKIP_PROLOGUE (stop_func_start);
+	      ecs->stop_func_start = SKIP_PROLOGUE (ecs->stop_func_start);
 	  }
-	  sal = find_pc_line (stop_func_start, 0);
+	  ecs->sal = find_pc_line (ecs->stop_func_start, 0);
 	  /* Use the step_resume_break to step until
 	     the end of the prologue, even if that involves jumps
 	     (as it seems to on the vax under 4.2).  */
@@ -2525,15 +2570,15 @@ wait_for_inferior ()
 	  /* no, don't either.  It skips any code that's
 	     legitimately on the first line.  */
 #else
-	  if (sal.end && sal.pc != stop_func_start && sal.end < stop_func_end)
-	    stop_func_start = sal.end;
+	  if (ecs->sal.end && ecs->sal.pc != ecs->stop_func_start && ecs->sal.end < ecs->stop_func_end)
+	    ecs->stop_func_start = ecs->sal.end;
 #endif
 
-	  if (stop_func_start == stop_pc)
+	  if (ecs->stop_func_start == stop_pc)
 	    {
 	      /* We are already there: stop now.  */
 	      stop_step = 1;
-	      break;
+	      goto wfi_break;
 	    }
 	  else
 	    /* Put the step-breakpoint there and go until there. */
@@ -2541,8 +2586,8 @@ wait_for_inferior ()
 	      struct symtab_and_line sr_sal;
 
 	      INIT_SAL (&sr_sal);	/* initialize to zeroes */
-	      sr_sal.pc = stop_func_start;
-	      sr_sal.section = find_pc_overlay (stop_func_start);
+	      sr_sal.pc = ecs->stop_func_start;
+	      sr_sal.section = find_pc_overlay (ecs->stop_func_start);
 	      /* Do not specify what the fp should be when we stop
 		 since on some machines the prologue
 		 is where the new fp value is established.  */
@@ -2559,19 +2604,19 @@ wait_for_inferior ()
 
       /* We've wandered out of the step range.  */
 
-      sal = find_pc_line (stop_pc, 0);
+      ecs->sal = find_pc_line (stop_pc, 0);
 
       if (step_range_end == 1)
 	{
 	  /* It is stepi or nexti.  We always want to stop stepping after
 	     one instruction.  */
 	  stop_step = 1;
-	  break;
+	  goto wfi_break;
 	}
 
       /* If we're in the return path from a shared library trampoline,
 	 we want to proceed through the trampoline when stepping.  */
-      if (IN_SOLIB_RETURN_TRAMPOLINE (stop_pc, stop_func_name))
+      if (IN_SOLIB_RETURN_TRAMPOLINE (stop_pc, ecs->stop_func_name))
 	{
 	  CORE_ADDR tmp;
 
@@ -2601,25 +2646,25 @@ wait_for_inferior ()
 	    }
 	}
 
-      if (sal.line == 0)
+      if (ecs->sal.line == 0)
 	{
 	  /* We have no line number information.  That means to stop
 	     stepping (does this always happen right after one instruction,
 	     when we do "s" in a function with no line numbers,
 	     or can this happen as a result of a return or longjmp?).  */
 	  stop_step = 1;
-	  break;
+	  goto wfi_break;
 	}
 
-      if ((stop_pc == sal.pc)
-	  && (current_line != sal.line || current_symtab != sal.symtab))
+      if ((stop_pc == ecs->sal.pc)
+	  && (ecs->current_line != ecs->sal.line || ecs->current_symtab != ecs->sal.symtab))
 	{
 	  /* We are at the start of a different line.  So stop.  Note that
 	     we don't stop if we step into the middle of a different line.
 	     That is said to make things like for (;;) statements work
 	     better.  */
 	  stop_step = 1;
-	  break;
+	  goto wfi_break;
 	}
 
       /* We aren't done stepping.
@@ -2629,7 +2674,7 @@ wait_for_inferior ()
 	 new line in mid-statement, we continue stepping.  This makes
 	 things like for(;;) statements work better.)  */
 
-      if (stop_func_end && sal.end >= stop_func_end)
+      if (ecs->stop_func_end && ecs->sal.end >= ecs->stop_func_end)
 	{
 	  /* If this is the last line of the function, don't keep stepping
 	     (it would probably step us out of the function).
@@ -2637,13 +2682,13 @@ wait_for_inferior ()
 	     in which after skipping the prologue we better stop even though
 	     we will be in mid-line.  */
 	  stop_step = 1;
-	  break;
+	  goto wfi_break;
 	}
-      step_range_start = sal.pc;
-      step_range_end = sal.end;
+      step_range_start = ecs->sal.pc;
+      step_range_end = ecs->sal.end;
       step_frame_address = FRAME_FP (get_current_frame ());
-      current_line = sal.line;
-      current_symtab = sal.symtab;
+      ecs->current_line = ecs->sal.line;
+      ecs->current_symtab = ecs->sal.symtab;
 
       /* In the case where we just stepped out of a function into the middle
          of a line of the caller, continue stepping, but step_frame_address
@@ -2659,7 +2704,7 @@ wait_for_inferior ()
 
     check_sigtramp2:
       if (trap_expected
-	  && IN_SIGTRAMP (stop_pc, stop_func_name)
+	  && IN_SIGTRAMP (stop_pc, ecs->stop_func_name)
 	  && !IN_SIGTRAMP (prev_pc, prev_func_name)
 	  && INNER_THAN (read_sp (), step_sp))
 	{
@@ -2686,8 +2731,8 @@ wait_for_inferior ()
 	  if (breakpoints_inserted)
 	    insert_breakpoints ();
 
-	  remove_breakpoints_on_following_step = 1;
-	  another_trap = 1;
+	  ecs->remove_breakpoints_on_following_step = 1;
+	  ecs->another_trap = 1;
 	}
 
     keep_going:
@@ -2708,16 +2753,16 @@ wait_for_inferior ()
 
       /* Save the pc before execution, to compare with pc after stop.  */
       prev_pc = read_pc ();	/* Might have been DECR_AFTER_BREAK */
-      prev_func_start = stop_func_start;	/* Ok, since if DECR_PC_AFTER
+      prev_func_start = ecs->stop_func_start;	/* Ok, since if DECR_PC_AFTER
 					  BREAK is defined, the
 					  original pc would not have
 					  been at the start of a
 					  function. */
-      prev_func_name = stop_func_name;
+      prev_func_name = ecs->stop_func_name;
 
-      if (update_step_sp)
+      if (ecs->update_step_sp)
 	step_sp = read_sp ();
-      update_step_sp = 0;
+      ecs->update_step_sp = 0;
 
       /* If we did not do break;, it means we should keep
 	 running the inferior and not return to debugger.  */
@@ -2727,7 +2772,7 @@ wait_for_inferior ()
 	  /* We took a signal (which we are supposed to pass through to
 	     the inferior, else we'd have done a break above) and we
 	     haven't yet gotten our trap.  Simply continue.  */
-	  resume (CURRENTLY_STEPPING (), stop_signal);
+	  resume (currently_stepping (ecs), stop_signal);
 	}
       else
 	{
@@ -2746,22 +2791,22 @@ wait_for_inferior ()
 	     want to hit a breakpoint, pull em out.  */
 	  if (step_resume_breakpoint == NULL
 	      && through_sigtramp_breakpoint == NULL
-	      && remove_breakpoints_on_following_step)
+	      && ecs->remove_breakpoints_on_following_step)
 	    {
-	      remove_breakpoints_on_following_step = 0;
+	      ecs->remove_breakpoints_on_following_step = 0;
 	      remove_breakpoints ();
 	      breakpoints_inserted = 0;
 	    }
 	  else if (!breakpoints_inserted &&
-		   (through_sigtramp_breakpoint != NULL || !another_trap))
+		   (through_sigtramp_breakpoint != NULL || !ecs->another_trap))
 	    {
 	      breakpoints_failed = insert_breakpoints ();
 	      if (breakpoints_failed)
-		break;
+		goto wfi_break;
 	      breakpoints_inserted = 1;
 	    }
 
-	  trap_expected = another_trap;
+	  trap_expected = ecs->another_trap;
 
           /* Do not deliver SIGNAL_TRAP (except when the user
 	     explicitly specifies that such a signal should be
@@ -2793,10 +2838,36 @@ wait_for_inferior ()
 	    SHIFT_INST_REGS ();
 #endif /* SHIFT_INST_REGS */
 
-	  resume (CURRENTLY_STEPPING (), stop_signal);
+	  resume (currently_stepping (ecs), stop_signal);
+	}
+
+      /* Former continues in the main loop goto here.  */
+    wfi_continue:
+      /* This used to be at the top of the loop.  */
+      if (ecs->infwait_state == infwait_normal_state)
+	{
+	  overlay_cache_invalid = 1;
+
+	  /* We have to invalidate the registers BEFORE calling
+	     target_wait because they can be loaded from the target
+	     while in target_wait.  This makes remote debugging a bit
+	     more efficient for those targets that provide critical
+	     registers as part of their normal status mechanism. */
+
+	  registers_changed ();
+	  ecs->waiton_pid = -1;
+	  ecs->wp = &(ecs->ws);
 	}
+      /* This is the old end of the while loop.  Let everybody know
+	 we want to wait for the inferior some more and get called
+	 again soon.  */
+      ecs->wait_some_more = 1;
+      return;
     }
 
+  /* Former breaks in the main loop goto here.  */
+wfi_break:
+
 stop_stepping:
   if (target_has_execution)
     {
@@ -2816,9 +2887,9 @@ stop_stepping:
 	  do
 	    {
 	      if (target_wait_hook)
-		parent_pid = target_wait_hook (-1, &w);
+		parent_pid = target_wait_hook (-1, &(ecs->ws));
 	      else
-		parent_pid = target_wait (-1, &w);
+		parent_pid = target_wait (-1, &(ecs->ws));
 	    }
 	  while (parent_pid != inferior_pid);
 	}
@@ -2827,10 +2898,25 @@ stop_stepping:
 	 time, just like we did above if we didn't break out of the
 	 loop.  */
       prev_pc = read_pc ();
-      prev_func_start = stop_func_start;
-      prev_func_name = stop_func_name;
+      prev_func_start = ecs->stop_func_start;
+      prev_func_name = ecs->stop_func_name;
     }
-  do_cleanups (old_cleanups);
+  /* Let callers know we don't want to wait for the inferior anymore.  */
+  ecs->wait_some_more = 0;
+}
+
+/* Are we in the middle of stepping?  */
+
+int
+currently_stepping (ecs)
+     struct execution_control_state *ecs;
+{
+  return ((through_sigtramp_breakpoint == NULL
+	   && !ecs->handling_longjmp
+	   && ((step_range_end && step_resume_breakpoint == NULL)
+	       || trap_expected))
+	  || ecs->stepping_through_solib_after_catch
+	  || bpstat_should_step ());
 }
 
 /* This function returns TRUE if ep is an internal breakpoint
@@ -3758,6 +3844,17 @@ of the program stops.", &cmdlist);
   signal_stop[TARGET_SIGNAL_WINCH] = 0;
   signal_print[TARGET_SIGNAL_WINCH] = 0;
 
+  /* These signals are used internally by user-level thread
+     implementations.  (See signal(5) on Solaris.)  Like the above
+     signals, a healthy program receives and handles them as part of
+     its normal operation.  */
+  signal_stop[TARGET_SIGNAL_LWP] = 0;
+  signal_print[TARGET_SIGNAL_LWP] = 0;
+  signal_stop[TARGET_SIGNAL_WAITING] = 0;
+  signal_print[TARGET_SIGNAL_WAITING] = 0;
+  signal_stop[TARGET_SIGNAL_CANCEL] = 0;
+  signal_print[TARGET_SIGNAL_CANCEL] = 0;
+
 #ifdef SOLIB_ADD
   add_show_from_set
     (add_set_cmd ("stop-on-solib-events", class_support, var_zinteger,