[binutils.git] / gdb / break-catch-sig.c

/* Everything about signal catchpoints, for GDB.

   Copyright (C) 2011-2015 Free Software Foundation, Inc.

   This file is part of GDB.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

#include "defs.h"
#include "arch-utils.h"
#include <ctype.h>
#include "breakpoint.h"
#include "gdbcmd.h"
#include "inferior.h"
#include "infrun.h"
#include "annotate.h"
#include "valprint.h"
#include "cli/cli-utils.h"
#include "completer.h"
#include "gdb_obstack.h"

#define INTERNAL_SIGNAL(x) ((x) == GDB_SIGNAL_TRAP || (x) == GDB_SIGNAL_INT)

typedef enum gdb_signal gdb_signal_type;

DEF_VEC_I (gdb_signal_type);

/* An instance of this type is used to represent a signal catchpoint.
   It includes a "struct breakpoint" as a kind of base class; users
   downcast to "struct breakpoint *" when needed.  A breakpoint is
   really of this type iff its ops pointer points to
   SIGNAL_CATCHPOINT_OPS.  */

struct signal_catchpoint
{
  /* The base class.  */

  struct breakpoint base;

  /* Signal numbers used for the 'catch signal' feature.  If no signal
     has been specified for filtering, its value is NULL.  Otherwise,
     it holds a list of all signals to be caught.  */

  VEC (gdb_signal_type) *signals_to_be_caught;

  /* If SIGNALS_TO_BE_CAUGHT is NULL, then all "ordinary" signals are
     caught.  If CATCH_ALL is non-zero, then internal signals are
     caught as well.  If SIGNALS_TO_BE_CAUGHT is non-NULL, then this
     field is ignored.  */

  int catch_all;
};

/* The breakpoint_ops structure to be used in signal catchpoints.  */

static struct breakpoint_ops signal_catchpoint_ops;

/* Count of each signal.  */

static unsigned int *signal_catch_counts;

\f

/* A convenience wrapper for gdb_signal_to_name that returns the
   integer value if the name is not known.  */

static const char *
signal_to_name_or_int (enum gdb_signal sig)
{
  const char *result = gdb_signal_to_name (sig);

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

  return result;
}

\f

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

static void
signal_catchpoint_dtor (struct breakpoint *b)
{
  struct signal_catchpoint *c = (struct signal_catchpoint *) b;

  VEC_free (gdb_signal_type, c->signals_to_be_caught);

  base_breakpoint_ops.dtor (b);
}

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

static int
signal_catchpoint_insert_location (struct bp_location *bl)
{
  struct signal_catchpoint *c = (void *) bl->owner;
  int i;

  if (c->signals_to_be_caught != NULL)
    {
      gdb_signal_type iter;

      for (i = 0;
	   VEC_iterate (gdb_signal_type, c->signals_to_be_caught, i, iter);
	   i++)
	++signal_catch_counts[iter];
    }
  else
    {
      for (i = 0; i < GDB_SIGNAL_LAST; ++i)
	{
	  if (c->catch_all || !INTERNAL_SIGNAL (i))
	    ++signal_catch_counts[i];
	}
    }

  signal_catch_update (signal_catch_counts);

  return 0;
}

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

static int
signal_catchpoint_remove_location (struct bp_location *bl)
{
  struct signal_catchpoint *c = (void *) bl->owner;
  int i;

  if (c->signals_to_be_caught != NULL)
    {
      gdb_signal_type iter;

      for (i = 0;
	   VEC_iterate (gdb_signal_type, c->signals_to_be_caught, i, iter);
	   i++)
	{
	  gdb_assert (signal_catch_counts[iter] > 0);
	  --signal_catch_counts[iter];
	}
    }
  else
    {
      for (i = 0; i < GDB_SIGNAL_LAST; ++i)
	{
	  if (c->catch_all || !INTERNAL_SIGNAL (i))
	    {
	      gdb_assert (signal_catch_counts[i] > 0);
	      --signal_catch_counts[i];
	    }
	}
    }

  signal_catch_update (signal_catch_counts);

  return 0;
}

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

