Changes from the FSF for Hurd thread support.

10 files changed, 773 insertions, 244 deletions

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 3e59a34..3f744e9 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -498,6 +498,24 @@ Sun May 26 14:14:49 1996  Fred Fish  <fnf@cygnus.com>
 	* alpha-nat.c: When compiling under Linux, include <asm/reg.h> and
  	<alpha/ptrace.h> instead of <machine/reg.h>
 
+Tue Jul  2 13:58:10 1996  Miles Bader  <miles@gnu.ai.mit.edu>
+
+	* gnu-nat.c (inf_validate_task_sc):
+	Give terminal to gdb while asking question.
+	(inf_resume): Don't validate the task suspend-count while execing.
+
+Thu Jun 13 11:04:52 1996  Miles Bader  <miles@gnu.ai.mit.edu>
+
+	* gnu-nat.c (inf_validate_task_sc): Query user before clearing any
+	additional suspend count.
+	(S_proc_wait_reply, gnu_attach): Don't call inf_validate_task_sc.
+	(inf_resume): Call inf_validate_task_sc here.
+	(gnu_resume): Call inf_update_procs to ensure noticing new threads.
+
+Fri Jun  7 17:00:43 1996  Miles Bader  <miles@gnu.ai.mit.edu>
+
+	* gnu-nat.c (gnu_create_inferior: attach_to_child): Return PID.
+
 Thu May 23 15:13:56 1996  Jeffrey A Law  (law@cygnus.com)
 
 	* h8300-tdep.c (IS_PUSH): Refine.
@@ -1679,6 +1697,163 @@ Wed Feb 28 22:32:18 1996  Stan Shebs  <shebs@andros.cygnus.com>
 	* remote.c (remote_detach): Send a command 'D' to the target
 	when detaching, update the function's comments.
 
+Thu Jun  6 16:11:38 1996  Miles Bader  <miles@gnu.ai.mit.edu>
+
+	* gnu-nat.c (thread_cmd_list): New declaration.
+	(parse_int_arg): New function.
+
+Wed Jun  5 17:28:04 1996  Miles Bader  <miles@gnu.ai.mit.edu>
+
+	* gnu-nat.h (struct proc): Add DETACH_SC field.
+	* gnu-nat.c (make_proc): Set DETACH_SC.
+	(struct inf): Add DETACH_SC & DEFAULT_THREAD_DETACH_SC fields.
+	(make_inf): Set DETACH_SC & DEFAULT_THREAD_DETACH_SC fields.
+	(add_thread_commands): Add set/show for detach-suspend-count.
+	Add takeover-suspend-count cmd.
+	(inf_detach): Set suspend counts to the detach SC, not 0.
+	(set_thread_detach_sc_cmd, show_thread_detach_sc_cmd,
+	set_task_detach_sc_cmd, show_task_detach_sc_cmd,
+	set_thread_default_thread_detach_sc_cmd,
+	show_thread_default_thread_detach_sc_cmd): New functions.
+	(show_task_cmd): Also show detach-suspend-count values.
+	(thread_takeover_sc_cmd): New function.
+
+Fri May 31 16:49:24 1996  Miles Bader  <miles@gnu.ai.mit.edu>
+
+	* gnu-nat.c (show_thread_run_cmd): Actually print state.
+
+Thu May 30 10:47:56 1996  Miles Bader  <miles@gnu.ai.mit.edu>
+
+	* gnu-nat.c (inf_signal): Make unforwardable exceptions an error.
+
+Tue May 28 17:06:36 1996  Miles Bader  <miles@gnu.ai.mit.edu>
+
+	* gnu-nat.c (inf_validate_stopped): proc_getprocinfo takes a
+	pointer to the flags now, not the flags themselves.
+
+Mon May 27 13:31:17 1996  Miles Bader  <miles@gnu.ai.mit.edu>
+
+	* gnu-nat.c (gnu_wait): Print debugging msgs for pending execs.
+	(gnu_create_inferior): Check return from ptrace.
+
+Sun May 26 16:56:35 1996  Miles Bader  <miles@gnu.ai.mit.edu>
+
+	* gnu-nat.h (struct proc): Add DEAD field.
+	* gnu-nat.c (make_proc): Initialize DEAD.
+	(inf_set_traced, inf_validate_task_sc, inf_validate_procs: Frob it.
+	(gnu_wait): Only abort for 0 threads if the task isn't dead.
+
+Sat May 25 17:06:05 1996  Miles Bader  <miles@gnu.ai.mit.edu>
+
+	* gnu-nat.c (inf_signal): Pass SIGCODE when posting a signal.
+
+Wed May 22 18:44:28 1996  Miles Bader  <miles@gnu.ai.mit.edu>
+
+	* gnu-nat.c (S_proc_wait_reply): Add SIGCODE argument.
+	(inf_set_traced): Only give no-signal-thread error message if
+	turning *on* tracing.
+
+Wed May 15 13:03:16 1996  Miles Bader  <miles@gnu.ai.mit.edu>
+
+	* gnu-nat.c (inf_validate_procs): If INF has no threads, always
+	set inf->threads_up_to_date to 0.
+	(inf_signal): Pass in new SIGCODE argument to msg_sig_post_untraced.
+	(gnu_wait): Pass in new TIMEOUT arg to interrupt_operation.
+	(proc_update_sc): Cast thread state arg to thread_set_state.
+	(proc_get_state): Cast thread state arg to thread_get_state.
+	(inf_validate_task_sc): Cast task_basic_info arg to task_info.
+	* i386gnu-nat.c (gnu_fetch_registers, gnu_store_registers): Call
+	inf_update_procs before we lookup the thread.
+	* config/i386/i386gnu.mh (MH_CFLAGS): New variable.
+
+Tue May  7 17:52:33 1996  Miles Bader  <miles@gnu.ai.mit.edu>
+
+	* gnu-nat.c (gnu_kill_inferior): Use inf_set_task to clear the task.
+
+Mon May  6 19:06:49 1996  Miles Bader  <miles@gnu.ai.mit.edu>
+
+	* gnu-nat.c (inf_set_traced): Use msg_set_init_int with
+	INIT_TRACEMASK instead of setting the exec flags.
+
+Fri May  3 19:10:57 1996  Miles Bader  <miles@gnu.ai.mit.edu>
+
+	* gnu-nat.c (inf_validate_procs): Don't clear INF->task if we find
+	the task's died, so others have a chance at it.
+	(gnu_resume): When single-stepping a single thread, given an error
+	if there is no such thread.  When single-stepping one but running
+	the others, just given a warning and still run all the threads.
+	(gnu_wait): If there seem to be no threads, look harder, and
+	signal an error if there really aren't any.
+	(gnu_attach): Reset thread numbering to 0.
+
+	* i386gnu-nat.c (gnu_fetch_registers, gnu_store_registers): Give
+	thread name in warning messages.
+
+	* gnu-nat.c (active_inf): New function.
+	(show_sig_thread_cmd, show_stopped_cmd): Use it.
+	(info_port_rights, info_send_rights_cmd, info_port_sets_cmd,
+	info_recv_rights_cmd, info_port_rights_cmd, info_port_rights_cmd):
+	New functions.
+	(add_task_commands): Add new port-right info commands.
+
+Fri Apr 26 20:42:16 1996  Miles Bader  <miles@gnu.ai.mit.edu>
+
+	* gnu-nat.c (gnu_wait): Instead of _hurd_intr_rpc_mach_msg, just
+	use mach_msg with MACH_RCV_INTERRUPT.
+	(set_noninvasive_cmd): New function.
+	(add_task_commands): Add command entry for `set noninvasive'.
+
+Mon Mar  4 14:12:02 1996  Miles Bader  <miles@gnu.ai.mit.edu>
+
+	* gnu-nat.c (gnu_read_inferior): Use hurd_safe_memmove, not safe_bcopy.
+	(safe_bcopy): Function removed.
+
+Mon Dec  4 14:18:26 1995  Miles Bader  <miles@gnu.ai.mit.edu>
+
+	* gnu-nat.c (proc_update_sc): Assert only threads can have state.
+	(make_proc): Initialize state_valid & state_changed fields.
+
+Tue Nov 28 17:51:21 1995  Miles Bader  <miles@gnu.ai.mit.edu>
+
+	* reply_mig_hack.awk: New file.
+
+Tue Nov 14 14:31:03 1995  Miles Bader  <miles@gnu.ai.mit.edu>
+
+	* breakpoint.c (breakpoint_1): Print breakpoint thread field.
+
+	* lynx-nat.c (child_wait): Return TARGET_WAITKIND_SPURIOUS for new
+	threads.
+
+Mon Nov 13 18:30:53 1995  Miles Bader  <miles@gnu.ai.mit.edu>
+
+	* target.c (debug_to_check_threads): New function.
+
+	* inflow.c (terminal_init_inferior_with_pgrp): New function.
+	(terminal_init_inferior): Call terminal_init_inferior_with_pgrp.
+	* inferior.h (terminal_init_inferior_with_pgrp): New declaration,
+	but only if PROCESS_GROUP_TYPE is defined.
+
+Mon Nov  6 16:42:09 1995  Miles Bader  <miles@gnu.ai.mit.edu>
+
+	* target.c (debug_to_thread_alive): Pass through the return value.
+
+Thu Nov  2 18:05:00 1995  Miles Bader  <miles@gnu.ai.mit.edu>
+
+	* target.c (signals, target_signal_from_host, target_signal_to_host): 
+	Add mach exceptions.
+	* target.h (enum target_signal): Add mach exceptions.
+
+Mon Oct 30 16:41:04 1995  Miles Bader  <miles@gnu.ai.mit.edu>
+
+	* gnu-nat.c: New file: gnu native backend.
+	* i386gnu-nat.c: New file: i386-specific part of gnu native backend.
+	* gnu-nat.h: New file.
+	* config/nm-gnu.h: New file.
+	* config/tm-i386gnu.h: New file.
+	* config/xm-i386gnu.h: New file.
+	* config/i386/i386gnu.mh: New file.
+	* config/i386/i386gnu.mt: New file.
+
 Wed Feb 28 15:50:12 1996  Fred Fish  <fnf@cygnus.com>
 
 	* Makefile.in (VERSION): Bump version to 4.15.2 to establish
diff --git a/gdb/breakpoint.c b/gdb/breakpoint.c
index 2356288..ff48d94 100644
--- a/gdb/breakpoint.c
+++ b/gdb/breakpoint.c
@@ -932,6 +932,11 @@ bpstat_do_actions (bsp)
   struct cleanup *old_chain;
   struct command_line *cmd;
 
+  /* Avoid endless recursion if a `source' command is contained
+     in bs->commands.  */
+  if (executing_breakpoint_commands)
+    return;
+
   executing_breakpoint_commands = 1;
   old_chain = make_cleanup (cleanup_executing_breakpoints, 0);
 
@@ -1665,7 +1670,7 @@ breakpoint_1 (bnum, allflag)
 			      "watchpoint scope", "call dummy",
 			      "shlib events" };
   static char *bpdisps[] = {"del", "dstp", "dis", "keep"};
