1/* Target signal translation functions for GDB. 2 Copyright (C) 1990-2020 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 28struct 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 47static 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 58const char * 59gdb_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. */ 67const char * 68gdb_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. */ 77const char * 78gdb_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. */ 90enum gdb_signal 91gdb_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. */ 115enum gdb_signal 116gdb_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 365static int 366do_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 630int 631gdb_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 638int 639gdb_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