2 Copyright (C) 2000, 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() */
43 /* Convenience macro for allocting typesafe memory. */
46 #define XMALLOC(TYPE) (TYPE*) xmalloc (sizeof (TYPE))
55 struct ui_file
*raw_stdout
;
57 /* The token of the last asynchronous command */
58 static char *last_async_command
;
59 static char *previous_async_command
;
60 static char *mi_error_message
;
61 static char *old_regs
;
63 extern void _initialize_mi_main (void);
64 static char *mi_input (char *);
65 static void mi_execute_command (char *cmd
, int from_tty
);
66 static enum mi_cmd_result
mi_cmd_execute (struct mi_parse
*parse
);
68 static void mi_execute_cli_command (const char *cli
, char *args
);
69 static enum mi_cmd_result
mi_execute_async_cli_command (char *mi
, char *args
, int from_tty
);
70 static void mi_execute_command_wrapper (char *cmd
);
72 void mi_exec_async_cli_cmd_continuation (struct continuation_arg
*arg
);
73 static void free_and_reset (char **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 asprintf (&mi_error_message
, "mi_cmd_exec_interrupt: Inferior not executing.");
203 interrupt_target_command_wrapper (args
, from_tty
);
204 if (last_async_command
)
205 fputs_unfiltered (last_async_command
, raw_stdout
);
206 fputs_unfiltered ("^done", raw_stdout
);
207 free (last_async_command
);
208 if (previous_async_command
)
209 last_async_command
= xstrdup (previous_async_command
);
210 free (previous_async_command
);
211 previous_async_command
= NULL
;
212 mi_out_put (uiout
, raw_stdout
);
213 mi_out_rewind (uiout
);
214 fputs_unfiltered ("\n", raw_stdout
);
220 mi_cmd_thread_select (char *command
, char **argv
, int argc
)
226 asprintf (&mi_error_message
,
227 "mi_cmd_thread_select: USAGE: threadnum.");
231 rc
= gdb_thread_select (argv
[0]);
233 if (rc
== GDB_RC_FAIL
)
234 return MI_CMD_CAUGHT_ERROR
;
240 mi_cmd_thread_list_ids (char *command
, char **argv
, int argc
)
242 enum gdb_rc rc
= MI_CMD_DONE
;
246 asprintf (&mi_error_message
,
247 "mi_cmd_thread_list_ids: No arguments required.");
252 rc
= gdb_list_thread_ids ();
255 if (rc
== GDB_RC_FAIL
)
256 return MI_CMD_CAUGHT_ERROR
;
262 mi_cmd_data_list_register_names (char *command
, char **argv
, int argc
)
267 /* Note that the test for a valid register must include checking the
268 REGISTER_NAME because NUM_REGS may be allocated for the union of
269 the register sets within a family of related processors. In this
270 case, some entries of REGISTER_NAME will change depending upon
271 the particular processor being debugged. */
273 numregs
= ARCH_NUM_REGS
;
275 ui_out_list_begin (uiout
, "register-names");
277 if (argc
== 0) /* No args, just do all the regs */
283 if (REGISTER_NAME (regnum
) == NULL
284 || *(REGISTER_NAME (regnum
)) == '\0')
287 ui_out_field_string (uiout
, NULL
, REGISTER_NAME (regnum
));
291 /* Else, list of register #s, just do listed regs */
292 for (i
= 0; i
< argc
; i
++)
294 regnum
= atoi (argv
[i
]);
298 && REGISTER_NAME (regnum
) != NULL
299 && *REGISTER_NAME (regnum
) != '\000')
300 ui_out_field_string (uiout
, NULL
, REGISTER_NAME (regnum
));
303 asprintf (&mi_error_message
, "bad register number");
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. */
323 numregs
= ARCH_NUM_REGS
;
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 asprintf (&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 asprintf (&mi_error_message
,
362 "mi_cmd_data_list_register_change: Unable to read register contents.");
366 ui_out_field_int (uiout
, NULL
, regnum
);
370 asprintf (&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. */
417 numregs
= ARCH_NUM_REGS
;
421 asprintf (&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 asprintf (&mi_error_message
, "mi_cmd_data_list_register_values: No registers.");
434 ui_out_list_begin (uiout
, "register-values");
436 if (argc
== 1) /* No args, beside the format: do all the regs */
442 if (REGISTER_NAME (regnum
) == NULL
443 || *(REGISTER_NAME (regnum
)) == '\0')
445 ui_out_list_begin (uiout
, NULL
);
446 ui_out_field_int (uiout
, "number", regnum
);
447 result
= get_register (regnum
, format
);
450 ui_out_list_end (uiout
);
454 /* Else, list of register #s, just do listed regs */
455 for (i
= 1; i
< argc
; i
++)
457 regnum
= atoi (argv
[i
]);
461 && REGISTER_NAME (regnum
) != NULL
462 && *REGISTER_NAME (regnum
) != '\000')
464 ui_out_list_begin (uiout
, NULL
);
465 ui_out_field_int (uiout
, "number", regnum
);
466 result
= get_register (regnum
, format
);
469 ui_out_list_end (uiout
);
473 asprintf (&mi_error_message
, "bad register number");
477 ui_out_list_end (uiout
);
481 /* Output one register's contents in the desired format. */
483 get_register (int regnum
, int format
)
485 char raw_buffer
[MAX_REGISTER_RAW_SIZE
];
486 char virtual_buffer
[MAX_REGISTER_VIRTUAL_SIZE
];
488 static struct ui_stream
*stb
= NULL
;
490 stb
= ui_out_stream_new (uiout
);
495 /* read_relative_register_raw_bytes returns a virtual frame pointer
496 (FRAME_FP (selected_frame)) if regnum == FP_REGNUM instead
497 of the real contents of the register. To get around this,
498 use get_saved_register instead. */
499 get_saved_register (raw_buffer
, &optim
, (CORE_ADDR
*) NULL
, selected_frame
,
500 regnum
, (enum lval_type
*) NULL
);
503 asprintf (&mi_error_message
, "Optimized out");
507 /* Convert raw data to virtual format if necessary. */
509 if (REGISTER_CONVERTIBLE (regnum
))
511 REGISTER_CONVERT_TO_VIRTUAL (regnum
, REGISTER_VIRTUAL_TYPE (regnum
),
512 raw_buffer
, virtual_buffer
);
515 memcpy (virtual_buffer
, raw_buffer
, REGISTER_VIRTUAL_SIZE (regnum
));
520 char *ptr
, buf
[1024];
524 for (j
= 0; j
< REGISTER_RAW_SIZE (regnum
); j
++)
526 register int idx
= TARGET_BYTE_ORDER
== BIG_ENDIAN
? j
527 : REGISTER_RAW_SIZE (regnum
) - 1 - j
;
528 sprintf (ptr
, "%02x", (unsigned char) raw_buffer
[idx
]);
531 ui_out_field_string (uiout
, "value", buf
);
532 /*fputs_filtered (buf, gdb_stdout); */
536 val_print (REGISTER_VIRTUAL_TYPE (regnum
), virtual_buffer
, 0, 0,
537 stb
->stream
, format
, 1, 0, Val_pretty_default
);
538 ui_out_field_stream (uiout
, "value", stb
);
539 ui_out_stream_delete (stb
);
544 /* Write given values into registers. The registers and values are
545 given as pairs. The corresponding MI command is
546 -data-write-register-values <format> [<regnum1> <value1>...<regnumN> <valueN>]*/
548 mi_cmd_data_write_register_values (char *command
, char **argv
, int argc
)
557 /* Note that the test for a valid register must include checking the
558 REGISTER_NAME because NUM_REGS may be allocated for the union of
559 the register sets within a family of related processors. In this
560 case, some entries of REGISTER_NAME will change depending upon
561 the particular processor being debugged. */
563 numregs
= ARCH_NUM_REGS
;
567 asprintf (&mi_error_message
,
568 "mi_cmd_data_write_register_values: Usage: -data-write-register-values <format> [<regnum1> <value1>...<regnumN> <valueN>]");
572 format
= (int) argv
[0][0];
574 if (!target_has_registers
)
576 asprintf (&mi_error_message
, "mi_cmd_data_write_register_values: No registers.");
582 asprintf (&mi_error_message
, "mi_cmd_data_write_register_values: No regs and values specified.");
588 asprintf (&mi_error_message
, "mi_cmd_data_write_register_values: Regs and vals are not in pairs.");
592 for (i
= 1; i
< argc
; i
= i
+ 2)
594 regnum
= atoi (argv
[i
]);
598 && REGISTER_NAME (regnum
) != NULL
599 && *REGISTER_NAME (regnum
) != '\000')
601 /* Get the value as a number */
602 value
= parse_and_eval_address (argv
[i
+ 1]);
603 /* Get the value into an array */
604 buffer
= (unsigned char *) xmalloc (REGISTER_SIZE
);
605 store_signed_integer (buffer
, REGISTER_SIZE
, value
);
607 write_register_bytes (REGISTER_BYTE (regnum
), buffer
, REGISTER_RAW_SIZE (regnum
));
608 /* write_register_bytes (REGISTER_BYTE (regnum), buffer, REGISTER_SIZE); */
612 asprintf (&mi_error_message
, "bad register number");
620 /*This is commented out because we decided it was not useful. I leave
621 it, just in case. ezannoni:1999-12-08 */
623 /* Assign a value to a variable. The expression argument must be in
624 the form A=2 or "A = 2" (I.e. if there are spaces it needs to be
627 mi_cmd_data_assign (char *command
, char **argv
, int argc
)
629 struct expression
*expr
;
630 struct cleanup
*old_chain
;
634 asprintf (&mi_error_message
,
635 "mi_cmd_data_assign: Usage: -data-assign expression");
639 /* NOTE what follows is a clone of set_command(). FIXME: ezannoni
640 01-12-1999: Need to decide what to do with this for libgdb purposes. */
642 expr
= parse_expression (argv
[0]);
643 old_chain
= make_cleanup ((make_cleanup_func
) free_current_contents
, &expr
);
644 evaluate_expression (expr
);
645 do_cleanups (old_chain
);
650 /* Evaluate the value of the argument. The argument is an
651 expression. If the expression contains spaces it needs to be
652 included in double quotes. */
654 mi_cmd_data_evaluate_expression (char *command
, char **argv
, int argc
)
656 struct expression
*expr
;
657 struct cleanup
*old_chain
= NULL
;
659 struct ui_stream
*stb
= NULL
;
661 stb
= ui_out_stream_new (uiout
);
665 asprintf (&mi_error_message
,
666 "mi_cmd_data_evaluate_expression: Usage: -data-evaluate-expression expression");
670 expr
= parse_expression (argv
[0]);
672 old_chain
= make_cleanup ((make_cleanup_func
) free_current_contents
, &expr
);
674 val
= evaluate_expression (expr
);
676 /* Print the result of the expression evaluation. */
677 val_print (VALUE_TYPE (val
), VALUE_CONTENTS (val
),
678 VALUE_EMBEDDED_OFFSET (val
), VALUE_ADDRESS (val
),
679 stb
->stream
, 0, 0, 0, 0);
681 ui_out_field_stream (uiout
, "value", stb
);
682 ui_out_stream_delete (stb
);
684 do_cleanups (old_chain
);
690 mi_cmd_target_download (char *args
, int from_tty
)
693 struct cleanup
*old_cleanups
= NULL
;
695 asprintf (&run
, "load %s", args
);
697 internal_error ("mi_cmd_target_download: no memory");
698 old_cleanups
= make_cleanup (free
, run
);
699 execute_command (run
, from_tty
);
701 do_cleanups (old_cleanups
);
705 /* Connect to the remote target. */
707 mi_cmd_target_select (char *args
, int from_tty
)
710 struct cleanup
*old_cleanups
= NULL
;
712 asprintf (&run
, "target %s", args
);
714 internal_error ("mi_cmd_target_select: no memory");
715 old_cleanups
= make_cleanup (free
, 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 asprintf (&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 asprintf (&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 asprintf (&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
= calloc (total_bytes
, 1);
862 make_cleanup (free
, mbuf
);
865 asprintf (&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_list_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_list_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 asprintf (&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 free (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 (free
, 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 ((make_cleanup_func
) free_and_reset
, &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 free_and_reset (char **arg
)
1237 mi_execute_command_wrapper (char *cmd
)
1239 mi_execute_command (cmd
, stdin
== instream
);
1242 /* FIXME: This is just a hack so we can get some extra commands going.
1243 We don't want to channel things through the CLI, but call libgdb directly */
1244 /* Use only for synchronous commands */
1247 mi_execute_cli_command (const char *cli
, char *args
)
1251 struct cleanup
*old_cleanups
;
1253 asprintf (&run
, cli
, args
);
1255 /* FIXME: gdb_???? */
1256 fprintf_unfiltered (gdb_stdout
, "cli=%s run=%s\n",
1260 old_cleanups
= make_cleanup (free
, run
);
1261 execute_command ( /*ui */ run
, 0 /*from_tty */ );
1262 do_cleanups (old_cleanups
);
1268 mi_execute_async_cli_command (char *mi
, char *args
, int from_tty
)
1270 struct cleanup
*old_cleanups
;
1274 if (target_can_async_p ())
1276 async_args
= (char *) xmalloc (strlen (args
) + 2);
1277 make_exec_cleanup (free
, async_args
);
1278 strcpy (async_args
, args
);
1279 strcat (async_args
, "&");
1280 asprintf (&run
, "%s %s", mi
, async_args
);
1282 internal_error ("mi_execute_async_cli_command: no memory");
1283 make_exec_cleanup (free
, run
);
1284 add_continuation (mi_exec_async_cli_cmd_continuation
, NULL
);
1288 asprintf (&run
, "%s %s", mi
, args
);
1290 internal_error ("mi_execute_async_cli_command: no memory");
1291 old_cleanups
= make_cleanup (free
, run
);
1294 if (!target_can_async_p ())
1296 /* NOTE: For synchronous targets asynchronous behavour is faked by
1297 printing out the GDB prompt before we even try to execute the
1299 if (last_async_command
)
1300 fputs_unfiltered (last_async_command
, raw_stdout
);
1301 fputs_unfiltered ("^running\n", raw_stdout
);
1302 fputs_unfiltered ("(gdb) \n", raw_stdout
);
1306 /* FIXME: cagney/1999-11-29: Printing this message before
1307 calling execute_command is wrong. It should only be printed
1308 once gdb has confirmed that it really has managed to send a
1309 run command to the target. */
1310 if (last_async_command
)
1311 fputs_unfiltered (last_async_command
, raw_stdout
);
1312 fputs_unfiltered ("^running\n", raw_stdout
);
1315 execute_command ( /*ui */ run
, 0 /*from_tty */ );
1317 if (!target_can_async_p ())
1319 /* Do this before doing any printing. It would appear that some
1320 print code leaves garbage around in the buffer. */
1321 do_cleanups (old_cleanups
);
1322 /* If the target was doing the operation synchronously we fake
1323 the stopped message. */
1324 if (last_async_command
)
1325 fputs_unfiltered (last_async_command
, raw_stdout
);
1326 fputs_unfiltered ("*stopped", raw_stdout
);
1327 mi_out_put (uiout
, raw_stdout
);
1328 mi_out_rewind (uiout
);
1329 fputs_unfiltered ("\n", raw_stdout
);
1330 return MI_CMD_QUIET
;
1336 mi_exec_async_cli_cmd_continuation (struct continuation_arg
*arg
)
1338 if (last_async_command
)
1339 fputs_unfiltered (last_async_command
, raw_stdout
);
1340 fputs_unfiltered ("*stopped", raw_stdout
);
1341 mi_out_put (uiout
, raw_stdout
);
1342 fputs_unfiltered ("\n", raw_stdout
);
1343 fputs_unfiltered ("(gdb) \n", raw_stdout
);
1344 do_exec_cleanups (ALL_CLEANUPS
);
1348 mi_input (char *buf
)
1350 return gdb_readline (NULL
);
1354 mi_load_progress (const char *section_name
,
1355 unsigned long sent_so_far
,
1356 unsigned long total_section
,
1357 unsigned long total_sent
,
1358 unsigned long grand_total
)
1360 struct timeval time_now
, delta
, update_threshold
;
1361 static struct timeval last_update
;
1362 static char *previous_sect_name
= NULL
;
1365 if (!interpreter_p
|| strcmp (interpreter_p
, "mi") != 0)
1368 update_threshold
.tv_sec
= 0;
1369 update_threshold
.tv_usec
= 500000;
1370 gettimeofday (&time_now
, NULL
);
1372 delta
.tv_usec
= time_now
.tv_usec
- last_update
.tv_usec
;
1373 delta
.tv_sec
= time_now
.tv_sec
- last_update
.tv_sec
;
1375 if (delta
.tv_usec
< 0)
1378 delta
.tv_usec
+= 1000000;
1381 new_section
= (previous_sect_name
?
1382 strcmp (previous_sect_name
, section_name
) : 1);
1385 free (previous_sect_name
);
1386 previous_sect_name
= xstrdup (section_name
);
1388 if (last_async_command
)
1389 fputs_unfiltered (last_async_command
, raw_stdout
);
1390 fputs_unfiltered ("+download", raw_stdout
);
1391 ui_out_list_begin (uiout
, NULL
);
1392 ui_out_field_string (uiout
, "section", section_name
);
1393 ui_out_field_int (uiout
, "section-size", total_section
);
1394 ui_out_field_int (uiout
, "total-size", grand_total
);
1395 ui_out_list_end (uiout
);
1396 mi_out_put (uiout
, raw_stdout
);
1397 fputs_unfiltered ("\n", raw_stdout
);
1398 gdb_flush (raw_stdout
);
1401 if (delta
.tv_sec
>= update_threshold
.tv_sec
&&
1402 delta
.tv_usec
>= update_threshold
.tv_usec
)
1404 last_update
.tv_sec
= time_now
.tv_sec
;
1405 last_update
.tv_usec
= time_now
.tv_usec
;
1406 if (last_async_command
)
1407 fputs_unfiltered (last_async_command
, raw_stdout
);
1408 fputs_unfiltered ("+download", raw_stdout
);
1409 ui_out_list_begin (uiout
, NULL
);
1410 ui_out_field_string (uiout
, "section", section_name
);
1411 ui_out_field_int (uiout
, "section-sent", sent_so_far
);
1412 ui_out_field_int (uiout
, "section-size", total_section
);
1413 ui_out_field_int (uiout
, "total-sent", total_sent
);
1414 ui_out_field_int (uiout
, "total-size", grand_total
);
1415 ui_out_list_end (uiout
);
1416 mi_out_put (uiout
, raw_stdout
);
1417 fputs_unfiltered ("\n", raw_stdout
);
1418 gdb_flush (raw_stdout
);
1425 /* HACK: Force stdout/stderr to point at the console. This avoids
1426 any potential side effects caused by legacy code that is still
1427 using the TUI / fputs_unfiltered_hook */
1428 raw_stdout
= stdio_fileopen (stdout
);
1429 /* Route normal output through the MIx */
1430 gdb_stdout
= mi_console_file_new (raw_stdout
, "~");
1431 /* Route error and log output through the MI */
1432 gdb_stderr
= mi_console_file_new (raw_stdout
, "&");
1433 gdb_stdlog
= gdb_stderr
;
1434 /* Route target output through the MI. */
1435 gdb_stdtarg
= mi_console_file_new (raw_stdout
, "@");
1437 /* HACK: Poke the ui_out table directly. Should we be creating a
1438 mi_out object wired up to the above gdb_stdout / gdb_stderr? */
1439 uiout
= mi_out_new ();
1441 /* HACK: Override any other interpreter hooks. We need to create a
1442 real event table and pass in that. */
1444 /* command_loop_hook = 0; */
1445 print_frame_info_listing_hook
= 0;
1448 create_breakpoint_hook
= 0;
1449 delete_breakpoint_hook
= 0;
1450 modify_breakpoint_hook
= 0;
1451 interactive_hook
= 0;
1452 registers_changed_hook
= 0;
1453 readline_begin_hook
= 0;
1455 readline_end_hook
= 0;
1456 register_changed_hook
= 0;
1457 memory_changed_hook
= 0;
1459 target_wait_hook
= 0;
1460 call_command_hook
= 0;
1462 error_begin_hook
= 0;
1463 show_load_progress
= mi_load_progress
;
1465 /* Turn off 8 bit strings in quoted output. Any character with the
1466 high bit set is printed using C's octal format. */
1467 sevenbit_strings
= 1;
1469 /* Tell the world that we're alive */
1470 fputs_unfiltered ("(gdb) \n", raw_stdout
);
1473 simplified_command_loop (mi_input
, mi_execute_command
);
1475 start_event_loop ();
1479 setup_architecture_data ()
1481 /* don't trust REGISTER_BYTES to be zero. */
1482 old_regs
= xmalloc (REGISTER_BYTES
+ 1);
1483 memset (old_regs
, 0, REGISTER_BYTES
+ 1);
1490 /* Eventually this will contain code that takes control of the
1495 _initialize_mi_main ()
1497 /* If we're _the_ interpreter, take control. */
1499 && strcmp (interpreter_p
, "mi") == 0)
1501 init_ui_hook
= mi_init_ui
;
1502 command_loop_hook
= mi_command_loop
;
1503 setup_architecture_data ();
1504 register_gdbarch_swap (&old_regs
, sizeof (old_regs
), NULL
);
1505 register_gdbarch_swap (NULL
, 0, setup_architecture_data
);
1508 /* These overwrite some of the initialization done in
1509 _intialize_event_loop. */
1510 call_readline
= gdb_readline2
;
1511 input_handler
= mi_execute_command_wrapper
;
1512 add_file_handler (input_fd
, stdin_event_handler
, 0);
1513 async_command_editing_p
= 0;
1516 /* FIXME: Should we notify main that we are here as a possible
1520 /* Local variables: */
1521 /* change-log-default-name: "ChangeLog-mi" */