[deliverable/binutils-gdb.git] / gdb / common / signals.c

/* Target signal translation functions for GDB.
   Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
   2000, 2001, 2002, 2003, 2006, 2007, 2008, 2009, 2010, 2011
   Free Software Foundation, Inc.
   Contributed by Cygnus Support.

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

#ifdef GDBSERVER
#include "server.h"
#else
#include "defs.h"
#include "gdb_string.h"
#endif

#ifdef HAVE_SIGNAL_H
#include <signal.h>
#endif

#include "gdb_signals.h"

struct gdbarch;

/* Always use __SIGRTMIN if it's available.  SIGRTMIN is the lowest
   _available_ realtime signal, not the lowest supported; glibc takes
   several for its own use.  */

#ifndef REALTIME_LO
# if defined(__SIGRTMIN)
#  define REALTIME_LO __SIGRTMIN
#  define REALTIME_HI (__SIGRTMAX + 1)
# elif defined(SIGRTMIN)
#  define REALTIME_LO SIGRTMIN
#  define REALTIME_HI (SIGRTMAX + 1)
# endif
#endif

/* This table must match in order and size the signals in enum
   target_signal.  */

static const struct {
  const char *name;
  const char *string;
  } signals [] =
{
#define SET(symbol, constant, name, string) { name, string },
#include "gdb/signals.def"
#undef SET
};


/* Return the string for a signal.  */
const char *
target_signal_to_string (enum target_signal sig)
{
  if ((int) sig >= TARGET_SIGNAL_FIRST && (int) sig <= TARGET_SIGNAL_LAST)
    return signals[sig].string;
  else
    return signals[TARGET_SIGNAL_UNKNOWN].string;
}

/* Return the name for a signal.  */
const char *
target_signal_to_name (enum target_signal sig)
{
  if ((int) sig >= TARGET_SIGNAL_FIRST && (int) sig <= TARGET_SIGNAL_LAST
      && signals[sig].name != NULL)
    return signals[sig].name;
  else
    /* I think the code which prints this will always print it along
       with the string, so no need to be verbose (very old comment).  */
    return "?";
}

/* Given a name, return its signal.  */
enum target_signal
target_signal_from_name (const char *name)
{
  enum target_signal sig;

  /* It's possible we also should allow "SIGCLD" as well as "SIGCHLD"
     for TARGET_SIGNAL_SIGCHLD.  SIGIOT, on the other hand, is more
     questionable; seems like by now people should call it SIGABRT
     instead.  */

  /* This ugly cast brought to you by the native VAX compiler.  */
  for (sig = TARGET_SIGNAL_HUP;
       sig < TARGET_SIGNAL_LAST;
       sig = (enum target_signal) ((int) sig + 1))
    if (signals[sig].name != NULL
	&& strcmp (name, signals[sig].name) == 0)
      return sig;
  return TARGET_SIGNAL_UNKNOWN;
}
\f
/* The following functions are to help certain targets deal
   with the signal/waitstatus stuff.  They could just as well be in
   a file called native-utils.c or unixwaitstatus-utils.c or whatever.  */

