2000-02-26 Mark Kettenis <kettenis@gnu.org>

	* gnu-nat.c: Include "gdbthread.h".  Include <hurd.h>.
	Reorder headers a bit.  Overall cleanup and minor reformatting.
	(MIG_SERVER_DIED): Remove define.
	(proc_update_sc): Add braces to silence compiler warning.
	(proc_steal_exc_port): Initialize err to zero.
	(make_proc): Add braces to silence compiler warning.
	(inf_validate_task_sc): Add cast to silence compiler warning.
	(inf_set_traced): Reorganize a bit to silence compiler warning.
	(inf_validate_procs): Use mach_msg_type_number_t for all thread
	numbers and add braces to silence compiler warning.
	(gnu_wait): Add prototypes for server functions and add braces to
	silence compiler warnings.
	(S_exception_raise_request): Pass subcode to inf_debug call.
	(gnu_write_inferior): Remove unused variable `protection_changed'.
	(gnu_xfer_memory): Remove unused variable `result'.
	(set_sig_thread_cmd): Remove unused varible `tid'.
	(set_signals_cmd): Remve unused variable `trace'.
	(add_task_commands): Provide complete prototype.  Reformat help
	strings a bit to make sure the first line is a full sentence.
	Call info_port_rights_cmd instead of info_send_rights_cmd for the
	"info port-rights" command.
	(add_thread_commands): Provide complete prototype.  Make static.
	Reformat help strings a bit to make sure the first line is a full
	sentence.
	(_initialize_gnu_nat): Provide complete prototype.

1 files changed, 301 insertions, 216 deletions

diff --git a/gdb/gnu-nat.c b/gdb/gnu-nat.c
index b39335f9904..6d69b93ff9d 100644
--- a/gdb/gnu-nat.c
+++ b/gdb/gnu-nat.c
@@ -23,28 +23,29 @@
    Boston, MA 02111-1307, USA.
  */
 
-#include <stdio.h>
-#include <string.h>
-#include <errno.h>
-#include <signal.h>
 #include <assert.h>
-#include <setjmp.h>
+#include <errno.h>
 #include <limits.h>
+#include <setjmp.h>
+#include <signal.h>
+#include <stdio.h>
+#include <string.h>
 #include <sys/ptrace.h>
 
 #include <mach.h>
-#include <mach/message.h>
-#include <mach/notify.h>
 #include <mach_error.h>
 #include <mach/exception.h>
+#include <mach/message.h>
+#include <mach/notify.h>
 #include <mach/vm_attributes.h>
 
-#include <hurd/process.h>
-#include <hurd/process_request.h>
+#include <hurd.h>
+#include <hurd/interrupt.h>
 #include <hurd/msg.h>
 #include <hurd/msg_request.h>
+#include <hurd/process.h>
+#include <hurd/process_request.h>
 #include <hurd/signal.h>
-#include <hurd/interrupt.h>
 #include <hurd/sigpreempt.h>
 
 #include <portinfo.h>
@@ -58,6 +59,7 @@
 #include "gdb_wait.h"
 #include "gdbcmd.h"
 #include "gdbcore.h"
+#include "gdbthread.h"
 
 #include "gnu-nat.h"
 
@@ -140,7 +142,6 @@ int proc_trace (struct proc *proc, int set);
 	__e; }) \
    : EIEIO)
 
-#define MIG_SERVER_DIED EMIG_SERVER_DIED	/* XXX */
 
 /* The state passed by an exception message.  */
 struct exc_state
@@ -243,6 +244,7 @@ __proc_pid (struct proc *proc)
 {
   return proc->inf->pid;
 }
+
 
 /* Update PROC's real suspend count to match it's desired one.  Returns true
    if we think PROC is now in a runnable state.  */
@@ -268,18 +270,25 @@ proc_update_sc (struct proc *proc)
     }
 
   if (delta > 0)
-    while (delta-- > 0 && !err)
-      if (proc_is_task (proc))
-	err = task_suspend (proc->port);
-      else
-	err = thread_suspend (proc->port);
+    {
+      while (delta-- > 0 && !err)
+	{
+	  if (proc_is_task (proc))
+	    err = task_suspend (proc->port);
+	  else
+	    err = thread_suspend (proc->port);
+	}
+    }
   else
-    while (delta++ < 0 && !err)
-      if (proc_is_task (proc))
-	err = task_resume (proc->port);
-      else
-	err = thread_resume (proc->port);
-
+    {
+      while (delta++ < 0 && !err)
+	{
+	  if (proc_is_task (proc))
+	    err = task_resume (proc->port);
+	  else
+	    err = thread_resume (proc->port);
+	}
+    }
   if (!err)
     proc->cur_sc = proc->sc;
 
@@ -299,6 +308,7 @@ proc_update_sc (struct proc *proc)
 
   return running;
 }
+
 
 /* Thread_abort is called on PROC if needed.  PROC must be a thread proc.
    If PROC is deemed `precious', then nothing is done unless FORCE is true.
@@ -374,6 +384,7 @@ proc_get_state (struct proc *proc, int will_modify)
   else
     return 0;
 }
+
 
 /* Set PORT to PROC's exception port.  */
 error_t
@@ -426,7 +437,7 @@ proc_steal_exc_port (struct proc *proc, mach_port_t exc_port)
 
   if (cur_exc_port)
     {
-      error_t err;
+      error_t err = 0;
 
       proc_debug (proc, "inserting exception port: %d", exc_port);
 
@@ -488,6 +499,7 @@ proc_restore_exc_port (struct proc *proc)
 		 proc_string (proc), strerror (err));
     }
 }
+
 
 /* Turns hardware tracing in PROC on or off when SET is true or false,
    respectively.  Returns true on success.  */