static int
signal_catchpoint_breakpoint_hit (const struct bp_location *bl,
				  struct address_space *aspace,
				  CORE_ADDR bp_addr,
				  const struct target_waitstatus *ws)
{
  const struct signal_catchpoint *c = (void *) bl->owner;
  gdb_signal_type signal_number;

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

  signal_number = ws->value.sig;

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

      for (i = 0;
           VEC_iterate (gdb_signal_type, c->signals_to_be_caught, i, iter);
           i++)
	if (signal_number == iter)
	  return 1;
      /* Not the same.  */
      gdb_assert (!iter);
      return 0;
    }
  else
    return c->catch_all || !INTERNAL_SIGNAL (signal_number);
}

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

static enum print_stop_action
signal_catchpoint_print_it (bpstat bs)
{
  struct breakpoint *b = bs->breakpoint_at;
  ptid_t ptid;
  struct target_waitstatus last;
  const char *signal_name;

  get_last_target_status (&ptid, &last);

  signal_name = signal_to_name_or_int (last.value.sig);

  annotate_catchpoint (b->number);

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

  return PRINT_SRC_AND_LOC;
}

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

static void
signal_catchpoint_print_one (struct breakpoint *b,
			     struct bp_location **last_loc)
{
  struct signal_catchpoint *c = (void *) b;
  struct value_print_options opts;
  struct ui_out *uiout = current_uiout;

  get_user_print_options (&opts);

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

  if (c->signals_to_be_caught
      && VEC_length (gdb_signal_type, c->signals_to_be_caught) > 1)
    ui_out_text (uiout, "signals \"");
  else
    ui_out_text (uiout, "signal \"");

  if (c->signals_to_be_caught)
    {
      int i;
      gdb_signal_type iter;
      struct obstack text;
      struct cleanup *cleanup;

      obstack_init (&text);
      cleanup = make_cleanup_obstack_free (&text);

      for (i = 0;
           VEC_iterate (gdb_signal_type, c->signals_to_be_caught, i, iter);
           i++)
        {
	  const char *name = signal_to_name_or_int (iter);

	  if (i > 0)
	    obstack_grow (&text, " ", 1);
	  obstack_grow (&text, name, strlen (name));
        }
      obstack_grow (&text, "", 1);
      ui_out_field_string (uiout, "what", obstack_base (&text));
      do_cleanups (cleanup);
    }
  else
    ui_out_field_string (uiout, "what",
			 c->catch_all ? "<any signal>" : "<standard signals>");
  ui_out_text (uiout, "\" ");

  if (ui_out_is_mi_like_p (uiout))
    ui_out_field_string (uiout, "catch-type", "signal");
}

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

static void
signal_catchpoint_print_mention (struct breakpoint *b)
{
  struct signal_catchpoint *c = (void *) b;

  if (c->signals_to_be_caught)
    {
      int i;
      gdb_signal_type iter;

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

      for (i = 0;
           VEC_iterate (gdb_signal_type, c->signals_to_be_caught, i, iter);
           i++)
        {
	  const char *name = signal_to_name_or_int (iter);

	  printf_filtered (" %s", name);
        }
      printf_filtered (")");
    }
  else if (c->catch_all)
    printf_filtered (_("Catchpoint %d (any signal)"), b->number);
  else
    printf_filtered (_("Catchpoint %d (standard signals)"), b->number);
}

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

static void
signal_catchpoint_print_recreate (struct breakpoint *b, struct ui_file *fp)
{
  struct signal_catchpoint *c = (void *) b;

  fprintf_unfiltered (fp, "catch signal");

  if (c->signals_to_be_caught)
    {
      int i;
      gdb_signal_type iter;

      for (i = 0;
           VEC_iterate (gdb_signal_type, c->signals_to_be_caught, i, iter);
           i++)
	fprintf_unfiltered (fp, " %s", signal_to_name_or_int (iter));
    }
  else if (c->catch_all)
    fprintf_unfiltered (fp, " all");
  fputc_unfiltered ('\n', fp);
}

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

static int
signal_catchpoint_explains_signal (struct breakpoint *b, enum gdb_signal sig)
{
  return 1;
}

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

