3 Copyright (C) 2000-2017 Free Software Foundation, Inc.
5 Contributed by Cygnus Solutions (a Red Hat company).
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 #include "arch-utils.h"
28 #include "gdbthread.h"
31 #include "mi-getopt.h"
32 #include "mi-console.h"
36 #include "event-loop.h"
37 #include "event-top.h"
38 #include "gdbcore.h" /* For write_memory(). */
43 #include "mi-common.h"
48 #include "common/gdb_splay_tree.h"
49 #include "tracepoint.h"
53 #include "extension.h"
56 #include "common/gdb_optional.h"
57 #include "common/byte-vector.h"
60 #include "run-time-clock.h"
62 #include "progspace-and-thread.h"
63 #include "common/rsp-low.h"
74 /* This is used to pass the current command timestamp down to
75 continuation routines. */
76 static struct mi_timestamp
*current_command_ts
;
78 static int do_timings
= 0;
81 /* Few commands would like to know if options like --thread-group were
82 explicitly specified. This variable keeps the current parsed
83 command including all option, and make it possible. */
84 static struct mi_parse
*current_context
;
86 int running_result_record_printed
= 1;
88 /* Flag indicating that the target has proceeded since the last
89 command was issued. */
92 static void mi_cmd_execute (struct mi_parse
*parse
);
94 static void mi_execute_cli_command (const char *cmd
, int args_p
,
96 static void mi_execute_async_cli_command (const char *cli_command
,
97 char **argv
, int argc
);
98 static int register_changed_p (int regnum
, struct regcache
*,
100 static void output_register (struct frame_info
*, int regnum
, int format
,
101 int skip_unavailable
);
103 /* Controls whether the frontend wants MI in async mode. */
104 static int mi_async
= 0;
106 /* The set command writes to this variable. If the inferior is
107 executing, mi_async is *not* updated. */
108 static int mi_async_1
= 0;
111 set_mi_async_command (char *args
, int from_tty
,
112 struct cmd_list_element
*c
)
114 if (have_live_inferiors ())
116 mi_async_1
= mi_async
;
117 error (_("Cannot change this setting while the inferior is running."));
120 mi_async
= mi_async_1
;
124 show_mi_async_command (struct ui_file
*file
, int from_tty
,
125 struct cmd_list_element
*c
,
128 fprintf_filtered (file
,
129 _("Whether MI is in asynchronous mode is %s.\n"),
133 /* A wrapper for target_can_async_p that takes the MI setting into
139 return mi_async
&& target_can_async_p ();
142 /* Command implementations. FIXME: Is this libgdb? No. This is the MI
143 layer that calls libgdb. Any operation used in the below should be
146 static void timestamp (struct mi_timestamp
*tv
);
148 static void print_diff (struct ui_file
*file
, struct mi_timestamp
*start
,
149 struct mi_timestamp
*end
);
152 mi_cmd_gdb_exit (const char *command
, char **argv
, int argc
)
154 struct mi_interp
*mi
= (struct mi_interp
*) current_interpreter ();
156 /* We have to print everything right here because we never return. */
158 fputs_unfiltered (current_token
, mi
->raw_stdout
);
159 fputs_unfiltered ("^exit\n", mi
->raw_stdout
);
160 mi_out_put (current_uiout
, mi
->raw_stdout
);
161 gdb_flush (mi
->raw_stdout
);
162 /* FIXME: The function called is not yet a formal libgdb function. */
163 quit_force (NULL
, FROM_TTY
);
167 mi_cmd_exec_next (const char *command
, char **argv
, int argc
)
169 /* FIXME: Should call a libgdb function, not a cli wrapper. */
170 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
171 mi_execute_async_cli_command ("reverse-next", argv
+ 1, argc
- 1);
173 mi_execute_async_cli_command ("next", argv
, argc
);
177 mi_cmd_exec_next_instruction (const char *command
, char **argv
, int argc
)
179 /* FIXME: Should call a libgdb function, not a cli wrapper. */
180 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
181 mi_execute_async_cli_command ("reverse-nexti", argv
+ 1, argc
- 1);
183 mi_execute_async_cli_command ("nexti", argv
, argc
);
187 mi_cmd_exec_step (const char *command
, char **argv
, int argc
)
189 /* FIXME: Should call a libgdb function, not a cli wrapper. */
190 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
191 mi_execute_async_cli_command ("reverse-step", argv
+ 1, argc
- 1);
193 mi_execute_async_cli_command ("step", argv
, argc
);
197 mi_cmd_exec_step_instruction (const char *command
, char **argv
, int argc
)
199 /* FIXME: Should call a libgdb function, not a cli wrapper. */
200 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
201 mi_execute_async_cli_command ("reverse-stepi", argv
+ 1, argc
- 1);
203 mi_execute_async_cli_command ("stepi", argv
, argc
);
207 mi_cmd_exec_finish (const char *command
, char **argv
, int argc
)
209 /* FIXME: Should call a libgdb function, not a cli wrapper. */
210 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
211 mi_execute_async_cli_command ("reverse-finish", argv
+ 1, argc
- 1);
213 mi_execute_async_cli_command ("finish", argv
, argc
);
217 mi_cmd_exec_return (const char *command
, char **argv
, int argc
)
219 /* This command doesn't really execute the target, it just pops the
220 specified number of frames. */
222 /* Call return_command with from_tty argument equal to 0 so as to
223 avoid being queried. */
224 return_command (*argv
, 0);
226 /* Call return_command with from_tty argument equal to 0 so as to
227 avoid being queried. */
228 return_command (NULL
, 0);
230 /* Because we have called return_command with from_tty = 0, we need
231 to print the frame here. */
232 print_stack_frame (get_selected_frame (NULL
), 1, LOC_AND_ADDRESS
, 1);
236 mi_cmd_exec_jump (const char *args
, char **argv
, int argc
)
238 /* FIXME: Should call a libgdb function, not a cli wrapper. */
239 mi_execute_async_cli_command ("jump", argv
, argc
);
243 proceed_thread (struct thread_info
*thread
, int pid
)
245 if (!is_stopped (thread
->ptid
))
248 if (pid
!= 0 && ptid_get_pid (thread
->ptid
) != pid
)
251 switch_to_thread (thread
->ptid
);
252 clear_proceed_status (0);
253 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
);
257 proceed_thread_callback (struct thread_info
*thread
, void *arg
)
259 int pid
= *(int *)arg
;
261 proceed_thread (thread
, pid
);
266 exec_continue (char **argv
, int argc
)
268 prepare_execution_command (¤t_target
, mi_async_p ());
272 /* In non-stop mode, 'resume' always resumes a single thread.
273 Therefore, to resume all threads of the current inferior, or
274 all threads in all inferiors, we need to iterate over
277 See comment on infcmd.c:proceed_thread_callback for rationale. */
278 if (current_context
->all
|| current_context
->thread_group
!= -1)
280 scoped_restore_current_thread restore_thread
;
283 if (!current_context
->all
)
286 = find_inferior_id (current_context
->thread_group
);
290 iterate_over_threads (proceed_thread_callback
, &pid
);
299 scoped_restore save_multi
= make_scoped_restore (&sched_multi
);
301 if (current_context
->all
)
308 /* In all-stop mode, -exec-continue traditionally resumed
309 either all threads, or one thread, depending on the
310 'scheduler-locking' variable. Let's continue to do the
318 exec_reverse_continue (char **argv
, int argc
)
320 enum exec_direction_kind dir
= execution_direction
;
322 if (dir
== EXEC_REVERSE
)
323 error (_("Already in reverse mode."));
325 if (!target_can_execute_reverse
)
326 error (_("Target %s does not support this command."), target_shortname
);
328 scoped_restore save_exec_dir
= make_scoped_restore (&execution_direction
,
330 exec_continue (argv
, argc
);
334 mi_cmd_exec_continue (const char *command
, char **argv
, int argc
)
336 if (argc
> 0 && strcmp (argv
[0], "--reverse") == 0)
337 exec_reverse_continue (argv
+ 1, argc
- 1);
339 exec_continue (argv
, argc
);
343 interrupt_thread_callback (struct thread_info
*thread
, void *arg
)
345 int pid
= *(int *)arg
;
347 if (!is_running (thread
->ptid
))
350 if (ptid_get_pid (thread
->ptid
) != pid
)
353 target_stop (thread
->ptid
);
357 /* Interrupt the execution of the target. Note how we must play
358 around with the token variables, in order to display the current
359 token in the result of the interrupt command, and the previous
360 execution token when the target finally stops. See comments in
364 mi_cmd_exec_interrupt (const char *command
, char **argv
, int argc
)
366 /* In all-stop mode, everything stops, so we don't need to try
367 anything specific. */
370 interrupt_target_1 (0);
374 if (current_context
->all
)
376 /* This will interrupt all threads in all inferiors. */
377 interrupt_target_1 (1);
379 else if (current_context
->thread_group
!= -1)
381 struct inferior
*inf
= find_inferior_id (current_context
->thread_group
);
383 iterate_over_threads (interrupt_thread_callback
, &inf
->pid
);
387 /* Interrupt just the current thread -- either explicitly
388 specified via --thread or whatever was current before
389 MI command was sent. */
390 interrupt_target_1 (0);
394 /* Callback for iterate_over_inferiors which starts the execution
395 of the given inferior.
397 ARG is a pointer to an integer whose value, if non-zero, indicates
398 that the program should be stopped when reaching the main subprogram
399 (similar to what the CLI "start" command does). */
402 run_one_inferior (struct inferior
*inf
, void *arg
)
404 int start_p
= *(int *) arg
;
405 const char *run_cmd
= start_p
? "start" : "run";
406 struct target_ops
*run_target
= find_run_target ();
407 int async_p
= mi_async
&& run_target
->to_can_async_p (run_target
);
411 if (inf
->pid
!= ptid_get_pid (inferior_ptid
))
413 struct thread_info
*tp
;
415 tp
= any_thread_of_process (inf
->pid
);
417 error (_("Inferior has no threads."));
419 switch_to_thread (tp
->ptid
);
424 set_current_inferior (inf
);
425 switch_to_thread (null_ptid
);
426 set_current_program_space (inf
->pspace
);
428 mi_execute_cli_command (run_cmd
, async_p
,
429 async_p
? "&" : NULL
);
434 mi_cmd_exec_run (const char *command
, char **argv
, int argc
)
438 /* Parse the command options. */
443 static const struct mi_opt opts
[] =
445 {"-start", START_OPT
, 0},
454 int opt
= mi_getopt ("-exec-run", argc
, argv
, opts
, &oind
, &oarg
);
458 switch ((enum opt
) opt
)
466 /* This command does not accept any argument. Make sure the user
467 did not provide any. */
469 error (_("Invalid argument: %s"), argv
[oind
]);
471 if (current_context
->all
)
473 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
475 iterate_over_inferiors (run_one_inferior
, &start_p
);
479 const char *run_cmd
= start_p
? "start" : "run";
480 struct target_ops
*run_target
= find_run_target ();
481 int async_p
= mi_async
&& run_target
->to_can_async_p (run_target
);
483 mi_execute_cli_command (run_cmd
, async_p
,
484 async_p
? "&" : NULL
);
490 find_thread_of_process (struct thread_info
*ti
, void *p
)
494 if (ptid_get_pid (ti
->ptid
) == pid
&& !is_exited (ti
->ptid
))
501 mi_cmd_target_detach (const char *command
, char **argv
, int argc
)
503 if (argc
!= 0 && argc
!= 1)
504 error (_("Usage: -target-detach [pid | thread-group]"));
508 struct thread_info
*tp
;
512 /* First see if we are dealing with a thread-group id. */
515 struct inferior
*inf
;
516 int id
= strtoul (argv
[0] + 1, &end
, 0);
519 error (_("Invalid syntax of thread-group id '%s'"), argv
[0]);
521 inf
= find_inferior_id (id
);
523 error (_("Non-existent thread-group id '%d'"), id
);
529 /* We must be dealing with a pid. */
530 pid
= strtol (argv
[0], &end
, 10);
533 error (_("Invalid identifier '%s'"), argv
[0]);
536 /* Pick any thread in the desired process. Current
537 target_detach detaches from the parent of inferior_ptid. */
538 tp
= iterate_over_threads (find_thread_of_process
, &pid
);
540 error (_("Thread group is empty"));
542 switch_to_thread (tp
->ptid
);
545 detach_command (NULL
, 0);
549 mi_cmd_target_flash_erase (const char *command
, char **argv
, int argc
)
551 flash_erase_command (NULL
, 0);
555 mi_cmd_thread_select (const char *command
, char **argv
, int argc
)
558 error (_("-thread-select: USAGE: threadnum."));
560 int num
= value_as_long (parse_and_eval (argv
[0]));
561 thread_info
*thr
= find_thread_global_id (num
);
563 error (_("Thread ID %d not known."), num
);
565 ptid_t previous_ptid
= inferior_ptid
;
567 thread_select (argv
[0], thr
);
569 print_selected_thread_frame (current_uiout
,
570 USER_SELECTED_THREAD
| USER_SELECTED_FRAME
);
572 /* Notify if the thread has effectively changed. */
573 if (!ptid_equal (inferior_ptid
, previous_ptid
))
575 observer_notify_user_selected_context_changed (USER_SELECTED_THREAD
576 | USER_SELECTED_FRAME
);
581 mi_cmd_thread_list_ids (const char *command
, char **argv
, int argc
)
584 error (_("-thread-list-ids: No arguments required."));
587 int current_thread
= -1;
589 update_thread_list ();
592 ui_out_emit_tuple
tuple_emitter (current_uiout
, "thread-ids");
594 struct thread_info
*tp
;
595 ALL_NON_EXITED_THREADS (tp
)
597 if (tp
->ptid
== inferior_ptid
)
598 current_thread
= tp
->global_num
;
601 current_uiout
->field_int ("thread-id", tp
->global_num
);
605 if (current_thread
!= -1)
606 current_uiout
->field_int ("current-thread-id", current_thread
);
607 current_uiout
->field_int ("number-of-threads", num
);
611 mi_cmd_thread_info (const char *command
, char **argv
, int argc
)
613 if (argc
!= 0 && argc
!= 1)
614 error (_("Invalid MI command"));
616 print_thread_info (current_uiout
, argv
[0], -1);
619 struct collect_cores_data
626 collect_cores (struct thread_info
*ti
, void *xdata
)
628 struct collect_cores_data
*data
= (struct collect_cores_data
*) xdata
;
630 if (ptid_get_pid (ti
->ptid
) == data
->pid
)
632 int core
= target_core_of_thread (ti
->ptid
);
635 data
->cores
.insert (core
);
641 struct print_one_inferior_data
644 const std::set
<int> *inferiors
;
648 print_one_inferior (struct inferior
*inferior
, void *xdata
)
650 struct print_one_inferior_data
*top_data
651 = (struct print_one_inferior_data
*) xdata
;
652 struct ui_out
*uiout
= current_uiout
;
654 if (top_data
->inferiors
->empty ()
655 || (top_data
->inferiors
->find (inferior
->pid
)
656 != top_data
->inferiors
->end ()))
658 struct collect_cores_data data
;
659 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
661 uiout
->field_fmt ("id", "i%d", inferior
->num
);
662 uiout
->field_string ("type", "process");
663 if (inferior
->has_exit_code
)
664 uiout
->field_string ("exit-code",
665 int_string (inferior
->exit_code
, 8, 0, 0, 1));
666 if (inferior
->pid
!= 0)
667 uiout
->field_int ("pid", inferior
->pid
);
669 if (inferior
->pspace
->pspace_exec_filename
!= NULL
)
671 uiout
->field_string ("executable",
672 inferior
->pspace
->pspace_exec_filename
);
675 if (inferior
->pid
!= 0)
677 data
.pid
= inferior
->pid
;
678 iterate_over_threads (collect_cores
, &data
);
681 if (!data
.cores
.empty ())
683 ui_out_emit_list
list_emitter (uiout
, "cores");
685 for (int b
: data
.cores
)
686 uiout
->field_int (NULL
, b
);
689 if (top_data
->recurse
)
690 print_thread_info (uiout
, NULL
, inferior
->pid
);
696 /* Output a field named 'cores' with a list as the value. The
697 elements of the list are obtained by splitting 'cores' on
701 output_cores (struct ui_out
*uiout
, const char *field_name
, const char *xcores
)
703 ui_out_emit_list
list_emitter (uiout
, field_name
);
704 gdb::unique_xmalloc_ptr
<char> cores (xstrdup (xcores
));
705 char *p
= cores
.get ();
707 for (p
= strtok (p
, ","); p
; p
= strtok (NULL
, ","))
708 uiout
->field_string (NULL
, p
);
712 free_vector_of_osdata_items (splay_tree_value xvalue
)
714 VEC (osdata_item_s
) *value
= (VEC (osdata_item_s
) *) xvalue
;
716 /* We don't free the items itself, it will be done separately. */
717 VEC_free (osdata_item_s
, value
);
721 splay_tree_int_comparator (splay_tree_key xa
, splay_tree_key xb
)
730 list_available_thread_groups (const std::set
<int> &ids
, int recurse
)
733 struct osdata_item
*item
;
735 struct ui_out
*uiout
= current_uiout
;
736 struct cleanup
*cleanup
;
738 /* This keeps a map from integer (pid) to VEC (struct osdata_item *)*
739 The vector contains information about all threads for the given pid.
740 This is assigned an initial value to avoid "may be used uninitialized"
742 gdb_splay_tree_up tree
;
744 /* get_osdata will throw if it cannot return data. */
745 data
= get_osdata ("processes");
746 cleanup
= make_cleanup_osdata_free (data
);
750 struct osdata
*threads
= get_osdata ("threads");
752 make_cleanup_osdata_free (threads
);
753 tree
.reset (splay_tree_new (splay_tree_int_comparator
,
755 free_vector_of_osdata_items
));
758 VEC_iterate (osdata_item_s
, threads
->items
,
762 const char *pid
= get_osdata_column (item
, "pid");
763 int pid_i
= strtoul (pid
, NULL
, 0);
764 VEC (osdata_item_s
) *vec
= 0;
766 splay_tree_node n
= splay_tree_lookup (tree
.get (), pid_i
);
769 VEC_safe_push (osdata_item_s
, vec
, item
);
770 splay_tree_insert (tree
.get (), pid_i
, (splay_tree_value
)vec
);
774 vec
= (VEC (osdata_item_s
) *) n
->value
;
775 VEC_safe_push (osdata_item_s
, vec
, item
);
776 n
->value
= (splay_tree_value
) vec
;
781 ui_out_emit_list
list_emitter (uiout
, "groups");
784 VEC_iterate (osdata_item_s
, data
->items
,
788 const char *pid
= get_osdata_column (item
, "pid");
789 const char *cmd
= get_osdata_column (item
, "command");
790 const char *user
= get_osdata_column (item
, "user");
791 const char *cores
= get_osdata_column (item
, "cores");
793 int pid_i
= strtoul (pid
, NULL
, 0);
795 /* At present, the target will return all available processes
796 and if information about specific ones was required, we filter
797 undesired processes here. */
798 if (!ids
.empty () && ids
.find (pid_i
) == ids
.end ())
801 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
803 uiout
->field_fmt ("id", "%s", pid
);
804 uiout
->field_string ("type", "process");
806 uiout
->field_string ("description", cmd
);
808 uiout
->field_string ("user", user
);
810 output_cores (uiout
, "cores", cores
);
814 splay_tree_node n
= splay_tree_lookup (tree
.get (), pid_i
);
817 VEC (osdata_item_s
) *children
= (VEC (osdata_item_s
) *) n
->value
;
818 struct osdata_item
*child
;
821 ui_out_emit_list
thread_list_emitter (uiout
, "threads");
824 VEC_iterate (osdata_item_s
, children
, ix_child
, child
);
827 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
828 const char *tid
= get_osdata_column (child
, "tid");
829 const char *tcore
= get_osdata_column (child
, "core");
831 uiout
->field_string ("id", tid
);
833 uiout
->field_string ("core", tcore
);
839 do_cleanups (cleanup
);
843 mi_cmd_list_thread_groups (const char *command
, char **argv
, int argc
)
845 struct ui_out
*uiout
= current_uiout
;
852 AVAILABLE_OPT
, RECURSE_OPT
854 static const struct mi_opt opts
[] =
856 {"-available", AVAILABLE_OPT
, 0},
857 {"-recurse", RECURSE_OPT
, 1},
866 int opt
= mi_getopt ("-list-thread-groups", argc
, argv
, opts
,
871 switch ((enum opt
) opt
)
877 if (strcmp (oarg
, "0") == 0)
879 else if (strcmp (oarg
, "1") == 0)
882 error (_("only '0' and '1' are valid values "
883 "for the '--recurse' option"));
888 for (; oind
< argc
; ++oind
)
893 if (*(argv
[oind
]) != 'i')
894 error (_("invalid syntax of group id '%s'"), argv
[oind
]);
896 inf
= strtoul (argv
[oind
] + 1, &end
, 0);
899 error (_("invalid syntax of group id '%s'"), argv
[oind
]);
905 list_available_thread_groups (ids
, recurse
);
907 else if (ids
.size () == 1)
909 /* Local thread groups, single id. */
910 int id
= *(ids
.begin ());
911 struct inferior
*inf
= find_inferior_id (id
);
914 error (_("Non-existent thread group id '%d'"), id
);
916 print_thread_info (uiout
, NULL
, inf
->pid
);
920 struct print_one_inferior_data data
;
922 data
.recurse
= recurse
;
923 data
.inferiors
= &ids
;
925 /* Local thread groups. Either no explicit ids -- and we
926 print everything, or several explicit ids. In both cases,
927 we print more than one group, and have to use 'groups'
928 as the top-level element. */
929 ui_out_emit_list
list_emitter (uiout
, "groups");
930 update_thread_list ();
931 iterate_over_inferiors (print_one_inferior
, &data
);
936 mi_cmd_data_list_register_names (const char *command
, char **argv
, int argc
)
938 struct gdbarch
*gdbarch
;
939 struct ui_out
*uiout
= current_uiout
;
943 /* Note that the test for a valid register must include checking the
944 gdbarch_register_name because gdbarch_num_regs may be allocated
945 for the union of the register sets within a family of related
946 processors. In this case, some entries of gdbarch_register_name
947 will change depending upon the particular processor being
950 gdbarch
= get_current_arch ();
951 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
953 ui_out_emit_list
list_emitter (uiout
, "register-names");
955 if (argc
== 0) /* No args, just do all the regs. */
961 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
962 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
963 uiout
->field_string (NULL
, "");
965 uiout
->field_string (NULL
, gdbarch_register_name (gdbarch
, regnum
));
969 /* Else, list of register #s, just do listed regs. */
970 for (i
= 0; i
< argc
; i
++)
972 regnum
= atoi (argv
[i
]);
973 if (regnum
< 0 || regnum
>= numregs
)
974 error (_("bad register number"));
976 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
977 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
978 uiout
->field_string (NULL
, "");
980 uiout
->field_string (NULL
, gdbarch_register_name (gdbarch
, regnum
));
985 mi_cmd_data_list_changed_registers (const char *command
, char **argv
, int argc
)
987 static std::unique_ptr
<struct regcache
> this_regs
;
988 struct ui_out
*uiout
= current_uiout
;
989 std::unique_ptr
<struct regcache
> prev_regs
;
990 struct gdbarch
*gdbarch
;
991 int regnum
, numregs
, changed
;
994 /* The last time we visited this function, the current frame's
995 register contents were saved in THIS_REGS. Move THIS_REGS over
996 to PREV_REGS, and refresh THIS_REGS with the now-current register
999 prev_regs
= std::move (this_regs
);
1000 this_regs
= frame_save_as_regcache (get_selected_frame (NULL
));
1002 /* Note that the test for a valid register must include checking the
1003 gdbarch_register_name because gdbarch_num_regs may be allocated
1004 for the union of the register sets within a family of related
1005 processors. In this case, some entries of gdbarch_register_name
1006 will change depending upon the particular processor being
1009 gdbarch
= get_regcache_arch (this_regs
.get ());
1010 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1012 ui_out_emit_list
list_emitter (uiout
, "changed-registers");
1016 /* No args, just do all the regs. */
1021 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1022 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1024 changed
= register_changed_p (regnum
, prev_regs
.get (),
1027 error (_("-data-list-changed-registers: "
1028 "Unable to read register contents."));
1030 uiout
->field_int (NULL
, regnum
);
1034 /* Else, list of register #s, just do listed regs. */
1035 for (i
= 0; i
< argc
; i
++)
1037 regnum
= atoi (argv
[i
]);
1041 && gdbarch_register_name (gdbarch
, regnum
) != NULL
1042 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
1044 changed
= register_changed_p (regnum
, prev_regs
.get (),
1047 error (_("-data-list-changed-registers: "
1048 "Unable to read register contents."));
1050 uiout
->field_int (NULL
, regnum
);
1053 error (_("bad register number"));
1058 register_changed_p (int regnum
, struct regcache
*prev_regs
,
1059 struct regcache
*this_regs
)
1061 struct gdbarch
*gdbarch
= get_regcache_arch (this_regs
);
1062 struct value
*prev_value
, *this_value
;
1065 /* First time through or after gdbarch change consider all registers
1067 if (!prev_regs
|| get_regcache_arch (prev_regs
) != gdbarch
)
1070 /* Get register contents and compare. */
1071 prev_value
= prev_regs
->cooked_read_value (regnum
);
1072 this_value
= this_regs
->cooked_read_value (regnum
);
1073 gdb_assert (prev_value
!= NULL
);
1074 gdb_assert (this_value
!= NULL
);
1076 ret
= value_contents_eq (prev_value
, 0, this_value
, 0,
1077 register_size (gdbarch
, regnum
)) == 0;
1079 release_value (prev_value
);
1080 release_value (this_value
);
1081 value_free (prev_value
);
1082 value_free (this_value
);
1086 /* Return a list of register number and value pairs. The valid
1087 arguments expected are: a letter indicating the format in which to
1088 display the registers contents. This can be one of: x
1089 (hexadecimal), d (decimal), N (natural), t (binary), o (octal), r
1090 (raw). After the format argument there can be a sequence of
1091 numbers, indicating which registers to fetch the content of. If
1092 the format is the only argument, a list of all the registers with
1093 their values is returned. */
1096 mi_cmd_data_list_register_values (const char *command
, char **argv
, int argc
)
1098 struct ui_out
*uiout
= current_uiout
;
1099 struct frame_info
*frame
;
1100 struct gdbarch
*gdbarch
;
1101 int regnum
, numregs
, format
;
1103 int skip_unavailable
= 0;
1109 static const struct mi_opt opts
[] =
1111 {"-skip-unavailable", SKIP_UNAVAILABLE
, 0},
1115 /* Note that the test for a valid register must include checking the
1116 gdbarch_register_name because gdbarch_num_regs may be allocated
1117 for the union of the register sets within a family of related
1118 processors. In this case, some entries of gdbarch_register_name
1119 will change depending upon the particular processor being
1125 int opt
= mi_getopt ("-data-list-register-values", argc
, argv
,
1126 opts
, &oind
, &oarg
);
1130 switch ((enum opt
) opt
)
1132 case SKIP_UNAVAILABLE
:
1133 skip_unavailable
= 1;
1138 if (argc
- oind
< 1)
1139 error (_("-data-list-register-values: Usage: "
1140 "-data-list-register-values [--skip-unavailable] <format>"
1141 " [<regnum1>...<regnumN>]"));
1143 format
= (int) argv
[oind
][0];
1145 frame
= get_selected_frame (NULL
);
1146 gdbarch
= get_frame_arch (frame
);
1147 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1149 ui_out_emit_list
list_emitter (uiout
, "register-values");
1151 if (argc
- oind
== 1)
1153 /* No args, beside the format: do all the regs. */
1158 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1159 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1162 output_register (frame
, regnum
, format
, skip_unavailable
);
1166 /* Else, list of register #s, just do listed regs. */
1167 for (i
= 1 + oind
; i
< argc
; i
++)
1169 regnum
= atoi (argv
[i
]);
1173 && gdbarch_register_name (gdbarch
, regnum
) != NULL
1174 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
1175 output_register (frame
, regnum
, format
, skip_unavailable
);
1177 error (_("bad register number"));
1181 /* Output one register REGNUM's contents in the desired FORMAT. If
1182 SKIP_UNAVAILABLE is true, skip the register if it is
1186 output_register (struct frame_info
*frame
, int regnum
, int format
,
1187 int skip_unavailable
)
1189 struct ui_out
*uiout
= current_uiout
;
1190 struct value
*val
= value_of_register (regnum
, frame
);
1191 struct value_print_options opts
;
1193 if (skip_unavailable
&& !value_entirely_available (val
))
1196 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1197 uiout
->field_int ("number", regnum
);
1207 get_formatted_print_options (&opts
, format
);
1209 val_print (value_type (val
),
1210 value_embedded_offset (val
), 0,
1211 &stb
, 0, val
, &opts
, current_language
);
1212 uiout
->field_stream ("value", stb
);
1215 /* Write given values into registers. The registers and values are
1216 given as pairs. The corresponding MI command is
1217 -data-write-register-values <format>
1218 [<regnum1> <value1>...<regnumN> <valueN>] */
1220 mi_cmd_data_write_register_values (const char *command
, char **argv
, int argc
)
1222 struct regcache
*regcache
;
1223 struct gdbarch
*gdbarch
;
1226 /* Note that the test for a valid register must include checking the
1227 gdbarch_register_name because gdbarch_num_regs may be allocated
1228 for the union of the register sets within a family of related
1229 processors. In this case, some entries of gdbarch_register_name
1230 will change depending upon the particular processor being
1233 regcache
= get_current_regcache ();
1234 gdbarch
= get_regcache_arch (regcache
);
1235 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1238 error (_("-data-write-register-values: Usage: -data-write-register-"
1239 "values <format> [<regnum1> <value1>...<regnumN> <valueN>]"));
1241 if (!target_has_registers
)
1242 error (_("-data-write-register-values: No registers."));
1245 error (_("-data-write-register-values: No regs and values specified."));
1248 error (_("-data-write-register-values: "
1249 "Regs and vals are not in pairs."));
1251 for (i
= 1; i
< argc
; i
= i
+ 2)
1253 int regnum
= atoi (argv
[i
]);
1255 if (regnum
>= 0 && regnum
< numregs
1256 && gdbarch_register_name (gdbarch
, regnum
)
1257 && *gdbarch_register_name (gdbarch
, regnum
))
1261 /* Get the value as a number. */
1262 value
= parse_and_eval_address (argv
[i
+ 1]);
1264 /* Write it down. */
1265 regcache_cooked_write_signed (regcache
, regnum
, value
);
1268 error (_("bad register number"));
1272 /* Evaluate the value of the argument. The argument is an
1273 expression. If the expression contains spaces it needs to be
1274 included in double quotes. */
1277 mi_cmd_data_evaluate_expression (const char *command
, char **argv
, int argc
)
1280 struct value_print_options opts
;
1281 struct ui_out
*uiout
= current_uiout
;
1284 error (_("-data-evaluate-expression: "
1285 "Usage: -data-evaluate-expression expression"));
1287 expression_up expr
= parse_expression (argv
[0]);
1289 val
= evaluate_expression (expr
.get ());
1293 /* Print the result of the expression evaluation. */
1294 get_user_print_options (&opts
);
1296 common_val_print (val
, &stb
, 0, &opts
, current_language
);
1298 uiout
->field_stream ("value", stb
);
1301 /* This is the -data-read-memory command.
1303 ADDR: start address of data to be dumped.
1304 WORD-FORMAT: a char indicating format for the ``word''. See
1306 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes.
1307 NR_ROW: Number of rows.
1308 NR_COL: The number of colums (words per row).
1309 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
1310 ASCHAR for unprintable characters.
1312 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
1313 displayes them. Returns:
1315 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
1318 The number of bytes read is SIZE*ROW*COL. */
1321 mi_cmd_data_read_memory (const char *command
, char **argv
, int argc
)
1323 struct gdbarch
*gdbarch
= get_current_arch ();
1324 struct ui_out
*uiout
= current_uiout
;
1326 long total_bytes
, nr_cols
, nr_rows
;
1328 struct type
*word_type
;
1340 static const struct mi_opt opts
[] =
1342 {"o", OFFSET_OPT
, 1},
1348 int opt
= mi_getopt ("-data-read-memory", argc
, argv
, opts
,
1353 switch ((enum opt
) opt
)
1356 offset
= atol (oarg
);
1363 if (argc
< 5 || argc
> 6)
1364 error (_("-data-read-memory: Usage: "
1365 "ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR]."));
1367 /* Extract all the arguments. */
1369 /* Start address of the memory dump. */
1370 addr
= parse_and_eval_address (argv
[0]) + offset
;
1371 /* The format character to use when displaying a memory word. See
1372 the ``x'' command. */
1373 word_format
= argv
[1][0];
1374 /* The size of the memory word. */
1375 word_size
= atol (argv
[2]);
1379 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1383 word_type
= builtin_type (gdbarch
)->builtin_int16
;
1387 word_type
= builtin_type (gdbarch
)->builtin_int32
;
1391 word_type
= builtin_type (gdbarch
)->builtin_int64
;
1395 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1398 /* The number of rows. */
1399 nr_rows
= atol (argv
[3]);
1401 error (_("-data-read-memory: invalid number of rows."));
1403 /* Number of bytes per row. */
1404 nr_cols
= atol (argv
[4]);
1406 error (_("-data-read-memory: invalid number of columns."));
1408 /* The un-printable character when printing ascii. */
1414 /* Create a buffer and read it in. */
1415 total_bytes
= word_size
* nr_rows
* nr_cols
;
1417 gdb::byte_vector
mbuf (total_bytes
);
1419 /* Dispatch memory reads to the topmost target, not the flattened
1421 nr_bytes
= target_read (current_target
.beneath
,
1422 TARGET_OBJECT_MEMORY
, NULL
, mbuf
.data (),
1425 error (_("Unable to read memory."));
1427 /* Output the header information. */
1428 uiout
->field_core_addr ("addr", gdbarch
, addr
);
1429 uiout
->field_int ("nr-bytes", nr_bytes
);
1430 uiout
->field_int ("total-bytes", total_bytes
);
1431 uiout
->field_core_addr ("next-row", gdbarch
, addr
+ word_size
* nr_cols
);
1432 uiout
->field_core_addr ("prev-row", gdbarch
, addr
- word_size
* nr_cols
);
1433 uiout
->field_core_addr ("next-page", gdbarch
, addr
+ total_bytes
);
1434 uiout
->field_core_addr ("prev-page", gdbarch
, addr
- total_bytes
);
1436 /* Build the result as a two dimentional table. */
1443 ui_out_emit_list
list_emitter (uiout
, "memory");
1444 for (row
= 0, row_byte
= 0;
1446 row
++, row_byte
+= nr_cols
* word_size
)
1450 struct value_print_options opts
;
1452 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1453 uiout
->field_core_addr ("addr", gdbarch
, addr
+ row_byte
);
1454 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr +
1457 ui_out_emit_list
list_data_emitter (uiout
, "data");
1458 get_formatted_print_options (&opts
, word_format
);
1459 for (col
= 0, col_byte
= row_byte
;
1461 col
++, col_byte
+= word_size
)
1463 if (col_byte
+ word_size
> nr_bytes
)
1465 uiout
->field_string (NULL
, "N/A");
1470 print_scalar_formatted (&mbuf
[col_byte
], word_type
, &opts
,
1471 word_asize
, &stream
);
1472 uiout
->field_stream (NULL
, stream
);
1482 for (byte
= row_byte
;
1483 byte
< row_byte
+ word_size
* nr_cols
; byte
++)
1485 if (byte
>= nr_bytes
)
1487 else if (mbuf
[byte
] < 32 || mbuf
[byte
] > 126)
1488 stream
.putc (aschar
);
1490 stream
.putc (mbuf
[byte
]);
1492 uiout
->field_stream ("ascii", stream
);
1499 mi_cmd_data_read_memory_bytes (const char *command
, char **argv
, int argc
)
1501 struct gdbarch
*gdbarch
= get_current_arch ();
1502 struct ui_out
*uiout
= current_uiout
;
1506 int unit_size
= gdbarch_addressable_memory_unit_size (gdbarch
);
1513 static const struct mi_opt opts
[] =
1515 {"o", OFFSET_OPT
, 1},
1521 int opt
= mi_getopt ("-data-read-memory-bytes", argc
, argv
, opts
,
1525 switch ((enum opt
) opt
)
1528 offset
= atol (oarg
);
1536 error (_("Usage: [ -o OFFSET ] ADDR LENGTH."));
1538 addr
= parse_and_eval_address (argv
[0]) + offset
;
1539 length
= atol (argv
[1]);
1541 std::vector
<memory_read_result
> result
1542 = read_memory_robust (current_target
.beneath
, addr
, length
);
1544 if (result
.size () == 0)
1545 error (_("Unable to read memory."));
1547 ui_out_emit_list
list_emitter (uiout
, "memory");
1548 for (const memory_read_result
&read_result
: result
)
1550 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1552 uiout
->field_core_addr ("begin", gdbarch
, read_result
.begin
);
1553 uiout
->field_core_addr ("offset", gdbarch
, read_result
.begin
- addr
);
1554 uiout
->field_core_addr ("end", gdbarch
, read_result
.end
);
1556 std::string data
= bin2hex (read_result
.data
.get (),
1557 (read_result
.end
- read_result
.begin
)
1559 uiout
->field_string ("contents", data
.c_str ());
1563 /* Implementation of the -data-write_memory command.
1565 COLUMN_OFFSET: optional argument. Must be preceded by '-o'. The
1566 offset from the beginning of the memory grid row where the cell to
1568 ADDR: start address of the row in the memory grid where the memory
1569 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
1570 the location to write to.
1571 FORMAT: a char indicating format for the ``word''. See
1573 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
1574 VALUE: value to be written into the memory address.
1576 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
1581 mi_cmd_data_write_memory (const char *command
, char **argv
, int argc
)
1583 struct gdbarch
*gdbarch
= get_current_arch ();
1584 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1587 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
1588 enough when using a compiler other than GCC. */
1597 static const struct mi_opt opts
[] =
1599 {"o", OFFSET_OPT
, 1},
1605 int opt
= mi_getopt ("-data-write-memory", argc
, argv
, opts
,
1610 switch ((enum opt
) opt
)
1613 offset
= atol (oarg
);
1621 error (_("-data-write-memory: Usage: "
1622 "[-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE."));
1624 /* Extract all the arguments. */
1625 /* Start address of the memory dump. */
1626 addr
= parse_and_eval_address (argv
[0]);
1627 /* The size of the memory word. */
1628 word_size
= atol (argv
[2]);
1630 /* Calculate the real address of the write destination. */
1631 addr
+= (offset
* word_size
);
1633 /* Get the value as a number. */
1634 value
= parse_and_eval_address (argv
[3]);
1635 /* Get the value into an array. */
1636 gdb::byte_vector
buffer (word_size
);
1637 store_signed_integer (buffer
.data (), word_size
, byte_order
, value
);
1638 /* Write it down to memory. */
1639 write_memory_with_notification (addr
, buffer
.data (), word_size
);
1642 /* Implementation of the -data-write-memory-bytes command.
1645 DATA: string of bytes to write at that address
1646 COUNT: number of bytes to be filled (decimal integer). */
1649 mi_cmd_data_write_memory_bytes (const char *command
, char **argv
, int argc
)
1653 size_t len_hex
, len_bytes
, len_units
, i
, steps
, remaining_units
;
1654 long int count_units
;
1657 if (argc
!= 2 && argc
!= 3)
1658 error (_("Usage: ADDR DATA [COUNT]."));
1660 addr
= parse_and_eval_address (argv
[0]);
1662 len_hex
= strlen (cdata
);
1663 unit_size
= gdbarch_addressable_memory_unit_size (get_current_arch ());
1665 if (len_hex
% (unit_size
* 2) != 0)
1666 error (_("Hex-encoded '%s' must represent an integral number of "
1667 "addressable memory units."),
1670 len_bytes
= len_hex
/ 2;
1671 len_units
= len_bytes
/ unit_size
;
1674 count_units
= strtoul (argv
[2], NULL
, 10);
1676 count_units
= len_units
;
1678 gdb::byte_vector
databuf (len_bytes
);
1680 for (i
= 0; i
< len_bytes
; ++i
)
1683 if (sscanf (cdata
+ i
* 2, "%02x", &x
) != 1)
1684 error (_("Invalid argument"));
1685 databuf
[i
] = (gdb_byte
) x
;
1688 gdb::byte_vector data
;
1689 if (len_units
< count_units
)
1691 /* Pattern is made of less units than count:
1692 repeat pattern to fill memory. */
1693 data
= gdb::byte_vector (count_units
* unit_size
);
1695 /* Number of times the pattern is entirely repeated. */
1696 steps
= count_units
/ len_units
;
1697 /* Number of remaining addressable memory units. */
1698 remaining_units
= count_units
% len_units
;
1699 for (i
= 0; i
< steps
; i
++)
1700 memcpy (&data
[i
* len_bytes
], &databuf
[0], len_bytes
);
1702 if (remaining_units
> 0)
1703 memcpy (&data
[steps
* len_bytes
], &databuf
[0],
1704 remaining_units
* unit_size
);
1708 /* Pattern is longer than or equal to count:
1709 just copy count addressable memory units. */
1710 data
= std::move (databuf
);
1713 write_memory_with_notification (addr
, data
.data (), count_units
);
1717 mi_cmd_enable_timings (const char *command
, char **argv
, int argc
)
1723 if (strcmp (argv
[0], "yes") == 0)
1725 else if (strcmp (argv
[0], "no") == 0)
1736 error (_("-enable-timings: Usage: %s {yes|no}"), command
);
1740 mi_cmd_list_features (const char *command
, char **argv
, int argc
)
1744 struct ui_out
*uiout
= current_uiout
;
1746 ui_out_emit_list
list_emitter (uiout
, "features");
1747 uiout
->field_string (NULL
, "frozen-varobjs");
1748 uiout
->field_string (NULL
, "pending-breakpoints");
1749 uiout
->field_string (NULL
, "thread-info");
1750 uiout
->field_string (NULL
, "data-read-memory-bytes");
1751 uiout
->field_string (NULL
, "breakpoint-notifications");
1752 uiout
->field_string (NULL
, "ada-task-info");
1753 uiout
->field_string (NULL
, "language-option");
1754 uiout
->field_string (NULL
, "info-gdb-mi-command");
1755 uiout
->field_string (NULL
, "undefined-command-error-code");
1756 uiout
->field_string (NULL
, "exec-run-start-option");
1758 if (ext_lang_initialized_p (get_ext_lang_defn (EXT_LANG_PYTHON
)))
1759 uiout
->field_string (NULL
, "python");
1764 error (_("-list-features should be passed no arguments"));
1768 mi_cmd_list_target_features (const char *command
, char **argv
, int argc
)
1772 struct ui_out
*uiout
= current_uiout
;
1774 ui_out_emit_list
list_emitter (uiout
, "features");
1776 uiout
->field_string (NULL
, "async");
1777 if (target_can_execute_reverse
)
1778 uiout
->field_string (NULL
, "reverse");
1782 error (_("-list-target-features should be passed no arguments"));
1786 mi_cmd_add_inferior (const char *command
, char **argv
, int argc
)
1788 struct inferior
*inf
;
1791 error (_("-add-inferior should be passed no arguments"));
1793 inf
= add_inferior_with_spaces ();
1795 current_uiout
->field_fmt ("inferior", "i%d", inf
->num
);
1798 /* Callback used to find the first inferior other than the current
1802 get_other_inferior (struct inferior
*inf
, void *arg
)
1804 if (inf
== current_inferior ())
1811 mi_cmd_remove_inferior (const char *command
, char **argv
, int argc
)
1814 struct inferior
*inf
;
1817 error (_("-remove-inferior should be passed a single argument"));
1819 if (sscanf (argv
[0], "i%d", &id
) != 1)
1820 error (_("the thread group id is syntactically invalid"));
1822 inf
= find_inferior_id (id
);
1824 error (_("the specified thread group does not exist"));
1827 error (_("cannot remove an active inferior"));
1829 if (inf
== current_inferior ())
1831 struct thread_info
*tp
= 0;
1832 struct inferior
*new_inferior
1833 = iterate_over_inferiors (get_other_inferior
, NULL
);
1835 if (new_inferior
== NULL
)
1836 error (_("Cannot remove last inferior"));
1838 set_current_inferior (new_inferior
);
1839 if (new_inferior
->pid
!= 0)
1840 tp
= any_thread_of_process (new_inferior
->pid
);
1841 switch_to_thread (tp
? tp
->ptid
: null_ptid
);
1842 set_current_program_space (new_inferior
->pspace
);
1845 delete_inferior (inf
);
1850 /* Execute a command within a safe environment.
1851 Return <0 for error; >=0 for ok.
1853 args->action will tell mi_execute_command what action
1854 to perform after the given command has executed (display/suppress
1855 prompt, display error). */
1858 captured_mi_execute_command (struct ui_out
*uiout
, struct mi_parse
*context
)
1860 struct mi_interp
*mi
= (struct mi_interp
*) command_interp ();
1863 current_command_ts
= context
->cmd_start
;
1865 scoped_restore save_token
= make_scoped_restore (¤t_token
,
1868 running_result_record_printed
= 0;
1870 switch (context
->op
)
1873 /* A MI command was read from the input stream. */
1875 /* FIXME: gdb_???? */
1876 fprintf_unfiltered (mi
->raw_stdout
,
1877 " token=`%s' command=`%s' args=`%s'\n",
1878 context
->token
, context
->command
, context
->args
);
1880 mi_cmd_execute (context
);
1882 /* Print the result if there were no errors.
1884 Remember that on the way out of executing a command, you have
1885 to directly use the mi_interp's uiout, since the command
1886 could have reset the interpreter, in which case the current
1887 uiout will most likely crash in the mi_out_* routines. */
1888 if (!running_result_record_printed
)
1890 fputs_unfiltered (context
->token
, mi
->raw_stdout
);
1891 /* There's no particularly good reason why target-connect results
1892 in not ^done. Should kill ^connected for MI3. */
1893 fputs_unfiltered (strcmp (context
->command
, "target-select") == 0
1894 ? "^connected" : "^done", mi
->raw_stdout
);
1895 mi_out_put (uiout
, mi
->raw_stdout
);
1896 mi_out_rewind (uiout
);
1897 mi_print_timing_maybe (mi
->raw_stdout
);
1898 fputs_unfiltered ("\n", mi
->raw_stdout
);
1901 /* The command does not want anything to be printed. In that
1902 case, the command probably should not have written anything
1903 to uiout, but in case it has written something, discard it. */
1904 mi_out_rewind (uiout
);
1911 /* A CLI command was read from the input stream. */
1912 /* This "feature" will be removed as soon as we have a
1913 complete set of mi commands. */
1914 /* Echo the command on the console. */
1915 fprintf_unfiltered (gdb_stdlog
, "%s\n", context
->command
);
1916 /* Call the "console" interpreter. */
1917 argv
[0] = (char *) INTERP_CONSOLE
;
1918 argv
[1] = context
->command
;
1919 mi_cmd_interpreter_exec ("-interpreter-exec", argv
, 2);
1921 /* If we changed interpreters, DON'T print out anything. */
1922 if (current_interp_named_p (INTERP_MI
)
1923 || current_interp_named_p (INTERP_MI1
)
1924 || current_interp_named_p (INTERP_MI2
)
1925 || current_interp_named_p (INTERP_MI3
))
1927 if (!running_result_record_printed
)
1929 fputs_unfiltered (context
->token
, mi
->raw_stdout
);
1930 fputs_unfiltered ("^done", mi
->raw_stdout
);
1931 mi_out_put (uiout
, mi
->raw_stdout
);
1932 mi_out_rewind (uiout
);
1933 mi_print_timing_maybe (mi
->raw_stdout
);
1934 fputs_unfiltered ("\n", mi
->raw_stdout
);
1937 mi_out_rewind (uiout
);
1944 /* Print a gdb exception to the MI output stream. */
1947 mi_print_exception (const char *token
, struct gdb_exception exception
)
1949 struct mi_interp
*mi
= (struct mi_interp
*) current_interpreter ();
1951 fputs_unfiltered (token
, mi
->raw_stdout
);
1952 fputs_unfiltered ("^error,msg=\"", mi
->raw_stdout
);
1953 if (exception
.message
== NULL
)
1954 fputs_unfiltered ("unknown error", mi
->raw_stdout
);
1956 fputstr_unfiltered (exception
.message
, '"', mi
->raw_stdout
);
1957 fputs_unfiltered ("\"", mi
->raw_stdout
);
1959 switch (exception
.error
)
1961 case UNDEFINED_COMMAND_ERROR
:
1962 fputs_unfiltered (",code=\"undefined-command\"", mi
->raw_stdout
);
1966 fputs_unfiltered ("\n", mi
->raw_stdout
);
1969 /* Determine whether the parsed command already notifies the
1970 user_selected_context_changed observer. */
1973 command_notifies_uscc_observer (struct mi_parse
*command
)
1975 if (command
->op
== CLI_COMMAND
)
1977 /* CLI commands "thread" and "inferior" already send it. */
1978 return (strncmp (command
->command
, "thread ", 7) == 0
1979 || strncmp (command
->command
, "inferior ", 9) == 0);
1981 else /* MI_COMMAND */
1983 if (strcmp (command
->command
, "interpreter-exec") == 0
1984 && command
->argc
> 1)
1986 /* "thread" and "inferior" again, but through -interpreter-exec. */
1987 return (strncmp (command
->argv
[1], "thread ", 7) == 0
1988 || strncmp (command
->argv
[1], "inferior ", 9) == 0);
1992 /* -thread-select already sends it. */
1993 return strcmp (command
->command
, "thread-select") == 0;
1998 mi_execute_command (const char *cmd
, int from_tty
)
2001 std::unique_ptr
<struct mi_parse
> command
;
2003 /* This is to handle EOF (^D). We just quit gdb. */
2004 /* FIXME: we should call some API function here. */
2006 quit_force (NULL
, from_tty
);
2008 target_log_command (cmd
);
2012 command
= mi_parse (cmd
, &token
);
2014 CATCH (exception
, RETURN_MASK_ALL
)
2016 mi_print_exception (token
, exception
);
2021 if (command
!= NULL
)
2023 ptid_t previous_ptid
= inferior_ptid
;
2025 gdb::optional
<scoped_restore_tmpl
<int>> restore_suppress
;
2027 if (command
->cmd
!= NULL
&& command
->cmd
->suppress_notification
!= NULL
)
2028 restore_suppress
.emplace (command
->cmd
->suppress_notification
, 1);
2030 command
->token
= token
;
2034 command
->cmd_start
= new mi_timestamp ();
2035 timestamp (command
->cmd_start
);
2040 captured_mi_execute_command (current_uiout
, command
.get ());
2042 CATCH (result
, RETURN_MASK_ALL
)
2044 /* Like in start_event_loop, enable input and force display
2045 of the prompt. Otherwise, any command that calls
2046 async_disable_stdin, and then throws, will leave input
2048 async_enable_stdin ();
2049 current_ui
->prompt_state
= PROMPT_NEEDED
;
2051 /* The command execution failed and error() was called
2053 mi_print_exception (command
->token
, result
);
2054 mi_out_rewind (current_uiout
);
2058 bpstat_do_actions ();
2060 if (/* The notifications are only output when the top-level
2061 interpreter (specified on the command line) is MI. */
2062 interp_ui_out (top_level_interpreter ())->is_mi_like_p ()
2063 /* Don't try report anything if there are no threads --
2064 the program is dead. */
2065 && thread_count () != 0
2066 /* If the command already reports the thread change, no need to do it
2068 && !command_notifies_uscc_observer (command
.get ()))
2070 struct mi_interp
*mi
= (struct mi_interp
*) top_level_interpreter ();
2071 int report_change
= 0;
2073 if (command
->thread
== -1)
2075 report_change
= (!ptid_equal (previous_ptid
, null_ptid
)
2076 && !ptid_equal (inferior_ptid
, previous_ptid
)
2077 && !ptid_equal (inferior_ptid
, null_ptid
));
2079 else if (!ptid_equal (inferior_ptid
, null_ptid
))
2081 struct thread_info
*ti
= inferior_thread ();
2083 report_change
= (ti
->global_num
!= command
->thread
);
2088 observer_notify_user_selected_context_changed
2089 (USER_SELECTED_THREAD
| USER_SELECTED_FRAME
);
2096 mi_cmd_execute (struct mi_parse
*parse
)
2098 struct cleanup
*cleanup
;
2100 cleanup
= prepare_execute_command ();
2102 if (parse
->all
&& parse
->thread_group
!= -1)
2103 error (_("Cannot specify --thread-group together with --all"));
2105 if (parse
->all
&& parse
->thread
!= -1)
2106 error (_("Cannot specify --thread together with --all"));
2108 if (parse
->thread_group
!= -1 && parse
->thread
!= -1)
2109 error (_("Cannot specify --thread together with --thread-group"));
2111 if (parse
->frame
!= -1 && parse
->thread
== -1)
2112 error (_("Cannot specify --frame without --thread"));
2114 if (parse
->thread_group
!= -1)
2116 struct inferior
*inf
= find_inferior_id (parse
->thread_group
);
2117 struct thread_info
*tp
= 0;
2120 error (_("Invalid thread group for the --thread-group option"));
2122 set_current_inferior (inf
);
2123 /* This behaviour means that if --thread-group option identifies
2124 an inferior with multiple threads, then a random one will be
2125 picked. This is not a problem -- frontend should always
2126 provide --thread if it wishes to operate on a specific
2129 tp
= any_live_thread_of_process (inf
->pid
);
2130 switch_to_thread (tp
? tp
->ptid
: null_ptid
);
2131 set_current_program_space (inf
->pspace
);
2134 if (parse
->thread
!= -1)
2136 struct thread_info
*tp
= find_thread_global_id (parse
->thread
);
2139 error (_("Invalid thread id: %d"), parse
->thread
);
2141 if (is_exited (tp
->ptid
))
2142 error (_("Thread id: %d has terminated"), parse
->thread
);
2144 switch_to_thread (tp
->ptid
);
2147 if (parse
->frame
!= -1)
2149 struct frame_info
*fid
;
2150 int frame
= parse
->frame
;
2152 fid
= find_relative_frame (get_current_frame (), &frame
);
2154 /* find_relative_frame was successful */
2157 error (_("Invalid frame id: %d"), frame
);
2160 gdb::optional
<scoped_restore_current_language
> lang_saver
;
2161 if (parse
->language
!= language_unknown
)
2163 lang_saver
.emplace ();
2164 set_language (parse
->language
);
2167 current_context
= parse
;
2169 if (parse
->cmd
->argv_func
!= NULL
)
2171 parse
->cmd
->argv_func (parse
->command
, parse
->argv
, parse
->argc
);
2173 else if (parse
->cmd
->cli
.cmd
!= 0)
2175 /* FIXME: DELETE THIS. */
2176 /* The operation is still implemented by a cli command. */
2177 /* Must be a synchronous one. */
2178 mi_execute_cli_command (parse
->cmd
->cli
.cmd
, parse
->cmd
->cli
.args_p
,
2183 /* FIXME: DELETE THIS. */
2186 stb
.puts ("Undefined mi command: ");
2187 stb
.putstr (parse
->command
, '"');
2188 stb
.puts (" (missing implementation)");
2192 do_cleanups (cleanup
);
2195 /* FIXME: This is just a hack so we can get some extra commands going.
2196 We don't want to channel things through the CLI, but call libgdb directly.
2197 Use only for synchronous commands. */
2200 mi_execute_cli_command (const char *cmd
, int args_p
, const char *args
)
2204 std::string run
= cmd
;
2207 run
= run
+ " " + args
;
2209 /* FIXME: gdb_???? */
2210 fprintf_unfiltered (gdb_stdout
, "cli=%s run=%s\n",
2212 execute_command (&run
[0], 0 /* from_tty */ );
2217 mi_execute_async_cli_command (const char *cli_command
, char **argv
, int argc
)
2219 std::string run
= cli_command
;
2222 run
= run
+ " " + *argv
;
2226 execute_command (&run
[0], 0 /* from_tty */ );
2230 mi_load_progress (const char *section_name
,
2231 unsigned long sent_so_far
,
2232 unsigned long total_section
,
2233 unsigned long total_sent
,
2234 unsigned long grand_total
)
2236 using namespace std::chrono
;
2237 static steady_clock::time_point last_update
;
2238 static char *previous_sect_name
= NULL
;
2240 struct mi_interp
*mi
= (struct mi_interp
*) current_interpreter ();
2242 /* This function is called through deprecated_show_load_progress
2243 which means uiout may not be correct. Fix it for the duration
2244 of this function. */
2246 std::unique_ptr
<ui_out
> uiout
;
2248 if (current_interp_named_p (INTERP_MI
)
2249 || current_interp_named_p (INTERP_MI2
))
2250 uiout
.reset (mi_out_new (2));
2251 else if (current_interp_named_p (INTERP_MI1
))
2252 uiout
.reset (mi_out_new (1));
2253 else if (current_interp_named_p (INTERP_MI3
))
2254 uiout
.reset (mi_out_new (3));
2258 scoped_restore save_uiout
2259 = make_scoped_restore (¤t_uiout
, uiout
.get ());
2261 new_section
= (previous_sect_name
?
2262 strcmp (previous_sect_name
, section_name
) : 1);
2265 xfree (previous_sect_name
);
2266 previous_sect_name
= xstrdup (section_name
);
2269 fputs_unfiltered (current_token
, mi
->raw_stdout
);
2270 fputs_unfiltered ("+download", mi
->raw_stdout
);
2272 ui_out_emit_tuple
tuple_emitter (uiout
.get (), NULL
);
2273 uiout
->field_string ("section", section_name
);
2274 uiout
->field_int ("section-size", total_section
);
2275 uiout
->field_int ("total-size", grand_total
);
2277 mi_out_put (uiout
.get (), mi
->raw_stdout
);
2278 fputs_unfiltered ("\n", mi
->raw_stdout
);
2279 gdb_flush (mi
->raw_stdout
);
2282 steady_clock::time_point time_now
= steady_clock::now ();
2283 if (time_now
- last_update
> milliseconds (500))
2285 last_update
= time_now
;
2287 fputs_unfiltered (current_token
, mi
->raw_stdout
);
2288 fputs_unfiltered ("+download", mi
->raw_stdout
);
2290 ui_out_emit_tuple
tuple_emitter (uiout
.get (), NULL
);
2291 uiout
->field_string ("section", section_name
);
2292 uiout
->field_int ("section-sent", sent_so_far
);
2293 uiout
->field_int ("section-size", total_section
);
2294 uiout
->field_int ("total-sent", total_sent
);
2295 uiout
->field_int ("total-size", grand_total
);
2297 mi_out_put (uiout
.get (), mi
->raw_stdout
);
2298 fputs_unfiltered ("\n", mi
->raw_stdout
);
2299 gdb_flush (mi
->raw_stdout
);
2304 timestamp (struct mi_timestamp
*tv
)
2306 using namespace std::chrono
;
2308 tv
->wallclock
= steady_clock::now ();
2309 run_time_clock::now (tv
->utime
, tv
->stime
);
2313 print_diff_now (struct ui_file
*file
, struct mi_timestamp
*start
)
2315 struct mi_timestamp now
;
2318 print_diff (file
, start
, &now
);
2322 mi_print_timing_maybe (struct ui_file
*file
)
2324 /* If the command is -enable-timing then do_timings may be true
2325 whilst current_command_ts is not initialized. */
2326 if (do_timings
&& current_command_ts
)
2327 print_diff_now (file
, current_command_ts
);
2331 print_diff (struct ui_file
*file
, struct mi_timestamp
*start
,
2332 struct mi_timestamp
*end
)
2334 using namespace std::chrono
;
2336 duration
<double> wallclock
= end
->wallclock
- start
->wallclock
;
2337 duration
<double> utime
= end
->utime
- start
->utime
;
2338 duration
<double> stime
= end
->stime
- start
->stime
;
2342 ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
2343 wallclock
.count (), utime
.count (), stime
.count ());
2347 mi_cmd_trace_define_variable (const char *command
, char **argv
, int argc
)
2349 LONGEST initval
= 0;
2350 struct trace_state_variable
*tsv
;
2353 if (argc
!= 1 && argc
!= 2)
2354 error (_("Usage: -trace-define-variable VARIABLE [VALUE]"));
2358 error (_("Name of trace variable should start with '$'"));
2360 validate_trace_state_variable_name (name
);
2362 tsv
= find_trace_state_variable (name
);
2364 tsv
= create_trace_state_variable (name
);
2367 initval
= value_as_long (parse_and_eval (argv
[1]));
2369 tsv
->initial_value
= initval
;
2373 mi_cmd_trace_list_variables (const char *command
, char **argv
, int argc
)
2376 error (_("-trace-list-variables: no arguments allowed"));
2378 tvariables_info_1 ();
2382 mi_cmd_trace_find (const char *command
, char **argv
, int argc
)
2387 error (_("trace selection mode is required"));
2391 if (strcmp (mode
, "none") == 0)
2393 tfind_1 (tfind_number
, -1, 0, 0, 0);
2397 check_trace_running (current_trace_status ());
2399 if (strcmp (mode
, "frame-number") == 0)
2402 error (_("frame number is required"));
2403 tfind_1 (tfind_number
, atoi (argv
[1]), 0, 0, 0);
2405 else if (strcmp (mode
, "tracepoint-number") == 0)
2408 error (_("tracepoint number is required"));
2409 tfind_1 (tfind_tp
, atoi (argv
[1]), 0, 0, 0);
2411 else if (strcmp (mode
, "pc") == 0)
2414 error (_("PC is required"));
2415 tfind_1 (tfind_pc
, 0, parse_and_eval_address (argv
[1]), 0, 0);
2417 else if (strcmp (mode
, "pc-inside-range") == 0)
2420 error (_("Start and end PC are required"));
2421 tfind_1 (tfind_range
, 0, parse_and_eval_address (argv
[1]),
2422 parse_and_eval_address (argv
[2]), 0);
2424 else if (strcmp (mode
, "pc-outside-range") == 0)
2427 error (_("Start and end PC are required"));
2428 tfind_1 (tfind_outside
, 0, parse_and_eval_address (argv
[1]),
2429 parse_and_eval_address (argv
[2]), 0);
2431 else if (strcmp (mode
, "line") == 0)
2434 error (_("Line is required"));
2436 std::vector
<symtab_and_line
> sals
2437 = decode_line_with_current_source (argv
[1],
2438 DECODE_LINE_FUNFIRSTLINE
);
2439 const symtab_and_line
&sal
= sals
[0];
2441 if (sal
.symtab
== 0)
2442 error (_("Could not find the specified line"));
2444 CORE_ADDR start_pc
, end_pc
;
2445 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2446 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, 0);
2448 error (_("Could not find the specified line"));
2451 error (_("Invalid mode '%s'"), mode
);
2453 if (has_stack_frames () || get_traceframe_number () >= 0)
2454 print_stack_frame (get_selected_frame (NULL
), 1, LOC_AND_ADDRESS
, 1);
2458 mi_cmd_trace_save (const char *command
, char **argv
, int argc
)
2460 int target_saves
= 0;
2461 int generate_ctf
= 0;
2468 TARGET_SAVE_OPT
, CTF_OPT
2470 static const struct mi_opt opts
[] =
2472 {"r", TARGET_SAVE_OPT
, 0},
2473 {"ctf", CTF_OPT
, 0},
2479 int opt
= mi_getopt ("-trace-save", argc
, argv
, opts
,
2484 switch ((enum opt
) opt
)
2486 case TARGET_SAVE_OPT
:
2495 if (argc
- oind
!= 1)
2496 error (_("Exactly one argument required "
2497 "(file in which to save trace data)"));
2499 filename
= argv
[oind
];
2502 trace_save_ctf (filename
, target_saves
);
2504 trace_save_tfile (filename
, target_saves
);
2508 mi_cmd_trace_start (const char *command
, char **argv
, int argc
)
2510 start_tracing (NULL
);
2514 mi_cmd_trace_status (const char *command
, char **argv
, int argc
)
2516 trace_status_mi (0);
2520 mi_cmd_trace_stop (const char *command
, char **argv
, int argc
)
2522 stop_tracing (NULL
);
2523 trace_status_mi (1);
2526 /* Implement the "-ada-task-info" command. */
2529 mi_cmd_ada_task_info (const char *command
, char **argv
, int argc
)
2531 if (argc
!= 0 && argc
!= 1)
2532 error (_("Invalid MI command"));
2534 print_ada_task_info (current_uiout
, argv
[0], current_inferior ());
2537 /* Print EXPRESSION according to VALUES. */
2540 print_variable_or_computed (const char *expression
, enum print_values values
)
2544 struct ui_out
*uiout
= current_uiout
;
2548 expression_up expr
= parse_expression (expression
);
2550 if (values
== PRINT_SIMPLE_VALUES
)
2551 val
= evaluate_type (expr
.get ());
2553 val
= evaluate_expression (expr
.get ());
2555 gdb::optional
<ui_out_emit_tuple
> tuple_emitter
;
2556 if (values
!= PRINT_NO_VALUES
)
2557 tuple_emitter
.emplace (uiout
, nullptr);
2558 uiout
->field_string ("name", expression
);
2562 case PRINT_SIMPLE_VALUES
:
2563 type
= check_typedef (value_type (val
));
2564 type_print (value_type (val
), "", &stb
, -1);
2565 uiout
->field_stream ("type", stb
);
2566 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
2567 && TYPE_CODE (type
) != TYPE_CODE_STRUCT
2568 && TYPE_CODE (type
) != TYPE_CODE_UNION
)
2570 struct value_print_options opts
;
2572 get_no_prettyformat_print_options (&opts
);
2574 common_val_print (val
, &stb
, 0, &opts
, current_language
);
2575 uiout
->field_stream ("value", stb
);
2578 case PRINT_ALL_VALUES
:
2580 struct value_print_options opts
;
2582 get_no_prettyformat_print_options (&opts
);
2584 common_val_print (val
, &stb
, 0, &opts
, current_language
);
2585 uiout
->field_stream ("value", stb
);
2591 /* Implement the "-trace-frame-collected" command. */
2594 mi_cmd_trace_frame_collected (const char *command
, char **argv
, int argc
)
2596 struct bp_location
*tloc
;
2598 struct collection_list
*clist
;
2599 struct collection_list tracepoint_list
, stepping_list
;
2600 struct traceframe_info
*tinfo
;
2602 enum print_values var_print_values
= PRINT_ALL_VALUES
;
2603 enum print_values comp_print_values
= PRINT_ALL_VALUES
;
2604 int registers_format
= 'x';
2605 int memory_contents
= 0;
2606 struct ui_out
*uiout
= current_uiout
;
2614 static const struct mi_opt opts
[] =
2616 {"-var-print-values", VAR_PRINT_VALUES
, 1},
2617 {"-comp-print-values", COMP_PRINT_VALUES
, 1},
2618 {"-registers-format", REGISTERS_FORMAT
, 1},
2619 {"-memory-contents", MEMORY_CONTENTS
, 0},
2626 int opt
= mi_getopt ("-trace-frame-collected", argc
, argv
, opts
,
2630 switch ((enum opt
) opt
)
2632 case VAR_PRINT_VALUES
:
2633 var_print_values
= mi_parse_print_values (oarg
);
2635 case COMP_PRINT_VALUES
:
2636 comp_print_values
= mi_parse_print_values (oarg
);
2638 case REGISTERS_FORMAT
:
2639 registers_format
= oarg
[0];
2640 case MEMORY_CONTENTS
:
2641 memory_contents
= 1;
2647 error (_("Usage: -trace-frame-collected "
2648 "[--var-print-values PRINT_VALUES] "
2649 "[--comp-print-values PRINT_VALUES] "
2650 "[--registers-format FORMAT]"
2651 "[--memory-contents]"));
2653 /* This throws an error is not inspecting a trace frame. */
2654 tloc
= get_traceframe_location (&stepping_frame
);
2656 /* This command only makes sense for the current frame, not the
2658 scoped_restore_current_thread restore_thread
;
2659 select_frame (get_current_frame ());
2661 encode_actions (tloc
, &tracepoint_list
, &stepping_list
);
2664 clist
= &stepping_list
;
2666 clist
= &tracepoint_list
;
2668 tinfo
= get_traceframe_info ();
2670 /* Explicitly wholly collected variables. */
2674 ui_out_emit_list
list_emitter (uiout
, "explicit-variables");
2675 const std::vector
<std::string
> &wholly_collected
2676 = clist
->wholly_collected ();
2677 for (size_t i
= 0; i
< wholly_collected
.size (); i
++)
2679 const std::string
&str
= wholly_collected
[i
];
2680 print_variable_or_computed (str
.c_str (), var_print_values
);
2684 /* Computed expressions. */
2689 ui_out_emit_list
list_emitter (uiout
, "computed-expressions");
2691 const std::vector
<std::string
> &computed
= clist
->computed ();
2692 for (size_t i
= 0; i
< computed
.size (); i
++)
2694 const std::string
&str
= computed
[i
];
2695 print_variable_or_computed (str
.c_str (), comp_print_values
);
2699 /* Registers. Given pseudo-registers, and that some architectures
2700 (like MIPS) actually hide the raw registers, we don't go through
2701 the trace frame info, but instead consult the register cache for
2702 register availability. */
2704 struct frame_info
*frame
;
2705 struct gdbarch
*gdbarch
;
2709 ui_out_emit_list
list_emitter (uiout
, "registers");
2711 frame
= get_selected_frame (NULL
);
2712 gdbarch
= get_frame_arch (frame
);
2713 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
2715 for (regnum
= 0; regnum
< numregs
; regnum
++)
2717 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
2718 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
2721 output_register (frame
, regnum
, registers_format
, 1);
2725 /* Trace state variables. */
2730 ui_out_emit_list
list_emitter (uiout
, "tvars");
2732 for (i
= 0; VEC_iterate (int, tinfo
->tvars
, i
, tvar
); i
++)
2734 struct trace_state_variable
*tsv
;
2736 tsv
= find_trace_state_variable_by_number (tvar
);
2738 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
2742 uiout
->field_fmt ("name", "$%s", tsv
->name
);
2744 tsv
->value_known
= target_get_trace_state_variable_value (tsv
->number
,
2746 uiout
->field_int ("current", tsv
->value
);
2750 uiout
->field_skip ("name");
2751 uiout
->field_skip ("current");
2758 struct cleanup
*cleanups
;
2759 VEC(mem_range_s
) *available_memory
= NULL
;
2760 struct mem_range
*r
;
2763 traceframe_available_memory (&available_memory
, 0, ULONGEST_MAX
);
2764 cleanups
= make_cleanup (VEC_cleanup(mem_range_s
), &available_memory
);
2766 ui_out_emit_list
list_emitter (uiout
, "memory");
2768 for (i
= 0; VEC_iterate (mem_range_s
, available_memory
, i
, r
); i
++)
2770 struct gdbarch
*gdbarch
= target_gdbarch ();
2772 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
2774 uiout
->field_core_addr ("address", gdbarch
, r
->start
);
2775 uiout
->field_int ("length", r
->length
);
2777 gdb::byte_vector
data (r
->length
);
2779 if (memory_contents
)
2781 if (target_read_memory (r
->start
, data
.data (), r
->length
) == 0)
2783 std::string data_str
= bin2hex (data
.data (), r
->length
);
2784 uiout
->field_string ("contents", data_str
.c_str ());
2787 uiout
->field_skip ("contents");
2791 do_cleanups (cleanups
);
2796 _initialize_mi_main (void)
2798 struct cmd_list_element
*c
;
2800 add_setshow_boolean_cmd ("mi-async", class_run
,
2802 Set whether MI asynchronous mode is enabled."), _("\
2803 Show whether MI asynchronous mode is enabled."), _("\
2804 Tells GDB whether MI should be in asynchronous mode."),
2805 set_mi_async_command
,
2806 show_mi_async_command
,
2810 /* Alias old "target-async" to "mi-async". */
2811 c
= add_alias_cmd ("target-async", "mi-async", class_run
, 0, &setlist
);
2812 deprecate_cmd (c
, "set mi-async");
2813 c
= add_alias_cmd ("target-async", "mi-async", class_run
, 0, &showlist
);
2814 deprecate_cmd (c
, "show mi-async");