3 Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010,
4 2011 Free Software Foundation, Inc.
6 Contributed by Cygnus Solutions (a Red Hat company).
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 /* Work in progress. */
26 #include "arch-utils.h"
29 #include "gdb_string.h"
30 #include "exceptions.h"
32 #include "gdbthread.h"
35 #include "mi-getopt.h"
36 #include "mi-console.h"
40 #include "event-loop.h"
41 #include "event-top.h"
42 #include "gdbcore.h" /* For write_memory(). */
48 #include "mi-common.h"
53 #include "splay-tree.h"
54 #include "tracepoint.h"
59 #if defined HAVE_SYS_RESOURCE_H
60 #include <sys/resource.h>
73 struct ui_file
*raw_stdout
;
75 /* This is used to pass the current command timestamp
76 down to continuation routines. */
77 static struct mi_timestamp
*current_command_ts
;
79 static int do_timings
= 0;
82 /* Few commands would like to know if options like --thread-group
83 were explicitly specified. This variable keeps the current
84 parsed command including all option, and make it possible. */
85 static struct mi_parse
*current_context
;
87 int running_result_record_printed
= 1;
89 /* Flag indicating that the target has proceeded since the last
90 command was issued. */
93 extern void _initialize_mi_main (void);
94 static void mi_cmd_execute (struct mi_parse
*parse
);
96 static void mi_execute_cli_command (const char *cmd
, int args_p
,
98 static void mi_execute_async_cli_command (char *cli_command
,
99 char **argv
, int argc
);
100 static int register_changed_p (int regnum
, struct regcache
*,
102 static void get_register (struct frame_info
*, int regnum
, int format
);
104 /* Command implementations. FIXME: Is this libgdb? No. This is the MI
105 layer that calls libgdb. Any operation used in the below should be
108 static void timestamp (struct mi_timestamp
*tv
);
110 static void print_diff_now (struct mi_timestamp
*start
);
111 static void print_diff (struct mi_timestamp
*start
, struct mi_timestamp
*end
);
114 mi_cmd_gdb_exit (char *command
, char **argv
, int argc
)
116 /* We have to print everything right here because we never return. */
118 fputs_unfiltered (current_token
, raw_stdout
);
119 fputs_unfiltered ("^exit\n", raw_stdout
);
120 mi_out_put (uiout
, raw_stdout
);
121 gdb_flush (raw_stdout
);
122 /* FIXME: The function called is not yet a formal libgdb function. */
123 quit_force (NULL
, FROM_TTY
);
127 mi_cmd_exec_next (char *command
, char **argv
, int argc
)
129 /* FIXME: Should call a libgdb function, not a cli wrapper. */
130 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
131 mi_execute_async_cli_command ("reverse-next", argv
+ 1, argc
- 1);
133 mi_execute_async_cli_command ("next", argv
, argc
);
137 mi_cmd_exec_next_instruction (char *command
, char **argv
, int argc
)
139 /* FIXME: Should call a libgdb function, not a cli wrapper. */
140 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
141 mi_execute_async_cli_command ("reverse-nexti", argv
+ 1, argc
- 1);
143 mi_execute_async_cli_command ("nexti", argv
, argc
);
147 mi_cmd_exec_step (char *command
, char **argv
, int argc
)
149 /* FIXME: Should call a libgdb function, not a cli wrapper. */
150 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
151 mi_execute_async_cli_command ("reverse-step", argv
+ 1, argc
- 1);
153 mi_execute_async_cli_command ("step", argv
, argc
);
157 mi_cmd_exec_step_instruction (char *command
, char **argv
, int argc
)
159 /* FIXME: Should call a libgdb function, not a cli wrapper. */
160 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
161 mi_execute_async_cli_command ("reverse-stepi", argv
+ 1, argc
- 1);
163 mi_execute_async_cli_command ("stepi", argv
, argc
);
167 mi_cmd_exec_finish (char *command
, char **argv
, int argc
)
169 /* FIXME: Should call a libgdb function, not a cli wrapper. */
170 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
171 mi_execute_async_cli_command ("reverse-finish", argv
+ 1, argc
- 1);
173 mi_execute_async_cli_command ("finish", argv
, argc
);
177 mi_cmd_exec_return (char *command
, char **argv
, int argc
)
179 /* This command doesn't really execute the target, it just pops the
180 specified number of frames. */
182 /* Call return_command with from_tty argument equal to 0 so as to
183 avoid being queried. */
184 return_command (*argv
, 0);
186 /* Call return_command with from_tty argument equal to 0 so as to
187 avoid being queried. */
188 return_command (NULL
, 0);
190 /* Because we have called return_command with from_tty = 0, we need
191 to print the frame here. */
192 print_stack_frame (get_selected_frame (NULL
), 1, LOC_AND_ADDRESS
);
196 mi_cmd_exec_jump (char *args
, char **argv
, int argc
)
198 /* FIXME: Should call a libgdb function, not a cli wrapper. */
199 mi_execute_async_cli_command ("jump", argv
, argc
);
203 proceed_thread (struct thread_info
*thread
, int pid
)
205 if (!is_stopped (thread
->ptid
))
208 if (pid
!= 0 && PIDGET (thread
->ptid
) != pid
)
211 switch_to_thread (thread
->ptid
);
212 clear_proceed_status ();
213 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 0);
218 proceed_thread_callback (struct thread_info
*thread
, void *arg
)
220 int pid
= *(int *)arg
;
222 proceed_thread (thread
, pid
);
227 exec_continue (char **argv
, int argc
)
231 /* In non-stop mode, 'resume' always resumes a single thread. Therefore,
232 to resume all threads of the current inferior, or all threads in all
233 inferiors, we need to iterate over threads.
235 See comment on infcmd.c:proceed_thread_callback for rationale. */
236 if (current_context
->all
|| current_context
->thread_group
!= -1)
239 struct cleanup
*back_to
= make_cleanup_restore_current_thread ();
241 if (!current_context
->all
)
244 = find_inferior_id (current_context
->thread_group
);
248 iterate_over_threads (proceed_thread_callback
, &pid
);
249 do_cleanups (back_to
);
258 struct cleanup
*back_to
= make_cleanup_restore_integer (&sched_multi
);
260 if (current_context
->all
)
267 /* In all-stop mode, -exec-continue traditionally resumed either
268 all threads, or one thread, depending on the 'scheduler-locking'
269 variable. Let's continue to do the same. */
272 do_cleanups (back_to
);
277 exec_direction_forward (void *notused
)
279 execution_direction
= EXEC_FORWARD
;
283 exec_reverse_continue (char **argv
, int argc
)
285 enum exec_direction_kind dir
= execution_direction
;
286 struct cleanup
*old_chain
;
288 if (dir
== EXEC_REVERSE
)
289 error (_("Already in reverse mode."));
291 if (!target_can_execute_reverse
)
292 error (_("Target %s does not support this command."), target_shortname
);
294 old_chain
= make_cleanup (exec_direction_forward
, NULL
);
295 execution_direction
= EXEC_REVERSE
;
296 exec_continue (argv
, argc
);
297 do_cleanups (old_chain
);
301 mi_cmd_exec_continue (char *command
, char **argv
, int argc
)
303 if (argc
> 0 && strcmp (argv
[0], "--reverse") == 0)
304 exec_reverse_continue (argv
+ 1, argc
- 1);
306 exec_continue (argv
, argc
);
310 interrupt_thread_callback (struct thread_info
*thread
, void *arg
)
312 int pid
= *(int *)arg
;
314 if (!is_running (thread
->ptid
))
317 if (PIDGET (thread
->ptid
) != pid
)
320 target_stop (thread
->ptid
);
324 /* Interrupt the execution of the target. Note how we must play around
325 with the token variables, in order to display the current token in
326 the result of the interrupt command, and the previous execution
327 token when the target finally stops. See comments in
330 mi_cmd_exec_interrupt (char *command
, char **argv
, int argc
)
332 /* In all-stop mode, everything stops, so we don't need to try
333 anything specific. */
336 interrupt_target_1 (0);
340 if (current_context
->all
)
342 /* This will interrupt all threads in all inferiors. */
343 interrupt_target_1 (1);
345 else if (current_context
->thread_group
!= -1)
347 struct inferior
*inf
= find_inferior_id (current_context
->thread_group
);
349 iterate_over_threads (interrupt_thread_callback
, &inf
->pid
);
353 /* Interrupt just the current thread -- either explicitly
354 specified via --thread or whatever was current before
355 MI command was sent. */
356 interrupt_target_1 (0);
361 run_one_inferior (struct inferior
*inf
, void *arg
)
365 if (inf
->pid
!= ptid_get_pid (inferior_ptid
))
367 struct thread_info
*tp
;
369 tp
= any_thread_of_process (inf
->pid
);
371 error (_("Inferior has no threads."));
373 switch_to_thread (tp
->ptid
);
378 set_current_inferior (inf
);
379 switch_to_thread (null_ptid
);
380 set_current_program_space (inf
->pspace
);
382 mi_execute_cli_command ("run", target_can_async_p (),
383 target_can_async_p () ? "&" : NULL
);
388 mi_cmd_exec_run (char *command
, char **argv
, int argc
)
390 if (current_context
->all
)
392 struct cleanup
*back_to
= save_current_space_and_thread ();
394 iterate_over_inferiors (run_one_inferior
, NULL
);
395 do_cleanups (back_to
);
399 mi_execute_cli_command ("run", target_can_async_p (),
400 target_can_async_p () ? "&" : NULL
);
406 find_thread_of_process (struct thread_info
*ti
, void *p
)
410 if (PIDGET (ti
->ptid
) == pid
&& !is_exited (ti
->ptid
))
417 mi_cmd_target_detach (char *command
, char **argv
, int argc
)
419 if (argc
!= 0 && argc
!= 1)
420 error (_("Usage: -target-detach [pid | thread-group]"));
424 struct thread_info
*tp
;
428 /* First see if we are dealing with a thread-group id. */
431 struct inferior
*inf
;
432 int id
= strtoul (argv
[0] + 1, &end
, 0);
435 error (_("Invalid syntax of thread-group id '%s'"), argv
[0]);
437 inf
= find_inferior_id (id
);
439 error (_("Non-existent thread-group id '%d'"), id
);
445 /* We must be dealing with a pid. */
446 pid
= strtol (argv
[0], &end
, 10);
449 error (_("Invalid identifier '%s'"), argv
[0]);
452 /* Pick any thread in the desired process. Current
453 target_detach detaches from the parent of inferior_ptid. */
454 tp
= iterate_over_threads (find_thread_of_process
, &pid
);
456 error (_("Thread group is empty"));
458 switch_to_thread (tp
->ptid
);
461 detach_command (NULL
, 0);
465 mi_cmd_thread_select (char *command
, char **argv
, int argc
)
468 char *mi_error_message
;
471 error (_("-thread-select: USAGE: threadnum."));
473 rc
= gdb_thread_select (uiout
, argv
[0], &mi_error_message
);
475 if (rc
== GDB_RC_FAIL
)
477 make_cleanup (xfree
, mi_error_message
);
478 error ("%s", mi_error_message
);
483 mi_cmd_thread_list_ids (char *command
, char **argv
, int argc
)
486 char *mi_error_message
;
489 error (_("-thread-list-ids: No arguments required."));
491 rc
= gdb_list_thread_ids (uiout
, &mi_error_message
);
493 if (rc
== GDB_RC_FAIL
)
495 make_cleanup (xfree
, mi_error_message
);
496 error ("%s", mi_error_message
);
501 mi_cmd_thread_info (char *command
, char **argv
, int argc
)
503 if (argc
!= 0 && argc
!= 1)
504 error (_("Invalid MI command"));
506 print_thread_info (uiout
, argv
[0], -1);
509 struct collect_cores_data
517 collect_cores (struct thread_info
*ti
, void *xdata
)
519 struct collect_cores_data
*data
= xdata
;
521 if (ptid_get_pid (ti
->ptid
) == data
->pid
)
523 int core
= target_core_of_thread (ti
->ptid
);
526 VEC_safe_push (int, data
->cores
, core
);
533 unique (int *b
, int *e
)
543 struct print_one_inferior_data
546 VEC (int) *inferiors
;
550 print_one_inferior (struct inferior
*inferior
, void *xdata
)
552 struct print_one_inferior_data
*top_data
= xdata
;
554 if (VEC_empty (int, top_data
->inferiors
)
555 || bsearch (&(inferior
->pid
), VEC_address (int, top_data
->inferiors
),
556 VEC_length (int, top_data
->inferiors
), sizeof (int),
557 compare_positive_ints
))
559 struct collect_cores_data data
;
560 struct cleanup
*back_to
561 = make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
563 ui_out_field_fmt (uiout
, "id", "i%d", inferior
->num
);
564 ui_out_field_string (uiout
, "type", "process");
565 if (inferior
->pid
!= 0)
566 ui_out_field_int (uiout
, "pid", inferior
->pid
);
568 if (inferior
->pspace
->ebfd
)
570 ui_out_field_string (uiout
, "executable",
571 bfd_get_filename (inferior
->pspace
->ebfd
));
575 if (inferior
->pid
!= 0)
577 data
.pid
= inferior
->pid
;
578 iterate_over_threads (collect_cores
, &data
);
581 if (!VEC_empty (int, data
.cores
))
584 struct cleanup
*back_to_2
=
585 make_cleanup_ui_out_list_begin_end (uiout
, "cores");
587 qsort (VEC_address (int, data
.cores
),
588 VEC_length (int, data
.cores
), sizeof (int),
589 compare_positive_ints
);
591 b
= VEC_address (int, data
.cores
);
592 e
= b
+ VEC_length (int, data
.cores
);
596 ui_out_field_int (uiout
, NULL
, *b
);
598 do_cleanups (back_to_2
);
601 if (top_data
->recurse
)
602 print_thread_info (uiout
, NULL
, inferior
->pid
);
604 do_cleanups (back_to
);
610 /* Output a field named 'cores' with a list as the value. The elements of
611 the list are obtained by splitting 'cores' on comma. */
614 output_cores (struct ui_out
*uiout
, const char *field_name
, const char *xcores
)
616 struct cleanup
*back_to
= make_cleanup_ui_out_list_begin_end (uiout
,
618 char *cores
= xstrdup (xcores
);
621 make_cleanup (xfree
, cores
);
623 for (p
= strtok (p
, ","); p
; p
= strtok (NULL
, ","))
624 ui_out_field_string (uiout
, NULL
, p
);
626 do_cleanups (back_to
);
630 free_vector_of_ints (void *xvector
)
632 VEC (int) **vector
= xvector
;
634 VEC_free (int, *vector
);
638 do_nothing (splay_tree_key k
)
643 free_vector_of_osdata_items (splay_tree_value xvalue
)
645 VEC (osdata_item_s
) *value
= (VEC (osdata_item_s
) *) xvalue
;
647 /* We don't free the items itself, it will be done separately. */
648 VEC_free (osdata_item_s
, value
);
652 splay_tree_int_comparator (splay_tree_key xa
, splay_tree_key xb
)
661 free_splay_tree (void *xt
)
664 splay_tree_delete (t
);
668 list_available_thread_groups (VEC (int) *ids
, int recurse
)
671 struct osdata_item
*item
;
674 /* This keeps a map from integer (pid) to VEC (struct osdata_item *)*
675 The vector contains information about all threads for the given pid.
676 This is assigned an initial value to avoid "may be used uninitialized"
678 splay_tree tree
= NULL
;
680 /* get_osdata will throw if it cannot return data. */
681 data
= get_osdata ("processes");
682 make_cleanup_osdata_free (data
);
686 struct osdata
*threads
= get_osdata ("threads");
688 make_cleanup_osdata_free (threads
);
689 tree
= splay_tree_new (splay_tree_int_comparator
,
691 free_vector_of_osdata_items
);
692 make_cleanup (free_splay_tree
, tree
);
695 VEC_iterate (osdata_item_s
, threads
->items
,
699 const char *pid
= get_osdata_column (item
, "pid");
700 int pid_i
= strtoul (pid
, NULL
, 0);
701 VEC (osdata_item_s
) *vec
= 0;
703 splay_tree_node n
= splay_tree_lookup (tree
, pid_i
);
706 VEC_safe_push (osdata_item_s
, vec
, item
);
707 splay_tree_insert (tree
, pid_i
, (splay_tree_value
)vec
);
711 vec
= (VEC (osdata_item_s
) *) n
->value
;
712 VEC_safe_push (osdata_item_s
, vec
, item
);
713 n
->value
= (splay_tree_value
) vec
;
718 make_cleanup_ui_out_list_begin_end (uiout
, "groups");
721 VEC_iterate (osdata_item_s
, data
->items
,
725 struct cleanup
*back_to
;
727 const char *pid
= get_osdata_column (item
, "pid");
728 const char *cmd
= get_osdata_column (item
, "command");
729 const char *user
= get_osdata_column (item
, "user");
730 const char *cores
= get_osdata_column (item
, "cores");
732 int pid_i
= strtoul (pid
, NULL
, 0);
734 /* At present, the target will return all available processes
735 and if information about specific ones was required, we filter
736 undesired processes here. */
737 if (ids
&& bsearch (&pid_i
, VEC_address (int, ids
),
738 VEC_length (int, ids
),
739 sizeof (int), compare_positive_ints
) == NULL
)
743 back_to
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
745 ui_out_field_fmt (uiout
, "id", "%s", pid
);
746 ui_out_field_string (uiout
, "type", "process");
748 ui_out_field_string (uiout
, "description", cmd
);
750 ui_out_field_string (uiout
, "user", user
);
752 output_cores (uiout
, "cores", cores
);
756 splay_tree_node n
= splay_tree_lookup (tree
, pid_i
);
759 VEC (osdata_item_s
) *children
= (VEC (osdata_item_s
) *) n
->value
;
760 struct osdata_item
*child
;
763 make_cleanup_ui_out_list_begin_end (uiout
, "threads");
766 VEC_iterate (osdata_item_s
, children
, ix_child
, child
);
769 struct cleanup
*back_to_2
=
770 make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
771 const char *tid
= get_osdata_column (child
, "tid");
772 const char *tcore
= get_osdata_column (child
, "core");
774 ui_out_field_string (uiout
, "id", tid
);
776 ui_out_field_string (uiout
, "core", tcore
);
778 do_cleanups (back_to_2
);
783 do_cleanups (back_to
);
788 mi_cmd_list_thread_groups (char *command
, char **argv
, int argc
)
790 struct cleanup
*back_to
;
797 AVAILABLE_OPT
, RECURSE_OPT
799 static struct mi_opt opts
[] =
801 {"-available", AVAILABLE_OPT
, 0},
802 {"-recurse", RECURSE_OPT
, 1},
811 int opt
= mi_getopt ("-list-thread-groups", argc
, argv
, opts
,
816 switch ((enum opt
) opt
)
822 if (strcmp (optarg
, "0") == 0)
824 else if (strcmp (optarg
, "1") == 0)
827 error (_("only '0' and '1' are valid values "
828 "for the '--recurse' option"));
833 for (; optind
< argc
; ++optind
)
838 if (*(argv
[optind
]) != 'i')
839 error (_("invalid syntax of group id '%s'"), argv
[optind
]);
841 inf
= strtoul (argv
[optind
] + 1, &end
, 0);
844 error (_("invalid syntax of group id '%s'"), argv
[optind
]);
845 VEC_safe_push (int, ids
, inf
);
847 if (VEC_length (int, ids
) > 1)
848 qsort (VEC_address (int, ids
),
849 VEC_length (int, ids
),
850 sizeof (int), compare_positive_ints
);
852 back_to
= make_cleanup (free_vector_of_ints
, &ids
);
856 list_available_thread_groups (ids
, recurse
);
858 else if (VEC_length (int, ids
) == 1)
860 /* Local thread groups, single id. */
861 int id
= *VEC_address (int, ids
);
862 struct inferior
*inf
= find_inferior_id (id
);
865 error (_("Non-existent thread group id '%d'"), id
);
867 print_thread_info (uiout
, NULL
, inf
->pid
);
871 struct print_one_inferior_data data
;
873 data
.recurse
= recurse
;
874 data
.inferiors
= ids
;
876 /* Local thread groups. Either no explicit ids -- and we
877 print everything, or several explicit ids. In both cases,
878 we print more than one group, and have to use 'groups'
879 as the top-level element. */
880 make_cleanup_ui_out_list_begin_end (uiout
, "groups");
881 update_thread_list ();
882 iterate_over_inferiors (print_one_inferior
, &data
);
885 do_cleanups (back_to
);
889 mi_cmd_data_list_register_names (char *command
, char **argv
, int argc
)
891 struct gdbarch
*gdbarch
;
894 struct cleanup
*cleanup
;
896 /* Note that the test for a valid register must include checking the
897 gdbarch_register_name because gdbarch_num_regs may be allocated for
898 the union of the register sets within a family of related processors.
899 In this case, some entries of gdbarch_register_name will change depending
900 upon the particular processor being debugged. */
902 gdbarch
= get_current_arch ();
903 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
905 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "register-names");
907 if (argc
== 0) /* No args, just do all the regs. */
913 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
914 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
915 ui_out_field_string (uiout
, NULL
, "");
917 ui_out_field_string (uiout
, NULL
,
918 gdbarch_register_name (gdbarch
, regnum
));
922 /* Else, list of register #s, just do listed regs. */
923 for (i
= 0; i
< argc
; i
++)
925 regnum
= atoi (argv
[i
]);
926 if (regnum
< 0 || regnum
>= numregs
)
927 error (_("bad register number"));
929 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
930 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
931 ui_out_field_string (uiout
, NULL
, "");
933 ui_out_field_string (uiout
, NULL
,
934 gdbarch_register_name (gdbarch
, regnum
));
936 do_cleanups (cleanup
);
940 mi_cmd_data_list_changed_registers (char *command
, char **argv
, int argc
)
942 static struct regcache
*this_regs
= NULL
;
943 struct regcache
*prev_regs
;
944 struct gdbarch
*gdbarch
;
945 int regnum
, numregs
, changed
;
947 struct cleanup
*cleanup
;
949 /* The last time we visited this function, the current frame's register
950 contents were saved in THIS_REGS. Move THIS_REGS over to PREV_REGS,
951 and refresh THIS_REGS with the now-current register contents. */
953 prev_regs
= this_regs
;
954 this_regs
= frame_save_as_regcache (get_selected_frame (NULL
));
955 cleanup
= make_cleanup_regcache_xfree (prev_regs
);
957 /* Note that the test for a valid register must include checking the
958 gdbarch_register_name because gdbarch_num_regs may be allocated for
959 the union of the register sets within a family of related processors.
960 In this case, some entries of gdbarch_register_name will change depending
961 upon the particular processor being debugged. */
963 gdbarch
= get_regcache_arch (this_regs
);
964 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
966 make_cleanup_ui_out_list_begin_end (uiout
, "changed-registers");
968 if (argc
== 0) /* No args, just do all the regs. */
974 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
975 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
977 changed
= register_changed_p (regnum
, prev_regs
, this_regs
);
979 error (_("-data-list-changed-registers: "
980 "Unable to read register contents."));
982 ui_out_field_int (uiout
, NULL
, regnum
);
986 /* Else, list of register #s, just do listed regs. */
987 for (i
= 0; i
< argc
; i
++)
989 regnum
= atoi (argv
[i
]);
993 && gdbarch_register_name (gdbarch
, regnum
) != NULL
994 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
996 changed
= register_changed_p (regnum
, prev_regs
, this_regs
);
998 error (_("-data-list-changed-registers: "
999 "Unable to read register contents."));
1001 ui_out_field_int (uiout
, NULL
, regnum
);
1004 error (_("bad register number"));
1006 do_cleanups (cleanup
);
1010 register_changed_p (int regnum
, struct regcache
*prev_regs
,
1011 struct regcache
*this_regs
)
1013 struct gdbarch
*gdbarch
= get_regcache_arch (this_regs
);
1014 gdb_byte prev_buffer
[MAX_REGISTER_SIZE
];
1015 gdb_byte this_buffer
[MAX_REGISTER_SIZE
];
1016 enum register_status prev_status
;
1017 enum register_status this_status
;
1019 /* First time through or after gdbarch change consider all registers
1021 if (!prev_regs
|| get_regcache_arch (prev_regs
) != gdbarch
)
1024 /* Get register contents and compare. */
1025 prev_status
= regcache_cooked_read (prev_regs
, regnum
, prev_buffer
);
1026 this_status
= regcache_cooked_read (this_regs
, regnum
, this_buffer
);
1028 if (this_status
!= prev_status
)
1030 else if (this_status
== REG_VALID
)
1031 return memcmp (prev_buffer
, this_buffer
,
1032 register_size (gdbarch
, regnum
)) != 0;
1037 /* Return a list of register number and value pairs. The valid
1038 arguments expected are: a letter indicating the format in which to
1039 display the registers contents. This can be one of: x (hexadecimal), d
1040 (decimal), N (natural), t (binary), o (octal), r (raw). After the
1041 format argumetn there can be a sequence of numbers, indicating which
1042 registers to fetch the content of. If the format is the only argument,
1043 a list of all the registers with their values is returned. */
1045 mi_cmd_data_list_register_values (char *command
, char **argv
, int argc
)
1047 struct frame_info
*frame
;
1048 struct gdbarch
*gdbarch
;
1049 int regnum
, numregs
, format
;
1051 struct cleanup
*list_cleanup
, *tuple_cleanup
;
1053 /* Note that the test for a valid register must include checking the
1054 gdbarch_register_name because gdbarch_num_regs may be allocated for
1055 the union of the register sets within a family of related processors.
1056 In this case, some entries of gdbarch_register_name will change depending
1057 upon the particular processor being debugged. */
1060 error (_("-data-list-register-values: Usage: "
1061 "-data-list-register-values <format> [<regnum1>...<regnumN>]"));
1063 format
= (int) argv
[0][0];
1065 frame
= get_selected_frame (NULL
);
1066 gdbarch
= get_frame_arch (frame
);
1067 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1069 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "register-values");
1071 if (argc
== 1) /* No args, beside the format: do all the regs. */
1077 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1078 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1080 tuple_cleanup
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1081 ui_out_field_int (uiout
, "number", regnum
);
1082 get_register (frame
, regnum
, format
);
1083 do_cleanups (tuple_cleanup
);
1087 /* Else, list of register #s, just do listed regs. */
1088 for (i
= 1; i
< argc
; i
++)
1090 regnum
= atoi (argv
[i
]);
1094 && gdbarch_register_name (gdbarch
, regnum
) != NULL
1095 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
1097 tuple_cleanup
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1098 ui_out_field_int (uiout
, "number", regnum
);
1099 get_register (frame
, regnum
, format
);
1100 do_cleanups (tuple_cleanup
);
1103 error (_("bad register number"));
1105 do_cleanups (list_cleanup
);
1108 /* Output one register's contents in the desired format. */
1110 get_register (struct frame_info
*frame
, int regnum
, int format
)
1112 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1114 enum lval_type lval
;
1115 static struct ui_stream
*stb
= NULL
;
1118 stb
= ui_out_stream_new (uiout
);
1123 val
= get_frame_register_value (frame
, regnum
);
1125 if (value_optimized_out (val
))
1126 error (_("Optimized out"));
1131 char *ptr
, buf
[1024];
1132 const gdb_byte
*valaddr
= value_contents_for_printing (val
);
1136 for (j
= 0; j
< register_size (gdbarch
, regnum
); j
++)
1138 int idx
= gdbarch_byte_order (gdbarch
) == BFD_ENDIAN_BIG
?
1139 j
: register_size (gdbarch
, regnum
) - 1 - j
;
1141 sprintf (ptr
, "%02x", (unsigned char) valaddr
[idx
]);
1144 ui_out_field_string (uiout
, "value", buf
);
1145 /*fputs_filtered (buf, gdb_stdout); */
1149 struct value_print_options opts
;
1151 get_formatted_print_options (&opts
, format
);
1153 val_print (value_type (val
),
1154 value_contents_for_printing (val
),
1155 value_embedded_offset (val
), 0,
1156 stb
->stream
, 0, val
, &opts
, current_language
);
1157 ui_out_field_stream (uiout
, "value", stb
);
1158 ui_out_stream_delete (stb
);
1162 /* Write given values into registers. The registers and values are
1163 given as pairs. The corresponding MI command is
1164 -data-write-register-values <format>
1165 [<regnum1> <value1>...<regnumN> <valueN>] */
1167 mi_cmd_data_write_register_values (char *command
, char **argv
, int argc
)
1169 struct regcache
*regcache
;
1170 struct gdbarch
*gdbarch
;
1174 /* Note that the test for a valid register must include checking the
1175 gdbarch_register_name because gdbarch_num_regs may be allocated for
1176 the union of the register sets within a family of related processors.
1177 In this case, some entries of gdbarch_register_name will change depending
1178 upon the particular processor being debugged. */
1180 regcache
= get_current_regcache ();
1181 gdbarch
= get_regcache_arch (regcache
);
1182 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1185 error (_("-data-write-register-values: Usage: -data-write-register-"
1186 "values <format> [<regnum1> <value1>...<regnumN> <valueN>]"));
1188 format
= (int) argv
[0][0];
1190 if (!target_has_registers
)
1191 error (_("-data-write-register-values: No registers."));
1194 error (_("-data-write-register-values: No regs and values specified."));
1197 error (_("-data-write-register-values: "
1198 "Regs and vals are not in pairs."));
1200 for (i
= 1; i
< argc
; i
= i
+ 2)
1202 int regnum
= atoi (argv
[i
]);
1204 if (regnum
>= 0 && regnum
< numregs
1205 && gdbarch_register_name (gdbarch
, regnum
)
1206 && *gdbarch_register_name (gdbarch
, regnum
))
1210 /* Get the value as a number. */
1211 value
= parse_and_eval_address (argv
[i
+ 1]);
1213 /* Write it down. */
1214 regcache_cooked_write_signed (regcache
, regnum
, value
);
1217 error (_("bad register number"));
1221 /* Evaluate the value of the argument. The argument is an
1222 expression. If the expression contains spaces it needs to be
1223 included in double quotes. */
1225 mi_cmd_data_evaluate_expression (char *command
, char **argv
, int argc
)
1227 struct expression
*expr
;
1228 struct cleanup
*old_chain
= NULL
;
1230 struct ui_stream
*stb
= NULL
;
1231 struct value_print_options opts
;
1233 stb
= ui_out_stream_new (uiout
);
1237 ui_out_stream_delete (stb
);
1238 error (_("-data-evaluate-expression: "
1239 "Usage: -data-evaluate-expression expression"));
1242 expr
= parse_expression (argv
[0]);
1244 old_chain
= make_cleanup (free_current_contents
, &expr
);
1246 val
= evaluate_expression (expr
);
1248 /* Print the result of the expression evaluation. */
1249 get_user_print_options (&opts
);
1251 common_val_print (val
, stb
->stream
, 0, &opts
, current_language
);
1253 ui_out_field_stream (uiout
, "value", stb
);
1254 ui_out_stream_delete (stb
);
1256 do_cleanups (old_chain
);
1259 /* DATA-MEMORY-READ:
1261 ADDR: start address of data to be dumped.
1262 WORD-FORMAT: a char indicating format for the ``word''. See
1264 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes.
1265 NR_ROW: Number of rows.
1266 NR_COL: The number of colums (words per row).
1267 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
1268 ASCHAR for unprintable characters.
1270 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
1271 displayes them. Returns:
1273 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
1276 The number of bytes read is SIZE*ROW*COL. */
1279 mi_cmd_data_read_memory (char *command
, char **argv
, int argc
)
1281 struct gdbarch
*gdbarch
= get_current_arch ();
1282 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
1288 struct type
*word_type
;
1301 static struct mi_opt opts
[] =
1303 {"o", OFFSET_OPT
, 1},
1309 int opt
= mi_getopt ("-data-read-memory", argc
, argv
, opts
,
1314 switch ((enum opt
) opt
)
1317 offset
= atol (optarg
);
1324 if (argc
< 5 || argc
> 6)
1325 error (_("-data-read-memory: Usage: "
1326 "ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR]."));
1328 /* Extract all the arguments. */
1330 /* Start address of the memory dump. */
1331 addr
= parse_and_eval_address (argv
[0]) + offset
;
1332 /* The format character to use when displaying a memory word. See
1333 the ``x'' command. */
1334 word_format
= argv
[1][0];
1335 /* The size of the memory word. */
1336 word_size
= atol (argv
[2]);
1340 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1344 word_type
= builtin_type (gdbarch
)->builtin_int16
;
1348 word_type
= builtin_type (gdbarch
)->builtin_int32
;
1352 word_type
= builtin_type (gdbarch
)->builtin_int64
;
1356 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1359 /* The number of rows. */
1360 nr_rows
= atol (argv
[3]);
1362 error (_("-data-read-memory: invalid number of rows."));
1364 /* Number of bytes per row. */
1365 nr_cols
= atol (argv
[4]);
1367 error (_("-data-read-memory: invalid number of columns."));
1369 /* The un-printable character when printing ascii. */
1375 /* Create a buffer and read it in. */
1376 total_bytes
= word_size
* nr_rows
* nr_cols
;
1377 mbuf
= xcalloc (total_bytes
, 1);
1378 make_cleanup (xfree
, mbuf
);
1380 /* Dispatch memory reads to the topmost target, not the flattened
1382 nr_bytes
= target_read (current_target
.beneath
,
1383 TARGET_OBJECT_MEMORY
, NULL
, mbuf
,
1386 error (_("Unable to read memory."));
1388 /* Output the header information. */
1389 ui_out_field_core_addr (uiout
, "addr", gdbarch
, addr
);
1390 ui_out_field_int (uiout
, "nr-bytes", nr_bytes
);
1391 ui_out_field_int (uiout
, "total-bytes", total_bytes
);
1392 ui_out_field_core_addr (uiout
, "next-row",
1393 gdbarch
, addr
+ word_size
* nr_cols
);
1394 ui_out_field_core_addr (uiout
, "prev-row",
1395 gdbarch
, addr
- word_size
* nr_cols
);
1396 ui_out_field_core_addr (uiout
, "next-page", gdbarch
, addr
+ total_bytes
);
1397 ui_out_field_core_addr (uiout
, "prev-page", gdbarch
, addr
- total_bytes
);
1399 /* Build the result as a two dimentional table. */
1401 struct ui_stream
*stream
= ui_out_stream_new (uiout
);
1402 struct cleanup
*cleanup_list_memory
;
1406 cleanup_list_memory
= make_cleanup_ui_out_list_begin_end (uiout
, "memory");
1407 for (row
= 0, row_byte
= 0;
1409 row
++, row_byte
+= nr_cols
* word_size
)
1413 struct cleanup
*cleanup_tuple
;
1414 struct cleanup
*cleanup_list_data
;
1415 struct value_print_options opts
;
1417 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1418 ui_out_field_core_addr (uiout
, "addr", gdbarch
, addr
+ row_byte
);
1419 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr +
1421 cleanup_list_data
= make_cleanup_ui_out_list_begin_end (uiout
, "data");
1422 get_formatted_print_options (&opts
, word_format
);
1423 for (col
= 0, col_byte
= row_byte
;
1425 col
++, col_byte
+= word_size
)
1427 if (col_byte
+ word_size
> nr_bytes
)
1429 ui_out_field_string (uiout
, NULL
, "N/A");
1433 ui_file_rewind (stream
->stream
);
1434 print_scalar_formatted (mbuf
+ col_byte
, word_type
, &opts
,
1435 word_asize
, stream
->stream
);
1436 ui_out_field_stream (uiout
, NULL
, stream
);
1439 do_cleanups (cleanup_list_data
);
1444 ui_file_rewind (stream
->stream
);
1445 for (byte
= row_byte
;
1446 byte
< row_byte
+ word_size
* nr_cols
; byte
++)
1448 if (byte
>= nr_bytes
)
1450 fputc_unfiltered ('X', stream
->stream
);
1452 else if (mbuf
[byte
] < 32 || mbuf
[byte
] > 126)
1454 fputc_unfiltered (aschar
, stream
->stream
);
1457 fputc_unfiltered (mbuf
[byte
], stream
->stream
);
1459 ui_out_field_stream (uiout
, "ascii", stream
);
1461 do_cleanups (cleanup_tuple
);
1463 ui_out_stream_delete (stream
);
1464 do_cleanups (cleanup_list_memory
);
1466 do_cleanups (cleanups
);
1470 mi_cmd_data_read_memory_bytes (char *command
, char **argv
, int argc
)
1472 struct gdbarch
*gdbarch
= get_current_arch ();
1473 struct cleanup
*cleanups
;
1476 memory_read_result_s
*read_result
;
1478 VEC(memory_read_result_s
) *result
;
1486 static struct mi_opt opts
[] =
1488 {"o", OFFSET_OPT
, 1},
1494 int opt
= mi_getopt ("-data-read-memory-bytes", argc
, argv
, opts
,
1498 switch ((enum opt
) opt
)
1501 offset
= atol (optarg
);
1509 error (_("Usage: [ -o OFFSET ] ADDR LENGTH."));
1511 addr
= parse_and_eval_address (argv
[0]) + offset
;
1512 length
= atol (argv
[1]);
1514 result
= read_memory_robust (current_target
.beneath
, addr
, length
);
1516 cleanups
= make_cleanup (free_memory_read_result_vector
, result
);
1518 if (VEC_length (memory_read_result_s
, result
) == 0)
1519 error (_("Unable to read memory."));
1521 make_cleanup_ui_out_list_begin_end (uiout
, "memory");
1523 VEC_iterate (memory_read_result_s
, result
, ix
, read_result
);
1526 struct cleanup
*t
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1530 ui_out_field_core_addr (uiout
, "begin", gdbarch
, read_result
->begin
);
1531 ui_out_field_core_addr (uiout
, "offset", gdbarch
, read_result
->begin
1533 ui_out_field_core_addr (uiout
, "end", gdbarch
, read_result
->end
);
1535 data
= xmalloc ((read_result
->end
- read_result
->begin
) * 2 + 1);
1537 for (i
= 0, p
= data
;
1538 i
< (read_result
->end
- read_result
->begin
);
1541 sprintf (p
, "%02x", read_result
->data
[i
]);
1543 ui_out_field_string (uiout
, "contents", data
);
1547 do_cleanups (cleanups
);
1551 /* DATA-MEMORY-WRITE:
1553 COLUMN_OFFSET: optional argument. Must be preceded by '-o'. The
1554 offset from the beginning of the memory grid row where the cell to
1556 ADDR: start address of the row in the memory grid where the memory
1557 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
1558 the location to write to.
1559 FORMAT: a char indicating format for the ``word''. See
1561 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
1562 VALUE: value to be written into the memory address.
1564 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
1568 mi_cmd_data_write_memory (char *command
, char **argv
, int argc
)
1570 struct gdbarch
*gdbarch
= get_current_arch ();
1571 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1575 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
1576 enough when using a compiler other than GCC. */
1579 struct cleanup
*old_chain
;
1587 static struct mi_opt opts
[] =
1589 {"o", OFFSET_OPT
, 1},
1595 int opt
= mi_getopt ("-data-write-memory", argc
, argv
, opts
,
1600 switch ((enum opt
) opt
)
1603 offset
= atol (optarg
);
1611 error (_("-data-write-memory: Usage: "
1612 "[-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE."));
1614 /* Extract all the arguments. */
1615 /* Start address of the memory dump. */
1616 addr
= parse_and_eval_address (argv
[0]);
1617 /* The format character to use when displaying a memory word. See
1618 the ``x'' command. */
1619 word_format
= argv
[1][0];
1620 /* The size of the memory word. */
1621 word_size
= atol (argv
[2]);
1623 /* Calculate the real address of the write destination. */
1624 addr
+= (offset
* word_size
);
1626 /* Get the value as a number. */
1627 value
= parse_and_eval_address (argv
[3]);
1628 /* Get the value into an array. */
1629 buffer
= xmalloc (word_size
);
1630 old_chain
= make_cleanup (xfree
, buffer
);
1631 store_signed_integer (buffer
, word_size
, byte_order
, value
);
1632 /* Write it down to memory. */
1633 write_memory (addr
, buffer
, word_size
);
1634 /* Free the buffer. */
1635 do_cleanups (old_chain
);
1638 /* DATA-MEMORY-WRITE-RAW:
1641 DATA: string of bytes to write at that address. */
1643 mi_cmd_data_write_memory_bytes (char *command
, char **argv
, int argc
)
1649 struct cleanup
*back_to
;
1652 error (_("Usage: ADDR DATA."));
1654 addr
= parse_and_eval_address (argv
[0]);
1656 len
= strlen (cdata
)/2;
1658 data
= xmalloc (len
);
1659 back_to
= make_cleanup (xfree
, data
);
1661 for (i
= 0; i
< len
; ++i
)
1664 sscanf (cdata
+ i
* 2, "%02x", &x
);
1665 data
[i
] = (gdb_byte
)x
;
1668 r
= target_write_memory (addr
, data
, len
);
1670 error (_("Could not write memory"));
1672 do_cleanups (back_to
);
1677 mi_cmd_enable_timings (char *command
, char **argv
, int argc
)
1683 if (strcmp (argv
[0], "yes") == 0)
1685 else if (strcmp (argv
[0], "no") == 0)
1696 error (_("-enable-timings: Usage: %s {yes|no}"), command
);
1700 mi_cmd_list_features (char *command
, char **argv
, int argc
)
1704 struct cleanup
*cleanup
= NULL
;
1706 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "features");
1707 ui_out_field_string (uiout
, NULL
, "frozen-varobjs");
1708 ui_out_field_string (uiout
, NULL
, "pending-breakpoints");
1709 ui_out_field_string (uiout
, NULL
, "thread-info");
1710 ui_out_field_string (uiout
, NULL
, "data-read-memory-bytes");
1711 ui_out_field_string (uiout
, NULL
, "breakpoint-notifications");
1714 ui_out_field_string (uiout
, NULL
, "python");
1717 do_cleanups (cleanup
);
1721 error (_("-list-features should be passed no arguments"));
1725 mi_cmd_list_target_features (char *command
, char **argv
, int argc
)
1729 struct cleanup
*cleanup
= NULL
;
1731 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "features");
1732 if (target_can_async_p ())
1733 ui_out_field_string (uiout
, NULL
, "async");
1734 if (target_can_execute_reverse
)
1735 ui_out_field_string (uiout
, NULL
, "reverse");
1737 do_cleanups (cleanup
);
1741 error (_("-list-target-features should be passed no arguments"));
1745 mi_cmd_add_inferior (char *command
, char **argv
, int argc
)
1747 struct inferior
*inf
;
1750 error (_("-add-inferior should be passed no arguments"));
1752 inf
= add_inferior_with_spaces ();
1754 ui_out_field_fmt (uiout
, "inferior", "i%d", inf
->num
);
1757 /* Callback used to find the first inferior other than the
1761 get_other_inferior (struct inferior
*inf
, void *arg
)
1763 if (inf
== current_inferior ())
1770 mi_cmd_remove_inferior (char *command
, char **argv
, int argc
)
1773 struct inferior
*inf
;
1776 error (_("-remove-inferior should be passed a single argument"));
1778 if (sscanf (argv
[0], "i%d", &id
) != 1)
1779 error (_("the thread group id is syntactically invalid"));
1781 inf
= find_inferior_id (id
);
1783 error (_("the specified thread group does not exist"));
1786 error (_("cannot remove an active inferior"));
1788 if (inf
== current_inferior ())
1790 struct thread_info
*tp
= 0;
1791 struct inferior
*new_inferior
1792 = iterate_over_inferiors (get_other_inferior
, NULL
);
1794 if (new_inferior
== NULL
)
1795 error (_("Cannot remove last inferior"));
1797 set_current_inferior (new_inferior
);
1798 if (new_inferior
->pid
!= 0)
1799 tp
= any_thread_of_process (new_inferior
->pid
);
1800 switch_to_thread (tp
? tp
->ptid
: null_ptid
);
1801 set_current_program_space (new_inferior
->pspace
);
1804 delete_inferior_1 (inf
, 1 /* silent */);
1809 /* Execute a command within a safe environment.
1810 Return <0 for error; >=0 for ok.
1812 args->action will tell mi_execute_command what action
1813 to perfrom after the given command has executed (display/suppress
1814 prompt, display error). */
1817 captured_mi_execute_command (struct ui_out
*uiout
, struct mi_parse
*context
)
1819 struct cleanup
*cleanup
;
1822 current_command_ts
= context
->cmd_start
;
1824 current_token
= xstrdup (context
->token
);
1825 cleanup
= make_cleanup (free_current_contents
, ¤t_token
);
1827 running_result_record_printed
= 0;
1829 switch (context
->op
)
1832 /* A MI command was read from the input stream. */
1834 /* FIXME: gdb_???? */
1835 fprintf_unfiltered (raw_stdout
, " token=`%s' command=`%s' args=`%s'\n",
1836 context
->token
, context
->command
, context
->args
);
1839 mi_cmd_execute (context
);
1841 /* Print the result if there were no errors.
1843 Remember that on the way out of executing a command, you have
1844 to directly use the mi_interp's uiout, since the command could
1845 have reset the interpreter, in which case the current uiout
1846 will most likely crash in the mi_out_* routines. */
1847 if (!running_result_record_printed
)
1849 fputs_unfiltered (context
->token
, raw_stdout
);
1850 /* There's no particularly good reason why target-connect results
1851 in not ^done. Should kill ^connected for MI3. */
1852 fputs_unfiltered (strcmp (context
->command
, "target-select") == 0
1853 ? "^connected" : "^done", raw_stdout
);
1854 mi_out_put (uiout
, raw_stdout
);
1855 mi_out_rewind (uiout
);
1856 mi_print_timing_maybe ();
1857 fputs_unfiltered ("\n", raw_stdout
);
1860 /* The command does not want anything to be printed. In that
1861 case, the command probably should not have written anything
1862 to uiout, but in case it has written something, discard it. */
1863 mi_out_rewind (uiout
);
1870 /* A CLI command was read from the input stream. */
1871 /* This "feature" will be removed as soon as we have a
1872 complete set of mi commands. */
1873 /* Echo the command on the console. */
1874 fprintf_unfiltered (gdb_stdlog
, "%s\n", context
->command
);
1875 /* Call the "console" interpreter. */
1876 argv
[0] = "console";
1877 argv
[1] = context
->command
;
1878 mi_cmd_interpreter_exec ("-interpreter-exec", argv
, 2);
1880 /* If we changed interpreters, DON'T print out anything. */
1881 if (current_interp_named_p (INTERP_MI
)
1882 || current_interp_named_p (INTERP_MI1
)
1883 || current_interp_named_p (INTERP_MI2
)
1884 || current_interp_named_p (INTERP_MI3
))
1886 if (!running_result_record_printed
)
1888 fputs_unfiltered (context
->token
, raw_stdout
);
1889 fputs_unfiltered ("^done", raw_stdout
);
1890 mi_out_put (uiout
, raw_stdout
);
1891 mi_out_rewind (uiout
);
1892 mi_print_timing_maybe ();
1893 fputs_unfiltered ("\n", raw_stdout
);
1896 mi_out_rewind (uiout
);
1903 do_cleanups (cleanup
);
1908 /* Print a gdb exception to the MI output stream. */
1911 mi_print_exception (const char *token
, struct gdb_exception exception
)
1913 fputs_unfiltered (token
, raw_stdout
);
1914 fputs_unfiltered ("^error,msg=\"", raw_stdout
);
1915 if (exception
.message
== NULL
)
1916 fputs_unfiltered ("unknown error", raw_stdout
);
1918 fputstr_unfiltered (exception
.message
, '"', raw_stdout
);
1919 fputs_unfiltered ("\"\n", raw_stdout
);
1923 mi_execute_command (char *cmd
, int from_tty
)
1926 struct mi_parse
*command
= NULL
;
1927 volatile struct gdb_exception exception
;
1929 /* This is to handle EOF (^D). We just quit gdb. */
1930 /* FIXME: we should call some API function here. */
1932 quit_force (NULL
, from_tty
);
1934 target_log_command (cmd
);
1936 TRY_CATCH (exception
, RETURN_MASK_ALL
)
1938 command
= mi_parse (cmd
, &token
);
1940 if (exception
.reason
< 0)
1942 mi_print_exception (token
, exception
);
1947 volatile struct gdb_exception result
;
1948 ptid_t previous_ptid
= inferior_ptid
;
1950 command
->token
= token
;
1954 command
->cmd_start
= (struct mi_timestamp
*)
1955 xmalloc (sizeof (struct mi_timestamp
));
1956 timestamp (command
->cmd_start
);
1959 TRY_CATCH (result
, RETURN_MASK_ALL
)
1961 captured_mi_execute_command (uiout
, command
);
1963 if (result
.reason
< 0)
1965 /* The command execution failed and error() was called
1967 mi_print_exception (command
->token
, result
);
1968 mi_out_rewind (uiout
);
1971 bpstat_do_actions ();
1973 if (/* The notifications are only output when the top-level
1974 interpreter (specified on the command line) is MI. */
1975 ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ()))
1976 /* Don't try report anything if there are no threads --
1977 the program is dead. */
1978 && thread_count () != 0
1979 /* -thread-select explicitly changes thread. If frontend uses that
1980 internally, we don't want to emit =thread-selected, since
1981 =thread-selected is supposed to indicate user's intentions. */
1982 && strcmp (command
->command
, "thread-select") != 0)
1984 struct mi_interp
*mi
= top_level_interpreter_data ();
1985 int report_change
= 0;
1987 if (command
->thread
== -1)
1989 report_change
= (!ptid_equal (previous_ptid
, null_ptid
)
1990 && !ptid_equal (inferior_ptid
, previous_ptid
)
1991 && !ptid_equal (inferior_ptid
, null_ptid
));
1993 else if (!ptid_equal (inferior_ptid
, null_ptid
))
1995 struct thread_info
*ti
= inferior_thread ();
1997 report_change
= (ti
->num
!= command
->thread
);
2002 struct thread_info
*ti
= inferior_thread ();
2004 target_terminal_ours ();
2005 fprintf_unfiltered (mi
->event_channel
,
2006 "thread-selected,id=\"%d\"",
2008 gdb_flush (mi
->event_channel
);
2012 mi_parse_free (command
);
2015 fputs_unfiltered ("(gdb) \n", raw_stdout
);
2016 gdb_flush (raw_stdout
);
2017 /* Print any buffered hook code. */
2022 mi_cmd_execute (struct mi_parse
*parse
)
2024 struct cleanup
*cleanup
;
2026 cleanup
= prepare_execute_command ();
2028 if (parse
->all
&& parse
->thread_group
!= -1)
2029 error (_("Cannot specify --thread-group together with --all"));
2031 if (parse
->all
&& parse
->thread
!= -1)
2032 error (_("Cannot specify --thread together with --all"));
2034 if (parse
->thread_group
!= -1 && parse
->thread
!= -1)
2035 error (_("Cannot specify --thread together with --thread-group"));
2037 if (parse
->frame
!= -1 && parse
->thread
== -1)
2038 error (_("Cannot specify --frame without --thread"));
2040 if (parse
->thread_group
!= -1)
2042 struct inferior
*inf
= find_inferior_id (parse
->thread_group
);
2043 struct thread_info
*tp
= 0;
2046 error (_("Invalid thread group for the --thread-group option"));
2048 set_current_inferior (inf
);
2049 /* This behaviour means that if --thread-group option identifies
2050 an inferior with multiple threads, then a random one will be picked.
2051 This is not a problem -- frontend should always provide --thread if
2052 it wishes to operate on a specific thread. */
2054 tp
= any_thread_of_process (inf
->pid
);
2055 switch_to_thread (tp
? tp
->ptid
: null_ptid
);
2056 set_current_program_space (inf
->pspace
);
2059 if (parse
->thread
!= -1)
2061 struct thread_info
*tp
= find_thread_id (parse
->thread
);
2064 error (_("Invalid thread id: %d"), parse
->thread
);
2066 if (is_exited (tp
->ptid
))
2067 error (_("Thread id: %d has terminated"), parse
->thread
);
2069 switch_to_thread (tp
->ptid
);
2072 if (parse
->frame
!= -1)
2074 struct frame_info
*fid
;
2075 int frame
= parse
->frame
;
2077 fid
= find_relative_frame (get_current_frame (), &frame
);
2079 /* find_relative_frame was successful */
2082 error (_("Invalid frame id: %d"), frame
);
2085 current_context
= parse
;
2087 if (strncmp (parse
->command
, "break-", sizeof ("break-") - 1 ) == 0)
2089 make_cleanup_restore_integer (&mi_suppress_breakpoint_notifications
);
2090 mi_suppress_breakpoint_notifications
= 1;
2093 if (parse
->cmd
->argv_func
!= NULL
)
2095 parse
->cmd
->argv_func (parse
->command
, parse
->argv
, parse
->argc
);
2097 else if (parse
->cmd
->cli
.cmd
!= 0)
2099 /* FIXME: DELETE THIS. */
2100 /* The operation is still implemented by a cli command. */
2101 /* Must be a synchronous one. */
2102 mi_execute_cli_command (parse
->cmd
->cli
.cmd
, parse
->cmd
->cli
.args_p
,
2107 /* FIXME: DELETE THIS. */
2108 struct ui_file
*stb
;
2110 stb
= mem_fileopen ();
2112 fputs_unfiltered ("Undefined mi command: ", stb
);
2113 fputstr_unfiltered (parse
->command
, '"', stb
);
2114 fputs_unfiltered (" (missing implementation)", stb
);
2116 make_cleanup_ui_file_delete (stb
);
2119 do_cleanups (cleanup
);
2122 /* FIXME: This is just a hack so we can get some extra commands going.
2123 We don't want to channel things through the CLI, but call libgdb directly.
2124 Use only for synchronous commands. */
2127 mi_execute_cli_command (const char *cmd
, int args_p
, const char *args
)
2131 struct cleanup
*old_cleanups
;
2135 run
= xstrprintf ("%s %s", cmd
, args
);
2137 run
= xstrdup (cmd
);
2139 /* FIXME: gdb_???? */
2140 fprintf_unfiltered (gdb_stdout
, "cli=%s run=%s\n",
2142 old_cleanups
= make_cleanup (xfree
, run
);
2143 execute_command ( /*ui */ run
, 0 /*from_tty */ );
2144 do_cleanups (old_cleanups
);
2150 mi_execute_async_cli_command (char *cli_command
, char **argv
, int argc
)
2152 struct cleanup
*old_cleanups
;
2155 if (target_can_async_p ())
2156 run
= xstrprintf ("%s %s&", cli_command
, argc
? *argv
: "");
2158 run
= xstrprintf ("%s %s", cli_command
, argc
? *argv
: "");
2159 old_cleanups
= make_cleanup (xfree
, run
);
2161 execute_command ( /*ui */ run
, 0 /*from_tty */ );
2163 /* Do this before doing any printing. It would appear that some
2164 print code leaves garbage around in the buffer. */
2165 do_cleanups (old_cleanups
);
2169 mi_load_progress (const char *section_name
,
2170 unsigned long sent_so_far
,
2171 unsigned long total_section
,
2172 unsigned long total_sent
,
2173 unsigned long grand_total
)
2175 struct timeval time_now
, delta
, update_threshold
;
2176 static struct timeval last_update
;
2177 static char *previous_sect_name
= NULL
;
2179 struct ui_out
*saved_uiout
;
2181 /* This function is called through deprecated_show_load_progress
2182 which means uiout may not be correct. Fix it for the duration
2183 of this function. */
2184 saved_uiout
= uiout
;
2186 if (current_interp_named_p (INTERP_MI
)
2187 || current_interp_named_p (INTERP_MI2
))
2188 uiout
= mi_out_new (2);
2189 else if (current_interp_named_p (INTERP_MI1
))
2190 uiout
= mi_out_new (1);
2191 else if (current_interp_named_p (INTERP_MI3
))
2192 uiout
= mi_out_new (3);
2196 update_threshold
.tv_sec
= 0;
2197 update_threshold
.tv_usec
= 500000;
2198 gettimeofday (&time_now
, NULL
);
2200 delta
.tv_usec
= time_now
.tv_usec
- last_update
.tv_usec
;
2201 delta
.tv_sec
= time_now
.tv_sec
- last_update
.tv_sec
;
2203 if (delta
.tv_usec
< 0)
2206 delta
.tv_usec
+= 1000000L;
2209 new_section
= (previous_sect_name
?
2210 strcmp (previous_sect_name
, section_name
) : 1);
2213 struct cleanup
*cleanup_tuple
;
2215 xfree (previous_sect_name
);
2216 previous_sect_name
= xstrdup (section_name
);
2219 fputs_unfiltered (current_token
, raw_stdout
);
2220 fputs_unfiltered ("+download", raw_stdout
);
2221 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2222 ui_out_field_string (uiout
, "section", section_name
);
2223 ui_out_field_int (uiout
, "section-size", total_section
);
2224 ui_out_field_int (uiout
, "total-size", grand_total
);
2225 do_cleanups (cleanup_tuple
);
2226 mi_out_put (uiout
, raw_stdout
);
2227 fputs_unfiltered ("\n", raw_stdout
);
2228 gdb_flush (raw_stdout
);
2231 if (delta
.tv_sec
>= update_threshold
.tv_sec
&&
2232 delta
.tv_usec
>= update_threshold
.tv_usec
)
2234 struct cleanup
*cleanup_tuple
;
2236 last_update
.tv_sec
= time_now
.tv_sec
;
2237 last_update
.tv_usec
= time_now
.tv_usec
;
2239 fputs_unfiltered (current_token
, raw_stdout
);
2240 fputs_unfiltered ("+download", raw_stdout
);
2241 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2242 ui_out_field_string (uiout
, "section", section_name
);
2243 ui_out_field_int (uiout
, "section-sent", sent_so_far
);
2244 ui_out_field_int (uiout
, "section-size", total_section
);
2245 ui_out_field_int (uiout
, "total-sent", total_sent
);
2246 ui_out_field_int (uiout
, "total-size", grand_total
);
2247 do_cleanups (cleanup_tuple
);
2248 mi_out_put (uiout
, raw_stdout
);
2249 fputs_unfiltered ("\n", raw_stdout
);
2250 gdb_flush (raw_stdout
);
2254 uiout
= saved_uiout
;
2258 timestamp (struct mi_timestamp
*tv
)
2260 gettimeofday (&tv
->wallclock
, NULL
);
2261 #ifdef HAVE_GETRUSAGE
2262 getrusage (RUSAGE_SELF
, &rusage
);
2263 tv
->utime
.tv_sec
= rusage
.ru_utime
.tv_sec
;
2264 tv
->utime
.tv_usec
= rusage
.ru_utime
.tv_usec
;
2265 tv
->stime
.tv_sec
= rusage
.ru_stime
.tv_sec
;
2266 tv
->stime
.tv_usec
= rusage
.ru_stime
.tv_usec
;
2269 long usec
= get_run_time ();
2271 tv
->utime
.tv_sec
= usec
/1000000L;
2272 tv
->utime
.tv_usec
= usec
- 1000000L*tv
->utime
.tv_sec
;
2273 tv
->stime
.tv_sec
= 0;
2274 tv
->stime
.tv_usec
= 0;
2280 print_diff_now (struct mi_timestamp
*start
)
2282 struct mi_timestamp now
;
2285 print_diff (start
, &now
);
2289 mi_print_timing_maybe (void)
2291 /* If the command is -enable-timing then do_timings may be
2292 true whilst current_command_ts is not initialized. */
2293 if (do_timings
&& current_command_ts
)
2294 print_diff_now (current_command_ts
);
2298 timeval_diff (struct timeval start
, struct timeval end
)
2300 return ((end
.tv_sec
- start
.tv_sec
) * 1000000L)
2301 + (end
.tv_usec
- start
.tv_usec
);
2305 print_diff (struct mi_timestamp
*start
, struct mi_timestamp
*end
)
2309 ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
2310 timeval_diff (start
->wallclock
, end
->wallclock
) / 1000000.0,
2311 timeval_diff (start
->utime
, end
->utime
) / 1000000.0,
2312 timeval_diff (start
->stime
, end
->stime
) / 1000000.0);
2316 mi_cmd_trace_define_variable (char *command
, char **argv
, int argc
)
2318 struct expression
*expr
;
2319 struct cleanup
*back_to
;
2320 LONGEST initval
= 0;
2321 struct trace_state_variable
*tsv
;
2324 if (argc
!= 1 && argc
!= 2)
2325 error (_("Usage: -trace-define-variable VARIABLE [VALUE]"));
2327 expr
= parse_expression (argv
[0]);
2328 back_to
= make_cleanup (xfree
, expr
);
2330 if (expr
->nelts
== 3 && expr
->elts
[0].opcode
== OP_INTERNALVAR
)
2332 struct internalvar
*intvar
= expr
->elts
[1].internalvar
;
2335 name
= internalvar_name (intvar
);
2338 if (!name
|| *name
== '\0')
2339 error (_("Invalid name of trace variable"));
2341 tsv
= find_trace_state_variable (name
);
2343 tsv
= create_trace_state_variable (name
);
2346 initval
= value_as_long (parse_and_eval (argv
[1]));
2348 tsv
->initial_value
= initval
;
2350 do_cleanups (back_to
);
2354 mi_cmd_trace_list_variables (char *command
, char **argv
, int argc
)
2357 error (_("-trace-list-variables: no arguments are allowed"));
2359 tvariables_info_1 ();
2363 mi_cmd_trace_find (char *command
, char **argv
, int argc
)
2368 error (_("trace selection mode is required"));
2372 if (strcmp (mode
, "none") == 0)
2374 tfind_1 (tfind_number
, -1, 0, 0, 0);
2378 if (current_trace_status ()->running
)
2379 error (_("May not look at trace frames while trace is running."));
2381 if (strcmp (mode
, "frame-number") == 0)
2384 error (_("frame number is required"));
2385 tfind_1 (tfind_number
, atoi (argv
[1]), 0, 0, 0);
2387 else if (strcmp (mode
, "tracepoint-number") == 0)
2390 error (_("tracepoint number is required"));
2391 tfind_1 (tfind_tp
, atoi (argv
[1]), 0, 0, 0);
2393 else if (strcmp (mode
, "pc") == 0)
2396 error (_("PC is required"));
2397 tfind_1 (tfind_pc
, 0, parse_and_eval_address (argv
[1]), 0, 0);
2399 else if (strcmp (mode
, "pc-inside-range") == 0)
2402 error (_("Start and end PC are required"));
2403 tfind_1 (tfind_range
, 0, parse_and_eval_address (argv
[1]),
2404 parse_and_eval_address (argv
[2]), 0);
2406 else if (strcmp (mode
, "pc-outside-range") == 0)
2409 error (_("Start and end PC are required"));
2410 tfind_1 (tfind_outside
, 0, parse_and_eval_address (argv
[1]),
2411 parse_and_eval_address (argv
[2]), 0);
2413 else if (strcmp (mode
, "line") == 0)
2415 struct symtabs_and_lines sals
;
2416 struct symtab_and_line sal
;
2417 static CORE_ADDR start_pc
, end_pc
;
2418 struct cleanup
*back_to
;
2421 error (_("Line is required"));
2423 sals
= decode_line_spec (argv
[1], 1);
2424 back_to
= make_cleanup (xfree
, sals
.sals
);
2428 if (sal
.symtab
== 0)
2429 error (_("Could not find the specified line"));
2431 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2432 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, 0);
2434 error (_("Could not find the specified line"));
2436 do_cleanups (back_to
);
2439 error (_("Invalid mode '%s'"), mode
);
2441 if (has_stack_frames () || get_traceframe_number () >= 0)
2443 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
2448 mi_cmd_trace_save (char *command
, char **argv
, int argc
)
2450 int target_saves
= 0;
2453 if (argc
!= 1 && argc
!= 2)
2454 error (_("Usage: -trace-save [-r] filename"));
2459 if (strcmp (argv
[0], "-r") == 0)
2462 error (_("Invalid option: %s"), argv
[0]);
2469 trace_save (filename
, target_saves
);
2474 mi_cmd_trace_start (char *command
, char **argv
, int argc
)
2480 mi_cmd_trace_status (char *command
, char **argv
, int argc
)
2482 trace_status_mi (0);
2486 mi_cmd_trace_stop (char *command
, char **argv
, int argc
)
2489 trace_status_mi (1);