gdb/mi/mi-main.c - gdb

Global variables defined

Data types defined

Functions defined

Source code

  1. /* MI Command Set.

  3.    Copyright (C) 2000-2015 Free Software Foundation, Inc.

  5.    Contributed by Cygnus Solutions (a Red Hat company).

  7.    This file is part of GDB.

  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.

  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.

  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/>.  */

  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 "gdb.h"
  42. #include "frame.h"
  43. #include "mi-main.h"
  44. #include "mi-common.h"
  45. #include "language.h"
  46. #include "valprint.h"
  47. #include "inferior.h"
  48. #include "osdata.h"
  49. #include "splay-tree.h"
  50. #include "tracepoint.h"
  51. #include "ctf.h"
  52. #include "ada-lang.h"
  53. #include "linespec.h"
  54. #include "extension.h"
  55. #include "gdbcmd.h"

  57. #include <ctype.h>
  58. #include <sys/time.h>

  60. #if defined HAVE_SYS_RESOURCE_H
  61. #include <sys/resource.h>
  62. #endif

  64. #ifdef HAVE_GETRUSAGE
  65. ‌struct rusage rusage;
  66. #endif

  68. enum
  69.   {
  70.     FROM_TTY = 0
  71.   };

  73. ‌int mi_debug_p;

  75. ‌struct ui_file *raw_stdout;

  77. /* This is used to pass the current command timestamp down to
  78.    continuation routines.  */
  79. ‌static struct mi_timestamp *current_command_ts;

  81. ‌static int do_timings = 0;

  83. ‌char *current_token;
  84. /* Few commands would like to know if options like --thread-group were
  85.    explicitly specified.  This variable keeps the current parsed
  86.    command including all option, and make it possible.  */
  87. ‌static struct mi_parse *current_context;

  89. ‌int running_result_record_printed = 1;

  91. /* Flag indicating that the target has proceeded since the last
  92.    command was issued.  */
  93. ‌int mi_proceeded;

  95. extern void _initialize_mi_main (void);
  96. static void mi_cmd_execute (struct mi_parse *parse);

  98. static void mi_execute_cli_command (const char *cmd, int args_p,
  99.                                     const char *args);
  100. static void mi_execute_async_cli_command (char *cli_command,
  101.                                           char **argv, int argc);
  102. static int register_changed_p (int regnum, struct regcache *,
  103.                                struct regcache *);
  104. static void output_register (struct frame_info *, int regnum, int format,
  105.                              int skip_unavailable);

  107. /* Controls whether the frontend wants MI in async mode.  */
  108. ‌static int mi_async = 0;

  110. /* The set command writes to this variable.  If the inferior is
  111.    executing, mi_async is *not* updated.  */
  112. ‌static int mi_async_1 = 0;

  114. static void
  115. ‌set_mi_async_command (char *args, int from_tty,
  116.                       struct cmd_list_element *c)
  117. {
  118.   if (have_live_inferiors ())
  119.     {
  120.       mi_async_1 = mi_async;
  121.       error (_("Cannot change this setting while the inferior is running."));
  122.     }

  124.   mi_async = mi_async_1;
  125. }

  127. static void
  128. ‌show_mi_async_command (struct ui_file *file, int from_tty,
  129.                        struct cmd_list_element *c,
  130.                        const char *value)
  131. {
  132.   fprintf_filtered (file,
  133.                     _("Whether MI is in asynchronous mode is %s.\n"),
  134.                     value);
  135. }

  137. /* A wrapper for target_can_async_p that takes the MI setting into
  138.    account.  */

  140. int
  141. ‌mi_async_p (void)
  142. {
  143.   return mi_async && target_can_async_p ();
  144. }

  146. /* Command implementations.  FIXME: Is this libgdb?  No.  This is the MI
  147.    layer that calls libgdb.  Any operation used in the below should be
  148.    formalized.  */

  150. static void timestamp (struct mi_timestamp *tv);

  152. static void print_diff_now (struct mi_timestamp *start);
  153. static void print_diff (struct mi_timestamp *start, struct mi_timestamp *end);

  155. void
  156. ‌mi_cmd_gdb_exit (char *command, char **argv, int argc)
  157. {
  158.   /* We have to print everything right here because we never return.  */
  159.   if (current_token)
  160.     fputs_unfiltered (current_token, raw_stdout);
  161.   fputs_unfiltered ("^exit\n", raw_stdout);
  162.   mi_out_put (current_uiout, raw_stdout);
  163.   gdb_flush (raw_stdout);
  164.   /* FIXME: The function called is not yet a formal libgdb function.  */
  165.   quit_force (NULL, FROM_TTY);
  166. }

  168. void
  169. ‌mi_cmd_exec_next (char *command, char **argv, int argc)
  170. {
  171.   /* FIXME: Should call a libgdb function, not a cli wrapper.  */
  172.   if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
  173.     mi_execute_async_cli_command ("reverse-next", argv + 1, argc - 1);
  174.   else
  175.     mi_execute_async_cli_command ("next", argv, argc);
  176. }

  178. void
  179. ‌mi_cmd_exec_next_instruction (char *command, char **argv, int argc)
  180. {
  181.   /* FIXME: Should call a libgdb function, not a cli wrapper.  */
  182.   if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
  183.     mi_execute_async_cli_command ("reverse-nexti", argv + 1, argc - 1);
  184.   else
  185.     mi_execute_async_cli_command ("nexti", argv, argc);
  186. }

  188. void
  189. ‌mi_cmd_exec_step (char *command, char **argv, int argc)
  190. {
  191.   /* FIXME: Should call a libgdb function, not a cli wrapper.  */
  192.   if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
  193.     mi_execute_async_cli_command ("reverse-step", argv + 1, argc - 1);
  194.   else
  195.     mi_execute_async_cli_command ("step", argv, argc);
  196. }

  198. void
  199. ‌mi_cmd_exec_step_instruction (char *command, char **argv, int argc)
  200. {
  201.   /* FIXME: Should call a libgdb function, not a cli wrapper.  */
  202.   if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
  203.     mi_execute_async_cli_command ("reverse-stepi", argv + 1, argc - 1);
  204.   else
  205.     mi_execute_async_cli_command ("stepi", argv, argc);
  206. }

  208. void
  209. ‌mi_cmd_exec_finish (char *command, char **argv, int argc)
  210. {
  211.   /* FIXME: Should call a libgdb function, not a cli wrapper.  */
  212.   if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
  213.     mi_execute_async_cli_command ("reverse-finish", argv + 1, argc - 1);
  214.   else
  215.     mi_execute_async_cli_command ("finish", argv, argc);
  216. }

  218. void
  219. ‌mi_cmd_exec_return (char *command, char **argv, int argc)
  220. {
  221.   /* This command doesn't really execute the target, it just pops the
  222.      specified number of frames.  */
  223.   if (argc)
  224.     /* Call return_command with from_tty argument equal to 0 so as to
  225.        avoid being queried.  */
  226.     return_command (*argv, 0);
  227.   else
  228.     /* Call return_command with from_tty argument equal to 0 so as to
  229.        avoid being queried.  */
  230.     return_command (NULL, 0);

  232.   /* Because we have called return_command with from_tty = 0, we need
  233.      to print the frame here.  */
  234.   print_stack_frame (get_selected_frame (NULL), 1, LOC_AND_ADDRESS, 1);
  235. }

  237. void
  238. ‌mi_cmd_exec_jump (char *args, char **argv, int argc)
  239. {
  240.   /* FIXME: Should call a libgdb function, not a cli wrapper.  */
  241.   mi_execute_async_cli_command ("jump", argv, argc);
  242. }

  244. static void
  245. ‌proceed_thread (struct thread_info *thread, int pid)
  246. {
  247.   if (!is_stopped (thread->ptid))
  248.     return;

  250.   if (pid != 0 && ptid_get_pid (thread->ptid) != pid)
  251.     return;

  253.   switch_to_thread (thread->ptid);
  254.   clear_proceed_status (0);
  255.   proceed ((CORE_ADDR) -1, GDB_SIGNAL_DEFAULT, 0);
  256. }

  258. static int
  259. ‌proceed_thread_callback (struct thread_info *thread, void *arg)
  260. {
  261.   int pid = *(int *)arg;

  263.   proceed_thread (thread, pid);
  264.   return 0;
  265. }

  267. static void
  268. ‌exec_continue (char **argv, int argc)
  269. {
  270.   prepare_execution_command (&current_target, mi_async_p ());

  272.   if (non_stop)
  273.     {
  274.       /* In non-stop mode, 'resume' always resumes a single thread.
  275.          Therefore, to resume all threads of the current inferior, or
  276.          all threads in all inferiors, we need to iterate over
  277.          threads.

  279.          See comment on infcmd.c:proceed_thread_callback for rationale.  */
  280.       if (current_context->all || current_context->thread_group != -1)
  281.         {
  282.           int pid = 0;
  283.           struct cleanup *back_to = make_cleanup_restore_current_thread ();

  285.           if (!current_context->all)
  286.             {
  287.               struct inferior *inf
  288.                 = find_inferior_id (current_context->thread_group);

  290.               pid = inf->pid;
  291.             }
  292.           iterate_over_threads (proceed_thread_callback, &pid);
  293.           do_cleanups (back_to);
  294.         }
  295.       else
  296.         {
  297.           continue_1 (0);
  298.         }
  299.     }
  300.   else
  301.     {
  302.       struct cleanup *back_to = make_cleanup_restore_integer (&sched_multi);

  304.       if (current_context->all)
  305.         {
  306.           sched_multi = 1;
  307.           continue_1 (0);
  308.         }
  309.       else
  310.         {
  311.           /* In all-stop mode, -exec-continue traditionally resumed
  312.              either all threads, or one thread, depending on the
  313.              'scheduler-locking' variable.  Let's continue to do the
  314.              same.  */
  315.           continue_1 (1);
  316.         }
  317.       do_cleanups (back_to);
  318.     }
  319. }

  321. static void
  322. ‌exec_direction_forward (void *notused)
  323. {
  324.   execution_direction = EXEC_FORWARD;
  325. }

  327. static void
  328. ‌exec_reverse_continue (char **argv, int argc)
  329. {
  330.   enum exec_direction_kind dir = execution_direction;
  331.   struct cleanup *old_chain;

  333.   if (dir == EXEC_REVERSE)
  334.     error (_("Already in reverse mode."));

  336.   if (!target_can_execute_reverse)
  337.     error (_("Target %s does not support this command."), target_shortname);

  339.   old_chain = make_cleanup (exec_direction_forward, NULL);
  340.   execution_direction = EXEC_REVERSE;
  341.   exec_continue (argv, argc);
  342.   do_cleanups (old_chain);
  343. }

  345. void
  346. ‌mi_cmd_exec_continue (char *command, char **argv, int argc)
  347. {
  348.   if (argc > 0 && strcmp (argv[0], "--reverse") == 0)
  349.     exec_reverse_continue (argv + 1, argc - 1);
  350.   else
  351.     exec_continue (argv, argc);
  352. }

  354. static int
  355. ‌interrupt_thread_callback (struct thread_info *thread, void *arg)
  356. {
  357.   int pid = *(int *)arg;

  359.   if (!is_running (thread->ptid))
  360.     return 0;

  362.   if (ptid_get_pid (thread->ptid) != pid)
  363.     return 0;

  365.   target_stop (thread->ptid);
  366.   return 0;
  367. }

  369. /* Interrupt the execution of the target.  Note how we must play
  370.    around with the token variables, in order to display the current
  371.    token in the result of the interrupt command, and the previous
  372.    execution token when the target finally stops.  See comments in
  373.    mi_cmd_execute.  */

  375. void
  376. ‌mi_cmd_exec_interrupt (char *command, char **argv, int argc)
  377. {
  378.   /* In all-stop mode, everything stops, so we don't need to try
  379.      anything specific.  */
  380.   if (!non_stop)
  381.     {
  382.       interrupt_target_1 (0);
  383.       return;
  384.     }

  386.   if (current_context->all)
  387.     {
  388.       /* This will interrupt all threads in all inferiors.  */
  389.       interrupt_target_1 (1);
  390.     }
  391.   else if (current_context->thread_group != -1)
  392.     {
  393.       struct inferior *inf = find_inferior_id (current_context->thread_group);

  395.       iterate_over_threads (interrupt_thread_callback, &inf->pid);
  396.     }
  397.   else
  398.     {
  399.       /* Interrupt just the current thread -- either explicitly
  400.          specified via --thread or whatever was current before
  401.          MI command was sent.  */
  402.       interrupt_target_1 (0);
  403.     }
  404. }

  406. /* Callback for iterate_over_inferiors which starts the execution
  407.    of the given inferior.

  409.    ARG is a pointer to an integer whose value, if non-zero, indicates
  410.    that the program should be stopped when reaching the main subprogram
  411.    (similar to what the CLI "start" command does).  */

  413. static int
  414. ‌run_one_inferior (struct inferior *inf, void *arg)
  415. {
  416.   int start_p = *(int *) arg;
  417.   const char *run_cmd = start_p ? "start" : "run";

  419.   if (inf->pid != 0)
  420.     {
  421.       if (inf->pid != ptid_get_pid (inferior_ptid))
  422.         {
  423.           struct thread_info *tp;

  425.           tp = any_thread_of_process (inf->pid);
  426.           if (!tp)
  427.             error (_("Inferior has no threads."));

  429.           switch_to_thread (tp->ptid);
  430.         }
  431.     }
  432.   else
  433.     {
  434.       set_current_inferior (inf);
  435.       switch_to_thread (null_ptid);
  436.       set_current_program_space (inf->pspace);
  437.     }
  438.   mi_execute_cli_command (run_cmd, mi_async_p (),
  439.                           mi_async_p () ? "&" : NULL);
  440.   return 0;
  441. }

  443. void
  444. ‌mi_cmd_exec_run (char *command, char **argv, int argc)
  445. {
  446.   int i;
  447.   int start_p = 0;

  449.   /* Parse the command options.  */
  450.   enum opt
  451.     {
  452.       START_OPT,
  453.     };
  454.   static const struct mi_opt opts[] =
  455.     {
  456.         {"-start", START_OPT, 0},
  457.         {NULL, 0, 0},
  458.     };

  460.   int oind = 0;
  461.   char *oarg;

  463.   while (1)
  464.     {
  465.       int opt = mi_getopt ("-exec-run", argc, argv, opts, &oind, &oarg);

  467.       if (opt < 0)
  468.         break;
  469.       switch ((enum opt) opt)
  470.         {
  471.         case START_OPT:
  472.           start_p = 1;
  473.           break;
  474.         }
  475.     }

  477.   /* This command does not accept any argument.  Make sure the user
  478.      did not provide any.  */
  479.   if (oind != argc)
  480.     error (_("Invalid argument: %s"), argv[oind]);

  482.   if (current_context->all)
  483.     {
  484.       struct cleanup *back_to = save_current_space_and_thread ();

  486.       iterate_over_inferiors (run_one_inferior, &start_p);
  487.       do_cleanups (back_to);
  488.     }
  489.   else
  490.     {
  491.       const char *run_cmd = start_p ? "start" : "run";

  493.       mi_execute_cli_command (run_cmd, mi_async_p (),
  494.                               mi_async_p () ? "&" : NULL);
  495.     }
  496. }


  499. static int
  500. ‌find_thread_of_process (struct thread_info *ti, void *p)
  501. {
  502.   int pid = *(int *)p;

  504.   if (ptid_get_pid (ti->ptid) == pid && !is_exited (ti->ptid))
  505.     return 1;

  507.   return 0;
  508. }

  510. void
  511. ‌mi_cmd_target_detach (char *command, char **argv, int argc)
  512. {
  513.   if (argc != 0 && argc != 1)
  514.     error (_("Usage: -target-detach [pid | thread-group]"));

  516.   if (argc == 1)
  517.     {
  518.       struct thread_info *tp;
  519.       char *end = argv[0];
  520.       int pid;

  522.       /* First see if we are dealing with a thread-group id.  */
  523.       if (*argv[0] == 'i')
  524.         {
  525.           struct inferior *inf;
  526.           int id = strtoul (argv[0] + 1, &end, 0);

  528.           if (*end != '\0')
  529.             error (_("Invalid syntax of thread-group id '%s'"), argv[0]);

  531.           inf = find_inferior_id (id);
  532.           if (!inf)
  533.             error (_("Non-existent thread-group id '%d'"), id);

  535.           pid = inf->pid;
  536.         }
  537.       else
  538.         {
  539.           /* We must be dealing with a pid.  */
  540.           pid = strtol (argv[0], &end, 10);

  542.           if (*end != '\0')
  543.             error (_("Invalid identifier '%s'"), argv[0]);
  544.         }

  546.       /* Pick any thread in the desired process.  Current
  547.          target_detach detaches from the parent of inferior_ptid.  */
  548.       tp = iterate_over_threads (find_thread_of_process, &pid);
  549.       if (!tp)
  550.         error (_("Thread group is empty"));

  552.       switch_to_thread (tp->ptid);
  553.     }

  555.   detach_command (NULL, 0);
  556. }

  558. void
  559. ‌mi_cmd_thread_select (char *command, char **argv, int argc)
  560. {
  561.   enum gdb_rc rc;
  562.   char *mi_error_message;

  564.   if (argc != 1)
  565.     error (_("-thread-select: USAGE: threadnum."));

  567.   rc = gdb_thread_select (current_uiout, argv[0], &mi_error_message);

  569.   if (rc == GDB_RC_FAIL)
  570.     {
  571.       make_cleanup (xfree, mi_error_message);
  572.       error ("%s", mi_error_message);
  573.     }
  574. }

  576. void
  577. ‌mi_cmd_thread_list_ids (char *command, char **argv, int argc)
  578. {
  579.   enum gdb_rc rc;
  580.   char *mi_error_message;

  582.   if (argc != 0)
  583.     error (_("-thread-list-ids: No arguments required."));

  585.   rc = gdb_list_thread_ids (current_uiout, &mi_error_message);

  587.   if (rc == GDB_RC_FAIL)
  588.     {
  589.       make_cleanup (xfree, mi_error_message);
  590.       error ("%s", mi_error_message);
  591.     }
  592. }

  594. void
  595. ‌mi_cmd_thread_info (char *command, char **argv, int argc)
  596. {
  597.   if (argc != 0 && argc != 1)
  598.     error (_("Invalid MI command"));

  600.   print_thread_info (current_uiout, argv[0], -1);
  601. }

  603. ‌struct collect_cores_data
  604. {
  605.   int pid;

  607.   VEC (int) *cores;
  608. };

  610. static int
  611. ‌collect_cores (struct thread_info *ti, void *xdata)
  612. {
  613.   struct collect_cores_data *data = xdata;

  615.   if (ptid_get_pid (ti->ptid) == data->pid)
  616.     {
  617.       int core = target_core_of_thread (ti->ptid);

  619.       if (core != -1)
  620.         VEC_safe_push (int, data->cores, core);
  621.     }

  623.   return 0;
  624. }

  626. static int *
  627. ‌unique (int *b, int *e)
  628. {
  629.   int *d = b;

  631.   while (++b != e)
  632.     if (*d != *b)
  633.       *++d = *b;
  634.   return ++d;
  635. }

  637. ‌struct print_one_inferior_data
  638. {
  639.   int recurse;
  640.   VEC (int) *inferiors;
  641. };

  643. static int
  644. ‌print_one_inferior (struct inferior *inferior, void *xdata)
  645. {
  646.   struct print_one_inferior_data *top_data = xdata;
  647.   struct ui_out *uiout = current_uiout;

  649.   if (VEC_empty (int, top_data->inferiors)
  650.       || bsearch (&(inferior->pid), VEC_address (int, top_data->inferiors),
  651.                   VEC_length (int, top_data->inferiors), sizeof (int),
  652.                   compare_positive_ints))
  653.     {
  654.       struct collect_cores_data data;
  655.       struct cleanup *back_to
  656.         = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);

  658.       ui_out_field_fmt (uiout, "id", "i%d", inferior->num);
  659.       ui_out_field_string (uiout, "type", "process");
  660.       if (inferior->has_exit_code)
  661.         ui_out_field_string (uiout, "exit-code",
  662.                              int_string (inferior->exit_code, 8, 0, 0, 1));
  663.       if (inferior->pid != 0)
  664.         ui_out_field_int (uiout, "pid", inferior->pid);

  666.       if (inferior->pspace->pspace_exec_filename != NULL)
  667.         {
  668.           ui_out_field_string (uiout, "executable",
  669.                                inferior->pspace->pspace_exec_filename);
  670.         }

  672.       data.cores = 0;
  673.       if (inferior->pid != 0)
  674.         {
  675.           data.pid = inferior->pid;
  676.           iterate_over_threads (collect_cores, &data);
  677.         }

  679.       if (!VEC_empty (int, data.cores))
  680.         {
  681.           int *b, *e;
  682.           struct cleanup *back_to_2 =
  683.             make_cleanup_ui_out_list_begin_end (uiout, "cores");

  685.           qsort (VEC_address (int, data.cores),
  686.                  VEC_length (int, data.cores), sizeof (int),
  687.                  compare_positive_ints);

  689.           b = VEC_address (int, data.cores);
  690.           e = b + VEC_length (int, data.cores);
  691.           e = unique (b, e);

  693.           for (; b != e; ++b)
  694.             ui_out_field_int (uiout, NULL, *b);

  696.           do_cleanups (back_to_2);
  697.         }

  699.       if (top_data->recurse)
  700.         print_thread_info (uiout, NULL, inferior->pid);

  702.       do_cleanups (back_to);
  703.     }

  705.   return 0;
  706. }

  708. /* Output a field named 'cores' with a list as the value.  The
  709.    elements of the list are obtained by splitting 'cores' on
  710.    comma.  */

  712. static void
  713. ‌output_cores (struct ui_out *uiout, const char *field_name, const char *xcores)
  714. {
  715.   struct cleanup *back_to = make_cleanup_ui_out_list_begin_end (uiout,
  716.                                                                 field_name);
  717.   char *cores = xstrdup (xcores);
  718.   char *p = cores;

  720.   make_cleanup (xfree, cores);

  722.   for (p = strtok (p, ","); p;  p = strtok (NULL, ","))
  723.     ui_out_field_string (uiout, NULL, p);

  725.   do_cleanups (back_to);
  726. }

  728. static void
  729. ‌free_vector_of_ints (void *xvector)
  730. {
  731.   VEC (int) **vector = xvector;

  733.   VEC_free (int, *vector);
  734. }

  736. static void
  737. ‌do_nothing (splay_tree_key k)
  738. {
  739. }

  741. static void
  742. ‌free_vector_of_osdata_items (splay_tree_value xvalue)
  743. {
  744.   VEC (osdata_item_s) *value = (VEC (osdata_item_s) *) xvalue;

  746.   /* We don't free the items itself, it will be done separately.  */
  747.   VEC_free (osdata_item_s, value);
  748. }

  750. static int
  751. ‌splay_tree_int_comparator (splay_tree_key xa, splay_tree_key xb)
  752. {
  753.   int a = xa;
  754.   int b = xb;

  756.   return a - b;
  757. }

  759. static void
  760. ‌free_splay_tree (void *xt)
  761. {
  762.   splay_tree t = xt;
  763.   splay_tree_delete (t);
  764. }

  766. static void
  767. list_available_thread_groups (VEC (int) *ids, int recurse)
  768. {
  769.   struct osdata *data;
  770.   struct osdata_item *item;
  771.   int ix_items;
  772.   struct ui_out *uiout = current_uiout;
  773.   struct cleanup *cleanup;

  775.   /* This keeps a map from integer (pid) to VEC (struct osdata_item *)*
  776.      The vector contains information about all threads for the given pid.
  777.      This is assigned an initial value to avoid "may be used uninitialized"
  778.      warning from gcc.  */
  779.   splay_tree tree = NULL;

  781.   /* get_osdata will throw if it cannot return data.  */
  782.   data = get_osdata ("processes");
  783.   cleanup = make_cleanup_osdata_free (data);

  785.   if (recurse)
  786.     {
  787.       struct osdata *threads = get_osdata ("threads");

  789.       make_cleanup_osdata_free (threads);
  790.       tree = splay_tree_new (splay_tree_int_comparator,
  791.                              do_nothing,
  792.                              free_vector_of_osdata_items);
  793.       make_cleanup (free_splay_tree, tree);

  795.       for (ix_items = 0;
  796.            VEC_iterate (osdata_item_s, threads->items,
  797.                         ix_items, item);
  798.            ix_items++)
  799.         {
  800.           const char *pid = get_osdata_column (item, "pid");
  801.           int pid_i = strtoul (pid, NULL, 0);
  802.           VEC (osdata_item_s) *vec = 0;

  804.           splay_tree_node n = splay_tree_lookup (tree, pid_i);
  805.           if (!n)
  806.             {
  807.               VEC_safe_push (osdata_item_s, vec, item);
  808.               splay_tree_insert (tree, pid_i, (splay_tree_value)vec);
  809.             }
  810.           else
  811.             {
  812.               vec = (VEC (osdata_item_s) *) n->value;
  813.               VEC_safe_push (osdata_item_s, vec, item);
  814.               n->value = (splay_tree_value) vec;
  815.             }
  816.         }
  817.     }

  819.   make_cleanup_ui_out_list_begin_end (uiout, "groups");

  821.   for (ix_items = 0;
  822.        VEC_iterate (osdata_item_s, data->items,
  823.                     ix_items, item);
  824.        ix_items++)
  825.     {
  826.       struct cleanup *back_to;

  828.       const char *pid = get_osdata_column (item, "pid");
  829.       const char *cmd = get_osdata_column (item, "command");
  830.       const char *user = get_osdata_column (item, "user");
  831.       const char *cores = get_osdata_column (item, "cores");

  833.       int pid_i = strtoul (pid, NULL, 0);

  835.       /* At present, the target will return all available processes
  836.          and if information about specific ones was required, we filter
  837.          undesired processes here.  */
  838.       if (ids && bsearch (&pid_i, VEC_address (int, ids),
  839.                           VEC_length (int, ids),
  840.                           sizeof (int), compare_positive_ints) == NULL)
  841.         continue;


  844.       back_to = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);

  846.       ui_out_field_fmt (uiout, "id", "%s", pid);
  847.       ui_out_field_string (uiout, "type", "process");
  848.       if (cmd)
  849.         ui_out_field_string (uiout, "description", cmd);
  850.       if (user)
  851.         ui_out_field_string (uiout, "user", user);
  852.       if (cores)
  853.         output_cores (uiout, "cores", cores);

  855.       if (recurse)
  856.         {
  857.           splay_tree_node n = splay_tree_lookup (tree, pid_i);
  858.           if (n)
  859.             {
  860.               VEC (osdata_item_s) *children = (VEC (osdata_item_s) *) n->value;
  861.               struct osdata_item *child;
  862.               int ix_child;

  864.               make_cleanup_ui_out_list_begin_end (uiout, "threads");

  866.               for (ix_child = 0;
  867.                    VEC_iterate (osdata_item_s, children, ix_child, child);
  868.                    ++ix_child)
  869.                 {
  870.                   struct cleanup *back_to_2 =
  871.                     make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
  872.                   const char *tid = get_osdata_column (child, "tid");
  873.                   const char *tcore = get_osdata_column (child, "core");

  875.                   ui_out_field_string (uiout, "id", tid);
  876.                   if (tcore)
  877.                     ui_out_field_string (uiout, "core", tcore);

  879.                   do_cleanups (back_to_2);
  880.                 }
  881.             }
  882.         }

  884.       do_cleanups (back_to);
  885.     }

  887.   do_cleanups (cleanup);
  888. }

  890. void
  891. ‌mi_cmd_list_thread_groups (char *command, char **argv, int argc)
  892. {
  893.   struct ui_out *uiout = current_uiout;
  894.   struct cleanup *back_to;
  895.   int available = 0;
  896.   int recurse = 0;
  897.   VEC (int) *ids = 0;

  899.   enum opt
  900.   {
  901.     AVAILABLE_OPT, RECURSE_OPT
  902.   };
  903.   static const struct mi_opt opts[] =
  904.     {
  905.       {"-available", AVAILABLE_OPT, 0},
  906.       {"-recurse", RECURSE_OPT, 1},
  907.       { 0, 0, 0 }
  908.     };

  910.   int oind = 0;
  911.   char *oarg;

  913.   while (1)
  914.     {
  915.       int opt = mi_getopt ("-list-thread-groups", argc, argv, opts,
  916.                            &oind, &oarg);

  918.       if (opt < 0)
  919.         break;
  920.       switch ((enum opt) opt)
  921.         {
  922.         case AVAILABLE_OPT:
  923.           available = 1;
  924.           break;
  925.         case RECURSE_OPT:
  926.           if (strcmp (oarg, "0") == 0)
  927.             ;
  928.           else if (strcmp (oarg, "1") == 0)
  929.             recurse = 1;
  930.           else
  931.             error (_("only '0' and '1' are valid values "
  932.                      "for the '--recurse' option"));
  933.           break;
  934.         }
  935.     }

  937.   for (; oind < argc; ++oind)
  938.     {
  939.       char *end;
  940.       int inf;

  942.       if (*(argv[oind]) != 'i')
  943.         error (_("invalid syntax of group id '%s'"), argv[oind]);

  945.       inf = strtoul (argv[oind] + 1, &end, 0);

  947.       if (*end != '\0')
  948.         error (_("invalid syntax of group id '%s'"), argv[oind]);
  949.       VEC_safe_push (int, ids, inf);
  950.     }
  951.   if (VEC_length (int, ids) > 1)
  952.     qsort (VEC_address (int, ids),
  953.            VEC_length (int, ids),
  954.            sizeof (int), compare_positive_ints);

  956.   back_to = make_cleanup (free_vector_of_ints, &ids);

  958.   if (available)
  959.     {
  960.       list_available_thread_groups (ids, recurse);
  961.     }
  962.   else if (VEC_length (int, ids) == 1)
  963.     {
  964.       /* Local thread groups, single id.  */
  965.       int id = *VEC_address (int, ids);
  966.       struct inferior *inf = find_inferior_id (id);

  968.       if (!inf)
  969.         error (_("Non-existent thread group id '%d'"), id);

  971.       print_thread_info (uiout, NULL, inf->pid);
  972.     }
  973.   else
  974.     {
  975.       struct print_one_inferior_data data;

  977.       data.recurse = recurse;
  978.       data.inferiors = ids;

  980.       /* Local thread groups.  Either no explicit ids -- and we
  981.          print everything, or several explicit ids.  In both cases,
  982.          we print more than one group, and have to use 'groups'
  983.          as the top-level element.  */
  984.       make_cleanup_ui_out_list_begin_end (uiout, "groups");
  985.       update_thread_list ();
  986.       iterate_over_inferiors (print_one_inferior, &data);
  987.     }

  989.   do_cleanups (back_to);
  990. }

  992. void
  993. ‌mi_cmd_data_list_register_names (char *command, char **argv, int argc)
  994. {
  995.   struct gdbarch *gdbarch;
  996.   struct ui_out *uiout = current_uiout;
  997.   int regnum, numregs;
  998.   int i;
  999.   struct cleanup *cleanup;

  1001.   /* Note that the test for a valid register must include checking the
  1002.      gdbarch_register_name because gdbarch_num_regs may be allocated
  1003.      for the union of the register sets within a family of related
  1004.      processors.  In this case, some entries of gdbarch_register_name
  1005.      will change depending upon the particular processor being
  1006.      debugged.  */

  1008.   gdbarch = get_current_arch ();
  1009.   numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);

  1011.   cleanup = make_cleanup_ui_out_list_begin_end (uiout, "register-names");

  1013.   if (argc == 0)                /* No args, just do all the regs.  */
  1014.     {
  1015.       for (regnum = 0;
  1016.            regnum < numregs;
  1017.            regnum++)
  1018.         {
  1019.           if (gdbarch_register_name (gdbarch, regnum) == NULL
  1020.               || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
  1021.             ui_out_field_string (uiout, NULL, "");
  1022.           else
  1023.             ui_out_field_string (uiout, NULL,
  1024.                                  gdbarch_register_name (gdbarch, regnum));
  1025.         }
  1026.     }

  1028.   /* Else, list of register #s, just do listed regs.  */
  1029.   for (i = 0; i < argc; i++)
  1030.     {
  1031.       regnum = atoi (argv[i]);
  1032.       if (regnum < 0 || regnum >= numregs)
  1033.         error (_("bad register number"));

  1035.       if (gdbarch_register_name (gdbarch, regnum) == NULL
  1036.           || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
  1037.         ui_out_field_string (uiout, NULL, "");
  1038.       else
  1039.         ui_out_field_string (uiout, NULL,
  1040.                              gdbarch_register_name (gdbarch, regnum));
  1041.     }
  1042.   do_cleanups (cleanup);
  1043. }

  1045. void
  1046. ‌mi_cmd_data_list_changed_registers (char *command, char **argv, int argc)
  1047. {
  1048.   static struct regcache *this_regs = NULL;
  1049.   struct ui_out *uiout = current_uiout;
  1050.   struct regcache *prev_regs;
  1051.   struct gdbarch *gdbarch;
  1052.   int regnum, numregs, changed;
  1053.   int i;
  1054.   struct cleanup *cleanup;

  1056.   /* The last time we visited this function, the current frame's
  1057.      register contents were saved in THIS_REGS.  Move THIS_REGS over
  1058.      to PREV_REGS, and refresh THIS_REGS with the now-current register
  1059.      contents.  */

  1061.   prev_regs = this_regs;
  1062.   this_regs = frame_save_as_regcache (get_selected_frame (NULL));
  1063.   cleanup = make_cleanup_regcache_xfree (prev_regs);

  1065.   /* Note that the test for a valid register must include checking the
  1066.      gdbarch_register_name because gdbarch_num_regs may be allocated
  1067.      for the union of the register sets within a family of related
  1068.      processors.  In this case, some entries of gdbarch_register_name
  1069.      will change depending upon the particular processor being
  1070.      debugged.  */

  1072.   gdbarch = get_regcache_arch (this_regs);
  1073.   numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);

  1075.   make_cleanup_ui_out_list_begin_end (uiout, "changed-registers");

  1077.   if (argc == 0)
  1078.     {
  1079.       /* No args, just do all the regs.  */
  1080.       for (regnum = 0;
  1081.            regnum < numregs;
  1082.            regnum++)
  1083.         {
  1084.           if (gdbarch_register_name (gdbarch, regnum) == NULL
  1085.               || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
  1086.             continue;
  1087.           changed = register_changed_p (regnum, prev_regs, this_regs);
  1088.           if (changed < 0)
  1089.             error (_("-data-list-changed-registers: "
  1090.                      "Unable to read register contents."));
  1091.           else if (changed)
  1092.             ui_out_field_int (uiout, NULL, regnum);
  1093.         }
  1094.     }

  1096.   /* Else, list of register #s, just do listed regs.  */
  1097.   for (i = 0; i < argc; i++)
  1098.     {
  1099.       regnum = atoi (argv[i]);

  1101.       if (regnum >= 0
  1102.           && regnum < numregs
  1103.           && gdbarch_register_name (gdbarch, regnum) != NULL
  1104.           && *gdbarch_register_name (gdbarch, regnum) != '\000')
  1105.         {
  1106.           changed = register_changed_p (regnum, prev_regs, this_regs);
  1107.           if (changed < 0)
  1108.             error (_("-data-list-changed-registers: "
  1109.                      "Unable to read register contents."));
  1110.           else if (changed)
  1111.             ui_out_field_int (uiout, NULL, regnum);
  1112.         }
  1113.       else
  1114.         error (_("bad register number"));
  1115.     }
  1116.   do_cleanups (cleanup);
  1117. }

  1119. static int
  1120. ‌register_changed_p (int regnum, struct regcache *prev_regs,
  1121.                     struct regcache *this_regs)
  1122. {
  1123.   struct gdbarch *gdbarch = get_regcache_arch (this_regs);
  1124.   gdb_byte prev_buffer[MAX_REGISTER_SIZE];
  1125.   gdb_byte this_buffer[MAX_REGISTER_SIZE];
  1126.   enum register_status prev_status;
  1127.   enum register_status this_status;

  1129.   /* First time through or after gdbarch change consider all registers
  1130.      as changed.  */
  1131.   if (!prev_regs || get_regcache_arch (prev_regs) != gdbarch)
  1132.     return 1;

  1134.   /* Get register contents and compare.  */
  1135.   prev_status = regcache_cooked_read (prev_regs, regnum, prev_buffer);
  1136.   this_status = regcache_cooked_read (this_regs, regnum, this_buffer);

  1138.   if (this_status != prev_status)
  1139.     return 1;
  1140.   else if (this_status == REG_VALID)
  1141.     return memcmp (prev_buffer, this_buffer,
  1142.                    register_size (gdbarch, regnum)) != 0;
  1143.   else
  1144.     return 0;
  1145. }

  1147. /* Return a list of register number and value pairs.  The valid
  1148.    arguments expected are: a letter indicating the format in which to
  1149.    display the registers contents.  This can be one of: x
  1150.    (hexadecimal), d (decimal), N (natural), t (binary), o (octal), r
  1151.    (raw).  After the format argument there can be a sequence of
  1152.    numbers, indicating which registers to fetch the content of.  If
  1153.    the format is the only argument, a list of all the registers with
  1154.    their values is returned.  */

  1156. void
  1157. ‌mi_cmd_data_list_register_values (char *command, char **argv, int argc)
  1158. {
  1159.   struct ui_out *uiout = current_uiout;
  1160.   struct frame_info *frame;
  1161.   struct gdbarch *gdbarch;
  1162.   int regnum, numregs, format;
  1163.   int i;
  1164.   struct cleanup *list_cleanup;
  1165.   int skip_unavailable = 0;
  1166.   int oind = 0;
  1167.   enum opt
  1168.   {
  1169.     SKIP_UNAVAILABLE,
  1170.   };
  1171.   static const struct mi_opt opts[] =
  1172.     {
  1173.       {"-skip-unavailable", SKIP_UNAVAILABLE, 0},
  1174.       { 0, 0, 0 }
  1175.     };

  1177.   /* Note that the test for a valid register must include checking the
  1178.      gdbarch_register_name because gdbarch_num_regs may be allocated
  1179.      for the union of the register sets within a family of related
  1180.      processors.  In this case, some entries of gdbarch_register_name
  1181.      will change depending upon the particular processor being
  1182.      debugged.  */

  1184.   while (1)
  1185.     {
  1186.       char *oarg;
  1187.       int opt = mi_getopt ("-data-list-register-values", argc, argv,
  1188.                            opts, &oind, &oarg);

  1190.       if (opt < 0)
  1191.         break;
  1192.       switch ((enum opt) opt)
  1193.         {
  1194.         case SKIP_UNAVAILABLE:
  1195.           skip_unavailable = 1;
  1196.           break;
  1197.         }
  1198.     }

  1200.   if (argc - oind < 1)
  1201.     error (_("-data-list-register-values: Usage: "
  1202.              "-data-list-register-values [--skip-unavailable] <format>"
  1203.              " [<regnum1>...<regnumN>]"));

  1205.   format = (int) argv[oind][0];

  1207.   frame = get_selected_frame (NULL);
  1208.   gdbarch = get_frame_arch (frame);
  1209.   numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);

  1211.   list_cleanup = make_cleanup_ui_out_list_begin_end (uiout, "register-values");

  1213.   if (argc - oind == 1)
  1214.     {
  1215.       /* No args, beside the format: do all the regs.  */
  1216.       for (regnum = 0;
  1217.            regnum < numregs;
  1218.            regnum++)
  1219.         {
  1220.           if (gdbarch_register_name (gdbarch, regnum) == NULL
  1221.               || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
  1222.             continue;

  1224.           output_register (frame, regnum, format, skip_unavailable);
  1225.         }
  1226.     }

  1228.   /* Else, list of register #s, just do listed regs.  */
  1229.   for (i = 1 + oind; i < argc; i++)
  1230.     {
  1231.       regnum = atoi (argv[i]);

  1233.       if (regnum >= 0
  1234.           && regnum < numregs
  1235.           && gdbarch_register_name (gdbarch, regnum) != NULL
  1236.           && *gdbarch_register_name (gdbarch, regnum) != '\000')
  1237.         output_register (frame, regnum, format, skip_unavailable);
  1238.       else
  1239.         error (_("bad register number"));
  1240.     }
  1241.   do_cleanups (list_cleanup);
  1242. }

  1244. /* Output one register REGNUM's contents in the desired FORMAT.  If
  1245.    SKIP_UNAVAILABLE is true, skip the register if it is
  1246.    unavailable.  */

  1248. static void
  1249. ‌output_register (struct frame_info *frame, int regnum, int format,
  1250.                  int skip_unavailable)
  1251. {
  1252.   struct gdbarch *gdbarch = get_frame_arch (frame);
  1253.   struct ui_out *uiout = current_uiout;
  1254.   struct value *val = value_of_register (regnum, frame);
  1255.   struct cleanup *tuple_cleanup;
  1256.   struct value_print_options opts;
  1257.   struct ui_file *stb;

  1259.   if (skip_unavailable && !value_entirely_available (val))
  1260.     return;

  1262.   tuple_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
  1263.   ui_out_field_int (uiout, "number", regnum);

  1265.   if (format == 'N')
  1266.     format = 0;

  1268.   if (format == 'r')
  1269.     format = 'z';

  1271.   stb = mem_fileopen ();
  1272.   make_cleanup_ui_file_delete (stb);

  1274.   get_formatted_print_options (&opts, format);
  1275.   opts.deref_ref = 1;
  1276.   val_print (value_type (val),
  1277.              value_contents_for_printing (val),
  1278.              value_embedded_offset (val), 0,
  1279.              stb, 0, val, &opts, current_language);
  1280.   ui_out_field_stream (uiout, "value", stb);

  1282.   do_cleanups (tuple_cleanup);
  1283. }

  1285. /* Write given values into registers. The registers and values are
  1286.    given as pairs.  The corresponding MI command is
  1287.    -data-write-register-values <format>
  1288.                                [<regnum1> <value1>...<regnumN> <valueN>] */
  1289. void
  1290. ‌mi_cmd_data_write_register_values (char *command, char **argv, int argc)
  1291. {
  1292.   struct regcache *regcache;
  1293.   struct gdbarch *gdbarch;
  1294.   int numregs, i;

  1296.   /* Note that the test for a valid register must include checking the
  1297.      gdbarch_register_name because gdbarch_num_regs may be allocated
  1298.      for the union of the register sets within a family of related
  1299.      processors.  In this case, some entries of gdbarch_register_name
  1300.      will change depending upon the particular processor being
  1301.      debugged.  */

  1303.   regcache = get_current_regcache ();
  1304.   gdbarch = get_regcache_arch (regcache);
  1305.   numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);

  1307.   if (argc == 0)
  1308.     error (_("-data-write-register-values: Usage: -data-write-register-"
  1309.              "values <format> [<regnum1> <value1>...<regnumN> <valueN>]"));

  1311.   if (!target_has_registers)
  1312.     error (_("-data-write-register-values: No registers."));

  1314.   if (!(argc - 1))
  1315.     error (_("-data-write-register-values: No regs and values specified."));

  1317.   if ((argc - 1) % 2)
  1318.     error (_("-data-write-register-values: "
  1319.              "Regs and vals are not in pairs."));

  1321.   for (i = 1; i < argc; i = i + 2)
  1322.     {
  1323.       int regnum = atoi (argv[i]);

  1325.       if (regnum >= 0 && regnum < numregs
  1326.           && gdbarch_register_name (gdbarch, regnum)
  1327.           && *gdbarch_register_name (gdbarch, regnum))
  1328.         {
  1329.           LONGEST value;

  1331.           /* Get the value as a number.  */
  1332.           value = parse_and_eval_address (argv[i + 1]);

  1334.           /* Write it down.  */
  1335.           regcache_cooked_write_signed (regcache, regnum, value);
  1336.         }
  1337.       else
  1338.         error (_("bad register number"));
  1339.     }
  1340. }

  1342. /* Evaluate the value of the argument.  The argument is an
  1343.    expression. If the expression contains spaces it needs to be
  1344.    included in double quotes.  */

  1346. void
  1347. ‌mi_cmd_data_evaluate_expression (char *command, char **argv, int argc)
  1348. {
  1349.   struct expression *expr;
  1350.   struct cleanup *old_chain;
  1351.   struct value *val;
  1352.   struct ui_file *stb;
  1353.   struct value_print_options opts;
  1354.   struct ui_out *uiout = current_uiout;

  1356.   stb = mem_fileopen ();
  1357.   old_chain = make_cleanup_ui_file_delete (stb);

  1359.   if (argc != 1)
  1360.     error (_("-data-evaluate-expression: "
  1361.              "Usage: -data-evaluate-expression expression"));

  1363.   expr = parse_expression (argv[0]);

  1365.   make_cleanup (free_current_contents, &expr);

  1367.   val = evaluate_expression (expr);

  1369.   /* Print the result of the expression evaluation.  */
  1370.   get_user_print_options (&opts);
  1371.   opts.deref_ref = 0;
  1372.   common_val_print (val, stb, 0, &opts, current_language);

  1374.   ui_out_field_stream (uiout, "value", stb);

  1376.   do_cleanups (old_chain);
  1377. }

  1379. /* This is the -data-read-memory command.

  1381.    ADDR: start address of data to be dumped.
  1382.    WORD-FORMAT: a char indicating format for the ``word''.  See
  1383.    the ``x'' command.
  1384.    WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes.
  1385.    NR_ROW: Number of rows.
  1386.    NR_COL: The number of colums (words per row).
  1387.    ASCHAR: (OPTIONAL) Append an ascii character dump to each row.  Use
  1388.    ASCHAR for unprintable characters.

  1390.    Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
  1391.    displayes them.  Returns:

  1393.    {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}

  1395.    Returns:
  1396.    The number of bytes read is SIZE*ROW*COL.  */

  1398. void
  1399. ‌mi_cmd_data_read_memory (char *command, char **argv, int argc)
  1400. {
  1401.   struct gdbarch *gdbarch = get_current_arch ();
  1402.   struct ui_out *uiout = current_uiout;
  1403.   struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
  1404.   CORE_ADDR addr;
  1405.   long total_bytes, nr_cols, nr_rows;
  1406.   char word_format;
  1407.   struct type *word_type;
  1408.   long word_size;
  1409.   char word_asize;
  1410.   char aschar;
  1411.   gdb_byte *mbuf;
  1412.   int nr_bytes;
  1413.   long offset = 0;
  1414.   int oind = 0;
  1415.   char *oarg;
  1416.   enum opt
  1417.   {
  1418.     OFFSET_OPT
  1419.   };
  1420.   static const struct mi_opt opts[] =
  1421.     {
  1422.       {"o", OFFSET_OPT, 1},
  1423.       { 0, 0, 0 }
  1424.     };

  1426.   while (1)
  1427.     {
  1428.       int opt = mi_getopt ("-data-read-memory", argc, argv, opts,
  1429.                            &oind, &oarg);

  1431.       if (opt < 0)
  1432.         break;
  1433.       switch ((enum opt) opt)
  1434.         {
  1435.         case OFFSET_OPT:
  1436.           offset = atol (oarg);
  1437.           break;
  1438.         }
  1439.     }
  1440.   argv += oind;
  1441.   argc -= oind;

  1443.   if (argc < 5 || argc > 6)
  1444.     error (_("-data-read-memory: Usage: "
  1445.              "ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR]."));

  1447.   /* Extract all the arguments. */

  1449.   /* Start address of the memory dump.  */
  1450.   addr = parse_and_eval_address (argv[0]) + offset;
  1451.   /* The format character to use when displaying a memory word.  See
  1452.      the ``x'' command.  */
  1453.   word_format = argv[1][0];
  1454.   /* The size of the memory word.  */
  1455.   word_size = atol (argv[2]);
  1456.   switch (word_size)
  1457.     {
  1458.     case 1:
  1459.       word_type = builtin_type (gdbarch)->builtin_int8;
  1460.       word_asize = 'b';
  1461.       break;
  1462.     case 2:
  1463.       word_type = builtin_type (gdbarch)->builtin_int16;
  1464.       word_asize = 'h';
  1465.       break;
  1466.     case 4:
  1467.       word_type = builtin_type (gdbarch)->builtin_int32;
  1468.       word_asize = 'w';
  1469.       break;
  1470.     case 8:
  1471.       word_type = builtin_type (gdbarch)->builtin_int64;
  1472.       word_asize = 'g';
  1473.       break;
  1474.     default:
  1475.       word_type = builtin_type (gdbarch)->builtin_int8;
  1476.       word_asize = 'b';
  1477.     }
  1478.   /* The number of rows.  */
  1479.   nr_rows = atol (argv[3]);
  1480.   if (nr_rows <= 0)
  1481.     error (_("-data-read-memory: invalid number of rows."));

  1483.   /* Number of bytes per row.  */
  1484.   nr_cols = atol (argv[4]);
  1485.   if (nr_cols <= 0)
  1486.     error (_("-data-read-memory: invalid number of columns."));

  1488.   /* The un-printable character when printing ascii.  */
  1489.   if (argc == 6)
  1490.     aschar = *argv[5];
  1491.   else
  1492.     aschar = 0;

  1494.   /* Create a buffer and read it in.  */
  1495.   total_bytes = word_size * nr_rows * nr_cols;
  1496.   mbuf = xcalloc (total_bytes, 1);
  1497.   make_cleanup (xfree, mbuf);

  1499.   /* Dispatch memory reads to the topmost target, not the flattened
  1500.      current_target.  */
  1501.   nr_bytes = target_read (current_target.beneath,
  1502.                           TARGET_OBJECT_MEMORY, NULL, mbuf,
  1503.                           addr, total_bytes);
  1504.   if (nr_bytes <= 0)
  1505.     error (_("Unable to read memory."));

  1507.   /* Output the header information.  */
  1508.   ui_out_field_core_addr (uiout, "addr", gdbarch, addr);
  1509.   ui_out_field_int (uiout, "nr-bytes", nr_bytes);
  1510.   ui_out_field_int (uiout, "total-bytes", total_bytes);
  1511.   ui_out_field_core_addr (uiout, "next-row",
  1512.                           gdbarch, addr + word_size * nr_cols);
  1513.   ui_out_field_core_addr (uiout, "prev-row",
  1514.                           gdbarch, addr - word_size * nr_cols);
  1515.   ui_out_field_core_addr (uiout, "next-page", gdbarch, addr + total_bytes);
  1516.   ui_out_field_core_addr (uiout, "prev-page", gdbarch, addr - total_bytes);

  1518.   /* Build the result as a two dimentional table.  */
  1519.   {
  1520.     struct ui_file *stream;
  1521.     struct cleanup *cleanup_stream;
  1522.     int row;
  1523.     int row_byte;

  1525.     stream = mem_fileopen ();
  1526.     cleanup_stream = make_cleanup_ui_file_delete (stream);

  1528.     make_cleanup_ui_out_list_begin_end (uiout, "memory");
  1529.     for (row = 0, row_byte = 0;
  1530.          row < nr_rows;
  1531.          row++, row_byte += nr_cols * word_size)
  1532.       {
  1533.         int col;
  1534.         int col_byte;
  1535.         struct cleanup *cleanup_tuple;
  1536.         struct cleanup *cleanup_list_data;
  1537.         struct value_print_options opts;

  1539.         cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
  1540.         ui_out_field_core_addr (uiout, "addr", gdbarch, addr + row_byte);
  1541.         /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr +
  1542.            row_byte); */
  1543.         cleanup_list_data = make_cleanup_ui_out_list_begin_end (uiout, "data");
  1544.         get_formatted_print_options (&opts, word_format);
  1545.         for (col = 0, col_byte = row_byte;
  1546.              col < nr_cols;
  1547.              col++, col_byte += word_size)
  1548.           {
  1549.             if (col_byte + word_size > nr_bytes)
  1550.               {
  1551.                 ui_out_field_string (uiout, NULL, "N/A");
  1552.               }
  1553.             else
  1554.               {
  1555.                 ui_file_rewind (stream);
  1556.                 print_scalar_formatted (mbuf + col_byte, word_type, &opts,
  1557.                                         word_asize, stream);
  1558.                 ui_out_field_stream (uiout, NULL, stream);
  1559.               }
  1560.           }
  1561.         do_cleanups (cleanup_list_data);
  1562.         if (aschar)
  1563.           {
  1564.             int byte;

  1566.             ui_file_rewind (stream);
  1567.             for (byte = row_byte;
  1568.                  byte < row_byte + word_size * nr_cols; byte++)
  1569.               {
  1570.                 if (byte >= nr_bytes)
  1571.                   fputc_unfiltered ('X', stream);
  1572.                 else if (mbuf[byte] < 32 || mbuf[byte] > 126)
  1573.                   fputc_unfiltered (aschar, stream);
  1574.                 else
  1575.                   fputc_unfiltered (mbuf[byte], stream);
  1576.               }
  1577.             ui_out_field_stream (uiout, "ascii", stream);
  1578.           }
  1579.         do_cleanups (cleanup_tuple);
  1580.       }
  1581.     do_cleanups (cleanup_stream);
  1582.   }
  1583.   do_cleanups (cleanups);
  1584. }

  1586. void
  1587. ‌mi_cmd_data_read_memory_bytes (char *command, char **argv, int argc)
  1588. {
  1589.   struct gdbarch *gdbarch = get_current_arch ();
  1590.   struct ui_out *uiout = current_uiout;
  1591.   struct cleanup *cleanups;
  1592.   CORE_ADDR addr;
  1593.   LONGEST length;
  1594.   memory_read_result_s *read_result;
  1595.   int ix;
  1596.   VEC(memory_read_result_s) *result;
  1597.   long offset = 0;
  1598.   int oind = 0;
  1599.   char *oarg;
  1600.   enum opt
  1601.   {
  1602.     OFFSET_OPT
  1603.   };
  1604.   static const struct mi_opt opts[] =
  1605.     {
  1606.       {"o", OFFSET_OPT, 1},
  1607.       { 0, 0, 0 }
  1608.     };

  1610.   while (1)
  1611.     {
  1612.       int opt = mi_getopt ("-data-read-memory-bytes", argc, argv, opts,
  1613.                            &oind, &oarg);
  1614.       if (opt < 0)
  1615.         break;
  1616.       switch ((enum opt) opt)
  1617.         {
  1618.         case OFFSET_OPT:
  1619.           offset = atol (oarg);
  1620.           break;
  1621.         }
  1622.     }
  1623.   argv += oind;
  1624.   argc -= oind;

  1626.   if (argc != 2)
  1627.     error (_("Usage: [ -o OFFSET ] ADDR LENGTH."));

  1629.   addr = parse_and_eval_address (argv[0]) + offset;
  1630.   length = atol (argv[1]);

  1632.   result = read_memory_robust (current_target.beneath, addr, length);

  1634.   cleanups = make_cleanup (free_memory_read_result_vector, result);

  1636.   if (VEC_length (memory_read_result_s, result) == 0)
  1637.     error (_("Unable to read memory."));

  1639.   make_cleanup_ui_out_list_begin_end (uiout, "memory");
  1640.   for (ix = 0;
  1641.        VEC_iterate (memory_read_result_s, result, ix, read_result);
  1642.        ++ix)
  1643.     {
  1644.       struct cleanup *t = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
  1645.       char *data, *p;
  1646.       int i;

  1648.       ui_out_field_core_addr (uiout, "begin", gdbarch, read_result->begin);
  1649.       ui_out_field_core_addr (uiout, "offset", gdbarch, read_result->begin
  1650.                               - addr);
  1651.       ui_out_field_core_addr (uiout, "end", gdbarch, read_result->end);

  1653.       data = xmalloc ((read_result->end - read_result->begin) * 2 + 1);

  1655.       for (i = 0, p = data;
  1656.            i < (read_result->end - read_result->begin);
  1657.            ++i, p += 2)
  1658.         {
  1659.           sprintf (p, "%02x", read_result->data[i]);
  1660.         }
  1661.       ui_out_field_string (uiout, "contents", data);
  1662.       xfree (data);
  1663.       do_cleanups (t);
  1664.     }
  1665.   do_cleanups (cleanups);
  1666. }

  1668. /* Implementation of the -data-write_memory command.

  1670.    COLUMN_OFFSET: optional argument. Must be preceded by '-o'. The
  1671.    offset from the beginning of the memory grid row where the cell to
  1672.    be written is.
  1673.    ADDR: start address of the row in the memory grid where the memory
  1674.    cell is, if OFFSET_COLUMN is specified.  Otherwise, the address of
  1675.    the location to write to.
  1676.    FORMAT: a char indicating format for the ``word''.  See
  1677.    the ``x'' command.
  1678.    WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
  1679.    VALUE: value to be written into the memory address.

  1681.    Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).

  1683.    Prints nothing.  */

  1685. void
  1686. ‌mi_cmd_data_write_memory (char *command, char **argv, int argc)
  1687. {
  1688.   struct gdbarch *gdbarch = get_current_arch ();
  1689.   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
  1690.   CORE_ADDR addr;
  1691.   long word_size;
  1692.   /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
  1693.      enough when using a compiler other than GCC.  */
  1694.   LONGEST value;
  1695.   void *buffer;
  1696.   struct cleanup *old_chain;
  1697.   long offset = 0;
  1698.   int oind = 0;
  1699.   char *oarg;
  1700.   enum opt
  1701.   {
  1702.     OFFSET_OPT
  1703.   };
  1704.   static const struct mi_opt opts[] =
  1705.     {
  1706.       {"o", OFFSET_OPT, 1},
  1707.       { 0, 0, 0 }
  1708.     };

  1710.   while (1)
  1711.     {
  1712.       int opt = mi_getopt ("-data-write-memory", argc, argv, opts,
  1713.                            &oind, &oarg);

  1715.       if (opt < 0)
  1716.         break;
  1717.       switch ((enum opt) opt)
  1718.         {
  1719.         case OFFSET_OPT:
  1720.           offset = atol (oarg);
  1721.           break;
  1722.         }
  1723.     }
  1724.   argv += oind;
  1725.   argc -= oind;

  1727.   if (argc != 4)
  1728.     error (_("-data-write-memory: Usage: "
  1729.              "[-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE."));

  1731.   /* Extract all the arguments.  */
  1732.   /* Start address of the memory dump.  */
  1733.   addr = parse_and_eval_address (argv[0]);
  1734.   /* The size of the memory word.  */
  1735.   word_size = atol (argv[2]);

  1737.   /* Calculate the real address of the write destination.  */
  1738.   addr += (offset * word_size);

  1740.   /* Get the value as a number.  */
  1741.   value = parse_and_eval_address (argv[3]);
  1742.   /* Get the value into an array.  */
  1743.   buffer = xmalloc (word_size);
  1744.   old_chain = make_cleanup (xfree, buffer);
  1745.   store_signed_integer (buffer, word_size, byte_order, value);
  1746.   /* Write it down to memory.  */
  1747.   write_memory_with_notification (addr, buffer, word_size);
  1748.   /* Free the buffer.  */
  1749.   do_cleanups (old_chain);
  1750. }

  1752. /* Implementation of the -data-write-memory-bytes command.

  1754.    ADDR: start address
  1755.    DATA: string of bytes to write at that address
  1756.    COUNT: number of bytes to be filled (decimal integer).  */

  1758. void
  1759. ‌mi_cmd_data_write_memory_bytes (char *command, char **argv, int argc)
  1760. {
  1761.   CORE_ADDR addr;
  1762.   char *cdata;
  1763.   gdb_byte *data;
  1764.   gdb_byte *databuf;
  1765.   size_t len, i, steps, remainder;
  1766.   long int count, j;
  1767.   struct cleanup *back_to;

  1769.   if (argc != 2 && argc != 3)
  1770.     error (_("Usage: ADDR DATA [COUNT]."));

  1772.   addr = parse_and_eval_address (argv[0]);
  1773.   cdata = argv[1];
  1774.   if (strlen (cdata) % 2)
  1775.     error (_("Hex-encoded '%s' must have an even number of characters."),
  1776.            cdata);

  1778.   len = strlen (cdata)/2;
  1779.   if (argc == 3)
  1780.     count = strtoul (argv[2], NULL, 10);
  1781.   else
  1782.     count = len;

  1784.   databuf = xmalloc (len * sizeof (gdb_byte));
  1785.   back_to = make_cleanup (xfree, databuf);

  1787.   for (i = 0; i < len; ++i)
  1788.     {
  1789.       int x;
  1790.       if (sscanf (cdata + i * 2, "%02x", &x) != 1)
  1791.         error (_("Invalid argument"));
  1792.       databuf[i] = (gdb_byte) x;
  1793.     }

  1795.   if (len < count)
  1796.     {
  1797.       /* Pattern is made of less bytes than count:
  1798.          repeat pattern to fill memory.  */
  1799.       data = xmalloc (count);
  1800.       make_cleanup (xfree, data);

  1802.       steps = count / len;
  1803.       remainder = count % len;
  1804.       for (j = 0; j < steps; j++)
  1805.         memcpy (data + j * len, databuf, len);

  1807.       if (remainder > 0)
  1808.         memcpy (data + steps * len, databuf, remainder);
  1809.     }
  1810.   else
  1811.     {
  1812.       /* Pattern is longer than or equal to count:
  1813.          just copy count bytes.  */
  1814.       data = databuf;
  1815.     }

  1817.   write_memory_with_notification (addr, data, count);

  1819.   do_cleanups (back_to);
  1820. }

  1822. void
  1823. ‌mi_cmd_enable_timings (char *command, char **argv, int argc)
  1824. {
  1825.   if (argc == 0)
  1826.     do_timings = 1;
  1827.   else if (argc == 1)
  1828.     {
  1829.       if (strcmp (argv[0], "yes") == 0)
  1830.         do_timings = 1;
  1831.       else if (strcmp (argv[0], "no") == 0)
  1832.         do_timings = 0;
  1833.       else
  1834.         goto usage_error;
  1835.     }
  1836.   else
  1837.     goto usage_error;

  1839.   return;

  1841. usage_error:
  1842.   error (_("-enable-timings: Usage: %s {yes|no}"), command);
  1843. }

  1845. void
  1846. ‌mi_cmd_list_features (char *command, char **argv, int argc)
  1847. {
  1848.   if (argc == 0)
  1849.     {
  1850.       struct cleanup *cleanup = NULL;
  1851.       struct ui_out *uiout = current_uiout;

  1853.       cleanup = make_cleanup_ui_out_list_begin_end (uiout, "features");
  1854.       ui_out_field_string (uiout, NULL, "frozen-varobjs");
  1855.       ui_out_field_string (uiout, NULL, "pending-breakpoints");
  1856.       ui_out_field_string (uiout, NULL, "thread-info");
  1857.       ui_out_field_string (uiout, NULL, "data-read-memory-bytes");
  1858.       ui_out_field_string (uiout, NULL, "breakpoint-notifications");
  1859.       ui_out_field_string (uiout, NULL, "ada-task-info");
  1860.       ui_out_field_string (uiout, NULL, "language-option");
  1861.       ui_out_field_string (uiout, NULL, "info-gdb-mi-command");
  1862.       ui_out_field_string (uiout, NULL, "undefined-command-error-code");
  1863.       ui_out_field_string (uiout, NULL, "exec-run-start-option");

  1865.       if (ext_lang_initialized_p (get_ext_lang_defn (EXT_LANG_PYTHON)))
  1866.         ui_out_field_string (uiout, NULL, "python");

  1868.       do_cleanups (cleanup);
  1869.       return;
  1870.     }

  1872.   error (_("-list-features should be passed no arguments"));
  1873. }

  1875. void
  1876. ‌mi_cmd_list_target_features (char *command, char **argv, int argc)
  1877. {
  1878.   if (argc == 0)
  1879.     {
  1880.       struct cleanup *cleanup = NULL;
  1881.       struct ui_out *uiout = current_uiout;

  1883.       cleanup = make_cleanup_ui_out_list_begin_end (uiout, "features");
  1884.       if (mi_async_p ())
  1885.         ui_out_field_string (uiout, NULL, "async");
  1886.       if (target_can_execute_reverse)
  1887.         ui_out_field_string (uiout, NULL, "reverse");
  1888.       do_cleanups (cleanup);
  1889.       return;
  1890.     }

  1892.   error (_("-list-target-features should be passed no arguments"));
  1893. }

  1895. void
  1896. ‌mi_cmd_add_inferior (char *command, char **argv, int argc)
  1897. {
  1898.   struct inferior *inf;

  1900.   if (argc != 0)
  1901.     error (_("-add-inferior should be passed no arguments"));

  1903.   inf = add_inferior_with_spaces ();

  1905.   ui_out_field_fmt (current_uiout, "inferior", "i%d", inf->num);
  1906. }

  1908. /* Callback used to find the first inferior other than the current
  1909.    one.  */

  1911. static int
  1912. ‌get_other_inferior (struct inferior *inf, void *arg)
  1913. {
  1914.   if (inf == current_inferior ())
  1915.     return 0;

  1917.   return 1;
  1918. }

  1920. void
  1921. ‌mi_cmd_remove_inferior (char *command, char **argv, int argc)
  1922. {
  1923.   int id;
  1924.   struct inferior *inf;

  1926.   if (argc != 1)
  1927.     error (_("-remove-inferior should be passed a single argument"));

  1929.   if (sscanf (argv[0], "i%d", &id) != 1)
  1930.     error (_("the thread group id is syntactically invalid"));

  1932.   inf = find_inferior_id (id);
  1933.   if (!inf)
  1934.     error (_("the specified thread group does not exist"));

  1936.   if (inf->pid != 0)
  1937.     error (_("cannot remove an active inferior"));

  1939.   if (inf == current_inferior ())
  1940.     {
  1941.       struct thread_info *tp = 0;
  1942.       struct inferior *new_inferior
  1943.         = iterate_over_inferiors (get_other_inferior, NULL);

  1945.       if (new_inferior == NULL)
  1946.         error (_("Cannot remove last inferior"));

  1948.       set_current_inferior (new_inferior);
  1949.       if (new_inferior->pid != 0)
  1950.         tp = any_thread_of_process (new_inferior->pid);
  1951.       switch_to_thread (tp ? tp->ptid : null_ptid);
  1952.       set_current_program_space (new_inferior->pspace);
  1953.     }

  1955.   delete_inferior_1 (inf, 1 /* silent */);
  1956. }



  1960. /* Execute a command within a safe environment.
  1961.    Return <0 for error; >=0 for ok.

  1963.    args->action will tell mi_execute_command what action
  1964.    to perfrom after the given command has executed (display/suppress
  1965.    prompt, display error).  */

  1967. static void
  1968. ‌captured_mi_execute_command (struct ui_out *uiout, struct mi_parse *context)
  1969. {
  1970.   struct cleanup *cleanup;

  1972.   if (do_timings)
  1973.     current_command_ts = context->cmd_start;

  1975.   current_token = xstrdup (context->token);
  1976.   cleanup = make_cleanup (free_current_contents, &current_token);

  1978.   running_result_record_printed = 0;
  1979.   mi_proceeded = 0;
  1980.   switch (context->op)
  1981.     {
  1982.     case MI_COMMAND:
  1983.       /* A MI command was read from the input stream.  */
  1984.       if (mi_debug_p)
  1985.         /* FIXME: gdb_???? */
  1986.         fprintf_unfiltered (raw_stdout, " token=`%s' command=`%s' args=`%s'\n",
  1987.                             context->token, context->command, context->args);

  1989.       mi_cmd_execute (context);

  1991.       /* Print the result if there were no errors.

  1993.          Remember that on the way out of executing a command, you have
  1994.          to directly use the mi_interp's uiout, since the command
  1995.          could have reset the interpreter, in which case the current
  1996.          uiout will most likely crash in the mi_out_* routines.  */
  1997.       if (!running_result_record_printed)
  1998.         {
  1999.           fputs_unfiltered (context->token, raw_stdout);
  2000.           /* There's no particularly good reason why target-connect results
  2001.              in not ^done.  Should kill ^connected for MI3.  */
  2002.           fputs_unfiltered (strcmp (context->command, "target-select") == 0
  2003.                             ? "^connected" : "^done", raw_stdout);
  2004.           mi_out_put (uiout, raw_stdout);
  2005.           mi_out_rewind (uiout);
  2006.           mi_print_timing_maybe ();
  2007.           fputs_unfiltered ("\n", raw_stdout);
  2008.         }
  2009.       else
  2010.         /* The command does not want anything to be printed.  In that
  2011.            case, the command probably should not have written anything
  2012.            to uiout, but in case it has written something, discard it.  */
  2013.         mi_out_rewind (uiout);
  2014.       break;

  2016.     case CLI_COMMAND:
  2017.       {
  2018.         char *argv[2];

  2020.         /* A CLI command was read from the input stream.  */
  2021.         /* This "feature" will be removed as soon as we have a
  2022.            complete set of mi commands.  */
  2023.         /* Echo the command on the console.  */
  2024.         fprintf_unfiltered (gdb_stdlog, "%s\n", context->command);
  2025.         /* Call the "console" interpreter.  */
  2026.         argv[0] = "console";
  2027.         argv[1] = context->command;
  2028.         mi_cmd_interpreter_exec ("-interpreter-exec", argv, 2);

  2030.         /* If we changed interpreters, DON'T print out anything.  */
  2031.         if (current_interp_named_p (INTERP_MI)
  2032.             || current_interp_named_p (INTERP_MI1)
  2033.             || current_interp_named_p (INTERP_MI2)
  2034.             || current_interp_named_p (INTERP_MI3))
  2035.           {
  2036.             if (!running_result_record_printed)
  2037.               {
  2038.                 fputs_unfiltered (context->token, raw_stdout);
  2039.                 fputs_unfiltered ("^done", raw_stdout);
  2040.                 mi_out_put (uiout, raw_stdout);
  2041.                 mi_out_rewind (uiout);
  2042.                 mi_print_timing_maybe ();
  2043.                 fputs_unfiltered ("\n", raw_stdout);
  2044.               }
  2045.             else
  2046.               mi_out_rewind (uiout);
  2047.           }
  2048.         break;
  2049.       }
  2050.     }

  2052.   do_cleanups (cleanup);
  2053. }

  2055. /* Print a gdb exception to the MI output stream.  */

  2057. static void
  2058. ‌mi_print_exception (const char *token, struct gdb_exception exception)
  2059. {
  2060.   fputs_unfiltered (token, raw_stdout);
  2061.   fputs_unfiltered ("^error,msg=\"", raw_stdout);
  2062.   if (exception.message == NULL)
  2063.     fputs_unfiltered ("unknown error", raw_stdout);
  2064.   else
  2065.     fputstr_unfiltered (exception.message, '"', raw_stdout);
  2066.   fputs_unfiltered ("\"", raw_stdout);

  2068.   switch (exception.error)
  2069.     {
  2070.       case UNDEFINED_COMMAND_ERROR:
  2071.         fputs_unfiltered (",code=\"undefined-command\"", raw_stdout);
  2072.         break;
  2073.     }

  2075.   fputs_unfiltered ("\n", raw_stdout);
  2076. }

  2078. void
  2079. ‌mi_execute_command (const char *cmd, int from_tty)
  2080. {
  2081.   char *token;
  2082.   struct mi_parse *command = NULL;
  2083.   volatile struct gdb_exception exception;

  2085.   /* This is to handle EOF (^D). We just quit gdb.  */
  2086.   /* FIXME: we should call some API function here.  */
  2087.   if (cmd == 0)
  2088.     quit_force (NULL, from_tty);

  2090.   target_log_command (cmd);

  2092.   TRY_CATCH (exception, RETURN_MASK_ALL)
  2093.     {
  2094.       command = mi_parse (cmd, &token);
  2095.     }
  2096.   if (exception.reason < 0)
  2097.     {
  2098.       mi_print_exception (token, exception);
  2099.       xfree (token);
  2100.     }
  2101.   else
  2102.     {
  2103.       volatile struct gdb_exception result;
  2104.       ptid_t previous_ptid = inferior_ptid;

  2106.       command->token = token;

  2108.       if (do_timings)
  2109.         {
  2110.           command->cmd_start = (struct mi_timestamp *)
  2111.             xmalloc (sizeof (struct mi_timestamp));
  2112.           timestamp (command->cmd_start);
  2113.         }

  2115.       TRY_CATCH (result, RETURN_MASK_ALL)
  2116.         {
  2117.           captured_mi_execute_command (current_uiout, command);
  2118.         }
  2119.       if (result.reason < 0)
  2120.         {
  2121.           /* The command execution failed and error() was called
  2122.              somewhere.  */
  2123.           mi_print_exception (command->token, result);
  2124.           mi_out_rewind (current_uiout);
  2125.         }

  2127.       bpstat_do_actions ();

  2129.       if (/* The notifications are only output when the top-level
  2130.              interpreter (specified on the command line) is MI.  */
  2131.           ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ()))
  2132.           /* Don't try report anything if there are no threads --
  2133.              the program is dead.  */
  2134.           && thread_count () != 0
  2135.           /* -thread-select explicitly changes thread. If frontend uses that
  2136.              internally, we don't want to emit =thread-selected, since
  2137.              =thread-selected is supposed to indicate user's intentions.  */
  2138.           && strcmp (command->command, "thread-select") != 0)
  2139.         {
  2140.           struct mi_interp *mi = top_level_interpreter_data ();
  2141.           int report_change = 0;

  2143.           if (command->thread == -1)
  2144.             {
  2145.               report_change = (!ptid_equal (previous_ptid, null_ptid)
  2146.                                && !ptid_equal (inferior_ptid, previous_ptid)
  2147.                                && !ptid_equal (inferior_ptid, null_ptid));
  2148.             }
  2149.           else if (!ptid_equal (inferior_ptid, null_ptid))
  2150.             {
  2151.               struct thread_info *ti = inferior_thread ();

  2153.               report_change = (ti->num != command->thread);
  2154.             }

  2156.           if (report_change)
  2157.             {
  2158.               struct thread_info *ti = inferior_thread ();

  2160.               target_terminal_ours ();
  2161.               fprintf_unfiltered (mi->event_channel,
  2162.                                   "thread-selected,id=\"%d\"",
  2163.                                   ti->num);
  2164.               gdb_flush (mi->event_channel);
  2165.             }
  2166.         }

  2168.       mi_parse_free (command);
  2169.     }
  2170. }

  2172. static void
  2173. ‌mi_cmd_execute (struct mi_parse *parse)
  2174. {
  2175.   struct cleanup *cleanup;
  2176.   enum language saved_language;

  2178.   cleanup = prepare_execute_command ();

  2180.   if (parse->all && parse->thread_group != -1)
  2181.     error (_("Cannot specify --thread-group together with --all"));

  2183.   if (parse->all && parse->thread != -1)
  2184.     error (_("Cannot specify --thread together with --all"));

  2186.   if (parse->thread_group != -1 && parse->thread != -1)
  2187.     error (_("Cannot specify --thread together with --thread-group"));

  2189.   if (parse->frame != -1 && parse->thread == -1)
  2190.     error (_("Cannot specify --frame without --thread"));

  2192.   if (parse->thread_group != -1)
  2193.     {
  2194.       struct inferior *inf = find_inferior_id (parse->thread_group);
  2195.       struct thread_info *tp = 0;

  2197.       if (!inf)
  2198.         error (_("Invalid thread group for the --thread-group option"));

  2200.       set_current_inferior (inf);
  2201.       /* This behaviour means that if --thread-group option identifies
  2202.          an inferior with multiple threads, then a random one will be
  2203.          picked.  This is not a problem -- frontend should always
  2204.          provide --thread if it wishes to operate on a specific
  2205.          thread.  */
  2206.       if (inf->pid != 0)
  2207.         tp = any_live_thread_of_process (inf->pid);
  2208.       switch_to_thread (tp ? tp->ptid : null_ptid);
  2209.       set_current_program_space (inf->pspace);
  2210.     }

  2212.   if (parse->thread != -1)
  2213.     {
  2214.       struct thread_info *tp = find_thread_id (parse->thread);

  2216.       if (!tp)
  2217.         error (_("Invalid thread id: %d"), parse->thread);

  2219.       if (is_exited (tp->ptid))
  2220.         error (_("Thread id: %d has terminated"), parse->thread);

  2222.       switch_to_thread (tp->ptid);
  2223.     }

  2225.   if (parse->frame != -1)
  2226.     {
  2227.       struct frame_info *fid;
  2228.       int frame = parse->frame;

  2230.       fid = find_relative_frame (get_current_frame (), &frame);
  2231.       if (frame == 0)
  2232.         /* find_relative_frame was successful */
  2233.         select_frame (fid);
  2234.       else
  2235.         error (_("Invalid frame id: %d"), frame);
  2236.     }

  2238.   if (parse->language != language_unknown)
  2239.     {
  2240.       make_cleanup_restore_current_language ();
  2241.       set_language (parse->language);
  2242.     }

  2244.   current_context = parse;

  2246.   if (parse->cmd->suppress_notification != NULL)
  2247.     {
  2248.       make_cleanup_restore_integer (parse->cmd->suppress_notification);
  2249.       *parse->cmd->suppress_notification = 1;
  2250.     }

  2252.   if (parse->cmd->argv_func != NULL)
  2253.     {
  2254.       parse->cmd->argv_func (parse->command, parse->argv, parse->argc);
  2255.     }
  2256.   else if (parse->cmd->cli.cmd != 0)
  2257.     {
  2258.       /* FIXME: DELETE THIS. */
  2259.       /* The operation is still implemented by a cli command.  */
  2260.       /* Must be a synchronous one.  */
  2261.       mi_execute_cli_command (parse->cmd->cli.cmd, parse->cmd->cli.args_p,
  2262.                               parse->args);
  2263.     }
  2264.   else
  2265.     {
  2266.       /* FIXME: DELETE THIS.  */
  2267.       struct ui_file *stb;

  2269.       stb = mem_fileopen ();

  2271.       fputs_unfiltered ("Undefined mi command: ", stb);
  2272.       fputstr_unfiltered (parse->command, '"', stb);
  2273.       fputs_unfiltered (" (missing implementation)", stb);

  2275.       make_cleanup_ui_file_delete (stb);
  2276.       error_stream (stb);
  2277.     }
  2278.   do_cleanups (cleanup);
  2279. }

  2281. /* FIXME: This is just a hack so we can get some extra commands going.
  2282.    We don't want to channel things through the CLI, but call libgdb directly.
  2283.    Use only for synchronous commands.  */

  2285. void
  2286. ‌mi_execute_cli_command (const char *cmd, int args_p, const char *args)
  2287. {
  2288.   if (cmd != 0)
  2289.     {
  2290.       struct cleanup *old_cleanups;
  2291.       char *run;

  2293.       if (args_p)
  2294.         run = xstrprintf ("%s %s", cmd, args);
  2295.       else
  2296.         run = xstrdup (cmd);
  2297.       if (mi_debug_p)
  2298.         /* FIXME: gdb_???? */
  2299.         fprintf_unfiltered (gdb_stdout, "cli=%s run=%s\n",
  2300.                             cmd, run);
  2301.       old_cleanups = make_cleanup (xfree, run);
  2302.       execute_command (run, 0 /* from_tty */ );
  2303.       do_cleanups (old_cleanups);
  2304.       return;
  2305.     }
  2306. }

  2308. void
  2309. ‌mi_execute_async_cli_command (char *cli_command, char **argv, int argc)
  2310. {
  2311.   struct cleanup *old_cleanups;
  2312.   char *run;

  2314.   if (mi_async_p ())
  2315.     run = xstrprintf ("%s %s&", cli_command, argc ? *argv : "");
  2316.   else
  2317.     run = xstrprintf ("%s %s", cli_command, argc ? *argv : "");
  2318.   old_cleanups = make_cleanup (xfree, run);

  2320.   execute_command (run, 0 /* from_tty */ );

  2322.   /* Do this before doing any printing.  It would appear that some
  2323.      print code leaves garbage around in the buffer.  */
  2324.   do_cleanups (old_cleanups);
  2325. }

  2327. void
  2328. ‌mi_load_progress (const char *section_name,
  2329.                   unsigned long sent_so_far,
  2330.                   unsigned long total_section,
  2331.                   unsigned long total_sent,
  2332.                   unsigned long grand_total)
  2333. {
  2334.   struct timeval time_now, delta, update_threshold;
  2335.   static struct timeval last_update;
  2336.   static char *previous_sect_name = NULL;
  2337.   int new_section;
  2338.   struct ui_out *saved_uiout;
  2339.   struct ui_out *uiout;

  2341.   /* This function is called through deprecated_show_load_progress
  2342.      which means uiout may not be correct.  Fix it for the duration
  2343.      of this function.  */
  2344.   saved_uiout = current_uiout;

  2346.   if (current_interp_named_p (INTERP_MI)
  2347.       || current_interp_named_p (INTERP_MI2))
  2348.     current_uiout = mi_out_new (2);
  2349.   else if (current_interp_named_p (INTERP_MI1))
  2350.     current_uiout = mi_out_new (1);
  2351.   else if (current_interp_named_p (INTERP_MI3))
  2352.     current_uiout = mi_out_new (3);
  2353.   else
  2354.     return;

  2356.   uiout = current_uiout;

  2358.   update_threshold.tv_sec = 0;
  2359.   update_threshold.tv_usec = 500000;
  2360.   gettimeofday (&time_now, NULL);

  2362.   delta.tv_usec = time_now.tv_usec - last_update.tv_usec;
  2363.   delta.tv_sec = time_now.tv_sec - last_update.tv_sec;

  2365.   if (delta.tv_usec < 0)
  2366.     {
  2367.       delta.tv_sec -= 1;
  2368.       delta.tv_usec += 1000000L;
  2369.     }

  2371.   new_section = (previous_sect_name ?
  2372.                  strcmp (previous_sect_name, section_name) : 1);
  2373.   if (new_section)
  2374.     {
  2375.       struct cleanup *cleanup_tuple;

  2377.       xfree (previous_sect_name);
  2378.       previous_sect_name = xstrdup (section_name);

  2380.       if (current_token)
  2381.         fputs_unfiltered (current_token, raw_stdout);
  2382.       fputs_unfiltered ("+download", raw_stdout);
  2383.       cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
  2384.       ui_out_field_string (uiout, "section", section_name);
  2385.       ui_out_field_int (uiout, "section-size", total_section);
  2386.       ui_out_field_int (uiout, "total-size", grand_total);
  2387.       do_cleanups (cleanup_tuple);
  2388.       mi_out_put (uiout, raw_stdout);
  2389.       fputs_unfiltered ("\n", raw_stdout);
  2390.       gdb_flush (raw_stdout);
  2391.     }

  2393.   if (delta.tv_sec >= update_threshold.tv_sec &&
  2394.       delta.tv_usec >= update_threshold.tv_usec)
  2395.     {
  2396.       struct cleanup *cleanup_tuple;

  2398.       last_update.tv_sec = time_now.tv_sec;
  2399.       last_update.tv_usec = time_now.tv_usec;
  2400.       if (current_token)
  2401.         fputs_unfiltered (current_token, raw_stdout);
  2402.       fputs_unfiltered ("+download", raw_stdout);
  2403.       cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
  2404.       ui_out_field_string (uiout, "section", section_name);
  2405.       ui_out_field_int (uiout, "section-sent", sent_so_far);
  2406.       ui_out_field_int (uiout, "section-size", total_section);
  2407.       ui_out_field_int (uiout, "total-sent", total_sent);
  2408.       ui_out_field_int (uiout, "total-size", grand_total);
  2409.       do_cleanups (cleanup_tuple);
  2410.       mi_out_put (uiout, raw_stdout);
  2411.       fputs_unfiltered ("\n", raw_stdout);
  2412.       gdb_flush (raw_stdout);
  2413.     }

  2415.   xfree (uiout);
  2416.   current_uiout = saved_uiout;
  2417. }

  2419. static void
  2420. ‌timestamp (struct mi_timestamp *tv)
  2421. {
  2422.   gettimeofday (&tv->wallclock, NULL);
  2423. #ifdef HAVE_GETRUSAGE
  2424.   getrusage (RUSAGE_SELF, &rusage);
  2425.   tv->utime.tv_sec = rusage.ru_utime.tv_sec;
  2426.   tv->utime.tv_usec = rusage.ru_utime.tv_usec;
  2427.   tv->stime.tv_sec = rusage.ru_stime.tv_sec;
  2428.   tv->stime.tv_usec = rusage.ru_stime.tv_usec;
  2429. #else
  2430.   {
  2431.     long usec = get_run_time ();

  2433.     tv->utime.tv_sec = usec/1000000L;
  2434.     tv->utime.tv_usec = usec - 1000000L*tv->utime.tv_sec;
  2435.     tv->stime.tv_sec = 0;
  2436.     tv->stime.tv_usec = 0;
  2437.   }
  2438. #endif
  2439. }

  2441. static void
  2442. ‌print_diff_now (struct mi_timestamp *start)
  2443. {
  2444.   struct mi_timestamp now;

  2446.   timestamp (&now);
  2447.   print_diff (start, &now);
  2448. }

  2450. void
  2451. ‌mi_print_timing_maybe (void)
  2452. {
  2453.   /* If the command is -enable-timing then do_timings may be true
  2454.      whilst current_command_ts is not initialized.  */
  2455.   if (do_timings && current_command_ts)
  2456.     print_diff_now (current_command_ts);
  2457. }

  2459. static long
  2460. ‌timeval_diff (struct timeval start, struct timeval end)
  2461. {
  2462.   return ((end.tv_sec - start.tv_sec) * 1000000L)
  2463.     + (end.tv_usec - start.tv_usec);
  2464. }

  2466. static void
  2467. ‌print_diff (struct mi_timestamp *start, struct mi_timestamp *end)
  2468. {
  2469.   fprintf_unfiltered
  2470.     (raw_stdout,
  2471.      ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
  2472.      timeval_diff (start->wallclock, end->wallclock) / 1000000.0,
  2473.      timeval_diff (start->utime, end->utime) / 1000000.0,
  2474.      timeval_diff (start->stime, end->stime) / 1000000.0);
  2475. }

  2477. void
  2478. ‌mi_cmd_trace_define_variable (char *command, char **argv, int argc)
  2479. {
  2480.   struct expression *expr;
  2481.   LONGEST initval = 0;
  2482.   struct trace_state_variable *tsv;
  2483.   char *name = 0;

  2485.   if (argc != 1 && argc != 2)
  2486.     error (_("Usage: -trace-define-variable VARIABLE [VALUE]"));

  2488.   name = argv[0];
  2489.   if (*name++ != '$')
  2490.     error (_("Name of trace variable should start with '$'"));

  2492.   validate_trace_state_variable_name (name);

  2494.   tsv = find_trace_state_variable (name);
  2495.   if (!tsv)
  2496.     tsv = create_trace_state_variable (name);

  2498.   if (argc == 2)
  2499.     initval = value_as_long (parse_and_eval (argv[1]));

  2501.   tsv->initial_value = initval;
  2502. }

  2504. void
  2505. ‌mi_cmd_trace_list_variables (char *command, char **argv, int argc)
  2506. {
  2507.   if (argc != 0)
  2508.     error (_("-trace-list-variables: no arguments allowed"));

  2510.   tvariables_info_1 ();
  2511. }

  2513. void
  2514. ‌mi_cmd_trace_find (char *command, char **argv, int argc)
  2515. {
  2516.   char *mode;

  2518.   if (argc == 0)
  2519.     error (_("trace selection mode is required"));

  2521.   mode = argv[0];

  2523.   if (strcmp (mode, "none") == 0)
  2524.     {
  2525.       tfind_1 (tfind_number, -1, 0, 0, 0);
  2526.       return;
  2527.     }

  2529.   check_trace_running (current_trace_status ());

  2531.   if (strcmp (mode, "frame-number") == 0)
  2532.     {
  2533.       if (argc != 2)
  2534.         error (_("frame number is required"));
  2535.       tfind_1 (tfind_number, atoi (argv[1]), 0, 0, 0);
  2536.     }
  2537.   else if (strcmp (mode, "tracepoint-number") == 0)
  2538.     {
  2539.       if (argc != 2)
  2540.         error (_("tracepoint number is required"));
  2541.       tfind_1 (tfind_tp, atoi (argv[1]), 0, 0, 0);
  2542.     }
  2543.   else if (strcmp (mode, "pc") == 0)
  2544.     {
  2545.       if (argc != 2)
  2546.         error (_("PC is required"));
  2547.       tfind_1 (tfind_pc, 0, parse_and_eval_address (argv[1]), 0, 0);
  2548.     }
  2549.   else if (strcmp (mode, "pc-inside-range") == 0)
  2550.     {
  2551.       if (argc != 3)
  2552.         error (_("Start and end PC are required"));
  2553.       tfind_1 (tfind_range, 0, parse_and_eval_address (argv[1]),
  2554.                parse_and_eval_address (argv[2]), 0);
  2555.     }
  2556.   else if (strcmp (mode, "pc-outside-range") == 0)
  2557.     {
  2558.       if (argc != 3)
  2559.         error (_("Start and end PC are required"));
  2560.       tfind_1 (tfind_outside, 0, parse_and_eval_address (argv[1]),
  2561.                parse_and_eval_address (argv[2]), 0);
  2562.     }
  2563.   else if (strcmp (mode, "line") == 0)
  2564.     {
  2565.       struct symtabs_and_lines sals;
  2566.       struct symtab_and_line sal;
  2567.       static CORE_ADDR start_pc, end_pc;
  2568.       struct cleanup *back_to;

  2570.       if (argc != 2)
  2571.         error (_("Line is required"));

  2573.       sals = decode_line_with_current_source (argv[1],
  2574.                                               DECODE_LINE_FUNFIRSTLINE);
  2575.       back_to = make_cleanup (xfree, sals.sals);

  2577.       sal = sals.sals[0];

  2579.       if (sal.symtab == 0)
  2580.         error (_("Could not find the specified line"));

  2582.       if (sal.line > 0 && find_line_pc_range (sal, &start_pc, &end_pc))
  2583.         tfind_1 (tfind_range, 0, start_pc, end_pc - 1, 0);
  2584.       else
  2585.         error (_("Could not find the specified line"));

  2587.       do_cleanups (back_to);
  2588.     }
  2589.   else
  2590.     error (_("Invalid mode '%s'"), mode);

  2592.   if (has_stack_frames () || get_traceframe_number () >= 0)
  2593.     print_stack_frame (get_selected_frame (NULL), 1, LOC_AND_ADDRESS, 1);
  2594. }

  2596. void
  2597. ‌mi_cmd_trace_save (char *command, char **argv, int argc)
  2598. {
  2599.   int target_saves = 0;
  2600.   int generate_ctf = 0;
  2601.   char *filename;
  2602.   int oind = 0;
  2603.   char *oarg;

  2605.   enum opt
  2606.   {
  2607.     TARGET_SAVE_OPT, CTF_OPT
  2608.   };
  2609.   static const struct mi_opt opts[] =
  2610.     {
  2611.       {"r", TARGET_SAVE_OPT, 0},
  2612.       {"ctf", CTF_OPT, 0},
  2613.       { 0, 0, 0 }
  2614.     };

  2616.   while (1)
  2617.     {
  2618.       int opt = mi_getopt ("-trace-save", argc, argv, opts,
  2619.                            &oind, &oarg);

  2621.       if (opt < 0)
  2622.         break;
  2623.       switch ((enum opt) opt)
  2624.         {
  2625.         case TARGET_SAVE_OPT:
  2626.           target_saves = 1;
  2627.           break;
  2628.         case CTF_OPT:
  2629.           generate_ctf = 1;
  2630.           break;
  2631.         }
  2632.     }
  2633.   filename = argv[oind];

  2635.   if (generate_ctf)
  2636.     trace_save_ctf (filename, target_saves);
  2637.   else
  2638.     trace_save_tfile (filename, target_saves);
  2639. }

  2641. void
  2642. ‌mi_cmd_trace_start (char *command, char **argv, int argc)
  2643. {
  2644.   start_tracing (NULL);
  2645. }

  2647. void
  2648. ‌mi_cmd_trace_status (char *command, char **argv, int argc)
  2649. {
  2650.   trace_status_mi (0);
  2651. }

  2653. void
  2654. ‌mi_cmd_trace_stop (char *command, char **argv, int argc)
  2655. {
  2656.   stop_tracing (NULL);
  2657.   trace_status_mi (1);
  2658. }

  2660. /* Implement the "-ada-task-info" command.  */

  2662. void
  2663. ‌mi_cmd_ada_task_info (char *command, char **argv, int argc)
  2664. {
  2665.   if (argc != 0 && argc != 1)
  2666.     error (_("Invalid MI command"));

  2668.   print_ada_task_info (current_uiout, argv[0], current_inferior ());
  2669. }

  2671. /* Print EXPRESSION according to VALUES.  */

  2673. static void
  2674. ‌print_variable_or_computed (char *expression, enum print_values values)
  2675. {
  2676.   struct expression *expr;
  2677.   struct cleanup *old_chain;
  2678.   struct value *val;
  2679.   struct ui_file *stb;
  2680.   struct value_print_options opts;
  2681.   struct type *type;
  2682.   struct ui_out *uiout = current_uiout;

  2684.   stb = mem_fileopen ();
  2685.   old_chain = make_cleanup_ui_file_delete (stb);

  2687.   expr = parse_expression (expression);

  2689.   make_cleanup (free_current_contents, &expr);

  2691.   if (values == PRINT_SIMPLE_VALUES)
  2692.     val = evaluate_type (expr);
  2693.   else
  2694.     val = evaluate_expression (expr);

  2696.   if (values != PRINT_NO_VALUES)
  2697.     make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
  2698.   ui_out_field_string (uiout, "name", expression);

  2700.   switch (values)
  2701.     {
  2702.     case PRINT_SIMPLE_VALUES:
  2703.       type = check_typedef (value_type (val));
  2704.       type_print (value_type (val), "", stb, -1);
  2705.       ui_out_field_stream (uiout, "type", stb);
  2706.       if (TYPE_CODE (type) != TYPE_CODE_ARRAY
  2707.           && TYPE_CODE (type) != TYPE_CODE_STRUCT
  2708.           && TYPE_CODE (type) != TYPE_CODE_UNION)
  2709.         {
  2710.           struct value_print_options opts;

  2712.           get_no_prettyformat_print_options (&opts);
  2713.           opts.deref_ref = 1;
  2714.           common_val_print (val, stb, 0, &opts, current_language);
  2715.           ui_out_field_stream (uiout, "value", stb);
  2716.         }
  2717.       break;
  2718.     case PRINT_ALL_VALUES:
  2719.       {
  2720.         struct value_print_options opts;

  2722.         get_no_prettyformat_print_options (&opts);
  2723.         opts.deref_ref = 1;
  2724.         common_val_print (val, stb, 0, &opts, current_language);
  2725.         ui_out_field_stream (uiout, "value", stb);
  2726.       }
  2727.       break;
  2728.     }

  2730.   do_cleanups (old_chain);
  2731. }

  2733. /* Implement the "-trace-frame-collected" command.  */

  2735. void
  2736. ‌mi_cmd_trace_frame_collected (char *command, char **argv, int argc)
  2737. {
  2738.   struct cleanup *old_chain;
  2739.   struct bp_location *tloc;
  2740.   int stepping_frame;
  2741.   struct collection_list *clist;
  2742.   struct collection_list tracepoint_list, stepping_list;
  2743.   struct traceframe_info *tinfo;
  2744.   int oind = 0;
  2745.   int var_print_values = PRINT_ALL_VALUES;
  2746.   int comp_print_values = PRINT_ALL_VALUES;
  2747.   int registers_format = 'x';
  2748.   int memory_contents = 0;
  2749.   struct ui_out *uiout = current_uiout;
  2750.   enum opt
  2751.   {
  2752.     VAR_PRINT_VALUES,
  2753.     COMP_PRINT_VALUES,
  2754.     REGISTERS_FORMAT,
  2755.     MEMORY_CONTENTS,
  2756.   };
  2757.   static const struct mi_opt opts[] =
  2758.     {
  2759.       {"-var-print-values", VAR_PRINT_VALUES, 1},
  2760.       {"-comp-print-values", COMP_PRINT_VALUES, 1},
  2761.       {"-registers-format", REGISTERS_FORMAT, 1},
  2762.       {"-memory-contents", MEMORY_CONTENTS, 0},
  2763.       { 0, 0, 0 }
  2764.     };

  2766.   while (1)
  2767.     {
  2768.       char *oarg;
  2769.       int opt = mi_getopt ("-trace-frame-collected", argc, argv, opts,
  2770.                            &oind, &oarg);
  2771.       if (opt < 0)
  2772.         break;
  2773.       switch ((enum opt) opt)
  2774.         {
  2775.         case VAR_PRINT_VALUES:
  2776.           var_print_values = mi_parse_print_values (oarg);
  2777.           break;
  2778.         case COMP_PRINT_VALUES:
  2779.           comp_print_values = mi_parse_print_values (oarg);
  2780.           break;
  2781.         case REGISTERS_FORMAT:
  2782.           registers_format = oarg[0];
  2783.         case MEMORY_CONTENTS:
  2784.           memory_contents = 1;
  2785.           break;
  2786.         }
  2787.     }

  2789.   if (oind != argc)
  2790.     error (_("Usage: -trace-frame-collected "
  2791.              "[--var-print-values PRINT_VALUES] "
  2792.              "[--comp-print-values PRINT_VALUES] "
  2793.              "[--registers-format FORMAT]"
  2794.              "[--memory-contents]"));

  2796.   /* This throws an error is not inspecting a trace frame.  */
  2797.   tloc = get_traceframe_location (&stepping_frame);

  2799.   /* This command only makes sense for the current frame, not the
  2800.      selected frame.  */
  2801.   old_chain = make_cleanup_restore_current_thread ();
  2802.   select_frame (get_current_frame ());

  2804.   encode_actions_and_make_cleanup (tloc, &tracepoint_list,
  2805.                                    &stepping_list);

  2807.   if (stepping_frame)
  2808.     clist = &stepping_list;
  2809.   else
  2810.     clist = &tracepoint_list;

  2812.   tinfo = get_traceframe_info ();

  2814.   /* Explicitly wholly collected variables.  */
  2815.   {
  2816.     struct cleanup *list_cleanup;
  2817.     char *p;
  2818.     int i;

  2820.     list_cleanup = make_cleanup_ui_out_list_begin_end (uiout,
  2821.                                                        "explicit-variables");
  2822.     for (i = 0; VEC_iterate (char_ptr, clist->wholly_collected, i, p); i++)
  2823.       print_variable_or_computed (p, var_print_values);
  2824.     do_cleanups (list_cleanup);
  2825.   }

  2827.   /* Computed expressions.  */
  2828.   {
  2829.     struct cleanup *list_cleanup;
  2830.     char *p;
  2831.     int i;

  2833.     list_cleanup
  2834.       = make_cleanup_ui_out_list_begin_end (uiout,
  2835.                                             "computed-expressions");
  2836.     for (i = 0; VEC_iterate (char_ptr, clist->computed, i, p); i++)
  2837.       print_variable_or_computed (p, comp_print_values);
  2838.     do_cleanups (list_cleanup);
  2839.   }

  2841.   /* Registers.  Given pseudo-registers, and that some architectures
  2842.      (like MIPS) actually hide the raw registers, we don't go through
  2843.      the trace frame info, but instead consult the register cache for
  2844.      register availability.  */
  2845.   {
  2846.     struct cleanup *list_cleanup;
  2847.     struct frame_info *frame;
  2848.     struct gdbarch *gdbarch;
  2849.     int regnum;
  2850.     int numregs;

  2852.     list_cleanup = make_cleanup_ui_out_list_begin_end (uiout, "registers");

  2854.     frame = get_selected_frame (NULL);
  2855.     gdbarch = get_frame_arch (frame);
  2856.     numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);

  2858.     for (regnum = 0; regnum < numregs; regnum++)
  2859.       {
  2860.         if (gdbarch_register_name (gdbarch, regnum) == NULL
  2861.             || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
  2862.           continue;

  2864.         output_register (frame, regnum, registers_format, 1);
  2865.       }

  2867.     do_cleanups (list_cleanup);
  2868.   }

  2870.   /* Trace state variables.  */
  2871.   {
  2872.     struct cleanup *list_cleanup;
  2873.     int tvar;
  2874.     char *tsvname;
  2875.     int i;

  2877.     list_cleanup = make_cleanup_ui_out_list_begin_end (uiout, "tvars");

  2879.     tsvname = NULL;
  2880.     make_cleanup (free_current_contents, &tsvname);

  2882.     for (i = 0; VEC_iterate (int, tinfo->tvars, i, tvar); i++)
  2883.       {
  2884.         struct cleanup *cleanup_child;
  2885.         struct trace_state_variable *tsv;

  2887.         tsv = find_trace_state_variable_by_number (tvar);

  2889.         cleanup_child = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);

  2891.         if (tsv != NULL)
  2892.           {
  2893.             tsvname = xrealloc (tsvname, strlen (tsv->name) + 2);
  2894.             tsvname[0] = '$';
  2895.             strcpy (tsvname + 1, tsv->name);
  2896.             ui_out_field_string (uiout, "name", tsvname);

  2898.             tsv->value_known = target_get_trace_state_variable_value (tsv->number,
  2899.                                                                       &tsv->value);
  2900.             ui_out_field_int (uiout, "current", tsv->value);
  2901.           }
  2902.         else
  2903.           {
  2904.             ui_out_field_skip (uiout, "name");
  2905.             ui_out_field_skip (uiout, "current");
  2906.           }

  2908.         do_cleanups (cleanup_child);
  2909.       }

  2911.     do_cleanups (list_cleanup);
  2912.   }

  2914.   /* Memory.  */
  2915.   {
  2916.     struct cleanup *list_cleanup;
  2917.     VEC(mem_range_s) *available_memory = NULL;
  2918.     struct mem_range *r;
  2919.     int i;

  2921.     traceframe_available_memory (&available_memory, 0, ULONGEST_MAX);
  2922.     make_cleanup (VEC_cleanup(mem_range_s), &available_memory);

  2924.     list_cleanup = make_cleanup_ui_out_list_begin_end (uiout, "memory");

  2926.     for (i = 0; VEC_iterate (mem_range_s, available_memory, i, r); i++)
  2927.       {
  2928.         struct cleanup *cleanup_child;
  2929.         gdb_byte *data;
  2930.         struct gdbarch *gdbarch = target_gdbarch ();

  2932.         cleanup_child = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);

  2934.         ui_out_field_core_addr (uiout, "address", gdbarch, r->start);
  2935.         ui_out_field_int (uiout, "length", r->length);

  2937.         data = xmalloc (r->length);
  2938.         make_cleanup (xfree, data);

  2940.         if (memory_contents)
  2941.           {
  2942.             if (target_read_memory (r->start, data, r->length) == 0)
  2943.               {
  2944.                 int m;
  2945.                 char *data_str, *p;

  2947.                 data_str = xmalloc (r->length * 2 + 1);
  2948.                 make_cleanup (xfree, data_str);

  2950.                 for (m = 0, p = data_str; m < r->length; ++m, p += 2)
  2951.                   sprintf (p, "%02x", data[m]);
  2952.                 ui_out_field_string (uiout, "contents", data_str);
  2953.               }
  2954.             else
  2955.               ui_out_field_skip (uiout, "contents");
  2956.           }
  2957.         do_cleanups (cleanup_child);
  2958.       }

  2960.     do_cleanups (list_cleanup);
  2961.   }

  2963.   do_cleanups (old_chain);
  2964. }

  2966. void
  2967. ‌_initialize_mi_main (void)
  2968. {
  2969.   struct cmd_list_element *c;

  2971.   add_setshow_boolean_cmd ("mi-async", class_run,
  2972.                            &mi_async_1, _("\
  2973. Set whether MI asynchronous mode is enabled."), _("\
  2974. Show whether MI asynchronous mode is enabled."), _("\
  2975. Tells GDB whether MI should be in asynchronous mode."),
  2976.                            set_mi_async_command,
  2977.                            show_mi_async_command,
  2978.                            &setlist,
  2979.                            &showlist);

  2981.   /* Alias old "target-async" to "mi-async".  */
  2982.   c = add_alias_cmd ("target-async", "mi-async", class_run, 0, &setlist);
  2983.   deprecate_cmd (c, "set mi-async");
  2984.   c = add_alias_cmd ("target-async", "mi-async", class_run, 0, &showlist);
  2985.   deprecate_cmd (c, "show mi-async");
  2986. }