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"
61 #if defined HAVE_SYS_RESOURCE_H
62 #include <sys/resource.h>
75 struct ui_file
*raw_stdout
;
77 /* This is used to pass the current command timestamp
78 down to continuation routines. */
79 static struct mi_timestamp
*current_command_ts
;
81 static int do_timings
= 0;
84 /* Few commands would like to know if options like --thread-group
85 were explicitly specified. This variable keeps the current
86 parsed command including all option, and make it possible. */
87 static struct mi_parse
*current_context
;
89 int running_result_record_printed
= 1;
91 /* Flag indicating that the target has proceeded since the last
92 command was issued. */
95 extern void _initialize_mi_main (void);
96 static void mi_cmd_execute (struct mi_parse
*parse
);
98 static void mi_execute_cli_command (const char *cmd
, int args_p
,
100 static void mi_execute_async_cli_command (char *cli_command
,
101 char **argv
, int argc
);
102 static int register_changed_p (int regnum
, struct regcache
*,
104 static void get_register (struct frame_info
*, int regnum
, int format
);
106 /* Command implementations. FIXME: Is this libgdb? No. This is the MI
107 layer that calls libgdb. Any operation used in the below should be
110 static void timestamp (struct mi_timestamp
*tv
);
112 static void print_diff_now (struct mi_timestamp
*start
);
113 static void print_diff (struct mi_timestamp
*start
, struct mi_timestamp
*end
);
116 mi_cmd_gdb_exit (char *command
, char **argv
, int argc
)
118 /* We have to print everything right here because we never return. */
120 fputs_unfiltered (current_token
, raw_stdout
);
121 fputs_unfiltered ("^exit\n", raw_stdout
);
122 mi_out_put (current_uiout
, raw_stdout
);
123 gdb_flush (raw_stdout
);
124 /* FIXME: The function called is not yet a formal libgdb function. */
125 quit_force (NULL
, FROM_TTY
);
129 mi_cmd_exec_next (char *command
, char **argv
, int argc
)
131 /* FIXME: Should call a libgdb function, not a cli wrapper. */
132 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
133 mi_execute_async_cli_command ("reverse-next", argv
+ 1, argc
- 1);
135 mi_execute_async_cli_command ("next", argv
, argc
);
139 mi_cmd_exec_next_instruction (char *command
, char **argv
, int argc
)
141 /* FIXME: Should call a libgdb function, not a cli wrapper. */
142 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
143 mi_execute_async_cli_command ("reverse-nexti", argv
+ 1, argc
- 1);
145 mi_execute_async_cli_command ("nexti", argv
, argc
);
149 mi_cmd_exec_step (char *command
, char **argv
, int argc
)
151 /* FIXME: Should call a libgdb function, not a cli wrapper. */
152 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
153 mi_execute_async_cli_command ("reverse-step", argv
+ 1, argc
- 1);
155 mi_execute_async_cli_command ("step", argv
, argc
);
159 mi_cmd_exec_step_instruction (char *command
, char **argv
, int argc
)
161 /* FIXME: Should call a libgdb function, not a cli wrapper. */
162 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
163 mi_execute_async_cli_command ("reverse-stepi", argv
+ 1, argc
- 1);
165 mi_execute_async_cli_command ("stepi", argv
, argc
);
169 mi_cmd_exec_finish (char *command
, char **argv
, int argc
)
171 /* FIXME: Should call a libgdb function, not a cli wrapper. */
172 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
173 mi_execute_async_cli_command ("reverse-finish", argv
+ 1, argc
- 1);
175 mi_execute_async_cli_command ("finish", argv
, argc
);
179 mi_cmd_exec_return (char *command
, char **argv
, int argc
)
181 /* This command doesn't really execute the target, it just pops the
182 specified number of frames. */
184 /* Call return_command with from_tty argument equal to 0 so as to
185 avoid being queried. */
186 return_command (*argv
, 0);
188 /* Call return_command with from_tty argument equal to 0 so as to
189 avoid being queried. */
190 return_command (NULL
, 0);
192 /* Because we have called return_command with from_tty = 0, we need
193 to print the frame here. */
194 print_stack_frame (get_selected_frame (NULL
), 1, LOC_AND_ADDRESS
);
198 mi_cmd_exec_jump (char *args
, char **argv
, int argc
)
200 /* FIXME: Should call a libgdb function, not a cli wrapper. */
201 mi_execute_async_cli_command ("jump", argv
, argc
);
205 proceed_thread (struct thread_info
*thread
, int pid
)
207 if (!is_stopped (thread
->ptid
))
210 if (pid
!= 0 && PIDGET (thread
->ptid
) != pid
)
213 switch_to_thread (thread
->ptid
);
214 clear_proceed_status ();
215 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 0);
220 proceed_thread_callback (struct thread_info
*thread
, void *arg
)
222 int pid
= *(int *)arg
;
224 proceed_thread (thread
, pid
);
229 exec_continue (char **argv
, int argc
)
233 /* In non-stop mode, 'resume' always resumes a single thread. Therefore,
234 to resume all threads of the current inferior, or all threads in all
235 inferiors, we need to iterate over threads.
237 See comment on infcmd.c:proceed_thread_callback for rationale. */
238 if (current_context
->all
|| current_context
->thread_group
!= -1)
241 struct cleanup
*back_to
= make_cleanup_restore_current_thread ();
243 if (!current_context
->all
)
246 = find_inferior_id (current_context
->thread_group
);
250 iterate_over_threads (proceed_thread_callback
, &pid
);
251 do_cleanups (back_to
);
260 struct cleanup
*back_to
= make_cleanup_restore_integer (&sched_multi
);
262 if (current_context
->all
)
269 /* In all-stop mode, -exec-continue traditionally resumed either
270 all threads, or one thread, depending on the 'scheduler-locking'
271 variable. Let's continue to do the same. */
274 do_cleanups (back_to
);
279 exec_direction_forward (void *notused
)
281 execution_direction
= EXEC_FORWARD
;
285 exec_reverse_continue (char **argv
, int argc
)
287 enum exec_direction_kind dir
= execution_direction
;
288 struct cleanup
*old_chain
;
290 if (dir
== EXEC_REVERSE
)
291 error (_("Already in reverse mode."));
293 if (!target_can_execute_reverse
)
294 error (_("Target %s does not support this command."), target_shortname
);
296 old_chain
= make_cleanup (exec_direction_forward
, NULL
);
297 execution_direction
= EXEC_REVERSE
;
298 exec_continue (argv
, argc
);
299 do_cleanups (old_chain
);
303 mi_cmd_exec_continue (char *command
, char **argv
, int argc
)
305 if (argc
> 0 && strcmp (argv
[0], "--reverse") == 0)
306 exec_reverse_continue (argv
+ 1, argc
- 1);
308 exec_continue (argv
, argc
);
312 interrupt_thread_callback (struct thread_info
*thread
, void *arg
)
314 int pid
= *(int *)arg
;
316 if (!is_running (thread
->ptid
))
319 if (PIDGET (thread
->ptid
) != pid
)
322 target_stop (thread
->ptid
);
326 /* Interrupt the execution of the target. Note how we must play around
327 with the token variables, in order to display the current token in
328 the result of the interrupt command, and the previous execution
329 token when the target finally stops. See comments in
332 mi_cmd_exec_interrupt (char *command
, char **argv
, int argc
)
334 /* In all-stop mode, everything stops, so we don't need to try
335 anything specific. */
338 interrupt_target_1 (0);
342 if (current_context
->all
)
344 /* This will interrupt all threads in all inferiors. */
345 interrupt_target_1 (1);
347 else if (current_context
->thread_group
!= -1)
349 struct inferior
*inf
= find_inferior_id (current_context
->thread_group
);
351 iterate_over_threads (interrupt_thread_callback
, &inf
->pid
);
355 /* Interrupt just the current thread -- either explicitly
356 specified via --thread or whatever was current before
357 MI command was sent. */
358 interrupt_target_1 (0);
363 run_one_inferior (struct inferior
*inf
, void *arg
)
367 if (inf
->pid
!= ptid_get_pid (inferior_ptid
))
369 struct thread_info
*tp
;
371 tp
= any_thread_of_process (inf
->pid
);
373 error (_("Inferior has no threads."));
375 switch_to_thread (tp
->ptid
);
380 set_current_inferior (inf
);
381 switch_to_thread (null_ptid
);
382 set_current_program_space (inf
->pspace
);
384 mi_execute_cli_command ("run", target_can_async_p (),
385 target_can_async_p () ? "&" : NULL
);
390 mi_cmd_exec_run (char *command
, char **argv
, int argc
)
392 if (current_context
->all
)
394 struct cleanup
*back_to
= save_current_space_and_thread ();
396 iterate_over_inferiors (run_one_inferior
, NULL
);
397 do_cleanups (back_to
);
401 mi_execute_cli_command ("run", target_can_async_p (),
402 target_can_async_p () ? "&" : NULL
);
408 find_thread_of_process (struct thread_info
*ti
, void *p
)
412 if (PIDGET (ti
->ptid
) == pid
&& !is_exited (ti
->ptid
))
419 mi_cmd_target_detach (char *command
, char **argv
, int argc
)
421 if (argc
!= 0 && argc
!= 1)
422 error (_("Usage: -target-detach [pid | thread-group]"));
426 struct thread_info
*tp
;
430 /* First see if we are dealing with a thread-group id. */
433 struct inferior
*inf
;
434 int id
= strtoul (argv
[0] + 1, &end
, 0);
437 error (_("Invalid syntax of thread-group id '%s'"), argv
[0]);
439 inf
= find_inferior_id (id
);
441 error (_("Non-existent thread-group id '%d'"), id
);
447 /* We must be dealing with a pid. */
448 pid
= strtol (argv
[0], &end
, 10);
451 error (_("Invalid identifier '%s'"), argv
[0]);
454 /* Pick any thread in the desired process. Current
455 target_detach detaches from the parent of inferior_ptid. */
456 tp
= iterate_over_threads (find_thread_of_process
, &pid
);
458 error (_("Thread group is empty"));
460 switch_to_thread (tp
->ptid
);
463 detach_command (NULL
, 0);
467 mi_cmd_thread_select (char *command
, char **argv
, int argc
)
470 char *mi_error_message
;
473 error (_("-thread-select: USAGE: threadnum."));
475 rc
= gdb_thread_select (current_uiout
, argv
[0], &mi_error_message
);
477 if (rc
== GDB_RC_FAIL
)
479 make_cleanup (xfree
, mi_error_message
);
480 error ("%s", mi_error_message
);
485 mi_cmd_thread_list_ids (char *command
, char **argv
, int argc
)
488 char *mi_error_message
;
491 error (_("-thread-list-ids: No arguments required."));
493 rc
= gdb_list_thread_ids (current_uiout
, &mi_error_message
);
495 if (rc
== GDB_RC_FAIL
)
497 make_cleanup (xfree
, mi_error_message
);
498 error ("%s", mi_error_message
);
503 mi_cmd_thread_info (char *command
, char **argv
, int argc
)
505 if (argc
!= 0 && argc
!= 1)
506 error (_("Invalid MI command"));
508 print_thread_info (current_uiout
, argv
[0], -1);
511 struct collect_cores_data
519 collect_cores (struct thread_info
*ti
, void *xdata
)
521 struct collect_cores_data
*data
= xdata
;
523 if (ptid_get_pid (ti
->ptid
) == data
->pid
)
525 int core
= target_core_of_thread (ti
->ptid
);
528 VEC_safe_push (int, data
->cores
, core
);
535 unique (int *b
, int *e
)
545 struct print_one_inferior_data
548 VEC (int) *inferiors
;
552 print_one_inferior (struct inferior
*inferior
, void *xdata
)
554 struct print_one_inferior_data
*top_data
= xdata
;
555 struct ui_out
*uiout
= current_uiout
;
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
;
676 struct ui_out
*uiout
= current_uiout
;
678 /* This keeps a map from integer (pid) to VEC (struct osdata_item *)*
679 The vector contains information about all threads for the given pid.
680 This is assigned an initial value to avoid "may be used uninitialized"
682 splay_tree tree
= NULL
;
684 /* get_osdata will throw if it cannot return data. */
685 data
= get_osdata ("processes");
686 make_cleanup_osdata_free (data
);
690 struct osdata
*threads
= get_osdata ("threads");
692 make_cleanup_osdata_free (threads
);
693 tree
= splay_tree_new (splay_tree_int_comparator
,
695 free_vector_of_osdata_items
);
696 make_cleanup (free_splay_tree
, tree
);
699 VEC_iterate (osdata_item_s
, threads
->items
,
703 const char *pid
= get_osdata_column (item
, "pid");
704 int pid_i
= strtoul (pid
, NULL
, 0);
705 VEC (osdata_item_s
) *vec
= 0;
707 splay_tree_node n
= splay_tree_lookup (tree
, pid_i
);
710 VEC_safe_push (osdata_item_s
, vec
, item
);
711 splay_tree_insert (tree
, pid_i
, (splay_tree_value
)vec
);
715 vec
= (VEC (osdata_item_s
) *) n
->value
;
716 VEC_safe_push (osdata_item_s
, vec
, item
);
717 n
->value
= (splay_tree_value
) vec
;
722 make_cleanup_ui_out_list_begin_end (uiout
, "groups");
725 VEC_iterate (osdata_item_s
, data
->items
,
729 struct cleanup
*back_to
;
731 const char *pid
= get_osdata_column (item
, "pid");
732 const char *cmd
= get_osdata_column (item
, "command");
733 const char *user
= get_osdata_column (item
, "user");
734 const char *cores
= get_osdata_column (item
, "cores");
736 int pid_i
= strtoul (pid
, NULL
, 0);
738 /* At present, the target will return all available processes
739 and if information about specific ones was required, we filter
740 undesired processes here. */
741 if (ids
&& bsearch (&pid_i
, VEC_address (int, ids
),
742 VEC_length (int, ids
),
743 sizeof (int), compare_positive_ints
) == NULL
)
747 back_to
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
749 ui_out_field_fmt (uiout
, "id", "%s", pid
);
750 ui_out_field_string (uiout
, "type", "process");
752 ui_out_field_string (uiout
, "description", cmd
);
754 ui_out_field_string (uiout
, "user", user
);
756 output_cores (uiout
, "cores", cores
);
760 splay_tree_node n
= splay_tree_lookup (tree
, pid_i
);
763 VEC (osdata_item_s
) *children
= (VEC (osdata_item_s
) *) n
->value
;
764 struct osdata_item
*child
;
767 make_cleanup_ui_out_list_begin_end (uiout
, "threads");
770 VEC_iterate (osdata_item_s
, children
, ix_child
, child
);
773 struct cleanup
*back_to_2
=
774 make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
775 const char *tid
= get_osdata_column (child
, "tid");
776 const char *tcore
= get_osdata_column (child
, "core");
778 ui_out_field_string (uiout
, "id", tid
);
780 ui_out_field_string (uiout
, "core", tcore
);
782 do_cleanups (back_to_2
);
787 do_cleanups (back_to
);
792 mi_cmd_list_thread_groups (char *command
, char **argv
, int argc
)
794 struct ui_out
*uiout
= current_uiout
;
795 struct cleanup
*back_to
;
802 AVAILABLE_OPT
, RECURSE_OPT
804 static const struct mi_opt opts
[] =
806 {"-available", AVAILABLE_OPT
, 0},
807 {"-recurse", RECURSE_OPT
, 1},
816 int opt
= mi_getopt ("-list-thread-groups", argc
, argv
, opts
,
821 switch ((enum opt
) opt
)
827 if (strcmp (optarg
, "0") == 0)
829 else if (strcmp (optarg
, "1") == 0)
832 error (_("only '0' and '1' are valid values "
833 "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
, NULL
, 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
;
897 struct ui_out
*uiout
= current_uiout
;
900 struct cleanup
*cleanup
;
902 /* Note that the test for a valid register must include checking the
903 gdbarch_register_name because gdbarch_num_regs may be allocated for
904 the union of the register sets within a family of related processors.
905 In this case, some entries of gdbarch_register_name will change depending
906 upon the particular processor being debugged. */
908 gdbarch
= get_current_arch ();
909 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
911 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "register-names");
913 if (argc
== 0) /* No args, just do all the regs. */
919 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
920 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
921 ui_out_field_string (uiout
, NULL
, "");
923 ui_out_field_string (uiout
, NULL
,
924 gdbarch_register_name (gdbarch
, regnum
));
928 /* Else, list of register #s, just do listed regs. */
929 for (i
= 0; i
< argc
; i
++)
931 regnum
= atoi (argv
[i
]);
932 if (regnum
< 0 || regnum
>= numregs
)
933 error (_("bad register number"));
935 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
936 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
937 ui_out_field_string (uiout
, NULL
, "");
939 ui_out_field_string (uiout
, NULL
,
940 gdbarch_register_name (gdbarch
, regnum
));
942 do_cleanups (cleanup
);
946 mi_cmd_data_list_changed_registers (char *command
, char **argv
, int argc
)
948 static struct regcache
*this_regs
= NULL
;
949 struct ui_out
*uiout
= current_uiout
;
950 struct regcache
*prev_regs
;
951 struct gdbarch
*gdbarch
;
952 int regnum
, numregs
, changed
;
954 struct cleanup
*cleanup
;
956 /* The last time we visited this function, the current frame's register
957 contents were saved in THIS_REGS. Move THIS_REGS over to PREV_REGS,
958 and refresh THIS_REGS with the now-current register contents. */
960 prev_regs
= this_regs
;
961 this_regs
= frame_save_as_regcache (get_selected_frame (NULL
));
962 cleanup
= make_cleanup_regcache_xfree (prev_regs
);
964 /* Note that the test for a valid register must include checking the
965 gdbarch_register_name because gdbarch_num_regs may be allocated for
966 the union of the register sets within a family of related processors.
967 In this case, some entries of gdbarch_register_name will change depending
968 upon the particular processor being debugged. */
970 gdbarch
= get_regcache_arch (this_regs
);
971 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
973 make_cleanup_ui_out_list_begin_end (uiout
, "changed-registers");
975 if (argc
== 0) /* No args, just do all the regs. */
981 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
982 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
984 changed
= register_changed_p (regnum
, prev_regs
, this_regs
);
986 error (_("-data-list-changed-registers: "
987 "Unable to read register contents."));
989 ui_out_field_int (uiout
, NULL
, regnum
);
993 /* Else, list of register #s, just do listed regs. */
994 for (i
= 0; i
< argc
; i
++)
996 regnum
= atoi (argv
[i
]);
1000 && gdbarch_register_name (gdbarch
, regnum
) != NULL
1001 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
1003 changed
= register_changed_p (regnum
, prev_regs
, this_regs
);
1005 error (_("-data-list-changed-registers: "
1006 "Unable to read register contents."));
1008 ui_out_field_int (uiout
, NULL
, regnum
);
1011 error (_("bad register number"));
1013 do_cleanups (cleanup
);
1017 register_changed_p (int regnum
, struct regcache
*prev_regs
,
1018 struct regcache
*this_regs
)
1020 struct gdbarch
*gdbarch
= get_regcache_arch (this_regs
);
1021 gdb_byte prev_buffer
[MAX_REGISTER_SIZE
];
1022 gdb_byte this_buffer
[MAX_REGISTER_SIZE
];
1023 enum register_status prev_status
;
1024 enum register_status this_status
;
1026 /* First time through or after gdbarch change consider all registers
1028 if (!prev_regs
|| get_regcache_arch (prev_regs
) != gdbarch
)
1031 /* Get register contents and compare. */
1032 prev_status
= regcache_cooked_read (prev_regs
, regnum
, prev_buffer
);
1033 this_status
= regcache_cooked_read (this_regs
, regnum
, this_buffer
);
1035 if (this_status
!= prev_status
)
1037 else if (this_status
== REG_VALID
)
1038 return memcmp (prev_buffer
, this_buffer
,
1039 register_size (gdbarch
, regnum
)) != 0;
1044 /* Return a list of register number and value pairs. The valid
1045 arguments expected are: a letter indicating the format in which to
1046 display the registers contents. This can be one of: x (hexadecimal), d
1047 (decimal), N (natural), t (binary), o (octal), r (raw). After the
1048 format argumetn there can be a sequence of numbers, indicating which
1049 registers to fetch the content of. If the format is the only argument,
1050 a list of all the registers with their values is returned. */
1052 mi_cmd_data_list_register_values (char *command
, char **argv
, int argc
)
1054 struct ui_out
*uiout
= current_uiout
;
1055 struct frame_info
*frame
;
1056 struct gdbarch
*gdbarch
;
1057 int regnum
, numregs
, format
;
1059 struct cleanup
*list_cleanup
, *tuple_cleanup
;
1061 /* Note that the test for a valid register must include checking the
1062 gdbarch_register_name because gdbarch_num_regs may be allocated for
1063 the union of the register sets within a family of related processors.
1064 In this case, some entries of gdbarch_register_name will change depending
1065 upon the particular processor being debugged. */
1068 error (_("-data-list-register-values: Usage: "
1069 "-data-list-register-values <format> [<regnum1>...<regnumN>]"));
1071 format
= (int) argv
[0][0];
1073 frame
= get_selected_frame (NULL
);
1074 gdbarch
= get_frame_arch (frame
);
1075 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1077 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "register-values");
1079 if (argc
== 1) /* No args, beside the format: do all the regs. */
1085 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1086 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1088 tuple_cleanup
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1089 ui_out_field_int (uiout
, "number", regnum
);
1090 get_register (frame
, regnum
, format
);
1091 do_cleanups (tuple_cleanup
);
1095 /* Else, list of register #s, just do listed regs. */
1096 for (i
= 1; i
< argc
; i
++)
1098 regnum
= atoi (argv
[i
]);
1102 && gdbarch_register_name (gdbarch
, regnum
) != NULL
1103 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
1105 tuple_cleanup
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1106 ui_out_field_int (uiout
, "number", regnum
);
1107 get_register (frame
, regnum
, format
);
1108 do_cleanups (tuple_cleanup
);
1111 error (_("bad register number"));
1113 do_cleanups (list_cleanup
);
1116 /* Output one register's contents in the desired format. */
1118 get_register (struct frame_info
*frame
, int regnum
, int format
)
1120 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1121 struct ui_out
*uiout
= current_uiout
;
1123 enum lval_type lval
;
1124 struct ui_stream
*stb
;
1127 stb
= ui_out_stream_new (uiout
);
1132 val
= get_frame_register_value (frame
, regnum
);
1134 if (value_optimized_out (val
))
1135 error (_("Optimized out"));
1140 char *ptr
, buf
[1024];
1141 const gdb_byte
*valaddr
= value_contents_for_printing (val
);
1145 for (j
= 0; j
< register_size (gdbarch
, regnum
); j
++)
1147 int idx
= gdbarch_byte_order (gdbarch
) == BFD_ENDIAN_BIG
?
1148 j
: register_size (gdbarch
, regnum
) - 1 - j
;
1150 sprintf (ptr
, "%02x", (unsigned char) valaddr
[idx
]);
1153 ui_out_field_string (uiout
, "value", buf
);
1154 /*fputs_filtered (buf, gdb_stdout); */
1158 struct value_print_options opts
;
1160 get_formatted_print_options (&opts
, format
);
1162 val_print (value_type (val
),
1163 value_contents_for_printing (val
),
1164 value_embedded_offset (val
), 0,
1165 stb
->stream
, 0, val
, &opts
, current_language
);
1166 ui_out_field_stream (uiout
, "value", stb
);
1167 ui_out_stream_delete (stb
);
1171 /* Write given values into registers. The registers and values are
1172 given as pairs. The corresponding MI command is
1173 -data-write-register-values <format>
1174 [<regnum1> <value1>...<regnumN> <valueN>] */
1176 mi_cmd_data_write_register_values (char *command
, char **argv
, int argc
)
1178 struct regcache
*regcache
;
1179 struct gdbarch
*gdbarch
;
1183 /* Note that the test for a valid register must include checking the
1184 gdbarch_register_name because gdbarch_num_regs may be allocated for
1185 the union of the register sets within a family of related processors.
1186 In this case, some entries of gdbarch_register_name will change depending
1187 upon the particular processor being debugged. */
1189 regcache
= get_current_regcache ();
1190 gdbarch
= get_regcache_arch (regcache
);
1191 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1194 error (_("-data-write-register-values: Usage: -data-write-register-"
1195 "values <format> [<regnum1> <value1>...<regnumN> <valueN>]"));
1197 format
= (int) argv
[0][0];
1199 if (!target_has_registers
)
1200 error (_("-data-write-register-values: No registers."));
1203 error (_("-data-write-register-values: No regs and values specified."));
1206 error (_("-data-write-register-values: "
1207 "Regs and vals are not in pairs."));
1209 for (i
= 1; i
< argc
; i
= i
+ 2)
1211 int regnum
= atoi (argv
[i
]);
1213 if (regnum
>= 0 && regnum
< numregs
1214 && gdbarch_register_name (gdbarch
, regnum
)
1215 && *gdbarch_register_name (gdbarch
, regnum
))
1219 /* Get the value as a number. */
1220 value
= parse_and_eval_address (argv
[i
+ 1]);
1222 /* Write it down. */
1223 regcache_cooked_write_signed (regcache
, regnum
, value
);
1226 error (_("bad register number"));
1230 /* Evaluate the value of the argument. The argument is an
1231 expression. If the expression contains spaces it needs to be
1232 included in double quotes. */
1234 mi_cmd_data_evaluate_expression (char *command
, char **argv
, int argc
)
1236 struct expression
*expr
;
1237 struct cleanup
*old_chain
= NULL
;
1239 struct ui_stream
*stb
= NULL
;
1240 struct value_print_options opts
;
1241 struct ui_out
*uiout
= current_uiout
;
1243 stb
= ui_out_stream_new (uiout
);
1247 ui_out_stream_delete (stb
);
1248 error (_("-data-evaluate-expression: "
1249 "Usage: -data-evaluate-expression expression"));
1252 expr
= parse_expression (argv
[0]);
1254 old_chain
= make_cleanup (free_current_contents
, &expr
);
1256 val
= evaluate_expression (expr
);
1258 /* Print the result of the expression evaluation. */
1259 get_user_print_options (&opts
);
1261 common_val_print (val
, stb
->stream
, 0, &opts
, current_language
);
1263 ui_out_field_stream (uiout
, "value", stb
);
1264 ui_out_stream_delete (stb
);
1266 do_cleanups (old_chain
);
1269 /* DATA-MEMORY-READ:
1271 ADDR: start address of data to be dumped.
1272 WORD-FORMAT: a char indicating format for the ``word''. See
1274 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes.
1275 NR_ROW: Number of rows.
1276 NR_COL: The number of colums (words per row).
1277 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
1278 ASCHAR for unprintable characters.
1280 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
1281 displayes them. Returns:
1283 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
1286 The number of bytes read is SIZE*ROW*COL. */
1289 mi_cmd_data_read_memory (char *command
, char **argv
, int argc
)
1291 struct gdbarch
*gdbarch
= get_current_arch ();
1292 struct ui_out
*uiout
= current_uiout
;
1293 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
1299 struct type
*word_type
;
1312 static const struct mi_opt opts
[] =
1314 {"o", OFFSET_OPT
, 1},
1320 int opt
= mi_getopt ("-data-read-memory", argc
, argv
, opts
,
1325 switch ((enum opt
) opt
)
1328 offset
= atol (optarg
);
1335 if (argc
< 5 || argc
> 6)
1336 error (_("-data-read-memory: Usage: "
1337 "ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR]."));
1339 /* Extract all the arguments. */
1341 /* Start address of the memory dump. */
1342 addr
= parse_and_eval_address (argv
[0]) + offset
;
1343 /* The format character to use when displaying a memory word. See
1344 the ``x'' command. */
1345 word_format
= argv
[1][0];
1346 /* The size of the memory word. */
1347 word_size
= atol (argv
[2]);
1351 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1355 word_type
= builtin_type (gdbarch
)->builtin_int16
;
1359 word_type
= builtin_type (gdbarch
)->builtin_int32
;
1363 word_type
= builtin_type (gdbarch
)->builtin_int64
;
1367 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1370 /* The number of rows. */
1371 nr_rows
= atol (argv
[3]);
1373 error (_("-data-read-memory: invalid number of rows."));
1375 /* Number of bytes per row. */
1376 nr_cols
= atol (argv
[4]);
1378 error (_("-data-read-memory: invalid number of columns."));
1380 /* The un-printable character when printing ascii. */
1386 /* Create a buffer and read it in. */
1387 total_bytes
= word_size
* nr_rows
* nr_cols
;
1388 mbuf
= xcalloc (total_bytes
, 1);
1389 make_cleanup (xfree
, mbuf
);
1391 /* Dispatch memory reads to the topmost target, not the flattened
1393 nr_bytes
= target_read (current_target
.beneath
,
1394 TARGET_OBJECT_MEMORY
, NULL
, mbuf
,
1397 error (_("Unable to read memory."));
1399 /* Output the header information. */
1400 ui_out_field_core_addr (uiout
, "addr", gdbarch
, addr
);
1401 ui_out_field_int (uiout
, "nr-bytes", nr_bytes
);
1402 ui_out_field_int (uiout
, "total-bytes", total_bytes
);
1403 ui_out_field_core_addr (uiout
, "next-row",
1404 gdbarch
, addr
+ word_size
* nr_cols
);
1405 ui_out_field_core_addr (uiout
, "prev-row",
1406 gdbarch
, addr
- word_size
* nr_cols
);
1407 ui_out_field_core_addr (uiout
, "next-page", gdbarch
, addr
+ total_bytes
);
1408 ui_out_field_core_addr (uiout
, "prev-page", gdbarch
, addr
- total_bytes
);
1410 /* Build the result as a two dimentional table. */
1412 struct ui_stream
*stream
= ui_out_stream_new (uiout
);
1413 struct cleanup
*cleanup_list_memory
;
1417 cleanup_list_memory
= make_cleanup_ui_out_list_begin_end (uiout
, "memory");
1418 for (row
= 0, row_byte
= 0;
1420 row
++, row_byte
+= nr_cols
* word_size
)
1424 struct cleanup
*cleanup_tuple
;
1425 struct cleanup
*cleanup_list_data
;
1426 struct value_print_options opts
;
1428 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1429 ui_out_field_core_addr (uiout
, "addr", gdbarch
, addr
+ row_byte
);
1430 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr +
1432 cleanup_list_data
= make_cleanup_ui_out_list_begin_end (uiout
, "data");
1433 get_formatted_print_options (&opts
, word_format
);
1434 for (col
= 0, col_byte
= row_byte
;
1436 col
++, col_byte
+= word_size
)
1438 if (col_byte
+ word_size
> nr_bytes
)
1440 ui_out_field_string (uiout
, NULL
, "N/A");
1444 ui_file_rewind (stream
->stream
);
1445 print_scalar_formatted (mbuf
+ col_byte
, word_type
, &opts
,
1446 word_asize
, stream
->stream
);
1447 ui_out_field_stream (uiout
, NULL
, stream
);
1450 do_cleanups (cleanup_list_data
);
1455 ui_file_rewind (stream
->stream
);
1456 for (byte
= row_byte
;
1457 byte
< row_byte
+ word_size
* nr_cols
; byte
++)
1459 if (byte
>= nr_bytes
)
1461 fputc_unfiltered ('X', stream
->stream
);
1463 else if (mbuf
[byte
] < 32 || mbuf
[byte
] > 126)
1465 fputc_unfiltered (aschar
, stream
->stream
);
1468 fputc_unfiltered (mbuf
[byte
], stream
->stream
);
1470 ui_out_field_stream (uiout
, "ascii", stream
);
1472 do_cleanups (cleanup_tuple
);
1474 ui_out_stream_delete (stream
);
1475 do_cleanups (cleanup_list_memory
);
1477 do_cleanups (cleanups
);
1481 mi_cmd_data_read_memory_bytes (char *command
, char **argv
, int argc
)
1483 struct gdbarch
*gdbarch
= get_current_arch ();
1484 struct ui_out
*uiout
= current_uiout
;
1485 struct cleanup
*cleanups
;
1488 memory_read_result_s
*read_result
;
1490 VEC(memory_read_result_s
) *result
;
1498 static const struct mi_opt opts
[] =
1500 {"o", OFFSET_OPT
, 1},
1506 int opt
= mi_getopt ("-data-read-memory-bytes", argc
, argv
, opts
,
1510 switch ((enum opt
) opt
)
1513 offset
= atol (optarg
);
1521 error (_("Usage: [ -o OFFSET ] ADDR LENGTH."));
1523 addr
= parse_and_eval_address (argv
[0]) + offset
;
1524 length
= atol (argv
[1]);
1526 result
= read_memory_robust (current_target
.beneath
, addr
, length
);
1528 cleanups
= make_cleanup (free_memory_read_result_vector
, result
);
1530 if (VEC_length (memory_read_result_s
, result
) == 0)
1531 error (_("Unable to read memory."));
1533 make_cleanup_ui_out_list_begin_end (uiout
, "memory");
1535 VEC_iterate (memory_read_result_s
, result
, ix
, read_result
);
1538 struct cleanup
*t
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1542 ui_out_field_core_addr (uiout
, "begin", gdbarch
, read_result
->begin
);
1543 ui_out_field_core_addr (uiout
, "offset", gdbarch
, read_result
->begin
1545 ui_out_field_core_addr (uiout
, "end", gdbarch
, read_result
->end
);
1547 data
= xmalloc ((read_result
->end
- read_result
->begin
) * 2 + 1);
1549 for (i
= 0, p
= data
;
1550 i
< (read_result
->end
- read_result
->begin
);
1553 sprintf (p
, "%02x", read_result
->data
[i
]);
1555 ui_out_field_string (uiout
, "contents", data
);
1559 do_cleanups (cleanups
);
1563 /* DATA-MEMORY-WRITE:
1565 COLUMN_OFFSET: optional argument. Must be preceded by '-o'. The
1566 offset from the beginning of the memory grid row where the cell to
1568 ADDR: start address of the row in the memory grid where the memory
1569 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
1570 the location to write to.
1571 FORMAT: a char indicating format for the ``word''. See
1573 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
1574 VALUE: value to be written into the memory address.
1576 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
1580 mi_cmd_data_write_memory (char *command
, char **argv
, int argc
)
1582 struct gdbarch
*gdbarch
= get_current_arch ();
1583 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1587 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
1588 enough when using a compiler other than GCC. */
1591 struct cleanup
*old_chain
;
1599 static const struct mi_opt opts
[] =
1601 {"o", OFFSET_OPT
, 1},
1607 int opt
= mi_getopt ("-data-write-memory", argc
, argv
, opts
,
1612 switch ((enum opt
) opt
)
1615 offset
= atol (optarg
);
1623 error (_("-data-write-memory: Usage: "
1624 "[-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE."));
1626 /* Extract all the arguments. */
1627 /* Start address of the memory dump. */
1628 addr
= parse_and_eval_address (argv
[0]);
1629 /* The format character to use when displaying a memory word. See
1630 the ``x'' command. */
1631 word_format
= argv
[1][0];
1632 /* The size of the memory word. */
1633 word_size
= atol (argv
[2]);
1635 /* Calculate the real address of the write destination. */
1636 addr
+= (offset
* word_size
);
1638 /* Get the value as a number. */
1639 value
= parse_and_eval_address (argv
[3]);
1640 /* Get the value into an array. */
1641 buffer
= xmalloc (word_size
);
1642 old_chain
= make_cleanup (xfree
, buffer
);
1643 store_signed_integer (buffer
, word_size
, byte_order
, value
);
1644 /* Write it down to memory. */
1645 write_memory (addr
, buffer
, word_size
);
1646 /* Free the buffer. */
1647 do_cleanups (old_chain
);
1650 /* DATA-MEMORY-WRITE-RAW:
1653 DATA: string of bytes to write at that address. */
1655 mi_cmd_data_write_memory_bytes (char *command
, char **argv
, int argc
)
1661 struct cleanup
*back_to
;
1664 error (_("Usage: ADDR DATA."));
1666 addr
= parse_and_eval_address (argv
[0]);
1668 len
= strlen (cdata
)/2;
1670 data
= xmalloc (len
);
1671 back_to
= make_cleanup (xfree
, data
);
1673 for (i
= 0; i
< len
; ++i
)
1676 sscanf (cdata
+ i
* 2, "%02x", &x
);
1677 data
[i
] = (gdb_byte
)x
;
1680 r
= target_write_memory (addr
, data
, len
);
1682 error (_("Could not write memory"));
1684 do_cleanups (back_to
);
1689 mi_cmd_enable_timings (char *command
, char **argv
, int argc
)
1695 if (strcmp (argv
[0], "yes") == 0)
1697 else if (strcmp (argv
[0], "no") == 0)
1708 error (_("-enable-timings: Usage: %s {yes|no}"), command
);
1712 mi_cmd_list_features (char *command
, char **argv
, int argc
)
1716 struct cleanup
*cleanup
= NULL
;
1717 struct ui_out
*uiout
= current_uiout
;
1719 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "features");
1720 ui_out_field_string (uiout
, NULL
, "frozen-varobjs");
1721 ui_out_field_string (uiout
, NULL
, "pending-breakpoints");
1722 ui_out_field_string (uiout
, NULL
, "thread-info");
1723 ui_out_field_string (uiout
, NULL
, "data-read-memory-bytes");
1724 ui_out_field_string (uiout
, NULL
, "breakpoint-notifications");
1725 ui_out_field_string (uiout
, NULL
, "ada-task-info");
1728 ui_out_field_string (uiout
, NULL
, "python");
1731 do_cleanups (cleanup
);
1735 error (_("-list-features should be passed no arguments"));
1739 mi_cmd_list_target_features (char *command
, char **argv
, int argc
)
1743 struct cleanup
*cleanup
= NULL
;
1744 struct ui_out
*uiout
= current_uiout
;
1746 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "features");
1747 if (target_can_async_p ())
1748 ui_out_field_string (uiout
, NULL
, "async");
1749 if (target_can_execute_reverse
)
1750 ui_out_field_string (uiout
, NULL
, "reverse");
1752 do_cleanups (cleanup
);
1756 error (_("-list-target-features should be passed no arguments"));
1760 mi_cmd_add_inferior (char *command
, char **argv
, int argc
)
1762 struct inferior
*inf
;
1765 error (_("-add-inferior should be passed no arguments"));
1767 inf
= add_inferior_with_spaces ();
1769 ui_out_field_fmt (current_uiout
, "inferior", "i%d", inf
->num
);
1772 /* Callback used to find the first inferior other than the
1776 get_other_inferior (struct inferior
*inf
, void *arg
)
1778 if (inf
== current_inferior ())
1785 mi_cmd_remove_inferior (char *command
, char **argv
, int argc
)
1788 struct inferior
*inf
;
1791 error (_("-remove-inferior should be passed a single argument"));
1793 if (sscanf (argv
[0], "i%d", &id
) != 1)
1794 error (_("the thread group id is syntactically invalid"));
1796 inf
= find_inferior_id (id
);
1798 error (_("the specified thread group does not exist"));
1801 error (_("cannot remove an active inferior"));
1803 if (inf
== current_inferior ())
1805 struct thread_info
*tp
= 0;
1806 struct inferior
*new_inferior
1807 = iterate_over_inferiors (get_other_inferior
, NULL
);
1809 if (new_inferior
== NULL
)
1810 error (_("Cannot remove last inferior"));
1812 set_current_inferior (new_inferior
);
1813 if (new_inferior
->pid
!= 0)
1814 tp
= any_thread_of_process (new_inferior
->pid
);
1815 switch_to_thread (tp
? tp
->ptid
: null_ptid
);
1816 set_current_program_space (new_inferior
->pspace
);
1819 delete_inferior_1 (inf
, 1 /* silent */);
1824 /* Execute a command within a safe environment.
1825 Return <0 for error; >=0 for ok.
1827 args->action will tell mi_execute_command what action
1828 to perfrom after the given command has executed (display/suppress
1829 prompt, display error). */
1832 captured_mi_execute_command (struct ui_out
*uiout
, struct mi_parse
*context
)
1834 struct cleanup
*cleanup
;
1837 current_command_ts
= context
->cmd_start
;
1839 current_token
= xstrdup (context
->token
);
1840 cleanup
= make_cleanup (free_current_contents
, ¤t_token
);
1842 running_result_record_printed
= 0;
1844 switch (context
->op
)
1847 /* A MI command was read from the input stream. */
1849 /* FIXME: gdb_???? */
1850 fprintf_unfiltered (raw_stdout
, " token=`%s' command=`%s' args=`%s'\n",
1851 context
->token
, context
->command
, context
->args
);
1854 mi_cmd_execute (context
);
1856 /* Print the result if there were no errors.
1858 Remember that on the way out of executing a command, you have
1859 to directly use the mi_interp's uiout, since the command could
1860 have reset the interpreter, in which case the current uiout
1861 will most likely crash in the mi_out_* routines. */
1862 if (!running_result_record_printed
)
1864 fputs_unfiltered (context
->token
, raw_stdout
);
1865 /* There's no particularly good reason why target-connect results
1866 in not ^done. Should kill ^connected for MI3. */
1867 fputs_unfiltered (strcmp (context
->command
, "target-select") == 0
1868 ? "^connected" : "^done", raw_stdout
);
1869 mi_out_put (uiout
, raw_stdout
);
1870 mi_out_rewind (uiout
);
1871 mi_print_timing_maybe ();
1872 fputs_unfiltered ("\n", raw_stdout
);
1875 /* The command does not want anything to be printed. In that
1876 case, the command probably should not have written anything
1877 to uiout, but in case it has written something, discard it. */
1878 mi_out_rewind (uiout
);
1885 /* A CLI command was read from the input stream. */
1886 /* This "feature" will be removed as soon as we have a
1887 complete set of mi commands. */
1888 /* Echo the command on the console. */
1889 fprintf_unfiltered (gdb_stdlog
, "%s\n", context
->command
);
1890 /* Call the "console" interpreter. */
1891 argv
[0] = "console";
1892 argv
[1] = context
->command
;
1893 mi_cmd_interpreter_exec ("-interpreter-exec", argv
, 2);
1895 /* If we changed interpreters, DON'T print out anything. */
1896 if (current_interp_named_p (INTERP_MI
)
1897 || current_interp_named_p (INTERP_MI1
)
1898 || current_interp_named_p (INTERP_MI2
)
1899 || current_interp_named_p (INTERP_MI3
))
1901 if (!running_result_record_printed
)
1903 fputs_unfiltered (context
->token
, raw_stdout
);
1904 fputs_unfiltered ("^done", raw_stdout
);
1905 mi_out_put (uiout
, raw_stdout
);
1906 mi_out_rewind (uiout
);
1907 mi_print_timing_maybe ();
1908 fputs_unfiltered ("\n", raw_stdout
);
1911 mi_out_rewind (uiout
);
1918 do_cleanups (cleanup
);
1923 /* Print a gdb exception to the MI output stream. */
1926 mi_print_exception (const char *token
, struct gdb_exception exception
)
1928 fputs_unfiltered (token
, raw_stdout
);
1929 fputs_unfiltered ("^error,msg=\"", raw_stdout
);
1930 if (exception
.message
== NULL
)
1931 fputs_unfiltered ("unknown error", raw_stdout
);
1933 fputstr_unfiltered (exception
.message
, '"', raw_stdout
);
1934 fputs_unfiltered ("\"\n", raw_stdout
);
1938 mi_execute_command (char *cmd
, int from_tty
)
1941 struct mi_parse
*command
= NULL
;
1942 volatile struct gdb_exception exception
;
1944 /* This is to handle EOF (^D). We just quit gdb. */
1945 /* FIXME: we should call some API function here. */
1947 quit_force (NULL
, from_tty
);
1949 target_log_command (cmd
);
1951 TRY_CATCH (exception
, RETURN_MASK_ALL
)
1953 command
= mi_parse (cmd
, &token
);
1955 if (exception
.reason
< 0)
1957 mi_print_exception (token
, exception
);
1962 volatile struct gdb_exception result
;
1963 ptid_t previous_ptid
= inferior_ptid
;
1965 command
->token
= token
;
1969 command
->cmd_start
= (struct mi_timestamp
*)
1970 xmalloc (sizeof (struct mi_timestamp
));
1971 timestamp (command
->cmd_start
);
1974 TRY_CATCH (result
, RETURN_MASK_ALL
)
1976 captured_mi_execute_command (current_uiout
, command
);
1978 if (result
.reason
< 0)
1980 /* The command execution failed and error() was called
1982 mi_print_exception (command
->token
, result
);
1983 mi_out_rewind (current_uiout
);
1986 bpstat_do_actions ();
1988 if (/* The notifications are only output when the top-level
1989 interpreter (specified on the command line) is MI. */
1990 ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ()))
1991 /* Don't try report anything if there are no threads --
1992 the program is dead. */
1993 && thread_count () != 0
1994 /* -thread-select explicitly changes thread. If frontend uses that
1995 internally, we don't want to emit =thread-selected, since
1996 =thread-selected is supposed to indicate user's intentions. */
1997 && strcmp (command
->command
, "thread-select") != 0)
1999 struct mi_interp
*mi
= top_level_interpreter_data ();
2000 int report_change
= 0;
2002 if (command
->thread
== -1)
2004 report_change
= (!ptid_equal (previous_ptid
, null_ptid
)
2005 && !ptid_equal (inferior_ptid
, previous_ptid
)
2006 && !ptid_equal (inferior_ptid
, null_ptid
));
2008 else if (!ptid_equal (inferior_ptid
, null_ptid
))
2010 struct thread_info
*ti
= inferior_thread ();
2012 report_change
= (ti
->num
!= command
->thread
);
2017 struct thread_info
*ti
= inferior_thread ();
2019 target_terminal_ours ();
2020 fprintf_unfiltered (mi
->event_channel
,
2021 "thread-selected,id=\"%d\"",
2023 gdb_flush (mi
->event_channel
);
2027 mi_parse_free (command
);
2030 fputs_unfiltered ("(gdb) \n", raw_stdout
);
2031 gdb_flush (raw_stdout
);
2032 /* Print any buffered hook code. */
2037 mi_cmd_execute (struct mi_parse
*parse
)
2039 struct cleanup
*cleanup
;
2041 cleanup
= prepare_execute_command ();
2043 if (parse
->all
&& parse
->thread_group
!= -1)
2044 error (_("Cannot specify --thread-group together with --all"));
2046 if (parse
->all
&& parse
->thread
!= -1)
2047 error (_("Cannot specify --thread together with --all"));
2049 if (parse
->thread_group
!= -1 && parse
->thread
!= -1)
2050 error (_("Cannot specify --thread together with --thread-group"));
2052 if (parse
->frame
!= -1 && parse
->thread
== -1)
2053 error (_("Cannot specify --frame without --thread"));
2055 if (parse
->thread_group
!= -1)
2057 struct inferior
*inf
= find_inferior_id (parse
->thread_group
);
2058 struct thread_info
*tp
= 0;
2061 error (_("Invalid thread group for the --thread-group option"));
2063 set_current_inferior (inf
);
2064 /* This behaviour means that if --thread-group option identifies
2065 an inferior with multiple threads, then a random one will be picked.
2066 This is not a problem -- frontend should always provide --thread if
2067 it wishes to operate on a specific thread. */
2069 tp
= any_thread_of_process (inf
->pid
);
2070 switch_to_thread (tp
? tp
->ptid
: null_ptid
);
2071 set_current_program_space (inf
->pspace
);
2074 if (parse
->thread
!= -1)
2076 struct thread_info
*tp
= find_thread_id (parse
->thread
);
2079 error (_("Invalid thread id: %d"), parse
->thread
);
2081 if (is_exited (tp
->ptid
))
2082 error (_("Thread id: %d has terminated"), parse
->thread
);
2084 switch_to_thread (tp
->ptid
);
2087 if (parse
->frame
!= -1)
2089 struct frame_info
*fid
;
2090 int frame
= parse
->frame
;
2092 fid
= find_relative_frame (get_current_frame (), &frame
);
2094 /* find_relative_frame was successful */
2097 error (_("Invalid frame id: %d"), frame
);
2100 current_context
= parse
;
2102 if (strncmp (parse
->command
, "break-", sizeof ("break-") - 1 ) == 0)
2104 make_cleanup_restore_integer (&mi_suppress_breakpoint_notifications
);
2105 mi_suppress_breakpoint_notifications
= 1;
2108 if (parse
->cmd
->argv_func
!= NULL
)
2110 parse
->cmd
->argv_func (parse
->command
, parse
->argv
, parse
->argc
);
2112 else if (parse
->cmd
->cli
.cmd
!= 0)
2114 /* FIXME: DELETE THIS. */
2115 /* The operation is still implemented by a cli command. */
2116 /* Must be a synchronous one. */
2117 mi_execute_cli_command (parse
->cmd
->cli
.cmd
, parse
->cmd
->cli
.args_p
,
2122 /* FIXME: DELETE THIS. */
2123 struct ui_file
*stb
;
2125 stb
= mem_fileopen ();
2127 fputs_unfiltered ("Undefined mi command: ", stb
);
2128 fputstr_unfiltered (parse
->command
, '"', stb
);
2129 fputs_unfiltered (" (missing implementation)", stb
);
2131 make_cleanup_ui_file_delete (stb
);
2134 do_cleanups (cleanup
);
2137 /* FIXME: This is just a hack so we can get some extra commands going.
2138 We don't want to channel things through the CLI, but call libgdb directly.
2139 Use only for synchronous commands. */
2142 mi_execute_cli_command (const char *cmd
, int args_p
, const char *args
)
2146 struct cleanup
*old_cleanups
;
2150 run
= xstrprintf ("%s %s", cmd
, args
);
2152 run
= xstrdup (cmd
);
2154 /* FIXME: gdb_???? */
2155 fprintf_unfiltered (gdb_stdout
, "cli=%s run=%s\n",
2157 old_cleanups
= make_cleanup (xfree
, run
);
2158 execute_command ( /*ui */ run
, 0 /*from_tty */ );
2159 do_cleanups (old_cleanups
);
2165 mi_execute_async_cli_command (char *cli_command
, char **argv
, int argc
)
2167 struct cleanup
*old_cleanups
;
2170 if (target_can_async_p ())
2171 run
= xstrprintf ("%s %s&", cli_command
, argc
? *argv
: "");
2173 run
= xstrprintf ("%s %s", cli_command
, argc
? *argv
: "");
2174 old_cleanups
= make_cleanup (xfree
, run
);
2176 execute_command ( /*ui */ run
, 0 /*from_tty */ );
2178 /* Do this before doing any printing. It would appear that some
2179 print code leaves garbage around in the buffer. */
2180 do_cleanups (old_cleanups
);
2184 mi_load_progress (const char *section_name
,
2185 unsigned long sent_so_far
,
2186 unsigned long total_section
,
2187 unsigned long total_sent
,
2188 unsigned long grand_total
)
2190 struct timeval time_now
, delta
, update_threshold
;
2191 static struct timeval last_update
;
2192 static char *previous_sect_name
= NULL
;
2194 struct ui_out
*saved_uiout
;
2195 struct ui_out
*uiout
;
2197 /* This function is called through deprecated_show_load_progress
2198 which means uiout may not be correct. Fix it for the duration
2199 of this function. */
2200 saved_uiout
= current_uiout
;
2202 if (current_interp_named_p (INTERP_MI
)
2203 || current_interp_named_p (INTERP_MI2
))
2204 current_uiout
= mi_out_new (2);
2205 else if (current_interp_named_p (INTERP_MI1
))
2206 current_uiout
= mi_out_new (1);
2207 else if (current_interp_named_p (INTERP_MI3
))
2208 current_uiout
= mi_out_new (3);
2212 uiout
= current_uiout
;
2214 update_threshold
.tv_sec
= 0;
2215 update_threshold
.tv_usec
= 500000;
2216 gettimeofday (&time_now
, NULL
);
2218 delta
.tv_usec
= time_now
.tv_usec
- last_update
.tv_usec
;
2219 delta
.tv_sec
= time_now
.tv_sec
- last_update
.tv_sec
;
2221 if (delta
.tv_usec
< 0)
2224 delta
.tv_usec
+= 1000000L;
2227 new_section
= (previous_sect_name
?
2228 strcmp (previous_sect_name
, section_name
) : 1);
2231 struct cleanup
*cleanup_tuple
;
2233 xfree (previous_sect_name
);
2234 previous_sect_name
= xstrdup (section_name
);
2237 fputs_unfiltered (current_token
, raw_stdout
);
2238 fputs_unfiltered ("+download", raw_stdout
);
2239 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2240 ui_out_field_string (uiout
, "section", section_name
);
2241 ui_out_field_int (uiout
, "section-size", total_section
);
2242 ui_out_field_int (uiout
, "total-size", grand_total
);
2243 do_cleanups (cleanup_tuple
);
2244 mi_out_put (uiout
, raw_stdout
);
2245 fputs_unfiltered ("\n", raw_stdout
);
2246 gdb_flush (raw_stdout
);
2249 if (delta
.tv_sec
>= update_threshold
.tv_sec
&&
2250 delta
.tv_usec
>= update_threshold
.tv_usec
)
2252 struct cleanup
*cleanup_tuple
;
2254 last_update
.tv_sec
= time_now
.tv_sec
;
2255 last_update
.tv_usec
= time_now
.tv_usec
;
2257 fputs_unfiltered (current_token
, raw_stdout
);
2258 fputs_unfiltered ("+download", raw_stdout
);
2259 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2260 ui_out_field_string (uiout
, "section", section_name
);
2261 ui_out_field_int (uiout
, "section-sent", sent_so_far
);
2262 ui_out_field_int (uiout
, "section-size", total_section
);
2263 ui_out_field_int (uiout
, "total-sent", total_sent
);
2264 ui_out_field_int (uiout
, "total-size", grand_total
);
2265 do_cleanups (cleanup_tuple
);
2266 mi_out_put (uiout
, raw_stdout
);
2267 fputs_unfiltered ("\n", raw_stdout
);
2268 gdb_flush (raw_stdout
);
2272 current_uiout
= saved_uiout
;
2276 timestamp (struct mi_timestamp
*tv
)
2278 gettimeofday (&tv
->wallclock
, NULL
);
2279 #ifdef HAVE_GETRUSAGE
2280 getrusage (RUSAGE_SELF
, &rusage
);
2281 tv
->utime
.tv_sec
= rusage
.ru_utime
.tv_sec
;
2282 tv
->utime
.tv_usec
= rusage
.ru_utime
.tv_usec
;
2283 tv
->stime
.tv_sec
= rusage
.ru_stime
.tv_sec
;
2284 tv
->stime
.tv_usec
= rusage
.ru_stime
.tv_usec
;
2287 long usec
= get_run_time ();
2289 tv
->utime
.tv_sec
= usec
/1000000L;
2290 tv
->utime
.tv_usec
= usec
- 1000000L*tv
->utime
.tv_sec
;
2291 tv
->stime
.tv_sec
= 0;
2292 tv
->stime
.tv_usec
= 0;
2298 print_diff_now (struct mi_timestamp
*start
)
2300 struct mi_timestamp now
;
2303 print_diff (start
, &now
);
2307 mi_print_timing_maybe (void)
2309 /* If the command is -enable-timing then do_timings may be
2310 true whilst current_command_ts is not initialized. */
2311 if (do_timings
&& current_command_ts
)
2312 print_diff_now (current_command_ts
);
2316 timeval_diff (struct timeval start
, struct timeval end
)
2318 return ((end
.tv_sec
- start
.tv_sec
) * 1000000L)
2319 + (end
.tv_usec
- start
.tv_usec
);
2323 print_diff (struct mi_timestamp
*start
, struct mi_timestamp
*end
)
2327 ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
2328 timeval_diff (start
->wallclock
, end
->wallclock
) / 1000000.0,
2329 timeval_diff (start
->utime
, end
->utime
) / 1000000.0,
2330 timeval_diff (start
->stime
, end
->stime
) / 1000000.0);
2334 mi_cmd_trace_define_variable (char *command
, char **argv
, int argc
)
2336 struct expression
*expr
;
2337 struct cleanup
*back_to
;
2338 LONGEST initval
= 0;
2339 struct trace_state_variable
*tsv
;
2342 if (argc
!= 1 && argc
!= 2)
2343 error (_("Usage: -trace-define-variable VARIABLE [VALUE]"));
2345 expr
= parse_expression (argv
[0]);
2346 back_to
= make_cleanup (xfree
, expr
);
2348 if (expr
->nelts
== 3 && expr
->elts
[0].opcode
== OP_INTERNALVAR
)
2350 struct internalvar
*intvar
= expr
->elts
[1].internalvar
;
2353 name
= internalvar_name (intvar
);
2356 if (!name
|| *name
== '\0')
2357 error (_("Invalid name of trace variable"));
2359 tsv
= find_trace_state_variable (name
);
2361 tsv
= create_trace_state_variable (name
);
2364 initval
= value_as_long (parse_and_eval (argv
[1]));
2366 tsv
->initial_value
= initval
;
2368 do_cleanups (back_to
);
2372 mi_cmd_trace_list_variables (char *command
, char **argv
, int argc
)
2375 error (_("-trace-list-variables: no arguments are allowed"));
2377 tvariables_info_1 ();
2381 mi_cmd_trace_find (char *command
, char **argv
, int argc
)
2386 error (_("trace selection mode is required"));
2390 if (strcmp (mode
, "none") == 0)
2392 tfind_1 (tfind_number
, -1, 0, 0, 0);
2396 if (current_trace_status ()->running
)
2397 error (_("May not look at trace frames while trace is running."));
2399 if (strcmp (mode
, "frame-number") == 0)
2402 error (_("frame number is required"));
2403 tfind_1 (tfind_number
, atoi (argv
[1]), 0, 0, 0);
2405 else if (strcmp (mode
, "tracepoint-number") == 0)
2408 error (_("tracepoint number is required"));
2409 tfind_1 (tfind_tp
, atoi (argv
[1]), 0, 0, 0);
2411 else if (strcmp (mode
, "pc") == 0)
2414 error (_("PC is required"));
2415 tfind_1 (tfind_pc
, 0, parse_and_eval_address (argv
[1]), 0, 0);
2417 else if (strcmp (mode
, "pc-inside-range") == 0)
2420 error (_("Start and end PC are required"));
2421 tfind_1 (tfind_range
, 0, parse_and_eval_address (argv
[1]),
2422 parse_and_eval_address (argv
[2]), 0);
2424 else if (strcmp (mode
, "pc-outside-range") == 0)
2427 error (_("Start and end PC are required"));
2428 tfind_1 (tfind_outside
, 0, parse_and_eval_address (argv
[1]),
2429 parse_and_eval_address (argv
[2]), 0);
2431 else if (strcmp (mode
, "line") == 0)
2433 struct symtabs_and_lines sals
;
2434 struct symtab_and_line sal
;
2435 static CORE_ADDR start_pc
, end_pc
;
2436 struct cleanup
*back_to
;
2439 error (_("Line is required"));
2441 sals
= decode_line_spec (argv
[1], DECODE_LINE_FUNFIRSTLINE
);
2442 back_to
= make_cleanup (xfree
, sals
.sals
);
2446 if (sal
.symtab
== 0)
2447 error (_("Could not find the specified line"));
2449 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2450 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, 0);
2452 error (_("Could not find the specified line"));
2454 do_cleanups (back_to
);
2457 error (_("Invalid mode '%s'"), mode
);
2459 if (has_stack_frames () || get_traceframe_number () >= 0)
2461 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
2466 mi_cmd_trace_save (char *command
, char **argv
, int argc
)
2468 int target_saves
= 0;
2471 if (argc
!= 1 && argc
!= 2)
2472 error (_("Usage: -trace-save [-r] filename"));
2477 if (strcmp (argv
[0], "-r") == 0)
2480 error (_("Invalid option: %s"), argv
[0]);
2487 trace_save (filename
, target_saves
);
2492 mi_cmd_trace_start (char *command
, char **argv
, int argc
)
2494 start_tracing (NULL
);
2498 mi_cmd_trace_status (char *command
, char **argv
, int argc
)
2500 trace_status_mi (0);
2504 mi_cmd_trace_stop (char *command
, char **argv
, int argc
)
2506 stop_tracing (NULL
);
2507 trace_status_mi (1);
2510 /* Implement the "-ada-task-info" GDB/MI command. */
2513 mi_cmd_ada_task_info (char *command
, char **argv
, int argc
)
2515 if (argc
!= 0 && argc
!= 1)
2516 error (_("Invalid MI command"));
2518 print_ada_task_info (current_uiout
, argv
[0], current_inferior ());