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