Merge to Cygnus 961112 + add some support (not ready) for shared libs

1 files changed, 411 insertions, 0 deletions

diff --git a/gnu/usr.bin/binutils/gdb/inftarg.c b/gnu/usr.bin/binutils/gdb/inftarg.c
new file mode 100644
index 00000000000..ccbba1661d2
--- /dev/null
+++ b/gnu/usr.bin/binutils/gdb/inftarg.c
@@ -0,0 +1,411 @@
+/* Target-vector operations for controlling Unix child processes, for GDB.
+   Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996
+   Free Software Foundation, Inc.
+   Contributed by Cygnus Support.
+
+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.  */
+
+#include "defs.h"
+#include "frame.h"  /* required by inferior.h */
+#include "inferior.h"
+#include "target.h"
+#include "wait.h"
+#include "gdbcore.h"
+#include "command.h"
+#include <signal.h>
+#include <sys/types.h>
+#include <fcntl.h>
+
+static void
+child_prepare_to_store PARAMS ((void));
+
+#ifndef CHILD_WAIT
+static int child_wait PARAMS ((int, struct target_waitstatus *));
+#endif /* CHILD_WAIT */
+
+static void child_open PARAMS ((char *, int));
+
+static void
+child_files_info PARAMS ((struct target_ops *));
+
+static void
+child_detach PARAMS ((char *, int));
+
+static void
+child_attach PARAMS ((char *, int));
+
+static void
+ptrace_me PARAMS ((void));
+
+static int
+ptrace_him PARAMS ((int));
+
+static void child_create_inferior PARAMS ((char *, char *, char **));
+
+static void
+child_mourn_inferior PARAMS ((void));
+
+static int
+child_can_run PARAMS ((void));
+
+static int
+proc_wait PARAMS ((int, int*));
+
+static void
+child_stop PARAMS ((void));
+
+#ifndef CHILD_THREAD_ALIVE
+static int child_thread_alive PARAMS ((int));
+#endif
+
+extern char **environ;
+
+/* Forward declaration */
+extern struct target_ops child_ops;
+
+int child_suppress_run = 0;	/* Non-zero if inftarg should pretend not to
+				   be a runnable target.  Used by targets
+				   that can sit atop inftarg, such as HPUX
+				   thread support.  */
+static int
+proc_wait (pid, status)
+     int pid;
+     int *status;
+{
+#ifndef __GO32__
+  return wait (status);
+#endif
+}
+
+#ifndef CHILD_WAIT
+
+/* Wait for child to do something.  Return pid of child, or -1 in case
+   of error; store status through argument pointer OURSTATUS.  */
+
+static int
+child_wait (pid, ourstatus)
+     int pid;
+     struct target_waitstatus *ourstatus;
+{
+  int save_errno;
+  int status;
+
+  do {
+    set_sigint_trap();	/* Causes SIGINT to be passed on to the
+			   attached process. */
+    set_sigio_trap ();
+
+    pid = proc_wait (inferior_pid, &status);
+    save_errno = errno;
+
+    clear_sigio_trap ();
+
+    clear_sigint_trap();
+
+    if (pid == -1)
+      {
+	if (save_errno == EINTR)
+	  continue;
+	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;
+      }
+  } while (pid != inferior_pid); /* Some other child died or stopped */
+  store_waitstatus (ourstatus, status);
+  return pid;
+}
+#endif /* CHILD_WAIT */
+
+#ifndef CHILD_THREAD_ALIVE
+
+/* Check to see if the given thread is alive.
+
+   FIXME: Is kill() ever the right way to do this?  I doubt it, but
+   for now we're going to try and be compatable with the old thread
+   code.  */
+static int
+child_thread_alive (pid)
+     int pid;
+{
+  return (kill (pid, 0) != -1);
+}
+
+#endif
+
+/* Attach to process PID, then initialize for debugging it.  */
+
+static void
+child_attach (args, from_tty)
+     char *args;
+     int from_tty;
+{
+  if (!args)
+    error_no_arg ("process-id to attach");
+
+#ifndef ATTACH_DETACH
+  error ("Can't attach to a process on this machine.");
+#else
+  {
+    char *exec_file;
+    int pid;
+
+    pid = atoi (args);
+
+    if (pid == getpid())		/* Trying to masturbate? */
+      error ("I refuse to debug myself!");
+
+    if (from_tty)
+      {
+	exec_file = (char *) get_exec_file (0);
+
+	if (exec_file)
+	  printf_unfiltered ("Attaching to program `%s', %s\n", exec_file,
+		  target_pid_to_str (pid));
+	else
+	  printf_unfiltered ("Attaching to %s\n", target_pid_to_str (pid));
+
+	gdb_flush (gdb_stdout);
+      }
+
+    attach (pid);
+    inferior_pid = pid;
+    push_target (&child_ops);
+  }
+#endif  /* ATTACH_DETACH */
+}
+
+
+/* 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
+child_detach (args, from_tty)
+     char *args;
+     int from_tty;
+{
+#ifdef ATTACH_DETACH
+  {
+    int siggnal = 0;
+
+    if (from_tty)
+      {
+	char *exec_file = get_exec_file (0);
+	if (exec_file == 0)
+	  exec_file = "";
+	printf_unfiltered ("Detaching from program: %s %s\n", exec_file,
+		target_pid_to_str (inferior_pid));
+	gdb_flush (gdb_stdout);
+      }
+    if (args)
+      siggnal = atoi (args);
+
+    detach (siggnal);
+    inferior_pid = 0;
+    unpush_target (&child_ops);
+  }
+#else
+  error ("This version of Unix does not support detaching a process.");
+#endif
+}
+
+/* Get ready to modify the registers array.  On machines which store
+   individual registers, this doesn't need to do anything.  On machines
+   which store all the registers in one fell swoop, this makes sure
+   that registers contains all the registers from the program being
+   debugged.  */
+
+static void
+child_prepare_to_store ()
+{
+#ifdef CHILD_PREPARE_TO_STORE
+  CHILD_PREPARE_TO_STORE ();
+#endif
+}
+
+/* Print status information about what we're accessing.  */
+
+static void
+child_files_info (ignore)
+     struct target_ops *ignore;
+{
+  printf_unfiltered ("\tUsing the running image of %s %s.\n",
+	  attach_flag? "attached": "child", target_pid_to_str (inferior_pid));
+}
+
+/* ARGSUSED */
+static void
+child_open (arg, from_tty)
+     char *arg;
+     int 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 int
+ptrace_him (pid)
+     int pid;
+{
+  push_target (&child_ops);
+
+#ifdef START_INFERIOR_TRAPS_EXPECTED
+  startup_inferior (START_INFERIOR_TRAPS_EXPECTED);
+#else
+  /* One trap to exec the shell, one to exec the program being debugged.  */
+  startup_inferior (2);
+#endif
+
+  return pid;
+}
+
+/* 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().  */
+
+static void
+child_create_inferior (exec_file, allargs, env)
+     char *exec_file;
+     char *allargs;
+     char **env;
+{
+  fork_inferior (exec_file, allargs, env, ptrace_me, ptrace_him, NULL);
+  /* We are at the first instruction we care about.  */
+  /* Pedal to the metal... */
+  proceed ((CORE_ADDR) -1, TARGET_SIGNAL_0, 0);
+}
+
+static void
+child_mourn_inferior ()
+{
+  /* FIXME: Should be in a header file */
+  extern void proc_remove_foreign PARAMS ((int));
+
+  unpush_target (&child_ops);
+  proc_remove_foreign (inferior_pid);
+  generic_mourn_inferior ();
+}
+
+static int
+child_can_run ()
+{
+  /* This variable is controlled by modules that sit atop inftarg that may layer
+     their own process structure atop that provided here.  hpux-thread.c does
+     this because of the Hpux user-mode level thread model.  */
+
+  return !child_suppress_run;
+}
+
+/* Send a SIGINT to the process group.  This acts just like the user typed a
+   ^C on the controlling terminal.
+
+   XXX - This may not be correct for all systems.  Some may want to use
+   killpg() instead of kill (-pgrp). */
+
+static void
+child_stop ()
+{
+  extern pid_t inferior_process_group;
+
+  kill (-inferior_process_group, SIGINT);
+}
+
+struct target_ops child_ops = {
+  "child",			/* to_shortname */
+  "Unix child process",		/* to_longname */
+  "Unix child process (started by the \"run\" command).",	/* to_doc */
+  child_open,			/* to_open */
+  0,				/* to_close */
+  child_attach,			/* to_attach */
+  child_detach, 		/* to_detach */
+  child_resume,			/* to_resume */
+  child_wait,			/* to_wait */
+  fetch_inferior_registers,	/* to_fetch_registers */
+  store_inferior_registers,	/* to_store_registers */
+  child_prepare_to_store,	/* to_prepare_to_store */
+  child_xfer_memory,		/* to_xfer_memory */
+  child_files_info,		/* to_files_info */
+  memory_insert_breakpoint,	/* to_insert_breakpoint */
+  memory_remove_breakpoint,	/* to_remove_breakpoint */
+  terminal_init_inferior,	/* to_terminal_init */
+  terminal_inferior, 		/* to_terminal_inferior */
+  terminal_ours_for_output,	/* to_terminal_ours_for_output */
+  terminal_ours,		/* to_terminal_ours */
+  child_terminal_info,		/* to_terminal_info */
+  kill_inferior,		/* to_kill */
+  0,				/* to_load */
+  0,				/* to_lookup_symbol */
+  child_create_inferior,	/* to_create_inferior */
+  child_mourn_inferior,		/* to_mourn_inferior */
+  child_can_run,		/* to_can_run */
+  0, 				/* to_notice_signals */
+  child_thread_alive,		/* to_thread_alive */
+  child_stop,			/* to_stop */
+  process_stratum,		/* to_stratum */
+  0,				/* to_next */
+  1,				/* to_has_all_memory */
+  1,				/* to_has_memory */
+  1,				/* to_has_stack */
+  1,				/* to_has_registers */
+  1,				/* to_has_execution */
+  0,				/* to_sections */
+  0,				/* to_sections_end */
+  OPS_MAGIC			/* to_magic */
+};
+
+void
+_initialize_inftarg ()
+{
+#ifdef HAVE_OPTIONAL_PROC_FS
+  char procname[32];
+  int fd;
+
+  /* If we have an optional /proc filesystem (e.g. under OSF/1),
+     don't add ptrace support if we can access the running GDB via /proc.  */
+#ifndef PROC_NAME_FMT
+#define PROC_NAME_FMT "/proc/%05d"
+#endif
+  sprintf (procname, PROC_NAME_FMT, getpid ());
+  if ((fd = open (procname, O_RDONLY)) >= 0)
+    {
+      close (fd);
+      return;
+    }
+#endif
+
+  add_target (&child_ops);
+}