3 Copyright 2000, 2001, 2002, 2003, 2004 Free Software Foundation,
6 Contributed by Cygnus Solutions (a Red Hat company).
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 59 Temple Place - Suite 330,
23 Boston, MA 02111-1307, USA. */
25 /* Work in progress */
30 #include "gdb_string.h"
32 #include "gdbthread.h"
35 #include "mi-getopt.h"
36 #include "mi-console.h"
40 #include "event-loop.h"
41 #include "event-top.h"
42 #include "gdbcore.h" /* for write_memory() */
43 #include "value.h" /* for deprecated_write_register_bytes() */
57 /* Enumerations of the actions that may result from calling
58 captured_mi_execute_command */
60 enum captured_mi_execute_command_actions
62 EXECUTE_COMMAND_DISPLAY_PROMPT
,
63 EXECUTE_COMMAND_SUPRESS_PROMPT
,
64 EXECUTE_COMMAND_DISPLAY_ERROR
67 /* This structure is used to pass information from captured_mi_execute_command
68 to mi_execute_command. */
69 struct captured_mi_execute_command_args
71 /* This return result of the MI command (output) */
72 enum mi_cmd_result rc
;
74 /* What action to perform when the call is finished (output) */
75 enum captured_mi_execute_command_actions action
;
77 /* The command context to be executed (input) */
78 struct mi_parse
*command
;
82 struct ui_file
*raw_stdout
;
84 /* The token of the last asynchronous command */
85 static char *last_async_command
;
86 static char *previous_async_command
;
87 char *mi_error_message
;
88 static char *old_regs
;
90 extern void _initialize_mi_main (void);
91 static enum mi_cmd_result
mi_cmd_execute (struct mi_parse
*parse
);
93 static void mi_execute_cli_command (const char *cmd
, int args_p
,
95 static enum mi_cmd_result
mi_execute_async_cli_command (char *mi
, char *args
, int from_tty
);
97 static void mi_exec_async_cli_cmd_continuation (struct continuation_arg
*arg
);
99 static int register_changed_p (int regnum
);
100 static int get_register (int regnum
, int format
);
102 /* A helper function which will set mi_error_message to
103 error_last_message. */
105 mi_error_last_message (void)
107 char *s
= error_last_message ();
108 xasprintf (&mi_error_message
, "%s", s
);
112 /* Command implementations. FIXME: Is this libgdb? No. This is the MI
113 layer that calls libgdb. Any operation used in the below should be
117 mi_cmd_gdb_exit (char *command
, char **argv
, int argc
)
119 /* We have to print everything right here because we never return */
120 if (last_async_command
)
121 fputs_unfiltered (last_async_command
, raw_stdout
);
122 fputs_unfiltered ("^exit\n", raw_stdout
);
123 mi_out_put (uiout
, raw_stdout
);
124 /* FIXME: The function called is not yet a formal libgdb function */
125 quit_force (NULL
, FROM_TTY
);
130 mi_cmd_exec_run (char *args
, int from_tty
)
132 /* FIXME: Should call a libgdb function, not a cli wrapper */
133 return mi_execute_async_cli_command ("run", args
, from_tty
);
137 mi_cmd_exec_next (char *args
, int from_tty
)
139 /* FIXME: Should call a libgdb function, not a cli wrapper */
140 return mi_execute_async_cli_command ("next", args
, from_tty
);
144 mi_cmd_exec_next_instruction (char *args
, int from_tty
)
146 /* FIXME: Should call a libgdb function, not a cli wrapper */
147 return mi_execute_async_cli_command ("nexti", args
, from_tty
);
151 mi_cmd_exec_step (char *args
, int from_tty
)
153 /* FIXME: Should call a libgdb function, not a cli wrapper */
154 return mi_execute_async_cli_command ("step", args
, from_tty
);
158 mi_cmd_exec_step_instruction (char *args
, int from_tty
)
160 /* FIXME: Should call a libgdb function, not a cli wrapper */
161 return mi_execute_async_cli_command ("stepi", args
, from_tty
);
165 mi_cmd_exec_finish (char *args
, int from_tty
)
167 /* FIXME: Should call a libgdb function, not a cli wrapper */
168 return mi_execute_async_cli_command ("finish", args
, from_tty
);
172 mi_cmd_exec_until (char *args
, int from_tty
)
174 /* FIXME: Should call a libgdb function, not a cli wrapper */
175 return mi_execute_async_cli_command ("until", args
, from_tty
);
179 mi_cmd_exec_return (char *args
, int from_tty
)
181 /* This command doesn't really execute the target, it just pops the
182 specified number of frames. */
184 /* Call return_command with from_tty argument equal to 0 so as to
185 avoid being queried. */
186 return_command (args
, 0);
188 /* Call return_command with from_tty argument equal to 0 so as to
189 avoid being queried. */
190 return_command (NULL
, 0);
192 /* Because we have called return_command with from_tty = 0, we need
193 to print the frame here. */
194 print_stack_frame (get_selected_frame (), 1, LOC_AND_ADDRESS
);
200 mi_cmd_exec_continue (char *args
, int from_tty
)
202 /* FIXME: Should call a libgdb function, not a cli wrapper */
203 return mi_execute_async_cli_command ("continue", args
, from_tty
);
206 /* Interrupt the execution of the target. Note how we must play around
207 with the token varialbes, in order to display the current token in
208 the result of the interrupt command, and the previous execution
209 token when the target finally stops. See comments in
212 mi_cmd_exec_interrupt (char *args
, int from_tty
)
214 if (!target_executing
)
216 xasprintf (&mi_error_message
,
217 "mi_cmd_exec_interrupt: Inferior not executing.");
220 interrupt_target_command (args
, from_tty
);
221 if (last_async_command
)
222 fputs_unfiltered (last_async_command
, raw_stdout
);
223 fputs_unfiltered ("^done", raw_stdout
);
224 xfree (last_async_command
);
225 if (previous_async_command
)
226 last_async_command
= xstrdup (previous_async_command
);
227 xfree (previous_async_command
);
228 previous_async_command
= NULL
;
229 mi_out_put (uiout
, raw_stdout
);
230 mi_out_rewind (uiout
);
231 fputs_unfiltered ("\n", raw_stdout
);
236 mi_cmd_thread_select (char *command
, char **argv
, int argc
)
242 xasprintf (&mi_error_message
,
243 "mi_cmd_thread_select: USAGE: threadnum.");
247 rc
= gdb_thread_select (uiout
, argv
[0]);
249 /* RC is enum gdb_rc if it is successful (>=0)
250 enum return_reason if not (<0). */
251 if ((int) rc
< 0 && (enum return_reason
) rc
== RETURN_ERROR
)
252 return MI_CMD_CAUGHT_ERROR
;
253 else if ((int) rc
>= 0 && rc
== GDB_RC_FAIL
)
260 mi_cmd_thread_list_ids (char *command
, char **argv
, int argc
)
262 enum gdb_rc rc
= MI_CMD_DONE
;
266 xasprintf (&mi_error_message
,
267 "mi_cmd_thread_list_ids: No arguments required.");
271 rc
= gdb_list_thread_ids (uiout
);
273 if (rc
== GDB_RC_FAIL
)
274 return MI_CMD_CAUGHT_ERROR
;
280 mi_cmd_data_list_register_names (char *command
, char **argv
, int argc
)
284 struct cleanup
*cleanup
;
286 /* Note that the test for a valid register must include checking the
287 REGISTER_NAME because NUM_REGS may be allocated for the union of
288 the register sets within a family of related processors. In this
289 case, some entries of REGISTER_NAME will change depending upon
290 the particular processor being debugged. */
292 numregs
= NUM_REGS
+ NUM_PSEUDO_REGS
;
294 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "register-names");
296 if (argc
== 0) /* No args, just do all the regs */
302 if (REGISTER_NAME (regnum
) == NULL
303 || *(REGISTER_NAME (regnum
)) == '\0')
304 ui_out_field_string (uiout
, NULL
, "");
306 ui_out_field_string (uiout
, NULL
, REGISTER_NAME (regnum
));
310 /* Else, list of register #s, just do listed regs */
311 for (i
= 0; i
< argc
; i
++)
313 regnum
= atoi (argv
[i
]);
314 if (regnum
< 0 || regnum
>= numregs
)
316 do_cleanups (cleanup
);
317 xasprintf (&mi_error_message
, "bad register number");
320 if (REGISTER_NAME (regnum
) == NULL
321 || *(REGISTER_NAME (regnum
)) == '\0')
322 ui_out_field_string (uiout
, NULL
, "");
324 ui_out_field_string (uiout
, NULL
, REGISTER_NAME (regnum
));
326 do_cleanups (cleanup
);
331 mi_cmd_data_list_changed_registers (char *command
, char **argv
, int argc
)
333 int regnum
, numregs
, changed
;
335 struct cleanup
*cleanup
;
337 /* Note that the test for a valid register must include checking the
338 REGISTER_NAME because NUM_REGS may be allocated for the union of
339 the register sets within a family of related processors. In this
340 case, some entries of REGISTER_NAME will change depending upon
341 the particular processor being debugged. */
345 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "changed-registers");
347 if (argc
== 0) /* No args, just do all the regs */
353 if (REGISTER_NAME (regnum
) == NULL
354 || *(REGISTER_NAME (regnum
)) == '\0')
356 changed
= register_changed_p (regnum
);
359 do_cleanups (cleanup
);
360 xasprintf (&mi_error_message
,
361 "mi_cmd_data_list_changed_registers: Unable to read register contents.");
365 ui_out_field_int (uiout
, NULL
, regnum
);
369 /* Else, list of register #s, just do listed regs */
370 for (i
= 0; i
< argc
; i
++)
372 regnum
= atoi (argv
[i
]);
376 && REGISTER_NAME (regnum
) != NULL
377 && *REGISTER_NAME (regnum
) != '\000')
379 changed
= register_changed_p (regnum
);
382 do_cleanups (cleanup
);
383 xasprintf (&mi_error_message
,
384 "mi_cmd_data_list_register_change: Unable to read register contents.");
388 ui_out_field_int (uiout
, NULL
, regnum
);
392 do_cleanups (cleanup
);
393 xasprintf (&mi_error_message
, "bad register number");
397 do_cleanups (cleanup
);
402 register_changed_p (int regnum
)
404 char raw_buffer
[MAX_REGISTER_SIZE
];
406 if (! frame_register_read (deprecated_selected_frame
, regnum
, raw_buffer
))
409 if (memcmp (&old_regs
[DEPRECATED_REGISTER_BYTE (regnum
)], raw_buffer
,
410 DEPRECATED_REGISTER_RAW_SIZE (regnum
)) == 0)
413 /* Found a changed register. Return 1. */
415 memcpy (&old_regs
[DEPRECATED_REGISTER_BYTE (regnum
)], raw_buffer
,
416 DEPRECATED_REGISTER_RAW_SIZE (regnum
));
421 /* Return a list of register number and value pairs. The valid
422 arguments expected are: a letter indicating the format in which to
423 display the registers contents. This can be one of: x (hexadecimal), d
424 (decimal), N (natural), t (binary), o (octal), r (raw). After the
425 format argumetn there can be a sequence of numbers, indicating which
426 registers to fetch the content of. If the format is the only argument,
427 a list of all the registers with their values is returned. */
429 mi_cmd_data_list_register_values (char *command
, char **argv
, int argc
)
431 int regnum
, numregs
, format
, result
;
433 struct cleanup
*list_cleanup
, *tuple_cleanup
;
435 /* Note that the test for a valid register must include checking the
436 REGISTER_NAME because NUM_REGS may be allocated for the union of
437 the register sets within a family of related processors. In this
438 case, some entries of REGISTER_NAME will change depending upon
439 the particular processor being debugged. */
445 xasprintf (&mi_error_message
,
446 "mi_cmd_data_list_register_values: Usage: -data-list-register-values <format> [<regnum1>...<regnumN>]");
450 format
= (int) argv
[0][0];
452 if (!target_has_registers
)
454 xasprintf (&mi_error_message
,
455 "mi_cmd_data_list_register_values: No registers.");
459 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "register-values");
461 if (argc
== 1) /* No args, beside the format: do all the regs */
467 if (REGISTER_NAME (regnum
) == NULL
468 || *(REGISTER_NAME (regnum
)) == '\0')
470 tuple_cleanup
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
471 ui_out_field_int (uiout
, "number", regnum
);
472 result
= get_register (regnum
, format
);
475 do_cleanups (list_cleanup
);
478 do_cleanups (tuple_cleanup
);
482 /* Else, list of register #s, just do listed regs */
483 for (i
= 1; i
< argc
; i
++)
485 regnum
= atoi (argv
[i
]);
489 && REGISTER_NAME (regnum
) != NULL
490 && *REGISTER_NAME (regnum
) != '\000')
492 tuple_cleanup
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
493 ui_out_field_int (uiout
, "number", regnum
);
494 result
= get_register (regnum
, format
);
497 do_cleanups (list_cleanup
);
500 do_cleanups (tuple_cleanup
);
504 do_cleanups (list_cleanup
);
505 xasprintf (&mi_error_message
, "bad register number");
509 do_cleanups (list_cleanup
);
513 /* Output one register's contents in the desired format. */
515 get_register (int regnum
, int format
)
517 char raw_buffer
[MAX_REGISTER_SIZE
];
518 char virtual_buffer
[MAX_REGISTER_SIZE
];
523 static struct ui_stream
*stb
= NULL
;
525 stb
= ui_out_stream_new (uiout
);
530 frame_register (deprecated_selected_frame
, regnum
, &optim
, &lval
, &addr
,
531 &realnum
, raw_buffer
);
535 xasprintf (&mi_error_message
, "Optimized out");
539 /* Convert raw data to virtual format if necessary. */
541 if (DEPRECATED_REGISTER_CONVERTIBLE_P ()
542 && DEPRECATED_REGISTER_CONVERTIBLE (regnum
))
544 DEPRECATED_REGISTER_CONVERT_TO_VIRTUAL (regnum
,
545 register_type (current_gdbarch
, regnum
),
546 raw_buffer
, virtual_buffer
);
549 memcpy (virtual_buffer
, raw_buffer
, DEPRECATED_REGISTER_VIRTUAL_SIZE (regnum
));
554 char *ptr
, buf
[1024];
558 for (j
= 0; j
< DEPRECATED_REGISTER_RAW_SIZE (regnum
); j
++)
560 int idx
= TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
? j
561 : DEPRECATED_REGISTER_RAW_SIZE (regnum
) - 1 - j
;
562 sprintf (ptr
, "%02x", (unsigned char) raw_buffer
[idx
]);
565 ui_out_field_string (uiout
, "value", buf
);
566 /*fputs_filtered (buf, gdb_stdout); */
570 val_print (register_type (current_gdbarch
, regnum
), virtual_buffer
, 0, 0,
571 stb
->stream
, format
, 1, 0, Val_pretty_default
);
572 ui_out_field_stream (uiout
, "value", stb
);
573 ui_out_stream_delete (stb
);
578 /* Write given values into registers. The registers and values are
579 given as pairs. The corresponding MI command is
580 -data-write-register-values <format> [<regnum1> <value1>...<regnumN> <valueN>]*/
582 mi_cmd_data_write_register_values (char *command
, char **argv
, int argc
)
590 /* Note that the test for a valid register must include checking the
591 REGISTER_NAME because NUM_REGS may be allocated for the union of
592 the register sets within a family of related processors. In this
593 case, some entries of REGISTER_NAME will change depending upon
594 the particular processor being debugged. */
600 xasprintf (&mi_error_message
,
601 "mi_cmd_data_write_register_values: Usage: -data-write-register-values <format> [<regnum1> <value1>...<regnumN> <valueN>]");
605 format
= (int) argv
[0][0];
607 if (!target_has_registers
)
609 xasprintf (&mi_error_message
,
610 "mi_cmd_data_write_register_values: No registers.");
616 xasprintf (&mi_error_message
,
617 "mi_cmd_data_write_register_values: No regs and values specified.");
623 xasprintf (&mi_error_message
,
624 "mi_cmd_data_write_register_values: Regs and vals are not in pairs.");
628 for (i
= 1; i
< argc
; i
= i
+ 2)
630 regnum
= atoi (argv
[i
]);
634 && REGISTER_NAME (regnum
) != NULL
635 && *REGISTER_NAME (regnum
) != '\000')
638 struct cleanup
*old_chain
;
640 /* Get the value as a number */
641 value
= parse_and_eval_address (argv
[i
+ 1]);
642 /* Get the value into an array */
643 buffer
= xmalloc (DEPRECATED_REGISTER_SIZE
);
644 old_chain
= make_cleanup (xfree
, buffer
);
645 store_signed_integer (buffer
, DEPRECATED_REGISTER_SIZE
, value
);
647 deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (regnum
), buffer
, DEPRECATED_REGISTER_RAW_SIZE (regnum
));
648 /* Free the buffer. */
649 do_cleanups (old_chain
);
653 xasprintf (&mi_error_message
, "bad register number");
661 /*This is commented out because we decided it was not useful. I leave
662 it, just in case. ezannoni:1999-12-08 */
664 /* Assign a value to a variable. The expression argument must be in
665 the form A=2 or "A = 2" (I.e. if there are spaces it needs to be
668 mi_cmd_data_assign (char *command
, char **argv
, int argc
)
670 struct expression
*expr
;
671 struct cleanup
*old_chain
;
675 xasprintf (&mi_error_message
,
676 "mi_cmd_data_assign: Usage: -data-assign expression");
680 /* NOTE what follows is a clone of set_command(). FIXME: ezannoni
681 01-12-1999: Need to decide what to do with this for libgdb purposes. */
683 expr
= parse_expression (argv
[0]);
684 old_chain
= make_cleanup (free_current_contents
, &expr
);
685 evaluate_expression (expr
);
686 do_cleanups (old_chain
);
691 /* Evaluate the value of the argument. The argument is an
692 expression. If the expression contains spaces it needs to be
693 included in double quotes. */
695 mi_cmd_data_evaluate_expression (char *command
, char **argv
, int argc
)
697 struct expression
*expr
;
698 struct cleanup
*old_chain
= NULL
;
700 struct ui_stream
*stb
= NULL
;
702 stb
= ui_out_stream_new (uiout
);
706 xasprintf (&mi_error_message
,
707 "mi_cmd_data_evaluate_expression: Usage: -data-evaluate-expression expression");
711 expr
= parse_expression (argv
[0]);
713 old_chain
= make_cleanup (free_current_contents
, &expr
);
715 val
= evaluate_expression (expr
);
717 /* Print the result of the expression evaluation. */
718 val_print (VALUE_TYPE (val
), VALUE_CONTENTS (val
),
719 VALUE_EMBEDDED_OFFSET (val
), VALUE_ADDRESS (val
),
720 stb
->stream
, 0, 0, 0, 0);
722 ui_out_field_stream (uiout
, "value", stb
);
723 ui_out_stream_delete (stb
);
725 do_cleanups (old_chain
);
731 mi_cmd_target_download (char *args
, int from_tty
)
734 struct cleanup
*old_cleanups
= NULL
;
736 xasprintf (&run
, "load %s", args
);
737 old_cleanups
= make_cleanup (xfree
, run
);
738 execute_command (run
, from_tty
);
740 do_cleanups (old_cleanups
);
744 /* Connect to the remote target. */
746 mi_cmd_target_select (char *args
, int from_tty
)
749 struct cleanup
*old_cleanups
= NULL
;
751 xasprintf (&run
, "target %s", args
);
752 old_cleanups
= make_cleanup (xfree
, run
);
754 /* target-select is always synchronous. once the call has returned
755 we know that we are connected. */
756 /* NOTE: At present all targets that are connected are also
757 (implicitly) talking to a halted target. In the future this may
759 execute_command (run
, from_tty
);
761 do_cleanups (old_cleanups
);
763 /* Issue the completion message here. */
764 if (last_async_command
)
765 fputs_unfiltered (last_async_command
, raw_stdout
);
766 fputs_unfiltered ("^connected", raw_stdout
);
767 mi_out_put (uiout
, raw_stdout
);
768 mi_out_rewind (uiout
);
769 fputs_unfiltered ("\n", raw_stdout
);
770 do_exec_cleanups (ALL_CLEANUPS
);
776 ADDR: start address of data to be dumped.
777 WORD-FORMAT: a char indicating format for the ``word''. See
779 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes
780 NR_ROW: Number of rows.
781 NR_COL: The number of colums (words per row).
782 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
783 ASCHAR for unprintable characters.
785 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
786 displayes them. Returns:
788 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
791 The number of bytes read is SIZE*ROW*COL. */
794 mi_cmd_data_read_memory (char *command
, char **argv
, int argc
)
796 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
802 struct type
*word_type
;
815 static struct mi_opt opts
[] =
817 {"o", OFFSET_OPT
, 1},
823 int opt
= mi_getopt ("mi_cmd_data_read_memory", argc
, argv
, opts
,
827 switch ((enum opt
) opt
)
830 offset
= atol (optarg
);
837 if (argc
< 5 || argc
> 6)
839 xasprintf (&mi_error_message
,
840 "mi_cmd_data_read_memory: Usage: ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR].");
844 /* Extract all the arguments. */
846 /* Start address of the memory dump. */
847 addr
= parse_and_eval_address (argv
[0]) + offset
;
848 /* The format character to use when displaying a memory word. See
849 the ``x'' command. */
850 word_format
= argv
[1][0];
851 /* The size of the memory word. */
852 word_size
= atol (argv
[2]);
856 word_type
= builtin_type_int8
;
860 word_type
= builtin_type_int16
;
864 word_type
= builtin_type_int32
;
868 word_type
= builtin_type_int64
;
872 word_type
= builtin_type_int8
;
875 /* The number of rows */
876 nr_rows
= atol (argv
[3]);
879 xasprintf (&mi_error_message
,
880 "mi_cmd_data_read_memory: invalid number of rows.");
883 /* number of bytes per row. */
884 nr_cols
= atol (argv
[4]);
887 xasprintf (&mi_error_message
,
888 "mi_cmd_data_read_memory: invalid number of columns.");
890 /* The un-printable character when printing ascii. */
896 /* create a buffer and read it in. */
897 total_bytes
= word_size
* nr_rows
* nr_cols
;
898 mbuf
= xcalloc (total_bytes
, 1);
899 make_cleanup (xfree
, mbuf
);
902 xasprintf (&mi_error_message
,
903 "mi_cmd_data_read_memory: out of memory.");
907 while (nr_bytes
< total_bytes
)
910 long num
= target_read_memory_partial (addr
+ nr_bytes
, mbuf
+ nr_bytes
,
911 total_bytes
- nr_bytes
,
918 /* output the header information. */
919 ui_out_field_core_addr (uiout
, "addr", addr
);
920 ui_out_field_int (uiout
, "nr-bytes", nr_bytes
);
921 ui_out_field_int (uiout
, "total-bytes", total_bytes
);
922 ui_out_field_core_addr (uiout
, "next-row", addr
+ word_size
* nr_cols
);
923 ui_out_field_core_addr (uiout
, "prev-row", addr
- word_size
* nr_cols
);
924 ui_out_field_core_addr (uiout
, "next-page", addr
+ total_bytes
);
925 ui_out_field_core_addr (uiout
, "prev-page", addr
- total_bytes
);
927 /* Build the result as a two dimentional table. */
929 struct ui_stream
*stream
= ui_out_stream_new (uiout
);
930 struct cleanup
*cleanup_list_memory
;
933 cleanup_list_memory
= make_cleanup_ui_out_list_begin_end (uiout
, "memory");
934 for (row
= 0, row_byte
= 0;
936 row
++, row_byte
+= nr_cols
* word_size
)
940 struct cleanup
*cleanup_tuple
;
941 struct cleanup
*cleanup_list_data
;
942 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
943 ui_out_field_core_addr (uiout
, "addr", addr
+ row_byte
);
944 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr + row_byte); */
945 cleanup_list_data
= make_cleanup_ui_out_list_begin_end (uiout
, "data");
946 for (col
= 0, col_byte
= row_byte
;
948 col
++, col_byte
+= word_size
)
950 if (col_byte
+ word_size
> nr_bytes
)
952 ui_out_field_string (uiout
, NULL
, "N/A");
956 ui_file_rewind (stream
->stream
);
957 print_scalar_formatted (mbuf
+ col_byte
, word_type
, word_format
,
958 word_asize
, stream
->stream
);
959 ui_out_field_stream (uiout
, NULL
, stream
);
962 do_cleanups (cleanup_list_data
);
966 ui_file_rewind (stream
->stream
);
967 for (byte
= row_byte
; byte
< row_byte
+ word_size
* nr_cols
; byte
++)
969 if (byte
>= nr_bytes
)
971 fputc_unfiltered ('X', stream
->stream
);
973 else if (mbuf
[byte
] < 32 || mbuf
[byte
] > 126)
975 fputc_unfiltered (aschar
, stream
->stream
);
978 fputc_unfiltered (mbuf
[byte
], stream
->stream
);
980 ui_out_field_stream (uiout
, "ascii", stream
);
982 do_cleanups (cleanup_tuple
);
984 ui_out_stream_delete (stream
);
985 do_cleanups (cleanup_list_memory
);
987 do_cleanups (cleanups
);
991 /* DATA-MEMORY-WRITE:
993 COLUMN_OFFSET: optional argument. Must be preceeded by '-o'. The
994 offset from the beginning of the memory grid row where the cell to
996 ADDR: start address of the row in the memory grid where the memory
997 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
998 the location to write to.
999 FORMAT: a char indicating format for the ``word''. See
1001 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
1002 VALUE: value to be written into the memory address.
1004 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
1008 mi_cmd_data_write_memory (char *command
, char **argv
, int argc
)
1013 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
1014 enough when using a compiler other than GCC. */
1017 struct cleanup
*old_chain
;
1025 static struct mi_opt opts
[] =
1027 {"o", OFFSET_OPT
, 1},
1033 int opt
= mi_getopt ("mi_cmd_data_write_memory", argc
, argv
, opts
,
1037 switch ((enum opt
) opt
)
1040 offset
= atol (optarg
);
1049 xasprintf (&mi_error_message
,
1050 "mi_cmd_data_write_memory: Usage: [-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE.");
1051 return MI_CMD_ERROR
;
1054 /* Extract all the arguments. */
1055 /* Start address of the memory dump. */
1056 addr
= parse_and_eval_address (argv
[0]);
1057 /* The format character to use when displaying a memory word. See
1058 the ``x'' command. */
1059 word_format
= argv
[1][0];
1060 /* The size of the memory word. */
1061 word_size
= atol (argv
[2]);
1063 /* Calculate the real address of the write destination. */
1064 addr
+= (offset
* word_size
);
1066 /* Get the value as a number */
1067 value
= parse_and_eval_address (argv
[3]);
1068 /* Get the value into an array */
1069 buffer
= xmalloc (word_size
);
1070 old_chain
= make_cleanup (xfree
, buffer
);
1071 store_signed_integer (buffer
, word_size
, value
);
1072 /* Write it down to memory */
1073 write_memory (addr
, buffer
, word_size
);
1074 /* Free the buffer. */
1075 do_cleanups (old_chain
);
1080 /* Execute a command within a safe environment.
1081 Return <0 for error; >=0 for ok.
1083 args->action will tell mi_execute_command what action
1084 to perfrom after the given command has executed (display/supress
1085 prompt, display error). */
1088 captured_mi_execute_command (struct ui_out
*uiout
, void *data
)
1090 struct captured_mi_execute_command_args
*args
=
1091 (struct captured_mi_execute_command_args
*) data
;
1092 struct mi_parse
*context
= args
->command
;
1094 switch (context
->op
)
1098 /* A MI command was read from the input stream */
1100 /* FIXME: gdb_???? */
1101 fprintf_unfiltered (raw_stdout
, " token=`%s' command=`%s' args=`%s'\n",
1102 context
->token
, context
->command
, context
->args
);
1103 /* FIXME: cagney/1999-09-25: Rather than this convoluted
1104 condition expression, each function should return an
1105 indication of what action is required and then switch on
1107 args
->action
= EXECUTE_COMMAND_DISPLAY_PROMPT
;
1108 args
->rc
= mi_cmd_execute (context
);
1110 if (!target_can_async_p () || !target_executing
)
1112 /* print the result if there were no errors
1114 Remember that on the way out of executing a command, you have
1115 to directly use the mi_interp's uiout, since the command could
1116 have reset the interpreter, in which case the current uiout
1117 will most likely crash in the mi_out_* routines. */
1118 if (args
->rc
== MI_CMD_DONE
)
1120 fputs_unfiltered (context
->token
, raw_stdout
);
1121 fputs_unfiltered ("^done", raw_stdout
);
1122 mi_out_put (uiout
, raw_stdout
);
1123 mi_out_rewind (uiout
);
1124 fputs_unfiltered ("\n", raw_stdout
);
1126 else if (args
->rc
== MI_CMD_ERROR
)
1128 if (mi_error_message
)
1130 fputs_unfiltered (context
->token
, raw_stdout
);
1131 fputs_unfiltered ("^error,msg=\"", raw_stdout
);
1132 fputstr_unfiltered (mi_error_message
, '"', raw_stdout
);
1133 xfree (mi_error_message
);
1134 fputs_unfiltered ("\"\n", raw_stdout
);
1136 mi_out_rewind (uiout
);
1138 else if (args
->rc
== MI_CMD_CAUGHT_ERROR
)
1140 mi_out_rewind (uiout
);
1141 args
->action
= EXECUTE_COMMAND_DISPLAY_ERROR
;
1145 mi_out_rewind (uiout
);
1147 else if (sync_execution
)
1149 /* Don't print the prompt. We are executing the target in
1150 synchronous mode. */
1151 args
->action
= EXECUTE_COMMAND_SUPRESS_PROMPT
;
1157 /* A CLI command was read from the input stream */
1158 /* This will be removed as soon as we have a complete set of
1160 /* echo the command on the console. */
1161 fprintf_unfiltered (gdb_stdlog
, "%s\n", context
->command
);
1162 mi_execute_cli_command (context
->command
, 0, NULL
);
1164 /* If we changed interpreters, DON'T print out anything. */
1165 if (current_interp_named_p (INTERP_MI
)
1166 || current_interp_named_p (INTERP_MI1
)
1167 || current_interp_named_p (INTERP_MI2
)
1168 || current_interp_named_p (INTERP_MI3
))
1170 /* print the result */
1171 /* FIXME: Check for errors here. */
1172 fputs_unfiltered (context
->token
, raw_stdout
);
1173 fputs_unfiltered ("^done", raw_stdout
);
1174 mi_out_put (uiout
, raw_stdout
);
1175 mi_out_rewind (uiout
);
1176 fputs_unfiltered ("\n", raw_stdout
);
1177 args
->action
= EXECUTE_COMMAND_DISPLAY_PROMPT
;
1178 args
->rc
= MI_CMD_DONE
;
1189 mi_execute_command (char *cmd
, int from_tty
)
1191 struct mi_parse
*command
;
1192 struct captured_mi_execute_command_args args
;
1193 struct ui_out
*saved_uiout
= uiout
;
1196 /* This is to handle EOF (^D). We just quit gdb. */
1197 /* FIXME: we should call some API function here. */
1199 quit_force (NULL
, from_tty
);
1201 command
= mi_parse (cmd
);
1203 if (command
!= NULL
)
1205 /* FIXME: cagney/1999-11-04: Can this use of catch_exceptions either
1206 be pushed even further down or even eliminated? */
1207 args
.command
= command
;
1208 result
= catch_exceptions (uiout
, captured_mi_execute_command
, &args
, "",
1211 if (args
.action
== EXECUTE_COMMAND_SUPRESS_PROMPT
)
1213 /* The command is executing synchronously. Bail out early
1214 suppressing the finished prompt. */
1215 mi_parse_free (command
);
1218 if (args
.action
== EXECUTE_COMMAND_DISPLAY_ERROR
|| result
< 0)
1220 char *msg
= error_last_message ();
1221 struct cleanup
*cleanup
= make_cleanup (xfree
, msg
);
1222 /* The command execution failed and error() was called
1224 fputs_unfiltered (command
->token
, raw_stdout
);
1225 fputs_unfiltered ("^error,msg=\"", raw_stdout
);
1226 fputstr_unfiltered (msg
, '"', raw_stdout
);
1227 fputs_unfiltered ("\"\n", raw_stdout
);
1229 mi_parse_free (command
);
1232 fputs_unfiltered ("(gdb) \n", raw_stdout
);
1233 gdb_flush (raw_stdout
);
1234 /* print any buffered hook code */
1238 static enum mi_cmd_result
1239 mi_cmd_execute (struct mi_parse
*parse
)
1241 if (parse
->cmd
->argv_func
!= NULL
1242 || parse
->cmd
->args_func
!= NULL
)
1244 /* FIXME: We need to save the token because the command executed
1245 may be asynchronous and need to print the token again.
1246 In the future we can pass the token down to the func
1247 and get rid of the last_async_command */
1248 /* The problem here is to keep the token around when we launch
1249 the target, and we want to interrupt it later on. The
1250 interrupt command will have its own token, but when the
1251 target stops, we must display the token corresponding to the
1252 last execution command given. So we have another string where
1253 we copy the token (previous_async_command), if this was
1254 indeed the token of an execution command, and when we stop we
1255 print that one. This is possible because the interrupt
1256 command, when over, will copy that token back into the
1257 default token string (last_async_command). */
1259 if (target_executing
)
1261 if (!previous_async_command
)
1262 previous_async_command
= xstrdup (last_async_command
);
1263 if (strcmp (parse
->command
, "exec-interrupt"))
1265 fputs_unfiltered (parse
->token
, raw_stdout
);
1266 fputs_unfiltered ("^error,msg=\"", raw_stdout
);
1267 fputs_unfiltered ("Cannot execute command ", raw_stdout
);
1268 fputstr_unfiltered (parse
->command
, '"', raw_stdout
);
1269 fputs_unfiltered (" while target running", raw_stdout
);
1270 fputs_unfiltered ("\"\n", raw_stdout
);
1271 return MI_CMD_ERROR
;
1274 last_async_command
= xstrdup (parse
->token
);
1275 make_exec_cleanup (free_current_contents
, &last_async_command
);
1276 /* FIXME: DELETE THIS! */
1277 if (parse
->cmd
->args_func
!= NULL
)
1278 return parse
->cmd
->args_func (parse
->args
, 0 /*from_tty */ );
1279 return parse
->cmd
->argv_func (parse
->command
, parse
->argv
, parse
->argc
);
1281 else if (parse
->cmd
->cli
.cmd
!= 0)
1283 /* FIXME: DELETE THIS. */
1284 /* The operation is still implemented by a cli command */
1285 /* Must be a synchronous one */
1286 mi_execute_cli_command (parse
->cmd
->cli
.cmd
, parse
->cmd
->cli
.args_p
,
1292 /* FIXME: DELETE THIS. */
1293 fputs_unfiltered (parse
->token
, raw_stdout
);
1294 fputs_unfiltered ("^error,msg=\"", raw_stdout
);
1295 fputs_unfiltered ("Undefined mi command: ", raw_stdout
);
1296 fputstr_unfiltered (parse
->command
, '"', raw_stdout
);
1297 fputs_unfiltered (" (missing implementation)", raw_stdout
);
1298 fputs_unfiltered ("\"\n", raw_stdout
);
1299 return MI_CMD_ERROR
;
1303 /* FIXME: This is just a hack so we can get some extra commands going.
1304 We don't want to channel things through the CLI, but call libgdb directly */
1305 /* Use only for synchronous commands */
1308 mi_execute_cli_command (const char *cmd
, int args_p
, const char *args
)
1312 struct cleanup
*old_cleanups
;
1315 xasprintf (&run
, "%s %s", cmd
, args
);
1317 run
= xstrdup (cmd
);
1319 /* FIXME: gdb_???? */
1320 fprintf_unfiltered (gdb_stdout
, "cli=%s run=%s\n",
1322 old_cleanups
= make_cleanup (xfree
, run
);
1323 execute_command ( /*ui */ run
, 0 /*from_tty */ );
1324 do_cleanups (old_cleanups
);
1330 mi_execute_async_cli_command (char *mi
, char *args
, int from_tty
)
1332 struct cleanup
*old_cleanups
;
1336 if (target_can_async_p ())
1338 async_args
= (char *) xmalloc (strlen (args
) + 2);
1339 make_exec_cleanup (free
, async_args
);
1340 strcpy (async_args
, args
);
1341 strcat (async_args
, "&");
1342 xasprintf (&run
, "%s %s", mi
, async_args
);
1343 make_exec_cleanup (free
, run
);
1344 add_continuation (mi_exec_async_cli_cmd_continuation
, NULL
);
1345 old_cleanups
= NULL
;
1349 xasprintf (&run
, "%s %s", mi
, args
);
1350 old_cleanups
= make_cleanup (xfree
, run
);
1353 if (!target_can_async_p ())
1355 /* NOTE: For synchronous targets asynchronous behavour is faked by
1356 printing out the GDB prompt before we even try to execute the
1358 if (last_async_command
)
1359 fputs_unfiltered (last_async_command
, raw_stdout
);
1360 fputs_unfiltered ("^running\n", raw_stdout
);
1361 fputs_unfiltered ("(gdb) \n", raw_stdout
);
1362 gdb_flush (raw_stdout
);
1366 /* FIXME: cagney/1999-11-29: Printing this message before
1367 calling execute_command is wrong. It should only be printed
1368 once gdb has confirmed that it really has managed to send a
1369 run command to the target. */
1370 if (last_async_command
)
1371 fputs_unfiltered (last_async_command
, raw_stdout
);
1372 fputs_unfiltered ("^running\n", raw_stdout
);
1375 execute_command ( /*ui */ run
, 0 /*from_tty */ );
1377 if (!target_can_async_p ())
1379 /* Do this before doing any printing. It would appear that some
1380 print code leaves garbage around in the buffer. */
1381 do_cleanups (old_cleanups
);
1382 /* If the target was doing the operation synchronously we fake
1383 the stopped message. */
1384 if (last_async_command
)
1385 fputs_unfiltered (last_async_command
, raw_stdout
);
1386 fputs_unfiltered ("*stopped", raw_stdout
);
1387 mi_out_put (uiout
, raw_stdout
);
1388 mi_out_rewind (uiout
);
1389 fputs_unfiltered ("\n", raw_stdout
);
1390 return MI_CMD_QUIET
;
1396 mi_exec_async_cli_cmd_continuation (struct continuation_arg
*arg
)
1398 if (last_async_command
)
1399 fputs_unfiltered (last_async_command
, raw_stdout
);
1400 fputs_unfiltered ("*stopped", raw_stdout
);
1401 mi_out_put (uiout
, raw_stdout
);
1402 fputs_unfiltered ("\n", raw_stdout
);
1403 fputs_unfiltered ("(gdb) \n", raw_stdout
);
1404 gdb_flush (raw_stdout
);
1405 do_exec_cleanups (ALL_CLEANUPS
);
1409 mi_load_progress (const char *section_name
,
1410 unsigned long sent_so_far
,
1411 unsigned long total_section
,
1412 unsigned long total_sent
,
1413 unsigned long grand_total
)
1415 struct timeval time_now
, delta
, update_threshold
;
1416 static struct timeval last_update
;
1417 static char *previous_sect_name
= NULL
;
1420 if (!current_interp_named_p (INTERP_MI
)
1421 && !current_interp_named_p (INTERP_MI1
))
1424 update_threshold
.tv_sec
= 0;
1425 update_threshold
.tv_usec
= 500000;
1426 gettimeofday (&time_now
, NULL
);
1428 delta
.tv_usec
= time_now
.tv_usec
- last_update
.tv_usec
;
1429 delta
.tv_sec
= time_now
.tv_sec
- last_update
.tv_sec
;
1431 if (delta
.tv_usec
< 0)
1434 delta
.tv_usec
+= 1000000;
1437 new_section
= (previous_sect_name
?
1438 strcmp (previous_sect_name
, section_name
) : 1);
1441 struct cleanup
*cleanup_tuple
;
1442 xfree (previous_sect_name
);
1443 previous_sect_name
= xstrdup (section_name
);
1445 if (last_async_command
)
1446 fputs_unfiltered (last_async_command
, raw_stdout
);
1447 fputs_unfiltered ("+download", raw_stdout
);
1448 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1449 ui_out_field_string (uiout
, "section", section_name
);
1450 ui_out_field_int (uiout
, "section-size", total_section
);
1451 ui_out_field_int (uiout
, "total-size", grand_total
);
1452 do_cleanups (cleanup_tuple
);
1453 mi_out_put (uiout
, raw_stdout
);
1454 fputs_unfiltered ("\n", raw_stdout
);
1455 gdb_flush (raw_stdout
);
1458 if (delta
.tv_sec
>= update_threshold
.tv_sec
&&
1459 delta
.tv_usec
>= update_threshold
.tv_usec
)
1461 struct cleanup
*cleanup_tuple
;
1462 last_update
.tv_sec
= time_now
.tv_sec
;
1463 last_update
.tv_usec
= time_now
.tv_usec
;
1464 if (last_async_command
)
1465 fputs_unfiltered (last_async_command
, raw_stdout
);
1466 fputs_unfiltered ("+download", raw_stdout
);
1467 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1468 ui_out_field_string (uiout
, "section", section_name
);
1469 ui_out_field_int (uiout
, "section-sent", sent_so_far
);
1470 ui_out_field_int (uiout
, "section-size", total_section
);
1471 ui_out_field_int (uiout
, "total-sent", total_sent
);
1472 ui_out_field_int (uiout
, "total-size", grand_total
);
1473 do_cleanups (cleanup_tuple
);
1474 mi_out_put (uiout
, raw_stdout
);
1475 fputs_unfiltered ("\n", raw_stdout
);
1476 gdb_flush (raw_stdout
);
1481 mi_setup_architecture_data (void)
1483 old_regs
= xmalloc ((NUM_REGS
+ NUM_PSEUDO_REGS
) * MAX_REGISTER_SIZE
+ 1);
1484 memset (old_regs
, 0, (NUM_REGS
+ NUM_PSEUDO_REGS
) * MAX_REGISTER_SIZE
+ 1);
1488 _initialize_mi_main (void)
1490 DEPRECATED_REGISTER_GDBARCH_SWAP (old_regs
);
1491 deprecated_register_gdbarch_swap (NULL
, 0, mi_setup_architecture_data
);