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"
58 #if defined HAVE_SYS_RESOURCE_H
59 #include <sys/resource.h>
72 struct ui_file *raw_stdout;
74 /* This is used to pass the current command timestamp
75 down to continuation routines. */
76 static struct mi_timestamp *current_command_ts;
78 static int do_timings = 0;
81 int running_result_record_printed = 1;
83 /* Flag indicating that the target has proceeded since the last
84 command was issued. */
87 extern void _initialize_mi_main (void);
88 static void mi_cmd_execute (struct mi_parse *parse);
90 static void mi_execute_cli_command (const char *cmd, int args_p,
92 static void mi_execute_async_cli_command (char *cli_command,
93 char **argv, int argc);
94 static int register_changed_p (int regnum, struct regcache *,
96 static void get_register (struct frame_info *, int regnum, int format);
98 /* Command implementations. FIXME: Is this libgdb? No. This is the MI
99 layer that calls libgdb. Any operation used in the below should be
102 static void timestamp (struct mi_timestamp *tv);
104 static void print_diff_now (struct mi_timestamp *start);
105 static void print_diff (struct mi_timestamp *start, struct mi_timestamp *end);
108 mi_cmd_gdb_exit (char *command, char **argv, int argc)
110 /* We have to print everything right here because we never return. */
112 fputs_unfiltered (current_token, raw_stdout);
113 fputs_unfiltered ("^exit\n", raw_stdout);
114 mi_out_put (uiout, raw_stdout);
115 gdb_flush (raw_stdout);
116 /* FIXME: The function called is not yet a formal libgdb function. */
117 quit_force (NULL, FROM_TTY);
121 mi_cmd_exec_next (char *command, char **argv, int argc)
123 /* FIXME: Should call a libgdb function, not a cli wrapper. */
124 if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
125 mi_execute_async_cli_command ("reverse-next", argv + 1, argc - 1);
127 mi_execute_async_cli_command ("next", argv, argc);
131 mi_cmd_exec_next_instruction (char *command, char **argv, int argc)
133 /* FIXME: Should call a libgdb function, not a cli wrapper. */
134 if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
135 mi_execute_async_cli_command ("reverse-nexti", argv + 1, argc - 1);
137 mi_execute_async_cli_command ("nexti", argv, argc);
141 mi_cmd_exec_step (char *command, char **argv, int argc)
143 /* FIXME: Should call a libgdb function, not a cli wrapper. */
144 if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
145 mi_execute_async_cli_command ("reverse-step", argv + 1, argc - 1);
147 mi_execute_async_cli_command ("step", argv, argc);
151 mi_cmd_exec_step_instruction (char *command, char **argv, int argc)
153 /* FIXME: Should call a libgdb function, not a cli wrapper. */
154 if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
155 mi_execute_async_cli_command ("reverse-stepi", argv + 1, argc - 1);
157 mi_execute_async_cli_command ("stepi", argv, argc);
161 mi_cmd_exec_finish (char *command, char **argv, int argc)
163 /* FIXME: Should call a libgdb function, not a cli wrapper. */
164 if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
165 mi_execute_async_cli_command ("reverse-finish", argv + 1, argc - 1);
167 mi_execute_async_cli_command ("finish", argv, argc);
171 mi_cmd_exec_return (char *command, char **argv, int argc)
173 /* This command doesn't really execute the target, it just pops the
174 specified number of frames. */
176 /* Call return_command with from_tty argument equal to 0 so as to
177 avoid being queried. */
178 return_command (*argv, 0);
180 /* Call return_command with from_tty argument equal to 0 so as to
181 avoid being queried. */
182 return_command (NULL, 0);
184 /* Because we have called return_command with from_tty = 0, we need
185 to print the frame here. */
186 print_stack_frame (get_selected_frame (NULL), 1, LOC_AND_ADDRESS);
190 mi_cmd_exec_jump (char *args, char **argv, int argc)
192 /* FIXME: Should call a libgdb function, not a cli wrapper. */
193 return mi_execute_async_cli_command ("jump", argv, argc);
197 proceed_thread_callback (struct thread_info *thread, void *arg)
199 int pid = *(int *)arg;
201 if (!is_stopped (thread->ptid))
204 if (PIDGET (thread->ptid) != pid)
207 switch_to_thread (thread->ptid);
208 clear_proceed_status ();
209 proceed ((CORE_ADDR) -1, TARGET_SIGNAL_DEFAULT, 0);
214 exec_continue (char **argv, int argc)
218 else if (argc == 1 && strcmp (argv[0], "--all") == 0)
220 else if (argc == 2 && strcmp (argv[0], "--thread-group") == 0)
222 struct cleanup *old_chain;
224 if (argv[1] == NULL || argv[1] == '\0')
225 error ("Thread group id not specified");
226 pid = atoi (argv[1]);
227 if (!in_inferior_list (pid))
228 error ("Invalid thread group id '%s'", argv[1]);
230 old_chain = make_cleanup_restore_current_thread ();
231 iterate_over_threads (proceed_thread_callback, &pid);
232 do_cleanups (old_chain);
235 error ("Usage: -exec-continue [--reverse] [--all|--thread-group id]");
238 /* continue in reverse direction:
239 XXX: code duplicated from reverse.c */
242 exec_direction_default (void *notused)
244 /* Return execution direction to default state. */
245 execution_direction = EXEC_FORWARD;
249 exec_reverse_continue (char **argv, int argc)
251 enum exec_direction_kind dir = execution_direction;
252 struct cleanup *old_chain;
254 if (dir == EXEC_ERROR)
255 error (_("Target %s does not support this command."), target_shortname);
257 if (dir == EXEC_REVERSE)
258 error (_("Already in reverse mode."));
260 if (!target_can_execute_reverse)
261 error (_("Target %s does not support this command."), target_shortname);
263 old_chain = make_cleanup (exec_direction_default, NULL);
264 execution_direction = EXEC_REVERSE;
265 exec_continue (argv, argc);
266 do_cleanups (old_chain);
270 mi_cmd_exec_continue (char *command, char **argv, int argc)
272 if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
273 exec_reverse_continue (argv + 1, argc - 1);
275 exec_continue (argv, argc);
279 interrupt_thread_callback (struct thread_info *thread, void *arg)
281 int pid = *(int *)arg;
283 if (!is_running (thread->ptid))
286 if (PIDGET (thread->ptid) != pid)
289 target_stop (thread->ptid);
293 /* Interrupt the execution of the target. Note how we must play around
294 with the token variables, in order to display the current token in
295 the result of the interrupt command, and the previous execution
296 token when the target finally stops. See comments in
299 mi_cmd_exec_interrupt (char *command, char **argv, int argc)
303 if (!is_running (inferior_ptid))
304 error ("Current thread is not running.");
306 interrupt_target_1 (0);
308 else if (argc == 1 && strcmp (argv[0], "--all") == 0)
311 error ("Inferior not running.");
313 interrupt_target_1 (1);
315 else if (argc == 2 && strcmp (argv[0], "--thread-group") == 0)
317 struct cleanup *old_chain;
319 if (argv[1] == NULL || argv[1] == '\0')
320 error ("Thread group id not specified");
321 pid = atoi (argv[1]);
322 if (!in_inferior_list (pid))
323 error ("Invalid thread group id '%s'", argv[1]);
325 old_chain = make_cleanup_restore_current_thread ();
326 iterate_over_threads (interrupt_thread_callback, &pid);
327 do_cleanups (old_chain);
330 error ("Usage: -exec-interrupt [--all|--thread-group id]");
334 find_thread_of_process (struct thread_info *ti, void *p)
337 if (PIDGET (ti->ptid) == pid && !is_exited (ti->ptid))
344 mi_cmd_target_detach (char *command, char **argv, int argc)
346 if (argc != 0 && argc != 1)
347 error ("Usage: -target-detach [thread-group]");
351 struct thread_info *tp;
353 int pid = strtol (argv[0], &end, 10);
355 error (_("Cannot parse thread group id '%s'"), argv[0]);
357 /* Pick any thread in the desired process. Current
358 target_detach deteches from the parent of inferior_ptid. */
359 tp = iterate_over_threads (find_thread_of_process, &pid);
361 error (_("Thread group is empty"));
363 switch_to_thread (tp->ptid);
366 detach_command (NULL, 0);
370 mi_cmd_thread_select (char *command, char **argv, int argc)
373 char *mi_error_message;
376 error ("mi_cmd_thread_select: USAGE: threadnum.");
378 rc = gdb_thread_select (uiout, argv[0], &mi_error_message);
380 if (rc == GDB_RC_FAIL)
382 make_cleanup (xfree, mi_error_message);
383 error ("%s", mi_error_message);
388 mi_cmd_thread_list_ids (char *command, char **argv, int argc)
391 char *mi_error_message;
394 error ("mi_cmd_thread_list_ids: No arguments required.");
396 rc = gdb_list_thread_ids (uiout, &mi_error_message);
398 if (rc == GDB_RC_FAIL)
400 make_cleanup (xfree, mi_error_message);
401 error ("%s", mi_error_message);
406 mi_cmd_thread_info (char *command, char **argv, int argc)
410 if (argc != 0 && argc != 1)
411 error ("Invalid MI command");
414 thread = atoi (argv[0]);
416 print_thread_info (uiout, thread, -1);
419 struct collect_cores_data
427 collect_cores (struct thread_info *ti, void *xdata)
429 struct collect_cores_data *data = xdata;
431 if (ptid_get_pid (ti->ptid) == data->pid)
433 int core = target_core_of_thread (ti->ptid);
435 VEC_safe_push (int, data->cores, core);
442 unique (int *b, int *e)
451 struct print_one_inferior_data
454 VEC (int) *inferiors;
458 print_one_inferior (struct inferior *inferior, void *xdata)
460 struct print_one_inferior_data *top_data = xdata;
462 if (VEC_empty (int, top_data->inferiors)
463 || bsearch (&(inferior->pid), VEC_address (int, top_data->inferiors),
464 VEC_length (int, top_data->inferiors), sizeof (int),
465 compare_positive_ints))
467 struct collect_cores_data data;
468 struct cleanup *back_to
469 = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
471 ui_out_field_fmt (uiout, "id", "%d", inferior->pid);
472 ui_out_field_string (uiout, "type", "process");
473 ui_out_field_int (uiout, "pid", inferior->pid);
475 data.pid = inferior->pid;
477 iterate_over_threads (collect_cores, &data);
479 if (!VEC_empty (int, data.cores))
484 struct cleanup *back_to_2 =
485 make_cleanup_ui_out_list_begin_end (uiout, "cores");
487 qsort (VEC_address (int, data.cores),
488 VEC_length (int, data.cores), sizeof (int),
489 compare_positive_ints);
491 b = VEC_address (int, data.cores);
492 e = b + VEC_length (int, data.cores);
496 ui_out_field_int (uiout, NULL, *b);
498 do_cleanups (back_to_2);
501 if (top_data->recurse)
502 print_thread_info (uiout, -1, inferior->pid);
504 do_cleanups (back_to);
510 /* Output a field named 'cores' with a list as the value. The elements of
511 the list are obtained by splitting 'cores' on comma. */
514 output_cores (struct ui_out *uiout, const char *field_name, const char *xcores)
516 struct cleanup *back_to = make_cleanup_ui_out_list_begin_end (uiout,
518 char *cores = xstrdup (xcores);
521 make_cleanup (xfree, cores);
523 for (p = strtok (p, ","); p; p = strtok (NULL, ","))
524 ui_out_field_string (uiout, NULL, p);
526 do_cleanups (back_to);
530 free_vector_of_ints (void *xvector)
532 VEC (int) **vector = xvector;
533 VEC_free (int, *vector);
537 do_nothing (splay_tree_key k)
542 free_vector_of_osdata_items (splay_tree_value xvalue)
544 VEC (osdata_item_s) *value = (VEC (osdata_item_s) *) xvalue;
545 /* We don't free the items itself, it will be done separately. */
546 VEC_free (osdata_item_s, value);
550 splay_tree_int_comparator (splay_tree_key xa, splay_tree_key xb)
558 free_splay_tree (void *xt)
561 splay_tree_delete (t);
565 list_available_thread_groups (VEC (int) *ids, int recurse)
568 struct osdata_item *item;
570 /* This keeps a map from integer (pid) to VEC (struct osdata_item *)*
571 The vector contains information about all threads for the given pid.
572 This is assigned an initial value to avoid "may be used uninitialized"
574 splay_tree tree = NULL;
576 /* get_osdata will throw if it cannot return data. */
577 data = get_osdata ("processes");
578 make_cleanup_osdata_free (data);
582 struct osdata *threads = get_osdata ("threads");
583 make_cleanup_osdata_free (threads);
585 tree = splay_tree_new (splay_tree_int_comparator,
587 free_vector_of_osdata_items);
588 make_cleanup (free_splay_tree, tree);
591 VEC_iterate (osdata_item_s, threads->items,
595 const char *pid = get_osdata_column (item, "pid");
596 int pid_i = strtoul (pid, NULL, 0);
597 VEC (osdata_item_s) *vec = 0;
599 splay_tree_node n = splay_tree_lookup (tree, pid_i);
602 VEC_safe_push (osdata_item_s, vec, item);
603 splay_tree_insert (tree, pid_i, (splay_tree_value)vec);
607 vec = (VEC (osdata_item_s) *) n->value;
608 VEC_safe_push (osdata_item_s, vec, item);
609 n->value = (splay_tree_value) vec;
614 make_cleanup_ui_out_list_begin_end (uiout, "groups");
617 VEC_iterate (osdata_item_s, data->items,
621 struct cleanup *back_to;
623 const char *pid = get_osdata_column (item, "pid");
624 const char *cmd = get_osdata_column (item, "command");
625 const char *user = get_osdata_column (item, "user");
626 const char *cores = get_osdata_column (item, "cores");
628 int pid_i = strtoul (pid, NULL, 0);
630 /* At present, the target will return all available processes
631 and if information about specific ones was required, we filter
632 undesired processes here. */
633 if (ids && bsearch (&pid_i, VEC_address (int, ids),
634 VEC_length (int, ids),
635 sizeof (int), compare_positive_ints) == NULL)
639 back_to = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
641 ui_out_field_fmt (uiout, "id", "%s", pid);
642 ui_out_field_string (uiout, "type", "process");
644 ui_out_field_string (uiout, "description", cmd);
646 ui_out_field_string (uiout, "user", user);
648 output_cores (uiout, "cores", cores);
652 splay_tree_node n = splay_tree_lookup (tree, pid_i);
655 VEC (osdata_item_s) *children = (VEC (osdata_item_s) *) n->value;
656 struct osdata_item *child;
659 make_cleanup_ui_out_list_begin_end (uiout, "threads");
662 VEC_iterate (osdata_item_s, children, ix_child, child);
665 struct cleanup *back_to_2 =
666 make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
668 const char *tid = get_osdata_column (child, "tid");
669 const char *tcore = get_osdata_column (child, "core");
670 ui_out_field_string (uiout, "id", tid);
672 ui_out_field_string (uiout, "core", tcore);
674 do_cleanups (back_to_2);
679 do_cleanups (back_to);
684 mi_cmd_list_thread_groups (char *command, char **argv, int argc)
686 struct cleanup *back_to;
693 AVAILABLE_OPT, RECURSE_OPT
695 static struct mi_opt opts[] =
697 {"-available", AVAILABLE_OPT, 0},
698 {"-recurse", RECURSE_OPT, 1},
707 int opt = mi_getopt ("-list-thread-groups", argc, argv, opts,
711 switch ((enum opt) opt)
717 if (strcmp (optarg, "0") == 0)
719 else if (strcmp (optarg, "1") == 0)
722 error ("only '0' and '1' are valid values for the '--recurse' option");
727 for (; optind < argc; ++optind)
730 int inf = strtoul (argv[optind], &end, 0);
732 error ("invalid group id '%s'", argv[optind]);
733 VEC_safe_push (int, ids, inf);
735 if (VEC_length (int, ids) > 1)
736 qsort (VEC_address (int, ids),
737 VEC_length (int, ids),
738 sizeof (int), compare_positive_ints);
740 back_to = make_cleanup (free_vector_of_ints, &ids);
744 list_available_thread_groups (ids, recurse);
746 else if (VEC_length (int, ids) == 1)
748 /* Local thread groups, single id. */
749 int pid = *VEC_address (int, ids);
750 if (!in_inferior_list (pid))
751 error ("Invalid thread group id '%d'", pid);
752 print_thread_info (uiout, -1, pid);
756 struct print_one_inferior_data data;
757 data.recurse = recurse;
758 data.inferiors = ids;
760 /* Local thread groups. Either no explicit ids -- and we
761 print everything, or several explicit ids. In both cases,
762 we print more than one group, and have to use 'groups'
763 as the top-level element. */
764 make_cleanup_ui_out_list_begin_end (uiout, "groups");
765 update_thread_list ();
766 iterate_over_inferiors (print_one_inferior, &data);
769 do_cleanups (back_to);
773 mi_cmd_data_list_register_names (char *command, char **argv, int argc)
775 struct frame_info *frame;
776 struct gdbarch *gdbarch;
779 struct cleanup *cleanup;
781 /* Note that the test for a valid register must include checking the
782 gdbarch_register_name because gdbarch_num_regs may be allocated for
783 the union of the register sets within a family of related processors.
784 In this case, some entries of gdbarch_register_name will change depending
785 upon the particular processor being debugged. */
787 frame = get_selected_frame (NULL);
788 gdbarch = get_frame_arch (frame);
789 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
791 cleanup = make_cleanup_ui_out_list_begin_end (uiout, "register-names");
793 if (argc == 0) /* No args, just do all the regs. */
799 if (gdbarch_register_name (gdbarch, regnum) == NULL
800 || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
801 ui_out_field_string (uiout, NULL, "");
803 ui_out_field_string (uiout, NULL,
804 gdbarch_register_name (gdbarch, regnum));
808 /* Else, list of register #s, just do listed regs. */
809 for (i = 0; i < argc; i++)
811 regnum = atoi (argv[i]);
812 if (regnum < 0 || regnum >= numregs)
813 error ("bad register number");
815 if (gdbarch_register_name (gdbarch, regnum) == NULL
816 || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
817 ui_out_field_string (uiout, NULL, "");
819 ui_out_field_string (uiout, NULL,
820 gdbarch_register_name (gdbarch, regnum));
822 do_cleanups (cleanup);
826 mi_cmd_data_list_changed_registers (char *command, char **argv, int argc)
828 static struct regcache *this_regs = NULL;
829 struct regcache *prev_regs;
830 struct gdbarch *gdbarch;
831 int regnum, numregs, changed;
833 struct cleanup *cleanup;
835 /* The last time we visited this function, the current frame's register
836 contents were saved in THIS_REGS. Move THIS_REGS over to PREV_REGS,
837 and refresh THIS_REGS with the now-current register contents. */
839 prev_regs = this_regs;
840 this_regs = frame_save_as_regcache (get_selected_frame (NULL));
841 cleanup = make_cleanup_regcache_xfree (prev_regs);
843 /* Note that the test for a valid register must include checking the
844 gdbarch_register_name because gdbarch_num_regs may be allocated for
845 the union of the register sets within a family of related processors.
846 In this case, some entries of gdbarch_register_name will change depending
847 upon the particular processor being debugged. */
849 gdbarch = get_regcache_arch (this_regs);
850 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
852 make_cleanup_ui_out_list_begin_end (uiout, "changed-registers");
854 if (argc == 0) /* No args, just do all the regs. */
860 if (gdbarch_register_name (gdbarch, regnum) == NULL
861 || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
863 changed = register_changed_p (regnum, prev_regs, this_regs);
865 error ("mi_cmd_data_list_changed_registers: Unable to read register contents.");
867 ui_out_field_int (uiout, NULL, regnum);
871 /* Else, list of register #s, just do listed regs. */
872 for (i = 0; i < argc; i++)
874 regnum = atoi (argv[i]);
878 && gdbarch_register_name (gdbarch, regnum) != NULL
879 && *gdbarch_register_name (gdbarch, regnum) != '\000')
881 changed = register_changed_p (regnum, prev_regs, this_regs);
883 error ("mi_cmd_data_list_register_change: Unable to read register contents.");
885 ui_out_field_int (uiout, NULL, regnum);
888 error ("bad register number");
890 do_cleanups (cleanup);
894 register_changed_p (int regnum, struct regcache *prev_regs,
895 struct regcache *this_regs)
897 struct gdbarch *gdbarch = get_regcache_arch (this_regs);
898 gdb_byte prev_buffer[MAX_REGISTER_SIZE];
899 gdb_byte this_buffer[MAX_REGISTER_SIZE];
901 /* Registers not valid in this frame return count as unchanged. */
902 if (!regcache_valid_p (this_regs, regnum))
905 /* First time through or after gdbarch change consider all registers as
906 changed. Same for registers not valid in the previous frame. */
907 if (!prev_regs || get_regcache_arch (prev_regs) != gdbarch
908 || !regcache_valid_p (prev_regs, regnum))
911 /* Get register contents and compare. */
912 regcache_cooked_read (prev_regs, regnum, prev_buffer);
913 regcache_cooked_read (this_regs, regnum, this_buffer);
915 return memcmp (prev_buffer, this_buffer,
916 register_size (gdbarch, regnum)) != 0;
919 /* Return a list of register number and value pairs. The valid
920 arguments expected are: a letter indicating the format in which to
921 display the registers contents. This can be one of: x (hexadecimal), d
922 (decimal), N (natural), t (binary), o (octal), r (raw). After the
923 format argumetn there can be a sequence of numbers, indicating which
924 registers to fetch the content of. If the format is the only argument,
925 a list of all the registers with their values is returned. */
927 mi_cmd_data_list_register_values (char *command, char **argv, int argc)
929 struct frame_info *frame;
930 struct gdbarch *gdbarch;
931 int regnum, numregs, format;
933 struct cleanup *list_cleanup, *tuple_cleanup;
935 /* Note that the test for a valid register must include checking the
936 gdbarch_register_name because gdbarch_num_regs may be allocated for
937 the union of the register sets within a family of related processors.
938 In this case, some entries of gdbarch_register_name will change depending
939 upon the particular processor being debugged. */
942 error ("mi_cmd_data_list_register_values: Usage: -data-list-register-values <format> [<regnum1>...<regnumN>]");
944 format = (int) argv[0][0];
946 frame = get_selected_frame (NULL);
947 gdbarch = get_frame_arch (frame);
948 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
950 list_cleanup = make_cleanup_ui_out_list_begin_end (uiout, "register-values");
952 if (argc == 1) /* No args, beside the format: do all the regs. */
958 if (gdbarch_register_name (gdbarch, regnum) == NULL
959 || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
961 tuple_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
962 ui_out_field_int (uiout, "number", regnum);
963 get_register (frame, regnum, format);
964 do_cleanups (tuple_cleanup);
968 /* Else, list of register #s, just do listed regs. */
969 for (i = 1; i < argc; i++)
971 regnum = atoi (argv[i]);
975 && gdbarch_register_name (gdbarch, regnum) != NULL
976 && *gdbarch_register_name (gdbarch, regnum) != '\000')
978 tuple_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
979 ui_out_field_int (uiout, "number", regnum);
980 get_register (frame, regnum, format);
981 do_cleanups (tuple_cleanup);
984 error ("bad register number");
986 do_cleanups (list_cleanup);
989 /* Output one register's contents in the desired format. */
991 get_register (struct frame_info *frame, int regnum, int format)
993 struct gdbarch *gdbarch = get_frame_arch (frame);
994 gdb_byte buffer[MAX_REGISTER_SIZE];
999 static struct ui_stream *stb = NULL;
1001 stb = ui_out_stream_new (uiout);
1006 frame_register (frame, regnum, &optim, &lval, &addr, &realnum, buffer);
1009 error ("Optimized out");
1014 char *ptr, buf[1024];
1018 for (j = 0; j < register_size (gdbarch, regnum); j++)
1020 int idx = gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG ?
1021 j : register_size (gdbarch, regnum) - 1 - j;
1022 sprintf (ptr, "%02x", (unsigned char) buffer[idx]);
1025 ui_out_field_string (uiout, "value", buf);
1026 /*fputs_filtered (buf, gdb_stdout); */
1030 struct value_print_options opts;
1031 get_formatted_print_options (&opts, format);
1033 val_print (register_type (gdbarch, regnum), buffer, 0, 0,
1034 stb->stream, 0, &opts, current_language);
1035 ui_out_field_stream (uiout, "value", stb);
1036 ui_out_stream_delete (stb);
1040 /* Write given values into registers. The registers and values are
1041 given as pairs. The corresponding MI command is
1042 -data-write-register-values <format> [<regnum1> <value1>...<regnumN> <valueN>]*/
1044 mi_cmd_data_write_register_values (char *command, char **argv, int argc)
1046 struct regcache *regcache;
1047 struct gdbarch *gdbarch;
1051 /* Note that the test for a valid register must include checking the
1052 gdbarch_register_name because gdbarch_num_regs may be allocated for
1053 the union of the register sets within a family of related processors.
1054 In this case, some entries of gdbarch_register_name will change depending
1055 upon the particular processor being debugged. */
1057 regcache = get_current_regcache ();
1058 gdbarch = get_regcache_arch (regcache);
1059 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
1062 error ("mi_cmd_data_write_register_values: Usage: -data-write-register-values <format> [<regnum1> <value1>...<regnumN> <valueN>]");
1064 format = (int) argv[0][0];
1066 if (!target_has_registers)
1067 error ("mi_cmd_data_write_register_values: No registers.");
1070 error ("mi_cmd_data_write_register_values: No regs and values specified.");
1073 error ("mi_cmd_data_write_register_values: Regs and vals are not in pairs.");
1075 for (i = 1; i < argc; i = i + 2)
1077 int regnum = atoi (argv[i]);
1079 if (regnum >= 0 && regnum < numregs
1080 && gdbarch_register_name (gdbarch, regnum)
1081 && *gdbarch_register_name (gdbarch, regnum))
1085 /* Get the value as a number. */
1086 value = parse_and_eval_address (argv[i + 1]);
1088 /* Write it down. */
1089 regcache_cooked_write_signed (regcache, regnum, value);
1092 error ("bad register number");
1096 /* Evaluate the value of the argument. The argument is an
1097 expression. If the expression contains spaces it needs to be
1098 included in double quotes. */
1100 mi_cmd_data_evaluate_expression (char *command, char **argv, int argc)
1102 struct expression *expr;
1103 struct cleanup *old_chain = NULL;
1105 struct ui_stream *stb = NULL;
1106 struct value_print_options opts;
1108 stb = ui_out_stream_new (uiout);
1112 ui_out_stream_delete (stb);
1113 error ("mi_cmd_data_evaluate_expression: Usage: -data-evaluate-expression expression");
1116 expr = parse_expression (argv[0]);
1118 old_chain = make_cleanup (free_current_contents, &expr);
1120 val = evaluate_expression (expr);
1122 /* Print the result of the expression evaluation. */
1123 get_user_print_options (&opts);
1125 val_print (value_type (val), value_contents (val),
1126 value_embedded_offset (val), value_address (val),
1127 stb->stream, 0, &opts, current_language);
1129 ui_out_field_stream (uiout, "value", stb);
1130 ui_out_stream_delete (stb);
1132 do_cleanups (old_chain);
1135 /* DATA-MEMORY-READ:
1137 ADDR: start address of data to be dumped.
1138 WORD-FORMAT: a char indicating format for the ``word''. See
1140 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes.
1141 NR_ROW: Number of rows.
1142 NR_COL: The number of colums (words per row).
1143 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
1144 ASCHAR for unprintable characters.
1146 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
1147 displayes them. Returns:
1149 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
1152 The number of bytes read is SIZE*ROW*COL. */
1155 mi_cmd_data_read_memory (char *command, char **argv, int argc)
1157 struct gdbarch *gdbarch = get_current_arch ();
1158 struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
1164 struct type *word_type;
1177 static struct mi_opt opts[] =
1179 {"o", OFFSET_OPT, 1},
1185 int opt = mi_getopt ("mi_cmd_data_read_memory", argc, argv, opts,
1189 switch ((enum opt) opt)
1192 offset = atol (optarg);
1199 if (argc < 5 || argc > 6)
1200 error ("mi_cmd_data_read_memory: Usage: ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR].");
1202 /* Extract all the arguments. */
1204 /* Start address of the memory dump. */
1205 addr = parse_and_eval_address (argv[0]) + offset;
1206 /* The format character to use when displaying a memory word. See
1207 the ``x'' command. */
1208 word_format = argv[1][0];
1209 /* The size of the memory word. */
1210 word_size = atol (argv[2]);
1214 word_type = builtin_type (gdbarch)->builtin_int8;
1218 word_type = builtin_type (gdbarch)->builtin_int16;
1222 word_type = builtin_type (gdbarch)->builtin_int32;
1226 word_type = builtin_type (gdbarch)->builtin_int64;
1230 word_type = builtin_type (gdbarch)->builtin_int8;
1233 /* The number of rows. */
1234 nr_rows = atol (argv[3]);
1236 error ("mi_cmd_data_read_memory: invalid number of rows.");
1238 /* Number of bytes per row. */
1239 nr_cols = atol (argv[4]);
1241 error ("mi_cmd_data_read_memory: invalid number of columns.");
1243 /* The un-printable character when printing ascii. */
1249 /* Create a buffer and read it in. */
1250 total_bytes = word_size * nr_rows * nr_cols;
1251 mbuf = xcalloc (total_bytes, 1);
1252 make_cleanup (xfree, mbuf);
1254 /* Dispatch memory reads to the topmost target, not the flattened
1256 nr_bytes = target_read_until_error (current_target.beneath,
1257 TARGET_OBJECT_MEMORY, NULL, mbuf,
1260 error ("Unable to read memory.");
1262 /* Output the header information. */
1263 ui_out_field_core_addr (uiout, "addr", gdbarch, addr);
1264 ui_out_field_int (uiout, "nr-bytes", nr_bytes);
1265 ui_out_field_int (uiout, "total-bytes", total_bytes);
1266 ui_out_field_core_addr (uiout, "next-row",
1267 gdbarch, addr + word_size * nr_cols);
1268 ui_out_field_core_addr (uiout, "prev-row",
1269 gdbarch, addr - word_size * nr_cols);
1270 ui_out_field_core_addr (uiout, "next-page", gdbarch, addr + total_bytes);
1271 ui_out_field_core_addr (uiout, "prev-page", gdbarch, addr - total_bytes);
1273 /* Build the result as a two dimentional table. */
1275 struct ui_stream *stream = ui_out_stream_new (uiout);
1276 struct cleanup *cleanup_list_memory;
1279 cleanup_list_memory = make_cleanup_ui_out_list_begin_end (uiout, "memory");
1280 for (row = 0, row_byte = 0;
1282 row++, row_byte += nr_cols * word_size)
1286 struct cleanup *cleanup_tuple;
1287 struct cleanup *cleanup_list_data;
1288 struct value_print_options opts;
1290 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1291 ui_out_field_core_addr (uiout, "addr", gdbarch, addr + row_byte);
1292 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr + row_byte); */
1293 cleanup_list_data = make_cleanup_ui_out_list_begin_end (uiout, "data");
1294 get_formatted_print_options (&opts, word_format);
1295 for (col = 0, col_byte = row_byte;
1297 col++, col_byte += word_size)
1299 if (col_byte + word_size > nr_bytes)
1301 ui_out_field_string (uiout, NULL, "N/A");
1305 ui_file_rewind (stream->stream);
1306 print_scalar_formatted (mbuf + col_byte, word_type, &opts,
1307 word_asize, stream->stream);
1308 ui_out_field_stream (uiout, NULL, stream);
1311 do_cleanups (cleanup_list_data);
1315 ui_file_rewind (stream->stream);
1316 for (byte = row_byte; byte < row_byte + word_size * nr_cols; byte++)
1318 if (byte >= nr_bytes)
1320 fputc_unfiltered ('X', stream->stream);
1322 else if (mbuf[byte] < 32 || mbuf[byte] > 126)
1324 fputc_unfiltered (aschar, stream->stream);
1327 fputc_unfiltered (mbuf[byte], stream->stream);
1329 ui_out_field_stream (uiout, "ascii", stream);
1331 do_cleanups (cleanup_tuple);
1333 ui_out_stream_delete (stream);
1334 do_cleanups (cleanup_list_memory);
1336 do_cleanups (cleanups);
1339 /* DATA-MEMORY-WRITE:
1341 COLUMN_OFFSET: optional argument. Must be preceeded by '-o'. The
1342 offset from the beginning of the memory grid row where the cell to
1344 ADDR: start address of the row in the memory grid where the memory
1345 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
1346 the location to write to.
1347 FORMAT: a char indicating format for the ``word''. See
1349 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
1350 VALUE: value to be written into the memory address.
1352 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
1356 mi_cmd_data_write_memory (char *command, char **argv, int argc)
1358 struct gdbarch *gdbarch = get_current_arch ();
1359 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1363 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
1364 enough when using a compiler other than GCC. */
1367 struct cleanup *old_chain;
1375 static struct mi_opt opts[] =
1377 {"o", OFFSET_OPT, 1},
1383 int opt = mi_getopt ("mi_cmd_data_write_memory", argc, argv, opts,
1387 switch ((enum opt) opt)
1390 offset = atol (optarg);
1398 error ("mi_cmd_data_write_memory: Usage: [-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE.");
1400 /* Extract all the arguments. */
1401 /* Start address of the memory dump. */
1402 addr = parse_and_eval_address (argv[0]);
1403 /* The format character to use when displaying a memory word. See
1404 the ``x'' command. */
1405 word_format = argv[1][0];
1406 /* The size of the memory word. */
1407 word_size = atol (argv[2]);
1409 /* Calculate the real address of the write destination. */
1410 addr += (offset * word_size);
1412 /* Get the value as a number. */
1413 value = parse_and_eval_address (argv[3]);
1414 /* Get the value into an array. */
1415 buffer = xmalloc (word_size);
1416 old_chain = make_cleanup (xfree, buffer);
1417 store_signed_integer (buffer, word_size, byte_order, value);
1418 /* Write it down to memory. */
1419 write_memory (addr, buffer, word_size);
1420 /* Free the buffer. */
1421 do_cleanups (old_chain);
1425 mi_cmd_enable_timings (char *command, char **argv, int argc)
1431 if (strcmp (argv[0], "yes") == 0)
1433 else if (strcmp (argv[0], "no") == 0)
1444 error ("mi_cmd_enable_timings: Usage: %s {yes|no}", command);
1448 mi_cmd_list_features (char *command, char **argv, int argc)
1452 struct cleanup *cleanup = NULL;
1453 cleanup = make_cleanup_ui_out_list_begin_end (uiout, "features");
1455 ui_out_field_string (uiout, NULL, "frozen-varobjs");
1456 ui_out_field_string (uiout, NULL, "pending-breakpoints");
1457 ui_out_field_string (uiout, NULL, "thread-info");
1460 ui_out_field_string (uiout, NULL, "python");
1463 do_cleanups (cleanup);
1467 error ("-list-features should be passed no arguments");
1471 mi_cmd_list_target_features (char *command, char **argv, int argc)
1475 struct cleanup *cleanup = NULL;
1476 cleanup = make_cleanup_ui_out_list_begin_end (uiout, "features");
1478 if (target_can_async_p ())
1479 ui_out_field_string (uiout, NULL, "async");
1481 do_cleanups (cleanup);
1485 error ("-list-target-features should be passed no arguments");
1488 /* Execute a command within a safe environment.
1489 Return <0 for error; >=0 for ok.
1491 args->action will tell mi_execute_command what action
1492 to perfrom after the given command has executed (display/suppress
1493 prompt, display error). */
1496 captured_mi_execute_command (struct ui_out *uiout, void *data)
1498 struct cleanup *cleanup;
1499 struct mi_parse *context = (struct mi_parse *) data;
1502 current_command_ts = context->cmd_start;
1504 current_token = xstrdup (context->token);
1505 cleanup = make_cleanup (free_current_contents, ¤t_token);
1507 running_result_record_printed = 0;
1509 switch (context->op)
1512 /* A MI command was read from the input stream. */
1514 /* FIXME: gdb_???? */
1515 fprintf_unfiltered (raw_stdout, " token=`%s' command=`%s' args=`%s'\n",
1516 context->token, context->command, context->args);
1519 mi_cmd_execute (context);
1521 /* Print the result if there were no errors.
1523 Remember that on the way out of executing a command, you have
1524 to directly use the mi_interp's uiout, since the command could
1525 have reset the interpreter, in which case the current uiout
1526 will most likely crash in the mi_out_* routines. */
1527 if (!running_result_record_printed)
1529 fputs_unfiltered (context->token, raw_stdout);
1530 /* There's no particularly good reason why target-connect results
1531 in not ^done. Should kill ^connected for MI3. */
1532 fputs_unfiltered (strcmp (context->command, "target-select") == 0
1533 ? "^connected" : "^done", raw_stdout);
1534 mi_out_put (uiout, raw_stdout);
1535 mi_out_rewind (uiout);
1536 mi_print_timing_maybe ();
1537 fputs_unfiltered ("\n", raw_stdout);
1540 /* The command does not want anything to be printed. In that
1541 case, the command probably should not have written anything
1542 to uiout, but in case it has written something, discard it. */
1543 mi_out_rewind (uiout);
1549 /* A CLI command was read from the input stream. */
1550 /* This "feature" will be removed as soon as we have a
1551 complete set of mi commands. */
1552 /* Echo the command on the console. */
1553 fprintf_unfiltered (gdb_stdlog, "%s\n", context->command);
1554 /* Call the "console" interpreter. */
1555 argv[0] = "console";
1556 argv[1] = context->command;
1557 mi_cmd_interpreter_exec ("-interpreter-exec", argv, 2);
1559 /* If we changed interpreters, DON'T print out anything. */
1560 if (current_interp_named_p (INTERP_MI)
1561 || current_interp_named_p (INTERP_MI1)
1562 || current_interp_named_p (INTERP_MI2)
1563 || current_interp_named_p (INTERP_MI3))
1565 if (!running_result_record_printed)
1567 fputs_unfiltered (context->token, raw_stdout);
1568 fputs_unfiltered ("^done", raw_stdout);
1569 mi_out_put (uiout, raw_stdout);
1570 mi_out_rewind (uiout);
1571 mi_print_timing_maybe ();
1572 fputs_unfiltered ("\n", raw_stdout);
1575 mi_out_rewind (uiout);
1582 do_cleanups (cleanup);
1589 mi_execute_command (char *cmd, int from_tty)
1591 struct mi_parse *command;
1592 struct ui_out *saved_uiout = uiout;
1594 /* This is to handle EOF (^D). We just quit gdb. */
1595 /* FIXME: we should call some API function here. */
1597 quit_force (NULL, from_tty);
1599 target_log_command (cmd);
1601 command = mi_parse (cmd);
1603 if (command != NULL)
1605 struct gdb_exception result;
1606 ptid_t previous_ptid = inferior_ptid;
1610 command->cmd_start = (struct mi_timestamp *)
1611 xmalloc (sizeof (struct mi_timestamp));
1612 timestamp (command->cmd_start);
1615 result = catch_exception (uiout, captured_mi_execute_command, command,
1617 if (result.reason < 0)
1619 /* The command execution failed and error() was called
1621 fputs_unfiltered (command->token, raw_stdout);
1622 fputs_unfiltered ("^error,msg=\"", raw_stdout);
1623 if (result.message == NULL)
1624 fputs_unfiltered ("unknown error", raw_stdout);
1626 fputstr_unfiltered (result.message, '"', raw_stdout);
1627 fputs_unfiltered ("\"\n", raw_stdout);
1628 mi_out_rewind (uiout);
1631 bpstat_do_actions ();
1633 if (/* The notifications are only output when the top-level
1634 interpreter (specified on the command line) is MI. */
1635 ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ()))
1636 /* Don't try report anything if there are no threads --
1637 the program is dead. */
1638 && thread_count () != 0
1639 /* -thread-select explicitly changes thread. If frontend uses that
1640 internally, we don't want to emit =thread-selected, since
1641 =thread-selected is supposed to indicate user's intentions. */
1642 && strcmp (command->command, "thread-select") != 0)
1644 struct mi_interp *mi = top_level_interpreter_data ();
1645 int report_change = 0;
1647 if (command->thread == -1)
1649 report_change = (!ptid_equal (previous_ptid, null_ptid)
1650 && !ptid_equal (inferior_ptid, previous_ptid)
1651 && !ptid_equal (inferior_ptid, null_ptid));
1653 else if (!ptid_equal (inferior_ptid, null_ptid))
1655 struct thread_info *ti = inferior_thread ();
1656 report_change = (ti->num != command->thread);
1661 struct thread_info *ti = inferior_thread ();
1662 target_terminal_ours ();
1663 fprintf_unfiltered (mi->event_channel,
1664 "thread-selected,id=\"%d\"",
1666 gdb_flush (mi->event_channel);
1670 mi_parse_free (command);
1673 fputs_unfiltered ("(gdb) \n", raw_stdout);
1674 gdb_flush (raw_stdout);
1675 /* Print any buffered hook code. */
1680 mi_cmd_execute (struct mi_parse *parse)
1682 struct cleanup *cleanup;
1685 prepare_execute_command ();
1687 cleanup = make_cleanup (null_cleanup, NULL);
1689 if (parse->frame != -1 && parse->thread == -1)
1690 error (_("Cannot specify --frame without --thread"));
1692 if (parse->thread != -1)
1694 struct thread_info *tp = find_thread_id (parse->thread);
1696 error (_("Invalid thread id: %d"), parse->thread);
1698 if (is_exited (tp->ptid))
1699 error (_("Thread id: %d has terminated"), parse->thread);
1701 switch_to_thread (tp->ptid);
1704 if (parse->frame != -1)
1706 struct frame_info *fid;
1707 int frame = parse->frame;
1708 fid = find_relative_frame (get_current_frame (), &frame);
1710 /* find_relative_frame was successful */
1713 error (_("Invalid frame id: %d"), frame);
1716 if (parse->cmd->argv_func != NULL)
1717 parse->cmd->argv_func (parse->command, parse->argv, parse->argc);
1718 else if (parse->cmd->cli.cmd != 0)
1720 /* FIXME: DELETE THIS. */
1721 /* The operation is still implemented by a cli command. */
1722 /* Must be a synchronous one. */
1723 mi_execute_cli_command (parse->cmd->cli.cmd, parse->cmd->cli.args_p,
1728 /* FIXME: DELETE THIS. */
1729 struct ui_file *stb;
1731 stb = mem_fileopen ();
1733 fputs_unfiltered ("Undefined mi command: ", stb);
1734 fputstr_unfiltered (parse->command, '"', stb);
1735 fputs_unfiltered (" (missing implementation)", stb);
1737 make_cleanup_ui_file_delete (stb);
1740 do_cleanups (cleanup);
1743 /* FIXME: This is just a hack so we can get some extra commands going.
1744 We don't want to channel things through the CLI, but call libgdb directly.
1745 Use only for synchronous commands. */
1748 mi_execute_cli_command (const char *cmd, int args_p, const char *args)
1752 struct cleanup *old_cleanups;
1755 run = xstrprintf ("%s %s", cmd, args);
1757 run = xstrdup (cmd);
1759 /* FIXME: gdb_???? */
1760 fprintf_unfiltered (gdb_stdout, "cli=%s run=%s\n",
1762 old_cleanups = make_cleanup (xfree, run);
1763 execute_command ( /*ui */ run, 0 /*from_tty */ );
1764 do_cleanups (old_cleanups);
1770 mi_execute_async_cli_command (char *cli_command, char **argv, int argc)
1772 struct cleanup *old_cleanups;
1775 if (target_can_async_p ())
1776 run = xstrprintf ("%s %s&", cli_command, argc ? *argv : "");
1778 run = xstrprintf ("%s %s", cli_command, argc ? *argv : "");
1779 old_cleanups = make_cleanup (xfree, run);
1781 execute_command ( /*ui */ run, 0 /*from_tty */ );
1783 if (target_can_async_p ())
1785 /* If we're not executing, an exception should have been throw. */
1786 gdb_assert (is_running (inferior_ptid));
1787 do_cleanups (old_cleanups);
1791 /* Do this before doing any printing. It would appear that some
1792 print code leaves garbage around in the buffer. */
1793 do_cleanups (old_cleanups);
1798 mi_load_progress (const char *section_name,
1799 unsigned long sent_so_far,
1800 unsigned long total_section,
1801 unsigned long total_sent,
1802 unsigned long grand_total)
1804 struct timeval time_now, delta, update_threshold;
1805 static struct timeval last_update;
1806 static char *previous_sect_name = NULL;
1808 struct ui_out *saved_uiout;
1810 /* This function is called through deprecated_show_load_progress
1811 which means uiout may not be correct. Fix it for the duration
1812 of this function. */
1813 saved_uiout = uiout;
1815 if (current_interp_named_p (INTERP_MI)
1816 || current_interp_named_p (INTERP_MI2))
1817 uiout = mi_out_new (2);
1818 else if (current_interp_named_p (INTERP_MI1))
1819 uiout = mi_out_new (1);
1820 else if (current_interp_named_p (INTERP_MI3))
1821 uiout = mi_out_new (3);
1825 update_threshold.tv_sec = 0;
1826 update_threshold.tv_usec = 500000;
1827 gettimeofday (&time_now, NULL);
1829 delta.tv_usec = time_now.tv_usec - last_update.tv_usec;
1830 delta.tv_sec = time_now.tv_sec - last_update.tv_sec;
1832 if (delta.tv_usec < 0)
1835 delta.tv_usec += 1000000L;
1838 new_section = (previous_sect_name ?
1839 strcmp (previous_sect_name, section_name) : 1);
1842 struct cleanup *cleanup_tuple;
1843 xfree (previous_sect_name);
1844 previous_sect_name = xstrdup (section_name);
1847 fputs_unfiltered (current_token, raw_stdout);
1848 fputs_unfiltered ("+download", raw_stdout);
1849 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1850 ui_out_field_string (uiout, "section", section_name);
1851 ui_out_field_int (uiout, "section-size", total_section);
1852 ui_out_field_int (uiout, "total-size", grand_total);
1853 do_cleanups (cleanup_tuple);
1854 mi_out_put (uiout, raw_stdout);
1855 fputs_unfiltered ("\n", raw_stdout);
1856 gdb_flush (raw_stdout);
1859 if (delta.tv_sec >= update_threshold.tv_sec &&
1860 delta.tv_usec >= update_threshold.tv_usec)
1862 struct cleanup *cleanup_tuple;
1863 last_update.tv_sec = time_now.tv_sec;
1864 last_update.tv_usec = time_now.tv_usec;
1866 fputs_unfiltered (current_token, raw_stdout);
1867 fputs_unfiltered ("+download", raw_stdout);
1868 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1869 ui_out_field_string (uiout, "section", section_name);
1870 ui_out_field_int (uiout, "section-sent", sent_so_far);
1871 ui_out_field_int (uiout, "section-size", total_section);
1872 ui_out_field_int (uiout, "total-sent", total_sent);
1873 ui_out_field_int (uiout, "total-size", grand_total);
1874 do_cleanups (cleanup_tuple);
1875 mi_out_put (uiout, raw_stdout);
1876 fputs_unfiltered ("\n", raw_stdout);
1877 gdb_flush (raw_stdout);
1881 uiout = saved_uiout;
1885 timestamp (struct mi_timestamp *tv)
1888 gettimeofday (&tv->wallclock, NULL);
1889 #ifdef HAVE_GETRUSAGE
1890 getrusage (RUSAGE_SELF, &rusage);
1891 tv->utime.tv_sec = rusage.ru_utime.tv_sec;
1892 tv->utime.tv_usec = rusage.ru_utime.tv_usec;
1893 tv->stime.tv_sec = rusage.ru_stime.tv_sec;
1894 tv->stime.tv_usec = rusage.ru_stime.tv_usec;
1896 usec = get_run_time ();
1897 tv->utime.tv_sec = usec/1000000L;
1898 tv->utime.tv_usec = usec - 1000000L*tv->utime.tv_sec;
1899 tv->stime.tv_sec = 0;
1900 tv->stime.tv_usec = 0;
1905 print_diff_now (struct mi_timestamp *start)
1907 struct mi_timestamp now;
1909 print_diff (start, &now);
1913 mi_print_timing_maybe (void)
1915 /* If the command is -enable-timing then do_timings may be
1916 true whilst current_command_ts is not initialized. */
1917 if (do_timings && current_command_ts)
1918 print_diff_now (current_command_ts);
1922 timeval_diff (struct timeval start, struct timeval end)
1924 return ((end.tv_sec - start.tv_sec) * 1000000L)
1925 + (end.tv_usec - start.tv_usec);
1929 print_diff (struct mi_timestamp *start, struct mi_timestamp *end)
1933 ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
1934 timeval_diff (start->wallclock, end->wallclock) / 1000000.0,
1935 timeval_diff (start->utime, end->utime) / 1000000.0,
1936 timeval_diff (start->stime, end->stime) / 1000000.0);