gdb/mi/mi-main.c

   1 /* MI Command Set.
   2
   3    Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010,
   4    2011 Free Software Foundation, Inc.
   5
   6    Contributed by Cygnus Solutions (a Red Hat company).
   7
   8    This file is part of GDB.
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 3 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  22
  23 /* Work in progress.  */
  24
  25 #include "defs.h"
  26 #include "arch-utils.h"
  27 #include "target.h"
  28 #include "inferior.h"
  29 #include "gdb_string.h"
  30 #include "exceptions.h"
  31 #include "top.h"
  32 #include "gdbthread.h"
  33 #include "mi-cmds.h"
  34 #include "mi-parse.h"
  35 #include "mi-getopt.h"
  36 #include "mi-console.h"
  37 #include "ui-out.h"
  38 #include "mi-out.h"
  39 #include "interps.h"
  40 #include "event-loop.h"
  41 #include "event-top.h"
  42 #include "gdbcore.h"            /* For write_memory().  */
  43 #include "value.h"
  44 #include "regcache.h"
  45 #include "gdb.h"
  46 #include "frame.h"
  47 #include "mi-main.h"
  48 #include "mi-common.h"
  49 #include "language.h"
  50 #include "valprint.h"
  51 #include "inferior.h"
  52 #include "osdata.h"
  53 #include "splay-tree.h"
  54 #include "tracepoint.h"
  55
  56 #include <ctype.h>
  57 #include <sys/time.h>
  58
  59 #if defined HAVE_SYS_RESOURCE_H
  60 #include <sys/resource.h>
  61 #endif
  62
  63 #ifdef HAVE_GETRUSAGE
  64 struct rusage rusage;
  65 #endif
  66
  67 enum
  68   {
  69     FROM_TTY = 0
  70   };
  71
  72 int mi_debug_p;
  73 struct ui_file *raw_stdout;
  74
  75 /* This is used to pass the current command timestamp
  76    down to continuation routines.  */
  77 static struct mi_timestamp *current_command_ts;
  78
  79 static int do_timings = 0;
  80
  81 char *current_token;
  82 /* Few commands would like to know if options like --thread-group
  83    were explicitly specified.  This variable keeps the current
  84    parsed command including all option, and make it possible.  */
  85 static struct mi_parse *current_context;
  86
  87 int running_result_record_printed = 1;
  88
  89 /* Flag indicating that the target has proceeded since the last
  90    command was issued.  */
  91 int mi_proceeded;
  92
  93 extern void _initialize_mi_main (void);
  94 static void mi_cmd_execute (struct mi_parse *parse);
  95
  96 static void mi_execute_cli_command (const char *cmd, int args_p,
  97                                     const char *args);
  98 static void mi_execute_async_cli_command (char *cli_command,
  99                                           char **argv, int argc);
 100 static int register_changed_p (int regnum, struct regcache *,
 101                                struct regcache *);
 102 static void get_register (struct frame_info *, int regnum, int format);
 103
 104 /* Command implementations.  FIXME: Is this libgdb?  No.  This is the MI
 105    layer that calls libgdb.  Any operation used in the below should be
 106    formalized.  */
 107
 108 static void timestamp (struct mi_timestamp *tv);
 109
 110 static void print_diff_now (struct mi_timestamp *start);
 111 static void print_diff (struct mi_timestamp *start, struct mi_timestamp *end);
 112
 113 void
 114 mi_cmd_gdb_exit (char *command, char **argv, int argc)
 115 {
 116   /* We have to print everything right here because we never return.  */
 117   if (current_token)
 118     fputs_unfiltered (current_token, raw_stdout);
 119   fputs_unfiltered ("^exit\n", raw_stdout);
 120   mi_out_put (current_uiout, raw_stdout);
 121   gdb_flush (raw_stdout);
 122   /* FIXME: The function called is not yet a formal libgdb function.  */
 123   quit_force (NULL, FROM_TTY);
 124 }
 125
 126 void
 127 mi_cmd_exec_next (char *command, char **argv, int argc)
 128 {
 129   /* FIXME: Should call a libgdb function, not a cli wrapper.  */
 130   if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
 131     mi_execute_async_cli_command ("reverse-next", argv + 1, argc - 1);
 132   else
 133     mi_execute_async_cli_command ("next", argv, argc);
 134 }
 135
 136 void
 137 mi_cmd_exec_next_instruction (char *command, char **argv, int argc)
 138 {
 139   /* FIXME: Should call a libgdb function, not a cli wrapper.  */
 140   if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
 141     mi_execute_async_cli_command ("reverse-nexti", argv + 1, argc - 1);
 142   else
 143     mi_execute_async_cli_command ("nexti", argv, argc);
 144 }
 145
 146 void
 147 mi_cmd_exec_step (char *command, char **argv, int argc)
 148 {
 149   /* FIXME: Should call a libgdb function, not a cli wrapper.  */
 150   if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
 151     mi_execute_async_cli_command ("reverse-step", argv + 1, argc - 1);
 152   else
 153     mi_execute_async_cli_command ("step", argv, argc);
 154 }
 155
 156 void
 157 mi_cmd_exec_step_instruction (char *command, char **argv, int argc)
 158 {
 159   /* FIXME: Should call a libgdb function, not a cli wrapper.  */
 160   if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
 161     mi_execute_async_cli_command ("reverse-stepi", argv + 1, argc - 1);
 162   else
 163     mi_execute_async_cli_command ("stepi", argv, argc);
 164 }
 165
 166 void
 167 mi_cmd_exec_finish (char *command, char **argv, int argc)
 168 {
 169   /* FIXME: Should call a libgdb function, not a cli wrapper.  */
 170   if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
 171     mi_execute_async_cli_command ("reverse-finish", argv + 1, argc - 1);
 172   else
 173     mi_execute_async_cli_command ("finish", argv, argc);
 174 }
 175
 176 void
 177 mi_cmd_exec_return (char *command, char **argv, int argc)
 178 {
 179   /* This command doesn't really execute the target, it just pops the
 180      specified number of frames. */
 181   if (argc)
 182     /* Call return_command with from_tty argument equal to 0 so as to
 183        avoid being queried.  */
 184     return_command (*argv, 0);
 185   else
 186     /* Call return_command with from_tty argument equal to 0 so as to
 187        avoid being queried.  */
 188     return_command (NULL, 0);
 189
 190   /* Because we have called return_command with from_tty = 0, we need
 191      to print the frame here.  */
 192   print_stack_frame (get_selected_frame (NULL), 1, LOC_AND_ADDRESS);
 193 }
 194
 195 void
 196 mi_cmd_exec_jump (char *args, char **argv, int argc)
 197 {
 198   /* FIXME: Should call a libgdb function, not a cli wrapper.  */
 199   mi_execute_async_cli_command ("jump", argv, argc);
 200 }
 201
 202 static void
 203 proceed_thread (struct thread_info *thread, int pid)
 204 {
 205   if (!is_stopped (thread->ptid))
 206     return;
 207
 208   if (pid != 0 && PIDGET (thread->ptid) != pid)
 209     return;
 210
 211   switch_to_thread (thread->ptid);
 212   clear_proceed_status ();
 213   proceed ((CORE_ADDR) -1, TARGET_SIGNAL_DEFAULT, 0);
 214 }
 215
 216
 217 static int
 218 proceed_thread_callback (struct thread_info *thread, void *arg)
 219 {
 220   int pid = *(int *)arg;
 221
 222   proceed_thread (thread, pid);
 223   return 0;
 224 }
 225
 226 static void
 227 exec_continue (char **argv, int argc)
 228 {
 229   if (non_stop)
 230     {
 231       /* In non-stop mode, 'resume' always resumes a single thread.  Therefore,
 232          to resume all threads of the current inferior, or all threads in all
 233          inferiors, we need to iterate over threads.
 234
 235          See comment on infcmd.c:proceed_thread_callback for rationale.  */
 236       if (current_context->all || current_context->thread_group != -1)
 237         {
 238           int pid = 0;
 239           struct cleanup *back_to = make_cleanup_restore_current_thread ();
 240
 241           if (!current_context->all)
 242             {
 243               struct inferior *inf
 244                 = find_inferior_id (current_context->thread_group);
 245
 246               pid = inf->pid;
 247             }
 248           iterate_over_threads (proceed_thread_callback, &pid);
 249           do_cleanups (back_to);
 250         }
 251       else
 252         {
 253           continue_1 (0);
 254         }
 255     }
 256   else
 257     {
 258       struct cleanup *back_to = make_cleanup_restore_integer (&sched_multi);
 259
 260       if (current_context->all)
 261         {
 262           sched_multi = 1;
 263           continue_1 (0);
 264         }
 265       else
 266         {
 267           /* In all-stop mode, -exec-continue traditionally resumed either
 268              all threads, or one thread, depending on the 'scheduler-locking'
 269              variable.  Let's continue to do the same.  */
 270           continue_1 (1);
 271         }
 272       do_cleanups (back_to);
 273     }
 274 }
 275
 276 static void
 277 exec_direction_forward (void *notused)
 278 {
 279   execution_direction = EXEC_FORWARD;
 280 }
 281
 282 static void
 283 exec_reverse_continue (char **argv, int argc)
 284 {
 285   enum exec_direction_kind dir = execution_direction;
 286   struct cleanup *old_chain;
 287
 288   if (dir == EXEC_REVERSE)
 289     error (_("Already in reverse mode."));
 290
 291   if (!target_can_execute_reverse)
 292     error (_("Target %s does not support this command."), target_shortname);
 293
 294   old_chain = make_cleanup (exec_direction_forward, NULL);
 295   execution_direction = EXEC_REVERSE;
 296   exec_continue (argv, argc);
 297   do_cleanups (old_chain);
 298 }
 299
 300 void
 301 mi_cmd_exec_continue (char *command, char **argv, int argc)
 302 {
 303   if (argc > 0 && strcmp (argv[0], "--reverse") == 0)
 304     exec_reverse_continue (argv + 1, argc - 1);
 305   else
 306     exec_continue (argv, argc);
 307 }
 308
 309 static int
 310 interrupt_thread_callback (struct thread_info *thread, void *arg)
 311 {
 312   int pid = *(int *)arg;
 313
 314   if (!is_running (thread->ptid))
 315     return 0;
 316
 317   if (PIDGET (thread->ptid) != pid)
 318     return 0;
 319
 320   target_stop (thread->ptid);
 321   return 0;
 322 }
 323
 324 /* Interrupt the execution of the target.  Note how we must play around
 325    with the token variables, in order to display the current token in
 326    the result of the interrupt command, and the previous execution
 327    token when the target finally stops.  See comments in
 328    mi_cmd_execute.  */
 329 void
 330 mi_cmd_exec_interrupt (char *command, char **argv, int argc)
 331 {
 332   /* In all-stop mode, everything stops, so we don't need to try
 333      anything specific.  */
 334   if (!non_stop)
 335     {
 336       interrupt_target_1 (0);
 337       return;
 338     }
 339
 340   if (current_context->all)
 341     {
 342       /* This will interrupt all threads in all inferiors.  */
 343       interrupt_target_1 (1);
 344     }
 345   else if (current_context->thread_group != -1)
 346     {
 347       struct inferior *inf = find_inferior_id (current_context->thread_group);
 348
 349       iterate_over_threads (interrupt_thread_callback, &inf->pid);
 350     }
 351   else
 352     {
 353       /* Interrupt just the current thread -- either explicitly
 354          specified via --thread or whatever was current before
 355          MI command was sent.  */
 356       interrupt_target_1 (0);
 357     }
 358 }
 359
 360 static int
 361 run_one_inferior (struct inferior *inf, void *arg)
 362 {
 363   if (inf->pid != 0)
 364     {
 365       if (inf->pid != ptid_get_pid (inferior_ptid))
 366         {
 367           struct thread_info *tp;
 368
 369           tp = any_thread_of_process (inf->pid);
 370           if (!tp)
 371             error (_("Inferior has no threads."));
 372
 373           switch_to_thread (tp->ptid);
 374         }
 375     }
 376   else
 377     {
 378       set_current_inferior (inf);
 379       switch_to_thread (null_ptid);
 380       set_current_program_space (inf->pspace);
 381     }
 382   mi_execute_cli_command ("run", target_can_async_p (),
 383                           target_can_async_p () ? "&" : NULL);
 384   return 0;
 385 }
 386
 387 void
 388 mi_cmd_exec_run (char *command, char **argv, int argc)
 389 {
 390   if (current_context->all)
 391     {
 392       struct cleanup *back_to = save_current_space_and_thread ();
 393
 394       iterate_over_inferiors (run_one_inferior, NULL);
 395       do_cleanups (back_to);
 396     }
 397   else
 398     {
 399       mi_execute_cli_command ("run", target_can_async_p (),
 400                               target_can_async_p () ? "&" : NULL);
 401     }
 402 }
 403
 404
 405 static int
 406 find_thread_of_process (struct thread_info *ti, void *p)
 407 {
 408   int pid = *(int *)p;
 409
 410   if (PIDGET (ti->ptid) == pid && !is_exited (ti->ptid))
 411     return 1;
 412
 413   return 0;
 414 }
 415
 416 void
 417 mi_cmd_target_detach (char *command, char **argv, int argc)
 418 {
 419   if (argc != 0 && argc != 1)
 420     error (_("Usage: -target-detach [pid | thread-group]"));
 421
 422   if (argc == 1)
 423     {
 424       struct thread_info *tp;
 425       char *end = argv[0];
 426       int pid;
 427
 428       /* First see if we are dealing with a thread-group id.  */
 429       if (*argv[0] == 'i')
 430         {
 431           struct inferior *inf;
 432           int id = strtoul (argv[0] + 1, &end, 0);
 433
 434           if (*end != '\0')
 435             error (_("Invalid syntax of thread-group id '%s'"), argv[0]);
 436
 437           inf = find_inferior_id (id);
 438           if (!inf)
 439             error (_("Non-existent thread-group id '%d'"), id);
 440
 441           pid = inf->pid;
 442         }
 443       else
 444         {
 445           /* We must be dealing with a pid.  */
 446           pid = strtol (argv[0], &end, 10);
 447
 448           if (*end != '\0')
 449             error (_("Invalid identifier '%s'"), argv[0]);
 450         }
 451
 452       /* Pick any thread in the desired process.  Current
 453          target_detach detaches from the parent of inferior_ptid.  */
 454       tp = iterate_over_threads (find_thread_of_process, &pid);
 455       if (!tp)
 456         error (_("Thread group is empty"));
 457
 458       switch_to_thread (tp->ptid);
 459     }
 460
 461   detach_command (NULL, 0);
 462 }
 463
 464 void
 465 mi_cmd_thread_select (char *command, char **argv, int argc)
 466 {
 467   enum gdb_rc rc;
 468   char *mi_error_message;
 469
 470   if (argc != 1)
 471     error (_("-thread-select: USAGE: threadnum."));
 472
 473   rc = gdb_thread_select (current_uiout, argv[0], &mi_error_message);
 474
 475   if (rc == GDB_RC_FAIL)
 476     {
 477       make_cleanup (xfree, mi_error_message);
 478       error ("%s", mi_error_message);
 479     }
 480 }
 481
 482 void
 483 mi_cmd_thread_list_ids (char *command, char **argv, int argc)
 484 {
 485   enum gdb_rc rc;
 486   char *mi_error_message;
 487
 488   if (argc != 0)
 489     error (_("-thread-list-ids: No arguments required."));
 490
 491   rc = gdb_list_thread_ids (current_uiout, &mi_error_message);
 492
 493   if (rc == GDB_RC_FAIL)
 494     {
 495       make_cleanup (xfree, mi_error_message);
 496       error ("%s", mi_error_message);
 497     }
 498 }
 499
 500 void
 501 mi_cmd_thread_info (char *command, char **argv, int argc)
 502 {
 503   if (argc != 0 && argc != 1)
 504     error (_("Invalid MI command"));
 505
 506   print_thread_info (current_uiout, argv[0], -1);
 507 }
 508
 509 struct collect_cores_data
 510 {
 511   int pid;
 512
 513   VEC (int) *cores;
 514 };
 515
 516 static int
 517 collect_cores (struct thread_info *ti, void *xdata)
 518 {
 519   struct collect_cores_data *data = xdata;
 520
 521   if (ptid_get_pid (ti->ptid) == data->pid)
 522     {
 523       int core = target_core_of_thread (ti->ptid);
 524
 525       if (core != -1)
 526         VEC_safe_push (int, data->cores, core);
 527     }
 528
 529   return 0;
 530 }
 531
 532 static int *
 533 unique (int *b, int *e)
 534 {
 535   int *d = b;
 536
 537   while (++b != e)
 538     if (*d != *b)
 539       *++d = *b;
 540   return ++d;
 541 }
 542
 543 struct print_one_inferior_data
 544 {
 545   int recurse;
 546   VEC (int) *inferiors;
 547 };
 548
 549 static int
 550 print_one_inferior (struct inferior *inferior, void *xdata)
 551 {
 552   struct print_one_inferior_data *top_data = xdata;
 553   struct ui_out *uiout = current_uiout;
 554
 555   if (VEC_empty (int, top_data->inferiors)
 556       || bsearch (&(inferior->pid), VEC_address (int, top_data->inferiors),
 557                   VEC_length (int, top_data->inferiors), sizeof (int),
 558                   compare_positive_ints))
 559     {
 560       struct collect_cores_data data;
 561       struct cleanup *back_to
 562         = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
 563
 564       ui_out_field_fmt (uiout, "id", "i%d", inferior->num);
 565       ui_out_field_string (uiout, "type", "process");
 566       if (inferior->pid != 0)
 567         ui_out_field_int (uiout, "pid", inferior->pid);
 568
 569       if (inferior->pspace->ebfd)
 570         {
 571           ui_out_field_string (uiout, "executable",
 572                                bfd_get_filename (inferior->pspace->ebfd));
 573         }
 574
 575       data.cores = 0;
 576       if (inferior->pid != 0)
 577         {
 578           data.pid = inferior->pid;
 579           iterate_over_threads (collect_cores, &data);
 580         }
 581
 582       if (!VEC_empty (int, data.cores))
 583         {
 584           int *b, *e;
 585           struct cleanup *back_to_2 =
 586             make_cleanup_ui_out_list_begin_end (uiout, "cores");
 587
 588           qsort (VEC_address (int, data.cores),
 589                  VEC_length (int, data.cores), sizeof (int),
 590                  compare_positive_ints);
 591
 592           b = VEC_address (int, data.cores);
 593           e = b + VEC_length (int, data.cores);
 594           e = unique (b, e);
 595
 596           for (; b != e; ++b)
 597             ui_out_field_int (uiout, NULL, *b);
 598
 599           do_cleanups (back_to_2);
 600         }
 601
 602       if (top_data->recurse)
 603         print_thread_info (uiout, NULL, inferior->pid);
 604
 605       do_cleanups (back_to);
 606     }
 607
 608   return 0;
 609 }
 610
 611 /* Output a field named 'cores' with a list as the value.  The elements of
 612    the list are obtained by splitting 'cores' on comma.  */
 613
 614 static void
 615 output_cores (struct ui_out *uiout, const char *field_name, const char *xcores)
 616 {
 617   struct cleanup *back_to = make_cleanup_ui_out_list_begin_end (uiout,
 618                                                                 field_name);
 619   char *cores = xstrdup (xcores);
 620   char *p = cores;
 621
 622   make_cleanup (xfree, cores);
 623
 624   for (p = strtok (p, ","); p;  p = strtok (NULL, ","))
 625     ui_out_field_string (uiout, NULL, p);
 626
 627   do_cleanups (back_to);
 628 }
 629
 630 static void
 631 free_vector_of_ints (void *xvector)
 632 {
 633   VEC (int) **vector = xvector;
 634
 635   VEC_free (int, *vector);
 636 }
 637
 638 static void
 639 do_nothing (splay_tree_key k)
 640 {
 641 }
 642
 643 static void
 644 free_vector_of_osdata_items (splay_tree_value xvalue)
 645 {
 646   VEC (osdata_item_s) *value = (VEC (osdata_item_s) *) xvalue;
 647
 648   /* We don't free the items itself, it will be done separately.  */
 649   VEC_free (osdata_item_s, value);
 650 }
 651
 652 static int
 653 splay_tree_int_comparator (splay_tree_key xa, splay_tree_key xb)
 654 {
 655   int a = xa;
 656   int b = xb;
 657
 658   return a - b;
 659 }
 660
 661 static void
 662 free_splay_tree (void *xt)
 663 {
 664   splay_tree t = xt;
 665   splay_tree_delete (t);
 666 }
 667
 668 static void
 669 list_available_thread_groups (VEC (int) *ids, int recurse)
 670 {
 671   struct osdata *data;
 672   struct osdata_item *item;
 673   int ix_items;
 674   struct ui_out *uiout = current_uiout;
 675
 676   /* This keeps a map from integer (pid) to VEC (struct osdata_item *)*
 677      The vector contains information about all threads for the given pid.
 678      This is assigned an initial value to avoid "may be used uninitialized"
 679      warning from gcc.  */
 680   splay_tree tree = NULL;
 681
 682   /* get_osdata will throw if it cannot return data.  */
 683   data = get_osdata ("processes");
 684   make_cleanup_osdata_free (data);
 685
 686   if (recurse)
 687     {
 688       struct osdata *threads = get_osdata ("threads");
 689
 690       make_cleanup_osdata_free (threads);
 691       tree = splay_tree_new (splay_tree_int_comparator,
 692                              do_nothing,
 693                              free_vector_of_osdata_items);
 694       make_cleanup (free_splay_tree, tree);
 695
 696       for (ix_items = 0;
 697            VEC_iterate (osdata_item_s, threads->items,
 698                         ix_items, item);
 699            ix_items++)
 700         {
 701           const char *pid = get_osdata_column (item, "pid");
 702           int pid_i = strtoul (pid, NULL, 0);
 703           VEC (osdata_item_s) *vec = 0;
 704
 705           splay_tree_node n = splay_tree_lookup (tree, pid_i);
 706           if (!n)
 707             {
 708               VEC_safe_push (osdata_item_s, vec, item);
 709               splay_tree_insert (tree, pid_i, (splay_tree_value)vec);
 710             }
 711           else
 712             {
 713               vec = (VEC (osdata_item_s) *) n->value;
 714               VEC_safe_push (osdata_item_s, vec, item);
 715               n->value = (splay_tree_value) vec;
 716             }
 717         }
 718     }
 719
 720   make_cleanup_ui_out_list_begin_end (uiout, "groups");
 721
 722   for (ix_items = 0;
 723        VEC_iterate (osdata_item_s, data->items,
 724                     ix_items, item);
 725        ix_items++)
 726     {
 727       struct cleanup *back_to;
 728
 729       const char *pid = get_osdata_column (item, "pid");
 730       const char *cmd = get_osdata_column (item, "command");
 731       const char *user = get_osdata_column (item, "user");
 732       const char *cores = get_osdata_column (item, "cores");
 733
 734       int pid_i = strtoul (pid, NULL, 0);
 735
 736       /* At present, the target will return all available processes
 737          and if information about specific ones was required, we filter
 738          undesired processes here.  */
 739       if (ids && bsearch (&pid_i, VEC_address (int, ids),
 740                           VEC_length (int, ids),
 741                           sizeof (int), compare_positive_ints) == NULL)
 742         continue;
 743
 744
 745       back_to = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
 746
 747       ui_out_field_fmt (uiout, "id", "%s", pid);
 748       ui_out_field_string (uiout, "type", "process");
 749       if (cmd)
 750         ui_out_field_string (uiout, "description", cmd);
 751       if (user)
 752         ui_out_field_string (uiout, "user", user);
 753       if (cores)
 754         output_cores (uiout, "cores", cores);
 755
 756       if (recurse)
 757         {
 758           splay_tree_node n = splay_tree_lookup (tree, pid_i);
 759           if (n)
 760             {
 761               VEC (osdata_item_s) *children = (VEC (osdata_item_s) *) n->value;
 762               struct osdata_item *child;
 763               int ix_child;
 764
 765               make_cleanup_ui_out_list_begin_end (uiout, "threads");
 766
 767               for (ix_child = 0;
 768                    VEC_iterate (osdata_item_s, children, ix_child, child);
 769                    ++ix_child)
 770                 {
 771                   struct cleanup *back_to_2 =
 772                     make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
 773                   const char *tid = get_osdata_column (child, "tid");
 774                   const char *tcore = get_osdata_column (child, "core");
 775
 776                   ui_out_field_string (uiout, "id", tid);
 777                   if (tcore)
 778                     ui_out_field_string (uiout, "core", tcore);
 779
 780                   do_cleanups (back_to_2);
 781                 }
 782             }
 783         }
 784
 785       do_cleanups (back_to);
 786     }
 787 }
 788
 789 void
 790 mi_cmd_list_thread_groups (char *command, char **argv, int argc)
 791 {
 792   struct ui_out *uiout = current_uiout;
 793   struct cleanup *back_to;
 794   int available = 0;
 795   int recurse = 0;
 796   VEC (int) *ids = 0;
 797
 798   enum opt
 799     {
 800       AVAILABLE_OPT, RECURSE_OPT
 801     };
 802   static struct mi_opt opts[] =
 803   {
 804     {"-available", AVAILABLE_OPT, 0},
 805     {"-recurse", RECURSE_OPT, 1},
 806     { 0, 0, 0 }
 807   };
 808
 809   int optind = 0;
 810   char *optarg;
 811
 812   while (1)
 813     {
 814       int opt = mi_getopt ("-list-thread-groups", argc, argv, opts,
 815                            &optind, &optarg);
 816
 817       if (opt < 0)
 818         break;
 819       switch ((enum opt) opt)
 820         {
 821         case AVAILABLE_OPT:
 822           available = 1;
 823           break;
 824         case RECURSE_OPT:
 825           if (strcmp (optarg, "0") == 0)
 826             ;
 827           else if (strcmp (optarg, "1") == 0)
 828             recurse = 1;
 829           else
 830             error (_("only '0' and '1' are valid values "
 831                      "for the '--recurse' option"));
 832           break;
 833         }
 834     }
 835
 836   for (; optind < argc; ++optind)
 837     {
 838       char *end;
 839       int inf;
 840
 841       if (*(argv[optind]) != 'i')
 842         error (_("invalid syntax of group id '%s'"), argv[optind]);
 843
 844       inf = strtoul (argv[optind] + 1, &end, 0);
 845
 846       if (*end != '\0')
 847         error (_("invalid syntax of group id '%s'"), argv[optind]);
 848       VEC_safe_push (int, ids, inf);
 849     }
 850   if (VEC_length (int, ids) > 1)
 851     qsort (VEC_address (int, ids),
 852            VEC_length (int, ids),
 853            sizeof (int), compare_positive_ints);
 854
 855   back_to = make_cleanup (free_vector_of_ints, &ids);
 856
 857   if (available)
 858     {
 859       list_available_thread_groups (ids, recurse);
 860     }
 861   else if (VEC_length (int, ids) == 1)
 862     {
 863       /* Local thread groups, single id. */
 864       int id = *VEC_address (int, ids);
 865       struct inferior *inf = find_inferior_id (id);
 866
 867       if (!inf)
 868         error (_("Non-existent thread group id '%d'"), id);
 869
 870       print_thread_info (uiout, NULL, inf->pid);
 871     }
 872   else
 873     {
 874       struct print_one_inferior_data data;
 875
 876       data.recurse = recurse;
 877       data.inferiors = ids;
 878
 879       /* Local thread groups.  Either no explicit ids -- and we
 880          print everything, or several explicit ids.  In both cases,
 881          we print more than one group, and have to use 'groups'
 882          as the top-level element.  */
 883       make_cleanup_ui_out_list_begin_end (uiout, "groups");
 884       update_thread_list ();
 885       iterate_over_inferiors (print_one_inferior, &data);
 886     }
 887
 888   do_cleanups (back_to);
 889 }
 890
 891 void
 892 mi_cmd_data_list_register_names (char *command, char **argv, int argc)
 893 {
 894   struct gdbarch *gdbarch;
 895   struct ui_out *uiout = current_uiout;
 896   int regnum, numregs;
 897   int i;
 898   struct cleanup *cleanup;
 899
 900   /* Note that the test for a valid register must include checking the
 901      gdbarch_register_name because gdbarch_num_regs may be allocated for
 902      the union of the register sets within a family of related processors.
 903      In this case, some entries of gdbarch_register_name will change depending
 904      upon the particular processor being debugged.  */
 905
 906   gdbarch = get_current_arch ();
 907   numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
 908
 909   cleanup = make_cleanup_ui_out_list_begin_end (uiout, "register-names");
 910
 911   if (argc == 0)                /* No args, just do all the regs.  */
 912     {
 913       for (regnum = 0;
 914            regnum < numregs;
 915            regnum++)
 916         {
 917           if (gdbarch_register_name (gdbarch, regnum) == NULL
 918               || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
 919             ui_out_field_string (uiout, NULL, "");
 920           else
 921             ui_out_field_string (uiout, NULL,
 922                                  gdbarch_register_name (gdbarch, regnum));
 923         }
 924     }
 925
 926   /* Else, list of register #s, just do listed regs.  */
 927   for (i = 0; i < argc; i++)
 928     {
 929       regnum = atoi (argv[i]);
 930       if (regnum < 0 || regnum >= numregs)
 931         error (_("bad register number"));
 932
 933       if (gdbarch_register_name (gdbarch, regnum) == NULL
 934           || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
 935         ui_out_field_string (uiout, NULL, "");
 936       else
 937         ui_out_field_string (uiout, NULL,
 938                              gdbarch_register_name (gdbarch, regnum));
 939     }
 940   do_cleanups (cleanup);
 941 }
 942
 943 void
 944 mi_cmd_data_list_changed_registers (char *command, char **argv, int argc)
 945 {
 946   static struct regcache *this_regs = NULL;
 947   struct ui_out *uiout = current_uiout;
 948   struct regcache *prev_regs;
 949   struct gdbarch *gdbarch;
 950   int regnum, numregs, changed;
 951   int i;
 952   struct cleanup *cleanup;
 953
 954   /* The last time we visited this function, the current frame's register
 955      contents were saved in THIS_REGS.  Move THIS_REGS over to PREV_REGS,
 956      and refresh THIS_REGS with the now-current register contents.  */
 957
 958   prev_regs = this_regs;
 959   this_regs = frame_save_as_regcache (get_selected_frame (NULL));
 960   cleanup = make_cleanup_regcache_xfree (prev_regs);
 961
 962   /* Note that the test for a valid register must include checking the
 963      gdbarch_register_name because gdbarch_num_regs may be allocated for
 964      the union of the register sets within a family of related processors.
 965      In this  case, some entries of gdbarch_register_name will change depending
 966      upon the particular processor being debugged.  */
 967
 968   gdbarch = get_regcache_arch (this_regs);
 969   numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
 970
 971   make_cleanup_ui_out_list_begin_end (uiout, "changed-registers");
 972
 973   if (argc == 0)                /* No args, just do all the regs.  */
 974     {
 975       for (regnum = 0;
 976            regnum < numregs;
 977            regnum++)
 978         {
 979           if (gdbarch_register_name (gdbarch, regnum) == NULL
 980               || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
 981             continue;
 982           changed = register_changed_p (regnum, prev_regs, this_regs);
 983           if (changed < 0)
 984             error (_("-data-list-changed-registers: "
 985                      "Unable to read register contents."));
 986           else if (changed)
 987             ui_out_field_int (uiout, NULL, regnum);
 988         }
 989     }
 990
 991   /* Else, list of register #s, just do listed regs.  */
 992   for (i = 0; i < argc; i++)
 993     {
 994       regnum = atoi (argv[i]);
 995
 996       if (regnum >= 0
 997           && regnum < numregs
 998           && gdbarch_register_name (gdbarch, regnum) != NULL
 999           && *gdbarch_register_name (gdbarch, regnum) != '\000')
1000         {
1001           changed = register_changed_p (regnum, prev_regs, this_regs);
1002           if (changed < 0)
1003             error (_("-data-list-changed-registers: "
1004                      "Unable to read register contents."));
1005           else if (changed)
1006             ui_out_field_int (uiout, NULL, regnum);
1007         }
1008       else
1009         error (_("bad register number"));
1010     }
1011   do_cleanups (cleanup);
1012 }
1013
1014 static int
1015 register_changed_p (int regnum, struct regcache *prev_regs,
1016                     struct regcache *this_regs)
1017 {
1018   struct gdbarch *gdbarch = get_regcache_arch (this_regs);
1019   gdb_byte prev_buffer[MAX_REGISTER_SIZE];
1020   gdb_byte this_buffer[MAX_REGISTER_SIZE];
1021   enum register_status prev_status;
1022   enum register_status this_status;
1023
1024   /* First time through or after gdbarch change consider all registers
1025      as changed.  */
1026   if (!prev_regs || get_regcache_arch (prev_regs) != gdbarch)
1027     return 1;
1028
1029   /* Get register contents and compare.  */
1030   prev_status = regcache_cooked_read (prev_regs, regnum, prev_buffer);
1031   this_status = regcache_cooked_read (this_regs, regnum, this_buffer);
1032
1033   if (this_status != prev_status)
1034     return 1;
1035   else if (this_status == REG_VALID)
1036     return memcmp (prev_buffer, this_buffer,
1037                    register_size (gdbarch, regnum)) != 0;
1038   else
1039     return 0;
1040 }
1041
1042 /* Return a list of register number and value pairs.  The valid
1043    arguments expected are: a letter indicating the format in which to
1044    display the registers contents.  This can be one of: x (hexadecimal), d
1045    (decimal), N (natural), t (binary), o (octal), r (raw).  After the
1046    format argumetn there can be a sequence of numbers, indicating which
1047    registers to fetch the content of.  If the format is the only argument,
1048    a list of all the registers with their values is returned.  */
1049 void
1050 mi_cmd_data_list_register_values (char *command, char **argv, int argc)
1051 {
1052   struct ui_out *uiout = current_uiout;
1053   struct frame_info *frame;
1054   struct gdbarch *gdbarch;
1055   int regnum, numregs, format;
1056   int i;
1057   struct cleanup *list_cleanup, *tuple_cleanup;
1058
1059   /* Note that the test for a valid register must include checking the
1060      gdbarch_register_name because gdbarch_num_regs may be allocated for
1061      the union of the register sets within a family of related processors.
1062      In this case, some entries of gdbarch_register_name will change depending
1063      upon the particular processor being debugged.  */
1064
1065   if (argc == 0)
1066     error (_("-data-list-register-values: Usage: "
1067              "-data-list-register-values <format> [<regnum1>...<regnumN>]"));
1068
1069   format = (int) argv[0][0];
1070
1071   frame = get_selected_frame (NULL);
1072   gdbarch = get_frame_arch (frame);
1073   numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
1074
1075   list_cleanup = make_cleanup_ui_out_list_begin_end (uiout, "register-values");
1076
1077   if (argc == 1)            /* No args, beside the format: do all the regs.  */
1078     {
1079       for (regnum = 0;
1080            regnum < numregs;
1081            regnum++)
1082         {
1083           if (gdbarch_register_name (gdbarch, regnum) == NULL
1084               || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
1085             continue;
1086           tuple_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1087           ui_out_field_int (uiout, "number", regnum);
1088           get_register (frame, regnum, format);
1089           do_cleanups (tuple_cleanup);
1090         }
1091     }
1092
1093   /* Else, list of register #s, just do listed regs.  */
1094   for (i = 1; i < argc; i++)
1095     {
1096       regnum = atoi (argv[i]);
1097
1098       if (regnum >= 0
1099           && regnum < numregs
1100           && gdbarch_register_name (gdbarch, regnum) != NULL
1101           && *gdbarch_register_name (gdbarch, regnum) != '\000')
1102         {
1103           tuple_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1104           ui_out_field_int (uiout, "number", regnum);
1105           get_register (frame, regnum, format);
1106           do_cleanups (tuple_cleanup);
1107         }
1108       else
1109         error (_("bad register number"));
1110     }
1111   do_cleanups (list_cleanup);
1112 }
1113
1114 /* Output one register's contents in the desired format.  */
1115 static void
1116 get_register (struct frame_info *frame, int regnum, int format)
1117 {
1118   struct gdbarch *gdbarch = get_frame_arch (frame);
1119   struct ui_out *uiout = current_uiout;
1120   CORE_ADDR addr;
1121   enum lval_type lval;
1122   static struct ui_stream *stb = NULL;
1123   struct value *val;
1124
1125   stb = ui_out_stream_new (uiout);
1126
1127   if (format == 'N')
1128     format = 0;
1129
1130   val = get_frame_register_value (frame, regnum);
1131
1132   if (value_optimized_out (val))
1133     error (_("Optimized out"));
1134
1135   if (format == 'r')
1136     {
1137       int j;
1138       char *ptr, buf[1024];
1139       const gdb_byte *valaddr = value_contents_for_printing (val);
1140
1141       strcpy (buf, "0x");
1142       ptr = buf + 2;
1143       for (j = 0; j < register_size (gdbarch, regnum); j++)
1144         {
1145           int idx = gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG ?
1146                     j : register_size (gdbarch, regnum) - 1 - j;
1147
1148           sprintf (ptr, "%02x", (unsigned char) valaddr[idx]);
1149           ptr += 2;
1150         }
1151       ui_out_field_string (uiout, "value", buf);
1152       /*fputs_filtered (buf, gdb_stdout); */
1153     }
1154   else
1155     {
1156       struct value_print_options opts;
1157
1158       get_formatted_print_options (&opts, format);
1159       opts.deref_ref = 1;
1160       val_print (value_type (val),
1161                  value_contents_for_printing (val),
1162                  value_embedded_offset (val), 0,
1163                  stb->stream, 0, val, &opts, current_language);
1164       ui_out_field_stream (uiout, "value", stb);
1165       ui_out_stream_delete (stb);
1166     }
1167 }
1168
1169 /* Write given values into registers. The registers and values are
1170    given as pairs.  The corresponding MI command is
1171    -data-write-register-values <format>
1172                                [<regnum1> <value1>...<regnumN> <valueN>] */
1173 void
1174 mi_cmd_data_write_register_values (char *command, char **argv, int argc)
1175 {
1176   struct regcache *regcache;
1177   struct gdbarch *gdbarch;
1178   int numregs, i;
1179   char format;
1180
1181   /* Note that the test for a valid register must include checking the
1182      gdbarch_register_name because gdbarch_num_regs may be allocated for
1183      the union of the register sets within a family of related processors.
1184      In this case, some entries of gdbarch_register_name will change depending
1185      upon the particular processor being debugged.  */
1186
1187   regcache = get_current_regcache ();
1188   gdbarch = get_regcache_arch (regcache);
1189   numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
1190
1191   if (argc == 0)
1192     error (_("-data-write-register-values: Usage: -data-write-register-"
1193              "values <format> [<regnum1> <value1>...<regnumN> <valueN>]"));
1194
1195   format = (int) argv[0][0];
1196
1197   if (!target_has_registers)
1198     error (_("-data-write-register-values: No registers."));
1199
1200   if (!(argc - 1))
1201     error (_("-data-write-register-values: No regs and values specified."));
1202
1203   if ((argc - 1) % 2)
1204     error (_("-data-write-register-values: "
1205              "Regs and vals are not in pairs."));
1206
1207   for (i = 1; i < argc; i = i + 2)
1208     {
1209       int regnum = atoi (argv[i]);
1210
1211       if (regnum >= 0 && regnum < numregs
1212           && gdbarch_register_name (gdbarch, regnum)
1213           && *gdbarch_register_name (gdbarch, regnum))
1214         {
1215           LONGEST value;
1216
1217           /* Get the value as a number.  */
1218           value = parse_and_eval_address (argv[i + 1]);
1219
1220           /* Write it down.  */
1221           regcache_cooked_write_signed (regcache, regnum, value);
1222         }
1223       else
1224         error (_("bad register number"));
1225     }
1226 }
1227
1228 /* Evaluate the value of the argument.  The argument is an
1229    expression. If the expression contains spaces it needs to be
1230    included in double quotes.  */
1231 void
1232 mi_cmd_data_evaluate_expression (char *command, char **argv, int argc)
1233 {
1234   struct expression *expr;
1235   struct cleanup *old_chain = NULL;
1236   struct value *val;
1237   struct ui_stream *stb = NULL;
1238   struct value_print_options opts;
1239   struct ui_out *uiout = current_uiout;
1240
1241   stb = ui_out_stream_new (uiout);
1242
1243   if (argc != 1)
1244     {
1245       ui_out_stream_delete (stb);
1246       error (_("-data-evaluate-expression: "
1247                "Usage: -data-evaluate-expression expression"));
1248     }
1249
1250   expr = parse_expression (argv[0]);
1251
1252   old_chain = make_cleanup (free_current_contents, &expr);
1253
1254   val = evaluate_expression (expr);
1255
1256   /* Print the result of the expression evaluation.  */
1257   get_user_print_options (&opts);
1258   opts.deref_ref = 0;
1259   common_val_print (val, stb->stream, 0, &opts, current_language);
1260
1261   ui_out_field_stream (uiout, "value", stb);
1262   ui_out_stream_delete (stb);
1263
1264   do_cleanups (old_chain);
1265 }
1266
1267 /* DATA-MEMORY-READ:
1268
1269    ADDR: start address of data to be dumped.
1270    WORD-FORMAT: a char indicating format for the ``word''.  See
1271    the ``x'' command.
1272    WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes.
1273    NR_ROW: Number of rows.
1274    NR_COL: The number of colums (words per row).
1275    ASCHAR: (OPTIONAL) Append an ascii character dump to each row.  Use
1276    ASCHAR for unprintable characters.
1277
1278    Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
1279    displayes them.  Returns:
1280
1281    {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
1282
1283    Returns:
1284    The number of bytes read is SIZE*ROW*COL. */
1285
1286 void
1287 mi_cmd_data_read_memory (char *command, char **argv, int argc)
1288 {
1289   struct gdbarch *gdbarch = get_current_arch ();
1290   struct ui_out *uiout = current_uiout;
1291   struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
1292   CORE_ADDR addr;
1293   long total_bytes;
1294   long nr_cols;
1295   long nr_rows;
1296   char word_format;
1297   struct type *word_type;
1298   long word_size;
1299   char word_asize;
1300   char aschar;
1301   gdb_byte *mbuf;
1302   int nr_bytes;
1303   long offset = 0;
1304   int optind = 0;
1305   char *optarg;
1306   enum opt
1307     {
1308       OFFSET_OPT
1309     };
1310   static struct mi_opt opts[] =
1311   {
1312     {"o", OFFSET_OPT, 1},
1313     { 0, 0, 0 }
1314   };
1315
1316   while (1)
1317     {
1318       int opt = mi_getopt ("-data-read-memory", argc, argv, opts,
1319                            &optind, &optarg);
1320
1321       if (opt < 0)
1322         break;
1323       switch ((enum opt) opt)
1324         {
1325         case OFFSET_OPT:
1326           offset = atol (optarg);
1327           break;
1328         }
1329     }
1330   argv += optind;
1331   argc -= optind;
1332
1333   if (argc < 5 || argc > 6)
1334     error (_("-data-read-memory: Usage: "
1335              "ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR]."));
1336
1337   /* Extract all the arguments. */
1338
1339   /* Start address of the memory dump.  */
1340   addr = parse_and_eval_address (argv[0]) + offset;
1341   /* The format character to use when displaying a memory word.  See
1342      the ``x'' command. */
1343   word_format = argv[1][0];
1344   /* The size of the memory word.  */
1345   word_size = atol (argv[2]);
1346   switch (word_size)
1347     {
1348     case 1:
1349       word_type = builtin_type (gdbarch)->builtin_int8;
1350       word_asize = 'b';
1351       break;
1352     case 2:
1353       word_type = builtin_type (gdbarch)->builtin_int16;
1354       word_asize = 'h';
1355       break;
1356     case 4:
1357       word_type = builtin_type (gdbarch)->builtin_int32;
1358       word_asize = 'w';
1359       break;
1360     case 8:
1361       word_type = builtin_type (gdbarch)->builtin_int64;
1362       word_asize = 'g';
1363       break;
1364     default:
1365       word_type = builtin_type (gdbarch)->builtin_int8;
1366       word_asize = 'b';
1367     }
1368   /* The number of rows.  */
1369   nr_rows = atol (argv[3]);
1370   if (nr_rows <= 0)
1371     error (_("-data-read-memory: invalid number of rows."));
1372
1373   /* Number of bytes per row.  */
1374   nr_cols = atol (argv[4]);
1375   if (nr_cols <= 0)
1376     error (_("-data-read-memory: invalid number of columns."));
1377
1378   /* The un-printable character when printing ascii.  */
1379   if (argc == 6)
1380     aschar = *argv[5];
1381   else
1382     aschar = 0;
1383
1384   /* Create a buffer and read it in.  */
1385   total_bytes = word_size * nr_rows * nr_cols;
1386   mbuf = xcalloc (total_bytes, 1);
1387   make_cleanup (xfree, mbuf);
1388
1389   /* Dispatch memory reads to the topmost target, not the flattened
1390      current_target.  */
1391   nr_bytes = target_read (current_target.beneath,
1392                           TARGET_OBJECT_MEMORY, NULL, mbuf,
1393                           addr, total_bytes);
1394   if (nr_bytes <= 0)
1395     error (_("Unable to read memory."));
1396
1397   /* Output the header information.  */
1398   ui_out_field_core_addr (uiout, "addr", gdbarch, addr);
1399   ui_out_field_int (uiout, "nr-bytes", nr_bytes);
1400   ui_out_field_int (uiout, "total-bytes", total_bytes);
1401   ui_out_field_core_addr (uiout, "next-row",
1402                           gdbarch, addr + word_size * nr_cols);
1403   ui_out_field_core_addr (uiout, "prev-row",
1404                           gdbarch, addr - word_size * nr_cols);
1405   ui_out_field_core_addr (uiout, "next-page", gdbarch, addr + total_bytes);
1406   ui_out_field_core_addr (uiout, "prev-page", gdbarch, addr - total_bytes);
1407
1408   /* Build the result as a two dimentional table.  */
1409   {
1410     struct ui_stream *stream = ui_out_stream_new (uiout);
1411     struct cleanup *cleanup_list_memory;
1412     int row;
1413     int row_byte;
1414
1415     cleanup_list_memory = make_cleanup_ui_out_list_begin_end (uiout, "memory");
1416     for (row = 0, row_byte = 0;
1417          row < nr_rows;
1418          row++, row_byte += nr_cols * word_size)
1419       {
1420         int col;
1421         int col_byte;
1422         struct cleanup *cleanup_tuple;
1423         struct cleanup *cleanup_list_data;
1424         struct value_print_options opts;
1425
1426         cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1427         ui_out_field_core_addr (uiout, "addr", gdbarch, addr + row_byte);
1428         /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr +
1429            row_byte); */
1430         cleanup_list_data = make_cleanup_ui_out_list_begin_end (uiout, "data");
1431         get_formatted_print_options (&opts, word_format);
1432         for (col = 0, col_byte = row_byte;
1433              col < nr_cols;
1434              col++, col_byte += word_size)
1435           {
1436             if (col_byte + word_size > nr_bytes)
1437               {
1438                 ui_out_field_string (uiout, NULL, "N/A");
1439               }
1440             else
1441               {
1442                 ui_file_rewind (stream->stream);
1443                 print_scalar_formatted (mbuf + col_byte, word_type, &opts,
1444                                         word_asize, stream->stream);
1445                 ui_out_field_stream (uiout, NULL, stream);
1446               }
1447           }
1448         do_cleanups (cleanup_list_data);
1449         if (aschar)
1450           {
1451             int byte;
1452
1453             ui_file_rewind (stream->stream);
1454             for (byte = row_byte;
1455                  byte < row_byte + word_size * nr_cols; byte++)
1456               {
1457                 if (byte >= nr_bytes)
1458                   {
1459                     fputc_unfiltered ('X', stream->stream);
1460                   }
1461                 else if (mbuf[byte] < 32 || mbuf[byte] > 126)
1462                   {
1463                     fputc_unfiltered (aschar, stream->stream);
1464                   }
1465                 else
1466                   fputc_unfiltered (mbuf[byte], stream->stream);
1467               }
1468             ui_out_field_stream (uiout, "ascii", stream);
1469           }
1470         do_cleanups (cleanup_tuple);
1471       }
1472     ui_out_stream_delete (stream);
1473     do_cleanups (cleanup_list_memory);
1474   }
1475   do_cleanups (cleanups);
1476 }
1477
1478 void
1479 mi_cmd_data_read_memory_bytes (char *command, char **argv, int argc)
1480 {
1481   struct gdbarch *gdbarch = get_current_arch ();
1482   struct ui_out *uiout = current_uiout;
1483   struct cleanup *cleanups;
1484   CORE_ADDR addr;
1485   LONGEST length;
1486   memory_read_result_s *read_result;
1487   int ix;
1488   VEC(memory_read_result_s) *result;
1489   long offset = 0;
1490   int optind = 0;
1491   char *optarg;
1492   enum opt
1493     {
1494       OFFSET_OPT
1495     };
1496   static struct mi_opt opts[] =
1497   {
1498     {"o", OFFSET_OPT, 1},
1499     { 0, 0, 0 }
1500   };
1501
1502   while (1)
1503     {
1504       int opt = mi_getopt ("-data-read-memory-bytes", argc, argv, opts,
1505                            &optind, &optarg);
1506       if (opt < 0)
1507         break;
1508       switch ((enum opt) opt)
1509         {
1510         case OFFSET_OPT:
1511           offset = atol (optarg);
1512           break;
1513         }
1514     }
1515   argv += optind;
1516   argc -= optind;
1517
1518   if (argc != 2)
1519     error (_("Usage: [ -o OFFSET ] ADDR LENGTH."));
1520
1521   addr = parse_and_eval_address (argv[0]) + offset;
1522   length = atol (argv[1]);
1523
1524   result = read_memory_robust (current_target.beneath, addr, length);
1525
1526   cleanups = make_cleanup (free_memory_read_result_vector, result);
1527
1528   if (VEC_length (memory_read_result_s, result) == 0)
1529     error (_("Unable to read memory."));
1530
1531   make_cleanup_ui_out_list_begin_end (uiout, "memory");
1532   for (ix = 0;
1533        VEC_iterate (memory_read_result_s, result, ix, read_result);
1534        ++ix)
1535     {
1536       struct cleanup *t = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1537       char *data, *p;
1538       int i;
1539
1540       ui_out_field_core_addr (uiout, "begin", gdbarch, read_result->begin);
1541       ui_out_field_core_addr (uiout, "offset", gdbarch, read_result->begin
1542                               - addr);
1543       ui_out_field_core_addr (uiout, "end", gdbarch, read_result->end);
1544
1545       data = xmalloc ((read_result->end - read_result->begin) * 2 + 1);
1546
1547       for (i = 0, p = data;
1548            i < (read_result->end - read_result->begin);
1549            ++i, p += 2)
1550         {
1551           sprintf (p, "%02x", read_result->data[i]);
1552         }
1553       ui_out_field_string (uiout, "contents", data);
1554       xfree (data);
1555       do_cleanups (t);
1556     }
1557   do_cleanups (cleanups);
1558 }
1559
1560
1561 /* DATA-MEMORY-WRITE:
1562
1563    COLUMN_OFFSET: optional argument. Must be preceded by '-o'. The
1564    offset from the beginning of the memory grid row where the cell to
1565    be written is.
1566    ADDR: start address of the row in the memory grid where the memory
1567    cell is, if OFFSET_COLUMN is specified.  Otherwise, the address of
1568    the location to write to.
1569    FORMAT: a char indicating format for the ``word''.  See
1570    the ``x'' command.
1571    WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
1572    VALUE: value to be written into the memory address.
1573
1574    Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
1575
1576    Prints nothing.  */
1577 void
1578 mi_cmd_data_write_memory (char *command, char **argv, int argc)
1579 {
1580   struct gdbarch *gdbarch = get_current_arch ();
1581   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1582   CORE_ADDR addr;
1583   char word_format;
1584   long word_size;
1585   /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
1586      enough when using a compiler other than GCC.  */
1587   LONGEST value;
1588   void *buffer;
1589   struct cleanup *old_chain;
1590   long offset = 0;
1591   int optind = 0;
1592   char *optarg;
1593   enum opt
1594     {
1595       OFFSET_OPT
1596     };
1597   static struct mi_opt opts[] =
1598   {
1599     {"o", OFFSET_OPT, 1},
1600     { 0, 0, 0 }
1601   };
1602
1603   while (1)
1604     {
1605       int opt = mi_getopt ("-data-write-memory", argc, argv, opts,
1606                            &optind, &optarg);
1607
1608       if (opt < 0)
1609         break;
1610       switch ((enum opt) opt)
1611         {
1612         case OFFSET_OPT:
1613           offset = atol (optarg);
1614           break;
1615         }
1616     }
1617   argv += optind;
1618   argc -= optind;
1619
1620   if (argc != 4)
1621     error (_("-data-write-memory: Usage: "
1622              "[-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE."));
1623
1624   /* Extract all the arguments.  */
1625   /* Start address of the memory dump.  */
1626   addr = parse_and_eval_address (argv[0]);
1627   /* The format character to use when displaying a memory word.  See
1628      the ``x'' command.  */
1629   word_format = argv[1][0];
1630   /* The size of the memory word. */
1631   word_size = atol (argv[2]);
1632
1633   /* Calculate the real address of the write destination.  */
1634   addr += (offset * word_size);
1635
1636   /* Get the value as a number.  */
1637   value = parse_and_eval_address (argv[3]);
1638   /* Get the value into an array.  */
1639   buffer = xmalloc (word_size);
1640   old_chain = make_cleanup (xfree, buffer);
1641   store_signed_integer (buffer, word_size, byte_order, value);
1642   /* Write it down to memory.  */
1643   write_memory (addr, buffer, word_size);
1644   /* Free the buffer.  */
1645   do_cleanups (old_chain);
1646 }
1647
1648 /* DATA-MEMORY-WRITE-RAW:
1649
1650    ADDR: start address
1651    DATA: string of bytes to write at that address. */
1652 void
1653 mi_cmd_data_write_memory_bytes (char *command, char **argv, int argc)
1654 {
1655   CORE_ADDR addr;
1656   char *cdata;
1657   gdb_byte *data;
1658   int len, r, i;
1659   struct cleanup *back_to;
1660
1661   if (argc != 2)
1662     error (_("Usage: ADDR DATA."));
1663
1664   addr = parse_and_eval_address (argv[0]);
1665   cdata = argv[1];
1666   len = strlen (cdata)/2;
1667
1668   data = xmalloc (len);
1669   back_to = make_cleanup (xfree, data);
1670
1671   for (i = 0; i < len; ++i)
1672     {
1673       int x;
1674       sscanf (cdata + i * 2, "%02x", &x);
1675       data[i] = (gdb_byte)x;
1676     }
1677
1678   r = target_write_memory (addr, data, len);
1679   if (r != 0)
1680     error (_("Could not write memory"));
1681
1682   do_cleanups (back_to);
1683 }
1684
1685
1686 void
1687 mi_cmd_enable_timings (char *command, char **argv, int argc)
1688 {
1689   if (argc == 0)
1690     do_timings = 1;
1691   else if (argc == 1)
1692     {
1693       if (strcmp (argv[0], "yes") == 0)
1694         do_timings = 1;
1695       else if (strcmp (argv[0], "no") == 0)
1696         do_timings = 0;
1697       else
1698         goto usage_error;
1699     }
1700   else
1701     goto usage_error;
1702
1703   return;
1704
1705  usage_error:
1706   error (_("-enable-timings: Usage: %s {yes|no}"), command);
1707 }
1708
1709 void
1710 mi_cmd_list_features (char *command, char **argv, int argc)
1711 {
1712   if (argc == 0)
1713     {
1714       struct cleanup *cleanup = NULL;
1715       struct ui_out *uiout = current_uiout;
1716
1717       cleanup = make_cleanup_ui_out_list_begin_end (uiout, "features");
1718       ui_out_field_string (uiout, NULL, "frozen-varobjs");
1719       ui_out_field_string (uiout, NULL, "pending-breakpoints");
1720       ui_out_field_string (uiout, NULL, "thread-info");
1721       ui_out_field_string (uiout, NULL, "data-read-memory-bytes");
1722       ui_out_field_string (uiout, NULL, "breakpoint-notifications");
1723
1724 #if HAVE_PYTHON
1725       ui_out_field_string (uiout, NULL, "python");
1726 #endif
1727
1728       do_cleanups (cleanup);
1729       return;
1730     }
1731
1732   error (_("-list-features should be passed no arguments"));
1733 }
1734
1735 void
1736 mi_cmd_list_target_features (char *command, char **argv, int argc)
1737 {
1738   if (argc == 0)
1739     {
1740       struct cleanup *cleanup = NULL;
1741       struct ui_out *uiout = current_uiout;
1742
1743       cleanup = make_cleanup_ui_out_list_begin_end (uiout, "features");
1744       if (target_can_async_p ())
1745         ui_out_field_string (uiout, NULL, "async");
1746       if (target_can_execute_reverse)
1747         ui_out_field_string (uiout, NULL, "reverse");
1748
1749       do_cleanups (cleanup);
1750       return;
1751     }
1752
1753   error (_("-list-target-features should be passed no arguments"));
1754 }
1755
1756 void
1757 mi_cmd_add_inferior (char *command, char **argv, int argc)
1758 {
1759   struct inferior *inf;
1760
1761   if (argc != 0)
1762     error (_("-add-inferior should be passed no arguments"));
1763
1764   inf = add_inferior_with_spaces ();
1765
1766   ui_out_field_fmt (current_uiout, "inferior", "i%d", inf->num);
1767 }
1768
1769 /* Callback used to find the first inferior other than the
1770    current one. */
1771
1772 static int
1773 get_other_inferior (struct inferior *inf, void *arg)
1774 {
1775   if (inf == current_inferior ())
1776     return 0;
1777
1778   return 1;
1779 }
1780
1781 void
1782 mi_cmd_remove_inferior (char *command, char **argv, int argc)
1783 {
1784   int id;
1785   struct inferior *inf;
1786
1787   if (argc != 1)
1788     error (_("-remove-inferior should be passed a single argument"));
1789
1790   if (sscanf (argv[0], "i%d", &id) != 1)
1791     error (_("the thread group id is syntactically invalid"));
1792
1793   inf = find_inferior_id (id);
1794   if (!inf)
1795     error (_("the specified thread group does not exist"));
1796
1797   if (inf->pid != 0)
1798     error (_("cannot remove an active inferior"));
1799
1800   if (inf == current_inferior ())
1801     {
1802       struct thread_info *tp = 0;
1803       struct inferior *new_inferior
1804         = iterate_over_inferiors (get_other_inferior, NULL);
1805
1806       if (new_inferior == NULL)
1807         error (_("Cannot remove last inferior"));
1808
1809       set_current_inferior (new_inferior);
1810       if (new_inferior->pid != 0)
1811         tp = any_thread_of_process (new_inferior->pid);
1812       switch_to_thread (tp ? tp->ptid : null_ptid);
1813       set_current_program_space (new_inferior->pspace);
1814     }
1815
1816   delete_inferior_1 (inf, 1 /* silent */);
1817 }
1818
1819 \f
1820
1821 /* Execute a command within a safe environment.
1822    Return <0 for error; >=0 for ok.
1823
1824    args->action will tell mi_execute_command what action
1825    to perfrom after the given command has executed (display/suppress
1826    prompt, display error). */
1827
1828 static void
1829 captured_mi_execute_command (struct ui_out *uiout, struct mi_parse *context)
1830 {
1831   struct cleanup *cleanup;
1832
1833   if (do_timings)
1834     current_command_ts = context->cmd_start;
1835
1836   current_token = xstrdup (context->token);
1837   cleanup = make_cleanup (free_current_contents, &current_token);
1838
1839   running_result_record_printed = 0;
1840   mi_proceeded = 0;
1841   switch (context->op)
1842     {
1843     case MI_COMMAND:
1844       /* A MI command was read from the input stream.  */
1845       if (mi_debug_p)
1846         /* FIXME: gdb_???? */
1847         fprintf_unfiltered (raw_stdout, " token=`%s' command=`%s' args=`%s'\n",
1848                             context->token, context->command, context->args);
1849
1850
1851       mi_cmd_execute (context);
1852
1853       /* Print the result if there were no errors.
1854
1855          Remember that on the way out of executing a command, you have
1856          to directly use the mi_interp's uiout, since the command could
1857          have reset the interpreter, in which case the current uiout
1858          will most likely crash in the mi_out_* routines.  */
1859       if (!running_result_record_printed)
1860         {
1861           fputs_unfiltered (context->token, raw_stdout);
1862           /* There's no particularly good reason why target-connect results
1863              in not ^done.  Should kill ^connected for MI3.  */
1864           fputs_unfiltered (strcmp (context->command, "target-select") == 0
1865                             ? "^connected" : "^done", raw_stdout);
1866           mi_out_put (uiout, raw_stdout);
1867           mi_out_rewind (uiout);
1868           mi_print_timing_maybe ();
1869           fputs_unfiltered ("\n", raw_stdout);
1870         }
1871       else
1872             /* The command does not want anything to be printed.  In that
1873                case, the command probably should not have written anything
1874                to uiout, but in case it has written something, discard it.  */
1875         mi_out_rewind (uiout);
1876       break;
1877
1878     case CLI_COMMAND:
1879       {
1880         char *argv[2];
1881
1882         /* A CLI command was read from the input stream.  */
1883         /* This "feature" will be removed as soon as we have a
1884            complete set of mi commands.  */
1885         /* Echo the command on the console.  */
1886         fprintf_unfiltered (gdb_stdlog, "%s\n", context->command);
1887         /* Call the "console" interpreter.  */
1888         argv[0] = "console";
1889         argv[1] = context->command;
1890         mi_cmd_interpreter_exec ("-interpreter-exec", argv, 2);
1891
1892         /* If we changed interpreters, DON'T print out anything.  */
1893         if (current_interp_named_p (INTERP_MI)
1894             || current_interp_named_p (INTERP_MI1)
1895             || current_interp_named_p (INTERP_MI2)
1896             || current_interp_named_p (INTERP_MI3))
1897           {
1898             if (!running_result_record_printed)
1899               {
1900                 fputs_unfiltered (context->token, raw_stdout);
1901                 fputs_unfiltered ("^done", raw_stdout);
1902                 mi_out_put (uiout, raw_stdout);
1903                 mi_out_rewind (uiout);
1904                 mi_print_timing_maybe ();
1905                 fputs_unfiltered ("\n", raw_stdout);
1906               }
1907             else
1908               mi_out_rewind (uiout);
1909           }
1910         break;
1911       }
1912
1913     }
1914
1915   do_cleanups (cleanup);
1916
1917   return;
1918 }
1919
1920 /* Print a gdb exception to the MI output stream.  */
1921
1922 static void
1923 mi_print_exception (const char *token, struct gdb_exception exception)
1924 {
1925   fputs_unfiltered (token, raw_stdout);
1926   fputs_unfiltered ("^error,msg=\"", raw_stdout);
1927   if (exception.message == NULL)
1928     fputs_unfiltered ("unknown error", raw_stdout);
1929   else
1930     fputstr_unfiltered (exception.message, '"', raw_stdout);
1931   fputs_unfiltered ("\"\n", raw_stdout);
1932 }
1933
1934 void
1935 mi_execute_command (char *cmd, int from_tty)
1936 {
1937   char *token;
1938   struct mi_parse *command = NULL;
1939   volatile struct gdb_exception exception;
1940
1941   /* This is to handle EOF (^D). We just quit gdb.  */
1942   /* FIXME: we should call some API function here.  */
1943   if (cmd == 0)
1944     quit_force (NULL, from_tty);
1945
1946   target_log_command (cmd);
1947
1948   TRY_CATCH (exception, RETURN_MASK_ALL)
1949     {
1950       command = mi_parse (cmd, &token);
1951     }
1952   if (exception.reason < 0)
1953     {
1954       mi_print_exception (token, exception);
1955       xfree (token);
1956     }
1957   else
1958     {
1959       volatile struct gdb_exception result;
1960       ptid_t previous_ptid = inferior_ptid;
1961
1962       command->token = token;
1963
1964       if (do_timings)
1965         {
1966           command->cmd_start = (struct mi_timestamp *)
1967             xmalloc (sizeof (struct mi_timestamp));
1968           timestamp (command->cmd_start);
1969         }
1970
1971       TRY_CATCH (result, RETURN_MASK_ALL)
1972         {
1973           captured_mi_execute_command (current_uiout, command);
1974         }
1975       if (result.reason < 0)
1976         {
1977           /* The command execution failed and error() was called
1978              somewhere.  */
1979           mi_print_exception (command->token, result);
1980           mi_out_rewind (current_uiout);
1981         }
1982
1983       bpstat_do_actions ();
1984
1985       if (/* The notifications are only output when the top-level
1986              interpreter (specified on the command line) is MI.  */
1987           ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ()))
1988           /* Don't try report anything if there are no threads --
1989              the program is dead.  */
1990           && thread_count () != 0
1991           /* -thread-select explicitly changes thread. If frontend uses that
1992              internally, we don't want to emit =thread-selected, since
1993              =thread-selected is supposed to indicate user's intentions.  */
1994           && strcmp (command->command, "thread-select") != 0)
1995         {
1996           struct mi_interp *mi = top_level_interpreter_data ();
1997           int report_change = 0;
1998
1999           if (command->thread == -1)
2000             {
2001               report_change = (!ptid_equal (previous_ptid, null_ptid)
2002                                && !ptid_equal (inferior_ptid, previous_ptid)
2003                                && !ptid_equal (inferior_ptid, null_ptid));
2004             }
2005           else if (!ptid_equal (inferior_ptid, null_ptid))
2006             {
2007               struct thread_info *ti = inferior_thread ();
2008
2009               report_change = (ti->num != command->thread);
2010             }
2011
2012           if (report_change)
2013             {
2014               struct thread_info *ti = inferior_thread ();
2015
2016               target_terminal_ours ();
2017               fprintf_unfiltered (mi->event_channel,
2018                                   "thread-selected,id=\"%d\"",
2019                                   ti->num);
2020               gdb_flush (mi->event_channel);
2021             }
2022         }
2023
2024       mi_parse_free (command);
2025     }
2026
2027   fputs_unfiltered ("(gdb) \n", raw_stdout);
2028   gdb_flush (raw_stdout);
2029   /* Print any buffered hook code.  */
2030   /* ..... */
2031 }
2032
2033 static void
2034 mi_cmd_execute (struct mi_parse *parse)
2035 {
2036   struct cleanup *cleanup;
2037
2038   cleanup = prepare_execute_command ();
2039
2040   if (parse->all && parse->thread_group != -1)
2041     error (_("Cannot specify --thread-group together with --all"));
2042
2043   if (parse->all && parse->thread != -1)
2044     error (_("Cannot specify --thread together with --all"));
2045
2046   if (parse->thread_group != -1 && parse->thread != -1)
2047     error (_("Cannot specify --thread together with --thread-group"));
2048
2049   if (parse->frame != -1 && parse->thread == -1)
2050     error (_("Cannot specify --frame without --thread"));
2051
2052   if (parse->thread_group != -1)
2053     {
2054       struct inferior *inf = find_inferior_id (parse->thread_group);
2055       struct thread_info *tp = 0;
2056
2057       if (!inf)
2058         error (_("Invalid thread group for the --thread-group option"));
2059
2060       set_current_inferior (inf);
2061       /* This behaviour means that if --thread-group option identifies
2062          an inferior with multiple threads, then a random one will be picked.
2063          This is not a problem -- frontend should always provide --thread if
2064          it wishes to operate on a specific thread.  */
2065       if (inf->pid != 0)
2066         tp = any_thread_of_process (inf->pid);
2067       switch_to_thread (tp ? tp->ptid : null_ptid);
2068       set_current_program_space (inf->pspace);
2069     }
2070
2071   if (parse->thread != -1)
2072     {
2073       struct thread_info *tp = find_thread_id (parse->thread);
2074
2075       if (!tp)
2076         error (_("Invalid thread id: %d"), parse->thread);
2077
2078       if (is_exited (tp->ptid))
2079         error (_("Thread id: %d has terminated"), parse->thread);
2080
2081       switch_to_thread (tp->ptid);
2082     }
2083
2084   if (parse->frame != -1)
2085     {
2086       struct frame_info *fid;
2087       int frame = parse->frame;
2088
2089       fid = find_relative_frame (get_current_frame (), &frame);
2090       if (frame == 0)
2091         /* find_relative_frame was successful */
2092         select_frame (fid);
2093       else
2094         error (_("Invalid frame id: %d"), frame);
2095     }
2096
2097   current_context = parse;
2098
2099   if (strncmp (parse->command, "break-", sizeof ("break-") - 1 ) == 0)
2100     {
2101       make_cleanup_restore_integer (&mi_suppress_breakpoint_notifications);
2102       mi_suppress_breakpoint_notifications = 1;
2103     }
2104
2105   if (parse->cmd->argv_func != NULL)
2106     {
2107       parse->cmd->argv_func (parse->command, parse->argv, parse->argc);
2108     }
2109   else if (parse->cmd->cli.cmd != 0)
2110     {
2111       /* FIXME: DELETE THIS. */
2112       /* The operation is still implemented by a cli command.  */
2113       /* Must be a synchronous one.  */
2114       mi_execute_cli_command (parse->cmd->cli.cmd, parse->cmd->cli.args_p,
2115                               parse->args);
2116     }
2117   else
2118     {
2119       /* FIXME: DELETE THIS.  */
2120       struct ui_file *stb;
2121
2122       stb = mem_fileopen ();
2123
2124       fputs_unfiltered ("Undefined mi command: ", stb);
2125       fputstr_unfiltered (parse->command, '"', stb);
2126       fputs_unfiltered (" (missing implementation)", stb);
2127
2128       make_cleanup_ui_file_delete (stb);
2129       error_stream (stb);
2130     }
2131   do_cleanups (cleanup);
2132 }
2133
2134 /* FIXME: This is just a hack so we can get some extra commands going.
2135    We don't want to channel things through the CLI, but call libgdb directly.
2136    Use only for synchronous commands.  */
2137
2138 void
2139 mi_execute_cli_command (const char *cmd, int args_p, const char *args)
2140 {
2141   if (cmd != 0)
2142     {
2143       struct cleanup *old_cleanups;
2144       char *run;
2145
2146       if (args_p)
2147         run = xstrprintf ("%s %s", cmd, args);
2148       else
2149         run = xstrdup (cmd);
2150       if (mi_debug_p)
2151         /* FIXME: gdb_???? */
2152         fprintf_unfiltered (gdb_stdout, "cli=%s run=%s\n",
2153                             cmd, run);
2154       old_cleanups = make_cleanup (xfree, run);
2155       execute_command ( /*ui */ run, 0 /*from_tty */ );
2156       do_cleanups (old_cleanups);
2157       return;
2158     }
2159 }
2160
2161 void
2162 mi_execute_async_cli_command (char *cli_command, char **argv, int argc)
2163 {
2164   struct cleanup *old_cleanups;
2165   char *run;
2166
2167   if (target_can_async_p ())
2168     run = xstrprintf ("%s %s&", cli_command, argc ? *argv : "");
2169   else
2170     run = xstrprintf ("%s %s", cli_command, argc ? *argv : "");
2171   old_cleanups = make_cleanup (xfree, run);
2172
2173   execute_command ( /*ui */ run, 0 /*from_tty */ );
2174
2175   /* Do this before doing any printing.  It would appear that some
2176      print code leaves garbage around in the buffer.  */
2177   do_cleanups (old_cleanups);
2178 }
2179
2180 void
2181 mi_load_progress (const char *section_name,
2182                   unsigned long sent_so_far,
2183                   unsigned long total_section,
2184                   unsigned long total_sent,
2185                   unsigned long grand_total)
2186 {
2187   struct timeval time_now, delta, update_threshold;
2188   static struct timeval last_update;
2189   static char *previous_sect_name = NULL;
2190   int new_section;
2191   struct ui_out *saved_uiout;
2192   struct ui_out *uiout;
2193
2194   /* This function is called through deprecated_show_load_progress
2195      which means uiout may not be correct.  Fix it for the duration
2196      of this function.  */
2197   saved_uiout = current_uiout;
2198
2199   if (current_interp_named_p (INTERP_MI)
2200       || current_interp_named_p (INTERP_MI2))
2201     current_uiout = mi_out_new (2);
2202   else if (current_interp_named_p (INTERP_MI1))
2203     current_uiout = mi_out_new (1);
2204   else if (current_interp_named_p (INTERP_MI3))
2205     current_uiout = mi_out_new (3);
2206   else
2207     return;
2208
2209   uiout = current_uiout;
2210
2211   update_threshold.tv_sec = 0;
2212   update_threshold.tv_usec = 500000;
2213   gettimeofday (&time_now, NULL);
2214
2215   delta.tv_usec = time_now.tv_usec - last_update.tv_usec;
2216   delta.tv_sec = time_now.tv_sec - last_update.tv_sec;
2217
2218   if (delta.tv_usec < 0)
2219     {
2220       delta.tv_sec -= 1;
2221       delta.tv_usec += 1000000L;
2222     }
2223
2224   new_section = (previous_sect_name ?
2225                  strcmp (previous_sect_name, section_name) : 1);
2226   if (new_section)
2227     {
2228       struct cleanup *cleanup_tuple;
2229
2230       xfree (previous_sect_name);
2231       previous_sect_name = xstrdup (section_name);
2232
2233       if (current_token)
2234         fputs_unfiltered (current_token, raw_stdout);
2235       fputs_unfiltered ("+download", raw_stdout);
2236       cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
2237       ui_out_field_string (uiout, "section", section_name);
2238       ui_out_field_int (uiout, "section-size", total_section);
2239       ui_out_field_int (uiout, "total-size", grand_total);
2240       do_cleanups (cleanup_tuple);
2241       mi_out_put (uiout, raw_stdout);
2242       fputs_unfiltered ("\n", raw_stdout);
2243       gdb_flush (raw_stdout);
2244     }
2245
2246   if (delta.tv_sec >= update_threshold.tv_sec &&
2247       delta.tv_usec >= update_threshold.tv_usec)
2248     {
2249       struct cleanup *cleanup_tuple;
2250
2251       last_update.tv_sec = time_now.tv_sec;
2252       last_update.tv_usec = time_now.tv_usec;
2253       if (current_token)
2254         fputs_unfiltered (current_token, raw_stdout);
2255       fputs_unfiltered ("+download", raw_stdout);
2256       cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
2257       ui_out_field_string (uiout, "section", section_name);
2258       ui_out_field_int (uiout, "section-sent", sent_so_far);
2259       ui_out_field_int (uiout, "section-size", total_section);
2260       ui_out_field_int (uiout, "total-sent", total_sent);
2261       ui_out_field_int (uiout, "total-size", grand_total);
2262       do_cleanups (cleanup_tuple);
2263       mi_out_put (uiout, raw_stdout);
2264       fputs_unfiltered ("\n", raw_stdout);
2265       gdb_flush (raw_stdout);
2266     }
2267
2268   xfree (uiout);
2269   uiout = saved_uiout;
2270 }
2271
2272 static void
2273 timestamp (struct mi_timestamp *tv)
2274   {
2275     gettimeofday (&tv->wallclock, NULL);
2276 #ifdef HAVE_GETRUSAGE
2277     getrusage (RUSAGE_SELF, &rusage);
2278     tv->utime.tv_sec = rusage.ru_utime.tv_sec;
2279     tv->utime.tv_usec = rusage.ru_utime.tv_usec;
2280     tv->stime.tv_sec = rusage.ru_stime.tv_sec;
2281     tv->stime.tv_usec = rusage.ru_stime.tv_usec;
2282 #else
2283     {
2284       long usec = get_run_time ();
2285
2286       tv->utime.tv_sec = usec/1000000L;
2287       tv->utime.tv_usec = usec - 1000000L*tv->utime.tv_sec;
2288       tv->stime.tv_sec = 0;
2289       tv->stime.tv_usec = 0;
2290     }
2291 #endif
2292   }
2293
2294 static void
2295 print_diff_now (struct mi_timestamp *start)
2296   {
2297     struct mi_timestamp now;
2298
2299     timestamp (&now);
2300     print_diff (start, &now);
2301   }
2302
2303 void
2304 mi_print_timing_maybe (void)
2305 {
2306   /* If the command is -enable-timing then do_timings may be
2307      true whilst current_command_ts is not initialized.  */
2308   if (do_timings && current_command_ts)
2309     print_diff_now (current_command_ts);
2310 }
2311
2312 static long
2313 timeval_diff (struct timeval start, struct timeval end)
2314   {
2315     return ((end.tv_sec - start.tv_sec) * 1000000L)
2316       + (end.tv_usec - start.tv_usec);
2317   }
2318
2319 static void
2320 print_diff (struct mi_timestamp *start, struct mi_timestamp *end)
2321   {
2322     fprintf_unfiltered
2323       (raw_stdout,
2324        ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
2325        timeval_diff (start->wallclock, end->wallclock) / 1000000.0,
2326        timeval_diff (start->utime, end->utime) / 1000000.0,
2327        timeval_diff (start->stime, end->stime) / 1000000.0);
2328   }
2329
2330 void
2331 mi_cmd_trace_define_variable (char *command, char **argv, int argc)
2332 {
2333   struct expression *expr;
2334   struct cleanup *back_to;
2335   LONGEST initval = 0;
2336   struct trace_state_variable *tsv;
2337   char *name = 0;
2338
2339   if (argc != 1 && argc != 2)
2340     error (_("Usage: -trace-define-variable VARIABLE [VALUE]"));
2341
2342   expr = parse_expression (argv[0]);
2343   back_to = make_cleanup (xfree, expr);
2344
2345   if (expr->nelts == 3 && expr->elts[0].opcode == OP_INTERNALVAR)
2346     {
2347       struct internalvar *intvar = expr->elts[1].internalvar;
2348
2349       if (intvar)
2350         name = internalvar_name (intvar);
2351     }
2352
2353   if (!name || *name == '\0')
2354     error (_("Invalid name of trace variable"));
2355
2356   tsv = find_trace_state_variable (name);
2357   if (!tsv)
2358     tsv = create_trace_state_variable (name);
2359
2360   if (argc == 2)
2361     initval = value_as_long (parse_and_eval (argv[1]));
2362
2363   tsv->initial_value = initval;
2364
2365   do_cleanups (back_to);
2366 }
2367
2368 void
2369 mi_cmd_trace_list_variables (char *command, char **argv, int argc)
2370 {
2371   if (argc != 0)
2372     error (_("-trace-list-variables: no arguments are allowed"));
2373
2374   tvariables_info_1 ();
2375 }
2376
2377 void
2378 mi_cmd_trace_find (char *command, char **argv, int argc)
2379 {
2380   char *mode;
2381
2382   if (argc == 0)
2383     error (_("trace selection mode is required"));
2384
2385   mode = argv[0];
2386
2387   if (strcmp (mode, "none") == 0)
2388     {
2389       tfind_1 (tfind_number, -1, 0, 0, 0);
2390       return;
2391     }
2392
2393   if (current_trace_status ()->running)
2394     error (_("May not look at trace frames while trace is running."));
2395
2396   if (strcmp (mode, "frame-number") == 0)
2397     {
2398       if (argc != 2)
2399         error (_("frame number is required"));
2400       tfind_1 (tfind_number, atoi (argv[1]), 0, 0, 0);
2401     }
2402   else if (strcmp (mode, "tracepoint-number") == 0)
2403     {
2404       if (argc != 2)
2405         error (_("tracepoint number is required"));
2406       tfind_1 (tfind_tp, atoi (argv[1]), 0, 0, 0);
2407     }
2408   else if (strcmp (mode, "pc") == 0)
2409     {
2410       if (argc != 2)
2411         error (_("PC is required"));
2412       tfind_1 (tfind_pc, 0, parse_and_eval_address (argv[1]), 0, 0);
2413     }
2414   else if (strcmp (mode, "pc-inside-range") == 0)
2415     {
2416       if (argc != 3)
2417         error (_("Start and end PC are required"));
2418       tfind_1 (tfind_range, 0, parse_and_eval_address (argv[1]),
2419                parse_and_eval_address (argv[2]), 0);
2420     }
2421   else if (strcmp (mode, "pc-outside-range") == 0)
2422     {
2423       if (argc != 3)
2424         error (_("Start and end PC are required"));
2425       tfind_1 (tfind_outside, 0, parse_and_eval_address (argv[1]),
2426                parse_and_eval_address (argv[2]), 0);
2427     }
2428   else if (strcmp (mode, "line") == 0)
2429     {
2430       struct symtabs_and_lines sals;
2431       struct symtab_and_line sal;
2432       static CORE_ADDR start_pc, end_pc;
2433       struct cleanup *back_to;
2434
2435       if (argc != 2)
2436         error (_("Line is required"));
2437
2438       sals = decode_line_spec (argv[1], 1);
2439       back_to = make_cleanup (xfree, sals.sals);
2440
2441       sal = sals.sals[0];
2442
2443       if (sal.symtab == 0)
2444         error (_("Could not find the specified line"));
2445
2446       if (sal.line > 0 && find_line_pc_range (sal, &start_pc, &end_pc))
2447         tfind_1 (tfind_range, 0, start_pc, end_pc - 1, 0);
2448       else
2449         error (_("Could not find the specified line"));
2450
2451       do_cleanups (back_to);
2452     }
2453   else
2454     error (_("Invalid mode '%s'"), mode);
2455
2456   if (has_stack_frames () || get_traceframe_number () >= 0)
2457     {
2458       print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
2459     }
2460 }
2461
2462 void
2463 mi_cmd_trace_save (char *command, char **argv, int argc)
2464 {
2465   int target_saves = 0;
2466   char *filename;
2467
2468   if (argc != 1 && argc != 2)
2469     error (_("Usage: -trace-save [-r] filename"));
2470
2471   if (argc == 2)
2472     {
2473       filename = argv[1];
2474       if (strcmp (argv[0], "-r") == 0)
2475         target_saves = 1;
2476       else
2477         error (_("Invalid option: %s"), argv[0]);
2478     }
2479   else
2480     {
2481       filename = argv[0];
2482     }
2483
2484   trace_save (filename, target_saves);
2485 }
2486
2487
2488 void
2489 mi_cmd_trace_start (char *command, char **argv, int argc)
2490 {
2491   start_tracing ();
2492 }
2493
2494 void
2495 mi_cmd_trace_status (char *command, char **argv, int argc)
2496 {
2497   trace_status_mi (0);
2498 }
2499
2500 void
2501 mi_cmd_trace_stop (char *command, char **argv, int argc)
2502 {
2503   stop_tracing ();
2504   trace_status_mi (1);
2505 }