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 scoped_disable_commit_resumed disable_commit_resumed
387 ("interrupting all threads of thread group");
389 iterate_over_threads (interrupt_thread_callback
, &inf
->pid
);
393 /* Interrupt just the current thread -- either explicitly
394 specified via --thread or whatever was current before
395 MI command was sent. */
396 interrupt_target_1 (0);
400 /* Start the execution of the given inferior.
402 START_P indicates whether the program should be stopped when reaching the
403 main subprogram (similar to what the CLI "start" command does). */
406 run_one_inferior (inferior
*inf
, bool start_p
)
408 const char *run_cmd
= start_p
? "start" : "run";
409 struct target_ops
*run_target
= find_run_target ();
410 int async_p
= mi_async
&& run_target
->can_async_p ();
414 thread_info
*tp
= any_thread_of_inferior (inf
);
416 error (_("Inferior has no threads."));
418 switch_to_thread (tp
);
421 switch_to_inferior_no_thread (inf
);
422 mi_execute_cli_command (run_cmd
, async_p
,
423 async_p
? "&" : NULL
);
427 mi_cmd_exec_run (const char *command
, char **argv
, int argc
)
431 /* Parse the command options. */
436 static const struct mi_opt opts
[] =
438 {"-start", START_OPT
, 0},
447 int opt
= mi_getopt ("-exec-run", argc
, argv
, opts
, &oind
, &oarg
);
451 switch ((enum opt
) opt
)
459 /* This command does not accept any argument. Make sure the user
460 did not provide any. */
462 error (_("Invalid argument: %s"), argv
[oind
]);
464 if (current_context
->all
)
466 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
468 for (inferior
*inf
: all_inferiors ())
469 run_one_inferior (inf
, start_p
);
473 const char *run_cmd
= start_p
? "start" : "run";
474 struct target_ops
*run_target
= find_run_target ();
475 int async_p
= mi_async
&& run_target
->can_async_p ();
477 mi_execute_cli_command (run_cmd
, async_p
,
478 async_p
? "&" : NULL
);
484 find_thread_of_process (struct thread_info
*ti
, void *p
)
488 if (ti
->ptid
.pid () == pid
&& ti
->state
!= THREAD_EXITED
)
495 mi_cmd_target_detach (const char *command
, char **argv
, int argc
)
497 if (argc
!= 0 && argc
!= 1)
498 error (_("Usage: -target-detach [pid | thread-group]"));
502 struct thread_info
*tp
;
506 /* First see if we are dealing with a thread-group id. */
509 struct inferior
*inf
;
510 int id
= strtoul (argv
[0] + 1, &end
, 0);
513 error (_("Invalid syntax of thread-group id '%s'"), argv
[0]);
515 inf
= find_inferior_id (id
);
517 error (_("Non-existent thread-group id '%d'"), id
);
523 /* We must be dealing with a pid. */
524 pid
= strtol (argv
[0], &end
, 10);
527 error (_("Invalid identifier '%s'"), argv
[0]);
530 /* Pick any thread in the desired process. Current
531 target_detach detaches from the parent of inferior_ptid. */
532 tp
= iterate_over_threads (find_thread_of_process
, &pid
);
534 error (_("Thread group is empty"));
536 switch_to_thread (tp
);
539 detach_command (NULL
, 0);
543 mi_cmd_target_flash_erase (const char *command
, char **argv
, int argc
)
545 flash_erase_command (NULL
, 0);
549 mi_cmd_thread_select (const char *command
, char **argv
, int argc
)
552 error (_("-thread-select: USAGE: threadnum."));
554 int num
= value_as_long (parse_and_eval (argv
[0]));
555 thread_info
*thr
= find_thread_global_id (num
);
557 error (_("Thread ID %d not known."), num
);
559 ptid_t previous_ptid
= inferior_ptid
;
561 thread_select (argv
[0], thr
);
563 print_selected_thread_frame (current_uiout
,
564 USER_SELECTED_THREAD
| USER_SELECTED_FRAME
);
566 /* Notify if the thread has effectively changed. */
567 if (inferior_ptid
!= previous_ptid
)
569 gdb::observers::user_selected_context_changed
.notify
570 (USER_SELECTED_THREAD
| USER_SELECTED_FRAME
);
575 mi_cmd_thread_list_ids (const char *command
, char **argv
, int argc
)
578 error (_("-thread-list-ids: No arguments required."));
581 int current_thread
= -1;
583 update_thread_list ();
586 ui_out_emit_tuple
tuple_emitter (current_uiout
, "thread-ids");
588 for (thread_info
*tp
: all_non_exited_threads ())
590 if (tp
->ptid
== inferior_ptid
)
591 current_thread
= tp
->global_num
;
594 current_uiout
->field_signed ("thread-id", tp
->global_num
);
598 if (current_thread
!= -1)
599 current_uiout
->field_signed ("current-thread-id", current_thread
);
600 current_uiout
->field_signed ("number-of-threads", num
);
604 mi_cmd_thread_info (const char *command
, char **argv
, int argc
)
606 if (argc
!= 0 && argc
!= 1)
607 error (_("Invalid MI command"));
609 print_thread_info (current_uiout
, argv
[0], -1);
612 struct collect_cores_data
619 collect_cores (struct thread_info
*ti
, void *xdata
)
621 struct collect_cores_data
*data
= (struct collect_cores_data
*) xdata
;
623 if (ti
->ptid
.pid () == data
->pid
)
625 int core
= target_core_of_thread (ti
->ptid
);
628 data
->cores
.insert (core
);
634 struct print_one_inferior_data
637 const std::set
<int> *inferiors
;
641 print_one_inferior (struct inferior
*inferior
, bool recurse
,
642 const std::set
<int> &ids
)
644 struct ui_out
*uiout
= current_uiout
;
646 if (ids
.empty () || (ids
.find (inferior
->pid
) != ids
.end ()))
648 struct collect_cores_data data
;
649 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
651 uiout
->field_fmt ("id", "i%d", inferior
->num
);
652 uiout
->field_string ("type", "process");
653 if (inferior
->has_exit_code
)
654 uiout
->field_string ("exit-code",
655 int_string (inferior
->exit_code
, 8, 0, 0, 1));
656 if (inferior
->pid
!= 0)
657 uiout
->field_signed ("pid", inferior
->pid
);
659 if (inferior
->pspace
->exec_filename
!= nullptr)
661 uiout
->field_string ("executable",
662 inferior
->pspace
->exec_filename
.get ());
665 if (inferior
->pid
!= 0)
667 data
.pid
= inferior
->pid
;
668 iterate_over_threads (collect_cores
, &data
);
671 if (!data
.cores
.empty ())
673 ui_out_emit_list
list_emitter (uiout
, "cores");
675 for (int b
: data
.cores
)
676 uiout
->field_signed (NULL
, b
);
680 print_thread_info (uiout
, NULL
, inferior
->pid
);
684 /* Output a field named 'cores' with a list as the value. The
685 elements of the list are obtained by splitting 'cores' on
689 output_cores (struct ui_out
*uiout
, const char *field_name
, const char *xcores
)
691 ui_out_emit_list
list_emitter (uiout
, field_name
);
692 auto cores
= make_unique_xstrdup (xcores
);
693 char *p
= cores
.get ();
696 for (p
= strtok_r (p
, ",", &saveptr
); p
; p
= strtok_r (NULL
, ",", &saveptr
))
697 uiout
->field_string (NULL
, p
);
701 list_available_thread_groups (const std::set
<int> &ids
, int recurse
)
703 struct ui_out
*uiout
= current_uiout
;
705 /* This keeps a map from integer (pid) to vector of struct osdata_item.
706 The vector contains information about all threads for the given pid. */
707 std::map
<int, std::vector
<osdata_item
>> tree
;
709 /* get_osdata will throw if it cannot return data. */
710 std::unique_ptr
<osdata
> data
= get_osdata ("processes");
714 std::unique_ptr
<osdata
> threads
= get_osdata ("threads");
716 for (const osdata_item
&item
: threads
->items
)
718 const std::string
*pid
= get_osdata_column (item
, "pid");
719 int pid_i
= strtoul (pid
->c_str (), NULL
, 0);
721 tree
[pid_i
].push_back (item
);
725 ui_out_emit_list
list_emitter (uiout
, "groups");
727 for (const osdata_item
&item
: data
->items
)
729 const std::string
*pid
= get_osdata_column (item
, "pid");
730 const std::string
*cmd
= get_osdata_column (item
, "command");
731 const std::string
*user
= get_osdata_column (item
, "user");
732 const std::string
*cores
= get_osdata_column (item
, "cores");
734 int pid_i
= strtoul (pid
->c_str (), NULL
, 0);
736 /* At present, the target will return all available processes
737 and if information about specific ones was required, we filter
738 undesired processes here. */
739 if (!ids
.empty () && ids
.find (pid_i
) == ids
.end ())
742 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
744 uiout
->field_string ("id", *pid
);
745 uiout
->field_string ("type", "process");
747 uiout
->field_string ("description", *cmd
);
749 uiout
->field_string ("user", *user
);
751 output_cores (uiout
, "cores", cores
->c_str ());
755 auto n
= tree
.find (pid_i
);
756 if (n
!= tree
.end ())
758 std::vector
<osdata_item
> &children
= n
->second
;
760 ui_out_emit_list
thread_list_emitter (uiout
, "threads");
762 for (const osdata_item
&child
: children
)
764 ui_out_emit_tuple
inner_tuple_emitter (uiout
, NULL
);
765 const std::string
*tid
= get_osdata_column (child
, "tid");
766 const std::string
*tcore
= get_osdata_column (child
, "core");
768 uiout
->field_string ("id", *tid
);
770 uiout
->field_string ("core", *tcore
);
778 mi_cmd_list_thread_groups (const char *command
, char **argv
, int argc
)
780 struct ui_out
*uiout
= current_uiout
;
787 AVAILABLE_OPT
, RECURSE_OPT
789 static const struct mi_opt opts
[] =
791 {"-available", AVAILABLE_OPT
, 0},
792 {"-recurse", RECURSE_OPT
, 1},
801 int opt
= mi_getopt ("-list-thread-groups", argc
, argv
, opts
,
806 switch ((enum opt
) opt
)
812 if (strcmp (oarg
, "0") == 0)
814 else if (strcmp (oarg
, "1") == 0)
817 error (_("only '0' and '1' are valid values "
818 "for the '--recurse' option"));
823 for (; oind
< argc
; ++oind
)
828 if (*(argv
[oind
]) != 'i')
829 error (_("invalid syntax of group id '%s'"), argv
[oind
]);
831 inf
= strtoul (argv
[oind
] + 1, &end
, 0);
834 error (_("invalid syntax of group id '%s'"), argv
[oind
]);
840 list_available_thread_groups (ids
, recurse
);
842 else if (ids
.size () == 1)
844 /* Local thread groups, single id. */
845 int id
= *(ids
.begin ());
846 struct inferior
*inf
= find_inferior_id (id
);
849 error (_("Non-existent thread group id '%d'"), id
);
851 print_thread_info (uiout
, NULL
, inf
->pid
);
855 /* Local thread groups. Either no explicit ids -- and we
856 print everything, or several explicit ids. In both cases,
857 we print more than one group, and have to use 'groups'
858 as the top-level element. */
859 ui_out_emit_list
list_emitter (uiout
, "groups");
860 update_thread_list ();
861 for (inferior
*inf
: all_inferiors ())
862 print_one_inferior (inf
, recurse
, ids
);
867 mi_cmd_data_list_register_names (const char *command
, char **argv
, int argc
)
869 struct gdbarch
*gdbarch
;
870 struct ui_out
*uiout
= current_uiout
;
874 /* Note that the test for a valid register must include checking the
875 gdbarch_register_name because gdbarch_num_regs may be allocated
876 for the union of the register sets within a family of related
877 processors. In this case, some entries of gdbarch_register_name
878 will change depending upon the particular processor being
881 gdbarch
= get_current_arch ();
882 numregs
= gdbarch_num_cooked_regs (gdbarch
);
884 ui_out_emit_list
list_emitter (uiout
, "register-names");
886 if (argc
== 0) /* No args, just do all the regs. */
892 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
893 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
894 uiout
->field_string (NULL
, "");
896 uiout
->field_string (NULL
, gdbarch_register_name (gdbarch
, regnum
));
900 /* Else, list of register #s, just do listed regs. */
901 for (i
= 0; i
< argc
; i
++)
903 regnum
= atoi (argv
[i
]);
904 if (regnum
< 0 || regnum
>= numregs
)
905 error (_("bad register number"));
907 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
908 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
909 uiout
->field_string (NULL
, "");
911 uiout
->field_string (NULL
, gdbarch_register_name (gdbarch
, regnum
));
916 mi_cmd_data_list_changed_registers (const char *command
, char **argv
, int argc
)
918 static std::unique_ptr
<readonly_detached_regcache
> this_regs
;
919 struct ui_out
*uiout
= current_uiout
;
920 std::unique_ptr
<readonly_detached_regcache
> prev_regs
;
921 struct gdbarch
*gdbarch
;
925 /* The last time we visited this function, the current frame's
926 register contents were saved in THIS_REGS. Move THIS_REGS over
927 to PREV_REGS, and refresh THIS_REGS with the now-current register
930 prev_regs
= std::move (this_regs
);
931 this_regs
= frame_save_as_regcache (get_selected_frame (NULL
));
933 /* Note that the test for a valid register must include checking the
934 gdbarch_register_name because gdbarch_num_regs may be allocated
935 for the union of the register sets within a family of related
936 processors. In this case, some entries of gdbarch_register_name
937 will change depending upon the particular processor being
940 gdbarch
= this_regs
->arch ();
941 numregs
= gdbarch_num_cooked_regs (gdbarch
);
943 ui_out_emit_list
list_emitter (uiout
, "changed-registers");
947 /* No args, just do all the regs. */
952 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
953 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
956 if (register_changed_p (regnum
, prev_regs
.get (),
958 uiout
->field_signed (NULL
, regnum
);
962 /* Else, list of register #s, just do listed regs. */
963 for (i
= 0; i
< argc
; i
++)
965 regnum
= atoi (argv
[i
]);
969 && gdbarch_register_name (gdbarch
, regnum
) != NULL
970 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
972 if (register_changed_p (regnum
, prev_regs
.get (),
974 uiout
->field_signed (NULL
, regnum
);
977 error (_("bad register number"));
982 register_changed_p (int regnum
, readonly_detached_regcache
*prev_regs
,
983 readonly_detached_regcache
*this_regs
)
985 struct gdbarch
*gdbarch
= this_regs
->arch ();
986 struct value
*prev_value
, *this_value
;
988 /* First time through or after gdbarch change consider all registers
990 if (!prev_regs
|| prev_regs
->arch () != gdbarch
)
993 /* Get register contents and compare. */
994 prev_value
= prev_regs
->cooked_read_value (regnum
);
995 this_value
= this_regs
->cooked_read_value (regnum
);
996 gdb_assert (prev_value
!= NULL
);
997 gdb_assert (this_value
!= NULL
);
999 auto ret
= !value_contents_eq (prev_value
, 0, this_value
, 0,
1000 register_size (gdbarch
, regnum
));
1002 release_value (prev_value
);
1003 release_value (this_value
);
1007 /* Return a list of register number and value pairs. The valid
1008 arguments expected are: a letter indicating the format in which to
1009 display the registers contents. This can be one of: x
1010 (hexadecimal), d (decimal), N (natural), t (binary), o (octal), r
1011 (raw). After the format argument there can be a sequence of
1012 numbers, indicating which registers to fetch the content of. If
1013 the format is the only argument, a list of all the registers with
1014 their values is returned. */
1017 mi_cmd_data_list_register_values (const char *command
, char **argv
, int argc
)
1019 struct ui_out
*uiout
= current_uiout
;
1020 struct frame_info
*frame
;
1021 struct gdbarch
*gdbarch
;
1022 int regnum
, numregs
, format
;
1024 int skip_unavailable
= 0;
1030 static const struct mi_opt opts
[] =
1032 {"-skip-unavailable", SKIP_UNAVAILABLE
, 0},
1036 /* Note that the test for a valid register must include checking the
1037 gdbarch_register_name because gdbarch_num_regs may be allocated
1038 for the union of the register sets within a family of related
1039 processors. In this case, some entries of gdbarch_register_name
1040 will change depending upon the particular processor being
1046 int opt
= mi_getopt ("-data-list-register-values", argc
, argv
,
1047 opts
, &oind
, &oarg
);
1051 switch ((enum opt
) opt
)
1053 case SKIP_UNAVAILABLE
:
1054 skip_unavailable
= 1;
1059 if (argc
- oind
< 1)
1060 error (_("-data-list-register-values: Usage: "
1061 "-data-list-register-values [--skip-unavailable] <format>"
1062 " [<regnum1>...<regnumN>]"));
1064 format
= (int) argv
[oind
][0];
1066 frame
= get_selected_frame (NULL
);
1067 gdbarch
= get_frame_arch (frame
);
1068 numregs
= gdbarch_num_cooked_regs (gdbarch
);
1070 ui_out_emit_list
list_emitter (uiout
, "register-values");
1072 if (argc
- oind
== 1)
1074 /* No args, beside the format: do all the regs. */
1079 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1080 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1083 output_register (frame
, regnum
, format
, skip_unavailable
);
1087 /* Else, list of register #s, just do listed regs. */
1088 for (i
= 1 + oind
; i
< argc
; i
++)
1090 regnum
= atoi (argv
[i
]);
1094 && gdbarch_register_name (gdbarch
, regnum
) != NULL
1095 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
1096 output_register (frame
, regnum
, format
, skip_unavailable
);
1098 error (_("bad register number"));
1102 /* Output one register REGNUM's contents in the desired FORMAT. If
1103 SKIP_UNAVAILABLE is true, skip the register if it is
1107 output_register (struct frame_info
*frame
, int regnum
, int format
,
1108 int skip_unavailable
)
1110 struct ui_out
*uiout
= current_uiout
;
1111 struct value
*val
= value_of_register (regnum
, frame
);
1112 struct value_print_options opts
;
1114 if (skip_unavailable
&& !value_entirely_available (val
))
1117 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1118 uiout
->field_signed ("number", regnum
);
1128 get_formatted_print_options (&opts
, format
);
1130 common_val_print (val
, &stb
, 0, &opts
, current_language
);
1131 uiout
->field_stream ("value", stb
);
1134 /* Write given values into registers. The registers and values are
1135 given as pairs. The corresponding MI command is
1136 -data-write-register-values <format>
1137 [<regnum1> <value1>...<regnumN> <valueN>] */
1139 mi_cmd_data_write_register_values (const char *command
, char **argv
, int argc
)
1141 struct regcache
*regcache
;
1142 struct gdbarch
*gdbarch
;
1145 /* Note that the test for a valid register must include checking the
1146 gdbarch_register_name because gdbarch_num_regs may be allocated
1147 for the union of the register sets within a family of related
1148 processors. In this case, some entries of gdbarch_register_name
1149 will change depending upon the particular processor being
1152 regcache
= get_current_regcache ();
1153 gdbarch
= regcache
->arch ();
1154 numregs
= gdbarch_num_cooked_regs (gdbarch
);
1157 error (_("-data-write-register-values: Usage: -data-write-register-"
1158 "values <format> [<regnum1> <value1>...<regnumN> <valueN>]"));
1160 if (!target_has_registers ())
1161 error (_("-data-write-register-values: No registers."));
1164 error (_("-data-write-register-values: No regs and values specified."));
1167 error (_("-data-write-register-values: "
1168 "Regs and vals are not in pairs."));
1170 for (i
= 1; i
< argc
; i
= i
+ 2)
1172 int regnum
= atoi (argv
[i
]);
1174 if (regnum
>= 0 && regnum
< numregs
1175 && gdbarch_register_name (gdbarch
, regnum
)
1176 && *gdbarch_register_name (gdbarch
, regnum
))
1180 /* Get the value as a number. */
1181 value
= parse_and_eval_address (argv
[i
+ 1]);
1183 /* Write it down. */
1184 regcache_cooked_write_signed (regcache
, regnum
, value
);
1187 error (_("bad register number"));
1191 /* Evaluate the value of the argument. The argument is an
1192 expression. If the expression contains spaces it needs to be
1193 included in double quotes. */
1196 mi_cmd_data_evaluate_expression (const char *command
, char **argv
, int argc
)
1199 struct value_print_options opts
;
1200 struct ui_out
*uiout
= current_uiout
;
1203 error (_("-data-evaluate-expression: "
1204 "Usage: -data-evaluate-expression expression"));
1206 expression_up expr
= parse_expression (argv
[0]);
1208 val
= evaluate_expression (expr
.get ());
1212 /* Print the result of the expression evaluation. */
1213 get_user_print_options (&opts
);
1215 common_val_print (val
, &stb
, 0, &opts
, current_language
);
1217 uiout
->field_stream ("value", stb
);
1220 /* This is the -data-read-memory command.
1222 ADDR: start address of data to be dumped.
1223 WORD-FORMAT: a char indicating format for the ``word''. See
1225 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes.
1226 NR_ROW: Number of rows.
1227 NR_COL: The number of columns (words per row).
1228 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
1229 ASCHAR for unprintable characters.
1231 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
1232 displays them. Returns:
1234 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
1237 The number of bytes read is SIZE*ROW*COL. */
1240 mi_cmd_data_read_memory (const char *command
, char **argv
, int argc
)
1242 struct gdbarch
*gdbarch
= get_current_arch ();
1243 struct ui_out
*uiout
= current_uiout
;
1245 long total_bytes
, nr_cols
, nr_rows
;
1247 struct type
*word_type
;
1259 static const struct mi_opt opts
[] =
1261 {"o", OFFSET_OPT
, 1},
1267 int opt
= mi_getopt ("-data-read-memory", argc
, argv
, opts
,
1272 switch ((enum opt
) opt
)
1275 offset
= atol (oarg
);
1282 if (argc
< 5 || argc
> 6)
1283 error (_("-data-read-memory: Usage: "
1284 "ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR]."));
1286 /* Extract all the arguments. */
1288 /* Start address of the memory dump. */
1289 addr
= parse_and_eval_address (argv
[0]) + offset
;
1290 /* The format character to use when displaying a memory word. See
1291 the ``x'' command. */
1292 word_format
= argv
[1][0];
1293 /* The size of the memory word. */
1294 word_size
= atol (argv
[2]);
1298 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1302 word_type
= builtin_type (gdbarch
)->builtin_int16
;
1306 word_type
= builtin_type (gdbarch
)->builtin_int32
;
1310 word_type
= builtin_type (gdbarch
)->builtin_int64
;
1314 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1317 /* The number of rows. */
1318 nr_rows
= atol (argv
[3]);
1320 error (_("-data-read-memory: invalid number of rows."));
1322 /* Number of bytes per row. */
1323 nr_cols
= atol (argv
[4]);
1325 error (_("-data-read-memory: invalid number of columns."));
1327 /* The un-printable character when printing ascii. */
1333 /* Create a buffer and read it in. */
1334 total_bytes
= word_size
* nr_rows
* nr_cols
;
1336 gdb::byte_vector
mbuf (total_bytes
);
1338 nr_bytes
= target_read (current_inferior ()->top_target (),
1339 TARGET_OBJECT_MEMORY
, NULL
,
1340 mbuf
.data (), addr
, total_bytes
);
1342 error (_("Unable to read memory."));
1344 /* Output the header information. */
1345 uiout
->field_core_addr ("addr", gdbarch
, addr
);
1346 uiout
->field_signed ("nr-bytes", nr_bytes
);
1347 uiout
->field_signed ("total-bytes", total_bytes
);
1348 uiout
->field_core_addr ("next-row", gdbarch
, addr
+ word_size
* nr_cols
);
1349 uiout
->field_core_addr ("prev-row", gdbarch
, addr
- word_size
* nr_cols
);
1350 uiout
->field_core_addr ("next-page", gdbarch
, addr
+ total_bytes
);
1351 uiout
->field_core_addr ("prev-page", gdbarch
, addr
- total_bytes
);
1353 /* Build the result as a two dimensional table. */
1360 ui_out_emit_list
list_emitter (uiout
, "memory");
1361 for (row
= 0, row_byte
= 0;
1363 row
++, row_byte
+= nr_cols
* word_size
)
1367 struct value_print_options print_opts
;
1369 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1370 uiout
->field_core_addr ("addr", gdbarch
, addr
+ row_byte
);
1371 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr +
1374 ui_out_emit_list
list_data_emitter (uiout
, "data");
1375 get_formatted_print_options (&print_opts
, word_format
);
1376 for (col
= 0, col_byte
= row_byte
;
1378 col
++, col_byte
+= word_size
)
1380 if (col_byte
+ word_size
> nr_bytes
)
1382 uiout
->field_string (NULL
, "N/A");
1387 print_scalar_formatted (&mbuf
[col_byte
], word_type
,
1388 &print_opts
, word_asize
, &stream
);
1389 uiout
->field_stream (NULL
, stream
);
1399 for (byte
= row_byte
;
1400 byte
< row_byte
+ word_size
* nr_cols
; byte
++)
1402 if (byte
>= nr_bytes
)
1404 else if (mbuf
[byte
] < 32 || mbuf
[byte
] > 126)
1405 stream
.putc (aschar
);
1407 stream
.putc (mbuf
[byte
]);
1409 uiout
->field_stream ("ascii", stream
);
1416 mi_cmd_data_read_memory_bytes (const char *command
, char **argv
, int argc
)
1418 struct gdbarch
*gdbarch
= get_current_arch ();
1419 struct ui_out
*uiout
= current_uiout
;
1423 int unit_size
= gdbarch_addressable_memory_unit_size (gdbarch
);
1430 static const struct mi_opt opts
[] =
1432 {"o", OFFSET_OPT
, 1},
1438 int opt
= mi_getopt ("-data-read-memory-bytes", argc
, argv
, opts
,
1442 switch ((enum opt
) opt
)
1445 offset
= atol (oarg
);
1453 error (_("Usage: [ -o OFFSET ] ADDR LENGTH."));
1455 addr
= parse_and_eval_address (argv
[0]) + offset
;
1456 length
= atol (argv
[1]);
1458 std::vector
<memory_read_result
> result
1459 = read_memory_robust (current_inferior ()->top_target (), addr
, length
);
1461 if (result
.size () == 0)
1462 error (_("Unable to read memory."));
1464 ui_out_emit_list
list_emitter (uiout
, "memory");
1465 for (const memory_read_result
&read_result
: result
)
1467 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1469 uiout
->field_core_addr ("begin", gdbarch
, read_result
.begin
);
1470 uiout
->field_core_addr ("offset", gdbarch
, read_result
.begin
- addr
);
1471 uiout
->field_core_addr ("end", gdbarch
, read_result
.end
);
1473 std::string data
= bin2hex (read_result
.data
.get (),
1474 (read_result
.end
- read_result
.begin
)
1476 uiout
->field_string ("contents", data
);
1480 /* Implementation of the -data-write_memory command.
1482 COLUMN_OFFSET: optional argument. Must be preceded by '-o'. The
1483 offset from the beginning of the memory grid row where the cell to
1485 ADDR: start address of the row in the memory grid where the memory
1486 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
1487 the location to write to.
1488 FORMAT: a char indicating format for the ``word''. See
1490 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
1491 VALUE: value to be written into the memory address.
1493 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
1498 mi_cmd_data_write_memory (const char *command
, char **argv
, int argc
)
1500 struct gdbarch
*gdbarch
= get_current_arch ();
1501 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1504 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
1505 enough when using a compiler other than GCC. */
1514 static const struct mi_opt opts
[] =
1516 {"o", OFFSET_OPT
, 1},
1522 int opt
= mi_getopt ("-data-write-memory", argc
, argv
, opts
,
1527 switch ((enum opt
) opt
)
1530 offset
= atol (oarg
);
1538 error (_("-data-write-memory: Usage: "
1539 "[-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE."));
1541 /* Extract all the arguments. */
1542 /* Start address of the memory dump. */
1543 addr
= parse_and_eval_address (argv
[0]);
1544 /* The size of the memory word. */
1545 word_size
= atol (argv
[2]);
1547 /* Calculate the real address of the write destination. */
1548 addr
+= (offset
* word_size
);
1550 /* Get the value as a number. */
1551 value
= parse_and_eval_address (argv
[3]);
1552 /* Get the value into an array. */
1553 gdb::byte_vector
buffer (word_size
);
1554 store_signed_integer (buffer
.data (), word_size
, byte_order
, value
);
1555 /* Write it down to memory. */
1556 write_memory_with_notification (addr
, buffer
.data (), word_size
);
1559 /* Implementation of the -data-write-memory-bytes command.
1562 DATA: string of bytes to write at that address
1563 COUNT: number of bytes to be filled (decimal integer). */
1566 mi_cmd_data_write_memory_bytes (const char *command
, char **argv
, int argc
)
1570 size_t len_hex
, len_bytes
, len_units
, i
, steps
, remaining_units
;
1571 long int count_units
;
1574 if (argc
!= 2 && argc
!= 3)
1575 error (_("Usage: ADDR DATA [COUNT]."));
1577 addr
= parse_and_eval_address (argv
[0]);
1579 len_hex
= strlen (cdata
);
1580 unit_size
= gdbarch_addressable_memory_unit_size (get_current_arch ());
1582 if (len_hex
% (unit_size
* 2) != 0)
1583 error (_("Hex-encoded '%s' must represent an integral number of "
1584 "addressable memory units."),
1587 len_bytes
= len_hex
/ 2;
1588 len_units
= len_bytes
/ unit_size
;
1591 count_units
= strtoul (argv
[2], NULL
, 10);
1593 count_units
= len_units
;
1595 gdb::byte_vector
databuf (len_bytes
);
1597 for (i
= 0; i
< len_bytes
; ++i
)
1600 if (sscanf (cdata
+ i
* 2, "%02x", &x
) != 1)
1601 error (_("Invalid argument"));
1602 databuf
[i
] = (gdb_byte
) x
;
1605 gdb::byte_vector data
;
1606 if (len_units
< count_units
)
1608 /* Pattern is made of less units than count:
1609 repeat pattern to fill memory. */
1610 data
= gdb::byte_vector (count_units
* unit_size
);
1612 /* Number of times the pattern is entirely repeated. */
1613 steps
= count_units
/ len_units
;
1614 /* Number of remaining addressable memory units. */
1615 remaining_units
= count_units
% len_units
;
1616 for (i
= 0; i
< steps
; i
++)
1617 memcpy (&data
[i
* len_bytes
], &databuf
[0], len_bytes
);
1619 if (remaining_units
> 0)
1620 memcpy (&data
[steps
* len_bytes
], &databuf
[0],
1621 remaining_units
* unit_size
);
1625 /* Pattern is longer than or equal to count:
1626 just copy count addressable memory units. */
1627 data
= std::move (databuf
);
1630 write_memory_with_notification (addr
, data
.data (), count_units
);
1634 mi_cmd_enable_timings (const char *command
, char **argv
, int argc
)
1640 if (strcmp (argv
[0], "yes") == 0)
1642 else if (strcmp (argv
[0], "no") == 0)
1653 error (_("-enable-timings: Usage: %s {yes|no}"), command
);
1657 mi_cmd_list_features (const char *command
, char **argv
, int argc
)
1661 struct ui_out
*uiout
= current_uiout
;
1663 ui_out_emit_list
list_emitter (uiout
, "features");
1664 uiout
->field_string (NULL
, "frozen-varobjs");
1665 uiout
->field_string (NULL
, "pending-breakpoints");
1666 uiout
->field_string (NULL
, "thread-info");
1667 uiout
->field_string (NULL
, "data-read-memory-bytes");
1668 uiout
->field_string (NULL
, "breakpoint-notifications");
1669 uiout
->field_string (NULL
, "ada-task-info");
1670 uiout
->field_string (NULL
, "language-option");
1671 uiout
->field_string (NULL
, "info-gdb-mi-command");
1672 uiout
->field_string (NULL
, "undefined-command-error-code");
1673 uiout
->field_string (NULL
, "exec-run-start-option");
1674 uiout
->field_string (NULL
, "data-disassemble-a-option");
1676 if (ext_lang_initialized_p (get_ext_lang_defn (EXT_LANG_PYTHON
)))
1677 uiout
->field_string (NULL
, "python");
1682 error (_("-list-features should be passed no arguments"));
1686 mi_cmd_list_target_features (const char *command
, char **argv
, int argc
)
1690 struct ui_out
*uiout
= current_uiout
;
1692 ui_out_emit_list
list_emitter (uiout
, "features");
1694 uiout
->field_string (NULL
, "async");
1695 if (target_can_execute_reverse ())
1696 uiout
->field_string (NULL
, "reverse");
1700 error (_("-list-target-features should be passed no arguments"));
1704 mi_cmd_add_inferior (const char *command
, char **argv
, int argc
)
1706 struct inferior
*inf
;
1709 error (_("-add-inferior should be passed no arguments"));
1711 inf
= add_inferior_with_spaces ();
1713 current_uiout
->field_fmt ("inferior", "i%d", inf
->num
);
1717 mi_cmd_remove_inferior (const char *command
, char **argv
, int argc
)
1720 struct inferior
*inf_to_remove
;
1723 error (_("-remove-inferior should be passed a single argument"));
1725 if (sscanf (argv
[0], "i%d", &id
) != 1)
1726 error (_("the thread group id is syntactically invalid"));
1728 inf_to_remove
= find_inferior_id (id
);
1729 if (inf_to_remove
== NULL
)
1730 error (_("the specified thread group does not exist"));
1732 if (inf_to_remove
->pid
!= 0)
1733 error (_("cannot remove an active inferior"));
1735 if (inf_to_remove
== current_inferior ())
1737 struct thread_info
*tp
= 0;
1738 struct inferior
*new_inferior
= NULL
;
1740 for (inferior
*inf
: all_inferiors ())
1742 if (inf
!= inf_to_remove
)
1746 if (new_inferior
== NULL
)
1747 error (_("Cannot remove last inferior"));
1749 set_current_inferior (new_inferior
);
1750 if (new_inferior
->pid
!= 0)
1751 tp
= any_thread_of_inferior (new_inferior
);
1753 switch_to_thread (tp
);
1755 switch_to_no_thread ();
1756 set_current_program_space (new_inferior
->pspace
);
1759 delete_inferior (inf_to_remove
);
1764 /* Execute a command within a safe environment.
1765 Return <0 for error; >=0 for ok.
1767 args->action will tell mi_execute_command what action
1768 to perform after the given command has executed (display/suppress
1769 prompt, display error). */
1772 captured_mi_execute_command (struct ui_out
*uiout
, struct mi_parse
*context
)
1774 struct mi_interp
*mi
= (struct mi_interp
*) command_interp ();
1777 current_command_ts
= context
->cmd_start
;
1779 scoped_restore save_token
= make_scoped_restore (¤t_token
,
1782 running_result_record_printed
= 0;
1784 switch (context
->op
)
1787 /* A MI command was read from the input stream. */
1789 /* FIXME: gdb_???? */
1790 fprintf_unfiltered (mi
->raw_stdout
,
1791 " token=`%s' command=`%s' args=`%s'\n",
1792 context
->token
, context
->command
, context
->args
);
1794 mi_cmd_execute (context
);
1796 /* Print the result if there were no errors.
1798 Remember that on the way out of executing a command, you have
1799 to directly use the mi_interp's uiout, since the command
1800 could have reset the interpreter, in which case the current
1801 uiout will most likely crash in the mi_out_* routines. */
1802 if (!running_result_record_printed
)
1804 fputs_unfiltered (context
->token
, mi
->raw_stdout
);
1805 /* There's no particularly good reason why target-connect results
1806 in not ^done. Should kill ^connected for MI3. */
1807 fputs_unfiltered (strcmp (context
->command
, "target-select") == 0
1808 ? "^connected" : "^done", mi
->raw_stdout
);
1809 mi_out_put (uiout
, mi
->raw_stdout
);
1810 mi_out_rewind (uiout
);
1811 mi_print_timing_maybe (mi
->raw_stdout
);
1812 fputs_unfiltered ("\n", mi
->raw_stdout
);
1815 /* The command does not want anything to be printed. In that
1816 case, the command probably should not have written anything
1817 to uiout, but in case it has written something, discard it. */
1818 mi_out_rewind (uiout
);
1825 /* A CLI command was read from the input stream. */
1826 /* This "feature" will be removed as soon as we have a
1827 complete set of mi commands. */
1828 /* Echo the command on the console. */
1829 fprintf_unfiltered (gdb_stdlog
, "%s\n", context
->command
);
1830 /* Call the "console" interpreter. */
1831 argv
[0] = (char *) INTERP_CONSOLE
;
1832 argv
[1] = context
->command
;
1833 mi_cmd_interpreter_exec ("-interpreter-exec", argv
, 2);
1835 /* If we changed interpreters, DON'T print out anything. */
1836 if (current_interp_named_p (INTERP_MI
)
1837 || current_interp_named_p (INTERP_MI1
)
1838 || current_interp_named_p (INTERP_MI2
)
1839 || current_interp_named_p (INTERP_MI3
))
1841 if (!running_result_record_printed
)
1843 fputs_unfiltered (context
->token
, mi
->raw_stdout
);
1844 fputs_unfiltered ("^done", mi
->raw_stdout
);
1845 mi_out_put (uiout
, mi
->raw_stdout
);
1846 mi_out_rewind (uiout
);
1847 mi_print_timing_maybe (mi
->raw_stdout
);
1848 fputs_unfiltered ("\n", mi
->raw_stdout
);
1851 mi_out_rewind (uiout
);
1858 /* Print a gdb exception to the MI output stream. */
1861 mi_print_exception (const char *token
, const struct gdb_exception
&exception
)
1863 struct mi_interp
*mi
= (struct mi_interp
*) current_interpreter ();
1865 fputs_unfiltered (token
, mi
->raw_stdout
);
1866 fputs_unfiltered ("^error,msg=\"", mi
->raw_stdout
);
1867 if (exception
.message
== NULL
)
1868 fputs_unfiltered ("unknown error", mi
->raw_stdout
);
1870 fputstr_unfiltered (exception
.what (), '"', mi
->raw_stdout
);
1871 fputs_unfiltered ("\"", mi
->raw_stdout
);
1873 switch (exception
.error
)
1875 case UNDEFINED_COMMAND_ERROR
:
1876 fputs_unfiltered (",code=\"undefined-command\"", mi
->raw_stdout
);
1880 fputs_unfiltered ("\n", mi
->raw_stdout
);
1883 /* Determine whether the parsed command already notifies the
1884 user_selected_context_changed observer. */
1887 command_notifies_uscc_observer (struct mi_parse
*command
)
1889 if (command
->op
== CLI_COMMAND
)
1891 /* CLI commands "thread" and "inferior" already send it. */
1892 return (startswith (command
->command
, "thread ")
1893 || startswith (command
->command
, "inferior "));
1895 else /* MI_COMMAND */
1897 if (strcmp (command
->command
, "interpreter-exec") == 0
1898 && command
->argc
> 1)
1900 /* "thread" and "inferior" again, but through -interpreter-exec. */
1901 return (startswith (command
->argv
[1], "thread ")
1902 || startswith (command
->argv
[1], "inferior "));
1906 /* -thread-select already sends it. */
1907 return strcmp (command
->command
, "thread-select") == 0;
1912 mi_execute_command (const char *cmd
, int from_tty
)
1915 std::unique_ptr
<struct mi_parse
> command
;
1917 /* This is to handle EOF (^D). We just quit gdb. */
1918 /* FIXME: we should call some API function here. */
1920 quit_force (NULL
, from_tty
);
1922 target_log_command (cmd
);
1926 command
= mi_parse (cmd
, &token
);
1928 catch (const gdb_exception
&exception
)
1930 mi_print_exception (token
, exception
);
1934 if (command
!= NULL
)
1936 ptid_t previous_ptid
= inferior_ptid
;
1938 gdb::optional
<scoped_restore_tmpl
<int>> restore_suppress
;
1940 if (command
->cmd
!= NULL
&& command
->cmd
->suppress_notification
!= NULL
)
1941 restore_suppress
.emplace (command
->cmd
->suppress_notification
, 1);
1943 command
->token
= token
;
1947 command
->cmd_start
= new mi_timestamp ();
1948 timestamp (command
->cmd_start
);
1953 captured_mi_execute_command (current_uiout
, command
.get ());
1955 catch (const gdb_exception
&result
)
1957 /* Like in start_event_loop, enable input and force display
1958 of the prompt. Otherwise, any command that calls
1959 async_disable_stdin, and then throws, will leave input
1961 async_enable_stdin ();
1962 current_ui
->prompt_state
= PROMPT_NEEDED
;
1964 /* The command execution failed and error() was called
1966 mi_print_exception (command
->token
, result
);
1967 mi_out_rewind (current_uiout
);
1970 bpstat_do_actions ();
1972 if (/* The notifications are only output when the top-level
1973 interpreter (specified on the command line) is MI. */
1974 top_level_interpreter ()->interp_ui_out ()->is_mi_like_p ()
1975 /* Don't try report anything if there are no threads --
1976 the program is dead. */
1978 /* If the command already reports the thread change, no need to do it
1980 && !command_notifies_uscc_observer (command
.get ()))
1982 int report_change
= 0;
1984 if (command
->thread
== -1)
1986 report_change
= (previous_ptid
!= null_ptid
1987 && inferior_ptid
!= previous_ptid
1988 && inferior_ptid
!= null_ptid
);
1990 else if (inferior_ptid
!= null_ptid
)
1992 struct thread_info
*ti
= inferior_thread ();
1994 report_change
= (ti
->global_num
!= command
->thread
);
1999 gdb::observers::user_selected_context_changed
.notify
2000 (USER_SELECTED_THREAD
| USER_SELECTED_FRAME
);
2007 mi_cmd_execute (struct mi_parse
*parse
)
2009 scoped_value_mark cleanup
= prepare_execute_command ();
2011 if (parse
->all
&& parse
->thread_group
!= -1)
2012 error (_("Cannot specify --thread-group together with --all"));
2014 if (parse
->all
&& parse
->thread
!= -1)
2015 error (_("Cannot specify --thread together with --all"));
2017 if (parse
->thread_group
!= -1 && parse
->thread
!= -1)
2018 error (_("Cannot specify --thread together with --thread-group"));
2020 if (parse
->frame
!= -1 && parse
->thread
== -1)
2021 error (_("Cannot specify --frame without --thread"));
2023 if (parse
->thread_group
!= -1)
2025 struct inferior
*inf
= find_inferior_id (parse
->thread_group
);
2026 struct thread_info
*tp
= 0;
2029 error (_("Invalid thread group for the --thread-group option"));
2031 set_current_inferior (inf
);
2032 /* This behaviour means that if --thread-group option identifies
2033 an inferior with multiple threads, then a random one will be
2034 picked. This is not a problem -- frontend should always
2035 provide --thread if it wishes to operate on a specific
2038 tp
= any_live_thread_of_inferior (inf
);
2040 switch_to_thread (tp
);
2042 switch_to_no_thread ();
2043 set_current_program_space (inf
->pspace
);
2046 if (parse
->thread
!= -1)
2048 thread_info
*tp
= find_thread_global_id (parse
->thread
);
2051 error (_("Invalid thread id: %d"), parse
->thread
);
2053 if (tp
->state
== THREAD_EXITED
)
2054 error (_("Thread id: %d has terminated"), parse
->thread
);
2056 switch_to_thread (tp
);
2059 if (parse
->frame
!= -1)
2061 struct frame_info
*fid
;
2062 int frame
= parse
->frame
;
2064 fid
= find_relative_frame (get_current_frame (), &frame
);
2066 /* find_relative_frame was successful */
2069 error (_("Invalid frame id: %d"), frame
);
2072 gdb::optional
<scoped_restore_current_language
> lang_saver
;
2073 if (parse
->language
!= language_unknown
)
2075 lang_saver
.emplace ();
2076 set_language (parse
->language
);
2079 current_context
= parse
;
2081 if (parse
->cmd
->argv_func
!= NULL
)
2083 parse
->cmd
->argv_func (parse
->command
, parse
->argv
, parse
->argc
);
2085 else if (parse
->cmd
->cli
.cmd
!= 0)
2087 /* FIXME: DELETE THIS. */
2088 /* The operation is still implemented by a cli command. */
2089 /* Must be a synchronous one. */
2090 mi_execute_cli_command (parse
->cmd
->cli
.cmd
, parse
->cmd
->cli
.args_p
,
2095 /* FIXME: DELETE THIS. */
2098 stb
.puts ("Undefined mi command: ");
2099 stb
.putstr (parse
->command
, '"');
2100 stb
.puts (" (missing implementation)");
2106 /* FIXME: This is just a hack so we can get some extra commands going.
2107 We don't want to channel things through the CLI, but call libgdb directly.
2108 Use only for synchronous commands. */
2111 mi_execute_cli_command (const char *cmd
, int args_p
, const char *args
)
2115 std::string run
= cmd
;
2118 run
= run
+ " " + args
;
2120 /* FIXME: gdb_???? */
2121 fprintf_unfiltered (gdb_stdout
, "cli=%s run=%s\n",
2123 execute_command (run
.c_str (), 0 /* from_tty */ );
2128 mi_execute_async_cli_command (const char *cli_command
, char **argv
, int argc
)
2130 std::string run
= cli_command
;
2133 run
= run
+ " " + *argv
;
2137 execute_command (run
.c_str (), 0 /* from_tty */ );
2141 mi_load_progress (const char *section_name
,
2142 unsigned long sent_so_far
,
2143 unsigned long total_section
,
2144 unsigned long total_sent
,
2145 unsigned long grand_total
)
2147 using namespace std::chrono
;
2148 static steady_clock::time_point last_update
;
2149 static char *previous_sect_name
= NULL
;
2151 struct mi_interp
*mi
= (struct mi_interp
*) current_interpreter ();
2153 /* This function is called through deprecated_show_load_progress
2154 which means uiout may not be correct. Fix it for the duration
2155 of this function. */
2157 std::unique_ptr
<ui_out
> uiout (mi_out_new (current_interpreter ()->name ()));
2158 if (uiout
== nullptr)
2161 scoped_restore save_uiout
2162 = make_scoped_restore (¤t_uiout
, uiout
.get ());
2164 new_section
= (previous_sect_name
?
2165 strcmp (previous_sect_name
, section_name
) : 1);
2168 xfree (previous_sect_name
);
2169 previous_sect_name
= xstrdup (section_name
);
2172 fputs_unfiltered (current_token
, mi
->raw_stdout
);
2173 fputs_unfiltered ("+download", mi
->raw_stdout
);
2175 ui_out_emit_tuple
tuple_emitter (uiout
.get (), NULL
);
2176 uiout
->field_string ("section", section_name
);
2177 uiout
->field_signed ("section-size", total_section
);
2178 uiout
->field_signed ("total-size", grand_total
);
2180 mi_out_put (uiout
.get (), mi
->raw_stdout
);
2181 fputs_unfiltered ("\n", mi
->raw_stdout
);
2182 gdb_flush (mi
->raw_stdout
);
2185 steady_clock::time_point time_now
= steady_clock::now ();
2186 if (time_now
- last_update
> milliseconds (500))
2188 last_update
= time_now
;
2190 fputs_unfiltered (current_token
, mi
->raw_stdout
);
2191 fputs_unfiltered ("+download", mi
->raw_stdout
);
2193 ui_out_emit_tuple
tuple_emitter (uiout
.get (), NULL
);
2194 uiout
->field_string ("section", section_name
);
2195 uiout
->field_signed ("section-sent", sent_so_far
);
2196 uiout
->field_signed ("section-size", total_section
);
2197 uiout
->field_signed ("total-sent", total_sent
);
2198 uiout
->field_signed ("total-size", grand_total
);
2200 mi_out_put (uiout
.get (), mi
->raw_stdout
);
2201 fputs_unfiltered ("\n", mi
->raw_stdout
);
2202 gdb_flush (mi
->raw_stdout
);
2207 timestamp (struct mi_timestamp
*tv
)
2209 using namespace std::chrono
;
2211 tv
->wallclock
= steady_clock::now ();
2212 run_time_clock::now (tv
->utime
, tv
->stime
);
2216 print_diff_now (struct ui_file
*file
, struct mi_timestamp
*start
)
2218 struct mi_timestamp now
;
2221 print_diff (file
, start
, &now
);
2225 mi_print_timing_maybe (struct ui_file
*file
)
2227 /* If the command is -enable-timing then do_timings may be true
2228 whilst current_command_ts is not initialized. */
2229 if (do_timings
&& current_command_ts
)
2230 print_diff_now (file
, current_command_ts
);
2234 print_diff (struct ui_file
*file
, struct mi_timestamp
*start
,
2235 struct mi_timestamp
*end
)
2237 using namespace std::chrono
;
2239 duration
<double> wallclock
= end
->wallclock
- start
->wallclock
;
2240 duration
<double> utime
= end
->utime
- start
->utime
;
2241 duration
<double> stime
= end
->stime
- start
->stime
;
2245 ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
2246 wallclock
.count (), utime
.count (), stime
.count ());
2250 mi_cmd_trace_define_variable (const char *command
, char **argv
, int argc
)
2252 LONGEST initval
= 0;
2253 struct trace_state_variable
*tsv
;
2256 if (argc
!= 1 && argc
!= 2)
2257 error (_("Usage: -trace-define-variable VARIABLE [VALUE]"));
2261 error (_("Name of trace variable should start with '$'"));
2263 validate_trace_state_variable_name (name
);
2265 tsv
= find_trace_state_variable (name
);
2267 tsv
= create_trace_state_variable (name
);
2270 initval
= value_as_long (parse_and_eval (argv
[1]));
2272 tsv
->initial_value
= initval
;
2276 mi_cmd_trace_list_variables (const char *command
, char **argv
, int argc
)
2279 error (_("-trace-list-variables: no arguments allowed"));
2281 tvariables_info_1 ();
2285 mi_cmd_trace_find (const char *command
, char **argv
, int argc
)
2290 error (_("trace selection mode is required"));
2294 if (strcmp (mode
, "none") == 0)
2296 tfind_1 (tfind_number
, -1, 0, 0, 0);
2300 check_trace_running (current_trace_status ());
2302 if (strcmp (mode
, "frame-number") == 0)
2305 error (_("frame number is required"));
2306 tfind_1 (tfind_number
, atoi (argv
[1]), 0, 0, 0);
2308 else if (strcmp (mode
, "tracepoint-number") == 0)
2311 error (_("tracepoint number is required"));
2312 tfind_1 (tfind_tp
, atoi (argv
[1]), 0, 0, 0);
2314 else if (strcmp (mode
, "pc") == 0)
2317 error (_("PC is required"));
2318 tfind_1 (tfind_pc
, 0, parse_and_eval_address (argv
[1]), 0, 0);
2320 else if (strcmp (mode
, "pc-inside-range") == 0)
2323 error (_("Start and end PC are required"));
2324 tfind_1 (tfind_range
, 0, parse_and_eval_address (argv
[1]),
2325 parse_and_eval_address (argv
[2]), 0);
2327 else if (strcmp (mode
, "pc-outside-range") == 0)
2330 error (_("Start and end PC are required"));
2331 tfind_1 (tfind_outside
, 0, parse_and_eval_address (argv
[1]),
2332 parse_and_eval_address (argv
[2]), 0);
2334 else if (strcmp (mode
, "line") == 0)
2337 error (_("Line is required"));
2339 std::vector
<symtab_and_line
> sals
2340 = decode_line_with_current_source (argv
[1],
2341 DECODE_LINE_FUNFIRSTLINE
);
2342 const symtab_and_line
&sal
= sals
[0];
2344 if (sal
.symtab
== 0)
2345 error (_("Could not find the specified line"));
2347 CORE_ADDR start_pc
, end_pc
;
2348 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2349 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, 0);
2351 error (_("Could not find the specified line"));
2354 error (_("Invalid mode '%s'"), mode
);
2356 if (has_stack_frames () || get_traceframe_number () >= 0)
2357 print_stack_frame (get_selected_frame (NULL
), 1, LOC_AND_ADDRESS
, 1);
2361 mi_cmd_trace_save (const char *command
, char **argv
, int argc
)
2363 int target_saves
= 0;
2364 int generate_ctf
= 0;
2371 TARGET_SAVE_OPT
, CTF_OPT
2373 static const struct mi_opt opts
[] =
2375 {"r", TARGET_SAVE_OPT
, 0},
2376 {"ctf", CTF_OPT
, 0},
2382 int opt
= mi_getopt ("-trace-save", argc
, argv
, opts
,
2387 switch ((enum opt
) opt
)
2389 case TARGET_SAVE_OPT
:
2398 if (argc
- oind
!= 1)
2399 error (_("Exactly one argument required "
2400 "(file in which to save trace data)"));
2402 filename
= argv
[oind
];
2405 trace_save_ctf (filename
, target_saves
);
2407 trace_save_tfile (filename
, target_saves
);
2411 mi_cmd_trace_start (const char *command
, char **argv
, int argc
)
2413 start_tracing (NULL
);
2417 mi_cmd_trace_status (const char *command
, char **argv
, int argc
)
2419 trace_status_mi (0);
2423 mi_cmd_trace_stop (const char *command
, char **argv
, int argc
)
2425 stop_tracing (NULL
);
2426 trace_status_mi (1);
2429 /* Implement the "-ada-task-info" command. */
2432 mi_cmd_ada_task_info (const char *command
, char **argv
, int argc
)
2434 if (argc
!= 0 && argc
!= 1)
2435 error (_("Invalid MI command"));
2437 print_ada_task_info (current_uiout
, argv
[0], current_inferior ());
2440 /* Print EXPRESSION according to VALUES. */
2443 print_variable_or_computed (const char *expression
, enum print_values values
)
2447 struct ui_out
*uiout
= current_uiout
;
2451 expression_up expr
= parse_expression (expression
);
2453 if (values
== PRINT_SIMPLE_VALUES
)
2454 val
= evaluate_type (expr
.get ());
2456 val
= evaluate_expression (expr
.get ());
2458 gdb::optional
<ui_out_emit_tuple
> tuple_emitter
;
2459 if (values
!= PRINT_NO_VALUES
)
2460 tuple_emitter
.emplace (uiout
, nullptr);
2461 uiout
->field_string ("name", expression
);
2465 case PRINT_SIMPLE_VALUES
:
2466 type
= check_typedef (value_type (val
));
2467 type_print (value_type (val
), "", &stb
, -1);
2468 uiout
->field_stream ("type", stb
);
2469 if (type
->code () != TYPE_CODE_ARRAY
2470 && type
->code () != TYPE_CODE_STRUCT
2471 && type
->code () != TYPE_CODE_UNION
)
2473 struct value_print_options opts
;
2475 get_no_prettyformat_print_options (&opts
);
2477 common_val_print (val
, &stb
, 0, &opts
, current_language
);
2478 uiout
->field_stream ("value", stb
);
2481 case PRINT_ALL_VALUES
:
2483 struct value_print_options opts
;
2485 get_no_prettyformat_print_options (&opts
);
2487 common_val_print (val
, &stb
, 0, &opts
, current_language
);
2488 uiout
->field_stream ("value", stb
);
2494 /* Implement the "-trace-frame-collected" command. */
2497 mi_cmd_trace_frame_collected (const char *command
, char **argv
, int argc
)
2499 struct bp_location
*tloc
;
2501 struct collection_list
*clist
;
2502 struct collection_list tracepoint_list
, stepping_list
;
2503 struct traceframe_info
*tinfo
;
2505 enum print_values var_print_values
= PRINT_ALL_VALUES
;
2506 enum print_values comp_print_values
= PRINT_ALL_VALUES
;
2507 int registers_format
= 'x';
2508 int memory_contents
= 0;
2509 struct ui_out
*uiout
= current_uiout
;
2517 static const struct mi_opt opts
[] =
2519 {"-var-print-values", VAR_PRINT_VALUES
, 1},
2520 {"-comp-print-values", COMP_PRINT_VALUES
, 1},
2521 {"-registers-format", REGISTERS_FORMAT
, 1},
2522 {"-memory-contents", MEMORY_CONTENTS
, 0},
2529 int opt
= mi_getopt ("-trace-frame-collected", argc
, argv
, opts
,
2533 switch ((enum opt
) opt
)
2535 case VAR_PRINT_VALUES
:
2536 var_print_values
= mi_parse_print_values (oarg
);
2538 case COMP_PRINT_VALUES
:
2539 comp_print_values
= mi_parse_print_values (oarg
);
2541 case REGISTERS_FORMAT
:
2542 registers_format
= oarg
[0];
2544 case MEMORY_CONTENTS
:
2545 memory_contents
= 1;
2551 error (_("Usage: -trace-frame-collected "
2552 "[--var-print-values PRINT_VALUES] "
2553 "[--comp-print-values PRINT_VALUES] "
2554 "[--registers-format FORMAT]"
2555 "[--memory-contents]"));
2557 /* This throws an error is not inspecting a trace frame. */
2558 tloc
= get_traceframe_location (&stepping_frame
);
2560 /* This command only makes sense for the current frame, not the
2562 scoped_restore_current_thread restore_thread
;
2563 select_frame (get_current_frame ());
2565 encode_actions (tloc
, &tracepoint_list
, &stepping_list
);
2568 clist
= &stepping_list
;
2570 clist
= &tracepoint_list
;
2572 tinfo
= get_traceframe_info ();
2574 /* Explicitly wholly collected variables. */
2576 ui_out_emit_list
list_emitter (uiout
, "explicit-variables");
2577 const std::vector
<std::string
> &wholly_collected
2578 = clist
->wholly_collected ();
2579 for (size_t i
= 0; i
< wholly_collected
.size (); i
++)
2581 const std::string
&str
= wholly_collected
[i
];
2582 print_variable_or_computed (str
.c_str (), var_print_values
);
2586 /* Computed expressions. */
2588 ui_out_emit_list
list_emitter (uiout
, "computed-expressions");
2590 const std::vector
<std::string
> &computed
= clist
->computed ();
2591 for (size_t i
= 0; i
< computed
.size (); i
++)
2593 const std::string
&str
= computed
[i
];
2594 print_variable_or_computed (str
.c_str (), comp_print_values
);
2598 /* Registers. Given pseudo-registers, and that some architectures
2599 (like MIPS) actually hide the raw registers, we don't go through
2600 the trace frame info, but instead consult the register cache for
2601 register availability. */
2603 struct frame_info
*frame
;
2604 struct gdbarch
*gdbarch
;
2608 ui_out_emit_list
list_emitter (uiout
, "registers");
2610 frame
= get_selected_frame (NULL
);
2611 gdbarch
= get_frame_arch (frame
);
2612 numregs
= gdbarch_num_cooked_regs (gdbarch
);
2614 for (regnum
= 0; regnum
< numregs
; regnum
++)
2616 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
2617 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
2620 output_register (frame
, regnum
, registers_format
, 1);
2624 /* Trace state variables. */
2626 ui_out_emit_list
list_emitter (uiout
, "tvars");
2628 for (int tvar
: tinfo
->tvars
)
2630 struct trace_state_variable
*tsv
;
2632 tsv
= find_trace_state_variable_by_number (tvar
);
2634 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
2638 uiout
->field_fmt ("name", "$%s", tsv
->name
.c_str ());
2640 tsv
->value_known
= target_get_trace_state_variable_value (tsv
->number
,
2642 uiout
->field_signed ("current", tsv
->value
);
2646 uiout
->field_skip ("name");
2647 uiout
->field_skip ("current");
2654 std::vector
<mem_range
> available_memory
;
2656 traceframe_available_memory (&available_memory
, 0, ULONGEST_MAX
);
2658 ui_out_emit_list
list_emitter (uiout
, "memory");
2660 for (const mem_range
&r
: available_memory
)
2662 struct gdbarch
*gdbarch
= target_gdbarch ();
2664 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
2666 uiout
->field_core_addr ("address", gdbarch
, r
.start
);
2667 uiout
->field_signed ("length", r
.length
);
2669 gdb::byte_vector
data (r
.length
);
2671 if (memory_contents
)
2673 if (target_read_memory (r
.start
, data
.data (), r
.length
) == 0)
2675 std::string data_str
= bin2hex (data
.data (), r
.length
);
2676 uiout
->field_string ("contents", data_str
);
2679 uiout
->field_skip ("contents");
2685 /* See mi/mi-main.h. */
2688 mi_cmd_fix_multi_location_breakpoint_output (const char *command
, char **argv
,
2691 fix_multi_location_breakpoint_output_globally
= true;
2694 /* Implement the "-complete" command. */
2697 mi_cmd_complete (const char *command
, char **argv
, int argc
)
2700 error (_("Usage: -complete COMMAND"));
2702 if (max_completions
== 0)
2703 error (_("max-completions is zero, completion is disabled."));
2705 int quote_char
= '\0';
2708 completion_result result
= complete (argv
[0], &word
, "e_char
);
2710 std::string
arg_prefix (argv
[0], word
- argv
[0]);
2712 struct ui_out
*uiout
= current_uiout
;
2714 if (result
.number_matches
> 0)
2715 uiout
->field_fmt ("completion", "%s%s",
2716 arg_prefix
.c_str (),result
.match_list
[0]);
2719 ui_out_emit_list
completions_emitter (uiout
, "matches");
2721 if (result
.number_matches
== 1)
2722 uiout
->field_fmt (NULL
, "%s%s",
2723 arg_prefix
.c_str (), result
.match_list
[0]);
2726 result
.sort_match_list ();
2727 for (size_t i
= 0; i
< result
.number_matches
; i
++)
2729 uiout
->field_fmt (NULL
, "%s%s",
2730 arg_prefix
.c_str (), result
.match_list
[i
+ 1]);
2734 uiout
->field_string ("max_completions_reached",
2735 result
.number_matches
== max_completions
? "1" : "0");
2739 void _initialize_mi_main ();
2741 _initialize_mi_main ()
2743 set_show_commands mi_async_cmds
2744 = add_setshow_boolean_cmd ("mi-async", class_run
,
2746 Set whether MI asynchronous mode is enabled."), _("\
2747 Show whether MI asynchronous mode is enabled."), _("\
2748 Tells GDB whether MI should be in asynchronous mode."),
2749 set_mi_async_command
,
2750 show_mi_async_command
,
2751 &setlist
, &showlist
);
2753 /* Alias old "target-async" to "mi-async". */
2754 cmd_list_element
*set_target_async_cmd
2755 = add_alias_cmd ("target-async", mi_async_cmds
.set
, class_run
, 0, &setlist
);
2756 deprecate_cmd (set_target_async_cmd
, "set mi-async");
2758 cmd_list_element
*show_target_async_cmd
2759 = add_alias_cmd ("target-async", mi_async_cmds
.show
, class_run
, 0,
2761 deprecate_cmd (show_target_async_cmd
, "show mi-async");