3 Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010
4 Free Software Foundation, Inc.
6 Contributed by Cygnus Solutions (a Red Hat company).
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 /* Work in progress. */
26 #include "arch-utils.h"
29 #include "gdb_string.h"
30 #include "exceptions.h"
32 #include "gdbthread.h"
35 #include "mi-getopt.h"
36 #include "mi-console.h"
40 #include "event-loop.h"
41 #include "event-top.h"
42 #include "gdbcore.h" /* For write_memory(). */
48 #include "mi-common.h"
53 #include "splay-tree.h"
54 #include "tracepoint.h"
59 #if defined HAVE_SYS_RESOURCE_H
60 #include <sys/resource.h>
73 struct ui_file
*raw_stdout
;
75 /* This is used to pass the current command timestamp
76 down to 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
83 were explicitly specified. This variable keeps the current
84 parsed 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 (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);
218 proceed_thread_callback (struct thread_info
*thread
, void *arg
)
220 int pid
= *(int *)arg
;
222 proceed_thread (thread
, pid
);
227 exec_continue (char **argv
, int argc
)
231 /* In non-stop mode, 'resume' always resumes a single thread. Therefore,
232 to resume all threads of the current inferior, or all threads in all
233 inferiors, we need to iterate over threads.
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
)
243 struct inferior
*inf
= find_inferior_id (current_context
->thread_group
);
246 iterate_over_threads (proceed_thread_callback
, &pid
);
247 do_cleanups (back_to
);
256 struct cleanup
*back_to
= make_cleanup_restore_integer (&sched_multi
);
258 if (current_context
->all
)
265 /* In all-stop mode, -exec-continue traditionally resumed either
266 all threads, or one thread, depending on the 'scheduler-locking'
267 variable. Let's continue to do the same. */
270 do_cleanups (back_to
);
275 exec_direction_forward (void *notused
)
277 execution_direction
= EXEC_FORWARD
;
281 exec_reverse_continue (char **argv
, int argc
)
283 enum exec_direction_kind dir
= execution_direction
;
284 struct cleanup
*old_chain
;
286 if (dir
== EXEC_ERROR
)
287 error (_("Target %s does not support this command."), target_shortname
);
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 around
326 with the token variables, in order to display the current token in
327 the result of the interrupt command, and the previous execution
328 token when the target finally stops. See comments in
331 mi_cmd_exec_interrupt (char *command
, char **argv
, int argc
)
333 /* In all-stop mode, everything stops, so we don't need to try
334 anything specific. */
337 interrupt_target_1 (0);
341 if (current_context
->all
)
343 /* This will interrupt all threads in all inferiors. */
344 interrupt_target_1 (1);
346 else if (current_context
->thread_group
!= -1)
348 struct inferior
*inf
= find_inferior_id (current_context
->thread_group
);
350 iterate_over_threads (interrupt_thread_callback
, &inf
->pid
);
354 /* Interrupt just the current thread -- either explicitly
355 specified via --thread or whatever was current before
356 MI command was sent. */
357 interrupt_target_1 (0);
362 run_one_inferior (struct inferior
*inf
, void *arg
)
366 if (inf
->pid
!= ptid_get_pid (inferior_ptid
))
368 struct thread_info
*tp
;
370 tp
= any_thread_of_process (inf
->pid
);
372 error (_("Inferior has no threads."));
374 switch_to_thread (tp
->ptid
);
379 set_current_inferior (inf
);
380 switch_to_thread (null_ptid
);
381 set_current_program_space (inf
->pspace
);
383 mi_execute_cli_command ("run", target_can_async_p (),
384 target_can_async_p () ? "&" : NULL
);
389 mi_cmd_exec_run (char *command
, char **argv
, int argc
)
391 if (current_context
->all
)
393 struct cleanup
*back_to
= save_current_space_and_thread ();
395 iterate_over_inferiors (run_one_inferior
, NULL
);
396 do_cleanups (back_to
);
400 mi_execute_cli_command ("run", target_can_async_p (),
401 target_can_async_p () ? "&" : NULL
);
407 find_thread_of_process (struct thread_info
*ti
, void *p
)
411 if (PIDGET (ti
->ptid
) == pid
&& !is_exited (ti
->ptid
))
418 mi_cmd_target_detach (char *command
, char **argv
, int argc
)
420 if (argc
!= 0 && argc
!= 1)
421 error ("Usage: -target-detach [pid | thread-group]");
425 struct thread_info
*tp
;
429 /* First see if we are dealing with a thread-group id. */
432 struct inferior
*inf
;
433 int id
= strtoul (argv
[0] + 1, &end
, 0);
436 error (_("Invalid syntax of thread-group id '%s'"), argv
[0]);
438 inf
= find_inferior_id (id
);
440 error (_("Non-existent thread-group id '%d'"), id
);
446 /* We must be dealing with a pid. */
447 pid
= strtol (argv
[0], &end
, 10);
450 error (_("Invalid identifier '%s'"), argv
[0]);
453 /* Pick any thread in the desired process. Current
454 target_detach detaches from the parent of inferior_ptid. */
455 tp
= iterate_over_threads (find_thread_of_process
, &pid
);
457 error (_("Thread group is empty"));
459 switch_to_thread (tp
->ptid
);
462 detach_command (NULL
, 0);
466 mi_cmd_thread_select (char *command
, char **argv
, int argc
)
469 char *mi_error_message
;
472 error ("mi_cmd_thread_select: USAGE: threadnum.");
474 rc
= gdb_thread_select (uiout
, argv
[0], &mi_error_message
);
476 if (rc
== GDB_RC_FAIL
)
478 make_cleanup (xfree
, mi_error_message
);
479 error ("%s", mi_error_message
);
484 mi_cmd_thread_list_ids (char *command
, char **argv
, int argc
)
487 char *mi_error_message
;
490 error ("mi_cmd_thread_list_ids: No arguments required.");
492 rc
= gdb_list_thread_ids (uiout
, &mi_error_message
);
494 if (rc
== GDB_RC_FAIL
)
496 make_cleanup (xfree
, mi_error_message
);
497 error ("%s", mi_error_message
);
502 mi_cmd_thread_info (char *command
, char **argv
, int argc
)
506 if (argc
!= 0 && argc
!= 1)
507 error ("Invalid MI command");
510 thread
= atoi (argv
[0]);
512 print_thread_info (uiout
, thread
, -1);
515 struct collect_cores_data
523 collect_cores (struct thread_info
*ti
, void *xdata
)
525 struct collect_cores_data
*data
= xdata
;
527 if (ptid_get_pid (ti
->ptid
) == data
->pid
)
529 int core
= target_core_of_thread (ti
->ptid
);
532 VEC_safe_push (int, data
->cores
, core
);
539 unique (int *b
, int *e
)
549 struct print_one_inferior_data
552 VEC (int) *inferiors
;
556 print_one_inferior (struct inferior
*inferior
, void *xdata
)
558 struct print_one_inferior_data
*top_data
= xdata
;
560 if (VEC_empty (int, top_data
->inferiors
)
561 || bsearch (&(inferior
->pid
), VEC_address (int, top_data
->inferiors
),
562 VEC_length (int, top_data
->inferiors
), sizeof (int),
563 compare_positive_ints
))
565 struct collect_cores_data data
;
566 struct cleanup
*back_to
567 = make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
569 ui_out_field_fmt (uiout
, "id", "i%d", inferior
->num
);
570 ui_out_field_string (uiout
, "type", "process");
571 if (inferior
->pid
!= 0)
572 ui_out_field_int (uiout
, "pid", inferior
->pid
);
574 if (inferior
->pspace
->ebfd
)
576 ui_out_field_string (uiout
, "executable",
577 bfd_get_filename (inferior
->pspace
->ebfd
));
581 if (inferior
->pid
!= 0)
583 data
.pid
= inferior
->pid
;
584 iterate_over_threads (collect_cores
, &data
);
587 if (!VEC_empty (int, data
.cores
))
590 struct cleanup
*back_to_2
=
591 make_cleanup_ui_out_list_begin_end (uiout
, "cores");
593 qsort (VEC_address (int, data
.cores
),
594 VEC_length (int, data
.cores
), sizeof (int),
595 compare_positive_ints
);
597 b
= VEC_address (int, data
.cores
);
598 e
= b
+ VEC_length (int, data
.cores
);
602 ui_out_field_int (uiout
, NULL
, *b
);
604 do_cleanups (back_to_2
);
607 if (top_data
->recurse
)
608 print_thread_info (uiout
, -1, inferior
->pid
);
610 do_cleanups (back_to
);
616 /* Output a field named 'cores' with a list as the value. The elements of
617 the list are obtained by splitting 'cores' on comma. */
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
;
680 /* This keeps a map from integer (pid) to VEC (struct osdata_item *)*
681 The vector contains information about all threads for the given pid.
682 This is assigned an initial value to avoid "may be used uninitialized"
684 splay_tree tree
= NULL
;
686 /* get_osdata will throw if it cannot return data. */
687 data
= get_osdata ("processes");
688 make_cleanup_osdata_free (data
);
692 struct osdata
*threads
= get_osdata ("threads");
694 make_cleanup_osdata_free (threads
);
695 tree
= splay_tree_new (splay_tree_int_comparator
,
697 free_vector_of_osdata_items
);
698 make_cleanup (free_splay_tree
, tree
);
701 VEC_iterate (osdata_item_s
, threads
->items
,
705 const char *pid
= get_osdata_column (item
, "pid");
706 int pid_i
= strtoul (pid
, NULL
, 0);
707 VEC (osdata_item_s
) *vec
= 0;
709 splay_tree_node n
= splay_tree_lookup (tree
, pid_i
);
712 VEC_safe_push (osdata_item_s
, vec
, item
);
713 splay_tree_insert (tree
, pid_i
, (splay_tree_value
)vec
);
717 vec
= (VEC (osdata_item_s
) *) n
->value
;
718 VEC_safe_push (osdata_item_s
, vec
, item
);
719 n
->value
= (splay_tree_value
) vec
;
724 make_cleanup_ui_out_list_begin_end (uiout
, "groups");
727 VEC_iterate (osdata_item_s
, data
->items
,
731 struct cleanup
*back_to
;
733 const char *pid
= get_osdata_column (item
, "pid");
734 const char *cmd
= get_osdata_column (item
, "command");
735 const char *user
= get_osdata_column (item
, "user");
736 const char *cores
= get_osdata_column (item
, "cores");
738 int pid_i
= strtoul (pid
, NULL
, 0);
740 /* At present, the target will return all available processes
741 and if information about specific ones was required, we filter
742 undesired processes here. */
743 if (ids
&& bsearch (&pid_i
, VEC_address (int, ids
),
744 VEC_length (int, ids
),
745 sizeof (int), compare_positive_ints
) == NULL
)
749 back_to
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
751 ui_out_field_fmt (uiout
, "id", "%s", pid
);
752 ui_out_field_string (uiout
, "type", "process");
754 ui_out_field_string (uiout
, "description", cmd
);
756 ui_out_field_string (uiout
, "user", user
);
758 output_cores (uiout
, "cores", cores
);
762 splay_tree_node n
= splay_tree_lookup (tree
, pid_i
);
765 VEC (osdata_item_s
) *children
= (VEC (osdata_item_s
) *) n
->value
;
766 struct osdata_item
*child
;
769 make_cleanup_ui_out_list_begin_end (uiout
, "threads");
772 VEC_iterate (osdata_item_s
, children
, ix_child
, child
);
775 struct cleanup
*back_to_2
=
776 make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
777 const char *tid
= get_osdata_column (child
, "tid");
778 const char *tcore
= get_osdata_column (child
, "core");
780 ui_out_field_string (uiout
, "id", tid
);
782 ui_out_field_string (uiout
, "core", tcore
);
784 do_cleanups (back_to_2
);
789 do_cleanups (back_to
);
794 mi_cmd_list_thread_groups (char *command
, char **argv
, int argc
)
796 struct cleanup
*back_to
;
803 AVAILABLE_OPT
, RECURSE_OPT
805 static struct mi_opt opts
[] =
807 {"-available", AVAILABLE_OPT
, 0},
808 {"-recurse", RECURSE_OPT
, 1},
817 int opt
= mi_getopt ("-list-thread-groups", argc
, argv
, opts
,
822 switch ((enum opt
) opt
)
828 if (strcmp (optarg
, "0") == 0)
830 else if (strcmp (optarg
, "1") == 0)
833 error ("only '0' and '1' are valid values for the '--recurse' option");
838 for (; optind
< argc
; ++optind
)
843 if (*(argv
[optind
]) != 'i')
844 error ("invalid syntax of group id '%s'", argv
[optind
]);
846 inf
= strtoul (argv
[optind
] + 1, &end
, 0);
849 error ("invalid syntax of group id '%s'", argv
[optind
]);
850 VEC_safe_push (int, ids
, inf
);
852 if (VEC_length (int, ids
) > 1)
853 qsort (VEC_address (int, ids
),
854 VEC_length (int, ids
),
855 sizeof (int), compare_positive_ints
);
857 back_to
= make_cleanup (free_vector_of_ints
, &ids
);
861 list_available_thread_groups (ids
, recurse
);
863 else if (VEC_length (int, ids
) == 1)
865 /* Local thread groups, single id. */
866 int id
= *VEC_address (int, ids
);
867 struct inferior
*inf
= find_inferior_id (id
);
870 error ("Non-existent thread group id '%d'", id
);
872 print_thread_info (uiout
, -1, inf
->pid
);
876 struct print_one_inferior_data data
;
878 data
.recurse
= recurse
;
879 data
.inferiors
= ids
;
881 /* Local thread groups. Either no explicit ids -- and we
882 print everything, or several explicit ids. In both cases,
883 we print more than one group, and have to use 'groups'
884 as the top-level element. */
885 make_cleanup_ui_out_list_begin_end (uiout
, "groups");
886 update_thread_list ();
887 iterate_over_inferiors (print_one_inferior
, &data
);
890 do_cleanups (back_to
);
894 mi_cmd_data_list_register_names (char *command
, char **argv
, int argc
)
896 struct gdbarch
*gdbarch
;
899 struct cleanup
*cleanup
;
901 /* Note that the test for a valid register must include checking the
902 gdbarch_register_name because gdbarch_num_regs may be allocated for
903 the union of the register sets within a family of related processors.
904 In this case, some entries of gdbarch_register_name will change depending
905 upon the particular processor being debugged. */
907 gdbarch
= get_current_arch ();
908 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
910 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "register-names");
912 if (argc
== 0) /* No args, just do all the regs. */
918 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
919 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
920 ui_out_field_string (uiout
, NULL
, "");
922 ui_out_field_string (uiout
, NULL
,
923 gdbarch_register_name (gdbarch
, regnum
));
927 /* Else, list of register #s, just do listed regs. */
928 for (i
= 0; i
< argc
; i
++)
930 regnum
= atoi (argv
[i
]);
931 if (regnum
< 0 || regnum
>= numregs
)
932 error ("bad register number");
934 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
935 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
936 ui_out_field_string (uiout
, NULL
, "");
938 ui_out_field_string (uiout
, NULL
,
939 gdbarch_register_name (gdbarch
, regnum
));
941 do_cleanups (cleanup
);
945 mi_cmd_data_list_changed_registers (char *command
, char **argv
, int argc
)
947 static struct regcache
*this_regs
= NULL
;
948 struct regcache
*prev_regs
;
949 struct gdbarch
*gdbarch
;
950 int regnum
, numregs
, changed
;
952 struct cleanup
*cleanup
;
954 /* The last time we visited this function, the current frame's register
955 contents were saved in THIS_REGS. Move THIS_REGS over to PREV_REGS,
956 and refresh THIS_REGS with the now-current register contents. */
958 prev_regs
= this_regs
;
959 this_regs
= frame_save_as_regcache (get_selected_frame (NULL
));
960 cleanup
= make_cleanup_regcache_xfree (prev_regs
);
962 /* Note that the test for a valid register must include checking the
963 gdbarch_register_name because gdbarch_num_regs may be allocated for
964 the union of the register sets within a family of related processors.
965 In this case, some entries of gdbarch_register_name will change depending
966 upon the particular processor being debugged. */
968 gdbarch
= get_regcache_arch (this_regs
);
969 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
971 make_cleanup_ui_out_list_begin_end (uiout
, "changed-registers");
973 if (argc
== 0) /* No args, just do all the regs. */
979 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
980 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
982 changed
= register_changed_p (regnum
, prev_regs
, this_regs
);
984 error ("mi_cmd_data_list_changed_registers: Unable to read register contents.");
986 ui_out_field_int (uiout
, NULL
, regnum
);
990 /* Else, list of register #s, just do listed regs. */
991 for (i
= 0; i
< argc
; i
++)
993 regnum
= atoi (argv
[i
]);
997 && gdbarch_register_name (gdbarch
, regnum
) != NULL
998 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
1000 changed
= register_changed_p (regnum
, prev_regs
, this_regs
);
1002 error ("mi_cmd_data_list_register_change: Unable to read register contents.");
1004 ui_out_field_int (uiout
, NULL
, regnum
);
1007 error ("bad register number");
1009 do_cleanups (cleanup
);
1013 register_changed_p (int regnum
, struct regcache
*prev_regs
,
1014 struct regcache
*this_regs
)
1016 struct gdbarch
*gdbarch
= get_regcache_arch (this_regs
);
1017 gdb_byte prev_buffer
[MAX_REGISTER_SIZE
];
1018 gdb_byte this_buffer
[MAX_REGISTER_SIZE
];
1020 /* Registers not valid in this frame return count as unchanged. */
1021 if (!regcache_valid_p (this_regs
, regnum
))
1024 /* First time through or after gdbarch change consider all registers as
1025 changed. Same for registers not valid in the previous frame. */
1026 if (!prev_regs
|| get_regcache_arch (prev_regs
) != gdbarch
1027 || !regcache_valid_p (prev_regs
, regnum
))
1030 /* Get register contents and compare. */
1031 regcache_cooked_read (prev_regs
, regnum
, prev_buffer
);
1032 regcache_cooked_read (this_regs
, regnum
, this_buffer
);
1034 return memcmp (prev_buffer
, this_buffer
,
1035 register_size (gdbarch
, regnum
)) != 0;
1038 /* Return a list of register number and value pairs. The valid
1039 arguments expected are: a letter indicating the format in which to
1040 display the registers contents. This can be one of: x (hexadecimal), d
1041 (decimal), N (natural), t (binary), o (octal), r (raw). After the
1042 format argumetn there can be a sequence of numbers, indicating which
1043 registers to fetch the content of. If the format is the only argument,
1044 a list of all the registers with their values is returned. */
1046 mi_cmd_data_list_register_values (char *command
, char **argv
, int argc
)
1048 struct frame_info
*frame
;
1049 struct gdbarch
*gdbarch
;
1050 int regnum
, numregs
, format
;
1052 struct cleanup
*list_cleanup
, *tuple_cleanup
;
1054 /* Note that the test for a valid register must include checking the
1055 gdbarch_register_name because gdbarch_num_regs may be allocated for
1056 the union of the register sets within a family of related processors.
1057 In this case, some entries of gdbarch_register_name will change depending
1058 upon the particular processor being debugged. */
1061 error ("mi_cmd_data_list_register_values: Usage: -data-list-register-values <format> [<regnum1>...<regnumN>]");
1063 format
= (int) argv
[0][0];
1065 frame
= get_selected_frame (NULL
);
1066 gdbarch
= get_frame_arch (frame
);
1067 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1069 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "register-values");
1071 if (argc
== 1) /* No args, beside the format: do all the regs. */
1077 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1078 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1080 tuple_cleanup
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1081 ui_out_field_int (uiout
, "number", regnum
);
1082 get_register (frame
, regnum
, format
);
1083 do_cleanups (tuple_cleanup
);
1087 /* Else, list of register #s, just do listed regs. */
1088 for (i
= 1; i
< argc
; i
++)
1090 regnum
= atoi (argv
[i
]);
1094 && gdbarch_register_name (gdbarch
, regnum
) != NULL
1095 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
1097 tuple_cleanup
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1098 ui_out_field_int (uiout
, "number", regnum
);
1099 get_register (frame
, regnum
, format
);
1100 do_cleanups (tuple_cleanup
);
1103 error ("bad register number");
1105 do_cleanups (list_cleanup
);
1108 /* Output one register's contents in the desired format. */
1110 get_register (struct frame_info
*frame
, int regnum
, int format
)
1112 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1113 gdb_byte buffer
[MAX_REGISTER_SIZE
];
1117 enum lval_type lval
;
1118 static struct ui_stream
*stb
= NULL
;
1120 stb
= ui_out_stream_new (uiout
);
1125 frame_register (frame
, regnum
, &optim
, &lval
, &addr
, &realnum
, buffer
);
1128 error ("Optimized out");
1133 char *ptr
, buf
[1024];
1137 for (j
= 0; j
< register_size (gdbarch
, regnum
); j
++)
1139 int idx
= gdbarch_byte_order (gdbarch
) == BFD_ENDIAN_BIG
?
1140 j
: register_size (gdbarch
, regnum
) - 1 - j
;
1142 sprintf (ptr
, "%02x", (unsigned char) buffer
[idx
]);
1145 ui_out_field_string (uiout
, "value", buf
);
1146 /*fputs_filtered (buf, gdb_stdout); */
1150 struct value_print_options opts
;
1152 get_formatted_print_options (&opts
, format
);
1154 val_print (register_type (gdbarch
, regnum
), buffer
, 0, 0,
1155 stb
->stream
, 0, NULL
, &opts
, current_language
);
1156 ui_out_field_stream (uiout
, "value", stb
);
1157 ui_out_stream_delete (stb
);
1161 /* Write given values into registers. The registers and values are
1162 given as pairs. The corresponding MI command is
1163 -data-write-register-values <format> [<regnum1> <value1>...<regnumN> <valueN>]*/
1165 mi_cmd_data_write_register_values (char *command
, char **argv
, int argc
)
1167 struct regcache
*regcache
;
1168 struct gdbarch
*gdbarch
;
1172 /* Note that the test for a valid register must include checking the
1173 gdbarch_register_name because gdbarch_num_regs may be allocated for
1174 the union of the register sets within a family of related processors.
1175 In this case, some entries of gdbarch_register_name will change depending
1176 upon the particular processor being debugged. */
1178 regcache
= get_current_regcache ();
1179 gdbarch
= get_regcache_arch (regcache
);
1180 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1183 error ("mi_cmd_data_write_register_values: Usage: -data-write-register-values <format> [<regnum1> <value1>...<regnumN> <valueN>]");
1185 format
= (int) argv
[0][0];
1187 if (!target_has_registers
)
1188 error ("mi_cmd_data_write_register_values: No registers.");
1191 error ("mi_cmd_data_write_register_values: No regs and values specified.");
1194 error ("mi_cmd_data_write_register_values: Regs and vals are not in pairs.");
1196 for (i
= 1; i
< argc
; i
= i
+ 2)
1198 int regnum
= atoi (argv
[i
]);
1200 if (regnum
>= 0 && regnum
< numregs
1201 && gdbarch_register_name (gdbarch
, regnum
)
1202 && *gdbarch_register_name (gdbarch
, regnum
))
1206 /* Get the value as a number. */
1207 value
= parse_and_eval_address (argv
[i
+ 1]);
1209 /* Write it down. */
1210 regcache_cooked_write_signed (regcache
, regnum
, value
);
1213 error ("bad register number");
1217 /* Evaluate the value of the argument. The argument is an
1218 expression. If the expression contains spaces it needs to be
1219 included in double quotes. */
1221 mi_cmd_data_evaluate_expression (char *command
, char **argv
, int argc
)
1223 struct expression
*expr
;
1224 struct cleanup
*old_chain
= NULL
;
1226 struct ui_stream
*stb
= NULL
;
1227 struct value_print_options opts
;
1229 stb
= ui_out_stream_new (uiout
);
1233 ui_out_stream_delete (stb
);
1234 error ("mi_cmd_data_evaluate_expression: Usage: -data-evaluate-expression expression");
1237 expr
= parse_expression (argv
[0]);
1239 old_chain
= make_cleanup (free_current_contents
, &expr
);
1241 val
= evaluate_expression (expr
);
1243 /* Print the result of the expression evaluation. */
1244 get_user_print_options (&opts
);
1246 common_val_print (val
, stb
->stream
, 0, &opts
, current_language
);
1248 ui_out_field_stream (uiout
, "value", stb
);
1249 ui_out_stream_delete (stb
);
1251 do_cleanups (old_chain
);
1254 /* DATA-MEMORY-READ:
1256 ADDR: start address of data to be dumped.
1257 WORD-FORMAT: a char indicating format for the ``word''. See
1259 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes.
1260 NR_ROW: Number of rows.
1261 NR_COL: The number of colums (words per row).
1262 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
1263 ASCHAR for unprintable characters.
1265 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
1266 displayes them. Returns:
1268 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
1271 The number of bytes read is SIZE*ROW*COL. */
1274 mi_cmd_data_read_memory (char *command
, char **argv
, int argc
)
1276 struct gdbarch
*gdbarch
= get_current_arch ();
1277 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
1283 struct type
*word_type
;
1296 static struct mi_opt opts
[] =
1298 {"o", OFFSET_OPT
, 1},
1304 int opt
= mi_getopt ("mi_cmd_data_read_memory", argc
, argv
, opts
,
1309 switch ((enum opt
) opt
)
1312 offset
= atol (optarg
);
1319 if (argc
< 5 || argc
> 6)
1320 error ("mi_cmd_data_read_memory: Usage: ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR].");
1322 /* Extract all the arguments. */
1324 /* Start address of the memory dump. */
1325 addr
= parse_and_eval_address (argv
[0]) + offset
;
1326 /* The format character to use when displaying a memory word. See
1327 the ``x'' command. */
1328 word_format
= argv
[1][0];
1329 /* The size of the memory word. */
1330 word_size
= atol (argv
[2]);
1334 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1338 word_type
= builtin_type (gdbarch
)->builtin_int16
;
1342 word_type
= builtin_type (gdbarch
)->builtin_int32
;
1346 word_type
= builtin_type (gdbarch
)->builtin_int64
;
1350 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1353 /* The number of rows. */
1354 nr_rows
= atol (argv
[3]);
1356 error ("mi_cmd_data_read_memory: invalid number of rows.");
1358 /* Number of bytes per row. */
1359 nr_cols
= atol (argv
[4]);
1361 error ("mi_cmd_data_read_memory: invalid number of columns.");
1363 /* The un-printable character when printing ascii. */
1369 /* Create a buffer and read it in. */
1370 total_bytes
= word_size
* nr_rows
* nr_cols
;
1371 mbuf
= xcalloc (total_bytes
, 1);
1372 make_cleanup (xfree
, mbuf
);
1374 /* Dispatch memory reads to the topmost target, not the flattened
1376 nr_bytes
= target_read (current_target
.beneath
,
1377 TARGET_OBJECT_MEMORY
, NULL
, mbuf
,
1380 error ("Unable to read memory.");
1382 /* Output the header information. */
1383 ui_out_field_core_addr (uiout
, "addr", gdbarch
, addr
);
1384 ui_out_field_int (uiout
, "nr-bytes", nr_bytes
);
1385 ui_out_field_int (uiout
, "total-bytes", total_bytes
);
1386 ui_out_field_core_addr (uiout
, "next-row",
1387 gdbarch
, addr
+ word_size
* nr_cols
);
1388 ui_out_field_core_addr (uiout
, "prev-row",
1389 gdbarch
, addr
- word_size
* nr_cols
);
1390 ui_out_field_core_addr (uiout
, "next-page", gdbarch
, addr
+ total_bytes
);
1391 ui_out_field_core_addr (uiout
, "prev-page", gdbarch
, addr
- total_bytes
);
1393 /* Build the result as a two dimentional table. */
1395 struct ui_stream
*stream
= ui_out_stream_new (uiout
);
1396 struct cleanup
*cleanup_list_memory
;
1400 cleanup_list_memory
= make_cleanup_ui_out_list_begin_end (uiout
, "memory");
1401 for (row
= 0, row_byte
= 0;
1403 row
++, row_byte
+= nr_cols
* word_size
)
1407 struct cleanup
*cleanup_tuple
;
1408 struct cleanup
*cleanup_list_data
;
1409 struct value_print_options opts
;
1411 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1412 ui_out_field_core_addr (uiout
, "addr", gdbarch
, addr
+ row_byte
);
1413 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr + row_byte); */
1414 cleanup_list_data
= make_cleanup_ui_out_list_begin_end (uiout
, "data");
1415 get_formatted_print_options (&opts
, word_format
);
1416 for (col
= 0, col_byte
= row_byte
;
1418 col
++, col_byte
+= word_size
)
1420 if (col_byte
+ word_size
> nr_bytes
)
1422 ui_out_field_string (uiout
, NULL
, "N/A");
1426 ui_file_rewind (stream
->stream
);
1427 print_scalar_formatted (mbuf
+ col_byte
, word_type
, &opts
,
1428 word_asize
, stream
->stream
);
1429 ui_out_field_stream (uiout
, NULL
, stream
);
1432 do_cleanups (cleanup_list_data
);
1437 ui_file_rewind (stream
->stream
);
1438 for (byte
= row_byte
; byte
< row_byte
+ word_size
* nr_cols
; byte
++)
1440 if (byte
>= nr_bytes
)
1442 fputc_unfiltered ('X', stream
->stream
);
1444 else if (mbuf
[byte
] < 32 || mbuf
[byte
] > 126)
1446 fputc_unfiltered (aschar
, stream
->stream
);
1449 fputc_unfiltered (mbuf
[byte
], stream
->stream
);
1451 ui_out_field_stream (uiout
, "ascii", stream
);
1453 do_cleanups (cleanup_tuple
);
1455 ui_out_stream_delete (stream
);
1456 do_cleanups (cleanup_list_memory
);
1458 do_cleanups (cleanups
);
1462 mi_cmd_data_read_memory_bytes (char *command
, char **argv
, int argc
)
1464 struct gdbarch
*gdbarch
= get_current_arch ();
1465 struct cleanup
*cleanups
;
1468 memory_read_result_s
*read_result
;
1470 VEC(memory_read_result_s
) *result
;
1478 static struct mi_opt opts
[] =
1480 {"o", OFFSET_OPT
, 1},
1486 int opt
= mi_getopt ("mi_cmd_data_read_memory_bytes", argc
, argv
, opts
,
1490 switch ((enum opt
) opt
)
1493 offset
= atol (optarg
);
1501 error ("Usage: [ -o OFFSET ] ADDR LENGTH.");
1503 addr
= parse_and_eval_address (argv
[0]) + offset
;
1504 length
= atol (argv
[1]);
1506 result
= read_memory_robust (current_target
.beneath
, addr
, length
);
1508 cleanups
= make_cleanup (free_memory_read_result_vector
, result
);
1510 if (VEC_length (memory_read_result_s
, result
) == 0)
1511 error ("Unable to read memory.");
1513 make_cleanup_ui_out_list_begin_end (uiout
, "memory");
1515 VEC_iterate (memory_read_result_s
, result
, ix
, read_result
);
1518 struct cleanup
*t
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1522 ui_out_field_core_addr (uiout
, "begin", gdbarch
, read_result
->begin
);
1523 ui_out_field_core_addr (uiout
, "offset", gdbarch
, read_result
->begin
1525 ui_out_field_core_addr (uiout
, "end", gdbarch
, read_result
->end
);
1527 data
= xmalloc ((read_result
->end
- read_result
->begin
) * 2 + 1);
1529 for (i
= 0, p
= data
;
1530 i
< (read_result
->end
- read_result
->begin
);
1533 sprintf (p
, "%02x", read_result
->data
[i
]);
1535 ui_out_field_string (uiout
, "contents", data
);
1539 do_cleanups (cleanups
);
1543 /* DATA-MEMORY-WRITE:
1545 COLUMN_OFFSET: optional argument. Must be preceeded by '-o'. The
1546 offset from the beginning of the memory grid row where the cell to
1548 ADDR: start address of the row in the memory grid where the memory
1549 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
1550 the location to write to.
1551 FORMAT: a char indicating format for the ``word''. See
1553 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
1554 VALUE: value to be written into the memory address.
1556 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
1560 mi_cmd_data_write_memory (char *command
, char **argv
, int argc
)
1562 struct gdbarch
*gdbarch
= get_current_arch ();
1563 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1567 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
1568 enough when using a compiler other than GCC. */
1571 struct cleanup
*old_chain
;
1579 static struct mi_opt opts
[] =
1581 {"o", OFFSET_OPT
, 1},
1587 int opt
= mi_getopt ("mi_cmd_data_write_memory", argc
, argv
, opts
,
1592 switch ((enum opt
) opt
)
1595 offset
= atol (optarg
);
1603 error ("mi_cmd_data_write_memory: Usage: [-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE.");
1605 /* Extract all the arguments. */
1606 /* Start address of the memory dump. */
1607 addr
= parse_and_eval_address (argv
[0]);
1608 /* The format character to use when displaying a memory word. See
1609 the ``x'' command. */
1610 word_format
= argv
[1][0];
1611 /* The size of the memory word. */
1612 word_size
= atol (argv
[2]);
1614 /* Calculate the real address of the write destination. */
1615 addr
+= (offset
* word_size
);
1617 /* Get the value as a number. */
1618 value
= parse_and_eval_address (argv
[3]);
1619 /* Get the value into an array. */
1620 buffer
= xmalloc (word_size
);
1621 old_chain
= make_cleanup (xfree
, buffer
);
1622 store_signed_integer (buffer
, word_size
, byte_order
, value
);
1623 /* Write it down to memory. */
1624 write_memory (addr
, buffer
, word_size
);
1625 /* Free the buffer. */
1626 do_cleanups (old_chain
);
1629 /* DATA-MEMORY-WRITE-RAW:
1632 DATA: string of bytes to write at that address. */
1634 mi_cmd_data_write_memory_bytes (char *command
, char **argv
, int argc
)
1640 struct cleanup
*back_to
;
1643 error ("Usage: ADDR DATA.");
1645 addr
= parse_and_eval_address (argv
[0]);
1647 len
= strlen (cdata
)/2;
1649 data
= xmalloc (len
);
1650 back_to
= make_cleanup (xfree
, data
);
1652 for (i
= 0; i
< len
; ++i
)
1655 sscanf (cdata
+ i
* 2, "%02x", &x
);
1656 data
[i
] = (gdb_byte
)x
;
1659 r
= target_write_memory (addr
, data
, len
);
1661 error (_("Could not write memory"));
1663 do_cleanups (back_to
);
1668 mi_cmd_enable_timings (char *command
, char **argv
, int argc
)
1674 if (strcmp (argv
[0], "yes") == 0)
1676 else if (strcmp (argv
[0], "no") == 0)
1687 error ("mi_cmd_enable_timings: Usage: %s {yes|no}", command
);
1691 mi_cmd_list_features (char *command
, char **argv
, int argc
)
1695 struct cleanup
*cleanup
= NULL
;
1697 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "features");
1698 ui_out_field_string (uiout
, NULL
, "frozen-varobjs");
1699 ui_out_field_string (uiout
, NULL
, "pending-breakpoints");
1700 ui_out_field_string (uiout
, NULL
, "thread-info");
1701 ui_out_field_string (uiout
, NULL
, "data-read-memory-bytes");
1704 ui_out_field_string (uiout
, NULL
, "python");
1707 do_cleanups (cleanup
);
1711 error ("-list-features should be passed no arguments");
1715 mi_cmd_list_target_features (char *command
, char **argv
, int argc
)
1719 struct cleanup
*cleanup
= NULL
;
1721 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "features");
1722 if (target_can_async_p ())
1723 ui_out_field_string (uiout
, NULL
, "async");
1724 if (target_can_execute_reverse
)
1725 ui_out_field_string (uiout
, NULL
, "reverse");
1727 do_cleanups (cleanup
);
1731 error ("-list-target-features should be passed no arguments");
1735 mi_cmd_add_inferior (char *command
, char **argv
, int argc
)
1737 struct inferior
*inf
;
1740 error (_("-add-inferior should be passed no arguments"));
1742 inf
= add_inferior_with_spaces ();
1744 ui_out_field_fmt (uiout
, "inferior", "i%d", inf
->num
);
1748 mi_cmd_remove_inferior (char *command
, char **argv
, int argc
)
1751 struct inferior
*inf
;
1754 error ("-remove-inferior should be passed a single argument");
1756 if (sscanf (argv
[0], "i%d", &id
) != 1)
1757 error ("the thread group id is syntactically invalid");
1759 inf
= find_inferior_id (id
);
1761 error ("the specified thread group does not exist");
1763 delete_inferior_1 (inf
, 1 /* silent */);
1768 /* Execute a command within a safe environment.
1769 Return <0 for error; >=0 for ok.
1771 args->action will tell mi_execute_command what action
1772 to perfrom after the given command has executed (display/suppress
1773 prompt, display error). */
1776 captured_mi_execute_command (struct ui_out
*uiout
, void *data
)
1778 struct cleanup
*cleanup
;
1779 struct mi_parse
*context
= (struct mi_parse
*) data
;
1782 current_command_ts
= context
->cmd_start
;
1784 current_token
= xstrdup (context
->token
);
1785 cleanup
= make_cleanup (free_current_contents
, ¤t_token
);
1787 running_result_record_printed
= 0;
1789 switch (context
->op
)
1792 /* A MI command was read from the input stream. */
1794 /* FIXME: gdb_???? */
1795 fprintf_unfiltered (raw_stdout
, " token=`%s' command=`%s' args=`%s'\n",
1796 context
->token
, context
->command
, context
->args
);
1799 mi_cmd_execute (context
);
1801 /* Print the result if there were no errors.
1803 Remember that on the way out of executing a command, you have
1804 to directly use the mi_interp's uiout, since the command could
1805 have reset the interpreter, in which case the current uiout
1806 will most likely crash in the mi_out_* routines. */
1807 if (!running_result_record_printed
)
1809 fputs_unfiltered (context
->token
, raw_stdout
);
1810 /* There's no particularly good reason why target-connect results
1811 in not ^done. Should kill ^connected for MI3. */
1812 fputs_unfiltered (strcmp (context
->command
, "target-select") == 0
1813 ? "^connected" : "^done", raw_stdout
);
1814 mi_out_put (uiout
, raw_stdout
);
1815 mi_out_rewind (uiout
);
1816 mi_print_timing_maybe ();
1817 fputs_unfiltered ("\n", raw_stdout
);
1820 /* The command does not want anything to be printed. In that
1821 case, the command probably should not have written anything
1822 to uiout, but in case it has written something, discard it. */
1823 mi_out_rewind (uiout
);
1830 /* A CLI command was read from the input stream. */
1831 /* This "feature" will be removed as soon as we have a
1832 complete set of mi commands. */
1833 /* Echo the command on the console. */
1834 fprintf_unfiltered (gdb_stdlog
, "%s\n", context
->command
);
1835 /* Call the "console" interpreter. */
1836 argv
[0] = "console";
1837 argv
[1] = context
->command
;
1838 mi_cmd_interpreter_exec ("-interpreter-exec", argv
, 2);
1840 /* If we changed interpreters, DON'T print out anything. */
1841 if (current_interp_named_p (INTERP_MI
)
1842 || current_interp_named_p (INTERP_MI1
)
1843 || current_interp_named_p (INTERP_MI2
)
1844 || current_interp_named_p (INTERP_MI3
))
1846 if (!running_result_record_printed
)
1848 fputs_unfiltered (context
->token
, raw_stdout
);
1849 fputs_unfiltered ("^done", raw_stdout
);
1850 mi_out_put (uiout
, raw_stdout
);
1851 mi_out_rewind (uiout
);
1852 mi_print_timing_maybe ();
1853 fputs_unfiltered ("\n", raw_stdout
);
1856 mi_out_rewind (uiout
);
1863 do_cleanups (cleanup
);
1868 /* Print a gdb exception to the MI output stream. */
1871 mi_print_exception (const char *token
, struct gdb_exception exception
)
1873 fputs_unfiltered (token
, raw_stdout
);
1874 fputs_unfiltered ("^error,msg=\"", raw_stdout
);
1875 if (exception
.message
== NULL
)
1876 fputs_unfiltered ("unknown error", raw_stdout
);
1878 fputstr_unfiltered (exception
.message
, '"', raw_stdout
);
1879 fputs_unfiltered ("\"\n", raw_stdout
);
1883 mi_execute_command (char *cmd
, int from_tty
)
1886 struct mi_parse
*command
= NULL
;
1887 volatile struct gdb_exception exception
;
1889 /* This is to handle EOF (^D). We just quit gdb. */
1890 /* FIXME: we should call some API function here. */
1892 quit_force (NULL
, from_tty
);
1894 target_log_command (cmd
);
1896 TRY_CATCH (exception
, RETURN_MASK_ALL
)
1898 command
= mi_parse (cmd
, &token
);
1900 if (exception
.reason
< 0)
1902 mi_print_exception (token
, exception
);
1907 struct gdb_exception result
;
1908 ptid_t previous_ptid
= inferior_ptid
;
1910 command
->token
= token
;
1914 command
->cmd_start
= (struct mi_timestamp
*)
1915 xmalloc (sizeof (struct mi_timestamp
));
1916 timestamp (command
->cmd_start
);
1919 result
= catch_exception (uiout
, captured_mi_execute_command
, command
,
1921 if (result
.reason
< 0)
1923 /* The command execution failed and error() was called
1925 mi_print_exception (command
->token
, result
);
1926 mi_out_rewind (uiout
);
1929 bpstat_do_actions ();
1931 if (/* The notifications are only output when the top-level
1932 interpreter (specified on the command line) is MI. */
1933 ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ()))
1934 /* Don't try report anything if there are no threads --
1935 the program is dead. */
1936 && thread_count () != 0
1937 /* -thread-select explicitly changes thread. If frontend uses that
1938 internally, we don't want to emit =thread-selected, since
1939 =thread-selected is supposed to indicate user's intentions. */
1940 && strcmp (command
->command
, "thread-select") != 0)
1942 struct mi_interp
*mi
= top_level_interpreter_data ();
1943 int report_change
= 0;
1945 if (command
->thread
== -1)
1947 report_change
= (!ptid_equal (previous_ptid
, null_ptid
)
1948 && !ptid_equal (inferior_ptid
, previous_ptid
)
1949 && !ptid_equal (inferior_ptid
, null_ptid
));
1951 else if (!ptid_equal (inferior_ptid
, null_ptid
))
1953 struct thread_info
*ti
= inferior_thread ();
1955 report_change
= (ti
->num
!= command
->thread
);
1960 struct thread_info
*ti
= inferior_thread ();
1962 target_terminal_ours ();
1963 fprintf_unfiltered (mi
->event_channel
,
1964 "thread-selected,id=\"%d\"",
1966 gdb_flush (mi
->event_channel
);
1970 mi_parse_free (command
);
1973 fputs_unfiltered ("(gdb) \n", raw_stdout
);
1974 gdb_flush (raw_stdout
);
1975 /* Print any buffered hook code. */
1980 mi_cmd_execute (struct mi_parse
*parse
)
1982 struct cleanup
*cleanup
;
1984 prepare_execute_command ();
1986 cleanup
= make_cleanup (null_cleanup
, NULL
);
1988 if (parse
->all
&& parse
->thread_group
!= -1)
1989 error (_("Cannot specify --thread-group together with --all"));
1991 if (parse
->all
&& parse
->thread
!= -1)
1992 error (_("Cannot specify --thread together with --all"));
1994 if (parse
->thread_group
!= -1 && parse
->thread
!= -1)
1995 error (_("Cannot specify --thread together with --thread-group"));
1997 if (parse
->frame
!= -1 && parse
->thread
== -1)
1998 error (_("Cannot specify --frame without --thread"));
2000 if (parse
->thread_group
!= -1)
2002 struct inferior
*inf
= find_inferior_id (parse
->thread_group
);
2003 struct thread_info
*tp
= 0;
2006 error (_("Invalid thread group for the --thread-group option"));
2008 set_current_inferior (inf
);
2009 /* This behaviour means that if --thread-group option identifies
2010 an inferior with multiple threads, then a random one will be picked.
2011 This is not a problem -- frontend should always provide --thread if
2012 it wishes to operate on a specific thread. */
2014 tp
= any_thread_of_process (inf
->pid
);
2015 switch_to_thread (tp
? tp
->ptid
: null_ptid
);
2016 set_current_program_space (inf
->pspace
);
2019 if (parse
->thread
!= -1)
2021 struct thread_info
*tp
= find_thread_id (parse
->thread
);
2024 error (_("Invalid thread id: %d"), parse
->thread
);
2026 if (is_exited (tp
->ptid
))
2027 error (_("Thread id: %d has terminated"), parse
->thread
);
2029 switch_to_thread (tp
->ptid
);
2032 if (parse
->frame
!= -1)
2034 struct frame_info
*fid
;
2035 int frame
= parse
->frame
;
2037 fid
= find_relative_frame (get_current_frame (), &frame
);
2039 /* find_relative_frame was successful */
2042 error (_("Invalid frame id: %d"), frame
);
2045 current_context
= parse
;
2047 if (parse
->cmd
->argv_func
!= NULL
)
2048 parse
->cmd
->argv_func (parse
->command
, parse
->argv
, parse
->argc
);
2049 else if (parse
->cmd
->cli
.cmd
!= 0)
2051 /* FIXME: DELETE THIS. */
2052 /* The operation is still implemented by a cli command. */
2053 /* Must be a synchronous one. */
2054 mi_execute_cli_command (parse
->cmd
->cli
.cmd
, parse
->cmd
->cli
.args_p
,
2059 /* FIXME: DELETE THIS. */
2060 struct ui_file
*stb
;
2062 stb
= mem_fileopen ();
2064 fputs_unfiltered ("Undefined mi command: ", stb
);
2065 fputstr_unfiltered (parse
->command
, '"', stb
);
2066 fputs_unfiltered (" (missing implementation)", stb
);
2068 make_cleanup_ui_file_delete (stb
);
2071 do_cleanups (cleanup
);
2074 /* FIXME: This is just a hack so we can get some extra commands going.
2075 We don't want to channel things through the CLI, but call libgdb directly.
2076 Use only for synchronous commands. */
2079 mi_execute_cli_command (const char *cmd
, int args_p
, const char *args
)
2083 struct cleanup
*old_cleanups
;
2087 run
= xstrprintf ("%s %s", cmd
, args
);
2089 run
= xstrdup (cmd
);
2091 /* FIXME: gdb_???? */
2092 fprintf_unfiltered (gdb_stdout
, "cli=%s run=%s\n",
2094 old_cleanups
= make_cleanup (xfree
, run
);
2095 execute_command ( /*ui */ run
, 0 /*from_tty */ );
2096 do_cleanups (old_cleanups
);
2102 mi_execute_async_cli_command (char *cli_command
, char **argv
, int argc
)
2104 struct cleanup
*old_cleanups
;
2107 if (target_can_async_p ())
2108 run
= xstrprintf ("%s %s&", cli_command
, argc
? *argv
: "");
2110 run
= xstrprintf ("%s %s", cli_command
, argc
? *argv
: "");
2111 old_cleanups
= make_cleanup (xfree
, run
);
2113 execute_command ( /*ui */ run
, 0 /*from_tty */ );
2115 if (target_can_async_p ())
2117 /* If we're not executing, an exception should have been throw. */
2118 gdb_assert (is_running (inferior_ptid
));
2119 do_cleanups (old_cleanups
);
2123 /* Do this before doing any printing. It would appear that some
2124 print code leaves garbage around in the buffer. */
2125 do_cleanups (old_cleanups
);
2130 mi_load_progress (const char *section_name
,
2131 unsigned long sent_so_far
,
2132 unsigned long total_section
,
2133 unsigned long total_sent
,
2134 unsigned long grand_total
)
2136 struct timeval time_now
, delta
, update_threshold
;
2137 static struct timeval last_update
;
2138 static char *previous_sect_name
= NULL
;
2140 struct ui_out
*saved_uiout
;
2142 /* This function is called through deprecated_show_load_progress
2143 which means uiout may not be correct. Fix it for the duration
2144 of this function. */
2145 saved_uiout
= uiout
;
2147 if (current_interp_named_p (INTERP_MI
)
2148 || current_interp_named_p (INTERP_MI2
))
2149 uiout
= mi_out_new (2);
2150 else if (current_interp_named_p (INTERP_MI1
))
2151 uiout
= mi_out_new (1);
2152 else if (current_interp_named_p (INTERP_MI3
))
2153 uiout
= mi_out_new (3);
2157 update_threshold
.tv_sec
= 0;
2158 update_threshold
.tv_usec
= 500000;
2159 gettimeofday (&time_now
, NULL
);
2161 delta
.tv_usec
= time_now
.tv_usec
- last_update
.tv_usec
;
2162 delta
.tv_sec
= time_now
.tv_sec
- last_update
.tv_sec
;
2164 if (delta
.tv_usec
< 0)
2167 delta
.tv_usec
+= 1000000L;
2170 new_section
= (previous_sect_name
?
2171 strcmp (previous_sect_name
, section_name
) : 1);
2174 struct cleanup
*cleanup_tuple
;
2176 xfree (previous_sect_name
);
2177 previous_sect_name
= xstrdup (section_name
);
2180 fputs_unfiltered (current_token
, raw_stdout
);
2181 fputs_unfiltered ("+download", raw_stdout
);
2182 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2183 ui_out_field_string (uiout
, "section", section_name
);
2184 ui_out_field_int (uiout
, "section-size", total_section
);
2185 ui_out_field_int (uiout
, "total-size", grand_total
);
2186 do_cleanups (cleanup_tuple
);
2187 mi_out_put (uiout
, raw_stdout
);
2188 fputs_unfiltered ("\n", raw_stdout
);
2189 gdb_flush (raw_stdout
);
2192 if (delta
.tv_sec
>= update_threshold
.tv_sec
&&
2193 delta
.tv_usec
>= update_threshold
.tv_usec
)
2195 struct cleanup
*cleanup_tuple
;
2197 last_update
.tv_sec
= time_now
.tv_sec
;
2198 last_update
.tv_usec
= time_now
.tv_usec
;
2200 fputs_unfiltered (current_token
, raw_stdout
);
2201 fputs_unfiltered ("+download", raw_stdout
);
2202 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2203 ui_out_field_string (uiout
, "section", section_name
);
2204 ui_out_field_int (uiout
, "section-sent", sent_so_far
);
2205 ui_out_field_int (uiout
, "section-size", total_section
);
2206 ui_out_field_int (uiout
, "total-sent", total_sent
);
2207 ui_out_field_int (uiout
, "total-size", grand_total
);
2208 do_cleanups (cleanup_tuple
);
2209 mi_out_put (uiout
, raw_stdout
);
2210 fputs_unfiltered ("\n", raw_stdout
);
2211 gdb_flush (raw_stdout
);
2215 uiout
= saved_uiout
;
2219 timestamp (struct mi_timestamp
*tv
)
2221 gettimeofday (&tv
->wallclock
, NULL
);
2222 #ifdef HAVE_GETRUSAGE
2223 getrusage (RUSAGE_SELF
, &rusage
);
2224 tv
->utime
.tv_sec
= rusage
.ru_utime
.tv_sec
;
2225 tv
->utime
.tv_usec
= rusage
.ru_utime
.tv_usec
;
2226 tv
->stime
.tv_sec
= rusage
.ru_stime
.tv_sec
;
2227 tv
->stime
.tv_usec
= rusage
.ru_stime
.tv_usec
;
2230 long usec
= get_run_time ();
2232 tv
->utime
.tv_sec
= usec
/1000000L;
2233 tv
->utime
.tv_usec
= usec
- 1000000L*tv
->utime
.tv_sec
;
2234 tv
->stime
.tv_sec
= 0;
2235 tv
->stime
.tv_usec
= 0;
2241 print_diff_now (struct mi_timestamp
*start
)
2243 struct mi_timestamp now
;
2246 print_diff (start
, &now
);
2250 mi_print_timing_maybe (void)
2252 /* If the command is -enable-timing then do_timings may be
2253 true whilst current_command_ts is not initialized. */
2254 if (do_timings
&& current_command_ts
)
2255 print_diff_now (current_command_ts
);
2259 timeval_diff (struct timeval start
, struct timeval end
)
2261 return ((end
.tv_sec
- start
.tv_sec
) * 1000000L)
2262 + (end
.tv_usec
- start
.tv_usec
);
2266 print_diff (struct mi_timestamp
*start
, struct mi_timestamp
*end
)
2270 ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
2271 timeval_diff (start
->wallclock
, end
->wallclock
) / 1000000.0,
2272 timeval_diff (start
->utime
, end
->utime
) / 1000000.0,
2273 timeval_diff (start
->stime
, end
->stime
) / 1000000.0);
2277 mi_cmd_trace_define_variable (char *command
, char **argv
, int argc
)
2279 struct expression
*expr
;
2280 struct cleanup
*back_to
;
2281 LONGEST initval
= 0;
2282 struct trace_state_variable
*tsv
;
2285 if (argc
!= 1 && argc
!= 2)
2286 error (_("Usage: -trace-define-variable VARIABLE [VALUE]"));
2288 expr
= parse_expression (argv
[0]);
2289 back_to
= make_cleanup (xfree
, expr
);
2291 if (expr
->nelts
== 3 && expr
->elts
[0].opcode
== OP_INTERNALVAR
)
2293 struct internalvar
*intvar
= expr
->elts
[1].internalvar
;
2296 name
= internalvar_name (intvar
);
2299 if (!name
|| *name
== '\0')
2300 error (_("Invalid name of trace variable"));
2302 tsv
= find_trace_state_variable (name
);
2304 tsv
= create_trace_state_variable (name
);
2307 initval
= value_as_long (parse_and_eval (argv
[1]));
2309 tsv
->initial_value
= initval
;
2311 do_cleanups (back_to
);
2315 mi_cmd_trace_list_variables (char *command
, char **argv
, int argc
)
2318 error (_("-trace-list-variables: no arguments are allowed"));
2320 tvariables_info_1 ();
2324 mi_cmd_trace_find (char *command
, char **argv
, int argc
)
2329 error (_("trace selection mode is required"));
2333 if (strcmp (mode
, "none") == 0)
2335 tfind_1 (tfind_number
, -1, 0, 0, 0);
2339 if (current_trace_status ()->running
)
2340 error (_("May not look at trace frames while trace is running."));
2342 if (strcmp (mode
, "frame-number") == 0)
2345 error (_("frame number is required"));
2346 tfind_1 (tfind_number
, atoi (argv
[1]), 0, 0, 0);
2348 else if (strcmp (mode
, "tracepoint-number") == 0)
2351 error (_("tracepoint number is required"));
2352 tfind_1 (tfind_tp
, atoi (argv
[1]), 0, 0, 0);
2354 else if (strcmp (mode
, "pc") == 0)
2357 error (_("PC is required"));
2358 tfind_1 (tfind_pc
, 0, parse_and_eval_address (argv
[1]), 0, 0);
2360 else if (strcmp (mode
, "pc-inside-range") == 0)
2363 error (_("Start and end PC are required"));
2364 tfind_1 (tfind_range
, 0, parse_and_eval_address (argv
[1]),
2365 parse_and_eval_address (argv
[2]), 0);
2367 else if (strcmp (mode
, "pc-outside-range") == 0)
2370 error (_("Start and end PC are required"));
2371 tfind_1 (tfind_outside
, 0, parse_and_eval_address (argv
[1]),
2372 parse_and_eval_address (argv
[2]), 0);
2374 else if (strcmp (mode
, "line") == 0)
2376 struct symtabs_and_lines sals
;
2377 struct symtab_and_line sal
;
2378 static CORE_ADDR start_pc
, end_pc
;
2379 struct cleanup
*back_to
;
2382 error (_("Line is required"));
2384 sals
= decode_line_spec (argv
[1], 1);
2385 back_to
= make_cleanup (xfree
, sals
.sals
);
2389 if (sal
.symtab
== 0)
2390 error (_("Could not find the specified line"));
2392 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2393 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, 0);
2395 error (_("Could not find the specified line"));
2397 do_cleanups (back_to
);
2400 error (_("Invalid mode '%s'"), mode
);
2402 if (has_stack_frames () || get_traceframe_number () >= 0)
2404 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
2409 mi_cmd_trace_save (char *command
, char **argv
, int argc
)
2411 int target_saves
= 0;
2414 if (argc
!= 1 && argc
!= 2)
2415 error (_("Usage: -trace-save [-r] filename"));
2420 if (strcmp (argv
[0], "-r") == 0)
2423 error (_("Invalid option: %s"), argv
[0]);
2430 trace_save (filename
, target_saves
);
2435 mi_cmd_trace_start (char *command
, char **argv
, int argc
)
2441 mi_cmd_trace_status (char *command
, char **argv
, int argc
)
2443 trace_status_mi (0);
2447 mi_cmd_trace_stop (char *command
, char **argv
, int argc
)
2450 trace_status_mi (1);