1 /* Everything about signal catchpoints, for GDB.
3 Copyright (C) 2011-2017 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"
34 #define INTERNAL_SIGNAL(x) ((x) == GDB_SIGNAL_TRAP || (x) == GDB_SIGNAL_INT)
36 /* An instance of this type is used to represent a signal catchpoint.
37 A breakpoint is really of this type iff its ops pointer points to
38 SIGNAL_CATCHPOINT_OPS. */
40 struct signal_catchpoint
: public breakpoint
42 /* Signal numbers used for the 'catch signal' feature. If no signal
43 has been specified for filtering, it is empty. Otherwise,
44 it holds a list of all signals to be caught. */
46 std::vector
<gdb_signal
> signals_to_be_caught
;
48 /* If SIGNALS_TO_BE_CAUGHT is empty, then all "ordinary" signals are
49 caught. If CATCH_ALL is true, then internal signals are caught
50 as well. If SIGNALS_TO_BE_CAUGHT is not empty, then this field
56 /* The breakpoint_ops structure to be used in signal catchpoints. */
58 static struct breakpoint_ops signal_catchpoint_ops
;
60 /* Count of each signal. */
62 static unsigned int *signal_catch_counts
;
66 /* A convenience wrapper for gdb_signal_to_name that returns the
67 integer value if the name is not known. */
70 signal_to_name_or_int (enum gdb_signal sig
)
72 const char *result
= gdb_signal_to_name (sig
);
74 if (strcmp (result
, "?") == 0)
75 result
= plongest (sig
);
82 /* Implement the "insert_location" breakpoint_ops method for signal
86 signal_catchpoint_insert_location (struct bp_location
*bl
)
88 struct signal_catchpoint
*c
= (struct signal_catchpoint
*) bl
->owner
;
90 if (!c
->signals_to_be_caught
.empty ())
92 for (gdb_signal iter
: c
->signals_to_be_caught
)
93 ++signal_catch_counts
[iter
];
97 for (int i
= 0; i
< GDB_SIGNAL_LAST
; ++i
)
99 if (c
->catch_all
|| !INTERNAL_SIGNAL (i
))
100 ++signal_catch_counts
[i
];
104 signal_catch_update (signal_catch_counts
);
109 /* Implement the "remove_location" breakpoint_ops method for signal
113 signal_catchpoint_remove_location (struct bp_location
*bl
,
114 enum remove_bp_reason reason
)
116 struct signal_catchpoint
*c
= (struct signal_catchpoint
*) bl
->owner
;
118 if (!c
->signals_to_be_caught
.empty ())
120 for (gdb_signal iter
: c
->signals_to_be_caught
)
122 gdb_assert (signal_catch_counts
[iter
] > 0);
123 --signal_catch_counts
[iter
];
128 for (int i
= 0; i
< GDB_SIGNAL_LAST
; ++i
)
130 if (c
->catch_all
|| !INTERNAL_SIGNAL (i
))
132 gdb_assert (signal_catch_counts
[i
] > 0);
133 --signal_catch_counts
[i
];
138 signal_catch_update (signal_catch_counts
);
143 /* Implement the "breakpoint_hit" breakpoint_ops method for signal
147 signal_catchpoint_breakpoint_hit (const struct bp_location
*bl
,
148 struct address_space
*aspace
,
150 const struct target_waitstatus
*ws
)
152 const struct signal_catchpoint
*c
153 = (const struct signal_catchpoint
*) bl
->owner
;
154 gdb_signal signal_number
;
156 if (ws
->kind
!= TARGET_WAITKIND_STOPPED
)
159 signal_number
= ws
->value
.sig
;
161 /* If we are catching specific signals in this breakpoint, then we
162 must guarantee that the called signal is the same signal we are
164 if (!c
->signals_to_be_caught
.empty ())
166 for (gdb_signal iter
: c
->signals_to_be_caught
)
167 if (signal_number
== iter
)
173 return c
->catch_all
|| !INTERNAL_SIGNAL (signal_number
);
176 /* Implement the "print_it" breakpoint_ops method for signal
179 static enum print_stop_action
180 signal_catchpoint_print_it (bpstat bs
)
182 struct breakpoint
*b
= bs
->breakpoint_at
;
184 struct target_waitstatus last
;
185 const char *signal_name
;
186 struct ui_out
*uiout
= current_uiout
;
188 get_last_target_status (&ptid
, &last
);
190 signal_name
= signal_to_name_or_int (last
.value
.sig
);
192 annotate_catchpoint (b
->number
);
193 maybe_print_thread_hit_breakpoint (uiout
);
195 printf_filtered (_("Catchpoint %d (signal %s), "), b
->number
, signal_name
);
197 return PRINT_SRC_AND_LOC
;
200 /* Implement the "print_one" breakpoint_ops method for signal
204 signal_catchpoint_print_one (struct breakpoint
*b
,
205 struct bp_location
**last_loc
)
207 struct signal_catchpoint
*c
= (struct signal_catchpoint
*) b
;
208 struct value_print_options opts
;
209 struct ui_out
*uiout
= current_uiout
;
211 get_user_print_options (&opts
);
213 /* Field 4, the address, is omitted (which makes the columns
214 not line up too nicely with the headers, but the effect
215 is relatively readable). */
216 if (opts
.addressprint
)
217 uiout
->field_skip ("addr");
220 if (c
->signals_to_be_caught
.size () > 1)
221 uiout
->text ("signals \"");
223 uiout
->text ("signal \"");
225 if (!c
->signals_to_be_caught
.empty ())
230 for (gdb_signal iter
: c
->signals_to_be_caught
)
232 const char *name
= signal_to_name_or_int (iter
);
240 uiout
->field_string ("what", text
.c_str ());
243 uiout
->field_string ("what",
244 c
->catch_all
? "<any signal>" : "<standard signals>");
247 if (uiout
->is_mi_like_p ())
248 uiout
->field_string ("catch-type", "signal");
251 /* Implement the "print_mention" breakpoint_ops method for signal
255 signal_catchpoint_print_mention (struct breakpoint
*b
)
257 struct signal_catchpoint
*c
= (struct signal_catchpoint
*) b
;
259 if (!c
->signals_to_be_caught
.empty ())
261 if (c
->signals_to_be_caught
.size () > 1)
262 printf_filtered (_("Catchpoint %d (signals"), b
->number
);
264 printf_filtered (_("Catchpoint %d (signal"), b
->number
);
266 for (gdb_signal iter
: c
->signals_to_be_caught
)
268 const char *name
= signal_to_name_or_int (iter
);
270 printf_filtered (" %s", name
);
272 printf_filtered (")");
274 else if (c
->catch_all
)
275 printf_filtered (_("Catchpoint %d (any signal)"), b
->number
);
277 printf_filtered (_("Catchpoint %d (standard signals)"), b
->number
);
280 /* Implement the "print_recreate" breakpoint_ops method for signal
284 signal_catchpoint_print_recreate (struct breakpoint
*b
, struct ui_file
*fp
)
286 struct signal_catchpoint
*c
= (struct signal_catchpoint
*) b
;
288 fprintf_unfiltered (fp
, "catch signal");
290 if (!c
->signals_to_be_caught
.empty ())
292 for (gdb_signal iter
: c
->signals_to_be_caught
)
293 fprintf_unfiltered (fp
, " %s", signal_to_name_or_int (iter
));
295 else if (c
->catch_all
)
296 fprintf_unfiltered (fp
, " all");
297 fputc_unfiltered ('\n', fp
);
300 /* Implement the "explains_signal" breakpoint_ops method for signal
304 signal_catchpoint_explains_signal (struct breakpoint
*b
, enum gdb_signal sig
)
309 /* Create a new signal catchpoint. TEMPFLAG is true if this should be
310 a temporary catchpoint. FILTER is the list of signals to catch; it
311 can be empty, meaning all signals. CATCH_ALL is a flag indicating
312 whether signals used internally by gdb should be caught; it is only
313 valid if FILTER is NULL. If FILTER is empty and CATCH_ALL is zero,
314 then internal signals like SIGTRAP are not caught. */
317 create_signal_catchpoint (int tempflag
, std::vector
<gdb_signal
> &&filter
,
320 struct signal_catchpoint
*c
;
321 struct gdbarch
*gdbarch
= get_current_arch ();
323 c
= new signal_catchpoint ();
324 init_catchpoint (c
, gdbarch
, tempflag
, NULL
, &signal_catchpoint_ops
);
325 c
->signals_to_be_caught
= filter
;
326 c
->catch_all
= catch_all
;
328 install_breakpoint (0, c
, 1);
332 /* Splits the argument using space as delimiter. Returns a filter
333 list, which is empty if no filtering is required. */
335 static std::vector
<gdb_signal
>
336 catch_signal_split_args (char *arg
, bool *catch_all
)
338 std::vector
<gdb_signal
> result
;
344 gdb_signal signal_number
;
347 gdb::unique_xmalloc_ptr
<char> one_arg (extract_arg (&arg
));
351 /* Check for the special flag "all". */
352 if (strcmp (one_arg
.get (), "all") == 0)
354 arg
= skip_spaces (arg
);
355 if (*arg
!= '\0' || !first
)
356 error (_("'all' cannot be caught with other signals"));
358 gdb_assert (result
.empty ());
364 /* Check if the user provided a signal name or a number. */
365 num
= (int) strtol (one_arg
.get (), &endptr
, 0);
367 signal_number
= gdb_signal_from_command (num
);
370 signal_number
= gdb_signal_from_name (one_arg
.get ());
371 if (signal_number
== GDB_SIGNAL_UNKNOWN
)
372 error (_("Unknown signal name '%s'."), one_arg
.get ());
375 result
.push_back (signal_number
);
378 result
.shrink_to_fit ();
382 /* Implement the "catch signal" command. */
385 catch_signal_command (char *arg
, int from_tty
,
386 struct cmd_list_element
*command
)
389 bool catch_all
= false;
390 std::vector
<gdb_signal
> filter
;
392 tempflag
= get_cmd_context (command
) == CATCH_TEMPORARY
;
394 arg
= skip_spaces (arg
);
396 /* The allowed syntax is:
398 catch signal <name | number> [<name | number> ... <name | number>]
400 Let's check if there's a signal name. */
403 filter
= catch_signal_split_args (arg
, &catch_all
);
405 create_signal_catchpoint (tempflag
, std::move (filter
), catch_all
);
409 initialize_signal_catchpoint_ops (void)
411 struct breakpoint_ops
*ops
;
413 initialize_breakpoint_ops ();
415 ops
= &signal_catchpoint_ops
;
416 *ops
= base_breakpoint_ops
;
417 ops
->insert_location
= signal_catchpoint_insert_location
;
418 ops
->remove_location
= signal_catchpoint_remove_location
;
419 ops
->breakpoint_hit
= signal_catchpoint_breakpoint_hit
;
420 ops
->print_it
= signal_catchpoint_print_it
;
421 ops
->print_one
= signal_catchpoint_print_one
;
422 ops
->print_mention
= signal_catchpoint_print_mention
;
423 ops
->print_recreate
= signal_catchpoint_print_recreate
;
424 ops
->explains_signal
= signal_catchpoint_explains_signal
;
427 initialize_file_ftype _initialize_break_catch_sig
;
430 _initialize_break_catch_sig (void)
432 initialize_signal_catchpoint_ops ();
434 signal_catch_counts
= XCNEWVEC (unsigned int, GDB_SIGNAL_LAST
);
436 add_catch_command ("signal", _("\
437 Catch signals by their names and/or numbers.\n\
438 Usage: catch signal [[NAME|NUMBER] [NAME|NUMBER]...|all]\n\
439 Arguments say which signals to catch. If no arguments\n\
440 are given, every \"normal\" signal will be caught.\n\
441 The argument \"all\" means to also catch signals used by GDB.\n\
442 Arguments, if given, should be one or more signal names\n\
443 (if your system supports that), or signal numbers."),
444 catch_signal_command
,