/* Convert host signal to our signals.  */
enum target_signal
target_signal_from_host (int hostsig)
{
  /* A switch statement would make sense but would require special kludges
     to deal with the cases where more than one signal has the same number.  */

  if (hostsig == 0)
    return TARGET_SIGNAL_0;

#if defined (SIGHUP)
  if (hostsig == SIGHUP)
    return TARGET_SIGNAL_HUP;
#endif
#if defined (SIGINT)
  if (hostsig == SIGINT)
    return TARGET_SIGNAL_INT;
#endif
#if defined (SIGQUIT)
  if (hostsig == SIGQUIT)
    return TARGET_SIGNAL_QUIT;
#endif
#if defined (SIGILL)
  if (hostsig == SIGILL)
    return TARGET_SIGNAL_ILL;
#endif
#if defined (SIGTRAP)
  if (hostsig == SIGTRAP)
    return TARGET_SIGNAL_TRAP;
#endif
#if defined (SIGABRT)
  if (hostsig == SIGABRT)
    return TARGET_SIGNAL_ABRT;
#endif
#if defined (SIGEMT)
  if (hostsig == SIGEMT)
    return TARGET_SIGNAL_EMT;
#endif
#if defined (SIGFPE)
  if (hostsig == SIGFPE)
    return TARGET_SIGNAL_FPE;
#endif
#if defined (SIGKILL)
  if (hostsig == SIGKILL)
    return TARGET_SIGNAL_KILL;
#endif
#if defined (SIGBUS)
  if (hostsig == SIGBUS)
    return TARGET_SIGNAL_BUS;
#endif
#if defined (SIGSEGV)
  if (hostsig == SIGSEGV)
    return TARGET_SIGNAL_SEGV;
#endif
#if defined (SIGSYS)
  if (hostsig == SIGSYS)
    return TARGET_SIGNAL_SYS;
#endif
#if defined (SIGPIPE)
  if (hostsig == SIGPIPE)
    return TARGET_SIGNAL_PIPE;
#endif
#if defined (SIGALRM)
  if (hostsig == SIGALRM)
    return TARGET_SIGNAL_ALRM;
#endif
#if defined (SIGTERM)
  if (hostsig == SIGTERM)
    return TARGET_SIGNAL_TERM;
#endif
#if defined (SIGUSR1)
  if (hostsig == SIGUSR1)
    return TARGET_SIGNAL_USR1;
#endif
#if defined (SIGUSR2)
  if (hostsig == SIGUSR2)
    return TARGET_SIGNAL_USR2;
#endif
#if defined (SIGCLD)
  if (hostsig == SIGCLD)
    return TARGET_SIGNAL_CHLD;
#endif
#if defined (SIGCHLD)
  if (hostsig == SIGCHLD)
    return TARGET_SIGNAL_CHLD;
#endif
#if defined (SIGPWR)
  if (hostsig == SIGPWR)
    return TARGET_SIGNAL_PWR;
#endif
#if defined (SIGWINCH)
  if (hostsig == SIGWINCH)
    return TARGET_SIGNAL_WINCH;
#endif
#if defined (SIGURG)
  if (hostsig == SIGURG)
    return TARGET_SIGNAL_URG;
#endif
#if defined (SIGIO)
  if (hostsig == SIGIO)
    return TARGET_SIGNAL_IO;
#endif
#if defined (SIGPOLL)
  if (hostsig == SIGPOLL)
    return TARGET_SIGNAL_POLL;
#endif
#if defined (SIGSTOP)
  if (hostsig == SIGSTOP)
    return TARGET_SIGNAL_STOP;
#endif
#if defined (SIGTSTP)
  if (hostsig == SIGTSTP)
    return TARGET_SIGNAL_TSTP;
#endif
#if defined (SIGCONT)
  if (hostsig == SIGCONT)
    return TARGET_SIGNAL_CONT;
#endif
#if defined (SIGTTIN)
  if (hostsig == SIGTTIN)
    return TARGET_SIGNAL_TTIN;
#endif
#if defined (SIGTTOU)
  if (hostsig == SIGTTOU)
    return TARGET_SIGNAL_TTOU;
#endif
#if defined (SIGVTALRM)
  if (hostsig == SIGVTALRM)
    return TARGET_SIGNAL_VTALRM;
#endif
#if defined (SIGPROF)
  if (hostsig == SIGPROF)
    return TARGET_SIGNAL_PROF;
#endif
#if defined (SIGXCPU)
  if (hostsig == SIGXCPU)
    return TARGET_SIGNAL_XCPU;
#endif
#if defined (SIGXFSZ)
  if (hostsig == SIGXFSZ)
    return TARGET_SIGNAL_XFSZ;
#endif
#if defined (SIGWIND)
  if (hostsig == SIGWIND)
    return TARGET_SIGNAL_WIND;
#endif
#if defined (SIGPHONE)
  if (hostsig == SIGPHONE)
    return TARGET_SIGNAL_PHONE;
#endif
#if defined (SIGLOST)
  if (hostsig == SIGLOST)
    return TARGET_SIGNAL_LOST;
#endif
#if defined (SIGWAITING)
  if (hostsig == SIGWAITING)
    return TARGET_SIGNAL_WAITING;
#endif
#if defined (SIGCANCEL)
  if (hostsig == SIGCANCEL)
    return TARGET_SIGNAL_CANCEL;
#endif
#if defined (SIGLWP)
  if (hostsig == SIGLWP)
    return TARGET_SIGNAL_LWP;
#endif
#if defined (SIGDANGER)
  if (hostsig == SIGDANGER)
    return TARGET_SIGNAL_DANGER;
#endif
#if defined (SIGGRANT)
  if (hostsig == SIGGRANT)
    return TARGET_SIGNAL_GRANT;
#endif
#if defined (SIGRETRACT)
  if (hostsig == SIGRETRACT)
    return TARGET_SIGNAL_RETRACT;
#endif
#if defined (SIGMSG)
  if (hostsig == SIGMSG)
    return TARGET_SIGNAL_MSG;
#endif
#if defined (SIGSOUND)
  if (hostsig == SIGSOUND)
    return TARGET_SIGNAL_SOUND;
#endif
#if defined (SIGSAK)
  if (hostsig == SIGSAK)
    return TARGET_SIGNAL_SAK;
#endif
#if defined (SIGPRIO)
  if (hostsig == SIGPRIO)
    return TARGET_SIGNAL_PRIO;
#endif

  /* Mach exceptions.  Assumes that the values for EXC_ are positive! */
#if defined (EXC_BAD_ACCESS) && defined (_NSIG)
  if (hostsig == _NSIG + EXC_BAD_ACCESS)
    return TARGET_EXC_BAD_ACCESS;
#endif
#if defined (EXC_BAD_INSTRUCTION) && defined (_NSIG)
  if (hostsig == _NSIG + EXC_BAD_INSTRUCTION)
    return TARGET_EXC_BAD_INSTRUCTION;
#endif
#if defined (EXC_ARITHMETIC) && defined (_NSIG)
  if (hostsig == _NSIG + EXC_ARITHMETIC)
    return TARGET_EXC_ARITHMETIC;
#endif
#if defined (EXC_EMULATION) && defined (_NSIG)
  if (hostsig == _NSIG + EXC_EMULATION)
    return TARGET_EXC_EMULATION;
#endif
#if defined (EXC_SOFTWARE) && defined (_NSIG)
  if (hostsig == _NSIG + EXC_SOFTWARE)
    return TARGET_EXC_SOFTWARE;
#endif
#if defined (EXC_BREAKPOINT) && defined (_NSIG)
  if (hostsig == _NSIG + EXC_BREAKPOINT)
    return TARGET_EXC_BREAKPOINT;
#endif

#if defined (SIGINFO)
  if (hostsig == SIGINFO)
    return TARGET_SIGNAL_INFO;
#endif

#if defined (REALTIME_LO)
  if (hostsig >= REALTIME_LO && hostsig < REALTIME_HI)
    {
      /* This block of TARGET_SIGNAL_REALTIME value is in order.  */
      if (33 <= hostsig && hostsig <= 63)
	return (enum target_signal)
	  (hostsig - 33 + (int) TARGET_SIGNAL_REALTIME_33);
      else if (hostsig == 32)
	return TARGET_SIGNAL_REALTIME_32;
      else if (64 <= hostsig && hostsig <= 127)
	return (enum target_signal)
	  (hostsig - 64 + (int) TARGET_SIGNAL_REALTIME_64);
      else
	error ("GDB bug: target.c (target_signal_from_host): "
	       "unrecognized real-time signal");
    }
#endif

  return TARGET_SIGNAL_UNKNOWN;
}

/* Convert a OURSIG (an enum target_signal) to the form used by the
   target operating system (refered to as the ``host'') or zero if the
   equivalent host signal is not available.  Set/clear OURSIG_OK
   accordingly. */

