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

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