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_command_loop (int mi_version);
  44
  45 /* These are hooks that we put in place while doing interpreter_exec
  46    so we can report interesting things that happened "behind the MI's
  47    back" in this command.  */
  48
  49 static int mi_interp_query_hook (const char *ctlstr, va_list ap)
  50   ATTRIBUTE_PRINTF (1, 0);
  51
  52 static void mi3_command_loop (void);
  53 static void mi2_command_loop (void);
  54 static void mi1_command_loop (void);
  55
  56 static void mi_insert_notify_hooks (void);
  57 static void mi_remove_notify_hooks (void);
  58 static void mi_on_normal_stop (struct bpstats *bs, int print_frame);
  59
  60 static void mi_new_thread (struct thread_info *t);
  61 static void mi_thread_exit (struct thread_info *t, int silent);
  62 static void mi_inferior_added (struct inferior *inf);
  63 static void mi_inferior_appeared (struct inferior *inf);
  64 static void mi_inferior_exit (struct inferior *inf);
  65 static void mi_inferior_removed (struct inferior *inf);
  66 static void mi_on_resume (ptid_t ptid);
  67 static void mi_solib_loaded (struct so_list *solib);
  68 static void mi_solib_unloaded (struct so_list *solib);
  69 static void mi_about_to_proceed (void);
  70 static void mi_breakpoint_created (struct breakpoint *b);
  71 static void mi_breakpoint_deleted (struct breakpoint *b);
  72 static void mi_breakpoint_modified (struct breakpoint *b);
  73
  74 static int report_initial_inferior (struct inferior *inf, void *closure);
  75
  76 static void *
  77 mi_interpreter_init (struct interp *interp, int top_level)
  78 {
  79   struct mi_interp *mi = XMALLOC (struct mi_interp);
  80   const char *name;
  81   int mi_version;
  82
  83   /* HACK: We need to force stdout/stderr to point at the console.
  84      This avoids any potential side effects caused by legacy code that
  85      is still using the TUI / fputs_unfiltered_hook.  So we set up
  86      output channels for this now, and swap them in when we are
  87      run.  */
  88
  89   raw_stdout = stdio_fileopen (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_wrapper;
 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 static void
 301 mi1_command_loop (void)
 302 {
 303   mi_command_loop (1);
 304 }
 305
 306 static void
 307 mi2_command_loop (void)
 308 {
 309   mi_command_loop (2);
 310 }
 311
 312 static void
 313 mi3_command_loop (void)
 314 {
 315   mi_command_loop (3);
 316 }
 317
 318 static void
 319 mi_command_loop (int mi_version)
 320 {
 321   /* Turn off 8 bit strings in quoted output.  Any character with the
 322      high bit set is printed using C's octal format.  */
 323   sevenbit_strings = 1;
 324
 325   /* Tell the world that we're alive.  */
 326   fputs_unfiltered ("(gdb) \n", raw_stdout);
 327   gdb_flush (raw_stdout);
 328
 329   start_event_loop ();
 330 }
 331
 332 static void
 333 mi_new_thread (struct thread_info *t)
 334 {
 335   struct mi_interp *mi = top_level_interpreter_data ();
 336   struct inferior *inf = find_inferior_pid (ptid_get_pid (t->ptid));
 337
 338   gdb_assert (inf);
 339
 340   fprintf_unfiltered (mi->event_channel,
 341                       "thread-created,id=\"%d\",group-id=\"i%d\"",
 342                       t->num, inf->num);
 343   gdb_flush (mi->event_channel);
 344 }
 345
 346 static void
 347 mi_thread_exit (struct thread_info *t, int silent)
 348 {
 349   struct mi_interp *mi;
 350   struct inferior *inf;
 351
 352   if (silent)
 353     return;
 354
 355   inf = find_inferior_pid (ptid_get_pid (t->ptid));
 356
 357   mi = top_level_interpreter_data ();
 358   target_terminal_ours ();
 359   fprintf_unfiltered (mi->event_channel,
 360                       "thread-exited,id=\"%d\",group-id=\"i%d\"",
 361                       t->num, inf->num);
 362   gdb_flush (mi->event_channel);
 363 }
 364
 365 static void
 366 mi_inferior_added (struct inferior *inf)
 367 {
 368   struct mi_interp *mi = top_level_interpreter_data ();
 369
 370   target_terminal_ours ();
 371   fprintf_unfiltered (mi->event_channel,
 372                       "thread-group-added,id=\"i%d\"",
 373                       inf->num);
 374   gdb_flush (mi->event_channel);
 375 }
 376
 377 static void
 378 mi_inferior_appeared (struct inferior *inf)
 379 {
 380   struct mi_interp *mi = top_level_interpreter_data ();
 381
 382   target_terminal_ours ();
 383   fprintf_unfiltered (mi->event_channel,
 384                       "thread-group-started,id=\"i%d\",pid=\"%d\"",
 385                       inf->num, inf->pid);
 386   gdb_flush (mi->event_channel);
 387 }
 388
 389 static void
 390 mi_inferior_exit (struct inferior *inf)
 391 {
 392   struct mi_interp *mi = top_level_interpreter_data ();
 393
 394   target_terminal_ours ();
 395   if (inf->has_exit_code)
 396     fprintf_unfiltered (mi->event_channel,
 397                         "thread-group-exited,id=\"i%d\",exit-code=\"%s\"",
 398                         inf->num, int_string (inf->exit_code, 8, 0, 0, 1));
 399   else
 400     fprintf_unfiltered (mi->event_channel,
 401                         "thread-group-exited,id=\"i%d\"", inf->num);
 402
 403   gdb_flush (mi->event_channel);
 404 }
 405
 406 static void
 407 mi_inferior_removed (struct inferior *inf)
 408 {
 409   struct mi_interp *mi = top_level_interpreter_data ();
 410
 411   target_terminal_ours ();
 412   fprintf_unfiltered (mi->event_channel,
 413                       "thread-group-removed,id=\"i%d\"",
 414                       inf->num);
 415   gdb_flush (mi->event_channel);
 416 }
 417
 418 static void
 419 mi_on_normal_stop (struct bpstats *bs, int print_frame)
 420 {
 421   /* Since this can be called when CLI command is executing,
 422      using cli interpreter, be sure to use MI uiout for output,
 423      not the current one.  */
 424   struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ());
 425
 426   if (print_frame)
 427     {
 428       int core;
 429
 430       if (current_uiout != mi_uiout)
 431         {
 432           /* The normal_stop function has printed frame information
 433              into CLI uiout, or some other non-MI uiout.  There's no
 434              way we can extract proper fields from random uiout
 435              object, so we print the frame again.  In practice, this
 436              can only happen when running a CLI command in MI.  */
 437           struct ui_out *saved_uiout = current_uiout;
 438           struct target_waitstatus last;
 439           ptid_t last_ptid;
 440
 441           current_uiout = mi_uiout;
 442
 443           get_last_target_status (&last_ptid, &last);
 444           bpstat_print (bs, last.kind);
 445
 446           print_stack_frame (get_selected_frame (NULL), 0, SRC_AND_LOC);
 447           current_uiout = saved_uiout;
 448         }
 449
 450       ui_out_field_int (mi_uiout, "thread-id",
 451                         pid_to_thread_id (inferior_ptid));
 452       if (non_stop)
 453         {
 454           struct cleanup *back_to = make_cleanup_ui_out_list_begin_end
 455             (mi_uiout, "stopped-threads");
 456
 457           ui_out_field_int (mi_uiout, NULL,
 458                             pid_to_thread_id (inferior_ptid));
 459           do_cleanups (back_to);
 460         }
 461       else
 462         ui_out_field_string (mi_uiout, "stopped-threads", "all");
 463
 464       core = target_core_of_thread (inferior_ptid);
 465       if (core != -1)
 466         ui_out_field_int (mi_uiout, "core", core);
 467     }
 468
 469   fputs_unfiltered ("*stopped", raw_stdout);
 470   mi_out_put (mi_uiout, raw_stdout);
 471   mi_out_rewind (mi_uiout);
 472   mi_print_timing_maybe ();
 473   fputs_unfiltered ("\n", raw_stdout);
 474   gdb_flush (raw_stdout);
 475 }
 476
 477 static void
 478 mi_about_to_proceed (void)
 479 {
 480   /* Suppress output while calling an inferior function.  */
 481
 482   if (!ptid_equal (inferior_ptid, null_ptid))
 483     {
 484       struct thread_info *tp = inferior_thread ();
 485
 486       if (tp->control.in_infcall)
 487         return;
 488     }
 489
 490   mi_proceeded = 1;
 491 }
 492
 493 /* When non-zero, no MI notifications will be emitted in
 494    response to breakpoint change observers.  */
 495
 496 int mi_suppress_breakpoint_notifications = 0;
 497
 498 /* Emit notification about a created breakpoint.  */
 499
 500 static void
 501 mi_breakpoint_created (struct breakpoint *b)
 502 {
 503   struct mi_interp *mi = top_level_interpreter_data ();
 504   struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ());
 505   volatile struct gdb_exception e;
 506
 507   if (mi_suppress_breakpoint_notifications)
 508     return;
 509
 510   if (b->number <= 0)
 511     return;
 512
 513   target_terminal_ours ();
 514   fprintf_unfiltered (mi->event_channel,
 515                       "breakpoint-created");
 516   /* We want the output from gdb_breakpoint_query to go to
 517      mi->event_channel.  One approach would be to just call
 518      gdb_breakpoint_query, and then use mi_out_put to send the current
 519      content of mi_outout into mi->event_channel.  However, that will
 520      break if anything is output to mi_uiout prior to calling the
 521      breakpoint_created notifications.  So, we use
 522      ui_out_redirect.  */
 523   ui_out_redirect (mi_uiout, mi->event_channel);
 524   TRY_CATCH (e, RETURN_MASK_ERROR)
 525     gdb_breakpoint_query (mi_uiout, b->number, NULL);
 526   ui_out_redirect (mi_uiout, NULL);
 527
 528   gdb_flush (mi->event_channel);
 529 }
 530
 531 /* Emit notification about deleted breakpoint.  */
 532
 533 static void
 534 mi_breakpoint_deleted (struct breakpoint *b)
 535 {
 536   struct mi_interp *mi = top_level_interpreter_data ();
 537
 538   if (mi_suppress_breakpoint_notifications)
 539     return;
 540
 541   if (b->number <= 0)
 542     return;
 543
 544   target_terminal_ours ();
 545
 546   fprintf_unfiltered (mi->event_channel, "breakpoint-deleted,id=\"%d\"",
 547                       b->number);
 548
 549   gdb_flush (mi->event_channel);
 550 }
 551
 552 /* Emit notification about modified breakpoint.  */
 553
 554 static void
 555 mi_breakpoint_modified (struct breakpoint *b)
 556 {
 557   struct mi_interp *mi = top_level_interpreter_data ();
 558   struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ());
 559   volatile struct gdb_exception e;
 560
 561   if (mi_suppress_breakpoint_notifications)
 562     return;
 563
 564   if (b->number <= 0)
 565     return;
 566
 567   target_terminal_ours ();
 568   fprintf_unfiltered (mi->event_channel,
 569                       "breakpoint-modified");
 570   /* We want the output from gdb_breakpoint_query to go to
 571      mi->event_channel.  One approach would be to just call
 572      gdb_breakpoint_query, and then use mi_out_put to send the current
 573      content of mi_outout into mi->event_channel.  However, that will
 574      break if anything is output to mi_uiout prior to calling the
 575      breakpoint_created notifications.  So, we use
 576      ui_out_redirect.  */
 577   ui_out_redirect (mi_uiout, mi->event_channel);
 578   TRY_CATCH (e, RETURN_MASK_ERROR)
 579     gdb_breakpoint_query (mi_uiout, b->number, NULL);
 580   ui_out_redirect (mi_uiout, NULL);
 581
 582   gdb_flush (mi->event_channel);
 583 }
 584
 585 static int
 586 mi_output_running_pid (struct thread_info *info, void *arg)
 587 {
 588   ptid_t *ptid = arg;
 589
 590   if (ptid_get_pid (*ptid) == ptid_get_pid (info->ptid))
 591     fprintf_unfiltered (raw_stdout,
 592                         "*running,thread-id=\"%d\"\n",
 593                         info->num);
 594
 595   return 0;
 596 }
 597
 598 static int
 599 mi_inferior_count (struct inferior *inf, void *arg)
 600 {
 601   if (inf->pid != 0)
 602     {
 603       int *count_p = arg;
 604       (*count_p)++;
 605     }
 606
 607   return 0;
 608 }
 609
 610 static void
 611 mi_on_resume (ptid_t ptid)
 612 {
 613   struct thread_info *tp = NULL;
 614
 615   if (ptid_equal (ptid, minus_one_ptid) || ptid_is_pid (ptid))
 616     tp = inferior_thread ();
 617   else
 618     tp = find_thread_ptid (ptid);
 619
 620   /* Suppress output while calling an inferior function.  */
 621   if (tp->control.in_infcall)
 622     return;
 623
 624   /* To cater for older frontends, emit ^running, but do it only once
 625      per each command.  We do it here, since at this point we know
 626      that the target was successfully resumed, and in non-async mode,
 627      we won't return back to MI interpreter code until the target
 628      is done running, so delaying the output of "^running" until then
 629      will make it impossible for frontend to know what's going on.
 630
 631      In future (MI3), we'll be outputting "^done" here.  */
 632   if (!running_result_record_printed && mi_proceeded)
 633     {
 634       fprintf_unfiltered (raw_stdout, "%s^running\n",
 635                           current_token ? current_token : "");
 636     }
 637
 638   if (PIDGET (ptid) == -1)
 639     fprintf_unfiltered (raw_stdout, "*running,thread-id=\"all\"\n");
 640   else if (ptid_is_pid (ptid))
 641     {
 642       int count = 0;
 643
 644       /* Backwards compatibility.  If there's only one inferior,
 645          output "all", otherwise, output each resumed thread
 646          individually.  */
 647       iterate_over_inferiors (mi_inferior_count, &count);
 648
 649       if (count == 1)
 650         fprintf_unfiltered (raw_stdout, "*running,thread-id=\"all\"\n");
 651       else
 652         iterate_over_threads (mi_output_running_pid, &ptid);
 653     }
 654   else
 655     {
 656       struct thread_info *ti = find_thread_ptid (ptid);
 657
 658       gdb_assert (ti);
 659       fprintf_unfiltered (raw_stdout, "*running,thread-id=\"%d\"\n", ti->num);
 660     }
 661
 662   if (!running_result_record_printed && mi_proceeded)
 663     {
 664       running_result_record_printed = 1;
 665       /* This is what gdb used to do historically -- printing prompt even if
 666          it cannot actually accept any input.  This will be surely removed
 667          for MI3, and may be removed even earler.  */
 668       /* FIXME: review the use of target_is_async_p here -- is that
 669          what we want? */
 670       if (!target_is_async_p ())
 671         fputs_unfiltered ("(gdb) \n", raw_stdout);
 672     }
 673   gdb_flush (raw_stdout);
 674 }
 675
 676 static void
 677 mi_solib_loaded (struct so_list *solib)
 678 {
 679   struct mi_interp *mi = top_level_interpreter_data ();
 680
 681   target_terminal_ours ();
 682   if (gdbarch_has_global_solist (target_gdbarch))
 683     fprintf_unfiltered (mi->event_channel,
 684                         "library-loaded,id=\"%s\",target-name=\"%s\","
 685                         "host-name=\"%s\",symbols-loaded=\"%d\"",
 686                         solib->so_original_name, solib->so_original_name,
 687                         solib->so_name, solib->symbols_loaded);
 688   else
 689     fprintf_unfiltered (mi->event_channel,
 690                         "library-loaded,id=\"%s\",target-name=\"%s\","
 691                         "host-name=\"%s\",symbols-loaded=\"%d\","
 692                         "thread-group=\"i%d\"",
 693                         solib->so_original_name, solib->so_original_name,
 694                         solib->so_name, solib->symbols_loaded,
 695                         current_inferior ()->num);
 696
 697   gdb_flush (mi->event_channel);
 698 }
 699
 700 static void
 701 mi_solib_unloaded (struct so_list *solib)
 702 {
 703   struct mi_interp *mi = top_level_interpreter_data ();
 704
 705   target_terminal_ours ();
 706   if (gdbarch_has_global_solist (target_gdbarch))
 707     fprintf_unfiltered (mi->event_channel,
 708                         "library-unloaded,id=\"%s\",target-name=\"%s\","
 709                         "host-name=\"%s\"",
 710                         solib->so_original_name, solib->so_original_name,
 711                         solib->so_name);
 712   else
 713     fprintf_unfiltered (mi->event_channel,
 714                         "library-unloaded,id=\"%s\",target-name=\"%s\","
 715                         "host-name=\"%s\",thread-group=\"i%d\"",
 716                         solib->so_original_name, solib->so_original_name,
 717                         solib->so_name, current_inferior ()->num);
 718
 719   gdb_flush (mi->event_channel);
 720 }
 721
 722 static int
 723 report_initial_inferior (struct inferior *inf, void *closure)
 724 {
 725   /* This function is called from mi_intepreter_init, and since
 726      mi_inferior_added assumes that inferior is fully initialized
 727      and top_level_interpreter_data is set, we cannot call
 728      it here.  */
 729   struct mi_interp *mi = closure;
 730
 731   target_terminal_ours ();
 732   fprintf_unfiltered (mi->event_channel,
 733                       "thread-group-added,id=\"i%d\"",
 734                       inf->num);
 735   gdb_flush (mi->event_channel);
 736   return 0;
 737 }
 738
 739 static struct ui_out *
 740 mi_ui_out (struct interp *interp)
 741 {
 742   struct mi_interp *mi = interp_data (interp);
 743
 744   return mi->uiout;
 745 }
 746
 747 extern initialize_file_ftype _initialize_mi_interp; /* -Wmissing-prototypes */
 748
 749 void
 750 _initialize_mi_interp (void)
 751 {
 752   static const struct interp_procs procs =
 753     {
 754       mi_interpreter_init,      /* init_proc */
 755       mi_interpreter_resume,    /* resume_proc */
 756       mi_interpreter_suspend,   /* suspend_proc */
 757       mi_interpreter_exec,      /* exec_proc */
 758       mi_interpreter_prompt_p,  /* prompt_proc_p */
 759       mi_ui_out                 /* ui_out_proc */
 760     };
 761
 762   /* The various interpreter levels.  */
 763   interp_add (interp_new (INTERP_MI1, &procs));
 764   interp_add (interp_new (INTERP_MI2, &procs));
 765   interp_add (interp_new (INTERP_MI3, &procs));
 766   interp_add (interp_new (INTERP_MI, &procs));
 767 }