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

/* Everything about signal catchpoints, for GDB.

   Copyright (C) 2011-2016 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 = (struct signal_catchpoint *) 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 = (struct signal_catchpoint *) 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
    = (const struct signal_catchpoint *) 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;
  struct ui_out *uiout = current_uiout;

  get_last_target_status (&ptid, &last);

  signal_name = signal_to_name_or_int (last.value.sig);

  annotate_catchpoint (b->number);
  maybe_print_thread_hit_breakpoint (uiout);

  printf_filtered (_("Catchpoint %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 = (struct signal_catchpoint *) 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", (const char *) 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 = (struct signal_catchpoint *) 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 = (struct signal_catchpoint *) 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
618f726f	3	Copyright (C) 2011-2016 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	{
9a3c8263	110	struct signal_catchpoint c = (struct signal_catchpoint ) bl->owner;
ab04a2af TT	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	{
9a3c8263	142	struct signal_catchpoint c = (struct signal_catchpoint ) bl->owner;
ab04a2af TT	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	{
9a3c8263 SM	183	const struct signal_catchpoint *c
9a3c8263 SM	184	= (const struct signal_catchpoint *) bl->owner;
ab04a2af TT	185	gdb_signal_type signal_number;
	186
	187	if (ws->kind != TARGET_WAITKIND_STOPPED)
	188	return 0;
	189
	190	signal_number = ws->value.sig;
	191
	192	/* If we are catching specific signals in this breakpoint, then we
	193	must guarantee that the called signal is the same signal we are
	194	catching. */
	195	if (c->signals_to_be_caught)
	196	{
	197	int i;
	198	gdb_signal_type iter;
	199
	200	for (i = 0;
	201	VEC_iterate (gdb_signal_type, c->signals_to_be_caught, i, iter);
	202	i++)
	203	if (signal_number == iter)
96f7d3f1	204	return 1;
ab04a2af	205	/* Not the same. */
96f7d3f1 PW	206	gdb_assert (!iter);
96f7d3f1 PW	207	return 0;
ab04a2af	208	}
96f7d3f1 PW	209	else
96f7d3f1 PW	210	return c->catch_all \|\| !INTERNAL_SIGNAL (signal_number);
ab04a2af TT	211	}
	212
	213	/* Implement the "print_it" breakpoint_ops method for signal
	214	catchpoints. */
	215
	216	static enum print_stop_action
	217	signal_catchpoint_print_it (bpstat bs)
	218	{
	219	struct breakpoint *b = bs->breakpoint_at;
	220	ptid_t ptid;
	221	struct target_waitstatus last;
	222	const char *signal_name;
f303dbd6	223	struct ui_out *uiout = current_uiout;
ab04a2af TT	224
	225	get_last_target_status (&ptid, &last);
	226
	227	signal_name = signal_to_name_or_int (last.value.sig);
	228
	229	annotate_catchpoint (b->number);
f303dbd6	230	maybe_print_thread_hit_breakpoint (uiout);
ab04a2af	231
f303dbd6	232	printf_filtered (_("Catchpoint %d (signal %s), "), b->number, signal_name);
ab04a2af TT	233
	234	return PRINT_SRC_AND_LOC;
	235	}
	236
	237	/* Implement the "print_one" breakpoint_ops method for signal
	238	catchpoints. */
	239
	240	static void
	241	signal_catchpoint_print_one (struct breakpoint *b,
	242	struct bp_location **last_loc)
	243	{
9a3c8263	244	struct signal_catchpoint c = (struct signal_catchpoint ) b;
ab04a2af TT	245	struct value_print_options opts;
	246	struct ui_out *uiout = current_uiout;
	247
	248	get_user_print_options (&opts);
	249
	250	/* Field 4, the address, is omitted (which makes the columns
	251	not line up too nicely with the headers, but the effect
	252	is relatively readable). */
	253	if (opts.addressprint)
	254	ui_out_field_skip (uiout, "addr");
	255	annotate_field (5);
	256
	257	if (c->signals_to_be_caught
	258	&& VEC_length (gdb_signal_type, c->signals_to_be_caught) > 1)
	259	ui_out_text (uiout, "signals \"");
	260	else
	261	ui_out_text (uiout, "signal \"");
	262
	263	if (c->signals_to_be_caught)
	264	{
	265	int i;
	266	gdb_signal_type iter;
	267	struct obstack text;
	268	struct cleanup *cleanup;
	269
	270	obstack_init (&text);
	271	cleanup = make_cleanup_obstack_free (&text);
	272
	273	for (i = 0;
	274	VEC_iterate (gdb_signal_type, c->signals_to_be_caught, i, iter);
	275	i++)
	276	{
	277	const char *name = signal_to_name_or_int (iter);
	278
	279	if (i > 0)
	280	obstack_grow (&text, " ", 1);
	281	obstack_grow (&text, name, strlen (name));
	282	}
	283	obstack_grow (&text, "", 1);
79f33898	284	ui_out_field_string (uiout, "what", (const char *) obstack_base (&text));
ab04a2af TT	285	do_cleanups (cleanup);
	286	}
	287	else
	288	ui_out_field_string (uiout, "what",
	289	c->catch_all ? "<any signal>" : "<standard signals>");
	290	ui_out_text (uiout, "\" ");
	291
	292	if (ui_out_is_mi_like_p (uiout))
	293	ui_out_field_string (uiout, "catch-type", "signal");
	294	}
	295
	296	/* Implement the "print_mention" breakpoint_ops method for signal
	297	catchpoints. */
	298
	299	static void
	300	signal_catchpoint_print_mention (struct breakpoint *b)
	301	{
9a3c8263	302	struct signal_catchpoint c = (struct signal_catchpoint ) b;
ab04a2af TT	303
	304	if (c->signals_to_be_caught)
	305	{
	306	int i;
	307	gdb_signal_type iter;
	308
	309	if (VEC_length (gdb_signal_type, c->signals_to_be_caught) > 1)
	310	printf_filtered (_("Catchpoint %d (signals"), b->number);
	311	else
	312	printf_filtered (_("Catchpoint %d (signal"), b->number);
	313
	314	for (i = 0;
	315	VEC_iterate (gdb_signal_type, c->signals_to_be_caught, i, iter);
	316	i++)
	317	{
	318	const char *name = signal_to_name_or_int (iter);
	319
	320	printf_filtered (" %s", name);
	321	}
	322	printf_filtered (")");
	323	}
	324	else if (c->catch_all)
	325	printf_filtered (_("Catchpoint %d (any signal)"), b->number);
	326	else
	327	printf_filtered (_("Catchpoint %d (standard signals)"), b->number);
	328	}
	329
	330	/* Implement the "print_recreate" breakpoint_ops method for signal
	331	catchpoints. */
	332
	333	static void
	334	signal_catchpoint_print_recreate (struct breakpoint b, struct ui_file fp)
	335	{
9a3c8263	336	struct signal_catchpoint c = (struct signal_catchpoint ) b;
ab04a2af TT	337
	338	fprintf_unfiltered (fp, "catch signal");
	339
	340	if (c->signals_to_be_caught)
	341	{
	342	int i;
	343	gdb_signal_type iter;
	344
	345	for (i = 0;
	346	VEC_iterate (gdb_signal_type, c->signals_to_be_caught, i, iter);
	347	i++)
	348	fprintf_unfiltered (fp, " %s", signal_to_name_or_int (iter));
	349	}
	350	else if (c->catch_all)
	351	fprintf_unfiltered (fp, " all");
c780cc2f	352	fputc_unfiltered ('\n', fp);
ab04a2af TT	353	}
	354
	355	/* Implement the "explains_signal" breakpoint_ops method for signal
	356	catchpoints. */
	357
