3 Copyright (C) 2000-2013 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, GDB_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
;
1139 val
= get_frame_register_value (frame
, regnum
);
1141 if (value_optimized_out (val
))
1142 error (_("Optimized out"));
1147 char *ptr
, buf
[1024];
1148 const gdb_byte
*valaddr
= value_contents_for_printing (val
);
1152 for (j
= 0; j
< register_size (gdbarch
, regnum
); j
++)
1154 int idx
= gdbarch_byte_order (gdbarch
) == BFD_ENDIAN_BIG
?
1155 j
: register_size (gdbarch
, regnum
) - 1 - j
;
1157 sprintf (ptr
, "%02x", (unsigned char) valaddr
[idx
]);
1160 ui_out_field_string (uiout
, "value", buf
);
1164 struct value_print_options opts
;
1165 struct ui_file
*stb
;
1166 struct cleanup
*old_chain
;
1168 stb
= mem_fileopen ();
1169 old_chain
= make_cleanup_ui_file_delete (stb
);
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
, 0, val
, &opts
, current_language
);
1177 ui_out_field_stream (uiout
, "value", stb
);
1178 do_cleanups (old_chain
);
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
;
1193 /* Note that the test for a valid register must include checking the
1194 gdbarch_register_name because gdbarch_num_regs may be allocated
1195 for the union of the register sets within a family of related
1196 processors. In this case, some entries of gdbarch_register_name
1197 will change depending upon the particular processor being
1200 regcache
= get_current_regcache ();
1201 gdbarch
= get_regcache_arch (regcache
);
1202 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1205 error (_("-data-write-register-values: Usage: -data-write-register-"
1206 "values <format> [<regnum1> <value1>...<regnumN> <valueN>]"));
1208 if (!target_has_registers
)
1209 error (_("-data-write-register-values: No registers."));
1212 error (_("-data-write-register-values: No regs and values specified."));
1215 error (_("-data-write-register-values: "
1216 "Regs and vals are not in pairs."));
1218 for (i
= 1; i
< argc
; i
= i
+ 2)
1220 int regnum
= atoi (argv
[i
]);
1222 if (regnum
>= 0 && regnum
< numregs
1223 && gdbarch_register_name (gdbarch
, regnum
)
1224 && *gdbarch_register_name (gdbarch
, regnum
))
1228 /* Get the value as a number. */
1229 value
= parse_and_eval_address (argv
[i
+ 1]);
1231 /* Write it down. */
1232 regcache_cooked_write_signed (regcache
, regnum
, value
);
1235 error (_("bad register number"));
1239 /* Evaluate the value of the argument. The argument is an
1240 expression. If the expression contains spaces it needs to be
1241 included in double quotes. */
1244 mi_cmd_data_evaluate_expression (char *command
, char **argv
, int argc
)
1246 struct expression
*expr
;
1247 struct cleanup
*old_chain
;
1249 struct ui_file
*stb
;
1250 struct value_print_options opts
;
1251 struct ui_out
*uiout
= current_uiout
;
1253 stb
= mem_fileopen ();
1254 old_chain
= make_cleanup_ui_file_delete (stb
);
1257 error (_("-data-evaluate-expression: "
1258 "Usage: -data-evaluate-expression expression"));
1260 expr
= parse_expression (argv
[0]);
1262 make_cleanup (free_current_contents
, &expr
);
1264 val
= evaluate_expression (expr
);
1266 /* Print the result of the expression evaluation. */
1267 get_user_print_options (&opts
);
1269 common_val_print (val
, stb
, 0, &opts
, current_language
);
1271 ui_out_field_stream (uiout
, "value", stb
);
1273 do_cleanups (old_chain
);
1276 /* This is the -data-read-memory command.
1278 ADDR: start address of data to be dumped.
1279 WORD-FORMAT: a char indicating format for the ``word''. See
1281 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes.
1282 NR_ROW: Number of rows.
1283 NR_COL: The number of colums (words per row).
1284 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
1285 ASCHAR for unprintable characters.
1287 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
1288 displayes them. Returns:
1290 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
1293 The number of bytes read is SIZE*ROW*COL. */
1296 mi_cmd_data_read_memory (char *command
, char **argv
, int argc
)
1298 struct gdbarch
*gdbarch
= get_current_arch ();
1299 struct ui_out
*uiout
= current_uiout
;
1300 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
1302 long total_bytes
, nr_cols
, nr_rows
;
1304 struct type
*word_type
;
1317 static const struct mi_opt opts
[] =
1319 {"o", OFFSET_OPT
, 1},
1325 int opt
= mi_getopt ("-data-read-memory", argc
, argv
, opts
,
1330 switch ((enum opt
) opt
)
1333 offset
= atol (oarg
);
1340 if (argc
< 5 || argc
> 6)
1341 error (_("-data-read-memory: Usage: "
1342 "ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR]."));
1344 /* Extract all the arguments. */
1346 /* Start address of the memory dump. */
1347 addr
= parse_and_eval_address (argv
[0]) + offset
;
1348 /* The format character to use when displaying a memory word. See
1349 the ``x'' command. */
1350 word_format
= argv
[1][0];
1351 /* The size of the memory word. */
1352 word_size
= atol (argv
[2]);
1356 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1360 word_type
= builtin_type (gdbarch
)->builtin_int16
;
1364 word_type
= builtin_type (gdbarch
)->builtin_int32
;
1368 word_type
= builtin_type (gdbarch
)->builtin_int64
;
1372 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1375 /* The number of rows. */
1376 nr_rows
= atol (argv
[3]);
1378 error (_("-data-read-memory: invalid number of rows."));
1380 /* Number of bytes per row. */
1381 nr_cols
= atol (argv
[4]);
1383 error (_("-data-read-memory: invalid number of columns."));
1385 /* The un-printable character when printing ascii. */
1391 /* Create a buffer and read it in. */
1392 total_bytes
= word_size
* nr_rows
* nr_cols
;
1393 mbuf
= xcalloc (total_bytes
, 1);
1394 make_cleanup (xfree
, mbuf
);
1396 /* Dispatch memory reads to the topmost target, not the flattened
1398 nr_bytes
= target_read (current_target
.beneath
,
1399 TARGET_OBJECT_MEMORY
, NULL
, mbuf
,
1402 error (_("Unable to read memory."));
1404 /* Output the header information. */
1405 ui_out_field_core_addr (uiout
, "addr", gdbarch
, addr
);
1406 ui_out_field_int (uiout
, "nr-bytes", nr_bytes
);
1407 ui_out_field_int (uiout
, "total-bytes", total_bytes
);
1408 ui_out_field_core_addr (uiout
, "next-row",
1409 gdbarch
, addr
+ word_size
* nr_cols
);
1410 ui_out_field_core_addr (uiout
, "prev-row",
1411 gdbarch
, addr
- word_size
* nr_cols
);
1412 ui_out_field_core_addr (uiout
, "next-page", gdbarch
, addr
+ total_bytes
);
1413 ui_out_field_core_addr (uiout
, "prev-page", gdbarch
, addr
- total_bytes
);
1415 /* Build the result as a two dimentional table. */
1417 struct ui_file
*stream
;
1418 struct cleanup
*cleanup_stream
;
1422 stream
= mem_fileopen ();
1423 cleanup_stream
= make_cleanup_ui_file_delete (stream
);
1425 make_cleanup_ui_out_list_begin_end (uiout
, "memory");
1426 for (row
= 0, row_byte
= 0;
1428 row
++, row_byte
+= nr_cols
* word_size
)
1432 struct cleanup
*cleanup_tuple
;
1433 struct cleanup
*cleanup_list_data
;
1434 struct value_print_options opts
;
1436 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1437 ui_out_field_core_addr (uiout
, "addr", gdbarch
, addr
+ row_byte
);
1438 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr +
1440 cleanup_list_data
= make_cleanup_ui_out_list_begin_end (uiout
, "data");
1441 get_formatted_print_options (&opts
, word_format
);
1442 for (col
= 0, col_byte
= row_byte
;
1444 col
++, col_byte
+= word_size
)
1446 if (col_byte
+ word_size
> nr_bytes
)
1448 ui_out_field_string (uiout
, NULL
, "N/A");
1452 ui_file_rewind (stream
);
1453 print_scalar_formatted (mbuf
+ col_byte
, word_type
, &opts
,
1454 word_asize
, stream
);
1455 ui_out_field_stream (uiout
, NULL
, stream
);
1458 do_cleanups (cleanup_list_data
);
1463 ui_file_rewind (stream
);
1464 for (byte
= row_byte
;
1465 byte
< row_byte
+ word_size
* nr_cols
; byte
++)
1467 if (byte
>= nr_bytes
)
1468 fputc_unfiltered ('X', stream
);
1469 else if (mbuf
[byte
] < 32 || mbuf
[byte
] > 126)
1470 fputc_unfiltered (aschar
, stream
);
1472 fputc_unfiltered (mbuf
[byte
], stream
);
1474 ui_out_field_stream (uiout
, "ascii", stream
);
1476 do_cleanups (cleanup_tuple
);
1478 do_cleanups (cleanup_stream
);
1480 do_cleanups (cleanups
);
1484 mi_cmd_data_read_memory_bytes (char *command
, char **argv
, int argc
)
1486 struct gdbarch
*gdbarch
= get_current_arch ();
1487 struct ui_out
*uiout
= current_uiout
;
1488 struct cleanup
*cleanups
;
1491 memory_read_result_s
*read_result
;
1493 VEC(memory_read_result_s
) *result
;
1501 static const struct mi_opt opts
[] =
1503 {"o", OFFSET_OPT
, 1},
1509 int opt
= mi_getopt ("-data-read-memory-bytes", argc
, argv
, opts
,
1513 switch ((enum opt
) opt
)
1516 offset
= atol (oarg
);
1524 error (_("Usage: [ -o OFFSET ] ADDR LENGTH."));
1526 addr
= parse_and_eval_address (argv
[0]) + offset
;
1527 length
= atol (argv
[1]);
1529 result
= read_memory_robust (current_target
.beneath
, addr
, length
);
1531 cleanups
= make_cleanup (free_memory_read_result_vector
, result
);
1533 if (VEC_length (memory_read_result_s
, result
) == 0)
1534 error (_("Unable to read memory."));
1536 make_cleanup_ui_out_list_begin_end (uiout
, "memory");
1538 VEC_iterate (memory_read_result_s
, result
, ix
, read_result
);
1541 struct cleanup
*t
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1545 ui_out_field_core_addr (uiout
, "begin", gdbarch
, read_result
->begin
);
1546 ui_out_field_core_addr (uiout
, "offset", gdbarch
, read_result
->begin
1548 ui_out_field_core_addr (uiout
, "end", gdbarch
, read_result
->end
);
1550 data
= xmalloc ((read_result
->end
- read_result
->begin
) * 2 + 1);
1552 for (i
= 0, p
= data
;
1553 i
< (read_result
->end
- read_result
->begin
);
1556 sprintf (p
, "%02x", read_result
->data
[i
]);
1558 ui_out_field_string (uiout
, "contents", data
);
1562 do_cleanups (cleanups
);
1565 /* Implementation of the -data-write_memory command.
1567 COLUMN_OFFSET: optional argument. Must be preceded by '-o'. The
1568 offset from the beginning of the memory grid row where the cell to
1570 ADDR: start address of the row in the memory grid where the memory
1571 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
1572 the location to write to.
1573 FORMAT: a char indicating format for the ``word''. See
1575 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
1576 VALUE: value to be written into the memory address.
1578 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
1583 mi_cmd_data_write_memory (char *command
, char **argv
, int argc
)
1585 struct gdbarch
*gdbarch
= get_current_arch ();
1586 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1589 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
1590 enough when using a compiler other than GCC. */
1593 struct cleanup
*old_chain
;
1601 static const struct mi_opt opts
[] =
1603 {"o", OFFSET_OPT
, 1},
1609 int opt
= mi_getopt ("-data-write-memory", argc
, argv
, opts
,
1614 switch ((enum opt
) opt
)
1617 offset
= atol (oarg
);
1625 error (_("-data-write-memory: Usage: "
1626 "[-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE."));
1628 /* Extract all the arguments. */
1629 /* Start address of the memory dump. */
1630 addr
= parse_and_eval_address (argv
[0]);
1631 /* The size of the memory word. */
1632 word_size
= atol (argv
[2]);
1634 /* Calculate the real address of the write destination. */
1635 addr
+= (offset
* word_size
);
1637 /* Get the value as a number. */
1638 value
= parse_and_eval_address (argv
[3]);
1639 /* Get the value into an array. */
1640 buffer
= xmalloc (word_size
);
1641 old_chain
= make_cleanup (xfree
, buffer
);
1642 store_signed_integer (buffer
, word_size
, byte_order
, value
);
1643 /* Write it down to memory. */
1644 write_memory_with_notification (addr
, buffer
, word_size
);
1645 /* Free the buffer. */
1646 do_cleanups (old_chain
);
1649 /* Implementation of the -data-write-memory-bytes command.
1652 DATA: string of bytes to write at that address
1653 COUNT: number of bytes to be filled (decimal integer). */
1656 mi_cmd_data_write_memory_bytes (char *command
, char **argv
, int argc
)
1662 size_t len
, i
, steps
, remainder
;
1664 struct cleanup
*back_to
;
1666 if (argc
!= 2 && argc
!= 3)
1667 error (_("Usage: ADDR DATA [COUNT]."));
1669 addr
= parse_and_eval_address (argv
[0]);
1671 if (strlen (cdata
) % 2)
1672 error (_("Hex-encoded '%s' must have an even number of characters."),
1675 len
= strlen (cdata
)/2;
1677 count
= strtoul (argv
[2], NULL
, 10);
1681 databuf
= xmalloc (len
* sizeof (gdb_byte
));
1682 back_to
= make_cleanup (xfree
, databuf
);
1684 for (i
= 0; i
< len
; ++i
)
1687 if (sscanf (cdata
+ i
* 2, "%02x", &x
) != 1)
1688 error (_("Invalid argument"));
1689 databuf
[i
] = (gdb_byte
) x
;
1694 /* Pattern is made of less bytes than count:
1695 repeat pattern to fill memory. */
1696 data
= xmalloc (count
);
1697 make_cleanup (xfree
, data
);
1699 steps
= count
/ len
;
1700 remainder
= count
% len
;
1701 for (j
= 0; j
< steps
; j
++)
1702 memcpy (data
+ j
* len
, databuf
, len
);
1705 memcpy (data
+ steps
* len
, databuf
, remainder
);
1709 /* Pattern is longer than or equal to count:
1710 just copy len bytes. */
1714 write_memory_with_notification (addr
, data
, count
);
1716 do_cleanups (back_to
);
1720 mi_cmd_enable_timings (char *command
, char **argv
, int argc
)
1726 if (strcmp (argv
[0], "yes") == 0)
1728 else if (strcmp (argv
[0], "no") == 0)
1739 error (_("-enable-timings: Usage: %s {yes|no}"), command
);
1743 mi_cmd_list_features (char *command
, char **argv
, int argc
)
1747 struct cleanup
*cleanup
= NULL
;
1748 struct ui_out
*uiout
= current_uiout
;
1750 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "features");
1751 ui_out_field_string (uiout
, NULL
, "frozen-varobjs");
1752 ui_out_field_string (uiout
, NULL
, "pending-breakpoints");
1753 ui_out_field_string (uiout
, NULL
, "thread-info");
1754 ui_out_field_string (uiout
, NULL
, "data-read-memory-bytes");
1755 ui_out_field_string (uiout
, NULL
, "breakpoint-notifications");
1756 ui_out_field_string (uiout
, NULL
, "ada-task-info");
1759 ui_out_field_string (uiout
, NULL
, "python");
1762 do_cleanups (cleanup
);
1766 error (_("-list-features should be passed no arguments"));
1770 mi_cmd_list_target_features (char *command
, char **argv
, int argc
)
1774 struct cleanup
*cleanup
= NULL
;
1775 struct ui_out
*uiout
= current_uiout
;
1777 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "features");
1778 if (target_can_async_p ())
1779 ui_out_field_string (uiout
, NULL
, "async");
1780 if (target_can_execute_reverse
)
1781 ui_out_field_string (uiout
, NULL
, "reverse");
1783 do_cleanups (cleanup
);
1787 error (_("-list-target-features should be passed no arguments"));
1791 mi_cmd_add_inferior (char *command
, char **argv
, int argc
)
1793 struct inferior
*inf
;
1796 error (_("-add-inferior should be passed no arguments"));
1798 inf
= add_inferior_with_spaces ();
1800 ui_out_field_fmt (current_uiout
, "inferior", "i%d", inf
->num
);
1803 /* Callback used to find the first inferior other than the current
1807 get_other_inferior (struct inferior
*inf
, void *arg
)
1809 if (inf
== current_inferior ())
1816 mi_cmd_remove_inferior (char *command
, char **argv
, int argc
)
1819 struct inferior
*inf
;
1822 error (_("-remove-inferior should be passed a single argument"));
1824 if (sscanf (argv
[0], "i%d", &id
) != 1)
1825 error (_("the thread group id is syntactically invalid"));
1827 inf
= find_inferior_id (id
);
1829 error (_("the specified thread group does not exist"));
1832 error (_("cannot remove an active inferior"));
1834 if (inf
== current_inferior ())
1836 struct thread_info
*tp
= 0;
1837 struct inferior
*new_inferior
1838 = iterate_over_inferiors (get_other_inferior
, NULL
);
1840 if (new_inferior
== NULL
)
1841 error (_("Cannot remove last inferior"));
1843 set_current_inferior (new_inferior
);
1844 if (new_inferior
->pid
!= 0)
1845 tp
= any_thread_of_process (new_inferior
->pid
);
1846 switch_to_thread (tp
? tp
->ptid
: null_ptid
);
1847 set_current_program_space (new_inferior
->pspace
);
1850 delete_inferior_1 (inf
, 1 /* silent */);
1855 /* Execute a command within a safe environment.
1856 Return <0 for error; >=0 for ok.
1858 args->action will tell mi_execute_command what action
1859 to perfrom after the given command has executed (display/suppress
1860 prompt, display error). */
1863 captured_mi_execute_command (struct ui_out
*uiout
, struct mi_parse
*context
)
1865 struct cleanup
*cleanup
;
1868 current_command_ts
= context
->cmd_start
;
1870 current_token
= xstrdup (context
->token
);
1871 cleanup
= make_cleanup (free_current_contents
, ¤t_token
);
1873 running_result_record_printed
= 0;
1875 switch (context
->op
)
1878 /* A MI command was read from the input stream. */
1880 /* FIXME: gdb_???? */
1881 fprintf_unfiltered (raw_stdout
, " token=`%s' command=`%s' args=`%s'\n",
1882 context
->token
, context
->command
, context
->args
);
1884 mi_cmd_execute (context
);
1886 /* Print the result if there were no errors.
1888 Remember that on the way out of executing a command, you have
1889 to directly use the mi_interp's uiout, since the command
1890 could have reset the interpreter, in which case the current
1891 uiout will most likely crash in the mi_out_* routines. */
1892 if (!running_result_record_printed
)
1894 fputs_unfiltered (context
->token
, raw_stdout
);
1895 /* There's no particularly good reason why target-connect results
1896 in not ^done. Should kill ^connected for MI3. */
1897 fputs_unfiltered (strcmp (context
->command
, "target-select") == 0
1898 ? "^connected" : "^done", raw_stdout
);
1899 mi_out_put (uiout
, raw_stdout
);
1900 mi_out_rewind (uiout
);
1901 mi_print_timing_maybe ();
1902 fputs_unfiltered ("\n", raw_stdout
);
1905 /* The command does not want anything to be printed. In that
1906 case, the command probably should not have written anything
1907 to uiout, but in case it has written something, discard it. */
1908 mi_out_rewind (uiout
);
1915 /* A CLI command was read from the input stream. */
1916 /* This "feature" will be removed as soon as we have a
1917 complete set of mi commands. */
1918 /* Echo the command on the console. */
1919 fprintf_unfiltered (gdb_stdlog
, "%s\n", context
->command
);
1920 /* Call the "console" interpreter. */
1921 argv
[0] = "console";
1922 argv
[1] = context
->command
;
1923 mi_cmd_interpreter_exec ("-interpreter-exec", argv
, 2);
1925 /* If we changed interpreters, DON'T print out anything. */
1926 if (current_interp_named_p (INTERP_MI
)
1927 || current_interp_named_p (INTERP_MI1
)
1928 || current_interp_named_p (INTERP_MI2
)
1929 || current_interp_named_p (INTERP_MI3
))
1931 if (!running_result_record_printed
)
1933 fputs_unfiltered (context
->token
, raw_stdout
);
1934 fputs_unfiltered ("^done", raw_stdout
);
1935 mi_out_put (uiout
, raw_stdout
);
1936 mi_out_rewind (uiout
);
1937 mi_print_timing_maybe ();
1938 fputs_unfiltered ("\n", raw_stdout
);
1941 mi_out_rewind (uiout
);
1947 do_cleanups (cleanup
);
1950 /* Print a gdb exception to the MI output stream. */
1953 mi_print_exception (const char *token
, struct gdb_exception exception
)
1955 fputs_unfiltered (token
, raw_stdout
);
1956 fputs_unfiltered ("^error,msg=\"", raw_stdout
);
1957 if (exception
.message
== NULL
)
1958 fputs_unfiltered ("unknown error", raw_stdout
);
1960 fputstr_unfiltered (exception
.message
, '"', raw_stdout
);
1961 fputs_unfiltered ("\"\n", raw_stdout
);
1965 mi_execute_command (char *cmd
, int from_tty
)
1968 struct mi_parse
*command
= NULL
;
1969 volatile struct gdb_exception exception
;
1971 /* This is to handle EOF (^D). We just quit gdb. */
1972 /* FIXME: we should call some API function here. */
1974 quit_force (NULL
, from_tty
);
1976 target_log_command (cmd
);
1978 TRY_CATCH (exception
, RETURN_MASK_ALL
)
1980 command
= mi_parse (cmd
, &token
);
1982 if (exception
.reason
< 0)
1984 mi_print_exception (token
, exception
);
1989 volatile struct gdb_exception result
;
1990 ptid_t previous_ptid
= inferior_ptid
;
1992 command
->token
= token
;
1996 command
->cmd_start
= (struct mi_timestamp
*)
1997 xmalloc (sizeof (struct mi_timestamp
));
1998 timestamp (command
->cmd_start
);
2001 TRY_CATCH (result
, RETURN_MASK_ALL
)
2003 captured_mi_execute_command (current_uiout
, command
);
2005 if (result
.reason
< 0)
2007 /* The command execution failed and error() was called
2009 mi_print_exception (command
->token
, result
);
2010 mi_out_rewind (current_uiout
);
2013 bpstat_do_actions ();
2015 if (/* The notifications are only output when the top-level
2016 interpreter (specified on the command line) is MI. */
2017 ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ()))
2018 /* Don't try report anything if there are no threads --
2019 the program is dead. */
2020 && thread_count () != 0
2021 /* -thread-select explicitly changes thread. If frontend uses that
2022 internally, we don't want to emit =thread-selected, since
2023 =thread-selected is supposed to indicate user's intentions. */
2024 && strcmp (command
->command
, "thread-select") != 0)
2026 struct mi_interp
*mi
= top_level_interpreter_data ();
2027 int report_change
= 0;
2029 if (command
->thread
== -1)
2031 report_change
= (!ptid_equal (previous_ptid
, null_ptid
)
2032 && !ptid_equal (inferior_ptid
, previous_ptid
)
2033 && !ptid_equal (inferior_ptid
, null_ptid
));
2035 else if (!ptid_equal (inferior_ptid
, null_ptid
))
2037 struct thread_info
*ti
= inferior_thread ();
2039 report_change
= (ti
->num
!= command
->thread
);
2044 struct thread_info
*ti
= inferior_thread ();
2046 target_terminal_ours ();
2047 fprintf_unfiltered (mi
->event_channel
,
2048 "thread-selected,id=\"%d\"",
2050 gdb_flush (mi
->event_channel
);
2054 mi_parse_free (command
);
2059 mi_cmd_execute (struct mi_parse
*parse
)
2061 struct cleanup
*cleanup
;
2063 cleanup
= prepare_execute_command ();
2065 if (parse
->all
&& parse
->thread_group
!= -1)
2066 error (_("Cannot specify --thread-group together with --all"));
2068 if (parse
->all
&& parse
->thread
!= -1)
2069 error (_("Cannot specify --thread together with --all"));
2071 if (parse
->thread_group
!= -1 && parse
->thread
!= -1)
2072 error (_("Cannot specify --thread together with --thread-group"));
2074 if (parse
->frame
!= -1 && parse
->thread
== -1)
2075 error (_("Cannot specify --frame without --thread"));
2077 if (parse
->thread_group
!= -1)
2079 struct inferior
*inf
= find_inferior_id (parse
->thread_group
);
2080 struct thread_info
*tp
= 0;
2083 error (_("Invalid thread group for the --thread-group option"));
2085 set_current_inferior (inf
);
2086 /* This behaviour means that if --thread-group option identifies
2087 an inferior with multiple threads, then a random one will be
2088 picked. This is not a problem -- frontend should always
2089 provide --thread if it wishes to operate on a specific
2092 tp
= any_live_thread_of_process (inf
->pid
);
2093 switch_to_thread (tp
? tp
->ptid
: null_ptid
);
2094 set_current_program_space (inf
->pspace
);
2097 if (parse
->thread
!= -1)
2099 struct thread_info
*tp
= find_thread_id (parse
->thread
);
2102 error (_("Invalid thread id: %d"), parse
->thread
);
2104 if (is_exited (tp
->ptid
))
2105 error (_("Thread id: %d has terminated"), parse
->thread
);
2107 switch_to_thread (tp
->ptid
);
2110 if (parse
->frame
!= -1)
2112 struct frame_info
*fid
;
2113 int frame
= parse
->frame
;
2115 fid
= find_relative_frame (get_current_frame (), &frame
);
2117 /* find_relative_frame was successful */
2120 error (_("Invalid frame id: %d"), frame
);
2123 current_context
= parse
;
2125 if (parse
->cmd
->suppress_notification
!= NULL
)
2127 make_cleanup_restore_integer (parse
->cmd
->suppress_notification
);
2128 *parse
->cmd
->suppress_notification
= 1;
2131 if (parse
->cmd
->argv_func
!= NULL
)
2133 parse
->cmd
->argv_func (parse
->command
, parse
->argv
, parse
->argc
);
2135 else if (parse
->cmd
->cli
.cmd
!= 0)
2137 /* FIXME: DELETE THIS. */
2138 /* The operation is still implemented by a cli command. */
2139 /* Must be a synchronous one. */
2140 mi_execute_cli_command (parse
->cmd
->cli
.cmd
, parse
->cmd
->cli
.args_p
,
2145 /* FIXME: DELETE THIS. */
2146 struct ui_file
*stb
;
2148 stb
= mem_fileopen ();
2150 fputs_unfiltered ("Undefined mi command: ", stb
);
2151 fputstr_unfiltered (parse
->command
, '"', stb
);
2152 fputs_unfiltered (" (missing implementation)", stb
);
2154 make_cleanup_ui_file_delete (stb
);
2157 do_cleanups (cleanup
);
2160 /* FIXME: This is just a hack so we can get some extra commands going.
2161 We don't want to channel things through the CLI, but call libgdb directly.
2162 Use only for synchronous commands. */
2165 mi_execute_cli_command (const char *cmd
, int args_p
, const char *args
)
2169 struct cleanup
*old_cleanups
;
2173 run
= xstrprintf ("%s %s", cmd
, args
);
2175 run
= xstrdup (cmd
);
2177 /* FIXME: gdb_???? */
2178 fprintf_unfiltered (gdb_stdout
, "cli=%s run=%s\n",
2180 old_cleanups
= make_cleanup (xfree
, run
);
2181 execute_command (run
, 0 /* from_tty */ );
2182 do_cleanups (old_cleanups
);
2188 mi_execute_async_cli_command (char *cli_command
, char **argv
, int argc
)
2190 struct cleanup
*old_cleanups
;
2193 if (target_can_async_p ())
2194 run
= xstrprintf ("%s %s&", cli_command
, argc
? *argv
: "");
2196 run
= xstrprintf ("%s %s", cli_command
, argc
? *argv
: "");
2197 old_cleanups
= make_cleanup (xfree
, run
);
2199 execute_command (run
, 0 /* from_tty */ );
2201 /* Do this before doing any printing. It would appear that some
2202 print code leaves garbage around in the buffer. */
2203 do_cleanups (old_cleanups
);
2207 mi_load_progress (const char *section_name
,
2208 unsigned long sent_so_far
,
2209 unsigned long total_section
,
2210 unsigned long total_sent
,
2211 unsigned long grand_total
)
2213 struct timeval time_now
, delta
, update_threshold
;
2214 static struct timeval last_update
;
2215 static char *previous_sect_name
= NULL
;
2217 struct ui_out
*saved_uiout
;
2218 struct ui_out
*uiout
;
2220 /* This function is called through deprecated_show_load_progress
2221 which means uiout may not be correct. Fix it for the duration
2222 of this function. */
2223 saved_uiout
= current_uiout
;
2225 if (current_interp_named_p (INTERP_MI
)
2226 || current_interp_named_p (INTERP_MI2
))
2227 current_uiout
= mi_out_new (2);
2228 else if (current_interp_named_p (INTERP_MI1
))
2229 current_uiout
= mi_out_new (1);
2230 else if (current_interp_named_p (INTERP_MI3
))
2231 current_uiout
= mi_out_new (3);
2235 uiout
= current_uiout
;
2237 update_threshold
.tv_sec
= 0;
2238 update_threshold
.tv_usec
= 500000;
2239 gettimeofday (&time_now
, NULL
);
2241 delta
.tv_usec
= time_now
.tv_usec
- last_update
.tv_usec
;
2242 delta
.tv_sec
= time_now
.tv_sec
- last_update
.tv_sec
;
2244 if (delta
.tv_usec
< 0)
2247 delta
.tv_usec
+= 1000000L;
2250 new_section
= (previous_sect_name
?
2251 strcmp (previous_sect_name
, section_name
) : 1);
2254 struct cleanup
*cleanup_tuple
;
2256 xfree (previous_sect_name
);
2257 previous_sect_name
= xstrdup (section_name
);
2260 fputs_unfiltered (current_token
, raw_stdout
);
2261 fputs_unfiltered ("+download", raw_stdout
);
2262 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2263 ui_out_field_string (uiout
, "section", section_name
);
2264 ui_out_field_int (uiout
, "section-size", total_section
);
2265 ui_out_field_int (uiout
, "total-size", grand_total
);
2266 do_cleanups (cleanup_tuple
);
2267 mi_out_put (uiout
, raw_stdout
);
2268 fputs_unfiltered ("\n", raw_stdout
);
2269 gdb_flush (raw_stdout
);
2272 if (delta
.tv_sec
>= update_threshold
.tv_sec
&&
2273 delta
.tv_usec
>= update_threshold
.tv_usec
)
2275 struct cleanup
*cleanup_tuple
;
2277 last_update
.tv_sec
= time_now
.tv_sec
;
2278 last_update
.tv_usec
= time_now
.tv_usec
;
2280 fputs_unfiltered (current_token
, raw_stdout
);
2281 fputs_unfiltered ("+download", raw_stdout
);
2282 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2283 ui_out_field_string (uiout
, "section", section_name
);
2284 ui_out_field_int (uiout
, "section-sent", sent_so_far
);
2285 ui_out_field_int (uiout
, "section-size", total_section
);
2286 ui_out_field_int (uiout
, "total-sent", total_sent
);
2287 ui_out_field_int (uiout
, "total-size", grand_total
);
2288 do_cleanups (cleanup_tuple
);
2289 mi_out_put (uiout
, raw_stdout
);
2290 fputs_unfiltered ("\n", raw_stdout
);
2291 gdb_flush (raw_stdout
);
2295 current_uiout
= saved_uiout
;
2299 timestamp (struct mi_timestamp
*tv
)
2301 gettimeofday (&tv
->wallclock
, NULL
);
2302 #ifdef HAVE_GETRUSAGE
2303 getrusage (RUSAGE_SELF
, &rusage
);
2304 tv
->utime
.tv_sec
= rusage
.ru_utime
.tv_sec
;
2305 tv
->utime
.tv_usec
= rusage
.ru_utime
.tv_usec
;
2306 tv
->stime
.tv_sec
= rusage
.ru_stime
.tv_sec
;
2307 tv
->stime
.tv_usec
= rusage
.ru_stime
.tv_usec
;
2310 long usec
= get_run_time ();
2312 tv
->utime
.tv_sec
= usec
/1000000L;
2313 tv
->utime
.tv_usec
= usec
- 1000000L*tv
->utime
.tv_sec
;
2314 tv
->stime
.tv_sec
= 0;
2315 tv
->stime
.tv_usec
= 0;
2321 print_diff_now (struct mi_timestamp
*start
)
2323 struct mi_timestamp now
;
2326 print_diff (start
, &now
);
2330 mi_print_timing_maybe (void)
2332 /* If the command is -enable-timing then do_timings may be true
2333 whilst current_command_ts is not initialized. */
2334 if (do_timings
&& current_command_ts
)
2335 print_diff_now (current_command_ts
);
2339 timeval_diff (struct timeval start
, struct timeval end
)
2341 return ((end
.tv_sec
- start
.tv_sec
) * 1000000L)
2342 + (end
.tv_usec
- start
.tv_usec
);
2346 print_diff (struct mi_timestamp
*start
, struct mi_timestamp
*end
)
2350 ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
2351 timeval_diff (start
->wallclock
, end
->wallclock
) / 1000000.0,
2352 timeval_diff (start
->utime
, end
->utime
) / 1000000.0,
2353 timeval_diff (start
->stime
, end
->stime
) / 1000000.0);
2357 mi_cmd_trace_define_variable (char *command
, char **argv
, int argc
)
2359 struct expression
*expr
;
2360 LONGEST initval
= 0;
2361 struct trace_state_variable
*tsv
;
2364 if (argc
!= 1 && argc
!= 2)
2365 error (_("Usage: -trace-define-variable VARIABLE [VALUE]"));
2369 error (_("Name of trace variable should start with '$'"));
2371 validate_trace_state_variable_name (name
);
2373 tsv
= find_trace_state_variable (name
);
2375 tsv
= create_trace_state_variable (name
);
2378 initval
= value_as_long (parse_and_eval (argv
[1]));
2380 tsv
->initial_value
= initval
;
2384 mi_cmd_trace_list_variables (char *command
, char **argv
, int argc
)
2387 error (_("-trace-list-variables: no arguments allowed"));
2389 tvariables_info_1 ();
2393 mi_cmd_trace_find (char *command
, char **argv
, int argc
)
2398 error (_("trace selection mode is required"));
2402 if (strcmp (mode
, "none") == 0)
2404 tfind_1 (tfind_number
, -1, 0, 0, 0);
2408 if (current_trace_status ()->running
)
2409 error (_("May not look at trace frames while trace is running."));
2411 if (strcmp (mode
, "frame-number") == 0)
2414 error (_("frame number is required"));
2415 tfind_1 (tfind_number
, atoi (argv
[1]), 0, 0, 0);
2417 else if (strcmp (mode
, "tracepoint-number") == 0)
2420 error (_("tracepoint number is required"));
2421 tfind_1 (tfind_tp
, atoi (argv
[1]), 0, 0, 0);
2423 else if (strcmp (mode
, "pc") == 0)
2426 error (_("PC is required"));
2427 tfind_1 (tfind_pc
, 0, parse_and_eval_address (argv
[1]), 0, 0);
2429 else if (strcmp (mode
, "pc-inside-range") == 0)
2432 error (_("Start and end PC are required"));
2433 tfind_1 (tfind_range
, 0, parse_and_eval_address (argv
[1]),
2434 parse_and_eval_address (argv
[2]), 0);
2436 else if (strcmp (mode
, "pc-outside-range") == 0)
2439 error (_("Start and end PC are required"));
2440 tfind_1 (tfind_outside
, 0, parse_and_eval_address (argv
[1]),
2441 parse_and_eval_address (argv
[2]), 0);
2443 else if (strcmp (mode
, "line") == 0)
2445 struct symtabs_and_lines sals
;
2446 struct symtab_and_line sal
;
2447 static CORE_ADDR start_pc
, end_pc
;
2448 struct cleanup
*back_to
;
2451 error (_("Line is required"));
2453 sals
= decode_line_with_current_source (argv
[1],
2454 DECODE_LINE_FUNFIRSTLINE
);
2455 back_to
= make_cleanup (xfree
, sals
.sals
);
2459 if (sal
.symtab
== 0)
2460 error (_("Could not find the specified line"));
2462 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2463 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, 0);
2465 error (_("Could not find the specified line"));
2467 do_cleanups (back_to
);
2470 error (_("Invalid mode '%s'"), mode
);
2472 if (has_stack_frames () || get_traceframe_number () >= 0)
2473 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
2477 mi_cmd_trace_save (char *command
, char **argv
, int argc
)
2479 int target_saves
= 0;
2482 if (argc
!= 1 && argc
!= 2)
2483 error (_("Usage: -trace-save [-r] filename"));
2488 if (strcmp (argv
[0], "-r") == 0)
2491 error (_("Invalid option: %s"), argv
[0]);
2498 trace_save (filename
, target_saves
);
2502 mi_cmd_trace_start (char *command
, char **argv
, int argc
)
2504 start_tracing (NULL
);
2508 mi_cmd_trace_status (char *command
, char **argv
, int argc
)
2510 trace_status_mi (0);
2514 mi_cmd_trace_stop (char *command
, char **argv
, int argc
)
2516 stop_tracing (NULL
);
2517 trace_status_mi (1);
2520 /* Implement the "-ada-task-info" command. */
2523 mi_cmd_ada_task_info (char *command
, char **argv
, int argc
)
2525 if (argc
!= 0 && argc
!= 1)
2526 error (_("Invalid MI command"));
2528 print_ada_task_info (current_uiout
, argv
[0], current_inferior ());