- more %%{__make} macros.

[packages/gdb.git] / gdb-threads.patch

1999-08-13  Jim Kingdon  <http://developer.redhat.com/>

	Threads code from gdb 4.18-codefusion-990706:
	* infrun.c (signal_stop_update, signal_print_update,
	signal_pass_update): new functions.
	* inferior.h: new prototypes for above functions.
	* target.h (enum strata): add thread stratum.
	* linuxthreads.c: new file.  Support for debugging linux threads.
	* config/i386/nm-linux.h: several new prototypes for above.
	* config/i386/linux.mh: add linuxthreads.o to NATDEPFILES.

	More threads code from the same place:
	* config/i386/tm-linux.h (REALTIME_LO, REALTIME_HI): Add
	definitions.
	* target.h (enum target_signal): Add TARGET_SIGNAL_REALTIME_32.
	* target.c (signals, target_signal_from_host,
	target_signal_to_host): Add clauses for
	TARGET_SIGNAL_REALTIME_32.

	* various files: various minor changes to make the above work
	with GDB 4.18.

diff -Ncr /home/kingdon/work/gdb/gdb/config/i386/linux.mh ./gdb/config/i386/linux.mh
*** /home/kingdon/work/gdb/gdb/config/i386/linux.mh	Thu Apr 15 21:34:19 1999
--- ./gdb/config/i386/linux.mh	Fri Aug 13 00:51:14 1999
***************
*** 4,7 ****
  XDEPFILES= ser-tcp.o
  
  NAT_FILE= nm-linux.h
! NATDEPFILES= infptrace.o solib.o inftarg.o fork-child.o corelow.o core-aout.o core-regset.o i386v-nat.o i386v4-nat.o
--- 4,7 ----
  XDEPFILES= ser-tcp.o
  
  NAT_FILE= nm-linux.h
! NATDEPFILES= infptrace.o solib.o inftarg.o fork-child.o corelow.o core-aout.o core-regset.o i386v-nat.o i386v4-nat.o linuxthreads.o
diff -Ncr /home/kingdon/work/gdb/gdb/config/i386/nm-linux.h ./gdb/config/i386/nm-linux.h
*** /home/kingdon/work/gdb/gdb/config/i386/nm-linux.h	Thu Jul  8 16:09:02 1999
--- ./gdb/config/i386/nm-linux.h	Fri Aug 13 00:49:54 1999
***************
*** 71,74 ****
--- 71,92 ----
  extern int
  i386_remove_watchpoint PARAMS ((int pid, CORE_ADDR addr, int len));
  
+ /* Support for the glibc linuxthreads package. */
+ 
+ #ifdef __STDC__
+ struct objfile;
+ #endif
+ 
+ extern void
+ linuxthreads_new_objfile PARAMS ((struct objfile *objfile));
+ #define target_new_objfile(OBJFILE) linuxthreads_new_objfile (OBJFILE)
+ 
+ extern char *
+ linuxthreads_pid_to_str PARAMS ((int pid));
+ #define target_pid_to_str(PID) linuxthreads_pid_to_str (PID)
+ 
+ extern int
+ linuxthreads_prepare_to_proceed PARAMS ((int step));
+ #define PREPARE_TO_PROCEED() linuxthreads_prepare_to_proceed (1)
+ 
  #endif /* #ifndef NM_LINUX_H */
diff -Ncr /home/kingdon/work/gdb/gdb/config/i386/tm-linux.h ./gdb/config/i386/tm-linux.h
*** /home/kingdon/work/gdb/gdb/config/i386/tm-linux.h	Tue Aug  3 16:40:28 1999
--- ./gdb/config/i386/tm-linux.h	Sat Aug 14 19:15:35 1999
***************
*** 104,107 ****
--- 104,121 ----
  
  extern CORE_ADDR i386_linux_sigtramp_saved_sp PARAMS ((struct frame_info *));
  
+ 
+ /* Some versions of Linux have real-time signal support in the C library, and
+    some don't.  We have to include this file to find out.  */
+ #include <signal.h>
+ 
+ #ifdef __SIGRTMIN
+ #define REALTIME_LO __SIGRTMIN
+ #define REALTIME_HI (__SIGRTMAX + 1)
+ #else
+ #define REALTIME_LO 32
+ #define REALTIME_HI 64
+ #endif
+ 
+ 
  #endif  /* #ifndef TM_LINUX_H */
diff -Ncr /home/kingdon/work/gdb/gdb/inferior.h ./gdb/inferior.h
*** /home/kingdon/work/gdb/gdb/inferior.h	Thu Jul  8 16:02:22 1999
--- ./gdb/inferior.h	Fri Aug 13 00:43:51 1999
***************
*** 260,265 ****
--- 260,271 ----
  
  extern int signal_pass_state PARAMS ((int));
  
+ extern int signal_stop_update PARAMS ((int, int));
+ 
+ extern int signal_print_update PARAMS ((int, int));
+ 
+ extern int signal_pass_update PARAMS ((int, int));
+ 
  /* From infcmd.c */
  
  extern void tty_command PARAMS ((char *, int));
diff -Ncr /home/kingdon/work/gdb/gdb/infrun.c ./gdb/infrun.c
*** /home/kingdon/work/gdb/gdb/infrun.c	Thu Aug 12 11:13:29 1999
--- ./gdb/infrun.c	Fri Aug 13 00:33:34 1999
***************
*** 3291,3296 ****
--- 3291,3323 ----
    return signal_program[signo];
  }
  
