1 /* Top level stuff for GDB, the GNU debugger. 2 3 Copyright (C) 1999-2013 Free Software Foundation, Inc. 4 5 Written by Elena Zannoni <ezannoni@cygnus.com> of Cygnus Solutions. 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 #include "defs.h" 23 #include "top.h" 24 #include "inferior.h" 25 #include "target.h" 26 #include "terminal.h" /* for job_control */ 27 #include "event-loop.h" 28 #include "event-top.h" 29 #include "interps.h" 30 #include <signal.h> 31 #include "exceptions.h" 32 #include "cli/cli-script.h" /* for reset_command_nest_depth */ 33 #include "main.h" 34 #include "gdbthread.h" 35 #include "observer.h" 36 #include "continuations.h" 37 #include "gdbcmd.h" /* for dont_repeat() */ 38 #include "annotate.h" 39 40 /* readline include files. */ 41 #include "readline/readline.h" 42 #include "readline/history.h" 43 44 /* readline defines this. */ 45 #undef savestring 46 47 static void rl_callback_read_char_wrapper (gdb_client_data client_data); 48 static void command_line_handler (char *rl); 49 static void change_line_handler (void); 50 static void command_handler (char *command); 51 static char *top_level_prompt (void); 52 53 /* Signal handlers. */ 54 #ifdef SIGQUIT 55 static void handle_sigquit (int sig); 56 #endif 57 #ifdef SIGHUP 58 static void handle_sighup (int sig); 59 #endif 60 static void handle_sigfpe (int sig); 61 62 /* Functions to be invoked by the event loop in response to 63 signals. */ 64 #if defined (SIGQUIT) || defined (SIGHUP) 65 static void async_do_nothing (gdb_client_data); 66 #endif 67 #ifdef SIGHUP 68 static void async_disconnect (gdb_client_data); 69 #endif 70 static void async_float_handler (gdb_client_data); 71 #ifdef STOP_SIGNAL 72 static void async_stop_sig (gdb_client_data); 73 #endif 74 75 /* Readline offers an alternate interface, via callback 76 functions. These are all included in the file callback.c in the 77 readline distribution. This file provides (mainly) a function, which 78 the event loop uses as callback (i.e. event handler) whenever an event 79 is detected on the standard input file descriptor. 80 readline_callback_read_char is called (by the GDB event loop) whenever 81 there is a new character ready on the input stream. This function 82 incrementally builds a buffer internal to readline where it 83 accumulates the line read up to the point of invocation. In the 84 special case in which the character read is newline, the function 85 invokes a GDB supplied callback routine, which does the processing of 86 a full command line. This latter routine is the asynchronous analog 87 of the old command_line_input in gdb. Instead of invoking (and waiting 88 for) readline to read the command line and pass it back to 89 command_loop for processing, the new command_line_handler function has 90 the command line already available as its parameter. INPUT_HANDLER is 91 to be set to the function that readline will invoke when a complete 92 line of input is ready. CALL_READLINE is to be set to the function 93 that readline offers as callback to the event_loop. */ 94 95 void (*input_handler) (char *); 96 void (*call_readline) (gdb_client_data); 97 98 /* Important variables for the event loop. */ 99 100 /* This is used to determine if GDB is using the readline library or 101 its own simplified form of readline. It is used by the asynchronous 102 form of the set editing command. 103 ezannoni: as of 1999-04-29 I expect that this 104 variable will not be used after gdb is changed to use the event 105 loop as default engine, and event-top.c is merged into top.c. */ 106 int async_command_editing_p; 107 108 /* This is the annotation suffix that will be used when the 109 annotation_level is 2. */ 110 char *async_annotation_suffix; 111 112 /* This is used to display the notification of the completion of an 113 asynchronous execution command. */ 114 int exec_done_display_p = 0; 115 116 /* This is the file descriptor for the input stream that GDB uses to 117 read commands from. */ 118 int input_fd; 119 120 /* Signal handling variables. */ 121 /* Each of these is a pointer to a function that the event loop will 122 invoke if the corresponding signal has received. The real signal 123 handlers mark these functions as ready to be executed and the event 124 loop, in a later iteration, calls them. See the function 125 invoke_async_signal_handler. */ 126 static struct async_signal_handler *sigint_token; 127 #ifdef SIGHUP 128 static struct async_signal_handler *sighup_token; 129 #endif 130 #ifdef SIGQUIT 131 static struct async_signal_handler *sigquit_token; 132 #endif 133 static struct async_signal_handler *sigfpe_token; 134 #ifdef STOP_SIGNAL 135 static struct async_signal_handler *sigtstp_token; 136 #endif 137 138 /* Structure to save a partially entered command. This is used when 139 the user types '\' at the end of a command line. This is necessary 140 because each line of input is handled by a different call to 141 command_line_handler, and normally there is no state retained 142 between different calls. */ 143 static int more_to_come = 0; 144 145 struct readline_input_state 146 { 147 char *linebuffer; 148 char *linebuffer_ptr; 149 } 150 readline_input_state; 151 152 /* This hook is called by rl_callback_read_char_wrapper after each 153 character is processed. */ 154 void (*after_char_processing_hook) (void); 155 156 157 /* Wrapper function for calling into the readline library. The event 158 loop expects the callback function to have a paramter, while 159 readline expects none. */ 160 static void 161 rl_callback_read_char_wrapper (gdb_client_data client_data) 162 { 163 rl_callback_read_char (); 164 if (after_char_processing_hook) 165 (*after_char_processing_hook) (); 166 } 167 168 /* Initialize all the necessary variables, start the event loop, 169 register readline, and stdin, start the loop. */ 170 void 171 cli_command_loop (void) 172 { 173 display_gdb_prompt (0); 174 175 /* Now it's time to start the event loop. */ 176 start_event_loop (); 177 } 178 179 /* Change the function to be invoked every time there is a character 180 ready on stdin. This is used when the user sets the editing off, 181 therefore bypassing readline, and letting gdb handle the input 182 itself, via gdb_readline2. Also it is used in the opposite case in 183 which the user sets editing on again, by restoring readline 184 handling of the input. */ 185 static void 186 change_line_handler (void) 187 { 188 /* NOTE: this operates on input_fd, not instream. If we are reading 189 commands from a file, instream will point to the file. However in 190 async mode, we always read commands from a file with editing 191 off. This means that the 'set editing on/off' will have effect 192 only on the interactive session. */ 193 194 if (async_command_editing_p) 195 { 196 /* Turn on editing by using readline. */ 197 call_readline = rl_callback_read_char_wrapper; 198 input_handler = command_line_handler; 199 } 200 else 201 { 202 /* Turn off editing by using gdb_readline2. */ 203 rl_callback_handler_remove (); 204 call_readline = gdb_readline2; 205 206 /* Set up the command handler as well, in case we are called as 207 first thing from .gdbinit. */ 208 input_handler = command_line_handler; 209 } 210 } 211 212 /* Displays the prompt. If the argument NEW_PROMPT is NULL, the 213 prompt that is displayed is the current top level prompt. 214 Otherwise, it displays whatever NEW_PROMPT is as a local/secondary 215 prompt. 216 217 This is used after each gdb command has completed, and in the 218 following cases: 219 220 1. When the user enters a command line which is ended by '\' 221 indicating that the command will continue on the next line. In 222 that case the prompt that is displayed is the empty string. 223 224 2. When the user is entering 'commands' for a breakpoint, or 225 actions for a tracepoint. In this case the prompt will be '>' 226 227 3. On prompting for pagination. */ 228 229 void 230 display_gdb_prompt (char *new_prompt) 231 { 232 char *actual_gdb_prompt = NULL; 233 struct cleanup *old_chain; 234 235 annotate_display_prompt (); 236 237 /* Reset the nesting depth used when trace-commands is set. */ 238 reset_command_nest_depth (); 239 240 /* Each interpreter has its own rules on displaying the command 241 prompt. */ 242 if (!current_interp_display_prompt_p ()) 243 return; 244 245 old_chain = make_cleanup (free_current_contents, &actual_gdb_prompt); 246 247 /* Do not call the python hook on an explicit prompt change as 248 passed to this function, as this forms a secondary/local prompt, 249 IE, displayed but not set. */ 250 if (! new_prompt) 251 { 252 if (sync_execution) 253 { 254 /* This is to trick readline into not trying to display the 255 prompt. Even though we display the prompt using this 256 function, readline still tries to do its own display if 257 we don't call rl_callback_handler_install and 258 rl_callback_handler_remove (which readline detects 259 because a global variable is not set). If readline did 260 that, it could mess up gdb signal handlers for SIGINT. 261 Readline assumes that between calls to rl_set_signals and 262 rl_clear_signals gdb doesn't do anything with the signal 263 handlers. Well, that's not the case, because when the 264 target executes we change the SIGINT signal handler. If 265 we allowed readline to display the prompt, the signal 266 handler change would happen exactly between the calls to 267 the above two functions. Calling 268 rl_callback_handler_remove(), does the job. */ 269 270 rl_callback_handler_remove (); 271 return; 272 } 273 else 274 { 275 /* Display the top level prompt. */ 276 actual_gdb_prompt = top_level_prompt (); 277 } 278 } 279 else 280 actual_gdb_prompt = xstrdup (new_prompt); 281 282 if (async_command_editing_p) 283 { 284 rl_callback_handler_remove (); 285 rl_callback_handler_install (actual_gdb_prompt, input_handler); 286 } 287 /* new_prompt at this point can be the top of the stack or the one 288 passed in. It can't be NULL. */ 289 else 290 { 291 /* Don't use a _filtered function here. It causes the assumed 292 character position to be off, since the newline we read from 293 the user is not accounted for. */ 294 fputs_unfiltered (actual_gdb_prompt, gdb_stdout); 295 gdb_flush (gdb_stdout); 296 } 297 298 do_cleanups (old_chain); 299 } 300 301 /* Return the top level prompt, as specified by "set prompt", possibly 302 overriden by the python gdb.prompt_hook hook, and then composed 303 with the prompt prefix and suffix (annotations). The caller is 304 responsible for freeing the returned string. */ 305 306 static char * 307 top_level_prompt (void) 308 { 309 char *prefix; 310 char *prompt = NULL; 311 char *suffix; 312 char *composed_prompt; 313 size_t prompt_length; 314 315 /* Give observers a chance of changing the prompt. E.g., the python 316 `gdb.prompt_hook' is installed as an observer. */ 317 observer_notify_before_prompt (get_prompt ()); 318 319 prompt = xstrdup (get_prompt ()); 320 321 if (annotation_level >= 2) 322 { 323 /* Prefix needs to have new line at end. */ 324 prefix = (char *) alloca (strlen (async_annotation_suffix) + 10); 325 strcpy (prefix, "\n\032\032pre-"); 326 strcat (prefix, async_annotation_suffix); 327 strcat (prefix, "\n"); 328 329 /* Suffix needs to have a new line at end and \032 \032 at 330 beginning. */ 331 suffix = (char *) alloca (strlen (async_annotation_suffix) + 6); 332 strcpy (suffix, "\n\032\032"); 333 strcat (suffix, async_annotation_suffix); 334 strcat (suffix, "\n"); 335 } 336 else 337 { 338 prefix = ""; 339 suffix = ""; 340 } 341 342 prompt_length = strlen (prefix) + strlen (prompt) + strlen (suffix); 343 composed_prompt = xmalloc (prompt_length + 1); 344 345 strcpy (composed_prompt, prefix); 346 strcat (composed_prompt, prompt); 347 strcat (composed_prompt, suffix); 348 349 xfree (prompt); 350 351 return composed_prompt; 352 } 353 354 /* When there is an event ready on the stdin file desriptor, instead 355 of calling readline directly throught the callback function, or 356 instead of calling gdb_readline2, give gdb a chance to detect 357 errors and do something. */ 358 void 359 stdin_event_handler (int error, gdb_client_data client_data) 360 { 361 if (error) 362 { 363 printf_unfiltered (_("error detected on stdin\n")); 364 delete_file_handler (input_fd); 365 discard_all_continuations (); 366 discard_all_intermediate_continuations (); 367 /* If stdin died, we may as well kill gdb. */ 368 quit_command ((char *) 0, stdin == instream); 369 } 370 else 371 (*call_readline) (client_data); 372 } 373 374 /* Re-enable stdin after the end of an execution command in 375 synchronous mode, or after an error from the target, and we aborted 376 the exec operation. */ 377 378 void 379 async_enable_stdin (void) 380 { 381 if (sync_execution) 382 { 383 /* See NOTE in async_disable_stdin(). */ 384 /* FIXME: cagney/1999-09-27: Call this before clearing 385 sync_execution. Current target_terminal_ours() implementations 386 check for sync_execution before switching the terminal. */ 387 target_terminal_ours (); 388 sync_execution = 0; 389 } 390 } 391 392 /* Disable reads from stdin (the console) marking the command as 393 synchronous. */ 394 395 void 396 async_disable_stdin (void) 397 { 398 sync_execution = 1; 399 } 400 401 402 /* Handles a gdb command. This function is called by 403 command_line_handler, which has processed one or more input lines 404 into COMMAND. */ 405 /* NOTE: 1999-04-30 This is the asynchronous version of the command_loop 406 function. The command_loop function will be obsolete when we 407 switch to use the event loop at every execution of gdb. */ 408 static void 409 command_handler (char *command) 410 { 411 int stdin_is_tty = ISATTY (stdin); 412 struct cleanup *stat_chain; 413 414 clear_quit_flag (); 415 if (instream == stdin && stdin_is_tty) 416 reinitialize_more_filter (); 417 418 /* If readline returned a NULL command, it means that the connection 419 with the terminal is gone. This happens at the end of a 420 testsuite run, after Expect has hung up but GDB is still alive. 421 In such a case, we just quit gdb killing the inferior program 422 too. */ 423 if (command == 0) 424 { 425 printf_unfiltered ("quit\n"); 426 execute_command ("quit", stdin == instream); 427 } 428 429 stat_chain = make_command_stats_cleanup (1); 430 431 execute_command (command, instream == stdin); 432 433 /* Do any commands attached to breakpoint we stopped at. */ 434 bpstat_do_actions (); 435 436 do_cleanups (stat_chain); 437 } 438 439 /* Handle a complete line of input. This is called by the callback 440 mechanism within the readline library. Deal with incomplete 441 commands as well, by saving the partial input in a global 442 buffer. */ 443 444 /* NOTE: 1999-04-30 This is the asynchronous version of the 445 command_line_input function; command_line_input will become 446 obsolete once we use the event loop as the default mechanism in 447 GDB. */ 448 static void 449 command_line_handler (char *rl) 450 { 451 static char *linebuffer = 0; 452 static unsigned linelength = 0; 453 char *p; 454 char *p1; 455 char *nline; 456 int repeat = (instream == stdin); 457 458 if (annotation_level > 1 && instream == stdin) 459 { 460 printf_unfiltered (("\n\032\032post-")); 461 puts_unfiltered (async_annotation_suffix); 462 printf_unfiltered (("\n")); 463 } 464 465 if (linebuffer == 0) 466 { 467 linelength = 80; 468 linebuffer = (char *) xmalloc (linelength); 469 } 470 471 p = linebuffer; 472 473 if (more_to_come) 474 { 475 strcpy (linebuffer, readline_input_state.linebuffer); 476 p = readline_input_state.linebuffer_ptr; 477 xfree (readline_input_state.linebuffer); 478 more_to_come = 0; 479 } 480 481 #ifdef STOP_SIGNAL 482 if (job_control) 483 signal (STOP_SIGNAL, handle_stop_sig); 484 #endif 485 486 /* Make sure that all output has been output. Some machines may let 487 you get away with leaving out some of the gdb_flush, but not 488 all. */ 489 wrap_here (""); 490 gdb_flush (gdb_stdout); 491 gdb_flush (gdb_stderr); 492 493 if (source_file_name != NULL) 494 ++source_line_number; 495 496 /* If we are in this case, then command_handler will call quit 497 and exit from gdb. */ 498 if (!rl || rl == (char *) EOF) 499 { 500 command_handler (0); 501 return; /* Lint. */ 502 } 503 if (strlen (rl) + 1 + (p - linebuffer) > linelength) 504 { 505 linelength = strlen (rl) + 1 + (p - linebuffer); 506 nline = (char *) xrealloc (linebuffer, linelength); 507 p += nline - linebuffer; 508 linebuffer = nline; 509 } 510 p1 = rl; 511 /* Copy line. Don't copy null at end. (Leaves line alone 512 if this was just a newline). */ 513 while (*p1) 514 *p++ = *p1++; 515 516 xfree (rl); /* Allocated in readline. */ 517 518 if (p > linebuffer && *(p - 1) == '\\') 519 { 520 *p = '\0'; 521 p--; /* Put on top of '\'. */ 522 523 readline_input_state.linebuffer = xstrdup (linebuffer); 524 readline_input_state.linebuffer_ptr = p; 525 526 /* We will not invoke a execute_command if there is more 527 input expected to complete the command. So, we need to 528 print an empty prompt here. */ 529 more_to_come = 1; 530 display_gdb_prompt (""); 531 return; 532 } 533 534 #ifdef STOP_SIGNAL 535 if (job_control) 536 signal (STOP_SIGNAL, SIG_DFL); 537 #endif 538 539 #define SERVER_COMMAND_LENGTH 7 540 server_command = 541 (p - linebuffer > SERVER_COMMAND_LENGTH) 542 && strncmp (linebuffer, "server ", SERVER_COMMAND_LENGTH) == 0; 543 if (server_command) 544 { 545 /* Note that we don't set `line'. Between this and the check in 546 dont_repeat, this insures that repeating will still do the 547 right thing. */ 548 *p = '\0'; 549 command_handler (linebuffer + SERVER_COMMAND_LENGTH); 550 display_gdb_prompt (0); 551 return; 552 } 553 554 /* Do history expansion if that is wished. */ 555 if (history_expansion_p && instream == stdin 556 && ISATTY (instream)) 557 { 558 char *history_value; 559 int expanded; 560 561 *p = '\0'; /* Insert null now. */ 562 expanded = history_expand (linebuffer, &history_value); 563 if (expanded) 564 { 565 /* Print the changes. */ 566 printf_unfiltered ("%s\n", history_value); 567 568 /* If there was an error, call this function again. */ 569 if (expanded < 0) 570 { 571 xfree (history_value); 572 return; 573 } 574 if (strlen (history_value) > linelength) 575 { 576 linelength = strlen (history_value) + 1; 577 linebuffer = (char *) xrealloc (linebuffer, linelength); 578 } 579 strcpy (linebuffer, history_value); 580 p = linebuffer + strlen (linebuffer); 581 } 582 xfree (history_value); 583 } 584 585 /* If we just got an empty line, and that is supposed to repeat the 586 previous command, return the value in the global buffer. */ 587 if (repeat && p == linebuffer && *p != '\\') 588 { 589 command_handler (saved_command_line); 590 display_gdb_prompt (0); 591 return; 592 } 593 594 for (p1 = linebuffer; *p1 == ' ' || *p1 == '\t'; p1++); 595 if (repeat && !*p1) 596 { 597 command_handler (saved_command_line); 598 display_gdb_prompt (0); 599 return; 600 } 601 602 *p = 0; 603 604 /* Add line to history if appropriate. */ 605 if (instream == stdin 606 && ISATTY (stdin) && *linebuffer) 607 add_history (linebuffer); 608 609 /* Note: lines consisting solely of comments are added to the command 610 history. This is useful when you type a command, and then 611 realize you don't want to execute it quite yet. You can comment 612 out the command and then later fetch it from the value history 613 and remove the '#'. The kill ring is probably better, but some 614 people are in the habit of commenting things out. */ 615 if (*p1 == '#') 616 *p1 = '\0'; /* Found a comment. */ 617 618 /* Save into global buffer if appropriate. */ 619 if (repeat) 620 { 621 if (linelength > saved_command_line_size) 622 { 623 saved_command_line = xrealloc (saved_command_line, linelength); 624 saved_command_line_size = linelength; 625 } 626 strcpy (saved_command_line, linebuffer); 627 if (!more_to_come) 628 { 629 command_handler (saved_command_line); 630 display_gdb_prompt (0); 631 } 632 return; 633 } 634 635 command_handler (linebuffer); 636 display_gdb_prompt (0); 637 return; 638 } 639 640 /* Does reading of input from terminal w/o the editing features 641 provided by the readline library. */ 642 643 /* NOTE: 1999-04-30 Asynchronous version of gdb_readline; gdb_readline 644 will become obsolete when the event loop is made the default 645 execution for gdb. */ 646 void 647 gdb_readline2 (gdb_client_data client_data) 648 { 649 int c; 650 char *result; 651 int input_index = 0; 652 int result_size = 80; 653 static int done_once = 0; 654 655 /* Unbuffer the input stream, so that, later on, the calls to fgetc 656 fetch only one char at the time from the stream. The fgetc's will 657 get up to the first newline, but there may be more chars in the 658 stream after '\n'. If we buffer the input and fgetc drains the 659 stream, getting stuff beyond the newline as well, a select, done 660 afterwards will not trigger. */ 661 if (!done_once && !ISATTY (instream)) 662 { 663 setbuf (instream, NULL); 664 done_once = 1; 665 } 666 667 result = (char *) xmalloc (result_size); 668 669 /* We still need the while loop here, even though it would seem 670 obvious to invoke gdb_readline2 at every character entered. If 671 not using the readline library, the terminal is in cooked mode, 672 which sends the characters all at once. Poll will notice that the 673 input fd has changed state only after enter is pressed. At this 674 point we still need to fetch all the chars entered. */ 675 676 while (1) 677 { 678 /* Read from stdin if we are executing a user defined command. 679 This is the right thing for prompt_for_continue, at least. */ 680 c = fgetc (instream ? instream : stdin); 681 682 if (c == EOF) 683 { 684 if (input_index > 0) 685 /* The last line does not end with a newline. Return it, 686 and if we are called again fgetc will still return EOF 687 and we'll return NULL then. */ 688 break; 689 xfree (result); 690 (*input_handler) (0); 691 return; 692 } 693 694 if (c == '\n') 695 { 696 if (input_index > 0 && result[input_index - 1] == '\r') 697 input_index--; 698 break; 699 } 700 701 result[input_index++] = c; 702 while (input_index >= result_size) 703 { 704 result_size *= 2; 705 result = (char *) xrealloc (result, result_size); 706 } 707 } 708 709 result[input_index++] = '\0'; 710 (*input_handler) (result); 711 } 712 713 714 /* Initialization of signal handlers and tokens. There is a function 715 handle_sig* for each of the signals GDB cares about. Specifically: 716 SIGINT, SIGFPE, SIGQUIT, SIGTSTP, SIGHUP, SIGWINCH. These 717 functions are the actual signal handlers associated to the signals 718 via calls to signal(). The only job for these functions is to 719 enqueue the appropriate event/procedure with the event loop. Such 720 procedures are the old signal handlers. The event loop will take 721 care of invoking the queued procedures to perform the usual tasks 722 associated with the reception of the signal. */ 723 /* NOTE: 1999-04-30 This is the asynchronous version of init_signals. 724 init_signals will become obsolete as we move to have to event loop 725 as the default for gdb. */ 726 void 727 async_init_signals (void) 728 { 729 signal (SIGINT, handle_sigint); 730 sigint_token = 731 create_async_signal_handler (async_request_quit, NULL); 732 signal (SIGTERM, handle_sigterm); 733 734 /* If SIGTRAP was set to SIG_IGN, then the SIG_IGN will get passed 735 to the inferior and breakpoints will be ignored. */ 736 #ifdef SIGTRAP 737 signal (SIGTRAP, SIG_DFL); 738 #endif 739 740 #ifdef SIGQUIT 741 /* If we initialize SIGQUIT to SIG_IGN, then the SIG_IGN will get 742 passed to the inferior, which we don't want. It would be 743 possible to do a "signal (SIGQUIT, SIG_DFL)" after we fork, but 744 on BSD4.3 systems using vfork, that can affect the 745 GDB process as well as the inferior (the signal handling tables 746 might be in memory, shared between the two). Since we establish 747 a handler for SIGQUIT, when we call exec it will set the signal 748 to SIG_DFL for us. */ 749 signal (SIGQUIT, handle_sigquit); 750 sigquit_token = 751 create_async_signal_handler (async_do_nothing, NULL); 752 #endif 753 #ifdef SIGHUP 754 if (signal (SIGHUP, handle_sighup) != SIG_IGN) 755 sighup_token = 756 create_async_signal_handler (async_disconnect, NULL); 757 else 758 sighup_token = 759 create_async_signal_handler (async_do_nothing, NULL); 760 #endif 761 signal (SIGFPE, handle_sigfpe); 762 sigfpe_token = 763 create_async_signal_handler (async_float_handler, NULL); 764 765 #ifdef STOP_SIGNAL 766 sigtstp_token = 767 create_async_signal_handler (async_stop_sig, NULL); 768 #endif 769 770 } 771 772 /* Tell the event loop what to do if SIGINT is received. 773 See event-signal.c. */ 774 void 775 handle_sigint (int sig) 776 { 777 signal (sig, handle_sigint); 778 779 /* We could be running in a loop reading in symfiles or something so 780 it may be quite a while before we get back to the event loop. So 781 set quit_flag to 1 here. Then if QUIT is called before we get to 782 the event loop, we will unwind as expected. */ 783 784 set_quit_flag (); 785 786 /* If immediate_quit is set, we go ahead and process the SIGINT right 787 away, even if we usually would defer this to the event loop. The 788 assumption here is that it is safe to process ^C immediately if 789 immediate_quit is set. If we didn't, SIGINT would be really 790 processed only the next time through the event loop. To get to 791 that point, though, the command that we want to interrupt needs to 792 finish first, which is unacceptable. If immediate quit is not set, 793 we process SIGINT the next time through the loop, which is fine. */ 794 gdb_call_async_signal_handler (sigint_token, immediate_quit); 795 } 796 797 /* Quit GDB if SIGTERM is received. 798 GDB would quit anyway, but this way it will clean up properly. */ 799 void 800 handle_sigterm (int sig) 801 { 802 signal (sig, handle_sigterm); 803 quit_force ((char *) 0, stdin == instream); 804 } 805 806 /* Do the quit. All the checks have been done by the caller. */ 807 void 808 async_request_quit (gdb_client_data arg) 809 { 810 /* If the quit_flag has gotten reset back to 0 by the time we get 811 back here, that means that an exception was thrown to unwind the 812 current command before we got back to the event loop. So there 813 is no reason to call quit again here. */ 814 815 if (check_quit_flag ()) 816 quit (); 817 } 818 819 #ifdef SIGQUIT 820 /* Tell the event loop what to do if SIGQUIT is received. 821 See event-signal.c. */ 822 static void 823 handle_sigquit (int sig) 824 { 825 mark_async_signal_handler (sigquit_token); 826 signal (sig, handle_sigquit); 827 } 828 #endif 829 830 #if defined (SIGQUIT) || defined (SIGHUP) 831 /* Called by the event loop in response to a SIGQUIT or an 832 ignored SIGHUP. */ 833 static void 834 async_do_nothing (gdb_client_data arg) 835 { 836 /* Empty function body. */ 837 } 838 #endif 839 840 #ifdef SIGHUP 841 /* Tell the event loop what to do if SIGHUP is received. 842 See event-signal.c. */ 843 static void 844 handle_sighup (int sig) 845 { 846 mark_async_signal_handler (sighup_token); 847 signal (sig, handle_sighup); 848 } 849 850 /* Called by the event loop to process a SIGHUP. */ 851 static void 852 async_disconnect (gdb_client_data arg) 853 { 854 volatile struct gdb_exception exception; 855 856 TRY_CATCH (exception, RETURN_MASK_ALL) 857 { 858 quit_cover (); 859 } 860 861 if (exception.reason < 0) 862 { 863 fputs_filtered ("Could not kill the program being debugged", 864 gdb_stderr); 865 exception_print (gdb_stderr, exception); 866 } 867 868 TRY_CATCH (exception, RETURN_MASK_ALL) 869 { 870 pop_all_targets (1); 871 } 872 873 signal (SIGHUP, SIG_DFL); /*FIXME: ??????????? */ 874 raise (SIGHUP); 875 } 876 #endif 877 878 #ifdef STOP_SIGNAL 879 void 880 handle_stop_sig (int sig) 881 { 882 mark_async_signal_handler (sigtstp_token); 883 signal (sig, handle_stop_sig); 884 } 885 886 static void 887 async_stop_sig (gdb_client_data arg) 888 { 889 char *prompt = get_prompt (); 890 891 #if STOP_SIGNAL == SIGTSTP 892 signal (SIGTSTP, SIG_DFL); 893 #if HAVE_SIGPROCMASK 894 { 895 sigset_t zero; 896 897 sigemptyset (&zero); 898 sigprocmask (SIG_SETMASK, &zero, 0); 899 } 900 #elif HAVE_SIGSETMASK 901 sigsetmask (0); 902 #endif 903 raise (SIGTSTP); 904 signal (SIGTSTP, handle_stop_sig); 905 #else 906 signal (STOP_SIGNAL, handle_stop_sig); 907 #endif 908 printf_unfiltered ("%s", prompt); 909 gdb_flush (gdb_stdout); 910 911 /* Forget about any previous command -- null line now will do 912 nothing. */ 913 dont_repeat (); 914 } 915 #endif /* STOP_SIGNAL */ 916 917 /* Tell the event loop what to do if SIGFPE is received. 918 See event-signal.c. */ 919 static void 920 handle_sigfpe (int sig) 921 { 922 mark_async_signal_handler (sigfpe_token); 923 signal (sig, handle_sigfpe); 924 } 925 926 /* Event loop will call this functin to process a SIGFPE. */ 927 static void 928 async_float_handler (gdb_client_data arg) 929 { 930 /* This message is based on ANSI C, section 4.7. Note that integer 931 divide by zero causes this, so "float" is a misnomer. */ 932 error (_("Erroneous arithmetic operation.")); 933 } 934 935 936 /* Called by do_setshow_command. */ 937 void 938 set_async_editing_command (char *args, int from_tty, 939 struct cmd_list_element *c) 940 { 941 change_line_handler (); 942 } 943 944 /* Set things up for readline to be invoked via the alternate 945 interface, i.e. via a callback function (rl_callback_read_char), 946 and hook up instream to the event loop. */ 947 void 948 gdb_setup_readline (void) 949 { 950 /* This function is a noop for the sync case. The assumption is 951 that the sync setup is ALL done in gdb_init, and we would only 952 mess it up here. The sync stuff should really go away over 953 time. */ 954 if (!batch_silent) 955 gdb_stdout = stdio_fileopen (stdout); 956 gdb_stderr = stdio_fileopen (stderr); 957 gdb_stdlog = gdb_stderr; /* for moment */ 958 gdb_stdtarg = gdb_stderr; /* for moment */ 959 gdb_stdtargerr = gdb_stderr; /* for moment */ 960 961 /* If the input stream is connected to a terminal, turn on 962 editing. */ 963 if (ISATTY (instream)) 964 { 965 /* Tell gdb that we will be using the readline library. This 966 could be overwritten by a command in .gdbinit like 'set 967 editing on' or 'off'. */ 968 async_command_editing_p = 1; 969 970 /* When a character is detected on instream by select or poll, 971 readline will be invoked via this callback function. */ 972 call_readline = rl_callback_read_char_wrapper; 973 } 974 else 975 { 976 async_command_editing_p = 0; 977 call_readline = gdb_readline2; 978 } 979 980 /* When readline has read an end-of-line character, it passes the 981 complete line to gdb for processing; command_line_handler is the 982 function that does this. */ 983 input_handler = command_line_handler; 984 985 /* Tell readline to use the same input stream that gdb uses. */ 986 rl_instream = instream; 987 988 /* Get a file descriptor for the input stream, so that we can 989 register it with the event loop. */ 990 input_fd = fileno (instream); 991 992 /* Now we need to create the event sources for the input file 993 descriptor. */ 994 /* At this point in time, this is the only event source that we 995 register with the even loop. Another source is going to be the 996 target program (inferior), but that must be registered only when 997 it actually exists (I.e. after we say 'run' or after we connect 998 to a remote target. */ 999 add_file_handler (input_fd, stdin_event_handler, 0); 1000 } 1001 1002 /* Disable command input through the standard CLI channels. Used in 1003 the suspend proc for interpreters that use the standard gdb readline 1004 interface, like the cli & the mi. */ 1005 void 1006 gdb_disable_readline (void) 1007 { 1008 /* FIXME - It is too heavyweight to delete and remake these every 1009 time you run an interpreter that needs readline. It is probably 1010 better to have the interpreters cache these, which in turn means 1011 that this needs to be moved into interpreter specific code. */ 1012 1013 #if 0 1014 ui_file_delete (gdb_stdout); 1015 ui_file_delete (gdb_stderr); 1016 gdb_stdlog = NULL; 1017 gdb_stdtarg = NULL; 1018 gdb_stdtargerr = NULL; 1019 #endif 1020 1021 rl_callback_handler_remove (); 1022 delete_file_handler (input_fd); 1023 } 1024