* breakpoint.c (breakpoint_thread_match break_command_1):

Thread-specific breakpoint support.
* breakpoint.h (struct breakpoint):  Add thread id field.
* fork-child.c (fork_inferior):  Move call to init_thread_list()
back a bit so that init_trace_fun can do thread functions.
* hppa-tdep.c (restore_pc_queue):  Add pid to call to target_wait.
* hppab-nat.c (child_resume):  Handle default pid.
* hppah-nat.c (child_resume):  Handle default pid.
* i386lynx-nat.c (child_wait):  New arg pid.
* inflow.c (kill_command):  Reset thread list.
* infptrace.c (child_resume):  Handle default pid.
* infrun.c:  Thread-specific breakpoint support.
* inftarg.c (child_wait):  Add pid arg.
* osfsolib.c (solib_create_inferior_hook):  Add pid to call to
target_resume.
* procfs.c:  Multi-thread support.
* remote-bug.c (bug_wait):  Add pid arg.
* remote-hms.c (hms_wait):  Add pid arg.
* remote-mips.c (mips_wait):  Add pid arg.
* remote-mon.c (monitor_wait):  Add pid arg.
* remote-nindy.c (nindy_wait):  Add pid arg.
* remote-sim.c (gdbsim_wait):  Add pid arg.
* remote-udi.c (udi_wait):  Add pid arg.
* remote-vx.c (vx_wait):  Add pid arg.
* remote-z8k.c (sim_wait):  Add pid arg.
* remote.c (remote_wait):  Add pid arg.
* solib.c (solib_create_inferior_hook):  Add pid to call to
target_resume.
* target.h (struct target_ops):  Add pid arg to to_wait and
to_notice_signals.
* thread.c (valid_thread_id):  New func to validate thread #s.
* (pid_to_thread_id):  New func to do the obvious.
* thread.h:  Prototypes for above.

* coff-solib.c (coff_solib_add):  Use nameoffset field to locate
filename.

1 files changed, 57 insertions, 231 deletions

diff --git a/gdb/inftarg.c b/gdb/inftarg.c
index e357c0e..3270fa6 100644
--- a/gdb/inftarg.c
+++ b/gdb/inftarg.c
@@ -24,23 +24,16 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 #include "target.h"
 #include "wait.h"
 #include "gdbcore.h"
-#include "ieee-float.h"		/* Required by REGISTER_CONVERT_TO_XXX */
-#include "terminal.h"		/* For #ifdef TIOCGPGRP and new_tty */
 
 #include <signal.h>
 
-#ifdef SET_STACK_LIMIT_HUGE
-#include <sys/time.h>
-#include <sys/resource.h>
-
-extern int original_stack_limit;
-#endif /* SET_STACK_LIMIT_HUGE */
-
 static void
 child_prepare_to_store PARAMS ((void));
 
+#ifndef CHILD_WAIT
 static int
 child_wait PARAMS ((int *));
+#endif /* CHILD_WAIT */
 
 static void
 child_open PARAMS ((char *, int));
@@ -55,6 +48,12 @@ static void
 child_attach PARAMS ((char *, int));
 
 static void
+ptrace_me PARAMS ((void));
+
+static void
+ptrace_him PARAMS ((int));
+
+static void
 child_create_inferior PARAMS ((char *, char *, char **));
 
 static void
@@ -68,31 +67,41 @@ extern char **environ;
 /* Forward declaration */
 extern struct target_ops child_ops;
 
+#ifndef CHILD_WAIT
+
 /* Wait for child to do something.  Return pid of child, or -1 in case
    of error; store status through argument pointer STATUS.  */
 
 static int
-child_wait (status)
+child_wait (pid, status)
+     int pid;
      int *status;
 {
-  int pid;
+  int save_errno;
 
   do {
-#ifdef USE_PROC_FS
-    pid = proc_wait (status);
-#else
+    if (attach_flag)
+      set_sigint_trap();	/* Causes SIGINT to be passed on to the
+				   attached process. */
     pid = wait (status);
-#endif
-    if (pid == -1)		/* No more children to wait for */
+    save_errno = errno;
+
+    if (attach_flag)
+      clear_sigint_trap();
+
+    if (pid == -1)
       {
-	fprintf (stderr, "Child process unexpectedly missing.\n");
+	if (save_errno == EINTR)
+	  continue;
+	fprintf (stderr, "Child process unexpectedly missing: %s.\n",
+		 safe_strerror (save_errno));
 	*status = 42;	/* Claim it exited with signal 42 */
         return -1;
       }
   } while (pid != inferior_pid); /* Some other child died or stopped */
   return pid;
 }
-
+#endif /* CHILD_WAIT */
 
 /* Attach to process PID, then initialize for debugging it.  */
 
@@ -120,9 +129,9 @@ child_attach (args, from_tty)
       exec_file = (char *) get_exec_file (0);
 
       if (exec_file)
-	printf ("Attaching program `%s', pid %d\n", exec_file, pid);
+	printf ("Attaching to program `%s', %s\n", exec_file, target_pid_to_str (pid));
       else
