import gdb-1999-07-07 post reformat

1 files changed, 1024 insertions, 959 deletions

diff --git a/gdb/m3-nat.c b/gdb/m3-nat.c
index 4614f65..61274bd 100644
--- a/gdb/m3-nat.c
+++ b/gdb/m3-nat.c
@@ -3,36 +3,37 @@
 
    Copyright (C) 1992, 1996, 1999 Free Software Foundation, Inc.
 
-This file is part of GDB.
+   This file is part of GDB.
 
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
 
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+   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., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
 
 /*
  * Author: Jukka Virtanen <jtv@hut.fi>
- *	   Computing Centre
+ *         Computing Centre
  *         Helsinki University of Technology
  *         Finland
  *
  * Thanks to my friends who helped with ideas and testing:
  *
- *	Johannes Helander, Antti Louko, Tero Mononen,
- *	jvh@cs.hut.fi	   alo@hut.fi   tmo@cs.hut.fi
+ *      Johannes Helander, Antti Louko, Tero Mononen,
+ *      jvh@cs.hut.fi      alo@hut.fi   tmo@cs.hut.fi
  *
  *      Tero Kivinen       and          Eamonn McManus
- *	kivinen@cs.hut.fi               emcmanus@gr.osf.org
- *	
+ *      kivinen@cs.hut.fi               emcmanus@gr.osf.org
+ *      
  */
 
 #include <stdio.h>
@@ -64,12 +65,12 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 #endif
 
 /* Included only for signal names and NSIG
- *
+
  * note: There are many problems in signal handling with
  *       gdb in Mach 3.0 in general.
  */
 #include <signal.h>
-#define SIG_UNKNOWN 0	/* Exception that has no matching unix signal */
+#define SIG_UNKNOWN 0		/* Exception that has no matching unix signal */
 
 #include <cthreads.h>
 
@@ -113,29 +114,31 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 #define CPROC_CONDWAIT	4
 
 /* For cproc and kernel thread mapping */
-typedef struct gdb_thread {
-  mach_port_t	name;
-  CORE_ADDR	sp;
-  CORE_ADDR	pc;
-  CORE_ADDR	fp;
-  boolean_t     in_emulator;
-  int		slotid;
-
-  /* This is for the mthreads list.  It points to the cproc list.
-     Perhaps the two lists should be merged (or perhaps it was a mistake
-     to make them both use a struct gdb_thread).  */
-  struct gdb_thread *cproc;
-
-  /* These are for the cproc list, which is linked through the next field
-     of the struct gdb_thread.  */
-  char raw_cproc[CPROC_SIZE];
-  /* The cthread which is pointed to by the incarnation field from the
-     cproc.  This points to the copy we've read into GDB.  */
-  cthread_t cthread;
-  /* Point back to the mthreads list.  */
-  int reverse_map;
-  struct gdb_thread *next;
-} *gdb_thread_t;
+typedef struct gdb_thread
+  {
+    mach_port_t name;
+    CORE_ADDR sp;
+    CORE_ADDR pc;
+    CORE_ADDR fp;
+    boolean_t in_emulator;
+    int slotid;
+
+    /* This is for the mthreads list.  It points to the cproc list.
+       Perhaps the two lists should be merged (or perhaps it was a mistake
+       to make them both use a struct gdb_thread).  */
+    struct gdb_thread *cproc;
+
+    /* These are for the cproc list, which is linked through the next field
+       of the struct gdb_thread.  */
+    char raw_cproc[CPROC_SIZE];
+    /* The cthread which is pointed to by the incarnation field from the
+       cproc.  This points to the copy we've read into GDB.  */
+    cthread_t cthread;
+    /* Point back to the mthreads list.  */
+    int reverse_map;
+    struct gdb_thread *next;
+  }
+ *gdb_thread_t;
 
 /* 
  * Actions for Mach exceptions.
@@ -146,23 +149,46 @@ typedef struct gdb_thread {
  * if SIG_UNKNOWN is specified.
  */
 
