/* Tracing functionality for remote targets in custom GDB protocol
- Copyright (C) 1997-2020 Free Software Foundation, Inc.
+ Copyright (C) 1997-2022 Free Software Foundation, Inc.
This file is part of GDB.
#include "location.h"
#include <algorithm>
#include "cli/cli-style.h"
+#include "expop.h"
+#include "gdbsupport/buildargv.h"
#include <unistd.h>
large. (400 - 31)/2 == 184 */
#define MAX_AGENT_EXPR_LEN 184
-/* A hook used to notify the UI of tracepoint operations. */
-
-void (*deprecated_trace_find_hook) (char *arg, int from_tty);
-void (*deprecated_trace_start_stop_hook) (int start, int from_tty);
-
/*
Tracepoint.c:
static struct cmd_list_element *tfindlist;
/* List of expressions to collect by default at each tracepoint hit. */
-char *default_collect;
+std::string default_collect;
static bool disconnected_tracing;
/* Textual notes applying to the current and/or future trace runs. */
-char *trace_user = NULL;
+static std::string trace_user;
/* Textual notes applying to the current and/or future trace runs. */
-char *trace_notes = NULL;
+static std::string trace_notes;
/* Textual notes applying to the stopping of a trace. */
-char *trace_stop_notes = NULL;
+static std::string trace_stop_notes;
/* support routines */
tsv->initial_value = initval;
gdb::observers::tsv_modified.notify (tsv);
}
- printf_filtered (_("Trace state variable $%s "
- "now has initial value %s.\n"),
- tsv->name.c_str (), plongest (tsv->initial_value));
+ gdb_printf (_("Trace state variable $%s "
+ "now has initial value %s.\n"),
+ tsv->name.c_str (), plongest (tsv->initial_value));
return;
}
gdb::observers::tsv_created.notify (tsv);
- printf_filtered (_("Trace state variable $%s "
- "created, with initial value %s.\n"),
- tsv->name.c_str (), plongest (tsv->initial_value));
+ gdb_printf (_("Trace state variable $%s "
+ "created, with initial value %s.\n"),
+ tsv->name.c_str (), plongest (tsv->initial_value));
}
static void
{
for (const trace_state_variable &tsv : tvariables)
{
- fprintf_unfiltered (fp, "tvariable $%s", tsv.name.c_str ());
+ gdb_printf (fp, "tvariable $%s", tsv.name.c_str ());
if (tsv.initial_value)
- fprintf_unfiltered (fp, " = %s", plongest (tsv.initial_value));
- fprintf_unfiltered (fp, "\n");
+ gdb_printf (fp, " = %s", plongest (tsv.initial_value));
+ gdb_printf (fp, "\n");
}
}
struct cmd_list_element *c;
const char *tmp_p;
const char *p;
- struct bp_location *loc;
struct tracepoint *t = (struct tracepoint *) b;
/* If EOF is typed, *line is NULL. */
if (*p == '#') /* comment line */
return;
- c = lookup_cmd (&p, cmdlist, "", -1, 1);
+ c = lookup_cmd (&p, cmdlist, "", NULL, -1, 1);
if (c == 0)
error (_("`%s' is not a tracepoint action, or is ambiguous."), p);
- if (cmd_cfunc_eq (c, collect_pseudocommand))
+ if (cmd_simple_func_eq (c, collect_pseudocommand))
{
int trace_string = 0;
/* else fall thru, treat p as an expression and parse it! */
}
tmp_p = p;
- for (loc = t->loc; loc; loc = loc->next)
+ for (bp_location *loc : t->locations ())
{
p = tmp_p;
expression_up exp = parse_exp_1 (&p, loc->address,
block_for_pc (loc->address), 1);
- if (exp->elts[0].opcode == OP_VAR_VALUE)
+ if (exp->first_opcode () == OP_VAR_VALUE)
{
- if (SYMBOL_CLASS (exp->elts[2].symbol) == LOC_CONST)
+ symbol *sym;
+ expr::var_value_operation *vvop
+ = (dynamic_cast<expr::var_value_operation *>
+ (exp->op.get ()));
+ sym = vvop->get_symbol ();
+
+ if (sym->aclass () == LOC_CONST)
{
error (_("constant `%s' (value %s) "
"will not be collected."),
- exp->elts[2].symbol->print_name (),
- plongest (SYMBOL_VALUE (exp->elts[2].symbol)));
+ sym->print_name (),
+ plongest (sym->value_longest ()));
}
- else if (SYMBOL_CLASS (exp->elts[2].symbol)
- == LOC_OPTIMIZED_OUT)
+ else if (sym->aclass () == LOC_OPTIMIZED_OUT)
{
error (_("`%s' is optimized away "
"and cannot be collected."),
- exp->elts[2].symbol->print_name ());
+ sym->print_name ());
}
}
while (p && *p++ == ',');
}
- else if (cmd_cfunc_eq (c, teval_pseudocommand))
+ else if (cmd_simple_func_eq (c, teval_pseudocommand))
{
do
{ /* Repeat over a comma-separated list. */
p = skip_spaces (p);
tmp_p = p;
- for (loc = t->loc; loc; loc = loc->next)
+ for (bp_location *loc : t->locations ())
{
p = tmp_p;
while (p && *p++ == ',');
}
- else if (cmd_cfunc_eq (c, while_stepping_pseudocommand))
+ else if (cmd_simple_func_eq (c, while_stepping_pseudocommand))
{
char *endp;
p = endp;
}
- else if (cmd_cfunc_eq (c, end_actions_pseudocommand))
+ else if (cmd_simple_func_eq (c, end_actions_pseudocommand))
;
else
collection_list::add_remote_register (unsigned int regno)
{
if (info_verbose)
- printf_filtered ("collect register %d\n", regno);
+ gdb_printf ("collect register %d\n", regno);
m_regs_mask.at (regno / 8) |= 1 << (regno % 8);
}
unsigned long len, CORE_ADDR scope)
{
if (info_verbose)
- printf_filtered ("(%d,%s,%ld)\n", type, paddress (gdbarch, base), len);
+ gdb_printf ("(%d,%s,%ld)\n", type, paddress (gdbarch, base), len);
/* type: memrange_absolute == memory, other n == basereg */
/* base: addr if memory, offset if reg relative. */
bfd_signed_vma offset;
int treat_as_expr = 0;
- len = TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym)));
- switch (SYMBOL_CLASS (sym))
+ len = TYPE_LENGTH (check_typedef (sym->type ()));
+ switch (sym->aclass ())
{
default:
- printf_filtered ("%s: don't know symbol class %d\n",
- sym->print_name (), SYMBOL_CLASS (sym));
+ gdb_printf ("%s: don't know symbol class %d\n",
+ sym->print_name (), sym->aclass ());
break;
case LOC_CONST:
- printf_filtered ("constant %s (value %s) will not be collected.\n",
- sym->print_name (), plongest (SYMBOL_VALUE (sym)));
+ gdb_printf ("constant %s (value %s) will not be collected.\n",
+ sym->print_name (), plongest (sym->value_longest ()));
break;
case LOC_STATIC:
- offset = SYMBOL_VALUE_ADDRESS (sym);
+ offset = sym->value_address ();
if (info_verbose)
{
- printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
- sym->print_name (), len,
- paddress (gdbarch, offset));
+ gdb_printf ("LOC_STATIC %s: collect %ld bytes at %s.\n",
+ sym->print_name (), len,
+ paddress (gdbarch, offset));
}
/* A struct may be a C++ class with static fields, go to general
expression handling. */
- if (SYMBOL_TYPE (sym)->code () == TYPE_CODE_STRUCT)
+ if (sym->type ()->code () == TYPE_CODE_STRUCT)
treat_as_expr = 1;
else
add_memrange (gdbarch, memrange_absolute, offset, len, scope);
case LOC_REGISTER:
reg = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch);
if (info_verbose)
- printf_filtered ("LOC_REG[parm] %s: ", sym->print_name ());
+ gdb_printf ("LOC_REG[parm] %s: ", sym->print_name ());
add_local_register (gdbarch, reg, scope);
/* Check for doubles stored in two registers. */
/* FIXME: how about larger types stored in 3 or more regs? */
- if (SYMBOL_TYPE (sym)->code () == TYPE_CODE_FLT &&
+ if (sym->type ()->code () == TYPE_CODE_FLT &&
len > register_size (gdbarch, reg))
add_local_register (gdbarch, reg + 1, scope);
break;
case LOC_REF_ARG:
- printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
- printf_filtered (" (will not collect %s)\n", sym->print_name ());
+ gdb_printf ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
+ gdb_printf (" (will not collect %s)\n", sym->print_name ());
break;
case LOC_ARG:
reg = frame_regno;
- offset = frame_offset + SYMBOL_VALUE (sym);
+ offset = frame_offset + sym->value_longest ();
if (info_verbose)
{
- printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset %s"
- " from frame ptr reg %d\n", sym->print_name (), len,
- paddress (gdbarch, offset), reg);
+ gdb_printf ("LOC_LOCAL %s: Collect %ld bytes at offset %s"
+ " from frame ptr reg %d\n", sym->print_name (), len,
+ paddress (gdbarch, offset), reg);
}
add_memrange (gdbarch, reg, offset, len, scope);
break;
case LOC_REGPARM_ADDR:
- reg = SYMBOL_VALUE (sym);
+ reg = sym->value_longest ();
offset = 0;
if (info_verbose)
{
- printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset %s"
- " from reg %d\n", sym->print_name (), len,
- paddress (gdbarch, offset), reg);
+ gdb_printf ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset %s"
+ " from reg %d\n", sym->print_name (), len,
+ paddress (gdbarch, offset), reg);
}
add_memrange (gdbarch, reg, offset, len, scope);
break;
case LOC_LOCAL:
reg = frame_regno;
- offset = frame_offset + SYMBOL_VALUE (sym);
+ offset = frame_offset + sym->value_longest ();
if (info_verbose)
{
- printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset %s"
- " from frame ptr reg %d\n", sym->print_name (), len,
- paddress (gdbarch, offset), reg);
+ gdb_printf ("LOC_LOCAL %s: Collect %ld bytes at offset %s"
+ " from frame ptr reg %d\n", sym->print_name (), len,
+ paddress (gdbarch, offset), reg);
}
add_memrange (gdbarch, reg, offset, len, scope);
break;
break;
case LOC_OPTIMIZED_OUT:
- printf_filtered ("%s has been optimized out of existence.\n",
- sym->print_name ());
+ gdb_printf ("%s has been optimized out of existence.\n",
+ sym->print_name ());
break;
case LOC_COMPUTED:
have a location expression. */
if (!aexpr)
{
- printf_filtered ("%s has been optimized out of existence.\n",
- sym->print_name ());
+ gdb_printf ("%s has been optimized out of existence.\n",
+ sym->print_name ());
return;
}
}
}
-/* Data to be passed around in the calls to the locals and args
- iterators. */
-
-struct add_local_symbols_data
-{
- struct collection_list *collect;
- struct gdbarch *gdbarch;
- CORE_ADDR pc;
- long frame_regno;
- long frame_offset;
- int count;
- int trace_string;
-};
-
-/* The callback for the locals and args iterators. */
-
-static void
-do_collect_symbol (const char *print_name,
- struct symbol *sym,
- void *cb_data)
-{
- struct add_local_symbols_data *p = (struct add_local_symbols_data *) cb_data;
-
- p->collect->collect_symbol (sym, p->gdbarch, p->frame_regno,
- p->frame_offset, p->pc, p->trace_string);
- p->count++;
-
- p->collect->add_wholly_collected (print_name);
-}
-
void
collection_list::add_wholly_collected (const char *print_name)
{
int trace_string)
{
const struct block *block;
- struct add_local_symbols_data cb_data;
+ int count = 0;
- cb_data.collect = this;
- cb_data.gdbarch = gdbarch;
- cb_data.pc = pc;
- cb_data.frame_regno = frame_regno;
- cb_data.frame_offset = frame_offset;
- cb_data.count = 0;
- cb_data.trace_string = trace_string;
+ auto do_collect_symbol = [&] (const char *print_name,
+ struct symbol *sym)
+ {
+ collect_symbol (sym, gdbarch, frame_regno,
+ frame_offset, pc, trace_string);
+ count++;
+ add_wholly_collected (print_name);
+ };
if (type == 'L')
{
return;
}
- iterate_over_block_local_vars (block, do_collect_symbol, &cb_data);
- if (cb_data.count == 0)
+ iterate_over_block_local_vars (block, do_collect_symbol);
+ if (count == 0)
warning (_("No locals found in scope."));
}
else
{
- pc = get_pc_function_start (pc);
- block = block_for_pc (pc);
+ CORE_ADDR fn_pc = get_pc_function_start (pc);
+ block = block_for_pc (fn_pc);
if (block == NULL)
{
warning (_("Can't collect args; no symbol table info available."));
return;
}
- iterate_over_block_arg_vars (block, do_collect_symbol, &cb_data);
- if (cb_data.count == 0)
+ iterate_over_block_arg_vars (block, do_collect_symbol);
+ if (count == 0)
warning (_("No args found in scope."));
}
}
collection_list::add_static_trace_data ()
{
if (info_verbose)
- printf_filtered ("collect static trace data\n");
+ gdb_printf ("collect static trace data\n");
m_strace_data = true;
}
if (m_strace_data)
{
if (info_verbose)
- printf_filtered ("\nCollecting static trace data\n");
+ gdb_printf ("\nCollecting static trace data\n");
end = temp_buf.data ();
*end++ = 'L';
str_list.emplace_back (temp_buf.data (), end - temp_buf.data ());
if (m_regs_mask[i] != 0) /* Prepare to send regs_mask to the stub. */
{
if (info_verbose)
- printf_filtered ("\nCollecting registers (mask): 0x");
+ gdb_printf ("\nCollecting registers (mask): 0x");
/* One char for 'R', one for the null terminator and two per
mask byte. */
{
QUIT; /* Allow user to bail out with ^C. */
if (info_verbose)
- printf_filtered ("%02X", m_regs_mask[i]);
+ gdb_printf ("%02X", m_regs_mask[i]);
end = pack_hex_byte (end, m_regs_mask[i]);
}
str_list.emplace_back (temp_buf.data ());
}
if (info_verbose)
- printf_filtered ("\n");
+ gdb_printf ("\n");
if (!m_memranges.empty () && info_verbose)
- printf_filtered ("Collecting memranges: \n");
+ gdb_printf ("Collecting memranges: \n");
for (i = 0, count = 0, end = temp_buf.data ();
i < m_memranges.size (); i++)
{
QUIT; /* Allow user to bail out with ^C. */
if (info_verbose)
{
- printf_filtered ("(%d, %s, %ld)\n",
- m_memranges[i].type,
- paddress (target_gdbarch (),
- m_memranges[i].start),
- (long) (m_memranges[i].end
- - m_memranges[i].start));
+ gdb_printf ("(%d, %s, %ld)\n",
+ m_memranges[i].type,
+ paddress (target_gdbarch (),
+ m_memranges[i].start),
+ (long) (m_memranges[i].end
+ - m_memranges[i].start));
}
if (count + 27 > MAX_AGENT_EXPR_LEN)
{
}
{
- bfd_signed_vma length
+ bfd_signed_vma length
= m_memranges[i].end - m_memranges[i].start;
- /* The "%X" conversion specifier expects an unsigned argument,
- so passing -1 (memrange_absolute) to it directly gives you
- "FFFFFFFF" (or more, depending on sizeof (unsigned)).
- Special-case it. */
- if (m_memranges[i].type == memrange_absolute)
- sprintf (end, "M-1,%s,%lX", phex_nz (m_memranges[i].start, 0),
+ /* The "%X" conversion specifier expects an unsigned argument,
+ so passing -1 (memrange_absolute) to it directly gives you
+ "FFFFFFFF" (or more, depending on sizeof (unsigned)).
+ Special-case it. */
+ if (m_memranges[i].type == memrange_absolute)
+ sprintf (end, "M-1,%s,%lX", phex_nz (m_memranges[i].start, 0),
(long) length);
- else
- sprintf (end, "M%X,%s,%lX", m_memranges[i].type,
+ else
+ sprintf (end, "M%X,%s,%lX", m_memranges[i].type,
phex_nz (m_memranges[i].start, 0), (long) length);
}
return str_list;
}
-/* Add the printed expression EXP to *LIST. */
+/* Add the expression STR to M_COMPUTED. */
void
-collection_list::append_exp (struct expression *exp)
+collection_list::append_exp (std::string &&str)
{
- string_file tmp_stream;
-
- print_expression (exp, &tmp_stream);
-
- m_computed.push_back (std::move (tmp_stream.string ()));
+ m_computed.push_back (std::move (str));
}
void
action_exp = action->line;
action_exp = skip_spaces (action_exp);
- cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
+ cmd = lookup_cmd (&action_exp, cmdlist, "", NULL, -1, 1);
if (cmd == 0)
error (_("Bad action list item: %s"), action_exp);
- if (cmd_cfunc_eq (cmd, collect_pseudocommand))
+ if (cmd_simple_func_eq (cmd, collect_pseudocommand))
{
int trace_string = 0;
{
unsigned long addr;
+ const char *exp_start = action_exp;
expression_up exp = parse_exp_1 (&action_exp, tloc->address,
block_for_pc (tloc->address),
1);
- switch (exp->elts[0].opcode)
+ switch (exp->first_opcode ())
{
case OP_REGISTER:
{
- const char *name = &exp->elts[2].string;
+ expr::register_operation *regop
+ = (dynamic_cast<expr::register_operation *>
+ (exp->op.get ()));
+ const char *name = regop->get_name ();
i = user_reg_map_name_to_regnum (target_gdbarch (),
name, strlen (name));
_("Register $%s not available"),
name);
if (info_verbose)
- printf_filtered ("OP_REGISTER: ");
+ gdb_printf ("OP_REGISTER: ");
collect->add_local_register (target_gdbarch (),
i, tloc->address);
break;
}
case UNOP_MEMVAL:
- /* Safe because we know it's a simple expression. */
- tempval = evaluate_expression (exp.get ());
- addr = value_address (tempval);
- /* Initialize the TYPE_LENGTH if it is a typedef. */
- check_typedef (exp->elts[1].type);
- collect->add_memrange (target_gdbarch (),
- memrange_absolute, addr,
- TYPE_LENGTH (exp->elts[1].type),
- tloc->address);
- collect->append_exp (exp.get ());
+ {
+ /* Safe because we know it's a simple expression. */
+ tempval = evaluate_expression (exp.get ());
+ addr = value_address (tempval);
+ expr::unop_memval_operation *memop
+ = (dynamic_cast<expr::unop_memval_operation *>
+ (exp->op.get ()));
+ struct type *type = memop->get_type ();
+ /* Initialize the TYPE_LENGTH if it is a typedef. */
+ check_typedef (type);
+ collect->add_memrange (target_gdbarch (),
+ memrange_absolute, addr,
+ TYPE_LENGTH (type),
+ tloc->address);
+ collect->append_exp (std::string (exp_start,
+ action_exp));
+ }
break;
case OP_VAR_VALUE:
{
- struct symbol *sym = exp->elts[2].symbol;
+ expr::var_value_operation *vvo
+ = (dynamic_cast<expr::var_value_operation *>
+ (exp->op.get ()));
+ struct symbol *sym = vvo->get_symbol ();
const char *name = sym->natural_name ();
- collect->collect_symbol (exp->elts[2].symbol,
+ collect->collect_symbol (sym,
target_gdbarch (),
frame_reg,
frame_offset,
collect->add_ax_registers (aexpr.get ());
collect->add_aexpr (std::move (aexpr));
- collect->append_exp (exp.get ());
+ collect->append_exp (std::string (exp_start,
+ action_exp));
break;
} /* switch */
} /* do */
}
while (action_exp && *action_exp++ == ',');
} /* if */
- else if (cmd_cfunc_eq (cmd, teval_pseudocommand))
+ else if (cmd_simple_func_eq (cmd, teval_pseudocommand))
{
do
{ /* Repeat over a comma-separated list. */
}
while (action_exp && *action_exp++ == ',');
} /* if */
- else if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
+ else if (cmd_simple_func_eq (cmd, while_stepping_pseudocommand))
{
/* We check against nested while-stepping when setting
breakpoint action, so no way to run into nested
}
else
{
- struct bp_location *loc1;
-
- for (loc1 = b->loc; loc1; loc1 = loc1->next)
+ for (bp_location *loc1 : b->locations ())
{
if (loc1->shlib_disabled)
{
int any_enabled = 0, num_to_download = 0;
int ret;
- std::vector<breakpoint *> tp_vec = all_tracepoints ();
+ auto tracepoint_range = all_tracepoints ();
/* No point in tracing without any tracepoints... */
- if (tp_vec.empty ())
+ if (tracepoint_range.begin () == tracepoint_range.end ())
error (_("No tracepoints defined, not starting trace"));
- for (breakpoint *b : tp_vec)
+ for (breakpoint *b : tracepoint_range)
{
if (b->enable_state == bp_enabled)
any_enabled = 1;
target_trace_init ();
- for (breakpoint *b : tp_vec)
+ for (breakpoint *b : tracepoint_range)
{
struct tracepoint *t = (struct tracepoint *) b;
- struct bp_location *loc;
int bp_location_downloaded = 0;
/* Clear `inserted' flag. */
- for (loc = b->loc; loc; loc = loc->next)
+ for (bp_location *loc : b->locations ())
loc->inserted = 0;
if ((b->type == bp_fast_tracepoint
t->number_on_target = 0;
- for (loc = b->loc; loc; loc = loc->next)
+ for (bp_location *loc : b->locations ())
{
/* Since tracepoint locations are never duplicated, `inserted'
flag should be zero. */
t->number_on_target = b->number;
- for (loc = b->loc; loc; loc = loc->next)
+ for (bp_location *loc : b->locations ())
if (loc->probe.prob != NULL)
loc->probe.prob->set_semaphore (loc->probe.objfile,
loc->gdbarch);
target_set_trace_buffer_size (trace_buffer_size);
if (!notes)
- notes = trace_notes;
- ret = target_set_trace_notes (trace_user, notes, NULL);
+ notes = trace_notes.c_str ();
+
+ ret = target_set_trace_notes (trace_user.c_str (), notes, NULL);
- if (!ret && (trace_user || notes))
+ if (!ret && (!trace_user.empty () || notes))
warning (_("Target does not support trace user/notes, info ignored"));
/* Now insert traps and begin collecting data. */
for (breakpoint *t : all_tracepoints ())
{
- 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)
+ for (bp_location *loc : t->locations ())
{
/* GDB can be totally absent in some disconnected trace scenarios,
but we don't really care if this semaphore goes out of sync.
}
if (!note)
- note = trace_stop_notes;
+ note = trace_stop_notes.c_str ();
+
ret = target_set_trace_notes (NULL, NULL, note);
if (!ret && note)
if (status == -1)
{
if (ts->filename != NULL)
- printf_filtered (_("Using a trace file.\n"));
+ gdb_printf (_("Using a trace file.\n"));
else
{
- printf_filtered (_("Trace can not be run on this target.\n"));
+ gdb_printf (_("Trace can not be run on this target.\n"));
return;
}
}
if (!ts->running_known)
{
- printf_filtered (_("Run/stop status is unknown.\n"));
+ gdb_printf (_("Run/stop status is unknown.\n"));
}
else if (ts->running)
{
- printf_filtered (_("Trace is running on the target.\n"));
+ gdb_printf (_("Trace is running on the target.\n"));
}
else
{
switch (ts->stop_reason)
{
case trace_never_run:
- printf_filtered (_("No trace has been run on the target.\n"));
+ gdb_printf (_("No trace has been run on the target.\n"));
break;
case trace_stop_command:
if (ts->stop_desc)
- printf_filtered (_("Trace stopped by a tstop command (%s).\n"),
- ts->stop_desc);
+ gdb_printf (_("Trace stopped by a tstop command (%s).\n"),
+ ts->stop_desc);
else
- printf_filtered (_("Trace stopped by a tstop command.\n"));
+ gdb_printf (_("Trace stopped by a tstop command.\n"));
break;
case trace_buffer_full:
- printf_filtered (_("Trace stopped because the buffer was full.\n"));
+ gdb_printf (_("Trace stopped because the buffer was full.\n"));
break;
case trace_disconnected:
- printf_filtered (_("Trace stopped because of disconnection.\n"));
+ gdb_printf (_("Trace stopped because of disconnection.\n"));
break;
case tracepoint_passcount:
- printf_filtered (_("Trace stopped by tracepoint %d.\n"),
- ts->stopping_tracepoint);
+ gdb_printf (_("Trace stopped by tracepoint %d.\n"),
+ ts->stopping_tracepoint);
break;
case tracepoint_error:
if (ts->stopping_tracepoint)
- printf_filtered (_("Trace stopped by an "
- "error (%s, tracepoint %d).\n"),
- ts->stop_desc, ts->stopping_tracepoint);
+ gdb_printf (_("Trace stopped by an "
+ "error (%s, tracepoint %d).\n"),
+ ts->stop_desc, ts->stopping_tracepoint);
else
- printf_filtered (_("Trace stopped by an error (%s).\n"),
- ts->stop_desc);
+ gdb_printf (_("Trace stopped by an error (%s).\n"),
+ ts->stop_desc);
break;
case trace_stop_reason_unknown:
- printf_filtered (_("Trace stopped for an unknown reason.\n"));
+ gdb_printf (_("Trace stopped for an unknown reason.\n"));
break;
default:
- printf_filtered (_("Trace stopped for some other reason (%d).\n"),
- ts->stop_reason);
+ gdb_printf (_("Trace stopped for some other reason (%d).\n"),
+ ts->stop_reason);
break;
}
}
if (ts->traceframes_created >= 0
&& ts->traceframe_count != ts->traceframes_created)
{
- printf_filtered (_("Buffer contains %d trace "
- "frames (of %d created total).\n"),
- ts->traceframe_count, ts->traceframes_created);
+ gdb_printf (_("Buffer contains %d trace "
+ "frames (of %d created total).\n"),
+ ts->traceframe_count, ts->traceframes_created);
}
else if (ts->traceframe_count >= 0)
{
- printf_filtered (_("Collected %d trace frames.\n"),
- ts->traceframe_count);
+ gdb_printf (_("Collected %d trace frames.\n"),
+ ts->traceframe_count);
}
if (ts->buffer_free >= 0)
{
if (ts->buffer_size >= 0)
{
- printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
- ts->buffer_free, ts->buffer_size);
+ gdb_printf (_("Trace buffer has %d bytes of %d bytes free"),
+ ts->buffer_free, ts->buffer_size);
if (ts->buffer_size > 0)
- printf_filtered (_(" (%d%% full)"),
- ((int) ((((long long) (ts->buffer_size
- - ts->buffer_free)) * 100)
- / ts->buffer_size)));
- printf_filtered (_(".\n"));
+ gdb_printf (_(" (%d%% full)"),
+ ((int) ((((long long) (ts->buffer_size
+ - ts->buffer_free)) * 100)
+ / ts->buffer_size)));
+ gdb_printf (_(".\n"));
}
else
- printf_filtered (_("Trace buffer has %d bytes free.\n"),
- ts->buffer_free);
+ gdb_printf (_("Trace buffer has %d bytes free.\n"),
+ ts->buffer_free);
}
if (ts->disconnected_tracing)
- printf_filtered (_("Trace will continue if GDB disconnects.\n"));
+ gdb_printf (_("Trace will continue if GDB disconnects.\n"));
else
- printf_filtered (_("Trace will stop if GDB disconnects.\n"));
+ gdb_printf (_("Trace will stop if GDB disconnects.\n"));
if (ts->circular_buffer)
- printf_filtered (_("Trace buffer is circular.\n"));
+ gdb_printf (_("Trace buffer is circular.\n"));
if (ts->user_name && strlen (ts->user_name) > 0)
- printf_filtered (_("Trace user is %s.\n"), ts->user_name);
+ gdb_printf (_("Trace user is %s.\n"), ts->user_name);
if (ts->notes && strlen (ts->notes) > 0)
- printf_filtered (_("Trace notes: %s.\n"), ts->notes);
+ gdb_printf (_("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);
+ gdb_printf (_("Looking at trace frame %d, tracepoint %d.\n"),
+ traceframe_number, tracepoint_number);
else
- printf_filtered (_("Not looking at any trace frame.\n"));
+ gdb_printf (_("Not looking at any trace frame.\n"));
/* Report start/stop times if supplied. */
if (ts->start_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));
+ gdb_printf (_("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));
+ gdb_printf (_("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));
+ gdb_printf (_("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. */
for (breakpoint *t : all_tracepoints ())
else
{
if (info_verbose)
- printf_filtered ("End of trace buffer.\n");
+ gdb_printf ("End of trace buffer.\n");
#if 0 /* dubious now? */
/* The following will not recurse, since it's
special-cased. */
}
else
{
- printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
- traceframe_number, tracepoint_number);
+ gdb_printf (_("Found trace frame %d, tracepoint %d\n"),
+ traceframe_number, tracepoint_number);
}
}
else
if (uiout->is_mi_like_p ())
uiout->field_string ("found", "0");
else if (type == tfind_number && num == -1)
- printf_unfiltered (_("No longer looking at any trace frame\n"));
+ gdb_printf (_("No longer looking at any trace frame\n"));
else /* This case may never occur, check. */
- printf_unfiltered (_("No trace frame found\n"));
+ gdb_printf (_("No trace frame found\n"));
}
/* If we're in nonstop mode and getting out of looking at trace
enum print_what print_what;
/* NOTE: in imitation of the step command, try to determine
- whether we have made a transition from one function to
- another. If so, we'll print the "stack frame" (ie. the new
- function and it's arguments) -- otherwise we'll just show the
- new source line. */
+ whether we have made a transition from one function to
+ another. If so, we'll print the "stack frame" (ie. the new
+ function and it's arguments) -- otherwise we'll just show the
+ new source line. */
if (frame_id_eq (old_frame_id,
get_frame_id (get_current_frame ())))
{ /* TFIND with no args means find NEXT trace frame. */
if (traceframe_number == -1)
frameno = 0; /* "next" is first one. */
- else
+ else
frameno = traceframe_number + 1;
}
else if (0 == strcmp (args, "-"))
if (sal.line > 0 && find_line_pc_range (sal, &start_pc, &end_pc))
{
if (start_pc == end_pc)
- {
- printf_filtered ("Line %d of \"%s\"",
- sal.line,
- symtab_to_filename_for_display (sal.symtab));
- wrap_here (" ");
- printf_filtered (" is at address ");
+ {
+ gdb_printf ("Line %d of \"%s\"",
+ sal.line,
+ symtab_to_filename_for_display (sal.symtab));
+ gdb_stdout->wrap_here (2);
+ gdb_printf (" is at address ");
print_address (get_current_arch (), start_pc, gdb_stdout);
- wrap_here (" ");
- printf_filtered (" but contains no code.\n");
+ gdb_stdout->wrap_here (2);
+ gdb_printf (" but contains no code.\n");
sal = find_pc_line (start_pc, 0);
if (sal.line > 0
&& find_line_pc_range (sal, &start_pc, &end_pc)
&& start_pc != end_pc)
- printf_filtered ("Attempting to find line %d instead.\n",
- sal.line);
- else
+ gdb_printf ("Attempting to find line %d instead.\n",
+ sal.line);
+ else
error (_("Cannot find a good line."));
- }
+ }
}
- else
- /* Is there any case in which we get here, and have an address
- which the user would want to see? If we have debugging
- symbols and no line numbers? */
- error (_("Line number %d is out of range for \"%s\"."),
- sal.line, symtab_to_filename_for_display (sal.symtab));
+ else
+ {
+ /* Is there any case in which we get here, and have an address
+ which the user would want to see? If we have debugging
+ symbols and no line numbers? */
+ error (_("Line number %d is out of range for \"%s\"."),
+ sal.line, symtab_to_filename_for_display (sal.symtab));
+ }
/* Find within range of stated line. */
if (args && *args)
if (args == 0 || *args == 0)
{ /* XXX FIXME: what should default behavior be? */
- printf_filtered ("Usage: tfind range STARTADDR, ENDADDR\n");
+ gdb_printf ("Usage: tfind range STARTADDR, ENDADDR\n");
return;
}
if (args == 0 || *args == 0)
{ /* XXX FIXME: what should default behavior be? */
- printf_filtered ("Usage: tfind outside STARTADDR, ENDADDR\n");
+ gdb_printf ("Usage: tfind outside STARTADDR, ENDADDR\n");
return;
}
{
QUIT; /* Allow user to bail out with ^C. */
if (count == 0)
- printf_filtered ("Scope for %s:\n", save_args);
+ gdb_printf ("Scope for %s:\n", save_args);
count++;
symname = sym->print_name ();
if (symname == NULL || *symname == '\0')
continue; /* Probably botched, certainly useless. */
- gdbarch = symbol_arch (sym);
+ gdbarch = sym->arch ();
- printf_filtered ("Symbol %s is ", symname);
+ gdb_printf ("Symbol %s is ", symname);
if (SYMBOL_COMPUTED_OPS (sym) != NULL)
SYMBOL_COMPUTED_OPS (sym)->describe_location (sym,
- BLOCK_ENTRY_PC (block),
+ block->entry_pc (),
gdb_stdout);
else
{
- switch (SYMBOL_CLASS (sym))
+ switch (sym->aclass ())
{
default:
case LOC_UNDEF: /* Messed up symbol? */
- printf_filtered ("a bogus symbol, class %d.\n",
- SYMBOL_CLASS (sym));
+ gdb_printf ("a bogus symbol, class %d.\n",
+ sym->aclass ());
count--; /* Don't count this one. */
continue;
case LOC_CONST:
- printf_filtered ("a constant with value %s (%s)",
- plongest (SYMBOL_VALUE (sym)),
- hex_string (SYMBOL_VALUE (sym)));
+ gdb_printf ("a constant with value %s (%s)",
+ plongest (sym->value_longest ()),
+ hex_string (sym->value_longest ()));
break;
case LOC_CONST_BYTES:
- printf_filtered ("constant bytes: ");
- if (SYMBOL_TYPE (sym))
- for (j = 0; j < TYPE_LENGTH (SYMBOL_TYPE (sym)); j++)
- fprintf_filtered (gdb_stdout, " %02x",
- (unsigned) SYMBOL_VALUE_BYTES (sym)[j]);
+ gdb_printf ("constant bytes: ");
+ if (sym->type ())
+ for (j = 0; j < TYPE_LENGTH (sym->type ()); j++)
+ gdb_printf (" %02x", (unsigned) sym->value_bytes ()[j]);
break;
case LOC_STATIC:
- printf_filtered ("in static storage at address ");
- printf_filtered ("%s", paddress (gdbarch,
- SYMBOL_VALUE_ADDRESS (sym)));
+ gdb_printf ("in static storage at address ");
+ gdb_printf ("%s", paddress (gdbarch, sym->value_address ()));
break;
case LOC_REGISTER:
/* GDBARCH is the architecture associated with the objfile
regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym,
gdbarch);
- if (SYMBOL_IS_ARGUMENT (sym))
- printf_filtered ("an argument in register $%s",
- gdbarch_register_name (gdbarch, regno));
+ if (sym->is_argument ())
+ gdb_printf ("an argument in register $%s",
+ gdbarch_register_name (gdbarch, regno));
else
- printf_filtered ("a local variable in register $%s",
- gdbarch_register_name (gdbarch, regno));
+ gdb_printf ("a local variable in register $%s",
+ gdbarch_register_name (gdbarch, regno));
break;
case LOC_ARG:
- printf_filtered ("an argument at stack/frame offset %s",
- plongest (SYMBOL_VALUE (sym)));
+ gdb_printf ("an argument at stack/frame offset %s",
+ plongest (sym->value_longest ()));
break;
case LOC_LOCAL:
- printf_filtered ("a local variable at frame offset %s",
- plongest (SYMBOL_VALUE (sym)));
+ gdb_printf ("a local variable at frame offset %s",
+ plongest (sym->value_longest ()));
break;
case LOC_REF_ARG:
- printf_filtered ("a reference argument at offset %s",
- plongest (SYMBOL_VALUE (sym)));
+ gdb_printf ("a reference argument at offset %s",
+ plongest (sym->value_longest ()));
break;
case LOC_REGPARM_ADDR:
/* Note comment at LOC_REGISTER. */
regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym,
gdbarch);
- printf_filtered ("the address of an argument, in register $%s",
- gdbarch_register_name (gdbarch, regno));
+ gdb_printf ("the address of an argument, in register $%s",
+ gdbarch_register_name (gdbarch, regno));
break;
case LOC_TYPEDEF:
- printf_filtered ("a typedef.\n");
+ gdb_printf ("a typedef.\n");
continue;
case LOC_LABEL:
- printf_filtered ("a label at address ");
- printf_filtered ("%s", paddress (gdbarch,
- SYMBOL_VALUE_ADDRESS (sym)));
+ gdb_printf ("a label at address ");
+ gdb_printf ("%s", paddress (gdbarch, sym->value_address ()));
break;
case LOC_BLOCK:
- printf_filtered ("a function at address ");
- printf_filtered ("%s",
- paddress (gdbarch, BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym))));
+ gdb_printf ("a function at address ");
+ gdb_printf ("%s",
+ paddress (gdbarch,
+ sym->value_block ()->entry_pc ()));
break;
case LOC_UNRESOLVED:
msym = lookup_minimal_symbol (sym->linkage_name (),
NULL, NULL);
if (msym.minsym == NULL)
- printf_filtered ("Unresolved Static");
+ gdb_printf ("Unresolved Static");
else
{
- printf_filtered ("static storage at address ");
- printf_filtered ("%s",
- paddress (gdbarch,
- BMSYMBOL_VALUE_ADDRESS (msym)));
+ gdb_printf ("static storage at address ");
+ gdb_printf ("%s",
+ paddress (gdbarch, msym.value_address ()));
}
break;
case LOC_OPTIMIZED_OUT:
- printf_filtered ("optimized out.\n");
+ gdb_printf ("optimized out.\n");
continue;
case LOC_COMPUTED:
- gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
+ gdb_assert_not_reached ("LOC_COMPUTED variable missing a method");
}
}
- if (SYMBOL_TYPE (sym))
+ if (sym->type ())
{
- struct type *t = check_typedef (SYMBOL_TYPE (sym));
+ struct type *t = check_typedef (sym->type ());
- printf_filtered (", length %s.\n", pulongest (TYPE_LENGTH (t)));
+ gdb_printf (", length %s.\n", pulongest (TYPE_LENGTH (t)));
}
}
- if (BLOCK_FUNCTION (block))
+ if (block->function ())
break;
else
- block = BLOCK_SUPERBLOCK (block);
+ block = block->superblock ();
}
if (count <= 0)
- printf_filtered ("Scope for %s contains no locals or arguments.\n",
- save_args);
+ gdb_printf ("Scope for %s contains no locals or arguments.\n",
+ save_args);
}
/* Helper for trace_dump_command. Dump the action list starting at
action_exp = skip_spaces (action_exp);
/* The collection actions to be done while stepping are
- bracketed by the commands "while-stepping" and "end". */
+ bracketed by the commands "while-stepping" and "end". */
if (*action_exp == '#') /* comment line */
continue;
- cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
+ cmd = lookup_cmd (&action_exp, cmdlist, "", NULL, -1, 1);
if (cmd == 0)
error (_("Bad action list item: %s"), action_exp);
- if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
+ if (cmd_simple_func_eq (cmd, while_stepping_pseudocommand))
{
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))
+ else if (cmd_simple_func_eq (cmd, collect_pseudocommand))
{
/* Display the collected data.
For the trap frame, display only what was collected at
exp = contents.c_str ();
}
- printf_filtered ("%s = ", exp);
+ gdb_printf ("%s = ", exp);
output_command (exp, from_tty);
- printf_filtered ("\n");
+ gdb_printf ("\n");
}
action_exp = next_comma;
}
get_traceframe_location (int *stepping_frame_p)
{
struct tracepoint *t;
- struct bp_location *tloc;
struct regcache *regcache;
if (tracepoint_number == -1)
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->loc; tloc; tloc = tloc->next)
+ for (bp_location *tloc : t->locations ())
if (tloc->address == regcache_read_pc (regcache))
{
*stepping_frame_p = 0;
validation is per-tracepoint (local var "xyz" might be valid for
one tracepoint and not another, etc), we make up the action on
the fly, and don't cache it. */
- if (*default_collect)
+ if (!default_collect.empty ())
{
gdb::unique_xmalloc_ptr<char> default_collect_line
- (xstrprintf ("collect %s", default_collect));
+ = xstrprintf ("collect %s", default_collect.c_str ());
validate_actionline (default_collect_line.get (), t);
actions.reset (new struct command_line (simple_control,
/* 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);
+ gdb_printf ("Data collected at tracepoint %d, trace frame %d:\n",
+ tracepoint_number, traceframe_number);
/* This command only makes sense for the current frame, not the
selected frame. */
{
int ret;
- ret = target_set_trace_notes (trace_user, NULL, NULL);
+ ret = target_set_trace_notes (trace_user.c_str (), NULL, NULL);
if (!ret)
warning (_("Target does not support trace notes, user ignored"));
{
int ret;
- ret = target_set_trace_notes (NULL, trace_notes, NULL);
+ ret = target_set_trace_notes (NULL, trace_notes.c_str (), NULL);
if (!ret)
warning (_("Target does not support trace notes, note ignored"));
{
int ret;
- ret = target_set_trace_notes (NULL, NULL, trace_stop_notes);
+ ret = target_set_trace_notes (NULL, NULL, trace_stop_notes.c_str ());
if (!ret)
warning (_("Target does not support trace notes, stop note ignored"));
if (b->type == utp->type
&& t->step_count == utp->step
&& t->pass_count == utp->pass
- && cond_string_is_same (t->cond_string,
+ && cond_string_is_same (t->cond_string.get (),
utp->cond_string.get ())
/* FIXME also test actions. */
)
/* 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));
+ gdb_printf (_("Assuming tracepoint %d is same "
+ "as target's tracepoint %d at %s.\n"),
+ loc->owner->number, utp->number,
+ paddress (loc->gdbarch, utp->addr));
/* The tracepoint LOC->owner was modified (the location LOC
was marked as inserted in the target). Save it in
{
t = create_tracepoint_from_upload (utp);
if (t)
- printf_filtered (_("Created tracepoint %d for "
- "target's tracepoint %d at %s.\n"),
- t->number, utp->number,
- paddress (get_current_arch (), utp->addr));
+ gdb_printf (_("Created tracepoint %d for "
+ "target's tracepoint %d at %s.\n"),
+ t->number, utp->number,
+ paddress (get_current_arch (), utp->addr));
else
- printf_filtered (_("Failed to create tracepoint for target's "
- "tracepoint %d at %s, skipping it.\n"),
- utp->number,
- paddress (get_current_arch (), utp->addr));
+ gdb_printf (_("Failed to create tracepoint for target's "
+ "tracepoint %d at %s, skipping it.\n"),
+ utp->number,
+ paddress (get_current_arch (), utp->addr));
}
/* Whether found or created, record the number used by the
target, to help with mapping target tracepoints back to their
if (tsv)
{
if (info_verbose)
- printf_filtered (_("Assuming trace state variable $%s "
- "is same as target's variable %d.\n"),
- tsv->name.c_str (), utsv->number);
+ gdb_printf (_("Assuming trace state variable $%s "
+ "is same as target's variable %d.\n"),
+ tsv->name.c_str (), utsv->number);
}
else
{
tsv = create_tsv_from_upload (utsv);
if (info_verbose)
- printf_filtered (_("Created trace state variable "
- "$%s for target's variable %d.\n"),
- tsv->name.c_str (), utsv->number);
+ gdb_printf (_("Created trace state variable "
+ "$%s for target's variable %d.\n"),
+ tsv->name.c_str (), utsv->number);
}
/* Give precedence to numberings that come from the target. */
if (tsv)
{
struct symbol *sym;
- char wrap_indent[80];
- char extra_field_indent[80];
struct ui_out *uiout = current_uiout;
symtab_and_line sal;
identifier! */
uiout->field_signed ("count", count);
- uiout->field_string ("marker-id", marker.str_id.c_str ());
+ uiout->field_string ("marker-id", marker.str_id);
uiout->field_fmt ("enabled", "%c",
!tracepoints.empty () ? 'y' : 'n');
uiout->spaces (2);
- strcpy (wrap_indent, " ");
-
+ int wrap_indent = 35;
if (gdbarch_addr_bit (marker.gdbarch) <= 32)
- strcat (wrap_indent, " ");
+ wrap_indent += 11;
else
- strcat (wrap_indent, " ");
+ wrap_indent += 19;
- strcpy (extra_field_indent, " ");
+ const char *extra_field_indent = " ";
uiout->field_core_addr ("addr", marker.gdbarch, marker.address);
uiout->text ("\n");
uiout->text (extra_field_indent);
uiout->text (_("Data: \""));
- uiout->field_string ("extra-data", marker.extra.c_str ());
+ uiout->field_string ("extra-data", marker.extra);
uiout->text ("\"\n");
if (!tracepoints.empty ())
{
/* We need to read the whole object before we know its size. */
gdb::optional<gdb::byte_vector> buf
- = target_read_alloc (current_top_target (), TARGET_OBJECT_STATIC_TRACE_DATA,
+ = target_read_alloc (current_inferior ()->top_target (),
+ TARGET_OBJECT_STATIC_TRACE_DATA,
NULL);
if (buf)
{
type = init_vector_type (builtin_type (gdbarch)->builtin_true_char,
buf->size ());
v = allocate_value (type);
- memcpy (value_contents_raw (v), buf->data (), buf->size ());
+ memcpy (value_contents_raw (v).data (), buf->data (), buf->size ());
return v;
}
else
static const struct internalvar_funcs sdata_funcs =
{
sdata_make_value,
- NULL,
NULL
};
add_prefix_cmd ("tfind", class_trace, tfind_command, _("\
Select a trace frame.\n\
No argument means forward by one frame; '-' means backward by one frame."),
- &tfindlist, "tfind ", 1, &cmdlist);
+ &tfindlist, 1, &cmdlist);
add_cmd ("outside", class_trace, tfind_outside_command, _("\
Select a trace frame whose PC is outside the given range (exclusive).\n\
Default is the current PC, or the PC of the current trace frame."),
&tfindlist);
- add_cmd ("end", class_trace, tfind_end_command, _("\
-De-select any trace frame and resume 'live' debugging."),
- &tfindlist);
+ cmd_list_element *tfind_end_cmd
+ = add_cmd ("end", class_trace, tfind_end_command, _("\
+De-select any trace frame and resume 'live' debugging."), &tfindlist);
- add_alias_cmd ("none", "end", class_trace, 0, &tfindlist);
+ add_alias_cmd ("none", tfind_end_cmd, class_trace, 0, &tfindlist);
add_cmd ("start", class_trace, tfind_start_command,
_("Select the first trace frame in the trace buffer."),
while single-stepping.\n\n\
Note: this command can only be used in a tracepoint \"actions\" list."));
- add_com_alias ("ws", "while-stepping", class_trace, 0);
- add_com_alias ("stepping", "while-stepping", class_trace, 0);
+ add_com_alias ("ws", while_stepping_cmd_element, class_trace, 0);
+ add_com_alias ("stepping", while_stepping_cmd_element, class_trace, 0);
add_com ("collect", class_trace, collect_pseudocommand, _("\
Specify one or more data items to be collected at a tracepoint.\n\
single-stepping, or enabling/disabling other tracepoints,\n\
depending on target's capabilities."));
- default_collect = xstrdup ("");
add_setshow_string_cmd ("default-collect", class_trace,
&default_collect, _("\
Set the list of expressions to collect by default."), _("\