3 Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009
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"));
389 struct osdata_item *item;
392 data = get_osdata ("processes");
393 make_cleanup_osdata_free (data);
395 make_cleanup_ui_out_list_begin_end (uiout, "groups");
398 VEC_iterate (osdata_item_s, data->items,
402 struct cleanup *back_to =
403 make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
405 const char *pid = get_osdata_column (item, "pid");
406 const char *cmd = get_osdata_column (item, "command");
407 const char *user = get_osdata_column (item, "user");
409 ui_out_field_fmt (uiout, "id", "%s", pid);
410 ui_out_field_string (uiout, "type", "process");
412 ui_out_field_string (uiout, "description", cmd);
414 ui_out_field_string (uiout, "user", user);
416 do_cleanups (back_to);
422 if (!in_inferior_list (pid))
423 error ("Invalid thread group id '%s'", id);
424 print_thread_info (uiout, -1, pid);
428 make_cleanup_ui_out_list_begin_end (uiout, "groups");
429 iterate_over_inferiors (print_one_inferior, NULL);
432 do_cleanups (back_to);
436 mi_cmd_data_list_register_names (char *command, char **argv, int argc)
440 struct cleanup *cleanup;
442 /* Note that the test for a valid register must include checking the
443 gdbarch_register_name because gdbarch_num_regs may be allocated for
444 the union of the register sets within a family of related processors.
445 In this case, some entries of gdbarch_register_name will change depending
446 upon the particular processor being debugged. */
448 numregs = gdbarch_num_regs (current_gdbarch)
449 + gdbarch_num_pseudo_regs (current_gdbarch);
451 cleanup = make_cleanup_ui_out_list_begin_end (uiout, "register-names");
453 if (argc == 0) /* No args, just do all the regs. */
459 if (gdbarch_register_name (current_gdbarch, regnum) == NULL
460 || *(gdbarch_register_name (current_gdbarch, regnum)) == '\0')
461 ui_out_field_string (uiout, NULL, "");
463 ui_out_field_string (uiout, NULL,
464 gdbarch_register_name
465 (current_gdbarch, regnum));
469 /* Else, list of register #s, just do listed regs. */
470 for (i = 0; i < argc; i++)
472 regnum = atoi (argv[i]);
473 if (regnum < 0 || regnum >= numregs)
474 error ("bad register number");
476 if (gdbarch_register_name (current_gdbarch, regnum) == NULL
477 || *(gdbarch_register_name (current_gdbarch, regnum)) == '\0')
478 ui_out_field_string (uiout, NULL, "");
480 ui_out_field_string (uiout, NULL,
481 gdbarch_register_name (current_gdbarch, regnum));
483 do_cleanups (cleanup);
487 mi_cmd_data_list_changed_registers (char *command, char **argv, int argc)
489 static struct regcache *this_regs = NULL;
490 struct regcache *prev_regs;
491 int regnum, numregs, changed;
493 struct cleanup *cleanup;
495 /* The last time we visited this function, the current frame's register
496 contents were saved in THIS_REGS. Move THIS_REGS over to PREV_REGS,
497 and refresh THIS_REGS with the now-current register contents. */
499 prev_regs = this_regs;
500 this_regs = frame_save_as_regcache (get_selected_frame (NULL));
501 cleanup = make_cleanup_regcache_xfree (prev_regs);
503 /* Note that the test for a valid register must include checking the
504 gdbarch_register_name because gdbarch_num_regs may be allocated for
505 the union of the register sets within a family of related processors.
506 In this case, some entries of gdbarch_register_name will change depending
507 upon the particular processor being debugged. */
509 numregs = gdbarch_num_regs (current_gdbarch)
510 + gdbarch_num_pseudo_regs (current_gdbarch);
512 make_cleanup_ui_out_list_begin_end (uiout, "changed-registers");
514 if (argc == 0) /* No args, just do all the regs. */
520 if (gdbarch_register_name (current_gdbarch, regnum) == NULL
521 || *(gdbarch_register_name (current_gdbarch, regnum)) == '\0')
523 changed = register_changed_p (regnum, prev_regs, this_regs);
525 error ("mi_cmd_data_list_changed_registers: Unable to read register contents.");
527 ui_out_field_int (uiout, NULL, regnum);
531 /* Else, list of register #s, just do listed regs. */
532 for (i = 0; i < argc; i++)
534 regnum = atoi (argv[i]);
538 && gdbarch_register_name (current_gdbarch, regnum) != NULL
539 && *gdbarch_register_name (current_gdbarch, regnum) != '\000')
541 changed = register_changed_p (regnum, prev_regs, this_regs);
543 error ("mi_cmd_data_list_register_change: Unable to read register contents.");
545 ui_out_field_int (uiout, NULL, regnum);
548 error ("bad register number");
550 do_cleanups (cleanup);
554 register_changed_p (int regnum, struct regcache *prev_regs,
555 struct regcache *this_regs)
557 struct gdbarch *gdbarch = get_regcache_arch (this_regs);
558 gdb_byte prev_buffer[MAX_REGISTER_SIZE];
559 gdb_byte this_buffer[MAX_REGISTER_SIZE];
561 /* Registers not valid in this frame return count as unchanged. */
562 if (!regcache_valid_p (this_regs, regnum))
565 /* First time through or after gdbarch change consider all registers as
566 changed. Same for registers not valid in the previous frame. */
567 if (!prev_regs || get_regcache_arch (prev_regs) != gdbarch
568 || !regcache_valid_p (prev_regs, regnum))
571 /* Get register contents and compare. */
572 regcache_cooked_read (prev_regs, regnum, prev_buffer);
573 regcache_cooked_read (this_regs, regnum, this_buffer);
575 return memcmp (prev_buffer, this_buffer,
576 register_size (gdbarch, regnum)) != 0;
579 /* Return a list of register number and value pairs. The valid
580 arguments expected are: a letter indicating the format in which to
581 display the registers contents. This can be one of: x (hexadecimal), d
582 (decimal), N (natural), t (binary), o (octal), r (raw). After the
583 format argumetn there can be a sequence of numbers, indicating which
584 registers to fetch the content of. If the format is the only argument,
585 a list of all the registers with their values is returned. */
587 mi_cmd_data_list_register_values (char *command, char **argv, int argc)
589 int regnum, numregs, format;
591 struct cleanup *list_cleanup, *tuple_cleanup;
593 /* Note that the test for a valid register must include checking the
594 gdbarch_register_name because gdbarch_num_regs may be allocated for
595 the union of the register sets within a family of related processors.
596 In this case, some entries of gdbarch_register_name will change depending
597 upon the particular processor being debugged. */
599 numregs = gdbarch_num_regs (current_gdbarch)
600 + gdbarch_num_pseudo_regs (current_gdbarch);
603 error ("mi_cmd_data_list_register_values: Usage: -data-list-register-values <format> [<regnum1>...<regnumN>]");
605 format = (int) argv[0][0];
607 list_cleanup = make_cleanup_ui_out_list_begin_end (uiout, "register-values");
609 if (argc == 1) /* No args, beside the format: do all the regs. */
615 if (gdbarch_register_name (current_gdbarch, regnum) == NULL
616 || *(gdbarch_register_name (current_gdbarch, regnum)) == '\0')
618 tuple_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
619 ui_out_field_int (uiout, "number", regnum);
620 get_register (regnum, format);
621 do_cleanups (tuple_cleanup);
625 /* Else, list of register #s, just do listed regs. */
626 for (i = 1; i < argc; i++)
628 regnum = atoi (argv[i]);
632 && gdbarch_register_name (current_gdbarch, regnum) != NULL
633 && *gdbarch_register_name (current_gdbarch, regnum) != '\000')
635 tuple_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
636 ui_out_field_int (uiout, "number", regnum);
637 get_register (regnum, format);
638 do_cleanups (tuple_cleanup);
641 error ("bad register number");
643 do_cleanups (list_cleanup);
646 /* Output one register's contents in the desired format. */
648 get_register (int regnum, int format)
650 gdb_byte buffer[MAX_REGISTER_SIZE];
655 static struct ui_stream *stb = NULL;
657 stb = ui_out_stream_new (uiout);
662 frame_register (get_selected_frame (NULL), regnum, &optim, &lval, &addr,
666 error ("Optimized out");
671 char *ptr, buf[1024];
675 for (j = 0; j < register_size (current_gdbarch, regnum); j++)
677 int idx = gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG ? j
678 : register_size (current_gdbarch, regnum) - 1 - j;
679 sprintf (ptr, "%02x", (unsigned char) buffer[idx]);
682 ui_out_field_string (uiout, "value", buf);
683 /*fputs_filtered (buf, gdb_stdout); */
687 struct value_print_options opts;
688 get_formatted_print_options (&opts, format);
690 val_print (register_type (current_gdbarch, regnum), buffer, 0, 0,
691 stb->stream, 0, &opts, current_language);
692 ui_out_field_stream (uiout, "value", stb);
693 ui_out_stream_delete (stb);
697 /* Write given values into registers. The registers and values are
698 given as pairs. The corresponding MI command is
699 -data-write-register-values <format> [<regnum1> <value1>...<regnumN> <valueN>]*/
701 mi_cmd_data_write_register_values (char *command, char **argv, int argc)
706 /* Note that the test for a valid register must include checking the
707 gdbarch_register_name because gdbarch_num_regs may be allocated for
708 the union of the register sets within a family of related processors.
709 In this case, some entries of gdbarch_register_name will change depending
710 upon the particular processor being debugged. */
712 numregs = gdbarch_num_regs (current_gdbarch)
713 + gdbarch_num_pseudo_regs (current_gdbarch);
716 error ("mi_cmd_data_write_register_values: Usage: -data-write-register-values <format> [<regnum1> <value1>...<regnumN> <valueN>]");
718 format = (int) argv[0][0];
720 if (!target_has_registers)
721 error ("mi_cmd_data_write_register_values: No registers.");
724 error ("mi_cmd_data_write_register_values: No regs and values specified.");
727 error ("mi_cmd_data_write_register_values: Regs and vals are not in pairs.");
729 for (i = 1; i < argc; i = i + 2)
731 int regnum = atoi (argv[i]);
733 if (regnum >= 0 && regnum < numregs
734 && gdbarch_register_name (current_gdbarch, regnum)
735 && *gdbarch_register_name (current_gdbarch, regnum))
739 /* Get the value as a number. */
740 value = parse_and_eval_address (argv[i + 1]);
743 regcache_cooked_write_signed (get_current_regcache (), regnum, value);
746 error ("bad register number");
750 /* Evaluate the value of the argument. The argument is an
751 expression. If the expression contains spaces it needs to be
752 included in double quotes. */
754 mi_cmd_data_evaluate_expression (char *command, char **argv, int argc)
756 struct expression *expr;
757 struct cleanup *old_chain = NULL;
759 struct ui_stream *stb = NULL;
760 struct value_print_options opts;
762 stb = ui_out_stream_new (uiout);
766 ui_out_stream_delete (stb);
767 error ("mi_cmd_data_evaluate_expression: Usage: -data-evaluate-expression expression");
770 expr = parse_expression (argv[0]);
772 old_chain = make_cleanup (free_current_contents, &expr);
774 val = evaluate_expression (expr);
776 /* Print the result of the expression evaluation. */
777 get_user_print_options (&opts);
779 val_print (value_type (val), value_contents (val),
780 value_embedded_offset (val), VALUE_ADDRESS (val),
781 stb->stream, 0, &opts, current_language);
783 ui_out_field_stream (uiout, "value", stb);
784 ui_out_stream_delete (stb);
786 do_cleanups (old_chain);
791 ADDR: start address of data to be dumped.
792 WORD-FORMAT: a char indicating format for the ``word''. See
794 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes.
795 NR_ROW: Number of rows.
796 NR_COL: The number of colums (words per row).
797 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
798 ASCHAR for unprintable characters.
800 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
801 displayes them. Returns:
803 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
806 The number of bytes read is SIZE*ROW*COL. */
809 mi_cmd_data_read_memory (char *command, char **argv, int argc)
811 struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
817 struct type *word_type;
830 static struct mi_opt opts[] =
832 {"o", OFFSET_OPT, 1},
838 int opt = mi_getopt ("mi_cmd_data_read_memory", argc, argv, opts,
842 switch ((enum opt) opt)
845 offset = atol (optarg);
852 if (argc < 5 || argc > 6)
853 error ("mi_cmd_data_read_memory: Usage: ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR].");
855 /* Extract all the arguments. */
857 /* Start address of the memory dump. */
858 addr = parse_and_eval_address (argv[0]) + offset;
859 /* The format character to use when displaying a memory word. See
860 the ``x'' command. */
861 word_format = argv[1][0];
862 /* The size of the memory word. */
863 word_size = atol (argv[2]);
867 word_type = builtin_type_int8;
871 word_type = builtin_type_int16;
875 word_type = builtin_type_int32;
879 word_type = builtin_type_int64;
883 word_type = builtin_type_int8;
886 /* The number of rows. */
887 nr_rows = atol (argv[3]);
889 error ("mi_cmd_data_read_memory: invalid number of rows.");
891 /* Number of bytes per row. */
892 nr_cols = atol (argv[4]);
894 error ("mi_cmd_data_read_memory: invalid number of columns.");
896 /* The un-printable character when printing ascii. */
902 /* Create a buffer and read it in. */
903 total_bytes = word_size * nr_rows * nr_cols;
904 mbuf = xcalloc (total_bytes, 1);
905 make_cleanup (xfree, mbuf);
907 nr_bytes = target_read_until_error (¤t_target, TARGET_OBJECT_MEMORY,
908 NULL, mbuf, addr, total_bytes);
910 error ("Unable to read memory.");
912 /* Output the header information. */
913 ui_out_field_core_addr (uiout, "addr", addr);
914 ui_out_field_int (uiout, "nr-bytes", nr_bytes);
915 ui_out_field_int (uiout, "total-bytes", total_bytes);
916 ui_out_field_core_addr (uiout, "next-row", addr + word_size * nr_cols);
917 ui_out_field_core_addr (uiout, "prev-row", addr - word_size * nr_cols);
918 ui_out_field_core_addr (uiout, "next-page", addr + total_bytes);
919 ui_out_field_core_addr (uiout, "prev-page", addr - total_bytes);
921 /* Build the result as a two dimentional table. */
923 struct ui_stream *stream = ui_out_stream_new (uiout);
924 struct cleanup *cleanup_list_memory;
927 cleanup_list_memory = make_cleanup_ui_out_list_begin_end (uiout, "memory");
928 for (row = 0, row_byte = 0;
930 row++, row_byte += nr_cols * word_size)
934 struct cleanup *cleanup_tuple;
935 struct cleanup *cleanup_list_data;
936 struct value_print_options opts;
938 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
939 ui_out_field_core_addr (uiout, "addr", addr + row_byte);
940 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr + row_byte); */
941 cleanup_list_data = make_cleanup_ui_out_list_begin_end (uiout, "data");
942 get_formatted_print_options (&opts, word_format);
943 for (col = 0, col_byte = row_byte;
945 col++, col_byte += word_size)
947 if (col_byte + word_size > nr_bytes)
949 ui_out_field_string (uiout, NULL, "N/A");
953 ui_file_rewind (stream->stream);
954 print_scalar_formatted (mbuf + col_byte, word_type, &opts,
955 word_asize, stream->stream);
956 ui_out_field_stream (uiout, NULL, stream);
959 do_cleanups (cleanup_list_data);
963 ui_file_rewind (stream->stream);
964 for (byte = row_byte; byte < row_byte + word_size * nr_cols; byte++)
966 if (byte >= nr_bytes)
968 fputc_unfiltered ('X', stream->stream);
970 else if (mbuf[byte] < 32 || mbuf[byte] > 126)
972 fputc_unfiltered (aschar, stream->stream);
975 fputc_unfiltered (mbuf[byte], stream->stream);
977 ui_out_field_stream (uiout, "ascii", stream);
979 do_cleanups (cleanup_tuple);
981 ui_out_stream_delete (stream);
982 do_cleanups (cleanup_list_memory);
984 do_cleanups (cleanups);
987 /* DATA-MEMORY-WRITE:
989 COLUMN_OFFSET: optional argument. Must be preceeded by '-o'. The
990 offset from the beginning of the memory grid row where the cell to
992 ADDR: start address of the row in the memory grid where the memory
993 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
994 the location to write to.
995 FORMAT: a char indicating format for the ``word''. See
997 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
998 VALUE: value to be written into the memory address.
1000 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
1004 mi_cmd_data_write_memory (char *command, char **argv, int argc)
1009 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
1010 enough when using a compiler other than GCC. */
1013 struct cleanup *old_chain;
1021 static struct mi_opt opts[] =
1023 {"o", OFFSET_OPT, 1},
1029 int opt = mi_getopt ("mi_cmd_data_write_memory", argc, argv, opts,
1033 switch ((enum opt) opt)
1036 offset = atol (optarg);
1044 error ("mi_cmd_data_write_memory: Usage: [-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE.");
1046 /* Extract all the arguments. */
1047 /* Start address of the memory dump. */
1048 addr = parse_and_eval_address (argv[0]);
1049 /* The format character to use when displaying a memory word. See
1050 the ``x'' command. */
1051 word_format = argv[1][0];
1052 /* The size of the memory word. */
1053 word_size = atol (argv[2]);
1055 /* Calculate the real address of the write destination. */
1056 addr += (offset * word_size);
1058 /* Get the value as a number. */
1059 value = parse_and_eval_address (argv[3]);
1060 /* Get the value into an array. */
1061 buffer = xmalloc (word_size);
1062 old_chain = make_cleanup (xfree, buffer);
1063 store_signed_integer (buffer, word_size, value);
1064 /* Write it down to memory. */
1065 write_memory (addr, buffer, word_size);
1066 /* Free the buffer. */
1067 do_cleanups (old_chain);
1071 mi_cmd_enable_timings (char *command, char **argv, int argc)
1077 if (strcmp (argv[0], "yes") == 0)
1079 else if (strcmp (argv[0], "no") == 0)
1090 error ("mi_cmd_enable_timings: Usage: %s {yes|no}", command);
1094 mi_cmd_list_features (char *command, char **argv, int argc)
1098 struct cleanup *cleanup = NULL;
1099 cleanup = make_cleanup_ui_out_list_begin_end (uiout, "features");
1101 ui_out_field_string (uiout, NULL, "frozen-varobjs");
1102 ui_out_field_string (uiout, NULL, "pending-breakpoints");
1103 ui_out_field_string (uiout, NULL, "thread-info");
1105 do_cleanups (cleanup);
1109 error ("-list-features should be passed no arguments");
1113 mi_cmd_list_target_features (char *command, char **argv, int argc)
1117 struct cleanup *cleanup = NULL;
1118 cleanup = make_cleanup_ui_out_list_begin_end (uiout, "features");
1120 if (target_can_async_p ())
1121 ui_out_field_string (uiout, NULL, "async");
1123 do_cleanups (cleanup);
1127 error ("-list-target-features should be passed no arguments");
1130 /* Execute a command within a safe environment.
1131 Return <0 for error; >=0 for ok.
1133 args->action will tell mi_execute_command what action
1134 to perfrom after the given command has executed (display/suppress
1135 prompt, display error). */
1138 captured_mi_execute_command (struct ui_out *uiout, void *data)
1140 struct mi_parse *context = (struct mi_parse *) data;
1142 struct mi_timestamp cmd_finished;
1144 running_result_record_printed = 0;
1145 switch (context->op)
1148 /* A MI command was read from the input stream. */
1150 /* FIXME: gdb_???? */
1151 fprintf_unfiltered (raw_stdout, " token=`%s' command=`%s' args=`%s'\n",
1152 context->token, context->command, context->args);
1155 current_command_ts = context->cmd_start;
1157 mi_cmd_execute (context);
1160 timestamp (&cmd_finished);
1162 /* Print the result if there were no errors.
1164 Remember that on the way out of executing a command, you have
1165 to directly use the mi_interp's uiout, since the command could
1166 have reset the interpreter, in which case the current uiout
1167 will most likely crash in the mi_out_* routines. */
1168 if (!running_result_record_printed)
1170 fputs_unfiltered (context->token, raw_stdout);
1171 /* There's no particularly good reason why target-connect results
1172 in not ^done. Should kill ^connected for MI3. */
1173 fputs_unfiltered (strcmp (context->command, "target-select") == 0
1174 ? "^connected" : "^done", raw_stdout);
1175 mi_out_put (uiout, raw_stdout);
1176 mi_out_rewind (uiout);
1177 /* Have to check cmd_start, since the command could be
1179 if (do_timings && context->cmd_start)
1180 print_diff (context->cmd_start, &cmd_finished);
1181 fputs_unfiltered ("\n", raw_stdout);
1184 /* The command does not want anything to be printed. In that
1185 case, the command probably should not have written anything
1186 to uiout, but in case it has written something, discard it. */
1187 mi_out_rewind (uiout);
1193 /* A CLI command was read from the input stream. */
1194 /* This "feature" will be removed as soon as we have a
1195 complete set of mi commands. */
1196 /* Echo the command on the console. */
1197 fprintf_unfiltered (gdb_stdlog, "%s\n", context->command);
1198 /* Call the "console" interpreter. */
1199 argv[0] = "console";
1200 argv[1] = context->command;
1201 mi_cmd_interpreter_exec ("-interpreter-exec", argv, 2);
1203 /* If we changed interpreters, DON'T print out anything. */
1204 if (current_interp_named_p (INTERP_MI)
1205 || current_interp_named_p (INTERP_MI1)
1206 || current_interp_named_p (INTERP_MI2)
1207 || current_interp_named_p (INTERP_MI3))
1209 if (!running_result_record_printed)
1211 fputs_unfiltered (context->token, raw_stdout);
1212 fputs_unfiltered ("^done", raw_stdout);
1213 mi_out_put (uiout, raw_stdout);
1214 mi_out_rewind (uiout);
1215 fputs_unfiltered ("\n", raw_stdout);
1218 mi_out_rewind (uiout);
1230 mi_execute_command (char *cmd, int from_tty)
1232 struct mi_parse *command;
1233 struct ui_out *saved_uiout = uiout;
1235 /* This is to handle EOF (^D). We just quit gdb. */
1236 /* FIXME: we should call some API function here. */
1238 quit_force (NULL, from_tty);
1240 command = mi_parse (cmd);
1242 if (command != NULL)
1244 struct gdb_exception result;
1245 ptid_t previous_ptid = inferior_ptid;
1249 command->cmd_start = (struct mi_timestamp *)
1250 xmalloc (sizeof (struct mi_timestamp));
1251 timestamp (command->cmd_start);
1254 result = catch_exception (uiout, captured_mi_execute_command, command,
1256 if (result.reason < 0)
1258 /* The command execution failed and error() was called
1260 fputs_unfiltered (command->token, raw_stdout);
1261 fputs_unfiltered ("^error,msg=\"", raw_stdout);
1262 if (result.message == NULL)
1263 fputs_unfiltered ("unknown error", raw_stdout);
1265 fputstr_unfiltered (result.message, '"', raw_stdout);
1266 fputs_unfiltered ("\"\n", raw_stdout);
1267 mi_out_rewind (uiout);
1270 if (/* The notifications are only output when the top-level
1271 interpreter (specified on the command line) is MI. */
1272 ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ()))
1273 /* Don't try report anything if there are no threads --
1274 the program is dead. */
1275 && thread_count () != 0
1276 /* -thread-select explicitly changes thread. If frontend uses that
1277 internally, we don't want to emit =thread-selected, since
1278 =thread-selected is supposed to indicate user's intentions. */
1279 && strcmp (command->command, "thread-select") != 0)
1281 struct mi_interp *mi = top_level_interpreter_data ();
1282 struct thread_info *ti = inferior_thread ();
1285 if (command->thread == -1)
1287 report_change = !ptid_equal (previous_ptid, null_ptid)
1288 && !ptid_equal (inferior_ptid, previous_ptid);
1292 report_change = (ti->num != command->thread);
1297 target_terminal_ours ();
1298 fprintf_unfiltered (mi->event_channel,
1299 "thread-selected,id=\"%d\"",
1301 gdb_flush (mi->event_channel);
1305 mi_parse_free (command);
1308 fputs_unfiltered ("(gdb) \n", raw_stdout);
1309 gdb_flush (raw_stdout);
1310 /* Print any buffered hook code. */
1315 mi_cmd_execute (struct mi_parse *parse)
1317 struct cleanup *cleanup;
1321 current_token = xstrdup (parse->token);
1322 cleanup = make_cleanup (free_current_contents, ¤t_token);
1324 if (parse->frame != -1 && parse->thread == -1)
1325 error (_("Cannot specify --frame without --thread"));
1327 if (parse->thread != -1)
1329 struct thread_info *tp = find_thread_id (parse->thread);
1331 error (_("Invalid thread id: %d"), parse->thread);
1333 if (is_exited (tp->ptid))
1334 error (_("Thread id: %d has terminated"), parse->thread);
1336 switch_to_thread (tp->ptid);
1339 if (parse->frame != -1)
1341 struct frame_info *fid;
1342 int frame = parse->frame;
1343 fid = find_relative_frame (get_current_frame (), &frame);
1345 /* find_relative_frame was successful */
1348 error (_("Invalid frame id: %d"), frame);
1351 if (parse->cmd->argv_func != NULL)
1353 if (target_can_async_p ()
1354 && target_has_execution
1355 && (is_exited (inferior_ptid))
1356 && (strcmp (parse->command, "thread-info") != 0
1357 && strcmp (parse->command, "thread-list-ids") != 0
1358 && strcmp (parse->command, "thread-select") != 0)
1359 && strcmp (parse->command, "list-thread-groups") != 0)
1361 struct ui_file *stb;
1362 stb = mem_fileopen ();
1364 fputs_unfiltered ("Cannot execute command ", stb);
1365 fputstr_unfiltered (parse->command, '"', stb);
1366 fputs_unfiltered (" without a selected thread", stb);
1368 make_cleanup_ui_file_delete (stb);
1372 parse->cmd->argv_func (parse->command, parse->argv, parse->argc);
1374 else if (parse->cmd->cli.cmd != 0)
1376 /* FIXME: DELETE THIS. */
1377 /* The operation is still implemented by a cli command. */
1378 /* Must be a synchronous one. */
1379 mi_execute_cli_command (parse->cmd->cli.cmd, parse->cmd->cli.args_p,
1384 /* FIXME: DELETE THIS. */
1385 struct ui_file *stb;
1387 stb = mem_fileopen ();
1389 fputs_unfiltered ("Undefined mi command: ", stb);
1390 fputstr_unfiltered (parse->command, '"', stb);
1391 fputs_unfiltered (" (missing implementation)", stb);
1393 make_cleanup_ui_file_delete (stb);
1396 do_cleanups (cleanup);
1399 /* FIXME: This is just a hack so we can get some extra commands going.
1400 We don't want to channel things through the CLI, but call libgdb directly.
1401 Use only for synchronous commands. */
1404 mi_execute_cli_command (const char *cmd, int args_p, const char *args)
1408 struct cleanup *old_cleanups;
1411 run = xstrprintf ("%s %s", cmd, args);
1413 run = xstrdup (cmd);
1415 /* FIXME: gdb_???? */
1416 fprintf_unfiltered (gdb_stdout, "cli=%s run=%s\n",
1418 old_cleanups = make_cleanup (xfree, run);
1419 execute_command ( /*ui */ run, 0 /*from_tty */ );
1420 do_cleanups (old_cleanups);
1426 mi_execute_async_cli_command (char *cli_command, char **argv, int argc)
1428 struct cleanup *old_cleanups;
1431 if (target_can_async_p ())
1432 run = xstrprintf ("%s %s&", cli_command, argc ? *argv : "");
1434 run = xstrprintf ("%s %s", cli_command, argc ? *argv : "");
1435 old_cleanups = make_cleanup (xfree, run);
1437 execute_command ( /*ui */ run, 0 /*from_tty */ );
1439 if (target_can_async_p ())
1441 /* If we're not executing, an exception should have been throw. */
1442 gdb_assert (is_running (inferior_ptid));
1443 do_cleanups (old_cleanups);
1447 /* Do this before doing any printing. It would appear that some
1448 print code leaves garbage around in the buffer. */
1449 do_cleanups (old_cleanups);
1451 print_diff_now (current_command_ts);
1456 mi_load_progress (const char *section_name,
1457 unsigned long sent_so_far,
1458 unsigned long total_section,
1459 unsigned long total_sent,
1460 unsigned long grand_total)
1462 struct timeval time_now, delta, update_threshold;
1463 static struct timeval last_update;
1464 static char *previous_sect_name = NULL;
1466 struct ui_out *saved_uiout;
1468 /* This function is called through deprecated_show_load_progress
1469 which means uiout may not be correct. Fix it for the duration
1470 of this function. */
1471 saved_uiout = uiout;
1473 if (current_interp_named_p (INTERP_MI)
1474 || current_interp_named_p (INTERP_MI2))
1475 uiout = mi_out_new (2);
1476 else if (current_interp_named_p (INTERP_MI1))
1477 uiout = mi_out_new (1);
1478 else if (current_interp_named_p (INTERP_MI3))
1479 uiout = mi_out_new (3);
1483 update_threshold.tv_sec = 0;
1484 update_threshold.tv_usec = 500000;
1485 gettimeofday (&time_now, NULL);
1487 delta.tv_usec = time_now.tv_usec - last_update.tv_usec;
1488 delta.tv_sec = time_now.tv_sec - last_update.tv_sec;
1490 if (delta.tv_usec < 0)
1493 delta.tv_usec += 1000000L;
1496 new_section = (previous_sect_name ?
1497 strcmp (previous_sect_name, section_name) : 1);
1500 struct cleanup *cleanup_tuple;
1501 xfree (previous_sect_name);
1502 previous_sect_name = xstrdup (section_name);
1505 fputs_unfiltered (current_token, raw_stdout);
1506 fputs_unfiltered ("+download", raw_stdout);
1507 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1508 ui_out_field_string (uiout, "section", section_name);
1509 ui_out_field_int (uiout, "section-size", total_section);
1510 ui_out_field_int (uiout, "total-size", grand_total);
1511 do_cleanups (cleanup_tuple);
1512 mi_out_put (uiout, raw_stdout);
1513 fputs_unfiltered ("\n", raw_stdout);
1514 gdb_flush (raw_stdout);
1517 if (delta.tv_sec >= update_threshold.tv_sec &&
1518 delta.tv_usec >= update_threshold.tv_usec)
1520 struct cleanup *cleanup_tuple;
1521 last_update.tv_sec = time_now.tv_sec;
1522 last_update.tv_usec = time_now.tv_usec;
1524 fputs_unfiltered (current_token, raw_stdout);
1525 fputs_unfiltered ("+download", raw_stdout);
1526 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1527 ui_out_field_string (uiout, "section", section_name);
1528 ui_out_field_int (uiout, "section-sent", sent_so_far);
1529 ui_out_field_int (uiout, "section-size", total_section);
1530 ui_out_field_int (uiout, "total-sent", total_sent);
1531 ui_out_field_int (uiout, "total-size", grand_total);
1532 do_cleanups (cleanup_tuple);
1533 mi_out_put (uiout, raw_stdout);
1534 fputs_unfiltered ("\n", raw_stdout);
1535 gdb_flush (raw_stdout);
1539 uiout = saved_uiout;
1543 timestamp (struct mi_timestamp *tv)
1546 gettimeofday (&tv->wallclock, NULL);
1547 #ifdef HAVE_GETRUSAGE
1548 getrusage (RUSAGE_SELF, &rusage);
1549 tv->utime.tv_sec = rusage.ru_utime.tv_sec;
1550 tv->utime.tv_usec = rusage.ru_utime.tv_usec;
1551 tv->stime.tv_sec = rusage.ru_stime.tv_sec;
1552 tv->stime.tv_usec = rusage.ru_stime.tv_usec;
1554 usec = get_run_time ();
1555 tv->utime.tv_sec = usec/1000000L;
1556 tv->utime.tv_usec = usec - 1000000L*tv->utime.tv_sec;
1557 tv->stime.tv_sec = 0;
1558 tv->stime.tv_usec = 0;
1563 print_diff_now (struct mi_timestamp *start)
1565 struct mi_timestamp now;
1567 print_diff (start, &now);
1571 timeval_diff (struct timeval start, struct timeval end)
1573 return ((end.tv_sec - start.tv_sec) * 1000000L)
1574 + (end.tv_usec - start.tv_usec);
1578 print_diff (struct mi_timestamp *start, struct mi_timestamp *end)
1582 ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
1583 timeval_diff (start->wallclock, end->wallclock) / 1000000.0,
1584 timeval_diff (start->utime, end->utime) / 1000000.0,
1585 timeval_diff (start->stime, end->stime) / 1000000.0);