static int
do_target_signal_to_host (enum target_signal oursig,
			  int *oursig_ok)
{
  int retsig;
  /* Silence the 'not used' warning, for targets that
     do not support signals.  */
  (void) retsig;

  *oursig_ok = 1;
  switch (oursig)
    {
    case TARGET_SIGNAL_0:
      return 0;

#if defined (SIGHUP)
    case TARGET_SIGNAL_HUP:
      return SIGHUP;
#endif
#if defined (SIGINT)
    case TARGET_SIGNAL_INT:
      return SIGINT;
#endif
#if defined (SIGQUIT)
    case TARGET_SIGNAL_QUIT:
      return SIGQUIT;
#endif
#if defined (SIGILL)
    case TARGET_SIGNAL_ILL:
      return SIGILL;
#endif
#if defined (SIGTRAP)
    case TARGET_SIGNAL_TRAP:
      return SIGTRAP;
#endif
#if defined (SIGABRT)
    case TARGET_SIGNAL_ABRT:
      return SIGABRT;
#endif
#if defined (SIGEMT)
    case TARGET_SIGNAL_EMT:
      return SIGEMT;
#endif
#if defined (SIGFPE)
    case TARGET_SIGNAL_FPE:
      return SIGFPE;
#endif
#if defined (SIGKILL)
    case TARGET_SIGNAL_KILL:
      return SIGKILL;
#endif
#if defined (SIGBUS)
    case TARGET_SIGNAL_BUS:
      return SIGBUS;
#endif
#if defined (SIGSEGV)
    case TARGET_SIGNAL_SEGV:
      return SIGSEGV;
#endif
#if defined (SIGSYS)
    case TARGET_SIGNAL_SYS:
      return SIGSYS;
#endif
#if defined (SIGPIPE)
    case TARGET_SIGNAL_PIPE:
      return SIGPIPE;
#endif
#if defined (SIGALRM)
    case TARGET_SIGNAL_ALRM:
      return SIGALRM;
#endif
#if defined (SIGTERM)
    case TARGET_SIGNAL_TERM:
      return SIGTERM;
#endif
#if defined (SIGUSR1)
    case TARGET_SIGNAL_USR1:
      return SIGUSR1;
#endif
#if defined (SIGUSR2)
    case TARGET_SIGNAL_USR2:
      return SIGUSR2;
#endif
#if defined (SIGCHLD) || defined (SIGCLD)
    case TARGET_SIGNAL_CHLD:
#if defined (SIGCHLD)
      return SIGCHLD;
#else
      return SIGCLD;
#endif
#endif /* SIGCLD or SIGCHLD */
#if defined (SIGPWR)
    case TARGET_SIGNAL_PWR:
      return SIGPWR;
#endif
#if defined (SIGWINCH)
    case TARGET_SIGNAL_WINCH:
      return SIGWINCH;
#endif
#if defined (SIGURG)
    case TARGET_SIGNAL_URG:
      return SIGURG;
#endif
#if defined (SIGIO)
    case TARGET_SIGNAL_IO:
      return SIGIO;
#endif
#if defined (SIGPOLL)
    case TARGET_SIGNAL_POLL:
      return SIGPOLL;
#endif
#if defined (SIGSTOP)
    case TARGET_SIGNAL_STOP:
      return SIGSTOP;
#endif
#if defined (SIGTSTP)
    case TARGET_SIGNAL_TSTP:
      return SIGTSTP;
#endif
#if defined (SIGCONT)
    case TARGET_SIGNAL_CONT:
      return SIGCONT;
#endif
#if defined (SIGTTIN)
    case TARGET_SIGNAL_TTIN:
      return SIGTTIN;
#endif
#if defined (SIGTTOU)
    case TARGET_SIGNAL_TTOU:
      return SIGTTOU;
#endif
#if defined (SIGVTALRM)
    case TARGET_SIGNAL_VTALRM:
      return SIGVTALRM;
#endif
#if defined (SIGPROF)
    case TARGET_SIGNAL_PROF:
      return SIGPROF;
#endif
#if defined (SIGXCPU)
    case TARGET_SIGNAL_XCPU:
      return SIGXCPU;
#endif
#if defined (SIGXFSZ)
    case TARGET_SIGNAL_XFSZ:
      return SIGXFSZ;
#endif
#if defined (SIGWIND)
    case TARGET_SIGNAL_WIND:
      return SIGWIND;
#endif
#if defined (SIGPHONE)
    case TARGET_SIGNAL_PHONE:
      return SIGPHONE;
#endif
#if defined (SIGLOST)
    case TARGET_SIGNAL_LOST:
      return SIGLOST;
#endif
#if defined (SIGWAITING)
    case TARGET_SIGNAL_WAITING:
      return SIGWAITING;
#endif
#if defined (SIGCANCEL)
    case TARGET_SIGNAL_CANCEL:
      return SIGCANCEL;
#endif
#if defined (SIGLWP)
    case TARGET_SIGNAL_LWP:
      return SIGLWP;
#endif
#if defined (SIGDANGER)
    case TARGET_SIGNAL_DANGER:
      return SIGDANGER;
#endif
#if defined (SIGGRANT)
    case TARGET_SIGNAL_GRANT:
      return SIGGRANT;
#endif
#if defined (SIGRETRACT)
    case TARGET_SIGNAL_RETRACT:
      return SIGRETRACT;
#endif
#if defined (SIGMSG)
    case TARGET_SIGNAL_MSG:
      return SIGMSG;
#endif
#if defined (SIGSOUND)
    case TARGET_SIGNAL_SOUND:
      return SIGSOUND;
#endif
#if defined (SIGSAK)
    case TARGET_SIGNAL_SAK:
      return SIGSAK;
#endif
#if defined (SIGPRIO)
    case TARGET_SIGNAL_PRIO:
      return SIGPRIO;
#endif

      /* Mach exceptions.  Assumes that the values for EXC_ are positive! */
#if defined (EXC_BAD_ACCESS) && defined (_NSIG)
    case TARGET_EXC_BAD_ACCESS:
      return _NSIG + EXC_BAD_ACCESS;
#endif
#if defined (EXC_BAD_INSTRUCTION) && defined (_NSIG)
    case TARGET_EXC_BAD_INSTRUCTION:
      return _NSIG + EXC_BAD_INSTRUCTION;
#endif
#if defined (EXC_ARITHMETIC) && defined (_NSIG)
    case TARGET_EXC_ARITHMETIC:
      return _NSIG + EXC_ARITHMETIC;
#endif
#if defined (EXC_EMULATION) && defined (_NSIG)
    case TARGET_EXC_EMULATION:
      return _NSIG + EXC_EMULATION;
#endif
#if defined (EXC_SOFTWARE) && defined (_NSIG)
    case TARGET_EXC_SOFTWARE:
      return _NSIG + EXC_SOFTWARE;
#endif
#if defined (EXC_BREAKPOINT) && defined (_NSIG)
    case TARGET_EXC_BREAKPOINT:
      return _NSIG + EXC_BREAKPOINT;
#endif

#if defined (SIGINFO)
    case TARGET_SIGNAL_INFO:
      return SIGINFO;
#endif

    default:
#if defined (REALTIME_LO)
      retsig = 0;

      if (oursig >= TARGET_SIGNAL_REALTIME_33
	  && oursig <= TARGET_SIGNAL_REALTIME_63)
	{
	  /* This block of signals is continuous, and
             TARGET_SIGNAL_REALTIME_33 is 33 by definition.  */
	  retsig = (int) oursig - (int) TARGET_SIGNAL_REALTIME_33 + 33;
	}
      else if (oursig == TARGET_SIGNAL_REALTIME_32)
	{
	  /* TARGET_SIGNAL_REALTIME_32 isn't contiguous with
             TARGET_SIGNAL_REALTIME_33.  It is 32 by definition.  */
	  retsig = 32;
	}
      else if (oursig >= TARGET_SIGNAL_REALTIME_64
	  && oursig <= TARGET_SIGNAL_REALTIME_127)
	{
	  /* This block of signals is continuous, and
             TARGET_SIGNAL_REALTIME_64 is 64 by definition.  */
	  retsig = (int) oursig - (int) TARGET_SIGNAL_REALTIME_64 + 64;
	}

      if (retsig >= REALTIME_LO && retsig < REALTIME_HI)
	return retsig;
#endif

      *oursig_ok = 0;
      return 0;
    }
}

