1 /* Target signal translation functions for GDB. 2 Copyright (C) 1990-2023 Free Software Foundation, Inc. 3 Contributed by Cygnus Support. 4 5 This file is part of GDB. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 19 20 #include "common-defs.h" 21 22 #ifdef HAVE_SIGNAL_H 23 #include <signal.h> 24 #endif 25 26 #include "gdb_signals.h" 27 28 struct gdbarch; 29 30 /* Always use __SIGRTMIN if it's available. SIGRTMIN is the lowest 31 _available_ realtime signal, not the lowest supported; glibc takes 32 several for its own use. */ 33 34 #ifndef REALTIME_LO 35 # if defined(__SIGRTMIN) 36 # define REALTIME_LO __SIGRTMIN 37 # define REALTIME_HI (__SIGRTMAX + 1) 38 # elif defined(SIGRTMIN) 39 # define REALTIME_LO SIGRTMIN 40 # define REALTIME_HI (SIGRTMAX + 1) 41 # endif 42 #endif 43 44 /* This table must match in order and size the signals in enum 45 gdb_signal. */ 46 47 static const struct { 48 const char *symbol; 49 const char *name; 50 const char *string; 51 } signals [] = 52 { 53 #define SET(symbol, constant, name, string) { #symbol, name, string }, 54 #include "gdb/signals.def" 55 #undef SET 56 }; 57 58 const char * 59 gdb_signal_to_symbol_string (enum gdb_signal sig) 60 { 61 gdb_assert ((int) sig >= GDB_SIGNAL_FIRST && (int) sig <= GDB_SIGNAL_LAST); 62 63 return signals[sig].symbol; 64 } 65 66 /* Return the string for a signal. */ 67 const char * 68 gdb_signal_to_string (enum gdb_signal sig) 69 { 70 if ((int) sig >= GDB_SIGNAL_FIRST && (int) sig <= GDB_SIGNAL_LAST) 71 return signals[sig].string; 72 else 73 return signals[GDB_SIGNAL_UNKNOWN].string; 74 } 75 76 /* Return the name for a signal. */ 77 const char * 78 gdb_signal_to_name (enum gdb_signal sig) 79 { 80 if ((int) sig >= GDB_SIGNAL_FIRST && (int) sig <= GDB_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 gdb_signal 91 gdb_signal_from_name (const char *name) 92 { 93 enum gdb_signal sig; 94 95 /* It's possible we also should allow "SIGCLD" as well as "SIGCHLD" 96 for GDB_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 = GDB_SIGNAL_HUP; 102 sig < GDB_SIGNAL_LAST; 103 sig = (enum gdb_signal) ((int) sig + 1)) 104 if (signals[sig].name != NULL 105 && strcmp (name, signals[sig].name) == 0) 106 return sig; 107 return GDB_SIGNAL_UNKNOWN; 108 } 109 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 gdb_signal 116 gdb_signal_from_host (int hostsig) 117 { 118 /* A switch statement would make sense but would require special 119 kludges to deal with the cases where more than one signal has the 120 same number. Signals are ordered ANSI-standard signals first, 121 other signals second, with signals in each block ordered by their 122 numerical values on a typical POSIX platform. */ 123 124 if (hostsig == 0) 125 return GDB_SIGNAL_0; 126 127 /* SIGINT, SIGILL, SIGABRT, SIGFPE, SIGSEGV and SIGTERM 128 are ANSI-standard signals and are always available. */ 129 if (hostsig == SIGINT) 130 return GDB_SIGNAL_INT; 131 if (hostsig == SIGILL) 132 return GDB_SIGNAL_ILL; 133 if (hostsig == SIGABRT) 134 return GDB_SIGNAL_ABRT; 135 if (hostsig == SIGFPE) 136 return GDB_SIGNAL_FPE; 137 if (hostsig == SIGSEGV) 138 return GDB_SIGNAL_SEGV; 139 if (hostsig == SIGTERM) 140 return GDB_SIGNAL_TERM; 141 142 /* All other signals need preprocessor conditionals. */ 143 #if defined (SIGHUP) 144 if (hostsig == SIGHUP) 145 return GDB_SIGNAL_HUP; 146 #endif 147 #if defined (SIGQUIT) 148 if (hostsig == SIGQUIT) 149 return GDB_SIGNAL_QUIT; 150 #endif 151 #if defined (SIGTRAP) 152 if (hostsig == SIGTRAP) 153 return GDB_SIGNAL_TRAP; 154 #endif 155 #if defined (SIGEMT) 156 if (hostsig == SIGEMT) 157 return GDB_SIGNAL_EMT; 158 #endif 159 #if defined (SIGKILL) 160 if (hostsig == SIGKILL) 161 return GDB_SIGNAL_KILL; 162 #endif 163 #if defined (SIGBUS) 164 if (hostsig == SIGBUS) 165 return GDB_SIGNAL_BUS; 166 #endif 167 #if defined (SIGSYS) 168 if (hostsig == SIGSYS) 169 return GDB_SIGNAL_SYS; 170 #endif 171 #if defined (SIGPIPE) 172 if (hostsig == SIGPIPE) 173 return GDB_SIGNAL_PIPE; 174 #endif 175 #if defined (SIGALRM) 176 if (hostsig == SIGALRM) 177 return GDB_SIGNAL_ALRM; 178 #endif 179 #if defined (SIGUSR1) 180 if (hostsig == SIGUSR1) 181 return GDB_SIGNAL_USR1; 182 #endif 183 #if defined (SIGUSR2) 184 if (hostsig == SIGUSR2) 185 return GDB_SIGNAL_USR2; 186 #endif 187 #if defined (SIGCLD) 188 if (hostsig == SIGCLD) 189 return GDB_SIGNAL_CHLD; 190 #endif 191 #if defined (SIGCHLD) 192 if (hostsig == SIGCHLD) 193 return GDB_SIGNAL_CHLD; 194 #endif 195 #if defined (SIGPWR) 196 if (hostsig == SIGPWR) 197 return GDB_SIGNAL_PWR; 198 #endif 199 #if defined (SIGWINCH) 200 if (hostsig == SIGWINCH) 201 return GDB_SIGNAL_WINCH; 202 #endif 203 #if defined (SIGURG) 204 if (hostsig == SIGURG) 205 return GDB_SIGNAL_URG; 206 #endif 207 #if defined (SIGIO) 208 if (hostsig == SIGIO) 209 return GDB_SIGNAL_IO; 210 #endif 211 #if defined (SIGPOLL) 212 if (hostsig == SIGPOLL) 213 return GDB_SIGNAL_POLL; 214 #endif 215 #if defined (SIGSTOP) 216 if (hostsig == SIGSTOP) 217 return GDB_SIGNAL_STOP; 218 #endif 219 #if defined (SIGTSTP) 220 if (hostsig == SIGTSTP) 221 return GDB_SIGNAL_TSTP; 222 #endif 223 #if defined (SIGCONT) 224 if (hostsig == SIGCONT) 225 return GDB_SIGNAL_CONT; 226 #endif 227 #if defined (SIGTTIN) 228 if (hostsig == SIGTTIN) 229 return GDB_SIGNAL_TTIN; 230 #endif 231 #if defined (SIGTTOU) 232 if (hostsig == SIGTTOU) 233 return GDB_SIGNAL_TTOU; 234 #endif 235 #if defined (SIGVTALRM) 236 if (hostsig == SIGVTALRM) 237 return GDB_SIGNAL_VTALRM; 238 #endif 239 #if defined (SIGPROF) 240 if (hostsig == SIGPROF) 241 return GDB_SIGNAL_PROF; 242 #endif 243 #if defined (SIGXCPU) 244 if (hostsig == SIGXCPU) 245 return GDB_SIGNAL_XCPU; 246 #endif 247 #if defined (SIGXFSZ) 248 if (hostsig == SIGXFSZ) 249 return GDB_SIGNAL_XFSZ; 250 #endif 251 #if defined (SIGWIND) 252 if (hostsig == SIGWIND) 253 return GDB_SIGNAL_WIND; 254 #endif 255 #if defined (SIGPHONE) 256 if (hostsig == SIGPHONE) 257 return GDB_SIGNAL_PHONE; 258 #endif 259 #if defined (SIGLOST) 260 if (hostsig == SIGLOST) 261 return GDB_SIGNAL_LOST; 262 #endif 263 #if defined (SIGWAITING) 264 if (hostsig == SIGWAITING) 265 return GDB_SIGNAL_WAITING; 266 #endif 267 #if defined (SIGCANCEL) 268 if (hostsig == SIGCANCEL) 269 return GDB_SIGNAL_CANCEL; 270 #endif 271 #if defined (SIGLWP) 272 if (hostsig == SIGLWP) 273 return GDB_SIGNAL_LWP; 274 #endif 275 #if defined (SIGDANGER) 276 if (hostsig == SIGDANGER) 277 return GDB_SIGNAL_DANGER; 278 #endif 279 #if defined (SIGGRANT) 280 if (hostsig == SIGGRANT) 281 return GDB_SIGNAL_GRANT; 282 #endif 283 #if defined (SIGRETRACT) 284 if (hostsig == SIGRETRACT) 285 return GDB_SIGNAL_RETRACT; 286 #endif 287 #if defined (SIGMSG) 288 if (hostsig == SIGMSG) 289 return GDB_SIGNAL_MSG; 290 #endif 291 #if defined (SIGSOUND) 292 if (hostsig == SIGSOUND) 293 return GDB_SIGNAL_SOUND; 294 #endif 295 #if defined (SIGSAK) 296 if (hostsig == SIGSAK) 297 return GDB_SIGNAL_SAK; 298 #endif 299 #if defined (SIGPRIO) 300 if (hostsig == SIGPRIO) 301 return GDB_SIGNAL_PRIO; 302 #endif 303 304 /* Mach exceptions. Assumes that the values for EXC_ are positive! */ 305 #if defined (EXC_BAD_ACCESS) && defined (_NSIG) 306 if (hostsig == _NSIG + EXC_BAD_ACCESS) 307 return GDB_EXC_BAD_ACCESS; 308 #endif 309 #if defined (EXC_BAD_INSTRUCTION) && defined (_NSIG) 310 if (hostsig == _NSIG + EXC_BAD_INSTRUCTION) 311 return GDB_EXC_BAD_INSTRUCTION; 312 #endif 313 #if defined (EXC_ARITHMETIC) && defined (_NSIG) 314 if (hostsig == _NSIG + EXC_ARITHMETIC) 315 return GDB_EXC_ARITHMETIC; 316 #endif 317 #if defined (EXC_EMULATION) && defined (_NSIG) 318 if (hostsig == _NSIG + EXC_EMULATION) 319 return GDB_EXC_EMULATION; 320 #endif 321 #if defined (EXC_SOFTWARE) && defined (_NSIG) 322 if (hostsig == _NSIG + EXC_SOFTWARE) 323 return GDB_EXC_SOFTWARE; 324 #endif 325 #if defined (EXC_BREAKPOINT) && defined (_NSIG) 326 if (hostsig == _NSIG + EXC_BREAKPOINT) 327 return GDB_EXC_BREAKPOINT; 328 #endif 329 330 #if defined (SIGINFO) 331 if (hostsig == SIGINFO) 332 return GDB_SIGNAL_INFO; 333 #endif 334 #if defined (SIGLIBRT) 335 if (hostsig == SIGLIBRT) 336 return GDB_SIGNAL_LIBRT; 337 #endif 338 339 #if defined (REALTIME_LO) 340 if (hostsig >= REALTIME_LO && hostsig < REALTIME_HI) 341 { 342 /* This block of GDB_SIGNAL_REALTIME value is in order. */ 343 if (33 <= hostsig && hostsig <= 63) 344 return (enum gdb_signal) 345 (hostsig - 33 + (int) GDB_SIGNAL_REALTIME_33); 346 else if (hostsig == 32) 347 return GDB_SIGNAL_REALTIME_32; 348 else if (64 <= hostsig && hostsig <= 127) 349 return (enum gdb_signal) 350 (hostsig - 64 + (int) GDB_SIGNAL_REALTIME_64); 351 else 352 error (_("GDB bug: target.c (gdb_signal_from_host): " 353 "unrecognized real-time signal")); 354 } 355 #endif 356 357 return GDB_SIGNAL_UNKNOWN; 358 } 359 360 /* Convert a OURSIG (an enum gdb_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_gdb_signal_to_host (enum gdb_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 /* Signals are ordered ANSI-standard signals first, other signals 375 second, with signals in each block ordered by their numerical 376 values on a typical POSIX platform. */ 377 378 *oursig_ok = 1; 379 switch (oursig) 380 { 381 case GDB_SIGNAL_0: 382 return 0; 383 384 /* SIGINT, SIGILL, SIGABRT, SIGFPE, SIGSEGV and SIGTERM 385 are ANSI-standard signals and are always available. */ 386 case GDB_SIGNAL_INT: 387 return SIGINT; 388 case GDB_SIGNAL_ILL: 389 return SIGILL; 390 case GDB_SIGNAL_ABRT: 391 return SIGABRT; 392 case GDB_SIGNAL_FPE: 393 return SIGFPE; 394 case GDB_SIGNAL_SEGV: 395 return SIGSEGV; 396 case GDB_SIGNAL_TERM: 397 return SIGTERM; 398 399 /* All other signals need preprocessor conditionals. */ 400 #if defined (SIGHUP) 401 case GDB_SIGNAL_HUP: 402 return SIGHUP; 403 #endif 404 #if defined (SIGQUIT) 405 case GDB_SIGNAL_QUIT: 406 return SIGQUIT; 407 #endif 408 #if defined (SIGTRAP) 409 case GDB_SIGNAL_TRAP: 410 return SIGTRAP; 411 #endif 412 #if defined (SIGEMT) 413 case GDB_SIGNAL_EMT: 414 return SIGEMT; 415 #endif 416 #if defined (SIGKILL) 417 case GDB_SIGNAL_KILL: 418 return SIGKILL; 419 #endif 420 #if defined (SIGBUS) 421 case GDB_SIGNAL_BUS: 422 return SIGBUS; 423 #endif 424 #if defined (SIGSYS) 425 case GDB_SIGNAL_SYS: 426 return SIGSYS; 427 #endif 428 #if defined (SIGPIPE) 429 case GDB_SIGNAL_PIPE: 430 return SIGPIPE; 431 #endif 432 #if defined (SIGALRM) 433 case GDB_SIGNAL_ALRM: 434 return SIGALRM; 435 #endif 436 #if defined (SIGUSR1) 437 case GDB_SIGNAL_USR1: 438 return SIGUSR1; 439 #endif 440 #if defined (SIGUSR2) 441 case GDB_SIGNAL_USR2: 442 return SIGUSR2; 443 #endif 444 #if defined (SIGCHLD) || defined (SIGCLD) 445 case GDB_SIGNAL_CHLD: 446 #if defined (SIGCHLD) 447 return SIGCHLD; 448 #else 449 return SIGCLD; 450 #endif 451 #endif /* SIGCLD or SIGCHLD */ 452 #if defined (SIGPWR) 453 case GDB_SIGNAL_PWR: 454 return SIGPWR; 455 #endif 456 #if defined (SIGWINCH) 457 case GDB_SIGNAL_WINCH: 458 return SIGWINCH; 459 #endif 460 #if defined (SIGURG) 461 case GDB_SIGNAL_URG: 462 return SIGURG; 463 #endif 464 #if defined (SIGIO) 465 case GDB_SIGNAL_IO: 466 return SIGIO; 467 #endif 468 #if defined (SIGPOLL) 469 case GDB_SIGNAL_POLL: 470 return SIGPOLL; 471 #endif 472 #if defined (SIGSTOP) 473 case GDB_SIGNAL_STOP: 474 return SIGSTOP; 475 #endif 476 #if defined (SIGTSTP) 477 case GDB_SIGNAL_TSTP: 478 return SIGTSTP; 479 #endif 480 #if defined (SIGCONT) 481 case GDB_SIGNAL_CONT: 482 return SIGCONT; 483 #endif 484 #if defined (SIGTTIN) 485 case GDB_SIGNAL_TTIN: 486 return SIGTTIN; 487 #endif 488 #if defined (SIGTTOU) 489 case GDB_SIGNAL_TTOU: 490 return SIGTTOU; 491 #endif 492 #if defined (SIGVTALRM) 493 case GDB_SIGNAL_VTALRM: 494 return SIGVTALRM; 495 #endif 496 #if defined (SIGPROF) 497 case GDB_SIGNAL_PROF: 498 return SIGPROF; 499 #endif 500 #if defined (SIGXCPU) 501 case GDB_SIGNAL_XCPU: 502 return SIGXCPU; 503 #endif 504 #if defined (SIGXFSZ) 505 case GDB_SIGNAL_XFSZ: 506 return SIGXFSZ; 507 #endif 508 #if defined (SIGWIND) 509 case GDB_SIGNAL_WIND: 510 return SIGWIND; 511 #endif 512 #if defined (SIGPHONE) 513 case GDB_SIGNAL_PHONE: 514 return SIGPHONE; 515 #endif 516 #if defined (SIGLOST) 517 case GDB_SIGNAL_LOST: 518 return SIGLOST; 519 #endif 520 #if defined (SIGWAITING) 521 case GDB_SIGNAL_WAITING: 522 return SIGWAITING; 523 #endif 524 #if defined (SIGCANCEL) 525 case GDB_SIGNAL_CANCEL: 526 return SIGCANCEL; 527 #endif 528 #if defined (SIGLWP) 529 case GDB_SIGNAL_LWP: 530 return SIGLWP; 531 #endif 532 #if defined (SIGDANGER) 533 case GDB_SIGNAL_DANGER: 534 return SIGDANGER; 535 #endif 536 #if defined (SIGGRANT) 537 case GDB_SIGNAL_GRANT: 538 return SIGGRANT; 539 #endif 540 #if defined (SIGRETRACT) 541 case GDB_SIGNAL_RETRACT: 542 return SIGRETRACT; 543 #endif 544 #if defined (SIGMSG) 545 case GDB_SIGNAL_MSG: 546 return SIGMSG; 547 #endif 548 #if defined (SIGSOUND) 549 case GDB_SIGNAL_SOUND: 550 return SIGSOUND; 551 #endif 552 #if defined (SIGSAK) 553 case GDB_SIGNAL_SAK: 554 return SIGSAK; 555 #endif 556 #if defined (SIGPRIO) 557 case GDB_SIGNAL_PRIO: 558 return SIGPRIO; 559 #endif 560 561 /* Mach exceptions. Assumes that the values for EXC_ are positive! */ 562 #if defined (EXC_BAD_ACCESS) && defined (_NSIG) 563 case GDB_EXC_BAD_ACCESS: 564 return _NSIG + EXC_BAD_ACCESS; 565 #endif 566 #if defined (EXC_BAD_INSTRUCTION) && defined (_NSIG) 567 case GDB_EXC_BAD_INSTRUCTION: 568 return _NSIG + EXC_BAD_INSTRUCTION; 569 #endif 570 #if defined (EXC_ARITHMETIC) && defined (_NSIG) 571 case GDB_EXC_ARITHMETIC: 572 return _NSIG + EXC_ARITHMETIC; 573 #endif 574 #if defined (EXC_EMULATION) && defined (_NSIG) 575 case GDB_EXC_EMULATION: 576 return _NSIG + EXC_EMULATION; 577 #endif 578 #if defined (EXC_SOFTWARE) && defined (_NSIG) 579 case GDB_EXC_SOFTWARE: 580 return _NSIG + EXC_SOFTWARE; 581 #endif 582 #if defined (EXC_BREAKPOINT) && defined (_NSIG) 583 case GDB_EXC_BREAKPOINT: 584 return _NSIG + EXC_BREAKPOINT; 585 #endif 586 587 #if defined (SIGINFO) 588 case GDB_SIGNAL_INFO: 589 return SIGINFO; 590 #endif 591 #if defined (SIGLIBRT) 592 case GDB_SIGNAL_LIBRT: 593 return SIGLIBRT; 594 #endif 595 596 default: 597 #if defined (REALTIME_LO) 598 retsig = 0; 599 600 if (oursig >= GDB_SIGNAL_REALTIME_33 601 && oursig <= GDB_SIGNAL_REALTIME_63) 602 { 603 /* This block of signals is continuous, and 604 GDB_SIGNAL_REALTIME_33 is 33 by definition. */ 605 retsig = (int) oursig - (int) GDB_SIGNAL_REALTIME_33 + 33; 606 } 607 else if (oursig == GDB_SIGNAL_REALTIME_32) 608 { 609 /* GDB_SIGNAL_REALTIME_32 isn't contiguous with 610 GDB_SIGNAL_REALTIME_33. It is 32 by definition. */ 611 retsig = 32; 612 } 613 else if (oursig >= GDB_SIGNAL_REALTIME_64 614 && oursig <= GDB_SIGNAL_REALTIME_127) 615 { 616 /* This block of signals is continuous, and 617 GDB_SIGNAL_REALTIME_64 is 64 by definition. */ 618 retsig = (int) oursig - (int) GDB_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 gdb_signal_to_host_p (enum gdb_signal oursig) 632 { 633 int oursig_ok; 634 do_gdb_signal_to_host (oursig, &oursig_ok); 635 return oursig_ok; 636 } 637 638 int 639 gdb_signal_to_host (enum gdb_signal oursig) 640 { 641 int oursig_ok; 642 int targ_signo = do_gdb_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 gdb_signal_to_name (oursig)); 649 return 0; 650 } 651 else 652 return targ_signo; 653 } 654