3 Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010
4 Free Software Foundation, Inc.
6 Contributed by Cygnus Solutions (a Red Hat company).
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 /* Work in progress. */
26 #include "arch-utils.h"
29 #include "gdb_string.h"
30 #include "exceptions.h"
32 #include "gdbthread.h"
35 #include "mi-getopt.h"
36 #include "mi-console.h"
40 #include "event-loop.h"
41 #include "event-top.h"
42 #include "gdbcore.h" /* For write_memory(). */
48 #include "mi-common.h"
53 #include "splay-tree.h"
54 #include "tracepoint.h"
59 #if defined HAVE_SYS_RESOURCE_H
60 #include <sys/resource.h>
73 struct ui_file
*raw_stdout
;
75 /* This is used to pass the current command timestamp
76 down to continuation routines. */
77 static struct mi_timestamp
*current_command_ts
;
79 static int do_timings
= 0;
82 /* Few commands would like to know if options like --thread-group
83 were explicitly specified. This variable keeps the current
84 parsed command including all option, and make it possible. */
85 static struct mi_parse
*current_context
;
87 int running_result_record_printed
= 1;
89 /* Flag indicating that the target has proceeded since the last
90 command was issued. */
93 extern void _initialize_mi_main (void);
94 static void mi_cmd_execute (struct mi_parse
*parse
);
96 static void mi_execute_cli_command (const char *cmd
, int args_p
,
98 static void mi_execute_async_cli_command (char *cli_command
,
99 char **argv
, int argc
);
100 static int register_changed_p (int regnum
, struct regcache
*,
102 static void get_register (struct frame_info
*, int regnum
, int format
);
104 /* Command implementations. FIXME: Is this libgdb? No. This is the MI
105 layer that calls libgdb. Any operation used in the below should be
108 static void timestamp (struct mi_timestamp
*tv
);
110 static void print_diff_now (struct mi_timestamp
*start
);
111 static void print_diff (struct mi_timestamp
*start
, struct mi_timestamp
*end
);
114 mi_cmd_gdb_exit (char *command
, char **argv
, int argc
)
116 /* We have to print everything right here because we never return. */
118 fputs_unfiltered (current_token
, raw_stdout
);
119 fputs_unfiltered ("^exit\n", raw_stdout
);
120 mi_out_put (uiout
, raw_stdout
);
121 gdb_flush (raw_stdout
);
122 /* FIXME: The function called is not yet a formal libgdb function. */
123 quit_force (NULL
, FROM_TTY
);
127 mi_cmd_exec_next (char *command
, char **argv
, int argc
)
129 /* FIXME: Should call a libgdb function, not a cli wrapper. */
130 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
131 mi_execute_async_cli_command ("reverse-next", argv
+ 1, argc
- 1);
133 mi_execute_async_cli_command ("next", argv
, argc
);
137 mi_cmd_exec_next_instruction (char *command
, char **argv
, int argc
)
139 /* FIXME: Should call a libgdb function, not a cli wrapper. */
140 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
141 mi_execute_async_cli_command ("reverse-nexti", argv
+ 1, argc
- 1);
143 mi_execute_async_cli_command ("nexti", argv
, argc
);
147 mi_cmd_exec_step (char *command
, char **argv
, int argc
)
149 /* FIXME: Should call a libgdb function, not a cli wrapper. */
150 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
151 mi_execute_async_cli_command ("reverse-step", argv
+ 1, argc
- 1);
153 mi_execute_async_cli_command ("step", argv
, argc
);
157 mi_cmd_exec_step_instruction (char *command
, char **argv
, int argc
)
159 /* FIXME: Should call a libgdb function, not a cli wrapper. */
160 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
161 mi_execute_async_cli_command ("reverse-stepi", argv
+ 1, argc
- 1);
163 mi_execute_async_cli_command ("stepi", argv
, argc
);
167 mi_cmd_exec_finish (char *command
, char **argv
, int argc
)
169 /* FIXME: Should call a libgdb function, not a cli wrapper. */
170 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
171 mi_execute_async_cli_command ("reverse-finish", argv
+ 1, argc
- 1);
173 mi_execute_async_cli_command ("finish", argv
, argc
);
177 mi_cmd_exec_return (char *command
, char **argv
, int argc
)
179 /* This command doesn't really execute the target, it just pops the
180 specified number of frames. */
182 /* Call return_command with from_tty argument equal to 0 so as to
183 avoid being queried. */
184 return_command (*argv
, 0);
186 /* Call return_command with from_tty argument equal to 0 so as to
187 avoid being queried. */
188 return_command (NULL
, 0);
190 /* Because we have called return_command with from_tty = 0, we need
191 to print the frame here. */
192 print_stack_frame (get_selected_frame (NULL
), 1, LOC_AND_ADDRESS
);
196 mi_cmd_exec_jump (char *args
, char **argv
, int argc
)
198 /* FIXME: Should call a libgdb function, not a cli wrapper. */
199 mi_execute_async_cli_command ("jump", argv
, argc
);
203 proceed_thread (struct thread_info
*thread
, int pid
)
205 if (!is_stopped (thread
->ptid
))
208 if (pid
!= 0 && PIDGET (thread
->ptid
) != pid
)
211 switch_to_thread (thread
->ptid
);
212 clear_proceed_status ();
213 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 0);
218 proceed_thread_callback (struct thread_info
*thread
, void *arg
)
220 int pid
= *(int *)arg
;
221 proceed_thread (thread
, pid
);
226 exec_continue (char **argv
, int argc
)
230 /* In non-stop mode, 'resume' always resumes a single thread. Therefore,
231 to resume all threads of the current inferior, or all threads in all
232 inferiors, we need to iterate over threads.
234 See comment on infcmd.c:proceed_thread_callback for rationale. */
235 if (current_context
->all
|| current_context
->thread_group
!= -1)
238 struct cleanup
*back_to
= make_cleanup_restore_current_thread ();
240 if (!current_context
->all
)
242 struct inferior
*inf
= find_inferior_id (current_context
->thread_group
);
245 iterate_over_threads (proceed_thread_callback
, &pid
);
246 do_cleanups (back_to
);
255 struct cleanup
*back_to
= make_cleanup_restore_integer (&sched_multi
);
256 if (current_context
->all
)
263 /* In all-stop mode, -exec-continue traditionally resumed either
264 all threads, or one thread, depending on the 'scheduler-locking'
265 variable. Let's continue to do the same. */
268 do_cleanups (back_to
);
273 exec_direction_forward (void *notused
)
275 execution_direction
= EXEC_FORWARD
;
279 exec_reverse_continue (char **argv
, int argc
)
281 enum exec_direction_kind dir
= execution_direction
;
282 struct cleanup
*old_chain
;
284 if (dir
== EXEC_ERROR
)
285 error (_("Target %s does not support this command."), target_shortname
);
287 if (dir
== EXEC_REVERSE
)
288 error (_("Already in reverse mode."));
290 if (!target_can_execute_reverse
)
291 error (_("Target %s does not support this command."), target_shortname
);
293 old_chain
= make_cleanup (exec_direction_forward
, NULL
);
294 execution_direction
= EXEC_REVERSE
;
295 exec_continue (argv
, argc
);
296 do_cleanups (old_chain
);
300 mi_cmd_exec_continue (char *command
, char **argv
, int argc
)
302 if (argc
> 0 && strcmp (argv
[0], "--reverse") == 0)
303 exec_reverse_continue (argv
+ 1, argc
- 1);
305 exec_continue (argv
, argc
);
309 interrupt_thread_callback (struct thread_info
*thread
, void *arg
)
311 int pid
= *(int *)arg
;
313 if (!is_running (thread
->ptid
))
316 if (PIDGET (thread
->ptid
) != pid
)
319 target_stop (thread
->ptid
);
323 /* Interrupt the execution of the target. Note how we must play around
324 with the token variables, in order to display the current token in
325 the result of the interrupt command, and the previous execution
326 token when the target finally stops. See comments in
329 mi_cmd_exec_interrupt (char *command
, char **argv
, int argc
)
331 /* In all-stop mode, everything stops, so we don't need to try
332 anything specific. */
335 interrupt_target_1 (0);
339 if (current_context
->all
)
341 /* This will interrupt all threads in all inferiors. */
342 interrupt_target_1 (1);
344 else if (current_context
->thread_group
!= -1)
346 struct inferior
*inf
= find_inferior_id (current_context
->thread_group
);
347 iterate_over_threads (interrupt_thread_callback
, &inf
->pid
);
351 /* Interrupt just the current thread -- either explicitly
352 specified via --thread or whatever was current before
353 MI command was sent. */
354 interrupt_target_1 (0);
359 run_one_inferior (struct inferior
*inf
, void *arg
)
361 struct thread_info
*tp
= 0;
365 if (inf
->pid
!= ptid_get_pid (inferior_ptid
))
367 struct thread_info
*tp
;
369 tp
= any_thread_of_process (inf
->pid
);
371 error (_("Inferior has no threads."));
373 switch_to_thread (tp
->ptid
);
378 set_current_inferior (inf
);
379 switch_to_thread (null_ptid
);
380 set_current_program_space (inf
->pspace
);
382 mi_execute_cli_command ("run", target_can_async_p (),
383 target_can_async_p () ? "&" : NULL
);
388 mi_cmd_exec_run (char *command
, char **argv
, int argc
)
390 if (current_context
->all
)
392 struct cleanup
*back_to
= save_current_space_and_thread ();
393 iterate_over_inferiors (run_one_inferior
, NULL
);
394 do_cleanups (back_to
);
398 mi_execute_cli_command ("run", target_can_async_p (),
399 target_can_async_p () ? "&" : NULL
);
405 find_thread_of_process (struct thread_info
*ti
, void *p
)
408 if (PIDGET (ti
->ptid
) == pid
&& !is_exited (ti
->ptid
))
415 mi_cmd_target_detach (char *command
, char **argv
, int argc
)
417 if (argc
!= 0 && argc
!= 1)
418 error ("Usage: -target-detach [thread-group]");
422 struct thread_info
*tp
;
424 int pid
= strtol (argv
[0], &end
, 10);
426 error (_("Cannot parse thread group id '%s'"), argv
[0]);
428 /* Pick any thread in the desired process. Current
429 target_detach deteches from the parent of inferior_ptid. */
430 tp
= iterate_over_threads (find_thread_of_process
, &pid
);
432 error (_("Thread group is empty"));
434 switch_to_thread (tp
->ptid
);
437 detach_command (NULL
, 0);
441 mi_cmd_thread_select (char *command
, char **argv
, int argc
)
444 char *mi_error_message
;
447 error ("mi_cmd_thread_select: USAGE: threadnum.");
449 rc
= gdb_thread_select (uiout
, argv
[0], &mi_error_message
);
451 if (rc
== GDB_RC_FAIL
)
453 make_cleanup (xfree
, mi_error_message
);
454 error ("%s", mi_error_message
);
459 mi_cmd_thread_list_ids (char *command
, char **argv
, int argc
)
462 char *mi_error_message
;
465 error ("mi_cmd_thread_list_ids: No arguments required.");
467 rc
= gdb_list_thread_ids (uiout
, &mi_error_message
);
469 if (rc
== GDB_RC_FAIL
)
471 make_cleanup (xfree
, mi_error_message
);
472 error ("%s", mi_error_message
);
477 mi_cmd_thread_info (char *command
, char **argv
, int argc
)
481 if (argc
!= 0 && argc
!= 1)
482 error ("Invalid MI command");
485 thread
= atoi (argv
[0]);
487 print_thread_info (uiout
, thread
, -1);
490 struct collect_cores_data
498 collect_cores (struct thread_info
*ti
, void *xdata
)
500 struct collect_cores_data
*data
= xdata
;
502 if (ptid_get_pid (ti
->ptid
) == data
->pid
)
504 int core
= target_core_of_thread (ti
->ptid
);
506 VEC_safe_push (int, data
->cores
, core
);
513 unique (int *b
, int *e
)
522 struct print_one_inferior_data
525 VEC (int) *inferiors
;
529 print_one_inferior (struct inferior
*inferior
, void *xdata
)
531 struct print_one_inferior_data
*top_data
= xdata
;
533 if (VEC_empty (int, top_data
->inferiors
)
534 || bsearch (&(inferior
->pid
), VEC_address (int, top_data
->inferiors
),
535 VEC_length (int, top_data
->inferiors
), sizeof (int),
536 compare_positive_ints
))
538 struct collect_cores_data data
;
539 struct cleanup
*back_to
540 = make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
542 ui_out_field_fmt (uiout
, "id", "i%d", inferior
->num
);
543 ui_out_field_string (uiout
, "type", "process");
544 if (inferior
->pid
!= 0)
545 ui_out_field_int (uiout
, "pid", inferior
->pid
);
547 if (inferior
->pspace
->ebfd
)
549 ui_out_field_string (uiout
, "executable",
550 bfd_get_filename (inferior
->pspace
->ebfd
));
554 if (inferior
->pid
!= 0)
556 data
.pid
= inferior
->pid
;
557 iterate_over_threads (collect_cores
, &data
);
560 if (!VEC_empty (int, data
.cores
))
565 struct cleanup
*back_to_2
=
566 make_cleanup_ui_out_list_begin_end (uiout
, "cores");
568 qsort (VEC_address (int, data
.cores
),
569 VEC_length (int, data
.cores
), sizeof (int),
570 compare_positive_ints
);
572 b
= VEC_address (int, data
.cores
);
573 e
= b
+ VEC_length (int, data
.cores
);
577 ui_out_field_int (uiout
, NULL
, *b
);
579 do_cleanups (back_to_2
);
582 if (top_data
->recurse
)
583 print_thread_info (uiout
, -1, inferior
->pid
);
585 do_cleanups (back_to
);
591 /* Output a field named 'cores' with a list as the value. The elements of
592 the list are obtained by splitting 'cores' on comma. */
595 output_cores (struct ui_out
*uiout
, const char *field_name
, const char *xcores
)
597 struct cleanup
*back_to
= make_cleanup_ui_out_list_begin_end (uiout
,
599 char *cores
= xstrdup (xcores
);
602 make_cleanup (xfree
, cores
);
604 for (p
= strtok (p
, ","); p
; p
= strtok (NULL
, ","))
605 ui_out_field_string (uiout
, NULL
, p
);
607 do_cleanups (back_to
);
611 free_vector_of_ints (void *xvector
)
613 VEC (int) **vector
= xvector
;
614 VEC_free (int, *vector
);
618 do_nothing (splay_tree_key k
)
623 free_vector_of_osdata_items (splay_tree_value xvalue
)
625 VEC (osdata_item_s
) *value
= (VEC (osdata_item_s
) *) xvalue
;
626 /* We don't free the items itself, it will be done separately. */
627 VEC_free (osdata_item_s
, value
);
631 splay_tree_int_comparator (splay_tree_key xa
, splay_tree_key xb
)
639 free_splay_tree (void *xt
)
642 splay_tree_delete (t
);
646 list_available_thread_groups (VEC (int) *ids
, int recurse
)
649 struct osdata_item
*item
;
651 /* This keeps a map from integer (pid) to VEC (struct osdata_item *)*
652 The vector contains information about all threads for the given pid.
653 This is assigned an initial value to avoid "may be used uninitialized"
655 splay_tree tree
= NULL
;
657 /* get_osdata will throw if it cannot return data. */
658 data
= get_osdata ("processes");
659 make_cleanup_osdata_free (data
);
663 struct osdata
*threads
= get_osdata ("threads");
664 make_cleanup_osdata_free (threads
);
666 tree
= splay_tree_new (splay_tree_int_comparator
,
668 free_vector_of_osdata_items
);
669 make_cleanup (free_splay_tree
, tree
);
672 VEC_iterate (osdata_item_s
, threads
->items
,
676 const char *pid
= get_osdata_column (item
, "pid");
677 int pid_i
= strtoul (pid
, NULL
, 0);
678 VEC (osdata_item_s
) *vec
= 0;
680 splay_tree_node n
= splay_tree_lookup (tree
, pid_i
);
683 VEC_safe_push (osdata_item_s
, vec
, item
);
684 splay_tree_insert (tree
, pid_i
, (splay_tree_value
)vec
);
688 vec
= (VEC (osdata_item_s
) *) n
->value
;
689 VEC_safe_push (osdata_item_s
, vec
, item
);
690 n
->value
= (splay_tree_value
) vec
;
695 make_cleanup_ui_out_list_begin_end (uiout
, "groups");
698 VEC_iterate (osdata_item_s
, data
->items
,
702 struct cleanup
*back_to
;
704 const char *pid
= get_osdata_column (item
, "pid");
705 const char *cmd
= get_osdata_column (item
, "command");
706 const char *user
= get_osdata_column (item
, "user");
707 const char *cores
= get_osdata_column (item
, "cores");
709 int pid_i
= strtoul (pid
, NULL
, 0);
711 /* At present, the target will return all available processes
712 and if information about specific ones was required, we filter
713 undesired processes here. */
714 if (ids
&& bsearch (&pid_i
, VEC_address (int, ids
),
715 VEC_length (int, ids
),
716 sizeof (int), compare_positive_ints
) == NULL
)
720 back_to
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
722 ui_out_field_fmt (uiout
, "id", "%s", pid
);
723 ui_out_field_string (uiout
, "type", "process");
725 ui_out_field_string (uiout
, "description", cmd
);
727 ui_out_field_string (uiout
, "user", user
);
729 output_cores (uiout
, "cores", cores
);
733 splay_tree_node n
= splay_tree_lookup (tree
, pid_i
);
736 VEC (osdata_item_s
) *children
= (VEC (osdata_item_s
) *) n
->value
;
737 struct osdata_item
*child
;
740 make_cleanup_ui_out_list_begin_end (uiout
, "threads");
743 VEC_iterate (osdata_item_s
, children
, ix_child
, child
);
746 struct cleanup
*back_to_2
=
747 make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
749 const char *tid
= get_osdata_column (child
, "tid");
750 const char *tcore
= get_osdata_column (child
, "core");
751 ui_out_field_string (uiout
, "id", tid
);
753 ui_out_field_string (uiout
, "core", tcore
);
755 do_cleanups (back_to_2
);
760 do_cleanups (back_to
);
765 mi_cmd_list_thread_groups (char *command
, char **argv
, int argc
)
767 struct cleanup
*back_to
;
774 AVAILABLE_OPT
, RECURSE_OPT
776 static struct mi_opt opts
[] =
778 {"-available", AVAILABLE_OPT
, 0},
779 {"-recurse", RECURSE_OPT
, 1},
788 int opt
= mi_getopt ("-list-thread-groups", argc
, argv
, opts
,
792 switch ((enum opt
) opt
)
798 if (strcmp (optarg
, "0") == 0)
800 else if (strcmp (optarg
, "1") == 0)
803 error ("only '0' and '1' are valid values for the '--recurse' option");
808 for (; optind
< argc
; ++optind
)
811 int inf
= strtoul (argv
[optind
], &end
, 0);
813 error ("invalid group id '%s'", argv
[optind
]);
814 VEC_safe_push (int, ids
, inf
);
816 if (VEC_length (int, ids
) > 1)
817 qsort (VEC_address (int, ids
),
818 VEC_length (int, ids
),
819 sizeof (int), compare_positive_ints
);
821 back_to
= make_cleanup (free_vector_of_ints
, &ids
);
825 list_available_thread_groups (ids
, recurse
);
827 else if (VEC_length (int, ids
) == 1)
829 /* Local thread groups, single id. */
830 int pid
= *VEC_address (int, ids
);
831 if (!in_inferior_list (pid
))
832 error ("Invalid thread group id '%d'", pid
);
833 print_thread_info (uiout
, -1, pid
);
837 struct print_one_inferior_data data
;
838 data
.recurse
= recurse
;
839 data
.inferiors
= ids
;
841 /* Local thread groups. Either no explicit ids -- and we
842 print everything, or several explicit ids. In both cases,
843 we print more than one group, and have to use 'groups'
844 as the top-level element. */
845 make_cleanup_ui_out_list_begin_end (uiout
, "groups");
846 update_thread_list ();
847 iterate_over_inferiors (print_one_inferior
, &data
);
850 do_cleanups (back_to
);
854 mi_cmd_data_list_register_names (char *command
, char **argv
, int argc
)
856 struct gdbarch
*gdbarch
;
859 struct cleanup
*cleanup
;
861 /* Note that the test for a valid register must include checking the
862 gdbarch_register_name because gdbarch_num_regs may be allocated for
863 the union of the register sets within a family of related processors.
864 In this case, some entries of gdbarch_register_name will change depending
865 upon the particular processor being debugged. */
867 gdbarch
= get_current_arch ();
868 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
870 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "register-names");
872 if (argc
== 0) /* No args, just do all the regs. */
878 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
879 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
880 ui_out_field_string (uiout
, NULL
, "");
882 ui_out_field_string (uiout
, NULL
,
883 gdbarch_register_name (gdbarch
, regnum
));
887 /* Else, list of register #s, just do listed regs. */
888 for (i
= 0; i
< argc
; i
++)
890 regnum
= atoi (argv
[i
]);
891 if (regnum
< 0 || regnum
>= numregs
)
892 error ("bad register number");
894 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
895 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
896 ui_out_field_string (uiout
, NULL
, "");
898 ui_out_field_string (uiout
, NULL
,
899 gdbarch_register_name (gdbarch
, regnum
));
901 do_cleanups (cleanup
);
905 mi_cmd_data_list_changed_registers (char *command
, char **argv
, int argc
)
907 static struct regcache
*this_regs
= NULL
;
908 struct regcache
*prev_regs
;
909 struct gdbarch
*gdbarch
;
910 int regnum
, numregs
, changed
;
912 struct cleanup
*cleanup
;
914 /* The last time we visited this function, the current frame's register
915 contents were saved in THIS_REGS. Move THIS_REGS over to PREV_REGS,
916 and refresh THIS_REGS with the now-current register contents. */
918 prev_regs
= this_regs
;
919 this_regs
= frame_save_as_regcache (get_selected_frame (NULL
));
920 cleanup
= make_cleanup_regcache_xfree (prev_regs
);
922 /* Note that the test for a valid register must include checking the
923 gdbarch_register_name because gdbarch_num_regs may be allocated for
924 the union of the register sets within a family of related processors.
925 In this case, some entries of gdbarch_register_name will change depending
926 upon the particular processor being debugged. */
928 gdbarch
= get_regcache_arch (this_regs
);
929 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
931 make_cleanup_ui_out_list_begin_end (uiout
, "changed-registers");
933 if (argc
== 0) /* No args, just do all the regs. */
939 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
940 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
942 changed
= register_changed_p (regnum
, prev_regs
, this_regs
);
944 error ("mi_cmd_data_list_changed_registers: Unable to read register contents.");
946 ui_out_field_int (uiout
, NULL
, regnum
);
950 /* Else, list of register #s, just do listed regs. */
951 for (i
= 0; i
< argc
; i
++)
953 regnum
= atoi (argv
[i
]);
957 && gdbarch_register_name (gdbarch
, regnum
) != NULL
958 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
960 changed
= register_changed_p (regnum
, prev_regs
, this_regs
);
962 error ("mi_cmd_data_list_register_change: Unable to read register contents.");
964 ui_out_field_int (uiout
, NULL
, regnum
);
967 error ("bad register number");
969 do_cleanups (cleanup
);
973 register_changed_p (int regnum
, struct regcache
*prev_regs
,
974 struct regcache
*this_regs
)
976 struct gdbarch
*gdbarch
= get_regcache_arch (this_regs
);
977 gdb_byte prev_buffer
[MAX_REGISTER_SIZE
];
978 gdb_byte this_buffer
[MAX_REGISTER_SIZE
];
980 /* Registers not valid in this frame return count as unchanged. */
981 if (!regcache_valid_p (this_regs
, regnum
))
984 /* First time through or after gdbarch change consider all registers as
985 changed. Same for registers not valid in the previous frame. */
986 if (!prev_regs
|| get_regcache_arch (prev_regs
) != gdbarch
987 || !regcache_valid_p (prev_regs
, regnum
))
990 /* Get register contents and compare. */
991 regcache_cooked_read (prev_regs
, regnum
, prev_buffer
);
992 regcache_cooked_read (this_regs
, regnum
, this_buffer
);
994 return memcmp (prev_buffer
, this_buffer
,
995 register_size (gdbarch
, regnum
)) != 0;
998 /* Return a list of register number and value pairs. The valid
999 arguments expected are: a letter indicating the format in which to
1000 display the registers contents. This can be one of: x (hexadecimal), d
1001 (decimal), N (natural), t (binary), o (octal), r (raw). After the
1002 format argumetn there can be a sequence of numbers, indicating which
1003 registers to fetch the content of. If the format is the only argument,
1004 a list of all the registers with their values is returned. */
1006 mi_cmd_data_list_register_values (char *command
, char **argv
, int argc
)
1008 struct frame_info
*frame
;
1009 struct gdbarch
*gdbarch
;
1010 int regnum
, numregs
, format
;
1012 struct cleanup
*list_cleanup
, *tuple_cleanup
;
1014 /* Note that the test for a valid register must include checking the
1015 gdbarch_register_name because gdbarch_num_regs may be allocated for
1016 the union of the register sets within a family of related processors.
1017 In this case, some entries of gdbarch_register_name will change depending
1018 upon the particular processor being debugged. */
1021 error ("mi_cmd_data_list_register_values: Usage: -data-list-register-values <format> [<regnum1>...<regnumN>]");
1023 format
= (int) argv
[0][0];
1025 frame
= get_selected_frame (NULL
);
1026 gdbarch
= get_frame_arch (frame
);
1027 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1029 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "register-values");
1031 if (argc
== 1) /* No args, beside the format: do all the regs. */
1037 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1038 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1040 tuple_cleanup
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1041 ui_out_field_int (uiout
, "number", regnum
);
1042 get_register (frame
, regnum
, format
);
1043 do_cleanups (tuple_cleanup
);
1047 /* Else, list of register #s, just do listed regs. */
1048 for (i
= 1; i
< argc
; i
++)
1050 regnum
= atoi (argv
[i
]);
1054 && gdbarch_register_name (gdbarch
, regnum
) != NULL
1055 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
1057 tuple_cleanup
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1058 ui_out_field_int (uiout
, "number", regnum
);
1059 get_register (frame
, regnum
, format
);
1060 do_cleanups (tuple_cleanup
);
1063 error ("bad register number");
1065 do_cleanups (list_cleanup
);
1068 /* Output one register's contents in the desired format. */
1070 get_register (struct frame_info
*frame
, int regnum
, int format
)
1072 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1073 gdb_byte buffer
[MAX_REGISTER_SIZE
];
1077 enum lval_type lval
;
1078 static struct ui_stream
*stb
= NULL
;
1080 stb
= ui_out_stream_new (uiout
);
1085 frame_register (frame
, regnum
, &optim
, &lval
, &addr
, &realnum
, buffer
);
1088 error ("Optimized out");
1093 char *ptr
, buf
[1024];
1097 for (j
= 0; j
< register_size (gdbarch
, regnum
); j
++)
1099 int idx
= gdbarch_byte_order (gdbarch
) == BFD_ENDIAN_BIG
?
1100 j
: register_size (gdbarch
, regnum
) - 1 - j
;
1101 sprintf (ptr
, "%02x", (unsigned char) buffer
[idx
]);
1104 ui_out_field_string (uiout
, "value", buf
);
1105 /*fputs_filtered (buf, gdb_stdout); */
1109 struct value_print_options opts
;
1110 get_formatted_print_options (&opts
, format
);
1112 val_print (register_type (gdbarch
, regnum
), buffer
, 0, 0,
1113 stb
->stream
, 0, &opts
, current_language
);
1114 ui_out_field_stream (uiout
, "value", stb
);
1115 ui_out_stream_delete (stb
);
1119 /* Write given values into registers. The registers and values are
1120 given as pairs. The corresponding MI command is
1121 -data-write-register-values <format> [<regnum1> <value1>...<regnumN> <valueN>]*/
1123 mi_cmd_data_write_register_values (char *command
, char **argv
, int argc
)
1125 struct regcache
*regcache
;
1126 struct gdbarch
*gdbarch
;
1130 /* Note that the test for a valid register must include checking the
1131 gdbarch_register_name because gdbarch_num_regs may be allocated for
1132 the union of the register sets within a family of related processors.
1133 In this case, some entries of gdbarch_register_name will change depending
1134 upon the particular processor being debugged. */
1136 regcache
= get_current_regcache ();
1137 gdbarch
= get_regcache_arch (regcache
);
1138 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1141 error ("mi_cmd_data_write_register_values: Usage: -data-write-register-values <format> [<regnum1> <value1>...<regnumN> <valueN>]");
1143 format
= (int) argv
[0][0];
1145 if (!target_has_registers
)
1146 error ("mi_cmd_data_write_register_values: No registers.");
1149 error ("mi_cmd_data_write_register_values: No regs and values specified.");
1152 error ("mi_cmd_data_write_register_values: Regs and vals are not in pairs.");
1154 for (i
= 1; i
< argc
; i
= i
+ 2)
1156 int regnum
= atoi (argv
[i
]);
1158 if (regnum
>= 0 && regnum
< numregs
1159 && gdbarch_register_name (gdbarch
, regnum
)
1160 && *gdbarch_register_name (gdbarch
, regnum
))
1164 /* Get the value as a number. */
1165 value
= parse_and_eval_address (argv
[i
+ 1]);
1167 /* Write it down. */
1168 regcache_cooked_write_signed (regcache
, regnum
, value
);
1171 error ("bad register number");
1175 /* Evaluate the value of the argument. The argument is an
1176 expression. If the expression contains spaces it needs to be
1177 included in double quotes. */
1179 mi_cmd_data_evaluate_expression (char *command
, char **argv
, int argc
)
1181 struct expression
*expr
;
1182 struct cleanup
*old_chain
= NULL
;
1184 struct ui_stream
*stb
= NULL
;
1185 struct value_print_options opts
;
1187 stb
= ui_out_stream_new (uiout
);
1191 ui_out_stream_delete (stb
);
1192 error ("mi_cmd_data_evaluate_expression: Usage: -data-evaluate-expression expression");
1195 expr
= parse_expression (argv
[0]);
1197 old_chain
= make_cleanup (free_current_contents
, &expr
);
1199 val
= evaluate_expression (expr
);
1201 /* Print the result of the expression evaluation. */
1202 get_user_print_options (&opts
);
1204 val_print (value_type (val
), value_contents (val
),
1205 value_embedded_offset (val
), value_address (val
),
1206 stb
->stream
, 0, &opts
, current_language
);
1208 ui_out_field_stream (uiout
, "value", stb
);
1209 ui_out_stream_delete (stb
);
1211 do_cleanups (old_chain
);
1214 /* DATA-MEMORY-READ:
1216 ADDR: start address of data to be dumped.
1217 WORD-FORMAT: a char indicating format for the ``word''. See
1219 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes.
1220 NR_ROW: Number of rows.
1221 NR_COL: The number of colums (words per row).
1222 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
1223 ASCHAR for unprintable characters.
1225 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
1226 displayes them. Returns:
1228 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
1231 The number of bytes read is SIZE*ROW*COL. */
1234 mi_cmd_data_read_memory (char *command
, char **argv
, int argc
)
1236 struct gdbarch
*gdbarch
= get_current_arch ();
1237 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
1243 struct type
*word_type
;
1256 static struct mi_opt opts
[] =
1258 {"o", OFFSET_OPT
, 1},
1264 int opt
= mi_getopt ("mi_cmd_data_read_memory", argc
, argv
, opts
,
1268 switch ((enum opt
) opt
)
1271 offset
= atol (optarg
);
1278 if (argc
< 5 || argc
> 6)
1279 error ("mi_cmd_data_read_memory: Usage: ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR].");
1281 /* Extract all the arguments. */
1283 /* Start address of the memory dump. */
1284 addr
= parse_and_eval_address (argv
[0]) + offset
;
1285 /* The format character to use when displaying a memory word. See
1286 the ``x'' command. */
1287 word_format
= argv
[1][0];
1288 /* The size of the memory word. */
1289 word_size
= atol (argv
[2]);
1293 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1297 word_type
= builtin_type (gdbarch
)->builtin_int16
;
1301 word_type
= builtin_type (gdbarch
)->builtin_int32
;
1305 word_type
= builtin_type (gdbarch
)->builtin_int64
;
1309 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1312 /* The number of rows. */
1313 nr_rows
= atol (argv
[3]);
1315 error ("mi_cmd_data_read_memory: invalid number of rows.");
1317 /* Number of bytes per row. */
1318 nr_cols
= atol (argv
[4]);
1320 error ("mi_cmd_data_read_memory: invalid number of columns.");
1322 /* The un-printable character when printing ascii. */
1328 /* Create a buffer and read it in. */
1329 total_bytes
= word_size
* nr_rows
* nr_cols
;
1330 mbuf
= xcalloc (total_bytes
, 1);
1331 make_cleanup (xfree
, mbuf
);
1333 /* Dispatch memory reads to the topmost target, not the flattened
1335 nr_bytes
= target_read_until_error (current_target
.beneath
,
1336 TARGET_OBJECT_MEMORY
, NULL
, mbuf
,
1339 error ("Unable to read memory.");
1341 /* Output the header information. */
1342 ui_out_field_core_addr (uiout
, "addr", gdbarch
, addr
);
1343 ui_out_field_int (uiout
, "nr-bytes", nr_bytes
);
1344 ui_out_field_int (uiout
, "total-bytes", total_bytes
);
1345 ui_out_field_core_addr (uiout
, "next-row",
1346 gdbarch
, addr
+ word_size
* nr_cols
);
1347 ui_out_field_core_addr (uiout
, "prev-row",
1348 gdbarch
, addr
- word_size
* nr_cols
);
1349 ui_out_field_core_addr (uiout
, "next-page", gdbarch
, addr
+ total_bytes
);
1350 ui_out_field_core_addr (uiout
, "prev-page", gdbarch
, addr
- total_bytes
);
1352 /* Build the result as a two dimentional table. */
1354 struct ui_stream
*stream
= ui_out_stream_new (uiout
);
1355 struct cleanup
*cleanup_list_memory
;
1358 cleanup_list_memory
= make_cleanup_ui_out_list_begin_end (uiout
, "memory");
1359 for (row
= 0, row_byte
= 0;
1361 row
++, row_byte
+= nr_cols
* word_size
)
1365 struct cleanup
*cleanup_tuple
;
1366 struct cleanup
*cleanup_list_data
;
1367 struct value_print_options opts
;
1369 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1370 ui_out_field_core_addr (uiout
, "addr", gdbarch
, addr
+ row_byte
);
1371 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr + row_byte); */
1372 cleanup_list_data
= make_cleanup_ui_out_list_begin_end (uiout
, "data");
1373 get_formatted_print_options (&opts
, word_format
);
1374 for (col
= 0, col_byte
= row_byte
;
1376 col
++, col_byte
+= word_size
)
1378 if (col_byte
+ word_size
> nr_bytes
)
1380 ui_out_field_string (uiout
, NULL
, "N/A");
1384 ui_file_rewind (stream
->stream
);
1385 print_scalar_formatted (mbuf
+ col_byte
, word_type
, &opts
,
1386 word_asize
, stream
->stream
);
1387 ui_out_field_stream (uiout
, NULL
, stream
);
1390 do_cleanups (cleanup_list_data
);
1394 ui_file_rewind (stream
->stream
);
1395 for (byte
= row_byte
; byte
< row_byte
+ word_size
* nr_cols
; byte
++)
1397 if (byte
>= nr_bytes
)
1399 fputc_unfiltered ('X', stream
->stream
);
1401 else if (mbuf
[byte
] < 32 || mbuf
[byte
] > 126)
1403 fputc_unfiltered (aschar
, stream
->stream
);
1406 fputc_unfiltered (mbuf
[byte
], stream
->stream
);
1408 ui_out_field_stream (uiout
, "ascii", stream
);
1410 do_cleanups (cleanup_tuple
);
1412 ui_out_stream_delete (stream
);
1413 do_cleanups (cleanup_list_memory
);
1415 do_cleanups (cleanups
);
1418 /* DATA-MEMORY-WRITE:
1420 COLUMN_OFFSET: optional argument. Must be preceeded by '-o'. The
1421 offset from the beginning of the memory grid row where the cell to
1423 ADDR: start address of the row in the memory grid where the memory
1424 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
1425 the location to write to.
1426 FORMAT: a char indicating format for the ``word''. See
1428 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
1429 VALUE: value to be written into the memory address.
1431 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
1435 mi_cmd_data_write_memory (char *command
, char **argv
, int argc
)
1437 struct gdbarch
*gdbarch
= get_current_arch ();
1438 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1442 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
1443 enough when using a compiler other than GCC. */
1446 struct cleanup
*old_chain
;
1454 static struct mi_opt opts
[] =
1456 {"o", OFFSET_OPT
, 1},
1462 int opt
= mi_getopt ("mi_cmd_data_write_memory", argc
, argv
, opts
,
1466 switch ((enum opt
) opt
)
1469 offset
= atol (optarg
);
1477 error ("mi_cmd_data_write_memory: Usage: [-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE.");
1479 /* Extract all the arguments. */
1480 /* Start address of the memory dump. */
1481 addr
= parse_and_eval_address (argv
[0]);
1482 /* The format character to use when displaying a memory word. See
1483 the ``x'' command. */
1484 word_format
= argv
[1][0];
1485 /* The size of the memory word. */
1486 word_size
= atol (argv
[2]);
1488 /* Calculate the real address of the write destination. */
1489 addr
+= (offset
* word_size
);
1491 /* Get the value as a number. */
1492 value
= parse_and_eval_address (argv
[3]);
1493 /* Get the value into an array. */
1494 buffer
= xmalloc (word_size
);
1495 old_chain
= make_cleanup (xfree
, buffer
);
1496 store_signed_integer (buffer
, word_size
, byte_order
, value
);
1497 /* Write it down to memory. */
1498 write_memory (addr
, buffer
, word_size
);
1499 /* Free the buffer. */
1500 do_cleanups (old_chain
);
1504 mi_cmd_enable_timings (char *command
, char **argv
, int argc
)
1510 if (strcmp (argv
[0], "yes") == 0)
1512 else if (strcmp (argv
[0], "no") == 0)
1523 error ("mi_cmd_enable_timings: Usage: %s {yes|no}", command
);
1527 mi_cmd_list_features (char *command
, char **argv
, int argc
)
1531 struct cleanup
*cleanup
= NULL
;
1532 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "features");
1534 ui_out_field_string (uiout
, NULL
, "frozen-varobjs");
1535 ui_out_field_string (uiout
, NULL
, "pending-breakpoints");
1536 ui_out_field_string (uiout
, NULL
, "thread-info");
1539 ui_out_field_string (uiout
, NULL
, "python");
1542 do_cleanups (cleanup
);
1546 error ("-list-features should be passed no arguments");
1550 mi_cmd_list_target_features (char *command
, char **argv
, int argc
)
1554 struct cleanup
*cleanup
= NULL
;
1555 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "features");
1557 if (target_can_async_p ())
1558 ui_out_field_string (uiout
, NULL
, "async");
1560 do_cleanups (cleanup
);
1564 error ("-list-target-features should be passed no arguments");
1568 mi_cmd_add_inferior (char *command
, char **argv
, int argc
)
1570 struct inferior
*inf
;
1573 error (_("-add-inferior should be passed no arguments"));
1575 inf
= add_inferior_with_spaces ();
1577 ui_out_field_fmt (uiout
, "inferior", "i%d", inf
->num
);
1581 mi_cmd_remove_inferior (char *command
, char **argv
, int argc
)
1584 struct inferior
*inf
;
1587 error ("-remove-inferior should be passed a single argument");
1589 if (sscanf (argv
[1], "i%d", &id
) != 1)
1590 error ("the thread group id is syntactically invalid");
1592 inf
= find_inferior_id (id
);
1594 error ("the specified thread group does not exist");
1596 delete_inferior_1 (inf
, 1 /* silent */);
1601 /* Execute a command within a safe environment.
1602 Return <0 for error; >=0 for ok.
1604 args->action will tell mi_execute_command what action
1605 to perfrom after the given command has executed (display/suppress
1606 prompt, display error). */
1609 captured_mi_execute_command (struct ui_out
*uiout
, void *data
)
1611 struct cleanup
*cleanup
;
1612 struct mi_parse
*context
= (struct mi_parse
*) data
;
1615 current_command_ts
= context
->cmd_start
;
1617 current_token
= xstrdup (context
->token
);
1618 cleanup
= make_cleanup (free_current_contents
, ¤t_token
);
1620 running_result_record_printed
= 0;
1622 switch (context
->op
)
1625 /* A MI command was read from the input stream. */
1627 /* FIXME: gdb_???? */
1628 fprintf_unfiltered (raw_stdout
, " token=`%s' command=`%s' args=`%s'\n",
1629 context
->token
, context
->command
, context
->args
);
1632 mi_cmd_execute (context
);
1634 /* Print the result if there were no errors.
1636 Remember that on the way out of executing a command, you have
1637 to directly use the mi_interp's uiout, since the command could
1638 have reset the interpreter, in which case the current uiout
1639 will most likely crash in the mi_out_* routines. */
1640 if (!running_result_record_printed
)
1642 fputs_unfiltered (context
->token
, raw_stdout
);
1643 /* There's no particularly good reason why target-connect results
1644 in not ^done. Should kill ^connected for MI3. */
1645 fputs_unfiltered (strcmp (context
->command
, "target-select") == 0
1646 ? "^connected" : "^done", raw_stdout
);
1647 mi_out_put (uiout
, raw_stdout
);
1648 mi_out_rewind (uiout
);
1649 mi_print_timing_maybe ();
1650 fputs_unfiltered ("\n", raw_stdout
);
1653 /* The command does not want anything to be printed. In that
1654 case, the command probably should not have written anything
1655 to uiout, but in case it has written something, discard it. */
1656 mi_out_rewind (uiout
);
1662 /* A CLI command was read from the input stream. */
1663 /* This "feature" will be removed as soon as we have a
1664 complete set of mi commands. */
1665 /* Echo the command on the console. */
1666 fprintf_unfiltered (gdb_stdlog
, "%s\n", context
->command
);
1667 /* Call the "console" interpreter. */
1668 argv
[0] = "console";
1669 argv
[1] = context
->command
;
1670 mi_cmd_interpreter_exec ("-interpreter-exec", argv
, 2);
1672 /* If we changed interpreters, DON'T print out anything. */
1673 if (current_interp_named_p (INTERP_MI
)
1674 || current_interp_named_p (INTERP_MI1
)
1675 || current_interp_named_p (INTERP_MI2
)
1676 || current_interp_named_p (INTERP_MI3
))
1678 if (!running_result_record_printed
)
1680 fputs_unfiltered (context
->token
, raw_stdout
);
1681 fputs_unfiltered ("^done", raw_stdout
);
1682 mi_out_put (uiout
, raw_stdout
);
1683 mi_out_rewind (uiout
);
1684 mi_print_timing_maybe ();
1685 fputs_unfiltered ("\n", raw_stdout
);
1688 mi_out_rewind (uiout
);
1695 do_cleanups (cleanup
);
1702 mi_execute_command (char *cmd
, int from_tty
)
1704 struct mi_parse
*command
;
1705 struct ui_out
*saved_uiout
= uiout
;
1707 /* This is to handle EOF (^D). We just quit gdb. */
1708 /* FIXME: we should call some API function here. */
1710 quit_force (NULL
, from_tty
);
1712 target_log_command (cmd
);
1714 command
= mi_parse (cmd
);
1716 if (command
!= NULL
)
1718 struct gdb_exception result
;
1719 ptid_t previous_ptid
= inferior_ptid
;
1723 command
->cmd_start
= (struct mi_timestamp
*)
1724 xmalloc (sizeof (struct mi_timestamp
));
1725 timestamp (command
->cmd_start
);
1728 result
= catch_exception (uiout
, captured_mi_execute_command
, command
,
1730 if (result
.reason
< 0)
1732 /* The command execution failed and error() was called
1734 fputs_unfiltered (command
->token
, raw_stdout
);
1735 fputs_unfiltered ("^error,msg=\"", raw_stdout
);
1736 if (result
.message
== NULL
)
1737 fputs_unfiltered ("unknown error", raw_stdout
);
1739 fputstr_unfiltered (result
.message
, '"', raw_stdout
);
1740 fputs_unfiltered ("\"\n", raw_stdout
);
1741 mi_out_rewind (uiout
);
1744 bpstat_do_actions ();
1746 if (/* The notifications are only output when the top-level
1747 interpreter (specified on the command line) is MI. */
1748 ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ()))
1749 /* Don't try report anything if there are no threads --
1750 the program is dead. */
1751 && thread_count () != 0
1752 /* -thread-select explicitly changes thread. If frontend uses that
1753 internally, we don't want to emit =thread-selected, since
1754 =thread-selected is supposed to indicate user's intentions. */
1755 && strcmp (command
->command
, "thread-select") != 0)
1757 struct mi_interp
*mi
= top_level_interpreter_data ();
1758 int report_change
= 0;
1760 if (command
->thread
== -1)
1762 report_change
= (!ptid_equal (previous_ptid
, null_ptid
)
1763 && !ptid_equal (inferior_ptid
, previous_ptid
)
1764 && !ptid_equal (inferior_ptid
, null_ptid
));
1766 else if (!ptid_equal (inferior_ptid
, null_ptid
))
1768 struct thread_info
*ti
= inferior_thread ();
1769 report_change
= (ti
->num
!= command
->thread
);
1774 struct thread_info
*ti
= inferior_thread ();
1775 target_terminal_ours ();
1776 fprintf_unfiltered (mi
->event_channel
,
1777 "thread-selected,id=\"%d\"",
1779 gdb_flush (mi
->event_channel
);
1783 mi_parse_free (command
);
1786 fputs_unfiltered ("(gdb) \n", raw_stdout
);
1787 gdb_flush (raw_stdout
);
1788 /* Print any buffered hook code. */
1793 mi_cmd_execute (struct mi_parse
*parse
)
1795 struct cleanup
*cleanup
;
1798 prepare_execute_command ();
1800 cleanup
= make_cleanup (null_cleanup
, NULL
);
1802 if (parse
->all
&& parse
->thread_group
!= -1)
1803 error (_("Cannot specify --thread-group together with --all"));
1805 if (parse
->all
&& parse
->thread
!= -1)
1806 error (_("Cannot specify --thread together with --all"));
1808 if (parse
->thread_group
!= -1 && parse
->thread
!= -1)
1809 error (_("Cannot specify --thread together with --thread-group"));
1811 if (parse
->frame
!= -1 && parse
->thread
== -1)
1812 error (_("Cannot specify --frame without --thread"));
1814 if (parse
->thread_group
!= -1)
1816 struct inferior
*inf
= find_inferior_id (parse
->thread_group
);
1817 struct thread_info
*tp
= 0;
1820 error (_("Invalid thread group for the --thread-group option"));
1822 set_current_inferior (inf
);
1823 /* This behaviour means that if --thread-group option identifies
1824 an inferior with multiple threads, then a random one will be picked.
1825 This is not a problem -- frontend should always provide --thread if
1826 it wishes to operate on a specific thread. */
1828 tp
= any_thread_of_process (inf
->pid
);
1829 switch_to_thread (tp
? tp
->ptid
: null_ptid
);
1830 set_current_program_space (inf
->pspace
);
1833 if (parse
->thread
!= -1)
1835 struct thread_info
*tp
= find_thread_id (parse
->thread
);
1837 error (_("Invalid thread id: %d"), parse
->thread
);
1839 if (is_exited (tp
->ptid
))
1840 error (_("Thread id: %d has terminated"), parse
->thread
);
1842 switch_to_thread (tp
->ptid
);
1845 if (parse
->frame
!= -1)
1847 struct frame_info
*fid
;
1848 int frame
= parse
->frame
;
1849 fid
= find_relative_frame (get_current_frame (), &frame
);
1851 /* find_relative_frame was successful */
1854 error (_("Invalid frame id: %d"), frame
);
1857 current_context
= parse
;
1859 if (parse
->cmd
->argv_func
!= NULL
)
1860 parse
->cmd
->argv_func (parse
->command
, parse
->argv
, parse
->argc
);
1861 else if (parse
->cmd
->cli
.cmd
!= 0)
1863 /* FIXME: DELETE THIS. */
1864 /* The operation is still implemented by a cli command. */
1865 /* Must be a synchronous one. */
1866 mi_execute_cli_command (parse
->cmd
->cli
.cmd
, parse
->cmd
->cli
.args_p
,
1871 /* FIXME: DELETE THIS. */
1872 struct ui_file
*stb
;
1874 stb
= mem_fileopen ();
1876 fputs_unfiltered ("Undefined mi command: ", stb
);
1877 fputstr_unfiltered (parse
->command
, '"', stb
);
1878 fputs_unfiltered (" (missing implementation)", stb
);
1880 make_cleanup_ui_file_delete (stb
);
1883 do_cleanups (cleanup
);
1886 /* FIXME: This is just a hack so we can get some extra commands going.
1887 We don't want to channel things through the CLI, but call libgdb directly.
1888 Use only for synchronous commands. */
1891 mi_execute_cli_command (const char *cmd
, int args_p
, const char *args
)
1895 struct cleanup
*old_cleanups
;
1898 run
= xstrprintf ("%s %s", cmd
, args
);
1900 run
= xstrdup (cmd
);
1902 /* FIXME: gdb_???? */
1903 fprintf_unfiltered (gdb_stdout
, "cli=%s run=%s\n",
1905 old_cleanups
= make_cleanup (xfree
, run
);
1906 execute_command ( /*ui */ run
, 0 /*from_tty */ );
1907 do_cleanups (old_cleanups
);
1913 mi_execute_async_cli_command (char *cli_command
, char **argv
, int argc
)
1915 struct cleanup
*old_cleanups
;
1918 if (target_can_async_p ())
1919 run
= xstrprintf ("%s %s&", cli_command
, argc
? *argv
: "");
1921 run
= xstrprintf ("%s %s", cli_command
, argc
? *argv
: "");
1922 old_cleanups
= make_cleanup (xfree
, run
);
1924 execute_command ( /*ui */ run
, 0 /*from_tty */ );
1926 if (target_can_async_p ())
1928 /* If we're not executing, an exception should have been throw. */
1929 gdb_assert (is_running (inferior_ptid
));
1930 do_cleanups (old_cleanups
);
1934 /* Do this before doing any printing. It would appear that some
1935 print code leaves garbage around in the buffer. */
1936 do_cleanups (old_cleanups
);
1941 mi_load_progress (const char *section_name
,
1942 unsigned long sent_so_far
,
1943 unsigned long total_section
,
1944 unsigned long total_sent
,
1945 unsigned long grand_total
)
1947 struct timeval time_now
, delta
, update_threshold
;
1948 static struct timeval last_update
;
1949 static char *previous_sect_name
= NULL
;
1951 struct ui_out
*saved_uiout
;
1953 /* This function is called through deprecated_show_load_progress
1954 which means uiout may not be correct. Fix it for the duration
1955 of this function. */
1956 saved_uiout
= uiout
;
1958 if (current_interp_named_p (INTERP_MI
)
1959 || current_interp_named_p (INTERP_MI2
))
1960 uiout
= mi_out_new (2);
1961 else if (current_interp_named_p (INTERP_MI1
))
1962 uiout
= mi_out_new (1);
1963 else if (current_interp_named_p (INTERP_MI3
))
1964 uiout
= mi_out_new (3);
1968 update_threshold
.tv_sec
= 0;
1969 update_threshold
.tv_usec
= 500000;
1970 gettimeofday (&time_now
, NULL
);
1972 delta
.tv_usec
= time_now
.tv_usec
- last_update
.tv_usec
;
1973 delta
.tv_sec
= time_now
.tv_sec
- last_update
.tv_sec
;
1975 if (delta
.tv_usec
< 0)
1978 delta
.tv_usec
+= 1000000L;
1981 new_section
= (previous_sect_name
?
1982 strcmp (previous_sect_name
, section_name
) : 1);
1985 struct cleanup
*cleanup_tuple
;
1986 xfree (previous_sect_name
);
1987 previous_sect_name
= xstrdup (section_name
);
1990 fputs_unfiltered (current_token
, raw_stdout
);
1991 fputs_unfiltered ("+download", raw_stdout
);
1992 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1993 ui_out_field_string (uiout
, "section", section_name
);
1994 ui_out_field_int (uiout
, "section-size", total_section
);
1995 ui_out_field_int (uiout
, "total-size", grand_total
);
1996 do_cleanups (cleanup_tuple
);
1997 mi_out_put (uiout
, raw_stdout
);
1998 fputs_unfiltered ("\n", raw_stdout
);
1999 gdb_flush (raw_stdout
);
2002 if (delta
.tv_sec
>= update_threshold
.tv_sec
&&
2003 delta
.tv_usec
>= update_threshold
.tv_usec
)
2005 struct cleanup
*cleanup_tuple
;
2006 last_update
.tv_sec
= time_now
.tv_sec
;
2007 last_update
.tv_usec
= time_now
.tv_usec
;
2009 fputs_unfiltered (current_token
, raw_stdout
);
2010 fputs_unfiltered ("+download", raw_stdout
);
2011 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2012 ui_out_field_string (uiout
, "section", section_name
);
2013 ui_out_field_int (uiout
, "section-sent", sent_so_far
);
2014 ui_out_field_int (uiout
, "section-size", total_section
);
2015 ui_out_field_int (uiout
, "total-sent", total_sent
);
2016 ui_out_field_int (uiout
, "total-size", grand_total
);
2017 do_cleanups (cleanup_tuple
);
2018 mi_out_put (uiout
, raw_stdout
);
2019 fputs_unfiltered ("\n", raw_stdout
);
2020 gdb_flush (raw_stdout
);
2024 uiout
= saved_uiout
;
2028 timestamp (struct mi_timestamp
*tv
)
2031 gettimeofday (&tv
->wallclock
, NULL
);
2032 #ifdef HAVE_GETRUSAGE
2033 getrusage (RUSAGE_SELF
, &rusage
);
2034 tv
->utime
.tv_sec
= rusage
.ru_utime
.tv_sec
;
2035 tv
->utime
.tv_usec
= rusage
.ru_utime
.tv_usec
;
2036 tv
->stime
.tv_sec
= rusage
.ru_stime
.tv_sec
;
2037 tv
->stime
.tv_usec
= rusage
.ru_stime
.tv_usec
;
2039 usec
= get_run_time ();
2040 tv
->utime
.tv_sec
= usec
/1000000L;
2041 tv
->utime
.tv_usec
= usec
- 1000000L*tv
->utime
.tv_sec
;
2042 tv
->stime
.tv_sec
= 0;
2043 tv
->stime
.tv_usec
= 0;
2048 print_diff_now (struct mi_timestamp
*start
)
2050 struct mi_timestamp now
;
2052 print_diff (start
, &now
);
2056 mi_print_timing_maybe (void)
2058 /* If the command is -enable-timing then do_timings may be
2059 true whilst current_command_ts is not initialized. */
2060 if (do_timings
&& current_command_ts
)
2061 print_diff_now (current_command_ts
);
2065 timeval_diff (struct timeval start
, struct timeval end
)
2067 return ((end
.tv_sec
- start
.tv_sec
) * 1000000L)
2068 + (end
.tv_usec
- start
.tv_usec
);
2072 print_diff (struct mi_timestamp
*start
, struct mi_timestamp
*end
)
2076 ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
2077 timeval_diff (start
->wallclock
, end
->wallclock
) / 1000000.0,
2078 timeval_diff (start
->utime
, end
->utime
) / 1000000.0,
2079 timeval_diff (start
->stime
, end
->stime
) / 1000000.0);
2083 mi_cmd_trace_define_variable (char *command
, char **argv
, int argc
)
2085 struct expression
*expr
;
2086 struct cleanup
*back_to
;
2087 LONGEST initval
= 0;
2088 struct trace_state_variable
*tsv
;
2091 if (argc
!= 1 && argc
!= 2)
2092 error (_("Usage: -trace-define-variable VARIABLE [VALUE]"));
2094 expr
= parse_expression (argv
[0]);
2095 back_to
= make_cleanup (xfree
, expr
);
2097 if (expr
->nelts
== 3 && expr
->elts
[0].opcode
== OP_INTERNALVAR
)
2099 struct internalvar
*intvar
= expr
->elts
[1].internalvar
;
2101 name
= internalvar_name (intvar
);
2104 if (!name
|| *name
== '\0')
2105 error (_("Invalid name of trace variable"));
2107 tsv
= find_trace_state_variable (name
);
2109 tsv
= create_trace_state_variable (name
);
2112 initval
= value_as_long (parse_and_eval (argv
[1]));
2114 tsv
->initial_value
= initval
;
2116 do_cleanups (back_to
);
2120 mi_cmd_trace_list_variables (char *command
, char **argv
, int argc
)
2123 error (_("-trace-list-variables: no arguments are allowed"));
2125 tvariables_info_1 ();
2129 mi_cmd_trace_start (char *command
, char **argv
, int argc
)
2135 mi_cmd_trace_status (char *command
, char **argv
, int argc
)
2137 trace_status_mi (0);
2141 mi_cmd_trace_stop (char *command
, char **argv
, int argc
)
2144 trace_status_mi (1);