X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=gdb%2Fcommon%2Fsignals.c;h=d4cf9532925d6d172a03a95bd09bc8cb2af43e0d;hb=e8b416815be691cc3fb1212d1a3dcb5d21a0d19d;hp=321319aa20d5083227986ac866fa38d991bc31a4;hpb=7b6bb8daaceb9ecf3f42dea57ae82733d6a3b2f6;p=external%2Fbinutils.git

diff --git a/gdb/common/signals.c b/gdb/common/signals.c
index 321319a..d4cf953 100644
--- a/gdb/common/signals.c
+++ b/gdb/common/signals.c
@@ -1,7 +1,5 @@
 /* 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.
+   Copyright (C) 1990-2015 Free Software Foundation, Inc.
    Contributed by Cygnus Support.
 
    This file is part of GDB.
@@ -19,12 +17,7 @@
    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
+#include "common-defs.h"
 
 #ifdef HAVE_SIGNAL_H
 #include <signal.h>
@@ -48,34 +41,43 @@ struct gdbarch;
 # endif
 #endif
 
-/* This table must match in order and size the signals in enum target_signal.  */
+/* 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) { name, string },
+#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 *
-target_signal_to_string (enum target_signal sig)
+gdb_signal_to_string (enum gdb_signal sig)
 {
-  if ((int) sig >= TARGET_SIGNAL_FIRST && (int) sig <= TARGET_SIGNAL_LAST)
+  if ((int) sig >= GDB_SIGNAL_FIRST && (int) sig <= GDB_SIGNAL_LAST)
     return signals[sig].string;
   else
-    return signals[TARGET_SIGNAL_UNKNOWN].string;
+    return signals[GDB_SIGNAL_UNKNOWN].string;
 }
 
 /* Return the name for a signal.  */
 const char *
