2003-03-28 Jeff Johnston <jjohnstn@redhat.com>

        * thread.c: Reindented.
        * lin-lwp.c: Ditto.
        * linux-proc.c: Ditto.

4 files changed, 239 insertions, 267 deletions

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 0c13c5f..325a889 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,9 @@
+2003-03-28  Jeff Johnston  <jjohnstn@redhat.com>
+
+	* thread.c: Reindented.
+	* lin-lwp.c: Ditto.
+	* linux-proc.c: Ditto.
+
 2003-03-28  Bob Rossi  <bob_rossi@cox.net>
 
         * MAINTAINERS (write after approval): Add myself.
diff --git a/gdb/lin-lwp.c b/gdb/lin-lwp.c
index 9f9dd81..c36394e 100644
--- a/gdb/lin-lwp.c
+++ b/gdb/lin-lwp.c
@@ -172,8 +172,7 @@ status_to_str (int status)
     snprintf (buf, sizeof (buf), "%s (terminated)",
 	      strsignal (WSTOPSIG (status)));
   else
-    snprintf (buf, sizeof (buf), "%d (exited)",
-	      WEXITSTATUS (status));
+    snprintf (buf, sizeof (buf), "%d (exited)", WEXITSTATUS (status));
 
   return buf;
 }
@@ -306,8 +305,8 @@ iterate_over_lwps (int (*callback) (struct lwp_info *, void *), void *data)
 int
 lin_lwp_prepare_to_proceed (void)
 {
-  if (! ptid_equal (trap_ptid, null_ptid)
-      && ! ptid_equal (inferior_ptid, trap_ptid))
+  if (!ptid_equal (trap_ptid, null_ptid)
+      && !ptid_equal (inferior_ptid, trap_ptid))
     {
       /* Switched over from TRAP_PID.  */
       CORE_ADDR stop_pc = read_pc ();
@@ -319,7 +318,7 @@ lin_lwp_prepare_to_proceed (void)
       if (trap_pc != stop_pc && breakpoint_here_p (trap_pc))
 	{
 	  /* User hasn't deleted the breakpoint.  Return non-zero, and
-             switch back to TRAP_PID.  */
+	     switch back to TRAP_PID.  */
 	  inferior_ptid = trap_ptid;
 
 	  /* FIXME: Is this stuff really necessary?  */
@@ -355,7 +354,7 @@ lin_lwp_attach_lwp (ptid_t ptid, int verbose)
 
   /* Make sure SIGCHLD is blocked.  We don't want SIGCHLD events
      to interrupt either the ptrace() or waitpid() calls below.  */
-  if (! sigismember (&blocked_mask, SIGCHLD))
+  if (!sigismember (&blocked_mask, SIGCHLD))
     {
       sigaddset (&blocked_mask, SIGCHLD);
       sigprocmask (SIG_BLOCK, &blocked_mask, NULL);
@@ -380,8 +379,8 @@ lin_lwp_attach_lwp (ptid_t ptid, int verbose)
 	       safe_strerror (errno));
 
       if (debug_lin_lwp)
-	fprintf_unfiltered (gdb_stdlog, 
-			    "LLAL: PTRACE_ATTACH %s, 0, 0 (OK)\n", 
+	fprintf_unfiltered (gdb_stdlog,
+			    "LLAL: PTRACE_ATTACH %s, 0, 0 (OK)\n",
 			    target_pid_to_str (ptid));
 
       pid = waitpid (GET_LWP (ptid), &status, 0);
@@ -401,18 +400,18 @@ lin_lwp_attach_lwp (ptid_t ptid, int verbose)
 	{
 	  fprintf_unfiltered (gdb_stdlog,
 			      "LLAL: waitpid %s received %s\n",
-			      target_pid_to_str (ptid), 
+			      target_pid_to_str (ptid),
 			      status_to_str (status));
 	}
     }
   else
     {
       /* We assume that the LWP representing the original process
-	 is already stopped.  Mark it as stopped in the data structure
-	 that the lin-lwp layer uses to keep track of threads.  Note
-	 that this won't have already been done since the main thread
-	 will have, we assume, been stopped by an attach from a
-	 different layer.  */
+         is already stopped.  Mark it as stopped in the data structure
+         that the lin-lwp layer uses to keep track of threads.  Note
+         that this won't have already been done since the main thread
+         will have, we assume, been stopped by an attach from a
+         different layer.  */
       lp->stopped = 1;
     }
 }
@@ -455,8 +454,7 @@ lin_lwp_attach (char *args, int from_tty)
   if (debug_lin_lwp)
     {
       fprintf_unfiltered (gdb_stdlog,
-			  "LLA: waitpid %ld, faking SIGSTOP\n", 
-			  (long) pid);
+			  "LLA: waitpid %ld, faking SIGSTOP\n", (long) pid);
     }
 }
 
@@ -467,7 +465,7 @@ detach_callback (struct lwp_info *lp, void *data)
 
   if (debug_lin_lwp && lp->status)
     fprintf_unfiltered (gdb_stdlog, "DC:  Pending %s for %s on detach.\n",
-			strsignal (WSTOPSIG (lp->status)), 
+			strsignal (WSTOPSIG (lp->status)),
 			target_pid_to_str (lp->ptid));
 
   while (lp->signalled && lp->stopped)
@@ -479,10 +477,10 @@ detach_callback (struct lwp_info *lp, void *data)
 	       safe_strerror (errno));
 
       if (debug_lin_lwp)
-	fprintf_unfiltered (gdb_stdlog, 
+	fprintf_unfiltered (gdb_stdlog,
 			    "DC:  PTRACE_CONTINUE (%s, 0, %s) (OK)\n",
 			    target_pid_to_str (lp->ptid),
-			    status_to_str (lp->status)); 
+			    status_to_str (lp->status));
 
       lp->stopped = 0;
       lp->signalled = 0;
@@ -505,7 +503,7 @@ detach_callback (struct lwp_info *lp, void *data)
       if (debug_lin_lwp)
 	fprintf_unfiltered (gdb_stdlog,
 			    "PTRACE_DETACH (%s, %s, 0) (OK)\n",
-			    target_pid_to_str (lp->ptid), 
+			    target_pid_to_str (lp->ptid),
 			    strsignal (WSTOPSIG (lp->status)));
 
       delete_lwp (lp->ptid);
@@ -547,7 +545,7 @@ resume_callback (struct lwp_info *lp, void *data)
 
       child_resume (pid_to_ptid (GET_LWP (lp->ptid)), 0, TARGET_SIGNAL_0);
       if (debug_lin_lwp)
