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 asprintf (&mi_error_message
, "mi_cmd_exec_interrupt: Inferior not executing.");
202 interrupt_target_command_wrapper (args
, from_tty
);
203 if (last_async_command
)
204 fputs_unfiltered (last_async_command
, raw_stdout
);
205 fputs_unfiltered ("^done", raw_stdout
);
206 free (last_async_command
);
207 if (previous_async_command
)
208 last_async_command
= xstrdup (previous_async_command
);
209 free (previous_async_command
);
210 previous_async_command
= NULL
;
211 mi_out_put (uiout
, raw_stdout
);
212 mi_out_rewind (uiout
);
213 fputs_unfiltered ("\n", raw_stdout
);
219 mi_cmd_thread_select (char *command
, char **argv
, int argc
)
225 asprintf (&mi_error_message
,
226 "mi_cmd_thread_select: USAGE: threadnum.");
230 rc
= gdb_thread_select (argv
[0]);
232 if (rc
== GDB_RC_FAIL
)
233 return MI_CMD_CAUGHT_ERROR
;
239 mi_cmd_thread_list_ids (char *command
, char **argv
, int argc
)
241 enum gdb_rc rc
= MI_CMD_DONE
;
245 asprintf (&mi_error_message
,
246 "mi_cmd_thread_list_ids: No arguments required.");
251 rc
= gdb_list_thread_ids ();
254 if (rc
== GDB_RC_FAIL
)
255 return MI_CMD_CAUGHT_ERROR
;
261 mi_cmd_data_list_register_names (char *command
, char **argv
, int argc
)
266 /* Note that the test for a valid register must include checking the
267 REGISTER_NAME because NUM_REGS may be allocated for the union of
268 the register sets within a family of related processors. In this
269 case, some entries of REGISTER_NAME will change depending upon
270 the particular processor being debugged. */
272 numregs
= ARCH_NUM_REGS
;
274 ui_out_list_begin (uiout
, "register-names");
276 if (argc
== 0) /* No args, just do all the regs */
282 if (REGISTER_NAME (regnum
) == NULL
283 || *(REGISTER_NAME (regnum
)) == '\0')
286 ui_out_field_string (uiout
, NULL
, REGISTER_NAME (regnum
));
290 /* Else, list of register #s, just do listed regs */
291 for (i
= 0; i
< argc
; i
++)
293 regnum
= atoi (argv
[i
]);
297 && REGISTER_NAME (regnum
) != NULL
298 && *REGISTER_NAME (regnum
) != '\000')
299 ui_out_field_string (uiout
, NULL
, REGISTER_NAME (regnum
));
302 asprintf (&mi_error_message
, "bad register number");
306 ui_out_list_end (uiout
);
311 mi_cmd_data_list_changed_registers (char *command
, char **argv
, int argc
)
313 int regnum
, numregs
, changed
;
316 /* Note that the test for a valid register must include checking the
317 REGISTER_NAME because NUM_REGS may be allocated for the union of
318 the register sets within a family of related processors. In this
319 case, some entries of REGISTER_NAME will change depending upon
320 the particular processor being debugged. */
322 numregs
= ARCH_NUM_REGS
;
324 ui_out_list_begin (uiout
, "changed-registers");
326 if (argc
== 0) /* No args, just do all the regs */
332 if (REGISTER_NAME (regnum
) == NULL
333 || *(REGISTER_NAME (regnum
)) == '\0')
335 changed
= register_changed_p (regnum
);
338 asprintf (&mi_error_message
,
339 "mi_cmd_data_list_changed_registers: Unable to read register contents.");
343 ui_out_field_int (uiout
, NULL
, regnum
);
347 /* Else, list of register #s, just do listed regs */
348 for (i
= 0; i
< argc
; i
++)
350 regnum
= atoi (argv
[i
]);
354 && REGISTER_NAME (regnum
) != NULL
355 && *REGISTER_NAME (regnum
) != '\000')
357 changed
= register_changed_p (regnum
);
360 asprintf (&mi_error_message
,
361 "mi_cmd_data_list_register_change: Unable to read register contents.");
365 ui_out_field_int (uiout
, NULL
, regnum
);
369 asprintf (&mi_error_message
, "bad register number");
373 ui_out_list_end (uiout
);
378 register_changed_p (int regnum
)
380 char raw_buffer
[MAX_REGISTER_RAW_SIZE
];
382 if (read_relative_register_raw_bytes (regnum
, raw_buffer
))
385 if (memcmp (&old_regs
[REGISTER_BYTE (regnum
)], raw_buffer
,
386 REGISTER_RAW_SIZE (regnum
)) == 0)
389 /* Found a changed register. Return 1. */
391 memcpy (&old_regs
[REGISTER_BYTE (regnum
)], raw_buffer
,
392 REGISTER_RAW_SIZE (regnum
));
397 /* Return a list of register number and value pairs. The valid
398 arguments expected are: a letter indicating the format in which to
399 display the registers contents. This can be one of: x (hexadecimal), d
400 (decimal), N (natural), t (binary), o (octal), r (raw). After the
401 format argumetn there can be a sequence of numbers, indicating which
402 registers to fetch the content of. If the format is the only argument,
403 a list of all the registers with their values is returned. */
405 mi_cmd_data_list_register_values (char *command
, char **argv
, int argc
)
407 int regnum
, numregs
, format
, result
;
410 /* Note that the test for a valid register must include checking the
411 REGISTER_NAME because NUM_REGS may be allocated for the union of
412 the register sets within a family of related processors. In this
413 case, some entries of REGISTER_NAME will change depending upon
414 the particular processor being debugged. */
416 numregs
= ARCH_NUM_REGS
;
420 asprintf (&mi_error_message
,
421 "mi_cmd_data_list_register_values: Usage: -data-list-register-values <format> [<regnum1>...<regnumN>]");
425 format
= (int) argv
[0][0];
427 if (!target_has_registers
)
429 asprintf (&mi_error_message
, "mi_cmd_data_list_register_values: No registers.");
433 ui_out_list_begin (uiout
, "register-values");
435 if (argc
== 1) /* No args, beside the format: do all the regs */
441 if (REGISTER_NAME (regnum
) == NULL
442 || *(REGISTER_NAME (regnum
)) == '\0')
444 ui_out_list_begin (uiout
, NULL
);
445 ui_out_field_int (uiout
, "number", regnum
);
446 result
= get_register (regnum
, format
);
449 ui_out_list_end (uiout
);
453 /* Else, list of register #s, just do listed regs */
454 for (i
= 1; i
< argc
; i
++)
456 regnum
= atoi (argv
[i
]);
460 && REGISTER_NAME (regnum
) != NULL
461 && *REGISTER_NAME (regnum
) != '\000')
463 ui_out_list_begin (uiout
, NULL
);
464 ui_out_field_int (uiout
, "number", regnum
);
465 result
= get_register (regnum
, format
);
468 ui_out_list_end (uiout
);
472 asprintf (&mi_error_message
, "bad register number");
476 ui_out_list_end (uiout
);
480 /* Output one register's contents in the desired format. */
482 get_register (int regnum
, int format
)
484 char raw_buffer
[MAX_REGISTER_RAW_SIZE
];
485 char virtual_buffer
[MAX_REGISTER_VIRTUAL_SIZE
];
487 static struct ui_stream
*stb
= NULL
;
489 stb
= ui_out_stream_new (uiout
);
494 /* read_relative_register_raw_bytes returns a virtual frame pointer
495 (FRAME_FP (selected_frame)) if regnum == FP_REGNUM instead
496 of the real contents of the register. To get around this,
497 use get_saved_register instead. */
498 get_saved_register (raw_buffer
, &optim
, (CORE_ADDR
*) NULL
, selected_frame
,
499 regnum
, (enum lval_type
*) NULL
);
502 asprintf (&mi_error_message
, "Optimized out");
506 /* Convert raw data to virtual format if necessary. */
508 if (REGISTER_CONVERTIBLE (regnum
))
510 REGISTER_CONVERT_TO_VIRTUAL (regnum
, REGISTER_VIRTUAL_TYPE (regnum
),
511 raw_buffer
, virtual_buffer
);
514 memcpy (virtual_buffer
, raw_buffer
, REGISTER_VIRTUAL_SIZE (regnum
));
519 char *ptr
, buf
[1024];
523 for (j
= 0; j
< REGISTER_RAW_SIZE (regnum
); j
++)
525 register int idx
= TARGET_BYTE_ORDER
== BIG_ENDIAN
? j
526 : REGISTER_RAW_SIZE (regnum
) - 1 - j
;
527 sprintf (ptr
, "%02x", (unsigned char) raw_buffer
[idx
]);
530 ui_out_field_string (uiout
, "value", buf
);
531 /*fputs_filtered (buf, gdb_stdout); */
535 val_print (REGISTER_VIRTUAL_TYPE (regnum
), virtual_buffer
, 0, 0,
536 stb
->stream
, format
, 1, 0, Val_pretty_default
);
537 ui_out_field_stream (uiout
, "value", stb
);
538 ui_out_stream_delete (stb
);
543 /* Write given values into registers. The registers and values are
544 given as pairs. The corresponding MI command is
545 -data-write-register-values <format> [<regnum1> <value1>...<regnumN> <valueN>]*/
547 mi_cmd_data_write_register_values (char *command
, char **argv
, int argc
)
556 /* Note that the test for a valid register must include checking the
557 REGISTER_NAME because NUM_REGS may be allocated for the union of
558 the register sets within a family of related processors. In this
559 case, some entries of REGISTER_NAME will change depending upon
560 the particular processor being debugged. */
562 numregs
= ARCH_NUM_REGS
;
566 asprintf (&mi_error_message
,
567 "mi_cmd_data_write_register_values: Usage: -data-write-register-values <format> [<regnum1> <value1>...<regnumN> <valueN>]");
571 format
= (int) argv
[0][0];
573 if (!target_has_registers
)
575 asprintf (&mi_error_message
, "mi_cmd_data_write_register_values: No registers.");
581 asprintf (&mi_error_message
, "mi_cmd_data_write_register_values: No regs and values specified.");
587 asprintf (&mi_error_message
, "mi_cmd_data_write_register_values: Regs and vals are not in pairs.");
591 for (i
= 1; i
< argc
; i
= i
+ 2)
593 regnum
= atoi (argv
[i
]);
597 && REGISTER_NAME (regnum
) != NULL
598 && *REGISTER_NAME (regnum
) != '\000')
600 /* Get the value as a number */
601 value
= parse_and_eval_address (argv
[i
+ 1]);
602 /* Get the value into an array */
603 buffer
= (unsigned char *) xmalloc (REGISTER_SIZE
);
604 store_signed_integer (buffer
, REGISTER_SIZE
, value
);
606 write_register_bytes (REGISTER_BYTE (regnum
), buffer
, REGISTER_RAW_SIZE (regnum
));
607 /* write_register_bytes (REGISTER_BYTE (regnum), buffer, REGISTER_SIZE); */
611 asprintf (&mi_error_message
, "bad register number");
619 /*This is commented out because we decided it was not useful. I leave
620 it, just in case. ezannoni:1999-12-08 */
622 /* Assign a value to a variable. The expression argument must be in
623 the form A=2 or "A = 2" (I.e. if there are spaces it needs to be
626 mi_cmd_data_assign (char *command
, char **argv
, int argc
)
628 struct expression
*expr
;
629 struct cleanup
*old_chain
;
633 asprintf (&mi_error_message
,
634 "mi_cmd_data_assign: Usage: -data-assign expression");
638 /* NOTE what follows is a clone of set_command(). FIXME: ezannoni
639 01-12-1999: Need to decide what to do with this for libgdb purposes. */
641 expr
= parse_expression (argv
[0]);
642 old_chain
= make_cleanup (free_current_contents
, &expr
);
643 evaluate_expression (expr
);
644 do_cleanups (old_chain
);
649 /* Evaluate the value of the argument. The argument is an
650 expression. If the expression contains spaces it needs to be
651 included in double quotes. */
653 mi_cmd_data_evaluate_expression (char *command
, char **argv
, int argc
)
655 struct expression
*expr
;
656 struct cleanup
*old_chain
= NULL
;
658 struct ui_stream
*stb
= NULL
;
660 stb
= ui_out_stream_new (uiout
);
664 asprintf (&mi_error_message
,
665 "mi_cmd_data_evaluate_expression: Usage: -data-evaluate-expression expression");
669 expr
= parse_expression (argv
[0]);
671 old_chain
= make_cleanup (free_current_contents
, &expr
);
673 val
= evaluate_expression (expr
);
675 /* Print the result of the expression evaluation. */
676 val_print (VALUE_TYPE (val
), VALUE_CONTENTS (val
),
677 VALUE_EMBEDDED_OFFSET (val
), VALUE_ADDRESS (val
),
678 stb
->stream
, 0, 0, 0, 0);
680 ui_out_field_stream (uiout
, "value", stb
);
681 ui_out_stream_delete (stb
);
683 do_cleanups (old_chain
);
689 mi_cmd_target_download (char *args
, int from_tty
)
692 struct cleanup
*old_cleanups
= NULL
;
694 asprintf (&run
, "load %s", args
);
696 internal_error ("mi_cmd_target_download: no memory");
697 old_cleanups
= make_cleanup (free
, run
);
698 execute_command (run
, from_tty
);
700 do_cleanups (old_cleanups
);
704 /* Connect to the remote target. */
706 mi_cmd_target_select (char *args
, int from_tty
)
709 struct cleanup
*old_cleanups
= NULL
;
711 asprintf (&run
, "target %s", args
);
713 internal_error ("mi_cmd_target_select: no memory");
714 old_cleanups
= make_cleanup (free
, run
);
716 /* target-select is always synchronous. once the call has returned
717 we know that we are connected. */
718 /* NOTE: At present all targets that are connected are also
719 (implicitly) talking to a halted target. In the future this may
721 execute_command (run
, from_tty
);
723 do_cleanups (old_cleanups
);
725 /* Issue the completion message here. */
726 if (last_async_command
)
727 fputs_unfiltered (last_async_command
, raw_stdout
);
728 fputs_unfiltered ("^connected", raw_stdout
);
729 mi_out_put (uiout
, raw_stdout
);
730 mi_out_rewind (uiout
);
731 fputs_unfiltered ("\n", raw_stdout
);
732 do_exec_cleanups (ALL_CLEANUPS
);
738 ADDR: start address of data to be dumped.
739 WORD-FORMAT: a char indicating format for the ``word''. See
741 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes
742 NR_ROW: Number of rows.
743 NR_COL: The number of colums (words per row).
744 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
745 ASCHAR for unprintable characters.
747 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
748 displayes them. Returns:
750 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
753 The number of bytes read is SIZE*ROW*COL. */
756 mi_cmd_data_read_memory (char *command
, char **argv
, int argc
)
758 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
764 struct type
*word_type
;
777 static struct mi_opt opts
[] =
779 {"o", OFFSET_OPT
, 1},
785 int opt
= mi_getopt ("mi_cmd_data_read_memory", argc
, argv
, opts
,
789 switch ((enum opt
) opt
)
792 offset
= atol (optarg
);
799 if (argc
< 5 || argc
> 6)
801 asprintf (&mi_error_message
,
802 "mi_cmd_data_read_memory: Usage: ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR].");
806 /* Extract all the arguments. */
808 /* Start address of the memory dump. */
809 addr
= parse_and_eval_address (argv
[0]) + offset
;
810 /* The format character to use when displaying a memory word. See
811 the ``x'' command. */
812 word_format
= argv
[1][0];
813 /* The size of the memory word. */
814 word_size
= atol (argv
[2]);
818 word_type
= builtin_type_int8
;
822 word_type
= builtin_type_int16
;
826 word_type
= builtin_type_int32
;
830 word_type
= builtin_type_int64
;
834 word_type
= builtin_type_int8
;
837 /* The number of rows */
838 nr_rows
= atol (argv
[3]);
841 asprintf (&mi_error_message
,
842 "mi_cmd_data_read_memory: invalid number of rows.");
845 /* number of bytes per row. */
846 nr_cols
= atol (argv
[4]);
849 asprintf (&mi_error_message
,
850 "mi_cmd_data_read_memory: invalid number of columns.");
852 /* The un-printable character when printing ascii. */
858 /* create a buffer and read it in. */
859 total_bytes
= word_size
* nr_rows
* nr_cols
;
860 mbuf
= calloc (total_bytes
, 1);
861 make_cleanup (free
, mbuf
);
864 asprintf (&mi_error_message
,
865 "mi_cmd_data_read_memory: out of memory.");
869 while (nr_bytes
< total_bytes
)
872 long num
= target_read_memory_partial (addr
+ nr_bytes
, mbuf
+ nr_bytes
,
873 total_bytes
- nr_bytes
,
880 /* output the header information. */
881 ui_out_field_core_addr (uiout
, "addr", addr
);
882 ui_out_field_int (uiout
, "nr-bytes", nr_bytes
);
883 ui_out_field_int (uiout
, "total-bytes", total_bytes
);
884 ui_out_field_core_addr (uiout
, "next-row", addr
+ word_size
* nr_cols
);
885 ui_out_field_core_addr (uiout
, "prev-row", addr
- word_size
* nr_cols
);
886 ui_out_field_core_addr (uiout
, "next-page", addr
+ total_bytes
);
887 ui_out_field_core_addr (uiout
, "prev-page", addr
- total_bytes
);
889 /* Build the result as a two dimentional table. */
891 struct ui_stream
*stream
= ui_out_stream_new (uiout
);
894 ui_out_list_begin (uiout
, "memory");
895 for (row
= 0, row_byte
= 0;
897 row
++, row_byte
+= nr_cols
* word_size
)
901 ui_out_list_begin (uiout
, NULL
);
902 ui_out_field_core_addr (uiout
, "addr", addr
+ row_byte
);
903 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr + row_byte); */
904 ui_out_list_begin (uiout
, "data");
905 for (col
= 0, col_byte
= row_byte
;
907 col
++, col_byte
+= word_size
)
909 if (col_byte
+ word_size
> nr_bytes
)
911 ui_out_field_string (uiout
, NULL
, "N/A");
915 ui_file_rewind (stream
->stream
);
916 print_scalar_formatted (mbuf
+ col_byte
, word_type
, word_format
,
917 word_asize
, stream
->stream
);
918 ui_out_field_stream (uiout
, NULL
, stream
);
921 ui_out_list_end (uiout
);
925 ui_file_rewind (stream
->stream
);
926 for (byte
= row_byte
; byte
< row_byte
+ word_size
* nr_cols
; byte
++)
928 if (byte
>= nr_bytes
)
930 fputc_unfiltered ('X', stream
->stream
);
932 else if (mbuf
[byte
] < 32 || mbuf
[byte
] > 126)
934 fputc_unfiltered (aschar
, stream
->stream
);
937 fputc_unfiltered (mbuf
[byte
], stream
->stream
);
939 ui_out_field_stream (uiout
, "ascii", stream
);
941 ui_out_list_end (uiout
);
943 ui_out_stream_delete (stream
);
944 ui_out_list_end (uiout
);
946 do_cleanups (cleanups
);
950 /* DATA-MEMORY-WRITE:
952 COLUMN_OFFSET: optional argument. Must be preceeded by '-o'. The
953 offset from the beginning of the memory grid row where the cell to
955 ADDR: start address of the row in the memory grid where the memory
956 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
957 the location to write to.
958 FORMAT: a char indicating format for the ``word''. See
960 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
961 VALUE: value to be written into the memory address.
963 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
967 mi_cmd_data_write_memory (char *command
, char **argv
, int argc
)
972 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
973 enough when using a compiler other than GCC. */
975 unsigned char *buffer
;
983 static struct mi_opt opts
[] =
985 {"o", OFFSET_OPT
, 1},
991 int opt
= mi_getopt ("mi_cmd_data_write_memory", argc
, argv
, opts
,
995 switch ((enum opt
) opt
)
998 offset
= atol (optarg
);
1007 asprintf (&mi_error_message
,
1008 "mi_cmd_data_write_memory: Usage: [-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE.");
1009 return MI_CMD_ERROR
;
1012 /* Extract all the arguments. */
1013 /* Start address of the memory dump. */
1014 addr
= parse_and_eval_address (argv
[0]);
1015 /* The format character to use when displaying a memory word. See
1016 the ``x'' command. */
1017 word_format
= argv
[1][0];
1018 /* The size of the memory word. */
1019 word_size
= atol (argv
[2]);
1021 /* Calculate the real address of the write destination. */
1022 addr
+= (offset
* word_size
);
1024 /* Get the value as a number */
1025 value
= parse_and_eval_address (argv
[3]);
1026 /* Get the value into an array */
1027 buffer
= (unsigned char *) xmalloc (word_size
);
1028 store_signed_integer (buffer
, word_size
, value
);
1029 /* Write it down to memory */
1030 write_memory (addr
, buffer
, word_size
);
1035 /* Execute a command within a safe environment. Return >0 for
1036 ok. Return <0 for supress prompt. Return 0 to have the error
1037 extracted from error_last_message(). */
1040 captured_mi_execute_command (void *data
)
1042 struct mi_parse
*context
= data
;
1043 enum mi_cmd_result rc
;
1045 switch (context
->op
)
1049 /* A MI command was read from the input stream */
1051 /* FIXME: gdb_???? */
1052 fprintf_unfiltered (raw_stdout
, " token=`%s' command=`%s' args=`%s'\n",
1053 context
->token
, context
->command
, context
->args
);
1054 /* FIXME: cagney/1999-09-25: Rather than this convoluted
1055 condition expression, each function should return an
1056 indication of what action is required and then switch on
1058 rc
= mi_cmd_execute (context
);
1059 if (!target_can_async_p () || !target_executing
)
1061 /* print the result if there were no errors */
1062 if (rc
== MI_CMD_DONE
)
1064 fputs_unfiltered (context
->token
, raw_stdout
);
1065 fputs_unfiltered ("^done", raw_stdout
);
1066 mi_out_put (uiout
, raw_stdout
);
1067 mi_out_rewind (uiout
);
1068 fputs_unfiltered ("\n", raw_stdout
);
1070 else if (rc
== MI_CMD_ERROR
)
1072 if (mi_error_message
)
1074 fputs_unfiltered (context
->token
, raw_stdout
);
1075 fputs_unfiltered ("^error,msg=\"", raw_stdout
);
1076 fputstr_unfiltered (mi_error_message
, '"', raw_stdout
);
1077 free (mi_error_message
);
1078 fputs_unfiltered ("\"\n", raw_stdout
);
1080 mi_out_rewind (uiout
);
1082 else if (rc
== MI_CMD_CAUGHT_ERROR
)
1084 mi_out_rewind (uiout
);
1088 mi_out_rewind (uiout
);
1090 else if (sync_execution
)
1091 /* Don't print the prompt. We are executing the target in
1092 synchronous mode. */
1097 /* A CLI command was read from the input stream */
1098 /* This will be removed as soon as we have a complete set of
1100 /* echo the command on the console. */
1101 fprintf_unfiltered (gdb_stdlog
, "%s\n", context
->command
);
1102 /* FIXME: If the command string has something that looks like
1103 a format spec (e.g. %s) we will get a core dump */
1104 mi_execute_cli_command ("%s", context
->command
);
1105 /* print the result */
1106 /* FIXME: Check for errors here. */
1107 fputs_unfiltered (context
->token
, raw_stdout
);
1108 fputs_unfiltered ("^done", raw_stdout
);
1109 mi_out_put (uiout
, raw_stdout
);
1110 mi_out_rewind (uiout
);
1111 fputs_unfiltered ("\n", raw_stdout
);
1120 mi_execute_command (char *cmd
, int from_tty
)
1122 struct mi_parse
*command
;
1124 /* This is to handle EOF (^D). We just quit gdb. */
1125 /* FIXME: we should call some API function here. */
1127 quit_force (NULL
, from_tty
);
1129 command
= mi_parse (cmd
);
1131 if (command
!= NULL
)
1133 /* FIXME: cagney/1999-11-04: Can this use of catch_errors either
1134 be pushed even further down or even eliminated? */
1135 int rc
= catch_errors (captured_mi_execute_command
, command
, "",
1139 /* The command is executing synchronously. Bail out early
1140 suppressing the finished prompt. */
1141 mi_parse_free (command
);
1146 char *msg
= error_last_message ();
1147 struct cleanup
*cleanup
= make_cleanup (free
, msg
);
1148 /* The command execution failed and error() was called
1150 fputs_unfiltered (command
->token
, raw_stdout
);
1151 fputs_unfiltered ("^error,msg=\"", raw_stdout
);
1152 fputstr_unfiltered (msg
, '"', raw_stdout
);
1153 fputs_unfiltered ("\"\n", raw_stdout
);
1155 mi_parse_free (command
);
1158 gdb_flush (raw_stdout
);
1159 fputs_unfiltered ("(gdb) \n", raw_stdout
);
1160 /* print any buffered hook code */
1164 static enum mi_cmd_result
1165 mi_cmd_execute (struct mi_parse
*parse
)
1167 if (parse
->cmd
->argv_func
!= NULL
1168 || parse
->cmd
->args_func
!= NULL
)
1170 /* FIXME: We need to save the token because the command executed
1171 may be asynchronous and need to print the token again.
1172 In the future we can pass the token down to the func
1173 and get rid of the last_async_command */
1174 /* The problem here is to keep the token around when we launch
1175 the target, and we want to interrupt it later on. The
1176 interrupt command will have its own token, but when the
1177 target stops, we must display the token corresponding to the
1178 last execution command given. So we have another string where
1179 we copy the token (previous_async_command), if this was
1180 indeed the token of an execution command, and when we stop we
1181 print that one. This is possible because the interrupt
1182 command, when over, will copy that token back into the
1183 default token string (last_async_command). */
1185 if (target_executing
)
1187 if (!previous_async_command
)
1188 previous_async_command
= xstrdup (last_async_command
);
1189 if (strcmp (parse
->command
, "exec-interrupt"))
1191 fputs_unfiltered (parse
->token
, raw_stdout
);
1192 fputs_unfiltered ("^error,msg=\"", raw_stdout
);
1193 fputs_unfiltered ("Cannot execute command ", raw_stdout
);
1194 fputstr_unfiltered (parse
->command
, '"', raw_stdout
);
1195 fputs_unfiltered (" while target running", raw_stdout
);
1196 fputs_unfiltered ("\"\n", raw_stdout
);
1197 return MI_CMD_ERROR
;
1200 last_async_command
= xstrdup (parse
->token
);
1201 make_exec_cleanup (free_current_contents
, &last_async_command
);
1202 /* FIXME: DELETE THIS! */
1203 if (parse
->cmd
->args_func
!= NULL
)
1204 return parse
->cmd
->args_func (parse
->args
, 0 /*from_tty */ );
1205 return parse
->cmd
->argv_func (parse
->command
, parse
->argv
, parse
->argc
);
1207 else if (parse
->cmd
->cli
!= 0)
1209 /* FIXME: DELETE THIS. */
1210 /* The operation is still implemented by a cli command */
1211 /* Must be a synchronous one */
1212 mi_execute_cli_command (parse
->cmd
->cli
, parse
->args
);
1217 /* FIXME: DELETE THIS. */
1218 fputs_unfiltered (parse
->token
, raw_stdout
);
1219 fputs_unfiltered ("^error,msg=\"", raw_stdout
);
1220 fputs_unfiltered ("Undefined mi command: ", raw_stdout
);
1221 fputstr_unfiltered (parse
->command
, '"', raw_stdout
);
1222 fputs_unfiltered (" (missing implementation)", raw_stdout
);
1223 fputs_unfiltered ("\"\n", raw_stdout
);
1224 return MI_CMD_ERROR
;
1229 mi_execute_command_wrapper (char *cmd
)
1231 mi_execute_command (cmd
, stdin
== instream
);
1234 /* FIXME: This is just a hack so we can get some extra commands going.
1235 We don't want to channel things through the CLI, but call libgdb directly */
1236 /* Use only for synchronous commands */
1239 mi_execute_cli_command (const char *cli
, char *args
)
1243 struct cleanup
*old_cleanups
;
1245 asprintf (&run
, cli
, args
);
1247 /* FIXME: gdb_???? */
1248 fprintf_unfiltered (gdb_stdout
, "cli=%s run=%s\n",
1252 old_cleanups
= make_cleanup (free
, run
);
1253 execute_command ( /*ui */ run
, 0 /*from_tty */ );
1254 do_cleanups (old_cleanups
);
1260 mi_execute_async_cli_command (char *mi
, char *args
, int from_tty
)
1262 struct cleanup
*old_cleanups
;
1266 if (target_can_async_p ())
1268 async_args
= (char *) xmalloc (strlen (args
) + 2);
1269 make_exec_cleanup (free
, async_args
);
1270 strcpy (async_args
, args
);
1271 strcat (async_args
, "&");
1272 asprintf (&run
, "%s %s", mi
, async_args
);
1274 internal_error ("mi_execute_async_cli_command: no memory");
1275 make_exec_cleanup (free
, run
);
1276 add_continuation (mi_exec_async_cli_cmd_continuation
, NULL
);
1280 asprintf (&run
, "%s %s", mi
, args
);
1282 internal_error ("mi_execute_async_cli_command: no memory");
1283 old_cleanups
= make_cleanup (free
, run
);
1286 if (!target_can_async_p ())
1288 /* NOTE: For synchronous targets asynchronous behavour is faked by
1289 printing out the GDB prompt before we even try to execute the
1291 if (last_async_command
)
1292 fputs_unfiltered (last_async_command
, raw_stdout
);
1293 fputs_unfiltered ("^running\n", raw_stdout
);
1294 fputs_unfiltered ("(gdb) \n", raw_stdout
);
1298 /* FIXME: cagney/1999-11-29: Printing this message before
1299 calling execute_command is wrong. It should only be printed
1300 once gdb has confirmed that it really has managed to send a
1301 run command to the target. */
1302 if (last_async_command
)
1303 fputs_unfiltered (last_async_command
, raw_stdout
);
1304 fputs_unfiltered ("^running\n", raw_stdout
);
1307 execute_command ( /*ui */ run
, 0 /*from_tty */ );
1309 if (!target_can_async_p ())
1311 /* Do this before doing any printing. It would appear that some
1312 print code leaves garbage around in the buffer. */
1313 do_cleanups (old_cleanups
);
1314 /* If the target was doing the operation synchronously we fake
1315 the stopped message. */
1316 if (last_async_command
)
1317 fputs_unfiltered (last_async_command
, raw_stdout
);
1318 fputs_unfiltered ("*stopped", raw_stdout
);
1319 mi_out_put (uiout
, raw_stdout
);
1320 mi_out_rewind (uiout
);
1321 fputs_unfiltered ("\n", raw_stdout
);
1322 return MI_CMD_QUIET
;
1328 mi_exec_async_cli_cmd_continuation (struct continuation_arg
*arg
)
1330 if (last_async_command
)
1331 fputs_unfiltered (last_async_command
, raw_stdout
);
1332 fputs_unfiltered ("*stopped", raw_stdout
);
1333 mi_out_put (uiout
, raw_stdout
);
1334 fputs_unfiltered ("\n", raw_stdout
);
1335 fputs_unfiltered ("(gdb) \n", raw_stdout
);
1336 do_exec_cleanups (ALL_CLEANUPS
);
1340 mi_input (char *buf
)
1342 return gdb_readline (NULL
);
1346 mi_load_progress (const char *section_name
,
1347 unsigned long sent_so_far
,
1348 unsigned long total_section
,
1349 unsigned long total_sent
,
1350 unsigned long grand_total
)
1352 struct timeval time_now
, delta
, update_threshold
;
1353 static struct timeval last_update
;
1354 static char *previous_sect_name
= NULL
;
1357 if (!interpreter_p
|| strcmp (interpreter_p
, "mi") != 0)
1360 update_threshold
.tv_sec
= 0;
1361 update_threshold
.tv_usec
= 500000;
1362 gettimeofday (&time_now
, NULL
);
1364 delta
.tv_usec
= time_now
.tv_usec
- last_update
.tv_usec
;
1365 delta
.tv_sec
= time_now
.tv_sec
- last_update
.tv_sec
;
1367 if (delta
.tv_usec
< 0)
1370 delta
.tv_usec
+= 1000000;
1373 new_section
= (previous_sect_name
?
1374 strcmp (previous_sect_name
, section_name
) : 1);
1377 free (previous_sect_name
);
1378 previous_sect_name
= xstrdup (section_name
);
1380 if (last_async_command
)
1381 fputs_unfiltered (last_async_command
, raw_stdout
);
1382 fputs_unfiltered ("+download", raw_stdout
);
1383 ui_out_list_begin (uiout
, NULL
);
1384 ui_out_field_string (uiout
, "section", section_name
);
1385 ui_out_field_int (uiout
, "section-size", total_section
);
1386 ui_out_field_int (uiout
, "total-size", grand_total
);
1387 ui_out_list_end (uiout
);
1388 mi_out_put (uiout
, raw_stdout
);
1389 fputs_unfiltered ("\n", raw_stdout
);
1390 gdb_flush (raw_stdout
);
1393 if (delta
.tv_sec
>= update_threshold
.tv_sec
&&
1394 delta
.tv_usec
>= update_threshold
.tv_usec
)
1396 last_update
.tv_sec
= time_now
.tv_sec
;
1397 last_update
.tv_usec
= time_now
.tv_usec
;
1398 if (last_async_command
)
1399 fputs_unfiltered (last_async_command
, raw_stdout
);
1400 fputs_unfiltered ("+download", raw_stdout
);
1401 ui_out_list_begin (uiout
, NULL
);
1402 ui_out_field_string (uiout
, "section", section_name
);
1403 ui_out_field_int (uiout
, "section-sent", sent_so_far
);
1404 ui_out_field_int (uiout
, "section-size", total_section
);
1405 ui_out_field_int (uiout
, "total-sent", total_sent
);
1406 ui_out_field_int (uiout
, "total-size", grand_total
);
1407 ui_out_list_end (uiout
);
1408 mi_out_put (uiout
, raw_stdout
);
1409 fputs_unfiltered ("\n", raw_stdout
);
1410 gdb_flush (raw_stdout
);
1415 mi_command_loop (void)
1417 /* HACK: Force stdout/stderr to point at the console. This avoids
1418 any potential side effects caused by legacy code that is still
1419 using the TUI / fputs_unfiltered_hook */
1420 raw_stdout
= stdio_fileopen (stdout
);
1421 /* Route normal output through the MIx */
1422 gdb_stdout
= mi_console_file_new (raw_stdout
, "~");
1423 /* Route error and log output through the MI */
1424 gdb_stderr
= mi_console_file_new (raw_stdout
, "&");
1425 gdb_stdlog
= gdb_stderr
;
1426 /* Route target output through the MI. */
1427 gdb_stdtarg
= mi_console_file_new (raw_stdout
, "@");
1429 /* HACK: Poke the ui_out table directly. Should we be creating a
1430 mi_out object wired up to the above gdb_stdout / gdb_stderr? */
1431 uiout
= mi_out_new ();
1433 /* HACK: Override any other interpreter hooks. We need to create a
1434 real event table and pass in that. */
1436 /* command_loop_hook = 0; */
1437 print_frame_info_listing_hook
= 0;
1440 create_breakpoint_hook
= 0;
1441 delete_breakpoint_hook
= 0;
1442 modify_breakpoint_hook
= 0;
1443 interactive_hook
= 0;
1444 registers_changed_hook
= 0;
1445 readline_begin_hook
= 0;
1447 readline_end_hook
= 0;
1448 register_changed_hook
= 0;
1449 memory_changed_hook
= 0;
1451 target_wait_hook
= 0;
1452 call_command_hook
= 0;
1454 error_begin_hook
= 0;
1455 show_load_progress
= mi_load_progress
;
1457 /* Turn off 8 bit strings in quoted output. Any character with the
1458 high bit set is printed using C's octal format. */
1459 sevenbit_strings
= 1;
1461 /* Tell the world that we're alive */
1462 fputs_unfiltered ("(gdb) \n", raw_stdout
);
1465 simplified_command_loop (mi_input
, mi_execute_command
);
1467 start_event_loop ();
1471 setup_architecture_data (void)
1473 /* don't trust REGISTER_BYTES to be zero. */
1474 old_regs
= xmalloc (REGISTER_BYTES
+ 1);
1475 memset (old_regs
, 0, REGISTER_BYTES
+ 1);
1479 mi_init_ui (char *arg0
)
1481 /* Eventually this will contain code that takes control of the
1486 _initialize_mi_main (void)
1488 /* If we're _the_ interpreter, take control. */
1490 && strcmp (interpreter_p
, "mi") == 0)
1492 init_ui_hook
= mi_init_ui
;
1493 command_loop_hook
= mi_command_loop
;
1494 setup_architecture_data ();
1495 register_gdbarch_swap (&old_regs
, sizeof (old_regs
), NULL
);
1496 register_gdbarch_swap (NULL
, 0, setup_architecture_data
);
1499 /* These overwrite some of the initialization done in
1500 _intialize_event_loop. */
1501 call_readline
= gdb_readline2
;
1502 input_handler
= mi_execute_command_wrapper
;
1503 add_file_handler (input_fd
, stdin_event_handler
, 0);
1504 async_command_editing_p
= 0;
1507 /* FIXME: Should we notify main that we are here as a possible