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