3 Copyright (C) 2000-2019 Free Software Foundation, Inc.
5 Contributed by Cygnus Solutions (a Red Hat company).
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 #include "arch-utils.h"
28 #include "gdbthread.h"
31 #include "mi-getopt.h"
32 #include "mi-console.h"
36 #include "event-loop.h"
37 #include "event-top.h"
38 #include "gdbcore.h" /* For write_memory(). */
43 #include "mi-common.h"
47 #include "common/gdb_splay_tree.h"
48 #include "tracepoint.h"
52 #include "extension.h"
54 #include "observable.h"
55 #include "common/gdb_optional.h"
56 #include "common/byte-vector.h"
59 #include "common/run-time-clock.h"
61 #include "progspace-and-thread.h"
62 #include "common/rsp-low.h"
74 /* This is used to pass the current command timestamp down to
75 continuation routines. */
76 static struct mi_timestamp
*current_command_ts
;
78 static int do_timings
= 0;
81 /* Few commands would like to know if options like --thread-group were
82 explicitly specified. This variable keeps the current parsed
83 command including all option, and make it possible. */
84 static struct mi_parse
*current_context
;
86 int running_result_record_printed
= 1;
88 /* Flag indicating that the target has proceeded since the last
89 command was issued. */
92 static void mi_cmd_execute (struct mi_parse
*parse
);
94 static void mi_execute_cli_command (const char *cmd
, int args_p
,
96 static void mi_execute_async_cli_command (const char *cli_command
,
97 char **argv
, int argc
);
98 static bool register_changed_p (int regnum
, readonly_detached_regcache
*,
99 readonly_detached_regcache
*);
100 static void output_register (struct frame_info
*, int regnum
, int format
,
101 int skip_unavailable
);
103 /* Controls whether the frontend wants MI in async mode. */
104 static int mi_async
= 0;
106 /* The set command writes to this variable. If the inferior is
107 executing, mi_async is *not* updated. */
108 static int mi_async_1
= 0;
111 set_mi_async_command (const char *args
, int from_tty
,
112 struct cmd_list_element
*c
)
114 if (have_live_inferiors ())
116 mi_async_1
= mi_async
;
117 error (_("Cannot change this setting while the inferior is running."));
120 mi_async
= mi_async_1
;
124 show_mi_async_command (struct ui_file
*file
, int from_tty
,
125 struct cmd_list_element
*c
,
128 fprintf_filtered (file
,
129 _("Whether MI is in asynchronous mode is %s.\n"),
133 /* A wrapper for target_can_async_p that takes the MI setting into
139 return mi_async
&& target_can_async_p ();
142 /* Command implementations. FIXME: Is this libgdb? No. This is the MI
143 layer that calls libgdb. Any operation used in the below should be
146 static void timestamp (struct mi_timestamp
*tv
);
148 static void print_diff (struct ui_file
*file
, struct mi_timestamp
*start
,
149 struct mi_timestamp
*end
);
152 mi_cmd_gdb_exit (const char *command
, char **argv
, int argc
)
154 struct mi_interp
*mi
= (struct mi_interp
*) current_interpreter ();
156 /* We have to print everything right here because we never return. */
158 fputs_unfiltered (current_token
, mi
->raw_stdout
);
159 fputs_unfiltered ("^exit\n", mi
->raw_stdout
);
160 mi_out_put (current_uiout
, mi
->raw_stdout
);
161 gdb_flush (mi
->raw_stdout
);
162 /* FIXME: The function called is not yet a formal libgdb function. */
163 quit_force (NULL
, FROM_TTY
);
167 mi_cmd_exec_next (const char *command
, char **argv
, int argc
)
169 /* FIXME: Should call a libgdb function, not a cli wrapper. */
170 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
171 mi_execute_async_cli_command ("reverse-next", argv
+ 1, argc
- 1);
173 mi_execute_async_cli_command ("next", argv
, argc
);
177 mi_cmd_exec_next_instruction (const char *command
, char **argv
, int argc
)
179 /* FIXME: Should call a libgdb function, not a cli wrapper. */
180 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
181 mi_execute_async_cli_command ("reverse-nexti", argv
+ 1, argc
- 1);
183 mi_execute_async_cli_command ("nexti", argv
, argc
);
187 mi_cmd_exec_step (const char *command
, char **argv
, int argc
)
189 /* FIXME: Should call a libgdb function, not a cli wrapper. */
190 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
191 mi_execute_async_cli_command ("reverse-step", argv
+ 1, argc
- 1);
193 mi_execute_async_cli_command ("step", argv
, argc
);
197 mi_cmd_exec_step_instruction (const char *command
, char **argv
, int argc
)
199 /* FIXME: Should call a libgdb function, not a cli wrapper. */
200 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
201 mi_execute_async_cli_command ("reverse-stepi", argv
+ 1, argc
- 1);
203 mi_execute_async_cli_command ("stepi", argv
, argc
);
207 mi_cmd_exec_finish (const char *command
, char **argv
, int argc
)
209 /* FIXME: Should call a libgdb function, not a cli wrapper. */
210 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
211 mi_execute_async_cli_command ("reverse-finish", argv
+ 1, argc
- 1);
213 mi_execute_async_cli_command ("finish", argv
, argc
);
217 mi_cmd_exec_return (const char *command
, char **argv
, int argc
)
219 /* This command doesn't really execute the target, it just pops the
220 specified number of frames. */
222 /* Call return_command with from_tty argument equal to 0 so as to
223 avoid being queried. */
224 return_command (*argv
, 0);
226 /* Call return_command with from_tty argument equal to 0 so as to
227 avoid being queried. */
228 return_command (NULL
, 0);
230 /* Because we have called return_command with from_tty = 0, we need
231 to print the frame here. */
232 print_stack_frame (get_selected_frame (NULL
), 1, LOC_AND_ADDRESS
, 1);
236 mi_cmd_exec_jump (const char *args
, char **argv
, int argc
)
238 /* FIXME: Should call a libgdb function, not a cli wrapper. */
239 mi_execute_async_cli_command ("jump", argv
, argc
);
243 proceed_thread (struct thread_info
*thread
, int pid
)
245 if (thread
->state
!= THREAD_STOPPED
)
248 if (pid
!= 0 && thread
->ptid
.pid () != pid
)
251 switch_to_thread (thread
);
252 clear_proceed_status (0);
253 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
);
257 proceed_thread_callback (struct thread_info
*thread
, void *arg
)
259 int pid
= *(int *)arg
;
261 proceed_thread (thread
, pid
);
266 exec_continue (char **argv
, int argc
)
268 prepare_execution_command (current_top_target (), mi_async_p ());
272 /* In non-stop mode, 'resume' always resumes a single thread.
273 Therefore, to resume all threads of the current inferior, or
274 all threads in all inferiors, we need to iterate over
277 See comment on infcmd.c:proceed_thread_callback for rationale. */
278 if (current_context
->all
|| current_context
->thread_group
!= -1)
280 scoped_restore_current_thread restore_thread
;
283 if (!current_context
->all
)
286 = find_inferior_id (current_context
->thread_group
);
290 iterate_over_threads (proceed_thread_callback
, &pid
);
299 scoped_restore save_multi
= make_scoped_restore (&sched_multi
);
301 if (current_context
->all
)
308 /* In all-stop mode, -exec-continue traditionally resumed
309 either all threads, or one thread, depending on the
310 'scheduler-locking' variable. Let's continue to do the
318 exec_reverse_continue (char **argv
, int argc
)
320 enum exec_direction_kind dir
= execution_direction
;
322 if (dir
== EXEC_REVERSE
)
323 error (_("Already in reverse mode."));
325 if (!target_can_execute_reverse
)
326 error (_("Target %s does not support this command."), target_shortname
);
328 scoped_restore save_exec_dir
= make_scoped_restore (&execution_direction
,
330 exec_continue (argv
, argc
);
334 mi_cmd_exec_continue (const char *command
, char **argv
, int argc
)
336 if (argc
> 0 && strcmp (argv
[0], "--reverse") == 0)
337 exec_reverse_continue (argv
+ 1, argc
- 1);
339 exec_continue (argv
, argc
);
343 interrupt_thread_callback (struct thread_info
*thread
, void *arg
)
345 int pid
= *(int *)arg
;
347 if (thread
->state
!= THREAD_RUNNING
)
350 if (thread
->ptid
.pid () != pid
)
353 target_stop (thread
->ptid
);
357 /* Interrupt the execution of the target. Note how we must play
358 around with the token variables, in order to display the current
359 token in the result of the interrupt command, and the previous
360 execution token when the target finally stops. See comments in
364 mi_cmd_exec_interrupt (const char *command
, char **argv
, int argc
)
366 /* In all-stop mode, everything stops, so we don't need to try
367 anything specific. */
370 interrupt_target_1 (0);
374 if (current_context
->all
)
376 /* This will interrupt all threads in all inferiors. */
377 interrupt_target_1 (1);
379 else if (current_context
->thread_group
!= -1)
381 struct inferior
*inf
= find_inferior_id (current_context
->thread_group
);
383 iterate_over_threads (interrupt_thread_callback
, &inf
->pid
);
387 /* Interrupt just the current thread -- either explicitly
388 specified via --thread or whatever was current before
389 MI command was sent. */
390 interrupt_target_1 (0);
394 /* Callback for iterate_over_inferiors which starts the execution
395 of the given inferior.
397 ARG is a pointer to an integer whose value, if non-zero, indicates
398 that the program should be stopped when reaching the main subprogram
399 (similar to what the CLI "start" command does). */
402 run_one_inferior (struct inferior
*inf
, void *arg
)
404 int start_p
= *(int *) arg
;
405 const char *run_cmd
= start_p
? "start" : "run";
406 struct target_ops
*run_target
= find_run_target ();
407 int async_p
= mi_async
&& run_target
->can_async_p ();
411 thread_info
*tp
= any_thread_of_inferior (inf
);
413 error (_("Inferior has no threads."));
415 switch_to_thread (tp
);
419 set_current_inferior (inf
);
420 switch_to_no_thread ();
421 set_current_program_space (inf
->pspace
);
423 mi_execute_cli_command (run_cmd
, async_p
,
424 async_p
? "&" : NULL
);
429 mi_cmd_exec_run (const char *command
, char **argv
, int argc
)
433 /* Parse the command options. */
438 static const struct mi_opt opts
[] =
440 {"-start", START_OPT
, 0},
449 int opt
= mi_getopt ("-exec-run", argc
, argv
, opts
, &oind
, &oarg
);
453 switch ((enum opt
) opt
)
461 /* This command does not accept any argument. Make sure the user
462 did not provide any. */
464 error (_("Invalid argument: %s"), argv
[oind
]);
466 if (current_context
->all
)
468 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
470 iterate_over_inferiors (run_one_inferior
, &start_p
);
474 const char *run_cmd
= start_p
? "start" : "run";
475 struct target_ops
*run_target
= find_run_target ();
476 int async_p
= mi_async
&& run_target
->can_async_p ();
478 mi_execute_cli_command (run_cmd
, async_p
,
479 async_p
? "&" : NULL
);
485 find_thread_of_process (struct thread_info
*ti
, void *p
)
489 if (ti
->ptid
.pid () == pid
&& ti
->state
!= THREAD_EXITED
)
496 mi_cmd_target_detach (const char *command
, char **argv
, int argc
)
498 if (argc
!= 0 && argc
!= 1)
499 error (_("Usage: -target-detach [pid | thread-group]"));
503 struct thread_info
*tp
;
507 /* First see if we are dealing with a thread-group id. */
510 struct inferior
*inf
;
511 int id
= strtoul (argv
[0] + 1, &end
, 0);
514 error (_("Invalid syntax of thread-group id '%s'"), argv
[0]);
516 inf
= find_inferior_id (id
);
518 error (_("Non-existent thread-group id '%d'"), id
);
524 /* We must be dealing with a pid. */
525 pid
= strtol (argv
[0], &end
, 10);
528 error (_("Invalid identifier '%s'"), argv
[0]);
531 /* Pick any thread in the desired process. Current
532 target_detach detaches from the parent of inferior_ptid. */
533 tp
= iterate_over_threads (find_thread_of_process
, &pid
);
535 error (_("Thread group is empty"));
537 switch_to_thread (tp
);
540 detach_command (NULL
, 0);
544 mi_cmd_target_flash_erase (const char *command
, char **argv
, int argc
)
546 flash_erase_command (NULL
, 0);
550 mi_cmd_thread_select (const char *command
, char **argv
, int argc
)
553 error (_("-thread-select: USAGE: threadnum."));
555 int num
= value_as_long (parse_and_eval (argv
[0]));
556 thread_info
*thr
= find_thread_global_id (num
);
558 error (_("Thread ID %d not known."), num
);
560 ptid_t previous_ptid
= inferior_ptid
;
562 thread_select (argv
[0], thr
);
564 print_selected_thread_frame (current_uiout
,
565 USER_SELECTED_THREAD
| USER_SELECTED_FRAME
);
567 /* Notify if the thread has effectively changed. */
568 if (inferior_ptid
!= previous_ptid
)
570 gdb::observers::user_selected_context_changed
.notify
571 (USER_SELECTED_THREAD
| USER_SELECTED_FRAME
);
576 mi_cmd_thread_list_ids (const char *command
, char **argv
, int argc
)
579 error (_("-thread-list-ids: No arguments required."));
582 int current_thread
= -1;
584 update_thread_list ();
587 ui_out_emit_tuple
tuple_emitter (current_uiout
, "thread-ids");
589 for (thread_info
*tp
: all_non_exited_threads ())
591 if (tp
->ptid
== inferior_ptid
)
592 current_thread
= tp
->global_num
;
595 current_uiout
->field_int ("thread-id", tp
->global_num
);
599 if (current_thread
!= -1)
600 current_uiout
->field_int ("current-thread-id", current_thread
);
601 current_uiout
->field_int ("number-of-threads", num
);
605 mi_cmd_thread_info (const char *command
, char **argv
, int argc
)
607 if (argc
!= 0 && argc
!= 1)
608 error (_("Invalid MI command"));
610 print_thread_info (current_uiout
, argv
[0], -1);
613 struct collect_cores_data
620 collect_cores (struct thread_info
*ti
, void *xdata
)
622 struct collect_cores_data
*data
= (struct collect_cores_data
*) xdata
;
624 if (ti
->ptid
.pid () == data
->pid
)
626 int core
= target_core_of_thread (ti
->ptid
);
629 data
->cores
.insert (core
);
635 struct print_one_inferior_data
638 const std::set
<int> *inferiors
;
642 print_one_inferior (struct inferior
*inferior
, void *xdata
)
644 struct print_one_inferior_data
*top_data
645 = (struct print_one_inferior_data
*) xdata
;
646 struct ui_out
*uiout
= current_uiout
;
648 if (top_data
->inferiors
->empty ()
649 || (top_data
->inferiors
->find (inferior
->pid
)
650 != top_data
->inferiors
->end ()))
652 struct collect_cores_data data
;
653 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
655 uiout
->field_fmt ("id", "i%d", inferior
->num
);
656 uiout
->field_string ("type", "process");
657 if (inferior
->has_exit_code
)
658 uiout
->field_string ("exit-code",
659 int_string (inferior
->exit_code
, 8, 0, 0, 1));
660 if (inferior
->pid
!= 0)
661 uiout
->field_int ("pid", inferior
->pid
);
663 if (inferior
->pspace
->pspace_exec_filename
!= NULL
)
665 uiout
->field_string ("executable",
666 inferior
->pspace
->pspace_exec_filename
);
669 if (inferior
->pid
!= 0)
671 data
.pid
= inferior
->pid
;
672 iterate_over_threads (collect_cores
, &data
);
675 if (!data
.cores
.empty ())
677 ui_out_emit_list
list_emitter (uiout
, "cores");
679 for (int b
: data
.cores
)
680 uiout
->field_int (NULL
, b
);
683 if (top_data
->recurse
)
684 print_thread_info (uiout
, NULL
, inferior
->pid
);
690 /* Output a field named 'cores' with a list as the value. The
691 elements of the list are obtained by splitting 'cores' on
695 output_cores (struct ui_out
*uiout
, const char *field_name
, const char *xcores
)
697 ui_out_emit_list
list_emitter (uiout
, field_name
);
698 gdb::unique_xmalloc_ptr
<char> cores (xstrdup (xcores
));
699 char *p
= cores
.get ();
701 for (p
= strtok (p
, ","); p
; p
= strtok (NULL
, ","))
702 uiout
->field_string (NULL
, p
);
706 list_available_thread_groups (const std::set
<int> &ids
, int recurse
)
708 struct ui_out
*uiout
= current_uiout
;
710 /* This keeps a map from integer (pid) to vector of struct osdata_item.
711 The vector contains information about all threads for the given pid. */
712 std::map
<int, std::vector
<osdata_item
>> tree
;
714 /* get_osdata will throw if it cannot return data. */
715 std::unique_ptr
<osdata
> data
= get_osdata ("processes");
719 std::unique_ptr
<osdata
> threads
= get_osdata ("threads");
721 for (const osdata_item
&item
: threads
->items
)
723 const std::string
*pid
= get_osdata_column (item
, "pid");
724 int pid_i
= strtoul (pid
->c_str (), NULL
, 0);
726 tree
[pid_i
].push_back (item
);
730 ui_out_emit_list
list_emitter (uiout
, "groups");
732 for (const osdata_item
&item
: data
->items
)
734 const std::string
*pid
= get_osdata_column (item
, "pid");
735 const std::string
*cmd
= get_osdata_column (item
, "command");
736 const std::string
*user
= get_osdata_column (item
, "user");
737 const std::string
*cores
= get_osdata_column (item
, "cores");
739 int pid_i
= strtoul (pid
->c_str (), NULL
, 0);
741 /* At present, the target will return all available processes
742 and if information about specific ones was required, we filter
743 undesired processes here. */
744 if (!ids
.empty () && ids
.find (pid_i
) == ids
.end ())
747 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
749 uiout
->field_fmt ("id", "%s", pid
->c_str ());
750 uiout
->field_string ("type", "process");
752 uiout
->field_string ("description", cmd
->c_str ());
754 uiout
->field_string ("user", user
->c_str ());
756 output_cores (uiout
, "cores", cores
->c_str ());
760 auto n
= tree
.find (pid_i
);
761 if (n
!= tree
.end ())
763 std::vector
<osdata_item
> &children
= n
->second
;
765 ui_out_emit_list
thread_list_emitter (uiout
, "threads");
767 for (const osdata_item
&child
: children
)
769 ui_out_emit_tuple
inner_tuple_emitter (uiout
, NULL
);
770 const std::string
*tid
= get_osdata_column (child
, "tid");
771 const std::string
*tcore
= get_osdata_column (child
, "core");
773 uiout
->field_string ("id", tid
->c_str ());
775 uiout
->field_string ("core", tcore
->c_str ());
783 mi_cmd_list_thread_groups (const char *command
, char **argv
, int argc
)
785 struct ui_out
*uiout
= current_uiout
;
792 AVAILABLE_OPT
, RECURSE_OPT
794 static const struct mi_opt opts
[] =
796 {"-available", AVAILABLE_OPT
, 0},
797 {"-recurse", RECURSE_OPT
, 1},
806 int opt
= mi_getopt ("-list-thread-groups", argc
, argv
, opts
,
811 switch ((enum opt
) opt
)
817 if (strcmp (oarg
, "0") == 0)
819 else if (strcmp (oarg
, "1") == 0)
822 error (_("only '0' and '1' are valid values "
823 "for the '--recurse' option"));
828 for (; oind
< argc
; ++oind
)
833 if (*(argv
[oind
]) != 'i')
834 error (_("invalid syntax of group id '%s'"), argv
[oind
]);
836 inf
= strtoul (argv
[oind
] + 1, &end
, 0);
839 error (_("invalid syntax of group id '%s'"), argv
[oind
]);
845 list_available_thread_groups (ids
, recurse
);
847 else if (ids
.size () == 1)
849 /* Local thread groups, single id. */
850 int id
= *(ids
.begin ());
851 struct inferior
*inf
= find_inferior_id (id
);
854 error (_("Non-existent thread group id '%d'"), id
);
856 print_thread_info (uiout
, NULL
, inf
->pid
);
860 struct print_one_inferior_data data
;
862 data
.recurse
= recurse
;
863 data
.inferiors
= &ids
;
865 /* Local thread groups. Either no explicit ids -- and we
866 print everything, or several explicit ids. In both cases,
867 we print more than one group, and have to use 'groups'
868 as the top-level element. */
869 ui_out_emit_list
list_emitter (uiout
, "groups");
870 update_thread_list ();
871 iterate_over_inferiors (print_one_inferior
, &data
);
876 mi_cmd_data_list_register_names (const char *command
, char **argv
, int argc
)
878 struct gdbarch
*gdbarch
;
879 struct ui_out
*uiout
= current_uiout
;
883 /* Note that the test for a valid register must include checking the
884 gdbarch_register_name because gdbarch_num_regs may be allocated
885 for the union of the register sets within a family of related
886 processors. In this case, some entries of gdbarch_register_name
887 will change depending upon the particular processor being
890 gdbarch
= get_current_arch ();
891 numregs
= gdbarch_num_cooked_regs (gdbarch
);
893 ui_out_emit_list
list_emitter (uiout
, "register-names");
895 if (argc
== 0) /* No args, just do all the regs. */
901 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
902 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
903 uiout
->field_string (NULL
, "");
905 uiout
->field_string (NULL
, gdbarch_register_name (gdbarch
, regnum
));
909 /* Else, list of register #s, just do listed regs. */
910 for (i
= 0; i
< argc
; i
++)
912 regnum
= atoi (argv
[i
]);
913 if (regnum
< 0 || regnum
>= numregs
)
914 error (_("bad register number"));
916 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
917 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
918 uiout
->field_string (NULL
, "");
920 uiout
->field_string (NULL
, gdbarch_register_name (gdbarch
, regnum
));
925 mi_cmd_data_list_changed_registers (const char *command
, char **argv
, int argc
)
927 static std::unique_ptr
<readonly_detached_regcache
> this_regs
;
928 struct ui_out
*uiout
= current_uiout
;
929 std::unique_ptr
<readonly_detached_regcache
> prev_regs
;
930 struct gdbarch
*gdbarch
;
934 /* The last time we visited this function, the current frame's
935 register contents were saved in THIS_REGS. Move THIS_REGS over
936 to PREV_REGS, and refresh THIS_REGS with the now-current register
939 prev_regs
= std::move (this_regs
);
940 this_regs
= frame_save_as_regcache (get_selected_frame (NULL
));
942 /* Note that the test for a valid register must include checking the
943 gdbarch_register_name because gdbarch_num_regs may be allocated
944 for the union of the register sets within a family of related
945 processors. In this case, some entries of gdbarch_register_name
946 will change depending upon the particular processor being
949 gdbarch
= this_regs
->arch ();
950 numregs
= gdbarch_num_cooked_regs (gdbarch
);
952 ui_out_emit_list
list_emitter (uiout
, "changed-registers");
956 /* No args, just do all the regs. */
961 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
962 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
965 if (register_changed_p (regnum
, prev_regs
.get (),
967 uiout
->field_int (NULL
, regnum
);
971 /* Else, list of register #s, just do listed regs. */
972 for (i
= 0; i
< argc
; i
++)
974 regnum
= atoi (argv
[i
]);
978 && gdbarch_register_name (gdbarch
, regnum
) != NULL
979 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
981 if (register_changed_p (regnum
, prev_regs
.get (),
983 uiout
->field_int (NULL
, regnum
);
986 error (_("bad register number"));
991 register_changed_p (int regnum
, readonly_detached_regcache
*prev_regs
,
992 readonly_detached_regcache
*this_regs
)
994 struct gdbarch
*gdbarch
= this_regs
->arch ();
995 struct value
*prev_value
, *this_value
;
997 /* First time through or after gdbarch change consider all registers
999 if (!prev_regs
|| prev_regs
->arch () != gdbarch
)
1002 /* Get register contents and compare. */
1003 prev_value
= prev_regs
->cooked_read_value (regnum
);
1004 this_value
= this_regs
->cooked_read_value (regnum
);
1005 gdb_assert (prev_value
!= NULL
);
1006 gdb_assert (this_value
!= NULL
);
1008 auto ret
= !value_contents_eq (prev_value
, 0, this_value
, 0,
1009 register_size (gdbarch
, regnum
));
1011 release_value (prev_value
);
1012 release_value (this_value
);
1016 /* Return a list of register number and value pairs. The valid
1017 arguments expected are: a letter indicating the format in which to
1018 display the registers contents. This can be one of: x
1019 (hexadecimal), d (decimal), N (natural), t (binary), o (octal), r
1020 (raw). After the format argument there can be a sequence of
1021 numbers, indicating which registers to fetch the content of. If
1022 the format is the only argument, a list of all the registers with
1023 their values is returned. */
1026 mi_cmd_data_list_register_values (const char *command
, char **argv
, int argc
)
1028 struct ui_out
*uiout
= current_uiout
;
1029 struct frame_info
*frame
;
1030 struct gdbarch
*gdbarch
;
1031 int regnum
, numregs
, format
;
1033 int skip_unavailable
= 0;
1039 static const struct mi_opt opts
[] =
1041 {"-skip-unavailable", SKIP_UNAVAILABLE
, 0},
1045 /* Note that the test for a valid register must include checking the
1046 gdbarch_register_name because gdbarch_num_regs may be allocated
1047 for the union of the register sets within a family of related
1048 processors. In this case, some entries of gdbarch_register_name
1049 will change depending upon the particular processor being
1055 int opt
= mi_getopt ("-data-list-register-values", argc
, argv
,
1056 opts
, &oind
, &oarg
);
1060 switch ((enum opt
) opt
)
1062 case SKIP_UNAVAILABLE
:
1063 skip_unavailable
= 1;
1068 if (argc
- oind
< 1)
1069 error (_("-data-list-register-values: Usage: "
1070 "-data-list-register-values [--skip-unavailable] <format>"
1071 " [<regnum1>...<regnumN>]"));
1073 format
= (int) argv
[oind
][0];
1075 frame
= get_selected_frame (NULL
);
1076 gdbarch
= get_frame_arch (frame
);
1077 numregs
= gdbarch_num_cooked_regs (gdbarch
);
1079 ui_out_emit_list
list_emitter (uiout
, "register-values");
1081 if (argc
- oind
== 1)
1083 /* No args, beside the format: do all the regs. */
1088 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1089 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1092 output_register (frame
, regnum
, format
, skip_unavailable
);
1096 /* Else, list of register #s, just do listed regs. */
1097 for (i
= 1 + oind
; i
< argc
; i
++)
1099 regnum
= atoi (argv
[i
]);
1103 && gdbarch_register_name (gdbarch
, regnum
) != NULL
1104 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
1105 output_register (frame
, regnum
, format
, skip_unavailable
);
1107 error (_("bad register number"));
1111 /* Output one register REGNUM's contents in the desired FORMAT. If
1112 SKIP_UNAVAILABLE is true, skip the register if it is
1116 output_register (struct frame_info
*frame
, int regnum
, int format
,
1117 int skip_unavailable
)
1119 struct ui_out
*uiout
= current_uiout
;
1120 struct value
*val
= value_of_register (regnum
, frame
);
1121 struct value_print_options opts
;
1123 if (skip_unavailable
&& !value_entirely_available (val
))
1126 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1127 uiout
->field_int ("number", regnum
);
1137 get_formatted_print_options (&opts
, format
);
1139 val_print (value_type (val
),
1140 value_embedded_offset (val
), 0,
1141 &stb
, 0, val
, &opts
, current_language
);
1142 uiout
->field_stream ("value", stb
);
1145 /* Write given values into registers. The registers and values are
1146 given as pairs. The corresponding MI command is
1147 -data-write-register-values <format>
1148 [<regnum1> <value1>...<regnumN> <valueN>] */
1150 mi_cmd_data_write_register_values (const char *command
, char **argv
, int argc
)
1152 struct regcache
*regcache
;
1153 struct gdbarch
*gdbarch
;
1156 /* Note that the test for a valid register must include checking the
1157 gdbarch_register_name because gdbarch_num_regs may be allocated
1158 for the union of the register sets within a family of related
1159 processors. In this case, some entries of gdbarch_register_name
1160 will change depending upon the particular processor being
1163 regcache
= get_current_regcache ();
1164 gdbarch
= regcache
->arch ();
1165 numregs
= gdbarch_num_cooked_regs (gdbarch
);
1168 error (_("-data-write-register-values: Usage: -data-write-register-"
1169 "values <format> [<regnum1> <value1>...<regnumN> <valueN>]"));
1171 if (!target_has_registers
)
1172 error (_("-data-write-register-values: No registers."));
1175 error (_("-data-write-register-values: No regs and values specified."));
1178 error (_("-data-write-register-values: "
1179 "Regs and vals are not in pairs."));
1181 for (i
= 1; i
< argc
; i
= i
+ 2)
1183 int regnum
= atoi (argv
[i
]);
1185 if (regnum
>= 0 && regnum
< numregs
1186 && gdbarch_register_name (gdbarch
, regnum
)
1187 && *gdbarch_register_name (gdbarch
, regnum
))
1191 /* Get the value as a number. */
1192 value
= parse_and_eval_address (argv
[i
+ 1]);
1194 /* Write it down. */
1195 regcache_cooked_write_signed (regcache
, regnum
, value
);
1198 error (_("bad register number"));
1202 /* Evaluate the value of the argument. The argument is an
1203 expression. If the expression contains spaces it needs to be
1204 included in double quotes. */
1207 mi_cmd_data_evaluate_expression (const char *command
, char **argv
, int argc
)
1210 struct value_print_options opts
;
1211 struct ui_out
*uiout
= current_uiout
;
1214 error (_("-data-evaluate-expression: "
1215 "Usage: -data-evaluate-expression expression"));
1217 expression_up expr
= parse_expression (argv
[0]);
1219 val
= evaluate_expression (expr
.get ());
1223 /* Print the result of the expression evaluation. */
1224 get_user_print_options (&opts
);
1226 common_val_print (val
, &stb
, 0, &opts
, current_language
);
1228 uiout
->field_stream ("value", stb
);
1231 /* This is the -data-read-memory command.
1233 ADDR: start address of data to be dumped.
1234 WORD-FORMAT: a char indicating format for the ``word''. See
1236 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes.
1237 NR_ROW: Number of rows.
1238 NR_COL: The number of colums (words per row).
1239 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
1240 ASCHAR for unprintable characters.
1242 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
1243 displayes them. Returns:
1245 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
1248 The number of bytes read is SIZE*ROW*COL. */
1251 mi_cmd_data_read_memory (const char *command
, char **argv
, int argc
)
1253 struct gdbarch
*gdbarch
= get_current_arch ();
1254 struct ui_out
*uiout
= current_uiout
;
1256 long total_bytes
, nr_cols
, nr_rows
;
1258 struct type
*word_type
;
1270 static const struct mi_opt opts
[] =
1272 {"o", OFFSET_OPT
, 1},
1278 int opt
= mi_getopt ("-data-read-memory", argc
, argv
, opts
,
1283 switch ((enum opt
) opt
)
1286 offset
= atol (oarg
);
1293 if (argc
< 5 || argc
> 6)
1294 error (_("-data-read-memory: Usage: "
1295 "ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR]."));
1297 /* Extract all the arguments. */
1299 /* Start address of the memory dump. */
1300 addr
= parse_and_eval_address (argv
[0]) + offset
;
1301 /* The format character to use when displaying a memory word. See
1302 the ``x'' command. */
1303 word_format
= argv
[1][0];
1304 /* The size of the memory word. */
1305 word_size
= atol (argv
[2]);
1309 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1313 word_type
= builtin_type (gdbarch
)->builtin_int16
;
1317 word_type
= builtin_type (gdbarch
)->builtin_int32
;
1321 word_type
= builtin_type (gdbarch
)->builtin_int64
;
1325 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1328 /* The number of rows. */
1329 nr_rows
= atol (argv
[3]);
1331 error (_("-data-read-memory: invalid number of rows."));
1333 /* Number of bytes per row. */
1334 nr_cols
= atol (argv
[4]);
1336 error (_("-data-read-memory: invalid number of columns."));
1338 /* The un-printable character when printing ascii. */
1344 /* Create a buffer and read it in. */
1345 total_bytes
= word_size
* nr_rows
* nr_cols
;
1347 gdb::byte_vector
mbuf (total_bytes
);
1349 nr_bytes
= target_read (current_top_target (), TARGET_OBJECT_MEMORY
, NULL
,
1350 mbuf
.data (), addr
, total_bytes
);
1352 error (_("Unable to read memory."));
1354 /* Output the header information. */
1355 uiout
->field_core_addr ("addr", gdbarch
, addr
);
1356 uiout
->field_int ("nr-bytes", nr_bytes
);
1357 uiout
->field_int ("total-bytes", total_bytes
);
1358 uiout
->field_core_addr ("next-row", gdbarch
, addr
+ word_size
* nr_cols
);
1359 uiout
->field_core_addr ("prev-row", gdbarch
, addr
- word_size
* nr_cols
);
1360 uiout
->field_core_addr ("next-page", gdbarch
, addr
+ total_bytes
);
1361 uiout
->field_core_addr ("prev-page", gdbarch
, addr
- total_bytes
);
1363 /* Build the result as a two dimentional table. */
1370 ui_out_emit_list
list_emitter (uiout
, "memory");
1371 for (row
= 0, row_byte
= 0;
1373 row
++, row_byte
+= nr_cols
* word_size
)
1377 struct value_print_options print_opts
;
1379 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1380 uiout
->field_core_addr ("addr", gdbarch
, addr
+ row_byte
);
1381 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr +
1384 ui_out_emit_list
list_data_emitter (uiout
, "data");
1385 get_formatted_print_options (&print_opts
, word_format
);
1386 for (col
= 0, col_byte
= row_byte
;
1388 col
++, col_byte
+= word_size
)
1390 if (col_byte
+ word_size
> nr_bytes
)
1392 uiout
->field_string (NULL
, "N/A");
1397 print_scalar_formatted (&mbuf
[col_byte
], word_type
,
1398 &print_opts
, word_asize
, &stream
);
1399 uiout
->field_stream (NULL
, stream
);
1409 for (byte
= row_byte
;
1410 byte
< row_byte
+ word_size
* nr_cols
; byte
++)
1412 if (byte
>= nr_bytes
)
1414 else if (mbuf
[byte
] < 32 || mbuf
[byte
] > 126)
1415 stream
.putc (aschar
);
1417 stream
.putc (mbuf
[byte
]);
1419 uiout
->field_stream ("ascii", stream
);
1426 mi_cmd_data_read_memory_bytes (const char *command
, char **argv
, int argc
)
1428 struct gdbarch
*gdbarch
= get_current_arch ();
1429 struct ui_out
*uiout
= current_uiout
;
1433 int unit_size
= gdbarch_addressable_memory_unit_size (gdbarch
);
1440 static const struct mi_opt opts
[] =
1442 {"o", OFFSET_OPT
, 1},
1448 int opt
= mi_getopt ("-data-read-memory-bytes", argc
, argv
, opts
,
1452 switch ((enum opt
) opt
)
1455 offset
= atol (oarg
);
1463 error (_("Usage: [ -o OFFSET ] ADDR LENGTH."));
1465 addr
= parse_and_eval_address (argv
[0]) + offset
;
1466 length
= atol (argv
[1]);
1468 std::vector
<memory_read_result
> result
1469 = read_memory_robust (current_top_target (), addr
, length
);
1471 if (result
.size () == 0)
1472 error (_("Unable to read memory."));
1474 ui_out_emit_list
list_emitter (uiout
, "memory");
1475 for (const memory_read_result
&read_result
: result
)
1477 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1479 uiout
->field_core_addr ("begin", gdbarch
, read_result
.begin
);
1480 uiout
->field_core_addr ("offset", gdbarch
, read_result
.begin
- addr
);
1481 uiout
->field_core_addr ("end", gdbarch
, read_result
.end
);
1483 std::string data
= bin2hex (read_result
.data
.get (),
1484 (read_result
.end
- read_result
.begin
)
1486 uiout
->field_string ("contents", data
.c_str ());
1490 /* Implementation of the -data-write_memory command.
1492 COLUMN_OFFSET: optional argument. Must be preceded by '-o'. The
1493 offset from the beginning of the memory grid row where the cell to
1495 ADDR: start address of the row in the memory grid where the memory
1496 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
1497 the location to write to.
1498 FORMAT: a char indicating format for the ``word''. See
1500 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
1501 VALUE: value to be written into the memory address.
1503 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
1508 mi_cmd_data_write_memory (const char *command
, char **argv
, int argc
)
1510 struct gdbarch
*gdbarch
= get_current_arch ();
1511 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1514 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
1515 enough when using a compiler other than GCC. */
1524 static const struct mi_opt opts
[] =
1526 {"o", OFFSET_OPT
, 1},
1532 int opt
= mi_getopt ("-data-write-memory", argc
, argv
, opts
,
1537 switch ((enum opt
) opt
)
1540 offset
= atol (oarg
);
1548 error (_("-data-write-memory: Usage: "
1549 "[-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE."));
1551 /* Extract all the arguments. */
1552 /* Start address of the memory dump. */
1553 addr
= parse_and_eval_address (argv
[0]);
1554 /* The size of the memory word. */
1555 word_size
= atol (argv
[2]);
1557 /* Calculate the real address of the write destination. */
1558 addr
+= (offset
* word_size
);
1560 /* Get the value as a number. */
1561 value
= parse_and_eval_address (argv
[3]);
1562 /* Get the value into an array. */
1563 gdb::byte_vector
buffer (word_size
);
1564 store_signed_integer (buffer
.data (), word_size
, byte_order
, value
);
1565 /* Write it down to memory. */
1566 write_memory_with_notification (addr
, buffer
.data (), word_size
);
1569 /* Implementation of the -data-write-memory-bytes command.
1572 DATA: string of bytes to write at that address
1573 COUNT: number of bytes to be filled (decimal integer). */
1576 mi_cmd_data_write_memory_bytes (const char *command
, char **argv
, int argc
)
1580 size_t len_hex
, len_bytes
, len_units
, i
, steps
, remaining_units
;
1581 long int count_units
;
1584 if (argc
!= 2 && argc
!= 3)
1585 error (_("Usage: ADDR DATA [COUNT]."));
1587 addr
= parse_and_eval_address (argv
[0]);
1589 len_hex
= strlen (cdata
);
1590 unit_size
= gdbarch_addressable_memory_unit_size (get_current_arch ());
1592 if (len_hex
% (unit_size
* 2) != 0)
1593 error (_("Hex-encoded '%s' must represent an integral number of "
1594 "addressable memory units."),
1597 len_bytes
= len_hex
/ 2;
1598 len_units
= len_bytes
/ unit_size
;
1601 count_units
= strtoul (argv
[2], NULL
, 10);
1603 count_units
= len_units
;
1605 gdb::byte_vector
databuf (len_bytes
);
1607 for (i
= 0; i
< len_bytes
; ++i
)
1610 if (sscanf (cdata
+ i
* 2, "%02x", &x
) != 1)
1611 error (_("Invalid argument"));
1612 databuf
[i
] = (gdb_byte
) x
;
1615 gdb::byte_vector data
;
1616 if (len_units
< count_units
)
1618 /* Pattern is made of less units than count:
1619 repeat pattern to fill memory. */
1620 data
= gdb::byte_vector (count_units
* unit_size
);
1622 /* Number of times the pattern is entirely repeated. */
1623 steps
= count_units
/ len_units
;
1624 /* Number of remaining addressable memory units. */
1625 remaining_units
= count_units
% len_units
;
1626 for (i
= 0; i
< steps
; i
++)
1627 memcpy (&data
[i
* len_bytes
], &databuf
[0], len_bytes
);
1629 if (remaining_units
> 0)
1630 memcpy (&data
[steps
* len_bytes
], &databuf
[0],
1631 remaining_units
* unit_size
);
1635 /* Pattern is longer than or equal to count:
1636 just copy count addressable memory units. */
1637 data
= std::move (databuf
);
1640 write_memory_with_notification (addr
, data
.data (), count_units
);
1644 mi_cmd_enable_timings (const char *command
, char **argv
, int argc
)
1650 if (strcmp (argv
[0], "yes") == 0)
1652 else if (strcmp (argv
[0], "no") == 0)
1663 error (_("-enable-timings: Usage: %s {yes|no}"), command
);
1667 mi_cmd_list_features (const char *command
, char **argv
, int argc
)
1671 struct ui_out
*uiout
= current_uiout
;
1673 ui_out_emit_list
list_emitter (uiout
, "features");
1674 uiout
->field_string (NULL
, "frozen-varobjs");
1675 uiout
->field_string (NULL
, "pending-breakpoints");
1676 uiout
->field_string (NULL
, "thread-info");
1677 uiout
->field_string (NULL
, "data-read-memory-bytes");
1678 uiout
->field_string (NULL
, "breakpoint-notifications");
1679 uiout
->field_string (NULL
, "ada-task-info");
1680 uiout
->field_string (NULL
, "language-option");
1681 uiout
->field_string (NULL
, "info-gdb-mi-command");
1682 uiout
->field_string (NULL
, "undefined-command-error-code");
1683 uiout
->field_string (NULL
, "exec-run-start-option");
1684 uiout
->field_string (NULL
, "data-disassemble-a-option");
1686 if (ext_lang_initialized_p (get_ext_lang_defn (EXT_LANG_PYTHON
)))
1687 uiout
->field_string (NULL
, "python");
1692 error (_("-list-features should be passed no arguments"));
1696 mi_cmd_list_target_features (const char *command
, char **argv
, int argc
)
1700 struct ui_out
*uiout
= current_uiout
;
1702 ui_out_emit_list
list_emitter (uiout
, "features");
1704 uiout
->field_string (NULL
, "async");
1705 if (target_can_execute_reverse
)
1706 uiout
->field_string (NULL
, "reverse");
1710 error (_("-list-target-features should be passed no arguments"));
1714 mi_cmd_add_inferior (const char *command
, char **argv
, int argc
)
1716 struct inferior
*inf
;
1719 error (_("-add-inferior should be passed no arguments"));
1721 inf
= add_inferior_with_spaces ();
1723 current_uiout
->field_fmt ("inferior", "i%d", inf
->num
);
1726 /* Callback used to find the first inferior other than the current
1730 get_other_inferior (struct inferior
*inf
, void *arg
)
1732 if (inf
== current_inferior ())
1739 mi_cmd_remove_inferior (const char *command
, char **argv
, int argc
)
1742 struct inferior
*inf
;
1745 error (_("-remove-inferior should be passed a single argument"));
1747 if (sscanf (argv
[0], "i%d", &id
) != 1)
1748 error (_("the thread group id is syntactically invalid"));
1750 inf
= find_inferior_id (id
);
1752 error (_("the specified thread group does not exist"));
1755 error (_("cannot remove an active inferior"));
1757 if (inf
== current_inferior ())
1759 struct thread_info
*tp
= 0;
1760 struct inferior
*new_inferior
1761 = iterate_over_inferiors (get_other_inferior
, NULL
);
1763 if (new_inferior
== NULL
)
1764 error (_("Cannot remove last inferior"));
1766 set_current_inferior (new_inferior
);
1767 if (new_inferior
->pid
!= 0)
1768 tp
= any_thread_of_inferior (new_inferior
);
1770 switch_to_thread (tp
);
1772 switch_to_no_thread ();
1773 set_current_program_space (new_inferior
->pspace
);
1776 delete_inferior (inf
);
1781 /* Execute a command within a safe environment.
1782 Return <0 for error; >=0 for ok.
1784 args->action will tell mi_execute_command what action
1785 to perform after the given command has executed (display/suppress
1786 prompt, display error). */
1789 captured_mi_execute_command (struct ui_out
*uiout
, struct mi_parse
*context
)
1791 struct mi_interp
*mi
= (struct mi_interp
*) command_interp ();
1794 current_command_ts
= context
->cmd_start
;
1796 scoped_restore save_token
= make_scoped_restore (¤t_token
,
1799 running_result_record_printed
= 0;
1801 switch (context
->op
)
1804 /* A MI command was read from the input stream. */
1806 /* FIXME: gdb_???? */
1807 fprintf_unfiltered (mi
->raw_stdout
,
1808 " token=`%s' command=`%s' args=`%s'\n",
1809 context
->token
, context
->command
, context
->args
);
1811 mi_cmd_execute (context
);
1813 /* Print the result if there were no errors.
1815 Remember that on the way out of executing a command, you have
1816 to directly use the mi_interp's uiout, since the command
1817 could have reset the interpreter, in which case the current
1818 uiout will most likely crash in the mi_out_* routines. */
1819 if (!running_result_record_printed
)
1821 fputs_unfiltered (context
->token
, mi
->raw_stdout
);
1822 /* There's no particularly good reason why target-connect results
1823 in not ^done. Should kill ^connected for MI3. */
1824 fputs_unfiltered (strcmp (context
->command
, "target-select") == 0
1825 ? "^connected" : "^done", mi
->raw_stdout
);
1826 mi_out_put (uiout
, mi
->raw_stdout
);
1827 mi_out_rewind (uiout
);
1828 mi_print_timing_maybe (mi
->raw_stdout
);
1829 fputs_unfiltered ("\n", mi
->raw_stdout
);
1832 /* The command does not want anything to be printed. In that
1833 case, the command probably should not have written anything
1834 to uiout, but in case it has written something, discard it. */
1835 mi_out_rewind (uiout
);
1842 /* A CLI command was read from the input stream. */
1843 /* This "feature" will be removed as soon as we have a
1844 complete set of mi commands. */
1845 /* Echo the command on the console. */
1846 fprintf_unfiltered (gdb_stdlog
, "%s\n", context
->command
);
1847 /* Call the "console" interpreter. */
1848 argv
[0] = (char *) INTERP_CONSOLE
;
1849 argv
[1] = context
->command
;
1850 mi_cmd_interpreter_exec ("-interpreter-exec", argv
, 2);
1852 /* If we changed interpreters, DON'T print out anything. */
1853 if (current_interp_named_p (INTERP_MI
)
1854 || current_interp_named_p (INTERP_MI1
)
1855 || current_interp_named_p (INTERP_MI2
)
1856 || current_interp_named_p (INTERP_MI3
))
1858 if (!running_result_record_printed
)
1860 fputs_unfiltered (context
->token
, mi
->raw_stdout
);
1861 fputs_unfiltered ("^done", mi
->raw_stdout
);
1862 mi_out_put (uiout
, mi
->raw_stdout
);
1863 mi_out_rewind (uiout
);
1864 mi_print_timing_maybe (mi
->raw_stdout
);
1865 fputs_unfiltered ("\n", mi
->raw_stdout
);
1868 mi_out_rewind (uiout
);
1875 /* Print a gdb exception to the MI output stream. */
1878 mi_print_exception (const char *token
, struct gdb_exception exception
)
1880 struct mi_interp
*mi
= (struct mi_interp
*) current_interpreter ();
1882 fputs_unfiltered (token
, mi
->raw_stdout
);
1883 fputs_unfiltered ("^error,msg=\"", mi
->raw_stdout
);
1884 if (exception
.message
== NULL
)
1885 fputs_unfiltered ("unknown error", mi
->raw_stdout
);
1887 fputstr_unfiltered (exception
.message
, '"', mi
->raw_stdout
);
1888 fputs_unfiltered ("\"", mi
->raw_stdout
);
1890 switch (exception
.error
)
1892 case UNDEFINED_COMMAND_ERROR
:
1893 fputs_unfiltered (",code=\"undefined-command\"", mi
->raw_stdout
);
1897 fputs_unfiltered ("\n", mi
->raw_stdout
);
1900 /* Determine whether the parsed command already notifies the
1901 user_selected_context_changed observer. */
1904 command_notifies_uscc_observer (struct mi_parse
*command
)
1906 if (command
->op
== CLI_COMMAND
)
1908 /* CLI commands "thread" and "inferior" already send it. */
1909 return (strncmp (command
->command
, "thread ", 7) == 0
1910 || strncmp (command
->command
, "inferior ", 9) == 0);
1912 else /* MI_COMMAND */
1914 if (strcmp (command
->command
, "interpreter-exec") == 0
1915 && command
->argc
> 1)
1917 /* "thread" and "inferior" again, but through -interpreter-exec. */
1918 return (strncmp (command
->argv
[1], "thread ", 7) == 0
1919 || strncmp (command
->argv
[1], "inferior ", 9) == 0);
1923 /* -thread-select already sends it. */
1924 return strcmp (command
->command
, "thread-select") == 0;
1929 mi_execute_command (const char *cmd
, int from_tty
)
1932 std::unique_ptr
<struct mi_parse
> command
;
1934 /* This is to handle EOF (^D). We just quit gdb. */
1935 /* FIXME: we should call some API function here. */
1937 quit_force (NULL
, from_tty
);
1939 target_log_command (cmd
);
1943 command
= mi_parse (cmd
, &token
);
1945 CATCH (exception
, RETURN_MASK_ALL
)
1947 mi_print_exception (token
, exception
);
1952 if (command
!= NULL
)
1954 ptid_t previous_ptid
= inferior_ptid
;
1956 gdb::optional
<scoped_restore_tmpl
<int>> restore_suppress
;
1958 if (command
->cmd
!= NULL
&& command
->cmd
->suppress_notification
!= NULL
)
1959 restore_suppress
.emplace (command
->cmd
->suppress_notification
, 1);
1961 command
->token
= token
;
1965 command
->cmd_start
= new mi_timestamp ();
1966 timestamp (command
->cmd_start
);
1971 captured_mi_execute_command (current_uiout
, command
.get ());
1973 CATCH (result
, RETURN_MASK_ALL
)
1975 /* Like in start_event_loop, enable input and force display
1976 of the prompt. Otherwise, any command that calls
1977 async_disable_stdin, and then throws, will leave input
1979 async_enable_stdin ();
1980 current_ui
->prompt_state
= PROMPT_NEEDED
;
1982 /* The command execution failed and error() was called
1984 mi_print_exception (command
->token
, result
);
1985 mi_out_rewind (current_uiout
);
1989 bpstat_do_actions ();
1991 if (/* The notifications are only output when the top-level
1992 interpreter (specified on the command line) is MI. */
1993 top_level_interpreter ()->interp_ui_out ()->is_mi_like_p ()
1994 /* Don't try report anything if there are no threads --
1995 the program is dead. */
1997 /* If the command already reports the thread change, no need to do it
1999 && !command_notifies_uscc_observer (command
.get ()))
2001 int report_change
= 0;
2003 if (command
->thread
== -1)
2005 report_change
= (previous_ptid
!= null_ptid
2006 && inferior_ptid
!= previous_ptid
2007 && inferior_ptid
!= null_ptid
);
2009 else if (inferior_ptid
!= null_ptid
)
2011 struct thread_info
*ti
= inferior_thread ();
2013 report_change
= (ti
->global_num
!= command
->thread
);
2018 gdb::observers::user_selected_context_changed
.notify
2019 (USER_SELECTED_THREAD
| USER_SELECTED_FRAME
);
2026 mi_cmd_execute (struct mi_parse
*parse
)
2028 scoped_value_mark cleanup
= prepare_execute_command ();
2030 if (parse
->all
&& parse
->thread_group
!= -1)
2031 error (_("Cannot specify --thread-group together with --all"));
2033 if (parse
->all
&& parse
->thread
!= -1)
2034 error (_("Cannot specify --thread together with --all"));
2036 if (parse
->thread_group
!= -1 && parse
->thread
!= -1)
2037 error (_("Cannot specify --thread together with --thread-group"));
2039 if (parse
->frame
!= -1 && parse
->thread
== -1)
2040 error (_("Cannot specify --frame without --thread"));
2042 if (parse
->thread_group
!= -1)
2044 struct inferior
*inf
= find_inferior_id (parse
->thread_group
);
2045 struct thread_info
*tp
= 0;
2048 error (_("Invalid thread group for the --thread-group option"));
2050 set_current_inferior (inf
);
2051 /* This behaviour means that if --thread-group option identifies
2052 an inferior with multiple threads, then a random one will be
2053 picked. This is not a problem -- frontend should always
2054 provide --thread if it wishes to operate on a specific
2057 tp
= any_live_thread_of_inferior (inf
);
2059 switch_to_thread (tp
);
2061 switch_to_no_thread ();
2062 set_current_program_space (inf
->pspace
);
2065 if (parse
->thread
!= -1)
2067 thread_info
*tp
= find_thread_global_id (parse
->thread
);
2070 error (_("Invalid thread id: %d"), parse
->thread
);
2072 if (tp
->state
== THREAD_EXITED
)
2073 error (_("Thread id: %d has terminated"), parse
->thread
);
2075 switch_to_thread (tp
);
2078 if (parse
->frame
!= -1)
2080 struct frame_info
*fid
;
2081 int frame
= parse
->frame
;
2083 fid
= find_relative_frame (get_current_frame (), &frame
);
2085 /* find_relative_frame was successful */
2088 error (_("Invalid frame id: %d"), frame
);
2091 gdb::optional
<scoped_restore_current_language
> lang_saver
;
2092 if (parse
->language
!= language_unknown
)
2094 lang_saver
.emplace ();
2095 set_language (parse
->language
);
2098 current_context
= parse
;
2100 if (parse
->cmd
->argv_func
!= NULL
)
2102 parse
->cmd
->argv_func (parse
->command
, parse
->argv
, parse
->argc
);
2104 else if (parse
->cmd
->cli
.cmd
!= 0)
2106 /* FIXME: DELETE THIS. */
2107 /* The operation is still implemented by a cli command. */
2108 /* Must be a synchronous one. */
2109 mi_execute_cli_command (parse
->cmd
->cli
.cmd
, parse
->cmd
->cli
.args_p
,
2114 /* FIXME: DELETE THIS. */
2117 stb
.puts ("Undefined mi command: ");
2118 stb
.putstr (parse
->command
, '"');
2119 stb
.puts (" (missing implementation)");
2125 /* FIXME: This is just a hack so we can get some extra commands going.
2126 We don't want to channel things through the CLI, but call libgdb directly.
2127 Use only for synchronous commands. */
2130 mi_execute_cli_command (const char *cmd
, int args_p
, const char *args
)
2134 std::string run
= cmd
;
2137 run
= run
+ " " + args
;
2139 /* FIXME: gdb_???? */
2140 fprintf_unfiltered (gdb_stdout
, "cli=%s run=%s\n",
2142 execute_command (run
.c_str (), 0 /* from_tty */ );
2147 mi_execute_async_cli_command (const char *cli_command
, char **argv
, int argc
)
2149 std::string run
= cli_command
;
2152 run
= run
+ " " + *argv
;
2156 execute_command (run
.c_str (), 0 /* from_tty */ );
2160 mi_load_progress (const char *section_name
,
2161 unsigned long sent_so_far
,
2162 unsigned long total_section
,
2163 unsigned long total_sent
,
2164 unsigned long grand_total
)
2166 using namespace std::chrono
;
2167 static steady_clock::time_point last_update
;
2168 static char *previous_sect_name
= NULL
;
2170 struct mi_interp
*mi
= (struct mi_interp
*) current_interpreter ();
2172 /* This function is called through deprecated_show_load_progress
2173 which means uiout may not be correct. Fix it for the duration
2174 of this function. */
2176 std::unique_ptr
<ui_out
> uiout (mi_out_new (current_interpreter ()->name ()));
2177 if (uiout
== nullptr)
2180 scoped_restore save_uiout
2181 = make_scoped_restore (¤t_uiout
, uiout
.get ());
2183 new_section
= (previous_sect_name
?
2184 strcmp (previous_sect_name
, section_name
) : 1);
2187 xfree (previous_sect_name
);
2188 previous_sect_name
= xstrdup (section_name
);
2191 fputs_unfiltered (current_token
, mi
->raw_stdout
);
2192 fputs_unfiltered ("+download", mi
->raw_stdout
);
2194 ui_out_emit_tuple
tuple_emitter (uiout
.get (), NULL
);
2195 uiout
->field_string ("section", section_name
);
2196 uiout
->field_int ("section-size", total_section
);
2197 uiout
->field_int ("total-size", grand_total
);
2199 mi_out_put (uiout
.get (), mi
->raw_stdout
);
2200 fputs_unfiltered ("\n", mi
->raw_stdout
);
2201 gdb_flush (mi
->raw_stdout
);
2204 steady_clock::time_point time_now
= steady_clock::now ();
2205 if (time_now
- last_update
> milliseconds (500))
2207 last_update
= time_now
;
2209 fputs_unfiltered (current_token
, mi
->raw_stdout
);
2210 fputs_unfiltered ("+download", mi
->raw_stdout
);
2212 ui_out_emit_tuple
tuple_emitter (uiout
.get (), NULL
);
2213 uiout
->field_string ("section", section_name
);
2214 uiout
->field_int ("section-sent", sent_so_far
);
2215 uiout
->field_int ("section-size", total_section
);
2216 uiout
->field_int ("total-sent", total_sent
);
2217 uiout
->field_int ("total-size", grand_total
);
2219 mi_out_put (uiout
.get (), mi
->raw_stdout
);
2220 fputs_unfiltered ("\n", mi
->raw_stdout
);
2221 gdb_flush (mi
->raw_stdout
);
2226 timestamp (struct mi_timestamp
*tv
)
2228 using namespace std::chrono
;
2230 tv
->wallclock
= steady_clock::now ();
2231 run_time_clock::now (tv
->utime
, tv
->stime
);
2235 print_diff_now (struct ui_file
*file
, struct mi_timestamp
*start
)
2237 struct mi_timestamp now
;
2240 print_diff (file
, start
, &now
);
2244 mi_print_timing_maybe (struct ui_file
*file
)
2246 /* If the command is -enable-timing then do_timings may be true
2247 whilst current_command_ts is not initialized. */
2248 if (do_timings
&& current_command_ts
)
2249 print_diff_now (file
, current_command_ts
);
2253 print_diff (struct ui_file
*file
, struct mi_timestamp
*start
,
2254 struct mi_timestamp
*end
)
2256 using namespace std::chrono
;
2258 duration
<double> wallclock
= end
->wallclock
- start
->wallclock
;
2259 duration
<double> utime
= end
->utime
- start
->utime
;
2260 duration
<double> stime
= end
->stime
- start
->stime
;
2264 ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
2265 wallclock
.count (), utime
.count (), stime
.count ());
2269 mi_cmd_trace_define_variable (const char *command
, char **argv
, int argc
)
2271 LONGEST initval
= 0;
2272 struct trace_state_variable
*tsv
;
2275 if (argc
!= 1 && argc
!= 2)
2276 error (_("Usage: -trace-define-variable VARIABLE [VALUE]"));
2280 error (_("Name of trace variable should start with '$'"));
2282 validate_trace_state_variable_name (name
);
2284 tsv
= find_trace_state_variable (name
);
2286 tsv
= create_trace_state_variable (name
);
2289 initval
= value_as_long (parse_and_eval (argv
[1]));
2291 tsv
->initial_value
= initval
;
2295 mi_cmd_trace_list_variables (const char *command
, char **argv
, int argc
)
2298 error (_("-trace-list-variables: no arguments allowed"));
2300 tvariables_info_1 ();
2304 mi_cmd_trace_find (const char *command
, char **argv
, int argc
)
2309 error (_("trace selection mode is required"));
2313 if (strcmp (mode
, "none") == 0)
2315 tfind_1 (tfind_number
, -1, 0, 0, 0);
2319 check_trace_running (current_trace_status ());
2321 if (strcmp (mode
, "frame-number") == 0)
2324 error (_("frame number is required"));
2325 tfind_1 (tfind_number
, atoi (argv
[1]), 0, 0, 0);
2327 else if (strcmp (mode
, "tracepoint-number") == 0)
2330 error (_("tracepoint number is required"));
2331 tfind_1 (tfind_tp
, atoi (argv
[1]), 0, 0, 0);
2333 else if (strcmp (mode
, "pc") == 0)
2336 error (_("PC is required"));
2337 tfind_1 (tfind_pc
, 0, parse_and_eval_address (argv
[1]), 0, 0);
2339 else if (strcmp (mode
, "pc-inside-range") == 0)
2342 error (_("Start and end PC are required"));
2343 tfind_1 (tfind_range
, 0, parse_and_eval_address (argv
[1]),
2344 parse_and_eval_address (argv
[2]), 0);
2346 else if (strcmp (mode
, "pc-outside-range") == 0)
2349 error (_("Start and end PC are required"));
2350 tfind_1 (tfind_outside
, 0, parse_and_eval_address (argv
[1]),
2351 parse_and_eval_address (argv
[2]), 0);
2353 else if (strcmp (mode
, "line") == 0)
2356 error (_("Line is required"));
2358 std::vector
<symtab_and_line
> sals
2359 = decode_line_with_current_source (argv
[1],
2360 DECODE_LINE_FUNFIRSTLINE
);
2361 const symtab_and_line
&sal
= sals
[0];
2363 if (sal
.symtab
== 0)
2364 error (_("Could not find the specified line"));
2366 CORE_ADDR start_pc
, end_pc
;
2367 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2368 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, 0);
2370 error (_("Could not find the specified line"));
2373 error (_("Invalid mode '%s'"), mode
);
2375 if (has_stack_frames () || get_traceframe_number () >= 0)
2376 print_stack_frame (get_selected_frame (NULL
), 1, LOC_AND_ADDRESS
, 1);
2380 mi_cmd_trace_save (const char *command
, char **argv
, int argc
)
2382 int target_saves
= 0;
2383 int generate_ctf
= 0;
2390 TARGET_SAVE_OPT
, CTF_OPT
2392 static const struct mi_opt opts
[] =
2394 {"r", TARGET_SAVE_OPT
, 0},
2395 {"ctf", CTF_OPT
, 0},
2401 int opt
= mi_getopt ("-trace-save", argc
, argv
, opts
,
2406 switch ((enum opt
) opt
)
2408 case TARGET_SAVE_OPT
:
2417 if (argc
- oind
!= 1)
2418 error (_("Exactly one argument required "
2419 "(file in which to save trace data)"));
2421 filename
= argv
[oind
];
2424 trace_save_ctf (filename
, target_saves
);
2426 trace_save_tfile (filename
, target_saves
);
2430 mi_cmd_trace_start (const char *command
, char **argv
, int argc
)
2432 start_tracing (NULL
);
2436 mi_cmd_trace_status (const char *command
, char **argv
, int argc
)
2438 trace_status_mi (0);
2442 mi_cmd_trace_stop (const char *command
, char **argv
, int argc
)
2444 stop_tracing (NULL
);
2445 trace_status_mi (1);
2448 /* Implement the "-ada-task-info" command. */
2451 mi_cmd_ada_task_info (const char *command
, char **argv
, int argc
)
2453 if (argc
!= 0 && argc
!= 1)
2454 error (_("Invalid MI command"));
2456 print_ada_task_info (current_uiout
, argv
[0], current_inferior ());
2459 /* Print EXPRESSION according to VALUES. */
2462 print_variable_or_computed (const char *expression
, enum print_values values
)
2466 struct ui_out
*uiout
= current_uiout
;
2470 expression_up expr
= parse_expression (expression
);
2472 if (values
== PRINT_SIMPLE_VALUES
)
2473 val
= evaluate_type (expr
.get ());
2475 val
= evaluate_expression (expr
.get ());
2477 gdb::optional
<ui_out_emit_tuple
> tuple_emitter
;
2478 if (values
!= PRINT_NO_VALUES
)
2479 tuple_emitter
.emplace (uiout
, nullptr);
2480 uiout
->field_string ("name", expression
);
2484 case PRINT_SIMPLE_VALUES
:
2485 type
= check_typedef (value_type (val
));
2486 type_print (value_type (val
), "", &stb
, -1);
2487 uiout
->field_stream ("type", stb
);
2488 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
2489 && TYPE_CODE (type
) != TYPE_CODE_STRUCT
2490 && TYPE_CODE (type
) != TYPE_CODE_UNION
)
2492 struct value_print_options opts
;
2494 get_no_prettyformat_print_options (&opts
);
2496 common_val_print (val
, &stb
, 0, &opts
, current_language
);
2497 uiout
->field_stream ("value", stb
);
2500 case PRINT_ALL_VALUES
:
2502 struct value_print_options opts
;
2504 get_no_prettyformat_print_options (&opts
);
2506 common_val_print (val
, &stb
, 0, &opts
, current_language
);
2507 uiout
->field_stream ("value", stb
);
2513 /* Implement the "-trace-frame-collected" command. */
2516 mi_cmd_trace_frame_collected (const char *command
, char **argv
, int argc
)
2518 struct bp_location
*tloc
;
2520 struct collection_list
*clist
;
2521 struct collection_list tracepoint_list
, stepping_list
;
2522 struct traceframe_info
*tinfo
;
2524 enum print_values var_print_values
= PRINT_ALL_VALUES
;
2525 enum print_values comp_print_values
= PRINT_ALL_VALUES
;
2526 int registers_format
= 'x';
2527 int memory_contents
= 0;
2528 struct ui_out
*uiout
= current_uiout
;
2536 static const struct mi_opt opts
[] =
2538 {"-var-print-values", VAR_PRINT_VALUES
, 1},
2539 {"-comp-print-values", COMP_PRINT_VALUES
, 1},
2540 {"-registers-format", REGISTERS_FORMAT
, 1},
2541 {"-memory-contents", MEMORY_CONTENTS
, 0},
2548 int opt
= mi_getopt ("-trace-frame-collected", argc
, argv
, opts
,
2552 switch ((enum opt
) opt
)
2554 case VAR_PRINT_VALUES
:
2555 var_print_values
= mi_parse_print_values (oarg
);
2557 case COMP_PRINT_VALUES
:
2558 comp_print_values
= mi_parse_print_values (oarg
);
2560 case REGISTERS_FORMAT
:
2561 registers_format
= oarg
[0];
2563 case MEMORY_CONTENTS
:
2564 memory_contents
= 1;
2570 error (_("Usage: -trace-frame-collected "
2571 "[--var-print-values PRINT_VALUES] "
2572 "[--comp-print-values PRINT_VALUES] "
2573 "[--registers-format FORMAT]"
2574 "[--memory-contents]"));
2576 /* This throws an error is not inspecting a trace frame. */
2577 tloc
= get_traceframe_location (&stepping_frame
);
2579 /* This command only makes sense for the current frame, not the
2581 scoped_restore_current_thread restore_thread
;
2582 select_frame (get_current_frame ());
2584 encode_actions (tloc
, &tracepoint_list
, &stepping_list
);
2587 clist
= &stepping_list
;
2589 clist
= &tracepoint_list
;
2591 tinfo
= get_traceframe_info ();
2593 /* Explicitly wholly collected variables. */
2595 ui_out_emit_list
list_emitter (uiout
, "explicit-variables");
2596 const std::vector
<std::string
> &wholly_collected
2597 = clist
->wholly_collected ();
2598 for (size_t i
= 0; i
< wholly_collected
.size (); i
++)
2600 const std::string
&str
= wholly_collected
[i
];
2601 print_variable_or_computed (str
.c_str (), var_print_values
);
2605 /* Computed expressions. */
2607 ui_out_emit_list
list_emitter (uiout
, "computed-expressions");
2609 const std::vector
<std::string
> &computed
= clist
->computed ();
2610 for (size_t i
= 0; i
< computed
.size (); i
++)
2612 const std::string
&str
= computed
[i
];
2613 print_variable_or_computed (str
.c_str (), comp_print_values
);
2617 /* Registers. Given pseudo-registers, and that some architectures
2618 (like MIPS) actually hide the raw registers, we don't go through
2619 the trace frame info, but instead consult the register cache for
2620 register availability. */
2622 struct frame_info
*frame
;
2623 struct gdbarch
*gdbarch
;
2627 ui_out_emit_list
list_emitter (uiout
, "registers");
2629 frame
= get_selected_frame (NULL
);
2630 gdbarch
= get_frame_arch (frame
);
2631 numregs
= gdbarch_num_cooked_regs (gdbarch
);
2633 for (regnum
= 0; regnum
< numregs
; regnum
++)
2635 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
2636 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
2639 output_register (frame
, regnum
, registers_format
, 1);
2643 /* Trace state variables. */
2645 ui_out_emit_list
list_emitter (uiout
, "tvars");
2647 for (int tvar
: tinfo
->tvars
)
2649 struct trace_state_variable
*tsv
;
2651 tsv
= find_trace_state_variable_by_number (tvar
);
2653 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
2657 uiout
->field_fmt ("name", "$%s", tsv
->name
.c_str ());
2659 tsv
->value_known
= target_get_trace_state_variable_value (tsv
->number
,
2661 uiout
->field_int ("current", tsv
->value
);
2665 uiout
->field_skip ("name");
2666 uiout
->field_skip ("current");
2673 std::vector
<mem_range
> available_memory
;
2675 traceframe_available_memory (&available_memory
, 0, ULONGEST_MAX
);
2677 ui_out_emit_list
list_emitter (uiout
, "memory");
2679 for (const mem_range
&r
: available_memory
)
2681 struct gdbarch
*gdbarch
= target_gdbarch ();
2683 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
2685 uiout
->field_core_addr ("address", gdbarch
, r
.start
);
2686 uiout
->field_int ("length", r
.length
);
2688 gdb::byte_vector
data (r
.length
);
2690 if (memory_contents
)
2692 if (target_read_memory (r
.start
, data
.data (), r
.length
) == 0)
2694 std::string data_str
= bin2hex (data
.data (), r
.length
);
2695 uiout
->field_string ("contents", data_str
.c_str ());
2698 uiout
->field_skip ("contents");
2705 _initialize_mi_main (void)
2707 struct cmd_list_element
*c
;
2709 add_setshow_boolean_cmd ("mi-async", class_run
,
2711 Set whether MI asynchronous mode is enabled."), _("\
2712 Show whether MI asynchronous mode is enabled."), _("\
2713 Tells GDB whether MI should be in asynchronous mode."),
2714 set_mi_async_command
,
2715 show_mi_async_command
,
2719 /* Alias old "target-async" to "mi-async". */
2720 c
= add_alias_cmd ("target-async", "mi-async", class_run
, 0, &setlist
);
2721 deprecate_cmd (c
, "set mi-async");
2722 c
= add_alias_cmd ("target-async", "mi-async", class_run
, 0, &showlist
);
2723 deprecate_cmd (c
, "show mi-async");