3 Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2007
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 2 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, write to the Free Software
22 Foundation, Inc., 51 Franklin Street, Fifth Floor,
23 Boston, MA 02110-1301, USA. */
25 /* Work in progress. */
30 #include "gdb_string.h"
31 #include "exceptions.h"
33 #include "gdbthread.h"
36 #include "mi-getopt.h"
37 #include "mi-console.h"
41 #include "event-loop.h"
42 #include "event-top.h"
43 #include "gdbcore.h" /* For write_memory(). */
53 #if defined HAVE_SYS_RESOURCE_H
54 #include <sys/resource.h>
66 /* Enumerations of the actions that may result from calling
67 captured_mi_execute_command. */
69 enum captured_mi_execute_command_actions
71 EXECUTE_COMMAND_DISPLAY_PROMPT,
72 EXECUTE_COMMAND_SUPRESS_PROMPT
75 /* This structure is used to pass information from captured_mi_execute_command
76 to mi_execute_command. */
77 struct captured_mi_execute_command_args
79 /* This return result of the MI command (output). */
80 enum mi_cmd_result rc;
82 /* What action to perform when the call is finished (output). */
83 enum captured_mi_execute_command_actions action;
85 /* The command context to be executed (input). */
86 struct mi_parse *command;
90 struct ui_file *raw_stdout;
92 /* This is used to pass the current command timestamp
93 down to continuation routines. */
94 static struct mi_timestamp *current_command_ts;
96 static int do_timings = 0;
98 /* The token of the last asynchronous command. */
99 static char *last_async_command;
100 static char *previous_async_command;
101 char *mi_error_message;
103 extern void _initialize_mi_main (void);
104 static enum mi_cmd_result mi_cmd_execute (struct mi_parse *parse);
106 static void mi_execute_cli_command (const char *cmd, int args_p,
108 static enum mi_cmd_result mi_execute_async_cli_command (char *mi, char *args, int from_tty);
110 static void mi_exec_async_cli_cmd_continuation (struct continuation_arg *arg);
112 static int register_changed_p (int regnum, struct regcache *,
114 static int get_register (int regnum, int format);
116 /* Command implementations. FIXME: Is this libgdb? No. This is the MI
117 layer that calls libgdb. Any operation used in the below should be
120 static void timestamp (struct mi_timestamp *tv);
122 static void print_diff_now (struct mi_timestamp *start);
123 static void print_diff (struct mi_timestamp *start, struct mi_timestamp *end);
126 mi_cmd_gdb_exit (char *command, char **argv, int argc)
128 /* We have to print everything right here because we never return. */
129 if (last_async_command)
130 fputs_unfiltered (last_async_command, raw_stdout);
131 fputs_unfiltered ("^exit\n", raw_stdout);
132 mi_out_put (uiout, raw_stdout);
133 /* FIXME: The function called is not yet a formal libgdb function. */
134 quit_force (NULL, FROM_TTY);
139 mi_cmd_exec_run (char *args, int from_tty)
141 /* FIXME: Should call a libgdb function, not a cli wrapper. */
142 return mi_execute_async_cli_command ("run", args, from_tty);
146 mi_cmd_exec_next (char *args, int from_tty)
148 /* FIXME: Should call a libgdb function, not a cli wrapper. */
149 return mi_execute_async_cli_command ("next", args, from_tty);
153 mi_cmd_exec_next_instruction (char *args, int from_tty)
155 /* FIXME: Should call a libgdb function, not a cli wrapper. */
156 return mi_execute_async_cli_command ("nexti", args, from_tty);
160 mi_cmd_exec_step (char *args, int from_tty)
162 /* FIXME: Should call a libgdb function, not a cli wrapper. */
163 return mi_execute_async_cli_command ("step", args, from_tty);
167 mi_cmd_exec_step_instruction (char *args, int from_tty)
169 /* FIXME: Should call a libgdb function, not a cli wrapper. */
170 return mi_execute_async_cli_command ("stepi", args, from_tty);
174 mi_cmd_exec_finish (char *args, int from_tty)
176 /* FIXME: Should call a libgdb function, not a cli wrapper. */
177 return mi_execute_async_cli_command ("finish", args, from_tty);
181 mi_cmd_exec_until (char *args, int from_tty)
183 /* FIXME: Should call a libgdb function, not a cli wrapper. */
184 return mi_execute_async_cli_command ("until", args, from_tty);
188 mi_cmd_exec_return (char *args, int from_tty)
190 /* This command doesn't really execute the target, it just pops the
191 specified number of frames. */
193 /* Call return_command with from_tty argument equal to 0 so as to
194 avoid being queried. */
195 return_command (args, 0);
197 /* Call return_command with from_tty argument equal to 0 so as to
198 avoid being queried. */
199 return_command (NULL, 0);
201 /* Because we have called return_command with from_tty = 0, we need
202 to print the frame here. */
203 print_stack_frame (get_selected_frame (NULL), 1, LOC_AND_ADDRESS);
209 mi_cmd_exec_continue (char *args, int from_tty)
211 /* FIXME: Should call a libgdb function, not a cli wrapper. */
212 return mi_execute_async_cli_command ("continue", args, from_tty);
215 /* Interrupt the execution of the target. Note how we must play around
216 with the token variables, in order to display the current token in
217 the result of the interrupt command, and the previous execution
218 token when the target finally stops. See comments in
221 mi_cmd_exec_interrupt (char *args, int from_tty)
223 if (!target_executing)
225 mi_error_message = xstrprintf ("mi_cmd_exec_interrupt: Inferior not executing.");
228 interrupt_target_command (args, from_tty);
229 if (last_async_command)
230 fputs_unfiltered (last_async_command, raw_stdout);
231 fputs_unfiltered ("^done", raw_stdout);
232 xfree (last_async_command);
233 if (previous_async_command)
234 last_async_command = xstrdup (previous_async_command);
235 xfree (previous_async_command);
236 previous_async_command = NULL;
237 mi_out_put (uiout, raw_stdout);
238 mi_out_rewind (uiout);
239 fputs_unfiltered ("\n", raw_stdout);
244 mi_cmd_thread_select (char *command, char **argv, int argc)
250 mi_error_message = xstrprintf ("mi_cmd_thread_select: USAGE: threadnum.");
254 rc = gdb_thread_select (uiout, argv[0], &mi_error_message);
256 if (rc == GDB_RC_FAIL)
263 mi_cmd_thread_list_ids (char *command, char **argv, int argc)
269 mi_error_message = xstrprintf ("mi_cmd_thread_list_ids: No arguments required.");
273 rc = gdb_list_thread_ids (uiout, &mi_error_message);
275 if (rc == GDB_RC_FAIL)
282 mi_cmd_data_list_register_names (char *command, char **argv, int argc)
286 struct cleanup *cleanup;
288 /* Note that the test for a valid register must include checking the
289 REGISTER_NAME because NUM_REGS may be allocated for the union of
290 the register sets within a family of related processors. In this
291 case, some entries of REGISTER_NAME will change depending upon
292 the particular processor being debugged. */
294 numregs = NUM_REGS + NUM_PSEUDO_REGS;
296 cleanup = make_cleanup_ui_out_list_begin_end (uiout, "register-names");
298 if (argc == 0) /* No args, just do all the regs. */
304 if (REGISTER_NAME (regnum) == NULL
305 || *(REGISTER_NAME (regnum)) == '\0')
306 ui_out_field_string (uiout, NULL, "");
308 ui_out_field_string (uiout, NULL, REGISTER_NAME (regnum));
312 /* Else, list of register #s, just do listed regs. */
313 for (i = 0; i < argc; i++)
315 regnum = atoi (argv[i]);
316 if (regnum < 0 || regnum >= numregs)
318 do_cleanups (cleanup);
319 mi_error_message = xstrprintf ("bad register number");
322 if (REGISTER_NAME (regnum) == NULL
323 || *(REGISTER_NAME (regnum)) == '\0')
324 ui_out_field_string (uiout, NULL, "");
326 ui_out_field_string (uiout, NULL, REGISTER_NAME (regnum));
328 do_cleanups (cleanup);
333 mi_cmd_data_list_changed_registers (char *command, char **argv, int argc)
335 static struct regcache *this_regs = NULL;
336 struct regcache *prev_regs;
337 int regnum, numregs, changed;
339 struct cleanup *cleanup;
341 /* The last time we visited this function, the current frame's register
342 contents were saved in THIS_REGS. Move THIS_REGS over to PREV_REGS,
343 and refresh THIS_REGS with the now-current register contents. */
345 prev_regs = this_regs;
346 this_regs = frame_save_as_regcache (get_selected_frame (NULL));
347 cleanup = make_cleanup_regcache_xfree (prev_regs);
349 /* Note that the test for a valid register must include checking the
350 REGISTER_NAME because NUM_REGS may be allocated for the union of
351 the register sets within a family of related processors. In this
352 case, some entries of REGISTER_NAME will change depending upon
353 the particular processor being debugged. */
355 numregs = NUM_REGS + NUM_PSEUDO_REGS;
357 make_cleanup_ui_out_list_begin_end (uiout, "changed-registers");
359 if (argc == 0) /* No args, just do all the regs. */
365 if (REGISTER_NAME (regnum) == NULL
366 || *(REGISTER_NAME (regnum)) == '\0')
368 changed = register_changed_p (regnum, prev_regs, this_regs);
371 do_cleanups (cleanup);
372 mi_error_message = xstrprintf ("mi_cmd_data_list_changed_registers: Unable to read register contents.");
376 ui_out_field_int (uiout, NULL, regnum);
380 /* Else, list of register #s, just do listed regs. */
381 for (i = 0; i < argc; i++)
383 regnum = atoi (argv[i]);
387 && REGISTER_NAME (regnum) != NULL
388 && *REGISTER_NAME (regnum) != '\000')
390 changed = register_changed_p (regnum, prev_regs, this_regs);
393 do_cleanups (cleanup);
394 mi_error_message = xstrprintf ("mi_cmd_data_list_register_change: Unable to read register contents.");
398 ui_out_field_int (uiout, NULL, regnum);
402 do_cleanups (cleanup);
403 mi_error_message = xstrprintf ("bad register number");
407 do_cleanups (cleanup);
412 register_changed_p (int regnum, struct regcache *prev_regs,
413 struct regcache *this_regs)
415 struct gdbarch *gdbarch = get_regcache_arch (this_regs);
416 gdb_byte prev_buffer[MAX_REGISTER_SIZE];
417 gdb_byte this_buffer[MAX_REGISTER_SIZE];
419 /* Registers not valid in this frame return count as unchanged. */
420 if (!regcache_valid_p (this_regs, regnum))
423 /* First time through or after gdbarch change consider all registers as
424 changed. Same for registers not valid in the previous frame. */
425 if (!prev_regs || get_regcache_arch (prev_regs) != gdbarch
426 || !regcache_valid_p (prev_regs, regnum))
429 /* Get register contents and compare. */
430 regcache_cooked_read (prev_regs, regnum, prev_buffer);
431 regcache_cooked_read (this_regs, regnum, this_buffer);
433 return memcmp (prev_buffer, this_buffer,
434 register_size (gdbarch, regnum)) != 0;
437 /* Return a list of register number and value pairs. The valid
438 arguments expected are: a letter indicating the format in which to
439 display the registers contents. This can be one of: x (hexadecimal), d
440 (decimal), N (natural), t (binary), o (octal), r (raw). After the
441 format argumetn there can be a sequence of numbers, indicating which
442 registers to fetch the content of. If the format is the only argument,
443 a list of all the registers with their values is returned. */
445 mi_cmd_data_list_register_values (char *command, char **argv, int argc)
447 int regnum, numregs, format, result;
449 struct cleanup *list_cleanup, *tuple_cleanup;
451 /* Note that the test for a valid register must include checking the
452 REGISTER_NAME because NUM_REGS may be allocated for the union of
453 the register sets within a family of related processors. In this
454 case, some entries of REGISTER_NAME will change depending upon
455 the particular processor being debugged. */
457 numregs = NUM_REGS + NUM_PSEUDO_REGS;
461 mi_error_message = xstrprintf ("mi_cmd_data_list_register_values: Usage: -data-list-register-values <format> [<regnum1>...<regnumN>]");
465 format = (int) argv[0][0];
467 list_cleanup = make_cleanup_ui_out_list_begin_end (uiout, "register-values");
469 if (argc == 1) /* No args, beside the format: do all the regs. */
475 if (REGISTER_NAME (regnum) == NULL
476 || *(REGISTER_NAME (regnum)) == '\0')
478 tuple_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
479 ui_out_field_int (uiout, "number", regnum);
480 result = get_register (regnum, format);
483 do_cleanups (list_cleanup);
486 do_cleanups (tuple_cleanup);
490 /* Else, list of register #s, just do listed regs. */
491 for (i = 1; i < argc; i++)
493 regnum = atoi (argv[i]);
497 && REGISTER_NAME (regnum) != NULL
498 && *REGISTER_NAME (regnum) != '\000')
500 tuple_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
501 ui_out_field_int (uiout, "number", regnum);
502 result = get_register (regnum, format);
505 do_cleanups (list_cleanup);
508 do_cleanups (tuple_cleanup);
512 do_cleanups (list_cleanup);
513 mi_error_message = xstrprintf ("bad register number");
517 do_cleanups (list_cleanup);
521 /* Output one register's contents in the desired format. */
523 get_register (int regnum, int format)
525 gdb_byte buffer[MAX_REGISTER_SIZE];
530 static struct ui_stream *stb = NULL;
532 stb = ui_out_stream_new (uiout);
537 frame_register (get_selected_frame (NULL), regnum, &optim, &lval, &addr,
542 mi_error_message = xstrprintf ("Optimized out");
549 char *ptr, buf[1024];
553 for (j = 0; j < register_size (current_gdbarch, regnum); j++)
555 int idx = TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? j
556 : register_size (current_gdbarch, regnum) - 1 - j;
557 sprintf (ptr, "%02x", (unsigned char) buffer[idx]);
560 ui_out_field_string (uiout, "value", buf);
561 /*fputs_filtered (buf, gdb_stdout); */
565 val_print (register_type (current_gdbarch, regnum), buffer, 0, 0,
566 stb->stream, format, 1, 0, Val_pretty_default);
567 ui_out_field_stream (uiout, "value", stb);
568 ui_out_stream_delete (stb);
573 /* Write given values into registers. The registers and values are
574 given as pairs. The corresponding MI command is
575 -data-write-register-values <format> [<regnum1> <value1>...<regnumN> <valueN>]*/
577 mi_cmd_data_write_register_values (char *command, char **argv, int argc)
582 /* Note that the test for a valid register must include checking the
583 REGISTER_NAME because NUM_REGS may be allocated for the union of
584 the register sets within a family of related processors. In this
585 case, some entries of REGISTER_NAME will change depending upon
586 the particular processor being debugged. */
588 numregs = NUM_REGS + NUM_PSEUDO_REGS;
592 mi_error_message = xstrprintf ("mi_cmd_data_write_register_values: Usage: -data-write-register-values <format> [<regnum1> <value1>...<regnumN> <valueN>]");
596 format = (int) argv[0][0];
598 if (!target_has_registers)
600 mi_error_message = xstrprintf ("mi_cmd_data_write_register_values: No registers.");
606 mi_error_message = xstrprintf ("mi_cmd_data_write_register_values: No regs and values specified.");
612 mi_error_message = xstrprintf ("mi_cmd_data_write_register_values: Regs and vals are not in pairs.");
616 for (i = 1; i < argc; i = i + 2)
618 int regnum = atoi (argv[i]);
620 if (regnum >= 0 && regnum < numregs
621 && REGISTER_NAME (regnum) && *REGISTER_NAME (regnum))
625 /* Get the value as a number. */
626 value = parse_and_eval_address (argv[i + 1]);
629 regcache_cooked_write_signed (current_regcache, regnum, value);
633 mi_error_message = xstrprintf ("bad register number");
641 /* This is commented out because we decided it was not useful. I leave
642 it, just in case. ezannoni:1999-12-08 */
644 /* Assign a value to a variable. The expression argument must be in
645 the form A=2 or "A = 2" i.e. if there are spaces it needs to be
648 mi_cmd_data_assign (char *command, char **argv, int argc)
650 struct expression *expr;
651 struct cleanup *old_chain;
655 mi_error_message = xstrprintf ("mi_cmd_data_assign: Usage: -data-assign expression");
659 /* NOTE what follows is a clone of set_command(). FIXME: ezannoni
660 01-12-1999: Need to decide what to do with this for libgdb purposes. */
662 expr = parse_expression (argv[0]);
663 old_chain = make_cleanup (free_current_contents, &expr);
664 evaluate_expression (expr);
665 do_cleanups (old_chain);
670 /* Evaluate the value of the argument. The argument is an
671 expression. If the expression contains spaces it needs to be
672 included in double quotes. */
674 mi_cmd_data_evaluate_expression (char *command, char **argv, int argc)
676 struct expression *expr;
677 struct cleanup *old_chain = NULL;
679 struct ui_stream *stb = NULL;
681 stb = ui_out_stream_new (uiout);
685 mi_error_message = xstrprintf ("mi_cmd_data_evaluate_expression: Usage: -data-evaluate-expression expression");
689 expr = parse_expression (argv[0]);
691 old_chain = make_cleanup (free_current_contents, &expr);
693 val = evaluate_expression (expr);
695 /* Print the result of the expression evaluation. */
696 val_print (value_type (val), value_contents (val),
697 value_embedded_offset (val), VALUE_ADDRESS (val),
698 stb->stream, 0, 0, 0, 0);
700 ui_out_field_stream (uiout, "value", stb);
701 ui_out_stream_delete (stb);
703 do_cleanups (old_chain);
709 mi_cmd_target_download (char *args, int from_tty)
712 struct cleanup *old_cleanups = NULL;
714 run = xstrprintf ("load %s", args);
715 old_cleanups = make_cleanup (xfree, run);
716 execute_command (run, from_tty);
718 do_cleanups (old_cleanups);
722 /* Connect to the remote target. */
724 mi_cmd_target_select (char *args, int from_tty)
727 struct cleanup *old_cleanups = NULL;
729 run = xstrprintf ("target %s", args);
730 old_cleanups = make_cleanup (xfree, run);
732 /* target-select is always synchronous. Once the call has returned
733 we know that we are connected. */
734 /* NOTE: At present all targets that are connected are also
735 (implicitly) talking to a halted target. In the future this may
737 execute_command (run, from_tty);
739 do_cleanups (old_cleanups);
741 /* Issue the completion message here. */
742 if (last_async_command)
743 fputs_unfiltered (last_async_command, raw_stdout);
744 fputs_unfiltered ("^connected", raw_stdout);
745 mi_out_put (uiout, raw_stdout);
746 mi_out_rewind (uiout);
747 fputs_unfiltered ("\n", raw_stdout);
748 do_exec_cleanups (ALL_CLEANUPS);
754 ADDR: start address of data to be dumped.
755 WORD-FORMAT: a char indicating format for the ``word''. See
757 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes.
758 NR_ROW: Number of rows.
759 NR_COL: The number of colums (words per row).
760 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
761 ASCHAR for unprintable characters.
763 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
764 displayes them. Returns:
766 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
769 The number of bytes read is SIZE*ROW*COL. */
772 mi_cmd_data_read_memory (char *command, char **argv, int argc)
774 struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
780 struct type *word_type;
793 static struct mi_opt opts[] =
795 {"o", OFFSET_OPT, 1},
801 int opt = mi_getopt ("mi_cmd_data_read_memory", argc, argv, opts,
805 switch ((enum opt) opt)
808 offset = atol (optarg);
815 if (argc < 5 || argc > 6)
817 mi_error_message = xstrprintf ("mi_cmd_data_read_memory: Usage: ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR].");
821 /* Extract all the arguments. */
823 /* Start address of the memory dump. */
824 addr = parse_and_eval_address (argv[0]) + offset;
825 /* The format character to use when displaying a memory word. See
826 the ``x'' command. */
827 word_format = argv[1][0];
828 /* The size of the memory word. */
829 word_size = atol (argv[2]);
833 word_type = builtin_type_int8;
837 word_type = builtin_type_int16;
841 word_type = builtin_type_int32;
845 word_type = builtin_type_int64;
849 word_type = builtin_type_int8;
852 /* The number of rows. */
853 nr_rows = atol (argv[3]);
856 mi_error_message = xstrprintf ("mi_cmd_data_read_memory: invalid number of rows.");
859 /* Number of bytes per row. */
860 nr_cols = atol (argv[4]);
863 mi_error_message = xstrprintf ("mi_cmd_data_read_memory: invalid number of columns.");
866 /* The un-printable character when printing ascii. */
872 /* Create a buffer and read it in. */
873 total_bytes = word_size * nr_rows * nr_cols;
874 mbuf = xcalloc (total_bytes, 1);
875 make_cleanup (xfree, mbuf);
877 nr_bytes = target_read (¤t_target, TARGET_OBJECT_MEMORY, NULL,
878 mbuf, addr, total_bytes);
881 do_cleanups (cleanups);
882 mi_error_message = xstrdup ("Unable to read memory.");
886 /* Output the header information. */
887 ui_out_field_core_addr (uiout, "addr", addr);
888 ui_out_field_int (uiout, "nr-bytes", nr_bytes);
889 ui_out_field_int (uiout, "total-bytes", total_bytes);
890 ui_out_field_core_addr (uiout, "next-row", addr + word_size * nr_cols);
891 ui_out_field_core_addr (uiout, "prev-row", addr - word_size * nr_cols);
892 ui_out_field_core_addr (uiout, "next-page", addr + total_bytes);
893 ui_out_field_core_addr (uiout, "prev-page", addr - total_bytes);
895 /* Build the result as a two dimentional table. */
897 struct ui_stream *stream = ui_out_stream_new (uiout);
898 struct cleanup *cleanup_list_memory;
901 cleanup_list_memory = make_cleanup_ui_out_list_begin_end (uiout, "memory");
902 for (row = 0, row_byte = 0;
904 row++, row_byte += nr_cols * word_size)
908 struct cleanup *cleanup_tuple;
909 struct cleanup *cleanup_list_data;
910 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
911 ui_out_field_core_addr (uiout, "addr", addr + row_byte);
912 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr + row_byte); */
913 cleanup_list_data = make_cleanup_ui_out_list_begin_end (uiout, "data");
914 for (col = 0, col_byte = row_byte;
916 col++, col_byte += word_size)
918 if (col_byte + word_size > nr_bytes)
920 ui_out_field_string (uiout, NULL, "N/A");
924 ui_file_rewind (stream->stream);
925 print_scalar_formatted (mbuf + col_byte, word_type, word_format,
926 word_asize, stream->stream);
927 ui_out_field_stream (uiout, NULL, stream);
930 do_cleanups (cleanup_list_data);
934 ui_file_rewind (stream->stream);
935 for (byte = row_byte; byte < row_byte + word_size * nr_cols; byte++)
937 if (byte >= nr_bytes)
939 fputc_unfiltered ('X', stream->stream);
941 else if (mbuf[byte] < 32 || mbuf[byte] > 126)
943 fputc_unfiltered (aschar, stream->stream);
946 fputc_unfiltered (mbuf[byte], stream->stream);
948 ui_out_field_stream (uiout, "ascii", stream);
950 do_cleanups (cleanup_tuple);
952 ui_out_stream_delete (stream);
953 do_cleanups (cleanup_list_memory);
955 do_cleanups (cleanups);
959 /* DATA-MEMORY-WRITE:
961 COLUMN_OFFSET: optional argument. Must be preceeded by '-o'. The
962 offset from the beginning of the memory grid row where the cell to
964 ADDR: start address of the row in the memory grid where the memory
965 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
966 the location to write to.
967 FORMAT: a char indicating format for the ``word''. See
969 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
970 VALUE: value to be written into the memory address.
972 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
976 mi_cmd_data_write_memory (char *command, char **argv, int argc)
981 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
982 enough when using a compiler other than GCC. */
985 struct cleanup *old_chain;
993 static struct mi_opt opts[] =
995 {"o", OFFSET_OPT, 1},
1001 int opt = mi_getopt ("mi_cmd_data_write_memory", argc, argv, opts,
1005 switch ((enum opt) opt)
1008 offset = atol (optarg);
1017 mi_error_message = xstrprintf ("mi_cmd_data_write_memory: Usage: [-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE.");
1018 return MI_CMD_ERROR;
1021 /* Extract all the arguments. */
1022 /* Start address of the memory dump. */
1023 addr = parse_and_eval_address (argv[0]);
1024 /* The format character to use when displaying a memory word. See
1025 the ``x'' command. */
1026 word_format = argv[1][0];
1027 /* The size of the memory word. */
1028 word_size = atol (argv[2]);
1030 /* Calculate the real address of the write destination. */
1031 addr += (offset * word_size);
1033 /* Get the value as a number. */
1034 value = parse_and_eval_address (argv[3]);
1035 /* Get the value into an array. */
1036 buffer = xmalloc (word_size);
1037 old_chain = make_cleanup (xfree, buffer);
1038 store_signed_integer (buffer, word_size, value);
1039 /* Write it down to memory. */
1040 write_memory (addr, buffer, word_size);
1041 /* Free the buffer. */
1042 do_cleanups (old_chain);
1048 mi_cmd_enable_timings (char *command, char **argv, int argc)
1054 if (strcmp (argv[0], "yes") == 0)
1056 else if (strcmp (argv[0], "no") == 0)
1067 error ("mi_cmd_enable_timings: Usage: %s {yes|no}", command);
1068 return MI_CMD_ERROR;
1071 /* Execute a command within a safe environment.
1072 Return <0 for error; >=0 for ok.
1074 args->action will tell mi_execute_command what action
1075 to perfrom after the given command has executed (display/supress
1076 prompt, display error). */
1079 captured_mi_execute_command (struct ui_out *uiout, void *data)
1081 struct captured_mi_execute_command_args *args =
1082 (struct captured_mi_execute_command_args *) data;
1083 struct mi_parse *context = args->command;
1085 struct mi_timestamp cmd_finished;
1087 switch (context->op)
1091 /* A MI command was read from the input stream. */
1093 /* FIXME: gdb_???? */
1094 fprintf_unfiltered (raw_stdout, " token=`%s' command=`%s' args=`%s'\n",
1095 context->token, context->command, context->args);
1096 /* FIXME: cagney/1999-09-25: Rather than this convoluted
1097 condition expression, each function should return an
1098 indication of what action is required and then switch on
1100 args->action = EXECUTE_COMMAND_DISPLAY_PROMPT;
1103 current_command_ts = context->cmd_start;
1105 args->rc = mi_cmd_execute (context);
1108 timestamp (&cmd_finished);
1110 if (!target_can_async_p () || !target_executing)
1112 /* Print the result if there were no errors.
1114 Remember that on the way out of executing a command, you have
1115 to directly use the mi_interp's uiout, since the command could
1116 have reset the interpreter, in which case the current uiout
1117 will most likely crash in the mi_out_* routines. */
1118 if (args->rc == MI_CMD_DONE)
1120 fputs_unfiltered (context->token, raw_stdout);
1121 fputs_unfiltered ("^done", raw_stdout);
1122 mi_out_put (uiout, raw_stdout);
1123 mi_out_rewind (uiout);
1124 /* Have to check cmd_start, since the command could be
1126 if (do_timings && context->cmd_start)
1127 print_diff (context->cmd_start, &cmd_finished);
1128 fputs_unfiltered ("\n", raw_stdout);
1130 else if (args->rc == MI_CMD_ERROR)
1132 if (mi_error_message)
1134 fputs_unfiltered (context->token, raw_stdout);
1135 fputs_unfiltered ("^error,msg=\"", raw_stdout);
1136 fputstr_unfiltered (mi_error_message, '"', raw_stdout);
1137 xfree (mi_error_message);
1138 fputs_unfiltered ("\"\n", raw_stdout);
1140 mi_out_rewind (uiout);
1143 mi_out_rewind (uiout);
1145 else if (sync_execution)
1147 /* Don't print the prompt. We are executing the target in
1148 synchronous mode. */
1149 args->action = EXECUTE_COMMAND_SUPRESS_PROMPT;
1157 /* A CLI command was read from the input stream. */
1158 /* This "feature" will be removed as soon as we have a
1159 complete set of mi commands. */
1160 /* Echo the command on the console. */
1161 fprintf_unfiltered (gdb_stdlog, "%s\n", context->command);
1162 /* Call the "console" interpreter. */
1163 argv[0] = "console";
1164 argv[1] = context->command;
1165 args->rc = mi_cmd_interpreter_exec ("-interpreter-exec", argv, 2);
1167 /* If we changed interpreters, DON'T print out anything. */
1168 if (current_interp_named_p (INTERP_MI)
1169 || current_interp_named_p (INTERP_MI1)
1170 || current_interp_named_p (INTERP_MI2)
1171 || current_interp_named_p (INTERP_MI3))
1173 if (args->rc == MI_CMD_DONE)
1175 fputs_unfiltered (context->token, raw_stdout);
1176 fputs_unfiltered ("^done", raw_stdout);
1177 mi_out_put (uiout, raw_stdout);
1178 mi_out_rewind (uiout);
1179 fputs_unfiltered ("\n", raw_stdout);
1180 args->action = EXECUTE_COMMAND_DISPLAY_PROMPT;
1182 else if (args->rc == MI_CMD_ERROR)
1184 if (mi_error_message)
1186 fputs_unfiltered (context->token, raw_stdout);
1187 fputs_unfiltered ("^error,msg=\"", raw_stdout);
1188 fputstr_unfiltered (mi_error_message, '"', raw_stdout);
1189 xfree (mi_error_message);
1190 fputs_unfiltered ("\"\n", raw_stdout);
1192 mi_out_rewind (uiout);
1195 mi_out_rewind (uiout);
1207 mi_execute_command (char *cmd, int from_tty)
1209 struct mi_parse *command;
1210 struct captured_mi_execute_command_args args;
1211 struct ui_out *saved_uiout = uiout;
1213 /* This is to handle EOF (^D). We just quit gdb. */
1214 /* FIXME: we should call some API function here. */
1216 quit_force (NULL, from_tty);
1218 command = mi_parse (cmd);
1220 if (command != NULL)
1222 struct gdb_exception result;
1226 command->cmd_start = (struct mi_timestamp *)
1227 xmalloc (sizeof (struct mi_timestamp));
1228 timestamp (command->cmd_start);
1231 /* FIXME: cagney/1999-11-04: Can this use of catch_exceptions either
1232 be pushed even further down or even eliminated? */
1233 args.command = command;
1234 result = catch_exception (uiout, captured_mi_execute_command, &args,
1236 exception_print (gdb_stderr, result);
1238 if (args.action == EXECUTE_COMMAND_SUPRESS_PROMPT)
1240 /* The command is executing synchronously. Bail out early
1241 suppressing the finished prompt. */
1242 mi_parse_free (command);
1245 if (result.reason < 0)
1247 /* The command execution failed and error() was called
1249 fputs_unfiltered (command->token, raw_stdout);
1250 fputs_unfiltered ("^error,msg=\"", raw_stdout);
1251 if (result.message == NULL)
1252 fputs_unfiltered ("unknown error", raw_stdout);
1254 fputstr_unfiltered (result.message, '"', raw_stdout);
1255 fputs_unfiltered ("\"\n", raw_stdout);
1256 mi_out_rewind (uiout);
1258 mi_parse_free (command);
1261 fputs_unfiltered ("(gdb) \n", raw_stdout);
1262 gdb_flush (raw_stdout);
1263 /* Print any buffered hook code. */
1267 static enum mi_cmd_result
1268 mi_cmd_execute (struct mi_parse *parse)
1272 if (parse->cmd->argv_func != NULL
1273 || parse->cmd->args_func != NULL)
1275 /* FIXME: We need to save the token because the command executed
1276 may be asynchronous and need to print the token again.
1277 In the future we can pass the token down to the func
1278 and get rid of the last_async_command. */
1279 /* The problem here is to keep the token around when we launch
1280 the target, and we want to interrupt it later on. The
1281 interrupt command will have its own token, but when the
1282 target stops, we must display the token corresponding to the
1283 last execution command given. So we have another string where
1284 we copy the token (previous_async_command), if this was
1285 indeed the token of an execution command, and when we stop we
1286 print that one. This is possible because the interrupt
1287 command, when over, will copy that token back into the
1288 default token string (last_async_command). */
1290 if (target_executing)
1292 if (!previous_async_command)
1293 previous_async_command = xstrdup (last_async_command);
1294 if (strcmp (parse->command, "exec-interrupt"))
1296 fputs_unfiltered (parse->token, raw_stdout);
1297 fputs_unfiltered ("^error,msg=\"", raw_stdout);
1298 fputs_unfiltered ("Cannot execute command ", raw_stdout);
1299 fputstr_unfiltered (parse->command, '"', raw_stdout);
1300 fputs_unfiltered (" while target running", raw_stdout);
1301 fputs_unfiltered ("\"\n", raw_stdout);
1302 return MI_CMD_ERROR;
1305 last_async_command = xstrdup (parse->token);
1306 make_exec_cleanup (free_current_contents, &last_async_command);
1307 /* FIXME: DELETE THIS! */
1308 if (parse->cmd->args_func != NULL)
1309 return parse->cmd->args_func (parse->args, 0 /*from_tty */ );
1310 return parse->cmd->argv_func (parse->command, parse->argv, parse->argc);
1312 else if (parse->cmd->cli.cmd != 0)
1314 /* FIXME: DELETE THIS. */
1315 /* The operation is still implemented by a cli command. */
1316 /* Must be a synchronous one. */
1317 mi_execute_cli_command (parse->cmd->cli.cmd, parse->cmd->cli.args_p,
1323 /* FIXME: DELETE THIS. */
1324 fputs_unfiltered (parse->token, raw_stdout);
1325 fputs_unfiltered ("^error,msg=\"", raw_stdout);
1326 fputs_unfiltered ("Undefined mi command: ", raw_stdout);
1327 fputstr_unfiltered (parse->command, '"', raw_stdout);
1328 fputs_unfiltered (" (missing implementation)", raw_stdout);
1329 fputs_unfiltered ("\"\n", raw_stdout);
1330 return MI_CMD_ERROR;
1334 /* FIXME: This is just a hack so we can get some extra commands going.
1335 We don't want to channel things through the CLI, but call libgdb directly.
1336 Use only for synchronous commands. */
1339 mi_execute_cli_command (const char *cmd, int args_p, const char *args)
1343 struct cleanup *old_cleanups;
1346 run = xstrprintf ("%s %s", cmd, args);
1348 run = xstrdup (cmd);
1350 /* FIXME: gdb_???? */
1351 fprintf_unfiltered (gdb_stdout, "cli=%s run=%s\n",
1353 old_cleanups = make_cleanup (xfree, run);
1354 execute_command ( /*ui */ run, 0 /*from_tty */ );
1355 do_cleanups (old_cleanups);
1361 mi_execute_async_cli_command (char *mi, char *args, int from_tty)
1363 struct cleanup *old_cleanups;
1367 if (target_can_async_p ())
1369 async_args = (char *) xmalloc (strlen (args) + 2);
1370 make_exec_cleanup (free, async_args);
1371 strcpy (async_args, args);
1372 strcat (async_args, "&");
1373 run = xstrprintf ("%s %s", mi, async_args);
1374 make_exec_cleanup (free, run);
1375 add_continuation (mi_exec_async_cli_cmd_continuation, NULL);
1376 old_cleanups = NULL;
1380 run = xstrprintf ("%s %s", mi, args);
1381 old_cleanups = make_cleanup (xfree, run);
1384 if (!target_can_async_p ())
1386 /* NOTE: For synchronous targets asynchronous behavour is faked by
1387 printing out the GDB prompt before we even try to execute the
1389 if (last_async_command)
1390 fputs_unfiltered (last_async_command, raw_stdout);
1391 fputs_unfiltered ("^running\n", raw_stdout);
1392 fputs_unfiltered ("(gdb) \n", raw_stdout);
1393 gdb_flush (raw_stdout);
1397 /* FIXME: cagney/1999-11-29: Printing this message before
1398 calling execute_command is wrong. It should only be printed
1399 once gdb has confirmed that it really has managed to send a
1400 run command to the target. */
1401 if (last_async_command)
1402 fputs_unfiltered (last_async_command, raw_stdout);
1403 fputs_unfiltered ("^running\n", raw_stdout);
1406 execute_command ( /*ui */ run, 0 /*from_tty */ );
1408 if (!target_can_async_p ())
1410 /* Do this before doing any printing. It would appear that some
1411 print code leaves garbage around in the buffer. */
1412 do_cleanups (old_cleanups);
1413 /* If the target was doing the operation synchronously we fake
1414 the stopped message. */
1415 if (last_async_command)
1416 fputs_unfiltered (last_async_command, raw_stdout);
1417 fputs_unfiltered ("*stopped", raw_stdout);
1418 mi_out_put (uiout, raw_stdout);
1419 mi_out_rewind (uiout);
1421 print_diff_now (current_command_ts);
1422 fputs_unfiltered ("\n", raw_stdout);
1423 return MI_CMD_QUIET;
1429 mi_exec_async_cli_cmd_continuation (struct continuation_arg *arg)
1431 if (last_async_command)
1432 fputs_unfiltered (last_async_command, raw_stdout);
1433 fputs_unfiltered ("*stopped", raw_stdout);
1434 mi_out_put (uiout, raw_stdout);
1435 fputs_unfiltered ("\n", raw_stdout);
1436 fputs_unfiltered ("(gdb) \n", raw_stdout);
1437 gdb_flush (raw_stdout);
1438 do_exec_cleanups (ALL_CLEANUPS);
1442 mi_load_progress (const char *section_name,
1443 unsigned long sent_so_far,
1444 unsigned long total_section,
1445 unsigned long total_sent,
1446 unsigned long grand_total)
1448 struct timeval time_now, delta, update_threshold;
1449 static struct timeval last_update;
1450 static char *previous_sect_name = NULL;
1452 struct ui_out *saved_uiout;
1454 /* This function is called through deprecated_show_load_progress
1455 which means uiout may not be correct. Fix it for the duration
1456 of this function. */
1457 saved_uiout = uiout;
1459 if (current_interp_named_p (INTERP_MI))
1460 uiout = mi_out_new (2);
1461 else if (current_interp_named_p (INTERP_MI1))
1462 uiout = mi_out_new (1);
1466 update_threshold.tv_sec = 0;
1467 update_threshold.tv_usec = 500000;
1468 gettimeofday (&time_now, NULL);
1470 delta.tv_usec = time_now.tv_usec - last_update.tv_usec;
1471 delta.tv_sec = time_now.tv_sec - last_update.tv_sec;
1473 if (delta.tv_usec < 0)
1476 delta.tv_usec += 1000000L;
1479 new_section = (previous_sect_name ?
1480 strcmp (previous_sect_name, section_name) : 1);
1483 struct cleanup *cleanup_tuple;
1484 xfree (previous_sect_name);
1485 previous_sect_name = xstrdup (section_name);
1487 if (last_async_command)
1488 fputs_unfiltered (last_async_command, raw_stdout);
1489 fputs_unfiltered ("+download", raw_stdout);
1490 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1491 ui_out_field_string (uiout, "section", section_name);
1492 ui_out_field_int (uiout, "section-size", total_section);
1493 ui_out_field_int (uiout, "total-size", grand_total);
1494 do_cleanups (cleanup_tuple);
1495 mi_out_put (uiout, raw_stdout);
1496 fputs_unfiltered ("\n", raw_stdout);
1497 gdb_flush (raw_stdout);
1500 if (delta.tv_sec >= update_threshold.tv_sec &&
1501 delta.tv_usec >= update_threshold.tv_usec)
1503 struct cleanup *cleanup_tuple;
1504 last_update.tv_sec = time_now.tv_sec;
1505 last_update.tv_usec = time_now.tv_usec;
1506 if (last_async_command)
1507 fputs_unfiltered (last_async_command, raw_stdout);
1508 fputs_unfiltered ("+download", raw_stdout);
1509 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1510 ui_out_field_string (uiout, "section", section_name);
1511 ui_out_field_int (uiout, "section-sent", sent_so_far);
1512 ui_out_field_int (uiout, "section-size", total_section);
1513 ui_out_field_int (uiout, "total-sent", total_sent);
1514 ui_out_field_int (uiout, "total-size", grand_total);
1515 do_cleanups (cleanup_tuple);
1516 mi_out_put (uiout, raw_stdout);
1517 fputs_unfiltered ("\n", raw_stdout);
1518 gdb_flush (raw_stdout);
1522 uiout = saved_uiout;
1526 timestamp (struct mi_timestamp *tv)
1529 gettimeofday (&tv->wallclock, NULL);
1530 #ifdef HAVE_GETRUSAGE
1531 getrusage (RUSAGE_SELF, &rusage);
1532 tv->utime.tv_sec = rusage.ru_utime.tv_sec;
1533 tv->utime.tv_usec = rusage.ru_utime.tv_usec;
1534 tv->stime.tv_sec = rusage.ru_stime.tv_sec;
1535 tv->stime.tv_usec = rusage.ru_stime.tv_usec;
1537 usec = get_run_time ();
1538 tv->utime.tv_sec = usec/1000000L;
1539 tv->utime.tv_usec = usec - 1000000L*tv->utime.tv_sec;
1540 tv->stime.tv_sec = 0;
1541 tv->stime.tv_usec = 0;
1546 print_diff_now (struct mi_timestamp *start)
1548 struct mi_timestamp now;
1550 print_diff (start, &now);
1554 timeval_diff (struct timeval start, struct timeval end)
1556 return ((end.tv_sec - start.tv_sec) * 1000000L)
1557 + (end.tv_usec - start.tv_usec);
1561 print_diff (struct mi_timestamp *start, struct mi_timestamp *end)
1565 ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
1566 timeval_diff (start->wallclock, end->wallclock) / 1000000.0,
1567 timeval_diff (start->utime, end->utime) / 1000000.0,
1568 timeval_diff (start->stime, end->stime) / 1000000.0);