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
);
74 static int register_changed_p (int regnum
);
75 static int get_register (int regnum
, int format
);
76 static void mi_load_progress (const char *section_name
,
77 unsigned long sent_so_far
,
78 unsigned long total_section
,
79 unsigned long total_sent
,
80 unsigned long grand_total
);
83 /* FIXME: these should go in some .h file, but infcmd.c doesn't have a
84 corresponding .h file. These wrappers will be obsolete anyway, once
85 we pull the plug on the sanitization. */
86 extern void interrupt_target_command_wrapper (char *, int);
87 extern void return_command_wrapper (char *, int);
90 /* Command implementations. FIXME: Is this libgdb? No. This is the MI
91 layer that calls libgdb. Any operation used in the below should be
95 mi_cmd_gdb_exit (char *command
, char **argv
, int argc
)
97 /* We have to print everything right here because we never return */
98 if (last_async_command
)
99 fputs_unfiltered (last_async_command
, raw_stdout
);
100 fputs_unfiltered ("^exit\n", raw_stdout
);
101 mi_out_put (uiout
, raw_stdout
);
102 /* FIXME: The function called is not yet a formal libgdb function */
103 quit_force (NULL
, FROM_TTY
);
108 mi_cmd_exec_run (char *args
, int from_tty
)
110 /* FIXME: Should call a libgdb function, not a cli wrapper */
111 return mi_execute_async_cli_command ("run", args
, from_tty
);
115 mi_cmd_exec_next (char *args
, int from_tty
)
117 /* FIXME: Should call a libgdb function, not a cli wrapper */
118 return mi_execute_async_cli_command ("next", args
, from_tty
);
122 mi_cmd_exec_next_instruction (char *args
, int from_tty
)
124 /* FIXME: Should call a libgdb function, not a cli wrapper */
125 return mi_execute_async_cli_command ("nexti", args
, from_tty
);
129 mi_cmd_exec_step (char *args
, int from_tty
)
131 /* FIXME: Should call a libgdb function, not a cli wrapper */
132 return mi_execute_async_cli_command ("step", args
, from_tty
);
136 mi_cmd_exec_step_instruction (char *args
, int from_tty
)
138 /* FIXME: Should call a libgdb function, not a cli wrapper */
139 return mi_execute_async_cli_command ("stepi", args
, from_tty
);
143 mi_cmd_exec_finish (char *args
, int from_tty
)
145 /* FIXME: Should call a libgdb function, not a cli wrapper */
146 return mi_execute_async_cli_command ("finish", args
, from_tty
);
150 mi_cmd_exec_until (char *args
, int from_tty
)
152 /* FIXME: Should call a libgdb function, not a cli wrapper */
153 return mi_execute_async_cli_command ("until", args
, from_tty
);
157 mi_cmd_exec_return (char *args
, int from_tty
)
160 /* This command doesn't really execute the target, it just pops the
161 specified number of frames. */
163 /* Call return_command with from_tty argument equal to 0 so as to
164 avoid being queried. */
165 return_command_wrapper (args
, 0);
167 /* Call return_command with from_tty argument equal to 0 so as to
168 avoid being queried. */
169 return_command_wrapper (NULL
, 0);
171 /* Because we have called return_command with from_tty = 0, we need
172 to print the frame here. */
173 show_and_print_stack_frame (selected_frame
,
174 selected_frame_level
,
182 mi_cmd_exec_continue (char *args
, int from_tty
)
184 /* FIXME: Should call a libgdb function, not a cli wrapper */
185 return mi_execute_async_cli_command ("continue", args
, from_tty
);
188 /* Interrupt the execution of the target. Note how we must play around
189 with the token varialbes, in order to display the current token in
190 the result of the interrupt command, and the previous execution
191 token when the target finally stops. See comments in
194 mi_cmd_exec_interrupt (char *args
, int from_tty
)
197 if (!target_executing
)
199 xasprintf (&mi_error_message
,
200 "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 xasprintf (&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 xasprintf (&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 xasprintf (&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 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. */
417 numregs
= ARCH_NUM_REGS
;
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_list_begin (uiout
, NULL
);
447 ui_out_field_int (uiout
, "number", regnum
);
448 result
= get_register (regnum
, format
);
451 ui_out_list_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_list_begin (uiout
, NULL
);
466 ui_out_field_int (uiout
, "number", regnum
);
467 result
= get_register (regnum
, format
);
470 ui_out_list_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. */
564 numregs
= ARCH_NUM_REGS
;
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 (free
, 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 (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 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
= calloc (total_bytes
, 1);
862 make_cleanup (free
, 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_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 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 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 (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 (free
, 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
);
1277 xasprintf (&run
, "%s %s", mi
, args
);
1278 old_cleanups
= make_cleanup (free
, run
);
1281 if (!target_can_async_p ())
1283 /* NOTE: For synchronous targets asynchronous behavour is faked by
1284 printing out the GDB prompt before we even try to execute the
1286 if (last_async_command
)
1287 fputs_unfiltered (last_async_command
, raw_stdout
);
1288 fputs_unfiltered ("^running\n", raw_stdout
);
1289 fputs_unfiltered ("(gdb) \n", raw_stdout
);
1293 /* FIXME: cagney/1999-11-29: Printing this message before
1294 calling execute_command is wrong. It should only be printed
1295 once gdb has confirmed that it really has managed to send a
1296 run command to the target. */
1297 if (last_async_command
)
1298 fputs_unfiltered (last_async_command
, raw_stdout
);
1299 fputs_unfiltered ("^running\n", raw_stdout
);
1302 execute_command ( /*ui */ run
, 0 /*from_tty */ );
1304 if (!target_can_async_p ())
1306 /* Do this before doing any printing. It would appear that some
1307 print code leaves garbage around in the buffer. */
1308 do_cleanups (old_cleanups
);
1309 /* If the target was doing the operation synchronously we fake
1310 the stopped message. */
1311 if (last_async_command
)
1312 fputs_unfiltered (last_async_command
, raw_stdout
);
1313 fputs_unfiltered ("*stopped", raw_stdout
);
1314 mi_out_put (uiout
, raw_stdout
);
1315 mi_out_rewind (uiout
);
1316 fputs_unfiltered ("\n", raw_stdout
);
1317 return MI_CMD_QUIET
;
1323 mi_exec_async_cli_cmd_continuation (struct continuation_arg
*arg
)
1325 if (last_async_command
)
1326 fputs_unfiltered (last_async_command
, raw_stdout
);
1327 fputs_unfiltered ("*stopped", raw_stdout
);
1328 mi_out_put (uiout
, raw_stdout
);
1329 fputs_unfiltered ("\n", raw_stdout
);
1330 fputs_unfiltered ("(gdb) \n", raw_stdout
);
1331 do_exec_cleanups (ALL_CLEANUPS
);
1335 mi_input (char *buf
)
1337 return gdb_readline (NULL
);
1341 mi_load_progress (const char *section_name
,
1342 unsigned long sent_so_far
,
1343 unsigned long total_section
,
1344 unsigned long total_sent
,
1345 unsigned long grand_total
)
1347 struct timeval time_now
, delta
, update_threshold
;
1348 static struct timeval last_update
;
1349 static char *previous_sect_name
= NULL
;
1352 if (!interpreter_p
|| strcmp (interpreter_p
, "mi") != 0)
1355 update_threshold
.tv_sec
= 0;
1356 update_threshold
.tv_usec
= 500000;
1357 gettimeofday (&time_now
, NULL
);
1359 delta
.tv_usec
= time_now
.tv_usec
- last_update
.tv_usec
;
1360 delta
.tv_sec
= time_now
.tv_sec
- last_update
.tv_sec
;
1362 if (delta
.tv_usec
< 0)
1365 delta
.tv_usec
+= 1000000;
1368 new_section
= (previous_sect_name
?
1369 strcmp (previous_sect_name
, section_name
) : 1);
1372 free (previous_sect_name
);
1373 previous_sect_name
= xstrdup (section_name
);
1375 if (last_async_command
)
1376 fputs_unfiltered (last_async_command
, raw_stdout
);
1377 fputs_unfiltered ("+download", raw_stdout
);
1378 ui_out_list_begin (uiout
, NULL
);
1379 ui_out_field_string (uiout
, "section", section_name
);
1380 ui_out_field_int (uiout
, "section-size", total_section
);
1381 ui_out_field_int (uiout
, "total-size", grand_total
);
1382 ui_out_list_end (uiout
);
1383 mi_out_put (uiout
, raw_stdout
);
1384 fputs_unfiltered ("\n", raw_stdout
);
1385 gdb_flush (raw_stdout
);
1388 if (delta
.tv_sec
>= update_threshold
.tv_sec
&&
1389 delta
.tv_usec
>= update_threshold
.tv_usec
)
1391 last_update
.tv_sec
= time_now
.tv_sec
;
1392 last_update
.tv_usec
= time_now
.tv_usec
;
1393 if (last_async_command
)
1394 fputs_unfiltered (last_async_command
, raw_stdout
);
1395 fputs_unfiltered ("+download", raw_stdout
);
1396 ui_out_list_begin (uiout
, NULL
);
1397 ui_out_field_string (uiout
, "section", section_name
);
1398 ui_out_field_int (uiout
, "section-sent", sent_so_far
);
1399 ui_out_field_int (uiout
, "section-size", total_section
);
1400 ui_out_field_int (uiout
, "total-sent", total_sent
);
1401 ui_out_field_int (uiout
, "total-size", grand_total
);
1402 ui_out_list_end (uiout
);
1403 mi_out_put (uiout
, raw_stdout
);
1404 fputs_unfiltered ("\n", raw_stdout
);
1405 gdb_flush (raw_stdout
);
1410 mi_command_loop (void)
1412 /* HACK: Force stdout/stderr to point at the console. This avoids
1413 any potential side effects caused by legacy code that is still
1414 using the TUI / fputs_unfiltered_hook */
1415 raw_stdout
= stdio_fileopen (stdout
);
1416 /* Route normal output through the MIx */
1417 gdb_stdout
= mi_console_file_new (raw_stdout
, "~");
1418 /* Route error and log output through the MI */
1419 gdb_stderr
= mi_console_file_new (raw_stdout
, "&");
1420 gdb_stdlog
= gdb_stderr
;
1421 /* Route target output through the MI. */
1422 gdb_stdtarg
= mi_console_file_new (raw_stdout
, "@");
1424 /* HACK: Poke the ui_out table directly. Should we be creating a
1425 mi_out object wired up to the above gdb_stdout / gdb_stderr? */
1426 uiout
= mi_out_new ();
1428 /* HACK: Override any other interpreter hooks. We need to create a
1429 real event table and pass in that. */
1431 /* command_loop_hook = 0; */
1432 print_frame_info_listing_hook
= 0;
1435 create_breakpoint_hook
= 0;
1436 delete_breakpoint_hook
= 0;
1437 modify_breakpoint_hook
= 0;
1438 interactive_hook
= 0;
1439 registers_changed_hook
= 0;
1440 readline_begin_hook
= 0;
1442 readline_end_hook
= 0;
1443 register_changed_hook
= 0;
1444 memory_changed_hook
= 0;
1446 target_wait_hook
= 0;
1447 call_command_hook
= 0;
1449 error_begin_hook
= 0;
1450 show_load_progress
= mi_load_progress
;
1452 /* Turn off 8 bit strings in quoted output. Any character with the
1453 high bit set is printed using C's octal format. */
1454 sevenbit_strings
= 1;
1456 /* Tell the world that we're alive */
1457 fputs_unfiltered ("(gdb) \n", raw_stdout
);
1460 simplified_command_loop (mi_input
, mi_execute_command
);
1462 start_event_loop ();
1466 setup_architecture_data (void)
1468 /* don't trust REGISTER_BYTES to be zero. */
1469 old_regs
= xmalloc (REGISTER_BYTES
+ 1);
1470 memset (old_regs
, 0, REGISTER_BYTES
+ 1);
1474 mi_init_ui (char *arg0
)
1476 /* Eventually this will contain code that takes control of the
1481 _initialize_mi_main (void)
1483 /* If we're _the_ interpreter, take control. */
1485 && strcmp (interpreter_p
, "mi") == 0)
1487 init_ui_hook
= mi_init_ui
;
1488 command_loop_hook
= mi_command_loop
;
1489 setup_architecture_data ();
1490 register_gdbarch_swap (&old_regs
, sizeof (old_regs
), NULL
);
1491 register_gdbarch_swap (NULL
, 0, setup_architecture_data
);
1494 /* These overwrite some of the initialization done in
1495 _intialize_event_loop. */
1496 call_readline
= gdb_readline2
;
1497 input_handler
= mi_execute_command_wrapper
;
1498 add_file_handler (input_fd
, stdin_event_handler
, 0);
1499 async_command_editing_p
= 0;
1502 /* FIXME: Should we notify main that we are here as a possible