2 Copyright 2000, 2001 Free Software Foundation, Inc.
3 Contributed by Cygnus Solutions (a Red Hat company).
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
22 /* Work in progress */
27 #include "gdb_string.h"
29 #include "gdbthread.h"
32 #include "mi-getopt.h"
33 #include "mi-console.h"
36 #include "event-loop.h"
37 #include "event-top.h"
38 #include "gdbcore.h" /* for write_memory() */
39 #include "value.h" /* for write_register_bytes() */
44 /* Convenience macro for allocting typesafe memory. */
47 #define XMALLOC(TYPE) (TYPE*) xmalloc (sizeof (TYPE))
56 struct ui_file
*raw_stdout
;
58 /* The token of the last asynchronous command */
59 static char *last_async_command
;
60 static char *previous_async_command
;
61 static char *mi_error_message
;
62 static char *old_regs
;
64 extern void _initialize_mi_main (void);
65 static char *mi_input (char *);
66 static void mi_execute_command (char *cmd
, int from_tty
);
67 static enum mi_cmd_result
mi_cmd_execute (struct mi_parse
*parse
);
69 static void mi_execute_cli_command (const char *cli
, char *args
);
70 static enum mi_cmd_result
mi_execute_async_cli_command (char *mi
, char *args
, int from_tty
);
71 static void mi_execute_command_wrapper (char *cmd
);
73 void mi_exec_async_cli_cmd_continuation (struct continuation_arg
*arg
);
75 static int register_changed_p (int regnum
);
76 static int get_register (int regnum
, int format
);
77 static void mi_load_progress (const char *section_name
,
78 unsigned long sent_so_far
,
79 unsigned long total_section
,
80 unsigned long total_sent
,
81 unsigned long grand_total
);
84 /* FIXME: these should go in some .h file, but infcmd.c doesn't have a
85 corresponding .h file. These wrappers will be obsolete anyway, once
86 we pull the plug on the sanitization. */
87 extern void interrupt_target_command_wrapper (char *, int);
88 extern void return_command_wrapper (char *, int);
91 /* Command implementations. FIXME: Is this libgdb? No. This is the MI
92 layer that calls libgdb. Any operation used in the below should be
96 mi_cmd_gdb_exit (char *command
, char **argv
, int argc
)
98 /* We have to print everything right here because we never return */
99 if (last_async_command
)
100 fputs_unfiltered (last_async_command
, raw_stdout
);
101 fputs_unfiltered ("^exit\n", raw_stdout
);
102 mi_out_put (uiout
, raw_stdout
);
103 /* FIXME: The function called is not yet a formal libgdb function */
104 quit_force (NULL
, FROM_TTY
);
109 mi_cmd_exec_run (char *args
, int from_tty
)
111 /* FIXME: Should call a libgdb function, not a cli wrapper */
112 return mi_execute_async_cli_command ("run", args
, from_tty
);
116 mi_cmd_exec_next (char *args
, int from_tty
)
118 /* FIXME: Should call a libgdb function, not a cli wrapper */
119 return mi_execute_async_cli_command ("next", args
, from_tty
);
123 mi_cmd_exec_next_instruction (char *args
, int from_tty
)
125 /* FIXME: Should call a libgdb function, not a cli wrapper */
126 return mi_execute_async_cli_command ("nexti", args
, from_tty
);
130 mi_cmd_exec_step (char *args
, int from_tty
)
132 /* FIXME: Should call a libgdb function, not a cli wrapper */
133 return mi_execute_async_cli_command ("step", args
, from_tty
);
137 mi_cmd_exec_step_instruction (char *args
, int from_tty
)
139 /* FIXME: Should call a libgdb function, not a cli wrapper */
140 return mi_execute_async_cli_command ("stepi", args
, from_tty
);
144 mi_cmd_exec_finish (char *args
, int from_tty
)
146 /* FIXME: Should call a libgdb function, not a cli wrapper */
147 return mi_execute_async_cli_command ("finish", args
, from_tty
);
151 mi_cmd_exec_until (char *args
, int from_tty
)
153 /* FIXME: Should call a libgdb function, not a cli wrapper */
154 return mi_execute_async_cli_command ("until", args
, from_tty
);
158 mi_cmd_exec_return (char *args
, int from_tty
)
161 /* This command doesn't really execute the target, it just pops the
162 specified number of frames. */
164 /* Call return_command with from_tty argument equal to 0 so as to
165 avoid being queried. */
166 return_command_wrapper (args
, 0);
168 /* Call return_command with from_tty argument equal to 0 so as to
169 avoid being queried. */
170 return_command_wrapper (NULL
, 0);
172 /* Because we have called return_command with from_tty = 0, we need
173 to print the frame here. */
174 show_and_print_stack_frame (selected_frame
,
175 selected_frame_level
,
183 mi_cmd_exec_continue (char *args
, int from_tty
)
185 /* FIXME: Should call a libgdb function, not a cli wrapper */
186 return mi_execute_async_cli_command ("continue", args
, from_tty
);
189 /* Interrupt the execution of the target. Note how we must play around
190 with the token varialbes, in order to display the current token in
191 the result of the interrupt command, and the previous execution
192 token when the target finally stops. See comments in
195 mi_cmd_exec_interrupt (char *args
, int from_tty
)
198 if (!target_executing
)
200 xasprintf (&mi_error_message
,
201 "mi_cmd_exec_interrupt: Inferior not executing.");
204 interrupt_target_command_wrapper (args
, from_tty
);
205 if (last_async_command
)
206 fputs_unfiltered (last_async_command
, raw_stdout
);
207 fputs_unfiltered ("^done", raw_stdout
);
208 xfree (last_async_command
);
209 if (previous_async_command
)
210 last_async_command
= xstrdup (previous_async_command
);
211 xfree (previous_async_command
);
212 previous_async_command
= NULL
;
213 mi_out_put (uiout
, raw_stdout
);
214 mi_out_rewind (uiout
);
215 fputs_unfiltered ("\n", raw_stdout
);
221 mi_cmd_thread_select (char *command
, char **argv
, int argc
)
227 xasprintf (&mi_error_message
,
228 "mi_cmd_thread_select: USAGE: threadnum.");
232 rc
= gdb_thread_select (argv
[0]);
234 if (rc
== GDB_RC_FAIL
)
235 return MI_CMD_CAUGHT_ERROR
;
241 mi_cmd_thread_list_ids (char *command
, char **argv
, int argc
)
243 enum gdb_rc rc
= MI_CMD_DONE
;
247 xasprintf (&mi_error_message
,
248 "mi_cmd_thread_list_ids: No arguments required.");
253 rc
= gdb_list_thread_ids ();
256 if (rc
== GDB_RC_FAIL
)
257 return MI_CMD_CAUGHT_ERROR
;
263 mi_cmd_data_list_register_names (char *command
, char **argv
, int argc
)
268 /* Note that the test for a valid register must include checking the
269 REGISTER_NAME because NUM_REGS may be allocated for the union of
270 the register sets within a family of related processors. In this
271 case, some entries of REGISTER_NAME will change depending upon
272 the particular processor being debugged. */
274 numregs
= NUM_REGS
+ NUM_PSEUDO_REGS
;
276 ui_out_list_begin (uiout
, "register-names");
278 if (argc
== 0) /* No args, just do all the regs */
284 if (REGISTER_NAME (regnum
) == NULL
285 || *(REGISTER_NAME (regnum
)) == '\0')
286 ui_out_field_string (uiout
, NULL
, "");
288 ui_out_field_string (uiout
, NULL
, REGISTER_NAME (regnum
));
292 /* Else, list of register #s, just do listed regs */
293 for (i
= 0; i
< argc
; i
++)
295 regnum
= atoi (argv
[i
]);
296 if (regnum
< 0 || regnum
>= numregs
)
298 xasprintf (&mi_error_message
, "bad register number");
301 if (REGISTER_NAME (regnum
) == NULL
302 || *(REGISTER_NAME (regnum
)) == '\0')
303 ui_out_field_string (uiout
, NULL
, "");
305 ui_out_field_string (uiout
, NULL
, REGISTER_NAME (regnum
));
307 ui_out_list_end (uiout
);
312 mi_cmd_data_list_changed_registers (char *command
, char **argv
, int argc
)
314 int regnum
, numregs
, changed
;
317 /* Note that the test for a valid register must include checking the
318 REGISTER_NAME because NUM_REGS may be allocated for the union of
319 the register sets within a family of related processors. In this
320 case, some entries of REGISTER_NAME will change depending upon
321 the particular processor being debugged. */
325 ui_out_list_begin (uiout
, "changed-registers");
327 if (argc
== 0) /* No args, just do all the regs */
333 if (REGISTER_NAME (regnum
) == NULL
334 || *(REGISTER_NAME (regnum
)) == '\0')
336 changed
= register_changed_p (regnum
);
339 xasprintf (&mi_error_message
,
340 "mi_cmd_data_list_changed_registers: Unable to read register contents.");
344 ui_out_field_int (uiout
, NULL
, regnum
);
348 /* Else, list of register #s, just do listed regs */
349 for (i
= 0; i
< argc
; i
++)
351 regnum
= atoi (argv
[i
]);
355 && REGISTER_NAME (regnum
) != NULL
356 && *REGISTER_NAME (regnum
) != '\000')
358 changed
= register_changed_p (regnum
);
361 xasprintf (&mi_error_message
,
362 "mi_cmd_data_list_register_change: Unable to read register contents.");
366 ui_out_field_int (uiout
, NULL
, regnum
);
370 xasprintf (&mi_error_message
, "bad register number");
374 ui_out_list_end (uiout
);
379 register_changed_p (int regnum
)
381 char raw_buffer
[MAX_REGISTER_RAW_SIZE
];
383 if (read_relative_register_raw_bytes (regnum
, raw_buffer
))
386 if (memcmp (&old_regs
[REGISTER_BYTE (regnum
)], raw_buffer
,
387 REGISTER_RAW_SIZE (regnum
)) == 0)
390 /* Found a changed register. Return 1. */
392 memcpy (&old_regs
[REGISTER_BYTE (regnum
)], raw_buffer
,
393 REGISTER_RAW_SIZE (regnum
));
398 /* Return a list of register number and value pairs. The valid
399 arguments expected are: a letter indicating the format in which to
400 display the registers contents. This can be one of: x (hexadecimal), d
401 (decimal), N (natural), t (binary), o (octal), r (raw). After the
402 format argumetn there can be a sequence of numbers, indicating which
403 registers to fetch the content of. If the format is the only argument,
404 a list of all the registers with their values is returned. */
406 mi_cmd_data_list_register_values (char *command
, char **argv
, int argc
)
408 int regnum
, numregs
, format
, result
;
411 /* Note that the test for a valid register must include checking the
412 REGISTER_NAME because NUM_REGS may be allocated for the union of
413 the register sets within a family of related processors. In this
414 case, some entries of REGISTER_NAME will change depending upon
415 the particular processor being debugged. */
421 xasprintf (&mi_error_message
,
422 "mi_cmd_data_list_register_values: Usage: -data-list-register-values <format> [<regnum1>...<regnumN>]");
426 format
= (int) argv
[0][0];
428 if (!target_has_registers
)
430 xasprintf (&mi_error_message
,
431 "mi_cmd_data_list_register_values: No registers.");
435 ui_out_list_begin (uiout
, "register-values");
437 if (argc
== 1) /* No args, beside the format: do all the regs */
443 if (REGISTER_NAME (regnum
) == NULL
444 || *(REGISTER_NAME (regnum
)) == '\0')
446 ui_out_tuple_begin (uiout
, NULL
);
447 ui_out_field_int (uiout
, "number", regnum
);
448 result
= get_register (regnum
, format
);
451 ui_out_tuple_end (uiout
);
455 /* Else, list of register #s, just do listed regs */
456 for (i
= 1; i
< argc
; i
++)
458 regnum
= atoi (argv
[i
]);
462 && REGISTER_NAME (regnum
) != NULL
463 && *REGISTER_NAME (regnum
) != '\000')
465 ui_out_tuple_begin (uiout
, NULL
);
466 ui_out_field_int (uiout
, "number", regnum
);
467 result
= get_register (regnum
, format
);
470 ui_out_tuple_end (uiout
);
474 xasprintf (&mi_error_message
, "bad register number");
478 ui_out_list_end (uiout
);
482 /* Output one register's contents in the desired format. */
484 get_register (int regnum
, int format
)
486 char raw_buffer
[MAX_REGISTER_RAW_SIZE
];
487 char virtual_buffer
[MAX_REGISTER_VIRTUAL_SIZE
];
489 static struct ui_stream
*stb
= NULL
;
491 stb
= ui_out_stream_new (uiout
);
496 /* read_relative_register_raw_bytes returns a virtual frame pointer
497 (FRAME_FP (selected_frame)) if regnum == FP_REGNUM instead
498 of the real contents of the register. To get around this,
499 use get_saved_register instead. */
500 get_saved_register (raw_buffer
, &optim
, (CORE_ADDR
*) NULL
, selected_frame
,
501 regnum
, (enum lval_type
*) NULL
);
504 xasprintf (&mi_error_message
, "Optimized out");
508 /* Convert raw data to virtual format if necessary. */
510 if (REGISTER_CONVERTIBLE (regnum
))
512 REGISTER_CONVERT_TO_VIRTUAL (regnum
, REGISTER_VIRTUAL_TYPE (regnum
),
513 raw_buffer
, virtual_buffer
);
516 memcpy (virtual_buffer
, raw_buffer
, REGISTER_VIRTUAL_SIZE (regnum
));
521 char *ptr
, buf
[1024];
525 for (j
= 0; j
< REGISTER_RAW_SIZE (regnum
); j
++)
527 register int idx
= TARGET_BYTE_ORDER
== BIG_ENDIAN
? j
528 : REGISTER_RAW_SIZE (regnum
) - 1 - j
;
529 sprintf (ptr
, "%02x", (unsigned char) raw_buffer
[idx
]);
532 ui_out_field_string (uiout
, "value", buf
);
533 /*fputs_filtered (buf, gdb_stdout); */
537 val_print (REGISTER_VIRTUAL_TYPE (regnum
), virtual_buffer
, 0, 0,
538 stb
->stream
, format
, 1, 0, Val_pretty_default
);
539 ui_out_field_stream (uiout
, "value", stb
);
540 ui_out_stream_delete (stb
);
545 /* Write given values into registers. The registers and values are
546 given as pairs. The corresponding MI command is
547 -data-write-register-values <format> [<regnum1> <value1>...<regnumN> <valueN>]*/
549 mi_cmd_data_write_register_values (char *command
, char **argv
, int argc
)
558 /* Note that the test for a valid register must include checking the
559 REGISTER_NAME because NUM_REGS may be allocated for the union of
560 the register sets within a family of related processors. In this
561 case, some entries of REGISTER_NAME will change depending upon
562 the particular processor being debugged. */
568 xasprintf (&mi_error_message
,
569 "mi_cmd_data_write_register_values: Usage: -data-write-register-values <format> [<regnum1> <value1>...<regnumN> <valueN>]");
573 format
= (int) argv
[0][0];
575 if (!target_has_registers
)
577 xasprintf (&mi_error_message
,
578 "mi_cmd_data_write_register_values: No registers.");
584 xasprintf (&mi_error_message
,
585 "mi_cmd_data_write_register_values: No regs and values specified.");
591 xasprintf (&mi_error_message
,
592 "mi_cmd_data_write_register_values: Regs and vals are not in pairs.");
596 for (i
= 1; i
< argc
; i
= i
+ 2)
598 regnum
= atoi (argv
[i
]);
602 && REGISTER_NAME (regnum
) != NULL
603 && *REGISTER_NAME (regnum
) != '\000')
605 /* Get the value as a number */
606 value
= parse_and_eval_address (argv
[i
+ 1]);
607 /* Get the value into an array */
608 buffer
= (unsigned char *) xmalloc (REGISTER_SIZE
);
609 store_signed_integer (buffer
, REGISTER_SIZE
, value
);
611 write_register_bytes (REGISTER_BYTE (regnum
), buffer
, REGISTER_RAW_SIZE (regnum
));
612 /* write_register_bytes (REGISTER_BYTE (regnum), buffer, REGISTER_SIZE); */
616 xasprintf (&mi_error_message
, "bad register number");
624 /*This is commented out because we decided it was not useful. I leave
625 it, just in case. ezannoni:1999-12-08 */
627 /* Assign a value to a variable. The expression argument must be in
628 the form A=2 or "A = 2" (I.e. if there are spaces it needs to be
631 mi_cmd_data_assign (char *command
, char **argv
, int argc
)
633 struct expression
*expr
;
634 struct cleanup
*old_chain
;
638 xasprintf (&mi_error_message
,
639 "mi_cmd_data_assign: Usage: -data-assign expression");
643 /* NOTE what follows is a clone of set_command(). FIXME: ezannoni
644 01-12-1999: Need to decide what to do with this for libgdb purposes. */
646 expr
= parse_expression (argv
[0]);
647 old_chain
= make_cleanup (free_current_contents
, &expr
);
648 evaluate_expression (expr
);
649 do_cleanups (old_chain
);
654 /* Evaluate the value of the argument. The argument is an
655 expression. If the expression contains spaces it needs to be
656 included in double quotes. */
658 mi_cmd_data_evaluate_expression (char *command
, char **argv
, int argc
)
660 struct expression
*expr
;
661 struct cleanup
*old_chain
= NULL
;
663 struct ui_stream
*stb
= NULL
;
665 stb
= ui_out_stream_new (uiout
);
669 xasprintf (&mi_error_message
,
670 "mi_cmd_data_evaluate_expression: Usage: -data-evaluate-expression expression");
674 expr
= parse_expression (argv
[0]);
676 old_chain
= make_cleanup (free_current_contents
, &expr
);
678 val
= evaluate_expression (expr
);
680 /* Print the result of the expression evaluation. */
681 val_print (VALUE_TYPE (val
), VALUE_CONTENTS (val
),
682 VALUE_EMBEDDED_OFFSET (val
), VALUE_ADDRESS (val
),
683 stb
->stream
, 0, 0, 0, 0);
685 ui_out_field_stream (uiout
, "value", stb
);
686 ui_out_stream_delete (stb
);
688 do_cleanups (old_chain
);
694 mi_cmd_target_download (char *args
, int from_tty
)
697 struct cleanup
*old_cleanups
= NULL
;
699 xasprintf (&run
, "load %s", args
);
700 old_cleanups
= make_cleanup (xfree
, run
);
701 execute_command (run
, from_tty
);
703 do_cleanups (old_cleanups
);
707 /* Connect to the remote target. */
709 mi_cmd_target_select (char *args
, int from_tty
)
712 struct cleanup
*old_cleanups
= NULL
;
714 xasprintf (&run
, "target %s", args
);
715 old_cleanups
= make_cleanup (xfree
, run
);
717 /* target-select is always synchronous. once the call has returned
718 we know that we are connected. */
719 /* NOTE: At present all targets that are connected are also
720 (implicitly) talking to a halted target. In the future this may
722 execute_command (run
, from_tty
);
724 do_cleanups (old_cleanups
);
726 /* Issue the completion message here. */
727 if (last_async_command
)
728 fputs_unfiltered (last_async_command
, raw_stdout
);
729 fputs_unfiltered ("^connected", raw_stdout
);
730 mi_out_put (uiout
, raw_stdout
);
731 mi_out_rewind (uiout
);
732 fputs_unfiltered ("\n", raw_stdout
);
733 do_exec_cleanups (ALL_CLEANUPS
);
739 ADDR: start address of data to be dumped.
740 WORD-FORMAT: a char indicating format for the ``word''. See
742 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes
743 NR_ROW: Number of rows.
744 NR_COL: The number of colums (words per row).
745 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
746 ASCHAR for unprintable characters.
748 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
749 displayes them. Returns:
751 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
754 The number of bytes read is SIZE*ROW*COL. */
757 mi_cmd_data_read_memory (char *command
, char **argv
, int argc
)
759 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
765 struct type
*word_type
;
778 static struct mi_opt opts
[] =
780 {"o", OFFSET_OPT
, 1},
786 int opt
= mi_getopt ("mi_cmd_data_read_memory", argc
, argv
, opts
,
790 switch ((enum opt
) opt
)
793 offset
= atol (optarg
);
800 if (argc
< 5 || argc
> 6)
802 xasprintf (&mi_error_message
,
803 "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 xasprintf (&mi_error_message
,
843 "mi_cmd_data_read_memory: invalid number of rows.");
846 /* number of bytes per row. */
847 nr_cols
= atol (argv
[4]);
850 xasprintf (&mi_error_message
,
851 "mi_cmd_data_read_memory: invalid number of columns.");
853 /* The un-printable character when printing ascii. */
859 /* create a buffer and read it in. */
860 total_bytes
= word_size
* nr_rows
* nr_cols
;
861 mbuf
= xcalloc (total_bytes
, 1);
862 make_cleanup (xfree
, mbuf
);
865 xasprintf (&mi_error_message
,
866 "mi_cmd_data_read_memory: out of memory.");
870 while (nr_bytes
< total_bytes
)
873 long num
= target_read_memory_partial (addr
+ nr_bytes
, mbuf
+ nr_bytes
,
874 total_bytes
- nr_bytes
,
881 /* output the header information. */
882 ui_out_field_core_addr (uiout
, "addr", addr
);
883 ui_out_field_int (uiout
, "nr-bytes", nr_bytes
);
884 ui_out_field_int (uiout
, "total-bytes", total_bytes
);
885 ui_out_field_core_addr (uiout
, "next-row", addr
+ word_size
* nr_cols
);
886 ui_out_field_core_addr (uiout
, "prev-row", addr
- word_size
* nr_cols
);
887 ui_out_field_core_addr (uiout
, "next-page", addr
+ total_bytes
);
888 ui_out_field_core_addr (uiout
, "prev-page", addr
- total_bytes
);
890 /* Build the result as a two dimentional table. */
892 struct ui_stream
*stream
= ui_out_stream_new (uiout
);
895 ui_out_list_begin (uiout
, "memory");
896 for (row
= 0, row_byte
= 0;
898 row
++, row_byte
+= nr_cols
* word_size
)
902 ui_out_tuple_begin (uiout
, NULL
);
903 ui_out_field_core_addr (uiout
, "addr", addr
+ row_byte
);
904 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr + row_byte); */
905 ui_out_list_begin (uiout
, "data");
906 for (col
= 0, col_byte
= row_byte
;
908 col
++, col_byte
+= word_size
)
910 if (col_byte
+ word_size
> nr_bytes
)
912 ui_out_field_string (uiout
, NULL
, "N/A");
916 ui_file_rewind (stream
->stream
);
917 print_scalar_formatted (mbuf
+ col_byte
, word_type
, word_format
,
918 word_asize
, stream
->stream
);
919 ui_out_field_stream (uiout
, NULL
, stream
);
922 ui_out_list_end (uiout
);
926 ui_file_rewind (stream
->stream
);
927 for (byte
= row_byte
; byte
< row_byte
+ word_size
* nr_cols
; byte
++)
929 if (byte
>= nr_bytes
)
931 fputc_unfiltered ('X', stream
->stream
);
933 else if (mbuf
[byte
] < 32 || mbuf
[byte
] > 126)
935 fputc_unfiltered (aschar
, stream
->stream
);
938 fputc_unfiltered (mbuf
[byte
], stream
->stream
);
940 ui_out_field_stream (uiout
, "ascii", stream
);
942 ui_out_tuple_end (uiout
);
944 ui_out_stream_delete (stream
);
945 ui_out_list_end (uiout
);
947 do_cleanups (cleanups
);
951 /* DATA-MEMORY-WRITE:
953 COLUMN_OFFSET: optional argument. Must be preceeded by '-o'. The
954 offset from the beginning of the memory grid row where the cell to
956 ADDR: start address of the row in the memory grid where the memory
957 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
958 the location to write to.
959 FORMAT: a char indicating format for the ``word''. See
961 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
962 VALUE: value to be written into the memory address.
964 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
968 mi_cmd_data_write_memory (char *command
, char **argv
, int argc
)
973 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
974 enough when using a compiler other than GCC. */
976 unsigned char *buffer
;
984 static struct mi_opt opts
[] =
986 {"o", OFFSET_OPT
, 1},
992 int opt
= mi_getopt ("mi_cmd_data_write_memory", argc
, argv
, opts
,
996 switch ((enum opt
) opt
)
999 offset
= atol (optarg
);
1008 xasprintf (&mi_error_message
,
1009 "mi_cmd_data_write_memory: Usage: [-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE.");
1010 return MI_CMD_ERROR
;
1013 /* Extract all the arguments. */
1014 /* Start address of the memory dump. */
1015 addr
= parse_and_eval_address (argv
[0]);
1016 /* The format character to use when displaying a memory word. See
1017 the ``x'' command. */
1018 word_format
= argv
[1][0];
1019 /* The size of the memory word. */
1020 word_size
= atol (argv
[2]);
1022 /* Calculate the real address of the write destination. */
1023 addr
+= (offset
* word_size
);
1025 /* Get the value as a number */
1026 value
= parse_and_eval_address (argv
[3]);
1027 /* Get the value into an array */
1028 buffer
= (unsigned char *) xmalloc (word_size
);
1029 store_signed_integer (buffer
, word_size
, value
);
1030 /* Write it down to memory */
1031 write_memory (addr
, buffer
, word_size
);
1036 /* Execute a command within a safe environment. Return >0 for
1037 ok. Return <0 for supress prompt. Return 0 to have the error
1038 extracted from error_last_message(). */
1041 captured_mi_execute_command (void *data
)
1043 struct mi_parse
*context
= data
;
1044 enum mi_cmd_result rc
;
1046 switch (context
->op
)
1050 /* A MI command was read from the input stream */
1052 /* FIXME: gdb_???? */
1053 fprintf_unfiltered (raw_stdout
, " token=`%s' command=`%s' args=`%s'\n",
1054 context
->token
, context
->command
, context
->args
);
1055 /* FIXME: cagney/1999-09-25: Rather than this convoluted
1056 condition expression, each function should return an
1057 indication of what action is required and then switch on
1059 rc
= mi_cmd_execute (context
);
1060 if (!target_can_async_p () || !target_executing
)
1062 /* print the result if there were no errors */
1063 if (rc
== MI_CMD_DONE
)
1065 fputs_unfiltered (context
->token
, raw_stdout
);
1066 fputs_unfiltered ("^done", raw_stdout
);
1067 mi_out_put (uiout
, raw_stdout
);
1068 mi_out_rewind (uiout
);
1069 fputs_unfiltered ("\n", raw_stdout
);
1071 else if (rc
== MI_CMD_ERROR
)
1073 if (mi_error_message
)
1075 fputs_unfiltered (context
->token
, raw_stdout
);
1076 fputs_unfiltered ("^error,msg=\"", raw_stdout
);
1077 fputstr_unfiltered (mi_error_message
, '"', raw_stdout
);
1078 xfree (mi_error_message
);
1079 fputs_unfiltered ("\"\n", raw_stdout
);
1081 mi_out_rewind (uiout
);
1083 else if (rc
== MI_CMD_CAUGHT_ERROR
)
1085 mi_out_rewind (uiout
);
1089 mi_out_rewind (uiout
);
1091 else if (sync_execution
)
1092 /* Don't print the prompt. We are executing the target in
1093 synchronous mode. */
1098 /* A CLI command was read from the input stream */
1099 /* This will be removed as soon as we have a complete set of
1101 /* echo the command on the console. */
1102 fprintf_unfiltered (gdb_stdlog
, "%s\n", context
->command
);
1103 /* FIXME: If the command string has something that looks like
1104 a format spec (e.g. %s) we will get a core dump */
1105 mi_execute_cli_command ("%s", context
->command
);
1106 /* print the result */
1107 /* FIXME: Check for errors here. */
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 fputs_unfiltered ("\n", raw_stdout
);
1121 mi_execute_command (char *cmd
, int from_tty
)
1123 struct mi_parse
*command
;
1125 /* This is to handle EOF (^D). We just quit gdb. */
1126 /* FIXME: we should call some API function here. */
1128 quit_force (NULL
, from_tty
);
1130 command
= mi_parse (cmd
);
1132 if (command
!= NULL
)
1134 /* FIXME: cagney/1999-11-04: Can this use of catch_errors either
1135 be pushed even further down or even eliminated? */
1136 int rc
= catch_errors (captured_mi_execute_command
, command
, "",
1140 /* The command is executing synchronously. Bail out early
1141 suppressing the finished prompt. */
1142 mi_parse_free (command
);
1147 char *msg
= error_last_message ();
1148 struct cleanup
*cleanup
= make_cleanup (xfree
, msg
);
1149 /* The command execution failed and error() was called
1151 fputs_unfiltered (command
->token
, raw_stdout
);
1152 fputs_unfiltered ("^error,msg=\"", raw_stdout
);
1153 fputstr_unfiltered (msg
, '"', raw_stdout
);
1154 fputs_unfiltered ("\"\n", raw_stdout
);
1156 mi_parse_free (command
);
1159 gdb_flush (raw_stdout
);
1160 fputs_unfiltered ("(gdb) \n", raw_stdout
);
1161 /* print any buffered hook code */
1165 static enum mi_cmd_result
1166 mi_cmd_execute (struct mi_parse
*parse
)
1168 if (parse
->cmd
->argv_func
!= NULL
1169 || parse
->cmd
->args_func
!= NULL
)
1171 /* FIXME: We need to save the token because the command executed
1172 may be asynchronous and need to print the token again.
1173 In the future we can pass the token down to the func
1174 and get rid of the last_async_command */
1175 /* The problem here is to keep the token around when we launch
1176 the target, and we want to interrupt it later on. The
1177 interrupt command will have its own token, but when the
1178 target stops, we must display the token corresponding to the
1179 last execution command given. So we have another string where
1180 we copy the token (previous_async_command), if this was
1181 indeed the token of an execution command, and when we stop we
1182 print that one. This is possible because the interrupt
1183 command, when over, will copy that token back into the
1184 default token string (last_async_command). */
1186 if (target_executing
)
1188 if (!previous_async_command
)
1189 previous_async_command
= xstrdup (last_async_command
);
1190 if (strcmp (parse
->command
, "exec-interrupt"))
1192 fputs_unfiltered (parse
->token
, raw_stdout
);
1193 fputs_unfiltered ("^error,msg=\"", raw_stdout
);
1194 fputs_unfiltered ("Cannot execute command ", raw_stdout
);
1195 fputstr_unfiltered (parse
->command
, '"', raw_stdout
);
1196 fputs_unfiltered (" while target running", raw_stdout
);
1197 fputs_unfiltered ("\"\n", raw_stdout
);
1198 return MI_CMD_ERROR
;
1201 last_async_command
= xstrdup (parse
->token
);
1202 make_exec_cleanup (free_current_contents
, &last_async_command
);
1203 /* FIXME: DELETE THIS! */
1204 if (parse
->cmd
->args_func
!= NULL
)
1205 return parse
->cmd
->args_func (parse
->args
, 0 /*from_tty */ );
1206 return parse
->cmd
->argv_func (parse
->command
, parse
->argv
, parse
->argc
);
1208 else if (parse
->cmd
->cli
!= 0)
1210 /* FIXME: DELETE THIS. */
1211 /* The operation is still implemented by a cli command */
1212 /* Must be a synchronous one */
1213 mi_execute_cli_command (parse
->cmd
->cli
, parse
->args
);
1218 /* FIXME: DELETE THIS. */
1219 fputs_unfiltered (parse
->token
, raw_stdout
);
1220 fputs_unfiltered ("^error,msg=\"", raw_stdout
);
1221 fputs_unfiltered ("Undefined mi command: ", raw_stdout
);
1222 fputstr_unfiltered (parse
->command
, '"', raw_stdout
);
1223 fputs_unfiltered (" (missing implementation)", raw_stdout
);
1224 fputs_unfiltered ("\"\n", raw_stdout
);
1225 return MI_CMD_ERROR
;
1230 mi_execute_command_wrapper (char *cmd
)
1232 mi_execute_command (cmd
, stdin
== instream
);
1235 /* FIXME: This is just a hack so we can get some extra commands going.
1236 We don't want to channel things through the CLI, but call libgdb directly */
1237 /* Use only for synchronous commands */
1240 mi_execute_cli_command (const char *cli
, char *args
)
1244 struct cleanup
*old_cleanups
;
1246 xasprintf (&run
, cli
, args
);
1248 /* FIXME: gdb_???? */
1249 fprintf_unfiltered (gdb_stdout
, "cli=%s run=%s\n",
1251 old_cleanups
= make_cleanup (xfree
, run
);
1252 execute_command ( /*ui */ run
, 0 /*from_tty */ );
1253 do_cleanups (old_cleanups
);
1259 mi_execute_async_cli_command (char *mi
, char *args
, int from_tty
)
1261 struct cleanup
*old_cleanups
;
1265 if (target_can_async_p ())
1267 async_args
= (char *) xmalloc (strlen (args
) + 2);
1268 make_exec_cleanup (free
, async_args
);
1269 strcpy (async_args
, args
);
1270 strcat (async_args
, "&");
1271 xasprintf (&run
, "%s %s", mi
, async_args
);
1272 make_exec_cleanup (free
, run
);
1273 add_continuation (mi_exec_async_cli_cmd_continuation
, NULL
);
1274 old_cleanups
= NULL
;
1278 xasprintf (&run
, "%s %s", mi
, args
);
1279 old_cleanups
= make_cleanup (xfree
, run
);
1282 if (!target_can_async_p ())
1284 /* NOTE: For synchronous targets asynchronous behavour is faked by
1285 printing out the GDB prompt before we even try to execute the
1287 if (last_async_command
)
1288 fputs_unfiltered (last_async_command
, raw_stdout
);
1289 fputs_unfiltered ("^running\n", raw_stdout
);
1290 fputs_unfiltered ("(gdb) \n", raw_stdout
);
1294 /* FIXME: cagney/1999-11-29: Printing this message before
1295 calling execute_command is wrong. It should only be printed
1296 once gdb has confirmed that it really has managed to send a
1297 run command to the target. */
1298 if (last_async_command
)
1299 fputs_unfiltered (last_async_command
, raw_stdout
);
1300 fputs_unfiltered ("^running\n", raw_stdout
);
1303 execute_command ( /*ui */ run
, 0 /*from_tty */ );
1305 if (!target_can_async_p ())
1307 /* Do this before doing any printing. It would appear that some
1308 print code leaves garbage around in the buffer. */
1309 do_cleanups (old_cleanups
);
1310 /* If the target was doing the operation synchronously we fake
1311 the stopped message. */
1312 if (last_async_command
)
1313 fputs_unfiltered (last_async_command
, raw_stdout
);
1314 fputs_unfiltered ("*stopped", raw_stdout
);
1315 mi_out_put (uiout
, raw_stdout
);
1316 mi_out_rewind (uiout
);
1317 fputs_unfiltered ("\n", raw_stdout
);
1318 return MI_CMD_QUIET
;
1324 mi_exec_async_cli_cmd_continuation (struct continuation_arg
*arg
)
1326 if (last_async_command
)
1327 fputs_unfiltered (last_async_command
, raw_stdout
);
1328 fputs_unfiltered ("*stopped", raw_stdout
);
1329 mi_out_put (uiout
, raw_stdout
);
1330 fputs_unfiltered ("\n", raw_stdout
);
1331 fputs_unfiltered ("(gdb) \n", raw_stdout
);
1332 do_exec_cleanups (ALL_CLEANUPS
);
1336 mi_input (char *buf
)
1338 return gdb_readline (NULL
);
1342 mi_load_progress (const char *section_name
,
1343 unsigned long sent_so_far
,
1344 unsigned long total_section
,
1345 unsigned long total_sent
,
1346 unsigned long grand_total
)
1348 struct timeval time_now
, delta
, update_threshold
;
1349 static struct timeval last_update
;
1350 static char *previous_sect_name
= NULL
;
1353 if (!interpreter_p
|| strncmp (interpreter_p
, "mi", 2) != 0)
1356 update_threshold
.tv_sec
= 0;
1357 update_threshold
.tv_usec
= 500000;
1358 gettimeofday (&time_now
, NULL
);
1360 delta
.tv_usec
= time_now
.tv_usec
- last_update
.tv_usec
;
1361 delta
.tv_sec
= time_now
.tv_sec
- last_update
.tv_sec
;
1363 if (delta
.tv_usec
< 0)
1366 delta
.tv_usec
+= 1000000;
1369 new_section
= (previous_sect_name
?
1370 strcmp (previous_sect_name
, section_name
) : 1);
1373 xfree (previous_sect_name
);
1374 previous_sect_name
= xstrdup (section_name
);
1376 if (last_async_command
)
1377 fputs_unfiltered (last_async_command
, raw_stdout
);
1378 fputs_unfiltered ("+download", raw_stdout
);
1379 ui_out_tuple_begin (uiout
, NULL
);
1380 ui_out_field_string (uiout
, "section", section_name
);
1381 ui_out_field_int (uiout
, "section-size", total_section
);
1382 ui_out_field_int (uiout
, "total-size", grand_total
);
1383 ui_out_tuple_end (uiout
);
1384 mi_out_put (uiout
, raw_stdout
);
1385 fputs_unfiltered ("\n", raw_stdout
);
1386 gdb_flush (raw_stdout
);
1389 if (delta
.tv_sec
>= update_threshold
.tv_sec
&&
1390 delta
.tv_usec
>= update_threshold
.tv_usec
)
1392 last_update
.tv_sec
= time_now
.tv_sec
;
1393 last_update
.tv_usec
= time_now
.tv_usec
;
1394 if (last_async_command
)
1395 fputs_unfiltered (last_async_command
, raw_stdout
);
1396 fputs_unfiltered ("+download", raw_stdout
);
1397 ui_out_tuple_begin (uiout
, NULL
);
1398 ui_out_field_string (uiout
, "section", section_name
);
1399 ui_out_field_int (uiout
, "section-sent", sent_so_far
);
1400 ui_out_field_int (uiout
, "section-size", total_section
);
1401 ui_out_field_int (uiout
, "total-sent", total_sent
);
1402 ui_out_field_int (uiout
, "total-size", grand_total
);
1403 ui_out_tuple_end (uiout
);
1404 mi_out_put (uiout
, raw_stdout
);
1405 fputs_unfiltered ("\n", raw_stdout
);
1406 gdb_flush (raw_stdout
);
1411 mi_command_loop (int mi_version
)
1413 /* HACK: Force stdout/stderr to point at the console. This avoids
1414 any potential side effects caused by legacy code that is still
1415 using the TUI / fputs_unfiltered_hook */
1416 raw_stdout
= stdio_fileopen (stdout
);
1417 /* Route normal output through the MIx */
1418 gdb_stdout
= mi_console_file_new (raw_stdout
, "~");
1419 /* Route error and log output through the MI */
1420 gdb_stderr
= mi_console_file_new (raw_stdout
, "&");
1421 gdb_stdlog
= gdb_stderr
;
1422 /* Route target output through the MI. */
1423 gdb_stdtarg
= mi_console_file_new (raw_stdout
, "@");
1425 /* HACK: Poke the ui_out table directly. Should we be creating a
1426 mi_out object wired up to the above gdb_stdout / gdb_stderr? */
1427 uiout
= mi_out_new (mi_version
);
1429 /* HACK: Override any other interpreter hooks. We need to create a
1430 real event table and pass in that. */
1432 /* command_loop_hook = 0; */
1433 print_frame_info_listing_hook
= 0;
1436 create_breakpoint_hook
= 0;
1437 delete_breakpoint_hook
= 0;
1438 modify_breakpoint_hook
= 0;
1439 interactive_hook
= 0;
1440 registers_changed_hook
= 0;
1441 readline_begin_hook
= 0;
1443 readline_end_hook
= 0;
1444 register_changed_hook
= 0;
1445 memory_changed_hook
= 0;
1447 target_wait_hook
= 0;
1448 call_command_hook
= 0;
1450 error_begin_hook
= 0;
1451 show_load_progress
= mi_load_progress
;
1453 /* Turn off 8 bit strings in quoted output. Any character with the
1454 high bit set is printed using C's octal format. */
1455 sevenbit_strings
= 1;
1457 /* Tell the world that we're alive */
1458 fputs_unfiltered ("(gdb) \n", raw_stdout
);
1461 simplified_command_loop (mi_input
, mi_execute_command
);
1463 start_event_loop ();
1467 mi0_command_loop (void)
1469 mi_command_loop (0);
1473 mi1_command_loop (void)
1475 mi_command_loop (1);
1479 setup_architecture_data (void)
1481 /* don't trust REGISTER_BYTES to be zero. */
1482 old_regs
= xmalloc (REGISTER_BYTES
+ 1);
1483 memset (old_regs
, 0, REGISTER_BYTES
+ 1);
1487 mi_init_ui (char *arg0
)
1489 /* Eventually this will contain code that takes control of the
1494 _initialize_mi_main (void)
1496 if (interpreter_p
== NULL
)
1499 /* If we're _the_ interpreter, take control. */
1500 if (strcmp (interpreter_p
, "mi0") == 0)
1501 command_loop_hook
= mi0_command_loop
;
1502 else if (strcmp (interpreter_p
, "mi") == 0
1503 || strcmp (interpreter_p
, "mi1") == 0)
1504 command_loop_hook
= mi1_command_loop
;
1508 init_ui_hook
= mi_init_ui
;
1509 setup_architecture_data ();
1510 register_gdbarch_swap (&old_regs
, sizeof (old_regs
), NULL
);
1511 register_gdbarch_swap (NULL
, 0, setup_architecture_data
);
1514 /* These overwrite some of the initialization done in
1515 _intialize_event_loop. */
1516 call_readline
= gdb_readline2
;
1517 input_handler
= mi_execute_command_wrapper
;
1518 add_file_handler (input_fd
, stdin_event_handler
, 0);
1519 async_command_editing_p
= 0;
1521 /* FIXME: Should we notify main that we are here as a possible