gdb/mi/mi-interp.c

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