X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fcorelow.c;h=3e405dee1bc3b89f9dc0cd9bfe57859bb673cb1e;hb=feb129926a8d12656f1ca4b7a8bb10268d3af4fb;hp=77a4d17c2e1197357ea488f208506416e90821b7;hpb=199b2450f62ad6ffbe56ec34fc447716b811579d;p=deliverable%2Fbinutils-gdb.git

diff --git a/gdb/corelow.c b/gdb/corelow.c
index 77a4d17c2e..3e405dee1b 100644
--- a/gdb/corelow.c
+++ b/gdb/corelow.c
@@ -1,83 +1,133 @@
 /* Core dump and executable file functions below target vector, for GDB.
-   Copyright 1986, 1987, 1989, 1991, 1992 Free Software Foundation, Inc.
+   Copyright 1986, 87, 89, 91, 92, 93, 94, 95, 96, 97, 1998
+   Free Software Foundation, Inc.
 
-This file is part of GDB.
+   This file is part of GDB.
 
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
 
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
 
-You should have received a copy of the GNU General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
 
 #include "defs.h"
+#include "gdb_string.h"
 #include <errno.h>
 #include <signal.h>
 #include <fcntl.h>
-#include "frame.h"  /* required by inferior.h */
+#include <unistd.h>
+#include "frame.h"		/* required by inferior.h */
 #include "inferior.h"
 #include "symtab.h"
 #include "command.h"
 #include "bfd.h"
 #include "target.h"
 #include "gdbcore.h"
-#include "thread.h"
+#include "gdbthread.h"
 
-static void
-core_files_info PARAMS ((struct target_ops *));
+/* List of all available core_fns.  On gdb startup, each core file register
+   reader calls add_core_fns() to register information on each core format it
+   is prepared to read. */
+
+static struct core_fns *core_file_fns = NULL;
+
+static void core_files_info PARAMS ((struct target_ops *));
 
 #ifdef SOLIB_ADD
-static int 
-solib_add_stub PARAMS ((char *));
+static int solib_add_stub PARAMS ((PTR));
 #endif
 
-static void
-core_close PARAMS ((int));
+static void core_open PARAMS ((char *, int));
 
-static void
-get_core_registers PARAMS ((int));
+static void core_detach PARAMS ((char *, int));
+
+static void core_close PARAMS ((int));
+
+static void get_core_registers PARAMS ((int));
+
+static void add_to_thread_list PARAMS ((bfd *, asection *, PTR));
+
+static int ignore PARAMS ((CORE_ADDR, char *));
+
+static char *core_file_to_sym_file PARAMS ((char *));
+
+static int core_file_thread_alive PARAMS ((int tid));
 
