/* Work with core dump and executable files, for GDB.
- Copyright (C) 1986, 1987, 1989 Free Software Foundation, Inc.
+ Copyright 1986, 1987, 1989, 1991, 1992 Free Software Foundation, Inc.
This file is part of GDB.
-GDB is free software; you can redistribute it and/or modify
+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 1, or (at your option)
-any later version.
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
-GDB is distributed in the hope that it will be useful,
+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 GDB; see the file COPYING. If not, write to
-the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
+along with this program; if not, write to the Free Software
+Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
-#include <stdio.h>
+#include "defs.h"
#include <errno.h>
#include <signal.h>
-#include "defs.h"
-#include "param.h"
+#include <fcntl.h>
#include "frame.h" /* required by inferior.h */
#include "inferior.h"
#include "symtab.h"
#include "target.h"
#include "gdbcore.h"
-extern int xfer_memory ();
-extern void child_attach (), child_create_inferior ();
+#ifdef SOLIB_ADD
+static int
+solib_add_stub PARAMS ((char *));
+#endif
-extern int sys_nerr;
-extern char *sys_errlist[];
-extern char *sys_siglist[];
+static void
+core_close PARAMS ((int));
+
+static void
+core_open PARAMS ((char *, int));
+
+static void
+core_detach PARAMS ((char *, int));
+
+static void
+get_core_registers PARAMS ((int));
+
+static void
+core_files_info PARAMS ((struct target_ops *));
extern char registers[];
/* Hook for `exec_file_command' command to call. */
-void (*exec_file_display_hook) () = NULL;
-
-struct section_table *core_sections, *core_sections_end;
+void (*exec_file_display_hook) PARAMS ((char *)) = NULL;
/* Binary file diddling handle for the core file. */
/* Discard all vestiges of any previous core file
and mark data and stack spaces as empty. */
-void
+/* ARGSUSED */
+static void
core_close (quitting)
int quitting;
{
#ifdef 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;
+ }
}
}
+#ifdef SOLIB_ADD
+/* Stub function for catch_errors around shared library hacking. */
+
+static int
+solib_add_stub (from_tty)
+ char *from_tty;
+{
+ SOLIB_ADD (NULL, (int)from_tty, &core_ops);
+ return 0;
+}
+#endif /* SOLIB_ADD */
+
/* This routine opens and sets up the core file bfd */
-void
+static void
core_open (filename, from_tty)
char *filename;
int from_tty;
{
- char *p;
+ const char *p;
int siggy;
struct cleanup *old_chain;
char *temp;
bfd *temp_bfd;
int ontop;
+ int scratch_chan;
target_preopen (from_tty);
if (!filename)
filename = tilde_expand (filename);
if (filename[0] != '/') {
- temp = concat (current_directory, "/", filename);
+ temp = concat (current_directory, "/", filename, NULL);
free (filename);
filename = temp;
}
old_chain = make_cleanup (free, filename);
- temp_bfd = bfd_openr (filename, NULL);
+
+ scratch_chan = open (filename, write_files? O_RDWR: O_RDONLY, 0);
+ if (scratch_chan < 0)
+ perror_with_name (filename);
+
+ temp_bfd = bfd_fdopenr (filename, NULL, scratch_chan);
if (temp_bfd == NULL)
{
perror_with_name (filename);
if (!bfd_check_format (temp_bfd, bfd_core))
{
- bfd_close (temp_bfd);
- error ("\"%s\" does not appear to be a core dump", 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));
}
/* Looks semi-reasonable. Toss the old core file and work on the new. */
validate_files ();
/* Find the data section */
- if (build_section_table (core_bfd, &core_sections, &core_sections_end))
+ 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));
ontop = !push_target (&core_ops);
+ discard_cleanups (old_chain);
p = bfd_core_file_failing_command (core_bfd);
if (p)
- printf ("Core file invoked as `%s'.\n", p);
+ printf ("Core was generated by `%s'.\n", p);
siggy = bfd_core_file_failing_signal (core_bfd);
if (siggy > 0)
printf ("Program terminated with signal %d, %s.\n", siggy,
- siggy < NSIG ? sys_siglist[siggy] : "(undocumented)");
+ safe_strsignal (siggy));
if (ontop) {
/* Fetch all registers from core file */
target_fetch_registers (-1);
- set_current_frame ( create_new_frame (read_register (FP_REGNUM),
- read_pc ()));
- select_frame (get_current_frame (), 0);
-#if 0
- /* Shouldn't be necessary to read in symbols. */
+
+ /* Add symbols and section mappings for any shared libraries */
#ifdef SOLIB_ADD
- SOLIB_ADD (NULL, from_tty);
+ catch_errors (solib_add_stub, (char *)from_tty, (char *)0);
#endif
-#endif /* 0 */
- print_sel_frame (0); /* Print the top frame and source line */
+
+ /* Now, set up the frame cache, and print the top of stack */
+ set_current_frame (create_new_frame (read_register (FP_REGNUM),
+ read_pc ()));
+ select_frame (get_current_frame (), 0);
+ print_stack_frame (selected_frame, selected_frame_level, 1);
} else {
- printf (
-"Warning: you won't be able to access this core file until you terminate\n\
-your %s; do ``info files''\n", current_target->to_longname);
+ warning (
+"you won't be able to access this core file until you terminate\n\
+your %s; do ``info files''", current_target->to_longname);
}
-
- discard_cleanups (old_chain);
}
-void
+static void
core_detach (args, from_tty)
char *args;
int from_tty;
void
specify_exec_file_hook (hook)
- void (*hook) ();
+ void (*hook) PARAMS ((char *));
{
exec_file_display_hook = hook;
}
}
\f
/* If we have both a core file and an exec file,
- print a warning if they don't go together.
- This should really check that the core file came
- from that exec file, but I don't know how to do it. */
+ print a warning if they don't go together. */
void
validate_files ()
{
if (exec_bfd && core_bfd)
{
- if (core_file_matches_executable_p (core_bfd, exec_bfd))
- printf ("Warning: core file does not match specified executable file.\n");
+ if (!core_file_matches_executable_p (core_bfd, exec_bfd))
+ warning ("core file may not match specified executable file.");
else if (bfd_get_mtime(exec_bfd) > bfd_get_mtime(core_bfd))
- printf ("Warning: exec file is newer than core file.\n");
+ warning ("exec file is newer than core file.");
}
}
}
static void
-core_files_info ()
+core_files_info (t)
+ struct target_ops *t;
{
- struct section_table *p;
-
- printf ("\tCore file `%s'.\n", bfd_get_filename(core_bfd));
-
- for (p = core_sections; p < core_sections_end; p++)
- printf("\tcore file from 0x%08x to 0x%08x is %s\n",
- p->addr, p->endaddr,
- bfd_section_name (core_bfd, p->sec_ptr));
+ print_section_info (t, core_bfd);
}
\f
+/* Report a memory error with error(). */
+
void
memory_error (status, memaddr)
int status;
{
/* Actually, address between memaddr and memaddr + len
was out of bounds. */
- error ("Cannot access memory: address 0x%x out of bounds.", memaddr);
+ error ("Cannot access memory at address %s.", local_hex_string(memaddr));
}
else
{
- if (status >= sys_nerr || status < 0)
- error ("Error accessing memory address 0x%x: unknown error (%d).",
- memaddr, status);
- else
- error ("Error accessing memory address 0x%x: %s.",
- memaddr, sys_errlist[status]);
+ error ("Error accessing memory address %s: %s.",
+ local_hex_string (memaddr), safe_strerror (status));
}
}
return -1; /* for lint */
}
\f
-/* Read or write the core file.
-
- Args are address within core file, address within gdb address-space,
- length, and a flag indicating whether to read or write.
-
- Result is a length:
-
- 0: We cannot handle this address and length.
- > 0: We have handled N bytes starting at this address.
- (If N == length, we did it all.) We might be able
- to handle more bytes beyond this length, but no
- promises.
- < 0: We cannot handle this address, but if somebody
- else handles (-N) bytes, we can start from there.
-
- The actual work is done by xfer_memory in exec.c, which we share
- in common with exec_xfer_memory(). */
-
-static int
-core_xfer_memory (memaddr, myaddr, len, write)
- CORE_ADDR memaddr;
- char *myaddr;
- int len;
- int write;
-{
- int res;
- res = xfer_memory (memaddr, myaddr, len, write,
- core_bfd, core_sections, core_sections_end);
-#ifdef SOLIB_XFER_MEMORY
- if (res == 0)
- res = SOLIB_XFER_MEMORY (memaddr, myaddr, len, write);
-#endif
- return res;
-}
-\f
/* Get the registers out of a core file. This is the machine-
independent part. Fetch_core_registers is the machine-dependent
part, typically implemented in the xm-file for each architecture. */
-static int
+/* We just get all the registers, so we don't use regno. */
+/* ARGSUSED */
+static void
get_core_registers (regno)
int regno;
{
char *the_regs;
reg_sec = bfd_get_section_by_name (core_bfd, ".reg");
+ 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,
- (unsigned)0, size))
+ if (bfd_get_section_contents (core_bfd, reg_sec, the_regs, (file_ptr)0, size))
{
- fetch_core_registers (the_regs, size, 0);
+ fetch_core_registers (the_regs, size, 0,
+ (unsigned) bfd_section_vma (abfd,reg_sec));
}
else
{
+cant:
fprintf (stderr, "Couldn't fetch registers from core file: %s\n",
bfd_errmsg (bfd_error));
}
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,
- (unsigned)0, size))
+ if (bfd_get_section_contents (core_bfd, reg_sec, the_regs, (file_ptr)0,
+ size))
{
- fetch_core_registers (the_regs, size, 2);
+ fetch_core_registers (the_regs, size, 2,
+ (unsigned) bfd_section_vma (abfd,reg_sec));
}
else
{
}
}
registers_fetched();
- return 0; /* FIXME, what result goes here? */
}
\f
struct target_ops core_ops = {
child_attach, core_detach, 0, 0, /* resume, wait */
get_core_registers,
0, 0, 0, 0, /* store_regs, prepare_to_store, conv_to, conv_from */
- core_xfer_memory, core_files_info,
+ xfer_memory, core_files_info,
0, 0, /* core_insert_breakpoint, core_remove_breakpoint, */
0, 0, 0, 0, 0, /* terminal stuff */
- 0, 0, 0, 0, 0, /* kill, load, add_syms, call fn, lookup sym */
+ 0, 0, 0, /* kill, load, lookup sym */
child_create_inferior, 0, /* mourn_inferior */
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 */
};