gdb/signals/signals.c

   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 Free Software Foundation, Inc.
   4    Contributed by Cygnus Support.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21 #ifdef GDBSERVER
  22 #include "server.h"
  23 #else
  24 #include "defs.h"
  25 #include "target.h"
  26 #include "gdb_string.h"
  27 #endif
  28
  29 #ifdef HAVE_SIGNAL_H
  30 #include <signal.h>
  31 #endif
  32
  33 struct gdbarch;
  34
  35 /* Always use __SIGRTMIN if it's available.  SIGRTMIN is the lowest
  36    _available_ realtime signal, not the lowest supported; glibc takes
  37    several for its own use.  */
  38
  39 #ifndef REALTIME_LO
  40 # if defined(__SIGRTMIN)
  41 #  define REALTIME_LO __SIGRTMIN
  42 #  define REALTIME_HI (__SIGRTMAX + 1)
  43 # elif defined(SIGRTMIN)
  44 #  define REALTIME_LO SIGRTMIN
  45 #  define REALTIME_HI (SIGRTMAX + 1)
  46 # endif
  47 #endif
  48
  49 /* This table must match in order and size the signals in enum target_signal
  50    in src/include/gdb/signals.h.  */
  51 /* *INDENT-OFF* */
  52 static struct {
  53   char *name;
  54   char *string;
  55   } signals [] =
  56 {
  57   {"0", "Signal 0"},
  58   {"SIGHUP", "Hangup"},
  59   {"SIGINT", "Interrupt"},
  60   {"SIGQUIT", "Quit"},
  61   {"SIGILL", "Illegal instruction"},
  62   {"SIGTRAP", "Trace/breakpoint trap"},
  63   {"SIGABRT", "Aborted"},
  64   {"SIGEMT", "Emulation trap"},
  65   {"SIGFPE", "Arithmetic exception"},
  66   {"SIGKILL", "Killed"},
  67   {"SIGBUS", "Bus error"},
  68   {"SIGSEGV", "Segmentation fault"},
  69   {"SIGSYS", "Bad system call"},
  70   {"SIGPIPE", "Broken pipe"},
  71   {"SIGALRM", "Alarm clock"},
  72   {"SIGTERM", "Terminated"},
  73   {"SIGURG", "Urgent I/O condition"},
  74   {"SIGSTOP", "Stopped (signal)"},
  75   {"SIGTSTP", "Stopped (user)"},
  76   {"SIGCONT", "Continued"},
  77   {"SIGCHLD", "Child status changed"},
  78   {"SIGTTIN", "Stopped (tty input)"},
  79   {"SIGTTOU", "Stopped (tty output)"},
  80   {"SIGIO", "I/O possible"},
  81   {"SIGXCPU", "CPU time limit exceeded"},
  82   {"SIGXFSZ", "File size limit exceeded"},
  83   {"SIGVTALRM", "Virtual timer expired"},
  84   {"SIGPROF", "Profiling timer expired"},
  85   {"SIGWINCH", "Window size changed"},
  86   {"SIGLOST", "Resource lost"},
  87   {"SIGUSR1", "User defined signal 1"},
  88   {"SIGUSR2", "User defined signal 2"},
  89   {"SIGPWR", "Power fail/restart"},
  90   {"SIGPOLL", "Pollable event occurred"},
  91   {"SIGWIND", "SIGWIND"},
  92   {"SIGPHONE", "SIGPHONE"},
  93   {"SIGWAITING", "Process's LWPs are blocked"},
  94   {"SIGLWP", "Signal LWP"},
  95   {"SIGDANGER", "Swap space dangerously low"},
  96   {"SIGGRANT", "Monitor mode granted"},
  97   {"SIGRETRACT", "Need to relinquish monitor mode"},
  98   {"SIGMSG", "Monitor mode data available"},
  99   {"SIGSOUND", "Sound completed"},
 100   {"SIGSAK", "Secure attention"},
 101   {"SIGPRIO", "SIGPRIO"},
 102   {"SIG33", "Real-time event 33"},
 103   {"SIG34", "Real-time event 34"},
 104   {"SIG35", "Real-time event 35"},
 105   {"SIG36", "Real-time event 36"},
 106   {"SIG37", "Real-time event 37"},
 107   {"SIG38", "Real-time event 38"},
 108   {"SIG39", "Real-time event 39"},
 109   {"SIG40", "Real-time event 40"},
 110   {"SIG41", "Real-time event 41"},
 111   {"SIG42", "Real-time event 42"},
 112   {"SIG43", "Real-time event 43"},
 113   {"SIG44", "Real-time event 44"},
 114   {"SIG45", "Real-time event 45"},
 115   {"SIG46", "Real-time event 46"},
 116   {"SIG47", "Real-time event 47"},
 117   {"SIG48", "Real-time event 48"},
 118   {"SIG49", "Real-time event 49"},
 119   {"SIG50", "Real-time event 50"},
 120   {"SIG51", "Real-time event 51"},
 121   {"SIG52", "Real-time event 52"},
 122   {"SIG53", "Real-time event 53"},
 123   {"SIG54", "Real-time event 54"},
 124   {"SIG55", "Real-time event 55"},
 125   {"SIG56", "Real-time event 56"},
 126   {"SIG57", "Real-time event 57"},
 127   {"SIG58", "Real-time event 58"},
 128   {"SIG59", "Real-time event 59"},
 129   {"SIG60", "Real-time event 60"},
 130   {"SIG61", "Real-time event 61"},
 131   {"SIG62", "Real-time event 62"},
 132   {"SIG63", "Real-time event 63"},
 133   {"SIGCANCEL", "LWP internal signal"},
 134   {"SIG32", "Real-time event 32"},
 135   {"SIG64", "Real-time event 64"},
 136   {"SIG65", "Real-time event 65"},
 137   {"SIG66", "Real-time event 66"},
 138   {"SIG67", "Real-time event 67"},
 139   {"SIG68", "Real-time event 68"},
 140   {"SIG69", "Real-time event 69"},
 141   {"SIG70", "Real-time event 70"},
 142   {"SIG71", "Real-time event 71"},
 143   {"SIG72", "Real-time event 72"},
 144   {"SIG73", "Real-time event 73"},
 145   {"SIG74", "Real-time event 74"},
 146   {"SIG75", "Real-time event 75"},
 147   {"SIG76", "Real-time event 76"},
 148   {"SIG77", "Real-time event 77"},
 149   {"SIG78", "Real-time event 78"},
 150   {"SIG79", "Real-time event 79"},
 151   {"SIG80", "Real-time event 80"},
 152   {"SIG81", "Real-time event 81"},
 153   {"SIG82", "Real-time event 82"},
 154   {"SIG83", "Real-time event 83"},
 155   {"SIG84", "Real-time event 84"},
 156   {"SIG85", "Real-time event 85"},
 157   {"SIG86", "Real-time event 86"},
 158   {"SIG87", "Real-time event 87"},
 159   {"SIG88", "Real-time event 88"},
 160   {"SIG89", "Real-time event 89"},
 161   {"SIG90", "Real-time event 90"},
 162   {"SIG91", "Real-time event 91"},
 163   {"SIG92", "Real-time event 92"},
 164   {"SIG93", "Real-time event 93"},
 165   {"SIG94", "Real-time event 94"},
 166   {"SIG95", "Real-time event 95"},
 167   {"SIG96", "Real-time event 96"},
 168   {"SIG97", "Real-time event 97"},
 169   {"SIG98", "Real-time event 98"},
 170   {"SIG99", "Real-time event 99"},
 171   {"SIG100", "Real-time event 100"},
 172   {"SIG101", "Real-time event 101"},
 173   {"SIG102", "Real-time event 102"},
 174   {"SIG103", "Real-time event 103"},
 175   {"SIG104", "Real-time event 104"},
 176   {"SIG105", "Real-time event 105"},
 177   {"SIG106", "Real-time event 106"},
 178   {"SIG107", "Real-time event 107"},
 179   {"SIG108", "Real-time event 108"},
 180   {"SIG109", "Real-time event 109"},
 181   {"SIG110", "Real-time event 110"},
 182   {"SIG111", "Real-time event 111"},
 183   {"SIG112", "Real-time event 112"},
 184   {"SIG113", "Real-time event 113"},
 185   {"SIG114", "Real-time event 114"},
 186   {"SIG115", "Real-time event 115"},
 187   {"SIG116", "Real-time event 116"},
 188   {"SIG117", "Real-time event 117"},
 189   {"SIG118", "Real-time event 118"},
 190   {"SIG119", "Real-time event 119"},
 191   {"SIG120", "Real-time event 120"},
 192   {"SIG121", "Real-time event 121"},
 193   {"SIG122", "Real-time event 122"},
 194   {"SIG123", "Real-time event 123"},
 195   {"SIG124", "Real-time event 124"},
 196   {"SIG125", "Real-time event 125"},
 197   {"SIG126", "Real-time event 126"},
 198   {"SIG127", "Real-time event 127"},
 199
 200   {"SIGINFO", "Information request"},
 201
 202   {NULL, "Unknown signal"},
 203   {NULL, "Internal error: printing TARGET_SIGNAL_DEFAULT"},
 204
 205   /* Mach exceptions */
 206   {"EXC_BAD_ACCESS", "Could not access memory"},
 207   {"EXC_BAD_INSTRUCTION", "Illegal instruction/operand"},
 208   {"EXC_ARITHMETIC", "Arithmetic exception"},
 209   {"EXC_EMULATION", "Emulation instruction"},
 210   {"EXC_SOFTWARE", "Software generated exception"},
 211   {"EXC_BREAKPOINT", "Breakpoint"},
 212
 213   /* Last entry, used to check whether the table is the right size.  */
 214   {NULL, "TARGET_SIGNAL_MAGIC"}
 215 };
 216 /* *INDENT-ON* */
 217
 218
 219
 220 /* Return the string for a signal.  */
 221 char *
 222 target_signal_to_string (enum target_signal sig)
 223 {
 224   if ((int) sig >= TARGET_SIGNAL_FIRST && (int) sig <= TARGET_SIGNAL_LAST)
 225     return signals[sig].string;
 226   else
 227     return signals[TARGET_SIGNAL_UNKNOWN].string;
 228 }
 229
 230 /* Return the name for a signal.  */
 231 char *
 232 target_signal_to_name (enum target_signal sig)
 233 {
 234   if ((int) sig >= TARGET_SIGNAL_FIRST && (int) sig <= TARGET_SIGNAL_LAST
 235       && signals[sig].name != NULL)
 236     return signals[sig].name;
 237   else
 238     /* I think the code which prints this will always print it along
 239        with the string, so no need to be verbose (very old comment).  */
 240     return "?";
 241 }
 242
 243 /* Given a name, return its signal.  */
 244 enum target_signal
 245 target_signal_from_name (char *name)
 246 {
 247   enum target_signal sig;
 248
 249   /* It's possible we also should allow "SIGCLD" as well as "SIGCHLD"
 250      for TARGET_SIGNAL_SIGCHLD.  SIGIOT, on the other hand, is more
 251      questionable; seems like by now people should call it SIGABRT
 252      instead.  */
 253
 254   /* This ugly cast brought to you by the native VAX compiler.  */
 255   for (sig = TARGET_SIGNAL_HUP;
 256        sig < TARGET_SIGNAL_LAST;
 257        sig = (enum target_signal) ((int) sig + 1))
 258     if (signals[sig].name != NULL
 259         && strcmp (name, signals[sig].name) == 0)
 260       return sig;
 261   return TARGET_SIGNAL_UNKNOWN;
 262 }
 263 \f
 264 /* The following functions are to help certain targets deal
 265    with the signal/waitstatus stuff.  They could just as well be in
 266    a file called native-utils.c or unixwaitstatus-utils.c or whatever.  */
 267
 268 /* Convert host signal to our signals.  */
 269 enum target_signal
 270 target_signal_from_host (int hostsig)
 271 {
 272   /* A switch statement would make sense but would require special kludges
 273      to deal with the cases where more than one signal has the same number.  */
 274
 275   if (hostsig == 0)
 276     return TARGET_SIGNAL_0;
 277
 278 #if defined (SIGHUP)
 279   if (hostsig == SIGHUP)
 280     return TARGET_SIGNAL_HUP;
 281 #endif
 282 #if defined (SIGINT)
 283   if (hostsig == SIGINT)
 284     return TARGET_SIGNAL_INT;
 285 #endif
 286 #if defined (SIGQUIT)
 287   if (hostsig == SIGQUIT)
 288     return TARGET_SIGNAL_QUIT;
 289 #endif
 290 #if defined (SIGILL)
 291   if (hostsig == SIGILL)
 292     return TARGET_SIGNAL_ILL;
 293 #endif
 294 #if defined (SIGTRAP)
 295   if (hostsig == SIGTRAP)
 296     return TARGET_SIGNAL_TRAP;
 297 #endif
 298 #if defined (SIGABRT)
 299   if (hostsig == SIGABRT)
 300     return TARGET_SIGNAL_ABRT;
 301 #endif
 302 #if defined (SIGEMT)
 303   if (hostsig == SIGEMT)
 304     return TARGET_SIGNAL_EMT;
 305 #endif
 306 #if defined (SIGFPE)
 307   if (hostsig == SIGFPE)
 308     return TARGET_SIGNAL_FPE;
 309 #endif
 310 #if defined (SIGKILL)
 311   if (hostsig == SIGKILL)
 312     return TARGET_SIGNAL_KILL;
 313 #endif
 314 #if defined (SIGBUS)
 315   if (hostsig == SIGBUS)
 316     return TARGET_SIGNAL_BUS;
 317 #endif
 318 #if defined (SIGSEGV)
 319   if (hostsig == SIGSEGV)
 320     return TARGET_SIGNAL_SEGV;
 321 #endif
 322 #if defined (SIGSYS)
 323   if (hostsig == SIGSYS)
 324     return TARGET_SIGNAL_SYS;
 325 #endif
 326 #if defined (SIGPIPE)
 327   if (hostsig == SIGPIPE)
 328     return TARGET_SIGNAL_PIPE;
 329 #endif
 330 #if defined (SIGALRM)
 331   if (hostsig == SIGALRM)
 332     return TARGET_SIGNAL_ALRM;
 333 #endif
 334 #if defined (SIGTERM)
 335   if (hostsig == SIGTERM)
 336     return TARGET_SIGNAL_TERM;
 337 #endif
 338 #if defined (SIGUSR1)
 339   if (hostsig == SIGUSR1)
 340     return TARGET_SIGNAL_USR1;
 341 #endif
 342 #if defined (SIGUSR2)
 343   if (hostsig == SIGUSR2)
 344     return TARGET_SIGNAL_USR2;
 345 #endif
 346 #if defined (SIGCLD)
 347   if (hostsig == SIGCLD)
 348     return TARGET_SIGNAL_CHLD;
 349 #endif
 350 #if defined (SIGCHLD)
 351   if (hostsig == SIGCHLD)
 352     return TARGET_SIGNAL_CHLD;
 353 #endif
 354 #if defined (SIGPWR)
 355   if (hostsig == SIGPWR)
 356     return TARGET_SIGNAL_PWR;
 357 #endif
 358 #if defined (SIGWINCH)
 359   if (hostsig == SIGWINCH)
 360     return TARGET_SIGNAL_WINCH;
 361 #endif
 362 #if defined (SIGURG)
 363   if (hostsig == SIGURG)
 364     return TARGET_SIGNAL_URG;
 365 #endif
 366 #if defined (SIGIO)
 367   if (hostsig == SIGIO)
 368     return TARGET_SIGNAL_IO;
 369 #endif
 370 #if defined (SIGPOLL)
 371   if (hostsig == SIGPOLL)
 372     return TARGET_SIGNAL_POLL;
 373 #endif
 374 #if defined (SIGSTOP)
 375   if (hostsig == SIGSTOP)
 376     return TARGET_SIGNAL_STOP;
 377 #endif
 378 #if defined (SIGTSTP)
 379   if (hostsig == SIGTSTP)
 380     return TARGET_SIGNAL_TSTP;
 381 #endif
 382 #if defined (SIGCONT)
 383   if (hostsig == SIGCONT)
 384     return TARGET_SIGNAL_CONT;
 385 #endif
 386 #if defined (SIGTTIN)
 387   if (hostsig == SIGTTIN)
 388     return TARGET_SIGNAL_TTIN;
 389 #endif
 390 #if defined (SIGTTOU)
 391   if (hostsig == SIGTTOU)
 392     return TARGET_SIGNAL_TTOU;
 393 #endif
 394 #if defined (SIGVTALRM)
 395   if (hostsig == SIGVTALRM)
 396     return TARGET_SIGNAL_VTALRM;
 397 #endif
 398 #if defined (SIGPROF)
 399   if (hostsig == SIGPROF)
 400     return TARGET_SIGNAL_PROF;
 401 #endif
 402 #if defined (SIGXCPU)
 403   if (hostsig == SIGXCPU)
 404     return TARGET_SIGNAL_XCPU;
 405 #endif
 406 #if defined (SIGXFSZ)
 407   if (hostsig == SIGXFSZ)
 408     return TARGET_SIGNAL_XFSZ;
 409 #endif
 410 #if defined (SIGWIND)
 411   if (hostsig == SIGWIND)
 412     return TARGET_SIGNAL_WIND;
 413 #endif
 414 #if defined (SIGPHONE)
 415   if (hostsig == SIGPHONE)
 416     return TARGET_SIGNAL_PHONE;
 417 #endif
 418 #if defined (SIGLOST)
 419   if (hostsig == SIGLOST)
 420     return TARGET_SIGNAL_LOST;
 421 #endif
 422 #if defined (SIGWAITING)
 423   if (hostsig == SIGWAITING)
 424     return TARGET_SIGNAL_WAITING;
 425 #endif
 426 #if defined (SIGCANCEL)
 427   if (hostsig == SIGCANCEL)
 428     return TARGET_SIGNAL_CANCEL;
 429 #endif
 430 #if defined (SIGLWP)
 431   if (hostsig == SIGLWP)
 432     return TARGET_SIGNAL_LWP;
 433 #endif
 434 #if defined (SIGDANGER)
 435   if (hostsig == SIGDANGER)
 436     return TARGET_SIGNAL_DANGER;
 437 #endif
 438 #if defined (SIGGRANT)
 439   if (hostsig == SIGGRANT)
 440     return TARGET_SIGNAL_GRANT;
 441 #endif
 442 #if defined (SIGRETRACT)
 443   if (hostsig == SIGRETRACT)
 444     return TARGET_SIGNAL_RETRACT;
 445 #endif
 446 #if defined (SIGMSG)
 447   if (hostsig == SIGMSG)
 448     return TARGET_SIGNAL_MSG;
 449 #endif
 450 #if defined (SIGSOUND)
 451   if (hostsig == SIGSOUND)
 452     return TARGET_SIGNAL_SOUND;
 453 #endif
 454 #if defined (SIGSAK)
 455   if (hostsig == SIGSAK)
 456     return TARGET_SIGNAL_SAK;
 457 #endif
 458 #if defined (SIGPRIO)
 459   if (hostsig == SIGPRIO)
 460     return TARGET_SIGNAL_PRIO;
 461 #endif
 462
 463   /* Mach exceptions.  Assumes that the values for EXC_ are positive! */
 464 #if defined (EXC_BAD_ACCESS) && defined (_NSIG)
 465   if (hostsig == _NSIG + EXC_BAD_ACCESS)
 466     return TARGET_EXC_BAD_ACCESS;
 467 #endif
 468 #if defined (EXC_BAD_INSTRUCTION) && defined (_NSIG)
 469   if (hostsig == _NSIG + EXC_BAD_INSTRUCTION)
 470     return TARGET_EXC_BAD_INSTRUCTION;
 471 #endif
 472 #if defined (EXC_ARITHMETIC) && defined (_NSIG)
 473   if (hostsig == _NSIG + EXC_ARITHMETIC)
 474     return TARGET_EXC_ARITHMETIC;
 475 #endif
 476 #if defined (EXC_EMULATION) && defined (_NSIG)
 477   if (hostsig == _NSIG + EXC_EMULATION)
 478     return TARGET_EXC_EMULATION;
 479 #endif
 480 #if defined (EXC_SOFTWARE) && defined (_NSIG)
 481   if (hostsig == _NSIG + EXC_SOFTWARE)
 482     return TARGET_EXC_SOFTWARE;
 483 #endif
 484 #if defined (EXC_BREAKPOINT) && defined (_NSIG)
 485   if (hostsig == _NSIG + EXC_BREAKPOINT)
 486     return TARGET_EXC_BREAKPOINT;
 487 #endif
 488
 489 #if defined (SIGINFO)
 490   if (hostsig == SIGINFO)
 491     return TARGET_SIGNAL_INFO;
 492 #endif
 493
 494 #if defined (REALTIME_LO)
 495   if (hostsig >= REALTIME_LO && hostsig < REALTIME_HI)
 496     {
 497       /* This block of TARGET_SIGNAL_REALTIME value is in order.  */
 498       if (33 <= hostsig && hostsig <= 63)
 499         return (enum target_signal)
 500           (hostsig - 33 + (int) TARGET_SIGNAL_REALTIME_33);
 501       else if (hostsig == 32)
 502         return TARGET_SIGNAL_REALTIME_32;
 503       else if (64 <= hostsig && hostsig <= 127)
 504         return (enum target_signal)
 505           (hostsig - 64 + (int) TARGET_SIGNAL_REALTIME_64);
 506       else
 507         error ("GDB bug: target.c (target_signal_from_host): unrecognized real-time signal");
 508     }
 509 #endif
 510
 511   return TARGET_SIGNAL_UNKNOWN;
 512 }
 513
 514 /* Convert a OURSIG (an enum target_signal) to the form used by the
 515    target operating system (refered to as the ``host'') or zero if the
 516    equivalent host signal is not available.  Set/clear OURSIG_OK
 517    accordingly. */
 518
 519 static int
 520 do_target_signal_to_host (enum target_signal oursig,
 521                           int *oursig_ok)
 522 {
 523   int retsig;
 524   /* Silence the 'not used' warning, for targets that
 525      do not support signals.  */
 526   (void) retsig;
 527
 528   *oursig_ok = 1;
 529   switch (oursig)
 530     {
 531     case TARGET_SIGNAL_0:
 532       return 0;
 533
 534 #if defined (SIGHUP)
 535     case TARGET_SIGNAL_HUP:
 536       return SIGHUP;
 537 #endif
 538 #if defined (SIGINT)
 539     case TARGET_SIGNAL_INT:
 540       return SIGINT;
 541 #endif
 542 #if defined (SIGQUIT)
 543     case TARGET_SIGNAL_QUIT:
 544       return SIGQUIT;
 545 #endif
 546 #if defined (SIGILL)
 547     case TARGET_SIGNAL_ILL:
 548       return SIGILL;
 549 #endif
 550 #if defined (SIGTRAP)
 551     case TARGET_SIGNAL_TRAP:
 552       return SIGTRAP;
 553 #endif
 554 #if defined (SIGABRT)
 555     case TARGET_SIGNAL_ABRT:
 556       return SIGABRT;
 557 #endif
 558 #if defined (SIGEMT)
 559     case TARGET_SIGNAL_EMT:
 560       return SIGEMT;
 561 #endif
 562 #if defined (SIGFPE)
 563     case TARGET_SIGNAL_FPE:
 564       return SIGFPE;
 565 #endif
 566 #if defined (SIGKILL)
 567     case TARGET_SIGNAL_KILL:
 568       return SIGKILL;
 569 #endif
 570 #if defined (SIGBUS)
 571     case TARGET_SIGNAL_BUS:
 572       return SIGBUS;
 573 #endif
 574 #if defined (SIGSEGV)
 575     case TARGET_SIGNAL_SEGV:
 576       return SIGSEGV;
 577 #endif
 578 #if defined (SIGSYS)
 579     case TARGET_SIGNAL_SYS:
 580       return SIGSYS;
 581 #endif
 582 #if defined (SIGPIPE)
 583     case TARGET_SIGNAL_PIPE:
 584       return SIGPIPE;
 585 #endif
 586 #if defined (SIGALRM)
 587     case TARGET_SIGNAL_ALRM:
 588       return SIGALRM;
 589 #endif
 590 #if defined (SIGTERM)
 591     case TARGET_SIGNAL_TERM:
 592       return SIGTERM;
 593 #endif
 594 #if defined (SIGUSR1)
 595     case TARGET_SIGNAL_USR1:
 596       return SIGUSR1;
 597 #endif
 598 #if defined (SIGUSR2)
 599     case TARGET_SIGNAL_USR2:
 600       return SIGUSR2;
 601 #endif
 602 #if defined (SIGCHLD) || defined (SIGCLD)
 603     case TARGET_SIGNAL_CHLD:
 604 #if defined (SIGCHLD)
 605       return SIGCHLD;
 606 #else
 607       return SIGCLD;
 608 #endif
 609 #endif /* SIGCLD or SIGCHLD */
 610 #if defined (SIGPWR)
 611     case TARGET_SIGNAL_PWR:
 612       return SIGPWR;
 613 #endif
 614 #if defined (SIGWINCH)
 615     case TARGET_SIGNAL_WINCH:
 616       return SIGWINCH;
 617 #endif
 618 #if defined (SIGURG)
 619     case TARGET_SIGNAL_URG:
 620       return SIGURG;
 621 #endif
 622 #if defined (SIGIO)
 623     case TARGET_SIGNAL_IO:
 624       return SIGIO;
 625 #endif
 626 #if defined (SIGPOLL)
 627     case TARGET_SIGNAL_POLL:
 628       return SIGPOLL;
 629 #endif
 630 #if defined (SIGSTOP)
 631     case TARGET_SIGNAL_STOP:
 632       return SIGSTOP;
 633 #endif
 634 #if defined (SIGTSTP)
 635     case TARGET_SIGNAL_TSTP:
 636       return SIGTSTP;
 637 #endif
 638 #if defined (SIGCONT)
 639     case TARGET_SIGNAL_CONT:
 640       return SIGCONT;
 641 #endif
 642 #if defined (SIGTTIN)
 643     case TARGET_SIGNAL_TTIN:
 644       return SIGTTIN;
 645 #endif
 646 #if defined (SIGTTOU)
 647     case TARGET_SIGNAL_TTOU:
 648       return SIGTTOU;
 649 #endif
 650 #if defined (SIGVTALRM)
 651     case TARGET_SIGNAL_VTALRM:
 652       return SIGVTALRM;
 653 #endif
 654 #if defined (SIGPROF)
 655     case TARGET_SIGNAL_PROF:
 656       return SIGPROF;
 657 #endif
 658 #if defined (SIGXCPU)
 659     case TARGET_SIGNAL_XCPU:
 660       return SIGXCPU;
 661 #endif
 662 #if defined (SIGXFSZ)
 663     case TARGET_SIGNAL_XFSZ:
 664       return SIGXFSZ;
 665 #endif
 666 #if defined (SIGWIND)
 667     case TARGET_SIGNAL_WIND:
 668       return SIGWIND;
 669 #endif
 670 #if defined (SIGPHONE)
 671     case TARGET_SIGNAL_PHONE:
 672       return SIGPHONE;
 673 #endif
 674 #if defined (SIGLOST)
 675     case TARGET_SIGNAL_LOST:
 676       return SIGLOST;
 677 #endif
 678 #if defined (SIGWAITING)
 679     case TARGET_SIGNAL_WAITING:
 680       return SIGWAITING;
 681 #endif
 682 #if defined (SIGCANCEL)
 683     case TARGET_SIGNAL_CANCEL:
 684       return SIGCANCEL;
 685 #endif
 686 #if defined (SIGLWP)
 687     case TARGET_SIGNAL_LWP:
 688       return SIGLWP;
 689 #endif
 690 #if defined (SIGDANGER)
 691     case TARGET_SIGNAL_DANGER:
 692       return SIGDANGER;
 693 #endif
 694 #if defined (SIGGRANT)
 695     case TARGET_SIGNAL_GRANT:
 696       return SIGGRANT;
 697 #endif
 698 #if defined (SIGRETRACT)
 699     case TARGET_SIGNAL_RETRACT:
 700       return SIGRETRACT;
 701 #endif
 702 #if defined (SIGMSG)
 703     case TARGET_SIGNAL_MSG:
 704       return SIGMSG;
 705 #endif
 706 #if defined (SIGSOUND)
 707     case TARGET_SIGNAL_SOUND:
 708       return SIGSOUND;
 709 #endif
 710 #if defined (SIGSAK)
 711     case TARGET_SIGNAL_SAK:
 712       return SIGSAK;
 713 #endif
 714 #if defined (SIGPRIO)
 715     case TARGET_SIGNAL_PRIO:
 716       return SIGPRIO;
 717 #endif
 718
 719       /* Mach exceptions.  Assumes that the values for EXC_ are positive! */
 720 #if defined (EXC_BAD_ACCESS) && defined (_NSIG)
 721     case TARGET_EXC_BAD_ACCESS:
 722       return _NSIG + EXC_BAD_ACCESS;
 723 #endif
 724 #if defined (EXC_BAD_INSTRUCTION) && defined (_NSIG)
 725     case TARGET_EXC_BAD_INSTRUCTION:
 726       return _NSIG + EXC_BAD_INSTRUCTION;
 727 #endif
 728 #if defined (EXC_ARITHMETIC) && defined (_NSIG)
 729     case TARGET_EXC_ARITHMETIC:
 730       return _NSIG + EXC_ARITHMETIC;
 731 #endif
 732 #if defined (EXC_EMULATION) && defined (_NSIG)
 733     case TARGET_EXC_EMULATION:
 734       return _NSIG + EXC_EMULATION;
 735 #endif
 736 #if defined (EXC_SOFTWARE) && defined (_NSIG)
 737     case TARGET_EXC_SOFTWARE:
 738       return _NSIG + EXC_SOFTWARE;
 739 #endif
 740 #if defined (EXC_BREAKPOINT) && defined (_NSIG)
 741     case TARGET_EXC_BREAKPOINT:
 742       return _NSIG + EXC_BREAKPOINT;
 743 #endif
 744
 745 #if defined (SIGINFO)
 746     case TARGET_SIGNAL_INFO:
 747       return SIGINFO;
 748 #endif
 749
 750     default:
 751 #if defined (REALTIME_LO)
 752       retsig = 0;
 753
 754       if (oursig >= TARGET_SIGNAL_REALTIME_33
 755           && oursig <= TARGET_SIGNAL_REALTIME_63)
 756         {
 757           /* This block of signals is continuous, and
 758              TARGET_SIGNAL_REALTIME_33 is 33 by definition.  */
 759           retsig = (int) oursig - (int) TARGET_SIGNAL_REALTIME_33 + 33;
 760         }
 761       else if (oursig == TARGET_SIGNAL_REALTIME_32)
 762         {
 763           /* TARGET_SIGNAL_REALTIME_32 isn't contiguous with
 764              TARGET_SIGNAL_REALTIME_33.  It is 32 by definition.  */
 765           retsig = 32;
 766         }
 767       else if (oursig >= TARGET_SIGNAL_REALTIME_64
 768           && oursig <= TARGET_SIGNAL_REALTIME_127)
 769         {
 770           /* This block of signals is continuous, and
 771              TARGET_SIGNAL_REALTIME_64 is 64 by definition.  */
 772           retsig = (int) oursig - (int) TARGET_SIGNAL_REALTIME_64 + 64;
 773         }
 774
 775       if (retsig >= REALTIME_LO && retsig < REALTIME_HI)
 776         return retsig;
 777 #endif
 778
 779       *oursig_ok = 0;
 780       return 0;
 781     }
 782 }
 783
 784 int
 785 target_signal_to_host_p (enum target_signal oursig)
 786 {
 787   int oursig_ok;
 788   do_target_signal_to_host (oursig, &oursig_ok);
 789   return oursig_ok;
 790 }
 791
 792 int
 793 target_signal_to_host (enum target_signal oursig)
 794 {
 795   int oursig_ok;
 796   int targ_signo = do_target_signal_to_host (oursig, &oursig_ok);
 797   if (!oursig_ok)
 798     {
 799       /* The user might be trying to do "signal SIGSAK" where this system
 800          doesn't have SIGSAK.  */
 801       warning ("Signal %s does not exist on this system.\n",
 802                target_signal_to_name (oursig));
 803       return 0;
 804     }
 805   else
 806     return targ_signo;
 807 }
 808
 809 /* In some circumstances we allow a command to specify a numeric
 810    signal.  The idea is to keep these circumstances limited so that
 811    users (and scripts) develop portable habits.  For comparison,
 812    POSIX.2 `kill' requires that 1,2,3,6,9,14, and 15 work (and using a
 813    numeric signal at all is obsolescent.  We are slightly more
 814    lenient and allow 1-15 which should match host signal numbers on
 815    most systems.  Use of symbolic signal names is strongly encouraged.  */
 816
 817 enum target_signal
 818 target_signal_from_command (int num)
 819 {
 820   if (num >= 1 && num <= 15)
 821     return (enum target_signal) num;
 822   error ("Only signals 1-15 are valid as numeric signals.\n\
 823 Use \"info signals\" for a list of symbolic signals.");
 824 }
 825
 826 #ifndef GDBSERVER
 827 extern initialize_file_ftype _initialize_signals; /* -Wmissing-prototype */
 828
 829 void
 830 _initialize_signals (void)
 831 {
 832   if (strcmp (signals[TARGET_SIGNAL_LAST].string, "TARGET_SIGNAL_MAGIC") != 0)
 833     internal_error (__FILE__, __LINE__, "failed internal consistency check");
 834 }
 835 #endif
 836
 837 int
 838 default_target_signal_to_host (struct gdbarch *gdbarch, enum target_signal ts)
 839 {
 840   return target_signal_to_host (ts);
 841 }
 842
 843 enum target_signal
 844 default_target_signal_from_host (struct gdbarch *gdbarch, int signo)
 845 {
 846   return target_signal_from_host (signo);
 847 }