1 /* MI Interpreter Definitions and Commands for GDB, the GNU debugger. 2 3 Copyright (C) 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010 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 ("mi_cmd_interpreter_exec: Usage: -interpreter-exec interp command"); 196 197 interp_to_use = interp_lookup (argv[0]); 198 if (interp_to_use == NULL) 199 error ("mi_cmd_interpreter_exec: could not find interpreter \"%s\"", argv[0]); 200 201 if (!interp_exec_p (interp_to_use)) 202 error ("mi_cmd_interpreter_exec: interpreter \"%s\" does not support command execution", 203 argv[0]); 204 205 /* Insert the MI out hooks, making sure to also call the interpreter's hooks 206 if it has any. */ 207 /* KRS: We shouldn't need this... Events should be installed and they should 208 just ALWAYS fire something out down the MI channel... */ 209 mi_insert_notify_hooks (); 210 211 /* Now run the code... */ 212 213 old_chain = make_cleanup (null_cleanup, 0); 214 for (i = 1; i < argc; i++) 215 { 216 struct gdb_exception e = interp_exec (interp_to_use, argv[i]); 217 218 if (e.reason < 0) 219 { 220 mi_error_message = xstrdup (e.message); 221 make_cleanup (xfree, mi_error_message); 222 break; 223 } 224 } 225 226 mi_remove_notify_hooks (); 227 228 if (mi_error_message != NULL) 229 error ("%s", mi_error_message); 230 do_cleanups (old_chain); 231 } 232 233 /* 234 * mi_insert_notify_hooks - This inserts a number of hooks that are meant to produce 235 * async-notify ("=") MI messages while running commands in another interpreter 236 * using mi_interpreter_exec. The canonical use for this is to allow access to 237 * the gdb CLI interpreter from within the MI, while still producing MI style output 238 * when actions in the CLI command change gdb's state. 239 */ 240 241 static void 242 mi_insert_notify_hooks (void) 243 { 244 deprecated_query_hook = mi_interp_query_hook; 245 } 246 247 static void 248 mi_remove_notify_hooks (void) 249 { 250 deprecated_query_hook = NULL; 251 } 252 253 static int 254 mi_interp_query_hook (const char *ctlstr, va_list ap) 255 { 256 return 1; 257 } 258 259 static void 260 mi_execute_command_wrapper (char *cmd) 261 { 262 mi_execute_command (cmd, stdin == instream); 263 } 264 265 static void 266 mi1_command_loop (void) 267 { 268 mi_command_loop (1); 269 } 270 271 static void 272 mi2_command_loop (void) 273 { 274 mi_command_loop (2); 275 } 276 277 static void 278 mi3_command_loop (void) 279 { 280 mi_command_loop (3); 281 } 282 283 static void 284 mi_command_loop (int mi_version) 285 { 286 /* Turn off 8 bit strings in quoted output. Any character with the 287 high bit set is printed using C's octal format. */ 288 sevenbit_strings = 1; 289 /* Tell the world that we're alive */ 290 fputs_unfiltered ("(gdb) \n", raw_stdout); 291 gdb_flush (raw_stdout); 292 start_event_loop (); 293 } 294 295 static void 296 mi_new_thread (struct thread_info *t) 297 { 298 struct mi_interp *mi = top_level_interpreter_data (); 299 struct inferior *inf = find_inferior_pid (ptid_get_pid (t->ptid)); 300 301 gdb_assert (inf); 302 303 fprintf_unfiltered (mi->event_channel, 304 "thread-created,id=\"%d\",group-id=\"i%d\"", 305 t->num, inf->num); 306 gdb_flush (mi->event_channel); 307 } 308 309 static void 310 mi_thread_exit (struct thread_info *t, int silent) 311 { 312 struct mi_interp *mi; 313 struct inferior *inf; 314 315 if (silent) 316 return; 317 318 inf = find_inferior_pid (ptid_get_pid (t->ptid)); 319 320 mi = top_level_interpreter_data (); 321 target_terminal_ours (); 322 fprintf_unfiltered (mi->event_channel, 323 "thread-exited,id=\"%d\",group-id=\"i%d\"", 324 t->num, inf->num); 325 gdb_flush (mi->event_channel); 326 } 327 328 static void 329 mi_inferior_added (struct inferior *inf) 330 { 331 struct mi_interp *mi = top_level_interpreter_data (); 332 333 target_terminal_ours (); 334 fprintf_unfiltered (mi->event_channel, 335 "thread-group-added,id=\"i%d\"", 336 inf->num); 337 gdb_flush (mi->event_channel); 338 } 339 340 static void 341 mi_inferior_appeared (struct inferior *inf) 342 { 343 struct mi_interp *mi = top_level_interpreter_data (); 344 345 target_terminal_ours (); 346 fprintf_unfiltered (mi->event_channel, 347 "thread-group-started,id=\"i%d\",pid=\"%d\"", 348 inf->num, inf->pid); 349 gdb_flush (mi->event_channel); 350 } 351 352 static void 353 mi_inferior_exit (struct inferior *inf) 354 { 355 struct mi_interp *mi = top_level_interpreter_data (); 356 357 target_terminal_ours (); 358 fprintf_unfiltered (mi->event_channel, "thread-group-exited,id=\"i%d\"", 359 inf->num); 360 gdb_flush (mi->event_channel); 361 } 362 363 static void 364 mi_inferior_removed (struct inferior *inf) 365 { 366 struct mi_interp *mi = top_level_interpreter_data (); 367 368 target_terminal_ours (); 369 fprintf_unfiltered (mi->event_channel, 370 "thread-group-removed,id=\"i%d\"", 371 inf->num); 372 gdb_flush (mi->event_channel); 373 } 374 375 static void 376 mi_on_normal_stop (struct bpstats *bs, int print_frame) 377 { 378 /* Since this can be called when CLI command is executing, 379 using cli interpreter, be sure to use MI uiout for output, 380 not the current one. */ 381 struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ()); 382 383 if (print_frame) 384 { 385 int core; 386 387 if (uiout != mi_uiout) 388 { 389 /* The normal_stop function has printed frame information into 390 CLI uiout, or some other non-MI uiout. There's no way we 391 can extract proper fields from random uiout object, so we print 392 the frame again. In practice, this can only happen when running 393 a CLI command in MI. */ 394 struct ui_out *saved_uiout = uiout; 395 396 uiout = mi_uiout; 397 print_stack_frame (get_selected_frame (NULL), 0, SRC_AND_LOC); 398 uiout = saved_uiout; 399 } 400 401 ui_out_field_int (mi_uiout, "thread-id", 402 pid_to_thread_id (inferior_ptid)); 403 if (non_stop) 404 { 405 struct cleanup *back_to = make_cleanup_ui_out_list_begin_end 406 (mi_uiout, "stopped-threads"); 407 408 ui_out_field_int (mi_uiout, NULL, 409 pid_to_thread_id (inferior_ptid)); 410 do_cleanups (back_to); 411 } 412 else 413 ui_out_field_string (mi_uiout, "stopped-threads", "all"); 414 415 core = target_core_of_thread (inferior_ptid); 416 if (core != -1) 417 ui_out_field_int (mi_uiout, "core", core); 418 } 419 420 fputs_unfiltered ("*stopped", raw_stdout); 421 mi_out_put (mi_uiout, raw_stdout); 422 mi_out_rewind (mi_uiout); 423 mi_print_timing_maybe (); 424 fputs_unfiltered ("\n", raw_stdout); 425 gdb_flush (raw_stdout); 426 } 427 428 static void 429 mi_about_to_proceed (void) 430 { 431 /* Suppress output while calling an inferior function. */ 432 433 if (!ptid_equal (inferior_ptid, null_ptid)) 434 { 435 struct thread_info *tp = inferior_thread (); 436 437 if (tp->in_infcall) 438 return; 439 } 440 441 mi_proceeded = 1; 442 } 443 444 static int 445 mi_output_running_pid (struct thread_info *info, void *arg) 446 { 447 ptid_t *ptid = arg; 448 449 if (ptid_get_pid (*ptid) == ptid_get_pid (info->ptid)) 450 fprintf_unfiltered (raw_stdout, 451 "*running,thread-id=\"%d\"\n", 452 info->num); 453 454 return 0; 455 } 456 457 static int 458 mi_inferior_count (struct inferior *inf, void *arg) 459 { 460 if (inf->pid != 0) 461 { 462 int *count_p = arg; 463 (*count_p)++; 464 } 465 466 return 0; 467 } 468 469 static void 470 mi_on_resume (ptid_t ptid) 471 { 472 struct thread_info *tp = NULL; 473 474 if (ptid_equal (ptid, minus_one_ptid) || ptid_is_pid (ptid)) 475 tp = inferior_thread (); 476 else 477 tp = find_thread_ptid (ptid); 478 479 /* Suppress output while calling an inferior function. */ 480 if (tp->in_infcall) 481 return; 482 483 /* To cater for older frontends, emit ^running, but do it only once 484 per each command. We do it here, since at this point we know 485 that the target was successfully resumed, and in non-async mode, 486 we won't return back to MI interpreter code until the target 487 is done running, so delaying the output of "^running" until then 488 will make it impossible for frontend to know what's going on. 489 490 In future (MI3), we'll be outputting "^done" here. */ 491 if (!running_result_record_printed && mi_proceeded) 492 { 493 fprintf_unfiltered (raw_stdout, "%s^running\n", 494 current_token ? current_token : ""); 495 } 496 497 if (PIDGET (ptid) == -1) 498 fprintf_unfiltered (raw_stdout, "*running,thread-id=\"all\"\n"); 499 else if (ptid_is_pid (ptid)) 500 { 501 int count = 0; 502 503 /* Backwards compatibility. If there's only one inferior, 504 output "all", otherwise, output each resumed thread 505 individually. */ 506 iterate_over_inferiors (mi_inferior_count, &count); 507 508 if (count == 1) 509 fprintf_unfiltered (raw_stdout, "*running,thread-id=\"all\"\n"); 510 else 511 iterate_over_threads (mi_output_running_pid, &ptid); 512 } 513 else 514 { 515 struct thread_info *ti = find_thread_ptid (ptid); 516 517 gdb_assert (ti); 518 fprintf_unfiltered (raw_stdout, "*running,thread-id=\"%d\"\n", ti->num); 519 } 520 521 if (!running_result_record_printed && mi_proceeded) 522 { 523 running_result_record_printed = 1; 524 /* This is what gdb used to do historically -- printing prompt even if 525 it cannot actually accept any input. This will be surely removed 526 for MI3, and may be removed even earler. */ 527 /* FIXME: review the use of target_is_async_p here -- is that 528 what we want? */ 529 if (!target_is_async_p ()) 530 fputs_unfiltered ("(gdb) \n", raw_stdout); 531 } 532 gdb_flush (raw_stdout); 533 } 534 535 static void 536 mi_solib_loaded (struct so_list *solib) 537 { 538 struct mi_interp *mi = top_level_interpreter_data (); 539 540 target_terminal_ours (); 541 if (gdbarch_has_global_solist (target_gdbarch)) 542 fprintf_unfiltered (mi->event_channel, 543 "library-loaded,id=\"%s\",target-name=\"%s\"," 544 "host-name=\"%s\",symbols-loaded=\"%d\"", 545 solib->so_original_name, solib->so_original_name, 546 solib->so_name, solib->symbols_loaded); 547 else 548 fprintf_unfiltered (mi->event_channel, 549 "library-loaded,id=\"%s\",target-name=\"%s\"," 550 "host-name=\"%s\",symbols-loaded=\"%d\"," 551 "thread-group=\"i%d\"", 552 solib->so_original_name, solib->so_original_name, 553 solib->so_name, solib->symbols_loaded, 554 current_inferior ()->num); 555 556 gdb_flush (mi->event_channel); 557 } 558 559 static void 560 mi_solib_unloaded (struct so_list *solib) 561 { 562 struct mi_interp *mi = top_level_interpreter_data (); 563 564 target_terminal_ours (); 565 if (gdbarch_has_global_solist (target_gdbarch)) 566 fprintf_unfiltered (mi->event_channel, 567 "library-unloaded,id=\"%s\",target-name=\"%s\"," 568 "host-name=\"%s\"", 569 solib->so_original_name, solib->so_original_name, 570 solib->so_name); 571 else 572 fprintf_unfiltered (mi->event_channel, 573 "library-unloaded,id=\"%s\",target-name=\"%s\"," 574 "host-name=\"%s\",thread-group=\"i%d\"", 575 solib->so_original_name, solib->so_original_name, 576 solib->so_name, current_inferior ()->num); 577 578 gdb_flush (mi->event_channel); 579 } 580 581 static int 582 report_initial_inferior (struct inferior *inf, void *closure) 583 { 584 /* This function is called from mi_intepreter_init, and since 585 mi_inferior_added assumes that inferior is fully initialized 586 and top_level_interpreter_data is set, we cannot call 587 it here. */ 588 struct mi_interp *mi = closure; 589 590 target_terminal_ours (); 591 fprintf_unfiltered (mi->event_channel, 592 "thread-group-added,id=\"i%d\"", 593 inf->num); 594 gdb_flush (mi->event_channel); 595 return 0; 596 } 597 598 extern initialize_file_ftype _initialize_mi_interp; /* -Wmissing-prototypes */ 599 600 void 601 _initialize_mi_interp (void) 602 { 603 static const struct interp_procs procs = 604 { 605 mi_interpreter_init, /* init_proc */ 606 mi_interpreter_resume, /* resume_proc */ 607 mi_interpreter_suspend, /* suspend_proc */ 608 mi_interpreter_exec, /* exec_proc */ 609 mi_interpreter_prompt_p /* prompt_proc_p */ 610 }; 611 612 /* The various interpreter levels. */ 613 interp_add (interp_new (INTERP_MI1, NULL, mi_out_new (1), &procs)); 614 interp_add (interp_new (INTERP_MI2, NULL, mi_out_new (2), &procs)); 615 interp_add (interp_new (INTERP_MI3, NULL, mi_out_new (3), &procs)); 616 617 /* "mi" selects the most recent released version. "mi2" was 618 released as part of GDB 6.0. */ 619 interp_add (interp_new (INTERP_MI, NULL, mi_out_new (2), &procs)); 620 } 621