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() */
52 struct ui_file
*raw_stdout
;
54 /* The token of the last asynchronous command */
55 static char *last_async_command
;
56 static char *previous_async_command
;
57 static char *mi_error_message
;
58 static char *old_regs
;
60 extern void _initialize_mi_main (void);
61 static char *mi_input (char *);
62 static void mi_execute_command (char *cmd
, int from_tty
);
63 static enum mi_cmd_result
mi_cmd_execute (struct mi_parse
*parse
);
65 static void mi_execute_cli_command (const char *cli
, char *args
);
66 static enum mi_cmd_result
mi_execute_async_cli_command (char *mi
, char *args
, int from_tty
);
67 static void mi_execute_command_wrapper (char *cmd
);
69 void mi_exec_async_cli_cmd_continuation (struct continuation_arg
*arg
);
71 static int register_changed_p (int regnum
);
72 static int get_register (int regnum
, int format
);
73 static void mi_load_progress (const char *section_name
,
74 unsigned long sent_so_far
,
75 unsigned long total_section
,
76 unsigned long total_sent
,
77 unsigned long grand_total
);
79 /* FIXME: these should go in some .h file, but infcmd.c doesn't have a
80 corresponding .h file. These wrappers will be obsolete anyway, once
81 we pull the plug on the sanitization. */
82 extern void interrupt_target_command_wrapper (char *, int);
83 extern void return_command_wrapper (char *, int);
85 /* Command implementations. FIXME: Is this libgdb? No. This is the MI
86 layer that calls libgdb. Any operation used in the below should be
90 mi_cmd_gdb_exit (char *command
, char **argv
, int argc
)
92 /* We have to print everything right here because we never return */
93 if (last_async_command
)
94 fputs_unfiltered (last_async_command
, raw_stdout
);
95 fputs_unfiltered ("^exit\n", raw_stdout
);
96 mi_out_put (uiout
, raw_stdout
);
97 /* FIXME: The function called is not yet a formal libgdb function */
98 quit_force (NULL
, FROM_TTY
);
103 mi_cmd_exec_run (char *args
, int from_tty
)
105 /* FIXME: Should call a libgdb function, not a cli wrapper */
106 return mi_execute_async_cli_command ("run", args
, from_tty
);
110 mi_cmd_exec_next (char *args
, int from_tty
)
112 /* FIXME: Should call a libgdb function, not a cli wrapper */
113 return mi_execute_async_cli_command ("next", args
, from_tty
);
117 mi_cmd_exec_next_instruction (char *args
, int from_tty
)
119 /* FIXME: Should call a libgdb function, not a cli wrapper */
120 return mi_execute_async_cli_command ("nexti", args
, from_tty
);
124 mi_cmd_exec_step (char *args
, int from_tty
)
126 /* FIXME: Should call a libgdb function, not a cli wrapper */
127 return mi_execute_async_cli_command ("step", args
, from_tty
);
131 mi_cmd_exec_step_instruction (char *args
, int from_tty
)
133 /* FIXME: Should call a libgdb function, not a cli wrapper */
134 return mi_execute_async_cli_command ("stepi", args
, from_tty
);
138 mi_cmd_exec_finish (char *args
, int from_tty
)
140 /* FIXME: Should call a libgdb function, not a cli wrapper */
141 return mi_execute_async_cli_command ("finish", args
, from_tty
);
145 mi_cmd_exec_until (char *args
, int from_tty
)
147 /* FIXME: Should call a libgdb function, not a cli wrapper */
148 return mi_execute_async_cli_command ("until", args
, from_tty
);
152 mi_cmd_exec_return (char *args
, int from_tty
)
154 /* This command doesn't really execute the target, it just pops the
155 specified number of frames. */
157 /* Call return_command with from_tty argument equal to 0 so as to
158 avoid being queried. */
159 return_command_wrapper (args
, 0);
161 /* Call return_command with from_tty argument equal to 0 so as to
162 avoid being queried. */
163 return_command_wrapper (NULL
, 0);
165 /* Because we have called return_command with from_tty = 0, we need
166 to print the frame here. */
167 show_and_print_stack_frame (selected_frame
,
168 frame_relative_level (selected_frame
),
175 mi_cmd_exec_continue (char *args
, int from_tty
)
177 /* FIXME: Should call a libgdb function, not a cli wrapper */
178 return mi_execute_async_cli_command ("continue", args
, from_tty
);
181 /* Interrupt the execution of the target. Note how we must play around
182 with the token varialbes, in order to display the current token in
183 the result of the interrupt command, and the previous execution
184 token when the target finally stops. See comments in
187 mi_cmd_exec_interrupt (char *args
, int from_tty
)
189 if (!target_executing
)
191 xasprintf (&mi_error_message
,
192 "mi_cmd_exec_interrupt: Inferior not executing.");
195 interrupt_target_command_wrapper (args
, from_tty
);
196 if (last_async_command
)
197 fputs_unfiltered (last_async_command
, raw_stdout
);
198 fputs_unfiltered ("^done", raw_stdout
);
199 xfree (last_async_command
);
200 if (previous_async_command
)
201 last_async_command
= xstrdup (previous_async_command
);
202 xfree (previous_async_command
);
203 previous_async_command
= NULL
;
204 mi_out_put (uiout
, raw_stdout
);
205 mi_out_rewind (uiout
);
206 fputs_unfiltered ("\n", raw_stdout
);
211 mi_cmd_thread_select (char *command
, char **argv
, int argc
)
217 xasprintf (&mi_error_message
,
218 "mi_cmd_thread_select: USAGE: threadnum.");
222 rc
= gdb_thread_select (uiout
, argv
[0]);
224 if (rc
== GDB_RC_FAIL
)
225 return MI_CMD_CAUGHT_ERROR
;
231 mi_cmd_thread_list_ids (char *command
, char **argv
, int argc
)
233 enum gdb_rc rc
= MI_CMD_DONE
;
237 xasprintf (&mi_error_message
,
238 "mi_cmd_thread_list_ids: No arguments required.");
242 rc
= gdb_list_thread_ids (uiout
);
244 if (rc
== GDB_RC_FAIL
)
245 return MI_CMD_CAUGHT_ERROR
;
251 mi_cmd_data_list_register_names (char *command
, char **argv
, int argc
)
256 /* Note that the test for a valid register must include checking the
257 REGISTER_NAME because NUM_REGS may be allocated for the union of
258 the register sets within a family of related processors. In this
259 case, some entries of REGISTER_NAME will change depending upon
260 the particular processor being debugged. */
262 numregs
= NUM_REGS
+ NUM_PSEUDO_REGS
;
264 ui_out_list_begin (uiout
, "register-names");
266 if (argc
== 0) /* No args, just do all the regs */
272 if (REGISTER_NAME (regnum
) == NULL
273 || *(REGISTER_NAME (regnum
)) == '\0')
274 ui_out_field_string (uiout
, NULL
, "");
276 ui_out_field_string (uiout
, NULL
, REGISTER_NAME (regnum
));
280 /* Else, list of register #s, just do listed regs */
281 for (i
= 0; i
< argc
; i
++)
283 regnum
= atoi (argv
[i
]);
284 if (regnum
< 0 || regnum
>= numregs
)
286 xasprintf (&mi_error_message
, "bad register number");
289 if (REGISTER_NAME (regnum
) == NULL
290 || *(REGISTER_NAME (regnum
)) == '\0')
291 ui_out_field_string (uiout
, NULL
, "");
293 ui_out_field_string (uiout
, NULL
, REGISTER_NAME (regnum
));
295 ui_out_list_end (uiout
);
300 mi_cmd_data_list_changed_registers (char *command
, char **argv
, int argc
)
302 int regnum
, numregs
, changed
;
305 /* Note that the test for a valid register must include checking the
306 REGISTER_NAME because NUM_REGS may be allocated for the union of
307 the register sets within a family of related processors. In this
308 case, some entries of REGISTER_NAME will change depending upon
309 the particular processor being debugged. */
313 ui_out_list_begin (uiout
, "changed-registers");
315 if (argc
== 0) /* No args, just do all the regs */
321 if (REGISTER_NAME (regnum
) == NULL
322 || *(REGISTER_NAME (regnum
)) == '\0')
324 changed
= register_changed_p (regnum
);
327 xasprintf (&mi_error_message
,
328 "mi_cmd_data_list_changed_registers: Unable to read register contents.");
332 ui_out_field_int (uiout
, NULL
, regnum
);
336 /* Else, list of register #s, just do listed regs */
337 for (i
= 0; i
< argc
; i
++)
339 regnum
= atoi (argv
[i
]);
343 && REGISTER_NAME (regnum
) != NULL
344 && *REGISTER_NAME (regnum
) != '\000')
346 changed
= register_changed_p (regnum
);
349 xasprintf (&mi_error_message
,
350 "mi_cmd_data_list_register_change: Unable to read register contents.");
354 ui_out_field_int (uiout
, NULL
, regnum
);
358 xasprintf (&mi_error_message
, "bad register number");
362 ui_out_list_end (uiout
);
367 register_changed_p (int regnum
)
369 char *raw_buffer
= alloca (MAX_REGISTER_RAW_SIZE
);
371 if (! frame_register_read (selected_frame
, regnum
, raw_buffer
))
374 if (memcmp (&old_regs
[REGISTER_BYTE (regnum
)], raw_buffer
,
375 REGISTER_RAW_SIZE (regnum
)) == 0)
378 /* Found a changed register. Return 1. */
380 memcpy (&old_regs
[REGISTER_BYTE (regnum
)], raw_buffer
,
381 REGISTER_RAW_SIZE (regnum
));
386 /* Return a list of register number and value pairs. The valid
387 arguments expected are: a letter indicating the format in which to
388 display the registers contents. This can be one of: x (hexadecimal), d
389 (decimal), N (natural), t (binary), o (octal), r (raw). After the
390 format argumetn there can be a sequence of numbers, indicating which
391 registers to fetch the content of. If the format is the only argument,
392 a list of all the registers with their values is returned. */
394 mi_cmd_data_list_register_values (char *command
, char **argv
, int argc
)
396 int regnum
, numregs
, format
, result
;
399 /* Note that the test for a valid register must include checking the
400 REGISTER_NAME because NUM_REGS may be allocated for the union of
401 the register sets within a family of related processors. In this
402 case, some entries of REGISTER_NAME will change depending upon
403 the particular processor being debugged. */
409 xasprintf (&mi_error_message
,
410 "mi_cmd_data_list_register_values: Usage: -data-list-register-values <format> [<regnum1>...<regnumN>]");
414 format
= (int) argv
[0][0];
416 if (!target_has_registers
)
418 xasprintf (&mi_error_message
,
419 "mi_cmd_data_list_register_values: No registers.");
423 ui_out_list_begin (uiout
, "register-values");
425 if (argc
== 1) /* No args, beside the format: do all the regs */
431 if (REGISTER_NAME (regnum
) == NULL
432 || *(REGISTER_NAME (regnum
)) == '\0')
434 ui_out_tuple_begin (uiout
, NULL
);
435 ui_out_field_int (uiout
, "number", regnum
);
436 result
= get_register (regnum
, format
);
439 ui_out_tuple_end (uiout
);
443 /* Else, list of register #s, just do listed regs */
444 for (i
= 1; i
< argc
; i
++)
446 regnum
= atoi (argv
[i
]);
450 && REGISTER_NAME (regnum
) != NULL
451 && *REGISTER_NAME (regnum
) != '\000')
453 ui_out_tuple_begin (uiout
, NULL
);
454 ui_out_field_int (uiout
, "number", regnum
);
455 result
= get_register (regnum
, format
);
458 ui_out_tuple_end (uiout
);
462 xasprintf (&mi_error_message
, "bad register number");
466 ui_out_list_end (uiout
);
470 /* Output one register's contents in the desired format. */
472 get_register (int regnum
, int format
)
474 char *raw_buffer
= alloca (MAX_REGISTER_RAW_SIZE
);
475 char *virtual_buffer
= alloca (MAX_REGISTER_VIRTUAL_SIZE
);
477 static struct ui_stream
*stb
= NULL
;
479 stb
= ui_out_stream_new (uiout
);
484 get_saved_register (raw_buffer
, &optim
, (CORE_ADDR
*) NULL
, selected_frame
,
485 regnum
, (enum lval_type
*) NULL
);
488 xasprintf (&mi_error_message
, "Optimized out");
492 /* Convert raw data to virtual format if necessary. */
494 if (REGISTER_CONVERTIBLE (regnum
))
496 REGISTER_CONVERT_TO_VIRTUAL (regnum
, REGISTER_VIRTUAL_TYPE (regnum
),
497 raw_buffer
, virtual_buffer
);
500 memcpy (virtual_buffer
, raw_buffer
, REGISTER_VIRTUAL_SIZE (regnum
));
505 char *ptr
, buf
[1024];
509 for (j
= 0; j
< REGISTER_RAW_SIZE (regnum
); j
++)
511 register int idx
= TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
? j
512 : REGISTER_RAW_SIZE (regnum
) - 1 - j
;
513 sprintf (ptr
, "%02x", (unsigned char) raw_buffer
[idx
]);
516 ui_out_field_string (uiout
, "value", buf
);
517 /*fputs_filtered (buf, gdb_stdout); */
521 val_print (REGISTER_VIRTUAL_TYPE (regnum
), virtual_buffer
, 0, 0,
522 stb
->stream
, format
, 1, 0, Val_pretty_default
);
523 ui_out_field_stream (uiout
, "value", stb
);
524 ui_out_stream_delete (stb
);
529 /* Write given values into registers. The registers and values are
530 given as pairs. The corresponding MI command is
531 -data-write-register-values <format> [<regnum1> <value1>...<regnumN> <valueN>]*/
533 mi_cmd_data_write_register_values (char *command
, char **argv
, int argc
)
541 /* Note that the test for a valid register must include checking the
542 REGISTER_NAME because NUM_REGS may be allocated for the union of
543 the register sets within a family of related processors. In this
544 case, some entries of REGISTER_NAME will change depending upon
545 the particular processor being debugged. */
551 xasprintf (&mi_error_message
,
552 "mi_cmd_data_write_register_values: Usage: -data-write-register-values <format> [<regnum1> <value1>...<regnumN> <valueN>]");
556 format
= (int) argv
[0][0];
558 if (!target_has_registers
)
560 xasprintf (&mi_error_message
,
561 "mi_cmd_data_write_register_values: No registers.");
567 xasprintf (&mi_error_message
,
568 "mi_cmd_data_write_register_values: No regs and values specified.");
574 xasprintf (&mi_error_message
,
575 "mi_cmd_data_write_register_values: Regs and vals are not in pairs.");
579 for (i
= 1; i
< argc
; i
= i
+ 2)
581 regnum
= atoi (argv
[i
]);
585 && REGISTER_NAME (regnum
) != NULL
586 && *REGISTER_NAME (regnum
) != '\000')
589 struct cleanup
*old_chain
;
591 /* Get the value as a number */
592 value
= parse_and_eval_address (argv
[i
+ 1]);
593 /* Get the value into an array */
594 buffer
= xmalloc (REGISTER_SIZE
);
595 old_chain
= make_cleanup (xfree
, buffer
);
596 store_signed_integer (buffer
, REGISTER_SIZE
, value
);
598 write_register_bytes (REGISTER_BYTE (regnum
), buffer
, REGISTER_RAW_SIZE (regnum
));
599 /* Free the buffer. */
600 do_cleanups (old_chain
);
604 xasprintf (&mi_error_message
, "bad register number");
612 /*This is commented out because we decided it was not useful. I leave
613 it, just in case. ezannoni:1999-12-08 */
615 /* Assign a value to a variable. The expression argument must be in
616 the form A=2 or "A = 2" (I.e. if there are spaces it needs to be
619 mi_cmd_data_assign (char *command
, char **argv
, int argc
)
621 struct expression
*expr
;
622 struct cleanup
*old_chain
;
626 xasprintf (&mi_error_message
,
627 "mi_cmd_data_assign: Usage: -data-assign expression");
631 /* NOTE what follows is a clone of set_command(). FIXME: ezannoni
632 01-12-1999: Need to decide what to do with this for libgdb purposes. */
634 expr
= parse_expression (argv
[0]);
635 old_chain
= make_cleanup (free_current_contents
, &expr
);
636 evaluate_expression (expr
);
637 do_cleanups (old_chain
);
642 /* Evaluate the value of the argument. The argument is an
643 expression. If the expression contains spaces it needs to be
644 included in double quotes. */
646 mi_cmd_data_evaluate_expression (char *command
, char **argv
, int argc
)
648 struct expression
*expr
;
649 struct cleanup
*old_chain
= NULL
;
651 struct ui_stream
*stb
= NULL
;
653 stb
= ui_out_stream_new (uiout
);
657 xasprintf (&mi_error_message
,
658 "mi_cmd_data_evaluate_expression: Usage: -data-evaluate-expression expression");
662 expr
= parse_expression (argv
[0]);
664 old_chain
= make_cleanup (free_current_contents
, &expr
);
666 val
= evaluate_expression (expr
);
668 /* Print the result of the expression evaluation. */
669 val_print (VALUE_TYPE (val
), VALUE_CONTENTS (val
),
670 VALUE_EMBEDDED_OFFSET (val
), VALUE_ADDRESS (val
),
671 stb
->stream
, 0, 0, 0, 0);
673 ui_out_field_stream (uiout
, "value", stb
);
674 ui_out_stream_delete (stb
);
676 do_cleanups (old_chain
);
682 mi_cmd_target_download (char *args
, int from_tty
)
685 struct cleanup
*old_cleanups
= NULL
;
687 xasprintf (&run
, "load %s", args
);
688 old_cleanups
= make_cleanup (xfree
, run
);
689 execute_command (run
, from_tty
);
691 do_cleanups (old_cleanups
);
695 /* Connect to the remote target. */
697 mi_cmd_target_select (char *args
, int from_tty
)
700 struct cleanup
*old_cleanups
= NULL
;
702 xasprintf (&run
, "target %s", args
);
703 old_cleanups
= make_cleanup (xfree
, run
);
705 /* target-select is always synchronous. once the call has returned
706 we know that we are connected. */
707 /* NOTE: At present all targets that are connected are also
708 (implicitly) talking to a halted target. In the future this may
710 execute_command (run
, from_tty
);
712 do_cleanups (old_cleanups
);
714 /* Issue the completion message here. */
715 if (last_async_command
)
716 fputs_unfiltered (last_async_command
, raw_stdout
);
717 fputs_unfiltered ("^connected", raw_stdout
);
718 mi_out_put (uiout
, raw_stdout
);
719 mi_out_rewind (uiout
);
720 fputs_unfiltered ("\n", raw_stdout
);
721 do_exec_cleanups (ALL_CLEANUPS
);
727 ADDR: start address of data to be dumped.
728 WORD-FORMAT: a char indicating format for the ``word''. See
730 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes
731 NR_ROW: Number of rows.
732 NR_COL: The number of colums (words per row).
733 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
734 ASCHAR for unprintable characters.
736 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
737 displayes them. Returns:
739 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
742 The number of bytes read is SIZE*ROW*COL. */
745 mi_cmd_data_read_memory (char *command
, char **argv
, int argc
)
747 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
753 struct type
*word_type
;
766 static struct mi_opt opts
[] =
768 {"o", OFFSET_OPT
, 1},
774 int opt
= mi_getopt ("mi_cmd_data_read_memory", argc
, argv
, opts
,
778 switch ((enum opt
) opt
)
781 offset
= atol (optarg
);
788 if (argc
< 5 || argc
> 6)
790 xasprintf (&mi_error_message
,
791 "mi_cmd_data_read_memory: Usage: ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR].");
795 /* Extract all the arguments. */
797 /* Start address of the memory dump. */
798 addr
= parse_and_eval_address (argv
[0]) + offset
;
799 /* The format character to use when displaying a memory word. See
800 the ``x'' command. */
801 word_format
= argv
[1][0];
802 /* The size of the memory word. */
803 word_size
= atol (argv
[2]);
807 word_type
= builtin_type_int8
;
811 word_type
= builtin_type_int16
;
815 word_type
= builtin_type_int32
;
819 word_type
= builtin_type_int64
;
823 word_type
= builtin_type_int8
;
826 /* The number of rows */
827 nr_rows
= atol (argv
[3]);
830 xasprintf (&mi_error_message
,
831 "mi_cmd_data_read_memory: invalid number of rows.");
834 /* number of bytes per row. */
835 nr_cols
= atol (argv
[4]);
838 xasprintf (&mi_error_message
,
839 "mi_cmd_data_read_memory: invalid number of columns.");
841 /* The un-printable character when printing ascii. */
847 /* create a buffer and read it in. */
848 total_bytes
= word_size
* nr_rows
* nr_cols
;
849 mbuf
= xcalloc (total_bytes
, 1);
850 make_cleanup (xfree
, mbuf
);
853 xasprintf (&mi_error_message
,
854 "mi_cmd_data_read_memory: out of memory.");
858 while (nr_bytes
< total_bytes
)
861 long num
= target_read_memory_partial (addr
+ nr_bytes
, mbuf
+ nr_bytes
,
862 total_bytes
- nr_bytes
,
869 /* output the header information. */
870 ui_out_field_core_addr (uiout
, "addr", addr
);
871 ui_out_field_int (uiout
, "nr-bytes", nr_bytes
);
872 ui_out_field_int (uiout
, "total-bytes", total_bytes
);
873 ui_out_field_core_addr (uiout
, "next-row", addr
+ word_size
* nr_cols
);
874 ui_out_field_core_addr (uiout
, "prev-row", addr
- word_size
* nr_cols
);
875 ui_out_field_core_addr (uiout
, "next-page", addr
+ total_bytes
);
876 ui_out_field_core_addr (uiout
, "prev-page", addr
- total_bytes
);
878 /* Build the result as a two dimentional table. */
880 struct ui_stream
*stream
= ui_out_stream_new (uiout
);
883 ui_out_list_begin (uiout
, "memory");
884 for (row
= 0, row_byte
= 0;
886 row
++, row_byte
+= nr_cols
* word_size
)
890 ui_out_tuple_begin (uiout
, NULL
);
891 ui_out_field_core_addr (uiout
, "addr", addr
+ row_byte
);
892 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr + row_byte); */
893 ui_out_list_begin (uiout
, "data");
894 for (col
= 0, col_byte
= row_byte
;
896 col
++, col_byte
+= word_size
)
898 if (col_byte
+ word_size
> nr_bytes
)
900 ui_out_field_string (uiout
, NULL
, "N/A");
904 ui_file_rewind (stream
->stream
);
905 print_scalar_formatted (mbuf
+ col_byte
, word_type
, word_format
,
906 word_asize
, stream
->stream
);
907 ui_out_field_stream (uiout
, NULL
, stream
);
910 ui_out_list_end (uiout
);
914 ui_file_rewind (stream
->stream
);
915 for (byte
= row_byte
; byte
< row_byte
+ word_size
* nr_cols
; byte
++)
917 if (byte
>= nr_bytes
)
919 fputc_unfiltered ('X', stream
->stream
);
921 else if (mbuf
[byte
] < 32 || mbuf
[byte
] > 126)
923 fputc_unfiltered (aschar
, stream
->stream
);
926 fputc_unfiltered (mbuf
[byte
], stream
->stream
);
928 ui_out_field_stream (uiout
, "ascii", stream
);
930 ui_out_tuple_end (uiout
);
932 ui_out_stream_delete (stream
);
933 ui_out_list_end (uiout
);
935 do_cleanups (cleanups
);
939 /* DATA-MEMORY-WRITE:
941 COLUMN_OFFSET: optional argument. Must be preceeded by '-o'. The
942 offset from the beginning of the memory grid row where the cell to
944 ADDR: start address of the row in the memory grid where the memory
945 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
946 the location to write to.
947 FORMAT: a char indicating format for the ``word''. See
949 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
950 VALUE: value to be written into the memory address.
952 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
956 mi_cmd_data_write_memory (char *command
, char **argv
, int argc
)
961 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
962 enough when using a compiler other than GCC. */
965 struct cleanup
*old_chain
;
973 static struct mi_opt opts
[] =
975 {"o", OFFSET_OPT
, 1},
981 int opt
= mi_getopt ("mi_cmd_data_write_memory", argc
, argv
, opts
,
985 switch ((enum opt
) opt
)
988 offset
= atol (optarg
);
997 xasprintf (&mi_error_message
,
998 "mi_cmd_data_write_memory: Usage: [-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE.");
1002 /* Extract all the arguments. */
1003 /* Start address of the memory dump. */
1004 addr
= parse_and_eval_address (argv
[0]);
1005 /* The format character to use when displaying a memory word. See
1006 the ``x'' command. */
1007 word_format
= argv
[1][0];
1008 /* The size of the memory word. */
1009 word_size
= atol (argv
[2]);
1011 /* Calculate the real address of the write destination. */
1012 addr
+= (offset
* word_size
);
1014 /* Get the value as a number */
1015 value
= parse_and_eval_address (argv
[3]);
1016 /* Get the value into an array */
1017 buffer
= xmalloc (word_size
);
1018 old_chain
= make_cleanup (xfree
, buffer
);
1019 store_signed_integer (buffer
, word_size
, value
);
1020 /* Write it down to memory */
1021 write_memory (addr
, buffer
, word_size
);
1022 /* Free the buffer. */
1023 do_cleanups (old_chain
);
1028 /* Execute a command within a safe environment. Return >0 for
1029 ok. Return <0 for supress prompt. Return 0 to have the error
1030 extracted from error_last_message(). */
1033 captured_mi_execute_command (void *data
)
1035 struct mi_parse
*context
= data
;
1036 enum mi_cmd_result rc
;
1038 switch (context
->op
)
1042 /* A MI command was read from the input stream */
1044 /* FIXME: gdb_???? */
1045 fprintf_unfiltered (raw_stdout
, " token=`%s' command=`%s' args=`%s'\n",
1046 context
->token
, context
->command
, context
->args
);
1047 /* FIXME: cagney/1999-09-25: Rather than this convoluted
1048 condition expression, each function should return an
1049 indication of what action is required and then switch on
1051 rc
= mi_cmd_execute (context
);
1052 if (!target_can_async_p () || !target_executing
)
1054 /* print the result if there were no errors */
1055 if (rc
== MI_CMD_DONE
)
1057 fputs_unfiltered (context
->token
, raw_stdout
);
1058 fputs_unfiltered ("^done", raw_stdout
);
1059 mi_out_put (uiout
, raw_stdout
);
1060 mi_out_rewind (uiout
);
1061 fputs_unfiltered ("\n", raw_stdout
);
1063 else if (rc
== MI_CMD_ERROR
)
1065 if (mi_error_message
)
1067 fputs_unfiltered (context
->token
, raw_stdout
);
1068 fputs_unfiltered ("^error,msg=\"", raw_stdout
);
1069 fputstr_unfiltered (mi_error_message
, '"', raw_stdout
);
1070 xfree (mi_error_message
);
1071 fputs_unfiltered ("\"\n", raw_stdout
);
1073 mi_out_rewind (uiout
);
1075 else if (rc
== MI_CMD_CAUGHT_ERROR
)
1077 mi_out_rewind (uiout
);
1081 mi_out_rewind (uiout
);
1083 else if (sync_execution
)
1084 /* Don't print the prompt. We are executing the target in
1085 synchronous mode. */
1090 /* A CLI command was read from the input stream */
1091 /* This will be removed as soon as we have a complete set of
1093 /* echo the command on the console. */
1094 fprintf_unfiltered (gdb_stdlog
, "%s\n", context
->command
);
1095 /* FIXME: If the command string has something that looks like
1096 a format spec (e.g. %s) we will get a core dump */
1097 mi_execute_cli_command ("%s", context
->command
);
1098 /* print the result */
1099 /* FIXME: Check for errors here. */
1100 fputs_unfiltered (context
->token
, raw_stdout
);
1101 fputs_unfiltered ("^done", raw_stdout
);
1102 mi_out_put (uiout
, raw_stdout
);
1103 mi_out_rewind (uiout
);
1104 fputs_unfiltered ("\n", raw_stdout
);
1113 mi_execute_command (char *cmd
, int from_tty
)
1115 struct mi_parse
*command
;
1117 /* This is to handle EOF (^D). We just quit gdb. */
1118 /* FIXME: we should call some API function here. */
1120 quit_force (NULL
, from_tty
);
1122 command
= mi_parse (cmd
);
1124 if (command
!= NULL
)
1126 /* FIXME: cagney/1999-11-04: Can this use of catch_errors either
1127 be pushed even further down or even eliminated? */
1128 int rc
= catch_errors (captured_mi_execute_command
, command
, "",
1132 /* The command is executing synchronously. Bail out early
1133 suppressing the finished prompt. */
1134 mi_parse_free (command
);
1139 char *msg
= error_last_message ();
1140 struct cleanup
*cleanup
= make_cleanup (xfree
, msg
);
1141 /* The command execution failed and error() was called
1143 fputs_unfiltered (command
->token
, raw_stdout
);
1144 fputs_unfiltered ("^error,msg=\"", raw_stdout
);
1145 fputstr_unfiltered (msg
, '"', raw_stdout
);
1146 fputs_unfiltered ("\"\n", raw_stdout
);
1148 mi_parse_free (command
);
1151 fputs_unfiltered ("(gdb) \n", raw_stdout
);
1152 gdb_flush (raw_stdout
);
1153 /* print any buffered hook code */
1157 static enum mi_cmd_result
1158 mi_cmd_execute (struct mi_parse
*parse
)
1160 if (parse
->cmd
->argv_func
!= NULL
1161 || parse
->cmd
->args_func
!= NULL
)
1163 /* FIXME: We need to save the token because the command executed
1164 may be asynchronous and need to print the token again.
1165 In the future we can pass the token down to the func
1166 and get rid of the last_async_command */
1167 /* The problem here is to keep the token around when we launch
1168 the target, and we want to interrupt it later on. The
1169 interrupt command will have its own token, but when the
1170 target stops, we must display the token corresponding to the
1171 last execution command given. So we have another string where
1172 we copy the token (previous_async_command), if this was
1173 indeed the token of an execution command, and when we stop we
1174 print that one. This is possible because the interrupt
1175 command, when over, will copy that token back into the
1176 default token string (last_async_command). */
1178 if (target_executing
)
1180 if (!previous_async_command
)
1181 previous_async_command
= xstrdup (last_async_command
);
1182 if (strcmp (parse
->command
, "exec-interrupt"))
1184 fputs_unfiltered (parse
->token
, raw_stdout
);
1185 fputs_unfiltered ("^error,msg=\"", raw_stdout
);
1186 fputs_unfiltered ("Cannot execute command ", raw_stdout
);
1187 fputstr_unfiltered (parse
->command
, '"', raw_stdout
);
1188 fputs_unfiltered (" while target running", raw_stdout
);
1189 fputs_unfiltered ("\"\n", raw_stdout
);
1190 return MI_CMD_ERROR
;
1193 last_async_command
= xstrdup (parse
->token
);
1194 make_exec_cleanup (free_current_contents
, &last_async_command
);
1195 /* FIXME: DELETE THIS! */
1196 if (parse
->cmd
->args_func
!= NULL
)
1197 return parse
->cmd
->args_func (parse
->args
, 0 /*from_tty */ );
1198 return parse
->cmd
->argv_func (parse
->command
, parse
->argv
, parse
->argc
);
1200 else if (parse
->cmd
->cli
!= 0)
1202 /* FIXME: DELETE THIS. */
1203 /* The operation is still implemented by a cli command */
1204 /* Must be a synchronous one */
1205 mi_execute_cli_command (parse
->cmd
->cli
, parse
->args
);
1210 /* FIXME: DELETE THIS. */
1211 fputs_unfiltered (parse
->token
, raw_stdout
);
1212 fputs_unfiltered ("^error,msg=\"", raw_stdout
);
1213 fputs_unfiltered ("Undefined mi command: ", raw_stdout
);
1214 fputstr_unfiltered (parse
->command
, '"', raw_stdout
);
1215 fputs_unfiltered (" (missing implementation)", raw_stdout
);
1216 fputs_unfiltered ("\"\n", raw_stdout
);
1217 return MI_CMD_ERROR
;
1222 mi_execute_command_wrapper (char *cmd
)
1224 mi_execute_command (cmd
, stdin
== instream
);
1227 /* FIXME: This is just a hack so we can get some extra commands going.
1228 We don't want to channel things through the CLI, but call libgdb directly */
1229 /* Use only for synchronous commands */
1232 mi_execute_cli_command (const char *cli
, char *args
)
1236 struct cleanup
*old_cleanups
;
1238 xasprintf (&run
, cli
, args
);
1240 /* FIXME: gdb_???? */
1241 fprintf_unfiltered (gdb_stdout
, "cli=%s run=%s\n",
1243 old_cleanups
= make_cleanup (xfree
, run
);
1244 execute_command ( /*ui */ run
, 0 /*from_tty */ );
1245 do_cleanups (old_cleanups
);
1251 mi_execute_async_cli_command (char *mi
, char *args
, int from_tty
)
1253 struct cleanup
*old_cleanups
;
1257 if (target_can_async_p ())
1259 async_args
= (char *) xmalloc (strlen (args
) + 2);
1260 make_exec_cleanup (free
, async_args
);
1261 strcpy (async_args
, args
);
1262 strcat (async_args
, "&");
1263 xasprintf (&run
, "%s %s", mi
, async_args
);
1264 make_exec_cleanup (free
, run
);
1265 add_continuation (mi_exec_async_cli_cmd_continuation
, NULL
);
1266 old_cleanups
= NULL
;
1270 xasprintf (&run
, "%s %s", mi
, args
);
1271 old_cleanups
= make_cleanup (xfree
, run
);
1274 if (!target_can_async_p ())
1276 /* NOTE: For synchronous targets asynchronous behavour is faked by
1277 printing out the GDB prompt before we even try to execute the
1279 if (last_async_command
)
1280 fputs_unfiltered (last_async_command
, raw_stdout
);
1281 fputs_unfiltered ("^running\n", raw_stdout
);
1282 fputs_unfiltered ("(gdb) \n", raw_stdout
);
1283 gdb_flush (raw_stdout
);
1287 /* FIXME: cagney/1999-11-29: Printing this message before
1288 calling execute_command is wrong. It should only be printed
1289 once gdb has confirmed that it really has managed to send a
1290 run command to the target. */
1291 if (last_async_command
)
1292 fputs_unfiltered (last_async_command
, raw_stdout
);
1293 fputs_unfiltered ("^running\n", raw_stdout
);
1296 execute_command ( /*ui */ run
, 0 /*from_tty */ );
1298 if (!target_can_async_p ())
1300 /* Do this before doing any printing. It would appear that some
1301 print code leaves garbage around in the buffer. */
1302 do_cleanups (old_cleanups
);
1303 /* If the target was doing the operation synchronously we fake
1304 the stopped message. */
1305 if (last_async_command
)
1306 fputs_unfiltered (last_async_command
, raw_stdout
);
1307 fputs_unfiltered ("*stopped", raw_stdout
);
1308 mi_out_put (uiout
, raw_stdout
);
1309 mi_out_rewind (uiout
);
1310 fputs_unfiltered ("\n", raw_stdout
);
1311 return MI_CMD_QUIET
;
1317 mi_exec_async_cli_cmd_continuation (struct continuation_arg
*arg
)
1319 if (last_async_command
)
1320 fputs_unfiltered (last_async_command
, raw_stdout
);
1321 fputs_unfiltered ("*stopped", raw_stdout
);
1322 mi_out_put (uiout
, raw_stdout
);
1323 fputs_unfiltered ("\n", raw_stdout
);
1324 fputs_unfiltered ("(gdb) \n", raw_stdout
);
1325 gdb_flush (raw_stdout
);
1326 do_exec_cleanups (ALL_CLEANUPS
);
1330 mi_input (char *buf
)
1332 return gdb_readline (NULL
);
1336 mi_load_progress (const char *section_name
,
1337 unsigned long sent_so_far
,
1338 unsigned long total_section
,
1339 unsigned long total_sent
,
1340 unsigned long grand_total
)
1342 struct timeval time_now
, delta
, update_threshold
;
1343 static struct timeval last_update
;
1344 static char *previous_sect_name
= NULL
;
1347 if (!interpreter_p
|| strncmp (interpreter_p
, "mi", 2) != 0)
1350 update_threshold
.tv_sec
= 0;
1351 update_threshold
.tv_usec
= 500000;
1352 gettimeofday (&time_now
, NULL
);
1354 delta
.tv_usec
= time_now
.tv_usec
- last_update
.tv_usec
;
1355 delta
.tv_sec
= time_now
.tv_sec
- last_update
.tv_sec
;
1357 if (delta
.tv_usec
< 0)
1360 delta
.tv_usec
+= 1000000;
1363 new_section
= (previous_sect_name
?
1364 strcmp (previous_sect_name
, section_name
) : 1);
1367 xfree (previous_sect_name
);
1368 previous_sect_name
= xstrdup (section_name
);
1370 if (last_async_command
)
1371 fputs_unfiltered (last_async_command
, raw_stdout
);
1372 fputs_unfiltered ("+download", raw_stdout
);
1373 ui_out_tuple_begin (uiout
, NULL
);
1374 ui_out_field_string (uiout
, "section", section_name
);
1375 ui_out_field_int (uiout
, "section-size", total_section
);
1376 ui_out_field_int (uiout
, "total-size", grand_total
);
1377 ui_out_tuple_end (uiout
);
1378 mi_out_put (uiout
, raw_stdout
);
1379 fputs_unfiltered ("\n", raw_stdout
);
1380 gdb_flush (raw_stdout
);
1383 if (delta
.tv_sec
>= update_threshold
.tv_sec
&&
1384 delta
.tv_usec
>= update_threshold
.tv_usec
)
1386 last_update
.tv_sec
= time_now
.tv_sec
;
1387 last_update
.tv_usec
= time_now
.tv_usec
;
1388 if (last_async_command
)
1389 fputs_unfiltered (last_async_command
, raw_stdout
);
1390 fputs_unfiltered ("+download", raw_stdout
);
1391 ui_out_tuple_begin (uiout
, NULL
);
1392 ui_out_field_string (uiout
, "section", section_name
);
1393 ui_out_field_int (uiout
, "section-sent", sent_so_far
);
1394 ui_out_field_int (uiout
, "section-size", total_section
);
1395 ui_out_field_int (uiout
, "total-sent", total_sent
);
1396 ui_out_field_int (uiout
, "total-size", grand_total
);
1397 ui_out_tuple_end (uiout
);
1398 mi_out_put (uiout
, raw_stdout
);
1399 fputs_unfiltered ("\n", raw_stdout
);
1400 gdb_flush (raw_stdout
);
1405 mi_command_loop (int mi_version
)
1407 /* HACK: Force stdout/stderr to point at the console. This avoids
1408 any potential side effects caused by legacy code that is still
1409 using the TUI / fputs_unfiltered_hook */
1410 raw_stdout
= stdio_fileopen (stdout
);
1411 /* Route normal output through the MIx */
1412 gdb_stdout
= mi_console_file_new (raw_stdout
, "~");
1413 /* Route error and log output through the MI */
1414 gdb_stderr
= mi_console_file_new (raw_stdout
, "&");
1415 gdb_stdlog
= gdb_stderr
;
1416 /* Route target output through the MI. */
1417 gdb_stdtarg
= mi_console_file_new (raw_stdout
, "@");
1419 /* HACK: Poke the ui_out table directly. Should we be creating a
1420 mi_out object wired up to the above gdb_stdout / gdb_stderr? */
1421 uiout
= mi_out_new (mi_version
);
1423 /* HACK: Override any other interpreter hooks. We need to create a
1424 real event table and pass in that. */
1426 /* command_loop_hook = 0; */
1427 print_frame_info_listing_hook
= 0;
1430 create_breakpoint_hook
= 0;
1431 delete_breakpoint_hook
= 0;
1432 modify_breakpoint_hook
= 0;
1433 interactive_hook
= 0;
1434 registers_changed_hook
= 0;
1435 readline_begin_hook
= 0;
1437 readline_end_hook
= 0;
1438 register_changed_hook
= 0;
1439 memory_changed_hook
= 0;
1441 target_wait_hook
= 0;
1442 call_command_hook
= 0;
1444 error_begin_hook
= 0;
1445 show_load_progress
= mi_load_progress
;
1447 /* Turn off 8 bit strings in quoted output. Any character with the
1448 high bit set is printed using C's octal format. */
1449 sevenbit_strings
= 1;
1451 /* Tell the world that we're alive */
1452 fputs_unfiltered ("(gdb) \n", raw_stdout
);
1453 gdb_flush (raw_stdout
);
1456 simplified_command_loop (mi_input
, mi_execute_command
);
1458 start_event_loop ();
1462 mi0_command_loop (void)
1464 mi_command_loop (0);
1468 mi1_command_loop (void)
1470 mi_command_loop (1);
1474 setup_architecture_data (void)
1476 /* don't trust REGISTER_BYTES to be zero. */
1477 old_regs
= xmalloc (REGISTER_BYTES
+ 1);
1478 memset (old_regs
, 0, REGISTER_BYTES
+ 1);
1482 mi_init_ui (char *arg0
)
1484 /* Eventually this will contain code that takes control of the
1489 _initialize_mi_main (void)
1491 if (interpreter_p
== NULL
)
1494 /* If we're _the_ interpreter, take control. */
1495 if (strcmp (interpreter_p
, "mi0") == 0)
1496 command_loop_hook
= mi0_command_loop
;
1497 else if (strcmp (interpreter_p
, "mi") == 0
1498 || strcmp (interpreter_p
, "mi1") == 0)
1499 command_loop_hook
= mi1_command_loop
;
1503 init_ui_hook
= mi_init_ui
;
1504 setup_architecture_data ();
1505 register_gdbarch_swap (&old_regs
, sizeof (old_regs
), NULL
);
1506 register_gdbarch_swap (NULL
, 0, setup_architecture_data
);
1509 /* These overwrite some of the initialization done in
1510 _intialize_event_loop. */
1511 call_readline
= gdb_readline2
;
1512 input_handler
= mi_execute_command_wrapper
;
1513 add_file_handler (input_fd
, stdin_event_handler
, 0);
1514 async_command_editing_p
= 0;
1516 /* FIXME: Should we notify main that we are here as a possible