-  static char bpenables[] = "ny";
+  static char bpenables[] = "nyn";
   char wrap_indent[80];
 
   ALL_BREAKPOINTS (b)
@@ -1794,6 +1799,12 @@ breakpoint_1 (bnum, allflag)
 	    printf_filtered ("\n");
 	  }
 
+	if (b->thread != -1)
+	  {
+	    /* FIXME should make an annotation for this */
+	    printf_filtered ("\tstop only in thread %d\n", b->thread);
+	  }
+
         if (show_breakpoint_hit_counts && b->hit_count)
 	  {
 	    /* FIXME should make an annotation for this */
diff --git a/gdb/gnu-nat.c b/gdb/gnu-nat.c
index 2d9cbed..55953c0 100644
--- a/gdb/gnu-nat.c
+++ b/gdb/gnu-nat.c
@@ -49,6 +49,8 @@
 #include <hurd/interrupt.h>
 #include <hurd/sigpreempt.h>
 
+#include <portinfo.h>
+
 #include "defs.h"
 #include "inferior.h"
 #include "symtab.h"
@@ -217,10 +219,14 @@ struct inf
      (pausing individual threads as necessary).  */
   int pause_sc;
 
+  /* The task suspend count left when detaching from a task.  */
+  int detach_sc;
+
   /* The initial values used for the run_sc and pause_sc of newly discovered
      threads -- see the definition of those fields in struct proc.  */
   int default_thread_run_sc;
   int default_thread_pause_sc;
+  int default_thread_detach_sc;
 
   /* True if the process should be traced when started/attached.  Newly
      started processes *must* be traced at first to exec them properly, but
@@ -255,7 +261,7 @@ proc_update_sc (struct proc *proc)
       assert (proc_is_thread (proc));
       proc_debug (proc, "storing back changed thread state");
       err = thread_set_state (proc->port, THREAD_STATE_FLAVOR,
-			      &proc->state, THREAD_STATE_SIZE);
+			      (thread_state_t)&proc->state, THREAD_STATE_SIZE);
       if (! err)
 	proc->state_changed = 0;
     }
@@ -353,7 +359,7 @@ proc_get_state (struct proc *proc, int will_modify)
       mach_msg_type_number_t state_size = THREAD_STATE_SIZE;
       error_t err =
 	thread_get_state (proc->port, THREAD_STATE_FLAVOR,
-			  &proc->state, &state_size);
+			  (thread_state_t)&proc->state, &state_size);
       proc_debug (proc, "getting thread state");
       proc->state_valid = !err;
     }
@@ -362,7 +368,7 @@ proc_get_state (struct proc *proc, int will_modify)
     {
       if (will_modify)
 	proc->state_changed = 1;
-      return &proc->state;
+      return (thread_state_t)&proc->state;
     }
   else
     return 0;
@@ -524,12 +530,19 @@ make_proc (struct inf *inf, mach_port_t port, int tid)
   proc->next = 0;
   proc->saved_exc_port = MACH_PORT_NULL;
   proc->exc_port = MACH_PORT_NULL;
+
   proc->sc = 0;
   proc->cur_sc = 0;
+
+  /* Note that these are all the values for threads; the task simply uses the
+     corresponding field in INF directly.  */
   proc->run_sc = inf->default_thread_run_sc;
   proc->pause_sc = inf->default_thread_pause_sc;
+  proc->detach_sc = inf->default_thread_detach_sc;
   proc->resume_sc = proc->run_sc;
+
   proc->aborted = 0;
+  proc->dead = 0;
   proc->state_valid = 0;
   proc->state_changed = 0;
 
@@ -623,8 +636,10 @@ struct inf *make_inf ()
   inf->no_wait = 0;
   inf->pending_execs = 0;
   inf->pause_sc = 1;
+  inf->detach_sc = 0;
   inf->default_thread_run_sc = 0;
   inf->default_thread_pause_sc = 0;
+  inf->default_thread_detach_sc = 0;
   inf->want_signals = 1;	/* By default */
   inf->want_exceptions = 1;	/* By default */
 
@@ -733,8 +748,9 @@ inf_validate_stopped (struct inf *inf)
   mach_msg_type_number_t noise_len = 0;
   struct procinfo *pi;
   mach_msg_type_number_t pi_len = 0;
+  int info_flags = 0;
   error_t err =
-    proc_getprocinfo (proc_server, inf->pid, 0,
+    proc_getprocinfo (proc_server, inf->pid, &info_flags,
 		      (procinfo_t *)&pi, &pi_len, &noise, &noise_len);
 
   if (! err)
@@ -746,17 +762,31 @@ inf_validate_stopped (struct inf *inf)
     }
 }
 
-/* Validates INF's task suspend count.  */
+/* Validates INF's task suspend count.  If it's higher than we expect, verify
+   with the user before `stealing' the extra count.  */
 static void
 inf_validate_task_sc (struct inf *inf)
 {
   struct task_basic_info info;
   mach_msg_type_number_t info_len = TASK_BASIC_INFO_COUNT;
-  error_t err = task_info (inf->task->port, TASK_BASIC_INFO, &info, &info_len);
-  if (! err)
+  error_t err =
+    task_info (inf->task->port, TASK_BASIC_INFO, (task_info_t)&info, &info_len);
+
+  if (err)
+    inf->task->dead = 1;	/* oh well */
+  else if (inf->task->cur_sc < info.suspend_count)
     {
-      if (inf->task->cur_sc < info.suspend_count)
-	warning ("Pid %d is suspended; continuing will clear existing suspend count.", inf->pid);
+      int abort;
+
+      target_terminal_ours ();	/* Allow I/O.  */
+      abort =
+	!query ("Pid %d has an additional task suspend count of %d; clear it? ",
+		inf->pid, info.suspend_count - inf->task->cur_sc);
+      target_terminal_inferior (); /* Give it back to the child.  */
+
+      if (abort)
+	error ("Additional task suspend count left untouched.");
+
       inf->task->cur_sc = info.suspend_count;
     }
 }
