3 Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010
4 Free Software Foundation, Inc.
6 Contributed by Cygnus Solutions (a Red Hat company).
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 /* Work in progress. */
26 #include "arch-utils.h"
29 #include "gdb_string.h"
30 #include "exceptions.h"
32 #include "gdbthread.h"
35 #include "mi-getopt.h"
36 #include "mi-console.h"
40 #include "event-loop.h"
41 #include "event-top.h"
42 #include "gdbcore.h" /* For write_memory(). */
48 #include "mi-common.h"
53 #include "splay-tree.h"
54 #include "tracepoint.h"
59 #if defined HAVE_SYS_RESOURCE_H
60 #include <sys/resource.h>
73 struct ui_file
*raw_stdout
;
75 /* This is used to pass the current command timestamp
76 down to continuation routines. */
77 static struct mi_timestamp
*current_command_ts
;
79 static int do_timings
= 0;
82 /* Few commands would like to know if options like --thread-group
83 were explicitly specified. This variable keeps the current
84 parsed command including all option, and make it possible. */
85 static struct mi_parse
*current_context
;
87 int running_result_record_printed
= 1;
89 /* Flag indicating that the target has proceeded since the last
90 command was issued. */
93 extern void _initialize_mi_main (void);
94 static void mi_cmd_execute (struct mi_parse
*parse
);
96 static void mi_execute_cli_command (const char *cmd
, int args_p
,
98 static void mi_execute_async_cli_command (char *cli_command
,
99 char **argv
, int argc
);
100 static int register_changed_p (int regnum
, struct regcache
*,
102 static void get_register (struct frame_info
*, int regnum
, int format
);
104 /* Command implementations. FIXME: Is this libgdb? No. This is the MI
105 layer that calls libgdb. Any operation used in the below should be
108 static void timestamp (struct mi_timestamp
*tv
);
110 static void print_diff_now (struct mi_timestamp
*start
);
111 static void print_diff (struct mi_timestamp
*start
, struct mi_timestamp
*end
);
114 mi_cmd_gdb_exit (char *command
, char **argv
, int argc
)
116 /* We have to print everything right here because we never return. */
118 fputs_unfiltered (current_token
, raw_stdout
);
119 fputs_unfiltered ("^exit\n", raw_stdout
);
120 mi_out_put (uiout
, raw_stdout
);
121 gdb_flush (raw_stdout
);
122 /* FIXME: The function called is not yet a formal libgdb function. */
123 quit_force (NULL
, FROM_TTY
);
127 mi_cmd_exec_next (char *command
, char **argv
, int argc
)
129 /* FIXME: Should call a libgdb function, not a cli wrapper. */
130 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
131 mi_execute_async_cli_command ("reverse-next", argv
+ 1, argc
- 1);
133 mi_execute_async_cli_command ("next", argv
, argc
);
137 mi_cmd_exec_next_instruction (char *command
, char **argv
, int argc
)
139 /* FIXME: Should call a libgdb function, not a cli wrapper. */
140 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
141 mi_execute_async_cli_command ("reverse-nexti", argv
+ 1, argc
- 1);
143 mi_execute_async_cli_command ("nexti", argv
, argc
);
147 mi_cmd_exec_step (char *command
, char **argv
, int argc
)
149 /* FIXME: Should call a libgdb function, not a cli wrapper. */
150 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
151 mi_execute_async_cli_command ("reverse-step", argv
+ 1, argc
- 1);
153 mi_execute_async_cli_command ("step", argv
, argc
);
157 mi_cmd_exec_step_instruction (char *command
, char **argv
, int argc
)
159 /* FIXME: Should call a libgdb function, not a cli wrapper. */
160 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
161 mi_execute_async_cli_command ("reverse-stepi", argv
+ 1, argc
- 1);
163 mi_execute_async_cli_command ("stepi", argv
, argc
);
167 mi_cmd_exec_finish (char *command
, char **argv
, int argc
)
169 /* FIXME: Should call a libgdb function, not a cli wrapper. */
170 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
171 mi_execute_async_cli_command ("reverse-finish", argv
+ 1, argc
- 1);
173 mi_execute_async_cli_command ("finish", argv
, argc
);
177 mi_cmd_exec_return (char *command
, char **argv
, int argc
)
179 /* This command doesn't really execute the target, it just pops the
180 specified number of frames. */
182 /* Call return_command with from_tty argument equal to 0 so as to
183 avoid being queried. */
184 return_command (*argv
, 0);
186 /* Call return_command with from_tty argument equal to 0 so as to
187 avoid being queried. */
188 return_command (NULL
, 0);
190 /* Because we have called return_command with from_tty = 0, we need
191 to print the frame here. */
192 print_stack_frame (get_selected_frame (NULL
), 1, LOC_AND_ADDRESS
);
196 mi_cmd_exec_jump (char *args
, char **argv
, int argc
)
198 /* FIXME: Should call a libgdb function, not a cli wrapper. */
199 mi_execute_async_cli_command ("jump", argv
, argc
);
203 proceed_thread (struct thread_info
*thread
, int pid
)
205 if (!is_stopped (thread
->ptid
))
208 if (pid
!= 0 && PIDGET (thread
->ptid
) != pid
)
211 switch_to_thread (thread
->ptid
);
212 clear_proceed_status ();
213 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 0);
218 proceed_thread_callback (struct thread_info
*thread
, void *arg
)
220 int pid
= *(int *)arg
;
222 proceed_thread (thread
, pid
);
227 exec_continue (char **argv
, int argc
)
231 /* In non-stop mode, 'resume' always resumes a single thread. Therefore,
232 to resume all threads of the current inferior, or all threads in all
233 inferiors, we need to iterate over threads.
235 See comment on infcmd.c:proceed_thread_callback for rationale. */
236 if (current_context
->all
|| current_context
->thread_group
!= -1)
239 struct cleanup
*back_to
= make_cleanup_restore_current_thread ();
241 if (!current_context
->all
)
243 struct inferior
*inf
= find_inferior_id (current_context
->thread_group
);
246 iterate_over_threads (proceed_thread_callback
, &pid
);
247 do_cleanups (back_to
);
256 struct cleanup
*back_to
= make_cleanup_restore_integer (&sched_multi
);
258 if (current_context
->all
)
265 /* In all-stop mode, -exec-continue traditionally resumed either
266 all threads, or one thread, depending on the 'scheduler-locking'
267 variable. Let's continue to do the same. */
270 do_cleanups (back_to
);
275 exec_direction_forward (void *notused
)
277 execution_direction
= EXEC_FORWARD
;
281 exec_reverse_continue (char **argv
, int argc
)
283 enum exec_direction_kind dir
= execution_direction
;
284 struct cleanup
*old_chain
;
286 if (dir
== EXEC_ERROR
)
287 error (_("Target %s does not support this command."), target_shortname
);
289 if (dir
== EXEC_REVERSE
)
290 error (_("Already in reverse mode."));
292 if (!target_can_execute_reverse
)
293 error (_("Target %s does not support this command."), target_shortname
);
295 old_chain
= make_cleanup (exec_direction_forward
, NULL
);
296 execution_direction
= EXEC_REVERSE
;
297 exec_continue (argv
, argc
);
298 do_cleanups (old_chain
);
302 mi_cmd_exec_continue (char *command
, char **argv
, int argc
)
304 if (argc
> 0 && strcmp (argv
[0], "--reverse") == 0)
305 exec_reverse_continue (argv
+ 1, argc
- 1);
307 exec_continue (argv
, argc
);
311 interrupt_thread_callback (struct thread_info
*thread
, void *arg
)
313 int pid
= *(int *)arg
;
315 if (!is_running (thread
->ptid
))
318 if (PIDGET (thread
->ptid
) != pid
)
321 target_stop (thread
->ptid
);
325 /* Interrupt the execution of the target. Note how we must play around
326 with the token variables, in order to display the current token in
327 the result of the interrupt command, and the previous execution
328 token when the target finally stops. See comments in
331 mi_cmd_exec_interrupt (char *command
, char **argv
, int argc
)
333 /* In all-stop mode, everything stops, so we don't need to try
334 anything specific. */
337 interrupt_target_1 (0);
341 if (current_context
->all
)
343 /* This will interrupt all threads in all inferiors. */
344 interrupt_target_1 (1);
346 else if (current_context
->thread_group
!= -1)
348 struct inferior
*inf
= find_inferior_id (current_context
->thread_group
);
350 iterate_over_threads (interrupt_thread_callback
, &inf
->pid
);
354 /* Interrupt just the current thread -- either explicitly
355 specified via --thread or whatever was current before
356 MI command was sent. */
357 interrupt_target_1 (0);
362 run_one_inferior (struct inferior
*inf
, void *arg
)
366 if (inf
->pid
!= ptid_get_pid (inferior_ptid
))
368 struct thread_info
*tp
;
370 tp
= any_thread_of_process (inf
->pid
);
372 error (_("Inferior has no threads."));
374 switch_to_thread (tp
->ptid
);
379 set_current_inferior (inf
);
380 switch_to_thread (null_ptid
);
381 set_current_program_space (inf
->pspace
);
383 mi_execute_cli_command ("run", target_can_async_p (),
384 target_can_async_p () ? "&" : NULL
);
389 mi_cmd_exec_run (char *command
, char **argv
, int argc
)
391 if (current_context
->all
)
393 struct cleanup
*back_to
= save_current_space_and_thread ();
395 iterate_over_inferiors (run_one_inferior
, NULL
);
396 do_cleanups (back_to
);
400 mi_execute_cli_command ("run", target_can_async_p (),
401 target_can_async_p () ? "&" : NULL
);
407 find_thread_of_process (struct thread_info
*ti
, void *p
)
411 if (PIDGET (ti
->ptid
) == pid
&& !is_exited (ti
->ptid
))
418 mi_cmd_target_detach (char *command
, char **argv
, int argc
)
420 if (argc
!= 0 && argc
!= 1)
421 error ("Usage: -target-detach [thread-group]");
425 struct thread_info
*tp
;
427 int pid
= strtol (argv
[0], &end
, 10);
430 error (_("Cannot parse thread group id '%s'"), argv
[0]);
432 /* Pick any thread in the desired process. Current
433 target_detach deteches from the parent of inferior_ptid. */
434 tp
= iterate_over_threads (find_thread_of_process
, &pid
);
436 error (_("Thread group is empty"));
438 switch_to_thread (tp
->ptid
);
441 detach_command (NULL
, 0);
445 mi_cmd_thread_select (char *command
, char **argv
, int argc
)
448 char *mi_error_message
;
451 error ("mi_cmd_thread_select: USAGE: threadnum.");
453 rc
= gdb_thread_select (uiout
, argv
[0], &mi_error_message
);
455 if (rc
== GDB_RC_FAIL
)
457 make_cleanup (xfree
, mi_error_message
);
458 error ("%s", mi_error_message
);
463 mi_cmd_thread_list_ids (char *command
, char **argv
, int argc
)
466 char *mi_error_message
;
469 error ("mi_cmd_thread_list_ids: No arguments required.");
471 rc
= gdb_list_thread_ids (uiout
, &mi_error_message
);
473 if (rc
== GDB_RC_FAIL
)
475 make_cleanup (xfree
, mi_error_message
);
476 error ("%s", mi_error_message
);
481 mi_cmd_thread_info (char *command
, char **argv
, int argc
)
485 if (argc
!= 0 && argc
!= 1)
486 error ("Invalid MI command");
489 thread
= atoi (argv
[0]);
491 print_thread_info (uiout
, thread
, -1);
494 struct collect_cores_data
502 collect_cores (struct thread_info
*ti
, void *xdata
)
504 struct collect_cores_data
*data
= xdata
;
506 if (ptid_get_pid (ti
->ptid
) == data
->pid
)
508 int core
= target_core_of_thread (ti
->ptid
);
511 VEC_safe_push (int, data
->cores
, core
);
518 unique (int *b
, int *e
)
528 struct print_one_inferior_data
531 VEC (int) *inferiors
;
535 print_one_inferior (struct inferior
*inferior
, void *xdata
)
537 struct print_one_inferior_data
*top_data
= xdata
;
539 if (VEC_empty (int, top_data
->inferiors
)
540 || bsearch (&(inferior
->pid
), VEC_address (int, top_data
->inferiors
),
541 VEC_length (int, top_data
->inferiors
), sizeof (int),
542 compare_positive_ints
))
544 struct collect_cores_data data
;
545 struct cleanup
*back_to
546 = make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
548 ui_out_field_fmt (uiout
, "id", "i%d", inferior
->num
);
549 ui_out_field_string (uiout
, "type", "process");
550 if (inferior
->pid
!= 0)
551 ui_out_field_int (uiout
, "pid", inferior
->pid
);
553 if (inferior
->pspace
->ebfd
)
555 ui_out_field_string (uiout
, "executable",
556 bfd_get_filename (inferior
->pspace
->ebfd
));
560 if (inferior
->pid
!= 0)
562 data
.pid
= inferior
->pid
;
563 iterate_over_threads (collect_cores
, &data
);
566 if (!VEC_empty (int, data
.cores
))
569 struct cleanup
*back_to_2
=
570 make_cleanup_ui_out_list_begin_end (uiout
, "cores");
572 qsort (VEC_address (int, data
.cores
),
573 VEC_length (int, data
.cores
), sizeof (int),
574 compare_positive_ints
);
576 b
= VEC_address (int, data
.cores
);
577 e
= b
+ VEC_length (int, data
.cores
);
581 ui_out_field_int (uiout
, NULL
, *b
);
583 do_cleanups (back_to_2
);
586 if (top_data
->recurse
)
587 print_thread_info (uiout
, -1, inferior
->pid
);
589 do_cleanups (back_to
);
595 /* Output a field named 'cores' with a list as the value. The elements of
596 the list are obtained by splitting 'cores' on comma. */
599 output_cores (struct ui_out
*uiout
, const char *field_name
, const char *xcores
)
601 struct cleanup
*back_to
= make_cleanup_ui_out_list_begin_end (uiout
,
603 char *cores
= xstrdup (xcores
);
606 make_cleanup (xfree
, cores
);
608 for (p
= strtok (p
, ","); p
; p
= strtok (NULL
, ","))
609 ui_out_field_string (uiout
, NULL
, p
);
611 do_cleanups (back_to
);
615 free_vector_of_ints (void *xvector
)
617 VEC (int) **vector
= xvector
;
619 VEC_free (int, *vector
);
623 do_nothing (splay_tree_key k
)
628 free_vector_of_osdata_items (splay_tree_value xvalue
)
630 VEC (osdata_item_s
) *value
= (VEC (osdata_item_s
) *) xvalue
;
632 /* We don't free the items itself, it will be done separately. */
633 VEC_free (osdata_item_s
, value
);
637 splay_tree_int_comparator (splay_tree_key xa
, splay_tree_key xb
)
646 free_splay_tree (void *xt
)
649 splay_tree_delete (t
);
653 list_available_thread_groups (VEC (int) *ids
, int recurse
)
656 struct osdata_item
*item
;
659 /* This keeps a map from integer (pid) to VEC (struct osdata_item *)*
660 The vector contains information about all threads for the given pid.
661 This is assigned an initial value to avoid "may be used uninitialized"
663 splay_tree tree
= NULL
;
665 /* get_osdata will throw if it cannot return data. */
666 data
= get_osdata ("processes");
667 make_cleanup_osdata_free (data
);
671 struct osdata
*threads
= get_osdata ("threads");
673 make_cleanup_osdata_free (threads
);
674 tree
= splay_tree_new (splay_tree_int_comparator
,
676 free_vector_of_osdata_items
);
677 make_cleanup (free_splay_tree
, tree
);
680 VEC_iterate (osdata_item_s
, threads
->items
,
684 const char *pid
= get_osdata_column (item
, "pid");
685 int pid_i
= strtoul (pid
, NULL
, 0);
686 VEC (osdata_item_s
) *vec
= 0;
688 splay_tree_node n
= splay_tree_lookup (tree
, pid_i
);
691 VEC_safe_push (osdata_item_s
, vec
, item
);
692 splay_tree_insert (tree
, pid_i
, (splay_tree_value
)vec
);
696 vec
= (VEC (osdata_item_s
) *) n
->value
;
697 VEC_safe_push (osdata_item_s
, vec
, item
);
698 n
->value
= (splay_tree_value
) vec
;
703 make_cleanup_ui_out_list_begin_end (uiout
, "groups");
706 VEC_iterate (osdata_item_s
, data
->items
,
710 struct cleanup
*back_to
;
712 const char *pid
= get_osdata_column (item
, "pid");
713 const char *cmd
= get_osdata_column (item
, "command");
714 const char *user
= get_osdata_column (item
, "user");
715 const char *cores
= get_osdata_column (item
, "cores");
717 int pid_i
= strtoul (pid
, NULL
, 0);
719 /* At present, the target will return all available processes
720 and if information about specific ones was required, we filter
721 undesired processes here. */
722 if (ids
&& bsearch (&pid_i
, VEC_address (int, ids
),
723 VEC_length (int, ids
),
724 sizeof (int), compare_positive_ints
) == NULL
)
728 back_to
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
730 ui_out_field_fmt (uiout
, "id", "%s", pid
);
731 ui_out_field_string (uiout
, "type", "process");
733 ui_out_field_string (uiout
, "description", cmd
);
735 ui_out_field_string (uiout
, "user", user
);
737 output_cores (uiout
, "cores", cores
);
741 splay_tree_node n
= splay_tree_lookup (tree
, pid_i
);
744 VEC (osdata_item_s
) *children
= (VEC (osdata_item_s
) *) n
->value
;
745 struct osdata_item
*child
;
748 make_cleanup_ui_out_list_begin_end (uiout
, "threads");
751 VEC_iterate (osdata_item_s
, children
, ix_child
, child
);
754 struct cleanup
*back_to_2
=
755 make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
756 const char *tid
= get_osdata_column (child
, "tid");
757 const char *tcore
= get_osdata_column (child
, "core");
759 ui_out_field_string (uiout
, "id", tid
);
761 ui_out_field_string (uiout
, "core", tcore
);
763 do_cleanups (back_to_2
);
768 do_cleanups (back_to
);
773 mi_cmd_list_thread_groups (char *command
, char **argv
, int argc
)
775 struct cleanup
*back_to
;
782 AVAILABLE_OPT
, RECURSE_OPT
784 static struct mi_opt opts
[] =
786 {"-available", AVAILABLE_OPT
, 0},
787 {"-recurse", RECURSE_OPT
, 1},
796 int opt
= mi_getopt ("-list-thread-groups", argc
, argv
, opts
,
801 switch ((enum opt
) opt
)
807 if (strcmp (optarg
, "0") == 0)
809 else if (strcmp (optarg
, "1") == 0)
812 error ("only '0' and '1' are valid values for the '--recurse' option");
817 for (; optind
< argc
; ++optind
)
820 int inf
= strtoul (argv
[optind
], &end
, 0);
823 error ("invalid group id '%s'", argv
[optind
]);
824 VEC_safe_push (int, ids
, inf
);
826 if (VEC_length (int, ids
) > 1)
827 qsort (VEC_address (int, ids
),
828 VEC_length (int, ids
),
829 sizeof (int), compare_positive_ints
);
831 back_to
= make_cleanup (free_vector_of_ints
, &ids
);
835 list_available_thread_groups (ids
, recurse
);
837 else if (VEC_length (int, ids
) == 1)
839 /* Local thread groups, single id. */
840 int pid
= *VEC_address (int, ids
);
842 if (!in_inferior_list (pid
))
843 error ("Invalid thread group id '%d'", pid
);
844 print_thread_info (uiout
, -1, pid
);
848 struct print_one_inferior_data data
;
850 data
.recurse
= recurse
;
851 data
.inferiors
= ids
;
853 /* Local thread groups. Either no explicit ids -- and we
854 print everything, or several explicit ids. In both cases,
855 we print more than one group, and have to use 'groups'
856 as the top-level element. */
857 make_cleanup_ui_out_list_begin_end (uiout
, "groups");
858 update_thread_list ();
859 iterate_over_inferiors (print_one_inferior
, &data
);
862 do_cleanups (back_to
);
866 mi_cmd_data_list_register_names (char *command
, char **argv
, int argc
)
868 struct gdbarch
*gdbarch
;
871 struct cleanup
*cleanup
;
873 /* Note that the test for a valid register must include checking the
874 gdbarch_register_name because gdbarch_num_regs may be allocated for
875 the union of the register sets within a family of related processors.
876 In this case, some entries of gdbarch_register_name will change depending
877 upon the particular processor being debugged. */
879 gdbarch
= get_current_arch ();
880 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
882 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "register-names");
884 if (argc
== 0) /* No args, just do all the regs. */
890 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
891 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
892 ui_out_field_string (uiout
, NULL
, "");
894 ui_out_field_string (uiout
, NULL
,
895 gdbarch_register_name (gdbarch
, regnum
));
899 /* Else, list of register #s, just do listed regs. */
900 for (i
= 0; i
< argc
; i
++)
902 regnum
= atoi (argv
[i
]);
903 if (regnum
< 0 || regnum
>= numregs
)
904 error ("bad register number");
906 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
907 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
908 ui_out_field_string (uiout
, NULL
, "");
910 ui_out_field_string (uiout
, NULL
,
911 gdbarch_register_name (gdbarch
, regnum
));
913 do_cleanups (cleanup
);
917 mi_cmd_data_list_changed_registers (char *command
, char **argv
, int argc
)
919 static struct regcache
*this_regs
= NULL
;
920 struct regcache
*prev_regs
;
921 struct gdbarch
*gdbarch
;
922 int regnum
, numregs
, changed
;
924 struct cleanup
*cleanup
;
926 /* The last time we visited this function, the current frame's register
927 contents were saved in THIS_REGS. Move THIS_REGS over to PREV_REGS,
928 and refresh THIS_REGS with the now-current register contents. */
930 prev_regs
= this_regs
;
931 this_regs
= frame_save_as_regcache (get_selected_frame (NULL
));
932 cleanup
= make_cleanup_regcache_xfree (prev_regs
);
934 /* Note that the test for a valid register must include checking the
935 gdbarch_register_name because gdbarch_num_regs may be allocated for
936 the union of the register sets within a family of related processors.
937 In this case, some entries of gdbarch_register_name will change depending
938 upon the particular processor being debugged. */
940 gdbarch
= get_regcache_arch (this_regs
);
941 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
943 make_cleanup_ui_out_list_begin_end (uiout
, "changed-registers");
945 if (argc
== 0) /* No args, just do all the regs. */
951 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
952 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
954 changed
= register_changed_p (regnum
, prev_regs
, this_regs
);
956 error ("mi_cmd_data_list_changed_registers: Unable to read register contents.");
958 ui_out_field_int (uiout
, NULL
, regnum
);
962 /* Else, list of register #s, just do listed regs. */
963 for (i
= 0; i
< argc
; i
++)
965 regnum
= atoi (argv
[i
]);
969 && gdbarch_register_name (gdbarch
, regnum
) != NULL
970 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
972 changed
= register_changed_p (regnum
, prev_regs
, this_regs
);
974 error ("mi_cmd_data_list_register_change: Unable to read register contents.");
976 ui_out_field_int (uiout
, NULL
, regnum
);
979 error ("bad register number");
981 do_cleanups (cleanup
);
985 register_changed_p (int regnum
, struct regcache
*prev_regs
,
986 struct regcache
*this_regs
)
988 struct gdbarch
*gdbarch
= get_regcache_arch (this_regs
);
989 gdb_byte prev_buffer
[MAX_REGISTER_SIZE
];
990 gdb_byte this_buffer
[MAX_REGISTER_SIZE
];
992 /* Registers not valid in this frame return count as unchanged. */
993 if (!regcache_valid_p (this_regs
, regnum
))
996 /* First time through or after gdbarch change consider all registers as
997 changed. Same for registers not valid in the previous frame. */
998 if (!prev_regs
|| get_regcache_arch (prev_regs
) != gdbarch
999 || !regcache_valid_p (prev_regs
, regnum
))
1002 /* Get register contents and compare. */
1003 regcache_cooked_read (prev_regs
, regnum
, prev_buffer
);
1004 regcache_cooked_read (this_regs
, regnum
, this_buffer
);
1006 return memcmp (prev_buffer
, this_buffer
,
1007 register_size (gdbarch
, regnum
)) != 0;
1010 /* Return a list of register number and value pairs. The valid
1011 arguments expected are: a letter indicating the format in which to
1012 display the registers contents. This can be one of: x (hexadecimal), d
1013 (decimal), N (natural), t (binary), o (octal), r (raw). After the
1014 format argumetn there can be a sequence of numbers, indicating which
1015 registers to fetch the content of. If the format is the only argument,
1016 a list of all the registers with their values is returned. */
1018 mi_cmd_data_list_register_values (char *command
, char **argv
, int argc
)
1020 struct frame_info
*frame
;
1021 struct gdbarch
*gdbarch
;
1022 int regnum
, numregs
, format
;
1024 struct cleanup
*list_cleanup
, *tuple_cleanup
;
1026 /* Note that the test for a valid register must include checking the
1027 gdbarch_register_name because gdbarch_num_regs may be allocated for
1028 the union of the register sets within a family of related processors.
1029 In this case, some entries of gdbarch_register_name will change depending
1030 upon the particular processor being debugged. */
1033 error ("mi_cmd_data_list_register_values: Usage: -data-list-register-values <format> [<regnum1>...<regnumN>]");
1035 format
= (int) argv
[0][0];
1037 frame
= get_selected_frame (NULL
);
1038 gdbarch
= get_frame_arch (frame
);
1039 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1041 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "register-values");
1043 if (argc
== 1) /* No args, beside the format: do all the regs. */
1049 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1050 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1052 tuple_cleanup
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1053 ui_out_field_int (uiout
, "number", regnum
);
1054 get_register (frame
, regnum
, format
);
1055 do_cleanups (tuple_cleanup
);
1059 /* Else, list of register #s, just do listed regs. */
1060 for (i
= 1; i
< argc
; i
++)
1062 regnum
= atoi (argv
[i
]);
1066 && gdbarch_register_name (gdbarch
, regnum
) != NULL
1067 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
1069 tuple_cleanup
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1070 ui_out_field_int (uiout
, "number", regnum
);
1071 get_register (frame
, regnum
, format
);
1072 do_cleanups (tuple_cleanup
);
1075 error ("bad register number");
1077 do_cleanups (list_cleanup
);
1080 /* Output one register's contents in the desired format. */
1082 get_register (struct frame_info
*frame
, int regnum
, int format
)
1084 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1085 gdb_byte buffer
[MAX_REGISTER_SIZE
];
1089 enum lval_type lval
;
1090 static struct ui_stream
*stb
= NULL
;
1092 stb
= ui_out_stream_new (uiout
);
1097 frame_register (frame
, regnum
, &optim
, &lval
, &addr
, &realnum
, buffer
);
1100 error ("Optimized out");
1105 char *ptr
, buf
[1024];
1109 for (j
= 0; j
< register_size (gdbarch
, regnum
); j
++)
1111 int idx
= gdbarch_byte_order (gdbarch
) == BFD_ENDIAN_BIG
?
1112 j
: register_size (gdbarch
, regnum
) - 1 - j
;
1114 sprintf (ptr
, "%02x", (unsigned char) buffer
[idx
]);
1117 ui_out_field_string (uiout
, "value", buf
);
1118 /*fputs_filtered (buf, gdb_stdout); */
1122 struct value_print_options opts
;
1124 get_formatted_print_options (&opts
, format
);
1126 val_print (register_type (gdbarch
, regnum
), buffer
, 0, 0,
1127 stb
->stream
, 0, &opts
, current_language
);
1128 ui_out_field_stream (uiout
, "value", stb
);
1129 ui_out_stream_delete (stb
);
1133 /* Write given values into registers. The registers and values are
1134 given as pairs. The corresponding MI command is
1135 -data-write-register-values <format> [<regnum1> <value1>...<regnumN> <valueN>]*/
1137 mi_cmd_data_write_register_values (char *command
, char **argv
, int argc
)
1139 struct regcache
*regcache
;
1140 struct gdbarch
*gdbarch
;
1144 /* Note that the test for a valid register must include checking the
1145 gdbarch_register_name because gdbarch_num_regs may be allocated for
1146 the union of the register sets within a family of related processors.
1147 In this case, some entries of gdbarch_register_name will change depending
1148 upon the particular processor being debugged. */
1150 regcache
= get_current_regcache ();
1151 gdbarch
= get_regcache_arch (regcache
);
1152 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1155 error ("mi_cmd_data_write_register_values: Usage: -data-write-register-values <format> [<regnum1> <value1>...<regnumN> <valueN>]");
1157 format
= (int) argv
[0][0];
1159 if (!target_has_registers
)
1160 error ("mi_cmd_data_write_register_values: No registers.");
1163 error ("mi_cmd_data_write_register_values: No regs and values specified.");
1166 error ("mi_cmd_data_write_register_values: Regs and vals are not in pairs.");
1168 for (i
= 1; i
< argc
; i
= i
+ 2)
1170 int regnum
= atoi (argv
[i
]);
1172 if (regnum
>= 0 && regnum
< numregs
1173 && gdbarch_register_name (gdbarch
, regnum
)
1174 && *gdbarch_register_name (gdbarch
, regnum
))
1178 /* Get the value as a number. */
1179 value
= parse_and_eval_address (argv
[i
+ 1]);
1181 /* Write it down. */
1182 regcache_cooked_write_signed (regcache
, regnum
, value
);
1185 error ("bad register number");
1189 /* Evaluate the value of the argument. The argument is an
1190 expression. If the expression contains spaces it needs to be
1191 included in double quotes. */
1193 mi_cmd_data_evaluate_expression (char *command
, char **argv
, int argc
)
1195 struct expression
*expr
;
1196 struct cleanup
*old_chain
= NULL
;
1198 struct ui_stream
*stb
= NULL
;
1199 struct value_print_options opts
;
1201 stb
= ui_out_stream_new (uiout
);
1205 ui_out_stream_delete (stb
);
1206 error ("mi_cmd_data_evaluate_expression: Usage: -data-evaluate-expression expression");
1209 expr
= parse_expression (argv
[0]);
1211 old_chain
= make_cleanup (free_current_contents
, &expr
);
1213 val
= evaluate_expression (expr
);
1215 /* Print the result of the expression evaluation. */
1216 get_user_print_options (&opts
);
1218 val_print (value_type (val
), value_contents (val
),
1219 value_embedded_offset (val
), value_address (val
),
1220 stb
->stream
, 0, &opts
, current_language
);
1222 ui_out_field_stream (uiout
, "value", stb
);
1223 ui_out_stream_delete (stb
);
1225 do_cleanups (old_chain
);
1228 /* DATA-MEMORY-READ:
1230 ADDR: start address of data to be dumped.
1231 WORD-FORMAT: a char indicating format for the ``word''. See
1233 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes.
1234 NR_ROW: Number of rows.
1235 NR_COL: The number of colums (words per row).
1236 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
1237 ASCHAR for unprintable characters.
1239 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
1240 displayes them. Returns:
1242 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
1245 The number of bytes read is SIZE*ROW*COL. */
1248 mi_cmd_data_read_memory (char *command
, char **argv
, int argc
)
1250 struct gdbarch
*gdbarch
= get_current_arch ();
1251 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
1257 struct type
*word_type
;
1270 static struct mi_opt opts
[] =
1272 {"o", OFFSET_OPT
, 1},
1278 int opt
= mi_getopt ("mi_cmd_data_read_memory", argc
, argv
, opts
,
1283 switch ((enum opt
) opt
)
1286 offset
= atol (optarg
);
1293 if (argc
< 5 || argc
> 6)
1294 error ("mi_cmd_data_read_memory: Usage: ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR].");
1296 /* Extract all the arguments. */
1298 /* Start address of the memory dump. */
1299 addr
= parse_and_eval_address (argv
[0]) + offset
;
1300 /* The format character to use when displaying a memory word. See
1301 the ``x'' command. */
1302 word_format
= argv
[1][0];
1303 /* The size of the memory word. */
1304 word_size
= atol (argv
[2]);
1308 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1312 word_type
= builtin_type (gdbarch
)->builtin_int16
;
1316 word_type
= builtin_type (gdbarch
)->builtin_int32
;
1320 word_type
= builtin_type (gdbarch
)->builtin_int64
;
1324 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1327 /* The number of rows. */
1328 nr_rows
= atol (argv
[3]);
1330 error ("mi_cmd_data_read_memory: invalid number of rows.");
1332 /* Number of bytes per row. */
1333 nr_cols
= atol (argv
[4]);
1335 error ("mi_cmd_data_read_memory: invalid number of columns.");
1337 /* The un-printable character when printing ascii. */
1343 /* Create a buffer and read it in. */
1344 total_bytes
= word_size
* nr_rows
* nr_cols
;
1345 mbuf
= xcalloc (total_bytes
, 1);
1346 make_cleanup (xfree
, mbuf
);
1348 /* Dispatch memory reads to the topmost target, not the flattened
1350 nr_bytes
= target_read_until_error (current_target
.beneath
,
1351 TARGET_OBJECT_MEMORY
, NULL
, mbuf
,
1354 error ("Unable to read memory.");
1356 /* Output the header information. */
1357 ui_out_field_core_addr (uiout
, "addr", gdbarch
, addr
);
1358 ui_out_field_int (uiout
, "nr-bytes", nr_bytes
);
1359 ui_out_field_int (uiout
, "total-bytes", total_bytes
);
1360 ui_out_field_core_addr (uiout
, "next-row",
1361 gdbarch
, addr
+ word_size
* nr_cols
);
1362 ui_out_field_core_addr (uiout
, "prev-row",
1363 gdbarch
, addr
- word_size
* nr_cols
);
1364 ui_out_field_core_addr (uiout
, "next-page", gdbarch
, addr
+ total_bytes
);
1365 ui_out_field_core_addr (uiout
, "prev-page", gdbarch
, addr
- total_bytes
);
1367 /* Build the result as a two dimentional table. */
1369 struct ui_stream
*stream
= ui_out_stream_new (uiout
);
1370 struct cleanup
*cleanup_list_memory
;
1374 cleanup_list_memory
= make_cleanup_ui_out_list_begin_end (uiout
, "memory");
1375 for (row
= 0, row_byte
= 0;
1377 row
++, row_byte
+= nr_cols
* word_size
)
1381 struct cleanup
*cleanup_tuple
;
1382 struct cleanup
*cleanup_list_data
;
1383 struct value_print_options opts
;
1385 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1386 ui_out_field_core_addr (uiout
, "addr", gdbarch
, addr
+ row_byte
);
1387 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr + row_byte); */
1388 cleanup_list_data
= make_cleanup_ui_out_list_begin_end (uiout
, "data");
1389 get_formatted_print_options (&opts
, word_format
);
1390 for (col
= 0, col_byte
= row_byte
;
1392 col
++, col_byte
+= word_size
)
1394 if (col_byte
+ word_size
> nr_bytes
)
1396 ui_out_field_string (uiout
, NULL
, "N/A");
1400 ui_file_rewind (stream
->stream
);
1401 print_scalar_formatted (mbuf
+ col_byte
, word_type
, &opts
,
1402 word_asize
, stream
->stream
);
1403 ui_out_field_stream (uiout
, NULL
, stream
);
1406 do_cleanups (cleanup_list_data
);
1411 ui_file_rewind (stream
->stream
);
1412 for (byte
= row_byte
; byte
< row_byte
+ word_size
* nr_cols
; byte
++)
1414 if (byte
>= nr_bytes
)
1416 fputc_unfiltered ('X', stream
->stream
);
1418 else if (mbuf
[byte
] < 32 || mbuf
[byte
] > 126)
1420 fputc_unfiltered (aschar
, stream
->stream
);
1423 fputc_unfiltered (mbuf
[byte
], stream
->stream
);
1425 ui_out_field_stream (uiout
, "ascii", stream
);
1427 do_cleanups (cleanup_tuple
);
1429 ui_out_stream_delete (stream
);
1430 do_cleanups (cleanup_list_memory
);
1432 do_cleanups (cleanups
);
1435 /* DATA-MEMORY-WRITE:
1437 COLUMN_OFFSET: optional argument. Must be preceeded by '-o'. The
1438 offset from the beginning of the memory grid row where the cell to
1440 ADDR: start address of the row in the memory grid where the memory
1441 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
1442 the location to write to.
1443 FORMAT: a char indicating format for the ``word''. See
1445 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
1446 VALUE: value to be written into the memory address.
1448 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
1452 mi_cmd_data_write_memory (char *command
, char **argv
, int argc
)
1454 struct gdbarch
*gdbarch
= get_current_arch ();
1455 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1459 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
1460 enough when using a compiler other than GCC. */
1463 struct cleanup
*old_chain
;
1471 static struct mi_opt opts
[] =
1473 {"o", OFFSET_OPT
, 1},
1479 int opt
= mi_getopt ("mi_cmd_data_write_memory", argc
, argv
, opts
,
1484 switch ((enum opt
) opt
)
1487 offset
= atol (optarg
);
1495 error ("mi_cmd_data_write_memory: Usage: [-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE.");
1497 /* Extract all the arguments. */
1498 /* Start address of the memory dump. */
1499 addr
= parse_and_eval_address (argv
[0]);
1500 /* The format character to use when displaying a memory word. See
1501 the ``x'' command. */
1502 word_format
= argv
[1][0];
1503 /* The size of the memory word. */
1504 word_size
= atol (argv
[2]);
1506 /* Calculate the real address of the write destination. */
1507 addr
+= (offset
* word_size
);
1509 /* Get the value as a number. */
1510 value
= parse_and_eval_address (argv
[3]);
1511 /* Get the value into an array. */
1512 buffer
= xmalloc (word_size
);
1513 old_chain
= make_cleanup (xfree
, buffer
);
1514 store_signed_integer (buffer
, word_size
, byte_order
, value
);
1515 /* Write it down to memory. */
1516 write_memory (addr
, buffer
, word_size
);
1517 /* Free the buffer. */
1518 do_cleanups (old_chain
);
1522 mi_cmd_enable_timings (char *command
, char **argv
, int argc
)
1528 if (strcmp (argv
[0], "yes") == 0)
1530 else if (strcmp (argv
[0], "no") == 0)
1541 error ("mi_cmd_enable_timings: Usage: %s {yes|no}", command
);
1545 mi_cmd_list_features (char *command
, char **argv
, int argc
)
1549 struct cleanup
*cleanup
= NULL
;
1551 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "features");
1552 ui_out_field_string (uiout
, NULL
, "frozen-varobjs");
1553 ui_out_field_string (uiout
, NULL
, "pending-breakpoints");
1554 ui_out_field_string (uiout
, NULL
, "thread-info");
1557 ui_out_field_string (uiout
, NULL
, "python");
1560 do_cleanups (cleanup
);
1564 error ("-list-features should be passed no arguments");
1568 mi_cmd_list_target_features (char *command
, char **argv
, int argc
)
1572 struct cleanup
*cleanup
= NULL
;
1574 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "features");
1575 if (target_can_async_p ())
1576 ui_out_field_string (uiout
, NULL
, "async");
1578 do_cleanups (cleanup
);
1582 error ("-list-target-features should be passed no arguments");
1586 mi_cmd_add_inferior (char *command
, char **argv
, int argc
)
1588 struct inferior
*inf
;
1591 error (_("-add-inferior should be passed no arguments"));
1593 inf
= add_inferior_with_spaces ();
1595 ui_out_field_fmt (uiout
, "inferior", "i%d", inf
->num
);
1599 mi_cmd_remove_inferior (char *command
, char **argv
, int argc
)
1602 struct inferior
*inf
;
1605 error ("-remove-inferior should be passed a single argument");
1607 if (sscanf (argv
[1], "i%d", &id
) != 1)
1608 error ("the thread group id is syntactically invalid");
1610 inf
= find_inferior_id (id
);
1612 error ("the specified thread group does not exist");
1614 delete_inferior_1 (inf
, 1 /* silent */);
1619 /* Execute a command within a safe environment.
1620 Return <0 for error; >=0 for ok.
1622 args->action will tell mi_execute_command what action
1623 to perfrom after the given command has executed (display/suppress
1624 prompt, display error). */
1627 captured_mi_execute_command (struct ui_out
*uiout
, void *data
)
1629 struct cleanup
*cleanup
;
1630 struct mi_parse
*context
= (struct mi_parse
*) data
;
1633 current_command_ts
= context
->cmd_start
;
1635 current_token
= xstrdup (context
->token
);
1636 cleanup
= make_cleanup (free_current_contents
, ¤t_token
);
1638 running_result_record_printed
= 0;
1640 switch (context
->op
)
1643 /* A MI command was read from the input stream. */
1645 /* FIXME: gdb_???? */
1646 fprintf_unfiltered (raw_stdout
, " token=`%s' command=`%s' args=`%s'\n",
1647 context
->token
, context
->command
, context
->args
);
1650 mi_cmd_execute (context
);
1652 /* Print the result if there were no errors.
1654 Remember that on the way out of executing a command, you have
1655 to directly use the mi_interp's uiout, since the command could
1656 have reset the interpreter, in which case the current uiout
1657 will most likely crash in the mi_out_* routines. */
1658 if (!running_result_record_printed
)
1660 fputs_unfiltered (context
->token
, raw_stdout
);
1661 /* There's no particularly good reason why target-connect results
1662 in not ^done. Should kill ^connected for MI3. */
1663 fputs_unfiltered (strcmp (context
->command
, "target-select") == 0
1664 ? "^connected" : "^done", raw_stdout
);
1665 mi_out_put (uiout
, raw_stdout
);
1666 mi_out_rewind (uiout
);
1667 mi_print_timing_maybe ();
1668 fputs_unfiltered ("\n", raw_stdout
);
1671 /* The command does not want anything to be printed. In that
1672 case, the command probably should not have written anything
1673 to uiout, but in case it has written something, discard it. */
1674 mi_out_rewind (uiout
);
1681 /* A CLI command was read from the input stream. */
1682 /* This "feature" will be removed as soon as we have a
1683 complete set of mi commands. */
1684 /* Echo the command on the console. */
1685 fprintf_unfiltered (gdb_stdlog
, "%s\n", context
->command
);
1686 /* Call the "console" interpreter. */
1687 argv
[0] = "console";
1688 argv
[1] = context
->command
;
1689 mi_cmd_interpreter_exec ("-interpreter-exec", argv
, 2);
1691 /* If we changed interpreters, DON'T print out anything. */
1692 if (current_interp_named_p (INTERP_MI
)
1693 || current_interp_named_p (INTERP_MI1
)
1694 || current_interp_named_p (INTERP_MI2
)
1695 || current_interp_named_p (INTERP_MI3
))
1697 if (!running_result_record_printed
)
1699 fputs_unfiltered (context
->token
, raw_stdout
);
1700 fputs_unfiltered ("^done", raw_stdout
);
1701 mi_out_put (uiout
, raw_stdout
);
1702 mi_out_rewind (uiout
);
1703 mi_print_timing_maybe ();
1704 fputs_unfiltered ("\n", raw_stdout
);
1707 mi_out_rewind (uiout
);
1714 do_cleanups (cleanup
);
1721 mi_execute_command (char *cmd
, int from_tty
)
1723 struct mi_parse
*command
;
1725 /* This is to handle EOF (^D). We just quit gdb. */
1726 /* FIXME: we should call some API function here. */
1728 quit_force (NULL
, from_tty
);
1730 target_log_command (cmd
);
1732 command
= mi_parse (cmd
);
1734 if (command
!= NULL
)
1736 struct gdb_exception result
;
1737 ptid_t previous_ptid
= inferior_ptid
;
1741 command
->cmd_start
= (struct mi_timestamp
*)
1742 xmalloc (sizeof (struct mi_timestamp
));
1743 timestamp (command
->cmd_start
);
1746 result
= catch_exception (uiout
, captured_mi_execute_command
, command
,
1748 if (result
.reason
< 0)
1750 /* The command execution failed and error() was called
1752 fputs_unfiltered (command
->token
, raw_stdout
);
1753 fputs_unfiltered ("^error,msg=\"", raw_stdout
);
1754 if (result
.message
== NULL
)
1755 fputs_unfiltered ("unknown error", raw_stdout
);
1757 fputstr_unfiltered (result
.message
, '"', raw_stdout
);
1758 fputs_unfiltered ("\"\n", raw_stdout
);
1759 mi_out_rewind (uiout
);
1762 bpstat_do_actions ();
1764 if (/* The notifications are only output when the top-level
1765 interpreter (specified on the command line) is MI. */
1766 ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ()))
1767 /* Don't try report anything if there are no threads --
1768 the program is dead. */
1769 && thread_count () != 0
1770 /* -thread-select explicitly changes thread. If frontend uses that
1771 internally, we don't want to emit =thread-selected, since
1772 =thread-selected is supposed to indicate user's intentions. */
1773 && strcmp (command
->command
, "thread-select") != 0)
1775 struct mi_interp
*mi
= top_level_interpreter_data ();
1776 int report_change
= 0;
1778 if (command
->thread
== -1)
1780 report_change
= (!ptid_equal (previous_ptid
, null_ptid
)
1781 && !ptid_equal (inferior_ptid
, previous_ptid
)
1782 && !ptid_equal (inferior_ptid
, null_ptid
));
1784 else if (!ptid_equal (inferior_ptid
, null_ptid
))
1786 struct thread_info
*ti
= inferior_thread ();
1788 report_change
= (ti
->num
!= command
->thread
);
1793 struct thread_info
*ti
= inferior_thread ();
1795 target_terminal_ours ();
1796 fprintf_unfiltered (mi
->event_channel
,
1797 "thread-selected,id=\"%d\"",
1799 gdb_flush (mi
->event_channel
);
1803 mi_parse_free (command
);
1806 fputs_unfiltered ("(gdb) \n", raw_stdout
);
1807 gdb_flush (raw_stdout
);
1808 /* Print any buffered hook code. */
1813 mi_cmd_execute (struct mi_parse
*parse
)
1815 struct cleanup
*cleanup
;
1817 prepare_execute_command ();
1819 cleanup
= make_cleanup (null_cleanup
, NULL
);
1821 if (parse
->all
&& parse
->thread_group
!= -1)
1822 error (_("Cannot specify --thread-group together with --all"));
1824 if (parse
->all
&& parse
->thread
!= -1)
1825 error (_("Cannot specify --thread together with --all"));
1827 if (parse
->thread_group
!= -1 && parse
->thread
!= -1)
1828 error (_("Cannot specify --thread together with --thread-group"));
1830 if (parse
->frame
!= -1 && parse
->thread
== -1)
1831 error (_("Cannot specify --frame without --thread"));
1833 if (parse
->thread_group
!= -1)
1835 struct inferior
*inf
= find_inferior_id (parse
->thread_group
);
1836 struct thread_info
*tp
= 0;
1839 error (_("Invalid thread group for the --thread-group option"));
1841 set_current_inferior (inf
);
1842 /* This behaviour means that if --thread-group option identifies
1843 an inferior with multiple threads, then a random one will be picked.
1844 This is not a problem -- frontend should always provide --thread if
1845 it wishes to operate on a specific thread. */
1847 tp
= any_thread_of_process (inf
->pid
);
1848 switch_to_thread (tp
? tp
->ptid
: null_ptid
);
1849 set_current_program_space (inf
->pspace
);
1852 if (parse
->thread
!= -1)
1854 struct thread_info
*tp
= find_thread_id (parse
->thread
);
1857 error (_("Invalid thread id: %d"), parse
->thread
);
1859 if (is_exited (tp
->ptid
))
1860 error (_("Thread id: %d has terminated"), parse
->thread
);
1862 switch_to_thread (tp
->ptid
);
1865 if (parse
->frame
!= -1)
1867 struct frame_info
*fid
;
1868 int frame
= parse
->frame
;
1870 fid
= find_relative_frame (get_current_frame (), &frame
);
1872 /* find_relative_frame was successful */
1875 error (_("Invalid frame id: %d"), frame
);
1878 current_context
= parse
;
1880 if (parse
->cmd
->argv_func
!= NULL
)
1881 parse
->cmd
->argv_func (parse
->command
, parse
->argv
, parse
->argc
);
1882 else if (parse
->cmd
->cli
.cmd
!= 0)
1884 /* FIXME: DELETE THIS. */
1885 /* The operation is still implemented by a cli command. */
1886 /* Must be a synchronous one. */
1887 mi_execute_cli_command (parse
->cmd
->cli
.cmd
, parse
->cmd
->cli
.args_p
,
1892 /* FIXME: DELETE THIS. */
1893 struct ui_file
*stb
;
1895 stb
= mem_fileopen ();
1897 fputs_unfiltered ("Undefined mi command: ", stb
);
1898 fputstr_unfiltered (parse
->command
, '"', stb
);
1899 fputs_unfiltered (" (missing implementation)", stb
);
1901 make_cleanup_ui_file_delete (stb
);
1904 do_cleanups (cleanup
);
1907 /* FIXME: This is just a hack so we can get some extra commands going.
1908 We don't want to channel things through the CLI, but call libgdb directly.
1909 Use only for synchronous commands. */
1912 mi_execute_cli_command (const char *cmd
, int args_p
, const char *args
)
1916 struct cleanup
*old_cleanups
;
1920 run
= xstrprintf ("%s %s", cmd
, args
);
1922 run
= xstrdup (cmd
);
1924 /* FIXME: gdb_???? */
1925 fprintf_unfiltered (gdb_stdout
, "cli=%s run=%s\n",
1927 old_cleanups
= make_cleanup (xfree
, run
);
1928 execute_command ( /*ui */ run
, 0 /*from_tty */ );
1929 do_cleanups (old_cleanups
);
1935 mi_execute_async_cli_command (char *cli_command
, char **argv
, int argc
)
1937 struct cleanup
*old_cleanups
;
1940 if (target_can_async_p ())
1941 run
= xstrprintf ("%s %s&", cli_command
, argc
? *argv
: "");
1943 run
= xstrprintf ("%s %s", cli_command
, argc
? *argv
: "");
1944 old_cleanups
= make_cleanup (xfree
, run
);
1946 execute_command ( /*ui */ run
, 0 /*from_tty */ );
1948 if (target_can_async_p ())
1950 /* If we're not executing, an exception should have been throw. */
1951 gdb_assert (is_running (inferior_ptid
));
1952 do_cleanups (old_cleanups
);
1956 /* Do this before doing any printing. It would appear that some
1957 print code leaves garbage around in the buffer. */
1958 do_cleanups (old_cleanups
);
1963 mi_load_progress (const char *section_name
,
1964 unsigned long sent_so_far
,
1965 unsigned long total_section
,
1966 unsigned long total_sent
,
1967 unsigned long grand_total
)
1969 struct timeval time_now
, delta
, update_threshold
;
1970 static struct timeval last_update
;
1971 static char *previous_sect_name
= NULL
;
1973 struct ui_out
*saved_uiout
;
1975 /* This function is called through deprecated_show_load_progress
1976 which means uiout may not be correct. Fix it for the duration
1977 of this function. */
1978 saved_uiout
= uiout
;
1980 if (current_interp_named_p (INTERP_MI
)
1981 || current_interp_named_p (INTERP_MI2
))
1982 uiout
= mi_out_new (2);
1983 else if (current_interp_named_p (INTERP_MI1
))
1984 uiout
= mi_out_new (1);
1985 else if (current_interp_named_p (INTERP_MI3
))
1986 uiout
= mi_out_new (3);
1990 update_threshold
.tv_sec
= 0;
1991 update_threshold
.tv_usec
= 500000;
1992 gettimeofday (&time_now
, NULL
);
1994 delta
.tv_usec
= time_now
.tv_usec
- last_update
.tv_usec
;
1995 delta
.tv_sec
= time_now
.tv_sec
- last_update
.tv_sec
;
1997 if (delta
.tv_usec
< 0)
2000 delta
.tv_usec
+= 1000000L;
2003 new_section
= (previous_sect_name
?
2004 strcmp (previous_sect_name
, section_name
) : 1);
2007 struct cleanup
*cleanup_tuple
;
2009 xfree (previous_sect_name
);
2010 previous_sect_name
= xstrdup (section_name
);
2013 fputs_unfiltered (current_token
, raw_stdout
);
2014 fputs_unfiltered ("+download", raw_stdout
);
2015 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2016 ui_out_field_string (uiout
, "section", section_name
);
2017 ui_out_field_int (uiout
, "section-size", total_section
);
2018 ui_out_field_int (uiout
, "total-size", grand_total
);
2019 do_cleanups (cleanup_tuple
);
2020 mi_out_put (uiout
, raw_stdout
);
2021 fputs_unfiltered ("\n", raw_stdout
);
2022 gdb_flush (raw_stdout
);
2025 if (delta
.tv_sec
>= update_threshold
.tv_sec
&&
2026 delta
.tv_usec
>= update_threshold
.tv_usec
)
2028 struct cleanup
*cleanup_tuple
;
2030 last_update
.tv_sec
= time_now
.tv_sec
;
2031 last_update
.tv_usec
= time_now
.tv_usec
;
2033 fputs_unfiltered (current_token
, raw_stdout
);
2034 fputs_unfiltered ("+download", raw_stdout
);
2035 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2036 ui_out_field_string (uiout
, "section", section_name
);
2037 ui_out_field_int (uiout
, "section-sent", sent_so_far
);
2038 ui_out_field_int (uiout
, "section-size", total_section
);
2039 ui_out_field_int (uiout
, "total-sent", total_sent
);
2040 ui_out_field_int (uiout
, "total-size", grand_total
);
2041 do_cleanups (cleanup_tuple
);
2042 mi_out_put (uiout
, raw_stdout
);
2043 fputs_unfiltered ("\n", raw_stdout
);
2044 gdb_flush (raw_stdout
);
2048 uiout
= saved_uiout
;
2052 timestamp (struct mi_timestamp
*tv
)
2054 gettimeofday (&tv
->wallclock
, NULL
);
2055 #ifdef HAVE_GETRUSAGE
2056 getrusage (RUSAGE_SELF
, &rusage
);
2057 tv
->utime
.tv_sec
= rusage
.ru_utime
.tv_sec
;
2058 tv
->utime
.tv_usec
= rusage
.ru_utime
.tv_usec
;
2059 tv
->stime
.tv_sec
= rusage
.ru_stime
.tv_sec
;
2060 tv
->stime
.tv_usec
= rusage
.ru_stime
.tv_usec
;
2063 long usec
= get_run_time ();
2065 tv
->utime
.tv_sec
= usec
/1000000L;
2066 tv
->utime
.tv_usec
= usec
- 1000000L*tv
->utime
.tv_sec
;
2067 tv
->stime
.tv_sec
= 0;
2068 tv
->stime
.tv_usec
= 0;
2074 print_diff_now (struct mi_timestamp
*start
)
2076 struct mi_timestamp now
;
2079 print_diff (start
, &now
);
2083 mi_print_timing_maybe (void)
2085 /* If the command is -enable-timing then do_timings may be
2086 true whilst current_command_ts is not initialized. */
2087 if (do_timings
&& current_command_ts
)
2088 print_diff_now (current_command_ts
);
2092 timeval_diff (struct timeval start
, struct timeval end
)
2094 return ((end
.tv_sec
- start
.tv_sec
) * 1000000L)
2095 + (end
.tv_usec
- start
.tv_usec
);
2099 print_diff (struct mi_timestamp
*start
, struct mi_timestamp
*end
)
2103 ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
2104 timeval_diff (start
->wallclock
, end
->wallclock
) / 1000000.0,
2105 timeval_diff (start
->utime
, end
->utime
) / 1000000.0,
2106 timeval_diff (start
->stime
, end
->stime
) / 1000000.0);
2110 mi_cmd_trace_define_variable (char *command
, char **argv
, int argc
)
2112 struct expression
*expr
;
2113 struct cleanup
*back_to
;
2114 LONGEST initval
= 0;
2115 struct trace_state_variable
*tsv
;
2118 if (argc
!= 1 && argc
!= 2)
2119 error (_("Usage: -trace-define-variable VARIABLE [VALUE]"));
2121 expr
= parse_expression (argv
[0]);
2122 back_to
= make_cleanup (xfree
, expr
);
2124 if (expr
->nelts
== 3 && expr
->elts
[0].opcode
== OP_INTERNALVAR
)
2126 struct internalvar
*intvar
= expr
->elts
[1].internalvar
;
2129 name
= internalvar_name (intvar
);
2132 if (!name
|| *name
== '\0')
2133 error (_("Invalid name of trace variable"));
2135 tsv
= find_trace_state_variable (name
);
2137 tsv
= create_trace_state_variable (name
);
2140 initval
= value_as_long (parse_and_eval (argv
[1]));
2142 tsv
->initial_value
= initval
;
2144 do_cleanups (back_to
);
2148 mi_cmd_trace_list_variables (char *command
, char **argv
, int argc
)
2151 error (_("-trace-list-variables: no arguments are allowed"));
2153 tvariables_info_1 ();
2157 mi_cmd_trace_find (char *command
, char **argv
, int argc
)
2162 error (_("trace selection mode is required"));
2166 if (strcmp (mode
, "none") == 0)
2168 tfind_1 (tfind_number
, -1, 0, 0, 0);
2172 if (current_trace_status ()->running
)
2173 error (_("May not look at trace frames while trace is running."));
2175 if (strcmp (mode
, "frame-number") == 0)
2178 error (_("frame number is required"));
2179 tfind_1 (tfind_number
, atoi (argv
[1]), 0, 0, 0);
2181 else if (strcmp (mode
, "tracepoint-number") == 0)
2184 error (_("tracepoint number is required"));
2185 tfind_1 (tfind_tp
, atoi (argv
[1]), 0, 0, 0);
2187 else if (strcmp (mode
, "pc") == 0)
2190 error (_("PC is required"));
2191 tfind_1 (tfind_pc
, 0, parse_and_eval_address (argv
[1]), 0, 0);
2193 else if (strcmp (mode
, "pc-inside-range") == 0)
2196 error (_("Start and end PC are required"));
2197 tfind_1 (tfind_range
, 0, parse_and_eval_address (argv
[1]),
2198 parse_and_eval_address (argv
[2]), 0);
2200 else if (strcmp (mode
, "pc-outside-range") == 0)
2203 error (_("Start and end PC are required"));
2204 tfind_1 (tfind_outside
, 0, parse_and_eval_address (argv
[1]),
2205 parse_and_eval_address (argv
[2]), 0);
2207 else if (strcmp (mode
, "line") == 0)
2209 struct symtabs_and_lines sals
;
2210 struct symtab_and_line sal
;
2211 static CORE_ADDR start_pc
, end_pc
;
2212 struct cleanup
*back_to
;
2215 error (_("Line is required"));
2217 sals
= decode_line_spec (argv
[1], 1);
2218 back_to
= make_cleanup (xfree
, sals
.sals
);
2222 if (sal
.symtab
== 0)
2223 error (_("Could not find the specified line"));
2225 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2226 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, 0);
2228 error (_("Could not find the specified line"));
2230 do_cleanups (back_to
);
2233 error (_("Invalid mode '%s'"), mode
);
2235 if (has_stack_frames () || get_traceframe_number () >= 0)
2237 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
2242 mi_cmd_trace_save (char *command
, char **argv
, int argc
)
2244 int target_saves
= 0;
2247 if (argc
!= 1 && argc
!= 2)
2248 error (_("Usage: -trace-save [-r] filename"));
2253 if (strcmp (argv
[0], "-r") == 0)
2256 error (_("Invalid option: %s"), argv
[0]);
2263 trace_save (filename
, target_saves
);
2268 mi_cmd_trace_start (char *command
, char **argv
, int argc
)
2274 mi_cmd_trace_status (char *command
, char **argv
, int argc
)
2276 trace_status_mi (0);
2280 mi_cmd_trace_stop (char *command
, char **argv
, int argc
)
2283 trace_status_mi (1);