@@ -514,6 +526,7 @@ proc_trace (struct proc *proc, int set)
 
   return 1;
 }
+
 
 /* A variable from which to assign new TIDs.  */
 static int next_thread_id = 1;
@@ -569,12 +582,15 @@ make_proc (struct inf *inf, mach_port_t port, int tid)
     }
 
   if (inf->want_exceptions)
-    if (proc_is_task (proc))
-      /* Make the task exception port point to us.  */
-      proc_steal_exc_port (proc, inf->event_port);
-    else
-      /* Just clear thread exception ports -- they default to the task one.  */
-      proc_steal_exc_port (proc, MACH_PORT_NULL);
+    {
+      if (proc_is_task (proc))
+	/* Make the task exception port point to us.  */
+	proc_steal_exc_port (proc, inf->event_port);
+      else
+	/* Just clear thread exception ports -- they default to the
+           task one.  */
+	proc_steal_exc_port (proc, MACH_PORT_NULL);
+    }
 
   return proc;
 }
@@ -614,6 +630,7 @@ _proc_free (struct proc *proc)
   free (proc);
   return next;
 }
+
 
 struct inf *
 make_inf ()
@@ -651,7 +668,7 @@ make_inf ()
   return inf;
 }
 
-/* clear INF's target wait status.  */
+/* Clear INF's target wait status.  */
 void
 inf_clear_wait (struct inf *inf)
 {
@@ -670,6 +687,7 @@ inf_clear_wait (struct inf *inf)
       inf->wait.exc.reply = MACH_PORT_NULL;
     }
 }
+
 
 void
 inf_cleanup (struct inf *inf)
@@ -714,8 +732,9 @@ inf_startup (struct inf *inf, int pid)
 			  inf->event_port, MACH_MSG_TYPE_MAKE_SEND);
   inf_set_pid (inf, pid);
 }
+
 
-/* close current process, if any, and attach INF to process PORT */
+/* Close current process, if any, and attach INF to process PORT.  */
 void
 inf_set_pid (struct inf *inf, pid_t pid)
 {
@@ -755,11 +774,13 @@ inf_set_pid (struct inf *inf, pid_t pid)
     {
       inf->pid = pid;
       if (inf->pause_sc)
-	inf->task->sc = inf->task->cur_sc = 1;	/* Reflect task_suspend above */
+	/* Reflect task_suspend above.  */
+	inf->task->sc = inf->task->cur_sc = 1;
     }
   else
     inf->pid = -1;
 }
+
 
 /* Validates INF's stopped, nomsg and traced field from the actual
    proc server state.  Note that the traced field is only updated from
@@ -804,7 +825,7 @@ inf_validate_task_sc (struct inf *inf)
 
  retry:
   err = proc_getprocinfo (proc_server, inf->pid, &info_flags,
-			  &pi, &pi_len, &noise, &noise_len);
+			  (procinfo_t *) &pi, &pi_len, &noise, &noise_len);
   if (err)
     {
       inf->task->dead = 1; /* oh well */
@@ -844,40 +865,45 @@ inf_validate_task_sc (struct inf *inf)
     }
 }
 
-/* Turns tracing for INF on or off, depending on ON, unless it already is.
-   If INF is running, the resume_sc count of INF's threads will be modified,
-   and the signal thread will briefly be run to change the trace state.  */
+/* Turns tracing for INF on or off, depending on ON, unless it already
+   is.  If INF is running, the resume_sc count of INF's threads will
+   be modified, and the signal thread will briefly be run to change
+   the trace state.  */
 void
 inf_set_traced (struct inf *inf, int on)
 {
-  if (on != inf->traced)
-    if (inf->task && !inf->task->dead)
-      /* Make it take effect immediately.  */
-      {
-	sigset_t mask = on ? ~(sigset_t) 0 : 0;
-	error_t err =
+  if (on == inf->traced)
+    return;
+  
+  if (inf->task && !inf->task->dead)
+    /* Make it take effect immediately.  */
+    {
+      sigset_t mask = on ? ~(sigset_t) 0 : 0;
+      error_t err =
 	INF_RESUME_MSGPORT_RPC (inf, msg_set_init_int (msgport, refport,
-						     INIT_TRACEMASK, mask));
-	if (err == EIEIO)
-	  {
-	    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));
-	else
+						       INIT_TRACEMASK, mask));
+      if (err == EIEIO)
+	{
+	  if (on)
+	    warning ("Can't modify tracing state for pid %d: %s",
+		     inf->pid, "No signal thread");
 	  inf->traced = on;
-      }
-    else
-      inf->traced = on;
+	}
+      else if (err)
+	warning ("Can't modify tracing state for pid %d: %s",
+		 inf->pid, strerror (err));
+      else
+	inf->traced = on;
+    }
+  else
+    inf->traced = on;
 }
+
 
-/* Makes all the real suspend count deltas of all the procs in INF match the
-   desired values.  Careful to always do thread/task suspend counts in the
-   safe order.  Returns true if at least one thread is thought to be running. */
+/* Makes all the real suspend count deltas of all the procs in INF
+   match the desired values.  Careful to always do thread/task suspend
+   counts in the safe order.  Returns true if at least one thread is
+   thought to be running. */
 int
 inf_update_suspends (struct inf *inf)
 {
@@ -926,6 +952,7 @@ inf_update_suspends (struct inf *inf)
 
   return 0;
 }
+
 
 /* Converts a GDB pid to a struct proc.  */
 struct proc *
@@ -953,14 +980,14 @@ inf_port_to_thread (struct inf *inf, mach_port_t port)
       thread = thread->next;
   return 0;
 }
