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 do_nothing (splay_tree_key k
)
710 free_vector_of_osdata_items (splay_tree_value xvalue
)
712 VEC (osdata_item_s
) *value
= (VEC (osdata_item_s
) *) xvalue
;
714 /* We don't free the items itself, it will be done separately. */
715 VEC_free (osdata_item_s
, value
);
719 splay_tree_int_comparator (splay_tree_key xa
, splay_tree_key xb
)
728 free_splay_tree (void *xt
)
730 splay_tree t
= (splay_tree
) xt
;
731 splay_tree_delete (t
);
735 list_available_thread_groups (const std::set
<int> &ids
, int recurse
)
738 struct osdata_item
*item
;
740 struct ui_out
*uiout
= current_uiout
;
741 struct cleanup
*cleanup
;
743 /* This keeps a map from integer (pid) to VEC (struct osdata_item *)*
744 The vector contains information about all threads for the given pid.
745 This is assigned an initial value to avoid "may be used uninitialized"
747 splay_tree tree
= NULL
;
749 /* get_osdata will throw if it cannot return data. */
750 data
= get_osdata ("processes");
751 cleanup
= make_cleanup_osdata_free (data
);
755 struct osdata
*threads
= get_osdata ("threads");
757 make_cleanup_osdata_free (threads
);
758 tree
= splay_tree_new (splay_tree_int_comparator
,
760 free_vector_of_osdata_items
);
761 make_cleanup (free_splay_tree
, tree
);
764 VEC_iterate (osdata_item_s
, threads
->items
,
768 const char *pid
= get_osdata_column (item
, "pid");
769 int pid_i
= strtoul (pid
, NULL
, 0);
770 VEC (osdata_item_s
) *vec
= 0;
772 splay_tree_node n
= splay_tree_lookup (tree
, pid_i
);
775 VEC_safe_push (osdata_item_s
, vec
, item
);
776 splay_tree_insert (tree
, pid_i
, (splay_tree_value
)vec
);
780 vec
= (VEC (osdata_item_s
) *) n
->value
;
781 VEC_safe_push (osdata_item_s
, vec
, item
);
782 n
->value
= (splay_tree_value
) vec
;
787 ui_out_emit_list
list_emitter (uiout
, "groups");
790 VEC_iterate (osdata_item_s
, data
->items
,
794 const char *pid
= get_osdata_column (item
, "pid");
795 const char *cmd
= get_osdata_column (item
, "command");
796 const char *user
= get_osdata_column (item
, "user");
797 const char *cores
= get_osdata_column (item
, "cores");
799 int pid_i
= strtoul (pid
, NULL
, 0);
801 /* At present, the target will return all available processes
802 and if information about specific ones was required, we filter
803 undesired processes here. */
804 if (!ids
.empty () && ids
.find (pid_i
) != ids
.end ())
807 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
809 uiout
->field_fmt ("id", "%s", pid
);
810 uiout
->field_string ("type", "process");
812 uiout
->field_string ("description", cmd
);
814 uiout
->field_string ("user", user
);
816 output_cores (uiout
, "cores", cores
);
820 splay_tree_node n
= splay_tree_lookup (tree
, pid_i
);
823 VEC (osdata_item_s
) *children
= (VEC (osdata_item_s
) *) n
->value
;
824 struct osdata_item
*child
;
827 ui_out_emit_list
thread_list_emitter (uiout
, "threads");
830 VEC_iterate (osdata_item_s
, children
, ix_child
, child
);
833 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
834 const char *tid
= get_osdata_column (child
, "tid");
835 const char *tcore
= get_osdata_column (child
, "core");
837 uiout
->field_string ("id", tid
);
839 uiout
->field_string ("core", tcore
);
845 do_cleanups (cleanup
);
849 mi_cmd_list_thread_groups (const char *command
, char **argv
, int argc
)
851 struct ui_out
*uiout
= current_uiout
;
858 AVAILABLE_OPT
, RECURSE_OPT
860 static const struct mi_opt opts
[] =
862 {"-available", AVAILABLE_OPT
, 0},
863 {"-recurse", RECURSE_OPT
, 1},
872 int opt
= mi_getopt ("-list-thread-groups", argc
, argv
, opts
,
877 switch ((enum opt
) opt
)
883 if (strcmp (oarg
, "0") == 0)
885 else if (strcmp (oarg
, "1") == 0)
888 error (_("only '0' and '1' are valid values "
889 "for the '--recurse' option"));
894 for (; oind
< argc
; ++oind
)
899 if (*(argv
[oind
]) != 'i')
900 error (_("invalid syntax of group id '%s'"), argv
[oind
]);
902 inf
= strtoul (argv
[oind
] + 1, &end
, 0);
905 error (_("invalid syntax of group id '%s'"), argv
[oind
]);
911 list_available_thread_groups (ids
, recurse
);
913 else if (ids
.size () == 1)
915 /* Local thread groups, single id. */
916 int id
= *(ids
.begin ());
917 struct inferior
*inf
= find_inferior_id (id
);
920 error (_("Non-existent thread group id '%d'"), id
);
922 print_thread_info (uiout
, NULL
, inf
->pid
);
926 struct print_one_inferior_data data
;
928 data
.recurse
= recurse
;
929 data
.inferiors
= &ids
;
931 /* Local thread groups. Either no explicit ids -- and we
932 print everything, or several explicit ids. In both cases,
933 we print more than one group, and have to use 'groups'
934 as the top-level element. */
935 ui_out_emit_list
list_emitter (uiout
, "groups");
936 update_thread_list ();
937 iterate_over_inferiors (print_one_inferior
, &data
);
942 mi_cmd_data_list_register_names (const char *command
, char **argv
, int argc
)
944 struct gdbarch
*gdbarch
;
945 struct ui_out
*uiout
= current_uiout
;
949 /* Note that the test for a valid register must include checking the
950 gdbarch_register_name because gdbarch_num_regs may be allocated
951 for the union of the register sets within a family of related
952 processors. In this case, some entries of gdbarch_register_name
953 will change depending upon the particular processor being
956 gdbarch
= get_current_arch ();
957 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
959 ui_out_emit_list
list_emitter (uiout
, "register-names");
961 if (argc
== 0) /* No args, just do all the regs. */
967 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
968 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
969 uiout
->field_string (NULL
, "");
971 uiout
->field_string (NULL
, gdbarch_register_name (gdbarch
, regnum
));
975 /* Else, list of register #s, just do listed regs. */
976 for (i
= 0; i
< argc
; i
++)
978 regnum
= atoi (argv
[i
]);
979 if (regnum
< 0 || regnum
>= numregs
)
980 error (_("bad register number"));
982 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
983 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
984 uiout
->field_string (NULL
, "");
986 uiout
->field_string (NULL
, gdbarch_register_name (gdbarch
, regnum
));
991 mi_cmd_data_list_changed_registers (const char *command
, char **argv
, int argc
)
993 static std::unique_ptr
<struct regcache
> this_regs
;
994 struct ui_out
*uiout
= current_uiout
;
995 std::unique_ptr
<struct regcache
> prev_regs
;
996 struct gdbarch
*gdbarch
;
997 int regnum
, numregs
, changed
;
1000 /* The last time we visited this function, the current frame's
1001 register contents were saved in THIS_REGS. Move THIS_REGS over
1002 to PREV_REGS, and refresh THIS_REGS with the now-current register
1005 prev_regs
= std::move (this_regs
);
1006 this_regs
= frame_save_as_regcache (get_selected_frame (NULL
));
1008 /* Note that the test for a valid register must include checking the
1009 gdbarch_register_name because gdbarch_num_regs may be allocated
1010 for the union of the register sets within a family of related
1011 processors. In this case, some entries of gdbarch_register_name
1012 will change depending upon the particular processor being
1015 gdbarch
= get_regcache_arch (this_regs
.get ());
1016 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1018 ui_out_emit_list
list_emitter (uiout
, "changed-registers");
1022 /* No args, just do all the regs. */
1027 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1028 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1030 changed
= register_changed_p (regnum
, prev_regs
.get (),
1033 error (_("-data-list-changed-registers: "
1034 "Unable to read register contents."));
1036 uiout
->field_int (NULL
, regnum
);
1040 /* Else, list of register #s, just do listed regs. */
1041 for (i
= 0; i
< argc
; i
++)
1043 regnum
= atoi (argv
[i
]);
1047 && gdbarch_register_name (gdbarch
, regnum
) != NULL
1048 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
1050 changed
= register_changed_p (regnum
, prev_regs
.get (),
1053 error (_("-data-list-changed-registers: "
1054 "Unable to read register contents."));
1056 uiout
->field_int (NULL
, regnum
);
1059 error (_("bad register number"));
1064 register_changed_p (int regnum
, struct regcache
*prev_regs
,
1065 struct regcache
*this_regs
)
1067 struct gdbarch
*gdbarch
= get_regcache_arch (this_regs
);
1068 struct value
*prev_value
, *this_value
;
1071 /* First time through or after gdbarch change consider all registers
1073 if (!prev_regs
|| get_regcache_arch (prev_regs
) != gdbarch
)
1076 /* Get register contents and compare. */
1077 prev_value
= prev_regs
->cooked_read_value (regnum
);
1078 this_value
= this_regs
->cooked_read_value (regnum
);
1079 gdb_assert (prev_value
!= NULL
);
1080 gdb_assert (this_value
!= NULL
);
1082 ret
= value_contents_eq (prev_value
, 0, this_value
, 0,
1083 register_size (gdbarch
, regnum
)) == 0;
1085 release_value (prev_value
);
1086 release_value (this_value
);
1087 value_free (prev_value
);
1088 value_free (this_value
);
1092 /* Return a list of register number and value pairs. The valid
1093 arguments expected are: a letter indicating the format in which to
1094 display the registers contents. This can be one of: x
1095 (hexadecimal), d (decimal), N (natural), t (binary), o (octal), r
1096 (raw). After the format argument there can be a sequence of
1097 numbers, indicating which registers to fetch the content of. If
1098 the format is the only argument, a list of all the registers with
1099 their values is returned. */
1102 mi_cmd_data_list_register_values (const char *command
, char **argv
, int argc
)
1104 struct ui_out
*uiout
= current_uiout
;
1105 struct frame_info
*frame
;
1106 struct gdbarch
*gdbarch
;
1107 int regnum
, numregs
, format
;
1109 int skip_unavailable
= 0;
1115 static const struct mi_opt opts
[] =
1117 {"-skip-unavailable", SKIP_UNAVAILABLE
, 0},
1121 /* Note that the test for a valid register must include checking the
1122 gdbarch_register_name because gdbarch_num_regs may be allocated
1123 for the union of the register sets within a family of related
1124 processors. In this case, some entries of gdbarch_register_name
1125 will change depending upon the particular processor being
1131 int opt
= mi_getopt ("-data-list-register-values", argc
, argv
,
1132 opts
, &oind
, &oarg
);
1136 switch ((enum opt
) opt
)
1138 case SKIP_UNAVAILABLE
:
1139 skip_unavailable
= 1;
1144 if (argc
- oind
< 1)
1145 error (_("-data-list-register-values: Usage: "
1146 "-data-list-register-values [--skip-unavailable] <format>"
1147 " [<regnum1>...<regnumN>]"));
1149 format
= (int) argv
[oind
][0];
1151 frame
= get_selected_frame (NULL
);
1152 gdbarch
= get_frame_arch (frame
);
1153 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1155 ui_out_emit_list
list_emitter (uiout
, "register-values");
1157 if (argc
- oind
== 1)
1159 /* No args, beside the format: do all the regs. */
1164 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1165 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1168 output_register (frame
, regnum
, format
, skip_unavailable
);
1172 /* Else, list of register #s, just do listed regs. */
1173 for (i
= 1 + oind
; i
< argc
; i
++)
1175 regnum
= atoi (argv
[i
]);
1179 && gdbarch_register_name (gdbarch
, regnum
) != NULL
1180 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
1181 output_register (frame
, regnum
, format
, skip_unavailable
);
1183 error (_("bad register number"));
1187 /* Output one register REGNUM's contents in the desired FORMAT. If
1188 SKIP_UNAVAILABLE is true, skip the register if it is
1192 output_register (struct frame_info
*frame
, int regnum
, int format
,
1193 int skip_unavailable
)
1195 struct ui_out
*uiout
= current_uiout
;
1196 struct value
*val
= value_of_register (regnum
, frame
);
1197 struct value_print_options opts
;
1199 if (skip_unavailable
&& !value_entirely_available (val
))
1202 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1203 uiout
->field_int ("number", regnum
);
1213 get_formatted_print_options (&opts
, format
);
1215 val_print (value_type (val
),
1216 value_embedded_offset (val
), 0,
1217 &stb
, 0, val
, &opts
, current_language
);
1218 uiout
->field_stream ("value", stb
);
1221 /* Write given values into registers. The registers and values are
1222 given as pairs. The corresponding MI command is
1223 -data-write-register-values <format>
1224 [<regnum1> <value1>...<regnumN> <valueN>] */
1226 mi_cmd_data_write_register_values (const char *command
, char **argv
, int argc
)
1228 struct regcache
*regcache
;
1229 struct gdbarch
*gdbarch
;
1232 /* Note that the test for a valid register must include checking the
1233 gdbarch_register_name because gdbarch_num_regs may be allocated
1234 for the union of the register sets within a family of related
1235 processors. In this case, some entries of gdbarch_register_name
1236 will change depending upon the particular processor being
1239 regcache
= get_current_regcache ();
1240 gdbarch
= get_regcache_arch (regcache
);
1241 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1244 error (_("-data-write-register-values: Usage: -data-write-register-"
1245 "values <format> [<regnum1> <value1>...<regnumN> <valueN>]"));
1247 if (!target_has_registers
)
1248 error (_("-data-write-register-values: No registers."));
1251 error (_("-data-write-register-values: No regs and values specified."));
1254 error (_("-data-write-register-values: "
1255 "Regs and vals are not in pairs."));
1257 for (i
= 1; i
< argc
; i
= i
+ 2)
1259 int regnum
= atoi (argv
[i
]);
1261 if (regnum
>= 0 && regnum
< numregs
1262 && gdbarch_register_name (gdbarch
, regnum
)
1263 && *gdbarch_register_name (gdbarch
, regnum
))
1267 /* Get the value as a number. */
1268 value
= parse_and_eval_address (argv
[i
+ 1]);
1270 /* Write it down. */
1271 regcache_cooked_write_signed (regcache
, regnum
, value
);
1274 error (_("bad register number"));
1278 /* Evaluate the value of the argument. The argument is an
1279 expression. If the expression contains spaces it needs to be
1280 included in double quotes. */
1283 mi_cmd_data_evaluate_expression (const char *command
, char **argv
, int argc
)
1286 struct value_print_options opts
;
1287 struct ui_out
*uiout
= current_uiout
;
1290 error (_("-data-evaluate-expression: "
1291 "Usage: -data-evaluate-expression expression"));
1293 expression_up expr
= parse_expression (argv
[0]);
1295 val
= evaluate_expression (expr
.get ());
1299 /* Print the result of the expression evaluation. */
1300 get_user_print_options (&opts
);
1302 common_val_print (val
, &stb
, 0, &opts
, current_language
);
1304 uiout
->field_stream ("value", stb
);
1307 /* This is the -data-read-memory command.
1309 ADDR: start address of data to be dumped.
1310 WORD-FORMAT: a char indicating format for the ``word''. See
1312 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes.
1313 NR_ROW: Number of rows.
1314 NR_COL: The number of colums (words per row).
1315 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
1316 ASCHAR for unprintable characters.
1318 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
1319 displayes them. Returns:
1321 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
1324 The number of bytes read is SIZE*ROW*COL. */
1327 mi_cmd_data_read_memory (const char *command
, char **argv
, int argc
)
1329 struct gdbarch
*gdbarch
= get_current_arch ();
1330 struct ui_out
*uiout
= current_uiout
;
1332 long total_bytes
, nr_cols
, nr_rows
;
1334 struct type
*word_type
;
1346 static const struct mi_opt opts
[] =
1348 {"o", OFFSET_OPT
, 1},
1354 int opt
= mi_getopt ("-data-read-memory", argc
, argv
, opts
,
1359 switch ((enum opt
) opt
)
1362 offset
= atol (oarg
);
1369 if (argc
< 5 || argc
> 6)
1370 error (_("-data-read-memory: Usage: "
1371 "ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR]."));
1373 /* Extract all the arguments. */
1375 /* Start address of the memory dump. */
1376 addr
= parse_and_eval_address (argv
[0]) + offset
;
1377 /* The format character to use when displaying a memory word. See
1378 the ``x'' command. */
1379 word_format
= argv
[1][0];
1380 /* The size of the memory word. */
1381 word_size
= atol (argv
[2]);
1385 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1389 word_type
= builtin_type (gdbarch
)->builtin_int16
;
1393 word_type
= builtin_type (gdbarch
)->builtin_int32
;
1397 word_type
= builtin_type (gdbarch
)->builtin_int64
;
1401 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1404 /* The number of rows. */
1405 nr_rows
= atol (argv
[3]);
1407 error (_("-data-read-memory: invalid number of rows."));
1409 /* Number of bytes per row. */
1410 nr_cols
= atol (argv
[4]);
1412 error (_("-data-read-memory: invalid number of columns."));
1414 /* The un-printable character when printing ascii. */
1420 /* Create a buffer and read it in. */
1421 total_bytes
= word_size
* nr_rows
* nr_cols
;
1423 gdb::byte_vector
mbuf (total_bytes
);
1425 /* Dispatch memory reads to the topmost target, not the flattened
1427 nr_bytes
= target_read (current_target
.beneath
,
1428 TARGET_OBJECT_MEMORY
, NULL
, mbuf
.data (),
1431 error (_("Unable to read memory."));
1433 /* Output the header information. */
1434 uiout
->field_core_addr ("addr", gdbarch
, addr
);
1435 uiout
->field_int ("nr-bytes", nr_bytes
);
1436 uiout
->field_int ("total-bytes", total_bytes
);
1437 uiout
->field_core_addr ("next-row", gdbarch
, addr
+ word_size
* nr_cols
);
1438 uiout
->field_core_addr ("prev-row", gdbarch
, addr
- word_size
* nr_cols
);
1439 uiout
->field_core_addr ("next-page", gdbarch
, addr
+ total_bytes
);
1440 uiout
->field_core_addr ("prev-page", gdbarch
, addr
- total_bytes
);
1442 /* Build the result as a two dimentional table. */
1449 ui_out_emit_list
list_emitter (uiout
, "memory");
1450 for (row
= 0, row_byte
= 0;
1452 row
++, row_byte
+= nr_cols
* word_size
)
1456 struct value_print_options opts
;
1458 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1459 uiout
->field_core_addr ("addr", gdbarch
, addr
+ row_byte
);
1460 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr +
1463 ui_out_emit_list
list_data_emitter (uiout
, "data");
1464 get_formatted_print_options (&opts
, word_format
);
1465 for (col
= 0, col_byte
= row_byte
;
1467 col
++, col_byte
+= word_size
)
1469 if (col_byte
+ word_size
> nr_bytes
)
1471 uiout
->field_string (NULL
, "N/A");
1476 print_scalar_formatted (&mbuf
[col_byte
], word_type
, &opts
,
1477 word_asize
, &stream
);
1478 uiout
->field_stream (NULL
, stream
);
1488 for (byte
= row_byte
;
1489 byte
< row_byte
+ word_size
* nr_cols
; byte
++)
1491 if (byte
>= nr_bytes
)
1493 else if (mbuf
[byte
] < 32 || mbuf
[byte
] > 126)
1494 stream
.putc (aschar
);
1496 stream
.putc (mbuf
[byte
]);
1498 uiout
->field_stream ("ascii", stream
);
1505 mi_cmd_data_read_memory_bytes (const char *command
, char **argv
, int argc
)
1507 struct gdbarch
*gdbarch
= get_current_arch ();
1508 struct ui_out
*uiout
= current_uiout
;
1509 struct cleanup
*cleanups
;
1512 memory_read_result_s
*read_result
;
1514 VEC(memory_read_result_s
) *result
;
1516 int unit_size
= gdbarch_addressable_memory_unit_size (gdbarch
);
1523 static const struct mi_opt opts
[] =
1525 {"o", OFFSET_OPT
, 1},
1531 int opt
= mi_getopt ("-data-read-memory-bytes", argc
, argv
, opts
,
1535 switch ((enum opt
) opt
)
1538 offset
= atol (oarg
);
1546 error (_("Usage: [ -o OFFSET ] ADDR LENGTH."));
1548 addr
= parse_and_eval_address (argv
[0]) + offset
;
1549 length
= atol (argv
[1]);
1551 result
= read_memory_robust (current_target
.beneath
, addr
, length
);
1553 cleanups
= make_cleanup (free_memory_read_result_vector
, &result
);
1555 if (VEC_length (memory_read_result_s
, result
) == 0)
1556 error (_("Unable to read memory."));
1558 ui_out_emit_list
list_emitter (uiout
, "memory");
1560 VEC_iterate (memory_read_result_s
, result
, ix
, read_result
);
1563 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1568 uiout
->field_core_addr ("begin", gdbarch
, read_result
->begin
);
1569 uiout
->field_core_addr ("offset", gdbarch
, read_result
->begin
- addr
);
1570 uiout
->field_core_addr ("end", gdbarch
, read_result
->end
);
1572 alloc_len
= (read_result
->end
- read_result
->begin
) * 2 * unit_size
+ 1;
1573 data
= (char *) xmalloc (alloc_len
);
1575 for (i
= 0, p
= data
;
1576 i
< ((read_result
->end
- read_result
->begin
) * unit_size
);
1579 sprintf (p
, "%02x", read_result
->data
[i
]);
1581 uiout
->field_string ("contents", data
);
1584 do_cleanups (cleanups
);
1587 /* Implementation of the -data-write_memory command.
1589 COLUMN_OFFSET: optional argument. Must be preceded by '-o'. The
1590 offset from the beginning of the memory grid row where the cell to
1592 ADDR: start address of the row in the memory grid where the memory
1593 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
1594 the location to write to.
1595 FORMAT: a char indicating format for the ``word''. See
1597 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
1598 VALUE: value to be written into the memory address.
1600 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
1605 mi_cmd_data_write_memory (const char *command
, char **argv
, int argc
)
1607 struct gdbarch
*gdbarch
= get_current_arch ();
1608 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1611 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
1612 enough when using a compiler other than GCC. */
1621 static const struct mi_opt opts
[] =
1623 {"o", OFFSET_OPT
, 1},
1629 int opt
= mi_getopt ("-data-write-memory", argc
, argv
, opts
,
1634 switch ((enum opt
) opt
)
1637 offset
= atol (oarg
);
1645 error (_("-data-write-memory: Usage: "
1646 "[-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE."));
1648 /* Extract all the arguments. */
1649 /* Start address of the memory dump. */
1650 addr
= parse_and_eval_address (argv
[0]);
1651 /* The size of the memory word. */
1652 word_size
= atol (argv
[2]);
1654 /* Calculate the real address of the write destination. */
1655 addr
+= (offset
* word_size
);
1657 /* Get the value as a number. */
1658 value
= parse_and_eval_address (argv
[3]);
1659 /* Get the value into an array. */
1660 gdb::byte_vector
buffer (word_size
);
1661 store_signed_integer (buffer
.data (), word_size
, byte_order
, value
);
1662 /* Write it down to memory. */
1663 write_memory_with_notification (addr
, buffer
.data (), word_size
);
1666 /* Implementation of the -data-write-memory-bytes command.
1669 DATA: string of bytes to write at that address
1670 COUNT: number of bytes to be filled (decimal integer). */
1673 mi_cmd_data_write_memory_bytes (const char *command
, char **argv
, int argc
)
1677 size_t len_hex
, len_bytes
, len_units
, i
, steps
, remaining_units
;
1678 long int count_units
;
1681 if (argc
!= 2 && argc
!= 3)
1682 error (_("Usage: ADDR DATA [COUNT]."));
1684 addr
= parse_and_eval_address (argv
[0]);
1686 len_hex
= strlen (cdata
);
1687 unit_size
= gdbarch_addressable_memory_unit_size (get_current_arch ());
1689 if (len_hex
% (unit_size
* 2) != 0)
1690 error (_("Hex-encoded '%s' must represent an integral number of "
1691 "addressable memory units."),
1694 len_bytes
= len_hex
/ 2;
1695 len_units
= len_bytes
/ unit_size
;
1698 count_units
= strtoul (argv
[2], NULL
, 10);
1700 count_units
= len_units
;
1702 gdb::byte_vector
databuf (len_bytes
);
1704 for (i
= 0; i
< len_bytes
; ++i
)
1707 if (sscanf (cdata
+ i
* 2, "%02x", &x
) != 1)
1708 error (_("Invalid argument"));
1709 databuf
[i
] = (gdb_byte
) x
;
1712 gdb::byte_vector data
;
1713 if (len_units
< count_units
)
1715 /* Pattern is made of less units than count:
1716 repeat pattern to fill memory. */
1717 data
= gdb::byte_vector (count_units
* unit_size
);
1719 /* Number of times the pattern is entirely repeated. */
1720 steps
= count_units
/ len_units
;
1721 /* Number of remaining addressable memory units. */
1722 remaining_units
= count_units
% len_units
;
1723 for (i
= 0; i
< steps
; i
++)
1724 memcpy (&data
[i
* len_bytes
], &databuf
[0], len_bytes
);
1726 if (remaining_units
> 0)
1727 memcpy (&data
[steps
* len_bytes
], &databuf
[0],
1728 remaining_units
* unit_size
);
1732 /* Pattern is longer than or equal to count:
1733 just copy count addressable memory units. */
1734 data
= std::move (databuf
);
1737 write_memory_with_notification (addr
, data
.data (), count_units
);
1741 mi_cmd_enable_timings (const char *command
, char **argv
, int argc
)
1747 if (strcmp (argv
[0], "yes") == 0)
1749 else if (strcmp (argv
[0], "no") == 0)
1760 error (_("-enable-timings: Usage: %s {yes|no}"), command
);
1764 mi_cmd_list_features (const char *command
, char **argv
, int argc
)
1768 struct ui_out
*uiout
= current_uiout
;
1770 ui_out_emit_list
list_emitter (uiout
, "features");
1771 uiout
->field_string (NULL
, "frozen-varobjs");
1772 uiout
->field_string (NULL
, "pending-breakpoints");
1773 uiout
->field_string (NULL
, "thread-info");
1774 uiout
->field_string (NULL
, "data-read-memory-bytes");
1775 uiout
->field_string (NULL
, "breakpoint-notifications");
1776 uiout
->field_string (NULL
, "ada-task-info");
1777 uiout
->field_string (NULL
, "language-option");
1778 uiout
->field_string (NULL
, "info-gdb-mi-command");
1779 uiout
->field_string (NULL
, "undefined-command-error-code");
1780 uiout
->field_string (NULL
, "exec-run-start-option");
1782 if (ext_lang_initialized_p (get_ext_lang_defn (EXT_LANG_PYTHON
)))
1783 uiout
->field_string (NULL
, "python");
1788 error (_("-list-features should be passed no arguments"));
1792 mi_cmd_list_target_features (const char *command
, char **argv
, int argc
)
1796 struct ui_out
*uiout
= current_uiout
;
1798 ui_out_emit_list
list_emitter (uiout
, "features");
1800 uiout
->field_string (NULL
, "async");
1801 if (target_can_execute_reverse
)
1802 uiout
->field_string (NULL
, "reverse");
1806 error (_("-list-target-features should be passed no arguments"));
1810 mi_cmd_add_inferior (const char *command
, char **argv
, int argc
)
1812 struct inferior
*inf
;
1815 error (_("-add-inferior should be passed no arguments"));
1817 inf
= add_inferior_with_spaces ();
1819 current_uiout
->field_fmt ("inferior", "i%d", inf
->num
);
1822 /* Callback used to find the first inferior other than the current
1826 get_other_inferior (struct inferior
*inf
, void *arg
)
1828 if (inf
== current_inferior ())
1835 mi_cmd_remove_inferior (const char *command
, char **argv
, int argc
)
1838 struct inferior
*inf
;
1841 error (_("-remove-inferior should be passed a single argument"));
1843 if (sscanf (argv
[0], "i%d", &id
) != 1)
1844 error (_("the thread group id is syntactically invalid"));
1846 inf
= find_inferior_id (id
);
1848 error (_("the specified thread group does not exist"));
1851 error (_("cannot remove an active inferior"));
1853 if (inf
== current_inferior ())
1855 struct thread_info
*tp
= 0;
1856 struct inferior
*new_inferior
1857 = iterate_over_inferiors (get_other_inferior
, NULL
);
1859 if (new_inferior
== NULL
)
1860 error (_("Cannot remove last inferior"));
1862 set_current_inferior (new_inferior
);
1863 if (new_inferior
->pid
!= 0)
1864 tp
= any_thread_of_process (new_inferior
->pid
);
1865 switch_to_thread (tp
? tp
->ptid
: null_ptid
);
1866 set_current_program_space (new_inferior
->pspace
);
1869 delete_inferior (inf
);
1874 /* Execute a command within a safe environment.
1875 Return <0 for error; >=0 for ok.
1877 args->action will tell mi_execute_command what action
1878 to perfrom after the given command has executed (display/suppress
1879 prompt, display error). */
1882 captured_mi_execute_command (struct ui_out
*uiout
, struct mi_parse
*context
)
1884 struct mi_interp
*mi
= (struct mi_interp
*) command_interp ();
1885 struct cleanup
*cleanup
;
1888 current_command_ts
= context
->cmd_start
;
1890 current_token
= xstrdup (context
->token
);
1891 cleanup
= make_cleanup (free_current_contents
, ¤t_token
);
1893 running_result_record_printed
= 0;
1895 switch (context
->op
)
1898 /* A MI command was read from the input stream. */
1900 /* FIXME: gdb_???? */
1901 fprintf_unfiltered (mi
->raw_stdout
,
1902 " token=`%s' command=`%s' args=`%s'\n",
1903 context
->token
, context
->command
, context
->args
);
1905 mi_cmd_execute (context
);
1907 /* Print the result if there were no errors.
1909 Remember that on the way out of executing a command, you have
1910 to directly use the mi_interp's uiout, since the command
1911 could have reset the interpreter, in which case the current
1912 uiout will most likely crash in the mi_out_* routines. */
1913 if (!running_result_record_printed
)
1915 fputs_unfiltered (context
->token
, mi
->raw_stdout
);
1916 /* There's no particularly good reason why target-connect results
1917 in not ^done. Should kill ^connected for MI3. */
1918 fputs_unfiltered (strcmp (context
->command
, "target-select") == 0
1919 ? "^connected" : "^done", mi
->raw_stdout
);
1920 mi_out_put (uiout
, mi
->raw_stdout
);
1921 mi_out_rewind (uiout
);
1922 mi_print_timing_maybe (mi
->raw_stdout
);
1923 fputs_unfiltered ("\n", mi
->raw_stdout
);
1926 /* The command does not want anything to be printed. In that
1927 case, the command probably should not have written anything
1928 to uiout, but in case it has written something, discard it. */
1929 mi_out_rewind (uiout
);
1936 /* A CLI command was read from the input stream. */
1937 /* This "feature" will be removed as soon as we have a
1938 complete set of mi commands. */
1939 /* Echo the command on the console. */
1940 fprintf_unfiltered (gdb_stdlog
, "%s\n", context
->command
);
1941 /* Call the "console" interpreter. */
1942 argv
[0] = (char *) INTERP_CONSOLE
;
1943 argv
[1] = context
->command
;
1944 mi_cmd_interpreter_exec ("-interpreter-exec", argv
, 2);
1946 /* If we changed interpreters, DON'T print out anything. */
1947 if (current_interp_named_p (INTERP_MI
)
1948 || current_interp_named_p (INTERP_MI1
)
1949 || current_interp_named_p (INTERP_MI2
)
1950 || current_interp_named_p (INTERP_MI3
))
1952 if (!running_result_record_printed
)
1954 fputs_unfiltered (context
->token
, mi
->raw_stdout
);
1955 fputs_unfiltered ("^done", mi
->raw_stdout
);
1956 mi_out_put (uiout
, mi
->raw_stdout
);
1957 mi_out_rewind (uiout
);
1958 mi_print_timing_maybe (mi
->raw_stdout
);
1959 fputs_unfiltered ("\n", mi
->raw_stdout
);
1962 mi_out_rewind (uiout
);
1968 do_cleanups (cleanup
);
1971 /* Print a gdb exception to the MI output stream. */
1974 mi_print_exception (const char *token
, struct gdb_exception exception
)
1976 struct mi_interp
*mi
= (struct mi_interp
*) current_interpreter ();
1978 fputs_unfiltered (token
, mi
->raw_stdout
);
1979 fputs_unfiltered ("^error,msg=\"", mi
->raw_stdout
);
1980 if (exception
.message
== NULL
)
1981 fputs_unfiltered ("unknown error", mi
->raw_stdout
);
1983 fputstr_unfiltered (exception
.message
, '"', mi
->raw_stdout
);
1984 fputs_unfiltered ("\"", mi
->raw_stdout
);
1986 switch (exception
.error
)
1988 case UNDEFINED_COMMAND_ERROR
:
1989 fputs_unfiltered (",code=\"undefined-command\"", mi
->raw_stdout
);
1993 fputs_unfiltered ("\n", mi
->raw_stdout
);
1996 /* Determine whether the parsed command already notifies the
1997 user_selected_context_changed observer. */
2000 command_notifies_uscc_observer (struct mi_parse
*command
)
2002 if (command
->op
== CLI_COMMAND
)
2004 /* CLI commands "thread" and "inferior" already send it. */
2005 return (strncmp (command
->command
, "thread ", 7) == 0
2006 || strncmp (command
->command
, "inferior ", 9) == 0);
2008 else /* MI_COMMAND */
2010 if (strcmp (command
->command
, "interpreter-exec") == 0
2011 && command
->argc
> 1)
2013 /* "thread" and "inferior" again, but through -interpreter-exec. */
2014 return (strncmp (command
->argv
[1], "thread ", 7) == 0
2015 || strncmp (command
->argv
[1], "inferior ", 9) == 0);
2019 /* -thread-select already sends it. */
2020 return strcmp (command
->command
, "thread-select") == 0;
2025 mi_execute_command (const char *cmd
, int from_tty
)
2028 std::unique_ptr
<struct mi_parse
> command
;
2030 /* This is to handle EOF (^D). We just quit gdb. */
2031 /* FIXME: we should call some API function here. */
2033 quit_force (NULL
, from_tty
);
2035 target_log_command (cmd
);
2039 command
= mi_parse (cmd
, &token
);
2041 CATCH (exception
, RETURN_MASK_ALL
)
2043 mi_print_exception (token
, exception
);
2048 if (command
!= NULL
)
2050 ptid_t previous_ptid
= inferior_ptid
;
2052 gdb::optional
<scoped_restore_tmpl
<int>> restore_suppress
;
2054 if (command
->cmd
!= NULL
&& command
->cmd
->suppress_notification
!= NULL
)
2055 restore_suppress
.emplace (command
->cmd
->suppress_notification
, 1);
2057 command
->token
= token
;
2061 command
->cmd_start
= new mi_timestamp ();
2062 timestamp (command
->cmd_start
);
2067 captured_mi_execute_command (current_uiout
, command
.get ());
2069 CATCH (result
, RETURN_MASK_ALL
)
2071 /* Like in start_event_loop, enable input and force display
2072 of the prompt. Otherwise, any command that calls
2073 async_disable_stdin, and then throws, will leave input
2075 async_enable_stdin ();
2076 current_ui
->prompt_state
= PROMPT_NEEDED
;
2078 /* The command execution failed and error() was called
2080 mi_print_exception (command
->token
, result
);
2081 mi_out_rewind (current_uiout
);
2085 bpstat_do_actions ();
2087 if (/* The notifications are only output when the top-level
2088 interpreter (specified on the command line) is MI. */
2089 interp_ui_out (top_level_interpreter ())->is_mi_like_p ()
2090 /* Don't try report anything if there are no threads --
2091 the program is dead. */
2092 && thread_count () != 0
2093 /* If the command already reports the thread change, no need to do it
2095 && !command_notifies_uscc_observer (command
.get ()))
2097 struct mi_interp
*mi
= (struct mi_interp
*) top_level_interpreter ();
2098 int report_change
= 0;
2100 if (command
->thread
== -1)
2102 report_change
= (!ptid_equal (previous_ptid
, null_ptid
)
2103 && !ptid_equal (inferior_ptid
, previous_ptid
)
2104 && !ptid_equal (inferior_ptid
, null_ptid
));
2106 else if (!ptid_equal (inferior_ptid
, null_ptid
))
2108 struct thread_info
*ti
= inferior_thread ();
2110 report_change
= (ti
->global_num
!= command
->thread
);
2115 observer_notify_user_selected_context_changed
2116 (USER_SELECTED_THREAD
| USER_SELECTED_FRAME
);
2123 mi_cmd_execute (struct mi_parse
*parse
)
2125 struct cleanup
*cleanup
;
2127 cleanup
= prepare_execute_command ();
2129 if (parse
->all
&& parse
->thread_group
!= -1)
2130 error (_("Cannot specify --thread-group together with --all"));
2132 if (parse
->all
&& parse
->thread
!= -1)
2133 error (_("Cannot specify --thread together with --all"));
2135 if (parse
->thread_group
!= -1 && parse
->thread
!= -1)
2136 error (_("Cannot specify --thread together with --thread-group"));
2138 if (parse
->frame
!= -1 && parse
->thread
== -1)
2139 error (_("Cannot specify --frame without --thread"));
2141 if (parse
->thread_group
!= -1)
2143 struct inferior
*inf
= find_inferior_id (parse
->thread_group
);
2144 struct thread_info
*tp
= 0;
2147 error (_("Invalid thread group for the --thread-group option"));
2149 set_current_inferior (inf
);
2150 /* This behaviour means that if --thread-group option identifies
2151 an inferior with multiple threads, then a random one will be
2152 picked. This is not a problem -- frontend should always
2153 provide --thread if it wishes to operate on a specific
2156 tp
= any_live_thread_of_process (inf
->pid
);
2157 switch_to_thread (tp
? tp
->ptid
: null_ptid
);
2158 set_current_program_space (inf
->pspace
);
2161 if (parse
->thread
!= -1)
2163 struct thread_info
*tp
= find_thread_global_id (parse
->thread
);
2166 error (_("Invalid thread id: %d"), parse
->thread
);
2168 if (is_exited (tp
->ptid
))
2169 error (_("Thread id: %d has terminated"), parse
->thread
);
2171 switch_to_thread (tp
->ptid
);
2174 if (parse
->frame
!= -1)
2176 struct frame_info
*fid
;
2177 int frame
= parse
->frame
;
2179 fid
= find_relative_frame (get_current_frame (), &frame
);
2181 /* find_relative_frame was successful */
2184 error (_("Invalid frame id: %d"), frame
);
2187 gdb::optional
<scoped_restore_current_language
> lang_saver
;
2188 if (parse
->language
!= language_unknown
)
2190 lang_saver
.emplace ();
2191 set_language (parse
->language
);
2194 current_context
= parse
;
2196 if (parse
->cmd
->argv_func
!= NULL
)
2198 parse
->cmd
->argv_func (parse
->command
, parse
->argv
, parse
->argc
);
2200 else if (parse
->cmd
->cli
.cmd
!= 0)
2202 /* FIXME: DELETE THIS. */
2203 /* The operation is still implemented by a cli command. */
2204 /* Must be a synchronous one. */
2205 mi_execute_cli_command (parse
->cmd
->cli
.cmd
, parse
->cmd
->cli
.args_p
,
2210 /* FIXME: DELETE THIS. */
2213 stb
.puts ("Undefined mi command: ");
2214 stb
.putstr (parse
->command
, '"');
2215 stb
.puts (" (missing implementation)");
2219 do_cleanups (cleanup
);
2222 /* FIXME: This is just a hack so we can get some extra commands going.
2223 We don't want to channel things through the CLI, but call libgdb directly.
2224 Use only for synchronous commands. */
2227 mi_execute_cli_command (const char *cmd
, int args_p
, const char *args
)
2231 std::string run
= cmd
;
2234 run
= run
+ " " + args
;
2236 /* FIXME: gdb_???? */
2237 fprintf_unfiltered (gdb_stdout
, "cli=%s run=%s\n",
2239 execute_command (&run
[0], 0 /* from_tty */ );
2244 mi_execute_async_cli_command (const char *cli_command
, char **argv
, int argc
)
2246 std::string run
= cli_command
;
2249 run
= run
+ " " + *argv
;
2253 execute_command (&run
[0], 0 /* from_tty */ );
2257 mi_load_progress (const char *section_name
,
2258 unsigned long sent_so_far
,
2259 unsigned long total_section
,
2260 unsigned long total_sent
,
2261 unsigned long grand_total
)
2263 using namespace std::chrono
;
2264 static steady_clock::time_point last_update
;
2265 static char *previous_sect_name
= NULL
;
2267 struct mi_interp
*mi
= (struct mi_interp
*) current_interpreter ();
2269 /* This function is called through deprecated_show_load_progress
2270 which means uiout may not be correct. Fix it for the duration
2271 of this function. */
2273 std::unique_ptr
<ui_out
> uiout
;
2275 if (current_interp_named_p (INTERP_MI
)
2276 || current_interp_named_p (INTERP_MI2
))
2277 uiout
.reset (mi_out_new (2));
2278 else if (current_interp_named_p (INTERP_MI1
))
2279 uiout
.reset (mi_out_new (1));
2280 else if (current_interp_named_p (INTERP_MI3
))
2281 uiout
.reset (mi_out_new (3));
2285 scoped_restore save_uiout
2286 = make_scoped_restore (¤t_uiout
, uiout
.get ());
2288 new_section
= (previous_sect_name
?
2289 strcmp (previous_sect_name
, section_name
) : 1);
2292 xfree (previous_sect_name
);
2293 previous_sect_name
= xstrdup (section_name
);
2296 fputs_unfiltered (current_token
, mi
->raw_stdout
);
2297 fputs_unfiltered ("+download", mi
->raw_stdout
);
2299 ui_out_emit_tuple
tuple_emitter (uiout
.get (), NULL
);
2300 uiout
->field_string ("section", section_name
);
2301 uiout
->field_int ("section-size", total_section
);
2302 uiout
->field_int ("total-size", grand_total
);
2304 mi_out_put (uiout
.get (), mi
->raw_stdout
);
2305 fputs_unfiltered ("\n", mi
->raw_stdout
);
2306 gdb_flush (mi
->raw_stdout
);
2309 steady_clock::time_point time_now
= steady_clock::now ();
2310 if (time_now
- last_update
> milliseconds (500))
2312 last_update
= time_now
;
2314 fputs_unfiltered (current_token
, mi
->raw_stdout
);
2315 fputs_unfiltered ("+download", mi
->raw_stdout
);
2317 ui_out_emit_tuple
tuple_emitter (uiout
.get (), NULL
);
2318 uiout
->field_string ("section", section_name
);
2319 uiout
->field_int ("section-sent", sent_so_far
);
2320 uiout
->field_int ("section-size", total_section
);
2321 uiout
->field_int ("total-sent", total_sent
);
2322 uiout
->field_int ("total-size", grand_total
);
2324 mi_out_put (uiout
.get (), mi
->raw_stdout
);
2325 fputs_unfiltered ("\n", mi
->raw_stdout
);
2326 gdb_flush (mi
->raw_stdout
);
2331 timestamp (struct mi_timestamp
*tv
)
2333 using namespace std::chrono
;
2335 tv
->wallclock
= steady_clock::now ();
2336 run_time_clock::now (tv
->utime
, tv
->stime
);
2340 print_diff_now (struct ui_file
*file
, struct mi_timestamp
*start
)
2342 struct mi_timestamp now
;
2345 print_diff (file
, start
, &now
);
2349 mi_print_timing_maybe (struct ui_file
*file
)
2351 /* If the command is -enable-timing then do_timings may be true
2352 whilst current_command_ts is not initialized. */
2353 if (do_timings
&& current_command_ts
)
2354 print_diff_now (file
, current_command_ts
);
2358 print_diff (struct ui_file
*file
, struct mi_timestamp
*start
,
2359 struct mi_timestamp
*end
)
2361 using namespace std::chrono
;
2363 duration
<double> wallclock
= end
->wallclock
- start
->wallclock
;
2364 duration
<double> utime
= end
->utime
- start
->utime
;
2365 duration
<double> stime
= end
->stime
- start
->stime
;
2369 ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
2370 wallclock
.count (), utime
.count (), stime
.count ());
2374 mi_cmd_trace_define_variable (const char *command
, char **argv
, int argc
)
2376 LONGEST initval
= 0;
2377 struct trace_state_variable
*tsv
;
2380 if (argc
!= 1 && argc
!= 2)
2381 error (_("Usage: -trace-define-variable VARIABLE [VALUE]"));
2385 error (_("Name of trace variable should start with '$'"));
2387 validate_trace_state_variable_name (name
);
2389 tsv
= find_trace_state_variable (name
);
2391 tsv
= create_trace_state_variable (name
);
2394 initval
= value_as_long (parse_and_eval (argv
[1]));
2396 tsv
->initial_value
= initval
;
2400 mi_cmd_trace_list_variables (const char *command
, char **argv
, int argc
)
2403 error (_("-trace-list-variables: no arguments allowed"));
2405 tvariables_info_1 ();
2409 mi_cmd_trace_find (const char *command
, char **argv
, int argc
)
2414 error (_("trace selection mode is required"));
2418 if (strcmp (mode
, "none") == 0)
2420 tfind_1 (tfind_number
, -1, 0, 0, 0);
2424 check_trace_running (current_trace_status ());
2426 if (strcmp (mode
, "frame-number") == 0)
2429 error (_("frame number is required"));
2430 tfind_1 (tfind_number
, atoi (argv
[1]), 0, 0, 0);
2432 else if (strcmp (mode
, "tracepoint-number") == 0)
2435 error (_("tracepoint number is required"));
2436 tfind_1 (tfind_tp
, atoi (argv
[1]), 0, 0, 0);
2438 else if (strcmp (mode
, "pc") == 0)
2441 error (_("PC is required"));
2442 tfind_1 (tfind_pc
, 0, parse_and_eval_address (argv
[1]), 0, 0);
2444 else if (strcmp (mode
, "pc-inside-range") == 0)
2447 error (_("Start and end PC are required"));
2448 tfind_1 (tfind_range
, 0, parse_and_eval_address (argv
[1]),
2449 parse_and_eval_address (argv
[2]), 0);
2451 else if (strcmp (mode
, "pc-outside-range") == 0)
2454 error (_("Start and end PC are required"));
2455 tfind_1 (tfind_outside
, 0, parse_and_eval_address (argv
[1]),
2456 parse_and_eval_address (argv
[2]), 0);
2458 else if (strcmp (mode
, "line") == 0)
2461 error (_("Line is required"));
2463 std::vector
<symtab_and_line
> sals
2464 = decode_line_with_current_source (argv
[1],
2465 DECODE_LINE_FUNFIRSTLINE
);
2466 const symtab_and_line
&sal
= sals
[0];
2468 if (sal
.symtab
== 0)
2469 error (_("Could not find the specified line"));
2471 CORE_ADDR start_pc
, end_pc
;
2472 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2473 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, 0);
2475 error (_("Could not find the specified line"));
2478 error (_("Invalid mode '%s'"), mode
);
2480 if (has_stack_frames () || get_traceframe_number () >= 0)
2481 print_stack_frame (get_selected_frame (NULL
), 1, LOC_AND_ADDRESS
, 1);
2485 mi_cmd_trace_save (const char *command
, char **argv
, int argc
)
2487 int target_saves
= 0;
2488 int generate_ctf
= 0;
2495 TARGET_SAVE_OPT
, CTF_OPT
2497 static const struct mi_opt opts
[] =
2499 {"r", TARGET_SAVE_OPT
, 0},
2500 {"ctf", CTF_OPT
, 0},
2506 int opt
= mi_getopt ("-trace-save", argc
, argv
, opts
,
2511 switch ((enum opt
) opt
)
2513 case TARGET_SAVE_OPT
:
2522 if (argc
- oind
!= 1)
2523 error (_("Exactly one argument required "
2524 "(file in which to save trace data)"));
2526 filename
= argv
[oind
];
2529 trace_save_ctf (filename
, target_saves
);
2531 trace_save_tfile (filename
, target_saves
);
2535 mi_cmd_trace_start (const char *command
, char **argv
, int argc
)
2537 start_tracing (NULL
);
2541 mi_cmd_trace_status (const char *command
, char **argv
, int argc
)
2543 trace_status_mi (0);
2547 mi_cmd_trace_stop (const char *command
, char **argv
, int argc
)
2549 stop_tracing (NULL
);
2550 trace_status_mi (1);
2553 /* Implement the "-ada-task-info" command. */
2556 mi_cmd_ada_task_info (const char *command
, char **argv
, int argc
)
2558 if (argc
!= 0 && argc
!= 1)
2559 error (_("Invalid MI command"));
2561 print_ada_task_info (current_uiout
, argv
[0], current_inferior ());
2564 /* Print EXPRESSION according to VALUES. */
2567 print_variable_or_computed (const char *expression
, enum print_values values
)
2571 struct ui_out
*uiout
= current_uiout
;
2575 expression_up expr
= parse_expression (expression
);
2577 if (values
== PRINT_SIMPLE_VALUES
)
2578 val
= evaluate_type (expr
.get ());
2580 val
= evaluate_expression (expr
.get ());
2582 gdb::optional
<ui_out_emit_tuple
> tuple_emitter
;
2583 if (values
!= PRINT_NO_VALUES
)
2584 tuple_emitter
.emplace (uiout
, nullptr);
2585 uiout
->field_string ("name", expression
);
2589 case PRINT_SIMPLE_VALUES
:
2590 type
= check_typedef (value_type (val
));
2591 type_print (value_type (val
), "", &stb
, -1);
2592 uiout
->field_stream ("type", stb
);
2593 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
2594 && TYPE_CODE (type
) != TYPE_CODE_STRUCT
2595 && TYPE_CODE (type
) != TYPE_CODE_UNION
)
2597 struct value_print_options opts
;
2599 get_no_prettyformat_print_options (&opts
);
2601 common_val_print (val
, &stb
, 0, &opts
, current_language
);
2602 uiout
->field_stream ("value", stb
);
2605 case PRINT_ALL_VALUES
:
2607 struct value_print_options opts
;
2609 get_no_prettyformat_print_options (&opts
);
2611 common_val_print (val
, &stb
, 0, &opts
, current_language
);
2612 uiout
->field_stream ("value", stb
);
2618 /* Implement the "-trace-frame-collected" command. */
2621 mi_cmd_trace_frame_collected (const char *command
, char **argv
, int argc
)
2623 struct bp_location
*tloc
;
2625 struct collection_list
*clist
;
2626 struct collection_list tracepoint_list
, stepping_list
;
2627 struct traceframe_info
*tinfo
;
2629 enum print_values var_print_values
= PRINT_ALL_VALUES
;
2630 enum print_values comp_print_values
= PRINT_ALL_VALUES
;
2631 int registers_format
= 'x';
2632 int memory_contents
= 0;
2633 struct ui_out
*uiout
= current_uiout
;
2641 static const struct mi_opt opts
[] =
2643 {"-var-print-values", VAR_PRINT_VALUES
, 1},
2644 {"-comp-print-values", COMP_PRINT_VALUES
, 1},
2645 {"-registers-format", REGISTERS_FORMAT
, 1},
2646 {"-memory-contents", MEMORY_CONTENTS
, 0},
2653 int opt
= mi_getopt ("-trace-frame-collected", argc
, argv
, opts
,
2657 switch ((enum opt
) opt
)
2659 case VAR_PRINT_VALUES
:
2660 var_print_values
= mi_parse_print_values (oarg
);
2662 case COMP_PRINT_VALUES
:
2663 comp_print_values
= mi_parse_print_values (oarg
);
2665 case REGISTERS_FORMAT
:
2666 registers_format
= oarg
[0];
2667 case MEMORY_CONTENTS
:
2668 memory_contents
= 1;
2674 error (_("Usage: -trace-frame-collected "
2675 "[--var-print-values PRINT_VALUES] "
2676 "[--comp-print-values PRINT_VALUES] "
2677 "[--registers-format FORMAT]"
2678 "[--memory-contents]"));
2680 /* This throws an error is not inspecting a trace frame. */
2681 tloc
= get_traceframe_location (&stepping_frame
);
2683 /* This command only makes sense for the current frame, not the
2685 scoped_restore_current_thread restore_thread
;
2686 select_frame (get_current_frame ());
2688 encode_actions (tloc
, &tracepoint_list
, &stepping_list
);
2691 clist
= &stepping_list
;
2693 clist
= &tracepoint_list
;
2695 tinfo
= get_traceframe_info ();
2697 /* Explicitly wholly collected variables. */
2701 ui_out_emit_list
list_emitter (uiout
, "explicit-variables");
2702 const std::vector
<std::string
> &wholly_collected
2703 = clist
->wholly_collected ();
2704 for (size_t i
= 0; i
< wholly_collected
.size (); i
++)
2706 const std::string
&str
= wholly_collected
[i
];
2707 print_variable_or_computed (str
.c_str (), var_print_values
);
2711 /* Computed expressions. */
2716 ui_out_emit_list
list_emitter (uiout
, "computed-expressions");
2718 const std::vector
<std::string
> &computed
= clist
->computed ();
2719 for (size_t i
= 0; i
< computed
.size (); i
++)
2721 const std::string
&str
= computed
[i
];
2722 print_variable_or_computed (str
.c_str (), comp_print_values
);
2726 /* Registers. Given pseudo-registers, and that some architectures
2727 (like MIPS) actually hide the raw registers, we don't go through
2728 the trace frame info, but instead consult the register cache for
2729 register availability. */
2731 struct frame_info
*frame
;
2732 struct gdbarch
*gdbarch
;
2736 ui_out_emit_list
list_emitter (uiout
, "registers");
2738 frame
= get_selected_frame (NULL
);
2739 gdbarch
= get_frame_arch (frame
);
2740 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
2742 for (regnum
= 0; regnum
< numregs
; regnum
++)
2744 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
2745 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
2748 output_register (frame
, regnum
, registers_format
, 1);
2752 /* Trace state variables. */
2754 struct cleanup
*cleanups
;
2758 ui_out_emit_list
list_emitter (uiout
, "tvars");
2760 for (i
= 0; VEC_iterate (int, tinfo
->tvars
, i
, tvar
); i
++)
2762 struct trace_state_variable
*tsv
;
2764 tsv
= find_trace_state_variable_by_number (tvar
);
2766 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
2770 uiout
->field_fmt ("name", "$%s", tsv
->name
);
2772 tsv
->value_known
= target_get_trace_state_variable_value (tsv
->number
,
2774 uiout
->field_int ("current", tsv
->value
);
2778 uiout
->field_skip ("name");
2779 uiout
->field_skip ("current");
2786 struct cleanup
*cleanups
;
2787 VEC(mem_range_s
) *available_memory
= NULL
;
2788 struct mem_range
*r
;
2791 traceframe_available_memory (&available_memory
, 0, ULONGEST_MAX
);
2792 cleanups
= make_cleanup (VEC_cleanup(mem_range_s
), &available_memory
);
2794 ui_out_emit_list
list_emitter (uiout
, "memory");
2796 for (i
= 0; VEC_iterate (mem_range_s
, available_memory
, i
, r
); i
++)
2798 struct gdbarch
*gdbarch
= target_gdbarch ();
2800 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
2802 uiout
->field_core_addr ("address", gdbarch
, r
->start
);
2803 uiout
->field_int ("length", r
->length
);
2805 gdb::byte_vector
data (r
->length
);
2807 if (memory_contents
)
2809 if (target_read_memory (r
->start
, data
.data (), r
->length
) == 0)
2811 std::string data_str
= bin2hex (data
.data (), r
->length
);
2812 uiout
->field_string ("contents", data_str
.c_str ());
2815 uiout
->field_skip ("contents");
2819 do_cleanups (cleanups
);
2824 _initialize_mi_main (void)
2826 struct cmd_list_element
*c
;
2828 add_setshow_boolean_cmd ("mi-async", class_run
,
2830 Set whether MI asynchronous mode is enabled."), _("\
2831 Show whether MI asynchronous mode is enabled."), _("\
2832 Tells GDB whether MI should be in asynchronous mode."),
2833 set_mi_async_command
,
2834 show_mi_async_command
,
2838 /* Alias old "target-async" to "mi-async". */
2839 c
= add_alias_cmd ("target-async", "mi-async", class_run
, 0, &setlist
);
2840 deprecate_cmd (c
, "set mi-async");
2841 c
= add_alias_cmd ("target-async", "mi-async", class_run
, 0, &showlist
);
2842 deprecate_cmd (c
, "show mi-async");