/* Target signal translation functions for GDB. Copyright (C) 1990-2013 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 . */ #ifdef GDBSERVER #include "server.h" #else #include "defs.h" #include "gdb_string.h" #endif #ifdef HAVE_SIGNAL_H #include #endif #include "gdb_signals.h" #include "gdb_assert.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; } /* 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. */ if (hostsig == 0) return GDB_SIGNAL_0; #if defined (SIGHUP) if (hostsig == SIGHUP) return GDB_SIGNAL_HUP; #endif #if defined (SIGINT) if (hostsig == SIGINT) return GDB_SIGNAL_INT; #endif #if defined (SIGQUIT) if (hostsig == SIGQUIT) return GDB_SIGNAL_QUIT; #endif #if defined (SIGILL) if (hostsig == SIGILL) return GDB_SIGNAL_ILL; #endif #if defined (SIGTRAP) if (hostsig == SIGTRAP) return GDB_SIGNAL_TRAP; #endif #if defined (SIGABRT) if (hostsig == SIGABRT) return GDB_SIGNAL_ABRT; #endif #if defined (SIGEMT) if (hostsig == SIGEMT) return GDB_SIGNAL_EMT; #endif #if defined (SIGFPE) if (hostsig == SIGFPE) return GDB_SIGNAL_FPE; #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 (SIGSEGV) if (hostsig == SIGSEGV) return GDB_SIGNAL_SEGV; #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 (SIGTERM) if (hostsig == SIGTERM) return GDB_SIGNAL_TERM; #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 (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; *oursig_ok = 1; switch (oursig) { case GDB_SIGNAL_0: return 0; #if defined (SIGHUP) case GDB_SIGNAL_HUP: return SIGHUP; #endif #if defined (SIGINT) case GDB_SIGNAL_INT: return SIGINT; #endif #if defined (SIGQUIT) case GDB_SIGNAL_QUIT: return SIGQUIT; #endif #if defined (SIGILL) case GDB_SIGNAL_ILL: return SIGILL; #endif #if defined (SIGTRAP) case GDB_SIGNAL_TRAP: return SIGTRAP; #endif #if defined (SIGABRT) case GDB_SIGNAL_ABRT: return SIGABRT; #endif #if defined (SIGEMT) case GDB_SIGNAL_EMT: return SIGEMT; #endif #if defined (SIGFPE) case GDB_SIGNAL_FPE: return SIGFPE; #endif #if defined (SIGKILL) case GDB_SIGNAL_KILL: return SIGKILL; #endif #if defined (SIGBUS) case GDB_SIGNAL_BUS: return SIGBUS; #endif #if defined (SIGSEGV) case GDB_SIGNAL_SEGV: return SIGSEGV; #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 (SIGTERM) case GDB_SIGNAL_TERM: return SIGTERM; #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 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; }