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