3 Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008
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. */
28 #include "gdb_string.h"
29 #include "exceptions.h"
31 #include "gdbthread.h"
34 #include "mi-getopt.h"
35 #include "mi-console.h"
39 #include "event-loop.h"
40 #include "event-top.h"
41 #include "gdbcore.h" /* For write_memory(). */
47 #include "mi-common.h"
56 #if defined HAVE_SYS_RESOURCE_H
57 #include <sys/resource.h>
70 struct ui_file *raw_stdout;
72 /* This is used to pass the current command timestamp
73 down to continuation routines. */
74 static struct mi_timestamp *current_command_ts;
76 static int do_timings = 0;
79 int running_result_record_printed = 1;
81 extern void _initialize_mi_main (void);
82 static void mi_cmd_execute (struct mi_parse *parse);
84 static void mi_execute_cli_command (const char *cmd, int args_p,
86 static void mi_execute_async_cli_command (char *cli_command,
87 char **argv, int argc);
88 static int register_changed_p (int regnum, struct regcache *,
90 static void get_register (int regnum, int format);
92 /* Command implementations. FIXME: Is this libgdb? No. This is the MI
93 layer that calls libgdb. Any operation used in the below should be
96 static void timestamp (struct mi_timestamp *tv);
98 static void print_diff_now (struct mi_timestamp *start);
99 static void print_diff (struct mi_timestamp *start, struct mi_timestamp *end);
102 mi_cmd_gdb_exit (char *command, char **argv, int argc)
104 /* We have to print everything right here because we never return. */
106 fputs_unfiltered (current_token, raw_stdout);
107 fputs_unfiltered ("^exit\n", raw_stdout);
108 mi_out_put (uiout, raw_stdout);
109 /* FIXME: The function called is not yet a formal libgdb function. */
110 quit_force (NULL, FROM_TTY);
114 mi_cmd_exec_next (char *command, char **argv, int argc)
116 /* FIXME: Should call a libgdb function, not a cli wrapper. */
117 mi_execute_async_cli_command ("next", argv, argc);
121 mi_cmd_exec_next_instruction (char *command, char **argv, int argc)
123 /* FIXME: Should call a libgdb function, not a cli wrapper. */
124 mi_execute_async_cli_command ("nexti", argv, argc);
128 mi_cmd_exec_step (char *command, char **argv, int argc)
130 /* FIXME: Should call a libgdb function, not a cli wrapper. */
131 mi_execute_async_cli_command ("step", argv, argc);
135 mi_cmd_exec_step_instruction (char *command, char **argv, int argc)
137 /* FIXME: Should call a libgdb function, not a cli wrapper. */
138 mi_execute_async_cli_command ("stepi", argv, argc);
142 mi_cmd_exec_finish (char *command, char **argv, int argc)
144 /* FIXME: Should call a libgdb function, not a cli wrapper. */
145 mi_execute_async_cli_command ("finish", argv, argc);
149 mi_cmd_exec_return (char *command, char **argv, int argc)
151 /* This command doesn't really execute the target, it just pops the
152 specified number of frames. */
154 /* Call return_command with from_tty argument equal to 0 so as to
155 avoid being queried. */
156 return_command (*argv, 0);
158 /* Call return_command with from_tty argument equal to 0 so as to
159 avoid being queried. */
160 return_command (NULL, 0);
162 /* Because we have called return_command with from_tty = 0, we need
163 to print the frame here. */
164 print_stack_frame (get_selected_frame (NULL), 1, LOC_AND_ADDRESS);
168 proceed_thread_callback (struct thread_info *thread, void *arg)
170 int pid = *(int *)arg;
172 if (!is_stopped (thread->ptid))
175 if (PIDGET (thread->ptid) != pid)
178 switch_to_thread (thread->ptid);
179 clear_proceed_status ();
180 proceed ((CORE_ADDR) -1, TARGET_SIGNAL_DEFAULT, 0);
185 mi_cmd_exec_continue (char *command, char **argv, int argc)
189 else if (argc == 1 && strcmp (argv[0], "--all") == 0)
191 else if (argc == 2 && strcmp (argv[0], "--thread-group") == 0)
193 struct cleanup *old_chain;
195 if (argv[1] == NULL || argv[1] == '\0')
196 error ("Thread group id not specified");
197 pid = atoi (argv[1] + 1);
198 if (!in_inferior_list (pid))
199 error ("Invalid thread group id '%s'", argv[1]);
201 old_chain = make_cleanup_restore_current_thread ();
202 iterate_over_threads (proceed_thread_callback, &pid);
203 do_cleanups (old_chain);
206 error ("Usage: -exec-continue [--all|--thread-group id]");
210 interrupt_thread_callback (struct thread_info *thread, void *arg)
212 int pid = *(int *)arg;
214 if (!is_running (thread->ptid))
217 if (PIDGET (thread->ptid) != pid)
220 target_stop (thread->ptid);
224 /* Interrupt the execution of the target. Note how we must play around
225 with the token variables, in order to display the current token in
226 the result of the interrupt command, and the previous execution
227 token when the target finally stops. See comments in
230 mi_cmd_exec_interrupt (char *command, char **argv, int argc)
234 if (!is_running (inferior_ptid))
235 error ("Current thread is not running.");
237 interrupt_target_1 (0);
239 else if (argc == 1 && strcmp (argv[0], "--all") == 0)
242 error ("Inferior not running.");
244 interrupt_target_1 (1);
246 else if (argc == 2 && strcmp (argv[0], "--thread-group") == 0)
248 struct cleanup *old_chain;
250 if (argv[1] == NULL || argv[1] == '\0')
251 error ("Thread group id not specified");
252 pid = atoi (argv[1] + 1);
253 if (!in_inferior_list (pid))
254 error ("Invalid thread group id '%s'", argv[1]);
256 old_chain = make_cleanup_restore_current_thread ();
257 iterate_over_threads (interrupt_thread_callback, &pid);
258 do_cleanups (old_chain);
261 error ("Usage: -exec-interrupt [--all|--thread-group id]");
265 find_thread_of_process (struct thread_info *ti, void *p)
268 if (PIDGET (ti->ptid) == pid && !is_exited (ti->ptid))
275 mi_cmd_target_detach (char *command, char **argv, int argc)
277 if (argc != 0 && argc != 1)
278 error ("Usage: -target-detach [thread-group]");
282 struct thread_info *tp;
284 int pid = strtol (argv[0], &end, 10);
286 error (_("Cannot parse thread group id '%s'"), argv[0]);
288 /* Pick any thread in the desired process. Current
289 target_detach deteches from the parent of inferior_ptid. */
290 tp = iterate_over_threads (find_thread_of_process, &pid);
292 error (_("Thread group is empty"));
294 switch_to_thread (tp->ptid);
297 detach_command (NULL, 0);
301 mi_cmd_thread_select (char *command, char **argv, int argc)
304 char *mi_error_message;
307 error ("mi_cmd_thread_select: USAGE: threadnum.");
309 rc = gdb_thread_select (uiout, argv[0], &mi_error_message);
311 if (rc == GDB_RC_FAIL)
313 make_cleanup (xfree, mi_error_message);
314 error ("%s", mi_error_message);
319 mi_cmd_thread_list_ids (char *command, char **argv, int argc)
322 char *mi_error_message;
325 error ("mi_cmd_thread_list_ids: No arguments required.");
327 rc = gdb_list_thread_ids (uiout, &mi_error_message);
329 if (rc == GDB_RC_FAIL)
331 make_cleanup (xfree, mi_error_message);
332 error ("%s", mi_error_message);
337 mi_cmd_thread_info (char *command, char **argv, int argc)
341 if (argc != 0 && argc != 1)
342 error ("Invalid MI command");
345 thread = atoi (argv[0]);
347 print_thread_info (uiout, thread, -1);
351 print_one_inferior (struct inferior *inferior, void *arg)
353 struct cleanup *back_to = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
355 ui_out_field_fmt (uiout, "id", "%d", inferior->pid);
356 ui_out_field_string (uiout, "type", "process");
357 ui_out_field_int (uiout, "pid", inferior->pid);
359 do_cleanups (back_to);
364 mi_cmd_list_thread_groups (char *command, char **argv, int argc)
366 struct cleanup *back_to;
370 if (argc > 0 && strcmp (argv[0], "--available") == 0)
380 back_to = make_cleanup (&null_cleanup, NULL);
384 error (_("Can only report top-level available thread groups"));
388 struct osdata *data = get_osdata ("processes");
389 struct osdata_item *item;
392 make_cleanup_ui_out_list_begin_end (uiout, "groups");
395 VEC_iterate (osdata_item_s, data->items,
399 struct cleanup *back_to =
400 make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
402 const char *pid = get_osdata_column (item, "pid");
403 const char *cmd = get_osdata_column (item, "command");
404 const char *user = get_osdata_column (item, "user");
406 ui_out_field_fmt (uiout, "id", "%s", pid);
407 ui_out_field_string (uiout, "type", "process");
409 ui_out_field_string (uiout, "description", cmd);
411 ui_out_field_string (uiout, "user", user);
413 do_cleanups (back_to);
419 if (!in_inferior_list (pid))
420 error ("Invalid thread group id '%s'", id);
421 print_thread_info (uiout, -1, pid);
425 make_cleanup_ui_out_list_begin_end (uiout, "groups");
426 iterate_over_inferiors (print_one_inferior, NULL);
429 do_cleanups (back_to);
433 mi_cmd_data_list_register_names (char *command, char **argv, int argc)
437 struct cleanup *cleanup;
439 /* Note that the test for a valid register must include checking the
440 gdbarch_register_name because gdbarch_num_regs may be allocated for
441 the union of the register sets within a family of related processors.
442 In this case, some entries of gdbarch_register_name will change depending
443 upon the particular processor being debugged. */
445 numregs = gdbarch_num_regs (current_gdbarch)
446 + gdbarch_num_pseudo_regs (current_gdbarch);
448 cleanup = make_cleanup_ui_out_list_begin_end (uiout, "register-names");
450 if (argc == 0) /* No args, just do all the regs. */
456 if (gdbarch_register_name (current_gdbarch, regnum) == NULL
457 || *(gdbarch_register_name (current_gdbarch, regnum)) == '\0')
458 ui_out_field_string (uiout, NULL, "");
460 ui_out_field_string (uiout, NULL,
461 gdbarch_register_name
462 (current_gdbarch, regnum));
466 /* Else, list of register #s, just do listed regs. */
467 for (i = 0; i < argc; i++)
469 regnum = atoi (argv[i]);
470 if (regnum < 0 || regnum >= numregs)
471 error ("bad register number");
473 if (gdbarch_register_name (current_gdbarch, regnum) == NULL
474 || *(gdbarch_register_name (current_gdbarch, regnum)) == '\0')
475 ui_out_field_string (uiout, NULL, "");
477 ui_out_field_string (uiout, NULL,
478 gdbarch_register_name (current_gdbarch, regnum));
480 do_cleanups (cleanup);
484 mi_cmd_data_list_changed_registers (char *command, char **argv, int argc)
486 static struct regcache *this_regs = NULL;
487 struct regcache *prev_regs;
488 int regnum, numregs, changed;
490 struct cleanup *cleanup;
492 /* The last time we visited this function, the current frame's register
493 contents were saved in THIS_REGS. Move THIS_REGS over to PREV_REGS,
494 and refresh THIS_REGS with the now-current register contents. */
496 prev_regs = this_regs;
497 this_regs = frame_save_as_regcache (get_selected_frame (NULL));
498 cleanup = make_cleanup_regcache_xfree (prev_regs);
500 /* Note that the test for a valid register must include checking the
501 gdbarch_register_name because gdbarch_num_regs may be allocated for
502 the union of the register sets within a family of related processors.
503 In this case, some entries of gdbarch_register_name will change depending
504 upon the particular processor being debugged. */
506 numregs = gdbarch_num_regs (current_gdbarch)
507 + gdbarch_num_pseudo_regs (current_gdbarch);
509 make_cleanup_ui_out_list_begin_end (uiout, "changed-registers");
511 if (argc == 0) /* No args, just do all the regs. */
517 if (gdbarch_register_name (current_gdbarch, regnum) == NULL
518 || *(gdbarch_register_name (current_gdbarch, regnum)) == '\0')
520 changed = register_changed_p (regnum, prev_regs, this_regs);
522 error ("mi_cmd_data_list_changed_registers: Unable to read register contents.");
524 ui_out_field_int (uiout, NULL, regnum);
528 /* Else, list of register #s, just do listed regs. */
529 for (i = 0; i < argc; i++)
531 regnum = atoi (argv[i]);
535 && gdbarch_register_name (current_gdbarch, regnum) != NULL
536 && *gdbarch_register_name (current_gdbarch, regnum) != '\000')
538 changed = register_changed_p (regnum, prev_regs, this_regs);
540 error ("mi_cmd_data_list_register_change: Unable to read register contents.");
542 ui_out_field_int (uiout, NULL, regnum);
545 error ("bad register number");
547 do_cleanups (cleanup);
551 register_changed_p (int regnum, struct regcache *prev_regs,
552 struct regcache *this_regs)
554 struct gdbarch *gdbarch = get_regcache_arch (this_regs);
555 gdb_byte prev_buffer[MAX_REGISTER_SIZE];
556 gdb_byte this_buffer[MAX_REGISTER_SIZE];
558 /* Registers not valid in this frame return count as unchanged. */
559 if (!regcache_valid_p (this_regs, regnum))
562 /* First time through or after gdbarch change consider all registers as
563 changed. Same for registers not valid in the previous frame. */
564 if (!prev_regs || get_regcache_arch (prev_regs) != gdbarch
565 || !regcache_valid_p (prev_regs, regnum))
568 /* Get register contents and compare. */
569 regcache_cooked_read (prev_regs, regnum, prev_buffer);
570 regcache_cooked_read (this_regs, regnum, this_buffer);
572 return memcmp (prev_buffer, this_buffer,
573 register_size (gdbarch, regnum)) != 0;
576 /* Return a list of register number and value pairs. The valid
577 arguments expected are: a letter indicating the format in which to
578 display the registers contents. This can be one of: x (hexadecimal), d
579 (decimal), N (natural), t (binary), o (octal), r (raw). After the
580 format argumetn there can be a sequence of numbers, indicating which
581 registers to fetch the content of. If the format is the only argument,
582 a list of all the registers with their values is returned. */
584 mi_cmd_data_list_register_values (char *command, char **argv, int argc)
586 int regnum, numregs, format;
588 struct cleanup *list_cleanup, *tuple_cleanup;
590 /* Note that the test for a valid register must include checking the
591 gdbarch_register_name because gdbarch_num_regs may be allocated for
592 the union of the register sets within a family of related processors.
593 In this case, some entries of gdbarch_register_name will change depending
594 upon the particular processor being debugged. */
596 numregs = gdbarch_num_regs (current_gdbarch)
597 + gdbarch_num_pseudo_regs (current_gdbarch);
600 error ("mi_cmd_data_list_register_values: Usage: -data-list-register-values <format> [<regnum1>...<regnumN>]");
602 format = (int) argv[0][0];
604 list_cleanup = make_cleanup_ui_out_list_begin_end (uiout, "register-values");
606 if (argc == 1) /* No args, beside the format: do all the regs. */
612 if (gdbarch_register_name (current_gdbarch, regnum) == NULL
613 || *(gdbarch_register_name (current_gdbarch, regnum)) == '\0')
615 tuple_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
616 ui_out_field_int (uiout, "number", regnum);
617 get_register (regnum, format);
618 do_cleanups (tuple_cleanup);
622 /* Else, list of register #s, just do listed regs. */
623 for (i = 1; i < argc; i++)
625 regnum = atoi (argv[i]);
629 && gdbarch_register_name (current_gdbarch, regnum) != NULL
630 && *gdbarch_register_name (current_gdbarch, regnum) != '\000')
632 tuple_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
633 ui_out_field_int (uiout, "number", regnum);
634 get_register (regnum, format);
635 do_cleanups (tuple_cleanup);
638 error ("bad register number");
640 do_cleanups (list_cleanup);
643 /* Output one register's contents in the desired format. */
645 get_register (int regnum, int format)
647 gdb_byte buffer[MAX_REGISTER_SIZE];
652 static struct ui_stream *stb = NULL;
654 stb = ui_out_stream_new (uiout);
659 frame_register (get_selected_frame (NULL), regnum, &optim, &lval, &addr,
663 error ("Optimized out");
668 char *ptr, buf[1024];
672 for (j = 0; j < register_size (current_gdbarch, regnum); j++)
674 int idx = gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG ? j
675 : register_size (current_gdbarch, regnum) - 1 - j;
676 sprintf (ptr, "%02x", (unsigned char) buffer[idx]);
679 ui_out_field_string (uiout, "value", buf);
680 /*fputs_filtered (buf, gdb_stdout); */
684 struct value_print_options opts;
685 get_formatted_print_options (&opts, format);
687 val_print (register_type (current_gdbarch, regnum), buffer, 0, 0,
688 stb->stream, 0, &opts, current_language);
689 ui_out_field_stream (uiout, "value", stb);
690 ui_out_stream_delete (stb);
694 /* Write given values into registers. The registers and values are
695 given as pairs. The corresponding MI command is
696 -data-write-register-values <format> [<regnum1> <value1>...<regnumN> <valueN>]*/
698 mi_cmd_data_write_register_values (char *command, char **argv, int argc)
703 /* Note that the test for a valid register must include checking the
704 gdbarch_register_name because gdbarch_num_regs may be allocated for
705 the union of the register sets within a family of related processors.
706 In this case, some entries of gdbarch_register_name will change depending
707 upon the particular processor being debugged. */
709 numregs = gdbarch_num_regs (current_gdbarch)
710 + gdbarch_num_pseudo_regs (current_gdbarch);
713 error ("mi_cmd_data_write_register_values: Usage: -data-write-register-values <format> [<regnum1> <value1>...<regnumN> <valueN>]");
715 format = (int) argv[0][0];
717 if (!target_has_registers)
718 error ("mi_cmd_data_write_register_values: No registers.");
721 error ("mi_cmd_data_write_register_values: No regs and values specified.");
724 error ("mi_cmd_data_write_register_values: Regs and vals are not in pairs.");
726 for (i = 1; i < argc; i = i + 2)
728 int regnum = atoi (argv[i]);
730 if (regnum >= 0 && regnum < numregs
731 && gdbarch_register_name (current_gdbarch, regnum)
732 && *gdbarch_register_name (current_gdbarch, regnum))
736 /* Get the value as a number. */
737 value = parse_and_eval_address (argv[i + 1]);
740 regcache_cooked_write_signed (get_current_regcache (), regnum, value);
743 error ("bad register number");
747 /* Evaluate the value of the argument. The argument is an
748 expression. If the expression contains spaces it needs to be
749 included in double quotes. */
751 mi_cmd_data_evaluate_expression (char *command, char **argv, int argc)
753 struct expression *expr;
754 struct cleanup *old_chain = NULL;
756 struct ui_stream *stb = NULL;
757 struct value_print_options opts;
759 stb = ui_out_stream_new (uiout);
763 ui_out_stream_delete (stb);
764 error ("mi_cmd_data_evaluate_expression: Usage: -data-evaluate-expression expression");
767 expr = parse_expression (argv[0]);
769 old_chain = make_cleanup (free_current_contents, &expr);
771 val = evaluate_expression (expr);
773 /* Print the result of the expression evaluation. */
774 get_user_print_options (&opts);
776 val_print (value_type (val), value_contents (val),
777 value_embedded_offset (val), VALUE_ADDRESS (val),
778 stb->stream, 0, &opts, current_language);
780 ui_out_field_stream (uiout, "value", stb);
781 ui_out_stream_delete (stb);
783 do_cleanups (old_chain);
788 ADDR: start address of data to be dumped.
789 WORD-FORMAT: a char indicating format for the ``word''. See
791 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes.
792 NR_ROW: Number of rows.
793 NR_COL: The number of colums (words per row).
794 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
795 ASCHAR for unprintable characters.
797 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
798 displayes them. Returns:
800 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
803 The number of bytes read is SIZE*ROW*COL. */
806 mi_cmd_data_read_memory (char *command, char **argv, int argc)
808 struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
814 struct type *word_type;
827 static struct mi_opt opts[] =
829 {"o", OFFSET_OPT, 1},
835 int opt = mi_getopt ("mi_cmd_data_read_memory", argc, argv, opts,
839 switch ((enum opt) opt)
842 offset = atol (optarg);
849 if (argc < 5 || argc > 6)
850 error ("mi_cmd_data_read_memory: Usage: ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR].");
852 /* Extract all the arguments. */
854 /* Start address of the memory dump. */
855 addr = parse_and_eval_address (argv[0]) + offset;
856 /* The format character to use when displaying a memory word. See
857 the ``x'' command. */
858 word_format = argv[1][0];
859 /* The size of the memory word. */
860 word_size = atol (argv[2]);
864 word_type = builtin_type_int8;
868 word_type = builtin_type_int16;
872 word_type = builtin_type_int32;
876 word_type = builtin_type_int64;
880 word_type = builtin_type_int8;
883 /* The number of rows. */
884 nr_rows = atol (argv[3]);
886 error ("mi_cmd_data_read_memory: invalid number of rows.");
888 /* Number of bytes per row. */
889 nr_cols = atol (argv[4]);
891 error ("mi_cmd_data_read_memory: invalid number of columns.");
893 /* The un-printable character when printing ascii. */
899 /* Create a buffer and read it in. */
900 total_bytes = word_size * nr_rows * nr_cols;
901 mbuf = xcalloc (total_bytes, 1);
902 make_cleanup (xfree, mbuf);
904 nr_bytes = target_read_until_error (¤t_target, TARGET_OBJECT_MEMORY,
905 NULL, mbuf, addr, total_bytes);
907 error ("Unable to read memory.");
909 /* Output the header information. */
910 ui_out_field_core_addr (uiout, "addr", addr);
911 ui_out_field_int (uiout, "nr-bytes", nr_bytes);
912 ui_out_field_int (uiout, "total-bytes", total_bytes);
913 ui_out_field_core_addr (uiout, "next-row", addr + word_size * nr_cols);
914 ui_out_field_core_addr (uiout, "prev-row", addr - word_size * nr_cols);
915 ui_out_field_core_addr (uiout, "next-page", addr + total_bytes);
916 ui_out_field_core_addr (uiout, "prev-page", addr - total_bytes);
918 /* Build the result as a two dimentional table. */
920 struct ui_stream *stream = ui_out_stream_new (uiout);
921 struct cleanup *cleanup_list_memory;
924 cleanup_list_memory = make_cleanup_ui_out_list_begin_end (uiout, "memory");
925 for (row = 0, row_byte = 0;
927 row++, row_byte += nr_cols * word_size)
931 struct cleanup *cleanup_tuple;
932 struct cleanup *cleanup_list_data;
933 struct value_print_options opts;
935 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
936 ui_out_field_core_addr (uiout, "addr", addr + row_byte);
937 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr + row_byte); */
938 cleanup_list_data = make_cleanup_ui_out_list_begin_end (uiout, "data");
939 get_formatted_print_options (&opts, word_format);
940 for (col = 0, col_byte = row_byte;
942 col++, col_byte += word_size)
944 if (col_byte + word_size > nr_bytes)
946 ui_out_field_string (uiout, NULL, "N/A");
950 ui_file_rewind (stream->stream);
951 print_scalar_formatted (mbuf + col_byte, word_type, &opts,
952 word_asize, stream->stream);
953 ui_out_field_stream (uiout, NULL, stream);
956 do_cleanups (cleanup_list_data);
960 ui_file_rewind (stream->stream);
961 for (byte = row_byte; byte < row_byte + word_size * nr_cols; byte++)
963 if (byte >= nr_bytes)
965 fputc_unfiltered ('X', stream->stream);
967 else if (mbuf[byte] < 32 || mbuf[byte] > 126)
969 fputc_unfiltered (aschar, stream->stream);
972 fputc_unfiltered (mbuf[byte], stream->stream);
974 ui_out_field_stream (uiout, "ascii", stream);
976 do_cleanups (cleanup_tuple);
978 ui_out_stream_delete (stream);
979 do_cleanups (cleanup_list_memory);
981 do_cleanups (cleanups);
984 /* DATA-MEMORY-WRITE:
986 COLUMN_OFFSET: optional argument. Must be preceeded by '-o'. The
987 offset from the beginning of the memory grid row where the cell to
989 ADDR: start address of the row in the memory grid where the memory
990 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
991 the location to write to.
992 FORMAT: a char indicating format for the ``word''. See
994 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
995 VALUE: value to be written into the memory address.
997 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
1001 mi_cmd_data_write_memory (char *command, char **argv, int argc)
1006 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
1007 enough when using a compiler other than GCC. */
1010 struct cleanup *old_chain;
1018 static struct mi_opt opts[] =
1020 {"o", OFFSET_OPT, 1},
1026 int opt = mi_getopt ("mi_cmd_data_write_memory", argc, argv, opts,
1030 switch ((enum opt) opt)
1033 offset = atol (optarg);
1041 error ("mi_cmd_data_write_memory: Usage: [-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE.");
1043 /* Extract all the arguments. */
1044 /* Start address of the memory dump. */
1045 addr = parse_and_eval_address (argv[0]);
1046 /* The format character to use when displaying a memory word. See
1047 the ``x'' command. */
1048 word_format = argv[1][0];
1049 /* The size of the memory word. */
1050 word_size = atol (argv[2]);
1052 /* Calculate the real address of the write destination. */
1053 addr += (offset * word_size);
1055 /* Get the value as a number. */
1056 value = parse_and_eval_address (argv[3]);
1057 /* Get the value into an array. */
1058 buffer = xmalloc (word_size);
1059 old_chain = make_cleanup (xfree, buffer);
1060 store_signed_integer (buffer, word_size, value);
1061 /* Write it down to memory. */
1062 write_memory (addr, buffer, word_size);
1063 /* Free the buffer. */
1064 do_cleanups (old_chain);
1068 mi_cmd_enable_timings (char *command, char **argv, int argc)
1074 if (strcmp (argv[0], "yes") == 0)
1076 else if (strcmp (argv[0], "no") == 0)
1087 error ("mi_cmd_enable_timings: Usage: %s {yes|no}", command);
1091 mi_cmd_list_features (char *command, char **argv, int argc)
1095 struct cleanup *cleanup = NULL;
1096 cleanup = make_cleanup_ui_out_list_begin_end (uiout, "features");
1098 ui_out_field_string (uiout, NULL, "frozen-varobjs");
1099 ui_out_field_string (uiout, NULL, "pending-breakpoints");
1100 ui_out_field_string (uiout, NULL, "thread-info");
1102 do_cleanups (cleanup);
1106 error ("-list-features should be passed no arguments");
1110 mi_cmd_list_target_features (char *command, char **argv, int argc)
1114 struct cleanup *cleanup = NULL;
1115 cleanup = make_cleanup_ui_out_list_begin_end (uiout, "features");
1117 if (target_can_async_p ())
1118 ui_out_field_string (uiout, NULL, "async");
1120 do_cleanups (cleanup);
1124 error ("-list-target-features should be passed no arguments");
1127 /* Execute a command within a safe environment.
1128 Return <0 for error; >=0 for ok.
1130 args->action will tell mi_execute_command what action
1131 to perfrom after the given command has executed (display/suppress
1132 prompt, display error). */
1135 captured_mi_execute_command (struct ui_out *uiout, void *data)
1137 struct mi_parse *context = (struct mi_parse *) data;
1139 struct mi_timestamp cmd_finished;
1141 running_result_record_printed = 0;
1142 switch (context->op)
1145 /* A MI command was read from the input stream. */
1147 /* FIXME: gdb_???? */
1148 fprintf_unfiltered (raw_stdout, " token=`%s' command=`%s' args=`%s'\n",
1149 context->token, context->command, context->args);
1152 current_command_ts = context->cmd_start;
1154 mi_cmd_execute (context);
1157 timestamp (&cmd_finished);
1159 /* Print the result if there were no errors.
1161 Remember that on the way out of executing a command, you have
1162 to directly use the mi_interp's uiout, since the command could
1163 have reset the interpreter, in which case the current uiout
1164 will most likely crash in the mi_out_* routines. */
1165 if (!running_result_record_printed)
1167 fputs_unfiltered (context->token, raw_stdout);
1168 /* There's no particularly good reason why target-connect results
1169 in not ^done. Should kill ^connected for MI3. */
1170 fputs_unfiltered (strcmp (context->command, "target-select") == 0
1171 ? "^connected" : "^done", raw_stdout);
1172 mi_out_put (uiout, raw_stdout);
1173 mi_out_rewind (uiout);
1174 /* Have to check cmd_start, since the command could be
1176 if (do_timings && context->cmd_start)
1177 print_diff (context->cmd_start, &cmd_finished);
1178 fputs_unfiltered ("\n", raw_stdout);
1181 /* The command does not want anything to be printed. In that
1182 case, the command probably should not have written anything
1183 to uiout, but in case it has written something, discard it. */
1184 mi_out_rewind (uiout);
1190 /* A CLI command was read from the input stream. */
1191 /* This "feature" will be removed as soon as we have a
1192 complete set of mi commands. */
1193 /* Echo the command on the console. */
1194 fprintf_unfiltered (gdb_stdlog, "%s\n", context->command);
1195 /* Call the "console" interpreter. */
1196 argv[0] = "console";
1197 argv[1] = context->command;
1198 mi_cmd_interpreter_exec ("-interpreter-exec", argv, 2);
1200 /* If we changed interpreters, DON'T print out anything. */
1201 if (current_interp_named_p (INTERP_MI)
1202 || current_interp_named_p (INTERP_MI1)
1203 || current_interp_named_p (INTERP_MI2)
1204 || current_interp_named_p (INTERP_MI3))
1206 if (!running_result_record_printed)
1208 fputs_unfiltered (context->token, raw_stdout);
1209 fputs_unfiltered ("^done", raw_stdout);
1210 mi_out_put (uiout, raw_stdout);
1211 mi_out_rewind (uiout);
1212 fputs_unfiltered ("\n", raw_stdout);
1215 mi_out_rewind (uiout);
1227 mi_execute_command (char *cmd, int from_tty)
1229 struct mi_parse *command;
1230 struct ui_out *saved_uiout = uiout;
1232 /* This is to handle EOF (^D). We just quit gdb. */
1233 /* FIXME: we should call some API function here. */
1235 quit_force (NULL, from_tty);
1237 command = mi_parse (cmd);
1239 if (command != NULL)
1241 struct gdb_exception result;
1242 ptid_t previous_ptid = inferior_ptid;
1246 command->cmd_start = (struct mi_timestamp *)
1247 xmalloc (sizeof (struct mi_timestamp));
1248 timestamp (command->cmd_start);
1251 result = catch_exception (uiout, captured_mi_execute_command, command,
1253 if (result.reason < 0)
1255 /* The command execution failed and error() was called
1257 fputs_unfiltered (command->token, raw_stdout);
1258 fputs_unfiltered ("^error,msg=\"", raw_stdout);
1259 if (result.message == NULL)
1260 fputs_unfiltered ("unknown error", raw_stdout);
1262 fputstr_unfiltered (result.message, '"', raw_stdout);
1263 fputs_unfiltered ("\"\n", raw_stdout);
1264 mi_out_rewind (uiout);
1267 if (/* The notifications are only output when the top-level
1268 interpreter (specified on the command line) is MI. */
1269 ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ()))
1270 /* Don't try report anything if there are no threads --
1271 the program is dead. */
1272 && thread_count () != 0
1273 /* -thread-select explicitly changes thread. If frontend uses that
1274 internally, we don't want to emit =thread-selected, since
1275 =thread-selected is supposed to indicate user's intentions. */
1276 && strcmp (command->command, "thread-select") != 0)
1278 struct mi_interp *mi = top_level_interpreter_data ();
1279 struct thread_info *ti = inferior_thread ();
1282 if (command->thread == -1)
1284 report_change = !ptid_equal (previous_ptid, null_ptid)
1285 && !ptid_equal (inferior_ptid, previous_ptid);
1289 report_change = (ti->num != command->thread);
1294 target_terminal_ours ();
1295 fprintf_unfiltered (mi->event_channel,
1296 "thread-selected,id=\"%d\"",
1298 gdb_flush (mi->event_channel);
1302 mi_parse_free (command);
1305 fputs_unfiltered ("(gdb) \n", raw_stdout);
1306 gdb_flush (raw_stdout);
1307 /* Print any buffered hook code. */
1312 mi_cmd_execute (struct mi_parse *parse)
1314 struct cleanup *cleanup;
1318 current_token = xstrdup (parse->token);
1319 cleanup = make_cleanup (free_current_contents, ¤t_token);
1321 if (parse->frame != -1 && parse->thread == -1)
1322 error (_("Cannot specify --frame without --thread"));
1324 if (parse->thread != -1)
1326 struct thread_info *tp = find_thread_id (parse->thread);
1328 error (_("Invalid thread id: %d"), parse->thread);
1330 if (is_exited (tp->ptid))
1331 error (_("Thread id: %d has terminated"), parse->thread);
1333 switch_to_thread (tp->ptid);
1336 if (parse->frame != -1)
1338 struct frame_info *fid;
1339 int frame = parse->frame;
1340 fid = find_relative_frame (get_current_frame (), &frame);
1342 /* find_relative_frame was successful */
1345 error (_("Invalid frame id: %d"), frame);
1348 if (parse->cmd->argv_func != NULL)
1350 if (target_can_async_p ()
1351 && target_has_execution
1352 && (is_exited (inferior_ptid))
1353 && (strcmp (parse->command, "thread-info") != 0
1354 && strcmp (parse->command, "thread-list-ids") != 0
1355 && strcmp (parse->command, "thread-select") != 0))
1357 struct ui_file *stb;
1358 stb = mem_fileopen ();
1360 fputs_unfiltered ("Cannot execute command ", stb);
1361 fputstr_unfiltered (parse->command, '"', stb);
1362 fputs_unfiltered (" without a selected thread", stb);
1364 make_cleanup_ui_file_delete (stb);
1368 parse->cmd->argv_func (parse->command, parse->argv, parse->argc);
1370 else if (parse->cmd->cli.cmd != 0)
1372 /* FIXME: DELETE THIS. */
1373 /* The operation is still implemented by a cli command. */
1374 /* Must be a synchronous one. */
1375 mi_execute_cli_command (parse->cmd->cli.cmd, parse->cmd->cli.args_p,
1380 /* FIXME: DELETE THIS. */
1381 struct ui_file *stb;
1383 stb = mem_fileopen ();
1385 fputs_unfiltered ("Undefined mi command: ", stb);
1386 fputstr_unfiltered (parse->command, '"', stb);
1387 fputs_unfiltered (" (missing implementation)", stb);
1389 make_cleanup_ui_file_delete (stb);
1392 do_cleanups (cleanup);
1395 /* FIXME: This is just a hack so we can get some extra commands going.
1396 We don't want to channel things through the CLI, but call libgdb directly.
1397 Use only for synchronous commands. */
1400 mi_execute_cli_command (const char *cmd, int args_p, const char *args)
1404 struct cleanup *old_cleanups;
1407 run = xstrprintf ("%s %s", cmd, args);
1409 run = xstrdup (cmd);
1411 /* FIXME: gdb_???? */
1412 fprintf_unfiltered (gdb_stdout, "cli=%s run=%s\n",
1414 old_cleanups = make_cleanup (xfree, run);
1415 execute_command ( /*ui */ run, 0 /*from_tty */ );
1416 do_cleanups (old_cleanups);
1422 mi_execute_async_cli_command (char *cli_command, char **argv, int argc)
1424 struct cleanup *old_cleanups;
1427 if (target_can_async_p ())
1428 run = xstrprintf ("%s %s&", cli_command, argc ? *argv : "");
1430 run = xstrprintf ("%s %s", cli_command, argc ? *argv : "");
1431 old_cleanups = make_cleanup (xfree, run);
1433 execute_command ( /*ui */ run, 0 /*from_tty */ );
1435 if (target_can_async_p ())
1437 /* If we're not executing, an exception should have been throw. */
1438 gdb_assert (is_running (inferior_ptid));
1439 do_cleanups (old_cleanups);
1443 /* Do this before doing any printing. It would appear that some
1444 print code leaves garbage around in the buffer. */
1445 do_cleanups (old_cleanups);
1447 print_diff_now (current_command_ts);
1452 mi_load_progress (const char *section_name,
1453 unsigned long sent_so_far,
1454 unsigned long total_section,
1455 unsigned long total_sent,
1456 unsigned long grand_total)
1458 struct timeval time_now, delta, update_threshold;
1459 static struct timeval last_update;
1460 static char *previous_sect_name = NULL;
1462 struct ui_out *saved_uiout;
1464 /* This function is called through deprecated_show_load_progress
1465 which means uiout may not be correct. Fix it for the duration
1466 of this function. */
1467 saved_uiout = uiout;
1469 if (current_interp_named_p (INTERP_MI)
1470 || current_interp_named_p (INTERP_MI2))
1471 uiout = mi_out_new (2);
1472 else if (current_interp_named_p (INTERP_MI1))
1473 uiout = mi_out_new (1);
1474 else if (current_interp_named_p (INTERP_MI3))
1475 uiout = mi_out_new (3);
1479 update_threshold.tv_sec = 0;
1480 update_threshold.tv_usec = 500000;
1481 gettimeofday (&time_now, NULL);
1483 delta.tv_usec = time_now.tv_usec - last_update.tv_usec;
1484 delta.tv_sec = time_now.tv_sec - last_update.tv_sec;
1486 if (delta.tv_usec < 0)
1489 delta.tv_usec += 1000000L;
1492 new_section = (previous_sect_name ?
1493 strcmp (previous_sect_name, section_name) : 1);
1496 struct cleanup *cleanup_tuple;
1497 xfree (previous_sect_name);
1498 previous_sect_name = xstrdup (section_name);
1501 fputs_unfiltered (current_token, raw_stdout);
1502 fputs_unfiltered ("+download", raw_stdout);
1503 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1504 ui_out_field_string (uiout, "section", section_name);
1505 ui_out_field_int (uiout, "section-size", total_section);
1506 ui_out_field_int (uiout, "total-size", grand_total);
1507 do_cleanups (cleanup_tuple);
1508 mi_out_put (uiout, raw_stdout);
1509 fputs_unfiltered ("\n", raw_stdout);
1510 gdb_flush (raw_stdout);
1513 if (delta.tv_sec >= update_threshold.tv_sec &&
1514 delta.tv_usec >= update_threshold.tv_usec)
1516 struct cleanup *cleanup_tuple;
1517 last_update.tv_sec = time_now.tv_sec;
1518 last_update.tv_usec = time_now.tv_usec;
1520 fputs_unfiltered (current_token, raw_stdout);
1521 fputs_unfiltered ("+download", raw_stdout);
1522 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1523 ui_out_field_string (uiout, "section", section_name);
1524 ui_out_field_int (uiout, "section-sent", sent_so_far);
1525 ui_out_field_int (uiout, "section-size", total_section);
1526 ui_out_field_int (uiout, "total-sent", total_sent);
1527 ui_out_field_int (uiout, "total-size", grand_total);
1528 do_cleanups (cleanup_tuple);
1529 mi_out_put (uiout, raw_stdout);
1530 fputs_unfiltered ("\n", raw_stdout);
1531 gdb_flush (raw_stdout);
1535 uiout = saved_uiout;
1539 timestamp (struct mi_timestamp *tv)
1542 gettimeofday (&tv->wallclock, NULL);
1543 #ifdef HAVE_GETRUSAGE
1544 getrusage (RUSAGE_SELF, &rusage);
1545 tv->utime.tv_sec = rusage.ru_utime.tv_sec;
1546 tv->utime.tv_usec = rusage.ru_utime.tv_usec;
1547 tv->stime.tv_sec = rusage.ru_stime.tv_sec;
1548 tv->stime.tv_usec = rusage.ru_stime.tv_usec;
1550 usec = get_run_time ();
1551 tv->utime.tv_sec = usec/1000000L;
1552 tv->utime.tv_usec = usec - 1000000L*tv->utime.tv_sec;
1553 tv->stime.tv_sec = 0;
1554 tv->stime.tv_usec = 0;
1559 print_diff_now (struct mi_timestamp *start)
1561 struct mi_timestamp now;
1563 print_diff (start, &now);
1567 timeval_diff (struct timeval start, struct timeval end)
1569 return ((end.tv_sec - start.tv_sec) * 1000000L)
1570 + (end.tv_usec - start.tv_usec);
1574 print_diff (struct mi_timestamp *start, struct mi_timestamp *end)
1578 ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
1579 timeval_diff (start->wallclock, end->wallclock) / 1000000.0,
1580 timeval_diff (start->utime, end->utime) / 1000000.0,
1581 timeval_diff (start->stime, end->stime) / 1000000.0);