-/* Discard all vestiges of any previous core file
-   and mark data and stack spaces as empty.  */
+static void init_core_ops PARAMS ((void));
+
+void _initialize_corelow PARAMS ((void));
+
+struct target_ops core_ops;
+
+/* Link a new core_fns into the global core_file_fns list.  Called on gdb
+   startup by the _initialize routine in each core file register reader, to
+   register information about each format the the reader is prepared to
+   handle. */
+
+void
+add_core_fns (cf)
+     struct core_fns *cf;
+{
+  cf->next = core_file_fns;
+  core_file_fns = cf;
+}
+
+
+/* Discard all vestiges of any previous core file and mark data and stack
+   spaces as empty.  */
 
 /* ARGSUSED */
 static void
 core_close (quitting)
      int quitting;
 {
-  inferior_pid = 0;		/* Avoid confusion from thread stuff */
+  char *name;
+
+  if (core_bfd)
+    {
+      inferior_pid = 0;		/* Avoid confusion from thread stuff */
 
-  if (core_bfd) {
-    free (bfd_get_filename (core_bfd));
-    bfd_close (core_bfd);
-    core_bfd = NULL;
+      /* Clear out solib state while the bfd is still open. See
+         comments in clear_solib in solib.c. */
 #ifdef CLEAR_SOLIB
-    CLEAR_SOLIB ();
+      CLEAR_SOLIB ();
 #endif
-    if (core_ops.to_sections) {
-      free ((PTR)core_ops.to_sections);
-      core_ops.to_sections = NULL;
-      core_ops.to_sections_end = NULL;
+
+      name = bfd_get_filename (core_bfd);
+      if (!bfd_close (core_bfd))
+	warning ("cannot close \"%s\": %s",
+		 name, bfd_errmsg (bfd_get_error ()));
+      free (name);
+      core_bfd = NULL;
+      if (core_ops.to_sections)
+	{
+	  free ((PTR) core_ops.to_sections);
+	  core_ops.to_sections = NULL;
+	  core_ops.to_sections_end = NULL;
+	}
     }
-  }
 }
 
 #ifdef SOLIB_ADD
-/* Stub function for catch_errors around shared library hacking. */
+/* Stub function for catch_errors around shared library hacking.  FROM_TTYP
+   is really an int * which points to from_tty.  */
 
-static int 
-solib_add_stub (from_tty)
-     char *from_tty;
+static int
+solib_add_stub (from_ttyp)
+     PTR from_ttyp;
 {
-    SOLIB_ADD (NULL, (int)from_tty, &core_ops);
-    return 0;
+  SOLIB_ADD (NULL, *(int *) from_ttyp, &current_target);
+  re_enable_breakpoints_in_shlibs ();
+  return 0;
 }
 #endif /* SOLIB_ADD */
 
@@ -102,13 +152,14 @@ add_to_thread_list (abfd, asect, reg_sect_arg)
 
 /* Warning, Will Robinson, looking at BFD private data! */
 
-  if (asect->filepos == reg_sect->filepos) /* Did we find .reg? */
+  if (reg_sect != NULL
+      && asect->filepos == reg_sect->filepos)	/* Did we find .reg? */
     inferior_pid = thread_id;	/* Yes, make it current */
 }
 
-/* This routine opens and sets up the core file bfd */
+/* This routine opens and sets up the core file bfd.  */
 
-void
+static void
 core_open (filename, from_tty)
      char *filename;
      int from_tty;
@@ -124,51 +175,54 @@ core_open (filename, from_tty)
   target_preopen (from_tty);
   if (!filename)
     {
-      error (core_bfd? 
-       "No core file specified.  (Use `detach' to stop debugging a core file.)"
-     : "No core file specified.");
+      error (core_bfd ?
+	     "No core file specified.  (Use `detach' to stop debugging a core file.)"
+	     : "No core file specified.");
     }
 
   filename = tilde_expand (filename);
-  if (filename[0] != '/') {
-    temp = concat (current_directory, "/", filename, NULL);
-    free (filename);
-    filename = temp;
-  }
+  if (filename[0] != '/')
+    {
+      temp = concat (current_directory, "/", filename, NULL);
+      free (filename);
+      filename = temp;
+    }
 
   old_chain = make_cleanup (free, filename);
 
-  scratch_chan = open (filename, write_files? O_RDWR: O_RDONLY, 0);
+  scratch_chan = open (filename, write_files ? O_RDWR : O_RDONLY, 0);
   if (scratch_chan < 0)
     perror_with_name (filename);
 
   temp_bfd = bfd_fdopenr (filename, gnutarget, scratch_chan);
   if (temp_bfd == NULL)
-    {
-      perror_with_name (filename);
-    }
+    perror_with_name (filename);
 
   if (!bfd_check_format (temp_bfd, bfd_core))
     {
       /* Do it after the err msg */
-      make_cleanup (bfd_close, temp_bfd);
-      error ("\"%s\" is not a core dump: %s", filename, bfd_errmsg(bfd_error));
+      /* FIXME: should be checking for errors from bfd_close (for one thing,
+         on error it does not free all the storage associated with the
+         bfd).  */
+      make_cleanup ((make_cleanup_func) bfd_close, temp_bfd);
+      error ("\"%s\" is not a core dump: %s",
+	     filename, bfd_errmsg (bfd_get_error ()));
     }
 
   /* Looks semi-reasonable.  Toss the old core file and work on the new.  */
 
-  discard_cleanups (old_chain);		/* Don't free filename any more */
+  discard_cleanups (old_chain);	/* Don't free filename any more */
   unpush_target (&core_ops);
   core_bfd = temp_bfd;