-	fprintf_unfiltered (gdb_stdlog, 
+	fprintf_unfiltered (gdb_stdlog,
 			    "RC:  PTRACE_CONT %s, 0, 0 (resume sibling)\n",
 			    target_pid_to_str (lp->ptid));
       lp->stopped = 0;
@@ -606,13 +604,13 @@ lin_lwp_resume (ptid_t ptid, int step, enum target_signal signo)
       if (lp->status)
 	{
 	  /* FIXME: What should we do if we are supposed to continue
-             this thread with a signal?  */
+	     this thread with a signal?  */
 	  gdb_assert (signo == TARGET_SIGNAL_0);
 	  return;
 	}
 
       /* Mark LWP as not stopped to prevent it from being continued by
-	 resume_callback.  */
+         resume_callback.  */
       lp->stopped = 0;
     }
 
@@ -634,7 +632,7 @@ lin_lwp_resume (ptid_t ptid, int step, enum target_signal signo)
 static int
 stop_callback (struct lwp_info *lp, void *data)
 {
-  if (! lp->stopped && ! lp->signalled)
+  if (!lp->stopped && !lp->signalled)
     {
       int ret;
 
@@ -662,7 +660,7 @@ stop_wait_callback (struct lwp_info *lp, void *data)
 {
   sigset_t *flush_mask = data;
 
-  if (! lp->stopped && lp->signalled)
+  if (!lp->stopped && lp->signalled)
     {
       pid_t pid;
       int status;
@@ -681,7 +679,7 @@ stop_wait_callback (struct lwp_info *lp, void *data)
 	{
 	  fprintf_unfiltered (gdb_stdlog,
 			      "SWC: waitpid %s received %s\n",
-			      target_pid_to_str (lp->ptid), 
+			      target_pid_to_str (lp->ptid),
 			      status_to_str (status));
 	}
 
@@ -692,14 +690,14 @@ stop_wait_callback (struct lwp_info *lp, void *data)
 	  if (in_thread_list (lp->ptid))
 	    {
 	      /* Core GDB cannot deal with us deleting the current
-		 thread.  */
+	         thread.  */
 	      if (!ptid_equal (lp->ptid, inferior_ptid))
 		delete_thread (lp->ptid);
 	      printf_unfiltered ("[%s exited]\n",
 				 target_pid_to_str (lp->ptid));
 	    }
 	  if (debug_lin_lwp)
-	    fprintf_unfiltered (gdb_stdlog, "SWC: %s exited.\n", 
+	    fprintf_unfiltered (gdb_stdlog, "SWC: %s exited.\n",
 				target_pid_to_str (lp->ptid));
 
 	  delete_lwp (lp->ptid);
@@ -727,29 +725,29 @@ stop_wait_callback (struct lwp_info *lp, void *data)
 	  if (WSTOPSIG (status) == SIGTRAP)
 	    {
 	      /* If a LWP other than the LWP that we're reporting an
-                 event for has hit a GDB breakpoint (as opposed to
-                 some random trap signal), then just arrange for it to
-                 hit it again later.  We don't keep the SIGTRAP status
-                 and don't forward the SIGTRAP signal to the LWP.  We
-                 will handle the current event, eventually we will
-                 resume all LWPs, and this one will get its breakpoint
-                 trap again.
-
-		 If we do not do this, then we run the risk that the
-		 user will delete or disable the breakpoint, but the
-		 thread will have already tripped on it.  */
+	         event for has hit a GDB breakpoint (as opposed to
+	         some random trap signal), then just arrange for it to
+	         hit it again later.  We don't keep the SIGTRAP status
+	         and don't forward the SIGTRAP signal to the LWP.  We
+	         will handle the current event, eventually we will
+	         resume all LWPs, and this one will get its breakpoint
+	         trap again.
+
+	         If we do not do this, then we run the risk that the
+	         user will delete or disable the breakpoint, but the
+	         thread will have already tripped on it.  */
 
 	      /* Now resume this LWP and get the SIGSTOP event. */
 	      errno = 0;
 	      ptrace (PTRACE_CONT, GET_LWP (lp->ptid), 0, 0);
 	      if (debug_lin_lwp)
 		{
-		  fprintf_unfiltered (gdb_stdlog, 
+		  fprintf_unfiltered (gdb_stdlog,
 				      "PTRACE_CONT %s, 0, 0 (%s)\n",
 				      target_pid_to_str (lp->ptid),
 				      errno ? safe_strerror (errno) : "OK");
 
-		  fprintf_unfiltered (gdb_stdlog, 
+		  fprintf_unfiltered (gdb_stdlog,
 				      "SWC: Candidate SIGTRAP event in %s\n",
 				      target_pid_to_str (lp->ptid));
 		}
@@ -767,39 +765,39 @@ stop_wait_callback (struct lwp_info *lp, void *data)
 	  else
 	    {
 	      /* The thread was stopped with a signal other than
-		 SIGSTOP, and didn't accidentally trip a breakpoint. */
+	         SIGSTOP, and didn't accidentally trip a breakpoint. */
 
 	      if (debug_lin_lwp)
 		{
-		  fprintf_unfiltered (gdb_stdlog, 
+		  fprintf_unfiltered (gdb_stdlog,
 				      "SWC: Pending event %s in %s\n",
-				      status_to_str ((int) status), 
+				      status_to_str ((int) status),
 				      target_pid_to_str (lp->ptid));
 		}
 	      /* Now resume this LWP and get the SIGSTOP event. */
 	      errno = 0;
 	      ptrace (PTRACE_CONT, GET_LWP (lp->ptid), 0, 0);
 	      if (debug_lin_lwp)
-		fprintf_unfiltered (gdb_stdlog, 
+		fprintf_unfiltered (gdb_stdlog,
 				    "SWC: PTRACE_CONT %s, 0, 0 (%s)\n",
 				    target_pid_to_str (lp->ptid),
 				    errno ? safe_strerror (errno) : "OK");
 
 	      /* Hold this event/waitstatus while we check to see if
-		 there are any more (we still want to get that SIGSTOP). */
+	         there are any more (we still want to get that SIGSTOP). */
 	      stop_wait_callback (lp, data);
 	      /* If the lp->status field is still empty, use it to hold
-		 this event.  If not, then this event must be returned
-		 to the event queue of the LWP.  */
+	         this event.  If not, then this event must be returned
+	         to the event queue of the LWP.  */
 	      if (lp->status == 0)
 		lp->status = status;
 	      else
 		{
 		  if (debug_lin_lwp)
 		    {
-		      fprintf_unfiltered (gdb_stdlog, 
+		      fprintf_unfiltered (gdb_stdlog,
 					  "SWC: kill %s, %s\n",
-					  target_pid_to_str (lp->ptid), 
+					  target_pid_to_str (lp->ptid),
 					  status_to_str ((int) status));
 		    }
 		  kill (GET_LWP (lp->ptid), WSTOPSIG (status));
@@ -810,7 +808,7 @@ stop_wait_callback (struct lwp_info *lp, void *data)
       else
 	{
 	  /* We caught the SIGSTOP that we intended to catch, so
-             there's no SIGSTOP pending.  */
+	     there's no SIGSTOP pending.  */
 	  lp->stopped = 1;
 	  lp->signalled = 0;
 	}
@@ -904,8 +902,8 @@ cancel_breakpoints_callback (struct lwp_info *lp, void *data)
      tripped on it.  */
 
   if (lp->status != 0
-      && WIFSTOPPED (lp->status) &&  WSTOPSIG (lp->status) == SIGTRAP
-      && breakpoint_inserted_here_p (read_pc_pid (lp->ptid) - 
+      && WIFSTOPPED (lp->status) && WSTOPSIG (lp->status) == SIGTRAP
+      && breakpoint_inserted_here_p (read_pc_pid (lp->ptid) -
 				     DECR_PC_AFTER_BREAK))
     {
       if (debug_lin_lwp)
@@ -948,7 +946,7 @@ select_event_lwp (struct lwp_info **orig_lp, int *status)
   else
     {
       /* No single-stepping LWP.  Select one at random, out of those
-	 which have had SIGTRAP events.  */
+         which have had SIGTRAP events.  */
 
       /* First see how many SIGTRAP events we have.  */
       iterate_over_lwps (count_events_callback, &num_events);
@@ -958,8 +956,8 @@ select_event_lwp (struct lwp_info **orig_lp, int *status)
 	((num_events * (double) rand ()) / (RAND_MAX + 1.0));
 
       if (debug_lin_lwp && num_events > 1)
-	fprintf_unfiltered (gdb_stdlog, 
-			    "SEL: Found %d SIGTRAP events, selecting #%d\n", 
+	fprintf_unfiltered (gdb_stdlog,
+			    "SEL: Found %d SIGTRAP events, selecting #%d\n",
 			    num_events, random_selector);
 
       event_lp = iterate_over_lwps (select_event_lwp_callback,
@@ -970,7 +968,7 @@ select_event_lwp (struct lwp_info **orig_lp, int *status)
     {
       /* Switch the event LWP.  */
       *orig_lp = event_lp;
-      *status  = event_lp->status;
+      *status = event_lp->status;
     }
 
   /* Flush the wait status for the event LWP.  */
@@ -1014,17 +1012,16 @@ child_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
 
       if (debug_lin_lwp)
 	{
-	  fprintf_unfiltered (gdb_stdlog, 
+	  fprintf_unfiltered (gdb_stdlog,
 			      "CW:  waitpid %ld received %s\n",
-			      (long) pid, 
-			      status_to_str (status));
+			      (long) pid, status_to_str (status));
 	}
 
       save_errno = errno;
 
       /* Make sure we don't report an event for the exit of the
-	 original program, if we've detached from it.  */
-      if (pid != -1 && ! WIFSTOPPED (status) && pid != GET_PID (inferior_ptid))
+         original program, if we've detached from it.  */
+      if (pid != -1 && !WIFSTOPPED (status) && pid != GET_PID (inferior_ptid))
 	{
 	  pid = -1;
 	  save_errno = EINTR;
@@ -1037,7 +1034,7 @@ child_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
 
   if (pid == -1)
     {
-      warning ("Child process unexpectedly missing: %s", 
+      warning ("Child process unexpectedly missing: %s",
 	       safe_strerror (errno));
 
       /* Claim it exited with unknown signal.  */
@@ -1064,13 +1061,13 @@ lin_lwp_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
   sigemptyset (&flush_mask);
 
   /* Make sure SIGCHLD is blocked.  */
-  if (! sigismember (&blocked_mask, SIGCHLD))
+  if (!sigismember (&blocked_mask, SIGCHLD))
     {
       sigaddset (&blocked_mask, SIGCHLD);
       sigprocmask (SIG_BLOCK, &blocked_mask, NULL);
     }
 
- retry:
+retry:
 
   /* Make sure there is at least one LWP that has been resumed, at
      least if there are any LWPs at all.  */
@@ -1089,7 +1086,7 @@ lin_lwp_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
 	  if (debug_lin_lwp && status)
 	    fprintf_unfiltered (gdb_stdlog,
 				"LLW: Using pending wait status %s for %s.\n",
-				status_to_str (status), 
+				status_to_str (status),
 				target_pid_to_str (lp->ptid));
 	}
 
@@ -1101,7 +1098,7 @@ lin_lwp_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
   else if (is_lwp (ptid))
     {
       if (debug_lin_lwp)
-	fprintf_unfiltered (gdb_stdlog, 
+	fprintf_unfiltered (gdb_stdlog,
 			    "LLW: Waiting for specific LWP %s.\n",
 			    target_pid_to_str (ptid));
 
@@ -1114,7 +1111,7 @@ lin_lwp_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
       if (debug_lin_lwp && status)
 	fprintf_unfiltered (gdb_stdlog,
 			    "LLW: Using pending wait status %s for %s.\n",
-			    status_to_str (status), 
+			    status_to_str (status),
 			    target_pid_to_str (lp->ptid));
 
       /* If we have to wait, take into account whether PID is a cloned
@@ -1127,19 +1124,19 @@ lin_lwp_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
   if (status && lp->signalled)
     {
       /* A pending SIGSTOP may interfere with the normal stream of
-	 events.  In a typical case where interference is a problem,
-	 we have a SIGSTOP signal pending for LWP A while
-	 single-stepping it, encounter an event in LWP B, and take the
-	 pending SIGSTOP while trying to stop LWP A.  After processing
-	 the event in LWP B, LWP A is continued, and we'll never see
-	 the SIGTRAP associated with the last time we were
-	 single-stepping LWP A.  */
+         events.  In a typical case where interference is a problem,
+         we have a SIGSTOP signal pending for LWP A while
+         single-stepping it, encounter an event in LWP B, and take the
+         pending SIGSTOP while trying to stop LWP A.  After processing
+         the event in LWP B, LWP A is continued, and we'll never see
+         the SIGTRAP associated with the last time we were
+         single-stepping LWP A.  */
 
       /* Resume the thread.  It should halt immediately returning the
-	 pending SIGSTOP.  */
+         pending SIGSTOP.  */
       registers_changed ();
       child_resume (pid_to_ptid (GET_LWP (lp->ptid)), lp->step,
-                    TARGET_SIGNAL_0);
+		    TARGET_SIGNAL_0);
       if (debug_lin_lwp)
 	fprintf_unfiltered (gdb_stdlog,
 			    "LLW: %s %s, 0, 0 (expect SIGSTOP)\n",
@@ -1152,8 +1149,8 @@ lin_lwp_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
       stop_wait_callback (lp, NULL);
     }
 
-  set_sigint_trap ();	/* Causes SIGINT to be passed on to the
-			   attached process. */
+  set_sigint_trap ();		/* Causes SIGINT to be passed on to the
+				   attached process. */
   set_sigio_trap ();
 
   while (status == 0)
@@ -1169,8 +1166,7 @@ lin_lwp_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
 	    {
 	      fprintf_unfiltered (gdb_stdlog,
 				  "LLW: waitpid %ld received %s\n",
-				  (long) lwpid, 
-				  status_to_str (status));
+				  (long) lwpid, status_to_str (status));
 	    }
 
 	  lp = find_lwp_pid (pid_to_ptid (lwpid));
@@ -1179,13 +1175,13 @@ lin_lwp_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
 	     our list, i.e.  not part of the current process.  This can happen
 	     if we detach from a program we original forked and then it
 	     exits.  */
-	  if (! WIFSTOPPED (status) && ! lp)
+	  if (!WIFSTOPPED (status) && !lp)
 	    {
 	      status = 0;
 	      continue;
 	    }
 
-	  if (! lp)
+	  if (!lp)
 	    {
 	      lp = add_lwp (BUILD_LWP (lwpid, GET_PID (inferior_ptid)));
 	      if (options & __WCLONE)
@@ -1197,10 +1193,10 @@ lin_lwp_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
 			      && WSTOPSIG (status) == SIGSTOP);
 		  lp->signalled = 1;
 
-		  if (! in_thread_list (inferior_ptid))
+		  if (!in_thread_list (inferior_ptid))
 		    {
 		      inferior_ptid = BUILD_LWP (GET_PID (inferior_ptid),
-		                                 GET_PID (inferior_ptid));
+						 GET_PID (inferior_ptid));
 		      add_thread (inferior_ptid);
 		    }
 
@@ -1211,22 +1207,22 @@ lin_lwp_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
 	    }
 
 	  /* Make sure we don't report a TARGET_WAITKIND_EXITED or
-             TARGET_WAITKIND_SIGNALLED event if there are still LWP's
-             left in the process.  */
+	     TARGET_WAITKIND_SIGNALLED event if there are still LWP's
+	     left in the process.  */
 	  if ((WIFEXITED (status) || WIFSIGNALED (status)) && num_lwps > 1)
 	    {
 	      if (in_thread_list (lp->ptid))
 		{
 		  /* Core GDB cannot deal with us deleting the current
-                     thread.  */
-		  if (! ptid_equal (lp->ptid, inferior_ptid))
+		     thread.  */
+		  if (!ptid_equal (lp->ptid, inferior_ptid))
 		    delete_thread (lp->ptid);
 		  printf_unfiltered ("[%s exited]\n",
 				     target_pid_to_str (lp->ptid));
 		}
 	      if (debug_lin_lwp)
-		fprintf_unfiltered (gdb_stdlog, 
-				    "LLW: %s exited.\n", 
+		fprintf_unfiltered (gdb_stdlog,
+				    "LLW: %s exited.\n",
 				    target_pid_to_str (lp->ptid));
 
 	      delete_lwp (lp->ptid);
@@ -1240,13 +1236,12 @@ lin_lwp_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
 	    }
 
 	  /* Make sure we don't report a SIGSTOP that we sent
-             ourselves in an attempt to stop an LWP.  */
+	     ourselves in an attempt to stop an LWP.  */
 	  if (lp->signalled
-              && WIFSTOPPED (status)
-	      && WSTOPSIG (status) == SIGSTOP)
+	      && WIFSTOPPED (status) && WSTOPSIG (status) == SIGSTOP)
 	    {
 	      if (debug_lin_lwp)
-		fprintf_unfiltered (gdb_stdlog, 
+		fprintf_unfiltered (gdb_stdlog,
 				    "LLW: Delayed SIGSTOP caught for %s.\n",
 				    target_pid_to_str (lp->ptid));
 
@@ -1255,11 +1250,11 @@ lin_lwp_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
 
 	      registers_changed ();
 	      child_resume (pid_to_ptid (GET_LWP (lp->ptid)), lp->step,
-	                    TARGET_SIGNAL_0);
+			    TARGET_SIGNAL_0);
 	      if (debug_lin_lwp)
 		fprintf_unfiltered (gdb_stdlog,
 				    "LLW: %s %s, 0, 0 (discard SIGSTOP)\n",
-				    lp->step ? 
+				    lp->step ?
 				    "PTRACE_SINGLESTEP" : "PTRACE_CONT",
 				    target_pid_to_str (lp->ptid));
 
@@ -1309,16 +1304,17 @@ lin_lwp_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
 	  && signal_pass_state (signo) == 1)
 	{
 	  /* FIMXE: kettenis/2001-06-06: Should we resume all threads
-             here?  It is not clear we should.  GDB may not expect
-             other threads to run.  On the other hand, not resuming
-             newly attached threads may cause an unwanted delay in
-             getting them running.  */
+	     here?  It is not clear we should.  GDB may not expect
+	     other threads to run.  On the other hand, not resuming
+	     newly attached threads may cause an unwanted delay in
+	     getting them running.  */
 	  registers_changed ();
 	  child_resume (pid_to_ptid (GET_LWP (lp->ptid)), lp->step, signo);
 	  if (debug_lin_lwp)
 	    fprintf_unfiltered (gdb_stdlog,
 				"LLW: %s %s, %s (preempt 'handle')\n",
-				lp->step ? "PTRACE_SINGLESTEP" : "PTRACE_CONT",
+				lp->step ?
+				"PTRACE_SINGLESTEP" : "PTRACE_CONT",
 				target_pid_to_str (lp->ptid),
 				signo ? strsignal (signo) : "0");
 	  lp->stopped = 0;
@@ -1326,13 +1322,12 @@ lin_lwp_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
 	  goto retry;
 	}
 
-      if (signo == TARGET_SIGNAL_INT
-	  && signal_pass_state (signo) == 0)
+      if (signo == TARGET_SIGNAL_INT && signal_pass_state (signo) == 0)
 	{
 	  /* If ^C/BREAK is typed at the tty/console, SIGINT gets
-             forwarded to the entire process group, that is, all LWP's
-             will receive it.  Since we only want to report it once,
-             we try to flush it from all LWPs except this one.  */
+	     forwarded to the entire process group, that is, all LWP's
+	     will receive it.  Since we only want to report it once,
+	     we try to flush it from all LWPs except this one.  */
 	  sigaddset (&flush_mask, SIGINT);
 	}
     }
@@ -1342,8 +1337,7 @@ lin_lwp_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
 
   if (debug_lin_lwp)
     fprintf_unfiltered (gdb_stdlog, "LLW: Candidate event %s in %s.\n",
-			status_to_str (status), 
-			target_pid_to_str (lp->ptid));
+			status_to_str (status), target_pid_to_str (lp->ptid));
 
   /* Now stop all other LWP's ...  */
   iterate_over_lwps (stop_callback, NULL);
@@ -1370,7 +1364,7 @@ lin_lwp_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
     {
       trap_ptid = (threaded ? lp->ptid : pid_to_ptid (GET_LWP (lp->ptid)));
       if (debug_lin_lwp)
-	fprintf_unfiltered (gdb_stdlog, 
+	fprintf_unfiltered (gdb_stdlog,
 			    "LLW: trap_ptid is %s.\n",
 			    target_pid_to_str (trap_ptid));
     }
@@ -1387,7 +1381,7 @@ kill_callback (struct lwp_info *lp, void *data)
   errno = 0;
   ptrace (PTRACE_KILL, GET_LWP (lp->ptid), 0, 0);
   if (debug_lin_lwp)
-    fprintf_unfiltered (gdb_stdlog, 
+    fprintf_unfiltered (gdb_stdlog,
 			"KC:  PTRACE_KILL %s, 0, 0 (%s)\n",
 			target_pid_to_str (lp->ptid),
 			errno ? safe_strerror (errno) : "OK");
@@ -1430,7 +1424,7 @@ kill_wait_callback (struct lwp_info *lp, void *data)
       if (pid != (pid_t) -1 && debug_lin_lwp)
 	{
 	  fprintf_unfiltered (gdb_stdlog,
-			      "KWC: wait %s received unk.\n", 
+			      "KWC: wait %s received unk.\n",
 			      target_pid_to_str (lp->ptid));
 	}
     }
@@ -1458,7 +1452,7 @@ lin_lwp_create_inferior (char *exec_file, char *allargs, char **env)
   child_ops.to_create_inferior (exec_file, allargs, env);
 }
 
-static void  
+static void
 lin_lwp_mourn_inferior (void)
 {
   trap_ptid = null_ptid;
@@ -1475,8 +1469,7 @@ lin_lwp_mourn_inferior (void)
 
 static int
 lin_lwp_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
-		     struct mem_attrib *attrib,
-		     struct target_ops *target)
+		     struct mem_attrib *attrib, struct target_ops *target)
 {
   struct cleanup *old_chain = save_inferior_ptid ();
   int xfer;
@@ -1502,7 +1495,7 @@ lin_lwp_thread_alive (ptid_t ptid)
   if (debug_lin_lwp)
     fprintf_unfiltered (gdb_stdlog,
 			"LLTA: PTRACE_PEEKUSER %s, 0, 0 (%s)\n",
-			target_pid_to_str (ptid), 
+			target_pid_to_str (ptid),
 			errno ? safe_strerror (errno) : "OK");
   if (errno)
     return 0;
@@ -1586,11 +1579,9 @@ _initialize_lin_lwp (void)
   sigemptyset (&blocked_mask);
 
   add_show_from_set (add_set_cmd ("lin-lwp", no_class, var_zinteger,
-				  (char *) &debug_lin_lwp, 
+				  (char *) &debug_lin_lwp,
 				  "Set debugging of GNU/Linux lwp module.\n\
-Enables printf debugging output.\n",
-				      &setdebuglist),
-		     &showdebuglist);
+Enables printf debugging output.\n", &setdebuglist), &showdebuglist);
 }
 
 
diff --git a/gdb/linux-proc.c b/gdb/linux-proc.c
index 00383e9..a951296 100644
--- a/gdb/linux-proc.c
+++ b/gdb/linux-proc.c
@@ -21,17 +21,17 @@
 
 #include "defs.h"
 #include "inferior.h"
-#include <sys/param.h>	/* for MAXPATHLEN */
-#include <sys/procfs.h>	/* for elf_gregset etc. */
-#include "gdb_stat.h"	/* for struct stat */
-#include <ctype.h>	/* for isdigit */
-#include <unistd.h>	/* for open, pread64 */
-#include <fcntl.h>	/* for O_RDONLY */
-#include "regcache.h"	/* for registers_changed */
-#include "gregset.h"	/* for gregset */
-#include "gdbcore.h"	/* for get_exec_file */
-#include "gdbthread.h"	/* for struct thread_info etc. */
-#include "elf-bfd.h"	/* for elfcore_write_* */
+#include <sys/param.h>		/* for MAXPATHLEN */
+#include <sys/procfs.h>		/* for elf_gregset etc. */
+#include "gdb_stat.h"		/* for struct stat */
+#include <ctype.h>		/* for isdigit */
+#include <unistd.h>		/* for open, pread64 */
+#include <fcntl.h>		/* for O_RDONLY */
+#include "regcache.h"		/* for registers_changed */
+#include "gregset.h"		/* for gregset */
+#include "gdbcore.h"		/* for get_exec_file */
+#include "gdbthread.h"		/* for struct thread_info etc. */
+#include "elf-bfd.h"		/* for elfcore_write_* */
 #include "cli/cli-decode.h"	/* for add_info */
 #include "gdb_string.h"
 
@@ -69,28 +69,26 @@ child_pid_to_exec_file (int pid)
  * Service function for corefiles and info proc.
  */
 
-static int 
-read_mapping (FILE *mapfile, 
-	      long long *addr, 
-	      long long *endaddr, 
-	      char *permissions, 
-	      long long *offset, 
-	      char *device, 
-	      long long *inode, 
-	      char *filename)
+static int
+read_mapping (FILE *mapfile,
+	      long long *addr,
+	      long long *endaddr,
+	      char *permissions,
+	      long long *offset,
+	      char *device, long long *inode, char *filename)
 {
-  int ret = fscanf (mapfile,  "%llx-%llx %s %llx %s %llx", 
+  int ret = fscanf (mapfile, "%llx-%llx %s %llx %s %llx",
 		    addr, endaddr, permissions, offset, device, inode);
 
   if (ret > 0 && ret != EOF && *inode != 0)
     {
       /* Eat everything up to EOL for the filename.  This will prevent
-       weird filenames (such as one with embedded whitespace) from
-       confusing this code.  It also makes this code more robust
-       in respect to annotations the kernel may add after the
-       filename.
+         weird filenames (such as one with embedded whitespace) from
+         confusing this code.  It also makes this code more robust
+         in respect to annotations the kernel may add after the
+         filename.
 
-       Note the filename is used for informational purposes only.  */
+         Note the filename is used for informational purposes only.  */
       ret += fscanf (mapfile, "%[^\n]\n", filename);
     }
   else
@@ -108,11 +106,9 @@ read_mapping (FILE *mapfile,
  */
 
 static int
-linux_find_memory_regions (int (*func) (CORE_ADDR, 
+linux_find_memory_regions (int (*func) (CORE_ADDR,
 					unsigned long,
-					int, int, int,
-					void *), 
-			   void *obfd)
+					int, int, int, void *), void *obfd)
 {
   long long pid = PIDGET (inferior_ptid);
   char mapsfilename[MAXPATHLEN];
@@ -128,31 +124,29 @@ linux_find_memory_regions (int (*func) (CORE_ADDR,
     error ("Could not open %s\n", mapsfilename);
 
   if (info_verbose)
-    fprintf_filtered (gdb_stdout, 
+    fprintf_filtered (gdb_stdout,
 		      "Reading memory regions from %s\n", mapsfilename);
 
   /* Now iterate until end-of-file. */
-  while (read_mapping (mapsfile, &addr, &endaddr, &permissions[0], 
+  while (read_mapping (mapsfile, &addr, &endaddr, &permissions[0],
 		       &offset, &device[0], &inode, &filename[0]))
     {
       size = endaddr - addr;
 
       /* Get the segment's permissions.  */
-      read  = (strchr (permissions, 'r') != 0);
+      read = (strchr (permissions, 'r') != 0);
       write = (strchr (permissions, 'w') != 0);
-      exec  = (strchr (permissions, 'x') != 0);
+      exec = (strchr (permissions, 'x') != 0);
 
       if (info_verbose)
 	{
-	  fprintf_filtered (gdb_stdout, 
-			    "Save segment, %lld bytes at 0x%s (%c%c%c)", 
-			    size, paddr_nz (addr), 
-			    read  ? 'r' : ' ', 
-			    write ? 'w' : ' ',
-			    exec  ? 'x' : ' ');
+	  fprintf_filtered (gdb_stdout,
+			    "Save segment, %lld bytes at 0x%s (%c%c%c)",
+			    size, paddr_nz (addr),
+			    read ? 'r' : ' ',
+			    write ? 'w' : ' ', exec ? 'x' : ' ');
 	  if (filename && filename[0])
-	    fprintf_filtered (gdb_stdout, 
-			      " for %s", filename);
+	    fprintf_filtered (gdb_stdout, " for %s", filename);
 	  fprintf_filtered (gdb_stdout, "\n");
 	}
 
@@ -169,7 +163,7 @@ linux_find_memory_regions (int (*func) (CORE_ADDR,
  */
 
 static char *
-linux_do_thread_registers (bfd *obfd, ptid_t ptid, 
+linux_do_thread_registers (bfd *obfd, ptid_t ptid,
 			   char *note_data, int *note_size)
 {
   gdb_gregset_t gregs;
@@ -180,26 +174,23 @@ linux_do_thread_registers (bfd *obfd, ptid_t ptid,
   unsigned long merged_pid = ptid_get_tid (ptid) << 16 | ptid_get_pid (ptid);
 
   fill_gregset (&gregs, -1);
-  note_data = (char *) elfcore_write_prstatus (obfd, 
-					       note_data, 
-					       note_size, 
-					       merged_pid, 
-					       stop_signal, 
-					       &gregs);
+  note_data = (char *) elfcore_write_prstatus (obfd,
+					       note_data,
+					       note_size,
+					       merged_pid,
+					       stop_signal, &gregs);
 
   fill_fpregset (&fpregs, -1);
-  note_data = (char *) elfcore_write_prfpreg (obfd, 
-					      note_data, 
-					      note_size, 
-					      &fpregs, 
-					      sizeof (fpregs));
+  note_data = (char *) elfcore_write_prfpreg (obfd,
+					      note_data,
+					      note_size,
+					      &fpregs, sizeof (fpregs));
 #ifdef FILL_FPXREGSET
   fill_fpxregset (&fpxregs, -1);
-  note_data = (char *) elfcore_write_prxfpreg (obfd, 
-					       note_data, 
-					       note_size, 
-					       &fpxregs, 
-					       sizeof (fpxregs));
+  note_data = (char *) elfcore_write_prxfpreg (obfd,
+					       note_data,
+					       note_size,
+					       &fpxregs, sizeof (fpxregs));
 #endif
   return note_data;
 }
@@ -228,9 +219,9 @@ linux_corefile_thread_callback (struct thread_info *ti, void *data)
   registers_changed ();
   target_fetch_registers (-1);	/* FIXME should not be necessary; 
 				   fill_gregset should do it automatically. */
-  args->note_data = linux_do_thread_registers (args->obfd, 
-					       ti->ptid, 
-					       args->note_data, 
+  args->note_data = linux_do_thread_registers (args->obfd,
+					       ti->ptid,
+					       args->note_data,
 					       args->note_size);
   args->num_notes++;
   inferior_ptid = saved_ptid;
@@ -252,28 +243,24 @@ linux_make_note_section (bfd *obfd, int *note_size)
 {
   struct linux_corefile_thread_data thread_args;
   struct cleanup *old_chain;
-  char fname[16] = {'\0'};
-  char psargs[80] = {'\0'};
+  char fname[16] = { '\0' };
+  char psargs[80] = { '\0' };
   char *note_data = NULL;
   ptid_t current_ptid = inferior_ptid;
 
   if (get_exec_file (0))
     {
       strncpy (fname, strrchr (get_exec_file (0), '/') + 1, sizeof (fname));
-      strncpy (psargs, get_exec_file (0), 
-	       sizeof (psargs));
+      strncpy (psargs, get_exec_file (0), sizeof (psargs));
       if (get_inferior_args ())
 	{
-	  strncat (psargs, " ", 
-		   sizeof (psargs) - strlen (psargs));
-	  strncat (psargs, get_inferior_args (), 
+	  strncat (psargs, " ", sizeof (psargs) - strlen (psargs));
+	  strncat (psargs, get_inferior_args (),
 		   sizeof (psargs) - strlen (psargs));
 	}
-      note_data = (char *) elfcore_write_prpsinfo (obfd, 
-						   note_data, 
-						   note_size, 
-						   fname, 
-						   psargs);
+      note_data = (char *) elfcore_write_prpsinfo (obfd,
+						   note_data,
+						   note_size, fname, psargs);
     }
 
   /* Dump information for threads.  */
@@ -285,8 +272,8 @@ linux_make_note_section (bfd *obfd, int *note_size)
   if (thread_args.num_notes == 0)
     {
       /* iterate_over_threads didn't come up with any threads;
-	 just use inferior_ptid.  */
-      note_data = linux_do_thread_registers (obfd, inferior_ptid, 
+         just use inferior_ptid.  */
+      note_data = linux_do_thread_registers (obfd, inferior_ptid,
 					     note_data, note_size);
     }
   else
@@ -420,33 +407,30 @@ linux_info_proc_cmd (char *args, int from_tty)
 	  if (TARGET_ADDR_BIT == 32)
 	    {
 	      header_fmt_string = "\t%10s %10s %10s %10s %7s\n";
-	      data_fmt_string   = "\t%#10lx %#10lx %#10x %#10x %7s\n";
+	      data_fmt_string = "\t%#10lx %#10lx %#10x %#10x %7s\n";
 	    }
 	  else
 	    {
 	      header_fmt_string = "  %18s %18s %10s %10s %7s\n";
-	      data_fmt_string   = "  %#18lx %#18lx %#10x %#10x %7s\n";
+	      data_fmt_string = "  %#18lx %#18lx %#10x %#10x %7s\n";
 	    }
 
 	  printf_filtered ("Mapped address spaces:\n\n");
-	  printf_filtered (header_fmt_string, 
+	  printf_filtered (header_fmt_string,
 			   "Start Addr",
 			   "  End Addr",
-			   "      Size",
-			   "    Offset",
-			   "objfile");
-	  
-	  while (read_mapping (procfile, &addr, &endaddr, &permissions[0], 
+			   "      Size", "    Offset", "objfile");
+
+	  while (read_mapping (procfile, &addr, &endaddr, &permissions[0],
 			       &offset, &device[0], &inode, &filename[0]))
 	    {
 	      size = endaddr - addr;
-	      printf_filtered (data_fmt_string, 
-			       (unsigned long) addr, /* FIXME: pr_addr */
-			       (unsigned long) endaddr, 
-			       (int) size, 
-			       (unsigned int) offset, 
+	      printf_filtered (data_fmt_string, (unsigned long) addr,	/* FIXME: pr_addr */
+			       (unsigned long) endaddr,
+			       (int) size,
+			       (unsigned int) offset,
 			       filename[0] ? filename : "");
-	      
+
 	    }
 
 	  fclose (procfile);
@@ -463,7 +447,7 @@ linux_info_proc_cmd (char *args, int from_tty)
 	    printf_filtered (buffer);
 	  fclose (procfile);
 	}
-      else 
+      else
 	warning ("unable to open /proc file '%s'", fname1);
     }
   if (stat_f || all)
@@ -493,16 +477,16 @@ linux_info_proc_cmd (char *args, int from_tty)
 	  if (fscanf (procfile, "%u ", &itmp) > 0)
 	    printf_filtered ("Flags: 0x%x\n", itmp);
 	  if (fscanf (procfile, "%u ", &itmp) > 0)
-	    printf_filtered ("Minor faults (no memory page): %u\n", 
+	    printf_filtered ("Minor faults (no memory page): %u\n",
 			     (unsigned int) itmp);
 	  if (fscanf (procfile, "%u ", &itmp) > 0)
-	    printf_filtered ("Minor faults, children: %u\n", 
+	    printf_filtered ("Minor faults, children: %u\n",
 			     (unsigned int) itmp);
 	  if (fscanf (procfile, "%u ", &itmp) > 0)
-	    printf_filtered ("Major faults (memory page faults): %u\n", 
+	    printf_filtered ("Major faults (memory page faults): %u\n",
 			     (unsigned int) itmp);
 	  if (fscanf (procfile, "%u ", &itmp) > 0)
-	    printf_filtered ("Major faults, children: %u\n", 
+	    printf_filtered ("Major faults, children: %u\n",
 			     (unsigned int) itmp);
 	  if (fscanf (procfile, "%d ", &itmp) > 0)
 	    printf_filtered ("utime: %d\n", itmp);
@@ -513,36 +497,34 @@ linux_info_proc_cmd (char *args, int from_tty)
 	  if (fscanf (procfile, "%d ", &itmp) > 0)
 	    printf_filtered ("stime, children: %d\n", itmp);
 	  if (fscanf (procfile, "%d ", &itmp) > 0)
-	    printf_filtered ("jiffies remaining in current time slice: %d\n", 
+	    printf_filtered ("jiffies remaining in current time slice: %d\n",
 			     itmp);
 	  if (fscanf (procfile, "%d ", &itmp) > 0)
 	    printf_filtered ("'nice' value: %d\n", itmp);
 	  if (fscanf (procfile, "%u ", &itmp) > 0)
-	    printf_filtered ("jiffies until next timeout: %u\n", 
+	    printf_filtered ("jiffies until next timeout: %u\n",
 			     (unsigned int) itmp);
 	  if (fscanf (procfile, "%u ", &itmp) > 0)
-	    printf_filtered ("jiffies until next SIGALRM: %u\n", 
+	    printf_filtered ("jiffies until next SIGALRM: %u\n",
 			     (unsigned int) itmp);
 	  if (fscanf (procfile, "%d ", &itmp) > 0)
-	    printf_filtered ("start time (jiffies since system boot): %d\n", 
+	    printf_filtered ("start time (jiffies since system boot): %d\n",
 			     itmp);
 	  if (fscanf (procfile, "%u ", &itmp) > 0)
-	    printf_filtered ("Virtual memory size: %u\n", 
+	    printf_filtered ("Virtual memory size: %u\n",
 			     (unsigned int) itmp);
 	  if (fscanf (procfile, "%u ", &itmp) > 0)
-	    printf_filtered ("Resident set size: %u\n", 
-			     (unsigned int) itmp);
+	    printf_filtered ("Resident set size: %u\n", (unsigned int) itmp);
 	  if (fscanf (procfile, "%u ", &itmp) > 0)
-	    printf_filtered ("rlim: %u\n", 
-			     (unsigned int) itmp);
+	    printf_filtered ("rlim: %u\n", (unsigned int) itmp);
 	  if (fscanf (procfile, "%u ", &itmp) > 0)
 	    printf_filtered ("Start of text: 0x%x\n", itmp);
 	  if (fscanf (procfile, "%u ", &itmp) > 0)
 	    printf_filtered ("End of text: 0x%x\n", itmp);
 	  if (fscanf (procfile, "%u ", &itmp) > 0)
 	    printf_filtered ("Start of stack: 0x%x\n", itmp);
-#if 0	/* Don't know how architecture-dependent the rest is... 
-	   Anyway the signal bitmap info is available from "status".  */
+#if 0				/* Don't know how architecture-dependent the rest is... 
+				   Anyway the signal bitmap info is available from "status".  */
 	  if (fscanf (procfile, "%u ", &itmp) > 0)	/* FIXME arch? */
 	    printf_filtered ("Kernel stack pointer: 0x%x\n", itmp);
 	  if (fscanf (procfile, "%u ", &itmp) > 0)	/* FIXME arch? */
@@ -574,7 +556,7 @@ _initialize_linux_proc (void)
   inftarg_set_find_memory_regions (linux_find_memory_regions);
   inftarg_set_make_corefile_notes (linux_make_note_section);
 
-  add_info ("proc", linux_info_proc_cmd, 
+  add_info ("proc", linux_info_proc_cmd,
 	    "Show /proc process information about any running process.\n\
 Specify any process id, or use the program being debugged by default.\n\
 Specify any of the following keywords for detailed info:\n\
@@ -584,9 +566,9 @@ Specify any of the following keywords for detailed info:\n\
   all      -- list all available /proc info.");
 }
 
-int linux_proc_xfer_memory (CORE_ADDR addr, char *myaddr, int len, int write,
-			    struct mem_attrib *attrib,
-			    struct target_ops *target)
+int
+linux_proc_xfer_memory (CORE_ADDR addr, char *myaddr, int len, int write,
+			struct mem_attrib *attrib, struct target_ops *target)
 {
   int fd, ret;
   char filename[64];
@@ -616,8 +598,7 @@ int linux_proc_xfer_memory (CORE_ADDR addr, char *myaddr, int len, int write,
 #ifdef HAVE_PREAD64
   if (pread64 (fd, myaddr, len, addr) != len)
 #else
-  if (lseek (fd, addr, SEEK_SET) == -1
-      || read (fd, myaddr, len) != len)
+  if (lseek (fd, addr, SEEK_SET) == -1 || read (fd, myaddr, len) != len)
 #endif
     ret = 0;
   else
diff --git a/gdb/thread.c b/gdb/thread.c
index 2c70ee5..1b6d872 100644
--- a/gdb/thread.c
+++ b/gdb/thread.c
@@ -255,9 +255,8 @@ in_thread_list (ptid_t ptid)
 
 /* Print a list of thread ids currently known, and the total number of
    threads. To be used from within catch_errors. */
-static int 
-do_captured_list_thread_ids (struct ui_out *uiout,
-			     void *arg)
+static int
+do_captured_list_thread_ids (struct ui_out *uiout, void *arg)
 {
   struct thread_info *tp;
   int num = 0;
@@ -291,24 +290,23 @@ gdb_list_thread_ids (struct ui_out *uiout)
 /* Load infrun state for the thread PID.  */
 
 void
-load_infrun_state (ptid_t ptid, 
-		   CORE_ADDR *prev_pc, 
+load_infrun_state (ptid_t ptid,
+		   CORE_ADDR *prev_pc,
 		   CORE_ADDR *prev_func_start,
-		   char **prev_func_name, 
+		   char **prev_func_name,
 		   int *trap_expected,
 		   struct breakpoint **step_resume_breakpoint,
 		   struct breakpoint **through_sigtramp_breakpoint,
-		   CORE_ADDR *step_range_start, 
+		   CORE_ADDR *step_range_start,
 		   CORE_ADDR *step_range_end,
-		   struct frame_id *step_frame_id, 
+		   struct frame_id *step_frame_id,
 		   int *handling_longjmp,
-		   int *another_trap, 
+		   int *another_trap,
 		   int *stepping_through_solib_after_catch,
 		   bpstat *stepping_through_solib_catchpoints,
 		   int *stepping_through_sigtramp,
-		   int *current_line, 
-		   struct symtab **current_symtab, 
-		   CORE_ADDR *step_sp)
+		   int *current_line,
+		   struct symtab **current_symtab, CORE_ADDR *step_sp)
 {
   struct thread_info *tp;
 
@@ -329,8 +327,10 @@ load_infrun_state (ptid_t ptid,
   *step_frame_id = tp->step_frame_id;
   *handling_longjmp = tp->handling_longjmp;
   *another_trap = tp->another_trap;
-  *stepping_through_solib_after_catch = tp->stepping_through_solib_after_catch;
-  *stepping_through_solib_catchpoints = tp->stepping_through_solib_catchpoints;
+  *stepping_through_solib_after_catch =
+    tp->stepping_through_solib_after_catch;
+  *stepping_through_solib_catchpoints =
+    tp->stepping_through_solib_catchpoints;
   *stepping_through_sigtramp = tp->stepping_through_sigtramp;
   *current_line = tp->current_line;
   *current_symtab = tp->current_symtab;
@@ -340,24 +340,23 @@ load_infrun_state (ptid_t ptid,
 /* Save infrun state for the thread PID.  */
 
 void
-save_infrun_state (ptid_t ptid, 
-		   CORE_ADDR prev_pc, 
+save_infrun_state (ptid_t ptid,
+		   CORE_ADDR prev_pc,
 		   CORE_ADDR prev_func_start,
-		   char *prev_func_name, 
+		   char *prev_func_name,
 		   int trap_expected,
 		   struct breakpoint *step_resume_breakpoint,
 		   struct breakpoint *through_sigtramp_breakpoint,
-		   CORE_ADDR step_range_start, 
+		   CORE_ADDR step_range_start,
 		   CORE_ADDR step_range_end,
-		   const struct frame_id *step_frame_id, 
+		   const struct frame_id *step_frame_id,
 		   int handling_longjmp,
-		   int another_trap, 
+		   int another_trap,
 		   int stepping_through_solib_after_catch,
 		   bpstat stepping_through_solib_catchpoints,
-		   int stepping_through_sigtramp, 
+		   int stepping_through_sigtramp,
 		   int current_line,
-		   struct symtab *current_symtab,
-		   CORE_ADDR step_sp)
+		   struct symtab *current_symtab, CORE_ADDR step_sp)
 {
   struct thread_info *tp;
 
@@ -506,7 +505,7 @@ switch_to_thread (ptid_t ptid)
 static void
 restore_current_thread (ptid_t ptid)
 {
-  if (! ptid_equal (ptid, inferior_ptid))
+  if (!ptid_equal (ptid, inferior_ptid))
     {
       switch_to_thread (ptid);
       print_stack_frame (get_current_frame (), 0, -1);
@@ -571,14 +570,13 @@ thread_apply_all_command (char *cmd, int from_tty)
 	switch_to_thread (tp->ptid);
 #ifdef HPUXHPPA
 	printf_filtered ("\nThread %d (%s):\n",
-			 tp->num,
-			 target_tid_to_str (inferior_ptid));
+			 tp->num, target_tid_to_str (inferior_ptid));
 #else
 	printf_filtered ("\nThread %d (%s):\n", tp->num,
 			 target_pid_to_str (inferior_ptid));
 #endif
 	execute_command (cmd, from_tty);
-	strcpy (cmd, saved_cmd); /* Restore exact command used previously */
+	strcpy (cmd, saved_cmd);	/* Restore exact command used previously */
       }
 
   do_cleanups (saved_cmd_cleanup_chain);
@@ -690,8 +688,7 @@ thread_command (char *tidstr, int from_tty)
 }
 
 static int
-do_captured_thread_select (struct ui_out *uiout,
-			   void *tidstr)
+do_captured_thread_select (struct ui_out *uiout, void *tidstr)
 {
   int num;
   struct thread_info *tp;
@@ -724,8 +721,7 @@ do_captured_thread_select (struct ui_out *uiout,
 }
 
 enum gdb_rc
-gdb_thread_select (struct ui_out *uiout,
-		   char *tidstr)
+gdb_thread_select (struct ui_out *uiout, char *tidstr)
 {
   return catch_exceptions (uiout, do_captured_thread_select, tidstr,
 			   NULL, RETURN_MASK_ALL);
@@ -744,16 +740,14 @@ _initialize_thread (void)
 
   add_prefix_cmd ("thread", class_run, thread_command,
 		  "Use this command to switch between threads.\n\
-The new thread ID must be currently known.", &thread_cmd_list, "thread ", 1,
-		  &cmdlist);
+The new thread ID must be currently known.", &thread_cmd_list, "thread ", 1, &cmdlist);
 
   add_prefix_cmd ("apply", class_run, thread_apply_command,
 		  "Apply a command to a list of threads.",
 		  &thread_apply_list, "apply ", 1, &thread_cmd_list);
 
   add_cmd ("all", class_run, thread_apply_all_command,
-	   "Apply a command to all threads.",
-	   &thread_apply_list);
+	   "Apply a command to all threads.", &thread_apply_list);
 
   if (!xdb_commands)
     add_com_alias ("t", "thread", class_run, 1);