binutils-gdb/gdb/corefile.c

459 lines
12 KiB
C
Raw Normal View History

/* Core dump and executable file functions above target vector, for GDB.
Copyright 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1996, 1997,
1998, 1999, 2000, 2001, 2003 Free Software Foundation, Inc.
1999-07-07 22:19:36 +02:00
This file is part of GDB.
1999-07-07 22:19:36 +02:00
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.
1999-07-07 22:19:36 +02:00
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.
1999-07-07 22:19:36 +02:00
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 "inferior.h"
#include "symtab.h"
#include "command.h"
#include "gdbcmd.h"
#include "bfd.h"
#include "target.h"
#include "gdbcore.h"
#include "dis-asm.h"
#include "gdb_stat.h"
#include "completer.h"
/* Local function declarations. */
2000-05-28 03:12:42 +02:00
extern void _initialize_core (void);
static void call_extra_exec_file_hooks (char *filename);
/* You can have any number of hooks for `exec_file_command' command to call.
If there's only one hook, it is set in exec_file_display hook.
If there are two or more hooks, they are set in exec_file_extra_hooks[],
and exec_file_display_hook is set to a function that calls all of them.
This extra complexity is needed to preserve compatibility with
old code that assumed that only one hook could be set, and which called
exec_file_display_hook directly. */
typedef void (*hook_type) (char *);
1999-07-07 22:19:36 +02:00
hook_type exec_file_display_hook; /* the original hook */
static hook_type *exec_file_extra_hooks; /* array of additional hooks */
1999-07-07 22:19:36 +02:00
static int exec_file_hook_count = 0; /* size of array */
/* Binary file diddling handle for the core file. */
bfd *core_bfd = NULL;
1999-07-07 22:19:36 +02:00
/* Backward compatability with old way of specifying core files. */
void
2000-07-30 03:48:28 +02:00
core_file_command (char *filename, int from_tty)
{
struct target_ops *t;
1999-07-07 22:19:36 +02:00
dont_repeat (); /* Either way, seems bogus. */
t = find_core_target ();
if (t == NULL)
error ("GDB can't read core files on this machine.");
if (!filename)
(t->to_detach) (filename, from_tty);
else
(t->to_open) (filename, from_tty);
}
1999-07-07 22:19:36 +02:00
/* If there are two or more functions that wish to hook into exec_file_command,
* this function will call all of the hook functions. */
static void
2000-07-30 03:48:28 +02:00
call_extra_exec_file_hooks (char *filename)
{
int i;
for (i = 0; i < exec_file_hook_count; i++)
1999-07-07 22:19:36 +02:00
(*exec_file_extra_hooks[i]) (filename);
}
/* Call this to specify the hook for exec_file_command to call back.
This is called from the x-window display code. */
void
2000-08-10 02:58:09 +02:00
specify_exec_file_hook (void (*hook) (char *))
{
hook_type *new_array;
if (exec_file_display_hook != NULL)
{
/* There's already a hook installed. Arrange to have both it
* and the subsequent hooks called. */
if (exec_file_hook_count == 0)
{
/* If this is the first extra hook, initialize the hook array. */
1999-07-07 22:19:36 +02:00
exec_file_extra_hooks = (hook_type *) xmalloc (sizeof (hook_type));
exec_file_extra_hooks[0] = exec_file_display_hook;
exec_file_display_hook = call_extra_exec_file_hooks;
exec_file_hook_count = 1;
}
/* Grow the hook array by one and add the new hook to the end.
Yes, it's inefficient to grow it by one each time but since
this is hardly ever called it's not a big deal. */
exec_file_hook_count++;
new_array =
(hook_type *) xrealloc (exec_file_extra_hooks,
1999-07-07 22:19:36 +02:00
exec_file_hook_count * sizeof (hook_type));
exec_file_extra_hooks = new_array;
exec_file_extra_hooks[exec_file_hook_count - 1] = hook;
}
else
exec_file_display_hook = hook;
}
/* The exec file must be closed before running an inferior.
If it is needed again after the inferior dies, it must
be reopened. */
void
2000-07-30 03:48:28 +02:00
close_exec_file (void)
{
1999-07-07 22:19:36 +02:00
#if 0 /* FIXME */
if (exec_bfd)
bfd_tempclose (exec_bfd);
#endif
}
void
2000-07-30 03:48:28 +02:00
reopen_exec_file (void)
{
1999-07-07 22:19:36 +02:00
#if 0 /* FIXME */
if (exec_bfd)
bfd_reopen (exec_bfd);
#else
char *filename;
int res;
struct stat st;
long mtime;
/* Don't do anything if the current target isn't exec. */
if (exec_bfd == NULL || strcmp (target_shortname, "exec") != 0)
return;
1999-07-07 22:19:36 +02:00
/* If the timestamp of the exec file has changed, reopen it. */
1999-12-07 04:56:43 +01:00
filename = xstrdup (bfd_get_filename (exec_bfd));
2000-12-15 02:01:51 +01:00
make_cleanup (xfree, filename);
1999-07-07 22:19:36 +02:00
mtime = bfd_get_mtime (exec_bfd);
res = stat (filename, &st);
if (mtime && mtime != st.st_mtime)
2001-01-26 Fernando Nasser <fnasser@redhat.com> Fix double parsing of filenames passed as command line arguments to GDB (causes weird handling of escape characters). Also, remove dependencies on the CLI from libgdb. * call-cmds.h: Remove declaration of exec_file_command(). * gdbcore.h: Remove declaration of exec_file_command(). Add declarations for exec_open() and exec_file_clear(). * symfile.h: Add declarations for symbol_file_add_main() and symbol_file_clear(). * exec.c (exec_open): New function. Implements to_open for exec targets. (exec_file_clear): New function. Makes GDB forget about a previously specified executable file. (exec_file_attach): Move parsing of arguments from here ... (exec_file_command): ... to here. (init_exec_ops): Use exec_open(), not exec_file_command() to implement to_open for exec targets. * symfile.c (symbol_file_add_main): New function. Call symbol_file_add() with default values. Used when the file name has already been parsed. (symbol_file_clear): New function. Makes GDB forget about previously read symbols. (symbol_file_command): Call the above function instead of inline code. * main.c: Include "symfile.h" and "gdbcore.h" instead of the deprecated "call-cmds.h". (captured_main): Call exec_file_attach() and symbol_file_add_main() instead of exec_file_command() and symbol_file_command(). (captured_main): Add comment. * corefile.c: Include "symfile.h". (core_file_command): Call symbol_file_add_main() instead of symbol_file_command(). (reopen_exec_file): Call exec_open() instead of exec_file_command(). * infcmd.c: Include "symfile.h". (attach_command): Call symbol_file_add_main() instead of symbol_file_command(). * infrun.c: Remove comment about the inclusion of "symfile.h", not any longer appropriate. (follow_exec): Call symbol_file_add_main() instead of symbol_file_command(). * remote-es.c: Include "symfile.h". (es1800_load): Call symbol_file_add_main() instead of symbol_file_command(). * remote-vx.c: Remove comment about the inclusion of "symfile.h", not any longer appropriate. (vx-wait): Call symbol_file_add_main() instead of symbol_file_command(). * solib-svr4.c (open_symbol_file_object): Call symbol_file_add_main() instead of symbol_file_command(). * v850ice.c (ice_file): Call exec_open(), exec_file_attach() and symbol_file_add_main() instead of exec_file_command() and symbol_file_command(). * Makefile.in: Update dependencies.
2001-01-27 01:43:26 +01:00
{
exec_open (filename, 0);
}
#endif
}
/* If we have both a core file and an exec file,
print a warning if they don't go together. */
void
2000-07-30 03:48:28 +02:00
validate_files (void)
{
if (exec_bfd && core_bfd)
{
if (!core_file_matches_executable_p (core_bfd, exec_bfd))
warning ("core file may not match specified executable file.");
1999-07-07 22:19:36 +02:00
else if (bfd_get_mtime (exec_bfd) > bfd_get_mtime (core_bfd))
warning ("exec file is newer than core file.");
}
}
/* Return the name of the executable file as a string.
ERR nonzero means get error if there is none specified;
otherwise return 0 in that case. */
char *
2000-07-30 03:48:28 +02:00
get_exec_file (int err)
{
1999-07-07 22:19:36 +02:00
if (exec_bfd)
return bfd_get_filename (exec_bfd);
if (!err)
return NULL;
error ("No executable file specified.\n\
Use the \"file\" or \"exec-file\" command.");
return NULL;
}
1999-07-07 22:19:36 +02:00
/* Report a memory error with error(). */
void
2000-07-30 03:48:28 +02:00
memory_error (int status, CORE_ADDR memaddr)
{
2000-02-02 01:21:19 +01:00
struct ui_file *tmp_stream = mem_fileopen ();
make_cleanup_ui_file_delete (tmp_stream);
1999-10-06 01:13:56 +02:00
if (status == EIO)
{
/* Actually, address between memaddr and memaddr + len
1999-07-07 22:19:36 +02:00
was out of bounds. */
1999-10-06 01:13:56 +02:00
fprintf_unfiltered (tmp_stream, "Cannot access memory at address ");
print_address_numeric (memaddr, 1, tmp_stream);
}
else
{
1999-10-06 01:13:56 +02:00
fprintf_filtered (tmp_stream, "Error accessing memory address ");
print_address_numeric (memaddr, 1, tmp_stream);
fprintf_filtered (tmp_stream, ": %s.",
1999-07-07 22:19:36 +02:00
safe_strerror (status));
}
1999-10-06 01:13:56 +02:00
error_stream (tmp_stream);
}
/* Same as target_read_memory, but report an error if can't read. */
void
2000-07-30 03:48:28 +02:00
read_memory (CORE_ADDR memaddr, char *myaddr, int len)
{
int status;
status = target_read_memory (memaddr, myaddr, len);
if (status != 0)
memory_error (status, memaddr);
}
/* Argument / return result struct for use with
do_captured_read_memory_integer(). MEMADDR and LEN are filled in
by gdb_read_memory_integer(). RESULT is the contents that were
successfully read from MEMADDR of length LEN. */
struct captured_read_memory_integer_arguments
{
CORE_ADDR memaddr;
int len;
LONGEST result;
};
/* Helper function for gdb_read_memory_integer(). DATA must be a
pointer to a captured_read_memory_integer_arguments struct.
Return 1 if successful. Note that the catch_errors() interface
will return 0 if an error occurred while reading memory. This
choice of return code is so that we can distinguish between
success and failure. */
static int
do_captured_read_memory_integer (void *data)
{
struct captured_read_memory_integer_arguments *args = (struct captured_read_memory_integer_arguments*) data;
CORE_ADDR memaddr = args->memaddr;
int len = args->len;
args->result = read_memory_integer (memaddr, len);
return 1;
}
/* Read memory at MEMADDR of length LEN and put the contents in
RETURN_VALUE. Return 0 if MEMADDR couldn't be read and non-zero
if successful. */
int
safe_read_memory_integer (CORE_ADDR memaddr, int len, LONGEST *return_value)
{
int status;
struct captured_read_memory_integer_arguments args;
args.memaddr = memaddr;
args.len = len;
status = catch_errors (do_captured_read_memory_integer, &args,
"", RETURN_MASK_ALL);
if (status)
*return_value = args.result;
return status;
}
LONGEST
2000-07-30 03:48:28 +02:00
read_memory_integer (CORE_ADDR memaddr, int len)
{
char buf[sizeof (LONGEST)];
read_memory (memaddr, buf, len);
return extract_signed_integer (buf, len);
}
ULONGEST
2000-07-30 03:48:28 +02:00
read_memory_unsigned_integer (CORE_ADDR memaddr, int len)
{
char buf[sizeof (ULONGEST)];
read_memory (memaddr, buf, len);
return extract_unsigned_integer (buf, len);
}
void
2000-07-30 03:48:28 +02:00
read_memory_string (CORE_ADDR memaddr, char *buffer, int max_len)
{
char *cp;
int i;
int cnt;
cp = buffer;
while (1)
{
if (cp - buffer >= max_len)
1999-07-07 22:19:36 +02:00
{
buffer[max_len - 1] = '\0';
break;
}
cnt = max_len - (cp - buffer);
if (cnt > 8)
cnt = 8;
read_memory (memaddr + (int) (cp - buffer), cp, cnt);
for (i = 0; i < cnt && *cp; i++, cp++)
1999-07-07 22:19:36 +02:00
; /* null body */
if (i < cnt && !*cp)
1999-07-07 22:19:36 +02:00
break;
}
}
CORE_ADDR
read_memory_typed_address (CORE_ADDR addr, struct type *type)
{
char *buf = alloca (TYPE_LENGTH (type));
read_memory (addr, buf, TYPE_LENGTH (type));
return extract_typed_address (buf, type);
}
/* Same as target_write_memory, but report an error if can't write. */
void
write_memory (CORE_ADDR memaddr, char *myaddr, int len)
{
int status;
status = target_write_memory (memaddr, myaddr, len);
if (status != 0)
memory_error (status, memaddr);
}
/* Store VALUE at ADDR in the inferior as a LEN-byte unsigned integer. */
void
write_memory_unsigned_integer (CORE_ADDR addr, int len, ULONGEST value)
{
char *buf = alloca (len);
store_unsigned_integer (buf, len, value);
write_memory (addr, buf, len);
}
/* Store VALUE at ADDR in the inferior as a LEN-byte signed integer. */
void
write_memory_signed_integer (CORE_ADDR addr, int len, LONGEST value)
{
char *buf = alloca (len);
store_signed_integer (buf, len, value);
write_memory (addr, buf, len);
}
1999-07-07 22:19:36 +02:00
#if 0
/* Enable after 4.12. It is not tested. */
/* Search code. Targets can just make this their search function, or
if the protocol has a less general search function, they can call this
in the cases it can't handle. */
void
2000-08-10 02:58:09 +02:00
generic_search (int len, char *data, char *mask, CORE_ADDR startaddr,
int increment, CORE_ADDR lorange, CORE_ADDR hirange,
CORE_ADDR *addr_found, char *data_found)
{
int i;
CORE_ADDR curaddr = startaddr;
while (curaddr >= lorange && curaddr < hirange)
{
read_memory (curaddr, data_found, len);
for (i = 0; i < len; ++i)
if ((data_found[i] & mask[i]) != data[i])
goto try_again;
/* It matches. */
*addr_found = curaddr;
return;
try_again:
curaddr += increment;
}
1999-07-07 22:19:36 +02:00
*addr_found = (CORE_ADDR) 0;
return;
}
#endif /* 0 */
/* The current default bfd target. Points to storage allocated for
gnutarget_string. */
char *gnutarget;
/* Same thing, except it is "auto" not NULL for the default case. */
static char *gnutarget_string;
2000-05-28 03:12:42 +02:00
static void set_gnutarget_command (char *, int, struct cmd_list_element *);
static void
2000-07-30 03:48:28 +02:00
set_gnutarget_command (char *ignore, int from_tty, struct cmd_list_element *c)
{
if (strcmp (gnutarget_string, "auto") == 0)
gnutarget = NULL;
else
gnutarget = gnutarget_string;
}
/* Set the gnutarget. */
void
2000-07-30 03:48:28 +02:00
set_gnutarget (char *newtarget)
{
if (gnutarget_string != NULL)
2000-12-15 02:01:51 +01:00
xfree (gnutarget_string);
gnutarget_string = savestring (newtarget, strlen (newtarget));
set_gnutarget_command (NULL, 0, NULL);
}
void
2000-07-30 03:48:28 +02:00
_initialize_core (void)
{
struct cmd_list_element *c;
c = add_cmd ("core-file", class_files, core_file_command,
"Use FILE as core dump for examining memory and registers.\n\
No arg means have no core file. This command has been superseded by the\n\
`target core' and `detach' commands.", &cmdlist);
set_cmd_completer (c, filename_completer);
c = add_set_cmd ("gnutarget", class_files, var_string_noescape,
1999-07-07 22:19:36 +02:00
(char *) &gnutarget_string,
"Set the current BFD target.\n\
Use `set gnutarget auto' to specify automatic detection.",
1999-07-07 22:19:36 +02:00
&setlist);
* cli/cli-decode.c (do_cfunc, set_cmd_cfunc): New functions. (do_sfunc, set_cmd_sfunc): New functions. * command.h (struct cmd_list_element): Add field func. * cli/cli-decode.h (struct cmd_list_element): Ditto. * command.h (set_cmd_sfunc, set_cmd_cfunc): Declare. * cli/cli-decode.h: Ditto. * cli/cli-decode.c (help_cmd): Test for func not cfunc/sfunc. (help_all, help_cmd_list): Ditto. (find_cmd, complete_on_cmdlist): Ditto. * top.c (execute_command): Ditto. * cli/cli-setshow.c (do_setshow_command): Call func instead of function.sfunc. * infcmd.c (notice_args_read): Fix function signature. * cli/cli-cmds.c (init_cli_cmds): Use set_cmd_sfunc. * cli/cli-decode.c (add_set_cmd): Ditto. * utils.c (initialize_utils): Ditto. * maint.c (_initialize_maint_cmds): Ditto. * infrun.c (_initialize_infrun): Ditto. * demangle.c (_initialize_demangler): Ditto. * remote.c (add_packet_config_cmd): Ditto. * mips-tdep.c (_initialize_mips_tdep): Ditto. * cris-tdep.c (_initialize_cris_tdep): Ditto. * proc-api.c (_initialize_proc_api): Ditto. * kod.c (_initialize_kod): Ditto. * valprint.c (_initialize_valprint): Ditto. * top.c (init_main): Ditto. * infcmd.c (_initialize_infcmd): Ditto. * corefile.c (_initialize_core): Ditto. * arm-tdep.c (_initialize_arm_tdep): Ditto. * arch-utils.c (initialize_current_architecture): Ditto. (_initialize_gdbarch_utils): Ditto. * alpha-tdep.c (_initialize_alpha_tdep): Ditto. * cli/cli-decode.c (add_cmd): Use set_cmd_cfunc. * wince.c (_initialize_inftarg): Ditto. * symfile.c (_initialize_symfile): Ditto. * mips-tdep.c (_initialize_mips_tdep): Ditto. * language.c (_initialize_language): Ditto. * arc-tdep.c (_initialize_arc_tdep): Ditto.
2002-02-05 05:37:23 +01:00
set_cmd_sfunc (c, set_gnutarget_command);
add_show_from_set (c, &showlist);
if (getenv ("GNUTARGET"))
set_gnutarget (getenv ("GNUTARGET"));
else
set_gnutarget ("auto");
}