-  old_chain = make_cleanup (core_close, core_bfd);
+  old_chain = make_cleanup ((make_cleanup_func) core_close, core_bfd);
 
   validate_files ();
 
   /* Find the data section */
   if (build_section_table (core_bfd, &core_ops.to_sections,
 			   &core_ops.to_sections_end))
-    error ("Can't find sections in `%s': %s", bfd_get_filename(core_bfd),
-	   bfd_errmsg (bfd_error));
+    error ("\"%s\": Can't find sections: %s",
+	   bfd_get_filename (core_bfd), bfd_errmsg (bfd_get_error ()));
 
   ontop = !push_target (&core_ops);
   discard_cleanups (old_chain);
@@ -180,7 +234,7 @@ core_open (filename, from_tty)
   siggy = bfd_core_file_failing_signal (core_bfd);
   if (siggy > 0)
     printf_filtered ("Program terminated with signal %d, %s.\n", siggy,
-	    safe_strsignal (siggy));
+		     safe_strsignal (siggy));
 
   /* Build up thread list from BFD sections. */
 
@@ -188,29 +242,31 @@ core_open (filename, from_tty)
   bfd_map_over_sections (core_bfd, add_to_thread_list,
 			 bfd_get_section_by_name (core_bfd, ".reg"));
 
-  if (ontop) {
-    /* Fetch all registers from core file */
-    target_fetch_registers (-1);
+  if (ontop)
+    {
+      /* Fetch all registers from core file.  */
+      target_fetch_registers (-1);
 
-    /* Add symbols and section mappings for any shared libraries */
+      /* Add symbols and section mappings for any shared libraries.  */
 #ifdef SOLIB_ADD
-    catch_errors (solib_add_stub, (char *)from_tty, (char *)0,
-		  RETURN_MASK_ALL);
+      catch_errors (solib_add_stub, &from_tty, (char *) 0,
+		    RETURN_MASK_ALL);
 #endif
 
-    /* Now, set up the frame cache, and print the top of stack */
-    set_current_frame (create_new_frame (read_fp (),
-					 read_pc ()));
-    select_frame (get_current_frame (), 0);
-    print_stack_frame (selected_frame, selected_frame_level, 1);
-  } else {
-    warning (
-"you won't be able to access this core file until you terminate\n\
-your %s; do ``info files''", current_target->to_longname);
-  }
+      /* Now, set up the frame cache, and print the top of stack.  */
+      flush_cached_frames ();
+      select_frame (get_current_frame (), 0);
+      print_stack_frame (selected_frame, selected_frame_level, 1);
+    }
+  else
+    {
+      warning (
+		"you won't be able to access this core file until you terminate\n\
+your %s; do ``info files''", target_longname);
+    }
 }
 
-void
+static void
 core_detach (args, from_tty)
      char *args;
      int from_tty;
@@ -228,6 +284,7 @@ core_detach (args, from_tty)
    part, typically implemented in the xm-file for each architecture.  */
 
 /* We just get all the registers, so we don't use regno.  */
+
 /* ARGSUSED */
 static void
 get_core_registers (regno)
@@ -236,7 +293,16 @@ get_core_registers (regno)
   sec_ptr reg_sec;
   unsigned size;
   char *the_regs;
