3 Copyright (C) 2000-2020 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 "gdbsupport/gdb_splay_tree.h"
48 #include "tracepoint.h"
51 #include "extension.h"
53 #include "observable.h"
54 #include "gdbsupport/gdb_optional.h"
55 #include "gdbsupport/byte-vector.h"
58 #include "gdbsupport/run-time-clock.h"
60 #include "progspace-and-thread.h"
61 #include "gdbsupport/rsp-low.h"
73 /* This is used to pass the current command timestamp down to
74 continuation routines. */
75 static struct mi_timestamp
*current_command_ts
;
77 static int do_timings
= 0;
80 /* Few commands would like to know if options like --thread-group were
81 explicitly specified. This variable keeps the current parsed
82 command including all option, and make it possible. */
83 static struct mi_parse
*current_context
;
85 int running_result_record_printed
= 1;
87 /* Flag indicating that the target has proceeded since the last
88 command was issued. */
91 static void mi_cmd_execute (struct mi_parse
*parse
);
93 static void mi_execute_cli_command (const char *cmd
, int args_p
,
95 static void mi_execute_async_cli_command (const char *cli_command
,
96 char **argv
, int argc
);
97 static bool register_changed_p (int regnum
, readonly_detached_regcache
*,
98 readonly_detached_regcache
*);
99 static void output_register (struct frame_info
*, int regnum
, int format
,
100 int skip_unavailable
);
102 /* Controls whether the frontend wants MI in async mode. */
103 static bool mi_async
= false;
105 /* The set command writes to this variable. If the inferior is
106 executing, mi_async is *not* updated. */
107 static bool mi_async_1
= false;
110 set_mi_async_command (const char *args
, int from_tty
,
111 struct cmd_list_element
*c
)
113 if (have_live_inferiors ())
115 mi_async_1
= mi_async
;
116 error (_("Cannot change this setting while the inferior is running."));
119 mi_async
= mi_async_1
;
123 show_mi_async_command (struct ui_file
*file
, int from_tty
,
124 struct cmd_list_element
*c
,
127 fprintf_filtered (file
,
128 _("Whether MI is in asynchronous mode is %s.\n"),
132 /* A wrapper for target_can_async_p that takes the MI setting into
138 return mi_async
&& target_can_async_p ();
141 /* Command implementations. FIXME: Is this libgdb? No. This is the MI
142 layer that calls libgdb. Any operation used in the below should be
145 static void timestamp (struct mi_timestamp
*tv
);
147 static void print_diff (struct ui_file
*file
, struct mi_timestamp
*start
,
148 struct mi_timestamp
*end
);
151 mi_cmd_gdb_exit (const char *command
, char **argv
, int argc
)
153 struct mi_interp
*mi
= (struct mi_interp
*) current_interpreter ();
155 /* We have to print everything right here because we never return. */
157 fputs_unfiltered (current_token
, mi
->raw_stdout
);
158 fputs_unfiltered ("^exit\n", mi
->raw_stdout
);
159 mi_out_put (current_uiout
, mi
->raw_stdout
);
160 gdb_flush (mi
->raw_stdout
);
161 /* FIXME: The function called is not yet a formal libgdb function. */
162 quit_force (NULL
, FROM_TTY
);
166 mi_cmd_exec_next (const char *command
, char **argv
, int argc
)
168 /* FIXME: Should call a libgdb function, not a cli wrapper. */
169 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
170 mi_execute_async_cli_command ("reverse-next", argv
+ 1, argc
- 1);
172 mi_execute_async_cli_command ("next", argv
, argc
);
176 mi_cmd_exec_next_instruction (const char *command
, char **argv
, int argc
)
178 /* FIXME: Should call a libgdb function, not a cli wrapper. */
179 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
180 mi_execute_async_cli_command ("reverse-nexti", argv
+ 1, argc
- 1);
182 mi_execute_async_cli_command ("nexti", argv
, argc
);
186 mi_cmd_exec_step (const char *command
, char **argv
, int argc
)
188 /* FIXME: Should call a libgdb function, not a cli wrapper. */
189 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
190 mi_execute_async_cli_command ("reverse-step", argv
+ 1, argc
- 1);
192 mi_execute_async_cli_command ("step", argv
, argc
);
196 mi_cmd_exec_step_instruction (const char *command
, char **argv
, int argc
)
198 /* FIXME: Should call a libgdb function, not a cli wrapper. */
199 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
200 mi_execute_async_cli_command ("reverse-stepi", argv
+ 1, argc
- 1);
202 mi_execute_async_cli_command ("stepi", argv
, argc
);
206 mi_cmd_exec_finish (const char *command
, char **argv
, int argc
)
208 /* FIXME: Should call a libgdb function, not a cli wrapper. */
209 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
210 mi_execute_async_cli_command ("reverse-finish", argv
+ 1, argc
- 1);
212 mi_execute_async_cli_command ("finish", argv
, argc
);
216 mi_cmd_exec_return (const char *command
, char **argv
, int argc
)
218 /* This command doesn't really execute the target, it just pops the
219 specified number of frames. */
221 /* Call return_command with from_tty argument equal to 0 so as to
222 avoid being queried. */
223 return_command (*argv
, 0);
225 /* Call return_command with from_tty argument equal to 0 so as to
226 avoid being queried. */
227 return_command (NULL
, 0);
229 /* Because we have called return_command with from_tty = 0, we need
230 to print the frame here. */
231 print_stack_frame (get_selected_frame (NULL
), 1, LOC_AND_ADDRESS
, 1);
235 mi_cmd_exec_jump (const char *args
, char **argv
, int argc
)
237 /* FIXME: Should call a libgdb function, not a cli wrapper. */
238 mi_execute_async_cli_command ("jump", argv
, argc
);
242 proceed_thread (struct thread_info
*thread
, int pid
)
244 if (thread
->state
!= THREAD_STOPPED
)
247 if (pid
!= 0 && thread
->ptid
.pid () != pid
)
250 switch_to_thread (thread
);
251 clear_proceed_status (0);
252 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
);
256 proceed_thread_callback (struct thread_info
*thread
, void *arg
)
258 int pid
= *(int *)arg
;
260 proceed_thread (thread
, pid
);
265 exec_continue (char **argv
, int argc
)
267 prepare_execution_command (current_top_target (), mi_async_p ());
271 /* In non-stop mode, 'resume' always resumes a single thread.
272 Therefore, to resume all threads of the current inferior, or
273 all threads in all inferiors, we need to iterate over
276 See comment on infcmd.c:proceed_thread_callback for rationale. */
277 if (current_context
->all
|| current_context
->thread_group
!= -1)
279 scoped_restore_current_thread restore_thread
;
282 if (!current_context
->all
)
285 = find_inferior_id (current_context
->thread_group
);
289 iterate_over_threads (proceed_thread_callback
, &pid
);
298 scoped_restore save_multi
= make_scoped_restore (&sched_multi
);
300 if (current_context
->all
)
307 /* In all-stop mode, -exec-continue traditionally resumed
308 either all threads, or one thread, depending on the
309 'scheduler-locking' variable. Let's continue to do the
317 exec_reverse_continue (char **argv
, int argc
)
319 enum exec_direction_kind dir
= execution_direction
;
321 if (dir
== EXEC_REVERSE
)
322 error (_("Already in reverse mode."));
324 if (!target_can_execute_reverse
)
325 error (_("Target %s does not support this command."), target_shortname
);
327 scoped_restore save_exec_dir
= make_scoped_restore (&execution_direction
,
329 exec_continue (argv
, argc
);
333 mi_cmd_exec_continue (const char *command
, char **argv
, int argc
)
335 if (argc
> 0 && strcmp (argv
[0], "--reverse") == 0)
336 exec_reverse_continue (argv
+ 1, argc
- 1);
338 exec_continue (argv
, argc
);
342 interrupt_thread_callback (struct thread_info
*thread
, void *arg
)
344 int pid
= *(int *)arg
;
346 if (thread
->state
!= THREAD_RUNNING
)
349 if (thread
->ptid
.pid () != pid
)
352 target_stop (thread
->ptid
);
356 /* Interrupt the execution of the target. Note how we must play
357 around with the token variables, in order to display the current
358 token in the result of the interrupt command, and the previous
359 execution token when the target finally stops. See comments in
363 mi_cmd_exec_interrupt (const char *command
, char **argv
, int argc
)
365 /* In all-stop mode, everything stops, so we don't need to try
366 anything specific. */
369 interrupt_target_1 (0);
373 if (current_context
->all
)
375 /* This will interrupt all threads in all inferiors. */
376 interrupt_target_1 (1);
378 else if (current_context
->thread_group
!= -1)
380 struct inferior
*inf
= find_inferior_id (current_context
->thread_group
);
382 iterate_over_threads (interrupt_thread_callback
, &inf
->pid
);
386 /* Interrupt just the current thread -- either explicitly
387 specified via --thread or whatever was current before
388 MI command was sent. */
389 interrupt_target_1 (0);
393 /* Callback for iterate_over_inferiors which starts the execution
394 of the given inferior.
396 ARG is a pointer to an integer whose value, if non-zero, indicates
397 that the program should be stopped when reaching the main subprogram
398 (similar to what the CLI "start" command does). */
401 run_one_inferior (struct inferior
*inf
, void *arg
)
403 int start_p
= *(int *) arg
;
404 const char *run_cmd
= start_p
? "start" : "run";
405 struct target_ops
*run_target
= find_run_target ();
406 int async_p
= mi_async
&& run_target
->can_async_p ();
410 thread_info
*tp
= any_thread_of_inferior (inf
);
412 error (_("Inferior has no threads."));
414 switch_to_thread (tp
);
417 switch_to_inferior_no_thread (inf
);
418 mi_execute_cli_command (run_cmd
, async_p
,
419 async_p
? "&" : NULL
);
424 mi_cmd_exec_run (const char *command
, char **argv
, int argc
)
428 /* Parse the command options. */
433 static const struct mi_opt opts
[] =
435 {"-start", START_OPT
, 0},
444 int opt
= mi_getopt ("-exec-run", argc
, argv
, opts
, &oind
, &oarg
);
448 switch ((enum opt
) opt
)
456 /* This command does not accept any argument. Make sure the user
457 did not provide any. */
459 error (_("Invalid argument: %s"), argv
[oind
]);
461 if (current_context
->all
)
463 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
465 iterate_over_inferiors (run_one_inferior
, &start_p
);
469 const char *run_cmd
= start_p
? "start" : "run";
470 struct target_ops
*run_target
= find_run_target ();
471 int async_p
= mi_async
&& run_target
->can_async_p ();
473 mi_execute_cli_command (run_cmd
, async_p
,
474 async_p
? "&" : NULL
);
480 find_thread_of_process (struct thread_info
*ti
, void *p
)
484 if (ti
->ptid
.pid () == pid
&& ti
->state
!= THREAD_EXITED
)
491 mi_cmd_target_detach (const char *command
, char **argv
, int argc
)
493 if (argc
!= 0 && argc
!= 1)
494 error (_("Usage: -target-detach [pid | thread-group]"));
498 struct thread_info
*tp
;
502 /* First see if we are dealing with a thread-group id. */
505 struct inferior
*inf
;
506 int id
= strtoul (argv
[0] + 1, &end
, 0);
509 error (_("Invalid syntax of thread-group id '%s'"), argv
[0]);
511 inf
= find_inferior_id (id
);
513 error (_("Non-existent thread-group id '%d'"), id
);
519 /* We must be dealing with a pid. */
520 pid
= strtol (argv
[0], &end
, 10);
523 error (_("Invalid identifier '%s'"), argv
[0]);
526 /* Pick any thread in the desired process. Current
527 target_detach detaches from the parent of inferior_ptid. */
528 tp
= iterate_over_threads (find_thread_of_process
, &pid
);
530 error (_("Thread group is empty"));
532 switch_to_thread (tp
);
535 detach_command (NULL
, 0);
539 mi_cmd_target_flash_erase (const char *command
, char **argv
, int argc
)
541 flash_erase_command (NULL
, 0);
545 mi_cmd_thread_select (const char *command
, char **argv
, int argc
)
548 error (_("-thread-select: USAGE: threadnum."));
550 int num
= value_as_long (parse_and_eval (argv
[0]));
551 thread_info
*thr
= find_thread_global_id (num
);
553 error (_("Thread ID %d not known."), num
);
555 ptid_t previous_ptid
= inferior_ptid
;
557 thread_select (argv
[0], thr
);
559 print_selected_thread_frame (current_uiout
,
560 USER_SELECTED_THREAD
| USER_SELECTED_FRAME
);
562 /* Notify if the thread has effectively changed. */
563 if (inferior_ptid
!= previous_ptid
)
565 gdb::observers::user_selected_context_changed
.notify
566 (USER_SELECTED_THREAD
| USER_SELECTED_FRAME
);
571 mi_cmd_thread_list_ids (const char *command
, char **argv
, int argc
)
574 error (_("-thread-list-ids: No arguments required."));
577 int current_thread
= -1;
579 update_thread_list ();
582 ui_out_emit_tuple
tuple_emitter (current_uiout
, "thread-ids");
584 for (thread_info
*tp
: all_non_exited_threads ())
586 if (tp
->ptid
== inferior_ptid
)
587 current_thread
= tp
->global_num
;
590 current_uiout
->field_signed ("thread-id", tp
->global_num
);
594 if (current_thread
!= -1)
595 current_uiout
->field_signed ("current-thread-id", current_thread
);
596 current_uiout
->field_signed ("number-of-threads", num
);
600 mi_cmd_thread_info (const char *command
, char **argv
, int argc
)
602 if (argc
!= 0 && argc
!= 1)
603 error (_("Invalid MI command"));
605 print_thread_info (current_uiout
, argv
[0], -1);
608 struct collect_cores_data
615 collect_cores (struct thread_info
*ti
, void *xdata
)
617 struct collect_cores_data
*data
= (struct collect_cores_data
*) xdata
;
619 if (ti
->ptid
.pid () == data
->pid
)
621 int core
= target_core_of_thread (ti
->ptid
);
624 data
->cores
.insert (core
);
630 struct print_one_inferior_data
633 const std::set
<int> *inferiors
;
637 print_one_inferior (struct inferior
*inferior
, void *xdata
)
639 struct print_one_inferior_data
*top_data
640 = (struct print_one_inferior_data
*) xdata
;
641 struct ui_out
*uiout
= current_uiout
;
643 if (top_data
->inferiors
->empty ()
644 || (top_data
->inferiors
->find (inferior
->pid
)
645 != top_data
->inferiors
->end ()))
647 struct collect_cores_data data
;
648 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
650 uiout
->field_fmt ("id", "i%d", inferior
->num
);
651 uiout
->field_string ("type", "process");
652 if (inferior
->has_exit_code
)
653 uiout
->field_string ("exit-code",
654 int_string (inferior
->exit_code
, 8, 0, 0, 1));
655 if (inferior
->pid
!= 0)
656 uiout
->field_signed ("pid", inferior
->pid
);
658 if (inferior
->pspace
->pspace_exec_filename
!= NULL
)
660 uiout
->field_string ("executable",
661 inferior
->pspace
->pspace_exec_filename
);
664 if (inferior
->pid
!= 0)
666 data
.pid
= inferior
->pid
;
667 iterate_over_threads (collect_cores
, &data
);
670 if (!data
.cores
.empty ())
672 ui_out_emit_list
list_emitter (uiout
, "cores");
674 for (int b
: data
.cores
)
675 uiout
->field_signed (NULL
, b
);
678 if (top_data
->recurse
)
679 print_thread_info (uiout
, NULL
, inferior
->pid
);
685 /* Output a field named 'cores' with a list as the value. The
686 elements of the list are obtained by splitting 'cores' on
690 output_cores (struct ui_out
*uiout
, const char *field_name
, const char *xcores
)
692 ui_out_emit_list
list_emitter (uiout
, field_name
);
693 auto cores
= make_unique_xstrdup (xcores
);
694 char *p
= cores
.get ();
697 for (p
= strtok_r (p
, ",", &saveptr
); p
; p
= strtok_r (NULL
, ",", &saveptr
))
698 uiout
->field_string (NULL
, p
);
702 list_available_thread_groups (const std::set
<int> &ids
, int recurse
)
704 struct ui_out
*uiout
= current_uiout
;
706 /* This keeps a map from integer (pid) to vector of struct osdata_item.
707 The vector contains information about all threads for the given pid. */
708 std::map
<int, std::vector
<osdata_item
>> tree
;
710 /* get_osdata will throw if it cannot return data. */
711 std::unique_ptr
<osdata
> data
= get_osdata ("processes");
715 std::unique_ptr
<osdata
> threads
= get_osdata ("threads");
717 for (const osdata_item
&item
: threads
->items
)
719 const std::string
*pid
= get_osdata_column (item
, "pid");
720 int pid_i
= strtoul (pid
->c_str (), NULL
, 0);
722 tree
[pid_i
].push_back (item
);
726 ui_out_emit_list
list_emitter (uiout
, "groups");
728 for (const osdata_item
&item
: data
->items
)
730 const std::string
*pid
= get_osdata_column (item
, "pid");
731 const std::string
*cmd
= get_osdata_column (item
, "command");
732 const std::string
*user
= get_osdata_column (item
, "user");
733 const std::string
*cores
= get_osdata_column (item
, "cores");
735 int pid_i
= strtoul (pid
->c_str (), NULL
, 0);
737 /* At present, the target will return all available processes
738 and if information about specific ones was required, we filter
739 undesired processes here. */
740 if (!ids
.empty () && ids
.find (pid_i
) == ids
.end ())
743 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
745 uiout
->field_string ("id", pid
->c_str ());
746 uiout
->field_string ("type", "process");
748 uiout
->field_string ("description", cmd
->c_str ());
750 uiout
->field_string ("user", user
->c_str ());
752 output_cores (uiout
, "cores", cores
->c_str ());
756 auto n
= tree
.find (pid_i
);
757 if (n
!= tree
.end ())
759 std::vector
<osdata_item
> &children
= n
->second
;
761 ui_out_emit_list
thread_list_emitter (uiout
, "threads");
763 for (const osdata_item
&child
: children
)
765 ui_out_emit_tuple
inner_tuple_emitter (uiout
, NULL
);
766 const std::string
*tid
= get_osdata_column (child
, "tid");
767 const std::string
*tcore
= get_osdata_column (child
, "core");
769 uiout
->field_string ("id", tid
->c_str ());
771 uiout
->field_string ("core", tcore
->c_str ());
779 mi_cmd_list_thread_groups (const char *command
, char **argv
, int argc
)
781 struct ui_out
*uiout
= current_uiout
;
788 AVAILABLE_OPT
, RECURSE_OPT
790 static const struct mi_opt opts
[] =
792 {"-available", AVAILABLE_OPT
, 0},
793 {"-recurse", RECURSE_OPT
, 1},
802 int opt
= mi_getopt ("-list-thread-groups", argc
, argv
, opts
,
807 switch ((enum opt
) opt
)
813 if (strcmp (oarg
, "0") == 0)
815 else if (strcmp (oarg
, "1") == 0)
818 error (_("only '0' and '1' are valid values "
819 "for the '--recurse' option"));
824 for (; oind
< argc
; ++oind
)
829 if (*(argv
[oind
]) != 'i')
830 error (_("invalid syntax of group id '%s'"), argv
[oind
]);
832 inf
= strtoul (argv
[oind
] + 1, &end
, 0);
835 error (_("invalid syntax of group id '%s'"), argv
[oind
]);
841 list_available_thread_groups (ids
, recurse
);
843 else if (ids
.size () == 1)
845 /* Local thread groups, single id. */
846 int id
= *(ids
.begin ());
847 struct inferior
*inf
= find_inferior_id (id
);
850 error (_("Non-existent thread group id '%d'"), id
);
852 print_thread_info (uiout
, NULL
, inf
->pid
);
856 struct print_one_inferior_data data
;
858 data
.recurse
= recurse
;
859 data
.inferiors
= &ids
;
861 /* Local thread groups. Either no explicit ids -- and we
862 print everything, or several explicit ids. In both cases,
863 we print more than one group, and have to use 'groups'
864 as the top-level element. */
865 ui_out_emit_list
list_emitter (uiout
, "groups");
866 update_thread_list ();
867 iterate_over_inferiors (print_one_inferior
, &data
);
872 mi_cmd_data_list_register_names (const char *command
, char **argv
, int argc
)
874 struct gdbarch
*gdbarch
;
875 struct ui_out
*uiout
= current_uiout
;
879 /* Note that the test for a valid register must include checking the
880 gdbarch_register_name because gdbarch_num_regs may be allocated
881 for the union of the register sets within a family of related
882 processors. In this case, some entries of gdbarch_register_name
883 will change depending upon the particular processor being
886 gdbarch
= get_current_arch ();
887 numregs
= gdbarch_num_cooked_regs (gdbarch
);
889 ui_out_emit_list
list_emitter (uiout
, "register-names");
891 if (argc
== 0) /* No args, just do all the regs. */
897 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
898 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
899 uiout
->field_string (NULL
, "");
901 uiout
->field_string (NULL
, gdbarch_register_name (gdbarch
, regnum
));
905 /* Else, list of register #s, just do listed regs. */
906 for (i
= 0; i
< argc
; i
++)
908 regnum
= atoi (argv
[i
]);
909 if (regnum
< 0 || regnum
>= numregs
)
910 error (_("bad register number"));
912 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
913 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
914 uiout
->field_string (NULL
, "");
916 uiout
->field_string (NULL
, gdbarch_register_name (gdbarch
, regnum
));
921 mi_cmd_data_list_changed_registers (const char *command
, char **argv
, int argc
)
923 static std::unique_ptr
<readonly_detached_regcache
> this_regs
;
924 struct ui_out
*uiout
= current_uiout
;
925 std::unique_ptr
<readonly_detached_regcache
> prev_regs
;
926 struct gdbarch
*gdbarch
;
930 /* The last time we visited this function, the current frame's
931 register contents were saved in THIS_REGS. Move THIS_REGS over
932 to PREV_REGS, and refresh THIS_REGS with the now-current register
935 prev_regs
= std::move (this_regs
);
936 this_regs
= frame_save_as_regcache (get_selected_frame (NULL
));
938 /* Note that the test for a valid register must include checking the
939 gdbarch_register_name because gdbarch_num_regs may be allocated
940 for the union of the register sets within a family of related
941 processors. In this case, some entries of gdbarch_register_name
942 will change depending upon the particular processor being
945 gdbarch
= this_regs
->arch ();
946 numregs
= gdbarch_num_cooked_regs (gdbarch
);
948 ui_out_emit_list
list_emitter (uiout
, "changed-registers");
952 /* No args, just do all the regs. */
957 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
958 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
961 if (register_changed_p (regnum
, prev_regs
.get (),
963 uiout
->field_signed (NULL
, regnum
);
967 /* Else, list of register #s, just do listed regs. */
968 for (i
= 0; i
< argc
; i
++)
970 regnum
= atoi (argv
[i
]);
974 && gdbarch_register_name (gdbarch
, regnum
) != NULL
975 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
977 if (register_changed_p (regnum
, prev_regs
.get (),
979 uiout
->field_signed (NULL
, regnum
);
982 error (_("bad register number"));
987 register_changed_p (int regnum
, readonly_detached_regcache
*prev_regs
,
988 readonly_detached_regcache
*this_regs
)
990 struct gdbarch
*gdbarch
= this_regs
->arch ();
991 struct value
*prev_value
, *this_value
;
993 /* First time through or after gdbarch change consider all registers
995 if (!prev_regs
|| prev_regs
->arch () != gdbarch
)
998 /* Get register contents and compare. */
999 prev_value
= prev_regs
->cooked_read_value (regnum
);
1000 this_value
= this_regs
->cooked_read_value (regnum
);
1001 gdb_assert (prev_value
!= NULL
);
1002 gdb_assert (this_value
!= NULL
);
1004 auto ret
= !value_contents_eq (prev_value
, 0, this_value
, 0,
1005 register_size (gdbarch
, regnum
));
1007 release_value (prev_value
);
1008 release_value (this_value
);
1012 /* Return a list of register number and value pairs. The valid
1013 arguments expected are: a letter indicating the format in which to
1014 display the registers contents. This can be one of: x
1015 (hexadecimal), d (decimal), N (natural), t (binary), o (octal), r
1016 (raw). After the format argument there can be a sequence of
1017 numbers, indicating which registers to fetch the content of. If
1018 the format is the only argument, a list of all the registers with
1019 their values is returned. */
1022 mi_cmd_data_list_register_values (const char *command
, char **argv
, int argc
)
1024 struct ui_out
*uiout
= current_uiout
;
1025 struct frame_info
*frame
;
1026 struct gdbarch
*gdbarch
;
1027 int regnum
, numregs
, format
;
1029 int skip_unavailable
= 0;
1035 static const struct mi_opt opts
[] =
1037 {"-skip-unavailable", SKIP_UNAVAILABLE
, 0},
1041 /* Note that the test for a valid register must include checking the
1042 gdbarch_register_name because gdbarch_num_regs may be allocated
1043 for the union of the register sets within a family of related
1044 processors. In this case, some entries of gdbarch_register_name
1045 will change depending upon the particular processor being
1051 int opt
= mi_getopt ("-data-list-register-values", argc
, argv
,
1052 opts
, &oind
, &oarg
);
1056 switch ((enum opt
) opt
)
1058 case SKIP_UNAVAILABLE
:
1059 skip_unavailable
= 1;
1064 if (argc
- oind
< 1)
1065 error (_("-data-list-register-values: Usage: "
1066 "-data-list-register-values [--skip-unavailable] <format>"
1067 " [<regnum1>...<regnumN>]"));
1069 format
= (int) argv
[oind
][0];
1071 frame
= get_selected_frame (NULL
);
1072 gdbarch
= get_frame_arch (frame
);
1073 numregs
= gdbarch_num_cooked_regs (gdbarch
);
1075 ui_out_emit_list
list_emitter (uiout
, "register-values");
1077 if (argc
- oind
== 1)
1079 /* No args, beside the format: do all the regs. */
1084 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1085 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1088 output_register (frame
, regnum
, format
, skip_unavailable
);
1092 /* Else, list of register #s, just do listed regs. */
1093 for (i
= 1 + oind
; i
< argc
; i
++)
1095 regnum
= atoi (argv
[i
]);
1099 && gdbarch_register_name (gdbarch
, regnum
) != NULL
1100 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
1101 output_register (frame
, regnum
, format
, skip_unavailable
);
1103 error (_("bad register number"));
1107 /* Output one register REGNUM's contents in the desired FORMAT. If
1108 SKIP_UNAVAILABLE is true, skip the register if it is
1112 output_register (struct frame_info
*frame
, int regnum
, int format
,
1113 int skip_unavailable
)
1115 struct ui_out
*uiout
= current_uiout
;
1116 struct value
*val
= value_of_register (regnum
, frame
);
1117 struct value_print_options opts
;
1119 if (skip_unavailable
&& !value_entirely_available (val
))
1122 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1123 uiout
->field_signed ("number", regnum
);
1133 get_formatted_print_options (&opts
, format
);
1135 val_print (value_type (val
),
1136 value_embedded_offset (val
), 0,
1137 &stb
, 0, val
, &opts
, current_language
);
1138 uiout
->field_stream ("value", stb
);
1141 /* Write given values into registers. The registers and values are
1142 given as pairs. The corresponding MI command is
1143 -data-write-register-values <format>
1144 [<regnum1> <value1>...<regnumN> <valueN>] */
1146 mi_cmd_data_write_register_values (const char *command
, char **argv
, int argc
)
1148 struct regcache
*regcache
;
1149 struct gdbarch
*gdbarch
;
1152 /* Note that the test for a valid register must include checking the
1153 gdbarch_register_name because gdbarch_num_regs may be allocated
1154 for the union of the register sets within a family of related
1155 processors. In this case, some entries of gdbarch_register_name
1156 will change depending upon the particular processor being
1159 regcache
= get_current_regcache ();
1160 gdbarch
= regcache
->arch ();
1161 numregs
= gdbarch_num_cooked_regs (gdbarch
);
1164 error (_("-data-write-register-values: Usage: -data-write-register-"
1165 "values <format> [<regnum1> <value1>...<regnumN> <valueN>]"));
1167 if (!target_has_registers
)
1168 error (_("-data-write-register-values: No registers."));
1171 error (_("-data-write-register-values: No regs and values specified."));
1174 error (_("-data-write-register-values: "
1175 "Regs and vals are not in pairs."));
1177 for (i
= 1; i
< argc
; i
= i
+ 2)
1179 int regnum
= atoi (argv
[i
]);
1181 if (regnum
>= 0 && regnum
< numregs
1182 && gdbarch_register_name (gdbarch
, regnum
)
1183 && *gdbarch_register_name (gdbarch
, regnum
))
1187 /* Get the value as a number. */
1188 value
= parse_and_eval_address (argv
[i
+ 1]);
1190 /* Write it down. */
1191 regcache_cooked_write_signed (regcache
, regnum
, value
);
1194 error (_("bad register number"));
1198 /* Evaluate the value of the argument. The argument is an
1199 expression. If the expression contains spaces it needs to be
1200 included in double quotes. */
1203 mi_cmd_data_evaluate_expression (const char *command
, char **argv
, int argc
)
1206 struct value_print_options opts
;
1207 struct ui_out
*uiout
= current_uiout
;
1210 error (_("-data-evaluate-expression: "
1211 "Usage: -data-evaluate-expression expression"));
1213 expression_up expr
= parse_expression (argv
[0]);
1215 val
= evaluate_expression (expr
.get ());
1219 /* Print the result of the expression evaluation. */
1220 get_user_print_options (&opts
);
1222 common_val_print (val
, &stb
, 0, &opts
, current_language
);
1224 uiout
->field_stream ("value", stb
);
1227 /* This is the -data-read-memory command.
1229 ADDR: start address of data to be dumped.
1230 WORD-FORMAT: a char indicating format for the ``word''. See
1232 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes.
1233 NR_ROW: Number of rows.
1234 NR_COL: The number of columns (words per row).
1235 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
1236 ASCHAR for unprintable characters.
1238 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
1239 displays them. Returns:
1241 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
1244 The number of bytes read is SIZE*ROW*COL. */
1247 mi_cmd_data_read_memory (const char *command
, char **argv
, int argc
)
1249 struct gdbarch
*gdbarch
= get_current_arch ();
1250 struct ui_out
*uiout
= current_uiout
;
1252 long total_bytes
, nr_cols
, nr_rows
;
1254 struct type
*word_type
;
1266 static const struct mi_opt opts
[] =
1268 {"o", OFFSET_OPT
, 1},
1274 int opt
= mi_getopt ("-data-read-memory", argc
, argv
, opts
,
1279 switch ((enum opt
) opt
)
1282 offset
= atol (oarg
);
1289 if (argc
< 5 || argc
> 6)
1290 error (_("-data-read-memory: Usage: "
1291 "ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR]."));
1293 /* Extract all the arguments. */
1295 /* Start address of the memory dump. */
1296 addr
= parse_and_eval_address (argv
[0]) + offset
;
1297 /* The format character to use when displaying a memory word. See
1298 the ``x'' command. */
1299 word_format
= argv
[1][0];
1300 /* The size of the memory word. */
1301 word_size
= atol (argv
[2]);
1305 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1309 word_type
= builtin_type (gdbarch
)->builtin_int16
;
1313 word_type
= builtin_type (gdbarch
)->builtin_int32
;
1317 word_type
= builtin_type (gdbarch
)->builtin_int64
;
1321 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1324 /* The number of rows. */
1325 nr_rows
= atol (argv
[3]);
1327 error (_("-data-read-memory: invalid number of rows."));
1329 /* Number of bytes per row. */
1330 nr_cols
= atol (argv
[4]);
1332 error (_("-data-read-memory: invalid number of columns."));
1334 /* The un-printable character when printing ascii. */
1340 /* Create a buffer and read it in. */
1341 total_bytes
= word_size
* nr_rows
* nr_cols
;
1343 gdb::byte_vector
mbuf (total_bytes
);
1345 nr_bytes
= target_read (current_top_target (), TARGET_OBJECT_MEMORY
, NULL
,
1346 mbuf
.data (), addr
, total_bytes
);
1348 error (_("Unable to read memory."));
1350 /* Output the header information. */
1351 uiout
->field_core_addr ("addr", gdbarch
, addr
);
1352 uiout
->field_signed ("nr-bytes", nr_bytes
);
1353 uiout
->field_signed ("total-bytes", total_bytes
);
1354 uiout
->field_core_addr ("next-row", gdbarch
, addr
+ word_size
* nr_cols
);
1355 uiout
->field_core_addr ("prev-row", gdbarch
, addr
- word_size
* nr_cols
);
1356 uiout
->field_core_addr ("next-page", gdbarch
, addr
+ total_bytes
);
1357 uiout
->field_core_addr ("prev-page", gdbarch
, addr
- total_bytes
);
1359 /* Build the result as a two dimensional table. */
1366 ui_out_emit_list
list_emitter (uiout
, "memory");
1367 for (row
= 0, row_byte
= 0;
1369 row
++, row_byte
+= nr_cols
* word_size
)
1373 struct value_print_options print_opts
;
1375 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1376 uiout
->field_core_addr ("addr", gdbarch
, addr
+ row_byte
);
1377 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr +
1380 ui_out_emit_list
list_data_emitter (uiout
, "data");
1381 get_formatted_print_options (&print_opts
, word_format
);
1382 for (col
= 0, col_byte
= row_byte
;
1384 col
++, col_byte
+= word_size
)
1386 if (col_byte
+ word_size
> nr_bytes
)
1388 uiout
->field_string (NULL
, "N/A");
1393 print_scalar_formatted (&mbuf
[col_byte
], word_type
,
1394 &print_opts
, word_asize
, &stream
);
1395 uiout
->field_stream (NULL
, stream
);
1405 for (byte
= row_byte
;
1406 byte
< row_byte
+ word_size
* nr_cols
; byte
++)
1408 if (byte
>= nr_bytes
)
1410 else if (mbuf
[byte
] < 32 || mbuf
[byte
] > 126)
1411 stream
.putc (aschar
);
1413 stream
.putc (mbuf
[byte
]);
1415 uiout
->field_stream ("ascii", stream
);
1422 mi_cmd_data_read_memory_bytes (const char *command
, char **argv
, int argc
)
1424 struct gdbarch
*gdbarch
= get_current_arch ();
1425 struct ui_out
*uiout
= current_uiout
;
1429 int unit_size
= gdbarch_addressable_memory_unit_size (gdbarch
);
1436 static const struct mi_opt opts
[] =
1438 {"o", OFFSET_OPT
, 1},
1444 int opt
= mi_getopt ("-data-read-memory-bytes", argc
, argv
, opts
,
1448 switch ((enum opt
) opt
)
1451 offset
= atol (oarg
);
1459 error (_("Usage: [ -o OFFSET ] ADDR LENGTH."));
1461 addr
= parse_and_eval_address (argv
[0]) + offset
;
1462 length
= atol (argv
[1]);
1464 std::vector
<memory_read_result
> result
1465 = read_memory_robust (current_top_target (), addr
, length
);
1467 if (result
.size () == 0)
1468 error (_("Unable to read memory."));
1470 ui_out_emit_list
list_emitter (uiout
, "memory");
1471 for (const memory_read_result
&read_result
: result
)
1473 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1475 uiout
->field_core_addr ("begin", gdbarch
, read_result
.begin
);
1476 uiout
->field_core_addr ("offset", gdbarch
, read_result
.begin
- addr
);
1477 uiout
->field_core_addr ("end", gdbarch
, read_result
.end
);
1479 std::string data
= bin2hex (read_result
.data
.get (),
1480 (read_result
.end
- read_result
.begin
)
1482 uiout
->field_string ("contents", data
.c_str ());
1486 /* Implementation of the -data-write_memory command.
1488 COLUMN_OFFSET: optional argument. Must be preceded by '-o'. The
1489 offset from the beginning of the memory grid row where the cell to
1491 ADDR: start address of the row in the memory grid where the memory
1492 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
1493 the location to write to.
1494 FORMAT: a char indicating format for the ``word''. See
1496 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
1497 VALUE: value to be written into the memory address.
1499 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
1504 mi_cmd_data_write_memory (const char *command
, char **argv
, int argc
)
1506 struct gdbarch
*gdbarch
= get_current_arch ();
1507 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1510 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
1511 enough when using a compiler other than GCC. */
1520 static const struct mi_opt opts
[] =
1522 {"o", OFFSET_OPT
, 1},
1528 int opt
= mi_getopt ("-data-write-memory", argc
, argv
, opts
,
1533 switch ((enum opt
) opt
)
1536 offset
= atol (oarg
);
1544 error (_("-data-write-memory: Usage: "
1545 "[-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE."));
1547 /* Extract all the arguments. */
1548 /* Start address of the memory dump. */
1549 addr
= parse_and_eval_address (argv
[0]);
1550 /* The size of the memory word. */
1551 word_size
= atol (argv
[2]);
1553 /* Calculate the real address of the write destination. */
1554 addr
+= (offset
* word_size
);
1556 /* Get the value as a number. */
1557 value
= parse_and_eval_address (argv
[3]);
1558 /* Get the value into an array. */
1559 gdb::byte_vector
buffer (word_size
);
1560 store_signed_integer (buffer
.data (), word_size
, byte_order
, value
);
1561 /* Write it down to memory. */
1562 write_memory_with_notification (addr
, buffer
.data (), word_size
);
1565 /* Implementation of the -data-write-memory-bytes command.
1568 DATA: string of bytes to write at that address
1569 COUNT: number of bytes to be filled (decimal integer). */
1572 mi_cmd_data_write_memory_bytes (const char *command
, char **argv
, int argc
)
1576 size_t len_hex
, len_bytes
, len_units
, i
, steps
, remaining_units
;
1577 long int count_units
;
1580 if (argc
!= 2 && argc
!= 3)
1581 error (_("Usage: ADDR DATA [COUNT]."));
1583 addr
= parse_and_eval_address (argv
[0]);
1585 len_hex
= strlen (cdata
);
1586 unit_size
= gdbarch_addressable_memory_unit_size (get_current_arch ());
1588 if (len_hex
% (unit_size
* 2) != 0)
1589 error (_("Hex-encoded '%s' must represent an integral number of "
1590 "addressable memory units."),
1593 len_bytes
= len_hex
/ 2;
1594 len_units
= len_bytes
/ unit_size
;
1597 count_units
= strtoul (argv
[2], NULL
, 10);
1599 count_units
= len_units
;
1601 gdb::byte_vector
databuf (len_bytes
);
1603 for (i
= 0; i
< len_bytes
; ++i
)
1606 if (sscanf (cdata
+ i
* 2, "%02x", &x
) != 1)
1607 error (_("Invalid argument"));
1608 databuf
[i
] = (gdb_byte
) x
;
1611 gdb::byte_vector data
;
1612 if (len_units
< count_units
)
1614 /* Pattern is made of less units than count:
1615 repeat pattern to fill memory. */
1616 data
= gdb::byte_vector (count_units
* unit_size
);
1618 /* Number of times the pattern is entirely repeated. */
1619 steps
= count_units
/ len_units
;
1620 /* Number of remaining addressable memory units. */
1621 remaining_units
= count_units
% len_units
;
1622 for (i
= 0; i
< steps
; i
++)
1623 memcpy (&data
[i
* len_bytes
], &databuf
[0], len_bytes
);
1625 if (remaining_units
> 0)
1626 memcpy (&data
[steps
* len_bytes
], &databuf
[0],
1627 remaining_units
* unit_size
);
1631 /* Pattern is longer than or equal to count:
1632 just copy count addressable memory units. */
1633 data
= std::move (databuf
);
1636 write_memory_with_notification (addr
, data
.data (), count_units
);
1640 mi_cmd_enable_timings (const char *command
, char **argv
, int argc
)
1646 if (strcmp (argv
[0], "yes") == 0)
1648 else if (strcmp (argv
[0], "no") == 0)
1659 error (_("-enable-timings: Usage: %s {yes|no}"), command
);
1663 mi_cmd_list_features (const char *command
, char **argv
, int argc
)
1667 struct ui_out
*uiout
= current_uiout
;
1669 ui_out_emit_list
list_emitter (uiout
, "features");
1670 uiout
->field_string (NULL
, "frozen-varobjs");
1671 uiout
->field_string (NULL
, "pending-breakpoints");
1672 uiout
->field_string (NULL
, "thread-info");
1673 uiout
->field_string (NULL
, "data-read-memory-bytes");
1674 uiout
->field_string (NULL
, "breakpoint-notifications");
1675 uiout
->field_string (NULL
, "ada-task-info");
1676 uiout
->field_string (NULL
, "language-option");
1677 uiout
->field_string (NULL
, "info-gdb-mi-command");
1678 uiout
->field_string (NULL
, "undefined-command-error-code");
1679 uiout
->field_string (NULL
, "exec-run-start-option");
1680 uiout
->field_string (NULL
, "data-disassemble-a-option");
1682 if (ext_lang_initialized_p (get_ext_lang_defn (EXT_LANG_PYTHON
)))
1683 uiout
->field_string (NULL
, "python");
1688 error (_("-list-features should be passed no arguments"));
1692 mi_cmd_list_target_features (const char *command
, char **argv
, int argc
)
1696 struct ui_out
*uiout
= current_uiout
;
1698 ui_out_emit_list
list_emitter (uiout
, "features");
1700 uiout
->field_string (NULL
, "async");
1701 if (target_can_execute_reverse
)
1702 uiout
->field_string (NULL
, "reverse");
1706 error (_("-list-target-features should be passed no arguments"));
1710 mi_cmd_add_inferior (const char *command
, char **argv
, int argc
)
1712 struct inferior
*inf
;
1715 error (_("-add-inferior should be passed no arguments"));
1717 inf
= add_inferior_with_spaces ();
1719 current_uiout
->field_fmt ("inferior", "i%d", inf
->num
);
1722 /* Callback used to find the first inferior other than the current
1726 get_other_inferior (struct inferior
*inf
, void *arg
)
1728 if (inf
== current_inferior ())
1735 mi_cmd_remove_inferior (const char *command
, char **argv
, int argc
)
1738 struct inferior
*inf
;
1741 error (_("-remove-inferior should be passed a single argument"));
1743 if (sscanf (argv
[0], "i%d", &id
) != 1)
1744 error (_("the thread group id is syntactically invalid"));
1746 inf
= find_inferior_id (id
);
1748 error (_("the specified thread group does not exist"));
1751 error (_("cannot remove an active inferior"));
1753 if (inf
== current_inferior ())
1755 struct thread_info
*tp
= 0;
1756 struct inferior
*new_inferior
1757 = iterate_over_inferiors (get_other_inferior
, NULL
);
1759 if (new_inferior
== NULL
)
1760 error (_("Cannot remove last inferior"));
1762 set_current_inferior (new_inferior
);
1763 if (new_inferior
->pid
!= 0)
1764 tp
= any_thread_of_inferior (new_inferior
);
1766 switch_to_thread (tp
);
1768 switch_to_no_thread ();
1769 set_current_program_space (new_inferior
->pspace
);
1772 delete_inferior (inf
);
1777 /* Execute a command within a safe environment.
1778 Return <0 for error; >=0 for ok.
1780 args->action will tell mi_execute_command what action
1781 to perform after the given command has executed (display/suppress
1782 prompt, display error). */
1785 captured_mi_execute_command (struct ui_out
*uiout
, struct mi_parse
*context
)
1787 struct mi_interp
*mi
= (struct mi_interp
*) command_interp ();
1790 current_command_ts
= context
->cmd_start
;
1792 scoped_restore save_token
= make_scoped_restore (¤t_token
,
1795 running_result_record_printed
= 0;
1797 switch (context
->op
)
1800 /* A MI command was read from the input stream. */
1802 /* FIXME: gdb_???? */
1803 fprintf_unfiltered (mi
->raw_stdout
,
1804 " token=`%s' command=`%s' args=`%s'\n",
1805 context
->token
, context
->command
, context
->args
);
1807 mi_cmd_execute (context
);
1809 /* Print the result if there were no errors.
1811 Remember that on the way out of executing a command, you have
1812 to directly use the mi_interp's uiout, since the command
1813 could have reset the interpreter, in which case the current
1814 uiout will most likely crash in the mi_out_* routines. */
1815 if (!running_result_record_printed
)
1817 fputs_unfiltered (context
->token
, mi
->raw_stdout
);
1818 /* There's no particularly good reason why target-connect results
1819 in not ^done. Should kill ^connected for MI3. */
1820 fputs_unfiltered (strcmp (context
->command
, "target-select") == 0
1821 ? "^connected" : "^done", mi
->raw_stdout
);
1822 mi_out_put (uiout
, mi
->raw_stdout
);
1823 mi_out_rewind (uiout
);
1824 mi_print_timing_maybe (mi
->raw_stdout
);
1825 fputs_unfiltered ("\n", mi
->raw_stdout
);
1828 /* The command does not want anything to be printed. In that
1829 case, the command probably should not have written anything
1830 to uiout, but in case it has written something, discard it. */
1831 mi_out_rewind (uiout
);
1838 /* A CLI command was read from the input stream. */
1839 /* This "feature" will be removed as soon as we have a
1840 complete set of mi commands. */
1841 /* Echo the command on the console. */
1842 fprintf_unfiltered (gdb_stdlog
, "%s\n", context
->command
);
1843 /* Call the "console" interpreter. */
1844 argv
[0] = (char *) INTERP_CONSOLE
;
1845 argv
[1] = context
->command
;
1846 mi_cmd_interpreter_exec ("-interpreter-exec", argv
, 2);
1848 /* If we changed interpreters, DON'T print out anything. */
1849 if (current_interp_named_p (INTERP_MI
)
1850 || current_interp_named_p (INTERP_MI1
)
1851 || current_interp_named_p (INTERP_MI2
)
1852 || current_interp_named_p (INTERP_MI3
))
1854 if (!running_result_record_printed
)
1856 fputs_unfiltered (context
->token
, mi
->raw_stdout
);
1857 fputs_unfiltered ("^done", mi
->raw_stdout
);
1858 mi_out_put (uiout
, mi
->raw_stdout
);
1859 mi_out_rewind (uiout
);
1860 mi_print_timing_maybe (mi
->raw_stdout
);
1861 fputs_unfiltered ("\n", mi
->raw_stdout
);
1864 mi_out_rewind (uiout
);
1871 /* Print a gdb exception to the MI output stream. */
1874 mi_print_exception (const char *token
, const struct gdb_exception
&exception
)
1876 struct mi_interp
*mi
= (struct mi_interp
*) current_interpreter ();
1878 fputs_unfiltered (token
, mi
->raw_stdout
);
1879 fputs_unfiltered ("^error,msg=\"", mi
->raw_stdout
);
1880 if (exception
.message
== NULL
)
1881 fputs_unfiltered ("unknown error", mi
->raw_stdout
);
1883 fputstr_unfiltered (exception
.what (), '"', mi
->raw_stdout
);
1884 fputs_unfiltered ("\"", mi
->raw_stdout
);
1886 switch (exception
.error
)
1888 case UNDEFINED_COMMAND_ERROR
:
1889 fputs_unfiltered (",code=\"undefined-command\"", mi
->raw_stdout
);
1893 fputs_unfiltered ("\n", mi
->raw_stdout
);
1896 /* Determine whether the parsed command already notifies the
1897 user_selected_context_changed observer. */
1900 command_notifies_uscc_observer (struct mi_parse
*command
)
1902 if (command
->op
== CLI_COMMAND
)
1904 /* CLI commands "thread" and "inferior" already send it. */
1905 return (strncmp (command
->command
, "thread ", 7) == 0
1906 || strncmp (command
->command
, "inferior ", 9) == 0);
1908 else /* MI_COMMAND */
1910 if (strcmp (command
->command
, "interpreter-exec") == 0
1911 && command
->argc
> 1)
1913 /* "thread" and "inferior" again, but through -interpreter-exec. */
1914 return (strncmp (command
->argv
[1], "thread ", 7) == 0
1915 || strncmp (command
->argv
[1], "inferior ", 9) == 0);
1919 /* -thread-select already sends it. */
1920 return strcmp (command
->command
, "thread-select") == 0;
1925 mi_execute_command (const char *cmd
, int from_tty
)
1928 std::unique_ptr
<struct mi_parse
> command
;
1930 /* This is to handle EOF (^D). We just quit gdb. */
1931 /* FIXME: we should call some API function here. */
1933 quit_force (NULL
, from_tty
);
1935 target_log_command (cmd
);
1939 command
= mi_parse (cmd
, &token
);
1941 catch (const gdb_exception
&exception
)
1943 mi_print_exception (token
, exception
);
1947 if (command
!= NULL
)
1949 ptid_t previous_ptid
= inferior_ptid
;
1951 gdb::optional
<scoped_restore_tmpl
<int>> restore_suppress
;
1953 if (command
->cmd
!= NULL
&& command
->cmd
->suppress_notification
!= NULL
)
1954 restore_suppress
.emplace (command
->cmd
->suppress_notification
, 1);
1956 command
->token
= token
;
1960 command
->cmd_start
= new mi_timestamp ();
1961 timestamp (command
->cmd_start
);
1966 captured_mi_execute_command (current_uiout
, command
.get ());
1968 catch (const gdb_exception
&result
)
1970 /* Like in start_event_loop, enable input and force display
1971 of the prompt. Otherwise, any command that calls
1972 async_disable_stdin, and then throws, will leave input
1974 async_enable_stdin ();
1975 current_ui
->prompt_state
= PROMPT_NEEDED
;
1977 /* The command execution failed and error() was called
1979 mi_print_exception (command
->token
, result
);
1980 mi_out_rewind (current_uiout
);
1983 bpstat_do_actions ();
1985 if (/* The notifications are only output when the top-level
1986 interpreter (specified on the command line) is MI. */
1987 top_level_interpreter ()->interp_ui_out ()->is_mi_like_p ()
1988 /* Don't try report anything if there are no threads --
1989 the program is dead. */
1991 /* If the command already reports the thread change, no need to do it
1993 && !command_notifies_uscc_observer (command
.get ()))
1995 int report_change
= 0;
1997 if (command
->thread
== -1)
1999 report_change
= (previous_ptid
!= null_ptid
2000 && inferior_ptid
!= previous_ptid
2001 && inferior_ptid
!= null_ptid
);
2003 else if (inferior_ptid
!= null_ptid
)
2005 struct thread_info
*ti
= inferior_thread ();
2007 report_change
= (ti
->global_num
!= command
->thread
);
2012 gdb::observers::user_selected_context_changed
.notify
2013 (USER_SELECTED_THREAD
| USER_SELECTED_FRAME
);
2020 mi_cmd_execute (struct mi_parse
*parse
)
2022 scoped_value_mark cleanup
= prepare_execute_command ();
2024 if (parse
->all
&& parse
->thread_group
!= -1)
2025 error (_("Cannot specify --thread-group together with --all"));
2027 if (parse
->all
&& parse
->thread
!= -1)
2028 error (_("Cannot specify --thread together with --all"));
2030 if (parse
->thread_group
!= -1 && parse
->thread
!= -1)
2031 error (_("Cannot specify --thread together with --thread-group"));
2033 if (parse
->frame
!= -1 && parse
->thread
== -1)
2034 error (_("Cannot specify --frame without --thread"));
2036 if (parse
->thread_group
!= -1)
2038 struct inferior
*inf
= find_inferior_id (parse
->thread_group
);
2039 struct thread_info
*tp
= 0;
2042 error (_("Invalid thread group for the --thread-group option"));
2044 set_current_inferior (inf
);
2045 /* This behaviour means that if --thread-group option identifies
2046 an inferior with multiple threads, then a random one will be
2047 picked. This is not a problem -- frontend should always
2048 provide --thread if it wishes to operate on a specific
2051 tp
= any_live_thread_of_inferior (inf
);
2053 switch_to_thread (tp
);
2055 switch_to_no_thread ();
2056 set_current_program_space (inf
->pspace
);
2059 if (parse
->thread
!= -1)
2061 thread_info
*tp
= find_thread_global_id (parse
->thread
);
2064 error (_("Invalid thread id: %d"), parse
->thread
);
2066 if (tp
->state
== THREAD_EXITED
)
2067 error (_("Thread id: %d has terminated"), parse
->thread
);
2069 switch_to_thread (tp
);
2072 if (parse
->frame
!= -1)
2074 struct frame_info
*fid
;
2075 int frame
= parse
->frame
;
2077 fid
= find_relative_frame (get_current_frame (), &frame
);
2079 /* find_relative_frame was successful */
2082 error (_("Invalid frame id: %d"), frame
);
2085 gdb::optional
<scoped_restore_current_language
> lang_saver
;
2086 if (parse
->language
!= language_unknown
)
2088 lang_saver
.emplace ();
2089 set_language (parse
->language
);
2092 current_context
= parse
;
2094 if (parse
->cmd
->argv_func
!= NULL
)
2096 parse
->cmd
->argv_func (parse
->command
, parse
->argv
, parse
->argc
);
2098 else if (parse
->cmd
->cli
.cmd
!= 0)
2100 /* FIXME: DELETE THIS. */
2101 /* The operation is still implemented by a cli command. */
2102 /* Must be a synchronous one. */
2103 mi_execute_cli_command (parse
->cmd
->cli
.cmd
, parse
->cmd
->cli
.args_p
,
2108 /* FIXME: DELETE THIS. */
2111 stb
.puts ("Undefined mi command: ");
2112 stb
.putstr (parse
->command
, '"');
2113 stb
.puts (" (missing implementation)");
2119 /* FIXME: This is just a hack so we can get some extra commands going.
2120 We don't want to channel things through the CLI, but call libgdb directly.
2121 Use only for synchronous commands. */
2124 mi_execute_cli_command (const char *cmd
, int args_p
, const char *args
)
2128 std::string run
= cmd
;
2131 run
= run
+ " " + args
;
2133 /* FIXME: gdb_???? */
2134 fprintf_unfiltered (gdb_stdout
, "cli=%s run=%s\n",
2136 execute_command (run
.c_str (), 0 /* from_tty */ );
2141 mi_execute_async_cli_command (const char *cli_command
, char **argv
, int argc
)
2143 std::string run
= cli_command
;
2146 run
= run
+ " " + *argv
;
2150 execute_command (run
.c_str (), 0 /* from_tty */ );
2154 mi_load_progress (const char *section_name
,
2155 unsigned long sent_so_far
,
2156 unsigned long total_section
,
2157 unsigned long total_sent
,
2158 unsigned long grand_total
)
2160 using namespace std::chrono
;
2161 static steady_clock::time_point last_update
;
2162 static char *previous_sect_name
= NULL
;
2164 struct mi_interp
*mi
= (struct mi_interp
*) current_interpreter ();
2166 /* This function is called through deprecated_show_load_progress
2167 which means uiout may not be correct. Fix it for the duration
2168 of this function. */
2170 std::unique_ptr
<ui_out
> uiout (mi_out_new (current_interpreter ()->name ()));
2171 if (uiout
== nullptr)
2174 scoped_restore save_uiout
2175 = make_scoped_restore (¤t_uiout
, uiout
.get ());
2177 new_section
= (previous_sect_name
?
2178 strcmp (previous_sect_name
, section_name
) : 1);
2181 xfree (previous_sect_name
);
2182 previous_sect_name
= xstrdup (section_name
);
2185 fputs_unfiltered (current_token
, mi
->raw_stdout
);
2186 fputs_unfiltered ("+download", mi
->raw_stdout
);
2188 ui_out_emit_tuple
tuple_emitter (uiout
.get (), NULL
);
2189 uiout
->field_string ("section", section_name
);
2190 uiout
->field_signed ("section-size", total_section
);
2191 uiout
->field_signed ("total-size", grand_total
);
2193 mi_out_put (uiout
.get (), mi
->raw_stdout
);
2194 fputs_unfiltered ("\n", mi
->raw_stdout
);
2195 gdb_flush (mi
->raw_stdout
);
2198 steady_clock::time_point time_now
= steady_clock::now ();
2199 if (time_now
- last_update
> milliseconds (500))
2201 last_update
= time_now
;
2203 fputs_unfiltered (current_token
, mi
->raw_stdout
);
2204 fputs_unfiltered ("+download", mi
->raw_stdout
);
2206 ui_out_emit_tuple
tuple_emitter (uiout
.get (), NULL
);
2207 uiout
->field_string ("section", section_name
);
2208 uiout
->field_signed ("section-sent", sent_so_far
);
2209 uiout
->field_signed ("section-size", total_section
);
2210 uiout
->field_signed ("total-sent", total_sent
);
2211 uiout
->field_signed ("total-size", grand_total
);
2213 mi_out_put (uiout
.get (), mi
->raw_stdout
);
2214 fputs_unfiltered ("\n", mi
->raw_stdout
);
2215 gdb_flush (mi
->raw_stdout
);
2220 timestamp (struct mi_timestamp
*tv
)
2222 using namespace std::chrono
;
2224 tv
->wallclock
= steady_clock::now ();
2225 run_time_clock::now (tv
->utime
, tv
->stime
);
2229 print_diff_now (struct ui_file
*file
, struct mi_timestamp
*start
)
2231 struct mi_timestamp now
;
2234 print_diff (file
, start
, &now
);
2238 mi_print_timing_maybe (struct ui_file
*file
)
2240 /* If the command is -enable-timing then do_timings may be true
2241 whilst current_command_ts is not initialized. */
2242 if (do_timings
&& current_command_ts
)
2243 print_diff_now (file
, current_command_ts
);
2247 print_diff (struct ui_file
*file
, struct mi_timestamp
*start
,
2248 struct mi_timestamp
*end
)
2250 using namespace std::chrono
;
2252 duration
<double> wallclock
= end
->wallclock
- start
->wallclock
;
2253 duration
<double> utime
= end
->utime
- start
->utime
;
2254 duration
<double> stime
= end
->stime
- start
->stime
;
2258 ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
2259 wallclock
.count (), utime
.count (), stime
.count ());
2263 mi_cmd_trace_define_variable (const char *command
, char **argv
, int argc
)
2265 LONGEST initval
= 0;
2266 struct trace_state_variable
*tsv
;
2269 if (argc
!= 1 && argc
!= 2)
2270 error (_("Usage: -trace-define-variable VARIABLE [VALUE]"));
2274 error (_("Name of trace variable should start with '$'"));
2276 validate_trace_state_variable_name (name
);
2278 tsv
= find_trace_state_variable (name
);
2280 tsv
= create_trace_state_variable (name
);
2283 initval
= value_as_long (parse_and_eval (argv
[1]));
2285 tsv
->initial_value
= initval
;
2289 mi_cmd_trace_list_variables (const char *command
, char **argv
, int argc
)
2292 error (_("-trace-list-variables: no arguments allowed"));
2294 tvariables_info_1 ();
2298 mi_cmd_trace_find (const char *command
, char **argv
, int argc
)
2303 error (_("trace selection mode is required"));
2307 if (strcmp (mode
, "none") == 0)
2309 tfind_1 (tfind_number
, -1, 0, 0, 0);
2313 check_trace_running (current_trace_status ());
2315 if (strcmp (mode
, "frame-number") == 0)
2318 error (_("frame number is required"));
2319 tfind_1 (tfind_number
, atoi (argv
[1]), 0, 0, 0);
2321 else if (strcmp (mode
, "tracepoint-number") == 0)
2324 error (_("tracepoint number is required"));
2325 tfind_1 (tfind_tp
, atoi (argv
[1]), 0, 0, 0);
2327 else if (strcmp (mode
, "pc") == 0)
2330 error (_("PC is required"));
2331 tfind_1 (tfind_pc
, 0, parse_and_eval_address (argv
[1]), 0, 0);
2333 else if (strcmp (mode
, "pc-inside-range") == 0)
2336 error (_("Start and end PC are required"));
2337 tfind_1 (tfind_range
, 0, parse_and_eval_address (argv
[1]),
2338 parse_and_eval_address (argv
[2]), 0);
2340 else if (strcmp (mode
, "pc-outside-range") == 0)
2343 error (_("Start and end PC are required"));
2344 tfind_1 (tfind_outside
, 0, parse_and_eval_address (argv
[1]),
2345 parse_and_eval_address (argv
[2]), 0);
2347 else if (strcmp (mode
, "line") == 0)
2350 error (_("Line is required"));
2352 std::vector
<symtab_and_line
> sals
2353 = decode_line_with_current_source (argv
[1],
2354 DECODE_LINE_FUNFIRSTLINE
);
2355 const symtab_and_line
&sal
= sals
[0];
2357 if (sal
.symtab
== 0)
2358 error (_("Could not find the specified line"));
2360 CORE_ADDR start_pc
, end_pc
;
2361 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2362 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, 0);
2364 error (_("Could not find the specified line"));
2367 error (_("Invalid mode '%s'"), mode
);
2369 if (has_stack_frames () || get_traceframe_number () >= 0)
2370 print_stack_frame (get_selected_frame (NULL
), 1, LOC_AND_ADDRESS
, 1);
2374 mi_cmd_trace_save (const char *command
, char **argv
, int argc
)
2376 int target_saves
= 0;
2377 int generate_ctf
= 0;
2384 TARGET_SAVE_OPT
, CTF_OPT
2386 static const struct mi_opt opts
[] =
2388 {"r", TARGET_SAVE_OPT
, 0},
2389 {"ctf", CTF_OPT
, 0},
2395 int opt
= mi_getopt ("-trace-save", argc
, argv
, opts
,
2400 switch ((enum opt
) opt
)
2402 case TARGET_SAVE_OPT
:
2411 if (argc
- oind
!= 1)
2412 error (_("Exactly one argument required "
2413 "(file in which to save trace data)"));
2415 filename
= argv
[oind
];
2418 trace_save_ctf (filename
, target_saves
);
2420 trace_save_tfile (filename
, target_saves
);
2424 mi_cmd_trace_start (const char *command
, char **argv
, int argc
)
2426 start_tracing (NULL
);
2430 mi_cmd_trace_status (const char *command
, char **argv
, int argc
)
2432 trace_status_mi (0);
2436 mi_cmd_trace_stop (const char *command
, char **argv
, int argc
)
2438 stop_tracing (NULL
);
2439 trace_status_mi (1);
2442 /* Implement the "-ada-task-info" command. */
2445 mi_cmd_ada_task_info (const char *command
, char **argv
, int argc
)
2447 if (argc
!= 0 && argc
!= 1)
2448 error (_("Invalid MI command"));
2450 print_ada_task_info (current_uiout
, argv
[0], current_inferior ());
2453 /* Print EXPRESSION according to VALUES. */
2456 print_variable_or_computed (const char *expression
, enum print_values values
)
2460 struct ui_out
*uiout
= current_uiout
;
2464 expression_up expr
= parse_expression (expression
);
2466 if (values
== PRINT_SIMPLE_VALUES
)
2467 val
= evaluate_type (expr
.get ());
2469 val
= evaluate_expression (expr
.get ());
2471 gdb::optional
<ui_out_emit_tuple
> tuple_emitter
;
2472 if (values
!= PRINT_NO_VALUES
)
2473 tuple_emitter
.emplace (uiout
, nullptr);
2474 uiout
->field_string ("name", expression
);
2478 case PRINT_SIMPLE_VALUES
:
2479 type
= check_typedef (value_type (val
));
2480 type_print (value_type (val
), "", &stb
, -1);
2481 uiout
->field_stream ("type", stb
);
2482 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
2483 && TYPE_CODE (type
) != TYPE_CODE_STRUCT
2484 && TYPE_CODE (type
) != TYPE_CODE_UNION
)
2486 struct value_print_options opts
;
2488 get_no_prettyformat_print_options (&opts
);
2490 common_val_print (val
, &stb
, 0, &opts
, current_language
);
2491 uiout
->field_stream ("value", stb
);
2494 case PRINT_ALL_VALUES
:
2496 struct value_print_options opts
;
2498 get_no_prettyformat_print_options (&opts
);
2500 common_val_print (val
, &stb
, 0, &opts
, current_language
);
2501 uiout
->field_stream ("value", stb
);
2507 /* Implement the "-trace-frame-collected" command. */
2510 mi_cmd_trace_frame_collected (const char *command
, char **argv
, int argc
)
2512 struct bp_location
*tloc
;
2514 struct collection_list
*clist
;
2515 struct collection_list tracepoint_list
, stepping_list
;
2516 struct traceframe_info
*tinfo
;
2518 enum print_values var_print_values
= PRINT_ALL_VALUES
;
2519 enum print_values comp_print_values
= PRINT_ALL_VALUES
;
2520 int registers_format
= 'x';
2521 int memory_contents
= 0;
2522 struct ui_out
*uiout
= current_uiout
;
2530 static const struct mi_opt opts
[] =
2532 {"-var-print-values", VAR_PRINT_VALUES
, 1},
2533 {"-comp-print-values", COMP_PRINT_VALUES
, 1},
2534 {"-registers-format", REGISTERS_FORMAT
, 1},
2535 {"-memory-contents", MEMORY_CONTENTS
, 0},
2542 int opt
= mi_getopt ("-trace-frame-collected", argc
, argv
, opts
,
2546 switch ((enum opt
) opt
)
2548 case VAR_PRINT_VALUES
:
2549 var_print_values
= mi_parse_print_values (oarg
);
2551 case COMP_PRINT_VALUES
:
2552 comp_print_values
= mi_parse_print_values (oarg
);
2554 case REGISTERS_FORMAT
:
2555 registers_format
= oarg
[0];
2557 case MEMORY_CONTENTS
:
2558 memory_contents
= 1;
2564 error (_("Usage: -trace-frame-collected "
2565 "[--var-print-values PRINT_VALUES] "
2566 "[--comp-print-values PRINT_VALUES] "
2567 "[--registers-format FORMAT]"
2568 "[--memory-contents]"));
2570 /* This throws an error is not inspecting a trace frame. */
2571 tloc
= get_traceframe_location (&stepping_frame
);
2573 /* This command only makes sense for the current frame, not the
2575 scoped_restore_current_thread restore_thread
;
2576 select_frame (get_current_frame ());
2578 encode_actions (tloc
, &tracepoint_list
, &stepping_list
);
2581 clist
= &stepping_list
;
2583 clist
= &tracepoint_list
;
2585 tinfo
= get_traceframe_info ();
2587 /* Explicitly wholly collected variables. */
2589 ui_out_emit_list
list_emitter (uiout
, "explicit-variables");
2590 const std::vector
<std::string
> &wholly_collected
2591 = clist
->wholly_collected ();
2592 for (size_t i
= 0; i
< wholly_collected
.size (); i
++)
2594 const std::string
&str
= wholly_collected
[i
];
2595 print_variable_or_computed (str
.c_str (), var_print_values
);
2599 /* Computed expressions. */
2601 ui_out_emit_list
list_emitter (uiout
, "computed-expressions");
2603 const std::vector
<std::string
> &computed
= clist
->computed ();
2604 for (size_t i
= 0; i
< computed
.size (); i
++)
2606 const std::string
&str
= computed
[i
];
2607 print_variable_or_computed (str
.c_str (), comp_print_values
);
2611 /* Registers. Given pseudo-registers, and that some architectures
2612 (like MIPS) actually hide the raw registers, we don't go through
2613 the trace frame info, but instead consult the register cache for
2614 register availability. */
2616 struct frame_info
*frame
;
2617 struct gdbarch
*gdbarch
;
2621 ui_out_emit_list
list_emitter (uiout
, "registers");
2623 frame
= get_selected_frame (NULL
);
2624 gdbarch
= get_frame_arch (frame
);
2625 numregs
= gdbarch_num_cooked_regs (gdbarch
);
2627 for (regnum
= 0; regnum
< numregs
; regnum
++)
2629 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
2630 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
2633 output_register (frame
, regnum
, registers_format
, 1);
2637 /* Trace state variables. */
2639 ui_out_emit_list
list_emitter (uiout
, "tvars");
2641 for (int tvar
: tinfo
->tvars
)
2643 struct trace_state_variable
*tsv
;
2645 tsv
= find_trace_state_variable_by_number (tvar
);
2647 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
2651 uiout
->field_fmt ("name", "$%s", tsv
->name
.c_str ());
2653 tsv
->value_known
= target_get_trace_state_variable_value (tsv
->number
,
2655 uiout
->field_signed ("current", tsv
->value
);
2659 uiout
->field_skip ("name");
2660 uiout
->field_skip ("current");
2667 std::vector
<mem_range
> available_memory
;
2669 traceframe_available_memory (&available_memory
, 0, ULONGEST_MAX
);
2671 ui_out_emit_list
list_emitter (uiout
, "memory");
2673 for (const mem_range
&r
: available_memory
)
2675 struct gdbarch
*gdbarch
= target_gdbarch ();
2677 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
2679 uiout
->field_core_addr ("address", gdbarch
, r
.start
);
2680 uiout
->field_signed ("length", r
.length
);
2682 gdb::byte_vector
data (r
.length
);
2684 if (memory_contents
)
2686 if (target_read_memory (r
.start
, data
.data (), r
.length
) == 0)
2688 std::string data_str
= bin2hex (data
.data (), r
.length
);
2689 uiout
->field_string ("contents", data_str
.c_str ());
2692 uiout
->field_skip ("contents");
2698 /* See mi/mi-main.h. */
2701 mi_cmd_fix_multi_location_breakpoint_output (const char *command
, char **argv
,
2704 fix_multi_location_breakpoint_output_globally
= true;
2707 /* Implement the "-complete" command. */
2710 mi_cmd_complete (const char *command
, char **argv
, int argc
)
2713 error (_("Usage: -complete COMMAND"));
2715 if (max_completions
== 0)
2716 error (_("max-completions is zero, completion is disabled."));
2718 int quote_char
= '\0';
2721 completion_result result
= complete (argv
[0], &word
, "e_char
);
2723 std::string
arg_prefix (argv
[0], word
- argv
[0]);
2725 struct ui_out
*uiout
= current_uiout
;
2727 if (result
.number_matches
> 0)
2728 uiout
->field_fmt ("completion", "%s%s",
2729 arg_prefix
.c_str (),result
.match_list
[0]);
2732 ui_out_emit_list
completions_emitter (uiout
, "matches");
2734 if (result
.number_matches
== 1)
2735 uiout
->field_fmt (NULL
, "%s%s",
2736 arg_prefix
.c_str (), result
.match_list
[0]);
2739 result
.sort_match_list ();
2740 for (size_t i
= 0; i
< result
.number_matches
; i
++)
2742 uiout
->field_fmt (NULL
, "%s%s",
2743 arg_prefix
.c_str (), result
.match_list
[i
+ 1]);
2747 uiout
->field_string ("max_completions_reached",
2748 result
.number_matches
== max_completions
? "1" : "0");
2753 _initialize_mi_main (void)
2755 struct cmd_list_element
*c
;
2757 add_setshow_boolean_cmd ("mi-async", class_run
,
2759 Set whether MI asynchronous mode is enabled."), _("\
2760 Show whether MI asynchronous mode is enabled."), _("\
2761 Tells GDB whether MI should be in asynchronous mode."),
2762 set_mi_async_command
,
2763 show_mi_async_command
,
2767 /* Alias old "target-async" to "mi-async". */
2768 c
= add_alias_cmd ("target-async", "mi-async", class_run
, 0, &setlist
);
2769 deprecate_cmd (c
, "set mi-async");
2770 c
= add_alias_cmd ("target-async", "mi-async", class_run
, 0, &showlist
);
2771 deprecate_cmd (c
, "show mi-async");