int
target_signal_to_host_p (enum target_signal oursig)
{
  int oursig_ok;
  do_target_signal_to_host (oursig, &oursig_ok);
  return oursig_ok;
}

int
target_signal_to_host (enum target_signal oursig)
{
  int oursig_ok;
  int targ_signo = do_target_signal_to_host (oursig, &oursig_ok);
  if (!oursig_ok)
    {
      /* The user might be trying to do "signal SIGSAK" where this system
         doesn't have SIGSAK.  */
      warning ("Signal %s does not exist on this system.\n",
	       target_signal_to_name (oursig));
      return 0;
    }
  else
    return targ_signo;
}

#ifndef GDBSERVER

/* In some circumstances we allow a command to specify a numeric
   signal.  The idea is to keep these circumstances limited so that
   users (and scripts) develop portable habits.  For comparison,
   POSIX.2 `kill' requires that 1,2,3,6,9,14, and 15 work (and using a
   numeric signal at all is obsolescent.  We are slightly more
   lenient and allow 1-15 which should match host signal numbers on
   most systems.  Use of symbolic signal names is strongly encouraged.  */

enum target_signal
target_signal_from_command (int num)
{
  if (num >= 1 && num <= 15)
    return (enum target_signal) num;
  error ("Only signals 1-15 are valid as numeric signals.\n\
Use \"info signals\" for a list of symbolic signals.");
}

extern initialize_file_ftype _initialize_signals; /* -Wmissing-prototype */

void
_initialize_signals (void)
{
  if (strcmp (signals[TARGET_SIGNAL_LAST].string, "TARGET_SIGNAL_MAGIC") != 0)
    internal_error (__FILE__, __LINE__, "failed internal consistency check");
}

int
default_target_signal_to_host (struct gdbarch *gdbarch, enum target_signal ts)
{
  return target_signal_to_host (ts);
}

enum target_signal
default_target_signal_from_host (struct gdbarch *gdbarch, int signo)
{
  return target_signal_from_host (signo);
}

#endif /* ! GDBSERVER */
Commit	Line	Data
0150732f	1	/* Target signal translation functions for GDB.
8c719703	2	Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
7b6bb8da	3	2000, 2001, 2002, 2003, 2006, 2007, 2008, 2009, 2010, 2011
0fb0cc75	4	Free Software Foundation, Inc.
0150732f DJ	5	Contributed by Cygnus Support.
	6
	7	This file is part of GDB.
	8
	9	This program is free software; you can redistribute it and/or modify
	10	it under the terms of the GNU General Public License as published by
a9762ec7	11	the Free Software Foundation; either version 3 of the License, or
0150732f DJ	12	(at your option) any later version.
	13
	14	This program is distributed in the hope that it will be useful,
	15	but WITHOUT ANY WARRANTY; without even the implied warranty of
	16	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	17	GNU General Public License for more details.
	18
	19	You should have received a copy of the GNU General Public License
a9762ec7	20	along with this program. If not, see <http://www.gnu.org/licenses/>. */
0150732f	21
3130066b DJ	22	#ifdef GDBSERVER
	23	#include "server.h"
	24	#else
0150732f	25	#include "defs.h"
309367d4	26	#include "gdb_string.h"
3130066b DJ	27	#endif
3130066b DJ	28
68070c10	29	#ifdef HAVE_SIGNAL_H
0150732f	30	#include <signal.h>
68070c10	31	#endif
0150732f	32
2aecd87f DE	33	#include "gdb_signals.h"
2aecd87f DE	34
1cded358 AR	35	struct gdbarch;
1cded358 AR	36
960cb555 DJ	37	/* Always use __SIGRTMIN if it's available. SIGRTMIN is the lowest
	38	_available_ realtime signal, not the lowest supported; glibc takes
	39	several for its own use. */
	40
	41	#ifndef REALTIME_LO
	42	# if defined(__SIGRTMIN)
	43	# define REALTIME_LO __SIGRTMIN
0b757755	44	# define REALTIME_HI (__SIGRTMAX + 1)
960cb555	45	# elif defined(SIGRTMIN)
bdd73e22	46	# define REALTIME_LO SIGRTMIN
0b757755	47	# define REALTIME_HI (SIGRTMAX + 1)
960cb555 DJ	48	# endif
	49	#endif
	50
9a2b4c1b MS	51	/* This table must match in order and size the signals in enum
9a2b4c1b MS	52	target_signal. */
a19cae16	53
54363045 DE	54	static const struct {
	55	const char *name;
	56	const char *string;
0150732f DJ	57	} signals [] =
0150732f DJ	58	{
a6eb9bc8	59	#define SET(symbol, constant, name, string) { name, string },
a19cae16	60	#include "gdb/signals.def"
a19cae16	61	#undef SET
0150732f	62	};
0150732f DJ	63
	64
	65	/* Return the string for a signal. */
