3 Copyright (C) 2000-2016 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"
28 #include "gdbthread.h"
31 #include "mi-getopt.h"
32 #include "mi-console.h"
36 #include "event-loop.h"
37 #include "event-top.h"
38 #include "gdbcore.h" /* For write_memory(). */
44 #include "mi-common.h"
49 #include "splay-tree.h"
50 #include "tracepoint.h"
54 #include "extension.h"
59 #include "gdb_sys_time.h"
61 #if defined HAVE_SYS_RESOURCE_H
62 #include <sys/resource.h>
76 /* This is used to pass the current command timestamp down to
77 continuation routines. */
78 static struct mi_timestamp
*current_command_ts
;
80 static int do_timings
= 0;
83 /* Few commands would like to know if options like --thread-group were
84 explicitly specified. This variable keeps the current parsed
85 command including all option, and make it possible. */
86 static struct mi_parse
*current_context
;
88 int running_result_record_printed
= 1;
90 /* Flag indicating that the target has proceeded since the last
91 command was issued. */
94 extern void _initialize_mi_main (void);
95 static void mi_cmd_execute (struct mi_parse
*parse
);
97 static void mi_execute_cli_command (const char *cmd
, int args_p
,
99 static void mi_execute_async_cli_command (char *cli_command
,
100 char **argv
, int argc
);
101 static int register_changed_p (int regnum
, struct regcache
*,
103 static void output_register (struct frame_info
*, int regnum
, int format
,
104 int skip_unavailable
);
106 /* Controls whether the frontend wants MI in async mode. */
107 static int mi_async
= 0;
109 /* The set command writes to this variable. If the inferior is
110 executing, mi_async is *not* updated. */
111 static int mi_async_1
= 0;
114 set_mi_async_command (char *args
, int from_tty
,
115 struct cmd_list_element
*c
)
117 if (have_live_inferiors ())
119 mi_async_1
= mi_async
;
120 error (_("Cannot change this setting while the inferior is running."));
123 mi_async
= mi_async_1
;
127 show_mi_async_command (struct ui_file
*file
, int from_tty
,
128 struct cmd_list_element
*c
,
131 fprintf_filtered (file
,
132 _("Whether MI is in asynchronous mode is %s.\n"),
136 /* A wrapper for target_can_async_p that takes the MI setting into
142 return mi_async
&& target_can_async_p ();
145 /* Command implementations. FIXME: Is this libgdb? No. This is the MI
146 layer that calls libgdb. Any operation used in the below should be
149 static void timestamp (struct mi_timestamp
*tv
);
151 static void print_diff (struct ui_file
*file
, struct mi_timestamp
*start
,
152 struct mi_timestamp
*end
);
155 mi_cmd_gdb_exit (char *command
, char **argv
, int argc
)
158 = (struct mi_interp
*) interp_data (current_interpreter ());
160 /* We have to print everything right here because we never return. */
162 fputs_unfiltered (current_token
, mi
->raw_stdout
);
163 fputs_unfiltered ("^exit\n", mi
->raw_stdout
);
164 mi_out_put (current_uiout
, mi
->raw_stdout
);
165 gdb_flush (mi
->raw_stdout
);
166 /* FIXME: The function called is not yet a formal libgdb function. */
167 quit_force (NULL
, FROM_TTY
);
171 mi_cmd_exec_next (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-next", argv
+ 1, argc
- 1);
177 mi_execute_async_cli_command ("next", argv
, argc
);
181 mi_cmd_exec_next_instruction (char *command
, char **argv
, int argc
)
183 /* FIXME: Should call a libgdb function, not a cli wrapper. */
184 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
185 mi_execute_async_cli_command ("reverse-nexti", argv
+ 1, argc
- 1);
187 mi_execute_async_cli_command ("nexti", argv
, argc
);
191 mi_cmd_exec_step (char *command
, char **argv
, int argc
)
193 /* FIXME: Should call a libgdb function, not a cli wrapper. */
194 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
195 mi_execute_async_cli_command ("reverse-step", argv
+ 1, argc
- 1);
197 mi_execute_async_cli_command ("step", argv
, argc
);
201 mi_cmd_exec_step_instruction (char *command
, char **argv
, int argc
)
203 /* FIXME: Should call a libgdb function, not a cli wrapper. */
204 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
205 mi_execute_async_cli_command ("reverse-stepi", argv
+ 1, argc
- 1);
207 mi_execute_async_cli_command ("stepi", argv
, argc
);
211 mi_cmd_exec_finish (char *command
, char **argv
, int argc
)
213 /* FIXME: Should call a libgdb function, not a cli wrapper. */
214 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
215 mi_execute_async_cli_command ("reverse-finish", argv
+ 1, argc
- 1);
217 mi_execute_async_cli_command ("finish", argv
, argc
);
221 mi_cmd_exec_return (char *command
, char **argv
, int argc
)
223 /* This command doesn't really execute the target, it just pops the
224 specified number of frames. */
226 /* Call return_command with from_tty argument equal to 0 so as to
227 avoid being queried. */
228 return_command (*argv
, 0);
230 /* Call return_command with from_tty argument equal to 0 so as to
231 avoid being queried. */
232 return_command (NULL
, 0);
234 /* Because we have called return_command with from_tty = 0, we need
235 to print the frame here. */
236 print_stack_frame (get_selected_frame (NULL
), 1, LOC_AND_ADDRESS
, 1);
240 mi_cmd_exec_jump (char *args
, char **argv
, int argc
)
242 /* FIXME: Should call a libgdb function, not a cli wrapper. */
243 mi_execute_async_cli_command ("jump", argv
, argc
);
247 proceed_thread (struct thread_info
*thread
, int pid
)
249 if (!is_stopped (thread
->ptid
))
252 if (pid
!= 0 && ptid_get_pid (thread
->ptid
) != pid
)
255 switch_to_thread (thread
->ptid
);
256 clear_proceed_status (0);
257 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
);
261 proceed_thread_callback (struct thread_info
*thread
, void *arg
)
263 int pid
= *(int *)arg
;
265 proceed_thread (thread
, pid
);
270 exec_continue (char **argv
, int argc
)
272 prepare_execution_command (¤t_target
, mi_async_p ());
276 /* In non-stop mode, 'resume' always resumes a single thread.
277 Therefore, to resume all threads of the current inferior, or
278 all threads in all inferiors, we need to iterate over
281 See comment on infcmd.c:proceed_thread_callback for rationale. */
282 if (current_context
->all
|| current_context
->thread_group
!= -1)
285 struct cleanup
*back_to
= make_cleanup_restore_current_thread ();
287 if (!current_context
->all
)
290 = find_inferior_id (current_context
->thread_group
);
294 iterate_over_threads (proceed_thread_callback
, &pid
);
295 do_cleanups (back_to
);
304 struct cleanup
*back_to
= make_cleanup_restore_integer (&sched_multi
);
306 if (current_context
->all
)
313 /* In all-stop mode, -exec-continue traditionally resumed
314 either all threads, or one thread, depending on the
315 'scheduler-locking' variable. Let's continue to do the
319 do_cleanups (back_to
);
324 exec_direction_forward (void *notused
)
326 execution_direction
= EXEC_FORWARD
;
330 exec_reverse_continue (char **argv
, int argc
)
332 enum exec_direction_kind dir
= execution_direction
;
333 struct cleanup
*old_chain
;
335 if (dir
== EXEC_REVERSE
)
336 error (_("Already in reverse mode."));
338 if (!target_can_execute_reverse
)
339 error (_("Target %s does not support this command."), target_shortname
);
341 old_chain
= make_cleanup (exec_direction_forward
, NULL
);
342 execution_direction
= EXEC_REVERSE
;
343 exec_continue (argv
, argc
);
344 do_cleanups (old_chain
);
348 mi_cmd_exec_continue (char *command
, char **argv
, int argc
)
350 if (argc
> 0 && strcmp (argv
[0], "--reverse") == 0)
351 exec_reverse_continue (argv
+ 1, argc
- 1);
353 exec_continue (argv
, argc
);
357 interrupt_thread_callback (struct thread_info
*thread
, void *arg
)
359 int pid
= *(int *)arg
;
361 if (!is_running (thread
->ptid
))
364 if (ptid_get_pid (thread
->ptid
) != pid
)
367 target_stop (thread
->ptid
);
371 /* Interrupt the execution of the target. Note how we must play
372 around with the token variables, in order to display the current
373 token in the result of the interrupt command, and the previous
374 execution token when the target finally stops. See comments in
378 mi_cmd_exec_interrupt (char *command
, char **argv
, int argc
)
380 /* In all-stop mode, everything stops, so we don't need to try
381 anything specific. */
384 interrupt_target_1 (0);
388 if (current_context
->all
)
390 /* This will interrupt all threads in all inferiors. */
391 interrupt_target_1 (1);
393 else if (current_context
->thread_group
!= -1)
395 struct inferior
*inf
= find_inferior_id (current_context
->thread_group
);
397 iterate_over_threads (interrupt_thread_callback
, &inf
->pid
);
401 /* Interrupt just the current thread -- either explicitly
402 specified via --thread or whatever was current before
403 MI command was sent. */
404 interrupt_target_1 (0);
408 /* Callback for iterate_over_inferiors which starts the execution
409 of the given inferior.
411 ARG is a pointer to an integer whose value, if non-zero, indicates
412 that the program should be stopped when reaching the main subprogram
413 (similar to what the CLI "start" command does). */
416 run_one_inferior (struct inferior
*inf
, void *arg
)
418 int start_p
= *(int *) arg
;
419 const char *run_cmd
= start_p
? "start" : "run";
420 struct target_ops
*run_target
= find_run_target ();
421 int async_p
= mi_async
&& run_target
->to_can_async_p (run_target
);
425 if (inf
->pid
!= ptid_get_pid (inferior_ptid
))
427 struct thread_info
*tp
;
429 tp
= any_thread_of_process (inf
->pid
);
431 error (_("Inferior has no threads."));
433 switch_to_thread (tp
->ptid
);
438 set_current_inferior (inf
);
439 switch_to_thread (null_ptid
);
440 set_current_program_space (inf
->pspace
);
442 mi_execute_cli_command (run_cmd
, async_p
,
443 async_p
? "&" : NULL
);
448 mi_cmd_exec_run (char *command
, char **argv
, int argc
)
452 /* Parse the command options. */
457 static const struct mi_opt opts
[] =
459 {"-start", START_OPT
, 0},
468 int opt
= mi_getopt ("-exec-run", argc
, argv
, opts
, &oind
, &oarg
);
472 switch ((enum opt
) opt
)
480 /* This command does not accept any argument. Make sure the user
481 did not provide any. */
483 error (_("Invalid argument: %s"), argv
[oind
]);
485 if (current_context
->all
)
487 struct cleanup
*back_to
= save_current_space_and_thread ();
489 iterate_over_inferiors (run_one_inferior
, &start_p
);
490 do_cleanups (back_to
);
494 const char *run_cmd
= start_p
? "start" : "run";
495 struct target_ops
*run_target
= find_run_target ();
496 int async_p
= mi_async
&& run_target
->to_can_async_p (run_target
);
498 mi_execute_cli_command (run_cmd
, async_p
,
499 async_p
? "&" : NULL
);
505 find_thread_of_process (struct thread_info
*ti
, void *p
)
509 if (ptid_get_pid (ti
->ptid
) == pid
&& !is_exited (ti
->ptid
))
516 mi_cmd_target_detach (char *command
, char **argv
, int argc
)
518 if (argc
!= 0 && argc
!= 1)
519 error (_("Usage: -target-detach [pid | thread-group]"));
523 struct thread_info
*tp
;
527 /* First see if we are dealing with a thread-group id. */
530 struct inferior
*inf
;
531 int id
= strtoul (argv
[0] + 1, &end
, 0);
534 error (_("Invalid syntax of thread-group id '%s'"), argv
[0]);
536 inf
= find_inferior_id (id
);
538 error (_("Non-existent thread-group id '%d'"), id
);
544 /* We must be dealing with a pid. */
545 pid
= strtol (argv
[0], &end
, 10);
548 error (_("Invalid identifier '%s'"), argv
[0]);
551 /* Pick any thread in the desired process. Current
552 target_detach detaches from the parent of inferior_ptid. */
553 tp
= iterate_over_threads (find_thread_of_process
, &pid
);
555 error (_("Thread group is empty"));
557 switch_to_thread (tp
->ptid
);
560 detach_command (NULL
, 0);
564 mi_cmd_thread_select (char *command
, char **argv
, int argc
)
567 char *mi_error_message
;
568 ptid_t previous_ptid
= inferior_ptid
;
571 error (_("-thread-select: USAGE: threadnum."));
573 rc
= gdb_thread_select (current_uiout
, argv
[0], &mi_error_message
);
575 /* If thread switch did not succeed don't notify or print. */
576 if (rc
== GDB_RC_FAIL
)
578 make_cleanup (xfree
, mi_error_message
);
579 error ("%s", mi_error_message
);
582 print_selected_thread_frame (current_uiout
,
583 USER_SELECTED_THREAD
| USER_SELECTED_FRAME
);
585 /* Notify if the thread has effectively changed. */
586 if (!ptid_equal (inferior_ptid
, previous_ptid
))
588 observer_notify_user_selected_context_changed (USER_SELECTED_THREAD
589 | USER_SELECTED_FRAME
);
594 mi_cmd_thread_list_ids (char *command
, char **argv
, int argc
)
597 char *mi_error_message
;
600 error (_("-thread-list-ids: No arguments required."));
602 rc
= gdb_list_thread_ids (current_uiout
, &mi_error_message
);
604 if (rc
== GDB_RC_FAIL
)
606 make_cleanup (xfree
, mi_error_message
);
607 error ("%s", mi_error_message
);
612 mi_cmd_thread_info (char *command
, char **argv
, int argc
)
614 if (argc
!= 0 && argc
!= 1)
615 error (_("Invalid MI command"));
617 print_thread_info (current_uiout
, argv
[0], -1);
620 struct collect_cores_data
628 collect_cores (struct thread_info
*ti
, void *xdata
)
630 struct collect_cores_data
*data
= (struct collect_cores_data
*) xdata
;
632 if (ptid_get_pid (ti
->ptid
) == data
->pid
)
634 int core
= target_core_of_thread (ti
->ptid
);
637 VEC_safe_push (int, data
->cores
, core
);
644 unique (int *b
, int *e
)
654 struct print_one_inferior_data
657 VEC (int) *inferiors
;
661 print_one_inferior (struct inferior
*inferior
, void *xdata
)
663 struct print_one_inferior_data
*top_data
664 = (struct print_one_inferior_data
*) xdata
;
665 struct ui_out
*uiout
= current_uiout
;
667 if (VEC_empty (int, top_data
->inferiors
)
668 || bsearch (&(inferior
->pid
), VEC_address (int, top_data
->inferiors
),
669 VEC_length (int, top_data
->inferiors
), sizeof (int),
670 compare_positive_ints
))
672 struct collect_cores_data data
;
673 struct cleanup
*back_to
674 = make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
676 ui_out_field_fmt (uiout
, "id", "i%d", inferior
->num
);
677 ui_out_field_string (uiout
, "type", "process");
678 if (inferior
->has_exit_code
)
679 ui_out_field_string (uiout
, "exit-code",
680 int_string (inferior
->exit_code
, 8, 0, 0, 1));
681 if (inferior
->pid
!= 0)
682 ui_out_field_int (uiout
, "pid", inferior
->pid
);
684 if (inferior
->pspace
->pspace_exec_filename
!= NULL
)
686 ui_out_field_string (uiout
, "executable",
687 inferior
->pspace
->pspace_exec_filename
);
691 if (inferior
->pid
!= 0)
693 data
.pid
= inferior
->pid
;
694 iterate_over_threads (collect_cores
, &data
);
697 if (!VEC_empty (int, data
.cores
))
700 struct cleanup
*back_to_2
=
701 make_cleanup_ui_out_list_begin_end (uiout
, "cores");
703 qsort (VEC_address (int, data
.cores
),
704 VEC_length (int, data
.cores
), sizeof (int),
705 compare_positive_ints
);
707 b
= VEC_address (int, data
.cores
);
708 e
= b
+ VEC_length (int, data
.cores
);
712 ui_out_field_int (uiout
, NULL
, *b
);
714 do_cleanups (back_to_2
);
717 if (top_data
->recurse
)
718 print_thread_info (uiout
, NULL
, inferior
->pid
);
720 do_cleanups (back_to
);
726 /* Output a field named 'cores' with a list as the value. The
727 elements of the list are obtained by splitting 'cores' on
731 output_cores (struct ui_out
*uiout
, const char *field_name
, const char *xcores
)
733 struct cleanup
*back_to
= make_cleanup_ui_out_list_begin_end (uiout
,
735 char *cores
= xstrdup (xcores
);
738 make_cleanup (xfree
, cores
);
740 for (p
= strtok (p
, ","); p
; p
= strtok (NULL
, ","))
741 ui_out_field_string (uiout
, NULL
, p
);
743 do_cleanups (back_to
);
747 free_vector_of_ints (void *xvector
)
749 VEC (int) **vector
= (VEC (int) **) xvector
;
751 VEC_free (int, *vector
);
755 do_nothing (splay_tree_key k
)
760 free_vector_of_osdata_items (splay_tree_value xvalue
)
762 VEC (osdata_item_s
) *value
= (VEC (osdata_item_s
) *) xvalue
;
764 /* We don't free the items itself, it will be done separately. */
765 VEC_free (osdata_item_s
, value
);
769 splay_tree_int_comparator (splay_tree_key xa
, splay_tree_key xb
)
778 free_splay_tree (void *xt
)
780 splay_tree t
= (splay_tree
) xt
;
781 splay_tree_delete (t
);
785 list_available_thread_groups (VEC (int) *ids
, int recurse
)
788 struct osdata_item
*item
;
790 struct ui_out
*uiout
= current_uiout
;
791 struct cleanup
*cleanup
;
793 /* This keeps a map from integer (pid) to VEC (struct osdata_item *)*
794 The vector contains information about all threads for the given pid.
795 This is assigned an initial value to avoid "may be used uninitialized"
797 splay_tree tree
= NULL
;
799 /* get_osdata will throw if it cannot return data. */
800 data
= get_osdata ("processes");
801 cleanup
= make_cleanup_osdata_free (data
);
805 struct osdata
*threads
= get_osdata ("threads");
807 make_cleanup_osdata_free (threads
);
808 tree
= splay_tree_new (splay_tree_int_comparator
,
810 free_vector_of_osdata_items
);
811 make_cleanup (free_splay_tree
, tree
);
814 VEC_iterate (osdata_item_s
, threads
->items
,
818 const char *pid
= get_osdata_column (item
, "pid");
819 int pid_i
= strtoul (pid
, NULL
, 0);
820 VEC (osdata_item_s
) *vec
= 0;
822 splay_tree_node n
= splay_tree_lookup (tree
, pid_i
);
825 VEC_safe_push (osdata_item_s
, vec
, item
);
826 splay_tree_insert (tree
, pid_i
, (splay_tree_value
)vec
);
830 vec
= (VEC (osdata_item_s
) *) n
->value
;
831 VEC_safe_push (osdata_item_s
, vec
, item
);
832 n
->value
= (splay_tree_value
) vec
;
837 make_cleanup_ui_out_list_begin_end (uiout
, "groups");
840 VEC_iterate (osdata_item_s
, data
->items
,
844 struct cleanup
*back_to
;
846 const char *pid
= get_osdata_column (item
, "pid");
847 const char *cmd
= get_osdata_column (item
, "command");
848 const char *user
= get_osdata_column (item
, "user");
849 const char *cores
= get_osdata_column (item
, "cores");
851 int pid_i
= strtoul (pid
, NULL
, 0);
853 /* At present, the target will return all available processes
854 and if information about specific ones was required, we filter
855 undesired processes here. */
856 if (ids
&& bsearch (&pid_i
, VEC_address (int, ids
),
857 VEC_length (int, ids
),
858 sizeof (int), compare_positive_ints
) == NULL
)
862 back_to
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
864 ui_out_field_fmt (uiout
, "id", "%s", pid
);
865 ui_out_field_string (uiout
, "type", "process");
867 ui_out_field_string (uiout
, "description", cmd
);
869 ui_out_field_string (uiout
, "user", user
);
871 output_cores (uiout
, "cores", cores
);
875 splay_tree_node n
= splay_tree_lookup (tree
, pid_i
);
878 VEC (osdata_item_s
) *children
= (VEC (osdata_item_s
) *) n
->value
;
879 struct osdata_item
*child
;
882 make_cleanup_ui_out_list_begin_end (uiout
, "threads");
885 VEC_iterate (osdata_item_s
, children
, ix_child
, child
);
888 struct cleanup
*back_to_2
=
889 make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
890 const char *tid
= get_osdata_column (child
, "tid");
891 const char *tcore
= get_osdata_column (child
, "core");
893 ui_out_field_string (uiout
, "id", tid
);
895 ui_out_field_string (uiout
, "core", tcore
);
897 do_cleanups (back_to_2
);
902 do_cleanups (back_to
);
905 do_cleanups (cleanup
);
909 mi_cmd_list_thread_groups (char *command
, char **argv
, int argc
)
911 struct ui_out
*uiout
= current_uiout
;
912 struct cleanup
*back_to
;
919 AVAILABLE_OPT
, RECURSE_OPT
921 static const struct mi_opt opts
[] =
923 {"-available", AVAILABLE_OPT
, 0},
924 {"-recurse", RECURSE_OPT
, 1},
933 int opt
= mi_getopt ("-list-thread-groups", argc
, argv
, opts
,
938 switch ((enum opt
) opt
)
944 if (strcmp (oarg
, "0") == 0)
946 else if (strcmp (oarg
, "1") == 0)
949 error (_("only '0' and '1' are valid values "
950 "for the '--recurse' option"));
955 for (; oind
< argc
; ++oind
)
960 if (*(argv
[oind
]) != 'i')
961 error (_("invalid syntax of group id '%s'"), argv
[oind
]);
963 inf
= strtoul (argv
[oind
] + 1, &end
, 0);
966 error (_("invalid syntax of group id '%s'"), argv
[oind
]);
967 VEC_safe_push (int, ids
, inf
);
969 if (VEC_length (int, ids
) > 1)
970 qsort (VEC_address (int, ids
),
971 VEC_length (int, ids
),
972 sizeof (int), compare_positive_ints
);
974 back_to
= make_cleanup (free_vector_of_ints
, &ids
);
978 list_available_thread_groups (ids
, recurse
);
980 else if (VEC_length (int, ids
) == 1)
982 /* Local thread groups, single id. */
983 int id
= *VEC_address (int, ids
);
984 struct inferior
*inf
= find_inferior_id (id
);
987 error (_("Non-existent thread group id '%d'"), id
);
989 print_thread_info (uiout
, NULL
, inf
->pid
);
993 struct print_one_inferior_data data
;
995 data
.recurse
= recurse
;
996 data
.inferiors
= ids
;
998 /* Local thread groups. Either no explicit ids -- and we
999 print everything, or several explicit ids. In both cases,
1000 we print more than one group, and have to use 'groups'
1001 as the top-level element. */
1002 make_cleanup_ui_out_list_begin_end (uiout
, "groups");
1003 update_thread_list ();
1004 iterate_over_inferiors (print_one_inferior
, &data
);
1007 do_cleanups (back_to
);
1011 mi_cmd_data_list_register_names (char *command
, char **argv
, int argc
)
1013 struct gdbarch
*gdbarch
;
1014 struct ui_out
*uiout
= current_uiout
;
1015 int regnum
, numregs
;
1017 struct cleanup
*cleanup
;
1019 /* Note that the test for a valid register must include checking the
1020 gdbarch_register_name because gdbarch_num_regs may be allocated
1021 for the union of the register sets within a family of related
1022 processors. In this case, some entries of gdbarch_register_name
1023 will change depending upon the particular processor being
1026 gdbarch
= get_current_arch ();
1027 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1029 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "register-names");
1031 if (argc
== 0) /* No args, just do all the regs. */
1037 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1038 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1039 ui_out_field_string (uiout
, NULL
, "");
1041 ui_out_field_string (uiout
, NULL
,
1042 gdbarch_register_name (gdbarch
, regnum
));
1046 /* Else, list of register #s, just do listed regs. */
1047 for (i
= 0; i
< argc
; i
++)
1049 regnum
= atoi (argv
[i
]);
1050 if (regnum
< 0 || regnum
>= numregs
)
1051 error (_("bad register number"));
1053 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1054 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1055 ui_out_field_string (uiout
, NULL
, "");
1057 ui_out_field_string (uiout
, NULL
,
1058 gdbarch_register_name (gdbarch
, regnum
));
1060 do_cleanups (cleanup
);
1064 mi_cmd_data_list_changed_registers (char *command
, char **argv
, int argc
)
1066 static struct regcache
*this_regs
= NULL
;
1067 struct ui_out
*uiout
= current_uiout
;
1068 struct regcache
*prev_regs
;
1069 struct gdbarch
*gdbarch
;
1070 int regnum
, numregs
, changed
;
1072 struct cleanup
*cleanup
;
1074 /* The last time we visited this function, the current frame's
1075 register contents were saved in THIS_REGS. Move THIS_REGS over
1076 to PREV_REGS, and refresh THIS_REGS with the now-current register
1079 prev_regs
= this_regs
;
1080 this_regs
= frame_save_as_regcache (get_selected_frame (NULL
));
1081 cleanup
= make_cleanup_regcache_xfree (prev_regs
);
1083 /* Note that the test for a valid register must include checking the
1084 gdbarch_register_name because gdbarch_num_regs may be allocated
1085 for the union of the register sets within a family of related
1086 processors. In this case, some entries of gdbarch_register_name
1087 will change depending upon the particular processor being
1090 gdbarch
= get_regcache_arch (this_regs
);
1091 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1093 make_cleanup_ui_out_list_begin_end (uiout
, "changed-registers");
1097 /* No args, just do all the regs. */
1102 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1103 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1105 changed
= register_changed_p (regnum
, prev_regs
, this_regs
);
1107 error (_("-data-list-changed-registers: "
1108 "Unable to read register contents."));
1110 ui_out_field_int (uiout
, NULL
, regnum
);
1114 /* Else, list of register #s, just do listed regs. */
1115 for (i
= 0; i
< argc
; i
++)
1117 regnum
= atoi (argv
[i
]);
1121 && gdbarch_register_name (gdbarch
, regnum
) != NULL
1122 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
1124 changed
= register_changed_p (regnum
, prev_regs
, this_regs
);
1126 error (_("-data-list-changed-registers: "
1127 "Unable to read register contents."));
1129 ui_out_field_int (uiout
, NULL
, regnum
);
1132 error (_("bad register number"));
1134 do_cleanups (cleanup
);
1138 register_changed_p (int regnum
, struct regcache
*prev_regs
,
1139 struct regcache
*this_regs
)
1141 struct gdbarch
*gdbarch
= get_regcache_arch (this_regs
);
1142 gdb_byte prev_buffer
[MAX_REGISTER_SIZE
];
1143 gdb_byte this_buffer
[MAX_REGISTER_SIZE
];
1144 enum register_status prev_status
;
1145 enum register_status this_status
;
1147 /* First time through or after gdbarch change consider all registers
1149 if (!prev_regs
|| get_regcache_arch (prev_regs
) != gdbarch
)
1152 /* Get register contents and compare. */
1153 prev_status
= regcache_cooked_read (prev_regs
, regnum
, prev_buffer
);
1154 this_status
= regcache_cooked_read (this_regs
, regnum
, this_buffer
);
1156 if (this_status
!= prev_status
)
1158 else if (this_status
== REG_VALID
)
1159 return memcmp (prev_buffer
, this_buffer
,
1160 register_size (gdbarch
, regnum
)) != 0;
1165 /* Return a list of register number and value pairs. The valid
1166 arguments expected are: a letter indicating the format in which to
1167 display the registers contents. This can be one of: x
1168 (hexadecimal), d (decimal), N (natural), t (binary), o (octal), r
1169 (raw). After the format argument there can be a sequence of
1170 numbers, indicating which registers to fetch the content of. If
1171 the format is the only argument, a list of all the registers with
1172 their values is returned. */
1175 mi_cmd_data_list_register_values (char *command
, char **argv
, int argc
)
1177 struct ui_out
*uiout
= current_uiout
;
1178 struct frame_info
*frame
;
1179 struct gdbarch
*gdbarch
;
1180 int regnum
, numregs
, format
;
1182 struct cleanup
*list_cleanup
;
1183 int skip_unavailable
= 0;
1189 static const struct mi_opt opts
[] =
1191 {"-skip-unavailable", SKIP_UNAVAILABLE
, 0},
1195 /* Note that the test for a valid register must include checking the
1196 gdbarch_register_name because gdbarch_num_regs may be allocated
1197 for the union of the register sets within a family of related
1198 processors. In this case, some entries of gdbarch_register_name
1199 will change depending upon the particular processor being
1205 int opt
= mi_getopt ("-data-list-register-values", argc
, argv
,
1206 opts
, &oind
, &oarg
);
1210 switch ((enum opt
) opt
)
1212 case SKIP_UNAVAILABLE
:
1213 skip_unavailable
= 1;
1218 if (argc
- oind
< 1)
1219 error (_("-data-list-register-values: Usage: "
1220 "-data-list-register-values [--skip-unavailable] <format>"
1221 " [<regnum1>...<regnumN>]"));
1223 format
= (int) argv
[oind
][0];
1225 frame
= get_selected_frame (NULL
);
1226 gdbarch
= get_frame_arch (frame
);
1227 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1229 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "register-values");
1231 if (argc
- oind
== 1)
1233 /* No args, beside the format: do all the regs. */
1238 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1239 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1242 output_register (frame
, regnum
, format
, skip_unavailable
);
1246 /* Else, list of register #s, just do listed regs. */
1247 for (i
= 1 + oind
; i
< argc
; i
++)
1249 regnum
= atoi (argv
[i
]);
1253 && gdbarch_register_name (gdbarch
, regnum
) != NULL
1254 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
1255 output_register (frame
, regnum
, format
, skip_unavailable
);
1257 error (_("bad register number"));
1259 do_cleanups (list_cleanup
);
1262 /* Output one register REGNUM's contents in the desired FORMAT. If
1263 SKIP_UNAVAILABLE is true, skip the register if it is
1267 output_register (struct frame_info
*frame
, int regnum
, int format
,
1268 int skip_unavailable
)
1270 struct ui_out
*uiout
= current_uiout
;
1271 struct value
*val
= value_of_register (regnum
, frame
);
1272 struct cleanup
*tuple_cleanup
;
1273 struct value_print_options opts
;
1274 struct ui_file
*stb
;
1276 if (skip_unavailable
&& !value_entirely_available (val
))
1279 tuple_cleanup
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1280 ui_out_field_int (uiout
, "number", regnum
);
1288 stb
= mem_fileopen ();
1289 make_cleanup_ui_file_delete (stb
);
1291 get_formatted_print_options (&opts
, format
);
1293 val_print (value_type (val
),
1294 value_contents_for_printing (val
),
1295 value_embedded_offset (val
), 0,
1296 stb
, 0, val
, &opts
, current_language
);
1297 ui_out_field_stream (uiout
, "value", stb
);
1299 do_cleanups (tuple_cleanup
);
1302 /* Write given values into registers. The registers and values are
1303 given as pairs. The corresponding MI command is
1304 -data-write-register-values <format>
1305 [<regnum1> <value1>...<regnumN> <valueN>] */
1307 mi_cmd_data_write_register_values (char *command
, char **argv
, int argc
)
1309 struct regcache
*regcache
;
1310 struct gdbarch
*gdbarch
;
1313 /* Note that the test for a valid register must include checking the
1314 gdbarch_register_name because gdbarch_num_regs may be allocated
1315 for the union of the register sets within a family of related
1316 processors. In this case, some entries of gdbarch_register_name
1317 will change depending upon the particular processor being
1320 regcache
= get_current_regcache ();
1321 gdbarch
= get_regcache_arch (regcache
);
1322 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1325 error (_("-data-write-register-values: Usage: -data-write-register-"
1326 "values <format> [<regnum1> <value1>...<regnumN> <valueN>]"));
1328 if (!target_has_registers
)
1329 error (_("-data-write-register-values: No registers."));
1332 error (_("-data-write-register-values: No regs and values specified."));
1335 error (_("-data-write-register-values: "
1336 "Regs and vals are not in pairs."));
1338 for (i
= 1; i
< argc
; i
= i
+ 2)
1340 int regnum
= atoi (argv
[i
]);
1342 if (regnum
>= 0 && regnum
< numregs
1343 && gdbarch_register_name (gdbarch
, regnum
)
1344 && *gdbarch_register_name (gdbarch
, regnum
))
1348 /* Get the value as a number. */
1349 value
= parse_and_eval_address (argv
[i
+ 1]);
1351 /* Write it down. */
1352 regcache_cooked_write_signed (regcache
, regnum
, value
);
1355 error (_("bad register number"));
1359 /* Evaluate the value of the argument. The argument is an
1360 expression. If the expression contains spaces it needs to be
1361 included in double quotes. */
1364 mi_cmd_data_evaluate_expression (char *command
, char **argv
, int argc
)
1366 struct expression
*expr
;
1367 struct cleanup
*old_chain
;
1369 struct ui_file
*stb
;
1370 struct value_print_options opts
;
1371 struct ui_out
*uiout
= current_uiout
;
1373 stb
= mem_fileopen ();
1374 old_chain
= make_cleanup_ui_file_delete (stb
);
1377 error (_("-data-evaluate-expression: "
1378 "Usage: -data-evaluate-expression expression"));
1380 expr
= parse_expression (argv
[0]);
1382 make_cleanup (free_current_contents
, &expr
);
1384 val
= evaluate_expression (expr
);
1386 /* Print the result of the expression evaluation. */
1387 get_user_print_options (&opts
);
1389 common_val_print (val
, stb
, 0, &opts
, current_language
);
1391 ui_out_field_stream (uiout
, "value", stb
);
1393 do_cleanups (old_chain
);
1396 /* This is the -data-read-memory command.
1398 ADDR: start address of data to be dumped.
1399 WORD-FORMAT: a char indicating format for the ``word''. See
1401 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes.
1402 NR_ROW: Number of rows.
1403 NR_COL: The number of colums (words per row).
1404 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
1405 ASCHAR for unprintable characters.
1407 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
1408 displayes them. Returns:
1410 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
1413 The number of bytes read is SIZE*ROW*COL. */
1416 mi_cmd_data_read_memory (char *command
, char **argv
, int argc
)
1418 struct gdbarch
*gdbarch
= get_current_arch ();
1419 struct ui_out
*uiout
= current_uiout
;
1420 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
1422 long total_bytes
, nr_cols
, nr_rows
;
1424 struct type
*word_type
;
1437 static const struct mi_opt opts
[] =
1439 {"o", OFFSET_OPT
, 1},
1445 int opt
= mi_getopt ("-data-read-memory", argc
, argv
, opts
,
1450 switch ((enum opt
) opt
)
1453 offset
= atol (oarg
);
1460 if (argc
< 5 || argc
> 6)
1461 error (_("-data-read-memory: Usage: "
1462 "ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR]."));
1464 /* Extract all the arguments. */
1466 /* Start address of the memory dump. */
1467 addr
= parse_and_eval_address (argv
[0]) + offset
;
1468 /* The format character to use when displaying a memory word. See
1469 the ``x'' command. */
1470 word_format
= argv
[1][0];
1471 /* The size of the memory word. */
1472 word_size
= atol (argv
[2]);
1476 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1480 word_type
= builtin_type (gdbarch
)->builtin_int16
;
1484 word_type
= builtin_type (gdbarch
)->builtin_int32
;
1488 word_type
= builtin_type (gdbarch
)->builtin_int64
;
1492 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1495 /* The number of rows. */
1496 nr_rows
= atol (argv
[3]);
1498 error (_("-data-read-memory: invalid number of rows."));
1500 /* Number of bytes per row. */
1501 nr_cols
= atol (argv
[4]);
1503 error (_("-data-read-memory: invalid number of columns."));
1505 /* The un-printable character when printing ascii. */
1511 /* Create a buffer and read it in. */
1512 total_bytes
= word_size
* nr_rows
* nr_cols
;
1513 mbuf
= XCNEWVEC (gdb_byte
, total_bytes
);
1514 make_cleanup (xfree
, mbuf
);
1516 /* Dispatch memory reads to the topmost target, not the flattened
1518 nr_bytes
= target_read (current_target
.beneath
,
1519 TARGET_OBJECT_MEMORY
, NULL
, mbuf
,
1522 error (_("Unable to read memory."));
1524 /* Output the header information. */
1525 ui_out_field_core_addr (uiout
, "addr", gdbarch
, addr
);
1526 ui_out_field_int (uiout
, "nr-bytes", nr_bytes
);
1527 ui_out_field_int (uiout
, "total-bytes", total_bytes
);
1528 ui_out_field_core_addr (uiout
, "next-row",
1529 gdbarch
, addr
+ word_size
* nr_cols
);
1530 ui_out_field_core_addr (uiout
, "prev-row",
1531 gdbarch
, addr
- word_size
* nr_cols
);
1532 ui_out_field_core_addr (uiout
, "next-page", gdbarch
, addr
+ total_bytes
);
1533 ui_out_field_core_addr (uiout
, "prev-page", gdbarch
, addr
- total_bytes
);
1535 /* Build the result as a two dimentional table. */
1537 struct ui_file
*stream
;
1538 struct cleanup
*cleanup_stream
;
1542 stream
= mem_fileopen ();
1543 cleanup_stream
= make_cleanup_ui_file_delete (stream
);
1545 make_cleanup_ui_out_list_begin_end (uiout
, "memory");
1546 for (row
= 0, row_byte
= 0;
1548 row
++, row_byte
+= nr_cols
* word_size
)
1552 struct cleanup
*cleanup_tuple
;
1553 struct cleanup
*cleanup_list_data
;
1554 struct value_print_options opts
;
1556 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1557 ui_out_field_core_addr (uiout
, "addr", gdbarch
, addr
+ row_byte
);
1558 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr +
1560 cleanup_list_data
= make_cleanup_ui_out_list_begin_end (uiout
, "data");
1561 get_formatted_print_options (&opts
, word_format
);
1562 for (col
= 0, col_byte
= row_byte
;
1564 col
++, col_byte
+= word_size
)
1566 if (col_byte
+ word_size
> nr_bytes
)
1568 ui_out_field_string (uiout
, NULL
, "N/A");
1572 ui_file_rewind (stream
);
1573 print_scalar_formatted (mbuf
+ col_byte
, word_type
, &opts
,
1574 word_asize
, stream
);
1575 ui_out_field_stream (uiout
, NULL
, stream
);
1578 do_cleanups (cleanup_list_data
);
1583 ui_file_rewind (stream
);
1584 for (byte
= row_byte
;
1585 byte
< row_byte
+ word_size
* nr_cols
; byte
++)
1587 if (byte
>= nr_bytes
)
1588 fputc_unfiltered ('X', stream
);
1589 else if (mbuf
[byte
] < 32 || mbuf
[byte
] > 126)
1590 fputc_unfiltered (aschar
, stream
);
1592 fputc_unfiltered (mbuf
[byte
], stream
);
1594 ui_out_field_stream (uiout
, "ascii", stream
);
1596 do_cleanups (cleanup_tuple
);
1598 do_cleanups (cleanup_stream
);
1600 do_cleanups (cleanups
);
1604 mi_cmd_data_read_memory_bytes (char *command
, char **argv
, int argc
)
1606 struct gdbarch
*gdbarch
= get_current_arch ();
1607 struct ui_out
*uiout
= current_uiout
;
1608 struct cleanup
*cleanups
;
1611 memory_read_result_s
*read_result
;
1613 VEC(memory_read_result_s
) *result
;
1615 int unit_size
= gdbarch_addressable_memory_unit_size (gdbarch
);
1622 static const struct mi_opt opts
[] =
1624 {"o", OFFSET_OPT
, 1},
1630 int opt
= mi_getopt ("-data-read-memory-bytes", argc
, argv
, opts
,
1634 switch ((enum opt
) opt
)
1637 offset
= atol (oarg
);
1645 error (_("Usage: [ -o OFFSET ] ADDR LENGTH."));
1647 addr
= parse_and_eval_address (argv
[0]) + offset
;
1648 length
= atol (argv
[1]);
1650 result
= read_memory_robust (current_target
.beneath
, addr
, length
);
1652 cleanups
= make_cleanup (free_memory_read_result_vector
, &result
);
1654 if (VEC_length (memory_read_result_s
, result
) == 0)
1655 error (_("Unable to read memory."));
1657 make_cleanup_ui_out_list_begin_end (uiout
, "memory");
1659 VEC_iterate (memory_read_result_s
, result
, ix
, read_result
);
1662 struct cleanup
*t
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1667 ui_out_field_core_addr (uiout
, "begin", gdbarch
, read_result
->begin
);
1668 ui_out_field_core_addr (uiout
, "offset", gdbarch
, read_result
->begin
1670 ui_out_field_core_addr (uiout
, "end", gdbarch
, read_result
->end
);
1672 alloc_len
= (read_result
->end
- read_result
->begin
) * 2 * unit_size
+ 1;
1673 data
= (char *) xmalloc (alloc_len
);
1675 for (i
= 0, p
= data
;
1676 i
< ((read_result
->end
- read_result
->begin
) * unit_size
);
1679 sprintf (p
, "%02x", read_result
->data
[i
]);
1681 ui_out_field_string (uiout
, "contents", data
);
1685 do_cleanups (cleanups
);
1688 /* Implementation of the -data-write_memory command.
1690 COLUMN_OFFSET: optional argument. Must be preceded by '-o'. The
1691 offset from the beginning of the memory grid row where the cell to
1693 ADDR: start address of the row in the memory grid where the memory
1694 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
1695 the location to write to.
1696 FORMAT: a char indicating format for the ``word''. See
1698 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
1699 VALUE: value to be written into the memory address.
1701 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
1706 mi_cmd_data_write_memory (char *command
, char **argv
, int argc
)
1708 struct gdbarch
*gdbarch
= get_current_arch ();
1709 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1712 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
1713 enough when using a compiler other than GCC. */
1716 struct cleanup
*old_chain
;
1724 static const struct mi_opt opts
[] =
1726 {"o", OFFSET_OPT
, 1},
1732 int opt
= mi_getopt ("-data-write-memory", argc
, argv
, opts
,
1737 switch ((enum opt
) opt
)
1740 offset
= atol (oarg
);
1748 error (_("-data-write-memory: Usage: "
1749 "[-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE."));
1751 /* Extract all the arguments. */
1752 /* Start address of the memory dump. */
1753 addr
= parse_and_eval_address (argv
[0]);
1754 /* The size of the memory word. */
1755 word_size
= atol (argv
[2]);
1757 /* Calculate the real address of the write destination. */
1758 addr
+= (offset
* word_size
);
1760 /* Get the value as a number. */
1761 value
= parse_and_eval_address (argv
[3]);
1762 /* Get the value into an array. */
1763 buffer
= (gdb_byte
*) xmalloc (word_size
);
1764 old_chain
= make_cleanup (xfree
, buffer
);
1765 store_signed_integer (buffer
, word_size
, byte_order
, value
);
1766 /* Write it down to memory. */
1767 write_memory_with_notification (addr
, buffer
, word_size
);
1768 /* Free the buffer. */
1769 do_cleanups (old_chain
);
1772 /* Implementation of the -data-write-memory-bytes command.
1775 DATA: string of bytes to write at that address
1776 COUNT: number of bytes to be filled (decimal integer). */
1779 mi_cmd_data_write_memory_bytes (char *command
, char **argv
, int argc
)
1785 size_t len_hex
, len_bytes
, len_units
, i
, steps
, remaining_units
;
1786 long int count_units
;
1787 struct cleanup
*back_to
;
1790 if (argc
!= 2 && argc
!= 3)
1791 error (_("Usage: ADDR DATA [COUNT]."));
1793 addr
= parse_and_eval_address (argv
[0]);
1795 len_hex
= strlen (cdata
);
1796 unit_size
= gdbarch_addressable_memory_unit_size (get_current_arch ());
1798 if (len_hex
% (unit_size
* 2) != 0)
1799 error (_("Hex-encoded '%s' must represent an integral number of "
1800 "addressable memory units."),
1803 len_bytes
= len_hex
/ 2;
1804 len_units
= len_bytes
/ unit_size
;
1807 count_units
= strtoul (argv
[2], NULL
, 10);
1809 count_units
= len_units
;
1811 databuf
= XNEWVEC (gdb_byte
, len_bytes
);
1812 back_to
= make_cleanup (xfree
, databuf
);
1814 for (i
= 0; i
< len_bytes
; ++i
)
1817 if (sscanf (cdata
+ i
* 2, "%02x", &x
) != 1)
1818 error (_("Invalid argument"));
1819 databuf
[i
] = (gdb_byte
) x
;
1822 if (len_units
< count_units
)
1824 /* Pattern is made of less units than count:
1825 repeat pattern to fill memory. */
1826 data
= (gdb_byte
*) xmalloc (count_units
* unit_size
);
1827 make_cleanup (xfree
, data
);
1829 /* Number of times the pattern is entirely repeated. */
1830 steps
= count_units
/ len_units
;
1831 /* Number of remaining addressable memory units. */
1832 remaining_units
= count_units
% len_units
;
1833 for (i
= 0; i
< steps
; i
++)
1834 memcpy (data
+ i
* len_bytes
, databuf
, len_bytes
);
1836 if (remaining_units
> 0)
1837 memcpy (data
+ steps
* len_bytes
, databuf
,
1838 remaining_units
* unit_size
);
1842 /* Pattern is longer than or equal to count:
1843 just copy count addressable memory units. */
1847 write_memory_with_notification (addr
, data
, count_units
);
1849 do_cleanups (back_to
);
1853 mi_cmd_enable_timings (char *command
, char **argv
, int argc
)
1859 if (strcmp (argv
[0], "yes") == 0)
1861 else if (strcmp (argv
[0], "no") == 0)
1872 error (_("-enable-timings: Usage: %s {yes|no}"), command
);
1876 mi_cmd_list_features (char *command
, char **argv
, int argc
)
1880 struct cleanup
*cleanup
= NULL
;
1881 struct ui_out
*uiout
= current_uiout
;
1883 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "features");
1884 ui_out_field_string (uiout
, NULL
, "frozen-varobjs");
1885 ui_out_field_string (uiout
, NULL
, "pending-breakpoints");
1886 ui_out_field_string (uiout
, NULL
, "thread-info");
1887 ui_out_field_string (uiout
, NULL
, "data-read-memory-bytes");
1888 ui_out_field_string (uiout
, NULL
, "breakpoint-notifications");
1889 ui_out_field_string (uiout
, NULL
, "ada-task-info");
1890 ui_out_field_string (uiout
, NULL
, "language-option");
1891 ui_out_field_string (uiout
, NULL
, "info-gdb-mi-command");
1892 ui_out_field_string (uiout
, NULL
, "undefined-command-error-code");
1893 ui_out_field_string (uiout
, NULL
, "exec-run-start-option");
1895 if (ext_lang_initialized_p (get_ext_lang_defn (EXT_LANG_PYTHON
)))
1896 ui_out_field_string (uiout
, NULL
, "python");
1898 do_cleanups (cleanup
);
1902 error (_("-list-features should be passed no arguments"));
1906 mi_cmd_list_target_features (char *command
, char **argv
, int argc
)
1910 struct cleanup
*cleanup
= NULL
;
1911 struct ui_out
*uiout
= current_uiout
;
1913 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "features");
1915 ui_out_field_string (uiout
, NULL
, "async");
1916 if (target_can_execute_reverse
)
1917 ui_out_field_string (uiout
, NULL
, "reverse");
1918 do_cleanups (cleanup
);
1922 error (_("-list-target-features should be passed no arguments"));
1926 mi_cmd_add_inferior (char *command
, char **argv
, int argc
)
1928 struct inferior
*inf
;
1931 error (_("-add-inferior should be passed no arguments"));
1933 inf
= add_inferior_with_spaces ();
1935 ui_out_field_fmt (current_uiout
, "inferior", "i%d", inf
->num
);
1938 /* Callback used to find the first inferior other than the current
1942 get_other_inferior (struct inferior
*inf
, void *arg
)
1944 if (inf
== current_inferior ())
1951 mi_cmd_remove_inferior (char *command
, char **argv
, int argc
)
1954 struct inferior
*inf
;
1957 error (_("-remove-inferior should be passed a single argument"));
1959 if (sscanf (argv
[0], "i%d", &id
) != 1)
1960 error (_("the thread group id is syntactically invalid"));
1962 inf
= find_inferior_id (id
);
1964 error (_("the specified thread group does not exist"));
1967 error (_("cannot remove an active inferior"));
1969 if (inf
== current_inferior ())
1971 struct thread_info
*tp
= 0;
1972 struct inferior
*new_inferior
1973 = iterate_over_inferiors (get_other_inferior
, NULL
);
1975 if (new_inferior
== NULL
)
1976 error (_("Cannot remove last inferior"));
1978 set_current_inferior (new_inferior
);
1979 if (new_inferior
->pid
!= 0)
1980 tp
= any_thread_of_process (new_inferior
->pid
);
1981 switch_to_thread (tp
? tp
->ptid
: null_ptid
);
1982 set_current_program_space (new_inferior
->pspace
);
1985 delete_inferior (inf
);
1990 /* Execute a command within a safe environment.
1991 Return <0 for error; >=0 for ok.
1993 args->action will tell mi_execute_command what action
1994 to perfrom after the given command has executed (display/suppress
1995 prompt, display error). */
1998 captured_mi_execute_command (struct ui_out
*uiout
, struct mi_parse
*context
)
2000 struct mi_interp
*mi
= (struct mi_interp
*) interp_data (command_interp ());
2001 struct cleanup
*cleanup
;
2004 current_command_ts
= context
->cmd_start
;
2006 current_token
= xstrdup (context
->token
);
2007 cleanup
= make_cleanup (free_current_contents
, ¤t_token
);
2009 running_result_record_printed
= 0;
2011 switch (context
->op
)
2014 /* A MI command was read from the input stream. */
2016 /* FIXME: gdb_???? */
2017 fprintf_unfiltered (mi
->raw_stdout
,
2018 " token=`%s' command=`%s' args=`%s'\n",
2019 context
->token
, context
->command
, context
->args
);
2021 mi_cmd_execute (context
);
2023 /* Print the result if there were no errors.
2025 Remember that on the way out of executing a command, you have
2026 to directly use the mi_interp's uiout, since the command
2027 could have reset the interpreter, in which case the current
2028 uiout will most likely crash in the mi_out_* routines. */
2029 if (!running_result_record_printed
)
2031 fputs_unfiltered (context
->token
, mi
->raw_stdout
);
2032 /* There's no particularly good reason why target-connect results
2033 in not ^done. Should kill ^connected for MI3. */
2034 fputs_unfiltered (strcmp (context
->command
, "target-select") == 0
2035 ? "^connected" : "^done", mi
->raw_stdout
);
2036 mi_out_put (uiout
, mi
->raw_stdout
);
2037 mi_out_rewind (uiout
);
2038 mi_print_timing_maybe (mi
->raw_stdout
);
2039 fputs_unfiltered ("\n", mi
->raw_stdout
);
2042 /* The command does not want anything to be printed. In that
2043 case, the command probably should not have written anything
2044 to uiout, but in case it has written something, discard it. */
2045 mi_out_rewind (uiout
);
2052 /* A CLI command was read from the input stream. */
2053 /* This "feature" will be removed as soon as we have a
2054 complete set of mi commands. */
2055 /* Echo the command on the console. */
2056 fprintf_unfiltered (gdb_stdlog
, "%s\n", context
->command
);
2057 /* Call the "console" interpreter. */
2058 argv
[0] = INTERP_CONSOLE
;
2059 argv
[1] = context
->command
;
2060 mi_cmd_interpreter_exec ("-interpreter-exec", argv
, 2);
2062 /* If we changed interpreters, DON'T print out anything. */
2063 if (current_interp_named_p (INTERP_MI
)
2064 || current_interp_named_p (INTERP_MI1
)
2065 || current_interp_named_p (INTERP_MI2
)
2066 || current_interp_named_p (INTERP_MI3
))
2068 if (!running_result_record_printed
)
2070 fputs_unfiltered (context
->token
, mi
->raw_stdout
);
2071 fputs_unfiltered ("^done", mi
->raw_stdout
);
2072 mi_out_put (uiout
, mi
->raw_stdout
);
2073 mi_out_rewind (uiout
);
2074 mi_print_timing_maybe (mi
->raw_stdout
);
2075 fputs_unfiltered ("\n", mi
->raw_stdout
);
2078 mi_out_rewind (uiout
);
2084 do_cleanups (cleanup
);
2087 /* Print a gdb exception to the MI output stream. */
2090 mi_print_exception (const char *token
, struct gdb_exception exception
)
2092 struct mi_interp
*mi
2093 = (struct mi_interp
*) interp_data (current_interpreter ());
2095 fputs_unfiltered (token
, mi
->raw_stdout
);
2096 fputs_unfiltered ("^error,msg=\"", mi
->raw_stdout
);
2097 if (exception
.message
== NULL
)
2098 fputs_unfiltered ("unknown error", mi
->raw_stdout
);
2100 fputstr_unfiltered (exception
.message
, '"', mi
->raw_stdout
);
2101 fputs_unfiltered ("\"", mi
->raw_stdout
);
2103 switch (exception
.error
)
2105 case UNDEFINED_COMMAND_ERROR
:
2106 fputs_unfiltered (",code=\"undefined-command\"", mi
->raw_stdout
);
2110 fputs_unfiltered ("\n", mi
->raw_stdout
);
2113 /* Determine whether the parsed command already notifies the
2114 user_selected_context_changed observer. */
2117 command_notifies_uscc_observer (struct mi_parse
*command
)
2119 if (command
->op
== CLI_COMMAND
)
2121 /* CLI commands "thread" and "inferior" already send it. */
2122 return (strncmp (command
->command
, "thread ", 7) == 0
2123 || strncmp (command
->command
, "inferior ", 9) == 0);
2125 else /* MI_COMMAND */
2127 if (strcmp (command
->command
, "interpreter-exec") == 0
2128 && command
->argc
> 1)
2130 /* "thread" and "inferior" again, but through -interpreter-exec. */
2131 return (strncmp (command
->argv
[1], "thread ", 7) == 0
2132 || strncmp (command
->argv
[1], "inferior ", 9) == 0);
2136 /* -thread-select already sends it. */
2137 return strcmp (command
->command
, "thread-select") == 0;
2142 mi_execute_command (const char *cmd
, int from_tty
)
2145 struct mi_parse
*command
= NULL
;
2147 /* This is to handle EOF (^D). We just quit gdb. */
2148 /* FIXME: we should call some API function here. */
2150 quit_force (NULL
, from_tty
);
2152 target_log_command (cmd
);
2156 command
= mi_parse (cmd
, &token
);
2158 CATCH (exception
, RETURN_MASK_ALL
)
2160 mi_print_exception (token
, exception
);
2165 if (command
!= NULL
)
2167 ptid_t previous_ptid
= inferior_ptid
;
2168 struct cleanup
*cleanup
= make_cleanup (null_cleanup
, NULL
);
2170 command
->token
= token
;
2172 if (command
->cmd
!= NULL
&& command
->cmd
->suppress_notification
!= NULL
)
2174 make_cleanup_restore_integer (command
->cmd
->suppress_notification
);
2175 *command
->cmd
->suppress_notification
= 1;
2180 command
->cmd_start
= XNEW (struct mi_timestamp
);
2181 timestamp (command
->cmd_start
);
2186 captured_mi_execute_command (current_uiout
, command
);
2188 CATCH (result
, RETURN_MASK_ALL
)
2190 /* Like in start_event_loop, enable input and force display
2191 of the prompt. Otherwise, any command that calls
2192 async_disable_stdin, and then throws, will leave input
2194 async_enable_stdin ();
2195 current_ui
->prompt_state
= PROMPT_NEEDED
;
2197 /* The command execution failed and error() was called
2199 mi_print_exception (command
->token
, result
);
2200 mi_out_rewind (current_uiout
);
2204 bpstat_do_actions ();
2206 if (/* The notifications are only output when the top-level
2207 interpreter (specified on the command line) is MI. */
2208 ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ()))
2209 /* Don't try report anything if there are no threads --
2210 the program is dead. */
2211 && thread_count () != 0
2212 /* If the command already reports the thread change, no need to do it
2214 && !command_notifies_uscc_observer (command
))
2216 struct mi_interp
*mi
2217 = (struct mi_interp
*) top_level_interpreter_data ();
2218 int report_change
= 0;
2220 if (command
->thread
== -1)
2222 report_change
= (!ptid_equal (previous_ptid
, null_ptid
)
2223 && !ptid_equal (inferior_ptid
, previous_ptid
)
2224 && !ptid_equal (inferior_ptid
, null_ptid
));
2226 else if (!ptid_equal (inferior_ptid
, null_ptid
))
2228 struct thread_info
*ti
= inferior_thread ();
2230 report_change
= (ti
->global_num
!= command
->thread
);
2235 observer_notify_user_selected_context_changed
2236 (USER_SELECTED_THREAD
| USER_SELECTED_FRAME
);
2240 mi_parse_free (command
);
2242 do_cleanups (cleanup
);
2247 mi_cmd_execute (struct mi_parse
*parse
)
2249 struct cleanup
*cleanup
;
2251 cleanup
= prepare_execute_command ();
2253 if (parse
->all
&& parse
->thread_group
!= -1)
2254 error (_("Cannot specify --thread-group together with --all"));
2256 if (parse
->all
&& parse
->thread
!= -1)
2257 error (_("Cannot specify --thread together with --all"));
2259 if (parse
->thread_group
!= -1 && parse
->thread
!= -1)
2260 error (_("Cannot specify --thread together with --thread-group"));
2262 if (parse
->frame
!= -1 && parse
->thread
== -1)
2263 error (_("Cannot specify --frame without --thread"));
2265 if (parse
->thread_group
!= -1)
2267 struct inferior
*inf
= find_inferior_id (parse
->thread_group
);
2268 struct thread_info
*tp
= 0;
2271 error (_("Invalid thread group for the --thread-group option"));
2273 set_current_inferior (inf
);
2274 /* This behaviour means that if --thread-group option identifies
2275 an inferior with multiple threads, then a random one will be
2276 picked. This is not a problem -- frontend should always
2277 provide --thread if it wishes to operate on a specific
2280 tp
= any_live_thread_of_process (inf
->pid
);
2281 switch_to_thread (tp
? tp
->ptid
: null_ptid
);
2282 set_current_program_space (inf
->pspace
);
2285 if (parse
->thread
!= -1)
2287 struct thread_info
*tp
= find_thread_global_id (parse
->thread
);
2290 error (_("Invalid thread id: %d"), parse
->thread
);
2292 if (is_exited (tp
->ptid
))
2293 error (_("Thread id: %d has terminated"), parse
->thread
);
2295 switch_to_thread (tp
->ptid
);
2298 if (parse
->frame
!= -1)
2300 struct frame_info
*fid
;
2301 int frame
= parse
->frame
;
2303 fid
= find_relative_frame (get_current_frame (), &frame
);
2305 /* find_relative_frame was successful */
2308 error (_("Invalid frame id: %d"), frame
);
2311 if (parse
->language
!= language_unknown
)
2313 make_cleanup_restore_current_language ();
2314 set_language (parse
->language
);
2317 current_context
= parse
;
2319 if (parse
->cmd
->argv_func
!= NULL
)
2321 parse
->cmd
->argv_func (parse
->command
, parse
->argv
, parse
->argc
);
2323 else if (parse
->cmd
->cli
.cmd
!= 0)
2325 /* FIXME: DELETE THIS. */
2326 /* The operation is still implemented by a cli command. */
2327 /* Must be a synchronous one. */
2328 mi_execute_cli_command (parse
->cmd
->cli
.cmd
, parse
->cmd
->cli
.args_p
,
2333 /* FIXME: DELETE THIS. */
2334 struct ui_file
*stb
;
2336 stb
= mem_fileopen ();
2338 fputs_unfiltered ("Undefined mi command: ", stb
);
2339 fputstr_unfiltered (parse
->command
, '"', stb
);
2340 fputs_unfiltered (" (missing implementation)", stb
);
2342 make_cleanup_ui_file_delete (stb
);
2345 do_cleanups (cleanup
);
2348 /* FIXME: This is just a hack so we can get some extra commands going.
2349 We don't want to channel things through the CLI, but call libgdb directly.
2350 Use only for synchronous commands. */
2353 mi_execute_cli_command (const char *cmd
, int args_p
, const char *args
)
2357 struct cleanup
*old_cleanups
;
2361 run
= xstrprintf ("%s %s", cmd
, args
);
2363 run
= xstrdup (cmd
);
2365 /* FIXME: gdb_???? */
2366 fprintf_unfiltered (gdb_stdout
, "cli=%s run=%s\n",
2368 old_cleanups
= make_cleanup (xfree
, run
);
2369 execute_command (run
, 0 /* from_tty */ );
2370 do_cleanups (old_cleanups
);
2376 mi_execute_async_cli_command (char *cli_command
, char **argv
, int argc
)
2378 struct cleanup
*old_cleanups
;
2382 run
= xstrprintf ("%s %s&", cli_command
, argc
? *argv
: "");
2384 run
= xstrprintf ("%s %s", cli_command
, argc
? *argv
: "");
2385 old_cleanups
= make_cleanup (xfree
, run
);
2387 execute_command (run
, 0 /* from_tty */ );
2389 /* Do this before doing any printing. It would appear that some
2390 print code leaves garbage around in the buffer. */
2391 do_cleanups (old_cleanups
);
2395 mi_load_progress (const char *section_name
,
2396 unsigned long sent_so_far
,
2397 unsigned long total_section
,
2398 unsigned long total_sent
,
2399 unsigned long grand_total
)
2401 struct timeval time_now
, delta
, update_threshold
;
2402 static struct timeval last_update
;
2403 static char *previous_sect_name
= NULL
;
2405 struct ui_out
*saved_uiout
;
2406 struct ui_out
*uiout
;
2407 struct mi_interp
*mi
2408 = (struct mi_interp
*) interp_data (current_interpreter ());
2410 /* This function is called through deprecated_show_load_progress
2411 which means uiout may not be correct. Fix it for the duration
2412 of this function. */
2413 saved_uiout
= current_uiout
;
2415 if (current_interp_named_p (INTERP_MI
)
2416 || current_interp_named_p (INTERP_MI2
))
2417 current_uiout
= mi_out_new (2);
2418 else if (current_interp_named_p (INTERP_MI1
))
2419 current_uiout
= mi_out_new (1);
2420 else if (current_interp_named_p (INTERP_MI3
))
2421 current_uiout
= mi_out_new (3);
2425 uiout
= current_uiout
;
2427 update_threshold
.tv_sec
= 0;
2428 update_threshold
.tv_usec
= 500000;
2429 gettimeofday (&time_now
, NULL
);
2431 delta
.tv_usec
= time_now
.tv_usec
- last_update
.tv_usec
;
2432 delta
.tv_sec
= time_now
.tv_sec
- last_update
.tv_sec
;
2434 if (delta
.tv_usec
< 0)
2437 delta
.tv_usec
+= 1000000L;
2440 new_section
= (previous_sect_name
?
2441 strcmp (previous_sect_name
, section_name
) : 1);
2444 struct cleanup
*cleanup_tuple
;
2446 xfree (previous_sect_name
);
2447 previous_sect_name
= xstrdup (section_name
);
2450 fputs_unfiltered (current_token
, mi
->raw_stdout
);
2451 fputs_unfiltered ("+download", mi
->raw_stdout
);
2452 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2453 ui_out_field_string (uiout
, "section", section_name
);
2454 ui_out_field_int (uiout
, "section-size", total_section
);
2455 ui_out_field_int (uiout
, "total-size", grand_total
);
2456 do_cleanups (cleanup_tuple
);
2457 mi_out_put (uiout
, mi
->raw_stdout
);
2458 fputs_unfiltered ("\n", mi
->raw_stdout
);
2459 gdb_flush (mi
->raw_stdout
);
2462 if (delta
.tv_sec
>= update_threshold
.tv_sec
&&
2463 delta
.tv_usec
>= update_threshold
.tv_usec
)
2465 struct cleanup
*cleanup_tuple
;
2467 last_update
.tv_sec
= time_now
.tv_sec
;
2468 last_update
.tv_usec
= time_now
.tv_usec
;
2470 fputs_unfiltered (current_token
, mi
->raw_stdout
);
2471 fputs_unfiltered ("+download", mi
->raw_stdout
);
2472 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2473 ui_out_field_string (uiout
, "section", section_name
);
2474 ui_out_field_int (uiout
, "section-sent", sent_so_far
);
2475 ui_out_field_int (uiout
, "section-size", total_section
);
2476 ui_out_field_int (uiout
, "total-sent", total_sent
);
2477 ui_out_field_int (uiout
, "total-size", grand_total
);
2478 do_cleanups (cleanup_tuple
);
2479 mi_out_put (uiout
, mi
->raw_stdout
);
2480 fputs_unfiltered ("\n", mi
->raw_stdout
);
2481 gdb_flush (mi
->raw_stdout
);
2485 current_uiout
= saved_uiout
;
2489 timestamp (struct mi_timestamp
*tv
)
2491 gettimeofday (&tv
->wallclock
, NULL
);
2492 #ifdef HAVE_GETRUSAGE
2493 getrusage (RUSAGE_SELF
, &rusage
);
2494 tv
->utime
.tv_sec
= rusage
.ru_utime
.tv_sec
;
2495 tv
->utime
.tv_usec
= rusage
.ru_utime
.tv_usec
;
2496 tv
->stime
.tv_sec
= rusage
.ru_stime
.tv_sec
;
2497 tv
->stime
.tv_usec
= rusage
.ru_stime
.tv_usec
;
2500 long usec
= get_run_time ();
2502 tv
->utime
.tv_sec
= usec
/1000000L;
2503 tv
->utime
.tv_usec
= usec
- 1000000L*tv
->utime
.tv_sec
;
2504 tv
->stime
.tv_sec
= 0;
2505 tv
->stime
.tv_usec
= 0;
2511 print_diff_now (struct ui_file
*file
, struct mi_timestamp
*start
)
2513 struct mi_timestamp now
;
2516 print_diff (file
, start
, &now
);
2520 mi_print_timing_maybe (struct ui_file
*file
)
2522 /* If the command is -enable-timing then do_timings may be true
2523 whilst current_command_ts is not initialized. */
2524 if (do_timings
&& current_command_ts
)
2525 print_diff_now (file
, current_command_ts
);
2529 timeval_diff (struct timeval start
, struct timeval end
)
2531 return ((end
.tv_sec
- start
.tv_sec
) * 1000000L)
2532 + (end
.tv_usec
- start
.tv_usec
);
2536 print_diff (struct ui_file
*file
, struct mi_timestamp
*start
,
2537 struct mi_timestamp
*end
)
2541 ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
2542 timeval_diff (start
->wallclock
, end
->wallclock
) / 1000000.0,
2543 timeval_diff (start
->utime
, end
->utime
) / 1000000.0,
2544 timeval_diff (start
->stime
, end
->stime
) / 1000000.0);
2548 mi_cmd_trace_define_variable (char *command
, char **argv
, int argc
)
2550 LONGEST initval
= 0;
2551 struct trace_state_variable
*tsv
;
2554 if (argc
!= 1 && argc
!= 2)
2555 error (_("Usage: -trace-define-variable VARIABLE [VALUE]"));
2559 error (_("Name of trace variable should start with '$'"));
2561 validate_trace_state_variable_name (name
);
2563 tsv
= find_trace_state_variable (name
);
2565 tsv
= create_trace_state_variable (name
);
2568 initval
= value_as_long (parse_and_eval (argv
[1]));
2570 tsv
->initial_value
= initval
;
2574 mi_cmd_trace_list_variables (char *command
, char **argv
, int argc
)
2577 error (_("-trace-list-variables: no arguments allowed"));
2579 tvariables_info_1 ();
2583 mi_cmd_trace_find (char *command
, char **argv
, int argc
)
2588 error (_("trace selection mode is required"));
2592 if (strcmp (mode
, "none") == 0)
2594 tfind_1 (tfind_number
, -1, 0, 0, 0);
2598 check_trace_running (current_trace_status ());
2600 if (strcmp (mode
, "frame-number") == 0)
2603 error (_("frame number is required"));
2604 tfind_1 (tfind_number
, atoi (argv
[1]), 0, 0, 0);
2606 else if (strcmp (mode
, "tracepoint-number") == 0)
2609 error (_("tracepoint number is required"));
2610 tfind_1 (tfind_tp
, atoi (argv
[1]), 0, 0, 0);
2612 else if (strcmp (mode
, "pc") == 0)
2615 error (_("PC is required"));
2616 tfind_1 (tfind_pc
, 0, parse_and_eval_address (argv
[1]), 0, 0);
2618 else if (strcmp (mode
, "pc-inside-range") == 0)
2621 error (_("Start and end PC are required"));
2622 tfind_1 (tfind_range
, 0, parse_and_eval_address (argv
[1]),
2623 parse_and_eval_address (argv
[2]), 0);
2625 else if (strcmp (mode
, "pc-outside-range") == 0)
2628 error (_("Start and end PC are required"));
2629 tfind_1 (tfind_outside
, 0, parse_and_eval_address (argv
[1]),
2630 parse_and_eval_address (argv
[2]), 0);
2632 else if (strcmp (mode
, "line") == 0)
2634 struct symtabs_and_lines sals
;
2635 struct symtab_and_line sal
;
2636 static CORE_ADDR start_pc
, end_pc
;
2637 struct cleanup
*back_to
;
2640 error (_("Line is required"));
2642 sals
= decode_line_with_current_source (argv
[1],
2643 DECODE_LINE_FUNFIRSTLINE
);
2644 back_to
= make_cleanup (xfree
, sals
.sals
);
2648 if (sal
.symtab
== 0)
2649 error (_("Could not find the specified line"));
2651 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2652 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, 0);
2654 error (_("Could not find the specified line"));
2656 do_cleanups (back_to
);
2659 error (_("Invalid mode '%s'"), mode
);
2661 if (has_stack_frames () || get_traceframe_number () >= 0)
2662 print_stack_frame (get_selected_frame (NULL
), 1, LOC_AND_ADDRESS
, 1);
2666 mi_cmd_trace_save (char *command
, char **argv
, int argc
)
2668 int target_saves
= 0;
2669 int generate_ctf
= 0;
2676 TARGET_SAVE_OPT
, CTF_OPT
2678 static const struct mi_opt opts
[] =
2680 {"r", TARGET_SAVE_OPT
, 0},
2681 {"ctf", CTF_OPT
, 0},
2687 int opt
= mi_getopt ("-trace-save", argc
, argv
, opts
,
2692 switch ((enum opt
) opt
)
2694 case TARGET_SAVE_OPT
:
2702 filename
= argv
[oind
];
2705 trace_save_ctf (filename
, target_saves
);
2707 trace_save_tfile (filename
, target_saves
);
2711 mi_cmd_trace_start (char *command
, char **argv
, int argc
)
2713 start_tracing (NULL
);
2717 mi_cmd_trace_status (char *command
, char **argv
, int argc
)
2719 trace_status_mi (0);
2723 mi_cmd_trace_stop (char *command
, char **argv
, int argc
)
2725 stop_tracing (NULL
);
2726 trace_status_mi (1);
2729 /* Implement the "-ada-task-info" command. */
2732 mi_cmd_ada_task_info (char *command
, char **argv
, int argc
)
2734 if (argc
!= 0 && argc
!= 1)
2735 error (_("Invalid MI command"));
2737 print_ada_task_info (current_uiout
, argv
[0], current_inferior ());
2740 /* Print EXPRESSION according to VALUES. */
2743 print_variable_or_computed (char *expression
, enum print_values values
)
2745 struct expression
*expr
;
2746 struct cleanup
*old_chain
;
2748 struct ui_file
*stb
;
2750 struct ui_out
*uiout
= current_uiout
;
2752 stb
= mem_fileopen ();
2753 old_chain
= make_cleanup_ui_file_delete (stb
);
2755 expr
= parse_expression (expression
);
2757 make_cleanup (free_current_contents
, &expr
);
2759 if (values
== PRINT_SIMPLE_VALUES
)
2760 val
= evaluate_type (expr
);
2762 val
= evaluate_expression (expr
);
2764 if (values
!= PRINT_NO_VALUES
)
2765 make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2766 ui_out_field_string (uiout
, "name", expression
);
2770 case PRINT_SIMPLE_VALUES
:
2771 type
= check_typedef (value_type (val
));
2772 type_print (value_type (val
), "", stb
, -1);
2773 ui_out_field_stream (uiout
, "type", stb
);
2774 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
2775 && TYPE_CODE (type
) != TYPE_CODE_STRUCT
2776 && TYPE_CODE (type
) != TYPE_CODE_UNION
)
2778 struct value_print_options opts
;
2780 get_no_prettyformat_print_options (&opts
);
2782 common_val_print (val
, stb
, 0, &opts
, current_language
);
2783 ui_out_field_stream (uiout
, "value", stb
);
2786 case PRINT_ALL_VALUES
:
2788 struct value_print_options opts
;
2790 get_no_prettyformat_print_options (&opts
);
2792 common_val_print (val
, stb
, 0, &opts
, current_language
);
2793 ui_out_field_stream (uiout
, "value", stb
);
2798 do_cleanups (old_chain
);
2801 /* Implement the "-trace-frame-collected" command. */
2804 mi_cmd_trace_frame_collected (char *command
, char **argv
, int argc
)
2806 struct cleanup
*old_chain
;
2807 struct bp_location
*tloc
;
2809 struct collection_list
*clist
;
2810 struct collection_list tracepoint_list
, stepping_list
;
2811 struct traceframe_info
*tinfo
;
2813 enum print_values var_print_values
= PRINT_ALL_VALUES
;
2814 enum print_values comp_print_values
= PRINT_ALL_VALUES
;
2815 int registers_format
= 'x';
2816 int memory_contents
= 0;
2817 struct ui_out
*uiout
= current_uiout
;
2825 static const struct mi_opt opts
[] =
2827 {"-var-print-values", VAR_PRINT_VALUES
, 1},
2828 {"-comp-print-values", COMP_PRINT_VALUES
, 1},
2829 {"-registers-format", REGISTERS_FORMAT
, 1},
2830 {"-memory-contents", MEMORY_CONTENTS
, 0},
2837 int opt
= mi_getopt ("-trace-frame-collected", argc
, argv
, opts
,
2841 switch ((enum opt
) opt
)
2843 case VAR_PRINT_VALUES
:
2844 var_print_values
= mi_parse_print_values (oarg
);
2846 case COMP_PRINT_VALUES
:
2847 comp_print_values
= mi_parse_print_values (oarg
);
2849 case REGISTERS_FORMAT
:
2850 registers_format
= oarg
[0];
2851 case MEMORY_CONTENTS
:
2852 memory_contents
= 1;
2858 error (_("Usage: -trace-frame-collected "
2859 "[--var-print-values PRINT_VALUES] "
2860 "[--comp-print-values PRINT_VALUES] "
2861 "[--registers-format FORMAT]"
2862 "[--memory-contents]"));
2864 /* This throws an error is not inspecting a trace frame. */
2865 tloc
= get_traceframe_location (&stepping_frame
);
2867 /* This command only makes sense for the current frame, not the
2869 old_chain
= make_cleanup_restore_current_thread ();
2870 select_frame (get_current_frame ());
2872 encode_actions_and_make_cleanup (tloc
, &tracepoint_list
,
2876 clist
= &stepping_list
;
2878 clist
= &tracepoint_list
;
2880 tinfo
= get_traceframe_info ();
2882 /* Explicitly wholly collected variables. */
2884 struct cleanup
*list_cleanup
;
2888 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
,
2889 "explicit-variables");
2890 for (i
= 0; VEC_iterate (char_ptr
, clist
->wholly_collected
, i
, p
); i
++)
2891 print_variable_or_computed (p
, var_print_values
);
2892 do_cleanups (list_cleanup
);
2895 /* Computed expressions. */
2897 struct cleanup
*list_cleanup
;
2902 = make_cleanup_ui_out_list_begin_end (uiout
,
2903 "computed-expressions");
2904 for (i
= 0; VEC_iterate (char_ptr
, clist
->computed
, i
, p
); i
++)
2905 print_variable_or_computed (p
, comp_print_values
);
2906 do_cleanups (list_cleanup
);
2909 /* Registers. Given pseudo-registers, and that some architectures
2910 (like MIPS) actually hide the raw registers, we don't go through
2911 the trace frame info, but instead consult the register cache for
2912 register availability. */
2914 struct cleanup
*list_cleanup
;
2915 struct frame_info
*frame
;
2916 struct gdbarch
*gdbarch
;
2920 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "registers");
2922 frame
= get_selected_frame (NULL
);
2923 gdbarch
= get_frame_arch (frame
);
2924 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
2926 for (regnum
= 0; regnum
< numregs
; regnum
++)
2928 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
2929 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
2932 output_register (frame
, regnum
, registers_format
, 1);
2935 do_cleanups (list_cleanup
);
2938 /* Trace state variables. */
2940 struct cleanup
*list_cleanup
;
2945 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "tvars");
2948 make_cleanup (free_current_contents
, &tsvname
);
2950 for (i
= 0; VEC_iterate (int, tinfo
->tvars
, i
, tvar
); i
++)
2952 struct cleanup
*cleanup_child
;
2953 struct trace_state_variable
*tsv
;
2955 tsv
= find_trace_state_variable_by_number (tvar
);
2957 cleanup_child
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2961 tsvname
= (char *) xrealloc (tsvname
, strlen (tsv
->name
) + 2);
2963 strcpy (tsvname
+ 1, tsv
->name
);
2964 ui_out_field_string (uiout
, "name", tsvname
);
2966 tsv
->value_known
= target_get_trace_state_variable_value (tsv
->number
,
2968 ui_out_field_int (uiout
, "current", tsv
->value
);
2972 ui_out_field_skip (uiout
, "name");
2973 ui_out_field_skip (uiout
, "current");
2976 do_cleanups (cleanup_child
);
2979 do_cleanups (list_cleanup
);
2984 struct cleanup
*list_cleanup
;
2985 VEC(mem_range_s
) *available_memory
= NULL
;
2986 struct mem_range
*r
;
2989 traceframe_available_memory (&available_memory
, 0, ULONGEST_MAX
);
2990 make_cleanup (VEC_cleanup(mem_range_s
), &available_memory
);
2992 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "memory");
2994 for (i
= 0; VEC_iterate (mem_range_s
, available_memory
, i
, r
); i
++)
2996 struct cleanup
*cleanup_child
;
2998 struct gdbarch
*gdbarch
= target_gdbarch ();
3000 cleanup_child
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
3002 ui_out_field_core_addr (uiout
, "address", gdbarch
, r
->start
);
3003 ui_out_field_int (uiout
, "length", r
->length
);
3005 data
= (gdb_byte
*) xmalloc (r
->length
);
3006 make_cleanup (xfree
, data
);
3008 if (memory_contents
)
3010 if (target_read_memory (r
->start
, data
, r
->length
) == 0)
3015 data_str
= (char *) xmalloc (r
->length
* 2 + 1);
3016 make_cleanup (xfree
, data_str
);
3018 for (m
= 0, p
= data_str
; m
< r
->length
; ++m
, p
+= 2)
3019 sprintf (p
, "%02x", data
[m
]);
3020 ui_out_field_string (uiout
, "contents", data_str
);
3023 ui_out_field_skip (uiout
, "contents");
3025 do_cleanups (cleanup_child
);
3028 do_cleanups (list_cleanup
);
3031 do_cleanups (old_chain
);
3035 _initialize_mi_main (void)
3037 struct cmd_list_element
*c
;
3039 add_setshow_boolean_cmd ("mi-async", class_run
,
3041 Set whether MI asynchronous mode is enabled."), _("\
3042 Show whether MI asynchronous mode is enabled."), _("\
3043 Tells GDB whether MI should be in asynchronous mode."),
3044 set_mi_async_command
,
3045 show_mi_async_command
,
3049 /* Alias old "target-async" to "mi-async". */
3050 c
= add_alias_cmd ("target-async", "mi-async", class_run
, 0, &setlist
);
3051 deprecate_cmd (c
, "set mi-async");
3052 c
= add_alias_cmd ("target-async", "mi-async", class_run
, 0, &showlist
);
3053 deprecate_cmd (c
, "show mi-async");