3 Copyright (C) 2000-2013 Free Software Foundation, Inc.
5 Contributed by Cygnus Solutions (a Red Hat company).
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 #include "arch-utils.h"
26 #include "gdb_string.h"
27 #include "exceptions.h"
29 #include "gdbthread.h"
32 #include "mi-getopt.h"
33 #include "mi-console.h"
37 #include "event-loop.h"
38 #include "event-top.h"
39 #include "gdbcore.h" /* For write_memory(). */
45 #include "mi-common.h"
50 #include "splay-tree.h"
51 #include "tracepoint.h"
56 #include "python/python-internal.h"
62 #if defined HAVE_SYS_RESOURCE_H
63 #include <sys/resource.h>
77 struct ui_file
*raw_stdout
;
79 /* This is used to pass the current command timestamp down to
80 continuation routines. */
81 static struct mi_timestamp
*current_command_ts
;
83 static int do_timings
= 0;
86 /* Few commands would like to know if options like --thread-group were
87 explicitly specified. This variable keeps the current parsed
88 command including all option, and make it possible. */
89 static struct mi_parse
*current_context
;
91 int running_result_record_printed
= 1;
93 /* Flag indicating that the target has proceeded since the last
94 command was issued. */
97 extern void _initialize_mi_main (void);
98 static void mi_cmd_execute (struct mi_parse
*parse
);
100 static void mi_execute_cli_command (const char *cmd
, int args_p
,
102 static void mi_execute_async_cli_command (char *cli_command
,
103 char **argv
, int argc
);
104 static int register_changed_p (int regnum
, struct regcache
*,
106 static void get_register (struct frame_info
*, int regnum
, int format
);
108 /* Command implementations. FIXME: Is this libgdb? No. This is the MI
109 layer that calls libgdb. Any operation used in the below should be
112 static void timestamp (struct mi_timestamp
*tv
);
114 static void print_diff_now (struct mi_timestamp
*start
);
115 static void print_diff (struct mi_timestamp
*start
, struct mi_timestamp
*end
);
118 mi_cmd_gdb_exit (char *command
, char **argv
, int argc
)
120 /* We have to print everything right here because we never return. */
122 fputs_unfiltered (current_token
, raw_stdout
);
123 fputs_unfiltered ("^exit\n", raw_stdout
);
124 mi_out_put (current_uiout
, raw_stdout
);
125 gdb_flush (raw_stdout
);
126 /* FIXME: The function called is not yet a formal libgdb function. */
127 quit_force (NULL
, FROM_TTY
);
131 mi_cmd_exec_next (char *command
, char **argv
, int argc
)
133 /* FIXME: Should call a libgdb function, not a cli wrapper. */
134 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
135 mi_execute_async_cli_command ("reverse-next", argv
+ 1, argc
- 1);
137 mi_execute_async_cli_command ("next", argv
, argc
);
141 mi_cmd_exec_next_instruction (char *command
, char **argv
, int argc
)
143 /* FIXME: Should call a libgdb function, not a cli wrapper. */
144 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
145 mi_execute_async_cli_command ("reverse-nexti", argv
+ 1, argc
- 1);
147 mi_execute_async_cli_command ("nexti", argv
, argc
);
151 mi_cmd_exec_step (char *command
, char **argv
, int argc
)
153 /* FIXME: Should call a libgdb function, not a cli wrapper. */
154 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
155 mi_execute_async_cli_command ("reverse-step", argv
+ 1, argc
- 1);
157 mi_execute_async_cli_command ("step", argv
, argc
);
161 mi_cmd_exec_step_instruction (char *command
, char **argv
, int argc
)
163 /* FIXME: Should call a libgdb function, not a cli wrapper. */
164 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
165 mi_execute_async_cli_command ("reverse-stepi", argv
+ 1, argc
- 1);
167 mi_execute_async_cli_command ("stepi", argv
, argc
);
171 mi_cmd_exec_finish (char *command
, char **argv
, int argc
)
173 /* FIXME: Should call a libgdb function, not a cli wrapper. */
174 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
175 mi_execute_async_cli_command ("reverse-finish", argv
+ 1, argc
- 1);
177 mi_execute_async_cli_command ("finish", argv
, argc
);
181 mi_cmd_exec_return (char *command
, char **argv
, int argc
)
183 /* This command doesn't really execute the target, it just pops the
184 specified number of frames. */
186 /* Call return_command with from_tty argument equal to 0 so as to
187 avoid being queried. */
188 return_command (*argv
, 0);
190 /* Call return_command with from_tty argument equal to 0 so as to
191 avoid being queried. */
192 return_command (NULL
, 0);
194 /* Because we have called return_command with from_tty = 0, we need
195 to print the frame here. */
196 print_stack_frame (get_selected_frame (NULL
), 1, LOC_AND_ADDRESS
);
200 mi_cmd_exec_jump (char *args
, char **argv
, int argc
)
202 /* FIXME: Should call a libgdb function, not a cli wrapper. */
203 mi_execute_async_cli_command ("jump", argv
, argc
);
207 proceed_thread (struct thread_info
*thread
, int pid
)
209 if (!is_stopped (thread
->ptid
))
212 if (pid
!= 0 && PIDGET (thread
->ptid
) != pid
)
215 switch_to_thread (thread
->ptid
);
216 clear_proceed_status ();
217 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
, 0);
221 proceed_thread_callback (struct thread_info
*thread
, void *arg
)
223 int pid
= *(int *)arg
;
225 proceed_thread (thread
, pid
);
230 exec_continue (char **argv
, int argc
)
234 /* In non-stop mode, 'resume' always resumes a single thread.
235 Therefore, to resume all threads of the current inferior, or
236 all threads in all inferiors, we need to iterate over
239 See comment on infcmd.c:proceed_thread_callback for rationale. */
240 if (current_context
->all
|| current_context
->thread_group
!= -1)
243 struct cleanup
*back_to
= make_cleanup_restore_current_thread ();
245 if (!current_context
->all
)
248 = find_inferior_id (current_context
->thread_group
);
252 iterate_over_threads (proceed_thread_callback
, &pid
);
253 do_cleanups (back_to
);
262 struct cleanup
*back_to
= make_cleanup_restore_integer (&sched_multi
);
264 if (current_context
->all
)
271 /* In all-stop mode, -exec-continue traditionally resumed
272 either all threads, or one thread, depending on the
273 'scheduler-locking' variable. Let's continue to do the
277 do_cleanups (back_to
);
282 exec_direction_forward (void *notused
)
284 execution_direction
= EXEC_FORWARD
;
288 exec_reverse_continue (char **argv
, int argc
)
290 enum exec_direction_kind dir
= execution_direction
;
291 struct cleanup
*old_chain
;
293 if (dir
== EXEC_REVERSE
)
294 error (_("Already in reverse mode."));
296 if (!target_can_execute_reverse
)
297 error (_("Target %s does not support this command."), target_shortname
);
299 old_chain
= make_cleanup (exec_direction_forward
, NULL
);
300 execution_direction
= EXEC_REVERSE
;
301 exec_continue (argv
, argc
);
302 do_cleanups (old_chain
);
306 mi_cmd_exec_continue (char *command
, char **argv
, int argc
)
308 if (argc
> 0 && strcmp (argv
[0], "--reverse") == 0)
309 exec_reverse_continue (argv
+ 1, argc
- 1);
311 exec_continue (argv
, argc
);
315 interrupt_thread_callback (struct thread_info
*thread
, void *arg
)
317 int pid
= *(int *)arg
;
319 if (!is_running (thread
->ptid
))
322 if (PIDGET (thread
->ptid
) != pid
)
325 target_stop (thread
->ptid
);
329 /* Interrupt the execution of the target. Note how we must play
330 around with the token variables, in order to display the current
331 token in the result of the interrupt command, and the previous
332 execution token when the target finally stops. See comments in
336 mi_cmd_exec_interrupt (char *command
, char **argv
, int argc
)
338 /* In all-stop mode, everything stops, so we don't need to try
339 anything specific. */
342 interrupt_target_1 (0);
346 if (current_context
->all
)
348 /* This will interrupt all threads in all inferiors. */
349 interrupt_target_1 (1);
351 else if (current_context
->thread_group
!= -1)
353 struct inferior
*inf
= find_inferior_id (current_context
->thread_group
);
355 iterate_over_threads (interrupt_thread_callback
, &inf
->pid
);
359 /* Interrupt just the current thread -- either explicitly
360 specified via --thread or whatever was current before
361 MI command was sent. */
362 interrupt_target_1 (0);
367 run_one_inferior (struct inferior
*inf
, void *arg
)
371 if (inf
->pid
!= ptid_get_pid (inferior_ptid
))
373 struct thread_info
*tp
;
375 tp
= any_thread_of_process (inf
->pid
);
377 error (_("Inferior has no threads."));
379 switch_to_thread (tp
->ptid
);
384 set_current_inferior (inf
);
385 switch_to_thread (null_ptid
);
386 set_current_program_space (inf
->pspace
);
388 mi_execute_cli_command ("run", target_can_async_p (),
389 target_can_async_p () ? "&" : NULL
);
394 mi_cmd_exec_run (char *command
, char **argv
, int argc
)
396 if (current_context
->all
)
398 struct cleanup
*back_to
= save_current_space_and_thread ();
400 iterate_over_inferiors (run_one_inferior
, NULL
);
401 do_cleanups (back_to
);
405 mi_execute_cli_command ("run", target_can_async_p (),
406 target_can_async_p () ? "&" : NULL
);
412 find_thread_of_process (struct thread_info
*ti
, void *p
)
416 if (PIDGET (ti
->ptid
) == pid
&& !is_exited (ti
->ptid
))
423 mi_cmd_target_detach (char *command
, char **argv
, int argc
)
425 if (argc
!= 0 && argc
!= 1)
426 error (_("Usage: -target-detach [pid | thread-group]"));
430 struct thread_info
*tp
;
434 /* First see if we are dealing with a thread-group id. */
437 struct inferior
*inf
;
438 int id
= strtoul (argv
[0] + 1, &end
, 0);
441 error (_("Invalid syntax of thread-group id '%s'"), argv
[0]);
443 inf
= find_inferior_id (id
);
445 error (_("Non-existent thread-group id '%d'"), id
);
451 /* We must be dealing with a pid. */
452 pid
= strtol (argv
[0], &end
, 10);
455 error (_("Invalid identifier '%s'"), argv
[0]);
458 /* Pick any thread in the desired process. Current
459 target_detach detaches from the parent of inferior_ptid. */
460 tp
= iterate_over_threads (find_thread_of_process
, &pid
);
462 error (_("Thread group is empty"));
464 switch_to_thread (tp
->ptid
);
467 detach_command (NULL
, 0);
471 mi_cmd_thread_select (char *command
, char **argv
, int argc
)
474 char *mi_error_message
;
477 error (_("-thread-select: USAGE: threadnum."));
479 rc
= gdb_thread_select (current_uiout
, argv
[0], &mi_error_message
);
481 if (rc
== GDB_RC_FAIL
)
483 make_cleanup (xfree
, mi_error_message
);
484 error ("%s", mi_error_message
);
489 mi_cmd_thread_list_ids (char *command
, char **argv
, int argc
)
492 char *mi_error_message
;
495 error (_("-thread-list-ids: No arguments required."));
497 rc
= gdb_list_thread_ids (current_uiout
, &mi_error_message
);
499 if (rc
== GDB_RC_FAIL
)
501 make_cleanup (xfree
, mi_error_message
);
502 error ("%s", mi_error_message
);
507 mi_cmd_thread_info (char *command
, char **argv
, int argc
)
509 if (argc
!= 0 && argc
!= 1)
510 error (_("Invalid MI command"));
512 print_thread_info (current_uiout
, argv
[0], -1);
517 struct collect_cores_data
525 collect_cores (struct thread_info
*ti
, void *xdata
)
527 struct collect_cores_data
*data
= xdata
;
529 if (ptid_get_pid (ti
->ptid
) == data
->pid
)
531 int core
= target_core_of_thread (ti
->ptid
);
534 VEC_safe_push (int, data
->cores
, core
);
541 unique (int *b
, int *e
)
551 struct print_one_inferior_data
554 VEC (int) *inferiors
;
558 print_one_inferior (struct inferior
*inferior
, void *xdata
)
560 struct print_one_inferior_data
*top_data
= xdata
;
561 struct ui_out
*uiout
= current_uiout
;
563 if (VEC_empty (int, top_data
->inferiors
)
564 || bsearch (&(inferior
->pid
), VEC_address (int, top_data
->inferiors
),
565 VEC_length (int, top_data
->inferiors
), sizeof (int),
566 compare_positive_ints
))
568 struct collect_cores_data data
;
569 struct cleanup
*back_to
570 = make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
572 ui_out_field_fmt (uiout
, "id", "i%d", inferior
->num
);
573 ui_out_field_string (uiout
, "type", "process");
574 if (inferior
->pid
!= 0)
575 ui_out_field_int (uiout
, "pid", inferior
->pid
);
577 if (inferior
->pspace
->ebfd
)
579 ui_out_field_string (uiout
, "executable",
580 bfd_get_filename (inferior
->pspace
->ebfd
));
584 if (inferior
->pid
!= 0)
586 data
.pid
= inferior
->pid
;
587 iterate_over_threads (collect_cores
, &data
);
590 if (!VEC_empty (int, data
.cores
))
593 struct cleanup
*back_to_2
=
594 make_cleanup_ui_out_list_begin_end (uiout
, "cores");
596 qsort (VEC_address (int, data
.cores
),
597 VEC_length (int, data
.cores
), sizeof (int),
598 compare_positive_ints
);
600 b
= VEC_address (int, data
.cores
);
601 e
= b
+ VEC_length (int, data
.cores
);
605 ui_out_field_int (uiout
, NULL
, *b
);
607 do_cleanups (back_to_2
);
610 if (top_data
->recurse
)
611 print_thread_info (uiout
, NULL
, inferior
->pid
);
613 do_cleanups (back_to
);
619 /* Output a field named 'cores' with a list as the value. The
620 elements of the list are obtained by splitting 'cores' on
624 output_cores (struct ui_out
*uiout
, const char *field_name
, const char *xcores
)
626 struct cleanup
*back_to
= make_cleanup_ui_out_list_begin_end (uiout
,
628 char *cores
= xstrdup (xcores
);
631 make_cleanup (xfree
, cores
);
633 for (p
= strtok (p
, ","); p
; p
= strtok (NULL
, ","))
634 ui_out_field_string (uiout
, NULL
, p
);
636 do_cleanups (back_to
);
640 free_vector_of_ints (void *xvector
)
642 VEC (int) **vector
= xvector
;
644 VEC_free (int, *vector
);
648 do_nothing (splay_tree_key k
)
653 free_vector_of_osdata_items (splay_tree_value xvalue
)
655 VEC (osdata_item_s
) *value
= (VEC (osdata_item_s
) *) xvalue
;
657 /* We don't free the items itself, it will be done separately. */
658 VEC_free (osdata_item_s
, value
);
662 splay_tree_int_comparator (splay_tree_key xa
, splay_tree_key xb
)
671 free_splay_tree (void *xt
)
674 splay_tree_delete (t
);
678 list_available_thread_groups (VEC (int) *ids
, int recurse
)
681 struct osdata_item
*item
;
683 struct ui_out
*uiout
= current_uiout
;
685 /* This keeps a map from integer (pid) to VEC (struct osdata_item *)*
686 The vector contains information about all threads for the given pid.
687 This is assigned an initial value to avoid "may be used uninitialized"
689 splay_tree tree
= NULL
;
691 /* get_osdata will throw if it cannot return data. */
692 data
= get_osdata ("processes");
693 make_cleanup_osdata_free (data
);
697 struct osdata
*threads
= get_osdata ("threads");
699 make_cleanup_osdata_free (threads
);
700 tree
= splay_tree_new (splay_tree_int_comparator
,
702 free_vector_of_osdata_items
);
703 make_cleanup (free_splay_tree
, tree
);
706 VEC_iterate (osdata_item_s
, threads
->items
,
710 const char *pid
= get_osdata_column (item
, "pid");
711 int pid_i
= strtoul (pid
, NULL
, 0);
712 VEC (osdata_item_s
) *vec
= 0;
714 splay_tree_node n
= splay_tree_lookup (tree
, pid_i
);
717 VEC_safe_push (osdata_item_s
, vec
, item
);
718 splay_tree_insert (tree
, pid_i
, (splay_tree_value
)vec
);
722 vec
= (VEC (osdata_item_s
) *) n
->value
;
723 VEC_safe_push (osdata_item_s
, vec
, item
);
724 n
->value
= (splay_tree_value
) vec
;
729 make_cleanup_ui_out_list_begin_end (uiout
, "groups");
732 VEC_iterate (osdata_item_s
, data
->items
,
736 struct cleanup
*back_to
;
738 const char *pid
= get_osdata_column (item
, "pid");
739 const char *cmd
= get_osdata_column (item
, "command");
740 const char *user
= get_osdata_column (item
, "user");
741 const char *cores
= get_osdata_column (item
, "cores");
743 int pid_i
= strtoul (pid
, NULL
, 0);
745 /* At present, the target will return all available processes
746 and if information about specific ones was required, we filter
747 undesired processes here. */
748 if (ids
&& bsearch (&pid_i
, VEC_address (int, ids
),
749 VEC_length (int, ids
),
750 sizeof (int), compare_positive_ints
) == NULL
)
754 back_to
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
756 ui_out_field_fmt (uiout
, "id", "%s", pid
);
757 ui_out_field_string (uiout
, "type", "process");
759 ui_out_field_string (uiout
, "description", cmd
);
761 ui_out_field_string (uiout
, "user", user
);
763 output_cores (uiout
, "cores", cores
);
767 splay_tree_node n
= splay_tree_lookup (tree
, pid_i
);
770 VEC (osdata_item_s
) *children
= (VEC (osdata_item_s
) *) n
->value
;
771 struct osdata_item
*child
;
774 make_cleanup_ui_out_list_begin_end (uiout
, "threads");
777 VEC_iterate (osdata_item_s
, children
, ix_child
, child
);
780 struct cleanup
*back_to_2
=
781 make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
782 const char *tid
= get_osdata_column (child
, "tid");
783 const char *tcore
= get_osdata_column (child
, "core");
785 ui_out_field_string (uiout
, "id", tid
);
787 ui_out_field_string (uiout
, "core", tcore
);
789 do_cleanups (back_to_2
);
794 do_cleanups (back_to
);
799 mi_cmd_list_thread_groups (char *command
, char **argv
, int argc
)
801 struct ui_out
*uiout
= current_uiout
;
802 struct cleanup
*back_to
;
809 AVAILABLE_OPT
, RECURSE_OPT
811 static const struct mi_opt opts
[] =
813 {"-available", AVAILABLE_OPT
, 0},
814 {"-recurse", RECURSE_OPT
, 1},
823 int opt
= mi_getopt ("-list-thread-groups", argc
, argv
, opts
,
828 switch ((enum opt
) opt
)
834 if (strcmp (oarg
, "0") == 0)
836 else if (strcmp (oarg
, "1") == 0)
839 error (_("only '0' and '1' are valid values "
840 "for the '--recurse' option"));
845 for (; oind
< argc
; ++oind
)
850 if (*(argv
[oind
]) != 'i')
851 error (_("invalid syntax of group id '%s'"), argv
[oind
]);
853 inf
= strtoul (argv
[oind
] + 1, &end
, 0);
856 error (_("invalid syntax of group id '%s'"), argv
[oind
]);
857 VEC_safe_push (int, ids
, inf
);
859 if (VEC_length (int, ids
) > 1)
860 qsort (VEC_address (int, ids
),
861 VEC_length (int, ids
),
862 sizeof (int), compare_positive_ints
);
864 back_to
= make_cleanup (free_vector_of_ints
, &ids
);
868 list_available_thread_groups (ids
, recurse
);
870 else if (VEC_length (int, ids
) == 1)
872 /* Local thread groups, single id. */
873 int id
= *VEC_address (int, ids
);
874 struct inferior
*inf
= find_inferior_id (id
);
877 error (_("Non-existent thread group id '%d'"), id
);
879 print_thread_info (uiout
, NULL
, inf
->pid
);
883 struct print_one_inferior_data data
;
885 data
.recurse
= recurse
;
886 data
.inferiors
= ids
;
888 /* Local thread groups. Either no explicit ids -- and we
889 print everything, or several explicit ids. In both cases,
890 we print more than one group, and have to use 'groups'
891 as the top-level element. */
892 make_cleanup_ui_out_list_begin_end (uiout
, "groups");
893 update_thread_list ();
894 iterate_over_inferiors (print_one_inferior
, &data
);
897 do_cleanups (back_to
);
901 mi_cmd_data_list_register_names (char *command
, char **argv
, int argc
)
903 struct gdbarch
*gdbarch
;
904 struct ui_out
*uiout
= current_uiout
;
907 struct cleanup
*cleanup
;
909 /* Note that the test for a valid register must include checking the
910 gdbarch_register_name because gdbarch_num_regs may be allocated
911 for the union of the register sets within a family of related
912 processors. In this case, some entries of gdbarch_register_name
913 will change depending upon the particular processor being
916 gdbarch
= get_current_arch ();
917 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
919 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "register-names");
921 if (argc
== 0) /* No args, just do all the regs. */
927 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
928 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
929 ui_out_field_string (uiout
, NULL
, "");
931 ui_out_field_string (uiout
, NULL
,
932 gdbarch_register_name (gdbarch
, regnum
));
936 /* Else, list of register #s, just do listed regs. */
937 for (i
= 0; i
< argc
; i
++)
939 regnum
= atoi (argv
[i
]);
940 if (regnum
< 0 || regnum
>= numregs
)
941 error (_("bad register number"));
943 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
944 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
945 ui_out_field_string (uiout
, NULL
, "");
947 ui_out_field_string (uiout
, NULL
,
948 gdbarch_register_name (gdbarch
, regnum
));
950 do_cleanups (cleanup
);
954 mi_cmd_data_list_changed_registers (char *command
, char **argv
, int argc
)
956 static struct regcache
*this_regs
= NULL
;
957 struct ui_out
*uiout
= current_uiout
;
958 struct regcache
*prev_regs
;
959 struct gdbarch
*gdbarch
;
960 int regnum
, numregs
, changed
;
962 struct cleanup
*cleanup
;
964 /* The last time we visited this function, the current frame's
965 register contents were saved in THIS_REGS. Move THIS_REGS over
966 to PREV_REGS, and refresh THIS_REGS with the now-current register
969 prev_regs
= this_regs
;
970 this_regs
= frame_save_as_regcache (get_selected_frame (NULL
));
971 cleanup
= make_cleanup_regcache_xfree (prev_regs
);
973 /* Note that the test for a valid register must include checking the
974 gdbarch_register_name because gdbarch_num_regs may be allocated
975 for the union of the register sets within a family of related
976 processors. In this case, some entries of gdbarch_register_name
977 will change depending upon the particular processor being
980 gdbarch
= get_regcache_arch (this_regs
);
981 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
983 make_cleanup_ui_out_list_begin_end (uiout
, "changed-registers");
987 /* No args, just do all the regs. */
992 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
993 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
995 changed
= register_changed_p (regnum
, prev_regs
, this_regs
);
997 error (_("-data-list-changed-registers: "
998 "Unable to read register contents."));
1000 ui_out_field_int (uiout
, NULL
, regnum
);
1004 /* Else, list of register #s, just do listed regs. */
1005 for (i
= 0; i
< argc
; i
++)
1007 regnum
= atoi (argv
[i
]);
1011 && gdbarch_register_name (gdbarch
, regnum
) != NULL
1012 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
1014 changed
= register_changed_p (regnum
, prev_regs
, this_regs
);
1016 error (_("-data-list-changed-registers: "
1017 "Unable to read register contents."));
1019 ui_out_field_int (uiout
, NULL
, regnum
);
1022 error (_("bad register number"));
1024 do_cleanups (cleanup
);
1028 register_changed_p (int regnum
, struct regcache
*prev_regs
,
1029 struct regcache
*this_regs
)
1031 struct gdbarch
*gdbarch
= get_regcache_arch (this_regs
);
1032 gdb_byte prev_buffer
[MAX_REGISTER_SIZE
];
1033 gdb_byte this_buffer
[MAX_REGISTER_SIZE
];
1034 enum register_status prev_status
;
1035 enum register_status this_status
;
1037 /* First time through or after gdbarch change consider all registers
1039 if (!prev_regs
|| get_regcache_arch (prev_regs
) != gdbarch
)
1042 /* Get register contents and compare. */
1043 prev_status
= regcache_cooked_read (prev_regs
, regnum
, prev_buffer
);
1044 this_status
= regcache_cooked_read (this_regs
, regnum
, this_buffer
);
1046 if (this_status
!= prev_status
)
1048 else if (this_status
== REG_VALID
)
1049 return memcmp (prev_buffer
, this_buffer
,
1050 register_size (gdbarch
, regnum
)) != 0;
1055 /* Return a list of register number and value pairs. The valid
1056 arguments expected are: a letter indicating the format in which to
1057 display the registers contents. This can be one of: x
1058 (hexadecimal), d (decimal), N (natural), t (binary), o (octal), r
1059 (raw). After the format argument there can be a sequence of
1060 numbers, indicating which registers to fetch the content of. If
1061 the format is the only argument, a list of all the registers with
1062 their values is returned. */
1065 mi_cmd_data_list_register_values (char *command
, char **argv
, int argc
)
1067 struct ui_out
*uiout
= current_uiout
;
1068 struct frame_info
*frame
;
1069 struct gdbarch
*gdbarch
;
1070 int regnum
, numregs
, format
;
1072 struct cleanup
*list_cleanup
, *tuple_cleanup
;
1074 /* Note that the test for a valid register must include checking the
1075 gdbarch_register_name because gdbarch_num_regs may be allocated
1076 for the union of the register sets within a family of related
1077 processors. In this case, some entries of gdbarch_register_name
1078 will change depending upon the particular processor being
1082 error (_("-data-list-register-values: Usage: "
1083 "-data-list-register-values <format> [<regnum1>...<regnumN>]"));
1085 format
= (int) argv
[0][0];
1087 frame
= get_selected_frame (NULL
);
1088 gdbarch
= get_frame_arch (frame
);
1089 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1091 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "register-values");
1095 /* No args, beside the format: do all the regs. */
1100 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1101 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1103 tuple_cleanup
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1104 ui_out_field_int (uiout
, "number", regnum
);
1105 get_register (frame
, regnum
, format
);
1106 do_cleanups (tuple_cleanup
);
1110 /* Else, list of register #s, just do listed regs. */
1111 for (i
= 1; i
< argc
; i
++)
1113 regnum
= atoi (argv
[i
]);
1117 && gdbarch_register_name (gdbarch
, regnum
) != NULL
1118 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
1120 tuple_cleanup
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1121 ui_out_field_int (uiout
, "number", regnum
);
1122 get_register (frame
, regnum
, format
);
1123 do_cleanups (tuple_cleanup
);
1126 error (_("bad register number"));
1128 do_cleanups (list_cleanup
);
1131 /* Output one register's contents in the desired format. */
1134 get_register (struct frame_info
*frame
, int regnum
, int format
)
1136 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1137 struct ui_out
*uiout
= current_uiout
;
1143 val
= get_frame_register_value (frame
, regnum
);
1145 if (value_optimized_out (val
))
1146 error (_("Optimized out"));
1151 char *ptr
, buf
[1024];
1152 const gdb_byte
*valaddr
= value_contents_for_printing (val
);
1156 for (j
= 0; j
< register_size (gdbarch
, regnum
); j
++)
1158 int idx
= gdbarch_byte_order (gdbarch
) == BFD_ENDIAN_BIG
?
1159 j
: register_size (gdbarch
, regnum
) - 1 - j
;
1161 sprintf (ptr
, "%02x", (unsigned char) valaddr
[idx
]);
1164 ui_out_field_string (uiout
, "value", buf
);
1168 struct value_print_options opts
;
1169 struct ui_file
*stb
;
1170 struct cleanup
*old_chain
;
1172 stb
= mem_fileopen ();
1173 old_chain
= make_cleanup_ui_file_delete (stb
);
1175 get_formatted_print_options (&opts
, format
);
1177 val_print (value_type (val
),
1178 value_contents_for_printing (val
),
1179 value_embedded_offset (val
), 0,
1180 stb
, 0, val
, &opts
, current_language
);
1181 ui_out_field_stream (uiout
, "value", stb
);
1182 do_cleanups (old_chain
);
1186 /* Write given values into registers. The registers and values are
1187 given as pairs. The corresponding MI command is
1188 -data-write-register-values <format>
1189 [<regnum1> <value1>...<regnumN> <valueN>] */
1191 mi_cmd_data_write_register_values (char *command
, char **argv
, int argc
)
1193 struct regcache
*regcache
;
1194 struct gdbarch
*gdbarch
;
1197 /* Note that the test for a valid register must include checking the
1198 gdbarch_register_name because gdbarch_num_regs may be allocated
1199 for the union of the register sets within a family of related
1200 processors. In this case, some entries of gdbarch_register_name
1201 will change depending upon the particular processor being
1204 regcache
= get_current_regcache ();
1205 gdbarch
= get_regcache_arch (regcache
);
1206 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1209 error (_("-data-write-register-values: Usage: -data-write-register-"
1210 "values <format> [<regnum1> <value1>...<regnumN> <valueN>]"));
1212 if (!target_has_registers
)
1213 error (_("-data-write-register-values: No registers."));
1216 error (_("-data-write-register-values: No regs and values specified."));
1219 error (_("-data-write-register-values: "
1220 "Regs and vals are not in pairs."));
1222 for (i
= 1; i
< argc
; i
= i
+ 2)
1224 int regnum
= atoi (argv
[i
]);
1226 if (regnum
>= 0 && regnum
< numregs
1227 && gdbarch_register_name (gdbarch
, regnum
)
1228 && *gdbarch_register_name (gdbarch
, regnum
))
1232 /* Get the value as a number. */
1233 value
= parse_and_eval_address (argv
[i
+ 1]);
1235 /* Write it down. */
1236 regcache_cooked_write_signed (regcache
, regnum
, value
);
1239 error (_("bad register number"));
1243 /* Evaluate the value of the argument. The argument is an
1244 expression. If the expression contains spaces it needs to be
1245 included in double quotes. */
1248 mi_cmd_data_evaluate_expression (char *command
, char **argv
, int argc
)
1250 struct expression
*expr
;
1251 struct cleanup
*old_chain
;
1253 struct ui_file
*stb
;
1254 struct value_print_options opts
;
1255 struct ui_out
*uiout
= current_uiout
;
1257 stb
= mem_fileopen ();
1258 old_chain
= make_cleanup_ui_file_delete (stb
);
1261 error (_("-data-evaluate-expression: "
1262 "Usage: -data-evaluate-expression expression"));
1264 expr
= parse_expression (argv
[0]);
1266 make_cleanup (free_current_contents
, &expr
);
1268 val
= evaluate_expression (expr
);
1270 /* Print the result of the expression evaluation. */
1271 get_user_print_options (&opts
);
1273 common_val_print (val
, stb
, 0, &opts
, current_language
);
1275 ui_out_field_stream (uiout
, "value", stb
);
1277 do_cleanups (old_chain
);
1280 /* This is the -data-read-memory command.
1282 ADDR: start address of data to be dumped.
1283 WORD-FORMAT: a char indicating format for the ``word''. See
1285 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes.
1286 NR_ROW: Number of rows.
1287 NR_COL: The number of colums (words per row).
1288 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
1289 ASCHAR for unprintable characters.
1291 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
1292 displayes them. Returns:
1294 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
1297 The number of bytes read is SIZE*ROW*COL. */
1300 mi_cmd_data_read_memory (char *command
, char **argv
, int argc
)
1302 struct gdbarch
*gdbarch
= get_current_arch ();
1303 struct ui_out
*uiout
= current_uiout
;
1304 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
1306 long total_bytes
, nr_cols
, nr_rows
;
1308 struct type
*word_type
;
1321 static const struct mi_opt opts
[] =
1323 {"o", OFFSET_OPT
, 1},
1329 int opt
= mi_getopt ("-data-read-memory", argc
, argv
, opts
,
1334 switch ((enum opt
) opt
)
1337 offset
= atol (oarg
);
1344 if (argc
< 5 || argc
> 6)
1345 error (_("-data-read-memory: Usage: "
1346 "ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR]."));
1348 /* Extract all the arguments. */
1350 /* Start address of the memory dump. */
1351 addr
= parse_and_eval_address (argv
[0]) + offset
;
1352 /* The format character to use when displaying a memory word. See
1353 the ``x'' command. */
1354 word_format
= argv
[1][0];
1355 /* The size of the memory word. */
1356 word_size
= atol (argv
[2]);
1360 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1364 word_type
= builtin_type (gdbarch
)->builtin_int16
;
1368 word_type
= builtin_type (gdbarch
)->builtin_int32
;
1372 word_type
= builtin_type (gdbarch
)->builtin_int64
;
1376 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1379 /* The number of rows. */
1380 nr_rows
= atol (argv
[3]);
1382 error (_("-data-read-memory: invalid number of rows."));
1384 /* Number of bytes per row. */
1385 nr_cols
= atol (argv
[4]);
1387 error (_("-data-read-memory: invalid number of columns."));
1389 /* The un-printable character when printing ascii. */
1395 /* Create a buffer and read it in. */
1396 total_bytes
= word_size
* nr_rows
* nr_cols
;
1397 mbuf
= xcalloc (total_bytes
, 1);
1398 make_cleanup (xfree
, mbuf
);
1400 /* Dispatch memory reads to the topmost target, not the flattened
1402 nr_bytes
= target_read (current_target
.beneath
,
1403 TARGET_OBJECT_MEMORY
, NULL
, mbuf
,
1406 error (_("Unable to read memory."));
1408 /* Output the header information. */
1409 ui_out_field_core_addr (uiout
, "addr", gdbarch
, addr
);
1410 ui_out_field_int (uiout
, "nr-bytes", nr_bytes
);
1411 ui_out_field_int (uiout
, "total-bytes", total_bytes
);
1412 ui_out_field_core_addr (uiout
, "next-row",
1413 gdbarch
, addr
+ word_size
* nr_cols
);
1414 ui_out_field_core_addr (uiout
, "prev-row",
1415 gdbarch
, addr
- word_size
* nr_cols
);
1416 ui_out_field_core_addr (uiout
, "next-page", gdbarch
, addr
+ total_bytes
);
1417 ui_out_field_core_addr (uiout
, "prev-page", gdbarch
, addr
- total_bytes
);
1419 /* Build the result as a two dimentional table. */
1421 struct ui_file
*stream
;
1422 struct cleanup
*cleanup_stream
;
1426 stream
= mem_fileopen ();
1427 cleanup_stream
= make_cleanup_ui_file_delete (stream
);
1429 make_cleanup_ui_out_list_begin_end (uiout
, "memory");
1430 for (row
= 0, row_byte
= 0;
1432 row
++, row_byte
+= nr_cols
* word_size
)
1436 struct cleanup
*cleanup_tuple
;
1437 struct cleanup
*cleanup_list_data
;
1438 struct value_print_options opts
;
1440 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1441 ui_out_field_core_addr (uiout
, "addr", gdbarch
, addr
+ row_byte
);
1442 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr +
1444 cleanup_list_data
= make_cleanup_ui_out_list_begin_end (uiout
, "data");
1445 get_formatted_print_options (&opts
, word_format
);
1446 for (col
= 0, col_byte
= row_byte
;
1448 col
++, col_byte
+= word_size
)
1450 if (col_byte
+ word_size
> nr_bytes
)
1452 ui_out_field_string (uiout
, NULL
, "N/A");
1456 ui_file_rewind (stream
);
1457 print_scalar_formatted (mbuf
+ col_byte
, word_type
, &opts
,
1458 word_asize
, stream
);
1459 ui_out_field_stream (uiout
, NULL
, stream
);
1462 do_cleanups (cleanup_list_data
);
1467 ui_file_rewind (stream
);
1468 for (byte
= row_byte
;
1469 byte
< row_byte
+ word_size
* nr_cols
; byte
++)
1471 if (byte
>= nr_bytes
)
1472 fputc_unfiltered ('X', stream
);
1473 else if (mbuf
[byte
] < 32 || mbuf
[byte
] > 126)
1474 fputc_unfiltered (aschar
, stream
);
1476 fputc_unfiltered (mbuf
[byte
], stream
);
1478 ui_out_field_stream (uiout
, "ascii", stream
);
1480 do_cleanups (cleanup_tuple
);
1482 do_cleanups (cleanup_stream
);
1484 do_cleanups (cleanups
);
1488 mi_cmd_data_read_memory_bytes (char *command
, char **argv
, int argc
)
1490 struct gdbarch
*gdbarch
= get_current_arch ();
1491 struct ui_out
*uiout
= current_uiout
;
1492 struct cleanup
*cleanups
;
1495 memory_read_result_s
*read_result
;
1497 VEC(memory_read_result_s
) *result
;
1505 static const struct mi_opt opts
[] =
1507 {"o", OFFSET_OPT
, 1},
1513 int opt
= mi_getopt ("-data-read-memory-bytes", argc
, argv
, opts
,
1517 switch ((enum opt
) opt
)
1520 offset
= atol (oarg
);
1528 error (_("Usage: [ -o OFFSET ] ADDR LENGTH."));
1530 addr
= parse_and_eval_address (argv
[0]) + offset
;
1531 length
= atol (argv
[1]);
1533 result
= read_memory_robust (current_target
.beneath
, addr
, length
);
1535 cleanups
= make_cleanup (free_memory_read_result_vector
, result
);
1537 if (VEC_length (memory_read_result_s
, result
) == 0)
1538 error (_("Unable to read memory."));
1540 make_cleanup_ui_out_list_begin_end (uiout
, "memory");
1542 VEC_iterate (memory_read_result_s
, result
, ix
, read_result
);
1545 struct cleanup
*t
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1549 ui_out_field_core_addr (uiout
, "begin", gdbarch
, read_result
->begin
);
1550 ui_out_field_core_addr (uiout
, "offset", gdbarch
, read_result
->begin
1552 ui_out_field_core_addr (uiout
, "end", gdbarch
, read_result
->end
);
1554 data
= xmalloc ((read_result
->end
- read_result
->begin
) * 2 + 1);
1556 for (i
= 0, p
= data
;
1557 i
< (read_result
->end
- read_result
->begin
);
1560 sprintf (p
, "%02x", read_result
->data
[i
]);
1562 ui_out_field_string (uiout
, "contents", data
);
1566 do_cleanups (cleanups
);
1569 /* Implementation of the -data-write_memory command.
1571 COLUMN_OFFSET: optional argument. Must be preceded by '-o'. The
1572 offset from the beginning of the memory grid row where the cell to
1574 ADDR: start address of the row in the memory grid where the memory
1575 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
1576 the location to write to.
1577 FORMAT: a char indicating format for the ``word''. See
1579 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
1580 VALUE: value to be written into the memory address.
1582 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
1587 mi_cmd_data_write_memory (char *command
, char **argv
, int argc
)
1589 struct gdbarch
*gdbarch
= get_current_arch ();
1590 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1593 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
1594 enough when using a compiler other than GCC. */
1597 struct cleanup
*old_chain
;
1605 static const struct mi_opt opts
[] =
1607 {"o", OFFSET_OPT
, 1},
1613 int opt
= mi_getopt ("-data-write-memory", argc
, argv
, opts
,
1618 switch ((enum opt
) opt
)
1621 offset
= atol (oarg
);
1629 error (_("-data-write-memory: Usage: "
1630 "[-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE."));
1632 /* Extract all the arguments. */
1633 /* Start address of the memory dump. */
1634 addr
= parse_and_eval_address (argv
[0]);
1635 /* The size of the memory word. */
1636 word_size
= atol (argv
[2]);
1638 /* Calculate the real address of the write destination. */
1639 addr
+= (offset
* word_size
);
1641 /* Get the value as a number. */
1642 value
= parse_and_eval_address (argv
[3]);
1643 /* Get the value into an array. */
1644 buffer
= xmalloc (word_size
);
1645 old_chain
= make_cleanup (xfree
, buffer
);
1646 store_signed_integer (buffer
, word_size
, byte_order
, value
);
1647 /* Write it down to memory. */
1648 write_memory_with_notification (addr
, buffer
, word_size
);
1649 /* Free the buffer. */
1650 do_cleanups (old_chain
);
1653 /* Implementation of the -data-write-memory-bytes command.
1656 DATA: string of bytes to write at that address
1657 COUNT: number of bytes to be filled (decimal integer). */
1660 mi_cmd_data_write_memory_bytes (char *command
, char **argv
, int argc
)
1666 size_t len
, i
, steps
, remainder
;
1668 struct cleanup
*back_to
;
1670 if (argc
!= 2 && argc
!= 3)
1671 error (_("Usage: ADDR DATA [COUNT]."));
1673 addr
= parse_and_eval_address (argv
[0]);
1675 if (strlen (cdata
) % 2)
1676 error (_("Hex-encoded '%s' must have an even number of characters."),
1679 len
= strlen (cdata
)/2;
1681 count
= strtoul (argv
[2], NULL
, 10);
1685 databuf
= xmalloc (len
* sizeof (gdb_byte
));
1686 back_to
= make_cleanup (xfree
, databuf
);
1688 for (i
= 0; i
< len
; ++i
)
1691 if (sscanf (cdata
+ i
* 2, "%02x", &x
) != 1)
1692 error (_("Invalid argument"));
1693 databuf
[i
] = (gdb_byte
) x
;
1698 /* Pattern is made of less bytes than count:
1699 repeat pattern to fill memory. */
1700 data
= xmalloc (count
);
1701 make_cleanup (xfree
, data
);
1703 steps
= count
/ len
;
1704 remainder
= count
% len
;
1705 for (j
= 0; j
< steps
; j
++)
1706 memcpy (data
+ j
* len
, databuf
, len
);
1709 memcpy (data
+ steps
* len
, databuf
, remainder
);
1713 /* Pattern is longer than or equal to count:
1714 just copy len bytes. */
1718 write_memory_with_notification (addr
, data
, count
);
1720 do_cleanups (back_to
);
1724 mi_cmd_enable_timings (char *command
, char **argv
, int argc
)
1730 if (strcmp (argv
[0], "yes") == 0)
1732 else if (strcmp (argv
[0], "no") == 0)
1743 error (_("-enable-timings: Usage: %s {yes|no}"), command
);
1747 mi_cmd_list_features (char *command
, char **argv
, int argc
)
1751 struct cleanup
*cleanup
= NULL
;
1752 struct ui_out
*uiout
= current_uiout
;
1754 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "features");
1755 ui_out_field_string (uiout
, NULL
, "frozen-varobjs");
1756 ui_out_field_string (uiout
, NULL
, "pending-breakpoints");
1757 ui_out_field_string (uiout
, NULL
, "thread-info");
1758 ui_out_field_string (uiout
, NULL
, "data-read-memory-bytes");
1759 ui_out_field_string (uiout
, NULL
, "breakpoint-notifications");
1760 ui_out_field_string (uiout
, NULL
, "ada-task-info");
1763 if (gdb_python_initialized
)
1764 ui_out_field_string (uiout
, NULL
, "python");
1767 do_cleanups (cleanup
);
1771 error (_("-list-features should be passed no arguments"));
1775 mi_cmd_list_target_features (char *command
, char **argv
, int argc
)
1779 struct cleanup
*cleanup
= NULL
;
1780 struct ui_out
*uiout
= current_uiout
;
1782 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "features");
1783 if (target_can_async_p ())
1784 ui_out_field_string (uiout
, NULL
, "async");
1785 if (target_can_execute_reverse
)
1786 ui_out_field_string (uiout
, NULL
, "reverse");
1788 do_cleanups (cleanup
);
1792 error (_("-list-target-features should be passed no arguments"));
1796 mi_cmd_add_inferior (char *command
, char **argv
, int argc
)
1798 struct inferior
*inf
;
1801 error (_("-add-inferior should be passed no arguments"));
1803 inf
= add_inferior_with_spaces ();
1805 ui_out_field_fmt (current_uiout
, "inferior", "i%d", inf
->num
);
1808 /* Callback used to find the first inferior other than the current
1812 get_other_inferior (struct inferior
*inf
, void *arg
)
1814 if (inf
== current_inferior ())
1821 mi_cmd_remove_inferior (char *command
, char **argv
, int argc
)
1824 struct inferior
*inf
;
1827 error (_("-remove-inferior should be passed a single argument"));
1829 if (sscanf (argv
[0], "i%d", &id
) != 1)
1830 error (_("the thread group id is syntactically invalid"));
1832 inf
= find_inferior_id (id
);
1834 error (_("the specified thread group does not exist"));
1837 error (_("cannot remove an active inferior"));
1839 if (inf
== current_inferior ())
1841 struct thread_info
*tp
= 0;
1842 struct inferior
*new_inferior
1843 = iterate_over_inferiors (get_other_inferior
, NULL
);
1845 if (new_inferior
== NULL
)
1846 error (_("Cannot remove last inferior"));
1848 set_current_inferior (new_inferior
);
1849 if (new_inferior
->pid
!= 0)
1850 tp
= any_thread_of_process (new_inferior
->pid
);
1851 switch_to_thread (tp
? tp
->ptid
: null_ptid
);
1852 set_current_program_space (new_inferior
->pspace
);
1855 delete_inferior_1 (inf
, 1 /* silent */);
1860 /* Execute a command within a safe environment.
1861 Return <0 for error; >=0 for ok.
1863 args->action will tell mi_execute_command what action
1864 to perfrom after the given command has executed (display/suppress
1865 prompt, display error). */
1868 captured_mi_execute_command (struct ui_out
*uiout
, struct mi_parse
*context
)
1870 struct cleanup
*cleanup
;
1873 current_command_ts
= context
->cmd_start
;
1875 current_token
= xstrdup (context
->token
);
1876 cleanup
= make_cleanup (free_current_contents
, ¤t_token
);
1878 running_result_record_printed
= 0;
1880 switch (context
->op
)
1883 /* A MI command was read from the input stream. */
1885 /* FIXME: gdb_???? */
1886 fprintf_unfiltered (raw_stdout
, " token=`%s' command=`%s' args=`%s'\n",
1887 context
->token
, context
->command
, context
->args
);
1889 mi_cmd_execute (context
);
1891 /* Print the result if there were no errors.
1893 Remember that on the way out of executing a command, you have
1894 to directly use the mi_interp's uiout, since the command
1895 could have reset the interpreter, in which case the current
1896 uiout will most likely crash in the mi_out_* routines. */
1897 if (!running_result_record_printed
)
1899 fputs_unfiltered (context
->token
, raw_stdout
);
1900 /* There's no particularly good reason why target-connect results
1901 in not ^done. Should kill ^connected for MI3. */
1902 fputs_unfiltered (strcmp (context
->command
, "target-select") == 0
1903 ? "^connected" : "^done", raw_stdout
);
1904 mi_out_put (uiout
, raw_stdout
);
1905 mi_out_rewind (uiout
);
1906 mi_print_timing_maybe ();
1907 fputs_unfiltered ("\n", raw_stdout
);
1910 /* The command does not want anything to be printed. In that
1911 case, the command probably should not have written anything
1912 to uiout, but in case it has written something, discard it. */
1913 mi_out_rewind (uiout
);
1920 /* A CLI command was read from the input stream. */
1921 /* This "feature" will be removed as soon as we have a
1922 complete set of mi commands. */
1923 /* Echo the command on the console. */
1924 fprintf_unfiltered (gdb_stdlog
, "%s\n", context
->command
);
1925 /* Call the "console" interpreter. */
1926 argv
[0] = "console";
1927 argv
[1] = context
->command
;
1928 mi_cmd_interpreter_exec ("-interpreter-exec", argv
, 2);
1930 /* If we changed interpreters, DON'T print out anything. */
1931 if (current_interp_named_p (INTERP_MI
)
1932 || current_interp_named_p (INTERP_MI1
)
1933 || current_interp_named_p (INTERP_MI2
)
1934 || current_interp_named_p (INTERP_MI3
))
1936 if (!running_result_record_printed
)
1938 fputs_unfiltered (context
->token
, raw_stdout
);
1939 fputs_unfiltered ("^done", raw_stdout
);
1940 mi_out_put (uiout
, raw_stdout
);
1941 mi_out_rewind (uiout
);
1942 mi_print_timing_maybe ();
1943 fputs_unfiltered ("\n", raw_stdout
);
1946 mi_out_rewind (uiout
);
1952 do_cleanups (cleanup
);
1955 /* Print a gdb exception to the MI output stream. */
1958 mi_print_exception (const char *token
, struct gdb_exception exception
)
1960 fputs_unfiltered (token
, raw_stdout
);
1961 fputs_unfiltered ("^error,msg=\"", raw_stdout
);
1962 if (exception
.message
== NULL
)
1963 fputs_unfiltered ("unknown error", raw_stdout
);
1965 fputstr_unfiltered (exception
.message
, '"', raw_stdout
);
1966 fputs_unfiltered ("\"\n", raw_stdout
);
1970 mi_execute_command (const char *cmd
, int from_tty
)
1973 struct mi_parse
*command
= NULL
;
1974 volatile struct gdb_exception exception
;
1976 /* This is to handle EOF (^D). We just quit gdb. */
1977 /* FIXME: we should call some API function here. */
1979 quit_force (NULL
, from_tty
);
1981 target_log_command (cmd
);
1983 TRY_CATCH (exception
, RETURN_MASK_ALL
)
1985 command
= mi_parse (cmd
, &token
);
1987 if (exception
.reason
< 0)
1989 mi_print_exception (token
, exception
);
1994 volatile struct gdb_exception result
;
1995 ptid_t previous_ptid
= inferior_ptid
;
1997 command
->token
= token
;
2001 command
->cmd_start
= (struct mi_timestamp
*)
2002 xmalloc (sizeof (struct mi_timestamp
));
2003 timestamp (command
->cmd_start
);
2006 TRY_CATCH (result
, RETURN_MASK_ALL
)
2008 captured_mi_execute_command (current_uiout
, command
);
2010 if (result
.reason
< 0)
2012 /* The command execution failed and error() was called
2014 mi_print_exception (command
->token
, result
);
2015 mi_out_rewind (current_uiout
);
2018 bpstat_do_actions ();
2020 if (/* The notifications are only output when the top-level
2021 interpreter (specified on the command line) is MI. */
2022 ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ()))
2023 /* Don't try report anything if there are no threads --
2024 the program is dead. */
2025 && thread_count () != 0
2026 /* -thread-select explicitly changes thread. If frontend uses that
2027 internally, we don't want to emit =thread-selected, since
2028 =thread-selected is supposed to indicate user's intentions. */
2029 && strcmp (command
->command
, "thread-select") != 0)
2031 struct mi_interp
*mi
= top_level_interpreter_data ();
2032 int report_change
= 0;
2034 if (command
->thread
== -1)
2036 report_change
= (!ptid_equal (previous_ptid
, null_ptid
)
2037 && !ptid_equal (inferior_ptid
, previous_ptid
)
2038 && !ptid_equal (inferior_ptid
, null_ptid
));
2040 else if (!ptid_equal (inferior_ptid
, null_ptid
))
2042 struct thread_info
*ti
= inferior_thread ();
2044 report_change
= (ti
->num
!= command
->thread
);
2049 struct thread_info
*ti
= inferior_thread ();
2051 target_terminal_ours ();
2052 fprintf_unfiltered (mi
->event_channel
,
2053 "thread-selected,id=\"%d\"",
2055 gdb_flush (mi
->event_channel
);
2059 mi_parse_free (command
);
2064 mi_cmd_execute (struct mi_parse
*parse
)
2066 struct cleanup
*cleanup
;
2068 cleanup
= prepare_execute_command ();
2070 if (parse
->all
&& parse
->thread_group
!= -1)
2071 error (_("Cannot specify --thread-group together with --all"));
2073 if (parse
->all
&& parse
->thread
!= -1)
2074 error (_("Cannot specify --thread together with --all"));
2076 if (parse
->thread_group
!= -1 && parse
->thread
!= -1)
2077 error (_("Cannot specify --thread together with --thread-group"));
2079 if (parse
->frame
!= -1 && parse
->thread
== -1)
2080 error (_("Cannot specify --frame without --thread"));
2082 if (parse
->thread_group
!= -1)
2084 struct inferior
*inf
= find_inferior_id (parse
->thread_group
);
2085 struct thread_info
*tp
= 0;
2088 error (_("Invalid thread group for the --thread-group option"));
2090 set_current_inferior (inf
);
2091 /* This behaviour means that if --thread-group option identifies
2092 an inferior with multiple threads, then a random one will be
2093 picked. This is not a problem -- frontend should always
2094 provide --thread if it wishes to operate on a specific
2097 tp
= any_live_thread_of_process (inf
->pid
);
2098 switch_to_thread (tp
? tp
->ptid
: null_ptid
);
2099 set_current_program_space (inf
->pspace
);
2102 if (parse
->thread
!= -1)
2104 struct thread_info
*tp
= find_thread_id (parse
->thread
);
2107 error (_("Invalid thread id: %d"), parse
->thread
);
2109 if (is_exited (tp
->ptid
))
2110 error (_("Thread id: %d has terminated"), parse
->thread
);
2112 switch_to_thread (tp
->ptid
);
2115 if (parse
->frame
!= -1)
2117 struct frame_info
*fid
;
2118 int frame
= parse
->frame
;
2120 fid
= find_relative_frame (get_current_frame (), &frame
);
2122 /* find_relative_frame was successful */
2125 error (_("Invalid frame id: %d"), frame
);
2128 current_context
= parse
;
2130 if (parse
->cmd
->suppress_notification
!= NULL
)
2132 make_cleanup_restore_integer (parse
->cmd
->suppress_notification
);
2133 *parse
->cmd
->suppress_notification
= 1;
2136 if (parse
->cmd
->argv_func
!= NULL
)
2138 parse
->cmd
->argv_func (parse
->command
, parse
->argv
, parse
->argc
);
2140 else if (parse
->cmd
->cli
.cmd
!= 0)
2142 /* FIXME: DELETE THIS. */
2143 /* The operation is still implemented by a cli command. */
2144 /* Must be a synchronous one. */
2145 mi_execute_cli_command (parse
->cmd
->cli
.cmd
, parse
->cmd
->cli
.args_p
,
2150 /* FIXME: DELETE THIS. */
2151 struct ui_file
*stb
;
2153 stb
= mem_fileopen ();
2155 fputs_unfiltered ("Undefined mi command: ", stb
);
2156 fputstr_unfiltered (parse
->command
, '"', stb
);
2157 fputs_unfiltered (" (missing implementation)", stb
);
2159 make_cleanup_ui_file_delete (stb
);
2162 do_cleanups (cleanup
);
2165 /* FIXME: This is just a hack so we can get some extra commands going.
2166 We don't want to channel things through the CLI, but call libgdb directly.
2167 Use only for synchronous commands. */
2170 mi_execute_cli_command (const char *cmd
, int args_p
, const char *args
)
2174 struct cleanup
*old_cleanups
;
2178 run
= xstrprintf ("%s %s", cmd
, args
);
2180 run
= xstrdup (cmd
);
2182 /* FIXME: gdb_???? */
2183 fprintf_unfiltered (gdb_stdout
, "cli=%s run=%s\n",
2185 old_cleanups
= make_cleanup (xfree
, run
);
2186 execute_command (run
, 0 /* from_tty */ );
2187 do_cleanups (old_cleanups
);
2193 mi_execute_async_cli_command (char *cli_command
, char **argv
, int argc
)
2195 struct cleanup
*old_cleanups
;
2198 if (target_can_async_p ())
2199 run
= xstrprintf ("%s %s&", cli_command
, argc
? *argv
: "");
2201 run
= xstrprintf ("%s %s", cli_command
, argc
? *argv
: "");
2202 old_cleanups
= make_cleanup (xfree
, run
);
2204 execute_command (run
, 0 /* from_tty */ );
2206 /* Do this before doing any printing. It would appear that some
2207 print code leaves garbage around in the buffer. */
2208 do_cleanups (old_cleanups
);
2212 mi_load_progress (const char *section_name
,
2213 unsigned long sent_so_far
,
2214 unsigned long total_section
,
2215 unsigned long total_sent
,
2216 unsigned long grand_total
)
2218 struct timeval time_now
, delta
, update_threshold
;
2219 static struct timeval last_update
;
2220 static char *previous_sect_name
= NULL
;
2222 struct ui_out
*saved_uiout
;
2223 struct ui_out
*uiout
;
2225 /* This function is called through deprecated_show_load_progress
2226 which means uiout may not be correct. Fix it for the duration
2227 of this function. */
2228 saved_uiout
= current_uiout
;
2230 if (current_interp_named_p (INTERP_MI
)
2231 || current_interp_named_p (INTERP_MI2
))
2232 current_uiout
= mi_out_new (2);
2233 else if (current_interp_named_p (INTERP_MI1
))
2234 current_uiout
= mi_out_new (1);
2235 else if (current_interp_named_p (INTERP_MI3
))
2236 current_uiout
= mi_out_new (3);
2240 uiout
= current_uiout
;
2242 update_threshold
.tv_sec
= 0;
2243 update_threshold
.tv_usec
= 500000;
2244 gettimeofday (&time_now
, NULL
);
2246 delta
.tv_usec
= time_now
.tv_usec
- last_update
.tv_usec
;
2247 delta
.tv_sec
= time_now
.tv_sec
- last_update
.tv_sec
;
2249 if (delta
.tv_usec
< 0)
2252 delta
.tv_usec
+= 1000000L;
2255 new_section
= (previous_sect_name
?
2256 strcmp (previous_sect_name
, section_name
) : 1);
2259 struct cleanup
*cleanup_tuple
;
2261 xfree (previous_sect_name
);
2262 previous_sect_name
= xstrdup (section_name
);
2265 fputs_unfiltered (current_token
, raw_stdout
);
2266 fputs_unfiltered ("+download", raw_stdout
);
2267 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2268 ui_out_field_string (uiout
, "section", section_name
);
2269 ui_out_field_int (uiout
, "section-size", total_section
);
2270 ui_out_field_int (uiout
, "total-size", grand_total
);
2271 do_cleanups (cleanup_tuple
);
2272 mi_out_put (uiout
, raw_stdout
);
2273 fputs_unfiltered ("\n", raw_stdout
);
2274 gdb_flush (raw_stdout
);
2277 if (delta
.tv_sec
>= update_threshold
.tv_sec
&&
2278 delta
.tv_usec
>= update_threshold
.tv_usec
)
2280 struct cleanup
*cleanup_tuple
;
2282 last_update
.tv_sec
= time_now
.tv_sec
;
2283 last_update
.tv_usec
= time_now
.tv_usec
;
2285 fputs_unfiltered (current_token
, raw_stdout
);
2286 fputs_unfiltered ("+download", raw_stdout
);
2287 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2288 ui_out_field_string (uiout
, "section", section_name
);
2289 ui_out_field_int (uiout
, "section-sent", sent_so_far
);
2290 ui_out_field_int (uiout
, "section-size", total_section
);
2291 ui_out_field_int (uiout
, "total-sent", total_sent
);
2292 ui_out_field_int (uiout
, "total-size", grand_total
);
2293 do_cleanups (cleanup_tuple
);
2294 mi_out_put (uiout
, raw_stdout
);
2295 fputs_unfiltered ("\n", raw_stdout
);
2296 gdb_flush (raw_stdout
);
2300 current_uiout
= saved_uiout
;
2304 timestamp (struct mi_timestamp
*tv
)
2306 gettimeofday (&tv
->wallclock
, NULL
);
2307 #ifdef HAVE_GETRUSAGE
2308 getrusage (RUSAGE_SELF
, &rusage
);
2309 tv
->utime
.tv_sec
= rusage
.ru_utime
.tv_sec
;
2310 tv
->utime
.tv_usec
= rusage
.ru_utime
.tv_usec
;
2311 tv
->stime
.tv_sec
= rusage
.ru_stime
.tv_sec
;
2312 tv
->stime
.tv_usec
= rusage
.ru_stime
.tv_usec
;
2315 long usec
= get_run_time ();
2317 tv
->utime
.tv_sec
= usec
/1000000L;
2318 tv
->utime
.tv_usec
= usec
- 1000000L*tv
->utime
.tv_sec
;
2319 tv
->stime
.tv_sec
= 0;
2320 tv
->stime
.tv_usec
= 0;
2326 print_diff_now (struct mi_timestamp
*start
)
2328 struct mi_timestamp now
;
2331 print_diff (start
, &now
);
2335 mi_print_timing_maybe (void)
2337 /* If the command is -enable-timing then do_timings may be true
2338 whilst current_command_ts is not initialized. */
2339 if (do_timings
&& current_command_ts
)
2340 print_diff_now (current_command_ts
);
2344 timeval_diff (struct timeval start
, struct timeval end
)
2346 return ((end
.tv_sec
- start
.tv_sec
) * 1000000L)
2347 + (end
.tv_usec
- start
.tv_usec
);
2351 print_diff (struct mi_timestamp
*start
, struct mi_timestamp
*end
)
2355 ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
2356 timeval_diff (start
->wallclock
, end
->wallclock
) / 1000000.0,
2357 timeval_diff (start
->utime
, end
->utime
) / 1000000.0,
2358 timeval_diff (start
->stime
, end
->stime
) / 1000000.0);
2362 mi_cmd_trace_define_variable (char *command
, char **argv
, int argc
)
2364 struct expression
*expr
;
2365 LONGEST initval
= 0;
2366 struct trace_state_variable
*tsv
;
2369 if (argc
!= 1 && argc
!= 2)
2370 error (_("Usage: -trace-define-variable VARIABLE [VALUE]"));
2374 error (_("Name of trace variable should start with '$'"));
2376 validate_trace_state_variable_name (name
);
2378 tsv
= find_trace_state_variable (name
);
2380 tsv
= create_trace_state_variable (name
);
2383 initval
= value_as_long (parse_and_eval (argv
[1]));
2385 tsv
->initial_value
= initval
;
2389 mi_cmd_trace_list_variables (char *command
, char **argv
, int argc
)
2392 error (_("-trace-list-variables: no arguments allowed"));
2394 tvariables_info_1 ();
2398 mi_cmd_trace_find (char *command
, char **argv
, int argc
)
2403 error (_("trace selection mode is required"));
2407 if (strcmp (mode
, "none") == 0)
2409 tfind_1 (tfind_number
, -1, 0, 0, 0);
2413 if (current_trace_status ()->running
)
2414 error (_("May not look at trace frames while trace is running."));
2416 if (strcmp (mode
, "frame-number") == 0)
2419 error (_("frame number is required"));
2420 tfind_1 (tfind_number
, atoi (argv
[1]), 0, 0, 0);
2422 else if (strcmp (mode
, "tracepoint-number") == 0)
2425 error (_("tracepoint number is required"));
2426 tfind_1 (tfind_tp
, atoi (argv
[1]), 0, 0, 0);
2428 else if (strcmp (mode
, "pc") == 0)
2431 error (_("PC is required"));
2432 tfind_1 (tfind_pc
, 0, parse_and_eval_address (argv
[1]), 0, 0);
2434 else if (strcmp (mode
, "pc-inside-range") == 0)
2437 error (_("Start and end PC are required"));
2438 tfind_1 (tfind_range
, 0, parse_and_eval_address (argv
[1]),
2439 parse_and_eval_address (argv
[2]), 0);
2441 else if (strcmp (mode
, "pc-outside-range") == 0)
2444 error (_("Start and end PC are required"));
2445 tfind_1 (tfind_outside
, 0, parse_and_eval_address (argv
[1]),
2446 parse_and_eval_address (argv
[2]), 0);
2448 else if (strcmp (mode
, "line") == 0)
2450 struct symtabs_and_lines sals
;
2451 struct symtab_and_line sal
;
2452 static CORE_ADDR start_pc
, end_pc
;
2453 struct cleanup
*back_to
;
2456 error (_("Line is required"));
2458 sals
= decode_line_with_current_source (argv
[1],
2459 DECODE_LINE_FUNFIRSTLINE
);
2460 back_to
= make_cleanup (xfree
, sals
.sals
);
2464 if (sal
.symtab
== 0)
2465 error (_("Could not find the specified line"));
2467 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2468 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, 0);
2470 error (_("Could not find the specified line"));
2472 do_cleanups (back_to
);
2475 error (_("Invalid mode '%s'"), mode
);
2477 if (has_stack_frames () || get_traceframe_number () >= 0)
2478 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
2482 mi_cmd_trace_save (char *command
, char **argv
, int argc
)
2484 int target_saves
= 0;
2485 int generate_ctf
= 0;
2492 TARGET_SAVE_OPT
, CTF_OPT
2494 static const struct mi_opt opts
[] =
2496 {"r", TARGET_SAVE_OPT
, 0},
2497 {"ctf", CTF_OPT
, 0},
2503 int opt
= mi_getopt ("-trace-save", argc
, argv
, opts
,
2508 switch ((enum opt
) opt
)
2510 case TARGET_SAVE_OPT
:
2518 filename
= argv
[oind
];
2521 trace_save_ctf (filename
, target_saves
);
2523 trace_save_tfile (filename
, target_saves
);
2527 mi_cmd_trace_start (char *command
, char **argv
, int argc
)
2529 start_tracing (NULL
);
2533 mi_cmd_trace_status (char *command
, char **argv
, int argc
)
2535 trace_status_mi (0);
2539 mi_cmd_trace_stop (char *command
, char **argv
, int argc
)
2541 stop_tracing (NULL
);
2542 trace_status_mi (1);
2545 /* Implement the "-ada-task-info" command. */
2548 mi_cmd_ada_task_info (char *command
, char **argv
, int argc
)
2550 if (argc
!= 0 && argc
!= 1)
2551 error (_("Invalid MI command"));
2553 print_ada_task_info (current_uiout
, argv
[0], current_inferior ());