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