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

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

   This file is part of GDB.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

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

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

#include "gdb_signals.h"

struct gdbarch;

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

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

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

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


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

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

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

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

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

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

  if (hostsig == 0)
    return TARGET_SIGNAL_0;

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

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

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

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

  return TARGET_SIGNAL_UNKNOWN;
}

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

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

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

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

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

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

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

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

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

      *oursig_ok = 0;
      return 0;
    }
}

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

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

#ifndef GDBSERVER

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

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

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

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

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

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

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