3 Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009
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(). */
47 #include "mi-common.h"
56 #if defined HAVE_SYS_RESOURCE_H
57 #include <sys/resource.h>
70 struct ui_file *raw_stdout;
72 /* This is used to pass the current command timestamp
73 down to continuation routines. */
74 static struct mi_timestamp *current_command_ts;
76 static int do_timings = 0;
79 int running_result_record_printed = 1;
81 /* Flag indicating that the target has proceeded since the last
82 command was issued. */
85 extern void _initialize_mi_main (void);
86 static void mi_cmd_execute (struct mi_parse *parse);
88 static void mi_execute_cli_command (const char *cmd, int args_p,
90 static void mi_execute_async_cli_command (char *cli_command,
91 char **argv, int argc);
92 static int register_changed_p (int regnum, struct regcache *,
94 static void get_register (int regnum, int format);
96 /* Command implementations. FIXME: Is this libgdb? No. This is the MI
97 layer that calls libgdb. Any operation used in the below should be
100 static void timestamp (struct mi_timestamp *tv);
102 static void print_diff_now (struct mi_timestamp *start);
103 static void print_diff (struct mi_timestamp *start, struct mi_timestamp *end);
106 mi_cmd_gdb_exit (char *command, char **argv, int argc)
108 /* We have to print everything right here because we never return. */
110 fputs_unfiltered (current_token, raw_stdout);
111 fputs_unfiltered ("^exit\n", raw_stdout);
112 mi_out_put (uiout, raw_stdout);
113 /* FIXME: The function called is not yet a formal libgdb function. */
114 quit_force (NULL, FROM_TTY);
118 mi_cmd_exec_next (char *command, char **argv, int argc)
120 /* FIXME: Should call a libgdb function, not a cli wrapper. */
121 mi_execute_async_cli_command ("next", argv, argc);
125 mi_cmd_exec_next_instruction (char *command, char **argv, int argc)
127 /* FIXME: Should call a libgdb function, not a cli wrapper. */
128 mi_execute_async_cli_command ("nexti", argv, argc);
132 mi_cmd_exec_step (char *command, char **argv, int argc)
134 /* FIXME: Should call a libgdb function, not a cli wrapper. */
135 mi_execute_async_cli_command ("step", argv, argc);
139 mi_cmd_exec_step_instruction (char *command, char **argv, int argc)
141 /* FIXME: Should call a libgdb function, not a cli wrapper. */
142 mi_execute_async_cli_command ("stepi", argv, argc);
146 mi_cmd_exec_finish (char *command, char **argv, int argc)
148 /* FIXME: Should call a libgdb function, not a cli wrapper. */
149 mi_execute_async_cli_command ("finish", argv, argc);
153 mi_cmd_exec_return (char *command, char **argv, int argc)
155 /* This command doesn't really execute the target, it just pops the
156 specified number of frames. */
158 /* Call return_command with from_tty argument equal to 0 so as to
159 avoid being queried. */
160 return_command (*argv, 0);
162 /* Call return_command with from_tty argument equal to 0 so as to
163 avoid being queried. */
164 return_command (NULL, 0);
166 /* Because we have called return_command with from_tty = 0, we need
167 to print the frame here. */
168 print_stack_frame (get_selected_frame (NULL), 1, LOC_AND_ADDRESS);
172 mi_cmd_exec_jump (char *args, char **argv, int argc)
174 /* FIXME: Should call a libgdb function, not a cli wrapper. */
175 return mi_execute_async_cli_command ("jump", argv, argc);
179 proceed_thread_callback (struct thread_info *thread, void *arg)
181 int pid = *(int *)arg;
183 if (!is_stopped (thread->ptid))
186 if (PIDGET (thread->ptid) != pid)
189 switch_to_thread (thread->ptid);
190 clear_proceed_status ();
191 proceed ((CORE_ADDR) -1, TARGET_SIGNAL_DEFAULT, 0);
196 mi_cmd_exec_continue (char *command, char **argv, int argc)
200 else if (argc == 1 && strcmp (argv[0], "--all") == 0)
202 else if (argc == 2 && strcmp (argv[0], "--thread-group") == 0)
204 struct cleanup *old_chain;
206 if (argv[1] == NULL || argv[1] == '\0')
207 error ("Thread group id not specified");
208 pid = atoi (argv[1]);
209 if (!in_inferior_list (pid))
210 error ("Invalid thread group id '%s'", argv[1]);
212 old_chain = make_cleanup_restore_current_thread ();
213 iterate_over_threads (proceed_thread_callback, &pid);
214 do_cleanups (old_chain);
217 error ("Usage: -exec-continue [--all|--thread-group id]");
221 interrupt_thread_callback (struct thread_info *thread, void *arg)
223 int pid = *(int *)arg;
225 if (!is_running (thread->ptid))
228 if (PIDGET (thread->ptid) != pid)
231 target_stop (thread->ptid);
235 /* Interrupt the execution of the target. Note how we must play around
236 with the token variables, in order to display the current token in
237 the result of the interrupt command, and the previous execution
238 token when the target finally stops. See comments in
241 mi_cmd_exec_interrupt (char *command, char **argv, int argc)
245 if (!is_running (inferior_ptid))
246 error ("Current thread is not running.");
248 interrupt_target_1 (0);
250 else if (argc == 1 && strcmp (argv[0], "--all") == 0)
253 error ("Inferior not running.");
255 interrupt_target_1 (1);
257 else if (argc == 2 && strcmp (argv[0], "--thread-group") == 0)
259 struct cleanup *old_chain;
261 if (argv[1] == NULL || argv[1] == '\0')
262 error ("Thread group id not specified");
263 pid = atoi (argv[1]);
264 if (!in_inferior_list (pid))
265 error ("Invalid thread group id '%s'", argv[1]);
267 old_chain = make_cleanup_restore_current_thread ();
268 iterate_over_threads (interrupt_thread_callback, &pid);
269 do_cleanups (old_chain);
272 error ("Usage: -exec-interrupt [--all|--thread-group id]");
276 find_thread_of_process (struct thread_info *ti, void *p)
279 if (PIDGET (ti->ptid) == pid && !is_exited (ti->ptid))
286 mi_cmd_target_detach (char *command, char **argv, int argc)
288 if (argc != 0 && argc != 1)
289 error ("Usage: -target-detach [thread-group]");
293 struct thread_info *tp;
295 int pid = strtol (argv[0], &end, 10);
297 error (_("Cannot parse thread group id '%s'"), argv[0]);
299 /* Pick any thread in the desired process. Current
300 target_detach deteches from the parent of inferior_ptid. */
301 tp = iterate_over_threads (find_thread_of_process, &pid);
303 error (_("Thread group is empty"));
305 switch_to_thread (tp->ptid);
308 detach_command (NULL, 0);
312 mi_cmd_thread_select (char *command, char **argv, int argc)
315 char *mi_error_message;
318 error ("mi_cmd_thread_select: USAGE: threadnum.");
320 rc = gdb_thread_select (uiout, argv[0], &mi_error_message);
322 if (rc == GDB_RC_FAIL)
324 make_cleanup (xfree, mi_error_message);
325 error ("%s", mi_error_message);
330 mi_cmd_thread_list_ids (char *command, char **argv, int argc)
333 char *mi_error_message;
336 error ("mi_cmd_thread_list_ids: No arguments required.");
338 rc = gdb_list_thread_ids (uiout, &mi_error_message);
340 if (rc == GDB_RC_FAIL)
342 make_cleanup (xfree, mi_error_message);
343 error ("%s", mi_error_message);
348 mi_cmd_thread_info (char *command, char **argv, int argc)
352 if (argc != 0 && argc != 1)
353 error ("Invalid MI command");
356 thread = atoi (argv[0]);
358 print_thread_info (uiout, thread, -1);
362 print_one_inferior (struct inferior *inferior, void *arg)
364 struct cleanup *back_to = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
366 ui_out_field_fmt (uiout, "id", "%d", inferior->pid);
367 ui_out_field_string (uiout, "type", "process");
368 ui_out_field_int (uiout, "pid", inferior->pid);
370 do_cleanups (back_to);
375 mi_cmd_list_thread_groups (char *command, char **argv, int argc)
377 struct cleanup *back_to;
381 if (argc > 0 && strcmp (argv[0], "--available") == 0)
391 back_to = make_cleanup (null_cleanup, NULL);
395 error (_("Can only report top-level available thread groups"));
400 struct osdata_item *item;
403 data = get_osdata ("processes");
404 make_cleanup_osdata_free (data);
406 make_cleanup_ui_out_list_begin_end (uiout, "groups");
409 VEC_iterate (osdata_item_s, data->items,
413 struct cleanup *back_to =
414 make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
416 const char *pid = get_osdata_column (item, "pid");
417 const char *cmd = get_osdata_column (item, "command");
418 const char *user = get_osdata_column (item, "user");
420 ui_out_field_fmt (uiout, "id", "%s", pid);
421 ui_out_field_string (uiout, "type", "process");
423 ui_out_field_string (uiout, "description", cmd);
425 ui_out_field_string (uiout, "user", user);
427 do_cleanups (back_to);
433 if (!in_inferior_list (pid))
434 error ("Invalid thread group id '%s'", id);
435 print_thread_info (uiout, -1, pid);
439 make_cleanup_ui_out_list_begin_end (uiout, "groups");
440 iterate_over_inferiors (print_one_inferior, NULL);
443 do_cleanups (back_to);
447 mi_cmd_data_list_register_names (char *command, char **argv, int argc)
451 struct cleanup *cleanup;
453 /* Note that the test for a valid register must include checking the
454 gdbarch_register_name because gdbarch_num_regs may be allocated for
455 the union of the register sets within a family of related processors.
456 In this case, some entries of gdbarch_register_name will change depending
457 upon the particular processor being debugged. */
459 numregs = gdbarch_num_regs (current_gdbarch)
460 + gdbarch_num_pseudo_regs (current_gdbarch);
462 cleanup = make_cleanup_ui_out_list_begin_end (uiout, "register-names");
464 if (argc == 0) /* No args, just do all the regs. */
470 if (gdbarch_register_name (current_gdbarch, regnum) == NULL
471 || *(gdbarch_register_name (current_gdbarch, regnum)) == '\0')
472 ui_out_field_string (uiout, NULL, "");
474 ui_out_field_string (uiout, NULL,
475 gdbarch_register_name
476 (current_gdbarch, regnum));
480 /* Else, list of register #s, just do listed regs. */
481 for (i = 0; i < argc; i++)
483 regnum = atoi (argv[i]);
484 if (regnum < 0 || regnum >= numregs)
485 error ("bad register number");
487 if (gdbarch_register_name (current_gdbarch, regnum) == NULL
488 || *(gdbarch_register_name (current_gdbarch, regnum)) == '\0')
489 ui_out_field_string (uiout, NULL, "");
491 ui_out_field_string (uiout, NULL,
492 gdbarch_register_name (current_gdbarch, regnum));
494 do_cleanups (cleanup);
498 mi_cmd_data_list_changed_registers (char *command, char **argv, int argc)
500 static struct regcache *this_regs = NULL;
501 struct regcache *prev_regs;
502 int regnum, numregs, changed;
504 struct cleanup *cleanup;
506 /* The last time we visited this function, the current frame's register
507 contents were saved in THIS_REGS. Move THIS_REGS over to PREV_REGS,
508 and refresh THIS_REGS with the now-current register contents. */
510 prev_regs = this_regs;
511 this_regs = frame_save_as_regcache (get_selected_frame (NULL));
512 cleanup = make_cleanup_regcache_xfree (prev_regs);
514 /* Note that the test for a valid register must include checking the
515 gdbarch_register_name because gdbarch_num_regs may be allocated for
516 the union of the register sets within a family of related processors.
517 In this case, some entries of gdbarch_register_name will change depending
518 upon the particular processor being debugged. */
520 numregs = gdbarch_num_regs (current_gdbarch)
521 + gdbarch_num_pseudo_regs (current_gdbarch);
523 make_cleanup_ui_out_list_begin_end (uiout, "changed-registers");
525 if (argc == 0) /* No args, just do all the regs. */
531 if (gdbarch_register_name (current_gdbarch, regnum) == NULL
532 || *(gdbarch_register_name (current_gdbarch, regnum)) == '\0')
534 changed = register_changed_p (regnum, prev_regs, this_regs);
536 error ("mi_cmd_data_list_changed_registers: Unable to read register contents.");
538 ui_out_field_int (uiout, NULL, regnum);
542 /* Else, list of register #s, just do listed regs. */
543 for (i = 0; i < argc; i++)
545 regnum = atoi (argv[i]);
549 && gdbarch_register_name (current_gdbarch, regnum) != NULL
550 && *gdbarch_register_name (current_gdbarch, regnum) != '\000')
552 changed = register_changed_p (regnum, prev_regs, this_regs);
554 error ("mi_cmd_data_list_register_change: Unable to read register contents.");
556 ui_out_field_int (uiout, NULL, regnum);
559 error ("bad register number");
561 do_cleanups (cleanup);
565 register_changed_p (int regnum, struct regcache *prev_regs,
566 struct regcache *this_regs)
568 struct gdbarch *gdbarch = get_regcache_arch (this_regs);
569 gdb_byte prev_buffer[MAX_REGISTER_SIZE];
570 gdb_byte this_buffer[MAX_REGISTER_SIZE];
572 /* Registers not valid in this frame return count as unchanged. */
573 if (!regcache_valid_p (this_regs, regnum))
576 /* First time through or after gdbarch change consider all registers as
577 changed. Same for registers not valid in the previous frame. */
578 if (!prev_regs || get_regcache_arch (prev_regs) != gdbarch
579 || !regcache_valid_p (prev_regs, regnum))
582 /* Get register contents and compare. */
583 regcache_cooked_read (prev_regs, regnum, prev_buffer);
584 regcache_cooked_read (this_regs, regnum, this_buffer);
586 return memcmp (prev_buffer, this_buffer,
587 register_size (gdbarch, regnum)) != 0;
590 /* Return a list of register number and value pairs. The valid
591 arguments expected are: a letter indicating the format in which to
592 display the registers contents. This can be one of: x (hexadecimal), d
593 (decimal), N (natural), t (binary), o (octal), r (raw). After the
594 format argumetn there can be a sequence of numbers, indicating which
595 registers to fetch the content of. If the format is the only argument,
596 a list of all the registers with their values is returned. */
598 mi_cmd_data_list_register_values (char *command, char **argv, int argc)
600 int regnum, numregs, format;
602 struct cleanup *list_cleanup, *tuple_cleanup;
604 /* Note that the test for a valid register must include checking the
605 gdbarch_register_name because gdbarch_num_regs may be allocated for
606 the union of the register sets within a family of related processors.
607 In this case, some entries of gdbarch_register_name will change depending
608 upon the particular processor being debugged. */
610 numregs = gdbarch_num_regs (current_gdbarch)
611 + gdbarch_num_pseudo_regs (current_gdbarch);
614 error ("mi_cmd_data_list_register_values: Usage: -data-list-register-values <format> [<regnum1>...<regnumN>]");
616 format = (int) argv[0][0];
618 list_cleanup = make_cleanup_ui_out_list_begin_end (uiout, "register-values");
620 if (argc == 1) /* No args, beside the format: do all the regs. */
626 if (gdbarch_register_name (current_gdbarch, regnum) == NULL
627 || *(gdbarch_register_name (current_gdbarch, regnum)) == '\0')
629 tuple_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
630 ui_out_field_int (uiout, "number", regnum);
631 get_register (regnum, format);
632 do_cleanups (tuple_cleanup);
636 /* Else, list of register #s, just do listed regs. */
637 for (i = 1; i < argc; i++)
639 regnum = atoi (argv[i]);
643 && gdbarch_register_name (current_gdbarch, regnum) != NULL
644 && *gdbarch_register_name (current_gdbarch, regnum) != '\000')
646 tuple_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
647 ui_out_field_int (uiout, "number", regnum);
648 get_register (regnum, format);
649 do_cleanups (tuple_cleanup);
652 error ("bad register number");
654 do_cleanups (list_cleanup);
657 /* Output one register's contents in the desired format. */
659 get_register (int regnum, int format)
661 gdb_byte buffer[MAX_REGISTER_SIZE];
666 static struct ui_stream *stb = NULL;
668 stb = ui_out_stream_new (uiout);
673 frame_register (get_selected_frame (NULL), regnum, &optim, &lval, &addr,
677 error ("Optimized out");
682 char *ptr, buf[1024];
686 for (j = 0; j < register_size (current_gdbarch, regnum); j++)
688 int idx = gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG ? j
689 : register_size (current_gdbarch, regnum) - 1 - j;
690 sprintf (ptr, "%02x", (unsigned char) buffer[idx]);
693 ui_out_field_string (uiout, "value", buf);
694 /*fputs_filtered (buf, gdb_stdout); */
698 struct value_print_options opts;
699 get_formatted_print_options (&opts, format);
701 val_print (register_type (current_gdbarch, regnum), buffer, 0, 0,
702 stb->stream, 0, &opts, current_language);
703 ui_out_field_stream (uiout, "value", stb);
704 ui_out_stream_delete (stb);
708 /* Write given values into registers. The registers and values are
709 given as pairs. The corresponding MI command is
710 -data-write-register-values <format> [<regnum1> <value1>...<regnumN> <valueN>]*/
712 mi_cmd_data_write_register_values (char *command, char **argv, int argc)
717 /* Note that the test for a valid register must include checking the
718 gdbarch_register_name because gdbarch_num_regs may be allocated for
719 the union of the register sets within a family of related processors.
720 In this case, some entries of gdbarch_register_name will change depending
721 upon the particular processor being debugged. */
723 numregs = gdbarch_num_regs (current_gdbarch)
724 + gdbarch_num_pseudo_regs (current_gdbarch);
727 error ("mi_cmd_data_write_register_values: Usage: -data-write-register-values <format> [<regnum1> <value1>...<regnumN> <valueN>]");
729 format = (int) argv[0][0];
731 if (!target_has_registers)
732 error ("mi_cmd_data_write_register_values: No registers.");
735 error ("mi_cmd_data_write_register_values: No regs and values specified.");
738 error ("mi_cmd_data_write_register_values: Regs and vals are not in pairs.");
740 for (i = 1; i < argc; i = i + 2)
742 int regnum = atoi (argv[i]);
744 if (regnum >= 0 && regnum < numregs
745 && gdbarch_register_name (current_gdbarch, regnum)
746 && *gdbarch_register_name (current_gdbarch, regnum))
750 /* Get the value as a number. */
751 value = parse_and_eval_address (argv[i + 1]);
754 regcache_cooked_write_signed (get_current_regcache (), regnum, value);
757 error ("bad register number");
761 /* Evaluate the value of the argument. The argument is an
762 expression. If the expression contains spaces it needs to be
763 included in double quotes. */
765 mi_cmd_data_evaluate_expression (char *command, char **argv, int argc)
767 struct expression *expr;
768 struct cleanup *old_chain = NULL;
770 struct ui_stream *stb = NULL;
771 struct value_print_options opts;
773 stb = ui_out_stream_new (uiout);
777 ui_out_stream_delete (stb);
778 error ("mi_cmd_data_evaluate_expression: Usage: -data-evaluate-expression expression");
781 expr = parse_expression (argv[0]);
783 old_chain = make_cleanup (free_current_contents, &expr);
785 val = evaluate_expression (expr);
787 /* Print the result of the expression evaluation. */
788 get_user_print_options (&opts);
790 val_print (value_type (val), value_contents (val),
791 value_embedded_offset (val), value_address (val),
792 stb->stream, 0, &opts, current_language);
794 ui_out_field_stream (uiout, "value", stb);
795 ui_out_stream_delete (stb);
797 do_cleanups (old_chain);
802 ADDR: start address of data to be dumped.
803 WORD-FORMAT: a char indicating format for the ``word''. See
805 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes.
806 NR_ROW: Number of rows.
807 NR_COL: The number of colums (words per row).
808 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
809 ASCHAR for unprintable characters.
811 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
812 displayes them. Returns:
814 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
817 The number of bytes read is SIZE*ROW*COL. */
820 mi_cmd_data_read_memory (char *command, char **argv, int argc)
822 struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
828 struct type *word_type;
841 static struct mi_opt opts[] =
843 {"o", OFFSET_OPT, 1},
849 int opt = mi_getopt ("mi_cmd_data_read_memory", argc, argv, opts,
853 switch ((enum opt) opt)
856 offset = atol (optarg);
863 if (argc < 5 || argc > 6)
864 error ("mi_cmd_data_read_memory: Usage: ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR].");
866 /* Extract all the arguments. */
868 /* Start address of the memory dump. */
869 addr = parse_and_eval_address (argv[0]) + offset;
870 /* The format character to use when displaying a memory word. See
871 the ``x'' command. */
872 word_format = argv[1][0];
873 /* The size of the memory word. */
874 word_size = atol (argv[2]);
878 word_type = builtin_type_int8;
882 word_type = builtin_type_int16;
886 word_type = builtin_type_int32;
890 word_type = builtin_type_int64;
894 word_type = builtin_type_int8;
897 /* The number of rows. */
898 nr_rows = atol (argv[3]);
900 error ("mi_cmd_data_read_memory: invalid number of rows.");
902 /* Number of bytes per row. */
903 nr_cols = atol (argv[4]);
905 error ("mi_cmd_data_read_memory: invalid number of columns.");
907 /* The un-printable character when printing ascii. */
913 /* Create a buffer and read it in. */
914 total_bytes = word_size * nr_rows * nr_cols;
915 mbuf = xcalloc (total_bytes, 1);
916 make_cleanup (xfree, mbuf);
918 nr_bytes = target_read_until_error (¤t_target, TARGET_OBJECT_MEMORY,
919 NULL, mbuf, addr, total_bytes);
921 error ("Unable to read memory.");
923 /* Output the header information. */
924 ui_out_field_core_addr (uiout, "addr", addr);
925 ui_out_field_int (uiout, "nr-bytes", nr_bytes);
926 ui_out_field_int (uiout, "total-bytes", total_bytes);
927 ui_out_field_core_addr (uiout, "next-row", addr + word_size * nr_cols);
928 ui_out_field_core_addr (uiout, "prev-row", addr - word_size * nr_cols);
929 ui_out_field_core_addr (uiout, "next-page", addr + total_bytes);
930 ui_out_field_core_addr (uiout, "prev-page", addr - total_bytes);
932 /* Build the result as a two dimentional table. */
934 struct ui_stream *stream = ui_out_stream_new (uiout);
935 struct cleanup *cleanup_list_memory;
938 cleanup_list_memory = make_cleanup_ui_out_list_begin_end (uiout, "memory");
939 for (row = 0, row_byte = 0;
941 row++, row_byte += nr_cols * word_size)
945 struct cleanup *cleanup_tuple;
946 struct cleanup *cleanup_list_data;
947 struct value_print_options opts;
949 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
950 ui_out_field_core_addr (uiout, "addr", addr + row_byte);
951 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr + row_byte); */
952 cleanup_list_data = make_cleanup_ui_out_list_begin_end (uiout, "data");
953 get_formatted_print_options (&opts, word_format);
954 for (col = 0, col_byte = row_byte;
956 col++, col_byte += word_size)
958 if (col_byte + word_size > nr_bytes)
960 ui_out_field_string (uiout, NULL, "N/A");
964 ui_file_rewind (stream->stream);
965 print_scalar_formatted (mbuf + col_byte, word_type, &opts,
966 word_asize, stream->stream);
967 ui_out_field_stream (uiout, NULL, stream);
970 do_cleanups (cleanup_list_data);
974 ui_file_rewind (stream->stream);
975 for (byte = row_byte; byte < row_byte + word_size * nr_cols; byte++)
977 if (byte >= nr_bytes)
979 fputc_unfiltered ('X', stream->stream);
981 else if (mbuf[byte] < 32 || mbuf[byte] > 126)
983 fputc_unfiltered (aschar, stream->stream);
986 fputc_unfiltered (mbuf[byte], stream->stream);
988 ui_out_field_stream (uiout, "ascii", stream);
990 do_cleanups (cleanup_tuple);
992 ui_out_stream_delete (stream);
993 do_cleanups (cleanup_list_memory);
995 do_cleanups (cleanups);
998 /* DATA-MEMORY-WRITE:
1000 COLUMN_OFFSET: optional argument. Must be preceeded by '-o'. The
1001 offset from the beginning of the memory grid row where the cell to
1003 ADDR: start address of the row in the memory grid where the memory
1004 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
1005 the location to write to.
1006 FORMAT: a char indicating format for the ``word''. See
1008 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
1009 VALUE: value to be written into the memory address.
1011 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
1015 mi_cmd_data_write_memory (char *command, char **argv, int argc)
1020 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
1021 enough when using a compiler other than GCC. */
1024 struct cleanup *old_chain;
1032 static struct mi_opt opts[] =
1034 {"o", OFFSET_OPT, 1},
1040 int opt = mi_getopt ("mi_cmd_data_write_memory", argc, argv, opts,
1044 switch ((enum opt) opt)
1047 offset = atol (optarg);
1055 error ("mi_cmd_data_write_memory: Usage: [-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE.");
1057 /* Extract all the arguments. */
1058 /* Start address of the memory dump. */
1059 addr = parse_and_eval_address (argv[0]);
1060 /* The format character to use when displaying a memory word. See
1061 the ``x'' command. */
1062 word_format = argv[1][0];
1063 /* The size of the memory word. */
1064 word_size = atol (argv[2]);
1066 /* Calculate the real address of the write destination. */
1067 addr += (offset * word_size);
1069 /* Get the value as a number. */
1070 value = parse_and_eval_address (argv[3]);
1071 /* Get the value into an array. */
1072 buffer = xmalloc (word_size);
1073 old_chain = make_cleanup (xfree, buffer);
1074 store_signed_integer (buffer, word_size, value);
1075 /* Write it down to memory. */
1076 write_memory (addr, buffer, word_size);
1077 /* Free the buffer. */
1078 do_cleanups (old_chain);
1082 mi_cmd_enable_timings (char *command, char **argv, int argc)
1088 if (strcmp (argv[0], "yes") == 0)
1090 else if (strcmp (argv[0], "no") == 0)
1101 error ("mi_cmd_enable_timings: Usage: %s {yes|no}", command);
1105 mi_cmd_list_features (char *command, char **argv, int argc)
1109 struct cleanup *cleanup = NULL;
1110 cleanup = make_cleanup_ui_out_list_begin_end (uiout, "features");
1112 ui_out_field_string (uiout, NULL, "frozen-varobjs");
1113 ui_out_field_string (uiout, NULL, "pending-breakpoints");
1114 ui_out_field_string (uiout, NULL, "thread-info");
1117 ui_out_field_string (uiout, NULL, "python");
1120 do_cleanups (cleanup);
1124 error ("-list-features should be passed no arguments");
1128 mi_cmd_list_target_features (char *command, char **argv, int argc)
1132 struct cleanup *cleanup = NULL;
1133 cleanup = make_cleanup_ui_out_list_begin_end (uiout, "features");
1135 if (target_can_async_p ())
1136 ui_out_field_string (uiout, NULL, "async");
1138 do_cleanups (cleanup);
1142 error ("-list-target-features should be passed no arguments");
1145 /* Execute a command within a safe environment.
1146 Return <0 for error; >=0 for ok.
1148 args->action will tell mi_execute_command what action
1149 to perfrom after the given command has executed (display/suppress
1150 prompt, display error). */
1153 captured_mi_execute_command (struct ui_out *uiout, void *data)
1155 struct cleanup *cleanup;
1156 struct mi_parse *context = (struct mi_parse *) data;
1159 current_command_ts = context->cmd_start;
1161 current_token = xstrdup (context->token);
1162 cleanup = make_cleanup (free_current_contents, ¤t_token);
1164 running_result_record_printed = 0;
1166 switch (context->op)
1169 /* A MI command was read from the input stream. */
1171 /* FIXME: gdb_???? */
1172 fprintf_unfiltered (raw_stdout, " token=`%s' command=`%s' args=`%s'\n",
1173 context->token, context->command, context->args);
1176 mi_cmd_execute (context);
1178 /* Print the result if there were no errors.
1180 Remember that on the way out of executing a command, you have
1181 to directly use the mi_interp's uiout, since the command could
1182 have reset the interpreter, in which case the current uiout
1183 will most likely crash in the mi_out_* routines. */
1184 if (!running_result_record_printed)
1186 fputs_unfiltered (context->token, raw_stdout);
1187 /* There's no particularly good reason why target-connect results
1188 in not ^done. Should kill ^connected for MI3. */
1189 fputs_unfiltered (strcmp (context->command, "target-select") == 0
1190 ? "^connected" : "^done", raw_stdout);
1191 mi_out_put (uiout, raw_stdout);
1192 mi_out_rewind (uiout);
1193 mi_print_timing_maybe ();
1194 fputs_unfiltered ("\n", raw_stdout);
1197 /* The command does not want anything to be printed. In that
1198 case, the command probably should not have written anything
1199 to uiout, but in case it has written something, discard it. */
1200 mi_out_rewind (uiout);
1206 /* A CLI command was read from the input stream. */
1207 /* This "feature" will be removed as soon as we have a
1208 complete set of mi commands. */
1209 /* Echo the command on the console. */
1210 fprintf_unfiltered (gdb_stdlog, "%s\n", context->command);
1211 /* Call the "console" interpreter. */
1212 argv[0] = "console";
1213 argv[1] = context->command;
1214 mi_cmd_interpreter_exec ("-interpreter-exec", argv, 2);
1216 /* If we changed interpreters, DON'T print out anything. */
1217 if (current_interp_named_p (INTERP_MI)
1218 || current_interp_named_p (INTERP_MI1)
1219 || current_interp_named_p (INTERP_MI2)
1220 || current_interp_named_p (INTERP_MI3))
1222 if (!running_result_record_printed)
1224 fputs_unfiltered (context->token, raw_stdout);
1225 fputs_unfiltered ("^done", raw_stdout);
1226 mi_out_put (uiout, raw_stdout);
1227 mi_out_rewind (uiout);
1228 mi_print_timing_maybe ();
1229 fputs_unfiltered ("\n", raw_stdout);
1232 mi_out_rewind (uiout);
1239 do_cleanups (cleanup);
1246 mi_execute_command (char *cmd, int from_tty)
1248 struct mi_parse *command;
1249 struct ui_out *saved_uiout = uiout;
1251 /* This is to handle EOF (^D). We just quit gdb. */
1252 /* FIXME: we should call some API function here. */
1254 quit_force (NULL, from_tty);
1256 command = mi_parse (cmd);
1258 if (command != NULL)
1260 struct gdb_exception result;
1261 ptid_t previous_ptid = inferior_ptid;
1265 command->cmd_start = (struct mi_timestamp *)
1266 xmalloc (sizeof (struct mi_timestamp));
1267 timestamp (command->cmd_start);
1270 result = catch_exception (uiout, captured_mi_execute_command, command,
1272 if (result.reason < 0)
1274 /* The command execution failed and error() was called
1276 fputs_unfiltered (command->token, raw_stdout);
1277 fputs_unfiltered ("^error,msg=\"", raw_stdout);
1278 if (result.message == NULL)
1279 fputs_unfiltered ("unknown error", raw_stdout);
1281 fputstr_unfiltered (result.message, '"', raw_stdout);
1282 fputs_unfiltered ("\"\n", raw_stdout);
1283 mi_out_rewind (uiout);
1286 if (/* The notifications are only output when the top-level
1287 interpreter (specified on the command line) is MI. */
1288 ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ()))
1289 /* Don't try report anything if there are no threads --
1290 the program is dead. */
1291 && thread_count () != 0
1292 /* -thread-select explicitly changes thread. If frontend uses that
1293 internally, we don't want to emit =thread-selected, since
1294 =thread-selected is supposed to indicate user's intentions. */
1295 && strcmp (command->command, "thread-select") != 0)
1297 struct mi_interp *mi = top_level_interpreter_data ();
1298 int report_change = 0;
1300 if (command->thread == -1)
1302 report_change = (!ptid_equal (previous_ptid, null_ptid)
1303 && !ptid_equal (inferior_ptid, previous_ptid)
1304 && !ptid_equal (inferior_ptid, null_ptid));
1306 else if (!ptid_equal (inferior_ptid, null_ptid))
1308 struct thread_info *ti = inferior_thread ();
1309 report_change = (ti->num != command->thread);
1314 struct thread_info *ti = inferior_thread ();
1315 target_terminal_ours ();
1316 fprintf_unfiltered (mi->event_channel,
1317 "thread-selected,id=\"%d\"",
1319 gdb_flush (mi->event_channel);
1323 mi_parse_free (command);
1326 fputs_unfiltered ("(gdb) \n", raw_stdout);
1327 gdb_flush (raw_stdout);
1328 /* Print any buffered hook code. */
1333 mi_cmd_execute (struct mi_parse *parse)
1335 struct cleanup *cleanup;
1339 cleanup = make_cleanup (null_cleanup, NULL);
1341 if (parse->frame != -1 && parse->thread == -1)
1342 error (_("Cannot specify --frame without --thread"));
1344 if (parse->thread != -1)
1346 struct thread_info *tp = find_thread_id (parse->thread);
1348 error (_("Invalid thread id: %d"), parse->thread);
1350 if (is_exited (tp->ptid))
1351 error (_("Thread id: %d has terminated"), parse->thread);
1353 switch_to_thread (tp->ptid);
1356 if (parse->frame != -1)
1358 struct frame_info *fid;
1359 int frame = parse->frame;
1360 fid = find_relative_frame (get_current_frame (), &frame);
1362 /* find_relative_frame was successful */
1365 error (_("Invalid frame id: %d"), frame);
1368 if (parse->cmd->argv_func != NULL)
1369 parse->cmd->argv_func (parse->command, parse->argv, parse->argc);
1370 else if (parse->cmd->cli.cmd != 0)
1372 /* FIXME: DELETE THIS. */
1373 /* The operation is still implemented by a cli command. */
1374 /* Must be a synchronous one. */
1375 mi_execute_cli_command (parse->cmd->cli.cmd, parse->cmd->cli.args_p,
1380 /* FIXME: DELETE THIS. */
1381 struct ui_file *stb;
1383 stb = mem_fileopen ();
1385 fputs_unfiltered ("Undefined mi command: ", stb);
1386 fputstr_unfiltered (parse->command, '"', stb);
1387 fputs_unfiltered (" (missing implementation)", stb);
1389 make_cleanup_ui_file_delete (stb);
1392 do_cleanups (cleanup);
1395 /* FIXME: This is just a hack so we can get some extra commands going.
1396 We don't want to channel things through the CLI, but call libgdb directly.
1397 Use only for synchronous commands. */
1400 mi_execute_cli_command (const char *cmd, int args_p, const char *args)
1404 struct cleanup *old_cleanups;
1407 run = xstrprintf ("%s %s", cmd, args);
1409 run = xstrdup (cmd);
1411 /* FIXME: gdb_???? */
1412 fprintf_unfiltered (gdb_stdout, "cli=%s run=%s\n",
1414 old_cleanups = make_cleanup (xfree, run);
1415 execute_command ( /*ui */ run, 0 /*from_tty */ );
1416 do_cleanups (old_cleanups);
1422 mi_execute_async_cli_command (char *cli_command, char **argv, int argc)
1424 struct cleanup *old_cleanups;
1427 if (target_can_async_p ())
1428 run = xstrprintf ("%s %s&", cli_command, argc ? *argv : "");
1430 run = xstrprintf ("%s %s", cli_command, argc ? *argv : "");
1431 old_cleanups = make_cleanup (xfree, run);
1433 execute_command ( /*ui */ run, 0 /*from_tty */ );
1435 if (target_can_async_p ())
1437 /* If we're not executing, an exception should have been throw. */
1438 gdb_assert (is_running (inferior_ptid));
1439 do_cleanups (old_cleanups);
1443 /* Do this before doing any printing. It would appear that some
1444 print code leaves garbage around in the buffer. */
1445 do_cleanups (old_cleanups);
1450 mi_load_progress (const char *section_name,
1451 unsigned long sent_so_far,
1452 unsigned long total_section,
1453 unsigned long total_sent,
1454 unsigned long grand_total)
1456 struct timeval time_now, delta, update_threshold;
1457 static struct timeval last_update;
1458 static char *previous_sect_name = NULL;
1460 struct ui_out *saved_uiout;
1462 /* This function is called through deprecated_show_load_progress
1463 which means uiout may not be correct. Fix it for the duration
1464 of this function. */
1465 saved_uiout = uiout;
1467 if (current_interp_named_p (INTERP_MI)
1468 || current_interp_named_p (INTERP_MI2))
1469 uiout = mi_out_new (2);
1470 else if (current_interp_named_p (INTERP_MI1))
1471 uiout = mi_out_new (1);
1472 else if (current_interp_named_p (INTERP_MI3))
1473 uiout = mi_out_new (3);
1477 update_threshold.tv_sec = 0;
1478 update_threshold.tv_usec = 500000;
1479 gettimeofday (&time_now, NULL);
1481 delta.tv_usec = time_now.tv_usec - last_update.tv_usec;
1482 delta.tv_sec = time_now.tv_sec - last_update.tv_sec;
1484 if (delta.tv_usec < 0)
1487 delta.tv_usec += 1000000L;
1490 new_section = (previous_sect_name ?
1491 strcmp (previous_sect_name, section_name) : 1);
1494 struct cleanup *cleanup_tuple;
1495 xfree (previous_sect_name);
1496 previous_sect_name = xstrdup (section_name);
1499 fputs_unfiltered (current_token, raw_stdout);
1500 fputs_unfiltered ("+download", raw_stdout);
1501 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1502 ui_out_field_string (uiout, "section", section_name);
1503 ui_out_field_int (uiout, "section-size", total_section);
1504 ui_out_field_int (uiout, "total-size", grand_total);
1505 do_cleanups (cleanup_tuple);
1506 mi_out_put (uiout, raw_stdout);
1507 fputs_unfiltered ("\n", raw_stdout);
1508 gdb_flush (raw_stdout);
1511 if (delta.tv_sec >= update_threshold.tv_sec &&
1512 delta.tv_usec >= update_threshold.tv_usec)
1514 struct cleanup *cleanup_tuple;
1515 last_update.tv_sec = time_now.tv_sec;
1516 last_update.tv_usec = time_now.tv_usec;
1518 fputs_unfiltered (current_token, raw_stdout);
1519 fputs_unfiltered ("+download", raw_stdout);
1520 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1521 ui_out_field_string (uiout, "section", section_name);
1522 ui_out_field_int (uiout, "section-sent", sent_so_far);
1523 ui_out_field_int (uiout, "section-size", total_section);
1524 ui_out_field_int (uiout, "total-sent", total_sent);
1525 ui_out_field_int (uiout, "total-size", grand_total);
1526 do_cleanups (cleanup_tuple);
1527 mi_out_put (uiout, raw_stdout);
1528 fputs_unfiltered ("\n", raw_stdout);
1529 gdb_flush (raw_stdout);
1533 uiout = saved_uiout;
1537 timestamp (struct mi_timestamp *tv)
1540 gettimeofday (&tv->wallclock, NULL);
1541 #ifdef HAVE_GETRUSAGE
1542 getrusage (RUSAGE_SELF, &rusage);
1543 tv->utime.tv_sec = rusage.ru_utime.tv_sec;
1544 tv->utime.tv_usec = rusage.ru_utime.tv_usec;
1545 tv->stime.tv_sec = rusage.ru_stime.tv_sec;
1546 tv->stime.tv_usec = rusage.ru_stime.tv_usec;
1548 usec = get_run_time ();
1549 tv->utime.tv_sec = usec/1000000L;
1550 tv->utime.tv_usec = usec - 1000000L*tv->utime.tv_sec;
1551 tv->stime.tv_sec = 0;
1552 tv->stime.tv_usec = 0;
1557 print_diff_now (struct mi_timestamp *start)
1559 struct mi_timestamp now;
1561 print_diff (start, &now);
1565 mi_print_timing_maybe (void)
1567 /* If the command is -enable-timing then do_timings may be
1568 true whilst current_command_ts is not initialized. */
1569 if (do_timings && current_command_ts)
1570 print_diff_now (current_command_ts);
1574 timeval_diff (struct timeval start, struct timeval end)
1576 return ((end.tv_sec - start.tv_sec) * 1000000L)
1577 + (end.tv_usec - start.tv_usec);
1581 print_diff (struct mi_timestamp *start, struct mi_timestamp *end)
1585 ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
1586 timeval_diff (start->wallclock, end->wallclock) / 1000000.0,
1587 timeval_diff (start->utime, end->utime) / 1000000.0,
1588 timeval_diff (start->stime, end->stime) / 1000000.0);