Upgrade GDB from 7.4.1 to 7.6.1 on the vendor branch
[dragonfly.git] / contrib / gdb-7 / gdb / mi / mi-main.c
CommitLineData
5796c8dc
SS
1/* MI Command Set.
2
ef5ccd6c 3 Copyright (C) 2000-2013 Free Software Foundation, Inc.
5796c8dc
SS
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
5796c8dc
SS
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"
cf7f2e2d
JM
50#include "splay-tree.h"
51#include "tracepoint.h"
a45ae5f8
JM
52#include "ada-lang.h"
53#include "linespec.h"
5796c8dc
SS
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
63struct rusage rusage;
64#endif
65
66enum
67 {
68 FROM_TTY = 0
69 };
70
71int mi_debug_p;
ef5ccd6c 72
5796c8dc
SS
73struct ui_file *raw_stdout;
74
ef5ccd6c
JM
75/* This is used to pass the current command timestamp down to
76 continuation routines. */
5796c8dc
SS
77static struct mi_timestamp *current_command_ts;
78
79static int do_timings = 0;
80
81char *current_token;
ef5ccd6c
JM
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. */
cf7f2e2d
JM
85static struct mi_parse *current_context;
86
5796c8dc
SS
87int running_result_record_printed = 1;
88
89/* Flag indicating that the target has proceeded since the last
90 command was issued. */
91int mi_proceeded;
92
93extern void _initialize_mi_main (void);
94static void mi_cmd_execute (struct mi_parse *parse);
95
96static void mi_execute_cli_command (const char *cmd, int args_p,
97 const char *args);
98static void mi_execute_async_cli_command (char *cli_command,
c50c785c 99 char **argv, int argc);
5796c8dc
SS
100static int register_changed_p (int regnum, struct regcache *,
101 struct regcache *);
102static 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
108static void timestamp (struct mi_timestamp *tv);
109
110static void print_diff_now (struct mi_timestamp *start);
111static void print_diff (struct mi_timestamp *start, struct mi_timestamp *end);
112
113void
114mi_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);
a45ae5f8 120 mi_out_put (current_uiout, raw_stdout);
cf7f2e2d 121 gdb_flush (raw_stdout);
5796c8dc
SS
122 /* FIXME: The function called is not yet a formal libgdb function. */
123 quit_force (NULL, FROM_TTY);
124}
125
126void
127mi_cmd_exec_next (char *command, char **argv, int argc)
128{
129 /* FIXME: Should call a libgdb function, not a cli wrapper. */
cf7f2e2d
JM
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);
5796c8dc
SS
134}
135
136void
137mi_cmd_exec_next_instruction (char *command, char **argv, int argc)
138{
139 /* FIXME: Should call a libgdb function, not a cli wrapper. */
cf7f2e2d
JM
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);
5796c8dc
SS
144}
145
146void
147mi_cmd_exec_step (char *command, char **argv, int argc)
148{
149 /* FIXME: Should call a libgdb function, not a cli wrapper. */
cf7f2e2d
JM
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);
5796c8dc
SS
154}
155
156void
157mi_cmd_exec_step_instruction (char *command, char **argv, int argc)
158{
159 /* FIXME: Should call a libgdb function, not a cli wrapper. */
cf7f2e2d
JM
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);
5796c8dc
SS
164}
165
166void
167mi_cmd_exec_finish (char *command, char **argv, int argc)
168{
169 /* FIXME: Should call a libgdb function, not a cli wrapper. */
cf7f2e2d
JM
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);
5796c8dc
SS
174}
175
176void
177mi_cmd_exec_return (char *command, char **argv, int argc)
178{
179 /* This command doesn't really execute the target, it just pops the
ef5ccd6c 180 specified number of frames. */
5796c8dc
SS
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
195void
196mi_cmd_exec_jump (char *args, char **argv, int argc)
197{
198 /* FIXME: Should call a libgdb function, not a cli wrapper. */
cf7f2e2d 199 mi_execute_async_cli_command ("jump", argv, argc);
5796c8dc
SS
200}
201
cf7f2e2d
JM
202static void
203proceed_thread (struct thread_info *thread, int pid)
5796c8dc 204{
5796c8dc 205 if (!is_stopped (thread->ptid))
cf7f2e2d 206 return;
5796c8dc 207
cf7f2e2d
JM
208 if (pid != 0 && PIDGET (thread->ptid) != pid)
209 return;
5796c8dc
SS
210
211 switch_to_thread (thread->ptid);
212 clear_proceed_status ();
ef5ccd6c 213 proceed ((CORE_ADDR) -1, GDB_SIGNAL_DEFAULT, 0);
cf7f2e2d
JM
214}
215
cf7f2e2d
JM
216static int
217proceed_thread_callback (struct thread_info *thread, void *arg)
218{
219 int pid = *(int *)arg;
220
221 proceed_thread (thread, pid);
5796c8dc
SS
222 return 0;
223}
224
cf7f2e2d
JM
225static void
226exec_continue (char **argv, int argc)
227{
228 if (non_stop)
229 {
ef5ccd6c
JM
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.
cf7f2e2d
JM
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 {
c50c785c
JM
243 struct inferior *inf
244 = find_inferior_id (current_context->thread_group);
245
cf7f2e2d
JM
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 {
ef5ccd6c
JM
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. */
cf7f2e2d
JM
271 continue_1 (1);
272 }
273 do_cleanups (back_to);
274 }
275}
276
277static void
278exec_direction_forward (void *notused)
279{
280 execution_direction = EXEC_FORWARD;
281}
282
283static void
284exec_reverse_continue (char **argv, int argc)
285{
286 enum exec_direction_kind dir = execution_direction;
287 struct cleanup *old_chain;
288
cf7f2e2d
JM
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
5796c8dc
SS
301void
302mi_cmd_exec_continue (char *command, char **argv, int argc)
303{
cf7f2e2d
JM
304 if (argc > 0 && strcmp (argv[0], "--reverse") == 0)
305 exec_reverse_continue (argv + 1, argc - 1);
5796c8dc 306 else
cf7f2e2d 307 exec_continue (argv, argc);
5796c8dc
SS
308}
309
310static int
311interrupt_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
ef5ccd6c
JM
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
5796c8dc 329 mi_cmd_execute. */
ef5ccd6c 330
5796c8dc
SS
331void
332mi_cmd_exec_interrupt (char *command, char **argv, int argc)
333{
cf7f2e2d
JM
334 /* In all-stop mode, everything stops, so we don't need to try
335 anything specific. */
336 if (!non_stop)
5796c8dc 337 {
5796c8dc 338 interrupt_target_1 (0);
cf7f2e2d 339 return;
5796c8dc 340 }
cf7f2e2d
JM
341
342 if (current_context->all)
5796c8dc 343 {
cf7f2e2d 344 /* This will interrupt all threads in all inferiors. */
5796c8dc
SS
345 interrupt_target_1 (1);
346 }
cf7f2e2d
JM
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
362static int
363run_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
389void
390mi_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);
5796c8dc
SS
398 }
399 else
cf7f2e2d
JM
400 {
401 mi_execute_cli_command ("run", target_can_async_p (),
402 target_can_async_p () ? "&" : NULL);
403 }
5796c8dc
SS
404}
405
cf7f2e2d 406
5796c8dc
SS
407static int
408find_thread_of_process (struct thread_info *ti, void *p)
409{
410 int pid = *(int *)p;
cf7f2e2d 411
5796c8dc
SS
412 if (PIDGET (ti->ptid) == pid && !is_exited (ti->ptid))
413 return 1;
414
415 return 0;
416}
417
418void
419mi_cmd_target_detach (char *command, char **argv, int argc)
420{
421 if (argc != 0 && argc != 1)
c50c785c 422 error (_("Usage: -target-detach [pid | thread-group]"));
5796c8dc
SS
423
424 if (argc == 1)
425 {
426 struct thread_info *tp;
427 char *end = argv[0];
c50c785c 428 int pid;
cf7f2e2d 429
c50c785c
JM
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 }
5796c8dc
SS
453
454 /* Pick any thread in the desired process. Current
c50c785c 455 target_detach detaches from the parent of inferior_ptid. */
5796c8dc
SS
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
466void
467mi_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)
c50c785c 473 error (_("-thread-select: USAGE: threadnum."));
5796c8dc 474
a45ae5f8 475 rc = gdb_thread_select (current_uiout, argv[0], &mi_error_message);
5796c8dc
SS
476
477 if (rc == GDB_RC_FAIL)
478 {
479 make_cleanup (xfree, mi_error_message);
480 error ("%s", mi_error_message);
481 }
482}
483
484void
485mi_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)
c50c785c 491 error (_("-thread-list-ids: No arguments required."));
5796c8dc 492
a45ae5f8 493 rc = gdb_list_thread_ids (current_uiout, &mi_error_message);
5796c8dc
SS
494
495 if (rc == GDB_RC_FAIL)
496 {
497 make_cleanup (xfree, mi_error_message);
498 error ("%s", mi_error_message);
499 }
500}
501
502void
503mi_cmd_thread_info (char *command, char **argv, int argc)
504{
5796c8dc 505 if (argc != 0 && argc != 1)
c50c785c 506 error (_("Invalid MI command"));
5796c8dc 507
a45ae5f8 508 print_thread_info (current_uiout, argv[0], -1);
5796c8dc
SS
509}
510
ef5ccd6c
JM
511DEF_VEC_I(int);
512
cf7f2e2d
JM
513struct collect_cores_data
514{
515 int pid;
516
517 VEC (int) *cores;
518};
519
5796c8dc 520static int
cf7f2e2d 521collect_cores (struct thread_info *ti, void *xdata)
5796c8dc 522{
cf7f2e2d
JM
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 }
5796c8dc 532
5796c8dc
SS
533 return 0;
534}
535
cf7f2e2d
JM
536static int *
537unique (int *b, int *e)
5796c8dc 538{
cf7f2e2d 539 int *d = b;
5796c8dc 540
cf7f2e2d
JM
541 while (++b != e)
542 if (*d != *b)
543 *++d = *b;
544 return ++d;
545}
5796c8dc 546
cf7f2e2d
JM
547struct print_one_inferior_data
548{
549 int recurse;
550 VEC (int) *inferiors;
551};
5796c8dc 552
cf7f2e2d
JM
553static int
554print_one_inferior (struct inferior *inferior, void *xdata)
555{
556 struct print_one_inferior_data *top_data = xdata;
a45ae5f8 557 struct ui_out *uiout = current_uiout;
5796c8dc 558
cf7f2e2d
JM
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))
5796c8dc 563 {
cf7f2e2d
JM
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
ef5ccd6c 573 if (inferior->pspace->pspace_exec_filename != NULL)
cf7f2e2d
JM
574 {
575 ui_out_field_string (uiout, "executable",
ef5ccd6c 576 inferior->pspace->pspace_exec_filename);
cf7f2e2d
JM
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)
c50c785c 607 print_thread_info (uiout, NULL, inferior->pid);
cf7f2e2d
JM
608
609 do_cleanups (back_to);
5796c8dc 610 }
5796c8dc 611
cf7f2e2d
JM
612 return 0;
613}
614
ef5ccd6c
JM
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. */
5796c8dc 618
cf7f2e2d
JM
619static void
620output_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
635static void
636free_vector_of_ints (void *xvector)
637{
638 VEC (int) **vector = xvector;
639
640 VEC_free (int, *vector);
641}
642
643static void
644do_nothing (splay_tree_key k)
645{
646}
647
648static void
649free_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
657static int
658splay_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
666static void
667free_splay_tree (void *xt)
668{
669 splay_tree t = xt;
670 splay_tree_delete (t);
671}
672
673static void
674list_available_thread_groups (VEC (int) *ids, int recurse)
675{
676 struct osdata *data;
677 struct osdata_item *item;
678 int ix_items;
a45ae5f8 679 struct ui_out *uiout = current_uiout;
cf7f2e2d
JM
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);
5796c8dc
SS
700
701 for (ix_items = 0;
cf7f2e2d 702 VEC_iterate (osdata_item_s, threads->items,
5796c8dc
SS
703 ix_items, item);
704 ix_items++)
705 {
5796c8dc 706 const char *pid = get_osdata_column (item, "pid");
cf7f2e2d
JM
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 }
5796c8dc 724
cf7f2e2d 725 make_cleanup_ui_out_list_begin_end (uiout, "groups");
5796c8dc 726
cf7f2e2d
JM
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 }
5796c8dc 788 }
cf7f2e2d
JM
789
790 do_cleanups (back_to);
791 }
792}
793
794void
795mi_cmd_list_thread_groups (char *command, char **argv, int argc)
796{
a45ae5f8 797 struct ui_out *uiout = current_uiout;
cf7f2e2d
JM
798 struct cleanup *back_to;
799 int available = 0;
800 int recurse = 0;
801 VEC (int) *ids = 0;
802
803 enum opt
cf7f2e2d 804 {
ef5ccd6c 805 AVAILABLE_OPT, RECURSE_OPT
cf7f2e2d 806 };
ef5ccd6c
JM
807 static const struct mi_opt opts[] =
808 {
809 {"-available", AVAILABLE_OPT, 0},
810 {"-recurse", RECURSE_OPT, 1},
811 { 0, 0, 0 }
812 };
cf7f2e2d 813
ef5ccd6c
JM
814 int oind = 0;
815 char *oarg;
cf7f2e2d
JM
816
817 while (1)
818 {
819 int opt = mi_getopt ("-list-thread-groups", argc, argv, opts,
ef5ccd6c 820 &oind, &oarg);
cf7f2e2d
JM
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:
ef5ccd6c 830 if (strcmp (oarg, "0") == 0)
cf7f2e2d 831 ;
ef5ccd6c 832 else if (strcmp (oarg, "1") == 0)
cf7f2e2d
JM
833 recurse = 1;
834 else
c50c785c
JM
835 error (_("only '0' and '1' are valid values "
836 "for the '--recurse' option"));
cf7f2e2d
JM
837 break;
838 }
839 }
840
ef5ccd6c 841 for (; oind < argc; ++oind)
cf7f2e2d
JM
842 {
843 char *end;
844 int inf;
845
ef5ccd6c
JM
846 if (*(argv[oind]) != 'i')
847 error (_("invalid syntax of group id '%s'"), argv[oind]);
cf7f2e2d 848
ef5ccd6c 849 inf = strtoul (argv[oind] + 1, &end, 0);
cf7f2e2d
JM
850
851 if (*end != '\0')
ef5ccd6c 852 error (_("invalid syntax of group id '%s'"), argv[oind]);
cf7f2e2d
JM
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);
5796c8dc 865 }
cf7f2e2d 866 else if (VEC_length (int, ids) == 1)
5796c8dc 867 {
ef5ccd6c 868 /* Local thread groups, single id. */
cf7f2e2d
JM
869 int id = *VEC_address (int, ids);
870 struct inferior *inf = find_inferior_id (id);
871
872 if (!inf)
c50c785c 873 error (_("Non-existent thread group id '%d'"), id);
cf7f2e2d 874
c50c785c 875 print_thread_info (uiout, NULL, inf->pid);
5796c8dc
SS
876 }
877 else
878 {
cf7f2e2d
JM
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. */
5796c8dc 888 make_cleanup_ui_out_list_begin_end (uiout, "groups");
cf7f2e2d
JM
889 update_thread_list ();
890 iterate_over_inferiors (print_one_inferior, &data);
5796c8dc 891 }
cf7f2e2d 892
5796c8dc
SS
893 do_cleanups (back_to);
894}
895
896void
897mi_cmd_data_list_register_names (char *command, char **argv, int argc)
898{
5796c8dc 899 struct gdbarch *gdbarch;
a45ae5f8 900 struct ui_out *uiout = current_uiout;
5796c8dc
SS
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
ef5ccd6c
JM
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. */
5796c8dc 911
cf7f2e2d 912 gdbarch = get_current_arch ();
5796c8dc
SS
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)
c50c785c 937 error (_("bad register number"));
5796c8dc
SS
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
949void
950mi_cmd_data_list_changed_registers (char *command, char **argv, int argc)
951{
952 static struct regcache *this_regs = NULL;
a45ae5f8 953 struct ui_out *uiout = current_uiout;
5796c8dc
SS
954 struct regcache *prev_regs;
955 struct gdbarch *gdbarch;
956 int regnum, numregs, changed;
957 int i;
958 struct cleanup *cleanup;
959
ef5ccd6c
JM
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. */
5796c8dc
SS
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
ef5ccd6c
JM
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. */
5796c8dc
SS
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
ef5ccd6c 981 if (argc == 0)
5796c8dc 982 {
ef5ccd6c 983 /* No args, just do all the regs. */
5796c8dc
SS
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)
c50c785c
JM
993 error (_("-data-list-changed-registers: "
994 "Unable to read register contents."));
5796c8dc
SS
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)
c50c785c
JM
1012 error (_("-data-list-changed-registers: "
1013 "Unable to read register contents."));
5796c8dc
SS
1014 else if (changed)
1015 ui_out_field_int (uiout, NULL, regnum);
1016 }
1017 else
c50c785c 1018 error (_("bad register number"));
5796c8dc
SS
1019 }
1020 do_cleanups (cleanup);
1021}
1022
1023static int
1024register_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];
c50c785c
JM
1030 enum register_status prev_status;
1031 enum register_status this_status;
5796c8dc 1032
c50c785c
JM
1033 /* First time through or after gdbarch change consider all registers
1034 as changed. */
1035 if (!prev_regs || get_regcache_arch (prev_regs) != gdbarch)
5796c8dc
SS
1036 return 1;
1037
1038 /* Get register contents and compare. */
c50c785c
JM
1039 prev_status = regcache_cooked_read (prev_regs, regnum, prev_buffer);
1040 this_status = regcache_cooked_read (this_regs, regnum, this_buffer);
5796c8dc 1041
c50c785c
JM
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;
5796c8dc
SS
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
ef5ccd6c
JM
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
5796c8dc
SS
1060void
1061mi_cmd_data_list_register_values (char *command, char **argv, int argc)
1062{
a45ae5f8 1063 struct ui_out *uiout = current_uiout;
5796c8dc
SS
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
ef5ccd6c
JM
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. */
5796c8dc
SS
1076
1077 if (argc == 0)
c50c785c
JM
1078 error (_("-data-list-register-values: Usage: "
1079 "-data-list-register-values <format> [<regnum1>...<regnumN>]"));
5796c8dc
SS
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
ef5ccd6c 1089 if (argc == 1)
5796c8dc 1090 {
ef5ccd6c 1091 /* No args, beside the format: do all the regs. */
5796c8dc
SS
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
c50c785c 1122 error (_("bad register number"));
5796c8dc
SS
1123 }
1124 do_cleanups (list_cleanup);
1125}
1126
1127/* Output one register's contents in the desired format. */
ef5ccd6c 1128
5796c8dc
SS
1129static void
1130get_register (struct frame_info *frame, int regnum, int format)
1131{
1132 struct gdbarch *gdbarch = get_frame_arch (frame);
a45ae5f8 1133 struct ui_out *uiout = current_uiout;
c50c785c 1134 struct value *val;
5796c8dc 1135
5796c8dc
SS
1136 if (format == 'N')
1137 format = 0;
1138
c50c785c 1139 val = get_frame_register_value (frame, regnum);
5796c8dc 1140
c50c785c
JM
1141 if (value_optimized_out (val))
1142 error (_("Optimized out"));
5796c8dc
SS
1143
1144 if (format == 'r')
1145 {
1146 int j;
1147 char *ptr, buf[1024];
c50c785c 1148 const gdb_byte *valaddr = value_contents_for_printing (val);
5796c8dc
SS
1149
1150 strcpy (buf, "0x");
1151 ptr = buf + 2;
1152 for (j = 0; j < register_size (gdbarch, regnum); j++)
1153 {
1154 int idx = gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG ?
1155 j : register_size (gdbarch, regnum) - 1 - j;
cf7f2e2d 1156
c50c785c 1157 sprintf (ptr, "%02x", (unsigned char) valaddr[idx]);
5796c8dc
SS
1158 ptr += 2;
1159 }
1160 ui_out_field_string (uiout, "value", buf);
5796c8dc
SS
1161 }
1162 else
1163 {
1164 struct value_print_options opts;
ef5ccd6c
JM
1165 struct ui_file *stb;
1166 struct cleanup *old_chain;
1167
1168 stb = mem_fileopen ();
1169 old_chain = make_cleanup_ui_file_delete (stb);
cf7f2e2d 1170
5796c8dc
SS
1171 get_formatted_print_options (&opts, format);
1172 opts.deref_ref = 1;
c50c785c
JM
1173 val_print (value_type (val),
1174 value_contents_for_printing (val),
1175 value_embedded_offset (val), 0,
ef5ccd6c 1176 stb, 0, val, &opts, current_language);
5796c8dc 1177 ui_out_field_stream (uiout, "value", stb);
ef5ccd6c 1178 do_cleanups (old_chain);
5796c8dc
SS
1179 }
1180}
1181
1182/* Write given values into registers. The registers and values are
1183 given as pairs. The corresponding MI command is
c50c785c
JM
1184 -data-write-register-values <format>
1185 [<regnum1> <value1>...<regnumN> <valueN>] */
5796c8dc
SS
1186void
1187mi_cmd_data_write_register_values (char *command, char **argv, int argc)
1188{
1189 struct regcache *regcache;
1190 struct gdbarch *gdbarch;
1191 int numregs, i;
5796c8dc
SS
1192
1193 /* Note that the test for a valid register must include checking the
ef5ccd6c
JM
1194 gdbarch_register_name because gdbarch_num_regs may be allocated
1195 for the union of the register sets within a family of related
1196 processors. In this case, some entries of gdbarch_register_name
1197 will change depending upon the particular processor being
1198 debugged. */
5796c8dc
SS
1199
1200 regcache = get_current_regcache ();
1201 gdbarch = get_regcache_arch (regcache);
1202 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
1203
1204 if (argc == 0)
c50c785c
JM
1205 error (_("-data-write-register-values: Usage: -data-write-register-"
1206 "values <format> [<regnum1> <value1>...<regnumN> <valueN>]"));
5796c8dc 1207
5796c8dc 1208 if (!target_has_registers)
c50c785c 1209 error (_("-data-write-register-values: No registers."));
5796c8dc
SS
1210
1211 if (!(argc - 1))
c50c785c 1212 error (_("-data-write-register-values: No regs and values specified."));
5796c8dc
SS
1213
1214 if ((argc - 1) % 2)
c50c785c
JM
1215 error (_("-data-write-register-values: "
1216 "Regs and vals are not in pairs."));
5796c8dc
SS
1217
1218 for (i = 1; i < argc; i = i + 2)
1219 {
1220 int regnum = atoi (argv[i]);
1221
1222 if (regnum >= 0 && regnum < numregs
1223 && gdbarch_register_name (gdbarch, regnum)
1224 && *gdbarch_register_name (gdbarch, regnum))
1225 {
1226 LONGEST value;
1227
1228 /* Get the value as a number. */
1229 value = parse_and_eval_address (argv[i + 1]);
1230
1231 /* Write it down. */
1232 regcache_cooked_write_signed (regcache, regnum, value);
1233 }
1234 else
c50c785c 1235 error (_("bad register number"));
5796c8dc
SS
1236 }
1237}
1238
1239/* Evaluate the value of the argument. The argument is an
1240 expression. If the expression contains spaces it needs to be
1241 included in double quotes. */
ef5ccd6c 1242
5796c8dc
SS
1243void
1244mi_cmd_data_evaluate_expression (char *command, char **argv, int argc)
1245{
1246 struct expression *expr;
ef5ccd6c 1247 struct cleanup *old_chain;
5796c8dc 1248 struct value *val;
ef5ccd6c 1249 struct ui_file *stb;
5796c8dc 1250 struct value_print_options opts;
a45ae5f8 1251 struct ui_out *uiout = current_uiout;
5796c8dc 1252
ef5ccd6c
JM
1253 stb = mem_fileopen ();
1254 old_chain = make_cleanup_ui_file_delete (stb);
5796c8dc
SS
1255
1256 if (argc != 1)
ef5ccd6c
JM
1257 error (_("-data-evaluate-expression: "
1258 "Usage: -data-evaluate-expression expression"));
5796c8dc
SS
1259
1260 expr = parse_expression (argv[0]);
1261
ef5ccd6c 1262 make_cleanup (free_current_contents, &expr);
5796c8dc
SS
1263
1264 val = evaluate_expression (expr);
1265
1266 /* Print the result of the expression evaluation. */
1267 get_user_print_options (&opts);
1268 opts.deref_ref = 0;
ef5ccd6c 1269 common_val_print (val, stb, 0, &opts, current_language);
5796c8dc
SS
1270
1271 ui_out_field_stream (uiout, "value", stb);
5796c8dc
SS
1272
1273 do_cleanups (old_chain);
1274}
1275
ef5ccd6c 1276/* This is the -data-read-memory command.
5796c8dc
SS
1277
1278 ADDR: start address of data to be dumped.
1279 WORD-FORMAT: a char indicating format for the ``word''. See
1280 the ``x'' command.
1281 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes.
1282 NR_ROW: Number of rows.
1283 NR_COL: The number of colums (words per row).
1284 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
1285 ASCHAR for unprintable characters.
1286
1287 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
1288 displayes them. Returns:
1289
1290 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
1291
1292 Returns:
ef5ccd6c 1293 The number of bytes read is SIZE*ROW*COL. */
5796c8dc
SS
1294
1295void
1296mi_cmd_data_read_memory (char *command, char **argv, int argc)
1297{
1298 struct gdbarch *gdbarch = get_current_arch ();
a45ae5f8 1299 struct ui_out *uiout = current_uiout;
5796c8dc
SS
1300 struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
1301 CORE_ADDR addr;
ef5ccd6c 1302 long total_bytes, nr_cols, nr_rows;
5796c8dc
SS
1303 char word_format;
1304 struct type *word_type;
1305 long word_size;
1306 char word_asize;
1307 char aschar;
1308 gdb_byte *mbuf;
1309 int nr_bytes;
1310 long offset = 0;
ef5ccd6c
JM
1311 int oind = 0;
1312 char *oarg;
5796c8dc 1313 enum opt
5796c8dc 1314 {
ef5ccd6c 1315 OFFSET_OPT
5796c8dc 1316 };
ef5ccd6c
JM
1317 static const struct mi_opt opts[] =
1318 {
1319 {"o", OFFSET_OPT, 1},
1320 { 0, 0, 0 }
1321 };
5796c8dc
SS
1322
1323 while (1)
1324 {
c50c785c 1325 int opt = mi_getopt ("-data-read-memory", argc, argv, opts,
ef5ccd6c 1326 &oind, &oarg);
cf7f2e2d 1327
5796c8dc
SS
1328 if (opt < 0)
1329 break;
1330 switch ((enum opt) opt)
1331 {
1332 case OFFSET_OPT:
ef5ccd6c 1333 offset = atol (oarg);
5796c8dc
SS
1334 break;
1335 }
1336 }
ef5ccd6c
JM
1337 argv += oind;
1338 argc -= oind;
5796c8dc
SS
1339
1340 if (argc < 5 || argc > 6)
c50c785c
JM
1341 error (_("-data-read-memory: Usage: "
1342 "ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR]."));
5796c8dc
SS
1343
1344 /* Extract all the arguments. */
1345
1346 /* Start address of the memory dump. */
1347 addr = parse_and_eval_address (argv[0]) + offset;
1348 /* The format character to use when displaying a memory word. See
ef5ccd6c 1349 the ``x'' command. */
5796c8dc
SS
1350 word_format = argv[1][0];
1351 /* The size of the memory word. */
1352 word_size = atol (argv[2]);
1353 switch (word_size)
1354 {
1355 case 1:
1356 word_type = builtin_type (gdbarch)->builtin_int8;
1357 word_asize = 'b';
1358 break;
1359 case 2:
1360 word_type = builtin_type (gdbarch)->builtin_int16;
1361 word_asize = 'h';
1362 break;
1363 case 4:
1364 word_type = builtin_type (gdbarch)->builtin_int32;
1365 word_asize = 'w';
1366 break;
1367 case 8:
1368 word_type = builtin_type (gdbarch)->builtin_int64;
1369 word_asize = 'g';
1370 break;
1371 default:
1372 word_type = builtin_type (gdbarch)->builtin_int8;
1373 word_asize = 'b';
1374 }
1375 /* The number of rows. */
1376 nr_rows = atol (argv[3]);
1377 if (nr_rows <= 0)
c50c785c 1378 error (_("-data-read-memory: invalid number of rows."));
5796c8dc
SS
1379
1380 /* Number of bytes per row. */
1381 nr_cols = atol (argv[4]);
1382 if (nr_cols <= 0)
c50c785c 1383 error (_("-data-read-memory: invalid number of columns."));
5796c8dc
SS
1384
1385 /* The un-printable character when printing ascii. */
1386 if (argc == 6)
1387 aschar = *argv[5];
1388 else
1389 aschar = 0;
1390
1391 /* Create a buffer and read it in. */
1392 total_bytes = word_size * nr_rows * nr_cols;
1393 mbuf = xcalloc (total_bytes, 1);
1394 make_cleanup (xfree, mbuf);
1395
1396 /* Dispatch memory reads to the topmost target, not the flattened
1397 current_target. */
c50c785c
JM
1398 nr_bytes = target_read (current_target.beneath,
1399 TARGET_OBJECT_MEMORY, NULL, mbuf,
1400 addr, total_bytes);
5796c8dc 1401 if (nr_bytes <= 0)
c50c785c 1402 error (_("Unable to read memory."));
5796c8dc
SS
1403
1404 /* Output the header information. */
1405 ui_out_field_core_addr (uiout, "addr", gdbarch, addr);
1406 ui_out_field_int (uiout, "nr-bytes", nr_bytes);
1407 ui_out_field_int (uiout, "total-bytes", total_bytes);
1408 ui_out_field_core_addr (uiout, "next-row",
1409 gdbarch, addr + word_size * nr_cols);
1410 ui_out_field_core_addr (uiout, "prev-row",
1411 gdbarch, addr - word_size * nr_cols);
1412 ui_out_field_core_addr (uiout, "next-page", gdbarch, addr + total_bytes);
1413 ui_out_field_core_addr (uiout, "prev-page", gdbarch, addr - total_bytes);
1414
1415 /* Build the result as a two dimentional table. */
1416 {
ef5ccd6c
JM
1417 struct ui_file *stream;
1418 struct cleanup *cleanup_stream;
5796c8dc
SS
1419 int row;
1420 int row_byte;
cf7f2e2d 1421
ef5ccd6c
JM
1422 stream = mem_fileopen ();
1423 cleanup_stream = make_cleanup_ui_file_delete (stream);
1424
1425 make_cleanup_ui_out_list_begin_end (uiout, "memory");
5796c8dc
SS
1426 for (row = 0, row_byte = 0;
1427 row < nr_rows;
1428 row++, row_byte += nr_cols * word_size)
1429 {
1430 int col;
1431 int col_byte;
1432 struct cleanup *cleanup_tuple;
1433 struct cleanup *cleanup_list_data;
1434 struct value_print_options opts;
1435
1436 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1437 ui_out_field_core_addr (uiout, "addr", gdbarch, addr + row_byte);
c50c785c
JM
1438 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr +
1439 row_byte); */
5796c8dc
SS
1440 cleanup_list_data = make_cleanup_ui_out_list_begin_end (uiout, "data");
1441 get_formatted_print_options (&opts, word_format);
1442 for (col = 0, col_byte = row_byte;
1443 col < nr_cols;
1444 col++, col_byte += word_size)
1445 {
1446 if (col_byte + word_size > nr_bytes)
1447 {
1448 ui_out_field_string (uiout, NULL, "N/A");
1449 }
1450 else
1451 {
ef5ccd6c 1452 ui_file_rewind (stream);
5796c8dc 1453 print_scalar_formatted (mbuf + col_byte, word_type, &opts,
ef5ccd6c 1454 word_asize, stream);
5796c8dc
SS
1455 ui_out_field_stream (uiout, NULL, stream);
1456 }
1457 }
1458 do_cleanups (cleanup_list_data);
1459 if (aschar)
1460 {
1461 int byte;
cf7f2e2d 1462
ef5ccd6c 1463 ui_file_rewind (stream);
c50c785c
JM
1464 for (byte = row_byte;
1465 byte < row_byte + word_size * nr_cols; byte++)
5796c8dc
SS
1466 {
1467 if (byte >= nr_bytes)
ef5ccd6c 1468 fputc_unfiltered ('X', stream);
5796c8dc 1469 else if (mbuf[byte] < 32 || mbuf[byte] > 126)
ef5ccd6c 1470 fputc_unfiltered (aschar, stream);
5796c8dc 1471 else
ef5ccd6c 1472 fputc_unfiltered (mbuf[byte], stream);
5796c8dc
SS
1473 }
1474 ui_out_field_stream (uiout, "ascii", stream);
1475 }
1476 do_cleanups (cleanup_tuple);
1477 }
ef5ccd6c 1478 do_cleanups (cleanup_stream);
5796c8dc
SS
1479 }
1480 do_cleanups (cleanups);
1481}
1482
c50c785c
JM
1483void
1484mi_cmd_data_read_memory_bytes (char *command, char **argv, int argc)
1485{
1486 struct gdbarch *gdbarch = get_current_arch ();
a45ae5f8 1487 struct ui_out *uiout = current_uiout;
c50c785c
JM
1488 struct cleanup *cleanups;
1489 CORE_ADDR addr;
1490 LONGEST length;
1491 memory_read_result_s *read_result;
1492 int ix;
1493 VEC(memory_read_result_s) *result;
1494 long offset = 0;
ef5ccd6c
JM
1495 int oind = 0;
1496 char *oarg;
c50c785c 1497 enum opt
c50c785c 1498 {
ef5ccd6c 1499 OFFSET_OPT
c50c785c 1500 };
ef5ccd6c
JM
1501 static const struct mi_opt opts[] =
1502 {
1503 {"o", OFFSET_OPT, 1},
1504 { 0, 0, 0 }
1505 };
c50c785c
JM
1506
1507 while (1)
1508 {
1509 int opt = mi_getopt ("-data-read-memory-bytes", argc, argv, opts,
ef5ccd6c 1510 &oind, &oarg);
c50c785c
JM
1511 if (opt < 0)
1512 break;
1513 switch ((enum opt) opt)
1514 {
1515 case OFFSET_OPT:
ef5ccd6c 1516 offset = atol (oarg);
c50c785c
JM
1517 break;
1518 }
1519 }
ef5ccd6c
JM
1520 argv += oind;
1521 argc -= oind;
c50c785c
JM
1522
1523 if (argc != 2)
1524 error (_("Usage: [ -o OFFSET ] ADDR LENGTH."));
1525
1526 addr = parse_and_eval_address (argv[0]) + offset;
1527 length = atol (argv[1]);
1528
1529 result = read_memory_robust (current_target.beneath, addr, length);
1530
1531 cleanups = make_cleanup (free_memory_read_result_vector, result);
1532
1533 if (VEC_length (memory_read_result_s, result) == 0)
1534 error (_("Unable to read memory."));
1535
1536 make_cleanup_ui_out_list_begin_end (uiout, "memory");
1537 for (ix = 0;
1538 VEC_iterate (memory_read_result_s, result, ix, read_result);
1539 ++ix)
1540 {
1541 struct cleanup *t = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1542 char *data, *p;
1543 int i;
1544
1545 ui_out_field_core_addr (uiout, "begin", gdbarch, read_result->begin);
1546 ui_out_field_core_addr (uiout, "offset", gdbarch, read_result->begin
1547 - addr);
1548 ui_out_field_core_addr (uiout, "end", gdbarch, read_result->end);
1549
1550 data = xmalloc ((read_result->end - read_result->begin) * 2 + 1);
1551
1552 for (i = 0, p = data;
1553 i < (read_result->end - read_result->begin);
1554 ++i, p += 2)
1555 {
1556 sprintf (p, "%02x", read_result->data[i]);
1557 }
1558 ui_out_field_string (uiout, "contents", data);
1559 xfree (data);
1560 do_cleanups (t);
1561 }
1562 do_cleanups (cleanups);
1563}
1564
ef5ccd6c 1565/* Implementation of the -data-write_memory command.
5796c8dc 1566
a45ae5f8 1567 COLUMN_OFFSET: optional argument. Must be preceded by '-o'. The
5796c8dc
SS
1568 offset from the beginning of the memory grid row where the cell to
1569 be written is.
1570 ADDR: start address of the row in the memory grid where the memory
1571 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
1572 the location to write to.
1573 FORMAT: a char indicating format for the ``word''. See
1574 the ``x'' command.
1575 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
1576 VALUE: value to be written into the memory address.
1577
1578 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
1579
1580 Prints nothing. */
ef5ccd6c 1581
5796c8dc
SS
1582void
1583mi_cmd_data_write_memory (char *command, char **argv, int argc)
1584{
1585 struct gdbarch *gdbarch = get_current_arch ();
1586 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1587 CORE_ADDR addr;
5796c8dc
SS
1588 long word_size;
1589 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
1590 enough when using a compiler other than GCC. */
1591 LONGEST value;
1592 void *buffer;
1593 struct cleanup *old_chain;
1594 long offset = 0;
ef5ccd6c
JM
1595 int oind = 0;
1596 char *oarg;
5796c8dc 1597 enum opt
5796c8dc 1598 {
ef5ccd6c 1599 OFFSET_OPT
5796c8dc 1600 };
ef5ccd6c
JM
1601 static const struct mi_opt opts[] =
1602 {
1603 {"o", OFFSET_OPT, 1},
1604 { 0, 0, 0 }
1605 };
5796c8dc
SS
1606
1607 while (1)
1608 {
c50c785c 1609 int opt = mi_getopt ("-data-write-memory", argc, argv, opts,
ef5ccd6c 1610 &oind, &oarg);
cf7f2e2d 1611
5796c8dc
SS
1612 if (opt < 0)
1613 break;
1614 switch ((enum opt) opt)
1615 {
1616 case OFFSET_OPT:
ef5ccd6c 1617 offset = atol (oarg);
5796c8dc
SS
1618 break;
1619 }
1620 }
ef5ccd6c
JM
1621 argv += oind;
1622 argc -= oind;
5796c8dc
SS
1623
1624 if (argc != 4)
c50c785c
JM
1625 error (_("-data-write-memory: Usage: "
1626 "[-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE."));
5796c8dc
SS
1627
1628 /* Extract all the arguments. */
1629 /* Start address of the memory dump. */
1630 addr = parse_and_eval_address (argv[0]);
ef5ccd6c 1631 /* The size of the memory word. */
5796c8dc
SS
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. */
ef5ccd6c 1644 write_memory_with_notification (addr, buffer, word_size);
5796c8dc
SS
1645 /* Free the buffer. */
1646 do_cleanups (old_chain);
1647}
1648
ef5ccd6c 1649/* Implementation of the -data-write-memory-bytes command.
c50c785c
JM
1650
1651 ADDR: start address
ef5ccd6c
JM
1652 DATA: string of bytes to write at that address
1653 COUNT: number of bytes to be filled (decimal integer). */
1654
c50c785c
JM
1655void
1656mi_cmd_data_write_memory_bytes (char *command, char **argv, int argc)
1657{
1658 CORE_ADDR addr;
1659 char *cdata;
1660 gdb_byte *data;
ef5ccd6c
JM
1661 gdb_byte *databuf;
1662 size_t len, i, steps, remainder;
1663 long int count, j;
c50c785c
JM
1664 struct cleanup *back_to;
1665
ef5ccd6c
JM
1666 if (argc != 2 && argc != 3)
1667 error (_("Usage: ADDR DATA [COUNT]."));
c50c785c
JM
1668
1669 addr = parse_and_eval_address (argv[0]);
1670 cdata = argv[1];
ef5ccd6c
JM
1671 if (strlen (cdata) % 2)
1672 error (_("Hex-encoded '%s' must have an even number of characters."),
1673 cdata);
1674
c50c785c 1675 len = strlen (cdata)/2;
ef5ccd6c
JM
1676 if (argc == 3)
1677 count = strtoul (argv[2], NULL, 10);
1678 else
1679 count = len;
c50c785c 1680
ef5ccd6c
JM
1681 databuf = xmalloc (len * sizeof (gdb_byte));
1682 back_to = make_cleanup (xfree, databuf);
c50c785c
JM
1683
1684 for (i = 0; i < len; ++i)
1685 {
1686 int x;
ef5ccd6c
JM
1687 if (sscanf (cdata + i * 2, "%02x", &x) != 1)
1688 error (_("Invalid argument"));
1689 databuf[i] = (gdb_byte) x;
1690 }
1691
1692 if (len < count)
1693 {
1694 /* Pattern is made of less bytes than count:
1695 repeat pattern to fill memory. */
1696 data = xmalloc (count);
1697 make_cleanup (xfree, data);
1698
1699 steps = count / len;
1700 remainder = count % len;
1701 for (j = 0; j < steps; j++)
1702 memcpy (data + j * len, databuf, len);
1703
1704 if (remainder > 0)
1705 memcpy (data + steps * len, databuf, remainder);
1706 }
1707 else
1708 {
1709 /* Pattern is longer than or equal to count:
1710 just copy len bytes. */
1711 data = databuf;
c50c785c
JM
1712 }
1713
ef5ccd6c 1714 write_memory_with_notification (addr, data, count);
c50c785c
JM
1715
1716 do_cleanups (back_to);
1717}
1718
5796c8dc
SS
1719void
1720mi_cmd_enable_timings (char *command, char **argv, int argc)
1721{
1722 if (argc == 0)
1723 do_timings = 1;
1724 else if (argc == 1)
1725 {
1726 if (strcmp (argv[0], "yes") == 0)
1727 do_timings = 1;
1728 else if (strcmp (argv[0], "no") == 0)
1729 do_timings = 0;
1730 else
1731 goto usage_error;
1732 }
1733 else
1734 goto usage_error;
1735
1736 return;
1737
1738 usage_error:
c50c785c 1739 error (_("-enable-timings: Usage: %s {yes|no}"), command);
5796c8dc
SS
1740}
1741
1742void
1743mi_cmd_list_features (char *command, char **argv, int argc)
1744{
1745 if (argc == 0)
1746 {
1747 struct cleanup *cleanup = NULL;
a45ae5f8 1748 struct ui_out *uiout = current_uiout;
5796c8dc 1749
cf7f2e2d 1750 cleanup = make_cleanup_ui_out_list_begin_end (uiout, "features");
5796c8dc
SS
1751 ui_out_field_string (uiout, NULL, "frozen-varobjs");
1752 ui_out_field_string (uiout, NULL, "pending-breakpoints");
1753 ui_out_field_string (uiout, NULL, "thread-info");
c50c785c 1754 ui_out_field_string (uiout, NULL, "data-read-memory-bytes");
a45ae5f8
JM
1755 ui_out_field_string (uiout, NULL, "breakpoint-notifications");
1756 ui_out_field_string (uiout, NULL, "ada-task-info");
5796c8dc
SS
1757
1758#if HAVE_PYTHON
1759 ui_out_field_string (uiout, NULL, "python");
1760#endif
1761
1762 do_cleanups (cleanup);
1763 return;
1764 }
1765
c50c785c 1766 error (_("-list-features should be passed no arguments"));
5796c8dc
SS
1767}
1768
1769void
1770mi_cmd_list_target_features (char *command, char **argv, int argc)
1771{
1772 if (argc == 0)
1773 {
1774 struct cleanup *cleanup = NULL;
a45ae5f8 1775 struct ui_out *uiout = current_uiout;
5796c8dc 1776
cf7f2e2d 1777 cleanup = make_cleanup_ui_out_list_begin_end (uiout, "features");
5796c8dc
SS
1778 if (target_can_async_p ())
1779 ui_out_field_string (uiout, NULL, "async");
cf7f2e2d
JM
1780 if (target_can_execute_reverse)
1781 ui_out_field_string (uiout, NULL, "reverse");
5796c8dc
SS
1782
1783 do_cleanups (cleanup);
1784 return;
1785 }
1786
c50c785c 1787 error (_("-list-target-features should be passed no arguments"));
5796c8dc
SS
1788}
1789
cf7f2e2d
JM
1790void
1791mi_cmd_add_inferior (char *command, char **argv, int argc)
1792{
1793 struct inferior *inf;
1794
1795 if (argc != 0)
1796 error (_("-add-inferior should be passed no arguments"));
1797
1798 inf = add_inferior_with_spaces ();
1799
a45ae5f8 1800 ui_out_field_fmt (current_uiout, "inferior", "i%d", inf->num);
cf7f2e2d
JM
1801}
1802
ef5ccd6c
JM
1803/* Callback used to find the first inferior other than the current
1804 one. */
c50c785c
JM
1805
1806static int
1807get_other_inferior (struct inferior *inf, void *arg)
1808{
1809 if (inf == current_inferior ())
1810 return 0;
1811
1812 return 1;
1813}
1814
cf7f2e2d
JM
1815void
1816mi_cmd_remove_inferior (char *command, char **argv, int argc)
1817{
1818 int id;
1819 struct inferior *inf;
1820
1821 if (argc != 1)
c50c785c 1822 error (_("-remove-inferior should be passed a single argument"));
cf7f2e2d
JM
1823
1824 if (sscanf (argv[0], "i%d", &id) != 1)
c50c785c 1825 error (_("the thread group id is syntactically invalid"));
cf7f2e2d
JM
1826
1827 inf = find_inferior_id (id);
1828 if (!inf)
c50c785c
JM
1829 error (_("the specified thread group does not exist"));
1830
1831 if (inf->pid != 0)
1832 error (_("cannot remove an active inferior"));
1833
1834 if (inf == current_inferior ())
1835 {
1836 struct thread_info *tp = 0;
1837 struct inferior *new_inferior
1838 = iterate_over_inferiors (get_other_inferior, NULL);
1839
1840 if (new_inferior == NULL)
1841 error (_("Cannot remove last inferior"));
1842
1843 set_current_inferior (new_inferior);
1844 if (new_inferior->pid != 0)
1845 tp = any_thread_of_process (new_inferior->pid);
1846 switch_to_thread (tp ? tp->ptid : null_ptid);
1847 set_current_program_space (new_inferior->pspace);
1848 }
cf7f2e2d
JM
1849
1850 delete_inferior_1 (inf, 1 /* silent */);
1851}
1852
1853\f
1854
5796c8dc
SS
1855/* Execute a command within a safe environment.
1856 Return <0 for error; >=0 for ok.
1857
1858 args->action will tell mi_execute_command what action
1859 to perfrom after the given command has executed (display/suppress
ef5ccd6c 1860 prompt, display error). */
5796c8dc
SS
1861
1862static void
a45ae5f8 1863captured_mi_execute_command (struct ui_out *uiout, struct mi_parse *context)
5796c8dc
SS
1864{
1865 struct cleanup *cleanup;
5796c8dc
SS
1866
1867 if (do_timings)
1868 current_command_ts = context->cmd_start;
1869
1870 current_token = xstrdup (context->token);
1871 cleanup = make_cleanup (free_current_contents, &current_token);
1872
1873 running_result_record_printed = 0;
1874 mi_proceeded = 0;
1875 switch (context->op)
1876 {
1877 case MI_COMMAND:
1878 /* A MI command was read from the input stream. */
1879 if (mi_debug_p)
1880 /* FIXME: gdb_???? */
1881 fprintf_unfiltered (raw_stdout, " token=`%s' command=`%s' args=`%s'\n",
1882 context->token, context->command, context->args);
1883
5796c8dc
SS
1884 mi_cmd_execute (context);
1885
1886 /* Print the result if there were no errors.
1887
1888 Remember that on the way out of executing a command, you have
ef5ccd6c
JM
1889 to directly use the mi_interp's uiout, since the command
1890 could have reset the interpreter, in which case the current
1891 uiout will most likely crash in the mi_out_* routines. */
5796c8dc
SS
1892 if (!running_result_record_printed)
1893 {
1894 fputs_unfiltered (context->token, raw_stdout);
1895 /* There's no particularly good reason why target-connect results
1896 in not ^done. Should kill ^connected for MI3. */
1897 fputs_unfiltered (strcmp (context->command, "target-select") == 0
1898 ? "^connected" : "^done", raw_stdout);
1899 mi_out_put (uiout, raw_stdout);
1900 mi_out_rewind (uiout);
1901 mi_print_timing_maybe ();
1902 fputs_unfiltered ("\n", raw_stdout);
1903 }
1904 else
ef5ccd6c
JM
1905 /* The command does not want anything to be printed. In that
1906 case, the command probably should not have written anything
1907 to uiout, but in case it has written something, discard it. */
5796c8dc
SS
1908 mi_out_rewind (uiout);
1909 break;
1910
1911 case CLI_COMMAND:
1912 {
1913 char *argv[2];
cf7f2e2d 1914
5796c8dc
SS
1915 /* A CLI command was read from the input stream. */
1916 /* This "feature" will be removed as soon as we have a
1917 complete set of mi commands. */
1918 /* Echo the command on the console. */
1919 fprintf_unfiltered (gdb_stdlog, "%s\n", context->command);
1920 /* Call the "console" interpreter. */
1921 argv[0] = "console";
1922 argv[1] = context->command;
1923 mi_cmd_interpreter_exec ("-interpreter-exec", argv, 2);
1924
1925 /* If we changed interpreters, DON'T print out anything. */
1926 if (current_interp_named_p (INTERP_MI)
1927 || current_interp_named_p (INTERP_MI1)
1928 || current_interp_named_p (INTERP_MI2)
1929 || current_interp_named_p (INTERP_MI3))
1930 {
1931 if (!running_result_record_printed)
1932 {
1933 fputs_unfiltered (context->token, raw_stdout);
1934 fputs_unfiltered ("^done", raw_stdout);
1935 mi_out_put (uiout, raw_stdout);
1936 mi_out_rewind (uiout);
1937 mi_print_timing_maybe ();
1938 fputs_unfiltered ("\n", raw_stdout);
1939 }
1940 else
1941 mi_out_rewind (uiout);
1942 }
1943 break;
1944 }
5796c8dc
SS
1945 }
1946
1947 do_cleanups (cleanup);
5796c8dc
SS
1948}
1949
c50c785c
JM
1950/* Print a gdb exception to the MI output stream. */
1951
1952static void
1953mi_print_exception (const char *token, struct gdb_exception exception)
1954{
1955 fputs_unfiltered (token, raw_stdout);
1956 fputs_unfiltered ("^error,msg=\"", raw_stdout);
1957 if (exception.message == NULL)
1958 fputs_unfiltered ("unknown error", raw_stdout);
1959 else
1960 fputstr_unfiltered (exception.message, '"', raw_stdout);
1961 fputs_unfiltered ("\"\n", raw_stdout);
1962}
5796c8dc
SS
1963
1964void
ef5ccd6c 1965mi_execute_command (const char *cmd, int from_tty)
5796c8dc 1966{
c50c785c
JM
1967 char *token;
1968 struct mi_parse *command = NULL;
1969 volatile struct gdb_exception exception;
5796c8dc
SS
1970
1971 /* This is to handle EOF (^D). We just quit gdb. */
1972 /* FIXME: we should call some API function here. */
1973 if (cmd == 0)
1974 quit_force (NULL, from_tty);
1975
cf7f2e2d
JM
1976 target_log_command (cmd);
1977
c50c785c
JM
1978 TRY_CATCH (exception, RETURN_MASK_ALL)
1979 {
1980 command = mi_parse (cmd, &token);
1981 }
1982 if (exception.reason < 0)
1983 {
1984 mi_print_exception (token, exception);
1985 xfree (token);
1986 }
1987 else
5796c8dc 1988 {
a45ae5f8 1989 volatile struct gdb_exception result;
5796c8dc
SS
1990 ptid_t previous_ptid = inferior_ptid;
1991
c50c785c
JM
1992 command->token = token;
1993
5796c8dc
SS
1994 if (do_timings)
1995 {
1996 command->cmd_start = (struct mi_timestamp *)
1997 xmalloc (sizeof (struct mi_timestamp));
1998 timestamp (command->cmd_start);
1999 }
2000
a45ae5f8
JM
2001 TRY_CATCH (result, RETURN_MASK_ALL)
2002 {
2003 captured_mi_execute_command (current_uiout, command);
2004 }
5796c8dc
SS
2005 if (result.reason < 0)
2006 {
2007 /* The command execution failed and error() was called
2008 somewhere. */
c50c785c 2009 mi_print_exception (command->token, result);
a45ae5f8 2010 mi_out_rewind (current_uiout);
5796c8dc
SS
2011 }
2012
cf7f2e2d
JM
2013 bpstat_do_actions ();
2014
5796c8dc
SS
2015 if (/* The notifications are only output when the top-level
2016 interpreter (specified on the command line) is MI. */
2017 ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ()))
2018 /* Don't try report anything if there are no threads --
2019 the program is dead. */
2020 && thread_count () != 0
2021 /* -thread-select explicitly changes thread. If frontend uses that
2022 internally, we don't want to emit =thread-selected, since
2023 =thread-selected is supposed to indicate user's intentions. */
2024 && strcmp (command->command, "thread-select") != 0)
2025 {
2026 struct mi_interp *mi = top_level_interpreter_data ();
2027 int report_change = 0;
2028
2029 if (command->thread == -1)
2030 {
2031 report_change = (!ptid_equal (previous_ptid, null_ptid)
2032 && !ptid_equal (inferior_ptid, previous_ptid)
2033 && !ptid_equal (inferior_ptid, null_ptid));
2034 }
2035 else if (!ptid_equal (inferior_ptid, null_ptid))
2036 {
2037 struct thread_info *ti = inferior_thread ();
cf7f2e2d 2038
5796c8dc
SS
2039 report_change = (ti->num != command->thread);
2040 }
2041
2042 if (report_change)
2043 {
2044 struct thread_info *ti = inferior_thread ();
cf7f2e2d 2045
5796c8dc
SS
2046 target_terminal_ours ();
2047 fprintf_unfiltered (mi->event_channel,
2048 "thread-selected,id=\"%d\"",
2049 ti->num);
2050 gdb_flush (mi->event_channel);
2051 }
2052 }
2053
2054 mi_parse_free (command);
2055 }
5796c8dc
SS
2056}
2057
2058static void
2059mi_cmd_execute (struct mi_parse *parse)
2060{
2061 struct cleanup *cleanup;
5796c8dc 2062
a45ae5f8 2063 cleanup = prepare_execute_command ();
5796c8dc 2064
cf7f2e2d
JM
2065 if (parse->all && parse->thread_group != -1)
2066 error (_("Cannot specify --thread-group together with --all"));
2067
2068 if (parse->all && parse->thread != -1)
2069 error (_("Cannot specify --thread together with --all"));
2070
2071 if (parse->thread_group != -1 && parse->thread != -1)
2072 error (_("Cannot specify --thread together with --thread-group"));
2073
5796c8dc
SS
2074 if (parse->frame != -1 && parse->thread == -1)
2075 error (_("Cannot specify --frame without --thread"));
2076
cf7f2e2d
JM
2077 if (parse->thread_group != -1)
2078 {
2079 struct inferior *inf = find_inferior_id (parse->thread_group);
2080 struct thread_info *tp = 0;
2081
2082 if (!inf)
2083 error (_("Invalid thread group for the --thread-group option"));
2084
2085 set_current_inferior (inf);
2086 /* This behaviour means that if --thread-group option identifies
ef5ccd6c
JM
2087 an inferior with multiple threads, then a random one will be
2088 picked. This is not a problem -- frontend should always
2089 provide --thread if it wishes to operate on a specific
2090 thread. */
cf7f2e2d 2091 if (inf->pid != 0)
a45ae5f8 2092 tp = any_live_thread_of_process (inf->pid);
cf7f2e2d
JM
2093 switch_to_thread (tp ? tp->ptid : null_ptid);
2094 set_current_program_space (inf->pspace);
2095 }
2096
5796c8dc
SS
2097 if (parse->thread != -1)
2098 {
2099 struct thread_info *tp = find_thread_id (parse->thread);
cf7f2e2d 2100
5796c8dc
SS
2101 if (!tp)
2102 error (_("Invalid thread id: %d"), parse->thread);
2103
2104 if (is_exited (tp->ptid))
2105 error (_("Thread id: %d has terminated"), parse->thread);
2106
2107 switch_to_thread (tp->ptid);
2108 }
2109
2110 if (parse->frame != -1)
2111 {
2112 struct frame_info *fid;
2113 int frame = parse->frame;
cf7f2e2d 2114
5796c8dc
SS
2115 fid = find_relative_frame (get_current_frame (), &frame);
2116 if (frame == 0)
2117 /* find_relative_frame was successful */
2118 select_frame (fid);
2119 else
2120 error (_("Invalid frame id: %d"), frame);
2121 }
2122
cf7f2e2d
JM
2123 current_context = parse;
2124
ef5ccd6c 2125 if (parse->cmd->suppress_notification != NULL)
a45ae5f8 2126 {
ef5ccd6c
JM
2127 make_cleanup_restore_integer (parse->cmd->suppress_notification);
2128 *parse->cmd->suppress_notification = 1;
a45ae5f8
JM
2129 }
2130
5796c8dc 2131 if (parse->cmd->argv_func != NULL)
a45ae5f8
JM
2132 {
2133 parse->cmd->argv_func (parse->command, parse->argv, parse->argc);
2134 }
5796c8dc
SS
2135 else if (parse->cmd->cli.cmd != 0)
2136 {
2137 /* FIXME: DELETE THIS. */
2138 /* The operation is still implemented by a cli command. */
2139 /* Must be a synchronous one. */
2140 mi_execute_cli_command (parse->cmd->cli.cmd, parse->cmd->cli.args_p,
2141 parse->args);
2142 }
2143 else
2144 {
2145 /* FIXME: DELETE THIS. */
2146 struct ui_file *stb;
2147
2148 stb = mem_fileopen ();
2149
2150 fputs_unfiltered ("Undefined mi command: ", stb);
2151 fputstr_unfiltered (parse->command, '"', stb);
2152 fputs_unfiltered (" (missing implementation)", stb);
2153
2154 make_cleanup_ui_file_delete (stb);
2155 error_stream (stb);
2156 }
2157 do_cleanups (cleanup);
2158}
2159
2160/* FIXME: This is just a hack so we can get some extra commands going.
2161 We don't want to channel things through the CLI, but call libgdb directly.
2162 Use only for synchronous commands. */
2163
2164void
2165mi_execute_cli_command (const char *cmd, int args_p, const char *args)
2166{
2167 if (cmd != 0)
2168 {
2169 struct cleanup *old_cleanups;
2170 char *run;
cf7f2e2d 2171
5796c8dc
SS
2172 if (args_p)
2173 run = xstrprintf ("%s %s", cmd, args);
2174 else
2175 run = xstrdup (cmd);
2176 if (mi_debug_p)
2177 /* FIXME: gdb_???? */
2178 fprintf_unfiltered (gdb_stdout, "cli=%s run=%s\n",
2179 cmd, run);
2180 old_cleanups = make_cleanup (xfree, run);
ef5ccd6c 2181 execute_command (run, 0 /* from_tty */ );
5796c8dc
SS
2182 do_cleanups (old_cleanups);
2183 return;
2184 }
2185}
2186
2187void
2188mi_execute_async_cli_command (char *cli_command, char **argv, int argc)
2189{
2190 struct cleanup *old_cleanups;
2191 char *run;
2192
2193 if (target_can_async_p ())
2194 run = xstrprintf ("%s %s&", cli_command, argc ? *argv : "");
2195 else
2196 run = xstrprintf ("%s %s", cli_command, argc ? *argv : "");
2197 old_cleanups = make_cleanup (xfree, run);
2198
ef5ccd6c 2199 execute_command (run, 0 /* from_tty */ );
5796c8dc 2200
a45ae5f8
JM
2201 /* Do this before doing any printing. It would appear that some
2202 print code leaves garbage around in the buffer. */
2203 do_cleanups (old_cleanups);
5796c8dc
SS
2204}
2205
2206void
2207mi_load_progress (const char *section_name,
2208 unsigned long sent_so_far,
2209 unsigned long total_section,
2210 unsigned long total_sent,
2211 unsigned long grand_total)
2212{
2213 struct timeval time_now, delta, update_threshold;
2214 static struct timeval last_update;
2215 static char *previous_sect_name = NULL;
2216 int new_section;
2217 struct ui_out *saved_uiout;
a45ae5f8 2218 struct ui_out *uiout;
5796c8dc
SS
2219
2220 /* This function is called through deprecated_show_load_progress
2221 which means uiout may not be correct. Fix it for the duration
2222 of this function. */
a45ae5f8 2223 saved_uiout = current_uiout;
5796c8dc
SS
2224
2225 if (current_interp_named_p (INTERP_MI)
2226 || current_interp_named_p (INTERP_MI2))
a45ae5f8 2227 current_uiout = mi_out_new (2);
5796c8dc 2228 else if (current_interp_named_p (INTERP_MI1))
a45ae5f8 2229 current_uiout = mi_out_new (1);
5796c8dc 2230 else if (current_interp_named_p (INTERP_MI3))
a45ae5f8 2231 current_uiout = mi_out_new (3);
5796c8dc
SS
2232 else
2233 return;
2234
a45ae5f8
JM
2235 uiout = current_uiout;
2236
5796c8dc
SS
2237 update_threshold.tv_sec = 0;
2238 update_threshold.tv_usec = 500000;
2239 gettimeofday (&time_now, NULL);
2240
2241 delta.tv_usec = time_now.tv_usec - last_update.tv_usec;
2242 delta.tv_sec = time_now.tv_sec - last_update.tv_sec;
2243
2244 if (delta.tv_usec < 0)
2245 {
2246 delta.tv_sec -= 1;
2247 delta.tv_usec += 1000000L;
2248 }
2249
2250 new_section = (previous_sect_name ?
2251 strcmp (previous_sect_name, section_name) : 1);
2252 if (new_section)
2253 {
2254 struct cleanup *cleanup_tuple;
cf7f2e2d 2255
5796c8dc
SS
2256 xfree (previous_sect_name);
2257 previous_sect_name = xstrdup (section_name);
2258
2259 if (current_token)
2260 fputs_unfiltered (current_token, raw_stdout);
2261 fputs_unfiltered ("+download", raw_stdout);
2262 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
2263 ui_out_field_string (uiout, "section", section_name);
2264 ui_out_field_int (uiout, "section-size", total_section);
2265 ui_out_field_int (uiout, "total-size", grand_total);
2266 do_cleanups (cleanup_tuple);
2267 mi_out_put (uiout, raw_stdout);
2268 fputs_unfiltered ("\n", raw_stdout);
2269 gdb_flush (raw_stdout);
2270 }
2271
2272 if (delta.tv_sec >= update_threshold.tv_sec &&
2273 delta.tv_usec >= update_threshold.tv_usec)
2274 {
2275 struct cleanup *cleanup_tuple;
cf7f2e2d 2276
5796c8dc
SS
2277 last_update.tv_sec = time_now.tv_sec;
2278 last_update.tv_usec = time_now.tv_usec;
2279 if (current_token)
2280 fputs_unfiltered (current_token, raw_stdout);
2281 fputs_unfiltered ("+download", raw_stdout);
2282 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
2283 ui_out_field_string (uiout, "section", section_name);
2284 ui_out_field_int (uiout, "section-sent", sent_so_far);
2285 ui_out_field_int (uiout, "section-size", total_section);
2286 ui_out_field_int (uiout, "total-sent", total_sent);
2287 ui_out_field_int (uiout, "total-size", grand_total);
2288 do_cleanups (cleanup_tuple);
2289 mi_out_put (uiout, raw_stdout);
2290 fputs_unfiltered ("\n", raw_stdout);
2291 gdb_flush (raw_stdout);
2292 }
2293
2294 xfree (uiout);
a45ae5f8 2295 current_uiout = saved_uiout;
5796c8dc
SS
2296}
2297
2298static void
2299timestamp (struct mi_timestamp *tv)
ef5ccd6c
JM
2300{
2301 gettimeofday (&tv->wallclock, NULL);
5796c8dc 2302#ifdef HAVE_GETRUSAGE
ef5ccd6c
JM
2303 getrusage (RUSAGE_SELF, &rusage);
2304 tv->utime.tv_sec = rusage.ru_utime.tv_sec;
2305 tv->utime.tv_usec = rusage.ru_utime.tv_usec;
2306 tv->stime.tv_sec = rusage.ru_stime.tv_sec;
2307 tv->stime.tv_usec = rusage.ru_stime.tv_usec;
5796c8dc 2308#else
ef5ccd6c
JM
2309 {
2310 long usec = get_run_time ();
cf7f2e2d 2311
ef5ccd6c
JM
2312 tv->utime.tv_sec = usec/1000000L;
2313 tv->utime.tv_usec = usec - 1000000L*tv->utime.tv_sec;
2314 tv->stime.tv_sec = 0;
2315 tv->stime.tv_usec = 0;
5796c8dc 2316 }
ef5ccd6c
JM
2317#endif
2318}
5796c8dc
SS
2319
2320static void
2321print_diff_now (struct mi_timestamp *start)
ef5ccd6c
JM
2322{
2323 struct mi_timestamp now;
cf7f2e2d 2324
ef5ccd6c
JM
2325 timestamp (&now);
2326 print_diff (start, &now);
2327}
5796c8dc
SS
2328
2329void
2330mi_print_timing_maybe (void)
2331{
ef5ccd6c
JM
2332 /* If the command is -enable-timing then do_timings may be true
2333 whilst current_command_ts is not initialized. */
5796c8dc
SS
2334 if (do_timings && current_command_ts)
2335 print_diff_now (current_command_ts);
2336}
2337
2338static long
2339timeval_diff (struct timeval start, struct timeval end)
ef5ccd6c
JM
2340{
2341 return ((end.tv_sec - start.tv_sec) * 1000000L)
2342 + (end.tv_usec - start.tv_usec);
2343}
5796c8dc
SS
2344
2345static void
2346print_diff (struct mi_timestamp *start, struct mi_timestamp *end)
ef5ccd6c
JM
2347{
2348 fprintf_unfiltered
2349 (raw_stdout,
2350 ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
2351 timeval_diff (start->wallclock, end->wallclock) / 1000000.0,
2352 timeval_diff (start->utime, end->utime) / 1000000.0,
2353 timeval_diff (start->stime, end->stime) / 1000000.0);
2354}
cf7f2e2d
JM
2355
2356void
2357mi_cmd_trace_define_variable (char *command, char **argv, int argc)
2358{
2359 struct expression *expr;
cf7f2e2d
JM
2360 LONGEST initval = 0;
2361 struct trace_state_variable *tsv;
2362 char *name = 0;
2363
2364 if (argc != 1 && argc != 2)
2365 error (_("Usage: -trace-define-variable VARIABLE [VALUE]"));
2366
ef5ccd6c
JM
2367 name = argv[0];
2368 if (*name++ != '$')
2369 error (_("Name of trace variable should start with '$'"));
cf7f2e2d 2370
ef5ccd6c 2371 validate_trace_state_variable_name (name);
cf7f2e2d
JM
2372
2373 tsv = find_trace_state_variable (name);
2374 if (!tsv)
2375 tsv = create_trace_state_variable (name);
2376
2377 if (argc == 2)
2378 initval = value_as_long (parse_and_eval (argv[1]));
2379
2380 tsv->initial_value = initval;
cf7f2e2d
JM
2381}
2382
2383void
2384mi_cmd_trace_list_variables (char *command, char **argv, int argc)
2385{
2386 if (argc != 0)
ef5ccd6c 2387 error (_("-trace-list-variables: no arguments allowed"));
cf7f2e2d
JM
2388
2389 tvariables_info_1 ();
2390}
2391
2392void
2393mi_cmd_trace_find (char *command, char **argv, int argc)
2394{
2395 char *mode;
2396
2397 if (argc == 0)
2398 error (_("trace selection mode is required"));
2399
2400 mode = argv[0];
2401
2402 if (strcmp (mode, "none") == 0)
2403 {
2404 tfind_1 (tfind_number, -1, 0, 0, 0);
2405 return;
2406 }
2407
2408 if (current_trace_status ()->running)
2409 error (_("May not look at trace frames while trace is running."));
2410
2411 if (strcmp (mode, "frame-number") == 0)
2412 {
2413 if (argc != 2)
2414 error (_("frame number is required"));
2415 tfind_1 (tfind_number, atoi (argv[1]), 0, 0, 0);
2416 }
2417 else if (strcmp (mode, "tracepoint-number") == 0)
2418 {
2419 if (argc != 2)
2420 error (_("tracepoint number is required"));
2421 tfind_1 (tfind_tp, atoi (argv[1]), 0, 0, 0);
2422 }
2423 else if (strcmp (mode, "pc") == 0)
2424 {
2425 if (argc != 2)
2426 error (_("PC is required"));
2427 tfind_1 (tfind_pc, 0, parse_and_eval_address (argv[1]), 0, 0);
2428 }
2429 else if (strcmp (mode, "pc-inside-range") == 0)
2430 {
2431 if (argc != 3)
2432 error (_("Start and end PC are required"));
2433 tfind_1 (tfind_range, 0, parse_and_eval_address (argv[1]),
2434 parse_and_eval_address (argv[2]), 0);
2435 }
2436 else if (strcmp (mode, "pc-outside-range") == 0)
2437 {
2438 if (argc != 3)
2439 error (_("Start and end PC are required"));
2440 tfind_1 (tfind_outside, 0, parse_and_eval_address (argv[1]),
2441 parse_and_eval_address (argv[2]), 0);
2442 }
2443 else if (strcmp (mode, "line") == 0)
2444 {
2445 struct symtabs_and_lines sals;
2446 struct symtab_and_line sal;
2447 static CORE_ADDR start_pc, end_pc;
2448 struct cleanup *back_to;
2449
2450 if (argc != 2)
2451 error (_("Line is required"));
2452
ef5ccd6c
JM
2453 sals = decode_line_with_current_source (argv[1],
2454 DECODE_LINE_FUNFIRSTLINE);
cf7f2e2d
JM
2455 back_to = make_cleanup (xfree, sals.sals);
2456
2457 sal = sals.sals[0];
2458
2459 if (sal.symtab == 0)
2460 error (_("Could not find the specified line"));
2461
2462 if (sal.line > 0 && find_line_pc_range (sal, &start_pc, &end_pc))
2463 tfind_1 (tfind_range, 0, start_pc, end_pc - 1, 0);
2464 else
2465 error (_("Could not find the specified line"));
2466
2467 do_cleanups (back_to);
2468 }
2469 else
2470 error (_("Invalid mode '%s'"), mode);
2471
2472 if (has_stack_frames () || get_traceframe_number () >= 0)
ef5ccd6c 2473 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
cf7f2e2d
JM
2474}
2475
2476void
2477mi_cmd_trace_save (char *command, char **argv, int argc)
2478{
2479 int target_saves = 0;
2480 char *filename;
2481
2482 if (argc != 1 && argc != 2)
2483 error (_("Usage: -trace-save [-r] filename"));
2484
2485 if (argc == 2)
2486 {
2487 filename = argv[1];
2488 if (strcmp (argv[0], "-r") == 0)
2489 target_saves = 1;
2490 else
2491 error (_("Invalid option: %s"), argv[0]);
2492 }
2493 else
2494 {
2495 filename = argv[0];
2496 }
2497
2498 trace_save (filename, target_saves);
2499}
2500
cf7f2e2d
JM
2501void
2502mi_cmd_trace_start (char *command, char **argv, int argc)
2503{
a45ae5f8 2504 start_tracing (NULL);
cf7f2e2d
JM
2505}
2506
2507void
2508mi_cmd_trace_status (char *command, char **argv, int argc)
2509{
2510 trace_status_mi (0);
2511}
2512
2513void
2514mi_cmd_trace_stop (char *command, char **argv, int argc)
2515{
a45ae5f8 2516 stop_tracing (NULL);
cf7f2e2d
JM
2517 trace_status_mi (1);
2518}
a45ae5f8 2519
ef5ccd6c 2520/* Implement the "-ada-task-info" command. */
a45ae5f8
JM
2521
2522void
2523mi_cmd_ada_task_info (char *command, char **argv, int argc)
2524{
2525 if (argc != 0 && argc != 1)
2526 error (_("Invalid MI command"));
2527
2528 print_ada_task_info (current_uiout, argv[0], current_inferior ());
2529}