/* Trace file support in GDB.
- Copyright (C) 1997-2014 Free Software Foundation, Inc.
+ Copyright (C) 1997-2017 Free Software Foundation, Inc.
This file is part of GDB.
#include "defs.h"
#include "tracefile.h"
#include "ctf.h"
+#include "exec.h"
+#include "regcache.h"
/* Helper macros. */
static void
trace_file_writer_xfree (void *arg)
{
- struct trace_file_writer *writer = arg;
+ struct trace_file_writer *writer = (struct trace_file_writer *) arg;
writer->ops->dtor (writer);
xfree (writer);
int target_does_save)
{
struct trace_status *ts = current_trace_status ();
- int status;
struct uploaded_tp *uploaded_tps = NULL, *utp;
struct uploaded_tsv *uploaded_tsvs = NULL, *utsv;
ULONGEST offset = 0;
#define MAX_TRACE_UPLOAD 2000
gdb_byte buf[MAX_TRACE_UPLOAD];
- int written;
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
/* If the target is to save the data to a file on its own, then just
}
/* Get the trace status first before opening the file, so if the
- target is losing, we can get out without touching files. */
- status = target_get_trace_status (ts);
+ target is losing, we can get out without touching files. Since
+ we're just calling this for side effects, we ignore the
+ result. */
+ target_get_trace_status (ts);
writer->ops->start (writer, filename);
/* Write out the size of a register block. */
writer->ops->write_regblock_type (writer, trace_regblock_size);
+ /* Write out the target description info. */
+ writer->ops->write_tdesc (writer);
+
/* Write out status of the tracing run (aka "tstatus" info). */
writer->ops->write_status (writer, ts);
}
static void
-trace_save_command (char *args, int from_tty)
+tsave_command (const char *args, int from_tty)
{
int target_does_save = 0;
char **argv;
if (args == NULL)
error_no_arg (_("file in which to save trace data"));
- argv = gdb_buildargv (args);
- back_to = make_cleanup_freeargv (argv);
+ gdb_argv built_argv (args);
+ argv = built_argv.get ();
for (; *argv; ++argv)
{
if (strcmp (*argv, "-r") == 0)
target_does_save = 1;
- if (strcmp (*argv, "-ctf") == 0)
+ else if (strcmp (*argv, "-ctf") == 0)
generate_ctf = 1;
else if (**argv == '-')
error (_("unknown option `%s'"), *argv);
else
writer = tfile_trace_file_writer_new ();
- make_cleanup (trace_file_writer_xfree, writer);
+ back_to = make_cleanup (trace_file_writer_xfree, writer);
trace_save (filename, writer, target_does_save);
do_cleanups (back_to);
}
-extern initialize_file_ftype _initialize_tracefile;
+/* Fetch register data from tracefile, shared for both tfile and
+ ctf. */
+
+void
+tracefile_fetch_registers (struct regcache *regcache, int regno)
+{
+ struct gdbarch *gdbarch = regcache->arch ();
+ struct tracepoint *tp = get_tracepoint (get_tracepoint_number ());
+ int regn;
+
+ /* We get here if no register data has been found. Mark registers
+ as unavailable. */
+ for (regn = 0; regn < gdbarch_num_regs (gdbarch); regn++)
+ regcache_raw_supply (regcache, regn, NULL);
+
+ /* We can often usefully guess that the PC is going to be the same
+ as the address of the tracepoint. */
+ if (tp == NULL || tp->loc == NULL)
+ return;
+
+ /* But don't try to guess if tracepoint is multi-location... */
+ if (tp->loc->next)
+ {
+ warning (_("Tracepoint %d has multiple "
+ "locations, cannot infer $pc"),
+ tp->number);
+ return;
+ }
+ /* ... or does while-stepping. */
+ else if (tp->step_count > 0)
+ {
+ warning (_("Tracepoint %d does while-stepping, "
+ "cannot infer $pc"),
+ tp->number);
+ return;
+ }
+
+ /* Guess what we can from the tracepoint location. */
+ gdbarch_guess_tracepoint_registers (gdbarch, regcache,
+ tp->loc->address);
+}
+
+/* This is the implementation of target_ops method to_has_all_memory. */
+
+static int
+tracefile_has_all_memory (struct target_ops *ops)
+{
+ return 1;
+}
+
+/* This is the implementation of target_ops method to_has_memory. */
+
+static int
+tracefile_has_memory (struct target_ops *ops)
+{
+ return 1;
+}
+
+/* This is the implementation of target_ops method to_has_stack.
+ The target has a stack when GDB has already selected one trace
+ frame. */
+
+static int
+tracefile_has_stack (struct target_ops *ops)
+{
+ return get_traceframe_number () != -1;
+}
+
+/* This is the implementation of target_ops method to_has_registers.
+ The target has registers when GDB has already selected one trace
+ frame. */
+
+static int
+tracefile_has_registers (struct target_ops *ops)
+{
+ return get_traceframe_number () != -1;
+}
+
+/* This is the implementation of target_ops method to_thread_alive.
+ tracefile has one thread faked by GDB. */
+
+static int
+tracefile_thread_alive (struct target_ops *ops, ptid_t ptid)
+{
+ return 1;
+}
+
+/* This is the implementation of target_ops method to_get_trace_status.
+ The trace status for a file is that tracing can never be run. */
+
+static int
+tracefile_get_trace_status (struct target_ops *self, struct trace_status *ts)
+{
+ /* Other bits of trace status were collected as part of opening the
+ trace files, so nothing to do here. */
+
+ return -1;
+}
+
+/* Initialize OPS for tracefile related targets. */
+
+void
+init_tracefile_ops (struct target_ops *ops)
+{
+ ops->to_stratum = process_stratum;
+ ops->to_get_trace_status = tracefile_get_trace_status;
+ ops->to_has_all_memory = tracefile_has_all_memory;
+ ops->to_has_memory = tracefile_has_memory;
+ ops->to_has_stack = tracefile_has_stack;
+ ops->to_has_registers = tracefile_has_registers;
+ ops->to_thread_alive = tracefile_thread_alive;
+ ops->to_magic = OPS_MAGIC;
+}
void
_initialize_tracefile (void)
{
- add_com ("tsave", class_trace, trace_save_command, _("\
+ add_com ("tsave", class_trace, tsave_command, _("\
Save the trace data to a file.\n\
Use the '-ctf' option to save the data to CTF format.\n\
Use the '-r' option to direct the target to save directly to the file,\n\
projects / thirdparty / binutils-gdb.git / blobdiff