1 /* Everything about signal catchpoints, for GDB.
3 Copyright (C) 2011-2023 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 "cli/cli-style.h"
32 #include "cli/cli-decode.h"
36 #define INTERNAL_SIGNAL(x) ((x) == GDB_SIGNAL_TRAP || (x) == GDB_SIGNAL_INT)
38 /* An instance of this type is used to represent a signal
41 struct signal_catchpoint
: public catchpoint
43 signal_catchpoint (struct gdbarch
*gdbarch
, bool temp
,
44 std::vector
<gdb_signal
> &&sigs
,
46 : catchpoint (gdbarch
, temp
, nullptr),
47 signals_to_be_caught (std::move (sigs
)),
48 catch_all (catch_all_
)
52 int insert_location (struct bp_location
*) override
;
53 int remove_location (struct bp_location
*,
54 enum remove_bp_reason reason
) override
;
55 int breakpoint_hit (const struct bp_location
*bl
,
56 const address_space
*aspace
,
58 const target_waitstatus
&ws
) override
;
59 enum print_stop_action
print_it (const bpstat
*bs
) const override
;
60 bool print_one (const bp_location
**) const override
;
61 void print_mention () const override
;
62 void print_recreate (struct ui_file
*fp
) const override
;
63 bool explains_signal (enum gdb_signal
) override
;
65 /* Signal numbers used for the 'catch signal' feature. If no signal
66 has been specified for filtering, it is empty. Otherwise,
67 it holds a list of all signals to be caught. */
69 std::vector
<gdb_signal
> signals_to_be_caught
;
71 /* If SIGNALS_TO_BE_CAUGHT is empty, then all "ordinary" signals are
72 caught. If CATCH_ALL is true, then internal signals are caught
73 as well. If SIGNALS_TO_BE_CAUGHT is not empty, then this field
79 /* Count of each signal. */
81 static unsigned int signal_catch_counts
[GDB_SIGNAL_LAST
];
85 /* A convenience wrapper for gdb_signal_to_name that returns the
86 integer value if the name is not known. */
89 signal_to_name_or_int (enum gdb_signal sig
)
91 const char *result
= gdb_signal_to_name (sig
);
93 if (strcmp (result
, "?") == 0)
94 result
= plongest (sig
);
101 /* Implement the "insert_location" method for signal catchpoints. */
104 signal_catchpoint::insert_location (struct bp_location
*bl
)
107 = gdb::checked_static_cast
<signal_catchpoint
*> (bl
->owner
);
109 if (!c
->signals_to_be_caught
.empty ())
111 for (gdb_signal iter
: c
->signals_to_be_caught
)
112 ++signal_catch_counts
[iter
];
116 for (int i
= 0; i
< GDB_SIGNAL_LAST
; ++i
)
118 if (c
->catch_all
|| !INTERNAL_SIGNAL (i
))
119 ++signal_catch_counts
[i
];
123 signal_catch_update (signal_catch_counts
);
128 /* Implement the "remove_location" method for signal catchpoints. */
131 signal_catchpoint::remove_location (struct bp_location
*bl
,
132 enum remove_bp_reason reason
)
135 = gdb::checked_static_cast
<signal_catchpoint
*> (bl
->owner
);
137 if (!c
->signals_to_be_caught
.empty ())
139 for (gdb_signal iter
: c
->signals_to_be_caught
)
141 gdb_assert (signal_catch_counts
[iter
] > 0);
142 --signal_catch_counts
[iter
];
147 for (int i
= 0; i
< GDB_SIGNAL_LAST
; ++i
)
149 if (c
->catch_all
|| !INTERNAL_SIGNAL (i
))
151 gdb_assert (signal_catch_counts
[i
] > 0);
152 --signal_catch_counts
[i
];
157 signal_catch_update (signal_catch_counts
);
162 /* Implement the "breakpoint_hit" method for signal catchpoints. */
165 signal_catchpoint::breakpoint_hit (const struct bp_location
*bl
,
166 const address_space
*aspace
,
168 const target_waitstatus
&ws
)
170 const signal_catchpoint
*c
171 = gdb::checked_static_cast
<const signal_catchpoint
*> (bl
->owner
);
172 gdb_signal signal_number
;
174 if (ws
.kind () != TARGET_WAITKIND_STOPPED
)
177 signal_number
= ws
.sig ();
179 /* If we are catching specific signals in this breakpoint, then we
180 must guarantee that the called signal is the same signal we are
182 if (!c
->signals_to_be_caught
.empty ())
184 for (gdb_signal iter
: c
->signals_to_be_caught
)
185 if (signal_number
== iter
)
191 return c
->catch_all
|| !INTERNAL_SIGNAL (signal_number
);
194 /* Implement the "print_it" method for signal catchpoints. */
196 enum print_stop_action
197 signal_catchpoint::print_it (const bpstat
*bs
) const
199 struct target_waitstatus last
;
200 const char *signal_name
;
201 struct ui_out
*uiout
= current_uiout
;
203 get_last_target_status (nullptr, nullptr, &last
);
205 signal_name
= signal_to_name_or_int (last
.sig ());
207 annotate_catchpoint (number
);
208 maybe_print_thread_hit_breakpoint (uiout
);
210 gdb_printf (_("Catchpoint %d (signal %s), "), number
, signal_name
);
212 return PRINT_SRC_AND_LOC
;
215 /* Implement the "print_one" method for signal catchpoints. */
218 signal_catchpoint::print_one (const bp_location
**last_loc
) const
220 struct value_print_options opts
;
221 struct ui_out
*uiout
= current_uiout
;
223 get_user_print_options (&opts
);
225 /* Field 4, the address, is omitted (which makes the columns
226 not line up too nicely with the headers, but the effect
227 is relatively readable). */
228 if (opts
.addressprint
)
229 uiout
->field_skip ("addr");
232 if (signals_to_be_caught
.size () > 1)
233 uiout
->text ("signals \"");
235 uiout
->text ("signal \"");
237 if (!signals_to_be_caught
.empty ())
242 for (gdb_signal iter
: signals_to_be_caught
)
244 const char *name
= signal_to_name_or_int (iter
);
252 uiout
->field_string ("what", text
);
255 uiout
->field_string ("what",
256 catch_all
? "<any signal>" : "<standard signals>",
257 metadata_style
.style ());
260 if (uiout
->is_mi_like_p ())
261 uiout
->field_string ("catch-type", "signal");
266 /* Implement the "print_mention" method for signal catchpoints. */
269 signal_catchpoint::print_mention () const
271 if (!signals_to_be_caught
.empty ())
273 if (signals_to_be_caught
.size () > 1)
274 gdb_printf (_("Catchpoint %d (signals"), number
);
276 gdb_printf (_("Catchpoint %d (signal"), number
);
278 for (gdb_signal iter
: signals_to_be_caught
)
280 const char *name
= signal_to_name_or_int (iter
);
282 gdb_printf (" %s", name
);
287 gdb_printf (_("Catchpoint %d (any signal)"), number
);
289 gdb_printf (_("Catchpoint %d (standard signals)"), number
);
292 /* Implement the "print_recreate" method for signal catchpoints. */
295 signal_catchpoint::print_recreate (struct ui_file
*fp
) const
297 gdb_printf (fp
, "catch signal");
299 if (!signals_to_be_caught
.empty ())
301 for (gdb_signal iter
: signals_to_be_caught
)
302 gdb_printf (fp
, " %s", signal_to_name_or_int (iter
));
305 gdb_printf (fp
, " all");
309 /* Implement the "explains_signal" method for signal catchpoints. */
312 signal_catchpoint::explains_signal (enum gdb_signal sig
)
317 /* Create a new signal catchpoint. TEMPFLAG is true if this should be
318 a temporary catchpoint. FILTER is the list of signals to catch; it
319 can be empty, meaning all signals. CATCH_ALL is a flag indicating
320 whether signals used internally by gdb should be caught; it is only
321 valid if FILTER is NULL. If FILTER is empty and CATCH_ALL is zero,
322 then internal signals like SIGTRAP are not caught. */
325 create_signal_catchpoint (int tempflag
, std::vector
<gdb_signal
> &&filter
,
328 struct gdbarch
*gdbarch
= get_current_arch ();
330 std::unique_ptr
<signal_catchpoint
> c
331 (new signal_catchpoint (gdbarch
, tempflag
, std::move (filter
), catch_all
));
333 install_breakpoint (0, std::move (c
), 1);
337 /* Splits the argument using space as delimiter. Returns a filter
338 list, which is empty if no filtering is required. */
340 static std::vector
<gdb_signal
>
341 catch_signal_split_args (const char *arg
, bool *catch_all
)
343 std::vector
<gdb_signal
> result
;
349 gdb_signal signal_number
;
352 std::string one_arg
= extract_arg (&arg
);
353 if (one_arg
.empty ())
356 /* Check for the special flag "all". */
357 if (one_arg
== "all")
359 arg
= skip_spaces (arg
);
360 if (*arg
!= '\0' || !first
)
361 error (_("'all' cannot be caught with other signals"));
363 gdb_assert (result
.empty ());
369 /* Check if the user provided a signal name or a number. */
370 num
= (int) strtol (one_arg
.c_str (), &endptr
, 0);
372 signal_number
= gdb_signal_from_command (num
);
375 signal_number
= gdb_signal_from_name (one_arg
.c_str ());
376 if (signal_number
== GDB_SIGNAL_UNKNOWN
)
377 error (_("Unknown signal name '%s'."), one_arg
.c_str ());
380 result
.push_back (signal_number
);
383 result
.shrink_to_fit ();
387 /* Implement the "catch signal" command. */
390 catch_signal_command (const char *arg
, int from_tty
,
391 struct cmd_list_element
*command
)
394 bool catch_all
= false;
395 std::vector
<gdb_signal
> filter
;
397 tempflag
= command
->context () == CATCH_TEMPORARY
;
399 arg
= skip_spaces (arg
);
401 /* The allowed syntax is:
403 catch signal <name | number> [<name | number> ... <name | number>]
405 Let's check if there's a signal name. */
408 filter
= catch_signal_split_args (arg
, &catch_all
);
410 create_signal_catchpoint (tempflag
, std::move (filter
), catch_all
);
413 void _initialize_break_catch_sig ();
415 _initialize_break_catch_sig ()
417 add_catch_command ("signal", _("\
418 Catch signals by their names and/or numbers.\n\
419 Usage: catch signal [[NAME|NUMBER] [NAME|NUMBER]...|all]\n\
420 Arguments say which signals to catch. If no arguments\n\
421 are given, every \"normal\" signal will be caught.\n\
422 The argument \"all\" means to also catch signals used by GDB.\n\
423 Arguments, if given, should be one or more signal names\n\
424 (if your system supports that), or signal numbers."),
425 catch_signal_command
,