gdb/mi/mi-interp.c

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