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