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 exec_continue (char **argv
, int argc
)
258 prepare_execution_command (current_top_target (), mi_async_p ());
262 /* In non-stop mode, 'resume' always resumes a single thread.
263 Therefore, to resume all threads of the current inferior, or
264 all threads in all inferiors, we need to iterate over
267 See comment on infcmd.c:proceed_thread_callback for rationale. */
268 if (current_context
->all
|| current_context
->thread_group
!= -1)
270 scoped_restore_current_thread restore_thread
;
273 if (!current_context
->all
)
276 = find_inferior_id (current_context
->thread_group
);
281 /* Proceed the threads in global number order. This is not necessary,
282 it's just to avoid breaking some tests like gdb.mi/mi-nsintrall.exp
283 that expect the *running notifications in that order. In the end,
284 we should instead fix the test to accept the notifications in any
286 std::vector
<thread_info
*> threads
;
287 for (thread_info
*tp
: all_threads ())
288 threads
.push_back (tp
);
290 std::sort (threads
.begin (), threads
.end (),
291 [] (thread_info
*a
, thread_info
*b
)
293 return a
->global_num
< b
->global_num
;
296 for (thread_info
*tp
: threads
)
297 proceed_thread (tp
, pid
);
306 scoped_restore save_multi
= make_scoped_restore (&sched_multi
);
308 if (current_context
->all
)
315 /* In all-stop mode, -exec-continue traditionally resumed
316 either all threads, or one thread, depending on the
317 'scheduler-locking' variable. Let's continue to do the
325 exec_reverse_continue (char **argv
, int argc
)
327 enum exec_direction_kind dir
= execution_direction
;
329 if (dir
== EXEC_REVERSE
)
330 error (_("Already in reverse mode."));
332 if (!target_can_execute_reverse
)
333 error (_("Target %s does not support this command."), target_shortname
);
335 scoped_restore save_exec_dir
= make_scoped_restore (&execution_direction
,
337 exec_continue (argv
, argc
);
341 mi_cmd_exec_continue (const char *command
, char **argv
, int argc
)
343 if (argc
> 0 && strcmp (argv
[0], "--reverse") == 0)
344 exec_reverse_continue (argv
+ 1, argc
- 1);
346 exec_continue (argv
, argc
);
350 interrupt_thread_callback (struct thread_info
*thread
, void *arg
)
352 int pid
= *(int *)arg
;
354 if (thread
->state
!= THREAD_RUNNING
)
357 if (thread
->ptid
.pid () != pid
)
360 target_stop (thread
->ptid
);
364 /* Interrupt the execution of the target. Note how we must play
365 around with the token variables, in order to display the current
366 token in the result of the interrupt command, and the previous
367 execution token when the target finally stops. See comments in
371 mi_cmd_exec_interrupt (const char *command
, char **argv
, int argc
)
373 /* In all-stop mode, everything stops, so we don't need to try
374 anything specific. */
377 interrupt_target_1 (0);
381 if (current_context
->all
)
383 /* This will interrupt all threads in all inferiors. */
384 interrupt_target_1 (1);
386 else if (current_context
->thread_group
!= -1)
388 struct inferior
*inf
= find_inferior_id (current_context
->thread_group
);
390 iterate_over_threads (interrupt_thread_callback
, &inf
->pid
);
394 /* Interrupt just the current thread -- either explicitly
395 specified via --thread or whatever was current before
396 MI command was sent. */
397 interrupt_target_1 (0);
401 /* Callback for iterate_over_inferiors which starts the execution
402 of the given inferior.
404 ARG is a pointer to an integer whose value, if non-zero, indicates
405 that the program should be stopped when reaching the main subprogram
406 (similar to what the CLI "start" command does). */
409 run_one_inferior (struct inferior
*inf
, void *arg
)
411 int start_p
= *(int *) arg
;
412 const char *run_cmd
= start_p
? "start" : "run";
413 struct target_ops
*run_target
= find_run_target ();
414 int async_p
= mi_async
&& run_target
->can_async_p ();
418 thread_info
*tp
= any_thread_of_inferior (inf
);
420 error (_("Inferior has no threads."));
422 switch_to_thread (tp
);
425 switch_to_inferior_no_thread (inf
);
426 mi_execute_cli_command (run_cmd
, async_p
,
427 async_p
? "&" : NULL
);
432 mi_cmd_exec_run (const char *command
, char **argv
, int argc
)
436 /* Parse the command options. */
441 static const struct mi_opt opts
[] =
443 {"-start", START_OPT
, 0},
452 int opt
= mi_getopt ("-exec-run", argc
, argv
, opts
, &oind
, &oarg
);
456 switch ((enum opt
) opt
)
464 /* This command does not accept any argument. Make sure the user
465 did not provide any. */
467 error (_("Invalid argument: %s"), argv
[oind
]);
469 if (current_context
->all
)
471 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
473 iterate_over_inferiors (run_one_inferior
, &start_p
);
477 const char *run_cmd
= start_p
? "start" : "run";
478 struct target_ops
*run_target
= find_run_target ();
479 int async_p
= mi_async
&& run_target
->can_async_p ();
481 mi_execute_cli_command (run_cmd
, async_p
,
482 async_p
? "&" : NULL
);
488 find_thread_of_process (struct thread_info
*ti
, void *p
)
492 if (ti
->ptid
.pid () == pid
&& ti
->state
!= THREAD_EXITED
)
499 mi_cmd_target_detach (const char *command
, char **argv
, int argc
)
501 if (argc
!= 0 && argc
!= 1)
502 error (_("Usage: -target-detach [pid | thread-group]"));
506 struct thread_info
*tp
;
510 /* First see if we are dealing with a thread-group id. */
513 struct inferior
*inf
;
514 int id
= strtoul (argv
[0] + 1, &end
, 0);
517 error (_("Invalid syntax of thread-group id '%s'"), argv
[0]);
519 inf
= find_inferior_id (id
);
521 error (_("Non-existent thread-group id '%d'"), id
);
527 /* We must be dealing with a pid. */
528 pid
= strtol (argv
[0], &end
, 10);
531 error (_("Invalid identifier '%s'"), argv
[0]);
534 /* Pick any thread in the desired process. Current
535 target_detach detaches from the parent of inferior_ptid. */
536 tp
= iterate_over_threads (find_thread_of_process
, &pid
);
538 error (_("Thread group is empty"));
540 switch_to_thread (tp
);
543 detach_command (NULL
, 0);
547 mi_cmd_target_flash_erase (const char *command
, char **argv
, int argc
)
549 flash_erase_command (NULL
, 0);
553 mi_cmd_thread_select (const char *command
, char **argv
, int argc
)
556 error (_("-thread-select: USAGE: threadnum."));
558 int num
= value_as_long (parse_and_eval (argv
[0]));
559 thread_info
*thr
= find_thread_global_id (num
);
561 error (_("Thread ID %d not known."), num
);
563 ptid_t previous_ptid
= inferior_ptid
;
565 thread_select (argv
[0], thr
);
567 print_selected_thread_frame (current_uiout
,
568 USER_SELECTED_THREAD
| USER_SELECTED_FRAME
);
570 /* Notify if the thread has effectively changed. */
571 if (inferior_ptid
!= previous_ptid
)
573 gdb::observers::user_selected_context_changed
.notify
574 (USER_SELECTED_THREAD
| USER_SELECTED_FRAME
);
579 mi_cmd_thread_list_ids (const char *command
, char **argv
, int argc
)
582 error (_("-thread-list-ids: No arguments required."));
585 int current_thread
= -1;
587 update_thread_list ();
590 ui_out_emit_tuple
tuple_emitter (current_uiout
, "thread-ids");
592 for (thread_info
*tp
: all_non_exited_threads ())
594 if (tp
->ptid
== inferior_ptid
)
595 current_thread
= tp
->global_num
;
598 current_uiout
->field_signed ("thread-id", tp
->global_num
);
602 if (current_thread
!= -1)
603 current_uiout
->field_signed ("current-thread-id", current_thread
);
604 current_uiout
->field_signed ("number-of-threads", num
);
608 mi_cmd_thread_info (const char *command
, char **argv
, int argc
)
610 if (argc
!= 0 && argc
!= 1)
611 error (_("Invalid MI command"));
613 print_thread_info (current_uiout
, argv
[0], -1);
616 struct collect_cores_data
623 collect_cores (struct thread_info
*ti
, void *xdata
)
625 struct collect_cores_data
*data
= (struct collect_cores_data
*) xdata
;
627 if (ti
->ptid
.pid () == data
->pid
)
629 int core
= target_core_of_thread (ti
->ptid
);
632 data
->cores
.insert (core
);
638 struct print_one_inferior_data
641 const std::set
<int> *inferiors
;
645 print_one_inferior (struct inferior
*inferior
, void *xdata
)
647 struct print_one_inferior_data
*top_data
648 = (struct print_one_inferior_data
*) xdata
;
649 struct ui_out
*uiout
= current_uiout
;
651 if (top_data
->inferiors
->empty ()
652 || (top_data
->inferiors
->find (inferior
->pid
)
653 != top_data
->inferiors
->end ()))
655 struct collect_cores_data data
;
656 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
658 uiout
->field_fmt ("id", "i%d", inferior
->num
);
659 uiout
->field_string ("type", "process");
660 if (inferior
->has_exit_code
)
661 uiout
->field_string ("exit-code",
662 int_string (inferior
->exit_code
, 8, 0, 0, 1));
663 if (inferior
->pid
!= 0)
664 uiout
->field_signed ("pid", inferior
->pid
);
666 if (inferior
->pspace
->pspace_exec_filename
!= NULL
)
668 uiout
->field_string ("executable",
669 inferior
->pspace
->pspace_exec_filename
);
672 if (inferior
->pid
!= 0)
674 data
.pid
= inferior
->pid
;
675 iterate_over_threads (collect_cores
, &data
);
678 if (!data
.cores
.empty ())
680 ui_out_emit_list
list_emitter (uiout
, "cores");
682 for (int b
: data
.cores
)
683 uiout
->field_signed (NULL
, b
);
686 if (top_data
->recurse
)
687 print_thread_info (uiout
, NULL
, inferior
->pid
);
693 /* Output a field named 'cores' with a list as the value. The
694 elements of the list are obtained by splitting 'cores' on
698 output_cores (struct ui_out
*uiout
, const char *field_name
, const char *xcores
)
700 ui_out_emit_list
list_emitter (uiout
, field_name
);
701 auto cores
= make_unique_xstrdup (xcores
);
702 char *p
= cores
.get ();
705 for (p
= strtok_r (p
, ",", &saveptr
); p
; p
= strtok_r (NULL
, ",", &saveptr
))
706 uiout
->field_string (NULL
, p
);
710 list_available_thread_groups (const std::set
<int> &ids
, int recurse
)
712 struct ui_out
*uiout
= current_uiout
;
714 /* This keeps a map from integer (pid) to vector of struct osdata_item.
715 The vector contains information about all threads for the given pid. */
716 std::map
<int, std::vector
<osdata_item
>> tree
;
718 /* get_osdata will throw if it cannot return data. */
719 std::unique_ptr
<osdata
> data
= get_osdata ("processes");
723 std::unique_ptr
<osdata
> threads
= get_osdata ("threads");
725 for (const osdata_item
&item
: threads
->items
)
727 const std::string
*pid
= get_osdata_column (item
, "pid");
728 int pid_i
= strtoul (pid
->c_str (), NULL
, 0);
730 tree
[pid_i
].push_back (item
);
734 ui_out_emit_list
list_emitter (uiout
, "groups");
736 for (const osdata_item
&item
: data
->items
)
738 const std::string
*pid
= get_osdata_column (item
, "pid");
739 const std::string
*cmd
= get_osdata_column (item
, "command");
740 const std::string
*user
= get_osdata_column (item
, "user");
741 const std::string
*cores
= get_osdata_column (item
, "cores");
743 int pid_i
= strtoul (pid
->c_str (), NULL
, 0);
745 /* At present, the target will return all available processes
746 and if information about specific ones was required, we filter
747 undesired processes here. */
748 if (!ids
.empty () && ids
.find (pid_i
) == ids
.end ())
751 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
753 uiout
->field_string ("id", pid
->c_str ());
754 uiout
->field_string ("type", "process");
756 uiout
->field_string ("description", cmd
->c_str ());
758 uiout
->field_string ("user", user
->c_str ());
760 output_cores (uiout
, "cores", cores
->c_str ());
764 auto n
= tree
.find (pid_i
);
765 if (n
!= tree
.end ())
767 std::vector
<osdata_item
> &children
= n
->second
;
769 ui_out_emit_list
thread_list_emitter (uiout
, "threads");
771 for (const osdata_item
&child
: children
)
773 ui_out_emit_tuple
inner_tuple_emitter (uiout
, NULL
);
774 const std::string
*tid
= get_osdata_column (child
, "tid");
775 const std::string
*tcore
= get_osdata_column (child
, "core");
777 uiout
->field_string ("id", tid
->c_str ());
779 uiout
->field_string ("core", tcore
->c_str ());
787 mi_cmd_list_thread_groups (const char *command
, char **argv
, int argc
)
789 struct ui_out
*uiout
= current_uiout
;
796 AVAILABLE_OPT
, RECURSE_OPT
798 static const struct mi_opt opts
[] =
800 {"-available", AVAILABLE_OPT
, 0},
801 {"-recurse", RECURSE_OPT
, 1},
810 int opt
= mi_getopt ("-list-thread-groups", argc
, argv
, opts
,
815 switch ((enum opt
) opt
)
821 if (strcmp (oarg
, "0") == 0)
823 else if (strcmp (oarg
, "1") == 0)
826 error (_("only '0' and '1' are valid values "
827 "for the '--recurse' option"));
832 for (; oind
< argc
; ++oind
)
837 if (*(argv
[oind
]) != 'i')
838 error (_("invalid syntax of group id '%s'"), argv
[oind
]);
840 inf
= strtoul (argv
[oind
] + 1, &end
, 0);
843 error (_("invalid syntax of group id '%s'"), argv
[oind
]);
849 list_available_thread_groups (ids
, recurse
);
851 else if (ids
.size () == 1)
853 /* Local thread groups, single id. */
854 int id
= *(ids
.begin ());
855 struct inferior
*inf
= find_inferior_id (id
);
858 error (_("Non-existent thread group id '%d'"), id
);
860 print_thread_info (uiout
, NULL
, inf
->pid
);
864 struct print_one_inferior_data data
;
866 data
.recurse
= recurse
;
867 data
.inferiors
= &ids
;
869 /* Local thread groups. Either no explicit ids -- and we
870 print everything, or several explicit ids. In both cases,
871 we print more than one group, and have to use 'groups'
872 as the top-level element. */
873 ui_out_emit_list
list_emitter (uiout
, "groups");
874 update_thread_list ();
875 iterate_over_inferiors (print_one_inferior
, &data
);
880 mi_cmd_data_list_register_names (const char *command
, char **argv
, int argc
)
882 struct gdbarch
*gdbarch
;
883 struct ui_out
*uiout
= current_uiout
;
887 /* Note that the test for a valid register must include checking the
888 gdbarch_register_name because gdbarch_num_regs may be allocated
889 for the union of the register sets within a family of related
890 processors. In this case, some entries of gdbarch_register_name
891 will change depending upon the particular processor being
894 gdbarch
= get_current_arch ();
895 numregs
= gdbarch_num_cooked_regs (gdbarch
);
897 ui_out_emit_list
list_emitter (uiout
, "register-names");
899 if (argc
== 0) /* No args, just do all the regs. */
905 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
906 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
907 uiout
->field_string (NULL
, "");
909 uiout
->field_string (NULL
, gdbarch_register_name (gdbarch
, regnum
));
913 /* Else, list of register #s, just do listed regs. */
914 for (i
= 0; i
< argc
; i
++)
916 regnum
= atoi (argv
[i
]);
917 if (regnum
< 0 || regnum
>= numregs
)
918 error (_("bad register number"));
920 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
921 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
922 uiout
->field_string (NULL
, "");
924 uiout
->field_string (NULL
, gdbarch_register_name (gdbarch
, regnum
));
929 mi_cmd_data_list_changed_registers (const char *command
, char **argv
, int argc
)
931 static std::unique_ptr
<readonly_detached_regcache
> this_regs
;
932 struct ui_out
*uiout
= current_uiout
;
933 std::unique_ptr
<readonly_detached_regcache
> prev_regs
;
934 struct gdbarch
*gdbarch
;
938 /* The last time we visited this function, the current frame's
939 register contents were saved in THIS_REGS. Move THIS_REGS over
940 to PREV_REGS, and refresh THIS_REGS with the now-current register
943 prev_regs
= std::move (this_regs
);
944 this_regs
= frame_save_as_regcache (get_selected_frame (NULL
));
946 /* Note that the test for a valid register must include checking the
947 gdbarch_register_name because gdbarch_num_regs may be allocated
948 for the union of the register sets within a family of related
949 processors. In this case, some entries of gdbarch_register_name
950 will change depending upon the particular processor being
953 gdbarch
= this_regs
->arch ();
954 numregs
= gdbarch_num_cooked_regs (gdbarch
);
956 ui_out_emit_list
list_emitter (uiout
, "changed-registers");
960 /* No args, just do all the regs. */
965 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
966 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
969 if (register_changed_p (regnum
, prev_regs
.get (),
971 uiout
->field_signed (NULL
, regnum
);
975 /* Else, list of register #s, just do listed regs. */
976 for (i
= 0; i
< argc
; i
++)
978 regnum
= atoi (argv
[i
]);
982 && gdbarch_register_name (gdbarch
, regnum
) != NULL
983 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
985 if (register_changed_p (regnum
, prev_regs
.get (),
987 uiout
->field_signed (NULL
, regnum
);
990 error (_("bad register number"));
995 register_changed_p (int regnum
, readonly_detached_regcache
*prev_regs
,
996 readonly_detached_regcache
*this_regs
)
998 struct gdbarch
*gdbarch
= this_regs
->arch ();
999 struct value
*prev_value
, *this_value
;
1001 /* First time through or after gdbarch change consider all registers
1003 if (!prev_regs
|| prev_regs
->arch () != gdbarch
)
1006 /* Get register contents and compare. */
1007 prev_value
= prev_regs
->cooked_read_value (regnum
);
1008 this_value
= this_regs
->cooked_read_value (regnum
);
1009 gdb_assert (prev_value
!= NULL
);
1010 gdb_assert (this_value
!= NULL
);
1012 auto ret
= !value_contents_eq (prev_value
, 0, this_value
, 0,
1013 register_size (gdbarch
, regnum
));
1015 release_value (prev_value
);
1016 release_value (this_value
);
1020 /* Return a list of register number and value pairs. The valid
1021 arguments expected are: a letter indicating the format in which to
1022 display the registers contents. This can be one of: x
1023 (hexadecimal), d (decimal), N (natural), t (binary), o (octal), r
1024 (raw). After the format argument there can be a sequence of
1025 numbers, indicating which registers to fetch the content of. If
1026 the format is the only argument, a list of all the registers with
1027 their values is returned. */
1030 mi_cmd_data_list_register_values (const char *command
, char **argv
, int argc
)
1032 struct ui_out
*uiout
= current_uiout
;
1033 struct frame_info
*frame
;
1034 struct gdbarch
*gdbarch
;
1035 int regnum
, numregs
, format
;
1037 int skip_unavailable
= 0;
1043 static const struct mi_opt opts
[] =
1045 {"-skip-unavailable", SKIP_UNAVAILABLE
, 0},
1049 /* Note that the test for a valid register must include checking the
1050 gdbarch_register_name because gdbarch_num_regs may be allocated
1051 for the union of the register sets within a family of related
1052 processors. In this case, some entries of gdbarch_register_name
1053 will change depending upon the particular processor being
1059 int opt
= mi_getopt ("-data-list-register-values", argc
, argv
,
1060 opts
, &oind
, &oarg
);
1064 switch ((enum opt
) opt
)
1066 case SKIP_UNAVAILABLE
:
1067 skip_unavailable
= 1;
1072 if (argc
- oind
< 1)
1073 error (_("-data-list-register-values: Usage: "
1074 "-data-list-register-values [--skip-unavailable] <format>"
1075 " [<regnum1>...<regnumN>]"));
1077 format
= (int) argv
[oind
][0];
1079 frame
= get_selected_frame (NULL
);
1080 gdbarch
= get_frame_arch (frame
);
1081 numregs
= gdbarch_num_cooked_regs (gdbarch
);
1083 ui_out_emit_list
list_emitter (uiout
, "register-values");
1085 if (argc
- oind
== 1)
1087 /* No args, beside the format: do all the regs. */
1092 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1093 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1096 output_register (frame
, regnum
, format
, skip_unavailable
);
1100 /* Else, list of register #s, just do listed regs. */
1101 for (i
= 1 + oind
; i
< argc
; i
++)
1103 regnum
= atoi (argv
[i
]);
1107 && gdbarch_register_name (gdbarch
, regnum
) != NULL
1108 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
1109 output_register (frame
, regnum
, format
, skip_unavailable
);
1111 error (_("bad register number"));
1115 /* Output one register REGNUM's contents in the desired FORMAT. If
1116 SKIP_UNAVAILABLE is true, skip the register if it is
1120 output_register (struct frame_info
*frame
, int regnum
, int format
,
1121 int skip_unavailable
)
1123 struct ui_out
*uiout
= current_uiout
;
1124 struct value
*val
= value_of_register (regnum
, frame
);
1125 struct value_print_options opts
;
1127 if (skip_unavailable
&& !value_entirely_available (val
))
1130 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1131 uiout
->field_signed ("number", regnum
);
1141 get_formatted_print_options (&opts
, format
);
1143 val_print (value_type (val
),
1144 value_embedded_offset (val
), 0,
1145 &stb
, 0, val
, &opts
, current_language
);
1146 uiout
->field_stream ("value", stb
);
1149 /* Write given values into registers. The registers and values are
1150 given as pairs. The corresponding MI command is
1151 -data-write-register-values <format>
1152 [<regnum1> <value1>...<regnumN> <valueN>] */
1154 mi_cmd_data_write_register_values (const char *command
, char **argv
, int argc
)
1156 struct regcache
*regcache
;
1157 struct gdbarch
*gdbarch
;
1160 /* Note that the test for a valid register must include checking the
1161 gdbarch_register_name because gdbarch_num_regs may be allocated
1162 for the union of the register sets within a family of related
1163 processors. In this case, some entries of gdbarch_register_name
1164 will change depending upon the particular processor being
1167 regcache
= get_current_regcache ();
1168 gdbarch
= regcache
->arch ();
1169 numregs
= gdbarch_num_cooked_regs (gdbarch
);
1172 error (_("-data-write-register-values: Usage: -data-write-register-"
1173 "values <format> [<regnum1> <value1>...<regnumN> <valueN>]"));
1175 if (!target_has_registers
)
1176 error (_("-data-write-register-values: No registers."));
1179 error (_("-data-write-register-values: No regs and values specified."));
1182 error (_("-data-write-register-values: "
1183 "Regs and vals are not in pairs."));
1185 for (i
= 1; i
< argc
; i
= i
+ 2)
1187 int regnum
= atoi (argv
[i
]);
1189 if (regnum
>= 0 && regnum
< numregs
1190 && gdbarch_register_name (gdbarch
, regnum
)
1191 && *gdbarch_register_name (gdbarch
, regnum
))
1195 /* Get the value as a number. */
1196 value
= parse_and_eval_address (argv
[i
+ 1]);
1198 /* Write it down. */
1199 regcache_cooked_write_signed (regcache
, regnum
, value
);
1202 error (_("bad register number"));
1206 /* Evaluate the value of the argument. The argument is an
1207 expression. If the expression contains spaces it needs to be
1208 included in double quotes. */
1211 mi_cmd_data_evaluate_expression (const char *command
, char **argv
, int argc
)
1214 struct value_print_options opts
;
1215 struct ui_out
*uiout
= current_uiout
;
1218 error (_("-data-evaluate-expression: "
1219 "Usage: -data-evaluate-expression expression"));
1221 expression_up expr
= parse_expression (argv
[0]);
1223 val
= evaluate_expression (expr
.get ());
1227 /* Print the result of the expression evaluation. */
1228 get_user_print_options (&opts
);
1230 common_val_print (val
, &stb
, 0, &opts
, current_language
);
1232 uiout
->field_stream ("value", stb
);
1235 /* This is the -data-read-memory command.
1237 ADDR: start address of data to be dumped.
1238 WORD-FORMAT: a char indicating format for the ``word''. See
1240 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes.
1241 NR_ROW: Number of rows.
1242 NR_COL: The number of columns (words per row).
1243 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
1244 ASCHAR for unprintable characters.
1246 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
1247 displays them. Returns:
1249 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
1252 The number of bytes read is SIZE*ROW*COL. */
1255 mi_cmd_data_read_memory (const char *command
, char **argv
, int argc
)
1257 struct gdbarch
*gdbarch
= get_current_arch ();
1258 struct ui_out
*uiout
= current_uiout
;
1260 long total_bytes
, nr_cols
, nr_rows
;
1262 struct type
*word_type
;
1274 static const struct mi_opt opts
[] =
1276 {"o", OFFSET_OPT
, 1},
1282 int opt
= mi_getopt ("-data-read-memory", argc
, argv
, opts
,
1287 switch ((enum opt
) opt
)
1290 offset
= atol (oarg
);
1297 if (argc
< 5 || argc
> 6)
1298 error (_("-data-read-memory: Usage: "
1299 "ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR]."));
1301 /* Extract all the arguments. */
1303 /* Start address of the memory dump. */
1304 addr
= parse_and_eval_address (argv
[0]) + offset
;
1305 /* The format character to use when displaying a memory word. See
1306 the ``x'' command. */
1307 word_format
= argv
[1][0];
1308 /* The size of the memory word. */
1309 word_size
= atol (argv
[2]);
1313 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1317 word_type
= builtin_type (gdbarch
)->builtin_int16
;
1321 word_type
= builtin_type (gdbarch
)->builtin_int32
;
1325 word_type
= builtin_type (gdbarch
)->builtin_int64
;
1329 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1332 /* The number of rows. */
1333 nr_rows
= atol (argv
[3]);
1335 error (_("-data-read-memory: invalid number of rows."));
1337 /* Number of bytes per row. */
1338 nr_cols
= atol (argv
[4]);
1340 error (_("-data-read-memory: invalid number of columns."));
1342 /* The un-printable character when printing ascii. */
1348 /* Create a buffer and read it in. */
1349 total_bytes
= word_size
* nr_rows
* nr_cols
;
1351 gdb::byte_vector
mbuf (total_bytes
);
1353 nr_bytes
= target_read (current_top_target (), TARGET_OBJECT_MEMORY
, NULL
,
1354 mbuf
.data (), addr
, total_bytes
);
1356 error (_("Unable to read memory."));
1358 /* Output the header information. */
1359 uiout
->field_core_addr ("addr", gdbarch
, addr
);
1360 uiout
->field_signed ("nr-bytes", nr_bytes
);
1361 uiout
->field_signed ("total-bytes", total_bytes
);
1362 uiout
->field_core_addr ("next-row", gdbarch
, addr
+ word_size
* nr_cols
);
1363 uiout
->field_core_addr ("prev-row", gdbarch
, addr
- word_size
* nr_cols
);
1364 uiout
->field_core_addr ("next-page", gdbarch
, addr
+ total_bytes
);
1365 uiout
->field_core_addr ("prev-page", gdbarch
, addr
- total_bytes
);
1367 /* Build the result as a two dimensional table. */
1374 ui_out_emit_list
list_emitter (uiout
, "memory");
1375 for (row
= 0, row_byte
= 0;
1377 row
++, row_byte
+= nr_cols
* word_size
)
1381 struct value_print_options print_opts
;
1383 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1384 uiout
->field_core_addr ("addr", gdbarch
, addr
+ row_byte
);
1385 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr +
1388 ui_out_emit_list
list_data_emitter (uiout
, "data");
1389 get_formatted_print_options (&print_opts
, word_format
);
1390 for (col
= 0, col_byte
= row_byte
;
1392 col
++, col_byte
+= word_size
)
1394 if (col_byte
+ word_size
> nr_bytes
)
1396 uiout
->field_string (NULL
, "N/A");
1401 print_scalar_formatted (&mbuf
[col_byte
], word_type
,
1402 &print_opts
, word_asize
, &stream
);
1403 uiout
->field_stream (NULL
, stream
);
1413 for (byte
= row_byte
;
1414 byte
< row_byte
+ word_size
* nr_cols
; byte
++)
1416 if (byte
>= nr_bytes
)
1418 else if (mbuf
[byte
] < 32 || mbuf
[byte
] > 126)
1419 stream
.putc (aschar
);
1421 stream
.putc (mbuf
[byte
]);
1423 uiout
->field_stream ("ascii", stream
);
1430 mi_cmd_data_read_memory_bytes (const char *command
, char **argv
, int argc
)
1432 struct gdbarch
*gdbarch
= get_current_arch ();
1433 struct ui_out
*uiout
= current_uiout
;
1437 int unit_size
= gdbarch_addressable_memory_unit_size (gdbarch
);
1444 static const struct mi_opt opts
[] =
1446 {"o", OFFSET_OPT
, 1},
1452 int opt
= mi_getopt ("-data-read-memory-bytes", argc
, argv
, opts
,
1456 switch ((enum opt
) opt
)
1459 offset
= atol (oarg
);
1467 error (_("Usage: [ -o OFFSET ] ADDR LENGTH."));
1469 addr
= parse_and_eval_address (argv
[0]) + offset
;
1470 length
= atol (argv
[1]);
1472 std::vector
<memory_read_result
> result
1473 = read_memory_robust (current_top_target (), addr
, length
);
1475 if (result
.size () == 0)
1476 error (_("Unable to read memory."));
1478 ui_out_emit_list
list_emitter (uiout
, "memory");
1479 for (const memory_read_result
&read_result
: result
)
1481 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1483 uiout
->field_core_addr ("begin", gdbarch
, read_result
.begin
);
1484 uiout
->field_core_addr ("offset", gdbarch
, read_result
.begin
- addr
);
1485 uiout
->field_core_addr ("end", gdbarch
, read_result
.end
);
1487 std::string data
= bin2hex (read_result
.data
.get (),
1488 (read_result
.end
- read_result
.begin
)
1490 uiout
->field_string ("contents", data
.c_str ());
1494 /* Implementation of the -data-write_memory command.
1496 COLUMN_OFFSET: optional argument. Must be preceded by '-o'. The
1497 offset from the beginning of the memory grid row where the cell to
1499 ADDR: start address of the row in the memory grid where the memory
1500 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
1501 the location to write to.
1502 FORMAT: a char indicating format for the ``word''. See
1504 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
1505 VALUE: value to be written into the memory address.
1507 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
1512 mi_cmd_data_write_memory (const char *command
, char **argv
, int argc
)
1514 struct gdbarch
*gdbarch
= get_current_arch ();
1515 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1518 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
1519 enough when using a compiler other than GCC. */
1528 static const struct mi_opt opts
[] =
1530 {"o", OFFSET_OPT
, 1},
1536 int opt
= mi_getopt ("-data-write-memory", argc
, argv
, opts
,
1541 switch ((enum opt
) opt
)
1544 offset
= atol (oarg
);
1552 error (_("-data-write-memory: Usage: "
1553 "[-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE."));
1555 /* Extract all the arguments. */
1556 /* Start address of the memory dump. */
1557 addr
= parse_and_eval_address (argv
[0]);
1558 /* The size of the memory word. */
1559 word_size
= atol (argv
[2]);
1561 /* Calculate the real address of the write destination. */
1562 addr
+= (offset
* word_size
);
1564 /* Get the value as a number. */
1565 value
= parse_and_eval_address (argv
[3]);
1566 /* Get the value into an array. */
1567 gdb::byte_vector
buffer (word_size
);
1568 store_signed_integer (buffer
.data (), word_size
, byte_order
, value
);
1569 /* Write it down to memory. */
1570 write_memory_with_notification (addr
, buffer
.data (), word_size
);
1573 /* Implementation of the -data-write-memory-bytes command.
1576 DATA: string of bytes to write at that address
1577 COUNT: number of bytes to be filled (decimal integer). */
1580 mi_cmd_data_write_memory_bytes (const char *command
, char **argv
, int argc
)
1584 size_t len_hex
, len_bytes
, len_units
, i
, steps
, remaining_units
;
1585 long int count_units
;
1588 if (argc
!= 2 && argc
!= 3)
1589 error (_("Usage: ADDR DATA [COUNT]."));
1591 addr
= parse_and_eval_address (argv
[0]);
1593 len_hex
= strlen (cdata
);
1594 unit_size
= gdbarch_addressable_memory_unit_size (get_current_arch ());
1596 if (len_hex
% (unit_size
* 2) != 0)
1597 error (_("Hex-encoded '%s' must represent an integral number of "
1598 "addressable memory units."),
1601 len_bytes
= len_hex
/ 2;
1602 len_units
= len_bytes
/ unit_size
;
1605 count_units
= strtoul (argv
[2], NULL
, 10);
1607 count_units
= len_units
;
1609 gdb::byte_vector
databuf (len_bytes
);
1611 for (i
= 0; i
< len_bytes
; ++i
)
1614 if (sscanf (cdata
+ i
* 2, "%02x", &x
) != 1)
1615 error (_("Invalid argument"));
1616 databuf
[i
] = (gdb_byte
) x
;
1619 gdb::byte_vector data
;
1620 if (len_units
< count_units
)
1622 /* Pattern is made of less units than count:
1623 repeat pattern to fill memory. */
1624 data
= gdb::byte_vector (count_units
* unit_size
);
1626 /* Number of times the pattern is entirely repeated. */
1627 steps
= count_units
/ len_units
;
1628 /* Number of remaining addressable memory units. */
1629 remaining_units
= count_units
% len_units
;
1630 for (i
= 0; i
< steps
; i
++)
1631 memcpy (&data
[i
* len_bytes
], &databuf
[0], len_bytes
);
1633 if (remaining_units
> 0)
1634 memcpy (&data
[steps
* len_bytes
], &databuf
[0],
1635 remaining_units
* unit_size
);
1639 /* Pattern is longer than or equal to count:
1640 just copy count addressable memory units. */
1641 data
= std::move (databuf
);
1644 write_memory_with_notification (addr
, data
.data (), count_units
);
1648 mi_cmd_enable_timings (const char *command
, char **argv
, int argc
)
1654 if (strcmp (argv
[0], "yes") == 0)
1656 else if (strcmp (argv
[0], "no") == 0)
1667 error (_("-enable-timings: Usage: %s {yes|no}"), command
);
1671 mi_cmd_list_features (const char *command
, char **argv
, int argc
)
1675 struct ui_out
*uiout
= current_uiout
;
1677 ui_out_emit_list
list_emitter (uiout
, "features");
1678 uiout
->field_string (NULL
, "frozen-varobjs");
1679 uiout
->field_string (NULL
, "pending-breakpoints");
1680 uiout
->field_string (NULL
, "thread-info");
1681 uiout
->field_string (NULL
, "data-read-memory-bytes");
1682 uiout
->field_string (NULL
, "breakpoint-notifications");
1683 uiout
->field_string (NULL
, "ada-task-info");
1684 uiout
->field_string (NULL
, "language-option");
1685 uiout
->field_string (NULL
, "info-gdb-mi-command");
1686 uiout
->field_string (NULL
, "undefined-command-error-code");
1687 uiout
->field_string (NULL
, "exec-run-start-option");
1688 uiout
->field_string (NULL
, "data-disassemble-a-option");
1690 if (ext_lang_initialized_p (get_ext_lang_defn (EXT_LANG_PYTHON
)))
1691 uiout
->field_string (NULL
, "python");
1696 error (_("-list-features should be passed no arguments"));
1700 mi_cmd_list_target_features (const char *command
, char **argv
, int argc
)
1704 struct ui_out
*uiout
= current_uiout
;
1706 ui_out_emit_list
list_emitter (uiout
, "features");
1708 uiout
->field_string (NULL
, "async");
1709 if (target_can_execute_reverse
)
1710 uiout
->field_string (NULL
, "reverse");
1714 error (_("-list-target-features should be passed no arguments"));
1718 mi_cmd_add_inferior (const char *command
, char **argv
, int argc
)
1720 struct inferior
*inf
;
1723 error (_("-add-inferior should be passed no arguments"));
1725 inf
= add_inferior_with_spaces ();
1727 current_uiout
->field_fmt ("inferior", "i%d", inf
->num
);
1730 /* Callback used to find the first inferior other than the current
1734 get_other_inferior (struct inferior
*inf
, void *arg
)
1736 if (inf
== current_inferior ())
1743 mi_cmd_remove_inferior (const char *command
, char **argv
, int argc
)
1746 struct inferior
*inf
;
1749 error (_("-remove-inferior should be passed a single argument"));
1751 if (sscanf (argv
[0], "i%d", &id
) != 1)
1752 error (_("the thread group id is syntactically invalid"));
1754 inf
= find_inferior_id (id
);
1756 error (_("the specified thread group does not exist"));
1759 error (_("cannot remove an active inferior"));
1761 if (inf
== current_inferior ())
1763 struct thread_info
*tp
= 0;
1764 struct inferior
*new_inferior
1765 = iterate_over_inferiors (get_other_inferior
, NULL
);
1767 if (new_inferior
== NULL
)
1768 error (_("Cannot remove last inferior"));
1770 set_current_inferior (new_inferior
);
1771 if (new_inferior
->pid
!= 0)
1772 tp
= any_thread_of_inferior (new_inferior
);
1774 switch_to_thread (tp
);
1776 switch_to_no_thread ();
1777 set_current_program_space (new_inferior
->pspace
);
1780 delete_inferior (inf
);
1785 /* Execute a command within a safe environment.
1786 Return <0 for error; >=0 for ok.
1788 args->action will tell mi_execute_command what action
1789 to perform after the given command has executed (display/suppress
1790 prompt, display error). */
1793 captured_mi_execute_command (struct ui_out
*uiout
, struct mi_parse
*context
)
1795 struct mi_interp
*mi
= (struct mi_interp
*) command_interp ();
1798 current_command_ts
= context
->cmd_start
;
1800 scoped_restore save_token
= make_scoped_restore (¤t_token
,
1803 running_result_record_printed
= 0;
1805 switch (context
->op
)
1808 /* A MI command was read from the input stream. */
1810 /* FIXME: gdb_???? */
1811 fprintf_unfiltered (mi
->raw_stdout
,
1812 " token=`%s' command=`%s' args=`%s'\n",
1813 context
->token
, context
->command
, context
->args
);
1815 mi_cmd_execute (context
);
1817 /* Print the result if there were no errors.
1819 Remember that on the way out of executing a command, you have
1820 to directly use the mi_interp's uiout, since the command
1821 could have reset the interpreter, in which case the current
1822 uiout will most likely crash in the mi_out_* routines. */
1823 if (!running_result_record_printed
)
1825 fputs_unfiltered (context
->token
, mi
->raw_stdout
);
1826 /* There's no particularly good reason why target-connect results
1827 in not ^done. Should kill ^connected for MI3. */
1828 fputs_unfiltered (strcmp (context
->command
, "target-select") == 0
1829 ? "^connected" : "^done", mi
->raw_stdout
);
1830 mi_out_put (uiout
, mi
->raw_stdout
);
1831 mi_out_rewind (uiout
);
1832 mi_print_timing_maybe (mi
->raw_stdout
);
1833 fputs_unfiltered ("\n", mi
->raw_stdout
);
1836 /* The command does not want anything to be printed. In that
1837 case, the command probably should not have written anything
1838 to uiout, but in case it has written something, discard it. */
1839 mi_out_rewind (uiout
);
1846 /* A CLI command was read from the input stream. */
1847 /* This "feature" will be removed as soon as we have a
1848 complete set of mi commands. */
1849 /* Echo the command on the console. */
1850 fprintf_unfiltered (gdb_stdlog
, "%s\n", context
->command
);
1851 /* Call the "console" interpreter. */
1852 argv
[0] = (char *) INTERP_CONSOLE
;
1853 argv
[1] = context
->command
;
1854 mi_cmd_interpreter_exec ("-interpreter-exec", argv
, 2);
1856 /* If we changed interpreters, DON'T print out anything. */
1857 if (current_interp_named_p (INTERP_MI
)
1858 || current_interp_named_p (INTERP_MI1
)
1859 || current_interp_named_p (INTERP_MI2
)
1860 || current_interp_named_p (INTERP_MI3
))
1862 if (!running_result_record_printed
)
1864 fputs_unfiltered (context
->token
, mi
->raw_stdout
);
1865 fputs_unfiltered ("^done", mi
->raw_stdout
);
1866 mi_out_put (uiout
, mi
->raw_stdout
);
1867 mi_out_rewind (uiout
);
1868 mi_print_timing_maybe (mi
->raw_stdout
);
1869 fputs_unfiltered ("\n", mi
->raw_stdout
);
1872 mi_out_rewind (uiout
);
1879 /* Print a gdb exception to the MI output stream. */
1882 mi_print_exception (const char *token
, const struct gdb_exception
&exception
)
1884 struct mi_interp
*mi
= (struct mi_interp
*) current_interpreter ();
1886 fputs_unfiltered (token
, mi
->raw_stdout
);
1887 fputs_unfiltered ("^error,msg=\"", mi
->raw_stdout
);
1888 if (exception
.message
== NULL
)
1889 fputs_unfiltered ("unknown error", mi
->raw_stdout
);
1891 fputstr_unfiltered (exception
.what (), '"', mi
->raw_stdout
);
1892 fputs_unfiltered ("\"", mi
->raw_stdout
);
1894 switch (exception
.error
)
1896 case UNDEFINED_COMMAND_ERROR
:
1897 fputs_unfiltered (",code=\"undefined-command\"", mi
->raw_stdout
);
1901 fputs_unfiltered ("\n", mi
->raw_stdout
);
1904 /* Determine whether the parsed command already notifies the
1905 user_selected_context_changed observer. */
1908 command_notifies_uscc_observer (struct mi_parse
*command
)
1910 if (command
->op
== CLI_COMMAND
)
1912 /* CLI commands "thread" and "inferior" already send it. */
1913 return (strncmp (command
->command
, "thread ", 7) == 0
1914 || strncmp (command
->command
, "inferior ", 9) == 0);
1916 else /* MI_COMMAND */
1918 if (strcmp (command
->command
, "interpreter-exec") == 0
1919 && command
->argc
> 1)
1921 /* "thread" and "inferior" again, but through -interpreter-exec. */
1922 return (strncmp (command
->argv
[1], "thread ", 7) == 0
1923 || strncmp (command
->argv
[1], "inferior ", 9) == 0);
1927 /* -thread-select already sends it. */
1928 return strcmp (command
->command
, "thread-select") == 0;
1933 mi_execute_command (const char *cmd
, int from_tty
)
1936 std::unique_ptr
<struct mi_parse
> command
;
1938 /* This is to handle EOF (^D). We just quit gdb. */
1939 /* FIXME: we should call some API function here. */
1941 quit_force (NULL
, from_tty
);
1943 target_log_command (cmd
);
1947 command
= mi_parse (cmd
, &token
);
1949 catch (const gdb_exception
&exception
)
1951 mi_print_exception (token
, exception
);
1955 if (command
!= NULL
)
1957 ptid_t previous_ptid
= inferior_ptid
;
1959 gdb::optional
<scoped_restore_tmpl
<int>> restore_suppress
;
1961 if (command
->cmd
!= NULL
&& command
->cmd
->suppress_notification
!= NULL
)
1962 restore_suppress
.emplace (command
->cmd
->suppress_notification
, 1);
1964 command
->token
= token
;
1968 command
->cmd_start
= new mi_timestamp ();
1969 timestamp (command
->cmd_start
);
1974 captured_mi_execute_command (current_uiout
, command
.get ());
1976 catch (const gdb_exception
&result
)
1978 /* Like in start_event_loop, enable input and force display
1979 of the prompt. Otherwise, any command that calls
1980 async_disable_stdin, and then throws, will leave input
1982 async_enable_stdin ();
1983 current_ui
->prompt_state
= PROMPT_NEEDED
;
1985 /* The command execution failed and error() was called
1987 mi_print_exception (command
->token
, result
);
1988 mi_out_rewind (current_uiout
);
1991 bpstat_do_actions ();
1993 if (/* The notifications are only output when the top-level
1994 interpreter (specified on the command line) is MI. */
1995 top_level_interpreter ()->interp_ui_out ()->is_mi_like_p ()
1996 /* Don't try report anything if there are no threads --
1997 the program is dead. */
1999 /* If the command already reports the thread change, no need to do it
2001 && !command_notifies_uscc_observer (command
.get ()))
2003 int report_change
= 0;
2005 if (command
->thread
== -1)
2007 report_change
= (previous_ptid
!= null_ptid
2008 && inferior_ptid
!= previous_ptid
2009 && inferior_ptid
!= null_ptid
);
2011 else if (inferior_ptid
!= null_ptid
)
2013 struct thread_info
*ti
= inferior_thread ();
2015 report_change
= (ti
->global_num
!= command
->thread
);
2020 gdb::observers::user_selected_context_changed
.notify
2021 (USER_SELECTED_THREAD
| USER_SELECTED_FRAME
);
2028 mi_cmd_execute (struct mi_parse
*parse
)
2030 scoped_value_mark cleanup
= prepare_execute_command ();
2032 if (parse
->all
&& parse
->thread_group
!= -1)
2033 error (_("Cannot specify --thread-group together with --all"));
2035 if (parse
->all
&& parse
->thread
!= -1)
2036 error (_("Cannot specify --thread together with --all"));
2038 if (parse
->thread_group
!= -1 && parse
->thread
!= -1)
2039 error (_("Cannot specify --thread together with --thread-group"));
2041 if (parse
->frame
!= -1 && parse
->thread
== -1)
2042 error (_("Cannot specify --frame without --thread"));
2044 if (parse
->thread_group
!= -1)
2046 struct inferior
*inf
= find_inferior_id (parse
->thread_group
);
2047 struct thread_info
*tp
= 0;
2050 error (_("Invalid thread group for the --thread-group option"));
2052 set_current_inferior (inf
);
2053 /* This behaviour means that if --thread-group option identifies
2054 an inferior with multiple threads, then a random one will be
2055 picked. This is not a problem -- frontend should always
2056 provide --thread if it wishes to operate on a specific
2059 tp
= any_live_thread_of_inferior (inf
);
2061 switch_to_thread (tp
);
2063 switch_to_no_thread ();
2064 set_current_program_space (inf
->pspace
);
2067 if (parse
->thread
!= -1)
2069 thread_info
*tp
= find_thread_global_id (parse
->thread
);
2072 error (_("Invalid thread id: %d"), parse
->thread
);
2074 if (tp
->state
== THREAD_EXITED
)
2075 error (_("Thread id: %d has terminated"), parse
->thread
);
2077 switch_to_thread (tp
);
2080 if (parse
->frame
!= -1)
2082 struct frame_info
*fid
;
2083 int frame
= parse
->frame
;
2085 fid
= find_relative_frame (get_current_frame (), &frame
);
2087 /* find_relative_frame was successful */
2090 error (_("Invalid frame id: %d"), frame
);
2093 gdb::optional
<scoped_restore_current_language
> lang_saver
;
2094 if (parse
->language
!= language_unknown
)
2096 lang_saver
.emplace ();
2097 set_language (parse
->language
);
2100 current_context
= parse
;
2102 if (parse
->cmd
->argv_func
!= NULL
)
2104 parse
->cmd
->argv_func (parse
->command
, parse
->argv
, parse
->argc
);
2106 else if (parse
->cmd
->cli
.cmd
!= 0)
2108 /* FIXME: DELETE THIS. */
2109 /* The operation is still implemented by a cli command. */
2110 /* Must be a synchronous one. */
2111 mi_execute_cli_command (parse
->cmd
->cli
.cmd
, parse
->cmd
->cli
.args_p
,
2116 /* FIXME: DELETE THIS. */
2119 stb
.puts ("Undefined mi command: ");
2120 stb
.putstr (parse
->command
, '"');
2121 stb
.puts (" (missing implementation)");
2127 /* FIXME: This is just a hack so we can get some extra commands going.
2128 We don't want to channel things through the CLI, but call libgdb directly.
2129 Use only for synchronous commands. */
2132 mi_execute_cli_command (const char *cmd
, int args_p
, const char *args
)
2136 std::string run
= cmd
;
2139 run
= run
+ " " + args
;
2141 /* FIXME: gdb_???? */
2142 fprintf_unfiltered (gdb_stdout
, "cli=%s run=%s\n",
2144 execute_command (run
.c_str (), 0 /* from_tty */ );
2149 mi_execute_async_cli_command (const char *cli_command
, char **argv
, int argc
)
2151 std::string run
= cli_command
;
2154 run
= run
+ " " + *argv
;
2158 execute_command (run
.c_str (), 0 /* from_tty */ );
2162 mi_load_progress (const char *section_name
,
2163 unsigned long sent_so_far
,
2164 unsigned long total_section
,
2165 unsigned long total_sent
,
2166 unsigned long grand_total
)
2168 using namespace std::chrono
;
2169 static steady_clock::time_point last_update
;
2170 static char *previous_sect_name
= NULL
;
2172 struct mi_interp
*mi
= (struct mi_interp
*) current_interpreter ();
2174 /* This function is called through deprecated_show_load_progress
2175 which means uiout may not be correct. Fix it for the duration
2176 of this function. */
2178 std::unique_ptr
<ui_out
> uiout (mi_out_new (current_interpreter ()->name ()));
2179 if (uiout
== nullptr)
2182 scoped_restore save_uiout
2183 = make_scoped_restore (¤t_uiout
, uiout
.get ());
2185 new_section
= (previous_sect_name
?
2186 strcmp (previous_sect_name
, section_name
) : 1);
2189 xfree (previous_sect_name
);
2190 previous_sect_name
= xstrdup (section_name
);
2193 fputs_unfiltered (current_token
, mi
->raw_stdout
);
2194 fputs_unfiltered ("+download", mi
->raw_stdout
);
2196 ui_out_emit_tuple
tuple_emitter (uiout
.get (), NULL
);
2197 uiout
->field_string ("section", section_name
);
2198 uiout
->field_signed ("section-size", total_section
);
2199 uiout
->field_signed ("total-size", grand_total
);
2201 mi_out_put (uiout
.get (), mi
->raw_stdout
);
2202 fputs_unfiltered ("\n", mi
->raw_stdout
);
2203 gdb_flush (mi
->raw_stdout
);
2206 steady_clock::time_point time_now
= steady_clock::now ();
2207 if (time_now
- last_update
> milliseconds (500))
2209 last_update
= time_now
;
2211 fputs_unfiltered (current_token
, mi
->raw_stdout
);
2212 fputs_unfiltered ("+download", mi
->raw_stdout
);
2214 ui_out_emit_tuple
tuple_emitter (uiout
.get (), NULL
);
2215 uiout
->field_string ("section", section_name
);
2216 uiout
->field_signed ("section-sent", sent_so_far
);
2217 uiout
->field_signed ("section-size", total_section
);
2218 uiout
->field_signed ("total-sent", total_sent
);
2219 uiout
->field_signed ("total-size", grand_total
);
2221 mi_out_put (uiout
.get (), mi
->raw_stdout
);
2222 fputs_unfiltered ("\n", mi
->raw_stdout
);
2223 gdb_flush (mi
->raw_stdout
);
2228 timestamp (struct mi_timestamp
*tv
)
2230 using namespace std::chrono
;
2232 tv
->wallclock
= steady_clock::now ();
2233 run_time_clock::now (tv
->utime
, tv
->stime
);
2237 print_diff_now (struct ui_file
*file
, struct mi_timestamp
*start
)
2239 struct mi_timestamp now
;
2242 print_diff (file
, start
, &now
);
2246 mi_print_timing_maybe (struct ui_file
*file
)
2248 /* If the command is -enable-timing then do_timings may be true
2249 whilst current_command_ts is not initialized. */
2250 if (do_timings
&& current_command_ts
)
2251 print_diff_now (file
, current_command_ts
);
2255 print_diff (struct ui_file
*file
, struct mi_timestamp
*start
,
2256 struct mi_timestamp
*end
)
2258 using namespace std::chrono
;
2260 duration
<double> wallclock
= end
->wallclock
- start
->wallclock
;
2261 duration
<double> utime
= end
->utime
- start
->utime
;
2262 duration
<double> stime
= end
->stime
- start
->stime
;
2266 ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
2267 wallclock
.count (), utime
.count (), stime
.count ());
2271 mi_cmd_trace_define_variable (const char *command
, char **argv
, int argc
)
2273 LONGEST initval
= 0;
2274 struct trace_state_variable
*tsv
;
2277 if (argc
!= 1 && argc
!= 2)
2278 error (_("Usage: -trace-define-variable VARIABLE [VALUE]"));
2282 error (_("Name of trace variable should start with '$'"));
2284 validate_trace_state_variable_name (name
);
2286 tsv
= find_trace_state_variable (name
);
2288 tsv
= create_trace_state_variable (name
);
2291 initval
= value_as_long (parse_and_eval (argv
[1]));
2293 tsv
->initial_value
= initval
;
2297 mi_cmd_trace_list_variables (const char *command
, char **argv
, int argc
)
2300 error (_("-trace-list-variables: no arguments allowed"));
2302 tvariables_info_1 ();
2306 mi_cmd_trace_find (const char *command
, char **argv
, int argc
)
2311 error (_("trace selection mode is required"));
2315 if (strcmp (mode
, "none") == 0)
2317 tfind_1 (tfind_number
, -1, 0, 0, 0);
2321 check_trace_running (current_trace_status ());
2323 if (strcmp (mode
, "frame-number") == 0)
2326 error (_("frame number is required"));
2327 tfind_1 (tfind_number
, atoi (argv
[1]), 0, 0, 0);
2329 else if (strcmp (mode
, "tracepoint-number") == 0)
2332 error (_("tracepoint number is required"));
2333 tfind_1 (tfind_tp
, atoi (argv
[1]), 0, 0, 0);
2335 else if (strcmp (mode
, "pc") == 0)
2338 error (_("PC is required"));
2339 tfind_1 (tfind_pc
, 0, parse_and_eval_address (argv
[1]), 0, 0);
2341 else if (strcmp (mode
, "pc-inside-range") == 0)
2344 error (_("Start and end PC are required"));
2345 tfind_1 (tfind_range
, 0, parse_and_eval_address (argv
[1]),
2346 parse_and_eval_address (argv
[2]), 0);
2348 else if (strcmp (mode
, "pc-outside-range") == 0)
2351 error (_("Start and end PC are required"));
2352 tfind_1 (tfind_outside
, 0, parse_and_eval_address (argv
[1]),
2353 parse_and_eval_address (argv
[2]), 0);
2355 else if (strcmp (mode
, "line") == 0)
2358 error (_("Line is required"));
2360 std::vector
<symtab_and_line
> sals
2361 = decode_line_with_current_source (argv
[1],
2362 DECODE_LINE_FUNFIRSTLINE
);
2363 const symtab_and_line
&sal
= sals
[0];
2365 if (sal
.symtab
== 0)
2366 error (_("Could not find the specified line"));
2368 CORE_ADDR start_pc
, end_pc
;
2369 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2370 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, 0);
2372 error (_("Could not find the specified line"));
2375 error (_("Invalid mode '%s'"), mode
);
2377 if (has_stack_frames () || get_traceframe_number () >= 0)
2378 print_stack_frame (get_selected_frame (NULL
), 1, LOC_AND_ADDRESS
, 1);
2382 mi_cmd_trace_save (const char *command
, char **argv
, int argc
)
2384 int target_saves
= 0;
2385 int generate_ctf
= 0;
2392 TARGET_SAVE_OPT
, CTF_OPT
2394 static const struct mi_opt opts
[] =
2396 {"r", TARGET_SAVE_OPT
, 0},
2397 {"ctf", CTF_OPT
, 0},
2403 int opt
= mi_getopt ("-trace-save", argc
, argv
, opts
,
2408 switch ((enum opt
) opt
)
2410 case TARGET_SAVE_OPT
:
2419 if (argc
- oind
!= 1)
2420 error (_("Exactly one argument required "
2421 "(file in which to save trace data)"));
2423 filename
= argv
[oind
];
2426 trace_save_ctf (filename
, target_saves
);
2428 trace_save_tfile (filename
, target_saves
);
2432 mi_cmd_trace_start (const char *command
, char **argv
, int argc
)
2434 start_tracing (NULL
);
2438 mi_cmd_trace_status (const char *command
, char **argv
, int argc
)
2440 trace_status_mi (0);
2444 mi_cmd_trace_stop (const char *command
, char **argv
, int argc
)
2446 stop_tracing (NULL
);
2447 trace_status_mi (1);
2450 /* Implement the "-ada-task-info" command. */
2453 mi_cmd_ada_task_info (const char *command
, char **argv
, int argc
)
2455 if (argc
!= 0 && argc
!= 1)
2456 error (_("Invalid MI command"));
2458 print_ada_task_info (current_uiout
, argv
[0], current_inferior ());
2461 /* Print EXPRESSION according to VALUES. */
2464 print_variable_or_computed (const char *expression
, enum print_values values
)
2468 struct ui_out
*uiout
= current_uiout
;
2472 expression_up expr
= parse_expression (expression
);
2474 if (values
== PRINT_SIMPLE_VALUES
)
2475 val
= evaluate_type (expr
.get ());
2477 val
= evaluate_expression (expr
.get ());
2479 gdb::optional
<ui_out_emit_tuple
> tuple_emitter
;
2480 if (values
!= PRINT_NO_VALUES
)
2481 tuple_emitter
.emplace (uiout
, nullptr);
2482 uiout
->field_string ("name", expression
);
2486 case PRINT_SIMPLE_VALUES
:
2487 type
= check_typedef (value_type (val
));
2488 type_print (value_type (val
), "", &stb
, -1);
2489 uiout
->field_stream ("type", stb
);
2490 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
2491 && TYPE_CODE (type
) != TYPE_CODE_STRUCT
2492 && TYPE_CODE (type
) != TYPE_CODE_UNION
)
2494 struct value_print_options opts
;
2496 get_no_prettyformat_print_options (&opts
);
2498 common_val_print (val
, &stb
, 0, &opts
, current_language
);
2499 uiout
->field_stream ("value", stb
);
2502 case PRINT_ALL_VALUES
:
2504 struct value_print_options opts
;
2506 get_no_prettyformat_print_options (&opts
);
2508 common_val_print (val
, &stb
, 0, &opts
, current_language
);
2509 uiout
->field_stream ("value", stb
);
2515 /* Implement the "-trace-frame-collected" command. */
2518 mi_cmd_trace_frame_collected (const char *command
, char **argv
, int argc
)
2520 struct bp_location
*tloc
;
2522 struct collection_list
*clist
;
2523 struct collection_list tracepoint_list
, stepping_list
;
2524 struct traceframe_info
*tinfo
;
2526 enum print_values var_print_values
= PRINT_ALL_VALUES
;
2527 enum print_values comp_print_values
= PRINT_ALL_VALUES
;
2528 int registers_format
= 'x';
2529 int memory_contents
= 0;
2530 struct ui_out
*uiout
= current_uiout
;
2538 static const struct mi_opt opts
[] =
2540 {"-var-print-values", VAR_PRINT_VALUES
, 1},
2541 {"-comp-print-values", COMP_PRINT_VALUES
, 1},
2542 {"-registers-format", REGISTERS_FORMAT
, 1},
2543 {"-memory-contents", MEMORY_CONTENTS
, 0},
2550 int opt
= mi_getopt ("-trace-frame-collected", argc
, argv
, opts
,
2554 switch ((enum opt
) opt
)
2556 case VAR_PRINT_VALUES
:
2557 var_print_values
= mi_parse_print_values (oarg
);
2559 case COMP_PRINT_VALUES
:
2560 comp_print_values
= mi_parse_print_values (oarg
);
2562 case REGISTERS_FORMAT
:
2563 registers_format
= oarg
[0];
2565 case MEMORY_CONTENTS
:
2566 memory_contents
= 1;
2572 error (_("Usage: -trace-frame-collected "
2573 "[--var-print-values PRINT_VALUES] "
2574 "[--comp-print-values PRINT_VALUES] "
2575 "[--registers-format FORMAT]"
2576 "[--memory-contents]"));
2578 /* This throws an error is not inspecting a trace frame. */
2579 tloc
= get_traceframe_location (&stepping_frame
);
2581 /* This command only makes sense for the current frame, not the
2583 scoped_restore_current_thread restore_thread
;
2584 select_frame (get_current_frame ());
2586 encode_actions (tloc
, &tracepoint_list
, &stepping_list
);
2589 clist
= &stepping_list
;
2591 clist
= &tracepoint_list
;
2593 tinfo
= get_traceframe_info ();
2595 /* Explicitly wholly collected variables. */
2597 ui_out_emit_list
list_emitter (uiout
, "explicit-variables");
2598 const std::vector
<std::string
> &wholly_collected
2599 = clist
->wholly_collected ();
2600 for (size_t i
= 0; i
< wholly_collected
.size (); i
++)
2602 const std::string
&str
= wholly_collected
[i
];
2603 print_variable_or_computed (str
.c_str (), var_print_values
);
2607 /* Computed expressions. */
2609 ui_out_emit_list
list_emitter (uiout
, "computed-expressions");
2611 const std::vector
<std::string
> &computed
= clist
->computed ();
2612 for (size_t i
= 0; i
< computed
.size (); i
++)
2614 const std::string
&str
= computed
[i
];
2615 print_variable_or_computed (str
.c_str (), comp_print_values
);
2619 /* Registers. Given pseudo-registers, and that some architectures
2620 (like MIPS) actually hide the raw registers, we don't go through
2621 the trace frame info, but instead consult the register cache for
2622 register availability. */
2624 struct frame_info
*frame
;
2625 struct gdbarch
*gdbarch
;
2629 ui_out_emit_list
list_emitter (uiout
, "registers");
2631 frame
= get_selected_frame (NULL
);
2632 gdbarch
= get_frame_arch (frame
);
2633 numregs
= gdbarch_num_cooked_regs (gdbarch
);
2635 for (regnum
= 0; regnum
< numregs
; regnum
++)
2637 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
2638 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
2641 output_register (frame
, regnum
, registers_format
, 1);
2645 /* Trace state variables. */
2647 ui_out_emit_list
list_emitter (uiout
, "tvars");
2649 for (int tvar
: tinfo
->tvars
)
2651 struct trace_state_variable
*tsv
;
2653 tsv
= find_trace_state_variable_by_number (tvar
);
2655 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
2659 uiout
->field_fmt ("name", "$%s", tsv
->name
.c_str ());
2661 tsv
->value_known
= target_get_trace_state_variable_value (tsv
->number
,
2663 uiout
->field_signed ("current", tsv
->value
);
2667 uiout
->field_skip ("name");
2668 uiout
->field_skip ("current");
2675 std::vector
<mem_range
> available_memory
;
2677 traceframe_available_memory (&available_memory
, 0, ULONGEST_MAX
);
2679 ui_out_emit_list
list_emitter (uiout
, "memory");
2681 for (const mem_range
&r
: available_memory
)
2683 struct gdbarch
*gdbarch
= target_gdbarch ();
2685 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
2687 uiout
->field_core_addr ("address", gdbarch
, r
.start
);
2688 uiout
->field_signed ("length", r
.length
);
2690 gdb::byte_vector
data (r
.length
);
2692 if (memory_contents
)
2694 if (target_read_memory (r
.start
, data
.data (), r
.length
) == 0)
2696 std::string data_str
= bin2hex (data
.data (), r
.length
);
2697 uiout
->field_string ("contents", data_str
.c_str ());
2700 uiout
->field_skip ("contents");
2706 /* See mi/mi-main.h. */
2709 mi_cmd_fix_multi_location_breakpoint_output (const char *command
, char **argv
,
2712 fix_multi_location_breakpoint_output_globally
= true;
2715 /* Implement the "-complete" command. */
2718 mi_cmd_complete (const char *command
, char **argv
, int argc
)
2721 error (_("Usage: -complete COMMAND"));
2723 if (max_completions
== 0)
2724 error (_("max-completions is zero, completion is disabled."));
2726 int quote_char
= '\0';
2729 completion_result result
= complete (argv
[0], &word
, "e_char
);
2731 std::string
arg_prefix (argv
[0], word
- argv
[0]);
2733 struct ui_out
*uiout
= current_uiout
;
2735 if (result
.number_matches
> 0)
2736 uiout
->field_fmt ("completion", "%s%s",
2737 arg_prefix
.c_str (),result
.match_list
[0]);
2740 ui_out_emit_list
completions_emitter (uiout
, "matches");
2742 if (result
.number_matches
== 1)
2743 uiout
->field_fmt (NULL
, "%s%s",
2744 arg_prefix
.c_str (), result
.match_list
[0]);
2747 result
.sort_match_list ();
2748 for (size_t i
= 0; i
< result
.number_matches
; i
++)
2750 uiout
->field_fmt (NULL
, "%s%s",
2751 arg_prefix
.c_str (), result
.match_list
[i
+ 1]);
2755 uiout
->field_string ("max_completions_reached",
2756 result
.number_matches
== max_completions
? "1" : "0");
2761 _initialize_mi_main (void)
2763 struct cmd_list_element
*c
;
2765 add_setshow_boolean_cmd ("mi-async", class_run
,
2767 Set whether MI asynchronous mode is enabled."), _("\
2768 Show whether MI asynchronous mode is enabled."), _("\
2769 Tells GDB whether MI should be in asynchronous mode."),
2770 set_mi_async_command
,
2771 show_mi_async_command
,
2775 /* Alias old "target-async" to "mi-async". */
2776 c
= add_alias_cmd ("target-async", "mi-async", class_run
, 0, &setlist
);
2777 deprecate_cmd (c
, "set mi-async");
2778 c
= add_alias_cmd ("target-async", "mi-async", class_run
, 0, &showlist
);
2779 deprecate_cmd (c
, "show mi-async");