-struct exception_list {
-  char *name;
-  boolean_t forward;
-  boolean_t print;
-  int       sigmap;
-} exception_map[] = {
-  {"not_mach3_exception",	FALSE, TRUE,  SIG_UNKNOWN},
-  {"EXC_BAD_ACCESS",		FALSE, TRUE,  SIGSEGV},
-  {"EXC_BAD_INSTRUCTION",	FALSE, TRUE,  SIGILL},
-  {"EXC_ARITHMETIC",		FALSE, TRUE,  SIGFPE},
-  {"EXC_EMULATION",		FALSE, TRUE,  SIGEMT},	/* ??? */
-  {"EXC_SOFTWARE",		FALSE, TRUE,  SIG_UNKNOWN},
-  {"EXC_BREAKPOINT",		FALSE, FALSE, SIGTRAP}
+struct exception_list
+  {
+    char *name;
+    boolean_t forward;
+    boolean_t print;
+    int sigmap;
+  }
+exception_map[] =
+{
+  {
+    "not_mach3_exception", FALSE, TRUE, SIG_UNKNOWN
+  }
+  ,
+  {
+    "EXC_BAD_ACCESS", FALSE, TRUE, SIGSEGV
+  }
+  ,
+  {
+    "EXC_BAD_INSTRUCTION", FALSE, TRUE, SIGILL
+  }
+  ,
+  {
+    "EXC_ARITHMETIC", FALSE, TRUE, SIGFPE
+  }
+  ,
+  {
+    "EXC_EMULATION", FALSE, TRUE, SIGEMT
+  }
+  ,				/* ??? */
+  {
+    "EXC_SOFTWARE", FALSE, TRUE, SIG_UNKNOWN
+  }
+  ,
+  {
+    "EXC_BREAKPOINT", FALSE, FALSE, SIGTRAP
+  }
 };
 
 /* Mach exception table size */
-int max_exception = sizeof(exception_map)/sizeof(struct exception_list) - 1;
+int max_exception = sizeof (exception_map) / sizeof (struct exception_list) - 1;
 
 #define MAX_EXCEPTION max_exception
 
@@ -172,7 +198,7 @@ WAITTYPE wait_status;
  * dumped while waiting the inferior to EXEC the correct
  * program
  */
-/* #define DUMP_SYSCALL		/* debugging interceptor */
+/* #define DUMP_SYSCALL         /* debugging interceptor */
 
 /* xx_debug() outputs messages if this is nonzero.
  * If > 1, DUMP_SYSCALL will dump message contents.
@@ -181,16 +207,16 @@ int debug_level = 0;
 
 /* "Temporary" debug stuff */
 void
-xx_debug (fmt, a,b,c)
-char *fmt;
-int a,b,c;
+xx_debug (fmt, a, b, c)
+     char *fmt;
+     int a, b, c;
 {
   if (debug_level)
     warning (fmt, a, b, c);
 }
 
 /* This is in libmach.a */
-extern  mach_port_t  name_server_port;
+extern mach_port_t name_server_port;
 
 /* Set in catch_exception_raise */
 int stop_exception, stop_code, stop_subcode;
@@ -204,23 +230,23 @@ char *hostname = "";
 /* Set when task is attached or created */
 boolean_t emulator_present = FALSE;
 
-task_t   inferior_task;
+task_t inferior_task;
 thread_t current_thread;
 
 /* Exception ports for inferior task */
-mach_port_t inferior_exception_port     = MACH_PORT_NULL;
+mach_port_t inferior_exception_port = MACH_PORT_NULL;
 mach_port_t inferior_old_exception_port = MACH_PORT_NULL;
 
 /* task exceptions and notifications */
-mach_port_t inferior_wait_port_set	= MACH_PORT_NULL;
-mach_port_t our_notify_port       	= MACH_PORT_NULL;
+mach_port_t inferior_wait_port_set = MACH_PORT_NULL;
+mach_port_t our_notify_port = MACH_PORT_NULL;
 
 /* This is "inferior_wait_port_set" when not single stepping, and
  *         "singlestepped_thread_port" when we are single stepping.
  * 
  * This is protected by a cleanup function: discard_single_step()
  */
-mach_port_t currently_waiting_for	= MACH_PORT_NULL;
+mach_port_t currently_waiting_for = MACH_PORT_NULL;
 
 /* A port for external messages to gdb.
  * External in the meaning that they do not come
@@ -235,16 +261,16 @@ mach_port_t currently_waiting_for	= MACH_PORT_NULL;
  *    (top-gdb) set stop_inferior_gdb ()
  *    (top-gdb) continue
  */
-mach_port_t our_message_port       	= MACH_PORT_NULL;
+mach_port_t our_message_port = MACH_PORT_NULL;
 
 /* For single stepping */
-mach_port_t thread_exception_port 	= MACH_PORT_NULL;
+mach_port_t thread_exception_port = MACH_PORT_NULL;
 mach_port_t thread_saved_exception_port = MACH_PORT_NULL;
-mach_port_t singlestepped_thread_port   = MACH_PORT_NULL;
+mach_port_t singlestepped_thread_port = MACH_PORT_NULL;
 
 /* For machid calls */
 mach_port_t mid_server = MACH_PORT_NULL;
-mach_port_t mid_auth   = MACH_PORT_NULL;
+mach_port_t mid_auth = MACH_PORT_NULL;
 
 /* If gdb thinks the inferior task is not suspended, it
  * must take suspend/abort the threads when it reads the state.
@@ -258,8 +284,8 @@ int must_suspend_thread = 0;
  */
 #define NULL_CLEANUP (struct cleanup *)0
 struct cleanup *cleanup_step = NULL_CLEANUP;
-
 
+
 static struct target_ops m3_ops;
 
 static void m3_kill_inferior ();
@@ -270,13 +296,14 @@ static void m3_kill_inferior ();
 
 /* Chain of ports to remember requested notifications. */
 
-struct port_chain {
-  struct port_chain *next;
-  mach_port_t	     port;
-  int		     type;
-  int		     mid;  /* Now only valid with MACH_TYPE_THREAD and */
-  			   /*  MACH_TYPE_THREAD */
-};
+struct port_chain
+  {
+    struct port_chain *next;
+    mach_port_t port;
+    int type;
+    int mid;			/* Now only valid with MACH_TYPE_THREAD and */
+    /*  MACH_TYPE_THREAD */
+  };
 typedef struct port_chain *port_chain_t;
 
 /* Room for chain nodes comes from pchain_obstack */
@@ -294,18 +321,18 @@ port_chain_t
 port_chain_insert (list, name, type)
      port_chain_t list;
      mach_port_t name;
-     int	 type;
+     int type;
 {
   kern_return_t ret;
   port_chain_t new;
   int mid;
 
-  if (! MACH_PORT_VALID (name))
+  if (!MACH_PORT_VALID (name))
     return list;
-  
+
   if (type == MACH_TYPE_TASK || type == MACH_TYPE_THREAD)
     {
-      if (! MACH_PORT_VALID (mid_server))
+      if (!MACH_PORT_VALID (mid_server))
 	{
 	  warning ("Machid server port invalid, can not map port 0x%x to MID",
 		   name);
@@ -314,7 +341,7 @@ port_chain_insert (list, name, type)
       else
 	{
 	  ret = machid_mach_register (mid_server, mid_auth, name, type, &mid);
-	  
+
 	  if (ret != KERN_SUCCESS)
 	    {
 	      warning ("Can not map name (0x%x) to MID with machid", name);
@@ -327,10 +354,10 @@ port_chain_insert (list, name, type)
 
   new = (port_chain_t) obstack_alloc (port_chain_obstack,
 				      sizeof (struct port_chain));
-  new->next  = list;
-  new->port  = name;
-  new->type  = type;
-  new->mid   = mid;
+  new->next = list;
+  new->port = name;
+  new->type = type;
+  new->mid = mid;
 
   return new;
 }
@@ -347,7 +374,7 @@ port_chain_delete (list, elem)
       while (list->next)
 	{
 	  if (list->next->port == elem)
-	    list->next = list->next->next; /* GCd with obstack_free() */
+	    list->next = list->next->next;	/* GCd with obstack_free() */
 	  else
 	    list = list->next;
 	}
@@ -378,8 +405,8 @@ port_chain_member (list, elem)
 
 int
 map_port_name_to_mid (name, type)
-mach_port_t name;
-int         type;
+     mach_port_t name;
+     int type;
 {
   port_chain_t elem;
 
@@ -390,11 +417,11 @@ int         type;
 
   if (elem && (elem->type == type))
     return elem->mid;
-  
+
   if (elem)
     return -1;
-  
-  if (! MACH_PORT_VALID (mid_server))
+
+  if (!MACH_PORT_VALID (mid_server))
     {
       warning ("Machid server port invalid, can not map port 0x%x to mid",
 	       name);
@@ -406,7 +433,7 @@ int         type;
       kern_return_t ret;
 
       ret = machid_mach_register (mid_server, mid_auth, name, type, &mid);
-      
+
       if (ret != KERN_SUCCESS)
 	{
 	  warning ("Can not map name (0x%x) to mid with machid", name);
@@ -429,12 +456,12 @@ discard_single_step (thread)
 }
 
 setup_single_step (thread, start_step)
-     thread_t  thread;
+     thread_t thread;
      boolean_t start_step;
 {
   kern_return_t ret;
 
-  if (! MACH_PORT_VALID (thread))
+  if (!MACH_PORT_VALID (thread))
     error ("Invalid thread supplied to setup_single_step");
   else
     {
@@ -443,7 +470,7 @@ setup_single_step (thread, start_step)
       /* Get the current thread exception port */
       ret = thread_get_exception_port (thread, &teport);
       CHK ("Getting thread's exception port", ret);
-	  
+
       if (start_step)
 	{
 	  if (MACH_PORT_VALID (singlestepped_thread_port))
@@ -452,7 +479,7 @@ setup_single_step (thread, start_step)
 		       singlestepped_thread_port);
 	      singlestepped_thread_port = MACH_PORT_NULL;
 	    }
-      
+
 	  /* If we are already stepping this thread */
 	  if (MACH_PORT_VALID (teport) && teport == thread_exception_port)
 	    {
@@ -465,7 +492,7 @@ setup_single_step (thread, start_step)
 	      CHK ("Setting exception port for thread", ret);
 #if 0
 	      /* Insert thread exception port to wait port set */
-	      ret = mach_port_move_member (mach_task_self(), 
+	      ret = mach_port_move_member (mach_task_self (),
 					   thread_exception_port,
 					   inferior_wait_port_set);
 	      CHK ("Moving thread exception port to inferior_wait_port_set",
@@ -473,42 +500,42 @@ setup_single_step (thread, start_step)
 #endif
 	      thread_saved_exception_port = teport;
 	    }
-	  
+
 	  thread_trace (thread, TRUE);
-	  
-	  singlestepped_thread_port   = thread_exception_port;
-	  currently_waiting_for       = singlestepped_thread_port;
+
+	  singlestepped_thread_port = thread_exception_port;
+	  currently_waiting_for = singlestepped_thread_port;
 	  cleanup_step = make_cleanup (discard_single_step, thread);
 	}
       else
 	{
-	  if (! MACH_PORT_VALID (teport))
+	  if (!MACH_PORT_VALID (teport))
 	    error ("Single stepped thread had an invalid exception port?");
 
 	  if (teport != thread_exception_port)
 	    error ("Single stepped thread had an unknown exception port?");
-	  
+
 	  ret = mach_port_deallocate (mach_task_self (), teport);
 	  CHK ("Couldn't deallocate thread exception port", ret);
 #if 0
 	  /* Remove thread exception port from wait port set */
-	  ret = mach_port_move_member (mach_task_self(), 
+	  ret = mach_port_move_member (mach_task_self (),
 				       thread_exception_port,
 				       MACH_PORT_NULL);
 	  CHK ("Removing thread exception port from inferior_wait_port_set",
 	       ret);
-#endif	  
+#endif
 	  /* Restore thread's old exception port */
 	  ret = thread_set_exception_port (thread,
 					   thread_saved_exception_port);
 	  CHK ("Restoring stepped thread's exception port", ret);
-	  
+
 	  if (MACH_PORT_VALID (thread_saved_exception_port))
 	    (void) mach_port_deallocate (mach_task_self (),
 					 thread_saved_exception_port);
-	  
+
 	  thread_trace (thread, FALSE);
-	  
+
 	  singlestepped_thread_port = MACH_PORT_NULL;
 	  currently_waiting_for = inferior_wait_port_set;
 	  if (cleanup_step)
@@ -519,20 +546,20 @@ setup_single_step (thread, start_step)
 
 static
 request_notify (name, variant, type)
-     mach_port_t	name;
-     mach_msg_id_t	variant;
-     int	        type;
+     mach_port_t name;
+     mach_msg_id_t variant;
+     int type;
 {
   kern_return_t ret;
-  mach_port_t	previous_port_dummy = MACH_PORT_NULL;
-  
-  if (! MACH_PORT_VALID (name))
+  mach_port_t previous_port_dummy = MACH_PORT_NULL;
+
+  if (!MACH_PORT_VALID (name))
     return;
-  
+
   if (port_chain_member (notify_chain, name))
     return;
 
-  ret = mach_port_request_notification (mach_task_self(),
+  ret = mach_port_request_notification (mach_task_self (),
 					name,
 					variant,
 					1,
@@ -547,22 +574,22 @@ request_notify (name, variant, type)
   notify_chain = port_chain_insert (notify_chain, name, type);
 }
 
-reverse_msg_bits(msgp, type)
-     mach_msg_header_t	*msgp;
+reverse_msg_bits (msgp, type)
+     mach_msg_header_t *msgp;
      int type;
 {
-  int		rbits,lbits;
-  rbits = MACH_MSGH_BITS_REMOTE(msgp->msgh_bits);
+  int rbits, lbits;
+  rbits = MACH_MSGH_BITS_REMOTE (msgp->msgh_bits);
   lbits = type;
   msgp->msgh_bits =
     (msgp->msgh_bits & ~MACH_MSGH_BITS_PORTS_MASK) |
-      MACH_MSGH_BITS(lbits,rbits);
+    MACH_MSGH_BITS (lbits, rbits);
 }
 
 /* On the third day He said:
 
-   	Let this be global
-	and then it was global.
+   Let this be global
+   and then it was global.
 
    When creating the inferior fork, the
    child code in inflow.c sets the name of the
@@ -588,7 +615,7 @@ static void
 m3_trace_me ()
 {
   kern_return_t ret;
-  
+
   /* Get the NAME of the bootstrap port in this task
      so that GDB can read it */
   ret = task_get_bootstrap_port (mach_task_self (),
@@ -599,7 +626,7 @@ m3_trace_me ()
 			      original_server_port_name);
   if (ret != KERN_SUCCESS)
     abort ();
-  
+
   /* Suspend this task to let the parent change my ports.
      Resumed by the debugger */
   ret = task_suspend (mach_task_self ());
@@ -621,11 +648,12 @@ intercept_exec_calls (exec_counter)
 {
   int terminal_initted = 0;
 
-  struct syscall_msg_t {
-    mach_msg_header_t	header;
-    mach_msg_type_t 	type;
-    char room[ 2000 ];	/* Enuff space */
-  };
+  struct syscall_msg_t
+    {
+      mach_msg_header_t header;
+      mach_msg_type_t type;
+      char room[2000];		/* Enuff space */
+    };
 
   struct syscall_msg_t syscall_in, syscall_out;
 
@@ -642,20 +670,20 @@ intercept_exec_calls (exec_counter)
   kern_return_t ret;
 
   if (exec_counter <= 0)
-    return;		/* We are already set up in the correct program */
+    return;			/* We are already set up in the correct program */
+
+  ret = mach_port_allocate (mach_task_self (),
+			    MACH_PORT_RIGHT_RECEIVE,
+			    &fake_server);
+  CHK ("create inferior_fake_server port failed", ret);
 
-  ret = mach_port_allocate(mach_task_self(), 
-			   MACH_PORT_RIGHT_RECEIVE,
-			   &fake_server);
-  CHK("create inferior_fake_server port failed", ret);
-  
   /* Wait for inferior_task to suspend itself */
-  while(1)
+  while (1)
     {
       info_count = sizeof (info);
       ret = task_info (inferior_task,
 		       TASK_BASIC_INFO,
-		       (task_info_t)&info,
+		       (task_info_t) & info,
 		       &info_count);
       CHK ("Task info", ret);
 
@@ -665,7 +693,7 @@ intercept_exec_calls (exec_counter)
       /* Note that the definition of the parameter was undefined
        * at the time of this writing, so I just use an `ad hoc' value.
        */
-      (void) swtch_pri (42); /* Universal Priority Value */
+      (void) swtch_pri (42);	/* Universal Priority Value */
     }
 
   /* Read the inferior's bootstrap port name */
@@ -682,62 +710,62 @@ intercept_exec_calls (exec_counter)
 				 MACH_MSG_TYPE_MOVE_SEND,
 				 &original_server_send,
 				 &acquired);
-  CHK("mach_port_extract_right (bsd server send)",ret);
-  
+  CHK ("mach_port_extract_right (bsd server send)", ret);
+
   if (acquired != MACH_MSG_TYPE_PORT_SEND)
-    error("Incorrect right extracted, send right to bsd server excpected");
+    error ("Incorrect right extracted, send right to bsd server excpected");
 
   ret = mach_port_insert_right (inferior_task,
 				original_server_port_name,
 				fake_server,
 				MACH_MSG_TYPE_MAKE_SEND);
-  CHK("mach_port_insert_right (fake server send)",ret);
+  CHK ("mach_port_insert_right (fake server send)", ret);
 
   xx_debug ("inferior task bsd server ports set up \nfs %x, ospn %x, oss %x\n",
 	    fake_server,
 	    original_server_port_name, original_server_send);
 
   /* A receive right to the reply generated by unix server exec() request */
-  ret = mach_port_allocate(mach_task_self(), 
-			   MACH_PORT_RIGHT_RECEIVE,
-			   &exec_reply);
-  CHK("create intercepted_reply_port port failed", ret);
-    
+  ret = mach_port_allocate (mach_task_self (),
+			    MACH_PORT_RIGHT_RECEIVE,
+			    &exec_reply);
+  CHK ("create intercepted_reply_port port failed", ret);
+
   /* Pass this send right to Unix server so it replies to us after exec() */
   ret = mach_port_extract_right (mach_task_self (),
 				 exec_reply,
 				 MACH_MSG_TYPE_MAKE_SEND_ONCE,
 				 &exec_reply_send,
 				 &acquired);
-  CHK("mach_port_extract_right (exec_reply)",ret);
+  CHK ("mach_port_extract_right (exec_reply)", ret);
 
   if (acquired != MACH_MSG_TYPE_PORT_SEND_ONCE)
-    error("Incorrect right extracted, send once excpected for exec reply");
+    error ("Incorrect right extracted, send once excpected for exec reply");
 
-  ret = mach_port_move_member(mach_task_self(), 
-			      fake_server,
-			      inferior_wait_port_set);
+  ret = mach_port_move_member (mach_task_self (),
+			       fake_server,
+			       inferior_wait_port_set);
   CHK ("Moving fake syscall port to inferior_wait_port_set", ret);
 
   xx_debug ("syscall fake server set up, resuming inferior\n");
-  
+
   ret = task_resume (inferior_task);
-  CHK("task_resume (startup)", ret);
-	
+  CHK ("task_resume (startup)", ret);
+
   /* Read requests from the inferior.
      Pass directly through everything else except exec() calls.
    */
-  while(exec_counter > 0)
+  while (exec_counter > 0)
     {
       ret = mach_msg (&syscall_in.header,	/* header */
-		      MACH_RCV_MSG,		/* options */
-		      0,			/* send size */
-		      sizeof (struct syscall_msg_t), /* receive size */
-		      inferior_wait_port_set,        /* receive_name */
+		      MACH_RCV_MSG,	/* options */
+		      0,	/* send size */
+		      sizeof (struct syscall_msg_t),	/* receive size */
+		      inferior_wait_port_set,	/* receive_name */
 		      MACH_MSG_TIMEOUT_NONE,
 		      MACH_PORT_NULL);
-      CHK("mach_msg (intercepted sycall)", ret);
-	    
+      CHK ("mach_msg (intercepted sycall)", ret);
+
 #ifdef DUMP_SYSCALL
       print_msg (&syscall_in.header);
 #endif
@@ -759,11 +787,11 @@ intercept_exec_calls (exec_counter)
 	  if (!terminal_initted)
 	    {
 	      /* Now that the child has exec'd we know it has already set its
-		 process group.  On POSIX systems, tcsetpgrp will fail with
-		 EPERM if we try it before the child's setpgid.  */
+	         process group.  On POSIX systems, tcsetpgrp will fail with
+	         EPERM if we try it before the child's setpgid.  */
 
 	      /* Set up the "saved terminal modes" of the inferior
-		 based on what modes we are starting it with.  */
+	         based on what modes we are starting it with.  */
 	      target_terminal_init ();
 
 	      /* Install inferior's terminal modes.  */
@@ -774,34 +802,34 @@ intercept_exec_calls (exec_counter)
 
 	  exec_counter--;
 	}
-	    
-      syscall_in.header.msgh_local_port  = syscall_in.header.msgh_remote_port;
+
+      syscall_in.header.msgh_local_port = syscall_in.header.msgh_remote_port;
       syscall_in.header.msgh_remote_port = original_server_send;
 
-      reverse_msg_bits(&syscall_in.header, MACH_MSG_TYPE_COPY_SEND);
+      reverse_msg_bits (&syscall_in.header, MACH_MSG_TYPE_COPY_SEND);
 
       ret = mach_msg_send (&syscall_in.header);
       CHK ("Forwarded syscall", ret);
     }
-	
-  ret = mach_port_move_member(mach_task_self(), 
-			      fake_server,
-			      MACH_PORT_NULL);
+
+  ret = mach_port_move_member (mach_task_self (),
+			       fake_server,
+			       MACH_PORT_NULL);
   CHK ("Moving fake syscall out of inferior_wait_port_set", ret);
 
-  ret = mach_port_move_member(mach_task_self(), 
-			      exec_reply,
-			      inferior_wait_port_set);
+  ret = mach_port_move_member (mach_task_self (),
+			       exec_reply,
+			       inferior_wait_port_set);
   CHK ("Moving exec_reply to inferior_wait_port_set", ret);
 
   ret = mach_msg (&syscall_in.header,	/* header */
-		  MACH_RCV_MSG,		/* options */
-		  0,			/* send size */
+		  MACH_RCV_MSG,	/* options */
+		  0,		/* send size */
 		  sizeof (struct syscall_msg_t),	/* receive size */
-		  inferior_wait_port_set,		/* receive_name */
+		  inferior_wait_port_set,	/* receive_name */
 		  MACH_MSG_TIMEOUT_NONE,
 		  MACH_PORT_NULL);
-  CHK("mach_msg (exec reply)", ret);
+  CHK ("mach_msg (exec reply)", ret);
 
   ret = task_suspend (inferior_task);
   CHK ("Suspending inferior after last exec", ret);
@@ -811,7 +839,7 @@ intercept_exec_calls (exec_counter)
   xx_debug ("Received exec reply from bsd server, suspended inferior task\n");
 
 #ifdef DUMP_SYSCALL
-      print_msg (&syscall_in.header);
+  print_msg (&syscall_in.header);
 #endif
 
   /* Message should appear as if it came from the unix server */
@@ -820,7 +848,7 @@ intercept_exec_calls (exec_counter)
   /*  and go to the inferior task original reply port */
   syscall_in.header.msgh_remote_port = original_exec_reply;
 
-  reverse_msg_bits(&syscall_in.header, MACH_MSG_TYPE_MOVE_SEND_ONCE);
+  reverse_msg_bits (&syscall_in.header, MACH_MSG_TYPE_MOVE_SEND_ONCE);
 
   ret = mach_msg_send (&syscall_in.header);
   CHK ("Forwarding exec reply to inferior", ret);
@@ -839,12 +867,12 @@ intercept_exec_calls (exec_counter)
   ret = mach_port_destroy (mach_task_self (),
 			   fake_server);
   fake_server = MACH_PORT_DEAD;
-  CHK("mach_port_destroy (fake_server)", ret);
+  CHK ("mach_port_destroy (fake_server)", ret);
 
   ret = mach_port_destroy (mach_task_self (),
 			   exec_reply);
   exec_reply = MACH_PORT_DEAD;
-  CHK("mach_port_destroy (exec_reply)", ret);
+  CHK ("mach_port_destroy (exec_reply)", ret);
 
   xx_debug ("Done with exec call interception\n");
 }
@@ -852,7 +880,7 @@ intercept_exec_calls (exec_counter)
 void
 consume_send_rights (thread_list, thread_count)
      thread_array_t thread_list;
-     int            thread_count;
+     int thread_count;
 {
   int index;
 
@@ -863,7 +891,7 @@ consume_send_rights (thread_list, thread_count)
     {
       /* Since thread kill command kills threads, don't check ret */
       (void) mach_port_deallocate (mach_task_self (),
-				   thread_list [ index ]);
+				   thread_list[index]);
     }
 }
 
@@ -878,7 +906,7 @@ setup_thread (thread, what)
     {
       ret = thread_suspend (thread);
       CHK ("setup_thread thread_suspend", ret);
-      
+
       ret = thread_abort (thread);
       CHK ("setup_thread thread_abort", ret);
     }
@@ -900,34 +928,34 @@ map_slot_to_mid (slot, threads, thread_count)
   int index;
   int mid;
 
-  if (! threads)
+  if (!threads)
     {
       deallocate++;
       ret = task_threads (inferior_task, &threads, &thread_count);
       CHK ("Can not select a thread from a dead task", ret);
     }
-  
+
   if (slot < 0 || slot >= thread_count)
     {
       if (deallocate)
 	{
 	  consume_send_rights (threads, thread_count);
-	  (void) vm_deallocate (mach_task_self(), (vm_address_t)threads, 
-				(thread_count * sizeof(mach_port_t)));
+	  (void) vm_deallocate (mach_task_self (), (vm_address_t) threads,
+				(thread_count * sizeof (mach_port_t)));
 	}
       if (slot < 0)
 	error ("invalid slot number");
       else
-	return -(slot+1);
+	return -(slot + 1);
     }
 
-  mid = map_port_name_to_mid (threads [slot], MACH_TYPE_THREAD);
+  mid = map_port_name_to_mid (threads[slot], MACH_TYPE_THREAD);
 
   if (deallocate)
     {
       consume_send_rights (threads, thread_count);
-      (void) vm_deallocate (mach_task_self(), (vm_address_t)threads, 
-			    (thread_count * sizeof(mach_port_t)));
+      (void) vm_deallocate (mach_task_self (), (vm_address_t) threads,
+			    (thread_count * sizeof (mach_port_t)));
     }
 
   return mid;
@@ -943,16 +971,16 @@ parse_thread_id (arg, thread_count, slots)
   int mid;
   int slot;
   int index;
-  
+
   if (arg == 0)
     return 0;
-  
+
   while (*arg && (*arg == ' ' || *arg == '\t'))
     arg++;
-  
-  if (! *arg)
+
+  if (!*arg)
     return 0;
-  
+
   /* Currently parse MID and @SLOTNUMBER */
   if (*arg != '@')
     {
@@ -961,7 +989,7 @@ parse_thread_id (arg, thread_count, slots)
 	error ("valid thread mid expected");
       return mid;
     }
-  
+
   arg++;
   slot = atoi (arg);
 
@@ -969,19 +997,19 @@ parse_thread_id (arg, thread_count, slots)
     error ("invalid slot number");
 
   /* If you want slot numbers to remain slot numbers, set slots.
-   *
+
    * Well, since 0 is reserved, return the ordinal number
    * of the thread rather than the slot number. Awk, this
    * counts as a kludge.
    */
   if (slots)
-    return -(slot+1);
+    return -(slot + 1);
 
   if (thread_count && slot >= thread_count)
-    return -(slot+1);
+    return -(slot + 1);
 
   mid = map_slot_to_mid (slot);
-  
+
   return mid;
 }
 
@@ -1028,26 +1056,26 @@ select_thread (task, thread_id, flag)
       warning ("Task %d has no threads",
 	       map_port_name_to_mid (task, MACH_TYPE_TASK));
       current_thread = MACH_PORT_NULL;
-      (void) vm_deallocate(mach_task_self(),
-			   (vm_address_t) thread_list,
-			   (thread_count * sizeof(mach_port_t)));
+      (void) vm_deallocate (mach_task_self (),
+			    (vm_address_t) thread_list,
+			    (thread_count * sizeof (mach_port_t)));
       return KERN_FAILURE;
     }
 
-  if (! thread_id || flag == 2)
+  if (!thread_id || flag == 2)
     {
       /* First thread or a slotnumber */
-      if (! thread_id)
+      if (!thread_id)
 	new_thread = thread_list[0];
       else
 	{
 	  if (thread_id < thread_count)
-	    new_thread = thread_list[ thread_id ];
+	    new_thread = thread_list[thread_id];
 	  else
 	    {
-	      (void) vm_deallocate(mach_task_self(),
-				   (vm_address_t) thread_list,
-				   (thread_count * sizeof(mach_port_t)));
+	      (void) vm_deallocate (mach_task_self (),
+				    (vm_address_t) thread_list,
+				    (thread_count * sizeof (mach_port_t)));
 	      error ("No such thread slot number : %d", thread_id);
 	    }
 	}
@@ -1055,27 +1083,27 @@ select_thread (task, thread_id, flag)
   else
     {
       for (index = 0; index < thread_count; index++)
-	if (thread_id == map_port_name_to_mid (thread_list [index],
+	if (thread_id == map_port_name_to_mid (thread_list[index],
 					       MACH_TYPE_THREAD))
 	  {
-	    new_thread = thread_list [index];
+	    new_thread = thread_list[index];
 	    index = -1;
 	    break;
 	  }
-      
+
       if (index != -1)
 	error ("No thread with mid %d", thread_id);
     }
-  
+
   /* Notify when the selected thread dies */
   request_notify (new_thread, MACH_NOTIFY_DEAD_NAME, MACH_TYPE_THREAD);
-  
-  ret = vm_deallocate(mach_task_self(),
-		      (vm_address_t) thread_list,
-		      (thread_count * sizeof(mach_port_t)));
+
+  ret = vm_deallocate (mach_task_self (),
+		       (vm_address_t) thread_list,
+		       (thread_count * sizeof (mach_port_t)));
   CHK ("vm_deallocate", ret);
-  
-  if (! flag)
+
+  if (!flag)
     current_thread = new_thread;
   else
     {
@@ -1083,7 +1111,7 @@ select_thread (task, thread_id, flag)
       if (MACH_PORT_VALID (current_thread))
 	{
 	  /* Store the gdb's view of the thread we are deselecting
-	   *
+
 	   * @@ I think gdb updates registers immediately when they are
 	   * changed, so don't do this.
 	   */
@@ -1102,7 +1130,7 @@ select_thread (task, thread_id, flag)
       ret = thread_abort (current_thread);
       CHK ("Could not abort system calls when selecting a thread", ret);
 
-      stop_pc = read_pc();
+      stop_pc = read_pc ();
       flush_cached_frames ();
 
       select_frame (get_current_frame (), 0);
@@ -1132,7 +1160,7 @@ switch_to_thread (new_thread)
 	current_thread = saved_thread;
       error ("Could not select thread %d", mid);
     }
-	
+
   return mid;
 }
 
@@ -1149,7 +1177,7 @@ m3_trace_him (pid)
 
   inferior_task = task_by_pid (pid);
 
-  if (! MACH_PORT_VALID (inferior_task))
+  if (!MACH_PORT_VALID (inferior_task))
     error ("Can not map Unix pid %d to Mach task", pid);
 
   /* Clean up previous notifications and create new ones */
@@ -1182,36 +1210,36 @@ setup_exception_port ()
 {
   kern_return_t ret;
 
-  ret = mach_port_allocate (mach_task_self(), 
+  ret = mach_port_allocate (mach_task_self (),
 			    MACH_PORT_RIGHT_RECEIVE,
 			    &inferior_exception_port);
-  CHK("mach_port_allocate",ret);
+  CHK ("mach_port_allocate", ret);
 
   /* add send right */
   ret = mach_port_insert_right (mach_task_self (),
 				inferior_exception_port,
 				inferior_exception_port,
 				MACH_MSG_TYPE_MAKE_SEND);
-  CHK("mach_port_insert_right",ret);
+  CHK ("mach_port_insert_right", ret);
 
-  ret = mach_port_move_member (mach_task_self(), 
+  ret = mach_port_move_member (mach_task_self (),
 			       inferior_exception_port,
 			       inferior_wait_port_set);
-  CHK("mach_port_move_member",ret);
+  CHK ("mach_port_move_member", ret);
 
-  ret = task_get_special_port (inferior_task, 
+  ret = task_get_special_port (inferior_task,
 			       TASK_EXCEPTION_PORT,
 			       &inferior_old_exception_port);
-  CHK ("task_get_special_port(old exc)",ret);
+  CHK ("task_get_special_port(old exc)", ret);
 
   ret = task_set_special_port (inferior_task,
-			       TASK_EXCEPTION_PORT, 
+			       TASK_EXCEPTION_PORT,
 			       inferior_exception_port);
-  CHK("task_set_special_port",ret);
+  CHK ("task_set_special_port", ret);
 
   ret = mach_port_deallocate (mach_task_self (),
 			      inferior_exception_port);
-  CHK("mack_port_deallocate",ret);
+  CHK ("mack_port_deallocate", ret);
 
 #if 0
   /* When notify appears, the inferior_task's exception
@@ -1233,7 +1261,7 @@ int mach_really_waiting;
 /* Wait for the inferior to stop for some reason.
    - Loop on notifications until inferior_task dies.
    - Loop on exceptions until stopped_in_exception comes true.
-     (e.g. we receive a single step trace trap)
+   (e.g. we receive a single step trace trap)
    - a message arrives to gdb's message port
 
    There is no other way to exit this loop.
@@ -1248,11 +1276,13 @@ mach_really_wait (pid, ourstatus)
   kern_return_t ret;
   int w;
 
-  struct msg {
-    mach_msg_header_t    header;
-    mach_msg_type_t foo;
-    int             data[8000];
-  } in_msg, out_msg;
+  struct msg
+    {
+      mach_msg_header_t header;
+      mach_msg_type_t foo;
+      int data[8000];
+    }
+  in_msg, out_msg;
 
   /* Either notify (death), exception or message can stop the inferior */
   stopped_in_exception = FALSE;
@@ -1265,15 +1295,15 @@ mach_really_wait (pid, ourstatus)
       stop_thread = MACH_PORT_NULL;
 
       mach_really_waiting = 1;
-      ret = mach_msg (&in_msg.header,		/* header */
-		      MACH_RCV_MSG,		/* options */
-		      0,			/* send size */
+      ret = mach_msg (&in_msg.header,	/* header */
+		      MACH_RCV_MSG,	/* options */
+		      0,	/* send size */
 		      sizeof (struct msg),	/* receive size */
 		      currently_waiting_for,	/* receive name */
 		      MACH_MSG_TIMEOUT_NONE,
 		      MACH_PORT_NULL);
       mach_really_waiting = 0;
-      CHK("mach_msg (receive)", ret);
+      CHK ("mach_msg (receive)", ret);
 
       /* Check if we received a notify of the childs' death */
       if (notify_server (&in_msg.header, &out_msg.header))
@@ -1288,7 +1318,7 @@ mach_really_wait (pid, ourstatus)
 	    {
 	      /* Collect Unix exit status for gdb */
 
-	      wait3(&w, WNOHANG, 0);
+	      wait3 (&w, WNOHANG, 0);
 
 	      /* This mess is here to check that the rest of
 	       * gdb knows that the inferior died. It also
@@ -1297,22 +1327,22 @@ mach_really_wait (pid, ourstatus)
 	       * has happened to it's children when mach-magic
 	       * is applied on them.
 	       */
-	      if ((!WIFEXITED(w) && WIFSTOPPED(w))         ||
-		  (WIFEXITED(w)  && WEXITSTATUS(w) > 0377))
+	      if ((!WIFEXITED (w) && WIFSTOPPED (w)) ||
+		  (WIFEXITED (w) && WEXITSTATUS (w) > 0377))
 		{
-		  WSETEXIT(w, 0);
+		  WSETEXIT (w, 0);
 		  warning ("Using exit value 0 for terminated task");
 		}
-	      else if (!WIFEXITED(w))
+	      else if (!WIFEXITED (w))
 		{
-		  int sig = WTERMSIG(w);
+		  int sig = WTERMSIG (w);
 
 		  /* Signals cause problems. Warn the user. */
-		  if (sig != SIGKILL) /* Bad luck if garbage matches this */
+		  if (sig != SIGKILL)	/* Bad luck if garbage matches this */
 		    warning ("The terminating signal stuff may be nonsense");
 		  else if (sig > NSIG)
 		    {
-		      WSETEXIT(w, 0);
+		      WSETEXIT (w, 0);
 		      warning ("Using exit value 0 for terminated task");
 		    }
 		}
@@ -1322,15 +1352,15 @@ mach_really_wait (pid, ourstatus)
 	}
 
       /* Hmm. Check for exception, as it was not a notification.
-	 exc_server() does an upcall to catch_exception_raise()
-	 if this rpc is an exception. Further actions are decided
-	 there.
+         exc_server() does an upcall to catch_exception_raise()
+         if this rpc is an exception. Further actions are decided
+         there.
        */
-      if (! exc_server (&in_msg.header, &out_msg.header))
+      if (!exc_server (&in_msg.header, &out_msg.header))
 	{
 
 	  /* Not an exception, check for message.
-	   *
+
 	   * Messages don't come from the inferior, or if they
 	   * do they better be asynchronous or it will hang.
 	   */
@@ -1343,11 +1373,11 @@ mach_really_wait (pid, ourstatus)
       /* Send the reply of the exception rpc to the suspended task */
       ret = mach_msg_send (&out_msg.header);
       CHK ("mach_msg_send (exc reply)", ret);
-      
+
       if (stopped_in_exception)
 	{
 	  /* Get unix state. May be changed in mach3_exception_actions() */
-	  wait3(&w, WNOHANG, 0);
+	  wait3 (&w, WNOHANG, 0);
 
 	  mach3_exception_actions (&w, FALSE, "Task");
 
@@ -1365,11 +1395,11 @@ mach3_quit ()
 {
   int mid;
   kern_return_t ret;
-  
+
   if (mach_really_waiting)
     {
       ret = task_suspend (inferior_task);
-      
+
       if (ret != KERN_SUCCESS)
 	{
 	  warning ("Could not suspend task for interrupt: %s",
@@ -1389,7 +1419,7 @@ mach3_quit ()
       mid = 0;
     }
 
-  current_thread = MACH_PORT_NULL; /* Force setup */
+  current_thread = MACH_PORT_NULL;	/* Force setup */
   select_thread (inferior_task, mid, 1);
 
   return;
@@ -1409,7 +1439,7 @@ mach3_request_quit ()
 {
   if (mach_really_waiting)
     immediate_quit = 1;
-}      
+}
 #endif
 
 /*
@@ -1427,23 +1457,24 @@ gdb_message_server (InP)
   if (InP->msgh_local_port == our_message_port)
     {
       /* A message coming to our_message_port. Check validity */
-      switch (InP->msgh_id) {
+      switch (InP->msgh_id)
+	{
 
-      case GDB_MESSAGE_ID_STOP:
-	ret = task_suspend (inferior_task);
-	if (ret != KERN_SUCCESS)
-	  warning ("Could not suspend task for stop message: %s",
-		   mach_error_string (ret));
+	case GDB_MESSAGE_ID_STOP:
+	  ret = task_suspend (inferior_task);
+	  if (ret != KERN_SUCCESS)
+	    warning ("Could not suspend task for stop message: %s",
+		     mach_error_string (ret));
 
-	/* QUIT in mach_really_wait() loop. */
-	request_quit (0);
-	break;
+	  /* QUIT in mach_really_wait() loop. */
+	  request_quit (0);
+	  break;
 
-      default:
-	warning ("Invalid message id %d received, ignored.",
-		 InP->msgh_id);
-	break;
-      }
+	default:
+	  warning ("Invalid message id %d received, ignored.",
+		   InP->msgh_id);
+	  break;
+	}
 
       return 1;
     }
@@ -1453,7 +1484,7 @@ gdb_message_server (InP)
 }
 
 /* NOTE: This is not an RPC call. It is a simpleroutine.
- *
+
  * This is not called from this gdb code.
  *
  * It may be called by another debugger to cause this
@@ -1470,29 +1501,31 @@ stop_inferior_gdb ()
   kern_return_t ret;
 
   /* Code generated by mig, with minor cleanups :-)
-   *
+
    * simpleroutine stop_inferior_gdb (our_message_port : mach_port_t);
    */
 
-  typedef struct {
-    mach_msg_header_t Head;
-  } Request;
+  typedef struct
+    {
+      mach_msg_header_t Head;
+    }
+  Request;
 
   Request Mess;
 
   register Request *InP = &Mess;
 
-  InP->Head.msgh_bits = MACH_MSGH_BITS(MACH_MSG_TYPE_COPY_SEND, 0);
+  InP->Head.msgh_bits = MACH_MSGH_BITS (MACH_MSG_TYPE_COPY_SEND, 0);
 
   /* msgh_size passed as argument */
   InP->Head.msgh_remote_port = our_message_port;
-  InP->Head.msgh_local_port  = MACH_PORT_NULL;
-  InP->Head.msgh_seqno       = 0;
-  InP->Head.msgh_id          = GDB_MESSAGE_ID_STOP;
+  InP->Head.msgh_local_port = MACH_PORT_NULL;
+  InP->Head.msgh_seqno = 0;
+  InP->Head.msgh_id = GDB_MESSAGE_ID_STOP;
 
   ret = mach_msg (&InP->Head,
-		  MACH_SEND_MSG|MACH_MSG_OPTION_NONE,
-		  sizeof(Request),
+		  MACH_SEND_MSG | MACH_MSG_OPTION_NONE,
+		  sizeof (Request),
 		  0,
 		  MACH_PORT_NULL,
 		  MACH_MSG_TIMEOUT_NONE,
@@ -1515,13 +1548,13 @@ mach_thread_for_breakpoint (mid)
 
   if (mid < 0)
     {
-      mid = map_slot_to_mid (-(mid+1), 0, 0);
+      mid = map_slot_to_mid (-(mid + 1), 0, 0);
       if (mid < 0)
 	return 0;		/* Don't stop, no such slot */
     }
 
-  if (! mid || cmid == -1)
-    return 1;	/* stop */
+  if (!mid || cmid == -1)
+    return 1;			/* stop */
 
   return cmid == mid && stop_exception == EXC_BREAKPOINT;
 }
@@ -1560,12 +1593,12 @@ char *
 mach_thread_output_id (mid)
      int mid;
 {
-  static char foobar [20];
+  static char foobar[20];
 
   if (mid > 0)
     sprintf (foobar, "mid %d", mid);
   else if (mid < 0)
-    sprintf (foobar, "@%d", -(mid+1));
+    sprintf (foobar, "@%d", -(mid + 1));
   else
     sprintf (foobar, "*any thread*");
 
@@ -1574,7 +1607,7 @@ mach_thread_output_id (mid)
 #endif /* THREAD_OUTPUT_ID */
 
 /* Called with hook PREPARE_TO_PROCEED() from infrun.c.
- *
+
  * If we have switched threads and stopped at breakpoint return 1 otherwise 0.
  *
  *  if SELECT_IT is nonzero, reselect the thread that was active when
@@ -1591,7 +1624,7 @@ mach3_prepare_to_proceed (select_it)
     {
       int mid;
 
-      if (! select_it)
+      if (!select_it)
 	return 1;
 
       mid = switch_to_thread (stop_thread);
@@ -1607,16 +1640,16 @@ mach3_prepare_to_proceed (select_it)
 
    The code will pass the exception to the inferior if:
 
-     - The task that signaled is not the inferior task
-       (e.g. when debugging another debugger)
+   - The task that signaled is not the inferior task
+   (e.g. when debugging another debugger)
 
-     - The user has explicitely requested to pass on the exceptions.
-       (e.g to the default unix exception handler, which maps
-	exceptions to signals, or the user has her own exception handler)
+   - The user has explicitely requested to pass on the exceptions.
+   (e.g to the default unix exception handler, which maps
+   exceptions to signals, or the user has her own exception handler)
 
-     - If the thread that signaled is being single-stepped and it
-       has set it's own exception port and the exception is not
-       EXC_BREAKPOINT. (Maybe this is not desirable?)
+   - If the thread that signaled is being single-stepped and it
+   has set it's own exception port and the exception is not
+   EXC_BREAKPOINT. (Maybe this is not desirable?)
  */
 
 kern_return_t
@@ -1630,10 +1663,10 @@ catch_exception_raise (port, thread, task, exception, code, subcode)
   boolean_t signal_thread;
   int mid = map_port_name_to_mid (thread, MACH_TYPE_THREAD);
 
-  if (! MACH_PORT_VALID (thread))
+  if (!MACH_PORT_VALID (thread))
     {
       /* If the exception was sent and thread dies before we
-	 receive it, THREAD will be MACH_PORT_DEAD
+         receive it, THREAD will be MACH_PORT_DEAD
        */
 
       current_thread = thread = MACH_PORT_NULL;
@@ -1643,7 +1676,7 @@ catch_exception_raise (port, thread, task, exception, code, subcode)
   /* Check if the task died in transit.
    * @@ Isn't the thread also invalid in such case?
    */
-  if (! MACH_PORT_VALID (task))
+  if (!MACH_PORT_VALID (task))
     {
       current_thread = thread = MACH_PORT_NULL;
       error ("Received exception from nonexistent task");
@@ -1654,17 +1687,17 @@ catch_exception_raise (port, thread, task, exception, code, subcode)
 	   exception,
 	   mid);
 
-  if (! MACH_PORT_VALID (inferior_task))
+  if (!MACH_PORT_VALID (inferior_task))
     error ("got an exception, but inferior_task is null or dead");
-  
+
   stop_exception = exception;
-  stop_code      = code;
-  stop_subcode   = subcode;  
-  stop_thread    = thread;
-  
-  signal_thread = exception != EXC_BREAKPOINT       &&
-    		  port == singlestepped_thread_port &&
-		  MACH_PORT_VALID (thread_saved_exception_port);
+  stop_code = code;
+  stop_subcode = subcode;
+  stop_thread = thread;
+
+  signal_thread = exception != EXC_BREAKPOINT &&
+    port == singlestepped_thread_port &&
+    MACH_PORT_VALID (thread_saved_exception_port);
 
   /* If it was not our inferior or if we want to forward
    * the exception to the inferior's handler, do it here
@@ -1672,26 +1705,26 @@ catch_exception_raise (port, thread, task, exception, code, subcode)
    * Note: If you have forwarded EXC_BREAKPOINT I trust you know why.
    */
   if (task != inferior_task ||
-      signal_thread         ||
-      exception_map [exception].forward)
+      signal_thread ||
+      exception_map[exception].forward)
     {
       mach_port_t eport = inferior_old_exception_port;
 
       if (signal_thread)
 	{
 	  /*
-	    GDB now forwards the exeption to thread's original handler,
-	    since the user propably knows what he is doing.
-	    Give a message, though.
+	     GDB now forwards the exeption to thread's original handler,
+	     since the user propably knows what he is doing.
+	     Give a message, though.
 	   */
 
-	  mach3_exception_actions ((WAITTYPE *)NULL, TRUE, "Thread");
+	  mach3_exception_actions ((WAITTYPE *) NULL, TRUE, "Thread");
 	  eport = thread_saved_exception_port;
 	}
 
       /* Send the exception to the original handler */
       ret = exception_raise (eport,
-			     thread, 
+			     thread,
 			     task,
 			     exception,
 			     code,
@@ -1708,7 +1741,7 @@ catch_exception_raise (port, thread, task, exception, code, subcode)
       /* Do not stop the inferior */
       return ret;
     }
-  
+
   /* Now gdb handles the exception */
   stopped_in_exception = TRUE;
 
@@ -1724,7 +1757,7 @@ catch_exception_raise (port, thread, task, exception, code, subcode)
 	error ("Exception from thread %d while singlestepping thread %d",
 	       mid,
 	       map_port_name_to_mid (current_thread, MACH_TYPE_THREAD));
-      
+
       /* Then select the thread that caused the exception */
       if (select_thread (inferior_task, mid, 0) != KERN_SUCCESS)
 	error ("Could not select thread %d causing exception", mid);
@@ -1745,9 +1778,9 @@ catch_exception_raise (port, thread, task, exception, code, subcode)
 	  /* Single step exception occurred, remove trace bit
 	   * and return to gdb.
 	   */
-	  if (! MACH_PORT_VALID (current_thread))
+	  if (!MACH_PORT_VALID (current_thread))
 	    error ("Single stepped thread is not valid");
-	
+
 	  /* Resume threads, but leave the task suspended */
 	  resume_all_threads (0);
 	}
@@ -1756,7 +1789,7 @@ catch_exception_raise (port, thread, task, exception, code, subcode)
 
       discard_single_step (current_thread);
     }
-  
+
   (void) mach_port_deallocate (mach_task_self (), task);
   (void) mach_port_deallocate (mach_task_self (), thread);
 
@@ -1765,8 +1798,8 @@ catch_exception_raise (port, thread, task, exception, code, subcode)
 
 int
 port_valid (port, mask)
-  mach_port_t port;
-  int         mask;
+     mach_port_t port;
+     int mask;
 {
   kern_return_t ret;
   mach_port_type_t type;
@@ -1795,11 +1828,11 @@ mach3_read_inferior (addr, myaddr, length)
      int length;
 {
   kern_return_t ret;
-  vm_address_t low_address       = (vm_address_t) trunc_page (addr);
-  vm_size_t    aligned_length = 
-    			(vm_size_t) round_page (addr+length) - low_address;
-  pointer_t    copied_memory;
-  int	       copy_count;
+  vm_address_t low_address = (vm_address_t) trunc_page (addr);
+  vm_size_t aligned_length =
+  (vm_size_t) round_page (addr + length) - low_address;
+  pointer_t copied_memory;
+  int copy_count;
 
   /* Get memory from inferior with page aligned addresses */
   ret = vm_read (inferior_task,
@@ -1816,7 +1849,7 @@ mach3_read_inferior (addr, myaddr, length)
        * to arrive via a SINGLE port set. (Including user input!)
        */
 
-      if (! port_valid (inferior_task, MACH_PORT_TYPE_SEND))
+      if (!port_valid (inferior_task, MACH_PORT_TYPE_SEND))
 	{
 	  m3_kill_inferior ();
 	  error ("Inferior killed (task port invalid)");
@@ -1837,12 +1870,12 @@ mach3_read_inferior (addr, myaddr, length)
 	}
     }
 
-  memcpy (myaddr, (char *)addr - low_address + copied_memory, length);
+  memcpy (myaddr, (char *) addr - low_address + copied_memory, length);
 
   ret = vm_deallocate (mach_task_self (),
 		       copied_memory,
 		       copy_count);
-  CHK("mach3_read_inferior vm_deallocate failed", ret);
+  CHK ("mach3_read_inferior vm_deallocate failed", ret);
 
   return length;
 }
@@ -1855,14 +1888,15 @@ mach3_read_inferior (addr, myaddr, length)
   do if (ret != KERN_SUCCESS) { errstr = str; goto out; } while(0)
 #endif
 
-struct vm_region_list {
+struct vm_region_list
+{
   struct vm_region_list *next;
-  vm_prot_t	protection;
-  vm_address_t  start;
-  vm_size_t	length;
+  vm_prot_t protection;
+  vm_address_t start;
+  vm_size_t length;
 };
 
-struct obstack  region_obstack;
+struct obstack region_obstack;
 
 /*
  * Write inferior task's LEN bytes from ADDR and copy it to MYADDR
@@ -1875,17 +1909,17 @@ mach3_write_inferior (addr, myaddr, length)
      int length;
 {
   kern_return_t ret;
-  vm_address_t low_address       = (vm_address_t) trunc_page (addr);
-  vm_size_t    aligned_length = 
-    			(vm_size_t) round_page (addr+length) - low_address;
-  pointer_t    copied_memory;
-  int	       copy_count;
-  int	       deallocate = 0;
+  vm_address_t low_address = (vm_address_t) trunc_page (addr);
+  vm_size_t aligned_length =
+  (vm_size_t) round_page (addr + length) - low_address;
+  pointer_t copied_memory;
+  int copy_count;
+  int deallocate = 0;
 
-  char         *errstr = "Bug in mach3_write_inferior";
+  char *errstr = "Bug in mach3_write_inferior";
 
   struct vm_region_list *region_element;
-  struct vm_region_list *region_head = (struct vm_region_list *)NULL;
+  struct vm_region_list *region_head = (struct vm_region_list *) NULL;
 
   /* Get memory from inferior with page aligned addresses */
   ret = vm_read (inferior_task,
@@ -1897,7 +1931,7 @@ mach3_write_inferior (addr, myaddr, length)
 
   deallocate++;
 
-  memcpy ((char *)addr - low_address + copied_memory, myaddr, length);
+  memcpy ((char *) addr - low_address + copied_memory, myaddr, length);
 
   obstack_init (&region_obstack);
 
@@ -1905,12 +1939,12 @@ mach3_write_inferior (addr, myaddr, length)
    * First check for holes and unwritable memory.
    */
   {
-    vm_size_t    remaining_length  = aligned_length;
-    vm_address_t region_address    = low_address;
+    vm_size_t remaining_length = aligned_length;
+    vm_address_t region_address = low_address;
 
     struct vm_region_list *scan;
 
-    while(region_address < low_address + aligned_length)
+    while (region_address < low_address + aligned_length)
       {
 	vm_prot_t protection;
 	vm_prot_t max_protection;
@@ -1918,9 +1952,9 @@ mach3_write_inferior (addr, myaddr, length)
 	boolean_t shared;
 	mach_port_t object_name;
 	vm_offset_t offset;
-	vm_size_t   region_length = remaining_length;
-	vm_address_t old_address  = region_address;
-    
+	vm_size_t region_length = remaining_length;
+	vm_address_t old_address = region_address;
+
 	ret = vm_region (inferior_task,
 			 &region_address,
 			 &region_length,
@@ -1952,18 +1986,18 @@ mach3_write_inferior (addr, myaddr, length)
 	  }
 
 	/* Chain the regions for later use */
-	region_element = 
+	region_element =
 	  (struct vm_region_list *)
-	    obstack_alloc (&region_obstack, sizeof (struct vm_region_list));
-    
+	  obstack_alloc (&region_obstack, sizeof (struct vm_region_list));
+
 	region_element->protection = protection;
-	region_element->start      = region_address;
-	region_element->length     = region_length;
+	region_element->start = region_address;
+	region_element->length = region_length;
 
 	/* Chain the regions along with protections */
 	region_element->next = region_head;
-	region_head          = region_element;
-	
+	region_head = region_element;
+
 	region_address += region_length;
 	remaining_length = remaining_length - region_length;
       }
@@ -1971,12 +2005,12 @@ mach3_write_inferior (addr, myaddr, length)
     /* If things fail after this, we give up.
      * 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))
 	  {
 	    ret = vm_protect (inferior_task,
@@ -1993,12 +2027,12 @@ mach3_write_inferior (addr, myaddr, length)
 		    copied_memory,
 		    aligned_length);
     CHK_GOTO_OUT ("vm_write failed", ret);
-	
+
     /* 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))
 	  {
 	    ret = vm_protect (inferior_task,
@@ -2011,11 +2045,11 @@ mach3_write_inferior (addr, myaddr, length)
       }
   }
 
- out:
+out:
   if (deallocate)
     {
       obstack_free (&region_obstack, 0);
-      
+
       (void) vm_deallocate (mach_task_self (),
 			    copied_memory,
 			    copy_count);
@@ -2044,24 +2078,31 @@ m3_xfer_memory (memaddr, myaddr, len, write, target)
   if (write)
     result = mach3_write_inferior (memaddr, myaddr, len);
   else
-    result = mach3_read_inferior  (memaddr, myaddr, len);
+    result = mach3_read_inferior (memaddr, myaddr, len);
 
   return result;
 }
-
 
+
 static char *
-translate_state(state)
-int	state;
+translate_state (state)
+     int state;
 {
-  switch (state) {
-  case TH_STATE_RUNNING:	return("R");
-  case TH_STATE_STOPPED:	return("S");
-  case TH_STATE_WAITING:	return("W");
-  case TH_STATE_UNINTERRUPTIBLE: return("U");
-  case TH_STATE_HALTED:		return("H");
-  default:			return("?");
-  }
+  switch (state)
+    {
+    case TH_STATE_RUNNING:
+      return ("R");
+    case TH_STATE_STOPPED:
+      return ("S");
+    case TH_STATE_WAITING:
+      return ("W");
+    case TH_STATE_UNINTERRUPTIBLE:
+      return ("U");
+    case TH_STATE_HALTED:
+      return ("H");
+    default:
+      return ("?");
+    }
 }
 
 static char *
@@ -2070,35 +2111,41 @@ translate_cstate (state)
 {
   switch (state)
     {
-    case CPROC_RUNNING:	return "R";
-    case CPROC_SWITCHING: return "S";
-    case CPROC_BLOCKED: return "B";
-    case CPROC_CONDWAIT: return "C";
-    case CPROC_CONDWAIT|CPROC_SWITCHING: return "CS";
-    default: return "?";
+    case CPROC_RUNNING:
+      return "R";
+    case CPROC_SWITCHING:
+      return "S";
+    case CPROC_BLOCKED:
+      return "B";
+    case CPROC_CONDWAIT:
+      return "C";
+    case CPROC_CONDWAIT | CPROC_SWITCHING:
+      return "CS";
+    default:
+      return "?";
     }
 }
 
 /* type == MACH_MSG_TYPE_COPY_SEND || type == MACH_MSG_TYPE_MAKE_SEND */
 
-mach_port_t           /* no mach_port_name_t found in include files. */
+mach_port_t			/* no mach_port_name_t found in include files. */
 map_inferior_port_name (inferior_name, type)
      mach_port_t inferior_name;
      mach_msg_type_name_t type;
 {
-  kern_return_t        ret;
+  kern_return_t ret;
   mach_msg_type_name_t acquired;
-  mach_port_t          iport;
-  
+  mach_port_t iport;
+
   ret = mach_port_extract_right (inferior_task,
 				 inferior_name,
 				 type,
 				 &iport,
 				 &acquired);
-  CHK("mach_port_extract_right (map_inferior_port_name)", ret);
+  CHK ("mach_port_extract_right (map_inferior_port_name)", ret);
 
   if (acquired != MACH_MSG_TYPE_PORT_SEND)
-    error("Incorrect right extracted, (map_inferior_port_name)");
+    error ("Incorrect right extracted, (map_inferior_port_name)");
 
   ret = mach_port_deallocate (mach_task_self (),
 			      iport);
@@ -2130,22 +2177,22 @@ get_thread_name (one_cproc, id)
     if (one_cproc->cthread == NULL)
       {
 	/* cproc not mapped to any cthread */
-	sprintf(buf, "_C%d", id);
+	sprintf (buf, "_C%d", id);
       }
-    else if (! one_cproc->cthread->name)
+    else if (!one_cproc->cthread->name)
       {
 	/* cproc and cthread, but no name */
-	sprintf(buf, "_t%d", id);
+	sprintf (buf, "_t%d", id);
       }
     else
-      return (char *)(one_cproc->cthread->name);
+      return (char *) (one_cproc->cthread->name);
   else
     {
       if (id < 0)
 	warning ("Inconsistency in thread name id %d", id);
 
       /* Kernel thread without cproc */
-      sprintf(buf, "_K%d", id);
+      sprintf (buf, "_K%d", id);
     }
 
   return buf;
@@ -2153,28 +2200,28 @@ get_thread_name (one_cproc, id)
 
 int
 fetch_thread_info (task, mthreads_out)
-     mach_port_t	task;
-     gdb_thread_t	*mthreads_out;	/* out */
+     mach_port_t task;
+     gdb_thread_t *mthreads_out;	/* out */
 {
-  kern_return_t  ret;
+  kern_return_t ret;
   thread_array_t th_table;
-  int		 th_count;
+  int th_count;
   gdb_thread_t mthreads = NULL;
-  int 		 index;
+  int index;
 
   ret = task_threads (task, &th_table, &th_count);
   if (ret != KERN_SUCCESS)
     {
       warning ("Error getting inferior's thread list:%s",
-	       mach_error_string(ret));
+	       mach_error_string (ret));
       m3_kill_inferior ();
       return -1;
     }
-  
+
   mthreads = (gdb_thread_t)
-    		obstack_alloc
-		  (cproc_obstack,
-		   th_count * sizeof (struct gdb_thread));
+    obstack_alloc
+    (cproc_obstack,
+     th_count * sizeof (struct gdb_thread));
 
   for (index = 0; index < th_count; index++)
     {
@@ -2182,20 +2229,20 @@ fetch_thread_info (task, mthreads_out)
       int mid;
 
       if (must_suspend_thread)
-	setup_thread (th_table[ index ], 1);
+	setup_thread (th_table[index], 1);
 
       if (th_table[index] != current_thread)
 	{
 	  saved_thread = current_thread;
-	  
-	  mid = switch_to_thread (th_table[ index ]);
+
+	  mid = switch_to_thread (th_table[index]);
 	}
 
-      mthreads[index].name  = th_table[index];
+      mthreads[index].name = th_table[index];
       mthreads[index].cproc = NULL;	/* map_cprocs_to_kernel_threads() */
       mthreads[index].in_emulator = FALSE;
       mthreads[index].slotid = index;
-      
+
       mthreads[index].sp = read_register (SP_REGNUM);
       mthreads[index].fp = read_register (FP_REGNUM);
       mthreads[index].pc = read_pc ();
@@ -2204,12 +2251,12 @@ fetch_thread_info (task, mthreads_out)
 	mid = switch_to_thread (saved_thread);
 
       if (must_suspend_thread)
-	setup_thread (th_table[ index ], 0);
+	setup_thread (th_table[index], 0);
     }
-  
+
   consume_send_rights (th_table, th_count);
-  ret = vm_deallocate (mach_task_self(), (vm_address_t)th_table, 
-		       (th_count * sizeof(mach_port_t)));
+  ret = vm_deallocate (mach_task_self (), (vm_address_t) th_table,
+		       (th_count * sizeof (mach_port_t)));
   if (ret != KERN_SUCCESS)
     {
       warning ("Error trying to deallocate thread list : %s",
@@ -2232,9 +2279,9 @@ fetch_usp_from_emulator_stack (sp)
 {
   CORE_ADDR stack_pointer;
 
-  sp = (sp & ~(EMULATOR_STACK_SIZE-1)) +
-    	EMULATOR_STACK_SIZE - sizeof (struct emul_stack_top);
-  
+  sp = (sp & ~(EMULATOR_STACK_SIZE - 1)) +
+    EMULATOR_STACK_SIZE - sizeof (struct emul_stack_top);
+
   if (mach3_read_inferior (sp,
 			   &stack_pointer,
 			   sizeof (CORE_ADDR)) != sizeof (CORE_ADDR))
@@ -2259,17 +2306,17 @@ boolean_t
 have_emulator_p (task)
      task_t task;
 {
-  kern_return_t	ret;
+  kern_return_t ret;
 #ifndef EMUL_VECTOR_COUNT
-  vm_offset_t	*emulation_vector;
-  int		n;
+  vm_offset_t *emulation_vector;
+  int n;
 #else
-  vm_offset_t	emulation_vector[ EMUL_VECTOR_COUNT ];
-  int		n = EMUL_VECTOR_COUNT;
+  vm_offset_t emulation_vector[EMUL_VECTOR_COUNT];
+  int n = EMUL_VECTOR_COUNT;
 #endif
-  int		i;
-  int		vector_start;
-  
+  int i;
+  int vector_start;
+
   ret = task_get_emulation_vector (task,
 				   &vector_start,
 #ifndef EMUL_VECTOR_COUNT
@@ -2278,13 +2325,13 @@ have_emulator_p (task)
 				   emulation_vector,
 #endif
 				   &n);
-  CHK("task_get_emulation_vector", ret);
+  CHK ("task_get_emulation_vector", ret);
   xx_debug ("%d vectors from %d at 0x%08x\n",
 	    n, vector_start, emulation_vector);
-  
-  for(i = 0; i < n; i++)
+
+  for (i = 0; i < n; i++)
     {
-      vm_offset_t entry = emulation_vector [i];
+      vm_offset_t entry = emulation_vector[i];
 
       if (EMULATOR_BASE <= entry && entry <= EMULATOR_END)
 	return TRUE;
@@ -2293,8 +2340,8 @@ have_emulator_p (task)
 	  static boolean_t informed = FALSE;
 	  if (!informed)
 	    {
-	      warning("Emulation vector address 0x08%x outside emulator space",
-		      entry);
+	      warning ("Emulation vector address 0x08%x outside emulator space",
+		       entry);
 	      informed = TRUE;
 	    }
 	}
@@ -2327,7 +2374,7 @@ map_cprocs_to_kernel_threads (cprocs, mthreads, thread_count)
 	  stack_base =
 	    extract_signed_integer (scan->raw_cproc + CPROC_BASE_OFFSET,
 				    CPROC_BASE_SIZE);
-	  stack_size = 
+	  stack_size =
 	    extract_signed_integer (scan->raw_cproc + CPROC_SIZE_OFFSET,
 				    CPROC_SIZE_SIZE);
 	  if ((mthreads + index)->sp > stack_base &&
@@ -2354,7 +2401,7 @@ map_cprocs_to_kernel_threads (cprocs, mthreads, thread_count)
    *  stack, and try to map that to the cprocs.
    *
    * Also set in_emulator for kernel threads.
-   */ 
+   */
 
   if (emulator_present)
     {
@@ -2363,28 +2410,28 @@ map_cprocs_to_kernel_threads (cprocs, mthreads, thread_count)
 	  CORE_ADDR emul_sp;
 	  CORE_ADDR usp;
 
-	  gdb_thread_t mthread = (mthreads+index);
+	  gdb_thread_t mthread = (mthreads + index);
 	  emul_sp = mthread->sp;
 
 	  if (mthread->cproc == NULL &&
 	      EMULATOR_BASE <= emul_sp && emul_sp <= EMULATOR_END)
 	    {
 	      mthread->in_emulator = emulator_present;
-	      
+
 	      if (!all_mapped && cprocs)
 		{
 		  usp = fetch_usp_from_emulator_stack (emul_sp);
-		  
+
 		  /* @@ Could be more accurate */
-		  if (! usp)
+		  if (!usp)
 		    error ("Zero stack pointer read from emulator?");
-		  
+
 		  /* Try to match this stack pointer to the cprocs that
 		   * don't yet have a kernel thread.
 		   */
 		  for (scan = cprocs; scan; scan = scan->next)
 		    {
-		      
+
 		      /* Check is this unmapped CPROC stack contains
 		       * the user stack pointer saved in the
 		       * emulator.
@@ -2393,12 +2440,12 @@ map_cprocs_to_kernel_threads (cprocs, mthreads, thread_count)
 			{
 			  stack_base =
 			    extract_signed_integer
-			      (scan->raw_cproc + CPROC_BASE_OFFSET,
-			       CPROC_BASE_SIZE);
-			  stack_size = 
+			    (scan->raw_cproc + CPROC_BASE_OFFSET,
+			     CPROC_BASE_SIZE);
+			  stack_size =
 			    extract_signed_integer
-			      (scan->raw_cproc + CPROC_SIZE_OFFSET,
-			       CPROC_SIZE_SIZE);
+			    (scan->raw_cproc + CPROC_SIZE_OFFSET,
+			     CPROC_SIZE_SIZE);
 			  if (usp > stack_base &&
 			      usp <= stack_base + stack_size)
 			    {
@@ -2417,7 +2464,7 @@ map_cprocs_to_kernel_threads (cprocs, mthreads, thread_count)
 /*
  * Format of the thread_list command
  *
- * 	             slot mid sel   name  emul ks susp  cstate wired   address
+ *                   slot mid sel   name  emul ks susp  cstate wired   address
  */
 #define TL_FORMAT "%-2.2s %5d%c %-10.10s %1.1s%s%-5.5s %-2.2s %-5.5s "
 
@@ -2428,14 +2475,14 @@ print_tl_address (stream, pc)
      GDB_FILE *stream;
      CORE_ADDR pc;
 {
-  if (! lookup_minimal_symbol_by_pc (pc))
-    fprintf_filtered (stream, local_hex_format(), pc);
+  if (!lookup_minimal_symbol_by_pc (pc))
+    fprintf_filtered (stream, local_hex_format (), pc);
   else
     {
       extern int addressprint;
       extern int asm_demangle;
 
-      int store    = addressprint;
+      int store = addressprint;
       addressprint = 0;
       print_address_symbolic (pc, stream, asm_demangle, "");
       addressprint = store;
@@ -2455,15 +2502,15 @@ lookup_address_of_variable (name)
   struct minimal_symbol *msymbol;
 
   sym = lookup_symbol (name,
-		       (struct block *)NULL,
+		       (struct block *) NULL,
 		       VAR_NAMESPACE,
-		       (int *)NULL,
-		       (struct symtab **)NULL);
+		       (int *) NULL,
+		       (struct symtab **) NULL);
 
   if (sym)
     symaddr = SYMBOL_VALUE (sym);
 
-  if (! symaddr)
+  if (!symaddr)
     {
       msymbol = lookup_minimal_symbol (name, NULL, NULL);
 
@@ -2475,7 +2522,7 @@ lookup_address_of_variable (name)
 }
 
 static gdb_thread_t
-get_cprocs()
+get_cprocs ()
 {
   gdb_thread_t cproc_head;
   gdb_thread_t cproc_copy;
@@ -2484,13 +2531,13 @@ get_cprocs()
   char *name;
   cthread_t cthread;
   CORE_ADDR symaddr;
-  
+
   symaddr = lookup_address_of_variable ("cproc_list");
 
-  if (! symaddr)
+  if (!symaddr)
     {
       /* cproc_list is not in a file compiled with debugging
-	 symbols, but don't give up yet */
+         symbols, but don't give up yet */
 
       symaddr = lookup_address_of_variable ("cprocs");
 
@@ -2508,7 +2555,7 @@ get_cprocs()
     }
 
   /* Stripped or no -lthreads loaded or "cproc_list" is in wrong segment. */
-  if (! symaddr)
+  if (!symaddr)
     return NULL;
 
   /* Get the address of the first cproc in the task */
@@ -2524,7 +2571,7 @@ get_cprocs()
 
   cproc_head = NULL;
 
-  while (their_cprocs != (CORE_ADDR)0)
+  while (their_cprocs != (CORE_ADDR) 0)
     {
       CORE_ADDR cproc_copy_incarnation;
       cproc_copy = (gdb_thread_t) obstack_alloc (cproc_obstack,
@@ -2533,7 +2580,7 @@ get_cprocs()
       if (!mach3_read_inferior (their_cprocs,
 				&cproc_copy->raw_cproc[0],
 				CPROC_SIZE))
-	error("Can't read next cproc at 0x%x.", their_cprocs);
+	error ("Can't read next cproc at 0x%x.", their_cprocs);
 
       their_cprocs =
 	extract_address (cproc_copy->raw_cproc + CPROC_LIST_OFFSET,
@@ -2542,19 +2589,19 @@ get_cprocs()
 	extract_address (cproc_copy->raw_cproc + CPROC_INCARNATION_OFFSET,
 			 CPROC_INCARNATION_SIZE);
 
-      if (cproc_copy_incarnation == (CORE_ADDR)0)
+      if (cproc_copy_incarnation == (CORE_ADDR) 0)
 	cproc_copy->cthread = NULL;
       else
 	{
 	  /* This CPROC has an attached CTHREAD. Get its name */
-	  cthread = (cthread_t)obstack_alloc (cproc_obstack,
-					      sizeof(struct cthread));
+	  cthread = (cthread_t) obstack_alloc (cproc_obstack,
+					       sizeof (struct cthread));
 
 	  if (!mach3_read_inferior (cproc_copy_incarnation,
 				    cthread,
-				    sizeof(struct cthread)))
-	    error("Can't read next thread at 0x%x.",
-		  cproc_copy_incarnation);
+				    sizeof (struct cthread)))
+	      error ("Can't read next thread at 0x%x.",
+		     cproc_copy_incarnation);
 
 	  cproc_copy->cthread = cthread;
 
@@ -2562,8 +2609,8 @@ get_cprocs()
 	    {
 	      name = (char *) obstack_alloc (cproc_obstack, MAX_NAME_LEN);
 
-	      if (!mach3_read_inferior(cthread->name, name, MAX_NAME_LEN))
-		error("Can't read next thread's name at 0x%x.", cthread->name);
+	      if (!mach3_read_inferior (cthread->name, name, MAX_NAME_LEN))
+		error ("Can't read next thread's name at 0x%x.", cthread->name);
 
 	      cthread->name = name;
 	    }
@@ -2594,7 +2641,7 @@ mach3_cproc_state (mthread)
 {
   int context;
 
-  if (! mthread || !mthread->cproc)
+  if (!mthread || !mthread->cproc)
     return -1;
 
   context = extract_signed_integer
@@ -2624,83 +2671,83 @@ mach3_cproc_state (mthread)
   return 0;
 }
 #endif /* FETCH_CPROC_STATE */
-
 
+
 void
-thread_list_command()
+thread_list_command ()
 {
   thread_basic_info_data_t ths;
-  int     thread_count;
+  int thread_count;
   gdb_thread_t cprocs;
   gdb_thread_t scan;
-  int     index;
-  char   *name;
-  char    selected;
-  char   *wired;
-  int     infoCnt;
+  int index;
+  char *name;
+  char selected;
+  char *wired;
+  int infoCnt;
   kern_return_t ret;
-  mach_port_t   mid_or_port;
-  gdb_thread_t  their_threads;
-  gdb_thread_t  kthread;
+  mach_port_t mid_or_port;
+  gdb_thread_t their_threads;
+  gdb_thread_t kthread;
 
   int neworder = 1;
 
   char *fmt = "There are %d kernel threads in task %d.\n";
-  
+
   int tmid = map_port_name_to_mid (inferior_task, MACH_TYPE_TASK);
-  
+
   MACH_ERROR_NO_INFERIOR;
-  
+
   thread_count = fetch_thread_info (inferior_task,
 				    &their_threads);
   if (thread_count == -1)
     return;
-  
+
   if (thread_count == 1)
     fmt = "There is %d kernel thread in task %d.\n";
-  
+
   printf_filtered (fmt, thread_count, tmid);
-  
+
   puts_filtered (TL_HEADER);
-  
-  cprocs = get_cprocs();
-  
+
+  cprocs = get_cprocs ();
+
   map_cprocs_to_kernel_threads (cprocs, their_threads, thread_count);
-  
+
   for (scan = cprocs; scan; scan = scan->next)
     {
       int mid;
       char buf[10];
       char slot[3];
       int cproc_state =
-	extract_signed_integer
-	  (scan->raw_cproc + CPROC_STATE_OFFSET, CPROC_STATE_SIZE);
-      
+      extract_signed_integer
+      (scan->raw_cproc + CPROC_STATE_OFFSET, CPROC_STATE_SIZE);
+
       selected = ' ';
-      
+
       /* a wired cproc? */
       wired = (extract_address (scan->raw_cproc + CPROC_WIRED_OFFSET,
 				CPROC_WIRED_SIZE)
 	       ? "wired" : "");
 
       if (scan->reverse_map != -1)
-	kthread  = (their_threads + scan->reverse_map);
+	kthread = (their_threads + scan->reverse_map);
       else
-	kthread  = NULL;
+	kthread = NULL;
 
       if (kthread)
 	{
 	  /* These cprocs have a kernel thread */
-	  
+
 	  mid = map_port_name_to_mid (kthread->name, MACH_TYPE_THREAD);
-	  
+
 	  infoCnt = THREAD_BASIC_INFO_COUNT;
-	  
+
 	  ret = thread_info (kthread->name,
 			     THREAD_BASIC_INFO,
-			     (thread_info_t)&ths,
+			     (thread_info_t) & ths,
 			     &infoCnt);
-	  
+
 	  if (ret != KERN_SUCCESS)
 	    {
 	      warning ("Unable to get basic info on thread %d : %s",
@@ -2710,11 +2757,11 @@ thread_list_command()
 	    }
 
 	  /* Who is the first to have more than 100 threads */
-	  sprintf (slot, "%d", kthread->slotid%100);
+	  sprintf (slot, "%d", kthread->slotid % 100);
 
 	  if (kthread->name == current_thread)
 	    selected = '*';
-	  
+
 	  if (ths.suspend_count)
 	    sprintf (buf, "%d", ths.suspend_count);
 	  else
@@ -2752,7 +2799,7 @@ thread_list_command()
 #if 0
 	  /* jtv -> emcmanus: why do you want this here? */
 	  if (scan->incarnation == NULL)
-	    continue; /* EMcM */
+	    continue;		/* EMcM */
 #endif
 
 	  printf_filtered (TL_FORMAT,
@@ -2776,28 +2823,28 @@ thread_list_command()
 	}
       puts_filtered ("\n");
     }
-  
+
   /* Scan for kernel threads without cprocs */
   for (index = 0; index < thread_count; index++)
     {
-      if (! their_threads[index].cproc)
+      if (!their_threads[index].cproc)
 	{
 	  int mid;
-	  
+
 	  char buf[10];
 	  char slot[3];
 
 	  mach_port_t name = their_threads[index].name;
-	  
+
 	  mid = map_port_name_to_mid (name, MACH_TYPE_THREAD);
-	  
+
 	  infoCnt = THREAD_BASIC_INFO_COUNT;
-	  
-	  ret = thread_info(name,
-			    THREAD_BASIC_INFO,
-			    (thread_info_t)&ths,
-			    &infoCnt);
-	    
+
+	  ret = thread_info (name,
+			     THREAD_BASIC_INFO,
+			     (thread_info_t) & ths,
+			     &infoCnt);
+
 	  if (ret != KERN_SUCCESS)
 	    {
 	      warning ("Unable to get basic info on thread %d : %s",
@@ -2806,7 +2853,7 @@ thread_list_command()
 	      continue;
 	    }
 
-	  sprintf (slot, "%d", index%100);
+	  sprintf (slot, "%d", index % 100);
 
 	  if (name == current_thread)
 	    selected = '*';
@@ -2834,19 +2881,19 @@ thread_list_command()
 			   their_threads[index].in_emulator ? "E" : "",
 			   translate_state (ths.run_state),
 			   buf,
-			   "",   /* No cproc state */
+			   "",	/* No cproc state */
 			   "");	/* Can't be wired */
 	  print_tl_address (gdb_stdout, their_threads[index].pc);
 	  puts_filtered ("\n");
 	}
     }
-  
+
   obstack_free (cproc_obstack, 0);
   obstack_init (cproc_obstack);
 }
 
 void
-thread_select_command(args, from_tty)
+thread_select_command (args, from_tty)
      char *args;
      int from_tty;
 {
@@ -2870,31 +2917,31 @@ thread_select_command(args, from_tty)
       args++;
     }
 
-  mid = atoi(args);
+  mid = atoi (args);
 
   if (mid == 0)
-    if (!is_slot || *args != '0') /* Rudimentary checks */
+    if (!is_slot || *args != '0')	/* Rudimentary checks */
       error ("You must select threads by MID or @SLOTNUMBER");
 
-  if (select_thread (inferior_task, mid, is_slot?2:1) != KERN_SUCCESS)
+  if (select_thread (inferior_task, mid, is_slot ? 2 : 1) != KERN_SUCCESS)
     return;
 
   if (from_tty)
     printf_filtered ("Thread %d selected\n",
 		     is_slot ? map_port_name_to_mid (current_thread,
-						     MACH_TYPE_THREAD) : mid);
+						   MACH_TYPE_THREAD) : mid);
 }
 
 thread_trace (thread, set)
-mach_port_t thread;
-boolean_t   set;
+     mach_port_t thread;
+     boolean_t set;
 {
-  int			flavor   = TRACE_FLAVOR;
-  unsigned int		stateCnt = TRACE_FLAVOR_SIZE;
-  kern_return_t		ret;
-  thread_state_data_t	state;
+  int flavor = TRACE_FLAVOR;
+  unsigned int stateCnt = TRACE_FLAVOR_SIZE;
+  kern_return_t ret;
+  thread_state_data_t state;
 
-  if (! MACH_PORT_VALID (thread))
+  if (!MACH_PORT_VALID (thread))
     {
       warning ("thread_trace: invalid thread");
       return;
@@ -2903,16 +2950,16 @@ boolean_t   set;
   if (must_suspend_thread)
     setup_thread (thread, 1);
 
-  ret = thread_get_state(thread, flavor, state, &stateCnt);
+  ret = thread_get_state (thread, flavor, state, &stateCnt);
   CHK ("thread_trace: error reading thread state", ret);
-  
+
   if (set)
     {
       TRACE_SET (thread, state);
     }
   else
     {
-      if (! TRACE_CLEAR (thread, state))
+      if (!TRACE_CLEAR (thread, state))
 	{
 	  if (must_suspend_thread)
 	    setup_thread (thread, 0);
@@ -2920,11 +2967,11 @@ boolean_t   set;
 	}
     }
 
-  ret = thread_set_state(thread, flavor, state, stateCnt);
+  ret = thread_set_state (thread, flavor, state, stateCnt);
   CHK ("thread_trace: error writing thread state", ret);
   if (must_suspend_thread)
     setup_thread (thread, 0);
-}  
+}
 
 #ifdef	FLUSH_INFERIOR_CACHE
 
@@ -2933,12 +2980,12 @@ boolean_t   set;
    This definitely includes breakpoints, for instance, or else we
    end up looping in mysterious Bpt traps */
 
-flush_inferior_icache(pc, amount)
+flush_inferior_icache (pc, amount)
      CORE_ADDR pc;
 {
   vm_machine_attribute_val_t flush = MATTR_VAL_ICACHE_FLUSH;
-  kern_return_t   ret;
-  
+  kern_return_t ret;
+
   ret = vm_machine_attribute (inferior_task,
 			      pc,
 			      amount,
@@ -2948,20 +2995,20 @@ flush_inferior_icache(pc, amount)
     warning ("Error flushing inferior's cache : %s",
 	     mach_error_string (ret));
 }
-#endif	FLUSH_INFERIOR_CACHE
-
+#endif /* FLUSH_INFERIOR_CACHE */
 
+
 static
 suspend_all_threads (from_tty)
      int from_tty;
 {
-  kern_return_t	   ret;
-  thread_array_t   thread_list;
-  int		   thread_count, index;
-  int		   infoCnt;
+  kern_return_t ret;
+  thread_array_t thread_list;
+  int thread_count, index;
+  int infoCnt;
   thread_basic_info_data_t th_info;
 
-  
+
   ret = task_threads (inferior_task, &thread_list, &thread_count);
   if (ret != KERN_SUCCESS)
     {
@@ -2969,15 +3016,15 @@ suspend_all_threads (from_tty)
       m3_kill_inferior ();
       return_to_top_level (RETURN_ERROR);
     }
-  
+
   for (index = 0; index < thread_count; index++)
     {
       int mid;
 
-      mid = map_port_name_to_mid (thread_list[ index ],
+      mid = map_port_name_to_mid (thread_list[index],
 				  MACH_TYPE_THREAD);
-	  
-      ret = thread_suspend(thread_list[ index ]);
+
+      ret = thread_suspend (thread_list[index]);
 
       if (ret != KERN_SUCCESS)
 	warning ("Error trying to suspend thread %d : %s",
@@ -2986,21 +3033,21 @@ suspend_all_threads (from_tty)
       if (from_tty)
 	{
 	  infoCnt = THREAD_BASIC_INFO_COUNT;
-	  ret = thread_info (thread_list[ index ],
+	  ret = thread_info (thread_list[index],
 			     THREAD_BASIC_INFO,
-			     (thread_info_t) &th_info,
+			     (thread_info_t) & th_info,
 			     &infoCnt);
 	  CHK ("suspend can't get thread info", ret);
-	  
+
 	  warning ("Thread %d suspend count is %d",
 		   mid, th_info.suspend_count);
 	}
     }
 
   consume_send_rights (thread_list, thread_count);
-  ret = vm_deallocate(mach_task_self(),
-		      (vm_address_t)thread_list, 
-		      (thread_count * sizeof(int)));
+  ret = vm_deallocate (mach_task_self (),
+		       (vm_address_t) thread_list,
+		       (thread_count * sizeof (int)));
   CHK ("Error trying to deallocate thread list", ret);
 }
 
@@ -3010,17 +3057,18 @@ thread_suspend_command (args, from_tty)
      int from_tty;
 {
   kern_return_t ret;
-  int           mid;
-  mach_port_t   saved_thread;
-  int           infoCnt;
+  int mid;
+  mach_port_t saved_thread;
+  int infoCnt;
   thread_basic_info_data_t th_info;
-  
+
   MACH_ERROR_NO_INFERIOR;
 
-  if (!strcasecmp (args, "all")) {
-    suspend_all_threads (from_tty);
-    return;
-  }
+  if (!strcasecmp (args, "all"))
+    {
+      suspend_all_threads (from_tty);
+      return;
+    }
 
   saved_thread = current_thread;
 
@@ -3031,13 +3079,12 @@ thread_suspend_command (args, from_tty)
 
   if (mid == 0)
     mid = map_port_name_to_mid (current_thread, MACH_TYPE_THREAD);
-  else
-    if (select_thread (inferior_task, mid, 0) != KERN_SUCCESS)
-      {
-	if (current_thread)
-	  current_thread = saved_thread;
-	error ("Could not select thread %d", mid);
-      }
+  else if (select_thread (inferior_task, mid, 0) != KERN_SUCCESS)
+    {
+      if (current_thread)
+	current_thread = saved_thread;
+      error ("Could not select thread %d", mid);
+    }
 
   ret = thread_suspend (current_thread);
   if (ret != KERN_SUCCESS)
@@ -3047,66 +3094,66 @@ thread_suspend_command (args, from_tty)
   infoCnt = THREAD_BASIC_INFO_COUNT;
   ret = thread_info (current_thread,
 		     THREAD_BASIC_INFO,
-		     (thread_info_t) &th_info,
+		     (thread_info_t) & th_info,
 		     &infoCnt);
   CHK ("suspend can't get thread info", ret);
-  
+
   warning ("Thread %d suspend count is %d", mid, th_info.suspend_count);
-  
+
   current_thread = saved_thread;
 }
 
 resume_all_threads (from_tty)
      int from_tty;
 {
-    kern_return_t  ret;
-    thread_array_t thread_list;
-    int		   thread_count, index;
-    int            mid;
-    int		   infoCnt;
-    thread_basic_info_data_t th_info;
+  kern_return_t ret;
+  thread_array_t thread_list;
+  int thread_count, index;
+  int mid;
+  int infoCnt;
+  thread_basic_info_data_t th_info;
 
-    ret = task_threads (inferior_task, &thread_list, &thread_count);
-    if (ret != KERN_SUCCESS)
-      {
-	m3_kill_inferior ();
-	error("task_threads", mach_error_string( ret));
-      }
+  ret = task_threads (inferior_task, &thread_list, &thread_count);
+  if (ret != KERN_SUCCESS)
+    {
+      m3_kill_inferior ();
+      error ("task_threads", mach_error_string (ret));
+    }
 
-    for (index = 0; index < thread_count; index++)
-      {
-	infoCnt = THREAD_BASIC_INFO_COUNT;
-	ret = thread_info (thread_list [ index ],
-			   THREAD_BASIC_INFO,
-			   (thread_info_t) &th_info,
-			   &infoCnt);
-	CHK ("resume_all can't get thread info", ret);
-	
-	mid = map_port_name_to_mid (thread_list[ index ],
-				    MACH_TYPE_THREAD);
-	
-	if (! th_info.suspend_count)
-	  {
-	    if (mid != -1 && from_tty)
-	      warning ("Thread %d is not suspended", mid);
-	    continue;
-	  }
+  for (index = 0; index < thread_count; index++)
+    {
+      infoCnt = THREAD_BASIC_INFO_COUNT;
+      ret = thread_info (thread_list[index],
+			 THREAD_BASIC_INFO,
+			 (thread_info_t) & th_info,
+			 &infoCnt);
+      CHK ("resume_all can't get thread info", ret);
 
-	ret = thread_resume (thread_list[ index ]);
+      mid = map_port_name_to_mid (thread_list[index],
+				  MACH_TYPE_THREAD);
 
-	if (ret != KERN_SUCCESS)
-	  warning ("Error trying to resume thread %d : %s",
-		   mid, mach_error_string (ret));
-	else if (mid != -1 && from_tty)
-	  warning ("Thread %d suspend count is %d",
-		   mid, --th_info.suspend_count);
-      }
+      if (!th_info.suspend_count)
+	{
+	  if (mid != -1 && from_tty)
+	    warning ("Thread %d is not suspended", mid);
+	  continue;
+	}
 
-    consume_send_rights (thread_list, thread_count);
-    ret = vm_deallocate(mach_task_self(),
-			(vm_address_t)thread_list, 
-			(thread_count * sizeof(int)));
-    CHK("Error trying to deallocate thread list", ret);
+      ret = thread_resume (thread_list[index]);
+
+      if (ret != KERN_SUCCESS)
+	warning ("Error trying to resume thread %d : %s",
+		 mid, mach_error_string (ret));
+      else if (mid != -1 && from_tty)
+	warning ("Thread %d suspend count is %d",
+		 mid, --th_info.suspend_count);
+    }
+
+  consume_send_rights (thread_list, thread_count);
+  ret = vm_deallocate (mach_task_self (),
+		       (vm_address_t) thread_list,
+		       (thread_count * sizeof (int)));
+  CHK ("Error trying to deallocate thread list", ret);
 }
 
 void
@@ -3119,13 +3166,14 @@ thread_resume_command (args, from_tty)
   kern_return_t ret;
   thread_basic_info_data_t th_info;
   int infoCnt = THREAD_BASIC_INFO_COUNT;
-  
+
   MACH_ERROR_NO_INFERIOR;
 
-  if (!strcasecmp (args, "all")) {
-    resume_all_threads (from_tty);
-    return;
-  }
+  if (!strcasecmp (args, "all"))
+    {
+      resume_all_threads (from_tty);
+      return;
+    }
 
   saved_thread = current_thread;
 
@@ -3136,21 +3184,20 @@ thread_resume_command (args, from_tty)
 
   if (mid == 0)
     mid = map_port_name_to_mid (current_thread, MACH_TYPE_THREAD);
-  else
-    if (select_thread (inferior_task, mid, 0) != KERN_SUCCESS)
-      {
-	if (current_thread)
-	  current_thread = saved_thread;
-	return_to_top_level (RETURN_ERROR);
-      }
+  else if (select_thread (inferior_task, mid, 0) != KERN_SUCCESS)
+    {
+      if (current_thread)
+	current_thread = saved_thread;
+      return_to_top_level (RETURN_ERROR);
+    }
 
   ret = thread_info (current_thread,
 		     THREAD_BASIC_INFO,
-		     (thread_info_t) &th_info,
+		     (thread_info_t) & th_info,
 		     &infoCnt);
   CHK ("resume can't get thread info", ret);
-  
-  if (! th_info.suspend_count)
+
+  if (!th_info.suspend_count)
     {
       warning ("Thread %d is not suspended", mid);
       goto out;
@@ -3165,8 +3212,8 @@ thread_resume_command (args, from_tty)
       th_info.suspend_count--;
       warning ("Thread %d suspend count is %d", mid, th_info.suspend_count);
     }
-      
- out:
+
+out:
   current_thread = saved_thread;
 }
 
@@ -3179,10 +3226,10 @@ thread_kill_command (args, from_tty)
   kern_return_t ret;
   int thread_count;
   thread_array_t thread_table;
-  int   index;
+  int index;
   mach_port_t thread_to_kill = MACH_PORT_NULL;
-  
-  
+
+
   MACH_ERROR_NO_INFERIOR;
 
   if (!args)
@@ -3200,11 +3247,11 @@ thread_kill_command (args, from_tty)
     }
   else
     mid = map_port_name_to_mid (current_thread, MACH_TYPE_THREAD);
-      
+
   /* Don't allow gdb to kill *any* thread in the system. Use mkill program for that */
   ret = task_threads (inferior_task, &thread_table, &thread_count);
   CHK ("Error getting inferior's thread list", ret);
-  
+
   if (thread_to_kill == current_thread)
     {
       ret = thread_terminate (thread_to_kill);
@@ -3215,7 +3262,7 @@ thread_kill_command (args, from_tty)
     }
   else
     for (index = 0; index < thread_count; index++)
-      if (thread_table [ index ] == thread_to_kill)
+      if (thread_table[index] == thread_to_kill)
 	{
 	  ret = thread_terminate (thread_to_kill);
 	  CHK ("Thread could not be terminated", ret);
@@ -3223,15 +3270,15 @@ thread_kill_command (args, from_tty)
 
   if (thread_count > 1)
     consume_send_rights (thread_table, thread_count);
-  
-  ret = vm_deallocate (mach_task_self(), (vm_address_t)thread_table, 
-		       (thread_count * sizeof(mach_port_t)));
+
+  ret = vm_deallocate (mach_task_self (), (vm_address_t) thread_table,
+		       (thread_count * sizeof (mach_port_t)));
   CHK ("Error trying to deallocate thread list", ret);
-  
+
   warning ("Thread %d killed", mid);
 }
-
 
+
 /* Task specific commands; add more if you like */
 
 void
@@ -3243,7 +3290,7 @@ task_resume_command (args, from_tty)
   task_basic_info_data_t ta_info;
   int infoCnt = TASK_BASIC_INFO_COUNT;
   int mid = map_port_name_to_mid (inferior_task, MACH_TYPE_TASK);
-  
+
   MACH_ERROR_NO_INFERIOR;
 
   /* Would be trivial to change, but is it desirable? */
@@ -3252,15 +3299,15 @@ task_resume_command (args, from_tty)
 
   ret = task_info (inferior_task,
 		   TASK_BASIC_INFO,
-		   (task_info_t) &ta_info,
+		   (task_info_t) & ta_info,
 		   &infoCnt);
   CHK ("task_resume_command: task_info failed", ret);
-  
+
   if (ta_info.suspend_count == 0)
     error ("Inferior task %d is not suspended", mid);
   else if (ta_info.suspend_count == 1 &&
 	   from_tty &&
-	   !query ("Suspend count is now 1. Do you know what you are doing? "))
+	!query ("Suspend count is now 1. Do you know what you are doing? "))
     error ("Task not resumed");
 
   ret = task_resume (inferior_task);
@@ -3271,12 +3318,12 @@ task_resume_command (args, from_tty)
       warning ("Inferior task %d is no longer suspended", mid);
       must_suspend_thread = 1;
       /* @@ This is not complete: Registers change all the time when not
-	 suspended! */
+         suspended! */
       registers_changed ();
     }
   else
     warning ("Inferior task %d suspend count is now %d",
-	     mid, ta_info.suspend_count-1);
+	     mid, ta_info.suspend_count - 1);
 }
 
 
@@ -3289,7 +3336,7 @@ task_suspend_command (args, from_tty)
   task_basic_info_data_t ta_info;
   int infoCnt = TASK_BASIC_INFO_COUNT;
   int mid = map_port_name_to_mid (inferior_task, MACH_TYPE_TASK);
-  
+
   MACH_ERROR_NO_INFERIOR;
 
   /* Would be trivial to change, but is it desirable? */
@@ -3303,10 +3350,10 @@ task_suspend_command (args, from_tty)
 
   ret = task_info (inferior_task,
 		   TASK_BASIC_INFO,
-		   (task_info_t) &ta_info,
+		   (task_info_t) & ta_info,
 		   &infoCnt);
   CHK ("task_suspend_command: task_info failed", ret);
-  
+
   warning ("Inferior task %d suspend count is now %d",
 	   mid, ta_info.suspend_count);
 }
@@ -3315,11 +3362,11 @@ static char *
 get_size (bytes)
      int bytes;
 {
-  static char size [ 30 ];
-  int zz = bytes/1024;
+  static char size[30];
+  int zz = bytes / 1024;
 
   if (zz / 1024)
-    sprintf (size, "%-2.1f M", ((float)bytes)/(1024.0*1024.0));
+    sprintf (size, "%-2.1f M", ((float) bytes) / (1024.0 * 1024.0));
   else
     sprintf (size, "%d K", zz);
 
@@ -3337,9 +3384,9 @@ task_info_command (args, from_tty)
   kern_return_t ret;
   task_basic_info_data_t ta_info;
   int infoCnt = TASK_BASIC_INFO_COUNT;
-  int page_size = round_page(1);
+  int page_size = round_page (1);
   int thread_count = 0;
-  
+
   if (MACH_PORT_VALID (inferior_task))
     mid = map_port_name_to_mid (inferior_task,
 				MACH_TYPE_TASK);
@@ -3366,7 +3413,7 @@ task_info_command (args, from_tty)
 
   ret = task_info (task,
 		   TASK_BASIC_INFO,
-		   (task_info_t) &ta_info,
+		   (task_info_t) & ta_info,
 		   &infoCnt);
   CHK ("task_info_command: task_info failed", ret);
 
@@ -3378,17 +3425,17 @@ task_info_command (args, from_tty)
 
   {
     thread_array_t thread_list;
-    
+
     ret = task_threads (task, &thread_list, &thread_count);
     CHK ("task_info_command: task_threads", ret);
-    
+
     printf_filtered (" Thread count  : %d\n", thread_count);
 
     consume_send_rights (thread_list, thread_count);
-    ret = vm_deallocate(mach_task_self(),
-			(vm_address_t)thread_list, 
-			(thread_count * sizeof(int)));
-    CHK("Error trying to deallocate thread list", ret);
+    ret = vm_deallocate (mach_task_self (),
+			 (vm_address_t) thread_list,
+			 (thread_count * sizeof (int)));
+    CHK ("Error trying to deallocate thread list", ret);
   }
   if (have_emulator_p (task))
     printf_filtered (" Emulator at   : 0x%x..0x%x\n",
@@ -3418,8 +3465,9 @@ exception_command (args, from_tty)
   if (!args)
     error_no_arg ("exception number action");
 
-  while (*scan == ' ' || *scan == '\t') scan++;
-  
+  while (*scan == ' ' || *scan == '\t')
+    scan++;
+
   if ('0' <= *scan && *scan <= '9')
     while ('0' <= *scan && *scan <= '9')
       scan++;
@@ -3434,7 +3482,8 @@ exception_command (args, from_tty)
   if (*scan != ' ' && *scan != '\t')
     error ("exception number must be followed by a space");
   else
-    while (*scan == ' ' || *scan == '\t') scan++;
+    while (*scan == ' ' || *scan == '\t')
+      scan++;
 
   args = scan;
   len = 0;
@@ -3445,12 +3494,12 @@ exception_command (args, from_tty)
     }
 
   if (!len)
-    error("exception number action");
+    error ("exception number action");
 
   if (!strncasecmp (args, "forward", len))
-    exception_map[ exception ].forward = TRUE;
+    exception_map[exception].forward = TRUE;
   else if (!strncasecmp (args, "keep", len))
-    exception_map[ exception ].forward = FALSE;
+    exception_map[exception].forward = FALSE;
   else
     error ("exception action is either \"keep\" or \"forward\"");
 }
@@ -3459,17 +3508,17 @@ static void
 print_exception_info (exception)
      int exception;
 {
-  boolean_t forward = exception_map[ exception ].forward;
+  boolean_t forward = exception_map[exception].forward;
 
-  printf_filtered ("%s\t(%d): ", exception_map[ exception ].name,
+  printf_filtered ("%s\t(%d): ", exception_map[exception].name,
 		   exception);
   if (!forward)
-    if (exception_map[ exception ].sigmap != SIG_UNKNOWN)
+    if (exception_map[exception].sigmap != SIG_UNKNOWN)
       printf_filtered ("keep and handle as signal %d\n",
-		       exception_map[ exception ].sigmap);
+		       exception_map[exception].sigmap);
     else
       printf_filtered ("keep and handle as unknown signal %d\n",
-		       exception_map[ exception ].sigmap);
+		       exception_map[exception].sigmap);
   else
     printf_filtered ("forward exception to inferior\n");
 }
@@ -3504,7 +3553,7 @@ mach3_exception_actions (w, force_print_only, who)
 {
   boolean_t force_print = FALSE;
 
-  
+
   if (force_print_only ||
       exception_map[stop_exception].sigmap == SIG_UNKNOWN)
     force_print = TRUE;
@@ -3514,42 +3563,43 @@ mach3_exception_actions (w, force_print_only, who)
   if (exception_map[stop_exception].print || force_print)
     {
       target_terminal_ours ();
-      
+
       printf_filtered ("\n%s received %s exception : ",
 		       who,
 		       exception_map[stop_exception].name);
-      
+
       wrap_here ("   ");
 
-      switch(stop_exception) {
-      case EXC_BAD_ACCESS:
-	printf_filtered ("referencing address 0x%x : %s\n",
-			 stop_subcode,
-			 mach_error_string (stop_code));
-	break;
-      case EXC_BAD_INSTRUCTION:
-	printf_filtered
-	  ("illegal or undefined instruction. code %d subcode %d\n",
-	   stop_code, stop_subcode);
-	break;
-      case EXC_ARITHMETIC:
-	printf_filtered ("code %d\n", stop_code);
-	break;
-      case EXC_EMULATION:
-	printf_filtered ("code %d subcode %d\n", stop_code, stop_subcode);
-	break;
-      case EXC_SOFTWARE:
-	printf_filtered ("%s specific, code 0x%x\n",
-			 stop_code < 0xffff ? "hardware" : "os emulation",
-			 stop_code);
-	break;
-      case EXC_BREAKPOINT:
-	printf_filtered ("type %d (machine dependent)\n",
-			 stop_code);
-	break;
-      default:
-	fatal ("Unknown exception");
-      }
+      switch (stop_exception)
+	{
+	case EXC_BAD_ACCESS:
+	  printf_filtered ("referencing address 0x%x : %s\n",
+			   stop_subcode,
+			   mach_error_string (stop_code));
+	  break;
+	case EXC_BAD_INSTRUCTION:
+	  printf_filtered
+	    ("illegal or undefined instruction. code %d subcode %d\n",
+	     stop_code, stop_subcode);
+	  break;
+	case EXC_ARITHMETIC:
+	  printf_filtered ("code %d\n", stop_code);
+	  break;
+	case EXC_EMULATION:
+	  printf_filtered ("code %d subcode %d\n", stop_code, stop_subcode);
+	  break;
+	case EXC_SOFTWARE:
+	  printf_filtered ("%s specific, code 0x%x\n",
+			   stop_code < 0xffff ? "hardware" : "os emulation",
+			   stop_code);
+	  break;
+	case EXC_BREAKPOINT:
+	  printf_filtered ("type %d (machine dependent)\n",
+			   stop_code);
+	  break;
+	default:
+	  fatal ("Unknown exception");
+	}
     }
 }
 
@@ -3565,22 +3615,22 @@ setup_notify_port (create_new)
     }
 
   our_notify_port = MACH_PORT_NULL;
-  notify_chain    = (port_chain_t) NULL;
+  notify_chain = (port_chain_t) NULL;
   port_chain_destroy (port_chain_obstack);
 
   if (create_new)
     {
-      ret = mach_port_allocate (mach_task_self(),
+      ret = mach_port_allocate (mach_task_self (),
 				MACH_PORT_RIGHT_RECEIVE,
 				&our_notify_port);
       if (ret != KERN_SUCCESS)
-	fatal("Creating notify port %s", mach_error_string(ret));
-      
-      ret = mach_port_move_member(mach_task_self(), 
-				  our_notify_port,
-				  inferior_wait_port_set);
+	fatal ("Creating notify port %s", mach_error_string (ret));
+
+      ret = mach_port_move_member (mach_task_self (),
+				   our_notify_port,
+				   inferior_wait_port_set);
       if (ret != KERN_SUCCESS)
-	fatal("initial move member %s",mach_error_string(ret));
+	fatal ("initial move member %s", mach_error_string (ret));
     }
 }
 
@@ -3596,7 +3646,7 @@ setup_notify_port (create_new)
  * Then, there should be a way to change it.
  */
 
-char registered_name[ MAX_NAME_LEN ];
+char registered_name[MAX_NAME_LEN];
 
 void
 message_port_info (args, from_tty)
@@ -3619,13 +3669,13 @@ gdb_register_port (name, port)
   static int already_signed = 0;
   int len;
 
-  if (! MACH_PORT_VALID (port) || !name || !*name)
+  if (!MACH_PORT_VALID (port) || !name || !*name)
     {
       warning ("Invalid registration request");
       return;
     }
 
-  if (! already_signed)
+  if (!already_signed)
     {
       ret = mach_port_insert_right (mach_task_self (),
 				    our_message_port,
@@ -3645,25 +3695,25 @@ gdb_register_port (name, port)
     }
 
   ret = netname_check_in (name_server_port,	/* Name server port */
-			  name,			/* Name of service */
+			  name,	/* Name of service */
 			  our_message_port,	/* Signature */
-			  port); 		/* Creates a new send right */
-  CHK("Failed to check in the port", ret);
-  
+			  port);	/* Creates a new send right */
+  CHK ("Failed to check in the port", ret);
+
   len = 0;
-  while(len < MAX_NAME_LEN && *(name+len))
+  while (len < MAX_NAME_LEN && *(name + len))
     {
-      registered_name[len] = *(name+len);
+      registered_name[len] = *(name + len);
       len++;
     }
   registered_name[len] = '\000';
   already_signed = 2;
-}  
+}
 
 struct cmd_list_element *cmd_thread_list;
 struct cmd_list_element *cmd_task_list;
 
-/*ARGSUSED*/
+/*ARGSUSED */
 static void
 thread_command (arg, from_tty)
      char *arg;
@@ -3673,7 +3723,7 @@ thread_command (arg, from_tty)
   help_list (cmd_thread_list, "thread ", -1, gdb_stdout);
 }
 
-/*ARGSUSED*/
+/*ARGSUSED */
 static void
 task_command (arg, from_tty)
      char *arg;
@@ -3690,15 +3740,15 @@ add_mach_specific_commands ()
   /* FIXME: Move our thread support into the generic thread.c stuff so we
      can share that code.  */
   add_prefix_cmd ("mthread", class_stack, thread_command,
-      "Generic command for handling Mach threads in the debugged task.",
-      &cmd_thread_list, "thread ", 0, &cmdlist);
+	  "Generic command for handling Mach threads in the debugged task.",
+		  &cmd_thread_list, "thread ", 0, &cmdlist);
 
   add_com_alias ("th", "mthread", class_stack, 1);
 
-  add_cmd ("select", class_stack, thread_select_command, 
+  add_cmd ("select", class_stack, thread_select_command,
 	   "Select and print MID of the selected thread",
 	   &cmd_thread_list);
-  add_cmd ("list",   class_stack, thread_list_command,
+  add_cmd ("list", class_stack, thread_list_command,
 	   "List info of task's threads. Selected thread is marked with '*'",
 	   &cmd_thread_list);
   add_cmd ("suspend", class_run, thread_suspend_command,
@@ -3721,13 +3771,13 @@ add_mach_specific_commands ()
 #endif
   /* Thread command shorthands (for backward compatibility) */
   add_alias_cmd ("ts", "mthread select", 0, 0, &cmdlist);
-  add_alias_cmd ("tl", "mthread list",   0, 0, &cmdlist);
+  add_alias_cmd ("tl", "mthread list", 0, 0, &cmdlist);
 
   /* task handling commands */
 
   add_prefix_cmd ("task", class_stack, task_command,
-      "Generic command for handling debugged task.",
-      &cmd_task_list, "task ", 0, &cmdlist);
+		  "Generic command for handling debugged task.",
+		  &cmd_task_list, "task ", 0, &cmdlist);
 
   add_com_alias ("ta", "task", class_stack, 1);
 
@@ -3776,49 +3826,50 @@ do_mach_notify_dead_name (notify, name)
   /* Take name of from unreceived dead name notification list */
   notify_chain = port_chain_delete (notify_chain, name);
 
-  if (! element)
+  if (!element)
     error ("Received a dead name notify from unchained port (0x%x)", name);
-  
-  switch (element->type) {
 
-  case MACH_TYPE_THREAD:
-    target_terminal_ours_for_output ();
-    if (name == current_thread)
-      {
-	printf_filtered ("\nCurrent thread %d died", element->mid);
-	current_thread = MACH_PORT_NULL;
-      }
-    else
-      printf_filtered ("\nThread %d died", element->mid);
+  switch (element->type)
+    {
 
-    break;
+    case MACH_TYPE_THREAD:
+      target_terminal_ours_for_output ();
+      if (name == current_thread)
+	{
+	  printf_filtered ("\nCurrent thread %d died", element->mid);
+	  current_thread = MACH_PORT_NULL;
+	}
+      else
+	printf_filtered ("\nThread %d died", element->mid);
 
-  case MACH_TYPE_TASK:
-    target_terminal_ours_for_output ();
-    if (name != inferior_task)
-      printf_filtered ("Task %d died, but it was not the selected task",
-	       element->mid);
-    else	       
-      {
-	printf_filtered ("Current task %d died", element->mid);
-	
-	mach_port_destroy (mach_task_self(), name);
-	inferior_task = MACH_PORT_NULL;
-	
-	if (notify_chain)
-	  warning ("There were still unreceived dead_name_notifications???");
-	
-	/* Destroy the old notifications */
-	setup_notify_port (0);
+      break;
 
-      }
-    break;
+    case MACH_TYPE_TASK:
+      target_terminal_ours_for_output ();
+      if (name != inferior_task)
+	printf_filtered ("Task %d died, but it was not the selected task",
+			 element->mid);
+      else
+	{
+	  printf_filtered ("Current task %d died", element->mid);
 
-  default:
-    error ("Unregistered dead_name 0x%x notification received. Type is %d, mid is 0x%x",
-	   name, element->type, element->mid);
-    break;
-  }
+	  mach_port_destroy (mach_task_self (), name);
+	  inferior_task = MACH_PORT_NULL;
+
+	  if (notify_chain)
+	    warning ("There were still unreceived dead_name_notifications???");
+
+	  /* Destroy the old notifications */
+	  setup_notify_port (0);
+
+	}
+      break;
+
+    default:
+      error ("Unregistered dead_name 0x%x notification received. Type is %d, mid is 0x%x",
+	     name, element->type, element->mid);
+      break;
+    }
 
   return KERN_SUCCESS;
 }
@@ -3893,7 +3944,7 @@ kill_inferior_fast ()
   /* It's propably terminate already */
   (void) task_terminate (inferior_task);
 
-  inferior_task  = MACH_PORT_NULL;
+  inferior_task = MACH_PORT_NULL;
   current_thread = MACH_PORT_NULL;
 
   wait3 (&w, WNOHANG, 0);
@@ -3916,8 +3967,8 @@ m3_mourn_inferior ()
   unpush_target (&m3_ops);
   generic_mourn_inferior ();
 }
-
 
+
 /* Fork an inferior process, and start debugging it.  */
 
 static void
@@ -3929,7 +3980,7 @@ m3_create_inferior (exec_file, allargs, env)
   fork_inferior (exec_file, allargs, env, m3_trace_me, m3_trace_him, NULL, NULL);
   /* We are at the first instruction we care about.  */
   /* Pedal to the metal... */
-  proceed ((CORE_ADDR) -1, 0, 0);
+  proceed ((CORE_ADDR) - 1, 0, 0);
 }
 
 /* Mark our target-struct as eligible for stray "run" and "attach"
@@ -3943,8 +3994,8 @@ m3_can_run ()
 /* Mach 3.0 does not need ptrace for anything
  * Make sure nobody uses it on mach.
  */
-ptrace (a,b,c,d)
-int a,b,c,d;
+ptrace (a, b, c, d)
+     int a, b, c, d;
 {
   error ("Lose, Lose! Somebody called ptrace\n");
 }
@@ -3959,34 +4010,34 @@ m3_resume (pid, step, signal)
      int step;
      enum target_signal signal;
 {
-  kern_return_t	ret;
+  kern_return_t ret;
 
   if (step)
     {
       thread_basic_info_data_t th_info;
-      unsigned int	       infoCnt = THREAD_BASIC_INFO_COUNT;
-      
+      unsigned int infoCnt = THREAD_BASIC_INFO_COUNT;
+
       /* There is no point in single stepping when current_thread
        * is dead.
        */
-      if (! MACH_PORT_VALID (current_thread))
+      if (!MACH_PORT_VALID (current_thread))
 	error ("No thread selected; can not single step");
-      
+
       /* If current_thread is suspended, tracing it would never return.
        */
       ret = thread_info (current_thread,
 			 THREAD_BASIC_INFO,
-			 (thread_info_t) &th_info,
+			 (thread_info_t) & th_info,
 			 &infoCnt);
       CHK ("child_resume: can't get thread info", ret);
-      
+
       if (th_info.suspend_count)
 	error ("Can't trace a suspended thread. Use \"thread resume\" command to resume it");
     }
 
   vm_read_cache_valid = FALSE;
 
-  if (signal && inferior_pid > 0) /* Do not signal, if attached by MID */
+  if (signal && inferior_pid > 0)	/* Do not signal, if attached by MID */
     kill (inferior_pid, target_signal_to_host (signal));
 
   if (step)
@@ -3994,20 +4045,20 @@ m3_resume (pid, step, signal)
       suspend_all_threads (0);
 
       setup_single_step (current_thread, TRUE);
-      
+
       ret = thread_resume (current_thread);
       CHK ("thread_resume", ret);
     }
-  
+
   ret = task_resume (inferior_task);
   if (ret == KERN_FAILURE)
     warning ("Task was not suspended");
   else
     CHK ("Resuming task", ret);
-  
+
   /* HACK HACK This is needed by the multiserver system HACK HACK */
-  while ((ret = task_resume(inferior_task)) == KERN_SUCCESS)
-    /* make sure it really runs */;
+  while ((ret = task_resume (inferior_task)) == KERN_SUCCESS)
+    /* make sure it really runs */ ;
   /* HACK HACK This is needed by the multiserver system HACK HACK */
 }
 
@@ -4016,13 +4067,13 @@ m3_resume (pid, step, signal)
 /* Start debugging the process with the given task */
 void
 task_attach (tid)
-  task_t tid;
+     task_t tid;
 {
   kern_return_t ret;
   inferior_task = tid;
 
   ret = task_suspend (inferior_task);
-  CHK("task_attach: task_suspend", ret);
+  CHK ("task_attach: task_suspend", ret);
 
   must_suspend_thread = 0;
 
@@ -4031,7 +4082,7 @@ task_attach (tid)
   request_notify (inferior_task, MACH_NOTIFY_DEAD_NAME, MACH_TYPE_TASK);
 
   setup_exception_port ();
-  
+
   emulator_present = have_emulator_p (inferior_task);
 
   attach_flag = 1;
@@ -4053,16 +4104,16 @@ attach_to_thread ()
 }
 
 mid_attach (mid)
-    int	mid;
+     int mid;
 {
-    kern_return_t ret;
+  kern_return_t ret;
 
-    ret = machid_mach_port (mid_server, mid_auth, mid, &inferior_task);
-    CHK("mid_attach: machid_mach_port", ret);
+  ret = machid_mach_port (mid_server, mid_auth, mid, &inferior_task);
+  CHK ("mid_attach: machid_mach_port", ret);
 
-    task_attach (inferior_task);
+  task_attach (inferior_task);
 
-    return mid;
+  return mid;
 }
 
 /* 
@@ -4080,10 +4131,10 @@ m3_do_attach (pid)
   kern_return_t ret;
 
   if (pid == 0)
-    error("MID=0, Debugging the master unix server does not compute");
+    error ("MID=0, Debugging the master unix server does not compute");
 
   /* Foo. This assumes gdb has a unix pid */
-  if (pid == getpid())
+  if (pid == getpid ())
     error ("I will debug myself only by mid. (Gdb would suspend itself!)");
 
   if (pid < 0)
@@ -4097,8 +4148,8 @@ m3_do_attach (pid)
     }
 
   inferior_task = task_by_pid (pid);
-  if (! MACH_PORT_VALID (inferior_task))
-    error("Cannot map Unix pid %d to Mach task port", pid);
+  if (!MACH_PORT_VALID (inferior_task))
+    error ("Cannot map Unix pid %d to Mach task port", pid);
 
   task_attach (inferior_task);
 
@@ -4123,7 +4174,7 @@ m3_attach (args, from_tty)
 
   pid = atoi (args);
 
-  if (pid == getpid())		/* Trying to masturbate? */
+  if (pid == getpid ())		/* Trying to masturbate? */
     error ("I refuse to debug myself!");
 
   if (from_tty)
@@ -4146,9 +4197,9 @@ m3_attach (args, from_tty)
 void
 deallocate_inferior_ports ()
 {
-  kern_return_t  ret;
+  kern_return_t ret;
   thread_array_t thread_list;
-  int		 thread_count, index;
+  int thread_count, index;
 
   if (!MACH_PORT_VALID (inferior_task))
     return;
@@ -4157,7 +4208,7 @@ deallocate_inferior_ports ()
   if (ret != KERN_SUCCESS)
     {
       warning ("deallocate_inferior_ports: task_threads",
-	       mach_error_string(ret));
+	       mach_error_string (ret));
       return;
     }
 
@@ -4169,7 +4220,7 @@ deallocate_inferior_ports ()
 				thread_list[index],
 				MACH_PORT_RIGHT_SEND,
 				&rights);
-      CHK("deallocate_inferior_ports: get refs", ret);
+      CHK ("deallocate_inferior_ports: get refs", ret);
 
       if (rights > 0)
 	{
@@ -4177,7 +4228,7 @@ deallocate_inferior_ports ()
 				    thread_list[index],
 				    MACH_PORT_RIGHT_SEND,
 				    -rights);
-	  CHK("deallocate_inferior_ports: mod refs", ret);
+	  CHK ("deallocate_inferior_ports: mod refs", ret);
 	}
     }
 
@@ -4192,7 +4243,7 @@ deallocate_inferior_ports ()
   CHK ("deallocate_task_port: deallocating inferior_task", ret);
 
   current_thread = MACH_PORT_NULL;
-  inferior_task  = MACH_PORT_NULL;
+  inferior_task = MACH_PORT_NULL;
 }
 
 /* Stop debugging the process whose number is PID
@@ -4218,7 +4269,7 @@ m3_do_detach (signal)
     }
 
   ret = task_set_special_port (inferior_task,
-			       TASK_EXCEPTION_PORT, 
+			       TASK_EXCEPTION_PORT,
 			       inferior_old_exception_port);
   CHK ("task_set_special_port", ret);
 
@@ -4227,15 +4278,15 @@ m3_do_detach (signal)
 
   if (remove_breakpoints ())
     warning ("Could not remove breakpoints when detaching");
-  
+
   if (signal && inferior_pid > 0)
     kill (inferior_pid, signal);
-  
+
   /* the task might be dead by now */
   (void) task_resume (inferior_task);
-  
+
   deallocate_inferior_ports ();
-  
+
   attach_flag = 0;
 }
 
@@ -4260,15 +4311,15 @@ m3_detach (args, from_tty)
       if (exec_file == 0)
 	exec_file = "";
       printf_unfiltered ("Detaching from program: %s %s\n",
-	      exec_file, target_pid_to_str (inferior_pid));
+			 exec_file, target_pid_to_str (inferior_pid));
       gdb_flush (gdb_stdout);
     }
   if (args)
     siggnal = atoi (args);
-  
+
   m3_do_detach (siggnal);
   inferior_pid = 0;
-  unpush_target (&m3_ops);		/* Pop out of handling an inferior */
+  unpush_target (&m3_ops);	/* Pop out of handling an inferior */
 }
 #endif /* ATTACH_DETACH */
 
@@ -4294,7 +4345,7 @@ m3_files_info (ignore)
 {
   /* FIXME: should print MID and all that crap.  */
   printf_unfiltered ("\tUsing the running image of %s %s.\n",
-		       attach_flag? "attached": "child", target_pid_to_str (inferior_pid));
+      attach_flag ? "attached" : "child", target_pid_to_str (inferior_pid));
 }
 
 static void
@@ -4312,7 +4363,8 @@ m3_open (arg, from_tty)
 #define STR(x) "x"
 #endif
 
-char	*bsd1_names[] = {
+char *bsd1_names[] =
+{
   "execve",
   "fork",
   "take_signal",
@@ -4380,146 +4432,159 @@ char	*bsd1_names[] = {
   "pid_by_task",
 };
 
-int	bsd1_nnames = sizeof(bsd1_names)/sizeof(bsd1_names[0]);
+int bsd1_nnames = sizeof (bsd1_names) / sizeof (bsd1_names[0]);
 
-char*
-name_str(name,buf)
+char *
+name_str (name, buf)
 
-int	name;
-char	*buf;
+     int name;
+     char *buf;
 
 {
-  switch (name) {
-  case MACH_MSG_TYPE_BOOLEAN:
-    return "boolean";
-  case MACH_MSG_TYPE_INTEGER_16:
-    return "short";
-  case MACH_MSG_TYPE_INTEGER_32:
-    return "long";
-  case MACH_MSG_TYPE_CHAR:
-    return "char";
-  case MACH_MSG_TYPE_BYTE:
-    return "byte";
-  case MACH_MSG_TYPE_REAL:
-    return "real";
-  case MACH_MSG_TYPE_STRING:
-    return "string";
-  default:
-    sprintf(buf,"%d",name);
-    return buf;
-  }
+  switch (name)
+    {
+    case MACH_MSG_TYPE_BOOLEAN:
+      return "boolean";
+    case MACH_MSG_TYPE_INTEGER_16:
+      return "short";
+    case MACH_MSG_TYPE_INTEGER_32:
+      return "long";
+    case MACH_MSG_TYPE_CHAR:
+      return "char";
+    case MACH_MSG_TYPE_BYTE:
+      return "byte";
+    case MACH_MSG_TYPE_REAL:
+      return "real";
+    case MACH_MSG_TYPE_STRING:
+      return "string";
+    default:
+      sprintf (buf, "%d", name);
+      return buf;
+    }
 }
 
 char *
-id_str(id,buf)
+id_str (id, buf)
 
-int	id;
-char	*buf;
+     int id;
+     char *buf;
 
 {
-  char	*p;
-  if (id >= 101000 && id < 101000+bsd1_nnames) {
-    if (p = bsd1_names[id-101000])
-      return p;
-  }
+  char *p;
+  if (id >= 101000 && id < 101000 + bsd1_nnames)
+    {
+      if (p = bsd1_names[id - 101000])
+	return p;
+    }
   if (id == 102000)
     return "psignal_retry";
   if (id == 100000)
     return "syscall";
-  sprintf(buf,"%d",id);
+  sprintf (buf, "%d", id);
   return buf;
 }
 
-print_msg(mp)
-mach_msg_header_t	*mp;
+print_msg (mp)
+     mach_msg_header_t *mp;
 {
-  char	*fmt_x = "%20s : 0x%08x\n";
-  char	*fmt_d = "%20s : %10d\n";
-  char	*fmt_s = "%20s : %s\n";
-  char	buf[100];
+  char *fmt_x = "%20s : 0x%08x\n";
+  char *fmt_d = "%20s : %10d\n";
+  char *fmt_s = "%20s : %s\n";
+  char buf[100];
 
   puts_filtered ("\n");
 #define pr(fmt,h,x) printf_filtered(fmt,STR(x),(h).x)
-  pr(fmt_x,(*mp),msgh_bits);
-  pr(fmt_d,(*mp),msgh_size);
-  pr(fmt_x,(*mp),msgh_remote_port);
-  pr(fmt_x,(*mp),msgh_local_port);
-  pr(fmt_d,(*mp),msgh_kind);
-  printf_filtered(fmt_s,STR(msgh_id),id_str(mp->msgh_id,buf));
-  
+  pr (fmt_x, (*mp), msgh_bits);
+  pr (fmt_d, (*mp), msgh_size);
+  pr (fmt_x, (*mp), msgh_remote_port);
+  pr (fmt_x, (*mp), msgh_local_port);
+  pr (fmt_d, (*mp), msgh_kind);
+  printf_filtered (fmt_s, STR (msgh_id), id_str (mp->msgh_id, buf));
+
   if (debug_level > 1)
-  {
-    char	*p,*ep,*dp;
-    int		plen;
-    p = (char*)mp;
-    ep = p+mp->msgh_size;
-    p += sizeof(*mp);
-    for(; p < ep; p += plen) {
-      mach_msg_type_t	*tp;
-      mach_msg_type_long_t	*tlp;
-      int	name,size,number;
-      tp = (mach_msg_type_t*)p;
-      if (tp->msgt_longform) {
-	tlp = (mach_msg_type_long_t*)tp;
-	name = tlp->msgtl_name;
-	size = tlp->msgtl_size;
-	number = tlp->msgtl_number;
-	plen = sizeof(*tlp);
-      } else {
-	name = tp->msgt_name;
-	size = tp->msgt_size;
-	number = tp->msgt_number;
-	plen = sizeof(*tp);
-      }
-      printf_filtered("name=%-16s size=%2d number=%7d inline=%d long=%d deal=%d\n",
-		      name_str(name,buf),size,number,tp->msgt_inline,
-		      tp->msgt_longform, tp->msgt_deallocate);
-      dp = p+plen;
-      if (tp->msgt_inline) {
-	int	l;
-	l = size*number/8;
-	l = (l+sizeof(long)-1)&~((sizeof(long))-1);
-	plen += l;
-	print_data(dp,size,number);
-      } else {
-	plen += sizeof(int*);
-      }
-      printf_filtered("plen=%d\n",plen);
+    {
+      char *p, *ep, *dp;
+      int plen;
+      p = (char *) mp;
+      ep = p + mp->msgh_size;
+      p += sizeof (*mp);
+      for (; p < ep; p += plen)
+	{
+	  mach_msg_type_t *tp;
+	  mach_msg_type_long_t *tlp;
+	  int name, size, number;
+	  tp = (mach_msg_type_t *) p;
+	  if (tp->msgt_longform)
+	    {
+	      tlp = (mach_msg_type_long_t *) tp;
+	      name = tlp->msgtl_name;
+	      size = tlp->msgtl_size;
+	      number = tlp->msgtl_number;
+	      plen = sizeof (*tlp);
+	    }
+	  else
+	    {
+	      name = tp->msgt_name;
+	      size = tp->msgt_size;
+	      number = tp->msgt_number;
+	      plen = sizeof (*tp);
+	    }
+	  printf_filtered ("name=%-16s size=%2d number=%7d inline=%d long=%d deal=%d\n",
+			name_str (name, buf), size, number, tp->msgt_inline,
+			   tp->msgt_longform, tp->msgt_deallocate);
+	  dp = p + plen;
+	  if (tp->msgt_inline)
+	    {
+	      int l;
+	      l = size * number / 8;
+	      l = (l + sizeof (long) - 1) & ~((sizeof (long)) - 1);
+	      plen += l;
+	      print_data (dp, size, number);
+	    }
+	  else
+	    {
+	      plen += sizeof (int *);
+	    }
+	  printf_filtered ("plen=%d\n", plen);
+	}
     }
-  }
 }
 
-print_data(p,size,number)
+print_data (p, size, number)
 
-char	*p;
+     char *p;
 
 {
-  int	*ip;
-  short	*sp;
-  int	i;
-
-  switch (size) {
-  case 8:
-    for(i = 0; i < number; i++) {
-      printf_filtered(" %02x",p[i]);
-    }
-    break;
-  case 16:
-    sp = (short*)p;
-    for(i = 0; i < number; i++) {
-      printf_filtered(" %04x",sp[i]);
-    }
-    break;
-  case 32:
-    ip = (int*)p;
-    for(i = 0; i < number; i++) {
-      printf_filtered(" %08x",ip[i]);
+  int *ip;
+  short *sp;
+  int i;
+
+  switch (size)
+    {
+    case 8:
+      for (i = 0; i < number; i++)
+	{
+	  printf_filtered (" %02x", p[i]);
+	}
+      break;
+    case 16:
+      sp = (short *) p;
+      for (i = 0; i < number; i++)
+	{
+	  printf_filtered (" %04x", sp[i]);
+	}
+      break;
+    case 32:
+      ip = (int *) p;
+      for (i = 0; i < number; i++)
+	{
+	  printf_filtered (" %08x", ip[i]);
+	}
+      break;
     }
-    break;
-  }
-  puts_filtered("\n");
+  puts_filtered ("\n");
 }
-#endif  DUMP_SYSCALL
+#endif /* DUMP_SYSCALL */
 
 static void
 m3_stop ()
@@ -4529,10 +4594,10 @@ m3_stop ()
 
 static char *
 m3_pid_to_exec_file (pid)
-int  pid;
+     int pid;
 {
   error ("to_pid_to_exec_file target function not implemented");
-  return NULL;  /* To keep all compilers happy. */
+  return NULL;			/* To keep all compilers happy. */
 }
 
 static void
@@ -4581,36 +4646,36 @@ _initialize_m3_nat ()
   init_m3_ops ();
   add_target (&m3_ops);
 
-  ret = mach_port_allocate(mach_task_self(), 
-			   MACH_PORT_RIGHT_PORT_SET,
-			   &inferior_wait_port_set);
+  ret = mach_port_allocate (mach_task_self (),
+			    MACH_PORT_RIGHT_PORT_SET,
+			    &inferior_wait_port_set);
   if (ret != KERN_SUCCESS)
-    fatal("initial port set %s",mach_error_string(ret));
+    fatal ("initial port set %s", mach_error_string (ret));
 
   /* mach_really_wait now waits for this */
   currently_waiting_for = inferior_wait_port_set;
 
-  ret = netname_look_up(name_server_port, hostname, "MachID", &mid_server);
+  ret = netname_look_up (name_server_port, hostname, "MachID", &mid_server);
   if (ret != KERN_SUCCESS)
     {
       mid_server = MACH_PORT_NULL;
-      
+
       warning ("initialize machid: netname_lookup_up(MachID) : %s",
-	       mach_error_string(ret));
+	       mach_error_string (ret));
       warning ("Some (most?) features disabled...");
     }
-  
-  mid_auth = mach_privileged_host_port();
+
+  mid_auth = mach_privileged_host_port ();
   if (mid_auth == MACH_PORT_NULL)
-    mid_auth = mach_task_self();
-  
+    mid_auth = mach_task_self ();
+
   obstack_init (port_chain_obstack);
 
-  ret = mach_port_allocate (mach_task_self (), 
+  ret = mach_port_allocate (mach_task_self (),
 			    MACH_PORT_RIGHT_RECEIVE,
 			    &thread_exception_port);
   CHK ("Creating thread_exception_port for single stepping", ret);
-  
+
   ret = mach_port_insert_right (mach_task_self (),
 				thread_exception_port,
 				thread_exception_port,
@@ -4625,10 +4690,10 @@ _initialize_m3_nat ()
     warning ("Creating message port %s", mach_error_string (ret));
   else
     {
-      char buf[ MAX_NAME_LEN ];
-      ret = mach_port_move_member(mach_task_self (),
-				  our_message_port,
-				  inferior_wait_port_set);
+      char buf[MAX_NAME_LEN];
+      ret = mach_port_move_member (mach_task_self (),
+				   our_message_port,
+				   inferior_wait_port_set);
       if (ret != KERN_SUCCESS)
 	warning ("message move member %s", mach_error_string (ret));
 
@@ -4638,7 +4703,7 @@ _initialize_m3_nat ()
       sprintf (buf, "gdb-%d", getpid ());
       gdb_register_port (buf, our_message_port);
     }
-  
+
   /* Heap for thread commands */
   obstack_init (cproc_obstack);