/* 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-2020 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,
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 <http://www.gnu.org/licenses/>. */
#include "defs.h"
-#include "gdb_string.h"
-#include <errno.h>
#include <signal.h>
#include <fcntl.h>
#include "inferior.h"
#include "target.h"
#include "gdbcore.h"
#include "dis-asm.h"
-#include "gdb_stat.h"
+#include <sys/stat.h>
#include "completer.h"
-#include "exceptions.h"
-
-/* Local function declarations. */
-
-extern void _initialize_core (void);
-static void call_extra_exec_file_hooks (char *filename);
+#include "observable.h"
+#include "cli/cli-utils.h"
+#include "gdbarch.h"
/* 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
only one hook could be set, and which called
deprecated_exec_file_display_hook directly. */
-typedef void (*hook_type) (char *);
+typedef void (*hook_type) (const char *);
-hook_type deprecated_exec_file_display_hook; /* the original hook */
-static hook_type *exec_file_extra_hooks; /* array of additional hooks */
-static int exec_file_hook_count = 0; /* size of array */
+hook_type deprecated_exec_file_display_hook; /* The original hook. */
+static hook_type *exec_file_extra_hooks; /* Array of additional
+ hooks. */
+static int exec_file_hook_count = 0; /* Size of array. */
-/* Binary file diddling handle for the core file. */
-
-bfd *core_bfd = NULL;
-\f
-
-/* Backward compatability with old way of specifying core files. */
-
-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)
- 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);
-}
\f
/* If there are two or more functions that wish to hook into
functions. */
static void
-call_extra_exec_file_hooks (char *filename)
+call_extra_exec_file_hooks (const char *filename)
{
int i;
This is called from the x-window display code. */
void
-specify_exec_file_hook (void (*hook) (char *))
+specify_exec_file_hook (void (*hook) (const char *))
{
hook_type *new_array;
if (deprecated_exec_file_display_hook != NULL)
{
/* There's already a hook installed. Arrange to have both it
- * and the subsequent hooks called. */
+ and the subsequent hooks called. */
if (exec_file_hook_count == 0)
{
- /* If this is the first extra hook, initialize the hook array. */
- exec_file_extra_hooks = (hook_type *) xmalloc (sizeof (hook_type));
+ /* If this is the first extra hook, initialize the hook
+ array. */
+ exec_file_extra_hooks = XNEW (hook_type);
exec_file_extra_hooks[0] = deprecated_exec_file_display_hook;
deprecated_exec_file_display_hook = call_extra_exec_file_hooks;
exec_file_hook_count = 1;
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,
- exec_file_hook_count * sizeof (hook_type));
+ new_array = (hook_type *)
+ xrealloc (exec_file_extra_hooks,
+ exec_file_hook_count * sizeof (hook_type));
exec_file_extra_hooks = new_array;
exec_file_extra_hooks[exec_file_hook_count - 1] = hook;
}
deprecated_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
-close_exec_file (void)
-{
-#if 0 /* FIXME */
- if (exec_bfd)
- bfd_tempclose (exec_bfd);
-#endif
-}
-
void
reopen_exec_file (void)
{
-#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)
+ /* 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);
- res = stat (filename, &st);
+ /* If the timestamp of the exec file has changed, reopen it. */
+ std::string filename = bfd_get_filename (exec_bfd);
+ res = stat (filename.c_str (), &st);
- if (mtime && mtime != st.st_mtime)
- {
- exec_open (filename, 0);
- }
-#endif
+ if (res == 0 && exec_bfd_mtime && exec_bfd_mtime != st.st_mtime)
+ exec_file_attach (filename.c_str (), 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 ();
}
\f
/* If we have both a core file and an exec 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. */
+/* See gdbsupport/common-inferior.h. */
-char *
+const char *
get_exec_file (int err)
{
- if (exec_bfd)
- return bfd_get_filename (exec_bfd);
+ if (exec_filename)
+ return exec_filename;
if (!err)
return NULL;
error (_("No executable file specified.\n\
Use the \"file\" or \"exec-file\" command."));
- return NULL;
}
\f
-/* Report a memory error with error(). */
+std::string
+memory_error_message (enum target_xfer_status err,
+ struct gdbarch *gdbarch, CORE_ADDR memaddr)
+{
+ switch (err)
+ {
+ case TARGET_XFER_E_IO:
+ /* Actually, address between memaddr and memaddr + len was out of
+ bounds. */
+ return string_printf (_("Cannot access memory at address %s"),
+ paddress (gdbarch, memaddr));
+ case TARGET_XFER_UNAVAILABLE:
+ return string_printf (_("Memory at address %s unavailable."),
+ paddress (gdbarch, memaddr));
+ default:
+ internal_error (__FILE__, __LINE__,
+ "unhandled target_xfer_status: %s (%s)",
+ target_xfer_status_to_string (err),
+ plongest (err));
+ }
+}
+
+/* Report a memory error by throwing a suitable exception. */
void
-memory_error (int status, CORE_ADDR memaddr)
+memory_error (enum target_xfer_status err, CORE_ADDR memaddr)
{
- struct ui_file *tmp_stream = mem_fileopen ();
- make_cleanup_ui_file_delete (tmp_stream);
+ enum errors exception = GDB_NO_ERROR;
+
+ /* Build error string. */
+ std::string str = memory_error_message (err, target_gdbarch (), memaddr);
- if (status == EIO)
+ /* Choose the right error to throw. */
+ switch (err)
{
- /* 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);
+ case TARGET_XFER_E_IO:
+ exception = MEMORY_ERROR;
+ break;
+ case TARGET_XFER_UNAVAILABLE:
+ exception = NOT_AVAILABLE_ERROR;
+ break;
}
- else
+
+ /* Throw it. */
+ throw_error (exception, ("%s"), str.c_str ());
+}
+
+/* Helper function. */
+
+static void
+read_memory_object (enum target_object object, CORE_ADDR memaddr,
+ gdb_byte *myaddr, ssize_t len)
+{
+ ULONGEST xfered = 0;
+
+ while (xfered < len)
{
- fprintf_filtered (tmp_stream, "Error accessing memory address ");
- deprecated_print_address_numeric (memaddr, 1, tmp_stream);
- fprintf_filtered (tmp_stream, ": %s.",
- safe_strerror (status));
- }
+ enum target_xfer_status status;
+ ULONGEST xfered_len;
+
+ status = target_xfer_partial (current_top_target (), object, NULL,
+ myaddr + xfered, NULL,
+ memaddr + xfered, len - xfered,
+ &xfered_len);
+
+ if (status != TARGET_XFER_OK)
+ memory_error (status == TARGET_XFER_EOF ? TARGET_XFER_E_IO : status,
+ memaddr + xfered);
- error_stream (tmp_stream);
+ xfered += xfered_len;
+ QUIT;
+ }
}
/* 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, ssize_t len)
{
- int status;
- status = target_read_memory (memaddr, myaddr, len);
- if (status != 0)
- memory_error (status, memaddr);
+ read_memory_object (TARGET_OBJECT_MEMORY, memaddr, myaddr, len);
+}
+
+/* Same as target_read_stack, but report an error if can't read. */
+
+void
+read_stack (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
+{
+ read_memory_object (TARGET_OBJECT_STACK_MEMORY, memaddr, myaddr, len);
}
-/* 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. */
+/* Same as target_read_code, but report an error if can't read. */
-struct captured_read_memory_integer_arguments
+void
+read_code (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
{
- 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)
+ read_memory_object (TARGET_OBJECT_CODE_MEMORY, memaddr, myaddr, len);
+}
+
+/* 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,
+ enum bfd_endian byte_order,
+ LONGEST *return_value)
{
- struct captured_read_memory_integer_arguments *args = (struct captured_read_memory_integer_arguments*) data;
- CORE_ADDR memaddr = args->memaddr;
- int len = args->len;
+ gdb_byte buf[sizeof (LONGEST)];
- args->result = read_memory_integer (memaddr, len);
+ if (target_read_memory (memaddr, buf, len))
+ return 0;
+ *return_value = extract_signed_integer (buf, len, byte_order);
return 1;
}
if successful. */
int
-safe_read_memory_integer (CORE_ADDR memaddr, int len, LONGEST *return_value)
+safe_read_memory_unsigned_integer (CORE_ADDR memaddr, int len,
+ enum bfd_endian byte_order,
+ ULONGEST *return_value)
{
- int status;
- struct captured_read_memory_integer_arguments args;
- args.memaddr = memaddr;
- args.len = len;
+ gdb_byte buf[sizeof (ULONGEST)];
- status = catch_errors (do_captured_read_memory_integer, &args,
- "", RETURN_MASK_ALL);
- if (status)
- *return_value = args.result;
+ if (target_read_memory (memaddr, buf, len))
+ return 0;
- return status;
+ *return_value = extract_unsigned_integer (buf, len, byte_order);
+ return 1;
}
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);
+}
+
+LONGEST
+read_code_integer (CORE_ADDR memaddr, int len,
+ enum bfd_endian byte_order)
+{
+ gdb_byte buf[sizeof (LONGEST)];
+
+ read_code (memaddr, buf, len);
+ return extract_signed_integer (buf, len, byte_order);
+}
+
+ULONGEST
+read_code_unsigned_integer (CORE_ADDR memaddr, int len,
+ enum bfd_endian byte_order)
+{
+ gdb_byte buf[sizeof (ULONGEST)];
+
+ read_code (memaddr, buf, len);
+ return extract_unsigned_integer (buf, len, byte_order);
}
void
cnt = max_len - (cp - buffer);
if (cnt > 8)
cnt = 8;
- read_memory (memaddr + (int) (cp - buffer), cp, cnt);
+ read_memory (memaddr + (int) (cp - buffer), (gdb_byte *) cp, cnt);
for (i = 0; i < cnt && *cp; i++, cp++)
; /* null body */
CORE_ADDR
read_memory_typed_address (CORE_ADDR addr, struct type *type)
{
- char *buf = alloca (TYPE_LENGTH (type));
+ gdb_byte *buf = (gdb_byte *) 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. */
+/* See gdbcore.h. */
+
void
-write_memory (CORE_ADDR memaddr, const bfd_byte *myaddr, int len)
+write_memory (CORE_ADDR memaddr,
+ const bfd_byte *myaddr, ssize_t 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);
+ memory_error (TARGET_XFER_E_IO, memaddr);
}
-/* Store VALUE at ADDR in the inferior as a LEN-byte unsigned integer. */
+/* Same as write_memory, but notify 'memory_changed' observers. */
+
void
-write_memory_unsigned_integer (CORE_ADDR addr, int len, ULONGEST value)
+write_memory_with_notification (CORE_ADDR memaddr, const bfd_byte *myaddr,
+ ssize_t len)
{
- char *buf = alloca (len);
- store_unsigned_integer (buf, len, value);
- write_memory (addr, buf, len);
+ write_memory (memaddr, myaddr, len);
+ gdb::observers::memory_changed.notify (current_inferior (), memaddr, len, myaddr);
}
-/* Store VALUE at ADDR in the inferior as a LEN-byte signed integer. */
+/* Store VALUE at ADDR in the inferior as a LEN-byte unsigned
+ integer. */
void
-write_memory_signed_integer (CORE_ADDR addr, int len, LONGEST value)
+write_memory_unsigned_integer (CORE_ADDR addr, int len,
+ enum bfd_endian byte_order,
+ ULONGEST value)
{
- char *buf = alloca (len);
- store_signed_integer (buf, len, value);
+ gdb_byte *buf = (gdb_byte *) alloca (len);
+
+ store_unsigned_integer (buf, len, byte_order, value);
write_memory (addr, buf, len);
}
-\f
-
-#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 = (gdb_byte *) 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 */
\f
/* The current default bfd target. Points to storage allocated for
gnutarget_string. */
-char *gnutarget;
+const char *gnutarget;
/* Same thing, except it is "auto" not NULL for the default case. */
static char *gnutarget_string;
-
-static void set_gnutarget_command (char *, int, struct cmd_list_element *);
+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 *ignore, int from_tty, struct cmd_list_element *c)
+set_gnutarget_command (const char *ignore, int from_tty,
+ struct cmd_list_element *c)
{
+ char *gend = gnutarget_string + strlen (gnutarget_string);
+
+ gend = remove_trailing_whitespace (gnutarget_string, gend);
+ *gend = '\0';
+
if (strcmp (gnutarget_string, "auto") == 0)
gnutarget = NULL;
else
gnutarget = gnutarget_string;
}
+/* A completion function for "set gnutarget". */
+
+static void
+complete_set_gnutarget (struct cmd_list_element *cmd,
+ completion_tracker &tracker,
+ const char *text, const char *word)
+{
+ static const char **bfd_targets;
+
+ if (bfd_targets == NULL)
+ {
+ int last;
+
+ bfd_targets = bfd_target_list ();
+ for (last = 0; bfd_targets[last] != NULL; ++last)
+ ;
+
+ bfd_targets = XRESIZEVEC (const char *, bfd_targets, last + 2);
+ bfd_targets[last] = "auto";
+ bfd_targets[last + 1] = NULL;
+ }
+
+ complete_on_enum (tracker, bfd_targets, text, word);
+}
+
/* Set the gnutarget. */
void
-set_gnutarget (char *newtarget)
+set_gnutarget (const char *newtarget)
{
- if (gnutarget_string != NULL)
- xfree (gnutarget_string);
- gnutarget_string = savestring (newtarget, strlen (newtarget));
+ xfree (gnutarget_string);
+ gnutarget_string = xstrdup (newtarget);
set_gnutarget_command (NULL, 0, NULL);
}
+void _initialize_core ();
void
-_initialize_core (void)
+_initialize_core ()
{
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\
+Usage: core-file FILE\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);
- add_setshow_string_noescape_cmd ("gnutarget", class_files,
- &gnutarget_string, _("(\
+ c = 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,
- NULL, /* FIXME: i18n: */
- &setlist, &showlist);
+ set_gnutarget_command,
+ show_gnutarget_string,
+ &setlist, &showlist);
+ set_cmd_completer (c, complete_set_gnutarget);
+
+ add_alias_cmd ("g", "gnutarget", class_files, 1, &setlist);
if (getenv ("GNUTARGET"))
set_gnutarget (getenv ("GNUTARGET"));
projects / deliverable / binutils-gdb.git / blobdiff