1 /* MI Interpreter Definitions and Commands for GDB, the GNU debugger. 2 3 Copyright (C) 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010, 2011 4 Free Software Foundation, Inc. 5 6 This file is part of GDB. 7 8 This program is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 3 of the License, or 11 (at your option) any later version. 12 13 This program is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 20 21 #include "defs.h" 22 #include "gdb_string.h" 23 #include "interps.h" 24 #include "event-top.h" 25 #include "event-loop.h" 26 #include "inferior.h" 27 #include "ui-out.h" 28 #include "top.h" 29 #include "exceptions.h" 30 #include "mi-main.h" 31 #include "mi-cmds.h" 32 #include "mi-out.h" 33 #include "mi-console.h" 34 #include "mi-common.h" 35 #include "observer.h" 36 #include "gdbthread.h" 37 #include "solist.h" 38 39 /* These are the interpreter setup, etc. functions for the MI interpreter */ 40 static void mi_execute_command_wrapper (char *cmd); 41 static void mi_command_loop (int mi_version); 42 43 /* These are hooks that we put in place while doing interpreter_exec 44 so we can report interesting things that happened "behind the mi's 45 back" in this command */ 46 static int mi_interp_query_hook (const char *ctlstr, va_list ap) 47 ATTRIBUTE_PRINTF (1, 0); 48 49 static void mi3_command_loop (void); 50 static void mi2_command_loop (void); 51 static void mi1_command_loop (void); 52 53 static void mi_insert_notify_hooks (void); 54 static void mi_remove_notify_hooks (void); 55 static void mi_on_normal_stop (struct bpstats *bs, int print_frame); 56 57 static void mi_new_thread (struct thread_info *t); 58 static void mi_thread_exit (struct thread_info *t, int silent); 59 static void mi_inferior_added (struct inferior *inf); 60 static void mi_inferior_appeared (struct inferior *inf); 61 static void mi_inferior_exit (struct inferior *inf); 62 static void mi_inferior_removed (struct inferior *inf); 63 static void mi_on_resume (ptid_t ptid); 64 static void mi_solib_loaded (struct so_list *solib); 65 static void mi_solib_unloaded (struct so_list *solib); 66 static void mi_about_to_proceed (void); 67 68 static int report_initial_inferior (struct inferior *inf, void *closure); 69 70 static void * 71 mi_interpreter_init (int top_level) 72 { 73 struct mi_interp *mi = XMALLOC (struct mi_interp); 74 75 /* HACK: We need to force stdout/stderr to point at the console. This avoids 76 any potential side effects caused by legacy code that is still 77 using the TUI / fputs_unfiltered_hook. So we set up output channels for 78 this now, and swap them in when we are run. */ 79 80 raw_stdout = stdio_fileopen (stdout); 81 82 /* Create MI channels */ 83 mi->out = mi_console_file_new (raw_stdout, "~", '"'); 84 mi->err = mi_console_file_new (raw_stdout, "&", '"'); 85 mi->log = mi->err; 86 mi->targ = mi_console_file_new (raw_stdout, "@", '"'); 87 mi->event_channel = mi_console_file_new (raw_stdout, "=", 0); 88 89 if (top_level) 90 { 91 observer_attach_new_thread (mi_new_thread); 92 observer_attach_thread_exit (mi_thread_exit); 93 observer_attach_inferior_added (mi_inferior_added); 94 observer_attach_inferior_appeared (mi_inferior_appeared); 95 observer_attach_inferior_exit (mi_inferior_exit); 96 observer_attach_inferior_removed (mi_inferior_removed); 97 observer_attach_normal_stop (mi_on_normal_stop); 98 observer_attach_target_resumed (mi_on_resume); 99 observer_attach_solib_loaded (mi_solib_loaded); 100 observer_attach_solib_unloaded (mi_solib_unloaded); 101 observer_attach_about_to_proceed (mi_about_to_proceed); 102 103 /* The initial inferior is created before this function is called, so we 104 need to report it explicitly. Use iteration in case future version 105 of GDB creates more than one inferior up-front. */ 106 iterate_over_inferiors (report_initial_inferior, mi); 107 } 108 109 return mi; 110 } 111 112 static int 113 mi_interpreter_resume (void *data) 114 { 115 struct mi_interp *mi = data; 116 117 /* As per hack note in mi_interpreter_init, swap in the output channels... */ 118 gdb_setup_readline (); 119 120 /* These overwrite some of the initialization done in 121 _intialize_event_loop. */ 122 call_readline = gdb_readline2; 123 input_handler = mi_execute_command_wrapper; 124 add_file_handler (input_fd, stdin_event_handler, 0); 125 async_command_editing_p = 0; 126 /* FIXME: This is a total hack for now. PB's use of the MI 127 implicitly relies on a bug in the async support which allows 128 asynchronous commands to leak through the commmand loop. The bug 129 involves (but is not limited to) the fact that sync_execution was 130 erroneously initialized to 0. Duplicate by initializing it thus 131 here... */ 132 sync_execution = 0; 133 134 gdb_stdout = mi->out; 135 /* Route error and log output through the MI */ 136 gdb_stderr = mi->err; 137 gdb_stdlog = mi->log; 138 /* Route target output through the MI. */ 139 gdb_stdtarg = mi->targ; 140 /* Route target error through the MI as well. */ 141 gdb_stdtargerr = mi->targ; 142 143 /* Replace all the hooks that we know about. There really needs to 144 be a better way of doing this... */ 145 clear_interpreter_hooks (); 146 147 deprecated_show_load_progress = mi_load_progress; 148 149 /* If we're _the_ interpreter, take control. */ 150 if (current_interp_named_p (INTERP_MI1)) 151 deprecated_command_loop_hook = mi1_command_loop; 152 else if (current_interp_named_p (INTERP_MI2)) 153 deprecated_command_loop_hook = mi2_command_loop; 154 else if (current_interp_named_p (INTERP_MI3)) 155 deprecated_command_loop_hook = mi3_command_loop; 156 else 157 deprecated_command_loop_hook = mi2_command_loop; 158 159 return 1; 160 } 161 162 static int 163 mi_interpreter_suspend (void *data) 164 { 165 gdb_disable_readline (); 166 return 1; 167 } 168 169 static struct gdb_exception 170 mi_interpreter_exec (void *data, const char *command) 171 { 172 char *tmp = alloca (strlen (command) + 1); 173 174 strcpy (tmp, command); 175 mi_execute_command_wrapper (tmp); 176 return exception_none; 177 } 178 179 /* Never display the default gdb prompt in mi case. */ 180 static int 181 mi_interpreter_prompt_p (void *data) 182 { 183 return 0; 184 } 185 186 void 187 mi_cmd_interpreter_exec (char *command, char **argv, int argc) 188 { 189 struct interp *interp_to_use; 190 int i; 191 char *mi_error_message = NULL; 192 struct cleanup *old_chain; 193 194 if (argc < 2) 195 error (_("-interpreter-exec: " 196 "Usage: -interpreter-exec interp command")); 197 198 interp_to_use = interp_lookup (argv[0]); 199 if (interp_to_use == NULL) 200 error (_("-interpreter-exec: could not find interpreter \"%s\""), 201 argv[0]); 202 203 if (!interp_exec_p (interp_to_use)) 204 error (_("-interpreter-exec: interpreter \"%s\" " 205 "does not support command execution"), 206 argv[0]); 207 208 /* Insert the MI out hooks, making sure to also call the interpreter's hooks 209 if it has any. */ 210 /* KRS: We shouldn't need this... Events should be installed and they should 211 just ALWAYS fire something out down the MI channel... */ 212 mi_insert_notify_hooks (); 213 214 /* Now run the code... */ 215 216 old_chain = make_cleanup (null_cleanup, 0); 217 for (i = 1; i < argc; i++) 218 { 219 struct gdb_exception e = interp_exec (interp_to_use, argv[i]); 220 221 if (e.reason < 0) 222 { 223 mi_error_message = xstrdup (e.message); 224 make_cleanup (xfree, mi_error_message); 225 break; 226 } 227 } 228 229 mi_remove_notify_hooks (); 230 231 if (mi_error_message != NULL) 232 error ("%s", mi_error_message); 233 do_cleanups (old_chain); 234 } 235 236 /* 237 * mi_insert_notify_hooks - This inserts a number of hooks that are 238 * meant to produce async-notify ("=") MI messages while running 239 * commands in another interpreter using mi_interpreter_exec. The 240 * canonical use for this is to allow access to the gdb CLI 241 * interpreter from within the MI, while still producing MI style 242 * output when actions in the CLI command change gdb's state. 243 */ 244 245 static void 246 mi_insert_notify_hooks (void) 247 { 248 deprecated_query_hook = mi_interp_query_hook; 249 } 250 251 static void 252 mi_remove_notify_hooks (void) 253 { 254 deprecated_query_hook = NULL; 255 } 256 257 static int 258 mi_interp_query_hook (const char *ctlstr, va_list ap) 259 { 260 return 1; 261 } 262 263 static void 264 mi_execute_command_wrapper (char *cmd) 265 { 266 mi_execute_command (cmd, stdin == instream); 267 } 268 269 static void 270 mi1_command_loop (void) 271 { 272 mi_command_loop (1); 273 } 274 275 static void 276 mi2_command_loop (void) 277 { 278 mi_command_loop (2); 279 } 280 281 static void 282 mi3_command_loop (void) 283 { 284 mi_command_loop (3); 285 } 286 287 static void 288 mi_command_loop (int mi_version) 289 { 290 /* Turn off 8 bit strings in quoted output. Any character with the 291 high bit set is printed using C's octal format. */ 292 sevenbit_strings = 1; 293 /* Tell the world that we're alive */ 294 fputs_unfiltered ("(gdb) \n", raw_stdout); 295 gdb_flush (raw_stdout); 296 start_event_loop (); 297 } 298 299 static void 300 mi_new_thread (struct thread_info *t) 301 { 302 struct mi_interp *mi = top_level_interpreter_data (); 303 struct inferior *inf = find_inferior_pid (ptid_get_pid (t->ptid)); 304 305 gdb_assert (inf); 306 307 fprintf_unfiltered (mi->event_channel, 308 "thread-created,id=\"%d\",group-id=\"i%d\"", 309 t->num, inf->num); 310 gdb_flush (mi->event_channel); 311 } 312 313 static void 314 mi_thread_exit (struct thread_info *t, int silent) 315 { 316 struct mi_interp *mi; 317 struct inferior *inf; 318 319 if (silent) 320 return; 321 322 inf = find_inferior_pid (ptid_get_pid (t->ptid)); 323 324 mi = top_level_interpreter_data (); 325 target_terminal_ours (); 326 fprintf_unfiltered (mi->event_channel, 327 "thread-exited,id=\"%d\",group-id=\"i%d\"", 328 t->num, inf->num); 329 gdb_flush (mi->event_channel); 330 } 331 332 static void 333 mi_inferior_added (struct inferior *inf) 334 { 335 struct mi_interp *mi = top_level_interpreter_data (); 336 337 target_terminal_ours (); 338 fprintf_unfiltered (mi->event_channel, 339 "thread-group-added,id=\"i%d\"", 340 inf->num); 341 gdb_flush (mi->event_channel); 342 } 343 344 static void 345 mi_inferior_appeared (struct inferior *inf) 346 { 347 struct mi_interp *mi = top_level_interpreter_data (); 348 349 target_terminal_ours (); 350 fprintf_unfiltered (mi->event_channel, 351 "thread-group-started,id=\"i%d\",pid=\"%d\"", 352 inf->num, inf->pid); 353 gdb_flush (mi->event_channel); 354 } 355 356 static void 357 mi_inferior_exit (struct inferior *inf) 358 { 359 struct mi_interp *mi = top_level_interpreter_data (); 360 361 target_terminal_ours (); 362 if (inf->has_exit_code) 363 fprintf_unfiltered (mi->event_channel, 364 "thread-group-exited,id=\"i%d\",exit-code=\"%s\"", 365 inf->num, int_string (inf->exit_code, 8, 0, 0, 1)); 366 else 367 fprintf_unfiltered (mi->event_channel, 368 "thread-group-exited,id=\"i%d\"", inf->num); 369 370 gdb_flush (mi->event_channel); 371 } 372 373 static void 374 mi_inferior_removed (struct inferior *inf) 375 { 376 struct mi_interp *mi = top_level_interpreter_data (); 377 378 target_terminal_ours (); 379 fprintf_unfiltered (mi->event_channel, 380 "thread-group-removed,id=\"i%d\"", 381 inf->num); 382 gdb_flush (mi->event_channel); 383 } 384 385 static void 386 mi_on_normal_stop (struct bpstats *bs, int print_frame) 387 { 388 /* Since this can be called when CLI command is executing, 389 using cli interpreter, be sure to use MI uiout for output, 390 not the current one. */ 391 struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ()); 392 393 if (print_frame) 394 { 395 int core; 396 397 if (uiout != mi_uiout) 398 { 399 /* The normal_stop function has printed frame information into 400 CLI uiout, or some other non-MI uiout. There's no way we 401 can extract proper fields from random uiout object, so we print 402 the frame again. In practice, this can only happen when running 403 a CLI command in MI. */ 404 struct ui_out *saved_uiout = uiout; 405 406 uiout = mi_uiout; 407 print_stack_frame (get_selected_frame (NULL), 0, SRC_AND_LOC); 408 uiout = saved_uiout; 409 } 410 411 ui_out_field_int (mi_uiout, "thread-id", 412 pid_to_thread_id (inferior_ptid)); 413 if (non_stop) 414 { 415 struct cleanup *back_to = make_cleanup_ui_out_list_begin_end 416 (mi_uiout, "stopped-threads"); 417 418 ui_out_field_int (mi_uiout, NULL, 419 pid_to_thread_id (inferior_ptid)); 420 do_cleanups (back_to); 421 } 422 else 423 ui_out_field_string (mi_uiout, "stopped-threads", "all"); 424 425 core = target_core_of_thread (inferior_ptid); 426 if (core != -1) 427 ui_out_field_int (mi_uiout, "core", core); 428 } 429 430 fputs_unfiltered ("*stopped", raw_stdout); 431 mi_out_put (mi_uiout, raw_stdout); 432 mi_out_rewind (mi_uiout); 433 mi_print_timing_maybe (); 434 fputs_unfiltered ("\n", raw_stdout); 435 gdb_flush (raw_stdout); 436 } 437 438 static void 439 mi_about_to_proceed (void) 440 { 441 /* Suppress output while calling an inferior function. */ 442 443 if (!ptid_equal (inferior_ptid, null_ptid)) 444 { 445 struct thread_info *tp = inferior_thread (); 446 447 if (tp->control.in_infcall) 448 return; 449 } 450 451 mi_proceeded = 1; 452 } 453 454 static int 455 mi_output_running_pid (struct thread_info *info, void *arg) 456 { 457 ptid_t *ptid = arg; 458 459 if (ptid_get_pid (*ptid) == ptid_get_pid (info->ptid)) 460 fprintf_unfiltered (raw_stdout, 461 "*running,thread-id=\"%d\"\n", 462 info->num); 463 464 return 0; 465 } 466 467 static int 468 mi_inferior_count (struct inferior *inf, void *arg) 469 { 470 if (inf->pid != FAKE_PROCESS_ID) 471 { 472 int *count_p = arg; 473 (*count_p)++; 474 } 475 476 return 0; 477 } 478 479 static void 480 mi_on_resume (ptid_t ptid) 481 { 482 struct thread_info *tp = NULL; 483 484 if (ptid_equal (ptid, minus_one_ptid) || ptid_is_pid (ptid)) 485 tp = inferior_thread (); 486 else 487 tp = find_thread_ptid (ptid); 488 489 /* Suppress output while calling an inferior function. */ 490 if (tp->control.in_infcall) 491 return; 492 493 /* To cater for older frontends, emit ^running, but do it only once 494 per each command. We do it here, since at this point we know 495 that the target was successfully resumed, and in non-async mode, 496 we won't return back to MI interpreter code until the target 497 is done running, so delaying the output of "^running" until then 498 will make it impossible for frontend to know what's going on. 499 500 In future (MI3), we'll be outputting "^done" here. */ 501 if (!running_result_record_printed && mi_proceeded) 502 { 503 fprintf_unfiltered (raw_stdout, "%s^running\n", 504 current_token ? current_token : ""); 505 } 506 507 if (PIDGET (ptid) == -1) 508 fprintf_unfiltered (raw_stdout, "*running,thread-id=\"all\"\n"); 509 else if (ptid_is_pid (ptid)) 510 { 511 int count = 0; 512 513 /* Backwards compatibility. If there's only one inferior, 514 output "all", otherwise, output each resumed thread 515 individually. */ 516 iterate_over_inferiors (mi_inferior_count, &count); 517 518 if (count == 1) 519 fprintf_unfiltered (raw_stdout, "*running,thread-id=\"all\"\n"); 520 else 521 iterate_over_threads (mi_output_running_pid, &ptid); 522 } 523 else 524 { 525 struct thread_info *ti = find_thread_ptid (ptid); 526 527 gdb_assert (ti); 528 fprintf_unfiltered (raw_stdout, "*running,thread-id=\"%d\"\n", ti->num); 529 } 530 531 if (!running_result_record_printed && mi_proceeded) 532 { 533 running_result_record_printed = 1; 534 /* This is what gdb used to do historically -- printing prompt even if 535 it cannot actually accept any input. This will be surely removed 536 for MI3, and may be removed even earler. */ 537 /* FIXME: review the use of target_is_async_p here -- is that 538 what we want? */ 539 if (!target_is_async_p ()) 540 fputs_unfiltered ("(gdb) \n", raw_stdout); 541 } 542 gdb_flush (raw_stdout); 543 } 544 545 static void 546 mi_solib_loaded (struct so_list *solib) 547 { 548 struct mi_interp *mi = top_level_interpreter_data (); 549 550 target_terminal_ours (); 551 if (gdbarch_has_global_solist (target_gdbarch)) 552 fprintf_unfiltered (mi->event_channel, 553 "library-loaded,id=\"%s\",target-name=\"%s\"," 554 "host-name=\"%s\",symbols-loaded=\"%d\"", 555 solib->so_original_name, solib->so_original_name, 556 solib->so_name, solib->symbols_loaded); 557 else 558 fprintf_unfiltered (mi->event_channel, 559 "library-loaded,id=\"%s\",target-name=\"%s\"," 560 "host-name=\"%s\",symbols-loaded=\"%d\"," 561 "thread-group=\"i%d\"", 562 solib->so_original_name, solib->so_original_name, 563 solib->so_name, solib->symbols_loaded, 564 current_inferior ()->num); 565 566 gdb_flush (mi->event_channel); 567 } 568 569 static void 570 mi_solib_unloaded (struct so_list *solib) 571 { 572 struct mi_interp *mi = top_level_interpreter_data (); 573 574 target_terminal_ours (); 575 if (gdbarch_has_global_solist (target_gdbarch)) 576 fprintf_unfiltered (mi->event_channel, 577 "library-unloaded,id=\"%s\",target-name=\"%s\"," 578 "host-name=\"%s\"", 579 solib->so_original_name, solib->so_original_name, 580 solib->so_name); 581 else 582 fprintf_unfiltered (mi->event_channel, 583 "library-unloaded,id=\"%s\",target-name=\"%s\"," 584 "host-name=\"%s\",thread-group=\"i%d\"", 585 solib->so_original_name, solib->so_original_name, 586 solib->so_name, current_inferior ()->num); 587 588 gdb_flush (mi->event_channel); 589 } 590 591 static int 592 report_initial_inferior (struct inferior *inf, void *closure) 593 { 594 /* This function is called from mi_intepreter_init, and since 595 mi_inferior_added assumes that inferior is fully initialized 596 and top_level_interpreter_data is set, we cannot call 597 it here. */ 598 struct mi_interp *mi = closure; 599 600 target_terminal_ours (); 601 fprintf_unfiltered (mi->event_channel, 602 "thread-group-added,id=\"i%d\"", 603 inf->num); 604 gdb_flush (mi->event_channel); 605 return 0; 606 } 607 608 extern initialize_file_ftype _initialize_mi_interp; /* -Wmissing-prototypes */ 609 610 void 611 _initialize_mi_interp (void) 612 { 613 static const struct interp_procs procs = 614 { 615 mi_interpreter_init, /* init_proc */ 616 mi_interpreter_resume, /* resume_proc */ 617 mi_interpreter_suspend, /* suspend_proc */ 618 mi_interpreter_exec, /* exec_proc */ 619 mi_interpreter_prompt_p /* prompt_proc_p */ 620 }; 621 622 /* The various interpreter levels. */ 623 interp_add (interp_new (INTERP_MI1, NULL, mi_out_new (1), &procs)); 624 interp_add (interp_new (INTERP_MI2, NULL, mi_out_new (2), &procs)); 625 interp_add (interp_new (INTERP_MI3, NULL, mi_out_new (3), &procs)); 626 627 /* "mi" selects the most recent released version. "mi2" was 628 released as part of GDB 6.0. */ 629 interp_add (interp_new (INTERP_MI, NULL, mi_out_new (2), &procs)); 630 } 631