3 Copyright 2000, 2001, 2002, 2003, 2004, 2005 Free Software
6 Contributed by Cygnus Solutions (a Red Hat company).
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 59 Temple Place - Suite 330,
23 Boston, MA 02111-1307, USA. */
25 /* Work in progress */
30 #include "gdb_string.h"
31 #include "exceptions.h"
33 #include "gdbthread.h"
36 #include "mi-getopt.h"
37 #include "mi-console.h"
41 #include "event-loop.h"
42 #include "event-top.h"
43 #include "gdbcore.h" /* for write_memory() */
44 #include "value.h" /* for deprecated_write_register_bytes() */
58 /* Enumerations of the actions that may result from calling
59 captured_mi_execute_command */
61 enum captured_mi_execute_command_actions
63 EXECUTE_COMMAND_DISPLAY_PROMPT
,
64 EXECUTE_COMMAND_SUPRESS_PROMPT
67 /* This structure is used to pass information from captured_mi_execute_command
68 to mi_execute_command. */
69 struct captured_mi_execute_command_args
71 /* This return result of the MI command (output) */
72 enum mi_cmd_result rc
;
74 /* What action to perform when the call is finished (output) */
75 enum captured_mi_execute_command_actions action
;
77 /* The command context to be executed (input) */
78 struct mi_parse
*command
;
82 struct ui_file
*raw_stdout
;
84 /* The token of the last asynchronous command */
85 static char *last_async_command
;
86 static char *previous_async_command
;
87 char *mi_error_message
;
88 static char *old_regs
;
90 extern void _initialize_mi_main (void);
91 static enum mi_cmd_result
mi_cmd_execute (struct mi_parse
*parse
);
93 static void mi_execute_cli_command (const char *cmd
, int args_p
,
95 static enum mi_cmd_result
mi_execute_async_cli_command (char *mi
, char *args
, int from_tty
);
97 static void mi_exec_async_cli_cmd_continuation (struct continuation_arg
*arg
);
99 static int register_changed_p (int regnum
);
100 static int get_register (int regnum
, int format
);
102 /* Command implementations. FIXME: Is this libgdb? No. This is the MI
103 layer that calls libgdb. Any operation used in the below should be
107 mi_cmd_gdb_exit (char *command
, char **argv
, int argc
)
109 /* We have to print everything right here because we never return */
110 if (last_async_command
)
111 fputs_unfiltered (last_async_command
, raw_stdout
);
112 fputs_unfiltered ("^exit\n", raw_stdout
);
113 mi_out_put (uiout
, raw_stdout
);
114 /* FIXME: The function called is not yet a formal libgdb function */
115 quit_force (NULL
, FROM_TTY
);
120 mi_cmd_exec_run (char *args
, int from_tty
)
122 /* FIXME: Should call a libgdb function, not a cli wrapper */
123 return mi_execute_async_cli_command ("run", args
, from_tty
);
127 mi_cmd_exec_next (char *args
, int from_tty
)
129 /* FIXME: Should call a libgdb function, not a cli wrapper */
130 return mi_execute_async_cli_command ("next", args
, from_tty
);
134 mi_cmd_exec_next_instruction (char *args
, int from_tty
)
136 /* FIXME: Should call a libgdb function, not a cli wrapper */
137 return mi_execute_async_cli_command ("nexti", args
, from_tty
);
141 mi_cmd_exec_step (char *args
, int from_tty
)
143 /* FIXME: Should call a libgdb function, not a cli wrapper */
144 return mi_execute_async_cli_command ("step", args
, from_tty
);
148 mi_cmd_exec_step_instruction (char *args
, int from_tty
)
150 /* FIXME: Should call a libgdb function, not a cli wrapper */
151 return mi_execute_async_cli_command ("stepi", args
, from_tty
);
155 mi_cmd_exec_finish (char *args
, int from_tty
)
157 /* FIXME: Should call a libgdb function, not a cli wrapper */
158 return mi_execute_async_cli_command ("finish", args
, from_tty
);
162 mi_cmd_exec_until (char *args
, int from_tty
)
164 /* FIXME: Should call a libgdb function, not a cli wrapper */
165 return mi_execute_async_cli_command ("until", args
, from_tty
);
169 mi_cmd_exec_return (char *args
, int from_tty
)
171 /* This command doesn't really execute the target, it just pops the
172 specified number of frames. */
174 /* Call return_command with from_tty argument equal to 0 so as to
175 avoid being queried. */
176 return_command (args
, 0);
178 /* Call return_command with from_tty argument equal to 0 so as to
179 avoid being queried. */
180 return_command (NULL
, 0);
182 /* Because we have called return_command with from_tty = 0, we need
183 to print the frame here. */
184 print_stack_frame (get_selected_frame (NULL
), 1, LOC_AND_ADDRESS
);
190 mi_cmd_exec_continue (char *args
, int from_tty
)
192 /* FIXME: Should call a libgdb function, not a cli wrapper */
193 return mi_execute_async_cli_command ("continue", args
, from_tty
);
196 /* Interrupt the execution of the target. Note how we must play around
197 with the token varialbes, in order to display the current token in
198 the result of the interrupt command, and the previous execution
199 token when the target finally stops. See comments in
202 mi_cmd_exec_interrupt (char *args
, int from_tty
)
204 if (!target_executing
)
206 mi_error_message
= xstrprintf ("mi_cmd_exec_interrupt: Inferior not executing.");
209 interrupt_target_command (args
, from_tty
);
210 if (last_async_command
)
211 fputs_unfiltered (last_async_command
, raw_stdout
);
212 fputs_unfiltered ("^done", raw_stdout
);
213 xfree (last_async_command
);
214 if (previous_async_command
)
215 last_async_command
= xstrdup (previous_async_command
);
216 xfree (previous_async_command
);
217 previous_async_command
= NULL
;
218 mi_out_put (uiout
, raw_stdout
);
219 mi_out_rewind (uiout
);
220 fputs_unfiltered ("\n", raw_stdout
);
225 mi_cmd_thread_select (char *command
, char **argv
, int argc
)
231 mi_error_message
= xstrprintf ("mi_cmd_thread_select: USAGE: threadnum.");
235 rc
= gdb_thread_select (uiout
, argv
[0], &mi_error_message
);
237 /* RC is enum gdb_rc if it is successful (>=0)
238 enum return_reason if not (<0). */
239 if ((int) rc
< 0 && (enum return_reason
) rc
== RETURN_ERROR
)
241 else if ((int) rc
>= 0 && rc
== GDB_RC_FAIL
)
248 mi_cmd_thread_list_ids (char *command
, char **argv
, int argc
)
250 enum gdb_rc rc
= MI_CMD_DONE
;
254 mi_error_message
= xstrprintf ("mi_cmd_thread_list_ids: No arguments required.");
258 rc
= gdb_list_thread_ids (uiout
, &mi_error_message
);
260 if (rc
== GDB_RC_FAIL
)
267 mi_cmd_data_list_register_names (char *command
, char **argv
, int argc
)
271 struct cleanup
*cleanup
;
273 /* Note that the test for a valid register must include checking the
274 REGISTER_NAME because NUM_REGS may be allocated for the union of
275 the register sets within a family of related processors. In this
276 case, some entries of REGISTER_NAME will change depending upon
277 the particular processor being debugged. */
279 numregs
= NUM_REGS
+ NUM_PSEUDO_REGS
;
281 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "register-names");
283 if (argc
== 0) /* No args, just do all the regs */
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
));
297 /* Else, list of register #s, just do listed regs */
298 for (i
= 0; i
< argc
; i
++)
300 regnum
= atoi (argv
[i
]);
301 if (regnum
< 0 || regnum
>= numregs
)
303 do_cleanups (cleanup
);
304 mi_error_message
= xstrprintf ("bad register number");
307 if (REGISTER_NAME (regnum
) == NULL
308 || *(REGISTER_NAME (regnum
)) == '\0')
309 ui_out_field_string (uiout
, NULL
, "");
311 ui_out_field_string (uiout
, NULL
, REGISTER_NAME (regnum
));
313 do_cleanups (cleanup
);
318 mi_cmd_data_list_changed_registers (char *command
, char **argv
, int argc
)
320 int regnum
, numregs
, changed
;
322 struct cleanup
*cleanup
;
324 /* Note that the test for a valid register must include checking the
325 REGISTER_NAME because NUM_REGS may be allocated for the union of
326 the register sets within a family of related processors. In this
327 case, some entries of REGISTER_NAME will change depending upon
328 the particular processor being debugged. */
330 numregs
= NUM_REGS
+ NUM_PSEUDO_REGS
;
332 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "changed-registers");
334 if (argc
== 0) /* No args, just do all the regs */
340 if (REGISTER_NAME (regnum
) == NULL
341 || *(REGISTER_NAME (regnum
)) == '\0')
343 changed
= register_changed_p (regnum
);
346 do_cleanups (cleanup
);
347 mi_error_message
= xstrprintf ("mi_cmd_data_list_changed_registers: Unable to read register contents.");
351 ui_out_field_int (uiout
, NULL
, regnum
);
355 /* Else, list of register #s, just do listed regs */
356 for (i
= 0; i
< argc
; i
++)
358 regnum
= atoi (argv
[i
]);
362 && REGISTER_NAME (regnum
) != NULL
363 && *REGISTER_NAME (regnum
) != '\000')
365 changed
= register_changed_p (regnum
);
368 do_cleanups (cleanup
);
369 mi_error_message
= xstrprintf ("mi_cmd_data_list_register_change: Unable to read register contents.");
373 ui_out_field_int (uiout
, NULL
, regnum
);
377 do_cleanups (cleanup
);
378 mi_error_message
= xstrprintf ("bad register number");
382 do_cleanups (cleanup
);
387 register_changed_p (int regnum
)
389 char raw_buffer
[MAX_REGISTER_SIZE
];
391 if (! frame_register_read (deprecated_selected_frame
, regnum
, raw_buffer
))
394 if (memcmp (&old_regs
[DEPRECATED_REGISTER_BYTE (regnum
)], raw_buffer
,
395 register_size (current_gdbarch
, regnum
)) == 0)
398 /* Found a changed register. Return 1. */
400 memcpy (&old_regs
[DEPRECATED_REGISTER_BYTE (regnum
)], raw_buffer
,
401 register_size (current_gdbarch
, regnum
));
406 /* Return a list of register number and value pairs. The valid
407 arguments expected are: a letter indicating the format in which to
408 display the registers contents. This can be one of: x (hexadecimal), d
409 (decimal), N (natural), t (binary), o (octal), r (raw). After the
410 format argumetn there can be a sequence of numbers, indicating which
411 registers to fetch the content of. If the format is the only argument,
412 a list of all the registers with their values is returned. */
414 mi_cmd_data_list_register_values (char *command
, char **argv
, int argc
)
416 int regnum
, numregs
, format
, result
;
418 struct cleanup
*list_cleanup
, *tuple_cleanup
;
420 /* Note that the test for a valid register must include checking the
421 REGISTER_NAME because NUM_REGS may be allocated for the union of
422 the register sets within a family of related processors. In this
423 case, some entries of REGISTER_NAME will change depending upon
424 the particular processor being debugged. */
426 numregs
= NUM_REGS
+ NUM_PSEUDO_REGS
;
430 mi_error_message
= xstrprintf ("mi_cmd_data_list_register_values: Usage: -data-list-register-values <format> [<regnum1>...<regnumN>]");
434 format
= (int) argv
[0][0];
436 if (!target_has_registers
)
438 mi_error_message
= xstrprintf ("mi_cmd_data_list_register_values: No registers.");
442 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "register-values");
444 if (argc
== 1) /* No args, beside the format: do all the regs */
450 if (REGISTER_NAME (regnum
) == NULL
451 || *(REGISTER_NAME (regnum
)) == '\0')
453 tuple_cleanup
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
454 ui_out_field_int (uiout
, "number", regnum
);
455 result
= get_register (regnum
, format
);
458 do_cleanups (list_cleanup
);
461 do_cleanups (tuple_cleanup
);
465 /* Else, list of register #s, just do listed regs */
466 for (i
= 1; i
< argc
; i
++)
468 regnum
= atoi (argv
[i
]);
472 && REGISTER_NAME (regnum
) != NULL
473 && *REGISTER_NAME (regnum
) != '\000')
475 tuple_cleanup
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
476 ui_out_field_int (uiout
, "number", regnum
);
477 result
= get_register (regnum
, format
);
480 do_cleanups (list_cleanup
);
483 do_cleanups (tuple_cleanup
);
487 do_cleanups (list_cleanup
);
488 mi_error_message
= xstrprintf ("bad register number");
492 do_cleanups (list_cleanup
);
496 /* Output one register's contents in the desired format. */
498 get_register (int regnum
, int format
)
500 char buffer
[MAX_REGISTER_SIZE
];
505 static struct ui_stream
*stb
= NULL
;
507 stb
= ui_out_stream_new (uiout
);
512 frame_register (deprecated_selected_frame
, regnum
, &optim
, &lval
, &addr
,
517 mi_error_message
= xstrprintf ("Optimized out");
524 char *ptr
, buf
[1024];
528 for (j
= 0; j
< register_size (current_gdbarch
, regnum
); j
++)
530 int idx
= TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
? j
531 : register_size (current_gdbarch
, regnum
) - 1 - j
;
532 sprintf (ptr
, "%02x", (unsigned char) buffer
[idx
]);
535 ui_out_field_string (uiout
, "value", buf
);
536 /*fputs_filtered (buf, gdb_stdout); */
540 val_print (register_type (current_gdbarch
, regnum
), buffer
, 0, 0,
541 stb
->stream
, format
, 1, 0, Val_pretty_default
);
542 ui_out_field_stream (uiout
, "value", stb
);
543 ui_out_stream_delete (stb
);
548 /* Write given values into registers. The registers and values are
549 given as pairs. The corresponding MI command is
550 -data-write-register-values <format> [<regnum1> <value1>...<regnumN> <valueN>]*/
552 mi_cmd_data_write_register_values (char *command
, char **argv
, int argc
)
560 /* Note that the test for a valid register must include checking the
561 REGISTER_NAME because NUM_REGS may be allocated for the union of
562 the register sets within a family of related processors. In this
563 case, some entries of REGISTER_NAME will change depending upon
564 the particular processor being debugged. */
566 numregs
= NUM_REGS
+ NUM_PSEUDO_REGS
;
570 mi_error_message
= xstrprintf ("mi_cmd_data_write_register_values: Usage: -data-write-register-values <format> [<regnum1> <value1>...<regnumN> <valueN>]");
574 format
= (int) argv
[0][0];
576 if (!target_has_registers
)
578 mi_error_message
= xstrprintf ("mi_cmd_data_write_register_values: No registers.");
584 mi_error_message
= xstrprintf ("mi_cmd_data_write_register_values: No regs and values specified.");
590 mi_error_message
= xstrprintf ("mi_cmd_data_write_register_values: Regs and vals are not in pairs.");
594 for (i
= 1; i
< argc
; i
= i
+ 2)
596 regnum
= atoi (argv
[i
]);
600 && REGISTER_NAME (regnum
) != NULL
601 && *REGISTER_NAME (regnum
) != '\000')
604 struct cleanup
*old_chain
;
606 /* Get the value as a number */
607 value
= parse_and_eval_address (argv
[i
+ 1]);
608 /* Get the value into an array */
609 buffer
= xmalloc (DEPRECATED_REGISTER_SIZE
);
610 old_chain
= make_cleanup (xfree
, buffer
);
611 store_signed_integer (buffer
, DEPRECATED_REGISTER_SIZE
, value
);
613 deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (regnum
), buffer
, register_size (current_gdbarch
, regnum
));
614 /* Free the buffer. */
615 do_cleanups (old_chain
);
619 mi_error_message
= xstrprintf ("bad register number");
627 /*This is commented out because we decided it was not useful. I leave
628 it, just in case. ezannoni:1999-12-08 */
630 /* Assign a value to a variable. The expression argument must be in
631 the form A=2 or "A = 2" (I.e. if there are spaces it needs to be
634 mi_cmd_data_assign (char *command
, char **argv
, int argc
)
636 struct expression
*expr
;
637 struct cleanup
*old_chain
;
641 mi_error_message
= xstrprintf ("mi_cmd_data_assign: Usage: -data-assign expression");
645 /* NOTE what follows is a clone of set_command(). FIXME: ezannoni
646 01-12-1999: Need to decide what to do with this for libgdb purposes. */
648 expr
= parse_expression (argv
[0]);
649 old_chain
= make_cleanup (free_current_contents
, &expr
);
650 evaluate_expression (expr
);
651 do_cleanups (old_chain
);
656 /* Evaluate the value of the argument. The argument is an
657 expression. If the expression contains spaces it needs to be
658 included in double quotes. */
660 mi_cmd_data_evaluate_expression (char *command
, char **argv
, int argc
)
662 struct expression
*expr
;
663 struct cleanup
*old_chain
= NULL
;
665 struct ui_stream
*stb
= NULL
;
667 stb
= ui_out_stream_new (uiout
);
671 mi_error_message
= xstrprintf ("mi_cmd_data_evaluate_expression: Usage: -data-evaluate-expression expression");
675 expr
= parse_expression (argv
[0]);
677 old_chain
= make_cleanup (free_current_contents
, &expr
);
679 val
= evaluate_expression (expr
);
681 /* Print the result of the expression evaluation. */
682 val_print (value_type (val
), value_contents (val
),
683 value_embedded_offset (val
), VALUE_ADDRESS (val
),
684 stb
->stream
, 0, 0, 0, 0);
686 ui_out_field_stream (uiout
, "value", stb
);
687 ui_out_stream_delete (stb
);
689 do_cleanups (old_chain
);
695 mi_cmd_target_download (char *args
, int from_tty
)
698 struct cleanup
*old_cleanups
= NULL
;
700 run
= xstrprintf ("load %s", args
);
701 old_cleanups
= make_cleanup (xfree
, run
);
702 execute_command (run
, from_tty
);
704 do_cleanups (old_cleanups
);
708 /* Connect to the remote target. */
710 mi_cmd_target_select (char *args
, int from_tty
)
713 struct cleanup
*old_cleanups
= NULL
;
715 run
= xstrprintf ("target %s", args
);
716 old_cleanups
= make_cleanup (xfree
, run
);
718 /* target-select is always synchronous. once the call has returned
719 we know that we are connected. */
720 /* NOTE: At present all targets that are connected are also
721 (implicitly) talking to a halted target. In the future this may
723 execute_command (run
, from_tty
);
725 do_cleanups (old_cleanups
);
727 /* Issue the completion message here. */
728 if (last_async_command
)
729 fputs_unfiltered (last_async_command
, raw_stdout
);
730 fputs_unfiltered ("^connected", raw_stdout
);
731 mi_out_put (uiout
, raw_stdout
);
732 mi_out_rewind (uiout
);
733 fputs_unfiltered ("\n", raw_stdout
);
734 do_exec_cleanups (ALL_CLEANUPS
);
740 ADDR: start address of data to be dumped.
741 WORD-FORMAT: a char indicating format for the ``word''. See
743 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes
744 NR_ROW: Number of rows.
745 NR_COL: The number of colums (words per row).
746 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
747 ASCHAR for unprintable characters.
749 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
750 displayes them. Returns:
752 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
755 The number of bytes read is SIZE*ROW*COL. */
758 mi_cmd_data_read_memory (char *command
, char **argv
, int argc
)
760 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
766 struct type
*word_type
;
779 static struct mi_opt opts
[] =
781 {"o", OFFSET_OPT
, 1},
787 int opt
= mi_getopt ("mi_cmd_data_read_memory", argc
, argv
, opts
,
791 switch ((enum opt
) opt
)
794 offset
= atol (optarg
);
801 if (argc
< 5 || argc
> 6)
803 mi_error_message
= xstrprintf ("mi_cmd_data_read_memory: Usage: ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR].");
807 /* Extract all the arguments. */
809 /* Start address of the memory dump. */
810 addr
= parse_and_eval_address (argv
[0]) + offset
;
811 /* The format character to use when displaying a memory word. See
812 the ``x'' command. */
813 word_format
= argv
[1][0];
814 /* The size of the memory word. */
815 word_size
= atol (argv
[2]);
819 word_type
= builtin_type_int8
;
823 word_type
= builtin_type_int16
;
827 word_type
= builtin_type_int32
;
831 word_type
= builtin_type_int64
;
835 word_type
= builtin_type_int8
;
838 /* The number of rows */
839 nr_rows
= atol (argv
[3]);
842 mi_error_message
= xstrprintf ("mi_cmd_data_read_memory: invalid number of rows.");
845 /* number of bytes per row. */
846 nr_cols
= atol (argv
[4]);
849 mi_error_message
= xstrprintf ("mi_cmd_data_read_memory: invalid number of columns.");
852 /* The un-printable character when printing ascii. */
858 /* create a buffer and read it in. */
859 total_bytes
= word_size
* nr_rows
* nr_cols
;
860 mbuf
= xcalloc (total_bytes
, 1);
861 make_cleanup (xfree
, mbuf
);
863 while (nr_bytes
< total_bytes
)
866 long num
= target_read_memory_partial (addr
+ nr_bytes
, mbuf
+ nr_bytes
,
867 total_bytes
- nr_bytes
,
874 /* output the header information. */
875 ui_out_field_core_addr (uiout
, "addr", addr
);
876 ui_out_field_int (uiout
, "nr-bytes", nr_bytes
);
877 ui_out_field_int (uiout
, "total-bytes", total_bytes
);
878 ui_out_field_core_addr (uiout
, "next-row", addr
+ word_size
* nr_cols
);
879 ui_out_field_core_addr (uiout
, "prev-row", addr
- word_size
* nr_cols
);
880 ui_out_field_core_addr (uiout
, "next-page", addr
+ total_bytes
);
881 ui_out_field_core_addr (uiout
, "prev-page", addr
- total_bytes
);
883 /* Build the result as a two dimentional table. */
885 struct ui_stream
*stream
= ui_out_stream_new (uiout
);
886 struct cleanup
*cleanup_list_memory
;
889 cleanup_list_memory
= make_cleanup_ui_out_list_begin_end (uiout
, "memory");
890 for (row
= 0, row_byte
= 0;
892 row
++, row_byte
+= nr_cols
* word_size
)
896 struct cleanup
*cleanup_tuple
;
897 struct cleanup
*cleanup_list_data
;
898 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
899 ui_out_field_core_addr (uiout
, "addr", addr
+ row_byte
);
900 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr + row_byte); */
901 cleanup_list_data
= make_cleanup_ui_out_list_begin_end (uiout
, "data");
902 for (col
= 0, col_byte
= row_byte
;
904 col
++, col_byte
+= word_size
)
906 if (col_byte
+ word_size
> nr_bytes
)
908 ui_out_field_string (uiout
, NULL
, "N/A");
912 ui_file_rewind (stream
->stream
);
913 print_scalar_formatted (mbuf
+ col_byte
, word_type
, word_format
,
914 word_asize
, stream
->stream
);
915 ui_out_field_stream (uiout
, NULL
, stream
);
918 do_cleanups (cleanup_list_data
);
922 ui_file_rewind (stream
->stream
);
923 for (byte
= row_byte
; byte
< row_byte
+ word_size
* nr_cols
; byte
++)
925 if (byte
>= nr_bytes
)
927 fputc_unfiltered ('X', stream
->stream
);
929 else if (mbuf
[byte
] < 32 || mbuf
[byte
] > 126)
931 fputc_unfiltered (aschar
, stream
->stream
);
934 fputc_unfiltered (mbuf
[byte
], stream
->stream
);
936 ui_out_field_stream (uiout
, "ascii", stream
);
938 do_cleanups (cleanup_tuple
);
940 ui_out_stream_delete (stream
);
941 do_cleanups (cleanup_list_memory
);
943 do_cleanups (cleanups
);
947 /* DATA-MEMORY-WRITE:
949 COLUMN_OFFSET: optional argument. Must be preceeded by '-o'. The
950 offset from the beginning of the memory grid row where the cell to
952 ADDR: start address of the row in the memory grid where the memory
953 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
954 the location to write to.
955 FORMAT: a char indicating format for the ``word''. See
957 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
958 VALUE: value to be written into the memory address.
960 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
964 mi_cmd_data_write_memory (char *command
, char **argv
, int argc
)
969 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
970 enough when using a compiler other than GCC. */
973 struct cleanup
*old_chain
;
981 static struct mi_opt opts
[] =
983 {"o", OFFSET_OPT
, 1},
989 int opt
= mi_getopt ("mi_cmd_data_write_memory", argc
, argv
, opts
,
993 switch ((enum opt
) opt
)
996 offset
= atol (optarg
);
1005 mi_error_message
= xstrprintf ("mi_cmd_data_write_memory: Usage: [-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE.");
1006 return MI_CMD_ERROR
;
1009 /* Extract all the arguments. */
1010 /* Start address of the memory dump. */
1011 addr
= parse_and_eval_address (argv
[0]);
1012 /* The format character to use when displaying a memory word. See
1013 the ``x'' command. */
1014 word_format
= argv
[1][0];
1015 /* The size of the memory word. */
1016 word_size
= atol (argv
[2]);
1018 /* Calculate the real address of the write destination. */
1019 addr
+= (offset
* word_size
);
1021 /* Get the value as a number */
1022 value
= parse_and_eval_address (argv
[3]);
1023 /* Get the value into an array */
1024 buffer
= xmalloc (word_size
);
1025 old_chain
= make_cleanup (xfree
, buffer
);
1026 store_signed_integer (buffer
, word_size
, value
);
1027 /* Write it down to memory */
1028 write_memory (addr
, buffer
, word_size
);
1029 /* Free the buffer. */
1030 do_cleanups (old_chain
);
1035 /* Execute a command within a safe environment.
1036 Return <0 for error; >=0 for ok.
1038 args->action will tell mi_execute_command what action
1039 to perfrom after the given command has executed (display/supress
1040 prompt, display error). */
1043 captured_mi_execute_command (struct ui_out
*uiout
, void *data
)
1045 struct captured_mi_execute_command_args
*args
=
1046 (struct captured_mi_execute_command_args
*) data
;
1047 struct mi_parse
*context
= args
->command
;
1049 switch (context
->op
)
1053 /* A MI command was read from the input stream */
1055 /* FIXME: gdb_???? */
1056 fprintf_unfiltered (raw_stdout
, " token=`%s' command=`%s' args=`%s'\n",
1057 context
->token
, context
->command
, context
->args
);
1058 /* FIXME: cagney/1999-09-25: Rather than this convoluted
1059 condition expression, each function should return an
1060 indication of what action is required and then switch on
1062 args
->action
= EXECUTE_COMMAND_DISPLAY_PROMPT
;
1063 args
->rc
= mi_cmd_execute (context
);
1065 if (!target_can_async_p () || !target_executing
)
1067 /* print the result if there were no errors
1069 Remember that on the way out of executing a command, you have
1070 to directly use the mi_interp's uiout, since the command could
1071 have reset the interpreter, in which case the current uiout
1072 will most likely crash in the mi_out_* routines. */
1073 if (args
->rc
== MI_CMD_DONE
)
1075 fputs_unfiltered (context
->token
, raw_stdout
);
1076 fputs_unfiltered ("^done", raw_stdout
);
1077 mi_out_put (uiout
, raw_stdout
);
1078 mi_out_rewind (uiout
);
1079 fputs_unfiltered ("\n", raw_stdout
);
1081 else if (args
->rc
== MI_CMD_ERROR
)
1083 if (mi_error_message
)
1085 fputs_unfiltered (context
->token
, raw_stdout
);
1086 fputs_unfiltered ("^error,msg=\"", raw_stdout
);
1087 fputstr_unfiltered (mi_error_message
, '"', raw_stdout
);
1088 xfree (mi_error_message
);
1089 fputs_unfiltered ("\"\n", raw_stdout
);
1091 mi_out_rewind (uiout
);
1094 mi_out_rewind (uiout
);
1096 else if (sync_execution
)
1098 /* Don't print the prompt. We are executing the target in
1099 synchronous mode. */
1100 args
->action
= EXECUTE_COMMAND_SUPRESS_PROMPT
;
1108 /* A CLI command was read from the input stream. */
1109 /* This "feature" will be removed as soon as we have a
1110 complete set of mi commands. */
1111 /* Echo the command on the console. */
1112 fprintf_unfiltered (gdb_stdlog
, "%s\n", context
->command
);
1113 /* Call the "console" interpreter. */
1114 argv
[0] = "console";
1115 argv
[1] = context
->command
;
1116 mi_cmd_interpreter_exec ("-interpreter-exec", argv
, 2);
1118 /* If we changed interpreters, DON'T print out anything. */
1119 if (current_interp_named_p (INTERP_MI
)
1120 || current_interp_named_p (INTERP_MI1
)
1121 || current_interp_named_p (INTERP_MI2
)
1122 || current_interp_named_p (INTERP_MI3
))
1124 /* print the result */
1125 /* FIXME: Check for errors here. */
1126 fputs_unfiltered (context
->token
, raw_stdout
);
1127 fputs_unfiltered ("^done", raw_stdout
);
1128 mi_out_put (uiout
, raw_stdout
);
1129 mi_out_rewind (uiout
);
1130 fputs_unfiltered ("\n", raw_stdout
);
1131 args
->action
= EXECUTE_COMMAND_DISPLAY_PROMPT
;
1132 args
->rc
= MI_CMD_DONE
;
1144 mi_execute_command (char *cmd
, int from_tty
)
1146 struct mi_parse
*command
;
1147 struct captured_mi_execute_command_args args
;
1148 struct ui_out
*saved_uiout
= uiout
;
1150 /* This is to handle EOF (^D). We just quit gdb. */
1151 /* FIXME: we should call some API function here. */
1153 quit_force (NULL
, from_tty
);
1155 command
= mi_parse (cmd
);
1157 if (command
!= NULL
)
1159 struct exception result
;
1160 /* FIXME: cagney/1999-11-04: Can this use of catch_exceptions either
1161 be pushed even further down or even eliminated? */
1162 args
.command
= command
;
1163 result
= catch_exception (uiout
, captured_mi_execute_command
, &args
,
1165 exception_print (gdb_stderr
, result
);
1167 if (args
.action
== EXECUTE_COMMAND_SUPRESS_PROMPT
)
1169 /* The command is executing synchronously. Bail out early
1170 suppressing the finished prompt. */
1171 mi_parse_free (command
);
1174 if (result
.reason
< 0)
1176 /* The command execution failed and error() was called
1178 fputs_unfiltered (command
->token
, raw_stdout
);
1179 fputs_unfiltered ("^error,msg=\"", raw_stdout
);
1180 fputstr_unfiltered (result
.message
, '"', raw_stdout
);
1181 fputs_unfiltered ("\"\n", raw_stdout
);
1183 mi_parse_free (command
);
1186 fputs_unfiltered ("(gdb) \n", raw_stdout
);
1187 gdb_flush (raw_stdout
);
1188 /* print any buffered hook code */
1192 static enum mi_cmd_result
1193 mi_cmd_execute (struct mi_parse
*parse
)
1195 if (parse
->cmd
->argv_func
!= NULL
1196 || parse
->cmd
->args_func
!= NULL
)
1198 /* FIXME: We need to save the token because the command executed
1199 may be asynchronous and need to print the token again.
1200 In the future we can pass the token down to the func
1201 and get rid of the last_async_command */
1202 /* The problem here is to keep the token around when we launch
1203 the target, and we want to interrupt it later on. The
1204 interrupt command will have its own token, but when the
1205 target stops, we must display the token corresponding to the
1206 last execution command given. So we have another string where
1207 we copy the token (previous_async_command), if this was
1208 indeed the token of an execution command, and when we stop we
1209 print that one. This is possible because the interrupt
1210 command, when over, will copy that token back into the
1211 default token string (last_async_command). */
1213 if (target_executing
)
1215 if (!previous_async_command
)
1216 previous_async_command
= xstrdup (last_async_command
);
1217 if (strcmp (parse
->command
, "exec-interrupt"))
1219 fputs_unfiltered (parse
->token
, raw_stdout
);
1220 fputs_unfiltered ("^error,msg=\"", raw_stdout
);
1221 fputs_unfiltered ("Cannot execute command ", raw_stdout
);
1222 fputstr_unfiltered (parse
->command
, '"', raw_stdout
);
1223 fputs_unfiltered (" while target running", raw_stdout
);
1224 fputs_unfiltered ("\"\n", raw_stdout
);
1225 return MI_CMD_ERROR
;
1228 last_async_command
= xstrdup (parse
->token
);
1229 make_exec_cleanup (free_current_contents
, &last_async_command
);
1230 /* FIXME: DELETE THIS! */
1231 if (parse
->cmd
->args_func
!= NULL
)
1232 return parse
->cmd
->args_func (parse
->args
, 0 /*from_tty */ );
1233 return parse
->cmd
->argv_func (parse
->command
, parse
->argv
, parse
->argc
);
1235 else if (parse
->cmd
->cli
.cmd
!= 0)
1237 /* FIXME: DELETE THIS. */
1238 /* The operation is still implemented by a cli command */
1239 /* Must be a synchronous one */
1240 mi_execute_cli_command (parse
->cmd
->cli
.cmd
, parse
->cmd
->cli
.args_p
,
1246 /* FIXME: DELETE THIS. */
1247 fputs_unfiltered (parse
->token
, raw_stdout
);
1248 fputs_unfiltered ("^error,msg=\"", raw_stdout
);
1249 fputs_unfiltered ("Undefined mi command: ", raw_stdout
);
1250 fputstr_unfiltered (parse
->command
, '"', raw_stdout
);
1251 fputs_unfiltered (" (missing implementation)", raw_stdout
);
1252 fputs_unfiltered ("\"\n", raw_stdout
);
1253 return MI_CMD_ERROR
;
1257 /* FIXME: This is just a hack so we can get some extra commands going.
1258 We don't want to channel things through the CLI, but call libgdb directly */
1259 /* Use only for synchronous commands */
1262 mi_execute_cli_command (const char *cmd
, int args_p
, const char *args
)
1266 struct cleanup
*old_cleanups
;
1269 run
= xstrprintf ("%s %s", cmd
, args
);
1271 run
= xstrdup (cmd
);
1273 /* FIXME: gdb_???? */
1274 fprintf_unfiltered (gdb_stdout
, "cli=%s run=%s\n",
1276 old_cleanups
= make_cleanup (xfree
, run
);
1277 execute_command ( /*ui */ run
, 0 /*from_tty */ );
1278 do_cleanups (old_cleanups
);
1284 mi_execute_async_cli_command (char *mi
, char *args
, int from_tty
)
1286 struct cleanup
*old_cleanups
;
1290 if (target_can_async_p ())
1292 async_args
= (char *) xmalloc (strlen (args
) + 2);
1293 make_exec_cleanup (free
, async_args
);
1294 strcpy (async_args
, args
);
1295 strcat (async_args
, "&");
1296 run
= xstrprintf ("%s %s", mi
, async_args
);
1297 make_exec_cleanup (free
, run
);
1298 add_continuation (mi_exec_async_cli_cmd_continuation
, NULL
);
1299 old_cleanups
= NULL
;
1303 run
= xstrprintf ("%s %s", mi
, args
);
1304 old_cleanups
= make_cleanup (xfree
, run
);
1307 if (!target_can_async_p ())
1309 /* NOTE: For synchronous targets asynchronous behavour is faked by
1310 printing out the GDB prompt before we even try to execute the
1312 if (last_async_command
)
1313 fputs_unfiltered (last_async_command
, raw_stdout
);
1314 fputs_unfiltered ("^running\n", raw_stdout
);
1315 fputs_unfiltered ("(gdb) \n", raw_stdout
);
1316 gdb_flush (raw_stdout
);
1320 /* FIXME: cagney/1999-11-29: Printing this message before
1321 calling execute_command is wrong. It should only be printed
1322 once gdb has confirmed that it really has managed to send a
1323 run command to the target. */
1324 if (last_async_command
)
1325 fputs_unfiltered (last_async_command
, raw_stdout
);
1326 fputs_unfiltered ("^running\n", raw_stdout
);
1329 execute_command ( /*ui */ run
, 0 /*from_tty */ );
1331 if (!target_can_async_p ())
1333 /* Do this before doing any printing. It would appear that some
1334 print code leaves garbage around in the buffer. */
1335 do_cleanups (old_cleanups
);
1336 /* If the target was doing the operation synchronously we fake
1337 the stopped message. */
1338 if (last_async_command
)
1339 fputs_unfiltered (last_async_command
, raw_stdout
);
1340 fputs_unfiltered ("*stopped", raw_stdout
);
1341 mi_out_put (uiout
, raw_stdout
);
1342 mi_out_rewind (uiout
);
1343 fputs_unfiltered ("\n", raw_stdout
);
1344 return MI_CMD_QUIET
;
1350 mi_exec_async_cli_cmd_continuation (struct continuation_arg
*arg
)
1352 if (last_async_command
)
1353 fputs_unfiltered (last_async_command
, raw_stdout
);
1354 fputs_unfiltered ("*stopped", raw_stdout
);
1355 mi_out_put (uiout
, raw_stdout
);
1356 fputs_unfiltered ("\n", raw_stdout
);
1357 fputs_unfiltered ("(gdb) \n", raw_stdout
);
1358 gdb_flush (raw_stdout
);
1359 do_exec_cleanups (ALL_CLEANUPS
);
1363 mi_load_progress (const char *section_name
,
1364 unsigned long sent_so_far
,
1365 unsigned long total_section
,
1366 unsigned long total_sent
,
1367 unsigned long grand_total
)
1369 struct timeval time_now
, delta
, update_threshold
;
1370 static struct timeval last_update
;
1371 static char *previous_sect_name
= NULL
;
1374 if (!current_interp_named_p (INTERP_MI
)
1375 && !current_interp_named_p (INTERP_MI1
))
1378 update_threshold
.tv_sec
= 0;
1379 update_threshold
.tv_usec
= 500000;
1380 gettimeofday (&time_now
, NULL
);
1382 delta
.tv_usec
= time_now
.tv_usec
- last_update
.tv_usec
;
1383 delta
.tv_sec
= time_now
.tv_sec
- last_update
.tv_sec
;
1385 if (delta
.tv_usec
< 0)
1388 delta
.tv_usec
+= 1000000;
1391 new_section
= (previous_sect_name
?
1392 strcmp (previous_sect_name
, section_name
) : 1);
1395 struct cleanup
*cleanup_tuple
;
1396 xfree (previous_sect_name
);
1397 previous_sect_name
= xstrdup (section_name
);
1399 if (last_async_command
)
1400 fputs_unfiltered (last_async_command
, raw_stdout
);
1401 fputs_unfiltered ("+download", raw_stdout
);
1402 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1403 ui_out_field_string (uiout
, "section", section_name
);
1404 ui_out_field_int (uiout
, "section-size", total_section
);
1405 ui_out_field_int (uiout
, "total-size", grand_total
);
1406 do_cleanups (cleanup_tuple
);
1407 mi_out_put (uiout
, raw_stdout
);
1408 fputs_unfiltered ("\n", raw_stdout
);
1409 gdb_flush (raw_stdout
);
1412 if (delta
.tv_sec
>= update_threshold
.tv_sec
&&
1413 delta
.tv_usec
>= update_threshold
.tv_usec
)
1415 struct cleanup
*cleanup_tuple
;
1416 last_update
.tv_sec
= time_now
.tv_sec
;
1417 last_update
.tv_usec
= time_now
.tv_usec
;
1418 if (last_async_command
)
1419 fputs_unfiltered (last_async_command
, raw_stdout
);
1420 fputs_unfiltered ("+download", raw_stdout
);
1421 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1422 ui_out_field_string (uiout
, "section", section_name
);
1423 ui_out_field_int (uiout
, "section-sent", sent_so_far
);
1424 ui_out_field_int (uiout
, "section-size", total_section
);
1425 ui_out_field_int (uiout
, "total-sent", total_sent
);
1426 ui_out_field_int (uiout
, "total-size", grand_total
);
1427 do_cleanups (cleanup_tuple
);
1428 mi_out_put (uiout
, raw_stdout
);
1429 fputs_unfiltered ("\n", raw_stdout
);
1430 gdb_flush (raw_stdout
);
1435 mi_setup_architecture_data (void)
1437 old_regs
= xmalloc ((NUM_REGS
+ NUM_PSEUDO_REGS
) * MAX_REGISTER_SIZE
+ 1);
1438 memset (old_regs
, 0, (NUM_REGS
+ NUM_PSEUDO_REGS
) * MAX_REGISTER_SIZE
+ 1);
1442 _initialize_mi_main (void)
1444 DEPRECATED_REGISTER_GDBARCH_SWAP (old_regs
);
1445 deprecated_register_gdbarch_swap (NULL
, 0, mi_setup_architecture_data
);