3 Copyright (C) 2000-2005, 2007-2012 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"
26 #include "gdb_string.h"
27 #include "exceptions.h"
29 #include "gdbthread.h"
32 #include "mi-getopt.h"
33 #include "mi-console.h"
37 #include "event-loop.h"
38 #include "event-top.h"
39 #include "gdbcore.h" /* For write_memory(). */
45 #include "mi-common.h"
50 #include "splay-tree.h"
51 #include "tracepoint.h"
58 #if defined HAVE_SYS_RESOURCE_H
59 #include <sys/resource.h>
73 struct ui_file
*raw_stdout
;
75 /* This is used to pass the current command timestamp down to
76 continuation routines. */
77 static struct mi_timestamp
*current_command_ts
;
79 static int do_timings
= 0;
82 /* Few commands would like to know if options like --thread-group were
83 explicitly specified. This variable keeps the current parsed
84 command including all option, and make it possible. */
85 static struct mi_parse
*current_context
;
87 int running_result_record_printed
= 1;
89 /* Flag indicating that the target has proceeded since the last
90 command was issued. */
93 extern void _initialize_mi_main (void);
94 static void mi_cmd_execute (struct mi_parse
*parse
);
96 static void mi_execute_cli_command (const char *cmd
, int args_p
,
98 static void mi_execute_async_cli_command (char *cli_command
,
99 char **argv
, int argc
);
100 static int register_changed_p (int regnum
, struct regcache
*,
102 static void get_register (struct frame_info
*, int regnum
, int format
);
104 /* Command implementations. FIXME: Is this libgdb? No. This is the MI
105 layer that calls libgdb. Any operation used in the below should be
108 static void timestamp (struct mi_timestamp
*tv
);
110 static void print_diff_now (struct mi_timestamp
*start
);
111 static void print_diff (struct mi_timestamp
*start
, struct mi_timestamp
*end
);
114 mi_cmd_gdb_exit (char *command
, char **argv
, int argc
)
116 /* We have to print everything right here because we never return. */
118 fputs_unfiltered (current_token
, raw_stdout
);
119 fputs_unfiltered ("^exit\n", raw_stdout
);
120 mi_out_put (current_uiout
, raw_stdout
);
121 gdb_flush (raw_stdout
);
122 /* FIXME: The function called is not yet a formal libgdb function. */
123 quit_force (NULL
, FROM_TTY
);
127 mi_cmd_exec_next (char *command
, char **argv
, int argc
)
129 /* FIXME: Should call a libgdb function, not a cli wrapper. */
130 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
131 mi_execute_async_cli_command ("reverse-next", argv
+ 1, argc
- 1);
133 mi_execute_async_cli_command ("next", argv
, argc
);
137 mi_cmd_exec_next_instruction (char *command
, char **argv
, int argc
)
139 /* FIXME: Should call a libgdb function, not a cli wrapper. */
140 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
141 mi_execute_async_cli_command ("reverse-nexti", argv
+ 1, argc
- 1);
143 mi_execute_async_cli_command ("nexti", argv
, argc
);
147 mi_cmd_exec_step (char *command
, char **argv
, int argc
)
149 /* FIXME: Should call a libgdb function, not a cli wrapper. */
150 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
151 mi_execute_async_cli_command ("reverse-step", argv
+ 1, argc
- 1);
153 mi_execute_async_cli_command ("step", argv
, argc
);
157 mi_cmd_exec_step_instruction (char *command
, char **argv
, int argc
)
159 /* FIXME: Should call a libgdb function, not a cli wrapper. */
160 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
161 mi_execute_async_cli_command ("reverse-stepi", argv
+ 1, argc
- 1);
163 mi_execute_async_cli_command ("stepi", argv
, argc
);
167 mi_cmd_exec_finish (char *command
, char **argv
, int argc
)
169 /* FIXME: Should call a libgdb function, not a cli wrapper. */
170 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
171 mi_execute_async_cli_command ("reverse-finish", argv
+ 1, argc
- 1);
173 mi_execute_async_cli_command ("finish", argv
, argc
);
177 mi_cmd_exec_return (char *command
, char **argv
, int argc
)
179 /* This command doesn't really execute the target, it just pops the
180 specified number of frames. */
182 /* Call return_command with from_tty argument equal to 0 so as to
183 avoid being queried. */
184 return_command (*argv
, 0);
186 /* Call return_command with from_tty argument equal to 0 so as to
187 avoid being queried. */
188 return_command (NULL
, 0);
190 /* Because we have called return_command with from_tty = 0, we need
191 to print the frame here. */
192 print_stack_frame (get_selected_frame (NULL
), 1, LOC_AND_ADDRESS
);
196 mi_cmd_exec_jump (char *args
, char **argv
, int argc
)
198 /* FIXME: Should call a libgdb function, not a cli wrapper. */
199 mi_execute_async_cli_command ("jump", argv
, argc
);
203 proceed_thread (struct thread_info
*thread
, int pid
)
205 if (!is_stopped (thread
->ptid
))
208 if (pid
!= 0 && PIDGET (thread
->ptid
) != pid
)
211 switch_to_thread (thread
->ptid
);
212 clear_proceed_status ();
213 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 0);
217 proceed_thread_callback (struct thread_info
*thread
, void *arg
)
219 int pid
= *(int *)arg
;
221 proceed_thread (thread
, pid
);
226 exec_continue (char **argv
, int argc
)
230 /* In non-stop mode, 'resume' always resumes a single thread.
231 Therefore, to resume all threads of the current inferior, or
232 all threads in all inferiors, we need to iterate over
235 See comment on infcmd.c:proceed_thread_callback for rationale. */
236 if (current_context
->all
|| current_context
->thread_group
!= -1)
239 struct cleanup
*back_to
= make_cleanup_restore_current_thread ();
241 if (!current_context
->all
)
244 = find_inferior_id (current_context
->thread_group
);
248 iterate_over_threads (proceed_thread_callback
, &pid
);
249 do_cleanups (back_to
);
258 struct cleanup
*back_to
= make_cleanup_restore_integer (&sched_multi
);
260 if (current_context
->all
)
267 /* In all-stop mode, -exec-continue traditionally resumed
268 either all threads, or one thread, depending on the
269 'scheduler-locking' variable. Let's continue to do the
273 do_cleanups (back_to
);
278 exec_direction_forward (void *notused
)
280 execution_direction
= EXEC_FORWARD
;
284 exec_reverse_continue (char **argv
, int argc
)
286 enum exec_direction_kind dir
= execution_direction
;
287 struct cleanup
*old_chain
;
289 if (dir
== EXEC_REVERSE
)
290 error (_("Already in reverse mode."));
292 if (!target_can_execute_reverse
)
293 error (_("Target %s does not support this command."), target_shortname
);
295 old_chain
= make_cleanup (exec_direction_forward
, NULL
);
296 execution_direction
= EXEC_REVERSE
;
297 exec_continue (argv
, argc
);
298 do_cleanups (old_chain
);
302 mi_cmd_exec_continue (char *command
, char **argv
, int argc
)
304 if (argc
> 0 && strcmp (argv
[0], "--reverse") == 0)
305 exec_reverse_continue (argv
+ 1, argc
- 1);
307 exec_continue (argv
, argc
);
311 interrupt_thread_callback (struct thread_info
*thread
, void *arg
)
313 int pid
= *(int *)arg
;
315 if (!is_running (thread
->ptid
))
318 if (PIDGET (thread
->ptid
) != pid
)
321 target_stop (thread
->ptid
);
325 /* Interrupt the execution of the target. Note how we must play
326 around with the token variables, in order to display the current
327 token in the result of the interrupt command, and the previous
328 execution token when the target finally stops. See comments in
332 mi_cmd_exec_interrupt (char *command
, char **argv
, int argc
)
334 /* In all-stop mode, everything stops, so we don't need to try
335 anything specific. */
338 interrupt_target_1 (0);
342 if (current_context
->all
)
344 /* This will interrupt all threads in all inferiors. */
345 interrupt_target_1 (1);
347 else if (current_context
->thread_group
!= -1)
349 struct inferior
*inf
= find_inferior_id (current_context
->thread_group
);
351 iterate_over_threads (interrupt_thread_callback
, &inf
->pid
);
355 /* Interrupt just the current thread -- either explicitly
356 specified via --thread or whatever was current before
357 MI command was sent. */
358 interrupt_target_1 (0);
363 run_one_inferior (struct inferior
*inf
, void *arg
)
367 if (inf
->pid
!= ptid_get_pid (inferior_ptid
))
369 struct thread_info
*tp
;
371 tp
= any_thread_of_process (inf
->pid
);
373 error (_("Inferior has no threads."));
375 switch_to_thread (tp
->ptid
);
380 set_current_inferior (inf
);
381 switch_to_thread (null_ptid
);
382 set_current_program_space (inf
->pspace
);
384 mi_execute_cli_command ("run", target_can_async_p (),
385 target_can_async_p () ? "&" : NULL
);
390 mi_cmd_exec_run (char *command
, char **argv
, int argc
)
392 if (current_context
->all
)
394 struct cleanup
*back_to
= save_current_space_and_thread ();
396 iterate_over_inferiors (run_one_inferior
, NULL
);
397 do_cleanups (back_to
);
401 mi_execute_cli_command ("run", target_can_async_p (),
402 target_can_async_p () ? "&" : NULL
);
408 find_thread_of_process (struct thread_info
*ti
, void *p
)
412 if (PIDGET (ti
->ptid
) == pid
&& !is_exited (ti
->ptid
))
419 mi_cmd_target_detach (char *command
, char **argv
, int argc
)
421 if (argc
!= 0 && argc
!= 1)
422 error (_("Usage: -target-detach [pid | thread-group]"));
426 struct thread_info
*tp
;
430 /* First see if we are dealing with a thread-group id. */
433 struct inferior
*inf
;
434 int id
= strtoul (argv
[0] + 1, &end
, 0);
437 error (_("Invalid syntax of thread-group id '%s'"), argv
[0]);
439 inf
= find_inferior_id (id
);
441 error (_("Non-existent thread-group id '%d'"), id
);
447 /* We must be dealing with a pid. */
448 pid
= strtol (argv
[0], &end
, 10);
451 error (_("Invalid identifier '%s'"), argv
[0]);
454 /* Pick any thread in the desired process. Current
455 target_detach detaches from the parent of inferior_ptid. */
456 tp
= iterate_over_threads (find_thread_of_process
, &pid
);
458 error (_("Thread group is empty"));
460 switch_to_thread (tp
->ptid
);
463 detach_command (NULL
, 0);
467 mi_cmd_thread_select (char *command
, char **argv
, int argc
)
470 char *mi_error_message
;
473 error (_("-thread-select: USAGE: threadnum."));
475 rc
= gdb_thread_select (current_uiout
, argv
[0], &mi_error_message
);
477 if (rc
== GDB_RC_FAIL
)
479 make_cleanup (xfree
, mi_error_message
);
480 error ("%s", mi_error_message
);
485 mi_cmd_thread_list_ids (char *command
, char **argv
, int argc
)
488 char *mi_error_message
;
491 error (_("-thread-list-ids: No arguments required."));
493 rc
= gdb_list_thread_ids (current_uiout
, &mi_error_message
);
495 if (rc
== GDB_RC_FAIL
)
497 make_cleanup (xfree
, mi_error_message
);
498 error ("%s", mi_error_message
);
503 mi_cmd_thread_info (char *command
, char **argv
, int argc
)
505 if (argc
!= 0 && argc
!= 1)
506 error (_("Invalid MI command"));
508 print_thread_info (current_uiout
, argv
[0], -1);
513 struct collect_cores_data
521 collect_cores (struct thread_info
*ti
, void *xdata
)
523 struct collect_cores_data
*data
= xdata
;
525 if (ptid_get_pid (ti
->ptid
) == data
->pid
)
527 int core
= target_core_of_thread (ti
->ptid
);
530 VEC_safe_push (int, data
->cores
, core
);
537 unique (int *b
, int *e
)
547 struct print_one_inferior_data
550 VEC (int) *inferiors
;
554 print_one_inferior (struct inferior
*inferior
, void *xdata
)
556 struct print_one_inferior_data
*top_data
= xdata
;
557 struct ui_out
*uiout
= current_uiout
;
559 if (VEC_empty (int, top_data
->inferiors
)
560 || bsearch (&(inferior
->pid
), VEC_address (int, top_data
->inferiors
),
561 VEC_length (int, top_data
->inferiors
), sizeof (int),
562 compare_positive_ints
))
564 struct collect_cores_data data
;
565 struct cleanup
*back_to
566 = make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
568 ui_out_field_fmt (uiout
, "id", "i%d", inferior
->num
);
569 ui_out_field_string (uiout
, "type", "process");
570 if (inferior
->pid
!= 0)
571 ui_out_field_int (uiout
, "pid", inferior
->pid
);
573 if (inferior
->pspace
->ebfd
)
575 ui_out_field_string (uiout
, "executable",
576 bfd_get_filename (inferior
->pspace
->ebfd
));
580 if (inferior
->pid
!= 0)
582 data
.pid
= inferior
->pid
;
583 iterate_over_threads (collect_cores
, &data
);
586 if (!VEC_empty (int, data
.cores
))
589 struct cleanup
*back_to_2
=
590 make_cleanup_ui_out_list_begin_end (uiout
, "cores");
592 qsort (VEC_address (int, data
.cores
),
593 VEC_length (int, data
.cores
), sizeof (int),
594 compare_positive_ints
);
596 b
= VEC_address (int, data
.cores
);
597 e
= b
+ VEC_length (int, data
.cores
);
601 ui_out_field_int (uiout
, NULL
, *b
);
603 do_cleanups (back_to_2
);
606 if (top_data
->recurse
)
607 print_thread_info (uiout
, NULL
, inferior
->pid
);
609 do_cleanups (back_to
);
615 /* Output a field named 'cores' with a list as the value. The
616 elements of the list are obtained by splitting 'cores' on
620 output_cores (struct ui_out
*uiout
, const char *field_name
, const char *xcores
)
622 struct cleanup
*back_to
= make_cleanup_ui_out_list_begin_end (uiout
,
624 char *cores
= xstrdup (xcores
);
627 make_cleanup (xfree
, cores
);
629 for (p
= strtok (p
, ","); p
; p
= strtok (NULL
, ","))
630 ui_out_field_string (uiout
, NULL
, p
);
632 do_cleanups (back_to
);
636 free_vector_of_ints (void *xvector
)
638 VEC (int) **vector
= xvector
;
640 VEC_free (int, *vector
);
644 do_nothing (splay_tree_key k
)
649 free_vector_of_osdata_items (splay_tree_value xvalue
)
651 VEC (osdata_item_s
) *value
= (VEC (osdata_item_s
) *) xvalue
;
653 /* We don't free the items itself, it will be done separately. */
654 VEC_free (osdata_item_s
, value
);
658 splay_tree_int_comparator (splay_tree_key xa
, splay_tree_key xb
)
667 free_splay_tree (void *xt
)
670 splay_tree_delete (t
);
674 list_available_thread_groups (VEC (int) *ids
, int recurse
)
677 struct osdata_item
*item
;
679 struct ui_out
*uiout
= current_uiout
;
681 /* This keeps a map from integer (pid) to VEC (struct osdata_item *)*
682 The vector contains information about all threads for the given pid.
683 This is assigned an initial value to avoid "may be used uninitialized"
685 splay_tree tree
= NULL
;
687 /* get_osdata will throw if it cannot return data. */
688 data
= get_osdata ("processes");
689 make_cleanup_osdata_free (data
);
693 struct osdata
*threads
= get_osdata ("threads");
695 make_cleanup_osdata_free (threads
);
696 tree
= splay_tree_new (splay_tree_int_comparator
,
698 free_vector_of_osdata_items
);
699 make_cleanup (free_splay_tree
, tree
);
702 VEC_iterate (osdata_item_s
, threads
->items
,
706 const char *pid
= get_osdata_column (item
, "pid");
707 int pid_i
= strtoul (pid
, NULL
, 0);
708 VEC (osdata_item_s
) *vec
= 0;
710 splay_tree_node n
= splay_tree_lookup (tree
, pid_i
);
713 VEC_safe_push (osdata_item_s
, vec
, item
);
714 splay_tree_insert (tree
, pid_i
, (splay_tree_value
)vec
);
718 vec
= (VEC (osdata_item_s
) *) n
->value
;
719 VEC_safe_push (osdata_item_s
, vec
, item
);
720 n
->value
= (splay_tree_value
) vec
;
725 make_cleanup_ui_out_list_begin_end (uiout
, "groups");
728 VEC_iterate (osdata_item_s
, data
->items
,
732 struct cleanup
*back_to
;
734 const char *pid
= get_osdata_column (item
, "pid");
735 const char *cmd
= get_osdata_column (item
, "command");
736 const char *user
= get_osdata_column (item
, "user");
737 const char *cores
= get_osdata_column (item
, "cores");
739 int pid_i
= strtoul (pid
, NULL
, 0);
741 /* At present, the target will return all available processes
742 and if information about specific ones was required, we filter
743 undesired processes here. */
744 if (ids
&& bsearch (&pid_i
, VEC_address (int, ids
),
745 VEC_length (int, ids
),
746 sizeof (int), compare_positive_ints
) == NULL
)
750 back_to
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
752 ui_out_field_fmt (uiout
, "id", "%s", pid
);
753 ui_out_field_string (uiout
, "type", "process");
755 ui_out_field_string (uiout
, "description", cmd
);
757 ui_out_field_string (uiout
, "user", user
);
759 output_cores (uiout
, "cores", cores
);
763 splay_tree_node n
= splay_tree_lookup (tree
, pid_i
);
766 VEC (osdata_item_s
) *children
= (VEC (osdata_item_s
) *) n
->value
;
767 struct osdata_item
*child
;
770 make_cleanup_ui_out_list_begin_end (uiout
, "threads");
773 VEC_iterate (osdata_item_s
, children
, ix_child
, child
);
776 struct cleanup
*back_to_2
=
777 make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
778 const char *tid
= get_osdata_column (child
, "tid");
779 const char *tcore
= get_osdata_column (child
, "core");
781 ui_out_field_string (uiout
, "id", tid
);
783 ui_out_field_string (uiout
, "core", tcore
);
785 do_cleanups (back_to_2
);
790 do_cleanups (back_to
);
795 mi_cmd_list_thread_groups (char *command
, char **argv
, int argc
)
797 struct ui_out
*uiout
= current_uiout
;
798 struct cleanup
*back_to
;
805 AVAILABLE_OPT
, RECURSE_OPT
807 static const struct mi_opt opts
[] =
809 {"-available", AVAILABLE_OPT
, 0},
810 {"-recurse", RECURSE_OPT
, 1},
819 int opt
= mi_getopt ("-list-thread-groups", argc
, argv
, opts
,
824 switch ((enum opt
) opt
)
830 if (strcmp (oarg
, "0") == 0)
832 else if (strcmp (oarg
, "1") == 0)
835 error (_("only '0' and '1' are valid values "
836 "for the '--recurse' option"));
841 for (; oind
< argc
; ++oind
)
846 if (*(argv
[oind
]) != 'i')
847 error (_("invalid syntax of group id '%s'"), argv
[oind
]);
849 inf
= strtoul (argv
[oind
] + 1, &end
, 0);
852 error (_("invalid syntax of group id '%s'"), argv
[oind
]);
853 VEC_safe_push (int, ids
, inf
);
855 if (VEC_length (int, ids
) > 1)
856 qsort (VEC_address (int, ids
),
857 VEC_length (int, ids
),
858 sizeof (int), compare_positive_ints
);
860 back_to
= make_cleanup (free_vector_of_ints
, &ids
);
864 list_available_thread_groups (ids
, recurse
);
866 else if (VEC_length (int, ids
) == 1)
868 /* Local thread groups, single id. */
869 int id
= *VEC_address (int, ids
);
870 struct inferior
*inf
= find_inferior_id (id
);
873 error (_("Non-existent thread group id '%d'"), id
);
875 print_thread_info (uiout
, NULL
, inf
->pid
);
879 struct print_one_inferior_data data
;
881 data
.recurse
= recurse
;
882 data
.inferiors
= ids
;
884 /* Local thread groups. Either no explicit ids -- and we
885 print everything, or several explicit ids. In both cases,
886 we print more than one group, and have to use 'groups'
887 as the top-level element. */
888 make_cleanup_ui_out_list_begin_end (uiout
, "groups");
889 update_thread_list ();
890 iterate_over_inferiors (print_one_inferior
, &data
);
893 do_cleanups (back_to
);
897 mi_cmd_data_list_register_names (char *command
, char **argv
, int argc
)
899 struct gdbarch
*gdbarch
;
900 struct ui_out
*uiout
= current_uiout
;
903 struct cleanup
*cleanup
;
905 /* Note that the test for a valid register must include checking the
906 gdbarch_register_name because gdbarch_num_regs may be allocated
907 for the union of the register sets within a family of related
908 processors. In this case, some entries of gdbarch_register_name
909 will change depending upon the particular processor being
912 gdbarch
= get_current_arch ();
913 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
915 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "register-names");
917 if (argc
== 0) /* No args, just do all the regs. */
923 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
924 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
925 ui_out_field_string (uiout
, NULL
, "");
927 ui_out_field_string (uiout
, NULL
,
928 gdbarch_register_name (gdbarch
, regnum
));
932 /* Else, list of register #s, just do listed regs. */
933 for (i
= 0; i
< argc
; i
++)
935 regnum
= atoi (argv
[i
]);
936 if (regnum
< 0 || regnum
>= numregs
)
937 error (_("bad register number"));
939 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
940 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
941 ui_out_field_string (uiout
, NULL
, "");
943 ui_out_field_string (uiout
, NULL
,
944 gdbarch_register_name (gdbarch
, regnum
));
946 do_cleanups (cleanup
);
950 mi_cmd_data_list_changed_registers (char *command
, char **argv
, int argc
)
952 static struct regcache
*this_regs
= NULL
;
953 struct ui_out
*uiout
= current_uiout
;
954 struct regcache
*prev_regs
;
955 struct gdbarch
*gdbarch
;
956 int regnum
, numregs
, changed
;
958 struct cleanup
*cleanup
;
960 /* The last time we visited this function, the current frame's
961 register contents were saved in THIS_REGS. Move THIS_REGS over
962 to PREV_REGS, and refresh THIS_REGS with the now-current register
965 prev_regs
= this_regs
;
966 this_regs
= frame_save_as_regcache (get_selected_frame (NULL
));
967 cleanup
= make_cleanup_regcache_xfree (prev_regs
);
969 /* Note that the test for a valid register must include checking the
970 gdbarch_register_name because gdbarch_num_regs may be allocated
971 for the union of the register sets within a family of related
972 processors. In this case, some entries of gdbarch_register_name
973 will change depending upon the particular processor being
976 gdbarch
= get_regcache_arch (this_regs
);
977 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
979 make_cleanup_ui_out_list_begin_end (uiout
, "changed-registers");
983 /* No args, just do all the regs. */
988 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
989 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
991 changed
= register_changed_p (regnum
, prev_regs
, this_regs
);
993 error (_("-data-list-changed-registers: "
994 "Unable to read register contents."));
996 ui_out_field_int (uiout
, NULL
, regnum
);
1000 /* Else, list of register #s, just do listed regs. */
1001 for (i
= 0; i
< argc
; i
++)
1003 regnum
= atoi (argv
[i
]);
1007 && gdbarch_register_name (gdbarch
, regnum
) != NULL
1008 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
1010 changed
= register_changed_p (regnum
, prev_regs
, this_regs
);
1012 error (_("-data-list-changed-registers: "
1013 "Unable to read register contents."));
1015 ui_out_field_int (uiout
, NULL
, regnum
);
1018 error (_("bad register number"));
1020 do_cleanups (cleanup
);
1024 register_changed_p (int regnum
, struct regcache
*prev_regs
,
1025 struct regcache
*this_regs
)
1027 struct gdbarch
*gdbarch
= get_regcache_arch (this_regs
);
1028 gdb_byte prev_buffer
[MAX_REGISTER_SIZE
];
1029 gdb_byte this_buffer
[MAX_REGISTER_SIZE
];
1030 enum register_status prev_status
;
1031 enum register_status this_status
;
1033 /* First time through or after gdbarch change consider all registers
1035 if (!prev_regs
|| get_regcache_arch (prev_regs
) != gdbarch
)
1038 /* Get register contents and compare. */
1039 prev_status
= regcache_cooked_read (prev_regs
, regnum
, prev_buffer
);
1040 this_status
= regcache_cooked_read (this_regs
, regnum
, this_buffer
);
1042 if (this_status
!= prev_status
)
1044 else if (this_status
== REG_VALID
)
1045 return memcmp (prev_buffer
, this_buffer
,
1046 register_size (gdbarch
, regnum
)) != 0;
1051 /* Return a list of register number and value pairs. The valid
1052 arguments expected are: a letter indicating the format in which to
1053 display the registers contents. This can be one of: x
1054 (hexadecimal), d (decimal), N (natural), t (binary), o (octal), r
1055 (raw). After the format argument there can be a sequence of
1056 numbers, indicating which registers to fetch the content of. If
1057 the format is the only argument, a list of all the registers with
1058 their values is returned. */
1061 mi_cmd_data_list_register_values (char *command
, char **argv
, int argc
)
1063 struct ui_out
*uiout
= current_uiout
;
1064 struct frame_info
*frame
;
1065 struct gdbarch
*gdbarch
;
1066 int regnum
, numregs
, format
;
1068 struct cleanup
*list_cleanup
, *tuple_cleanup
;
1070 /* Note that the test for a valid register must include checking the
1071 gdbarch_register_name because gdbarch_num_regs may be allocated
1072 for the union of the register sets within a family of related
1073 processors. In this case, some entries of gdbarch_register_name
1074 will change depending upon the particular processor being
1078 error (_("-data-list-register-values: Usage: "
1079 "-data-list-register-values <format> [<regnum1>...<regnumN>]"));
1081 format
= (int) argv
[0][0];
1083 frame
= get_selected_frame (NULL
);
1084 gdbarch
= get_frame_arch (frame
);
1085 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1087 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "register-values");
1091 /* No args, beside the format: do all the regs. */
1096 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1097 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1099 tuple_cleanup
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1100 ui_out_field_int (uiout
, "number", regnum
);
1101 get_register (frame
, regnum
, format
);
1102 do_cleanups (tuple_cleanup
);
1106 /* Else, list of register #s, just do listed regs. */
1107 for (i
= 1; i
< argc
; i
++)
1109 regnum
= atoi (argv
[i
]);
1113 && gdbarch_register_name (gdbarch
, regnum
) != NULL
1114 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
1116 tuple_cleanup
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1117 ui_out_field_int (uiout
, "number", regnum
);
1118 get_register (frame
, regnum
, format
);
1119 do_cleanups (tuple_cleanup
);
1122 error (_("bad register number"));
1124 do_cleanups (list_cleanup
);
1127 /* Output one register's contents in the desired format. */
1130 get_register (struct frame_info
*frame
, int regnum
, int format
)
1132 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1133 struct ui_out
*uiout
= current_uiout
;
1135 enum lval_type lval
;
1136 struct ui_stream
*stb
;
1139 stb
= ui_out_stream_new (uiout
);
1144 val
= get_frame_register_value (frame
, regnum
);
1146 if (value_optimized_out (val
))
1147 error (_("Optimized out"));
1152 char *ptr
, buf
[1024];
1153 const gdb_byte
*valaddr
= value_contents_for_printing (val
);
1157 for (j
= 0; j
< register_size (gdbarch
, regnum
); j
++)
1159 int idx
= gdbarch_byte_order (gdbarch
) == BFD_ENDIAN_BIG
?
1160 j
: register_size (gdbarch
, regnum
) - 1 - j
;
1162 sprintf (ptr
, "%02x", (unsigned char) valaddr
[idx
]);
1165 ui_out_field_string (uiout
, "value", buf
);
1169 struct value_print_options opts
;
1171 get_formatted_print_options (&opts
, format
);
1173 val_print (value_type (val
),
1174 value_contents_for_printing (val
),
1175 value_embedded_offset (val
), 0,
1176 stb
->stream
, 0, val
, &opts
, current_language
);
1177 ui_out_field_stream (uiout
, "value", stb
);
1178 ui_out_stream_delete (stb
);
1182 /* Write given values into registers. The registers and values are
1183 given as pairs. The corresponding MI command is
1184 -data-write-register-values <format>
1185 [<regnum1> <value1>...<regnumN> <valueN>] */
1187 mi_cmd_data_write_register_values (char *command
, char **argv
, int argc
)
1189 struct regcache
*regcache
;
1190 struct gdbarch
*gdbarch
;
1194 /* Note that the test for a valid register must include checking the
1195 gdbarch_register_name because gdbarch_num_regs may be allocated
1196 for the union of the register sets within a family of related
1197 processors. In this case, some entries of gdbarch_register_name
1198 will change depending upon the particular processor being
1201 regcache
= get_current_regcache ();
1202 gdbarch
= get_regcache_arch (regcache
);
1203 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1206 error (_("-data-write-register-values: Usage: -data-write-register-"
1207 "values <format> [<regnum1> <value1>...<regnumN> <valueN>]"));
1209 format
= (int) argv
[0][0];
1211 if (!target_has_registers
)
1212 error (_("-data-write-register-values: No registers."));
1215 error (_("-data-write-register-values: No regs and values specified."));
1218 error (_("-data-write-register-values: "
1219 "Regs and vals are not in pairs."));
1221 for (i
= 1; i
< argc
; i
= i
+ 2)
1223 int regnum
= atoi (argv
[i
]);
1225 if (regnum
>= 0 && regnum
< numregs
1226 && gdbarch_register_name (gdbarch
, regnum
)
1227 && *gdbarch_register_name (gdbarch
, regnum
))
1231 /* Get the value as a number. */
1232 value
= parse_and_eval_address (argv
[i
+ 1]);
1234 /* Write it down. */
1235 regcache_cooked_write_signed (regcache
, regnum
, value
);
1238 error (_("bad register number"));
1242 /* Evaluate the value of the argument. The argument is an
1243 expression. If the expression contains spaces it needs to be
1244 included in double quotes. */
1247 mi_cmd_data_evaluate_expression (char *command
, char **argv
, int argc
)
1249 struct expression
*expr
;
1250 struct cleanup
*old_chain
= NULL
;
1252 struct ui_stream
*stb
= NULL
;
1253 struct value_print_options opts
;
1254 struct ui_out
*uiout
= current_uiout
;
1256 stb
= ui_out_stream_new (uiout
);
1260 ui_out_stream_delete (stb
);
1261 error (_("-data-evaluate-expression: "
1262 "Usage: -data-evaluate-expression expression"));
1265 expr
= parse_expression (argv
[0]);
1267 old_chain
= make_cleanup (free_current_contents
, &expr
);
1269 val
= evaluate_expression (expr
);
1271 /* Print the result of the expression evaluation. */
1272 get_user_print_options (&opts
);
1274 common_val_print (val
, stb
->stream
, 0, &opts
, current_language
);
1276 ui_out_field_stream (uiout
, "value", stb
);
1277 ui_out_stream_delete (stb
);
1279 do_cleanups (old_chain
);
1282 /* This is the -data-read-memory command.
1284 ADDR: start address of data to be dumped.
1285 WORD-FORMAT: a char indicating format for the ``word''. See
1287 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes.
1288 NR_ROW: Number of rows.
1289 NR_COL: The number of colums (words per row).
1290 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
1291 ASCHAR for unprintable characters.
1293 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
1294 displayes them. Returns:
1296 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
1299 The number of bytes read is SIZE*ROW*COL. */
1302 mi_cmd_data_read_memory (char *command
, char **argv
, int argc
)
1304 struct gdbarch
*gdbarch
= get_current_arch ();
1305 struct ui_out
*uiout
= current_uiout
;
1306 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
1308 long total_bytes
, nr_cols
, nr_rows
;
1310 struct type
*word_type
;
1323 static const struct mi_opt opts
[] =
1325 {"o", OFFSET_OPT
, 1},
1331 int opt
= mi_getopt ("-data-read-memory", argc
, argv
, opts
,
1336 switch ((enum opt
) opt
)
1339 offset
= atol (oarg
);
1346 if (argc
< 5 || argc
> 6)
1347 error (_("-data-read-memory: Usage: "
1348 "ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR]."));
1350 /* Extract all the arguments. */
1352 /* Start address of the memory dump. */
1353 addr
= parse_and_eval_address (argv
[0]) + offset
;
1354 /* The format character to use when displaying a memory word. See
1355 the ``x'' command. */
1356 word_format
= argv
[1][0];
1357 /* The size of the memory word. */
1358 word_size
= atol (argv
[2]);
1362 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1366 word_type
= builtin_type (gdbarch
)->builtin_int16
;
1370 word_type
= builtin_type (gdbarch
)->builtin_int32
;
1374 word_type
= builtin_type (gdbarch
)->builtin_int64
;
1378 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1381 /* The number of rows. */
1382 nr_rows
= atol (argv
[3]);
1384 error (_("-data-read-memory: invalid number of rows."));
1386 /* Number of bytes per row. */
1387 nr_cols
= atol (argv
[4]);
1389 error (_("-data-read-memory: invalid number of columns."));
1391 /* The un-printable character when printing ascii. */
1397 /* Create a buffer and read it in. */
1398 total_bytes
= word_size
* nr_rows
* nr_cols
;
1399 mbuf
= xcalloc (total_bytes
, 1);
1400 make_cleanup (xfree
, mbuf
);
1402 /* Dispatch memory reads to the topmost target, not the flattened
1404 nr_bytes
= target_read (current_target
.beneath
,
1405 TARGET_OBJECT_MEMORY
, NULL
, mbuf
,
1408 error (_("Unable to read memory."));
1410 /* Output the header information. */
1411 ui_out_field_core_addr (uiout
, "addr", gdbarch
, addr
);
1412 ui_out_field_int (uiout
, "nr-bytes", nr_bytes
);
1413 ui_out_field_int (uiout
, "total-bytes", total_bytes
);
1414 ui_out_field_core_addr (uiout
, "next-row",
1415 gdbarch
, addr
+ word_size
* nr_cols
);
1416 ui_out_field_core_addr (uiout
, "prev-row",
1417 gdbarch
, addr
- word_size
* nr_cols
);
1418 ui_out_field_core_addr (uiout
, "next-page", gdbarch
, addr
+ total_bytes
);
1419 ui_out_field_core_addr (uiout
, "prev-page", gdbarch
, addr
- total_bytes
);
1421 /* Build the result as a two dimentional table. */
1423 struct ui_stream
*stream
= ui_out_stream_new (uiout
);
1424 struct cleanup
*cleanup_list_memory
;
1428 cleanup_list_memory
= make_cleanup_ui_out_list_begin_end (uiout
, "memory");
1429 for (row
= 0, row_byte
= 0;
1431 row
++, row_byte
+= nr_cols
* word_size
)
1435 struct cleanup
*cleanup_tuple
;
1436 struct cleanup
*cleanup_list_data
;
1437 struct value_print_options opts
;
1439 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1440 ui_out_field_core_addr (uiout
, "addr", gdbarch
, addr
+ row_byte
);
1441 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr +
1443 cleanup_list_data
= make_cleanup_ui_out_list_begin_end (uiout
, "data");
1444 get_formatted_print_options (&opts
, word_format
);
1445 for (col
= 0, col_byte
= row_byte
;
1447 col
++, col_byte
+= word_size
)
1449 if (col_byte
+ word_size
> nr_bytes
)
1451 ui_out_field_string (uiout
, NULL
, "N/A");
1455 ui_file_rewind (stream
->stream
);
1456 print_scalar_formatted (mbuf
+ col_byte
, word_type
, &opts
,
1457 word_asize
, stream
->stream
);
1458 ui_out_field_stream (uiout
, NULL
, stream
);
1461 do_cleanups (cleanup_list_data
);
1466 ui_file_rewind (stream
->stream
);
1467 for (byte
= row_byte
;
1468 byte
< row_byte
+ word_size
* nr_cols
; byte
++)
1470 if (byte
>= nr_bytes
)
1471 fputc_unfiltered ('X', stream
->stream
);
1472 else if (mbuf
[byte
] < 32 || mbuf
[byte
] > 126)
1473 fputc_unfiltered (aschar
, stream
->stream
);
1475 fputc_unfiltered (mbuf
[byte
], stream
->stream
);
1477 ui_out_field_stream (uiout
, "ascii", stream
);
1479 do_cleanups (cleanup_tuple
);
1481 ui_out_stream_delete (stream
);
1482 do_cleanups (cleanup_list_memory
);
1484 do_cleanups (cleanups
);
1488 mi_cmd_data_read_memory_bytes (char *command
, char **argv
, int argc
)
1490 struct gdbarch
*gdbarch
= get_current_arch ();
1491 struct ui_out
*uiout
= current_uiout
;
1492 struct cleanup
*cleanups
;
1495 memory_read_result_s
*read_result
;
1497 VEC(memory_read_result_s
) *result
;
1505 static const struct mi_opt opts
[] =
1507 {"o", OFFSET_OPT
, 1},
1513 int opt
= mi_getopt ("-data-read-memory-bytes", argc
, argv
, opts
,
1517 switch ((enum opt
) opt
)
1520 offset
= atol (oarg
);
1528 error (_("Usage: [ -o OFFSET ] ADDR LENGTH."));
1530 addr
= parse_and_eval_address (argv
[0]) + offset
;
1531 length
= atol (argv
[1]);
1533 result
= read_memory_robust (current_target
.beneath
, addr
, length
);
1535 cleanups
= make_cleanup (free_memory_read_result_vector
, result
);
1537 if (VEC_length (memory_read_result_s
, result
) == 0)
1538 error (_("Unable to read memory."));
1540 make_cleanup_ui_out_list_begin_end (uiout
, "memory");
1542 VEC_iterate (memory_read_result_s
, result
, ix
, read_result
);
1545 struct cleanup
*t
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1549 ui_out_field_core_addr (uiout
, "begin", gdbarch
, read_result
->begin
);
1550 ui_out_field_core_addr (uiout
, "offset", gdbarch
, read_result
->begin
1552 ui_out_field_core_addr (uiout
, "end", gdbarch
, read_result
->end
);
1554 data
= xmalloc ((read_result
->end
- read_result
->begin
) * 2 + 1);
1556 for (i
= 0, p
= data
;
1557 i
< (read_result
->end
- read_result
->begin
);
1560 sprintf (p
, "%02x", read_result
->data
[i
]);
1562 ui_out_field_string (uiout
, "contents", data
);
1566 do_cleanups (cleanups
);
1569 /* Implementation of the -data-write_memory command.
1571 COLUMN_OFFSET: optional argument. Must be preceded by '-o'. The
1572 offset from the beginning of the memory grid row where the cell to
1574 ADDR: start address of the row in the memory grid where the memory
1575 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
1576 the location to write to.
1577 FORMAT: a char indicating format for the ``word''. See
1579 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
1580 VALUE: value to be written into the memory address.
1582 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
1587 mi_cmd_data_write_memory (char *command
, char **argv
, int argc
)
1589 struct gdbarch
*gdbarch
= get_current_arch ();
1590 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1594 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
1595 enough when using a compiler other than GCC. */
1598 struct cleanup
*old_chain
;
1606 static const struct mi_opt opts
[] =
1608 {"o", OFFSET_OPT
, 1},
1614 int opt
= mi_getopt ("-data-write-memory", argc
, argv
, opts
,
1619 switch ((enum opt
) opt
)
1622 offset
= atol (oarg
);
1630 error (_("-data-write-memory: Usage: "
1631 "[-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE."));
1633 /* Extract all the arguments. */
1634 /* Start address of the memory dump. */
1635 addr
= parse_and_eval_address (argv
[0]);
1636 /* The format character to use when displaying a memory word. See
1637 the ``x'' command. */
1638 word_format
= argv
[1][0];
1639 /* The size of the memory word. */
1640 word_size
= atol (argv
[2]);
1642 /* Calculate the real address of the write destination. */
1643 addr
+= (offset
* word_size
);
1645 /* Get the value as a number. */
1646 value
= parse_and_eval_address (argv
[3]);
1647 /* Get the value into an array. */
1648 buffer
= xmalloc (word_size
);
1649 old_chain
= make_cleanup (xfree
, buffer
);
1650 store_signed_integer (buffer
, word_size
, byte_order
, value
);
1651 /* Write it down to memory. */
1652 write_memory (addr
, buffer
, word_size
);
1653 /* Free the buffer. */
1654 do_cleanups (old_chain
);
1657 /* Implementation of the -data-write-memory-bytes command.
1660 DATA: string of bytes to write at that address. */
1663 mi_cmd_data_write_memory_bytes (char *command
, char **argv
, int argc
)
1669 struct cleanup
*back_to
;
1672 error (_("Usage: ADDR DATA."));
1674 addr
= parse_and_eval_address (argv
[0]);
1676 len
= strlen (cdata
)/2;
1678 data
= xmalloc (len
);
1679 back_to
= make_cleanup (xfree
, data
);
1681 for (i
= 0; i
< len
; ++i
)
1684 sscanf (cdata
+ i
* 2, "%02x", &x
);
1685 data
[i
] = (gdb_byte
) x
;
1688 r
= target_write_memory (addr
, data
, len
);
1690 error (_("Could not write memory"));
1692 do_cleanups (back_to
);
1696 mi_cmd_enable_timings (char *command
, char **argv
, int argc
)
1702 if (strcmp (argv
[0], "yes") == 0)
1704 else if (strcmp (argv
[0], "no") == 0)
1715 error (_("-enable-timings: Usage: %s {yes|no}"), command
);
1719 mi_cmd_list_features (char *command
, char **argv
, int argc
)
1723 struct cleanup
*cleanup
= NULL
;
1724 struct ui_out
*uiout
= current_uiout
;
1726 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "features");
1727 ui_out_field_string (uiout
, NULL
, "frozen-varobjs");
1728 ui_out_field_string (uiout
, NULL
, "pending-breakpoints");
1729 ui_out_field_string (uiout
, NULL
, "thread-info");
1730 ui_out_field_string (uiout
, NULL
, "data-read-memory-bytes");
1731 ui_out_field_string (uiout
, NULL
, "breakpoint-notifications");
1732 ui_out_field_string (uiout
, NULL
, "ada-task-info");
1735 ui_out_field_string (uiout
, NULL
, "python");
1738 do_cleanups (cleanup
);
1742 error (_("-list-features should be passed no arguments"));
1746 mi_cmd_list_target_features (char *command
, char **argv
, int argc
)
1750 struct cleanup
*cleanup
= NULL
;
1751 struct ui_out
*uiout
= current_uiout
;
1753 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "features");
1754 if (target_can_async_p ())
1755 ui_out_field_string (uiout
, NULL
, "async");
1756 if (target_can_execute_reverse
)
1757 ui_out_field_string (uiout
, NULL
, "reverse");
1759 do_cleanups (cleanup
);
1763 error (_("-list-target-features should be passed no arguments"));
1767 mi_cmd_add_inferior (char *command
, char **argv
, int argc
)
1769 struct inferior
*inf
;
1772 error (_("-add-inferior should be passed no arguments"));
1774 inf
= add_inferior_with_spaces ();
1776 ui_out_field_fmt (current_uiout
, "inferior", "i%d", inf
->num
);
1779 /* Callback used to find the first inferior other than the current
1783 get_other_inferior (struct inferior
*inf
, void *arg
)
1785 if (inf
== current_inferior ())
1792 mi_cmd_remove_inferior (char *command
, char **argv
, int argc
)
1795 struct inferior
*inf
;
1798 error (_("-remove-inferior should be passed a single argument"));
1800 if (sscanf (argv
[0], "i%d", &id
) != 1)
1801 error (_("the thread group id is syntactically invalid"));
1803 inf
= find_inferior_id (id
);
1805 error (_("the specified thread group does not exist"));
1808 error (_("cannot remove an active inferior"));
1810 if (inf
== current_inferior ())
1812 struct thread_info
*tp
= 0;
1813 struct inferior
*new_inferior
1814 = iterate_over_inferiors (get_other_inferior
, NULL
);
1816 if (new_inferior
== NULL
)
1817 error (_("Cannot remove last inferior"));
1819 set_current_inferior (new_inferior
);
1820 if (new_inferior
->pid
!= 0)
1821 tp
= any_thread_of_process (new_inferior
->pid
);
1822 switch_to_thread (tp
? tp
->ptid
: null_ptid
);
1823 set_current_program_space (new_inferior
->pspace
);
1826 delete_inferior_1 (inf
, 1 /* silent */);
1831 /* Execute a command within a safe environment.
1832 Return <0 for error; >=0 for ok.
1834 args->action will tell mi_execute_command what action
1835 to perfrom after the given command has executed (display/suppress
1836 prompt, display error). */
1839 captured_mi_execute_command (struct ui_out
*uiout
, struct mi_parse
*context
)
1841 struct cleanup
*cleanup
;
1844 current_command_ts
= context
->cmd_start
;
1846 current_token
= xstrdup (context
->token
);
1847 cleanup
= make_cleanup (free_current_contents
, ¤t_token
);
1849 running_result_record_printed
= 0;
1851 switch (context
->op
)
1854 /* A MI command was read from the input stream. */
1856 /* FIXME: gdb_???? */
1857 fprintf_unfiltered (raw_stdout
, " token=`%s' command=`%s' args=`%s'\n",
1858 context
->token
, context
->command
, context
->args
);
1860 mi_cmd_execute (context
);
1862 /* Print the result if there were no errors.
1864 Remember that on the way out of executing a command, you have
1865 to directly use the mi_interp's uiout, since the command
1866 could have reset the interpreter, in which case the current
1867 uiout will most likely crash in the mi_out_* routines. */
1868 if (!running_result_record_printed
)
1870 fputs_unfiltered (context
->token
, raw_stdout
);
1871 /* There's no particularly good reason why target-connect results
1872 in not ^done. Should kill ^connected for MI3. */
1873 fputs_unfiltered (strcmp (context
->command
, "target-select") == 0
1874 ? "^connected" : "^done", raw_stdout
);
1875 mi_out_put (uiout
, raw_stdout
);
1876 mi_out_rewind (uiout
);
1877 mi_print_timing_maybe ();
1878 fputs_unfiltered ("\n", raw_stdout
);
1881 /* The command does not want anything to be printed. In that
1882 case, the command probably should not have written anything
1883 to uiout, but in case it has written something, discard it. */
1884 mi_out_rewind (uiout
);
1891 /* A CLI command was read from the input stream. */
1892 /* This "feature" will be removed as soon as we have a
1893 complete set of mi commands. */
1894 /* Echo the command on the console. */
1895 fprintf_unfiltered (gdb_stdlog
, "%s\n", context
->command
);
1896 /* Call the "console" interpreter. */
1897 argv
[0] = "console";
1898 argv
[1] = context
->command
;
1899 mi_cmd_interpreter_exec ("-interpreter-exec", argv
, 2);
1901 /* If we changed interpreters, DON'T print out anything. */
1902 if (current_interp_named_p (INTERP_MI
)
1903 || current_interp_named_p (INTERP_MI1
)
1904 || current_interp_named_p (INTERP_MI2
)
1905 || current_interp_named_p (INTERP_MI3
))
1907 if (!running_result_record_printed
)
1909 fputs_unfiltered (context
->token
, raw_stdout
);
1910 fputs_unfiltered ("^done", raw_stdout
);
1911 mi_out_put (uiout
, raw_stdout
);
1912 mi_out_rewind (uiout
);
1913 mi_print_timing_maybe ();
1914 fputs_unfiltered ("\n", raw_stdout
);
1917 mi_out_rewind (uiout
);
1923 do_cleanups (cleanup
);
1926 /* Print a gdb exception to the MI output stream. */
1929 mi_print_exception (const char *token
, struct gdb_exception exception
)
1931 fputs_unfiltered (token
, raw_stdout
);
1932 fputs_unfiltered ("^error,msg=\"", raw_stdout
);
1933 if (exception
.message
== NULL
)
1934 fputs_unfiltered ("unknown error", raw_stdout
);
1936 fputstr_unfiltered (exception
.message
, '"', raw_stdout
);
1937 fputs_unfiltered ("\"\n", raw_stdout
);
1941 mi_execute_command (char *cmd
, int from_tty
)
1944 struct mi_parse
*command
= NULL
;
1945 volatile struct gdb_exception exception
;
1947 /* This is to handle EOF (^D). We just quit gdb. */
1948 /* FIXME: we should call some API function here. */
1950 quit_force (NULL
, from_tty
);
1952 target_log_command (cmd
);
1954 TRY_CATCH (exception
, RETURN_MASK_ALL
)
1956 command
= mi_parse (cmd
, &token
);
1958 if (exception
.reason
< 0)
1960 mi_print_exception (token
, exception
);
1965 volatile struct gdb_exception result
;
1966 ptid_t previous_ptid
= inferior_ptid
;
1968 command
->token
= token
;
1972 command
->cmd_start
= (struct mi_timestamp
*)
1973 xmalloc (sizeof (struct mi_timestamp
));
1974 timestamp (command
->cmd_start
);
1977 TRY_CATCH (result
, RETURN_MASK_ALL
)
1979 captured_mi_execute_command (current_uiout
, command
);
1981 if (result
.reason
< 0)
1983 /* The command execution failed and error() was called
1985 mi_print_exception (command
->token
, result
);
1986 mi_out_rewind (current_uiout
);
1989 bpstat_do_actions ();
1991 if (/* The notifications are only output when the top-level
1992 interpreter (specified on the command line) is MI. */
1993 ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ()))
1994 /* Don't try report anything if there are no threads --
1995 the program is dead. */
1996 && thread_count () != 0
1997 /* -thread-select explicitly changes thread. If frontend uses that
1998 internally, we don't want to emit =thread-selected, since
1999 =thread-selected is supposed to indicate user's intentions. */
2000 && strcmp (command
->command
, "thread-select") != 0)
2002 struct mi_interp
*mi
= top_level_interpreter_data ();
2003 int report_change
= 0;
2005 if (command
->thread
== -1)
2007 report_change
= (!ptid_equal (previous_ptid
, null_ptid
)
2008 && !ptid_equal (inferior_ptid
, previous_ptid
)
2009 && !ptid_equal (inferior_ptid
, null_ptid
));
2011 else if (!ptid_equal (inferior_ptid
, null_ptid
))
2013 struct thread_info
*ti
= inferior_thread ();
2015 report_change
= (ti
->num
!= command
->thread
);
2020 struct thread_info
*ti
= inferior_thread ();
2022 target_terminal_ours ();
2023 fprintf_unfiltered (mi
->event_channel
,
2024 "thread-selected,id=\"%d\"",
2026 gdb_flush (mi
->event_channel
);
2030 mi_parse_free (command
);
2035 mi_cmd_execute (struct mi_parse
*parse
)
2037 struct cleanup
*cleanup
;
2039 cleanup
= prepare_execute_command ();
2041 if (parse
->all
&& parse
->thread_group
!= -1)
2042 error (_("Cannot specify --thread-group together with --all"));
2044 if (parse
->all
&& parse
->thread
!= -1)
2045 error (_("Cannot specify --thread together with --all"));
2047 if (parse
->thread_group
!= -1 && parse
->thread
!= -1)
2048 error (_("Cannot specify --thread together with --thread-group"));
2050 if (parse
->frame
!= -1 && parse
->thread
== -1)
2051 error (_("Cannot specify --frame without --thread"));
2053 if (parse
->thread_group
!= -1)
2055 struct inferior
*inf
= find_inferior_id (parse
->thread_group
);
2056 struct thread_info
*tp
= 0;
2059 error (_("Invalid thread group for the --thread-group option"));
2061 set_current_inferior (inf
);
2062 /* This behaviour means that if --thread-group option identifies
2063 an inferior with multiple threads, then a random one will be
2064 picked. This is not a problem -- frontend should always
2065 provide --thread if it wishes to operate on a specific
2068 tp
= any_thread_of_process (inf
->pid
);
2069 switch_to_thread (tp
? tp
->ptid
: null_ptid
);
2070 set_current_program_space (inf
->pspace
);
2073 if (parse
->thread
!= -1)
2075 struct thread_info
*tp
= find_thread_id (parse
->thread
);
2078 error (_("Invalid thread id: %d"), parse
->thread
);
2080 if (is_exited (tp
->ptid
))
2081 error (_("Thread id: %d has terminated"), parse
->thread
);
2083 switch_to_thread (tp
->ptid
);
2086 if (parse
->frame
!= -1)
2088 struct frame_info
*fid
;
2089 int frame
= parse
->frame
;
2091 fid
= find_relative_frame (get_current_frame (), &frame
);
2093 /* find_relative_frame was successful */
2096 error (_("Invalid frame id: %d"), frame
);
2099 current_context
= parse
;
2101 if (strncmp (parse
->command
, "break-", sizeof ("break-") - 1 ) == 0)
2103 make_cleanup_restore_integer (&mi_suppress_breakpoint_notifications
);
2104 mi_suppress_breakpoint_notifications
= 1;
2107 if (parse
->cmd
->argv_func
!= NULL
)
2109 parse
->cmd
->argv_func (parse
->command
, parse
->argv
, parse
->argc
);
2111 else if (parse
->cmd
->cli
.cmd
!= 0)
2113 /* FIXME: DELETE THIS. */
2114 /* The operation is still implemented by a cli command. */
2115 /* Must be a synchronous one. */
2116 mi_execute_cli_command (parse
->cmd
->cli
.cmd
, parse
->cmd
->cli
.args_p
,
2121 /* FIXME: DELETE THIS. */
2122 struct ui_file
*stb
;
2124 stb
= mem_fileopen ();
2126 fputs_unfiltered ("Undefined mi command: ", stb
);
2127 fputstr_unfiltered (parse
->command
, '"', stb
);
2128 fputs_unfiltered (" (missing implementation)", stb
);
2130 make_cleanup_ui_file_delete (stb
);
2133 do_cleanups (cleanup
);
2136 /* FIXME: This is just a hack so we can get some extra commands going.
2137 We don't want to channel things through the CLI, but call libgdb directly.
2138 Use only for synchronous commands. */
2141 mi_execute_cli_command (const char *cmd
, int args_p
, const char *args
)
2145 struct cleanup
*old_cleanups
;
2149 run
= xstrprintf ("%s %s", cmd
, args
);
2151 run
= xstrdup (cmd
);
2153 /* FIXME: gdb_???? */
2154 fprintf_unfiltered (gdb_stdout
, "cli=%s run=%s\n",
2156 old_cleanups
= make_cleanup (xfree
, run
);
2157 execute_command (run
, 0 /* from_tty */ );
2158 do_cleanups (old_cleanups
);
2164 mi_execute_async_cli_command (char *cli_command
, char **argv
, int argc
)
2166 struct cleanup
*old_cleanups
;
2169 if (target_can_async_p ())
2170 run
= xstrprintf ("%s %s&", cli_command
, argc
? *argv
: "");
2172 run
= xstrprintf ("%s %s", cli_command
, argc
? *argv
: "");
2173 old_cleanups
= make_cleanup (xfree
, run
);
2175 execute_command (run
, 0 /* from_tty */ );
2177 /* Do this before doing any printing. It would appear that some
2178 print code leaves garbage around in the buffer. */
2179 do_cleanups (old_cleanups
);
2183 mi_load_progress (const char *section_name
,
2184 unsigned long sent_so_far
,
2185 unsigned long total_section
,
2186 unsigned long total_sent
,
2187 unsigned long grand_total
)
2189 struct timeval time_now
, delta
, update_threshold
;
2190 static struct timeval last_update
;
2191 static char *previous_sect_name
= NULL
;
2193 struct ui_out
*saved_uiout
;
2194 struct ui_out
*uiout
;
2196 /* This function is called through deprecated_show_load_progress
2197 which means uiout may not be correct. Fix it for the duration
2198 of this function. */
2199 saved_uiout
= current_uiout
;
2201 if (current_interp_named_p (INTERP_MI
)
2202 || current_interp_named_p (INTERP_MI2
))
2203 current_uiout
= mi_out_new (2);
2204 else if (current_interp_named_p (INTERP_MI1
))
2205 current_uiout
= mi_out_new (1);
2206 else if (current_interp_named_p (INTERP_MI3
))
2207 current_uiout
= mi_out_new (3);
2211 uiout
= current_uiout
;
2213 update_threshold
.tv_sec
= 0;
2214 update_threshold
.tv_usec
= 500000;
2215 gettimeofday (&time_now
, NULL
);
2217 delta
.tv_usec
= time_now
.tv_usec
- last_update
.tv_usec
;
2218 delta
.tv_sec
= time_now
.tv_sec
- last_update
.tv_sec
;
2220 if (delta
.tv_usec
< 0)
2223 delta
.tv_usec
+= 1000000L;
2226 new_section
= (previous_sect_name
?
2227 strcmp (previous_sect_name
, section_name
) : 1);
2230 struct cleanup
*cleanup_tuple
;
2232 xfree (previous_sect_name
);
2233 previous_sect_name
= xstrdup (section_name
);
2236 fputs_unfiltered (current_token
, raw_stdout
);
2237 fputs_unfiltered ("+download", raw_stdout
);
2238 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2239 ui_out_field_string (uiout
, "section", section_name
);
2240 ui_out_field_int (uiout
, "section-size", total_section
);
2241 ui_out_field_int (uiout
, "total-size", grand_total
);
2242 do_cleanups (cleanup_tuple
);
2243 mi_out_put (uiout
, raw_stdout
);
2244 fputs_unfiltered ("\n", raw_stdout
);
2245 gdb_flush (raw_stdout
);
2248 if (delta
.tv_sec
>= update_threshold
.tv_sec
&&
2249 delta
.tv_usec
>= update_threshold
.tv_usec
)
2251 struct cleanup
*cleanup_tuple
;
2253 last_update
.tv_sec
= time_now
.tv_sec
;
2254 last_update
.tv_usec
= time_now
.tv_usec
;
2256 fputs_unfiltered (current_token
, raw_stdout
);
2257 fputs_unfiltered ("+download", raw_stdout
);
2258 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2259 ui_out_field_string (uiout
, "section", section_name
);
2260 ui_out_field_int (uiout
, "section-sent", sent_so_far
);
2261 ui_out_field_int (uiout
, "section-size", total_section
);
2262 ui_out_field_int (uiout
, "total-sent", total_sent
);
2263 ui_out_field_int (uiout
, "total-size", grand_total
);
2264 do_cleanups (cleanup_tuple
);
2265 mi_out_put (uiout
, raw_stdout
);
2266 fputs_unfiltered ("\n", raw_stdout
);
2267 gdb_flush (raw_stdout
);
2271 current_uiout
= saved_uiout
;
2275 timestamp (struct mi_timestamp
*tv
)
2277 gettimeofday (&tv
->wallclock
, NULL
);
2278 #ifdef HAVE_GETRUSAGE
2279 getrusage (RUSAGE_SELF
, &rusage
);
2280 tv
->utime
.tv_sec
= rusage
.ru_utime
.tv_sec
;
2281 tv
->utime
.tv_usec
= rusage
.ru_utime
.tv_usec
;
2282 tv
->stime
.tv_sec
= rusage
.ru_stime
.tv_sec
;
2283 tv
->stime
.tv_usec
= rusage
.ru_stime
.tv_usec
;
2286 long usec
= get_run_time ();
2288 tv
->utime
.tv_sec
= usec
/1000000L;
2289 tv
->utime
.tv_usec
= usec
- 1000000L*tv
->utime
.tv_sec
;
2290 tv
->stime
.tv_sec
= 0;
2291 tv
->stime
.tv_usec
= 0;
2297 print_diff_now (struct mi_timestamp
*start
)
2299 struct mi_timestamp now
;
2302 print_diff (start
, &now
);
2306 mi_print_timing_maybe (void)
2308 /* If the command is -enable-timing then do_timings may be true
2309 whilst current_command_ts is not initialized. */
2310 if (do_timings
&& current_command_ts
)
2311 print_diff_now (current_command_ts
);
2315 timeval_diff (struct timeval start
, struct timeval end
)
2317 return ((end
.tv_sec
- start
.tv_sec
) * 1000000L)
2318 + (end
.tv_usec
- start
.tv_usec
);
2322 print_diff (struct mi_timestamp
*start
, struct mi_timestamp
*end
)
2326 ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
2327 timeval_diff (start
->wallclock
, end
->wallclock
) / 1000000.0,
2328 timeval_diff (start
->utime
, end
->utime
) / 1000000.0,
2329 timeval_diff (start
->stime
, end
->stime
) / 1000000.0);
2333 mi_cmd_trace_define_variable (char *command
, char **argv
, int argc
)
2335 struct expression
*expr
;
2336 struct cleanup
*back_to
;
2337 LONGEST initval
= 0;
2338 struct trace_state_variable
*tsv
;
2341 if (argc
!= 1 && argc
!= 2)
2342 error (_("Usage: -trace-define-variable VARIABLE [VALUE]"));
2344 expr
= parse_expression (argv
[0]);
2345 back_to
= make_cleanup (xfree
, expr
);
2347 if (expr
->nelts
== 3 && expr
->elts
[0].opcode
== OP_INTERNALVAR
)
2349 struct internalvar
*intvar
= expr
->elts
[1].internalvar
;
2352 name
= internalvar_name (intvar
);
2355 if (!name
|| *name
== '\0')
2356 error (_("Invalid name of trace variable"));
2358 tsv
= find_trace_state_variable (name
);
2360 tsv
= create_trace_state_variable (name
);
2363 initval
= value_as_long (parse_and_eval (argv
[1]));
2365 tsv
->initial_value
= initval
;
2367 do_cleanups (back_to
);
2371 mi_cmd_trace_list_variables (char *command
, char **argv
, int argc
)
2374 error (_("-trace-list-variables: no arguments allowed"));
2376 tvariables_info_1 ();
2380 mi_cmd_trace_find (char *command
, char **argv
, int argc
)
2385 error (_("trace selection mode is required"));
2389 if (strcmp (mode
, "none") == 0)
2391 tfind_1 (tfind_number
, -1, 0, 0, 0);
2395 if (current_trace_status ()->running
)
2396 error (_("May not look at trace frames while trace is running."));
2398 if (strcmp (mode
, "frame-number") == 0)
2401 error (_("frame number is required"));
2402 tfind_1 (tfind_number
, atoi (argv
[1]), 0, 0, 0);
2404 else if (strcmp (mode
, "tracepoint-number") == 0)
2407 error (_("tracepoint number is required"));
2408 tfind_1 (tfind_tp
, atoi (argv
[1]), 0, 0, 0);
2410 else if (strcmp (mode
, "pc") == 0)
2413 error (_("PC is required"));
2414 tfind_1 (tfind_pc
, 0, parse_and_eval_address (argv
[1]), 0, 0);
2416 else if (strcmp (mode
, "pc-inside-range") == 0)
2419 error (_("Start and end PC are required"));
2420 tfind_1 (tfind_range
, 0, parse_and_eval_address (argv
[1]),
2421 parse_and_eval_address (argv
[2]), 0);
2423 else if (strcmp (mode
, "pc-outside-range") == 0)
2426 error (_("Start and end PC are required"));
2427 tfind_1 (tfind_outside
, 0, parse_and_eval_address (argv
[1]),
2428 parse_and_eval_address (argv
[2]), 0);
2430 else if (strcmp (mode
, "line") == 0)
2432 struct symtabs_and_lines sals
;
2433 struct symtab_and_line sal
;
2434 static CORE_ADDR start_pc
, end_pc
;
2435 struct cleanup
*back_to
;
2438 error (_("Line is required"));
2440 sals
= decode_line_spec (argv
[1], DECODE_LINE_FUNFIRSTLINE
);
2441 back_to
= make_cleanup (xfree
, sals
.sals
);
2445 if (sal
.symtab
== 0)
2446 error (_("Could not find the specified line"));
2448 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2449 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, 0);
2451 error (_("Could not find the specified line"));
2453 do_cleanups (back_to
);
2456 error (_("Invalid mode '%s'"), mode
);
2458 if (has_stack_frames () || get_traceframe_number () >= 0)
2459 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
2463 mi_cmd_trace_save (char *command
, char **argv
, int argc
)
2465 int target_saves
= 0;
2468 if (argc
!= 1 && argc
!= 2)
2469 error (_("Usage: -trace-save [-r] filename"));
2474 if (strcmp (argv
[0], "-r") == 0)
2477 error (_("Invalid option: %s"), argv
[0]);
2484 trace_save (filename
, target_saves
);
2488 mi_cmd_trace_start (char *command
, char **argv
, int argc
)
2490 start_tracing (NULL
);
2494 mi_cmd_trace_status (char *command
, char **argv
, int argc
)
2496 trace_status_mi (0);
2500 mi_cmd_trace_stop (char *command
, char **argv
, int argc
)
2502 stop_tracing (NULL
);
2503 trace_status_mi (1);
2506 /* Implement the "-ada-task-info" command. */
2509 mi_cmd_ada_task_info (char *command
, char **argv
, int argc
)
2511 if (argc
!= 0 && argc
!= 1)
2512 error (_("Invalid MI command"));
2514 print_ada_task_info (current_uiout
, argv
[0], current_inferior ());