1 /* MI Command Set - breakpoint and watchpoint commands.
2 Copyright (C) 2000-2013 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 "gdb_string.h"
27 #include "mi-getopt.h"
29 #include "exceptions.h"
32 #include "mi-cmd-break.h"
33 #include "gdb_obstack.h"
41 /* True if MI breakpoint observers have been registered. */
43 static int mi_breakpoint_observers_installed
;
45 /* Control whether breakpoint_notify may act. */
47 static int mi_can_breakpoint_notify
;
49 /* Output a single breakpoint, when allowed. */
52 breakpoint_notify (struct breakpoint
*b
)
54 if (mi_can_breakpoint_notify
)
55 gdb_breakpoint_query (current_uiout
, b
->number
, NULL
);
65 /* Arrange for all new breakpoints and catchpoints to be reported to
66 CURRENT_UIOUT until the cleanup returned by this function is run.
68 Note that MI output will be probably invalid if more than one
69 breakpoint is created inside one MI command. */
72 setup_breakpoint_reporting (void)
74 struct cleanup
*rev_flag
;
76 if (! mi_breakpoint_observers_installed
)
78 observer_attach_breakpoint_created (breakpoint_notify
);
79 mi_breakpoint_observers_installed
= 1;
82 rev_flag
= make_cleanup_restore_integer (&mi_can_breakpoint_notify
);
83 mi_can_breakpoint_notify
= 1;
89 /* Convert arguments in ARGV to the string in "format",argv,argv...
93 mi_argv_to_format (char **argv
, int argc
)
96 struct obstack obstack
;
99 obstack_init (&obstack
);
101 /* Convert ARGV[OIND + 1] to format string and save to FORMAT. */
102 obstack_1grow (&obstack
, '\"');
103 for (i
= 0; i
< strlen (argv
[0]); i
++)
108 obstack_grow (&obstack
, "\\\\", 2);
111 obstack_grow (&obstack
, "\\a", 2);
114 obstack_grow (&obstack
, "\\b", 2);
117 obstack_grow (&obstack
, "\\f", 2);
120 obstack_grow (&obstack
, "\\n", 2);
123 obstack_grow (&obstack
, "\\r", 2);
126 obstack_grow (&obstack
, "\\t", 2);
129 obstack_grow (&obstack
, "\\v", 2);
132 obstack_grow (&obstack
, "\\\"", 2);
135 if (isprint (argv
[0][i
]))
136 obstack_grow (&obstack
, argv
[0] + i
, 1);
141 xsnprintf (tmp
, sizeof (tmp
), "\\%o",
142 (unsigned char) argv
[0][i
]);
143 obstack_grow (&obstack
, tmp
, strlen (tmp
));
148 obstack_1grow (&obstack
, '\"');
150 /* Apply other argv to FORMAT. */
151 for (i
= 1; i
< argc
; i
++)
153 obstack_1grow (&obstack
, ',');
154 obstack_grow (&obstack
, argv
[i
], strlen (argv
[i
]));
156 obstack_1grow (&obstack
, '\0');
158 ret
= xstrdup (obstack_finish (&obstack
));
159 obstack_free (&obstack
, NULL
);
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
, char *command
, char **argv
, int argc
)
171 char *address
= NULL
;
175 int ignore_count
= 0;
176 char *condition
= NULL
;
180 struct cleanup
*back_to
= make_cleanup (null_cleanup
, NULL
);
181 enum bptype type_wanted
;
182 struct breakpoint_ops
*ops
;
183 char *extra_string
= NULL
;
187 HARDWARE_OPT
, TEMP_OPT
, CONDITION_OPT
,
188 IGNORE_COUNT_OPT
, THREAD_OPT
, PENDING_OPT
, DISABLE_OPT
,
191 static const struct mi_opt opts
[] =
193 {"h", HARDWARE_OPT
, 0},
195 {"c", CONDITION_OPT
, 1},
196 {"i", IGNORE_COUNT_OPT
, 1},
197 {"p", THREAD_OPT
, 1},
198 {"f", PENDING_OPT
, 0},
199 {"d", DISABLE_OPT
, 0},
200 {"a", TRACEPOINT_OPT
, 0},
204 /* Parse arguments. It could be -r or -h or -t, <location> or ``--''
205 to denote the end of the option list. */
211 int opt
= mi_getopt ("-break-insert", argc
, argv
,
215 switch ((enum opt
) opt
)
226 case IGNORE_COUNT_OPT
:
227 ignore_count
= atol (oarg
);
230 thread
= atol (oarg
);
245 error (_("-%s-insert: Missing <location>"),
246 dprintf
? "dprintf" : "break");
247 address
= argv
[oind
];
250 int format_num
= oind
+ 1;
252 if (hardware
|| tracepoint
)
253 error (_("-dprintf-insert: does not support -h or -a"));
254 if (format_num
>= argc
)
255 error (_("-dprintf-insert: Missing <format>"));
257 extra_string
= mi_argv_to_format (argv
+ format_num
, argc
- format_num
);
258 make_cleanup (xfree
, extra_string
);
263 error (_("-break-insert: Garbage following <location>"));
266 /* Now we have what we need, let's insert the breakpoint! */
267 setup_breakpoint_reporting ();
271 /* Note that to request a fast tracepoint, the client uses the
272 "hardware" flag, although there's nothing of hardware related to
273 fast tracepoints -- one can implement slow tracepoints with
274 hardware breakpoints, but fast tracepoints are always software.
275 "fast" is a misnomer, actually, "jump" would be more appropriate.
276 A simulator or an emulator could conceivably implement fast
277 regular non-jump based tracepoints. */
278 type_wanted
= hardware
? bp_fast_tracepoint
: bp_tracepoint
;
279 ops
= &tracepoint_breakpoint_ops
;
283 type_wanted
= bp_dprintf
;
284 ops
= &dprintf_breakpoint_ops
;
288 type_wanted
= hardware
? bp_hardware_breakpoint
: bp_breakpoint
;
289 ops
= &bkpt_breakpoint_ops
;
292 create_breakpoint (get_current_arch (), address
, condition
, thread
,
294 0 /* condition and thread are valid. */,
297 pending
? AUTO_BOOLEAN_TRUE
: AUTO_BOOLEAN_FALSE
,
298 ops
, 0, enabled
, 0, 0);
299 do_cleanups (back_to
);
302 /* Implements the -break-insert command.
303 See the MI manual for the list of possible options. */
306 mi_cmd_break_insert (char *command
, char **argv
, int argc
)
308 mi_cmd_break_insert_1 (0, command
, argv
, argc
);
311 /* Implements the -dprintf-insert command.
312 See the MI manual for the list of possible options. */
315 mi_cmd_dprintf_insert (char *command
, char **argv
, int argc
)
317 mi_cmd_break_insert_1 (1, command
, argv
, argc
);
328 mi_cmd_break_passcount (char *command
, char **argv
, int argc
)
332 struct tracepoint
*t
;
335 error (_("Usage: tracepoint-number passcount"));
339 t
= get_tracepoint (n
);
344 observer_notify_breakpoint_modified (&t
->base
);
348 error (_("Could not find tracepoint %d"), n
);
352 /* Insert a watchpoint. The type of watchpoint is specified by the
354 -break-watch <expr> --> insert a regular wp.
355 -break-watch -r <expr> --> insert a read watchpoint.
356 -break-watch -a <expr> --> insert an access wp. */
359 mi_cmd_break_watch (char *command
, char **argv
, int argc
)
362 enum wp_type type
= REG_WP
;
367 static const struct mi_opt opts
[] =
370 {"a", ACCESS_OPT
, 0},
374 /* Parse arguments. */
380 int opt
= mi_getopt ("-break-watch", argc
, argv
,
385 switch ((enum opt
) opt
)
396 error (_("-break-watch: Missing <expression>"));
398 error (_("-break-watch: Garbage following <expression>"));
401 /* Now we have what we need, let's insert the watchpoint! */
405 watch_command_wrapper (expr
, FROM_TTY
, 0);
408 rwatch_command_wrapper (expr
, FROM_TTY
, 0);
411 awatch_command_wrapper (expr
, FROM_TTY
, 0);
414 error (_("-break-watch: Unknown watchpoint type."));
418 /* The mi_read_next_line consults these variable to return successive
419 command lines. While it would be clearer to use a closure pointer,
420 it is not expected that any future code will use read_command_lines_1,
421 therefore no point of overengineering. */
423 static char **mi_command_line_array
;
424 static int mi_command_line_array_cnt
;
425 static int mi_command_line_array_ptr
;
428 mi_read_next_line (void)
430 if (mi_command_line_array_ptr
== mi_command_line_array_cnt
)
433 return mi_command_line_array
[mi_command_line_array_ptr
++];
437 mi_cmd_break_commands (char *command
, char **argv
, int argc
)
439 struct command_line
*break_command
;
442 struct breakpoint
*b
;
445 error (_("USAGE: %s <BKPT> [<COMMAND> [<COMMAND>...]]"), command
);
447 bnum
= strtol (argv
[0], &endptr
, 0);
448 if (endptr
== argv
[0])
449 error (_("breakpoint number argument \"%s\" is not a number."),
451 else if (*endptr
!= '\0')
452 error (_("junk at the end of breakpoint number argument \"%s\"."),
455 b
= get_breakpoint (bnum
);
457 error (_("breakpoint %d not found."), bnum
);
459 mi_command_line_array
= argv
;
460 mi_command_line_array_ptr
= 1;
461 mi_command_line_array_cnt
= argc
;
463 if (is_tracepoint (b
))
464 break_command
= read_command_lines_1 (mi_read_next_line
, 1,
465 check_tracepoint_command
, b
);
467 break_command
= read_command_lines_1 (mi_read_next_line
, 1, 0, 0);
469 breakpoint_set_commands (b
, break_command
);