54363045	66	const char *
0150732f DJ	67	target_signal_to_string (enum target_signal sig)
0150732f DJ	68	{
d5d6fca5	69	if ((int) sig >= TARGET_SIGNAL_FIRST && (int) sig <= TARGET_SIGNAL_LAST)
0150732f DJ	70	return signals[sig].string;
	71	else
	72	return signals[TARGET_SIGNAL_UNKNOWN].string;
	73	}
	74
	75	/* Return the name for a signal. */
54363045	76	const char *
0150732f DJ	77	target_signal_to_name (enum target_signal sig)
0150732f DJ	78	{
d5d6fca5	79	if ((int) sig >= TARGET_SIGNAL_FIRST && (int) sig <= TARGET_SIGNAL_LAST
ade8f45e	80	&& signals[sig].name != NULL)
89c49e7a AC	81	return signals[sig].name;
89c49e7a AC	82	else
ade8f45e AC	83	/* I think the code which prints this will always print it along
	84	with the string, so no need to be verbose (very old comment). */
	85	return "?";
0150732f DJ	86	}
	87
	88	/* Given a name, return its signal. */
	89	enum target_signal
54363045	90	target_signal_from_name (const char *name)
0150732f DJ	91	{
	92	enum target_signal sig;
	93
	94	/* It's possible we also should allow "SIGCLD" as well as "SIGCHLD"
	95	for TARGET_SIGNAL_SIGCHLD. SIGIOT, on the other hand, is more
	96	questionable; seems like by now people should call it SIGABRT
	97	instead. */
	98
	99	/* This ugly cast brought to you by the native VAX compiler. */
	100	for (sig = TARGET_SIGNAL_HUP;
fd326606	101	sig < TARGET_SIGNAL_LAST;
0150732f	102	sig = (enum target_signal) ((int) sig + 1))
fd326606 DJ	103	if (signals[sig].name != NULL
fd326606 DJ	104	&& strcmp (name, signals[sig].name) == 0)
0150732f DJ	105	return sig;
	106	return TARGET_SIGNAL_UNKNOWN;
	107	}
	108	\f
	109	/* The following functions are to help certain targets deal
	110	with the signal/waitstatus stuff. They could just as well be in
	111	a file called native-utils.c or unixwaitstatus-utils.c or whatever. */
	112
	113	/* Convert host signal to our signals. */
	114	enum target_signal
	115	target_signal_from_host (int hostsig)
	116	{
	117	/* A switch statement would make sense but would require special kludges
	118	to deal with the cases where more than one signal has the same number. */
	119
	120	if (hostsig == 0)
	121	return TARGET_SIGNAL_0;
	122
	123	#if defined (SIGHUP)
	124	if (hostsig == SIGHUP)
	125	return TARGET_SIGNAL_HUP;
	126	#endif
	127	#if defined (SIGINT)
	128	if (hostsig == SIGINT)
	129	return TARGET_SIGNAL_INT;
	130	#endif
	131	#if defined (SIGQUIT)
	132	if (hostsig == SIGQUIT)
	133	return TARGET_SIGNAL_QUIT;
	134	#endif
	135	#if defined (SIGILL)
	136	if (hostsig == SIGILL)
	137	return TARGET_SIGNAL_ILL;
	138	#endif
	139	#if defined (SIGTRAP)
	140	if (hostsig == SIGTRAP)
	141	return TARGET_SIGNAL_TRAP;
	142	#endif
	143	#if defined (SIGABRT)
	144	if (hostsig == SIGABRT)
	145	return TARGET_SIGNAL_ABRT;
	146	#endif
	147	#if defined (SIGEMT)
	148	if (hostsig == SIGEMT)
	149	return TARGET_SIGNAL_EMT;
	150	#endif
	151	#if defined (SIGFPE)
	152	if (hostsig == SIGFPE)
	153	return TARGET_SIGNAL_FPE;
	154	#endif
	155	#if defined (SIGKILL)
	156	if (hostsig == SIGKILL)
	157	return TARGET_SIGNAL_KILL;
	158	#endif
	159	#if defined (SIGBUS)
	160	if (hostsig == SIGBUS)
	161	return TARGET_SIGNAL_BUS;
	162	#endif
	163	#if defined (SIGSEGV)
	164	if (hostsig == SIGSEGV)
	165	return TARGET_SIGNAL_SEGV;
	166	#endif
	167	#if defined (SIGSYS)
	168	if (hostsig == SIGSYS)
169	return TARGET_SIGNAL_SYS;
170	#endif
171	#if defined (SIGPIPE)
172	if (hostsig == SIGPIPE)
173	return TARGET_SIGNAL_PIPE;
174	#endif
175	#if defined (SIGALRM)
176	if (hostsig == SIGALRM)
177	return TARGET_SIGNAL_ALRM;
178	#endif
179	#if defined (SIGTERM)
180	if (hostsig == SIGTERM)
181	return TARGET_SIGNAL_TERM;
182	#endif
183	#if defined (SIGUSR1)
184	if (hostsig == SIGUSR1)
185	return TARGET_SIGNAL_USR1;
186	#endif
187	#if defined (SIGUSR2)
188	if (hostsig == SIGUSR2)
189	return TARGET_SIGNAL_USR2;
190	#endif
191	#if defined (SIGCLD)
192	if (hostsig == SIGCLD)
193	return TARGET_SIGNAL_CHLD;
194	#endif
195	#if defined (SIGCHLD)
196	if (hostsig == SIGCHLD)
197	return TARGET_SIGNAL_CHLD;
198	#endif
199	#if defined (SIGPWR)
200	if (hostsig == SIGPWR)
201	return TARGET_SIGNAL_PWR;
202	#endif
203	#if defined (SIGWINCH)
204	if (hostsig == SIGWINCH)
205	return TARGET_SIGNAL_WINCH;
206	#endif
207	#if defined (SIGURG)
208	if (hostsig == SIGURG)
209	return TARGET_SIGNAL_URG;
210	#endif
211	#if defined (SIGIO)
212	if (hostsig == SIGIO)
213	return TARGET_SIGNAL_IO;
214	#endif
215	#if defined (SIGPOLL)
216	if (hostsig == SIGPOLL)
217	return TARGET_SIGNAL_POLL;
218	#endif
219	#if defined (SIGSTOP)
220	if (hostsig == SIGSTOP)
221	return TARGET_SIGNAL_STOP;
222	#endif
223	#if defined (SIGTSTP)
224	if (hostsig == SIGTSTP)
225	return TARGET_SIGNAL_TSTP;
226	#endif
227	#if defined (SIGCONT)
228	if (hostsig == SIGCONT)
229	return TARGET_SIGNAL_CONT;
230	#endif
231	#if defined (SIGTTIN)
232	if (hostsig == SIGTTIN)
233	return TARGET_SIGNAL_TTIN;
234	#endif
235	#if defined (SIGTTOU)
236	if (hostsig == SIGTTOU)
237	return TARGET_SIGNAL_TTOU;
238	#endif
239	#if defined (SIGVTALRM)
240	if (hostsig == SIGVTALRM)
241	return TARGET_SIGNAL_VTALRM;
242	#endif
243	#if defined (SIGPROF)
244	if (hostsig == SIGPROF)
245	return TARGET_SIGNAL_PROF;
246	#endif
247	#if defined (SIGXCPU)
248	if (hostsig == SIGXCPU)
249	return TARGET_SIGNAL_XCPU;
250	#endif
251	#if defined (SIGXFSZ)
252	if (hostsig == SIGXFSZ)
253	return TARGET_SIGNAL_XFSZ;
254	#endif
255	#if defined (SIGWIND)
256	if (hostsig == SIGWIND)
257	return TARGET_SIGNAL_WIND;
258	#endif
259	#if defined (SIGPHONE)
260	if (hostsig == SIGPHONE)
261	return TARGET_SIGNAL_PHONE;
262	#endif
263	#if defined (SIGLOST)
264	if (hostsig == SIGLOST)
265	return TARGET_SIGNAL_LOST;
266	#endif
267	#if defined (SIGWAITING)
268	if (hostsig == SIGWAITING)
269	return TARGET_SIGNAL_WAITING;
270	#endif
271	#if defined (SIGCANCEL)
272	if (hostsig == SIGCANCEL)
273	return TARGET_SIGNAL_CANCEL;
274	#endif
275	#if defined (SIGLWP)
276	if (hostsig == SIGLWP)
277	return TARGET_SIGNAL_LWP;
278	#endif
279	#if defined (SIGDANGER)
280	if (hostsig == SIGDANGER)
281	return TARGET_SIGNAL_DANGER;
282	#endif
283	#if defined (SIGGRANT)
284	if (hostsig == SIGGRANT)
285	return TARGET_SIGNAL_GRANT;
286	#endif
287	#if defined (SIGRETRACT)
288	if (hostsig == SIGRETRACT)
289	return TARGET_SIGNAL_RETRACT;
290	#endif
291	#if defined (SIGMSG)
292	if (hostsig == SIGMSG)
293	return TARGET_SIGNAL_MSG;
294	#endif
295	#if defined (SIGSOUND)
296	if (hostsig == SIGSOUND)
297	return TARGET_SIGNAL_SOUND;
298	#endif
299	#if defined (SIGSAK)
300	if (hostsig == SIGSAK)
301	return TARGET_SIGNAL_SAK;
302	#endif
303	#if defined (SIGPRIO)
304	if (hostsig == SIGPRIO)
305	return TARGET_SIGNAL_PRIO;
306	#endif
307
308	/* Mach exceptions. Assumes that the values for EXC_ are positive! */
309	#if defined (EXC_BAD_ACCESS) && defined (_NSIG)
310	if (hostsig == _NSIG + EXC_BAD_ACCESS)
311	return TARGET_EXC_BAD_ACCESS;
312	#endif
313	#if defined (EXC_BAD_INSTRUCTION) && defined (_NSIG)
314	if (hostsig == _NSIG + EXC_BAD_INSTRUCTION)
315	return TARGET_EXC_BAD_INSTRUCTION;
316	#endif
317	#if defined (EXC_ARITHMETIC) && defined (_NSIG)
318	if (hostsig == _NSIG + EXC_ARITHMETIC)
319	return TARGET_EXC_ARITHMETIC;
320	#endif
321	#if defined (EXC_EMULATION) && defined (_NSIG)
322	if (hostsig == _NSIG + EXC_EMULATION)
323	return TARGET_EXC_EMULATION;
324	#endif
325	#if defined (EXC_SOFTWARE) && defined (_NSIG)
326	if (hostsig == _NSIG + EXC_SOFTWARE)
327	return TARGET_EXC_SOFTWARE;
328	#endif
329	#if defined (EXC_BREAKPOINT) && defined (_NSIG)
330	if (hostsig == _NSIG + EXC_BREAKPOINT)
331	return TARGET_EXC_BREAKPOINT;
332	#endif
333
334	#if defined (SIGINFO)
335	if (hostsig == SIGINFO)
336	return TARGET_SIGNAL_INFO;
337	#endif
338
339	#if defined (REALTIME_LO)
340	if (hostsig >= REALTIME_LO && hostsig < REALTIME_HI)
341	{
342	/* This block of TARGET_SIGNAL_REALTIME value is in order. */
343	if (33 <= hostsig && hostsig <= 63)
344	return (enum target_signal)
345	(hostsig - 33 + (int) TARGET_SIGNAL_REALTIME_33);
346	else if (hostsig == 32)
347	return TARGET_SIGNAL_REALTIME_32;
348	else if (64 <= hostsig && hostsig <= 127)
349	return (enum target_signal)
350	(hostsig - 64 + (int) TARGET_SIGNAL_REALTIME_64);
351	else
9a2b4c1b MS	352	error ("GDB bug: target.c (target_signal_from_host): "
9a2b4c1b MS	353	"unrecognized real-time signal");
0150732f DJ	354	}
	355	#endif
	356
0150732f DJ	357	return TARGET_SIGNAL_UNKNOWN;
	358	}
	359
	360	/* Convert a OURSIG (an enum target_signal) to the form used by the
	361	target operating system (refered to as the ``host'') or zero if the
	362	equivalent host signal is not available. Set/clear OURSIG_OK
	363	accordingly. */
	364
	365	static int
	366	do_target_signal_to_host (enum target_signal oursig,
	367	int *oursig_ok)
	368	{
f541410f	369	int retsig;
68070c10 PA	370	/* Silence the 'not used' warning, for targets that
	371	do not support signals. */
	372	(void) retsig;
f541410f	373
0150732f DJ	374	*oursig_ok = 1;
	375	switch (oursig)
	376	{
	377	case TARGET_SIGNAL_0:
	378	return 0;
	379
	380	#if defined (SIGHUP)
	381	case TARGET_SIGNAL_HUP:
	382	return SIGHUP;
	383	#endif
	384	#if defined (SIGINT)
	385	case TARGET_SIGNAL_INT:
	386	return SIGINT;
	387	#endif
	388	#if defined (SIGQUIT)
	389	case TARGET_SIGNAL_QUIT:
	390	return SIGQUIT;
	391	#endif
	392	#if defined (SIGILL)
	393	case TARGET_SIGNAL_ILL:
	394	return SIGILL;
	395	#endif
	396	#if defined (SIGTRAP)
	397	case TARGET_SIGNAL_TRAP:
	398	return SIGTRAP;
	399	#endif
	400	#if defined (SIGABRT)
	401	case TARGET_SIGNAL_ABRT:
	402	return SIGABRT;
	403	#endif
	404	#if defined (SIGEMT)
	405	case TARGET_SIGNAL_EMT:
	406	return SIGEMT;
	407	#endif
	408	#if defined (SIGFPE)
	409	case TARGET_SIGNAL_FPE:
	410	return SIGFPE;
	411	#endif
	412	#if defined (SIGKILL)
	413	case TARGET_SIGNAL_KILL:
	414	return SIGKILL;
	415	#endif
	416	#if defined (SIGBUS)
	417	case TARGET_SIGNAL_BUS:
	418	return SIGBUS;
	419	#endif
	420	#if defined (SIGSEGV)
	421	case TARGET_SIGNAL_SEGV:
	422	return SIGSEGV;
	423	#endif
	424	#if defined (SIGSYS)
	425	case TARGET_SIGNAL_SYS:
	426	return SIGSYS;
	427	#endif
	428	#if defined (SIGPIPE)
	429	case TARGET_SIGNAL_PIPE:
	430	return SIGPIPE;
	431	#endif
	432	#if defined (SIGALRM)
	433	case TARGET_SIGNAL_ALRM:
	434	return SIGALRM;
	435	#endif
	436	#if defined (SIGTERM)
	437	case TARGET_SIGNAL_TERM:
438	return SIGTERM;
439	#endif
440	#if defined (SIGUSR1)
441	case TARGET_SIGNAL_USR1:
442	return SIGUSR1;
443	#endif
444	#if defined (SIGUSR2)
445	case TARGET_SIGNAL_USR2:
446	return SIGUSR2;
447	#endif
448	#if defined (SIGCHLD) \|\| defined (SIGCLD)
449	case TARGET_SIGNAL_CHLD:
450	#if defined (SIGCHLD)
451	return SIGCHLD;
452	#else
453	return SIGCLD;
454	#endif
455	#endif /* SIGCLD or SIGCHLD */
456	#if defined (SIGPWR)
457	case TARGET_SIGNAL_PWR:
458	return SIGPWR;
459	#endif
460	#if defined (SIGWINCH)
461	case TARGET_SIGNAL_WINCH:
462	return SIGWINCH;
463	#endif
464	#if defined (SIGURG)
465	case TARGET_SIGNAL_URG:
466	return SIGURG;
467	#endif
468	#if defined (SIGIO)
469	case TARGET_SIGNAL_IO:
470	return SIGIO;
471	#endif
472	#if defined (SIGPOLL)
473	case TARGET_SIGNAL_POLL:
474	return SIGPOLL;
475	#endif
476	#if defined (SIGSTOP)
477	case TARGET_SIGNAL_STOP:
478	return SIGSTOP;
479	#endif
480	#if defined (SIGTSTP)
481	case TARGET_SIGNAL_TSTP:
482	return SIGTSTP;
483	#endif
484	#if defined (SIGCONT)
485	case TARGET_SIGNAL_CONT:
486	return SIGCONT;
487	#endif
488	#if defined (SIGTTIN)
489	case TARGET_SIGNAL_TTIN:
490	return SIGTTIN;
491	#endif
492	#if defined (SIGTTOU)
493	case TARGET_SIGNAL_TTOU:
494	return SIGTTOU;
495	#endif
496	#if defined (SIGVTALRM)
497	case TARGET_SIGNAL_VTALRM:
498	return SIGVTALRM;
499	#endif
500	#if defined (SIGPROF)
501	case TARGET_SIGNAL_PROF:
502	return SIGPROF;
503	#endif
504	#if defined (SIGXCPU)
505	case TARGET_SIGNAL_XCPU:
506	return SIGXCPU;
507	#endif
508	#if defined (SIGXFSZ)
509	case TARGET_SIGNAL_XFSZ:
510	return SIGXFSZ;
511	#endif
512	#if defined (SIGWIND)
513	case TARGET_SIGNAL_WIND:
514	return SIGWIND;
515	#endif
516	#if defined (SIGPHONE)
517	case TARGET_SIGNAL_PHONE:
518	return SIGPHONE;
519	#endif
520	#if defined (SIGLOST)
521	case TARGET_SIGNAL_LOST:
522	return SIGLOST;
523	#endif
524	#if defined (SIGWAITING)
525	case TARGET_SIGNAL_WAITING:
526	return SIGWAITING;
527	#endif
528	#if defined (SIGCANCEL)
529	case TARGET_SIGNAL_CANCEL:
530	return SIGCANCEL;
531	#endif
532	#if defined (SIGLWP)
533	case TARGET_SIGNAL_LWP:
534	return SIGLWP;
535	#endif
536	#if defined (SIGDANGER)
537	case TARGET_SIGNAL_DANGER:
538	return SIGDANGER;
539	#endif
540	#if defined (SIGGRANT)
541	case TARGET_SIGNAL_GRANT:
542	return SIGGRANT;
543	#endif
544	#if defined (SIGRETRACT)
545	case TARGET_SIGNAL_RETRACT:
546	return SIGRETRACT;
547	#endif
548	#if defined (SIGMSG)
549	case TARGET_SIGNAL_MSG:
550	return SIGMSG;
551	#endif
552	#if defined (SIGSOUND)
553	case TARGET_SIGNAL_SOUND:
554	return SIGSOUND;
555	#endif
556	#if defined (SIGSAK)
557	case TARGET_SIGNAL_SAK:
558	return SIGSAK;
559	#endif
560	#if defined (SIGPRIO)
561	case TARGET_SIGNAL_PRIO:
562	return SIGPRIO;
563	#endif
564
565	/* Mach exceptions. Assumes that the values for EXC_ are positive! */
566	#if defined (EXC_BAD_ACCESS) && defined (_NSIG)
567	case TARGET_EXC_BAD_ACCESS:
568	return _NSIG + EXC_BAD_ACCESS;
569	#endif
570	#if defined (EXC_BAD_INSTRUCTION) && defined (_NSIG)
571	case TARGET_EXC_BAD_INSTRUCTION:
572	return _NSIG + EXC_BAD_INSTRUCTION;
573	#endif
574	#if defined (EXC_ARITHMETIC) && defined (_NSIG)
575	case TARGET_EXC_ARITHMETIC:
576	return _NSIG + EXC_ARITHMETIC;
577	#endif
578	#if defined (EXC_EMULATION) && defined (_NSIG)
579	case TARGET_EXC_EMULATION:
580	return _NSIG + EXC_EMULATION;
581	#endif
582	#if defined (EXC_SOFTWARE) && defined (_NSIG)
583	case TARGET_EXC_SOFTWARE:
584	return _NSIG + EXC_SOFTWARE;
585	#endif
586	#if defined (EXC_BREAKPOINT) && defined (_NSIG)
587	case TARGET_EXC_BREAKPOINT:
588	return _NSIG + EXC_BREAKPOINT;
589	#endif
590
591	#if defined (SIGINFO)
592	case TARGET_SIGNAL_INFO:
593	return SIGINFO;
594	#endif
595
596	default:
597	#if defined (REALTIME_LO)
f541410f	598	retsig = 0;
0150732f	599
0150732f DJ	600	if (oursig >= TARGET_SIGNAL_REALTIME_33
	601	&& oursig <= TARGET_SIGNAL_REALTIME_63)
	602	{
	603	/* This block of signals is continuous, and
	604	TARGET_SIGNAL_REALTIME_33 is 33 by definition. */
f541410f	605	retsig = (int) oursig - (int) TARGET_SIGNAL_REALTIME_33 + 33;
0150732f	606	}
2f2cf184 DJ	607	else if (oursig == TARGET_SIGNAL_REALTIME_32)
	608	{
	609	/* TARGET_SIGNAL_REALTIME_32 isn't contiguous with
	610	TARGET_SIGNAL_REALTIME_33. It is 32 by definition. */
f541410f	611	retsig = 32;
2f2cf184 DJ	612	}
	613	else if (oursig >= TARGET_SIGNAL_REALTIME_64
	614	&& oursig <= TARGET_SIGNAL_REALTIME_127)
	615	{
	616	/* This block of signals is continuous, and
	617	TARGET_SIGNAL_REALTIME_64 is 64 by definition. */
f541410f	618	retsig = (int) oursig - (int) TARGET_SIGNAL_REALTIME_64 + 64;
2f2cf184	619	}
f541410f DJ	620
	621	if (retsig >= REALTIME_LO && retsig < REALTIME_HI)
	622	return retsig;
0150732f	623	#endif
960cb555	624
0150732f DJ	625	*oursig_ok = 0;
	626	return 0;
	627	}
	628	}
	629
	630	int
	631	target_signal_to_host_p (enum target_signal oursig)
	632	{
	633	int oursig_ok;
	634	do_target_signal_to_host (oursig, &oursig_ok);
	635	return oursig_ok;
	636	}
	637
	638	int
	639	target_signal_to_host (enum target_signal oursig)
	640	{
	641	int oursig_ok;
	642	int targ_signo = do_target_signal_to_host (oursig, &oursig_ok);
	643	if (!oursig_ok)
	644	{
	645	/* The user might be trying to do "signal SIGSAK" where this system
	646	doesn't have SIGSAK. */
	647	warning ("Signal %s does not exist on this system.\n",
	648	target_signal_to_name (oursig));
	649	return 0;
	650	}
	651	else
	652	return targ_signo;
	653	}
	654
