3 Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2007
4 Free Software Foundation, Inc.
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., 51 Franklin Street, Fifth Floor,
23 Boston, MA 02110-1301, 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() */
53 #if defined HAVE_SYS_RESOURCE_H
54 #include <sys/resource.h>
66 /* Enumerations of the actions that may result from calling
67 captured_mi_execute_command */
69 enum captured_mi_execute_command_actions
71 EXECUTE_COMMAND_DISPLAY_PROMPT
,
72 EXECUTE_COMMAND_SUPRESS_PROMPT
75 /* This structure is used to pass information from captured_mi_execute_command
76 to mi_execute_command. */
77 struct captured_mi_execute_command_args
79 /* This return result of the MI command (output) */
80 enum mi_cmd_result rc
;
82 /* What action to perform when the call is finished (output) */
83 enum captured_mi_execute_command_actions action
;
85 /* The command context to be executed (input) */
86 struct mi_parse
*command
;
90 struct ui_file
*raw_stdout
;
92 /* This is used to pass the current command timestamp
93 down to continuation routines. */
94 static struct mi_timestamp
*current_command_ts
;
96 static int do_timings
= 0;
98 /* The token of the last asynchronous command */
99 static char *last_async_command
;
100 static char *previous_async_command
;
101 char *mi_error_message
;
102 static char *old_regs
;
104 extern void _initialize_mi_main (void);
105 static enum mi_cmd_result
mi_cmd_execute (struct mi_parse
*parse
);
107 static void mi_execute_cli_command (const char *cmd
, int args_p
,
109 static enum mi_cmd_result
mi_execute_async_cli_command (char *mi
, char *args
, int from_tty
);
111 static void mi_exec_async_cli_cmd_continuation (struct continuation_arg
*arg
);
113 static int register_changed_p (int regnum
);
114 static int get_register (int regnum
, int format
);
116 /* Command implementations. FIXME: Is this libgdb? No. This is the MI
117 layer that calls libgdb. Any operation used in the below should be
120 static void timestamp (struct mi_timestamp
*tv
);
122 static void print_diff_now (struct mi_timestamp
*start
);
123 static void print_diff (struct mi_timestamp
*start
, struct mi_timestamp
*end
);
126 mi_cmd_gdb_exit (char *command
, char **argv
, int argc
)
128 /* We have to print everything right here because we never return */
129 if (last_async_command
)
130 fputs_unfiltered (last_async_command
, raw_stdout
);
131 fputs_unfiltered ("^exit\n", raw_stdout
);
132 mi_out_put (uiout
, raw_stdout
);
133 /* FIXME: The function called is not yet a formal libgdb function */
134 quit_force (NULL
, FROM_TTY
);
139 mi_cmd_exec_run (char *args
, int from_tty
)
141 /* FIXME: Should call a libgdb function, not a cli wrapper */
142 return mi_execute_async_cli_command ("run", args
, from_tty
);
146 mi_cmd_exec_next (char *args
, int from_tty
)
148 /* FIXME: Should call a libgdb function, not a cli wrapper */
149 return mi_execute_async_cli_command ("next", args
, from_tty
);
153 mi_cmd_exec_next_instruction (char *args
, int from_tty
)
155 /* FIXME: Should call a libgdb function, not a cli wrapper */
156 return mi_execute_async_cli_command ("nexti", args
, from_tty
);
160 mi_cmd_exec_step (char *args
, int from_tty
)
162 /* FIXME: Should call a libgdb function, not a cli wrapper */
163 return mi_execute_async_cli_command ("step", args
, from_tty
);
167 mi_cmd_exec_step_instruction (char *args
, int from_tty
)
169 /* FIXME: Should call a libgdb function, not a cli wrapper */
170 return mi_execute_async_cli_command ("stepi", args
, from_tty
);
174 mi_cmd_exec_finish (char *args
, int from_tty
)
176 /* FIXME: Should call a libgdb function, not a cli wrapper */
177 return mi_execute_async_cli_command ("finish", args
, from_tty
);
181 mi_cmd_exec_until (char *args
, int from_tty
)
183 /* FIXME: Should call a libgdb function, not a cli wrapper */
184 return mi_execute_async_cli_command ("until", args
, from_tty
);
188 mi_cmd_exec_return (char *args
, int from_tty
)
190 /* This command doesn't really execute the target, it just pops the
191 specified number of frames. */
193 /* Call return_command with from_tty argument equal to 0 so as to
194 avoid being queried. */
195 return_command (args
, 0);
197 /* Call return_command with from_tty argument equal to 0 so as to
198 avoid being queried. */
199 return_command (NULL
, 0);
201 /* Because we have called return_command with from_tty = 0, we need
202 to print the frame here. */
203 print_stack_frame (get_selected_frame (NULL
), 1, LOC_AND_ADDRESS
);
209 mi_cmd_exec_continue (char *args
, int from_tty
)
211 /* FIXME: Should call a libgdb function, not a cli wrapper */
212 return mi_execute_async_cli_command ("continue", args
, from_tty
);
215 /* Interrupt the execution of the target. Note how we must play around
216 with the token variables, in order to display the current token in
217 the result of the interrupt command, and the previous execution
218 token when the target finally stops. See comments in
221 mi_cmd_exec_interrupt (char *args
, int from_tty
)
223 if (!target_executing
)
225 mi_error_message
= xstrprintf ("mi_cmd_exec_interrupt: Inferior not executing.");
228 interrupt_target_command (args
, from_tty
);
229 if (last_async_command
)
230 fputs_unfiltered (last_async_command
, raw_stdout
);
231 fputs_unfiltered ("^done", raw_stdout
);
232 xfree (last_async_command
);
233 if (previous_async_command
)
234 last_async_command
= xstrdup (previous_async_command
);
235 xfree (previous_async_command
);
236 previous_async_command
= NULL
;
237 mi_out_put (uiout
, raw_stdout
);
238 mi_out_rewind (uiout
);
239 fputs_unfiltered ("\n", raw_stdout
);
244 mi_cmd_thread_select (char *command
, char **argv
, int argc
)
250 mi_error_message
= xstrprintf ("mi_cmd_thread_select: USAGE: threadnum.");
254 rc
= gdb_thread_select (uiout
, argv
[0], &mi_error_message
);
256 /* RC is enum gdb_rc if it is successful (>=0)
257 enum return_reason if not (<0). */
258 if ((int) rc
< 0 && (enum return_reason
) rc
== RETURN_ERROR
)
260 else if ((int) rc
>= 0 && rc
== GDB_RC_FAIL
)
267 mi_cmd_thread_list_ids (char *command
, char **argv
, int argc
)
269 enum gdb_rc rc
= MI_CMD_DONE
;
273 mi_error_message
= xstrprintf ("mi_cmd_thread_list_ids: No arguments required.");
277 rc
= gdb_list_thread_ids (uiout
, &mi_error_message
);
279 if (rc
== GDB_RC_FAIL
)
286 mi_cmd_data_list_register_names (char *command
, char **argv
, int argc
)
290 struct cleanup
*cleanup
;
292 /* Note that the test for a valid register must include checking the
293 REGISTER_NAME because NUM_REGS may be allocated for the union of
294 the register sets within a family of related processors. In this
295 case, some entries of REGISTER_NAME will change depending upon
296 the particular processor being debugged. */
298 numregs
= NUM_REGS
+ NUM_PSEUDO_REGS
;
300 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "register-names");
302 if (argc
== 0) /* No args, just do all the regs */
308 if (REGISTER_NAME (regnum
) == NULL
309 || *(REGISTER_NAME (regnum
)) == '\0')
310 ui_out_field_string (uiout
, NULL
, "");
312 ui_out_field_string (uiout
, NULL
, REGISTER_NAME (regnum
));
316 /* Else, list of register #s, just do listed regs */
317 for (i
= 0; i
< argc
; i
++)
319 regnum
= atoi (argv
[i
]);
320 if (regnum
< 0 || regnum
>= numregs
)
322 do_cleanups (cleanup
);
323 mi_error_message
= xstrprintf ("bad register number");
326 if (REGISTER_NAME (regnum
) == NULL
327 || *(REGISTER_NAME (regnum
)) == '\0')
328 ui_out_field_string (uiout
, NULL
, "");
330 ui_out_field_string (uiout
, NULL
, REGISTER_NAME (regnum
));
332 do_cleanups (cleanup
);
337 mi_cmd_data_list_changed_registers (char *command
, char **argv
, int argc
)
339 int regnum
, numregs
, changed
;
341 struct cleanup
*cleanup
;
343 /* Note that the test for a valid register must include checking the
344 REGISTER_NAME because NUM_REGS may be allocated for the union of
345 the register sets within a family of related processors. In this
346 case, some entries of REGISTER_NAME will change depending upon
347 the particular processor being debugged. */
349 numregs
= NUM_REGS
+ NUM_PSEUDO_REGS
;
351 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "changed-registers");
353 if (argc
== 0) /* No args, just do all the regs */
359 if (REGISTER_NAME (regnum
) == NULL
360 || *(REGISTER_NAME (regnum
)) == '\0')
362 changed
= register_changed_p (regnum
);
365 do_cleanups (cleanup
);
366 mi_error_message
= xstrprintf ("mi_cmd_data_list_changed_registers: Unable to read register contents.");
370 ui_out_field_int (uiout
, NULL
, regnum
);
374 /* Else, list of register #s, just do listed regs */
375 for (i
= 0; i
< argc
; i
++)
377 regnum
= atoi (argv
[i
]);
381 && REGISTER_NAME (regnum
) != NULL
382 && *REGISTER_NAME (regnum
) != '\000')
384 changed
= register_changed_p (regnum
);
387 do_cleanups (cleanup
);
388 mi_error_message
= xstrprintf ("mi_cmd_data_list_register_change: Unable to read register contents.");
392 ui_out_field_int (uiout
, NULL
, regnum
);
396 do_cleanups (cleanup
);
397 mi_error_message
= xstrprintf ("bad register number");
401 do_cleanups (cleanup
);
406 register_changed_p (int regnum
)
408 gdb_byte raw_buffer
[MAX_REGISTER_SIZE
];
410 if (! frame_register_read (get_selected_frame (NULL
), regnum
, raw_buffer
))
413 if (memcmp (&old_regs
[DEPRECATED_REGISTER_BYTE (regnum
)], raw_buffer
,
414 register_size (current_gdbarch
, regnum
)) == 0)
417 /* Found a changed register. Return 1. */
419 memcpy (&old_regs
[DEPRECATED_REGISTER_BYTE (regnum
)], raw_buffer
,
420 register_size (current_gdbarch
, regnum
));
425 /* Return a list of register number and value pairs. The valid
426 arguments expected are: a letter indicating the format in which to
427 display the registers contents. This can be one of: x (hexadecimal), d
428 (decimal), N (natural), t (binary), o (octal), r (raw). After the
429 format argumetn there can be a sequence of numbers, indicating which
430 registers to fetch the content of. If the format is the only argument,
431 a list of all the registers with their values is returned. */
433 mi_cmd_data_list_register_values (char *command
, char **argv
, int argc
)
435 int regnum
, numregs
, format
, result
;
437 struct cleanup
*list_cleanup
, *tuple_cleanup
;
439 /* Note that the test for a valid register must include checking the
440 REGISTER_NAME because NUM_REGS may be allocated for the union of
441 the register sets within a family of related processors. In this
442 case, some entries of REGISTER_NAME will change depending upon
443 the particular processor being debugged. */
445 numregs
= NUM_REGS
+ NUM_PSEUDO_REGS
;
449 mi_error_message
= xstrprintf ("mi_cmd_data_list_register_values: Usage: -data-list-register-values <format> [<regnum1>...<regnumN>]");
453 format
= (int) argv
[0][0];
455 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "register-values");
457 if (argc
== 1) /* No args, beside the format: do all the regs */
463 if (REGISTER_NAME (regnum
) == NULL
464 || *(REGISTER_NAME (regnum
)) == '\0')
466 tuple_cleanup
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
467 ui_out_field_int (uiout
, "number", regnum
);
468 result
= get_register (regnum
, format
);
471 do_cleanups (list_cleanup
);
474 do_cleanups (tuple_cleanup
);
478 /* Else, list of register #s, just do listed regs */
479 for (i
= 1; i
< argc
; i
++)
481 regnum
= atoi (argv
[i
]);
485 && REGISTER_NAME (regnum
) != NULL
486 && *REGISTER_NAME (regnum
) != '\000')
488 tuple_cleanup
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
489 ui_out_field_int (uiout
, "number", regnum
);
490 result
= get_register (regnum
, format
);
493 do_cleanups (list_cleanup
);
496 do_cleanups (tuple_cleanup
);
500 do_cleanups (list_cleanup
);
501 mi_error_message
= xstrprintf ("bad register number");
505 do_cleanups (list_cleanup
);
509 /* Output one register's contents in the desired format. */
511 get_register (int regnum
, int format
)
513 gdb_byte buffer
[MAX_REGISTER_SIZE
];
518 static struct ui_stream
*stb
= NULL
;
520 stb
= ui_out_stream_new (uiout
);
525 frame_register (get_selected_frame (NULL
), regnum
, &optim
, &lval
, &addr
,
530 mi_error_message
= xstrprintf ("Optimized out");
537 char *ptr
, buf
[1024];
541 for (j
= 0; j
< register_size (current_gdbarch
, regnum
); j
++)
543 int idx
= TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
? j
544 : register_size (current_gdbarch
, regnum
) - 1 - j
;
545 sprintf (ptr
, "%02x", (unsigned char) buffer
[idx
]);
548 ui_out_field_string (uiout
, "value", buf
);
549 /*fputs_filtered (buf, gdb_stdout); */
553 val_print (register_type (current_gdbarch
, regnum
), buffer
, 0, 0,
554 stb
->stream
, format
, 1, 0, Val_pretty_default
);
555 ui_out_field_stream (uiout
, "value", stb
);
556 ui_out_stream_delete (stb
);
561 /* Write given values into registers. The registers and values are
562 given as pairs. The corresponding MI command is
563 -data-write-register-values <format> [<regnum1> <value1>...<regnumN> <valueN>]*/
565 mi_cmd_data_write_register_values (char *command
, char **argv
, int argc
)
570 /* Note that the test for a valid register must include checking the
571 REGISTER_NAME because NUM_REGS may be allocated for the union of
572 the register sets within a family of related processors. In this
573 case, some entries of REGISTER_NAME will change depending upon
574 the particular processor being debugged. */
576 numregs
= NUM_REGS
+ NUM_PSEUDO_REGS
;
580 mi_error_message
= xstrprintf ("mi_cmd_data_write_register_values: Usage: -data-write-register-values <format> [<regnum1> <value1>...<regnumN> <valueN>]");
584 format
= (int) argv
[0][0];
586 if (!target_has_registers
)
588 mi_error_message
= xstrprintf ("mi_cmd_data_write_register_values: No registers.");
594 mi_error_message
= xstrprintf ("mi_cmd_data_write_register_values: No regs and values specified.");
600 mi_error_message
= xstrprintf ("mi_cmd_data_write_register_values: Regs and vals are not in pairs.");
604 for (i
= 1; i
< argc
; i
= i
+ 2)
606 int regnum
= atoi (argv
[i
]);
608 if (regnum
>= 0 && regnum
< numregs
609 && REGISTER_NAME (regnum
) && *REGISTER_NAME (regnum
))
613 /* Get the value as a number. */
614 value
= parse_and_eval_address (argv
[i
+ 1]);
617 regcache_cooked_write_signed (current_regcache
, regnum
, value
);
621 mi_error_message
= xstrprintf ("bad register number");
629 /*This is commented out because we decided it was not useful. I leave
630 it, just in case. ezannoni:1999-12-08 */
632 /* Assign a value to a variable. The expression argument must be in
633 the form A=2 or "A = 2" (I.e. if there are spaces it needs to be
636 mi_cmd_data_assign (char *command
, char **argv
, int argc
)
638 struct expression
*expr
;
639 struct cleanup
*old_chain
;
643 mi_error_message
= xstrprintf ("mi_cmd_data_assign: Usage: -data-assign expression");
647 /* NOTE what follows is a clone of set_command(). FIXME: ezannoni
648 01-12-1999: Need to decide what to do with this for libgdb purposes. */
650 expr
= parse_expression (argv
[0]);
651 old_chain
= make_cleanup (free_current_contents
, &expr
);
652 evaluate_expression (expr
);
653 do_cleanups (old_chain
);
658 /* Evaluate the value of the argument. The argument is an
659 expression. If the expression contains spaces it needs to be
660 included in double quotes. */
662 mi_cmd_data_evaluate_expression (char *command
, char **argv
, int argc
)
664 struct expression
*expr
;
665 struct cleanup
*old_chain
= NULL
;
667 struct ui_stream
*stb
= NULL
;
669 stb
= ui_out_stream_new (uiout
);
673 mi_error_message
= xstrprintf ("mi_cmd_data_evaluate_expression: Usage: -data-evaluate-expression expression");
677 expr
= parse_expression (argv
[0]);
679 old_chain
= make_cleanup (free_current_contents
, &expr
);
681 val
= evaluate_expression (expr
);
683 /* Print the result of the expression evaluation. */
684 val_print (value_type (val
), value_contents (val
),
685 value_embedded_offset (val
), VALUE_ADDRESS (val
),
686 stb
->stream
, 0, 0, 0, 0);
688 ui_out_field_stream (uiout
, "value", stb
);
689 ui_out_stream_delete (stb
);
691 do_cleanups (old_chain
);
697 mi_cmd_target_download (char *args
, int from_tty
)
700 struct cleanup
*old_cleanups
= NULL
;
702 run
= xstrprintf ("load %s", args
);
703 old_cleanups
= make_cleanup (xfree
, run
);
704 execute_command (run
, from_tty
);
706 do_cleanups (old_cleanups
);
710 /* Connect to the remote target. */
712 mi_cmd_target_select (char *args
, int from_tty
)
715 struct cleanup
*old_cleanups
= NULL
;
717 run
= xstrprintf ("target %s", args
);
718 old_cleanups
= make_cleanup (xfree
, run
);
720 /* target-select is always synchronous. once the call has returned
721 we know that we are connected. */
722 /* NOTE: At present all targets that are connected are also
723 (implicitly) talking to a halted target. In the future this may
725 execute_command (run
, from_tty
);
727 do_cleanups (old_cleanups
);
729 /* Issue the completion message here. */
730 if (last_async_command
)
731 fputs_unfiltered (last_async_command
, raw_stdout
);
732 fputs_unfiltered ("^connected", raw_stdout
);
733 mi_out_put (uiout
, raw_stdout
);
734 mi_out_rewind (uiout
);
735 fputs_unfiltered ("\n", raw_stdout
);
736 do_exec_cleanups (ALL_CLEANUPS
);
742 ADDR: start address of data to be dumped.
743 WORD-FORMAT: a char indicating format for the ``word''. See
745 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes
746 NR_ROW: Number of rows.
747 NR_COL: The number of colums (words per row).
748 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
749 ASCHAR for unprintable characters.
751 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
752 displayes them. Returns:
754 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
757 The number of bytes read is SIZE*ROW*COL. */
760 mi_cmd_data_read_memory (char *command
, char **argv
, int argc
)
762 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
768 struct type
*word_type
;
781 static struct mi_opt opts
[] =
783 {"o", OFFSET_OPT
, 1},
789 int opt
= mi_getopt ("mi_cmd_data_read_memory", argc
, argv
, opts
,
793 switch ((enum opt
) opt
)
796 offset
= atol (optarg
);
803 if (argc
< 5 || argc
> 6)
805 mi_error_message
= xstrprintf ("mi_cmd_data_read_memory: Usage: ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR].");
809 /* Extract all the arguments. */
811 /* Start address of the memory dump. */
812 addr
= parse_and_eval_address (argv
[0]) + offset
;
813 /* The format character to use when displaying a memory word. See
814 the ``x'' command. */
815 word_format
= argv
[1][0];
816 /* The size of the memory word. */
817 word_size
= atol (argv
[2]);
821 word_type
= builtin_type_int8
;
825 word_type
= builtin_type_int16
;
829 word_type
= builtin_type_int32
;
833 word_type
= builtin_type_int64
;
837 word_type
= builtin_type_int8
;
840 /* The number of rows */
841 nr_rows
= atol (argv
[3]);
844 mi_error_message
= xstrprintf ("mi_cmd_data_read_memory: invalid number of rows.");
847 /* number of bytes per row. */
848 nr_cols
= atol (argv
[4]);
851 mi_error_message
= xstrprintf ("mi_cmd_data_read_memory: invalid number of columns.");
854 /* The un-printable character when printing ascii. */
860 /* create a buffer and read it in. */
861 total_bytes
= word_size
* nr_rows
* nr_cols
;
862 mbuf
= xcalloc (total_bytes
, 1);
863 make_cleanup (xfree
, mbuf
);
865 nr_bytes
= target_read (¤t_target
, TARGET_OBJECT_MEMORY
, NULL
,
866 mbuf
, addr
, total_bytes
);
869 do_cleanups (cleanups
);
870 mi_error_message
= xstrdup ("Unable to read memory.");
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
);
1036 mi_cmd_enable_timings (char *command
, char **argv
, int argc
)
1042 if (strcmp (argv
[0], "yes") == 0)
1044 else if (strcmp (argv
[0], "no") == 0)
1055 error ("mi_cmd_enable_timings: Usage: %s {yes|no}", command
);
1056 return MI_CMD_ERROR
;
1059 /* Execute a command within a safe environment.
1060 Return <0 for error; >=0 for ok.
1062 args->action will tell mi_execute_command what action
1063 to perfrom after the given command has executed (display/supress
1064 prompt, display error). */
1067 captured_mi_execute_command (struct ui_out
*uiout
, void *data
)
1069 struct captured_mi_execute_command_args
*args
=
1070 (struct captured_mi_execute_command_args
*) data
;
1071 struct mi_parse
*context
= args
->command
;
1073 struct mi_timestamp cmd_finished
;
1075 switch (context
->op
)
1079 /* A MI command was read from the input stream */
1081 /* FIXME: gdb_???? */
1082 fprintf_unfiltered (raw_stdout
, " token=`%s' command=`%s' args=`%s'\n",
1083 context
->token
, context
->command
, context
->args
);
1084 /* FIXME: cagney/1999-09-25: Rather than this convoluted
1085 condition expression, each function should return an
1086 indication of what action is required and then switch on
1088 args
->action
= EXECUTE_COMMAND_DISPLAY_PROMPT
;
1091 current_command_ts
= context
->cmd_start
;
1093 args
->rc
= mi_cmd_execute (context
);
1096 timestamp (&cmd_finished
);
1098 if (!target_can_async_p () || !target_executing
)
1100 /* print the result if there were no errors
1102 Remember that on the way out of executing a command, you have
1103 to directly use the mi_interp's uiout, since the command could
1104 have reset the interpreter, in which case the current uiout
1105 will most likely crash in the mi_out_* routines. */
1106 if (args
->rc
== MI_CMD_DONE
)
1108 fputs_unfiltered (context
->token
, raw_stdout
);
1109 fputs_unfiltered ("^done", raw_stdout
);
1110 mi_out_put (uiout
, raw_stdout
);
1111 mi_out_rewind (uiout
);
1112 /* Have to check cmd_start, since the command could be
1114 if (do_timings
&& context
->cmd_start
)
1115 print_diff (context
->cmd_start
, &cmd_finished
);
1116 fputs_unfiltered ("\n", raw_stdout
);
1118 else if (args
->rc
== MI_CMD_ERROR
)
1120 if (mi_error_message
)
1122 fputs_unfiltered (context
->token
, raw_stdout
);
1123 fputs_unfiltered ("^error,msg=\"", raw_stdout
);
1124 fputstr_unfiltered (mi_error_message
, '"', raw_stdout
);
1125 xfree (mi_error_message
);
1126 fputs_unfiltered ("\"\n", raw_stdout
);
1128 mi_out_rewind (uiout
);
1131 mi_out_rewind (uiout
);
1133 else if (sync_execution
)
1135 /* Don't print the prompt. We are executing the target in
1136 synchronous mode. */
1137 args
->action
= EXECUTE_COMMAND_SUPRESS_PROMPT
;
1145 /* A CLI command was read from the input stream. */
1146 /* This "feature" will be removed as soon as we have a
1147 complete set of mi commands. */
1148 /* Echo the command on the console. */
1149 fprintf_unfiltered (gdb_stdlog
, "%s\n", context
->command
);
1150 /* Call the "console" interpreter. */
1151 argv
[0] = "console";
1152 argv
[1] = context
->command
;
1153 args
->rc
= mi_cmd_interpreter_exec ("-interpreter-exec", argv
, 2);
1155 /* If we changed interpreters, DON'T print out anything. */
1156 if (current_interp_named_p (INTERP_MI
)
1157 || current_interp_named_p (INTERP_MI1
)
1158 || current_interp_named_p (INTERP_MI2
)
1159 || current_interp_named_p (INTERP_MI3
))
1161 if (args
->rc
== MI_CMD_DONE
)
1163 fputs_unfiltered (context
->token
, raw_stdout
);
1164 fputs_unfiltered ("^done", raw_stdout
);
1165 mi_out_put (uiout
, raw_stdout
);
1166 mi_out_rewind (uiout
);
1167 fputs_unfiltered ("\n", raw_stdout
);
1168 args
->action
= EXECUTE_COMMAND_DISPLAY_PROMPT
;
1170 else if (args
->rc
== MI_CMD_ERROR
)
1172 if (mi_error_message
)
1174 fputs_unfiltered (context
->token
, raw_stdout
);
1175 fputs_unfiltered ("^error,msg=\"", raw_stdout
);
1176 fputstr_unfiltered (mi_error_message
, '"', raw_stdout
);
1177 xfree (mi_error_message
);
1178 fputs_unfiltered ("\"\n", raw_stdout
);
1180 mi_out_rewind (uiout
);
1183 mi_out_rewind (uiout
);
1195 mi_execute_command (char *cmd
, int from_tty
)
1197 struct mi_parse
*command
;
1198 struct captured_mi_execute_command_args args
;
1199 struct ui_out
*saved_uiout
= uiout
;
1201 /* This is to handle EOF (^D). We just quit gdb. */
1202 /* FIXME: we should call some API function here. */
1204 quit_force (NULL
, from_tty
);
1206 command
= mi_parse (cmd
);
1208 if (command
!= NULL
)
1210 struct gdb_exception result
;
1214 command
->cmd_start
= (struct mi_timestamp
*)
1215 xmalloc (sizeof (struct mi_timestamp
));
1216 timestamp (command
->cmd_start
);
1219 /* FIXME: cagney/1999-11-04: Can this use of catch_exceptions either
1220 be pushed even further down or even eliminated? */
1221 args
.command
= command
;
1222 result
= catch_exception (uiout
, captured_mi_execute_command
, &args
,
1224 exception_print (gdb_stderr
, result
);
1226 if (args
.action
== EXECUTE_COMMAND_SUPRESS_PROMPT
)
1228 /* The command is executing synchronously. Bail out early
1229 suppressing the finished prompt. */
1230 mi_parse_free (command
);
1233 if (result
.reason
< 0)
1235 /* The command execution failed and error() was called
1237 fputs_unfiltered (command
->token
, raw_stdout
);
1238 fputs_unfiltered ("^error,msg=\"", raw_stdout
);
1239 if (result
.message
== NULL
)
1240 fputs_unfiltered ("unknown error", raw_stdout
);
1242 fputstr_unfiltered (result
.message
, '"', raw_stdout
);
1243 fputs_unfiltered ("\"\n", raw_stdout
);
1244 mi_out_rewind (uiout
);
1246 mi_parse_free (command
);
1249 fputs_unfiltered ("(gdb) \n", raw_stdout
);
1250 gdb_flush (raw_stdout
);
1251 /* print any buffered hook code */
1255 static enum mi_cmd_result
1256 mi_cmd_execute (struct mi_parse
*parse
)
1260 if (parse
->cmd
->argv_func
!= NULL
1261 || parse
->cmd
->args_func
!= NULL
)
1263 /* FIXME: We need to save the token because the command executed
1264 may be asynchronous and need to print the token again.
1265 In the future we can pass the token down to the func
1266 and get rid of the last_async_command */
1267 /* The problem here is to keep the token around when we launch
1268 the target, and we want to interrupt it later on. The
1269 interrupt command will have its own token, but when the
1270 target stops, we must display the token corresponding to the
1271 last execution command given. So we have another string where
1272 we copy the token (previous_async_command), if this was
1273 indeed the token of an execution command, and when we stop we
1274 print that one. This is possible because the interrupt
1275 command, when over, will copy that token back into the
1276 default token string (last_async_command). */
1278 if (target_executing
)
1280 if (!previous_async_command
)
1281 previous_async_command
= xstrdup (last_async_command
);
1282 if (strcmp (parse
->command
, "exec-interrupt"))
1284 fputs_unfiltered (parse
->token
, raw_stdout
);
1285 fputs_unfiltered ("^error,msg=\"", raw_stdout
);
1286 fputs_unfiltered ("Cannot execute command ", raw_stdout
);
1287 fputstr_unfiltered (parse
->command
, '"', raw_stdout
);
1288 fputs_unfiltered (" while target running", raw_stdout
);
1289 fputs_unfiltered ("\"\n", raw_stdout
);
1290 return MI_CMD_ERROR
;
1293 last_async_command
= xstrdup (parse
->token
);
1294 make_exec_cleanup (free_current_contents
, &last_async_command
);
1295 /* FIXME: DELETE THIS! */
1296 if (parse
->cmd
->args_func
!= NULL
)
1297 return parse
->cmd
->args_func (parse
->args
, 0 /*from_tty */ );
1298 return parse
->cmd
->argv_func (parse
->command
, parse
->argv
, parse
->argc
);
1300 else if (parse
->cmd
->cli
.cmd
!= 0)
1302 /* FIXME: DELETE THIS. */
1303 /* The operation is still implemented by a cli command */
1304 /* Must be a synchronous one */
1305 mi_execute_cli_command (parse
->cmd
->cli
.cmd
, parse
->cmd
->cli
.args_p
,
1311 /* FIXME: DELETE THIS. */
1312 fputs_unfiltered (parse
->token
, raw_stdout
);
1313 fputs_unfiltered ("^error,msg=\"", raw_stdout
);
1314 fputs_unfiltered ("Undefined mi command: ", raw_stdout
);
1315 fputstr_unfiltered (parse
->command
, '"', raw_stdout
);
1316 fputs_unfiltered (" (missing implementation)", raw_stdout
);
1317 fputs_unfiltered ("\"\n", raw_stdout
);
1318 return MI_CMD_ERROR
;
1322 /* FIXME: This is just a hack so we can get some extra commands going.
1323 We don't want to channel things through the CLI, but call libgdb directly */
1324 /* Use only for synchronous commands */
1327 mi_execute_cli_command (const char *cmd
, int args_p
, const char *args
)
1331 struct cleanup
*old_cleanups
;
1334 run
= xstrprintf ("%s %s", cmd
, args
);
1336 run
= xstrdup (cmd
);
1338 /* FIXME: gdb_???? */
1339 fprintf_unfiltered (gdb_stdout
, "cli=%s run=%s\n",
1341 old_cleanups
= make_cleanup (xfree
, run
);
1342 execute_command ( /*ui */ run
, 0 /*from_tty */ );
1343 do_cleanups (old_cleanups
);
1349 mi_execute_async_cli_command (char *mi
, char *args
, int from_tty
)
1351 struct cleanup
*old_cleanups
;
1355 if (target_can_async_p ())
1357 async_args
= (char *) xmalloc (strlen (args
) + 2);
1358 make_exec_cleanup (free
, async_args
);
1359 strcpy (async_args
, args
);
1360 strcat (async_args
, "&");
1361 run
= xstrprintf ("%s %s", mi
, async_args
);
1362 make_exec_cleanup (free
, run
);
1363 add_continuation (mi_exec_async_cli_cmd_continuation
, NULL
);
1364 old_cleanups
= NULL
;
1368 run
= xstrprintf ("%s %s", mi
, args
);
1369 old_cleanups
= make_cleanup (xfree
, run
);
1372 if (!target_can_async_p ())
1374 /* NOTE: For synchronous targets asynchronous behavour is faked by
1375 printing out the GDB prompt before we even try to execute the
1377 if (last_async_command
)
1378 fputs_unfiltered (last_async_command
, raw_stdout
);
1379 fputs_unfiltered ("^running\n", raw_stdout
);
1380 fputs_unfiltered ("(gdb) \n", raw_stdout
);
1381 gdb_flush (raw_stdout
);
1385 /* FIXME: cagney/1999-11-29: Printing this message before
1386 calling execute_command is wrong. It should only be printed
1387 once gdb has confirmed that it really has managed to send a
1388 run command to the target. */
1389 if (last_async_command
)
1390 fputs_unfiltered (last_async_command
, raw_stdout
);
1391 fputs_unfiltered ("^running\n", raw_stdout
);
1394 execute_command ( /*ui */ run
, 0 /*from_tty */ );
1396 if (!target_can_async_p ())
1398 /* Do this before doing any printing. It would appear that some
1399 print code leaves garbage around in the buffer. */
1400 do_cleanups (old_cleanups
);
1401 /* If the target was doing the operation synchronously we fake
1402 the stopped message. */
1403 if (last_async_command
)
1404 fputs_unfiltered (last_async_command
, raw_stdout
);
1405 fputs_unfiltered ("*stopped", raw_stdout
);
1406 mi_out_put (uiout
, raw_stdout
);
1407 mi_out_rewind (uiout
);
1409 print_diff_now (current_command_ts
);
1410 fputs_unfiltered ("\n", raw_stdout
);
1411 return MI_CMD_QUIET
;
1417 mi_exec_async_cli_cmd_continuation (struct continuation_arg
*arg
)
1419 if (last_async_command
)
1420 fputs_unfiltered (last_async_command
, raw_stdout
);
1421 fputs_unfiltered ("*stopped", raw_stdout
);
1422 mi_out_put (uiout
, raw_stdout
);
1423 fputs_unfiltered ("\n", raw_stdout
);
1424 fputs_unfiltered ("(gdb) \n", raw_stdout
);
1425 gdb_flush (raw_stdout
);
1426 do_exec_cleanups (ALL_CLEANUPS
);
1430 mi_load_progress (const char *section_name
,
1431 unsigned long sent_so_far
,
1432 unsigned long total_section
,
1433 unsigned long total_sent
,
1434 unsigned long grand_total
)
1436 struct timeval time_now
, delta
, update_threshold
;
1437 static struct timeval last_update
;
1438 static char *previous_sect_name
= NULL
;
1440 struct ui_out
*saved_uiout
;
1442 /* This function is called through deprecated_show_load_progress
1443 which means uiout may not be correct. Fix it for the duration
1444 of this function. */
1445 saved_uiout
= uiout
;
1447 if (current_interp_named_p (INTERP_MI
))
1448 uiout
= mi_out_new (2);
1449 else if (current_interp_named_p (INTERP_MI1
))
1450 uiout
= mi_out_new (1);
1454 update_threshold
.tv_sec
= 0;
1455 update_threshold
.tv_usec
= 500000;
1456 gettimeofday (&time_now
, NULL
);
1458 delta
.tv_usec
= time_now
.tv_usec
- last_update
.tv_usec
;
1459 delta
.tv_sec
= time_now
.tv_sec
- last_update
.tv_sec
;
1461 if (delta
.tv_usec
< 0)
1464 delta
.tv_usec
+= 1000000L;
1467 new_section
= (previous_sect_name
?
1468 strcmp (previous_sect_name
, section_name
) : 1);
1471 struct cleanup
*cleanup_tuple
;
1472 xfree (previous_sect_name
);
1473 previous_sect_name
= xstrdup (section_name
);
1475 if (last_async_command
)
1476 fputs_unfiltered (last_async_command
, raw_stdout
);
1477 fputs_unfiltered ("+download", raw_stdout
);
1478 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1479 ui_out_field_string (uiout
, "section", section_name
);
1480 ui_out_field_int (uiout
, "section-size", total_section
);
1481 ui_out_field_int (uiout
, "total-size", grand_total
);
1482 do_cleanups (cleanup_tuple
);
1483 mi_out_put (uiout
, raw_stdout
);
1484 fputs_unfiltered ("\n", raw_stdout
);
1485 gdb_flush (raw_stdout
);
1488 if (delta
.tv_sec
>= update_threshold
.tv_sec
&&
1489 delta
.tv_usec
>= update_threshold
.tv_usec
)
1491 struct cleanup
*cleanup_tuple
;
1492 last_update
.tv_sec
= time_now
.tv_sec
;
1493 last_update
.tv_usec
= time_now
.tv_usec
;
1494 if (last_async_command
)
1495 fputs_unfiltered (last_async_command
, raw_stdout
);
1496 fputs_unfiltered ("+download", raw_stdout
);
1497 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1498 ui_out_field_string (uiout
, "section", section_name
);
1499 ui_out_field_int (uiout
, "section-sent", sent_so_far
);
1500 ui_out_field_int (uiout
, "section-size", total_section
);
1501 ui_out_field_int (uiout
, "total-sent", total_sent
);
1502 ui_out_field_int (uiout
, "total-size", grand_total
);
1503 do_cleanups (cleanup_tuple
);
1504 mi_out_put (uiout
, raw_stdout
);
1505 fputs_unfiltered ("\n", raw_stdout
);
1506 gdb_flush (raw_stdout
);
1510 uiout
= saved_uiout
;
1514 mi_setup_architecture_data (void)
1516 old_regs
= xmalloc ((NUM_REGS
+ NUM_PSEUDO_REGS
) * MAX_REGISTER_SIZE
+ 1);
1517 memset (old_regs
, 0, (NUM_REGS
+ NUM_PSEUDO_REGS
) * MAX_REGISTER_SIZE
+ 1);
1521 _initialize_mi_main (void)
1523 DEPRECATED_REGISTER_GDBARCH_SWAP (old_regs
);
1524 deprecated_register_gdbarch_swap (NULL
, 0, mi_setup_architecture_data
);
1528 timestamp (struct mi_timestamp
*tv
)
1531 gettimeofday (&tv
->wallclock
, NULL
);
1532 #ifdef HAVE_GETRUSAGE
1533 getrusage (RUSAGE_SELF
, &rusage
);
1534 tv
->utime
.tv_sec
= rusage
.ru_utime
.tv_sec
;
1535 tv
->utime
.tv_usec
= rusage
.ru_utime
.tv_usec
;
1536 tv
->stime
.tv_sec
= rusage
.ru_stime
.tv_sec
;
1537 tv
->stime
.tv_usec
= rusage
.ru_stime
.tv_usec
;
1539 usec
= get_run_time ();
1540 tv
->utime
.tv_sec
= usec
/1000000L;
1541 tv
->utime
.tv_usec
= usec
- 1000000L*tv
->utime
.tv_sec
;
1542 tv
->stime
.tv_sec
= 0;
1543 tv
->stime
.tv_usec
= 0;
1548 print_diff_now (struct mi_timestamp
*start
)
1550 struct mi_timestamp now
;
1552 print_diff (start
, &now
);
1556 timeval_diff (struct timeval start
, struct timeval end
)
1558 return ((end
.tv_sec
- start
.tv_sec
) * 1000000L)
1559 + (end
.tv_usec
- start
.tv_usec
);
1563 print_diff (struct mi_timestamp
*start
, struct mi_timestamp
*end
)
1567 ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
1568 timeval_diff (start
->wallclock
, end
->wallclock
) / 1000000.0,
1569 timeval_diff (start
->utime
, end
->utime
) / 1000000.0,
1570 timeval_diff (start
->stime
, end
->stime
) / 1000000.0);