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 /* Last entry, used to check whether the table is the right size. */ 201 {NULL, "TARGET_SIGNAL_MAGIC"} 202 }; 203 /* *INDENT-ON* */ 204 205 206 207 /* Return the name for a signal. */ 208 const char *target_signal_to_name (enum target_signal sig) 209 { 210 if ((sig >= TARGET_SIGNAL_FIRST) && (sig <= TARGET_SIGNAL_LAST) 211 && signals[sig].name != NULL) 212 return signals[sig].name; 213 else 214 /* I think the code which prints this will always print it along 215 with the string, so no need to be verbose (very old comment). */ 216 return "?"; 217 } 218 219 /* Given a name, return its signal. */ 220 enum target_signal target_signal_from_name (const char *name) 221 { 222 enum target_signal sig; 223 224 /* It's possible we also should allow "SIGCLD" as well as "SIGCHLD" 225 for TARGET_SIGNAL_SIGCHLD. SIGIOT, on the other hand, is more 226 questionable; seems like by now people should call it SIGABRT 227 instead. */ 228 229 /* This ugly cast brought to you by the native VAX compiler. */ 230 for (sig = TARGET_SIGNAL_HUP; 231 sig < TARGET_SIGNAL_LAST; 232 sig = (enum target_signal) ((int) sig + 1)) 233 if (signals[sig].name != NULL 234 && strcmp (name, signals[sig].name) == 0) 235 return sig; 236 return TARGET_SIGNAL_UNKNOWN; 237 } 238 239 240 /* The following functions are to help certain targets deal 241 with the signal/waitstatus stuff. They could just as well be in 242 a file called native-utils.c or unixwaitstatus-utils.c or whatever. */ 243 244 /* Convert host signal to our signals. */ 245 enum target_signal target_signal_from_host (int hostsig) 246 { 247 /* A switch statement would make sense but would require special kludges 248 to deal with the cases where more than one signal has the same number. */ 249 250 if (hostsig == 0) 251 return TARGET_SIGNAL_0; 252 253 #if defined (VKI_SIGHUP) 254 if (hostsig == VKI_SIGHUP) 255 return TARGET_SIGNAL_HUP; 256 #endif 257 #if defined (VKI_SIGINT) 258 if (hostsig == VKI_SIGINT) 259 return TARGET_SIGNAL_INT; 260 #endif 261 #if defined (VKI_SIGQUIT) 262 if (hostsig == VKI_SIGQUIT) 263 return TARGET_SIGNAL_QUIT; 264 #endif 265 #if defined (VKI_SIGILL) 266 if (hostsig == VKI_SIGILL) 267 return TARGET_SIGNAL_ILL; 268 #endif 269 #if defined (VKI_SIGTRAP) 270 if (hostsig == VKI_SIGTRAP) 271 return TARGET_SIGNAL_TRAP; 272 #endif 273 #if defined (VKI_SIGABRT) 274 if (hostsig == VKI_SIGABRT) 275 return TARGET_SIGNAL_ABRT; 276 #endif 277 #if defined (VKI_SIGEMT) 278 if (hostsig == VKI_SIGEMT) 279 return TARGET_SIGNAL_EMT; 280 #endif 281 #if defined (VKI_SIGFPE) 282 if (hostsig == VKI_SIGFPE) 283 return TARGET_SIGNAL_FPE; 284 #endif 285 #if defined (VKI_SIGKILL) 286 if (hostsig == VKI_SIGKILL) 287 return TARGET_SIGNAL_KILL; 288 #endif 289 #if defined (VKI_SIGBUS) 290 if (hostsig == VKI_SIGBUS) 291 return TARGET_SIGNAL_BUS; 292 #endif 293 #if defined (VKI_SIGSEGV) 294 if (hostsig == VKI_SIGSEGV) 295 return TARGET_SIGNAL_SEGV; 296 #endif 297 #if defined (VKI_SIGSYS) 298 if (hostsig == VKI_SIGSYS) 299 return TARGET_SIGNAL_SYS; 300 #endif 301 #if defined (VKI_SIGPIPE) 302 if (hostsig == VKI_SIGPIPE) 303 return TARGET_SIGNAL_PIPE; 304 #endif 305 #if defined (VKI_SIGALRM) 306 if (hostsig == VKI_SIGALRM) 307 return TARGET_SIGNAL_ALRM; 308 #endif 309 #if defined (VKI_SIGTERM) 310 if (hostsig == VKI_SIGTERM) 311 return TARGET_SIGNAL_TERM; 312 #endif 313 #if defined (VKI_SIGUSR1) 314 if (hostsig == VKI_SIGUSR1) 315 return TARGET_SIGNAL_USR1; 316 #endif 317 #if defined (VKI_SIGUSR2) 318 if (hostsig == VKI_SIGUSR2) 319 return TARGET_SIGNAL_USR2; 320 #endif 321 #if defined (VKI_SIGCLD) 322 if (hostsig == VKI_SIGCLD) 323 return TARGET_SIGNAL_CHLD; 324 #endif 325 #if defined (VKI_SIGCHLD) 326 if (hostsig == VKI_SIGCHLD) 327 return TARGET_SIGNAL_CHLD; 328 #endif 329 #if defined (VKI_SIGPWR) 330 if (hostsig == VKI_SIGPWR) 331 return TARGET_SIGNAL_PWR; 332 #endif 333 #if defined (VKI_SIGWINCH) 334 if (hostsig == VKI_SIGWINCH) 335 return TARGET_SIGNAL_WINCH; 336 #endif 337 #if defined (VKI_SIGURG) 338 if (hostsig == VKI_SIGURG) 339 return TARGET_SIGNAL_URG; 340 #endif 341 #if defined (VKI_SIGIO) 342 if (hostsig == VKI_SIGIO) 343 return TARGET_SIGNAL_IO; 344 #endif 345 #if defined (VKI_SIGPOLL) 346 if (hostsig == VKI_SIGPOLL) 347 return TARGET_SIGNAL_POLL; 348 #endif 349 #if defined (VKI_SIGSTOP) 350 if (hostsig == VKI_SIGSTOP) 351 return TARGET_SIGNAL_STOP; 352 #endif 353 #if defined (VKI_SIGTSTP) 354 if (hostsig == VKI_SIGTSTP) 355 return TARGET_SIGNAL_TSTP; 356 #endif 357 #if defined (VKI_SIGCONT) 358 if (hostsig == VKI_SIGCONT) 359 return TARGET_SIGNAL_CONT; 360 #endif 361 #if defined (VKI_SIGTTIN) 362 if (hostsig == VKI_SIGTTIN) 363 return TARGET_SIGNAL_TTIN; 364 #endif 365 #if defined (VKI_SIGTTOU) 366 if (hostsig == VKI_SIGTTOU) 367 return TARGET_SIGNAL_TTOU; 368 #endif 369 #if defined (VKI_SIGVTALRM) 370 if (hostsig == VKI_SIGVTALRM) 371 return TARGET_SIGNAL_VTALRM; 372 #endif 373 #if defined (VKI_SIGPROF) 374 if (hostsig == VKI_SIGPROF) 375 return TARGET_SIGNAL_PROF; 376 #endif 377 #if defined (VKI_SIGXCPU) 378 if (hostsig == VKI_SIGXCPU) 379 return TARGET_SIGNAL_XCPU; 380 #endif 381 #if defined (VKI_SIGXFSZ) 382 if (hostsig == VKI_SIGXFSZ) 383 return TARGET_SIGNAL_XFSZ; 384 #endif 385 #if defined (VKI_SIGWIND) 386 if (hostsig == VKI_SIGWIND) 387 return TARGET_SIGNAL_WIND; 388 #endif 389 #if defined (VKI_SIGPHONE) 390 if (hostsig == VKI_SIGPHONE) 391 return TARGET_SIGNAL_PHONE; 392 #endif 393 #if defined (VKI_SIGLOST) 394 if (hostsig == VKI_SIGLOST) 395 return TARGET_SIGNAL_LOST; 396 #endif 397 #if defined (VKI_SIGWAITING) 398 if (hostsig == VKI_SIGWAITING) 399 return TARGET_SIGNAL_WAITING; 400 #endif 401 #if defined (VKI_SIGCANCEL) 402 if (hostsig == VKI_SIGCANCEL) 403 return TARGET_SIGNAL_CANCEL; 404 #endif 405 #if defined (VKI_SIGLWP) 406 if (hostsig == VKI_SIGLWP) 407 return TARGET_SIGNAL_LWP; 408 #endif 409 #if defined (VKI_SIGDANGER) 410 if (hostsig == VKI_SIGDANGER) 411 return TARGET_SIGNAL_DANGER; 412 #endif 413 #if defined (VKI_SIGGRANT) 414 if (hostsig == VKI_SIGGRANT) 415 return TARGET_SIGNAL_GRANT; 416 #endif 417 #if defined (VKI_SIGRETRACT) 418 if (hostsig == VKI_SIGRETRACT) 419 return TARGET_SIGNAL_RETRACT; 420 #endif 421 #if defined (VKI_SIGMSG) 422 if (hostsig == VKI_SIGMSG) 423 return TARGET_SIGNAL_MSG; 424 #endif 425 #if defined (VKI_SIGSOUND) 426 if (hostsig == VKI_SIGSOUND) 427 return TARGET_SIGNAL_SOUND; 428 #endif 429 #if defined (VKI_SIGSAK) 430 if (hostsig == VKI_SIGSAK) 431 return TARGET_SIGNAL_SAK; 432 #endif 433 #if defined (VKI_SIGPRIO) 434 if (hostsig == VKI_SIGPRIO) 435 return TARGET_SIGNAL_PRIO; 436 #endif 437 438 /* Mach exceptions. Assumes that the values for EXC_ are positive! */ 439 #if defined (EXC_BAD_ACCESS) && defined (_NSIG) 440 if (hostsig == _NSIG + EXC_BAD_ACCESS) 441 return TARGET_EXC_BAD_ACCESS; 442 #endif 443 #if defined (EXC_BAD_INSTRUCTION) && defined (_NSIG) 444 if (hostsig == _NSIG + EXC_BAD_INSTRUCTION) 445 return TARGET_EXC_BAD_INSTRUCTION; 446 #endif 447 #if defined (EXC_ARITHMETIC) && defined (_NSIG) 448 if (hostsig == _NSIG + EXC_ARITHMETIC) 449 return TARGET_EXC_ARITHMETIC; 450 #endif 451 #if defined (EXC_EMULATION) && defined (_NSIG) 452 if (hostsig == _NSIG + EXC_EMULATION) 453 return TARGET_EXC_EMULATION; 454 #endif 455 #if defined (EXC_SOFTWARE) && defined (_NSIG) 456 if (hostsig == _NSIG + EXC_SOFTWARE) 457 return TARGET_EXC_SOFTWARE; 458 #endif 459 #if defined (EXC_BREAKPOINT) && defined (_NSIG) 460 if (hostsig == _NSIG + EXC_BREAKPOINT) 461 return TARGET_EXC_BREAKPOINT; 462 #endif 463 464 #if defined (VKI_SIGINFO) 465 if (hostsig == VKI_SIGINFO) 466 return TARGET_SIGNAL_INFO; 467 #endif 468 469 #if defined (VKI_SIGRTMIN) 470 if (hostsig >= VKI_SIGRTMIN && hostsig < VKI_SIGRTMAX) { 471 /* This block of TARGET_SIGNAL_REALTIME value is in order. */ 472 if (33 <= hostsig && hostsig <= 63) 473 return (enum target_signal) 474 (hostsig - 33 + (int) TARGET_SIGNAL_REALTIME_33); 475 else if (hostsig == 32) 476 return TARGET_SIGNAL_REALTIME_32; 477 else if (64 <= hostsig && hostsig <= 127) 478 return (enum target_signal) 479 (hostsig - 64 + (int) TARGET_SIGNAL_REALTIME_64); 480 } 481 #endif 482 483 error ("Valgrind GDBSERVER bug: (target_signal_from_host):" 484 " unrecognized vki signal %d\n", hostsig); 485 return TARGET_SIGNAL_UNKNOWN; 486 } 487 488 /* Convert a OURSIG (an enum target_signal) to the form used by the 489 target operating system (referred to as the ``host'') or zero if the 490 equivalent host signal is not available. Set/clear OURSIG_OK 491 accordingly. */ 492 493 static 494 int do_target_signal_to_host (enum target_signal oursig, 495 int *oursig_ok) 496 { 497 *oursig_ok = 1; 498 switch (oursig) { 499 case TARGET_SIGNAL_0: 500 return 0; 501 502 #if defined (VKI_SIGHUP) 503 case TARGET_SIGNAL_HUP: 504 return VKI_SIGHUP; 505 #endif 506 #if defined (VKI_SIGINT) 507 case TARGET_SIGNAL_INT: 508 return VKI_SIGINT; 509 #endif 510 #if defined (VKI_SIGQUIT) 511 case TARGET_SIGNAL_QUIT: 512 return VKI_SIGQUIT; 513 #endif 514 #if defined (VKI_SIGILL) 515 case TARGET_SIGNAL_ILL: 516 return VKI_SIGILL; 517 #endif 518 #if defined (VKI_SIGTRAP) 519 case TARGET_SIGNAL_TRAP: 520 return VKI_SIGTRAP; 521 #endif 522 #if defined (VKI_SIGABRT) 523 case TARGET_SIGNAL_ABRT: 524 return VKI_SIGABRT; 525 #endif 526 #if defined (VKI_SIGEMT) 527 case TARGET_SIGNAL_EMT: 528 return VKI_SIGEMT; 529 #endif 530 #if defined (VKI_SIGFPE) 531 case TARGET_SIGNAL_FPE: 532 return VKI_SIGFPE; 533 #endif 534 #if defined (VKI_SIGKILL) 535 case TARGET_SIGNAL_KILL: 536 return VKI_SIGKILL; 537 #endif 538 #if defined (VKI_SIGBUS) 539 case TARGET_SIGNAL_BUS: 540 return VKI_SIGBUS; 541 #endif 542 #if defined (VKI_SIGSEGV) 543 case TARGET_SIGNAL_SEGV: 544 return VKI_SIGSEGV; 545 #endif 546 #if defined (VKI_SIGSYS) 547 case TARGET_SIGNAL_SYS: 548 return VKI_SIGSYS; 549 #endif 550 #if defined (VKI_SIGPIPE) 551 case TARGET_SIGNAL_PIPE: 552 return VKI_SIGPIPE; 553 #endif 554 #if defined (VKI_SIGALRM) 555 case TARGET_SIGNAL_ALRM: 556 return VKI_SIGALRM; 557 #endif 558 #if defined (VKI_SIGTERM) 559 case TARGET_SIGNAL_TERM: 560 return VKI_SIGTERM; 561 #endif 562 #if defined (VKI_SIGUSR1) 563 case TARGET_SIGNAL_USR1: 564 return VKI_SIGUSR1; 565 #endif 566 #if defined (VKI_SIGUSR2) 567 case TARGET_SIGNAL_USR2: 568 return VKI_SIGUSR2; 569 #endif 570 #if defined (VKI_SIGCHLD) || defined (VKI_SIGCLD) 571 case TARGET_SIGNAL_CHLD: 572 #if defined (VKI_SIGCHLD) 573 return VKI_SIGCHLD; 574 #else 575 return VKI_SIGCLD; 576 #endif 577 #endif /* SIGCLD or SIGCHLD */ 578 #if defined (VKI_SIGPWR) 579 case TARGET_SIGNAL_PWR: 580 return VKI_SIGPWR; 581 #endif 582 #if defined (VKI_SIGWINCH) 583 case TARGET_SIGNAL_WINCH: 584 return VKI_SIGWINCH; 585 #endif 586 #if defined (VKI_SIGURG) 587 case TARGET_SIGNAL_URG: 588 return VKI_SIGURG; 589 #endif 590 #if defined (VKI_SIGIO) 591 case TARGET_SIGNAL_IO: 592 return VKI_SIGIO; 593 #endif 594 #if defined (VKI_SIGPOLL) 595 case TARGET_SIGNAL_POLL: 596 return VKI_SIGPOLL; 597 #endif 598 #if defined (VKI_SIGSTOP) 599 case TARGET_SIGNAL_STOP: 600 return VKI_SIGSTOP; 601 #endif 602 #if defined (VKI_SIGTSTP) 603 case TARGET_SIGNAL_TSTP: 604 return VKI_SIGTSTP; 605 #endif 606 #if defined (VKI_SIGCONT) 607 case TARGET_SIGNAL_CONT: 608 return VKI_SIGCONT; 609 #endif 610 #if defined (VKI_SIGTTIN) 611 case TARGET_SIGNAL_TTIN: 612 return VKI_SIGTTIN; 613 #endif 614 #if defined (VKI_SIGTTOU) 615 case TARGET_SIGNAL_TTOU: 616 return VKI_SIGTTOU; 617 #endif 618 #if defined (VKI_SIGVTALRM) 619 case TARGET_SIGNAL_VTALRM: 620 return VKI_SIGVTALRM; 621 #endif 622 #if defined (VKI_SIGPROF) 623 case TARGET_SIGNAL_PROF: 624 return VKI_SIGPROF; 625 #endif 626 #if defined (VKI_SIGXCPU) 627 case TARGET_SIGNAL_XCPU: 628 return VKI_SIGXCPU; 629 #endif 630 #if defined (VKI_SIGXFSZ) 631 case TARGET_SIGNAL_XFSZ: 632 return VKI_SIGXFSZ; 633 #endif 634 #if defined (VKI_SIGWIND) 635 case TARGET_SIGNAL_WIND: 636 return VKI_SIGWIND; 637 #endif 638 #if defined (VKI_SIGPHONE) 639 case TARGET_SIGNAL_PHONE: 640 return VKI_SIGPHONE; 641 #endif 642 #if defined (VKI_SIGLOST) 643 case TARGET_SIGNAL_LOST: 644 return VKI_SIGLOST; 645 #endif 646 #if defined (VKI_SIGWAITING) 647 case TARGET_SIGNAL_WAITING: 648 return VKI_SIGWAITING; 649 #endif 650 #if defined (VKI_SIGCANCEL) 651 case TARGET_SIGNAL_CANCEL: 652 return VKI_SIGCANCEL; 653 #endif 654 #if defined (VKI_SIGLWP) 655 case TARGET_SIGNAL_LWP: 656 return VKI_SIGLWP; 657 #endif 658 #if defined (VKI_SIGDANGER) 659 case TARGET_SIGNAL_DANGER: 660 return VKI_SIGDANGER; 661 #endif 662 #if defined (VKI_SIGGRANT) 663 case TARGET_SIGNAL_GRANT: 664 return VKI_SIGGRANT; 665 #endif 666 #if defined (VKI_SIGRETRACT) 667 case TARGET_SIGNAL_RETRACT: 668 return VKI_SIGRETRACT; 669 #endif 670 #if defined (VKI_SIGMSG) 671 case TARGET_SIGNAL_MSG: 672 return VKI_SIGMSG; 673 #endif 674 #if defined (VKI_SIGSOUND) 675 case TARGET_SIGNAL_SOUND: 676 return VKI_SIGSOUND; 677 #endif 678 #if defined (VKI_SIGSAK) 679 case TARGET_SIGNAL_SAK: 680 return VKI_SIGSAK; 681 #endif 682 #if defined (VKI_SIGPRIO) 683 case TARGET_SIGNAL_PRIO: 684 return VKI_SIGPRIO; 685 #endif 686 687 /* Mach exceptions. Assumes that the values for EXC_ are positive! */ 688 #if defined (EXC_BAD_ACCESS) && defined (_NSIG) 689 case TARGET_EXC_BAD_ACCESS: 690 return _NSIG + EXC_BAD_ACCESS; 691 #endif 692 #if defined (EXC_BAD_INSTRUCTION) && defined (_NSIG) 693 case TARGET_EXC_BAD_INSTRUCTION: 694 return _NSIG + EXC_BAD_INSTRUCTION; 695 #endif 696 #if defined (EXC_ARITHMETIC) && defined (_NSIG) 697 case TARGET_EXC_ARITHMETIC: 698 return _NSIG + EXC_ARITHMETIC; 699 #endif 700 #if defined (EXC_EMULATION) && defined (_NSIG) 701 case TARGET_EXC_EMULATION: 702 return _NSIG + EXC_EMULATION; 703 #endif 704 #if defined (EXC_SOFTWARE) && defined (_NSIG) 705 case TARGET_EXC_SOFTWARE: 706 return _NSIG + EXC_SOFTWARE; 707 #endif 708 #if defined (EXC_BREAKPOINT) && defined (_NSIG) 709 case TARGET_EXC_BREAKPOINT: 710 return _NSIG + EXC_BREAKPOINT; 711 #endif 712 713 #if defined (VKI_SIGINFO) 714 case TARGET_SIGNAL_INFO: 715 return VKI_SIGINFO; 716 #endif 717 718 default: 719 #if defined (VKI_SIGRTMIN) 720 { 721 int retsig = 0; 722 723 if (oursig >= TARGET_SIGNAL_REALTIME_33 724 && oursig <= TARGET_SIGNAL_REALTIME_63) { 725 /* This block of signals is continuous, and 726 TARGET_SIGNAL_REALTIME_33 is 33 by definition. */ 727 retsig = (int) oursig - (int) TARGET_SIGNAL_REALTIME_33 + 33; 728 } else if (oursig == TARGET_SIGNAL_REALTIME_32) { 729 /* TARGET_SIGNAL_REALTIME_32 isn't contiguous with 730 TARGET_SIGNAL_REALTIME_33. It is 32 by definition. */ 731 retsig = 32; 732 } else if (oursig >= TARGET_SIGNAL_REALTIME_64 733 && oursig <= TARGET_SIGNAL_REALTIME_127) { 734 /* This block of signals is continuous, and 735 TARGET_SIGNAL_REALTIME_64 is 64 by definition. */ 736 retsig = (int) oursig - (int) TARGET_SIGNAL_REALTIME_64 + 64; 737 } 738 739 if (retsig >= VKI_SIGRTMIN && retsig < VKI_SIGRTMAX) 740 return retsig; 741 } 742 #endif 743 error ("Valgrind GDBSERVER bug: (do_target_signal_to_host):" 744 " unrecognized target signal %u\n", oursig); 745 *oursig_ok = 0; 746 return 0; 747 } 748 } 749 750 int target_signal_to_host_p (enum target_signal oursig) 751 { 752 int oursig_ok; 753 do_target_signal_to_host (oursig, &oursig_ok); 754 return oursig_ok; 755 } 756 757 int target_signal_to_host (enum target_signal oursig) 758 { 759 int oursig_ok; 760 int targ_signo = do_target_signal_to_host (oursig, &oursig_ok); 761 if (!oursig_ok) { 762 /* The user might be trying to do "signal SIGSAK" where this system 763 doesn't have SIGSAK. */ 764 warning ("Signal %s does not exist on this system.\n", 765 target_signal_to_name (oursig)); 766 return 0; 767 } else { 768 return targ_signo; 769 } 770 } 771 772 /* In some circumstances we allow a command to specify a numeric 773 signal. The idea is to keep these circumstances limited so that 774 users (and scripts) develop portable habits. For comparison, 775 POSIX.2 `kill' requires that 1,2,3,6,9,14, and 15 work (and using a 776 numeric signal at all is obsolescent. We are slightly more 777 lenient and allow 1-15 which should match host signal numbers on 778 most systems. Use of symbolic signal names is strongly encouraged. */ 779 780 enum target_signal target_signal_from_command (int num) 781 { 782 if (num >= 1 && num <= 15) 783 return (enum target_signal) num; 784 error ("Only signals 1-15 are valid as numeric signals.\n\ 785 Use \"info signals\" for a list of symbolic signals.\n"); 786 } 787