+
 
 /* Make INF's list of threads be consistent with reality of TASK.  */
 void
 inf_validate_procs (struct inf *inf)
 {
-  int i;
   thread_array_t threads;
-  unsigned num_threads;
+  mach_msg_type_number_t num_threads, i;
   struct proc *task = inf->task;
 
   /* If no threads are currently running, this function will guarantee that
@@ -988,7 +1015,8 @@ inf_validate_procs (struct inf *inf)
     }
 
   {
-    unsigned search_start = 0;	/* Make things normally linear.  */
+    /* Make things normally linear.  */
+    mach_msg_type_number_t search_start = 0;
     /* Which thread in PROCS corresponds to each task thread, & the task.  */
     struct proc *matched[num_threads + 1];
     /* The last thread in INF->threads, so we can add to the end.  */
@@ -1000,7 +1028,7 @@ inf_validate_procs (struct inf *inf)
 
     while (thread)
       {
-	unsigned left;
+	mach_msg_type_number_t left;
 
 	for (i = search_start, left = num_threads; left; i++, left--)
 	  {
@@ -1027,23 +1055,26 @@ inf_validate_procs (struct inf *inf)
       }
 
     for (i = 0; i < num_threads; i++)
-      if (matched[i])
-	/* Throw away the duplicate send right.  */
-	mach_port_deallocate (mach_task_self (), threads[i]);
-      else
-	/* THREADS[I] is a thread we don't know about yet!  */
-	{
-	  thread = make_proc (inf, threads[i], next_thread_id++);
-	  (last ? last->next : inf->threads) = thread;
-	  last = thread;
-	  proc_debug (thread, "new thread: %d", threads[i]);
-	  add_thread (thread->tid);	/* Tell GDB's generic thread code.  */
-	}
+      {
+	if (matched[i])
+	  /* Throw away the duplicate send right.  */
+	  mach_port_deallocate (mach_task_self (), threads[i]);
+	else
+	  /* THREADS[I] is a thread we don't know about yet!  */
+	  {
+	    thread = make_proc (inf, threads[i], next_thread_id++);
+	    (last ? last->next : inf->threads) = thread;
+	    last = thread;
+	    proc_debug (thread, "new thread: %d", threads[i]);
+	    add_thread (thread->tid);	/* Tell GDB's generic thread code.  */
+	  }
+      }
 
     vm_deallocate (mach_task_self (),
-		 (vm_address_t) threads, (num_threads * sizeof (thread_t)));
+		   (vm_address_t) threads, (num_threads * sizeof (thread_t)));
   }
 }
+
 
 /* Makes sure that INF's thread list is synced with the actual process.  */
 inline int
@@ -1073,6 +1104,7 @@ inf_set_threads_resume_sc (struct inf *inf,
     else
       thread->resume_sc = thread->pause_sc;
 }
+
 
 /* Cause INF to continue execution immediately; individual threads may still
    be suspended (but their suspend counts will be updated).  */
@@ -1116,10 +1148,11 @@ inf_suspend (struct inf *inf)
 
   inf_update_suspends (inf);
 }
+
 
-/* INF has one thread PROC that is in single-stepping mode.  This function
-   changes it to be PROC, changing any old step_thread to be a normal one.  A
-   PROC of 0 clears any existing value.  */
+/* INF has one thread PROC that is in single-stepping mode.  This
+   function changes it to be PROC, changing any old step_thread to be
+   a normal one.  A PROC of 0 clears any existing value.  */
 void
 inf_set_step_thread (struct inf *inf, struct proc *thread)
 {
@@ -1141,6 +1174,7 @@ inf_set_step_thread (struct inf *inf, struct proc *thread)
 	inf->step_thread = 0;
     }
 }
+
 
 /* Set up the thread resume_sc's so that only the signal thread is running
    (plus whatever other thread are set to always run).  Returns true if we
@@ -1164,6 +1198,7 @@ inf_update_signal_thread (struct inf *inf)
      the signal thread.  */
   inf->signal_thread = inf->threads ? inf->threads->next : 0;
 }
+
 
 /* Detachs from INF's inferior task, letting it run once again...  */
 void
@@ -1206,8 +1241,8 @@ inf_detach (struct inf *inf)
   inf_cleanup (inf);
 }
 
-/* Attaches INF to the process with process id PID, returning it in a suspended
-   state suitable for debugging.  */
+/* Attaches INF to the process with process id PID, returning it in a
+   suspended state suitable for debugging.  */
 void
 inf_attach (struct inf *inf, int pid)
 {
@@ -1218,6 +1253,7 @@ inf_attach (struct inf *inf, int pid)
 
   inf_startup (inf, pid);
 }
+
 
 /* Makes sure that we've got our exception ports entrenched in the process. */
 void
@@ -1248,6 +1284,7 @@ inf_restore_exc_ports (struct inf *inf)
   for (thread = inf->threads; thread; thread = thread->next)
     proc_restore_exc_port (thread);
 }
+
 
 /* Deliver signal SIG to INF.  If INF is stopped, delivering a signal, even
    signal 0, will continue it.  INF is assumed to be in a paused state, and
@@ -1318,10 +1355,12 @@ inf_signal (struct inf *inf, enum target_signal sig)
        process the signal we request will be the very first thing that
        happens. */
     {
-      inf_debug (inf, "sending %s to unstopped process (so resuming signal thread)", NAME);
+      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, 0, refport));
+	INF_RESUME_MSGPORT_RPC (inf,
+				msg_sig_post_untraced (msgport, host_sig,
+						       0, refport));
     }
 
   if (err == EIEIO)
@@ -1332,6 +1371,7 @@ inf_signal (struct inf *inf, enum target_signal sig)
 
 #undef NAME
 }
+
 
 /* Continue INF without delivering a signal.  This is meant to be used
    when INF does not have a message port.  */
