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