2 Copyright 2000, 2001 Free Software Foundation, Inc.
3 Contributed by Cygnus Solutions (a Red Hat company).
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
22 /* Work in progress */
27 #include "gdb_string.h"
29 #include "gdbthread.h"
32 #include "mi-getopt.h"
33 #include "mi-console.h"
36 #include "event-loop.h"
37 #include "event-top.h"
38 #include "gdbcore.h" /* for write_memory() */
39 #include "value.h" /* for write_register_bytes() */
44 /* Convenience macro for allocting typesafe memory. */
47 #define XMALLOC(TYPE) (TYPE*) xmalloc (sizeof (TYPE))
56 struct ui_file *raw_stdout;
58 /* The token of the last asynchronous command */
59 static char *last_async_command;
60 static char *previous_async_command;
61 static char *mi_error_message;
62 static char *old_regs;
64 extern void _initialize_mi_main (void);
65 static char *mi_input (char *);
66 static void mi_execute_command (char *cmd, int from_tty);
67 static enum mi_cmd_result mi_cmd_execute (struct mi_parse *parse);
69 static void mi_execute_cli_command (const char *cli, char *args);
70 static enum mi_cmd_result mi_execute_async_cli_command (char *mi, char *args, int from_tty);
71 static void mi_execute_command_wrapper (char *cmd);
73 void mi_exec_async_cli_cmd_continuation (struct continuation_arg *arg);
75 static int register_changed_p (int regnum);
76 static int get_register (int regnum, int format);
77 static void mi_load_progress (const char *section_name,
78 unsigned long sent_so_far,
79 unsigned long total_section,
80 unsigned long total_sent,
81 unsigned long grand_total);
84 /* FIXME: these should go in some .h file, but infcmd.c doesn't have a
85 corresponding .h file. These wrappers will be obsolete anyway, once
86 we pull the plug on the sanitization. */
87 extern void interrupt_target_command_wrapper (char *, int);
88 extern void return_command_wrapper (char *, int);
91 /* Command implementations. FIXME: Is this libgdb? No. This is the MI
92 layer that calls libgdb. Any operation used in the below should be
96 mi_cmd_gdb_exit (char *command, char **argv, int argc)
98 /* We have to print everything right here because we never return */
99 if (last_async_command)
100 fputs_unfiltered (last_async_command, raw_stdout);
101 fputs_unfiltered ("^exit\n", raw_stdout);
102 mi_out_put (uiout, raw_stdout);
103 /* FIXME: The function called is not yet a formal libgdb function */
104 quit_force (NULL, FROM_TTY);
109 mi_cmd_exec_run (char *args, int from_tty)
111 /* FIXME: Should call a libgdb function, not a cli wrapper */
112 return mi_execute_async_cli_command ("run", args, from_tty);
116 mi_cmd_exec_next (char *args, int from_tty)
118 /* FIXME: Should call a libgdb function, not a cli wrapper */
119 return mi_execute_async_cli_command ("next", args, from_tty);
123 mi_cmd_exec_next_instruction (char *args, int from_tty)
125 /* FIXME: Should call a libgdb function, not a cli wrapper */
126 return mi_execute_async_cli_command ("nexti", args, from_tty);
130 mi_cmd_exec_step (char *args, int from_tty)
132 /* FIXME: Should call a libgdb function, not a cli wrapper */
133 return mi_execute_async_cli_command ("step", args, from_tty);
137 mi_cmd_exec_step_instruction (char *args, int from_tty)
139 /* FIXME: Should call a libgdb function, not a cli wrapper */
140 return mi_execute_async_cli_command ("stepi", args, from_tty);
144 mi_cmd_exec_finish (char *args, int from_tty)
146 /* FIXME: Should call a libgdb function, not a cli wrapper */
147 return mi_execute_async_cli_command ("finish", args, from_tty);
151 mi_cmd_exec_until (char *args, int from_tty)
153 /* FIXME: Should call a libgdb function, not a cli wrapper */
154 return mi_execute_async_cli_command ("until", args, from_tty);
158 mi_cmd_exec_return (char *args, int from_tty)
161 /* This command doesn't really execute the target, it just pops the
162 specified number of frames. */
164 /* Call return_command with from_tty argument equal to 0 so as to
165 avoid being queried. */
166 return_command_wrapper (args, 0);
168 /* Call return_command with from_tty argument equal to 0 so as to
169 avoid being queried. */
170 return_command_wrapper (NULL, 0);
172 /* Because we have called return_command with from_tty = 0, we need
173 to print the frame here. */
174 show_and_print_stack_frame (selected_frame,
175 selected_frame_level,
183 mi_cmd_exec_continue (char *args, int from_tty)
185 /* FIXME: Should call a libgdb function, not a cli wrapper */
186 return mi_execute_async_cli_command ("continue", args, from_tty);
189 /* Interrupt the execution of the target. Note how we must play around
190 with the token varialbes, in order to display the current token in
191 the result of the interrupt command, and the previous execution
192 token when the target finally stops. See comments in
195 mi_cmd_exec_interrupt (char *args, int from_tty)
198 if (!target_executing)
200 xasprintf (&mi_error_message,
201 "mi_cmd_exec_interrupt: Inferior not executing.");
204 interrupt_target_command_wrapper (args, from_tty);
205 if (last_async_command)
206 fputs_unfiltered (last_async_command, raw_stdout);
207 fputs_unfiltered ("^done", raw_stdout);
208 xfree (last_async_command);
209 if (previous_async_command)
210 last_async_command = xstrdup (previous_async_command);
211 xfree (previous_async_command);
212 previous_async_command = NULL;
213 mi_out_put (uiout, raw_stdout);
214 mi_out_rewind (uiout);
215 fputs_unfiltered ("\n", raw_stdout);
221 mi_cmd_thread_select (char *command, char **argv, int argc)
227 xasprintf (&mi_error_message,
228 "mi_cmd_thread_select: USAGE: threadnum.");
232 rc = gdb_thread_select (argv[0]);
234 if (rc == GDB_RC_FAIL)
235 return MI_CMD_CAUGHT_ERROR;
241 mi_cmd_thread_list_ids (char *command, char **argv, int argc)
243 enum gdb_rc rc = MI_CMD_DONE;
247 xasprintf (&mi_error_message,
248 "mi_cmd_thread_list_ids: No arguments required.");
253 rc = gdb_list_thread_ids ();
256 if (rc == GDB_RC_FAIL)
257 return MI_CMD_CAUGHT_ERROR;
263 mi_cmd_data_list_register_names (char *command, char **argv, int argc)
268 /* Note that the test for a valid register must include checking the
269 REGISTER_NAME because NUM_REGS may be allocated for the union of
270 the register sets within a family of related processors. In this
271 case, some entries of REGISTER_NAME will change depending upon
272 the particular processor being debugged. */
274 numregs = NUM_REGS + NUM_PSEUDO_REGS;
276 ui_out_list_begin (uiout, "register-names");
278 if (argc == 0) /* No args, just do all the regs */
284 if (REGISTER_NAME (regnum) == NULL
285 || *(REGISTER_NAME (regnum)) == '\0')
286 ui_out_field_string (uiout, NULL, "");
288 ui_out_field_string (uiout, NULL, REGISTER_NAME (regnum));
292 /* Else, list of register #s, just do listed regs */
293 for (i = 0; i < argc; i++)
295 regnum = atoi (argv[i]);
296 if (regnum < 0 || regnum >= numregs)
298 xasprintf (&mi_error_message, "bad register number");
301 if (REGISTER_NAME (regnum) == NULL
302 || *(REGISTER_NAME (regnum)) == '\0')
303 ui_out_field_string (uiout, NULL, "");
305 ui_out_field_string (uiout, NULL, REGISTER_NAME (regnum));
307 ui_out_list_end (uiout);
312 mi_cmd_data_list_changed_registers (char *command, char **argv, int argc)
314 int regnum, numregs, changed;
317 /* Note that the test for a valid register must include checking the
318 REGISTER_NAME because NUM_REGS may be allocated for the union of
319 the register sets within a family of related processors. In this
320 case, some entries of REGISTER_NAME will change depending upon
321 the particular processor being debugged. */
325 ui_out_list_begin (uiout, "changed-registers");
327 if (argc == 0) /* No args, just do all the regs */
333 if (REGISTER_NAME (regnum) == NULL
334 || *(REGISTER_NAME (regnum)) == '\0')
336 changed = register_changed_p (regnum);
339 xasprintf (&mi_error_message,
340 "mi_cmd_data_list_changed_registers: Unable to read register contents.");
344 ui_out_field_int (uiout, NULL, regnum);
348 /* Else, list of register #s, just do listed regs */
349 for (i = 0; i < argc; i++)
351 regnum = atoi (argv[i]);
355 && REGISTER_NAME (regnum) != NULL
356 && *REGISTER_NAME (regnum) != '\000')
358 changed = register_changed_p (regnum);
361 xasprintf (&mi_error_message,
362 "mi_cmd_data_list_register_change: Unable to read register contents.");
366 ui_out_field_int (uiout, NULL, regnum);
370 xasprintf (&mi_error_message, "bad register number");
374 ui_out_list_end (uiout);
379 register_changed_p (int regnum)
381 char *raw_buffer = alloca (MAX_REGISTER_RAW_SIZE);
383 if (read_relative_register_raw_bytes (regnum, raw_buffer))
386 if (memcmp (&old_regs[REGISTER_BYTE (regnum)], raw_buffer,
387 REGISTER_RAW_SIZE (regnum)) == 0)
390 /* Found a changed register. Return 1. */
392 memcpy (&old_regs[REGISTER_BYTE (regnum)], raw_buffer,
393 REGISTER_RAW_SIZE (regnum));
398 /* Return a list of register number and value pairs. The valid
399 arguments expected are: a letter indicating the format in which to
400 display the registers contents. This can be one of: x (hexadecimal), d
401 (decimal), N (natural), t (binary), o (octal), r (raw). After the
402 format argumetn there can be a sequence of numbers, indicating which
403 registers to fetch the content of. If the format is the only argument,
404 a list of all the registers with their values is returned. */
406 mi_cmd_data_list_register_values (char *command, char **argv, int argc)
408 int regnum, numregs, format, result;
411 /* Note that the test for a valid register must include checking the
412 REGISTER_NAME because NUM_REGS may be allocated for the union of
413 the register sets within a family of related processors. In this
414 case, some entries of REGISTER_NAME will change depending upon
415 the particular processor being debugged. */
421 xasprintf (&mi_error_message,
422 "mi_cmd_data_list_register_values: Usage: -data-list-register-values <format> [<regnum1>...<regnumN>]");
426 format = (int) argv[0][0];
428 if (!target_has_registers)
430 xasprintf (&mi_error_message,
431 "mi_cmd_data_list_register_values: No registers.");
435 ui_out_list_begin (uiout, "register-values");
437 if (argc == 1) /* No args, beside the format: do all the regs */
443 if (REGISTER_NAME (regnum) == NULL
444 || *(REGISTER_NAME (regnum)) == '\0')
446 ui_out_tuple_begin (uiout, NULL);
447 ui_out_field_int (uiout, "number", regnum);
448 result = get_register (regnum, format);
451 ui_out_tuple_end (uiout);
455 /* Else, list of register #s, just do listed regs */
456 for (i = 1; i < argc; i++)
458 regnum = atoi (argv[i]);
462 && REGISTER_NAME (regnum) != NULL
463 && *REGISTER_NAME (regnum) != '\000')
465 ui_out_tuple_begin (uiout, NULL);
466 ui_out_field_int (uiout, "number", regnum);
467 result = get_register (regnum, format);
470 ui_out_tuple_end (uiout);
474 xasprintf (&mi_error_message, "bad register number");
478 ui_out_list_end (uiout);
482 /* Output one register's contents in the desired format. */
484 get_register (int regnum, int format)
486 char *raw_buffer = alloca (MAX_REGISTER_RAW_SIZE);
487 char *virtual_buffer = alloca (MAX_REGISTER_VIRTUAL_SIZE);
489 static struct ui_stream *stb = NULL;
491 stb = ui_out_stream_new (uiout);
496 /* read_relative_register_raw_bytes returns a virtual frame pointer
497 (FRAME_FP (selected_frame)) if regnum == FP_REGNUM instead
498 of the real contents of the register. To get around this,
499 use get_saved_register instead. */
500 get_saved_register (raw_buffer, &optim, (CORE_ADDR *) NULL, selected_frame,
501 regnum, (enum lval_type *) NULL);
504 xasprintf (&mi_error_message, "Optimized out");
508 /* Convert raw data to virtual format if necessary. */
510 if (REGISTER_CONVERTIBLE (regnum))
512 REGISTER_CONVERT_TO_VIRTUAL (regnum, REGISTER_VIRTUAL_TYPE (regnum),
513 raw_buffer, virtual_buffer);
516 memcpy (virtual_buffer, raw_buffer, REGISTER_VIRTUAL_SIZE (regnum));
521 char *ptr, buf[1024];
525 for (j = 0; j < REGISTER_RAW_SIZE (regnum); j++)
527 register int idx = TARGET_BYTE_ORDER == BIG_ENDIAN ? j
528 : REGISTER_RAW_SIZE (regnum) - 1 - j;
529 sprintf (ptr, "%02x", (unsigned char) raw_buffer[idx]);
532 ui_out_field_string (uiout, "value", buf);
533 /*fputs_filtered (buf, gdb_stdout); */
537 val_print (REGISTER_VIRTUAL_TYPE (regnum), virtual_buffer, 0, 0,
538 stb->stream, format, 1, 0, Val_pretty_default);
539 ui_out_field_stream (uiout, "value", stb);
540 ui_out_stream_delete (stb);
545 /* Write given values into registers. The registers and values are
546 given as pairs. The corresponding MI command is
547 -data-write-register-values <format> [<regnum1> <value1>...<regnumN> <valueN>]*/
549 mi_cmd_data_write_register_values (char *command, char **argv, int argc)
557 /* Note that the test for a valid register must include checking the
558 REGISTER_NAME because NUM_REGS may be allocated for the union of
559 the register sets within a family of related processors. In this
560 case, some entries of REGISTER_NAME will change depending upon
561 the particular processor being debugged. */
567 xasprintf (&mi_error_message,
568 "mi_cmd_data_write_register_values: Usage: -data-write-register-values <format> [<regnum1> <value1>...<regnumN> <valueN>]");
572 format = (int) argv[0][0];
574 if (!target_has_registers)
576 xasprintf (&mi_error_message,
577 "mi_cmd_data_write_register_values: No registers.");
583 xasprintf (&mi_error_message,
584 "mi_cmd_data_write_register_values: No regs and values specified.");
590 xasprintf (&mi_error_message,
591 "mi_cmd_data_write_register_values: Regs and vals are not in pairs.");
595 for (i = 1; i < argc; i = i + 2)
597 regnum = atoi (argv[i]);
601 && REGISTER_NAME (regnum) != NULL
602 && *REGISTER_NAME (regnum) != '\000')
605 struct cleanup *old_chain;
607 /* Get the value as a number */
608 value = parse_and_eval_address (argv[i + 1]);
609 /* Get the value into an array */
610 buffer = xmalloc (REGISTER_SIZE);
611 old_chain = make_cleanup (xfree, buffer);
612 store_signed_integer (buffer, REGISTER_SIZE, value);
614 write_register_bytes (REGISTER_BYTE (regnum), buffer, REGISTER_RAW_SIZE (regnum));
615 /* Free the buffer. */
616 do_cleanups (old_chain);
620 xasprintf (&mi_error_message, "bad register number");
628 /*This is commented out because we decided it was not useful. I leave
629 it, just in case. ezannoni:1999-12-08 */
631 /* Assign a value to a variable. The expression argument must be in
632 the form A=2 or "A = 2" (I.e. if there are spaces it needs to be
635 mi_cmd_data_assign (char *command, char **argv, int argc)
637 struct expression *expr;
638 struct cleanup *old_chain;
642 xasprintf (&mi_error_message,
643 "mi_cmd_data_assign: Usage: -data-assign expression");
647 /* NOTE what follows is a clone of set_command(). FIXME: ezannoni
648 01-12-1999: Need to decide what to do with this for libgdb purposes. */
650 expr = parse_expression (argv[0]);
651 old_chain = make_cleanup (free_current_contents, &expr);
652 evaluate_expression (expr);
653 do_cleanups (old_chain);
658 /* Evaluate the value of the argument. The argument is an
659 expression. If the expression contains spaces it needs to be
660 included in double quotes. */
662 mi_cmd_data_evaluate_expression (char *command, char **argv, int argc)
664 struct expression *expr;
665 struct cleanup *old_chain = NULL;
667 struct ui_stream *stb = NULL;
669 stb = ui_out_stream_new (uiout);
673 xasprintf (&mi_error_message,
674 "mi_cmd_data_evaluate_expression: Usage: -data-evaluate-expression expression");
678 expr = parse_expression (argv[0]);
680 old_chain = make_cleanup (free_current_contents, &expr);
682 val = evaluate_expression (expr);
684 /* Print the result of the expression evaluation. */
685 val_print (VALUE_TYPE (val), VALUE_CONTENTS (val),
686 VALUE_EMBEDDED_OFFSET (val), VALUE_ADDRESS (val),
687 stb->stream, 0, 0, 0, 0);
689 ui_out_field_stream (uiout, "value", stb);
690 ui_out_stream_delete (stb);
692 do_cleanups (old_chain);
698 mi_cmd_target_download (char *args, int from_tty)
701 struct cleanup *old_cleanups = NULL;
703 xasprintf (&run, "load %s", args);
704 old_cleanups = make_cleanup (xfree, run);
705 execute_command (run, from_tty);
707 do_cleanups (old_cleanups);
711 /* Connect to the remote target. */
713 mi_cmd_target_select (char *args, int from_tty)
716 struct cleanup *old_cleanups = NULL;
718 xasprintf (&run, "target %s", args);
719 old_cleanups = make_cleanup (xfree, run);
721 /* target-select is always synchronous. once the call has returned
722 we know that we are connected. */
723 /* NOTE: At present all targets that are connected are also
724 (implicitly) talking to a halted target. In the future this may
726 execute_command (run, from_tty);
728 do_cleanups (old_cleanups);
730 /* Issue the completion message here. */
731 if (last_async_command)
732 fputs_unfiltered (last_async_command, raw_stdout);
733 fputs_unfiltered ("^connected", raw_stdout);
734 mi_out_put (uiout, raw_stdout);
735 mi_out_rewind (uiout);
736 fputs_unfiltered ("\n", raw_stdout);
737 do_exec_cleanups (ALL_CLEANUPS);
743 ADDR: start address of data to be dumped.
744 WORD-FORMAT: a char indicating format for the ``word''. See
746 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes
747 NR_ROW: Number of rows.
748 NR_COL: The number of colums (words per row).
749 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
750 ASCHAR for unprintable characters.
752 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
753 displayes them. Returns:
755 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
758 The number of bytes read is SIZE*ROW*COL. */
761 mi_cmd_data_read_memory (char *command, char **argv, int argc)
763 struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
769 struct type *word_type;
782 static struct mi_opt opts[] =
784 {"o", OFFSET_OPT, 1},
790 int opt = mi_getopt ("mi_cmd_data_read_memory", argc, argv, opts,
794 switch ((enum opt) opt)
797 offset = atol (optarg);
804 if (argc < 5 || argc > 6)
806 xasprintf (&mi_error_message,
807 "mi_cmd_data_read_memory: Usage: ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR].");
811 /* Extract all the arguments. */
813 /* Start address of the memory dump. */
814 addr = parse_and_eval_address (argv[0]) + offset;
815 /* The format character to use when displaying a memory word. See
816 the ``x'' command. */
817 word_format = argv[1][0];
818 /* The size of the memory word. */
819 word_size = atol (argv[2]);
823 word_type = builtin_type_int8;
827 word_type = builtin_type_int16;
831 word_type = builtin_type_int32;
835 word_type = builtin_type_int64;
839 word_type = builtin_type_int8;
842 /* The number of rows */
843 nr_rows = atol (argv[3]);
846 xasprintf (&mi_error_message,
847 "mi_cmd_data_read_memory: invalid number of rows.");
850 /* number of bytes per row. */
851 nr_cols = atol (argv[4]);
854 xasprintf (&mi_error_message,
855 "mi_cmd_data_read_memory: invalid number of columns.");
857 /* The un-printable character when printing ascii. */
863 /* create a buffer and read it in. */
864 total_bytes = word_size * nr_rows * nr_cols;
865 mbuf = xcalloc (total_bytes, 1);
866 make_cleanup (xfree, mbuf);
869 xasprintf (&mi_error_message,
870 "mi_cmd_data_read_memory: out of memory.");
874 while (nr_bytes < total_bytes)
877 long num = target_read_memory_partial (addr + nr_bytes, mbuf + nr_bytes,
878 total_bytes - nr_bytes,
885 /* output the header information. */
886 ui_out_field_core_addr (uiout, "addr", addr);
887 ui_out_field_int (uiout, "nr-bytes", nr_bytes);
888 ui_out_field_int (uiout, "total-bytes", total_bytes);
889 ui_out_field_core_addr (uiout, "next-row", addr + word_size * nr_cols);
890 ui_out_field_core_addr (uiout, "prev-row", addr - word_size * nr_cols);
891 ui_out_field_core_addr (uiout, "next-page", addr + total_bytes);
892 ui_out_field_core_addr (uiout, "prev-page", addr - total_bytes);
894 /* Build the result as a two dimentional table. */
896 struct ui_stream *stream = ui_out_stream_new (uiout);
899 ui_out_list_begin (uiout, "memory");
900 for (row = 0, row_byte = 0;
902 row++, row_byte += nr_cols * word_size)
906 ui_out_tuple_begin (uiout, NULL);
907 ui_out_field_core_addr (uiout, "addr", addr + row_byte);
908 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr + row_byte); */
909 ui_out_list_begin (uiout, "data");
910 for (col = 0, col_byte = row_byte;
912 col++, col_byte += word_size)
914 if (col_byte + word_size > nr_bytes)
916 ui_out_field_string (uiout, NULL, "N/A");
920 ui_file_rewind (stream->stream);
921 print_scalar_formatted (mbuf + col_byte, word_type, word_format,
922 word_asize, stream->stream);
923 ui_out_field_stream (uiout, NULL, stream);
926 ui_out_list_end (uiout);
930 ui_file_rewind (stream->stream);
931 for (byte = row_byte; byte < row_byte + word_size * nr_cols; byte++)
933 if (byte >= nr_bytes)
935 fputc_unfiltered ('X', stream->stream);
937 else if (mbuf[byte] < 32 || mbuf[byte] > 126)
939 fputc_unfiltered (aschar, stream->stream);
942 fputc_unfiltered (mbuf[byte], stream->stream);
944 ui_out_field_stream (uiout, "ascii", stream);
946 ui_out_tuple_end (uiout);
948 ui_out_stream_delete (stream);
949 ui_out_list_end (uiout);
951 do_cleanups (cleanups);
955 /* DATA-MEMORY-WRITE:
957 COLUMN_OFFSET: optional argument. Must be preceeded by '-o'. The
958 offset from the beginning of the memory grid row where the cell to
960 ADDR: start address of the row in the memory grid where the memory
961 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
962 the location to write to.
963 FORMAT: a char indicating format for the ``word''. See
965 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
966 VALUE: value to be written into the memory address.
968 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
972 mi_cmd_data_write_memory (char *command, char **argv, int argc)
977 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
978 enough when using a compiler other than GCC. */
981 struct cleanup *old_chain;
989 static struct mi_opt opts[] =
991 {"o", OFFSET_OPT, 1},
997 int opt = mi_getopt ("mi_cmd_data_write_memory", argc, argv, opts,
1001 switch ((enum opt) opt)
1004 offset = atol (optarg);
1013 xasprintf (&mi_error_message,
1014 "mi_cmd_data_write_memory: Usage: [-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE.");
1015 return MI_CMD_ERROR;
1018 /* Extract all the arguments. */
1019 /* Start address of the memory dump. */
1020 addr = parse_and_eval_address (argv[0]);
1021 /* The format character to use when displaying a memory word. See
1022 the ``x'' command. */
1023 word_format = argv[1][0];
1024 /* The size of the memory word. */
1025 word_size = atol (argv[2]);
1027 /* Calculate the real address of the write destination. */
1028 addr += (offset * word_size);
1030 /* Get the value as a number */
1031 value = parse_and_eval_address (argv[3]);
1032 /* Get the value into an array */
1033 buffer = xmalloc (word_size);
1034 old_chain = make_cleanup (xfree, buffer);
1035 store_signed_integer (buffer, word_size, value);
1036 /* Write it down to memory */
1037 write_memory (addr, buffer, word_size);
1038 /* Free the buffer. */
1039 do_cleanups (old_chain);
1044 /* Execute a command within a safe environment. Return >0 for
1045 ok. Return <0 for supress prompt. Return 0 to have the error
1046 extracted from error_last_message(). */
1049 captured_mi_execute_command (void *data)
1051 struct mi_parse *context = data;
1052 enum mi_cmd_result rc;
1054 switch (context->op)
1058 /* A MI command was read from the input stream */
1060 /* FIXME: gdb_???? */
1061 fprintf_unfiltered (raw_stdout, " token=`%s' command=`%s' args=`%s'\n",
1062 context->token, context->command, context->args);
1063 /* FIXME: cagney/1999-09-25: Rather than this convoluted
1064 condition expression, each function should return an
1065 indication of what action is required and then switch on
1067 rc = mi_cmd_execute (context);
1068 if (!target_can_async_p () || !target_executing)
1070 /* print the result if there were no errors */
1071 if (rc == MI_CMD_DONE)
1073 fputs_unfiltered (context->token, raw_stdout);
1074 fputs_unfiltered ("^done", raw_stdout);
1075 mi_out_put (uiout, raw_stdout);
1076 mi_out_rewind (uiout);
1077 fputs_unfiltered ("\n", raw_stdout);
1079 else if (rc == MI_CMD_ERROR)
1081 if (mi_error_message)
1083 fputs_unfiltered (context->token, raw_stdout);
1084 fputs_unfiltered ("^error,msg=\"", raw_stdout);
1085 fputstr_unfiltered (mi_error_message, '"', raw_stdout);
1086 xfree (mi_error_message);
1087 fputs_unfiltered ("\"\n", raw_stdout);
1089 mi_out_rewind (uiout);
1091 else if (rc == MI_CMD_CAUGHT_ERROR)
1093 mi_out_rewind (uiout);
1097 mi_out_rewind (uiout);
1099 else if (sync_execution)
1100 /* Don't print the prompt. We are executing the target in
1101 synchronous mode. */
1106 /* A CLI command was read from the input stream */
1107 /* This will be removed as soon as we have a complete set of
1109 /* echo the command on the console. */
1110 fprintf_unfiltered (gdb_stdlog, "%s\n", context->command);
1111 /* FIXME: If the command string has something that looks like
1112 a format spec (e.g. %s) we will get a core dump */
1113 mi_execute_cli_command ("%s", context->command);
1114 /* print the result */
1115 /* FIXME: Check for errors here. */
1116 fputs_unfiltered (context->token, raw_stdout);
1117 fputs_unfiltered ("^done", raw_stdout);
1118 mi_out_put (uiout, raw_stdout);
1119 mi_out_rewind (uiout);
1120 fputs_unfiltered ("\n", raw_stdout);
1129 mi_execute_command (char *cmd, int from_tty)
1131 struct mi_parse *command;
1133 /* This is to handle EOF (^D). We just quit gdb. */
1134 /* FIXME: we should call some API function here. */
1136 quit_force (NULL, from_tty);
1138 command = mi_parse (cmd);
1140 if (command != NULL)
1142 /* FIXME: cagney/1999-11-04: Can this use of catch_errors either
1143 be pushed even further down or even eliminated? */
1144 int rc = catch_errors (captured_mi_execute_command, command, "",
1148 /* The command is executing synchronously. Bail out early
1149 suppressing the finished prompt. */
1150 mi_parse_free (command);
1155 char *msg = error_last_message ();
1156 struct cleanup *cleanup = make_cleanup (xfree, msg);
1157 /* The command execution failed and error() was called
1159 fputs_unfiltered (command->token, raw_stdout);
1160 fputs_unfiltered ("^error,msg=\"", raw_stdout);
1161 fputstr_unfiltered (msg, '"', raw_stdout);
1162 fputs_unfiltered ("\"\n", raw_stdout);
1164 mi_parse_free (command);
1167 gdb_flush (raw_stdout);
1168 fputs_unfiltered ("(gdb) \n", raw_stdout);
1169 /* print any buffered hook code */
1173 static enum mi_cmd_result
1174 mi_cmd_execute (struct mi_parse *parse)
1176 if (parse->cmd->argv_func != NULL
1177 || parse->cmd->args_func != NULL)
1179 /* FIXME: We need to save the token because the command executed
1180 may be asynchronous and need to print the token again.
1181 In the future we can pass the token down to the func
1182 and get rid of the last_async_command */
1183 /* The problem here is to keep the token around when we launch
1184 the target, and we want to interrupt it later on. The
1185 interrupt command will have its own token, but when the
1186 target stops, we must display the token corresponding to the
1187 last execution command given. So we have another string where
1188 we copy the token (previous_async_command), if this was
1189 indeed the token of an execution command, and when we stop we
1190 print that one. This is possible because the interrupt
1191 command, when over, will copy that token back into the
1192 default token string (last_async_command). */
1194 if (target_executing)
1196 if (!previous_async_command)
1197 previous_async_command = xstrdup (last_async_command);
1198 if (strcmp (parse->command, "exec-interrupt"))
1200 fputs_unfiltered (parse->token, raw_stdout);
1201 fputs_unfiltered ("^error,msg=\"", raw_stdout);
1202 fputs_unfiltered ("Cannot execute command ", raw_stdout);
1203 fputstr_unfiltered (parse->command, '"', raw_stdout);
1204 fputs_unfiltered (" while target running", raw_stdout);
1205 fputs_unfiltered ("\"\n", raw_stdout);
1206 return MI_CMD_ERROR;
1209 last_async_command = xstrdup (parse->token);
1210 make_exec_cleanup (free_current_contents, &last_async_command);
1211 /* FIXME: DELETE THIS! */
1212 if (parse->cmd->args_func != NULL)
1213 return parse->cmd->args_func (parse->args, 0 /*from_tty */ );
1214 return parse->cmd->argv_func (parse->command, parse->argv, parse->argc);
1216 else if (parse->cmd->cli != 0)
1218 /* FIXME: DELETE THIS. */
1219 /* The operation is still implemented by a cli command */
1220 /* Must be a synchronous one */
1221 mi_execute_cli_command (parse->cmd->cli, parse->args);
1226 /* FIXME: DELETE THIS. */
1227 fputs_unfiltered (parse->token, raw_stdout);
1228 fputs_unfiltered ("^error,msg=\"", raw_stdout);
1229 fputs_unfiltered ("Undefined mi command: ", raw_stdout);
1230 fputstr_unfiltered (parse->command, '"', raw_stdout);
1231 fputs_unfiltered (" (missing implementation)", raw_stdout);
1232 fputs_unfiltered ("\"\n", raw_stdout);
1233 return MI_CMD_ERROR;
1238 mi_execute_command_wrapper (char *cmd)
1240 mi_execute_command (cmd, stdin == instream);
1243 /* FIXME: This is just a hack so we can get some extra commands going.
1244 We don't want to channel things through the CLI, but call libgdb directly */
1245 /* Use only for synchronous commands */
1248 mi_execute_cli_command (const char *cli, char *args)
1252 struct cleanup *old_cleanups;
1254 xasprintf (&run, cli, args);
1256 /* FIXME: gdb_???? */
1257 fprintf_unfiltered (gdb_stdout, "cli=%s run=%s\n",
1259 old_cleanups = make_cleanup (xfree, run);
1260 execute_command ( /*ui */ run, 0 /*from_tty */ );
1261 do_cleanups (old_cleanups);
1267 mi_execute_async_cli_command (char *mi, char *args, int from_tty)
1269 struct cleanup *old_cleanups;
1273 if (target_can_async_p ())
1275 async_args = (char *) xmalloc (strlen (args) + 2);
1276 make_exec_cleanup (free, async_args);
1277 strcpy (async_args, args);
1278 strcat (async_args, "&");
1279 xasprintf (&run, "%s %s", mi, async_args);
1280 make_exec_cleanup (free, run);
1281 add_continuation (mi_exec_async_cli_cmd_continuation, NULL);
1282 old_cleanups = NULL;
1286 xasprintf (&run, "%s %s", mi, args);
1287 old_cleanups = make_cleanup (xfree, run);
1290 if (!target_can_async_p ())
1292 /* NOTE: For synchronous targets asynchronous behavour is faked by
1293 printing out the GDB prompt before we even try to execute the
1295 if (last_async_command)
1296 fputs_unfiltered (last_async_command, raw_stdout);
1297 fputs_unfiltered ("^running\n", raw_stdout);
1298 fputs_unfiltered ("(gdb) \n", raw_stdout);
1302 /* FIXME: cagney/1999-11-29: Printing this message before
1303 calling execute_command is wrong. It should only be printed
1304 once gdb has confirmed that it really has managed to send a
1305 run command to the target. */
1306 if (last_async_command)
1307 fputs_unfiltered (last_async_command, raw_stdout);
1308 fputs_unfiltered ("^running\n", raw_stdout);
1311 execute_command ( /*ui */ run, 0 /*from_tty */ );
1313 if (!target_can_async_p ())
1315 /* Do this before doing any printing. It would appear that some
1316 print code leaves garbage around in the buffer. */
1317 do_cleanups (old_cleanups);
1318 /* If the target was doing the operation synchronously we fake
1319 the stopped message. */
1320 if (last_async_command)
1321 fputs_unfiltered (last_async_command, raw_stdout);
1322 fputs_unfiltered ("*stopped", raw_stdout);
1323 mi_out_put (uiout, raw_stdout);
1324 mi_out_rewind (uiout);
1325 fputs_unfiltered ("\n", raw_stdout);
1326 return MI_CMD_QUIET;
1332 mi_exec_async_cli_cmd_continuation (struct continuation_arg *arg)
1334 if (last_async_command)
1335 fputs_unfiltered (last_async_command, raw_stdout);
1336 fputs_unfiltered ("*stopped", raw_stdout);
1337 mi_out_put (uiout, raw_stdout);
1338 fputs_unfiltered ("\n", raw_stdout);
1339 fputs_unfiltered ("(gdb) \n", raw_stdout);
1340 do_exec_cleanups (ALL_CLEANUPS);
1344 mi_input (char *buf)
1346 return gdb_readline (NULL);
1350 mi_load_progress (const char *section_name,
1351 unsigned long sent_so_far,
1352 unsigned long total_section,
1353 unsigned long total_sent,
1354 unsigned long grand_total)
1356 struct timeval time_now, delta, update_threshold;
1357 static struct timeval last_update;
1358 static char *previous_sect_name = NULL;
1361 if (!interpreter_p || strncmp (interpreter_p, "mi", 2) != 0)
1364 update_threshold.tv_sec = 0;
1365 update_threshold.tv_usec = 500000;
1366 gettimeofday (&time_now, NULL);
1368 delta.tv_usec = time_now.tv_usec - last_update.tv_usec;
1369 delta.tv_sec = time_now.tv_sec - last_update.tv_sec;
1371 if (delta.tv_usec < 0)
1374 delta.tv_usec += 1000000;
1377 new_section = (previous_sect_name ?
1378 strcmp (previous_sect_name, section_name) : 1);
1381 xfree (previous_sect_name);
1382 previous_sect_name = xstrdup (section_name);
1384 if (last_async_command)
1385 fputs_unfiltered (last_async_command, raw_stdout);
1386 fputs_unfiltered ("+download", raw_stdout);
1387 ui_out_tuple_begin (uiout, NULL);
1388 ui_out_field_string (uiout, "section", section_name);
1389 ui_out_field_int (uiout, "section-size", total_section);
1390 ui_out_field_int (uiout, "total-size", grand_total);
1391 ui_out_tuple_end (uiout);
1392 mi_out_put (uiout, raw_stdout);
1393 fputs_unfiltered ("\n", raw_stdout);
1394 gdb_flush (raw_stdout);
1397 if (delta.tv_sec >= update_threshold.tv_sec &&
1398 delta.tv_usec >= update_threshold.tv_usec)
1400 last_update.tv_sec = time_now.tv_sec;
1401 last_update.tv_usec = time_now.tv_usec;
1402 if (last_async_command)
1403 fputs_unfiltered (last_async_command, raw_stdout);
1404 fputs_unfiltered ("+download", raw_stdout);
1405 ui_out_tuple_begin (uiout, NULL);
1406 ui_out_field_string (uiout, "section", section_name);
1407 ui_out_field_int (uiout, "section-sent", sent_so_far);
1408 ui_out_field_int (uiout, "section-size", total_section);
1409 ui_out_field_int (uiout, "total-sent", total_sent);
1410 ui_out_field_int (uiout, "total-size", grand_total);
1411 ui_out_tuple_end (uiout);
1412 mi_out_put (uiout, raw_stdout);
1413 fputs_unfiltered ("\n", raw_stdout);
1414 gdb_flush (raw_stdout);
1419 mi_command_loop (int mi_version)
1421 /* HACK: Force stdout/stderr to point at the console. This avoids
1422 any potential side effects caused by legacy code that is still
1423 using the TUI / fputs_unfiltered_hook */
1424 raw_stdout = stdio_fileopen (stdout);
1425 /* Route normal output through the MIx */
1426 gdb_stdout = mi_console_file_new (raw_stdout, "~");
1427 /* Route error and log output through the MI */
1428 gdb_stderr = mi_console_file_new (raw_stdout, "&");
1429 gdb_stdlog = gdb_stderr;
1430 /* Route target output through the MI. */
1431 gdb_stdtarg = mi_console_file_new (raw_stdout, "@");
1433 /* HACK: Poke the ui_out table directly. Should we be creating a
1434 mi_out object wired up to the above gdb_stdout / gdb_stderr? */
1435 uiout = mi_out_new (mi_version);
1437 /* HACK: Override any other interpreter hooks. We need to create a
1438 real event table and pass in that. */
1440 /* command_loop_hook = 0; */
1441 print_frame_info_listing_hook = 0;
1444 create_breakpoint_hook = 0;
1445 delete_breakpoint_hook = 0;
1446 modify_breakpoint_hook = 0;
1447 interactive_hook = 0;
1448 registers_changed_hook = 0;
1449 readline_begin_hook = 0;
1451 readline_end_hook = 0;
1452 register_changed_hook = 0;
1453 memory_changed_hook = 0;
1455 target_wait_hook = 0;
1456 call_command_hook = 0;
1458 error_begin_hook = 0;
1459 show_load_progress = mi_load_progress;
1461 /* Turn off 8 bit strings in quoted output. Any character with the
1462 high bit set is printed using C's octal format. */
1463 sevenbit_strings = 1;
1465 /* Tell the world that we're alive */
1466 fputs_unfiltered ("(gdb) \n", raw_stdout);
1469 simplified_command_loop (mi_input, mi_execute_command);
1471 start_event_loop ();
1475 mi0_command_loop (void)
1477 mi_command_loop (0);
1481 mi1_command_loop (void)
1483 mi_command_loop (1);
1487 setup_architecture_data (void)
1489 /* don't trust REGISTER_BYTES to be zero. */
1490 old_regs = xmalloc (REGISTER_BYTES + 1);
1491 memset (old_regs, 0, REGISTER_BYTES + 1);
1495 mi_init_ui (char *arg0)
1497 /* Eventually this will contain code that takes control of the
1502 _initialize_mi_main (void)
1504 if (interpreter_p == NULL)
1507 /* If we're _the_ interpreter, take control. */
1508 if (strcmp (interpreter_p, "mi0") == 0)
1509 command_loop_hook = mi0_command_loop;
1510 else if (strcmp (interpreter_p, "mi") == 0
1511 || strcmp (interpreter_p, "mi1") == 0)
1512 command_loop_hook = mi1_command_loop;
1516 init_ui_hook = mi_init_ui;
1517 setup_architecture_data ();
1518 register_gdbarch_swap (&old_regs, sizeof (old_regs), NULL);
1519 register_gdbarch_swap (NULL, 0, setup_architecture_data);
1522 /* These overwrite some of the initialization done in
1523 _intialize_event_loop. */
1524 call_readline = gdb_readline2;
1525 input_handler = mi_execute_command_wrapper;
1526 add_file_handler (input_fd, stdin_event_handler, 0);
1527 async_command_editing_p = 0;
1529 /* FIXME: Should we notify main that we are here as a possible