static void
create_signal_catchpoint (int tempflag, VEC (gdb_signal_type) *filter,
			  int catch_all)
{
  struct signal_catchpoint *c;
  struct gdbarch *gdbarch = get_current_arch ();

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

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


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

static VEC (gdb_signal_type) *
catch_signal_split_args (char *arg, int *catch_all)
{
  VEC (gdb_signal_type) *result = NULL;
  struct cleanup *cleanup = make_cleanup (VEC_cleanup (gdb_signal_type),
					  &result);
  int first = 1;

  while (*arg != '\0')
    {
      int num;
      gdb_signal_type signal_number;
      char *one_arg, *endptr;
      struct cleanup *inner_cleanup;

      one_arg = extract_arg (&arg);
      if (one_arg == NULL)
	break;
      inner_cleanup = make_cleanup (xfree, one_arg);

      /* Check for the special flag "all".  */
      if (strcmp (one_arg, "all") == 0)
	{
	  arg = skip_spaces (arg);
	  if (*arg != '\0' || !first)
	    error (_("'all' cannot be caught with other signals"));
	  *catch_all = 1;
	  gdb_assert (result == NULL);
	  do_cleanups (inner_cleanup);
	  discard_cleanups (cleanup);
	  return NULL;
	}

      first = 0;

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

      VEC_safe_push (gdb_signal_type, result, signal_number);
      do_cleanups (inner_cleanup);
    }

  discard_cleanups (cleanup);
  return result;
}

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

static void
catch_signal_command (char *arg, int from_tty,
		      struct cmd_list_element *command)
{
  int tempflag, catch_all = 0;
  VEC (gdb_signal_type) *filter;

  tempflag = get_cmd_context (command) == CATCH_TEMPORARY;

  arg = skip_spaces (arg);

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

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

  if (arg != NULL)
    filter = catch_signal_split_args (arg, &catch_all);
  else
    filter = NULL;

  create_signal_catchpoint (tempflag, filter, catch_all);
}

static void
initialize_signal_catchpoint_ops (void)
{
  struct breakpoint_ops *ops;

  initialize_breakpoint_ops ();

  ops = &signal_catchpoint_ops;
  *ops = base_breakpoint_ops;
  ops->dtor = signal_catchpoint_dtor;
  ops->insert_location = signal_catchpoint_insert_location;
  ops->remove_location = signal_catchpoint_remove_location;
  ops->breakpoint_hit = signal_catchpoint_breakpoint_hit;
  ops->print_it = signal_catchpoint_print_it;
  ops->print_one = signal_catchpoint_print_one;
  ops->print_mention = signal_catchpoint_print_mention;
  ops->print_recreate = signal_catchpoint_print_recreate;
  ops->explains_signal = signal_catchpoint_explains_signal;
}

initialize_file_ftype _initialize_break_catch_sig;

void
_initialize_break_catch_sig (void)
{
  initialize_signal_catchpoint_ops ();

  signal_catch_counts = XCNEWVEC (unsigned int, GDB_SIGNAL_LAST);

  add_catch_command ("signal", _("\
Catch signals by their names and/or numbers.\n\
Usage: catch signal [[NAME|NUMBER] [NAME|NUMBER]...|all]\n\
Arguments say which signals to catch.  If no arguments\n\
are given, every \"normal\" signal will be caught.\n\
The argument \"all\" means to also catch signals used by GDB.\n\
Arguments, if given, should be one or more signal names\n\
(if your system supports that), or signal numbers."),
		     catch_signal_command,
		     signal_completer,
		     CATCH_PERMANENT,
		     CATCH_TEMPORARY);
}
Commit	Line	Data
ab04a2af TT	1	/* Everything about signal catchpoints, for GDB.
ab04a2af TT	2
32d0add0	3	Copyright (C) 2011-2015 Free Software Foundation, Inc.
ab04a2af TT	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"
45741a9c	26	#include "infrun.h"
ab04a2af TT	27	#include "annotate.h"
	28	#include "valprint.h"
	29	#include "cli/cli-utils.h"
	30	#include "completer.h"
	31	#include "gdb_obstack.h"
	32
	33	#define INTERNAL_SIGNAL(x) ((x) == GDB_SIGNAL_TRAP \|\| (x) == GDB_SIGNAL_INT)
	34
	35	typedef enum gdb_signal gdb_signal_type;
	36
	37	DEF_VEC_I (gdb_signal_type);
	38
	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. */
	44
	45	struct signal_catchpoint
	46	{
	47	/* The base class. */
	48
	49	struct breakpoint base;
	50
	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. */
	54
	55	VEC (gdb_signal_type) *signals_to_be_caught;
	56
	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. */
	61
	62	int catch_all;
	63	};
	64
	65	/* The breakpoint_ops structure to be used in signal catchpoints. */
	66
	67	static struct breakpoint_ops signal_catchpoint_ops;
	68
	69	/* Count of each signal. */
	70
	71	static unsigned int *signal_catch_counts;
	72
	73	\f
	74
	75	/* A convenience wrapper for gdb_signal_to_name that returns the
	76	integer value if the name is not known. */
	77
	78	static const char *
	79	signal_to_name_or_int (enum gdb_signal sig)
	80	{
	81	const char *result = gdb_signal_to_name (sig);
	82
	83	if (strcmp (result, "?") == 0)
	84	result = plongest (sig);
	85
	86	return result;
	87	}
	88
	89	\f
	90
91	/* Implement the "dtor" breakpoint_ops method for signal
92	catchpoints. */
93
94	static void
95	signal_catchpoint_dtor (struct breakpoint *b)
96	{
97	struct signal_catchpoint c = (struct signal_catchpoint ) b;
98
99	VEC_free (gdb_signal_type, c->signals_to_be_caught);
100
101	base_breakpoint_ops.dtor (b);
102	}
103
104	/* Implement the "insert_location" breakpoint_ops method for signal
105	catchpoints. */
106
107	static int
108	signal_catchpoint_insert_location (struct bp_location *bl)
109	{
110	struct signal_catchpoint c = (void ) bl->owner;
111	int i;
112
113	if (c->signals_to_be_caught != NULL)
114	{
115	gdb_signal_type iter;
116
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	}
130
131	signal_catch_update (signal_catch_counts);
132
133	return 0;
134	}
135
136	/* Implement the "remove_location" breakpoint_ops method for signal
137	catchpoints. */
138
139	static int
140	signal_catchpoint_remove_location (struct bp_location *bl)
141	{
142	struct signal_catchpoint c = (void ) bl->owner;
143	int i;
144
145	if (c->signals_to_be_caught != NULL)
146	{
147	gdb_signal_type iter;
148
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	}
168
169	signal_catch_update (signal_catch_counts);
170
171	return 0;
172	}
173
174	/* Implement the "breakpoint_hit" breakpoint_ops method for signal
175	catchpoints. */
176
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;
185
186	if (ws->kind != TARGET_WAITKIND_STOPPED)
187	return 0;
188
189	signal_number = ws->value.sig;
190
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;
198
199	for (i = 0;
200	VEC_iterate (gdb_signal_type, c->signals_to_be_caught, i, iter);
201	i++)
202	if (signal_number == iter)
96f7d3f1	203	return 1;
ab04a2af	204	/* Not the same. */
96f7d3f1 PW	205	gdb_assert (!iter);
96f7d3f1 PW	206	return 0;
ab04a2af	207	}
96f7d3f1 PW	208	else
96f7d3f1 PW	209	return c->catch_all \|\| !INTERNAL_SIGNAL (signal_number);
ab04a2af TT	210	}
	211
	212	/* Implement the "print_it" breakpoint_ops method for signal
	213	catchpoints. */
	214
	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;
	222
	223	get_last_target_status (&ptid, &last);
	224
	225	signal_name = signal_to_name_or_int (last.value.sig);
	226
	227	annotate_catchpoint (b->number);
	228
	229	printf_filtered (_("\nCatchpoint %d (signal %s), "), b->number, signal_name);
	230
	231	return PRINT_SRC_AND_LOC;
	232	}
	233
	234	/* Implement the "print_one" breakpoint_ops method for signal
	235	catchpoints. */
	236
	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;
	244
	245	get_user_print_options (&opts);
	246
	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);
	253
	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 \"");
	259
	260	if (c->signals_to_be_caught)
	261	{
	262	int i;
	263	gdb_signal_type iter;
	264	struct obstack text;
	265	struct cleanup *cleanup;
	266
	267	obstack_init (&text);
	268	cleanup = make_cleanup_obstack_free (&text);
	269
	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);