-	printf ("Attaching pid %d\n", pid);
+	printf ("Attaching to %s\n", target_pid_to_str (pid));
 
       fflush (stdout);
     }
@@ -155,8 +164,8 @@ child_detach (args, from_tty)
       char *exec_file = get_exec_file (0);
       if (exec_file == 0)
 	exec_file = "";
-      printf ("Detaching program: %s pid %d\n",
-	      exec_file, inferior_pid);
+      printf ("Detaching from program: %s %s\n", exec_file,
+	      target_pid_to_str (inferior_pid));
       fflush (stdout);
     }
   if (args)
@@ -190,8 +199,8 @@ static void
 child_files_info (ignore)
      struct target_ops *ignore;
 {
-  printf ("\tUsing the running image of %s process %d.\n",
-	  attach_flag? "attached": "child", inferior_pid);
+  printf ("\tUsing the running image of %s %s.\n",
+	  attach_flag? "attached": "child", target_pid_to_str (inferior_pid));
 }
 
 /* ARGSUSED */
@@ -203,224 +212,40 @@ child_open (arg, from_tty)
   error ("Use the \"run\" command to start a Unix child process.");
 }
 
+/* Stub function which causes the inferior that runs it, to be ptrace-able
+   by its parent process.  */
+
+static void
+ptrace_me ()
+{
+  /* "Trace me, Dr. Memory!" */
+  call_ptrace (0, 0, (PTRACE_ARG3_TYPE) 0, 0);
+}
+
+/* Stub function which causes the GDB that runs it, to start ptrace-ing
+   the child process.  */
+
+static void
+ptrace_him (pid)
+     int pid;
+{
+  push_target (&child_ops);
+}
+
 /* Start an inferior Unix child process and sets inferior_pid to its pid.
    EXEC_FILE is the file to run.
    ALLARGS is a string containing the arguments to the program.
    ENV is the environment vector to pass.  Errors reported with error().  */
 