@@ -1360,6 +1400,7 @@ inf_continue (struct inf *inf)
   if (err)
     warning ("Can't continue process: %s", strerror (err));
 }
+
 
 /* The inferior used for all gdb target ops.  */
 struct inf *current_inferior = 0;
@@ -1377,12 +1418,16 @@ gnu_wait (int tid, struct target_waitstatus *status)
       mach_msg_header_t hdr;
       mach_msg_type_t type;
       int data[8000];
-    }
-  msg;
+    } msg;
   error_t err;
   struct proc *thread;
   struct inf *inf = current_inferior;
 
+  extern int exc_server (mach_msg_header_t *, mach_msg_header_t *);
+  extern int msg_reply_server (mach_msg_header_t *, mach_msg_header_t *);
+  extern int notify_server (mach_msg_header_t *, mach_msg_header_t *);
+  extern int process_reply_server (mach_msg_header_t *, mach_msg_header_t *);
+
   assert (inf->task);
 
   if (!inf->threads && !inf->pending_execs)
@@ -1421,10 +1466,11 @@ rewait:
 	{
 	  inf_debug (inf, "waits pending: %d", proc_waits_pending);
 	  proc_wait_pid = inf->pid;
-	  /* Even if proc_waits_pending was > 0 before, we still won't get
-	     any other replies, because it was either from a different INF,
-	     or a different process attached to INF -- and the event port,
-	     which is the wait reply port, changes when you switch processes. */
+	  /* Even if proc_waits_pending was > 0 before, we still won't
+	     get any other replies, because it was either from a
+	     different INF, or a different process attached to INF --
+	     and the event port, which is the wait reply port, changes
+	     when you switch processes. */
 	  proc_waits_pending = 1;
 	}
     }
@@ -1537,15 +1583,18 @@ rewait:
     thread = inf_tid_to_thread (inf, tid);
 
   if (!thread || thread->port == MACH_PORT_NULL)
-    /* TID is dead; try and find a new thread.  */
-    if (inf_update_procs (inf) && inf->threads)
-      tid = inf->threads->tid;	/* The first available thread.  */
-    else
-      tid = inferior_pid;	/* let wait_for_inferior handle exit case */
+    {
+      /* TID is dead; try and find a new thread.  */
+      if (inf_update_procs (inf) && inf->threads)
+	tid = inf->threads->tid; /* The first available thread.  */
+      else
+	tid = inferior_pid;	/* let wait_for_inferior handle exit case */
+    }
 
   if (thread && tid >= 0 && status->kind != TARGET_WAITKIND_SPURIOUS
       && inf->pause_sc == 0 && thread->pause_sc == 0)
-    /* If something actually happened to THREAD, make sure we suspend it.  */
+    /* If something actually happened to THREAD, make sure we
+       suspend it.  */
     {
       thread->sc = 1;
       inf_update_suspends (inf);
@@ -1562,6 +1611,7 @@ rewait:
 
   return tid;
 }
+
 
 /* The rpc handler called by exc_server.  */
 error_t
@@ -1574,7 +1624,7 @@ S_exception_raise_request (mach_port_t port, mach_port_t reply_port,
 
   inf_debug (waiting_inf,
 	     "thread = %d, task = %d, exc = %d, code = %d, subcode = %d",
-	     thread_port, task_port, exception, code);
+	     thread_port, task_port, exception, code, subcode);
 
   if (!thread)
     /* We don't know about thread?  */
@@ -1646,6 +1696,7 @@ S_exception_raise_request (mach_port_t port, mach_port_t reply_port,
 
   return 0;
 }
+
 
 /* Fill in INF's wait field after a task has died without giving us more
    detailed information.  */
@@ -1697,6 +1748,7 @@ do_mach_notify_dead_name (mach_port_t notify, mach_port_t dead_port)
 
   return 0;
 }
+
 
 static error_t
 ill_rpc (char *fun)
@@ -1734,6 +1786,7 @@ do_mach_notify_send_once (mach_port_t notify)
 {
   return ill_rpc (__FUNCTION__);
 }
+
 
 /* Process_reply server routines.  We only use process_wait_reply.  */
 
@@ -1801,6 +1854,7 @@ S_proc_getmsgport_reply (mach_port_t reply, error_t err, mach_port_t msg_port)
 {
   return ill_rpc (__FUNCTION__);
 }
+
 
 /* Msg_reply server routines.  We only use msg_sig_post_untraced_reply.  */
 
@@ -1839,6 +1893,7 @@ S_msg_sig_post_reply (mach_port_t reply, error_t err)
 {
   return ill_rpc (__FUNCTION__);
 }
+
 
 /* Returns the number of messages queued for the receive right PORT.  */
 static mach_port_msgcount_t
@@ -1853,6 +1908,7 @@ port_msgs_queued (mach_port_t port)
   else
     return status.mps_msgcount;
 }
+
 
 /* Resume execution of the inferior process.
 
@@ -1935,6 +1991,7 @@ gnu_resume (int tid, int step, enum target_signal sig)
   inf_debug (inf, "here we go...");
   inf_resume (inf);
 }
+
 
 static void
 gnu_kill_inferior ()
@@ -1950,7 +2007,6 @@ gnu_kill_inferior ()
 }
 
 /* Clean up after the inferior dies.  */
-
 static void
 gnu_mourn_inferior ()
 {
@@ -1959,6 +2015,7 @@ gnu_mourn_inferior ()
   unpush_target (&gnu_ops);
   generic_mourn_inferior ();
 }
+
 
 /* Fork an inferior process, and start debugging it.  */
 
@@ -2046,6 +2103,7 @@ gnu_can_run ()
 {
   return 1;
 }