2aecd87f DE	655	#ifndef GDBSERVER
2aecd87f DE	656
0150732f DJ	657	/* In some circumstances we allow a command to specify a numeric
	658	signal. The idea is to keep these circumstances limited so that
	659	users (and scripts) develop portable habits. For comparison,
	660	POSIX.2 `kill' requires that 1,2,3,6,9,14, and 15 work (and using a
	661	numeric signal at all is obsolescent. We are slightly more
	662	lenient and allow 1-15 which should match host signal numbers on
	663	most systems. Use of symbolic signal names is strongly encouraged. */
	664
	665	enum target_signal
	666	target_signal_from_command (int num)
	667	{
	668	if (num >= 1 && num <= 15)
	669	return (enum target_signal) num;
	670	error ("Only signals 1-15 are valid as numeric signals.\n\
	671	Use \"info signals\" for a list of symbolic signals.");
	672	}
	673
b9362cc7 AC	674	extern initialize_file_ftype _initialize_signals; /* -Wmissing-prototype */
b9362cc7 AC	675
0150732f DJ	676	void
	677	_initialize_signals (void)
	678	{
3130066b	679	if (strcmp (signals[TARGET_SIGNAL_LAST].string, "TARGET_SIGNAL_MAGIC") != 0)
0150732f DJ	680	internal_error (__FILE__, __LINE__, "failed internal consistency check");
0150732f DJ	681	}
1cded358 AR	682
	683	int
	684	default_target_signal_to_host (struct gdbarch *gdbarch, enum target_signal ts)
	685	{
	686	return target_signal_to_host (ts);
	687	}
	688
	689	enum target_signal
	690	default_target_signal_from_host (struct gdbarch *gdbarch, int signo)
	691	{
	692	return target_signal_from_host (signo);
	693	}
2aecd87f DE	694
2aecd87f DE	695	#endif /* ! GDBSERVER */