3 Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010,
4 2011 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
)
244 = find_inferior_id (current_context
->thread_group
);
248 iterate_over_threads (proceed_thread_callback
, &pid
);
249 do_cleanups (back_to
);
258 struct cleanup
*back_to
= make_cleanup_restore_integer (&sched_multi
);
260 if (current_context
->all
)
267 /* In all-stop mode, -exec-continue traditionally resumed either
268 all threads, or one thread, depending on the 'scheduler-locking'
269 variable. Let's continue to do the same. */
272 do_cleanups (back_to
);
277 exec_direction_forward (void *notused
)
279 execution_direction
= EXEC_FORWARD
;
283 exec_reverse_continue (char **argv
, int argc
)
285 enum exec_direction_kind dir
= execution_direction
;
286 struct cleanup
*old_chain
;
288 if (dir
== EXEC_ERROR
)
289 error (_("Target %s does not support this command."), target_shortname
);
291 if (dir
== EXEC_REVERSE
)
292 error (_("Already in reverse mode."));
294 if (!target_can_execute_reverse
)
295 error (_("Target %s does not support this command."), target_shortname
);
297 old_chain
= make_cleanup (exec_direction_forward
, NULL
);
298 execution_direction
= EXEC_REVERSE
;
299 exec_continue (argv
, argc
);
300 do_cleanups (old_chain
);
304 mi_cmd_exec_continue (char *command
, char **argv
, int argc
)
306 if (argc
> 0 && strcmp (argv
[0], "--reverse") == 0)
307 exec_reverse_continue (argv
+ 1, argc
- 1);
309 exec_continue (argv
, argc
);
313 interrupt_thread_callback (struct thread_info
*thread
, void *arg
)
315 int pid
= *(int *)arg
;
317 if (!is_running (thread
->ptid
))
320 if (PIDGET (thread
->ptid
) != pid
)
323 target_stop (thread
->ptid
);
327 /* Interrupt the execution of the target. Note how we must play around
328 with the token variables, in order to display the current token in
329 the result of the interrupt command, and the previous execution
330 token when the target finally stops. See comments in
333 mi_cmd_exec_interrupt (char *command
, char **argv
, int argc
)
335 /* In all-stop mode, everything stops, so we don't need to try
336 anything specific. */
339 interrupt_target_1 (0);
343 if (current_context
->all
)
345 /* This will interrupt all threads in all inferiors. */
346 interrupt_target_1 (1);
348 else if (current_context
->thread_group
!= -1)
350 struct inferior
*inf
= find_inferior_id (current_context
->thread_group
);
352 iterate_over_threads (interrupt_thread_callback
, &inf
->pid
);
356 /* Interrupt just the current thread -- either explicitly
357 specified via --thread or whatever was current before
358 MI command was sent. */
359 interrupt_target_1 (0);
364 run_one_inferior (struct inferior
*inf
, void *arg
)
368 if (inf
->pid
!= ptid_get_pid (inferior_ptid
))
370 struct thread_info
*tp
;
372 tp
= any_thread_of_process (inf
->pid
);
374 error (_("Inferior has no threads."));
376 switch_to_thread (tp
->ptid
);
381 set_current_inferior (inf
);
382 switch_to_thread (null_ptid
);
383 set_current_program_space (inf
->pspace
);
385 mi_execute_cli_command ("run", target_can_async_p (),
386 target_can_async_p () ? "&" : NULL
);
391 mi_cmd_exec_run (char *command
, char **argv
, int argc
)
393 if (current_context
->all
)
395 struct cleanup
*back_to
= save_current_space_and_thread ();
397 iterate_over_inferiors (run_one_inferior
, NULL
);
398 do_cleanups (back_to
);
402 mi_execute_cli_command ("run", target_can_async_p (),
403 target_can_async_p () ? "&" : NULL
);
409 find_thread_of_process (struct thread_info
*ti
, void *p
)
413 if (PIDGET (ti
->ptid
) == pid
&& !is_exited (ti
->ptid
))
420 mi_cmd_target_detach (char *command
, char **argv
, int argc
)
422 if (argc
!= 0 && argc
!= 1)
423 error (_("Usage: -target-detach [pid | thread-group]"));
427 struct thread_info
*tp
;
431 /* First see if we are dealing with a thread-group id. */
434 struct inferior
*inf
;
435 int id
= strtoul (argv
[0] + 1, &end
, 0);
438 error (_("Invalid syntax of thread-group id '%s'"), argv
[0]);
440 inf
= find_inferior_id (id
);
442 error (_("Non-existent thread-group id '%d'"), id
);
448 /* We must be dealing with a pid. */
449 pid
= strtol (argv
[0], &end
, 10);
452 error (_("Invalid identifier '%s'"), argv
[0]);
455 /* Pick any thread in the desired process. Current
456 target_detach detaches from the parent of inferior_ptid. */
457 tp
= iterate_over_threads (find_thread_of_process
, &pid
);
459 error (_("Thread group is empty"));
461 switch_to_thread (tp
->ptid
);
464 detach_command (NULL
, 0);
468 mi_cmd_thread_select (char *command
, char **argv
, int argc
)
471 char *mi_error_message
;
474 error (_("-thread-select: USAGE: threadnum."));
476 rc
= gdb_thread_select (uiout
, argv
[0], &mi_error_message
);
478 if (rc
== GDB_RC_FAIL
)
480 make_cleanup (xfree
, mi_error_message
);
481 error ("%s", mi_error_message
);
486 mi_cmd_thread_list_ids (char *command
, char **argv
, int argc
)
489 char *mi_error_message
;
492 error ("-thread-list-ids: No arguments required.");
494 rc
= gdb_list_thread_ids (uiout
, &mi_error_message
);
496 if (rc
== GDB_RC_FAIL
)
498 make_cleanup (xfree
, mi_error_message
);
499 error ("%s", mi_error_message
);
504 mi_cmd_thread_info (char *command
, char **argv
, int argc
)
506 if (argc
!= 0 && argc
!= 1)
507 error ("Invalid MI command");
509 print_thread_info (uiout
, argv
[0], -1);
512 struct collect_cores_data
520 collect_cores (struct thread_info
*ti
, void *xdata
)
522 struct collect_cores_data
*data
= xdata
;
524 if (ptid_get_pid (ti
->ptid
) == data
->pid
)
526 int core
= target_core_of_thread (ti
->ptid
);
529 VEC_safe_push (int, data
->cores
, core
);
536 unique (int *b
, int *e
)
546 struct print_one_inferior_data
549 VEC (int) *inferiors
;
553 print_one_inferior (struct inferior
*inferior
, void *xdata
)
555 struct print_one_inferior_data
*top_data
= xdata
;
557 if (VEC_empty (int, top_data
->inferiors
)
558 || bsearch (&(inferior
->pid
), VEC_address (int, top_data
->inferiors
),
559 VEC_length (int, top_data
->inferiors
), sizeof (int),
560 compare_positive_ints
))
562 struct collect_cores_data data
;
563 struct cleanup
*back_to
564 = make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
566 ui_out_field_fmt (uiout
, "id", "i%d", inferior
->num
);
567 ui_out_field_string (uiout
, "type", "process");
568 if (inferior
->pid
!= 0)
569 ui_out_field_int (uiout
, "pid", inferior
->pid
);
571 if (inferior
->pspace
->ebfd
)
573 ui_out_field_string (uiout
, "executable",
574 bfd_get_filename (inferior
->pspace
->ebfd
));
578 if (inferior
->pid
!= 0)
580 data
.pid
= inferior
->pid
;
581 iterate_over_threads (collect_cores
, &data
);
584 if (!VEC_empty (int, data
.cores
))
587 struct cleanup
*back_to_2
=
588 make_cleanup_ui_out_list_begin_end (uiout
, "cores");
590 qsort (VEC_address (int, data
.cores
),
591 VEC_length (int, data
.cores
), sizeof (int),
592 compare_positive_ints
);
594 b
= VEC_address (int, data
.cores
);
595 e
= b
+ VEC_length (int, data
.cores
);
599 ui_out_field_int (uiout
, NULL
, *b
);
601 do_cleanups (back_to_2
);
604 if (top_data
->recurse
)
605 print_thread_info (uiout
, NULL
, inferior
->pid
);
607 do_cleanups (back_to
);
613 /* Output a field named 'cores' with a list as the value. The elements of
614 the list are obtained by splitting 'cores' on comma. */
617 output_cores (struct ui_out
*uiout
, const char *field_name
, const char *xcores
)
619 struct cleanup
*back_to
= make_cleanup_ui_out_list_begin_end (uiout
,
621 char *cores
= xstrdup (xcores
);
624 make_cleanup (xfree
, cores
);
626 for (p
= strtok (p
, ","); p
; p
= strtok (NULL
, ","))
627 ui_out_field_string (uiout
, NULL
, p
);
629 do_cleanups (back_to
);
633 free_vector_of_ints (void *xvector
)
635 VEC (int) **vector
= xvector
;
637 VEC_free (int, *vector
);
641 do_nothing (splay_tree_key k
)
646 free_vector_of_osdata_items (splay_tree_value xvalue
)
648 VEC (osdata_item_s
) *value
= (VEC (osdata_item_s
) *) xvalue
;
650 /* We don't free the items itself, it will be done separately. */
651 VEC_free (osdata_item_s
, value
);
655 splay_tree_int_comparator (splay_tree_key xa
, splay_tree_key xb
)
664 free_splay_tree (void *xt
)
667 splay_tree_delete (t
);
671 list_available_thread_groups (VEC (int) *ids
, int recurse
)
674 struct osdata_item
*item
;
677 /* This keeps a map from integer (pid) to VEC (struct osdata_item *)*
678 The vector contains information about all threads for the given pid.
679 This is assigned an initial value to avoid "may be used uninitialized"
681 splay_tree tree
= NULL
;
683 /* get_osdata will throw if it cannot return data. */
684 data
= get_osdata ("processes");
685 make_cleanup_osdata_free (data
);
689 struct osdata
*threads
= get_osdata ("threads");
691 make_cleanup_osdata_free (threads
);
692 tree
= splay_tree_new (splay_tree_int_comparator
,
694 free_vector_of_osdata_items
);
695 make_cleanup (free_splay_tree
, tree
);
698 VEC_iterate (osdata_item_s
, threads
->items
,
702 const char *pid
= get_osdata_column (item
, "pid");
703 int pid_i
= strtoul (pid
, NULL
, 0);
704 VEC (osdata_item_s
) *vec
= 0;
706 splay_tree_node n
= splay_tree_lookup (tree
, pid_i
);
709 VEC_safe_push (osdata_item_s
, vec
, item
);
710 splay_tree_insert (tree
, pid_i
, (splay_tree_value
)vec
);
714 vec
= (VEC (osdata_item_s
) *) n
->value
;
715 VEC_safe_push (osdata_item_s
, vec
, item
);
716 n
->value
= (splay_tree_value
) vec
;
721 make_cleanup_ui_out_list_begin_end (uiout
, "groups");
724 VEC_iterate (osdata_item_s
, data
->items
,
728 struct cleanup
*back_to
;
730 const char *pid
= get_osdata_column (item
, "pid");
731 const char *cmd
= get_osdata_column (item
, "command");
732 const char *user
= get_osdata_column (item
, "user");
733 const char *cores
= get_osdata_column (item
, "cores");
735 int pid_i
= strtoul (pid
, NULL
, 0);
737 /* At present, the target will return all available processes
738 and if information about specific ones was required, we filter
739 undesired processes here. */
740 if (ids
&& bsearch (&pid_i
, VEC_address (int, ids
),
741 VEC_length (int, ids
),
742 sizeof (int), compare_positive_ints
) == NULL
)
746 back_to
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
748 ui_out_field_fmt (uiout
, "id", "%s", pid
);
749 ui_out_field_string (uiout
, "type", "process");
751 ui_out_field_string (uiout
, "description", cmd
);
753 ui_out_field_string (uiout
, "user", user
);
755 output_cores (uiout
, "cores", cores
);
759 splay_tree_node n
= splay_tree_lookup (tree
, pid_i
);
762 VEC (osdata_item_s
) *children
= (VEC (osdata_item_s
) *) n
->value
;
763 struct osdata_item
*child
;
766 make_cleanup_ui_out_list_begin_end (uiout
, "threads");
769 VEC_iterate (osdata_item_s
, children
, ix_child
, child
);
772 struct cleanup
*back_to_2
=
773 make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
774 const char *tid
= get_osdata_column (child
, "tid");
775 const char *tcore
= get_osdata_column (child
, "core");
777 ui_out_field_string (uiout
, "id", tid
);
779 ui_out_field_string (uiout
, "core", tcore
);
781 do_cleanups (back_to_2
);
786 do_cleanups (back_to
);
791 mi_cmd_list_thread_groups (char *command
, char **argv
, int argc
)
793 struct cleanup
*back_to
;
800 AVAILABLE_OPT
, RECURSE_OPT
802 static struct mi_opt opts
[] =
804 {"-available", AVAILABLE_OPT
, 0},
805 {"-recurse", RECURSE_OPT
, 1},
814 int opt
= mi_getopt ("-list-thread-groups", argc
, argv
, opts
,
819 switch ((enum opt
) opt
)
825 if (strcmp (optarg
, "0") == 0)
827 else if (strcmp (optarg
, "1") == 0)
830 error ("only '0' and '1' are valid values "
831 "for the '--recurse' option");
836 for (; optind
< argc
; ++optind
)
841 if (*(argv
[optind
]) != 'i')
842 error ("invalid syntax of group id '%s'", argv
[optind
]);
844 inf
= strtoul (argv
[optind
] + 1, &end
, 0);
847 error ("invalid syntax of group id '%s'", argv
[optind
]);
848 VEC_safe_push (int, ids
, inf
);
850 if (VEC_length (int, ids
) > 1)
851 qsort (VEC_address (int, ids
),
852 VEC_length (int, ids
),
853 sizeof (int), compare_positive_ints
);
855 back_to
= make_cleanup (free_vector_of_ints
, &ids
);
859 list_available_thread_groups (ids
, recurse
);
861 else if (VEC_length (int, ids
) == 1)
863 /* Local thread groups, single id. */
864 int id
= *VEC_address (int, ids
);
865 struct inferior
*inf
= find_inferior_id (id
);
868 error ("Non-existent thread group id '%d'", id
);
870 print_thread_info (uiout
, NULL
, inf
->pid
);
874 struct print_one_inferior_data data
;
876 data
.recurse
= recurse
;
877 data
.inferiors
= ids
;
879 /* Local thread groups. Either no explicit ids -- and we
880 print everything, or several explicit ids. In both cases,
881 we print more than one group, and have to use 'groups'
882 as the top-level element. */
883 make_cleanup_ui_out_list_begin_end (uiout
, "groups");
884 update_thread_list ();
885 iterate_over_inferiors (print_one_inferior
, &data
);
888 do_cleanups (back_to
);
892 mi_cmd_data_list_register_names (char *command
, char **argv
, int argc
)
894 struct gdbarch
*gdbarch
;
897 struct cleanup
*cleanup
;
899 /* Note that the test for a valid register must include checking the
900 gdbarch_register_name because gdbarch_num_regs may be allocated for
901 the union of the register sets within a family of related processors.
902 In this case, some entries of gdbarch_register_name will change depending
903 upon the particular processor being debugged. */
905 gdbarch
= get_current_arch ();
906 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
908 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "register-names");
910 if (argc
== 0) /* No args, just do all the regs. */
916 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
917 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
918 ui_out_field_string (uiout
, NULL
, "");
920 ui_out_field_string (uiout
, NULL
,
921 gdbarch_register_name (gdbarch
, regnum
));
925 /* Else, list of register #s, just do listed regs. */
926 for (i
= 0; i
< argc
; i
++)
928 regnum
= atoi (argv
[i
]);
929 if (regnum
< 0 || regnum
>= numregs
)
930 error ("bad register number");
932 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
933 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
934 ui_out_field_string (uiout
, NULL
, "");
936 ui_out_field_string (uiout
, NULL
,
937 gdbarch_register_name (gdbarch
, regnum
));
939 do_cleanups (cleanup
);
943 mi_cmd_data_list_changed_registers (char *command
, char **argv
, int argc
)
945 static struct regcache
*this_regs
= NULL
;
946 struct regcache
*prev_regs
;
947 struct gdbarch
*gdbarch
;
948 int regnum
, numregs
, changed
;
950 struct cleanup
*cleanup
;
952 /* The last time we visited this function, the current frame's register
953 contents were saved in THIS_REGS. Move THIS_REGS over to PREV_REGS,
954 and refresh THIS_REGS with the now-current register contents. */
956 prev_regs
= this_regs
;
957 this_regs
= frame_save_as_regcache (get_selected_frame (NULL
));
958 cleanup
= make_cleanup_regcache_xfree (prev_regs
);
960 /* Note that the test for a valid register must include checking the
961 gdbarch_register_name because gdbarch_num_regs may be allocated for
962 the union of the register sets within a family of related processors.
963 In this case, some entries of gdbarch_register_name will change depending
964 upon the particular processor being debugged. */
966 gdbarch
= get_regcache_arch (this_regs
);
967 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
969 make_cleanup_ui_out_list_begin_end (uiout
, "changed-registers");
971 if (argc
== 0) /* No args, just do all the regs. */
977 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
978 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
980 changed
= register_changed_p (regnum
, prev_regs
, this_regs
);
982 error ("-data-list-changed-registers: "
983 "Unable to read register contents.");
985 ui_out_field_int (uiout
, NULL
, regnum
);
989 /* Else, list of register #s, just do listed regs. */
990 for (i
= 0; i
< argc
; i
++)
992 regnum
= atoi (argv
[i
]);
996 && gdbarch_register_name (gdbarch
, regnum
) != NULL
997 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
999 changed
= register_changed_p (regnum
, prev_regs
, this_regs
);
1001 error ("-data-list-changed-registers: "
1002 "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_register_status (this_regs
, regnum
) == REG_UNKNOWN
)
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_register_status (prev_regs
, regnum
) == REG_UNKNOWN
)
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 ("-data-list-register-values: Usage: "
1062 "-data-list-register-values <format> [<regnum1>...<regnumN>]");
1064 format
= (int) argv
[0][0];
1066 frame
= get_selected_frame (NULL
);
1067 gdbarch
= get_frame_arch (frame
);
1068 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1070 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "register-values");
1072 if (argc
== 1) /* No args, beside the format: do all the regs. */
1078 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1079 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1081 tuple_cleanup
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1082 ui_out_field_int (uiout
, "number", regnum
);
1083 get_register (frame
, regnum
, format
);
1084 do_cleanups (tuple_cleanup
);
1088 /* Else, list of register #s, just do listed regs. */
1089 for (i
= 1; i
< argc
; i
++)
1091 regnum
= atoi (argv
[i
]);
1095 && gdbarch_register_name (gdbarch
, regnum
) != NULL
1096 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
1098 tuple_cleanup
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1099 ui_out_field_int (uiout
, "number", regnum
);
1100 get_register (frame
, regnum
, format
);
1101 do_cleanups (tuple_cleanup
);
1104 error ("bad register number");
1106 do_cleanups (list_cleanup
);
1109 /* Output one register's contents in the desired format. */
1111 get_register (struct frame_info
*frame
, int regnum
, int format
)
1113 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1115 enum lval_type lval
;
1116 static struct ui_stream
*stb
= NULL
;
1119 stb
= ui_out_stream_new (uiout
);
1124 val
= get_frame_register_value (frame
, regnum
);
1126 if (value_optimized_out (val
))
1127 error ("Optimized out");
1132 char *ptr
, buf
[1024];
1133 const gdb_byte
*valaddr
= value_contents_for_printing (val
);
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) valaddr
[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 (value_type (val
),
1155 value_contents_for_printing (val
),
1156 value_embedded_offset (val
), 0,
1157 stb
->stream
, 0, val
, &opts
, current_language
);
1158 ui_out_field_stream (uiout
, "value", stb
);
1159 ui_out_stream_delete (stb
);
1163 /* Write given values into registers. The registers and values are
1164 given as pairs. The corresponding MI command is
1165 -data-write-register-values <format>
1166 [<regnum1> <value1>...<regnumN> <valueN>] */
1168 mi_cmd_data_write_register_values (char *command
, char **argv
, int argc
)
1170 struct regcache
*regcache
;
1171 struct gdbarch
*gdbarch
;
1175 /* Note that the test for a valid register must include checking the
1176 gdbarch_register_name because gdbarch_num_regs may be allocated for
1177 the union of the register sets within a family of related processors.
1178 In this case, some entries of gdbarch_register_name will change depending
1179 upon the particular processor being debugged. */
1181 regcache
= get_current_regcache ();
1182 gdbarch
= get_regcache_arch (regcache
);
1183 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1186 error ("-data-write-register-values: Usage: -data-write-register-"
1187 "values <format> [<regnum1> <value1>...<regnumN> <valueN>]");
1189 format
= (int) argv
[0][0];
1191 if (!target_has_registers
)
1192 error ("-data-write-register-values: No registers.");
1195 error ("-data-write-register-values: No regs and values specified.");
1198 error ("-data-write-register-values: "
1199 "Regs and vals are not in pairs.");
1201 for (i
= 1; i
< argc
; i
= i
+ 2)
1203 int regnum
= atoi (argv
[i
]);
1205 if (regnum
>= 0 && regnum
< numregs
1206 && gdbarch_register_name (gdbarch
, regnum
)
1207 && *gdbarch_register_name (gdbarch
, regnum
))
1211 /* Get the value as a number. */
1212 value
= parse_and_eval_address (argv
[i
+ 1]);
1214 /* Write it down. */
1215 regcache_cooked_write_signed (regcache
, regnum
, value
);
1218 error ("bad register number");
1222 /* Evaluate the value of the argument. The argument is an
1223 expression. If the expression contains spaces it needs to be
1224 included in double quotes. */
1226 mi_cmd_data_evaluate_expression (char *command
, char **argv
, int argc
)
1228 struct expression
*expr
;
1229 struct cleanup
*old_chain
= NULL
;
1231 struct ui_stream
*stb
= NULL
;
1232 struct value_print_options opts
;
1234 stb
= ui_out_stream_new (uiout
);
1238 ui_out_stream_delete (stb
);
1239 error ("-data-evaluate-expression: "
1240 "Usage: -data-evaluate-expression expression");
1243 expr
= parse_expression (argv
[0]);
1245 old_chain
= make_cleanup (free_current_contents
, &expr
);
1247 val
= evaluate_expression (expr
);
1249 /* Print the result of the expression evaluation. */
1250 get_user_print_options (&opts
);
1252 common_val_print (val
, stb
->stream
, 0, &opts
, current_language
);
1254 ui_out_field_stream (uiout
, "value", stb
);
1255 ui_out_stream_delete (stb
);
1257 do_cleanups (old_chain
);
1260 /* DATA-MEMORY-READ:
1262 ADDR: start address of data to be dumped.
1263 WORD-FORMAT: a char indicating format for the ``word''. See
1265 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes.
1266 NR_ROW: Number of rows.
1267 NR_COL: The number of colums (words per row).
1268 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
1269 ASCHAR for unprintable characters.
1271 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
1272 displayes them. Returns:
1274 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
1277 The number of bytes read is SIZE*ROW*COL. */
1280 mi_cmd_data_read_memory (char *command
, char **argv
, int argc
)
1282 struct gdbarch
*gdbarch
= get_current_arch ();
1283 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
1289 struct type
*word_type
;
1302 static struct mi_opt opts
[] =
1304 {"o", OFFSET_OPT
, 1},
1310 int opt
= mi_getopt ("-data-read-memory", argc
, argv
, opts
,
1315 switch ((enum opt
) opt
)
1318 offset
= atol (optarg
);
1325 if (argc
< 5 || argc
> 6)
1326 error ("-data-read-memory: Usage: "
1327 "ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR].");
1329 /* Extract all the arguments. */
1331 /* Start address of the memory dump. */
1332 addr
= parse_and_eval_address (argv
[0]) + offset
;
1333 /* The format character to use when displaying a memory word. See
1334 the ``x'' command. */
1335 word_format
= argv
[1][0];
1336 /* The size of the memory word. */
1337 word_size
= atol (argv
[2]);
1341 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1345 word_type
= builtin_type (gdbarch
)->builtin_int16
;
1349 word_type
= builtin_type (gdbarch
)->builtin_int32
;
1353 word_type
= builtin_type (gdbarch
)->builtin_int64
;
1357 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1360 /* The number of rows. */
1361 nr_rows
= atol (argv
[3]);
1363 error ("-data-read-memory: invalid number of rows.");
1365 /* Number of bytes per row. */
1366 nr_cols
= atol (argv
[4]);
1368 error ("-data-read-memory: invalid number of columns.");
1370 /* The un-printable character when printing ascii. */
1376 /* Create a buffer and read it in. */
1377 total_bytes
= word_size
* nr_rows
* nr_cols
;
1378 mbuf
= xcalloc (total_bytes
, 1);
1379 make_cleanup (xfree
, mbuf
);
1381 /* Dispatch memory reads to the topmost target, not the flattened
1383 nr_bytes
= target_read (current_target
.beneath
,
1384 TARGET_OBJECT_MEMORY
, NULL
, mbuf
,
1387 error ("Unable to read memory.");
1389 /* Output the header information. */
1390 ui_out_field_core_addr (uiout
, "addr", gdbarch
, addr
);
1391 ui_out_field_int (uiout
, "nr-bytes", nr_bytes
);
1392 ui_out_field_int (uiout
, "total-bytes", total_bytes
);
1393 ui_out_field_core_addr (uiout
, "next-row",
1394 gdbarch
, addr
+ word_size
* nr_cols
);
1395 ui_out_field_core_addr (uiout
, "prev-row",
1396 gdbarch
, addr
- word_size
* nr_cols
);
1397 ui_out_field_core_addr (uiout
, "next-page", gdbarch
, addr
+ total_bytes
);
1398 ui_out_field_core_addr (uiout
, "prev-page", gdbarch
, addr
- total_bytes
);
1400 /* Build the result as a two dimentional table. */
1402 struct ui_stream
*stream
= ui_out_stream_new (uiout
);
1403 struct cleanup
*cleanup_list_memory
;
1407 cleanup_list_memory
= make_cleanup_ui_out_list_begin_end (uiout
, "memory");
1408 for (row
= 0, row_byte
= 0;
1410 row
++, row_byte
+= nr_cols
* word_size
)
1414 struct cleanup
*cleanup_tuple
;
1415 struct cleanup
*cleanup_list_data
;
1416 struct value_print_options opts
;
1418 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1419 ui_out_field_core_addr (uiout
, "addr", gdbarch
, addr
+ row_byte
);
1420 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr +
1422 cleanup_list_data
= make_cleanup_ui_out_list_begin_end (uiout
, "data");
1423 get_formatted_print_options (&opts
, word_format
);
1424 for (col
= 0, col_byte
= row_byte
;
1426 col
++, col_byte
+= word_size
)
1428 if (col_byte
+ word_size
> nr_bytes
)
1430 ui_out_field_string (uiout
, NULL
, "N/A");
1434 ui_file_rewind (stream
->stream
);
1435 print_scalar_formatted (mbuf
+ col_byte
, word_type
, &opts
,
1436 word_asize
, stream
->stream
);
1437 ui_out_field_stream (uiout
, NULL
, stream
);
1440 do_cleanups (cleanup_list_data
);
1445 ui_file_rewind (stream
->stream
);
1446 for (byte
= row_byte
;
1447 byte
< row_byte
+ word_size
* nr_cols
; byte
++)
1449 if (byte
>= nr_bytes
)
1451 fputc_unfiltered ('X', stream
->stream
);
1453 else if (mbuf
[byte
] < 32 || mbuf
[byte
] > 126)
1455 fputc_unfiltered (aschar
, stream
->stream
);
1458 fputc_unfiltered (mbuf
[byte
], stream
->stream
);
1460 ui_out_field_stream (uiout
, "ascii", stream
);
1462 do_cleanups (cleanup_tuple
);
1464 ui_out_stream_delete (stream
);
1465 do_cleanups (cleanup_list_memory
);
1467 do_cleanups (cleanups
);
1471 mi_cmd_data_read_memory_bytes (char *command
, char **argv
, int argc
)
1473 struct gdbarch
*gdbarch
= get_current_arch ();
1474 struct cleanup
*cleanups
;
1477 memory_read_result_s
*read_result
;
1479 VEC(memory_read_result_s
) *result
;
1487 static struct mi_opt opts
[] =
1489 {"o", OFFSET_OPT
, 1},
1495 int opt
= mi_getopt ("-data-read-memory-bytes", argc
, argv
, opts
,
1499 switch ((enum opt
) opt
)
1502 offset
= atol (optarg
);
1510 error ("Usage: [ -o OFFSET ] ADDR LENGTH.");
1512 addr
= parse_and_eval_address (argv
[0]) + offset
;
1513 length
= atol (argv
[1]);
1515 result
= read_memory_robust (current_target
.beneath
, addr
, length
);
1517 cleanups
= make_cleanup (free_memory_read_result_vector
, result
);
1519 if (VEC_length (memory_read_result_s
, result
) == 0)
1520 error ("Unable to read memory.");
1522 make_cleanup_ui_out_list_begin_end (uiout
, "memory");
1524 VEC_iterate (memory_read_result_s
, result
, ix
, read_result
);
1527 struct cleanup
*t
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1531 ui_out_field_core_addr (uiout
, "begin", gdbarch
, read_result
->begin
);
1532 ui_out_field_core_addr (uiout
, "offset", gdbarch
, read_result
->begin
1534 ui_out_field_core_addr (uiout
, "end", gdbarch
, read_result
->end
);
1536 data
= xmalloc ((read_result
->end
- read_result
->begin
) * 2 + 1);
1538 for (i
= 0, p
= data
;
1539 i
< (read_result
->end
- read_result
->begin
);
1542 sprintf (p
, "%02x", read_result
->data
[i
]);
1544 ui_out_field_string (uiout
, "contents", data
);
1548 do_cleanups (cleanups
);
1552 /* DATA-MEMORY-WRITE:
1554 COLUMN_OFFSET: optional argument. Must be preceeded by '-o'. The
1555 offset from the beginning of the memory grid row where the cell to
1557 ADDR: start address of the row in the memory grid where the memory
1558 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
1559 the location to write to.
1560 FORMAT: a char indicating format for the ``word''. See
1562 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
1563 VALUE: value to be written into the memory address.
1565 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
1569 mi_cmd_data_write_memory (char *command
, char **argv
, int argc
)
1571 struct gdbarch
*gdbarch
= get_current_arch ();
1572 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1576 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
1577 enough when using a compiler other than GCC. */
1580 struct cleanup
*old_chain
;
1588 static struct mi_opt opts
[] =
1590 {"o", OFFSET_OPT
, 1},
1596 int opt
= mi_getopt ("-data-write-memory", argc
, argv
, opts
,
1601 switch ((enum opt
) opt
)
1604 offset
= atol (optarg
);
1612 error ("-data-write-memory: Usage: "
1613 "[-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE.");
1615 /* Extract all the arguments. */
1616 /* Start address of the memory dump. */
1617 addr
= parse_and_eval_address (argv
[0]);
1618 /* The format character to use when displaying a memory word. See
1619 the ``x'' command. */
1620 word_format
= argv
[1][0];
1621 /* The size of the memory word. */
1622 word_size
= atol (argv
[2]);
1624 /* Calculate the real address of the write destination. */
1625 addr
+= (offset
* word_size
);
1627 /* Get the value as a number. */
1628 value
= parse_and_eval_address (argv
[3]);
1629 /* Get the value into an array. */
1630 buffer
= xmalloc (word_size
);
1631 old_chain
= make_cleanup (xfree
, buffer
);
1632 store_signed_integer (buffer
, word_size
, byte_order
, value
);
1633 /* Write it down to memory. */
1634 write_memory (addr
, buffer
, word_size
);
1635 /* Free the buffer. */
1636 do_cleanups (old_chain
);
1639 /* DATA-MEMORY-WRITE-RAW:
1642 DATA: string of bytes to write at that address. */
1644 mi_cmd_data_write_memory_bytes (char *command
, char **argv
, int argc
)
1650 struct cleanup
*back_to
;
1653 error ("Usage: ADDR DATA.");
1655 addr
= parse_and_eval_address (argv
[0]);
1657 len
= strlen (cdata
)/2;
1659 data
= xmalloc (len
);
1660 back_to
= make_cleanup (xfree
, data
);
1662 for (i
= 0; i
< len
; ++i
)
1665 sscanf (cdata
+ i
* 2, "%02x", &x
);
1666 data
[i
] = (gdb_byte
)x
;
1669 r
= target_write_memory (addr
, data
, len
);
1671 error (_("Could not write memory"));
1673 do_cleanups (back_to
);
1678 mi_cmd_enable_timings (char *command
, char **argv
, int argc
)
1684 if (strcmp (argv
[0], "yes") == 0)
1686 else if (strcmp (argv
[0], "no") == 0)
1697 error ("-enable-timings: Usage: %s {yes|no}", command
);
1701 mi_cmd_list_features (char *command
, char **argv
, int argc
)
1705 struct cleanup
*cleanup
= NULL
;
1707 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "features");
1708 ui_out_field_string (uiout
, NULL
, "frozen-varobjs");
1709 ui_out_field_string (uiout
, NULL
, "pending-breakpoints");
1710 ui_out_field_string (uiout
, NULL
, "thread-info");
1711 ui_out_field_string (uiout
, NULL
, "data-read-memory-bytes");
1714 ui_out_field_string (uiout
, NULL
, "python");
1717 do_cleanups (cleanup
);
1721 error ("-list-features should be passed no arguments");
1725 mi_cmd_list_target_features (char *command
, char **argv
, int argc
)
1729 struct cleanup
*cleanup
= NULL
;
1731 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "features");
1732 if (target_can_async_p ())
1733 ui_out_field_string (uiout
, NULL
, "async");
1734 if (target_can_execute_reverse
)
1735 ui_out_field_string (uiout
, NULL
, "reverse");
1737 do_cleanups (cleanup
);
1741 error ("-list-target-features should be passed no arguments");
1745 mi_cmd_add_inferior (char *command
, char **argv
, int argc
)
1747 struct inferior
*inf
;
1750 error (_("-add-inferior should be passed no arguments"));
1752 inf
= add_inferior_with_spaces ();
1754 ui_out_field_fmt (uiout
, "inferior", "i%d", inf
->num
);
1757 /* Callback used to find the first inferior other than the
1761 get_other_inferior (struct inferior
*inf
, void *arg
)
1763 if (inf
== current_inferior ())
1770 mi_cmd_remove_inferior (char *command
, char **argv
, int argc
)
1773 struct inferior
*inf
;
1776 error ("-remove-inferior should be passed a single argument");
1778 if (sscanf (argv
[0], "i%d", &id
) != 1)
1779 error ("the thread group id is syntactically invalid");
1781 inf
= find_inferior_id (id
);
1783 error ("the specified thread group does not exist");
1786 error (_("cannot remove an active inferior"));
1788 if (inf
== current_inferior ())
1790 struct thread_info
*tp
= 0;
1791 struct inferior
*new_inferior
1792 = iterate_over_inferiors (get_other_inferior
, NULL
);
1794 if (new_inferior
== NULL
)
1795 error (_("Cannot remove last inferior"));
1797 set_current_inferior (new_inferior
);
1798 if (new_inferior
->pid
!= 0)
1799 tp
= any_thread_of_process (new_inferior
->pid
);
1800 switch_to_thread (tp
? tp
->ptid
: null_ptid
);
1801 set_current_program_space (new_inferior
->pspace
);
1804 delete_inferior_1 (inf
, 1 /* silent */);
1809 /* Execute a command within a safe environment.
1810 Return <0 for error; >=0 for ok.
1812 args->action will tell mi_execute_command what action
1813 to perfrom after the given command has executed (display/suppress
1814 prompt, display error). */
1817 captured_mi_execute_command (struct ui_out
*uiout
, void *data
)
1819 struct cleanup
*cleanup
;
1820 struct mi_parse
*context
= (struct mi_parse
*) data
;
1823 current_command_ts
= context
->cmd_start
;
1825 current_token
= xstrdup (context
->token
);
1826 cleanup
= make_cleanup (free_current_contents
, ¤t_token
);
1828 running_result_record_printed
= 0;
1830 switch (context
->op
)
1833 /* A MI command was read from the input stream. */
1835 /* FIXME: gdb_???? */
1836 fprintf_unfiltered (raw_stdout
, " token=`%s' command=`%s' args=`%s'\n",
1837 context
->token
, context
->command
, context
->args
);
1840 mi_cmd_execute (context
);
1842 /* Print the result if there were no errors.
1844 Remember that on the way out of executing a command, you have
1845 to directly use the mi_interp's uiout, since the command could
1846 have reset the interpreter, in which case the current uiout
1847 will most likely crash in the mi_out_* routines. */
1848 if (!running_result_record_printed
)
1850 fputs_unfiltered (context
->token
, raw_stdout
);
1851 /* There's no particularly good reason why target-connect results
1852 in not ^done. Should kill ^connected for MI3. */
1853 fputs_unfiltered (strcmp (context
->command
, "target-select") == 0
1854 ? "^connected" : "^done", raw_stdout
);
1855 mi_out_put (uiout
, raw_stdout
);
1856 mi_out_rewind (uiout
);
1857 mi_print_timing_maybe ();
1858 fputs_unfiltered ("\n", raw_stdout
);
1861 /* The command does not want anything to be printed. In that
1862 case, the command probably should not have written anything
1863 to uiout, but in case it has written something, discard it. */
1864 mi_out_rewind (uiout
);
1871 /* A CLI command was read from the input stream. */
1872 /* This "feature" will be removed as soon as we have a
1873 complete set of mi commands. */
1874 /* Echo the command on the console. */
1875 fprintf_unfiltered (gdb_stdlog
, "%s\n", context
->command
);
1876 /* Call the "console" interpreter. */
1877 argv
[0] = "console";
1878 argv
[1] = context
->command
;
1879 mi_cmd_interpreter_exec ("-interpreter-exec", argv
, 2);
1881 /* If we changed interpreters, DON'T print out anything. */
1882 if (current_interp_named_p (INTERP_MI
)
1883 || current_interp_named_p (INTERP_MI1
)
1884 || current_interp_named_p (INTERP_MI2
)
1885 || current_interp_named_p (INTERP_MI3
))
1887 if (!running_result_record_printed
)
1889 fputs_unfiltered (context
->token
, raw_stdout
);
1890 fputs_unfiltered ("^done", raw_stdout
);
1891 mi_out_put (uiout
, raw_stdout
);
1892 mi_out_rewind (uiout
);
1893 mi_print_timing_maybe ();
1894 fputs_unfiltered ("\n", raw_stdout
);
1897 mi_out_rewind (uiout
);
1904 do_cleanups (cleanup
);
1909 /* Print a gdb exception to the MI output stream. */
1912 mi_print_exception (const char *token
, struct gdb_exception exception
)
1914 fputs_unfiltered (token
, raw_stdout
);
1915 fputs_unfiltered ("^error,msg=\"", raw_stdout
);
1916 if (exception
.message
== NULL
)
1917 fputs_unfiltered ("unknown error", raw_stdout
);
1919 fputstr_unfiltered (exception
.message
, '"', raw_stdout
);
1920 fputs_unfiltered ("\"\n", raw_stdout
);
1924 mi_execute_command (char *cmd
, int from_tty
)
1927 struct mi_parse
*command
= NULL
;
1928 volatile struct gdb_exception exception
;
1930 /* This is to handle EOF (^D). We just quit gdb. */
1931 /* FIXME: we should call some API function here. */
1933 quit_force (NULL
, from_tty
);
1935 target_log_command (cmd
);
1937 TRY_CATCH (exception
, RETURN_MASK_ALL
)
1939 command
= mi_parse (cmd
, &token
);
1941 if (exception
.reason
< 0)
1943 mi_print_exception (token
, exception
);
1948 struct gdb_exception result
;
1949 ptid_t previous_ptid
= inferior_ptid
;
1951 command
->token
= token
;
1955 command
->cmd_start
= (struct mi_timestamp
*)
1956 xmalloc (sizeof (struct mi_timestamp
));
1957 timestamp (command
->cmd_start
);
1960 result
= catch_exception (uiout
, captured_mi_execute_command
, command
,
1962 if (result
.reason
< 0)
1964 /* The command execution failed and error() was called
1966 mi_print_exception (command
->token
, result
);
1967 mi_out_rewind (uiout
);
1970 bpstat_do_actions ();
1972 if (/* The notifications are only output when the top-level
1973 interpreter (specified on the command line) is MI. */
1974 ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ()))
1975 /* Don't try report anything if there are no threads --
1976 the program is dead. */
1977 && thread_count () != 0
1978 /* -thread-select explicitly changes thread. If frontend uses that
1979 internally, we don't want to emit =thread-selected, since
1980 =thread-selected is supposed to indicate user's intentions. */
1981 && strcmp (command
->command
, "thread-select") != 0)
1983 struct mi_interp
*mi
= top_level_interpreter_data ();
1984 int report_change
= 0;
1986 if (command
->thread
== -1)
1988 report_change
= (!ptid_equal (previous_ptid
, null_ptid
)
1989 && !ptid_equal (inferior_ptid
, previous_ptid
)
1990 && !ptid_equal (inferior_ptid
, null_ptid
));
1992 else if (!ptid_equal (inferior_ptid
, null_ptid
))
1994 struct thread_info
*ti
= inferior_thread ();
1996 report_change
= (ti
->num
!= command
->thread
);
2001 struct thread_info
*ti
= inferior_thread ();
2003 target_terminal_ours ();
2004 fprintf_unfiltered (mi
->event_channel
,
2005 "thread-selected,id=\"%d\"",
2007 gdb_flush (mi
->event_channel
);
2011 mi_parse_free (command
);
2014 fputs_unfiltered ("(gdb) \n", raw_stdout
);
2015 gdb_flush (raw_stdout
);
2016 /* Print any buffered hook code. */
2021 mi_cmd_execute (struct mi_parse
*parse
)
2023 struct cleanup
*cleanup
;
2025 prepare_execute_command ();
2027 cleanup
= make_cleanup (null_cleanup
, NULL
);
2029 if (parse
->all
&& parse
->thread_group
!= -1)
2030 error (_("Cannot specify --thread-group together with --all"));
2032 if (parse
->all
&& parse
->thread
!= -1)
2033 error (_("Cannot specify --thread together with --all"));
2035 if (parse
->thread_group
!= -1 && parse
->thread
!= -1)
2036 error (_("Cannot specify --thread together with --thread-group"));
2038 if (parse
->frame
!= -1 && parse
->thread
== -1)
2039 error (_("Cannot specify --frame without --thread"));
2041 if (parse
->thread_group
!= -1)
2043 struct inferior
*inf
= find_inferior_id (parse
->thread_group
);
2044 struct thread_info
*tp
= 0;
2047 error (_("Invalid thread group for the --thread-group option"));
2049 set_current_inferior (inf
);
2050 /* This behaviour means that if --thread-group option identifies
2051 an inferior with multiple threads, then a random one will be picked.
2052 This is not a problem -- frontend should always provide --thread if
2053 it wishes to operate on a specific thread. */
2055 tp
= any_thread_of_process (inf
->pid
);
2056 switch_to_thread (tp
? tp
->ptid
: null_ptid
);
2057 set_current_program_space (inf
->pspace
);
2060 if (parse
->thread
!= -1)
2062 struct thread_info
*tp
= find_thread_id (parse
->thread
);
2065 error (_("Invalid thread id: %d"), parse
->thread
);
2067 if (is_exited (tp
->ptid
))
2068 error (_("Thread id: %d has terminated"), parse
->thread
);
2070 switch_to_thread (tp
->ptid
);
2073 if (parse
->frame
!= -1)
2075 struct frame_info
*fid
;
2076 int frame
= parse
->frame
;
2078 fid
= find_relative_frame (get_current_frame (), &frame
);
2080 /* find_relative_frame was successful */
2083 error (_("Invalid frame id: %d"), frame
);
2086 current_context
= parse
;
2088 if (parse
->cmd
->argv_func
!= NULL
)
2089 parse
->cmd
->argv_func (parse
->command
, parse
->argv
, parse
->argc
);
2090 else if (parse
->cmd
->cli
.cmd
!= 0)
2092 /* FIXME: DELETE THIS. */
2093 /* The operation is still implemented by a cli command. */
2094 /* Must be a synchronous one. */
2095 mi_execute_cli_command (parse
->cmd
->cli
.cmd
, parse
->cmd
->cli
.args_p
,
2100 /* FIXME: DELETE THIS. */
2101 struct ui_file
*stb
;
2103 stb
= mem_fileopen ();
2105 fputs_unfiltered ("Undefined mi command: ", stb
);
2106 fputstr_unfiltered (parse
->command
, '"', stb
);
2107 fputs_unfiltered (" (missing implementation)", stb
);
2109 make_cleanup_ui_file_delete (stb
);
2112 do_cleanups (cleanup
);
2115 /* FIXME: This is just a hack so we can get some extra commands going.
2116 We don't want to channel things through the CLI, but call libgdb directly.
2117 Use only for synchronous commands. */
2120 mi_execute_cli_command (const char *cmd
, int args_p
, const char *args
)
2124 struct cleanup
*old_cleanups
;
2128 run
= xstrprintf ("%s %s", cmd
, args
);
2130 run
= xstrdup (cmd
);
2132 /* FIXME: gdb_???? */
2133 fprintf_unfiltered (gdb_stdout
, "cli=%s run=%s\n",
2135 old_cleanups
= make_cleanup (xfree
, run
);
2136 execute_command ( /*ui */ run
, 0 /*from_tty */ );
2137 do_cleanups (old_cleanups
);
2143 mi_execute_async_cli_command (char *cli_command
, char **argv
, int argc
)
2145 struct cleanup
*old_cleanups
;
2148 if (target_can_async_p ())
2149 run
= xstrprintf ("%s %s&", cli_command
, argc
? *argv
: "");
2151 run
= xstrprintf ("%s %s", cli_command
, argc
? *argv
: "");
2152 old_cleanups
= make_cleanup (xfree
, run
);
2154 execute_command ( /*ui */ run
, 0 /*from_tty */ );
2156 if (target_can_async_p ())
2158 /* If we're not executing, an exception should have been throw. */
2159 gdb_assert (is_running (inferior_ptid
));
2160 do_cleanups (old_cleanups
);
2164 /* Do this before doing any printing. It would appear that some
2165 print code leaves garbage around in the buffer. */
2166 do_cleanups (old_cleanups
);
2171 mi_load_progress (const char *section_name
,
2172 unsigned long sent_so_far
,
2173 unsigned long total_section
,
2174 unsigned long total_sent
,
2175 unsigned long grand_total
)
2177 struct timeval time_now
, delta
, update_threshold
;
2178 static struct timeval last_update
;
2179 static char *previous_sect_name
= NULL
;
2181 struct ui_out
*saved_uiout
;
2183 /* This function is called through deprecated_show_load_progress
2184 which means uiout may not be correct. Fix it for the duration
2185 of this function. */
2186 saved_uiout
= uiout
;
2188 if (current_interp_named_p (INTERP_MI
)
2189 || current_interp_named_p (INTERP_MI2
))
2190 uiout
= mi_out_new (2);
2191 else if (current_interp_named_p (INTERP_MI1
))
2192 uiout
= mi_out_new (1);
2193 else if (current_interp_named_p (INTERP_MI3
))
2194 uiout
= mi_out_new (3);
2198 update_threshold
.tv_sec
= 0;
2199 update_threshold
.tv_usec
= 500000;
2200 gettimeofday (&time_now
, NULL
);
2202 delta
.tv_usec
= time_now
.tv_usec
- last_update
.tv_usec
;
2203 delta
.tv_sec
= time_now
.tv_sec
- last_update
.tv_sec
;
2205 if (delta
.tv_usec
< 0)
2208 delta
.tv_usec
+= 1000000L;
2211 new_section
= (previous_sect_name
?
2212 strcmp (previous_sect_name
, section_name
) : 1);
2215 struct cleanup
*cleanup_tuple
;
2217 xfree (previous_sect_name
);
2218 previous_sect_name
= xstrdup (section_name
);
2221 fputs_unfiltered (current_token
, raw_stdout
);
2222 fputs_unfiltered ("+download", raw_stdout
);
2223 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2224 ui_out_field_string (uiout
, "section", section_name
);
2225 ui_out_field_int (uiout
, "section-size", total_section
);
2226 ui_out_field_int (uiout
, "total-size", grand_total
);
2227 do_cleanups (cleanup_tuple
);
2228 mi_out_put (uiout
, raw_stdout
);
2229 fputs_unfiltered ("\n", raw_stdout
);
2230 gdb_flush (raw_stdout
);
2233 if (delta
.tv_sec
>= update_threshold
.tv_sec
&&
2234 delta
.tv_usec
>= update_threshold
.tv_usec
)
2236 struct cleanup
*cleanup_tuple
;
2238 last_update
.tv_sec
= time_now
.tv_sec
;
2239 last_update
.tv_usec
= time_now
.tv_usec
;
2241 fputs_unfiltered (current_token
, raw_stdout
);
2242 fputs_unfiltered ("+download", raw_stdout
);
2243 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2244 ui_out_field_string (uiout
, "section", section_name
);
2245 ui_out_field_int (uiout
, "section-sent", sent_so_far
);
2246 ui_out_field_int (uiout
, "section-size", total_section
);
2247 ui_out_field_int (uiout
, "total-sent", total_sent
);
2248 ui_out_field_int (uiout
, "total-size", grand_total
);
2249 do_cleanups (cleanup_tuple
);
2250 mi_out_put (uiout
, raw_stdout
);
2251 fputs_unfiltered ("\n", raw_stdout
);
2252 gdb_flush (raw_stdout
);
2256 uiout
= saved_uiout
;
2260 timestamp (struct mi_timestamp
*tv
)
2262 gettimeofday (&tv
->wallclock
, NULL
);
2263 #ifdef HAVE_GETRUSAGE
2264 getrusage (RUSAGE_SELF
, &rusage
);
2265 tv
->utime
.tv_sec
= rusage
.ru_utime
.tv_sec
;
2266 tv
->utime
.tv_usec
= rusage
.ru_utime
.tv_usec
;
2267 tv
->stime
.tv_sec
= rusage
.ru_stime
.tv_sec
;
2268 tv
->stime
.tv_usec
= rusage
.ru_stime
.tv_usec
;
2271 long usec
= get_run_time ();
2273 tv
->utime
.tv_sec
= usec
/1000000L;
2274 tv
->utime
.tv_usec
= usec
- 1000000L*tv
->utime
.tv_sec
;
2275 tv
->stime
.tv_sec
= 0;
2276 tv
->stime
.tv_usec
= 0;
2282 print_diff_now (struct mi_timestamp
*start
)
2284 struct mi_timestamp now
;
2287 print_diff (start
, &now
);
2291 mi_print_timing_maybe (void)
2293 /* If the command is -enable-timing then do_timings may be
2294 true whilst current_command_ts is not initialized. */
2295 if (do_timings
&& current_command_ts
)
2296 print_diff_now (current_command_ts
);
2300 timeval_diff (struct timeval start
, struct timeval end
)
2302 return ((end
.tv_sec
- start
.tv_sec
) * 1000000L)
2303 + (end
.tv_usec
- start
.tv_usec
);
2307 print_diff (struct mi_timestamp
*start
, struct mi_timestamp
*end
)
2311 ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
2312 timeval_diff (start
->wallclock
, end
->wallclock
) / 1000000.0,
2313 timeval_diff (start
->utime
, end
->utime
) / 1000000.0,
2314 timeval_diff (start
->stime
, end
->stime
) / 1000000.0);
2318 mi_cmd_trace_define_variable (char *command
, char **argv
, int argc
)
2320 struct expression
*expr
;
2321 struct cleanup
*back_to
;
2322 LONGEST initval
= 0;
2323 struct trace_state_variable
*tsv
;
2326 if (argc
!= 1 && argc
!= 2)
2327 error (_("Usage: -trace-define-variable VARIABLE [VALUE]"));
2329 expr
= parse_expression (argv
[0]);
2330 back_to
= make_cleanup (xfree
, expr
);
2332 if (expr
->nelts
== 3 && expr
->elts
[0].opcode
== OP_INTERNALVAR
)
2334 struct internalvar
*intvar
= expr
->elts
[1].internalvar
;
2337 name
= internalvar_name (intvar
);
2340 if (!name
|| *name
== '\0')
2341 error (_("Invalid name of trace variable"));
2343 tsv
= find_trace_state_variable (name
);
2345 tsv
= create_trace_state_variable (name
);
2348 initval
= value_as_long (parse_and_eval (argv
[1]));
2350 tsv
->initial_value
= initval
;
2352 do_cleanups (back_to
);
2356 mi_cmd_trace_list_variables (char *command
, char **argv
, int argc
)
2359 error (_("-trace-list-variables: no arguments are allowed"));
2361 tvariables_info_1 ();
2365 mi_cmd_trace_find (char *command
, char **argv
, int argc
)
2370 error (_("trace selection mode is required"));
2374 if (strcmp (mode
, "none") == 0)
2376 tfind_1 (tfind_number
, -1, 0, 0, 0);
2380 if (current_trace_status ()->running
)
2381 error (_("May not look at trace frames while trace is running."));
2383 if (strcmp (mode
, "frame-number") == 0)
2386 error (_("frame number is required"));
2387 tfind_1 (tfind_number
, atoi (argv
[1]), 0, 0, 0);
2389 else if (strcmp (mode
, "tracepoint-number") == 0)
2392 error (_("tracepoint number is required"));
2393 tfind_1 (tfind_tp
, atoi (argv
[1]), 0, 0, 0);
2395 else if (strcmp (mode
, "pc") == 0)
2398 error (_("PC is required"));
2399 tfind_1 (tfind_pc
, 0, parse_and_eval_address (argv
[1]), 0, 0);
2401 else if (strcmp (mode
, "pc-inside-range") == 0)
2404 error (_("Start and end PC are required"));
2405 tfind_1 (tfind_range
, 0, parse_and_eval_address (argv
[1]),
2406 parse_and_eval_address (argv
[2]), 0);
2408 else if (strcmp (mode
, "pc-outside-range") == 0)
2411 error (_("Start and end PC are required"));
2412 tfind_1 (tfind_outside
, 0, parse_and_eval_address (argv
[1]),
2413 parse_and_eval_address (argv
[2]), 0);
2415 else if (strcmp (mode
, "line") == 0)
2417 struct symtabs_and_lines sals
;
2418 struct symtab_and_line sal
;
2419 static CORE_ADDR start_pc
, end_pc
;
2420 struct cleanup
*back_to
;
2423 error (_("Line is required"));
2425 sals
= decode_line_spec (argv
[1], 1);
2426 back_to
= make_cleanup (xfree
, sals
.sals
);
2430 if (sal
.symtab
== 0)
2431 error (_("Could not find the specified line"));
2433 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2434 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, 0);
2436 error (_("Could not find the specified line"));
2438 do_cleanups (back_to
);
2441 error (_("Invalid mode '%s'"), mode
);
2443 if (has_stack_frames () || get_traceframe_number () >= 0)
2445 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
2450 mi_cmd_trace_save (char *command
, char **argv
, int argc
)
2452 int target_saves
= 0;
2455 if (argc
!= 1 && argc
!= 2)
2456 error (_("Usage: -trace-save [-r] filename"));
2461 if (strcmp (argv
[0], "-r") == 0)
2464 error (_("Invalid option: %s"), argv
[0]);
2471 trace_save (filename
, target_saves
);
2476 mi_cmd_trace_start (char *command
, char **argv
, int argc
)
2482 mi_cmd_trace_status (char *command
, char **argv
, int argc
)
2484 trace_status_mi (0);
2488 mi_cmd_trace_stop (char *command
, char **argv
, int argc
)
2491 trace_status_mi (1);