gdb/break-catch-sig.c - gdb

Global variables defined

Data types defined

Functions defined

Macros defined

Source code

  1. /* Everything about signal catchpoints, for GDB.

  3.    Copyright (C) 2011-2015 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/>.  */

  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. #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
  46. {
  47.   /* The base class.  */

  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
  60.      field is ignored.  */

  62.   int catch_all;
  63. };

  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.  */

  78. static const char *
  79. ‌signal_to_name_or_int (enum gdb_signal sig)
  80. {
  81.   const char *result = gdb_signal_to_name (sig);

  83.   if (strcmp (result, "?") == 0)
  84.     result = plongest (sig);

  86.   return result;
  87. }



  91. /* Implement the "dtor" breakpoint_ops method for signal
  92.    catchpoints.  */

  94. static void
  95. ‌signal_catchpoint_dtor (struct breakpoint *b)
  96. {
  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);
  102. }

  104. /* Implement the "insert_location" breakpoint_ops method for signal
  105.    catchpoints.  */

  107. static int
  108. ‌signal_catchpoint_insert_location (struct bp_location *bl)
  109. {
  110.   struct signal_catchpoint *c = (void *) bl->owner;
  111.   int i;

  113.   if (c->signals_to_be_caught != NULL)
  114.     {
  115.       gdb_signal_type iter;

  117.       for (i = 0;
  118.            VEC_iterate (gdb_signal_type, c->signals_to_be_caught, i, iter);
  119.            i++)
  120.         ++signal_catch_counts[iter];
  121.     }
  122.   else
  123.     {
  124.       for (i = 0; i < GDB_SIGNAL_LAST; ++i)
  125.         {
  126.           if (c->catch_all || !INTERNAL_SIGNAL (i))
  127.             ++signal_catch_counts[i];
  128.         }
  129.     }

  131.   signal_catch_update (signal_catch_counts);

  133.   return 0;
  134. }

  136. /* Implement the "remove_location" breakpoint_ops method for signal
  137.    catchpoints.  */

  139. static int
  140. ‌signal_catchpoint_remove_location (struct bp_location *bl)
  141. {
  142.   struct signal_catchpoint *c = (void *) bl->owner;
  143.   int i;

  145.   if (c->signals_to_be_caught != NULL)
  146.     {
  147.       gdb_signal_type iter;

  149.       for (i = 0;
  150.            VEC_iterate (gdb_signal_type, c->signals_to_be_caught, i, iter);
  151.            i++)
  152.         {
  153.           gdb_assert (signal_catch_counts[iter] > 0);
  154.           --signal_catch_counts[iter];
  155.         }
  156.     }
  157.   else
  158.     {
  159.       for (i = 0; i < GDB_SIGNAL_LAST; ++i)
  160.         {
  161.           if (c->catch_all || !INTERNAL_SIGNAL (i))
  162.             {
  163.               gdb_assert (signal_catch_counts[i] > 0);
  164.               --signal_catch_counts[i];
  165.             }
  166.         }
  167.     }

  169.   signal_catch_update (signal_catch_counts);

  171.   return 0;
  172. }

  174. /* Implement the "breakpoint_hit" breakpoint_ops method for signal
  175.    catchpoints.  */

  177. static int
  178. ‌signal_catchpoint_breakpoint_hit (const struct bp_location *bl,
  179.                                   struct address_space *aspace,
  180.                                   CORE_ADDR bp_addr,
  181.                                   const struct target_waitstatus *ws)
  182. {
  183.   const struct signal_catchpoint *c = (void *) bl->owner;
  184.   gdb_signal_type signal_number;

  186.   if (ws->kind != TARGET_WAITKIND_STOPPED)
  187.     return 0;

  189.   signal_number = ws->value.sig;

  191.   /* If we are catching specific signals in this breakpoint, then we
  192.      must guarantee that the called signal is the same signal we are
  193.      catching.  */
  194.   if (c->signals_to_be_caught)
  195.     {
  196.       int i;
  197.       gdb_signal_type iter;

  199.       for (i = 0;
  200.            VEC_iterate (gdb_signal_type, c->signals_to_be_caught, i, iter);
  201.            i++)
  202.         if (signal_number == iter)
  203.           return 1;
  204.       /* Not the same.  */
  205.       gdb_assert (!iter);
  206.       return 0;
  207.     }
  208.   else
  209.     return c->catch_all || !INTERNAL_SIGNAL (signal_number);
  210. }

  212. /* Implement the "print_it" breakpoint_ops method for signal
  213.    catchpoints.  */

  215. static enum print_stop_action
  216. ‌signal_catchpoint_print_it (bpstat bs)
  217. {
  218.   struct breakpoint *b = bs->breakpoint_at;
  219.   ptid_t ptid;
  220.   struct target_waitstatus last;
  221.   const char *signal_name;

  223.   get_last_target_status (&ptid, &last);

  225.   signal_name = signal_to_name_or_int (last.value.sig);

  227.   annotate_catchpoint (b->number);

  229.   printf_filtered (_("\nCatchpoint %d (signal %s), "), b->number, signal_name);

  231.   return PRINT_SRC_AND_LOC;
  232. }

  234. /* Implement the "print_one" breakpoint_ops method for signal
  235.    catchpoints.  */

  237. static void
  238. ‌signal_catchpoint_print_one (struct breakpoint *b,
  239.                              struct bp_location **last_loc)
  240. {
  241.   struct signal_catchpoint *c = (void *) b;
  242.   struct value_print_options opts;
  243.   struct ui_out *uiout = current_uiout;

  245.   get_user_print_options (&opts);

  247.   /* Field 4, the address, is omitted (which makes the columns
  248.      not line up too nicely with the headers, but the effect
  249.      is relatively readable).  */
  250.   if (opts.addressprint)
  251.     ui_out_field_skip (uiout, "addr");
  252.   annotate_field (5);

  254.   if (c->signals_to_be_caught
  255.       && VEC_length (gdb_signal_type, c->signals_to_be_caught) > 1)
  256.     ui_out_text (uiout, "signals \"");
  257.   else
  258.     ui_out_text (uiout, "signal \"");

  260.   if (c->signals_to_be_caught)
  261.     {
  262.       int i;
  263.       gdb_signal_type iter;
  264.       struct obstack text;
  265.       struct cleanup *cleanup;

  267.       obstack_init (&text);
  268.       cleanup = make_cleanup_obstack_free (&text);

  270.       for (i = 0;
  271.            VEC_iterate (gdb_signal_type, c->signals_to_be_caught, i, iter);
  272.            i++)
  273.         {
  274.           const char *name = signal_to_name_or_int (iter);

  276.           if (i > 0)
  277.             obstack_grow (&text, " ", 1);
  278.           obstack_grow (&text, name, strlen (name));
  279.         }
  280.       obstack_grow (&text, "", 1);
  281.       ui_out_field_string (uiout, "what", obstack_base (&text));
  282.       do_cleanups (cleanup);
  283.     }
  284.   else
  285.     ui_out_field_string (uiout, "what",
  286.                          c->catch_all ? "<any signal>" : "<standard signals>");
  287.   ui_out_text (uiout, "\" ");

  289.   if (ui_out_is_mi_like_p (uiout))
  290.     ui_out_field_string (uiout, "catch-type", "signal");
  291. }

  293. /* Implement the "print_mention" breakpoint_ops method for signal
  294.    catchpoints.  */

  296. static void
  297. ‌signal_catchpoint_print_mention (struct breakpoint *b)
  298. {
  299.   struct signal_catchpoint *c = (void *) b;

  301.   if (c->signals_to_be_caught)
  302.     {
  303.       int i;
  304.       gdb_signal_type iter;

  306.       if (VEC_length (gdb_signal_type, c->signals_to_be_caught) > 1)
  307.         printf_filtered (_("Catchpoint %d (signals"), b->number);
  308.       else
  309.         printf_filtered (_("Catchpoint %d (signal"), b->number);

  311.       for (i = 0;
  312.            VEC_iterate (gdb_signal_type, c->signals_to_be_caught, i, iter);
  313.            i++)
  314.         {
  315.           const char *name = signal_to_name_or_int (iter);

  317.           printf_filtered (" %s", name);
  318.         }
  319.       printf_filtered (")");
  320.     }
  321.   else if (c->catch_all)
  322.     printf_filtered (_("Catchpoint %d (any signal)"), b->number);
  323.   else
  324.     printf_filtered (_("Catchpoint %d (standard signals)"), b->number);
  325. }

  327. /* Implement the "print_recreate" breakpoint_ops method for signal
  328.    catchpoints.  */

  330. static void
  331. ‌signal_catchpoint_print_recreate (struct breakpoint *b, struct ui_file *fp)
  332. {
  333.   struct signal_catchpoint *c = (void *) b;

  335.   fprintf_unfiltered (fp, "catch signal");

  337.   if (c->signals_to_be_caught)
  338.     {
  339.       int i;
  340.       gdb_signal_type iter;

  342.       for (i = 0;
  343.            VEC_iterate (gdb_signal_type, c->signals_to_be_caught, i, iter);
  344.            i++)
  345.         fprintf_unfiltered (fp, " %s", signal_to_name_or_int (iter));
  346.     }
  347.   else if (c->catch_all)
  348.     fprintf_unfiltered (fp, " all");
  349.   fputc_unfiltered ('\n', fp);
  350. }

  352. /* Implement the "explains_signal" breakpoint_ops method for signal
  353.    catchpoints.  */

  355. static int
  356. ‌signal_catchpoint_explains_signal (struct breakpoint *b, enum gdb_signal sig)
  357. {
  358.   return 1;
  359. }

  361. /* Create a new signal catchpoint.  TEMPFLAG is true if this should be
  362.    a temporary catchpoint.  FILTER is the list of signals to catch; it
  363.    can be NULL, meaning all signals.  CATCH_ALL is a flag indicating
  364.    whether signals used internally by gdb should be caught; it is only
  365.    valid if FILTER is NULL.  If FILTER is NULL and CATCH_ALL is zero,
  366.    then internal signals like SIGTRAP are not caught.  */

  368. static void
  369. ‌create_signal_catchpoint (int tempflag, VEC (gdb_signal_type) *filter,
  370.                           int catch_all)
  371. {
  372.   struct signal_catchpoint *c;
  373.   struct gdbarch *gdbarch = get_current_arch ();

  375.   c = XNEW (struct signal_catchpoint);
  376.   init_catchpoint (&c->base, gdbarch, tempflag, NULL, &signal_catchpoint_ops);
  377.   c->signals_to_be_caught = filter;
  378.   c->catch_all = catch_all;

  380.   install_breakpoint (0, &c->base, 1);
  381. }


  384. /* Splits the argument using space as delimiter.  Returns an xmalloc'd
  385.    filter list, or NULL if no filtering is required.  */

  387. ‌static VEC (gdb_signal_type) *
  388. catch_signal_split_args (char *arg, int *catch_all)
  389. {
  390.   VEC (gdb_signal_type) *result = NULL;
  391.   struct cleanup *cleanup = make_cleanup (VEC_cleanup (gdb_signal_type),
  392.                                           &result);
  393.   int first = 1;

  395.   while (*arg != '\0')
  396.     {
  397.       int num;
  398.       gdb_signal_type signal_number;
  399.       char *one_arg, *endptr;
  400.       struct cleanup *inner_cleanup;

  402.       one_arg = extract_arg (&arg);
  403.       if (one_arg == NULL)
  404.         break;
  405.       inner_cleanup = make_cleanup (xfree, one_arg);

  407.       /* Check for the special flag "all".  */
  408.       if (strcmp (one_arg, "all") == 0)
  409.         {
  410.           arg = skip_spaces (arg);
  411.           if (*arg != '\0' || !first)
  412.             error (_("'all' cannot be caught with other signals"));
  413.           *catch_all = 1;
  414.           gdb_assert (result == NULL);
  415.           do_cleanups (inner_cleanup);
  416.           discard_cleanups (cleanup);
  417.           return NULL;
  418.         }

  420.       first = 0;

  422.       /* Check if the user provided a signal name or a number.  */
  423.       num = (int) strtol (one_arg, &endptr, 0);
  424.       if (*endptr == '\0')
  425.         signal_number = gdb_signal_from_command (num);
  426.       else
  427.         {
  428.           signal_number = gdb_signal_from_name (one_arg);
  429.           if (signal_number == GDB_SIGNAL_UNKNOWN)
  430.             error (_("Unknown signal name '%s'."), one_arg);
  431.         }

  433.       VEC_safe_push (gdb_signal_type, result, signal_number);
  434.       do_cleanups (inner_cleanup);
  435.     }

  437.   discard_cleanups (cleanup);
  438.   return result;
  439. }

  441. /* Implement the "catch signal" command.  */

  443. static void
  444. ‌catch_signal_command (char *arg, int from_tty,
  445.                       struct cmd_list_element *command)
  446. {
  447.   int tempflag, catch_all = 0;
  448.   VEC (gdb_signal_type) *filter;

  450.   tempflag = get_cmd_context (command) == CATCH_TEMPORARY;

  452.   arg = skip_spaces (arg);

  454.   /* The allowed syntax is:
  455.      catch signal
  456.      catch signal <name | number> [<name | number> ... <name | number>]

  458.      Let's check if there's a signal name.  */

  460.   if (arg != NULL)
  461.     filter = catch_signal_split_args (arg, &catch_all);
  462.   else
  463.     filter = NULL;

  465.   create_signal_catchpoint (tempflag, filter, catch_all);
  466. }

  468. static void
  469. ‌initialize_signal_catchpoint_ops (void)
  470. {
  471.   struct breakpoint_ops *ops;

  473.   initialize_breakpoint_ops ();

  475.   ops = &signal_catchpoint_ops;
  476.   *ops = base_breakpoint_ops;
  477.   ops->dtor = signal_catchpoint_dtor;
  478.   ops->insert_location = signal_catchpoint_insert_location;
  479.   ops->remove_location = signal_catchpoint_remove_location;
  480.   ops->breakpoint_hit = signal_catchpoint_breakpoint_hit;
  481.   ops->print_it = signal_catchpoint_print_it;
  482.   ops->print_one = signal_catchpoint_print_one;
  483.   ops->print_mention = signal_catchpoint_print_mention;
  484.   ops->print_recreate = signal_catchpoint_print_recreate;
  485.   ops->explains_signal = signal_catchpoint_explains_signal;
  486. }

  488. ‌initialize_file_ftype _initialize_break_catch_sig;

  490. void
  491. ‌_initialize_break_catch_sig (void)
  492. {
  493.   initialize_signal_catchpoint_ops ();

  495.   signal_catch_counts = XCNEWVEC (unsigned int, GDB_SIGNAL_LAST);

  497.   add_catch_command ("signal", _("\
  498. Catch signals by their names and/or numbers.\n\
  499. Usage: catch signal [[NAME|NUMBER] [NAME|NUMBER]...|all]\n\
  500. Arguments say which signals to catch.  If no arguments\n\
  501. are given, every \"normal\" signal will be caught.\n\
  502. The argument \"all\" means to also catch signals used by GDB.\n\
  503. Arguments, if given, should be one or more signal names\n\
  504. (if your system supports that), or signal numbers."),
  505.                      catch_signal_command,
  506.                      signal_completer,
  507.                      CATCH_PERMANENT,
  508.                      CATCH_TEMPORARY);
  509. }