1 /* MI Command Set - breakpoint and watchpoint commands.
2 Copyright (C) 2000-2023 Free Software Foundation, Inc.
3 Contributed by Cygnus Solutions (a Red Hat company).
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 #include "arch-utils.h"
25 #include "breakpoint.h"
26 #include "mi-getopt.h"
27 #include "observable.h"
29 #include "mi-cmd-break.h"
33 #include "gdbsupport/gdb_obstack.h"
35 #include "tracepoint.h"
42 /* True if MI breakpoint observers have been registered. */
44 static int mi_breakpoint_observers_installed
;
46 /* Control whether breakpoint_notify may act. */
48 static int mi_can_breakpoint_notify
;
50 /* Output a single breakpoint, when allowed. */
53 breakpoint_notify (struct breakpoint
*b
)
55 if (mi_can_breakpoint_notify
)
61 catch (const gdb_exception
&ex
)
63 exception_print (gdb_stderr
, ex
);
75 /* Arrange for all new breakpoints and catchpoints to be reported to
76 CURRENT_UIOUT until the destructor of the returned scoped_restore
79 Note that MI output will be probably invalid if more than one
80 breakpoint is created inside one MI command. */
82 scoped_restore_tmpl
<int>
83 setup_breakpoint_reporting (void)
85 if (! mi_breakpoint_observers_installed
)
87 gdb::observers::breakpoint_created
.attach (breakpoint_notify
,
89 mi_breakpoint_observers_installed
= 1;
92 return make_scoped_restore (&mi_can_breakpoint_notify
, 1);
96 /* Convert arguments in ARGV to the string in "format",argv,argv...
100 mi_argv_to_format (char **argv
, int argc
)
105 /* Convert ARGV[OIND + 1] to format string and save to FORMAT. */
107 for (i
= 0; i
< strlen (argv
[0]); i
++)
139 if (isprint (argv
[0][i
]))
140 result
+= argv
[0][i
];
145 xsnprintf (tmp
, sizeof (tmp
), "\\%o",
146 (unsigned char) argv
[0][i
]);
154 /* Apply other argv to FORMAT. */
155 for (i
= 1; i
< argc
; i
++)
164 /* Insert breakpoint.
165 If dprintf is true, it will insert dprintf.
166 If not, it will insert other type breakpoint. */
169 mi_cmd_break_insert_1 (int dprintf
, const char *command
, char **argv
, int argc
)
171 const char *address
= NULL
;
175 int ignore_count
= 0;
176 char *condition
= NULL
;
180 symbol_name_match_type match_type
= symbol_name_match_type::WILD
;
181 enum bptype type_wanted
;
182 location_spec_up locspec
;
183 const struct breakpoint_ops
*ops
;
185 std::unique_ptr
<explicit_location_spec
> explicit_loc
186 (new explicit_location_spec ());
187 std::string extra_string
;
188 bool force_condition
= false;
192 HARDWARE_OPT
, TEMP_OPT
, CONDITION_OPT
,
193 IGNORE_COUNT_OPT
, THREAD_OPT
, PENDING_OPT
, DISABLE_OPT
,
197 EXPLICIT_SOURCE_OPT
, EXPLICIT_FUNC_OPT
,
198 EXPLICIT_LABEL_OPT
, EXPLICIT_LINE_OPT
200 static const struct mi_opt opts
[] =
202 {"h", HARDWARE_OPT
, 0},
204 {"c", CONDITION_OPT
, 1},
205 {"i", IGNORE_COUNT_OPT
, 1},
206 {"p", THREAD_OPT
, 1},
207 {"f", PENDING_OPT
, 0},
208 {"d", DISABLE_OPT
, 0},
209 {"a", TRACEPOINT_OPT
, 0},
210 {"-force-condition", FORCE_CONDITION_OPT
, 0},
211 {"-qualified", QUALIFIED_OPT
, 0},
212 {"-source" , EXPLICIT_SOURCE_OPT
, 1},
213 {"-function", EXPLICIT_FUNC_OPT
, 1},
214 {"-label", EXPLICIT_LABEL_OPT
, 1},
215 {"-line", EXPLICIT_LINE_OPT
, 1},
219 /* Parse arguments. It could be -r or -h or -t, <location> or ``--''
220 to denote the end of the option list. */
226 int opt
= mi_getopt ("-break-insert", argc
, argv
,
230 switch ((enum opt
) opt
)
241 case IGNORE_COUNT_OPT
:
242 ignore_count
= atol (oarg
);
245 thread
= atol (oarg
);
257 match_type
= symbol_name_match_type::FULL
;
259 case EXPLICIT_SOURCE_OPT
:
261 explicit_loc
->source_filename
= xstrdup (oarg
);
263 case EXPLICIT_FUNC_OPT
:
265 explicit_loc
->function_name
= xstrdup (oarg
);
267 case EXPLICIT_LABEL_OPT
:
269 explicit_loc
->label_name
= xstrdup (oarg
);
271 case EXPLICIT_LINE_OPT
:
273 explicit_loc
->line_offset
= linespec_parse_line_offset (oarg
);
275 case FORCE_CONDITION_OPT
:
276 force_condition
= true;
281 if (oind
>= argc
&& !is_explicit
)
282 error (_("-%s-insert: Missing <location>"),
283 dprintf
? "dprintf" : "break");
286 int format_num
= is_explicit
? oind
: oind
+ 1;
288 if (hardware
|| tracepoint
)
289 error (_("-dprintf-insert: does not support -h or -a"));
290 if (format_num
>= argc
)
291 error (_("-dprintf-insert: Missing <format>"));
293 extra_string
= mi_argv_to_format (argv
+ format_num
, argc
- format_num
);
294 address
= argv
[oind
];
301 error (_("-break-insert: Garbage following explicit location"));
306 error (_("-break-insert: Garbage following <location>"));
307 address
= argv
[oind
];
311 /* Now we have what we need, let's insert the breakpoint! */
312 scoped_restore restore_breakpoint_reporting
= setup_breakpoint_reporting ();
316 /* Note that to request a fast tracepoint, the client uses the
317 "hardware" flag, although there's nothing of hardware related to
318 fast tracepoints -- one can implement slow tracepoints with
319 hardware breakpoints, but fast tracepoints are always software.
320 "fast" is a misnomer, actually, "jump" would be more appropriate.
321 A simulator or an emulator could conceivably implement fast
322 regular non-jump based tracepoints. */
323 type_wanted
= hardware
? bp_fast_tracepoint
: bp_tracepoint
;
324 ops
= breakpoint_ops_for_location_spec (nullptr, true);
328 type_wanted
= bp_dprintf
;
329 ops
= &code_breakpoint_ops
;
333 type_wanted
= hardware
? bp_hardware_breakpoint
: bp_breakpoint
;
334 ops
= &code_breakpoint_ops
;
339 /* Error check -- we must have one of the other
340 parameters specified. */
341 if (explicit_loc
->source_filename
!= NULL
342 && explicit_loc
->function_name
== NULL
343 && explicit_loc
->label_name
== NULL
344 && explicit_loc
->line_offset
.sign
== LINE_OFFSET_UNKNOWN
)
345 error (_("-%s-insert: --source option requires --function, --label,"
346 " or --line"), dprintf
? "dprintf" : "break");
348 explicit_loc
->func_name_match_type
= match_type
;
350 locspec
= std::move (explicit_loc
);
354 locspec
= string_to_location_spec_basic (&address
, current_language
,
357 error (_("Garbage '%s' at end of location"), address
);
360 create_breakpoint (get_current_arch (), locspec
.get (), condition
, thread
,
361 extra_string
.c_str (),
363 0 /* condition and thread are valid. */,
366 pending
? AUTO_BOOLEAN_TRUE
: AUTO_BOOLEAN_FALSE
,
367 ops
, 0, enabled
, 0, 0);
370 /* Implements the -break-insert command.
371 See the MI manual for the list of possible options. */
374 mi_cmd_break_insert (const char *command
, char **argv
, int argc
)
376 mi_cmd_break_insert_1 (0, command
, argv
, argc
);
379 /* Implements the -dprintf-insert command.
380 See the MI manual for the list of possible options. */
383 mi_cmd_dprintf_insert (const char *command
, char **argv
, int argc
)
385 mi_cmd_break_insert_1 (1, command
, argv
, argc
);
388 /* Implements the -break-condition command.
389 See the MI manual for the list of options. */
392 mi_cmd_break_condition (const char *command
, char **argv
, int argc
)
399 static const struct mi_opt opts
[] =
401 {"-force", FORCE_CONDITION_OPT
, 0},
405 /* Parse arguments. */
408 bool force_condition
= false;
412 int opt
= mi_getopt ("-break-condition", argc
, argv
,
419 case FORCE_CONDITION_OPT
:
420 force_condition
= true;
425 /* There must be at least one more arg: a bpnum. */
427 error (_("-break-condition: Missing the <number> argument"));
429 int bpnum
= atoi (argv
[oind
]);
431 /* The rest form the condition expr. */
432 std::string expr
= "";
433 for (int i
= oind
+ 1; i
< argc
; ++i
)
440 set_breakpoint_condition (bpnum
, expr
.c_str (), 0 /* from_tty */,
452 mi_cmd_break_passcount (const char *command
, char **argv
, int argc
)
456 struct tracepoint
*t
;
459 error (_("Usage: tracepoint-number passcount"));
463 t
= get_tracepoint (n
);
468 gdb::observers::breakpoint_modified
.notify (t
);
472 error (_("Could not find tracepoint %d"), n
);
476 /* Insert a watchpoint. The type of watchpoint is specified by the
478 -break-watch <expr> --> insert a regular wp.
479 -break-watch -r <expr> --> insert a read watchpoint.
480 -break-watch -a <expr> --> insert an access wp. */
483 mi_cmd_break_watch (const char *command
, char **argv
, int argc
)
486 enum wp_type type
= REG_WP
;
491 static const struct mi_opt opts
[] =
494 {"a", ACCESS_OPT
, 0},
498 /* Parse arguments. */
504 int opt
= mi_getopt ("-break-watch", argc
, argv
,
509 switch ((enum opt
) opt
)
520 error (_("-break-watch: Missing <expression>"));
522 error (_("-break-watch: Garbage following <expression>"));
525 /* Now we have what we need, let's insert the watchpoint! */
529 watch_command_wrapper (expr
, FROM_TTY
, false);
532 rwatch_command_wrapper (expr
, FROM_TTY
, false);
535 awatch_command_wrapper (expr
, FROM_TTY
, false);
538 error (_("-break-watch: Unknown watchpoint type."));
543 mi_cmd_break_commands (const char *command
, char **argv
, int argc
)
545 counted_command_line break_command
;
548 struct breakpoint
*b
;
551 error (_("USAGE: %s <BKPT> [<COMMAND> [<COMMAND>...]]"), command
);
553 bnum
= strtol (argv
[0], &endptr
, 0);
554 if (endptr
== argv
[0])
555 error (_("breakpoint number argument \"%s\" is not a number."),
557 else if (*endptr
!= '\0')
558 error (_("junk at the end of breakpoint number argument \"%s\"."),
561 b
= get_breakpoint (bnum
);
563 error (_("breakpoint %d not found."), bnum
);
567 = [&] (std::string
&buffer
)
569 const char *result
= nullptr;
571 result
= argv
[count
++];
575 if (is_tracepoint (b
))
576 break_command
= read_command_lines_1 (reader
, 1,
577 [=] (const char *line
)
579 validate_actionline (line
, b
);
582 break_command
= read_command_lines_1 (reader
, 1, 0);
584 breakpoint_set_commands (b
, std::move (break_command
));