275
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, "\" ");
288
289	if (ui_out_is_mi_like_p (uiout))
290	ui_out_field_string (uiout, "catch-type", "signal");
291	}
292
293	/* Implement the "print_mention" breakpoint_ops method for signal
294	catchpoints. */
295
296	static void
297	signal_catchpoint_print_mention (struct breakpoint *b)
298	{
299	struct signal_catchpoint c = (void ) b;
300
301	if (c->signals_to_be_caught)
302	{
303	int i;
304	gdb_signal_type iter;
305
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);
310
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);
316
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	}
326
327	/* Implement the "print_recreate" breakpoint_ops method for signal
328	catchpoints. */
329
330	static void
331	signal_catchpoint_print_recreate (struct breakpoint b, struct ui_file fp)
332	{
333	struct signal_catchpoint c = (void ) b;
334
335	fprintf_unfiltered (fp, "catch signal");
336
337	if (c->signals_to_be_caught)
338	{
339	int i;
340	gdb_signal_type iter;
341
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");
c780cc2f	349	fputc_unfiltered ('\n', fp);
ab04a2af TT	350	}
	351
	352	/* Implement the "explains_signal" breakpoint_ops method for signal
	353	catchpoints. */
	354
47591c29	355	static int
427cd150	356	signal_catchpoint_explains_signal (struct breakpoint *b, enum gdb_signal sig)
ab04a2af	357	{
47591c29	358	return 1;
ab04a2af TT	359	}
	360
	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. */
	367
	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 ();
	374
	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;
	379
	380	install_breakpoint (0, &c->base, 1);
	381	}
	382
	383
	384	/* Splits the argument using space as delimiter. Returns an xmalloc'd
	385	filter list, or NULL if no filtering is required. */
	386
	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;
	394
	395	while (*arg != '\0')
	396	{
	397	int num;
	398	gdb_signal_type signal_number;
	399	char one_arg, endptr;
	400	struct cleanup *inner_cleanup;
	401
	402	one_arg = extract_arg (&arg);
	403	if (one_arg == NULL)
	404	break;
	405	inner_cleanup = make_cleanup (xfree, one_arg);
	406
	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	}
	419
	420	first = 0;
	421
	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	}