-  char secname[10];
+  char secname[30];
+  enum bfd_flavour our_flavour = bfd_get_flavour (core_bfd);
+  struct core_fns *cf = NULL;
+
+  if (core_file_fns == NULL)
+    {
+      fprintf_filtered (gdb_stderr,
+		     "Can't fetch registers from this type of core file\n");
+      return;
+    }
 
   /* Thread support.  If inferior_pid is non-zero, then we have found a core
      file with threads (or multiple processes).  In that case, we need to
@@ -250,44 +316,127 @@ get_core_registers (regno)
     strcpy (secname, ".reg");
 
   reg_sec = bfd_get_section_by_name (core_bfd, secname);
-  if (!reg_sec) goto cant;
+  if (!reg_sec)
+    goto cant;
   size = bfd_section_size (core_bfd, reg_sec);
   the_regs = alloca (size);
-  if (bfd_get_section_contents (core_bfd, reg_sec, the_regs, (file_ptr)0, size))
+  /* Look for the core functions that match this flavor.  Default to the
+     first one if nothing matches. */
+  for (cf = core_file_fns; cf != NULL; cf = cf->next)
     {
-      fetch_core_registers (the_regs, size, 0,
-			    (unsigned) bfd_section_vma (abfd,reg_sec));
+      if (our_flavour == cf->core_flavour)
+	{
+	  break;
+	}
+    }
+  if (cf == NULL)
+    {
+      cf = core_file_fns;
+    }
+  if (cf != NULL &&
+      bfd_get_section_contents (core_bfd, reg_sec, the_regs, (file_ptr) 0, size) &&
+      cf->core_read_registers != NULL)
+    {
+      (cf->core_read_registers (the_regs, size, 0,
+				(unsigned) bfd_section_vma (abfd, reg_sec)));
     }
   else
     {
-cant:
-      fprintf_filtered (gdb_stderr, "Couldn't fetch registers from core file: %s\n",
-	       bfd_errmsg (bfd_error));
+    cant:
+      fprintf_filtered (gdb_stderr,
+			"Couldn't fetch registers from core file: %s\n",
+			bfd_errmsg (bfd_get_error ()));
     }
 
   /* Now do it again for the float registers, if they exist.  */
   reg_sec = bfd_get_section_by_name (core_bfd, ".reg2");
-  if (reg_sec) {
-    size = bfd_section_size (core_bfd, reg_sec);
-    the_regs = alloca (size);
-    if (bfd_get_section_contents (core_bfd, reg_sec, the_regs, (file_ptr)0,
-				  size))
-      {
-	fetch_core_registers (the_regs, size, 2,
-			      (unsigned) bfd_section_vma (abfd,reg_sec));
-      }
-    else
-      {
-	fprintf_filtered (gdb_stderr, "Couldn't fetch register set 2 from core file: %s\n",
-		 bfd_errmsg (bfd_error));
-      }
-  }
-  registers_fetched();
+  if (reg_sec)
+    {
+      size = bfd_section_size (core_bfd, reg_sec);
+      the_regs = alloca (size);
+      if (cf != NULL &&
+	  bfd_get_section_contents (core_bfd, reg_sec, the_regs, (file_ptr) 0, size) &&
+	  cf->core_read_registers != NULL)
+	{
+	  (cf->core_read_registers (the_regs, size, 2,
+			       (unsigned) bfd_section_vma (abfd, reg_sec)));
+	}
+      else
+	{
+	  fprintf_filtered (gdb_stderr,
+		       "Couldn't fetch register set 2 from core file: %s\n",
+			    bfd_errmsg (bfd_get_error ()));
+	}
+    }
+  registers_fetched ();
+}
+
+static char *
+core_file_to_sym_file (core)
+     char *core;
+{
+  CONST char *failing_command;
+  char *p;
+  char *temp;
+  bfd *temp_bfd;
+  int scratch_chan;
+
+  if (!core)
+    error ("No core file specified.");
+
+  core = tilde_expand (core);
+  if (core[0] != '/')
+    {
+      temp = concat (current_directory, "/", core, NULL);
+      core = temp;
+    }
+
+  scratch_chan = open (core, write_files ? O_RDWR : O_RDONLY, 0);
+  if (scratch_chan < 0)
+    perror_with_name (core);
+
+  temp_bfd = bfd_fdopenr (core, gnutarget, scratch_chan);
+  if (temp_bfd == NULL)
+    perror_with_name (core);
+
+  if (!bfd_check_format (temp_bfd, bfd_core))
+    {
+      /* Do it after the err msg */
+      /* FIXME: should be checking for errors from bfd_close (for one thing,
+         on error it does not free all the storage associated with the
+         bfd).  */
+      make_cleanup ((make_cleanup_func) bfd_close, temp_bfd);
+      error ("\"%s\" is not a core dump: %s",
+	     core, bfd_errmsg (bfd_get_error ()));
+    }
+
+  /* Find the data section */
+  if (build_section_table (temp_bfd, &core_ops.to_sections,
+			   &core_ops.to_sections_end))
+    error ("\"%s\": Can't find sections: %s",
+	   bfd_get_filename (temp_bfd), bfd_errmsg (bfd_get_error ()));
+
+  failing_command = bfd_core_file_failing_command (temp_bfd);
+
+  bfd_close (temp_bfd);
+
+  /* If we found a filename, remember that it is probably saved
+     relative to the executable that created it.  If working directory
+     isn't there now, we may not be able to find the executable.  Rather
+     than trying to be sauve about finding it, just check if the file
+     exists where we are now.  If not, then punt and tell our client
+     we couldn't find the sym file.
+   */
+  p = (char *) failing_command;
+  if ((p != NULL) && (access (p, F_OK) != 0))
+    p = NULL;
+
+  return p;
 }
 
 static void
 core_files_info (t)
