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 "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 free_splay_tree (void *xt
)
725 splay_tree t
= (splay_tree
) xt
;
726 splay_tree_delete (t
);
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 splay_tree tree
= NULL
;
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
= splay_tree_new (splay_tree_int_comparator
,
755 free_vector_of_osdata_items
);
756 make_cleanup (free_splay_tree
, tree
);
759 VEC_iterate (osdata_item_s
, threads
->items
,
763 const char *pid
= get_osdata_column (item
, "pid");
764 int pid_i
= strtoul (pid
, NULL
, 0);
765 VEC (osdata_item_s
) *vec
= 0;
767 splay_tree_node n
= splay_tree_lookup (tree
, pid_i
);
770 VEC_safe_push (osdata_item_s
, vec
, item
);
771 splay_tree_insert (tree
, pid_i
, (splay_tree_value
)vec
);
775 vec
= (VEC (osdata_item_s
) *) n
->value
;
776 VEC_safe_push (osdata_item_s
, vec
, item
);
777 n
->value
= (splay_tree_value
) vec
;
782 ui_out_emit_list
list_emitter (uiout
, "groups");
785 VEC_iterate (osdata_item_s
, data
->items
,
789 const char *pid
= get_osdata_column (item
, "pid");
790 const char *cmd
= get_osdata_column (item
, "command");
791 const char *user
= get_osdata_column (item
, "user");
792 const char *cores
= get_osdata_column (item
, "cores");
794 int pid_i
= strtoul (pid
, NULL
, 0);
796 /* At present, the target will return all available processes
797 and if information about specific ones was required, we filter
798 undesired processes here. */
799 if (!ids
.empty () && ids
.find (pid_i
) == ids
.end ())
802 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
804 uiout
->field_fmt ("id", "%s", pid
);
805 uiout
->field_string ("type", "process");
807 uiout
->field_string ("description", cmd
);
809 uiout
->field_string ("user", user
);
811 output_cores (uiout
, "cores", cores
);
815 splay_tree_node n
= splay_tree_lookup (tree
, pid_i
);
818 VEC (osdata_item_s
) *children
= (VEC (osdata_item_s
) *) n
->value
;
819 struct osdata_item
*child
;
822 ui_out_emit_list
thread_list_emitter (uiout
, "threads");
825 VEC_iterate (osdata_item_s
, children
, ix_child
, child
);
828 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
829 const char *tid
= get_osdata_column (child
, "tid");
830 const char *tcore
= get_osdata_column (child
, "core");
832 uiout
->field_string ("id", tid
);
834 uiout
->field_string ("core", tcore
);
840 do_cleanups (cleanup
);
844 mi_cmd_list_thread_groups (const char *command
, char **argv
, int argc
)
846 struct ui_out
*uiout
= current_uiout
;
853 AVAILABLE_OPT
, RECURSE_OPT
855 static const struct mi_opt opts
[] =
857 {"-available", AVAILABLE_OPT
, 0},
858 {"-recurse", RECURSE_OPT
, 1},
867 int opt
= mi_getopt ("-list-thread-groups", argc
, argv
, opts
,
872 switch ((enum opt
) opt
)
878 if (strcmp (oarg
, "0") == 0)
880 else if (strcmp (oarg
, "1") == 0)
883 error (_("only '0' and '1' are valid values "
884 "for the '--recurse' option"));
889 for (; oind
< argc
; ++oind
)
894 if (*(argv
[oind
]) != 'i')
895 error (_("invalid syntax of group id '%s'"), argv
[oind
]);
897 inf
= strtoul (argv
[oind
] + 1, &end
, 0);
900 error (_("invalid syntax of group id '%s'"), argv
[oind
]);
906 list_available_thread_groups (ids
, recurse
);
908 else if (ids
.size () == 1)
910 /* Local thread groups, single id. */
911 int id
= *(ids
.begin ());
912 struct inferior
*inf
= find_inferior_id (id
);
915 error (_("Non-existent thread group id '%d'"), id
);
917 print_thread_info (uiout
, NULL
, inf
->pid
);
921 struct print_one_inferior_data data
;
923 data
.recurse
= recurse
;
924 data
.inferiors
= &ids
;
926 /* Local thread groups. Either no explicit ids -- and we
927 print everything, or several explicit ids. In both cases,
928 we print more than one group, and have to use 'groups'
929 as the top-level element. */
930 ui_out_emit_list
list_emitter (uiout
, "groups");
931 update_thread_list ();
932 iterate_over_inferiors (print_one_inferior
, &data
);
937 mi_cmd_data_list_register_names (const char *command
, char **argv
, int argc
)
939 struct gdbarch
*gdbarch
;
940 struct ui_out
*uiout
= current_uiout
;
944 /* Note that the test for a valid register must include checking the
945 gdbarch_register_name because gdbarch_num_regs may be allocated
946 for the union of the register sets within a family of related
947 processors. In this case, some entries of gdbarch_register_name
948 will change depending upon the particular processor being
951 gdbarch
= get_current_arch ();
952 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
954 ui_out_emit_list
list_emitter (uiout
, "register-names");
956 if (argc
== 0) /* No args, just do all the regs. */
962 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
963 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
964 uiout
->field_string (NULL
, "");
966 uiout
->field_string (NULL
, gdbarch_register_name (gdbarch
, regnum
));
970 /* Else, list of register #s, just do listed regs. */
971 for (i
= 0; i
< argc
; i
++)
973 regnum
= atoi (argv
[i
]);
974 if (regnum
< 0 || regnum
>= numregs
)
975 error (_("bad register number"));
977 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
978 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
979 uiout
->field_string (NULL
, "");
981 uiout
->field_string (NULL
, gdbarch_register_name (gdbarch
, regnum
));
986 mi_cmd_data_list_changed_registers (const char *command
, char **argv
, int argc
)
988 static std::unique_ptr
<struct regcache
> this_regs
;
989 struct ui_out
*uiout
= current_uiout
;
990 std::unique_ptr
<struct regcache
> prev_regs
;
991 struct gdbarch
*gdbarch
;
992 int regnum
, numregs
, changed
;
995 /* The last time we visited this function, the current frame's
996 register contents were saved in THIS_REGS. Move THIS_REGS over
997 to PREV_REGS, and refresh THIS_REGS with the now-current register
1000 prev_regs
= std::move (this_regs
);
1001 this_regs
= frame_save_as_regcache (get_selected_frame (NULL
));
1003 /* Note that the test for a valid register must include checking the
1004 gdbarch_register_name because gdbarch_num_regs may be allocated
1005 for the union of the register sets within a family of related
1006 processors. In this case, some entries of gdbarch_register_name
1007 will change depending upon the particular processor being
1010 gdbarch
= get_regcache_arch (this_regs
.get ());
1011 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1013 ui_out_emit_list
list_emitter (uiout
, "changed-registers");
1017 /* No args, just do all the regs. */
1022 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1023 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1025 changed
= register_changed_p (regnum
, prev_regs
.get (),
1028 error (_("-data-list-changed-registers: "
1029 "Unable to read register contents."));
1031 uiout
->field_int (NULL
, regnum
);
1035 /* Else, list of register #s, just do listed regs. */
1036 for (i
= 0; i
< argc
; i
++)
1038 regnum
= atoi (argv
[i
]);
1042 && gdbarch_register_name (gdbarch
, regnum
) != NULL
1043 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
1045 changed
= register_changed_p (regnum
, prev_regs
.get (),
1048 error (_("-data-list-changed-registers: "
1049 "Unable to read register contents."));
1051 uiout
->field_int (NULL
, regnum
);
1054 error (_("bad register number"));
1059 register_changed_p (int regnum
, struct regcache
*prev_regs
,
1060 struct regcache
*this_regs
)
1062 struct gdbarch
*gdbarch
= get_regcache_arch (this_regs
);
1063 struct value
*prev_value
, *this_value
;
1066 /* First time through or after gdbarch change consider all registers
1068 if (!prev_regs
|| get_regcache_arch (prev_regs
) != gdbarch
)
1071 /* Get register contents and compare. */
1072 prev_value
= prev_regs
->cooked_read_value (regnum
);
1073 this_value
= this_regs
->cooked_read_value (regnum
);
1074 gdb_assert (prev_value
!= NULL
);
1075 gdb_assert (this_value
!= NULL
);
1077 ret
= value_contents_eq (prev_value
, 0, this_value
, 0,
1078 register_size (gdbarch
, regnum
)) == 0;
1080 release_value (prev_value
);
1081 release_value (this_value
);
1082 value_free (prev_value
);
1083 value_free (this_value
);
1087 /* Return a list of register number and value pairs. The valid
1088 arguments expected are: a letter indicating the format in which to
1089 display the registers contents. This can be one of: x
1090 (hexadecimal), d (decimal), N (natural), t (binary), o (octal), r
1091 (raw). After the format argument there can be a sequence of
1092 numbers, indicating which registers to fetch the content of. If
1093 the format is the only argument, a list of all the registers with
1094 their values is returned. */
1097 mi_cmd_data_list_register_values (const char *command
, char **argv
, int argc
)
1099 struct ui_out
*uiout
= current_uiout
;
1100 struct frame_info
*frame
;
1101 struct gdbarch
*gdbarch
;
1102 int regnum
, numregs
, format
;
1104 int skip_unavailable
= 0;
1110 static const struct mi_opt opts
[] =
1112 {"-skip-unavailable", SKIP_UNAVAILABLE
, 0},
1116 /* Note that the test for a valid register must include checking the
1117 gdbarch_register_name because gdbarch_num_regs may be allocated
1118 for the union of the register sets within a family of related
1119 processors. In this case, some entries of gdbarch_register_name
1120 will change depending upon the particular processor being
1126 int opt
= mi_getopt ("-data-list-register-values", argc
, argv
,
1127 opts
, &oind
, &oarg
);
1131 switch ((enum opt
) opt
)
1133 case SKIP_UNAVAILABLE
:
1134 skip_unavailable
= 1;
1139 if (argc
- oind
< 1)
1140 error (_("-data-list-register-values: Usage: "
1141 "-data-list-register-values [--skip-unavailable] <format>"
1142 " [<regnum1>...<regnumN>]"));
1144 format
= (int) argv
[oind
][0];
1146 frame
= get_selected_frame (NULL
);
1147 gdbarch
= get_frame_arch (frame
);
1148 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1150 ui_out_emit_list
list_emitter (uiout
, "register-values");
1152 if (argc
- oind
== 1)
1154 /* No args, beside the format: do all the regs. */
1159 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1160 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1163 output_register (frame
, regnum
, format
, skip_unavailable
);
1167 /* Else, list of register #s, just do listed regs. */
1168 for (i
= 1 + oind
; i
< argc
; i
++)
1170 regnum
= atoi (argv
[i
]);
1174 && gdbarch_register_name (gdbarch
, regnum
) != NULL
1175 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
1176 output_register (frame
, regnum
, format
, skip_unavailable
);
1178 error (_("bad register number"));
1182 /* Output one register REGNUM's contents in the desired FORMAT. If
1183 SKIP_UNAVAILABLE is true, skip the register if it is
1187 output_register (struct frame_info
*frame
, int regnum
, int format
,
1188 int skip_unavailable
)
1190 struct ui_out
*uiout
= current_uiout
;
1191 struct value
*val
= value_of_register (regnum
, frame
);
1192 struct value_print_options opts
;
1194 if (skip_unavailable
&& !value_entirely_available (val
))
1197 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1198 uiout
->field_int ("number", regnum
);
1208 get_formatted_print_options (&opts
, format
);
1210 val_print (value_type (val
),
1211 value_embedded_offset (val
), 0,
1212 &stb
, 0, val
, &opts
, current_language
);
1213 uiout
->field_stream ("value", stb
);
1216 /* Write given values into registers. The registers and values are
1217 given as pairs. The corresponding MI command is
1218 -data-write-register-values <format>
1219 [<regnum1> <value1>...<regnumN> <valueN>] */
1221 mi_cmd_data_write_register_values (const char *command
, char **argv
, int argc
)
1223 struct regcache
*regcache
;
1224 struct gdbarch
*gdbarch
;
1227 /* Note that the test for a valid register must include checking the
1228 gdbarch_register_name because gdbarch_num_regs may be allocated
1229 for the union of the register sets within a family of related
1230 processors. In this case, some entries of gdbarch_register_name
1231 will change depending upon the particular processor being
1234 regcache
= get_current_regcache ();
1235 gdbarch
= get_regcache_arch (regcache
);
1236 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1239 error (_("-data-write-register-values: Usage: -data-write-register-"
1240 "values <format> [<regnum1> <value1>...<regnumN> <valueN>]"));
1242 if (!target_has_registers
)
1243 error (_("-data-write-register-values: No registers."));
1246 error (_("-data-write-register-values: No regs and values specified."));
1249 error (_("-data-write-register-values: "
1250 "Regs and vals are not in pairs."));
1252 for (i
= 1; i
< argc
; i
= i
+ 2)
1254 int regnum
= atoi (argv
[i
]);
1256 if (regnum
>= 0 && regnum
< numregs
1257 && gdbarch_register_name (gdbarch
, regnum
)
1258 && *gdbarch_register_name (gdbarch
, regnum
))
1262 /* Get the value as a number. */
1263 value
= parse_and_eval_address (argv
[i
+ 1]);
1265 /* Write it down. */
1266 regcache_cooked_write_signed (regcache
, regnum
, value
);
1269 error (_("bad register number"));
1273 /* Evaluate the value of the argument. The argument is an
1274 expression. If the expression contains spaces it needs to be
1275 included in double quotes. */
1278 mi_cmd_data_evaluate_expression (const char *command
, char **argv
, int argc
)
1281 struct value_print_options opts
;
1282 struct ui_out
*uiout
= current_uiout
;
1285 error (_("-data-evaluate-expression: "
1286 "Usage: -data-evaluate-expression expression"));
1288 expression_up expr
= parse_expression (argv
[0]);
1290 val
= evaluate_expression (expr
.get ());
1294 /* Print the result of the expression evaluation. */
1295 get_user_print_options (&opts
);
1297 common_val_print (val
, &stb
, 0, &opts
, current_language
);
1299 uiout
->field_stream ("value", stb
);
1302 /* This is the -data-read-memory command.
1304 ADDR: start address of data to be dumped.
1305 WORD-FORMAT: a char indicating format for the ``word''. See
1307 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes.
1308 NR_ROW: Number of rows.
1309 NR_COL: The number of colums (words per row).
1310 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
1311 ASCHAR for unprintable characters.
1313 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
1314 displayes them. Returns:
1316 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
1319 The number of bytes read is SIZE*ROW*COL. */
1322 mi_cmd_data_read_memory (const char *command
, char **argv
, int argc
)
1324 struct gdbarch
*gdbarch
= get_current_arch ();
1325 struct ui_out
*uiout
= current_uiout
;
1327 long total_bytes
, nr_cols
, nr_rows
;
1329 struct type
*word_type
;
1341 static const struct mi_opt opts
[] =
1343 {"o", OFFSET_OPT
, 1},
1349 int opt
= mi_getopt ("-data-read-memory", argc
, argv
, opts
,
1354 switch ((enum opt
) opt
)
1357 offset
= atol (oarg
);
1364 if (argc
< 5 || argc
> 6)
1365 error (_("-data-read-memory: Usage: "
1366 "ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR]."));
1368 /* Extract all the arguments. */
1370 /* Start address of the memory dump. */
1371 addr
= parse_and_eval_address (argv
[0]) + offset
;
1372 /* The format character to use when displaying a memory word. See
1373 the ``x'' command. */
1374 word_format
= argv
[1][0];
1375 /* The size of the memory word. */
1376 word_size
= atol (argv
[2]);
1380 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1384 word_type
= builtin_type (gdbarch
)->builtin_int16
;
1388 word_type
= builtin_type (gdbarch
)->builtin_int32
;
1392 word_type
= builtin_type (gdbarch
)->builtin_int64
;
1396 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1399 /* The number of rows. */
1400 nr_rows
= atol (argv
[3]);
1402 error (_("-data-read-memory: invalid number of rows."));
1404 /* Number of bytes per row. */
1405 nr_cols
= atol (argv
[4]);
1407 error (_("-data-read-memory: invalid number of columns."));
1409 /* The un-printable character when printing ascii. */
1415 /* Create a buffer and read it in. */
1416 total_bytes
= word_size
* nr_rows
* nr_cols
;
1418 gdb::byte_vector
mbuf (total_bytes
);
1420 /* Dispatch memory reads to the topmost target, not the flattened
1422 nr_bytes
= target_read (current_target
.beneath
,
1423 TARGET_OBJECT_MEMORY
, NULL
, mbuf
.data (),
1426 error (_("Unable to read memory."));
1428 /* Output the header information. */
1429 uiout
->field_core_addr ("addr", gdbarch
, addr
);
1430 uiout
->field_int ("nr-bytes", nr_bytes
);
1431 uiout
->field_int ("total-bytes", total_bytes
);
1432 uiout
->field_core_addr ("next-row", gdbarch
, addr
+ word_size
* nr_cols
);
1433 uiout
->field_core_addr ("prev-row", gdbarch
, addr
- word_size
* nr_cols
);
1434 uiout
->field_core_addr ("next-page", gdbarch
, addr
+ total_bytes
);
1435 uiout
->field_core_addr ("prev-page", gdbarch
, addr
- total_bytes
);
1437 /* Build the result as a two dimentional table. */
1444 ui_out_emit_list
list_emitter (uiout
, "memory");
1445 for (row
= 0, row_byte
= 0;
1447 row
++, row_byte
+= nr_cols
* word_size
)
1451 struct value_print_options opts
;
1453 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1454 uiout
->field_core_addr ("addr", gdbarch
, addr
+ row_byte
);
1455 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr +
1458 ui_out_emit_list
list_data_emitter (uiout
, "data");
1459 get_formatted_print_options (&opts
, word_format
);
1460 for (col
= 0, col_byte
= row_byte
;
1462 col
++, col_byte
+= word_size
)
1464 if (col_byte
+ word_size
> nr_bytes
)
1466 uiout
->field_string (NULL
, "N/A");
1471 print_scalar_formatted (&mbuf
[col_byte
], word_type
, &opts
,
1472 word_asize
, &stream
);
1473 uiout
->field_stream (NULL
, stream
);
1483 for (byte
= row_byte
;
1484 byte
< row_byte
+ word_size
* nr_cols
; byte
++)
1486 if (byte
>= nr_bytes
)
1488 else if (mbuf
[byte
] < 32 || mbuf
[byte
] > 126)
1489 stream
.putc (aschar
);
1491 stream
.putc (mbuf
[byte
]);
1493 uiout
->field_stream ("ascii", stream
);
1500 mi_cmd_data_read_memory_bytes (const char *command
, char **argv
, int argc
)
1502 struct gdbarch
*gdbarch
= get_current_arch ();
1503 struct ui_out
*uiout
= current_uiout
;
1507 int unit_size
= gdbarch_addressable_memory_unit_size (gdbarch
);
1514 static const struct mi_opt opts
[] =
1516 {"o", OFFSET_OPT
, 1},
1522 int opt
= mi_getopt ("-data-read-memory-bytes", argc
, argv
, opts
,
1526 switch ((enum opt
) opt
)
1529 offset
= atol (oarg
);
1537 error (_("Usage: [ -o OFFSET ] ADDR LENGTH."));
1539 addr
= parse_and_eval_address (argv
[0]) + offset
;
1540 length
= atol (argv
[1]);
1542 std::vector
<memory_read_result
> result
1543 = read_memory_robust (current_target
.beneath
, addr
, length
);
1545 if (result
.size () == 0)
1546 error (_("Unable to read memory."));
1548 ui_out_emit_list
list_emitter (uiout
, "memory");
1549 for (const memory_read_result
&read_result
: result
)
1551 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1553 uiout
->field_core_addr ("begin", gdbarch
, read_result
.begin
);
1554 uiout
->field_core_addr ("offset", gdbarch
, read_result
.begin
- addr
);
1555 uiout
->field_core_addr ("end", gdbarch
, read_result
.end
);
1557 std::string data
= bin2hex (read_result
.data
.get (),
1558 (read_result
.end
- read_result
.begin
)
1560 uiout
->field_string ("contents", data
.c_str ());
1564 /* Implementation of the -data-write_memory command.
1566 COLUMN_OFFSET: optional argument. Must be preceded by '-o'. The
1567 offset from the beginning of the memory grid row where the cell to
1569 ADDR: start address of the row in the memory grid where the memory
1570 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
1571 the location to write to.
1572 FORMAT: a char indicating format for the ``word''. See
1574 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
1575 VALUE: value to be written into the memory address.
1577 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
1582 mi_cmd_data_write_memory (const char *command
, char **argv
, int argc
)
1584 struct gdbarch
*gdbarch
= get_current_arch ();
1585 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1588 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
1589 enough when using a compiler other than GCC. */
1598 static const struct mi_opt opts
[] =
1600 {"o", OFFSET_OPT
, 1},
1606 int opt
= mi_getopt ("-data-write-memory", argc
, argv
, opts
,
1611 switch ((enum opt
) opt
)
1614 offset
= atol (oarg
);
1622 error (_("-data-write-memory: Usage: "
1623 "[-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE."));
1625 /* Extract all the arguments. */
1626 /* Start address of the memory dump. */
1627 addr
= parse_and_eval_address (argv
[0]);
1628 /* The size of the memory word. */
1629 word_size
= atol (argv
[2]);
1631 /* Calculate the real address of the write destination. */
1632 addr
+= (offset
* word_size
);
1634 /* Get the value as a number. */
1635 value
= parse_and_eval_address (argv
[3]);
1636 /* Get the value into an array. */
1637 gdb::byte_vector
buffer (word_size
);
1638 store_signed_integer (buffer
.data (), word_size
, byte_order
, value
);
1639 /* Write it down to memory. */
1640 write_memory_with_notification (addr
, buffer
.data (), word_size
);
1643 /* Implementation of the -data-write-memory-bytes command.
1646 DATA: string of bytes to write at that address
1647 COUNT: number of bytes to be filled (decimal integer). */
1650 mi_cmd_data_write_memory_bytes (const char *command
, char **argv
, int argc
)
1654 size_t len_hex
, len_bytes
, len_units
, i
, steps
, remaining_units
;
1655 long int count_units
;
1658 if (argc
!= 2 && argc
!= 3)
1659 error (_("Usage: ADDR DATA [COUNT]."));
1661 addr
= parse_and_eval_address (argv
[0]);
1663 len_hex
= strlen (cdata
);
1664 unit_size
= gdbarch_addressable_memory_unit_size (get_current_arch ());
1666 if (len_hex
% (unit_size
* 2) != 0)
1667 error (_("Hex-encoded '%s' must represent an integral number of "
1668 "addressable memory units."),
1671 len_bytes
= len_hex
/ 2;
1672 len_units
= len_bytes
/ unit_size
;
1675 count_units
= strtoul (argv
[2], NULL
, 10);
1677 count_units
= len_units
;
1679 gdb::byte_vector
databuf (len_bytes
);
1681 for (i
= 0; i
< len_bytes
; ++i
)
1684 if (sscanf (cdata
+ i
* 2, "%02x", &x
) != 1)
1685 error (_("Invalid argument"));
1686 databuf
[i
] = (gdb_byte
) x
;
1689 gdb::byte_vector data
;
1690 if (len_units
< count_units
)
1692 /* Pattern is made of less units than count:
1693 repeat pattern to fill memory. */
1694 data
= gdb::byte_vector (count_units
* unit_size
);
1696 /* Number of times the pattern is entirely repeated. */
1697 steps
= count_units
/ len_units
;
1698 /* Number of remaining addressable memory units. */
1699 remaining_units
= count_units
% len_units
;
1700 for (i
= 0; i
< steps
; i
++)
1701 memcpy (&data
[i
* len_bytes
], &databuf
[0], len_bytes
);
1703 if (remaining_units
> 0)
1704 memcpy (&data
[steps
* len_bytes
], &databuf
[0],
1705 remaining_units
* unit_size
);
1709 /* Pattern is longer than or equal to count:
1710 just copy count addressable memory units. */
1711 data
= std::move (databuf
);
1714 write_memory_with_notification (addr
, data
.data (), count_units
);
1718 mi_cmd_enable_timings (const char *command
, char **argv
, int argc
)
1724 if (strcmp (argv
[0], "yes") == 0)
1726 else if (strcmp (argv
[0], "no") == 0)
1737 error (_("-enable-timings: Usage: %s {yes|no}"), command
);
1741 mi_cmd_list_features (const char *command
, char **argv
, int argc
)
1745 struct ui_out
*uiout
= current_uiout
;
1747 ui_out_emit_list
list_emitter (uiout
, "features");
1748 uiout
->field_string (NULL
, "frozen-varobjs");
1749 uiout
->field_string (NULL
, "pending-breakpoints");
1750 uiout
->field_string (NULL
, "thread-info");
1751 uiout
->field_string (NULL
, "data-read-memory-bytes");
1752 uiout
->field_string (NULL
, "breakpoint-notifications");
1753 uiout
->field_string (NULL
, "ada-task-info");
1754 uiout
->field_string (NULL
, "language-option");
1755 uiout
->field_string (NULL
, "info-gdb-mi-command");
1756 uiout
->field_string (NULL
, "undefined-command-error-code");
1757 uiout
->field_string (NULL
, "exec-run-start-option");
1759 if (ext_lang_initialized_p (get_ext_lang_defn (EXT_LANG_PYTHON
)))
1760 uiout
->field_string (NULL
, "python");
1765 error (_("-list-features should be passed no arguments"));
1769 mi_cmd_list_target_features (const char *command
, char **argv
, int argc
)
1773 struct ui_out
*uiout
= current_uiout
;
1775 ui_out_emit_list
list_emitter (uiout
, "features");
1777 uiout
->field_string (NULL
, "async");
1778 if (target_can_execute_reverse
)
1779 uiout
->field_string (NULL
, "reverse");
1783 error (_("-list-target-features should be passed no arguments"));
1787 mi_cmd_add_inferior (const char *command
, char **argv
, int argc
)
1789 struct inferior
*inf
;
1792 error (_("-add-inferior should be passed no arguments"));
1794 inf
= add_inferior_with_spaces ();
1796 current_uiout
->field_fmt ("inferior", "i%d", inf
->num
);
1799 /* Callback used to find the first inferior other than the current
1803 get_other_inferior (struct inferior
*inf
, void *arg
)
1805 if (inf
== current_inferior ())
1812 mi_cmd_remove_inferior (const char *command
, char **argv
, int argc
)
1815 struct inferior
*inf
;
1818 error (_("-remove-inferior should be passed a single argument"));
1820 if (sscanf (argv
[0], "i%d", &id
) != 1)
1821 error (_("the thread group id is syntactically invalid"));
1823 inf
= find_inferior_id (id
);
1825 error (_("the specified thread group does not exist"));
1828 error (_("cannot remove an active inferior"));
1830 if (inf
== current_inferior ())
1832 struct thread_info
*tp
= 0;
1833 struct inferior
*new_inferior
1834 = iterate_over_inferiors (get_other_inferior
, NULL
);
1836 if (new_inferior
== NULL
)
1837 error (_("Cannot remove last inferior"));
1839 set_current_inferior (new_inferior
);
1840 if (new_inferior
->pid
!= 0)
1841 tp
= any_thread_of_process (new_inferior
->pid
);
1842 switch_to_thread (tp
? tp
->ptid
: null_ptid
);
1843 set_current_program_space (new_inferior
->pspace
);
1846 delete_inferior (inf
);
1851 /* Execute a command within a safe environment.
1852 Return <0 for error; >=0 for ok.
1854 args->action will tell mi_execute_command what action
1855 to perform after the given command has executed (display/suppress
1856 prompt, display error). */
1859 captured_mi_execute_command (struct ui_out
*uiout
, struct mi_parse
*context
)
1861 struct mi_interp
*mi
= (struct mi_interp
*) command_interp ();
1864 current_command_ts
= context
->cmd_start
;
1866 scoped_restore save_token
= make_scoped_restore (¤t_token
,
1869 running_result_record_printed
= 0;
1871 switch (context
->op
)
1874 /* A MI command was read from the input stream. */
1876 /* FIXME: gdb_???? */
1877 fprintf_unfiltered (mi
->raw_stdout
,
1878 " token=`%s' command=`%s' args=`%s'\n",
1879 context
->token
, context
->command
, context
->args
);
1881 mi_cmd_execute (context
);
1883 /* Print the result if there were no errors.
1885 Remember that on the way out of executing a command, you have
1886 to directly use the mi_interp's uiout, since the command
1887 could have reset the interpreter, in which case the current
1888 uiout will most likely crash in the mi_out_* routines. */
1889 if (!running_result_record_printed
)
1891 fputs_unfiltered (context
->token
, mi
->raw_stdout
);
1892 /* There's no particularly good reason why target-connect results
1893 in not ^done. Should kill ^connected for MI3. */
1894 fputs_unfiltered (strcmp (context
->command
, "target-select") == 0
1895 ? "^connected" : "^done", mi
->raw_stdout
);
1896 mi_out_put (uiout
, mi
->raw_stdout
);
1897 mi_out_rewind (uiout
);
1898 mi_print_timing_maybe (mi
->raw_stdout
);
1899 fputs_unfiltered ("\n", mi
->raw_stdout
);
1902 /* The command does not want anything to be printed. In that
1903 case, the command probably should not have written anything
1904 to uiout, but in case it has written something, discard it. */
1905 mi_out_rewind (uiout
);
1912 /* A CLI command was read from the input stream. */
1913 /* This "feature" will be removed as soon as we have a
1914 complete set of mi commands. */
1915 /* Echo the command on the console. */
1916 fprintf_unfiltered (gdb_stdlog
, "%s\n", context
->command
);
1917 /* Call the "console" interpreter. */
1918 argv
[0] = (char *) INTERP_CONSOLE
;
1919 argv
[1] = context
->command
;
1920 mi_cmd_interpreter_exec ("-interpreter-exec", argv
, 2);
1922 /* If we changed interpreters, DON'T print out anything. */
1923 if (current_interp_named_p (INTERP_MI
)
1924 || current_interp_named_p (INTERP_MI1
)
1925 || current_interp_named_p (INTERP_MI2
)
1926 || current_interp_named_p (INTERP_MI3
))
1928 if (!running_result_record_printed
)
1930 fputs_unfiltered (context
->token
, mi
->raw_stdout
);
1931 fputs_unfiltered ("^done", mi
->raw_stdout
);
1932 mi_out_put (uiout
, mi
->raw_stdout
);
1933 mi_out_rewind (uiout
);
1934 mi_print_timing_maybe (mi
->raw_stdout
);
1935 fputs_unfiltered ("\n", mi
->raw_stdout
);
1938 mi_out_rewind (uiout
);
1945 /* Print a gdb exception to the MI output stream. */
1948 mi_print_exception (const char *token
, struct gdb_exception exception
)
1950 struct mi_interp
*mi
= (struct mi_interp
*) current_interpreter ();
1952 fputs_unfiltered (token
, mi
->raw_stdout
);
1953 fputs_unfiltered ("^error,msg=\"", mi
->raw_stdout
);
1954 if (exception
.message
== NULL
)
1955 fputs_unfiltered ("unknown error", mi
->raw_stdout
);
1957 fputstr_unfiltered (exception
.message
, '"', mi
->raw_stdout
);
1958 fputs_unfiltered ("\"", mi
->raw_stdout
);
1960 switch (exception
.error
)
1962 case UNDEFINED_COMMAND_ERROR
:
1963 fputs_unfiltered (",code=\"undefined-command\"", mi
->raw_stdout
);
1967 fputs_unfiltered ("\n", mi
->raw_stdout
);
1970 /* Determine whether the parsed command already notifies the
1971 user_selected_context_changed observer. */
1974 command_notifies_uscc_observer (struct mi_parse
*command
)
1976 if (command
->op
== CLI_COMMAND
)
1978 /* CLI commands "thread" and "inferior" already send it. */
1979 return (strncmp (command
->command
, "thread ", 7) == 0
1980 || strncmp (command
->command
, "inferior ", 9) == 0);
1982 else /* MI_COMMAND */
1984 if (strcmp (command
->command
, "interpreter-exec") == 0
1985 && command
->argc
> 1)
1987 /* "thread" and "inferior" again, but through -interpreter-exec. */
1988 return (strncmp (command
->argv
[1], "thread ", 7) == 0
1989 || strncmp (command
->argv
[1], "inferior ", 9) == 0);
1993 /* -thread-select already sends it. */
1994 return strcmp (command
->command
, "thread-select") == 0;
1999 mi_execute_command (const char *cmd
, int from_tty
)
2002 std::unique_ptr
<struct mi_parse
> command
;
2004 /* This is to handle EOF (^D). We just quit gdb. */
2005 /* FIXME: we should call some API function here. */
2007 quit_force (NULL
, from_tty
);
2009 target_log_command (cmd
);
2013 command
= mi_parse (cmd
, &token
);
2015 CATCH (exception
, RETURN_MASK_ALL
)
2017 mi_print_exception (token
, exception
);
2022 if (command
!= NULL
)
2024 ptid_t previous_ptid
= inferior_ptid
;
2026 gdb::optional
<scoped_restore_tmpl
<int>> restore_suppress
;
2028 if (command
->cmd
!= NULL
&& command
->cmd
->suppress_notification
!= NULL
)
2029 restore_suppress
.emplace (command
->cmd
->suppress_notification
, 1);
2031 command
->token
= token
;
2035 command
->cmd_start
= new mi_timestamp ();
2036 timestamp (command
->cmd_start
);
2041 captured_mi_execute_command (current_uiout
, command
.get ());
2043 CATCH (result
, RETURN_MASK_ALL
)
2045 /* Like in start_event_loop, enable input and force display
2046 of the prompt. Otherwise, any command that calls
2047 async_disable_stdin, and then throws, will leave input
2049 async_enable_stdin ();
2050 current_ui
->prompt_state
= PROMPT_NEEDED
;
2052 /* The command execution failed and error() was called
2054 mi_print_exception (command
->token
, result
);
2055 mi_out_rewind (current_uiout
);
2059 bpstat_do_actions ();
2061 if (/* The notifications are only output when the top-level
2062 interpreter (specified on the command line) is MI. */
2063 interp_ui_out (top_level_interpreter ())->is_mi_like_p ()
2064 /* Don't try report anything if there are no threads --
2065 the program is dead. */
2066 && thread_count () != 0
2067 /* If the command already reports the thread change, no need to do it
2069 && !command_notifies_uscc_observer (command
.get ()))
2071 struct mi_interp
*mi
= (struct mi_interp
*) top_level_interpreter ();
2072 int report_change
= 0;
2074 if (command
->thread
== -1)
2076 report_change
= (!ptid_equal (previous_ptid
, null_ptid
)
2077 && !ptid_equal (inferior_ptid
, previous_ptid
)
2078 && !ptid_equal (inferior_ptid
, null_ptid
));
2080 else if (!ptid_equal (inferior_ptid
, null_ptid
))
2082 struct thread_info
*ti
= inferior_thread ();
2084 report_change
= (ti
->global_num
!= command
->thread
);
2089 observer_notify_user_selected_context_changed
2090 (USER_SELECTED_THREAD
| USER_SELECTED_FRAME
);
2097 mi_cmd_execute (struct mi_parse
*parse
)
2099 struct cleanup
*cleanup
;
2101 cleanup
= prepare_execute_command ();
2103 if (parse
->all
&& parse
->thread_group
!= -1)
2104 error (_("Cannot specify --thread-group together with --all"));
2106 if (parse
->all
&& parse
->thread
!= -1)
2107 error (_("Cannot specify --thread together with --all"));
2109 if (parse
->thread_group
!= -1 && parse
->thread
!= -1)
2110 error (_("Cannot specify --thread together with --thread-group"));
2112 if (parse
->frame
!= -1 && parse
->thread
== -1)
2113 error (_("Cannot specify --frame without --thread"));
2115 if (parse
->thread_group
!= -1)
2117 struct inferior
*inf
= find_inferior_id (parse
->thread_group
);
2118 struct thread_info
*tp
= 0;
2121 error (_("Invalid thread group for the --thread-group option"));
2123 set_current_inferior (inf
);
2124 /* This behaviour means that if --thread-group option identifies
2125 an inferior with multiple threads, then a random one will be
2126 picked. This is not a problem -- frontend should always
2127 provide --thread if it wishes to operate on a specific
2130 tp
= any_live_thread_of_process (inf
->pid
);
2131 switch_to_thread (tp
? tp
->ptid
: null_ptid
);
2132 set_current_program_space (inf
->pspace
);
2135 if (parse
->thread
!= -1)
2137 struct thread_info
*tp
= find_thread_global_id (parse
->thread
);
2140 error (_("Invalid thread id: %d"), parse
->thread
);
2142 if (is_exited (tp
->ptid
))
2143 error (_("Thread id: %d has terminated"), parse
->thread
);
2145 switch_to_thread (tp
->ptid
);
2148 if (parse
->frame
!= -1)
2150 struct frame_info
*fid
;
2151 int frame
= parse
->frame
;
2153 fid
= find_relative_frame (get_current_frame (), &frame
);
2155 /* find_relative_frame was successful */
2158 error (_("Invalid frame id: %d"), frame
);
2161 gdb::optional
<scoped_restore_current_language
> lang_saver
;
2162 if (parse
->language
!= language_unknown
)
2164 lang_saver
.emplace ();
2165 set_language (parse
->language
);
2168 current_context
= parse
;
2170 if (parse
->cmd
->argv_func
!= NULL
)
2172 parse
->cmd
->argv_func (parse
->command
, parse
->argv
, parse
->argc
);
2174 else if (parse
->cmd
->cli
.cmd
!= 0)
2176 /* FIXME: DELETE THIS. */
2177 /* The operation is still implemented by a cli command. */
2178 /* Must be a synchronous one. */
2179 mi_execute_cli_command (parse
->cmd
->cli
.cmd
, parse
->cmd
->cli
.args_p
,
2184 /* FIXME: DELETE THIS. */
2187 stb
.puts ("Undefined mi command: ");
2188 stb
.putstr (parse
->command
, '"');
2189 stb
.puts (" (missing implementation)");
2193 do_cleanups (cleanup
);
2196 /* FIXME: This is just a hack so we can get some extra commands going.
2197 We don't want to channel things through the CLI, but call libgdb directly.
2198 Use only for synchronous commands. */
2201 mi_execute_cli_command (const char *cmd
, int args_p
, const char *args
)
2205 std::string run
= cmd
;
2208 run
= run
+ " " + args
;
2210 /* FIXME: gdb_???? */
2211 fprintf_unfiltered (gdb_stdout
, "cli=%s run=%s\n",
2213 execute_command (&run
[0], 0 /* from_tty */ );
2218 mi_execute_async_cli_command (const char *cli_command
, char **argv
, int argc
)
2220 std::string run
= cli_command
;
2223 run
= run
+ " " + *argv
;
2227 execute_command (&run
[0], 0 /* from_tty */ );
2231 mi_load_progress (const char *section_name
,
2232 unsigned long sent_so_far
,
2233 unsigned long total_section
,
2234 unsigned long total_sent
,
2235 unsigned long grand_total
)
2237 using namespace std::chrono
;
2238 static steady_clock::time_point last_update
;
2239 static char *previous_sect_name
= NULL
;
2241 struct mi_interp
*mi
= (struct mi_interp
*) current_interpreter ();
2243 /* This function is called through deprecated_show_load_progress
2244 which means uiout may not be correct. Fix it for the duration
2245 of this function. */
2247 std::unique_ptr
<ui_out
> uiout
;
2249 if (current_interp_named_p (INTERP_MI
)
2250 || current_interp_named_p (INTERP_MI2
))
2251 uiout
.reset (mi_out_new (2));
2252 else if (current_interp_named_p (INTERP_MI1
))
2253 uiout
.reset (mi_out_new (1));
2254 else if (current_interp_named_p (INTERP_MI3
))
2255 uiout
.reset (mi_out_new (3));
2259 scoped_restore save_uiout
2260 = make_scoped_restore (¤t_uiout
, uiout
.get ());
2262 new_section
= (previous_sect_name
?
2263 strcmp (previous_sect_name
, section_name
) : 1);
2266 xfree (previous_sect_name
);
2267 previous_sect_name
= xstrdup (section_name
);
2270 fputs_unfiltered (current_token
, mi
->raw_stdout
);
2271 fputs_unfiltered ("+download", mi
->raw_stdout
);
2273 ui_out_emit_tuple
tuple_emitter (uiout
.get (), NULL
);
2274 uiout
->field_string ("section", section_name
);
2275 uiout
->field_int ("section-size", total_section
);
2276 uiout
->field_int ("total-size", grand_total
);
2278 mi_out_put (uiout
.get (), mi
->raw_stdout
);
2279 fputs_unfiltered ("\n", mi
->raw_stdout
);
2280 gdb_flush (mi
->raw_stdout
);
2283 steady_clock::time_point time_now
= steady_clock::now ();
2284 if (time_now
- last_update
> milliseconds (500))
2286 last_update
= time_now
;
2288 fputs_unfiltered (current_token
, mi
->raw_stdout
);
2289 fputs_unfiltered ("+download", mi
->raw_stdout
);
2291 ui_out_emit_tuple
tuple_emitter (uiout
.get (), NULL
);
2292 uiout
->field_string ("section", section_name
);
2293 uiout
->field_int ("section-sent", sent_so_far
);
2294 uiout
->field_int ("section-size", total_section
);
2295 uiout
->field_int ("total-sent", total_sent
);
2296 uiout
->field_int ("total-size", grand_total
);
2298 mi_out_put (uiout
.get (), mi
->raw_stdout
);
2299 fputs_unfiltered ("\n", mi
->raw_stdout
);
2300 gdb_flush (mi
->raw_stdout
);
2305 timestamp (struct mi_timestamp
*tv
)
2307 using namespace std::chrono
;
2309 tv
->wallclock
= steady_clock::now ();
2310 run_time_clock::now (tv
->utime
, tv
->stime
);
2314 print_diff_now (struct ui_file
*file
, struct mi_timestamp
*start
)
2316 struct mi_timestamp now
;
2319 print_diff (file
, start
, &now
);
2323 mi_print_timing_maybe (struct ui_file
*file
)
2325 /* If the command is -enable-timing then do_timings may be true
2326 whilst current_command_ts is not initialized. */
2327 if (do_timings
&& current_command_ts
)
2328 print_diff_now (file
, current_command_ts
);
2332 print_diff (struct ui_file
*file
, struct mi_timestamp
*start
,
2333 struct mi_timestamp
*end
)
2335 using namespace std::chrono
;
2337 duration
<double> wallclock
= end
->wallclock
- start
->wallclock
;
2338 duration
<double> utime
= end
->utime
- start
->utime
;
2339 duration
<double> stime
= end
->stime
- start
->stime
;
2343 ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
2344 wallclock
.count (), utime
.count (), stime
.count ());
2348 mi_cmd_trace_define_variable (const char *command
, char **argv
, int argc
)
2350 LONGEST initval
= 0;
2351 struct trace_state_variable
*tsv
;
2354 if (argc
!= 1 && argc
!= 2)
2355 error (_("Usage: -trace-define-variable VARIABLE [VALUE]"));
2359 error (_("Name of trace variable should start with '$'"));
2361 validate_trace_state_variable_name (name
);
2363 tsv
= find_trace_state_variable (name
);
2365 tsv
= create_trace_state_variable (name
);
2368 initval
= value_as_long (parse_and_eval (argv
[1]));
2370 tsv
->initial_value
= initval
;
2374 mi_cmd_trace_list_variables (const char *command
, char **argv
, int argc
)
2377 error (_("-trace-list-variables: no arguments allowed"));
2379 tvariables_info_1 ();
2383 mi_cmd_trace_find (const char *command
, char **argv
, int argc
)
2388 error (_("trace selection mode is required"));
2392 if (strcmp (mode
, "none") == 0)
2394 tfind_1 (tfind_number
, -1, 0, 0, 0);
2398 check_trace_running (current_trace_status ());
2400 if (strcmp (mode
, "frame-number") == 0)
2403 error (_("frame number is required"));
2404 tfind_1 (tfind_number
, atoi (argv
[1]), 0, 0, 0);
2406 else if (strcmp (mode
, "tracepoint-number") == 0)
2409 error (_("tracepoint number is required"));
2410 tfind_1 (tfind_tp
, atoi (argv
[1]), 0, 0, 0);
2412 else if (strcmp (mode
, "pc") == 0)
2415 error (_("PC is required"));
2416 tfind_1 (tfind_pc
, 0, parse_and_eval_address (argv
[1]), 0, 0);
2418 else if (strcmp (mode
, "pc-inside-range") == 0)
2421 error (_("Start and end PC are required"));
2422 tfind_1 (tfind_range
, 0, parse_and_eval_address (argv
[1]),
2423 parse_and_eval_address (argv
[2]), 0);
2425 else if (strcmp (mode
, "pc-outside-range") == 0)
2428 error (_("Start and end PC are required"));
2429 tfind_1 (tfind_outside
, 0, parse_and_eval_address (argv
[1]),
2430 parse_and_eval_address (argv
[2]), 0);
2432 else if (strcmp (mode
, "line") == 0)
2435 error (_("Line is required"));
2437 std::vector
<symtab_and_line
> sals
2438 = decode_line_with_current_source (argv
[1],
2439 DECODE_LINE_FUNFIRSTLINE
);
2440 const symtab_and_line
&sal
= sals
[0];
2442 if (sal
.symtab
== 0)
2443 error (_("Could not find the specified line"));
2445 CORE_ADDR start_pc
, end_pc
;
2446 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2447 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, 0);
2449 error (_("Could not find the specified line"));
2452 error (_("Invalid mode '%s'"), mode
);
2454 if (has_stack_frames () || get_traceframe_number () >= 0)
2455 print_stack_frame (get_selected_frame (NULL
), 1, LOC_AND_ADDRESS
, 1);
2459 mi_cmd_trace_save (const char *command
, char **argv
, int argc
)
2461 int target_saves
= 0;
2462 int generate_ctf
= 0;
2469 TARGET_SAVE_OPT
, CTF_OPT
2471 static const struct mi_opt opts
[] =
2473 {"r", TARGET_SAVE_OPT
, 0},
2474 {"ctf", CTF_OPT
, 0},
2480 int opt
= mi_getopt ("-trace-save", argc
, argv
, opts
,
2485 switch ((enum opt
) opt
)
2487 case TARGET_SAVE_OPT
:
2496 if (argc
- oind
!= 1)
2497 error (_("Exactly one argument required "
2498 "(file in which to save trace data)"));
2500 filename
= argv
[oind
];
2503 trace_save_ctf (filename
, target_saves
);
2505 trace_save_tfile (filename
, target_saves
);
2509 mi_cmd_trace_start (const char *command
, char **argv
, int argc
)
2511 start_tracing (NULL
);
2515 mi_cmd_trace_status (const char *command
, char **argv
, int argc
)
2517 trace_status_mi (0);
2521 mi_cmd_trace_stop (const char *command
, char **argv
, int argc
)
2523 stop_tracing (NULL
);
2524 trace_status_mi (1);
2527 /* Implement the "-ada-task-info" command. */
2530 mi_cmd_ada_task_info (const char *command
, char **argv
, int argc
)
2532 if (argc
!= 0 && argc
!= 1)
2533 error (_("Invalid MI command"));
2535 print_ada_task_info (current_uiout
, argv
[0], current_inferior ());
2538 /* Print EXPRESSION according to VALUES. */
2541 print_variable_or_computed (const char *expression
, enum print_values values
)
2545 struct ui_out
*uiout
= current_uiout
;
2549 expression_up expr
= parse_expression (expression
);
2551 if (values
== PRINT_SIMPLE_VALUES
)
2552 val
= evaluate_type (expr
.get ());
2554 val
= evaluate_expression (expr
.get ());
2556 gdb::optional
<ui_out_emit_tuple
> tuple_emitter
;
2557 if (values
!= PRINT_NO_VALUES
)
2558 tuple_emitter
.emplace (uiout
, nullptr);
2559 uiout
->field_string ("name", expression
);
2563 case PRINT_SIMPLE_VALUES
:
2564 type
= check_typedef (value_type (val
));
2565 type_print (value_type (val
), "", &stb
, -1);
2566 uiout
->field_stream ("type", stb
);
2567 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
2568 && TYPE_CODE (type
) != TYPE_CODE_STRUCT
2569 && TYPE_CODE (type
) != TYPE_CODE_UNION
)
2571 struct value_print_options opts
;
2573 get_no_prettyformat_print_options (&opts
);
2575 common_val_print (val
, &stb
, 0, &opts
, current_language
);
2576 uiout
->field_stream ("value", stb
);
2579 case PRINT_ALL_VALUES
:
2581 struct value_print_options opts
;
2583 get_no_prettyformat_print_options (&opts
);
2585 common_val_print (val
, &stb
, 0, &opts
, current_language
);
2586 uiout
->field_stream ("value", stb
);
2592 /* Implement the "-trace-frame-collected" command. */
2595 mi_cmd_trace_frame_collected (const char *command
, char **argv
, int argc
)
2597 struct bp_location
*tloc
;
2599 struct collection_list
*clist
;
2600 struct collection_list tracepoint_list
, stepping_list
;
2601 struct traceframe_info
*tinfo
;
2603 enum print_values var_print_values
= PRINT_ALL_VALUES
;
2604 enum print_values comp_print_values
= PRINT_ALL_VALUES
;
2605 int registers_format
= 'x';
2606 int memory_contents
= 0;
2607 struct ui_out
*uiout
= current_uiout
;
2615 static const struct mi_opt opts
[] =
2617 {"-var-print-values", VAR_PRINT_VALUES
, 1},
2618 {"-comp-print-values", COMP_PRINT_VALUES
, 1},
2619 {"-registers-format", REGISTERS_FORMAT
, 1},
2620 {"-memory-contents", MEMORY_CONTENTS
, 0},
2627 int opt
= mi_getopt ("-trace-frame-collected", argc
, argv
, opts
,
2631 switch ((enum opt
) opt
)
2633 case VAR_PRINT_VALUES
:
2634 var_print_values
= mi_parse_print_values (oarg
);
2636 case COMP_PRINT_VALUES
:
2637 comp_print_values
= mi_parse_print_values (oarg
);
2639 case REGISTERS_FORMAT
:
2640 registers_format
= oarg
[0];
2641 case MEMORY_CONTENTS
:
2642 memory_contents
= 1;
2648 error (_("Usage: -trace-frame-collected "
2649 "[--var-print-values PRINT_VALUES] "
2650 "[--comp-print-values PRINT_VALUES] "
2651 "[--registers-format FORMAT]"
2652 "[--memory-contents]"));
2654 /* This throws an error is not inspecting a trace frame. */
2655 tloc
= get_traceframe_location (&stepping_frame
);
2657 /* This command only makes sense for the current frame, not the
2659 scoped_restore_current_thread restore_thread
;
2660 select_frame (get_current_frame ());
2662 encode_actions (tloc
, &tracepoint_list
, &stepping_list
);
2665 clist
= &stepping_list
;
2667 clist
= &tracepoint_list
;
2669 tinfo
= get_traceframe_info ();
2671 /* Explicitly wholly collected variables. */
2675 ui_out_emit_list
list_emitter (uiout
, "explicit-variables");
2676 const std::vector
<std::string
> &wholly_collected
2677 = clist
->wholly_collected ();
2678 for (size_t i
= 0; i
< wholly_collected
.size (); i
++)
2680 const std::string
&str
= wholly_collected
[i
];
2681 print_variable_or_computed (str
.c_str (), var_print_values
);
2685 /* Computed expressions. */
2690 ui_out_emit_list
list_emitter (uiout
, "computed-expressions");
2692 const std::vector
<std::string
> &computed
= clist
->computed ();
2693 for (size_t i
= 0; i
< computed
.size (); i
++)
2695 const std::string
&str
= computed
[i
];
2696 print_variable_or_computed (str
.c_str (), comp_print_values
);
2700 /* Registers. Given pseudo-registers, and that some architectures
2701 (like MIPS) actually hide the raw registers, we don't go through
2702 the trace frame info, but instead consult the register cache for
2703 register availability. */
2705 struct frame_info
*frame
;
2706 struct gdbarch
*gdbarch
;
2710 ui_out_emit_list
list_emitter (uiout
, "registers");
2712 frame
= get_selected_frame (NULL
);
2713 gdbarch
= get_frame_arch (frame
);
2714 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
2716 for (regnum
= 0; regnum
< numregs
; regnum
++)
2718 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
2719 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
2722 output_register (frame
, regnum
, registers_format
, 1);
2726 /* Trace state variables. */
2731 ui_out_emit_list
list_emitter (uiout
, "tvars");
2733 for (i
= 0; VEC_iterate (int, tinfo
->tvars
, i
, tvar
); i
++)
2735 struct trace_state_variable
*tsv
;
2737 tsv
= find_trace_state_variable_by_number (tvar
);
2739 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
2743 uiout
->field_fmt ("name", "$%s", tsv
->name
);
2745 tsv
->value_known
= target_get_trace_state_variable_value (tsv
->number
,
2747 uiout
->field_int ("current", tsv
->value
);
2751 uiout
->field_skip ("name");
2752 uiout
->field_skip ("current");
2759 struct cleanup
*cleanups
;
2760 VEC(mem_range_s
) *available_memory
= NULL
;
2761 struct mem_range
*r
;
2764 traceframe_available_memory (&available_memory
, 0, ULONGEST_MAX
);
2765 cleanups
= make_cleanup (VEC_cleanup(mem_range_s
), &available_memory
);
2767 ui_out_emit_list
list_emitter (uiout
, "memory");
2769 for (i
= 0; VEC_iterate (mem_range_s
, available_memory
, i
, r
); i
++)
2771 struct gdbarch
*gdbarch
= target_gdbarch ();
2773 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
2775 uiout
->field_core_addr ("address", gdbarch
, r
->start
);
2776 uiout
->field_int ("length", r
->length
);
2778 gdb::byte_vector
data (r
->length
);
2780 if (memory_contents
)
2782 if (target_read_memory (r
->start
, data
.data (), r
->length
) == 0)
2784 std::string data_str
= bin2hex (data
.data (), r
->length
);
2785 uiout
->field_string ("contents", data_str
.c_str ());
2788 uiout
->field_skip ("contents");
2792 do_cleanups (cleanups
);
2797 _initialize_mi_main (void)
2799 struct cmd_list_element
*c
;
2801 add_setshow_boolean_cmd ("mi-async", class_run
,
2803 Set whether MI asynchronous mode is enabled."), _("\
2804 Show whether MI asynchronous mode is enabled."), _("\
2805 Tells GDB whether MI should be in asynchronous mode."),
2806 set_mi_async_command
,
2807 show_mi_async_command
,
2811 /* Alias old "target-async" to "mi-async". */
2812 c
= add_alias_cmd ("target-async", "mi-async", class_run
, 0, &setlist
);
2813 deprecate_cmd (c
, "set mi-async");
2814 c
= add_alias_cmd ("target-async", "mi-async", class_run
, 0, &showlist
);
2815 deprecate_cmd (c
, "show mi-async");