static int fromhex (int a);
-static int hex2bin (const char *hex, gdb_byte *bin, int count);
+extern int hex2bin (const char *hex, gdb_byte *bin, int count);
-static int bin2hex (const gdb_byte *bin, char *hex, int count);
+extern int bin2hex (const gdb_byte *bin, char *hex, int count);
static int putpkt_binary (char *buf, int cnt);
static ptid_t read_ptid (char *buf, char **obuf);
struct remote_state;
-static void remote_get_tracing_state (struct remote_state *);
+static int remote_get_trace_status (struct trace_status *ts);
+static int remote_upload_tracepoints (struct uploaded_tp **utpp);
+
+static int remote_upload_trace_state_variables (struct uploaded_tsv **utsvp);
+
static void remote_query_supported (void);
static void remote_check_symbols (struct objfile *objfile);
previously; find out where things are at. */
if (rs->disconnected_tracing)
{
- remote_get_tracing_state (rs);
+ struct uploaded_tp *uploaded_tps = NULL;
+ struct uploaded_tsv *uploaded_tsvs = NULL;
+
+ remote_get_trace_status (current_trace_status ());
+ if (current_trace_status ()->running)
+ printf_filtered (_("Trace is already running on the target.\n"));
+
+ /* Get trace state variables first, they may be checked when
+ parsing uploaded commands. */
+
+ remote_upload_trace_state_variables (&uploaded_tsvs);
+
+ merge_uploaded_trace_state_variables (&uploaded_tsvs);
+
+ remote_upload_tracepoints (&uploaded_tps);
+
+ merge_uploaded_tracepoints (&uploaded_tps);
}
/* If breakpoints are global, insert them now. */
error (_("Reply contains invalid hex digit %d"), a);
}
-static int
+int
hex2bin (const char *hex, gdb_byte *bin, int count)
{
int i;
return 'a' + nib - 10;
}
-static int
+int
bin2hex (const gdb_byte *bin, char *hex, int count)
{
int i;
{
char *buf;
- /* XXX - see also tracepoint.c:remote_get_noisy_reply(). */
+ /* XXX - see also remote_get_noisy_reply(). */
rs->buf[0] = '\0';
getpkt (&rs->buf, &rs->buf_size, 0);
buf = rs->buf;
remote_download_trace_state_variable (struct trace_state_variable *tsv)
{
struct remote_state *rs = get_remote_state ();
+ char *p;
- sprintf (rs->buf, "QTDV:%x:%s",
- tsv->number, phex ((ULONGEST) tsv->initial_value, 8));
+ sprintf (rs->buf, "QTDV:%x:%s:%x:",
+ tsv->number, phex ((ULONGEST) tsv->initial_value, 8), tsv->builtin);
+ p = rs->buf + strlen (rs->buf);
+ if ((p - rs->buf) + strlen (tsv->name) * 2 >= get_remote_packet_size ())
+ error (_("Trace state variable name too long for tsv definition packet"));
+ p += 2 * bin2hex ((gdb_byte *) (tsv->name), p, 0);
+ *p++ = '\0';
putpkt (rs->buf);
remote_get_noisy_reply (&target_buf, &target_buf_size);
}
}
static int
-remote_get_trace_status (int *stop_reason)
+remote_get_trace_status (struct trace_status *ts)
{
+ char *p, *p1, *p_temp;
+ ULONGEST val;
+ /* FIXME we need to get register block size some other way */
+ extern int trace_regblock_size;
+ trace_regblock_size = get_remote_arch_state ()->sizeof_g_packet;
+
putpkt ("qTStatus");
- remote_get_noisy_reply (&target_buf, &target_buf_size);
+ getpkt (&target_buf, &target_buf_size, 0);
+ /* FIXME should handle more variety of replies */
+
+ p = target_buf;
+
+ /* If the remote target doesn't do tracing, flag it. */
+ if (*p == '\0')
+ return -1;
- if (target_buf[0] != 'T' ||
- (target_buf[1] != '0' && target_buf[1] != '1'))
+ /* We're working with a live target. */
+ ts->from_file = 0;
+
+ /* Set some defaults. */
+ ts->running_known = 0;
+ ts->stop_reason = trace_stop_reason_unknown;
+ ts->traceframe_count = -1;
+ ts->buffer_free = 0;
+
+ if (*p++ != 'T')
error (_("Bogus trace status reply from target: %s"), target_buf);
- return (target_buf[1] == '1');
+ parse_trace_status (p, ts);
+
+ return ts->running;
}
static void
sprintf (p, "%x", num);
break;
case tfind_pc:
- sprintf (p, "pc:%s", paddress (target_gdbarch, addr1));
+ sprintf (p, "pc:%s", phex_nz (addr1, 0));
break;
case tfind_tp:
sprintf (p, "tdp:%x", num);
break;
case tfind_range:
- sprintf (p, "range:%s:%s", paddress (target_gdbarch, addr1), paddress (target_gdbarch, addr2));
+ sprintf (p, "range:%s:%s", phex_nz (addr1, 0), phex_nz (addr2, 0));
break;
case tfind_outside:
- sprintf (p, "outside:%s:%s", paddress (target_gdbarch, addr1), paddress (target_gdbarch, addr2));
+ sprintf (p, "outside:%s:%s", phex_nz (addr1, 0), phex_nz (addr2, 0));
break;
default:
error ("Unknown trace find type %d", type);
return 0;
}
+static int
+remote_save_trace_data (char *filename)
+{
+ struct remote_state *rs = get_remote_state ();
+ char *p, *reply;
+
+ p = rs->buf;
+ strcpy (p, "QTSave:");
+ p += strlen (p);
+ if ((p - rs->buf) + strlen (filename) * 2 >= get_remote_packet_size ())
+ error (_("Remote file name too long for trace save packet"));
+ p += 2 * bin2hex ((gdb_byte *) filename, p, 0);
+ *p++ = '\0';
+ putpkt (rs->buf);
+ remote_get_noisy_reply (&target_buf, &target_buf_size);
+ return 0;
+}
+
+/* This is basically a memory transfer, but needs to be its own packet
+ because we don't know how the target actually organizes its trace
+ memory, plus we want to be able to ask for as much as possible, but
+ not be unhappy if we don't get as much as we ask for. */
+
+static LONGEST
+remote_get_raw_trace_data (gdb_byte *buf, ULONGEST offset, LONGEST len)
+{
+ struct remote_state *rs = get_remote_state ();
+ char *reply;
+ char *p;
+ int rslt;
+
+ p = rs->buf;
+ strcpy (p, "qTBuffer:");
+ p += strlen (p);
+ p += hexnumstr (p, offset);
+ *p++ = ',';
+ p += hexnumstr (p, len);
+ *p++ = '\0';
+
+ putpkt (rs->buf);
+ reply = remote_get_noisy_reply (&target_buf, &target_buf_size);
+ if (reply && *reply)
+ {
+ /* 'l' by itself means we're at the end of the buffer and
+ there is nothing more to get. */
+ if (*reply == 'l')
+ return 0;
+
+ /* Convert the reply into binary. Limit the number of bytes to
+ convert according to our passed-in buffer size, rather than
+ what was returned in the packet; if the target is
+ unexpectedly generous and gives us a bigger reply than we
+ asked for, we don't want to crash. */
+ rslt = hex2bin (target_buf, buf, len);
+ return rslt;
+ }
+
+ /* Something went wrong, flag as an error. */
+ return -1;
+}
+
static void
remote_set_disconnected_tracing (int val)
{
remote_ops.to_trace_stop = remote_trace_stop;
remote_ops.to_trace_find = remote_trace_find;
remote_ops.to_get_trace_state_variable_value = remote_get_trace_state_variable_value;
+ remote_ops.to_save_trace_data = remote_save_trace_data;
+ remote_ops.to_upload_tracepoints = remote_upload_tracepoints;
+ remote_ops.to_upload_trace_state_variables = remote_upload_trace_state_variables;
+ remote_ops.to_get_raw_trace_data = remote_get_raw_trace_data;
remote_ops.to_set_disconnected_tracing = remote_set_disconnected_tracing;
remote_ops.to_core_of_thread = remote_core_of_thread;
}
remote_check_symbols (objfile);
}
-/* Struct to collect random info about tracepoints on the target. */
-
-struct uploaded_tp {
- int number;
- enum bptype type;
- ULONGEST addr;
- int enabled;
- int step;
- int pass;
- int orig_size;
- char *cond;
- int cond_len;
- struct uploaded_tp *next;
-};
-
-struct uploaded_tp *uploaded_tps;
-
-struct uploaded_tp *
-get_uploaded_tp (int num)
-{
- struct uploaded_tp *utp;
-
- for (utp = uploaded_tps; utp; utp = utp->next)
- if (utp->number == num)
- return utp;
- utp = (struct uploaded_tp *) xmalloc (sizeof (struct uploaded_tp));
- utp->number = num;
- utp->next = uploaded_tps;
- uploaded_tps = utp;
- return utp;
-}
-
-/* Look for an existing tracepoint that seems similar enough to the
- uploaded one. Enablement isn't checked, because the user can
- toggle that freely, and may have done so in anticipation of the
- next trace run. */
-
-struct breakpoint *
-find_matching_tracepoint (struct uploaded_tp *utp)
+/* Pull all the tracepoints defined on the target and create local
+ data structures representing them. We don't want to create real
+ tracepoints yet, we don't want to mess up the user's existing
+ collection. */
+
+static int
+remote_upload_tracepoints (struct uploaded_tp **utpp)
{
- VEC(breakpoint_p) *tp_vec = all_tracepoints ();
- int ix;
- struct breakpoint *t;
+ struct remote_state *rs = get_remote_state ();
+ char *p;
- for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, t); ix++)
+ /* Ask for a first packet of tracepoint definition. */
+ putpkt ("qTfP");
+ getpkt (&rs->buf, &rs->buf_size, 0);
+ p = rs->buf;
+ while (*p && *p != 'l')
{
- if (t->type == utp->type
- && (t->loc && t->loc->address == utp->addr)
- && t->step_count == utp->step
- && t->pass_count == utp->pass
- /* FIXME also test conditionals and actions */
- )
- return t;
+ parse_tracepoint_definition (p, utpp);
+ /* Ask for another packet of tracepoint definition. */
+ putpkt ("qTsP");
+ getpkt (&rs->buf, &rs->buf_size, 0);
+ p = rs->buf;
}
- return NULL;
+ return 0;
}
-/* Find out everything we can about the trace run that was already
- happening on the target. This includes both running/stopped, and
- the tracepoints that were in use. */
-
-static void
-remote_get_tracing_state (struct remote_state *rs)
+static int
+remote_upload_trace_state_variables (struct uploaded_tsv **utsvp)
{
+ struct remote_state *rs = get_remote_state ();
char *p;
- ULONGEST num, addr, step, pass, orig_size, xlen;
- int enabled, i;
- enum bptype type;
- char *cond;
- struct uploaded_tp *utp;
- struct breakpoint *t;
- extern void get_trace_status ();
-
- get_trace_status ();
- if (trace_running_p)
- printf_filtered (_("Trace is running on the target.\n"));
- putpkt ("qTfP");
+ /* Ask for a first packet of variable definition. */
+ putpkt ("qTfV");
getpkt (&rs->buf, &rs->buf_size, 0);
p = rs->buf;
- while (*p != '\0')
+ while (*p && *p != 'l')
{
- if (*p == 'T')
- {
- p++;
- p = unpack_varlen_hex (p, &num);
- p++;
- p = unpack_varlen_hex (p, &addr);
- p++;
- enabled = (*p++ == 'E');
- p++;
- p = unpack_varlen_hex (p, &step);
- p++;
- p = unpack_varlen_hex (p, &pass);
- p++;
- type = bp_tracepoint;
- cond = NULL;
- while (*p)
- {
- if (*p == 'F')
- {
- type = bp_fast_tracepoint;
- p++;
- p = unpack_varlen_hex (p, &orig_size);
- }
- else if (*p == 'X')
- {
- p++;
- p = unpack_varlen_hex (p, &xlen);
- p++; /* skip the comma */
- cond = (char *) xmalloc (xlen);
- hex2bin (p, cond, xlen);
- p += 2 * xlen;
- }
- else
- /* Silently skip over anything else. */
- p++;
- }
- utp = get_uploaded_tp (num);
- utp->type = type;
- utp->addr = addr;
- utp->enabled = enabled;
- utp->step = step;
- utp->pass = pass;
- utp->cond = cond;
- utp->cond_len = xlen;
- }
- else if (*p == 'A')
- {
- p++;
- p = unpack_varlen_hex (p, &num);
- p++;
- p = unpack_varlen_hex (p, &addr);
- p++;
- utp = get_uploaded_tp (num);
- /* FIXME save the action */
- }
- else if (*p == 'S')
- {
- p++;
- p = unpack_varlen_hex (p, &num);
- p++;
- p = unpack_varlen_hex (p, &addr);
- p++;
- utp = get_uploaded_tp (num);
- /* FIXME save the action */
- }
- else if (*p == 'l')
- {
- /* No more tracepoint info, get out of the loop. */
- break;
- }
- putpkt ("qTsP");
+ parse_tsv_definition (p, utsvp);
+ /* Ask for another packet of variable definition. */
+ putpkt ("qTsV");
getpkt (&rs->buf, &rs->buf_size, 0);
p = rs->buf;
}
- /* Got all the tracepoint info, now look for matches among what we
- already have in GDB. */
- for (utp = uploaded_tps; utp; utp = utp->next)
- {
- t = find_matching_tracepoint (utp);
- if (t)
- {
- printf_filtered (_("Assuming tracepoint %d is same as target's tracepoint %d.\n"),
- t->number, utp->number);
- t->number_on_target = utp->number;
- }
- else
- {
- extern void create_tracepoint_from_upload (int num, ULONGEST addr);
- create_tracepoint_from_upload (utp->number, utp->addr);
- }
- }
- /* FIXME free all the space */
- uploaded_tps = NULL;
+ return 0;
}
void
#include "gdbcore.h"
#include "objfiles.h"
#include "filenames.h"
+#include "gdbthread.h"
#include "ax.h"
#include "ax-gdb.h"
#include <unistd.h>
#endif
+#ifndef O_LARGEFILE
+#define O_LARGEFILE 0
+#endif
+
+extern int hex2bin (const char *hex, gdb_byte *bin, int count);
+extern int bin2hex (const gdb_byte *bin, char *hex, int count);
+
extern void stop_tracing ();
/* Maximum length of an agent aexpression.
extern void send_disconnected_tracing_value (int value);
+static void free_uploaded_tps (struct uploaded_tp **utpp);
+static void free_uploaded_tsvs (struct uploaded_tsv **utsvp);
+
+
extern void _initialize_tracepoint (void);
+static struct trace_status trace_status;
+
+char *stop_reason_names[] = {
+ "tunknown",
+ "tnotrun",
+ "tstop",
+ "tfull",
+ "tdisconnected",
+ "tpasscount"
+};
+
+struct trace_status *
+current_trace_status ()
+{
+ return &trace_status;
+}
+
/* Set traceframe number to NUM. */
static void
set_traceframe_num (int num)
print_spaces_filtered (11 - strlen (plongest (tsv->initial_value)), gdb_stdout);
if (tsv->value_known)
printf_filtered (" %s", plongest (tsv->value));
- else if (trace_running_p || traceframe_number >= 0)
+ else if (current_trace_status ()->running || traceframe_number >= 0)
/* The value is/was defined, but we don't have it. */
printf_filtered (_(" <unknown>"));
else
if (!any_downloaded)
error ("No tracepoints downloaded, not starting trace");
- /* Init any trace state variables that start with nonzero values. */
+ /* Send down all the trace state variables too. */
for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
{
- if (tsv->initial_value != 0)
- target_download_trace_state_variable (tsv);
+ target_download_trace_state_variable (tsv);
}
/* Tell target to treat text-like sections as transparent. */
set_traceframe_num (-1);
set_tracepoint_num (-1);
set_traceframe_context (NULL);
- trace_running_p = 1;
+ current_trace_status()->running = 1;
}
/* tstop command */
stop_tracing ()
{
target_trace_stop ();
- trace_running_p = 0;
-}
-
-unsigned long trace_running_p;
-
-int
-get_trace_status ()
-{
- int status = target_get_trace_status (NULL);
-
- /* exported for use by the GUI */
- trace_running_p = (status > 0);
-
- return status;
+ /* should change in response to reply? */
+ current_trace_status ()->running = 0;
}
/* tstatus command */
static void
trace_status_command (char *args, int from_tty)
{
- int status = get_trace_status ();
+ struct trace_status *ts = current_trace_status ();
+ int status;
- if (status < 0)
- printf_filtered (_("Trace can not be run on the target.\n"));
- else if (trace_running_p)
+ status = target_get_trace_status (ts);
+
+ if (status == -1)
+ {
+ if (ts->from_file)
+ printf_filtered (_("Using a trace file.\n"));
+ else
+ {
+ printf_filtered (_("Trace can not be run on this target.\n"));
+ return;
+ }
+ }
+
+ if (!ts->running_known)
+ {
+ printf_filtered (_("Run/stop status is unknown.\n"));
+ }
+ else if (ts->running)
{
printf_filtered (_("Trace is running on the target.\n"));
if (disconnected_tracing)
printf_filtered (_("Trace will stop if GDB disconnects.\n"));
}
else
- printf_filtered (_("Trace is not running on the target.\n"));
+ {
+ switch (ts->stop_reason)
+ {
+ case trace_never_run:
+ printf_filtered (_("No trace has been run on the target.\n"));
+ break;
+ case tstop_command:
+ printf_filtered (_("Trace stopped by a tstop command.\n"));
+ break;
+ case trace_buffer_full:
+ printf_filtered (_("Trace stopped because the buffer was full.\n"));
+ break;
+ case trace_disconnected:
+ printf_filtered (_("Trace stopped because of disconnection.\n"));
+ break;
+ case tracepoint_passcount:
+ /* FIXME account for number on target */
+ printf_filtered (_("Trace stopped by tracepoint %d.\n"),
+ ts->stopping_tracepoint);
+ break;
+ case trace_stop_reason_unknown:
+ printf_filtered (_("Trace stopped for an unknown reason.\n"));
+ break;
+ default:
+ printf_filtered (_("Trace stopped for some other reason (%d).\n"),
+ ts->stop_reason);
+ break;
+ }
+ }
+
+ if (ts->traceframe_count >= 0)
+ {
+ printf_filtered (_("Collected %d trace frames.\n"),
+ ts->traceframe_count);
+ }
+
+ if (ts->buffer_free)
+ {
+ printf_filtered (_("Trace buffer has %d bytes free.\n"),
+ ts->buffer_free);
+ }
+ /* Now report on what we're doing with tfind. */
if (traceframe_number >= 0)
printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
traceframe_number, tracepoint_number);
void
disconnect_or_stop_tracing (int from_tty)
{
- if (trace_running_p && from_tty)
+ /* It can happen that the target that was tracing went away on its
+ own, and we didn't notice. Get a status update, and if the
+ current target doesn't even do tracing, then assume it's not
+ running anymore. */
+ if (target_get_trace_status (current_trace_status ()) < 0)
+ current_trace_status ()->running = 0;
+
+ if (current_trace_status ()->running && from_tty)
{
int cont = query (_("Trace is running. Continue tracing after detach? "));
/* Note that we send the query result without affecting the
else
set_traceframe_context (get_current_frame ());
- if (from_tty)
+ /* If we're in nonstop mode and getting out of looking at trace
+ frames, there won't be any current frame to go back to and
+ display. */
+ if (from_tty
+ && (has_stack_frames () || traceframe_number >= 0))
{
enum print_what print_what;
{ /* this should only be called with a numeric argument */
int frameno = -1;
- if (trace_running_p)
+ if (current_trace_status ()->running && !current_trace_status ()->from_file)
error ("May not look at trace frames while trace is running.");
if (args == 0 || *args == 0)
CORE_ADDR pc;
char tmp[40];
- if (trace_running_p)
+ if (current_trace_status ()->running && !current_trace_status ()->from_file)
error ("May not look at trace frames while trace is running.");
if (args == 0 || *args == 0)
int tdp;
struct breakpoint *tp;
- if (trace_running_p)
+ if (current_trace_status ()->running && !current_trace_status ()->from_file)
error ("May not look at trace frames while trace is running.");
if (args == 0 || *args == 0)
struct cleanup *old_chain;
char startpc_str[40], endpc_str[40];
- if (trace_running_p)
+ if (current_trace_status ()->running && !current_trace_status ()->from_file)
error ("May not look at trace frames while trace is running.");
if (args == 0 || *args == 0)
char start_str[40], stop_str[40];
char *tmp;
- if (trace_running_p)
+ if (current_trace_status ()->running && !current_trace_status ()->from_file)
error ("May not look at trace frames while trace is running.");
if (args == 0 || *args == 0)
char start_str[40], stop_str[40];
char *tmp;
- if (trace_running_p)
+ if (current_trace_status ()->running && !current_trace_status ()->from_file)
error ("May not look at trace frames while trace is running.");
if (args == 0 || *args == 0)
discard_cleanups (old_cleanups);
}
+extern int trace_regblock_size;
+
+static void
+trace_save_command (char *args, int from_tty)
+{
+ char **argv;
+ char *filename = NULL, *pathname;
+ int target_does_save = 0;
+ struct cleanup *cleanup;
+ struct trace_status *ts = current_trace_status ();
+ int err, status;
+ FILE *fp;
+ struct uploaded_tp *uploaded_tps = NULL, *utp;
+ struct uploaded_tsv *uploaded_tsvs = NULL, *utsv;
+ int a;
+ LONGEST gotten = 0;
+ ULONGEST offset = 0;
+#define MAX_TRACE_UPLOAD 2000
+ gdb_byte buf[MAX_TRACE_UPLOAD];
+
+ if (args == NULL)
+ error_no_arg (_("file in which to save trace data"));
+
+ argv = gdb_buildargv (args);
+ make_cleanup_freeargv (argv);
+
+ for (; *argv; ++argv)
+ {
+ if (strcmp (*argv, "-r") == 0)
+ target_does_save = 1;
+ else if (**argv == '-')
+ error (_("unknown option `%s'"), *argv);
+ else
+ filename = *argv;
+ }
+
+ if (!filename)
+ error_no_arg (_("file in which to save trace data"));
+
+ /* If the target is to save the data to a file on its own, then just
+ send the command and be done with it. */
+ if (target_does_save)
+ {
+ err = target_save_trace_data (filename);
+ if (err < 0)
+ error (_("Target failed to save trace data to '%s'."),
+ filename);
+ return;
+ }
+
+ /* 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);
+
+ pathname = tilde_expand (args);
+ cleanup = make_cleanup (xfree, pathname);
+
+ fp = fopen (pathname, "w");
+ if (!fp)
+ error (_("Unable to open file '%s' for saving trace data (%s)"),
+ args, safe_strerror (errno));
+ make_cleanup_fclose (fp);
+
+ /* Write a file header, with a high-bit-set char to indicate a
+ binary file, plus a hint as what this file is, and a version
+ number in case of future needs. */
+ fwrite ("\x7fTRACE0\n", 8, 1, fp);
+
+ /* Write descriptive info. */
+
+ /* Write out the size of a register block. */
+ fprintf (fp, "R %x\n", trace_regblock_size);
+
+ /* Write out status of the tracing run (aka "tstatus" info). */
+ fprintf (fp, "status %c;%s:%x;tframes:%x;tfree:%x\n",
+ (ts->running ? '1' : '0'),
+ stop_reason_names[ts->stop_reason], ts->stopping_tracepoint,
+ ts->traceframe_count, (unsigned int) ts->buffer_free);
+
+ /* Note that we want to upload tracepoints and save those, rather
+ than simply writing out the local ones, because the user may have
+ changed tracepoints in GDB in preparation for a future tracing
+ run, or maybe just mass-deleted all types of breakpoints as part
+ of cleaning up. So as not to contaminate the session, leave the
+ data in its uploaded form, don't make into real tracepoints. */
+
+ /* Get trace state variables first, they may be checked when parsing
+ uploaded commands. */
+
+ target_upload_trace_state_variables (&uploaded_tsvs);
+
+ for (utsv = uploaded_tsvs; utsv; utsv = utsv->next)
+ {
+ char *buf = "";
+
+ if (utsv->name)
+ {
+ buf = (char *) xmalloc (strlen (utsv->name) * 2 + 1);
+ bin2hex ((gdb_byte *) (utsv->name), buf, 0);
+ }
+
+ fprintf (fp, "tsv %x:%s:%x:%s\n",
+ utsv->number, phex_nz (utsv->initial_value, 8),
+ utsv->builtin, buf);
+
+ if (utsv->name)
+ xfree (buf);
+ }
+
+ free_uploaded_tsvs (&uploaded_tsvs);
+
+ target_upload_tracepoints (&uploaded_tps);
+
+ for (utp = uploaded_tps; utp; utp = utp->next)
+ {
+ fprintf (fp, "tp T%x:%s:%c:%x:%x",
+ utp->number, phex_nz (utp->addr, sizeof (utp->addr)),
+ (utp->enabled ? 'E' : 'D'), utp->step, utp->pass);
+ if (utp->type == bp_fast_tracepoint)
+ fprintf (fp, ":F%x", utp->orig_size);
+ if (utp->cond)
+ fprintf (fp, ":X%x,%s", (unsigned int) strlen (utp->cond) / 2,
+ utp->cond);
+ fprintf (fp, "\n");
+ for (a = 0; a < utp->numactions; ++a)
+ fprintf (fp, "tp A%x:%s:%s\n",
+ utp->number, phex_nz (utp->addr, sizeof (utp->addr)),
+ utp->actions[a]);
+ for (a = 0; a < utp->num_step_actions; ++a)
+ fprintf (fp, "tp S%x:%s:%s\n",
+ utp->number, phex_nz (utp->addr, sizeof (utp->addr)),
+ utp->step_actions[a]);
+ }
+
+ free_uploaded_tps (&uploaded_tps);
+
+ /* Mark the end of the definition section. */
+ fprintf (fp, "\n");
+
+ /* Get and write the trace data proper. We ask for big blocks, in
+ the hopes of efficiency, but will take less if the target has
+ packet size limitations or some such. */
+ while (1)
+ {
+ gotten = target_get_raw_trace_data (buf, offset, MAX_TRACE_UPLOAD);
+ if (gotten < 0)
+ error (_("Failure to get requested trace buffer data"));
+ /* No more data is forthcoming, we're done. */
+ if (gotten == 0)
+ break;
+ fwrite (buf, gotten, 1, fp);
+ offset += gotten;
+ }
+
+ /* Mark the end of trace data. */
+ fwrite (&gotten, 4, 1, fp);
+
+ do_cleanups (cleanup);
+ if (from_tty)
+ printf_filtered (_("Trace data saved to file '%s'.\n"), args);
+}
+
/* Tell the target what to do with an ongoing tracing run if GDB
disconnects for some reason. */
return traceframe_number;
}
+
+/* Given a number and address, return an uploaded tracepoint with that
+ number, creating if necessary. */
+
+struct uploaded_tp *
+get_uploaded_tp (int num, ULONGEST addr, struct uploaded_tp **utpp)
+{
+ struct uploaded_tp *utp;
+
+ for (utp = *utpp; utp; utp = utp->next)
+ if (utp->number == num && utp->addr == addr)
+ return utp;
+ utp = (struct uploaded_tp *) xmalloc (sizeof (struct uploaded_tp));
+ memset (utp, 0, sizeof (struct uploaded_tp));
+ utp->number = num;
+ utp->addr = addr;
+ utp->next = *utpp;
+ *utpp = utp;
+ return utp;
+}
+
+static void
+free_uploaded_tps (struct uploaded_tp **utpp)
+{
+ struct uploaded_tp *next_one;
+
+ while (*utpp)
+ {
+ next_one = (*utpp)->next;
+ xfree (*utpp);
+ *utpp = next_one;
+ }
+}
+
+/* Given a number and address, return an uploaded tracepoint with that
+ number, creating if necessary. */
+
+struct uploaded_tsv *
+get_uploaded_tsv (int num, struct uploaded_tsv **utsvp)
+{
+ struct uploaded_tsv *utsv;
+
+ for (utsv = *utsvp; utsv; utsv = utsv->next)
+ if (utsv->number == num)
+ return utsv;
+ utsv = (struct uploaded_tsv *) xmalloc (sizeof (struct uploaded_tsv));
+ memset (utsv, 0, sizeof (struct uploaded_tsv));
+ utsv->number = num;
+ utsv->next = *utsvp;
+ *utsvp = utsv;
+ return utsv;
+}
+
+static void
+free_uploaded_tsvs (struct uploaded_tsv **utsvp)
+{
+ struct uploaded_tsv *next_one;
+
+ while (*utsvp)
+ {
+ next_one = (*utsvp)->next;
+ xfree (*utsvp);
+ *utsvp = next_one;
+ }
+}
+
+/* Look for an existing tracepoint that seems similar enough to the
+ uploaded one. Enablement isn't compared, because the user can
+ toggle that freely, and may have done so in anticipation of the
+ next trace run. */
+
+struct breakpoint *
+find_matching_tracepoint (struct uploaded_tp *utp)
+{
+ VEC(breakpoint_p) *tp_vec = all_tracepoints ();
+ int ix;
+ struct breakpoint *t;
+ struct bp_location *loc;
+
+ for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, t); ix++)
+ {
+ if (t->type == utp->type
+ && t->step_count == utp->step
+ && t->pass_count == utp->pass
+ /* FIXME also test conditionals and actions */
+ )
+ {
+ /* Scan the locations for an address match. */
+ for (loc = t->loc; loc; loc = loc->next)
+ {
+ if (loc->address == utp->addr)
+ return t;
+ }
+ }
+ }
+ return NULL;
+}
+
+/* Given a list of tracepoints uploaded from a target, attempt to
+ match them up with existing tracepoints, and create new ones if not
+ found. */
+
+void
+merge_uploaded_tracepoints (struct uploaded_tp **uploaded_tps)
+{
+ struct uploaded_tp *utp;
+ struct breakpoint *t;
+
+ /* Look for GDB tracepoints that match up with our uploaded versions. */
+ for (utp = *uploaded_tps; utp; utp = utp->next)
+ {
+ t = find_matching_tracepoint (utp);
+ if (t)
+ printf_filtered (_("Assuming tracepoint %d is same as target's tracepoint %d at %s.\n"),
+ t->number, utp->number, paddress (get_current_arch (), utp->addr));
+ else
+ {
+ t = create_tracepoint_from_upload (utp);
+ if (t)
+ printf_filtered (_("Created tracepoint %d for target's tracepoint %d at %s.\n"),
+ t->number, utp->number, paddress (get_current_arch (), utp->addr));
+ else
+ printf_filtered (_("Failed to create tracepoint for target's tracepoint %d at %s, skipping it.\n"),
+ utp->number, paddress (get_current_arch (), utp->addr));
+ }
+ /* Whether found or created, record the number used by the
+ target, to help with mapping target tracepoints back to their
+ counterparts here. */
+ if (t)
+ t->number_on_target = utp->number;
+ }
+
+ free_uploaded_tps (uploaded_tps);
+}
+
+/* Trace state variables don't have much to identify them beyond their
+ name, so just use that to detect matches. */
+
+struct trace_state_variable *
+find_matching_tsv (struct uploaded_tsv *utsv)
+{
+ if (!utsv->name)
+ return NULL;
+
+ return find_trace_state_variable (utsv->name);
+}
+
+struct trace_state_variable *
+create_tsv_from_upload (struct uploaded_tsv *utsv)
+{
+ const char *namebase;
+ char buf[20];
+ int try_num = 0;
+ struct trace_state_variable *tsv;
+
+ if (utsv->name)
+ {
+ namebase = utsv->name;
+ sprintf (buf, "%s", namebase);
+ }
+ else
+ {
+ namebase = "__tsv";
+ sprintf (buf, "%s_%d", namebase, try_num++);
+ }
+
+ /* Fish for a name that is not in use. */
+ /* (should check against all internal vars?) */
+ while (find_trace_state_variable (buf))
+ sprintf (buf, "%s_%d", namebase, try_num++);
+
+ /* We have an available name, create the variable. */
+ tsv = create_trace_state_variable (xstrdup (buf));
+ tsv->initial_value = utsv->initial_value;
+ tsv->builtin = utsv->builtin;
+
+ return tsv;
+}
+
+/* Given a list of uploaded trace state variables, try to match them
+ up with existing variables, or create additional ones. */
+
+void
+merge_uploaded_trace_state_variables (struct uploaded_tsv **uploaded_tsvs)
+{
+ int ix;
+ struct uploaded_tsv *utsv;
+ struct trace_state_variable *tsv;
+ int highest;
+
+ /* Most likely some numbers will have to be reassigned as part of
+ the merge, so clear them all in anticipation. */
+ for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
+ tsv->number = 0;
+
+ for (utsv = *uploaded_tsvs; utsv; utsv = utsv->next)
+ {
+ tsv = find_matching_tsv (utsv);
+ if (tsv)
+ printf_filtered (_("Assuming trace state variable $%s is same as target's variable %d.\n"),
+ tsv->name, utsv->number);
+ else
+ {
+ tsv = create_tsv_from_upload (utsv);
+ printf_filtered (_("Created trace state variable $%s for target's variable %d.\n"),
+ tsv->name, utsv->number);
+ }
+ /* Give precedence to numberings that come from the target. */
+ if (tsv)
+ tsv->number = utsv->number;
+ }
+
+ /* Renumber everything that didn't get a target-assigned number. */
+ highest = 0;
+ for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
+ if (tsv->number > highest)
+ highest = tsv->number;
+
+ ++highest;
+ for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
+ if (tsv->number == 0)
+ tsv->number = highest++;
+
+ free_uploaded_tsvs (uploaded_tsvs);
+}
+
+/* target tfile command */
+
+struct target_ops tfile_ops;
+
+/* Fill in tfile_ops with its defined operations and properties. */
+
+#define TRACE_HEADER_SIZE 8
+
+int trace_fd = -1;
+off_t trace_frames_offset;
+off_t cur_offset;
+int cur_data_size;
+int trace_regblock_size;
+
+static void tfile_interp_line (char *line,
+ struct uploaded_tp **utpp,
+ struct uploaded_tsv **utsvp);
+
+static void
+tfile_open (char *filename, int from_tty)
+{
+ char *temp;
+ struct cleanup *old_chain;
+ int flags;
+ int scratch_chan;
+ char header[TRACE_HEADER_SIZE];
+ char linebuf[1000]; /* should be max remote packet size or so */
+ char byte;
+ int bytes, i;
+ struct trace_status *ts;
+ struct uploaded_tp *uploaded_tps = NULL;
+ struct uploaded_tsv *uploaded_tsvs = NULL;
+
+ target_preopen (from_tty);
+ if (!filename)
+ error (_("No trace 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);
+
+ flags = O_BINARY | O_LARGEFILE;
+ flags |= O_RDONLY;
+ scratch_chan = open (filename, flags, 0);
+ if (scratch_chan < 0)
+ perror_with_name (filename);
+
+ /* Looks semi-reasonable. Toss the old trace file and work on the new. */
+
+ discard_cleanups (old_chain); /* Don't free filename any more */
+ unpush_target (&tfile_ops);
+
+ push_target (&tfile_ops);
+ discard_cleanups (old_chain);
+
+ trace_fd = scratch_chan;
+
+ bytes = 0;
+ /* Read the file header and test for validity. */
+ read (trace_fd, &header, TRACE_HEADER_SIZE);
+ bytes += TRACE_HEADER_SIZE;
+ if (!(header[0] == 0x7f
+ && (strncmp (header + 1, "TRACE0\n", 7) == 0)))
+ error (_("File is not a valid trace file."));
+
+ trace_regblock_size = 0;
+ ts = current_trace_status ();
+ /* We know we're working with a file. */
+ ts->from_file = 1;
+ /* Set defaults in case there is no status line. */
+ ts->running_known = 0;
+ ts->stop_reason = trace_stop_reason_unknown;
+ ts->traceframe_count = -1;
+ ts->buffer_free = 0;
+
+ /* Read through a section of newline-terminated lines that
+ define things like tracepoints. */
+ i = 0;
+ while (1)
+ {
+ read (trace_fd, &byte, 1);
+ ++bytes;
+ if (byte == '\n')
+ {
+ /* Empty line marks end of the definition section. */
+ if (i == 0)
+ break;
+ linebuf[i] = '\0';
+ i = 0;
+ tfile_interp_line (linebuf, &uploaded_tps, &uploaded_tsvs);
+ }
+ else
+ linebuf[i++] = byte;
+ if (i >= 1000)
+ error (_("Excessively long lines in trace file"));
+ }
+
+ /* Add the file's tracepoints and variables into the current mix. */
+
+ merge_uploaded_tracepoints (&uploaded_tps);
+
+ merge_uploaded_trace_state_variables (&uploaded_tsvs);
+
+ /* Record the starting offset of the binary trace data. */
+ trace_frames_offset = bytes;
+
+ /* If we don't have a blocksize, we can't interpret the
+ traceframes. */
+ if (trace_regblock_size == 0)
+ error (_("No register block size recorded in trace file"));
+ if (ts->traceframe_count <= 0)
+ {
+ warning ("No traceframes present in this file.");
+ return;
+ }
+
+#define TFILE_PID (1)
+ inferior_appeared (current_inferior (), TFILE_PID);
+ inferior_ptid = pid_to_ptid (TFILE_PID);
+ add_thread_silent (inferior_ptid);
+
+ post_create_inferior (&tfile_ops, from_tty);
+
+#if 0
+ /* FIXME this will get defined in MI patch submission */
+ tfind_1 (tfind_number, 0, 0, 0, 0);
+#endif
+}
+
+/* Interpret the given line from the definitions part of the trace
+ file. */
+
+static void
+tfile_interp_line (char *line,
+ struct uploaded_tp **utpp, struct uploaded_tsv **utsvp)
+{
+ char *p = line;
+
+ if (strncmp (p, "R ", strlen ("R ")) == 0)
+ {
+ p += strlen ("R ");
+ trace_regblock_size = strtol (p, &p, 16);
+ }
+ else if (strncmp (p, "status ", strlen ("status ")) == 0)
+ {
+ p += strlen ("status ");
+ parse_trace_status (p, current_trace_status ());
+ }
+ else if (strncmp (p, "tp ", strlen ("tp ")) == 0)
+ {
+ p += strlen ("tp ");
+ parse_tracepoint_definition (p, utpp);
+ }
+ else if (strncmp (p, "tsv ", strlen ("tsv ")) == 0)
+ {
+ p += strlen ("tsv ");
+ parse_tsv_definition (p, utsvp);
+ }
+ else
+ warning ("Ignoring trace file definition \"%s\"", line);
+}
+
+/* Parse the part of trace status syntax that is shared between
+ the remote protocol and the trace file reader. */
+
+extern char *unpack_varlen_hex (char *buff, ULONGEST *result);
+
+void
+parse_trace_status (char *line, struct trace_status *ts)
+{
+ char *p = line, *p1, *p_temp;
+ ULONGEST val;
+
+ ts->running_known = 1;
+ ts->running = (*p++ == '1');
+ ts->stop_reason = trace_stop_reason_unknown;
+ while (*p++)
+ {
+ p1 = strchr (p, ':');
+ if (p1 == NULL)
+ error (_("Malformed trace status, at %s\n\
+Status line: '%s'\n"), p, line);
+ if (strncmp (p, stop_reason_names[trace_buffer_full], p1 - p) == 0)
+ {
+ p = unpack_varlen_hex (++p1, &val);
+ ts->stop_reason = trace_buffer_full;
+ }
+ else if (strncmp (p, stop_reason_names[trace_never_run], p1 - p) == 0)
+ {
+ p = unpack_varlen_hex (++p1, &val);
+ ts->stop_reason = trace_never_run;
+ }
+ else if (strncmp (p, stop_reason_names[tracepoint_passcount], p1 - p) == 0)
+ {
+ p = unpack_varlen_hex (++p1, &val);
+ ts->stop_reason = tracepoint_passcount;
+ ts->stopping_tracepoint = val;
+ }
+ else if (strncmp (p, stop_reason_names[tstop_command], p1 - p) == 0)
+ {
+ p = unpack_varlen_hex (++p1, &val);
+ ts->stop_reason = tstop_command;
+ }
+ if (strncmp (p, "tframes", p1 - p) == 0)
+ {
+ p = unpack_varlen_hex (++p1, &val);
+ ts->traceframe_count = val;
+ }
+ if (strncmp (p, "tfree", p1 - p) == 0)
+ {
+ p = unpack_varlen_hex (++p1, &val);
+ ts->buffer_free = val;
+ }
+ else
+ {
+ /* Silently skip unknown optional info. */
+ p_temp = strchr (p1 + 1, ';');
+ if (p_temp)
+ p = p_temp;
+ else
+ /* Must be at the end. */
+ break;
+ }
+ }
+}
+
+/* Given a line of text defining a tracepoint or tracepoint action, parse
+ it into an "uploaded tracepoint". */
+
+void
+parse_tracepoint_definition (char *line, struct uploaded_tp **utpp)
+{
+ char *p;
+ char piece;
+ ULONGEST num, addr, step, pass, orig_size, xlen;
+ int enabled, i;
+ enum bptype type;
+ char *cond;
+ struct uploaded_tp *utp = NULL;
+
+ p = line;
+ /* Both tracepoint and action definitions start with the same number
+ and address sequence. */
+ piece = *p++;
+ p = unpack_varlen_hex (p, &num);
+ p++; /* skip a colon */
+ p = unpack_varlen_hex (p, &addr);
+ p++; /* skip a colon */
+ if (piece == 'T')
+ {
+ enabled = (*p++ == 'E');
+ p++; /* skip a colon */
+ p = unpack_varlen_hex (p, &step);
+ p++; /* skip a colon */
+ p = unpack_varlen_hex (p, &pass);
+ type = bp_tracepoint;
+ cond = NULL;
+ /* Thumb through optional fields. */
+ while (*p == ':')
+ {
+ p++; /* skip a colon */
+ if (*p == 'F')
+ {
+ type = bp_fast_tracepoint;
+ p++;
+ p = unpack_varlen_hex (p, &orig_size);
+ }
+ else if (*p == 'X')
+ {
+ p++;
+ p = unpack_varlen_hex (p, &xlen);
+ p++; /* skip a comma */
+ cond = (char *) xmalloc (2 * xlen + 1);
+ strncpy (cond, p, 2 * xlen);
+ cond[2 * xlen] = '\0';
+ p += 2 * xlen;
+ }
+ else
+ warning ("Unrecognized char '%c' in tracepoint definition, skipping rest", *p);
+ }
+ utp = get_uploaded_tp (num, addr, utpp);
+ utp->type = type;
+ utp->enabled = enabled;
+ utp->step = step;
+ utp->pass = pass;
+ utp->cond = cond;
+ }
+ else if (piece == 'A')
+ {
+ utp = get_uploaded_tp (num, addr, utpp);
+ utp->actions[utp->numactions++] = xstrdup (p);
+ }
+ else if (piece == 'S')
+ {
+ utp = get_uploaded_tp (num, addr, utpp);
+ utp->step_actions[utp->num_step_actions++] = xstrdup (p);
+ }
+ else
+ {
+ error ("Invalid tracepoint piece");
+ }
+}
+
+/* Convert a textual description of a trace state variable into an
+ uploaded object. */
+
+void
+parse_tsv_definition (char *line, struct uploaded_tsv **utsvp)
+{
+ char *p, *buf;
+ ULONGEST num, initval, builtin;
+ int end;
+ struct uploaded_tsv *utsv = NULL;
+
+ buf = alloca (strlen (line));
+
+ p = line;
+ p = unpack_varlen_hex (p, &num);
+ p++; /* skip a colon */
+ p = unpack_varlen_hex (p, &initval);
+ p++; /* skip a colon */
+ p = unpack_varlen_hex (p, &builtin);
+ p++; /* skip a colon */
+ end = hex2bin (p, (gdb_byte *) buf, strlen (p) / 2);
+ buf[end] = '\0';
+
+ utsv = get_uploaded_tsv (num, utsvp);
+ utsv->initial_value = initval;
+ utsv->builtin = builtin;
+ utsv->name = xstrdup (buf);
+}
+
+/* Close the trace file and generally clean up. */
+
+static void
+tfile_close (int quitting)
+{
+ int pid;
+
+ if (trace_fd < 0)
+ return;
+
+ pid = ptid_get_pid (inferior_ptid);
+ inferior_ptid = null_ptid; /* Avoid confusion from thread stuff */
+ exit_inferior_silent (pid);
+
+ close (trace_fd);
+ trace_fd = -1;
+}
+
+static void
+tfile_files_info (struct target_ops *t)
+{
+ /* (it would be useful to mention the name of the file) */
+ printf_filtered ("Looking at a trace file.\n");
+}
+
+/* The trace status for a file is that tracing can never be run. */
+
+static int
+tfile_get_trace_status (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;
+}
+
+/* Given the position of a traceframe in the file, figure out what
+ address the frame was collected at. This would normally be the
+ value of a collected PC register, but if not available, we
+ improvise. */
+
+static ULONGEST
+tfile_get_traceframe_address (off_t tframe_offset)
+{
+ ULONGEST addr = 0;
+ short tpnum;
+ struct breakpoint *tp;
+ off_t saved_offset = cur_offset;
+
+ /* FIXME dig pc out of collected registers */
+
+ /* Fall back to using tracepoint address. */
+ lseek (trace_fd, tframe_offset, SEEK_SET);
+ read (trace_fd, &tpnum, 2);
+ tp = get_tracepoint_by_number_on_target (tpnum);
+ if (tp && tp->loc)
+ addr = tp->loc->address;
+
+ /* Restore our seek position. */
+ cur_offset = saved_offset;
+ lseek (trace_fd, cur_offset, SEEK_SET);
+ return addr;
+}
+
+/* Given a type of search and some parameters, scan the collection of
+ traceframes in the file looking for a match. When found, return
+ both the traceframe and tracepoint number, otherwise -1 for
+ each. */
+
+static int
+tfile_trace_find (enum trace_find_type type, int num,
+ ULONGEST addr1, ULONGEST addr2, int *tpp)
+{
+ short tpnum;
+ int tfnum = 0, found = 0;
+ int data_size;
+ struct breakpoint *tp;
+ off_t offset, tframe_offset;
+ ULONGEST tfaddr;
+
+ lseek (trace_fd, trace_frames_offset, SEEK_SET);
+ offset = trace_frames_offset;
+ while (1)
+ {
+ tframe_offset = offset;
+ read (trace_fd, &tpnum, 2);
+ offset += 2;
+ if (tpnum == 0)
+ break;
+ read (trace_fd, &data_size, 4);
+ offset += 4;
+ switch (type)
+ {
+ case tfind_number:
+ if (tfnum == num)
+ found = 1;
+ break;
+ case tfind_pc:
+ tfaddr = tfile_get_traceframe_address (tframe_offset);
+ if (tfaddr == addr1)
+ found = 1;
+ break;
+ case tfind_tp:
+ tp = get_tracepoint (num);
+ if (tp && tpnum == tp->number_on_target)
+ found = 1;
+ break;
+ case tfind_range:
+ tfaddr = tfile_get_traceframe_address (tframe_offset);
+ if (addr1 <= tfaddr && tfaddr <= addr2)
+ found = 1;
+ break;
+ case tfind_outside:
+ tfaddr = tfile_get_traceframe_address (tframe_offset);
+ if (!(addr1 <= tfaddr && tfaddr <= addr2))
+ found = 1;
+ break;
+ default:
+ internal_error (__FILE__, __LINE__, _("unknown tfind type"));
+ }
+ if (found)
+ {
+ printf_filtered ("Found traceframe %d.\n", tfnum);
+ if (tpp)
+ *tpp = tpnum;
+ cur_offset = offset;
+ cur_data_size = data_size;
+ return tfnum;
+ }
+ /* Skip past the traceframe's data. */
+ lseek (trace_fd, data_size, SEEK_CUR);
+ offset += data_size;
+ /* Update our own count of traceframes. */
+ ++tfnum;
+ }
+ /* Did not find what we were looking for. */
+ if (tpp)
+ *tpp = -1;
+ return -1;
+}
+
+/* Look for a block of saved registers in the traceframe, and get the
+ requested register from it. */
+
+static void
+tfile_fetch_registers (struct target_ops *ops,
+ struct regcache *regcache, int regno)
+{
+ struct gdbarch *gdbarch = get_regcache_arch (regcache);
+ char block_type;
+ int i, pos, offset, regn, regsize;
+ unsigned short mlen;
+ char *regs;
+
+ /* An uninitialized reg size says we're not going to be
+ successful at getting register blocks. */
+ if (!trace_regblock_size)
+ return;
+
+ regs = alloca (trace_regblock_size);
+
+ lseek (trace_fd, cur_offset, SEEK_SET);
+ pos = 0;
+ while (pos < cur_data_size)
+ {
+ read (trace_fd, &block_type, 1);
+ ++pos;
+ switch (block_type)
+ {
+ case 'R':
+ read (trace_fd, regs, trace_regblock_size);
+ /* Assume the block is laid out in GDB register number order,
+ each register with the size that it has in GDB. */
+ offset = 0;
+ for (regn = 0; regn < gdbarch_num_regs (gdbarch); regn++)
+ {
+ regsize = register_size (gdbarch, regn);
+ /* Make sure we stay within block bounds. */
+ if (offset + regsize >= trace_regblock_size)
+ break;
+ if (!regcache_valid_p (regcache, regn))
+ {
+ if (regno == regn)
+ {
+ regcache_raw_supply (regcache, regno, regs + offset);
+ break;
+ }
+ else if (regno == -1)
+ {
+ regcache_raw_supply (regcache, regn, regs + offset);
+ }
+ }
+ offset += regsize;
+ }
+ return;
+ case 'M':
+ lseek (trace_fd, 8, SEEK_CUR);
+ read (trace_fd, &mlen, 2);
+ lseek (trace_fd, mlen, SEEK_CUR);
+ pos += (8 + 2 + mlen);
+ break;
+ case 'V':
+ lseek (trace_fd, 4 + 8, SEEK_CUR);
+ pos += (4 + 8);
+ break;
+ default:
+ error ("Unknown block type '%c' (0x%x) in trace frame",
+ block_type, block_type);
+ break;
+ }
+ }
+}
+
+static LONGEST
+tfile_xfer_partial (struct target_ops *ops, enum target_object object,
+ const char *annex, gdb_byte *readbuf,
+ const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
+{
+ char block_type;
+ int pos;
+ ULONGEST maddr;
+ unsigned short mlen;
+
+ /* We're only doing regular memory for now. */
+ if (object != TARGET_OBJECT_MEMORY)
+ return -1;
+
+ if (readbuf == NULL)
+ error ("tfile_xfer_partial: trace file is read-only");
+
+ lseek (trace_fd, cur_offset, SEEK_SET);
+ pos = 0;
+ while (pos < cur_data_size)
+ {
+ read (trace_fd, &block_type, 1);
+ ++pos;
+ switch (block_type)
+ {
+ case 'R':
+ lseek (trace_fd, trace_regblock_size, SEEK_CUR);
+ pos += trace_regblock_size;
+ break;
+ case 'M':
+ read (trace_fd, &maddr, 8);
+ read (trace_fd, &mlen, 2);
+ if (maddr <= offset && (offset + len) <= (maddr + mlen))
+ {
+ read (trace_fd, readbuf, mlen);
+ return mlen;
+ }
+ lseek (trace_fd, mlen, SEEK_CUR);
+ pos += (8 + 2 + mlen);
+ break;
+ case 'V':
+ lseek (trace_fd, 4 + 8, SEEK_CUR);
+ pos += (4 + 8);
+ break;
+ default:
+ error ("Unknown block type '%c' (0x%x) in traceframe",
+ block_type, block_type);
+ break;
+ }
+ }
+ /* Indicate failure to find the requested memory block. */
+ return -1;
+}
+
+/* Iterate through the blocks of a trace frame, looking for a 'V'
+ block with a matching tsv number. */
+
+static int
+tfile_get_trace_state_variable_value (int tsvnum, LONGEST *val)
+{
+ char block_type;
+ int pos, vnum;
+ unsigned short mlen;
+
+ lseek (trace_fd, cur_offset, SEEK_SET);
+ pos = 0;
+ while (pos < cur_data_size)
+ {
+ read (trace_fd, &block_type, 1);
+ ++pos;
+ switch (block_type)
+ {
+ case 'R':
+ lseek (trace_fd, trace_regblock_size, SEEK_CUR);
+ pos += trace_regblock_size;
+ break;
+ case 'M':
+ lseek (trace_fd, 8, SEEK_CUR);
+ read (trace_fd, &mlen, 2);
+ lseek (trace_fd, mlen, SEEK_CUR);
+ pos += (8 + 2 + mlen);
+ break;
+ case 'V':
+ read (trace_fd, &vnum, 4);
+ if (tsvnum == vnum)
+ {
+ read (trace_fd, val, 8);
+ return 1;
+ }
+ lseek (trace_fd, 8, SEEK_CUR);
+ pos += (4 + 8);
+ break;
+ default:
+ error ("Unknown block type '%c' (0x%x) in traceframe",
+ block_type, block_type);
+ break;
+ }
+ }
+ /* Didn't find anything. */
+ return 0;
+}
+
+static int
+tfile_has_memory (struct target_ops *ops)
+{
+ return 1;
+}
+
+static int
+tfile_has_stack (struct target_ops *ops)
+{
+ return 1;
+}
+
+static int
+tfile_has_registers (struct target_ops *ops)
+{
+ return 1;
+}
+
+static void
+init_tfile_ops (void)
+{
+ tfile_ops.to_shortname = "tfile";
+ tfile_ops.to_longname = "Local trace dump file";
+ tfile_ops.to_doc =
+ "Use a trace file as a target. Specify the filename of the trace file.";
+ tfile_ops.to_open = tfile_open;
+ tfile_ops.to_close = tfile_close;
+ tfile_ops.to_fetch_registers = tfile_fetch_registers;
+ tfile_ops.to_xfer_partial = tfile_xfer_partial;
+ tfile_ops.to_files_info = tfile_files_info;
+ tfile_ops.to_get_trace_status = tfile_get_trace_status;
+ tfile_ops.to_trace_find = tfile_trace_find;
+ tfile_ops.to_get_trace_state_variable_value = tfile_get_trace_state_variable_value;
+ /* core_stratum might seem more logical, but GDB doesn't like having
+ more than one core_stratum vector. */
+ tfile_ops.to_stratum = process_stratum;
+ tfile_ops.to_has_memory = tfile_has_memory;
+ tfile_ops.to_has_stack = tfile_has_stack;
+ tfile_ops.to_has_registers = tfile_has_registers;
+ tfile_ops.to_magic = OPS_MAGIC;
+}
+
/* module initialization */
void
_initialize_tracepoint (void)
add_com ("tdump", class_trace, trace_dump_command,
_("Print everything collected at the current tracepoint."));
+ add_com ("tsave", class_trace, trace_save_command, _("\
+Save the trace data to a file.\n\
+Use the '-r' option to direct the target to save directly to the file,\n\
+using its own filesystem."));
+
c = add_com ("tvariable", class_trace, trace_variable_command,_("\
Define a trace state variable.\n\
Argument is a $-prefixed name, optionally followed\n\
NULL,
&setlist,
&showlist);
+
+ init_tfile_ops ();
+
+ add_target (&tfile_ops);
}
projects / binutils-gdb.git / commitdiff