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