432
433	VEC_safe_push (gdb_signal_type, result, signal_number);
434	do_cleanups (inner_cleanup);
435	}
436
437	discard_cleanups (cleanup);
438	return result;
439	}
440
441	/* Implement the "catch signal" command. */
442
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;
ab04a2af TT	449
	450	tempflag = get_cmd_context (command) == CATCH_TEMPORARY;
	451
	452	arg = skip_spaces (arg);
	453
	454	/* The allowed syntax is:
	455	catch signal
	456	catch signal <name \| number> [<name \| number> ... <name \| number>]
	457
	458	Let's check if there's a signal name. */
	459
	460	if (arg != NULL)
	461	filter = catch_signal_split_args (arg, &catch_all);
	462	else
	463	filter = NULL;
	464
	465	create_signal_catchpoint (tempflag, filter, catch_all);
	466	}
	467
	468	static void
	469	initialize_signal_catchpoint_ops (void)
	470	{
	471	struct breakpoint_ops *ops;
	472
	473	initialize_breakpoint_ops ();
	474
	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	}
	487
	488	initialize_file_ftype _initialize_break_catch_sig;
	489
	490	void
	491	_initialize_break_catch_sig (void)
	492	{
	493	initialize_signal_catchpoint_ops ();
	494
	495	signal_catch_counts = XCNEWVEC (unsigned int, GDB_SIGNAL_LAST);
	496
	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	}