+
 
 #ifdef ATTACH_DETACH
 
@@ -2106,6 +2164,7 @@ gnu_attach (args, from_tty)
   renumber_threads (0);		/* Give our threads reasonable names. */
 #endif
 }
+
 
 /* Take a program previously attached to and detaches it.
    The program resumes execution and will no longer stop
@@ -2138,6 +2197,7 @@ gnu_detach (args, from_tty)
 }
 #endif /* ATTACH_DETACH */
 
+
 static void
 gnu_terminal_init_inferior ()
 {
@@ -2150,7 +2210,6 @@ gnu_terminal_init_inferior ()
    which store all the registers in one fell swoop, this makes sure
    that registers contains all the registers from the program being
    debugged.  */
-
 static void
 gnu_prepare_to_store ()
 {
@@ -2187,13 +2246,11 @@ gnu_thread_alive (int tid)
   inf_update_procs (current_inferior);
   return !!inf_tid_to_thread (current_inferior, tid);
 }
+
 
-/*
- * Read inferior task's LEN bytes from ADDR and copy it to MYADDR
- * in gdb's address space.
- *
- * Return 0 on failure; number of bytes read otherwise.
- */
+/* Read inferior task's LEN bytes from ADDR and copy it to MYADDR in
+   gdb's address space.  Return 0 on failure; number of bytes read
+   otherwise.  */
 int
 gnu_read_inferior (task, addr, myaddr, length)
      task_t task;
@@ -2240,10 +2297,8 @@ struct vm_region_list
 
 struct obstack region_obstack;
 
-/*
- * Write gdb's LEN bytes from MYADDR and copy it to ADDR
- * in inferior task's address space.
- */
+/* Write gdb's LEN bytes from MYADDR and copy it to ADDR in inferior
+   task's address space.  */
 int
 gnu_write_inferior (task, addr, myaddr, length)
      task_t task;
@@ -2274,14 +2329,14 @@ gnu_write_inferior (task, addr, myaddr, length)
 
   deallocate++;
 
-  err = hurd_safe_copyout ((void *) addr - low_address + copied, myaddr, length);
+  err = hurd_safe_copyout ((void *) addr - low_address + copied,
+			   myaddr, length);
   CHK_GOTO_OUT ("Write to inferior faulted", err);
 
   obstack_init (&region_obstack);
 
   /* Do writes atomically.
-   * First check for holes and unwritable memory.
-   */
+     First check for holes and unwritable memory.  */
   {
     vm_size_t remaining_length = aligned_length;
     vm_address_t region_address = low_address;
@@ -2347,14 +2402,11 @@ gnu_write_inferior (task, addr, myaddr, length)
       }
 
     /* If things fail after this, we give up.
-     * Somebody is messing up inferior_task's mappings.
-     */
+       Somebody is messing up inferior_task's mappings.  */
 
     /* Enable writes to the chained vm regions */
     for (scan = region_head; scan; scan = scan->next)
       {
-	boolean_t protection_changed = FALSE;
-
 	if (!(scan->protection & VM_PROT_WRITE))
 	  {
 	    err = vm_protect (task,
@@ -2375,8 +2427,6 @@ gnu_write_inferior (task, addr, myaddr, length)
     /* Set up the original region protections, if they were changed */
     for (scan = region_head; scan; scan = scan->next)
       {
-	boolean_t protection_changed = FALSE;
-
 	if (!(scan->protection & VM_PROT_WRITE))
 	  {
 	    err = vm_protect (task,
@@ -2407,6 +2457,7 @@ out:
 
   return length;
 }
+
 
 /* Return 0 on failure, number of bytes handled otherwise.  */
 static int
@@ -2417,11 +2468,10 @@ gnu_xfer_memory (memaddr, myaddr, len, write, target)
      int write;
      struct target_ops *target;	/* IGNORED */
 {
-  int result;
-  task_t task =
-  current_inferior
-  ? (current_inferior->task ? current_inferior->task->port : 0)
-  : 0;
+  task_t task = (current_inferior
+		 ? (current_inferior->task
+		    ? current_inferior->task->port : 0)
+		 : 0);
 
   if (task == MACH_PORT_NULL)
     return 0;
@@ -2436,6 +2486,7 @@ gnu_xfer_memory (memaddr, myaddr, len, write, target)
 	return gnu_read_inferior (task, memaddr, myaddr, len);
     }
 }
+
 
 /* Return printable description of proc.  */
 char *
@@ -2465,6 +2516,7 @@ gnu_pid_to_str (int tid)
       return tid_str;
     }
 }
+
 
 extern void gnu_store_registers (int regno);
 extern void gnu_fetch_registers (int regno);
@@ -2474,24 +2526,24 @@ struct target_ops gnu_ops;
 static void
 init_gnu_ops (void)
 {
-  gnu_ops.to_shortname = "GNU";	/* to_shortname */
-  gnu_ops.to_longname = "GNU Hurd process";	/* to_longname */
+  gnu_ops.to_shortname = "GNU";		/* to_shortname */
+  gnu_ops.to_longname = "GNU Hurd process"; /* to_longname */
   gnu_ops.to_doc = "GNU Hurd process";	/* to_doc */
-  gnu_ops.to_open = gnu_open;	/* to_open */
-  gnu_ops.to_close = 0;		/* to_close */
+  gnu_ops.to_open = gnu_open;		/* to_open */
+  gnu_ops.to_close = 0;			/* to_close */
   gnu_ops.to_attach = gnu_attach;	/* to_attach */
   gnu_ops.to_post_attach = NULL;
   gnu_ops.to_require_attach = NULL;	/* to_require_attach */
   gnu_ops.to_detach = gnu_detach;	/* to_detach */
   gnu_ops.to_require_detach = NULL;	/* to_require_detach */
   gnu_ops.to_resume = gnu_resume;	/* to_resume */
-  gnu_ops.to_wait = gnu_wait;	/* to_wait */
-  gnu_ops.to_post_wait = NULL;	/* to_post_wait */
-  gnu_ops.to_fetch_registers = gnu_fetch_registers;	/* to_fetch_registers */
-  gnu_ops.to_store_registers = gnu_store_registers;	/* to_store_registers */
-  gnu_ops.to_prepare_to_store = gnu_prepare_to_store;	/* to_prepare_to_store */
-  gnu_ops.to_xfer_memory = gnu_xfer_memory;	/* to_xfer_memory */
-  gnu_ops.to_files_info = 0;	/* to_files_info */
+  gnu_ops.to_wait = gnu_wait;		/* to_wait */
+  gnu_ops.to_post_wait = NULL;		/* to_post_wait */
+  gnu_ops.to_fetch_registers = gnu_fetch_registers;    /* to_fetch_registers */
+  gnu_ops.to_store_registers = gnu_store_registers;    /* to_store_registers */
+  gnu_ops.to_prepare_to_store = gnu_prepare_to_store; /* to_prepare_to_store */
+  gnu_ops.to_xfer_memory = gnu_xfer_memory; /* to_xfer_memory */
+  gnu_ops.to_files_info = 0;		/* to_files_info */
   gnu_ops.to_insert_breakpoint = memory_insert_breakpoint;
   gnu_ops.to_remove_breakpoint = memory_remove_breakpoint;
   gnu_ops.to_terminal_init = gnu_terminal_init_inferior;
@@ -2500,18 +2552,21 @@ init_gnu_ops (void)
   gnu_ops.to_terminal_ours = terminal_ours;
   gnu_ops.to_terminal_info = child_terminal_info;
   gnu_ops.to_kill = gnu_kill_inferior;	/* to_kill */
-  gnu_ops.to_load = 0;		/* to_load */
-  gnu_ops.to_lookup_symbol = 0;	/* to_lookup_symbol */
-  gnu_ops.to_create_inferior = gnu_create_inferior;	/* to_create_inferior */
-  gnu_ops.to_post_startup_inferior = NULL;	/* to_post_startup_inferior */
-  gnu_ops.to_acknowledge_created_inferior = NULL;	/* to_acknowledge_created_inferior */
-  gnu_ops.to_clone_and_follow_inferior = NULL;	/* to_clone_and_follow_inferior */
-  gnu_ops.to_post_follow_inferior_by_clone = NULL;	/* to_post_follow_inferior_by_clone */
+  gnu_ops.to_load = 0;			/* to_load */
+  gnu_ops.to_lookup_symbol = 0;		/* to_lookup_symbol */
+  gnu_ops.to_create_inferior = gnu_create_inferior; /* to_create_inferior */
+  gnu_ops.to_post_startup_inferior = NULL;    /* to_post_startup_inferior */
+  /* to_acknowledge_created_inferior */
+  gnu_ops.to_acknowledge_created_inferior = NULL;
+  /* to_clone_and_follow_inferior */
+  gnu_ops.to_clone_and_follow_inferior = NULL;
+  /* to_post_follow_inferior_by_clone */
+  gnu_ops.to_post_follow_inferior_by_clone = NULL;
   gnu_ops.to_insert_fork_catchpoint = NULL;
   gnu_ops.to_remove_fork_catchpoint = NULL;
   gnu_ops.to_insert_vfork_catchpoint = NULL;
   gnu_ops.to_remove_vfork_catchpoint = NULL;
-  gnu_ops.to_has_forked = NULL;	/* to_has_forked */
+  gnu_ops.to_has_forked = NULL;		/* to_has_forked */
   gnu_ops.to_has_vforked = NULL;	/* to_has_vforked */
   gnu_ops.to_can_follow_vfork_prior_to_exec = NULL;
   gnu_ops.to_post_follow_vfork = NULL;	/* to_post_follow_vfork */
@@ -2526,19 +2581,20 @@ init_gnu_ops (void)
   gnu_ops.to_thread_alive = gnu_thread_alive;	/* to_thread_alive */
   gnu_ops.to_pid_to_str = gnu_pid_to_str;   /* to_pid_to_str */
   gnu_ops.to_stop = gnu_stop;	/* to_stop */
-  gnu_ops.to_pid_to_exec_file = gnu_pid_to_exec_file;	/* to_pid_to_exec_file */
+  gnu_ops.to_pid_to_exec_file = gnu_pid_to_exec_file; /* to_pid_to_exec_file */
   gnu_ops.to_core_file_to_sym_file = NULL;
   gnu_ops.to_stratum = process_stratum;		/* to_stratum */
-  gnu_ops.DONT_USE = 0;		/* to_next */
+  gnu_ops.DONT_USE = 0;			/* to_next */
   gnu_ops.to_has_all_memory = 1;	/* to_has_all_memory */
-  gnu_ops.to_has_memory = 1;	/* to_has_memory */
-  gnu_ops.to_has_stack = 1;	/* to_has_stack */
-  gnu_ops.to_has_registers = 1;	/* to_has_registers */
-  gnu_ops.to_has_execution = 1;	/* to_has_execution */
-  gnu_ops.to_sections = 0;	/* sections */
-  gnu_ops.to_sections_end = 0;	/* sections_end */
-  gnu_ops.to_magic = OPS_MAGIC;	/* to_magic */
+  gnu_ops.to_has_memory = 1;		/* to_has_memory */
+  gnu_ops.to_has_stack = 1;		/* to_has_stack */
+  gnu_ops.to_has_registers = 1;		/* to_has_registers */
+  gnu_ops.to_has_execution = 1;		/* to_has_execution */
+  gnu_ops.to_sections = 0;		/* sections */
+  gnu_ops.to_sections_end = 0;		/* sections_end */
+  gnu_ops.to_magic = OPS_MAGIC;		/* to_magic */
 }				/* init_gnu_ops */
+
 
 /* User task commands.  */
 
@@ -2634,6 +2690,7 @@ active_inf ()
     error ("No current process.");
   return inf;
 }
+
 
 static void
 set_task_pause_cmd (char *args, int from_tty)
@@ -2673,6 +2730,7 @@ show_task_detach_sc_cmd (char *args, int from_tty)
   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)
@@ -2724,6 +2782,7 @@ show_thread_default_detach_sc_cmd (char *args, int from_tty)
   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.  */
@@ -2760,7 +2819,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)
 {
@@ -2788,7 +2847,6 @@ show_stopped_cmd (char *args, int from_tty)
 static void
 set_sig_thread_cmd (char *args, int from_tty)
 {
-  int tid;
   struct inf *inf = cur_inf ();
 
   if (!args || (!isdigit (*args) && strcmp (args, "none") != 0))
@@ -2818,11 +2876,11 @@ show_sig_thread_cmd (char *args, int from_tty)
   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");
@@ -2866,11 +2924,13 @@ 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)
 {
-  printf_unfiltered ("\"set task\" must be followed by the name of a task property.\n");
+  printf_unfiltered ("\"set task\" must be followed by the name"
+		     " of a task property.\n");
 }
 
 static void
@@ -2899,6 +2959,7 @@ show_task_cmd (char *args, int 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)
@@ -2910,6 +2971,7 @@ set_noninvasive_cmd (char *args, int 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)
@@ -2949,45 +3011,54 @@ 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_task_commands (void)
 {
   add_cmd ("pause", class_run, set_thread_default_pause_cmd,
-	"Set whether the new threads are suspended while gdb has control.\n"
-	   "This property normally has no effect because the whole task is\n"
-   "suspended, however, that may be disabled with \"set task pause off\".\n"
-	   "The default value is \"off\".",
+	   "Set whether the new threads are suspended while gdb has control.\n\
+This property normally has no effect because the whole task is\n\
+suspended, however, that may be disabled with \"set task pause off\".\n\
+The default value is \"off\".",
 	   &set_thread_default_cmd_list);
   add_cmd ("pause", no_class, show_thread_default_pause_cmd,
 	   "Show whether new threads are suspended while gdb has control.",
 	   &show_thread_default_cmd_list);
+  
   add_cmd ("run", class_run, set_thread_default_run_cmd,
-  "Set whether new threads are allowed to run (once gdb has noticed them).",
+	   "Set whether new threads are allowed to run \
+(once gdb has noticed them).",
 	   &set_thread_default_cmd_list);
   add_cmd ("run", no_class, show_thread_default_run_cmd,
-  "Show whether new threads are allowed to run (once gdb has noticed them).",
+	   "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);
@@ -2996,18 +3067,18 @@ add_task_commands ()
 	   &show_thread_default_cmd_list);
 
   add_cmd ("signals", class_run, set_signals_cmd,
-	 "Set whether the inferior process's signals will be intercepted.\n"
-	   "Mach exceptions (such as breakpoint traps) are not affected.",
+	   "Set whether the inferior process's signals will be intercepted.\n\
+Mach exceptions (such as breakpoint traps) are not affected.",
 	   &setlist);
   add_alias_cmd ("sigs", "signals", class_run, 1, &setlist);
   add_cmd ("signals", no_class, show_signals_cmd,
-	 "Show whether the inferior process's signals will be intercepted.",
+	   "Show whether the inferior process's signals will be intercepted.",
 	   &showlist);
   add_alias_cmd ("sigs", "signals", no_class, 1, &showlist);
 
   add_cmd ("signal-thread", class_run, set_sig_thread_cmd,
-	   "Set the thread that gdb thinks is the libc signal thread.\n"
-    "This thread is run when delivering a signal to a non-stopped process.",
+	   "Set the thread that gdb thinks is the libc signal thread.\n\
+This thread is run when delivering a signal to a non-stopped process.",
 	   &setlist);
   add_alias_cmd ("sigthread", "signal-thread", class_run, 1, &setlist);
   add_cmd ("signal-thread", no_class, show_sig_thread_cmd,
@@ -3016,22 +3087,24 @@ add_task_commands ()
   add_alias_cmd ("sigthread", "signal-thread", no_class, 1, &showlist);
 
   add_cmd ("stopped", class_run, set_stopped_cmd,
-  "Set whether gdb thinks the inferior process is stopped as with SIGSTOP.\n"
-	   "Stopped process will be continued by sending them a signal.",
+	   "Set whether gdb thinks the inferior process is stopped \
+as with SIGSTOP.\n\
+Stopped process will be continued by sending them a signal.",
 	   &setlist);
   add_cmd ("stopped", no_class, show_signals_cmd,
-  "Show whether gdb thinks the inferior process is stopped as with SIGSTOP.",
+	   "Show whether gdb thinks the inferior process is stopped \
+as with SIGSTOP.",
 	   &showlist);
 
   add_cmd ("exceptions", class_run, set_exceptions_cmd,
-	 "Set whether exceptions in the inferior process will be trapped.\n"
-  "When exceptions are turned off, neither breakpoints nor single-stepping\n"
-	   "will work.",
+	   "Set whether exceptions in the inferior process will be trapped.\n\
+When exceptions are turned off, neither breakpoints nor single-stepping\n\
+will work.",
 	   &setlist);
   /* Allow `set exc' despite conflict with `set exception-port'.  */
   add_alias_cmd ("exc", "exceptions", class_run, 1, &setlist);
   add_cmd ("exceptions", no_class, show_exceptions_cmd,
-	 "Show whether exceptions in the inferior process will be trapped.",
+	   "Show whether exceptions in the inferior process will be trapped.",
 	   &showlist);
 
   add_prefix_cmd ("task", no_class, set_task_cmd,
@@ -3042,15 +3115,16 @@ add_task_commands ()
 		  &show_task_cmd_list, "show task ", 0, &showlist);
 
   add_cmd ("pause", class_run, set_task_pause_cmd,
-	   "Set whether the task is suspended while gdb has control.\n"
-	   "A value of \"on\" takes effect immediately, otherwise nothing\n"
-	   "happens until the next time the program is continued.\n"
-	   "When setting this to \"off\", \"set thread default pause on\"\n"
-	   "can be used to pause individual threads by default instead.",
+	   "Set whether the task is suspended while gdb has control.\n\
+A value of \"on\" takes effect immediately, otherwise nothing happens\n\
+until the next time the program is continued.\n\
+When setting this to \"off\", \"set thread default pause on\" can be\n\
+used to pause individual threads by default instead.",
 	   &set_task_cmd_list);
   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);
@@ -3059,18 +3133,19 @@ add_task_commands ()
 	   &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"
-	   "The argument should be the value of the send right in the task.",
+	   "Set the task exception port to which we forward exceptions.\n\
+The argument should be the value of the send right in the task.",
 	   &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);
+  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.",
+	   "Set task options so that we interfere as little as possible.\n\
+This is the same as setting `task pause', `exceptions', and\n\
+`signals' to the opposite value.",
 	   &setlist);
 
   /* Commands to show information about the task's ports.  */
