/* Core dump and executable file functions below target vector, for GDB.
- Copyright 1986, 1987, 1989, 1991, 1992 Free Software Foundation, Inc.
+ Copyright 1986, 1987, 1989, 1991, 1992, 1993, 1994
+ Free Software Foundation, Inc.
This file is part of GDB.
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
#include "defs.h"
+#include <string.h>
#include <errno.h>
#include <signal.h>
#include <fcntl.h>
#include "bfd.h"
#include "target.h"
#include "gdbcore.h"
+#include "thread.h"
static void
core_files_info PARAMS ((struct target_ops *));
core_close (quitting)
int quitting;
{
+ inferior_pid = 0; /* Avoid confusion from thread stuff */
+
if (core_bfd) {
free (bfd_get_filename (core_bfd));
bfd_close (core_bfd);
}
#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;
+solib_add_stub (from_ttyp)
+ char *from_ttyp;
{
- SOLIB_ADD (NULL, (int)from_tty, &core_ops);
+ SOLIB_ADD (NULL, *(int *)from_ttyp, &core_ops);
return 0;
}
#endif /* SOLIB_ADD */
+/* Look for sections whose names start with `.reg/' so that we can extract the
+ list of threads in a core file. */
+
+static void
+add_to_thread_list (abfd, asect, reg_sect_arg)
+ bfd *abfd;
+ asection *asect;
+ PTR reg_sect_arg;
+{
+ int thread_id;
+ asection *reg_sect = (asection *) reg_sect_arg;
+
+ if (strncmp (bfd_section_name (abfd, asect), ".reg/", 5) != 0)
+ return;
+
+ thread_id = atoi (bfd_section_name (abfd, asect) + 5);
+
+ add_thread (thread_id);
+
+/* Warning, Will Robinson, looking at BFD private data! */
+
+ if (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 */
void
if (scratch_chan < 0)
perror_with_name (filename);
- temp_bfd = bfd_fdopenr (filename, NULL, scratch_chan);
+ temp_bfd = bfd_fdopenr (filename, gnutarget, scratch_chan);
if (temp_bfd == NULL)
{
perror_with_name (filename);
{
/* 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));
+ 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. */
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));
+ bfd_errmsg (bfd_get_error ()));
ontop = !push_target (&core_ops);
discard_cleanups (old_chain);
printf_filtered ("Program terminated with signal %d, %s.\n", siggy,
safe_strsignal (siggy));
+ /* Build up thread list from BFD sections. */
+
+ init_thread_list ();
+ 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);
/* Add symbols and section mappings for any shared libraries */
#ifdef SOLIB_ADD
- catch_errors (solib_add_stub, (char *)from_tty, (char *)0,
+ 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_register (FP_REGNUM),
+ 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);
+your %s; do ``info files''", target_longname);
}
}
if (args)
error ("Too many arguments");
unpush_target (&core_ops);
+ reinit_frame_cache ();
if (from_tty)
printf_filtered ("No core file now.\n");
}
sec_ptr reg_sec;
unsigned size;
char *the_regs;
+ char secname[10];
+
+ /* 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
+ use the appropriate register section, else we just use `.reg'. */
+
+ /* XXX - same thing needs to be done for floating-point (.reg2) sections. */
+
+ if (inferior_pid)
+ sprintf (secname, ".reg/%d", inferior_pid);
+ else
+ strcpy (secname, ".reg");
- reg_sec = bfd_get_section_by_name (core_bfd, ".reg");
+ reg_sec = bfd_get_section_by_name (core_bfd, secname);
if (!reg_sec) goto cant;
size = bfd_section_size (core_bfd, reg_sec);
the_regs = alloca (size);
else
{
cant:
- fprintf_filtered (stderr, "Couldn't fetch registers from core file: %s\n",
- bfd_errmsg (bfd_error));
+ 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. */
}
else
{
- fprintf_filtered (stderr, "Couldn't fetch register set 2 from core file: %s\n",
- bfd_errmsg (bfd_error));
+ fprintf_filtered (gdb_stderr, "Couldn't fetch register set 2 from core file: %s\n",
+ bfd_errmsg (bfd_get_error ()));
}
}
registers_fetched();
print_section_info (t, core_bfd);
}
\f
+/* If mourn is being called in all the right places, this could be say
+ `gdb internal error' (since generic_mourn calls breakpoint_init_inferior). */
+
+static int
+ignore (addr, contents)
+ CORE_ADDR addr;
+ char *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.",
get_core_registers,
0, 0, /* store_regs, prepare_to_store */
xfer_memory, core_files_info,
- 0, 0, /* core_insert_breakpoint, core_remove_breakpoint, */
+ 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 */
projects / deliverable / binutils-gdb.git / blobdiff