2 Copyright 2000, 2001, 2002 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() */
45 /* Convenience macro for allocting typesafe memory. */
48 #define XMALLOC(TYPE) (TYPE*) xmalloc (sizeof (TYPE))
57 struct ui_file
*raw_stdout
;
59 /* The token of the last asynchronous command */
60 static char *last_async_command
;
61 static char *previous_async_command
;
62 static char *mi_error_message
;
63 static char *old_regs
;
65 extern void _initialize_mi_main (void);
66 static char *mi_input (char *);
67 static void mi_execute_command (char *cmd
, int from_tty
);
68 static enum mi_cmd_result
mi_cmd_execute (struct mi_parse
*parse
);
70 static void mi_execute_cli_command (const char *cli
, char *args
);
71 static enum mi_cmd_result
mi_execute_async_cli_command (char *mi
, char *args
, int from_tty
);
72 static void mi_execute_command_wrapper (char *cmd
);
74 void mi_exec_async_cli_cmd_continuation (struct continuation_arg
*arg
);
76 static int register_changed_p (int regnum
);
77 static int get_register (int regnum
, int format
);
78 static void mi_load_progress (const char *section_name
,
79 unsigned long sent_so_far
,
80 unsigned long total_section
,
81 unsigned long total_sent
,
82 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);
90 /* Command implementations. FIXME: Is this libgdb? No. This is the MI
91 layer that calls libgdb. Any operation used in the below should be
95 mi_cmd_gdb_exit (char *command
, char **argv
, int argc
)
97 /* We have to print everything right here because we never return */
98 if (last_async_command
)
99 fputs_unfiltered (last_async_command
, raw_stdout
);
100 fputs_unfiltered ("^exit\n", raw_stdout
);
101 mi_out_put (uiout
, raw_stdout
);
102 /* FIXME: The function called is not yet a formal libgdb function */
103 quit_force (NULL
, FROM_TTY
);
108 mi_cmd_exec_run (char *args
, int from_tty
)
110 /* FIXME: Should call a libgdb function, not a cli wrapper */
111 return mi_execute_async_cli_command ("run", args
, from_tty
);
115 mi_cmd_exec_next (char *args
, int from_tty
)
117 /* FIXME: Should call a libgdb function, not a cli wrapper */
118 return mi_execute_async_cli_command ("next", args
, from_tty
);
122 mi_cmd_exec_next_instruction (char *args
, int from_tty
)
124 /* FIXME: Should call a libgdb function, not a cli wrapper */
125 return mi_execute_async_cli_command ("nexti", args
, from_tty
);
129 mi_cmd_exec_step (char *args
, int from_tty
)
131 /* FIXME: Should call a libgdb function, not a cli wrapper */
132 return mi_execute_async_cli_command ("step", args
, from_tty
);
136 mi_cmd_exec_step_instruction (char *args
, int from_tty
)
138 /* FIXME: Should call a libgdb function, not a cli wrapper */
139 return mi_execute_async_cli_command ("stepi", args
, from_tty
);
143 mi_cmd_exec_finish (char *args
, int from_tty
)
145 /* FIXME: Should call a libgdb function, not a cli wrapper */
146 return mi_execute_async_cli_command ("finish", args
, from_tty
);
150 mi_cmd_exec_until (char *args
, int from_tty
)
152 /* FIXME: Should call a libgdb function, not a cli wrapper */
153 return mi_execute_async_cli_command ("until", args
, from_tty
);
157 mi_cmd_exec_return (char *args
, int from_tty
)
159 /* This command doesn't really execute the target, it just pops the
160 specified number of frames. */
162 /* Call return_command with from_tty argument equal to 0 so as to
163 avoid being queried. */
164 return_command_wrapper (args
, 0);
166 /* Call return_command with from_tty argument equal to 0 so as to
167 avoid being queried. */
168 return_command_wrapper (NULL
, 0);
170 /* Because we have called return_command with from_tty = 0, we need
171 to print the frame here. */
172 show_and_print_stack_frame (selected_frame
,
173 selected_frame_level
,
180 mi_cmd_exec_continue (char *args
, int from_tty
)
182 /* FIXME: Should call a libgdb function, not a cli wrapper */
183 return mi_execute_async_cli_command ("continue", args
, from_tty
);
186 /* Interrupt the execution of the target. Note how we must play around
187 with the token varialbes, in order to display the current token in
188 the result of the interrupt command, and the previous execution
189 token when the target finally stops. See comments in
192 mi_cmd_exec_interrupt (char *args
, int from_tty
)
194 if (!target_executing
)
196 xasprintf (&mi_error_message
,
197 "mi_cmd_exec_interrupt: Inferior not executing.");
200 interrupt_target_command_wrapper (args
, from_tty
);
201 if (last_async_command
)
202 fputs_unfiltered (last_async_command
, raw_stdout
);
203 fputs_unfiltered ("^done", raw_stdout
);
204 xfree (last_async_command
);
205 if (previous_async_command
)
206 last_async_command
= xstrdup (previous_async_command
);
207 xfree (previous_async_command
);
208 previous_async_command
= NULL
;
209 mi_out_put (uiout
, raw_stdout
);
210 mi_out_rewind (uiout
);
211 fputs_unfiltered ("\n", raw_stdout
);
216 mi_cmd_thread_select (char *command
, char **argv
, int argc
)
222 xasprintf (&mi_error_message
,
223 "mi_cmd_thread_select: USAGE: threadnum.");
227 rc
= gdb_thread_select (uiout
, argv
[0]);
229 if (rc
== GDB_RC_FAIL
)
230 return MI_CMD_CAUGHT_ERROR
;
236 mi_cmd_thread_list_ids (char *command
, char **argv
, int argc
)
238 enum gdb_rc rc
= MI_CMD_DONE
;
242 xasprintf (&mi_error_message
,
243 "mi_cmd_thread_list_ids: No arguments required.");
247 rc
= gdb_list_thread_ids (uiout
);
249 if (rc
== GDB_RC_FAIL
)
250 return MI_CMD_CAUGHT_ERROR
;
256 mi_cmd_data_list_register_names (char *command
, char **argv
, int argc
)
261 /* Note that the test for a valid register must include checking the
262 REGISTER_NAME because NUM_REGS may be allocated for the union of
263 the register sets within a family of related processors. In this
264 case, some entries of REGISTER_NAME will change depending upon
265 the particular processor being debugged. */
267 numregs
= NUM_REGS
+ NUM_PSEUDO_REGS
;
269 ui_out_list_begin (uiout
, "register-names");
271 if (argc
== 0) /* No args, just do all the regs */
277 if (REGISTER_NAME (regnum
) == NULL
278 || *(REGISTER_NAME (regnum
)) == '\0')
279 ui_out_field_string (uiout
, NULL
, "");
281 ui_out_field_string (uiout
, NULL
, REGISTER_NAME (regnum
));
285 /* Else, list of register #s, just do listed regs */
286 for (i
= 0; i
< argc
; i
++)
288 regnum
= atoi (argv
[i
]);
289 if (regnum
< 0 || regnum
>= numregs
)
291 xasprintf (&mi_error_message
, "bad register number");
294 if (REGISTER_NAME (regnum
) == NULL
295 || *(REGISTER_NAME (regnum
)) == '\0')
296 ui_out_field_string (uiout
, NULL
, "");
298 ui_out_field_string (uiout
, NULL
, REGISTER_NAME (regnum
));
300 ui_out_list_end (uiout
);
305 mi_cmd_data_list_changed_registers (char *command
, char **argv
, int argc
)
307 int regnum
, numregs
, changed
;
310 /* Note that the test for a valid register must include checking the
311 REGISTER_NAME because NUM_REGS may be allocated for the union of
312 the register sets within a family of related processors. In this
313 case, some entries of REGISTER_NAME will change depending upon
314 the particular processor being debugged. */
318 ui_out_list_begin (uiout
, "changed-registers");
320 if (argc
== 0) /* No args, just do all the regs */
326 if (REGISTER_NAME (regnum
) == NULL
327 || *(REGISTER_NAME (regnum
)) == '\0')
329 changed
= register_changed_p (regnum
);
332 xasprintf (&mi_error_message
,
333 "mi_cmd_data_list_changed_registers: Unable to read register contents.");
337 ui_out_field_int (uiout
, NULL
, regnum
);
341 /* Else, list of register #s, just do listed regs */
342 for (i
= 0; i
< argc
; i
++)
344 regnum
= atoi (argv
[i
]);
348 && REGISTER_NAME (regnum
) != NULL
349 && *REGISTER_NAME (regnum
) != '\000')
351 changed
= register_changed_p (regnum
);
354 xasprintf (&mi_error_message
,
355 "mi_cmd_data_list_register_change: Unable to read register contents.");
359 ui_out_field_int (uiout
, NULL
, regnum
);
363 xasprintf (&mi_error_message
, "bad register number");
367 ui_out_list_end (uiout
);
372 register_changed_p (int regnum
)
374 char *raw_buffer
= alloca (MAX_REGISTER_RAW_SIZE
);
376 if (read_relative_register_raw_bytes (regnum
, raw_buffer
))
379 if (memcmp (&old_regs
[REGISTER_BYTE (regnum
)], raw_buffer
,
380 REGISTER_RAW_SIZE (regnum
)) == 0)
383 /* Found a changed register. Return 1. */
385 memcpy (&old_regs
[REGISTER_BYTE (regnum
)], raw_buffer
,
386 REGISTER_RAW_SIZE (regnum
));
391 /* Return a list of register number and value pairs. The valid
392 arguments expected are: a letter indicating the format in which to
393 display the registers contents. This can be one of: x (hexadecimal), d
394 (decimal), N (natural), t (binary), o (octal), r (raw). After the
395 format argumetn there can be a sequence of numbers, indicating which
396 registers to fetch the content of. If the format is the only argument,
397 a list of all the registers with their values is returned. */
399 mi_cmd_data_list_register_values (char *command
, char **argv
, int argc
)
401 int regnum
, numregs
, format
, result
;
404 /* Note that the test for a valid register must include checking the
405 REGISTER_NAME because NUM_REGS may be allocated for the union of
406 the register sets within a family of related processors. In this
407 case, some entries of REGISTER_NAME will change depending upon
408 the particular processor being debugged. */
414 xasprintf (&mi_error_message
,
415 "mi_cmd_data_list_register_values: Usage: -data-list-register-values <format> [<regnum1>...<regnumN>]");
419 format
= (int) argv
[0][0];
421 if (!target_has_registers
)
423 xasprintf (&mi_error_message
,
424 "mi_cmd_data_list_register_values: No registers.");
428 ui_out_list_begin (uiout
, "register-values");
430 if (argc
== 1) /* No args, beside the format: do all the regs */
436 if (REGISTER_NAME (regnum
) == NULL
437 || *(REGISTER_NAME (regnum
)) == '\0')
439 ui_out_tuple_begin (uiout
, NULL
);
440 ui_out_field_int (uiout
, "number", regnum
);
441 result
= get_register (regnum
, format
);
444 ui_out_tuple_end (uiout
);
448 /* Else, list of register #s, just do listed regs */
449 for (i
= 1; i
< argc
; i
++)
451 regnum
= atoi (argv
[i
]);
455 && REGISTER_NAME (regnum
) != NULL
456 && *REGISTER_NAME (regnum
) != '\000')
458 ui_out_tuple_begin (uiout
, NULL
);
459 ui_out_field_int (uiout
, "number", regnum
);
460 result
= get_register (regnum
, format
);
463 ui_out_tuple_end (uiout
);
467 xasprintf (&mi_error_message
, "bad register number");
471 ui_out_list_end (uiout
);
475 /* Output one register's contents in the desired format. */
477 get_register (int regnum
, int format
)
479 char *raw_buffer
= alloca (MAX_REGISTER_RAW_SIZE
);
480 char *virtual_buffer
= alloca (MAX_REGISTER_VIRTUAL_SIZE
);
482 static struct ui_stream
*stb
= NULL
;
484 stb
= ui_out_stream_new (uiout
);
489 /* read_relative_register_raw_bytes returns a virtual frame pointer
490 (FRAME_FP (selected_frame)) if regnum == FP_REGNUM instead
491 of the real contents of the register. To get around this,
492 use get_saved_register instead. */
493 get_saved_register (raw_buffer
, &optim
, (CORE_ADDR
*) NULL
, selected_frame
,
494 regnum
, (enum lval_type
*) NULL
);
497 xasprintf (&mi_error_message
, "Optimized out");
501 /* Convert raw data to virtual format if necessary. */
503 if (REGISTER_CONVERTIBLE (regnum
))
505 REGISTER_CONVERT_TO_VIRTUAL (regnum
, REGISTER_VIRTUAL_TYPE (regnum
),
506 raw_buffer
, virtual_buffer
);
509 memcpy (virtual_buffer
, raw_buffer
, REGISTER_VIRTUAL_SIZE (regnum
));
514 char *ptr
, buf
[1024];
518 for (j
= 0; j
< REGISTER_RAW_SIZE (regnum
); j
++)
520 register int idx
= TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
? j
521 : REGISTER_RAW_SIZE (regnum
) - 1 - j
;
522 sprintf (ptr
, "%02x", (unsigned char) raw_buffer
[idx
]);
525 ui_out_field_string (uiout
, "value", buf
);
526 /*fputs_filtered (buf, gdb_stdout); */
530 val_print (REGISTER_VIRTUAL_TYPE (regnum
), virtual_buffer
, 0, 0,
531 stb
->stream
, format
, 1, 0, Val_pretty_default
);
532 ui_out_field_stream (uiout
, "value", stb
);
533 ui_out_stream_delete (stb
);
538 /* Write given values into registers. The registers and values are
539 given as pairs. The corresponding MI command is
540 -data-write-register-values <format> [<regnum1> <value1>...<regnumN> <valueN>]*/
542 mi_cmd_data_write_register_values (char *command
, char **argv
, int argc
)
550 /* Note that the test for a valid register must include checking the
551 REGISTER_NAME because NUM_REGS may be allocated for the union of
552 the register sets within a family of related processors. In this
553 case, some entries of REGISTER_NAME will change depending upon
554 the particular processor being debugged. */
560 xasprintf (&mi_error_message
,
561 "mi_cmd_data_write_register_values: Usage: -data-write-register-values <format> [<regnum1> <value1>...<regnumN> <valueN>]");
565 format
= (int) argv
[0][0];
567 if (!target_has_registers
)
569 xasprintf (&mi_error_message
,
570 "mi_cmd_data_write_register_values: No registers.");
576 xasprintf (&mi_error_message
,
577 "mi_cmd_data_write_register_values: No regs and values specified.");
583 xasprintf (&mi_error_message
,
584 "mi_cmd_data_write_register_values: Regs and vals are not in pairs.");
588 for (i
= 1; i
< argc
; i
= i
+ 2)
590 regnum
= atoi (argv
[i
]);
594 && REGISTER_NAME (regnum
) != NULL
595 && *REGISTER_NAME (regnum
) != '\000')
598 struct cleanup
*old_chain
;
600 /* Get the value as a number */
601 value
= parse_and_eval_address (argv
[i
+ 1]);
602 /* Get the value into an array */
603 buffer
= xmalloc (REGISTER_SIZE
);
604 old_chain
= make_cleanup (xfree
, buffer
);
605 store_signed_integer (buffer
, REGISTER_SIZE
, value
);
607 write_register_bytes (REGISTER_BYTE (regnum
), buffer
, REGISTER_RAW_SIZE (regnum
));
608 /* Free the buffer. */
609 do_cleanups (old_chain
);
613 xasprintf (&mi_error_message
, "bad register number");
621 /*This is commented out because we decided it was not useful. I leave
622 it, just in case. ezannoni:1999-12-08 */
624 /* Assign a value to a variable. The expression argument must be in
625 the form A=2 or "A = 2" (I.e. if there are spaces it needs to be
628 mi_cmd_data_assign (char *command
, char **argv
, int argc
)
630 struct expression
*expr
;
631 struct cleanup
*old_chain
;
635 xasprintf (&mi_error_message
,
636 "mi_cmd_data_assign: Usage: -data-assign expression");
640 /* NOTE what follows is a clone of set_command(). FIXME: ezannoni
641 01-12-1999: Need to decide what to do with this for libgdb purposes. */
643 expr
= parse_expression (argv
[0]);
644 old_chain
= make_cleanup (free_current_contents
, &expr
);
645 evaluate_expression (expr
);
646 do_cleanups (old_chain
);
651 /* Evaluate the value of the argument. The argument is an
652 expression. If the expression contains spaces it needs to be
653 included in double quotes. */
655 mi_cmd_data_evaluate_expression (char *command
, char **argv
, int argc
)
657 struct expression
*expr
;
658 struct cleanup
*old_chain
= NULL
;
660 struct ui_stream
*stb
= NULL
;
662 stb
= ui_out_stream_new (uiout
);
666 xasprintf (&mi_error_message
,
667 "mi_cmd_data_evaluate_expression: Usage: -data-evaluate-expression expression");
671 expr
= parse_expression (argv
[0]);
673 old_chain
= make_cleanup (free_current_contents
, &expr
);
675 val
= evaluate_expression (expr
);
677 /* Print the result of the expression evaluation. */
678 val_print (VALUE_TYPE (val
), VALUE_CONTENTS (val
),
679 VALUE_EMBEDDED_OFFSET (val
), VALUE_ADDRESS (val
),
680 stb
->stream
, 0, 0, 0, 0);
682 ui_out_field_stream (uiout
, "value", stb
);
683 ui_out_stream_delete (stb
);
685 do_cleanups (old_chain
);
691 mi_cmd_target_download (char *args
, int from_tty
)
694 struct cleanup
*old_cleanups
= NULL
;
696 xasprintf (&run
, "load %s", args
);
697 old_cleanups
= make_cleanup (xfree
, run
);
698 execute_command (run
, from_tty
);
700 do_cleanups (old_cleanups
);
704 /* Connect to the remote target. */
706 mi_cmd_target_select (char *args
, int from_tty
)
709 struct cleanup
*old_cleanups
= NULL
;
711 xasprintf (&run
, "target %s", args
);
712 old_cleanups
= make_cleanup (xfree
, run
);
714 /* target-select is always synchronous. once the call has returned
715 we know that we are connected. */
716 /* NOTE: At present all targets that are connected are also
717 (implicitly) talking to a halted target. In the future this may
719 execute_command (run
, from_tty
);
721 do_cleanups (old_cleanups
);
723 /* Issue the completion message here. */
724 if (last_async_command
)
725 fputs_unfiltered (last_async_command
, raw_stdout
);
726 fputs_unfiltered ("^connected", raw_stdout
);
727 mi_out_put (uiout
, raw_stdout
);
728 mi_out_rewind (uiout
);
729 fputs_unfiltered ("\n", raw_stdout
);
730 do_exec_cleanups (ALL_CLEANUPS
);
736 ADDR: start address of data to be dumped.
737 WORD-FORMAT: a char indicating format for the ``word''. See
739 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes
740 NR_ROW: Number of rows.
741 NR_COL: The number of colums (words per row).
742 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
743 ASCHAR for unprintable characters.
745 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
746 displayes them. Returns:
748 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
751 The number of bytes read is SIZE*ROW*COL. */
754 mi_cmd_data_read_memory (char *command
, char **argv
, int argc
)
756 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
762 struct type
*word_type
;
775 static struct mi_opt opts
[] =
777 {"o", OFFSET_OPT
, 1},
783 int opt
= mi_getopt ("mi_cmd_data_read_memory", argc
, argv
, opts
,
787 switch ((enum opt
) opt
)
790 offset
= atol (optarg
);
797 if (argc
< 5 || argc
> 6)
799 xasprintf (&mi_error_message
,
800 "mi_cmd_data_read_memory: Usage: ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR].");
804 /* Extract all the arguments. */
806 /* Start address of the memory dump. */
807 addr
= parse_and_eval_address (argv
[0]) + offset
;
808 /* The format character to use when displaying a memory word. See
809 the ``x'' command. */
810 word_format
= argv
[1][0];
811 /* The size of the memory word. */
812 word_size
= atol (argv
[2]);
816 word_type
= builtin_type_int8
;
820 word_type
= builtin_type_int16
;
824 word_type
= builtin_type_int32
;
828 word_type
= builtin_type_int64
;
832 word_type
= builtin_type_int8
;
835 /* The number of rows */
836 nr_rows
= atol (argv
[3]);
839 xasprintf (&mi_error_message
,
840 "mi_cmd_data_read_memory: invalid number of rows.");
843 /* number of bytes per row. */
844 nr_cols
= atol (argv
[4]);
847 xasprintf (&mi_error_message
,
848 "mi_cmd_data_read_memory: invalid number of columns.");
850 /* The un-printable character when printing ascii. */
856 /* create a buffer and read it in. */
857 total_bytes
= word_size
* nr_rows
* nr_cols
;
858 mbuf
= xcalloc (total_bytes
, 1);
859 make_cleanup (xfree
, mbuf
);
862 xasprintf (&mi_error_message
,
863 "mi_cmd_data_read_memory: out of memory.");
867 while (nr_bytes
< total_bytes
)
870 long num
= target_read_memory_partial (addr
+ nr_bytes
, mbuf
+ nr_bytes
,
871 total_bytes
- nr_bytes
,
878 /* output the header information. */
879 ui_out_field_core_addr (uiout
, "addr", addr
);
880 ui_out_field_int (uiout
, "nr-bytes", nr_bytes
);
881 ui_out_field_int (uiout
, "total-bytes", total_bytes
);
882 ui_out_field_core_addr (uiout
, "next-row", addr
+ word_size
* nr_cols
);
883 ui_out_field_core_addr (uiout
, "prev-row", addr
- word_size
* nr_cols
);
884 ui_out_field_core_addr (uiout
, "next-page", addr
+ total_bytes
);
885 ui_out_field_core_addr (uiout
, "prev-page", addr
- total_bytes
);
887 /* Build the result as a two dimentional table. */
889 struct ui_stream
*stream
= ui_out_stream_new (uiout
);
892 ui_out_list_begin (uiout
, "memory");
893 for (row
= 0, row_byte
= 0;
895 row
++, row_byte
+= nr_cols
* word_size
)
899 ui_out_tuple_begin (uiout
, NULL
);
900 ui_out_field_core_addr (uiout
, "addr", addr
+ row_byte
);
901 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr + row_byte); */
902 ui_out_list_begin (uiout
, "data");
903 for (col
= 0, col_byte
= row_byte
;
905 col
++, col_byte
+= word_size
)
907 if (col_byte
+ word_size
> nr_bytes
)
909 ui_out_field_string (uiout
, NULL
, "N/A");
913 ui_file_rewind (stream
->stream
);
914 print_scalar_formatted (mbuf
+ col_byte
, word_type
, word_format
,
915 word_asize
, stream
->stream
);
916 ui_out_field_stream (uiout
, NULL
, stream
);
919 ui_out_list_end (uiout
);
923 ui_file_rewind (stream
->stream
);
924 for (byte
= row_byte
; byte
< row_byte
+ word_size
* nr_cols
; byte
++)
926 if (byte
>= nr_bytes
)
928 fputc_unfiltered ('X', stream
->stream
);
930 else if (mbuf
[byte
] < 32 || mbuf
[byte
] > 126)
932 fputc_unfiltered (aschar
, stream
->stream
);
935 fputc_unfiltered (mbuf
[byte
], stream
->stream
);
937 ui_out_field_stream (uiout
, "ascii", stream
);
939 ui_out_tuple_end (uiout
);
941 ui_out_stream_delete (stream
);
942 ui_out_list_end (uiout
);
944 do_cleanups (cleanups
);
948 /* DATA-MEMORY-WRITE:
950 COLUMN_OFFSET: optional argument. Must be preceeded by '-o'. The
951 offset from the beginning of the memory grid row where the cell to
953 ADDR: start address of the row in the memory grid where the memory
954 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
955 the location to write to.
956 FORMAT: a char indicating format for the ``word''. See
958 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
959 VALUE: value to be written into the memory address.
961 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
965 mi_cmd_data_write_memory (char *command
, char **argv
, int argc
)
970 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
971 enough when using a compiler other than GCC. */
974 struct cleanup
*old_chain
;
982 static struct mi_opt opts
[] =
984 {"o", OFFSET_OPT
, 1},
990 int opt
= mi_getopt ("mi_cmd_data_write_memory", argc
, argv
, opts
,
994 switch ((enum opt
) opt
)
997 offset
= atol (optarg
);
1006 xasprintf (&mi_error_message
,
1007 "mi_cmd_data_write_memory: Usage: [-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE.");
1008 return MI_CMD_ERROR
;
1011 /* Extract all the arguments. */
1012 /* Start address of the memory dump. */
1013 addr
= parse_and_eval_address (argv
[0]);
1014 /* The format character to use when displaying a memory word. See
1015 the ``x'' command. */
1016 word_format
= argv
[1][0];
1017 /* The size of the memory word. */
1018 word_size
= atol (argv
[2]);
1020 /* Calculate the real address of the write destination. */
1021 addr
+= (offset
* word_size
);
1023 /* Get the value as a number */
1024 value
= parse_and_eval_address (argv
[3]);
1025 /* Get the value into an array */
1026 buffer
= xmalloc (word_size
);
1027 old_chain
= make_cleanup (xfree
, buffer
);
1028 store_signed_integer (buffer
, word_size
, value
);
1029 /* Write it down to memory */
1030 write_memory (addr
, buffer
, word_size
);
1031 /* Free the buffer. */
1032 do_cleanups (old_chain
);
1037 /* Execute a command within a safe environment. Return >0 for
1038 ok. Return <0 for supress prompt. Return 0 to have the error
1039 extracted from error_last_message(). */
1042 captured_mi_execute_command (void *data
)
1044 struct mi_parse
*context
= data
;
1045 enum mi_cmd_result rc
;
1047 switch (context
->op
)
1051 /* A MI command was read from the input stream */
1053 /* FIXME: gdb_???? */
1054 fprintf_unfiltered (raw_stdout
, " token=`%s' command=`%s' args=`%s'\n",
1055 context
->token
, context
->command
, context
->args
);
1056 /* FIXME: cagney/1999-09-25: Rather than this convoluted
1057 condition expression, each function should return an
1058 indication of what action is required and then switch on
1060 rc
= mi_cmd_execute (context
);
1061 if (!target_can_async_p () || !target_executing
)
1063 /* print the result if there were no errors */
1064 if (rc
== MI_CMD_DONE
)
1066 fputs_unfiltered (context
->token
, raw_stdout
);
1067 fputs_unfiltered ("^done", raw_stdout
);
1068 mi_out_put (uiout
, raw_stdout
);
1069 mi_out_rewind (uiout
);
1070 fputs_unfiltered ("\n", raw_stdout
);
1072 else if (rc
== MI_CMD_ERROR
)
1074 if (mi_error_message
)
1076 fputs_unfiltered (context
->token
, raw_stdout
);
1077 fputs_unfiltered ("^error,msg=\"", raw_stdout
);
1078 fputstr_unfiltered (mi_error_message
, '"', raw_stdout
);
1079 xfree (mi_error_message
);
1080 fputs_unfiltered ("\"\n", raw_stdout
);
1082 mi_out_rewind (uiout
);
1084 else if (rc
== MI_CMD_CAUGHT_ERROR
)
1086 mi_out_rewind (uiout
);
1090 mi_out_rewind (uiout
);
1092 else if (sync_execution
)
1093 /* Don't print the prompt. We are executing the target in
1094 synchronous mode. */
1099 /* A CLI command was read from the input stream */
1100 /* This will be removed as soon as we have a complete set of
1102 /* echo the command on the console. */
1103 fprintf_unfiltered (gdb_stdlog
, "%s\n", context
->command
);
1104 /* FIXME: If the command string has something that looks like
1105 a format spec (e.g. %s) we will get a core dump */
1106 mi_execute_cli_command ("%s", context
->command
);
1107 /* print the result */
1108 /* FIXME: Check for errors here. */
1109 fputs_unfiltered (context
->token
, raw_stdout
);
1110 fputs_unfiltered ("^done", raw_stdout
);
1111 mi_out_put (uiout
, raw_stdout
);
1112 mi_out_rewind (uiout
);
1113 fputs_unfiltered ("\n", raw_stdout
);
1122 mi_execute_command (char *cmd
, int from_tty
)
1124 struct mi_parse
*command
;
1126 /* This is to handle EOF (^D). We just quit gdb. */
1127 /* FIXME: we should call some API function here. */
1129 quit_force (NULL
, from_tty
);
1131 command
= mi_parse (cmd
);
1133 if (command
!= NULL
)
1135 /* FIXME: cagney/1999-11-04: Can this use of catch_errors either
1136 be pushed even further down or even eliminated? */
1137 int rc
= catch_errors (captured_mi_execute_command
, command
, "",
1141 /* The command is executing synchronously. Bail out early
1142 suppressing the finished prompt. */
1143 mi_parse_free (command
);
1148 char *msg
= error_last_message ();
1149 struct cleanup
*cleanup
= make_cleanup (xfree
, msg
);
1150 /* The command execution failed and error() was called
1152 fputs_unfiltered (command
->token
, raw_stdout
);
1153 fputs_unfiltered ("^error,msg=\"", raw_stdout
);
1154 fputstr_unfiltered (msg
, '"', raw_stdout
);
1155 fputs_unfiltered ("\"\n", raw_stdout
);
1157 mi_parse_free (command
);
1160 fputs_unfiltered ("(gdb) \n", raw_stdout
);
1161 gdb_flush (raw_stdout
);
1162 /* print any buffered hook code */
1166 static enum mi_cmd_result
1167 mi_cmd_execute (struct mi_parse
*parse
)
1169 if (parse
->cmd
->argv_func
!= NULL
1170 || parse
->cmd
->args_func
!= NULL
)
1172 /* FIXME: We need to save the token because the command executed
1173 may be asynchronous and need to print the token again.
1174 In the future we can pass the token down to the func
1175 and get rid of the last_async_command */
1176 /* The problem here is to keep the token around when we launch
1177 the target, and we want to interrupt it later on. The
1178 interrupt command will have its own token, but when the
1179 target stops, we must display the token corresponding to the
1180 last execution command given. So we have another string where
1181 we copy the token (previous_async_command), if this was
1182 indeed the token of an execution command, and when we stop we
1183 print that one. This is possible because the interrupt
1184 command, when over, will copy that token back into the
1185 default token string (last_async_command). */
1187 if (target_executing
)
1189 if (!previous_async_command
)
1190 previous_async_command
= xstrdup (last_async_command
);
1191 if (strcmp (parse
->command
, "exec-interrupt"))
1193 fputs_unfiltered (parse
->token
, raw_stdout
);
1194 fputs_unfiltered ("^error,msg=\"", raw_stdout
);
1195 fputs_unfiltered ("Cannot execute command ", raw_stdout
);
1196 fputstr_unfiltered (parse
->command
, '"', raw_stdout
);
1197 fputs_unfiltered (" while target running", raw_stdout
);
1198 fputs_unfiltered ("\"\n", raw_stdout
);
1199 return MI_CMD_ERROR
;
1202 last_async_command
= xstrdup (parse
->token
);
1203 make_exec_cleanup (free_current_contents
, &last_async_command
);
1204 /* FIXME: DELETE THIS! */
1205 if (parse
->cmd
->args_func
!= NULL
)
1206 return parse
->cmd
->args_func (parse
->args
, 0 /*from_tty */ );
1207 return parse
->cmd
->argv_func (parse
->command
, parse
->argv
, parse
->argc
);
1209 else if (parse
->cmd
->cli
!= 0)
1211 /* FIXME: DELETE THIS. */
1212 /* The operation is still implemented by a cli command */
1213 /* Must be a synchronous one */
1214 mi_execute_cli_command (parse
->cmd
->cli
, parse
->args
);
1219 /* FIXME: DELETE THIS. */
1220 fputs_unfiltered (parse
->token
, raw_stdout
);
1221 fputs_unfiltered ("^error,msg=\"", raw_stdout
);
1222 fputs_unfiltered ("Undefined mi command: ", raw_stdout
);
1223 fputstr_unfiltered (parse
->command
, '"', raw_stdout
);
1224 fputs_unfiltered (" (missing implementation)", raw_stdout
);
1225 fputs_unfiltered ("\"\n", raw_stdout
);
1226 return MI_CMD_ERROR
;
1231 mi_execute_command_wrapper (char *cmd
)
1233 mi_execute_command (cmd
, stdin
== instream
);
1236 /* FIXME: This is just a hack so we can get some extra commands going.
1237 We don't want to channel things through the CLI, but call libgdb directly */
1238 /* Use only for synchronous commands */
1241 mi_execute_cli_command (const char *cli
, char *args
)
1245 struct cleanup
*old_cleanups
;
1247 xasprintf (&run
, cli
, args
);
1249 /* FIXME: gdb_???? */
1250 fprintf_unfiltered (gdb_stdout
, "cli=%s run=%s\n",
1252 old_cleanups
= make_cleanup (xfree
, run
);
1253 execute_command ( /*ui */ run
, 0 /*from_tty */ );
1254 do_cleanups (old_cleanups
);
1260 mi_execute_async_cli_command (char *mi
, char *args
, int from_tty
)
1262 struct cleanup
*old_cleanups
;
1266 if (target_can_async_p ())
1268 async_args
= (char *) xmalloc (strlen (args
) + 2);
1269 make_exec_cleanup (free
, async_args
);
1270 strcpy (async_args
, args
);
1271 strcat (async_args
, "&");
1272 xasprintf (&run
, "%s %s", mi
, async_args
);
1273 make_exec_cleanup (free
, run
);
1274 add_continuation (mi_exec_async_cli_cmd_continuation
, NULL
);
1275 old_cleanups
= NULL
;
1279 xasprintf (&run
, "%s %s", mi
, args
);
1280 old_cleanups
= make_cleanup (xfree
, run
);
1283 if (!target_can_async_p ())
1285 /* NOTE: For synchronous targets asynchronous behavour is faked by
1286 printing out the GDB prompt before we even try to execute the
1288 if (last_async_command
)
1289 fputs_unfiltered (last_async_command
, raw_stdout
);
1290 fputs_unfiltered ("^running\n", raw_stdout
);
1291 fputs_unfiltered ("(gdb) \n", raw_stdout
);
1292 gdb_flush (raw_stdout
);
1296 /* FIXME: cagney/1999-11-29: Printing this message before
1297 calling execute_command is wrong. It should only be printed
1298 once gdb has confirmed that it really has managed to send a
1299 run command to the target. */
1300 if (last_async_command
)
1301 fputs_unfiltered (last_async_command
, raw_stdout
);
1302 fputs_unfiltered ("^running\n", raw_stdout
);
1305 execute_command ( /*ui */ run
, 0 /*from_tty */ );
1307 if (!target_can_async_p ())
1309 /* Do this before doing any printing. It would appear that some
1310 print code leaves garbage around in the buffer. */
1311 do_cleanups (old_cleanups
);
1312 /* If the target was doing the operation synchronously we fake
1313 the stopped message. */
1314 if (last_async_command
)
1315 fputs_unfiltered (last_async_command
, raw_stdout
);
1316 fputs_unfiltered ("*stopped", raw_stdout
);
1317 mi_out_put (uiout
, raw_stdout
);
1318 mi_out_rewind (uiout
);
1319 fputs_unfiltered ("\n", raw_stdout
);
1320 return MI_CMD_QUIET
;
1326 mi_exec_async_cli_cmd_continuation (struct continuation_arg
*arg
)
1328 if (last_async_command
)
1329 fputs_unfiltered (last_async_command
, raw_stdout
);
1330 fputs_unfiltered ("*stopped", raw_stdout
);
1331 mi_out_put (uiout
, raw_stdout
);
1332 fputs_unfiltered ("\n", raw_stdout
);
1333 fputs_unfiltered ("(gdb) \n", raw_stdout
);
1334 gdb_flush (raw_stdout
);
1335 do_exec_cleanups (ALL_CLEANUPS
);
1339 mi_input (char *buf
)
1341 return gdb_readline (NULL
);
1345 mi_load_progress (const char *section_name
,
1346 unsigned long sent_so_far
,
1347 unsigned long total_section
,
1348 unsigned long total_sent
,
1349 unsigned long grand_total
)
1351 struct timeval time_now
, delta
, update_threshold
;
1352 static struct timeval last_update
;
1353 static char *previous_sect_name
= NULL
;
1356 if (!interpreter_p
|| strncmp (interpreter_p
, "mi", 2) != 0)
1359 update_threshold
.tv_sec
= 0;
1360 update_threshold
.tv_usec
= 500000;
1361 gettimeofday (&time_now
, NULL
);
1363 delta
.tv_usec
= time_now
.tv_usec
- last_update
.tv_usec
;
1364 delta
.tv_sec
= time_now
.tv_sec
- last_update
.tv_sec
;
1366 if (delta
.tv_usec
< 0)
1369 delta
.tv_usec
+= 1000000;
1372 new_section
= (previous_sect_name
?
1373 strcmp (previous_sect_name
, section_name
) : 1);
1376 xfree (previous_sect_name
);
1377 previous_sect_name
= xstrdup (section_name
);
1379 if (last_async_command
)
1380 fputs_unfiltered (last_async_command
, raw_stdout
);
1381 fputs_unfiltered ("+download", raw_stdout
);
1382 ui_out_tuple_begin (uiout
, NULL
);
1383 ui_out_field_string (uiout
, "section", section_name
);
1384 ui_out_field_int (uiout
, "section-size", total_section
);
1385 ui_out_field_int (uiout
, "total-size", grand_total
);
1386 ui_out_tuple_end (uiout
);
1387 mi_out_put (uiout
, raw_stdout
);
1388 fputs_unfiltered ("\n", raw_stdout
);
1389 gdb_flush (raw_stdout
);
1392 if (delta
.tv_sec
>= update_threshold
.tv_sec
&&
1393 delta
.tv_usec
>= update_threshold
.tv_usec
)
1395 last_update
.tv_sec
= time_now
.tv_sec
;
1396 last_update
.tv_usec
= time_now
.tv_usec
;
1397 if (last_async_command
)
1398 fputs_unfiltered (last_async_command
, raw_stdout
);
1399 fputs_unfiltered ("+download", raw_stdout
);
1400 ui_out_tuple_begin (uiout
, NULL
);
1401 ui_out_field_string (uiout
, "section", section_name
);
1402 ui_out_field_int (uiout
, "section-sent", sent_so_far
);
1403 ui_out_field_int (uiout
, "section-size", total_section
);
1404 ui_out_field_int (uiout
, "total-sent", total_sent
);
1405 ui_out_field_int (uiout
, "total-size", grand_total
);
1406 ui_out_tuple_end (uiout
);
1407 mi_out_put (uiout
, raw_stdout
);
1408 fputs_unfiltered ("\n", raw_stdout
);
1409 gdb_flush (raw_stdout
);
1414 mi_command_loop (int mi_version
)
1416 /* HACK: Force stdout/stderr to point at the console. This avoids
1417 any potential side effects caused by legacy code that is still
1418 using the TUI / fputs_unfiltered_hook */
1419 raw_stdout
= stdio_fileopen (stdout
);
1420 /* Route normal output through the MIx */
1421 gdb_stdout
= mi_console_file_new (raw_stdout
, "~");
1422 /* Route error and log output through the MI */
1423 gdb_stderr
= mi_console_file_new (raw_stdout
, "&");
1424 gdb_stdlog
= gdb_stderr
;
1425 /* Route target output through the MI. */
1426 gdb_stdtarg
= mi_console_file_new (raw_stdout
, "@");
1428 /* HACK: Poke the ui_out table directly. Should we be creating a
1429 mi_out object wired up to the above gdb_stdout / gdb_stderr? */
1430 uiout
= mi_out_new (mi_version
);
1432 /* HACK: Override any other interpreter hooks. We need to create a
1433 real event table and pass in that. */
1435 /* command_loop_hook = 0; */
1436 print_frame_info_listing_hook
= 0;
1439 create_breakpoint_hook
= 0;
1440 delete_breakpoint_hook
= 0;
1441 modify_breakpoint_hook
= 0;
1442 interactive_hook
= 0;
1443 registers_changed_hook
= 0;
1444 readline_begin_hook
= 0;
1446 readline_end_hook
= 0;
1447 register_changed_hook
= 0;
1448 memory_changed_hook
= 0;
1450 target_wait_hook
= 0;
1451 call_command_hook
= 0;
1453 error_begin_hook
= 0;
1454 show_load_progress
= mi_load_progress
;
1456 /* Turn off 8 bit strings in quoted output. Any character with the
1457 high bit set is printed using C's octal format. */
1458 sevenbit_strings
= 1;
1460 /* Tell the world that we're alive */
1461 fputs_unfiltered ("(gdb) \n", raw_stdout
);
1462 gdb_flush (raw_stdout
);
1465 simplified_command_loop (mi_input
, mi_execute_command
);
1467 start_event_loop ();
1471 mi0_command_loop (void)
1473 mi_command_loop (0);
1477 mi1_command_loop (void)
1479 mi_command_loop (1);
1483 setup_architecture_data (void)
1485 /* don't trust REGISTER_BYTES to be zero. */
1486 old_regs
= xmalloc (REGISTER_BYTES
+ 1);
1487 memset (old_regs
, 0, REGISTER_BYTES
+ 1);
1491 mi_init_ui (char *arg0
)
1493 /* Eventually this will contain code that takes control of the
1498 _initialize_mi_main (void)
1500 if (interpreter_p
== NULL
)
1503 /* If we're _the_ interpreter, take control. */
1504 if (strcmp (interpreter_p
, "mi0") == 0)
1505 command_loop_hook
= mi0_command_loop
;
1506 else if (strcmp (interpreter_p
, "mi") == 0
1507 || strcmp (interpreter_p
, "mi1") == 0)
1508 command_loop_hook
= mi1_command_loop
;
1512 init_ui_hook
= mi_init_ui
;
1513 setup_architecture_data ();
1514 register_gdbarch_swap (&old_regs
, sizeof (old_regs
), NULL
);
1515 register_gdbarch_swap (NULL
, 0, setup_architecture_data
);
1518 /* These overwrite some of the initialization done in
1519 _intialize_event_loop. */
1520 call_readline
= gdb_readline2
;
1521 input_handler
= mi_execute_command_wrapper
;
1522 add_file_handler (input_fd
, stdin_event_handler
, 0);
1523 async_command_editing_p
= 0;
1525 /* FIXME: Should we notify main that we are here as a possible