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