@@ -3080,7 +3155,7 @@ add_task_commands ()
   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,
+  add_cmd ("port-rights", class_info, info_port_rights_cmd,
 	   "Show information about the task's port rights",
 	   &infolist);
   add_cmd ("port-sets", class_info, info_port_sets_cmd,
@@ -3093,8 +3168,8 @@ add_task_commands ()
   add_info_alias ("port", "port-rights", 1);
   add_info_alias ("psets", "port-sets", 1);
 }
-
 
+
 static void
 set_thread_pause_cmd (char *args, int from_tty)
 {
@@ -3116,7 +3191,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
@@ -3139,7 +3214,8 @@ show_thread_run_cmd (char *args, int from_tty)
 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");
+  cur_thread ()->detach_sc = parse_int_arg (args,
+					    "set thread detach-suspend-count");
 }
 
 static void
@@ -3147,7 +3223,8 @@ 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",
+  printf_unfiltered ("Thread %s will be left with a suspend count"
+		     " of %d when detaching.\n",
 		     proc_string (thread),
 		     thread->detach_sc);
 }
@@ -3189,10 +3266,13 @@ thread_takeover_sc_cmd (char *args, int from_tty)
   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));
+    vm_deallocate (mach_task_self (), (vm_address_t) info,
+		   info_len * sizeof (int));
 }
 
