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
);
1747 /* Callback used to find the first inferior other than the
1751 get_other_inferior (struct inferior
*inf
, void *arg
)
1753 if (inf
== current_inferior ())
1760 mi_cmd_remove_inferior (char *command
, char **argv
, int argc
)
1763 struct inferior
*inf
;
1766 error ("-remove-inferior should be passed a single argument");
1768 if (sscanf (argv
[0], "i%d", &id
) != 1)
1769 error ("the thread group id is syntactically invalid");
1771 inf
= find_inferior_id (id
);
1773 error ("the specified thread group does not exist");
1776 error (_("cannot remove an active inferior"));
1778 if (inf
== current_inferior ())
1780 struct thread_info
*tp
= 0;
1781 struct inferior
*new_inferior
1782 = iterate_over_inferiors (get_other_inferior
, NULL
);
1784 if (new_inferior
== NULL
)
1785 error (_("Cannot remove last inferior"));
1787 set_current_inferior (new_inferior
);
1788 if (new_inferior
->pid
!= 0)
1789 tp
= any_thread_of_process (new_inferior
->pid
);
1790 switch_to_thread (tp
? tp
->ptid
: null_ptid
);
1791 set_current_program_space (new_inferior
->pspace
);
1794 delete_inferior_1 (inf
, 1 /* silent */);
1799 /* Execute a command within a safe environment.
1800 Return <0 for error; >=0 for ok.
1802 args->action will tell mi_execute_command what action
1803 to perfrom after the given command has executed (display/suppress
1804 prompt, display error). */
1807 captured_mi_execute_command (struct ui_out
*uiout
, void *data
)
1809 struct cleanup
*cleanup
;
1810 struct mi_parse
*context
= (struct mi_parse
*) data
;
1813 current_command_ts
= context
->cmd_start
;
1815 current_token
= xstrdup (context
->token
);
1816 cleanup
= make_cleanup (free_current_contents
, ¤t_token
);
1818 running_result_record_printed
= 0;
1820 switch (context
->op
)
1823 /* A MI command was read from the input stream. */
1825 /* FIXME: gdb_???? */
1826 fprintf_unfiltered (raw_stdout
, " token=`%s' command=`%s' args=`%s'\n",
1827 context
->token
, context
->command
, context
->args
);
1830 mi_cmd_execute (context
);
1832 /* Print the result if there were no errors.
1834 Remember that on the way out of executing a command, you have
1835 to directly use the mi_interp's uiout, since the command could
1836 have reset the interpreter, in which case the current uiout
1837 will most likely crash in the mi_out_* routines. */
1838 if (!running_result_record_printed
)
1840 fputs_unfiltered (context
->token
, raw_stdout
);
1841 /* There's no particularly good reason why target-connect results
1842 in not ^done. Should kill ^connected for MI3. */
1843 fputs_unfiltered (strcmp (context
->command
, "target-select") == 0
1844 ? "^connected" : "^done", raw_stdout
);
1845 mi_out_put (uiout
, raw_stdout
);
1846 mi_out_rewind (uiout
);
1847 mi_print_timing_maybe ();
1848 fputs_unfiltered ("\n", raw_stdout
);
1851 /* The command does not want anything to be printed. In that
1852 case, the command probably should not have written anything
1853 to uiout, but in case it has written something, discard it. */
1854 mi_out_rewind (uiout
);
1861 /* A CLI command was read from the input stream. */
1862 /* This "feature" will be removed as soon as we have a
1863 complete set of mi commands. */
1864 /* Echo the command on the console. */
1865 fprintf_unfiltered (gdb_stdlog
, "%s\n", context
->command
);
1866 /* Call the "console" interpreter. */
1867 argv
[0] = "console";
1868 argv
[1] = context
->command
;
1869 mi_cmd_interpreter_exec ("-interpreter-exec", argv
, 2);
1871 /* If we changed interpreters, DON'T print out anything. */
1872 if (current_interp_named_p (INTERP_MI
)
1873 || current_interp_named_p (INTERP_MI1
)
1874 || current_interp_named_p (INTERP_MI2
)
1875 || current_interp_named_p (INTERP_MI3
))
1877 if (!running_result_record_printed
)
1879 fputs_unfiltered (context
->token
, raw_stdout
);
1880 fputs_unfiltered ("^done", raw_stdout
);
1881 mi_out_put (uiout
, raw_stdout
);
1882 mi_out_rewind (uiout
);
1883 mi_print_timing_maybe ();
1884 fputs_unfiltered ("\n", raw_stdout
);
1887 mi_out_rewind (uiout
);
1894 do_cleanups (cleanup
);
1899 /* Print a gdb exception to the MI output stream. */
1902 mi_print_exception (const char *token
, struct gdb_exception exception
)
1904 fputs_unfiltered (token
, raw_stdout
);
1905 fputs_unfiltered ("^error,msg=\"", raw_stdout
);
1906 if (exception
.message
== NULL
)
1907 fputs_unfiltered ("unknown error", raw_stdout
);
1909 fputstr_unfiltered (exception
.message
, '"', raw_stdout
);
1910 fputs_unfiltered ("\"\n", raw_stdout
);
1914 mi_execute_command (char *cmd
, int from_tty
)
1917 struct mi_parse
*command
= NULL
;
1918 volatile struct gdb_exception exception
;
1920 /* This is to handle EOF (^D). We just quit gdb. */
1921 /* FIXME: we should call some API function here. */
1923 quit_force (NULL
, from_tty
);
1925 target_log_command (cmd
);
1927 TRY_CATCH (exception
, RETURN_MASK_ALL
)
1929 command
= mi_parse (cmd
, &token
);
1931 if (exception
.reason
< 0)
1933 mi_print_exception (token
, exception
);
1938 struct gdb_exception result
;
1939 ptid_t previous_ptid
= inferior_ptid
;
1941 command
->token
= token
;
1945 command
->cmd_start
= (struct mi_timestamp
*)
1946 xmalloc (sizeof (struct mi_timestamp
));
1947 timestamp (command
->cmd_start
);
1950 result
= catch_exception (uiout
, captured_mi_execute_command
, command
,
1952 if (result
.reason
< 0)
1954 /* The command execution failed and error() was called
1956 mi_print_exception (command
->token
, result
);
1957 mi_out_rewind (uiout
);
1960 bpstat_do_actions ();
1962 if (/* The notifications are only output when the top-level
1963 interpreter (specified on the command line) is MI. */
1964 ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ()))
1965 /* Don't try report anything if there are no threads --
1966 the program is dead. */
1967 && thread_count () != 0
1968 /* -thread-select explicitly changes thread. If frontend uses that
1969 internally, we don't want to emit =thread-selected, since
1970 =thread-selected is supposed to indicate user's intentions. */
1971 && strcmp (command
->command
, "thread-select") != 0)
1973 struct mi_interp
*mi
= top_level_interpreter_data ();
1974 int report_change
= 0;
1976 if (command
->thread
== -1)
1978 report_change
= (!ptid_equal (previous_ptid
, null_ptid
)
1979 && !ptid_equal (inferior_ptid
, previous_ptid
)
1980 && !ptid_equal (inferior_ptid
, null_ptid
));
1982 else if (!ptid_equal (inferior_ptid
, null_ptid
))
1984 struct thread_info
*ti
= inferior_thread ();
1986 report_change
= (ti
->num
!= command
->thread
);
1991 struct thread_info
*ti
= inferior_thread ();
1993 target_terminal_ours ();
1994 fprintf_unfiltered (mi
->event_channel
,
1995 "thread-selected,id=\"%d\"",
1997 gdb_flush (mi
->event_channel
);
2001 mi_parse_free (command
);
2004 fputs_unfiltered ("(gdb) \n", raw_stdout
);
2005 gdb_flush (raw_stdout
);
2006 /* Print any buffered hook code. */
2011 mi_cmd_execute (struct mi_parse
*parse
)
2013 struct cleanup
*cleanup
;
2015 prepare_execute_command ();
2017 cleanup
= make_cleanup (null_cleanup
, NULL
);
2019 if (parse
->all
&& parse
->thread_group
!= -1)
2020 error (_("Cannot specify --thread-group together with --all"));
2022 if (parse
->all
&& parse
->thread
!= -1)
2023 error (_("Cannot specify --thread together with --all"));
2025 if (parse
->thread_group
!= -1 && parse
->thread
!= -1)
2026 error (_("Cannot specify --thread together with --thread-group"));
2028 if (parse
->frame
!= -1 && parse
->thread
== -1)
2029 error (_("Cannot specify --frame without --thread"));
2031 if (parse
->thread_group
!= -1)
2033 struct inferior
*inf
= find_inferior_id (parse
->thread_group
);
2034 struct thread_info
*tp
= 0;
2037 error (_("Invalid thread group for the --thread-group option"));
2039 set_current_inferior (inf
);
2040 /* This behaviour means that if --thread-group option identifies
2041 an inferior with multiple threads, then a random one will be picked.
2042 This is not a problem -- frontend should always provide --thread if
2043 it wishes to operate on a specific thread. */
2045 tp
= any_thread_of_process (inf
->pid
);
2046 switch_to_thread (tp
? tp
->ptid
: null_ptid
);
2047 set_current_program_space (inf
->pspace
);
2050 if (parse
->thread
!= -1)
2052 struct thread_info
*tp
= find_thread_id (parse
->thread
);
2055 error (_("Invalid thread id: %d"), parse
->thread
);
2057 if (is_exited (tp
->ptid
))
2058 error (_("Thread id: %d has terminated"), parse
->thread
);
2060 switch_to_thread (tp
->ptid
);
2063 if (parse
->frame
!= -1)
2065 struct frame_info
*fid
;
2066 int frame
= parse
->frame
;
2068 fid
= find_relative_frame (get_current_frame (), &frame
);
2070 /* find_relative_frame was successful */
2073 error (_("Invalid frame id: %d"), frame
);
2076 current_context
= parse
;
2078 if (parse
->cmd
->argv_func
!= NULL
)
2079 parse
->cmd
->argv_func (parse
->command
, parse
->argv
, parse
->argc
);
2080 else if (parse
->cmd
->cli
.cmd
!= 0)
2082 /* FIXME: DELETE THIS. */
2083 /* The operation is still implemented by a cli command. */
2084 /* Must be a synchronous one. */
2085 mi_execute_cli_command (parse
->cmd
->cli
.cmd
, parse
->cmd
->cli
.args_p
,
2090 /* FIXME: DELETE THIS. */
2091 struct ui_file
*stb
;
2093 stb
= mem_fileopen ();
2095 fputs_unfiltered ("Undefined mi command: ", stb
);
2096 fputstr_unfiltered (parse
->command
, '"', stb
);
2097 fputs_unfiltered (" (missing implementation)", stb
);
2099 make_cleanup_ui_file_delete (stb
);
2102 do_cleanups (cleanup
);
2105 /* FIXME: This is just a hack so we can get some extra commands going.
2106 We don't want to channel things through the CLI, but call libgdb directly.
2107 Use only for synchronous commands. */
2110 mi_execute_cli_command (const char *cmd
, int args_p
, const char *args
)
2114 struct cleanup
*old_cleanups
;
2118 run
= xstrprintf ("%s %s", cmd
, args
);
2120 run
= xstrdup (cmd
);
2122 /* FIXME: gdb_???? */
2123 fprintf_unfiltered (gdb_stdout
, "cli=%s run=%s\n",
2125 old_cleanups
= make_cleanup (xfree
, run
);
2126 execute_command ( /*ui */ run
, 0 /*from_tty */ );
2127 do_cleanups (old_cleanups
);
2133 mi_execute_async_cli_command (char *cli_command
, char **argv
, int argc
)
2135 struct cleanup
*old_cleanups
;
2138 if (target_can_async_p ())
2139 run
= xstrprintf ("%s %s&", cli_command
, argc
? *argv
: "");
2141 run
= xstrprintf ("%s %s", cli_command
, argc
? *argv
: "");
2142 old_cleanups
= make_cleanup (xfree
, run
);
2144 execute_command ( /*ui */ run
, 0 /*from_tty */ );
2146 if (target_can_async_p ())
2148 /* If we're not executing, an exception should have been throw. */
2149 gdb_assert (is_running (inferior_ptid
));
2150 do_cleanups (old_cleanups
);
2154 /* Do this before doing any printing. It would appear that some
2155 print code leaves garbage around in the buffer. */
2156 do_cleanups (old_cleanups
);
2161 mi_load_progress (const char *section_name
,
2162 unsigned long sent_so_far
,
2163 unsigned long total_section
,
2164 unsigned long total_sent
,
2165 unsigned long grand_total
)
2167 struct timeval time_now
, delta
, update_threshold
;
2168 static struct timeval last_update
;
2169 static char *previous_sect_name
= NULL
;
2171 struct ui_out
*saved_uiout
;
2173 /* This function is called through deprecated_show_load_progress
2174 which means uiout may not be correct. Fix it for the duration
2175 of this function. */
2176 saved_uiout
= uiout
;
2178 if (current_interp_named_p (INTERP_MI
)
2179 || current_interp_named_p (INTERP_MI2
))
2180 uiout
= mi_out_new (2);
2181 else if (current_interp_named_p (INTERP_MI1
))
2182 uiout
= mi_out_new (1);
2183 else if (current_interp_named_p (INTERP_MI3
))
2184 uiout
= mi_out_new (3);
2188 update_threshold
.tv_sec
= 0;
2189 update_threshold
.tv_usec
= 500000;
2190 gettimeofday (&time_now
, NULL
);
2192 delta
.tv_usec
= time_now
.tv_usec
- last_update
.tv_usec
;
2193 delta
.tv_sec
= time_now
.tv_sec
- last_update
.tv_sec
;
2195 if (delta
.tv_usec
< 0)
2198 delta
.tv_usec
+= 1000000L;
2201 new_section
= (previous_sect_name
?
2202 strcmp (previous_sect_name
, section_name
) : 1);
2205 struct cleanup
*cleanup_tuple
;
2207 xfree (previous_sect_name
);
2208 previous_sect_name
= xstrdup (section_name
);
2211 fputs_unfiltered (current_token
, raw_stdout
);
2212 fputs_unfiltered ("+download", raw_stdout
);
2213 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2214 ui_out_field_string (uiout
, "section", section_name
);
2215 ui_out_field_int (uiout
, "section-size", total_section
);
2216 ui_out_field_int (uiout
, "total-size", grand_total
);
2217 do_cleanups (cleanup_tuple
);
2218 mi_out_put (uiout
, raw_stdout
);
2219 fputs_unfiltered ("\n", raw_stdout
);
2220 gdb_flush (raw_stdout
);
2223 if (delta
.tv_sec
>= update_threshold
.tv_sec
&&
2224 delta
.tv_usec
>= update_threshold
.tv_usec
)
2226 struct cleanup
*cleanup_tuple
;
2228 last_update
.tv_sec
= time_now
.tv_sec
;
2229 last_update
.tv_usec
= time_now
.tv_usec
;
2231 fputs_unfiltered (current_token
, raw_stdout
);
2232 fputs_unfiltered ("+download", raw_stdout
);
2233 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2234 ui_out_field_string (uiout
, "section", section_name
);
2235 ui_out_field_int (uiout
, "section-sent", sent_so_far
);
2236 ui_out_field_int (uiout
, "section-size", total_section
);
2237 ui_out_field_int (uiout
, "total-sent", total_sent
);
2238 ui_out_field_int (uiout
, "total-size", grand_total
);
2239 do_cleanups (cleanup_tuple
);
2240 mi_out_put (uiout
, raw_stdout
);
2241 fputs_unfiltered ("\n", raw_stdout
);
2242 gdb_flush (raw_stdout
);
2246 uiout
= saved_uiout
;
2250 timestamp (struct mi_timestamp
*tv
)
2252 gettimeofday (&tv
->wallclock
, NULL
);
2253 #ifdef HAVE_GETRUSAGE
2254 getrusage (RUSAGE_SELF
, &rusage
);
2255 tv
->utime
.tv_sec
= rusage
.ru_utime
.tv_sec
;
2256 tv
->utime
.tv_usec
= rusage
.ru_utime
.tv_usec
;
2257 tv
->stime
.tv_sec
= rusage
.ru_stime
.tv_sec
;
2258 tv
->stime
.tv_usec
= rusage
.ru_stime
.tv_usec
;
2261 long usec
= get_run_time ();
2263 tv
->utime
.tv_sec
= usec
/1000000L;
2264 tv
->utime
.tv_usec
= usec
- 1000000L*tv
->utime
.tv_sec
;
2265 tv
->stime
.tv_sec
= 0;
2266 tv
->stime
.tv_usec
= 0;
2272 print_diff_now (struct mi_timestamp
*start
)
2274 struct mi_timestamp now
;
2277 print_diff (start
, &now
);
2281 mi_print_timing_maybe (void)
2283 /* If the command is -enable-timing then do_timings may be
2284 true whilst current_command_ts is not initialized. */
2285 if (do_timings
&& current_command_ts
)
2286 print_diff_now (current_command_ts
);
2290 timeval_diff (struct timeval start
, struct timeval end
)
2292 return ((end
.tv_sec
- start
.tv_sec
) * 1000000L)
2293 + (end
.tv_usec
- start
.tv_usec
);
2297 print_diff (struct mi_timestamp
*start
, struct mi_timestamp
*end
)
2301 ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
2302 timeval_diff (start
->wallclock
, end
->wallclock
) / 1000000.0,
2303 timeval_diff (start
->utime
, end
->utime
) / 1000000.0,
2304 timeval_diff (start
->stime
, end
->stime
) / 1000000.0);
2308 mi_cmd_trace_define_variable (char *command
, char **argv
, int argc
)
2310 struct expression
*expr
;
2311 struct cleanup
*back_to
;
2312 LONGEST initval
= 0;
2313 struct trace_state_variable
*tsv
;
2316 if (argc
!= 1 && argc
!= 2)
2317 error (_("Usage: -trace-define-variable VARIABLE [VALUE]"));
2319 expr
= parse_expression (argv
[0]);
2320 back_to
= make_cleanup (xfree
, expr
);
2322 if (expr
->nelts
== 3 && expr
->elts
[0].opcode
== OP_INTERNALVAR
)
2324 struct internalvar
*intvar
= expr
->elts
[1].internalvar
;
2327 name
= internalvar_name (intvar
);
2330 if (!name
|| *name
== '\0')
2331 error (_("Invalid name of trace variable"));
2333 tsv
= find_trace_state_variable (name
);
2335 tsv
= create_trace_state_variable (name
);
2338 initval
= value_as_long (parse_and_eval (argv
[1]));
2340 tsv
->initial_value
= initval
;
2342 do_cleanups (back_to
);
2346 mi_cmd_trace_list_variables (char *command
, char **argv
, int argc
)
2349 error (_("-trace-list-variables: no arguments are allowed"));
2351 tvariables_info_1 ();
2355 mi_cmd_trace_find (char *command
, char **argv
, int argc
)
2360 error (_("trace selection mode is required"));
2364 if (strcmp (mode
, "none") == 0)
2366 tfind_1 (tfind_number
, -1, 0, 0, 0);
2370 if (current_trace_status ()->running
)
2371 error (_("May not look at trace frames while trace is running."));
2373 if (strcmp (mode
, "frame-number") == 0)
2376 error (_("frame number is required"));
2377 tfind_1 (tfind_number
, atoi (argv
[1]), 0, 0, 0);
2379 else if (strcmp (mode
, "tracepoint-number") == 0)
2382 error (_("tracepoint number is required"));
2383 tfind_1 (tfind_tp
, atoi (argv
[1]), 0, 0, 0);
2385 else if (strcmp (mode
, "pc") == 0)
2388 error (_("PC is required"));
2389 tfind_1 (tfind_pc
, 0, parse_and_eval_address (argv
[1]), 0, 0);
2391 else if (strcmp (mode
, "pc-inside-range") == 0)
2394 error (_("Start and end PC are required"));
2395 tfind_1 (tfind_range
, 0, parse_and_eval_address (argv
[1]),
2396 parse_and_eval_address (argv
[2]), 0);
2398 else if (strcmp (mode
, "pc-outside-range") == 0)
2401 error (_("Start and end PC are required"));
2402 tfind_1 (tfind_outside
, 0, parse_and_eval_address (argv
[1]),
2403 parse_and_eval_address (argv
[2]), 0);
2405 else if (strcmp (mode
, "line") == 0)
2407 struct symtabs_and_lines sals
;
2408 struct symtab_and_line sal
;
2409 static CORE_ADDR start_pc
, end_pc
;
2410 struct cleanup
*back_to
;
2413 error (_("Line is required"));
2415 sals
= decode_line_spec (argv
[1], 1);
2416 back_to
= make_cleanup (xfree
, sals
.sals
);
2420 if (sal
.symtab
== 0)
2421 error (_("Could not find the specified line"));
2423 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2424 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, 0);
2426 error (_("Could not find the specified line"));
2428 do_cleanups (back_to
);
2431 error (_("Invalid mode '%s'"), mode
);
2433 if (has_stack_frames () || get_traceframe_number () >= 0)
2435 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
2440 mi_cmd_trace_save (char *command
, char **argv
, int argc
)
2442 int target_saves
= 0;
2445 if (argc
!= 1 && argc
!= 2)
2446 error (_("Usage: -trace-save [-r] filename"));
2451 if (strcmp (argv
[0], "-r") == 0)
2454 error (_("Invalid option: %s"), argv
[0]);
2461 trace_save (filename
, target_saves
);
2466 mi_cmd_trace_start (char *command
, char **argv
, int argc
)
2472 mi_cmd_trace_status (char *command
, char **argv
, int argc
)
2474 trace_status_mi (0);
2478 mi_cmd_trace_stop (char *command
, char **argv
, int argc
)
2481 trace_status_mi (1);