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 ());
271 /* In non-stop mode, 'resume' always resumes a single thread.
272 Therefore, to resume all threads of the current inferior, or
273 all threads in all inferiors, we need to iterate over
276 See comment on infcmd.c:proceed_thread_callback for rationale. */
277 if (current_context
->all
|| current_context
->thread_group
!= -1)
279 scoped_restore_current_thread restore_thread
;
282 if (!current_context
->all
)
285 = find_inferior_id (current_context
->thread_group
);
289 iterate_over_threads (proceed_thread_callback
, &pid
);
298 scoped_restore save_multi
= make_scoped_restore (&sched_multi
);
300 if (current_context
->all
)
307 /* In all-stop mode, -exec-continue traditionally resumed
308 either all threads, or one thread, depending on the
309 'scheduler-locking' variable. Let's continue to do the
317 exec_reverse_continue (char **argv
, int argc
)
319 enum exec_direction_kind dir
= execution_direction
;
321 if (dir
== EXEC_REVERSE
)
322 error (_("Already in reverse mode."));
324 if (!target_can_execute_reverse ())
325 error (_("Target %s does not support this command."), target_shortname ());
327 scoped_restore save_exec_dir
= make_scoped_restore (&execution_direction
,
329 exec_continue (argv
, argc
);
333 mi_cmd_exec_continue (const char *command
, char **argv
, int argc
)
335 if (argc
> 0 && strcmp (argv
[0], "--reverse") == 0)
336 exec_reverse_continue (argv
+ 1, argc
- 1);
338 exec_continue (argv
, argc
);
342 interrupt_thread_callback (struct thread_info
*thread
, void *arg
)
344 int pid
= *(int *)arg
;
346 if (thread
->state
!= THREAD_RUNNING
)
349 if (thread
->ptid
.pid () != pid
)
352 target_stop (thread
->ptid
);
356 /* Interrupt the execution of the target. Note how we must play
357 around with the token variables, in order to display the current
358 token in the result of the interrupt command, and the previous
359 execution token when the target finally stops. See comments in
363 mi_cmd_exec_interrupt (const char *command
, char **argv
, int argc
)
365 /* In all-stop mode, everything stops, so we don't need to try
366 anything specific. */
369 interrupt_target_1 (0);
373 if (current_context
->all
)
375 /* This will interrupt all threads in all inferiors. */
376 interrupt_target_1 (1);
378 else if (current_context
->thread_group
!= -1)
380 struct inferior
*inf
= find_inferior_id (current_context
->thread_group
);
382 iterate_over_threads (interrupt_thread_callback
, &inf
->pid
);
386 /* Interrupt just the current thread -- either explicitly
387 specified via --thread or whatever was current before
388 MI command was sent. */
389 interrupt_target_1 (0);
393 /* Start the execution of the given inferior.
395 START_P indicates whether the program should be stopped when reaching the
396 main subprogram (similar to what the CLI "start" command does). */
399 run_one_inferior (inferior
*inf
, bool start_p
)
401 const char *run_cmd
= start_p
? "start" : "run";
402 struct target_ops
*run_target
= find_run_target ();
403 int async_p
= mi_async
&& run_target
->can_async_p ();
407 thread_info
*tp
= any_thread_of_inferior (inf
);
409 error (_("Inferior has no threads."));
411 switch_to_thread (tp
);
414 switch_to_inferior_no_thread (inf
);
415 mi_execute_cli_command (run_cmd
, async_p
,
416 async_p
? "&" : NULL
);
420 mi_cmd_exec_run (const char *command
, char **argv
, int argc
)
424 /* Parse the command options. */
429 static const struct mi_opt opts
[] =
431 {"-start", START_OPT
, 0},
440 int opt
= mi_getopt ("-exec-run", argc
, argv
, opts
, &oind
, &oarg
);
444 switch ((enum opt
) opt
)
452 /* This command does not accept any argument. Make sure the user
453 did not provide any. */
455 error (_("Invalid argument: %s"), argv
[oind
]);
457 if (current_context
->all
)
459 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
461 for (inferior
*inf
: all_inferiors ())
462 run_one_inferior (inf
, start_p
);
466 const char *run_cmd
= start_p
? "start" : "run";
467 struct target_ops
*run_target
= find_run_target ();
468 int async_p
= mi_async
&& run_target
->can_async_p ();
470 mi_execute_cli_command (run_cmd
, async_p
,
471 async_p
? "&" : NULL
);
477 find_thread_of_process (struct thread_info
*ti
, void *p
)
481 if (ti
->ptid
.pid () == pid
&& ti
->state
!= THREAD_EXITED
)
488 mi_cmd_target_detach (const char *command
, char **argv
, int argc
)
490 if (argc
!= 0 && argc
!= 1)
491 error (_("Usage: -target-detach [pid | thread-group]"));
495 struct thread_info
*tp
;
499 /* First see if we are dealing with a thread-group id. */
502 struct inferior
*inf
;
503 int id
= strtoul (argv
[0] + 1, &end
, 0);
506 error (_("Invalid syntax of thread-group id '%s'"), argv
[0]);
508 inf
= find_inferior_id (id
);
510 error (_("Non-existent thread-group id '%d'"), id
);
516 /* We must be dealing with a pid. */
517 pid
= strtol (argv
[0], &end
, 10);
520 error (_("Invalid identifier '%s'"), argv
[0]);
523 /* Pick any thread in the desired process. Current
524 target_detach detaches from the parent of inferior_ptid. */
525 tp
= iterate_over_threads (find_thread_of_process
, &pid
);
527 error (_("Thread group is empty"));
529 switch_to_thread (tp
);
532 detach_command (NULL
, 0);
536 mi_cmd_target_flash_erase (const char *command
, char **argv
, int argc
)
538 flash_erase_command (NULL
, 0);
542 mi_cmd_thread_select (const char *command
, char **argv
, int argc
)
545 error (_("-thread-select: USAGE: threadnum."));
547 int num
= value_as_long (parse_and_eval (argv
[0]));
548 thread_info
*thr
= find_thread_global_id (num
);
550 error (_("Thread ID %d not known."), num
);
552 ptid_t previous_ptid
= inferior_ptid
;
554 thread_select (argv
[0], thr
);
556 print_selected_thread_frame (current_uiout
,
557 USER_SELECTED_THREAD
| USER_SELECTED_FRAME
);
559 /* Notify if the thread has effectively changed. */
560 if (inferior_ptid
!= previous_ptid
)
562 gdb::observers::user_selected_context_changed
.notify
563 (USER_SELECTED_THREAD
| USER_SELECTED_FRAME
);
568 mi_cmd_thread_list_ids (const char *command
, char **argv
, int argc
)
571 error (_("-thread-list-ids: No arguments required."));
574 int current_thread
= -1;
576 update_thread_list ();
579 ui_out_emit_tuple
tuple_emitter (current_uiout
, "thread-ids");
581 for (thread_info
*tp
: all_non_exited_threads ())
583 if (tp
->ptid
== inferior_ptid
)
584 current_thread
= tp
->global_num
;
587 current_uiout
->field_signed ("thread-id", tp
->global_num
);
591 if (current_thread
!= -1)
592 current_uiout
->field_signed ("current-thread-id", current_thread
);
593 current_uiout
->field_signed ("number-of-threads", num
);
597 mi_cmd_thread_info (const char *command
, char **argv
, int argc
)
599 if (argc
!= 0 && argc
!= 1)
600 error (_("Invalid MI command"));
602 print_thread_info (current_uiout
, argv
[0], -1);
605 struct collect_cores_data
612 collect_cores (struct thread_info
*ti
, void *xdata
)
614 struct collect_cores_data
*data
= (struct collect_cores_data
*) xdata
;
616 if (ti
->ptid
.pid () == data
->pid
)
618 int core
= target_core_of_thread (ti
->ptid
);
621 data
->cores
.insert (core
);
627 struct print_one_inferior_data
630 const std::set
<int> *inferiors
;
634 print_one_inferior (struct inferior
*inferior
, bool recurse
,
635 const std::set
<int> &ids
)
637 struct ui_out
*uiout
= current_uiout
;
639 if (ids
.empty () || (ids
.find (inferior
->pid
) != ids
.end ()))
641 struct collect_cores_data data
;
642 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
644 uiout
->field_fmt ("id", "i%d", inferior
->num
);
645 uiout
->field_string ("type", "process");
646 if (inferior
->has_exit_code
)
647 uiout
->field_string ("exit-code",
648 int_string (inferior
->exit_code
, 8, 0, 0, 1));
649 if (inferior
->pid
!= 0)
650 uiout
->field_signed ("pid", inferior
->pid
);
652 if (inferior
->pspace
->exec_filename
!= nullptr)
654 uiout
->field_string ("executable",
655 inferior
->pspace
->exec_filename
.get ());
658 if (inferior
->pid
!= 0)
660 data
.pid
= inferior
->pid
;
661 iterate_over_threads (collect_cores
, &data
);
664 if (!data
.cores
.empty ())
666 ui_out_emit_list
list_emitter (uiout
, "cores");
668 for (int b
: data
.cores
)
669 uiout
->field_signed (NULL
, b
);
673 print_thread_info (uiout
, NULL
, inferior
->pid
);
677 /* Output a field named 'cores' with a list as the value. The
678 elements of the list are obtained by splitting 'cores' on
682 output_cores (struct ui_out
*uiout
, const char *field_name
, const char *xcores
)
684 ui_out_emit_list
list_emitter (uiout
, field_name
);
685 auto cores
= make_unique_xstrdup (xcores
);
686 char *p
= cores
.get ();
689 for (p
= strtok_r (p
, ",", &saveptr
); p
; p
= strtok_r (NULL
, ",", &saveptr
))
690 uiout
->field_string (NULL
, p
);
694 list_available_thread_groups (const std::set
<int> &ids
, int recurse
)
696 struct ui_out
*uiout
= current_uiout
;
698 /* This keeps a map from integer (pid) to vector of struct osdata_item.
699 The vector contains information about all threads for the given pid. */
700 std::map
<int, std::vector
<osdata_item
>> tree
;
702 /* get_osdata will throw if it cannot return data. */
703 std::unique_ptr
<osdata
> data
= get_osdata ("processes");
707 std::unique_ptr
<osdata
> threads
= get_osdata ("threads");
709 for (const osdata_item
&item
: threads
->items
)
711 const std::string
*pid
= get_osdata_column (item
, "pid");
712 int pid_i
= strtoul (pid
->c_str (), NULL
, 0);
714 tree
[pid_i
].push_back (item
);
718 ui_out_emit_list
list_emitter (uiout
, "groups");
720 for (const osdata_item
&item
: data
->items
)
722 const std::string
*pid
= get_osdata_column (item
, "pid");
723 const std::string
*cmd
= get_osdata_column (item
, "command");
724 const std::string
*user
= get_osdata_column (item
, "user");
725 const std::string
*cores
= get_osdata_column (item
, "cores");
727 int pid_i
= strtoul (pid
->c_str (), NULL
, 0);
729 /* At present, the target will return all available processes
730 and if information about specific ones was required, we filter
731 undesired processes here. */
732 if (!ids
.empty () && ids
.find (pid_i
) == ids
.end ())
735 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
737 uiout
->field_string ("id", pid
->c_str ());
738 uiout
->field_string ("type", "process");
740 uiout
->field_string ("description", cmd
->c_str ());
742 uiout
->field_string ("user", user
->c_str ());
744 output_cores (uiout
, "cores", cores
->c_str ());
748 auto n
= tree
.find (pid_i
);
749 if (n
!= tree
.end ())
751 std::vector
<osdata_item
> &children
= n
->second
;
753 ui_out_emit_list
thread_list_emitter (uiout
, "threads");
755 for (const osdata_item
&child
: children
)
757 ui_out_emit_tuple
inner_tuple_emitter (uiout
, NULL
);
758 const std::string
*tid
= get_osdata_column (child
, "tid");
759 const std::string
*tcore
= get_osdata_column (child
, "core");
761 uiout
->field_string ("id", tid
->c_str ());
763 uiout
->field_string ("core", tcore
->c_str ());
771 mi_cmd_list_thread_groups (const char *command
, char **argv
, int argc
)
773 struct ui_out
*uiout
= current_uiout
;
780 AVAILABLE_OPT
, RECURSE_OPT
782 static const struct mi_opt opts
[] =
784 {"-available", AVAILABLE_OPT
, 0},
785 {"-recurse", RECURSE_OPT
, 1},
794 int opt
= mi_getopt ("-list-thread-groups", argc
, argv
, opts
,
799 switch ((enum opt
) opt
)
805 if (strcmp (oarg
, "0") == 0)
807 else if (strcmp (oarg
, "1") == 0)
810 error (_("only '0' and '1' are valid values "
811 "for the '--recurse' option"));
816 for (; oind
< argc
; ++oind
)
821 if (*(argv
[oind
]) != 'i')
822 error (_("invalid syntax of group id '%s'"), argv
[oind
]);
824 inf
= strtoul (argv
[oind
] + 1, &end
, 0);
827 error (_("invalid syntax of group id '%s'"), argv
[oind
]);
833 list_available_thread_groups (ids
, recurse
);
835 else if (ids
.size () == 1)
837 /* Local thread groups, single id. */
838 int id
= *(ids
.begin ());
839 struct inferior
*inf
= find_inferior_id (id
);
842 error (_("Non-existent thread group id '%d'"), id
);
844 print_thread_info (uiout
, NULL
, inf
->pid
);
848 /* Local thread groups. Either no explicit ids -- and we
849 print everything, or several explicit ids. In both cases,
850 we print more than one group, and have to use 'groups'
851 as the top-level element. */
852 ui_out_emit_list
list_emitter (uiout
, "groups");
853 update_thread_list ();
854 for (inferior
*inf
: all_inferiors ())
855 print_one_inferior (inf
, recurse
, ids
);
860 mi_cmd_data_list_register_names (const char *command
, char **argv
, int argc
)
862 struct gdbarch
*gdbarch
;
863 struct ui_out
*uiout
= current_uiout
;
867 /* Note that the test for a valid register must include checking the
868 gdbarch_register_name because gdbarch_num_regs may be allocated
869 for the union of the register sets within a family of related
870 processors. In this case, some entries of gdbarch_register_name
871 will change depending upon the particular processor being
874 gdbarch
= get_current_arch ();
875 numregs
= gdbarch_num_cooked_regs (gdbarch
);
877 ui_out_emit_list
list_emitter (uiout
, "register-names");
879 if (argc
== 0) /* No args, just do all the regs. */
885 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
886 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
887 uiout
->field_string (NULL
, "");
889 uiout
->field_string (NULL
, gdbarch_register_name (gdbarch
, regnum
));
893 /* Else, list of register #s, just do listed regs. */
894 for (i
= 0; i
< argc
; i
++)
896 regnum
= atoi (argv
[i
]);
897 if (regnum
< 0 || regnum
>= numregs
)
898 error (_("bad register number"));
900 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
901 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
902 uiout
->field_string (NULL
, "");
904 uiout
->field_string (NULL
, gdbarch_register_name (gdbarch
, regnum
));
909 mi_cmd_data_list_changed_registers (const char *command
, char **argv
, int argc
)
911 static std::unique_ptr
<readonly_detached_regcache
> this_regs
;
912 struct ui_out
*uiout
= current_uiout
;
913 std::unique_ptr
<readonly_detached_regcache
> prev_regs
;
914 struct gdbarch
*gdbarch
;
918 /* The last time we visited this function, the current frame's
919 register contents were saved in THIS_REGS. Move THIS_REGS over
920 to PREV_REGS, and refresh THIS_REGS with the now-current register
923 prev_regs
= std::move (this_regs
);
924 this_regs
= frame_save_as_regcache (get_selected_frame (NULL
));
926 /* Note that the test for a valid register must include checking the
927 gdbarch_register_name because gdbarch_num_regs may be allocated
928 for the union of the register sets within a family of related
929 processors. In this case, some entries of gdbarch_register_name
930 will change depending upon the particular processor being
933 gdbarch
= this_regs
->arch ();
934 numregs
= gdbarch_num_cooked_regs (gdbarch
);
936 ui_out_emit_list
list_emitter (uiout
, "changed-registers");
940 /* No args, just do all the regs. */
945 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
946 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
949 if (register_changed_p (regnum
, prev_regs
.get (),
951 uiout
->field_signed (NULL
, regnum
);
955 /* Else, list of register #s, just do listed regs. */
956 for (i
= 0; i
< argc
; i
++)
958 regnum
= atoi (argv
[i
]);
962 && gdbarch_register_name (gdbarch
, regnum
) != NULL
963 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
965 if (register_changed_p (regnum
, prev_regs
.get (),
967 uiout
->field_signed (NULL
, regnum
);
970 error (_("bad register number"));
975 register_changed_p (int regnum
, readonly_detached_regcache
*prev_regs
,
976 readonly_detached_regcache
*this_regs
)
978 struct gdbarch
*gdbarch
= this_regs
->arch ();
979 struct value
*prev_value
, *this_value
;
981 /* First time through or after gdbarch change consider all registers
983 if (!prev_regs
|| prev_regs
->arch () != gdbarch
)
986 /* Get register contents and compare. */
987 prev_value
= prev_regs
->cooked_read_value (regnum
);
988 this_value
= this_regs
->cooked_read_value (regnum
);
989 gdb_assert (prev_value
!= NULL
);
990 gdb_assert (this_value
!= NULL
);
992 auto ret
= !value_contents_eq (prev_value
, 0, this_value
, 0,
993 register_size (gdbarch
, regnum
));
995 release_value (prev_value
);
996 release_value (this_value
);
1000 /* Return a list of register number and value pairs. The valid
1001 arguments expected are: a letter indicating the format in which to
1002 display the registers contents. This can be one of: x
1003 (hexadecimal), d (decimal), N (natural), t (binary), o (octal), r
1004 (raw). After the format argument there can be a sequence of
1005 numbers, indicating which registers to fetch the content of. If
1006 the format is the only argument, a list of all the registers with
1007 their values is returned. */
1010 mi_cmd_data_list_register_values (const char *command
, char **argv
, int argc
)
1012 struct ui_out
*uiout
= current_uiout
;
1013 struct frame_info
*frame
;
1014 struct gdbarch
*gdbarch
;
1015 int regnum
, numregs
, format
;
1017 int skip_unavailable
= 0;
1023 static const struct mi_opt opts
[] =
1025 {"-skip-unavailable", SKIP_UNAVAILABLE
, 0},
1029 /* Note that the test for a valid register must include checking the
1030 gdbarch_register_name because gdbarch_num_regs may be allocated
1031 for the union of the register sets within a family of related
1032 processors. In this case, some entries of gdbarch_register_name
1033 will change depending upon the particular processor being
1039 int opt
= mi_getopt ("-data-list-register-values", argc
, argv
,
1040 opts
, &oind
, &oarg
);
1044 switch ((enum opt
) opt
)
1046 case SKIP_UNAVAILABLE
:
1047 skip_unavailable
= 1;
1052 if (argc
- oind
< 1)
1053 error (_("-data-list-register-values: Usage: "
1054 "-data-list-register-values [--skip-unavailable] <format>"
1055 " [<regnum1>...<regnumN>]"));
1057 format
= (int) argv
[oind
][0];
1059 frame
= get_selected_frame (NULL
);
1060 gdbarch
= get_frame_arch (frame
);
1061 numregs
= gdbarch_num_cooked_regs (gdbarch
);
1063 ui_out_emit_list
list_emitter (uiout
, "register-values");
1065 if (argc
- oind
== 1)
1067 /* No args, beside the format: do all the regs. */
1072 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1073 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1076 output_register (frame
, regnum
, format
, skip_unavailable
);
1080 /* Else, list of register #s, just do listed regs. */
1081 for (i
= 1 + oind
; i
< argc
; i
++)
1083 regnum
= atoi (argv
[i
]);
1087 && gdbarch_register_name (gdbarch
, regnum
) != NULL
1088 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
1089 output_register (frame
, regnum
, format
, skip_unavailable
);
1091 error (_("bad register number"));
1095 /* Output one register REGNUM's contents in the desired FORMAT. If
1096 SKIP_UNAVAILABLE is true, skip the register if it is
1100 output_register (struct frame_info
*frame
, int regnum
, int format
,
1101 int skip_unavailable
)
1103 struct ui_out
*uiout
= current_uiout
;
1104 struct value
*val
= value_of_register (regnum
, frame
);
1105 struct value_print_options opts
;
1107 if (skip_unavailable
&& !value_entirely_available (val
))
1110 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1111 uiout
->field_signed ("number", regnum
);
1121 get_formatted_print_options (&opts
, format
);
1123 common_val_print (val
, &stb
, 0, &opts
, current_language
);
1124 uiout
->field_stream ("value", stb
);
1127 /* Write given values into registers. The registers and values are
1128 given as pairs. The corresponding MI command is
1129 -data-write-register-values <format>
1130 [<regnum1> <value1>...<regnumN> <valueN>] */
1132 mi_cmd_data_write_register_values (const char *command
, char **argv
, int argc
)
1134 struct regcache
*regcache
;
1135 struct gdbarch
*gdbarch
;
1138 /* Note that the test for a valid register must include checking the
1139 gdbarch_register_name because gdbarch_num_regs may be allocated
1140 for the union of the register sets within a family of related
1141 processors. In this case, some entries of gdbarch_register_name
1142 will change depending upon the particular processor being
1145 regcache
= get_current_regcache ();
1146 gdbarch
= regcache
->arch ();
1147 numregs
= gdbarch_num_cooked_regs (gdbarch
);
1150 error (_("-data-write-register-values: Usage: -data-write-register-"
1151 "values <format> [<regnum1> <value1>...<regnumN> <valueN>]"));
1153 if (!target_has_registers ())
1154 error (_("-data-write-register-values: No registers."));
1157 error (_("-data-write-register-values: No regs and values specified."));
1160 error (_("-data-write-register-values: "
1161 "Regs and vals are not in pairs."));
1163 for (i
= 1; i
< argc
; i
= i
+ 2)
1165 int regnum
= atoi (argv
[i
]);
1167 if (regnum
>= 0 && regnum
< numregs
1168 && gdbarch_register_name (gdbarch
, regnum
)
1169 && *gdbarch_register_name (gdbarch
, regnum
))
1173 /* Get the value as a number. */
1174 value
= parse_and_eval_address (argv
[i
+ 1]);
1176 /* Write it down. */
1177 regcache_cooked_write_signed (regcache
, regnum
, value
);
1180 error (_("bad register number"));
1184 /* Evaluate the value of the argument. The argument is an
1185 expression. If the expression contains spaces it needs to be
1186 included in double quotes. */
1189 mi_cmd_data_evaluate_expression (const char *command
, char **argv
, int argc
)
1192 struct value_print_options opts
;
1193 struct ui_out
*uiout
= current_uiout
;
1196 error (_("-data-evaluate-expression: "
1197 "Usage: -data-evaluate-expression expression"));
1199 expression_up expr
= parse_expression (argv
[0]);
1201 val
= evaluate_expression (expr
.get ());
1205 /* Print the result of the expression evaluation. */
1206 get_user_print_options (&opts
);
1208 common_val_print (val
, &stb
, 0, &opts
, current_language
);
1210 uiout
->field_stream ("value", stb
);
1213 /* This is the -data-read-memory command.
1215 ADDR: start address of data to be dumped.
1216 WORD-FORMAT: a char indicating format for the ``word''. See
1218 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes.
1219 NR_ROW: Number of rows.
1220 NR_COL: The number of columns (words per row).
1221 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
1222 ASCHAR for unprintable characters.
1224 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
1225 displays them. Returns:
1227 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
1230 The number of bytes read is SIZE*ROW*COL. */
1233 mi_cmd_data_read_memory (const char *command
, char **argv
, int argc
)
1235 struct gdbarch
*gdbarch
= get_current_arch ();
1236 struct ui_out
*uiout
= current_uiout
;
1238 long total_bytes
, nr_cols
, nr_rows
;
1240 struct type
*word_type
;
1252 static const struct mi_opt opts
[] =
1254 {"o", OFFSET_OPT
, 1},
1260 int opt
= mi_getopt ("-data-read-memory", argc
, argv
, opts
,
1265 switch ((enum opt
) opt
)
1268 offset
= atol (oarg
);
1275 if (argc
< 5 || argc
> 6)
1276 error (_("-data-read-memory: Usage: "
1277 "ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR]."));
1279 /* Extract all the arguments. */
1281 /* Start address of the memory dump. */
1282 addr
= parse_and_eval_address (argv
[0]) + offset
;
1283 /* The format character to use when displaying a memory word. See
1284 the ``x'' command. */
1285 word_format
= argv
[1][0];
1286 /* The size of the memory word. */
1287 word_size
= atol (argv
[2]);
1291 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1295 word_type
= builtin_type (gdbarch
)->builtin_int16
;
1299 word_type
= builtin_type (gdbarch
)->builtin_int32
;
1303 word_type
= builtin_type (gdbarch
)->builtin_int64
;
1307 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1310 /* The number of rows. */
1311 nr_rows
= atol (argv
[3]);
1313 error (_("-data-read-memory: invalid number of rows."));
1315 /* Number of bytes per row. */
1316 nr_cols
= atol (argv
[4]);
1318 error (_("-data-read-memory: invalid number of columns."));
1320 /* The un-printable character when printing ascii. */
1326 /* Create a buffer and read it in. */
1327 total_bytes
= word_size
* nr_rows
* nr_cols
;
1329 gdb::byte_vector
mbuf (total_bytes
);
1331 nr_bytes
= target_read (current_inferior ()->top_target (),
1332 TARGET_OBJECT_MEMORY
, NULL
,
1333 mbuf
.data (), addr
, total_bytes
);
1335 error (_("Unable to read memory."));
1337 /* Output the header information. */
1338 uiout
->field_core_addr ("addr", gdbarch
, addr
);
1339 uiout
->field_signed ("nr-bytes", nr_bytes
);
1340 uiout
->field_signed ("total-bytes", total_bytes
);
1341 uiout
->field_core_addr ("next-row", gdbarch
, addr
+ word_size
* nr_cols
);
1342 uiout
->field_core_addr ("prev-row", gdbarch
, addr
- word_size
* nr_cols
);
1343 uiout
->field_core_addr ("next-page", gdbarch
, addr
+ total_bytes
);
1344 uiout
->field_core_addr ("prev-page", gdbarch
, addr
- total_bytes
);
1346 /* Build the result as a two dimensional table. */
1353 ui_out_emit_list
list_emitter (uiout
, "memory");
1354 for (row
= 0, row_byte
= 0;
1356 row
++, row_byte
+= nr_cols
* word_size
)
1360 struct value_print_options print_opts
;
1362 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1363 uiout
->field_core_addr ("addr", gdbarch
, addr
+ row_byte
);
1364 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr +
1367 ui_out_emit_list
list_data_emitter (uiout
, "data");
1368 get_formatted_print_options (&print_opts
, word_format
);
1369 for (col
= 0, col_byte
= row_byte
;
1371 col
++, col_byte
+= word_size
)
1373 if (col_byte
+ word_size
> nr_bytes
)
1375 uiout
->field_string (NULL
, "N/A");
1380 print_scalar_formatted (&mbuf
[col_byte
], word_type
,
1381 &print_opts
, word_asize
, &stream
);
1382 uiout
->field_stream (NULL
, stream
);
1392 for (byte
= row_byte
;
1393 byte
< row_byte
+ word_size
* nr_cols
; byte
++)
1395 if (byte
>= nr_bytes
)
1397 else if (mbuf
[byte
] < 32 || mbuf
[byte
] > 126)
1398 stream
.putc (aschar
);
1400 stream
.putc (mbuf
[byte
]);
1402 uiout
->field_stream ("ascii", stream
);
1409 mi_cmd_data_read_memory_bytes (const char *command
, char **argv
, int argc
)
1411 struct gdbarch
*gdbarch
= get_current_arch ();
1412 struct ui_out
*uiout
= current_uiout
;
1416 int unit_size
= gdbarch_addressable_memory_unit_size (gdbarch
);
1423 static const struct mi_opt opts
[] =
1425 {"o", OFFSET_OPT
, 1},
1431 int opt
= mi_getopt ("-data-read-memory-bytes", argc
, argv
, opts
,
1435 switch ((enum opt
) opt
)
1438 offset
= atol (oarg
);
1446 error (_("Usage: [ -o OFFSET ] ADDR LENGTH."));
1448 addr
= parse_and_eval_address (argv
[0]) + offset
;
1449 length
= atol (argv
[1]);
1451 std::vector
<memory_read_result
> result
1452 = read_memory_robust (current_inferior ()->top_target (), addr
, length
);
1454 if (result
.size () == 0)
1455 error (_("Unable to read memory."));
1457 ui_out_emit_list
list_emitter (uiout
, "memory");
1458 for (const memory_read_result
&read_result
: result
)
1460 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1462 uiout
->field_core_addr ("begin", gdbarch
, read_result
.begin
);
1463 uiout
->field_core_addr ("offset", gdbarch
, read_result
.begin
- addr
);
1464 uiout
->field_core_addr ("end", gdbarch
, read_result
.end
);
1466 std::string data
= bin2hex (read_result
.data
.get (),
1467 (read_result
.end
- read_result
.begin
)
1469 uiout
->field_string ("contents", data
.c_str ());
1473 /* Implementation of the -data-write_memory command.
1475 COLUMN_OFFSET: optional argument. Must be preceded by '-o'. The
1476 offset from the beginning of the memory grid row where the cell to
1478 ADDR: start address of the row in the memory grid where the memory
1479 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
1480 the location to write to.
1481 FORMAT: a char indicating format for the ``word''. See
1483 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
1484 VALUE: value to be written into the memory address.
1486 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
1491 mi_cmd_data_write_memory (const char *command
, char **argv
, int argc
)
1493 struct gdbarch
*gdbarch
= get_current_arch ();
1494 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1497 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
1498 enough when using a compiler other than GCC. */
1507 static const struct mi_opt opts
[] =
1509 {"o", OFFSET_OPT
, 1},
1515 int opt
= mi_getopt ("-data-write-memory", argc
, argv
, opts
,
1520 switch ((enum opt
) opt
)
1523 offset
= atol (oarg
);
1531 error (_("-data-write-memory: Usage: "
1532 "[-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE."));
1534 /* Extract all the arguments. */
1535 /* Start address of the memory dump. */
1536 addr
= parse_and_eval_address (argv
[0]);
1537 /* The size of the memory word. */
1538 word_size
= atol (argv
[2]);
1540 /* Calculate the real address of the write destination. */
1541 addr
+= (offset
* word_size
);
1543 /* Get the value as a number. */
1544 value
= parse_and_eval_address (argv
[3]);
1545 /* Get the value into an array. */
1546 gdb::byte_vector
buffer (word_size
);
1547 store_signed_integer (buffer
.data (), word_size
, byte_order
, value
);
1548 /* Write it down to memory. */
1549 write_memory_with_notification (addr
, buffer
.data (), word_size
);
1552 /* Implementation of the -data-write-memory-bytes command.
1555 DATA: string of bytes to write at that address
1556 COUNT: number of bytes to be filled (decimal integer). */
1559 mi_cmd_data_write_memory_bytes (const char *command
, char **argv
, int argc
)
1563 size_t len_hex
, len_bytes
, len_units
, i
, steps
, remaining_units
;
1564 long int count_units
;
1567 if (argc
!= 2 && argc
!= 3)
1568 error (_("Usage: ADDR DATA [COUNT]."));
1570 addr
= parse_and_eval_address (argv
[0]);
1572 len_hex
= strlen (cdata
);
1573 unit_size
= gdbarch_addressable_memory_unit_size (get_current_arch ());
1575 if (len_hex
% (unit_size
* 2) != 0)
1576 error (_("Hex-encoded '%s' must represent an integral number of "
1577 "addressable memory units."),
1580 len_bytes
= len_hex
/ 2;
1581 len_units
= len_bytes
/ unit_size
;
1584 count_units
= strtoul (argv
[2], NULL
, 10);
1586 count_units
= len_units
;
1588 gdb::byte_vector
databuf (len_bytes
);
1590 for (i
= 0; i
< len_bytes
; ++i
)
1593 if (sscanf (cdata
+ i
* 2, "%02x", &x
) != 1)
1594 error (_("Invalid argument"));
1595 databuf
[i
] = (gdb_byte
) x
;
1598 gdb::byte_vector data
;
1599 if (len_units
< count_units
)
1601 /* Pattern is made of less units than count:
1602 repeat pattern to fill memory. */
1603 data
= gdb::byte_vector (count_units
* unit_size
);
1605 /* Number of times the pattern is entirely repeated. */
1606 steps
= count_units
/ len_units
;
1607 /* Number of remaining addressable memory units. */
1608 remaining_units
= count_units
% len_units
;
1609 for (i
= 0; i
< steps
; i
++)
1610 memcpy (&data
[i
* len_bytes
], &databuf
[0], len_bytes
);
1612 if (remaining_units
> 0)
1613 memcpy (&data
[steps
* len_bytes
], &databuf
[0],
1614 remaining_units
* unit_size
);
1618 /* Pattern is longer than or equal to count:
1619 just copy count addressable memory units. */
1620 data
= std::move (databuf
);
1623 write_memory_with_notification (addr
, data
.data (), count_units
);
1627 mi_cmd_enable_timings (const char *command
, char **argv
, int argc
)
1633 if (strcmp (argv
[0], "yes") == 0)
1635 else if (strcmp (argv
[0], "no") == 0)
1646 error (_("-enable-timings: Usage: %s {yes|no}"), command
);
1650 mi_cmd_list_features (const char *command
, char **argv
, int argc
)
1654 struct ui_out
*uiout
= current_uiout
;
1656 ui_out_emit_list
list_emitter (uiout
, "features");
1657 uiout
->field_string (NULL
, "frozen-varobjs");
1658 uiout
->field_string (NULL
, "pending-breakpoints");
1659 uiout
->field_string (NULL
, "thread-info");
1660 uiout
->field_string (NULL
, "data-read-memory-bytes");
1661 uiout
->field_string (NULL
, "breakpoint-notifications");
1662 uiout
->field_string (NULL
, "ada-task-info");
1663 uiout
->field_string (NULL
, "language-option");
1664 uiout
->field_string (NULL
, "info-gdb-mi-command");
1665 uiout
->field_string (NULL
, "undefined-command-error-code");
1666 uiout
->field_string (NULL
, "exec-run-start-option");
1667 uiout
->field_string (NULL
, "data-disassemble-a-option");
1669 if (ext_lang_initialized_p (get_ext_lang_defn (EXT_LANG_PYTHON
)))
1670 uiout
->field_string (NULL
, "python");
1675 error (_("-list-features should be passed no arguments"));
1679 mi_cmd_list_target_features (const char *command
, char **argv
, int argc
)
1683 struct ui_out
*uiout
= current_uiout
;
1685 ui_out_emit_list
list_emitter (uiout
, "features");
1687 uiout
->field_string (NULL
, "async");
1688 if (target_can_execute_reverse ())
1689 uiout
->field_string (NULL
, "reverse");
1693 error (_("-list-target-features should be passed no arguments"));
1697 mi_cmd_add_inferior (const char *command
, char **argv
, int argc
)
1699 struct inferior
*inf
;
1702 error (_("-add-inferior should be passed no arguments"));
1704 inf
= add_inferior_with_spaces ();
1706 current_uiout
->field_fmt ("inferior", "i%d", inf
->num
);
1710 mi_cmd_remove_inferior (const char *command
, char **argv
, int argc
)
1713 struct inferior
*inf_to_remove
;
1716 error (_("-remove-inferior should be passed a single argument"));
1718 if (sscanf (argv
[0], "i%d", &id
) != 1)
1719 error (_("the thread group id is syntactically invalid"));
1721 inf_to_remove
= find_inferior_id (id
);
1722 if (inf_to_remove
== NULL
)
1723 error (_("the specified thread group does not exist"));
1725 if (inf_to_remove
->pid
!= 0)
1726 error (_("cannot remove an active inferior"));
1728 if (inf_to_remove
== current_inferior ())
1730 struct thread_info
*tp
= 0;
1731 struct inferior
*new_inferior
= NULL
;
1733 for (inferior
*inf
: all_inferiors ())
1735 if (inf
!= inf_to_remove
)
1739 if (new_inferior
== NULL
)
1740 error (_("Cannot remove last inferior"));
1742 set_current_inferior (new_inferior
);
1743 if (new_inferior
->pid
!= 0)
1744 tp
= any_thread_of_inferior (new_inferior
);
1746 switch_to_thread (tp
);
1748 switch_to_no_thread ();
1749 set_current_program_space (new_inferior
->pspace
);
1752 delete_inferior (inf_to_remove
);
1757 /* Execute a command within a safe environment.
1758 Return <0 for error; >=0 for ok.
1760 args->action will tell mi_execute_command what action
1761 to perform after the given command has executed (display/suppress
1762 prompt, display error). */
1765 captured_mi_execute_command (struct ui_out
*uiout
, struct mi_parse
*context
)
1767 struct mi_interp
*mi
= (struct mi_interp
*) command_interp ();
1770 current_command_ts
= context
->cmd_start
;
1772 scoped_restore save_token
= make_scoped_restore (¤t_token
,
1775 running_result_record_printed
= 0;
1777 switch (context
->op
)
1780 /* A MI command was read from the input stream. */
1782 /* FIXME: gdb_???? */
1783 fprintf_unfiltered (mi
->raw_stdout
,
1784 " token=`%s' command=`%s' args=`%s'\n",
1785 context
->token
, context
->command
, context
->args
);
1787 mi_cmd_execute (context
);
1789 /* Print the result if there were no errors.
1791 Remember that on the way out of executing a command, you have
1792 to directly use the mi_interp's uiout, since the command
1793 could have reset the interpreter, in which case the current
1794 uiout will most likely crash in the mi_out_* routines. */
1795 if (!running_result_record_printed
)
1797 fputs_unfiltered (context
->token
, mi
->raw_stdout
);
1798 /* There's no particularly good reason why target-connect results
1799 in not ^done. Should kill ^connected for MI3. */
1800 fputs_unfiltered (strcmp (context
->command
, "target-select") == 0
1801 ? "^connected" : "^done", mi
->raw_stdout
);
1802 mi_out_put (uiout
, mi
->raw_stdout
);
1803 mi_out_rewind (uiout
);
1804 mi_print_timing_maybe (mi
->raw_stdout
);
1805 fputs_unfiltered ("\n", mi
->raw_stdout
);
1808 /* The command does not want anything to be printed. In that
1809 case, the command probably should not have written anything
1810 to uiout, but in case it has written something, discard it. */
1811 mi_out_rewind (uiout
);
1818 /* A CLI command was read from the input stream. */
1819 /* This "feature" will be removed as soon as we have a
1820 complete set of mi commands. */
1821 /* Echo the command on the console. */
1822 fprintf_unfiltered (gdb_stdlog
, "%s\n", context
->command
);
1823 /* Call the "console" interpreter. */
1824 argv
[0] = (char *) INTERP_CONSOLE
;
1825 argv
[1] = context
->command
;
1826 mi_cmd_interpreter_exec ("-interpreter-exec", argv
, 2);
1828 /* If we changed interpreters, DON'T print out anything. */
1829 if (current_interp_named_p (INTERP_MI
)
1830 || current_interp_named_p (INTERP_MI1
)
1831 || current_interp_named_p (INTERP_MI2
)
1832 || current_interp_named_p (INTERP_MI3
))
1834 if (!running_result_record_printed
)
1836 fputs_unfiltered (context
->token
, mi
->raw_stdout
);
1837 fputs_unfiltered ("^done", mi
->raw_stdout
);
1838 mi_out_put (uiout
, mi
->raw_stdout
);
1839 mi_out_rewind (uiout
);
1840 mi_print_timing_maybe (mi
->raw_stdout
);
1841 fputs_unfiltered ("\n", mi
->raw_stdout
);
1844 mi_out_rewind (uiout
);
1851 /* Print a gdb exception to the MI output stream. */
1854 mi_print_exception (const char *token
, const struct gdb_exception
&exception
)
1856 struct mi_interp
*mi
= (struct mi_interp
*) current_interpreter ();
1858 fputs_unfiltered (token
, mi
->raw_stdout
);
1859 fputs_unfiltered ("^error,msg=\"", mi
->raw_stdout
);
1860 if (exception
.message
== NULL
)
1861 fputs_unfiltered ("unknown error", mi
->raw_stdout
);
1863 fputstr_unfiltered (exception
.what (), '"', mi
->raw_stdout
);
1864 fputs_unfiltered ("\"", mi
->raw_stdout
);
1866 switch (exception
.error
)
1868 case UNDEFINED_COMMAND_ERROR
:
1869 fputs_unfiltered (",code=\"undefined-command\"", mi
->raw_stdout
);
1873 fputs_unfiltered ("\n", mi
->raw_stdout
);
1876 /* Determine whether the parsed command already notifies the
1877 user_selected_context_changed observer. */
1880 command_notifies_uscc_observer (struct mi_parse
*command
)
1882 if (command
->op
== CLI_COMMAND
)
1884 /* CLI commands "thread" and "inferior" already send it. */
1885 return (strncmp (command
->command
, "thread ", 7) == 0
1886 || strncmp (command
->command
, "inferior ", 9) == 0);
1888 else /* MI_COMMAND */
1890 if (strcmp (command
->command
, "interpreter-exec") == 0
1891 && command
->argc
> 1)
1893 /* "thread" and "inferior" again, but through -interpreter-exec. */
1894 return (strncmp (command
->argv
[1], "thread ", 7) == 0
1895 || strncmp (command
->argv
[1], "inferior ", 9) == 0);
1899 /* -thread-select already sends it. */
1900 return strcmp (command
->command
, "thread-select") == 0;
1905 mi_execute_command (const char *cmd
, int from_tty
)
1908 std::unique_ptr
<struct mi_parse
> command
;
1910 /* This is to handle EOF (^D). We just quit gdb. */
1911 /* FIXME: we should call some API function here. */
1913 quit_force (NULL
, from_tty
);
1915 target_log_command (cmd
);
1919 command
= mi_parse (cmd
, &token
);
1921 catch (const gdb_exception
&exception
)
1923 mi_print_exception (token
, exception
);
1927 if (command
!= NULL
)
1929 ptid_t previous_ptid
= inferior_ptid
;
1931 gdb::optional
<scoped_restore_tmpl
<int>> restore_suppress
;
1933 if (command
->cmd
!= NULL
&& command
->cmd
->suppress_notification
!= NULL
)
1934 restore_suppress
.emplace (command
->cmd
->suppress_notification
, 1);
1936 command
->token
= token
;
1940 command
->cmd_start
= new mi_timestamp ();
1941 timestamp (command
->cmd_start
);
1946 captured_mi_execute_command (current_uiout
, command
.get ());
1948 catch (const gdb_exception
&result
)
1950 /* Like in start_event_loop, enable input and force display
1951 of the prompt. Otherwise, any command that calls
1952 async_disable_stdin, and then throws, will leave input
1954 async_enable_stdin ();
1955 current_ui
->prompt_state
= PROMPT_NEEDED
;
1957 /* The command execution failed and error() was called
1959 mi_print_exception (command
->token
, result
);
1960 mi_out_rewind (current_uiout
);
1963 bpstat_do_actions ();
1965 if (/* The notifications are only output when the top-level
1966 interpreter (specified on the command line) is MI. */
1967 top_level_interpreter ()->interp_ui_out ()->is_mi_like_p ()
1968 /* Don't try report anything if there are no threads --
1969 the program is dead. */
1971 /* If the command already reports the thread change, no need to do it
1973 && !command_notifies_uscc_observer (command
.get ()))
1975 int report_change
= 0;
1977 if (command
->thread
== -1)
1979 report_change
= (previous_ptid
!= null_ptid
1980 && inferior_ptid
!= previous_ptid
1981 && inferior_ptid
!= null_ptid
);
1983 else if (inferior_ptid
!= null_ptid
)
1985 struct thread_info
*ti
= inferior_thread ();
1987 report_change
= (ti
->global_num
!= command
->thread
);
1992 gdb::observers::user_selected_context_changed
.notify
1993 (USER_SELECTED_THREAD
| USER_SELECTED_FRAME
);
2000 mi_cmd_execute (struct mi_parse
*parse
)
2002 scoped_value_mark cleanup
= prepare_execute_command ();
2004 if (parse
->all
&& parse
->thread_group
!= -1)
2005 error (_("Cannot specify --thread-group together with --all"));
2007 if (parse
->all
&& parse
->thread
!= -1)
2008 error (_("Cannot specify --thread together with --all"));
2010 if (parse
->thread_group
!= -1 && parse
->thread
!= -1)
2011 error (_("Cannot specify --thread together with --thread-group"));
2013 if (parse
->frame
!= -1 && parse
->thread
== -1)
2014 error (_("Cannot specify --frame without --thread"));
2016 if (parse
->thread_group
!= -1)
2018 struct inferior
*inf
= find_inferior_id (parse
->thread_group
);
2019 struct thread_info
*tp
= 0;
2022 error (_("Invalid thread group for the --thread-group option"));
2024 set_current_inferior (inf
);
2025 /* This behaviour means that if --thread-group option identifies
2026 an inferior with multiple threads, then a random one will be
2027 picked. This is not a problem -- frontend should always
2028 provide --thread if it wishes to operate on a specific
2031 tp
= any_live_thread_of_inferior (inf
);
2033 switch_to_thread (tp
);
2035 switch_to_no_thread ();
2036 set_current_program_space (inf
->pspace
);
2039 if (parse
->thread
!= -1)
2041 thread_info
*tp
= find_thread_global_id (parse
->thread
);
2044 error (_("Invalid thread id: %d"), parse
->thread
);
2046 if (tp
->state
== THREAD_EXITED
)
2047 error (_("Thread id: %d has terminated"), parse
->thread
);
2049 switch_to_thread (tp
);
2052 if (parse
->frame
!= -1)
2054 struct frame_info
*fid
;
2055 int frame
= parse
->frame
;
2057 fid
= find_relative_frame (get_current_frame (), &frame
);
2059 /* find_relative_frame was successful */
2062 error (_("Invalid frame id: %d"), frame
);
2065 gdb::optional
<scoped_restore_current_language
> lang_saver
;
2066 if (parse
->language
!= language_unknown
)
2068 lang_saver
.emplace ();
2069 set_language (parse
->language
);
2072 current_context
= parse
;
2074 if (parse
->cmd
->argv_func
!= NULL
)
2076 parse
->cmd
->argv_func (parse
->command
, parse
->argv
, parse
->argc
);
2078 else if (parse
->cmd
->cli
.cmd
!= 0)
2080 /* FIXME: DELETE THIS. */
2081 /* The operation is still implemented by a cli command. */
2082 /* Must be a synchronous one. */
2083 mi_execute_cli_command (parse
->cmd
->cli
.cmd
, parse
->cmd
->cli
.args_p
,
2088 /* FIXME: DELETE THIS. */
2091 stb
.puts ("Undefined mi command: ");
2092 stb
.putstr (parse
->command
, '"');
2093 stb
.puts (" (missing implementation)");
2099 /* FIXME: This is just a hack so we can get some extra commands going.
2100 We don't want to channel things through the CLI, but call libgdb directly.
2101 Use only for synchronous commands. */
2104 mi_execute_cli_command (const char *cmd
, int args_p
, const char *args
)
2108 std::string run
= cmd
;
2111 run
= run
+ " " + args
;
2113 /* FIXME: gdb_???? */
2114 fprintf_unfiltered (gdb_stdout
, "cli=%s run=%s\n",
2116 execute_command (run
.c_str (), 0 /* from_tty */ );
2121 mi_execute_async_cli_command (const char *cli_command
, char **argv
, int argc
)
2123 std::string run
= cli_command
;
2126 run
= run
+ " " + *argv
;
2130 execute_command (run
.c_str (), 0 /* from_tty */ );
2134 mi_load_progress (const char *section_name
,
2135 unsigned long sent_so_far
,
2136 unsigned long total_section
,
2137 unsigned long total_sent
,
2138 unsigned long grand_total
)
2140 using namespace std::chrono
;
2141 static steady_clock::time_point last_update
;
2142 static char *previous_sect_name
= NULL
;
2144 struct mi_interp
*mi
= (struct mi_interp
*) current_interpreter ();
2146 /* This function is called through deprecated_show_load_progress
2147 which means uiout may not be correct. Fix it for the duration
2148 of this function. */
2150 std::unique_ptr
<ui_out
> uiout (mi_out_new (current_interpreter ()->name ()));
2151 if (uiout
== nullptr)
2154 scoped_restore save_uiout
2155 = make_scoped_restore (¤t_uiout
, uiout
.get ());
2157 new_section
= (previous_sect_name
?
2158 strcmp (previous_sect_name
, section_name
) : 1);
2161 xfree (previous_sect_name
);
2162 previous_sect_name
= xstrdup (section_name
);
2165 fputs_unfiltered (current_token
, mi
->raw_stdout
);
2166 fputs_unfiltered ("+download", mi
->raw_stdout
);
2168 ui_out_emit_tuple
tuple_emitter (uiout
.get (), NULL
);
2169 uiout
->field_string ("section", section_name
);
2170 uiout
->field_signed ("section-size", total_section
);
2171 uiout
->field_signed ("total-size", grand_total
);
2173 mi_out_put (uiout
.get (), mi
->raw_stdout
);
2174 fputs_unfiltered ("\n", mi
->raw_stdout
);
2175 gdb_flush (mi
->raw_stdout
);
2178 steady_clock::time_point time_now
= steady_clock::now ();
2179 if (time_now
- last_update
> milliseconds (500))
2181 last_update
= time_now
;
2183 fputs_unfiltered (current_token
, mi
->raw_stdout
);
2184 fputs_unfiltered ("+download", mi
->raw_stdout
);
2186 ui_out_emit_tuple
tuple_emitter (uiout
.get (), NULL
);
2187 uiout
->field_string ("section", section_name
);
2188 uiout
->field_signed ("section-sent", sent_so_far
);
2189 uiout
->field_signed ("section-size", total_section
);
2190 uiout
->field_signed ("total-sent", total_sent
);
2191 uiout
->field_signed ("total-size", grand_total
);
2193 mi_out_put (uiout
.get (), mi
->raw_stdout
);
2194 fputs_unfiltered ("\n", mi
->raw_stdout
);
2195 gdb_flush (mi
->raw_stdout
);
2200 timestamp (struct mi_timestamp
*tv
)
2202 using namespace std::chrono
;
2204 tv
->wallclock
= steady_clock::now ();
2205 run_time_clock::now (tv
->utime
, tv
->stime
);
2209 print_diff_now (struct ui_file
*file
, struct mi_timestamp
*start
)
2211 struct mi_timestamp now
;
2214 print_diff (file
, start
, &now
);
2218 mi_print_timing_maybe (struct ui_file
*file
)
2220 /* If the command is -enable-timing then do_timings may be true
2221 whilst current_command_ts is not initialized. */
2222 if (do_timings
&& current_command_ts
)
2223 print_diff_now (file
, current_command_ts
);
2227 print_diff (struct ui_file
*file
, struct mi_timestamp
*start
,
2228 struct mi_timestamp
*end
)
2230 using namespace std::chrono
;
2232 duration
<double> wallclock
= end
->wallclock
- start
->wallclock
;
2233 duration
<double> utime
= end
->utime
- start
->utime
;
2234 duration
<double> stime
= end
->stime
- start
->stime
;
2238 ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
2239 wallclock
.count (), utime
.count (), stime
.count ());
2243 mi_cmd_trace_define_variable (const char *command
, char **argv
, int argc
)
2245 LONGEST initval
= 0;
2246 struct trace_state_variable
*tsv
;
2249 if (argc
!= 1 && argc
!= 2)
2250 error (_("Usage: -trace-define-variable VARIABLE [VALUE]"));
2254 error (_("Name of trace variable should start with '$'"));
2256 validate_trace_state_variable_name (name
);
2258 tsv
= find_trace_state_variable (name
);
2260 tsv
= create_trace_state_variable (name
);
2263 initval
= value_as_long (parse_and_eval (argv
[1]));
2265 tsv
->initial_value
= initval
;
2269 mi_cmd_trace_list_variables (const char *command
, char **argv
, int argc
)
2272 error (_("-trace-list-variables: no arguments allowed"));
2274 tvariables_info_1 ();
2278 mi_cmd_trace_find (const char *command
, char **argv
, int argc
)
2283 error (_("trace selection mode is required"));
2287 if (strcmp (mode
, "none") == 0)
2289 tfind_1 (tfind_number
, -1, 0, 0, 0);
2293 check_trace_running (current_trace_status ());
2295 if (strcmp (mode
, "frame-number") == 0)
2298 error (_("frame number is required"));
2299 tfind_1 (tfind_number
, atoi (argv
[1]), 0, 0, 0);
2301 else if (strcmp (mode
, "tracepoint-number") == 0)
2304 error (_("tracepoint number is required"));
2305 tfind_1 (tfind_tp
, atoi (argv
[1]), 0, 0, 0);
2307 else if (strcmp (mode
, "pc") == 0)
2310 error (_("PC is required"));
2311 tfind_1 (tfind_pc
, 0, parse_and_eval_address (argv
[1]), 0, 0);
2313 else if (strcmp (mode
, "pc-inside-range") == 0)
2316 error (_("Start and end PC are required"));
2317 tfind_1 (tfind_range
, 0, parse_and_eval_address (argv
[1]),
2318 parse_and_eval_address (argv
[2]), 0);
2320 else if (strcmp (mode
, "pc-outside-range") == 0)
2323 error (_("Start and end PC are required"));
2324 tfind_1 (tfind_outside
, 0, parse_and_eval_address (argv
[1]),
2325 parse_and_eval_address (argv
[2]), 0);
2327 else if (strcmp (mode
, "line") == 0)
2330 error (_("Line is required"));
2332 std::vector
<symtab_and_line
> sals
2333 = decode_line_with_current_source (argv
[1],
2334 DECODE_LINE_FUNFIRSTLINE
);
2335 const symtab_and_line
&sal
= sals
[0];
2337 if (sal
.symtab
== 0)
2338 error (_("Could not find the specified line"));
2340 CORE_ADDR start_pc
, end_pc
;
2341 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2342 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, 0);
2344 error (_("Could not find the specified line"));
2347 error (_("Invalid mode '%s'"), mode
);
2349 if (has_stack_frames () || get_traceframe_number () >= 0)
2350 print_stack_frame (get_selected_frame (NULL
), 1, LOC_AND_ADDRESS
, 1);
2354 mi_cmd_trace_save (const char *command
, char **argv
, int argc
)
2356 int target_saves
= 0;
2357 int generate_ctf
= 0;
2364 TARGET_SAVE_OPT
, CTF_OPT
2366 static const struct mi_opt opts
[] =
2368 {"r", TARGET_SAVE_OPT
, 0},
2369 {"ctf", CTF_OPT
, 0},
2375 int opt
= mi_getopt ("-trace-save", argc
, argv
, opts
,
2380 switch ((enum opt
) opt
)
2382 case TARGET_SAVE_OPT
:
2391 if (argc
- oind
!= 1)
2392 error (_("Exactly one argument required "
2393 "(file in which to save trace data)"));
2395 filename
= argv
[oind
];
2398 trace_save_ctf (filename
, target_saves
);
2400 trace_save_tfile (filename
, target_saves
);
2404 mi_cmd_trace_start (const char *command
, char **argv
, int argc
)
2406 start_tracing (NULL
);
2410 mi_cmd_trace_status (const char *command
, char **argv
, int argc
)
2412 trace_status_mi (0);
2416 mi_cmd_trace_stop (const char *command
, char **argv
, int argc
)
2418 stop_tracing (NULL
);
2419 trace_status_mi (1);
2422 /* Implement the "-ada-task-info" command. */
2425 mi_cmd_ada_task_info (const char *command
, char **argv
, int argc
)
2427 if (argc
!= 0 && argc
!= 1)
2428 error (_("Invalid MI command"));
2430 print_ada_task_info (current_uiout
, argv
[0], current_inferior ());
2433 /* Print EXPRESSION according to VALUES. */
2436 print_variable_or_computed (const char *expression
, enum print_values values
)
2440 struct ui_out
*uiout
= current_uiout
;
2444 expression_up expr
= parse_expression (expression
);
2446 if (values
== PRINT_SIMPLE_VALUES
)
2447 val
= evaluate_type (expr
.get ());
2449 val
= evaluate_expression (expr
.get ());
2451 gdb::optional
<ui_out_emit_tuple
> tuple_emitter
;
2452 if (values
!= PRINT_NO_VALUES
)
2453 tuple_emitter
.emplace (uiout
, nullptr);
2454 uiout
->field_string ("name", expression
);
2458 case PRINT_SIMPLE_VALUES
:
2459 type
= check_typedef (value_type (val
));
2460 type_print (value_type (val
), "", &stb
, -1);
2461 uiout
->field_stream ("type", stb
);
2462 if (type
->code () != TYPE_CODE_ARRAY
2463 && type
->code () != TYPE_CODE_STRUCT
2464 && type
->code () != TYPE_CODE_UNION
)
2466 struct value_print_options opts
;
2468 get_no_prettyformat_print_options (&opts
);
2470 common_val_print (val
, &stb
, 0, &opts
, current_language
);
2471 uiout
->field_stream ("value", stb
);
2474 case PRINT_ALL_VALUES
:
2476 struct value_print_options opts
;
2478 get_no_prettyformat_print_options (&opts
);
2480 common_val_print (val
, &stb
, 0, &opts
, current_language
);
2481 uiout
->field_stream ("value", stb
);
2487 /* Implement the "-trace-frame-collected" command. */
2490 mi_cmd_trace_frame_collected (const char *command
, char **argv
, int argc
)
2492 struct bp_location
*tloc
;
2494 struct collection_list
*clist
;
2495 struct collection_list tracepoint_list
, stepping_list
;
2496 struct traceframe_info
*tinfo
;
2498 enum print_values var_print_values
= PRINT_ALL_VALUES
;
2499 enum print_values comp_print_values
= PRINT_ALL_VALUES
;
2500 int registers_format
= 'x';
2501 int memory_contents
= 0;
2502 struct ui_out
*uiout
= current_uiout
;
2510 static const struct mi_opt opts
[] =
2512 {"-var-print-values", VAR_PRINT_VALUES
, 1},
2513 {"-comp-print-values", COMP_PRINT_VALUES
, 1},
2514 {"-registers-format", REGISTERS_FORMAT
, 1},
2515 {"-memory-contents", MEMORY_CONTENTS
, 0},
2522 int opt
= mi_getopt ("-trace-frame-collected", argc
, argv
, opts
,
2526 switch ((enum opt
) opt
)
2528 case VAR_PRINT_VALUES
:
2529 var_print_values
= mi_parse_print_values (oarg
);
2531 case COMP_PRINT_VALUES
:
2532 comp_print_values
= mi_parse_print_values (oarg
);
2534 case REGISTERS_FORMAT
:
2535 registers_format
= oarg
[0];
2537 case MEMORY_CONTENTS
:
2538 memory_contents
= 1;
2544 error (_("Usage: -trace-frame-collected "
2545 "[--var-print-values PRINT_VALUES] "
2546 "[--comp-print-values PRINT_VALUES] "
2547 "[--registers-format FORMAT]"
2548 "[--memory-contents]"));
2550 /* This throws an error is not inspecting a trace frame. */
2551 tloc
= get_traceframe_location (&stepping_frame
);
2553 /* This command only makes sense for the current frame, not the
2555 scoped_restore_current_thread restore_thread
;
2556 select_frame (get_current_frame ());
2558 encode_actions (tloc
, &tracepoint_list
, &stepping_list
);
2561 clist
= &stepping_list
;
2563 clist
= &tracepoint_list
;
2565 tinfo
= get_traceframe_info ();
2567 /* Explicitly wholly collected variables. */
2569 ui_out_emit_list
list_emitter (uiout
, "explicit-variables");
2570 const std::vector
<std::string
> &wholly_collected
2571 = clist
->wholly_collected ();
2572 for (size_t i
= 0; i
< wholly_collected
.size (); i
++)
2574 const std::string
&str
= wholly_collected
[i
];
2575 print_variable_or_computed (str
.c_str (), var_print_values
);
2579 /* Computed expressions. */
2581 ui_out_emit_list
list_emitter (uiout
, "computed-expressions");
2583 const std::vector
<std::string
> &computed
= clist
->computed ();
2584 for (size_t i
= 0; i
< computed
.size (); i
++)
2586 const std::string
&str
= computed
[i
];
2587 print_variable_or_computed (str
.c_str (), comp_print_values
);
2591 /* Registers. Given pseudo-registers, and that some architectures
2592 (like MIPS) actually hide the raw registers, we don't go through
2593 the trace frame info, but instead consult the register cache for
2594 register availability. */
2596 struct frame_info
*frame
;
2597 struct gdbarch
*gdbarch
;
2601 ui_out_emit_list
list_emitter (uiout
, "registers");
2603 frame
= get_selected_frame (NULL
);
2604 gdbarch
= get_frame_arch (frame
);
2605 numregs
= gdbarch_num_cooked_regs (gdbarch
);
2607 for (regnum
= 0; regnum
< numregs
; regnum
++)
2609 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
2610 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
2613 output_register (frame
, regnum
, registers_format
, 1);
2617 /* Trace state variables. */
2619 ui_out_emit_list
list_emitter (uiout
, "tvars");
2621 for (int tvar
: tinfo
->tvars
)
2623 struct trace_state_variable
*tsv
;
2625 tsv
= find_trace_state_variable_by_number (tvar
);
2627 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
2631 uiout
->field_fmt ("name", "$%s", tsv
->name
.c_str ());
2633 tsv
->value_known
= target_get_trace_state_variable_value (tsv
->number
,
2635 uiout
->field_signed ("current", tsv
->value
);
2639 uiout
->field_skip ("name");
2640 uiout
->field_skip ("current");
2647 std::vector
<mem_range
> available_memory
;
2649 traceframe_available_memory (&available_memory
, 0, ULONGEST_MAX
);
2651 ui_out_emit_list
list_emitter (uiout
, "memory");
2653 for (const mem_range
&r
: available_memory
)
2655 struct gdbarch
*gdbarch
= target_gdbarch ();
2657 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
2659 uiout
->field_core_addr ("address", gdbarch
, r
.start
);
2660 uiout
->field_signed ("length", r
.length
);
2662 gdb::byte_vector
data (r
.length
);
2664 if (memory_contents
)
2666 if (target_read_memory (r
.start
, data
.data (), r
.length
) == 0)
2668 std::string data_str
= bin2hex (data
.data (), r
.length
);
2669 uiout
->field_string ("contents", data_str
.c_str ());
2672 uiout
->field_skip ("contents");
2678 /* See mi/mi-main.h. */
2681 mi_cmd_fix_multi_location_breakpoint_output (const char *command
, char **argv
,
2684 fix_multi_location_breakpoint_output_globally
= true;
2687 /* Implement the "-complete" command. */
2690 mi_cmd_complete (const char *command
, char **argv
, int argc
)
2693 error (_("Usage: -complete COMMAND"));
2695 if (max_completions
== 0)
2696 error (_("max-completions is zero, completion is disabled."));
2698 int quote_char
= '\0';
2701 completion_result result
= complete (argv
[0], &word
, "e_char
);
2703 std::string
arg_prefix (argv
[0], word
- argv
[0]);
2705 struct ui_out
*uiout
= current_uiout
;
2707 if (result
.number_matches
> 0)
2708 uiout
->field_fmt ("completion", "%s%s",
2709 arg_prefix
.c_str (),result
.match_list
[0]);
2712 ui_out_emit_list
completions_emitter (uiout
, "matches");
2714 if (result
.number_matches
== 1)
2715 uiout
->field_fmt (NULL
, "%s%s",
2716 arg_prefix
.c_str (), result
.match_list
[0]);
2719 result
.sort_match_list ();
2720 for (size_t i
= 0; i
< result
.number_matches
; i
++)
2722 uiout
->field_fmt (NULL
, "%s%s",
2723 arg_prefix
.c_str (), result
.match_list
[i
+ 1]);
2727 uiout
->field_string ("max_completions_reached",
2728 result
.number_matches
== max_completions
? "1" : "0");
2732 void _initialize_mi_main ();
2734 _initialize_mi_main ()
2736 struct cmd_list_element
*c
;
2738 add_setshow_boolean_cmd ("mi-async", class_run
,
2740 Set whether MI asynchronous mode is enabled."), _("\
2741 Show whether MI asynchronous mode is enabled."), _("\
2742 Tells GDB whether MI should be in asynchronous mode."),
2743 set_mi_async_command
,
2744 show_mi_async_command
,
2748 /* Alias old "target-async" to "mi-async". */
2749 c
= add_alias_cmd ("target-async", "mi-async", class_run
, 0, &setlist
);
2750 deprecate_cmd (c
, "set mi-async");
2751 c
= add_alias_cmd ("target-async", "mi-async", class_run
, 0, &showlist
);
2752 deprecate_cmd (c
, "show mi-async");