@@ -768,16 +798,20 @@ void
 inf_set_traced (struct inf *inf, int on)
 {
   if (on != inf->traced)
-    if (inf->task)
+    if (inf->task && !inf->task->dead)
       /* Make it take effect immediately.  */
       {
-	error_t (*f)(mach_port_t, mach_port_t, int) =
-	  on ? msg_set_some_exec_flags : msg_clear_some_exec_flags;
+	sigset_t mask = on ? ~(sigset_t)0 : 0;
 	error_t err =
-	  INF_RESUME_MSGPORT_RPC (inf, (*f)(msgport, refport, EXEC_TRACED));
+	  INF_RESUME_MSGPORT_RPC (inf, msg_set_init_int (msgport, refport,
+							 INIT_TRACEMASK, mask));
 	if (err == EIEIO)
-	  warning ("Can't modify tracing state for pid %d: No signal thread",
-		   inf->pid);
+	  {
+	    if (on)
+	      warning ("Can't modify tracing state for pid %d: No signal thread",
+		       inf->pid);
+	    inf->traced = on;
+	  }
 	else if (err)
 	  warning ("Can't modify tracing state for pid %d: %s",
 		   inf->pid, strerror (err));
@@ -875,7 +909,11 @@ inf_validate_procs (struct inf *inf)
   unsigned num_threads;
   struct proc *task = inf->task;
 
-  inf->threads_up_to_date = !inf->running;
+  /* If no threads are currently running, this function will guarantee that
+     things are up to date.  The exception is if there are zero threads --
+     then it is almost certainly in an odd state, and probably some outside
+     agent will create threads.  */
+  inf->threads_up_to_date = inf->threads ? !inf->running : 0;
 
   if (task)
     {
@@ -884,9 +922,8 @@ inf_validate_procs (struct inf *inf)
       if (err)
 	/* TASK must be dead.  */
 	{
-	  task->port = MACH_PORT_NULL;
-	  _proc_free (task);
-	  task = inf->task = 0;
+	  task->dead = 1;
+	  task = 0;
 	}
     }
 
@@ -996,7 +1033,14 @@ inf_resume (struct inf *inf)
     thread->sc = thread->resume_sc;
 
   if (inf->task)
-    inf->task->sc = 0;
+    {
+      if (! inf->pending_execs)
+	/* Try to make sure our task count is correct -- in the case where
+	   we're waiting for an exec though, things are too volatile, so just
+	   assume things will be reasonable (which they usually will be).  */
+	inf_validate_task_sc (inf);
+      inf->task->sc = 0;
+    }
 
   inf_update_suspends (inf);
 }
@@ -1087,12 +1131,12 @@ inf_detach (struct inf *inf)
 	inf_signal (inf, TARGET_SIGNAL_0);
 
       proc_restore_exc_port (task);
-      task->sc = 0;
+      task->sc = inf->detach_sc;
 
       for (thread = inf->threads; thread; thread = thread->next)
 	{
 	  proc_restore_exc_port (thread);
-	  thread->sc = 0;
+	  thread->sc = thread->detach_sc;
 	}
 
       inf_update_suspends (inf);
@@ -1188,7 +1232,7 @@ inf_signal (struct inf *inf, enum target_signal sig)
 				     e->exception, e->code, e->subcode);
 	}
       else
-	warning ("Can't forward spontaneous exception (%s).", NAME);
+	error ("Can't forward spontaneous exception (%s).", NAME);
     }
   else
     /* A Unix signal.  */
@@ -1202,7 +1246,7 @@ inf_signal (struct inf *inf, enum target_signal sig)
 			   msg_sig_post_untraced_request (msgport,
 							  inf->event_port,
 							  MACH_MSG_TYPE_MAKE_SEND_ONCE,
-							  host_sig,
+							  host_sig, 0,
 							  refport));
 	if (! err)
 	  /* Posting an untraced signal automatically continues it.
@@ -1220,9 +1264,8 @@ inf_signal (struct inf *inf, enum target_signal sig)
       {
 	inf_debug (inf, "sending %s to unstopped process (so resuming signal thread)", NAME);
 	err = 
-	  INF_RESUME_MSGPORT_RPC (inf,
-				  msg_sig_post_untraced (msgport,
-							 host_sig, refport));
+	  INF_RESUME_MSGPORT_RPC (inf, msg_sig_post_untraced (msgport,
+							      host_sig, 0, refport));
       }
 
   if (err == EIEIO)
@@ -1254,6 +1297,18 @@ gnu_wait (int tid, struct target_waitstatus *status)
   struct proc *thread;
   struct inf *inf = current_inferior;
 
+  assert (inf->task);
+
+  if (!inf->threads && !inf->pending_execs)
+    /* No threads!  Assume that maybe some outside agency is frobbing our
+       task, and really look for new threads.  If we can't find any, just tell
+       the user to try again later.  */
+    {
+      inf_validate_procs (inf);
+      if (!inf->threads && !inf->task->dead)
+	error ("There are no threads; try again later.");
+    }
+
   waiting_inf = inf;
 
   inf_debug (inf, "waiting for: %d", tid);
@@ -1269,7 +1324,7 @@ gnu_wait (int tid, struct target_waitstatus *status)
 	   outstanding wait request, so we have to cancel the previous one. */
 	{
 	  inf_debug (inf, "cancelling previous wait on pid %d", proc_wait_pid);
-	  interrupt_operation (proc_server);
+	  interrupt_operation (proc_server, 0);
 	}
 
       err =
@@ -1294,14 +1349,14 @@ gnu_wait (int tid, struct target_waitstatus *status)
      (3) wait reply from the proc server.  */
 
   inf_debug (inf, "waiting for an event...");
-  err = _hurd_intr_rpc_mach_msg (&msg.hdr, MACH_RCV_MSG, 0,
-				 sizeof (struct msg),
-				 inf->event_port, MACH_PORT_NULL);
+  err = mach_msg (&msg.hdr, MACH_RCV_MSG | MACH_RCV_INTERRUPT,
+		  0, sizeof (struct msg), inf->event_port,
+		  MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
 
   /* Re-suspend the task.  */
   inf_suspend (inf);
 
-  if (err == EINTR)
+  if (err == EMACH_RCV_INTERRUPTED)
     inf_debug (inf, "interrupted");
   else if (err)
     error ("Couldn't wait for an event: %s", strerror (err));
@@ -1339,17 +1394,25 @@ gnu_wait (int tid, struct target_waitstatus *status)
 	/* Since gdb is actually counting the number of times the inferior
 	   stops, expecting one stop per exec, we only return major events
 	   while execing.  */
-	w->suppress = 1;
+	{
+	  w->suppress = 1;
+	  inf_debug (inf, "pending_execs = %d, ignoring minor event",
+		     inf->pending_execs);
+	}
       else if (kind == TARGET_WAITKIND_STOPPED
 	       && w->status.value.sig == TARGET_SIGNAL_TRAP)
 	/* Ah hah!  A SIGTRAP from the inferior while starting up probably
 	   means we've succesfully completed an exec!  */
-	if (--inf->pending_execs == 0)
-	  /* We're done!  */
-	  {
-	    prune_threads (1);	/* Get rid of the old shell threads */
-	    renumber_threads (0); /* Give our threads reasonable names. */
-	  }
+	{
+	  if (--inf->pending_execs == 0)
+	    /* We're done!  */
+	    {
+	      prune_threads (1);	/* Get rid of the old shell threads */
+	      renumber_threads (0); /* Give our threads reasonable names. */
+	    }
+	  inf_debug (inf, "pending exec completed, pending_execs => %d",
+		     inf->pending_execs);
+	}
     }
 
   if (inf->wait.suppress)
@@ -1442,9 +1505,15 @@ S_exception_raise_request (mach_port_t port, mach_port_t reply_port,
 	/* Record the exception so that we can forward it later.  */
 	{
 	  if (thread->exc_port == port)
-	    inf->wait.exc.handler = thread->saved_exc_port;
+	    {
+	      inf_debug (waiting_inf, "Handler is thread exeption port <%d>",
+			 thread->saved_exc_port);
+	      inf->wait.exc.handler = thread->saved_exc_port;
+	    }
 	  else
 	    {
+	      inf_debug (waiting_inf, "Handler is task exeption port <%d>",
+			 inf->task->saved_exc_port);
 	      inf->wait.exc.handler = inf->task->saved_exc_port;
 	      assert (inf->task->exc_port == port);
 	    }
@@ -1484,9 +1553,8 @@ inf_task_died_status (struct inf *inf)
   inf->wait.status.kind = TARGET_WAITKIND_SIGNALLED;
   inf->wait.status.value.sig = TARGET_SIGNAL_KILL;
 }
-
-/* Notify server routines.  The only real one is dead name notification.  */
 
+/* Notify server routines.  The only real one is dead name notification.  */
 error_t
 do_mach_notify_dead_name (mach_port_t notify, mach_port_t dead_port)
 {
@@ -1522,7 +1590,7 @@ do_mach_notify_dead_name (mach_port_t notify, mach_port_t dead_port)
 
   return 0;
 }
-
+
 static error_t
 ill_rpc (char *fun)
 {
@@ -1564,12 +1632,12 @@ do_mach_notify_send_once (mach_port_t notify)
 
 error_t
 S_proc_wait_reply (mach_port_t reply, error_t err,
-		 int status, rusage_t rusage, pid_t pid)
+		   int status, int sigcode, rusage_t rusage, pid_t pid)
 {
   struct inf *inf = waiting_inf;
 
-  inf_debug (inf, "err = %s, pid = %d, status = 0x%x",
-	     err ? strerror (err) : "0", pid, status);
+  inf_debug (inf, "err = %s, pid = %d, status = 0x%x, sigcode = %d",
+	     err ? strerror (err) : "0", pid, status, sigcode);
 
   if (err && proc_wait_pid && (!inf->task || !inf->task->port))
     /* Ack.  The task has died, but the task-died notification code didn't
@@ -1606,10 +1674,6 @@ S_proc_wait_reply (mach_port_t reply, error_t err,
 	{
 	  inf_debug (inf, "process has stopped itself");
 	  inf->stopped = 1;
-
-	  /* We recheck the task suspend count here because the crash server
-	     messes with it in an unfriendly way, right before `stopping'.  */
-	  inf_validate_task_sc (inf);
 	}
     }
   else
@@ -1724,6 +1788,8 @@ gnu_resume (int tid, int step, enum target_signal sig)
        the process, as we're just going to stop it right away anyway. */
     return;
 
