3 Copyright (C) 2000-2020 Free Software Foundation, Inc.
5 Contributed by Cygnus Solutions (a Red Hat company).
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 #include "arch-utils.h"
28 #include "gdbthread.h"
31 #include "mi-getopt.h"
32 #include "mi-console.h"
36 #include "event-loop.h"
37 #include "event-top.h"
38 #include "gdbcore.h" /* For write_memory(). */
43 #include "mi-common.h"
47 #include "gdbsupport/gdb_splay_tree.h"
48 #include "tracepoint.h"
51 #include "extension.h"
53 #include "observable.h"
54 #include "gdbsupport/gdb_optional.h"
55 #include "gdbsupport/byte-vector.h"
58 #include "gdbsupport/run-time-clock.h"
60 #include "progspace-and-thread.h"
61 #include "gdbsupport/rsp-low.h"
73 /* This is used to pass the current command timestamp down to
74 continuation routines. */
75 static struct mi_timestamp
*current_command_ts
;
77 static int do_timings
= 0;
80 /* Few commands would like to know if options like --thread-group were
81 explicitly specified. This variable keeps the current parsed
82 command including all option, and make it possible. */
83 static struct mi_parse
*current_context
;
85 int running_result_record_printed
= 1;
87 /* Flag indicating that the target has proceeded since the last
88 command was issued. */
91 static void mi_cmd_execute (struct mi_parse
*parse
);
93 static void mi_execute_cli_command (const char *cmd
, int args_p
,
95 static void mi_execute_async_cli_command (const char *cli_command
,
96 char **argv
, int argc
);
97 static bool register_changed_p (int regnum
, readonly_detached_regcache
*,
98 readonly_detached_regcache
*);
99 static void output_register (struct frame_info
*, int regnum
, int format
,
100 int skip_unavailable
);
102 /* Controls whether the frontend wants MI in async mode. */
103 static bool mi_async
= false;
105 /* The set command writes to this variable. If the inferior is
106 executing, mi_async is *not* updated. */
107 static bool mi_async_1
= false;
110 set_mi_async_command (const char *args
, int from_tty
,
111 struct cmd_list_element
*c
)
113 if (have_live_inferiors ())
115 mi_async_1
= mi_async
;
116 error (_("Cannot change this setting while the inferior is running."));
119 mi_async
= mi_async_1
;
123 show_mi_async_command (struct ui_file
*file
, int from_tty
,
124 struct cmd_list_element
*c
,
127 fprintf_filtered (file
,
128 _("Whether MI is in asynchronous mode is %s.\n"),
132 /* A wrapper for target_can_async_p that takes the MI setting into
138 return mi_async
&& target_can_async_p ();
141 /* Command implementations. FIXME: Is this libgdb? No. This is the MI
142 layer that calls libgdb. Any operation used in the below should be
145 static void timestamp (struct mi_timestamp
*tv
);
147 static void print_diff (struct ui_file
*file
, struct mi_timestamp
*start
,
148 struct mi_timestamp
*end
);
151 mi_cmd_gdb_exit (const char *command
, char **argv
, int argc
)
153 struct mi_interp
*mi
= (struct mi_interp
*) current_interpreter ();
155 /* We have to print everything right here because we never return. */
157 fputs_unfiltered (current_token
, mi
->raw_stdout
);
158 fputs_unfiltered ("^exit\n", mi
->raw_stdout
);
159 mi_out_put (current_uiout
, mi
->raw_stdout
);
160 gdb_flush (mi
->raw_stdout
);
161 /* FIXME: The function called is not yet a formal libgdb function. */
162 quit_force (NULL
, FROM_TTY
);
166 mi_cmd_exec_next (const char *command
, char **argv
, int argc
)
168 /* FIXME: Should call a libgdb function, not a cli wrapper. */
169 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
170 mi_execute_async_cli_command ("reverse-next", argv
+ 1, argc
- 1);
172 mi_execute_async_cli_command ("next", argv
, argc
);
176 mi_cmd_exec_next_instruction (const char *command
, char **argv
, int argc
)
178 /* FIXME: Should call a libgdb function, not a cli wrapper. */
179 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
180 mi_execute_async_cli_command ("reverse-nexti", argv
+ 1, argc
- 1);
182 mi_execute_async_cli_command ("nexti", argv
, argc
);
186 mi_cmd_exec_step (const char *command
, char **argv
, int argc
)
188 /* FIXME: Should call a libgdb function, not a cli wrapper. */
189 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
190 mi_execute_async_cli_command ("reverse-step", argv
+ 1, argc
- 1);
192 mi_execute_async_cli_command ("step", argv
, argc
);
196 mi_cmd_exec_step_instruction (const char *command
, char **argv
, int argc
)
198 /* FIXME: Should call a libgdb function, not a cli wrapper. */
199 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
200 mi_execute_async_cli_command ("reverse-stepi", argv
+ 1, argc
- 1);
202 mi_execute_async_cli_command ("stepi", argv
, argc
);
206 mi_cmd_exec_finish (const char *command
, char **argv
, int argc
)
208 /* FIXME: Should call a libgdb function, not a cli wrapper. */
209 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
210 mi_execute_async_cli_command ("reverse-finish", argv
+ 1, argc
- 1);
212 mi_execute_async_cli_command ("finish", argv
, argc
);
216 mi_cmd_exec_return (const char *command
, char **argv
, int argc
)
218 /* This command doesn't really execute the target, it just pops the
219 specified number of frames. */
221 /* Call return_command with from_tty argument equal to 0 so as to
222 avoid being queried. */
223 return_command (*argv
, 0);
225 /* Call return_command with from_tty argument equal to 0 so as to
226 avoid being queried. */
227 return_command (NULL
, 0);
229 /* Because we have called return_command with from_tty = 0, we need
230 to print the frame here. */
231 print_stack_frame (get_selected_frame (NULL
), 1, LOC_AND_ADDRESS
, 1);
235 mi_cmd_exec_jump (const char *args
, char **argv
, int argc
)
237 /* FIXME: Should call a libgdb function, not a cli wrapper. */
238 mi_execute_async_cli_command ("jump", argv
, argc
);
242 proceed_thread (struct thread_info
*thread
, int pid
)
244 if (thread
->state
!= THREAD_STOPPED
)
247 if (pid
!= 0 && thread
->ptid
.pid () != pid
)
250 switch_to_thread (thread
);
251 clear_proceed_status (0);
252 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
);
256 proceed_thread_callback (struct thread_info
*thread
, void *arg
)
258 int pid
= *(int *)arg
;
260 proceed_thread (thread
, pid
);
265 exec_continue (char **argv
, int argc
)
267 prepare_execution_command (current_top_target (), mi_async_p ());
271 /* In non-stop mode, 'resume' always resumes a single thread.
272 Therefore, to resume all threads of the current inferior, or
273 all threads in all inferiors, we need to iterate over
276 See comment on infcmd.c:proceed_thread_callback for rationale. */
277 if (current_context
->all
|| current_context
->thread_group
!= -1)
279 scoped_restore_current_thread restore_thread
;
282 if (!current_context
->all
)
285 = find_inferior_id (current_context
->thread_group
);
289 iterate_over_threads (proceed_thread_callback
, &pid
);
298 scoped_restore save_multi
= make_scoped_restore (&sched_multi
);
300 if (current_context
->all
)
307 /* In all-stop mode, -exec-continue traditionally resumed
308 either all threads, or one thread, depending on the
309 'scheduler-locking' variable. Let's continue to do the
317 exec_reverse_continue (char **argv
, int argc
)
319 enum exec_direction_kind dir
= execution_direction
;
321 if (dir
== EXEC_REVERSE
)
322 error (_("Already in reverse mode."));
324 if (!target_can_execute_reverse
)
325 error (_("Target %s does not support this command."), target_shortname
);
327 scoped_restore save_exec_dir
= make_scoped_restore (&execution_direction
,
329 exec_continue (argv
, argc
);
333 mi_cmd_exec_continue (const char *command
, char **argv
, int argc
)
335 if (argc
> 0 && strcmp (argv
[0], "--reverse") == 0)
336 exec_reverse_continue (argv
+ 1, argc
- 1);
338 exec_continue (argv
, argc
);
342 interrupt_thread_callback (struct thread_info
*thread
, void *arg
)
344 int pid
= *(int *)arg
;
346 if (thread
->state
!= THREAD_RUNNING
)
349 if (thread
->ptid
.pid () != pid
)
352 target_stop (thread
->ptid
);
356 /* Interrupt the execution of the target. Note how we must play
357 around with the token variables, in order to display the current
358 token in the result of the interrupt command, and the previous
359 execution token when the target finally stops. See comments in
363 mi_cmd_exec_interrupt (const char *command
, char **argv
, int argc
)
365 /* In all-stop mode, everything stops, so we don't need to try
366 anything specific. */
369 interrupt_target_1 (0);
373 if (current_context
->all
)
375 /* This will interrupt all threads in all inferiors. */
376 interrupt_target_1 (1);
378 else if (current_context
->thread_group
!= -1)
380 struct inferior
*inf
= find_inferior_id (current_context
->thread_group
);
382 iterate_over_threads (interrupt_thread_callback
, &inf
->pid
);
386 /* Interrupt just the current thread -- either explicitly
387 specified via --thread or whatever was current before
388 MI command was sent. */
389 interrupt_target_1 (0);
393 /* 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
->pspace_exec_filename
!= NULL
)
654 uiout
->field_string ("executable",
655 inferior
->pspace
->pspace_exec_filename
);
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 val_print (value_type (val
),
1124 value_embedded_offset (val
), 0,
1125 &stb
, 0, val
, &opts
, current_language
);
1126 uiout
->field_stream ("value", stb
);
1129 /* Write given values into registers. The registers and values are
1130 given as pairs. The corresponding MI command is
1131 -data-write-register-values <format>
1132 [<regnum1> <value1>...<regnumN> <valueN>] */
1134 mi_cmd_data_write_register_values (const char *command
, char **argv
, int argc
)
1136 struct regcache
*regcache
;
1137 struct gdbarch
*gdbarch
;
1140 /* Note that the test for a valid register must include checking the
1141 gdbarch_register_name because gdbarch_num_regs may be allocated
1142 for the union of the register sets within a family of related
1143 processors. In this case, some entries of gdbarch_register_name
1144 will change depending upon the particular processor being
1147 regcache
= get_current_regcache ();
1148 gdbarch
= regcache
->arch ();
1149 numregs
= gdbarch_num_cooked_regs (gdbarch
);
1152 error (_("-data-write-register-values: Usage: -data-write-register-"
1153 "values <format> [<regnum1> <value1>...<regnumN> <valueN>]"));
1155 if (!target_has_registers
)
1156 error (_("-data-write-register-values: No registers."));
1159 error (_("-data-write-register-values: No regs and values specified."));
1162 error (_("-data-write-register-values: "
1163 "Regs and vals are not in pairs."));
1165 for (i
= 1; i
< argc
; i
= i
+ 2)
1167 int regnum
= atoi (argv
[i
]);
1169 if (regnum
>= 0 && regnum
< numregs
1170 && gdbarch_register_name (gdbarch
, regnum
)
1171 && *gdbarch_register_name (gdbarch
, regnum
))
1175 /* Get the value as a number. */
1176 value
= parse_and_eval_address (argv
[i
+ 1]);
1178 /* Write it down. */
1179 regcache_cooked_write_signed (regcache
, regnum
, value
);
1182 error (_("bad register number"));
1186 /* Evaluate the value of the argument. The argument is an
1187 expression. If the expression contains spaces it needs to be
1188 included in double quotes. */
1191 mi_cmd_data_evaluate_expression (const char *command
, char **argv
, int argc
)
1194 struct value_print_options opts
;
1195 struct ui_out
*uiout
= current_uiout
;
1198 error (_("-data-evaluate-expression: "
1199 "Usage: -data-evaluate-expression expression"));
1201 expression_up expr
= parse_expression (argv
[0]);
1203 val
= evaluate_expression (expr
.get ());
1207 /* Print the result of the expression evaluation. */
1208 get_user_print_options (&opts
);
1210 common_val_print (val
, &stb
, 0, &opts
, current_language
);
1212 uiout
->field_stream ("value", stb
);
1215 /* This is the -data-read-memory command.
1217 ADDR: start address of data to be dumped.
1218 WORD-FORMAT: a char indicating format for the ``word''. See
1220 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes.
1221 NR_ROW: Number of rows.
1222 NR_COL: The number of columns (words per row).
1223 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
1224 ASCHAR for unprintable characters.
1226 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
1227 displays them. Returns:
1229 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
1232 The number of bytes read is SIZE*ROW*COL. */
1235 mi_cmd_data_read_memory (const char *command
, char **argv
, int argc
)
1237 struct gdbarch
*gdbarch
= get_current_arch ();
1238 struct ui_out
*uiout
= current_uiout
;
1240 long total_bytes
, nr_cols
, nr_rows
;
1242 struct type
*word_type
;
1254 static const struct mi_opt opts
[] =
1256 {"o", OFFSET_OPT
, 1},
1262 int opt
= mi_getopt ("-data-read-memory", argc
, argv
, opts
,
1267 switch ((enum opt
) opt
)
1270 offset
= atol (oarg
);
1277 if (argc
< 5 || argc
> 6)
1278 error (_("-data-read-memory: Usage: "
1279 "ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR]."));
1281 /* Extract all the arguments. */
1283 /* Start address of the memory dump. */
1284 addr
= parse_and_eval_address (argv
[0]) + offset
;
1285 /* The format character to use when displaying a memory word. See
1286 the ``x'' command. */
1287 word_format
= argv
[1][0];
1288 /* The size of the memory word. */
1289 word_size
= atol (argv
[2]);
1293 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1297 word_type
= builtin_type (gdbarch
)->builtin_int16
;
1301 word_type
= builtin_type (gdbarch
)->builtin_int32
;
1305 word_type
= builtin_type (gdbarch
)->builtin_int64
;
1309 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1312 /* The number of rows. */
1313 nr_rows
= atol (argv
[3]);
1315 error (_("-data-read-memory: invalid number of rows."));
1317 /* Number of bytes per row. */
1318 nr_cols
= atol (argv
[4]);
1320 error (_("-data-read-memory: invalid number of columns."));
1322 /* The un-printable character when printing ascii. */
1328 /* Create a buffer and read it in. */
1329 total_bytes
= word_size
* nr_rows
* nr_cols
;
1331 gdb::byte_vector
mbuf (total_bytes
);
1333 nr_bytes
= target_read (current_top_target (), TARGET_OBJECT_MEMORY
, NULL
,
1334 mbuf
.data (), addr
, total_bytes
);
1336 error (_("Unable to read memory."));
1338 /* Output the header information. */
1339 uiout
->field_core_addr ("addr", gdbarch
, addr
);
1340 uiout
->field_signed ("nr-bytes", nr_bytes
);
1341 uiout
->field_signed ("total-bytes", total_bytes
);
1342 uiout
->field_core_addr ("next-row", gdbarch
, addr
+ word_size
* nr_cols
);
1343 uiout
->field_core_addr ("prev-row", gdbarch
, addr
- word_size
* nr_cols
);
1344 uiout
->field_core_addr ("next-page", gdbarch
, addr
+ total_bytes
);
1345 uiout
->field_core_addr ("prev-page", gdbarch
, addr
- total_bytes
);
1347 /* Build the result as a two dimensional table. */
1354 ui_out_emit_list
list_emitter (uiout
, "memory");
1355 for (row
= 0, row_byte
= 0;
1357 row
++, row_byte
+= nr_cols
* word_size
)
1361 struct value_print_options print_opts
;
1363 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1364 uiout
->field_core_addr ("addr", gdbarch
, addr
+ row_byte
);
1365 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr +
1368 ui_out_emit_list
list_data_emitter (uiout
, "data");
1369 get_formatted_print_options (&print_opts
, word_format
);
1370 for (col
= 0, col_byte
= row_byte
;
1372 col
++, col_byte
+= word_size
)
1374 if (col_byte
+ word_size
> nr_bytes
)
1376 uiout
->field_string (NULL
, "N/A");
1381 print_scalar_formatted (&mbuf
[col_byte
], word_type
,
1382 &print_opts
, word_asize
, &stream
);
1383 uiout
->field_stream (NULL
, stream
);
1393 for (byte
= row_byte
;
1394 byte
< row_byte
+ word_size
* nr_cols
; byte
++)
1396 if (byte
>= nr_bytes
)
1398 else if (mbuf
[byte
] < 32 || mbuf
[byte
] > 126)
1399 stream
.putc (aschar
);
1401 stream
.putc (mbuf
[byte
]);
1403 uiout
->field_stream ("ascii", stream
);
1410 mi_cmd_data_read_memory_bytes (const char *command
, char **argv
, int argc
)
1412 struct gdbarch
*gdbarch
= get_current_arch ();
1413 struct ui_out
*uiout
= current_uiout
;
1417 int unit_size
= gdbarch_addressable_memory_unit_size (gdbarch
);
1424 static const struct mi_opt opts
[] =
1426 {"o", OFFSET_OPT
, 1},
1432 int opt
= mi_getopt ("-data-read-memory-bytes", argc
, argv
, opts
,
1436 switch ((enum opt
) opt
)
1439 offset
= atol (oarg
);
1447 error (_("Usage: [ -o OFFSET ] ADDR LENGTH."));
1449 addr
= parse_and_eval_address (argv
[0]) + offset
;
1450 length
= atol (argv
[1]);
1452 std::vector
<memory_read_result
> result
1453 = read_memory_robust (current_top_target (), addr
, length
);
1455 if (result
.size () == 0)
1456 error (_("Unable to read memory."));
1458 ui_out_emit_list
list_emitter (uiout
, "memory");
1459 for (const memory_read_result
&read_result
: result
)
1461 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1463 uiout
->field_core_addr ("begin", gdbarch
, read_result
.begin
);
1464 uiout
->field_core_addr ("offset", gdbarch
, read_result
.begin
- addr
);
1465 uiout
->field_core_addr ("end", gdbarch
, read_result
.end
);
1467 std::string data
= bin2hex (read_result
.data
.get (),
1468 (read_result
.end
- read_result
.begin
)
1470 uiout
->field_string ("contents", data
.c_str ());
1474 /* Implementation of the -data-write_memory command.
1476 COLUMN_OFFSET: optional argument. Must be preceded by '-o'. The
1477 offset from the beginning of the memory grid row where the cell to
1479 ADDR: start address of the row in the memory grid where the memory
1480 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
1481 the location to write to.
1482 FORMAT: a char indicating format for the ``word''. See
1484 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
1485 VALUE: value to be written into the memory address.
1487 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
1492 mi_cmd_data_write_memory (const char *command
, char **argv
, int argc
)
1494 struct gdbarch
*gdbarch
= get_current_arch ();
1495 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1498 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
1499 enough when using a compiler other than GCC. */
1508 static const struct mi_opt opts
[] =
1510 {"o", OFFSET_OPT
, 1},
1516 int opt
= mi_getopt ("-data-write-memory", argc
, argv
, opts
,
1521 switch ((enum opt
) opt
)
1524 offset
= atol (oarg
);
1532 error (_("-data-write-memory: Usage: "
1533 "[-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE."));
1535 /* Extract all the arguments. */
1536 /* Start address of the memory dump. */
1537 addr
= parse_and_eval_address (argv
[0]);
1538 /* The size of the memory word. */
1539 word_size
= atol (argv
[2]);
1541 /* Calculate the real address of the write destination. */
1542 addr
+= (offset
* word_size
);
1544 /* Get the value as a number. */
1545 value
= parse_and_eval_address (argv
[3]);
1546 /* Get the value into an array. */
1547 gdb::byte_vector
buffer (word_size
);
1548 store_signed_integer (buffer
.data (), word_size
, byte_order
, value
);
1549 /* Write it down to memory. */
1550 write_memory_with_notification (addr
, buffer
.data (), word_size
);
1553 /* Implementation of the -data-write-memory-bytes command.
1556 DATA: string of bytes to write at that address
1557 COUNT: number of bytes to be filled (decimal integer). */
1560 mi_cmd_data_write_memory_bytes (const char *command
, char **argv
, int argc
)
1564 size_t len_hex
, len_bytes
, len_units
, i
, steps
, remaining_units
;
1565 long int count_units
;
1568 if (argc
!= 2 && argc
!= 3)
1569 error (_("Usage: ADDR DATA [COUNT]."));
1571 addr
= parse_and_eval_address (argv
[0]);
1573 len_hex
= strlen (cdata
);
1574 unit_size
= gdbarch_addressable_memory_unit_size (get_current_arch ());
1576 if (len_hex
% (unit_size
* 2) != 0)
1577 error (_("Hex-encoded '%s' must represent an integral number of "
1578 "addressable memory units."),
1581 len_bytes
= len_hex
/ 2;
1582 len_units
= len_bytes
/ unit_size
;
1585 count_units
= strtoul (argv
[2], NULL
, 10);
1587 count_units
= len_units
;
1589 gdb::byte_vector
databuf (len_bytes
);
1591 for (i
= 0; i
< len_bytes
; ++i
)
1594 if (sscanf (cdata
+ i
* 2, "%02x", &x
) != 1)
1595 error (_("Invalid argument"));
1596 databuf
[i
] = (gdb_byte
) x
;
1599 gdb::byte_vector data
;
1600 if (len_units
< count_units
)
1602 /* Pattern is made of less units than count:
1603 repeat pattern to fill memory. */
1604 data
= gdb::byte_vector (count_units
* unit_size
);
1606 /* Number of times the pattern is entirely repeated. */
1607 steps
= count_units
/ len_units
;
1608 /* Number of remaining addressable memory units. */
1609 remaining_units
= count_units
% len_units
;
1610 for (i
= 0; i
< steps
; i
++)
1611 memcpy (&data
[i
* len_bytes
], &databuf
[0], len_bytes
);
1613 if (remaining_units
> 0)
1614 memcpy (&data
[steps
* len_bytes
], &databuf
[0],
1615 remaining_units
* unit_size
);
1619 /* Pattern is longer than or equal to count:
1620 just copy count addressable memory units. */
1621 data
= std::move (databuf
);
1624 write_memory_with_notification (addr
, data
.data (), count_units
);
1628 mi_cmd_enable_timings (const char *command
, char **argv
, int argc
)
1634 if (strcmp (argv
[0], "yes") == 0)
1636 else if (strcmp (argv
[0], "no") == 0)
1647 error (_("-enable-timings: Usage: %s {yes|no}"), command
);
1651 mi_cmd_list_features (const char *command
, char **argv
, int argc
)
1655 struct ui_out
*uiout
= current_uiout
;
1657 ui_out_emit_list
list_emitter (uiout
, "features");
1658 uiout
->field_string (NULL
, "frozen-varobjs");
1659 uiout
->field_string (NULL
, "pending-breakpoints");
1660 uiout
->field_string (NULL
, "thread-info");
1661 uiout
->field_string (NULL
, "data-read-memory-bytes");
1662 uiout
->field_string (NULL
, "breakpoint-notifications");
1663 uiout
->field_string (NULL
, "ada-task-info");
1664 uiout
->field_string (NULL
, "language-option");
1665 uiout
->field_string (NULL
, "info-gdb-mi-command");
1666 uiout
->field_string (NULL
, "undefined-command-error-code");
1667 uiout
->field_string (NULL
, "exec-run-start-option");
1668 uiout
->field_string (NULL
, "data-disassemble-a-option");
1670 if (ext_lang_initialized_p (get_ext_lang_defn (EXT_LANG_PYTHON
)))
1671 uiout
->field_string (NULL
, "python");
1676 error (_("-list-features should be passed no arguments"));
1680 mi_cmd_list_target_features (const char *command
, char **argv
, int argc
)
1684 struct ui_out
*uiout
= current_uiout
;
1686 ui_out_emit_list
list_emitter (uiout
, "features");
1688 uiout
->field_string (NULL
, "async");
1689 if (target_can_execute_reverse
)
1690 uiout
->field_string (NULL
, "reverse");
1694 error (_("-list-target-features should be passed no arguments"));
1698 mi_cmd_add_inferior (const char *command
, char **argv
, int argc
)
1700 struct inferior
*inf
;
1703 error (_("-add-inferior should be passed no arguments"));
1705 inf
= add_inferior_with_spaces ();
1707 current_uiout
->field_fmt ("inferior", "i%d", inf
->num
);
1711 mi_cmd_remove_inferior (const char *command
, char **argv
, int argc
)
1714 struct inferior
*inf_to_remove
;
1717 error (_("-remove-inferior should be passed a single argument"));
1719 if (sscanf (argv
[0], "i%d", &id
) != 1)
1720 error (_("the thread group id is syntactically invalid"));
1722 inf_to_remove
= find_inferior_id (id
);
1723 if (inf_to_remove
== NULL
)
1724 error (_("the specified thread group does not exist"));
1726 if (inf_to_remove
->pid
!= 0)
1727 error (_("cannot remove an active inferior"));
1729 if (inf_to_remove
== current_inferior ())
1731 struct thread_info
*tp
= 0;
1732 struct inferior
*new_inferior
= NULL
;
1734 for (inferior
*inf
: all_inferiors ())
1736 if (inf
!= inf_to_remove
)
1740 if (new_inferior
== NULL
)
1741 error (_("Cannot remove last inferior"));
1743 set_current_inferior (new_inferior
);
1744 if (new_inferior
->pid
!= 0)
1745 tp
= any_thread_of_inferior (new_inferior
);
1747 switch_to_thread (tp
);
1749 switch_to_no_thread ();
1750 set_current_program_space (new_inferior
->pspace
);
1753 delete_inferior (inf_to_remove
);
1758 /* Execute a command within a safe environment.
1759 Return <0 for error; >=0 for ok.
1761 args->action will tell mi_execute_command what action
1762 to perform after the given command has executed (display/suppress
1763 prompt, display error). */
1766 captured_mi_execute_command (struct ui_out
*uiout
, struct mi_parse
*context
)
1768 struct mi_interp
*mi
= (struct mi_interp
*) command_interp ();
1771 current_command_ts
= context
->cmd_start
;
1773 scoped_restore save_token
= make_scoped_restore (¤t_token
,
1776 running_result_record_printed
= 0;
1778 switch (context
->op
)
1781 /* A MI command was read from the input stream. */
1783 /* FIXME: gdb_???? */
1784 fprintf_unfiltered (mi
->raw_stdout
,
1785 " token=`%s' command=`%s' args=`%s'\n",
1786 context
->token
, context
->command
, context
->args
);
1788 mi_cmd_execute (context
);
1790 /* Print the result if there were no errors.
1792 Remember that on the way out of executing a command, you have
1793 to directly use the mi_interp's uiout, since the command
1794 could have reset the interpreter, in which case the current
1795 uiout will most likely crash in the mi_out_* routines. */
1796 if (!running_result_record_printed
)
1798 fputs_unfiltered (context
->token
, mi
->raw_stdout
);
1799 /* There's no particularly good reason why target-connect results
1800 in not ^done. Should kill ^connected for MI3. */
1801 fputs_unfiltered (strcmp (context
->command
, "target-select") == 0
1802 ? "^connected" : "^done", mi
->raw_stdout
);
1803 mi_out_put (uiout
, mi
->raw_stdout
);
1804 mi_out_rewind (uiout
);
1805 mi_print_timing_maybe (mi
->raw_stdout
);
1806 fputs_unfiltered ("\n", mi
->raw_stdout
);
1809 /* The command does not want anything to be printed. In that
1810 case, the command probably should not have written anything
1811 to uiout, but in case it has written something, discard it. */
1812 mi_out_rewind (uiout
);
1819 /* A CLI command was read from the input stream. */
1820 /* This "feature" will be removed as soon as we have a
1821 complete set of mi commands. */
1822 /* Echo the command on the console. */
1823 fprintf_unfiltered (gdb_stdlog
, "%s\n", context
->command
);
1824 /* Call the "console" interpreter. */
1825 argv
[0] = (char *) INTERP_CONSOLE
;
1826 argv
[1] = context
->command
;
1827 mi_cmd_interpreter_exec ("-interpreter-exec", argv
, 2);
1829 /* If we changed interpreters, DON'T print out anything. */
1830 if (current_interp_named_p (INTERP_MI
)
1831 || current_interp_named_p (INTERP_MI1
)
1832 || current_interp_named_p (INTERP_MI2
)
1833 || current_interp_named_p (INTERP_MI3
))
1835 if (!running_result_record_printed
)
1837 fputs_unfiltered (context
->token
, mi
->raw_stdout
);
1838 fputs_unfiltered ("^done", mi
->raw_stdout
);
1839 mi_out_put (uiout
, mi
->raw_stdout
);
1840 mi_out_rewind (uiout
);
1841 mi_print_timing_maybe (mi
->raw_stdout
);
1842 fputs_unfiltered ("\n", mi
->raw_stdout
);
1845 mi_out_rewind (uiout
);
1852 /* Print a gdb exception to the MI output stream. */
1855 mi_print_exception (const char *token
, const struct gdb_exception
&exception
)
1857 struct mi_interp
*mi
= (struct mi_interp
*) current_interpreter ();
1859 fputs_unfiltered (token
, mi
->raw_stdout
);
1860 fputs_unfiltered ("^error,msg=\"", mi
->raw_stdout
);
1861 if (exception
.message
== NULL
)
1862 fputs_unfiltered ("unknown error", mi
->raw_stdout
);
1864 fputstr_unfiltered (exception
.what (), '"', mi
->raw_stdout
);
1865 fputs_unfiltered ("\"", mi
->raw_stdout
);
1867 switch (exception
.error
)
1869 case UNDEFINED_COMMAND_ERROR
:
1870 fputs_unfiltered (",code=\"undefined-command\"", mi
->raw_stdout
);
1874 fputs_unfiltered ("\n", mi
->raw_stdout
);
1877 /* Determine whether the parsed command already notifies the
1878 user_selected_context_changed observer. */
1881 command_notifies_uscc_observer (struct mi_parse
*command
)
1883 if (command
->op
== CLI_COMMAND
)
1885 /* CLI commands "thread" and "inferior" already send it. */
1886 return (strncmp (command
->command
, "thread ", 7) == 0
1887 || strncmp (command
->command
, "inferior ", 9) == 0);
1889 else /* MI_COMMAND */
1891 if (strcmp (command
->command
, "interpreter-exec") == 0
1892 && command
->argc
> 1)
1894 /* "thread" and "inferior" again, but through -interpreter-exec. */
1895 return (strncmp (command
->argv
[1], "thread ", 7) == 0
1896 || strncmp (command
->argv
[1], "inferior ", 9) == 0);
1900 /* -thread-select already sends it. */
1901 return strcmp (command
->command
, "thread-select") == 0;
1906 mi_execute_command (const char *cmd
, int from_tty
)
1909 std::unique_ptr
<struct mi_parse
> command
;
1911 /* This is to handle EOF (^D). We just quit gdb. */
1912 /* FIXME: we should call some API function here. */
1914 quit_force (NULL
, from_tty
);
1916 target_log_command (cmd
);
1920 command
= mi_parse (cmd
, &token
);
1922 catch (const gdb_exception
&exception
)
1924 mi_print_exception (token
, exception
);
1928 if (command
!= NULL
)
1930 ptid_t previous_ptid
= inferior_ptid
;
1932 gdb::optional
<scoped_restore_tmpl
<int>> restore_suppress
;
1934 if (command
->cmd
!= NULL
&& command
->cmd
->suppress_notification
!= NULL
)
1935 restore_suppress
.emplace (command
->cmd
->suppress_notification
, 1);
1937 command
->token
= token
;
1941 command
->cmd_start
= new mi_timestamp ();
1942 timestamp (command
->cmd_start
);
1947 captured_mi_execute_command (current_uiout
, command
.get ());
1949 catch (const gdb_exception
&result
)
1951 /* Like in start_event_loop, enable input and force display
1952 of the prompt. Otherwise, any command that calls
1953 async_disable_stdin, and then throws, will leave input
1955 async_enable_stdin ();
1956 current_ui
->prompt_state
= PROMPT_NEEDED
;
1958 /* The command execution failed and error() was called
1960 mi_print_exception (command
->token
, result
);
1961 mi_out_rewind (current_uiout
);
1964 bpstat_do_actions ();
1966 if (/* The notifications are only output when the top-level
1967 interpreter (specified on the command line) is MI. */
1968 top_level_interpreter ()->interp_ui_out ()->is_mi_like_p ()
1969 /* Don't try report anything if there are no threads --
1970 the program is dead. */
1972 /* If the command already reports the thread change, no need to do it
1974 && !command_notifies_uscc_observer (command
.get ()))
1976 int report_change
= 0;
1978 if (command
->thread
== -1)
1980 report_change
= (previous_ptid
!= null_ptid
1981 && inferior_ptid
!= previous_ptid
1982 && inferior_ptid
!= null_ptid
);
1984 else if (inferior_ptid
!= null_ptid
)
1986 struct thread_info
*ti
= inferior_thread ();
1988 report_change
= (ti
->global_num
!= command
->thread
);
1993 gdb::observers::user_selected_context_changed
.notify
1994 (USER_SELECTED_THREAD
| USER_SELECTED_FRAME
);
2001 mi_cmd_execute (struct mi_parse
*parse
)
2003 scoped_value_mark cleanup
= prepare_execute_command ();
2005 if (parse
->all
&& parse
->thread_group
!= -1)
2006 error (_("Cannot specify --thread-group together with --all"));
2008 if (parse
->all
&& parse
->thread
!= -1)
2009 error (_("Cannot specify --thread together with --all"));
2011 if (parse
->thread_group
!= -1 && parse
->thread
!= -1)
2012 error (_("Cannot specify --thread together with --thread-group"));
2014 if (parse
->frame
!= -1 && parse
->thread
== -1)
2015 error (_("Cannot specify --frame without --thread"));
2017 if (parse
->thread_group
!= -1)
2019 struct inferior
*inf
= find_inferior_id (parse
->thread_group
);
2020 struct thread_info
*tp
= 0;
2023 error (_("Invalid thread group for the --thread-group option"));
2025 set_current_inferior (inf
);
2026 /* This behaviour means that if --thread-group option identifies
2027 an inferior with multiple threads, then a random one will be
2028 picked. This is not a problem -- frontend should always
2029 provide --thread if it wishes to operate on a specific
2032 tp
= any_live_thread_of_inferior (inf
);
2034 switch_to_thread (tp
);
2036 switch_to_no_thread ();
2037 set_current_program_space (inf
->pspace
);
2040 if (parse
->thread
!= -1)
2042 thread_info
*tp
= find_thread_global_id (parse
->thread
);
2045 error (_("Invalid thread id: %d"), parse
->thread
);
2047 if (tp
->state
== THREAD_EXITED
)
2048 error (_("Thread id: %d has terminated"), parse
->thread
);
2050 switch_to_thread (tp
);
2053 if (parse
->frame
!= -1)
2055 struct frame_info
*fid
;
2056 int frame
= parse
->frame
;
2058 fid
= find_relative_frame (get_current_frame (), &frame
);
2060 /* find_relative_frame was successful */
2063 error (_("Invalid frame id: %d"), frame
);
2066 gdb::optional
<scoped_restore_current_language
> lang_saver
;
2067 if (parse
->language
!= language_unknown
)
2069 lang_saver
.emplace ();
2070 set_language (parse
->language
);
2073 current_context
= parse
;
2075 if (parse
->cmd
->argv_func
!= NULL
)
2077 parse
->cmd
->argv_func (parse
->command
, parse
->argv
, parse
->argc
);
2079 else if (parse
->cmd
->cli
.cmd
!= 0)
2081 /* FIXME: DELETE THIS. */
2082 /* The operation is still implemented by a cli command. */
2083 /* Must be a synchronous one. */
2084 mi_execute_cli_command (parse
->cmd
->cli
.cmd
, parse
->cmd
->cli
.args_p
,
2089 /* FIXME: DELETE THIS. */
2092 stb
.puts ("Undefined mi command: ");
2093 stb
.putstr (parse
->command
, '"');
2094 stb
.puts (" (missing implementation)");
2100 /* FIXME: This is just a hack so we can get some extra commands going.
2101 We don't want to channel things through the CLI, but call libgdb directly.
2102 Use only for synchronous commands. */
2105 mi_execute_cli_command (const char *cmd
, int args_p
, const char *args
)
2109 std::string run
= cmd
;
2112 run
= run
+ " " + args
;
2114 /* FIXME: gdb_???? */
2115 fprintf_unfiltered (gdb_stdout
, "cli=%s run=%s\n",
2117 execute_command (run
.c_str (), 0 /* from_tty */ );
2122 mi_execute_async_cli_command (const char *cli_command
, char **argv
, int argc
)
2124 std::string run
= cli_command
;
2127 run
= run
+ " " + *argv
;
2131 execute_command (run
.c_str (), 0 /* from_tty */ );
2135 mi_load_progress (const char *section_name
,
2136 unsigned long sent_so_far
,
2137 unsigned long total_section
,
2138 unsigned long total_sent
,
2139 unsigned long grand_total
)
2141 using namespace std::chrono
;
2142 static steady_clock::time_point last_update
;
2143 static char *previous_sect_name
= NULL
;
2145 struct mi_interp
*mi
= (struct mi_interp
*) current_interpreter ();
2147 /* This function is called through deprecated_show_load_progress
2148 which means uiout may not be correct. Fix it for the duration
2149 of this function. */
2151 std::unique_ptr
<ui_out
> uiout (mi_out_new (current_interpreter ()->name ()));
2152 if (uiout
== nullptr)
2155 scoped_restore save_uiout
2156 = make_scoped_restore (¤t_uiout
, uiout
.get ());
2158 new_section
= (previous_sect_name
?
2159 strcmp (previous_sect_name
, section_name
) : 1);
2162 xfree (previous_sect_name
);
2163 previous_sect_name
= xstrdup (section_name
);
2166 fputs_unfiltered (current_token
, mi
->raw_stdout
);
2167 fputs_unfiltered ("+download", mi
->raw_stdout
);
2169 ui_out_emit_tuple
tuple_emitter (uiout
.get (), NULL
);
2170 uiout
->field_string ("section", section_name
);
2171 uiout
->field_signed ("section-size", total_section
);
2172 uiout
->field_signed ("total-size", grand_total
);
2174 mi_out_put (uiout
.get (), mi
->raw_stdout
);
2175 fputs_unfiltered ("\n", mi
->raw_stdout
);
2176 gdb_flush (mi
->raw_stdout
);
2179 steady_clock::time_point time_now
= steady_clock::now ();
2180 if (time_now
- last_update
> milliseconds (500))
2182 last_update
= time_now
;
2184 fputs_unfiltered (current_token
, mi
->raw_stdout
);
2185 fputs_unfiltered ("+download", mi
->raw_stdout
);
2187 ui_out_emit_tuple
tuple_emitter (uiout
.get (), NULL
);
2188 uiout
->field_string ("section", section_name
);
2189 uiout
->field_signed ("section-sent", sent_so_far
);
2190 uiout
->field_signed ("section-size", total_section
);
2191 uiout
->field_signed ("total-sent", total_sent
);
2192 uiout
->field_signed ("total-size", grand_total
);
2194 mi_out_put (uiout
.get (), mi
->raw_stdout
);
2195 fputs_unfiltered ("\n", mi
->raw_stdout
);
2196 gdb_flush (mi
->raw_stdout
);
2201 timestamp (struct mi_timestamp
*tv
)
2203 using namespace std::chrono
;
2205 tv
->wallclock
= steady_clock::now ();
2206 run_time_clock::now (tv
->utime
, tv
->stime
);
2210 print_diff_now (struct ui_file
*file
, struct mi_timestamp
*start
)
2212 struct mi_timestamp now
;
2215 print_diff (file
, start
, &now
);
2219 mi_print_timing_maybe (struct ui_file
*file
)
2221 /* If the command is -enable-timing then do_timings may be true
2222 whilst current_command_ts is not initialized. */
2223 if (do_timings
&& current_command_ts
)
2224 print_diff_now (file
, current_command_ts
);
2228 print_diff (struct ui_file
*file
, struct mi_timestamp
*start
,
2229 struct mi_timestamp
*end
)
2231 using namespace std::chrono
;
2233 duration
<double> wallclock
= end
->wallclock
- start
->wallclock
;
2234 duration
<double> utime
= end
->utime
- start
->utime
;
2235 duration
<double> stime
= end
->stime
- start
->stime
;
2239 ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
2240 wallclock
.count (), utime
.count (), stime
.count ());
2244 mi_cmd_trace_define_variable (const char *command
, char **argv
, int argc
)
2246 LONGEST initval
= 0;
2247 struct trace_state_variable
*tsv
;
2250 if (argc
!= 1 && argc
!= 2)
2251 error (_("Usage: -trace-define-variable VARIABLE [VALUE]"));
2255 error (_("Name of trace variable should start with '$'"));
2257 validate_trace_state_variable_name (name
);
2259 tsv
= find_trace_state_variable (name
);
2261 tsv
= create_trace_state_variable (name
);
2264 initval
= value_as_long (parse_and_eval (argv
[1]));
2266 tsv
->initial_value
= initval
;
2270 mi_cmd_trace_list_variables (const char *command
, char **argv
, int argc
)
2273 error (_("-trace-list-variables: no arguments allowed"));
2275 tvariables_info_1 ();
2279 mi_cmd_trace_find (const char *command
, char **argv
, int argc
)
2284 error (_("trace selection mode is required"));
2288 if (strcmp (mode
, "none") == 0)
2290 tfind_1 (tfind_number
, -1, 0, 0, 0);
2294 check_trace_running (current_trace_status ());
2296 if (strcmp (mode
, "frame-number") == 0)
2299 error (_("frame number is required"));
2300 tfind_1 (tfind_number
, atoi (argv
[1]), 0, 0, 0);
2302 else if (strcmp (mode
, "tracepoint-number") == 0)
2305 error (_("tracepoint number is required"));
2306 tfind_1 (tfind_tp
, atoi (argv
[1]), 0, 0, 0);
2308 else if (strcmp (mode
, "pc") == 0)
2311 error (_("PC is required"));
2312 tfind_1 (tfind_pc
, 0, parse_and_eval_address (argv
[1]), 0, 0);
2314 else if (strcmp (mode
, "pc-inside-range") == 0)
2317 error (_("Start and end PC are required"));
2318 tfind_1 (tfind_range
, 0, parse_and_eval_address (argv
[1]),
2319 parse_and_eval_address (argv
[2]), 0);
2321 else if (strcmp (mode
, "pc-outside-range") == 0)
2324 error (_("Start and end PC are required"));
2325 tfind_1 (tfind_outside
, 0, parse_and_eval_address (argv
[1]),
2326 parse_and_eval_address (argv
[2]), 0);
2328 else if (strcmp (mode
, "line") == 0)
2331 error (_("Line is required"));
2333 std::vector
<symtab_and_line
> sals
2334 = decode_line_with_current_source (argv
[1],
2335 DECODE_LINE_FUNFIRSTLINE
);
2336 const symtab_and_line
&sal
= sals
[0];
2338 if (sal
.symtab
== 0)
2339 error (_("Could not find the specified line"));
2341 CORE_ADDR start_pc
, end_pc
;
2342 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2343 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, 0);
2345 error (_("Could not find the specified line"));
2348 error (_("Invalid mode '%s'"), mode
);
2350 if (has_stack_frames () || get_traceframe_number () >= 0)
2351 print_stack_frame (get_selected_frame (NULL
), 1, LOC_AND_ADDRESS
, 1);
2355 mi_cmd_trace_save (const char *command
, char **argv
, int argc
)
2357 int target_saves
= 0;
2358 int generate_ctf
= 0;
2365 TARGET_SAVE_OPT
, CTF_OPT
2367 static const struct mi_opt opts
[] =
2369 {"r", TARGET_SAVE_OPT
, 0},
2370 {"ctf", CTF_OPT
, 0},
2376 int opt
= mi_getopt ("-trace-save", argc
, argv
, opts
,
2381 switch ((enum opt
) opt
)
2383 case TARGET_SAVE_OPT
:
2392 if (argc
- oind
!= 1)
2393 error (_("Exactly one argument required "
2394 "(file in which to save trace data)"));
2396 filename
= argv
[oind
];
2399 trace_save_ctf (filename
, target_saves
);
2401 trace_save_tfile (filename
, target_saves
);
2405 mi_cmd_trace_start (const char *command
, char **argv
, int argc
)
2407 start_tracing (NULL
);
2411 mi_cmd_trace_status (const char *command
, char **argv
, int argc
)
2413 trace_status_mi (0);
2417 mi_cmd_trace_stop (const char *command
, char **argv
, int argc
)
2419 stop_tracing (NULL
);
2420 trace_status_mi (1);
2423 /* Implement the "-ada-task-info" command. */
2426 mi_cmd_ada_task_info (const char *command
, char **argv
, int argc
)
2428 if (argc
!= 0 && argc
!= 1)
2429 error (_("Invalid MI command"));
2431 print_ada_task_info (current_uiout
, argv
[0], current_inferior ());
2434 /* Print EXPRESSION according to VALUES. */
2437 print_variable_or_computed (const char *expression
, enum print_values values
)
2441 struct ui_out
*uiout
= current_uiout
;
2445 expression_up expr
= parse_expression (expression
);
2447 if (values
== PRINT_SIMPLE_VALUES
)
2448 val
= evaluate_type (expr
.get ());
2450 val
= evaluate_expression (expr
.get ());
2452 gdb::optional
<ui_out_emit_tuple
> tuple_emitter
;
2453 if (values
!= PRINT_NO_VALUES
)
2454 tuple_emitter
.emplace (uiout
, nullptr);
2455 uiout
->field_string ("name", expression
);
2459 case PRINT_SIMPLE_VALUES
:
2460 type
= check_typedef (value_type (val
));
2461 type_print (value_type (val
), "", &stb
, -1);
2462 uiout
->field_stream ("type", stb
);
2463 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
2464 && TYPE_CODE (type
) != TYPE_CODE_STRUCT
2465 && TYPE_CODE (type
) != TYPE_CODE_UNION
)
2467 struct value_print_options opts
;
2469 get_no_prettyformat_print_options (&opts
);
2471 common_val_print (val
, &stb
, 0, &opts
, current_language
);
2472 uiout
->field_stream ("value", stb
);
2475 case PRINT_ALL_VALUES
:
2477 struct value_print_options opts
;
2479 get_no_prettyformat_print_options (&opts
);
2481 common_val_print (val
, &stb
, 0, &opts
, current_language
);
2482 uiout
->field_stream ("value", stb
);
2488 /* Implement the "-trace-frame-collected" command. */
2491 mi_cmd_trace_frame_collected (const char *command
, char **argv
, int argc
)
2493 struct bp_location
*tloc
;
2495 struct collection_list
*clist
;
2496 struct collection_list tracepoint_list
, stepping_list
;
2497 struct traceframe_info
*tinfo
;
2499 enum print_values var_print_values
= PRINT_ALL_VALUES
;
2500 enum print_values comp_print_values
= PRINT_ALL_VALUES
;
2501 int registers_format
= 'x';
2502 int memory_contents
= 0;
2503 struct ui_out
*uiout
= current_uiout
;
2511 static const struct mi_opt opts
[] =
2513 {"-var-print-values", VAR_PRINT_VALUES
, 1},
2514 {"-comp-print-values", COMP_PRINT_VALUES
, 1},
2515 {"-registers-format", REGISTERS_FORMAT
, 1},
2516 {"-memory-contents", MEMORY_CONTENTS
, 0},
2523 int opt
= mi_getopt ("-trace-frame-collected", argc
, argv
, opts
,
2527 switch ((enum opt
) opt
)
2529 case VAR_PRINT_VALUES
:
2530 var_print_values
= mi_parse_print_values (oarg
);
2532 case COMP_PRINT_VALUES
:
2533 comp_print_values
= mi_parse_print_values (oarg
);
2535 case REGISTERS_FORMAT
:
2536 registers_format
= oarg
[0];
2538 case MEMORY_CONTENTS
:
2539 memory_contents
= 1;
2545 error (_("Usage: -trace-frame-collected "
2546 "[--var-print-values PRINT_VALUES] "
2547 "[--comp-print-values PRINT_VALUES] "
2548 "[--registers-format FORMAT]"
2549 "[--memory-contents]"));
2551 /* This throws an error is not inspecting a trace frame. */
2552 tloc
= get_traceframe_location (&stepping_frame
);
2554 /* This command only makes sense for the current frame, not the
2556 scoped_restore_current_thread restore_thread
;
2557 select_frame (get_current_frame ());
2559 encode_actions (tloc
, &tracepoint_list
, &stepping_list
);
2562 clist
= &stepping_list
;
2564 clist
= &tracepoint_list
;
2566 tinfo
= get_traceframe_info ();
2568 /* Explicitly wholly collected variables. */
2570 ui_out_emit_list
list_emitter (uiout
, "explicit-variables");
2571 const std::vector
<std::string
> &wholly_collected
2572 = clist
->wholly_collected ();
2573 for (size_t i
= 0; i
< wholly_collected
.size (); i
++)
2575 const std::string
&str
= wholly_collected
[i
];
2576 print_variable_or_computed (str
.c_str (), var_print_values
);
2580 /* Computed expressions. */
2582 ui_out_emit_list
list_emitter (uiout
, "computed-expressions");
2584 const std::vector
<std::string
> &computed
= clist
->computed ();
2585 for (size_t i
= 0; i
< computed
.size (); i
++)
2587 const std::string
&str
= computed
[i
];
2588 print_variable_or_computed (str
.c_str (), comp_print_values
);
2592 /* Registers. Given pseudo-registers, and that some architectures
2593 (like MIPS) actually hide the raw registers, we don't go through
2594 the trace frame info, but instead consult the register cache for
2595 register availability. */
2597 struct frame_info
*frame
;
2598 struct gdbarch
*gdbarch
;
2602 ui_out_emit_list
list_emitter (uiout
, "registers");
2604 frame
= get_selected_frame (NULL
);
2605 gdbarch
= get_frame_arch (frame
);
2606 numregs
= gdbarch_num_cooked_regs (gdbarch
);
2608 for (regnum
= 0; regnum
< numregs
; regnum
++)
2610 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
2611 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
2614 output_register (frame
, regnum
, registers_format
, 1);
2618 /* Trace state variables. */
2620 ui_out_emit_list
list_emitter (uiout
, "tvars");
2622 for (int tvar
: tinfo
->tvars
)
2624 struct trace_state_variable
*tsv
;
2626 tsv
= find_trace_state_variable_by_number (tvar
);
2628 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
2632 uiout
->field_fmt ("name", "$%s", tsv
->name
.c_str ());
2634 tsv
->value_known
= target_get_trace_state_variable_value (tsv
->number
,
2636 uiout
->field_signed ("current", tsv
->value
);
2640 uiout
->field_skip ("name");
2641 uiout
->field_skip ("current");
2648 std::vector
<mem_range
> available_memory
;
2650 traceframe_available_memory (&available_memory
, 0, ULONGEST_MAX
);
2652 ui_out_emit_list
list_emitter (uiout
, "memory");
2654 for (const mem_range
&r
: available_memory
)
2656 struct gdbarch
*gdbarch
= target_gdbarch ();
2658 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
2660 uiout
->field_core_addr ("address", gdbarch
, r
.start
);
2661 uiout
->field_signed ("length", r
.length
);
2663 gdb::byte_vector
data (r
.length
);
2665 if (memory_contents
)
2667 if (target_read_memory (r
.start
, data
.data (), r
.length
) == 0)
2669 std::string data_str
= bin2hex (data
.data (), r
.length
);
2670 uiout
->field_string ("contents", data_str
.c_str ());
2673 uiout
->field_skip ("contents");
2679 /* See mi/mi-main.h. */
2682 mi_cmd_fix_multi_location_breakpoint_output (const char *command
, char **argv
,
2685 fix_multi_location_breakpoint_output_globally
= true;
2688 /* Implement the "-complete" command. */
2691 mi_cmd_complete (const char *command
, char **argv
, int argc
)
2694 error (_("Usage: -complete COMMAND"));
2696 if (max_completions
== 0)
2697 error (_("max-completions is zero, completion is disabled."));
2699 int quote_char
= '\0';
2702 completion_result result
= complete (argv
[0], &word
, "e_char
);
2704 std::string
arg_prefix (argv
[0], word
- argv
[0]);
2706 struct ui_out
*uiout
= current_uiout
;
2708 if (result
.number_matches
> 0)
2709 uiout
->field_fmt ("completion", "%s%s",
2710 arg_prefix
.c_str (),result
.match_list
[0]);
2713 ui_out_emit_list
completions_emitter (uiout
, "matches");
2715 if (result
.number_matches
== 1)
2716 uiout
->field_fmt (NULL
, "%s%s",
2717 arg_prefix
.c_str (), result
.match_list
[0]);
2720 result
.sort_match_list ();
2721 for (size_t i
= 0; i
< result
.number_matches
; i
++)
2723 uiout
->field_fmt (NULL
, "%s%s",
2724 arg_prefix
.c_str (), result
.match_list
[i
+ 1]);
2728 uiout
->field_string ("max_completions_reached",
2729 result
.number_matches
== max_completions
? "1" : "0");
2733 void _initialize_mi_main ();
2735 _initialize_mi_main ()
2737 struct cmd_list_element
*c
;
2739 add_setshow_boolean_cmd ("mi-async", class_run
,
2741 Set whether MI asynchronous mode is enabled."), _("\
2742 Show whether MI asynchronous mode is enabled."), _("\
2743 Tells GDB whether MI should be in asynchronous mode."),
2744 set_mi_async_command
,
2745 show_mi_async_command
,
2749 /* Alias old "target-async" to "mi-async". */
2750 c
= add_alias_cmd ("target-async", "mi-async", class_run
, 0, &setlist
);
2751 deprecate_cmd (c
, "set mi-async");
2752 c
= add_alias_cmd ("target-async", "mi-async", class_run
, 0, &showlist
);
2753 deprecate_cmd (c
, "show mi-async");