static void update_global_location_list_nothrow (enum ugll_insert_mode);
-static int is_hardware_watchpoint (const struct breakpoint *bpt);
-
static void insert_breakpoint_locations (void);
static void trace_pass_command (const char *, int);
static void set_tracepoint_count (int num);
-static int is_masked_watchpoint (const struct breakpoint *b);
+static bool is_masked_watchpoint (const struct breakpoint *b);
static struct bp_location **get_first_locp_gte_addr (CORE_ADDR address);
return type == bp_longjmp || type == bp_exception;
}
-int
+/* See breakpoint.h. */
+
+bool
is_tracepoint (const struct breakpoint *b)
{
return is_tracepoint_type (b->type);
}
}
-\f
-
-/* Return true if BPT is either a software breakpoint or a hardware
- breakpoint. */
+/* See breakpoint.h. */
-int
+bool
is_breakpoint (const struct breakpoint *bpt)
{
return (bpt->type == bp_breakpoint
/* Return true if BPT is of any hardware watchpoint kind. */
-static int
+static bool
is_hardware_watchpoint (const struct breakpoint *bpt)
{
return (bpt->type == bp_hardware_watchpoint
|| bpt->type == bp_access_watchpoint);
}
-/* Return true if BPT is of any watchpoint kind, hardware or
- software. */
+/* See breakpoint.h. */
-int
+bool
is_watchpoint (const struct breakpoint *bpt)
{
return (is_hardware_watchpoint (bpt)
/* Returns true if B is a software watchpoint that is not watching any
memory (e.g., "watch $pc"). */
-static int
+static bool
is_no_memory_software_watchpoint (struct breakpoint *b)
{
return (b->type == bp_watchpoint
}
return 0;
}
-\f
-/* bpstat stuff. External routines' interfaces are documented
- in breakpoint.h. */
+/* See breakpoint.h. */
-int
-is_catchpoint (struct breakpoint *ep)
+bool
+is_catchpoint (struct breakpoint *b)
{
- return (ep->type == bp_catchpoint);
+ return (b->type == bp_catchpoint);
}
/* Frees any storage that is part of a bpstat. Does not walk the
/* See breakpoint.h. */
-int
+bool
bpstat_explains_signal (bpstat bsp, enum gdb_signal sig)
{
for (; bsp != NULL; bsp = bsp->next)
/* A moribund location can never explain a signal other than
GDB_SIGNAL_TRAP. */
if (sig == GDB_SIGNAL_TRAP)
- return 1;
+ return true;
}
else
{
if (bsp->breakpoint_at->ops->explains_signal (bsp->breakpoint_at,
sig))
- return 1;
+ return true;
}
}
- return 0;
+ return false;
}
/* Put in *NUM the breakpoint number of the first breakpoint we are
struct thread_info *thr = inferior_thread ();
uiout->text ("Thread ");
- uiout->field_fmt ("thread-id", "%s", print_thread_id (thr));
+ uiout->field_string ("thread-id", print_thread_id (thr));
name = thr->name != NULL ? thr->name : target_thread_name (thr);
if (name != NULL)
{
uiout->text (" \"");
- uiout->field_fmt ("name", "%s", name);
+ uiout->field_string ("name", name);
uiout->text ("\"");
}
uiout->field_string
("reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_SCOPE));
uiout->text ("\nWatchpoint ");
- uiout->field_int ("wpnum", b->number);
+ uiout->field_signed ("wpnum", b->number);
uiout->text (" deleted because the program has left the block in\n"
"which its expression is valid.\n");
}
retval.main_action = BPSTAT_WHAT_KEEP_CHECKING;
retval.call_dummy = STOP_NONE;
- retval.is_longjmp = 0;
+ retval.is_longjmp = false;
for (bs = bs_head; bs != NULL; bs = bs->next)
{
}
}
-/* Nonzero if we should step constantly (e.g. watchpoints on machines
- without hardware support). This isn't related to a specific bpstat,
- just to things like whether watchpoints are set. */
+/* See breakpoint.h. */
-int
-bpstat_should_step (void)
+bool
+bpstat_should_step ()
{
struct breakpoint *b;
ALL_BREAKPOINTS (b)
if (breakpoint_enabled (b) && b->type == bp_watchpoint && b->loc != NULL)
- return 1;
- return 0;
+ return true;
+ return false;
}
-int
+/* See breakpoint.h. */
+
+bool
bpstat_causes_stop (bpstat bs)
{
for (; bs != NULL; bs = bs->next)
if (bs->stop)
- return 1;
+ return true;
- return 0;
+ return false;
}
\f
if (uiout->is_mi_like_p ())
uiout->field_string ("fullname", symtab_to_fullname (loc->symtab));
- uiout->field_int ("line", loc->line_number);
+ uiout->field_signed ("line", loc->line_number);
}
else if (loc)
{
}
}
-/* Print B to gdb_stdout. */
+/* Print B to gdb_stdout. If RAW_LOC, print raw breakpoint locations
+ instead of going via breakpoint_ops::print_one. This makes "maint
+ info breakpoints" show the software breakpoint locations of
+ catchpoints, which are considered internal implementation
+ detail. */
static void
print_one_breakpoint_location (struct breakpoint *b,
struct bp_location *loc,
int loc_number,
struct bp_location **last_loc,
- int allflag)
+ int allflag, bool raw_loc)
{
struct command_line *l;
static char bpenables[] = "nynny";
if (part_of_multiple)
uiout->field_fmt ("number", "%d.%d", b->number, loc_number);
else
- uiout->field_int ("number", b->number);
+ uiout->field_signed ("number", b->number);
/* 2 */
annotate_field (1);
uiout->field_fmt ("enabled", "%c", bpenables[(int) b->enable_state]);
/* 5 and 6 */
- if (b->ops != NULL && b->ops->print_one != NULL)
+ if (!raw_loc && b->ops != NULL && b->ops->print_one != NULL)
b->ops->print_one (b, last_loc);
else
- switch (b->type)
- {
- case bp_none:
- internal_error (__FILE__, __LINE__,
- _("print_one_breakpoint: bp_none encountered\n"));
- break;
-
- case bp_watchpoint:
- case bp_hardware_watchpoint:
- case bp_read_watchpoint:
- case bp_access_watchpoint:
+ {
+ if (is_watchpoint (b))
{
struct watchpoint *w = (struct watchpoint *) b;
annotate_field (5);
uiout->field_string ("what", w->exp_string);
}
- break;
-
- case bp_breakpoint:
- case bp_hardware_breakpoint:
- case bp_single_step:
- case bp_until:
- case bp_finish:
- case bp_longjmp:
- case bp_longjmp_resume:
- case bp_longjmp_call_dummy:
- case bp_exception:
- case bp_exception_resume:
- case bp_step_resume:
- case bp_hp_step_resume:
- case bp_watchpoint_scope:
- case bp_call_dummy:
- case bp_std_terminate:
- case bp_shlib_event:
- case bp_thread_event:
- case bp_overlay_event:
- case bp_longjmp_master:
- case bp_std_terminate_master:
- case bp_exception_master:
- case bp_tracepoint:
- case bp_fast_tracepoint:
- case bp_static_tracepoint:
- case bp_dprintf:
- case bp_jit_event:
- case bp_gnu_ifunc_resolver:
- case bp_gnu_ifunc_resolver_return:
- if (opts.addressprint)
- {
- annotate_field (4);
- if (header_of_multiple)
- uiout->field_string ("addr", "<MULTIPLE>");
- else if (b->loc == NULL || loc->shlib_disabled)
- uiout->field_string ("addr", "<PENDING>");
- else
- uiout->field_core_addr ("addr",
- loc->gdbarch, loc->address);
- }
- annotate_field (5);
- if (!header_of_multiple)
- print_breakpoint_location (b, loc);
- if (b->loc)
- *last_loc = b->loc;
- break;
- }
-
+ else if (!is_catchpoint (b) || is_exception_catchpoint (b)
+ || is_ada_exception_catchpoint (b))
+ {
+ if (opts.addressprint)
+ {
+ annotate_field (4);
+ if (header_of_multiple)
+ uiout->field_string ("addr", "<MULTIPLE>");
+ else if (b->loc == NULL || loc->shlib_disabled)
+ uiout->field_string ("addr", "<PENDING>");
+ else
+ uiout->field_core_addr ("addr",
+ loc->gdbarch, loc->address);
+ }
+ annotate_field (5);
+ if (!header_of_multiple)
+ print_breakpoint_location (b, loc);
+ if (b->loc)
+ *last_loc = b->loc;
+ }
+ }
if (loc != NULL && !header_of_multiple)
{
/* FIXME: This seems to be redundant and lost here; see the
"stop only in" line a little further down. */
uiout->text (" thread ");
- uiout->field_int ("thread", b->thread);
+ uiout->field_signed ("thread", b->thread);
}
else if (b->task != 0)
{
uiout->text (" task ");
- uiout->field_int ("task", b->task);
+ uiout->field_signed ("task", b->task);
}
}
/* FIXME should make an annotation for this. */
uiout->text ("\tstop only in thread ");
if (uiout->is_mi_like_p ())
- uiout->field_int ("thread", b->thread);
+ uiout->field_signed ("thread", b->thread);
else
{
struct thread_info *thr = find_thread_global_id (b->thread);
else
uiout->text ("\tbreakpoint");
uiout->text (" already hit ");
- uiout->field_int ("times", b->hit_count);
+ uiout->field_signed ("times", b->hit_count);
if (b->hit_count == 1)
uiout->text (" time\n");
else
{
/* Output the count also if it is zero, but only if this is mi. */
if (uiout->is_mi_like_p ())
- uiout->field_int ("times", b->hit_count);
+ uiout->field_signed ("times", b->hit_count);
}
}
{
annotate_field (8);
uiout->text ("\tignore next ");
- uiout->field_int ("ignore", b->ignore_count);
+ uiout->field_signed ("ignore", b->ignore_count);
uiout->text (" hits\n");
}
uiout->text ("additional ");
else
uiout->text ("next ");
- uiout->field_int ("enable", b->enable_count);
+ uiout->field_signed ("enable", b->enable_count);
uiout->text (" hits\n");
}
if (tp->traceframe_usage)
{
uiout->text ("\ttrace buffer usage ");
- uiout->field_int ("traceframe-usage", tp->traceframe_usage);
+ uiout->field_signed ("traceframe-usage", tp->traceframe_usage);
uiout->text (" bytes\n");
}
}
{
annotate_field (10);
uiout->text ("\tpass count ");
- uiout->field_int ("pass", t->pass_count);
+ uiout->field_signed ("pass", t->pass_count);
uiout->text (" \n");
}
|| fix_multi_location_breakpoint_output_globally);
gdb::optional<ui_out_emit_tuple> bkpt_tuple_emitter (gdb::in_place, uiout, "bkpt");
- print_one_breakpoint_location (b, NULL, 0, last_loc, allflag);
+ print_one_breakpoint_location (b, NULL, 0, last_loc, allflag, false);
/* The mi2 broken format: the main breakpoint tuple ends here, the locations
are outside. */
/* If this breakpoint has custom print function,
it's already printed. Otherwise, print individual
locations, if any. */
- if (b->ops == NULL || b->ops->print_one == NULL)
+ if (b->ops == NULL
+ || b->ops->print_one == NULL
+ || allflag)
{
/* If breakpoint has a single location that is disabled, we
print it as if it had several locations, since otherwise it's
situation.
Note that while hardware watchpoints have several locations
- internally, that's not a property exposed to user. */
- if (b->loc
- && !is_hardware_watchpoint (b)
- && (b->loc->next || !b->loc->enabled))
+ internally, that's not a property exposed to users.
+
+ Likewise, while catchpoints may be implemented with
+ breakpoints (e.g., catch throw), that's not a property
+ exposed to users. We do however display the internal
+ breakpoint locations with "maint info breakpoints". */
+ if (!is_hardware_watchpoint (b)
+ && (!is_catchpoint (b) || is_exception_catchpoint (b)
+ || is_ada_exception_catchpoint (b))
+ && (allflag
+ || (b->loc && (b->loc->next || !b->loc->enabled))))
{
gdb::optional<ui_out_emit_list> locations_list;
for (bp_location *loc = b->loc; loc != NULL; loc = loc->next, ++n)
{
ui_out_emit_tuple loc_tuple_emitter (uiout, NULL);
- print_one_breakpoint_location (b, loc, n, last_loc, allflag);
+ print_one_breakpoint_location (b, loc, n, last_loc,
+ allflag, allflag);
}
}
}
return b->loc == NULL;
}
-/* Print information on user settable breakpoint (watchpoint, etc)
- number BNUM. If BNUM is -1 print all user-settable breakpoints.
- If ALLFLAG is non-zero, include non-user-settable breakpoints. If
- FILTER is non-NULL, call it on each breakpoint and only include the
- ones for which it returns non-zero. Return the total number of
- breakpoints listed. */
+/* Print information on breakpoints (including watchpoints and tracepoints).
+
+ If non-NULL, BP_NUM_LIST is a list of numbers and number ranges as
+ understood by number_or_range_parser. Only breakpoints included in this
+ list are then printed.
+
+ If SHOW_INTERNAL is true, print internal breakpoints.
+
+ If FILTER is non-NULL, call it on each breakpoint and only include the
+ ones for which it returns true.
+
+ Return the total number of breakpoints listed. */
static int
-breakpoint_1 (const char *args, int allflag,
- int (*filter) (const struct breakpoint *))
+breakpoint_1 (const char *bp_num_list, bool show_internal,
+ bool (*filter) (const struct breakpoint *))
{
struct breakpoint *b;
struct bp_location *last_loc = NULL;
if (filter && !filter (b))
continue;
- /* If we have an "args" string, it is a list of breakpoints to
+ /* If we have a BP_NUM_LIST string, it is a list of breakpoints to
accept. Skip the others. */
- if (args != NULL && *args != '\0')
+ if (bp_num_list != NULL && *bp_num_list != '\0')
{
- if (allflag && parse_and_eval_long (args) != b->number)
+ if (show_internal && parse_and_eval_long (bp_num_list) != b->number)
continue;
- if (!allflag && !number_is_in_list (args, b->number))
+ if (!show_internal && !number_is_in_list (bp_num_list, b->number))
continue;
}
- if (allflag || user_breakpoint_p (b))
+ if (show_internal || user_breakpoint_p (b))
{
int addr_bit, type_len;
if (filter && !filter (b))
continue;
- /* If we have an "args" string, it is a list of breakpoints to
+ /* If we have a BP_NUM_LIST string, it is a list of breakpoints to
accept. Skip the others. */
- if (args != NULL && *args != '\0')
+ if (bp_num_list != NULL && *bp_num_list != '\0')
{
- if (allflag) /* maintenance info breakpoint */
+ if (show_internal) /* maintenance info breakpoint */
{
- if (parse_and_eval_long (args) != b->number)
+ if (parse_and_eval_long (bp_num_list) != b->number)
continue;
}
else /* all others */
{
- if (!number_is_in_list (args, b->number))
+ if (!number_is_in_list (bp_num_list, b->number))
continue;
}
}
/* We only print out user settable breakpoints unless the
- allflag is set. */
- if (allflag || user_breakpoint_p (b))
- print_one_breakpoint (b, &last_loc, allflag);
+ show_internal is set. */
+ if (show_internal || user_breakpoint_p (b))
+ print_one_breakpoint (b, &last_loc, show_internal);
}
}
empty list. */
if (!filter)
{
- if (args == NULL || *args == '\0')
+ if (bp_num_list == NULL || *bp_num_list == '\0')
uiout->message ("No breakpoints or watchpoints.\n");
else
uiout->message ("No breakpoint or watchpoint matching '%s'.\n",
- args);
+ bp_num_list);
}
}
else
static void
info_breakpoints_command (const char *args, int from_tty)
{
- breakpoint_1 (args, 0, NULL);
+ breakpoint_1 (args, false, NULL);
default_collect_info ();
}
static void
info_watchpoints_command (const char *args, int from_tty)
{
- int num_printed = breakpoint_1 (args, 0, is_watchpoint);
+ int num_printed = breakpoint_1 (args, false, is_watchpoint);
struct ui_out *uiout = current_uiout;
if (num_printed == 0)
static void
maintenance_info_breakpoints (const char *args, int from_tty)
{
- breakpoint_1 (args, 1, NULL);
+ breakpoint_1 (args, true, NULL);
default_collect_info ();
}
uiout->field_string ("reason", async_reason_lookup (EXEC_ASYNC_FORK));
uiout->field_string ("disp", bpdisp_text (b->disposition));
}
- uiout->field_int ("bkptno", b->number);
+ uiout->field_signed ("bkptno", b->number);
uiout->text (" (forked process ");
- uiout->field_int ("newpid", c->forked_inferior_pid.pid ());
+ uiout->field_signed ("newpid", c->forked_inferior_pid.pid ());
uiout->text ("), ");
return PRINT_SRC_AND_LOC;
}
if (c->forked_inferior_pid != null_ptid)
{
uiout->text (", process ");
- uiout->field_int ("what", c->forked_inferior_pid.pid ());
+ uiout->field_signed ("what", c->forked_inferior_pid.pid ());
uiout->spaces (1);
}
uiout->field_string ("reason", async_reason_lookup (EXEC_ASYNC_VFORK));
uiout->field_string ("disp", bpdisp_text (b->disposition));
}
- uiout->field_int ("bkptno", b->number);
+ uiout->field_signed ("bkptno", b->number);
uiout->text (" (vforked process ");
- uiout->field_int ("newpid", c->forked_inferior_pid.pid ());
+ uiout->field_signed ("newpid", c->forked_inferior_pid.pid ());
uiout->text ("), ");
return PRINT_SRC_AND_LOC;
}
if (c->forked_inferior_pid != null_ptid)
{
uiout->text (", process ");
- uiout->field_int ("what", c->forked_inferior_pid.pid ());
+ uiout->field_signed ("what", c->forked_inferior_pid.pid ());
uiout->spaces (1);
}
uiout->text ("Temporary catchpoint ");
else
uiout->text ("Catchpoint ");
- uiout->field_int ("bkptno", b->number);
+ uiout->field_signed ("bkptno", b->number);
uiout->text ("\n");
if (uiout->is_mi_like_p ())
uiout->field_string ("disp", bpdisp_text (b->disposition));
uiout->field_string ("reason", async_reason_lookup (EXEC_ASYNC_EXEC));
uiout->field_string ("disp", bpdisp_text (b->disposition));
}
- uiout->field_int ("bkptno", b->number);
+ uiout->field_signed ("bkptno", b->number);
uiout->text (" (exec'd ");
uiout->field_string ("new-exec", c->exec_pathname);
uiout->text ("), ");
b->location = std::move (location);
else
b->location = new_address_location (b->loc->address, NULL, 0);
- b->filter = filter.release ();
+ b->filter = std::move (filter);
}
static void
async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT));
uiout->field_string ("disp", bpdisp_text (b->disposition));
}
- uiout->field_int ("bkptno", b->number);
+ uiout->field_signed ("bkptno", b->number);
uiout->text (", ");
return PRINT_SRC_AND_LOC;
}
ui_out_emit_tuple tuple_emitter (uiout, tuple_name);
- uiout->field_int ("number", b->number);
+ uiout->field_signed ("number", b->number);
uiout->text (": ");
uiout->field_string ("exp", w->exp_string);
}
}
ui_out_emit_tuple tuple_emitter (uiout, tuple_name);
- uiout->field_int ("number", b->number);
+ uiout->field_signed ("number", b->number);
uiout->text (": ");
uiout->field_string ("exp", w->exp_string);
}
/* Tell whether the given watchpoint is a masked hardware watchpoint. */
-static int
+static bool
is_masked_watchpoint (const struct breakpoint *b)
{
return b->ops == &masked_watchpoint_breakpoint_ops;
enough for now, though. */
}
- init_raw_breakpoint (b, gdbarch, sal, bp_breakpoint, ops);
+ init_raw_breakpoint (b, gdbarch, sal, bp_catchpoint, ops);
b->enable_state = enabled ? bp_enabled : bp_disabled;
b->disposition = tempflag ? disp_del : disp_donttouch;
{
xfree (this->cond_string);
xfree (this->extra_string);
- xfree (this->filter);
}
static struct bp_location *
async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT));
uiout->field_string ("disp", bpdisp_text (b->disposition));
}
- uiout->field_int ("bkptno", b->number);
+ uiout->field_signed ("bkptno", b->number);
uiout->text (", ");
return PRINT_SRC_AND_LOC;
uiout->field_string ("fullname", fullname);
}
- uiout->field_int ("line", sal2.line);
+ uiout->field_signed ("line", sal2.line);
uiout->text ("\n");
b->loc->line_number = sal2.line;
decode_line_full (location, DECODE_LINE_FUNFIRSTLINE, search_pspace,
NULL, 0, &canonical, multiple_symbols_all,
- b->filter);
+ b->filter.get ());
/* We should get 0 or 1 resulting SALs. */
gdb_assert (canonical.lsals.size () < 2);
struct ui_out *uiout = current_uiout;
int num_printed;
- num_printed = breakpoint_1 (args, 0, is_tracepoint);
+ num_printed = breakpoint_1 (args, false, is_tracepoint);
if (num_printed == 0)
{
/* 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
- non-zero. */
+ true. */
static void
save_breakpoints (const char *filename, int from_tty,
- int (*filter) (const struct breakpoint *))
+ bool (*filter) (const struct breakpoint *))
{
struct breakpoint *tp;
int any = 0;
set_cmd_completer (c, location_completer);
add_prefix_cmd ("enable", class_breakpoint, enable_command, _("\
-Enable some breakpoints.\n\
+Enable all or some breakpoints.\n\
+Usage: enable [BREAKPOINTNUM]...\n\
Give breakpoint numbers (separated by spaces) as arguments.\n\
With no subcommand, breakpoints are enabled until you command otherwise.\n\
This is used to cancel the effect of the \"disable\" command.\n\
add_com_alias ("en", "enable", class_breakpoint, 1);
add_prefix_cmd ("breakpoints", class_breakpoint, enable_command, _("\
-Enable some breakpoints.\n\
+Enable all or some breakpoints.\n\
+Usage: enable breakpoints [BREAKPOINTNUM]...\n\
Give breakpoint numbers (separated by spaces) as arguments.\n\
This is used to cancel the effect of the \"disable\" command.\n\
May be abbreviated to simply \"enable\"."),
&enablebreaklist, "enable breakpoints ", 1, &enablelist);
add_cmd ("once", no_class, enable_once_command, _("\
-Enable breakpoints for one hit. Give breakpoint numbers.\n\
+Enable some breakpoints for one hit.\n\
+Usage: enable breakpoints once BREAKPOINTNUM...\n\
If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
&enablebreaklist);
add_cmd ("delete", no_class, enable_delete_command, _("\
-Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
+Enable some breakpoints and delete when hit.\n\
+Usage: enable breakpoints delete BREAKPOINTNUM...\n\
If a breakpoint is hit while enabled in this fashion, it is deleted."),
&enablebreaklist);
add_cmd ("count", no_class, enable_count_command, _("\
-Enable breakpoints for COUNT hits. Give count and then breakpoint numbers.\n\
+Enable some breakpoints for COUNT hits.\n\
+Usage: enable breakpoints count COUNT BREAKPOINTNUM...\n\
If a breakpoint is hit while enabled in this fashion,\n\
the count is decremented; when it reaches zero, the breakpoint is disabled."),
&enablebreaklist);
add_cmd ("delete", no_class, enable_delete_command, _("\
-Enable breakpoints and delete when hit. Give breakpoint numbers.\n\
+Enable some breakpoints and delete when hit.\n\
+Usage: enable delete BREAKPOINTNUM...\n\
If a breakpoint is hit while enabled in this fashion, it is deleted."),
&enablelist);
add_cmd ("once", no_class, enable_once_command, _("\
-Enable breakpoints for one hit. Give breakpoint numbers.\n\
+Enable some breakpoints for one hit.\n\
+Usage: enable once BREAKPOINTNUM...\n\
If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
&enablelist);
add_cmd ("count", no_class, enable_count_command, _("\
-Enable breakpoints for COUNT hits. Give count and then breakpoint numbers.\n\
+Enable some breakpoints for COUNT hits.\n\
+Usage: enable count COUNT BREAKPOINTNUM...\n\
If a breakpoint is hit while enabled in this fashion,\n\
the count is decremented; when it reaches zero, the breakpoint is disabled."),
&enablelist);
add_prefix_cmd ("disable", class_breakpoint, disable_command, _("\
-Disable some breakpoints.\n\
+Disable all or some breakpoints.\n\
+Usage: disable [BREAKPOINTNUM]...\n\
Arguments are breakpoint numbers with spaces in between.\n\
To disable all breakpoints, give no argument.\n\
A disabled breakpoint is not forgotten, but has no effect until re-enabled."),
add_com_alias ("disa", "disable", class_breakpoint, 1);
add_cmd ("breakpoints", class_alias, disable_command, _("\
-Disable some breakpoints.\n\
+Disable all or some breakpoints.\n\
+Usage: disable breakpoints [BREAKPOINTNUM]...\n\
Arguments are breakpoint numbers with spaces in between.\n\
To disable all breakpoints, give no argument.\n\
A disabled breakpoint is not forgotten, but has no effect until re-enabled.\n\
&disablelist);
add_prefix_cmd ("delete", class_breakpoint, delete_command, _("\
-Delete some breakpoints or auto-display expressions.\n\
+Delete all or some breakpoints.\n\
+Usage: delete [BREAKPOINTNUM]...\n\
Arguments are breakpoint numbers with spaces in between.\n\
To delete all breakpoints, give no argument.\n\
\n\
-Also a prefix command for deletion of other GDB objects.\n\
-The \"unset\" command is also an alias for \"delete\"."),
+Also a prefix command for deletion of other GDB objects."),
&deletelist, "delete ", 1, &cmdlist);
add_com_alias ("d", "delete", class_breakpoint, 1);
add_com_alias ("del", "delete", class_breakpoint, 1);
add_cmd ("breakpoints", class_alias, delete_command, _("\
-Delete some breakpoints or auto-display expressions.\n\
+Delete all or some breakpoints or auto-display expressions.\n\
+Usage: delete breakpoints [BREAKPOINTNUM]...\n\
Arguments are breakpoint numbers with spaces in between.\n\
To delete all breakpoints, give no argument.\n\
This command may be abbreviated \"delete\"."),
deprecate_cmd (c, "save tracepoints");
add_prefix_cmd ("breakpoint", class_maintenance, set_breakpoint_cmd, _("\
-Breakpoint specific settings\n\
+Breakpoint specific settings.\n\
Configure various breakpoint-specific variables such as\n\
-pending breakpoint behavior"),
+pending breakpoint behavior."),
&breakpoint_set_cmdlist, "set breakpoint ",
0/*allow-unknown*/, &setlist);
add_prefix_cmd ("breakpoint", class_maintenance, show_breakpoint_cmd, _("\
-Breakpoint specific settings\n\
+Breakpoint specific settings.\n\
Configure various breakpoint-specific variables such as\n\
-pending breakpoint behavior"),
+pending breakpoint behavior."),
&breakpoint_show_cmdlist, "show breakpoint ",
0/*allow-unknown*/, &showlist);
dprintf_function = xstrdup ("printf");
add_setshow_string_cmd ("dprintf-function", class_support,
&dprintf_function, _("\
-Set the function to use for dynamic printf"), _("\
-Show the function to use for dynamic printf"), NULL,
+Set the function to use for dynamic printf."), _("\
+Show the function to use for dynamic printf."), NULL,
update_dprintf_commands, NULL,
&setlist, &showlist);
dprintf_channel = xstrdup ("");
add_setshow_string_cmd ("dprintf-channel", class_support,
&dprintf_channel, _("\
-Set the channel to use for dynamic printf"), _("\
-Show the channel to use for dynamic printf"), NULL,
+Set the channel to use for dynamic printf."), _("\
+Show the channel to use for dynamic printf."), NULL,
update_dprintf_commands, NULL,
&setlist, &showlist);
&setlist, &showlist);
add_com ("agent-printf", class_vars, agent_printf_command, _("\
-agent-printf \"printf format string\", arg1, arg2, arg3, ..., argn\n\
-(target agent only) This is useful for formatted output in user-defined commands."));
+Target agent only formatted printing, like the C \"printf\" function.\n\
+Usage: agent-printf \"format string\", ARG1, ARG2, ARG3, ..., ARGN\n\
+This supports most C printf format specifications, like %s, %d, etc.\n\
+This is useful for formatted output in user-defined commands."));
automatic_hardware_breakpoints = 1;
projects / external / binutils.git / blobdiff