/* Tracing functionality for remote targets in custom GDB protocol
- Copyright (C) 1997-2013 Free Software Foundation, Inc.
+ Copyright (C) 1997-2014 Free Software Foundation, Inc.
This file is part of GDB.
#include "gdbcmd.h"
#include "value.h"
#include "target.h"
+#include "target-dcache.h"
#include "language.h"
-#include "gdb_string.h"
#include "inferior.h"
#include "breakpoint.h"
#include "tracepoint.h"
#include "filenames.h"
#include "gdbthread.h"
#include "stack.h"
-#include "gdbcore.h"
#include "remote.h"
#include "source.h"
#include "ax.h"
#include "ax-gdb.h"
#include "memrange.h"
-#include "exceptions.h"
#include "cli/cli-utils.h"
#include "probe.h"
#include "ctf.h"
-#include "completer.h"
#include "filestuff.h"
+#include "rsp-low.h"
+#include "tracefile.h"
/* readline include files */
#include "readline/readline.h"
/* readline defines this. */
#undef savestring
-#ifdef HAVE_UNISTD_H
#include <unistd.h>
-#endif
-
-#ifndef O_LARGEFILE
-#define O_LARGEFILE 0
-#endif
/* Maximum length of an agent aexpression.
This accounts for the fact that packets are limited to 400 bytes
void (*deprecated_trace_find_hook) (char *arg, int from_tty);
void (*deprecated_trace_start_stop_hook) (int start, int from_tty);
-extern void (*deprecated_readline_begin_hook) (char *, ...);
-extern char *(*deprecated_readline_hook) (char *);
-extern void (*deprecated_readline_end_hook) (void);
-
/*
Tracepoint.c:
/* Tracepoint for last traceframe collected. */
static int tracepoint_number;
-/* Symbol for function for last traceframe collected. */
-static struct symbol *traceframe_fun;
-
-/* Symtab and line for last traceframe collected. */
-static struct symtab_and_line traceframe_sal;
-
/* The traceframe info of the current traceframe. NULL if we haven't
yet attempted to fetch it, or if the target does not support
fetching this object, or if we're not inspecting a traceframe
static void add_register (struct collection_list *collection,
unsigned int regno);
-static void free_uploaded_tps (struct uploaded_tp **utpp);
-static void free_uploaded_tsvs (struct uploaded_tsv **utsvp);
-
static struct command_line *
all_tracepoint_actions_and_cleanup (struct breakpoint *t);
static struct trace_status trace_status;
-char *stop_reason_names[] = {
+const char *stop_reason_names[] = {
"tunknown",
"tnotrun",
"tstop",
if (info != NULL)
{
VEC_free (mem_range_s, info->memory);
+ VEC_free (int, info->tvars);
xfree (info);
}
set_traceframe_context (struct frame_info *trace_frame)
{
CORE_ADDR trace_pc;
+ struct symbol *traceframe_fun;
+ struct symtab_and_line traceframe_sal;
/* Save as globals for internal use. */
if (trace_frame != NULL
return NULL;
}
+/* Look for a trace state variable of the given number. Return NULL if
+ not found. */
+
+struct trace_state_variable *
+find_trace_state_variable_by_number (int number)
+{
+ struct trace_state_variable *tsv;
+ int ix;
+
+ for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
+ if (tsv->number == number)
+ return tsv;
+
+ return NULL;
+}
+
static void
delete_trace_state_variable (const char *name)
{
struct tracepoint *t;
struct command_line *l;
- t = get_tracepoint_by_number (&args, NULL, 1);
+ t = get_tracepoint_by_number (&args, NULL);
if (t)
{
char *tmpbuf =
memrange_absolute = -1
};
-struct memrange
-{
- int type; /* memrange_absolute for absolute memory range,
- else basereg number. */
- bfd_signed_vma start;
- bfd_signed_vma end;
-};
-
-struct collection_list
- {
- unsigned char regs_mask[32]; /* room for up to 256 regs */
- long listsize;
- long next_memrange;
- struct memrange *list;
- long aexpr_listsize; /* size of array pointed to by expr_list elt */
- long next_aexpr_elt;
- struct agent_expr **aexpr_list;
-
- /* True is the user requested a collection of "$_sdata", "static
- tracepoint data". */
- int strace_data;
- }
-tracepoint_list, stepping_list;
-
/* MEMRANGE functions: */
static int memrange_cmp (const void *, const void *);
collect_symbol (p->collect, sym, p->gdbarch, p->frame_regno,
p->frame_offset, p->pc, p->trace_string);
p->count++;
+
+ VEC_safe_push (char_ptr, p->collect->wholly_collected,
+ xstrdup (print_name));
}
/* Add all locals (or args) symbols to collection list. */
long frame_regno, long frame_offset, int type,
int trace_string)
{
- struct block *block;
+ const struct block *block;
struct add_local_symbols_data cb_data;
cb_data.collect = collect;
list->next_aexpr_elt = 0;
memset (list->regs_mask, 0, sizeof (list->regs_mask));
list->strace_data = 0;
+
+ xfree (list->aexpr_list);
+ xfree (list->list);
+
+ VEC_free (char_ptr, list->wholly_collected);
+ VEC_free (char_ptr, list->computed);
+}
+
+/* A cleanup wrapper for function clear_collection_list. */
+
+static void
+do_clear_collection_list (void *list)
+{
+ struct collection_list *l = list;
+
+ clear_collection_list (l);
+}
+
+/* Initialize collection_list CLIST. */
+
+static void
+init_collection_list (struct collection_list *clist)
+{
+ memset (clist, 0, sizeof *clist);
+
+ clist->listsize = 128;
+ clist->list = xcalloc (clist->listsize,
+ sizeof (struct memrange));
+
+ clist->aexpr_listsize = 128;
+ clist->aexpr_list = xcalloc (clist->aexpr_listsize,
+ sizeof (struct agent_expr *));
}
/* Reduce a collection list to string form (for gdb protocol). */
return *str_list;
}
+/* Add the printed expression EXP to *LIST. */
+
+static void
+append_exp (struct expression *exp, VEC(char_ptr) **list)
+{
+ struct ui_file *tmp_stream = mem_fileopen ();
+ char *text;
+
+ print_expression (exp, tmp_stream);
+
+ text = ui_file_xstrdup (tmp_stream, NULL);
+
+ VEC_safe_push (char_ptr, *list, text);
+ ui_file_delete (tmp_stream);
+}
static void
encode_actions_1 (struct command_line *action,
check_typedef (exp->elts[1].type);
add_memrange (collect, memrange_absolute, addr,
TYPE_LENGTH (exp->elts[1].type));
+ append_exp (exp, &collect->computed);
break;
case OP_VAR_VALUE:
- collect_symbol (collect,
- exp->elts[2].symbol,
- tloc->gdbarch,
- frame_reg,
- frame_offset,
- tloc->address,
- trace_string);
+ {
+ struct symbol *sym = exp->elts[2].symbol;
+ char_ptr name = (char_ptr) SYMBOL_NATURAL_NAME (sym);
+
+ collect_symbol (collect,
+ exp->elts[2].symbol,
+ tloc->gdbarch,
+ frame_reg,
+ frame_offset,
+ tloc->address,
+ trace_string);
+ VEC_safe_push (char_ptr,
+ collect->wholly_collected,
+ name);
+ }
break;
default: /* Full-fledged expression. */
}
}
}
+
+ append_exp (exp, &collect->computed);
break;
} /* switch */
do_cleanups (old_chain);
} /* for */
}
-/* Render all actions into gdb protocol. */
+/* Encode actions of tracepoint TLOC->owner and fill TRACEPOINT_LIST
+ and STEPPING_LIST. Return a cleanup pointer to clean up both
+ TRACEPOINT_LIST and STEPPING_LIST. */
-void
-encode_actions (struct bp_location *tloc, char ***tdp_actions,
- char ***stepping_actions)
+struct cleanup *
+encode_actions_and_make_cleanup (struct bp_location *tloc,
+ struct collection_list *tracepoint_list,
+ struct collection_list *stepping_list)
{
char *default_collect_line = NULL;
struct command_line *actions;
struct command_line *default_collect_action = NULL;
int frame_reg;
LONGEST frame_offset;
- struct cleanup *back_to;
-
- back_to = make_cleanup (null_cleanup, NULL);
+ struct cleanup *back_to, *return_chain;
- clear_collection_list (&tracepoint_list);
- clear_collection_list (&stepping_list);
+ return_chain = make_cleanup (null_cleanup, NULL);
+ init_collection_list (tracepoint_list);
+ init_collection_list (stepping_list);
- *tdp_actions = NULL;
- *stepping_actions = NULL;
+ make_cleanup (do_clear_collection_list, tracepoint_list);
+ make_cleanup (do_clear_collection_list, stepping_list);
+ back_to = make_cleanup (null_cleanup, NULL);
gdbarch_virtual_frame_pointer (tloc->gdbarch,
tloc->address, &frame_reg, &frame_offset);
actions = all_tracepoint_actions_and_cleanup (tloc->owner);
encode_actions_1 (actions, tloc, frame_reg, frame_offset,
- &tracepoint_list, &stepping_list);
+ tracepoint_list, stepping_list);
+
+ memrange_sortmerge (tracepoint_list);
+ memrange_sortmerge (stepping_list);
+
+ do_cleanups (back_to);
+ return return_chain;
+}
+
+/* Render all actions into gdb protocol. */
+
+void
+encode_actions_rsp (struct bp_location *tloc, char ***tdp_actions,
+ char ***stepping_actions)
+{
+ struct collection_list tracepoint_list, stepping_list;
+ struct cleanup *cleanup;
+
+ *tdp_actions = NULL;
+ *stepping_actions = NULL;
- memrange_sortmerge (&tracepoint_list);
- memrange_sortmerge (&stepping_list);
+ cleanup = encode_actions_and_make_cleanup (tloc, &tracepoint_list,
+ &stepping_list);
*tdp_actions = stringify_collection_list (&tracepoint_list);
*stepping_actions = stringify_collection_list (&stepping_list);
- do_cleanups (back_to);
+ do_cleanups (cleanup);
}
static void
" GDB is disconnected\n"));
}
+/* Reset local state of tracing. */
+
+void
+trace_reset_local_state (void)
+{
+ set_traceframe_num (-1);
+ set_tracepoint_num (-1);
+ set_traceframe_context (NULL);
+ clear_traceframe_info ();
+}
void
start_tracing (char *notes)
t->number_on_target = b->number;
for (loc = b->loc; loc; loc = loc->next)
- if (loc->probe != NULL)
- loc->probe->pops->set_semaphore (loc->probe, loc->gdbarch);
+ if (loc->probe.probe != NULL)
+ loc->probe.probe->pops->set_semaphore (loc->probe.probe,
+ loc->probe.objfile,
+ loc->gdbarch);
if (bp_location_downloaded)
observer_notify_breakpoint_modified (b);
target_trace_start ();
/* Reset our local state. */
- set_traceframe_num (-1);
- set_tracepoint_num (-1);
- set_traceframe_context (NULL);
+ trace_reset_local_state ();
current_trace_status()->running = 1;
- clear_traceframe_info ();
}
/* The tstart command requests the target to start a new trace run.
but we don't really care if this semaphore goes out of sync.
That's why we are decrementing it here, but not taking care
in other places. */
- if (loc->probe != NULL)
- loc->probe->pops->clear_semaphore (loc->probe, loc->gdbarch);
+ if (loc->probe.probe != NULL)
+ loc->probe.probe->pops->clear_semaphore (loc->probe.probe,
+ loc->probe.objfile,
+ loc->gdbarch);
}
}
/* Reporting a run time is more readable than two long numbers. */
printf_filtered (_("Trace started at %ld.%06ld secs, stopped %ld.%06ld secs later.\n"),
- (long int) ts->start_time / 1000000,
- (long int) ts->start_time % 1000000,
- (long int) run_time / 1000000,
- (long int) run_time % 1000000);
+ (long int) (ts->start_time / 1000000),
+ (long int) (ts->start_time % 1000000),
+ (long int) (run_time / 1000000),
+ (long int) (run_time % 1000000));
}
else
printf_filtered (_("Trace started at %ld.%06ld secs.\n"),
- (long int) ts->start_time / 1000000,
- (long int) ts->start_time % 1000000);
+ (long int) (ts->start_time / 1000000),
+ (long int) (ts->start_time % 1000000));
}
else if (ts->stop_time)
printf_filtered (_("Trace stopped at %ld.%06ld secs.\n"),
- (long int) ts->stop_time / 1000000,
- (long int) ts->stop_time % 1000000);
+ (long int) (ts->stop_time / 1000000),
+ (long int) (ts->stop_time % 1000000));
/* Now report any per-tracepoint status available. */
tp_vec = all_tracepoints ();
char buf[100];
xsnprintf (buf, sizeof buf, "%ld.%06ld",
- (long int) ts->start_time / 1000000,
- (long int) ts->start_time % 1000000);
+ (long int) (ts->start_time / 1000000),
+ (long int) (ts->start_time % 1000000));
ui_out_field_string (uiout, "start-time", buf);
xsnprintf (buf, sizeof buf, "%ld.%06ld",
- (long int) ts->stop_time / 1000000,
- (long int) ts->stop_time % 1000000);
+ (long int) (ts->stop_time / 1000000),
+ (long int) (ts->stop_time % 1000000));
ui_out_field_string (uiout, "stop-time", buf);
}
}
confusing upon reconnection. Just use these calls instead of
full tfind_1 behavior because we're in the middle of detaching,
and there's no point to updating current stack frame etc. */
- set_current_traceframe (-1);
- set_tracepoint_num (-1);
- set_traceframe_context (NULL);
+ trace_reset_local_state ();
}
/* Worker function for the various flavors of the tfind command. */
else
print_what = SRC_AND_LOC;
- print_stack_frame (get_selected_frame (NULL), 1, print_what);
+ print_stack_frame (get_selected_frame (NULL), 1, print_what, 1);
do_displays ();
}
}
+/* Error on looking at traceframes while trace is running. */
+
+void
+check_trace_running (struct trace_status *status)
+{
+ if (status->running && status->filename == NULL)
+ error (_("May not look at trace frames while trace is running."));
+}
+
/* trace_find_command takes a trace frame number n,
sends "QTFrame:<n>" to the target,
and accepts a reply that may contain several optional pieces
{ /* This should only be called with a numeric argument. */
int frameno = -1;
- if (current_trace_status ()->running
- && current_trace_status ()->filename == NULL)
- error (_("May not look at trace frames while trace is running."));
+ check_trace_running (current_trace_status ());
if (args == 0 || *args == 0)
{ /* TFIND with no args means find NEXT trace frame. */
{
CORE_ADDR pc;
- if (current_trace_status ()->running
- && current_trace_status ()->filename == NULL)
- error (_("May not look at trace frames while trace is running."));
+ check_trace_running (current_trace_status ());
if (args == 0 || *args == 0)
pc = regcache_read_pc (get_current_regcache ());
int tdp;
struct tracepoint *tp;
- if (current_trace_status ()->running
- && current_trace_status ()->filename == NULL)
- error (_("May not look at trace frames while trace is running."));
+ check_trace_running (current_trace_status ());
if (args == 0 || *args == 0)
{
struct symtab_and_line sal;
struct cleanup *old_chain;
- if (current_trace_status ()->running
- && current_trace_status ()->filename == NULL)
- error (_("May not look at trace frames while trace is running."));
+ check_trace_running (current_trace_status ());
if (args == 0 || *args == 0)
{
static CORE_ADDR start, stop;
char *tmp;
- if (current_trace_status ()->running
- && current_trace_status ()->filename == NULL)
- error (_("May not look at trace frames while trace is running."));
+ check_trace_running (current_trace_status ());
if (args == 0 || *args == 0)
{ /* XXX FIXME: what should default behavior be? */
{
struct symtabs_and_lines sals;
struct symbol *sym;
- struct minimal_symbol *msym;
- struct block *block;
+ struct bound_minimal_symbol msym;
+ const struct block *block;
const char *symname;
char *save_args = args;
struct block_iterator iter;
case LOC_UNRESOLVED:
msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym),
NULL, NULL);
- if (msym == NULL)
+ if (msym.minsym == NULL)
printf_filtered ("Unresolved Static");
else
{
printf_filtered ("static storage at address ");
printf_filtered ("%s",
paddress (gdbarch,
- SYMBOL_VALUE_ADDRESS (msym)));
+ BMSYMBOL_VALUE_ADDRESS (msym)));
}
break;
case LOC_OPTIMIZED_OUT:
}
}
+/* Return bp_location of the tracepoint associated with the current
+ traceframe. Set *STEPPING_FRAME_P to 1 if the current traceframe
+ is a stepping traceframe. */
+
+struct bp_location *
+get_traceframe_location (int *stepping_frame_p)
+{
+ struct tracepoint *t;
+ struct bp_location *tloc;
+ struct regcache *regcache;
+
+ if (tracepoint_number == -1)
+ error (_("No current trace frame."));
+
+ t = get_tracepoint (tracepoint_number);
+
+ if (t == NULL)
+ error (_("No known tracepoint matches 'current' tracepoint #%d."),
+ tracepoint_number);
+
+ /* The current frame is a trap frame if the frame PC is equal to the
+ tracepoint PC. If not, then the current frame was collected
+ during single-stepping. */
+ regcache = get_current_regcache ();
+
+ /* If the traceframe's address matches any of the tracepoint's
+ locations, assume it is a direct hit rather than a while-stepping
+ frame. (FIXME this is not reliable, should record each frame's
+ type.) */
+ for (tloc = t->base.loc; tloc; tloc = tloc->next)
+ if (tloc->address == regcache_read_pc (regcache))
+ {
+ *stepping_frame_p = 0;
+ return tloc;
+ }
+
+ /* If this is a stepping frame, we don't know which location
+ triggered. The first is as good (or bad) a guess as any... */
+ *stepping_frame_p = 1;
+ return t->base.loc;
+}
+
/* Return all the actions, including default collect, of a tracepoint
T. It constructs cleanups into the chain, and leaves the caller to
handle them (call do_cleanups). */
static void
trace_dump_command (char *args, int from_tty)
{
- struct regcache *regcache;
- struct tracepoint *t;
int stepping_frame = 0;
struct bp_location *loc;
- char *default_collect_line = NULL;
- struct command_line *actions, *default_collect_action = NULL;
struct cleanup *old_chain;
+ struct command_line *actions;
- if (tracepoint_number == -1)
- {
- warning (_("No current trace frame."));
- return;
- }
-
- old_chain = make_cleanup (null_cleanup, NULL);
- t = get_tracepoint (tracepoint_number);
-
- if (t == NULL)
- error (_("No known tracepoint matches 'current' tracepoint #%d."),
- tracepoint_number);
+ /* This throws an error is not inspecting a trace frame. */
+ loc = get_traceframe_location (&stepping_frame);
printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
tracepoint_number, traceframe_number);
- /* The current frame is a trap frame if the frame PC is equal
- to the tracepoint PC. If not, then the current frame was
- collected during single-stepping. */
-
- regcache = get_current_regcache ();
+ old_chain = make_cleanup (null_cleanup, NULL);
- /* If the traceframe's address matches any of the tracepoint's
- locations, assume it is a direct hit rather than a while-stepping
- frame. (FIXME this is not reliable, should record each frame's
- type.) */
- stepping_frame = 1;
- for (loc = t->base.loc; loc; loc = loc->next)
- if (loc->address == regcache_read_pc (regcache))
- stepping_frame = 0;
+ /* This command only makes sense for the current frame, not the
+ selected frame. */
+ make_cleanup_restore_current_thread ();
+ select_frame (get_current_frame ());
- actions = all_tracepoint_actions_and_cleanup (&t->base);
+ actions = all_tracepoint_actions_and_cleanup (loc->owner);
trace_dump_actions (actions, 0, stepping_frame, from_tty);
srctype, 0, (int) strlen (src));
if (strlen (buf) + strlen (src) * 2 >= buf_size)
error (_("Source string too long for buffer"));
- bin2hex ((gdb_byte *) src, buf + strlen (buf), 0);
+ bin2hex ((gdb_byte *) src, buf + strlen (buf), strlen (src));
return -1;
}
-/* Free trace file writer. */
+/* Tell the target what to do with an ongoing tracing run if GDB
+ disconnects for some reason. */
static void
-trace_file_writer_xfree (void *arg)
+set_disconnected_tracing (char *args, int from_tty,
+ struct cmd_list_element *c)
{
- struct trace_file_writer *writer = arg;
-
- writer->ops->dtor (writer);
- xfree (writer);
+ target_set_disconnected_tracing (disconnected_tracing);
}
-/* TFILE trace writer. */
-
-struct tfile_trace_file_writer
+static void
+set_circular_trace_buffer (char *args, int from_tty,
+ struct cmd_list_element *c)
{
- struct trace_file_writer base;
-
- /* File pointer to tfile trace file. */
- FILE *fp;
- /* Path name of the tfile trace file. */
- char *pathname;
-};
-
-/* This is the implementation of trace_file_write_ops method
- target_save. We just call the generic target
- target_save_trace_data to do target-side saving. */
+ target_set_circular_trace_buffer (circular_trace_buffer);
+}
-static int
-tfile_target_save (struct trace_file_writer *self,
- const char *filename)
+static void
+set_trace_buffer_size (char *args, int from_tty,
+ struct cmd_list_element *c)
{
- int err = target_save_trace_data (filename);
-
- return (err >= 0);
+ target_set_trace_buffer_size (trace_buffer_size);
}
-/* This is the implementation of trace_file_write_ops method
- dtor. */
-
static void
-tfile_dtor (struct trace_file_writer *self)
+set_trace_user (char *args, int from_tty,
+ struct cmd_list_element *c)
{
- struct tfile_trace_file_writer *writer
- = (struct tfile_trace_file_writer *) self;
+ int ret;
- xfree (writer->pathname);
+ ret = target_set_trace_notes (trace_user, NULL, NULL);
- if (writer->fp != NULL)
- fclose (writer->fp);
+ if (!ret)
+ warning (_("Target does not support trace notes, user ignored"));
}
-/* This is the implementation of trace_file_write_ops method
- start. It creates the trace file FILENAME and registers some
- cleanups. */
-
static void
-tfile_start (struct trace_file_writer *self, const char *filename)
+set_trace_notes (char *args, int from_tty,
+ struct cmd_list_element *c)
{
- struct tfile_trace_file_writer *writer
- = (struct tfile_trace_file_writer *) self;
-
- writer->pathname = tilde_expand (filename);
- writer->fp = gdb_fopen_cloexec (writer->pathname, "wb");
- if (writer->fp == NULL)
- error (_("Unable to open file '%s' for saving trace data (%s)"),
- filename, safe_strerror (errno));
-}
+ int ret;
-/* This is the implementation of trace_file_write_ops method
- write_header. Write the TFILE header. */
+ ret = target_set_trace_notes (NULL, trace_notes, NULL);
-static void
-tfile_write_header (struct trace_file_writer *self)
-{
- struct tfile_trace_file_writer *writer
- = (struct tfile_trace_file_writer *) self;
- int written;
-
- /* 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. */
- written = fwrite ("\x7fTRACE0\n", 8, 1, writer->fp);
- if (written < 1)
- perror_with_name (writer->pathname);
+ if (!ret)
+ warning (_("Target does not support trace notes, note ignored"));
}
-/* This is the implementation of trace_file_write_ops method
- write_regblock_type. Write the size of register block. */
-
static void
-tfile_write_regblock_type (struct trace_file_writer *self, int size)
+set_trace_stop_notes (char *args, int from_tty,
+ struct cmd_list_element *c)
{
- struct tfile_trace_file_writer *writer
- = (struct tfile_trace_file_writer *) self;
+ int ret;
+
+ ret = target_set_trace_notes (NULL, NULL, trace_stop_notes);
- fprintf (writer->fp, "R %x\n", size);
+ if (!ret)
+ warning (_("Target does not support trace notes, stop note ignored"));
}
-/* This is the implementation of trace_file_write_ops method
- write_status. */
+/* Convert the memory pointed to by mem into hex, placing result in buf.
+ * Return a pointer to the last char put in buf (null)
+ * "stolen" from sparc-stub.c
+ */
-static void
-tfile_write_status (struct trace_file_writer *self,
- struct trace_status *ts)
+static const char hexchars[] = "0123456789abcdef";
+
+static char *
+mem2hex (gdb_byte *mem, char *buf, int count)
{
- struct tfile_trace_file_writer *writer
- = (struct tfile_trace_file_writer *) self;
+ gdb_byte ch;
- fprintf (writer->fp, "status %c;%s",
- (ts->running ? '1' : '0'), stop_reason_names[ts->stop_reason]);
- if (ts->stop_reason == tracepoint_error
- || ts->stop_reason == tstop_command)
+ while (count-- > 0)
{
- char *buf = (char *) alloca (strlen (ts->stop_desc) * 2 + 1);
+ ch = *mem++;
- bin2hex ((gdb_byte *) ts->stop_desc, buf, 0);
- fprintf (writer->fp, ":%s", buf);
+ *buf++ = hexchars[ch >> 4];
+ *buf++ = hexchars[ch & 0xf];
}
- fprintf (writer->fp, ":%x", ts->stopping_tracepoint);
- if (ts->traceframe_count >= 0)
- fprintf (writer->fp, ";tframes:%x", ts->traceframe_count);
- if (ts->traceframes_created >= 0)
- fprintf (writer->fp, ";tcreated:%x", ts->traceframes_created);
- if (ts->buffer_free >= 0)
- fprintf (writer->fp, ";tfree:%x", ts->buffer_free);
- if (ts->buffer_size >= 0)
- fprintf (writer->fp, ";tsize:%x", ts->buffer_size);
- if (ts->disconnected_tracing)
- fprintf (writer->fp, ";disconn:%x", ts->disconnected_tracing);
- if (ts->circular_buffer)
- fprintf (writer->fp, ";circular:%x", ts->circular_buffer);
- if (ts->notes != NULL)
- {
- char *buf = (char *) alloca (strlen (ts->notes) * 2 + 1);
- bin2hex ((gdb_byte *) ts->notes, buf, 0);
- fprintf (writer->fp, ";notes:%s", buf);
- }
- if (ts->user_name != NULL)
- {
- char *buf = (char *) alloca (strlen (ts->user_name) * 2 + 1);
+ *buf = 0;
- bin2hex ((gdb_byte *) ts->user_name, buf, 0);
- fprintf (writer->fp, ";username:%s", buf);
- }
- fprintf (writer->fp, "\n");
+ return buf;
}
-/* This is the implementation of trace_file_write_ops method
- write_uploaded_tsv. */
+int
+get_traceframe_number (void)
+{
+ return traceframe_number;
+}
-static void
-tfile_write_uploaded_tsv (struct trace_file_writer *self,
- struct uploaded_tsv *utsv)
+int
+get_tracepoint_number (void)
{
- char *buf = "";
- struct tfile_trace_file_writer *writer
- = (struct tfile_trace_file_writer *) self;
+ return tracepoint_number;
+}
- if (utsv->name)
+/* Make the traceframe NUM be the current trace frame. Does nothing
+ if NUM is already current. */
+
+void
+set_current_traceframe (int num)
+{
+ int newnum;
+
+ if (traceframe_number == num)
{
- buf = (char *) xmalloc (strlen (utsv->name) * 2 + 1);
- bin2hex ((gdb_byte *) (utsv->name), buf, 0);
+ /* Nothing to do. */
+ return;
}
- fprintf (writer->fp, "tsv %x:%s:%x:%s\n",
- utsv->number, phex_nz (utsv->initial_value, 8),
- utsv->builtin, buf);
+ newnum = target_trace_find (tfind_number, num, 0, 0, NULL);
- if (utsv->name)
- xfree (buf);
-}
+ if (newnum != num)
+ warning (_("could not change traceframe"));
-#define MAX_TRACE_UPLOAD 2000
+ set_traceframe_num (newnum);
-/* This is the implementation of trace_file_write_ops method
- write_uploaded_tp. */
-
-static void
-tfile_write_uploaded_tp (struct trace_file_writer *self,
- struct uploaded_tp *utp)
-{
- struct tfile_trace_file_writer *writer
- = (struct tfile_trace_file_writer *) self;
- int a;
- char *act;
- char buf[MAX_TRACE_UPLOAD];
-
- fprintf (writer->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 (writer->fp, ":F%x", utp->orig_size);
- if (utp->cond)
- fprintf (writer->fp,
- ":X%x,%s", (unsigned int) strlen (utp->cond) / 2,
- utp->cond);
- fprintf (writer->fp, "\n");
- for (a = 0; VEC_iterate (char_ptr, utp->actions, a, act); ++a)
- fprintf (writer->fp, "tp A%x:%s:%s\n",
- utp->number, phex_nz (utp->addr, sizeof (utp->addr)), act);
- for (a = 0; VEC_iterate (char_ptr, utp->step_actions, a, act); ++a)
- fprintf (writer->fp, "tp S%x:%s:%s\n",
- utp->number, phex_nz (utp->addr, sizeof (utp->addr)), act);
- if (utp->at_string)
- {
- encode_source_string (utp->number, utp->addr,
- "at", utp->at_string, buf, MAX_TRACE_UPLOAD);
- fprintf (writer->fp, "tp Z%s\n", buf);
- }
- if (utp->cond_string)
- {
- encode_source_string (utp->number, utp->addr,
- "cond", utp->cond_string,
- buf, MAX_TRACE_UPLOAD);
- fprintf (writer->fp, "tp Z%s\n", buf);
- }
- for (a = 0; VEC_iterate (char_ptr, utp->cmd_strings, a, act); ++a)
- {
- encode_source_string (utp->number, utp->addr, "cmd", act,
- buf, MAX_TRACE_UPLOAD);
- fprintf (writer->fp, "tp Z%s\n", buf);
- }
- fprintf (writer->fp, "tp V%x:%s:%x:%s\n",
- utp->number, phex_nz (utp->addr, sizeof (utp->addr)),
- utp->hit_count,
- phex_nz (utp->traceframe_usage,
- sizeof (utp->traceframe_usage)));
-}
-
-/* This is the implementation of trace_file_write_ops method
- write_definition_end. */
-
-static void
-tfile_write_definition_end (struct trace_file_writer *self)
-{
- struct tfile_trace_file_writer *writer
- = (struct tfile_trace_file_writer *) self;
-
- fprintf (writer->fp, "\n");
-}
-
-/* This is the implementation of trace_file_write_ops method
- write_raw_data. */
-
-static void
-tfile_write_raw_data (struct trace_file_writer *self, gdb_byte *buf,
- LONGEST len)
-{
- struct tfile_trace_file_writer *writer
- = (struct tfile_trace_file_writer *) self;
-
- if (fwrite (buf, len, 1, writer->fp) < 1)
- perror_with_name (writer->pathname);
-}
-
-/* This is the implementation of trace_file_write_ops method
- end. */
-
-static void
-tfile_end (struct trace_file_writer *self)
-{
- struct tfile_trace_file_writer *writer
- = (struct tfile_trace_file_writer *) self;
- uint32_t gotten = 0;
-
- /* Mark the end of trace data. */
- if (fwrite (&gotten, 4, 1, writer->fp) < 1)
- perror_with_name (writer->pathname);
-}
-
-/* Operations to write trace buffers into TFILE format. */
-
-static const struct trace_file_write_ops tfile_write_ops =
-{
- tfile_dtor,
- tfile_target_save,
- tfile_start,
- tfile_write_header,
- tfile_write_regblock_type,
- tfile_write_status,
- tfile_write_uploaded_tsv,
- tfile_write_uploaded_tp,
- tfile_write_definition_end,
- tfile_write_raw_data,
- NULL,
- tfile_end,
-};
-
-/* Helper macros. */
-
-#define TRACE_WRITE_R_BLOCK(writer, buf, size) \
- writer->ops->frame_ops->write_r_block ((writer), (buf), (size))
-#define TRACE_WRITE_M_BLOCK_HEADER(writer, addr, size) \
- writer->ops->frame_ops->write_m_block_header ((writer), (addr), \
- (size))
-#define TRACE_WRITE_M_BLOCK_MEMORY(writer, buf, size) \
- writer->ops->frame_ops->write_m_block_memory ((writer), (buf), \
- (size))
-#define TRACE_WRITE_V_BLOCK(writer, num, val) \
- writer->ops->frame_ops->write_v_block ((writer), (num), (val))
-
-/* Save tracepoint data to file named FILENAME through WRITER. WRITER
- determines the trace file format. If TARGET_DOES_SAVE is non-zero,
- the save is performed on the target, otherwise GDB obtains all trace
- data and saves it locally. */
-
-static void
-trace_save (const char *filename, struct trace_file_writer *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;
- gdb_byte buf[MAX_TRACE_UPLOAD];
-#define MAX_TRACE_UPLOAD 2000
- 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
- send the command and be done with it. */
- if (target_does_save)
- {
- if (!writer->ops->target_save (writer, filename))
- 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);
-
- writer->ops->start (writer, filename);
-
- writer->ops->write_header (writer);
-
- /* Write descriptive info. */
-
- /* Write out the size of a register block. */
- writer->ops->write_regblock_type (writer, trace_regblock_size);
-
- /* Write out status of the tracing run (aka "tstatus" info). */
- writer->ops->write_status (writer, ts);
-
- /* 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)
- writer->ops->write_uploaded_tsv (writer, utsv);
-
- free_uploaded_tsvs (&uploaded_tsvs);
-
- target_upload_tracepoints (&uploaded_tps);
-
- for (utp = uploaded_tps; utp; utp = utp->next)
- target_get_tracepoint_status (NULL, utp);
-
- for (utp = uploaded_tps; utp; utp = utp->next)
- writer->ops->write_uploaded_tp (writer, utp);
-
- free_uploaded_tps (&uploaded_tps);
-
- /* Mark the end of the definition section. */
- writer->ops->write_definition_end (writer);
-
- /* Get and write the trace data proper. */
- while (1)
- {
- LONGEST gotten = 0;
-
- /* The writer supports writing the contents of trace buffer
- directly to trace file. Don't parse the contents of trace
- buffer. */
- if (writer->ops->write_trace_buffer != NULL)
- {
- /* We ask for big blocks, in the hopes of efficiency, but
- will take less if the target has packet size limitations
- or some such. */
- 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;
-
- writer->ops->write_trace_buffer (writer, buf, gotten);
-
- offset += gotten;
- }
- else
- {
- uint16_t tp_num;
- uint32_t tf_size;
- /* Parse the trace buffers according to how data are stored
- in trace buffer in GDBserver. */
-
- gotten = target_get_raw_trace_data (buf, offset, 6);
-
- if (gotten == 0)
- break;
-
- /* Read the first six bytes in, which is the tracepoint
- number and trace frame size. */
- tp_num = (uint16_t)
- extract_unsigned_integer (&buf[0], 2, byte_order);
-
- tf_size = (uint32_t)
- extract_unsigned_integer (&buf[2], 4, byte_order);
-
- writer->ops->frame_ops->start (writer, tp_num);
- gotten = 6;
-
- if (tf_size > 0)
- {
- unsigned int block;
-
- offset += 6;
-
- for (block = 0; block < tf_size; )
- {
- gdb_byte block_type;
-
- /* We'll fetch one block each time, in order to
- handle the extremely large 'M' block. We first
- fetch one byte to get the type of the block. */
- gotten = target_get_raw_trace_data (buf, offset, 1);
- if (gotten < 1)
- error (_("Failure to get requested trace buffer data"));
-
- gotten = 1;
- block += 1;
- offset += 1;
-
- block_type = buf[0];
- switch (block_type)
- {
- case 'R':
- gotten
- = target_get_raw_trace_data (buf, offset,
- trace_regblock_size);
- if (gotten < trace_regblock_size)
- error (_("Failure to get requested trace"
- " buffer data"));
-
- TRACE_WRITE_R_BLOCK (writer, buf,
- trace_regblock_size);
- break;
- case 'M':
- {
- unsigned short mlen;
- ULONGEST addr;
- LONGEST t;
- int j;
-
- t = target_get_raw_trace_data (buf,offset, 10);
- if (t < 10)
- error (_("Failure to get requested trace"
- " buffer data"));
-
- offset += 10;
- block += 10;
-
- gotten = 0;
- addr = (ULONGEST)
- extract_unsigned_integer (buf, 8,
- byte_order);
- mlen = (unsigned short)
- extract_unsigned_integer (&buf[8], 2,
- byte_order);
-
- TRACE_WRITE_M_BLOCK_HEADER (writer, addr,
- mlen);
-
- /* The memory contents in 'M' block may be
- very large. Fetch the data from the target
- and write them into file one by one. */
- for (j = 0; j < mlen; )
- {
- unsigned int read_length;
-
- if (mlen - j > MAX_TRACE_UPLOAD)
- read_length = MAX_TRACE_UPLOAD;
- else
- read_length = mlen - j;
-
- t = target_get_raw_trace_data (buf,
- offset + j,
- read_length);
- if (t < read_length)
- error (_("Failure to get requested"
- " trace buffer data"));
-
- TRACE_WRITE_M_BLOCK_MEMORY (writer, buf,
- read_length);
-
- j += read_length;
- gotten += read_length;
- }
-
- break;
- }
- case 'V':
- {
- int vnum;
- LONGEST val;
-
- gotten
- = target_get_raw_trace_data (buf, offset,
- 12);
- if (gotten < 12)
- error (_("Failure to get requested"
- " trace buffer data"));
-
- vnum = (int) extract_signed_integer (buf,
- 4,
- byte_order);
- val
- = extract_signed_integer (&buf[4], 8,
- byte_order);
-
- TRACE_WRITE_V_BLOCK (writer, vnum, val);
- }
- break;
- default:
- error (_("Unknown block type '%c' (0x%x) in"
- " trace frame"),
- block_type, block_type);
- }
-
- block += gotten;
- offset += gotten;
- }
- }
- else
- offset += gotten;
-
- writer->ops->frame_ops->end (writer);
- }
- }
-
- writer->ops->end (writer);
-}
-
-/* Return a trace writer for TFILE format. */
-
-static struct trace_file_writer *
-tfile_trace_file_writer_new (void)
-{
- struct tfile_trace_file_writer *writer
- = xmalloc (sizeof (struct tfile_trace_file_writer));
-
- writer->base.ops = &tfile_write_ops;
- writer->fp = NULL;
- writer->pathname = NULL;
-
- return (struct trace_file_writer *) writer;
-}
-
-static void
-trace_save_command (char *args, int from_tty)
-{
- int target_does_save = 0;
- char **argv;
- char *filename = NULL;
- struct cleanup *back_to;
- int generate_ctf = 0;
- struct trace_file_writer *writer = NULL;
-
- if (args == NULL)
- error_no_arg (_("file in which to save trace data"));
-
- argv = gdb_buildargv (args);
- back_to = make_cleanup_freeargv (argv);
-
- for (; *argv; ++argv)
- {
- if (strcmp (*argv, "-r") == 0)
- target_does_save = 1;
- if (strcmp (*argv, "-ctf") == 0)
- generate_ctf = 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 (generate_ctf)
- writer = ctf_trace_file_writer_new ();
- else
- writer = tfile_trace_file_writer_new ();
-
- make_cleanup (trace_file_writer_xfree, writer);
-
- trace_save (filename, writer, target_does_save);
-
- if (from_tty)
- printf_filtered (_("Trace data saved to %s '%s'.\n"),
- generate_ctf ? "directory" : "file", filename);
-
- do_cleanups (back_to);
-}
-
-/* Save the trace data to file FILENAME of tfile format. */
-
-void
-trace_save_tfile (const char *filename, int target_does_save)
-{
- struct trace_file_writer *writer;
- struct cleanup *back_to;
-
- writer = tfile_trace_file_writer_new ();
- back_to = make_cleanup (trace_file_writer_xfree, writer);
- trace_save (filename, writer, target_does_save);
- do_cleanups (back_to);
-}
-
-/* Save the trace data to dir DIRNAME of ctf format. */
-
-void
-trace_save_ctf (const char *dirname, int target_does_save)
-{
- struct trace_file_writer *writer;
- struct cleanup *back_to;
-
- writer = ctf_trace_file_writer_new ();
- back_to = make_cleanup (trace_file_writer_xfree, writer);
-
- trace_save (dirname, writer, target_does_save);
- do_cleanups (back_to);
-}
-
-/* Tell the target what to do with an ongoing tracing run if GDB
- disconnects for some reason. */
-
-static void
-set_disconnected_tracing (char *args, int from_tty,
- struct cmd_list_element *c)
-{
- target_set_disconnected_tracing (disconnected_tracing);
-}
-
-static void
-set_circular_trace_buffer (char *args, int from_tty,
- struct cmd_list_element *c)
-{
- target_set_circular_trace_buffer (circular_trace_buffer);
-}
-
-static void
-set_trace_buffer_size (char *args, int from_tty,
- struct cmd_list_element *c)
-{
- target_set_trace_buffer_size (trace_buffer_size);
-}
-
-static void
-set_trace_user (char *args, int from_tty,
- struct cmd_list_element *c)
-{
- int ret;
-
- ret = target_set_trace_notes (trace_user, NULL, NULL);
-
- if (!ret)
- warning (_("Target does not support trace notes, user ignored"));
-}
-
-static void
-set_trace_notes (char *args, int from_tty,
- struct cmd_list_element *c)
-{
- int ret;
-
- ret = target_set_trace_notes (NULL, trace_notes, NULL);
-
- if (!ret)
- warning (_("Target does not support trace notes, note ignored"));
-}
-
-static void
-set_trace_stop_notes (char *args, int from_tty,
- struct cmd_list_element *c)
-{
- int ret;
-
- ret = target_set_trace_notes (NULL, NULL, trace_stop_notes);
-
- if (!ret)
- warning (_("Target does not support trace notes, stop note ignored"));
-}
-
-/* Convert the memory pointed to by mem into hex, placing result in buf.
- * Return a pointer to the last char put in buf (null)
- * "stolen" from sparc-stub.c
- */
-
-static const char hexchars[] = "0123456789abcdef";
-
-static char *
-mem2hex (gdb_byte *mem, char *buf, int count)
-{
- gdb_byte ch;
-
- while (count-- > 0)
- {
- ch = *mem++;
-
- *buf++ = hexchars[ch >> 4];
- *buf++ = hexchars[ch & 0xf];
- }
-
- *buf = 0;
-
- return buf;
-}
-
-int
-get_traceframe_number (void)
-{
- return traceframe_number;
-}
-
-int
-get_tracepoint_number (void)
-{
- return tracepoint_number;
-}
-
-/* Make the traceframe NUM be the current trace frame. Does nothing
- if NUM is already current. */
-
-void
-set_current_traceframe (int num)
-{
- int newnum;
-
- if (traceframe_number == num)
- {
- /* Nothing to do. */
- return;
- }
-
- newnum = target_trace_find (tfind_number, num, 0, 0, NULL);
-
- if (newnum != num)
- warning (_("could not change traceframe"));
-
- set_traceframe_num (newnum);
-
- /* Changing the traceframe changes our view of registers and of the
- frame chain. */
- registers_changed ();
+ /* Changing the traceframe changes our view of registers and of the
+ frame chain. */
+ registers_changed ();
clear_traceframe_info ();
}
-/* Make the traceframe NUM be the current trace frame, and do nothing
- more. */
-
-void
-set_traceframe_number (int num)
-{
- traceframe_number = num;
-}
-
/* A cleanup used when switching away and back from tfind mode. */
struct current_traceframe_cleanup
restore_current_traceframe_cleanup_dtor);
}
-struct cleanup *
-make_cleanup_restore_traceframe_number (void)
-{
- return make_cleanup_restore_integer (&traceframe_number);
-}
-
/* Given a number and address, return an uploaded tracepoint with that
number, creating if necessary. */
return utp;
}
-static void
+void
free_uploaded_tps (struct uploaded_tp **utpp)
{
struct uploaded_tp *next_one;
return utsv;
}
-static void
+void
free_uploaded_tsvs (struct uploaded_tsv **utsvp)
{
struct uploaded_tsv *next_one;
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 */
-
-static struct target_ops tfile_ops;
-
-/* Fill in tfile_ops with its defined operations and properties. */
-
-#define TRACE_HEADER_SIZE 8
-
-static char *trace_filename;
-static int trace_fd = -1;
-static off_t trace_frames_offset;
-static off_t cur_offset;
-static int cur_data_size;
-int trace_regblock_size;
-
-static void tfile_interp_line (char *line,
- struct uploaded_tp **utpp,
- struct uploaded_tsv **utsvp);
-
-/* Read SIZE bytes into READBUF from the trace frame, starting at
- TRACE_FD's current position. Note that this call `read'
- underneath, hence it advances the file's seek position. Throws an
- error if the `read' syscall fails, or less than SIZE bytes are
- read. */
-
-static void
-tfile_read (gdb_byte *readbuf, int size)
-{
- int gotten;
-
- gotten = read (trace_fd, readbuf, size);
- if (gotten < 0)
- perror_with_name (trace_filename);
- else if (gotten < size)
- error (_("Premature end of file while reading trace file"));
-}
-
-static void
-tfile_open (char *filename, int from_tty)
-{
- volatile struct gdb_exception ex;
- 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. */
- gdb_byte 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 = gdb_open_cloexec (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);
-
- trace_filename = xstrdup (filename);
- trace_fd = scratch_chan;
-
- bytes = 0;
- /* Read the file header and test for validity. */
- tfile_read ((gdb_byte *) &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."));
-
- push_target (&tfile_ops);
-
- trace_regblock_size = 0;
- ts = current_trace_status ();
- /* We know we're working with a file. Record its name. */
- ts->filename = trace_filename;
- /* 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;
- ts->disconnected_tracing = 0;
- ts->circular_buffer = 0;
-
- TRY_CATCH (ex, RETURN_MASK_ALL)
- {
- /* Read through a section of newline-terminated lines that
- define things like tracepoints. */
- i = 0;
- while (1)
- {
- tfile_read (&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"));
- }
-
- /* 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 (ex.reason < 0)
- {
- /* Pop the partially set up target. */
- pop_target ();
- throw_exception (ex);
- }
-
- if (ts->traceframe_count <= 0)
- warning (_("No traceframes present in this file."));
-
- /* Add the file's tracepoints and variables into the current mix. */
-
- /* Get trace state variables first, they may be checked when parsing
- uploaded commands. */
- merge_uploaded_trace_state_variables (&uploaded_tsvs);
-
- merge_uploaded_tracepoints (&uploaded_tps);
-}
-
-/* Interpret the given line from the definitions part of the trace
- file. */
+ highest = tsv->number;
-static void
-tfile_interp_line (char *line, struct uploaded_tp **utpp,
- struct uploaded_tsv **utsvp)
-{
- char *p = line;
+ ++highest;
+ for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
+ if (tsv->number == 0)
+ tsv->number = highest++;
- 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);
+ free_uploaded_tsvs (uploaded_tsvs);
}
/* Parse the part of trace status syntax that is shared between
utsv->name = xstrdup (buf);
}
-/* Close the trace file and generally clean up. */
-
-static void
-tfile_close (void)
-{
- int pid;
-
- if (trace_fd < 0)
- return;
-
- close (trace_fd);
- trace_fd = -1;
- xfree (trace_filename);
- trace_filename = NULL;
-}
-
-static void
-tfile_files_info (struct target_ops *t)
-{
- printf_filtered ("\t`%s'\n", trace_filename);
-}
-
-/* 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;
-}
-
-static void
-tfile_get_tracepoint_status (struct breakpoint *tp, struct uploaded_tp *utp)
-{
- /* Other bits of trace status were collected as part of opening the
- trace files, so nothing to do here. */
-}
-
-/* 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 CORE_ADDR
-tfile_get_traceframe_address (off_t tframe_offset)
-{
- CORE_ADDR addr = 0;
- short tpnum;
- struct tracepoint *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);
- tfile_read ((gdb_byte *) &tpnum, 2);
- tpnum = (short) extract_signed_integer ((gdb_byte *) &tpnum, 2,
- gdbarch_byte_order
- (target_gdbarch ()));
-
- tp = get_tracepoint_by_number_on_target (tpnum);
- /* FIXME this is a poor heuristic if multiple locations. */
- if (tp && tp->base.loc)
- addr = tp->base.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,
- CORE_ADDR addr1, CORE_ADDR addr2, int *tpp)
-{
- short tpnum;
- int tfnum = 0, found = 0;
- unsigned int data_size;
- struct tracepoint *tp;
- off_t offset, tframe_offset;
- CORE_ADDR tfaddr;
-
- if (num == -1)
- {
- if (tpp)
- *tpp = -1;
- return -1;
- }
-
- lseek (trace_fd, trace_frames_offset, SEEK_SET);
- offset = trace_frames_offset;
- while (1)
- {
- tframe_offset = offset;
- tfile_read ((gdb_byte *) &tpnum, 2);
- tpnum = (short) extract_signed_integer ((gdb_byte *) &tpnum, 2,
- gdbarch_byte_order
- (target_gdbarch ()));
- offset += 2;
- if (tpnum == 0)
- break;
- tfile_read ((gdb_byte *) &data_size, 4);
- data_size = (unsigned int) extract_unsigned_integer
- ((gdb_byte *) &data_size, 4,
- gdbarch_byte_order (target_gdbarch ()));
- offset += 4;
-
- if (type == tfind_number)
- {
- /* Looking for a specific trace frame. */
- if (tfnum == num)
- found = 1;
- }
- else
- {
- /* Start from the _next_ trace frame. */
- if (tfnum > traceframe_number)
- {
- switch (type)
- {
- 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)
- {
- 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;
-}
-
-/* Prototype of the callback passed to tframe_walk_blocks. */
-typedef int (*walk_blocks_callback_func) (char blocktype, void *data);
-
-/* Callback for traceframe_walk_blocks, used to find a given block
- type in a traceframe. */
-
-static int
-match_blocktype (char blocktype, void *data)
-{
- char *wantedp = data;
-
- if (*wantedp == blocktype)
- return 1;
-
- return 0;
-}
-
-/* Walk over all traceframe block starting at POS offset from
- CUR_OFFSET, and call CALLBACK for each block found, passing in DATA
- unmodified. If CALLBACK returns true, this returns the position in
- the traceframe where the block is found, relative to the start of
- the traceframe (cur_offset). Returns -1 if no callback call
- returned true, indicating that all blocks have been walked. */
-
-static int
-traceframe_walk_blocks (walk_blocks_callback_func callback,
- int pos, void *data)
-{
- /* Iterate through a traceframe's blocks, looking for a block of the
- requested type. */
-
- lseek (trace_fd, cur_offset + pos, SEEK_SET);
- while (pos < cur_data_size)
- {
- unsigned short mlen;
- char block_type;
-
- tfile_read ((gdb_byte *) &block_type, 1);
-
- ++pos;
-
- if ((*callback) (block_type, data))
- return pos;
-
- switch (block_type)
- {
- case 'R':
- lseek (trace_fd, cur_offset + pos + trace_regblock_size, SEEK_SET);
- pos += trace_regblock_size;
- break;
- case 'M':
- lseek (trace_fd, cur_offset + pos + 8, SEEK_SET);
- tfile_read ((gdb_byte *) &mlen, 2);
- mlen = (unsigned short)
- extract_unsigned_integer ((gdb_byte *) &mlen, 2,
- gdbarch_byte_order
- (target_gdbarch ()));
- lseek (trace_fd, mlen, SEEK_CUR);
- pos += (8 + 2 + mlen);
- break;
- case 'V':
- lseek (trace_fd, cur_offset + pos + 4 + 8, SEEK_SET);
- pos += (4 + 8);
- break;
- default:
- error (_("Unknown block type '%c' (0x%x) in trace frame"),
- block_type, block_type);
- break;
- }
- }
-
- return -1;
-}
-
-/* Convenience wrapper around traceframe_walk_blocks. Looks for the
- position offset of a block of type TYPE_WANTED in the current trace
- frame, starting at POS. Returns -1 if no such block was found. */
-
-static int
-traceframe_find_block_type (char type_wanted, int pos)
-{
- return traceframe_walk_blocks (match_blocktype, pos, &type_wanted);
-}
-
-/* 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);
- int offset, regn, regsize, pc_regno;
- gdb_byte *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);
-
- if (traceframe_find_block_type ('R', 0) >= 0)
- {
- tfile_read (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_register_status (regcache, regn) == REG_UNKNOWN)
- {
- 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;
- }
-
- /* 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. */
- pc_regno = gdbarch_pc_regnum (gdbarch);
- if (pc_regno >= 0 && (regno == -1 || regno == pc_regno))
- {
- struct tracepoint *tp = get_tracepoint (tracepoint_number);
-
- if (tp && tp->base.loc)
- {
- /* But don't try to guess if tracepoint is multi-location... */
- if (tp->base.loc->next)
- {
- warning (_("Tracepoint %d has multiple "
- "locations, cannot infer $pc"),
- tp->base.number);
- return;
- }
- /* ... or does while-stepping. */
- if (tp->step_count > 0)
- {
- warning (_("Tracepoint %d does while-stepping, "
- "cannot infer $pc"),
- tp->base.number);
- return;
- }
-
- store_unsigned_integer (regs, register_size (gdbarch, pc_regno),
- gdbarch_byte_order (gdbarch),
- tp->base.loc->address);
- regcache_raw_supply (regcache, pc_regno, regs);
- }
- }
-}
-
-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)
-{
- /* 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"));
-
- if (traceframe_number != -1)
- {
- int pos = 0;
-
- /* Iterate through the traceframe's blocks, looking for
- memory. */
- while ((pos = traceframe_find_block_type ('M', pos)) >= 0)
- {
- ULONGEST maddr, amt;
- unsigned short mlen;
- enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
-
- tfile_read ((gdb_byte *) &maddr, 8);
- maddr = extract_unsigned_integer ((gdb_byte *) &maddr, 8,
- byte_order);
- tfile_read ((gdb_byte *) &mlen, 2);
- mlen = (unsigned short)
- extract_unsigned_integer ((gdb_byte *) &mlen, 2, byte_order);
-
- /* If the block includes the first part of the desired
- range, return as much it has; GDB will re-request the
- remainder, which might be in a different block of this
- trace frame. */
- if (maddr <= offset && offset < (maddr + mlen))
- {
- amt = (maddr + mlen) - offset;
- if (amt > len)
- amt = len;
-
- if (maddr != offset)
- lseek (trace_fd, offset - maddr, SEEK_CUR);
- tfile_read (readbuf, amt);
- return amt;
- }
-
- /* Skip over this block. */
- pos += (8 + 2 + mlen);
- }
- }
-
- /* It's unduly pedantic to refuse to look at the executable for
- read-only pieces; so do the equivalent of readonly regions aka
- QTro packet. */
- /* FIXME account for relocation at some point. */
- if (exec_bfd)
- {
- asection *s;
- bfd_size_type size;
- bfd_vma vma;
-
- for (s = exec_bfd->sections; s; s = s->next)
- {
- if ((s->flags & SEC_LOAD) == 0
- || (s->flags & SEC_READONLY) == 0)
- continue;
-
- vma = s->vma;
- size = bfd_get_section_size (s);
- if (vma <= offset && offset < (vma + size))
- {
- ULONGEST amt;
-
- amt = (vma + size) - offset;
- if (amt > len)
- amt = len;
-
- amt = bfd_get_section_contents (exec_bfd, s,
- readbuf, offset - vma, amt);
- return amt;
- }
- }
- }
-
- /* 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)
-{
- int pos;
- int found = 0;
-
- /* Iterate over blocks in current frame and find the last 'V'
- block in which tsv number is TSVNUM. In one trace frame, there
- may be multiple 'V' blocks created for a given trace variable,
- and the last matched 'V' block contains the updated value. */
- pos = 0;
- while ((pos = traceframe_find_block_type ('V', pos)) >= 0)
- {
- int vnum;
-
- tfile_read ((gdb_byte *) &vnum, 4);
- vnum = (int) extract_signed_integer ((gdb_byte *) &vnum, 4,
- gdbarch_byte_order
- (target_gdbarch ()));
- if (tsvnum == vnum)
- {
- tfile_read ((gdb_byte *) val, 8);
- *val = extract_signed_integer ((gdb_byte *) val, 8,
- gdbarch_byte_order
- (target_gdbarch ()));
- found = 1;
- }
- pos += (4 + 8);
- }
-
- return found;
-}
-
-static int
-tfile_has_all_memory (struct target_ops *ops)
-{
- return 1;
-}
-
-static int
-tfile_has_memory (struct target_ops *ops)
-{
- return 1;
-}
-
-static int
-tfile_has_stack (struct target_ops *ops)
-{
- return traceframe_number != -1;
-}
-
-static int
-tfile_has_registers (struct target_ops *ops)
-{
- return traceframe_number != -1;
-}
-
-/* Callback for traceframe_walk_blocks. Builds a traceframe_info
- object for the tfile target's current traceframe. */
-
-static int
-build_traceframe_info (char blocktype, void *data)
-{
- struct traceframe_info *info = data;
-
- switch (blocktype)
- {
- case 'M':
- {
- struct mem_range *r;
- ULONGEST maddr;
- unsigned short mlen;
-
- tfile_read ((gdb_byte *) &maddr, 8);
- maddr = extract_unsigned_integer ((gdb_byte *) &maddr, 8,
- gdbarch_byte_order
- (target_gdbarch ()));
- tfile_read ((gdb_byte *) &mlen, 2);
- mlen = (unsigned short)
- extract_unsigned_integer ((gdb_byte *) &mlen,
- 2, gdbarch_byte_order
- (target_gdbarch ()));
-
- r = VEC_safe_push (mem_range_s, info->memory, NULL);
-
- r->start = maddr;
- r->length = mlen;
- break;
- }
- case 'V':
- case 'R':
- case 'S':
- {
- break;
- }
- default:
- warning (_("Unhandled trace block type (%d) '%c ' "
- "while building trace frame info."),
- blocktype, blocktype);
- break;
- }
-
- return 0;
-}
-
-static struct traceframe_info *
-tfile_traceframe_info (void)
-{
- struct traceframe_info *info = XCNEW (struct traceframe_info);
-
- traceframe_walk_blocks (build_traceframe_info, 0, info);
- return info;
-}
-
-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_get_tracepoint_status = tfile_get_tracepoint_status;
- tfile_ops.to_trace_find = tfile_trace_find;
- tfile_ops.to_get_trace_state_variable_value
- = tfile_get_trace_state_variable_value;
- tfile_ops.to_stratum = process_stratum;
- tfile_ops.to_has_all_memory = tfile_has_all_memory;
- 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_traceframe_info = tfile_traceframe_info;
- tfile_ops.to_magic = OPS_MAGIC;
-}
-
void
free_current_marker (void *arg)
{
r->length = *length_p;
}
+/* Handle the start of a <tvar> element. */
+
+static void
+traceframe_info_start_tvar (struct gdb_xml_parser *parser,
+ const struct gdb_xml_element *element,
+ void *user_data,
+ VEC(gdb_xml_value_s) *attributes)
+{
+ struct traceframe_info *info = user_data;
+ const char *id_attrib = xml_find_attribute (attributes, "id")->value;
+ int id = gdb_xml_parse_ulongest (parser, id_attrib);
+
+ VEC_safe_push (int, info->tvars, id);
+}
+
/* Discard the constructed trace frame info (if an error occurs). */
static void
{ NULL, GDB_XML_AF_NONE, NULL, NULL }
};
+static const struct gdb_xml_attribute tvar_attributes[] = {
+ { "id", GDB_XML_AF_NONE, NULL, NULL },
+ { NULL, GDB_XML_AF_NONE, NULL, NULL }
+};
+
static const struct gdb_xml_element traceframe_info_children[] = {
{ "memory", memory_attributes, NULL,
GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL,
traceframe_info_start_memory, NULL },
+ { "tvar", tvar_attributes, NULL,
+ GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL,
+ traceframe_info_start_tvar, NULL },
{ NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
};
This is where we avoid re-fetching the object from the target if we
already have it cached. */
-static struct traceframe_info *
+struct traceframe_info *
get_traceframe_info (void)
{
if (traceframe_info == NULL)
traceframe_number = -1;
tracepoint_number = -1;
- if (tracepoint_list.list == NULL)
- {
- tracepoint_list.listsize = 128;
- tracepoint_list.list = xmalloc
- (tracepoint_list.listsize * sizeof (struct memrange));
- }
- if (tracepoint_list.aexpr_list == NULL)
- {
- tracepoint_list.aexpr_listsize = 128;
- tracepoint_list.aexpr_list = xmalloc
- (tracepoint_list.aexpr_listsize * sizeof (struct agent_expr *));
- }
-
- if (stepping_list.list == NULL)
- {
- stepping_list.listsize = 128;
- stepping_list.list = xmalloc
- (stepping_list.listsize * sizeof (struct memrange));
- }
-
- if (stepping_list.aexpr_list == NULL)
- {
- stepping_list.aexpr_listsize = 128;
- stepping_list.aexpr_list = xmalloc
- (stepping_list.aexpr_listsize * sizeof (struct agent_expr *));
- }
-
add_info ("scope", scope_info,
_("List the variables local to a scope"));
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 '-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\
-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\
Show the notes string to use for future tstop commands"), NULL,
set_trace_stop_notes, NULL,
&setlist, &showlist);
-
- init_tfile_ops ();
-
- add_target_with_completer (&tfile_ops, filename_completer);
}
projects / platform / upstream / binutils.git / blobdiff