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