-target_signal_to_name (enum target_signal sig)
+gdb_signal_to_name (enum gdb_signal sig)
 {
-  if ((int) sig >= TARGET_SIGNAL_FIRST && (int) sig <= TARGET_SIGNAL_LAST
+  if ((int) sig >= GDB_SIGNAL_FIRST && (int) sig <= GDB_SIGNAL_LAST
       && signals[sig].name != NULL)
     return signals[sig].name;
   else
@@ -85,24 +87,24 @@ target_signal_to_name (enum target_signal sig)
 }
 
 /* Given a name, return its signal.  */
-enum target_signal
-target_signal_from_name (const char *name)
+enum gdb_signal
+gdb_signal_from_name (const char *name)
 {
-  enum target_signal sig;
+  enum gdb_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
+     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 = TARGET_SIGNAL_HUP;
-       sig < TARGET_SIGNAL_LAST;
-       sig = (enum target_signal) ((int) sig + 1))
+  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 TARGET_SIGNAL_UNKNOWN;
+  return GDB_SIGNAL_UNKNOWN;
 }
 
 /* The following functions are to help certain targets deal
@@ -110,258 +112,254 @@ target_signal_from_name (const char *name)
    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)
+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.  */
+  /* 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 TARGET_SIGNAL_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 TARGET_SIGNAL_HUP;
-#endif
-#if defined (SIGINT)
-  if (hostsig == SIGINT)
-    return TARGET_SIGNAL_INT;
+    return GDB_SIGNAL_HUP;
 #endif
 #if defined (SIGQUIT)
   if (hostsig == SIGQUIT)
-    return TARGET_SIGNAL_QUIT;
-#endif
-#if defined (SIGILL)
-  if (hostsig == SIGILL)
-    return TARGET_SIGNAL_ILL;
+    return GDB_SIGNAL_QUIT;
 #endif
 #if defined (SIGTRAP)
   if (hostsig == SIGTRAP)
-    return TARGET_SIGNAL_TRAP;
-#endif
-#if defined (SIGABRT)
-  if (hostsig == SIGABRT)
-    return TARGET_SIGNAL_ABRT;
+    return GDB_SIGNAL_TRAP;
 #endif
 #if defined (SIGEMT)
   if (hostsig == SIGEMT)
-    return TARGET_SIGNAL_EMT;
-#endif
-#if defined (SIGFPE)
-  if (hostsig == SIGFPE)
-    return TARGET_SIGNAL_FPE;
+    return GDB_SIGNAL_EMT;
 #endif
 #if defined (SIGKILL)
   if (hostsig == SIGKILL)
-    return TARGET_SIGNAL_KILL;
+    return GDB_SIGNAL_KILL;
 #endif
 #if defined (SIGBUS)
   if (hostsig == SIGBUS)
-    return TARGET_SIGNAL_BUS;
-#endif
-#if defined (SIGSEGV)
-  if (hostsig == SIGSEGV)
-    return TARGET_SIGNAL_SEGV;
+    return GDB_SIGNAL_BUS;
 #endif
 #if defined (SIGSYS)
   if (hostsig == SIGSYS)
-    return TARGET_SIGNAL_SYS;
+    return GDB_SIGNAL_SYS;
 #endif
 #if defined (SIGPIPE)
   if (hostsig == SIGPIPE)
-    return TARGET_SIGNAL_PIPE;
+    return GDB_SIGNAL_PIPE;
 #endif
 #if defined (SIGALRM)
   if (hostsig == SIGALRM)
-    return TARGET_SIGNAL_ALRM;
-#endif
-#if defined (SIGTERM)
-  if (hostsig == SIGTERM)
-    return TARGET_SIGNAL_TERM;
+    return GDB_SIGNAL_ALRM;
 #endif
 #if defined (SIGUSR1)
   if (hostsig == SIGUSR1)
-    return TARGET_SIGNAL_USR1;
+    return GDB_SIGNAL_USR1;
 #endif
 #if defined (SIGUSR2)
   if (hostsig == SIGUSR2)
-    return TARGET_SIGNAL_USR2;
+    return GDB_SIGNAL_USR2;
 #endif
 #if defined (SIGCLD)
   if (hostsig == SIGCLD)
-    return TARGET_SIGNAL_CHLD;
+    return GDB_SIGNAL_CHLD;
 #endif
 #if defined (SIGCHLD)
   if (hostsig == SIGCHLD)
-    return TARGET_SIGNAL_CHLD;
+    return GDB_SIGNAL_CHLD;
 #endif
 #if defined (SIGPWR)
   if (hostsig == SIGPWR)
-    return TARGET_SIGNAL_PWR;
+    return GDB_SIGNAL_PWR;
 #endif
 #if defined (SIGWINCH)
   if (hostsig == SIGWINCH)
-    return TARGET_SIGNAL_WINCH;
+    return GDB_SIGNAL_WINCH;
 #endif
 #if defined (SIGURG)
   if (hostsig == SIGURG)
-    return TARGET_SIGNAL_URG;
+    return GDB_SIGNAL_URG;
 #endif
 #if defined (SIGIO)
   if (hostsig == SIGIO)
-    return TARGET_SIGNAL_IO;
+    return GDB_SIGNAL_IO;
 #endif
 #if defined (SIGPOLL)
   if (hostsig == SIGPOLL)
-    return TARGET_SIGNAL_POLL;
+    return GDB_SIGNAL_POLL;
 #endif
 #if defined (SIGSTOP)
   if (hostsig == SIGSTOP)
-    return TARGET_SIGNAL_STOP;
+    return GDB_SIGNAL_STOP;
 #endif
 #if defined (SIGTSTP)
   if (hostsig == SIGTSTP)
-    return TARGET_SIGNAL_TSTP;
+    return GDB_SIGNAL_TSTP;
 #endif
 #if defined (SIGCONT)
   if (hostsig == SIGCONT)
-    return TARGET_SIGNAL_CONT;
+    return GDB_SIGNAL_CONT;
 #endif
 #if defined (SIGTTIN)
   if (hostsig == SIGTTIN)
-    return TARGET_SIGNAL_TTIN;
+    return GDB_SIGNAL_TTIN;
 #endif
 #if defined (SIGTTOU)
   if (hostsig == SIGTTOU)
-    return TARGET_SIGNAL_TTOU;
+    return GDB_SIGNAL_TTOU;
 #endif
 #if defined (SIGVTALRM)
   if (hostsig == SIGVTALRM)
-    return TARGET_SIGNAL_VTALRM;
+    return GDB_SIGNAL_VTALRM;
 #endif
 #if defined (SIGPROF)
   if (hostsig == SIGPROF)
-    return TARGET_SIGNAL_PROF;
+    return GDB_SIGNAL_PROF;
 #endif
 #if defined (SIGXCPU)
   if (hostsig == SIGXCPU)
-    return TARGET_SIGNAL_XCPU;
+    return GDB_SIGNAL_XCPU;
 #endif
 #if defined (SIGXFSZ)
   if (hostsig == SIGXFSZ)
-    return TARGET_SIGNAL_XFSZ;
+    return GDB_SIGNAL_XFSZ;
 #endif
 #if defined (SIGWIND)
   if (hostsig == SIGWIND)
-    return TARGET_SIGNAL_WIND;
+    return GDB_SIGNAL_WIND;
 #endif
 #if defined (SIGPHONE)
   if (hostsig == SIGPHONE)
-    return TARGET_SIGNAL_PHONE;
+    return GDB_SIGNAL_PHONE;
 #endif
 #if defined (SIGLOST)
   if (hostsig == SIGLOST)
-    return TARGET_SIGNAL_LOST;
+    return GDB_SIGNAL_LOST;
 #endif
 #if defined (SIGWAITING)
   if (hostsig == SIGWAITING)
-    return TARGET_SIGNAL_WAITING;
+    return GDB_SIGNAL_WAITING;
 #endif
 #if defined (SIGCANCEL)
   if (hostsig == SIGCANCEL)
-    return TARGET_SIGNAL_CANCEL;
+    return GDB_SIGNAL_CANCEL;
 #endif
 #if defined (SIGLWP)
   if (hostsig == SIGLWP)
-    return TARGET_SIGNAL_LWP;
+    return GDB_SIGNAL_LWP;
 #endif
 #if defined (SIGDANGER)
   if (hostsig == SIGDANGER)
-    return TARGET_SIGNAL_DANGER;
+    return GDB_SIGNAL_DANGER;
 #endif
 #if defined (SIGGRANT)
   if (hostsig == SIGGRANT)
-    return TARGET_SIGNAL_GRANT;
+    return GDB_SIGNAL_GRANT;
 #endif
 #if defined (SIGRETRACT)
   if (hostsig == SIGRETRACT)
-    return TARGET_SIGNAL_RETRACT;
+    return GDB_SIGNAL_RETRACT;
 #endif
 #if defined (SIGMSG)
   if (hostsig == SIGMSG)
-    return TARGET_SIGNAL_MSG;
+    return GDB_SIGNAL_MSG;
 #endif
 #if defined (SIGSOUND)
   if (hostsig == SIGSOUND)
-    return TARGET_SIGNAL_SOUND;
+    return GDB_SIGNAL_SOUND;
 #endif
 #if defined (SIGSAK)
   if (hostsig == SIGSAK)
-    return TARGET_SIGNAL_SAK;
+    return GDB_SIGNAL_SAK;
 #endif
 #if defined (SIGPRIO)
   if (hostsig == SIGPRIO)
-    return TARGET_SIGNAL_PRIO;
+    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 TARGET_EXC_BAD_ACCESS;
+    return GDB_EXC_BAD_ACCESS;
 #endif
 #if defined (EXC_BAD_INSTRUCTION) && defined (_NSIG)
   if (hostsig == _NSIG + EXC_BAD_INSTRUCTION)
-    return TARGET_EXC_BAD_INSTRUCTION;
+    return GDB_EXC_BAD_INSTRUCTION;
 #endif
 #if defined (EXC_ARITHMETIC) && defined (_NSIG)
   if (hostsig == _NSIG + EXC_ARITHMETIC)
-    return TARGET_EXC_ARITHMETIC;
+    return GDB_EXC_ARITHMETIC;
 #endif
 #if defined (EXC_EMULATION) && defined (_NSIG)
   if (hostsig == _NSIG + EXC_EMULATION)
-    return TARGET_EXC_EMULATION;
+    return GDB_EXC_EMULATION;
 #endif
 #if defined (EXC_SOFTWARE) && defined (_NSIG)
   if (hostsig == _NSIG + EXC_SOFTWARE)
-    return TARGET_EXC_SOFTWARE;
+    return GDB_EXC_SOFTWARE;
 #endif
 #if defined (EXC_BREAKPOINT) && defined (_NSIG)
   if (hostsig == _NSIG + EXC_BREAKPOINT)
-    return TARGET_EXC_BREAKPOINT;
+    return GDB_EXC_BREAKPOINT;
 #endif
 
 #if defined (SIGINFO)
   if (hostsig == SIGINFO)
-    return TARGET_SIGNAL_INFO;
+    return GDB_SIGNAL_INFO;
 #endif
 
 #if defined (REALTIME_LO)
   if (hostsig >= REALTIME_LO && hostsig < REALTIME_HI)
     {
-      /* This block of TARGET_SIGNAL_REALTIME value is in order.  */
+      /* This block of GDB_SIGNAL_REALTIME value is in order.  */
       if (33 <= hostsig && hostsig <= 63)
