/* Tracing functionality for remote targets in custom GDB protocol
- Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
- 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
+ Copyright (C) 1997-2012 Free Software Foundation, Inc.
This file is part of GDB.
#include "ax-gdb.h"
#include "memrange.h"
#include "exceptions.h"
+#include "cli/cli-utils.h"
+#include "probe.h"
/* readline include files */
#include "readline/readline.h"
static int circular_trace_buffer;
+/* Textual notes applying to the current and/or future trace runs. */
+
+char *trace_user = NULL;
+
+/* Textual notes applying to the current and/or future trace runs. */
+
+char *trace_notes = NULL;
+
+/* Textual notes applying to the stopping of a trace. */
+
+char *trace_stop_notes = NULL;
+
/* ======= Important command functions: ======= */
static void trace_actions_command (char *, int);
static void trace_start_command (char *, int);
static void add_register (struct collection_list *collection,
unsigned int regno);
-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);
return NULL;
}
-void
+static void
delete_trace_state_variable (const char *name)
{
struct trace_state_variable *tsv;
/* The 'tvariable' command collects a name and optional expression to
evaluate into an initial value. */
-void
+static void
trace_variable_command (char *args, int from_tty)
{
struct expression *expr;
do_cleanups (old_chain);
}
-void
+static void
delete_trace_variable_command (char *args, int from_tty)
{
int ix;
error (_("This command can only be used in a tracepoint actions list."));
}
+/* Parse any collection options, such as /s for strings. */
+
+char *
+decode_agent_options (char *exp)
+{
+ struct value_print_options opts;
+
+ if (*exp != '/')
+ return exp;
+
+ /* Call this to borrow the print elements default for collection
+ size. */
+ get_user_print_options (&opts);
+
+ exp++;
+ if (*exp == 's')
+ {
+ if (target_supports_string_tracing ())
+ {
+ /* Allow an optional decimal number giving an explicit maximum
+ string length, defaulting it to the "print elements" value;
+ so "collect/s80 mystr" gets at most 80 bytes of string. */
+ trace_string_kludge = opts.print_max;
+ exp++;
+ if (*exp >= '0' && *exp <= '9')
+ trace_string_kludge = atoi (exp);
+ while (*exp >= '0' && *exp <= '9')
+ exp++;
+ }
+ else
+ error (_("Target does not support \"/s\" option for string tracing."));
+ }
+ else
+ error (_("Undefined collection format \"%c\"."), *exp);
+
+ exp = skip_spaces (exp);
+
+ return exp;
+}
+
/* Enter a list of actions for a tracepoint. */
static void
trace_actions_command (char *args, int from_tty)
if (cmd_cfunc_eq (c, collect_pseudocommand))
{
+ trace_string_kludge = 0;
+ if (*p == '/')
+ p = decode_agent_options (p);
+
do
{ /* Repeat over a comma-separated list. */
QUIT; /* Allow user to bail out with ^C. */
if (0 == strncasecmp ("reg", p + 1, 3)
|| 0 == strncasecmp ("arg", p + 1, 3)
|| 0 == strncasecmp ("loc", p + 1, 3)
+ || 0 == strncasecmp ("_ret", p + 1, 4)
|| 0 == strncasecmp ("_sdata", p + 1, 6))
{
p = strchr (p, ',');
{
if (SYMBOL_CLASS (exp->elts[2].symbol) == LOC_CONST)
{
- error (_("constant `%s' (value %ld) "
+ error (_("constant `%s' (value %s) "
"will not be collected."),
SYMBOL_PRINT_NAME (exp->elts[2].symbol),
- SYMBOL_VALUE (exp->elts[2].symbol));
+ plongest (SYMBOL_VALUE (exp->elts[2].symbol)));
}
else if (SYMBOL_CLASS (exp->elts[2].symbol)
== LOC_OPTIMIZED_OUT)
SYMBOL_CLASS (sym));
break;
case LOC_CONST:
- printf_filtered ("constant %s (value %ld) will not be collected.\n",
- SYMBOL_PRINT_NAME (sym), SYMBOL_VALUE (sym));
+ printf_filtered ("constant %s (value %s) will not be collected.\n",
+ SYMBOL_PRINT_NAME (sym), plongest (SYMBOL_VALUE (sym)));
break;
case LOC_STATIC:
offset = SYMBOL_VALUE_ADDRESS (sym);
if (cmd_cfunc_eq (cmd, collect_pseudocommand))
{
+ trace_string_kludge = 0;
+ if (*action_exp == '/')
+ action_exp = decode_agent_options (action_exp);
+
do
{ /* Repeat over a comma-separated list. */
QUIT; /* Allow user to bail out with ^C. */
if (0 == strncasecmp ("$reg", action_exp, 4))
{
- for (i = 0; i < gdbarch_num_regs (t->gdbarch); i++)
+ for (i = 0; i < gdbarch_num_regs (tloc->gdbarch); i++)
add_register (collect, i);
action_exp = strchr (action_exp, ','); /* more? */
}
else if (0 == strncasecmp ("$arg", action_exp, 4))
{
add_local_symbols (collect,
- t->gdbarch,
+ tloc->gdbarch,
tloc->address,
frame_reg,
frame_offset,
else if (0 == strncasecmp ("$loc", action_exp, 4))
{
add_local_symbols (collect,
- t->gdbarch,
+ tloc->gdbarch,
tloc->address,
frame_reg,
frame_offset,
'L');
action_exp = strchr (action_exp, ','); /* more? */
}
+ else if (0 == strncasecmp ("$_ret", action_exp, 5))
+ {
+ struct cleanup *old_chain1 = NULL;
+
+ aexpr = gen_trace_for_return_address (tloc->address,
+ tloc->gdbarch);
+
+ old_chain1 = make_cleanup_free_agent_expr (aexpr);
+
+ ax_reqs (aexpr);
+ report_agent_reqs_errors (aexpr);
+
+ discard_cleanups (old_chain1);
+ add_aexpr (collect, aexpr);
+
+ /* take care of the registers */
+ if (aexpr->reg_mask_len > 0)
+ {
+ int ndx1, ndx2;
+
+ for (ndx1 = 0; ndx1 < aexpr->reg_mask_len; ndx1++)
+ {
+ QUIT; /* allow user to bail out with ^C */
+ if (aexpr->reg_mask[ndx1] != 0)
+ {
+ /* assume chars have 8 bits */
+ for (ndx2 = 0; ndx2 < 8; ndx2++)
+ if (aexpr->reg_mask[ndx1] & (1 << ndx2))
+ /* it's used -- record it */
+ add_register (collect,
+ ndx1 * 8 + ndx2);
+ }
+ }
+ }
+
+ action_exp = strchr (action_exp, ','); /* more? */
+ }
else if (0 == strncasecmp ("$_sdata", action_exp, 7))
{
add_static_trace_data (collect);
{
const char *name = &exp->elts[2].string;
- i = user_reg_map_name_to_regnum (t->gdbarch,
+ i = user_reg_map_name_to_regnum (tloc->gdbarch,
name, strlen (name));
if (i == -1)
internal_error (__FILE__, __LINE__,
case OP_VAR_VALUE:
collect_symbol (collect,
exp->elts[2].symbol,
- t->gdbarch,
+ tloc->gdbarch,
frame_reg,
frame_offset,
tloc->address);
}
/* Render all actions into gdb protocol. */
-/*static*/ void
+
+void
encode_actions (struct breakpoint *t, struct bp_location *tloc,
char ***tdp_actions, char ***stepping_actions)
{
*tdp_actions = NULL;
*stepping_actions = NULL;
- gdbarch_virtual_frame_pointer (t->gdbarch,
- t->loc->address, &frame_reg, &frame_offset);
+ gdbarch_virtual_frame_pointer (tloc->gdbarch,
+ tloc->address, &frame_reg, &frame_offset);
actions = breakpoint_commands (t);
collect->next_aexpr_elt++;
}
+static void
+process_tracepoint_on_disconnect (void)
+{
+ VEC(breakpoint_p) *tp_vec = NULL;
+ int ix;
+ struct breakpoint *b;
+ int has_pending_p = 0;
+
+ /* Check whether we still have pending tracepoint. If we have, warn the
+ user that pending tracepoint will no longer work. */
+ tp_vec = all_tracepoints ();
+ for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
+ {
+ if (b->loc == NULL)
+ {
+ has_pending_p = 1;
+ break;
+ }
+ else
+ {
+ struct bp_location *loc1;
+
+ for (loc1 = b->loc; loc1; loc1 = loc1->next)
+ {
+ if (loc1->shlib_disabled)
+ {
+ has_pending_p = 1;
+ break;
+ }
+ }
+
+ if (has_pending_p)
+ break;
+ }
+ }
+ VEC_free (breakpoint_p, tp_vec);
+
+ if (has_pending_p)
+ warning (_("Pending tracepoints will not be resolved while"
+ " GDB is disconnected\n"));
+}
+
void
-start_tracing (void)
+start_tracing (char *notes)
{
VEC(breakpoint_p) *tp_vec = NULL;
int ix;
struct breakpoint *b;
struct trace_state_variable *tsv;
int any_enabled = 0, num_to_download = 0;
-
+ int ret;
+
tp_vec = all_tracepoints ();
/* No point in tracing without any tracepoints... */
for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
{
struct tracepoint *t = (struct tracepoint *) b;
+ struct bp_location *loc;
if (b->enable_state == bp_enabled)
any_enabled = 1;
for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
{
struct tracepoint *t = (struct tracepoint *) b;
+ struct bp_location *loc;
+
+ /* Clear `inserted' flag. */
+ for (loc = b->loc; loc; loc = loc->next)
+ loc->inserted = 0;
if ((b->type == bp_fast_tracepoint
? !may_insert_fast_tracepoints
continue;
t->number_on_target = 0;
- target_download_tracepoint (b);
+
+ for (loc = b->loc; loc; loc = loc->next)
+ {
+ /* Since tracepoint locations are never duplicated, `inserted'
+ flag should be zero. */
+ gdb_assert (!loc->inserted);
+
+ target_download_tracepoint (loc);
+
+ loc->inserted = 1;
+ }
+
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);
}
VEC_free (breakpoint_p, tp_vec);
target_set_disconnected_tracing (disconnected_tracing);
target_set_circular_trace_buffer (circular_trace_buffer);
+ if (!notes)
+ notes = trace_notes;
+ ret = target_set_trace_notes (trace_user, notes, NULL);
+
+ if (!ret && (trace_user || notes))
+ warning ("Target does not support trace user/notes, info ignored");
+
/* Now insert traps and begin collecting data. */
target_trace_start ();
clear_traceframe_info ();
}
-/* tstart command:
-
- Tell target to clear any previous trace experiment.
- Walk the list of tracepoints, and send them (and their actions)
- to the target. If no errors,
- Tell target to start a new trace experiment. */
+/* The tstart command requests the target to start a new trace run.
+ The command passes any arguments it has to the target verbatim, as
+ an optional "trace note". This is useful as for instance a warning
+ to other users if the trace runs disconnected, and you don't want
+ anybody else messing with the target. */
static void
trace_start_command (char *args, int from_tty)
error (_("New trace run not started."));
}
- start_tracing ();
+ start_tracing (args);
}
-/* tstop command */
+/* The tstop command stops the tracing run. The command passes any
+ supplied arguments to the target verbatim as a "stop note"; if the
+ target supports trace notes, then it will be reported back as part
+ of the trace run's status. */
+
static void
trace_stop_command (char *args, int from_tty)
{
if (!current_trace_status ()->running)
error (_("Trace is not running."));
- stop_tracing ();
+ stop_tracing (args);
}
void
-stop_tracing (void)
+stop_tracing (char *note)
{
+ int ret;
+ VEC(breakpoint_p) *tp_vec = NULL;
+ int ix;
+ struct breakpoint *t;
+
target_trace_stop ();
+
+ tp_vec = all_tracepoints ();
+ for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, t); ix++)
+ {
+ struct bp_location *loc;
+
+ if ((t->type == bp_fast_tracepoint
+ ? !may_insert_fast_tracepoints
+ : !may_insert_tracepoints))
+ continue;
+
+ for (loc = t->loc; loc; loc = loc->next)
+ {
+ /* GDB can be totally absent in some disconnected trace scenarios,
+ 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);
+ }
+ }
+
+ VEC_free (breakpoint_p, tp_vec);
+
+ if (!note)
+ note = trace_stop_notes;
+ ret = target_set_trace_notes (NULL, NULL, note);
+
+ if (!ret && note)
+ warning ("Target does not support trace notes, note ignored");
+
/* Should change in response to reply? */
current_trace_status ()->running = 0;
}
trace_status_command (char *args, int from_tty)
{
struct trace_status *ts = current_trace_status ();
- int status;
+ int status, ix;
+ VEC(breakpoint_p) *tp_vec = NULL;
+ struct breakpoint *t;
status = target_get_trace_status (ts);
printf_filtered (_("No trace has been run on the target.\n"));
break;
case tstop_command:
- printf_filtered (_("Trace stopped by a tstop command.\n"));
+ if (ts->stop_desc)
+ printf_filtered (_("Trace stopped by a tstop command (%s).\n"),
+ ts->stop_desc);
+ else
+ printf_filtered (_("Trace stopped by a tstop command.\n"));
break;
case trace_buffer_full:
printf_filtered (_("Trace stopped because the buffer was full.\n"));
if (ts->stopping_tracepoint)
printf_filtered (_("Trace stopped by an "
"error (%s, tracepoint %d).\n"),
- ts->error_desc, ts->stopping_tracepoint);
+ ts->stop_desc, ts->stopping_tracepoint);
else
printf_filtered (_("Trace stopped by an error (%s).\n"),
- ts->error_desc);
+ ts->stop_desc);
break;
case trace_stop_reason_unknown:
printf_filtered (_("Trace stopped for an unknown reason.\n"));
if (ts->circular_buffer)
printf_filtered (_("Trace buffer is circular.\n"));
+ if (ts->user_name && strlen (ts->user_name) > 0)
+ printf_filtered (_("Trace user is %s.\n"), ts->user_name);
+
+ if (ts->notes && strlen (ts->notes) > 0)
+ printf_filtered (_("Trace notes: %s.\n"), ts->notes);
+
/* 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);
else
printf_filtered (_("Not looking at any trace frame.\n"));
+
+ /* Report start/stop times if supplied. */
+ if (ts->start_time)
+ {
+ if (ts->stop_time)
+ {
+ LONGEST run_time = ts->stop_time - ts->start_time;
+
+ /* 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);
+ }
+ else
+ printf_filtered (_("Trace started at %ld.%06ld secs.\n"),
+ (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);
+
+ /* Now report any per-tracepoint status available. */
+ tp_vec = all_tracepoints ();
+
+ for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, t); ix++)
+ target_get_tracepoint_status (t, NULL);
+
+ VEC_free (breakpoint_p, tp_vec);
}
/* Report the trace status to uiout, in a way suitable for MI, and not
stopping_tracepoint);
if (ts->stop_reason == tracepoint_error)
ui_out_field_string (uiout, "error-description",
- ts->error_desc);
+ ts->stop_desc);
}
}
}
ui_out_field_int (uiout, "disconnected", ts->disconnected_tracing);
ui_out_field_int (uiout, "circular", ts->circular_buffer);
+
+ ui_out_field_string (uiout, "user-name", ts->user_name);
+ ui_out_field_string (uiout, "notes", ts->notes);
+
+ {
+ char buf[100];
+
+ xsnprintf (buf, sizeof buf, "%ld.%06ld",
+ (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);
+ ui_out_field_string (uiout, "stop-time", buf);
+ }
}
/* This function handles the details of what to do about an ongoing
disconnected-tracing. */
if (current_trace_status ()->running && from_tty)
{
+ process_tracepoint_on_disconnect ();
+
if (current_trace_status ()->disconnected_tracing)
{
if (!query (_("Trace is running and will "
}
else
{
- sals = decode_line_spec (args, 1);
+ sals = decode_line_spec (args, DECODE_LINE_FUNFIRSTLINE);
sal = sals.sals[0];
}
struct symbol *sym;
struct minimal_symbol *msym;
struct block *block;
- char *symname, *save_args = args;
+ const char *symname;
+ char *save_args = args;
struct dict_iterator iter;
int j, count = 0;
struct gdbarch *gdbarch;
error (_("requires an argument (function, "
"line or *addr) to define a scope"));
- sals = decode_line_1 (&args, 1, NULL, 0, NULL);
+ sals = decode_line_1 (&args, DECODE_LINE_FUNFIRSTLINE, NULL, 0);
if (sals.nelts == 0)
return; /* Presumably decode_line_1 has already warned. */
count--; /* Don't count this one. */
continue;
case LOC_CONST:
- printf_filtered ("a constant with value %ld (0x%lx)",
- SYMBOL_VALUE (sym), SYMBOL_VALUE (sym));
+ printf_filtered ("a constant with value %s (%s)",
+ plongest (SYMBOL_VALUE (sym)),
+ hex_string (SYMBOL_VALUE (sym)));
break;
case LOC_CONST_BYTES:
printf_filtered ("constant bytes: ");
gdbarch_register_name (gdbarch, regno));
break;
case LOC_ARG:
- printf_filtered ("an argument at stack/frame offset %ld",
- SYMBOL_VALUE (sym));
+ printf_filtered ("an argument at stack/frame offset %s",
+ plongest (SYMBOL_VALUE (sym)));
break;
case LOC_LOCAL:
- printf_filtered ("a local variable at frame offset %ld",
- SYMBOL_VALUE (sym));
+ printf_filtered ("a local variable at frame offset %s",
+ plongest (SYMBOL_VALUE (sym)));
break;
case LOC_REF_ARG:
- printf_filtered ("a reference argument at offset %ld",
- SYMBOL_VALUE (sym));
+ printf_filtered ("a reference argument at offset %s",
+ plongest (SYMBOL_VALUE (sym)));
break;
case LOC_REGPARM_ADDR:
/* Note comment at LOC_REGISTER. */
STEPPING_ACTIONS should be equal. */
if (stepping_frame == stepping_actions)
{
+ if (*action_exp == '/')
+ action_exp = decode_agent_options (action_exp);
+
do
{ /* Repeat over a comma-separated list. */
QUIT; /* Allow user to bail out with ^C. */
if (0 == strncasecmp (action_exp, "$reg", 4))
registers_info (NULL, from_tty);
+ else if (0 == strncasecmp (action_exp, "$_ret", 5))
+ ;
else if (0 == strncasecmp (action_exp, "$loc", 4))
locals_info (NULL, from_tty);
else if (0 == strncasecmp (action_exp, "$arg", 4))
(ts->running ? '1' : '0'), stop_reason_names[ts->stop_reason]);
if (ts->stop_reason == tracepoint_error)
{
- char *buf = (char *) alloca (strlen (ts->error_desc) * 2 + 1);
+ char *buf = (char *) alloca (strlen (ts->stop_desc) * 2 + 1);
- bin2hex ((gdb_byte *) ts->error_desc, buf, 0);
+ bin2hex ((gdb_byte *) ts->stop_desc, buf, 0);
fprintf (fp, ":%s", buf);
}
fprintf (fp, ":%x", ts->stopping_tracepoint);
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)
{
fprintf (fp, "tp T%x:%s:%c:%x:%x",
buf, MAX_TRACE_UPLOAD);
fprintf (fp, "tp Z%s\n", buf);
}
+ fprintf (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)));
}
free_uploaded_tps (&uploaded_tps);
trace_save (filename, target_does_save);
if (from_tty)
- printf_filtered (_("Trace data saved to file '%s'.\n"), args);
+ printf_filtered (_("Trace data saved to file '%s'.\n"), filename);
do_cleanups (back_to);
}
/* Tell the target what to do with an ongoing tracing run if GDB
disconnects for some reason. */
-void
-send_disconnected_tracing_value (int value)
-{
- target_set_disconnected_tracing (value);
-}
-
static void
set_disconnected_tracing (char *args, int from_tty,
struct cmd_list_element *c)
{
- send_disconnected_tracing_value (disconnected_tracing);
+ target_set_disconnected_tracing (disconnected_tracing);
}
static void
target_set_circular_trace_buffer (circular_trace_buffer);
}
+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
/* Given a number and address, return an uploaded tracepoint with that
number, creating if necessary. */
-struct uploaded_tsv *
+static struct uploaded_tsv *
get_uploaded_tsv (int num, struct uploaded_tsv **utsvp)
{
struct uploaded_tsv *utsv;
}
}
+/* FIXME this function is heuristic and will miss the cases where the
+ conditional is semantically identical but differs in whitespace,
+ such as "x == 0" vs "x==0". */
+
+static int
+cond_string_is_same (char *str1, char *str2)
+{
+ if (str1 == NULL || str2 == NULL)
+ return (str1 == str2);
+
+ return (strcmp (str1, str2) == 0);
+}
+
/* 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. */
+ next trace run. Return the location of matched tracepoint. */
-struct tracepoint *
-find_matching_tracepoint (struct uploaded_tp *utp)
+static struct bp_location *
+find_matching_tracepoint_location (struct uploaded_tp *utp)
{
VEC(breakpoint_p) *tp_vec = all_tracepoints ();
int ix;
if (b->type == utp->type
&& t->step_count == utp->step
&& t->pass_count == utp->pass
- /* FIXME also test conditionals and actions. */
+ && cond_string_is_same (t->base.cond_string, utp->cond_string)
+ /* FIXME also test actions. */
)
{
/* Scan the locations for an address match. */
for (loc = b->loc; loc; loc = loc->next)
{
if (loc->address == utp->addr)
- return t;
+ return loc;
}
}
}
merge_uploaded_tracepoints (struct uploaded_tp **uploaded_tps)
{
struct uploaded_tp *utp;
- struct tracepoint *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->base.number, utp->number,
- paddress (get_current_arch (), utp->addr));
+ struct bp_location *loc;
+ struct tracepoint *t;
+
+ loc = find_matching_tracepoint_location (utp);
+ if (loc)
+ {
+ /* Mark this location as already inserted. */
+ loc->inserted = 1;
+ t = (struct tracepoint *) loc->owner;
+ printf_filtered (_("Assuming tracepoint %d is same "
+ "as target's tracepoint %d at %s.\n"),
+ loc->owner->number, utp->number,
+ paddress (loc->gdbarch, utp->addr));
+ }
else
{
t = create_tracepoint_from_upload (utp);
/* Trace state variables don't have much to identify them beyond their
name, so just use that to detect matches. */
-struct trace_state_variable *
+static struct trace_state_variable *
find_matching_tsv (struct uploaded_tsv *utsv)
{
if (!utsv->name)
return find_trace_state_variable (utsv->name);
}
-struct trace_state_variable *
+static struct trace_state_variable *
create_tsv_from_upload (struct uploaded_tsv *utsv)
{
const char *namebase;
- char buf[20];
+ char *buf;
int try_num = 0;
struct trace_state_variable *tsv;
+ struct cleanup *old_chain;
if (utsv->name)
{
namebase = utsv->name;
- sprintf (buf, "%s", namebase);
+ buf = xstrprintf ("%s", namebase);
}
else
{
namebase = "__tsv";
- sprintf (buf, "%s_%d", namebase, try_num++);
+ buf = xstrprintf ("%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++);
+ {
+ xfree (buf);
+ buf = xstrprintf ("%s_%d", namebase, try_num++);
+ }
+
+ old_chain = make_cleanup (xfree, buf);
/* We have an available name, create the variable. */
tsv = create_trace_state_variable (buf);
tsv->initial_value = utsv->initial_value;
tsv->builtin = utsv->builtin;
+ do_cleanups (old_chain);
+
return tsv;
}
void
parse_trace_status (char *line, struct trace_status *ts)
{
- char *p = line, *p1, *p2, *p_temp;
+ char *p = line, *p1, *p2, *p3, *p_temp;
+ int end;
ULONGEST val;
ts->running_known = 1;
ts->running = (*p++ == '1');
ts->stop_reason = trace_stop_reason_unknown;
- xfree (ts->error_desc);
- ts->error_desc = NULL;
+ xfree (ts->stop_desc);
+ ts->stop_desc = NULL;
ts->traceframe_count = -1;
ts->traceframes_created = -1;
ts->buffer_free = -1;
ts->buffer_size = -1;
ts->disconnected_tracing = 0;
ts->circular_buffer = 0;
+ xfree (ts->user_name);
+ ts->user_name = NULL;
+ xfree (ts->notes);
+ ts->notes = NULL;
+ ts->start_time = ts->stop_time = 0;
while (*p++)
{
if (p1 == NULL)
error (_("Malformed trace status, at %s\n\
Status line: '%s'\n"), p, line);
+ p3 = strchr (p, ';');
+ if (p3 == NULL)
+ p3 = p + strlen (p);
if (strncmp (p, stop_reason_names[trace_buffer_full], p1 - p) == 0)
{
p = unpack_varlen_hex (++p1, &val);
}
else if (strncmp (p, stop_reason_names[tstop_command], p1 - p) == 0)
{
- p = unpack_varlen_hex (++p1, &val);
+ p2 = strchr (++p1, ':');
+ if (!p2 || p2 > p3)
+ {
+ /*older style*/
+ p2 = p1;
+ }
+ else if (p2 != p1)
+ {
+ ts->stop_desc = xmalloc (strlen (line));
+ end = hex2bin (p1, ts->stop_desc, (p2 - p1) / 2);
+ ts->stop_desc[end] = '\0';
+ }
+ else
+ ts->stop_desc = xstrdup ("");
+
+ p = unpack_varlen_hex (++p2, &val);
ts->stop_reason = tstop_command;
}
else if (strncmp (p, stop_reason_names[trace_disconnected], p1 - p) == 0)
p2 = strchr (++p1, ':');
if (p2 != p1)
{
- int end;
-
- ts->error_desc = xmalloc ((p2 - p1) / 2 + 1);
- end = hex2bin (p1, ts->error_desc, (p2 - p1) / 2);
- ts->error_desc[end] = '\0';
+ ts->stop_desc = xmalloc ((p2 - p1) / 2 + 1);
+ end = hex2bin (p1, ts->stop_desc, (p2 - p1) / 2);
+ ts->stop_desc[end] = '\0';
}
else
- ts->error_desc = xstrdup ("");
+ ts->stop_desc = xstrdup ("");
p = unpack_varlen_hex (++p2, &val);
ts->stopping_tracepoint = val;
p = unpack_varlen_hex (++p1, &val);
ts->circular_buffer = val;
}
+ else if (strncmp (p, "starttime", p1 - p) == 0)
+ {
+ p = unpack_varlen_hex (++p1, &val);
+ ts->start_time = val;
+ }
+ else if (strncmp (p, "stoptime", p1 - p) == 0)
+ {
+ p = unpack_varlen_hex (++p1, &val);
+ ts->stop_time = val;
+ }
+ else if (strncmp (p, "username", p1 - p) == 0)
+ {
+ ++p1;
+ ts->user_name = xmalloc (strlen (p) / 2);
+ end = hex2bin (p1, ts->user_name, (p3 - p1) / 2);
+ ts->user_name[end] = '\0';
+ p = p3;
+ }
+ else if (strncmp (p, "notes", p1 - p) == 0)
+ {
+ ++p1;
+ ts->notes = xmalloc (strlen (p) / 2);
+ end = hex2bin (p1, ts->notes, (p3 - p1) / 2);
+ ts->notes[end] = '\0';
+ p = p3;
+ }
else
{
/* Silently skip unknown optional info. */
}
}
+void
+parse_tracepoint_status (char *p, struct breakpoint *bp,
+ struct uploaded_tp *utp)
+{
+ ULONGEST uval;
+ struct tracepoint *tp = (struct tracepoint *) bp;
+
+ p = unpack_varlen_hex (p, &uval);
+ if (tp)
+ tp->base.hit_count += uval;
+ else
+ utp->hit_count += uval;
+ p = unpack_varlen_hex (p + 1, &uval);
+ if (tp)
+ tp->traceframe_usage += uval;
+ else
+ utp->traceframe_usage += uval;
+ /* Ignore any extra, allowing for future extensions. */
+}
+
/* Given a line of text defining a part of a tracepoint, parse it into
an "uploaded tracepoint". */
else if (strncmp (srctype, "cmd:", strlen ("cmd:")) == 0)
VEC_safe_push (char_ptr, utp->cmd_strings, xstrdup (buf));
}
+ else if (piece == 'V')
+ {
+ utp = get_uploaded_tp (num, addr, utpp);
+
+ parse_tracepoint_status (p, NULL, utp);
+ }
else
{
/* Don't error out, the target might be sending us optional
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
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_magic = OPS_MAGIC;
}
+void
+free_current_marker (void *arg)
+{
+ struct static_tracepoint_marker **marker_p = arg;
+
+ if (*marker_p != NULL)
+ {
+ release_static_tracepoint_marker (*marker_p);
+ xfree (*marker_p);
+ }
+ else
+ *marker_p = NULL;
+}
+
/* Given a line of text defining a static tracepoint marker, parse it
into a "static tracepoint marker" object. Throws an error is
parsing fails. If PP is non-null, it points to one past the end of
char wrap_indent[80];
char extra_field_indent[80];
struct ui_out *uiout = current_uiout;
- struct ui_stream *stb = ui_out_stream_new (uiout);
- struct cleanup *old_chain = make_cleanup_ui_out_stream_delete (stb);
struct cleanup *bkpt_chain;
VEC(breakpoint_p) *tracepoints;
VEC_free (breakpoint_p, tracepoints);
do_cleanups (bkpt_chain);
- do_cleanups (old_chain);
}
static void
struct ui_out *uiout = current_uiout;
int i;
+ /* We don't have to check target_can_use_agent and agent's capability on
+ static tracepoint here, in order to be compatible with older GDBserver.
+ We don't check USE_AGENT is true or not, because static tracepoints
+ don't work without in-process agent, so we don't bother users to type
+ `set agent on' when to use static tracepoint. */
+
old_chain
= make_cleanup_ui_out_table_begin_end (uiout, 5, -1,
"StaticTracepointMarkersTable");
available. */
static struct value *
-sdata_make_value (struct gdbarch *gdbarch, struct internalvar *var)
+sdata_make_value (struct gdbarch *gdbarch, struct internalvar *var,
+ void *ignore)
{
LONGEST size;
gdb_byte *buf;
This is where we avoid re-fetching the object from the target if we
already have it cached. */
-struct traceframe_info *
+static struct traceframe_info *
get_traceframe_info (void)
{
if (traceframe_info == NULL)
return 0;
}
+/* Implementation of `sdata' variable. */
+
+static const struct internalvar_funcs sdata_funcs =
+{
+ sdata_make_value,
+ NULL,
+ NULL
+};
+
/* module initialization */
void
_initialize_tracepoint (void)
value with a void typed value, and when we get here, gdbarch
isn't initialized yet. At this point, we're quite sure there
isn't another convenience variable of the same name. */
- create_internalvar_type_lazy ("_sdata", sdata_make_value);
+ create_internalvar_type_lazy ("_sdata", &sdata_funcs, NULL);
traceframe_number = -1;
tracepoint_number = -1;
add_com ("tstatus", class_trace, trace_status_command,
_("Display the status of the current trace data collection."));
- add_com ("tstop", class_trace, trace_stop_command,
- _("Stop trace data collection."));
+ add_com ("tstop", class_trace, trace_stop_command, _("\
+Stop trace data collection.\n\
+Usage: tstop [ <notes> ... ]\n\
+Any arguments supplied are recorded with the trace as a stop reason and\n\
+reported by tstatus (if the target supports trace notes)."));
- add_com ("tstart", class_trace, trace_start_command,
- _("Start trace data collection."));
+ add_com ("tstart", class_trace, trace_start_command, _("\
+Start trace data collection.\n\
+Usage: tstart [ <notes> ... ]\n\
+Any arguments supplied are recorded with the trace as a note and\n\
+reported by tstatus (if the target supports trace notes)."));
add_com ("end", class_trace, end_actions_pseudocommand, _("\
Ends a list of commands or actions.\n\
&setlist,
&showlist);
+ add_setshow_string_cmd ("trace-user", class_trace,
+ &trace_user, _("\
+Set the user name to use for current and future trace runs"), _("\
+Show the user name to use for current and future trace runs"), NULL,
+ set_trace_user, NULL,
+ &setlist, &showlist);
+
+ add_setshow_string_cmd ("trace-notes", class_trace,
+ &trace_notes, _("\
+Set notes string to use for current and future trace runs"), _("\
+Show the notes string to use for current and future trace runs"), NULL,
+ set_trace_notes, NULL,
+ &setlist, &showlist);
+
+ add_setshow_string_cmd ("trace-stop-notes", class_trace,
+ &trace_stop_notes, _("\
+Set notes string to use for future tstop commands"), _("\
+Show the notes string to use for future tstop commands"), NULL,
+ set_trace_stop_notes, NULL,
+ &setlist, &showlist);
+
init_tfile_ops ();
add_target (&tfile_ops);
projects / deliverable / binutils-gdb.git / blobdiff