struct collection_list;
static char *mem2hex (gdb_byte *, char *, int);
-static struct command_line *
- all_tracepoint_actions_and_cleanup (struct breakpoint *t);
+static counted_command_line all_tracepoint_actions (struct breakpoint *);
static struct trace_status trace_status;
{
struct ui_out *uiout = current_uiout;
- if (tvariables.empty () && !uiout->is_mi_like_p ())
- {
- printf_filtered (_("No trace state variables.\n"));
- return;
- }
-
/* Try to acquire values from the target. */
for (trace_state_variable &tsv : tvariables)
tsv.value_known
= target_get_trace_state_variable_value (tsv.number, &tsv.value);
- ui_out_emit_table table_emitter (uiout, 3, tvariables.size (),
- "trace-variables");
- uiout->table_header (15, ui_left, "name", "Name");
- uiout->table_header (11, ui_left, "initial", "Initial");
- uiout->table_header (11, ui_left, "current", "Current");
+ {
+ ui_out_emit_table table_emitter (uiout, 3, tvariables.size (),
+ "trace-variables");
+ uiout->table_header (15, ui_left, "name", "Name");
+ uiout->table_header (11, ui_left, "initial", "Initial");
+ uiout->table_header (11, ui_left, "current", "Current");
- uiout->table_body ();
+ uiout->table_body ();
- for (const trace_state_variable &tsv : tvariables)
- {
- const char *c;
-
- ui_out_emit_tuple tuple_emitter (uiout, "variable");
-
- uiout->field_string ("name", std::string ("$") + tsv.name);
- uiout->field_string ("initial", plongest (tsv.initial_value));
-
- if (tsv.value_known)
- c = plongest (tsv.value);
- else if (uiout->is_mi_like_p ())
- /* For MI, we prefer not to use magic string constants, but rather
- omit the field completely. The difference between unknown and
- undefined does not seem important enough to represent. */
- c = NULL;
- else if (current_trace_status ()->running || traceframe_number >= 0)
- /* The value is/was defined, but we don't have it. */
- c = "<unknown>";
- else
- /* It is not meaningful to ask about the value. */
- c = "<undefined>";
- if (c)
- uiout->field_string ("current", c);
- uiout->text ("\n");
- }
+ for (const trace_state_variable &tsv : tvariables)
+ {
+ const char *c;
+
+ ui_out_emit_tuple tuple_emitter (uiout, "variable");
+
+ uiout->field_string ("name", std::string ("$") + tsv.name);
+ uiout->field_string ("initial", plongest (tsv.initial_value));
+
+ if (tsv.value_known)
+ c = plongest (tsv.value);
+ else if (uiout->is_mi_like_p ())
+ /* For MI, we prefer not to use magic string constants, but rather
+ omit the field completely. The difference between unknown and
+ undefined does not seem important enough to represent. */
+ c = NULL;
+ else if (current_trace_status ()->running || traceframe_number >= 0)
+ /* The value is/was defined, but we don't have it. */
+ c = "<unknown>";
+ else
+ /* It is not meaningful to ask about the value. */
+ c = "<undefined>";
+ if (c)
+ uiout->field_string ("current", c);
+ uiout->text ("\n");
+ }
+ }
+
+ if (tvariables.empty ())
+ uiout->text (_("No trace state variables.\n"));
}
/* List all the trace state variables. */
string_printf ("Enter actions for tracepoint %d, one per line.",
t->number);
- command_line_up l = read_command_lines (&tmpbuf[0], from_tty, 1,
- check_tracepoint_command, t);
+ counted_command_line l = read_command_lines (tmpbuf.c_str (),
+ from_tty, 1,
+ [=] (const char *line)
+ {
+ validate_actionline (line, t);
+ });
breakpoint_set_commands (t, std::move (l));
}
/* else just return */
here. */
gdb_assert (stepping_list);
- encode_actions_1 (action->body_list[0], tloc, frame_reg,
+ encode_actions_1 (action->body_list_0.get (), tloc, frame_reg,
frame_offset, stepping_list, NULL);
}
else
struct collection_list *tracepoint_list,
struct collection_list *stepping_list)
{
- struct command_line *actions;
int frame_reg;
LONGEST frame_offset;
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,
+ counted_command_line actions = all_tracepoint_actions (tloc->owner);
+ encode_actions_1 (actions.get (), tloc, frame_reg, frame_offset,
tracepoint_list, stepping_list);
+ encode_actions_1 (breakpoint_commands (tloc->owner), tloc,
+ frame_reg, frame_offset, tracepoint_list, stepping_list);
tracepoint_list->finish ();
stepping_list->finish ();
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++)
+ for (breakpoint *b : all_tracepoints ())
{
if (b->loc == NULL)
{
break;
}
}
- VEC_free (breakpoint_p, tp_vec);
if (has_pending_p)
warning (_("Pending tracepoints will not be resolved while"
void
start_tracing (const 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 ();
+ std::vector<breakpoint *> tp_vec = all_tracepoints ();
/* No point in tracing without any tracepoints... */
- if (VEC_length (breakpoint_p, tp_vec) == 0)
- {
- VEC_free (breakpoint_p, tp_vec);
- error (_("No tracepoints defined, not starting trace"));
- }
+ if (tp_vec.empty ())
+ error (_("No tracepoints defined, not starting trace"));
- for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
+ for (breakpoint *b : tp_vec)
{
if (b->enable_state == bp_enabled)
any_enabled = 1;
{
/* No point in tracing with only disabled tracepoints that
cannot be re-enabled. */
- VEC_free (breakpoint_p, tp_vec);
error (_("No tracepoints enabled, not starting trace"));
}
}
if (num_to_download <= 0)
- {
- VEC_free (breakpoint_p, tp_vec);
- error (_("No tracepoints that may be downloaded, not starting trace"));
- }
+ error (_("No tracepoints that may be downloaded, not starting trace"));
target_trace_init ();
- for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
+ for (breakpoint *b : tp_vec)
{
struct tracepoint *t = (struct tracepoint *) b;
struct bp_location *loc;
if (bp_location_downloaded)
gdb::observers::breakpoint_modified.notify (b);
}
- VEC_free (breakpoint_p, tp_vec);
/* Send down all the trace state variables too. */
for (const trace_state_variable &tsv : tvariables)
stop_tracing (const 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++)
+ for (breakpoint *t : all_tracepoints ())
{
struct bp_location *loc;
}
}
- VEC_free (breakpoint_p, tp_vec);
-
if (!note)
note = trace_stop_notes;
ret = target_set_trace_notes (NULL, NULL, note);
tstatus_command (const char *args, int from_tty)
{
struct trace_status *ts = current_trace_status ();
- int status, ix;
- VEC(breakpoint_p) *tp_vec = NULL;
- struct breakpoint *t;
+ int status;
status = target_get_trace_status (ts);
(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++)
+ for (breakpoint *t : all_tracepoints ())
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
if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
{
- int i;
-
- for (i = 0; i < action->body_count; ++i)
- trace_dump_actions (action->body_list[i],
- 1, stepping_frame, from_tty);
+ gdb_assert (action->body_list_1 == nullptr);
+ trace_dump_actions (action->body_list_0.get (),
+ 1, stepping_frame, from_tty);
}
else if (cmd_cfunc_eq (cmd, collect_pseudocommand))
{
STEPPING_ACTIONS should be equal. */
if (stepping_frame == stepping_actions)
{
- char *cmd = NULL;
- struct cleanup *old_chain
- = make_cleanup (free_current_contents, &cmd);
int trace_string = 0;
if (*action_exp == '/')
info_args_command (NULL, from_tty);
else
{ /* variable */
+ std::string contents;
+ const char *exp = action_exp;
if (next_comma != NULL)
{
size_t len = next_comma - action_exp;
-
- cmd = (char *) xrealloc (cmd, len + 1);
- memcpy (cmd, action_exp, len);
- cmd[len] = 0;
+ contents = std::string (action_exp, len);
+ exp = contents.c_str ();
}
- else
- {
- size_t len = strlen (action_exp);
- cmd = (char *) xrealloc (cmd, len + 1);
- memcpy (cmd, action_exp, len + 1);
- }
-
- printf_filtered ("%s = ", cmd);
- output_command_const (cmd, from_tty);
+ printf_filtered ("%s = ", exp);
+ output_command (exp, from_tty);
printf_filtered ("\n");
}
action_exp = next_comma;
}
while (action_exp && *action_exp == ',');
-
- do_cleanups (old_chain);
}
}
}
return t->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). */
+/* Return the default collect actions of a tracepoint T. */
-static struct command_line *
-all_tracepoint_actions_and_cleanup (struct breakpoint *t)
+static counted_command_line
+all_tracepoint_actions (struct breakpoint *t)
{
- struct command_line *actions;
-
- actions = breakpoint_commands (t);
+ counted_command_line actions (nullptr, command_lines_deleter ());
/* If there are default expressions to collect, make up a collect
action and prepend to the action list to encode. Note that since
if (*default_collect)
{
struct command_line *default_collect_action;
- char *default_collect_line;
-
- default_collect_line = xstrprintf ("collect %s", default_collect);
- make_cleanup (xfree, default_collect_line);
+ gdb::unique_xmalloc_ptr<char> default_collect_line
+ (xstrprintf ("collect %s", default_collect));
- validate_actionline (default_collect_line, t);
- default_collect_action = XNEW (struct command_line);
- make_cleanup (xfree, default_collect_action);
- default_collect_action->next = actions;
- default_collect_action->line = default_collect_line;
- actions = default_collect_action;
+ validate_actionline (default_collect_line.get (), t);
+ actions.reset (new struct command_line (simple_control,
+ default_collect_line.release ()),
+ command_lines_deleter ());
}
return actions;
{
int stepping_frame = 0;
struct bp_location *loc;
- struct command_line *actions;
/* This throws an error is not inspecting a trace frame. */
loc = get_traceframe_location (&stepping_frame);
select_frame (get_current_frame ());
- actions = all_tracepoint_actions_and_cleanup (loc->owner);
+ counted_command_line actions = all_tracepoint_actions (loc->owner);
- trace_dump_actions (actions, 0, stepping_frame, from_tty);
+ trace_dump_actions (actions.get (), 0, stepping_frame, from_tty);
+ trace_dump_actions (breakpoint_commands (loc->owner), 0, stepping_frame,
+ from_tty);
}
/* Encode a piece of a tracepoint's source-level definition in a form
static struct bp_location *
find_matching_tracepoint_location (struct uploaded_tp *utp)
{
- VEC(breakpoint_p) *tp_vec = all_tracepoints ();
- int ix;
- struct breakpoint *b;
struct bp_location *loc;
- for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
+ for (breakpoint *b : all_tracepoints ())
{
struct tracepoint *t = (struct tracepoint *) b;
{
struct uploaded_tp *utp;
/* A set of tracepoints which are modified. */
- VEC(breakpoint_p) *modified_tp = NULL;
- int ix;
- struct breakpoint *b;
+ std::vector<breakpoint *> modified_tp;
/* Look for GDB tracepoints that match up with our uploaded versions. */
for (utp = *uploaded_tps; utp; utp = utp->next)
MODIFIED_TP if not there yet. The 'breakpoint-modified'
observers will be notified later once for each tracepoint
saved in MODIFIED_TP. */
- for (ix = 0;
- VEC_iterate (breakpoint_p, modified_tp, ix, b);
- ix++)
+ for (breakpoint *b : modified_tp)
if (b == loc->owner)
{
found = 1;
break;
}
if (!found)
- VEC_safe_push (breakpoint_p, modified_tp, loc->owner);
+ modified_tp.push_back (loc->owner);
}
else
{
/* Notify 'breakpoint-modified' observer that at least one of B's
locations was changed. */
- for (ix = 0; VEC_iterate (breakpoint_p, modified_tp, ix, b); ix++)
+ for (breakpoint *b : modified_tp)
gdb::observers::breakpoint_modified.notify (b);
- VEC_free (breakpoint_p, modified_tp);
free_uploaded_tps (uploaded_tps);
}
char wrap_indent[80];
char extra_field_indent[80];
struct ui_out *uiout = current_uiout;
- VEC(breakpoint_p) *tracepoints;
symtab_and_line sal;
sal.pc = marker.address;
- tracepoints = static_tracepoints_here (marker.address);
+ std::vector<breakpoint *> tracepoints
+ = static_tracepoints_here (marker.address);
ui_out_emit_tuple tuple_emitter (uiout, "marker");
uiout->field_string ("marker-id", marker.str_id.c_str ());
uiout->field_fmt ("enabled", "%c",
- !VEC_empty (breakpoint_p, tracepoints) ? 'y' : 'n');
+ !tracepoints.empty () ? 'y' : 'n');
uiout->spaces (2);
strcpy (wrap_indent, " ");
uiout->field_string ("extra-data", marker.extra.c_str ());
uiout->text ("\"\n");
- if (!VEC_empty (breakpoint_p, tracepoints))
+ if (!tracepoints.empty ())
{
int ix;
struct breakpoint *b;
uiout->text (extra_field_indent);
uiout->text (_("Probed by static tracepoints: "));
- for (ix = 0; VEC_iterate(breakpoint_p, tracepoints, ix, b); ix++)
+ for (ix = 0; ix < tracepoints.size (); ix++)
{
if (ix > 0)
uiout->text (", ");
uiout->text ("#");
- uiout->field_int ("tracepoint-id", b->number);
+ uiout->field_int ("tracepoint-id", tracepoints[ix]->number);
}
}
if (uiout->is_mi_like_p ())
- uiout->field_int ("number-of-tracepoints",
- VEC_length(breakpoint_p, tracepoints));
+ uiout->field_int ("number-of-tracepoints", tracepoints.size ());
else
uiout->text ("\n");
}
- VEC_free (breakpoint_p, tracepoints);
}
static void
{
/* We need to read the whole object before we know its size. */
gdb::optional<gdb::byte_vector> buf
- = target_read_alloc (¤t_target, TARGET_OBJECT_STATIC_TRACE_DATA,
+ = target_read_alloc (current_top_target (), TARGET_OBJECT_STATIC_TRACE_DATA,
NULL);
if (buf)
{
add_com ("tstop", class_trace, tstop_command, _("\
Stop trace data collection.\n\
-Usage: tstop [ <notes> ... ]\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, tstart_command, _("\
Start trace data collection.\n\
-Usage: tstart [ <notes> ... ]\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)."));