-	return (enum target_signal)
-	  (hostsig - 33 + (int) TARGET_SIGNAL_REALTIME_33);
+	return (enum gdb_signal)
+	  (hostsig - 33 + (int) GDB_SIGNAL_REALTIME_33);
       else if (hostsig == 32)
-	return TARGET_SIGNAL_REALTIME_32;
+	return GDB_SIGNAL_REALTIME_32;
       else if (64 <= hostsig && hostsig <= 127)
-	return (enum target_signal)
-	  (hostsig - 64 + (int) TARGET_SIGNAL_REALTIME_64);
+	return (enum gdb_signal)
+	  (hostsig - 64 + (int) GDB_SIGNAL_REALTIME_64);
       else
-	error ("GDB bug: target.c (target_signal_from_host): unrecognized real-time signal");
+	error (_("GDB bug: target.c (gdb_signal_from_host): "
+	       "unrecognized real-time signal"));
     }
 #endif
 
-  return TARGET_SIGNAL_UNKNOWN;
+  return GDB_SIGNAL_UNKNOWN;
 }
 
-/* Convert a OURSIG (an enum target_signal) to the form used by the
+/* 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_target_signal_to_host (enum target_signal oursig,
+do_gdb_signal_to_host (enum gdb_signal oursig,
 			  int *oursig_ok)
 {
   int retsig;
@@ -369,82 +367,78 @@ do_target_signal_to_host (enum target_signal oursig,
      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 TARGET_SIGNAL_0:
+    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 TARGET_SIGNAL_HUP:
+    case GDB_SIGNAL_HUP:
       return SIGHUP;
 #endif
-#if defined (SIGINT)
-    case TARGET_SIGNAL_INT:
-      return SIGINT;
-#endif
 #if defined (SIGQUIT)
-    case TARGET_SIGNAL_QUIT:
+    case GDB_SIGNAL_QUIT:
       return SIGQUIT;
 #endif
-#if defined (SIGILL)
-    case TARGET_SIGNAL_ILL:
-      return SIGILL;
-#endif
 #if defined (SIGTRAP)
-    case TARGET_SIGNAL_TRAP:
+    case GDB_SIGNAL_TRAP:
       return SIGTRAP;
 #endif
-#if defined (SIGABRT)
-    case TARGET_SIGNAL_ABRT:
-      return SIGABRT;
-#endif
 #if defined (SIGEMT)
-    case TARGET_SIGNAL_EMT:
+    case GDB_SIGNAL_EMT:
       return SIGEMT;
 #endif
-#if defined (SIGFPE)
-    case TARGET_SIGNAL_FPE:
-      return SIGFPE;
-#endif
 #if defined (SIGKILL)
-    case TARGET_SIGNAL_KILL:
+    case GDB_SIGNAL_KILL:
       return SIGKILL;
 #endif
 #if defined (SIGBUS)
-    case TARGET_SIGNAL_BUS:
+    case GDB_SIGNAL_BUS:
       return SIGBUS;
 #endif
-#if defined (SIGSEGV)
-    case TARGET_SIGNAL_SEGV:
-      return SIGSEGV;
-#endif
 #if defined (SIGSYS)
-    case TARGET_SIGNAL_SYS:
+    case GDB_SIGNAL_SYS:
       return SIGSYS;
 #endif
 #if defined (SIGPIPE)
-    case TARGET_SIGNAL_PIPE:
+    case GDB_SIGNAL_PIPE:
       return SIGPIPE;
 #endif
 #if defined (SIGALRM)
-    case TARGET_SIGNAL_ALRM:
+    case GDB_SIGNAL_ALRM:
       return SIGALRM;
 #endif
-#if defined (SIGTERM)
-    case TARGET_SIGNAL_TERM:
-      return SIGTERM;
-#endif
 #if defined (SIGUSR1)
-    case TARGET_SIGNAL_USR1:
+    case GDB_SIGNAL_USR1:
       return SIGUSR1;
 #endif
 #if defined (SIGUSR2)
-    case TARGET_SIGNAL_USR2:
+    case GDB_SIGNAL_USR2:
       return SIGUSR2;
 #endif
 #if defined (SIGCHLD) || defined (SIGCLD)
-    case TARGET_SIGNAL_CHLD:
+    case GDB_SIGNAL_CHLD:
 #if defined (SIGCHLD)
       return SIGCHLD;
 #else
@@ -452,142 +446,142 @@ do_target_signal_to_host (enum target_signal oursig,
 #endif
 #endif /* SIGCLD or SIGCHLD */
 #if defined (SIGPWR)
