static void
delete_trace_variable_command (char *args, int from_tty)
{
- int ix;
- char **argv;
- struct cleanup *back_to;
-
if (args == NULL)
{
if (query (_("Delete all trace state variables? ")))
return;
}
- argv = gdb_buildargv (args);
- back_to = make_cleanup_freeargv (argv);
+ gdb_argv argv (args);
- for (ix = 0; argv[ix] != NULL; ix++)
+ for (char *arg : argv)
{
- if (*argv[ix] == '$')
- delete_trace_state_variable (argv[ix] + 1);
+ if (*arg == '$')
+ delete_trace_state_variable (arg + 1);
else
- warning (_("Name \"%s\" not prefixed with '$', ignoring"), argv[ix]);
+ warning (_("Name \"%s\" not prefixed with '$', ignoring"), arg);
}
- do_cleanups (back_to);
-
dont_repeat ();
}
struct trace_state_variable *tsv;
int ix;
int count = 0;
- struct cleanup *back_to;
struct ui_out *uiout = current_uiout;
if (VEC_length (tsv_s, tvariables) == 0 && !uiout->is_mi_like_p ())
tsv->value_known = target_get_trace_state_variable_value (tsv->number,
&(tsv->value));
- back_to = make_cleanup_ui_out_table_begin_end (uiout, 3,
- count, "trace-variables");
+ ui_out_emit_table table_emitter (uiout, 3, count, "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");
for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
{
- struct cleanup *back_to2;
const char *c;
- char *name;
- back_to2 = make_cleanup_ui_out_tuple_begin_end (uiout, "variable");
+ ui_out_emit_tuple tuple_emitter (uiout, "variable");
- name = concat ("$", tsv->name, (char *) NULL);
- make_cleanup (xfree, name);
- uiout->field_string ("name", name);
+ std::string name = std::string ("$") + tsv->name;
+ uiout->field_string ("name", name.c_str ());
uiout->field_string ("initial", plongest (tsv->initial_value));
if (tsv->value_known)
if (c)
uiout->field_string ("current", c);
uiout->text ("\n");
-
- do_cleanups (back_to2);
}
-
- do_cleanups (back_to);
}
/* List all the trace state variables. */
{
std::string tmpbuf =
string_printf ("Enter actions for tracepoint %d, one per line.",
- t->base.number);
+ t->number);
command_line_up l = read_command_lines (&tmpbuf[0], from_tty, 1,
check_tracepoint_command, t);
- breakpoint_set_commands (&t->base, std::move (l));
+ breakpoint_set_commands (t, std::move (l));
}
/* else just return */
}
/* else fall thru, treat p as an expression and parse it! */
}
tmp_p = p;
- for (loc = t->base.loc; loc; loc = loc->next)
+ for (loc = t->loc; loc; loc = loc->next)
{
p = tmp_p;
expression_up exp = parse_exp_1 (&p, loc->address,
p = skip_spaces_const (p);
tmp_p = p;
- for (loc = t->base.loc; loc; loc = loc->next)
+ for (loc = t->loc; loc; loc = loc->next)
{
p = tmp_p;
reinit_frame_cache ();
target_dcache_invalidate ();
- set_tracepoint_num (tp ? tp->base.number : target_tracept);
+ set_tracepoint_num (tp ? tp->number : target_tracept);
if (target_frameno != get_traceframe_number ())
observer_notify_traceframe_changed (target_frameno, tracepoint_number);
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)
+ for (tloc = t->loc; tloc; tloc = tloc->next)
if (tloc->address == regcache_read_pc (regcache))
{
*stepping_frame_p = 0;
/* 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 t->loc;
}
/* Return all the actions, including default collect, of a tracepoint
{
int stepping_frame = 0;
struct bp_location *loc;
- struct cleanup *old_chain;
struct command_line *actions;
/* This throws an error is not inspecting a trace frame. */
/* This command only makes sense for the current frame, not the
selected frame. */
- old_chain = make_cleanup_restore_current_thread ();
+ scoped_restore_current_thread restore_thread;
+
select_frame (get_current_frame ());
actions = all_tracepoint_actions_and_cleanup (loc->owner);
trace_dump_actions (actions, 0, stepping_frame, from_tty);
-
- do_cleanups (old_chain);
}
/* Encode a piece of a tracepoint's source-level definition in a form
if (b->type == utp->type
&& t->step_count == utp->step
&& t->pass_count == utp->pass
- && cond_string_is_same (t->base.cond_string, utp->cond_string)
+ && cond_string_is_same (t->cond_string, utp->cond_string)
/* FIXME also test actions. */
)
{
if (t)
printf_filtered (_("Created tracepoint %d for "
"target's tracepoint %d at %s.\n"),
- t->base.number, utp->number,
+ t->number, utp->number,
paddress (get_current_arch (), utp->addr));
else
printf_filtered (_("Failed to create tracepoint for target's "
p = unpack_varlen_hex (p, &uval);
if (tp)
- tp->base.hit_count += uval;
+ tp->hit_count += uval;
else
utp->hit_count += uval;
p = unpack_varlen_hex (p + 1, &uval);
char wrap_indent[80];
char extra_field_indent[80];
struct ui_out *uiout = current_uiout;
- struct cleanup *bkpt_chain;
VEC(breakpoint_p) *tracepoints;
struct symtab_and_line sal;
tracepoints = static_tracepoints_here (marker->address);
- bkpt_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "marker");
+ ui_out_emit_tuple tuple_emitter (uiout, "marker");
/* A counter field to help readability. This is not a stable
identifier! */
if (!VEC_empty (breakpoint_p, tracepoints))
{
- struct cleanup *cleanup_chain;
int ix;
struct breakpoint *b;
- cleanup_chain = make_cleanup_ui_out_tuple_begin_end (uiout,
- "tracepoints-at");
-
- uiout->text (extra_field_indent);
- uiout->text (_("Probed by static tracepoints: "));
- for (ix = 0; VEC_iterate(breakpoint_p, tracepoints, ix, b); ix++)
- {
- if (ix > 0)
- uiout->text (", ");
- uiout->text ("#");
- uiout->field_int ("tracepoint-id", b->number);
- }
+ {
+ ui_out_emit_tuple tuple_emitter (uiout, "tracepoints-at");
- do_cleanups (cleanup_chain);
+ uiout->text (extra_field_indent);
+ uiout->text (_("Probed by static tracepoints: "));
+ for (ix = 0; VEC_iterate(breakpoint_p, tracepoints, ix, b); ix++)
+ {
+ if (ix > 0)
+ uiout->text (", ");
+ uiout->text ("#");
+ uiout->field_int ("tracepoint-id", b->number);
+ }
+ }
if (uiout->is_mi_like_p ())
uiout->field_int ("number-of-tracepoints",
uiout->text ("\n");
}
VEC_free (breakpoint_p, tracepoints);
-
- do_cleanups (bkpt_chain);
}
static void
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");
+ ui_out_emit_table table_emitter (uiout, 5, -1,
+ "StaticTracepointMarkersTable");
uiout->table_header (7, ui_left, "counter", "Cnt");
uiout->table_body ();
markers = target_static_tracepoint_markers_by_strid (NULL);
- make_cleanup (VEC_cleanup (static_tracepoint_marker_p), &markers);
+ old_chain = make_cleanup (VEC_cleanup (static_tracepoint_marker_p), &markers);
for (i = 0;
VEC_iterate (static_tracepoint_marker_p,