1 /* Everything about signal catchpoints, for GDB.
3 Copyright (C) 2011-2016 Free Software Foundation, Inc.
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"
23 #include "breakpoint.h"
29 #include "cli/cli-utils.h"
30 #include "completer.h"
31 #include "gdb_obstack.h"
33 #define INTERNAL_SIGNAL(x) ((x) == GDB_SIGNAL_TRAP || (x) == GDB_SIGNAL_INT)
35 typedef enum gdb_signal gdb_signal_type
;
37 DEF_VEC_I (gdb_signal_type
);
39 /* An instance of this type is used to represent a signal catchpoint.
40 It includes a "struct breakpoint" as a kind of base class; users
41 downcast to "struct breakpoint *" when needed. A breakpoint is
42 really of this type iff its ops pointer points to
43 SIGNAL_CATCHPOINT_OPS. */
45 struct signal_catchpoint
49 struct breakpoint base
;
51 /* Signal numbers used for the 'catch signal' feature. If no signal
52 has been specified for filtering, its value is NULL. Otherwise,
53 it holds a list of all signals to be caught. */
55 VEC (gdb_signal_type
) *signals_to_be_caught
;
57 /* If SIGNALS_TO_BE_CAUGHT is NULL, then all "ordinary" signals are
58 caught. If CATCH_ALL is non-zero, then internal signals are
59 caught as well. If SIGNALS_TO_BE_CAUGHT is non-NULL, then this
65 /* The breakpoint_ops structure to be used in signal catchpoints. */
67 static struct breakpoint_ops signal_catchpoint_ops
;
69 /* Count of each signal. */
71 static unsigned int *signal_catch_counts
;
75 /* A convenience wrapper for gdb_signal_to_name that returns the
76 integer value if the name is not known. */
79 signal_to_name_or_int (enum gdb_signal sig
)
81 const char *result
= gdb_signal_to_name (sig
);
83 if (strcmp (result
, "?") == 0)
84 result
= plongest (sig
);
91 /* Implement the "dtor" breakpoint_ops method for signal
95 signal_catchpoint_dtor (struct breakpoint
*b
)
97 struct signal_catchpoint
*c
= (struct signal_catchpoint
*) b
;
99 VEC_free (gdb_signal_type
, c
->signals_to_be_caught
);
101 base_breakpoint_ops
.dtor (b
);
104 /* Implement the "insert_location" breakpoint_ops method for signal
108 signal_catchpoint_insert_location (struct bp_location
*bl
)
110 struct signal_catchpoint
*c
= (struct signal_catchpoint
*) bl
->owner
;
113 if (c
->signals_to_be_caught
!= NULL
)
115 gdb_signal_type iter
;
118 VEC_iterate (gdb_signal_type
, c
->signals_to_be_caught
, i
, iter
);
120 ++signal_catch_counts
[iter
];
124 for (i
= 0; i
< GDB_SIGNAL_LAST
; ++i
)
126 if (c
->catch_all
|| !INTERNAL_SIGNAL (i
))
127 ++signal_catch_counts
[i
];
131 signal_catch_update (signal_catch_counts
);
136 /* Implement the "remove_location" breakpoint_ops method for signal
140 signal_catchpoint_remove_location (struct bp_location
*bl
,
141 enum remove_bp_reason reason
)
143 struct signal_catchpoint
*c
= (struct signal_catchpoint
*) bl
->owner
;
146 if (c
->signals_to_be_caught
!= NULL
)
148 gdb_signal_type iter
;
151 VEC_iterate (gdb_signal_type
, c
->signals_to_be_caught
, i
, iter
);
154 gdb_assert (signal_catch_counts
[iter
] > 0);
155 --signal_catch_counts
[iter
];
160 for (i
= 0; i
< GDB_SIGNAL_LAST
; ++i
)
162 if (c
->catch_all
|| !INTERNAL_SIGNAL (i
))
164 gdb_assert (signal_catch_counts
[i
] > 0);
165 --signal_catch_counts
[i
];
170 signal_catch_update (signal_catch_counts
);
175 /* Implement the "breakpoint_hit" breakpoint_ops method for signal
179 signal_catchpoint_breakpoint_hit (const struct bp_location
*bl
,
180 struct address_space
*aspace
,
182 const struct target_waitstatus
*ws
)
184 const struct signal_catchpoint
*c
185 = (const struct signal_catchpoint
*) bl
->owner
;
186 gdb_signal_type signal_number
;
188 if (ws
->kind
!= TARGET_WAITKIND_STOPPED
)
191 signal_number
= ws
->value
.sig
;
193 /* If we are catching specific signals in this breakpoint, then we
194 must guarantee that the called signal is the same signal we are
196 if (c
->signals_to_be_caught
)
199 gdb_signal_type iter
;
202 VEC_iterate (gdb_signal_type
, c
->signals_to_be_caught
, i
, iter
);
204 if (signal_number
== iter
)
211 return c
->catch_all
|| !INTERNAL_SIGNAL (signal_number
);
214 /* Implement the "print_it" breakpoint_ops method for signal
217 static enum print_stop_action
218 signal_catchpoint_print_it (bpstat bs
)
220 struct breakpoint
*b
= bs
->breakpoint_at
;
222 struct target_waitstatus last
;
223 const char *signal_name
;
224 struct ui_out
*uiout
= current_uiout
;
226 get_last_target_status (&ptid
, &last
);
228 signal_name
= signal_to_name_or_int (last
.value
.sig
);
230 annotate_catchpoint (b
->number
);
231 maybe_print_thread_hit_breakpoint (uiout
);
233 printf_filtered (_("Catchpoint %d (signal %s), "), b
->number
, signal_name
);
235 return PRINT_SRC_AND_LOC
;
238 /* Implement the "print_one" breakpoint_ops method for signal
242 signal_catchpoint_print_one (struct breakpoint
*b
,
243 struct bp_location
**last_loc
)
245 struct signal_catchpoint
*c
= (struct signal_catchpoint
*) b
;
246 struct value_print_options opts
;
247 struct ui_out
*uiout
= current_uiout
;
249 get_user_print_options (&opts
);
251 /* Field 4, the address, is omitted (which makes the columns
252 not line up too nicely with the headers, but the effect
253 is relatively readable). */
254 if (opts
.addressprint
)
255 ui_out_field_skip (uiout
, "addr");
258 if (c
->signals_to_be_caught
259 && VEC_length (gdb_signal_type
, c
->signals_to_be_caught
) > 1)
260 ui_out_text (uiout
, "signals \"");
262 ui_out_text (uiout
, "signal \"");
264 if (c
->signals_to_be_caught
)
267 gdb_signal_type iter
;
269 struct cleanup
*cleanup
;
271 obstack_init (&text
);
272 cleanup
= make_cleanup_obstack_free (&text
);
275 VEC_iterate (gdb_signal_type
, c
->signals_to_be_caught
, i
, iter
);
278 const char *name
= signal_to_name_or_int (iter
);
281 obstack_grow (&text
, " ", 1);
282 obstack_grow (&text
, name
, strlen (name
));
284 obstack_grow (&text
, "", 1);
285 ui_out_field_string (uiout
, "what", (const char *) obstack_base (&text
));
286 do_cleanups (cleanup
);
289 ui_out_field_string (uiout
, "what",
290 c
->catch_all
? "<any signal>" : "<standard signals>");
291 ui_out_text (uiout
, "\" ");
293 if (ui_out_is_mi_like_p (uiout
))
294 ui_out_field_string (uiout
, "catch-type", "signal");
297 /* Implement the "print_mention" breakpoint_ops method for signal
301 signal_catchpoint_print_mention (struct breakpoint
*b
)
303 struct signal_catchpoint
*c
= (struct signal_catchpoint
*) b
;
305 if (c
->signals_to_be_caught
)
308 gdb_signal_type iter
;
310 if (VEC_length (gdb_signal_type
, c
->signals_to_be_caught
) > 1)
311 printf_filtered (_("Catchpoint %d (signals"), b
->number
);
313 printf_filtered (_("Catchpoint %d (signal"), b
->number
);
316 VEC_iterate (gdb_signal_type
, c
->signals_to_be_caught
, i
, iter
);
319 const char *name
= signal_to_name_or_int (iter
);
321 printf_filtered (" %s", name
);
323 printf_filtered (")");
325 else if (c
->catch_all
)
326 printf_filtered (_("Catchpoint %d (any signal)"), b
->number
);
328 printf_filtered (_("Catchpoint %d (standard signals)"), b
->number
);
331 /* Implement the "print_recreate" breakpoint_ops method for signal
335 signal_catchpoint_print_recreate (struct breakpoint
*b
, struct ui_file
*fp
)
337 struct signal_catchpoint
*c
= (struct signal_catchpoint
*) b
;
339 fprintf_unfiltered (fp
, "catch signal");
341 if (c
->signals_to_be_caught
)
344 gdb_signal_type iter
;
347 VEC_iterate (gdb_signal_type
, c
->signals_to_be_caught
, i
, iter
);
349 fprintf_unfiltered (fp
, " %s", signal_to_name_or_int (iter
));
351 else if (c
->catch_all
)
352 fprintf_unfiltered (fp
, " all");
353 fputc_unfiltered ('\n', fp
);
356 /* Implement the "explains_signal" breakpoint_ops method for signal
360 signal_catchpoint_explains_signal (struct breakpoint
*b
, enum gdb_signal sig
)
365 /* Create a new signal catchpoint. TEMPFLAG is true if this should be
366 a temporary catchpoint. FILTER is the list of signals to catch; it
367 can be NULL, meaning all signals. CATCH_ALL is a flag indicating
368 whether signals used internally by gdb should be caught; it is only
369 valid if FILTER is NULL. If FILTER is NULL and CATCH_ALL is zero,
370 then internal signals like SIGTRAP are not caught. */
373 create_signal_catchpoint (int tempflag
, VEC (gdb_signal_type
) *filter
,
376 struct signal_catchpoint
*c
;
377 struct gdbarch
*gdbarch
= get_current_arch ();
379 c
= XNEW (struct signal_catchpoint
);
380 init_catchpoint (&c
->base
, gdbarch
, tempflag
, NULL
, &signal_catchpoint_ops
);
381 c
->signals_to_be_caught
= filter
;
382 c
->catch_all
= catch_all
;
384 install_breakpoint (0, &c
->base
, 1);
388 /* Splits the argument using space as delimiter. Returns an xmalloc'd
389 filter list, or NULL if no filtering is required. */
391 static VEC (gdb_signal_type
) *
392 catch_signal_split_args (char *arg
, int *catch_all
)
394 VEC (gdb_signal_type
) *result
= NULL
;
395 struct cleanup
*cleanup
= make_cleanup (VEC_cleanup (gdb_signal_type
),
402 gdb_signal_type signal_number
;
403 char *one_arg
, *endptr
;
404 struct cleanup
*inner_cleanup
;
406 one_arg
= extract_arg (&arg
);
409 inner_cleanup
= make_cleanup (xfree
, one_arg
);
411 /* Check for the special flag "all". */
412 if (strcmp (one_arg
, "all") == 0)
414 arg
= skip_spaces (arg
);
415 if (*arg
!= '\0' || !first
)
416 error (_("'all' cannot be caught with other signals"));
418 gdb_assert (result
== NULL
);
419 do_cleanups (inner_cleanup
);
420 discard_cleanups (cleanup
);
426 /* Check if the user provided a signal name or a number. */
427 num
= (int) strtol (one_arg
, &endptr
, 0);
429 signal_number
= gdb_signal_from_command (num
);
432 signal_number
= gdb_signal_from_name (one_arg
);
433 if (signal_number
== GDB_SIGNAL_UNKNOWN
)
434 error (_("Unknown signal name '%s'."), one_arg
);
437 VEC_safe_push (gdb_signal_type
, result
, signal_number
);
438 do_cleanups (inner_cleanup
);
441 discard_cleanups (cleanup
);
445 /* Implement the "catch signal" command. */
448 catch_signal_command (char *arg
, int from_tty
,
449 struct cmd_list_element
*command
)
451 int tempflag
, catch_all
= 0;
452 VEC (gdb_signal_type
) *filter
;
454 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
456 arg
= skip_spaces (arg
);
458 /* The allowed syntax is:
460 catch signal <name | number> [<name | number> ... <name | number>]
462 Let's check if there's a signal name. */
465 filter
= catch_signal_split_args (arg
, &catch_all
);
469 create_signal_catchpoint (tempflag
, filter
, catch_all
);
473 initialize_signal_catchpoint_ops (void)
475 struct breakpoint_ops
*ops
;
477 initialize_breakpoint_ops ();
479 ops
= &signal_catchpoint_ops
;
480 *ops
= base_breakpoint_ops
;
481 ops
->dtor
= signal_catchpoint_dtor
;
482 ops
->insert_location
= signal_catchpoint_insert_location
;
483 ops
->remove_location
= signal_catchpoint_remove_location
;
484 ops
->breakpoint_hit
= signal_catchpoint_breakpoint_hit
;
485 ops
->print_it
= signal_catchpoint_print_it
;
486 ops
->print_one
= signal_catchpoint_print_one
;
487 ops
->print_mention
= signal_catchpoint_print_mention
;
488 ops
->print_recreate
= signal_catchpoint_print_recreate
;
489 ops
->explains_signal
= signal_catchpoint_explains_signal
;
492 initialize_file_ftype _initialize_break_catch_sig
;
495 _initialize_break_catch_sig (void)
497 initialize_signal_catchpoint_ops ();
499 signal_catch_counts
= XCNEWVEC (unsigned int, GDB_SIGNAL_LAST
);
501 add_catch_command ("signal", _("\
502 Catch signals by their names and/or numbers.\n\
503 Usage: catch signal [[NAME|NUMBER] [NAME|NUMBER]...|all]\n\
504 Arguments say which signals to catch. If no arguments\n\
505 are given, every \"normal\" signal will be caught.\n\
506 The argument \"all\" means to also catch signals used by GDB.\n\
507 Arguments, if given, should be one or more signal names\n\
508 (if your system supports that), or signal numbers."),
509 catch_signal_command
,