/* Core dump and executable file functions below target vector, for GDB.
- Copyright (C) 1986-2014 Free Software Foundation, Inc.
+ Copyright (C) 1986-2018 Free Software Foundation, Inc.
This file is part of GDB.
#include "defs.h"
#include "arch-utils.h"
-#include <string.h>
-#include <errno.h>
#include <signal.h>
#include <fcntl.h>
#ifdef HAVE_SYS_FILE_H
#include "symfile.h"
#include "exec.h"
#include "readline/readline.h"
-#include "gdb_assert.h"
-#include "exceptions.h"
#include "solib.h"
#include "filenames.h"
#include "progspace.h"
#define O_LARGEFILE 0
#endif
+/* The core file target. */
+
+static const target_info core_target_info = {
+ "core",
+ N_("Local core dump file"),
+ N_("Use a core file as a target. Specify the filename of the core file.")
+};
+
+class core_target final : public target_ops
+{
+public:
+ core_target ()
+ { to_stratum = process_stratum; }
+
+ const target_info &info () const override
+ { return core_target_info; }
+
+ void close () override;
+ void detach (inferior *, int) override;
+ void fetch_registers (struct regcache *, int) override;
+
+ enum target_xfer_status xfer_partial (enum target_object object,
+ const char *annex,
+ gdb_byte *readbuf,
+ const gdb_byte *writebuf,
+ ULONGEST offset, ULONGEST len,
+ ULONGEST *xfered_len) override;
+ void files_info () override;
+
+ bool thread_alive (ptid_t ptid) override;
+ const struct target_desc *read_description () override;
+
+ const char *pid_to_str (ptid_t) override;
+
+ const char *thread_name (struct thread_info *) override;
+
+ bool has_memory () override;
+ bool has_stack () override;
+ bool has_registers () override;
+ bool info_proc (const char *, enum info_proc_what) override;
+};
+
+/* See gdbcore.h. */
+struct target_ops *the_core_target;
+
/* List of all available core_fns. On gdb startup, each core file
register reader calls deprecated_add_core_fns() to register
information on each core format it is prepared to read. */
unix child targets. */
static struct target_section_table *core_data;
-static void core_files_info (struct target_ops *);
-
static struct core_fns *sniff_core_bfd (bfd *);
static int gdb_check_format (bfd *);
-static void core_open (char *, int);
-
-static void core_close (struct target_ops *self);
-
static void core_close_cleanup (void *ignore);
static void add_to_thread_list (bfd *, asection *, void *);
-static void init_core_ops (void);
-
-void _initialize_corelow (void);
-
-static struct target_ops core_ops;
+static core_target core_ops;
/* An arbitrary identifier for the core inferior. */
#define CORELOW_PID 1
{
struct core_fns *cf;
struct core_fns *yummy = NULL;
- int matches = 0;;
+ int matches = 0;
/* Don't sniff if we have support for register sets in
CORE_GDBARCH. */
- if (core_gdbarch && gdbarch_regset_from_core_section_p (core_gdbarch))
+ if (core_gdbarch && gdbarch_iterate_over_regset_sections_p (core_gdbarch))
return NULL;
for (cf = core_file_fns; cf != NULL; cf = cf->next)
stack spaces as empty. */
static void
-core_close (struct target_ops *self)
+core_close ()
{
if (core_bfd)
{
static void
core_close_cleanup (void *ignore)
{
- core_close (NULL);
+ core_close ();
+}
+
+void
+core_target::close ()
+{
+ core_close ();
}
/* Look for sections whose names start with `.reg/' so that we can
int fake_pid_p = 0;
struct inferior *inf;
- if (strncmp (bfd_section_name (abfd, asect), ".reg/", 5) != 0)
+ if (!startswith (bfd_section_name (abfd, asect), ".reg/"))
return;
core_tid = atoi (bfd_section_name (abfd, asect) + 5);
inferior_ptid = ptid; /* Yes, make it current. */
}
-/* This routine opens and sets up the core file bfd. */
+/* See gdbcore.h. */
-static void
-core_open (char *filename, int from_tty)
+void
+core_target_open (const char *arg, int from_tty)
{
const char *p;
int siggy;
struct cleanup *old_chain;
- char *temp;
- bfd *temp_bfd;
int scratch_chan;
int flags;
- volatile struct gdb_exception except;
target_preopen (from_tty);
- if (!filename)
+ if (!arg)
{
if (core_bfd)
error (_("No core file specified. (Use `detach' "
error (_("No core file specified."));
}
- filename = tilde_expand (filename);
- if (!IS_ABSOLUTE_PATH (filename))
- {
- temp = concat (current_directory, "/",
- filename, (char *) NULL);
- xfree (filename);
- filename = temp;
- }
-
- old_chain = make_cleanup (xfree, filename);
+ gdb::unique_xmalloc_ptr<char> filename (tilde_expand (arg));
+ if (!IS_ABSOLUTE_PATH (filename.get ()))
+ filename.reset (concat (current_directory, "/",
+ filename.get (), (char *) NULL));
flags = O_BINARY | O_LARGEFILE;
if (write_files)
flags |= O_RDWR;
else
flags |= O_RDONLY;
- scratch_chan = gdb_open_cloexec (filename, flags, 0);
+ scratch_chan = gdb_open_cloexec (filename.get (), flags, 0);
if (scratch_chan < 0)
- perror_with_name (filename);
+ perror_with_name (filename.get ());
- temp_bfd = gdb_bfd_fopen (filename, gnutarget,
- write_files ? FOPEN_RUB : FOPEN_RB,
- scratch_chan);
+ gdb_bfd_ref_ptr temp_bfd (gdb_bfd_fopen (filename.get (), gnutarget,
+ write_files ? FOPEN_RUB : FOPEN_RB,
+ scratch_chan));
if (temp_bfd == NULL)
- perror_with_name (filename);
+ perror_with_name (filename.get ());
- if (!bfd_check_format (temp_bfd, bfd_core)
- && !gdb_check_format (temp_bfd))
+ if (!bfd_check_format (temp_bfd.get (), bfd_core)
+ && !gdb_check_format (temp_bfd.get ()))
{
/* Do it after the err msg */
/* FIXME: should be checking for errors from bfd_close (for one
thing, on error it does not free all the storage associated
with the bfd). */
- make_cleanup_bfd_unref (temp_bfd);
error (_("\"%s\" is not a core dump: %s"),
- filename, bfd_errmsg (bfd_get_error ()));
+ filename.get (), bfd_errmsg (bfd_get_error ()));
}
/* Looks semi-reasonable. Toss the old core file and work on the
new. */
- do_cleanups (old_chain);
unpush_target (&core_ops);
- core_bfd = temp_bfd;
+ core_bfd = temp_bfd.release ();
old_chain = make_cleanup (core_close_cleanup, 0 /*ignore*/);
core_gdbarch = gdbarch_from_bfd (core_bfd);
may be a thread_stratum target loaded on top of target core by
now. The layer above should claim threads found in the BFD
sections. */
- TRY_CATCH (except, RETURN_MASK_ERROR)
+ TRY
{
- target_find_new_threads ();
+ target_update_thread_list ();
}
- if (except.reason < 0)
- exception_print (gdb_stderr, except);
+ CATCH (except, RETURN_MASK_ERROR)
+ {
+ exception_print (gdb_stderr, except);
+ }
+ END_CATCH
p = bfd_core_file_failing_command (core_bfd);
if (p)
/* Now, set up the frame cache, and print the top of stack. */
reinit_frame_cache ();
print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1);
+
+ /* Current thread should be NUM 1 but the user does not know that.
+ If a program is single threaded gdb in general does not mention
+ anything about threads. That is why the test is >= 2. */
+ if (thread_count () >= 2)
+ {
+ TRY
+ {
+ thread_command (NULL, from_tty);
+ }
+ CATCH (except, RETURN_MASK_ERROR)
+ {
+ exception_print (gdb_stderr, except);
+ }
+ END_CATCH
+ }
}
-static void
-core_detach (struct target_ops *ops, const char *args, int from_tty)
+void
+core_target::detach (inferior *inf, int from_tty)
{
- if (args)
- error (_("Too many arguments"));
- unpush_target (ops);
+ unpush_target (this);
reinit_frame_cache ();
if (from_tty)
printf_filtered (_("No core file now.\n"));
them to core_vec->core_read_registers, as the register set numbered
WHICH.
- If inferior_ptid's lwp member is zero, do the single-threaded
- thing: look for a section named NAME. If inferior_ptid's lwp
+ If ptid's lwp member is zero, do the single-threaded
+ thing: look for a section named NAME. If ptid's lwp
member is non-zero, do the multi-threaded thing: look for a section
named "NAME/LWP", where LWP is the shortest ASCII decimal
- representation of inferior_ptid's lwp member.
+ representation of ptid's lwp member.
HUMAN_NAME is a human-readable name for the kind of registers the
NAME section contains, for use in error messages.
static void
get_core_register_section (struct regcache *regcache,
+ const struct regset *regset,
const char *name,
+ int min_size,
int which,
const char *human_name,
int required)
{
- static char *section_name = NULL;
struct bfd_section *section;
bfd_size_type size;
char *contents;
+ bool variable_size_section = (regset != NULL
+ && regset->flags & REGSET_VARIABLE_SIZE);
- xfree (section_name);
+ thread_section_name section_name (name, regcache->ptid ());
- if (ptid_get_lwp (inferior_ptid))
- section_name = xstrprintf ("%s/%ld", name,
- ptid_get_lwp (inferior_ptid));
- else
- section_name = xstrdup (name);
-
- section = bfd_get_section_by_name (core_bfd, section_name);
+ section = bfd_get_section_by_name (core_bfd, section_name.c_str ());
if (! section)
{
if (required)
}
size = bfd_section_size (core_bfd, section);
- contents = alloca (size);
+ if (size < min_size)
+ {
+ warning (_("Section `%s' in core file too small."),
+ section_name.c_str ());
+ return;
+ }
+ if (size != min_size && !variable_size_section)
+ {
+ warning (_("Unexpected size of section `%s' in core file."),
+ section_name.c_str ());
+ }
+
+ contents = (char *) alloca (size);
if (! bfd_get_section_contents (core_bfd, section, contents,
(file_ptr) 0, size))
{
warning (_("Couldn't read %s registers from `%s' section in core file."),
- human_name, name);
+ human_name, section_name.c_str ());
return;
}
- if (core_gdbarch && gdbarch_regset_from_core_section_p (core_gdbarch))
+ if (regset != NULL)
{
- const struct regset *regset;
-
- regset = gdbarch_regset_from_core_section (core_gdbarch,
- name, size);
- if (regset == NULL)
- {
- if (required)
- warning (_("Couldn't recognize %s registers in core file."),
- human_name);
- return;
- }
-
regset->supply_regset (regset, regcache, -1, contents, size);
return;
}
bfd_section_vma (core_bfd, section)));
}
+/* Callback for get_core_registers that handles a single core file
+ register note section. */
+
+static void
+get_core_registers_cb (const char *sect_name, int size,
+ const struct regset *regset,
+ const char *human_name, void *cb_data)
+{
+ struct regcache *regcache = (struct regcache *) cb_data;
+ int required = 0;
+
+ if (strcmp (sect_name, ".reg") == 0)
+ {
+ required = 1;
+ if (human_name == NULL)
+ human_name = "general-purpose";
+ }
+ else if (strcmp (sect_name, ".reg2") == 0)
+ {
+ if (human_name == NULL)
+ human_name = "floating-point";
+ }
+
+ /* The 'which' parameter is only used when no regset is provided.
+ Thus we just set it to -1. */
+ get_core_register_section (regcache, regset, sect_name,
+ size, -1, human_name, required);
+}
/* Get the registers out of a core file. This is the machine-
independent part. Fetch_core_registers is the machine-dependent
/* We just get all the registers, so we don't use regno. */
-static void
-get_core_registers (struct target_ops *ops,
- struct regcache *regcache, int regno)
+void
+core_target::fetch_registers (struct regcache *regcache, int regno)
{
- struct core_regset_section *sect_list;
int i;
+ struct gdbarch *gdbarch;
- if (!(core_gdbarch && gdbarch_regset_from_core_section_p (core_gdbarch))
+ if (!(core_gdbarch && gdbarch_iterate_over_regset_sections_p (core_gdbarch))
&& (core_vec == NULL || core_vec->core_read_registers == NULL))
{
fprintf_filtered (gdb_stderr,
return;
}
- sect_list = gdbarch_core_regset_sections (get_regcache_arch (regcache));
- if (sect_list)
- while (sect_list->sect_name != NULL)
- {
- if (strcmp (sect_list->sect_name, ".reg") == 0)
- get_core_register_section (regcache, sect_list->sect_name,
- 0, sect_list->human_name, 1);
- else if (strcmp (sect_list->sect_name, ".reg2") == 0)
- get_core_register_section (regcache, sect_list->sect_name,
- 2, sect_list->human_name, 0);
- else
- get_core_register_section (regcache, sect_list->sect_name,
- 3, sect_list->human_name, 0);
-
- sect_list++;
- }
-
+ gdbarch = regcache->arch ();
+ if (gdbarch_iterate_over_regset_sections_p (gdbarch))
+ gdbarch_iterate_over_regset_sections (gdbarch,
+ get_core_registers_cb,
+ (void *) regcache, NULL);
else
{
- get_core_register_section (regcache,
- ".reg", 0, "general-purpose", 1);
- get_core_register_section (regcache,
- ".reg2", 2, "floating-point", 0);
+ get_core_register_section (regcache, NULL,
+ ".reg", 0, 0, "general-purpose", 1);
+ get_core_register_section (regcache, NULL,
+ ".reg2", 0, 2, "floating-point", 0);
}
/* Mark all registers not found in the core as unavailable. */
- for (i = 0; i < gdbarch_num_regs (get_regcache_arch (regcache)); i++)
+ for (i = 0; i < gdbarch_num_regs (regcache->arch ()); i++)
if (regcache_register_status (regcache, i) == REG_UNKNOWN)
regcache_raw_supply (regcache, i, NULL);
}
-static void
-core_files_info (struct target_ops *t)
+void
+core_target::files_info ()
{
print_section_info (core_data, core_bfd);
}
static void
add_to_spuid_list (bfd *abfd, asection *asect, void *list_p)
{
- struct spuid_list *list = list_p;
+ struct spuid_list *list = (struct spuid_list *) list_p;
enum bfd_endian byte_order
= bfd_big_endian (abfd) ? BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE;
int fd, pos = 0;
list->pos += 4;
}
-/* Read siginfo data from the core, if possible. Returns -1 on
- failure. Otherwise, returns the number of bytes read. ABFD is the
- core file's BFD; READBUF, OFFSET, and LEN are all as specified by
- the to_xfer_partial interface. */
-
-static LONGEST
-get_core_siginfo (bfd *abfd, gdb_byte *readbuf, ULONGEST offset, ULONGEST len)
-{
- asection *section;
- char *section_name;
- const char *name = ".note.linuxcore.siginfo";
-
- if (ptid_get_lwp (inferior_ptid))
- section_name = xstrprintf ("%s/%ld", name,
- ptid_get_lwp (inferior_ptid));
- else
- section_name = xstrdup (name);
-
- section = bfd_get_section_by_name (abfd, section_name);
- xfree (section_name);
- if (section == NULL)
- return -1;
-
- if (!bfd_get_section_contents (abfd, section, readbuf, offset, len))
- return -1;
-
- return len;
-}
-
-static enum target_xfer_status
-core_xfer_partial (struct target_ops *ops, enum target_object object,
- const char *annex, gdb_byte *readbuf,
- const gdb_byte *writebuf, ULONGEST offset,
- ULONGEST len, ULONGEST *xfered_len)
+enum target_xfer_status
+core_target::xfer_partial (enum target_object object, const char *annex,
+ gdb_byte *readbuf, const gdb_byte *writebuf,
+ ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
{
switch (object)
{
size = bfd_section_size (core_bfd, section);
if (offset >= size)
- return 0;
+ return TARGET_XFER_EOF;
size -= offset;
if (size > len)
size = len;
case TARGET_OBJECT_SIGNAL_INFO:
if (readbuf)
{
- LONGEST l = get_core_siginfo (core_bfd, readbuf, offset, len);
-
- if (l > 0)
+ if (core_gdbarch
+ && gdbarch_core_xfer_siginfo_p (core_gdbarch))
{
- *xfered_len = len;
- return TARGET_XFER_OK;
+ LONGEST l = gdbarch_core_xfer_siginfo (core_gdbarch, readbuf,
+ offset, len);
+
+ if (l >= 0)
+ {
+ *xfered_len = l;
+ if (l == 0)
+ return TARGET_XFER_EOF;
+ else
+ return TARGET_XFER_OK;
+ }
}
}
return TARGET_XFER_E_IO;
default:
- return ops->beneath->to_xfer_partial (ops->beneath, object,
- annex, readbuf,
- writebuf, offset, len,
- xfered_len);
+ return this->beneath->xfer_partial (object, annex, readbuf,
+ writebuf, offset, len,
+ xfered_len);
}
}
\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 (struct target_ops *ops, struct gdbarch *gdbarch,
- struct bp_target_info *bp_tgt)
-{
- return 0;
-}
-
/* Okay, let's be honest: threads gleaned from a core file aren't
exactly lively, are they? On the other hand, if we don't claim
to appear in an "info thread" command, which is quite a useful
behaviour.
*/
-static int
-core_thread_alive (struct target_ops *ops, ptid_t ptid)
+bool
+core_target::thread_alive (ptid_t ptid)
{
- return 1;
+ return true;
}
/* Ask the current architecture what it knows about this core file.
wrapper could be avoided if targets got a chance to specialize
core_ops. */
-static const struct target_desc *
-core_read_description (struct target_ops *target)
+const struct target_desc *
+core_target::read_description ()
{
if (core_gdbarch && gdbarch_core_read_description_p (core_gdbarch))
{
const struct target_desc *result;
- result = gdbarch_core_read_description (core_gdbarch,
- target, core_bfd);
+ result = gdbarch_core_read_description (core_gdbarch, this, core_bfd);
if (result != NULL)
return result;
}
- return target->beneath->to_read_description (target->beneath);
+ return this->beneath->read_description ();
}
-static char *
-core_pid_to_str (struct target_ops *ops, ptid_t ptid)
+const char *
+core_target::pid_to_str (ptid_t ptid)
{
static char buf[64];
struct inferior *inf;
/* Otherwise, this isn't a "threaded" core -- use the PID field, but
only if it isn't a fake PID. */
- inf = find_inferior_pid (ptid_get_pid (ptid));
+ inf = find_inferior_ptid (ptid);
if (inf != NULL && !inf->fake_pid_p)
return normal_pid_to_str (ptid);
return buf;
}
-static int
-core_has_memory (struct target_ops *ops)
+const char *
+core_target::thread_name (struct thread_info *thr)
+{
+ if (core_gdbarch
+ && gdbarch_core_thread_name_p (core_gdbarch))
+ return gdbarch_core_thread_name (core_gdbarch, thr);
+ return NULL;
+}
+
+bool
+core_target::has_memory ()
{
return (core_bfd != NULL);
}
-static int
-core_has_stack (struct target_ops *ops)
+bool
+core_target::has_stack ()
{
return (core_bfd != NULL);
}
-static int
-core_has_registers (struct target_ops *ops)
+bool
+core_target::has_registers ()
{
return (core_bfd != NULL);
}
/* Implement the to_info_proc method. */
-static void
-core_info_proc (struct target_ops *ops, const char *args,
- enum info_proc_what request)
+bool
+core_target::info_proc (const char *args, enum info_proc_what request)
{
struct gdbarch *gdbarch = get_current_arch ();
method on gdbarch, not 'info_proc'. */
if (gdbarch_core_info_proc_p (gdbarch))
gdbarch_core_info_proc (gdbarch, args, request);
-}
-/* Fill in core_ops with its defined operations and properties. */
-
-static void
-init_core_ops (void)
-{
- core_ops.to_shortname = "core";
- core_ops.to_longname = "Local core dump file";
- core_ops.to_doc =
- "Use a core file as a target. Specify the filename of the core file.";
- core_ops.to_open = core_open;
- core_ops.to_close = core_close;
- core_ops.to_detach = core_detach;
- core_ops.to_fetch_registers = get_core_registers;
- core_ops.to_xfer_partial = core_xfer_partial;
- core_ops.to_files_info = core_files_info;
- core_ops.to_insert_breakpoint = ignore;
- core_ops.to_remove_breakpoint = ignore;
- core_ops.to_thread_alive = core_thread_alive;
- core_ops.to_read_description = core_read_description;
- core_ops.to_pid_to_str = core_pid_to_str;
- core_ops.to_stratum = process_stratum;
- core_ops.to_has_memory = core_has_memory;
- core_ops.to_has_stack = core_has_stack;
- core_ops.to_has_registers = core_has_registers;
- core_ops.to_info_proc = core_info_proc;
- core_ops.to_magic = OPS_MAGIC;
-
- if (core_target)
- internal_error (__FILE__, __LINE__,
- _("init_core_ops: core target already exists (\"%s\")."),
- core_target->to_longname);
- core_target = &core_ops;
+ return true;
}
void
_initialize_corelow (void)
{
- init_core_ops ();
+ if (the_core_target != NULL)
+ internal_error (__FILE__, __LINE__,
+ _("core target already exists (\"%s\")."),
+ the_core_target->longname ());
+ the_core_target = &core_ops;
- add_target_with_completer (&core_ops, filename_completer);
+ add_target (core_target_info, core_target_open, filename_completer);
}
projects / deliverable / binutils-gdb.git / blobdiff