+  inf_update_procs (inf);
+
   if (tid < 0)
     /* Allow all threads to run, except perhaps single-stepping one.  */
     {
@@ -1735,8 +1801,8 @@ gnu_resume (int tid, int step, enum target_signal sig)
     /* Just allow a single thread to run.  */
     {
       struct proc *thread = inf_tid_to_thread (inf, tid);
-      assert (thread);
-
+      if (! thread)
+	error ("Can't run single thread id %d: no such thread!");
       inf_debug (inf, "running one thread: %d/%d", inf->pid, thread->tid);
       inf_set_threads_resume_sc (inf, thread, 0);
     }
@@ -1744,8 +1810,10 @@ gnu_resume (int tid, int step, enum target_signal sig)
   if (step)
     {
       step_thread = inf_tid_to_thread (inf, tid);
-      assert (step_thread);
-      inf_debug (inf, "stepping thread: %d/%d", inf->pid, step_thread->tid);
+      if (! step_thread)
+	warning ("Can't step thread id %d: no such thread.", tid);
+      else
+	inf_debug (inf, "stepping thread: %d/%d", inf->pid, step_thread->tid);
     }
   if (step_thread != inf->step_thread)
     inf_set_step_thread (inf, step_thread);
@@ -1762,8 +1830,7 @@ gnu_kill_inferior ()
     {
       proc_debug (task, "terminating...");
       task_terminate (task->port);
-      task->port = MACH_PORT_NULL;
-      inf_validate_procs (current_inferior); /* Clear out the thread list &c */
+      inf_set_task (current_inferior, MACH_PORT_NULL);
     }
   target_mourn_inferior ();
 }
@@ -1813,9 +1880,10 @@ gnu_create_inferior (exec_file, allargs, env)
     {
       /* We're in the child; make this process stop as soon as it execs.  */
       inf_debug (inf, "tracing self");
-      ptrace (PTRACE_TRACEME, 0, 0, 0);
+      if (ptrace (PTRACE_TRACEME) != 0)
+	error ("ptrace (PTRACE_TRACEME) failed!");
     }
-  void attach_to_child (int pid)
+  int attach_to_child (int pid)
     {
       /* Attach to the now stopped child, which is actually a shell...  */
       inf_debug (inf, "attaching to child: %d", pid);
@@ -1834,6 +1902,8 @@ gnu_create_inferior (exec_file, allargs, env)
       inf_resume (inf);
 
       startup_inferior (pid, inf->pending_execs);
+
+      return pid;
     }
 
   inf_debug (inf, "creating inferior");
@@ -1912,7 +1982,8 @@ gnu_attach (args, from_tty)
   /* If the process was stopped before we attached, make it continue the next
      time the user does a continue.  */
   inf_validate_stopped (inf);
-  inf_validate_task_sc (inf);
+
+  renumber_threads (0);		/* Give our threads reasonable names. */
 }
 
 /* Take a program previously attached to and detaches it.
@@ -2320,6 +2391,19 @@ extern struct cmd_list_element *set_thread_default_cmd_list;
 extern struct cmd_list_element *show_thread_default_cmd_list;
 
 static int
+parse_int_arg (char *args, char *cmd_prefix)
+{
+  if (args)
+    {
+      char *arg_end;
+      int val = strtoul (args, &arg_end, 10);
+      if (*args && *arg_end == '\0')
+	return val;
+    }
+  error ("Illegal argument for \"%s\" command, should be an integer.", cmd_prefix);
+}
+
+static int
 _parse_bool_arg (char *args, char *t_val, char *f_val, char *cmd_prefix)
 {
   if (!args || strcmp (args, t_val) == 0)
@@ -2352,6 +2436,16 @@ cur_thread ()
   return thread;
 }
 
+/* Returns the current inferior, but signals an error if it has no task.  */
+static struct inf *
+active_inf ()
+{
+  struct inf *inf = cur_inf ();
+  if (! inf->task)
+    error ("No current process.");
+  return inf;
+}
+
 static void
 set_task_pause_cmd (char *args, int from_tty)
 {
@@ -2378,6 +2472,20 @@ show_task_pause_cmd (char *args, int from_tty)
 }
 
 static void
+set_task_detach_sc_cmd (char *args, int from_tty)
+{
+  cur_inf ()->detach_sc = parse_int_arg (args, "set task detach-suspend-count");
+}
+
+static void
+show_task_detach_sc_cmd (char *args, int from_tty)
+{
+  check_empty (args, "show task detach-suspend-count");
+  printf_unfiltered ("The inferior task will be left with a suspend count of %d when detaching.\n",
+		     cur_inf ()->detach_sc);
+}
+
+static void
 set_thread_default_pause_cmd (char *args, int from_tty)
 {
   struct inf *inf = cur_inf ();
@@ -2393,7 +2501,7 @@ show_thread_default_pause_cmd (char *args, int from_tty)
   check_empty (args, "show thread default pause");
   printf_unfiltered ("New threads %s suspended while gdb has control%s.\n",
 		     sc ? "are" : "aren't",
-		     !sc && inf->pause_sc ? "(but the task is)" : "");
+		     !sc && inf->pause_sc ? " (but the task is)" : "");
 }
 
 static void
@@ -2413,6 +2521,21 @@ show_thread_default_run_cmd (char *args, int from_tty)
 		     inf->default_thread_run_sc == 0 ? "are" : "aren't");
 }
 
+static void
+set_thread_default_detach_sc_cmd (char *args, int from_tty)
+{
+  cur_inf ()->default_thread_detach_sc =
+    parse_int_arg (args, "set thread default detach-suspend-count");
+}
+
+static void
+show_thread_default_detach_sc_cmd (char *args, int from_tty)
+{
+  check_empty (args, "show thread default detach-suspend-count");
+  printf_unfiltered ("New threads will get a detach-suspend-count of %d.\n",
+		     cur_inf ()->default_thread_detach_sc);
+}
+
 /* Steal a send right called NAME in the inferior task, and make it PROC's
    saved exception port.  */
 static void
@@ -2448,7 +2571,7 @@ steal_exc_port (struct proc *proc, mach_port_t name)
 	      proc_string (proc), strerror (err));
     }
 }
-
+
 static void
 set_task_exc_port_cmd (char *args, int from_tty)
 {
@@ -2459,30 +2582,6 @@ set_task_exc_port_cmd (char *args, int from_tty)
 }
 
 static void 
-set_signals_cmd (char *args, int from_tty)
-{
-  int trace;
-  struct inf *inf = cur_inf ();
-
-  inf->want_signals = parse_bool_arg (args, "set signals");
-
-  if (inf->task && inf->want_signals != inf->traced)
-    /* Make this take effect immediately in a running process.  */
-    inf_set_traced (inf, inf->want_signals);
-}
-
-static void
-show_signals_cmd (char *args, int from_tty)
-{
-  struct inf *inf = cur_inf ();
-  check_empty (args, "show signals");
-  printf_unfiltered ("The inferior process's signals %s intercepted.\n",
-		     inf->task
-		     ? (inf->traced ? "are" : "aren't")
-		     : (inf->want_signals ? "will be" : "won't be"));
-}
-
-static void 
 set_stopped_cmd (char *args, int from_tty)
 {
   cur_inf ()->stopped = _parse_bool_arg (args, "yes", "no", "set stopped");
@@ -2491,10 +2590,8 @@ set_stopped_cmd (char *args, int from_tty)
 static void
 show_stopped_cmd (char *args, int from_tty)
 {
-  struct inf *inf = cur_inf ();
+  struct inf *inf = active_inf ();
   check_empty (args, "show stopped");
-  if (! inf->task)
-    error ("No current process.");
   printf_unfiltered ("The inferior process %s stopped.\n",
 		     inf->stopped ? "is" : "isn't");
 }
@@ -2524,16 +2621,38 @@ set_sig_thread_cmd (char *args, int from_tty)
 static void
 show_sig_thread_cmd (char *args, int from_tty)
 {
-  struct inf *inf = cur_inf ();
+  struct inf *inf = active_inf ();
   check_empty (args, "show signal-thread");
-  if (! inf->task)
-    error ("No current process.");
   if (inf->signal_thread)
     printf_unfiltered ("The signal thread is %s.\n",
 		       proc_string (inf->signal_thread));
   else
     printf_unfiltered ("There is no signal thread.\n");
 }
+
+static void 
+set_signals_cmd (char *args, int from_tty)
+{
+  int trace;
+  struct inf *inf = cur_inf ();
+
+  inf->want_signals = parse_bool_arg (args, "set signals");
+
+  if (inf->task && inf->want_signals != inf->traced)
+    /* Make this take effect immediately in a running process.  */
+    inf_set_traced (inf, inf->want_signals);
+}
+
+static void
+show_signals_cmd (char *args, int from_tty)
+{
+  struct inf *inf = cur_inf ();
+  check_empty (args, "show signals");
+  printf_unfiltered ("The inferior process's signals %s intercepted.\n",
+		     inf->task
+		     ? (inf->traced ? "are" : "aren't")
+		     : (inf->want_signals ? "will be" : "won't be"));
+}
 
 static void 
 set_exceptions_cmd (char *args, int from_tty)
@@ -2558,7 +2677,7 @@ show_exceptions_cmd (char *args, int from_tty)
 		     ? (inf->want_exceptions ? "are" : "aren't")
 		     : (inf->want_exceptions ? "will be" : "won't be"));
 }
-
+
 static void
 set_task_cmd (char *args, int from_tty)
 {
@@ -2585,8 +2704,83 @@ show_task_cmd (char *args, int from_tty)
       show_stopped_cmd (0, from_tty);
       show_sig_thread_cmd (0, from_tty);
     }
