1 /* MI Interpreter Definitions and Commands for GDB, the GNU debugger. 2 3 Copyright (C) 2002-2013 Free Software Foundation, Inc. 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 "defs.h" 21 #include "gdb_string.h" 22 #include "interps.h" 23 #include "event-top.h" 24 #include "event-loop.h" 25 #include "inferior.h" 26 #include "ui-out.h" 27 #include "top.h" 28 #include "exceptions.h" 29 #include "mi-main.h" 30 #include "mi-cmds.h" 31 #include "mi-out.h" 32 #include "mi-console.h" 33 #include "mi-common.h" 34 #include "observer.h" 35 #include "gdbthread.h" 36 #include "solist.h" 37 #include "gdb.h" 38 #include "objfiles.h" 39 #include "tracepoint.h" 40 41 /* These are the interpreter setup, etc. functions for the MI 42 interpreter. */ 43 44 static void mi_execute_command_wrapper (const char *cmd); 45 static void mi_execute_command_input_handler (char *cmd); 46 static void mi_command_loop (int mi_version); 47 48 /* These are hooks that we put in place while doing interpreter_exec 49 so we can report interesting things that happened "behind the MI's 50 back" in this command. */ 51 52 static int mi_interp_query_hook (const char *ctlstr, va_list ap) 53 ATTRIBUTE_PRINTF (1, 0); 54 55 static void mi3_command_loop (void); 56 static void mi2_command_loop (void); 57 static void mi1_command_loop (void); 58 59 static void mi_insert_notify_hooks (void); 60 static void mi_remove_notify_hooks (void); 61 static void mi_on_normal_stop (struct bpstats *bs, int print_frame); 62 63 static void mi_new_thread (struct thread_info *t); 64 static void mi_thread_exit (struct thread_info *t, int silent); 65 static void mi_record_changed (struct inferior*, int); 66 static void mi_inferior_added (struct inferior *inf); 67 static void mi_inferior_appeared (struct inferior *inf); 68 static void mi_inferior_exit (struct inferior *inf); 69 static void mi_inferior_removed (struct inferior *inf); 70 static void mi_on_resume (ptid_t ptid); 71 static void mi_solib_loaded (struct so_list *solib); 72 static void mi_solib_unloaded (struct so_list *solib); 73 static void mi_about_to_proceed (void); 74 static void mi_traceframe_changed (int tfnum, int tpnum); 75 static void mi_tsv_created (const struct trace_state_variable *tsv); 76 static void mi_tsv_deleted (const struct trace_state_variable *tsv); 77 static void mi_tsv_modified (const struct trace_state_variable *tsv); 78 static void mi_breakpoint_created (struct breakpoint *b); 79 static void mi_breakpoint_deleted (struct breakpoint *b); 80 static void mi_breakpoint_modified (struct breakpoint *b); 81 static void mi_command_param_changed (const char *param, const char *value); 82 static void mi_memory_changed (struct inferior *inf, CORE_ADDR memaddr, 83 ssize_t len, const bfd_byte *myaddr); 84 85 static int report_initial_inferior (struct inferior *inf, void *closure); 86 87 static void * 88 mi_interpreter_init (struct interp *interp, int top_level) 89 { 90 struct mi_interp *mi = XMALLOC (struct mi_interp); 91 const char *name; 92 int mi_version; 93 94 /* Assign the output channel created at startup to its own global, 95 so that we can create a console channel that encapsulates and 96 prefixes all gdb_output-type bits coming from the rest of the 97 debugger. */ 98 99 raw_stdout = gdb_stdout; 100 101 /* Create MI console channels, each with a different prefix so they 102 can be distinguished. */ 103 mi->out = mi_console_file_new (raw_stdout, "~", '"'); 104 mi->err = mi_console_file_new (raw_stdout, "&", '"'); 105 mi->log = mi->err; 106 mi->targ = mi_console_file_new (raw_stdout, "@", '"'); 107 mi->event_channel = mi_console_file_new (raw_stdout, "=", 0); 108 109 name = interp_name (interp); 110 /* INTERP_MI selects the most recent released version. "mi2" was 111 released as part of GDB 6.0. */ 112 if (strcmp (name, INTERP_MI) == 0) 113 mi_version = 2; 114 else if (strcmp (name, INTERP_MI1) == 0) 115 mi_version = 1; 116 else if (strcmp (name, INTERP_MI2) == 0) 117 mi_version = 2; 118 else if (strcmp (name, INTERP_MI3) == 0) 119 mi_version = 3; 120 else 121 gdb_assert_not_reached ("unhandled MI version"); 122 123 mi->uiout = mi_out_new (mi_version); 124 125 if (top_level) 126 { 127 observer_attach_new_thread (mi_new_thread); 128 observer_attach_thread_exit (mi_thread_exit); 129 observer_attach_inferior_added (mi_inferior_added); 130 observer_attach_inferior_appeared (mi_inferior_appeared); 131 observer_attach_inferior_exit (mi_inferior_exit); 132 observer_attach_inferior_removed (mi_inferior_removed); 133 observer_attach_record_changed (mi_record_changed); 134 observer_attach_normal_stop (mi_on_normal_stop); 135 observer_attach_target_resumed (mi_on_resume); 136 observer_attach_solib_loaded (mi_solib_loaded); 137 observer_attach_solib_unloaded (mi_solib_unloaded); 138 observer_attach_about_to_proceed (mi_about_to_proceed); 139 observer_attach_traceframe_changed (mi_traceframe_changed); 140 observer_attach_tsv_created (mi_tsv_created); 141 observer_attach_tsv_deleted (mi_tsv_deleted); 142 observer_attach_tsv_modified (mi_tsv_modified); 143 observer_attach_breakpoint_created (mi_breakpoint_created); 144 observer_attach_breakpoint_deleted (mi_breakpoint_deleted); 145 observer_attach_breakpoint_modified (mi_breakpoint_modified); 146 observer_attach_command_param_changed (mi_command_param_changed); 147 observer_attach_memory_changed (mi_memory_changed); 148 149 /* The initial inferior is created before this function is 150 called, so we need to report it explicitly. Use iteration in 151 case future version of GDB creates more than one inferior 152 up-front. */ 153 iterate_over_inferiors (report_initial_inferior, mi); 154 } 155 156 return mi; 157 } 158 159 static int 160 mi_interpreter_resume (void *data) 161 { 162 struct mi_interp *mi = data; 163 164 /* As per hack note in mi_interpreter_init, swap in the output 165 channels... */ 166 gdb_setup_readline (); 167 168 /* These overwrite some of the initialization done in 169 _intialize_event_loop. */ 170 call_readline = gdb_readline2; 171 input_handler = mi_execute_command_input_handler; 172 add_file_handler (input_fd, stdin_event_handler, 0); 173 async_command_editing_p = 0; 174 /* FIXME: This is a total hack for now. PB's use of the MI 175 implicitly relies on a bug in the async support which allows 176 asynchronous commands to leak through the commmand loop. The bug 177 involves (but is not limited to) the fact that sync_execution was 178 erroneously initialized to 0. Duplicate by initializing it thus 179 here... */ 180 sync_execution = 0; 181 182 gdb_stdout = mi->out; 183 /* Route error and log output through the MI. */ 184 gdb_stderr = mi->err; 185 gdb_stdlog = mi->log; 186 /* Route target output through the MI. */ 187 gdb_stdtarg = mi->targ; 188 /* Route target error through the MI as well. */ 189 gdb_stdtargerr = mi->targ; 190 191 /* Replace all the hooks that we know about. There really needs to 192 be a better way of doing this... */ 193 clear_interpreter_hooks (); 194 195 deprecated_show_load_progress = mi_load_progress; 196 197 /* If we're _the_ interpreter, take control. */ 198 if (current_interp_named_p (INTERP_MI1)) 199 deprecated_command_loop_hook = mi1_command_loop; 200 else if (current_interp_named_p (INTERP_MI2)) 201 deprecated_command_loop_hook = mi2_command_loop; 202 else if (current_interp_named_p (INTERP_MI3)) 203 deprecated_command_loop_hook = mi3_command_loop; 204 else 205 deprecated_command_loop_hook = mi2_command_loop; 206 207 return 1; 208 } 209 210 static int 211 mi_interpreter_suspend (void *data) 212 { 213 gdb_disable_readline (); 214 return 1; 215 } 216 217 static struct gdb_exception 218 mi_interpreter_exec (void *data, const char *command) 219 { 220 mi_execute_command_wrapper (command); 221 return exception_none; 222 } 223 224 /* Never display the default GDB prompt in MI case. */ 225 226 static int 227 mi_interpreter_prompt_p (void *data) 228 { 229 return 0; 230 } 231 232 void 233 mi_cmd_interpreter_exec (char *command, char **argv, int argc) 234 { 235 struct interp *interp_to_use; 236 int i; 237 char *mi_error_message = NULL; 238 struct cleanup *old_chain; 239 240 if (argc < 2) 241 error (_("-interpreter-exec: " 242 "Usage: -interpreter-exec interp command")); 243 244 interp_to_use = interp_lookup (argv[0]); 245 if (interp_to_use == NULL) 246 error (_("-interpreter-exec: could not find interpreter \"%s\""), 247 argv[0]); 248 249 if (!interp_exec_p (interp_to_use)) 250 error (_("-interpreter-exec: interpreter \"%s\" " 251 "does not support command execution"), 252 argv[0]); 253 254 /* Insert the MI out hooks, making sure to also call the 255 interpreter's hooks if it has any. */ 256 /* KRS: We shouldn't need this... Events should be installed and 257 they should just ALWAYS fire something out down the MI 258 channel. */ 259 mi_insert_notify_hooks (); 260 261 /* Now run the code. */ 262 263 old_chain = make_cleanup (null_cleanup, 0); 264 for (i = 1; i < argc; i++) 265 { 266 struct gdb_exception e = interp_exec (interp_to_use, argv[i]); 267 268 if (e.reason < 0) 269 { 270 mi_error_message = xstrdup (e.message); 271 make_cleanup (xfree, mi_error_message); 272 break; 273 } 274 } 275 276 mi_remove_notify_hooks (); 277 278 if (mi_error_message != NULL) 279 error ("%s", mi_error_message); 280 do_cleanups (old_chain); 281 } 282 283 /* This inserts a number of hooks that are meant to produce 284 async-notify ("=") MI messages while running commands in another 285 interpreter using mi_interpreter_exec. The canonical use for this 286 is to allow access to the gdb CLI interpreter from within the MI, 287 while still producing MI style output when actions in the CLI 288 command change GDB's state. */ 289 290 static void 291 mi_insert_notify_hooks (void) 292 { 293 deprecated_query_hook = mi_interp_query_hook; 294 } 295 296 static void 297 mi_remove_notify_hooks (void) 298 { 299 deprecated_query_hook = NULL; 300 } 301 302 static int 303 mi_interp_query_hook (const char *ctlstr, va_list ap) 304 { 305 return 1; 306 } 307 308 static void 309 mi_execute_command_wrapper (const char *cmd) 310 { 311 mi_execute_command (cmd, stdin == instream); 312 } 313 314 /* mi_execute_command_wrapper wrapper suitable for INPUT_HANDLER. */ 315 316 static void 317 mi_execute_command_input_handler (char *cmd) 318 { 319 mi_execute_command_wrapper (cmd); 320 321 fputs_unfiltered ("(gdb) \n", raw_stdout); 322 gdb_flush (raw_stdout); 323 } 324 325 static void 326 mi1_command_loop (void) 327 { 328 mi_command_loop (1); 329 } 330 331 static void 332 mi2_command_loop (void) 333 { 334 mi_command_loop (2); 335 } 336 337 static void 338 mi3_command_loop (void) 339 { 340 mi_command_loop (3); 341 } 342 343 static void 344 mi_command_loop (int mi_version) 345 { 346 /* Turn off 8 bit strings in quoted output. Any character with the 347 high bit set is printed using C's octal format. */ 348 sevenbit_strings = 1; 349 350 /* Tell the world that we're alive. */ 351 fputs_unfiltered ("(gdb) \n", raw_stdout); 352 gdb_flush (raw_stdout); 353 354 start_event_loop (); 355 } 356 357 static void 358 mi_new_thread (struct thread_info *t) 359 { 360 struct mi_interp *mi = top_level_interpreter_data (); 361 struct inferior *inf = find_inferior_pid (ptid_get_pid (t->ptid)); 362 363 gdb_assert (inf); 364 365 fprintf_unfiltered (mi->event_channel, 366 "thread-created,id=\"%d\",group-id=\"i%d\"", 367 t->num, inf->num); 368 gdb_flush (mi->event_channel); 369 } 370 371 static void 372 mi_thread_exit (struct thread_info *t, int silent) 373 { 374 struct mi_interp *mi; 375 struct inferior *inf; 376 377 if (silent) 378 return; 379 380 inf = find_inferior_pid (ptid_get_pid (t->ptid)); 381 382 mi = top_level_interpreter_data (); 383 target_terminal_ours (); 384 fprintf_unfiltered (mi->event_channel, 385 "thread-exited,id=\"%d\",group-id=\"i%d\"", 386 t->num, inf->num); 387 gdb_flush (mi->event_channel); 388 } 389 390 /* Emit notification on changing the state of record. */ 391 392 static void 393 mi_record_changed (struct inferior *inferior, int started) 394 { 395 struct mi_interp *mi = top_level_interpreter_data (); 396 397 fprintf_unfiltered (mi->event_channel, "record-%s,thread-group=\"i%d\"", 398 started ? "started" : "stopped", inferior->num); 399 400 gdb_flush (mi->event_channel); 401 } 402 403 static void 404 mi_inferior_added (struct inferior *inf) 405 { 406 struct mi_interp *mi = top_level_interpreter_data (); 407 408 target_terminal_ours (); 409 fprintf_unfiltered (mi->event_channel, 410 "thread-group-added,id=\"i%d\"", 411 inf->num); 412 gdb_flush (mi->event_channel); 413 } 414 415 static void 416 mi_inferior_appeared (struct inferior *inf) 417 { 418 struct mi_interp *mi = top_level_interpreter_data (); 419 420 target_terminal_ours (); 421 fprintf_unfiltered (mi->event_channel, 422 "thread-group-started,id=\"i%d\",pid=\"%d\"", 423 inf->num, inf->pid); 424 gdb_flush (mi->event_channel); 425 } 426 427 static void 428 mi_inferior_exit (struct inferior *inf) 429 { 430 struct mi_interp *mi = top_level_interpreter_data (); 431 432 target_terminal_ours (); 433 if (inf->has_exit_code) 434 fprintf_unfiltered (mi->event_channel, 435 "thread-group-exited,id=\"i%d\",exit-code=\"%s\"", 436 inf->num, int_string (inf->exit_code, 8, 0, 0, 1)); 437 else 438 fprintf_unfiltered (mi->event_channel, 439 "thread-group-exited,id=\"i%d\"", inf->num); 440 441 gdb_flush (mi->event_channel); 442 } 443 444 static void 445 mi_inferior_removed (struct inferior *inf) 446 { 447 struct mi_interp *mi = top_level_interpreter_data (); 448 449 target_terminal_ours (); 450 fprintf_unfiltered (mi->event_channel, 451 "thread-group-removed,id=\"i%d\"", 452 inf->num); 453 gdb_flush (mi->event_channel); 454 } 455 456 static void 457 mi_on_normal_stop (struct bpstats *bs, int print_frame) 458 { 459 /* Since this can be called when CLI command is executing, 460 using cli interpreter, be sure to use MI uiout for output, 461 not the current one. */ 462 struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ()); 463 464 if (print_frame) 465 { 466 int core; 467 468 if (current_uiout != mi_uiout) 469 { 470 /* The normal_stop function has printed frame information 471 into CLI uiout, or some other non-MI uiout. There's no 472 way we can extract proper fields from random uiout 473 object, so we print the frame again. In practice, this 474 can only happen when running a CLI command in MI. */ 475 struct ui_out *saved_uiout = current_uiout; 476 struct target_waitstatus last; 477 ptid_t last_ptid; 478 479 current_uiout = mi_uiout; 480 481 get_last_target_status (&last_ptid, &last); 482 bpstat_print (bs, last.kind); 483 484 print_stack_frame (get_selected_frame (NULL), 0, SRC_AND_LOC); 485 current_uiout = saved_uiout; 486 } 487 488 ui_out_field_int (mi_uiout, "thread-id", 489 pid_to_thread_id (inferior_ptid)); 490 if (non_stop) 491 { 492 struct cleanup *back_to = make_cleanup_ui_out_list_begin_end 493 (mi_uiout, "stopped-threads"); 494 495 ui_out_field_int (mi_uiout, NULL, 496 pid_to_thread_id (inferior_ptid)); 497 do_cleanups (back_to); 498 } 499 else 500 ui_out_field_string (mi_uiout, "stopped-threads", "all"); 501 502 core = target_core_of_thread (inferior_ptid); 503 if (core != -1) 504 ui_out_field_int (mi_uiout, "core", core); 505 } 506 507 fputs_unfiltered ("*stopped", raw_stdout); 508 mi_out_put (mi_uiout, raw_stdout); 509 mi_out_rewind (mi_uiout); 510 mi_print_timing_maybe (); 511 fputs_unfiltered ("\n", raw_stdout); 512 gdb_flush (raw_stdout); 513 } 514 515 static void 516 mi_about_to_proceed (void) 517 { 518 /* Suppress output while calling an inferior function. */ 519 520 if (!ptid_equal (inferior_ptid, null_ptid)) 521 { 522 struct thread_info *tp = inferior_thread (); 523 524 if (tp->control.in_infcall) 525 return; 526 } 527 528 mi_proceeded = 1; 529 } 530 531 /* When the element is non-zero, no MI notifications will be emitted in 532 response to the corresponding observers. */ 533 534 struct mi_suppress_notification mi_suppress_notification = 535 { 536 0, 537 0, 538 0, 539 }; 540 541 /* Emit notification on changing a traceframe. */ 542 543 static void 544 mi_traceframe_changed (int tfnum, int tpnum) 545 { 546 struct mi_interp *mi = top_level_interpreter_data (); 547 548 if (mi_suppress_notification.traceframe) 549 return; 550 551 target_terminal_ours (); 552 553 if (tfnum >= 0) 554 fprintf_unfiltered (mi->event_channel, "traceframe-changed," 555 "num=\"%d\",tracepoint=\"%d\"\n", 556 tfnum, tpnum); 557 else 558 fprintf_unfiltered (mi->event_channel, "traceframe-changed,end"); 559 560 gdb_flush (mi->event_channel); 561 } 562 563 /* Emit notification on creating a trace state variable. */ 564 565 static void 566 mi_tsv_created (const struct trace_state_variable *tsv) 567 { 568 struct mi_interp *mi = top_level_interpreter_data (); 569 570 target_terminal_ours (); 571 572 fprintf_unfiltered (mi->event_channel, "tsv-created," 573 "name=\"%s\",initial=\"%s\"\n", 574 tsv->name, plongest (tsv->initial_value)); 575 576 gdb_flush (mi->event_channel); 577 } 578 579 /* Emit notification on deleting a trace state variable. */ 580 581 static void 582 mi_tsv_deleted (const struct trace_state_variable *tsv) 583 { 584 struct mi_interp *mi = top_level_interpreter_data (); 585 586 target_terminal_ours (); 587 588 if (tsv != NULL) 589 fprintf_unfiltered (mi->event_channel, "tsv-deleted," 590 "name=\"%s\"\n", tsv->name); 591 else 592 fprintf_unfiltered (mi->event_channel, "tsv-deleted\n"); 593 594 gdb_flush (mi->event_channel); 595 } 596 597 /* Emit notification on modifying a trace state variable. */ 598 599 static void 600 mi_tsv_modified (const struct trace_state_variable *tsv) 601 { 602 struct mi_interp *mi = top_level_interpreter_data (); 603 struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ()); 604 605 target_terminal_ours (); 606 607 fprintf_unfiltered (mi->event_channel, 608 "tsv-modified"); 609 610 ui_out_redirect (mi_uiout, mi->event_channel); 611 612 ui_out_field_string (mi_uiout, "name", tsv->name); 613 ui_out_field_string (mi_uiout, "initial", 614 plongest (tsv->initial_value)); 615 if (tsv->value_known) 616 ui_out_field_string (mi_uiout, "current", plongest (tsv->value)); 617 618 ui_out_redirect (mi_uiout, NULL); 619 620 gdb_flush (mi->event_channel); 621 } 622 623 /* Emit notification about a created breakpoint. */ 624 625 static void 626 mi_breakpoint_created (struct breakpoint *b) 627 { 628 struct mi_interp *mi = top_level_interpreter_data (); 629 struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ()); 630 volatile struct gdb_exception e; 631 632 if (mi_suppress_notification.breakpoint) 633 return; 634 635 if (b->number <= 0) 636 return; 637 638 target_terminal_ours (); 639 fprintf_unfiltered (mi->event_channel, 640 "breakpoint-created"); 641 /* We want the output from gdb_breakpoint_query to go to 642 mi->event_channel. One approach would be to just call 643 gdb_breakpoint_query, and then use mi_out_put to send the current 644 content of mi_outout into mi->event_channel. However, that will 645 break if anything is output to mi_uiout prior to calling the 646 breakpoint_created notifications. So, we use 647 ui_out_redirect. */ 648 ui_out_redirect (mi_uiout, mi->event_channel); 649 TRY_CATCH (e, RETURN_MASK_ERROR) 650 gdb_breakpoint_query (mi_uiout, b->number, NULL); 651 ui_out_redirect (mi_uiout, NULL); 652 653 gdb_flush (mi->event_channel); 654 } 655 656 /* Emit notification about deleted breakpoint. */ 657 658 static void 659 mi_breakpoint_deleted (struct breakpoint *b) 660 { 661 struct mi_interp *mi = top_level_interpreter_data (); 662 663 if (mi_suppress_notification.breakpoint) 664 return; 665 666 if (b->number <= 0) 667 return; 668 669 target_terminal_ours (); 670 671 fprintf_unfiltered (mi->event_channel, "breakpoint-deleted,id=\"%d\"", 672 b->number); 673 674 gdb_flush (mi->event_channel); 675 } 676 677 /* Emit notification about modified breakpoint. */ 678 679 static void 680 mi_breakpoint_modified (struct breakpoint *b) 681 { 682 struct mi_interp *mi = top_level_interpreter_data (); 683 struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ()); 684 volatile struct gdb_exception e; 685 686 if (mi_suppress_notification.breakpoint) 687 return; 688 689 if (b->number <= 0) 690 return; 691 692 target_terminal_ours (); 693 fprintf_unfiltered (mi->event_channel, 694 "breakpoint-modified"); 695 /* We want the output from gdb_breakpoint_query to go to 696 mi->event_channel. One approach would be to just call 697 gdb_breakpoint_query, and then use mi_out_put to send the current 698 content of mi_outout into mi->event_channel. However, that will 699 break if anything is output to mi_uiout prior to calling the 700 breakpoint_created notifications. So, we use 701 ui_out_redirect. */ 702 ui_out_redirect (mi_uiout, mi->event_channel); 703 TRY_CATCH (e, RETURN_MASK_ERROR) 704 gdb_breakpoint_query (mi_uiout, b->number, NULL); 705 ui_out_redirect (mi_uiout, NULL); 706 707 gdb_flush (mi->event_channel); 708 } 709 710 static int 711 mi_output_running_pid (struct thread_info *info, void *arg) 712 { 713 ptid_t *ptid = arg; 714 715 if (ptid_get_pid (*ptid) == ptid_get_pid (info->ptid)) 716 fprintf_unfiltered (raw_stdout, 717 "*running,thread-id=\"%d\"\n", 718 info->num); 719 720 return 0; 721 } 722 723 static int 724 mi_inferior_count (struct inferior *inf, void *arg) 725 { 726 if (inf->pid != 0) 727 { 728 int *count_p = arg; 729 (*count_p)++; 730 } 731 732 return 0; 733 } 734 735 static void 736 mi_on_resume (ptid_t ptid) 737 { 738 struct thread_info *tp = NULL; 739 740 if (ptid_equal (ptid, minus_one_ptid) || ptid_is_pid (ptid)) 741 tp = inferior_thread (); 742 else 743 tp = find_thread_ptid (ptid); 744 745 /* Suppress output while calling an inferior function. */ 746 if (tp->control.in_infcall) 747 return; 748 749 /* To cater for older frontends, emit ^running, but do it only once 750 per each command. We do it here, since at this point we know 751 that the target was successfully resumed, and in non-async mode, 752 we won't return back to MI interpreter code until the target 753 is done running, so delaying the output of "^running" until then 754 will make it impossible for frontend to know what's going on. 755 756 In future (MI3), we'll be outputting "^done" here. */ 757 if (!running_result_record_printed && mi_proceeded) 758 { 759 fprintf_unfiltered (raw_stdout, "%s^running\n", 760 current_token ? current_token : ""); 761 } 762 763 if (PIDGET (ptid) == -1) 764 fprintf_unfiltered (raw_stdout, "*running,thread-id=\"all\"\n"); 765 else if (ptid_is_pid (ptid)) 766 { 767 int count = 0; 768 769 /* Backwards compatibility. If there's only one inferior, 770 output "all", otherwise, output each resumed thread 771 individually. */ 772 iterate_over_inferiors (mi_inferior_count, &count); 773 774 if (count == 1) 775 fprintf_unfiltered (raw_stdout, "*running,thread-id=\"all\"\n"); 776 else 777 iterate_over_threads (mi_output_running_pid, &ptid); 778 } 779 else 780 { 781 struct thread_info *ti = find_thread_ptid (ptid); 782 783 gdb_assert (ti); 784 fprintf_unfiltered (raw_stdout, "*running,thread-id=\"%d\"\n", ti->num); 785 } 786 787 if (!running_result_record_printed && mi_proceeded) 788 { 789 running_result_record_printed = 1; 790 /* This is what gdb used to do historically -- printing prompt even if 791 it cannot actually accept any input. This will be surely removed 792 for MI3, and may be removed even earler. */ 793 /* FIXME: review the use of target_is_async_p here -- is that 794 what we want? */ 795 if (!target_is_async_p ()) 796 fputs_unfiltered ("(gdb) \n", raw_stdout); 797 } 798 gdb_flush (raw_stdout); 799 } 800 801 static void 802 mi_solib_loaded (struct so_list *solib) 803 { 804 struct mi_interp *mi = top_level_interpreter_data (); 805 806 target_terminal_ours (); 807 if (gdbarch_has_global_solist (target_gdbarch ())) 808 fprintf_unfiltered (mi->event_channel, 809 "library-loaded,id=\"%s\",target-name=\"%s\"," 810 "host-name=\"%s\",symbols-loaded=\"%d\"", 811 solib->so_original_name, solib->so_original_name, 812 solib->so_name, solib->symbols_loaded); 813 else 814 fprintf_unfiltered (mi->event_channel, 815 "library-loaded,id=\"%s\",target-name=\"%s\"," 816 "host-name=\"%s\",symbols-loaded=\"%d\"," 817 "thread-group=\"i%d\"", 818 solib->so_original_name, solib->so_original_name, 819 solib->so_name, solib->symbols_loaded, 820 current_inferior ()->num); 821 822 gdb_flush (mi->event_channel); 823 } 824 825 static void 826 mi_solib_unloaded (struct so_list *solib) 827 { 828 struct mi_interp *mi = top_level_interpreter_data (); 829 830 target_terminal_ours (); 831 if (gdbarch_has_global_solist (target_gdbarch ())) 832 fprintf_unfiltered (mi->event_channel, 833 "library-unloaded,id=\"%s\",target-name=\"%s\"," 834 "host-name=\"%s\"", 835 solib->so_original_name, solib->so_original_name, 836 solib->so_name); 837 else 838 fprintf_unfiltered (mi->event_channel, 839 "library-unloaded,id=\"%s\",target-name=\"%s\"," 840 "host-name=\"%s\",thread-group=\"i%d\"", 841 solib->so_original_name, solib->so_original_name, 842 solib->so_name, current_inferior ()->num); 843 844 gdb_flush (mi->event_channel); 845 } 846 847 /* Emit notification about the command parameter change. */ 848 849 static void 850 mi_command_param_changed (const char *param, const char *value) 851 { 852 struct mi_interp *mi = top_level_interpreter_data (); 853 struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ()); 854 855 if (mi_suppress_notification.cmd_param_changed) 856 return; 857 858 target_terminal_ours (); 859 860 fprintf_unfiltered (mi->event_channel, 861 "cmd-param-changed"); 862 863 ui_out_redirect (mi_uiout, mi->event_channel); 864 865 ui_out_field_string (mi_uiout, "param", param); 866 ui_out_field_string (mi_uiout, "value", value); 867 868 ui_out_redirect (mi_uiout, NULL); 869 870 gdb_flush (mi->event_channel); 871 } 872 873 /* Emit notification about the target memory change. */ 874 875 static void 876 mi_memory_changed (struct inferior *inferior, CORE_ADDR memaddr, 877 ssize_t len, const bfd_byte *myaddr) 878 { 879 struct mi_interp *mi = top_level_interpreter_data (); 880 struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ()); 881 struct obj_section *sec; 882 883 if (mi_suppress_notification.memory) 884 return; 885 886 target_terminal_ours (); 887 888 fprintf_unfiltered (mi->event_channel, 889 "memory-changed"); 890 891 ui_out_redirect (mi_uiout, mi->event_channel); 892 893 ui_out_field_fmt (mi_uiout, "thread-group", "i%d", inferior->num); 894 ui_out_field_core_addr (mi_uiout, "addr", target_gdbarch (), memaddr); 895 ui_out_field_fmt (mi_uiout, "len", "0x%zx", len); 896 897 /* Append 'type=code' into notification if MEMADDR falls in the range of 898 sections contain code. */ 899 sec = find_pc_section (memaddr); 900 if (sec != NULL && sec->objfile != NULL) 901 { 902 flagword flags = bfd_get_section_flags (sec->objfile->obfd, 903 sec->the_bfd_section); 904 905 if (flags & SEC_CODE) 906 ui_out_field_string (mi_uiout, "type", "code"); 907 } 908 909 ui_out_redirect (mi_uiout, NULL); 910 911 gdb_flush (mi->event_channel); 912 } 913 914 static int 915 report_initial_inferior (struct inferior *inf, void *closure) 916 { 917 /* This function is called from mi_intepreter_init, and since 918 mi_inferior_added assumes that inferior is fully initialized 919 and top_level_interpreter_data is set, we cannot call 920 it here. */ 921 struct mi_interp *mi = closure; 922 923 target_terminal_ours (); 924 fprintf_unfiltered (mi->event_channel, 925 "thread-group-added,id=\"i%d\"", 926 inf->num); 927 gdb_flush (mi->event_channel); 928 return 0; 929 } 930 931 static struct ui_out * 932 mi_ui_out (struct interp *interp) 933 { 934 struct mi_interp *mi = interp_data (interp); 935 936 return mi->uiout; 937 } 938 939 /* Save the original value of raw_stdout here when logging, so we can 940 restore correctly when done. */ 941 942 static struct ui_file *saved_raw_stdout; 943 944 /* Do MI-specific logging actions; save raw_stdout, and change all 945 the consoles to use the supplied ui-file(s). */ 946 947 static int 948 mi_set_logging (struct interp *interp, int start_log, 949 struct ui_file *out, struct ui_file *logfile) 950 { 951 struct mi_interp *mi = interp_data (interp); 952 953 if (!mi) 954 return 0; 955 956 if (start_log) 957 { 958 /* The tee created already is based on gdb_stdout, which for MI 959 is a console and so we end up in an infinite loop of console 960 writing to ui_file writing to console etc. So discard the 961 existing tee (it hasn't been used yet, and MI won't ever use 962 it), and create one based on raw_stdout instead. */ 963 if (logfile) 964 { 965 ui_file_delete (out); 966 out = tee_file_new (raw_stdout, 0, logfile, 0); 967 } 968 969 saved_raw_stdout = raw_stdout; 970 raw_stdout = out; 971 } 972 else 973 { 974 raw_stdout = saved_raw_stdout; 975 saved_raw_stdout = NULL; 976 } 977 978 mi_console_set_raw (mi->out, raw_stdout); 979 mi_console_set_raw (mi->err, raw_stdout); 980 mi_console_set_raw (mi->log, raw_stdout); 981 mi_console_set_raw (mi->targ, raw_stdout); 982 mi_console_set_raw (mi->event_channel, raw_stdout); 983 984 return 1; 985 } 986 987 extern initialize_file_ftype _initialize_mi_interp; /* -Wmissing-prototypes */ 988 989 void 990 _initialize_mi_interp (void) 991 { 992 static const struct interp_procs procs = 993 { 994 mi_interpreter_init, /* init_proc */ 995 mi_interpreter_resume, /* resume_proc */ 996 mi_interpreter_suspend, /* suspend_proc */ 997 mi_interpreter_exec, /* exec_proc */ 998 mi_interpreter_prompt_p, /* prompt_proc_p */ 999 mi_ui_out, /* ui_out_proc */ 1000 mi_set_logging /* set_logging_proc */ 1001 }; 1002 1003 /* The various interpreter levels. */ 1004 interp_add (interp_new (INTERP_MI1, &procs)); 1005 interp_add (interp_new (INTERP_MI2, &procs)); 1006 interp_add (interp_new (INTERP_MI3, &procs)); 1007 interp_add (interp_new (INTERP_MI, &procs)); 1008 } 1009