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; }