gdb/mi/mi-main.c

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