+ int signal_stop_update (signo, state)
+      int signo;
+      int state;
+ {
+   int ret = signal_stop[signo];
+   signal_stop[signo] = state;
+   return ret;
+ }
+ 
+ int signal_print_update (signo, state)
+      int signo;
+      int state;
+ {
+   int ret = signal_print[signo];
+   signal_print[signo] = state;
+   return ret;
+ }
+ 
+ int signal_pass_update (signo, state)
+      int signo;
+      int state;
+ {
+   int ret = signal_program[signo];
+   signal_program[signo] = state;
+   return ret;
+ }
+ 
  static void
  sig_print_header (void)
  {
diff -Ncr /home/kingdon/work/gdb/gdb/linuxthreads.c ./gdb/linuxthreads.c
*** /home/kingdon/work/gdb/gdb/linuxthreads.c	Wed Dec 31 19:00:00 1969
--- ./gdb/linuxthreads.c	Fri Aug 13 00:46:01 1999
***************
*** 0 ****
--- 1,1631 ----
+ /* Low level interface for debugging GNU/Linux threads for GDB,
+    the GNU debugger.
+    Copyright 1998, 1999 Free Software Foundation, Inc.
+ 
+ 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 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.  */
+ 
+ /* This module implements the debugging interface of the linuxthreads package
+    of the glibc. This package implements a simple clone()-based implementation
+    of Posix threads for Linux. To use this module, be sure that you have at
+    least the version of the linuxthreads package that holds the support of
+    GDB (currently 0.8 included in the glibc-2.0.7).
+ 
+    Right now, the linuxthreads package does not care of priority scheduling,
+    so, neither this module does; In particular, the threads are resumed
+    in any order, which could lead to different scheduling than the one
+    happening when GDB does not control the execution.
+ 
+    The latest point is that ptrace(PT_ATTACH, ...) is intrusive in Linux:
+    When a process is attached, then the attaching process becomes the current
+    parent of the attached process, and the old parent has lost this child.
+    If the old parent does a wait[...](), then this child is no longer
+    considered by the kernel as a child of the old parent, thus leading to
+    results of the call different when the child is attached and when it's not.
+ 
+    A fix has been submitted to the Linux community to solve this problem,
+    which consequences are not visible to the application itself, but on the
+    process which may wait() for the completion of the application (mostly,
+    it may consider that the application no longer exists (errno == ECHILD),
+    although it does, and thus being unable to get the exit status and resource
+    usage of the child. If by chance, it is able to wait() for the application
+    after it has died (by receiving first a SIGCHILD, and then doing a wait(),
+    then the exit status and resource usage may be wrong, because the
+    linuxthreads package heavily relies on wait() synchronization to keep
+    them correct.  */
+ 
+ #include <sys/types.h> /* for pid_t */
+ #include <sys/ptrace.h> /* for PT_* flags */
+ #include <sys/wait.h> /* for WUNTRACED and __WCLONE flags */
+ #include <signal.h> /* for struct sigaction and NSIG */
+ #include <sys/utsname.h>
+ 
+ #include "defs.h"
+ #include "target.h"
+ #include "inferior.h"
+ #include "gdbcore.h"
+ #include "gdbthread.h"
+ #include "wait.h"
+ #include "gdbcmd.h"
+ #include "breakpoint.h"
+ 
+ #ifndef PT_ATTACH
+ #define PT_ATTACH	PTRACE_ATTACH
+ #endif
+ #ifndef PT_KILL
+ #define PT_KILL		PTRACE_KILL
+ #endif
+ #ifndef PT_READ_U
+ #define PT_READ_U	PTRACE_PEEKUSR
+ #endif
+ 
+ #ifdef NSIG
+ #define LINUXTHREAD_NSIG NSIG
+ #else
+ #ifdef _NSIG
+ #define LINUXTHREAD_NSIG _NSIG
+ #endif
+ #endif
+ 
+ extern int child_suppress_run;		/* make inftarg.c non-runnable */
+ struct target_ops linuxthreads_ops;	/* Forward declaration */
+ extern struct target_ops child_ops;	/* target vector for inftarg.c */
+ 
+ static CORE_ADDR linuxthreads_handles;	/* array of linuxthreads handles */
+ static CORE_ADDR linuxthreads_manager;	/* pid of linuxthreads manager thread */
+ static CORE_ADDR linuxthreads_initial;	/* pid of linuxthreads initial thread */
+ static CORE_ADDR linuxthreads_debug;	/* linuxthreads internal debug flag */
+ static CORE_ADDR linuxthreads_num;	/* number of valid handle entries */
+ 
+ static int linuxthreads_max;		/* Maximum number of linuxthreads.
+ 					   Zero if this executable doesn't use
+ 					   threads, or wasn't linked with a
+ 					   debugger-friendly version of the
+ 					   linuxthreads library.  */
+ 
+ static int linuxthreads_sizeof_handle;	/* size of a linuxthreads handle */
+ static int linuxthreads_offset_descr;	/* h_descr offset of the linuxthreads
+ 					   handle */
+ static int linuxthreads_offset_pid;	/* p_pid offset of the linuxthreads
+ 					   descr */
+ 
+ static int linuxthreads_manager_pid;	/* manager pid */
+ static int linuxthreads_initial_pid;	/* initial pid */
+ 
+ /* These variables form a bag of threads with interesting status.  If
+    wait_thread (PID) finds that PID stopped for some interesting
+    reason (i.e. anything other than stopped with SIGSTOP), then it
+    records its status in this queue.  linuxthreads_wait and
+    linuxthreads_find_trap extract processes from here.  */
+ static int *linuxthreads_wait_pid;	/* wait array of pid */
+ static int *linuxthreads_wait_status;	/* wait array of status */
+ static int linuxthreads_wait_last;	/* index of last valid elt in
+ 					   linuxthreads_wait_{pid,status} */
+ 
+ static sigset_t linuxthreads_wait_mask;	/* sigset with SIGCHLD */
+ 
+ static int linuxthreads_step_pid;	/* current stepped pid */
+ static int linuxthreads_step_signo;	/* current stepped target signal */
+ static int linuxthreads_exit_status;	/* exit status of initial thread */
+ 
+ static int linuxthreads_inferior_pid;	/* temporary internal inferior pid */
+ static int linuxthreads_breakpoint_pid;	/* last pid that hit a breakpoint */
+ static int linuxthreads_attach_pending;	/* attach command without wait */
+ 
+ static int linuxthreads_breakpoints_inserted;	/* any breakpoints inserted */
+ 
+ /* LinuxThreads uses certain signals for communication between
+    processes; we need to tell GDB to pass them through silently to the
+    inferior.  The LinuxThreads library has global variables we can
+    read containing the relevant signal numbers, but since the signal
+    numbers are chosen at run-time, those variables aren't initialized
+    until the shared library's constructors have had a chance to run.  */
+ 
+ struct linuxthreads_signal {
+ 
+   /* The name of the LinuxThreads library variable that contains
+      the signal number.  */
+   char *var;
+ 
+   /* True if this variable must exist for us to debug properly.  */
+   int required;
+   
+   /* The variable's address in the inferior, or zero if the
+      LinuxThreads library hasn't been loaded into this inferior yet.  */
+   CORE_ADDR addr;
+ 
+   /* The signal number, or zero if we don't know yet (either because
+      we haven't found the variable, or it hasn't been initialized).
+      This is an actual target signal number that you could pass to
+      `kill', not a GDB signal number.  */
+   int signal;
+ 
+   /* GDB's original settings for `stop' and `print' for this signal.
+      We restore them when the user selects a different executable.
+      Invariant: if sig->signal != 0, then sig->{stop,print} contain
+      the original settings.  */
+   int stop, print;
+ };
+ 
+ struct linuxthreads_signal linuxthreads_sig_restart = {
+   "__pthread_sig_restart", 1, 0, 0, 0
+ };
+ struct linuxthreads_signal linuxthreads_sig_cancel = {
+   "__pthread_sig_cancel", 1, 0, 0, 0
+ };
+ struct linuxthreads_signal linuxthreads_sig_debug = {
+   "__pthread_sig_debug", 0, 0, 0, 0
+ };
+ 
+ /* A table of breakpoint locations, one per PID.  */
+ static struct linuxthreads_breakpoint {
+     CORE_ADDR	pc;	/* PC of breakpoint */
+     int		pid;	/* pid of breakpoint */
+     int		step;	/* whether the pc has been reached after sstep */
+ } *linuxthreads_breakpoint_zombie;		/* Zombie breakpoints array */
+ static int linuxthreads_breakpoint_last;	/* Last zombie breakpoint */
+ 
+ /* linuxthreads_{insert,remove}_breakpoint pass the breakpoint address
+    to {insert,remove}_breakpoint via this variable, since
+    iterate_active_threads doesn't provide any way to pass values
+    through to the worker function.  */
+ static CORE_ADDR linuxthreads_breakpoint_addr;
+ 
+ #define	REMOVE_BREAKPOINT_ZOMBIE(_i) \
+ { \
+   if ((_i) < linuxthreads_breakpoint_last) \
+     linuxthreads_breakpoint_zombie[(_i)] = \
+       linuxthreads_breakpoint_zombie[linuxthreads_breakpoint_last]; \
+   linuxthreads_breakpoint_last--; \
+ }
+ 
+ 
+ \f
+ #ifndef PTRACE_XFER_TYPE
+ #define PTRACE_XFER_TYPE int
+ #endif
+ /* Check to see if the given thread is alive.  */
+ static int
+ linuxthreads_thread_alive (pid)
+      int pid;
+ {
+     errno = 0;
+     return ptrace (PT_READ_U, pid, (PTRACE_ARG3_TYPE)0, 0) >= 0 || errno == 0;
+ }
+ 
+ /* On detach(), find a SIGTRAP status.  If stop is non-zero, find a
+    SIGSTOP one, too.
+ 
+    Make sure PID is ready to run, and free of interference from our
+    efforts to debug it (e.g., pending SIGSTOP or SIGTRAP signals).  If
+    STOP is zero, just look for a SIGTRAP.  If STOP is non-zero, look
+    for a SIGSTOP, too.  Return non-zero if PID is alive and ready to
+    run; return zero if PID is dead.
+ 
+    PID may or may not be stopped at the moment, and we may or may not
+    have waited for it already.  We check the linuxthreads_wait bag in
+    case we've already got a status for it.  We may possibly wait for
+    it ourselves.
+ 
+    PID may have signals waiting to be delivered.  If they're caused by
+    our efforts to debug it, accept them with wait, but don't pass them
+    through to PID.  Do pass all other signals through.  */   
+ static int
+ linuxthreads_find_trap (pid, stop)
+     int pid;
+     int stop;
+ {
+   int i;
+   int rpid;
+   int status;
+   int found_stop = 0;
+   int found_trap = 0;
+ 
+   /* PID may have any number of signals pending.  The kernel will
+      report each of them to us via wait, and then it's up to us to
+      pass them along to the process via ptrace, if we so choose.
+ 
+      We need to paw through the whole set until we've found a SIGTRAP
+      (or a SIGSTOP, if `stop' is set).  We don't pass the SIGTRAP (or
+      SIGSTOP) through, but we do re-send all the others, so PID will
+      receive them when we resume it.  */
+   int *wstatus = alloca (LINUXTHREAD_NSIG * sizeof (int));
+   int last = 0;
+ 
+   /* Look at the pending status */
+   for (i = linuxthreads_wait_last; i >= 0; i--)
+     if (linuxthreads_wait_pid[i] == pid)
+       {
+ 	status = linuxthreads_wait_status[i];
+ 
+ 	/* Delete the i'th member of the table.  Since the table is
+ 	   unordered, we can do this simply by copying the table's
+ 	   last element to the i'th position, and shrinking the table
+ 	   by one element.  */
+ 	if (i < linuxthreads_wait_last)
+ 	  {
+ 	    linuxthreads_wait_status[i] =
+ 	      linuxthreads_wait_status[linuxthreads_wait_last];
+ 	    linuxthreads_wait_pid[i] =
+ 	      linuxthreads_wait_pid[linuxthreads_wait_last];
+ 	  }
+ 	linuxthreads_wait_last--;
+ 
+ 	if (!WIFSTOPPED(status)) /* Thread has died */
+ 	  return 0;
+ 
+ 	if (WSTOPSIG(status) == SIGTRAP)
+ 	  {
+ 	    if (stop)
+ 	      found_trap = 1;
+ 	    else
+ 	      return 1;
+ 	  }
+ 	else if (WSTOPSIG(status) == SIGSTOP)
+ 	  {
+ 	    if (stop)
+ 	      found_stop = 1;
+ 	  }
+ 	else
+ 	  {
+ 	    wstatus[0] = status;
+ 	    last = 1;
+ 	  }
+ 
+ 	break;
+       }
+ 
+   if (stop)
+     {
+       /* Make sure that we'll find what we're looking for.  */
+       if (!found_trap)
+ 	kill (pid, SIGTRAP);
+       if (!found_stop)
+ 	kill (pid, SIGSTOP);
+     }
+ 		      
+   /* Catch all status until SIGTRAP and optionally SIGSTOP show up.  */
+   for (;;)
+     {
+       child_resume (pid, 1, TARGET_SIGNAL_0);
+ 
+       for (;;)
+ 	{
+ 	  rpid = waitpid (pid, &status, __WCLONE);
+ 	  if (rpid > 0)
+ 	    break;
+ 	  if (errno == EINTR)
+ 	    continue;
+ 
+ 	  /* There are a few reasons the wait call above may have
+ 	     failed.  If the thread manager dies, its children get
+ 	     reparented, and this interferes with GDB waiting for
+ 	     them, in some cases.  Another possibility is that the
+ 	     initial thread was not cloned, so calling wait with
+ 	     __WCLONE won't find it.  I think neither of these should
+ 	     occur in modern Linux kernels --- they don't seem to in
+ 	     2.0.36.  */
+ 	  rpid = waitpid (pid, &status, 0);
+ 	  if (rpid > 0)
+ 	    break;
+ 	  if (errno != EINTR)
+ 	    perror_with_name ("waitpid");
+ 	}
+ 
+       if (!WIFSTOPPED(status)) /* Thread has died */
+ 	return 0;
+ 
+       if (WSTOPSIG(status) == SIGTRAP)
+ 	if (!stop || found_stop)
+ 	  break;
+ 	else
+ 	  found_trap = 1;
+       else if (WSTOPSIG(status) != SIGSTOP)
+ 	wstatus[last++] = status;
+       else if (stop)
+ 	if (found_trap)
+ 	  break;
+ 	else
+ 	  found_stop = 1;
+     }
+ 
+   /* Resend any other signals we noticed to the thread, to be received
+      when we continue it.  */
+   while (--last >= 0)
+     kill (pid, WSTOPSIG(wstatus[last]));
+ 
+   return 1;
+ }
+ 
+ /* Cleanup stub for save_inferior_pid.  */
+ static void
+ restore_inferior_pid (arg)
+     void *arg;
+ {
+   int pid = (int) arg;
+   inferior_pid = pid;
+ }
+ 
+ /* Register a cleanup to restore the value of inferior_pid.  */
+ static struct cleanup *
+ save_inferior_pid ()
+ {
+   return make_cleanup (restore_inferior_pid, (void *) inferior_pid);
+ }
+ 
+ static void
+ sigchld_handler(signo)
+     int signo;
+ {
+     /* This handler is used to get an EINTR while doing waitpid()
+        when an event is received */
+ }
+ 
+ /* Have we already collected a wait status for PID in the
+    linuxthreads_wait bag?  */
+ static int
+ linuxthreads_pending_status (pid)
+     int pid;
+ {
+   int i;
+   for (i = linuxthreads_wait_last; i >= 0; i--)
+     if (linuxthreads_wait_pid[i] == pid)
+       return 1;
+   return 0;
+ }
+ 
+ \f
+ /* Internal linuxthreads signal management */
+ 
+ /* Check in OBJFILE for the variable that holds the number for signal SIG.
+    We assume that we've already found other LinuxThreads-ish variables
+    in OBJFILE, so we complain if it's required, but not there.
+    Return true iff things are okay.  */
+ static int
+ find_signal_var (struct linuxthreads_signal *sig,
+ 		 struct objfile *objfile)
+ {
+   struct minimal_symbol *ms = lookup_minimal_symbol (sig->var, NULL, objfile);
+ 
+   if (! ms)
+     {
+       if (sig->required)
+ 	{
+ 	  fprintf_unfiltered (gdb_stderr,
+ 			      "Unable to find linuxthreads symbol \"%s\"\n",
+ 			      sig->var);
+ 	  return 0;
+ 	}
+       else
+ 	{
+ 	  sig->addr = 0;
+ 	  return 1;
+ 	}
+     }
+ 
+   sig->addr = SYMBOL_VALUE_ADDRESS (ms);
+ 
+   return 1;
+ }
+ 
+ static int
+ find_all_signal_vars (struct objfile *objfile)
+ {
+   return (   find_signal_var (&linuxthreads_sig_restart, objfile)
+ 	  && find_signal_var (&linuxthreads_sig_cancel,  objfile)
+ 	  && find_signal_var (&linuxthreads_sig_debug,   objfile));
+ }
+ 
+ /* A struct complaint isn't appropriate here.  */
+ static int complained_cannot_determine_thread_signal_number = 0;
+ 
+ /* Check to see if the variable holding the signal number for SIG has
+    been initialized yet.  If it has, tell GDB to pass that signal
+    through to the inferior silently.  */
+ static void
+ check_signal_number (struct linuxthreads_signal *sig)
+ {
+   int num;
+ 
+   if (sig->signal)
+     /* We already know this signal number.  */
+     return;
+ 
+   if (! sig->addr)
+     /* We don't know the variable's address yet.  */
+     return;
+ 
+   if (target_read_memory (sig->addr, (char *)&num, sizeof (num))
+       != 0)
+     {
+       /* If this happens once, it'll probably happen for all the
+ 	 signals, so only complain once.  */
+       if (! complained_cannot_determine_thread_signal_number)
+ 	warning ("Cannot determine thread signal number; "
+ 		 "GDB may report spurious signals.");
+       complained_cannot_determine_thread_signal_number = 1;
+       return;
+     }
+   
+   if (num == 0)
+     /* It hasn't been initialized yet.  */
+     return;
+ 
+   /* We know sig->signal was zero, and is becoming non-zero, so it's
+      okay to sample GDB's original settings.  */
+   sig->signal = num;
+   sig->stop  = signal_stop_update  (target_signal_from_host (num), 0);
+   sig->print = signal_print_update (target_signal_from_host (num), 0);
+ }
+ 
+ 
+ static void
+ check_all_signal_numbers (void)
+ {
+   /* If this isn't a LinuxThreads program, quit early.  */
+   if (! linuxthreads_max)
+     return;
+ 
+   check_signal_number (&linuxthreads_sig_restart);
+   check_signal_number (&linuxthreads_sig_cancel);
+   check_signal_number (&linuxthreads_sig_debug);
+ 
+   /* handle linuxthread exit */
+   if (linuxthreads_sig_debug.signal
+       || linuxthreads_sig_restart.signal)
+     {
+       struct sigaction sact;
+ 
+       sact.sa_handler = sigchld_handler;
+       sigemptyset(&sact.sa_mask);
+       sact.sa_flags = 0;
+       if (linuxthreads_sig_debug.signal > 0)
+ 	sigaction(linuxthreads_sig_cancel.signal, &sact, NULL);
+       else
+ 	sigaction(linuxthreads_sig_restart.signal, &sact, NULL);
+     }
+ }
+ 
+ 
+ /* Restore GDB's original settings for SIG.
+    This should only be called when we're no longer sure if we're
+    talking to an executable that uses LinuxThreads, so we clear the
+    signal number and variable address too.  */
+ static void
+ restore_signal (struct linuxthreads_signal *sig)
+ {
+   if (! sig->signal)
+     return;
+ 
+   /* We know sig->signal was non-zero, and is becoming zero, so it's
+      okay to restore GDB's original settings.  */
+   signal_stop_update  (target_signal_from_host (sig->signal), sig->stop);
+   signal_print_update (target_signal_from_host (sig->signal), sig->print);
+ 
+   sig->signal = 0;
+   sig->addr = 0;
+ }
+ 
+ 
+ /* Restore GDB's original settings for all LinuxThreads signals.
+    This should only be called when we're no longer sure if we're
+    talking to an executable that uses LinuxThreads, so we clear the
+    signal number and variable address too.  */
+ static void
+ restore_all_signals (void)
+ {
+   restore_signal (&linuxthreads_sig_restart);
+   restore_signal (&linuxthreads_sig_cancel);
+   restore_signal (&linuxthreads_sig_debug);
+ 
+   /* If it happens again, we should complain again.  */
+   complained_cannot_determine_thread_signal_number = 0;
+ }
+ 
+ 
+ \f
+ 
+ /* Apply FUNC to the pid of each active thread.  This consults the
+    inferior's handle table to find active threads.
+ 
+    If ALL is non-zero, process all threads.
+    If ALL is zero, skip threads with pending status.  */
+ static void
+ iterate_active_threads (func, all)
+     void (*func)(int);
+     int all;
+ {
+   CORE_ADDR descr;
+   int pid;
+   int i;
+   int num;
+ 
+   read_memory (linuxthreads_num, (char *)&num, sizeof (int));
+ 
+   for (i = 0; i < linuxthreads_max && num > 0; i++)
+     {
+       read_memory (linuxthreads_handles +
+ 		   linuxthreads_sizeof_handle * i + linuxthreads_offset_descr,
+ 		   (char *)&descr, sizeof (void *));
+       if (descr)
+ 	{
+ 	  num--;
+ 	  read_memory (descr + linuxthreads_offset_pid,
+ 		       (char *)&pid, sizeof (pid_t));
+ 	  if (pid > 0 && pid != linuxthreads_manager_pid
+ 	      && (all || (!linuxthreads_pending_status (pid))))
+ 	    (*func)(pid);
+ 	}
+     }
+ 
+ }
+ 
+ /* Insert a thread breakpoint at linuxthreads_breakpoint_addr.
+    This is the worker function for linuxthreads_insert_breakpoint,
+    which passes it to iterate_active_threads.  */
+ static void
+ insert_breakpoint (pid)
+     int pid;
+ {
+   int j;
+ 
+   /* Remove (if any) the positive zombie breakpoint.  */
+   for (j = linuxthreads_breakpoint_last; j >= 0; j--)
+     if (linuxthreads_breakpoint_zombie[j].pid == pid)
+       {
+ 	if ((linuxthreads_breakpoint_zombie[j].pc - DECR_PC_AFTER_BREAK
+ 	     == linuxthreads_breakpoint_addr)
+ 	    && !linuxthreads_breakpoint_zombie[j].step)
+ 	  REMOVE_BREAKPOINT_ZOMBIE(j);
+ 	break;
+       }
+ }
+ 
+ /* Note that we're about to remove a thread breakpoint at
+    linuxthreads_breakpoint_addr.
+ 
+    This is the worker function for linuxthreads_remove_breakpoint,
+    which passes it to iterate_active_threads.  The actual work of
+    overwriting the breakpoint instruction is done by
+    child_ops.to_remove_breakpoint; here, we simply create a zombie
+    breakpoint if the thread's PC is pointing at the breakpoint being
+    removed.  */
+ static void
+ remove_breakpoint (pid)
+     int pid;
+ {
+   int j;
+ 
+   /* Insert a positive zombie breakpoint (if needed).  */
+   for (j = 0; j <= linuxthreads_breakpoint_last; j++)
+     if (linuxthreads_breakpoint_zombie[j].pid == pid)
+       break;
+ 
+   if (in_thread_list (pid) && linuxthreads_thread_alive (pid))
+     {
+       CORE_ADDR pc = read_pc_pid (pid);
+       if (linuxthreads_breakpoint_addr == pc - DECR_PC_AFTER_BREAK
+ 	  && j > linuxthreads_breakpoint_last)
+ 	{
+ 	  linuxthreads_breakpoint_zombie[j].pid = pid;
+ 	  linuxthreads_breakpoint_zombie[j].pc = pc;
+ 	  linuxthreads_breakpoint_zombie[j].step = 0;
+ 	  linuxthreads_breakpoint_last++;
+ 	}
+     }
+ }
+ 
+ /* Kill a thread */
+ static void
+ kill_thread (pid)
+     int pid;
+ {
+   if (in_thread_list (pid))
+     ptrace (PT_KILL, pid, (PTRACE_ARG3_TYPE) 0, 0);
+   else
+     kill (pid, SIGKILL);
+ }
+ 
+ /* Resume a thread */
+ static void
+ resume_thread (pid)
+     int pid;
+ {
+   if (pid != inferior_pid
+       && in_thread_list (pid)
+       && linuxthreads_thread_alive (pid))
+     if (pid == linuxthreads_step_pid)
+       child_resume (pid, 1, linuxthreads_step_signo);
+     else
+       child_resume (pid, 0, TARGET_SIGNAL_0);
+ }
+ 
+ /* Detach a thread */
+ static void
+ detach_thread (pid)
+     int pid;
+ {
+   if (in_thread_list (pid) && linuxthreads_thread_alive (pid))
+     {
+       /* Remove pending SIGTRAP and SIGSTOP */
+       linuxthreads_find_trap (pid, 1);
+ 
+       inferior_pid = pid;
+       detach (TARGET_SIGNAL_0);
+       inferior_pid = linuxthreads_manager_pid;
+     }
+ }
+ 
+ /* Stop a thread */
+ static void
+ stop_thread (pid)
+     int pid;
+ {
+   if (pid != inferior_pid)
+     if (in_thread_list (pid))
+       kill (pid, SIGSTOP);
+     else if (ptrace (PT_ATTACH, pid, (PTRACE_ARG3_TYPE) 0, 0) == 0)
+       {
+ 	if (!linuxthreads_attach_pending)
+ 	  printf_unfiltered ("[New %s]\n", target_pid_to_str (pid));
+ 	add_thread (pid);
+ 	if (linuxthreads_sig_debug.signal)
+ 	  /* After a new thread in glibc 2.1 signals gdb its existence,
+ 	     it suspends itself and wait for linuxthreads_sig_restart,
+ 	     now we can wake up it. */
+ 	  kill (pid, linuxthreads_sig_restart.signal);
+       }
+     else
+       perror_with_name ("ptrace in stop_thread");
+ }
+ 
+ /* Wait for a thread */
+ static void
+ wait_thread (pid)
+     int pid;
+ {
+   int status;
+   int rpid;
+ 
+   if (pid != inferior_pid && in_thread_list (pid))
+     {
+       for (;;)
+ 	{
+ 	  /* Get first pid status.  */
+ 	  rpid = waitpid(pid, &status, __WCLONE);
+ 	  if (rpid > 0)
+ 	    break;
+ 	  if (errno == EINTR)
+ 	    continue;
+ 
+ 	  /* There are two reasons this might have failed:
+ 
+ 	     1) PID is the initial thread, which wasn't cloned, so
+ 	     passing the __WCLONE flag to waitpid prevented us from
+ 	     finding it.
+ 
+ 	     2) The manager thread is the parent of all but the
+ 	     initial thread; if it dies, the children will all be
+ 	     reparented to init, which will wait for them.  This means
+ 	     our call to waitpid won't find them.
+ 
+ 	     Actually, based on a casual look at the 2.0.36 kernel
+ 	     code, I don't think either of these cases happen.  But I
+ 	     don't have things set up for remotely debugging the
+ 	     kernel, so I'm not sure.  And perhaps older kernels
+ 	     didn't work.  */
+ 	  rpid = waitpid(pid, &status, 0);
+ 	  if (rpid > 0)
+ 	    break;
+ 	  if (errno != EINTR && linuxthreads_thread_alive (pid))
+ 	    perror_with_name ("waitpid");
+ 
+ 	  /* the thread is dead.  */
+ 	  return;
+ 	}
+       if (!WIFSTOPPED(status) || WSTOPSIG(status) != SIGSTOP)
+ 	{
+ 	  linuxthreads_wait_pid[++linuxthreads_wait_last] = pid;
+ 	  linuxthreads_wait_status[linuxthreads_wait_last] = status;
+ 	}
+     }
+ }
+ 
+ /* Walk through the linuxthreads handles in order to detect all
+    threads and stop them */
+ static void
+ update_stop_threads (test_pid)
+     int test_pid;
+ {
+   struct cleanup *old_chain = NULL;
+ 
+   check_all_signal_numbers ();
+ 
+   if (linuxthreads_manager_pid == 0)
+     {
+       if (linuxthreads_manager)
+ 	{
+ 	  if (test_pid > 0 && test_pid != inferior_pid)
+ 	    {
+ 	      old_chain = save_inferior_pid ();
+ 	      inferior_pid = test_pid;
+ 	    }
+ 	  read_memory (linuxthreads_manager,
+ 		       (char *)&linuxthreads_manager_pid, sizeof (pid_t));
+ 	}
+       if (linuxthreads_initial)
+ 	{
+ 	  if (test_pid > 0 && test_pid != inferior_pid)
+ 	    {
+ 	      old_chain = save_inferior_pid ();
+ 	      inferior_pid = test_pid;
+ 	    }
+ 	  read_memory(linuxthreads_initial,
+ 		      (char *)&linuxthreads_initial_pid, sizeof (pid_t));
+ 	}
+     }
+ 
+   if (linuxthreads_manager_pid != 0)
+     {
+       if (old_chain == NULL && test_pid > 0 &&
+ 	  test_pid != inferior_pid && linuxthreads_thread_alive (test_pid))
+ 	{
+ 	  old_chain = save_inferior_pid ();
+ 	  inferior_pid = test_pid;
+ 	}
+ 
+       if (linuxthreads_thread_alive (inferior_pid))
+ 	{
+ 	  if (test_pid > 0)
+ 	    {
+ 	      if (test_pid != linuxthreads_manager_pid
+ 		  && !linuxthreads_pending_status (linuxthreads_manager_pid))
+ 		{
+ 		  stop_thread (linuxthreads_manager_pid);
+ 		  wait_thread (linuxthreads_manager_pid);
+ 		}
+ 	      if (!in_thread_list (test_pid))
+ 	        {
+ 		  if (!linuxthreads_attach_pending)
+ 		    printf_unfiltered ("[New %s]\n",
+ 				       target_pid_to_str (test_pid));
+ 		  add_thread (test_pid);
+ 		  if (linuxthreads_sig_debug.signal
+ 		      && inferior_pid == test_pid)
+ 		    /* After a new thread in glibc 2.1 signals gdb its
+ 		       existence, it suspends itself and wait for
+ 		       linuxthreads_sig_restart, now we can wake up
+ 		       it. */
+ 		    kill (test_pid, linuxthreads_sig_restart.signal);
+ 		}
+ 	    }
+ 	  iterate_active_threads (stop_thread, 0);
+ 	  iterate_active_threads (wait_thread, 0);
+ 	}
+     }
+ 
+   if (old_chain != NULL)
+     do_cleanups (old_chain);
+ }
+ 
+ /* This routine is called whenever a new symbol table is read in, or when all
+    symbol tables are removed.  libpthread can only be initialized when it
+    finds the right variables in libpthread.so.  Since it's a shared library,
+    those variables don't show up until the library gets mapped and the symbol
+    table is read in.  */
+ 
+ void
+ linuxthreads_new_objfile (objfile)
+     struct objfile *objfile;
+ {
+   struct minimal_symbol *ms;
+ 
+   if (!objfile)
+     {
+       /* We're starting an entirely new executable, so we can no
+ 	 longer be sure that it uses LinuxThreads.  Restore the signal
+ 	 flags to their original states.  */
+       restore_all_signals ();
+ 
+       /* Indicate that we don't know anything's address any more.  */
+       linuxthreads_max = 0;
+ 
+       return;
+     }
+ 
+   /* If we've already found our variables in another objfile, don't
+      bother looking for them again.  */
+   if (linuxthreads_max)
+     return;
+ 
+   if (! lookup_minimal_symbol ("__pthread_initial_thread", NULL, objfile))
+     /* This object file isn't the pthreads library.  */
+     return;
+ 
+   if ((ms = lookup_minimal_symbol ("__pthread_threads_debug",
+ 				   NULL, objfile)) == NULL)
+     {
+       /* The debugging-aware libpthreads is not present in this objfile */
+       warning ("\
+ This program seems to use POSIX threads, but the thread library used\n\
+ does not support debugging.  This may make using GDB difficult.  Don't\n\
+ set breakpoints or single-step through code that might be executed by\n\
+ any thread other than the main thread.");
+       return;
+     }
+   linuxthreads_debug = SYMBOL_VALUE_ADDRESS (ms);
+ 
+   /* Read internal structures configuration */
+   if ((ms = lookup_minimal_symbol ("__pthread_sizeof_handle",
+ 				   NULL, objfile)) == NULL
+       || target_read_memory (SYMBOL_VALUE_ADDRESS (ms),
+ 			     (char *)&linuxthreads_sizeof_handle,
+ 			     sizeof (linuxthreads_sizeof_handle)) != 0)
+     {
+       fprintf_unfiltered (gdb_stderr,
+ 			  "Unable to find linuxthreads symbol \"%s\"\n",
+ 			  "__pthread_sizeof_handle");
+       return;
+     }
+ 
+   if ((ms = lookup_minimal_symbol ("__pthread_offsetof_descr",
+ 				   NULL, objfile)) == NULL
+       || target_read_memory (SYMBOL_VALUE_ADDRESS (ms),
+ 			     (char *)&linuxthreads_offset_descr,
+ 			     sizeof (linuxthreads_offset_descr)) != 0)
+     {
+       fprintf_unfiltered (gdb_stderr,
+ 			  "Unable to find linuxthreads symbol \"%s\"\n",
+ 			  "__pthread_offsetof_descr");
+       return;
+     }
+ 	 
+   if ((ms = lookup_minimal_symbol ("__pthread_offsetof_pid",
+ 				   NULL, objfile)) == NULL
+       || target_read_memory (SYMBOL_VALUE_ADDRESS (ms),
+ 			     (char *)&linuxthreads_offset_pid,
+ 			     sizeof (linuxthreads_offset_pid)) != 0)
+     {
+       fprintf_unfiltered (gdb_stderr,
+ 			  "Unable to find linuxthreads symbol \"%s\"\n",
+ 			  "__pthread_offsetof_pid");
+       return;
+     }
+ 
+   if (! find_all_signal_vars (objfile))
+     return;
+ 
+   /* Read adresses of internal structures to access */
+   if ((ms = lookup_minimal_symbol ("__pthread_handles",
+ 				   NULL, objfile)) == NULL)
+     {
+       fprintf_unfiltered (gdb_stderr,
+ 			  "Unable to find linuxthreads symbol \"%s\"\n",
+ 			  "__pthread_handles");
+       return;
+     }
+   linuxthreads_handles = SYMBOL_VALUE_ADDRESS (ms);
+ 
+   if ((ms = lookup_minimal_symbol ("__pthread_handles_num",
+ 				   NULL, objfile)) == NULL)
+     {
+       fprintf_unfiltered (gdb_stderr,
+ 			  "Unable to find linuxthreads symbol \"%s\"\n",
+ 			  "__pthread_handles_num");
+       return;
+     }
+   linuxthreads_num = SYMBOL_VALUE_ADDRESS (ms);
+ 
+   if ((ms = lookup_minimal_symbol ("__pthread_manager_thread",
+ 				   NULL, objfile)) == NULL)
+     {
+       fprintf_unfiltered (gdb_stderr,
+ 			  "Unable to find linuxthreads symbol \"%s\"\n",
+ 			  "__pthread_manager_thread");
+       return;
+     }
+   linuxthreads_manager = SYMBOL_VALUE_ADDRESS (ms) + linuxthreads_offset_pid;
+ 
+   if ((ms = lookup_minimal_symbol ("__pthread_initial_thread",
+ 				   NULL, objfile)) == NULL)
+     {
+       fprintf_unfiltered (gdb_stderr,
+ 			  "Unable to find linuxthreads symbol \"%s\"\n",
+ 			  "__pthread_initial_thread");
+       return;
+     }
+   linuxthreads_initial = SYMBOL_VALUE_ADDRESS (ms) + linuxthreads_offset_pid;
+ 
+   /* Search for this last, so it won't be set to a non-zero value unless
+      we successfully found all the symbols above.  */
+   if ((ms = lookup_minimal_symbol ("__pthread_threads_max",
+ 				   NULL, objfile)) == NULL
+       || target_read_memory (SYMBOL_VALUE_ADDRESS (ms),
+ 			     (char *)&linuxthreads_max,
+ 			     sizeof (linuxthreads_max)) != 0)
+     {
+       fprintf_unfiltered (gdb_stderr,
+ 			  "Unable to find linuxthreads symbol \"%s\"\n",
+ 			  "__pthread_threads_max");
+       return;
+     }
+ 
+   /* Allocate gdb internal structures */
+   linuxthreads_wait_pid = 
+     (int *)xmalloc (sizeof (int) * (linuxthreads_max + 1));
+   linuxthreads_wait_status =
+     (int *)xmalloc (sizeof (int) * (linuxthreads_max + 1));
+   linuxthreads_breakpoint_zombie = (struct linuxthreads_breakpoint *)
+     xmalloc (sizeof (struct linuxthreads_breakpoint) * (linuxthreads_max + 1));
+ 
+   if (inferior_pid && !linuxthreads_attach_pending)
+     {
+       int on = 1;
+       target_write_memory (linuxthreads_debug, (char *)&on, sizeof (on));
+       linuxthreads_attach_pending = 1;
+       update_stop_threads (inferior_pid);
+       linuxthreads_attach_pending = 0;
+     }
+ }
+ 
+ /* If we have switched threads from a one that stopped at breakpoint,
+    return 1 otherwise 0.  */
+ 
+ int
+ linuxthreads_prepare_to_proceed (step)
+     int step;
+ {
+   if (!linuxthreads_max
+       || !linuxthreads_manager_pid
+       || !linuxthreads_breakpoint_pid
+       || !breakpoint_here_p (read_pc_pid (linuxthreads_breakpoint_pid)))
+     return 0;
+ 
+   if (step)
+     {
+       /* Mark the current inferior as single stepping process.  */
+       linuxthreads_step_pid = inferior_pid;
+     }
+ 
+   linuxthreads_inferior_pid = linuxthreads_breakpoint_pid;
+   return linuxthreads_breakpoint_pid;
+ }
+ 
+ /* Convert a pid to printable form. */
+ 
+ char *
+ linuxthreads_pid_to_str (pid)
+     int pid;
+ {
+   static char buf[100];
+ 
+   sprintf (buf, "%s %d%s", linuxthreads_max ? "Thread" : "Pid", pid,
+ 	   (pid == linuxthreads_manager_pid) ? " (manager thread)"
+ 	   : (pid == linuxthreads_initial_pid) ? " (initial thread)"
+ 	   : "");
+ 
+   return buf;
+ }
+ 
+ /* Attach to process PID, then initialize for debugging it
+    and wait for the trace-trap that results from attaching.  */
+ 
+ static void
+ linuxthreads_attach (args, from_tty)
+     char *args;
+     int from_tty;
+ {
+   if (!args)
+     error_no_arg ("process-id to attach");
+ 
+   push_target (&linuxthreads_ops);
+   linuxthreads_breakpoints_inserted = 1;
+   linuxthreads_breakpoint_last = -1;
+   linuxthreads_wait_last = -1;
+   linuxthreads_exit_status = __W_STOPCODE(0);
+ 
+   child_ops.to_attach (args, from_tty);
+ 
+   if (linuxthreads_max)
+     linuxthreads_attach_pending = 1;
+ }
+ 
+ /* Take a program previously attached to and detaches it.
+    The program resumes execution and will no longer stop
+    on signals, etc.  We'd better not have left any breakpoints
+    in the program or it'll die when it hits one.  For this
+    to work, it may be necessary for the process to have been
+    previously attached.  It *might* work if the program was
+    started via the normal ptrace (PTRACE_TRACEME).  */
+ 
+ static void
+ linuxthreads_detach (args, from_tty)
+     char *args;
+     int from_tty;
+ {
+   if (linuxthreads_max)
+     {
+       int i;
+       int pid;
+       int off = 0;
+       target_write_memory (linuxthreads_debug, (char *)&off, sizeof (off));
+ 
+       /* Walk through linuxthreads array in order to detach known threads.  */
+       if (linuxthreads_manager_pid != 0)
+ 	{
+ 	  /* Get rid of all positive zombie breakpoints.  */
+ 	  for (i = 0; i <= linuxthreads_breakpoint_last; i++)
+ 	    {
+ 	      if (linuxthreads_breakpoint_zombie[i].step)
+ 		continue;
+ 
+ 	      pid = linuxthreads_breakpoint_zombie[i].pid;
+ 	      if (!linuxthreads_thread_alive (pid))
+ 		continue;
+ 
+ 	      if (linuxthreads_breakpoint_zombie[i].pc != read_pc_pid (pid))
+ 		continue;
+ 
+ 	      /* Continue in STEP mode until the thread pc has moved or
+ 		 until SIGTRAP is found on the same PC.  */
+ 	      if (linuxthreads_find_trap (pid, 0)
+ 		  && linuxthreads_breakpoint_zombie[i].pc == read_pc_pid (pid))
+ 		write_pc_pid (linuxthreads_breakpoint_zombie[i].pc
+ 			      - DECR_PC_AFTER_BREAK, pid);
+ 	    }
+ 
+ 	  /* Detach thread after thread.  */
+ 	  inferior_pid = linuxthreads_manager_pid;
+ 	  iterate_active_threads (detach_thread, 1);
+ 
+ 	  /* Remove pending SIGTRAP and SIGSTOP */
+ 	  linuxthreads_find_trap (inferior_pid, 1);
+ 
+ 	  linuxthreads_wait_last = -1;
+ 	  linuxthreads_exit_status = __W_STOPCODE(0);
+ 	}
+ 
+       linuxthreads_inferior_pid = 0;
+       linuxthreads_breakpoint_pid = 0;
+       linuxthreads_step_pid = 0;
+       linuxthreads_step_signo = TARGET_SIGNAL_0;
+       linuxthreads_manager_pid = 0;
+       linuxthreads_initial_pid = 0;
+       linuxthreads_attach_pending = 0;
+       init_thread_list ();           /* Destroy thread info */
+     }
+ 
+   child_ops.to_detach (args, from_tty);
+ 
+   unpush_target (&linuxthreads_ops);
+ }
+ 
+ /* Resume execution of process PID.  If STEP is nozero, then
+    just single step it.  If SIGNAL is nonzero, restart it with that
+    signal activated.  */
+ 
+ static void
+ linuxthreads_resume (pid, step, signo)
+     int pid;
+     int step;
+     enum target_signal signo;
+ {
+   if (!linuxthreads_max || stop_soon_quietly || linuxthreads_manager_pid == 0)
+     child_ops.to_resume (pid, step, signo);
+   else
+     {
+       int rpid;
+       if (linuxthreads_inferior_pid)
+ 	{
+ 	  /* Prepare resume of the last thread that hit a breakpoint */
+ 	  linuxthreads_breakpoints_inserted = 0;
+ 	  rpid = linuxthreads_inferior_pid;
+ 	  linuxthreads_step_signo = signo;
+ 	}
+       else
+         {
+ 	  struct cleanup *old_chain = NULL;
+ 	  int i;
+ 
+ 	  if (pid < 0)
+ 	    {
+ 	      linuxthreads_step_pid = step ? inferior_pid : 0;
+ 	      linuxthreads_step_signo = signo;
+ 	      rpid = inferior_pid;
+ 	    }
+ 	  else
+ 	    rpid = pid;
+ 
+ 	  if (pid < 0 || !step)
+ 	    {
+ 	      linuxthreads_breakpoints_inserted = 1;
+ 
+ 	      /* Walk through linuxthreads array in order to resume threads */
+ 	      if (pid >= 0 && inferior_pid != pid)
+ 		{
+ 		  old_chain = save_inferior_pid ();
+ 		  inferior_pid = pid;
+ 		}
+ 
+ 	      iterate_active_threads (resume_thread, 0);
+ 	      if (linuxthreads_manager_pid != inferior_pid
+ 		  && !linuxthreads_pending_status (linuxthreads_manager_pid))
+ 		resume_thread (linuxthreads_manager_pid);
+ 	    }
+ 	  else
+ 	    linuxthreads_breakpoints_inserted = 0;
+ 
+ 	  /* Deal with zombie breakpoint */
+ 	  for (i = 0; i <= linuxthreads_breakpoint_last; i++)
+ 	    if (linuxthreads_breakpoint_zombie[i].pid == rpid)
+ 	      {
+ 		if (linuxthreads_breakpoint_zombie[i].pc != read_pc_pid (rpid))
+ 		  {
+ 		    /* The current pc is out of zombie breakpoint.  */
+ 		    REMOVE_BREAKPOINT_ZOMBIE(i);
+ 		  }
+ 		break;
+ 	      }
+ 
+ 	  if (old_chain != NULL)
+ 	    do_cleanups (old_chain);
+ 	}
+ 
+       /* Resume initial thread. */
+       if (!linuxthreads_pending_status (rpid))
+ 	child_ops.to_resume (rpid, step, signo);
+     }
+ }
+ 
+ /* Wait for any threads to stop.  We may have to convert PID from a thread id
+    to a LWP id, and vice versa on the way out.  */
+ 
+ static int
+ linuxthreads_wait (int pid, struct target_waitstatus *ourstatus)
+ {
+   int status;
+   int rpid;
+   int i;
+   int last;
+   int *wstatus;
+ 
+   if (linuxthreads_max && !linuxthreads_breakpoints_inserted)
+     wstatus = alloca (LINUXTHREAD_NSIG * sizeof (int));
+ 
+   /* See if the inferior has chosen values for its signals yet.  By
+      checking for them here, we can be sure we've updated GDB's signal
+      handling table before the inferior ever gets one of them.  (Well,
+      before we notice, anyway.)  */
+   check_all_signal_numbers ();
+ 
+   for (;;)
+     {
+       if (!linuxthreads_max)
+ 	  rpid = 0;
+       else if (!linuxthreads_breakpoints_inserted)
+ 	{
+ 	  if (linuxthreads_inferior_pid)
+ 	    pid = linuxthreads_inferior_pid;
+ 	  else if (pid < 0)
+ 	    pid = inferior_pid;
+ 	  last = rpid = 0;
+ 	}
+       else if (pid < 0 && linuxthreads_wait_last >= 0)
+ 	{
+ 	  status = linuxthreads_wait_status[linuxthreads_wait_last];
+ 	  rpid = linuxthreads_wait_pid[linuxthreads_wait_last--];
+         }
+       else if (pid > 0 && linuxthreads_pending_status (pid))
+ 	{
+ 	  for (i = linuxthreads_wait_last; i >= 0; i--)
+ 	    if (linuxthreads_wait_pid[i] == pid)
+ 		break;
+ 	  if (i < 0)
+ 	    rpid = 0;
+ 	  else
+ 	    {
+ 	      status = linuxthreads_wait_status[i];
+ 	      rpid = pid;
+ 	      if (i < linuxthreads_wait_last)
+ 		{
+ 		  linuxthreads_wait_status[i] =
+ 		    linuxthreads_wait_status[linuxthreads_wait_last];
+ 		  linuxthreads_wait_pid[i] =
+ 		    linuxthreads_wait_pid[linuxthreads_wait_last];
+ 		}
+ 	      linuxthreads_wait_last--;
+ 	    }
+ 	}
+       else
+ 	  rpid = 0;
+ 
+       if (rpid == 0)
+ 	{
+ 	  int save_errno;
+ 	  sigset_t omask;
+ 
+ 	  set_sigint_trap();	/* Causes SIGINT to be passed on to the
+ 				   attached process. */
+ 	  set_sigio_trap ();
+ 
+ 	  sigprocmask(SIG_BLOCK, &linuxthreads_wait_mask, &omask);
+ 	  for (;;)
+ 	    {
+ 	      rpid = waitpid (pid, &status, __WCLONE | WNOHANG);
+ 	      if (rpid > 0)
+ 		break;
+ 	      if (rpid == 0)
+ 		save_errno = 0;
+ 	      else if (errno != EINTR)
+ 		save_errno = errno;
+ 	      else
+ 		continue;
+ 
+ 	      rpid = waitpid (pid, &status, WNOHANG);
+ 	      if (rpid > 0)
+ 		break;
+ 	      if (rpid < 0)
+ 		if (errno == EINTR)
+ 		  continue;
+ 		else if (save_errno != 0)
+ 		  break;
+ 
+ 	      sigsuspend(&omask);
+ 	    }
+ 	  sigprocmask(SIG_SETMASK, &omask, NULL);
+ 
+ 	  save_errno = errno;
+ 	  clear_sigio_trap ();
+ 
+ 	  clear_sigint_trap();
+ 
+ 	  if (rpid == -1)
+ 	    {
+ 	      if (WIFEXITED(linuxthreads_exit_status))
+ 		{
+ 		  store_waitstatus (ourstatus, linuxthreads_exit_status);
+ 		  return inferior_pid;
+ 		}
+ 	      else
+ 		{
+ 		  fprintf_unfiltered
+ 		      (gdb_stderr, "Child process unexpectedly missing: %s.\n",
+ 		       safe_strerror (save_errno));
+ 		  /* Claim it exited with unknown signal.  */
+ 		  ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
+ 		  ourstatus->value.sig = TARGET_SIGNAL_UNKNOWN;
+ 		  return -1;
+ 		}
+ 	    }
+ 
+ 	  /* Signals arrive in any order.  So get all signals until SIGTRAP
+ 	     and resend previous ones to be held after.  */
+ 	  if (linuxthreads_max
+ 	      && !linuxthreads_breakpoints_inserted
+ 	      && WIFSTOPPED(status))
+ 	    if (WSTOPSIG(status) == SIGTRAP)
+ 	      {
+ 		while (--last >= 0)
+ 		  kill (rpid, WSTOPSIG(wstatus[last]));
+ 
+ 		/* insert negative zombie breakpoint */
+ 		for (i = 0; i <= linuxthreads_breakpoint_last; i++)
+ 		  if (linuxthreads_breakpoint_zombie[i].pid == rpid)
+ 		      break;
+ 		if (i > linuxthreads_breakpoint_last)
+ 		  {
+ 		    linuxthreads_breakpoint_zombie[i].pid = rpid;
+ 		    linuxthreads_breakpoint_last++;
+ 		  }
+ 		linuxthreads_breakpoint_zombie[i].pc = read_pc_pid (rpid);
+ 		linuxthreads_breakpoint_zombie[i].step = 1;
+ 	      }
+ 	    else
+ 	      {
+ 		if (WSTOPSIG(status) != SIGSTOP)
+ 		  {
+ 		    for (i = 0; i < last; i++)
+ 		      if (wstatus[i] == status)
+ 			break;
+ 		    if (i >= last)
+ 		      wstatus[last++] = status;
+ 		  }
+ 		child_resume (rpid, 1, TARGET_SIGNAL_0);
+ 		continue;
+ 	      }
+ 	  if (linuxthreads_inferior_pid)
+ 	    linuxthreads_inferior_pid = 0;
+ 	}
+ 
+       if (linuxthreads_max && !stop_soon_quietly)
+ 	{
+ 	  if (linuxthreads_max
+ 	      && WIFSTOPPED(status)
+ 	      && WSTOPSIG(status) == SIGSTOP)
+ 	    {
+ 	      /* Skip SIGSTOP signals.  */
+ 	      if (!linuxthreads_pending_status (rpid))
+ 		if (linuxthreads_step_pid == rpid)
+ 		  child_resume (rpid, 1, linuxthreads_step_signo);
+ 		else
+ 		  child_resume (rpid, 0, TARGET_SIGNAL_0);
+ 	      continue;
+ 	    }
+ 
+ 	  /* Do no report exit status of cloned threads.  */
+ 	  if (WIFEXITED(status))
+ 	    {
+ 	      if (rpid == linuxthreads_initial_pid)
+ 		linuxthreads_exit_status = status;
+ 
+ 	      /* Remove any zombie breakpoint.  */
+ 	      for (i = 0; i <= linuxthreads_breakpoint_last; i++)
+ 		if (linuxthreads_breakpoint_zombie[i].pid == rpid)
+ 		  {
+ 		    REMOVE_BREAKPOINT_ZOMBIE(i);
+ 		    break;
+ 		  }
+ 	      if (pid > 0)
+ 		pid = -1;
+ 	      continue;
+ 	    }
+ 
+ 	  /* Deal with zombie breakpoint */
+ 	  for (i = 0; i <= linuxthreads_breakpoint_last; i++)
+ 	    if (linuxthreads_breakpoint_zombie[i].pid == rpid)
+ 	      break;
+ 
+ 	  if (i <= linuxthreads_breakpoint_last)
+ 	    {
+ 	      /* There is a potential zombie breakpoint */
+ 	      if (WIFEXITED(status)
+ 		  || linuxthreads_breakpoint_zombie[i].pc != read_pc_pid (rpid))
+ 	        {
+ 		  /* The current pc is out of zombie breakpoint.  */
+ 		  REMOVE_BREAKPOINT_ZOMBIE(i);
+ 		}
+ 	      else if (!linuxthreads_breakpoint_zombie[i].step
+ 		       && WIFSTOPPED(status) && WSTOPSIG(status) == SIGTRAP)
+ 	        {
+ 		  /* This is a real one ==> decrement PC and restart.  */
+ 		  write_pc_pid (linuxthreads_breakpoint_zombie[i].pc
+ 				- DECR_PC_AFTER_BREAK, rpid);
+ 		  if (linuxthreads_step_pid == rpid)
+ 		    child_resume (rpid, 1, linuxthreads_step_signo);
+ 		  else
+ 		    child_resume (rpid, 0, TARGET_SIGNAL_0);
+ 		  continue;
+ 		}
+ 	    }
+ 
+ 	  /* Walk through linuxthreads array in order to stop them */
+ 	  if (linuxthreads_breakpoints_inserted)
+ 	    update_stop_threads (rpid);
+ 
+ 	}
+       else if (rpid != inferior_pid)
+ 	continue;
+ 
+       store_waitstatus (ourstatus, status);
+ 
+       if (linuxthreads_attach_pending && !stop_soon_quietly)
+         {
+ 	  int on = 1;
+ 	  target_write_memory (linuxthreads_debug, (char *)&on, sizeof (on));
+ 	  update_stop_threads (rpid);
+ 	  linuxthreads_attach_pending = 0;
+         }
+ 
+       if (linuxthreads_breakpoints_inserted
+ 	  && WIFSTOPPED(status)
+ 	  && WSTOPSIG(status) == SIGTRAP)
+ 	linuxthreads_breakpoint_pid = rpid;
+       else if (linuxthreads_breakpoint_pid)
+ 	linuxthreads_breakpoint_pid = 0;
+ 
+       return rpid;
+     }
+ }
+ 
+ /* Fork an inferior process, and start debugging it with ptrace.  */
+ 
+ static void
+ linuxthreads_create_inferior (exec_file, allargs, env)
+     char *exec_file;
+     char *allargs;
+     char **env;
+ {
+   if (!exec_file && !exec_bfd)
+     {
+       error ("No executable file specified.\n\
+ Use the \"file\" or \"exec-file\" command.");
+       return;
+     }
+ 
+   push_target (&linuxthreads_ops);
+   linuxthreads_breakpoints_inserted = 1;
+   linuxthreads_breakpoint_last = -1;
+   linuxthreads_wait_last = -1;
+   linuxthreads_exit_status = __W_STOPCODE(0);
+   
+   if (linuxthreads_max)
+     linuxthreads_attach_pending = 1;
+ 
+   child_ops.to_create_inferior (exec_file, allargs, env);
+ }
+ 
+ /* Clean up after the inferior dies.  */
+ 
+ static void
+ linuxthreads_mourn_inferior ()
+ {
+   if (linuxthreads_max)
+     {
+       int off = 0;
+       target_write_memory (linuxthreads_debug, (char *)&off, sizeof (off));
+ 
+       linuxthreads_inferior_pid = 0;
+       linuxthreads_breakpoint_pid = 0;
+       linuxthreads_step_pid = 0;
+       linuxthreads_step_signo = TARGET_SIGNAL_0;
+       linuxthreads_manager_pid = 0;
+       linuxthreads_initial_pid = 0;
+       linuxthreads_attach_pending = 0;
+       init_thread_list();           /* Destroy thread info */
+     }
+ 
+   child_ops.to_mourn_inferior ();
+ 
+   unpush_target (&linuxthreads_ops);
+ }
+ 
+ /* Kill the inferior process */
+ 
+ static void
+ linuxthreads_kill ()
+ {
+   int rpid;
+   int status;
+ 
+   if (inferior_pid == 0)
+     return;
+ 
+   if (linuxthreads_max && linuxthreads_manager_pid != 0)
+     {
+       /* Remove all threads status.  */
+       inferior_pid = linuxthreads_manager_pid;
+       iterate_active_threads (kill_thread, 1);
+     }
+ 
+   kill_thread (inferior_pid);
+ 
+ #if 0
+   /* doing_quit_force solves a real problem, but I think a properly
+      placed call to catch_errors would do the trick much more cleanly.  */
+   if (doing_quit_force >= 0)
+     {
+       if (linuxthreads_max && linuxthreads_manager_pid != 0)
+ 	{
+ 	  /* Wait for thread to complete */
+ 	  while ((rpid = waitpid (-1, &status, __WCLONE)) > 0)
+ 	    if (!WIFEXITED(status))
+ 	      kill_thread (rpid);
+ 
+ 	  while ((rpid = waitpid (-1, &status, 0)) > 0)
+ 	    if (!WIFEXITED(status))
+ 	      kill_thread (rpid);
+ 	}
+       else
+ 	while ((rpid = waitpid (inferior_pid, &status, 0)) > 0)
+ 	  if (!WIFEXITED(status))
+ 	    ptrace (PT_KILL, inferior_pid, (PTRACE_ARG3_TYPE) 0, 0);
+     }
+ #endif
+ 
+   /* Wait for all threads. */
+   do
+     rpid = waitpid (-1, &status, __WCLONE | WNOHANG);
+   while (rpid > 0 || errno == EINTR);
+ 
+   do
+     rpid = waitpid (-1, &status, WNOHANG);
+   while (rpid > 0 || errno == EINTR);
+ 
+   linuxthreads_mourn_inferior ();
+ }
+ 
+ /* Insert a breakpoint */
+ 
+ static int
+ linuxthreads_insert_breakpoint (addr, contents_cache)
+     CORE_ADDR addr;
+     char *contents_cache;
+ {
+   if (linuxthreads_max && linuxthreads_manager_pid != 0)
+     {
+       linuxthreads_breakpoint_addr = addr;
+       iterate_active_threads (insert_breakpoint, 1);
+       insert_breakpoint (linuxthreads_manager_pid);
+     }
+ 
+   return child_ops.to_insert_breakpoint (addr, contents_cache);
+ }
+ 
+ /* Remove a breakpoint */
+ 
+ static int
+ linuxthreads_remove_breakpoint (addr, contents_cache)
+     CORE_ADDR addr;
+     char *contents_cache;
+ {
+   if (linuxthreads_max && linuxthreads_manager_pid != 0)
+     {
+       linuxthreads_breakpoint_addr = addr;
+       iterate_active_threads (remove_breakpoint, 1);
+       remove_breakpoint (linuxthreads_manager_pid);
+     }
+ 
+   return child_ops.to_remove_breakpoint (addr, contents_cache);
+ }
+ 
+ /* Mark our target-struct as eligible for stray "run" and "attach" commands.  */
+ 
+ static int
+ linuxthreads_can_run ()
+ {
+   return child_suppress_run;
+ }
+ \f
+ static void
+ init_linuxthreads_ops ()
+ {
+   linuxthreads_ops.to_shortname = "linuxthreads";
+   linuxthreads_ops.to_longname  = "LINUX threads and pthread.";
+   linuxthreads_ops.to_doc       = "LINUX threads and pthread support.";
+   linuxthreads_ops.to_attach    = linuxthreads_attach;
+   linuxthreads_ops.to_detach    = linuxthreads_detach;
+   linuxthreads_ops.to_resume    = linuxthreads_resume;
+   linuxthreads_ops.to_wait      = linuxthreads_wait;
+   linuxthreads_ops.to_kill      = linuxthreads_kill;
+   linuxthreads_ops.to_can_run   = linuxthreads_can_run;
+   linuxthreads_ops.to_stratum   = thread_stratum;
+   linuxthreads_ops.to_insert_breakpoint = linuxthreads_insert_breakpoint;
+   linuxthreads_ops.to_remove_breakpoint = linuxthreads_remove_breakpoint;
+   linuxthreads_ops.to_create_inferior   = linuxthreads_create_inferior;
+   linuxthreads_ops.to_mourn_inferior    = linuxthreads_mourn_inferior;
+   linuxthreads_ops.to_thread_alive      = linuxthreads_thread_alive;
+   linuxthreads_ops.to_magic             = OPS_MAGIC;
+ }
+ 
+ void
+ _initialize_linuxthreads ()
+ {
+   struct sigaction sact;
+ 
+   init_linuxthreads_ops ();
+   add_target (&linuxthreads_ops);
+   child_suppress_run = 1;
+ 
+   /* Attach SIGCHLD handler */
+   sact.sa_handler = sigchld_handler;
+   sigemptyset (&sact.sa_mask);
+   sact.sa_flags = 0;
+   sigaction (SIGCHLD, &sact, NULL);
+ 
+   /* initialize SIGCHLD mask */
+   sigemptyset (&linuxthreads_wait_mask);
+   sigaddset (&linuxthreads_wait_mask, SIGCHLD);
+ }
diff -Ncr /home/kingdon/work/gdb/gdb/target.c ./gdb/target.c
*** /home/kingdon/work/gdb/gdb/target.c	Thu Aug 12 11:13:38 1999
--- ./gdb/target.c	Sat Aug 14 19:49:45 1999
***************
*** 1238,1243 ****
--- 1238,1244 ----
    {"SIG61", "Real-time event 61"},
    {"SIG62", "Real-time event 62"},
    {"SIG63", "Real-time event 63"},
+   {"SIG32", "Real-time event 32"},
  
  #if defined(MACH) || defined(__MACH__)
    /* Mach exceptions */
***************
*** 1571,1578 ****
  
  #if defined (REALTIME_LO)
    if (hostsig >= REALTIME_LO && hostsig < REALTIME_HI)
!     return (enum target_signal)
!       (hostsig - 33 + (int) TARGET_SIGNAL_REALTIME_33);
  #endif
    return TARGET_SIGNAL_UNKNOWN;
  }
