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

/* Target signal translation functions for GDB.
   Copyright (C) 1990-2020 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/>.  */

#include "common-defs.h"

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

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

const char *
gdb_signal_to_symbol_string (enum gdb_signal sig)
{
  gdb_assert ((int) sig >= GDB_SIGNAL_FIRST && (int) sig <= GDB_SIGNAL_LAST);

  return signals[sig].symbol;
}

/* Return the string for a signal.  */
const char *
gdb_signal_to_string (enum gdb_signal sig)
{
  if ((int) sig >= GDB_SIGNAL_FIRST && (int) sig <= GDB_SIGNAL_LAST)
    return signals[sig].string;
  else
    return signals[GDB_SIGNAL_UNKNOWN].string;
}

/* Return the name for a signal.  */
const char *
gdb_signal_to_name (enum gdb_signal sig)
{
  if ((int) sig >= GDB_SIGNAL_FIRST && (int) sig <= GDB_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 gdb_signal
gdb_signal_from_name (const char *name)
{
  enum gdb_signal sig;

  /* It's possible we also should allow "SIGCLD" as well as "SIGCHLD"
     for GDB_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 = GDB_SIGNAL_HUP;
       sig < GDB_SIGNAL_LAST;
       sig = (enum gdb_signal) ((int) sig + 1))
    if (signals[sig].name != NULL
	&& strcmp (name, signals[sig].name) == 0)
      return sig;
  return GDB_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 gdb_signal
gdb_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.  Signals are ordered ANSI-standard signals first,
     other signals second, with signals in each block ordered by their
     numerical values on a typical POSIX platform.  */

  if (hostsig == 0)
    return GDB_SIGNAL_0;

  /* SIGINT, SIGILL, SIGABRT, SIGFPE, SIGSEGV and SIGTERM
     are ANSI-standard signals and are always available.  */
  if (hostsig == SIGINT)
    return GDB_SIGNAL_INT;
  if (hostsig == SIGILL)
    return GDB_SIGNAL_ILL;
  if (hostsig == SIGABRT)
    return GDB_SIGNAL_ABRT;
  if (hostsig == SIGFPE)
    return GDB_SIGNAL_FPE;
  if (hostsig == SIGSEGV)
    return GDB_SIGNAL_SEGV;
  if (hostsig == SIGTERM)
    return GDB_SIGNAL_TERM;

  /* All other signals need preprocessor conditionals.  */
#if defined (SIGHUP)
  if (hostsig == SIGHUP)
    return GDB_SIGNAL_HUP;
#endif
#if defined (SIGQUIT)
  if (hostsig == SIGQUIT)
    return GDB_SIGNAL_QUIT;
#endif
#if defined (SIGTRAP)
  if (hostsig == SIGTRAP)
    return GDB_SIGNAL_TRAP;
#endif
#if defined (SIGEMT)
  if (hostsig == SIGEMT)
    return GDB_SIGNAL_EMT;
#endif
#if defined (SIGKILL)
  if (hostsig == SIGKILL)
    return GDB_SIGNAL_KILL;
#endif
#if defined (SIGBUS)
  if (hostsig == SIGBUS)
    return GDB_SIGNAL_BUS;
#endif
#if defined (SIGSYS)
  if (hostsig == SIGSYS)
    return GDB_SIGNAL_SYS;
#endif
#if defined (SIGPIPE)
  if (hostsig == SIGPIPE)
    return GDB_SIGNAL_PIPE;
#endif
#if defined (SIGALRM)
  if (hostsig == SIGALRM)
    return GDB_SIGNAL_ALRM;
#endif
#if defined (SIGUSR1)
  if (hostsig == SIGUSR1)
    return GDB_SIGNAL_USR1;
#endif
#if defined (SIGUSR2)
  if (hostsig == SIGUSR2)
    return GDB_SIGNAL_USR2;
#endif
#if defined (SIGCLD)
  if (hostsig == SIGCLD)
    return GDB_SIGNAL_CHLD;
#endif
#if defined (SIGCHLD)
  if (hostsig == SIGCHLD)
    return GDB_SIGNAL_CHLD;
#endif
#if defined (SIGPWR)
  if (hostsig == SIGPWR)
    return GDB_SIGNAL_PWR;
#endif
#if defined (SIGWINCH)
  if (hostsig == SIGWINCH)
    return GDB_SIGNAL_WINCH;
#endif
#if defined (SIGURG)
  if (hostsig == SIGURG)
    return GDB_SIGNAL_URG;
#endif
#if defined (SIGIO)
  if (hostsig == SIGIO)
    return GDB_SIGNAL_IO;
#endif
#if defined (SIGPOLL)
  if (hostsig == SIGPOLL)
    return GDB_SIGNAL_POLL;
#endif
#if defined (SIGSTOP)
  if (hostsig == SIGSTOP)
    return GDB_SIGNAL_STOP;
#endif
#if defined (SIGTSTP)
  if (hostsig == SIGTSTP)
    return GDB_SIGNAL_TSTP;
#endif
#if defined (SIGCONT)
  if (hostsig == SIGCONT)
    return GDB_SIGNAL_CONT;
#endif
#if defined (SIGTTIN)
  if (hostsig == SIGTTIN)
    return GDB_SIGNAL_TTIN;
#endif
#if defined (SIGTTOU)
  if (hostsig == SIGTTOU)
    return GDB_SIGNAL_TTOU;
#endif
#if defined (SIGVTALRM)
  if (hostsig == SIGVTALRM)
    return GDB_SIGNAL_VTALRM;
#endif
#if defined (SIGPROF)
  if (hostsig == SIGPROF)
    return GDB_SIGNAL_PROF;
#endif
#if defined (SIGXCPU)
  if (hostsig == SIGXCPU)
    return GDB_SIGNAL_XCPU;
#endif
#if defined (SIGXFSZ)
  if (hostsig == SIGXFSZ)
    return GDB_SIGNAL_XFSZ;
#endif
#if defined (SIGWIND)
  if (hostsig == SIGWIND)
    return GDB_SIGNAL_WIND;
#endif
#if defined (SIGPHONE)
  if (hostsig == SIGPHONE)
    return GDB_SIGNAL_PHONE;
#endif
#if defined (SIGLOST)
  if (hostsig == SIGLOST)
    return GDB_SIGNAL_LOST;
#endif
#if defined (SIGWAITING)
  if (hostsig == SIGWAITING)
    return GDB_SIGNAL_WAITING;
#endif
#if defined (SIGCANCEL)
  if (hostsig == SIGCANCEL)
    return GDB_SIGNAL_CANCEL;
#endif
#if defined (SIGLWP)
  if (hostsig == SIGLWP)
    return GDB_SIGNAL_LWP;
#endif
#if defined (SIGDANGER)
  if (hostsig == SIGDANGER)
    return GDB_SIGNAL_DANGER;
#endif
#if defined (SIGGRANT)
  if (hostsig == SIGGRANT)
    return GDB_SIGNAL_GRANT;
#endif
#if defined (SIGRETRACT)
  if (hostsig == SIGRETRACT)
    return GDB_SIGNAL_RETRACT;
#endif
#if defined (SIGMSG)
  if (hostsig == SIGMSG)
    return GDB_SIGNAL_MSG;
#endif
#if defined (SIGSOUND)
  if (hostsig == SIGSOUND)
    return GDB_SIGNAL_SOUND;
#endif
#if defined (SIGSAK)
  if (hostsig == SIGSAK)
    return GDB_SIGNAL_SAK;
#endif
#if defined (SIGPRIO)
  if (hostsig == SIGPRIO)
    return GDB_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 GDB_EXC_BAD_ACCESS;
#endif
#if defined (EXC_BAD_INSTRUCTION) && defined (_NSIG)
  if (hostsig == _NSIG + EXC_BAD_INSTRUCTION)
    return GDB_EXC_BAD_INSTRUCTION;
#endif
#if defined (EXC_ARITHMETIC) && defined (_NSIG)
  if (hostsig == _NSIG + EXC_ARITHMETIC)
    return GDB_EXC_ARITHMETIC;
#endif
#if defined (EXC_EMULATION) && defined (_NSIG)
  if (hostsig == _NSIG + EXC_EMULATION)
    return GDB_EXC_EMULATION;
#endif
#if defined (EXC_SOFTWARE) && defined (_NSIG)
  if (hostsig == _NSIG + EXC_SOFTWARE)
    return GDB_EXC_SOFTWARE;
#endif
#if defined (EXC_BREAKPOINT) && defined (_NSIG)
  if (hostsig == _NSIG + EXC_BREAKPOINT)
    return GDB_EXC_BREAKPOINT;
#endif

#if defined (SIGINFO)
  if (hostsig == SIGINFO)
    return GDB_SIGNAL_INFO;
#endif
#if defined (SIGLIBRT)
  if (hostsig == SIGLIBRT)
    return GDB_SIGNAL_LIBRT;
#endif

#if defined (REALTIME_LO)
  if (hostsig >= REALTIME_LO && hostsig < REALTIME_HI)
    {
      /* This block of GDB_SIGNAL_REALTIME value is in order.  */
      if (33 <= hostsig && hostsig <= 63)
	return (enum gdb_signal)
	  (hostsig - 33 + (int) GDB_SIGNAL_REALTIME_33);
      else if (hostsig == 32)
	return GDB_SIGNAL_REALTIME_32;
      else if (64 <= hostsig && hostsig <= 127)
	return (enum gdb_signal)
	  (hostsig - 64 + (int) GDB_SIGNAL_REALTIME_64);
      else
	error (_("GDB bug: target.c (gdb_signal_from_host): "
	       "unrecognized real-time signal"));
    }
#endif

  return GDB_SIGNAL_UNKNOWN;
}

/* Convert a OURSIG (an enum gdb_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_gdb_signal_to_host (enum gdb_signal oursig,
			  int *oursig_ok)
{
  int retsig;
  /* Silence the 'not used' warning, for targets that
     do not support signals.  */
  (void) retsig;

  /* Signals are ordered ANSI-standard signals first, other signals
     second, with signals in each block ordered by their numerical
     values on a typical POSIX platform.  */

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

      /* SIGINT, SIGILL, SIGABRT, SIGFPE, SIGSEGV and SIGTERM
	 are ANSI-standard signals and are always available.  */
    case GDB_SIGNAL_INT:
      return SIGINT;
    case GDB_SIGNAL_ILL:
      return SIGILL;
    case GDB_SIGNAL_ABRT:
      return SIGABRT;
    case GDB_SIGNAL_FPE:
      return SIGFPE;
    case GDB_SIGNAL_SEGV:
      return SIGSEGV;
    case GDB_SIGNAL_TERM:
      return SIGTERM;

      /* All other signals need preprocessor conditionals.  */
#if defined (SIGHUP)
    case GDB_SIGNAL_HUP:
      return SIGHUP;
#endif
#if defined (SIGQUIT)
    case GDB_SIGNAL_QUIT:
      return SIGQUIT;
#endif
#if defined (SIGTRAP)
    case GDB_SIGNAL_TRAP:
      return SIGTRAP;
#endif
#if defined (SIGEMT)
    case GDB_SIGNAL_EMT:
      return SIGEMT;
#endif
#if defined (SIGKILL)
    case GDB_SIGNAL_KILL:
      return SIGKILL;
#endif
#if defined (SIGBUS)
    case GDB_SIGNAL_BUS:
      return SIGBUS;
#endif
#if defined (SIGSYS)
    case GDB_SIGNAL_SYS:
      return SIGSYS;
#endif
#if defined (SIGPIPE)
    case GDB_SIGNAL_PIPE:
      return SIGPIPE;
#endif
#if defined (SIGALRM)
    case GDB_SIGNAL_ALRM:
      return SIGALRM;
#endif
#if defined (SIGUSR1)
    case GDB_SIGNAL_USR1:
      return SIGUSR1;
#endif
#if defined (SIGUSR2)
    case GDB_SIGNAL_USR2:
      return SIGUSR2;
#endif
#if defined (SIGCHLD) || defined (SIGCLD)
    case GDB_SIGNAL_CHLD:
#if defined (SIGCHLD)
      return SIGCHLD;
#else
      return SIGCLD;
#endif
#endif /* SIGCLD or SIGCHLD */
#if defined (SIGPWR)
    case GDB_SIGNAL_PWR:
      return SIGPWR;
#endif
#if defined (SIGWINCH)
    case GDB_SIGNAL_WINCH:
      return SIGWINCH;
#endif
#if defined (SIGURG)
    case GDB_SIGNAL_URG:
      return SIGURG;
#endif
#if defined (SIGIO)
    case GDB_SIGNAL_IO:
      return SIGIO;
#endif
#if defined (SIGPOLL)
    case GDB_SIGNAL_POLL:
      return SIGPOLL;
#endif
#if defined (SIGSTOP)
    case GDB_SIGNAL_STOP:
      return SIGSTOP;
#endif
#if defined (SIGTSTP)
    case GDB_SIGNAL_TSTP:
      return SIGTSTP;
#endif
#if defined (SIGCONT)
    case GDB_SIGNAL_CONT:
      return SIGCONT;
#endif
#if defined (SIGTTIN)
    case GDB_SIGNAL_TTIN:
      return SIGTTIN;
#endif
#if defined (SIGTTOU)
    case GDB_SIGNAL_TTOU:
      return SIGTTOU;
#endif
#if defined (SIGVTALRM)
    case GDB_SIGNAL_VTALRM:
      return SIGVTALRM;
#endif
#if defined (SIGPROF)
    case GDB_SIGNAL_PROF:
      return SIGPROF;
#endif
#if defined (SIGXCPU)
    case GDB_SIGNAL_XCPU:
      return SIGXCPU;
#endif
#if defined (SIGXFSZ)
    case GDB_SIGNAL_XFSZ:
      return SIGXFSZ;
#endif
#if defined (SIGWIND)
    case GDB_SIGNAL_WIND:
      return SIGWIND;
#endif
#if defined (SIGPHONE)
    case GDB_SIGNAL_PHONE:
      return SIGPHONE;
#endif
#if defined (SIGLOST)
    case GDB_SIGNAL_LOST:
      return SIGLOST;
#endif
#if defined (SIGWAITING)
    case GDB_SIGNAL_WAITING:
      return SIGWAITING;
#endif
#if defined (SIGCANCEL)
    case GDB_SIGNAL_CANCEL:
      return SIGCANCEL;
#endif
#if defined (SIGLWP)
    case GDB_SIGNAL_LWP:
      return SIGLWP;
#endif
#if defined (SIGDANGER)
    case GDB_SIGNAL_DANGER:
      return SIGDANGER;
#endif
#if defined (SIGGRANT)
    case GDB_SIGNAL_GRANT:
      return SIGGRANT;
#endif
#if defined (SIGRETRACT)
    case GDB_SIGNAL_RETRACT:
      return SIGRETRACT;
#endif
#if defined (SIGMSG)
    case GDB_SIGNAL_MSG:
      return SIGMSG;
#endif
#if defined (SIGSOUND)
    case GDB_SIGNAL_SOUND:
      return SIGSOUND;
#endif
#if defined (SIGSAK)
    case GDB_SIGNAL_SAK:
      return SIGSAK;
#endif
#if defined (SIGPRIO)
    case GDB_SIGNAL_PRIO:
      return SIGPRIO;
#endif

      /* Mach exceptions.  Assumes that the values for EXC_ are positive! */
#if defined (EXC_BAD_ACCESS) && defined (_NSIG)
    case GDB_EXC_BAD_ACCESS:
      return _NSIG + EXC_BAD_ACCESS;
#endif
#if defined (EXC_BAD_INSTRUCTION) && defined (_NSIG)
    case GDB_EXC_BAD_INSTRUCTION:
      return _NSIG + EXC_BAD_INSTRUCTION;
#endif
#if defined (EXC_ARITHMETIC) && defined (_NSIG)
    case GDB_EXC_ARITHMETIC:
      return _NSIG + EXC_ARITHMETIC;
#endif
#if defined (EXC_EMULATION) && defined (_NSIG)
    case GDB_EXC_EMULATION:
      return _NSIG + EXC_EMULATION;
#endif
#if defined (EXC_SOFTWARE) && defined (_NSIG)
    case GDB_EXC_SOFTWARE:
      return _NSIG + EXC_SOFTWARE;
#endif
#if defined (EXC_BREAKPOINT) && defined (_NSIG)
    case GDB_EXC_BREAKPOINT:
      return _NSIG + EXC_BREAKPOINT;
#endif

#if defined (SIGINFO)
    case GDB_SIGNAL_INFO:
      return SIGINFO;
#endif
#if defined (SIGLIBRT)
    case GDB_SIGNAL_LIBRT:
      return SIGLIBRT;
#endif

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

      if (oursig >= GDB_SIGNAL_REALTIME_33
	  && oursig <= GDB_SIGNAL_REALTIME_63)
	{
	  /* This block of signals is continuous, and
             GDB_SIGNAL_REALTIME_33 is 33 by definition.  */
	  retsig = (int) oursig - (int) GDB_SIGNAL_REALTIME_33 + 33;
	}
      else if (oursig == GDB_SIGNAL_REALTIME_32)
	{
	  /* GDB_SIGNAL_REALTIME_32 isn't contiguous with
             GDB_SIGNAL_REALTIME_33.  It is 32 by definition.  */
	  retsig = 32;
	}
      else if (oursig >= GDB_SIGNAL_REALTIME_64
	  && oursig <= GDB_SIGNAL_REALTIME_127)
	{
	  /* This block of signals is continuous, and
             GDB_SIGNAL_REALTIME_64 is 64 by definition.  */
	  retsig = (int) oursig - (int) GDB_SIGNAL_REALTIME_64 + 64;
	}

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

      *oursig_ok = 0;
      return 0;
    }
}

