3 Copyright 2000, 2001, 2002, 2003, 2004 Free Software Foundation,
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., 59 Temple Place - Suite 330,
23 Boston, MA 02111-1307, USA. */
25 /* Work in progress */
30 #include "gdb_string.h"
32 #include "gdbthread.h"
35 #include "mi-getopt.h"
36 #include "mi-console.h"
40 #include "event-loop.h"
41 #include "event-top.h"
42 #include "gdbcore.h" /* for write_memory() */
43 #include "value.h" /* for deprecated_write_register_bytes() */
57 /* Enumerations of the actions that may result from calling
58 captured_mi_execute_command */
60 enum captured_mi_execute_command_actions
62 EXECUTE_COMMAND_DISPLAY_PROMPT,
63 EXECUTE_COMMAND_SUPRESS_PROMPT,
64 EXECUTE_COMMAND_DISPLAY_ERROR
67 /* This structure is used to pass information from captured_mi_execute_command
68 to mi_execute_command. */
69 struct captured_mi_execute_command_args
71 /* This return result of the MI command (output) */
72 enum mi_cmd_result rc;
74 /* What action to perform when the call is finished (output) */
75 enum captured_mi_execute_command_actions action;
77 /* The command context to be executed (input) */
78 struct mi_parse *command;
82 struct ui_file *raw_stdout;
84 /* The token of the last asynchronous command */
85 static char *last_async_command;
86 static char *previous_async_command;
87 char *mi_error_message;
88 static char *old_regs;
90 extern void _initialize_mi_main (void);
91 static enum mi_cmd_result mi_cmd_execute (struct mi_parse *parse);
93 static void mi_execute_cli_command (const char *cmd, int args_p,
95 static enum mi_cmd_result mi_execute_async_cli_command (char *mi, char *args, int from_tty);
97 static void mi_exec_async_cli_cmd_continuation (struct continuation_arg *arg);
99 static int register_changed_p (int regnum);
100 static int get_register (int regnum, int format);
102 /* A helper function which will set mi_error_message to
103 error_last_message. */
105 mi_error_last_message (void)
107 char *s = error_last_message ();
108 xasprintf (&mi_error_message, "%s", s);
112 /* Command implementations. FIXME: Is this libgdb? No. This is the MI
113 layer that calls libgdb. Any operation used in the below should be
117 mi_cmd_gdb_exit (char *command, char **argv, int argc)
119 /* We have to print everything right here because we never return */
120 if (last_async_command)
121 fputs_unfiltered (last_async_command, raw_stdout);
122 fputs_unfiltered ("^exit\n", raw_stdout);
123 mi_out_put (uiout, raw_stdout);
124 /* FIXME: The function called is not yet a formal libgdb function */
125 quit_force (NULL, FROM_TTY);
130 mi_cmd_exec_run (char *args, int from_tty)
132 /* FIXME: Should call a libgdb function, not a cli wrapper */
133 return mi_execute_async_cli_command ("run", args, from_tty);
137 mi_cmd_exec_next (char *args, int from_tty)
139 /* FIXME: Should call a libgdb function, not a cli wrapper */
140 return mi_execute_async_cli_command ("next", args, from_tty);
144 mi_cmd_exec_next_instruction (char *args, int from_tty)
146 /* FIXME: Should call a libgdb function, not a cli wrapper */
147 return mi_execute_async_cli_command ("nexti", args, from_tty);
151 mi_cmd_exec_step (char *args, int from_tty)
153 /* FIXME: Should call a libgdb function, not a cli wrapper */
154 return mi_execute_async_cli_command ("step", args, from_tty);
158 mi_cmd_exec_step_instruction (char *args, int from_tty)
160 /* FIXME: Should call a libgdb function, not a cli wrapper */
161 return mi_execute_async_cli_command ("stepi", args, from_tty);
165 mi_cmd_exec_finish (char *args, int from_tty)
167 /* FIXME: Should call a libgdb function, not a cli wrapper */
168 return mi_execute_async_cli_command ("finish", args, from_tty);
172 mi_cmd_exec_until (char *args, int from_tty)
174 /* FIXME: Should call a libgdb function, not a cli wrapper */
175 return mi_execute_async_cli_command ("until", args, from_tty);
179 mi_cmd_exec_return (char *args, int from_tty)
181 /* This command doesn't really execute the target, it just pops the
182 specified number of frames. */
184 /* Call return_command with from_tty argument equal to 0 so as to
185 avoid being queried. */
186 return_command (args, 0);
188 /* Call return_command with from_tty argument equal to 0 so as to
189 avoid being queried. */
190 return_command (NULL, 0);
192 /* Because we have called return_command with from_tty = 0, we need
193 to print the frame here. */
194 print_stack_frame (deprecated_selected_frame,
195 frame_relative_level (deprecated_selected_frame),
202 mi_cmd_exec_continue (char *args, int from_tty)
204 /* FIXME: Should call a libgdb function, not a cli wrapper */
205 return mi_execute_async_cli_command ("continue", args, from_tty);
208 /* Interrupt the execution of the target. Note how we must play around
209 with the token varialbes, in order to display the current token in
210 the result of the interrupt command, and the previous execution
211 token when the target finally stops. See comments in
214 mi_cmd_exec_interrupt (char *args, int from_tty)
216 if (!target_executing)
218 xasprintf (&mi_error_message,
219 "mi_cmd_exec_interrupt: Inferior not executing.");
222 interrupt_target_command (args, from_tty);
223 if (last_async_command)
224 fputs_unfiltered (last_async_command, raw_stdout);
225 fputs_unfiltered ("^done", raw_stdout);
226 xfree (last_async_command);
227 if (previous_async_command)
228 last_async_command = xstrdup (previous_async_command);
229 xfree (previous_async_command);
230 previous_async_command = NULL;
231 mi_out_put (uiout, raw_stdout);
232 mi_out_rewind (uiout);
233 fputs_unfiltered ("\n", raw_stdout);
238 mi_cmd_thread_select (char *command, char **argv, int argc)
244 xasprintf (&mi_error_message,
245 "mi_cmd_thread_select: USAGE: threadnum.");
249 rc = gdb_thread_select (uiout, argv[0]);
251 /* RC is enum gdb_rc if it is successful (>=0)
252 enum return_reason if not (<0). */
253 if ((int) rc < 0 && (enum return_reason) rc == RETURN_ERROR)
254 return MI_CMD_CAUGHT_ERROR;
255 else if ((int) rc >= 0 && rc == GDB_RC_FAIL)
262 mi_cmd_thread_list_ids (char *command, char **argv, int argc)
264 enum gdb_rc rc = MI_CMD_DONE;
268 xasprintf (&mi_error_message,
269 "mi_cmd_thread_list_ids: No arguments required.");
273 rc = gdb_list_thread_ids (uiout);
275 if (rc == GDB_RC_FAIL)
276 return MI_CMD_CAUGHT_ERROR;
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 xasprintf (&mi_error_message, "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 int regnum, numregs, changed;
337 struct cleanup *cleanup;
339 /* Note that the test for a valid register must include checking the
340 REGISTER_NAME because NUM_REGS may be allocated for the union of
341 the register sets within a family of related processors. In this
342 case, some entries of REGISTER_NAME will change depending upon
343 the particular processor being debugged. */
347 cleanup = make_cleanup_ui_out_list_begin_end (uiout, "changed-registers");
349 if (argc == 0) /* No args, just do all the regs */
355 if (REGISTER_NAME (regnum) == NULL
356 || *(REGISTER_NAME (regnum)) == '\0')
358 changed = register_changed_p (regnum);
361 do_cleanups (cleanup);
362 xasprintf (&mi_error_message,
363 "mi_cmd_data_list_changed_registers: Unable to read register contents.");
367 ui_out_field_int (uiout, NULL, regnum);
371 /* Else, list of register #s, just do listed regs */
372 for (i = 0; i < argc; i++)
374 regnum = atoi (argv[i]);
378 && REGISTER_NAME (regnum) != NULL
379 && *REGISTER_NAME (regnum) != '\000')
381 changed = register_changed_p (regnum);
384 do_cleanups (cleanup);
385 xasprintf (&mi_error_message,
386 "mi_cmd_data_list_register_change: Unable to read register contents.");
390 ui_out_field_int (uiout, NULL, regnum);
394 do_cleanups (cleanup);
395 xasprintf (&mi_error_message, "bad register number");
399 do_cleanups (cleanup);
404 register_changed_p (int regnum)
406 char raw_buffer[MAX_REGISTER_SIZE];
408 if (! frame_register_read (deprecated_selected_frame, regnum, raw_buffer))
411 if (memcmp (&old_regs[DEPRECATED_REGISTER_BYTE (regnum)], raw_buffer,
412 DEPRECATED_REGISTER_RAW_SIZE (regnum)) == 0)
415 /* Found a changed register. Return 1. */
417 memcpy (&old_regs[DEPRECATED_REGISTER_BYTE (regnum)], raw_buffer,
418 DEPRECATED_REGISTER_RAW_SIZE (regnum));
423 /* Return a list of register number and value pairs. The valid
424 arguments expected are: a letter indicating the format in which to
425 display the registers contents. This can be one of: x (hexadecimal), d
426 (decimal), N (natural), t (binary), o (octal), r (raw). After the
427 format argumetn there can be a sequence of numbers, indicating which
428 registers to fetch the content of. If the format is the only argument,
429 a list of all the registers with their values is returned. */
431 mi_cmd_data_list_register_values (char *command, char **argv, int argc)
433 int regnum, numregs, format, result;
435 struct cleanup *list_cleanup, *tuple_cleanup;
437 /* Note that the test for a valid register must include checking the
438 REGISTER_NAME because NUM_REGS may be allocated for the union of
439 the register sets within a family of related processors. In this
440 case, some entries of REGISTER_NAME will change depending upon
441 the particular processor being debugged. */
447 xasprintf (&mi_error_message,
448 "mi_cmd_data_list_register_values: Usage: -data-list-register-values <format> [<regnum1>...<regnumN>]");
452 format = (int) argv[0][0];
454 if (!target_has_registers)
456 xasprintf (&mi_error_message,
457 "mi_cmd_data_list_register_values: No registers.");
461 list_cleanup = make_cleanup_ui_out_list_begin_end (uiout, "register-values");
463 if (argc == 1) /* No args, beside the format: do all the regs */
469 if (REGISTER_NAME (regnum) == NULL
470 || *(REGISTER_NAME (regnum)) == '\0')
472 tuple_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
473 ui_out_field_int (uiout, "number", regnum);
474 result = get_register (regnum, format);
477 do_cleanups (list_cleanup);
480 do_cleanups (tuple_cleanup);
484 /* Else, list of register #s, just do listed regs */
485 for (i = 1; i < argc; i++)
487 regnum = atoi (argv[i]);
491 && REGISTER_NAME (regnum) != NULL
492 && *REGISTER_NAME (regnum) != '\000')
494 tuple_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
495 ui_out_field_int (uiout, "number", regnum);
496 result = get_register (regnum, format);
499 do_cleanups (list_cleanup);
502 do_cleanups (tuple_cleanup);
506 do_cleanups (list_cleanup);
507 xasprintf (&mi_error_message, "bad register number");
511 do_cleanups (list_cleanup);
515 /* Output one register's contents in the desired format. */
517 get_register (int regnum, int format)
519 char raw_buffer[MAX_REGISTER_SIZE];
520 char virtual_buffer[MAX_REGISTER_SIZE];
525 static struct ui_stream *stb = NULL;
527 stb = ui_out_stream_new (uiout);
532 frame_register (deprecated_selected_frame, regnum, &optim, &lval, &addr,
533 &realnum, raw_buffer);
537 xasprintf (&mi_error_message, "Optimized out");
541 /* Convert raw data to virtual format if necessary. */
543 if (DEPRECATED_REGISTER_CONVERTIBLE_P ()
544 && DEPRECATED_REGISTER_CONVERTIBLE (regnum))
546 DEPRECATED_REGISTER_CONVERT_TO_VIRTUAL (regnum,
547 register_type (current_gdbarch, regnum),
548 raw_buffer, virtual_buffer);
551 memcpy (virtual_buffer, raw_buffer, DEPRECATED_REGISTER_VIRTUAL_SIZE (regnum));
556 char *ptr, buf[1024];
560 for (j = 0; j < DEPRECATED_REGISTER_RAW_SIZE (regnum); j++)
562 int idx = TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? j
563 : DEPRECATED_REGISTER_RAW_SIZE (regnum) - 1 - j;
564 sprintf (ptr, "%02x", (unsigned char) raw_buffer[idx]);
567 ui_out_field_string (uiout, "value", buf);
568 /*fputs_filtered (buf, gdb_stdout); */
572 val_print (register_type (current_gdbarch, regnum), virtual_buffer, 0, 0,
573 stb->stream, format, 1, 0, Val_pretty_default);
574 ui_out_field_stream (uiout, "value", stb);
575 ui_out_stream_delete (stb);
580 /* Write given values into registers. The registers and values are
581 given as pairs. The corresponding MI command is
582 -data-write-register-values <format> [<regnum1> <value1>...<regnumN> <valueN>]*/
584 mi_cmd_data_write_register_values (char *command, char **argv, int argc)
592 /* Note that the test for a valid register must include checking the
593 REGISTER_NAME because NUM_REGS may be allocated for the union of
594 the register sets within a family of related processors. In this
595 case, some entries of REGISTER_NAME will change depending upon
596 the particular processor being debugged. */
602 xasprintf (&mi_error_message,
603 "mi_cmd_data_write_register_values: Usage: -data-write-register-values <format> [<regnum1> <value1>...<regnumN> <valueN>]");
607 format = (int) argv[0][0];
609 if (!target_has_registers)
611 xasprintf (&mi_error_message,
612 "mi_cmd_data_write_register_values: No registers.");
618 xasprintf (&mi_error_message,
619 "mi_cmd_data_write_register_values: No regs and values specified.");
625 xasprintf (&mi_error_message,
626 "mi_cmd_data_write_register_values: Regs and vals are not in pairs.");
630 for (i = 1; i < argc; i = i + 2)
632 regnum = atoi (argv[i]);
636 && REGISTER_NAME (regnum) != NULL
637 && *REGISTER_NAME (regnum) != '\000')
640 struct cleanup *old_chain;
642 /* Get the value as a number */
643 value = parse_and_eval_address (argv[i + 1]);
644 /* Get the value into an array */
645 buffer = xmalloc (DEPRECATED_REGISTER_SIZE);
646 old_chain = make_cleanup (xfree, buffer);
647 store_signed_integer (buffer, DEPRECATED_REGISTER_SIZE, value);
649 deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (regnum), buffer, DEPRECATED_REGISTER_RAW_SIZE (regnum));
650 /* Free the buffer. */
651 do_cleanups (old_chain);
655 xasprintf (&mi_error_message, "bad register number");
663 /*This is commented out because we decided it was not useful. I leave
664 it, just in case. ezannoni:1999-12-08 */
666 /* Assign a value to a variable. The expression argument must be in
667 the form A=2 or "A = 2" (I.e. if there are spaces it needs to be
670 mi_cmd_data_assign (char *command, char **argv, int argc)
672 struct expression *expr;
673 struct cleanup *old_chain;
677 xasprintf (&mi_error_message,
678 "mi_cmd_data_assign: Usage: -data-assign expression");
682 /* NOTE what follows is a clone of set_command(). FIXME: ezannoni
683 01-12-1999: Need to decide what to do with this for libgdb purposes. */
685 expr = parse_expression (argv[0]);
686 old_chain = make_cleanup (free_current_contents, &expr);
687 evaluate_expression (expr);
688 do_cleanups (old_chain);
693 /* Evaluate the value of the argument. The argument is an
694 expression. If the expression contains spaces it needs to be
695 included in double quotes. */
697 mi_cmd_data_evaluate_expression (char *command, char **argv, int argc)
699 struct expression *expr;
700 struct cleanup *old_chain = NULL;
702 struct ui_stream *stb = NULL;
704 stb = ui_out_stream_new (uiout);
708 xasprintf (&mi_error_message,
709 "mi_cmd_data_evaluate_expression: Usage: -data-evaluate-expression expression");
713 expr = parse_expression (argv[0]);
715 old_chain = make_cleanup (free_current_contents, &expr);
717 val = evaluate_expression (expr);
719 /* Print the result of the expression evaluation. */
720 val_print (VALUE_TYPE (val), VALUE_CONTENTS (val),
721 VALUE_EMBEDDED_OFFSET (val), VALUE_ADDRESS (val),
722 stb->stream, 0, 0, 0, 0);
724 ui_out_field_stream (uiout, "value", stb);
725 ui_out_stream_delete (stb);
727 do_cleanups (old_chain);
733 mi_cmd_target_download (char *args, int from_tty)
736 struct cleanup *old_cleanups = NULL;
738 xasprintf (&run, "load %s", args);
739 old_cleanups = make_cleanup (xfree, run);
740 execute_command (run, from_tty);
742 do_cleanups (old_cleanups);
746 /* Connect to the remote target. */
748 mi_cmd_target_select (char *args, int from_tty)
751 struct cleanup *old_cleanups = NULL;
753 xasprintf (&run, "target %s", args);
754 old_cleanups = make_cleanup (xfree, run);
756 /* target-select is always synchronous. once the call has returned
757 we know that we are connected. */
758 /* NOTE: At present all targets that are connected are also
759 (implicitly) talking to a halted target. In the future this may
761 execute_command (run, from_tty);
763 do_cleanups (old_cleanups);
765 /* Issue the completion message here. */
766 if (last_async_command)
767 fputs_unfiltered (last_async_command, raw_stdout);
768 fputs_unfiltered ("^connected", raw_stdout);
769 mi_out_put (uiout, raw_stdout);
770 mi_out_rewind (uiout);
771 fputs_unfiltered ("\n", raw_stdout);
772 do_exec_cleanups (ALL_CLEANUPS);
778 ADDR: start address of data to be dumped.
779 WORD-FORMAT: a char indicating format for the ``word''. See
781 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes
782 NR_ROW: Number of rows.
783 NR_COL: The number of colums (words per row).
784 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
785 ASCHAR for unprintable characters.
787 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
788 displayes them. Returns:
790 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
793 The number of bytes read is SIZE*ROW*COL. */
796 mi_cmd_data_read_memory (char *command, char **argv, int argc)
798 struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
804 struct type *word_type;
817 static struct mi_opt opts[] =
819 {"o", OFFSET_OPT, 1},
825 int opt = mi_getopt ("mi_cmd_data_read_memory", argc, argv, opts,
829 switch ((enum opt) opt)
832 offset = atol (optarg);
839 if (argc < 5 || argc > 6)
841 xasprintf (&mi_error_message,
842 "mi_cmd_data_read_memory: Usage: ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR].");
846 /* Extract all the arguments. */
848 /* Start address of the memory dump. */
849 addr = parse_and_eval_address (argv[0]) + offset;
850 /* The format character to use when displaying a memory word. See
851 the ``x'' command. */
852 word_format = argv[1][0];
853 /* The size of the memory word. */
854 word_size = atol (argv[2]);
858 word_type = builtin_type_int8;
862 word_type = builtin_type_int16;
866 word_type = builtin_type_int32;
870 word_type = builtin_type_int64;
874 word_type = builtin_type_int8;
877 /* The number of rows */
878 nr_rows = atol (argv[3]);
881 xasprintf (&mi_error_message,
882 "mi_cmd_data_read_memory: invalid number of rows.");
885 /* number of bytes per row. */
886 nr_cols = atol (argv[4]);
889 xasprintf (&mi_error_message,
890 "mi_cmd_data_read_memory: invalid number of columns.");
892 /* The un-printable character when printing ascii. */
898 /* create a buffer and read it in. */
899 total_bytes = word_size * nr_rows * nr_cols;
900 mbuf = xcalloc (total_bytes, 1);
901 make_cleanup (xfree, mbuf);
904 xasprintf (&mi_error_message,
905 "mi_cmd_data_read_memory: out of memory.");
909 while (nr_bytes < total_bytes)
912 long num = target_read_memory_partial (addr + nr_bytes, mbuf + nr_bytes,
913 total_bytes - nr_bytes,
920 /* output the header information. */
921 ui_out_field_core_addr (uiout, "addr", addr);
922 ui_out_field_int (uiout, "nr-bytes", nr_bytes);
923 ui_out_field_int (uiout, "total-bytes", total_bytes);
924 ui_out_field_core_addr (uiout, "next-row", addr + word_size * nr_cols);
925 ui_out_field_core_addr (uiout, "prev-row", addr - word_size * nr_cols);
926 ui_out_field_core_addr (uiout, "next-page", addr + total_bytes);
927 ui_out_field_core_addr (uiout, "prev-page", addr - total_bytes);
929 /* Build the result as a two dimentional table. */
931 struct ui_stream *stream = ui_out_stream_new (uiout);
932 struct cleanup *cleanup_list_memory;
935 cleanup_list_memory = make_cleanup_ui_out_list_begin_end (uiout, "memory");
936 for (row = 0, row_byte = 0;
938 row++, row_byte += nr_cols * word_size)
942 struct cleanup *cleanup_tuple;
943 struct cleanup *cleanup_list_data;
944 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
945 ui_out_field_core_addr (uiout, "addr", addr + row_byte);
946 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr + row_byte); */
947 cleanup_list_data = make_cleanup_ui_out_list_begin_end (uiout, "data");
948 for (col = 0, col_byte = row_byte;
950 col++, col_byte += word_size)
952 if (col_byte + word_size > nr_bytes)
954 ui_out_field_string (uiout, NULL, "N/A");
958 ui_file_rewind (stream->stream);
959 print_scalar_formatted (mbuf + col_byte, word_type, word_format,
960 word_asize, stream->stream);
961 ui_out_field_stream (uiout, NULL, stream);
964 do_cleanups (cleanup_list_data);
968 ui_file_rewind (stream->stream);
969 for (byte = row_byte; byte < row_byte + word_size * nr_cols; byte++)
971 if (byte >= nr_bytes)
973 fputc_unfiltered ('X', stream->stream);
975 else if (mbuf[byte] < 32 || mbuf[byte] > 126)
977 fputc_unfiltered (aschar, stream->stream);
980 fputc_unfiltered (mbuf[byte], stream->stream);
982 ui_out_field_stream (uiout, "ascii", stream);
984 do_cleanups (cleanup_tuple);
986 ui_out_stream_delete (stream);
987 do_cleanups (cleanup_list_memory);
989 do_cleanups (cleanups);
993 /* DATA-MEMORY-WRITE:
995 COLUMN_OFFSET: optional argument. Must be preceeded by '-o'. The
996 offset from the beginning of the memory grid row where the cell to
998 ADDR: start address of the row in the memory grid where the memory
999 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
1000 the location to write to.
1001 FORMAT: a char indicating format for the ``word''. See
1003 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
1004 VALUE: value to be written into the memory address.
1006 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
1010 mi_cmd_data_write_memory (char *command, char **argv, int argc)
1015 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
1016 enough when using a compiler other than GCC. */
1019 struct cleanup *old_chain;
1027 static struct mi_opt opts[] =
1029 {"o", OFFSET_OPT, 1},
1035 int opt = mi_getopt ("mi_cmd_data_write_memory", argc, argv, opts,
1039 switch ((enum opt) opt)
1042 offset = atol (optarg);
1051 xasprintf (&mi_error_message,
1052 "mi_cmd_data_write_memory: Usage: [-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE.");
1053 return MI_CMD_ERROR;
1056 /* Extract all the arguments. */
1057 /* Start address of the memory dump. */
1058 addr = parse_and_eval_address (argv[0]);
1059 /* The format character to use when displaying a memory word. See
1060 the ``x'' command. */
1061 word_format = argv[1][0];
1062 /* The size of the memory word. */
1063 word_size = atol (argv[2]);
1065 /* Calculate the real address of the write destination. */
1066 addr += (offset * word_size);
1068 /* Get the value as a number */
1069 value = parse_and_eval_address (argv[3]);
1070 /* Get the value into an array */
1071 buffer = xmalloc (word_size);
1072 old_chain = make_cleanup (xfree, buffer);
1073 store_signed_integer (buffer, word_size, value);
1074 /* Write it down to memory */
1075 write_memory (addr, buffer, word_size);
1076 /* Free the buffer. */
1077 do_cleanups (old_chain);
1082 /* Execute a command within a safe environment.
1083 Return <0 for error; >=0 for ok.
1085 args->action will tell mi_execute_command what action
1086 to perfrom after the given command has executed (display/supress
1087 prompt, display error). */
1090 captured_mi_execute_command (struct ui_out *uiout, void *data)
1092 struct captured_mi_execute_command_args *args =
1093 (struct captured_mi_execute_command_args *) data;
1094 struct mi_parse *context = args->command;
1096 switch (context->op)
1100 /* A MI command was read from the input stream */
1102 /* FIXME: gdb_???? */
1103 fprintf_unfiltered (raw_stdout, " token=`%s' command=`%s' args=`%s'\n",
1104 context->token, context->command, context->args);
1105 /* FIXME: cagney/1999-09-25: Rather than this convoluted
1106 condition expression, each function should return an
1107 indication of what action is required and then switch on
1109 args->action = EXECUTE_COMMAND_DISPLAY_PROMPT;
1110 args->rc = mi_cmd_execute (context);
1112 if (!target_can_async_p () || !target_executing)
1114 /* print the result if there were no errors
1116 Remember that on the way out of executing a command, you have
1117 to directly use the mi_interp's uiout, since the command could
1118 have reset the interpreter, in which case the current uiout
1119 will most likely crash in the mi_out_* routines. */
1120 if (args->rc == MI_CMD_DONE)
1122 fputs_unfiltered (context->token, raw_stdout);
1123 fputs_unfiltered ("^done", raw_stdout);
1124 mi_out_put (uiout, raw_stdout);
1125 mi_out_rewind (uiout);
1126 fputs_unfiltered ("\n", raw_stdout);
1128 else if (args->rc == MI_CMD_ERROR)
1130 if (mi_error_message)
1132 fputs_unfiltered (context->token, raw_stdout);
1133 fputs_unfiltered ("^error,msg=\"", raw_stdout);
1134 fputstr_unfiltered (mi_error_message, '"', raw_stdout);
1135 xfree (mi_error_message);
1136 fputs_unfiltered ("\"\n", raw_stdout);
1138 mi_out_rewind (uiout);
1140 else if (args->rc == MI_CMD_CAUGHT_ERROR)
1142 mi_out_rewind (uiout);
1143 args->action = EXECUTE_COMMAND_DISPLAY_ERROR;
1147 mi_out_rewind (uiout);
1149 else if (sync_execution)
1151 /* Don't print the prompt. We are executing the target in
1152 synchronous mode. */
1153 args->action = EXECUTE_COMMAND_SUPRESS_PROMPT;
1159 /* A CLI command was read from the input stream */
1160 /* This will be removed as soon as we have a complete set of
1162 /* echo the command on the console. */
1163 fprintf_unfiltered (gdb_stdlog, "%s\n", context->command);
1164 mi_execute_cli_command (context->command, 0, NULL);
1166 /* If we changed interpreters, DON'T print out anything. */
1167 if (current_interp_named_p (INTERP_MI)
1168 || current_interp_named_p (INTERP_MI1)
1169 || current_interp_named_p (INTERP_MI2)
1170 || current_interp_named_p (INTERP_MI3))
1172 /* print the result */
1173 /* FIXME: Check for errors here. */
1174 fputs_unfiltered (context->token, raw_stdout);
1175 fputs_unfiltered ("^done", raw_stdout);
1176 mi_out_put (uiout, raw_stdout);
1177 mi_out_rewind (uiout);
1178 fputs_unfiltered ("\n", raw_stdout);
1179 args->action = EXECUTE_COMMAND_DISPLAY_PROMPT;
1180 args->rc = MI_CMD_DONE;
1191 mi_execute_command (char *cmd, int from_tty)
1193 struct mi_parse *command;
1194 struct captured_mi_execute_command_args args;
1195 struct ui_out *saved_uiout = uiout;
1198 /* This is to handle EOF (^D). We just quit gdb. */
1199 /* FIXME: we should call some API function here. */
1201 quit_force (NULL, from_tty);
1203 command = mi_parse (cmd);
1205 if (command != NULL)
1207 /* FIXME: cagney/1999-11-04: Can this use of catch_exceptions either
1208 be pushed even further down or even eliminated? */
1209 args.command = command;
1210 result = catch_exceptions (uiout, captured_mi_execute_command, &args, "",
1213 if (args.action == EXECUTE_COMMAND_SUPRESS_PROMPT)
1215 /* The command is executing synchronously. Bail out early
1216 suppressing the finished prompt. */
1217 mi_parse_free (command);
1220 if (args.action == EXECUTE_COMMAND_DISPLAY_ERROR || result < 0)
1222 char *msg = error_last_message ();
1223 struct cleanup *cleanup = make_cleanup (xfree, msg);
1224 /* The command execution failed and error() was called
1226 fputs_unfiltered (command->token, raw_stdout);
1227 fputs_unfiltered ("^error,msg=\"", raw_stdout);
1228 fputstr_unfiltered (msg, '"', raw_stdout);
1229 fputs_unfiltered ("\"\n", raw_stdout);
1231 mi_parse_free (command);
1234 fputs_unfiltered ("(gdb) \n", raw_stdout);
1235 gdb_flush (raw_stdout);
1236 /* print any buffered hook code */
1240 static enum mi_cmd_result
1241 mi_cmd_execute (struct mi_parse *parse)
1243 if (parse->cmd->argv_func != NULL
1244 || parse->cmd->args_func != NULL)
1246 /* FIXME: We need to save the token because the command executed
1247 may be asynchronous and need to print the token again.
1248 In the future we can pass the token down to the func
1249 and get rid of the last_async_command */
1250 /* The problem here is to keep the token around when we launch
1251 the target, and we want to interrupt it later on. The
1252 interrupt command will have its own token, but when the
1253 target stops, we must display the token corresponding to the
1254 last execution command given. So we have another string where
1255 we copy the token (previous_async_command), if this was
1256 indeed the token of an execution command, and when we stop we
1257 print that one. This is possible because the interrupt
1258 command, when over, will copy that token back into the
1259 default token string (last_async_command). */
1261 if (target_executing)
1263 if (!previous_async_command)
1264 previous_async_command = xstrdup (last_async_command);
1265 if (strcmp (parse->command, "exec-interrupt"))
1267 fputs_unfiltered (parse->token, raw_stdout);
1268 fputs_unfiltered ("^error,msg=\"", raw_stdout);
1269 fputs_unfiltered ("Cannot execute command ", raw_stdout);
1270 fputstr_unfiltered (parse->command, '"', raw_stdout);
1271 fputs_unfiltered (" while target running", raw_stdout);
1272 fputs_unfiltered ("\"\n", raw_stdout);
1273 return MI_CMD_ERROR;
1276 last_async_command = xstrdup (parse->token);
1277 make_exec_cleanup (free_current_contents, &last_async_command);
1278 /* FIXME: DELETE THIS! */
1279 if (parse->cmd->args_func != NULL)
1280 return parse->cmd->args_func (parse->args, 0 /*from_tty */ );
1281 return parse->cmd->argv_func (parse->command, parse->argv, parse->argc);
1283 else if (parse->cmd->cli.cmd != 0)
1285 /* FIXME: DELETE THIS. */
1286 /* The operation is still implemented by a cli command */
1287 /* Must be a synchronous one */
1288 mi_execute_cli_command (parse->cmd->cli.cmd, parse->cmd->cli.args_p,
1294 /* FIXME: DELETE THIS. */
1295 fputs_unfiltered (parse->token, raw_stdout);
1296 fputs_unfiltered ("^error,msg=\"", raw_stdout);
1297 fputs_unfiltered ("Undefined mi command: ", raw_stdout);
1298 fputstr_unfiltered (parse->command, '"', raw_stdout);
1299 fputs_unfiltered (" (missing implementation)", raw_stdout);
1300 fputs_unfiltered ("\"\n", raw_stdout);
1301 return MI_CMD_ERROR;
1305 /* FIXME: This is just a hack so we can get some extra commands going.
1306 We don't want to channel things through the CLI, but call libgdb directly */
1307 /* Use only for synchronous commands */
1310 mi_execute_cli_command (const char *cmd, int args_p, const char *args)
1314 struct cleanup *old_cleanups;
1317 xasprintf (&run, "%s %s", cmd, args);
1319 run = xstrdup (cmd);
1321 /* FIXME: gdb_???? */
1322 fprintf_unfiltered (gdb_stdout, "cli=%s run=%s\n",
1324 old_cleanups = make_cleanup (xfree, run);
1325 execute_command ( /*ui */ run, 0 /*from_tty */ );
1326 do_cleanups (old_cleanups);
1332 mi_execute_async_cli_command (char *mi, char *args, int from_tty)
1334 struct cleanup *old_cleanups;
1338 if (target_can_async_p ())
1340 async_args = (char *) xmalloc (strlen (args) + 2);
1341 make_exec_cleanup (free, async_args);
1342 strcpy (async_args, args);
1343 strcat (async_args, "&");
1344 xasprintf (&run, "%s %s", mi, async_args);
1345 make_exec_cleanup (free, run);
1346 add_continuation (mi_exec_async_cli_cmd_continuation, NULL);
1347 old_cleanups = NULL;
1351 xasprintf (&run, "%s %s", mi, args);
1352 old_cleanups = make_cleanup (xfree, run);
1355 if (!target_can_async_p ())
1357 /* NOTE: For synchronous targets asynchronous behavour is faked by
1358 printing out the GDB prompt before we even try to execute the
1360 if (last_async_command)
1361 fputs_unfiltered (last_async_command, raw_stdout);
1362 fputs_unfiltered ("^running\n", raw_stdout);
1363 fputs_unfiltered ("(gdb) \n", raw_stdout);
1364 gdb_flush (raw_stdout);
1368 /* FIXME: cagney/1999-11-29: Printing this message before
1369 calling execute_command is wrong. It should only be printed
1370 once gdb has confirmed that it really has managed to send a
1371 run command to the target. */
1372 if (last_async_command)
1373 fputs_unfiltered (last_async_command, raw_stdout);
1374 fputs_unfiltered ("^running\n", raw_stdout);
1377 execute_command ( /*ui */ run, 0 /*from_tty */ );
1379 if (!target_can_async_p ())
1381 /* Do this before doing any printing. It would appear that some
1382 print code leaves garbage around in the buffer. */
1383 do_cleanups (old_cleanups);
1384 /* If the target was doing the operation synchronously we fake
1385 the stopped message. */
1386 if (last_async_command)
1387 fputs_unfiltered (last_async_command, raw_stdout);
1388 fputs_unfiltered ("*stopped", raw_stdout);
1389 mi_out_put (uiout, raw_stdout);
1390 mi_out_rewind (uiout);
1391 fputs_unfiltered ("\n", raw_stdout);
1392 return MI_CMD_QUIET;
1398 mi_exec_async_cli_cmd_continuation (struct continuation_arg *arg)
1400 if (last_async_command)
1401 fputs_unfiltered (last_async_command, raw_stdout);
1402 fputs_unfiltered ("*stopped", raw_stdout);
1403 mi_out_put (uiout, raw_stdout);
1404 fputs_unfiltered ("\n", raw_stdout);
1405 fputs_unfiltered ("(gdb) \n", raw_stdout);
1406 gdb_flush (raw_stdout);
1407 do_exec_cleanups (ALL_CLEANUPS);
1411 mi_load_progress (const char *section_name,
1412 unsigned long sent_so_far,
1413 unsigned long total_section,
1414 unsigned long total_sent,
1415 unsigned long grand_total)
1417 struct timeval time_now, delta, update_threshold;
1418 static struct timeval last_update;
1419 static char *previous_sect_name = NULL;
1422 if (!current_interp_named_p (INTERP_MI)
1423 && !current_interp_named_p (INTERP_MI1))
1426 update_threshold.tv_sec = 0;
1427 update_threshold.tv_usec = 500000;
1428 gettimeofday (&time_now, NULL);
1430 delta.tv_usec = time_now.tv_usec - last_update.tv_usec;
1431 delta.tv_sec = time_now.tv_sec - last_update.tv_sec;
1433 if (delta.tv_usec < 0)
1436 delta.tv_usec += 1000000;
1439 new_section = (previous_sect_name ?
1440 strcmp (previous_sect_name, section_name) : 1);
1443 struct cleanup *cleanup_tuple;
1444 xfree (previous_sect_name);
1445 previous_sect_name = xstrdup (section_name);
1447 if (last_async_command)
1448 fputs_unfiltered (last_async_command, raw_stdout);
1449 fputs_unfiltered ("+download", raw_stdout);
1450 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1451 ui_out_field_string (uiout, "section", section_name);
1452 ui_out_field_int (uiout, "section-size", total_section);
1453 ui_out_field_int (uiout, "total-size", grand_total);
1454 do_cleanups (cleanup_tuple);
1455 mi_out_put (uiout, raw_stdout);
1456 fputs_unfiltered ("\n", raw_stdout);
1457 gdb_flush (raw_stdout);
1460 if (delta.tv_sec >= update_threshold.tv_sec &&
1461 delta.tv_usec >= update_threshold.tv_usec)
1463 struct cleanup *cleanup_tuple;
1464 last_update.tv_sec = time_now.tv_sec;
1465 last_update.tv_usec = time_now.tv_usec;
1466 if (last_async_command)
1467 fputs_unfiltered (last_async_command, raw_stdout);
1468 fputs_unfiltered ("+download", raw_stdout);
1469 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1470 ui_out_field_string (uiout, "section", section_name);
1471 ui_out_field_int (uiout, "section-sent", sent_so_far);
1472 ui_out_field_int (uiout, "section-size", total_section);
1473 ui_out_field_int (uiout, "total-sent", total_sent);
1474 ui_out_field_int (uiout, "total-size", grand_total);
1475 do_cleanups (cleanup_tuple);
1476 mi_out_put (uiout, raw_stdout);
1477 fputs_unfiltered ("\n", raw_stdout);
1478 gdb_flush (raw_stdout);
1483 mi_setup_architecture_data (void)
1485 old_regs = xmalloc ((NUM_REGS + NUM_PSEUDO_REGS) * MAX_REGISTER_SIZE + 1);
1486 memset (old_regs, 0, (NUM_REGS + NUM_PSEUDO_REGS) * MAX_REGISTER_SIZE + 1);
1490 _initialize_mi_main (void)
1492 DEPRECATED_REGISTER_GDBARCH_SWAP (old_regs);
1493 deprecated_register_gdbarch_swap (NULL, 0, mi_setup_architecture_data);