-#ifndef SHELL_FILE
-#define SHELL_FILE "/bin/sh"
-#endif
-
 static void
 child_create_inferior (exec_file, allargs, env)
      char *exec_file;
      char *allargs;
      char **env;
 {
-  int pid;
-  char *shell_command;
-  char *shell_file;
-  static char default_shell_file[] = SHELL_FILE;
-  int len;
-  int pending_execs;
-  /* Set debug_fork then attach to the child while it sleeps, to debug. */
-  static int debug_fork = 0;
-  /* This is set to the result of setpgrp, which if vforked, will be visible
-     to you in the parent process.  It's only used by humans for debugging.  */
-  static int debug_setpgrp = 657473;
-  char **save_our_env;
-
-  /* If no exec file handed to us, get it from the exec-file command -- with
-     a good, common error message if none is specified.  */
-  if (exec_file == 0)
-    exec_file = get_exec_file(1);
-
-  /* The user might want tilde-expansion, and in general probably wants
-     the program to behave the same way as if run from
-     his/her favorite shell.  So we let the shell run it for us.
-     FIXME, this should probably search the local environment (as
-     modified by the setenv command), not the env gdb inherited.  */
-  shell_file = getenv ("SHELL");
-  if (shell_file == NULL)
-    shell_file = default_shell_file;
-  
-  len = 5 + strlen (exec_file) + 1 + strlen (allargs) + 1 + /*slop*/ 10;
-  /* If desired, concat something onto the front of ALLARGS.
-     SHELL_COMMAND is the result.  */
-#ifdef SHELL_COMMAND_CONCAT
-  shell_command = (char *) alloca (strlen (SHELL_COMMAND_CONCAT) + len);
-  strcpy (shell_command, SHELL_COMMAND_CONCAT);
-#else
-  shell_command = (char *) alloca (len);
-  shell_command[0] = '\0';
-#endif
-  strcat (shell_command, "exec ");
-  strcat (shell_command, exec_file);
-  strcat (shell_command, " ");
-  strcat (shell_command, allargs);
-
-  /* exec is said to fail if the executable is open.  */
-  close_exec_file ();
-
-  /* Retain a copy of our environment variables, since the child will
-     replace the value of  environ  and if we're vforked, we have to 
-     restore it.  */
-  save_our_env = environ;
-
-  /* Tell the terminal handling subsystem what tty we plan to run on;
-     it will just record the information for later.  */
-
-  new_tty_prefork (inferior_io_terminal);
-
-  /* It is generally good practice to flush any possible pending stdio
-     output prior to doing a fork, to avoid the possibility of both the
-     parent and child flushing the same data after the fork. */
-
-  fflush (stdout);
-  fflush (stderr);
-
-#if defined(USG) && !defined(HAVE_VFORK)
-  pid = fork ();
-#else
-  if (debug_fork)
-    pid = fork ();
-  else
-    pid = vfork ();
-#endif
-
-  if (pid < 0)
-    perror_with_name ("vfork");
-
-  if (pid == 0)
-    {
-      if (debug_fork) 
-	sleep (debug_fork);
-
-#ifdef TIOCGPGRP
-      /* Run inferior in a separate process group.  */
-#ifdef NEED_POSIX_SETPGID
-      debug_setpgrp = setpgid (0, 0);
-#else
-#if defined(USG) && !defined(SETPGRP_ARGS)
-      debug_setpgrp = setpgrp ();
-#else
-      debug_setpgrp = setpgrp (getpid (), getpid ());
-#endif /* USG */
-#endif /* NEED_POSIX_SETPGID */
-      if (debug_setpgrp == -1)
-	 perror("setpgrp failed in child");
-#endif /* TIOCGPGRP */
-
-#ifdef SET_STACK_LIMIT_HUGE
-      /* Reset the stack limit back to what it was.  */
-      {
-	struct rlimit rlim;
-
-	getrlimit (RLIMIT_STACK, &rlim);
-	rlim.rlim_cur = original_stack_limit;
-	setrlimit (RLIMIT_STACK, &rlim);
-      }
-#endif /* SET_STACK_LIMIT_HUGE */
-
-      /* Ask the tty subsystem to switch to the one we specified earlier
-	 (or to share the current terminal, if none was specified).  */
-
-      new_tty ();
-
-      /* Changing the signal handlers for the inferior after
-	 a vfork can also change them for the superior, so we don't mess
-	 with signals here.  See comments in
-	 initialize_signals for how we get the right signal handlers
-	 for the inferior.  */
-
-#ifdef USE_PROC_FS
-      /* Use SVR4 /proc interface */
-      proc_set_exec_trap ();
-#else
-      /* "Trace me, Dr. Memory!" */
-      call_ptrace (0, 0, (PTRACE_ARG3_TYPE) 0, 0);
-#endif
-
-      /* There is no execlpe call, so we have to set the environment
-	 for our child in the global variable.  If we've vforked, this
-	 clobbers the parent, but environ is restored a few lines down
-	 in the parent.  By the way, yes we do need to look down the
-	 path to find $SHELL.  Rich Pixley says so, and I agree.  */
-      environ = env;
-      execlp (shell_file, shell_file, "-c", shell_command, (char *)0);
-
-      fprintf (stderr, "Cannot exec %s: %s.\n", shell_file,
-	       safe_strerror (errno));
-      fflush (stderr);
-      _exit (0177);
-    }
-
-  /* Restore our environment in case a vforked child clob'd it.  */
-  environ = save_our_env;
-
-  /* Now that we have a child process, make it our target.  */
-  push_target (&child_ops);
-
-#ifdef CREATE_INFERIOR_HOOK
-  CREATE_INFERIOR_HOOK (pid);
-#endif  
-
-/* The process was started by the fork that created it,
-   but it will have stopped one instruction after execing the shell.
-   Here we must get it up to actual execution of the real program.  */
-
-  inferior_pid = pid;		/* Needed for wait_for_inferior stuff below */
-
-  clear_proceed_status ();
-
-  /* We will get a trace trap after one instruction.
-     Continue it automatically.  Eventually (after shell does an exec)
-     it will get another trace trap.  Then insert breakpoints and continue.  */
-
-#ifdef START_INFERIOR_TRAPS_EXPECTED
-  pending_execs = START_INFERIOR_TRAPS_EXPECTED;
-#else
-  pending_execs = 2;
-#endif
-
-  init_wait_for_inferior ();
-
-  /* Set up the "saved terminal modes" of the inferior
-     based on what modes we are starting it with.  */
-  target_terminal_init ();
-
-  /* Install inferior's terminal modes.  */
-  target_terminal_inferior ();
-
-  while (1)
-    {
-      stop_soon_quietly = 1;	/* Make wait_for_inferior be quiet */
-      wait_for_inferior ();
-      if (stop_signal != SIGTRAP)
-	{
-	  /* Let shell child handle its own signals in its own way */
-	  /* FIXME, what if child has exit()ed?  Must exit loop somehow */
-	  resume (0, stop_signal);
-	}
-      else
-	{
-	  /* We handle SIGTRAP, however; it means child did an exec.  */
-	  if (0 == --pending_execs)
-	    break;
-	  resume (0, 0);		/* Just make it go on */
-	}
-    }
-  stop_soon_quietly = 0;
-
-  /* We are now in the child process of interest, having exec'd the
-     correct program, and are poised at the first instruction of the
-     new program.  */
-#ifdef SOLIB_CREATE_INFERIOR_HOOK
-  SOLIB_CREATE_INFERIOR_HOOK (pid);
-#endif
-
-  /* Pedal to the metal.  Away we go.  */
+  fork_inferior (exec_file, allargs, env, ptrace_me, ptrace_him);
+  /* We are at the first instruction we care about.  */
+  /* Pedal to the metal... */
   proceed ((CORE_ADDR) -1, 0, 0);
 }
 
@@ -465,6 +290,7 @@ struct target_ops child_ops = {
   child_create_inferior,	/* to_create_inferior */
   child_mourn_inferior,		/* to_mourn_inferior */
   child_can_run,		/* to_can_run */
+  0, 				/* to_notice_signals */
   process_stratum,		/* to_stratum */
   0,				/* to_next */
   1,				/* to_has_all_memory */