3 Copyright (C) 2000-2021 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 "gdbsupport/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_inferior ()->top_target (), mi_async_p ());
269 scoped_disable_commit_resumed
disable_commit_resumed ("mi continue");
273 /* In non-stop mode, 'resume' always resumes a single thread.
274 Therefore, to resume all threads of the current inferior, or
275 all threads in all inferiors, we need to iterate over
278 See comment on infcmd.c:proceed_thread_callback for rationale. */
279 if (current_context
->all
|| current_context
->thread_group
!= -1)
281 scoped_restore_current_thread restore_thread
;
284 if (!current_context
->all
)
287 = find_inferior_id (current_context
->thread_group
);
291 iterate_over_threads (proceed_thread_callback
, &pid
);
300 scoped_restore save_multi
= make_scoped_restore (&sched_multi
);
302 if (current_context
->all
)
309 /* In all-stop mode, -exec-continue traditionally resumed
310 either all threads, or one thread, depending on the
311 'scheduler-locking' variable. Let's continue to do the
317 disable_commit_resumed
.reset_and_commit ();
321 exec_reverse_continue (char **argv
, int argc
)
323 enum exec_direction_kind dir
= execution_direction
;
325 if (dir
== EXEC_REVERSE
)
326 error (_("Already in reverse mode."));
328 if (!target_can_execute_reverse ())
329 error (_("Target %s does not support this command."), target_shortname ());
331 scoped_restore save_exec_dir
= make_scoped_restore (&execution_direction
,
333 exec_continue (argv
, argc
);
337 mi_cmd_exec_continue (const char *command
, char **argv
, int argc
)
339 if (argc
> 0 && strcmp (argv
[0], "--reverse") == 0)
340 exec_reverse_continue (argv
+ 1, argc
- 1);
342 exec_continue (argv
, argc
);
346 interrupt_thread_callback (struct thread_info
*thread
, void *arg
)
348 int pid
= *(int *)arg
;
350 if (thread
->state
!= THREAD_RUNNING
)
353 if (thread
->ptid
.pid () != pid
)
356 target_stop (thread
->ptid
);
360 /* Interrupt the execution of the target. Note how we must play
361 around with the token variables, in order to display the current
362 token in the result of the interrupt command, and the previous
363 execution token when the target finally stops. See comments in
367 mi_cmd_exec_interrupt (const char *command
, char **argv
, int argc
)
369 /* In all-stop mode, everything stops, so we don't need to try
370 anything specific. */
373 interrupt_target_1 (0);
377 if (current_context
->all
)
379 /* This will interrupt all threads in all inferiors. */
380 interrupt_target_1 (1);
382 else if (current_context
->thread_group
!= -1)
384 struct inferior
*inf
= find_inferior_id (current_context
->thread_group
);
386 iterate_over_threads (interrupt_thread_callback
, &inf
->pid
);
390 /* Interrupt just the current thread -- either explicitly
391 specified via --thread or whatever was current before
392 MI command was sent. */
393 interrupt_target_1 (0);
397 /* Start the execution of the given inferior.
399 START_P indicates whether the program should be stopped when reaching the
400 main subprogram (similar to what the CLI "start" command does). */
403 run_one_inferior (inferior
*inf
, bool start_p
)
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
);
418 switch_to_inferior_no_thread (inf
);
419 mi_execute_cli_command (run_cmd
, async_p
,
420 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 for (inferior
*inf
: all_inferiors ())
466 run_one_inferior (inf
, start_p
);
470 const char *run_cmd
= start_p
? "start" : "run";
471 struct target_ops
*run_target
= find_run_target ();
472 int async_p
= mi_async
&& run_target
->can_async_p ();
474 mi_execute_cli_command (run_cmd
, async_p
,
475 async_p
? "&" : NULL
);
481 find_thread_of_process (struct thread_info
*ti
, void *p
)
485 if (ti
->ptid
.pid () == pid
&& ti
->state
!= THREAD_EXITED
)
492 mi_cmd_target_detach (const char *command
, char **argv
, int argc
)
494 if (argc
!= 0 && argc
!= 1)
495 error (_("Usage: -target-detach [pid | thread-group]"));
499 struct thread_info
*tp
;
503 /* First see if we are dealing with a thread-group id. */
506 struct inferior
*inf
;
507 int id
= strtoul (argv
[0] + 1, &end
, 0);
510 error (_("Invalid syntax of thread-group id '%s'"), argv
[0]);
512 inf
= find_inferior_id (id
);
514 error (_("Non-existent thread-group id '%d'"), id
);
520 /* We must be dealing with a pid. */
521 pid
= strtol (argv
[0], &end
, 10);
524 error (_("Invalid identifier '%s'"), argv
[0]);
527 /* Pick any thread in the desired process. Current
528 target_detach detaches from the parent of inferior_ptid. */
529 tp
= iterate_over_threads (find_thread_of_process
, &pid
);
531 error (_("Thread group is empty"));
533 switch_to_thread (tp
);
536 detach_command (NULL
, 0);
540 mi_cmd_target_flash_erase (const char *command
, char **argv
, int argc
)
542 flash_erase_command (NULL
, 0);
546 mi_cmd_thread_select (const char *command
, char **argv
, int argc
)
549 error (_("-thread-select: USAGE: threadnum."));
551 int num
= value_as_long (parse_and_eval (argv
[0]));
552 thread_info
*thr
= find_thread_global_id (num
);
554 error (_("Thread ID %d not known."), num
);
556 ptid_t previous_ptid
= inferior_ptid
;
558 thread_select (argv
[0], thr
);
560 print_selected_thread_frame (current_uiout
,
561 USER_SELECTED_THREAD
| USER_SELECTED_FRAME
);
563 /* Notify if the thread has effectively changed. */
564 if (inferior_ptid
!= previous_ptid
)
566 gdb::observers::user_selected_context_changed
.notify
567 (USER_SELECTED_THREAD
| USER_SELECTED_FRAME
);
572 mi_cmd_thread_list_ids (const char *command
, char **argv
, int argc
)
575 error (_("-thread-list-ids: No arguments required."));
578 int current_thread
= -1;
580 update_thread_list ();
583 ui_out_emit_tuple
tuple_emitter (current_uiout
, "thread-ids");
585 for (thread_info
*tp
: all_non_exited_threads ())
587 if (tp
->ptid
== inferior_ptid
)
588 current_thread
= tp
->global_num
;
591 current_uiout
->field_signed ("thread-id", tp
->global_num
);
595 if (current_thread
!= -1)
596 current_uiout
->field_signed ("current-thread-id", current_thread
);
597 current_uiout
->field_signed ("number-of-threads", num
);
601 mi_cmd_thread_info (const char *command
, char **argv
, int argc
)
603 if (argc
!= 0 && argc
!= 1)
604 error (_("Invalid MI command"));
606 print_thread_info (current_uiout
, argv
[0], -1);
609 struct collect_cores_data
616 collect_cores (struct thread_info
*ti
, void *xdata
)
618 struct collect_cores_data
*data
= (struct collect_cores_data
*) xdata
;
620 if (ti
->ptid
.pid () == data
->pid
)
622 int core
= target_core_of_thread (ti
->ptid
);
625 data
->cores
.insert (core
);
631 struct print_one_inferior_data
634 const std::set
<int> *inferiors
;
638 print_one_inferior (struct inferior
*inferior
, bool recurse
,
639 const std::set
<int> &ids
)
641 struct ui_out
*uiout
= current_uiout
;
643 if (ids
.empty () || (ids
.find (inferior
->pid
) != ids
.end ()))
645 struct collect_cores_data data
;
646 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
648 uiout
->field_fmt ("id", "i%d", inferior
->num
);
649 uiout
->field_string ("type", "process");
650 if (inferior
->has_exit_code
)
651 uiout
->field_string ("exit-code",
652 int_string (inferior
->exit_code
, 8, 0, 0, 1));
653 if (inferior
->pid
!= 0)
654 uiout
->field_signed ("pid", inferior
->pid
);
656 if (inferior
->pspace
->exec_filename
!= nullptr)
658 uiout
->field_string ("executable",
659 inferior
->pspace
->exec_filename
.get ());
662 if (inferior
->pid
!= 0)
664 data
.pid
= inferior
->pid
;
665 iterate_over_threads (collect_cores
, &data
);
668 if (!data
.cores
.empty ())
670 ui_out_emit_list
list_emitter (uiout
, "cores");
672 for (int b
: data
.cores
)
673 uiout
->field_signed (NULL
, b
);
677 print_thread_info (uiout
, NULL
, inferior
->pid
);
681 /* Output a field named 'cores' with a list as the value. The
682 elements of the list are obtained by splitting 'cores' on
686 output_cores (struct ui_out
*uiout
, const char *field_name
, const char *xcores
)
688 ui_out_emit_list
list_emitter (uiout
, field_name
);
689 auto cores
= make_unique_xstrdup (xcores
);
690 char *p
= cores
.get ();
693 for (p
= strtok_r (p
, ",", &saveptr
); p
; p
= strtok_r (NULL
, ",", &saveptr
))
694 uiout
->field_string (NULL
, p
);
698 list_available_thread_groups (const std::set
<int> &ids
, int recurse
)
700 struct ui_out
*uiout
= current_uiout
;
702 /* This keeps a map from integer (pid) to vector of struct osdata_item.
703 The vector contains information about all threads for the given pid. */
704 std::map
<int, std::vector
<osdata_item
>> tree
;
706 /* get_osdata will throw if it cannot return data. */
707 std::unique_ptr
<osdata
> data
= get_osdata ("processes");
711 std::unique_ptr
<osdata
> threads
= get_osdata ("threads");
713 for (const osdata_item
&item
: threads
->items
)
715 const std::string
*pid
= get_osdata_column (item
, "pid");
716 int pid_i
= strtoul (pid
->c_str (), NULL
, 0);
718 tree
[pid_i
].push_back (item
);
722 ui_out_emit_list
list_emitter (uiout
, "groups");
724 for (const osdata_item
&item
: data
->items
)
726 const std::string
*pid
= get_osdata_column (item
, "pid");
727 const std::string
*cmd
= get_osdata_column (item
, "command");
728 const std::string
*user
= get_osdata_column (item
, "user");
729 const std::string
*cores
= get_osdata_column (item
, "cores");
731 int pid_i
= strtoul (pid
->c_str (), NULL
, 0);
733 /* At present, the target will return all available processes
734 and if information about specific ones was required, we filter
735 undesired processes here. */
736 if (!ids
.empty () && ids
.find (pid_i
) == ids
.end ())
739 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
741 uiout
->field_string ("id", pid
->c_str ());
742 uiout
->field_string ("type", "process");
744 uiout
->field_string ("description", cmd
->c_str ());
746 uiout
->field_string ("user", user
->c_str ());
748 output_cores (uiout
, "cores", cores
->c_str ());
752 auto n
= tree
.find (pid_i
);
753 if (n
!= tree
.end ())
755 std::vector
<osdata_item
> &children
= n
->second
;
757 ui_out_emit_list
thread_list_emitter (uiout
, "threads");
759 for (const osdata_item
&child
: children
)
761 ui_out_emit_tuple
inner_tuple_emitter (uiout
, NULL
);
762 const std::string
*tid
= get_osdata_column (child
, "tid");
763 const std::string
*tcore
= get_osdata_column (child
, "core");
765 uiout
->field_string ("id", tid
->c_str ());
767 uiout
->field_string ("core", tcore
->c_str ());
775 mi_cmd_list_thread_groups (const char *command
, char **argv
, int argc
)
777 struct ui_out
*uiout
= current_uiout
;
784 AVAILABLE_OPT
, RECURSE_OPT
786 static const struct mi_opt opts
[] =
788 {"-available", AVAILABLE_OPT
, 0},
789 {"-recurse", RECURSE_OPT
, 1},
798 int opt
= mi_getopt ("-list-thread-groups", argc
, argv
, opts
,
803 switch ((enum opt
) opt
)
809 if (strcmp (oarg
, "0") == 0)
811 else if (strcmp (oarg
, "1") == 0)
814 error (_("only '0' and '1' are valid values "
815 "for the '--recurse' option"));
820 for (; oind
< argc
; ++oind
)
825 if (*(argv
[oind
]) != 'i')
826 error (_("invalid syntax of group id '%s'"), argv
[oind
]);
828 inf
= strtoul (argv
[oind
] + 1, &end
, 0);
831 error (_("invalid syntax of group id '%s'"), argv
[oind
]);
837 list_available_thread_groups (ids
, recurse
);
839 else if (ids
.size () == 1)
841 /* Local thread groups, single id. */
842 int id
= *(ids
.begin ());
843 struct inferior
*inf
= find_inferior_id (id
);
846 error (_("Non-existent thread group id '%d'"), id
);
848 print_thread_info (uiout
, NULL
, inf
->pid
);
852 /* Local thread groups. Either no explicit ids -- and we
853 print everything, or several explicit ids. In both cases,
854 we print more than one group, and have to use 'groups'
855 as the top-level element. */
856 ui_out_emit_list
list_emitter (uiout
, "groups");
857 update_thread_list ();
858 for (inferior
*inf
: all_inferiors ())
859 print_one_inferior (inf
, recurse
, ids
);
864 mi_cmd_data_list_register_names (const char *command
, char **argv
, int argc
)
866 struct gdbarch
*gdbarch
;
867 struct ui_out
*uiout
= current_uiout
;
871 /* Note that the test for a valid register must include checking the
872 gdbarch_register_name because gdbarch_num_regs may be allocated
873 for the union of the register sets within a family of related
874 processors. In this case, some entries of gdbarch_register_name
875 will change depending upon the particular processor being
878 gdbarch
= get_current_arch ();
879 numregs
= gdbarch_num_cooked_regs (gdbarch
);
881 ui_out_emit_list
list_emitter (uiout
, "register-names");
883 if (argc
== 0) /* No args, just do all the regs. */
889 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
890 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
891 uiout
->field_string (NULL
, "");
893 uiout
->field_string (NULL
, gdbarch_register_name (gdbarch
, regnum
));
897 /* Else, list of register #s, just do listed regs. */
898 for (i
= 0; i
< argc
; i
++)
900 regnum
= atoi (argv
[i
]);
901 if (regnum
< 0 || regnum
>= numregs
)
902 error (_("bad register number"));
904 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
905 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
906 uiout
->field_string (NULL
, "");
908 uiout
->field_string (NULL
, gdbarch_register_name (gdbarch
, regnum
));
913 mi_cmd_data_list_changed_registers (const char *command
, char **argv
, int argc
)
915 static std::unique_ptr
<readonly_detached_regcache
> this_regs
;
916 struct ui_out
*uiout
= current_uiout
;
917 std::unique_ptr
<readonly_detached_regcache
> prev_regs
;
918 struct gdbarch
*gdbarch
;
922 /* The last time we visited this function, the current frame's
923 register contents were saved in THIS_REGS. Move THIS_REGS over
924 to PREV_REGS, and refresh THIS_REGS with the now-current register
927 prev_regs
= std::move (this_regs
);
928 this_regs
= frame_save_as_regcache (get_selected_frame (NULL
));
930 /* Note that the test for a valid register must include checking the
931 gdbarch_register_name because gdbarch_num_regs may be allocated
932 for the union of the register sets within a family of related
933 processors. In this case, some entries of gdbarch_register_name
934 will change depending upon the particular processor being
937 gdbarch
= this_regs
->arch ();
938 numregs
= gdbarch_num_cooked_regs (gdbarch
);
940 ui_out_emit_list
list_emitter (uiout
, "changed-registers");
944 /* No args, just do all the regs. */
949 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
950 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
953 if (register_changed_p (regnum
, prev_regs
.get (),
955 uiout
->field_signed (NULL
, regnum
);
959 /* Else, list of register #s, just do listed regs. */
960 for (i
= 0; i
< argc
; i
++)
962 regnum
= atoi (argv
[i
]);
966 && gdbarch_register_name (gdbarch
, regnum
) != NULL
967 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
969 if (register_changed_p (regnum
, prev_regs
.get (),
971 uiout
->field_signed (NULL
, regnum
);
974 error (_("bad register number"));
979 register_changed_p (int regnum
, readonly_detached_regcache
*prev_regs
,
980 readonly_detached_regcache
*this_regs
)
982 struct gdbarch
*gdbarch
= this_regs
->arch ();
983 struct value
*prev_value
, *this_value
;
985 /* First time through or after gdbarch change consider all registers
987 if (!prev_regs
|| prev_regs
->arch () != gdbarch
)
990 /* Get register contents and compare. */
991 prev_value
= prev_regs
->cooked_read_value (regnum
);
992 this_value
= this_regs
->cooked_read_value (regnum
);
993 gdb_assert (prev_value
!= NULL
);
994 gdb_assert (this_value
!= NULL
);
996 auto ret
= !value_contents_eq (prev_value
, 0, this_value
, 0,
997 register_size (gdbarch
, regnum
));
999 release_value (prev_value
);
1000 release_value (this_value
);
1004 /* Return a list of register number and value pairs. The valid
1005 arguments expected are: a letter indicating the format in which to
1006 display the registers contents. This can be one of: x
1007 (hexadecimal), d (decimal), N (natural), t (binary), o (octal), r
1008 (raw). After the format argument there can be a sequence of
1009 numbers, indicating which registers to fetch the content of. If
1010 the format is the only argument, a list of all the registers with
1011 their values is returned. */
1014 mi_cmd_data_list_register_values (const char *command
, char **argv
, int argc
)
1016 struct ui_out
*uiout
= current_uiout
;
1017 struct frame_info
*frame
;
1018 struct gdbarch
*gdbarch
;
1019 int regnum
, numregs
, format
;
1021 int skip_unavailable
= 0;
1027 static const struct mi_opt opts
[] =
1029 {"-skip-unavailable", SKIP_UNAVAILABLE
, 0},
1033 /* Note that the test for a valid register must include checking the
1034 gdbarch_register_name because gdbarch_num_regs may be allocated
1035 for the union of the register sets within a family of related
1036 processors. In this case, some entries of gdbarch_register_name
1037 will change depending upon the particular processor being
1043 int opt
= mi_getopt ("-data-list-register-values", argc
, argv
,
1044 opts
, &oind
, &oarg
);
1048 switch ((enum opt
) opt
)
1050 case SKIP_UNAVAILABLE
:
1051 skip_unavailable
= 1;
1056 if (argc
- oind
< 1)
1057 error (_("-data-list-register-values: Usage: "
1058 "-data-list-register-values [--skip-unavailable] <format>"
1059 " [<regnum1>...<regnumN>]"));
1061 format
= (int) argv
[oind
][0];
1063 frame
= get_selected_frame (NULL
);
1064 gdbarch
= get_frame_arch (frame
);
1065 numregs
= gdbarch_num_cooked_regs (gdbarch
);
1067 ui_out_emit_list
list_emitter (uiout
, "register-values");
1069 if (argc
- oind
== 1)
1071 /* No args, beside the format: do all the regs. */
1076 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1077 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1080 output_register (frame
, regnum
, format
, skip_unavailable
);
1084 /* Else, list of register #s, just do listed regs. */
1085 for (i
= 1 + oind
; i
< argc
; i
++)
1087 regnum
= atoi (argv
[i
]);
1091 && gdbarch_register_name (gdbarch
, regnum
) != NULL
1092 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
1093 output_register (frame
, regnum
, format
, skip_unavailable
);
1095 error (_("bad register number"));
1099 /* Output one register REGNUM's contents in the desired FORMAT. If
1100 SKIP_UNAVAILABLE is true, skip the register if it is
1104 output_register (struct frame_info
*frame
, int regnum
, int format
,
1105 int skip_unavailable
)
1107 struct ui_out
*uiout
= current_uiout
;
1108 struct value
*val
= value_of_register (regnum
, frame
);
1109 struct value_print_options opts
;
1111 if (skip_unavailable
&& !value_entirely_available (val
))
1114 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1115 uiout
->field_signed ("number", regnum
);
1125 get_formatted_print_options (&opts
, format
);
1127 common_val_print (val
, &stb
, 0, &opts
, current_language
);
1128 uiout
->field_stream ("value", stb
);
1131 /* Write given values into registers. The registers and values are
1132 given as pairs. The corresponding MI command is
1133 -data-write-register-values <format>
1134 [<regnum1> <value1>...<regnumN> <valueN>] */
1136 mi_cmd_data_write_register_values (const char *command
, char **argv
, int argc
)
1138 struct regcache
*regcache
;
1139 struct gdbarch
*gdbarch
;
1142 /* Note that the test for a valid register must include checking the
1143 gdbarch_register_name because gdbarch_num_regs may be allocated
1144 for the union of the register sets within a family of related
1145 processors. In this case, some entries of gdbarch_register_name
1146 will change depending upon the particular processor being
1149 regcache
= get_current_regcache ();
1150 gdbarch
= regcache
->arch ();
1151 numregs
= gdbarch_num_cooked_regs (gdbarch
);
1154 error (_("-data-write-register-values: Usage: -data-write-register-"
1155 "values <format> [<regnum1> <value1>...<regnumN> <valueN>]"));
1157 if (!target_has_registers ())
1158 error (_("-data-write-register-values: No registers."));
1161 error (_("-data-write-register-values: No regs and values specified."));
1164 error (_("-data-write-register-values: "
1165 "Regs and vals are not in pairs."));
1167 for (i
= 1; i
< argc
; i
= i
+ 2)
1169 int regnum
= atoi (argv
[i
]);
1171 if (regnum
>= 0 && regnum
< numregs
1172 && gdbarch_register_name (gdbarch
, regnum
)
1173 && *gdbarch_register_name (gdbarch
, regnum
))
1177 /* Get the value as a number. */
1178 value
= parse_and_eval_address (argv
[i
+ 1]);
1180 /* Write it down. */
1181 regcache_cooked_write_signed (regcache
, regnum
, value
);
1184 error (_("bad register number"));
1188 /* Evaluate the value of the argument. The argument is an
1189 expression. If the expression contains spaces it needs to be
1190 included in double quotes. */
1193 mi_cmd_data_evaluate_expression (const char *command
, char **argv
, int argc
)
1196 struct value_print_options opts
;
1197 struct ui_out
*uiout
= current_uiout
;
1200 error (_("-data-evaluate-expression: "
1201 "Usage: -data-evaluate-expression expression"));
1203 expression_up expr
= parse_expression (argv
[0]);
1205 val
= evaluate_expression (expr
.get ());
1209 /* Print the result of the expression evaluation. */
1210 get_user_print_options (&opts
);
1212 common_val_print (val
, &stb
, 0, &opts
, current_language
);
1214 uiout
->field_stream ("value", stb
);
1217 /* This is the -data-read-memory command.
1219 ADDR: start address of data to be dumped.
1220 WORD-FORMAT: a char indicating format for the ``word''. See
1222 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes.
1223 NR_ROW: Number of rows.
1224 NR_COL: The number of columns (words per row).
1225 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
1226 ASCHAR for unprintable characters.
1228 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
1229 displays them. Returns:
1231 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
1234 The number of bytes read is SIZE*ROW*COL. */
1237 mi_cmd_data_read_memory (const char *command
, char **argv
, int argc
)
1239 struct gdbarch
*gdbarch
= get_current_arch ();
1240 struct ui_out
*uiout
= current_uiout
;
1242 long total_bytes
, nr_cols
, nr_rows
;
1244 struct type
*word_type
;
1256 static const struct mi_opt opts
[] =
1258 {"o", OFFSET_OPT
, 1},
1264 int opt
= mi_getopt ("-data-read-memory", argc
, argv
, opts
,
1269 switch ((enum opt
) opt
)
1272 offset
= atol (oarg
);
1279 if (argc
< 5 || argc
> 6)
1280 error (_("-data-read-memory: Usage: "
1281 "ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR]."));
1283 /* Extract all the arguments. */
1285 /* Start address of the memory dump. */
1286 addr
= parse_and_eval_address (argv
[0]) + offset
;
1287 /* The format character to use when displaying a memory word. See
1288 the ``x'' command. */
1289 word_format
= argv
[1][0];
1290 /* The size of the memory word. */
1291 word_size
= atol (argv
[2]);
1295 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1299 word_type
= builtin_type (gdbarch
)->builtin_int16
;
1303 word_type
= builtin_type (gdbarch
)->builtin_int32
;
1307 word_type
= builtin_type (gdbarch
)->builtin_int64
;
1311 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1314 /* The number of rows. */
1315 nr_rows
= atol (argv
[3]);
1317 error (_("-data-read-memory: invalid number of rows."));
1319 /* Number of bytes per row. */
1320 nr_cols
= atol (argv
[4]);
1322 error (_("-data-read-memory: invalid number of columns."));
1324 /* The un-printable character when printing ascii. */
1330 /* Create a buffer and read it in. */
1331 total_bytes
= word_size
* nr_rows
* nr_cols
;
1333 gdb::byte_vector
mbuf (total_bytes
);
1335 nr_bytes
= target_read (current_inferior ()->top_target (),
1336 TARGET_OBJECT_MEMORY
, NULL
,
1337 mbuf
.data (), addr
, total_bytes
);
1339 error (_("Unable to read memory."));
1341 /* Output the header information. */
1342 uiout
->field_core_addr ("addr", gdbarch
, addr
);
1343 uiout
->field_signed ("nr-bytes", nr_bytes
);
1344 uiout
->field_signed ("total-bytes", total_bytes
);
1345 uiout
->field_core_addr ("next-row", gdbarch
, addr
+ word_size
* nr_cols
);
1346 uiout
->field_core_addr ("prev-row", gdbarch
, addr
- word_size
* nr_cols
);
1347 uiout
->field_core_addr ("next-page", gdbarch
, addr
+ total_bytes
);
1348 uiout
->field_core_addr ("prev-page", gdbarch
, addr
- total_bytes
);
1350 /* Build the result as a two dimensional table. */
1357 ui_out_emit_list
list_emitter (uiout
, "memory");
1358 for (row
= 0, row_byte
= 0;
1360 row
++, row_byte
+= nr_cols
* word_size
)
1364 struct value_print_options print_opts
;
1366 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1367 uiout
->field_core_addr ("addr", gdbarch
, addr
+ row_byte
);
1368 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr +
1371 ui_out_emit_list
list_data_emitter (uiout
, "data");
1372 get_formatted_print_options (&print_opts
, word_format
);
1373 for (col
= 0, col_byte
= row_byte
;
1375 col
++, col_byte
+= word_size
)
1377 if (col_byte
+ word_size
> nr_bytes
)
1379 uiout
->field_string (NULL
, "N/A");
1384 print_scalar_formatted (&mbuf
[col_byte
], word_type
,
1385 &print_opts
, word_asize
, &stream
);
1386 uiout
->field_stream (NULL
, stream
);
1396 for (byte
= row_byte
;
1397 byte
< row_byte
+ word_size
* nr_cols
; byte
++)
1399 if (byte
>= nr_bytes
)
1401 else if (mbuf
[byte
] < 32 || mbuf
[byte
] > 126)
1402 stream
.putc (aschar
);
1404 stream
.putc (mbuf
[byte
]);
1406 uiout
->field_stream ("ascii", stream
);
1413 mi_cmd_data_read_memory_bytes (const char *command
, char **argv
, int argc
)
1415 struct gdbarch
*gdbarch
= get_current_arch ();
1416 struct ui_out
*uiout
= current_uiout
;
1420 int unit_size
= gdbarch_addressable_memory_unit_size (gdbarch
);
1427 static const struct mi_opt opts
[] =
1429 {"o", OFFSET_OPT
, 1},
1435 int opt
= mi_getopt ("-data-read-memory-bytes", argc
, argv
, opts
,
1439 switch ((enum opt
) opt
)
1442 offset
= atol (oarg
);
1450 error (_("Usage: [ -o OFFSET ] ADDR LENGTH."));
1452 addr
= parse_and_eval_address (argv
[0]) + offset
;
1453 length
= atol (argv
[1]);
1455 std::vector
<memory_read_result
> result
1456 = read_memory_robust (current_inferior ()->top_target (), addr
, length
);
1458 if (result
.size () == 0)
1459 error (_("Unable to read memory."));
1461 ui_out_emit_list
list_emitter (uiout
, "memory");
1462 for (const memory_read_result
&read_result
: result
)
1464 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1466 uiout
->field_core_addr ("begin", gdbarch
, read_result
.begin
);
1467 uiout
->field_core_addr ("offset", gdbarch
, read_result
.begin
- addr
);
1468 uiout
->field_core_addr ("end", gdbarch
, read_result
.end
);
1470 std::string data
= bin2hex (read_result
.data
.get (),
1471 (read_result
.end
- read_result
.begin
)
1473 uiout
->field_string ("contents", data
.c_str ());
1477 /* Implementation of the -data-write_memory command.
1479 COLUMN_OFFSET: optional argument. Must be preceded by '-o'. The
1480 offset from the beginning of the memory grid row where the cell to
1482 ADDR: start address of the row in the memory grid where the memory
1483 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
1484 the location to write to.
1485 FORMAT: a char indicating format for the ``word''. See
1487 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
1488 VALUE: value to be written into the memory address.
1490 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
1495 mi_cmd_data_write_memory (const char *command
, char **argv
, int argc
)
1497 struct gdbarch
*gdbarch
= get_current_arch ();
1498 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1501 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
1502 enough when using a compiler other than GCC. */
1511 static const struct mi_opt opts
[] =
1513 {"o", OFFSET_OPT
, 1},
1519 int opt
= mi_getopt ("-data-write-memory", argc
, argv
, opts
,
1524 switch ((enum opt
) opt
)
1527 offset
= atol (oarg
);
1535 error (_("-data-write-memory: Usage: "
1536 "[-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE."));
1538 /* Extract all the arguments. */
1539 /* Start address of the memory dump. */
1540 addr
= parse_and_eval_address (argv
[0]);
1541 /* The size of the memory word. */
1542 word_size
= atol (argv
[2]);
1544 /* Calculate the real address of the write destination. */
1545 addr
+= (offset
* word_size
);
1547 /* Get the value as a number. */
1548 value
= parse_and_eval_address (argv
[3]);
1549 /* Get the value into an array. */
1550 gdb::byte_vector
buffer (word_size
);
1551 store_signed_integer (buffer
.data (), word_size
, byte_order
, value
);
1552 /* Write it down to memory. */
1553 write_memory_with_notification (addr
, buffer
.data (), word_size
);
1556 /* Implementation of the -data-write-memory-bytes command.
1559 DATA: string of bytes to write at that address
1560 COUNT: number of bytes to be filled (decimal integer). */
1563 mi_cmd_data_write_memory_bytes (const char *command
, char **argv
, int argc
)
1567 size_t len_hex
, len_bytes
, len_units
, i
, steps
, remaining_units
;
1568 long int count_units
;
1571 if (argc
!= 2 && argc
!= 3)
1572 error (_("Usage: ADDR DATA [COUNT]."));
1574 addr
= parse_and_eval_address (argv
[0]);
1576 len_hex
= strlen (cdata
);
1577 unit_size
= gdbarch_addressable_memory_unit_size (get_current_arch ());
1579 if (len_hex
% (unit_size
* 2) != 0)
1580 error (_("Hex-encoded '%s' must represent an integral number of "
1581 "addressable memory units."),
1584 len_bytes
= len_hex
/ 2;
1585 len_units
= len_bytes
/ unit_size
;
1588 count_units
= strtoul (argv
[2], NULL
, 10);
1590 count_units
= len_units
;
1592 gdb::byte_vector
databuf (len_bytes
);
1594 for (i
= 0; i
< len_bytes
; ++i
)
1597 if (sscanf (cdata
+ i
* 2, "%02x", &x
) != 1)
1598 error (_("Invalid argument"));
1599 databuf
[i
] = (gdb_byte
) x
;
1602 gdb::byte_vector data
;
1603 if (len_units
< count_units
)
1605 /* Pattern is made of less units than count:
1606 repeat pattern to fill memory. */
1607 data
= gdb::byte_vector (count_units
* unit_size
);
1609 /* Number of times the pattern is entirely repeated. */
1610 steps
= count_units
/ len_units
;
1611 /* Number of remaining addressable memory units. */
1612 remaining_units
= count_units
% len_units
;
1613 for (i
= 0; i
< steps
; i
++)
1614 memcpy (&data
[i
* len_bytes
], &databuf
[0], len_bytes
);
1616 if (remaining_units
> 0)
1617 memcpy (&data
[steps
* len_bytes
], &databuf
[0],
1618 remaining_units
* unit_size
);
1622 /* Pattern is longer than or equal to count:
1623 just copy count addressable memory units. */
1624 data
= std::move (databuf
);
1627 write_memory_with_notification (addr
, data
.data (), count_units
);
1631 mi_cmd_enable_timings (const char *command
, char **argv
, int argc
)
1637 if (strcmp (argv
[0], "yes") == 0)
1639 else if (strcmp (argv
[0], "no") == 0)
1650 error (_("-enable-timings: Usage: %s {yes|no}"), command
);
1654 mi_cmd_list_features (const char *command
, char **argv
, int argc
)
1658 struct ui_out
*uiout
= current_uiout
;
1660 ui_out_emit_list
list_emitter (uiout
, "features");
1661 uiout
->field_string (NULL
, "frozen-varobjs");
1662 uiout
->field_string (NULL
, "pending-breakpoints");
1663 uiout
->field_string (NULL
, "thread-info");
1664 uiout
->field_string (NULL
, "data-read-memory-bytes");
1665 uiout
->field_string (NULL
, "breakpoint-notifications");
1666 uiout
->field_string (NULL
, "ada-task-info");
1667 uiout
->field_string (NULL
, "language-option");
1668 uiout
->field_string (NULL
, "info-gdb-mi-command");
1669 uiout
->field_string (NULL
, "undefined-command-error-code");
1670 uiout
->field_string (NULL
, "exec-run-start-option");
1671 uiout
->field_string (NULL
, "data-disassemble-a-option");
1673 if (ext_lang_initialized_p (get_ext_lang_defn (EXT_LANG_PYTHON
)))
1674 uiout
->field_string (NULL
, "python");
1679 error (_("-list-features should be passed no arguments"));
1683 mi_cmd_list_target_features (const char *command
, char **argv
, int argc
)
1687 struct ui_out
*uiout
= current_uiout
;
1689 ui_out_emit_list
list_emitter (uiout
, "features");
1691 uiout
->field_string (NULL
, "async");
1692 if (target_can_execute_reverse ())
1693 uiout
->field_string (NULL
, "reverse");
1697 error (_("-list-target-features should be passed no arguments"));
1701 mi_cmd_add_inferior (const char *command
, char **argv
, int argc
)
1703 struct inferior
*inf
;
1706 error (_("-add-inferior should be passed no arguments"));
1708 inf
= add_inferior_with_spaces ();
1710 current_uiout
->field_fmt ("inferior", "i%d", inf
->num
);
1714 mi_cmd_remove_inferior (const char *command
, char **argv
, int argc
)
1717 struct inferior
*inf_to_remove
;
1720 error (_("-remove-inferior should be passed a single argument"));
1722 if (sscanf (argv
[0], "i%d", &id
) != 1)
1723 error (_("the thread group id is syntactically invalid"));
1725 inf_to_remove
= find_inferior_id (id
);
1726 if (inf_to_remove
== NULL
)
1727 error (_("the specified thread group does not exist"));
1729 if (inf_to_remove
->pid
!= 0)
1730 error (_("cannot remove an active inferior"));
1732 if (inf_to_remove
== current_inferior ())
1734 struct thread_info
*tp
= 0;
1735 struct inferior
*new_inferior
= NULL
;
1737 for (inferior
*inf
: all_inferiors ())
1739 if (inf
!= inf_to_remove
)
1743 if (new_inferior
== NULL
)
1744 error (_("Cannot remove last inferior"));
1746 set_current_inferior (new_inferior
);
1747 if (new_inferior
->pid
!= 0)
1748 tp
= any_thread_of_inferior (new_inferior
);
1750 switch_to_thread (tp
);
1752 switch_to_no_thread ();
1753 set_current_program_space (new_inferior
->pspace
);
1756 delete_inferior (inf_to_remove
);
1761 /* Execute a command within a safe environment.
1762 Return <0 for error; >=0 for ok.
1764 args->action will tell mi_execute_command what action
1765 to perform after the given command has executed (display/suppress
1766 prompt, display error). */
1769 captured_mi_execute_command (struct ui_out
*uiout
, struct mi_parse
*context
)
1771 struct mi_interp
*mi
= (struct mi_interp
*) command_interp ();
1774 current_command_ts
= context
->cmd_start
;
1776 scoped_restore save_token
= make_scoped_restore (¤t_token
,
1779 running_result_record_printed
= 0;
1781 switch (context
->op
)
1784 /* A MI command was read from the input stream. */
1786 /* FIXME: gdb_???? */
1787 fprintf_unfiltered (mi
->raw_stdout
,
1788 " token=`%s' command=`%s' args=`%s'\n",
1789 context
->token
, context
->command
, context
->args
);
1791 mi_cmd_execute (context
);
1793 /* Print the result if there were no errors.
1795 Remember that on the way out of executing a command, you have
1796 to directly use the mi_interp's uiout, since the command
1797 could have reset the interpreter, in which case the current
1798 uiout will most likely crash in the mi_out_* routines. */
1799 if (!running_result_record_printed
)
1801 fputs_unfiltered (context
->token
, mi
->raw_stdout
);
1802 /* There's no particularly good reason why target-connect results
1803 in not ^done. Should kill ^connected for MI3. */
1804 fputs_unfiltered (strcmp (context
->command
, "target-select") == 0
1805 ? "^connected" : "^done", mi
->raw_stdout
);
1806 mi_out_put (uiout
, mi
->raw_stdout
);
1807 mi_out_rewind (uiout
);
1808 mi_print_timing_maybe (mi
->raw_stdout
);
1809 fputs_unfiltered ("\n", mi
->raw_stdout
);
1812 /* The command does not want anything to be printed. In that
1813 case, the command probably should not have written anything
1814 to uiout, but in case it has written something, discard it. */
1815 mi_out_rewind (uiout
);
1822 /* A CLI command was read from the input stream. */
1823 /* This "feature" will be removed as soon as we have a
1824 complete set of mi commands. */
1825 /* Echo the command on the console. */
1826 fprintf_unfiltered (gdb_stdlog
, "%s\n", context
->command
);
1827 /* Call the "console" interpreter. */
1828 argv
[0] = (char *) INTERP_CONSOLE
;
1829 argv
[1] = context
->command
;
1830 mi_cmd_interpreter_exec ("-interpreter-exec", argv
, 2);
1832 /* If we changed interpreters, DON'T print out anything. */
1833 if (current_interp_named_p (INTERP_MI
)
1834 || current_interp_named_p (INTERP_MI1
)
1835 || current_interp_named_p (INTERP_MI2
)
1836 || current_interp_named_p (INTERP_MI3
))
1838 if (!running_result_record_printed
)
1840 fputs_unfiltered (context
->token
, mi
->raw_stdout
);
1841 fputs_unfiltered ("^done", mi
->raw_stdout
);
1842 mi_out_put (uiout
, mi
->raw_stdout
);
1843 mi_out_rewind (uiout
);
1844 mi_print_timing_maybe (mi
->raw_stdout
);
1845 fputs_unfiltered ("\n", mi
->raw_stdout
);
1848 mi_out_rewind (uiout
);
1855 /* Print a gdb exception to the MI output stream. */
1858 mi_print_exception (const char *token
, const struct gdb_exception
&exception
)
1860 struct mi_interp
*mi
= (struct mi_interp
*) current_interpreter ();
1862 fputs_unfiltered (token
, mi
->raw_stdout
);
1863 fputs_unfiltered ("^error,msg=\"", mi
->raw_stdout
);
1864 if (exception
.message
== NULL
)
1865 fputs_unfiltered ("unknown error", mi
->raw_stdout
);
1867 fputstr_unfiltered (exception
.what (), '"', mi
->raw_stdout
);
1868 fputs_unfiltered ("\"", mi
->raw_stdout
);
1870 switch (exception
.error
)
1872 case UNDEFINED_COMMAND_ERROR
:
1873 fputs_unfiltered (",code=\"undefined-command\"", mi
->raw_stdout
);
1877 fputs_unfiltered ("\n", mi
->raw_stdout
);
1880 /* Determine whether the parsed command already notifies the
1881 user_selected_context_changed observer. */
1884 command_notifies_uscc_observer (struct mi_parse
*command
)
1886 if (command
->op
== CLI_COMMAND
)
1888 /* CLI commands "thread" and "inferior" already send it. */
1889 return (strncmp (command
->command
, "thread ", 7) == 0
1890 || strncmp (command
->command
, "inferior ", 9) == 0);
1892 else /* MI_COMMAND */
1894 if (strcmp (command
->command
, "interpreter-exec") == 0
1895 && command
->argc
> 1)
1897 /* "thread" and "inferior" again, but through -interpreter-exec. */
1898 return (strncmp (command
->argv
[1], "thread ", 7) == 0
1899 || strncmp (command
->argv
[1], "inferior ", 9) == 0);
1903 /* -thread-select already sends it. */
1904 return strcmp (command
->command
, "thread-select") == 0;
1909 mi_execute_command (const char *cmd
, int from_tty
)
1912 std::unique_ptr
<struct mi_parse
> command
;
1914 /* This is to handle EOF (^D). We just quit gdb. */
1915 /* FIXME: we should call some API function here. */
1917 quit_force (NULL
, from_tty
);
1919 target_log_command (cmd
);
1923 command
= mi_parse (cmd
, &token
);
1925 catch (const gdb_exception
&exception
)
1927 mi_print_exception (token
, exception
);
1931 if (command
!= NULL
)
1933 ptid_t previous_ptid
= inferior_ptid
;
1935 gdb::optional
<scoped_restore_tmpl
<int>> restore_suppress
;
1937 if (command
->cmd
!= NULL
&& command
->cmd
->suppress_notification
!= NULL
)
1938 restore_suppress
.emplace (command
->cmd
->suppress_notification
, 1);
1940 command
->token
= token
;
1944 command
->cmd_start
= new mi_timestamp ();
1945 timestamp (command
->cmd_start
);
1950 captured_mi_execute_command (current_uiout
, command
.get ());
1952 catch (const gdb_exception
&result
)
1954 /* Like in start_event_loop, enable input and force display
1955 of the prompt. Otherwise, any command that calls
1956 async_disable_stdin, and then throws, will leave input
1958 async_enable_stdin ();
1959 current_ui
->prompt_state
= PROMPT_NEEDED
;
1961 /* The command execution failed and error() was called
1963 mi_print_exception (command
->token
, result
);
1964 mi_out_rewind (current_uiout
);
1967 bpstat_do_actions ();
1969 if (/* The notifications are only output when the top-level
1970 interpreter (specified on the command line) is MI. */
1971 top_level_interpreter ()->interp_ui_out ()->is_mi_like_p ()
1972 /* Don't try report anything if there are no threads --
1973 the program is dead. */
1975 /* If the command already reports the thread change, no need to do it
1977 && !command_notifies_uscc_observer (command
.get ()))
1979 int report_change
= 0;
1981 if (command
->thread
== -1)
1983 report_change
= (previous_ptid
!= null_ptid
1984 && inferior_ptid
!= previous_ptid
1985 && inferior_ptid
!= null_ptid
);
1987 else if (inferior_ptid
!= null_ptid
)
1989 struct thread_info
*ti
= inferior_thread ();
1991 report_change
= (ti
->global_num
!= command
->thread
);
1996 gdb::observers::user_selected_context_changed
.notify
1997 (USER_SELECTED_THREAD
| USER_SELECTED_FRAME
);
2004 mi_cmd_execute (struct mi_parse
*parse
)
2006 scoped_value_mark cleanup
= prepare_execute_command ();
2008 if (parse
->all
&& parse
->thread_group
!= -1)
2009 error (_("Cannot specify --thread-group together with --all"));
2011 if (parse
->all
&& parse
->thread
!= -1)
2012 error (_("Cannot specify --thread together with --all"));
2014 if (parse
->thread_group
!= -1 && parse
->thread
!= -1)
2015 error (_("Cannot specify --thread together with --thread-group"));
2017 if (parse
->frame
!= -1 && parse
->thread
== -1)
2018 error (_("Cannot specify --frame without --thread"));
2020 if (parse
->thread_group
!= -1)
2022 struct inferior
*inf
= find_inferior_id (parse
->thread_group
);
2023 struct thread_info
*tp
= 0;
2026 error (_("Invalid thread group for the --thread-group option"));
2028 set_current_inferior (inf
);
2029 /* This behaviour means that if --thread-group option identifies
2030 an inferior with multiple threads, then a random one will be
2031 picked. This is not a problem -- frontend should always
2032 provide --thread if it wishes to operate on a specific
2035 tp
= any_live_thread_of_inferior (inf
);
2037 switch_to_thread (tp
);
2039 switch_to_no_thread ();
2040 set_current_program_space (inf
->pspace
);
2043 if (parse
->thread
!= -1)
2045 thread_info
*tp
= find_thread_global_id (parse
->thread
);
2048 error (_("Invalid thread id: %d"), parse
->thread
);
2050 if (tp
->state
== THREAD_EXITED
)
2051 error (_("Thread id: %d has terminated"), parse
->thread
);
2053 switch_to_thread (tp
);
2056 if (parse
->frame
!= -1)
2058 struct frame_info
*fid
;
2059 int frame
= parse
->frame
;
2061 fid
= find_relative_frame (get_current_frame (), &frame
);
2063 /* find_relative_frame was successful */
2066 error (_("Invalid frame id: %d"), frame
);
2069 gdb::optional
<scoped_restore_current_language
> lang_saver
;
2070 if (parse
->language
!= language_unknown
)
2072 lang_saver
.emplace ();
2073 set_language (parse
->language
);
2076 current_context
= parse
;
2078 if (parse
->cmd
->argv_func
!= NULL
)
2080 parse
->cmd
->argv_func (parse
->command
, parse
->argv
, parse
->argc
);
2082 else if (parse
->cmd
->cli
.cmd
!= 0)
2084 /* FIXME: DELETE THIS. */
2085 /* The operation is still implemented by a cli command. */
2086 /* Must be a synchronous one. */
2087 mi_execute_cli_command (parse
->cmd
->cli
.cmd
, parse
->cmd
->cli
.args_p
,
2092 /* FIXME: DELETE THIS. */
2095 stb
.puts ("Undefined mi command: ");
2096 stb
.putstr (parse
->command
, '"');
2097 stb
.puts (" (missing implementation)");
2103 /* FIXME: This is just a hack so we can get some extra commands going.
2104 We don't want to channel things through the CLI, but call libgdb directly.
2105 Use only for synchronous commands. */
2108 mi_execute_cli_command (const char *cmd
, int args_p
, const char *args
)
2112 std::string run
= cmd
;
2115 run
= run
+ " " + args
;
2117 /* FIXME: gdb_???? */
2118 fprintf_unfiltered (gdb_stdout
, "cli=%s run=%s\n",
2120 execute_command (run
.c_str (), 0 /* from_tty */ );
2125 mi_execute_async_cli_command (const char *cli_command
, char **argv
, int argc
)
2127 std::string run
= cli_command
;
2130 run
= run
+ " " + *argv
;
2134 execute_command (run
.c_str (), 0 /* from_tty */ );
2138 mi_load_progress (const char *section_name
,
2139 unsigned long sent_so_far
,
2140 unsigned long total_section
,
2141 unsigned long total_sent
,
2142 unsigned long grand_total
)
2144 using namespace std::chrono
;
2145 static steady_clock::time_point last_update
;
2146 static char *previous_sect_name
= NULL
;
2148 struct mi_interp
*mi
= (struct mi_interp
*) current_interpreter ();
2150 /* This function is called through deprecated_show_load_progress
2151 which means uiout may not be correct. Fix it for the duration
2152 of this function. */
2154 std::unique_ptr
<ui_out
> uiout (mi_out_new (current_interpreter ()->name ()));
2155 if (uiout
== nullptr)
2158 scoped_restore save_uiout
2159 = make_scoped_restore (¤t_uiout
, uiout
.get ());
2161 new_section
= (previous_sect_name
?
2162 strcmp (previous_sect_name
, section_name
) : 1);
2165 xfree (previous_sect_name
);
2166 previous_sect_name
= xstrdup (section_name
);
2169 fputs_unfiltered (current_token
, mi
->raw_stdout
);
2170 fputs_unfiltered ("+download", mi
->raw_stdout
);
2172 ui_out_emit_tuple
tuple_emitter (uiout
.get (), NULL
);
2173 uiout
->field_string ("section", section_name
);
2174 uiout
->field_signed ("section-size", total_section
);
2175 uiout
->field_signed ("total-size", grand_total
);
2177 mi_out_put (uiout
.get (), mi
->raw_stdout
);
2178 fputs_unfiltered ("\n", mi
->raw_stdout
);
2179 gdb_flush (mi
->raw_stdout
);
2182 steady_clock::time_point time_now
= steady_clock::now ();
2183 if (time_now
- last_update
> milliseconds (500))
2185 last_update
= time_now
;
2187 fputs_unfiltered (current_token
, mi
->raw_stdout
);
2188 fputs_unfiltered ("+download", mi
->raw_stdout
);
2190 ui_out_emit_tuple
tuple_emitter (uiout
.get (), NULL
);
2191 uiout
->field_string ("section", section_name
);
2192 uiout
->field_signed ("section-sent", sent_so_far
);
2193 uiout
->field_signed ("section-size", total_section
);
2194 uiout
->field_signed ("total-sent", total_sent
);
2195 uiout
->field_signed ("total-size", grand_total
);
2197 mi_out_put (uiout
.get (), mi
->raw_stdout
);
2198 fputs_unfiltered ("\n", mi
->raw_stdout
);
2199 gdb_flush (mi
->raw_stdout
);
2204 timestamp (struct mi_timestamp
*tv
)
2206 using namespace std::chrono
;
2208 tv
->wallclock
= steady_clock::now ();
2209 run_time_clock::now (tv
->utime
, tv
->stime
);
2213 print_diff_now (struct ui_file
*file
, struct mi_timestamp
*start
)
2215 struct mi_timestamp now
;
2218 print_diff (file
, start
, &now
);
2222 mi_print_timing_maybe (struct ui_file
*file
)
2224 /* If the command is -enable-timing then do_timings may be true
2225 whilst current_command_ts is not initialized. */
2226 if (do_timings
&& current_command_ts
)
2227 print_diff_now (file
, current_command_ts
);
2231 print_diff (struct ui_file
*file
, struct mi_timestamp
*start
,
2232 struct mi_timestamp
*end
)
2234 using namespace std::chrono
;
2236 duration
<double> wallclock
= end
->wallclock
- start
->wallclock
;
2237 duration
<double> utime
= end
->utime
- start
->utime
;
2238 duration
<double> stime
= end
->stime
- start
->stime
;
2242 ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
2243 wallclock
.count (), utime
.count (), stime
.count ());
2247 mi_cmd_trace_define_variable (const char *command
, char **argv
, int argc
)
2249 LONGEST initval
= 0;
2250 struct trace_state_variable
*tsv
;
2253 if (argc
!= 1 && argc
!= 2)
2254 error (_("Usage: -trace-define-variable VARIABLE [VALUE]"));
2258 error (_("Name of trace variable should start with '$'"));
2260 validate_trace_state_variable_name (name
);
2262 tsv
= find_trace_state_variable (name
);
2264 tsv
= create_trace_state_variable (name
);
2267 initval
= value_as_long (parse_and_eval (argv
[1]));
2269 tsv
->initial_value
= initval
;
2273 mi_cmd_trace_list_variables (const char *command
, char **argv
, int argc
)
2276 error (_("-trace-list-variables: no arguments allowed"));
2278 tvariables_info_1 ();
2282 mi_cmd_trace_find (const char *command
, char **argv
, int argc
)
2287 error (_("trace selection mode is required"));
2291 if (strcmp (mode
, "none") == 0)
2293 tfind_1 (tfind_number
, -1, 0, 0, 0);
2297 check_trace_running (current_trace_status ());
2299 if (strcmp (mode
, "frame-number") == 0)
2302 error (_("frame number is required"));
2303 tfind_1 (tfind_number
, atoi (argv
[1]), 0, 0, 0);
2305 else if (strcmp (mode
, "tracepoint-number") == 0)
2308 error (_("tracepoint number is required"));
2309 tfind_1 (tfind_tp
, atoi (argv
[1]), 0, 0, 0);
2311 else if (strcmp (mode
, "pc") == 0)
2314 error (_("PC is required"));
2315 tfind_1 (tfind_pc
, 0, parse_and_eval_address (argv
[1]), 0, 0);
2317 else if (strcmp (mode
, "pc-inside-range") == 0)
2320 error (_("Start and end PC are required"));
2321 tfind_1 (tfind_range
, 0, parse_and_eval_address (argv
[1]),
2322 parse_and_eval_address (argv
[2]), 0);
2324 else if (strcmp (mode
, "pc-outside-range") == 0)
2327 error (_("Start and end PC are required"));
2328 tfind_1 (tfind_outside
, 0, parse_and_eval_address (argv
[1]),
2329 parse_and_eval_address (argv
[2]), 0);
2331 else if (strcmp (mode
, "line") == 0)
2334 error (_("Line is required"));
2336 std::vector
<symtab_and_line
> sals
2337 = decode_line_with_current_source (argv
[1],
2338 DECODE_LINE_FUNFIRSTLINE
);
2339 const symtab_and_line
&sal
= sals
[0];
2341 if (sal
.symtab
== 0)
2342 error (_("Could not find the specified line"));
2344 CORE_ADDR start_pc
, end_pc
;
2345 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2346 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, 0);
2348 error (_("Could not find the specified line"));
2351 error (_("Invalid mode '%s'"), mode
);
2353 if (has_stack_frames () || get_traceframe_number () >= 0)
2354 print_stack_frame (get_selected_frame (NULL
), 1, LOC_AND_ADDRESS
, 1);
2358 mi_cmd_trace_save (const char *command
, char **argv
, int argc
)
2360 int target_saves
= 0;
2361 int generate_ctf
= 0;
2368 TARGET_SAVE_OPT
, CTF_OPT
2370 static const struct mi_opt opts
[] =
2372 {"r", TARGET_SAVE_OPT
, 0},
2373 {"ctf", CTF_OPT
, 0},
2379 int opt
= mi_getopt ("-trace-save", argc
, argv
, opts
,
2384 switch ((enum opt
) opt
)
2386 case TARGET_SAVE_OPT
:
2395 if (argc
- oind
!= 1)
2396 error (_("Exactly one argument required "
2397 "(file in which to save trace data)"));
2399 filename
= argv
[oind
];
2402 trace_save_ctf (filename
, target_saves
);
2404 trace_save_tfile (filename
, target_saves
);
2408 mi_cmd_trace_start (const char *command
, char **argv
, int argc
)
2410 start_tracing (NULL
);
2414 mi_cmd_trace_status (const char *command
, char **argv
, int argc
)
2416 trace_status_mi (0);
2420 mi_cmd_trace_stop (const char *command
, char **argv
, int argc
)
2422 stop_tracing (NULL
);
2423 trace_status_mi (1);
2426 /* Implement the "-ada-task-info" command. */
2429 mi_cmd_ada_task_info (const char *command
, char **argv
, int argc
)
2431 if (argc
!= 0 && argc
!= 1)
2432 error (_("Invalid MI command"));
2434 print_ada_task_info (current_uiout
, argv
[0], current_inferior ());
2437 /* Print EXPRESSION according to VALUES. */
2440 print_variable_or_computed (const char *expression
, enum print_values values
)
2444 struct ui_out
*uiout
= current_uiout
;
2448 expression_up expr
= parse_expression (expression
);
2450 if (values
== PRINT_SIMPLE_VALUES
)
2451 val
= evaluate_type (expr
.get ());
2453 val
= evaluate_expression (expr
.get ());
2455 gdb::optional
<ui_out_emit_tuple
> tuple_emitter
;
2456 if (values
!= PRINT_NO_VALUES
)
2457 tuple_emitter
.emplace (uiout
, nullptr);
2458 uiout
->field_string ("name", expression
);
2462 case PRINT_SIMPLE_VALUES
:
2463 type
= check_typedef (value_type (val
));
2464 type_print (value_type (val
), "", &stb
, -1);
2465 uiout
->field_stream ("type", stb
);
2466 if (type
->code () != TYPE_CODE_ARRAY
2467 && type
->code () != TYPE_CODE_STRUCT
2468 && type
->code () != TYPE_CODE_UNION
)
2470 struct value_print_options opts
;
2472 get_no_prettyformat_print_options (&opts
);
2474 common_val_print (val
, &stb
, 0, &opts
, current_language
);
2475 uiout
->field_stream ("value", stb
);
2478 case PRINT_ALL_VALUES
:
2480 struct value_print_options opts
;
2482 get_no_prettyformat_print_options (&opts
);
2484 common_val_print (val
, &stb
, 0, &opts
, current_language
);
2485 uiout
->field_stream ("value", stb
);
2491 /* Implement the "-trace-frame-collected" command. */
2494 mi_cmd_trace_frame_collected (const char *command
, char **argv
, int argc
)
2496 struct bp_location
*tloc
;
2498 struct collection_list
*clist
;
2499 struct collection_list tracepoint_list
, stepping_list
;
2500 struct traceframe_info
*tinfo
;
2502 enum print_values var_print_values
= PRINT_ALL_VALUES
;
2503 enum print_values comp_print_values
= PRINT_ALL_VALUES
;
2504 int registers_format
= 'x';
2505 int memory_contents
= 0;
2506 struct ui_out
*uiout
= current_uiout
;
2514 static const struct mi_opt opts
[] =
2516 {"-var-print-values", VAR_PRINT_VALUES
, 1},
2517 {"-comp-print-values", COMP_PRINT_VALUES
, 1},
2518 {"-registers-format", REGISTERS_FORMAT
, 1},
2519 {"-memory-contents", MEMORY_CONTENTS
, 0},
2526 int opt
= mi_getopt ("-trace-frame-collected", argc
, argv
, opts
,
2530 switch ((enum opt
) opt
)
2532 case VAR_PRINT_VALUES
:
2533 var_print_values
= mi_parse_print_values (oarg
);
2535 case COMP_PRINT_VALUES
:
2536 comp_print_values
= mi_parse_print_values (oarg
);
2538 case REGISTERS_FORMAT
:
2539 registers_format
= oarg
[0];
2541 case MEMORY_CONTENTS
:
2542 memory_contents
= 1;
2548 error (_("Usage: -trace-frame-collected "
2549 "[--var-print-values PRINT_VALUES] "
2550 "[--comp-print-values PRINT_VALUES] "
2551 "[--registers-format FORMAT]"
2552 "[--memory-contents]"));
2554 /* This throws an error is not inspecting a trace frame. */
2555 tloc
= get_traceframe_location (&stepping_frame
);
2557 /* This command only makes sense for the current frame, not the
2559 scoped_restore_current_thread restore_thread
;
2560 select_frame (get_current_frame ());
2562 encode_actions (tloc
, &tracepoint_list
, &stepping_list
);
2565 clist
= &stepping_list
;
2567 clist
= &tracepoint_list
;
2569 tinfo
= get_traceframe_info ();
2571 /* Explicitly wholly collected variables. */
2573 ui_out_emit_list
list_emitter (uiout
, "explicit-variables");
2574 const std::vector
<std::string
> &wholly_collected
2575 = clist
->wholly_collected ();
2576 for (size_t i
= 0; i
< wholly_collected
.size (); i
++)
2578 const std::string
&str
= wholly_collected
[i
];
2579 print_variable_or_computed (str
.c_str (), var_print_values
);
2583 /* Computed expressions. */
2585 ui_out_emit_list
list_emitter (uiout
, "computed-expressions");
2587 const std::vector
<std::string
> &computed
= clist
->computed ();
2588 for (size_t i
= 0; i
< computed
.size (); i
++)
2590 const std::string
&str
= computed
[i
];
2591 print_variable_or_computed (str
.c_str (), comp_print_values
);
2595 /* Registers. Given pseudo-registers, and that some architectures
2596 (like MIPS) actually hide the raw registers, we don't go through
2597 the trace frame info, but instead consult the register cache for
2598 register availability. */
2600 struct frame_info
*frame
;
2601 struct gdbarch
*gdbarch
;
2605 ui_out_emit_list
list_emitter (uiout
, "registers");
2607 frame
= get_selected_frame (NULL
);
2608 gdbarch
= get_frame_arch (frame
);
2609 numregs
= gdbarch_num_cooked_regs (gdbarch
);
2611 for (regnum
= 0; regnum
< numregs
; regnum
++)
2613 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
2614 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
2617 output_register (frame
, regnum
, registers_format
, 1);
2621 /* Trace state variables. */
2623 ui_out_emit_list
list_emitter (uiout
, "tvars");
2625 for (int tvar
: tinfo
->tvars
)
2627 struct trace_state_variable
*tsv
;
2629 tsv
= find_trace_state_variable_by_number (tvar
);
2631 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
2635 uiout
->field_fmt ("name", "$%s", tsv
->name
.c_str ());
2637 tsv
->value_known
= target_get_trace_state_variable_value (tsv
->number
,
2639 uiout
->field_signed ("current", tsv
->value
);
2643 uiout
->field_skip ("name");
2644 uiout
->field_skip ("current");
2651 std::vector
<mem_range
> available_memory
;
2653 traceframe_available_memory (&available_memory
, 0, ULONGEST_MAX
);
2655 ui_out_emit_list
list_emitter (uiout
, "memory");
2657 for (const mem_range
&r
: available_memory
)
2659 struct gdbarch
*gdbarch
= target_gdbarch ();
2661 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
2663 uiout
->field_core_addr ("address", gdbarch
, r
.start
);
2664 uiout
->field_signed ("length", r
.length
);
2666 gdb::byte_vector
data (r
.length
);
2668 if (memory_contents
)
2670 if (target_read_memory (r
.start
, data
.data (), r
.length
) == 0)
2672 std::string data_str
= bin2hex (data
.data (), r
.length
);
2673 uiout
->field_string ("contents", data_str
.c_str ());
2676 uiout
->field_skip ("contents");
2682 /* See mi/mi-main.h. */
2685 mi_cmd_fix_multi_location_breakpoint_output (const char *command
, char **argv
,
2688 fix_multi_location_breakpoint_output_globally
= true;
2691 /* Implement the "-complete" command. */
2694 mi_cmd_complete (const char *command
, char **argv
, int argc
)
2697 error (_("Usage: -complete COMMAND"));
2699 if (max_completions
== 0)
2700 error (_("max-completions is zero, completion is disabled."));
2702 int quote_char
= '\0';
2705 completion_result result
= complete (argv
[0], &word
, "e_char
);
2707 std::string
arg_prefix (argv
[0], word
- argv
[0]);
2709 struct ui_out
*uiout
= current_uiout
;
2711 if (result
.number_matches
> 0)
2712 uiout
->field_fmt ("completion", "%s%s",
2713 arg_prefix
.c_str (),result
.match_list
[0]);
2716 ui_out_emit_list
completions_emitter (uiout
, "matches");
2718 if (result
.number_matches
== 1)
2719 uiout
->field_fmt (NULL
, "%s%s",
2720 arg_prefix
.c_str (), result
.match_list
[0]);
2723 result
.sort_match_list ();
2724 for (size_t i
= 0; i
< result
.number_matches
; i
++)
2726 uiout
->field_fmt (NULL
, "%s%s",
2727 arg_prefix
.c_str (), result
.match_list
[i
+ 1]);
2731 uiout
->field_string ("max_completions_reached",
2732 result
.number_matches
== max_completions
? "1" : "0");
2736 void _initialize_mi_main ();
2738 _initialize_mi_main ()
2740 struct cmd_list_element
*c
;
2742 add_setshow_boolean_cmd ("mi-async", class_run
,
2744 Set whether MI asynchronous mode is enabled."), _("\
2745 Show whether MI asynchronous mode is enabled."), _("\
2746 Tells GDB whether MI should be in asynchronous mode."),
2747 set_mi_async_command
,
2748 show_mi_async_command
,
2752 /* Alias old "target-async" to "mi-async". */
2753 c
= add_alias_cmd ("target-async", "mi-async", class_run
, 0, &setlist
);
2754 deprecate_cmd (c
, "set mi-async");
2755 c
= add_alias_cmd ("target-async", "mi-async", class_run
, 0, &showlist
);
2756 deprecate_cmd (c
, "show mi-async");