/* Encapsulate tests for different types of tracepoints. */
+static int
+is_tracepoint_type (enum bptype type)
+{
+ return (type == bp_tracepoint
+ || type == bp_fast_tracepoint
+ || type == bp_static_tracepoint);
+}
+
int
is_tracepoint (const struct breakpoint *b)
{
- return (b->type == bp_tracepoint
- || b->type == bp_fast_tracepoint
- || b->type == bp_static_tracepoint);
+ return is_tracepoint_type (b->type);
}
-
+
/* A helper function that validates that COMMANDS are valid for a
breakpoint. This function will throw an exception if a problem is
found. */
do_cleanups (script_chain);
}
- if (!part_of_multiple && b->pass_count)
+ if (is_tracepoint (b))
{
- annotate_field (10);
- ui_out_text (uiout, "\tpass count ");
- ui_out_field_int (uiout, "pass", b->pass_count);
- ui_out_text (uiout, " \n");
+ struct tracepoint *t = (struct tracepoint *) b;
+
+ if (!part_of_multiple && t->pass_count)
+ {
+ annotate_field (10);
+ ui_out_text (uiout, "\tpass count ");
+ ui_out_field_int (uiout, "pass", t->pass_count);
+ ui_out_text (uiout, " \n");
+ }
}
if (ui_out_is_mi_like_p (uiout) && !part_of_multiple)
print_recreate_catch_fork (struct breakpoint *b, struct ui_file *fp)
{
fprintf_unfiltered (fp, "catch fork");
+ print_recreate_thread (b, fp);
}
/* The breakpoint_ops structure to be used in fork catchpoints. */
print_recreate_catch_vfork (struct breakpoint *b, struct ui_file *fp)
{
fprintf_unfiltered (fp, "catch vfork");
+ print_recreate_thread (b, fp);
}
/* The breakpoint_ops structure to be used in vfork catchpoints. */
fprintf_unfiltered (fp, " %d", s.number);
}
}
+ print_recreate_thread (b, fp);
}
/* The breakpoint_ops structure to be used in syscall catchpoints. */
print_recreate_catch_exec (struct breakpoint *b, struct ui_file *fp)
{
fprintf_unfiltered (fp, "catch exec");
+ print_recreate_thread (b, fp);
}
static struct breakpoint_ops catch_exec_breakpoint_ops;
as condition expression. */
static void
-create_breakpoint_sal (struct gdbarch *gdbarch,
- struct symtabs_and_lines sals, char *addr_string,
- char *cond_string,
- enum bptype type, enum bpdisp disposition,
- int thread, int task, int ignore_count,
- struct breakpoint_ops *ops, int from_tty,
- int enabled, int internal, int display_canonical)
+init_breakpoint_sal (struct breakpoint *b, struct gdbarch *gdbarch,
+ struct symtabs_and_lines sals, char *addr_string,
+ char *cond_string,
+ enum bptype type, enum bpdisp disposition,
+ int thread, int task, int ignore_count,
+ struct breakpoint_ops *ops, int from_tty,
+ int enabled, int internal, int display_canonical)
{
- struct breakpoint *b = NULL;
int i;
if (type == bp_hardware_breakpoint)
if (i == 0)
{
- b = set_raw_breakpoint (gdbarch, sal, type, ops);
- set_breakpoint_number (internal, b);
+ init_raw_breakpoint (b, gdbarch, sal, type, ops);
b->thread = thread;
b->task = task;
if (type == bp_static_tracepoint)
{
+ struct tracepoint *t = (struct tracepoint *) b;
struct static_tracepoint_marker marker;
if (is_marker_spec (addr_string))
endp = skip_to_space (p);
marker_str = savestring (p, endp - p);
- b->static_trace_marker_id = marker_str;
+ t->static_trace_marker_id = marker_str;
printf_filtered (_("Probed static tracepoint "
"marker \"%s\"\n"),
- b->static_trace_marker_id);
+ t->static_trace_marker_id);
}
else if (target_static_tracepoint_marker_at (sal.pc, &marker))
{
- b->static_trace_marker_id = xstrdup (marker.str_id);
+ t->static_trace_marker_id = xstrdup (marker.str_id);
release_static_tracepoint_marker (&marker);
printf_filtered (_("Probed static tracepoint "
"marker \"%s\"\n"),
- b->static_trace_marker_id);
+ t->static_trace_marker_id);
}
else
warning (_("Couldn't determine the static "
me. */
b->addr_string
= xstrprintf ("*%s", paddress (b->loc->gdbarch, b->loc->address));
+}
- /* Do not mention breakpoints with a negative number, but do
- notify observers. */
- if (!internal)
- mention (b);
- observer_notify_breakpoint_created (b);
+static void
+create_breakpoint_sal (struct gdbarch *gdbarch,
+ struct symtabs_and_lines sals, char *addr_string,
+ char *cond_string,
+ enum bptype type, enum bpdisp disposition,
+ int thread, int task, int ignore_count,
+ struct breakpoint_ops *ops, int from_tty,
+ int enabled, int internal, int display_canonical)
+{
+ struct breakpoint *b;
+ struct cleanup *old_chain;
+
+ if (is_tracepoint_type (type))
+ {
+ struct tracepoint *t;
+
+ t = XCNEW (struct tracepoint);
+ b = &t->base;
+ }
+ else
+ b = XNEW (struct breakpoint);
+
+ old_chain = make_cleanup (xfree, b);
+
+ init_breakpoint_sal (b, gdbarch,
+ sals, addr_string,
+ cond_string,
+ type, disposition,
+ thread, task, ignore_count,
+ ops, from_tty,
+ enabled, internal, display_canonical);
+ discard_cleanups (old_chain);
+
+ install_breakpoint (internal, b);
}
/* Remove element at INDEX_TO_REMOVE from SAL, shifting other
for (i = 0; i < sals.nelts; ++i)
{
struct symtabs_and_lines expanded;
- struct breakpoint *tp;
+ struct tracepoint *tp;
struct cleanup *old_chain;
expanded.nelts = 1;
expanded.sals[0] = sals.sals[i];
old_chain = make_cleanup (xfree, expanded.sals);
- create_breakpoint_sal (gdbarch, expanded, canonical.canonical[i],
- cond_string, type_wanted,
- tempflag ? disp_del : disp_donttouch,
- thread, task, ignore_count, ops,
- from_tty, enabled, internal,
- canonical.special_display);
-
- do_cleanups (old_chain);
-
- /* Get the tracepoint we just created. */
- if (internal)
- tp = get_breakpoint (internal_breakpoint_number);
- else
- tp = get_breakpoint (breakpoint_count);
- gdb_assert (tp != NULL);
-
+ tp = XCNEW (struct tracepoint);
+ init_breakpoint_sal (&tp->base, gdbarch, expanded,
+ canonical.canonical[i],
+ cond_string, type_wanted,
+ tempflag ? disp_del : disp_donttouch,
+ thread, task, ignore_count, ops,
+ from_tty, enabled, internal,
+ canonical.special_display);
/* Given that its possible to have multiple markers with
the same string id, if the user is creating a static
tracepoint by marker id ("strace -m MARKER_ID"), then
try to match up which of the newly found markers
corresponds to this one */
tp->static_trace_marker_id_idx = i;
+
+ install_breakpoint (internal, &tp->base);
+
+ do_cleanups (old_chain);
}
}
else
{
fprintf_unfiltered (fp, "break-range %s, %s", b->addr_string,
b->addr_string_range_end);
+ print_recreate_thread (b, fp);
}
/* The breakpoint_ops structure to be used in ranged breakpoints. */
}
fprintf_unfiltered (fp, " %s", w->exp_string);
+ print_recreate_thread (b, fp);
}
/* The breakpoint_ops structure to be used in hardware watchpoints. */
sprintf_vma (tmp, w->hw_wp_mask);
fprintf_unfiltered (fp, " %s mask 0x%s", w->exp_string, tmp);
+ print_recreate_thread (b, fp);
}
/* The breakpoint_ops structure to be used in masked hardware watchpoints. */
bp_throw = strstr (b->addr_string, "throw") != NULL;
fprintf_unfiltered (fp, bp_temp ? "tcatch " : "catch ");
fprintf_unfiltered (fp, bp_throw ? "throw" : "catch");
+ print_recreate_thread (b, fp);
}
static struct breakpoint_ops gnu_v3_exception_catchpoint_ops;
tracepoint_print_one_detail (const struct breakpoint *self,
struct ui_out *uiout)
{
- if (self->static_trace_marker_id)
+ struct tracepoint *tp = (struct tracepoint *) self;
+ if (tp->static_trace_marker_id)
{
gdb_assert (self->type == bp_static_tracepoint);
ui_out_text (uiout, "\tmarker id is ");
ui_out_field_string (uiout, "static-tracepoint-marker-string-id",
- self->static_trace_marker_id);
+ tp->static_trace_marker_id);
ui_out_text (uiout, "\n");
}
}
}
static void
-tracepoint_print_recreate (struct breakpoint *tp, struct ui_file *fp)
+tracepoint_print_recreate (struct breakpoint *self, struct ui_file *fp)
{
- if (tp->type == bp_fast_tracepoint)
+ struct tracepoint *tp = (struct tracepoint *) self;
+
+ if (self->type == bp_fast_tracepoint)
fprintf_unfiltered (fp, "ftrace");
- if (tp->type == bp_static_tracepoint)
+ if (self->type == bp_static_tracepoint)
fprintf_unfiltered (fp, "strace");
- else if (tp->type == bp_tracepoint)
+ else if (self->type == bp_tracepoint)
fprintf_unfiltered (fp, "trace");
else
internal_error (__FILE__, __LINE__,
- _("unhandled tracepoint type %d"), (int) tp->type);
+ _("unhandled tracepoint type %d"), (int) self->type);
- fprintf_unfiltered (fp, " %s", tp->addr_string);
+ fprintf_unfiltered (fp, " %s", self->addr_string);
+ print_recreate_thread (self, fp);
+
+ if (tp->pass_count)
+ fprintf_unfiltered (fp, " passcount %d\n", tp->pass_count);
}
struct breakpoint_ops tracepoint_breakpoint_ops;
static struct symtab_and_line
update_static_tracepoint (struct breakpoint *b, struct symtab_and_line sal)
{
+ struct tracepoint *tp = (struct tracepoint *) b;
struct static_tracepoint_marker marker;
CORE_ADDR pc;
int i;
if (target_static_tracepoint_marker_at (pc, &marker))
{
- if (strcmp (b->static_trace_marker_id, marker.str_id) != 0)
+ if (strcmp (tp->static_trace_marker_id, marker.str_id) != 0)
warning (_("static tracepoint %d changed probed marker from %s to %s"),
b->number,
- b->static_trace_marker_id, marker.str_id);
+ tp->static_trace_marker_id, marker.str_id);
- xfree (b->static_trace_marker_id);
- b->static_trace_marker_id = xstrdup (marker.str_id);
+ xfree (tp->static_trace_marker_id);
+ tp->static_trace_marker_id = xstrdup (marker.str_id);
release_static_tracepoint_marker (&marker);
return sal;
if (!sal.explicit_pc
&& sal.line != 0
&& sal.symtab != NULL
- && b->static_trace_marker_id != NULL)
+ && tp->static_trace_marker_id != NULL)
{
VEC(static_tracepoint_marker_p) *markers;
markers
- = target_static_tracepoint_markers_by_strid (b->static_trace_marker_id);
+ = target_static_tracepoint_markers_by_strid (tp->static_trace_marker_id);
if (!VEC_empty(static_tracepoint_marker_p, markers))
{
marker = VEC_index (static_tracepoint_marker_p, markers, 0);
- xfree (b->static_trace_marker_id);
- b->static_trace_marker_id = xstrdup (marker->str_id);
+ xfree (tp->static_trace_marker_id);
+ tp->static_trace_marker_id = xstrdup (marker->str_id);
warning (_("marker for static tracepoint %d (%s) not "
"found at previous line number"),
- b->number, b->static_trace_marker_id);
+ b->number, tp->static_trace_marker_id);
init_sal (&sal);
{
if (marker_spec)
{
+ struct tracepoint *tp = (struct tracepoint *) b;
+
sals = decode_static_tracepoint_spec (&s);
- if (sals.nelts > b->static_trace_marker_id_idx)
+ if (sals.nelts > tp->static_trace_marker_id_idx)
{
- sals.sals[0] = sals.sals[b->static_trace_marker_id_idx];
+ sals.sals[0] = sals.sals[tp->static_trace_marker_id_idx];
sals.nelts = 1;
}
else
- error (_("marker %s not found"), b->static_trace_marker_id);
+ error (_("marker %s not found"), tp->static_trace_marker_id);
}
else
sals = decode_line_1 (&s, 1, (struct symtab *) NULL, 0, NULL);
the target does not necessarily have all the information used when
the tracepoint was originally defined. */
-struct breakpoint *
+struct tracepoint *
create_tracepoint_from_upload (struct uploaded_tp *utp)
{
char *addr_str, small_buf[100];
- struct breakpoint *tp;
+ struct tracepoint *tp;
if (utp->at_string)
addr_str = utp->at_string;
if (utp->pass > 0)
{
- sprintf (small_buf, "%d %d", utp->pass, tp->number);
+ sprintf (small_buf, "%d %d", utp->pass, tp->base.number);
trace_pass_command (small_buf, 0);
}
cmd_list = read_command_lines_1 (read_uploaded_action, 1, NULL, NULL);
- breakpoint_set_commands (tp, cmd_list);
+ breakpoint_set_commands (&tp->base, cmd_list);
}
else if (!VEC_empty (char_ptr, utp->actions)
|| !VEC_empty (char_ptr, utp->step_actions))
utp->number);
return tp;
- }
+}
/* Print information on tracepoint number TPNUM_EXP, or all if
omitted. */
/* Helper function for trace_pass_command. */
static void
-trace_pass_set_count (struct breakpoint *bp, int count, int from_tty)
+trace_pass_set_count (struct tracepoint *tp, int count, int from_tty)
{
- bp->pass_count = count;
- observer_notify_tracepoint_modified (bp->number);
+ tp->pass_count = count;
+ observer_notify_tracepoint_modified (tp->base.number);
if (from_tty)
printf_filtered (_("Setting tracepoint %d's passcount to %d\n"),
- bp->number, count);
+ tp->base.number, count);
}
/* Set passcount for tracepoint.
static void
trace_pass_command (char *args, int from_tty)
{
- struct breakpoint *t1;
+ struct tracepoint *t1;
unsigned int count;
if (args == 0 || *args == 0)
if (*args && strncasecmp (args, "all", 3) == 0)
{
+ struct breakpoint *b;
+
args += 3; /* Skip special argument "all". */
if (*args)
error (_("Junk at end of arguments."));
- ALL_TRACEPOINTS (t1)
+ ALL_TRACEPOINTS (b)
{
+ t1 = (struct tracepoint *) b;
trace_pass_set_count (t1, count, from_tty);
}
}
}
}
-struct breakpoint *
+struct tracepoint *
get_tracepoint (int num)
{
struct breakpoint *t;
ALL_TRACEPOINTS (t)
if (t->number == num)
- return t;
+ return (struct tracepoint *) t;
return NULL;
}
different from the tracepoint number after disconnecting and
reconnecting). */
-struct breakpoint *
+struct tracepoint *
get_tracepoint_by_number_on_target (int num)
{
- struct breakpoint *t;
+ struct breakpoint *b;
- ALL_TRACEPOINTS (t)
- if (t->number_on_target == num)
- return t;
+ ALL_TRACEPOINTS (b)
+ {
+ struct tracepoint *t = (struct tracepoint *) b;
+
+ if (t->number_on_target == num)
+ return t;
+ }
return NULL;
}
If STATE is not NULL, use, get_number_or_range_state and ignore ARG.
If OPTIONAL_P is true, then if the argument is missing, the most
recent tracepoint (tracepoint_count) is returned. */
-struct breakpoint *
+struct tracepoint *
get_tracepoint_by_number (char **arg,
struct get_number_or_range_state *state,
int optional_p)
ALL_TRACEPOINTS (t)
if (t->number == tpnum)
{
- return t;
+ return (struct tracepoint *) t;
}
printf_unfiltered ("No tracepoint number %d.\n", tpnum);
return NULL;
}
+void
+print_recreate_thread (struct breakpoint *b, struct ui_file *fp)
+{
+ if (b->thread != -1)
+ fprintf_unfiltered (fp, " thread %d", b->thread);
+
+ if (b->task != 0)
+ fprintf_unfiltered (fp, " task %d", b->task);
+
+ fprintf_unfiltered (fp, "\n");
+}
+
/* Save information on user settable breakpoints (watchpoints, etc) to
a new script file named FILENAME. If FILTER is non-NULL, call it
on each breakpoint and only include the ones for which it returns
tp->ops->print_recreate (tp, fp);
- if (tp->thread != -1)
- fprintf_unfiltered (fp, " thread %d", tp->thread);
-
- if (tp->task != 0)
- fprintf_unfiltered (fp, " task %d", tp->task);
-
- fprintf_unfiltered (fp, "\n");
-
/* Note, we can't rely on tp->number for anything, as we can't
assume the recreated breakpoint numbers will match. Use $bpnum
instead. */
if (tp->ignore_count)
fprintf_unfiltered (fp, " ignore $bpnum %d\n", tp->ignore_count);
- if (tp->pass_count)
- fprintf_unfiltered (fp, " passcount %d\n", tp->pass_count);
-
if (tp->commands)
{
volatile struct gdb_exception ex;
projects / deliverable / binutils-gdb.git / blobdiff