-add_thread_commands ()
+
+static void
+add_thread_commands (void)
 {
   add_prefix_cmd ("thread", no_class, set_thread_cmd,
 		  "Command prefix for setting thread properties.",
@@ -3210,15 +3290,17 @@ add_thread_commands ()
 		  &show_thread_cmd_list);
 
   add_cmd ("pause", class_run, set_thread_pause_cmd,
-      "Set whether the current thread is suspended while gdb has control.\n"
-	   "A value of \"on\" takes effect immediately, otherwise nothing\n"
-	   "happens until the next time the program is continued.  This\n"
-    "property normally has no effect because the whole task is suspended,\n"
-	   "however, that may be disabled with \"set task pause off\".\n"
-	   "The default value is \"off\".",
+	   "Set whether the current thread is suspended \
+while gdb has control.\n\
+A value of \"on\" takes effect immediately, otherwise nothing happens\n\
+until the next time the program is continued.  This property normally\n\
+has no effect because the whole task is suspended, however, that may\n\
+be disabled with \"set task pause off\".\n\
+The default value is \"off\".",
 	   &set_thread_cmd_list);
   add_cmd ("pause", no_class, show_thread_pause_cmd,
-      "Show whether the current thread is suspended while gdb has control.",
+	   "Show whether the current thread is suspended \
+while gdb has control.",
 	   &show_thread_cmd_list);
 
   add_cmd ("run", class_run, set_thread_run_cmd,
@@ -3229,43 +3311,46 @@ add_thread_commands ()
 	   &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 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 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.",
 	   &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"
-	   "The argument should be the value of the send right in the task.",
+	   "Set the thread exception port to which we forward exceptions.\n\
+This overrides the task exception port.\n\
+The argument should be the value of the send right in the task.",
 	   &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_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.",
+	   "Force the threads absolute suspend-count to be gdb's.\n\
+Prior to giving this command, gdb's thread suspend-counts are relative\n\
+to the thread's initial suspend-count when gdb notices the threads.",
 	   &thread_cmd_list);
 }
+
 
 void
-_initialize_gnu_nat ()
+_initialize_gnu_nat (void)
 {
   proc_server = getproc ();
+  
   init_gnu_ops ();
   add_target (&gnu_ops);
+
   add_task_commands ();
   add_thread_commands ();
-
   add_set_cmd ("gnu-debug", class_maintenance,
 	       var_boolean, (char *) &gnu_debug_flag,
-	     "Set debugging output for the gnu backend.", &maintenancelist);
+	       "Set debugging output for the gnu backend.", &maintenancelist);
 }
 
 #ifdef	FLUSH_INFERIOR_CACHE