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 const 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 gdbarch *gdbarch = get_current_arch ();
322 std::unique_ptr<signal_catchpoint> c (new signal_catchpoint ());
323 init_catchpoint (c.get (), gdbarch, tempflag, NULL, &signal_catchpoint_ops);
324 c->signals_to_be_caught = std::move (filter);
325 c->catch_all = catch_all;
327 install_breakpoint (0, std::move (c), 1);
331 /* Splits the argument using space as delimiter. Returns a filter
332 list, which is empty if no filtering is required. */
334 static std::vector<gdb_signal>
335 catch_signal_split_args (const char *arg, bool *catch_all)
337 std::vector<gdb_signal> result;
343 gdb_signal signal_number;
346 std::string one_arg = extract_arg (&arg);
347 if (one_arg.empty ())
350 /* Check for the special flag "all". */
351 if (one_arg == "all")
353 arg = skip_spaces (arg);
354 if (*arg != '\0' || !first)
355 error (_("'all' cannot be caught with other signals"));
357 gdb_assert (result.empty ());
363 /* Check if the user provided a signal name or a number. */
364 num = (int) strtol (one_arg.c_str (), &endptr, 0);
366 signal_number = gdb_signal_from_command (num);
369 signal_number = gdb_signal_from_name (one_arg.c_str ());
370 if (signal_number == GDB_SIGNAL_UNKNOWN)
371 error (_("Unknown signal name '%s'."), one_arg.c_str ());
374 result.push_back (signal_number);
377 result.shrink_to_fit ();
381 /* Implement the "catch signal" command. */
384 catch_signal_command (const char *arg, int from_tty,
385 struct cmd_list_element *command)
388 bool catch_all = false;
389 std::vector<gdb_signal> filter;
391 tempflag = get_cmd_context (command) == CATCH_TEMPORARY;
393 arg = skip_spaces (arg);
395 /* The allowed syntax is:
397 catch signal <name | number> [<name | number> ... <name | number>]
399 Let's check if there's a signal name. */
402 filter = catch_signal_split_args (arg, &catch_all);
404 create_signal_catchpoint (tempflag, std::move (filter), catch_all);
408 initialize_signal_catchpoint_ops (void)
410 struct breakpoint_ops *ops;
412 initialize_breakpoint_ops ();
414 ops = &signal_catchpoint_ops;
415 *ops = base_breakpoint_ops;
416 ops->insert_location = signal_catchpoint_insert_location;
417 ops->remove_location = signal_catchpoint_remove_location;
418 ops->breakpoint_hit = signal_catchpoint_breakpoint_hit;
419 ops->print_it = signal_catchpoint_print_it;
420 ops->print_one = signal_catchpoint_print_one;
421 ops->print_mention = signal_catchpoint_print_mention;
422 ops->print_recreate = signal_catchpoint_print_recreate;
423 ops->explains_signal = signal_catchpoint_explains_signal;
427 _initialize_break_catch_sig (void)
429 initialize_signal_catchpoint_ops ();
431 signal_catch_counts = XCNEWVEC (unsigned int, GDB_SIGNAL_LAST);
433 add_catch_command ("signal", _("\
434 Catch signals by their names and/or numbers.\n\
435 Usage: catch signal [[NAME|NUMBER] [NAME|NUMBER]...|all]\n\
436 Arguments say which signals to catch. If no arguments\n\
437 are given, every \"normal\" signal will be caught.\n\
438 The argument \"all\" means to also catch signals used by GDB.\n\
439 Arguments, if given, should be one or more signal names\n\
440 (if your system supports that), or signal numbers."),
441 catch_signal_command,