47591c29	358	static int
427cd150	359	signal_catchpoint_explains_signal (struct breakpoint *b, enum gdb_signal sig)
ab04a2af	360	{
47591c29	361	return 1;
ab04a2af TT	362	}
	363
	364	/* Create a new signal catchpoint. TEMPFLAG is true if this should be
	365	a temporary catchpoint. FILTER is the list of signals to catch; it
	366	can be NULL, meaning all signals. CATCH_ALL is a flag indicating
	367	whether signals used internally by gdb should be caught; it is only
	368	valid if FILTER is NULL. If FILTER is NULL and CATCH_ALL is zero,
	369	then internal signals like SIGTRAP are not caught. */
	370
	371	static void
	372	create_signal_catchpoint (int tempflag, VEC (gdb_signal_type) *filter,
	373	int catch_all)
	374	{
	375	struct signal_catchpoint *c;
	376	struct gdbarch *gdbarch = get_current_arch ();
	377
	378	c = XNEW (struct signal_catchpoint);
	379	init_catchpoint (&c->base, gdbarch, tempflag, NULL, &signal_catchpoint_ops);
	380	c->signals_to_be_caught = filter;
	381	c->catch_all = catch_all;
	382
	383	install_breakpoint (0, &c->base, 1);
	384	}
	385
	386
	387	/* Splits the argument using space as delimiter. Returns an xmalloc'd
	388	filter list, or NULL if no filtering is required. */
	389
	390	static VEC (gdb_signal_type) *
	391	catch_signal_split_args (char arg, int catch_all)
	392	{
	393	VEC (gdb_signal_type) *result = NULL;
	394	struct cleanup *cleanup = make_cleanup (VEC_cleanup (gdb_signal_type),
	395	&result);
	396	int first = 1;
	397
	398	while (*arg != '\0')
	399	{
	400	int num;
	401	gdb_signal_type signal_number;
	402	char one_arg, endptr;
	403	struct cleanup *inner_cleanup;
	404
	405	one_arg = extract_arg (&arg);
	406	if (one_arg == NULL)
	407	break;
	408	inner_cleanup = make_cleanup (xfree, one_arg);
	409
	410	/* Check for the special flag "all". */
	411	if (strcmp (one_arg, "all") == 0)
	412	{
	413	arg = skip_spaces (arg);
	414	if (*arg != '\0' \|\| !first)
	415	error (_("'all' cannot be caught with other signals"));
	416	*catch_all = 1;
	417	gdb_assert (result == NULL);
	418	do_cleanups (inner_cleanup);
	419	discard_cleanups (cleanup);
	420	return NULL;
	421	}
	422
	423	first = 0;
	424
	425	/* Check if the user provided a signal name or a number. */
426	num = (int) strtol (one_arg, &endptr, 0);
427	if (*endptr == '\0')
428	signal_number = gdb_signal_from_command (num);
429	else
430	{
431	signal_number = gdb_signal_from_name (one_arg);
432	if (signal_number == GDB_SIGNAL_UNKNOWN)
433	error (_("Unknown signal name '%s'."), one_arg);
434	}
435
436	VEC_safe_push (gdb_signal_type, result, signal_number);
437	do_cleanups (inner_cleanup);
438	}
439
440	discard_cleanups (cleanup);
441	return result;
442	}
443
444	/* Implement the "catch signal" command. */
445
446	static void
447	catch_signal_command (char *arg, int from_tty,
448	struct cmd_list_element *command)
449	{
450	int tempflag, catch_all = 0;
451	VEC (gdb_signal_type) *filter;
ab04a2af TT	452
	453	tempflag = get_cmd_context (command) == CATCH_TEMPORARY;
	454
	455	arg = skip_spaces (arg);
	456
	457	/* The allowed syntax is:
	458	catch signal
	459	catch signal <name \| number> [<name \| number> ... <name \| number>]
	460
	461	Let's check if there's a signal name. */
	462
	463	if (arg != NULL)
	464	filter = catch_signal_split_args (arg, &catch_all);
	465	else
	466	filter = NULL;
	467
	468	create_signal_catchpoint (tempflag, filter, catch_all);
	469	}
	470
	471	static void
	472	initialize_signal_catchpoint_ops (void)
	473	{
	474	struct breakpoint_ops *ops;
	475
	476	initialize_breakpoint_ops ();
	477
	478	ops = &signal_catchpoint_ops;
	479	*ops = base_breakpoint_ops;
	480	ops->dtor = signal_catchpoint_dtor;
	481	ops->insert_location = signal_catchpoint_insert_location;
	482	ops->remove_location = signal_catchpoint_remove_location;
	483	ops->breakpoint_hit = signal_catchpoint_breakpoint_hit;
	484	ops->print_it = signal_catchpoint_print_it;
	485	ops->print_one = signal_catchpoint_print_one;
	486	ops->print_mention = signal_catchpoint_print_mention;
	487	ops->print_recreate = signal_catchpoint_print_recreate;
	488	ops->explains_signal = signal_catchpoint_explains_signal;
	489	}
	490
	491	initialize_file_ftype _initialize_break_catch_sig;
	492
	493	void
	494	_initialize_break_catch_sig (void)
	495	{
	496	initialize_signal_catchpoint_ops ();
	497
	498	signal_catch_counts = XCNEWVEC (unsigned int, GDB_SIGNAL_LAST);
	499
	500	add_catch_command ("signal", _("\
	501	Catch signals by their names and/or numbers.\n\
	502	Usage: catch signal [[NAME\|NUMBER] [NAME\|NUMBER]...\|all]\n\
	503	Arguments say which signals to catch. If no arguments\n\
	504	are given, every \"normal\" signal will be caught.\n\
	505	The argument \"all\" means to also catch signals used by GDB.\n\
	506	Arguments, if given, should be one or more signal names\n\
	507	(if your system supports that), or signal numbers."),
	508	catch_signal_command,
	509	signal_completer,
	510	CATCH_PERMANENT,
	511	CATCH_TEMPORARY);
	512	}