-    case TARGET_SIGNAL_PWR:
+    case GDB_SIGNAL_PWR:
       return SIGPWR;
 #endif
 #if defined (SIGWINCH)
-    case TARGET_SIGNAL_WINCH:
+    case GDB_SIGNAL_WINCH:
       return SIGWINCH;
 #endif
 #if defined (SIGURG)
-    case TARGET_SIGNAL_URG:
+    case GDB_SIGNAL_URG:
       return SIGURG;
 #endif
 #if defined (SIGIO)
-    case TARGET_SIGNAL_IO:
+    case GDB_SIGNAL_IO:
       return SIGIO;
 #endif
 #if defined (SIGPOLL)
-    case TARGET_SIGNAL_POLL:
+    case GDB_SIGNAL_POLL:
       return SIGPOLL;
 #endif
 #if defined (SIGSTOP)
-    case TARGET_SIGNAL_STOP:
+    case GDB_SIGNAL_STOP:
       return SIGSTOP;
 #endif
 #if defined (SIGTSTP)
-    case TARGET_SIGNAL_TSTP:
+    case GDB_SIGNAL_TSTP:
       return SIGTSTP;
 #endif
 #if defined (SIGCONT)
-    case TARGET_SIGNAL_CONT:
+    case GDB_SIGNAL_CONT:
       return SIGCONT;
 #endif
 #if defined (SIGTTIN)
