/* Tracing functionality for remote targets in custom GDB protocol
- Copyright (C) 1997-2018 Free Software Foundation, Inc.
+ Copyright (C) 1997-2021 Free Software Foundation, Inc.
This file is part of GDB.
#include "completer.h"
#include "block.h"
#include "dictionary.h"
-#include "observer.h"
+#include "observable.h"
#include "user-regs.h"
#include "valprint.h"
#include "gdbcore.h"
#include "memrange.h"
#include "cli/cli-utils.h"
#include "probe.h"
-#include "ctf.h"
-#include "filestuff.h"
-#include "rsp-low.h"
+#include "gdbsupport/filestuff.h"
+#include "gdbsupport/rsp-low.h"
#include "tracefile.h"
#include "location.h"
#include <algorithm>
-
-/* readline include files */
-#include "readline/readline.h"
-#include "readline/history.h"
-
-/* readline defines this. */
-#undef savestring
+#include "cli/cli-style.h"
+#include "expop.h"
#include <unistd.h>
any of these for any reason - API is by name or number only - so it
works to have a vector of objects. */
-typedef struct trace_state_variable tsv_s;
-DEF_VEC_O(tsv_s);
-
-static VEC(tsv_s) *tvariables;
+static std::vector<trace_state_variable> tvariables;
/* The next integer to assign to a variable. */
/* List of expressions to collect by default at each tracepoint hit. */
char *default_collect;
-static int disconnected_tracing;
+static bool disconnected_tracing;
/* This variable controls whether we ask the target for a linear or
circular trace buffer. */
-static int circular_trace_buffer;
+static bool circular_trace_buffer;
/* This variable is the requested trace buffer size, or -1 to indicate
that we don't care and leave it up to the target to set a size. */
/* Textual notes applying to the current and/or future trace runs. */
-char *trace_user = NULL;
+static char *trace_user = NULL;
/* Textual notes applying to the current and/or future trace runs. */
-char *trace_notes = NULL;
+static char *trace_notes = NULL;
/* Textual notes applying to the stopping of a trace. */
-char *trace_stop_notes = NULL;
+static char *trace_stop_notes = NULL;
/* support routines */
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;
/* Save func name as "$trace_func", a debugger variable visible to
users. */
if (traceframe_fun == NULL
- || SYMBOL_LINKAGE_NAME (traceframe_fun) == NULL)
+ || traceframe_fun->linkage_name () == NULL)
clear_internalvar (lookup_internalvar ("trace_func"));
else
set_internalvar_string (lookup_internalvar ("trace_func"),
- SYMBOL_LINKAGE_NAME (traceframe_fun));
+ traceframe_fun->linkage_name ());
/* Save file name as "$trace_file", a debugger variable visible to
users. */
struct trace_state_variable *
create_trace_state_variable (const char *name)
{
- struct trace_state_variable tsv;
-
- memset (&tsv, 0, sizeof (tsv));
- tsv.name = xstrdup (name);
- tsv.number = next_tsv_number++;
- return VEC_safe_push (tsv_s, tvariables, &tsv);
+ tvariables.emplace_back (name, next_tsv_number++);
+ return &tvariables.back ();
}
/* Look for a trace state variable of the given name. */
struct trace_state_variable *
find_trace_state_variable (const char *name)
{
- struct trace_state_variable *tsv;
- int ix;
-
- for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
- if (strcmp (name, tsv->name) == 0)
- return tsv;
+ for (trace_state_variable &tsv : tvariables)
+ if (tsv.name == name)
+ return &tsv;
return NULL;
}
struct trace_state_variable *
find_trace_state_variable_by_number (int number)
{
- struct trace_state_variable *tsv;
- int ix;
-
- for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
- if (tsv->number == number)
- return tsv;
+ for (trace_state_variable &tsv : tvariables)
+ if (tsv.number == number)
+ return &tsv;
return NULL;
}
static void
delete_trace_state_variable (const char *name)
{
- struct trace_state_variable *tsv;
- int ix;
-
- for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
- if (strcmp (name, tsv->name) == 0)
+ for (auto it = tvariables.begin (); it != tvariables.end (); it++)
+ if (it->name == name)
{
- observer_notify_tsv_deleted (tsv);
-
- xfree ((void *)tsv->name);
- VEC_unordered_remove (tsv_s, tvariables, ix);
-
+ gdb::observers::tsv_deleted.notify (&*it);
+ tvariables.erase (it);
return;
}
if (tsv->initial_value != initval)
{
tsv->initial_value = initval;
- observer_notify_tsv_modified (tsv);
+ gdb::observers::tsv_modified.notify (tsv);
}
printf_filtered (_("Trace state variable $%s "
"now has initial value %s.\n"),
- tsv->name, plongest (tsv->initial_value));
+ tsv->name.c_str (), plongest (tsv->initial_value));
return;
}
tsv = create_trace_state_variable (name.c_str ());
tsv->initial_value = initval;
- observer_notify_tsv_created (tsv);
+ gdb::observers::tsv_created.notify (tsv);
printf_filtered (_("Trace state variable $%s "
"created, with initial value %s.\n"),
- tsv->name, plongest (tsv->initial_value));
+ tsv->name.c_str (), plongest (tsv->initial_value));
}
static void
if (args == NULL)
{
if (query (_("Delete all trace state variables? ")))
- VEC_free (tsv_s, tvariables);
+ tvariables.clear ();
dont_repeat ();
- observer_notify_tsv_deleted (NULL);
+ gdb::observers::tsv_deleted.notify (NULL);
return;
}
void
tvariables_info_1 (void)
{
- struct trace_state_variable *tsv;
- int ix;
- int count = 0;
struct ui_out *uiout = current_uiout;
- if (VEC_length (tsv_s, tvariables) == 0 && !uiout->is_mi_like_p ())
- {
- printf_filtered (_("No trace state variables.\n"));
- return;
- }
-
/* Try to acquire values from the target. */
- for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix, ++count)
- tsv->value_known = target_get_trace_state_variable_value (tsv->number,
- &(tsv->value));
+ 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, 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");
+ {
+ 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 (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
- {
- const char *c;
-
- ui_out_emit_tuple tuple_emitter (uiout, "variable");
-
- 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)
- 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));
+
+ ui_file_style style;
+ 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>";
+ style = metadata_style.style ();
+ }
+ else
+ {
+ /* It is not meaningful to ask about the value. */
+ c = "<undefined>";
+ style = metadata_style.style ();
+ }
+ if (c)
+ uiout->field_string ("current", c, style);
+ uiout->text ("\n");
+ }
+ }
+
+ if (tvariables.empty ())
+ uiout->text (_("No trace state variables.\n"));
}
/* List all the trace state variables. */
void
save_trace_state_variables (struct ui_file *fp)
{
- struct trace_state_variable *tsv;
- int ix;
-
- for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
+ for (const trace_state_variable &tsv : tvariables)
{
- fprintf_unfiltered (fp, "tvariable $%s", tsv->name);
- if (tsv->initial_value)
- fprintf_unfiltered (fp, " = %s", plongest (tsv->initial_value));
+ fprintf_unfiltered (fp, "tvariable $%s", tsv.name.c_str ());
+ if (tsv.initial_value)
+ fprintf_unfiltered (fp, " = %s", plongest (tsv.initial_value));
fprintf_unfiltered (fp, "\n");
}
}
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 */
error (_("Expression is too complicated."));
}
+/* Call ax_reqs on AEXPR and raise an error if something is wrong. */
+
+static void
+finalize_tracepoint_aexpr (struct agent_expr *aexpr)
+{
+ ax_reqs (aexpr);
+
+ if (aexpr->len > MAX_AGENT_EXPR_LEN)
+ error (_("Expression is too complicated."));
+
+ report_agent_reqs_errors (aexpr);
+}
+
/* worker function */
void
validate_actionline (const char *line, struct breakpoint *b)
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);
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 (SYMBOL_CLASS (sym) == LOC_CONST)
{
error (_("constant `%s' (value %s) "
"will not be collected."),
- SYMBOL_PRINT_NAME (exp->elts[2].symbol),
- plongest (SYMBOL_VALUE (exp->elts[2].symbol)));
+ sym->print_name (),
+ plongest (SYMBOL_VALUE (sym)));
}
- else if (SYMBOL_CLASS (exp->elts[2].symbol)
- == LOC_OPTIMIZED_OUT)
+ else if (SYMBOL_CLASS (sym) == LOC_OPTIMIZED_OUT)
{
error (_("`%s' is optimized away "
"and cannot be collected."),
- SYMBOL_PRINT_NAME (exp->elts[2].symbol));
+ sym->print_name ());
}
}
exp.get (),
trace_string);
- if (aexpr->len > MAX_AGENT_EXPR_LEN)
- error (_("Expression is too complicated."));
-
- ax_reqs (aexpr.get ());
-
- report_agent_reqs_errors (aexpr.get ());
+ finalize_tracepoint_aexpr (aexpr.get ());
}
}
while (p && *p++ == ',');
long. */
agent_expr_up aexpr = gen_eval_for_expr (loc->address, exp.get ());
- if (aexpr->len > MAX_AGENT_EXPR_LEN)
- error (_("Expression is too complicated."));
-
- ax_reqs (aexpr.get ());
- report_agent_reqs_errors (aexpr.get ());
+ finalize_tracepoint_aexpr (aexpr.get ());
}
}
while (p && *p++ == ',');
}
}
-/* Add a register to a collection list. */
+/* Add remote register number REGNO to the collection list mask. */
void
-collection_list::add_register (unsigned int regno)
+collection_list::add_remote_register (unsigned int regno)
{
if (info_verbose)
printf_filtered ("collect register %d\n", regno);
- if (regno >= (8 * sizeof (m_regs_mask)))
- error (_("Internal: register number %d too large for tracepoint"),
- regno);
- m_regs_mask[regno / 8] |= 1 << (regno % 8);
+
+ m_regs_mask.at (regno / 8) |= 1 << (regno % 8);
+}
+
+/* Add all the registers from the mask in AEXPR to the mask in the
+ collection list. Registers in the AEXPR mask are already remote
+ register numbers. */
+
+void
+collection_list::add_ax_registers (struct agent_expr *aexpr)
+{
+ if (aexpr->reg_mask_len > 0)
+ {
+ for (int 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 (int ndx2 = 0; ndx2 < 8; ndx2++)
+ if (aexpr->reg_mask[ndx1] & (1 << ndx2))
+ /* It's used -- record it. */
+ add_remote_register (ndx1 * 8 + ndx2);
+ }
+ }
+ }
+}
+
+/* If REGNO is raw, add its corresponding remote register number to
+ the mask. If REGNO is a pseudo-register, figure out the necessary
+ registers using a temporary agent expression, and add it to the
+ list if it needs more than just a mask. */
+
+void
+collection_list::add_local_register (struct gdbarch *gdbarch,
+ unsigned int regno,
+ CORE_ADDR scope)
+{
+ if (regno < gdbarch_num_regs (gdbarch))
+ {
+ int remote_regno = gdbarch_remote_register_number (gdbarch, regno);
+
+ if (remote_regno < 0)
+ error (_("Can't collect register %d"), regno);
+
+ add_remote_register (remote_regno);
+ }
+ else
+ {
+ agent_expr_up aexpr (new agent_expr (gdbarch, scope));
+
+ ax_reg_mask (aexpr.get (), regno);
+
+ finalize_tracepoint_aexpr (aexpr.get ());
+
+ add_ax_registers (aexpr.get ());
+
+ /* Usually ax_reg_mask for a pseudo-regiser only sets the
+ corresponding raw registers in the ax mask, but if this isn't
+ the case add the expression that is generated to the
+ collection list. */
+ if (aexpr->len > 0)
+ add_aexpr (std::move (aexpr));
+ }
}
/* Add a memrange to a collection list. */
void
collection_list::add_memrange (struct gdbarch *gdbarch,
int type, bfd_signed_vma base,
- unsigned long len)
+ unsigned long len, CORE_ADDR scope)
{
if (info_verbose)
printf_filtered ("(%d,%s,%ld)\n", type, paddress (gdbarch, base), len);
m_memranges.emplace_back (type, base, base + len);
if (type != memrange_absolute) /* Better collect the base register! */
- add_register (type);
+ add_local_register (gdbarch, type, scope);
}
/* Add a symbol to a collection list. */
{
default:
printf_filtered ("%s: don't know symbol class %d\n",
- SYMBOL_PRINT_NAME (sym),
- SYMBOL_CLASS (sym));
+ sym->print_name (), SYMBOL_CLASS (sym));
break;
case LOC_CONST:
printf_filtered ("constant %s (value %s) will not be collected.\n",
- SYMBOL_PRINT_NAME (sym), plongest (SYMBOL_VALUE (sym)));
+ sym->print_name (), plongest (SYMBOL_VALUE (sym)));
break;
case LOC_STATIC:
offset = SYMBOL_VALUE_ADDRESS (sym);
if (info_verbose)
{
printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
- SYMBOL_PRINT_NAME (sym), len,
+ sym->print_name (), len,
paddress (gdbarch, offset));
}
/* A struct may be a C++ class with static fields, go to general
expression handling. */
- if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_STRUCT)
+ if (SYMBOL_TYPE (sym)->code () == TYPE_CODE_STRUCT)
treat_as_expr = 1;
else
- add_memrange (gdbarch, memrange_absolute, offset, len);
+ add_memrange (gdbarch, memrange_absolute, offset, len, scope);
break;
case LOC_REGISTER:
reg = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch);
if (info_verbose)
- printf_filtered ("LOC_REG[parm] %s: ",
- SYMBOL_PRINT_NAME (sym));
- add_register (reg);
+ printf_filtered ("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 (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_FLT &&
+ if (SYMBOL_TYPE (sym)->code () == TYPE_CODE_FLT &&
len > register_size (gdbarch, reg))
- add_register (reg + 1);
+ 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",
- SYMBOL_PRINT_NAME (sym));
+ printf_filtered (" (will not collect %s)\n", sym->print_name ());
break;
case LOC_ARG:
reg = frame_regno;
if (info_verbose)
{
printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset %s"
- " from frame ptr reg %d\n",
- SYMBOL_PRINT_NAME (sym), len,
+ " from frame ptr reg %d\n", sym->print_name (), len,
paddress (gdbarch, offset), reg);
}
- add_memrange (gdbarch, reg, offset, len);
+ add_memrange (gdbarch, reg, offset, len, scope);
break;
case LOC_REGPARM_ADDR:
reg = SYMBOL_VALUE (sym);
if (info_verbose)
{
printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset %s"
- " from reg %d\n",
- SYMBOL_PRINT_NAME (sym), len,
+ " from reg %d\n", sym->print_name (), len,
paddress (gdbarch, offset), reg);
}
- add_memrange (gdbarch, reg, offset, len);
+ add_memrange (gdbarch, reg, offset, len, scope);
break;
case LOC_LOCAL:
reg = frame_regno;
if (info_verbose)
{
printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset %s"
- " from frame ptr reg %d\n",
- SYMBOL_PRINT_NAME (sym), len,
+ " from frame ptr reg %d\n", sym->print_name (), len,
paddress (gdbarch, offset), reg);
}
- add_memrange (gdbarch, reg, offset, len);
+ add_memrange (gdbarch, reg, offset, len, scope);
break;
case LOC_UNRESOLVED:
case LOC_OPTIMIZED_OUT:
printf_filtered ("%s has been optimized out of existence.\n",
- SYMBOL_PRINT_NAME (sym));
+ sym->print_name ());
break;
case LOC_COMPUTED:
if (!aexpr)
{
printf_filtered ("%s has been optimized out of existence.\n",
- SYMBOL_PRINT_NAME (sym));
+ sym->print_name ());
return;
}
- ax_reqs (aexpr.get ());
-
- report_agent_reqs_errors (aexpr.get ());
+ finalize_tracepoint_aexpr (aexpr.get ());
/* Take care of the registers. */
- if (aexpr->reg_mask_len > 0)
- {
- for (int 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 (int ndx2 = 0; ndx2 < 8; ndx2++)
- if (aexpr->reg_mask[ndx1] & (1 << ndx2))
- /* It's used -- record it. */
- add_register (ndx1 * 8 + ndx2);
- }
- }
- }
+ add_ax_registers (aexpr.get ());
add_aexpr (std::move (aexpr));
}
}
collection_list::collection_list ()
- : m_regs_mask (),
- m_strace_data (false)
+ : m_strace_data (false)
{
+ int max_remote_regno = 0;
+ for (int i = 0; i < gdbarch_num_regs (target_gdbarch ()); i++)
+ {
+ int remote_regno = (gdbarch_remote_register_number
+ (target_gdbarch (), i));
+
+ if (remote_regno >= 0 && remote_regno > max_remote_regno)
+ max_remote_regno = remote_regno;
+ }
+
+ m_regs_mask.resize ((max_remote_regno / 8) + 1);
+
m_memranges.reserve (128);
m_aexprs.reserve (128);
}
std::vector<std::string>
collection_list::stringify ()
{
- char temp_buf[2048];
+ gdb::char_vector temp_buf (2048);
+
int count;
char *end;
long i;
{
if (info_verbose)
printf_filtered ("\nCollecting static trace data\n");
- end = temp_buf;
+ end = temp_buf.data ();
*end++ = 'L';
- str_list.emplace_back (temp_buf, end - temp_buf);
+ str_list.emplace_back (temp_buf.data (), end - temp_buf.data ());
}
- for (i = sizeof (m_regs_mask) - 1; i > 0; i--)
+ for (i = m_regs_mask.size () - 1; i > 0; i--)
if (m_regs_mask[i] != 0) /* Skip leading zeroes in regs_mask. */
break;
if (m_regs_mask[i] != 0) /* Prepare to send regs_mask to the stub. */
{
if (info_verbose)
printf_filtered ("\nCollecting registers (mask): 0x");
- end = temp_buf;
+
+ /* One char for 'R', one for the null terminator and two per
+ mask byte. */
+ std::size_t new_size = (i + 1) * 2 + 2;
+ if (new_size > temp_buf.size ())
+ temp_buf.resize (new_size);
+
+ end = temp_buf.data ();
*end++ = 'R';
for (; i >= 0; i--)
{
QUIT; /* Allow user to bail out with ^C. */
if (info_verbose)
printf_filtered ("%02X", m_regs_mask[i]);
- sprintf (end, "%02X", m_regs_mask[i]);
- end += 2;
+
+ end = pack_hex_byte (end, m_regs_mask[i]);
}
- str_list.emplace_back (temp_buf);
+ *end = '\0';
+
+ str_list.emplace_back (temp_buf.data ());
}
if (info_verbose)
printf_filtered ("\n");
if (!m_memranges.empty () && info_verbose)
printf_filtered ("Collecting memranges: \n");
- for (i = 0, count = 0, end = temp_buf; i < m_memranges.size (); i++)
+ 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)
}
if (count + 27 > MAX_AGENT_EXPR_LEN)
{
- str_list.emplace_back (temp_buf, count);
+ str_list.emplace_back (temp_buf.data (), count);
count = 0;
- end = temp_buf;
+ end = temp_buf.data ();
}
{
- 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);
}
count += strlen (end);
- end = temp_buf + count;
+ end = temp_buf.data () + count;
}
for (i = 0; i < m_aexprs.size (); i++)
QUIT; /* Allow user to bail out with ^C. */
if ((count + 10 + 2 * m_aexprs[i]->len) > MAX_AGENT_EXPR_LEN)
{
- str_list.emplace_back (temp_buf, count);
+ str_list.emplace_back (temp_buf.data (), count);
count = 0;
- end = temp_buf;
+ end = temp_buf.data ();
}
sprintf (end, "X%08X,", m_aexprs[i]->len);
end += 10; /* 'X' + 8 hex digits + ',' */
if (count != 0)
{
- str_list.emplace_back (temp_buf, count);
+ str_list.emplace_back (temp_buf.data (), count);
count = 0;
- end = temp_buf;
+ end = temp_buf.data ();
}
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 (0 == strncasecmp ("$reg", action_exp, 4))
{
- for (i = 0; i < gdbarch_num_regs (target_gdbarch ()); i++)
- collect->add_register (i);
+ for (i = 0; i < gdbarch_num_regs (target_gdbarch ());
+ i++)
+ {
+ int remote_regno = (gdbarch_remote_register_number
+ (target_gdbarch (), i));
+
+ /* Ignore arch regnos without a corresponding
+ remote regno. This can happen for regnos not
+ in the tdesc. */
+ if (remote_regno >= 0)
+ collect->add_remote_register (remote_regno);
+ }
action_exp = strchr (action_exp, ','); /* more? */
}
else if (0 == strncasecmp ("$arg", action_exp, 4))
target_gdbarch (),
trace_string);
- ax_reqs (aexpr.get ());
- report_agent_reqs_errors (aexpr.get ());
+ finalize_tracepoint_aexpr (aexpr.get ());
/* take care of the registers */
- if (aexpr->reg_mask_len > 0)
- {
- for (int 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 (int ndx2 = 0; ndx2 < 8; ndx2++)
- if (aexpr->reg_mask[ndx1] & (1 << ndx2))
- {
- /* It's used -- record it. */
- collect->add_register (ndx1 * 8 + ndx2);
- }
- }
- }
- }
+ collect->add_ax_registers (aexpr.get ());
collect->add_aexpr (std::move (aexpr));
action_exp = strchr (action_exp, ','); /* more? */
{
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));
name);
if (info_verbose)
printf_filtered ("OP_REGISTER: ");
- collect->add_register (i);
+ 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));
- 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;
- char_ptr name = (char_ptr) SYMBOL_NATURAL_NAME (sym);
+ 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,
exp.get (),
trace_string);
- ax_reqs (aexpr.get ());
-
- report_agent_reqs_errors (aexpr.get ());
+ finalize_tracepoint_aexpr (aexpr.get ());
/* Take care of the registers. */
- if (aexpr->reg_mask_len > 0)
- {
- for (int 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 (int ndx2 = 0; ndx2 < 8; ndx2++)
- if (aexpr->reg_mask[ndx1] & (1 << ndx2))
- {
- /* It's used -- record it. */
- collect->add_register (ndx1 * 8 + ndx2);
- }
- }
- }
- }
+ 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 */
agent_expr_up aexpr = gen_eval_for_expr (tloc->address,
exp.get ());
- ax_reqs (aexpr.get ());
- report_agent_reqs_errors (aexpr.get ());
+ finalize_tracepoint_aexpr (aexpr.get ());
/* Even though we're not officially collecting, add
to the collect list anyway. */
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;
loc->gdbarch);
if (bp_location_downloaded)
- observer_notify_breakpoint_modified (b);
+ gdb::observers::breakpoint_modified.notify (b);
}
- VEC_free (breakpoint_p, tp_vec);
/* Send down all the trace state variables too. */
- for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
- {
- target_download_trace_state_variable (tsv);
- }
+ for (const trace_state_variable &tsv : tvariables)
+ target_download_trace_state_variable (tsv);
/* Tell target to treat text-like sections as transparent. */
target_trace_set_readonly_regions ();
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
{
uiout->field_string ("stop-reason", stop_reason);
if (stopping_tracepoint != -1)
- uiout->field_int ("stopping-tracepoint",
- stopping_tracepoint);
+ uiout->field_signed ("stopping-tracepoint",
+ stopping_tracepoint);
if (ts->stop_reason == tracepoint_error)
uiout->field_string ("error-description",
ts->stop_desc);
}
if (ts->traceframe_count != -1)
- uiout->field_int ("frames", ts->traceframe_count);
+ uiout->field_signed ("frames", ts->traceframe_count);
if (ts->traceframes_created != -1)
- uiout->field_int ("frames-created", ts->traceframes_created);
+ uiout->field_signed ("frames-created", ts->traceframes_created);
if (ts->buffer_size != -1)
- uiout->field_int ("buffer-size", ts->buffer_size);
+ uiout->field_signed ("buffer-size", ts->buffer_size);
if (ts->buffer_free != -1)
- uiout->field_int ("buffer-free", ts->buffer_free);
+ uiout->field_signed ("buffer-free", ts->buffer_free);
- uiout->field_int ("disconnected", ts->disconnected_tracing);
- uiout->field_int ("circular", ts->circular_buffer);
+ uiout->field_signed ("disconnected", ts->disconnected_tracing);
+ uiout->field_signed ("circular", ts->circular_buffer);
uiout->field_string ("user-name", ts->user_name);
uiout->field_string ("notes", ts->notes);
DON'T give an error, but DO change the state of
traceframe_number etc. to invalid.
- The rationalle is that if you typed the command, you
+ The rationale is that if you typed the command, you
might just have committed a typo or something, and you'd
like to NOT lose your current debugging state. However
if you're in a user-defined command or especially in a
set_tracepoint_num (tp ? tp->number : target_tracept);
if (target_frameno != get_traceframe_number ())
- observer_notify_traceframe_changed (target_frameno, tracepoint_number);
+ gdb::observers::traceframe_changed.notify (target_frameno, tracepoint_number);
set_current_traceframe (target_frameno);
if (uiout->is_mi_like_p ())
{
uiout->field_string ("found", "1");
- uiout->field_int ("tracepoint", tracepoint_number);
- uiout->field_int ("traceframe", traceframe_number);
+ uiout->field_signed ("tracepoint", tracepoint_number);
+ uiout->field_signed ("traceframe", traceframe_number);
}
else
{
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 (args == 0 || *args == 0)
{ /* XXX FIXME: what should default behavior be? */
- printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
+ printf_filtered ("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");
+ printf_filtered ("Usage: tfind outside STARTADDR, ENDADDR\n");
return;
}
printf_filtered ("Scope for %s:\n", save_args);
count++;
- symname = SYMBOL_PRINT_NAME (sym);
+ symname = sym->print_name ();
if (symname == NULL || *symname == '\0')
continue; /* Probably botched, certainly useless. */
if (SYMBOL_COMPUTED_OPS (sym) != NULL)
SYMBOL_COMPUTED_OPS (sym)->describe_location (sym,
- BLOCK_START (block),
+ BLOCK_ENTRY_PC (block),
gdb_stdout);
else
{
case LOC_BLOCK:
printf_filtered ("a function at address ");
printf_filtered ("%s",
- paddress (gdbarch, BLOCK_START (SYMBOL_BLOCK_VALUE (sym))));
+ paddress (gdbarch, BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym))));
break;
case LOC_UNRESOLVED:
- msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym),
+ msym = lookup_minimal_symbol (sym->linkage_name (),
NULL, NULL);
if (msym.minsym == NULL)
printf_filtered ("Unresolved Static");
}
}
if (SYMBOL_TYPE (sym))
- printf_filtered (", length %d.\n",
- TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym))));
+ {
+ struct type *t = check_typedef (SYMBOL_TYPE (sym));
+
+ printf_filtered (", length %s.\n", pulongest (TYPE_LENGTH (t)));
+ }
}
if (BLOCK_FUNCTION (block))
break;
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))
{
- 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
the fly, and don't cache it. */
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);
-
- 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;
+ gdb::unique_xmalloc_ptr<char> default_collect_line
+ (xstrprintf ("collect %s", default_collect));
+
+ 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
clear_traceframe_info ();
}
-/* A cleanup used when switching away and back from tfind mode. */
-
-struct current_traceframe_cleanup
-{
- /* The traceframe we were inspecting. */
- int traceframe_number;
-};
-
-static void
-do_restore_current_traceframe_cleanup (void *arg)
-{
- struct current_traceframe_cleanup *old
- = (struct current_traceframe_cleanup *) arg;
-
- set_current_traceframe (old->traceframe_number);
-}
-
-static void
-restore_current_traceframe_cleanup_dtor (void *arg)
-{
- struct current_traceframe_cleanup *old
- = (struct current_traceframe_cleanup *) arg;
-
- xfree (old);
-}
-
-struct cleanup *
-make_cleanup_restore_current_traceframe (void)
-{
- struct current_traceframe_cleanup *old =
- XNEW (struct current_traceframe_cleanup);
-
- old->traceframe_number = traceframe_number;
-
- return make_cleanup_dtor (do_restore_current_traceframe_cleanup, old,
- restore_current_traceframe_cleanup_dtor);
-}
+scoped_restore_current_traceframe::scoped_restore_current_traceframe ()
+: m_traceframe_number (traceframe_number)
+{}
/* Given a number and address, return an uploaded tracepoint with that
number, creating if necessary. */
if (utp->number == num && utp->addr == addr)
return utp;
- utp = XCNEW (struct uploaded_tp);
+ utp = new uploaded_tp;
utp->number = num;
utp->addr = addr;
- utp->actions = NULL;
- utp->step_actions = NULL;
- utp->cmd_strings = NULL;
utp->next = *utpp;
*utpp = utp;
while (*utpp)
{
next_one = (*utpp)->next;
- xfree (*utpp);
+ delete *utpp;
*utpp = next_one;
}
}
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;
if (b->type == utp->type
&& t->step_count == utp->step
&& t->pass_count == utp->pass
- && cond_string_is_same (t->cond_string, utp->cond_string)
+ && cond_string_is_same (t->cond_string,
+ utp->cond_string.get ())
/* FIXME also test actions. */
)
{
{
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++)
- observer_notify_breakpoint_modified (b);
+ for (breakpoint *b : modified_tp)
+ gdb::observers::breakpoint_modified.notify (b);
- VEC_free (breakpoint_p, modified_tp);
free_uploaded_tps (uploaded_tps);
}
tsv->initial_value = utsv->initial_value;
tsv->builtin = utsv->builtin;
- observer_notify_tsv_created (tsv);
+ gdb::observers::tsv_created.notify (tsv);
return tsv;
}
void
merge_uploaded_trace_state_variables (struct uploaded_tsv **uploaded_tsvs)
{
- int ix;
struct uploaded_tsv *utsv;
- struct trace_state_variable *tsv;
int highest;
/* Most likely some numbers will have to be reassigned as part of
the merge, so clear them all in anticipation. */
- for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
- tsv->number = 0;
+ for (trace_state_variable &tsv : tvariables)
+ tsv.number = 0;
for (utsv = *uploaded_tsvs; utsv; utsv = utsv->next)
{
- tsv = find_matching_tsv (utsv);
+ struct trace_state_variable *tsv = find_matching_tsv (utsv);
if (tsv)
{
if (info_verbose)
printf_filtered (_("Assuming trace state variable $%s "
"is same as target's variable %d.\n"),
- tsv->name, utsv->number);
+ tsv->name.c_str (), utsv->number);
}
else
{
if (info_verbose)
printf_filtered (_("Created trace state variable "
"$%s for target's variable %d.\n"),
- tsv->name, utsv->number);
+ tsv->name.c_str (), utsv->number);
}
/* Give precedence to numberings that come from the target. */
if (tsv)
/* Renumber everything that didn't get a target-assigned number. */
highest = 0;
- for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
- if (tsv->number > highest)
- highest = tsv->number;
+ for (const trace_state_variable &tsv : tvariables)
+ highest = std::max (tsv.number, highest);
++highest;
- for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
- if (tsv->number == 0)
- tsv->number = highest++;
+ for (trace_state_variable &tsv : tvariables)
+ if (tsv.number == 0)
+ tsv.number = highest++;
free_uploaded_tsvs (uploaded_tsvs);
}
int enabled, end;
enum bptype type;
const char *srctype;
- char *cond, *buf;
+ char *buf;
struct uploaded_tp *utp = NULL;
p = line;
p++; /* skip a colon */
if (piece == 'T')
{
+ gdb::unique_xmalloc_ptr<char[]> cond;
+
enabled = (*p++ == 'E');
p++; /* skip a colon */
p = unpack_varlen_hex (p, &step);
p++; /* skip a colon */
p = unpack_varlen_hex (p, &pass);
type = bp_tracepoint;
- cond = NULL;
/* Thumb through optional fields. */
while (*p == ':')
{
p++;
p = unpack_varlen_hex (p, &xlen);
p++; /* skip a comma */
- cond = (char *) xmalloc (2 * xlen + 1);
- strncpy (cond, p, 2 * xlen);
+ cond.reset ((char *) xmalloc (2 * xlen + 1));
+ strncpy (&cond[0], p, 2 * xlen);
cond[2 * xlen] = '\0';
p += 2 * xlen;
}
utp->enabled = enabled;
utp->step = step;
utp->pass = pass;
- utp->cond = cond;
+ utp->cond = std::move (cond);
}
else if (piece == 'A')
{
utp = get_uploaded_tp (num, addr, utpp);
- VEC_safe_push (char_ptr, utp->actions, xstrdup (p));
+ utp->actions.emplace_back (xstrdup (p));
}
else if (piece == 'S')
{
utp = get_uploaded_tp (num, addr, utpp);
- VEC_safe_push (char_ptr, utp->step_actions, xstrdup (p));
+ utp->step_actions.emplace_back (xstrdup (p));
}
else if (piece == 'Z')
{
buf[end] = '\0';
if (startswith (srctype, "at:"))
- utp->at_string = xstrdup (buf);
+ utp->at_string.reset (xstrdup (buf));
else if (startswith (srctype, "cond:"))
- utp->cond_string = xstrdup (buf);
+ utp->cond_string.reset (xstrdup (buf));
else if (startswith (srctype, "cmd:"))
- VEC_safe_push (char_ptr, utp->cmd_strings, xstrdup (buf));
+ utp->cmd_strings.emplace_back (xstrdup (buf));
}
else if (piece == 'V')
{
utsv->name = xstrdup (buf);
}
-void
-free_current_marker (void *arg)
-{
- struct static_tracepoint_marker **marker_p
- = (struct static_tracepoint_marker **) 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
void
parse_static_tracepoint_marker_definition (const char *line, const char **pp,
- struct static_tracepoint_marker *marker)
+ static_tracepoint_marker *marker)
{
const char *p, *endp;
ULONGEST addr;
- int end;
p = line;
p = unpack_varlen_hex (p, &addr);
if (endp == NULL)
error (_("bad marker definition: %s"), line);
- marker->str_id = (char *) xmalloc (endp - p + 1);
- end = hex2bin (p, (gdb_byte *) marker->str_id, (endp - p + 1) / 2);
- marker->str_id[end] = '\0';
+ marker->str_id = hex2str (p, (endp - p) / 2);
- p += 2 * end;
- p++; /* skip a colon */
-
- marker->extra = (char *) xmalloc (strlen (p) + 1);
- end = hex2bin (p, (gdb_byte *) marker->extra, strlen (p) / 2);
- marker->extra[end] = '\0';
+ p = endp;
+ p++; /* skip a colon */
- if (pp)
- *pp = p;
-}
+ /* This definition may be followed by another one, separated by a comma. */
+ int hex_len;
+ endp = strchr (p, ',');
+ if (endp != nullptr)
+ hex_len = endp - p;
+ else
+ hex_len = strlen (p);
-/* Release a static tracepoint marker's contents. Note that the
- object itself isn't released here. There objects are usually on
- the stack. */
+ marker->extra = hex2str (p, hex_len / 2);
-void
-release_static_tracepoint_marker (struct static_tracepoint_marker *marker)
-{
- xfree (marker->str_id);
- marker->str_id = NULL;
+ if (pp != nullptr)
+ *pp = p + hex_len;
}
/* Print MARKER to gdb_stdout. */
static void
print_one_static_tracepoint_marker (int count,
- struct static_tracepoint_marker *marker)
+ const static_tracepoint_marker &marker)
{
struct symbol *sym;
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;
+ 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");
/* A counter field to help readability. This is not a stable
identifier! */
- uiout->field_int ("count", count);
+ uiout->field_signed ("count", count);
- uiout->field_string ("marker-id", marker->str_id);
+ 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, " ");
- if (gdbarch_addr_bit (marker->gdbarch) <= 32)
+ if (gdbarch_addr_bit (marker.gdbarch) <= 32)
strcat (wrap_indent, " ");
else
strcat (wrap_indent, " ");
strcpy (extra_field_indent, " ");
- uiout->field_core_addr ("addr", marker->gdbarch, marker->address);
+ uiout->field_core_addr ("addr", marker.gdbarch, marker.address);
- sal = find_pc_line (marker->address, 0);
- sym = find_pc_sect_function (marker->address, NULL);
+ sal = find_pc_line (marker.address, 0);
+ sym = find_pc_sect_function (marker.address, NULL);
if (sym)
{
uiout->text ("in ");
- uiout->field_string ("func",
- SYMBOL_PRINT_NAME (sym));
+ uiout->field_string ("func", sym->print_name (),
+ function_name_style.style ());
uiout->wrap_hint (wrap_indent);
uiout->text (" at ");
}
if (sal.symtab != NULL)
{
uiout->field_string ("file",
- symtab_to_filename_for_display (sal.symtab));
+ symtab_to_filename_for_display (sal.symtab),
+ file_name_style.style ());
uiout->text (":");
if (uiout->is_mi_like_p ())
else
uiout->field_skip ("fullname");
- uiout->field_int ("line", sal.line);
+ uiout->field_signed ("line", sal.line);
}
else
{
uiout->text ("\n");
uiout->text (extra_field_indent);
uiout->text (_("Data: \""));
- uiout->field_string ("extra-data", marker->extra);
+ 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;
{
- ui_out_emit_tuple tuple_emitter (uiout, "tracepoints-at");
+ ui_out_emit_tuple inner_tuple_emitter (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++)
+ for (ix = 0; ix < tracepoints.size (); ix++)
{
if (ix > 0)
uiout->text (", ");
uiout->text ("#");
- uiout->field_int ("tracepoint-id", b->number);
+ uiout->field_signed ("tracepoint-id", tracepoints[ix]->number);
}
}
if (uiout->is_mi_like_p ())
- uiout->field_int ("number-of-tracepoints",
- VEC_length(breakpoint_p, tracepoints));
+ uiout->field_signed ("number-of-tracepoints", tracepoints.size ());
else
uiout->text ("\n");
}
- VEC_free (breakpoint_p, tracepoints);
}
static void
info_static_tracepoint_markers_command (const char *arg, int from_tty)
{
- VEC(static_tracepoint_marker_p) *markers;
- struct cleanup *old_chain;
- struct static_tracepoint_marker *marker;
struct ui_out *uiout = current_uiout;
- int i;
+ std::vector<static_tracepoint_marker> markers
+ = target_static_tracepoint_markers_by_strid (NULL);
/* 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.
uiout->table_body ();
- markers = target_static_tracepoint_markers_by_strid (NULL);
- old_chain = make_cleanup (VEC_cleanup (static_tracepoint_marker_p), &markers);
-
- for (i = 0;
- VEC_iterate (static_tracepoint_marker_p,
- markers, i, marker);
- i++)
- {
- print_one_static_tracepoint_marker (i + 1, marker);
- release_static_tracepoint_marker (marker);
- }
-
- do_cleanups (old_chain);
+ for (int i = 0; i < markers.size (); i++)
+ print_one_static_tracepoint_marker (i + 1, markers[i]);
}
/* The $_sdata convenience variable is a bit special. We don't know
sdata_make_value (struct gdbarch *gdbarch, struct internalvar *var,
void *ignore)
{
- LONGEST size;
- gdb_byte *buf;
-
/* We need to read the whole object before we know its size. */
- size = target_read_alloc (¤t_target,
- TARGET_OBJECT_STATIC_TRACE_DATA,
- NULL, &buf);
- if (size >= 0)
+ gdb::optional<gdb::byte_vector> buf
+ = target_read_alloc (current_inferior ()->top_target (),
+ TARGET_OBJECT_STATIC_TRACE_DATA,
+ NULL);
+ if (buf)
{
struct value *v;
struct type *type;
type = init_vector_type (builtin_type (gdbarch)->builtin_true_char,
- size);
+ buf->size ());
v = allocate_value (type);
- memcpy (value_contents_raw (v), buf, size);
- xfree (buf);
+ memcpy (value_contents_raw (v), buf->data (), buf->size ());
return v;
}
else
static void
traceframe_info_start_memory (struct gdb_xml_parser *parser,
const struct gdb_xml_element *element,
- void *user_data, VEC(gdb_xml_value_s) *attributes)
+ void *user_data,
+ std::vector<gdb_xml_value> &attributes)
{
struct traceframe_info *info = (struct traceframe_info *) user_data;
ULONGEST *start_p, *length_p;
start_p
- = (ULONGEST *) xml_find_attribute (attributes, "start")->value;
+ = (ULONGEST *) xml_find_attribute (attributes, "start")->value.get ();
length_p
- = (ULONGEST *) xml_find_attribute (attributes, "length")->value;
+ = (ULONGEST *) xml_find_attribute (attributes, "length")->value.get ();
info->memory.emplace_back (*start_p, *length_p);
}
traceframe_info_start_tvar (struct gdb_xml_parser *parser,
const struct gdb_xml_element *element,
void *user_data,
- VEC(gdb_xml_value_s) *attributes)
+ std::vector<gdb_xml_value> &attributes)
{
struct traceframe_info *info = (struct traceframe_info *) user_data;
const char *id_attrib
- = (const char *) xml_find_attribute (attributes, "id")->value;
+ = (const char *) xml_find_attribute (attributes, "id")->value.get ();
int id = gdb_xml_parse_ulongest (parser, id_attrib);
info->tvars.push_back (id);
NULL
};
+/* See tracepoint.h. */
+cmd_list_element *while_stepping_cmd_element = nullptr;
+
/* module initialization */
+void _initialize_tracepoint ();
void
-_initialize_tracepoint (void)
+_initialize_tracepoint ()
{
struct cmd_list_element *c;
tracepoint_number = -1;
add_info ("scope", info_scope_command,
- _("List the variables local to a scope"));
+ _("List the variables local to a scope."));
add_cmd ("tracepoints", class_trace,
_("Tracing of program execution without stopping the program."),
/* FIXME add a trace variable completer. */
add_info ("tvariables", info_tvariables_command, _("\
-Status of trace state variables and their values.\n\
-"));
+Status of trace state variables and their values."));
add_info ("static-tracepoint-markers",
info_static_tracepoint_markers_command, _("\
-List target static tracepoints markers.\n\
-"));
+List target static tracepoints markers."));
add_prefix_cmd ("tfind", class_trace, tfind_command, _("\
-Select a trace frame;\n\
+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\
-Usage: tfind outside addr1, addr2"),
+Usage: tfind outside ADDR1, ADDR2"),
&tfindlist);
add_cmd ("range", class_trace, tfind_range_command, _("\
Select a trace frame whose PC is in the given range (inclusive).\n\
-Usage: tfind range addr1,addr2"),
+Usage: tfind range ADDR1, ADDR2"),
&tfindlist);
add_cmd ("line", class_trace, tfind_line_command, _("\
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)."));
such a list.\n\n\
Note: the \"end\" command cannot be used at the gdb prompt."));
- add_com ("while-stepping", class_trace, while_stepping_pseudocommand, _("\
+ while_stepping_cmd_element = add_com ("while-stepping", class_trace,
+ while_stepping_pseudocommand, _("\
Specify single-stepping behavior at a tracepoint.\n\
Argument is number of instructions to trace in single-step mode\n\
following the tracepoint. This command is normally followed by\n\
while single-stepping.\n\n\
Note: this command can only be used in a tracepoint \"actions\" list."));
- add_com_alias ("ws", "while-stepping", class_alias, 0);
- add_com_alias ("stepping", "while-stepping", class_alias, 0);
+ add_com_alias ("ws", "while-stepping", class_trace, 0);
+ add_com_alias ("stepping", "while-stepping", class_trace, 0);
add_com ("collect", class_trace, collect_pseudocommand, _("\
Specify one or more data items to be collected at a tracepoint.\n\
default_collect = xstrdup ("");
add_setshow_string_cmd ("default-collect", class_trace,
&default_collect, _("\
-Set the list of expressions to collect by default"), _("\
-Show the list of expressions to collect by default"), NULL,
+Set the list of expressions to collect by default."), _("\
+Show the list of expressions to collect by default."), NULL,
NULL, NULL,
&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 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 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 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);
}
projects / binutils.git / blobdiff