[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
   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) ANY (symbol, name, string)
#define ANY(symbol, name, string) { name, string },
#include "gdb/signals.def"
#undef ANY
#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,
4c38e0a4	3	2000, 2001, 2002, 2003, 2006, 2007, 2008, 2009, 2010
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
a19cae16 JK	51	/* This table must match in order and size the signals in enum target_signal. */
a19cae16 JK	52
54363045 DE	53	static const struct {
	54	const char *name;
	55	const char *string;
0150732f DJ	56	} signals [] =
0150732f DJ	57	{
a19cae16 JK	58	#define SET(symbol, constant, name, string) ANY (symbol, name, string)
	59	#define ANY(symbol, name, string) { name, string },
	60	#include "gdb/signals.def"
	61	#undef ANY
	62	#undef SET
0150732f	63	};
0150732f DJ	64
	65
	66	/* Return the string for a signal. */
54363045	67	const char *
0150732f DJ	68	target_signal_to_string (enum target_signal sig)
0150732f DJ	69	{
d5d6fca5	70	if ((int) sig >= TARGET_SIGNAL_FIRST && (int) sig <= TARGET_SIGNAL_LAST)
0150732f DJ	71	return signals[sig].string;
	72	else
	73	return signals[TARGET_SIGNAL_UNKNOWN].string;
	74	}
	75
	76	/* Return the name for a signal. */
54363045	77	const char *
0150732f DJ	78	target_signal_to_name (enum target_signal sig)
0150732f DJ	79	{
d5d6fca5	80	if ((int) sig >= TARGET_SIGNAL_FIRST && (int) sig <= TARGET_SIGNAL_LAST
ade8f45e	81	&& signals[sig].name != NULL)
89c49e7a AC	82	return signals[sig].name;
89c49e7a AC	83	else
ade8f45e AC	84	/* I think the code which prints this will always print it along
	85	with the string, so no need to be verbose (very old comment). */
	86	return "?";
0150732f DJ	87	}
	88
	89	/* Given a name, return its signal. */
	90	enum target_signal