int
gdb_signal_to_host_p (enum gdb_signal oursig)
{
  int oursig_ok;
  do_gdb_signal_to_host (oursig, &oursig_ok);
  return oursig_ok;
}

int
gdb_signal_to_host (enum gdb_signal oursig)
{
  int oursig_ok;
  int targ_signo = do_gdb_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."),
	       gdb_signal_to_name (oursig));
      return 0;
    }
  else
    return targ_signo;
}
Commit	Line	Data
	1	/* Target signal translation functions for GDB.
	2	Copyright (C) 1990-2020 Free Software Foundation, Inc.
	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
	9	the Free Software Foundation; either version 3 of the License, or
	10	(at your option) any later version.
	11
	12	This program is distributed in the hope that it will be useful,
	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	GNU General Public License for more details.
	16
	17	You should have received a copy of the GNU General Public License
	18	along with this program. If not, see <http://www.gnu.org/licenses/>. */
	19
	20	#include "common-defs.h"
	21
	22	#ifdef HAVE_SIGNAL_H
	23	#include <signal.h>
	24	#endif
	25
	26	#include "gdb_signals.h"
	27
	28	struct gdbarch;
	29
	30	/* Always use __SIGRTMIN if it's available. SIGRTMIN is the lowest
	31	_available_ realtime signal, not the lowest supported; glibc takes
	32	several for its own use. */
	33
	34	#ifndef REALTIME_LO
	35	# if defined(__SIGRTMIN)
	36	# define REALTIME_LO __SIGRTMIN
	37	# define REALTIME_HI (__SIGRTMAX + 1)
	38	# elif defined(SIGRTMIN)
	39	# define REALTIME_LO SIGRTMIN
	40	# define REALTIME_HI (SIGRTMAX + 1)
	41	# endif
	42	#endif
	43
	44	/* This table must match in order and size the signals in enum
	45	gdb_signal. */
	46
	47	static const struct {
	48	const char *symbol;
	49	const char *name;
	50	const char *string;
	51	} signals [] =
	52	{
	53	#define SET(symbol, constant, name, string) { #symbol, name, string },
	54	#include "gdb/signals.def"
	55	#undef SET
	56	};
	57
	58	const char *
	59	gdb_signal_to_symbol_string (enum gdb_signal sig)
	60	{
	61	gdb_assert ((int) sig >= GDB_SIGNAL_FIRST && (int) sig <= GDB_SIGNAL_LAST);
	62
	63	return signals[sig].symbol;
	64	}
	65
	66	/* Return the string for a signal. */
	67	const char *
	68	gdb_signal_to_string (enum gdb_signal sig)
	69	{
	70	if ((int) sig >= GDB_SIGNAL_FIRST && (int) sig <= GDB_SIGNAL_LAST)
	71	return signals[sig].string;
	72	else
	73	return signals[GDB_SIGNAL_UNKNOWN].string;
	74	}
	75
	76	/* Return the name for a signal. */
	77	const char *
	78	gdb_signal_to_name (enum gdb_signal sig)
	79	{
	80	if ((int) sig >= GDB_SIGNAL_FIRST && (int) sig <= GDB_SIGNAL_LAST
	81	&& signals[sig].name != NULL)
	82	return signals[sig].name;
	83	else
	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 "?";
	87	}
	88
	89	/* Given a name, return its signal. */
	90	enum gdb_signal
	91	gdb_signal_from_name (const char *name)
	92	{
	93	enum gdb_signal sig;
	94
	95	/* It's possible we also should allow "SIGCLD" as well as "SIGCHLD"
	96	for GDB_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 = GDB_SIGNAL_HUP;
	102	sig < GDB_SIGNAL_LAST;
	103	sig = (enum gdb_signal) ((int) sig + 1))
	104	if (signals[sig].name != NULL
	105	&& strcmp (name, signals[sig].name) == 0)
	106	return sig;
	107	return GDB_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 gdb_signal
	116	gdb_signal_from_host (int hostsig)
	117	{
	118	/* A switch statement would make sense but would require special
	119	kludges to deal with the cases where more than one signal has the
	120	same number. Signals are ordered ANSI-standard signals first,
	121	other signals second, with signals in each block ordered by their
	122	numerical values on a typical POSIX platform. */
	123
	124	if (hostsig == 0)
	125	return GDB_SIGNAL_0;
	126
	127	/* SIGINT, SIGILL, SIGABRT, SIGFPE, SIGSEGV and SIGTERM
	128	are ANSI-standard signals and are always available. */
	129	if (hostsig == SIGINT)
	130	return GDB_SIGNAL_INT;
	131	if (hostsig == SIGILL)
	132	return GDB_SIGNAL_ILL;
	133	if (hostsig == SIGABRT)
	134	return GDB_SIGNAL_ABRT;
	135	if (hostsig == SIGFPE)
	136	return GDB_SIGNAL_FPE;
	137	if (hostsig == SIGSEGV)
	138	return GDB_SIGNAL_SEGV;
	139	if (hostsig == SIGTERM)
	140	return GDB_SIGNAL_TERM;
	141
	142	/* All other signals need preprocessor conditionals. */
	143	#if defined (SIGHUP)
	144	if (hostsig == SIGHUP)
	145	return GDB_SIGNAL_HUP;
	146	#endif
	147	#if defined (SIGQUIT)
	148	if (hostsig == SIGQUIT)
	149	return GDB_SIGNAL_QUIT;
	150	#endif
	151	#if defined (SIGTRAP)
	152	if (hostsig == SIGTRAP)
	153	return GDB_SIGNAL_TRAP;
	154	#endif
	155	#if defined (SIGEMT)
	156	if (hostsig == SIGEMT)
	157	return GDB_SIGNAL_EMT;
	158	#endif
	159	#if defined (SIGKILL)
	160	if (hostsig == SIGKILL)
	161	return GDB_SIGNAL_KILL;
	162	#endif
	163	#if defined (SIGBUS)
	164	if (hostsig == SIGBUS)
	165	return GDB_SIGNAL_BUS;
	166	#endif
	167	#if defined (SIGSYS)
	168	if (hostsig == SIGSYS)
	169	return GDB_SIGNAL_SYS;
	170	#endif
	171	#if defined (SIGPIPE)
	172	if (hostsig == SIGPIPE)
	173	return GDB_SIGNAL_PIPE;
	174	#endif
	175	#if defined (SIGALRM)
	176	if (hostsig == SIGALRM)
	177	return GDB_SIGNAL_ALRM;
	178	#endif
	179	#if defined (SIGUSR1)
	180	if (hostsig == SIGUSR1)
	181	return GDB_SIGNAL_USR1;
	182	#endif
	183	#if defined (SIGUSR2)
	184	if (hostsig == SIGUSR2)
	185	return GDB_SIGNAL_USR2;
	186	#endif
	187	#if defined (SIGCLD)
	188	if (hostsig == SIGCLD)
	189	return GDB_SIGNAL_CHLD;
	190	#endif
	191	#if defined (SIGCHLD)
	192	if (hostsig == SIGCHLD)
	193	return GDB_SIGNAL_CHLD;
	194	#endif
	195	#if defined (SIGPWR)
	196	if (hostsig == SIGPWR)
	197	return GDB_SIGNAL_PWR;
	198	#endif
	199	#if defined (SIGWINCH)
	200	if (hostsig == SIGWINCH)
	201	return GDB_SIGNAL_WINCH;
	202	#endif
	203	#if defined (SIGURG)
	204	if (hostsig == SIGURG)
	205	return GDB_SIGNAL_URG;
	206	#endif
	207	#if defined (SIGIO)
	208	if (hostsig == SIGIO)
	209	return GDB_SIGNAL_IO;
	210	#endif
	211	#if defined (SIGPOLL)
	212	if (hostsig == SIGPOLL)
	213	return GDB_SIGNAL_POLL;
	214	#endif
	215	#if defined (SIGSTOP)
	216	if (hostsig == SIGSTOP)
	217	return GDB_SIGNAL_STOP;
	218	#endif
	219	#if defined (SIGTSTP)
	220	if (hostsig == SIGTSTP)
	221	return GDB_SIGNAL_TSTP;
	222	#endif
	223	#if defined (SIGCONT)
	224	if (hostsig == SIGCONT)
	225	return GDB_SIGNAL_CONT;
	226	#endif
	227	#if defined (SIGTTIN)
	228	if (hostsig == SIGTTIN)
	229	return GDB_SIGNAL_TTIN;
	230	#endif
	231	#if defined (SIGTTOU)
	232	if (hostsig == SIGTTOU)
	233	return GDB_SIGNAL_TTOU;
	234	#endif
	235	#if defined (SIGVTALRM)
	236	if (hostsig == SIGVTALRM)
	237	return GDB_SIGNAL_VTALRM;
	238	#endif
	239	#if defined (SIGPROF)
	240	if (hostsig == SIGPROF)
	241	return GDB_SIGNAL_PROF;
	242	#endif
	243	#if defined (SIGXCPU)
	244	if (hostsig == SIGXCPU)
	245	return GDB_SIGNAL_XCPU;
	246	#endif
	247	#if defined (SIGXFSZ)
	248	if (hostsig == SIGXFSZ)
	249	return GDB_SIGNAL_XFSZ;
	250	#endif
	251	#if defined (SIGWIND)
	252	if (hostsig == SIGWIND)
	253	return GDB_SIGNAL_WIND;
	254	#endif
	255	#if defined (SIGPHONE)
	256	if (hostsig == SIGPHONE)
	257	return GDB_SIGNAL_PHONE;
	258	#endif
	259	#if defined (SIGLOST)
	260	if (hostsig == SIGLOST)
	261	return GDB_SIGNAL_LOST;
	262	#endif
	263	#if defined (SIGWAITING)
	264	if (hostsig == SIGWAITING)
	265	return GDB_SIGNAL_WAITING;
	266	#endif
	267	#if defined (SIGCANCEL)
	268	if (hostsig == SIGCANCEL)
	269	return GDB_SIGNAL_CANCEL;
	270	#endif
	271	#if defined (SIGLWP)
	272	if (hostsig == SIGLWP)
	273	return GDB_SIGNAL_LWP;
	274	#endif
	275	#if defined (SIGDANGER)
	276	if (hostsig == SIGDANGER)
	277	return GDB_SIGNAL_DANGER;
	278	#endif
	279	#if defined (SIGGRANT)
	280	if (hostsig == SIGGRANT)
	281	return GDB_SIGNAL_GRANT;
	282	#endif
	283	#if defined (SIGRETRACT)
	284	if (hostsig == SIGRETRACT)
	285	return GDB_SIGNAL_RETRACT;
	286	#endif
	287	#if defined (SIGMSG)
	288	if (hostsig == SIGMSG)
	289	return GDB_SIGNAL_MSG;
	290	#endif
	291	#if defined (SIGSOUND)
	292	if (hostsig == SIGSOUND)
	293	return GDB_SIGNAL_SOUND;
	294	#endif
	295	#if defined (SIGSAK)
	296	if (hostsig == SIGSAK)
	297	return GDB_SIGNAL_SAK;
	298	#endif
	299	#if defined (SIGPRIO)
	300	if (hostsig == SIGPRIO)
	301	return GDB_SIGNAL_PRIO;
	302	#endif
	303
	304	/* Mach exceptions. Assumes that the values for EXC_ are positive! */
	305	#if defined (EXC_BAD_ACCESS) && defined (_NSIG)
	306	if (hostsig == _NSIG + EXC_BAD_ACCESS)
	307	return GDB_EXC_BAD_ACCESS;
	308	#endif
	309	#if defined (EXC_BAD_INSTRUCTION) && defined (_NSIG)
	310	if (hostsig == _NSIG + EXC_BAD_INSTRUCTION)
	311	return GDB_EXC_BAD_INSTRUCTION;
	312	#endif
	313	#if defined (EXC_ARITHMETIC) && defined (_NSIG)
	314	if (hostsig == _NSIG + EXC_ARITHMETIC)
	315	return GDB_EXC_ARITHMETIC;
	316	#endif
	317	#if defined (EXC_EMULATION) && defined (_NSIG)
	318	if (hostsig == _NSIG + EXC_EMULATION)
	319	return GDB_EXC_EMULATION;
	320	#endif
	321	#if defined (EXC_SOFTWARE) && defined (_NSIG)
	322	if (hostsig == _NSIG + EXC_SOFTWARE)
	323	return GDB_EXC_SOFTWARE;
	324	#endif
	325	#if defined (EXC_BREAKPOINT) && defined (_NSIG)
	326	if (hostsig == _NSIG + EXC_BREAKPOINT)
	327	return GDB_EXC_BREAKPOINT;
	328	#endif
	329
	330	#if defined (SIGINFO)
	331	if (hostsig == SIGINFO)
	332	return GDB_SIGNAL_INFO;
	333	#endif
	334	#if defined (SIGLIBRT)
	335	if (hostsig == SIGLIBRT)
	336	return GDB_SIGNAL_LIBRT;
	337	#endif
	338
	339	#if defined (REALTIME_LO)
	340	if (hostsig >= REALTIME_LO && hostsig < REALTIME_HI)
	341	{
	342	/* This block of GDB_SIGNAL_REALTIME value is in order. */
	343	if (33 <= hostsig && hostsig <= 63)
	344	return (enum gdb_signal)
	345	(hostsig - 33 + (int) GDB_SIGNAL_REALTIME_33);
	346	else if (hostsig == 32)
	347	return GDB_SIGNAL_REALTIME_32;
	348	else if (64 <= hostsig && hostsig <= 127)
	349	return (enum gdb_signal)
	350	(hostsig - 64 + (int) GDB_SIGNAL_REALTIME_64);
	351	else
	352	error (_("GDB bug: target.c (gdb_signal_from_host): "
	353	"unrecognized real-time signal"));
	354	}
	355	#endif
	356
	357	return GDB_SIGNAL_UNKNOWN;
	358	}
	359
	360	/* Convert a OURSIG (an enum gdb_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_gdb_signal_to_host (enum gdb_signal oursig,
	367	int *oursig_ok)
	368	{
	369	int retsig;
	370	/* Silence the 'not used' warning, for targets that
	371	do not support signals. */
	372	(void) retsig;
	373
	374	/* Signals are ordered ANSI-standard signals first, other signals
	375	second, with signals in each block ordered by their numerical
	376	values on a typical POSIX platform. */
	377
	378	*oursig_ok = 1;
	379	switch (oursig)
	380	{
	381	case GDB_SIGNAL_0:
	382	return 0;
	383
	384	/* SIGINT, SIGILL, SIGABRT, SIGFPE, SIGSEGV and SIGTERM
	385	are ANSI-standard signals and are always available. */
	386	case GDB_SIGNAL_INT:
	387	return SIGINT;
	388	case GDB_SIGNAL_ILL:
	389	return SIGILL;
	390	case GDB_SIGNAL_ABRT:
	391	return SIGABRT;
	392	case GDB_SIGNAL_FPE:
	393	return SIGFPE;
	394	case GDB_SIGNAL_SEGV:
	395	return SIGSEGV;
	396	case GDB_SIGNAL_TERM:
	397	return SIGTERM;
	398
	399	/* All other signals need preprocessor conditionals. */
	400	#if defined (SIGHUP)
	401	case GDB_SIGNAL_HUP:
	402	return SIGHUP;
	403	#endif
	404	#if defined (SIGQUIT)
	405	case GDB_SIGNAL_QUIT:
	406	return SIGQUIT;
	407	#endif
	408	#if defined (SIGTRAP)
	409	case GDB_SIGNAL_TRAP:
	410	return SIGTRAP;
	411	#endif
	412	#if defined (SIGEMT)
	413	case GDB_SIGNAL_EMT:
	414	return SIGEMT;
	415	#endif
	416	#if defined (SIGKILL)
	417	case GDB_SIGNAL_KILL:
	418	return SIGKILL;
	419	#endif
	420	#if defined (SIGBUS)
	421	case GDB_SIGNAL_BUS:
	422	return SIGBUS;
	423	#endif
	424	#if defined (SIGSYS)
	425	case GDB_SIGNAL_SYS:
	426	return SIGSYS;
	427	#endif
	428	#if defined (SIGPIPE)
	429	case GDB_SIGNAL_PIPE:
	430	return SIGPIPE;
	431	#endif
	432	#if defined (SIGALRM)
	433	case GDB_SIGNAL_ALRM:
	434	return SIGALRM;
	435	#endif
	436	#if defined (SIGUSR1)
	437	case GDB_SIGNAL_USR1:
	438	return SIGUSR1;
	439	#endif
	440	#if defined (SIGUSR2)
	441	case GDB_SIGNAL_USR2:
	442	return SIGUSR2;
	443	#endif
	444	#if defined (SIGCHLD) \|\| defined (SIGCLD)
	445	case GDB_SIGNAL_CHLD:
	446	#if defined (SIGCHLD)
	447	return SIGCHLD;
	448	#else
	449	return SIGCLD;
	450	#endif
	451	#endif /* SIGCLD or SIGCHLD */
	452	#if defined (SIGPWR)
	453	case GDB_SIGNAL_PWR:
	454	return SIGPWR;
	455	#endif
	456	#if defined (SIGWINCH)
	457	case GDB_SIGNAL_WINCH:
	458	return SIGWINCH;
	459	#endif
	460	#if defined (SIGURG)
	461	case GDB_SIGNAL_URG:
	462	return SIGURG;
	463	#endif
	464	#if defined (SIGIO)
	465	case GDB_SIGNAL_IO:
	466	return SIGIO;
	467	#endif
	468	#if defined (SIGPOLL)
	469	case GDB_SIGNAL_POLL:
	470	return SIGPOLL;
	471	#endif
	472	#if defined (SIGSTOP)
	473	case GDB_SIGNAL_STOP:
	474	return SIGSTOP;
	475	#endif
	476	#if defined (SIGTSTP)
	477	case GDB_SIGNAL_TSTP:
	478	return SIGTSTP;
	479	#endif
	480	#if defined (SIGCONT)
	481	case GDB_SIGNAL_CONT:
	482	return SIGCONT;
	483	#endif
	484	#if defined (SIGTTIN)
	485	case GDB_SIGNAL_TTIN:
	486	return SIGTTIN;
	487	#endif
	488	#if defined (SIGTTOU)
	489	case GDB_SIGNAL_TTOU:
	490	return SIGTTOU;
	491	#endif
	492	#if defined (SIGVTALRM)
	493	case GDB_SIGNAL_VTALRM:
	494	return SIGVTALRM;
	495	#endif
	496	#if defined (SIGPROF)
	497	case GDB_SIGNAL_PROF:
	498	return SIGPROF;
	499	#endif
	500	#if defined (SIGXCPU)
	501	case GDB_SIGNAL_XCPU:
	502	return SIGXCPU;
	503	#endif
	504	#if defined (SIGXFSZ)
	505	case GDB_SIGNAL_XFSZ:
	506	return SIGXFSZ;
	507	#endif
	508	#if defined (SIGWIND)
	509	case GDB_SIGNAL_WIND:
	510	return SIGWIND;
	511	#endif
	512	#if defined (SIGPHONE)
	513	case GDB_SIGNAL_PHONE:
	514	return SIGPHONE;
	515	#endif
	516	#if defined (SIGLOST)
	517	case GDB_SIGNAL_LOST:
	518	return SIGLOST;
	519	#endif
	520	#if defined (SIGWAITING)
	521	case GDB_SIGNAL_WAITING:
	522	return SIGWAITING;
	523	#endif
	524	#if defined (SIGCANCEL)
	525	case GDB_SIGNAL_CANCEL:
	526	return SIGCANCEL;
	527	#endif
	528	#if defined (SIGLWP)
	529	case GDB_SIGNAL_LWP:
	530	return SIGLWP;
	531	#endif
	532	#if defined (SIGDANGER)
	533	case GDB_SIGNAL_DANGER:
	534	return SIGDANGER;
	535	#endif
	536	#if defined (SIGGRANT)
	537	case GDB_SIGNAL_GRANT:
	538	return SIGGRANT;
	539	#endif
	540	#if defined (SIGRETRACT)
	541	case GDB_SIGNAL_RETRACT:
	542	return SIGRETRACT;
	543	#endif
	544	#if defined (SIGMSG)
	545	case GDB_SIGNAL_MSG:
	546	return SIGMSG;
	547	#endif
	548	#if defined (SIGSOUND)
	549	case GDB_SIGNAL_SOUND:
	550	return SIGSOUND;
	551	#endif
	552	#if defined (SIGSAK)
	553	case GDB_SIGNAL_SAK:
	554	return SIGSAK;
	555	#endif
	556	#if defined (SIGPRIO)
	557	case GDB_SIGNAL_PRIO:
	558	return SIGPRIO;
	559	#endif
	560
	561	/* Mach exceptions. Assumes that the values for EXC_ are positive! */
	562	#if defined (EXC_BAD_ACCESS) && defined (_NSIG)
	563	case GDB_EXC_BAD_ACCESS:
	564	return _NSIG + EXC_BAD_ACCESS;
	565	#endif
	566	#if defined (EXC_BAD_INSTRUCTION) && defined (_NSIG)
	567	case GDB_EXC_BAD_INSTRUCTION:
	568	return _NSIG + EXC_BAD_INSTRUCTION;
	569	#endif
	570	#if defined (EXC_ARITHMETIC) && defined (_NSIG)
	571	case GDB_EXC_ARITHMETIC:
	572	return _NSIG + EXC_ARITHMETIC;
	573	#endif
	574	#if defined (EXC_EMULATION) && defined (_NSIG)
	575	case GDB_EXC_EMULATION:
	576	return _NSIG + EXC_EMULATION;
	577	#endif
	578	#if defined (EXC_SOFTWARE) && defined (_NSIG)
	579	case GDB_EXC_SOFTWARE:
	580	return _NSIG + EXC_SOFTWARE;
	581	#endif
	582	#if defined (EXC_BREAKPOINT) && defined (_NSIG)
	583	case GDB_EXC_BREAKPOINT:
	584	return _NSIG + EXC_BREAKPOINT;
	585	#endif
	586
	587	#if defined (SIGINFO)
	588	case GDB_SIGNAL_INFO:
	589	return SIGINFO;
	590	#endif
	591	#if defined (SIGLIBRT)
	592	case GDB_SIGNAL_LIBRT:
	593	return SIGLIBRT;
	594	#endif
	595
	596	default:
	597	#if defined (REALTIME_LO)
	598	retsig = 0;
	599
	600	if (oursig >= GDB_SIGNAL_REALTIME_33
	601	&& oursig <= GDB_SIGNAL_REALTIME_63)
	602	{
	603	/* This block of signals is continuous, and
	604	GDB_SIGNAL_REALTIME_33 is 33 by definition. */
	605	retsig = (int) oursig - (int) GDB_SIGNAL_REALTIME_33 + 33;
	606	}
	607	else if (oursig == GDB_SIGNAL_REALTIME_32)
	608	{
	609	/* GDB_SIGNAL_REALTIME_32 isn't contiguous with
	610	GDB_SIGNAL_REALTIME_33. It is 32 by definition. */
	611	retsig = 32;
	612	}
	613	else if (oursig >= GDB_SIGNAL_REALTIME_64
	614	&& oursig <= GDB_SIGNAL_REALTIME_127)
	615	{
	616	/* This block of signals is continuous, and
	617	GDB_SIGNAL_REALTIME_64 is 64 by definition. */
	618	retsig = (int) oursig - (int) GDB_SIGNAL_REALTIME_64 + 64;
	619	}
	620
	621	if (retsig >= REALTIME_LO && retsig < REALTIME_HI)
	622	return retsig;
	623	#endif
	624
	625	*oursig_ok = 0;
	626	return 0;
	627	}
	628	}
	629
	630	int
	631	gdb_signal_to_host_p (enum gdb_signal oursig)
	632	{
	633	int oursig_ok;
	634	do_gdb_signal_to_host (oursig, &oursig_ok);
	635	return oursig_ok;
	636	}
	637
	638	int
	639	gdb_signal_to_host (enum gdb_signal oursig)
	640	{
	641	int oursig_ok;
	642	int targ_signo = do_gdb_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."),
	648	gdb_signal_to_name (oursig));
	649	return 0;
	650	}
	651	else
	652	return targ_signo;
	653	}