3 Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008
4 Free Software Foundation, Inc.
6 Contributed by Cygnus Solutions (a Red Hat company).
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 /* Work in progress. */
28 #include "gdb_string.h"
29 #include "exceptions.h"
31 #include "gdbthread.h"
34 #include "mi-getopt.h"
35 #include "mi-console.h"
39 #include "event-loop.h"
40 #include "event-top.h"
41 #include "gdbcore.h" /* For write_memory(). */
52 #if defined HAVE_SYS_RESOURCE_H
53 #include <sys/resource.h>
66 struct ui_file *raw_stdout;
68 /* This is used to pass the current command timestamp
69 down to continuation routines. */
70 static struct mi_timestamp *current_command_ts;
72 static int do_timings = 0;
75 int running_result_record_printed = 1;
77 extern void _initialize_mi_main (void);
78 static void mi_cmd_execute (struct mi_parse *parse);
80 static void mi_execute_cli_command (const char *cmd, int args_p,
82 static void mi_execute_async_cli_command (char *cli_command,
83 char **argv, int argc);
84 static int register_changed_p (int regnum, struct regcache *,
86 static void get_register (int regnum, int format);
88 /* Command implementations. FIXME: Is this libgdb? No. This is the MI
89 layer that calls libgdb. Any operation used in the below should be
92 static void timestamp (struct mi_timestamp *tv);
94 static void print_diff_now (struct mi_timestamp *start);
95 static void print_diff (struct mi_timestamp *start, struct mi_timestamp *end);
98 mi_cmd_gdb_exit (char *command, char **argv, int argc)
100 /* We have to print everything right here because we never return. */
102 fputs_unfiltered (current_token, raw_stdout);
103 fputs_unfiltered ("^exit\n", raw_stdout);
104 mi_out_put (uiout, raw_stdout);
105 /* FIXME: The function called is not yet a formal libgdb function. */
106 quit_force (NULL, FROM_TTY);
110 mi_cmd_exec_next (char *command, char **argv, int argc)
112 /* FIXME: Should call a libgdb function, not a cli wrapper. */
113 return mi_execute_async_cli_command ("next", argv, argc);
117 mi_cmd_exec_next_instruction (char *command, char **argv, int argc)
119 /* FIXME: Should call a libgdb function, not a cli wrapper. */
120 return mi_execute_async_cli_command ("nexti", argv, argc);
124 mi_cmd_exec_step (char *command, char **argv, int argc)
126 /* FIXME: Should call a libgdb function, not a cli wrapper. */
127 return mi_execute_async_cli_command ("step", argv, argc);
131 mi_cmd_exec_step_instruction (char *command, char **argv, int argc)
133 /* FIXME: Should call a libgdb function, not a cli wrapper. */
134 return mi_execute_async_cli_command ("stepi", argv, argc);
138 mi_cmd_exec_finish (char *command, char **argv, int argc)
140 /* FIXME: Should call a libgdb function, not a cli wrapper. */
141 return mi_execute_async_cli_command ("finish", argv, argc);
145 mi_cmd_exec_return (char *command, char **argv, int argc)
147 /* This command doesn't really execute the target, it just pops the
148 specified number of frames. */
150 /* Call return_command with from_tty argument equal to 0 so as to
151 avoid being queried. */
152 return_command (*argv, 0);
154 /* Call return_command with from_tty argument equal to 0 so as to
155 avoid being queried. */
156 return_command (NULL, 0);
158 /* Because we have called return_command with from_tty = 0, we need
159 to print the frame here. */
160 print_stack_frame (get_selected_frame (NULL), 1, LOC_AND_ADDRESS);
164 mi_cmd_exec_continue (char *command, char **argv, int argc)
168 else if (argc == 1 && strcmp (argv[0], "--all") == 0)
171 error ("Usage: -exec-continue [--all]");
174 /* Interrupt the execution of the target. Note how we must play around
175 with the token variables, in order to display the current token in
176 the result of the interrupt command, and the previous execution
177 token when the target finally stops. See comments in
180 mi_cmd_exec_interrupt (char *command, char **argv, int argc)
184 if (!is_running (inferior_ptid))
185 error ("Current thread is not running.");
187 interrupt_target_1 (0);
189 else if (argc == 1 && strcmp (argv[0], "--all") == 0)
192 error ("Inferior not running.");
194 interrupt_target_1 (1);
197 error ("Usage: -exec-interrupt [--all]");
201 mi_cmd_thread_select (char *command, char **argv, int argc)
204 char *mi_error_message;
207 error ("mi_cmd_thread_select: USAGE: threadnum.");
209 rc = gdb_thread_select (uiout, argv[0], &mi_error_message);
211 if (rc == GDB_RC_FAIL)
213 make_cleanup (xfree, mi_error_message);
214 error ("%s", mi_error_message);
219 mi_cmd_thread_list_ids (char *command, char **argv, int argc)
222 char *mi_error_message;
225 error ("mi_cmd_thread_list_ids: No arguments required.");
227 rc = gdb_list_thread_ids (uiout, &mi_error_message);
229 if (rc == GDB_RC_FAIL)
231 make_cleanup (xfree, mi_error_message);
232 error ("%s", mi_error_message);
237 mi_cmd_thread_info (char *command, char **argv, int argc)
241 if (argc != 0 && argc != 1)
242 error ("Invalid MI command");
245 thread = atoi (argv[0]);
247 print_thread_info (uiout, thread);
251 mi_cmd_data_list_register_names (char *command, char **argv, int argc)
255 struct cleanup *cleanup;
257 /* Note that the test for a valid register must include checking the
258 gdbarch_register_name because gdbarch_num_regs may be allocated for
259 the union of the register sets within a family of related processors.
260 In this case, some entries of gdbarch_register_name will change depending
261 upon the particular processor being debugged. */
263 numregs = gdbarch_num_regs (current_gdbarch)
264 + gdbarch_num_pseudo_regs (current_gdbarch);
266 cleanup = make_cleanup_ui_out_list_begin_end (uiout, "register-names");
268 if (argc == 0) /* No args, just do all the regs. */
274 if (gdbarch_register_name (current_gdbarch, regnum) == NULL
275 || *(gdbarch_register_name (current_gdbarch, regnum)) == '\0')
276 ui_out_field_string (uiout, NULL, "");
278 ui_out_field_string (uiout, NULL,
279 gdbarch_register_name
280 (current_gdbarch, regnum));
284 /* Else, list of register #s, just do listed regs. */
285 for (i = 0; i < argc; i++)
287 regnum = atoi (argv[i]);
288 if (regnum < 0 || regnum >= numregs)
289 error ("bad register number");
291 if (gdbarch_register_name (current_gdbarch, regnum) == NULL
292 || *(gdbarch_register_name (current_gdbarch, regnum)) == '\0')
293 ui_out_field_string (uiout, NULL, "");
295 ui_out_field_string (uiout, NULL,
296 gdbarch_register_name (current_gdbarch, regnum));
298 do_cleanups (cleanup);
302 mi_cmd_data_list_changed_registers (char *command, char **argv, int argc)
304 static struct regcache *this_regs = NULL;
305 struct regcache *prev_regs;
306 int regnum, numregs, changed;
308 struct cleanup *cleanup;
310 /* The last time we visited this function, the current frame's register
311 contents were saved in THIS_REGS. Move THIS_REGS over to PREV_REGS,
312 and refresh THIS_REGS with the now-current register contents. */
314 prev_regs = this_regs;
315 this_regs = frame_save_as_regcache (get_selected_frame (NULL));
316 cleanup = make_cleanup_regcache_xfree (prev_regs);
318 /* Note that the test for a valid register must include checking the
319 gdbarch_register_name because gdbarch_num_regs may be allocated for
320 the union of the register sets within a family of related processors.
321 In this case, some entries of gdbarch_register_name will change depending
322 upon the particular processor being debugged. */
324 numregs = gdbarch_num_regs (current_gdbarch)
325 + gdbarch_num_pseudo_regs (current_gdbarch);
327 make_cleanup_ui_out_list_begin_end (uiout, "changed-registers");
329 if (argc == 0) /* No args, just do all the regs. */
335 if (gdbarch_register_name (current_gdbarch, regnum) == NULL
336 || *(gdbarch_register_name (current_gdbarch, regnum)) == '\0')
338 changed = register_changed_p (regnum, prev_regs, this_regs);
340 error ("mi_cmd_data_list_changed_registers: Unable to read register contents.");
342 ui_out_field_int (uiout, NULL, regnum);
346 /* Else, list of register #s, just do listed regs. */
347 for (i = 0; i < argc; i++)
349 regnum = atoi (argv[i]);
353 && gdbarch_register_name (current_gdbarch, regnum) != NULL
354 && *gdbarch_register_name (current_gdbarch, regnum) != '\000')
356 changed = register_changed_p (regnum, prev_regs, this_regs);
358 error ("mi_cmd_data_list_register_change: Unable to read register contents.");
360 ui_out_field_int (uiout, NULL, regnum);
363 error ("bad register number");
365 do_cleanups (cleanup);
369 register_changed_p (int regnum, struct regcache *prev_regs,
370 struct regcache *this_regs)
372 struct gdbarch *gdbarch = get_regcache_arch (this_regs);
373 gdb_byte prev_buffer[MAX_REGISTER_SIZE];
374 gdb_byte this_buffer[MAX_REGISTER_SIZE];
376 /* Registers not valid in this frame return count as unchanged. */
377 if (!regcache_valid_p (this_regs, regnum))
380 /* First time through or after gdbarch change consider all registers as
381 changed. Same for registers not valid in the previous frame. */
382 if (!prev_regs || get_regcache_arch (prev_regs) != gdbarch
383 || !regcache_valid_p (prev_regs, regnum))
386 /* Get register contents and compare. */
387 regcache_cooked_read (prev_regs, regnum, prev_buffer);
388 regcache_cooked_read (this_regs, regnum, this_buffer);
390 return memcmp (prev_buffer, this_buffer,
391 register_size (gdbarch, regnum)) != 0;
394 /* Return a list of register number and value pairs. The valid
395 arguments expected are: a letter indicating the format in which to
396 display the registers contents. This can be one of: x (hexadecimal), d
397 (decimal), N (natural), t (binary), o (octal), r (raw). After the
398 format argumetn there can be a sequence of numbers, indicating which
399 registers to fetch the content of. If the format is the only argument,
400 a list of all the registers with their values is returned. */
402 mi_cmd_data_list_register_values (char *command, char **argv, int argc)
404 int regnum, numregs, format;
406 struct cleanup *list_cleanup, *tuple_cleanup;
408 /* Note that the test for a valid register must include checking the
409 gdbarch_register_name because gdbarch_num_regs may be allocated for
410 the union of the register sets within a family of related processors.
411 In this case, some entries of gdbarch_register_name will change depending
412 upon the particular processor being debugged. */
414 numregs = gdbarch_num_regs (current_gdbarch)
415 + gdbarch_num_pseudo_regs (current_gdbarch);
418 error ("mi_cmd_data_list_register_values: Usage: -data-list-register-values <format> [<regnum1>...<regnumN>]");
420 format = (int) argv[0][0];
422 list_cleanup = make_cleanup_ui_out_list_begin_end (uiout, "register-values");
424 if (argc == 1) /* No args, beside the format: do all the regs. */
430 if (gdbarch_register_name (current_gdbarch, regnum) == NULL
431 || *(gdbarch_register_name (current_gdbarch, regnum)) == '\0')
433 tuple_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
434 ui_out_field_int (uiout, "number", regnum);
435 get_register (regnum, format);
436 do_cleanups (tuple_cleanup);
440 /* Else, list of register #s, just do listed regs. */
441 for (i = 1; i < argc; i++)
443 regnum = atoi (argv[i]);
447 && gdbarch_register_name (current_gdbarch, regnum) != NULL
448 && *gdbarch_register_name (current_gdbarch, regnum) != '\000')
450 tuple_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
451 ui_out_field_int (uiout, "number", regnum);
452 get_register (regnum, format);
453 do_cleanups (tuple_cleanup);
456 error ("bad register number");
458 do_cleanups (list_cleanup);
461 /* Output one register's contents in the desired format. */
463 get_register (int regnum, int format)
465 gdb_byte buffer[MAX_REGISTER_SIZE];
470 static struct ui_stream *stb = NULL;
472 stb = ui_out_stream_new (uiout);
477 frame_register (get_selected_frame (NULL), regnum, &optim, &lval, &addr,
481 error ("Optimized out");
486 char *ptr, buf[1024];
490 for (j = 0; j < register_size (current_gdbarch, regnum); j++)
492 int idx = gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG ? j
493 : register_size (current_gdbarch, regnum) - 1 - j;
494 sprintf (ptr, "%02x", (unsigned char) buffer[idx]);
497 ui_out_field_string (uiout, "value", buf);
498 /*fputs_filtered (buf, gdb_stdout); */
502 val_print (register_type (current_gdbarch, regnum), buffer, 0, 0,
503 stb->stream, format, 1, 0, Val_pretty_default,
505 ui_out_field_stream (uiout, "value", stb);
506 ui_out_stream_delete (stb);
510 /* Write given values into registers. The registers and values are
511 given as pairs. The corresponding MI command is
512 -data-write-register-values <format> [<regnum1> <value1>...<regnumN> <valueN>]*/
514 mi_cmd_data_write_register_values (char *command, char **argv, int argc)
519 /* Note that the test for a valid register must include checking the
520 gdbarch_register_name because gdbarch_num_regs may be allocated for
521 the union of the register sets within a family of related processors.
522 In this case, some entries of gdbarch_register_name will change depending
523 upon the particular processor being debugged. */
525 numregs = gdbarch_num_regs (current_gdbarch)
526 + gdbarch_num_pseudo_regs (current_gdbarch);
529 error ("mi_cmd_data_write_register_values: Usage: -data-write-register-values <format> [<regnum1> <value1>...<regnumN> <valueN>]");
531 format = (int) argv[0][0];
533 if (!target_has_registers)
534 error ("mi_cmd_data_write_register_values: No registers.");
537 error ("mi_cmd_data_write_register_values: No regs and values specified.");
540 error ("mi_cmd_data_write_register_values: Regs and vals are not in pairs.");
542 for (i = 1; i < argc; i = i + 2)
544 int regnum = atoi (argv[i]);
546 if (regnum >= 0 && regnum < numregs
547 && gdbarch_register_name (current_gdbarch, regnum)
548 && *gdbarch_register_name (current_gdbarch, regnum))
552 /* Get the value as a number. */
553 value = parse_and_eval_address (argv[i + 1]);
556 regcache_cooked_write_signed (get_current_regcache (), regnum, value);
559 error ("bad register number");
563 /* Evaluate the value of the argument. The argument is an
564 expression. If the expression contains spaces it needs to be
565 included in double quotes. */
567 mi_cmd_data_evaluate_expression (char *command, char **argv, int argc)
569 struct expression *expr;
570 struct cleanup *old_chain = NULL;
572 struct ui_stream *stb = NULL;
574 stb = ui_out_stream_new (uiout);
578 ui_out_stream_delete (stb);
579 error ("mi_cmd_data_evaluate_expression: Usage: -data-evaluate-expression expression");
582 expr = parse_expression (argv[0]);
584 old_chain = make_cleanup (free_current_contents, &expr);
586 val = evaluate_expression (expr);
588 /* Print the result of the expression evaluation. */
589 val_print (value_type (val), value_contents (val),
590 value_embedded_offset (val), VALUE_ADDRESS (val),
591 stb->stream, 0, 0, 0, 0, current_language);
593 ui_out_field_stream (uiout, "value", stb);
594 ui_out_stream_delete (stb);
596 do_cleanups (old_chain);
601 ADDR: start address of data to be dumped.
602 WORD-FORMAT: a char indicating format for the ``word''. See
604 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes.
605 NR_ROW: Number of rows.
606 NR_COL: The number of colums (words per row).
607 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
608 ASCHAR for unprintable characters.
610 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
611 displayes them. Returns:
613 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
616 The number of bytes read is SIZE*ROW*COL. */
619 mi_cmd_data_read_memory (char *command, char **argv, int argc)
621 struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
627 struct type *word_type;
640 static struct mi_opt opts[] =
642 {"o", OFFSET_OPT, 1},
648 int opt = mi_getopt ("mi_cmd_data_read_memory", argc, argv, opts,
652 switch ((enum opt) opt)
655 offset = atol (optarg);
662 if (argc < 5 || argc > 6)
663 error ("mi_cmd_data_read_memory: Usage: ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR].");
665 /* Extract all the arguments. */
667 /* Start address of the memory dump. */
668 addr = parse_and_eval_address (argv[0]) + offset;
669 /* The format character to use when displaying a memory word. See
670 the ``x'' command. */
671 word_format = argv[1][0];
672 /* The size of the memory word. */
673 word_size = atol (argv[2]);
677 word_type = builtin_type_int8;
681 word_type = builtin_type_int16;
685 word_type = builtin_type_int32;
689 word_type = builtin_type_int64;
693 word_type = builtin_type_int8;
696 /* The number of rows. */
697 nr_rows = atol (argv[3]);
699 error ("mi_cmd_data_read_memory: invalid number of rows.");
701 /* Number of bytes per row. */
702 nr_cols = atol (argv[4]);
704 error ("mi_cmd_data_read_memory: invalid number of columns.");
706 /* The un-printable character when printing ascii. */
712 /* Create a buffer and read it in. */
713 total_bytes = word_size * nr_rows * nr_cols;
714 mbuf = xcalloc (total_bytes, 1);
715 make_cleanup (xfree, mbuf);
717 nr_bytes = target_read_until_error (¤t_target, TARGET_OBJECT_MEMORY,
718 NULL, mbuf, addr, total_bytes);
720 error ("Unable to read memory.");
722 /* Output the header information. */
723 ui_out_field_core_addr (uiout, "addr", addr);
724 ui_out_field_int (uiout, "nr-bytes", nr_bytes);
725 ui_out_field_int (uiout, "total-bytes", total_bytes);
726 ui_out_field_core_addr (uiout, "next-row", addr + word_size * nr_cols);
727 ui_out_field_core_addr (uiout, "prev-row", addr - word_size * nr_cols);
728 ui_out_field_core_addr (uiout, "next-page", addr + total_bytes);
729 ui_out_field_core_addr (uiout, "prev-page", addr - total_bytes);
731 /* Build the result as a two dimentional table. */
733 struct ui_stream *stream = ui_out_stream_new (uiout);
734 struct cleanup *cleanup_list_memory;
737 cleanup_list_memory = make_cleanup_ui_out_list_begin_end (uiout, "memory");
738 for (row = 0, row_byte = 0;
740 row++, row_byte += nr_cols * word_size)
744 struct cleanup *cleanup_tuple;
745 struct cleanup *cleanup_list_data;
746 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
747 ui_out_field_core_addr (uiout, "addr", addr + row_byte);
748 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr + row_byte); */
749 cleanup_list_data = make_cleanup_ui_out_list_begin_end (uiout, "data");
750 for (col = 0, col_byte = row_byte;
752 col++, col_byte += word_size)
754 if (col_byte + word_size > nr_bytes)
756 ui_out_field_string (uiout, NULL, "N/A");
760 ui_file_rewind (stream->stream);
761 print_scalar_formatted (mbuf + col_byte, word_type, word_format,
762 word_asize, stream->stream);
763 ui_out_field_stream (uiout, NULL, stream);
766 do_cleanups (cleanup_list_data);
770 ui_file_rewind (stream->stream);
771 for (byte = row_byte; byte < row_byte + word_size * nr_cols; byte++)
773 if (byte >= nr_bytes)
775 fputc_unfiltered ('X', stream->stream);
777 else if (mbuf[byte] < 32 || mbuf[byte] > 126)
779 fputc_unfiltered (aschar, stream->stream);
782 fputc_unfiltered (mbuf[byte], stream->stream);
784 ui_out_field_stream (uiout, "ascii", stream);
786 do_cleanups (cleanup_tuple);
788 ui_out_stream_delete (stream);
789 do_cleanups (cleanup_list_memory);
791 do_cleanups (cleanups);
794 /* DATA-MEMORY-WRITE:
796 COLUMN_OFFSET: optional argument. Must be preceeded by '-o'. The
797 offset from the beginning of the memory grid row where the cell to
799 ADDR: start address of the row in the memory grid where the memory
800 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
801 the location to write to.
802 FORMAT: a char indicating format for the ``word''. See
804 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
805 VALUE: value to be written into the memory address.
807 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
811 mi_cmd_data_write_memory (char *command, char **argv, int argc)
816 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
817 enough when using a compiler other than GCC. */
820 struct cleanup *old_chain;
828 static struct mi_opt opts[] =
830 {"o", OFFSET_OPT, 1},
836 int opt = mi_getopt ("mi_cmd_data_write_memory", argc, argv, opts,
840 switch ((enum opt) opt)
843 offset = atol (optarg);
851 error ("mi_cmd_data_write_memory: Usage: [-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE.");
853 /* Extract all the arguments. */
854 /* Start address of the memory dump. */
855 addr = parse_and_eval_address (argv[0]);
856 /* The format character to use when displaying a memory word. See
857 the ``x'' command. */
858 word_format = argv[1][0];
859 /* The size of the memory word. */
860 word_size = atol (argv[2]);
862 /* Calculate the real address of the write destination. */
863 addr += (offset * word_size);
865 /* Get the value as a number. */
866 value = parse_and_eval_address (argv[3]);
867 /* Get the value into an array. */
868 buffer = xmalloc (word_size);
869 old_chain = make_cleanup (xfree, buffer);
870 store_signed_integer (buffer, word_size, value);
871 /* Write it down to memory. */
872 write_memory (addr, buffer, word_size);
873 /* Free the buffer. */
874 do_cleanups (old_chain);
878 mi_cmd_enable_timings (char *command, char **argv, int argc)
884 if (strcmp (argv[0], "yes") == 0)
886 else if (strcmp (argv[0], "no") == 0)
897 error ("mi_cmd_enable_timings: Usage: %s {yes|no}", command);
901 mi_cmd_list_features (char *command, char **argv, int argc)
905 struct cleanup *cleanup = NULL;
906 cleanup = make_cleanup_ui_out_list_begin_end (uiout, "features");
908 ui_out_field_string (uiout, NULL, "frozen-varobjs");
909 ui_out_field_string (uiout, NULL, "pending-breakpoints");
910 ui_out_field_string (uiout, NULL, "thread-info");
912 do_cleanups (cleanup);
916 error ("-list-features should be passed no arguments");
919 /* Execute a command within a safe environment.
920 Return <0 for error; >=0 for ok.
922 args->action will tell mi_execute_command what action
923 to perfrom after the given command has executed (display/suppress
924 prompt, display error). */
927 captured_mi_execute_command (struct ui_out *uiout, void *data)
929 struct mi_parse *context = (struct mi_parse *) data;
931 struct mi_timestamp cmd_finished;
933 running_result_record_printed = 0;
937 /* A MI command was read from the input stream. */
939 /* FIXME: gdb_???? */
940 fprintf_unfiltered (raw_stdout, " token=`%s' command=`%s' args=`%s'\n",
941 context->token, context->command, context->args);
944 current_command_ts = context->cmd_start;
946 mi_cmd_execute (context);
949 timestamp (&cmd_finished);
951 /* Print the result if there were no errors.
953 Remember that on the way out of executing a command, you have
954 to directly use the mi_interp's uiout, since the command could
955 have reset the interpreter, in which case the current uiout
956 will most likely crash in the mi_out_* routines. */
957 if (!running_result_record_printed)
959 fputs_unfiltered (context->token, raw_stdout);
960 /* There's no particularly good reason why target-connect results
961 in not ^done. Should kill ^connected for MI3. */
962 fputs_unfiltered (strcmp (context->command, "target-select") == 0
963 ? "^connected" : "^done", raw_stdout);
964 mi_out_put (uiout, raw_stdout);
965 mi_out_rewind (uiout);
966 /* Have to check cmd_start, since the command could be
968 if (do_timings && context->cmd_start)
969 print_diff (context->cmd_start, &cmd_finished);
970 fputs_unfiltered ("\n", raw_stdout);
973 /* The command does not want anything to be printed. In that
974 case, the command probably should not have written anything
975 to uiout, but in case it has written something, discard it. */
976 mi_out_rewind (uiout);
982 /* A CLI command was read from the input stream. */
983 /* This "feature" will be removed as soon as we have a
984 complete set of mi commands. */
985 /* Echo the command on the console. */
986 fprintf_unfiltered (gdb_stdlog, "%s\n", context->command);
987 /* Call the "console" interpreter. */
989 argv[1] = context->command;
990 mi_cmd_interpreter_exec ("-interpreter-exec", argv, 2);
992 /* If we changed interpreters, DON'T print out anything. */
993 if (current_interp_named_p (INTERP_MI)
994 || current_interp_named_p (INTERP_MI1)
995 || current_interp_named_p (INTERP_MI2)
996 || current_interp_named_p (INTERP_MI3))
998 if (!running_result_record_printed)
1000 fputs_unfiltered (context->token, raw_stdout);
1001 fputs_unfiltered ("^done", raw_stdout);
1002 mi_out_put (uiout, raw_stdout);
1003 mi_out_rewind (uiout);
1004 fputs_unfiltered ("\n", raw_stdout);
1007 mi_out_rewind (uiout);
1019 mi_execute_command (char *cmd, int from_tty)
1021 struct mi_parse *command;
1022 struct ui_out *saved_uiout = uiout;
1024 /* This is to handle EOF (^D). We just quit gdb. */
1025 /* FIXME: we should call some API function here. */
1027 quit_force (NULL, from_tty);
1029 command = mi_parse (cmd);
1031 if (command != NULL)
1033 struct gdb_exception result;
1037 command->cmd_start = (struct mi_timestamp *)
1038 xmalloc (sizeof (struct mi_timestamp));
1039 timestamp (command->cmd_start);
1042 result = catch_exception (uiout, captured_mi_execute_command, command,
1044 if (result.reason < 0)
1046 /* The command execution failed and error() was called
1048 fputs_unfiltered (command->token, raw_stdout);
1049 fputs_unfiltered ("^error,msg=\"", raw_stdout);
1050 if (result.message == NULL)
1051 fputs_unfiltered ("unknown error", raw_stdout);
1053 fputstr_unfiltered (result.message, '"', raw_stdout);
1054 fputs_unfiltered ("\"\n", raw_stdout);
1055 mi_out_rewind (uiout);
1058 mi_parse_free (command);
1061 fputs_unfiltered ("(gdb) \n", raw_stdout);
1062 gdb_flush (raw_stdout);
1063 /* Print any buffered hook code. */
1068 mi_cmd_execute (struct mi_parse *parse)
1070 struct cleanup *cleanup;
1074 current_token = xstrdup (parse->token);
1075 cleanup = make_cleanup (free_current_contents, ¤t_token);
1077 if (parse->frame != -1 && parse->thread == -1)
1078 error (_("Cannot specify --frame without --thread"));
1080 if (parse->thread != -1)
1082 struct thread_info *tp = find_thread_id (parse->thread);
1084 error (_("Invalid thread id: %d"), parse->thread);
1087 context_switch_to (tp->ptid);
1089 switch_to_thread (tp->ptid);
1092 if (parse->frame != -1)
1094 struct frame_info *fid;
1095 int frame = parse->frame;
1096 fid = find_relative_frame (get_current_frame (), &frame);
1098 /* find_relative_frame was successful */
1101 error (_("Invalid frame id: %d"), frame);
1104 if (parse->cmd->argv_func != NULL)
1106 if (target_can_async_p ()
1107 && target_has_execution
1108 && (is_exited (inferior_ptid))
1109 && (strcmp (parse->command, "thread-info") != 0
1110 && strcmp (parse->command, "thread-list-ids") != 0
1111 && strcmp (parse->command, "thread-select") != 0))
1113 struct ui_file *stb;
1114 stb = mem_fileopen ();
1116 fputs_unfiltered ("Cannot execute command ", stb);
1117 fputstr_unfiltered (parse->command, '"', stb);
1118 fputs_unfiltered (" without a selected thread", stb);
1120 make_cleanup_ui_file_delete (stb);
1124 parse->cmd->argv_func (parse->command, parse->argv, parse->argc);
1126 else if (parse->cmd->cli.cmd != 0)
1128 /* FIXME: DELETE THIS. */
1129 /* The operation is still implemented by a cli command. */
1130 /* Must be a synchronous one. */
1131 mi_execute_cli_command (parse->cmd->cli.cmd, parse->cmd->cli.args_p,
1136 /* FIXME: DELETE THIS. */
1137 struct ui_file *stb;
1139 stb = mem_fileopen ();
1141 fputs_unfiltered ("Undefined mi command: ", stb);
1142 fputstr_unfiltered (parse->command, '"', stb);
1143 fputs_unfiltered (" (missing implementation)", stb);
1145 make_cleanup_ui_file_delete (stb);
1148 do_cleanups (cleanup);
1151 /* FIXME: This is just a hack so we can get some extra commands going.
1152 We don't want to channel things through the CLI, but call libgdb directly.
1153 Use only for synchronous commands. */
1156 mi_execute_cli_command (const char *cmd, int args_p, const char *args)
1160 struct cleanup *old_cleanups;
1163 run = xstrprintf ("%s %s", cmd, args);
1165 run = xstrdup (cmd);
1167 /* FIXME: gdb_???? */
1168 fprintf_unfiltered (gdb_stdout, "cli=%s run=%s\n",
1170 old_cleanups = make_cleanup (xfree, run);
1171 execute_command ( /*ui */ run, 0 /*from_tty */ );
1172 do_cleanups (old_cleanups);
1178 mi_execute_async_cli_command (char *cli_command, char **argv, int argc)
1180 struct cleanup *old_cleanups;
1183 if (target_can_async_p ())
1184 run = xstrprintf ("%s %s&", cli_command, argc ? *argv : "");
1186 run = xstrprintf ("%s %s", cli_command, argc ? *argv : "");
1187 old_cleanups = make_cleanup (xfree, run);
1189 execute_command ( /*ui */ run, 0 /*from_tty */ );
1191 if (target_can_async_p ())
1193 /* If we're not executing, an exception should have been throw. */
1194 gdb_assert (is_running (inferior_ptid));
1195 do_cleanups (old_cleanups);
1199 /* Do this before doing any printing. It would appear that some
1200 print code leaves garbage around in the buffer. */
1201 do_cleanups (old_cleanups);
1203 print_diff_now (current_command_ts);
1208 mi_load_progress (const char *section_name,
1209 unsigned long sent_so_far,
1210 unsigned long total_section,
1211 unsigned long total_sent,
1212 unsigned long grand_total)
1214 struct timeval time_now, delta, update_threshold;
1215 static struct timeval last_update;
1216 static char *previous_sect_name = NULL;
1218 struct ui_out *saved_uiout;
1220 /* This function is called through deprecated_show_load_progress
1221 which means uiout may not be correct. Fix it for the duration
1222 of this function. */
1223 saved_uiout = uiout;
1225 if (current_interp_named_p (INTERP_MI)
1226 || current_interp_named_p (INTERP_MI2))
1227 uiout = mi_out_new (2);
1228 else if (current_interp_named_p (INTERP_MI1))
1229 uiout = mi_out_new (1);
1230 else if (current_interp_named_p (INTERP_MI3))
1231 uiout = mi_out_new (3);
1235 update_threshold.tv_sec = 0;
1236 update_threshold.tv_usec = 500000;
1237 gettimeofday (&time_now, NULL);
1239 delta.tv_usec = time_now.tv_usec - last_update.tv_usec;
1240 delta.tv_sec = time_now.tv_sec - last_update.tv_sec;
1242 if (delta.tv_usec < 0)
1245 delta.tv_usec += 1000000L;
1248 new_section = (previous_sect_name ?
1249 strcmp (previous_sect_name, section_name) : 1);
1252 struct cleanup *cleanup_tuple;
1253 xfree (previous_sect_name);
1254 previous_sect_name = xstrdup (section_name);
1257 fputs_unfiltered (current_token, raw_stdout);
1258 fputs_unfiltered ("+download", raw_stdout);
1259 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1260 ui_out_field_string (uiout, "section", section_name);
1261 ui_out_field_int (uiout, "section-size", total_section);
1262 ui_out_field_int (uiout, "total-size", grand_total);
1263 do_cleanups (cleanup_tuple);
1264 mi_out_put (uiout, raw_stdout);
1265 fputs_unfiltered ("\n", raw_stdout);
1266 gdb_flush (raw_stdout);
1269 if (delta.tv_sec >= update_threshold.tv_sec &&
1270 delta.tv_usec >= update_threshold.tv_usec)
1272 struct cleanup *cleanup_tuple;
1273 last_update.tv_sec = time_now.tv_sec;
1274 last_update.tv_usec = time_now.tv_usec;
1276 fputs_unfiltered (current_token, raw_stdout);
1277 fputs_unfiltered ("+download", raw_stdout);
1278 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1279 ui_out_field_string (uiout, "section", section_name);
1280 ui_out_field_int (uiout, "section-sent", sent_so_far);
1281 ui_out_field_int (uiout, "section-size", total_section);
1282 ui_out_field_int (uiout, "total-sent", total_sent);
1283 ui_out_field_int (uiout, "total-size", grand_total);
1284 do_cleanups (cleanup_tuple);
1285 mi_out_put (uiout, raw_stdout);
1286 fputs_unfiltered ("\n", raw_stdout);
1287 gdb_flush (raw_stdout);
1291 uiout = saved_uiout;
1295 timestamp (struct mi_timestamp *tv)
1298 gettimeofday (&tv->wallclock, NULL);
1299 #ifdef HAVE_GETRUSAGE
1300 getrusage (RUSAGE_SELF, &rusage);
1301 tv->utime.tv_sec = rusage.ru_utime.tv_sec;
1302 tv->utime.tv_usec = rusage.ru_utime.tv_usec;
1303 tv->stime.tv_sec = rusage.ru_stime.tv_sec;
1304 tv->stime.tv_usec = rusage.ru_stime.tv_usec;
1306 usec = get_run_time ();
1307 tv->utime.tv_sec = usec/1000000L;
1308 tv->utime.tv_usec = usec - 1000000L*tv->utime.tv_sec;
1309 tv->stime.tv_sec = 0;
1310 tv->stime.tv_usec = 0;
1315 print_diff_now (struct mi_timestamp *start)
1317 struct mi_timestamp now;
1319 print_diff (start, &now);
1323 timeval_diff (struct timeval start, struct timeval end)
1325 return ((end.tv_sec - start.tv_sec) * 1000000L)
1326 + (end.tv_usec - start.tv_usec);
1330 print_diff (struct mi_timestamp *start, struct mi_timestamp *end)
1334 ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
1335 timeval_diff (start->wallclock, end->wallclock) / 1000000.0,
1336 timeval_diff (start->utime, end->utime) / 1000000.0,
1337 timeval_diff (start->stime, end->stime) / 1000000.0);