3 Copyright (C) 2000-2019 Free Software Foundation, Inc.
5 Contributed by Cygnus Solutions (a Red Hat company).
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 #include "arch-utils.h"
28 #include "gdbthread.h"
31 #include "mi-getopt.h"
32 #include "mi-console.h"
36 #include "event-loop.h"
37 #include "event-top.h"
38 #include "gdbcore.h" /* For write_memory(). */
43 #include "mi-common.h"
47 #include "gdbsupport/gdb_splay_tree.h"
48 #include "tracepoint.h"
51 #include "extension.h"
53 #include "observable.h"
54 #include "gdbsupport/gdb_optional.h"
55 #include "gdbsupport/byte-vector.h"
58 #include "gdbsupport/run-time-clock.h"
60 #include "progspace-and-thread.h"
61 #include "gdbsupport/rsp-low.h"
73 /* This is used to pass the current command timestamp down to
74 continuation routines. */
75 static struct mi_timestamp
*current_command_ts
;
77 static int do_timings
= 0;
80 /* Few commands would like to know if options like --thread-group were
81 explicitly specified. This variable keeps the current parsed
82 command including all option, and make it possible. */
83 static struct mi_parse
*current_context
;
85 int running_result_record_printed
= 1;
87 /* Flag indicating that the target has proceeded since the last
88 command was issued. */
91 static void mi_cmd_execute (struct mi_parse
*parse
);
93 static void mi_execute_cli_command (const char *cmd
, int args_p
,
95 static void mi_execute_async_cli_command (const char *cli_command
,
96 char **argv
, int argc
);
97 static bool register_changed_p (int regnum
, readonly_detached_regcache
*,
98 readonly_detached_regcache
*);
99 static void output_register (struct frame_info
*, int regnum
, int format
,
100 int skip_unavailable
);
102 /* Controls whether the frontend wants MI in async mode. */
103 static bool mi_async
= false;
105 /* The set command writes to this variable. If the inferior is
106 executing, mi_async is *not* updated. */
107 static bool mi_async_1
= false;
110 set_mi_async_command (const char *args
, int from_tty
,
111 struct cmd_list_element
*c
)
113 if (have_live_inferiors ())
115 mi_async_1
= mi_async
;
116 error (_("Cannot change this setting while the inferior is running."));
119 mi_async
= mi_async_1
;
123 show_mi_async_command (struct ui_file
*file
, int from_tty
,
124 struct cmd_list_element
*c
,
127 fprintf_filtered (file
,
128 _("Whether MI is in asynchronous mode is %s.\n"),
132 /* A wrapper for target_can_async_p that takes the MI setting into
138 return mi_async
&& target_can_async_p ();
141 /* Command implementations. FIXME: Is this libgdb? No. This is the MI
142 layer that calls libgdb. Any operation used in the below should be
145 static void timestamp (struct mi_timestamp
*tv
);
147 static void print_diff (struct ui_file
*file
, struct mi_timestamp
*start
,
148 struct mi_timestamp
*end
);
151 mi_cmd_gdb_exit (const char *command
, char **argv
, int argc
)
153 struct mi_interp
*mi
= (struct mi_interp
*) current_interpreter ();
155 /* We have to print everything right here because we never return. */
157 fputs_unfiltered (current_token
, mi
->raw_stdout
);
158 fputs_unfiltered ("^exit\n", mi
->raw_stdout
);
159 mi_out_put (current_uiout
, mi
->raw_stdout
);
160 gdb_flush (mi
->raw_stdout
);
161 /* FIXME: The function called is not yet a formal libgdb function. */
162 quit_force (NULL
, FROM_TTY
);
166 mi_cmd_exec_next (const char *command
, char **argv
, int argc
)
168 /* FIXME: Should call a libgdb function, not a cli wrapper. */
169 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
170 mi_execute_async_cli_command ("reverse-next", argv
+ 1, argc
- 1);
172 mi_execute_async_cli_command ("next", argv
, argc
);
176 mi_cmd_exec_next_instruction (const char *command
, char **argv
, int argc
)
178 /* FIXME: Should call a libgdb function, not a cli wrapper. */
179 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
180 mi_execute_async_cli_command ("reverse-nexti", argv
+ 1, argc
- 1);
182 mi_execute_async_cli_command ("nexti", argv
, argc
);
186 mi_cmd_exec_step (const char *command
, char **argv
, int argc
)
188 /* FIXME: Should call a libgdb function, not a cli wrapper. */
189 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
190 mi_execute_async_cli_command ("reverse-step", argv
+ 1, argc
- 1);
192 mi_execute_async_cli_command ("step", argv
, argc
);
196 mi_cmd_exec_step_instruction (const char *command
, char **argv
, int argc
)
198 /* FIXME: Should call a libgdb function, not a cli wrapper. */
199 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
200 mi_execute_async_cli_command ("reverse-stepi", argv
+ 1, argc
- 1);
202 mi_execute_async_cli_command ("stepi", argv
, argc
);
206 mi_cmd_exec_finish (const char *command
, char **argv
, int argc
)
208 /* FIXME: Should call a libgdb function, not a cli wrapper. */
209 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
210 mi_execute_async_cli_command ("reverse-finish", argv
+ 1, argc
- 1);
212 mi_execute_async_cli_command ("finish", argv
, argc
);
216 mi_cmd_exec_return (const char *command
, char **argv
, int argc
)
218 /* This command doesn't really execute the target, it just pops the
219 specified number of frames. */
221 /* Call return_command with from_tty argument equal to 0 so as to
222 avoid being queried. */
223 return_command (*argv
, 0);
225 /* Call return_command with from_tty argument equal to 0 so as to
226 avoid being queried. */
227 return_command (NULL
, 0);
229 /* Because we have called return_command with from_tty = 0, we need
230 to print the frame here. */
231 print_stack_frame (get_selected_frame (NULL
), 1, LOC_AND_ADDRESS
, 1);
235 mi_cmd_exec_jump (const char *args
, char **argv
, int argc
)
237 /* FIXME: Should call a libgdb function, not a cli wrapper. */
238 mi_execute_async_cli_command ("jump", argv
, argc
);
242 proceed_thread (struct thread_info
*thread
, int pid
)
244 if (thread
->state
!= THREAD_STOPPED
)
247 if (pid
!= 0 && thread
->ptid
.pid () != pid
)
250 switch_to_thread (thread
);
251 clear_proceed_status (0);
252 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
);
256 proceed_thread_callback (struct thread_info
*thread
, void *arg
)
258 int pid
= *(int *)arg
;
260 proceed_thread (thread
, pid
);
265 exec_continue (char **argv
, int argc
)
267 prepare_execution_command (current_top_target (), mi_async_p ());
271 /* In non-stop mode, 'resume' always resumes a single thread.
272 Therefore, to resume all threads of the current inferior, or
273 all threads in all inferiors, we need to iterate over
276 See comment on infcmd.c:proceed_thread_callback for rationale. */
277 if (current_context
->all
|| current_context
->thread_group
!= -1)
279 scoped_restore_current_thread restore_thread
;
282 if (!current_context
->all
)
285 = find_inferior_id (current_context
->thread_group
);
289 iterate_over_threads (proceed_thread_callback
, &pid
);
298 scoped_restore save_multi
= make_scoped_restore (&sched_multi
);
300 if (current_context
->all
)
307 /* In all-stop mode, -exec-continue traditionally resumed
308 either all threads, or one thread, depending on the
309 'scheduler-locking' variable. Let's continue to do the
317 exec_reverse_continue (char **argv
, int argc
)
319 enum exec_direction_kind dir
= execution_direction
;
321 if (dir
== EXEC_REVERSE
)
322 error (_("Already in reverse mode."));
324 if (!target_can_execute_reverse
)
325 error (_("Target %s does not support this command."), target_shortname
);
327 scoped_restore save_exec_dir
= make_scoped_restore (&execution_direction
,
329 exec_continue (argv
, argc
);
333 mi_cmd_exec_continue (const char *command
, char **argv
, int argc
)
335 if (argc
> 0 && strcmp (argv
[0], "--reverse") == 0)
336 exec_reverse_continue (argv
+ 1, argc
- 1);
338 exec_continue (argv
, argc
);
342 interrupt_thread_callback (struct thread_info
*thread
, void *arg
)
344 int pid
= *(int *)arg
;
346 if (thread
->state
!= THREAD_RUNNING
)
349 if (thread
->ptid
.pid () != pid
)
352 target_stop (thread
->ptid
);
356 /* Interrupt the execution of the target. Note how we must play
357 around with the token variables, in order to display the current
358 token in the result of the interrupt command, and the previous
359 execution token when the target finally stops. See comments in
363 mi_cmd_exec_interrupt (const char *command
, char **argv
, int argc
)
365 /* In all-stop mode, everything stops, so we don't need to try
366 anything specific. */
369 interrupt_target_1 (0);
373 if (current_context
->all
)
375 /* This will interrupt all threads in all inferiors. */
376 interrupt_target_1 (1);
378 else if (current_context
->thread_group
!= -1)
380 struct inferior
*inf
= find_inferior_id (current_context
->thread_group
);
382 iterate_over_threads (interrupt_thread_callback
, &inf
->pid
);
386 /* Interrupt just the current thread -- either explicitly
387 specified via --thread or whatever was current before
388 MI command was sent. */
389 interrupt_target_1 (0);
393 /* Callback for iterate_over_inferiors which starts the execution
394 of the given inferior.
396 ARG is a pointer to an integer whose value, if non-zero, indicates
397 that the program should be stopped when reaching the main subprogram
398 (similar to what the CLI "start" command does). */
401 run_one_inferior (struct inferior
*inf
, void *arg
)
403 int start_p
= *(int *) arg
;
404 const char *run_cmd
= start_p
? "start" : "run";
405 struct target_ops
*run_target
= find_run_target ();
406 int async_p
= mi_async
&& run_target
->can_async_p ();
410 thread_info
*tp
= any_thread_of_inferior (inf
);
412 error (_("Inferior has no threads."));
414 switch_to_thread (tp
);
418 set_current_inferior (inf
);
419 switch_to_no_thread ();
420 set_current_program_space (inf
->pspace
);
422 mi_execute_cli_command (run_cmd
, async_p
,
423 async_p
? "&" : NULL
);
428 mi_cmd_exec_run (const char *command
, char **argv
, int argc
)
432 /* Parse the command options. */
437 static const struct mi_opt opts
[] =
439 {"-start", START_OPT
, 0},
448 int opt
= mi_getopt ("-exec-run", argc
, argv
, opts
, &oind
, &oarg
);
452 switch ((enum opt
) opt
)
460 /* This command does not accept any argument. Make sure the user
461 did not provide any. */
463 error (_("Invalid argument: %s"), argv
[oind
]);
465 if (current_context
->all
)
467 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
469 iterate_over_inferiors (run_one_inferior
, &start_p
);
473 const char *run_cmd
= start_p
? "start" : "run";
474 struct target_ops
*run_target
= find_run_target ();
475 int async_p
= mi_async
&& run_target
->can_async_p ();
477 mi_execute_cli_command (run_cmd
, async_p
,
478 async_p
? "&" : NULL
);
484 find_thread_of_process (struct thread_info
*ti
, void *p
)
488 if (ti
->ptid
.pid () == pid
&& ti
->state
!= THREAD_EXITED
)
495 mi_cmd_target_detach (const char *command
, char **argv
, int argc
)
497 if (argc
!= 0 && argc
!= 1)
498 error (_("Usage: -target-detach [pid | thread-group]"));
502 struct thread_info
*tp
;
506 /* First see if we are dealing with a thread-group id. */
509 struct inferior
*inf
;
510 int id
= strtoul (argv
[0] + 1, &end
, 0);
513 error (_("Invalid syntax of thread-group id '%s'"), argv
[0]);
515 inf
= find_inferior_id (id
);
517 error (_("Non-existent thread-group id '%d'"), id
);
523 /* We must be dealing with a pid. */
524 pid
= strtol (argv
[0], &end
, 10);
527 error (_("Invalid identifier '%s'"), argv
[0]);
530 /* Pick any thread in the desired process. Current
531 target_detach detaches from the parent of inferior_ptid. */
532 tp
= iterate_over_threads (find_thread_of_process
, &pid
);
534 error (_("Thread group is empty"));
536 switch_to_thread (tp
);
539 detach_command (NULL
, 0);
543 mi_cmd_target_flash_erase (const char *command
, char **argv
, int argc
)
545 flash_erase_command (NULL
, 0);
549 mi_cmd_thread_select (const char *command
, char **argv
, int argc
)
552 error (_("-thread-select: USAGE: threadnum."));
554 int num
= value_as_long (parse_and_eval (argv
[0]));
555 thread_info
*thr
= find_thread_global_id (num
);
557 error (_("Thread ID %d not known."), num
);
559 ptid_t previous_ptid
= inferior_ptid
;
561 thread_select (argv
[0], thr
);
563 print_selected_thread_frame (current_uiout
,
564 USER_SELECTED_THREAD
| USER_SELECTED_FRAME
);
566 /* Notify if the thread has effectively changed. */
567 if (inferior_ptid
!= previous_ptid
)
569 gdb::observers::user_selected_context_changed
.notify
570 (USER_SELECTED_THREAD
| USER_SELECTED_FRAME
);
575 mi_cmd_thread_list_ids (const char *command
, char **argv
, int argc
)
578 error (_("-thread-list-ids: No arguments required."));
581 int current_thread
= -1;
583 update_thread_list ();
586 ui_out_emit_tuple
tuple_emitter (current_uiout
, "thread-ids");
588 for (thread_info
*tp
: all_non_exited_threads ())
590 if (tp
->ptid
== inferior_ptid
)
591 current_thread
= tp
->global_num
;
594 current_uiout
->field_signed ("thread-id", tp
->global_num
);
598 if (current_thread
!= -1)
599 current_uiout
->field_signed ("current-thread-id", current_thread
);
600 current_uiout
->field_signed ("number-of-threads", num
);
604 mi_cmd_thread_info (const char *command
, char **argv
, int argc
)
606 if (argc
!= 0 && argc
!= 1)
607 error (_("Invalid MI command"));
609 print_thread_info (current_uiout
, argv
[0], -1);
612 struct collect_cores_data
619 collect_cores (struct thread_info
*ti
, void *xdata
)
621 struct collect_cores_data
*data
= (struct collect_cores_data
*) xdata
;
623 if (ti
->ptid
.pid () == data
->pid
)
625 int core
= target_core_of_thread (ti
->ptid
);
628 data
->cores
.insert (core
);
634 struct print_one_inferior_data
637 const std::set
<int> *inferiors
;
641 print_one_inferior (struct inferior
*inferior
, void *xdata
)
643 struct print_one_inferior_data
*top_data
644 = (struct print_one_inferior_data
*) xdata
;
645 struct ui_out
*uiout
= current_uiout
;
647 if (top_data
->inferiors
->empty ()
648 || (top_data
->inferiors
->find (inferior
->pid
)
649 != top_data
->inferiors
->end ()))
651 struct collect_cores_data data
;
652 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
654 uiout
->field_fmt ("id", "i%d", inferior
->num
);
655 uiout
->field_string ("type", "process");
656 if (inferior
->has_exit_code
)
657 uiout
->field_string ("exit-code",
658 int_string (inferior
->exit_code
, 8, 0, 0, 1));
659 if (inferior
->pid
!= 0)
660 uiout
->field_signed ("pid", inferior
->pid
);
662 if (inferior
->pspace
->pspace_exec_filename
!= NULL
)
664 uiout
->field_string ("executable",
665 inferior
->pspace
->pspace_exec_filename
);
668 if (inferior
->pid
!= 0)
670 data
.pid
= inferior
->pid
;
671 iterate_over_threads (collect_cores
, &data
);
674 if (!data
.cores
.empty ())
676 ui_out_emit_list
list_emitter (uiout
, "cores");
678 for (int b
: data
.cores
)
679 uiout
->field_signed (NULL
, b
);
682 if (top_data
->recurse
)
683 print_thread_info (uiout
, NULL
, inferior
->pid
);
689 /* Output a field named 'cores' with a list as the value. The
690 elements of the list are obtained by splitting 'cores' on
694 output_cores (struct ui_out
*uiout
, const char *field_name
, const char *xcores
)
696 ui_out_emit_list
list_emitter (uiout
, field_name
);
697 auto cores
= make_unique_xstrdup (xcores
);
698 char *p
= cores
.get ();
700 for (p
= strtok (p
, ","); p
; p
= strtok (NULL
, ","))
701 uiout
->field_string (NULL
, p
);
705 list_available_thread_groups (const std::set
<int> &ids
, int recurse
)
707 struct ui_out
*uiout
= current_uiout
;
709 /* This keeps a map from integer (pid) to vector of struct osdata_item.
710 The vector contains information about all threads for the given pid. */
711 std::map
<int, std::vector
<osdata_item
>> tree
;
713 /* get_osdata will throw if it cannot return data. */
714 std::unique_ptr
<osdata
> data
= get_osdata ("processes");
718 std::unique_ptr
<osdata
> threads
= get_osdata ("threads");
720 for (const osdata_item
&item
: threads
->items
)
722 const std::string
*pid
= get_osdata_column (item
, "pid");
723 int pid_i
= strtoul (pid
->c_str (), NULL
, 0);
725 tree
[pid_i
].push_back (item
);
729 ui_out_emit_list
list_emitter (uiout
, "groups");
731 for (const osdata_item
&item
: data
->items
)
733 const std::string
*pid
= get_osdata_column (item
, "pid");
734 const std::string
*cmd
= get_osdata_column (item
, "command");
735 const std::string
*user
= get_osdata_column (item
, "user");
736 const std::string
*cores
= get_osdata_column (item
, "cores");
738 int pid_i
= strtoul (pid
->c_str (), NULL
, 0);
740 /* At present, the target will return all available processes
741 and if information about specific ones was required, we filter
742 undesired processes here. */
743 if (!ids
.empty () && ids
.find (pid_i
) == ids
.end ())
746 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
748 uiout
->field_string ("id", pid
->c_str ());
749 uiout
->field_string ("type", "process");
751 uiout
->field_string ("description", cmd
->c_str ());
753 uiout
->field_string ("user", user
->c_str ());
755 output_cores (uiout
, "cores", cores
->c_str ());
759 auto n
= tree
.find (pid_i
);
760 if (n
!= tree
.end ())
762 std::vector
<osdata_item
> &children
= n
->second
;
764 ui_out_emit_list
thread_list_emitter (uiout
, "threads");
766 for (const osdata_item
&child
: children
)
768 ui_out_emit_tuple
inner_tuple_emitter (uiout
, NULL
);
769 const std::string
*tid
= get_osdata_column (child
, "tid");
770 const std::string
*tcore
= get_osdata_column (child
, "core");
772 uiout
->field_string ("id", tid
->c_str ());
774 uiout
->field_string ("core", tcore
->c_str ());
782 mi_cmd_list_thread_groups (const char *command
, char **argv
, int argc
)
784 struct ui_out
*uiout
= current_uiout
;
791 AVAILABLE_OPT
, RECURSE_OPT
793 static const struct mi_opt opts
[] =
795 {"-available", AVAILABLE_OPT
, 0},
796 {"-recurse", RECURSE_OPT
, 1},
805 int opt
= mi_getopt ("-list-thread-groups", argc
, argv
, opts
,
810 switch ((enum opt
) opt
)
816 if (strcmp (oarg
, "0") == 0)
818 else if (strcmp (oarg
, "1") == 0)
821 error (_("only '0' and '1' are valid values "
822 "for the '--recurse' option"));
827 for (; oind
< argc
; ++oind
)
832 if (*(argv
[oind
]) != 'i')
833 error (_("invalid syntax of group id '%s'"), argv
[oind
]);
835 inf
= strtoul (argv
[oind
] + 1, &end
, 0);
838 error (_("invalid syntax of group id '%s'"), argv
[oind
]);
844 list_available_thread_groups (ids
, recurse
);
846 else if (ids
.size () == 1)
848 /* Local thread groups, single id. */
849 int id
= *(ids
.begin ());
850 struct inferior
*inf
= find_inferior_id (id
);
853 error (_("Non-existent thread group id '%d'"), id
);
855 print_thread_info (uiout
, NULL
, inf
->pid
);
859 struct print_one_inferior_data data
;
861 data
.recurse
= recurse
;
862 data
.inferiors
= &ids
;
864 /* Local thread groups. Either no explicit ids -- and we
865 print everything, or several explicit ids. In both cases,
866 we print more than one group, and have to use 'groups'
867 as the top-level element. */
868 ui_out_emit_list
list_emitter (uiout
, "groups");
869 update_thread_list ();
870 iterate_over_inferiors (print_one_inferior
, &data
);
875 mi_cmd_data_list_register_names (const char *command
, char **argv
, int argc
)
877 struct gdbarch
*gdbarch
;
878 struct ui_out
*uiout
= current_uiout
;
882 /* Note that the test for a valid register must include checking the
883 gdbarch_register_name because gdbarch_num_regs may be allocated
884 for the union of the register sets within a family of related
885 processors. In this case, some entries of gdbarch_register_name
886 will change depending upon the particular processor being
889 gdbarch
= get_current_arch ();
890 numregs
= gdbarch_num_cooked_regs (gdbarch
);
892 ui_out_emit_list
list_emitter (uiout
, "register-names");
894 if (argc
== 0) /* No args, just do all the regs. */
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
));
908 /* Else, list of register #s, just do listed regs. */
909 for (i
= 0; i
< argc
; i
++)
911 regnum
= atoi (argv
[i
]);
912 if (regnum
< 0 || regnum
>= numregs
)
913 error (_("bad register number"));
915 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
916 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
917 uiout
->field_string (NULL
, "");
919 uiout
->field_string (NULL
, gdbarch_register_name (gdbarch
, regnum
));
924 mi_cmd_data_list_changed_registers (const char *command
, char **argv
, int argc
)
926 static std::unique_ptr
<readonly_detached_regcache
> this_regs
;
927 struct ui_out
*uiout
= current_uiout
;
928 std::unique_ptr
<readonly_detached_regcache
> prev_regs
;
929 struct gdbarch
*gdbarch
;
933 /* The last time we visited this function, the current frame's
934 register contents were saved in THIS_REGS. Move THIS_REGS over
935 to PREV_REGS, and refresh THIS_REGS with the now-current register
938 prev_regs
= std::move (this_regs
);
939 this_regs
= frame_save_as_regcache (get_selected_frame (NULL
));
941 /* Note that the test for a valid register must include checking the
942 gdbarch_register_name because gdbarch_num_regs may be allocated
943 for the union of the register sets within a family of related
944 processors. In this case, some entries of gdbarch_register_name
945 will change depending upon the particular processor being
948 gdbarch
= this_regs
->arch ();
949 numregs
= gdbarch_num_cooked_regs (gdbarch
);
951 ui_out_emit_list
list_emitter (uiout
, "changed-registers");
955 /* No args, just do all the regs. */
960 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
961 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
964 if (register_changed_p (regnum
, prev_regs
.get (),
966 uiout
->field_signed (NULL
, regnum
);
970 /* Else, list of register #s, just do listed regs. */
971 for (i
= 0; i
< argc
; i
++)
973 regnum
= atoi (argv
[i
]);
977 && gdbarch_register_name (gdbarch
, regnum
) != NULL
978 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
980 if (register_changed_p (regnum
, prev_regs
.get (),
982 uiout
->field_signed (NULL
, regnum
);
985 error (_("bad register number"));
990 register_changed_p (int regnum
, readonly_detached_regcache
*prev_regs
,
991 readonly_detached_regcache
*this_regs
)
993 struct gdbarch
*gdbarch
= this_regs
->arch ();
994 struct value
*prev_value
, *this_value
;
996 /* First time through or after gdbarch change consider all registers
998 if (!prev_regs
|| prev_regs
->arch () != gdbarch
)
1001 /* Get register contents and compare. */
1002 prev_value
= prev_regs
->cooked_read_value (regnum
);
1003 this_value
= this_regs
->cooked_read_value (regnum
);
1004 gdb_assert (prev_value
!= NULL
);
1005 gdb_assert (this_value
!= NULL
);
1007 auto ret
= !value_contents_eq (prev_value
, 0, this_value
, 0,
1008 register_size (gdbarch
, regnum
));
1010 release_value (prev_value
);
1011 release_value (this_value
);
1015 /* Return a list of register number and value pairs. The valid
1016 arguments expected are: a letter indicating the format in which to
1017 display the registers contents. This can be one of: x
1018 (hexadecimal), d (decimal), N (natural), t (binary), o (octal), r
1019 (raw). After the format argument there can be a sequence of
1020 numbers, indicating which registers to fetch the content of. If
1021 the format is the only argument, a list of all the registers with
1022 their values is returned. */
1025 mi_cmd_data_list_register_values (const char *command
, char **argv
, int argc
)
1027 struct ui_out
*uiout
= current_uiout
;
1028 struct frame_info
*frame
;
1029 struct gdbarch
*gdbarch
;
1030 int regnum
, numregs
, format
;
1032 int skip_unavailable
= 0;
1038 static const struct mi_opt opts
[] =
1040 {"-skip-unavailable", SKIP_UNAVAILABLE
, 0},
1044 /* Note that the test for a valid register must include checking the
1045 gdbarch_register_name because gdbarch_num_regs may be allocated
1046 for the union of the register sets within a family of related
1047 processors. In this case, some entries of gdbarch_register_name
1048 will change depending upon the particular processor being
1054 int opt
= mi_getopt ("-data-list-register-values", argc
, argv
,
1055 opts
, &oind
, &oarg
);
1059 switch ((enum opt
) opt
)
1061 case SKIP_UNAVAILABLE
:
1062 skip_unavailable
= 1;
1067 if (argc
- oind
< 1)
1068 error (_("-data-list-register-values: Usage: "
1069 "-data-list-register-values [--skip-unavailable] <format>"
1070 " [<regnum1>...<regnumN>]"));
1072 format
= (int) argv
[oind
][0];
1074 frame
= get_selected_frame (NULL
);
1075 gdbarch
= get_frame_arch (frame
);
1076 numregs
= gdbarch_num_cooked_regs (gdbarch
);
1078 ui_out_emit_list
list_emitter (uiout
, "register-values");
1080 if (argc
- oind
== 1)
1082 /* No args, beside the format: do all the regs. */
1087 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1088 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1091 output_register (frame
, regnum
, format
, skip_unavailable
);
1095 /* Else, list of register #s, just do listed regs. */
1096 for (i
= 1 + oind
; i
< argc
; i
++)
1098 regnum
= atoi (argv
[i
]);
1102 && gdbarch_register_name (gdbarch
, regnum
) != NULL
1103 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
1104 output_register (frame
, regnum
, format
, skip_unavailable
);
1106 error (_("bad register number"));
1110 /* Output one register REGNUM's contents in the desired FORMAT. If
1111 SKIP_UNAVAILABLE is true, skip the register if it is
1115 output_register (struct frame_info
*frame
, int regnum
, int format
,
1116 int skip_unavailable
)
1118 struct ui_out
*uiout
= current_uiout
;
1119 struct value
*val
= value_of_register (regnum
, frame
);
1120 struct value_print_options opts
;
1122 if (skip_unavailable
&& !value_entirely_available (val
))
1125 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1126 uiout
->field_signed ("number", regnum
);
1136 get_formatted_print_options (&opts
, format
);
1138 val_print (value_type (val
),
1139 value_embedded_offset (val
), 0,
1140 &stb
, 0, val
, &opts
, current_language
);
1141 uiout
->field_stream ("value", stb
);
1144 /* Write given values into registers. The registers and values are
1145 given as pairs. The corresponding MI command is
1146 -data-write-register-values <format>
1147 [<regnum1> <value1>...<regnumN> <valueN>] */
1149 mi_cmd_data_write_register_values (const char *command
, char **argv
, int argc
)
1151 struct regcache
*regcache
;
1152 struct gdbarch
*gdbarch
;
1155 /* Note that the test for a valid register must include checking the
1156 gdbarch_register_name because gdbarch_num_regs may be allocated
1157 for the union of the register sets within a family of related
1158 processors. In this case, some entries of gdbarch_register_name
1159 will change depending upon the particular processor being
1162 regcache
= get_current_regcache ();
1163 gdbarch
= regcache
->arch ();
1164 numregs
= gdbarch_num_cooked_regs (gdbarch
);
1167 error (_("-data-write-register-values: Usage: -data-write-register-"
1168 "values <format> [<regnum1> <value1>...<regnumN> <valueN>]"));
1170 if (!target_has_registers
)
1171 error (_("-data-write-register-values: No registers."));
1174 error (_("-data-write-register-values: No regs and values specified."));
1177 error (_("-data-write-register-values: "
1178 "Regs and vals are not in pairs."));
1180 for (i
= 1; i
< argc
; i
= i
+ 2)
1182 int regnum
= atoi (argv
[i
]);
1184 if (regnum
>= 0 && regnum
< numregs
1185 && gdbarch_register_name (gdbarch
, regnum
)
1186 && *gdbarch_register_name (gdbarch
, regnum
))
1190 /* Get the value as a number. */
1191 value
= parse_and_eval_address (argv
[i
+ 1]);
1193 /* Write it down. */
1194 regcache_cooked_write_signed (regcache
, regnum
, value
);
1197 error (_("bad register number"));
1201 /* Evaluate the value of the argument. The argument is an
1202 expression. If the expression contains spaces it needs to be
1203 included in double quotes. */
1206 mi_cmd_data_evaluate_expression (const char *command
, char **argv
, int argc
)
1209 struct value_print_options opts
;
1210 struct ui_out
*uiout
= current_uiout
;
1213 error (_("-data-evaluate-expression: "
1214 "Usage: -data-evaluate-expression expression"));
1216 expression_up expr
= parse_expression (argv
[0]);
1218 val
= evaluate_expression (expr
.get ());
1222 /* Print the result of the expression evaluation. */
1223 get_user_print_options (&opts
);
1225 common_val_print (val
, &stb
, 0, &opts
, current_language
);
1227 uiout
->field_stream ("value", stb
);
1230 /* This is the -data-read-memory command.
1232 ADDR: start address of data to be dumped.
1233 WORD-FORMAT: a char indicating format for the ``word''. See
1235 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes.
1236 NR_ROW: Number of rows.
1237 NR_COL: The number of columns (words per row).
1238 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
1239 ASCHAR for unprintable characters.
1241 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
1242 displays them. Returns:
1244 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
1247 The number of bytes read is SIZE*ROW*COL. */
1250 mi_cmd_data_read_memory (const char *command
, char **argv
, int argc
)
1252 struct gdbarch
*gdbarch
= get_current_arch ();
1253 struct ui_out
*uiout
= current_uiout
;
1255 long total_bytes
, nr_cols
, nr_rows
;
1257 struct type
*word_type
;
1269 static const struct mi_opt opts
[] =
1271 {"o", OFFSET_OPT
, 1},
1277 int opt
= mi_getopt ("-data-read-memory", argc
, argv
, opts
,
1282 switch ((enum opt
) opt
)
1285 offset
= atol (oarg
);
1292 if (argc
< 5 || argc
> 6)
1293 error (_("-data-read-memory: Usage: "
1294 "ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR]."));
1296 /* Extract all the arguments. */
1298 /* Start address of the memory dump. */
1299 addr
= parse_and_eval_address (argv
[0]) + offset
;
1300 /* The format character to use when displaying a memory word. See
1301 the ``x'' command. */
1302 word_format
= argv
[1][0];
1303 /* The size of the memory word. */
1304 word_size
= atol (argv
[2]);
1308 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1312 word_type
= builtin_type (gdbarch
)->builtin_int16
;
1316 word_type
= builtin_type (gdbarch
)->builtin_int32
;
1320 word_type
= builtin_type (gdbarch
)->builtin_int64
;
1324 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1327 /* The number of rows. */
1328 nr_rows
= atol (argv
[3]);
1330 error (_("-data-read-memory: invalid number of rows."));
1332 /* Number of bytes per row. */
1333 nr_cols
= atol (argv
[4]);
1335 error (_("-data-read-memory: invalid number of columns."));
1337 /* The un-printable character when printing ascii. */
1343 /* Create a buffer and read it in. */
1344 total_bytes
= word_size
* nr_rows
* nr_cols
;
1346 gdb::byte_vector
mbuf (total_bytes
);
1348 nr_bytes
= target_read (current_top_target (), TARGET_OBJECT_MEMORY
, NULL
,
1349 mbuf
.data (), addr
, total_bytes
);
1351 error (_("Unable to read memory."));
1353 /* Output the header information. */
1354 uiout
->field_core_addr ("addr", gdbarch
, addr
);
1355 uiout
->field_signed ("nr-bytes", nr_bytes
);
1356 uiout
->field_signed ("total-bytes", total_bytes
);
1357 uiout
->field_core_addr ("next-row", gdbarch
, addr
+ word_size
* nr_cols
);
1358 uiout
->field_core_addr ("prev-row", gdbarch
, addr
- word_size
* nr_cols
);
1359 uiout
->field_core_addr ("next-page", gdbarch
, addr
+ total_bytes
);
1360 uiout
->field_core_addr ("prev-page", gdbarch
, addr
- total_bytes
);
1362 /* Build the result as a two dimensional table. */
1369 ui_out_emit_list
list_emitter (uiout
, "memory");
1370 for (row
= 0, row_byte
= 0;
1372 row
++, row_byte
+= nr_cols
* word_size
)
1376 struct value_print_options print_opts
;
1378 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1379 uiout
->field_core_addr ("addr", gdbarch
, addr
+ row_byte
);
1380 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr +
1383 ui_out_emit_list
list_data_emitter (uiout
, "data");
1384 get_formatted_print_options (&print_opts
, word_format
);
1385 for (col
= 0, col_byte
= row_byte
;
1387 col
++, col_byte
+= word_size
)
1389 if (col_byte
+ word_size
> nr_bytes
)
1391 uiout
->field_string (NULL
, "N/A");
1396 print_scalar_formatted (&mbuf
[col_byte
], word_type
,
1397 &print_opts
, word_asize
, &stream
);
1398 uiout
->field_stream (NULL
, stream
);
1408 for (byte
= row_byte
;
1409 byte
< row_byte
+ word_size
* nr_cols
; byte
++)
1411 if (byte
>= nr_bytes
)
1413 else if (mbuf
[byte
] < 32 || mbuf
[byte
] > 126)
1414 stream
.putc (aschar
);
1416 stream
.putc (mbuf
[byte
]);
1418 uiout
->field_stream ("ascii", stream
);
1425 mi_cmd_data_read_memory_bytes (const char *command
, char **argv
, int argc
)
1427 struct gdbarch
*gdbarch
= get_current_arch ();
1428 struct ui_out
*uiout
= current_uiout
;
1432 int unit_size
= gdbarch_addressable_memory_unit_size (gdbarch
);
1439 static const struct mi_opt opts
[] =
1441 {"o", OFFSET_OPT
, 1},
1447 int opt
= mi_getopt ("-data-read-memory-bytes", argc
, argv
, opts
,
1451 switch ((enum opt
) opt
)
1454 offset
= atol (oarg
);
1462 error (_("Usage: [ -o OFFSET ] ADDR LENGTH."));
1464 addr
= parse_and_eval_address (argv
[0]) + offset
;
1465 length
= atol (argv
[1]);
1467 std::vector
<memory_read_result
> result
1468 = read_memory_robust (current_top_target (), addr
, length
);
1470 if (result
.size () == 0)
1471 error (_("Unable to read memory."));
1473 ui_out_emit_list
list_emitter (uiout
, "memory");
1474 for (const memory_read_result
&read_result
: result
)
1476 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1478 uiout
->field_core_addr ("begin", gdbarch
, read_result
.begin
);
1479 uiout
->field_core_addr ("offset", gdbarch
, read_result
.begin
- addr
);
1480 uiout
->field_core_addr ("end", gdbarch
, read_result
.end
);
1482 std::string data
= bin2hex (read_result
.data
.get (),
1483 (read_result
.end
- read_result
.begin
)
1485 uiout
->field_string ("contents", data
.c_str ());
1489 /* Implementation of the -data-write_memory command.
1491 COLUMN_OFFSET: optional argument. Must be preceded by '-o'. The
1492 offset from the beginning of the memory grid row where the cell to
1494 ADDR: start address of the row in the memory grid where the memory
1495 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
1496 the location to write to.
1497 FORMAT: a char indicating format for the ``word''. See
1499 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
1500 VALUE: value to be written into the memory address.
1502 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
1507 mi_cmd_data_write_memory (const char *command
, char **argv
, int argc
)
1509 struct gdbarch
*gdbarch
= get_current_arch ();
1510 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1513 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
1514 enough when using a compiler other than GCC. */
1523 static const struct mi_opt opts
[] =
1525 {"o", OFFSET_OPT
, 1},
1531 int opt
= mi_getopt ("-data-write-memory", argc
, argv
, opts
,
1536 switch ((enum opt
) opt
)
1539 offset
= atol (oarg
);
1547 error (_("-data-write-memory: Usage: "
1548 "[-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE."));
1550 /* Extract all the arguments. */
1551 /* Start address of the memory dump. */
1552 addr
= parse_and_eval_address (argv
[0]);
1553 /* The size of the memory word. */
1554 word_size
= atol (argv
[2]);
1556 /* Calculate the real address of the write destination. */
1557 addr
+= (offset
* word_size
);
1559 /* Get the value as a number. */
1560 value
= parse_and_eval_address (argv
[3]);
1561 /* Get the value into an array. */
1562 gdb::byte_vector
buffer (word_size
);
1563 store_signed_integer (buffer
.data (), word_size
, byte_order
, value
);
1564 /* Write it down to memory. */
1565 write_memory_with_notification (addr
, buffer
.data (), word_size
);
1568 /* Implementation of the -data-write-memory-bytes command.
1571 DATA: string of bytes to write at that address
1572 COUNT: number of bytes to be filled (decimal integer). */
1575 mi_cmd_data_write_memory_bytes (const char *command
, char **argv
, int argc
)
1579 size_t len_hex
, len_bytes
, len_units
, i
, steps
, remaining_units
;
1580 long int count_units
;
1583 if (argc
!= 2 && argc
!= 3)
1584 error (_("Usage: ADDR DATA [COUNT]."));
1586 addr
= parse_and_eval_address (argv
[0]);
1588 len_hex
= strlen (cdata
);
1589 unit_size
= gdbarch_addressable_memory_unit_size (get_current_arch ());
1591 if (len_hex
% (unit_size
* 2) != 0)
1592 error (_("Hex-encoded '%s' must represent an integral number of "
1593 "addressable memory units."),
1596 len_bytes
= len_hex
/ 2;
1597 len_units
= len_bytes
/ unit_size
;
1600 count_units
= strtoul (argv
[2], NULL
, 10);
1602 count_units
= len_units
;
1604 gdb::byte_vector
databuf (len_bytes
);
1606 for (i
= 0; i
< len_bytes
; ++i
)
1609 if (sscanf (cdata
+ i
* 2, "%02x", &x
) != 1)
1610 error (_("Invalid argument"));
1611 databuf
[i
] = (gdb_byte
) x
;
1614 gdb::byte_vector data
;
1615 if (len_units
< count_units
)
1617 /* Pattern is made of less units than count:
1618 repeat pattern to fill memory. */
1619 data
= gdb::byte_vector (count_units
* unit_size
);
1621 /* Number of times the pattern is entirely repeated. */
1622 steps
= count_units
/ len_units
;
1623 /* Number of remaining addressable memory units. */
1624 remaining_units
= count_units
% len_units
;
1625 for (i
= 0; i
< steps
; i
++)
1626 memcpy (&data
[i
* len_bytes
], &databuf
[0], len_bytes
);
1628 if (remaining_units
> 0)
1629 memcpy (&data
[steps
* len_bytes
], &databuf
[0],
1630 remaining_units
* unit_size
);
1634 /* Pattern is longer than or equal to count:
1635 just copy count addressable memory units. */
1636 data
= std::move (databuf
);
1639 write_memory_with_notification (addr
, data
.data (), count_units
);
1643 mi_cmd_enable_timings (const char *command
, char **argv
, int argc
)
1649 if (strcmp (argv
[0], "yes") == 0)
1651 else if (strcmp (argv
[0], "no") == 0)
1662 error (_("-enable-timings: Usage: %s {yes|no}"), command
);
1666 mi_cmd_list_features (const char *command
, char **argv
, int argc
)
1670 struct ui_out
*uiout
= current_uiout
;
1672 ui_out_emit_list
list_emitter (uiout
, "features");
1673 uiout
->field_string (NULL
, "frozen-varobjs");
1674 uiout
->field_string (NULL
, "pending-breakpoints");
1675 uiout
->field_string (NULL
, "thread-info");
1676 uiout
->field_string (NULL
, "data-read-memory-bytes");
1677 uiout
->field_string (NULL
, "breakpoint-notifications");
1678 uiout
->field_string (NULL
, "ada-task-info");
1679 uiout
->field_string (NULL
, "language-option");
1680 uiout
->field_string (NULL
, "info-gdb-mi-command");
1681 uiout
->field_string (NULL
, "undefined-command-error-code");
1682 uiout
->field_string (NULL
, "exec-run-start-option");
1683 uiout
->field_string (NULL
, "data-disassemble-a-option");
1685 if (ext_lang_initialized_p (get_ext_lang_defn (EXT_LANG_PYTHON
)))
1686 uiout
->field_string (NULL
, "python");
1691 error (_("-list-features should be passed no arguments"));
1695 mi_cmd_list_target_features (const char *command
, char **argv
, int argc
)
1699 struct ui_out
*uiout
= current_uiout
;
1701 ui_out_emit_list
list_emitter (uiout
, "features");
1703 uiout
->field_string (NULL
, "async");
1704 if (target_can_execute_reverse
)
1705 uiout
->field_string (NULL
, "reverse");
1709 error (_("-list-target-features should be passed no arguments"));
1713 mi_cmd_add_inferior (const char *command
, char **argv
, int argc
)
1715 struct inferior
*inf
;
1718 error (_("-add-inferior should be passed no arguments"));
1720 inf
= add_inferior_with_spaces ();
1722 current_uiout
->field_fmt ("inferior", "i%d", inf
->num
);
1725 /* Callback used to find the first inferior other than the current
1729 get_other_inferior (struct inferior
*inf
, void *arg
)
1731 if (inf
== current_inferior ())
1738 mi_cmd_remove_inferior (const char *command
, char **argv
, int argc
)
1741 struct inferior
*inf
;
1744 error (_("-remove-inferior should be passed a single argument"));
1746 if (sscanf (argv
[0], "i%d", &id
) != 1)
1747 error (_("the thread group id is syntactically invalid"));
1749 inf
= find_inferior_id (id
);
1751 error (_("the specified thread group does not exist"));
1754 error (_("cannot remove an active inferior"));
1756 if (inf
== current_inferior ())
1758 struct thread_info
*tp
= 0;
1759 struct inferior
*new_inferior
1760 = iterate_over_inferiors (get_other_inferior
, NULL
);
1762 if (new_inferior
== NULL
)
1763 error (_("Cannot remove last inferior"));
1765 set_current_inferior (new_inferior
);
1766 if (new_inferior
->pid
!= 0)
1767 tp
= any_thread_of_inferior (new_inferior
);
1769 switch_to_thread (tp
);
1771 switch_to_no_thread ();
1772 set_current_program_space (new_inferior
->pspace
);
1775 delete_inferior (inf
);
1780 /* Execute a command within a safe environment.
1781 Return <0 for error; >=0 for ok.
1783 args->action will tell mi_execute_command what action
1784 to perform after the given command has executed (display/suppress
1785 prompt, display error). */
1788 captured_mi_execute_command (struct ui_out
*uiout
, struct mi_parse
*context
)
1790 struct mi_interp
*mi
= (struct mi_interp
*) command_interp ();
1793 current_command_ts
= context
->cmd_start
;
1795 scoped_restore save_token
= make_scoped_restore (¤t_token
,
1798 running_result_record_printed
= 0;
1800 switch (context
->op
)
1803 /* A MI command was read from the input stream. */
1805 /* FIXME: gdb_???? */
1806 fprintf_unfiltered (mi
->raw_stdout
,
1807 " token=`%s' command=`%s' args=`%s'\n",
1808 context
->token
, context
->command
, context
->args
);
1810 mi_cmd_execute (context
);
1812 /* Print the result if there were no errors.
1814 Remember that on the way out of executing a command, you have
1815 to directly use the mi_interp's uiout, since the command
1816 could have reset the interpreter, in which case the current
1817 uiout will most likely crash in the mi_out_* routines. */
1818 if (!running_result_record_printed
)
1820 fputs_unfiltered (context
->token
, mi
->raw_stdout
);
1821 /* There's no particularly good reason why target-connect results
1822 in not ^done. Should kill ^connected for MI3. */
1823 fputs_unfiltered (strcmp (context
->command
, "target-select") == 0
1824 ? "^connected" : "^done", mi
->raw_stdout
);
1825 mi_out_put (uiout
, mi
->raw_stdout
);
1826 mi_out_rewind (uiout
);
1827 mi_print_timing_maybe (mi
->raw_stdout
);
1828 fputs_unfiltered ("\n", mi
->raw_stdout
);
1831 /* The command does not want anything to be printed. In that
1832 case, the command probably should not have written anything
1833 to uiout, but in case it has written something, discard it. */
1834 mi_out_rewind (uiout
);
1841 /* A CLI command was read from the input stream. */
1842 /* This "feature" will be removed as soon as we have a
1843 complete set of mi commands. */
1844 /* Echo the command on the console. */
1845 fprintf_unfiltered (gdb_stdlog
, "%s\n", context
->command
);
1846 /* Call the "console" interpreter. */
1847 argv
[0] = (char *) INTERP_CONSOLE
;
1848 argv
[1] = context
->command
;
1849 mi_cmd_interpreter_exec ("-interpreter-exec", argv
, 2);
1851 /* If we changed interpreters, DON'T print out anything. */
1852 if (current_interp_named_p (INTERP_MI
)
1853 || current_interp_named_p (INTERP_MI1
)
1854 || current_interp_named_p (INTERP_MI2
)
1855 || current_interp_named_p (INTERP_MI3
))
1857 if (!running_result_record_printed
)
1859 fputs_unfiltered (context
->token
, mi
->raw_stdout
);
1860 fputs_unfiltered ("^done", mi
->raw_stdout
);
1861 mi_out_put (uiout
, mi
->raw_stdout
);
1862 mi_out_rewind (uiout
);
1863 mi_print_timing_maybe (mi
->raw_stdout
);
1864 fputs_unfiltered ("\n", mi
->raw_stdout
);
1867 mi_out_rewind (uiout
);
1874 /* Print a gdb exception to the MI output stream. */
1877 mi_print_exception (const char *token
, const struct gdb_exception
&exception
)
1879 struct mi_interp
*mi
= (struct mi_interp
*) current_interpreter ();
1881 fputs_unfiltered (token
, mi
->raw_stdout
);
1882 fputs_unfiltered ("^error,msg=\"", mi
->raw_stdout
);
1883 if (exception
.message
== NULL
)
1884 fputs_unfiltered ("unknown error", mi
->raw_stdout
);
1886 fputstr_unfiltered (exception
.what (), '"', mi
->raw_stdout
);
1887 fputs_unfiltered ("\"", mi
->raw_stdout
);
1889 switch (exception
.error
)
1891 case UNDEFINED_COMMAND_ERROR
:
1892 fputs_unfiltered (",code=\"undefined-command\"", mi
->raw_stdout
);
1896 fputs_unfiltered ("\n", mi
->raw_stdout
);
1899 /* Determine whether the parsed command already notifies the
1900 user_selected_context_changed observer. */
1903 command_notifies_uscc_observer (struct mi_parse
*command
)
1905 if (command
->op
== CLI_COMMAND
)
1907 /* CLI commands "thread" and "inferior" already send it. */
1908 return (strncmp (command
->command
, "thread ", 7) == 0
1909 || strncmp (command
->command
, "inferior ", 9) == 0);
1911 else /* MI_COMMAND */
1913 if (strcmp (command
->command
, "interpreter-exec") == 0
1914 && command
->argc
> 1)
1916 /* "thread" and "inferior" again, but through -interpreter-exec. */
1917 return (strncmp (command
->argv
[1], "thread ", 7) == 0
1918 || strncmp (command
->argv
[1], "inferior ", 9) == 0);
1922 /* -thread-select already sends it. */
1923 return strcmp (command
->command
, "thread-select") == 0;
1928 mi_execute_command (const char *cmd
, int from_tty
)
1931 std::unique_ptr
<struct mi_parse
> command
;
1933 /* This is to handle EOF (^D). We just quit gdb. */
1934 /* FIXME: we should call some API function here. */
1936 quit_force (NULL
, from_tty
);
1938 target_log_command (cmd
);
1942 command
= mi_parse (cmd
, &token
);
1944 catch (const gdb_exception
&exception
)
1946 mi_print_exception (token
, exception
);
1950 if (command
!= NULL
)
1952 ptid_t previous_ptid
= inferior_ptid
;
1954 gdb::optional
<scoped_restore_tmpl
<int>> restore_suppress
;
1956 if (command
->cmd
!= NULL
&& command
->cmd
->suppress_notification
!= NULL
)
1957 restore_suppress
.emplace (command
->cmd
->suppress_notification
, 1);
1959 command
->token
= token
;
1963 command
->cmd_start
= new mi_timestamp ();
1964 timestamp (command
->cmd_start
);
1969 captured_mi_execute_command (current_uiout
, command
.get ());
1971 catch (const gdb_exception
&result
)
1973 /* Like in start_event_loop, enable input and force display
1974 of the prompt. Otherwise, any command that calls
1975 async_disable_stdin, and then throws, will leave input
1977 async_enable_stdin ();
1978 current_ui
->prompt_state
= PROMPT_NEEDED
;
1980 /* The command execution failed and error() was called
1982 mi_print_exception (command
->token
, result
);
1983 mi_out_rewind (current_uiout
);
1986 bpstat_do_actions ();
1988 if (/* The notifications are only output when the top-level
1989 interpreter (specified on the command line) is MI. */
1990 top_level_interpreter ()->interp_ui_out ()->is_mi_like_p ()
1991 /* Don't try report anything if there are no threads --
1992 the program is dead. */
1994 /* If the command already reports the thread change, no need to do it
1996 && !command_notifies_uscc_observer (command
.get ()))
1998 int report_change
= 0;
2000 if (command
->thread
== -1)
2002 report_change
= (previous_ptid
!= null_ptid
2003 && inferior_ptid
!= previous_ptid
2004 && inferior_ptid
!= null_ptid
);
2006 else if (inferior_ptid
!= null_ptid
)
2008 struct thread_info
*ti
= inferior_thread ();
2010 report_change
= (ti
->global_num
!= command
->thread
);
2015 gdb::observers::user_selected_context_changed
.notify
2016 (USER_SELECTED_THREAD
| USER_SELECTED_FRAME
);
2023 mi_cmd_execute (struct mi_parse
*parse
)
2025 scoped_value_mark cleanup
= prepare_execute_command ();
2027 if (parse
->all
&& parse
->thread_group
!= -1)
2028 error (_("Cannot specify --thread-group together with --all"));
2030 if (parse
->all
&& parse
->thread
!= -1)
2031 error (_("Cannot specify --thread together with --all"));
2033 if (parse
->thread_group
!= -1 && parse
->thread
!= -1)
2034 error (_("Cannot specify --thread together with --thread-group"));
2036 if (parse
->frame
!= -1 && parse
->thread
== -1)
2037 error (_("Cannot specify --frame without --thread"));
2039 if (parse
->thread_group
!= -1)
2041 struct inferior
*inf
= find_inferior_id (parse
->thread_group
);
2042 struct thread_info
*tp
= 0;
2045 error (_("Invalid thread group for the --thread-group option"));
2047 set_current_inferior (inf
);
2048 /* This behaviour means that if --thread-group option identifies
2049 an inferior with multiple threads, then a random one will be
2050 picked. This is not a problem -- frontend should always
2051 provide --thread if it wishes to operate on a specific
2054 tp
= any_live_thread_of_inferior (inf
);
2056 switch_to_thread (tp
);
2058 switch_to_no_thread ();
2059 set_current_program_space (inf
->pspace
);
2062 if (parse
->thread
!= -1)
2064 thread_info
*tp
= find_thread_global_id (parse
->thread
);
2067 error (_("Invalid thread id: %d"), parse
->thread
);
2069 if (tp
->state
== THREAD_EXITED
)
2070 error (_("Thread id: %d has terminated"), parse
->thread
);
2072 switch_to_thread (tp
);
2075 if (parse
->frame
!= -1)
2077 struct frame_info
*fid
;
2078 int frame
= parse
->frame
;
2080 fid
= find_relative_frame (get_current_frame (), &frame
);
2082 /* find_relative_frame was successful */
2085 error (_("Invalid frame id: %d"), frame
);
2088 gdb::optional
<scoped_restore_current_language
> lang_saver
;
2089 if (parse
->language
!= language_unknown
)
2091 lang_saver
.emplace ();
2092 set_language (parse
->language
);
2095 current_context
= parse
;
2097 if (parse
->cmd
->argv_func
!= NULL
)
2099 parse
->cmd
->argv_func (parse
->command
, parse
->argv
, parse
->argc
);
2101 else if (parse
->cmd
->cli
.cmd
!= 0)
2103 /* FIXME: DELETE THIS. */
2104 /* The operation is still implemented by a cli command. */
2105 /* Must be a synchronous one. */
2106 mi_execute_cli_command (parse
->cmd
->cli
.cmd
, parse
->cmd
->cli
.args_p
,
2111 /* FIXME: DELETE THIS. */
2114 stb
.puts ("Undefined mi command: ");
2115 stb
.putstr (parse
->command
, '"');
2116 stb
.puts (" (missing implementation)");
2122 /* FIXME: This is just a hack so we can get some extra commands going.
2123 We don't want to channel things through the CLI, but call libgdb directly.
2124 Use only for synchronous commands. */
2127 mi_execute_cli_command (const char *cmd
, int args_p
, const char *args
)
2131 std::string run
= cmd
;
2134 run
= run
+ " " + args
;
2136 /* FIXME: gdb_???? */
2137 fprintf_unfiltered (gdb_stdout
, "cli=%s run=%s\n",
2139 execute_command (run
.c_str (), 0 /* from_tty */ );
2144 mi_execute_async_cli_command (const char *cli_command
, char **argv
, int argc
)
2146 std::string run
= cli_command
;
2149 run
= run
+ " " + *argv
;
2153 execute_command (run
.c_str (), 0 /* from_tty */ );
2157 mi_load_progress (const char *section_name
,
2158 unsigned long sent_so_far
,
2159 unsigned long total_section
,
2160 unsigned long total_sent
,
2161 unsigned long grand_total
)
2163 using namespace std::chrono
;
2164 static steady_clock::time_point last_update
;
2165 static char *previous_sect_name
= NULL
;
2167 struct mi_interp
*mi
= (struct mi_interp
*) current_interpreter ();
2169 /* This function is called through deprecated_show_load_progress
2170 which means uiout may not be correct. Fix it for the duration
2171 of this function. */
2173 std::unique_ptr
<ui_out
> uiout (mi_out_new (current_interpreter ()->name ()));
2174 if (uiout
== nullptr)
2177 scoped_restore save_uiout
2178 = make_scoped_restore (¤t_uiout
, uiout
.get ());
2180 new_section
= (previous_sect_name
?
2181 strcmp (previous_sect_name
, section_name
) : 1);
2184 xfree (previous_sect_name
);
2185 previous_sect_name
= xstrdup (section_name
);
2188 fputs_unfiltered (current_token
, mi
->raw_stdout
);
2189 fputs_unfiltered ("+download", mi
->raw_stdout
);
2191 ui_out_emit_tuple
tuple_emitter (uiout
.get (), NULL
);
2192 uiout
->field_string ("section", section_name
);
2193 uiout
->field_signed ("section-size", total_section
);
2194 uiout
->field_signed ("total-size", grand_total
);
2196 mi_out_put (uiout
.get (), mi
->raw_stdout
);
2197 fputs_unfiltered ("\n", mi
->raw_stdout
);
2198 gdb_flush (mi
->raw_stdout
);
2201 steady_clock::time_point time_now
= steady_clock::now ();
2202 if (time_now
- last_update
> milliseconds (500))
2204 last_update
= time_now
;
2206 fputs_unfiltered (current_token
, mi
->raw_stdout
);
2207 fputs_unfiltered ("+download", mi
->raw_stdout
);
2209 ui_out_emit_tuple
tuple_emitter (uiout
.get (), NULL
);
2210 uiout
->field_string ("section", section_name
);
2211 uiout
->field_signed ("section-sent", sent_so_far
);
2212 uiout
->field_signed ("section-size", total_section
);
2213 uiout
->field_signed ("total-sent", total_sent
);
2214 uiout
->field_signed ("total-size", grand_total
);
2216 mi_out_put (uiout
.get (), mi
->raw_stdout
);
2217 fputs_unfiltered ("\n", mi
->raw_stdout
);
2218 gdb_flush (mi
->raw_stdout
);
2223 timestamp (struct mi_timestamp
*tv
)
2225 using namespace std::chrono
;
2227 tv
->wallclock
= steady_clock::now ();
2228 run_time_clock::now (tv
->utime
, tv
->stime
);
2232 print_diff_now (struct ui_file
*file
, struct mi_timestamp
*start
)
2234 struct mi_timestamp now
;
2237 print_diff (file
, start
, &now
);
2241 mi_print_timing_maybe (struct ui_file
*file
)
2243 /* If the command is -enable-timing then do_timings may be true
2244 whilst current_command_ts is not initialized. */
2245 if (do_timings
&& current_command_ts
)
2246 print_diff_now (file
, current_command_ts
);
2250 print_diff (struct ui_file
*file
, struct mi_timestamp
*start
,
2251 struct mi_timestamp
*end
)
2253 using namespace std::chrono
;
2255 duration
<double> wallclock
= end
->wallclock
- start
->wallclock
;
2256 duration
<double> utime
= end
->utime
- start
->utime
;
2257 duration
<double> stime
= end
->stime
- start
->stime
;
2261 ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
2262 wallclock
.count (), utime
.count (), stime
.count ());
2266 mi_cmd_trace_define_variable (const char *command
, char **argv
, int argc
)
2268 LONGEST initval
= 0;
2269 struct trace_state_variable
*tsv
;
2272 if (argc
!= 1 && argc
!= 2)
2273 error (_("Usage: -trace-define-variable VARIABLE [VALUE]"));
2277 error (_("Name of trace variable should start with '$'"));
2279 validate_trace_state_variable_name (name
);
2281 tsv
= find_trace_state_variable (name
);
2283 tsv
= create_trace_state_variable (name
);
2286 initval
= value_as_long (parse_and_eval (argv
[1]));
2288 tsv
->initial_value
= initval
;
2292 mi_cmd_trace_list_variables (const char *command
, char **argv
, int argc
)
2295 error (_("-trace-list-variables: no arguments allowed"));
2297 tvariables_info_1 ();
2301 mi_cmd_trace_find (const char *command
, char **argv
, int argc
)
2306 error (_("trace selection mode is required"));
2310 if (strcmp (mode
, "none") == 0)
2312 tfind_1 (tfind_number
, -1, 0, 0, 0);
2316 check_trace_running (current_trace_status ());
2318 if (strcmp (mode
, "frame-number") == 0)
2321 error (_("frame number is required"));
2322 tfind_1 (tfind_number
, atoi (argv
[1]), 0, 0, 0);
2324 else if (strcmp (mode
, "tracepoint-number") == 0)
2327 error (_("tracepoint number is required"));
2328 tfind_1 (tfind_tp
, atoi (argv
[1]), 0, 0, 0);
2330 else if (strcmp (mode
, "pc") == 0)
2333 error (_("PC is required"));
2334 tfind_1 (tfind_pc
, 0, parse_and_eval_address (argv
[1]), 0, 0);
2336 else if (strcmp (mode
, "pc-inside-range") == 0)
2339 error (_("Start and end PC are required"));
2340 tfind_1 (tfind_range
, 0, parse_and_eval_address (argv
[1]),
2341 parse_and_eval_address (argv
[2]), 0);
2343 else if (strcmp (mode
, "pc-outside-range") == 0)
2346 error (_("Start and end PC are required"));
2347 tfind_1 (tfind_outside
, 0, parse_and_eval_address (argv
[1]),
2348 parse_and_eval_address (argv
[2]), 0);
2350 else if (strcmp (mode
, "line") == 0)
2353 error (_("Line is required"));
2355 std::vector
<symtab_and_line
> sals
2356 = decode_line_with_current_source (argv
[1],
2357 DECODE_LINE_FUNFIRSTLINE
);
2358 const symtab_and_line
&sal
= sals
[0];
2360 if (sal
.symtab
== 0)
2361 error (_("Could not find the specified line"));
2363 CORE_ADDR start_pc
, end_pc
;
2364 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2365 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, 0);
2367 error (_("Could not find the specified line"));
2370 error (_("Invalid mode '%s'"), mode
);
2372 if (has_stack_frames () || get_traceframe_number () >= 0)
2373 print_stack_frame (get_selected_frame (NULL
), 1, LOC_AND_ADDRESS
, 1);
2377 mi_cmd_trace_save (const char *command
, char **argv
, int argc
)
2379 int target_saves
= 0;
2380 int generate_ctf
= 0;
2387 TARGET_SAVE_OPT
, CTF_OPT
2389 static const struct mi_opt opts
[] =
2391 {"r", TARGET_SAVE_OPT
, 0},
2392 {"ctf", CTF_OPT
, 0},
2398 int opt
= mi_getopt ("-trace-save", argc
, argv
, opts
,
2403 switch ((enum opt
) opt
)
2405 case TARGET_SAVE_OPT
:
2414 if (argc
- oind
!= 1)
2415 error (_("Exactly one argument required "
2416 "(file in which to save trace data)"));
2418 filename
= argv
[oind
];
2421 trace_save_ctf (filename
, target_saves
);
2423 trace_save_tfile (filename
, target_saves
);
2427 mi_cmd_trace_start (const char *command
, char **argv
, int argc
)
2429 start_tracing (NULL
);
2433 mi_cmd_trace_status (const char *command
, char **argv
, int argc
)
2435 trace_status_mi (0);
2439 mi_cmd_trace_stop (const char *command
, char **argv
, int argc
)
2441 stop_tracing (NULL
);
2442 trace_status_mi (1);
2445 /* Implement the "-ada-task-info" command. */
2448 mi_cmd_ada_task_info (const char *command
, char **argv
, int argc
)
2450 if (argc
!= 0 && argc
!= 1)
2451 error (_("Invalid MI command"));
2453 print_ada_task_info (current_uiout
, argv
[0], current_inferior ());
2456 /* Print EXPRESSION according to VALUES. */
2459 print_variable_or_computed (const char *expression
, enum print_values values
)
2463 struct ui_out
*uiout
= current_uiout
;
2467 expression_up expr
= parse_expression (expression
);
2469 if (values
== PRINT_SIMPLE_VALUES
)
2470 val
= evaluate_type (expr
.get ());
2472 val
= evaluate_expression (expr
.get ());
2474 gdb::optional
<ui_out_emit_tuple
> tuple_emitter
;
2475 if (values
!= PRINT_NO_VALUES
)
2476 tuple_emitter
.emplace (uiout
, nullptr);
2477 uiout
->field_string ("name", expression
);
2481 case PRINT_SIMPLE_VALUES
:
2482 type
= check_typedef (value_type (val
));
2483 type_print (value_type (val
), "", &stb
, -1);
2484 uiout
->field_stream ("type", stb
);
2485 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
2486 && TYPE_CODE (type
) != TYPE_CODE_STRUCT
2487 && TYPE_CODE (type
) != TYPE_CODE_UNION
)
2489 struct value_print_options opts
;
2491 get_no_prettyformat_print_options (&opts
);
2493 common_val_print (val
, &stb
, 0, &opts
, current_language
);
2494 uiout
->field_stream ("value", stb
);
2497 case PRINT_ALL_VALUES
:
2499 struct value_print_options opts
;
2501 get_no_prettyformat_print_options (&opts
);
2503 common_val_print (val
, &stb
, 0, &opts
, current_language
);
2504 uiout
->field_stream ("value", stb
);
2510 /* Implement the "-trace-frame-collected" command. */
2513 mi_cmd_trace_frame_collected (const char *command
, char **argv
, int argc
)
2515 struct bp_location
*tloc
;
2517 struct collection_list
*clist
;
2518 struct collection_list tracepoint_list
, stepping_list
;
2519 struct traceframe_info
*tinfo
;
2521 enum print_values var_print_values
= PRINT_ALL_VALUES
;
2522 enum print_values comp_print_values
= PRINT_ALL_VALUES
;
2523 int registers_format
= 'x';
2524 int memory_contents
= 0;
2525 struct ui_out
*uiout
= current_uiout
;
2533 static const struct mi_opt opts
[] =
2535 {"-var-print-values", VAR_PRINT_VALUES
, 1},
2536 {"-comp-print-values", COMP_PRINT_VALUES
, 1},
2537 {"-registers-format", REGISTERS_FORMAT
, 1},
2538 {"-memory-contents", MEMORY_CONTENTS
, 0},
2545 int opt
= mi_getopt ("-trace-frame-collected", argc
, argv
, opts
,
2549 switch ((enum opt
) opt
)
2551 case VAR_PRINT_VALUES
:
2552 var_print_values
= mi_parse_print_values (oarg
);
2554 case COMP_PRINT_VALUES
:
2555 comp_print_values
= mi_parse_print_values (oarg
);
2557 case REGISTERS_FORMAT
:
2558 registers_format
= oarg
[0];
2560 case MEMORY_CONTENTS
:
2561 memory_contents
= 1;
2567 error (_("Usage: -trace-frame-collected "
2568 "[--var-print-values PRINT_VALUES] "
2569 "[--comp-print-values PRINT_VALUES] "
2570 "[--registers-format FORMAT]"
2571 "[--memory-contents]"));
2573 /* This throws an error is not inspecting a trace frame. */
2574 tloc
= get_traceframe_location (&stepping_frame
);
2576 /* This command only makes sense for the current frame, not the
2578 scoped_restore_current_thread restore_thread
;
2579 select_frame (get_current_frame ());
2581 encode_actions (tloc
, &tracepoint_list
, &stepping_list
);
2584 clist
= &stepping_list
;
2586 clist
= &tracepoint_list
;
2588 tinfo
= get_traceframe_info ();
2590 /* Explicitly wholly collected variables. */
2592 ui_out_emit_list
list_emitter (uiout
, "explicit-variables");
2593 const std::vector
<std::string
> &wholly_collected
2594 = clist
->wholly_collected ();
2595 for (size_t i
= 0; i
< wholly_collected
.size (); i
++)
2597 const std::string
&str
= wholly_collected
[i
];
2598 print_variable_or_computed (str
.c_str (), var_print_values
);
2602 /* Computed expressions. */
2604 ui_out_emit_list
list_emitter (uiout
, "computed-expressions");
2606 const std::vector
<std::string
> &computed
= clist
->computed ();
2607 for (size_t i
= 0; i
< computed
.size (); i
++)
2609 const std::string
&str
= computed
[i
];
2610 print_variable_or_computed (str
.c_str (), comp_print_values
);
2614 /* Registers. Given pseudo-registers, and that some architectures
2615 (like MIPS) actually hide the raw registers, we don't go through
2616 the trace frame info, but instead consult the register cache for
2617 register availability. */
2619 struct frame_info
*frame
;
2620 struct gdbarch
*gdbarch
;
2624 ui_out_emit_list
list_emitter (uiout
, "registers");
2626 frame
= get_selected_frame (NULL
);
2627 gdbarch
= get_frame_arch (frame
);
2628 numregs
= gdbarch_num_cooked_regs (gdbarch
);
2630 for (regnum
= 0; regnum
< numregs
; regnum
++)
2632 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
2633 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
2636 output_register (frame
, regnum
, registers_format
, 1);
2640 /* Trace state variables. */
2642 ui_out_emit_list
list_emitter (uiout
, "tvars");
2644 for (int tvar
: tinfo
->tvars
)
2646 struct trace_state_variable
*tsv
;
2648 tsv
= find_trace_state_variable_by_number (tvar
);
2650 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
2654 uiout
->field_fmt ("name", "$%s", tsv
->name
.c_str ());
2656 tsv
->value_known
= target_get_trace_state_variable_value (tsv
->number
,
2658 uiout
->field_signed ("current", tsv
->value
);
2662 uiout
->field_skip ("name");
2663 uiout
->field_skip ("current");
2670 std::vector
<mem_range
> available_memory
;
2672 traceframe_available_memory (&available_memory
, 0, ULONGEST_MAX
);
2674 ui_out_emit_list
list_emitter (uiout
, "memory");
2676 for (const mem_range
&r
: available_memory
)
2678 struct gdbarch
*gdbarch
= target_gdbarch ();
2680 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
2682 uiout
->field_core_addr ("address", gdbarch
, r
.start
);
2683 uiout
->field_signed ("length", r
.length
);
2685 gdb::byte_vector
data (r
.length
);
2687 if (memory_contents
)
2689 if (target_read_memory (r
.start
, data
.data (), r
.length
) == 0)
2691 std::string data_str
= bin2hex (data
.data (), r
.length
);
2692 uiout
->field_string ("contents", data_str
.c_str ());
2695 uiout
->field_skip ("contents");
2701 /* See mi/mi-main.h. */
2704 mi_cmd_fix_multi_location_breakpoint_output (const char *command
, char **argv
,
2707 fix_multi_location_breakpoint_output_globally
= true;
2710 /* Implement the "-complete" command. */
2713 mi_cmd_complete (const char *command
, char **argv
, int argc
)
2716 error (_("Usage: -complete COMMAND"));
2718 if (max_completions
== 0)
2719 error (_("max-completions is zero, completion is disabled."));
2721 int quote_char
= '\0';
2724 completion_result result
= complete (argv
[0], &word
, "e_char
);
2726 std::string
arg_prefix (argv
[0], word
- argv
[0]);
2728 struct ui_out
*uiout
= current_uiout
;
2730 if (result
.number_matches
> 0)
2731 uiout
->field_fmt ("completion", "%s%s",
2732 arg_prefix
.c_str (),result
.match_list
[0]);
2735 ui_out_emit_list
completions_emitter (uiout
, "matches");
2737 if (result
.number_matches
== 1)
2738 uiout
->field_fmt (NULL
, "%s%s",
2739 arg_prefix
.c_str (), result
.match_list
[0]);
2742 result
.sort_match_list ();
2743 for (size_t i
= 0; i
< result
.number_matches
; i
++)
2745 uiout
->field_fmt (NULL
, "%s%s",
2746 arg_prefix
.c_str (), result
.match_list
[i
+ 1]);
2750 uiout
->field_string ("max_completions_reached",
2751 result
.number_matches
== max_completions
? "1" : "0");
2756 _initialize_mi_main (void)
2758 struct cmd_list_element
*c
;
2760 add_setshow_boolean_cmd ("mi-async", class_run
,
2762 Set whether MI asynchronous mode is enabled."), _("\
2763 Show whether MI asynchronous mode is enabled."), _("\
2764 Tells GDB whether MI should be in asynchronous mode."),
2765 set_mi_async_command
,
2766 show_mi_async_command
,
2770 /* Alias old "target-async" to "mi-async". */
2771 c
= add_alias_cmd ("target-async", "mi-async", class_run
, 0, &setlist
);
2772 deprecate_cmd (c
, "set mi-async");
2773 c
= add_alias_cmd ("target-async", "mi-async", class_run
, 0, &showlist
);
2774 deprecate_cmd (c
, "show mi-async");