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(). */
44 #include "mi-common.h"
49 #include "common/gdb_splay_tree.h"
50 #include "tracepoint.h"
54 #include "extension.h"
57 #include "common/gdb_optional.h"
58 #include "common/byte-vector.h"
61 #include "run-time-clock.h"
63 #include "progspace-and-thread.h"
64 #include "common/rsp-low.h"
75 /* This is used to pass the current command timestamp down to
76 continuation routines. */
77 static struct mi_timestamp
*current_command_ts
;
79 static int do_timings
= 0;
82 /* Few commands would like to know if options like --thread-group were
83 explicitly specified. This variable keeps the current parsed
84 command including all option, and make it possible. */
85 static struct mi_parse
*current_context
;
87 int running_result_record_printed
= 1;
89 /* Flag indicating that the target has proceeded since the last
90 command was issued. */
93 static void mi_cmd_execute (struct mi_parse
*parse
);
95 static void mi_execute_cli_command (const char *cmd
, int args_p
,
97 static void mi_execute_async_cli_command (const char *cli_command
,
98 char **argv
, int argc
);
99 static int register_changed_p (int regnum
, struct regcache
*,
101 static void output_register (struct frame_info
*, int regnum
, int format
,
102 int skip_unavailable
);
104 /* Controls whether the frontend wants MI in async mode. */
105 static int mi_async
= 0;
107 /* The set command writes to this variable. If the inferior is
108 executing, mi_async is *not* updated. */
109 static int mi_async_1
= 0;
112 set_mi_async_command (char *args
, int from_tty
,
113 struct cmd_list_element
*c
)
115 if (have_live_inferiors ())
117 mi_async_1
= mi_async
;
118 error (_("Cannot change this setting while the inferior is running."));
121 mi_async
= mi_async_1
;
125 show_mi_async_command (struct ui_file
*file
, int from_tty
,
126 struct cmd_list_element
*c
,
129 fprintf_filtered (file
,
130 _("Whether MI is in asynchronous mode is %s.\n"),
134 /* A wrapper for target_can_async_p that takes the MI setting into
140 return mi_async
&& target_can_async_p ();
143 /* Command implementations. FIXME: Is this libgdb? No. This is the MI
144 layer that calls libgdb. Any operation used in the below should be
147 static void timestamp (struct mi_timestamp
*tv
);
149 static void print_diff (struct ui_file
*file
, struct mi_timestamp
*start
,
150 struct mi_timestamp
*end
);
153 mi_cmd_gdb_exit (const char *command
, char **argv
, int argc
)
155 struct mi_interp
*mi
= (struct mi_interp
*) current_interpreter ();
157 /* We have to print everything right here because we never return. */
159 fputs_unfiltered (current_token
, mi
->raw_stdout
);
160 fputs_unfiltered ("^exit\n", mi
->raw_stdout
);
161 mi_out_put (current_uiout
, mi
->raw_stdout
);
162 gdb_flush (mi
->raw_stdout
);
163 /* FIXME: The function called is not yet a formal libgdb function. */
164 quit_force (NULL
, FROM_TTY
);
168 mi_cmd_exec_next (const char *command
, char **argv
, int argc
)
170 /* FIXME: Should call a libgdb function, not a cli wrapper. */
171 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
172 mi_execute_async_cli_command ("reverse-next", argv
+ 1, argc
- 1);
174 mi_execute_async_cli_command ("next", argv
, argc
);
178 mi_cmd_exec_next_instruction (const char *command
, char **argv
, int argc
)
180 /* FIXME: Should call a libgdb function, not a cli wrapper. */
181 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
182 mi_execute_async_cli_command ("reverse-nexti", argv
+ 1, argc
- 1);
184 mi_execute_async_cli_command ("nexti", argv
, argc
);
188 mi_cmd_exec_step (const char *command
, char **argv
, int argc
)
190 /* FIXME: Should call a libgdb function, not a cli wrapper. */
191 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
192 mi_execute_async_cli_command ("reverse-step", argv
+ 1, argc
- 1);
194 mi_execute_async_cli_command ("step", argv
, argc
);
198 mi_cmd_exec_step_instruction (const char *command
, char **argv
, int argc
)
200 /* FIXME: Should call a libgdb function, not a cli wrapper. */
201 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
202 mi_execute_async_cli_command ("reverse-stepi", argv
+ 1, argc
- 1);
204 mi_execute_async_cli_command ("stepi", argv
, argc
);
208 mi_cmd_exec_finish (const char *command
, char **argv
, int argc
)
210 /* FIXME: Should call a libgdb function, not a cli wrapper. */
211 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
212 mi_execute_async_cli_command ("reverse-finish", argv
+ 1, argc
- 1);
214 mi_execute_async_cli_command ("finish", argv
, argc
);
218 mi_cmd_exec_return (const char *command
, char **argv
, int argc
)
220 /* This command doesn't really execute the target, it just pops the
221 specified number of frames. */
223 /* Call return_command with from_tty argument equal to 0 so as to
224 avoid being queried. */
225 return_command (*argv
, 0);
227 /* Call return_command with from_tty argument equal to 0 so as to
228 avoid being queried. */
229 return_command (NULL
, 0);
231 /* Because we have called return_command with from_tty = 0, we need
232 to print the frame here. */
233 print_stack_frame (get_selected_frame (NULL
), 1, LOC_AND_ADDRESS
, 1);
237 mi_cmd_exec_jump (const char *args
, char **argv
, int argc
)
239 /* FIXME: Should call a libgdb function, not a cli wrapper. */
240 mi_execute_async_cli_command ("jump", argv
, argc
);
244 proceed_thread (struct thread_info
*thread
, int pid
)
246 if (!is_stopped (thread
->ptid
))
249 if (pid
!= 0 && ptid_get_pid (thread
->ptid
) != pid
)
252 switch_to_thread (thread
->ptid
);
253 clear_proceed_status (0);
254 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
);
258 proceed_thread_callback (struct thread_info
*thread
, void *arg
)
260 int pid
= *(int *)arg
;
262 proceed_thread (thread
, pid
);
267 exec_continue (char **argv
, int argc
)
269 prepare_execution_command (¤t_target
, mi_async_p ());
273 /* In non-stop mode, 'resume' always resumes a single thread.
274 Therefore, to resume all threads of the current inferior, or
275 all threads in all inferiors, we need to iterate over
278 See comment on infcmd.c:proceed_thread_callback for rationale. */
279 if (current_context
->all
|| current_context
->thread_group
!= -1)
281 scoped_restore_current_thread restore_thread
;
284 if (!current_context
->all
)
287 = find_inferior_id (current_context
->thread_group
);
291 iterate_over_threads (proceed_thread_callback
, &pid
);
300 scoped_restore save_multi
= make_scoped_restore (&sched_multi
);
302 if (current_context
->all
)
309 /* In all-stop mode, -exec-continue traditionally resumed
310 either all threads, or one thread, depending on the
311 'scheduler-locking' variable. Let's continue to do the
319 exec_reverse_continue (char **argv
, int argc
)
321 enum exec_direction_kind dir
= execution_direction
;
323 if (dir
== EXEC_REVERSE
)
324 error (_("Already in reverse mode."));
326 if (!target_can_execute_reverse
)
327 error (_("Target %s does not support this command."), target_shortname
);
329 scoped_restore save_exec_dir
= make_scoped_restore (&execution_direction
,
331 exec_continue (argv
, argc
);
335 mi_cmd_exec_continue (const char *command
, char **argv
, int argc
)
337 if (argc
> 0 && strcmp (argv
[0], "--reverse") == 0)
338 exec_reverse_continue (argv
+ 1, argc
- 1);
340 exec_continue (argv
, argc
);
344 interrupt_thread_callback (struct thread_info
*thread
, void *arg
)
346 int pid
= *(int *)arg
;
348 if (!is_running (thread
->ptid
))
351 if (ptid_get_pid (thread
->ptid
) != pid
)
354 target_stop (thread
->ptid
);
358 /* Interrupt the execution of the target. Note how we must play
359 around with the token variables, in order to display the current
360 token in the result of the interrupt command, and the previous
361 execution token when the target finally stops. See comments in
365 mi_cmd_exec_interrupt (const char *command
, char **argv
, int argc
)
367 /* In all-stop mode, everything stops, so we don't need to try
368 anything specific. */
371 interrupt_target_1 (0);
375 if (current_context
->all
)
377 /* This will interrupt all threads in all inferiors. */
378 interrupt_target_1 (1);
380 else if (current_context
->thread_group
!= -1)
382 struct inferior
*inf
= find_inferior_id (current_context
->thread_group
);
384 iterate_over_threads (interrupt_thread_callback
, &inf
->pid
);
388 /* Interrupt just the current thread -- either explicitly
389 specified via --thread or whatever was current before
390 MI command was sent. */
391 interrupt_target_1 (0);
395 /* Callback for iterate_over_inferiors which starts the execution
396 of the given inferior.
398 ARG is a pointer to an integer whose value, if non-zero, indicates
399 that the program should be stopped when reaching the main subprogram
400 (similar to what the CLI "start" command does). */
403 run_one_inferior (struct inferior
*inf
, void *arg
)
405 int start_p
= *(int *) arg
;
406 const char *run_cmd
= start_p
? "start" : "run";
407 struct target_ops
*run_target
= find_run_target ();
408 int async_p
= mi_async
&& run_target
->to_can_async_p (run_target
);
412 if (inf
->pid
!= ptid_get_pid (inferior_ptid
))
414 struct thread_info
*tp
;
416 tp
= any_thread_of_process (inf
->pid
);
418 error (_("Inferior has no threads."));
420 switch_to_thread (tp
->ptid
);
425 set_current_inferior (inf
);
426 switch_to_thread (null_ptid
);
427 set_current_program_space (inf
->pspace
);
429 mi_execute_cli_command (run_cmd
, async_p
,
430 async_p
? "&" : NULL
);
435 mi_cmd_exec_run (const char *command
, char **argv
, int argc
)
439 /* Parse the command options. */
444 static const struct mi_opt opts
[] =
446 {"-start", START_OPT
, 0},
455 int opt
= mi_getopt ("-exec-run", argc
, argv
, opts
, &oind
, &oarg
);
459 switch ((enum opt
) opt
)
467 /* This command does not accept any argument. Make sure the user
468 did not provide any. */
470 error (_("Invalid argument: %s"), argv
[oind
]);
472 if (current_context
->all
)
474 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
476 iterate_over_inferiors (run_one_inferior
, &start_p
);
480 const char *run_cmd
= start_p
? "start" : "run";
481 struct target_ops
*run_target
= find_run_target ();
482 int async_p
= mi_async
&& run_target
->to_can_async_p (run_target
);
484 mi_execute_cli_command (run_cmd
, async_p
,
485 async_p
? "&" : NULL
);
491 find_thread_of_process (struct thread_info
*ti
, void *p
)
495 if (ptid_get_pid (ti
->ptid
) == pid
&& !is_exited (ti
->ptid
))
502 mi_cmd_target_detach (const char *command
, char **argv
, int argc
)
504 if (argc
!= 0 && argc
!= 1)
505 error (_("Usage: -target-detach [pid | thread-group]"));
509 struct thread_info
*tp
;
513 /* First see if we are dealing with a thread-group id. */
516 struct inferior
*inf
;
517 int id
= strtoul (argv
[0] + 1, &end
, 0);
520 error (_("Invalid syntax of thread-group id '%s'"), argv
[0]);
522 inf
= find_inferior_id (id
);
524 error (_("Non-existent thread-group id '%d'"), id
);
530 /* We must be dealing with a pid. */
531 pid
= strtol (argv
[0], &end
, 10);
534 error (_("Invalid identifier '%s'"), argv
[0]);
537 /* Pick any thread in the desired process. Current
538 target_detach detaches from the parent of inferior_ptid. */
539 tp
= iterate_over_threads (find_thread_of_process
, &pid
);
541 error (_("Thread group is empty"));
543 switch_to_thread (tp
->ptid
);
546 detach_command (NULL
, 0);
550 mi_cmd_target_flash_erase (const char *command
, char **argv
, int argc
)
552 flash_erase_command (NULL
, 0);
556 mi_cmd_thread_select (const char *command
, char **argv
, int argc
)
559 char *mi_error_message
;
560 ptid_t previous_ptid
= inferior_ptid
;
563 error (_("-thread-select: USAGE: threadnum."));
565 rc
= gdb_thread_select (current_uiout
, argv
[0], &mi_error_message
);
567 /* If thread switch did not succeed don't notify or print. */
568 if (rc
== GDB_RC_FAIL
)
570 make_cleanup (xfree
, mi_error_message
);
571 error ("%s", mi_error_message
);
574 print_selected_thread_frame (current_uiout
,
575 USER_SELECTED_THREAD
| USER_SELECTED_FRAME
);
577 /* Notify if the thread has effectively changed. */
578 if (!ptid_equal (inferior_ptid
, previous_ptid
))
580 observer_notify_user_selected_context_changed (USER_SELECTED_THREAD
581 | USER_SELECTED_FRAME
);
586 mi_cmd_thread_list_ids (const char *command
, char **argv
, int argc
)
589 char *mi_error_message
;
592 error (_("-thread-list-ids: No arguments required."));
594 rc
= gdb_list_thread_ids (current_uiout
, &mi_error_message
);
596 if (rc
== GDB_RC_FAIL
)
598 make_cleanup (xfree
, mi_error_message
);
599 error ("%s", mi_error_message
);
604 mi_cmd_thread_info (const char *command
, char **argv
, int argc
)
606 if (argc
!= 0 && argc
!= 1)
607 error (_("Invalid MI command"));
609 print_thread_info (current_uiout
, argv
[0], -1);
612 struct collect_cores_data
619 collect_cores (struct thread_info
*ti
, void *xdata
)
621 struct collect_cores_data
*data
= (struct collect_cores_data
*) xdata
;
623 if (ptid_get_pid (ti
->ptid
) == data
->pid
)
625 int core
= target_core_of_thread (ti
->ptid
);
628 data
->cores
.insert (core
);
634 struct print_one_inferior_data
637 const std::set
<int> *inferiors
;
641 print_one_inferior (struct inferior
*inferior
, void *xdata
)
643 struct print_one_inferior_data
*top_data
644 = (struct print_one_inferior_data
*) xdata
;
645 struct ui_out
*uiout
= current_uiout
;
647 if (top_data
->inferiors
->empty ()
648 || (top_data
->inferiors
->find (inferior
->pid
)
649 != top_data
->inferiors
->end ()))
651 struct collect_cores_data data
;
652 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
654 uiout
->field_fmt ("id", "i%d", inferior
->num
);
655 uiout
->field_string ("type", "process");
656 if (inferior
->has_exit_code
)
657 uiout
->field_string ("exit-code",
658 int_string (inferior
->exit_code
, 8, 0, 0, 1));
659 if (inferior
->pid
!= 0)
660 uiout
->field_int ("pid", inferior
->pid
);
662 if (inferior
->pspace
->pspace_exec_filename
!= NULL
)
664 uiout
->field_string ("executable",
665 inferior
->pspace
->pspace_exec_filename
);
668 if (inferior
->pid
!= 0)
670 data
.pid
= inferior
->pid
;
671 iterate_over_threads (collect_cores
, &data
);
674 if (!data
.cores
.empty ())
676 ui_out_emit_list
list_emitter (uiout
, "cores");
678 for (int b
: data
.cores
)
679 uiout
->field_int (NULL
, b
);
682 if (top_data
->recurse
)
683 print_thread_info (uiout
, NULL
, inferior
->pid
);
689 /* Output a field named 'cores' with a list as the value. The
690 elements of the list are obtained by splitting 'cores' on
694 output_cores (struct ui_out
*uiout
, const char *field_name
, const char *xcores
)
696 ui_out_emit_list
list_emitter (uiout
, field_name
);
697 gdb::unique_xmalloc_ptr
<char> cores (xstrdup (xcores
));
698 char *p
= cores
.get ();
700 for (p
= strtok (p
, ","); p
; p
= strtok (NULL
, ","))
701 uiout
->field_string (NULL
, p
);
705 free_vector_of_osdata_items (splay_tree_value xvalue
)
707 VEC (osdata_item_s
) *value
= (VEC (osdata_item_s
) *) xvalue
;
709 /* We don't free the items itself, it will be done separately. */
710 VEC_free (osdata_item_s
, value
);
714 splay_tree_int_comparator (splay_tree_key xa
, splay_tree_key xb
)
723 list_available_thread_groups (const std::set
<int> &ids
, int recurse
)
726 struct osdata_item
*item
;
728 struct ui_out
*uiout
= current_uiout
;
729 struct cleanup
*cleanup
;
731 /* This keeps a map from integer (pid) to VEC (struct osdata_item *)*
732 The vector contains information about all threads for the given pid.
733 This is assigned an initial value to avoid "may be used uninitialized"
735 gdb_splay_tree_up tree
;
737 /* get_osdata will throw if it cannot return data. */
738 data
= get_osdata ("processes");
739 cleanup
= make_cleanup_osdata_free (data
);
743 struct osdata
*threads
= get_osdata ("threads");
745 make_cleanup_osdata_free (threads
);
746 tree
.reset (splay_tree_new (splay_tree_int_comparator
,
748 free_vector_of_osdata_items
));
751 VEC_iterate (osdata_item_s
, threads
->items
,
755 const char *pid
= get_osdata_column (item
, "pid");
756 int pid_i
= strtoul (pid
, NULL
, 0);
757 VEC (osdata_item_s
) *vec
= 0;
759 splay_tree_node n
= splay_tree_lookup (tree
.get (), pid_i
);
762 VEC_safe_push (osdata_item_s
, vec
, item
);
763 splay_tree_insert (tree
.get (), pid_i
, (splay_tree_value
)vec
);
767 vec
= (VEC (osdata_item_s
) *) n
->value
;
768 VEC_safe_push (osdata_item_s
, vec
, item
);
769 n
->value
= (splay_tree_value
) vec
;
774 ui_out_emit_list
list_emitter (uiout
, "groups");
777 VEC_iterate (osdata_item_s
, data
->items
,
781 const char *pid
= get_osdata_column (item
, "pid");
782 const char *cmd
= get_osdata_column (item
, "command");
783 const char *user
= get_osdata_column (item
, "user");
784 const char *cores
= get_osdata_column (item
, "cores");
786 int pid_i
= strtoul (pid
, NULL
, 0);
788 /* At present, the target will return all available processes
789 and if information about specific ones was required, we filter
790 undesired processes here. */
791 if (!ids
.empty () && ids
.find (pid_i
) == ids
.end ())
794 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
796 uiout
->field_fmt ("id", "%s", pid
);
797 uiout
->field_string ("type", "process");
799 uiout
->field_string ("description", cmd
);
801 uiout
->field_string ("user", user
);
803 output_cores (uiout
, "cores", cores
);
807 splay_tree_node n
= splay_tree_lookup (tree
.get (), pid_i
);
810 VEC (osdata_item_s
) *children
= (VEC (osdata_item_s
) *) n
->value
;
811 struct osdata_item
*child
;
814 ui_out_emit_list
thread_list_emitter (uiout
, "threads");
817 VEC_iterate (osdata_item_s
, children
, ix_child
, child
);
820 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
821 const char *tid
= get_osdata_column (child
, "tid");
822 const char *tcore
= get_osdata_column (child
, "core");
824 uiout
->field_string ("id", tid
);
826 uiout
->field_string ("core", tcore
);
832 do_cleanups (cleanup
);
836 mi_cmd_list_thread_groups (const char *command
, char **argv
, int argc
)
838 struct ui_out
*uiout
= current_uiout
;
845 AVAILABLE_OPT
, RECURSE_OPT
847 static const struct mi_opt opts
[] =
849 {"-available", AVAILABLE_OPT
, 0},
850 {"-recurse", RECURSE_OPT
, 1},
859 int opt
= mi_getopt ("-list-thread-groups", argc
, argv
, opts
,
864 switch ((enum opt
) opt
)
870 if (strcmp (oarg
, "0") == 0)
872 else if (strcmp (oarg
, "1") == 0)
875 error (_("only '0' and '1' are valid values "
876 "for the '--recurse' option"));
881 for (; oind
< argc
; ++oind
)
886 if (*(argv
[oind
]) != 'i')
887 error (_("invalid syntax of group id '%s'"), argv
[oind
]);
889 inf
= strtoul (argv
[oind
] + 1, &end
, 0);
892 error (_("invalid syntax of group id '%s'"), argv
[oind
]);
898 list_available_thread_groups (ids
, recurse
);
900 else if (ids
.size () == 1)
902 /* Local thread groups, single id. */
903 int id
= *(ids
.begin ());
904 struct inferior
*inf
= find_inferior_id (id
);
907 error (_("Non-existent thread group id '%d'"), id
);
909 print_thread_info (uiout
, NULL
, inf
->pid
);
913 struct print_one_inferior_data data
;
915 data
.recurse
= recurse
;
916 data
.inferiors
= &ids
;
918 /* Local thread groups. Either no explicit ids -- and we
919 print everything, or several explicit ids. In both cases,
920 we print more than one group, and have to use 'groups'
921 as the top-level element. */
922 ui_out_emit_list
list_emitter (uiout
, "groups");
923 update_thread_list ();
924 iterate_over_inferiors (print_one_inferior
, &data
);
929 mi_cmd_data_list_register_names (const char *command
, char **argv
, int argc
)
931 struct gdbarch
*gdbarch
;
932 struct ui_out
*uiout
= current_uiout
;
936 /* Note that the test for a valid register must include checking the
937 gdbarch_register_name because gdbarch_num_regs may be allocated
938 for the union of the register sets within a family of related
939 processors. In this case, some entries of gdbarch_register_name
940 will change depending upon the particular processor being
943 gdbarch
= get_current_arch ();
944 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
946 ui_out_emit_list
list_emitter (uiout
, "register-names");
948 if (argc
== 0) /* No args, just do all the regs. */
954 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
955 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
956 uiout
->field_string (NULL
, "");
958 uiout
->field_string (NULL
, gdbarch_register_name (gdbarch
, regnum
));
962 /* Else, list of register #s, just do listed regs. */
963 for (i
= 0; i
< argc
; i
++)
965 regnum
= atoi (argv
[i
]);
966 if (regnum
< 0 || regnum
>= numregs
)
967 error (_("bad register number"));
969 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
970 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
971 uiout
->field_string (NULL
, "");
973 uiout
->field_string (NULL
, gdbarch_register_name (gdbarch
, regnum
));
978 mi_cmd_data_list_changed_registers (const char *command
, char **argv
, int argc
)
980 static std::unique_ptr
<struct regcache
> this_regs
;
981 struct ui_out
*uiout
= current_uiout
;
982 std::unique_ptr
<struct regcache
> prev_regs
;
983 struct gdbarch
*gdbarch
;
984 int regnum
, numregs
, changed
;
987 /* The last time we visited this function, the current frame's
988 register contents were saved in THIS_REGS. Move THIS_REGS over
989 to PREV_REGS, and refresh THIS_REGS with the now-current register
992 prev_regs
= std::move (this_regs
);
993 this_regs
= frame_save_as_regcache (get_selected_frame (NULL
));
995 /* Note that the test for a valid register must include checking the
996 gdbarch_register_name because gdbarch_num_regs may be allocated
997 for the union of the register sets within a family of related
998 processors. In this case, some entries of gdbarch_register_name
999 will change depending upon the particular processor being
1002 gdbarch
= get_regcache_arch (this_regs
.get ());
1003 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1005 ui_out_emit_list
list_emitter (uiout
, "changed-registers");
1009 /* No args, just do all the regs. */
1014 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1015 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1017 changed
= register_changed_p (regnum
, prev_regs
.get (),
1020 error (_("-data-list-changed-registers: "
1021 "Unable to read register contents."));
1023 uiout
->field_int (NULL
, regnum
);
1027 /* Else, list of register #s, just do listed regs. */
1028 for (i
= 0; i
< argc
; i
++)
1030 regnum
= atoi (argv
[i
]);
1034 && gdbarch_register_name (gdbarch
, regnum
) != NULL
1035 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
1037 changed
= register_changed_p (regnum
, prev_regs
.get (),
1040 error (_("-data-list-changed-registers: "
1041 "Unable to read register contents."));
1043 uiout
->field_int (NULL
, regnum
);
1046 error (_("bad register number"));
1051 register_changed_p (int regnum
, struct regcache
*prev_regs
,
1052 struct regcache
*this_regs
)
1054 struct gdbarch
*gdbarch
= get_regcache_arch (this_regs
);
1055 struct value
*prev_value
, *this_value
;
1058 /* First time through or after gdbarch change consider all registers
1060 if (!prev_regs
|| get_regcache_arch (prev_regs
) != gdbarch
)
1063 /* Get register contents and compare. */
1064 prev_value
= prev_regs
->cooked_read_value (regnum
);
1065 this_value
= this_regs
->cooked_read_value (regnum
);
1066 gdb_assert (prev_value
!= NULL
);
1067 gdb_assert (this_value
!= NULL
);
1069 ret
= value_contents_eq (prev_value
, 0, this_value
, 0,
1070 register_size (gdbarch
, regnum
)) == 0;
1072 release_value (prev_value
);
1073 release_value (this_value
);
1074 value_free (prev_value
);
1075 value_free (this_value
);
1079 /* Return a list of register number and value pairs. The valid
1080 arguments expected are: a letter indicating the format in which to
1081 display the registers contents. This can be one of: x
1082 (hexadecimal), d (decimal), N (natural), t (binary), o (octal), r
1083 (raw). After the format argument there can be a sequence of
1084 numbers, indicating which registers to fetch the content of. If
1085 the format is the only argument, a list of all the registers with
1086 their values is returned. */
1089 mi_cmd_data_list_register_values (const char *command
, char **argv
, int argc
)
1091 struct ui_out
*uiout
= current_uiout
;
1092 struct frame_info
*frame
;
1093 struct gdbarch
*gdbarch
;
1094 int regnum
, numregs
, format
;
1096 int skip_unavailable
= 0;
1102 static const struct mi_opt opts
[] =
1104 {"-skip-unavailable", SKIP_UNAVAILABLE
, 0},
1108 /* Note that the test for a valid register must include checking the
1109 gdbarch_register_name because gdbarch_num_regs may be allocated
1110 for the union of the register sets within a family of related
1111 processors. In this case, some entries of gdbarch_register_name
1112 will change depending upon the particular processor being
1118 int opt
= mi_getopt ("-data-list-register-values", argc
, argv
,
1119 opts
, &oind
, &oarg
);
1123 switch ((enum opt
) opt
)
1125 case SKIP_UNAVAILABLE
:
1126 skip_unavailable
= 1;
1131 if (argc
- oind
< 1)
1132 error (_("-data-list-register-values: Usage: "
1133 "-data-list-register-values [--skip-unavailable] <format>"
1134 " [<regnum1>...<regnumN>]"));
1136 format
= (int) argv
[oind
][0];
1138 frame
= get_selected_frame (NULL
);
1139 gdbarch
= get_frame_arch (frame
);
1140 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1142 ui_out_emit_list
list_emitter (uiout
, "register-values");
1144 if (argc
- oind
== 1)
1146 /* No args, beside the format: do all the regs. */
1151 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1152 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1155 output_register (frame
, regnum
, format
, skip_unavailable
);
1159 /* Else, list of register #s, just do listed regs. */
1160 for (i
= 1 + oind
; i
< argc
; i
++)
1162 regnum
= atoi (argv
[i
]);
1166 && gdbarch_register_name (gdbarch
, regnum
) != NULL
1167 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
1168 output_register (frame
, regnum
, format
, skip_unavailable
);
1170 error (_("bad register number"));
1174 /* Output one register REGNUM's contents in the desired FORMAT. If
1175 SKIP_UNAVAILABLE is true, skip the register if it is
1179 output_register (struct frame_info
*frame
, int regnum
, int format
,
1180 int skip_unavailable
)
1182 struct ui_out
*uiout
= current_uiout
;
1183 struct value
*val
= value_of_register (regnum
, frame
);
1184 struct value_print_options opts
;
1186 if (skip_unavailable
&& !value_entirely_available (val
))
1189 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1190 uiout
->field_int ("number", regnum
);
1200 get_formatted_print_options (&opts
, format
);
1202 val_print (value_type (val
),
1203 value_embedded_offset (val
), 0,
1204 &stb
, 0, val
, &opts
, current_language
);
1205 uiout
->field_stream ("value", stb
);
1208 /* Write given values into registers. The registers and values are
1209 given as pairs. The corresponding MI command is
1210 -data-write-register-values <format>
1211 [<regnum1> <value1>...<regnumN> <valueN>] */
1213 mi_cmd_data_write_register_values (const char *command
, char **argv
, int argc
)
1215 struct regcache
*regcache
;
1216 struct gdbarch
*gdbarch
;
1219 /* Note that the test for a valid register must include checking the
1220 gdbarch_register_name because gdbarch_num_regs may be allocated
1221 for the union of the register sets within a family of related
1222 processors. In this case, some entries of gdbarch_register_name
1223 will change depending upon the particular processor being
1226 regcache
= get_current_regcache ();
1227 gdbarch
= get_regcache_arch (regcache
);
1228 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1231 error (_("-data-write-register-values: Usage: -data-write-register-"
1232 "values <format> [<regnum1> <value1>...<regnumN> <valueN>]"));
1234 if (!target_has_registers
)
1235 error (_("-data-write-register-values: No registers."));
1238 error (_("-data-write-register-values: No regs and values specified."));
1241 error (_("-data-write-register-values: "
1242 "Regs and vals are not in pairs."));
1244 for (i
= 1; i
< argc
; i
= i
+ 2)
1246 int regnum
= atoi (argv
[i
]);
1248 if (regnum
>= 0 && regnum
< numregs
1249 && gdbarch_register_name (gdbarch
, regnum
)
1250 && *gdbarch_register_name (gdbarch
, regnum
))
1254 /* Get the value as a number. */
1255 value
= parse_and_eval_address (argv
[i
+ 1]);
1257 /* Write it down. */
1258 regcache_cooked_write_signed (regcache
, regnum
, value
);
1261 error (_("bad register number"));
1265 /* Evaluate the value of the argument. The argument is an
1266 expression. If the expression contains spaces it needs to be
1267 included in double quotes. */
1270 mi_cmd_data_evaluate_expression (const char *command
, char **argv
, int argc
)
1273 struct value_print_options opts
;
1274 struct ui_out
*uiout
= current_uiout
;
1277 error (_("-data-evaluate-expression: "
1278 "Usage: -data-evaluate-expression expression"));
1280 expression_up expr
= parse_expression (argv
[0]);
1282 val
= evaluate_expression (expr
.get ());
1286 /* Print the result of the expression evaluation. */
1287 get_user_print_options (&opts
);
1289 common_val_print (val
, &stb
, 0, &opts
, current_language
);
1291 uiout
->field_stream ("value", stb
);
1294 /* This is the -data-read-memory command.
1296 ADDR: start address of data to be dumped.
1297 WORD-FORMAT: a char indicating format for the ``word''. See
1299 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes.
1300 NR_ROW: Number of rows.
1301 NR_COL: The number of colums (words per row).
1302 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
1303 ASCHAR for unprintable characters.
1305 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
1306 displayes them. Returns:
1308 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
1311 The number of bytes read is SIZE*ROW*COL. */
1314 mi_cmd_data_read_memory (const char *command
, char **argv
, int argc
)
1316 struct gdbarch
*gdbarch
= get_current_arch ();
1317 struct ui_out
*uiout
= current_uiout
;
1319 long total_bytes
, nr_cols
, nr_rows
;
1321 struct type
*word_type
;
1333 static const struct mi_opt opts
[] =
1335 {"o", OFFSET_OPT
, 1},
1341 int opt
= mi_getopt ("-data-read-memory", argc
, argv
, opts
,
1346 switch ((enum opt
) opt
)
1349 offset
= atol (oarg
);
1356 if (argc
< 5 || argc
> 6)
1357 error (_("-data-read-memory: Usage: "
1358 "ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR]."));
1360 /* Extract all the arguments. */
1362 /* Start address of the memory dump. */
1363 addr
= parse_and_eval_address (argv
[0]) + offset
;
1364 /* The format character to use when displaying a memory word. See
1365 the ``x'' command. */
1366 word_format
= argv
[1][0];
1367 /* The size of the memory word. */
1368 word_size
= atol (argv
[2]);
1372 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1376 word_type
= builtin_type (gdbarch
)->builtin_int16
;
1380 word_type
= builtin_type (gdbarch
)->builtin_int32
;
1384 word_type
= builtin_type (gdbarch
)->builtin_int64
;
1388 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1391 /* The number of rows. */
1392 nr_rows
= atol (argv
[3]);
1394 error (_("-data-read-memory: invalid number of rows."));
1396 /* Number of bytes per row. */
1397 nr_cols
= atol (argv
[4]);
1399 error (_("-data-read-memory: invalid number of columns."));
1401 /* The un-printable character when printing ascii. */
1407 /* Create a buffer and read it in. */
1408 total_bytes
= word_size
* nr_rows
* nr_cols
;
1410 gdb::byte_vector
mbuf (total_bytes
);
1412 /* Dispatch memory reads to the topmost target, not the flattened
1414 nr_bytes
= target_read (current_target
.beneath
,
1415 TARGET_OBJECT_MEMORY
, NULL
, mbuf
.data (),
1418 error (_("Unable to read memory."));
1420 /* Output the header information. */
1421 uiout
->field_core_addr ("addr", gdbarch
, addr
);
1422 uiout
->field_int ("nr-bytes", nr_bytes
);
1423 uiout
->field_int ("total-bytes", total_bytes
);
1424 uiout
->field_core_addr ("next-row", gdbarch
, addr
+ word_size
* nr_cols
);
1425 uiout
->field_core_addr ("prev-row", gdbarch
, addr
- word_size
* nr_cols
);
1426 uiout
->field_core_addr ("next-page", gdbarch
, addr
+ total_bytes
);
1427 uiout
->field_core_addr ("prev-page", gdbarch
, addr
- total_bytes
);
1429 /* Build the result as a two dimentional table. */
1436 ui_out_emit_list
list_emitter (uiout
, "memory");
1437 for (row
= 0, row_byte
= 0;
1439 row
++, row_byte
+= nr_cols
* word_size
)
1443 struct value_print_options opts
;
1445 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1446 uiout
->field_core_addr ("addr", gdbarch
, addr
+ row_byte
);
1447 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr +
1450 ui_out_emit_list
list_data_emitter (uiout
, "data");
1451 get_formatted_print_options (&opts
, word_format
);
1452 for (col
= 0, col_byte
= row_byte
;
1454 col
++, col_byte
+= word_size
)
1456 if (col_byte
+ word_size
> nr_bytes
)
1458 uiout
->field_string (NULL
, "N/A");
1463 print_scalar_formatted (&mbuf
[col_byte
], word_type
, &opts
,
1464 word_asize
, &stream
);
1465 uiout
->field_stream (NULL
, stream
);
1475 for (byte
= row_byte
;
1476 byte
< row_byte
+ word_size
* nr_cols
; byte
++)
1478 if (byte
>= nr_bytes
)
1480 else if (mbuf
[byte
] < 32 || mbuf
[byte
] > 126)
1481 stream
.putc (aschar
);
1483 stream
.putc (mbuf
[byte
]);
1485 uiout
->field_stream ("ascii", stream
);
1492 mi_cmd_data_read_memory_bytes (const char *command
, char **argv
, int argc
)
1494 struct gdbarch
*gdbarch
= get_current_arch ();
1495 struct ui_out
*uiout
= current_uiout
;
1499 int unit_size
= gdbarch_addressable_memory_unit_size (gdbarch
);
1506 static const struct mi_opt opts
[] =
1508 {"o", OFFSET_OPT
, 1},
1514 int opt
= mi_getopt ("-data-read-memory-bytes", argc
, argv
, opts
,
1518 switch ((enum opt
) opt
)
1521 offset
= atol (oarg
);
1529 error (_("Usage: [ -o OFFSET ] ADDR LENGTH."));
1531 addr
= parse_and_eval_address (argv
[0]) + offset
;
1532 length
= atol (argv
[1]);
1534 std::vector
<memory_read_result
> result
1535 = read_memory_robust (current_target
.beneath
, addr
, length
);
1537 if (result
.size () == 0)
1538 error (_("Unable to read memory."));
1540 ui_out_emit_list
list_emitter (uiout
, "memory");
1541 for (const memory_read_result
&read_result
: result
)
1543 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1545 uiout
->field_core_addr ("begin", gdbarch
, read_result
.begin
);
1546 uiout
->field_core_addr ("offset", gdbarch
, read_result
.begin
- addr
);
1547 uiout
->field_core_addr ("end", gdbarch
, read_result
.end
);
1549 std::string data
= bin2hex (read_result
.data
.get (),
1550 (read_result
.end
- read_result
.begin
)
1552 uiout
->field_string ("contents", data
.c_str ());
1556 /* Implementation of the -data-write_memory command.
1558 COLUMN_OFFSET: optional argument. Must be preceded by '-o'. The
1559 offset from the beginning of the memory grid row where the cell to
1561 ADDR: start address of the row in the memory grid where the memory
1562 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
1563 the location to write to.
1564 FORMAT: a char indicating format for the ``word''. See
1566 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
1567 VALUE: value to be written into the memory address.
1569 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
1574 mi_cmd_data_write_memory (const char *command
, char **argv
, int argc
)
1576 struct gdbarch
*gdbarch
= get_current_arch ();
1577 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1580 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
1581 enough when using a compiler other than GCC. */
1590 static const struct mi_opt opts
[] =
1592 {"o", OFFSET_OPT
, 1},
1598 int opt
= mi_getopt ("-data-write-memory", argc
, argv
, opts
,
1603 switch ((enum opt
) opt
)
1606 offset
= atol (oarg
);
1614 error (_("-data-write-memory: Usage: "
1615 "[-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE."));
1617 /* Extract all the arguments. */
1618 /* Start address of the memory dump. */
1619 addr
= parse_and_eval_address (argv
[0]);
1620 /* The size of the memory word. */
1621 word_size
= atol (argv
[2]);
1623 /* Calculate the real address of the write destination. */
1624 addr
+= (offset
* word_size
);
1626 /* Get the value as a number. */
1627 value
= parse_and_eval_address (argv
[3]);
1628 /* Get the value into an array. */
1629 gdb::byte_vector
buffer (word_size
);
1630 store_signed_integer (buffer
.data (), word_size
, byte_order
, value
);
1631 /* Write it down to memory. */
1632 write_memory_with_notification (addr
, buffer
.data (), word_size
);
1635 /* Implementation of the -data-write-memory-bytes command.
1638 DATA: string of bytes to write at that address
1639 COUNT: number of bytes to be filled (decimal integer). */
1642 mi_cmd_data_write_memory_bytes (const char *command
, char **argv
, int argc
)
1646 size_t len_hex
, len_bytes
, len_units
, i
, steps
, remaining_units
;
1647 long int count_units
;
1650 if (argc
!= 2 && argc
!= 3)
1651 error (_("Usage: ADDR DATA [COUNT]."));
1653 addr
= parse_and_eval_address (argv
[0]);
1655 len_hex
= strlen (cdata
);
1656 unit_size
= gdbarch_addressable_memory_unit_size (get_current_arch ());
1658 if (len_hex
% (unit_size
* 2) != 0)
1659 error (_("Hex-encoded '%s' must represent an integral number of "
1660 "addressable memory units."),
1663 len_bytes
= len_hex
/ 2;
1664 len_units
= len_bytes
/ unit_size
;
1667 count_units
= strtoul (argv
[2], NULL
, 10);
1669 count_units
= len_units
;
1671 gdb::byte_vector
databuf (len_bytes
);
1673 for (i
= 0; i
< len_bytes
; ++i
)
1676 if (sscanf (cdata
+ i
* 2, "%02x", &x
) != 1)
1677 error (_("Invalid argument"));
1678 databuf
[i
] = (gdb_byte
) x
;
1681 gdb::byte_vector data
;
1682 if (len_units
< count_units
)
1684 /* Pattern is made of less units than count:
1685 repeat pattern to fill memory. */
1686 data
= gdb::byte_vector (count_units
* unit_size
);
1688 /* Number of times the pattern is entirely repeated. */
1689 steps
= count_units
/ len_units
;
1690 /* Number of remaining addressable memory units. */
1691 remaining_units
= count_units
% len_units
;
1692 for (i
= 0; i
< steps
; i
++)
1693 memcpy (&data
[i
* len_bytes
], &databuf
[0], len_bytes
);
1695 if (remaining_units
> 0)
1696 memcpy (&data
[steps
* len_bytes
], &databuf
[0],
1697 remaining_units
* unit_size
);
1701 /* Pattern is longer than or equal to count:
1702 just copy count addressable memory units. */
1703 data
= std::move (databuf
);
1706 write_memory_with_notification (addr
, data
.data (), count_units
);
1710 mi_cmd_enable_timings (const char *command
, char **argv
, int argc
)
1716 if (strcmp (argv
[0], "yes") == 0)
1718 else if (strcmp (argv
[0], "no") == 0)
1729 error (_("-enable-timings: Usage: %s {yes|no}"), command
);
1733 mi_cmd_list_features (const char *command
, char **argv
, int argc
)
1737 struct ui_out
*uiout
= current_uiout
;
1739 ui_out_emit_list
list_emitter (uiout
, "features");
1740 uiout
->field_string (NULL
, "frozen-varobjs");
1741 uiout
->field_string (NULL
, "pending-breakpoints");
1742 uiout
->field_string (NULL
, "thread-info");
1743 uiout
->field_string (NULL
, "data-read-memory-bytes");
1744 uiout
->field_string (NULL
, "breakpoint-notifications");
1745 uiout
->field_string (NULL
, "ada-task-info");
1746 uiout
->field_string (NULL
, "language-option");
1747 uiout
->field_string (NULL
, "info-gdb-mi-command");
1748 uiout
->field_string (NULL
, "undefined-command-error-code");
1749 uiout
->field_string (NULL
, "exec-run-start-option");
1751 if (ext_lang_initialized_p (get_ext_lang_defn (EXT_LANG_PYTHON
)))
1752 uiout
->field_string (NULL
, "python");
1757 error (_("-list-features should be passed no arguments"));
1761 mi_cmd_list_target_features (const char *command
, char **argv
, int argc
)
1765 struct ui_out
*uiout
= current_uiout
;
1767 ui_out_emit_list
list_emitter (uiout
, "features");
1769 uiout
->field_string (NULL
, "async");
1770 if (target_can_execute_reverse
)
1771 uiout
->field_string (NULL
, "reverse");
1775 error (_("-list-target-features should be passed no arguments"));
1779 mi_cmd_add_inferior (const char *command
, char **argv
, int argc
)
1781 struct inferior
*inf
;
1784 error (_("-add-inferior should be passed no arguments"));
1786 inf
= add_inferior_with_spaces ();
1788 current_uiout
->field_fmt ("inferior", "i%d", inf
->num
);
1791 /* Callback used to find the first inferior other than the current
1795 get_other_inferior (struct inferior
*inf
, void *arg
)
1797 if (inf
== current_inferior ())
1804 mi_cmd_remove_inferior (const char *command
, char **argv
, int argc
)
1807 struct inferior
*inf
;
1810 error (_("-remove-inferior should be passed a single argument"));
1812 if (sscanf (argv
[0], "i%d", &id
) != 1)
1813 error (_("the thread group id is syntactically invalid"));
1815 inf
= find_inferior_id (id
);
1817 error (_("the specified thread group does not exist"));
1820 error (_("cannot remove an active inferior"));
1822 if (inf
== current_inferior ())
1824 struct thread_info
*tp
= 0;
1825 struct inferior
*new_inferior
1826 = iterate_over_inferiors (get_other_inferior
, NULL
);
1828 if (new_inferior
== NULL
)
1829 error (_("Cannot remove last inferior"));
1831 set_current_inferior (new_inferior
);
1832 if (new_inferior
->pid
!= 0)
1833 tp
= any_thread_of_process (new_inferior
->pid
);
1834 switch_to_thread (tp
? tp
->ptid
: null_ptid
);
1835 set_current_program_space (new_inferior
->pspace
);
1838 delete_inferior (inf
);
1843 /* Execute a command within a safe environment.
1844 Return <0 for error; >=0 for ok.
1846 args->action will tell mi_execute_command what action
1847 to perform after the given command has executed (display/suppress
1848 prompt, display error). */
1851 captured_mi_execute_command (struct ui_out
*uiout
, struct mi_parse
*context
)
1853 struct mi_interp
*mi
= (struct mi_interp
*) command_interp ();
1856 current_command_ts
= context
->cmd_start
;
1858 scoped_restore save_token
= make_scoped_restore (¤t_token
,
1861 running_result_record_printed
= 0;
1863 switch (context
->op
)
1866 /* A MI command was read from the input stream. */
1868 /* FIXME: gdb_???? */
1869 fprintf_unfiltered (mi
->raw_stdout
,
1870 " token=`%s' command=`%s' args=`%s'\n",
1871 context
->token
, context
->command
, context
->args
);
1873 mi_cmd_execute (context
);
1875 /* Print the result if there were no errors.
1877 Remember that on the way out of executing a command, you have
1878 to directly use the mi_interp's uiout, since the command
1879 could have reset the interpreter, in which case the current
1880 uiout will most likely crash in the mi_out_* routines. */
1881 if (!running_result_record_printed
)
1883 fputs_unfiltered (context
->token
, mi
->raw_stdout
);
1884 /* There's no particularly good reason why target-connect results
1885 in not ^done. Should kill ^connected for MI3. */
1886 fputs_unfiltered (strcmp (context
->command
, "target-select") == 0
1887 ? "^connected" : "^done", mi
->raw_stdout
);
1888 mi_out_put (uiout
, mi
->raw_stdout
);
1889 mi_out_rewind (uiout
);
1890 mi_print_timing_maybe (mi
->raw_stdout
);
1891 fputs_unfiltered ("\n", mi
->raw_stdout
);
1894 /* The command does not want anything to be printed. In that
1895 case, the command probably should not have written anything
1896 to uiout, but in case it has written something, discard it. */
1897 mi_out_rewind (uiout
);
1904 /* A CLI command was read from the input stream. */
1905 /* This "feature" will be removed as soon as we have a
1906 complete set of mi commands. */
1907 /* Echo the command on the console. */
1908 fprintf_unfiltered (gdb_stdlog
, "%s\n", context
->command
);
1909 /* Call the "console" interpreter. */
1910 argv
[0] = (char *) INTERP_CONSOLE
;
1911 argv
[1] = context
->command
;
1912 mi_cmd_interpreter_exec ("-interpreter-exec", argv
, 2);
1914 /* If we changed interpreters, DON'T print out anything. */
1915 if (current_interp_named_p (INTERP_MI
)
1916 || current_interp_named_p (INTERP_MI1
)
1917 || current_interp_named_p (INTERP_MI2
)
1918 || current_interp_named_p (INTERP_MI3
))
1920 if (!running_result_record_printed
)
1922 fputs_unfiltered (context
->token
, mi
->raw_stdout
);
1923 fputs_unfiltered ("^done", mi
->raw_stdout
);
1924 mi_out_put (uiout
, mi
->raw_stdout
);
1925 mi_out_rewind (uiout
);
1926 mi_print_timing_maybe (mi
->raw_stdout
);
1927 fputs_unfiltered ("\n", mi
->raw_stdout
);
1930 mi_out_rewind (uiout
);
1937 /* Print a gdb exception to the MI output stream. */
1940 mi_print_exception (const char *token
, struct gdb_exception exception
)
1942 struct mi_interp
*mi
= (struct mi_interp
*) current_interpreter ();
1944 fputs_unfiltered (token
, mi
->raw_stdout
);
1945 fputs_unfiltered ("^error,msg=\"", mi
->raw_stdout
);
1946 if (exception
.message
== NULL
)
1947 fputs_unfiltered ("unknown error", mi
->raw_stdout
);
1949 fputstr_unfiltered (exception
.message
, '"', mi
->raw_stdout
);
1950 fputs_unfiltered ("\"", mi
->raw_stdout
);
1952 switch (exception
.error
)
1954 case UNDEFINED_COMMAND_ERROR
:
1955 fputs_unfiltered (",code=\"undefined-command\"", mi
->raw_stdout
);
1959 fputs_unfiltered ("\n", mi
->raw_stdout
);
1962 /* Determine whether the parsed command already notifies the
1963 user_selected_context_changed observer. */
1966 command_notifies_uscc_observer (struct mi_parse
*command
)
1968 if (command
->op
== CLI_COMMAND
)
1970 /* CLI commands "thread" and "inferior" already send it. */
1971 return (strncmp (command
->command
, "thread ", 7) == 0
1972 || strncmp (command
->command
, "inferior ", 9) == 0);
1974 else /* MI_COMMAND */
1976 if (strcmp (command
->command
, "interpreter-exec") == 0
1977 && command
->argc
> 1)
1979 /* "thread" and "inferior" again, but through -interpreter-exec. */
1980 return (strncmp (command
->argv
[1], "thread ", 7) == 0
1981 || strncmp (command
->argv
[1], "inferior ", 9) == 0);
1985 /* -thread-select already sends it. */
1986 return strcmp (command
->command
, "thread-select") == 0;
1991 mi_execute_command (const char *cmd
, int from_tty
)
1994 std::unique_ptr
<struct mi_parse
> command
;
1996 /* This is to handle EOF (^D). We just quit gdb. */
1997 /* FIXME: we should call some API function here. */
1999 quit_force (NULL
, from_tty
);
2001 target_log_command (cmd
);
2005 command
= mi_parse (cmd
, &token
);
2007 CATCH (exception
, RETURN_MASK_ALL
)
2009 mi_print_exception (token
, exception
);
2014 if (command
!= NULL
)
2016 ptid_t previous_ptid
= inferior_ptid
;
2018 gdb::optional
<scoped_restore_tmpl
<int>> restore_suppress
;
2020 if (command
->cmd
!= NULL
&& command
->cmd
->suppress_notification
!= NULL
)
2021 restore_suppress
.emplace (command
->cmd
->suppress_notification
, 1);
2023 command
->token
= token
;
2027 command
->cmd_start
= new mi_timestamp ();
2028 timestamp (command
->cmd_start
);
2033 captured_mi_execute_command (current_uiout
, command
.get ());
2035 CATCH (result
, RETURN_MASK_ALL
)
2037 /* Like in start_event_loop, enable input and force display
2038 of the prompt. Otherwise, any command that calls
2039 async_disable_stdin, and then throws, will leave input
2041 async_enable_stdin ();
2042 current_ui
->prompt_state
= PROMPT_NEEDED
;
2044 /* The command execution failed and error() was called
2046 mi_print_exception (command
->token
, result
);
2047 mi_out_rewind (current_uiout
);
2051 bpstat_do_actions ();
2053 if (/* The notifications are only output when the top-level
2054 interpreter (specified on the command line) is MI. */
2055 interp_ui_out (top_level_interpreter ())->is_mi_like_p ()
2056 /* Don't try report anything if there are no threads --
2057 the program is dead. */
2058 && thread_count () != 0
2059 /* If the command already reports the thread change, no need to do it
2061 && !command_notifies_uscc_observer (command
.get ()))
2063 struct mi_interp
*mi
= (struct mi_interp
*) top_level_interpreter ();
2064 int report_change
= 0;
2066 if (command
->thread
== -1)
2068 report_change
= (!ptid_equal (previous_ptid
, null_ptid
)
2069 && !ptid_equal (inferior_ptid
, previous_ptid
)
2070 && !ptid_equal (inferior_ptid
, null_ptid
));
2072 else if (!ptid_equal (inferior_ptid
, null_ptid
))
2074 struct thread_info
*ti
= inferior_thread ();
2076 report_change
= (ti
->global_num
!= command
->thread
);
2081 observer_notify_user_selected_context_changed
2082 (USER_SELECTED_THREAD
| USER_SELECTED_FRAME
);
2089 mi_cmd_execute (struct mi_parse
*parse
)
2091 struct cleanup
*cleanup
;
2093 cleanup
= prepare_execute_command ();
2095 if (parse
->all
&& parse
->thread_group
!= -1)
2096 error (_("Cannot specify --thread-group together with --all"));
2098 if (parse
->all
&& parse
->thread
!= -1)
2099 error (_("Cannot specify --thread together with --all"));
2101 if (parse
->thread_group
!= -1 && parse
->thread
!= -1)
2102 error (_("Cannot specify --thread together with --thread-group"));
2104 if (parse
->frame
!= -1 && parse
->thread
== -1)
2105 error (_("Cannot specify --frame without --thread"));
2107 if (parse
->thread_group
!= -1)
2109 struct inferior
*inf
= find_inferior_id (parse
->thread_group
);
2110 struct thread_info
*tp
= 0;
2113 error (_("Invalid thread group for the --thread-group option"));
2115 set_current_inferior (inf
);
2116 /* This behaviour means that if --thread-group option identifies
2117 an inferior with multiple threads, then a random one will be
2118 picked. This is not a problem -- frontend should always
2119 provide --thread if it wishes to operate on a specific
2122 tp
= any_live_thread_of_process (inf
->pid
);
2123 switch_to_thread (tp
? tp
->ptid
: null_ptid
);
2124 set_current_program_space (inf
->pspace
);
2127 if (parse
->thread
!= -1)
2129 struct thread_info
*tp
= find_thread_global_id (parse
->thread
);
2132 error (_("Invalid thread id: %d"), parse
->thread
);
2134 if (is_exited (tp
->ptid
))
2135 error (_("Thread id: %d has terminated"), parse
->thread
);
2137 switch_to_thread (tp
->ptid
);
2140 if (parse
->frame
!= -1)
2142 struct frame_info
*fid
;
2143 int frame
= parse
->frame
;
2145 fid
= find_relative_frame (get_current_frame (), &frame
);
2147 /* find_relative_frame was successful */
2150 error (_("Invalid frame id: %d"), frame
);
2153 gdb::optional
<scoped_restore_current_language
> lang_saver
;
2154 if (parse
->language
!= language_unknown
)
2156 lang_saver
.emplace ();
2157 set_language (parse
->language
);
2160 current_context
= parse
;
2162 if (parse
->cmd
->argv_func
!= NULL
)
2164 parse
->cmd
->argv_func (parse
->command
, parse
->argv
, parse
->argc
);
2166 else if (parse
->cmd
->cli
.cmd
!= 0)
2168 /* FIXME: DELETE THIS. */
2169 /* The operation is still implemented by a cli command. */
2170 /* Must be a synchronous one. */
2171 mi_execute_cli_command (parse
->cmd
->cli
.cmd
, parse
->cmd
->cli
.args_p
,
2176 /* FIXME: DELETE THIS. */
2179 stb
.puts ("Undefined mi command: ");
2180 stb
.putstr (parse
->command
, '"');
2181 stb
.puts (" (missing implementation)");
2185 do_cleanups (cleanup
);
2188 /* FIXME: This is just a hack so we can get some extra commands going.
2189 We don't want to channel things through the CLI, but call libgdb directly.
2190 Use only for synchronous commands. */
2193 mi_execute_cli_command (const char *cmd
, int args_p
, const char *args
)
2197 std::string run
= cmd
;
2200 run
= run
+ " " + args
;
2202 /* FIXME: gdb_???? */
2203 fprintf_unfiltered (gdb_stdout
, "cli=%s run=%s\n",
2205 execute_command (&run
[0], 0 /* from_tty */ );
2210 mi_execute_async_cli_command (const char *cli_command
, char **argv
, int argc
)
2212 std::string run
= cli_command
;
2215 run
= run
+ " " + *argv
;
2219 execute_command (&run
[0], 0 /* from_tty */ );
2223 mi_load_progress (const char *section_name
,
2224 unsigned long sent_so_far
,
2225 unsigned long total_section
,
2226 unsigned long total_sent
,
2227 unsigned long grand_total
)
2229 using namespace std::chrono
;
2230 static steady_clock::time_point last_update
;
2231 static char *previous_sect_name
= NULL
;
2233 struct mi_interp
*mi
= (struct mi_interp
*) current_interpreter ();
2235 /* This function is called through deprecated_show_load_progress
2236 which means uiout may not be correct. Fix it for the duration
2237 of this function. */
2239 std::unique_ptr
<ui_out
> uiout
;
2241 if (current_interp_named_p (INTERP_MI
)
2242 || current_interp_named_p (INTERP_MI2
))
2243 uiout
.reset (mi_out_new (2));
2244 else if (current_interp_named_p (INTERP_MI1
))
2245 uiout
.reset (mi_out_new (1));
2246 else if (current_interp_named_p (INTERP_MI3
))
2247 uiout
.reset (mi_out_new (3));
2251 scoped_restore save_uiout
2252 = make_scoped_restore (¤t_uiout
, uiout
.get ());
2254 new_section
= (previous_sect_name
?
2255 strcmp (previous_sect_name
, section_name
) : 1);
2258 xfree (previous_sect_name
);
2259 previous_sect_name
= xstrdup (section_name
);
2262 fputs_unfiltered (current_token
, mi
->raw_stdout
);
2263 fputs_unfiltered ("+download", mi
->raw_stdout
);
2265 ui_out_emit_tuple
tuple_emitter (uiout
.get (), NULL
);
2266 uiout
->field_string ("section", section_name
);
2267 uiout
->field_int ("section-size", total_section
);
2268 uiout
->field_int ("total-size", grand_total
);
2270 mi_out_put (uiout
.get (), mi
->raw_stdout
);
2271 fputs_unfiltered ("\n", mi
->raw_stdout
);
2272 gdb_flush (mi
->raw_stdout
);
2275 steady_clock::time_point time_now
= steady_clock::now ();
2276 if (time_now
- last_update
> milliseconds (500))
2278 last_update
= time_now
;
2280 fputs_unfiltered (current_token
, mi
->raw_stdout
);
2281 fputs_unfiltered ("+download", mi
->raw_stdout
);
2283 ui_out_emit_tuple
tuple_emitter (uiout
.get (), NULL
);
2284 uiout
->field_string ("section", section_name
);
2285 uiout
->field_int ("section-sent", sent_so_far
);
2286 uiout
->field_int ("section-size", total_section
);
2287 uiout
->field_int ("total-sent", total_sent
);
2288 uiout
->field_int ("total-size", grand_total
);
2290 mi_out_put (uiout
.get (), mi
->raw_stdout
);
2291 fputs_unfiltered ("\n", mi
->raw_stdout
);
2292 gdb_flush (mi
->raw_stdout
);
2297 timestamp (struct mi_timestamp
*tv
)
2299 using namespace std::chrono
;
2301 tv
->wallclock
= steady_clock::now ();
2302 run_time_clock::now (tv
->utime
, tv
->stime
);
2306 print_diff_now (struct ui_file
*file
, struct mi_timestamp
*start
)
2308 struct mi_timestamp now
;
2311 print_diff (file
, start
, &now
);
2315 mi_print_timing_maybe (struct ui_file
*file
)
2317 /* If the command is -enable-timing then do_timings may be true
2318 whilst current_command_ts is not initialized. */
2319 if (do_timings
&& current_command_ts
)
2320 print_diff_now (file
, current_command_ts
);
2324 print_diff (struct ui_file
*file
, struct mi_timestamp
*start
,
2325 struct mi_timestamp
*end
)
2327 using namespace std::chrono
;
2329 duration
<double> wallclock
= end
->wallclock
- start
->wallclock
;
2330 duration
<double> utime
= end
->utime
- start
->utime
;
2331 duration
<double> stime
= end
->stime
- start
->stime
;
2335 ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
2336 wallclock
.count (), utime
.count (), stime
.count ());
2340 mi_cmd_trace_define_variable (const char *command
, char **argv
, int argc
)
2342 LONGEST initval
= 0;
2343 struct trace_state_variable
*tsv
;
2346 if (argc
!= 1 && argc
!= 2)
2347 error (_("Usage: -trace-define-variable VARIABLE [VALUE]"));
2351 error (_("Name of trace variable should start with '$'"));
2353 validate_trace_state_variable_name (name
);
2355 tsv
= find_trace_state_variable (name
);
2357 tsv
= create_trace_state_variable (name
);
2360 initval
= value_as_long (parse_and_eval (argv
[1]));
2362 tsv
->initial_value
= initval
;
2366 mi_cmd_trace_list_variables (const char *command
, char **argv
, int argc
)
2369 error (_("-trace-list-variables: no arguments allowed"));
2371 tvariables_info_1 ();
2375 mi_cmd_trace_find (const char *command
, char **argv
, int argc
)
2380 error (_("trace selection mode is required"));
2384 if (strcmp (mode
, "none") == 0)
2386 tfind_1 (tfind_number
, -1, 0, 0, 0);
2390 check_trace_running (current_trace_status ());
2392 if (strcmp (mode
, "frame-number") == 0)
2395 error (_("frame number is required"));
2396 tfind_1 (tfind_number
, atoi (argv
[1]), 0, 0, 0);
2398 else if (strcmp (mode
, "tracepoint-number") == 0)
2401 error (_("tracepoint number is required"));
2402 tfind_1 (tfind_tp
, atoi (argv
[1]), 0, 0, 0);
2404 else if (strcmp (mode
, "pc") == 0)
2407 error (_("PC is required"));
2408 tfind_1 (tfind_pc
, 0, parse_and_eval_address (argv
[1]), 0, 0);
2410 else if (strcmp (mode
, "pc-inside-range") == 0)
2413 error (_("Start and end PC are required"));
2414 tfind_1 (tfind_range
, 0, parse_and_eval_address (argv
[1]),
2415 parse_and_eval_address (argv
[2]), 0);
2417 else if (strcmp (mode
, "pc-outside-range") == 0)
2420 error (_("Start and end PC are required"));
2421 tfind_1 (tfind_outside
, 0, parse_and_eval_address (argv
[1]),
2422 parse_and_eval_address (argv
[2]), 0);
2424 else if (strcmp (mode
, "line") == 0)
2427 error (_("Line is required"));
2429 std::vector
<symtab_and_line
> sals
2430 = decode_line_with_current_source (argv
[1],
2431 DECODE_LINE_FUNFIRSTLINE
);
2432 const symtab_and_line
&sal
= sals
[0];
2434 if (sal
.symtab
== 0)
2435 error (_("Could not find the specified line"));
2437 CORE_ADDR start_pc
, end_pc
;
2438 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2439 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, 0);
2441 error (_("Could not find the specified line"));
2444 error (_("Invalid mode '%s'"), mode
);
2446 if (has_stack_frames () || get_traceframe_number () >= 0)
2447 print_stack_frame (get_selected_frame (NULL
), 1, LOC_AND_ADDRESS
, 1);
2451 mi_cmd_trace_save (const char *command
, char **argv
, int argc
)
2453 int target_saves
= 0;
2454 int generate_ctf
= 0;
2461 TARGET_SAVE_OPT
, CTF_OPT
2463 static const struct mi_opt opts
[] =
2465 {"r", TARGET_SAVE_OPT
, 0},
2466 {"ctf", CTF_OPT
, 0},
2472 int opt
= mi_getopt ("-trace-save", argc
, argv
, opts
,
2477 switch ((enum opt
) opt
)
2479 case TARGET_SAVE_OPT
:
2488 if (argc
- oind
!= 1)
2489 error (_("Exactly one argument required "
2490 "(file in which to save trace data)"));
2492 filename
= argv
[oind
];
2495 trace_save_ctf (filename
, target_saves
);
2497 trace_save_tfile (filename
, target_saves
);
2501 mi_cmd_trace_start (const char *command
, char **argv
, int argc
)
2503 start_tracing (NULL
);
2507 mi_cmd_trace_status (const char *command
, char **argv
, int argc
)
2509 trace_status_mi (0);
2513 mi_cmd_trace_stop (const char *command
, char **argv
, int argc
)
2515 stop_tracing (NULL
);
2516 trace_status_mi (1);
2519 /* Implement the "-ada-task-info" command. */
2522 mi_cmd_ada_task_info (const char *command
, char **argv
, int argc
)
2524 if (argc
!= 0 && argc
!= 1)
2525 error (_("Invalid MI command"));
2527 print_ada_task_info (current_uiout
, argv
[0], current_inferior ());
2530 /* Print EXPRESSION according to VALUES. */
2533 print_variable_or_computed (const char *expression
, enum print_values values
)
2537 struct ui_out
*uiout
= current_uiout
;
2541 expression_up expr
= parse_expression (expression
);
2543 if (values
== PRINT_SIMPLE_VALUES
)
2544 val
= evaluate_type (expr
.get ());
2546 val
= evaluate_expression (expr
.get ());
2548 gdb::optional
<ui_out_emit_tuple
> tuple_emitter
;
2549 if (values
!= PRINT_NO_VALUES
)
2550 tuple_emitter
.emplace (uiout
, nullptr);
2551 uiout
->field_string ("name", expression
);
2555 case PRINT_SIMPLE_VALUES
:
2556 type
= check_typedef (value_type (val
));
2557 type_print (value_type (val
), "", &stb
, -1);
2558 uiout
->field_stream ("type", stb
);
2559 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
2560 && TYPE_CODE (type
) != TYPE_CODE_STRUCT
2561 && TYPE_CODE (type
) != TYPE_CODE_UNION
)
2563 struct value_print_options opts
;
2565 get_no_prettyformat_print_options (&opts
);
2567 common_val_print (val
, &stb
, 0, &opts
, current_language
);
2568 uiout
->field_stream ("value", stb
);
2571 case PRINT_ALL_VALUES
:
2573 struct value_print_options opts
;
2575 get_no_prettyformat_print_options (&opts
);
2577 common_val_print (val
, &stb
, 0, &opts
, current_language
);
2578 uiout
->field_stream ("value", stb
);
2584 /* Implement the "-trace-frame-collected" command. */
2587 mi_cmd_trace_frame_collected (const char *command
, char **argv
, int argc
)
2589 struct bp_location
*tloc
;
2591 struct collection_list
*clist
;
2592 struct collection_list tracepoint_list
, stepping_list
;
2593 struct traceframe_info
*tinfo
;
2595 enum print_values var_print_values
= PRINT_ALL_VALUES
;
2596 enum print_values comp_print_values
= PRINT_ALL_VALUES
;
2597 int registers_format
= 'x';
2598 int memory_contents
= 0;
2599 struct ui_out
*uiout
= current_uiout
;
2607 static const struct mi_opt opts
[] =
2609 {"-var-print-values", VAR_PRINT_VALUES
, 1},
2610 {"-comp-print-values", COMP_PRINT_VALUES
, 1},
2611 {"-registers-format", REGISTERS_FORMAT
, 1},
2612 {"-memory-contents", MEMORY_CONTENTS
, 0},
2619 int opt
= mi_getopt ("-trace-frame-collected", argc
, argv
, opts
,
2623 switch ((enum opt
) opt
)
2625 case VAR_PRINT_VALUES
:
2626 var_print_values
= mi_parse_print_values (oarg
);
2628 case COMP_PRINT_VALUES
:
2629 comp_print_values
= mi_parse_print_values (oarg
);
2631 case REGISTERS_FORMAT
:
2632 registers_format
= oarg
[0];
2633 case MEMORY_CONTENTS
:
2634 memory_contents
= 1;
2640 error (_("Usage: -trace-frame-collected "
2641 "[--var-print-values PRINT_VALUES] "
2642 "[--comp-print-values PRINT_VALUES] "
2643 "[--registers-format FORMAT]"
2644 "[--memory-contents]"));
2646 /* This throws an error is not inspecting a trace frame. */
2647 tloc
= get_traceframe_location (&stepping_frame
);
2649 /* This command only makes sense for the current frame, not the
2651 scoped_restore_current_thread restore_thread
;
2652 select_frame (get_current_frame ());
2654 encode_actions (tloc
, &tracepoint_list
, &stepping_list
);
2657 clist
= &stepping_list
;
2659 clist
= &tracepoint_list
;
2661 tinfo
= get_traceframe_info ();
2663 /* Explicitly wholly collected variables. */
2667 ui_out_emit_list
list_emitter (uiout
, "explicit-variables");
2668 const std::vector
<std::string
> &wholly_collected
2669 = clist
->wholly_collected ();
2670 for (size_t i
= 0; i
< wholly_collected
.size (); i
++)
2672 const std::string
&str
= wholly_collected
[i
];
2673 print_variable_or_computed (str
.c_str (), var_print_values
);
2677 /* Computed expressions. */
2682 ui_out_emit_list
list_emitter (uiout
, "computed-expressions");
2684 const std::vector
<std::string
> &computed
= clist
->computed ();
2685 for (size_t i
= 0; i
< computed
.size (); i
++)
2687 const std::string
&str
= computed
[i
];
2688 print_variable_or_computed (str
.c_str (), comp_print_values
);
2692 /* Registers. Given pseudo-registers, and that some architectures
2693 (like MIPS) actually hide the raw registers, we don't go through
2694 the trace frame info, but instead consult the register cache for
2695 register availability. */
2697 struct frame_info
*frame
;
2698 struct gdbarch
*gdbarch
;
2702 ui_out_emit_list
list_emitter (uiout
, "registers");
2704 frame
= get_selected_frame (NULL
);
2705 gdbarch
= get_frame_arch (frame
);
2706 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
2708 for (regnum
= 0; regnum
< numregs
; regnum
++)
2710 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
2711 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
2714 output_register (frame
, regnum
, registers_format
, 1);
2718 /* Trace state variables. */
2723 ui_out_emit_list
list_emitter (uiout
, "tvars");
2725 for (i
= 0; VEC_iterate (int, tinfo
->tvars
, i
, tvar
); i
++)
2727 struct trace_state_variable
*tsv
;
2729 tsv
= find_trace_state_variable_by_number (tvar
);
2731 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
2735 uiout
->field_fmt ("name", "$%s", tsv
->name
);
2737 tsv
->value_known
= target_get_trace_state_variable_value (tsv
->number
,
2739 uiout
->field_int ("current", tsv
->value
);
2743 uiout
->field_skip ("name");
2744 uiout
->field_skip ("current");
2751 struct cleanup
*cleanups
;
2752 VEC(mem_range_s
) *available_memory
= NULL
;
2753 struct mem_range
*r
;
2756 traceframe_available_memory (&available_memory
, 0, ULONGEST_MAX
);
2757 cleanups
= make_cleanup (VEC_cleanup(mem_range_s
), &available_memory
);
2759 ui_out_emit_list
list_emitter (uiout
, "memory");
2761 for (i
= 0; VEC_iterate (mem_range_s
, available_memory
, i
, r
); i
++)
2763 struct gdbarch
*gdbarch
= target_gdbarch ();
2765 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
2767 uiout
->field_core_addr ("address", gdbarch
, r
->start
);
2768 uiout
->field_int ("length", r
->length
);
2770 gdb::byte_vector
data (r
->length
);
2772 if (memory_contents
)
2774 if (target_read_memory (r
->start
, data
.data (), r
->length
) == 0)
2776 std::string data_str
= bin2hex (data
.data (), r
->length
);
2777 uiout
->field_string ("contents", data_str
.c_str ());
2780 uiout
->field_skip ("contents");
2784 do_cleanups (cleanups
);
2789 _initialize_mi_main (void)
2791 struct cmd_list_element
*c
;
2793 add_setshow_boolean_cmd ("mi-async", class_run
,
2795 Set whether MI asynchronous mode is enabled."), _("\
2796 Show whether MI asynchronous mode is enabled."), _("\
2797 Tells GDB whether MI should be in asynchronous mode."),
2798 set_mi_async_command
,
2799 show_mi_async_command
,
2803 /* Alias old "target-async" to "mi-async". */
2804 c
= add_alias_cmd ("target-async", "mi-async", class_run
, 0, &setlist
);
2805 deprecate_cmd (c
, "set mi-async");
2806 c
= add_alias_cmd ("target-async", "mi-async", class_run
, 0, &showlist
);
2807 deprecate_cmd (c
, "show mi-async");