--- 1572,1587 ----
  
  #if defined (REALTIME_LO)
    if (hostsig >= REALTIME_LO && hostsig < REALTIME_HI)
!     {
!       /* This block of TARGET_SIGNAL_REALTIME value is in order.  */
!       if (33 <= hostsig && hostsig <= 63)
! 	return (enum target_signal)
! 	  (hostsig - 33 + (int) TARGET_SIGNAL_REALTIME_33);
!       else if (hostsig == 32)
! 	return TARGET_SIGNAL_REALTIME_32;
!       else
! 	error ("GDB bug: target.c (target_signal_from_host): unrecognized real-time signal");
!     }
  #endif
    return TARGET_SIGNAL_UNKNOWN;
  }
***************
*** 1619,1624 ****
--- 1628,1635 ----
      case TARGET_SIGNAL_PRIO:
        return SIGPRIO;
  #endif
+ 
+     case TARGET_SIGNAL_REALTIME_32: return 32; /* by definition */ 
  
        /* Mach exceptions.  Assumes that the values for EXC_ are positive! */
  #if defined (EXC_BAD_ACCESS) && defined (_NSIG)
diff -Ncr /home/kingdon/work/gdb/gdb/target.h ./gdb/target.h
*** /home/kingdon/work/gdb/gdb/target.h	Thu Aug 12 11:13:38 1999
--- ./gdb/target.h	Sat Aug 14 19:07:48 1999
***************
*** 48,54 ****
  	file_stratum,		/* Executable files, etc */
  	core_stratum,		/* Core dump files */
  	download_stratum,	/* Downloading of remote targets */
! 	process_stratum		/* Executing processes */
  };
  
  enum thread_control_capabilities {
--- 48,55 ----
  	file_stratum,		/* Executable files, etc */
  	core_stratum,		/* Core dump files */
  	download_stratum,	/* Downloading of remote targets */
! 	process_stratum,	/* Executing processes */
! 	thread_stratum		/* Executing threads */
  };
  
  enum thread_control_capabilities {
***************
*** 214,219 ****
--- 215,227 ----
    TARGET_EXC_SOFTWARE = 80,
    TARGET_EXC_BREAKPOINT = 81,
  #endif
+ 
+   /* Yes, this pains me, too.  But LynxOS didn't have SIG32, and now
+      Linux does, and we can't disturb the numbering, since it's part
+      of the protocol.  Note that in some GDB's TARGET_SIGNAL_REALTIME_32
+      is number 76.  */
+   TARGET_SIGNAL_REALTIME_32,
+ 
    /* Some signal we don't know about.  */
    TARGET_SIGNAL_UNKNOWN,