void
tracefile_fetch_registers (struct regcache *regcache, int regno)
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
struct tracepoint *tp = get_tracepoint (get_tracepoint_number ());
int regn;
/* We get here if no register data has been found. Mark registers
as unavailable. */
for (regn = 0; regn < gdbarch_num_regs (gdbarch); regn++)
regcache_raw_supply (regcache, regn, NULL);
/* We can often usefully guess that the PC is going to be the same
as the address of the tracepoint. */
if (tp == NULL || tp->base.loc == NULL)
return;
/* But don't try to guess if tracepoint is multi-location... */
if (tp->base.loc->next)
{
warning (_("Tracepoint %d has multiple "
"locations, cannot infer $pc"),
tp->base.number);
return;
}
/* ... or does while-stepping. */
else if (tp->step_count > 0)
{
warning (_("Tracepoint %d does while-stepping, "
"cannot infer $pc"),
tp->base.number);
return;
}
/* Guess what we can from the tracepoint location. */
gdbarch_guess_tracepoint_registers (gdbarch, regcache,
tp->base.loc->address);
}
void
mi_cmd_break_passcount (char *command, char **argv, int argc)
{
int n;
int p;
struct tracepoint *t;
if (argc != 2)
error (_("Usage: tracepoint-number passcount"));
n = atoi (argv[0]);
p = atoi (argv[1]);
t = get_tracepoint (n);
if (t)
{
t->pass_count = p;
observer_notify_breakpoint_modified (&t->base);
}
else
{
error (_("Could not find tracepoint %d"), n);
}
}
static int
ctf_trace_find (struct target_ops *self, enum trace_find_type type, int num,
CORE_ADDR addr1, CORE_ADDR addr2, int *tpp)
{
int ret = -1;
int tfnum = 0;
int found = 0;
struct bt_iter_pos pos;
if (num == -1)
{
if (tpp != NULL)
*tpp = -1;
return -1;
}
gdb_assert (ctf_iter != NULL);
/* Set iterator back to the start. */
bt_iter_set_pos (bt_ctf_get_iter (ctf_iter), start_pos);
while (1)
{
int id;
struct bt_ctf_event *event;
const char *name;
event = bt_ctf_iter_read_event (ctf_iter);
name = bt_ctf_event_name (event);
if (event == NULL || name == NULL)
break;
if (strcmp (name, "frame") == 0)
{
CORE_ADDR tfaddr;
if (type == tfind_number)
{
/* Looking for a specific trace frame. */
if (tfnum == num)
found = 1;
}
else
{
/* Start from the _next_ trace frame. */
if (tfnum > get_traceframe_number ())
{
switch (type)
{
case tfind_tp:
{
struct tracepoint *tp = get_tracepoint (num);
if (tp != NULL
&& (tp->number_on_target
== ctf_get_tpnum_from_frame_event (event)))
found = 1;
break;
}
case tfind_pc:
tfaddr = ctf_get_traceframe_address ();
if (tfaddr == addr1)
found = 1;
break;
case tfind_range:
tfaddr = ctf_get_traceframe_address ();
if (addr1 <= tfaddr && tfaddr <= addr2)
found = 1;
break;
case tfind_outside:
tfaddr = ctf_get_traceframe_address ();
if (!(addr1 <= tfaddr && tfaddr <= addr2))
found = 1;
break;
default:
internal_error (__FILE__, __LINE__, _("unknown tfind type"));
}
}
}
if (found)
{
if (tpp != NULL)
*tpp = ctf_get_tpnum_from_frame_event (event);
/* Skip the event "frame". */
bt_iter_next (bt_ctf_get_iter (ctf_iter));
return tfnum;
}
tfnum++;
}
if (bt_iter_next (bt_ctf_get_iter (ctf_iter)) < 0)
break;
}
return -1;
}