-  struct target_ops *t;
+     struct target_ops *t;
 {
   print_section_info (t, core_bfd);
 }
@@ -303,28 +452,64 @@ ignore (addr, contents)
   return 0;
 }
 
-struct target_ops core_ops = {
-	"core", "Local core dump file",
-	"Use a core file as a target.  Specify the filename of the core file.",
-	core_open, core_close,
-	find_default_attach, core_detach, 0, 0, /* resume, wait */
-	get_core_registers, 
-	0, 0, /* store_regs, prepare_to_store */
-	xfer_memory, core_files_info,
-	ignore, ignore, /* core_insert_breakpoint, core_remove_breakpoint, */
-	0, 0, 0, 0, 0, /* terminal stuff */
-	0, 0, 0, /* kill, load, lookup sym */
-	find_default_create_inferior, 0, /* mourn_inferior */
-	0, /* can_run */
-	0, /* notice_signals */
-	core_stratum, 0, /* next */
-	0, 1, 1, 1, 0,	/* all mem, mem, stack, regs, exec */
-	0, 0,			/* section pointers */
-	OPS_MAGIC,		/* Always the last thing */
-};
+
+/* Okay, let's be honest: threads gleaned from a core file aren't
+   exactly lively, are they?  On the other hand, if we don't claim
+   that each & every one is alive, then we don't get any of them
+   to appear in an "info thread" command, which is quite a useful
+   behaviour.
+ */
+static int
+core_file_thread_alive (tid)
+     int tid;
+{
+  return 1;
+}
+
+/* Fill in core_ops with its defined operations and properties.  */
+
+static void
+init_core_ops ()
+{
+  core_ops.to_shortname = "core";
+  core_ops.to_longname = "Local core dump file";
+  core_ops.to_doc =
+    "Use a core file as a target.  Specify the filename of the core file.";
+  core_ops.to_open = core_open;
+  core_ops.to_close = core_close;
+  core_ops.to_attach = find_default_attach;
+  core_ops.to_require_attach = find_default_require_attach;
+  core_ops.to_detach = core_detach;
+  core_ops.to_require_detach = find_default_require_detach;
+  core_ops.to_fetch_registers = get_core_registers;
+  core_ops.to_xfer_memory = xfer_memory;
+  core_ops.to_files_info = core_files_info;
+  core_ops.to_insert_breakpoint = ignore;
+  core_ops.to_remove_breakpoint = ignore;
+  core_ops.to_create_inferior = find_default_create_inferior;
+  core_ops.to_clone_and_follow_inferior = find_default_clone_and_follow_inferior;
+  core_ops.to_thread_alive = core_file_thread_alive;
+  core_ops.to_core_file_to_sym_file = core_file_to_sym_file;
+  core_ops.to_stratum = core_stratum;
+  core_ops.to_has_memory = 1;
+  core_ops.to_has_stack = 1;
+  core_ops.to_has_registers = 1;
+  core_ops.to_magic = OPS_MAGIC;
+}
+
+/* non-zero if we should not do the add_target call in
+   _initialize_corelow; not initialized (i.e., bss) so that
+   the target can initialize it (i.e., data) if appropriate.
+   This needs to be set at compile time because we don't know
+   for sure whether the target's initialize routine is called
+   before us or after us. */
+int coreops_suppress_target;
 
 void
-_initialize_corelow()
+_initialize_corelow ()
 {
-  add_target (&core_ops);
+  init_core_ops ();
+
+  if (!coreops_suppress_target)
+    add_target (&core_ops);
 }