+
+  if (inf->detach_sc != 0)
+    show_task_detach_sc_cmd (0, from_tty);
+  if (inf->default_thread_detach_sc != 0)
+    show_thread_default_detach_sc_cmd (0, from_tty);
+}
+
+static void
+set_noninvasive_cmd (char *args, int from_tty)
+{
+  /* Invert the sense of the arg for each component.  */
+  char *inv_args = parse_bool_arg (args, "set noninvasive") ? "off" : "on";
+
+  set_task_pause_cmd (inv_args, from_tty);
+  set_signals_cmd (inv_args, from_tty);
+  set_exceptions_cmd (inv_args, from_tty);
+}
+
+static void
+info_port_rights (char *args, mach_port_type_t only)
+{
+  struct inf *inf = active_inf ();
+  value_ptr vmark = value_mark ();
+
+  if (args)
+    /* Explicit list of port rights.  */
+    {
+      while (*args)
+	{
+	  value_ptr val = parse_to_comma_and_eval (&args);
+	  long right = value_as_long (val);
+	  error_t err =
+	    print_port_info (right, 0, inf->task->port, PORTINFO_DETAILS,
+			     stdout);
+	  if (err)
+	    error ("%ld: %s.", right, strerror (err));
+	}
+    }
+  else
+    /* Print all of them.  */
+    {
+      error_t err =
+	print_task_ports_info (inf->task->port, only, PORTINFO_DETAILS,
+			       stdout);
+      if (err)
+	error ("%s.", strerror (err));
+    }
+
+  value_free_to_mark (vmark);
 }
 
+static void
+info_send_rights_cmd (char *args, int from_tty)
+{
+  info_port_rights (args, MACH_PORT_TYPE_SEND);
+}
+static void
+info_recv_rights_cmd (char *args, int from_tty)
+{
+  info_port_rights (args, MACH_PORT_TYPE_RECEIVE);
+}
+static void
+info_port_sets_cmd (char *args, int from_tty)
+{
+  info_port_rights (args, MACH_PORT_TYPE_PORT_SET);
+}
+static void
+info_dead_names_cmd (char *args, int from_tty)
+{
+  info_port_rights (args, MACH_PORT_TYPE_DEAD_NAME);
+}
+static void
+info_port_rights_cmd (char *args, int from_tty)
+{
+  info_port_rights (args, ~0);
+}
+
 static void add_task_commands ()
 {
   add_cmd ("pause", class_run, set_thread_default_pause_cmd,
@@ -2605,6 +2799,12 @@ static void add_task_commands ()
 	   "Show whether new threads are allowed to run (once gdb has noticed
 them).",
 	   &show_thread_default_cmd_list);
+  add_cmd ("detach-suspend-count", class_run, set_thread_default_detach_sc_cmd,
+	   "Set the default detach-suspend-count value for new threads.",
+	   &set_thread_default_cmd_list);
+  add_cmd ("detach-suspend-count", no_class, show_thread_default_detach_sc_cmd,
+	   "Show the default detach-suspend-count value for new threads.",
+	   &show_thread_default_cmd_list);
 
   add_cmd ("signals", class_run, set_signals_cmd,
 	   "Set whether the inferior process's signals will be intercepted.\n"
@@ -2645,8 +2845,6 @@ them).",
 	   "Show whether exceptions in the inferior process will be trapped.",
 	   &showlist);
 
-  
-
   add_prefix_cmd ("task", no_class, set_task_cmd,
 		  "Command prefix for setting task attributes.",
 		  &set_task_cmd_list, "set task ", 0, &setlist);
@@ -2664,6 +2862,12 @@ them).",
   add_cmd ("pause", no_class, show_task_pause_cmd,
 	   "Show whether the task is suspended while gdb has control.",
 	   &show_task_cmd_list);
+  add_cmd ("detach-suspend-count", class_run, set_task_detach_sc_cmd,
+	   "Set the suspend count will leave on the thread when detaching.",
+	   &set_task_cmd_list);
+  add_cmd ("detach-suspend-count", no_class, show_task_detach_sc_cmd,
+	   "Show the suspend count will leave on the thread when detaching.",
+	   &show_task_cmd_list);
 
   add_cmd ("exception-port", no_class, set_task_exc_port_cmd,
 	   "Set the task exception port to which we forward exceptions.\n"
@@ -2671,12 +2875,41 @@ them).",
 	   &set_task_cmd_list);
   add_alias_cmd ("excp", "exception-port", no_class, 1, &set_task_cmd_list);
   add_alias_cmd ("exc-port", "exception-port", no_class, 1, &set_task_cmd_list);
+
+  /* A convenient way of turning on all options require to noninvasively
+     debug running tasks.  */
+  add_cmd ("noninvasive", no_class, set_noninvasive_cmd,
+	   "Set task options so that we interfere as little as possible.\n"
+	   "This is the same as setting `task pause', `exceptions', and"
+	   "`signals' to the opposite value.",
+	   &setlist);
+
+  /* Commands to show information about the task's ports.  */
+  add_cmd ("send-rights", class_info, info_send_rights_cmd,
+	   "Show information about the task's send rights",
+	   &infolist);
+  add_cmd ("receive-rights", class_info, info_recv_rights_cmd,
+	   "Show information about the task's receive rights",
+	   &infolist);
+  add_cmd ("port-rights", class_info, info_send_rights_cmd,
+	   "Show information about the task's port rights",
+	   &infolist);
+  add_cmd ("port-sets", class_info, info_port_sets_cmd,
+	   "Show information about the task's port sets",
+	   &infolist);
+  add_cmd ("dead-names", class_info, info_dead_names_cmd,
+	   "Show information about the task's dead names",
+	   &infolist);
+  add_info_alias ("ports", "port-rights", 1);
+  add_info_alias ("port", "port-rights", 1);
+  add_info_alias ("psets", "port-sets", 1);
 }
 
 /* User thread commands.  */
 
 extern struct cmd_list_element *set_thread_cmd_list;
 extern struct cmd_list_element *show_thread_cmd_list;
+extern struct cmd_list_element *thread_cmd_list;
 
 static void
 set_thread_pause_cmd (char *args, int from_tty)
@@ -2699,7 +2932,7 @@ show_thread_pause_cmd (char *args, int from_tty)
   printf_unfiltered ("Thread %s %s suspended while gdb has control%s.\n",
 		     proc_string (thread),
 		     sc ? "is" : "isn't",
-		     !sc && thread->inf->pause_sc ? "(but the task is)" : "");
+		     !sc && thread->inf->pause_sc ? " (but the task is)" : "");
 }
 
 static void
@@ -2714,12 +2947,28 @@ show_thread_run_cmd (char *args, int from_tty)
 {
   struct proc *thread = cur_thread ();
   check_empty (args, "show thread run");
-  printf_unfiltered ("Thread %s allowed to run.",
+  printf_unfiltered ("Thread %s %s allowed to run.",
 		     proc_string (thread),
 		     thread->run_sc == 0 ? "is" : "isn't");
 }
 
 static void
+set_thread_detach_sc_cmd (char *args, int from_tty)
+{
+  cur_thread ()->detach_sc = parse_int_arg (args, "set thread detach-suspend-count");
+}
+
+static void
+show_thread_detach_sc_cmd (char *args, int from_tty)
+{
+  struct proc *thread = cur_thread ();
+  check_empty (args, "show thread detach-suspend-count");
+  printf_unfiltered ("Thread %s will be left with a suspend count of %d when detaching.\n",
+		     proc_string (thread),
+		     thread->detach_sc);
+}
+
+static void
 set_thread_exc_port_cmd (char *args, int from_tty)
 {
   struct proc *thread = cur_thread ();
@@ -2737,9 +2986,30 @@ set_thread_cmd (char *args, int from_tty)
 static void
 show_thread_cmd (char *args, int from_tty)
 {
+  struct proc *thread = cur_thread ();
   check_empty (args, "show thread");
   show_thread_run_cmd (0, from_tty);
   show_thread_pause_cmd (0, from_tty);
+  if (thread->detach_sc != 0)
+    show_thread_detach_sc_cmd (0, from_tty);
+}
+
+static void
+thread_takeover_sc_cmd (char *args, int from_tty)
+{
+  struct proc *thread = cur_thread ();
+  thread_basic_info_data_t _info;
+  thread_basic_info_t info = &_info;
+  mach_msg_type_number_t info_len = THREAD_BASIC_INFO_COUNT;
+  error_t err =
+    thread_info (thread->port, THREAD_BASIC_INFO, (int *)&info, &info_len);
+  if (err)
+    error ("%s.", strerror (err));
+  thread->sc = info->suspend_count;
+  if (from_tty)
+    printf_unfiltered ("Suspend count was %d.\n", thread->sc);
+  if (info != &_info)
+    vm_deallocate (mach_task_self (), (vm_address_t)info, info_len * sizeof (int));
 }
 
 add_thread_commands ()
@@ -2763,6 +3033,17 @@ add_thread_commands ()
 	   "Show whether the current thread is allowed to run.",
 	   &show_thread_cmd_list);
 
+  add_cmd ("detach-suspend-count", class_run, set_thread_detach_sc_cmd,
+	   "Set the suspend count will leave on the thread when detaching.\n"
+	   "Note that this is relative to suspend count when gdb noticed the thread;\n"
+	   "use the `thread takeover-suspend-count' to force it to an absolute value.",
+	   &set_thread_cmd_list);
+  add_cmd ("detach-suspend-count", no_class, show_thread_detach_sc_cmd,
+	   "Show the suspend count will leave on the thread when detaching."
+	   "Note that this is relative to suspend count when gdb noticed the thread;\n"
+	   "use the `thread takeover-suspend-count' to force it to an absolute value.",
+	   &show_thread_cmd_list);
+
   add_cmd ("exception-port", no_class, set_thread_exc_port_cmd,
 	   "Set the exception port to which we forward exceptions for the\n"
 	   "current thread, overriding the task exception port.\n"
@@ -2770,6 +3051,12 @@ add_thread_commands ()
 	   &set_thread_cmd_list);
   add_alias_cmd ("excp", "exception-port", no_class, 1, &set_thread_cmd_list);
   add_alias_cmd ("exc-port", "exception-port", no_class, 1, &set_thread_cmd_list);
+
+  add_cmd ("takeover-suspend-count", no_class, thread_takeover_sc_cmd,
+	   "Force the threads absolute suspend-count to be gdb's.\n"
+	   "Prior to giving this command, gdb's thread suspend-counts are relative to\n"
+	   "the thread's initial suspend-count when gdb notices the threads.",
+	   &thread_cmd_list);
 }
 
 void
