1 /* Target signal translation functions for GDB. 2 Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 3 2000, 2001, 2002, 2003, 2006, 2007, 2008, 2009, 2010, 2011 4 Free Software Foundation, Inc. 5 Contributed by Cygnus Support. 6 7 This file is part of GDB. 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 3 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, see <http://www.gnu.org/licenses/>. */ 21 22 #ifdef GDBSERVER 23 #include "server.h" 24 #else 25 #include "defs.h" 26 #include "gdb_string.h" 27 #endif 28 29 #ifdef HAVE_SIGNAL_H 30 #include <signal.h> 31 #endif 32 33 #include "gdb_signals.h" 34 35 struct gdbarch; 36 37 /* Always use __SIGRTMIN if it's available. SIGRTMIN is the lowest 38 _available_ realtime signal, not the lowest supported; glibc takes 39 several for its own use. */ 40 41 #ifndef REALTIME_LO 42 # if defined(__SIGRTMIN) 43 # define REALTIME_LO __SIGRTMIN 44 # define REALTIME_HI (__SIGRTMAX + 1) 45 # elif defined(SIGRTMIN) 46 # define REALTIME_LO SIGRTMIN 47 # define REALTIME_HI (SIGRTMAX + 1) 48 # endif 49 #endif 50 51 /* This table must match in order and size the signals in enum 52 target_signal. */ 53 54 static const struct { 55 const char *name; 56 const char *string; 57 } signals [] = 58 { 59 #define SET(symbol, constant, name, string) { name, string }, 60 #include "gdb/signals.def" 61 #undef SET 62 }; 63 64 65 /* Return the string for a signal. */ 66 const char * 67 target_signal_to_string (enum target_signal sig) 68 { 69 if ((int) sig >= TARGET_SIGNAL_FIRST && (int) sig <= TARGET_SIGNAL_LAST) 70 return signals[sig].string; 71 else 72 return signals[TARGET_SIGNAL_UNKNOWN].string; 73 } 74 75 /* Return the name for a signal. */ 76 const char * 77 target_signal_to_name (enum target_signal sig) 78 { 79 if ((int) sig >= TARGET_SIGNAL_FIRST && (int) sig <= TARGET_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 target_signal 90 target_signal_from_name (const char *name) 91 { 92 enum target_signal sig; 93 94 /* It's possible we also should allow "SIGCLD" as well as "SIGCHLD" 95 for TARGET_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 = TARGET_SIGNAL_HUP; 101 sig < TARGET_SIGNAL_LAST; 102 sig = (enum target_signal) ((int) sig + 1)) 103 if (signals[sig].name != NULL 104 && strcmp (name, signals[sig].name) == 0) 105 return sig; 106 return TARGET_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 target_signal 115 target_signal_from_host (int hostsig) 116 { 117 /* A switch statement would make sense but would require special kludges 118 to deal with the cases where more than one signal has the same number. */ 119 120 if (hostsig == 0) 121 return TARGET_SIGNAL_0; 122 123 #if defined (SIGHUP) 124 if (hostsig == SIGHUP) 125 return TARGET_SIGNAL_HUP; 126 #endif 127 #if defined (SIGINT) 128 if (hostsig == SIGINT) 129 return TARGET_SIGNAL_INT; 130 #endif 131 #if defined (SIGQUIT) 132 if (hostsig == SIGQUIT) 133 return TARGET_SIGNAL_QUIT; 134 #endif 135 #if defined (SIGILL) 136 if (hostsig == SIGILL) 137 return TARGET_SIGNAL_ILL; 138 #endif 139 #if defined (SIGTRAP) 140 if (hostsig == SIGTRAP) 141 return TARGET_SIGNAL_TRAP; 142 #endif 143 #if defined (SIGABRT) 144 if (hostsig == SIGABRT) 145 return TARGET_SIGNAL_ABRT; 146 #endif 147 #if defined (SIGEMT) 148 if (hostsig == SIGEMT) 149 return TARGET_SIGNAL_EMT; 150 #endif 151 #if defined (SIGFPE) 152 if (hostsig == SIGFPE) 153 return TARGET_SIGNAL_FPE; 154 #endif 155 #if defined (SIGKILL) 156 if (hostsig == SIGKILL) 157 return TARGET_SIGNAL_KILL; 158 #endif 159 #if defined (SIGBUS) 160 if (hostsig == SIGBUS) 161 return TARGET_SIGNAL_BUS; 162 #endif 163 #if defined (SIGSEGV) 164 if (hostsig == SIGSEGV) 165 return TARGET_SIGNAL_SEGV; 166 #endif 167 #if defined (SIGSYS) 168 if (hostsig == SIGSYS) 169 return TARGET_SIGNAL_SYS; 170 #endif 171 #if defined (SIGPIPE) 172 if (hostsig == SIGPIPE) 173 return TARGET_SIGNAL_PIPE; 174 #endif 175 #if defined (SIGALRM) 176 if (hostsig == SIGALRM) 177 return TARGET_SIGNAL_ALRM; 178 #endif 179 #if defined (SIGTERM) 180 if (hostsig == SIGTERM) 181 return TARGET_SIGNAL_TERM; 182 #endif 183 #if defined (SIGUSR1) 184 if (hostsig == SIGUSR1) 185 return TARGET_SIGNAL_USR1; 186 #endif 187 #if defined (SIGUSR2) 188 if (hostsig == SIGUSR2) 189 return TARGET_SIGNAL_USR2; 190 #endif 191 #if defined (SIGCLD) 192 if (hostsig == SIGCLD) 193 return TARGET_SIGNAL_CHLD; 194 #endif 195 #if defined (SIGCHLD) 196 if (hostsig == SIGCHLD) 197 return TARGET_SIGNAL_CHLD; 198 #endif 199 #if defined (SIGPWR) 200 if (hostsig == SIGPWR) 201 return TARGET_SIGNAL_PWR; 202 #endif 203 #if defined (SIGWINCH) 204 if (hostsig == SIGWINCH) 205 return TARGET_SIGNAL_WINCH; 206 #endif 207 #if defined (SIGURG) 208 if (hostsig == SIGURG) 209 return TARGET_SIGNAL_URG; 210 #endif 211 #if defined (SIGIO) 212 if (hostsig == SIGIO) 213 return TARGET_SIGNAL_IO; 214 #endif 215 #if defined (SIGPOLL) 216 if (hostsig == SIGPOLL) 217 return TARGET_SIGNAL_POLL; 218 #endif 219 #if defined (SIGSTOP) 220 if (hostsig == SIGSTOP) 221 return TARGET_SIGNAL_STOP; 222 #endif 223 #if defined (SIGTSTP) 224 if (hostsig == SIGTSTP) 225 return TARGET_SIGNAL_TSTP; 226 #endif 227 #if defined (SIGCONT) 228 if (hostsig == SIGCONT) 229 return TARGET_SIGNAL_CONT; 230 #endif 231 #if defined (SIGTTIN) 232 if (hostsig == SIGTTIN) 233 return TARGET_SIGNAL_TTIN; 234 #endif 235 #if defined (SIGTTOU) 236 if (hostsig == SIGTTOU) 237 return TARGET_SIGNAL_TTOU; 238 #endif 239 #if defined (SIGVTALRM) 240 if (hostsig == SIGVTALRM) 241 return TARGET_SIGNAL_VTALRM; 242 #endif 243 #if defined (SIGPROF) 244 if (hostsig == SIGPROF) 245 return TARGET_SIGNAL_PROF; 246 #endif 247 #if defined (SIGXCPU) 248 if (hostsig == SIGXCPU) 249 return TARGET_SIGNAL_XCPU; 250 #endif 251 #if defined (SIGXFSZ) 252 if (hostsig == SIGXFSZ) 253 return TARGET_SIGNAL_XFSZ; 254 #endif 255 #if defined (SIGWIND) 256 if (hostsig == SIGWIND) 257 return TARGET_SIGNAL_WIND; 258 #endif 259 #if defined (SIGPHONE) 260 if (hostsig == SIGPHONE) 261 return TARGET_SIGNAL_PHONE; 262 #endif 263 #if defined (SIGLOST) 264 if (hostsig == SIGLOST) 265 return TARGET_SIGNAL_LOST; 266 #endif 267 #if defined (SIGWAITING) 268 if (hostsig == SIGWAITING) 269 return TARGET_SIGNAL_WAITING; 270 #endif 271 #if defined (SIGCANCEL) 272 if (hostsig == SIGCANCEL) 273 return TARGET_SIGNAL_CANCEL; 274 #endif 275 #if defined (SIGLWP) 276 if (hostsig == SIGLWP) 277 return TARGET_SIGNAL_LWP; 278 #endif 279 #if defined (SIGDANGER) 280 if (hostsig == SIGDANGER) 281 return TARGET_SIGNAL_DANGER; 282 #endif 283 #if defined (SIGGRANT) 284 if (hostsig == SIGGRANT) 285 return TARGET_SIGNAL_GRANT; 286 #endif 287 #if defined (SIGRETRACT) 288 if (hostsig == SIGRETRACT) 289 return TARGET_SIGNAL_RETRACT; 290 #endif 291 #if defined (SIGMSG) 292 if (hostsig == SIGMSG) 293 return TARGET_SIGNAL_MSG; 294 #endif 295 #if defined (SIGSOUND) 296 if (hostsig == SIGSOUND) 297 return TARGET_SIGNAL_SOUND; 298 #endif 299 #if defined (SIGSAK) 300 if (hostsig == SIGSAK) 301 return TARGET_SIGNAL_SAK; 302 #endif 303 #if defined (SIGPRIO) 304 if (hostsig == SIGPRIO) 305 return TARGET_SIGNAL_PRIO; 306 #endif 307 308 /* Mach exceptions. Assumes that the values for EXC_ are positive! */ 309 #if defined (EXC_BAD_ACCESS) && defined (_NSIG) 310 if (hostsig == _NSIG + EXC_BAD_ACCESS) 311 return TARGET_EXC_BAD_ACCESS; 312 #endif 313 #if defined (EXC_BAD_INSTRUCTION) && defined (_NSIG) 314 if (hostsig == _NSIG + EXC_BAD_INSTRUCTION) 315 return TARGET_EXC_BAD_INSTRUCTION; 316 #endif 317 #if defined (EXC_ARITHMETIC) && defined (_NSIG) 318 if (hostsig == _NSIG + EXC_ARITHMETIC) 319 return TARGET_EXC_ARITHMETIC; 320 #endif 321 #if defined (EXC_EMULATION) && defined (_NSIG) 322 if (hostsig == _NSIG + EXC_EMULATION) 323 return TARGET_EXC_EMULATION; 324 #endif 325 #if defined (EXC_SOFTWARE) && defined (_NSIG) 326 if (hostsig == _NSIG + EXC_SOFTWARE) 327 return TARGET_EXC_SOFTWARE; 328 #endif 329 #if defined (EXC_BREAKPOINT) && defined (_NSIG) 330 if (hostsig == _NSIG + EXC_BREAKPOINT) 331 return TARGET_EXC_BREAKPOINT; 332 #endif 333 334 #if defined (SIGINFO) 335 if (hostsig == SIGINFO) 336 return TARGET_SIGNAL_INFO; 337 #endif 338 339 #if defined (REALTIME_LO) 340 if (hostsig >= REALTIME_LO && hostsig < REALTIME_HI) 341 { 342 /* This block of TARGET_SIGNAL_REALTIME value is in order. */ 343 if (33 <= hostsig && hostsig <= 63) 344 return (enum target_signal) 345 (hostsig - 33 + (int) TARGET_SIGNAL_REALTIME_33); 346 else if (hostsig == 32) 347 return TARGET_SIGNAL_REALTIME_32; 348 else if (64 <= hostsig && hostsig <= 127) 349 return (enum target_signal) 350 (hostsig - 64 + (int) TARGET_SIGNAL_REALTIME_64); 351 else 352 error (_("GDB bug: target.c (target_signal_from_host): " 353 "unrecognized real-time signal")); 354 } 355 #endif 356 357 return TARGET_SIGNAL_UNKNOWN; 358 } 359 360 /* Convert a OURSIG (an enum target_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_target_signal_to_host (enum target_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 *oursig_ok = 1; 375 switch (oursig) 376 { 377 case TARGET_SIGNAL_0: 378 return 0; 379 380 #if defined (SIGHUP) 381 case TARGET_SIGNAL_HUP: 382 return SIGHUP; 383 #endif 384 #if defined (SIGINT) 385 case TARGET_SIGNAL_INT: 386 return SIGINT; 387 #endif 388 #if defined (SIGQUIT) 389 case TARGET_SIGNAL_QUIT: 390 return SIGQUIT; 391 #endif 392 #if defined (SIGILL) 393 case TARGET_SIGNAL_ILL: 394 return SIGILL; 395 #endif 396 #if defined (SIGTRAP) 397 case TARGET_SIGNAL_TRAP: 398 return SIGTRAP; 399 #endif 400 #if defined (SIGABRT) 401 case TARGET_SIGNAL_ABRT: 402 return SIGABRT; 403 #endif 404 #if defined (SIGEMT) 405 case TARGET_SIGNAL_EMT: 406 return SIGEMT; 407 #endif 408 #if defined (SIGFPE) 409 case TARGET_SIGNAL_FPE: 410 return SIGFPE; 411 #endif 412 #if defined (SIGKILL) 413 case TARGET_SIGNAL_KILL: 414 return SIGKILL; 415 #endif 416 #if defined (SIGBUS) 417 case TARGET_SIGNAL_BUS: 418 return SIGBUS; 419 #endif 420 #if defined (SIGSEGV) 421 case TARGET_SIGNAL_SEGV: 422 return SIGSEGV; 423 #endif 424 #if defined (SIGSYS) 425 case TARGET_SIGNAL_SYS: 426 return SIGSYS; 427 #endif 428 #if defined (SIGPIPE) 429 case TARGET_SIGNAL_PIPE: 430 return SIGPIPE; 431 #endif 432 #if defined (SIGALRM) 433 case TARGET_SIGNAL_ALRM: 434 return SIGALRM; 435 #endif 436 #if defined (SIGTERM) 437 case TARGET_SIGNAL_TERM: 438 return SIGTERM; 439 #endif 440 #if defined (SIGUSR1) 441 case TARGET_SIGNAL_USR1: 442 return SIGUSR1; 443 #endif 444 #if defined (SIGUSR2) 445 case TARGET_SIGNAL_USR2: 446 return SIGUSR2; 447 #endif 448 #if defined (SIGCHLD) || defined (SIGCLD) 449 case TARGET_SIGNAL_CHLD: 450 #if defined (SIGCHLD) 451 return SIGCHLD; 452 #else 453 return SIGCLD; 454 #endif 455 #endif /* SIGCLD or SIGCHLD */ 456 #if defined (SIGPWR) 457 case TARGET_SIGNAL_PWR: 458 return SIGPWR; 459 #endif 460 #if defined (SIGWINCH) 461 case TARGET_SIGNAL_WINCH: 462 return SIGWINCH; 463 #endif 464 #if defined (SIGURG) 465 case TARGET_SIGNAL_URG: 466 return SIGURG; 467 #endif 468 #if defined (SIGIO) 469 case TARGET_SIGNAL_IO: 470 return SIGIO; 471 #endif 472 #if defined (SIGPOLL) 473 case TARGET_SIGNAL_POLL: 474 return SIGPOLL; 475 #endif 476 #if defined (SIGSTOP) 477 case TARGET_SIGNAL_STOP: 478 return SIGSTOP; 479 #endif 480 #if defined (SIGTSTP) 481 case TARGET_SIGNAL_TSTP: 482 return SIGTSTP; 483 #endif 484 #if defined (SIGCONT) 485 case TARGET_SIGNAL_CONT: 486 return SIGCONT; 487 #endif 488 #if defined (SIGTTIN) 489 case TARGET_SIGNAL_TTIN: 490 return SIGTTIN; 491 #endif 492 #if defined (SIGTTOU) 493 case TARGET_SIGNAL_TTOU: 494 return SIGTTOU; 495 #endif 496 #if defined (SIGVTALRM) 497 case TARGET_SIGNAL_VTALRM: 498 return SIGVTALRM; 499 #endif 500 #if defined (SIGPROF) 501 case TARGET_SIGNAL_PROF: 502 return SIGPROF; 503 #endif 504 #if defined (SIGXCPU) 505 case TARGET_SIGNAL_XCPU: 506 return SIGXCPU; 507 #endif 508 #if defined (SIGXFSZ) 509 case TARGET_SIGNAL_XFSZ: 510 return SIGXFSZ; 511 #endif 512 #if defined (SIGWIND) 513 case TARGET_SIGNAL_WIND: 514 return SIGWIND; 515 #endif 516 #if defined (SIGPHONE) 517 case TARGET_SIGNAL_PHONE: 518 return SIGPHONE; 519 #endif 520 #if defined (SIGLOST) 521 case TARGET_SIGNAL_LOST: 522 return SIGLOST; 523 #endif 524 #if defined (SIGWAITING) 525 case TARGET_SIGNAL_WAITING: 526 return SIGWAITING; 527 #endif 528 #if defined (SIGCANCEL) 529 case TARGET_SIGNAL_CANCEL: 530 return SIGCANCEL; 531 #endif 532 #if defined (SIGLWP) 533 case TARGET_SIGNAL_LWP: 534 return SIGLWP; 535 #endif 536 #if defined (SIGDANGER) 537 case TARGET_SIGNAL_DANGER: 538 return SIGDANGER; 539 #endif 540 #if defined (SIGGRANT) 541 case TARGET_SIGNAL_GRANT: 542 return SIGGRANT; 543 #endif 544 #if defined (SIGRETRACT) 545 case TARGET_SIGNAL_RETRACT: 546 return SIGRETRACT; 547 #endif 548 #if defined (SIGMSG) 549 case TARGET_SIGNAL_MSG: 550 return SIGMSG; 551 #endif 552 #if defined (SIGSOUND) 553 case TARGET_SIGNAL_SOUND: 554 return SIGSOUND; 555 #endif 556 #if defined (SIGSAK) 557 case TARGET_SIGNAL_SAK: 558 return SIGSAK; 559 #endif 560 #if defined (SIGPRIO) 561 case TARGET_SIGNAL_PRIO: 562 return SIGPRIO; 563 #endif 564 565 /* Mach exceptions. Assumes that the values for EXC_ are positive! */ 566 #if defined (EXC_BAD_ACCESS) && defined (_NSIG) 567 case TARGET_EXC_BAD_ACCESS: 568 return _NSIG + EXC_BAD_ACCESS; 569 #endif 570 #if defined (EXC_BAD_INSTRUCTION) && defined (_NSIG) 571 case TARGET_EXC_BAD_INSTRUCTION: 572 return _NSIG + EXC_BAD_INSTRUCTION; 573 #endif 574 #if defined (EXC_ARITHMETIC) && defined (_NSIG) 575 case TARGET_EXC_ARITHMETIC: 576 return _NSIG + EXC_ARITHMETIC; 577 #endif 578 #if defined (EXC_EMULATION) && defined (_NSIG) 579 case TARGET_EXC_EMULATION: 580 return _NSIG + EXC_EMULATION; 581 #endif 582 #if defined (EXC_SOFTWARE) && defined (_NSIG) 583 case TARGET_EXC_SOFTWARE: 584 return _NSIG + EXC_SOFTWARE; 585 #endif 586 #if defined (EXC_BREAKPOINT) && defined (_NSIG) 587 case TARGET_EXC_BREAKPOINT: 588 return _NSIG + EXC_BREAKPOINT; 589 #endif 590 591 #if defined (SIGINFO) 592 case TARGET_SIGNAL_INFO: 593 return SIGINFO; 594 #endif 595 596 default: 597 #if defined (REALTIME_LO) 598 retsig = 0; 599 600 if (oursig >= TARGET_SIGNAL_REALTIME_33 601 && oursig <= TARGET_SIGNAL_REALTIME_63) 602 { 603 /* This block of signals is continuous, and 604 TARGET_SIGNAL_REALTIME_33 is 33 by definition. */ 605 retsig = (int) oursig - (int) TARGET_SIGNAL_REALTIME_33 + 33; 606 } 607 else if (oursig == TARGET_SIGNAL_REALTIME_32) 608 { 609 /* TARGET_SIGNAL_REALTIME_32 isn't contiguous with 610 TARGET_SIGNAL_REALTIME_33. It is 32 by definition. */ 611 retsig = 32; 612 } 613 else if (oursig >= TARGET_SIGNAL_REALTIME_64 614 && oursig <= TARGET_SIGNAL_REALTIME_127) 615 { 616 /* This block of signals is continuous, and 617 TARGET_SIGNAL_REALTIME_64 is 64 by definition. */ 618 retsig = (int) oursig - (int) TARGET_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 target_signal_to_host_p (enum target_signal oursig) 632 { 633 int oursig_ok; 634 do_target_signal_to_host (oursig, &oursig_ok); 635 return oursig_ok; 636 } 637 638 int 639 target_signal_to_host (enum target_signal oursig) 640 { 641 int oursig_ok; 642 int targ_signo = do_target_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 target_signal_to_name (oursig)); 649 return 0; 650 } 651 else 652 return targ_signo; 653 } 654 655 #ifndef GDBSERVER 656 657 /* In some circumstances we allow a command to specify a numeric 658 signal. The idea is to keep these circumstances limited so that 659 users (and scripts) develop portable habits. For comparison, 660 POSIX.2 `kill' requires that 1,2,3,6,9,14, and 15 work (and using a 661 numeric signal at all is obsolescent. We are slightly more 662 lenient and allow 1-15 which should match host signal numbers on 663 most systems. Use of symbolic signal names is strongly encouraged. */ 664 665 enum target_signal 666 target_signal_from_command (int num) 667 { 668 if (num >= 1 && num <= 15) 669 return (enum target_signal) num; 670 error (_("Only signals 1-15 are valid as numeric signals.\n\ 671 Use \"info signals\" for a list of symbolic signals.")); 672 } 673 674 extern initialize_file_ftype _initialize_signals; /* -Wmissing-prototype */ 675 676 void 677 _initialize_signals (void) 678 { 679 if (strcmp (signals[TARGET_SIGNAL_LAST].string, "TARGET_SIGNAL_MAGIC") != 0) 680 internal_error (__FILE__, __LINE__, "failed internal consistency check"); 681 } 682 683 int 684 default_target_signal_to_host (struct gdbarch *gdbarch, enum target_signal ts) 685 { 686 return target_signal_to_host (ts); 687 } 688 689 enum target_signal 690 default_target_signal_from_host (struct gdbarch *gdbarch, int signo) 691 { 692 return target_signal_from_host (signo); 693 } 694 695 #endif /* ! GDBSERVER */ 696