-    case TARGET_SIGNAL_TTIN:
+    case GDB_SIGNAL_TTIN:
       return SIGTTIN;
 #endif
 #if defined (SIGTTOU)
-    case TARGET_SIGNAL_TTOU:
+    case GDB_SIGNAL_TTOU:
       return SIGTTOU;
 #endif
 #if defined (SIGVTALRM)
-    case TARGET_SIGNAL_VTALRM:
+    case GDB_SIGNAL_VTALRM:
       return SIGVTALRM;
 #endif
 #if defined (SIGPROF)
-    case TARGET_SIGNAL_PROF:
+    case GDB_SIGNAL_PROF:
       return SIGPROF;
 #endif
 #if defined (SIGXCPU)
-    case TARGET_SIGNAL_XCPU:
+    case GDB_SIGNAL_XCPU:
       return SIGXCPU;
 #endif
 #if defined (SIGXFSZ)
-    case TARGET_SIGNAL_XFSZ:
+    case GDB_SIGNAL_XFSZ:
       return SIGXFSZ;
 #endif
 #if defined (SIGWIND)
-    case TARGET_SIGNAL_WIND:
+    case GDB_SIGNAL_WIND:
       return SIGWIND;
 #endif
 #if defined (SIGPHONE)
-    case TARGET_SIGNAL_PHONE:
+    case GDB_SIGNAL_PHONE:
       return SIGPHONE;
 #endif
 #if defined (SIGLOST)
-    case TARGET_SIGNAL_LOST:
+    case GDB_SIGNAL_LOST:
       return SIGLOST;
 #endif
 #if defined (SIGWAITING)
-    case TARGET_SIGNAL_WAITING:
+    case GDB_SIGNAL_WAITING:
       return SIGWAITING;
 #endif
 #if defined (SIGCANCEL)
-    case TARGET_SIGNAL_CANCEL:
+    case GDB_SIGNAL_CANCEL:
       return SIGCANCEL;
 #endif
 #if defined (SIGLWP)
-    case TARGET_SIGNAL_LWP:
+    case GDB_SIGNAL_LWP:
       return SIGLWP;
 #endif
 #if defined (SIGDANGER)
-    case TARGET_SIGNAL_DANGER:
+    case GDB_SIGNAL_DANGER:
       return SIGDANGER;
 #endif
 #if defined (SIGGRANT)
-    case TARGET_SIGNAL_GRANT:
+    case GDB_SIGNAL_GRANT:
       return SIGGRANT;
 #endif
 #if defined (SIGRETRACT)
-    case TARGET_SIGNAL_RETRACT:
+    case GDB_SIGNAL_RETRACT:
       return SIGRETRACT;
 #endif
 #if defined (SIGMSG)
-    case TARGET_SIGNAL_MSG:
+    case GDB_SIGNAL_MSG:
       return SIGMSG;
 #endif
 #if defined (SIGSOUND)