diff --git a/gdb/gnu-nat.h b/gdb/gnu-nat.h
index 6f29b73..8f0ab7b 100644
--- a/gdb/gnu-nat.h
+++ b/gdb/gnu-nat.h
@@ -1,6 +1,6 @@
 /* Common things used by the various *gnu-nat.c files
 
-   Copyright (C) 1995 Free Software Foundation, Inc.
+   Copyright (C) 1995, 1996 Free Software Foundation, Inc.
 
    Written by Miles Bader <miles@gnu.ai.mit.edu>
 
@@ -47,12 +47,14 @@ struct proc
   int run_sc;			/* Default sc when the program is running. */
   int pause_sc;			/* Default sc when gdb has control. */
   int resume_sc;		/* Sc resulting form the last resume. */
+  int detach_sc;		/* SC to leave around when detaching from program. */
 
   thread_state_data_t state;	/* Registers, &c. */
   int state_valid : 1;		/* True if STATE is up to date. */
   int state_changed : 1;
 
   int aborted : 1;		/* True if thread_abort has been called.  */
+  int dead : 1;			/* We happen to know it's actually dead. */
 
   /* Bit mask of registers fetched by gdb.  This is used when we re-fetch
      STATE after aborting the thread, to detect that gdb may have out-of-date
diff --git a/gdb/i386gnu-nat.c b/gdb/i386gnu-nat.c
index 63c3bd0..74a1c73 100644
--- a/gdb/i386gnu-nat.c
+++ b/gdb/i386gnu-nat.c
@@ -1,5 +1,5 @@
 /* Low level interface to I386 running the GNU Hurd
-   Copyright (C) 1992 Free Software Foundation, Inc.
+   Copyright (C) 1992, 1995, 1996 Free Software Foundation, Inc.
 
 This file is part of GDB.
 
@@ -22,6 +22,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 #include "floatformat.h"
 
 #include <stdio.h>
+#include <errno.h>
 
 #include <mach.h>
 #include <mach/message.h>
@@ -81,16 +82,20 @@ static int reg_offset[] =
 void
 gnu_fetch_registers (int reg)
 {
+  struct proc *thread;
   thread_state_t state;
-  struct proc *thread = inf_tid_to_thread (current_inferior, inferior_pid);
   
-  if (!thread)
+  inf_update_procs (current_inferior); /* Make sure we know about new threads.  */
+
+  thread = inf_tid_to_thread (current_inferior, inferior_pid);
+  if (! thread)
     error ("fetch inferior registers: %d: Invalid thread", inferior_pid);
 
   state = proc_get_state (thread, 0);
 
   if (! state)
