gdb/break-catch-sig.c

   1 /* Everything about signal catchpoints, for GDB.
   2
   3    Copyright (C) 2011-2017 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   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.
  11
  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.
  16
  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/>.  */
  19
  20 #include "defs.h"
  21 #include "arch-utils.h"
  22 #include <ctype.h>
  23 #include "breakpoint.h"
  24 #include "gdbcmd.h"
  25 #include "inferior.h"
  26 #include "infrun.h"
  27 #include "annotate.h"
  28 #include "valprint.h"
  29 #include "cli/cli-utils.h"
  30 #include "completer.h"
  31
  32 #include <string>
  33
  34 #define INTERNAL_SIGNAL(x) ((x) == GDB_SIGNAL_TRAP || (x) == GDB_SIGNAL_INT)
  35
  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.  */
  39
  40 struct signal_catchpoint : public breakpoint
  41 {
  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.  */
  45
  46   std::vector<gdb_signal> signals_to_be_caught;
  47
  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
  51      is ignored.  */
  52
  53   bool catch_all;
  54 };
  55
  56 /* The breakpoint_ops structure to be used in signal catchpoints.  */
  57
  58 static struct breakpoint_ops signal_catchpoint_ops;
  59
  60 /* Count of each signal.  */
  61
  62 static unsigned int *signal_catch_counts;
  63
  64 \f
  65
  66 /* A convenience wrapper for gdb_signal_to_name that returns the
  67    integer value if the name is not known.  */
  68
  69 static const char *
  70 signal_to_name_or_int (enum gdb_signal sig)
  71 {
  72   const char *result = gdb_signal_to_name (sig);
  73
  74   if (strcmp (result, "?") == 0)
  75     result = plongest (sig);
  76
  77   return result;
  78 }
  79
  80 \f
  81
  82 /* Implement the "insert_location" breakpoint_ops method for signal
  83    catchpoints.  */
  84
  85 static int
  86 signal_catchpoint_insert_location (struct bp_location *bl)
  87 {
  88   struct signal_catchpoint *c = (struct signal_catchpoint *) bl->owner;
  89
  90   if (!c->signals_to_be_caught.empty ())
  91     {
  92       for (gdb_signal iter : c->signals_to_be_caught)
  93         ++signal_catch_counts[iter];
  94     }
  95   else
  96     {
  97       for (int i = 0; i < GDB_SIGNAL_LAST; ++i)
  98         {
  99           if (c->catch_all || !INTERNAL_SIGNAL (i))
 100             ++signal_catch_counts[i];
 101         }
 102     }
 103
 104   signal_catch_update (signal_catch_counts);
 105
 106   return 0;
 107 }
 108
 109 /* Implement the "remove_location" breakpoint_ops method for signal
 110    catchpoints.  */
 111
 112 static int
 113 signal_catchpoint_remove_location (struct bp_location *bl,
 114                                    enum remove_bp_reason reason)
 115 {
 116   struct signal_catchpoint *c = (struct signal_catchpoint *) bl->owner;
 117
 118   if (!c->signals_to_be_caught.empty ())
 119     {
 120       for (gdb_signal iter : c->signals_to_be_caught)
 121         {
 122           gdb_assert (signal_catch_counts[iter] > 0);
 123           --signal_catch_counts[iter];
 124         }
 125     }
 126   else
 127     {
 128       for (int i = 0; i < GDB_SIGNAL_LAST; ++i)
 129         {
 130           if (c->catch_all || !INTERNAL_SIGNAL (i))
 131             {
 132               gdb_assert (signal_catch_counts[i] > 0);
 133               --signal_catch_counts[i];
 134             }
 135         }
 136     }
 137
 138   signal_catch_update (signal_catch_counts);
 139
 140   return 0;
 141 }
 142
 143 /* Implement the "breakpoint_hit" breakpoint_ops method for signal
 144    catchpoints.  */
 145
 146 static int
 147 signal_catchpoint_breakpoint_hit (const struct bp_location *bl,
 148                                   struct address_space *aspace,
 149                                   CORE_ADDR bp_addr,
 150                                   const struct target_waitstatus *ws)
 151 {
 152   const struct signal_catchpoint *c
 153     = (const struct signal_catchpoint *) bl->owner;
 154   gdb_signal signal_number;
 155
 156   if (ws->kind != TARGET_WAITKIND_STOPPED)
 157     return 0;
 158
 159   signal_number = ws->value.sig;
 160
 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
 163      catching.  */
 164   if (!c->signals_to_be_caught.empty ())
 165     {
 166       for (gdb_signal iter : c->signals_to_be_caught)
 167         if (signal_number == iter)
 168           return 1;
 169       /* Not the same.  */
 170       return 0;
 171     }
 172   else
 173     return c->catch_all || !INTERNAL_SIGNAL (signal_number);
 174 }
 175
 176 /* Implement the "print_it" breakpoint_ops method for signal
 177    catchpoints.  */
 178
 179 static enum print_stop_action
 180 signal_catchpoint_print_it (bpstat bs)
 181 {
 182   struct breakpoint *b = bs->breakpoint_at;
 183   ptid_t ptid;
 184   struct target_waitstatus last;
 185   const char *signal_name;
 186   struct ui_out *uiout = current_uiout;
 187
 188   get_last_target_status (&ptid, &last);
 189
 190   signal_name = signal_to_name_or_int (last.value.sig);
 191
 192   annotate_catchpoint (b->number);
 193   maybe_print_thread_hit_breakpoint (uiout);
 194
 195   printf_filtered (_("Catchpoint %d (signal %s), "), b->number, signal_name);
 196
 197   return PRINT_SRC_AND_LOC;
 198 }
 199
 200 /* Implement the "print_one" breakpoint_ops method for signal
 201    catchpoints.  */
 202
 203 static void
 204 signal_catchpoint_print_one (struct breakpoint *b,
 205                              struct bp_location **last_loc)
 206 {
 207   struct signal_catchpoint *c = (struct signal_catchpoint *) b;
 208   struct value_print_options opts;
 209   struct ui_out *uiout = current_uiout;
 210
 211   get_user_print_options (&opts);
 212
 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");
 218   annotate_field (5);
 219
 220   if (c->signals_to_be_caught.size () > 1)
 221     uiout->text ("signals \"");
 222   else
 223     uiout->text ("signal \"");
 224
 225   if (!c->signals_to_be_caught.empty ())
 226     {
 227       std::string text;
 228
 229       bool first = true;
 230       for (gdb_signal iter : c->signals_to_be_caught)
 231         {
 232           const char *name = signal_to_name_or_int (iter);
 233
 234           if (!first)
 235             text += " ";
 236           first = false;
 237
 238           text += name;
 239         }
 240       uiout->field_string ("what", text.c_str ());
 241     }
 242   else
 243     uiout->field_string ("what",
 244                          c->catch_all ? "<any signal>" : "<standard signals>");
 245   uiout->text ("\" ");
 246
 247   if (uiout->is_mi_like_p ())
 248     uiout->field_string ("catch-type", "signal");
 249 }
 250
 251 /* Implement the "print_mention" breakpoint_ops method for signal
 252    catchpoints.  */
 253
 254 static void
 255 signal_catchpoint_print_mention (struct breakpoint *b)
 256 {
 257   struct signal_catchpoint *c = (struct signal_catchpoint *) b;
 258
 259   if (!c->signals_to_be_caught.empty ())
 260     {
 261       if (c->signals_to_be_caught.size () > 1)
 262         printf_filtered (_("Catchpoint %d (signals"), b->number);
 263       else
 264         printf_filtered (_("Catchpoint %d (signal"), b->number);
 265
 266       for (gdb_signal iter : c->signals_to_be_caught)
 267         {
 268           const char *name = signal_to_name_or_int (iter);
 269
 270           printf_filtered (" %s", name);
 271         }
 272       printf_filtered (")");
 273     }
 274   else if (c->catch_all)
 275     printf_filtered (_("Catchpoint %d (any signal)"), b->number);
 276   else
 277     printf_filtered (_("Catchpoint %d (standard signals)"), b->number);
 278 }
 279
 280 /* Implement the "print_recreate" breakpoint_ops method for signal
 281    catchpoints.  */
 282
 283 static void
 284 signal_catchpoint_print_recreate (struct breakpoint *b, struct ui_file *fp)
 285 {
 286   struct signal_catchpoint *c = (struct signal_catchpoint *) b;
 287
 288   fprintf_unfiltered (fp, "catch signal");
 289
 290   if (!c->signals_to_be_caught.empty ())
 291     {
 292       for (gdb_signal iter : c->signals_to_be_caught)
 293         fprintf_unfiltered (fp, " %s", signal_to_name_or_int (iter));
 294     }
 295   else if (c->catch_all)
 296     fprintf_unfiltered (fp, " all");
 297   fputc_unfiltered ('\n', fp);
 298 }
 299
 300 /* Implement the "explains_signal" breakpoint_ops method for signal
 301    catchpoints.  */
 302
 303 static int
 304 signal_catchpoint_explains_signal (struct breakpoint *b, enum gdb_signal sig)
 305 {
 306   return 1;
 307 }
 308
 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.  */
 315
 316 static void
 317 create_signal_catchpoint (int tempflag, std::vector<gdb_signal> &&filter,
 318                           bool catch_all)
 319 {
 320   struct gdbarch *gdbarch = get_current_arch ();
 321
 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;
 326
 327   install_breakpoint (0, std::move (c), 1);
 328 }
 329
 330
 331 /* Splits the argument using space as delimiter.  Returns a filter
 332    list, which is empty if no filtering is required.  */
 333
 334 static std::vector<gdb_signal>
 335 catch_signal_split_args (char *arg, bool *catch_all)
 336 {
 337   std::vector<gdb_signal> result;
 338   bool first = true;
 339
 340   while (*arg != '\0')
 341     {
 342       int num;
 343       gdb_signal signal_number;
 344       char *endptr;
 345
 346       std::string one_arg = extract_arg (&arg);
 347       if (one_arg.empty ())
 348         break;
 349
 350       /* Check for the special flag "all".  */
 351       if (one_arg == "all")
 352         {
 353           arg = skip_spaces (arg);
 354           if (*arg != '\0' || !first)
 355             error (_("'all' cannot be caught with other signals"));
 356           *catch_all = true;
 357           gdb_assert (result.empty ());
 358           return result;
 359         }
 360
 361       first = false;
 362
 363       /* Check if the user provided a signal name or a number.  */
 364       num = (int) strtol (one_arg.c_str (), &endptr, 0);
 365       if (*endptr == '\0')
 366         signal_number = gdb_signal_from_command (num);
 367       else
 368         {
 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 ());
 372         }
 373
 374       result.push_back (signal_number);
 375     }
 376
 377   result.shrink_to_fit ();
 378   return result;
 379 }
 380
 381 /* Implement the "catch signal" command.  */
 382
 383 static void
 384 catch_signal_command (char *arg, int from_tty,
 385                       struct cmd_list_element *command)
 386 {
 387   int tempflag;
 388   bool catch_all = false;
 389   std::vector<gdb_signal> filter;
 390
 391   tempflag = get_cmd_context (command) == CATCH_TEMPORARY;
 392
 393   arg = skip_spaces (arg);
 394
 395   /* The allowed syntax is:
 396      catch signal
 397      catch signal <name | number> [<name | number> ... <name | number>]
 398
 399      Let's check if there's a signal name.  */
 400
 401   if (arg != NULL)
 402     filter = catch_signal_split_args (arg, &catch_all);
 403
 404   create_signal_catchpoint (tempflag, std::move (filter), catch_all);
 405 }
 406
 407 static void
 408 initialize_signal_catchpoint_ops (void)
 409 {
 410   struct breakpoint_ops *ops;
 411
 412   initialize_breakpoint_ops ();
 413
 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;
 424 }
 425
 426 void
 427 _initialize_break_catch_sig (void)
 428 {
 429   initialize_signal_catchpoint_ops ();
 430
 431   signal_catch_counts = XCNEWVEC (unsigned int, GDB_SIGNAL_LAST);
 432
 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,
 442                      signal_completer,
 443                      CATCH_PERMANENT,
 444                      CATCH_TEMPORARY);
 445 }