X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=gdb%2Fcorefile.c;h=c6efba7da2583cd9af6d5063054e29ea45e19ff2;hb=809df4465f01277ab689fb82b3f16ff79f9a2606;hp=2f4fccc5eac7636a77a6ee9213184b49f53d8a0e;hpb=1a966eabdfe5d28f2e17f73988c9124cc5b76f31;p=binutils-gdb.git diff --git a/gdb/corefile.c b/gdb/corefile.c index 2f4fccc5eac..c6efba7da25 100644 --- a/gdb/corefile.c +++ b/gdb/corefile.c @@ -1,13 +1,14 @@ /* 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. + Copyright (C) 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1996, 1997, 1998, + 1999, 2000, 2001, 2003, 2006, 2007, 2008, 2009, 2010 + Free Software Foundation, Inc. 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 + the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, @@ -16,9 +17,7 @@ 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. */ + along with this program. If not, see . */ #include "defs.h" #include "gdb_string.h" @@ -60,6 +59,10 @@ static int exec_file_hook_count = 0; /* size of array */ /* Binary file diddling handle for the core file. */ bfd *core_bfd = NULL; + +/* corelow.c target (if included for this gdb target). */ + +struct target_ops *core_target; /* Backward compatability with old way of specifying core files. */ @@ -67,18 +70,15 @@ bfd *core_bfd = NULL; void core_file_command (char *filename, int from_tty) { - struct target_ops *t; - dont_repeat (); /* Either way, seems bogus. */ - t = find_core_target (); - if (t == NULL) + if (core_target == NULL) error (_("GDB can't read core files on this machine.")); if (!filename) - (t->to_detach) (filename, from_tty); + (core_target->to_detach) (core_target, filename, from_tty); else - (t->to_open) (filename, from_tty); + (core_target->to_open) (filename, from_tty); } @@ -153,22 +153,26 @@ reopen_exec_file (void) char *filename; int res; struct stat st; - long mtime; + struct cleanup *cleanups; - /* Don't do anything if the current target isn't exec. */ - if (exec_bfd == NULL || strcmp (target_shortname, "exec") != 0) + /* Don't do anything if there isn't an exec file. */ + if (exec_bfd == NULL) return; /* If the timestamp of the exec file has changed, reopen it. */ filename = xstrdup (bfd_get_filename (exec_bfd)); - make_cleanup (xfree, filename); - mtime = bfd_get_mtime (exec_bfd); + cleanups = make_cleanup (xfree, filename); res = stat (filename, &st); - if (mtime && mtime != st.st_mtime) - { - exec_open (filename, 0); - } + if (exec_bfd_mtime && exec_bfd_mtime != st.st_mtime) + exec_file_attach (filename, 0); + else + /* If we accessed the file since last opening it, close it now; + this stops GDB from holding the executable open after it + exits. */ + bfd_cache_close_all (); + + do_cleanups (cleanups); #endif } @@ -205,42 +209,48 @@ Use the \"file\" or \"exec-file\" command.")); } -/* Report a memory error with error(). */ +/* Report a memory error by throwing a MEMORY_ERROR error. */ void memory_error (int status, CORE_ADDR memaddr) { - struct ui_file *tmp_stream = mem_fileopen (); - make_cleanup_ui_file_delete (tmp_stream); - if (status == EIO) - { - /* Actually, address between memaddr and memaddr + len - was out of bounds. */ - fprintf_unfiltered (tmp_stream, "Cannot access memory at address "); - deprecated_print_address_numeric (memaddr, 1, tmp_stream); - } + /* Actually, address between memaddr and memaddr + len was out of + bounds. */ + throw_error (MEMORY_ERROR, + _("Cannot access memory at address %s"), + paddress (target_gdbarch, memaddr)); else - { - fprintf_filtered (tmp_stream, "Error accessing memory address "); - deprecated_print_address_numeric (memaddr, 1, tmp_stream); - fprintf_filtered (tmp_stream, ": %s.", - safe_strerror (status)); - } - - error_stream (tmp_stream); + throw_error (MEMORY_ERROR, + _("Error accessing memory address %s: %s."), + paddress (target_gdbarch, memaddr), + safe_strerror (status)); } /* Same as target_read_memory, but report an error if can't read. */ + void -read_memory (CORE_ADDR memaddr, char *myaddr, int len) +read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len) { int status; + status = target_read_memory (memaddr, myaddr, len); if (status != 0) memory_error (status, memaddr); } +/* Same as target_read_stack, but report an error if can't read. */ + +void +read_stack (CORE_ADDR memaddr, gdb_byte *myaddr, int len) +{ + int status; + + status = target_read_stack (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 @@ -250,6 +260,7 @@ struct captured_read_memory_integer_arguments { CORE_ADDR memaddr; int len; + enum bfd_endian byte_order; LONGEST result; }; @@ -266,8 +277,9 @@ 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; + enum bfd_endian byte_order = args->byte_order; - args->result = read_memory_integer (memaddr, len); + args->result = read_memory_integer (memaddr, len, byte_order); return 1; } @@ -277,12 +289,16 @@ do_captured_read_memory_integer (void *data) if successful. */ int -safe_read_memory_integer (CORE_ADDR memaddr, int len, LONGEST *return_value) +safe_read_memory_integer (CORE_ADDR memaddr, int len, + enum bfd_endian byte_order, + LONGEST *return_value) { int status; struct captured_read_memory_integer_arguments args; + args.memaddr = memaddr; args.len = len; + args.byte_order = byte_order; status = catch_errors (do_captured_read_memory_integer, &args, "", RETURN_MASK_ALL); @@ -293,21 +309,21 @@ safe_read_memory_integer (CORE_ADDR memaddr, int len, LONGEST *return_value) } LONGEST -read_memory_integer (CORE_ADDR memaddr, int len) +read_memory_integer (CORE_ADDR memaddr, int len, enum bfd_endian byte_order) { - char buf[sizeof (LONGEST)]; + gdb_byte buf[sizeof (LONGEST)]; read_memory (memaddr, buf, len); - return extract_signed_integer (buf, len); + return extract_signed_integer (buf, len, byte_order); } ULONGEST -read_memory_unsigned_integer (CORE_ADDR memaddr, int len) +read_memory_unsigned_integer (CORE_ADDR memaddr, int len, enum bfd_endian byte_order) { - char buf[sizeof (ULONGEST)]; + gdb_byte buf[sizeof (ULONGEST)]; read_memory (memaddr, buf, len); - return extract_unsigned_integer (buf, len); + return extract_unsigned_integer (buf, len, byte_order); } void @@ -340,7 +356,8 @@ read_memory_string (CORE_ADDR memaddr, char *buffer, int max_len) CORE_ADDR read_memory_typed_address (CORE_ADDR addr, struct type *type) { - char *buf = alloca (TYPE_LENGTH (type)); + gdb_byte *buf = alloca (TYPE_LENGTH (type)); + read_memory (addr, buf, TYPE_LENGTH (type)); return extract_typed_address (buf, type); } @@ -350,65 +367,35 @@ void write_memory (CORE_ADDR memaddr, const bfd_byte *myaddr, int len) { int status; - bfd_byte *bytes = alloca (len); - - memcpy (bytes, myaddr, len); - status = target_write_memory (memaddr, bytes, len); + + 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) +write_memory_unsigned_integer (CORE_ADDR addr, int len, + enum bfd_endian byte_order, + ULONGEST value) { - char *buf = alloca (len); - store_unsigned_integer (buf, len, value); - write_memory (addr, buf, len); -} + gdb_byte *buf = alloca (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); + store_unsigned_integer (buf, len, byte_order, value); write_memory (addr, buf, len); } - - -#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. */ +/* Store VALUE at ADDR in the inferior as a LEN-byte signed integer. */ void -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) +write_memory_signed_integer (CORE_ADDR addr, int len, + enum bfd_endian byte_order, + LONGEST value) { - int i; - CORE_ADDR curaddr = startaddr; + gdb_byte *buf = alloca (len); - 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; - } - *addr_found = (CORE_ADDR) 0; - return; + store_signed_integer (buf, len, byte_order, value); + write_memory (addr, buf, len); } -#endif /* 0 */ /* The current default bfd target. Points to storage allocated for gnutarget_string. */ @@ -416,6 +403,12 @@ char *gnutarget; /* Same thing, except it is "auto" not NULL for the default case. */ static char *gnutarget_string; +static void +show_gnutarget_string (struct ui_file *file, int from_tty, + struct cmd_list_element *c, const char *value) +{ + fprintf_filtered (file, _("The current BFD target is \"%s\".\n"), value); +} static void set_gnutarget_command (char *, int, struct cmd_list_element *); @@ -434,7 +427,7 @@ set_gnutarget (char *newtarget) { if (gnutarget_string != NULL) xfree (gnutarget_string); - gnutarget_string = savestring (newtarget, strlen (newtarget)); + gnutarget_string = xstrdup (newtarget); set_gnutarget_command (NULL, 0, NULL); } @@ -442,19 +435,22 @@ void _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, - (char *) &gnutarget_string, - "Set the current BFD target.\n\ -Use `set gnutarget auto' to specify automatic detection.", - &setlist); - set_cmd_sfunc (c, set_gnutarget_command); - deprecated_add_show_from_set (c, &showlist); + + add_setshow_string_noescape_cmd ("gnutarget", class_files, + &gnutarget_string, _("\ +Set the current BFD target."), _("\ +Show the current BFD target."), _("\ +Use `set gnutarget auto' to specify automatic detection."), + set_gnutarget_command, + show_gnutarget_string, + &setlist, &showlist); if (getenv ("GNUTARGET")) set_gnutarget (getenv ("GNUTARGET"));