-    warning ("Couldn't fetch register %s.", reg_names[reg]);
+    warning ("Couldn't fetch register %s from %s (invalid thread).",
+	     reg_names[reg], proc_string (thread));
   else if (reg >= 0)
     {
       proc_debug (thread, "fetching register: %s", reg_names[reg]);
@@ -116,11 +121,14 @@ void
 gnu_store_registers (reg)
      int reg;
 {
+  struct proc *thread;
   int was_aborted, was_valid;
   thread_state_t state;
   thread_state_data_t old_state;
-  struct proc *thread = inf_tid_to_thread (current_inferior, inferior_pid);
+  
+  inf_update_procs (current_inferior); /* Make sure we know about new threads.  */
 
+  thread = inf_tid_to_thread (current_inferior, inferior_pid);
   if (! thread)
     error ("store inferior registers: %d: Invalid thread", inferior_pid);
 
@@ -134,7 +142,8 @@ gnu_store_registers (reg)
   state = proc_get_state (thread, 1);
 
   if (! state)
-    warning ("Couldn't store register %s.", reg_names[reg]);
+    warning ("Couldn't store register %s from %s (invalid thread).",
+	     reg_names[reg], proc_string (thread));
   else
     {
       if (! was_aborted && was_valid)
diff --git a/gdb/inferior.h b/gdb/inferior.h
index 014eecc..02a4e2e 100644
--- a/gdb/inferior.h
+++ b/gdb/inferior.h
@@ -1,6 +1,6 @@
 /* Variables that describe the inferior process running under GDB:
    Where it is, why it stopped, and how to step it.
-   Copyright 1986, 1989, 1992 Free Software Foundation, Inc.
+   Copyright 1986, 1989, 1992, 1996 Free Software Foundation, Inc.
 
 This file is part of GDB.
 
@@ -16,7 +16,7 @@ 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
-Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 
 #if !defined (INFERIOR_H)
 #define INFERIOR_H 1
@@ -24,24 +24,19 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 /* For bpstat.  */
 #include "breakpoint.h"
 
-/* For FRAME_ADDR.  */
-#include "frame.h"
-
 /* For enum target_signal.  */
 #include "target.h"
 
-/*
- * Structure in which to save the status of the inferior.  Save
- * through "save_inferior_status", restore through
- * "restore_inferior_status".
- * This pair of routines should be called around any transfer of
- * control to the inferior which you don't want showing up in your
- * control variables.
- */
+/* Structure in which to save the status of the inferior.  Save
+   through "save_inferior_status", restore through
+   "restore_inferior_status".
+   This pair of routines should be called around any transfer of
+   control to the inferior which you don't want showing up in your
+   control variables.  */
+
 struct inferior_status {
   enum target_signal stop_signal;
   CORE_ADDR stop_pc;
-  FRAME_ADDR stop_frame_address;
   bpstat stop_bpstat;
   int stop_step;
   int stop_stack_dummy;
@@ -49,12 +44,12 @@ struct inferior_status {
   int trap_expected;
   CORE_ADDR step_range_start;
   CORE_ADDR step_range_end;
-  FRAME_ADDR step_frame_address;
+  CORE_ADDR step_frame_address;
   int step_over_calls;
   CORE_ADDR step_resume_break_address;
   int stop_after_trap;
   int stop_soon_quietly;
-  FRAME_ADDR selected_frame_address;
+  CORE_ADDR selected_frame_address;
   int selected_level;
   char stop_registers[REGISTER_BYTES];
 
@@ -68,16 +63,24 @@ struct inferior_status {
   int proceed_to_finish;
 };
 
-extern void
-save_inferior_status PARAMS ((struct inferior_status *, int));
+/* This macro gives the number of registers actually in use by the
+   inferior.  This may be less than the total number of registers,
+   perhaps depending on the actual CPU in use or program being run.  */
+
+#ifndef ARCH_NUM_REGS
+#define ARCH_NUM_REGS NUM_REGS
+#endif
+
+extern void save_inferior_status PARAMS ((struct inferior_status *, int));
 
-extern void
-restore_inferior_status PARAMS ((struct inferior_status *));
+extern void restore_inferior_status PARAMS ((struct inferior_status *));
 
 extern void set_sigint_trap PARAMS ((void));
+
 extern void clear_sigint_trap PARAMS ((void));
 
 extern void set_sigio_trap PARAMS ((void));
+
 extern void clear_sigio_trap PARAMS ((void));
 
 /* File name for default use for standard in/out in the inferior.  */
@@ -88,6 +91,10 @@ extern char *inferior_io_terminal;
 
 extern int inferior_pid;
 
+/* Inferior environment. */
+
+extern struct environ *inferior_environ;
+
 /* Character array containing an image of the inferior programs' registers.  */
 
 extern char registers[];
@@ -97,149 +104,116 @@ extern char registers[];
 
 extern char register_valid[NUM_REGS];
 
-extern void
-clear_proceed_status PARAMS ((void));
+extern void clear_proceed_status PARAMS ((void));
 
-extern void
-proceed PARAMS ((CORE_ADDR, enum target_signal, int));
+extern void proceed PARAMS ((CORE_ADDR, enum target_signal, int));
 
-extern void
-kill_inferior PARAMS ((void));
+extern void kill_inferior PARAMS ((void));
 
-extern void
-generic_mourn_inferior PARAMS ((void));
+extern void generic_mourn_inferior PARAMS ((void));
 
-extern void
-terminal_ours PARAMS ((void));
+extern void terminal_ours PARAMS ((void));
 
 extern int run_stack_dummy PARAMS ((CORE_ADDR, char [REGISTER_BYTES]));
 
-extern CORE_ADDR
-read_pc PARAMS ((void));
+extern CORE_ADDR read_pc PARAMS ((void));
 
-extern CORE_ADDR
-read_pc_pid PARAMS ((int));
+extern CORE_ADDR read_pc_pid PARAMS ((int));
 
-extern void
-write_pc PARAMS ((CORE_ADDR));
+extern void write_pc PARAMS ((CORE_ADDR));
 
-extern CORE_ADDR
-read_sp PARAMS ((void));
+extern CORE_ADDR read_sp PARAMS ((void));
 
-extern void
-write_sp PARAMS ((CORE_ADDR));
+extern void write_sp PARAMS ((CORE_ADDR));
 
-extern CORE_ADDR
-read_fp PARAMS ((void));
+extern CORE_ADDR read_fp PARAMS ((void));
 
-extern void
-write_fp PARAMS ((CORE_ADDR));
+extern void write_fp PARAMS ((CORE_ADDR));
 
-extern void
-wait_for_inferior PARAMS ((void));
+extern void wait_for_inferior PARAMS ((void));
 
-extern void
-init_wait_for_inferior PARAMS ((void));
+extern void init_wait_for_inferior PARAMS ((void));
 
-extern void
-close_exec_file PARAMS ((void));
+extern void close_exec_file PARAMS ((void));
 
-extern void
-reopen_exec_file PARAMS ((void));
+extern void reopen_exec_file PARAMS ((void));
 
 /* The `resume' routine should only be called in special circumstances.
    Normally, use `proceed', which handles a lot of bookkeeping.  */
-extern void
-resume PARAMS ((int, enum target_signal));
+
+extern void resume PARAMS ((int, enum target_signal));
 
 /* From misc files */
 
-extern void
-store_inferior_registers PARAMS ((int));
+extern void store_inferior_registers PARAMS ((int));
 
-extern void
-fetch_inferior_registers PARAMS ((int));
+extern void fetch_inferior_registers PARAMS ((int));
 
-extern void 
-solib_create_inferior_hook PARAMS ((void));
+extern void  solib_create_inferior_hook PARAMS ((void));
 
-extern void
-child_terminal_info PARAMS ((char *, int));
+extern void child_terminal_info PARAMS ((char *, int));
 
-extern void
-term_info PARAMS ((char *, int));
+extern void term_info PARAMS ((char *, int));
 
-extern void
-terminal_ours_for_output PARAMS ((void));
+extern void terminal_ours_for_output PARAMS ((void));
 
-extern void
-terminal_inferior PARAMS ((void));
+extern void terminal_inferior PARAMS ((void));
 
-extern void
-terminal_init_inferior PARAMS ((void));
+extern void terminal_init_inferior PARAMS ((void));
+
+#ifdef PROCESS_GROUP_TYPE
+extern void terminal_init_inferior_with_pgrp PARAMS ((PROCESS_GROUP_TYPE pgrp));
+#endif
 
 /* From infptrace.c */
 
-extern int
-attach PARAMS ((int));
+extern int attach PARAMS ((int));
 
-void
-detach PARAMS ((int));
+void detach PARAMS ((int));
 
-extern void
-child_resume PARAMS ((int, int, enum target_signal));
+extern void child_resume PARAMS ((int, int, enum target_signal));
 
 #ifndef PTRACE_ARG3_TYPE
 #define PTRACE_ARG3_TYPE int	/* Correct definition for most systems. */
 #endif
 
-extern int
-call_ptrace PARAMS ((int, int, PTRACE_ARG3_TYPE, int));
+extern int call_ptrace PARAMS ((int, int, PTRACE_ARG3_TYPE, int));
 
 /* From procfs.c */
 
-extern int
-proc_iterate_over_mappings PARAMS ((int (*) (int, CORE_ADDR)));
+extern int proc_iterate_over_mappings PARAMS ((int (*) (int, CORE_ADDR)));
 
 /* From fork-child.c */
 
 extern void fork_inferior PARAMS ((char *, char *, char **,
 				   void (*) (void),
-				   void (*) (int), char *));
+				   int (*) (int), char *));
 
 extern void startup_inferior PARAMS ((int));
 
 /* From inflow.c */
 
-extern void
-new_tty_prefork PARAMS ((char *));
+extern void new_tty_prefork PARAMS ((char *));
 
 extern int gdb_has_a_terminal PARAMS ((void));
 
 /* From infrun.c */
 
-extern void
-start_remote PARAMS ((void));
+extern void start_remote PARAMS ((void));
 
-extern void
-normal_stop PARAMS ((void));
+extern void normal_stop PARAMS ((void));
 
-extern int
-signal_stop_state PARAMS ((int));
+extern int signal_stop_state PARAMS ((int));
 
-extern int
-signal_print_state PARAMS ((int));
+extern int signal_print_state PARAMS ((int));
 
-extern int
-signal_pass_state PARAMS ((int));
+extern int signal_pass_state PARAMS ((int));
 
 /* From infcmd.c */
 
-extern void
-tty_command PARAMS ((char *, int));
+extern void tty_command PARAMS ((char *, int));
 
-extern void
-attach_command PARAMS ((char *, int));
+extern void attach_command PARAMS ((char *, int));
 
 /* Last signal that the inferior received (why it stopped).  */
 
@@ -249,10 +223,6 @@ extern enum target_signal stop_signal;
 
 extern CORE_ADDR stop_pc;
 
-/* Stack frame when program stopped.  */
-
-extern FRAME_ADDR stop_frame_address;
-
 /* Chain containing status of breakpoint(s) that we have stopped at.  */
 
 extern bpstat stop_bpstat;
@@ -291,7 +261,11 @@ extern CORE_ADDR step_range_end; /* Exclusive */
    This is how we know when we step into a subroutine call,
    and how to set the frame for the breakpoint used to step out.  */
 
-extern FRAME_ADDR step_frame_address;
+extern CORE_ADDR step_frame_address;
+
+/* Our notion of the current stack pointer.  */
+
+extern CORE_ADDR step_sp;
 
 /* 1 means step over all subroutine calls.
    -1 means step over calls to undebuggable functions.  */
diff --git a/gdb/inflow.c b/gdb/inflow.c
index 788d786..23f828b 100644
--- a/gdb/inflow.c
+++ b/gdb/inflow.c
@@ -15,7 +15,7 @@ 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
-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"
@@ -25,18 +25,12 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 #include "serial.h"
 #include "terminal.h"
 #include "target.h"
-#include "thread.h"
+#include "gdbthread.h"
 
 #include "gdb_string.h"
 #include <signal.h>
 #include <fcntl.h>
-
-#if !defined (HAVE_TERMIOS) && !defined (HAVE_TERMIO) && !defined (HAVE_SGTTY) && !defined (__GO32__) && !defined(WIN32)
-#define HAVE_SGTTY
-#endif
-
-#if defined (HAVE_TERMIOS)
-#include <termios.h>
+#ifdef HAVE_UNISTD_H
 #include <unistd.h>
 #endif
 
@@ -161,7 +155,8 @@ static void terminal_ours_1 PARAMS ((int));
    before we actually run the inferior.  */
 
 void
-terminal_init_inferior ()
+terminal_init_inferior_with_pgrp (pgrp)
+     int pgrp;
 {
   if (gdb_has_a_terminal ())
     {
@@ -170,18 +165,9 @@ terminal_init_inferior ()
       if (inferior_ttystate)
 	free (inferior_ttystate);
       inferior_ttystate = SERIAL_GET_TTY_STATE (stdin_serial);
+
 #ifdef PROCESS_GROUP_TYPE
-#ifdef PIDGET
-      /* This is for Lynx, and should be cleaned up by having Lynx be
-	 a separate debugging target with a version of
-	 target_terminal_init_inferior which passes in the process
-	 group to a generic routine which does all the work (and the
-	 non-threaded child_terminal_init_inferior can just pass in
-	 inferior_pid to the same routine).  */
-      inferior_process_group = PIDGET (inferior_pid);
-#else
-      inferior_process_group = inferior_pid;
-#endif
+      inferior_process_group = pgrp;
 #endif
 
       /* Make sure that next time we call terminal_inferior (which will be
@@ -191,6 +177,24 @@ terminal_init_inferior ()
     }
 }
 
+void
+terminal_init_inferior ()
+{
+#ifdef PROCESS_GROUP_TYPE
+#ifdef PIDGET
+  /* This is for Lynx, and should be cleaned up by having Lynx be a separate
+     debugging target with a version of target_terminal_init_inferior which
+     passes in the process group to a generic routine which does all the work
+     (and the non-threaded child_terminal_init_inferior can just pass in
+     inferior_pid to the same routine).  */
+  terminal_init_inferior_with_pgrp (PIDGET (inferior_pid));
+#else
+  /* By default, we assume INFERIOR_PID is also the child's process group.  */
+  terminal_init_inferior_with_pgrp (inferior_pid);
+#endif
+#endif /* PROCESS_GROUP_TYPE */
+}
+
 /* Put the inferior's terminal settings into effect.
    This is preparation for starting or resuming the inferior.  */
 
@@ -484,7 +488,7 @@ new_tty ()
 
   if (inferior_thisrun_terminal == 0)
     return;
-#if !defined(__GO32__) && !defined(WIN32)
+#if !defined(__GO32__) && !defined(__WIN32__)
 #ifdef TIOCNOTTY
   /* Disconnect the child process from our controlling terminal.  On some
      systems (SVR4 for example), this may cause a SIGTTOU, so temporarily
@@ -666,8 +670,7 @@ gdb_setpgid ()
 
   if (job_control)
     {
-#if defined (NEED_POSIX_SETPGID) || defined (HAVE_TERMIOS)
-      /* Do all systems with termios have setpgid?  I hope so.  */
+#if defined (NEED_POSIX_SETPGID) || (defined (HAVE_TERMIOS) && defined (HAVE_SETPGID))
       /* setpgid (0, 0) is supposed to work and mean the same thing as
 	 this, but on Ultrix 4.2A it fails with EPERM (and
 	 setpgid (getpid (), getpid ()) succeeds).  */
@@ -707,9 +710,13 @@ _initialize_inflow ()
 #ifdef _POSIX_JOB_CONTROL
   job_control = 1;
 #else
+#ifdef _SC_JOB_CONTROL
   job_control = sysconf (_SC_JOB_CONTROL);
-#endif
-#endif /* termios */
+#else
+  job_control = 0;	/* have to assume the worst */
+#endif	/* _SC_JOB_CONTROL */
+#endif	/* _POSIX_JOB_CONTROL */
+#endif	/* HAVE_TERMIOS */
 
 #ifdef HAVE_SGTTY
 #ifdef TIOCGPGRP
diff --git a/gdb/lynx-nat.c b/gdb/lynx-nat.c
index 78716e0..b9b8717 100644
--- a/gdb/lynx-nat.c
+++ b/gdb/lynx-nat.c
@@ -655,13 +655,11 @@ child_wait (pid, ourstatus)
 
 	  if (realsig == SIGNEWTHREAD)
 	    {
-	      /* It's a new thread notification.  Nothing to do here since
-		 the machine independent code in wait_for_inferior will
-		 add the thread to the thread list and restart the thread
-		 when pid != inferior_pid and pid is not in the thread
-		 list.   We don't even want to much with realsig -- the
-		 code in wait_for_inferior expects SIGTRAP.  */
-	      ;
+	      /* It's a new thread notification.  We don't want to much with
+		 realsig -- the code in wait_for_inferior expects SIGTRAP. */
+	      ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
+	      ourstatus->value.sig = TARGET_SIGNAL_0;
+	      return pid;
 	    }
 	  else
 	    error ("Signal for unknown thread was not SIGNEWTHREAD");
diff --git a/gdb/target.c b/gdb/target.c
index c959b73..8e87aaf 100644
--- a/gdb/target.c
+++ b/gdb/target.c
@@ -1028,6 +1028,14 @@ static struct {
   {"SIG62", "Real-time event 62"},
   {"SIG63", "Real-time event 63"},
 
+  /* Mach exceptions */
+  {"EXC_BAD_ACCESS", "Could not access memory"},
+  {"EXC_BAD_INSTRUCTION", "Illegal instruction/operand"},
+  {"EXC_ARITHMETIC", "Arithmetic exception"},
+  {"EXC_EMULATION", "Emulation instruction"},
+  {"EXC_SOFTWARE", "Software generated exception"},
+  {"EXC_BREAKPOINT", "Breakpoint"},
+
   {NULL, "Unknown signal"},
   {NULL, "Internal error: printing TARGET_SIGNAL_DEFAULT"},
 
@@ -1225,6 +1233,27 @@ target_signal_from_host (hostsig)
 #if defined (SIGPRIO)
   if (hostsig == SIGPRIO) return TARGET_SIGNAL_PRIO;
 #endif
+
+  /* Mach exceptions.  Assumes that the values for EXC_ are positive! */
+#if defined (EXC_BAD_ACCESS) && defined (_NSIG)
+  if (hostsig == _NSIG + EXC_BAD_ACCESS) return TARGET_EXC_BAD_ACCESS;
+#endif
+#if defined (EXC_BAD_INSTRUCTION) && defined (_NSIG)
+  if (hostsig == _NSIG + EXC_BAD_INSTRUCTION) return TARGET_EXC_BAD_INSTRUCTION;
+#endif
+#if defined (EXC_ARITHMETIC) && defined (_NSIG)
+  if (hostsig == _NSIG + EXC_ARITHMETIC) return TARGET_EXC_ARITHMETIC;
+#endif
+#if defined (EXC_EMULATION) && defined (_NSIG)
+  if (hostsig == _NSIG + EXC_EMULATION) return TARGET_EXC_EMULATION;
+#endif
+#if defined (EXC_SOFTWARE) && defined (_NSIG)
+  if (hostsig == _NSIG + EXC_SOFTWARE) return TARGET_EXC_SOFTWARE;
+#endif
+#if defined (EXC_BREAKPOINT) && defined (_NSIG)
+  if (hostsig == _NSIG + EXC_BREAKPOINT) return TARGET_EXC_BREAKPOINT;
+#endif
+
 #if defined (REALTIME_LO)
   if (hostsig >= REALTIME_LO && hostsig < REALTIME_HI)
     return (enum target_signal)
@@ -1378,6 +1407,27 @@ target_signal_to_host (oursig)
 #if defined (SIGPRIO)
     case TARGET_SIGNAL_PRIO: return SIGPRIO;
 #endif
+
+      /* Mach exceptions.  Assumes that the values for EXC_ are positive! */
+#if defined (EXC_BAD_ACCESS) && defined (_NSIG)
+    case TARGET_EXC_BAD_ACCESS: return _NSIG + EXC_BAD_ACCESS;
+#endif
+#if defined (EXC_BAD_INSTRUCTION) && defined (_NSIG)
+    case TARGET_EXC_BAD_INSTRUCTION: return _NSIG + EXC_BAD_INSTRUCTION;
+#endif
+#if defined (EXC_ARITHMETIC) && defined (_NSIG)
+    case TARGET_EXC_ARITHMETIC: return _NSIG + EXC_ARITHMETIC;
+#endif
+#if defined (EXC_EMULATION) && defined (_NSIG)
+    case TARGET_EXC_EMULATION: return _NSIG + EXC_EMULATION;
+#endif
+#if defined (EXC_SOFTWARE) && defined (_NSIG)
+    case TARGET_EXC_SOFTWARE: return _NSIG + EXC_SOFTWARE;
+#endif
+#if defined (EXC_BREAKPOINT) && defined (_NSIG)
+    case TARGET_EXC_BREAKPOINT: return _NSIG + EXC_BREAKPOINT;
+#endif
+
     default:
 #if defined (REALTIME_LO)
       if (oursig >= TARGET_SIGNAL_REALTIME_33
@@ -1609,7 +1659,8 @@ debug_to_xfer_memory (memaddr, myaddr, len, write, target)
 
   retval = debug_target.to_xfer_memory (memaddr, myaddr, len, write, target);
 
-  fprintf_unfiltered (stderr, "target_xfer_memory (0x%x, xxx, %d, %s, xxx) = %d",
+  fprintf_unfiltered (stderr,
+		      "target_xfer_memory (0x%x, xxx, %d, %s, xxx) = %d",
 		      memaddr, len, write ? "write" : "read", retval);
 
   if (retval > 0)
@@ -1618,7 +1669,11 @@ debug_to_xfer_memory (memaddr, myaddr, len, write, target)
 
       fputs_unfiltered (", bytes =", gdb_stderr);
       for (i = 0; i < retval; i++)
-	fprintf_unfiltered (stderr, " %02x", myaddr[i] & 0xff);
+	{
+	  if ((((long) &(myaddr[i])) & 0xf) == 0)
+	    fprintf_unfiltered (stderr, "\n");
+	  fprintf_unfiltered (stderr, " %02x", myaddr[i] & 0xff);
+	}
     }
 
   fputc_unfiltered ('\n', gdb_stderr);
@@ -1783,10 +1838,13 @@ static int
 debug_to_thread_alive (pid)
      int pid;
 {
-  debug_target.to_thread_alive (pid);
+  int retval;
+
+  retval = debug_target.to_thread_alive (pid);
 
-  fprintf_unfiltered (stderr, "target_thread_alive (%d)\n", pid);
-  return (0);
+  fprintf_unfiltered (stderr, "target_thread_alive (%d) = %d\n", pid, retval);
+
+  return retval;
 }
 
 static void
diff --git a/gdb/target.h b/gdb/target.h
index 2f20409..18dc35d 100644
--- a/gdb/target.h
+++ b/gdb/target.h
@@ -178,6 +178,14 @@ enum target_signal {
   TARGET_SIGNAL_REALTIME_62 = 74,
   TARGET_SIGNAL_REALTIME_63 = 75,
 
+  /* Mach exceptions */
+  TARGET_EXC_BAD_ACCESS = 76,
+  TARGET_EXC_BAD_INSTRUCTION = 77,
+  TARGET_EXC_ARITHMETIC = 78,
+  TARGET_EXC_EMULATION = 79,
+  TARGET_EXC_SOFTWARE = 80,
+  TARGET_EXC_BREAKPOINT = 81,
+
   /* Some signal we don't know about.  */
   TARGET_SIGNAL_UNKNOWN,