54363045	91	target_signal_from_name (const char *name)
0150732f DJ	92	{
	93	enum target_signal sig;
	94
	95	/* It's possible we also should allow "SIGCLD" as well as "SIGCHLD"
	96	for TARGET_SIGNAL_SIGCHLD. SIGIOT, on the other hand, is more
	97	questionable; seems like by now people should call it SIGABRT
	98	instead. */
	99
	100	/* This ugly cast brought to you by the native VAX compiler. */
	101	for (sig = TARGET_SIGNAL_HUP;
fd326606	102	sig < TARGET_SIGNAL_LAST;
0150732f	103	sig = (enum target_signal) ((int) sig + 1))
fd326606 DJ	104	if (signals[sig].name != NULL
fd326606 DJ	105	&& strcmp (name, signals[sig].name) == 0)
0150732f DJ	106	return sig;
	107	return TARGET_SIGNAL_UNKNOWN;
	108	}
	109	\f
	110	/* The following functions are to help certain targets deal
	111	with the signal/waitstatus stuff. They could just as well be in
	112	a file called native-utils.c or unixwaitstatus-utils.c or whatever. */
	113
	114	/* Convert host signal to our signals. */
	115	enum target_signal
	116	target_signal_from_host (int hostsig)
	117	{
	118	/* A switch statement would make sense but would require special kludges
	119	to deal with the cases where more than one signal has the same number. */
	120
	121	if (hostsig == 0)
	122	return TARGET_SIGNAL_0;
	123
	124	#if defined (SIGHUP)
	125	if (hostsig == SIGHUP)
	126	return TARGET_SIGNAL_HUP;
	127	#endif
	128	#if defined (SIGINT)
	129	if (hostsig == SIGINT)
	130	return TARGET_SIGNAL_INT;
	131	#endif
	132	#if defined (SIGQUIT)
	133	if (hostsig == SIGQUIT)
	134	return TARGET_SIGNAL_QUIT;
	135	#endif
	136	#if defined (SIGILL)
	137	if (hostsig == SIGILL)
	138	return TARGET_SIGNAL_ILL;
	139	#endif
	140	#if defined (SIGTRAP)
	141	if (hostsig == SIGTRAP)
	142	return TARGET_SIGNAL_TRAP;
	143	#endif
	144	#if defined (SIGABRT)
	145	if (hostsig == SIGABRT)
	146	return TARGET_SIGNAL_ABRT;
	147	#endif
	148	#if defined (SIGEMT)
	149	if (hostsig == SIGEMT)
	150	return TARGET_SIGNAL_EMT;
	151	#endif
	152	#if defined (SIGFPE)
	153	if (hostsig == SIGFPE)
	154	return TARGET_SIGNAL_FPE;
	155	#endif
	156	#if defined (SIGKILL)
	157	if (hostsig == SIGKILL)
	158	return TARGET_SIGNAL_KILL;
	159	#endif
	160	#if defined (SIGBUS)
	161	if (hostsig == SIGBUS)
	162	return TARGET_SIGNAL_BUS;
	163	#endif
	164	#if defined (SIGSEGV)
	165	if (hostsig == SIGSEGV)
	166	return TARGET_SIGNAL_SEGV;
	167	#endif
	168	#if defined (SIGSYS)
	169	if (hostsig == SIGSYS)
170	return TARGET_SIGNAL_SYS;
171	#endif
172	#if defined (SIGPIPE)
173	if (hostsig == SIGPIPE)
174	return TARGET_SIGNAL_PIPE;
175	#endif
176	#if defined (SIGALRM)
177	if (hostsig == SIGALRM)
178	return TARGET_SIGNAL_ALRM;
179	#endif
180	#if defined (SIGTERM)
181	if (hostsig == SIGTERM)
182	return TARGET_SIGNAL_TERM;
183	#endif
184	#if defined (SIGUSR1)
185	if (hostsig == SIGUSR1)
186	return TARGET_SIGNAL_USR1;
187	#endif
188	#if defined (SIGUSR2)
189	if (hostsig == SIGUSR2)
190	return TARGET_SIGNAL_USR2;
191	#endif
192	#if defined (SIGCLD)
193	if (hostsig == SIGCLD)
194	return TARGET_SIGNAL_CHLD;
195	#endif
196	#if defined (SIGCHLD)
197	if (hostsig == SIGCHLD)
198	return TARGET_SIGNAL_CHLD;
199	#endif
200	#if defined (SIGPWR)
201	if (hostsig == SIGPWR)
202	return TARGET_SIGNAL_PWR;
203	#endif
204	#if defined (SIGWINCH)
205	if (hostsig == SIGWINCH)
206	return TARGET_SIGNAL_WINCH;
207	#endif
208	#if defined (SIGURG)
209	if (hostsig == SIGURG)
210	return TARGET_SIGNAL_URG;
211	#endif
212	#if defined (SIGIO)
213	if (hostsig == SIGIO)
214	return TARGET_SIGNAL_IO;
215	#endif
216	#if defined (SIGPOLL)
217	if (hostsig == SIGPOLL)
218	return TARGET_SIGNAL_POLL;
219	#endif
220	#if defined (SIGSTOP)
221	if (hostsig == SIGSTOP)
222	return TARGET_SIGNAL_STOP;
223	#endif
224	#if defined (SIGTSTP)
225	if (hostsig == SIGTSTP)
226	return TARGET_SIGNAL_TSTP;
227	#endif
228	#if defined (SIGCONT)
229	if (hostsig == SIGCONT)
230	return TARGET_SIGNAL_CONT;
231	#endif
232	#if defined (SIGTTIN)
233	if (hostsig == SIGTTIN)
234	return TARGET_SIGNAL_TTIN;
235	#endif
236	#if defined (SIGTTOU)
237	if (hostsig == SIGTTOU)
238	return TARGET_SIGNAL_TTOU;
239	#endif
240	#if defined (SIGVTALRM)
241	if (hostsig == SIGVTALRM)
242	return TARGET_SIGNAL_VTALRM;
243	#endif
244	#if defined (SIGPROF)
245	if (hostsig == SIGPROF)
246	return TARGET_SIGNAL_PROF;
247	#endif
248	#if defined (SIGXCPU)
249	if (hostsig == SIGXCPU)
250	return TARGET_SIGNAL_XCPU;
251	#endif
252	#if defined (SIGXFSZ)
253	if (hostsig == SIGXFSZ)
254	return TARGET_SIGNAL_XFSZ;
255	#endif
256	#if defined (SIGWIND)
257	if (hostsig == SIGWIND)
258	return TARGET_SIGNAL_WIND;
259	#endif
260	#if defined (SIGPHONE)
261	if (hostsig == SIGPHONE)
262	return TARGET_SIGNAL_PHONE;
263	#endif
264	#if defined (SIGLOST)
265	if (hostsig == SIGLOST)
266	return TARGET_SIGNAL_LOST;
267	#endif
268	#if defined (SIGWAITING)
269	if (hostsig == SIGWAITING)
270	return TARGET_SIGNAL_WAITING;
271	#endif
272	#if defined (SIGCANCEL)
273	if (hostsig == SIGCANCEL)
274	return TARGET_SIGNAL_CANCEL;
275	#endif
276	#if defined (SIGLWP)
277	if (hostsig == SIGLWP)
278	return TARGET_SIGNAL_LWP;
279	#endif
280	#if defined (SIGDANGER)
281	if (hostsig == SIGDANGER)
282	return TARGET_SIGNAL_DANGER;
283	#endif
284	#if defined (SIGGRANT)
285	if (hostsig == SIGGRANT)
286	return TARGET_SIGNAL_GRANT;
287	#endif
288	#if defined (SIGRETRACT)
289	if (hostsig == SIGRETRACT)
290	return TARGET_SIGNAL_RETRACT;
291	#endif
292	#if defined (SIGMSG)
293	if (hostsig == SIGMSG)
294	return TARGET_SIGNAL_MSG;
295	#endif
296	#if defined (SIGSOUND)
297	if (hostsig == SIGSOUND)
298	return TARGET_SIGNAL_SOUND;
299	#endif
300	#if defined (SIGSAK)
301	if (hostsig == SIGSAK)
302	return TARGET_SIGNAL_SAK;
303	#endif
304	#if defined (SIGPRIO)
305	if (hostsig == SIGPRIO)
306	return TARGET_SIGNAL_PRIO;
307	#endif
308
309	/* Mach exceptions. Assumes that the values for EXC_ are positive! */
310	#if defined (EXC_BAD_ACCESS) && defined (_NSIG)
311	if (hostsig == _NSIG + EXC_BAD_ACCESS)
312	return TARGET_EXC_BAD_ACCESS;
313	#endif
314	#if defined (EXC_BAD_INSTRUCTION) && defined (_NSIG)
315	if (hostsig == _NSIG + EXC_BAD_INSTRUCTION)
316	return TARGET_EXC_BAD_INSTRUCTION;
317	#endif
318	#if defined (EXC_ARITHMETIC) && defined (_NSIG)
319	if (hostsig == _NSIG + EXC_ARITHMETIC)
320	return TARGET_EXC_ARITHMETIC;
321	#endif
322	#if defined (EXC_EMULATION) && defined (_NSIG)
323	if (hostsig == _NSIG + EXC_EMULATION)
324	return TARGET_EXC_EMULATION;
325	#endif
326	#if defined (EXC_SOFTWARE) && defined (_NSIG)
327	if (hostsig == _NSIG + EXC_SOFTWARE)
328	return TARGET_EXC_SOFTWARE;
329	#endif
330	#if defined (EXC_BREAKPOINT) && defined (_NSIG)
331	if (hostsig == _NSIG + EXC_BREAKPOINT)
332	return TARGET_EXC_BREAKPOINT;
333	#endif
334
335	#if defined (SIGINFO)
336	if (hostsig == SIGINFO)
337	return TARGET_SIGNAL_INFO;
338	#endif
339
340	#if defined (REALTIME_LO)
341	if (hostsig >= REALTIME_LO && hostsig < REALTIME_HI)
342	{
343	/* This block of TARGET_SIGNAL_REALTIME value is in order. */
344	if (33 <= hostsig && hostsig <= 63)
345	return (enum target_signal)
346	(hostsig - 33 + (int) TARGET_SIGNAL_REALTIME_33);
347	else if (hostsig == 32)
348	return TARGET_SIGNAL_REALTIME_32;
349	else if (64 <= hostsig && hostsig <= 127)
350	return (enum target_signal)
351	(hostsig - 64 + (int) TARGET_SIGNAL_REALTIME_64);
352	else
353	error ("GDB bug: target.c (target_signal_from_host): unrecognized real-time signal");
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 */