-    case TARGET_SIGNAL_SOUND:
+    case GDB_SIGNAL_SOUND:
       return SIGSOUND;
 #endif
 #if defined (SIGSAK)
-    case TARGET_SIGNAL_SAK:
+    case GDB_SIGNAL_SAK:
       return SIGSAK;
 #endif
 #if defined (SIGPRIO)
-    case TARGET_SIGNAL_PRIO:
+    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 TARGET_EXC_BAD_ACCESS:
+    case GDB_EXC_BAD_ACCESS:
       return _NSIG + EXC_BAD_ACCESS;
 #endif
 #if defined (EXC_BAD_INSTRUCTION) && defined (_NSIG)
-    case TARGET_EXC_BAD_INSTRUCTION:
+    case GDB_EXC_BAD_INSTRUCTION:
       return _NSIG + EXC_BAD_INSTRUCTION;
 #endif
 #if defined (EXC_ARITHMETIC) && defined (_NSIG)
-    case TARGET_EXC_ARITHMETIC:
+    case GDB_EXC_ARITHMETIC:
       return _NSIG + EXC_ARITHMETIC;
 #endif
 #if defined (EXC_EMULATION) && defined (_NSIG)
-    case TARGET_EXC_EMULATION:
+    case GDB_EXC_EMULATION:
       return _NSIG + EXC_EMULATION;
 #endif
 #if defined (EXC_SOFTWARE) && defined (_NSIG)
-    case TARGET_EXC_SOFTWARE:
+    case GDB_EXC_SOFTWARE:
       return _NSIG + EXC_SOFTWARE;
 #endif
 #if defined (EXC_BREAKPOINT) && defined (_NSIG)
-    case TARGET_EXC_BREAKPOINT:
+    case GDB_EXC_BREAKPOINT:
       return _NSIG + EXC_BREAKPOINT;
 #endif
 
 #if defined (SIGINFO)
-    case TARGET_SIGNAL_INFO:
+    case GDB_SIGNAL_INFO:
       return SIGINFO;
 #endif
 
@@ -595,25 +589,25 @@ do_target_signal_to_host (enum target_signal oursig,
 #if defined (REALTIME_LO)
       retsig = 0;
 
-      if (oursig >= TARGET_SIGNAL_REALTIME_33
-	  && oursig <= TARGET_SIGNAL_REALTIME_63)
+      if (oursig >= GDB_SIGNAL_REALTIME_33
+	  && oursig <= GDB_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;
+             GDB_SIGNAL_REALTIME_33 is 33 by definition.  */
+	  retsig = (int) oursig - (int) GDB_SIGNAL_REALTIME_33 + 33;
 	}
-      else if (oursig == TARGET_SIGNAL_REALTIME_32)
+      else if (oursig == GDB_SIGNAL_REALTIME_32)
 	{
-	  /* TARGET_SIGNAL_REALTIME_32 isn't contiguous with
-             TARGET_SIGNAL_REALTIME_33.  It is 32 by definition.  */
+	  /* GDB_SIGNAL_REALTIME_32 isn't contiguous with
+             GDB_SIGNAL_REALTIME_33.  It is 32 by definition.  */
 	  retsig = 32;
 	}
-      else if (oursig >= TARGET_SIGNAL_REALTIME_64
-	  && oursig <= TARGET_SIGNAL_REALTIME_127)
+      else if (oursig >= GDB_SIGNAL_REALTIME_64
+	  && oursig <= GDB_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;
+             GDB_SIGNAL_REALTIME_64 is 64 by definition.  */
+	  retsig = (int) oursig - (int) GDB_SIGNAL_REALTIME_64 + 64;
 	}
 
       if (retsig >= REALTIME_LO && retsig < REALTIME_HI)
@@ -626,68 +620,26 @@ do_target_signal_to_host (enum target_signal oursig,
 }
 
 int
-target_signal_to_host_p (enum target_signal oursig)
+gdb_signal_to_host_p (enum gdb_signal oursig)
 {
   int oursig_ok;
-  do_target_signal_to_host (oursig, &oursig_ok);
+  do_gdb_signal_to_host (oursig, &oursig_ok);
   return oursig_ok;
 }
 
 int
-target_signal_to_host (enum target_signal oursig)
+gdb_signal_to_host (enum gdb_signal oursig)
 {
   int oursig_ok;
-  int targ_signo = do_target_signal_to_host (oursig, &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.\n",
-	       target_signal_to_name (oursig));
+      warning (_("Signal %s does not exist on this system."),
+	       gdb_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 */