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