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 extern void _initialize_mi_main (void);
82 static void mi_cmd_execute (struct mi_parse
*parse
);
84 static void mi_execute_cli_command (const char *cmd
, int args_p
,
86 static void mi_execute_async_cli_command (char *cli_command
,
87 char **argv
, int argc
);
88 static int register_changed_p (int regnum
, struct regcache
*,
90 static void get_register (int regnum
, int format
);
92 /* Command implementations. FIXME: Is this libgdb? No. This is the MI
93 layer that calls libgdb. Any operation used in the below should be
96 static void timestamp (struct mi_timestamp
*tv
);
98 static void print_diff_now (struct mi_timestamp
*start
);
99 static void print_diff (struct mi_timestamp
*start
, struct mi_timestamp
*end
);
102 mi_cmd_gdb_exit (char *command
, char **argv
, int argc
)
104 /* We have to print everything right here because we never return. */
106 fputs_unfiltered (current_token
, raw_stdout
);
107 fputs_unfiltered ("^exit\n", raw_stdout
);
108 mi_out_put (uiout
, raw_stdout
);
109 /* FIXME: The function called is not yet a formal libgdb function. */
110 quit_force (NULL
, FROM_TTY
);
114 mi_cmd_exec_next (char *command
, char **argv
, int argc
)
116 /* FIXME: Should call a libgdb function, not a cli wrapper. */
117 mi_execute_async_cli_command ("next", argv
, argc
);
121 mi_cmd_exec_next_instruction (char *command
, char **argv
, int argc
)
123 /* FIXME: Should call a libgdb function, not a cli wrapper. */
124 mi_execute_async_cli_command ("nexti", argv
, argc
);
128 mi_cmd_exec_step (char *command
, char **argv
, int argc
)
130 /* FIXME: Should call a libgdb function, not a cli wrapper. */
131 mi_execute_async_cli_command ("step", argv
, argc
);
135 mi_cmd_exec_step_instruction (char *command
, char **argv
, int argc
)
137 /* FIXME: Should call a libgdb function, not a cli wrapper. */
138 mi_execute_async_cli_command ("stepi", argv
, argc
);
142 mi_cmd_exec_finish (char *command
, char **argv
, int argc
)
144 /* FIXME: Should call a libgdb function, not a cli wrapper. */
145 mi_execute_async_cli_command ("finish", argv
, argc
);
149 mi_cmd_exec_return (char *command
, char **argv
, int argc
)
151 /* This command doesn't really execute the target, it just pops the
152 specified number of frames. */
154 /* Call return_command with from_tty argument equal to 0 so as to
155 avoid being queried. */
156 return_command (*argv
, 0);
158 /* Call return_command with from_tty argument equal to 0 so as to
159 avoid being queried. */
160 return_command (NULL
, 0);
162 /* Because we have called return_command with from_tty = 0, we need
163 to print the frame here. */
164 print_stack_frame (get_selected_frame (NULL
), 1, LOC_AND_ADDRESS
);
168 proceed_thread_callback (struct thread_info
*thread
, void *arg
)
170 int pid
= *(int *)arg
;
172 if (!is_stopped (thread
->ptid
))
175 if (PIDGET (thread
->ptid
) != pid
)
178 switch_to_thread (thread
->ptid
);
179 clear_proceed_status ();
180 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 0);
185 mi_cmd_exec_continue (char *command
, char **argv
, int argc
)
189 else if (argc
== 1 && strcmp (argv
[0], "--all") == 0)
191 else if (argc
== 2 && strcmp (argv
[0], "--thread-group") == 0)
193 struct cleanup
*old_chain
;
195 if (argv
[1] == NULL
|| argv
[1] == '\0')
196 error ("Thread group id not specified");
197 pid
= atoi (argv
[1] + 1);
198 if (!in_inferior_list (pid
))
199 error ("Invalid thread group id '%s'", argv
[1]);
201 old_chain
= make_cleanup_restore_current_thread ();
202 iterate_over_threads (proceed_thread_callback
, &pid
);
203 do_cleanups (old_chain
);
206 error ("Usage: -exec-continue [--all|--thread-group id]");
210 interrupt_thread_callback (struct thread_info
*thread
, void *arg
)
212 int pid
= *(int *)arg
;
214 if (!is_running (thread
->ptid
))
217 if (PIDGET (thread
->ptid
) != pid
)
220 target_stop (thread
->ptid
);
224 /* Interrupt the execution of the target. Note how we must play around
225 with the token variables, in order to display the current token in
226 the result of the interrupt command, and the previous execution
227 token when the target finally stops. See comments in
230 mi_cmd_exec_interrupt (char *command
, char **argv
, int argc
)
234 if (!is_running (inferior_ptid
))
235 error ("Current thread is not running.");
237 interrupt_target_1 (0);
239 else if (argc
== 1 && strcmp (argv
[0], "--all") == 0)
242 error ("Inferior not running.");
244 interrupt_target_1 (1);
246 else if (argc
== 2 && strcmp (argv
[0], "--thread-group") == 0)
248 struct cleanup
*old_chain
;
250 if (argv
[1] == NULL
|| argv
[1] == '\0')
251 error ("Thread group id not specified");
252 pid
= atoi (argv
[1] + 1);
253 if (!in_inferior_list (pid
))
254 error ("Invalid thread group id '%s'", argv
[1]);
256 old_chain
= make_cleanup_restore_current_thread ();
257 iterate_over_threads (interrupt_thread_callback
, &pid
);
258 do_cleanups (old_chain
);
261 error ("Usage: -exec-interrupt [--all|--thread-group id]");
265 find_thread_of_process (struct thread_info
*ti
, void *p
)
268 if (PIDGET (ti
->ptid
) == pid
&& !is_exited (ti
->ptid
))
275 mi_cmd_target_detach (char *command
, char **argv
, int argc
)
277 if (argc
!= 0 && argc
!= 1)
278 error ("Usage: -target-detach [thread-group]");
282 struct thread_info
*tp
;
284 int pid
= strtol (argv
[0], &end
, 10);
286 error (_("Cannot parse thread group id '%s'"), argv
[0]);
288 /* Pick any thread in the desired process. Current
289 target_detach deteches from the parent of inferior_ptid. */
290 tp
= iterate_over_threads (find_thread_of_process
, &pid
);
292 error (_("Thread group is empty"));
294 switch_to_thread (tp
->ptid
);
297 detach_command (NULL
, 0);
301 mi_cmd_thread_select (char *command
, char **argv
, int argc
)
304 char *mi_error_message
;
307 error ("mi_cmd_thread_select: USAGE: threadnum.");
309 rc
= gdb_thread_select (uiout
, argv
[0], &mi_error_message
);
311 if (rc
== GDB_RC_FAIL
)
313 make_cleanup (xfree
, mi_error_message
);
314 error ("%s", mi_error_message
);
319 mi_cmd_thread_list_ids (char *command
, char **argv
, int argc
)
322 char *mi_error_message
;
325 error ("mi_cmd_thread_list_ids: No arguments required.");
327 rc
= gdb_list_thread_ids (uiout
, &mi_error_message
);
329 if (rc
== GDB_RC_FAIL
)
331 make_cleanup (xfree
, mi_error_message
);
332 error ("%s", mi_error_message
);
337 mi_cmd_thread_info (char *command
, char **argv
, int argc
)
341 if (argc
!= 0 && argc
!= 1)
342 error ("Invalid MI command");
345 thread
= atoi (argv
[0]);
347 print_thread_info (uiout
, thread
, -1);
351 print_one_inferior (struct inferior
*inferior
, void *arg
)
353 struct cleanup
*back_to
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
355 ui_out_field_fmt (uiout
, "id", "%d", inferior
->pid
);
356 ui_out_field_string (uiout
, "type", "process");
357 ui_out_field_int (uiout
, "pid", inferior
->pid
);
359 do_cleanups (back_to
);
364 mi_cmd_list_thread_groups (char *command
, char **argv
, int argc
)
366 struct cleanup
*back_to
;
370 if (argc
> 0 && strcmp (argv
[0], "--available") == 0)
380 back_to
= make_cleanup (null_cleanup
, NULL
);
384 error (_("Can only report top-level available thread groups"));
389 struct osdata_item
*item
;
392 data
= get_osdata ("processes");
393 make_cleanup_osdata_free (data
);
395 make_cleanup_ui_out_list_begin_end (uiout
, "groups");
398 VEC_iterate (osdata_item_s
, data
->items
,
402 struct cleanup
*back_to
=
403 make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
405 const char *pid
= get_osdata_column (item
, "pid");
406 const char *cmd
= get_osdata_column (item
, "command");
407 const char *user
= get_osdata_column (item
, "user");
409 ui_out_field_fmt (uiout
, "id", "%s", pid
);
410 ui_out_field_string (uiout
, "type", "process");
412 ui_out_field_string (uiout
, "description", cmd
);
414 ui_out_field_string (uiout
, "user", user
);
416 do_cleanups (back_to
);
422 if (!in_inferior_list (pid
))
423 error ("Invalid thread group id '%s'", id
);
424 print_thread_info (uiout
, -1, pid
);
428 make_cleanup_ui_out_list_begin_end (uiout
, "groups");
429 iterate_over_inferiors (print_one_inferior
, NULL
);
432 do_cleanups (back_to
);
436 mi_cmd_data_list_register_names (char *command
, char **argv
, int argc
)
440 struct cleanup
*cleanup
;
442 /* Note that the test for a valid register must include checking the
443 gdbarch_register_name because gdbarch_num_regs may be allocated for
444 the union of the register sets within a family of related processors.
445 In this case, some entries of gdbarch_register_name will change depending
446 upon the particular processor being debugged. */
448 numregs
= gdbarch_num_regs (current_gdbarch
)
449 + gdbarch_num_pseudo_regs (current_gdbarch
);
451 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "register-names");
453 if (argc
== 0) /* No args, just do all the regs. */
459 if (gdbarch_register_name (current_gdbarch
, regnum
) == NULL
460 || *(gdbarch_register_name (current_gdbarch
, regnum
)) == '\0')
461 ui_out_field_string (uiout
, NULL
, "");
463 ui_out_field_string (uiout
, NULL
,
464 gdbarch_register_name
465 (current_gdbarch
, regnum
));
469 /* Else, list of register #s, just do listed regs. */
470 for (i
= 0; i
< argc
; i
++)
472 regnum
= atoi (argv
[i
]);
473 if (regnum
< 0 || regnum
>= numregs
)
474 error ("bad register number");
476 if (gdbarch_register_name (current_gdbarch
, regnum
) == NULL
477 || *(gdbarch_register_name (current_gdbarch
, regnum
)) == '\0')
478 ui_out_field_string (uiout
, NULL
, "");
480 ui_out_field_string (uiout
, NULL
,
481 gdbarch_register_name (current_gdbarch
, regnum
));
483 do_cleanups (cleanup
);
487 mi_cmd_data_list_changed_registers (char *command
, char **argv
, int argc
)
489 static struct regcache
*this_regs
= NULL
;
490 struct regcache
*prev_regs
;
491 int regnum
, numregs
, changed
;
493 struct cleanup
*cleanup
;
495 /* The last time we visited this function, the current frame's register
496 contents were saved in THIS_REGS. Move THIS_REGS over to PREV_REGS,
497 and refresh THIS_REGS with the now-current register contents. */
499 prev_regs
= this_regs
;
500 this_regs
= frame_save_as_regcache (get_selected_frame (NULL
));
501 cleanup
= make_cleanup_regcache_xfree (prev_regs
);
503 /* Note that the test for a valid register must include checking the
504 gdbarch_register_name because gdbarch_num_regs may be allocated for
505 the union of the register sets within a family of related processors.
506 In this case, some entries of gdbarch_register_name will change depending
507 upon the particular processor being debugged. */
509 numregs
= gdbarch_num_regs (current_gdbarch
)
510 + gdbarch_num_pseudo_regs (current_gdbarch
);
512 make_cleanup_ui_out_list_begin_end (uiout
, "changed-registers");
514 if (argc
== 0) /* No args, just do all the regs. */
520 if (gdbarch_register_name (current_gdbarch
, regnum
) == NULL
521 || *(gdbarch_register_name (current_gdbarch
, regnum
)) == '\0')
523 changed
= register_changed_p (regnum
, prev_regs
, this_regs
);
525 error ("mi_cmd_data_list_changed_registers: Unable to read register contents.");
527 ui_out_field_int (uiout
, NULL
, regnum
);
531 /* Else, list of register #s, just do listed regs. */
532 for (i
= 0; i
< argc
; i
++)
534 regnum
= atoi (argv
[i
]);
538 && gdbarch_register_name (current_gdbarch
, regnum
) != NULL
539 && *gdbarch_register_name (current_gdbarch
, regnum
) != '\000')
541 changed
= register_changed_p (regnum
, prev_regs
, this_regs
);
543 error ("mi_cmd_data_list_register_change: Unable to read register contents.");
545 ui_out_field_int (uiout
, NULL
, regnum
);
548 error ("bad register number");
550 do_cleanups (cleanup
);
554 register_changed_p (int regnum
, struct regcache
*prev_regs
,
555 struct regcache
*this_regs
)
557 struct gdbarch
*gdbarch
= get_regcache_arch (this_regs
);
558 gdb_byte prev_buffer
[MAX_REGISTER_SIZE
];
559 gdb_byte this_buffer
[MAX_REGISTER_SIZE
];
561 /* Registers not valid in this frame return count as unchanged. */
562 if (!regcache_valid_p (this_regs
, regnum
))
565 /* First time through or after gdbarch change consider all registers as
566 changed. Same for registers not valid in the previous frame. */
567 if (!prev_regs
|| get_regcache_arch (prev_regs
) != gdbarch
568 || !regcache_valid_p (prev_regs
, regnum
))
571 /* Get register contents and compare. */
572 regcache_cooked_read (prev_regs
, regnum
, prev_buffer
);
573 regcache_cooked_read (this_regs
, regnum
, this_buffer
);
575 return memcmp (prev_buffer
, this_buffer
,
576 register_size (gdbarch
, regnum
)) != 0;
579 /* Return a list of register number and value pairs. The valid
580 arguments expected are: a letter indicating the format in which to
581 display the registers contents. This can be one of: x (hexadecimal), d
582 (decimal), N (natural), t (binary), o (octal), r (raw). After the
583 format argumetn there can be a sequence of numbers, indicating which
584 registers to fetch the content of. If the format is the only argument,
585 a list of all the registers with their values is returned. */
587 mi_cmd_data_list_register_values (char *command
, char **argv
, int argc
)
589 int regnum
, numregs
, format
;
591 struct cleanup
*list_cleanup
, *tuple_cleanup
;
593 /* Note that the test for a valid register must include checking the
594 gdbarch_register_name because gdbarch_num_regs may be allocated for
595 the union of the register sets within a family of related processors.
596 In this case, some entries of gdbarch_register_name will change depending
597 upon the particular processor being debugged. */
599 numregs
= gdbarch_num_regs (current_gdbarch
)
600 + gdbarch_num_pseudo_regs (current_gdbarch
);
603 error ("mi_cmd_data_list_register_values: Usage: -data-list-register-values <format> [<regnum1>...<regnumN>]");
605 format
= (int) argv
[0][0];
607 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "register-values");
609 if (argc
== 1) /* No args, beside the format: do all the regs. */
615 if (gdbarch_register_name (current_gdbarch
, regnum
) == NULL
616 || *(gdbarch_register_name (current_gdbarch
, regnum
)) == '\0')
618 tuple_cleanup
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
619 ui_out_field_int (uiout
, "number", regnum
);
620 get_register (regnum
, format
);
621 do_cleanups (tuple_cleanup
);
625 /* Else, list of register #s, just do listed regs. */
626 for (i
= 1; i
< argc
; i
++)
628 regnum
= atoi (argv
[i
]);
632 && gdbarch_register_name (current_gdbarch
, regnum
) != NULL
633 && *gdbarch_register_name (current_gdbarch
, regnum
) != '\000')
635 tuple_cleanup
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
636 ui_out_field_int (uiout
, "number", regnum
);
637 get_register (regnum
, format
);
638 do_cleanups (tuple_cleanup
);
641 error ("bad register number");
643 do_cleanups (list_cleanup
);
646 /* Output one register's contents in the desired format. */
648 get_register (int regnum
, int format
)
650 gdb_byte buffer
[MAX_REGISTER_SIZE
];
655 static struct ui_stream
*stb
= NULL
;
657 stb
= ui_out_stream_new (uiout
);
662 frame_register (get_selected_frame (NULL
), regnum
, &optim
, &lval
, &addr
,
666 error ("Optimized out");
671 char *ptr
, buf
[1024];
675 for (j
= 0; j
< register_size (current_gdbarch
, regnum
); j
++)
677 int idx
= gdbarch_byte_order (current_gdbarch
) == BFD_ENDIAN_BIG
? j
678 : register_size (current_gdbarch
, regnum
) - 1 - j
;
679 sprintf (ptr
, "%02x", (unsigned char) buffer
[idx
]);
682 ui_out_field_string (uiout
, "value", buf
);
683 /*fputs_filtered (buf, gdb_stdout); */
687 struct value_print_options opts
;
688 get_formatted_print_options (&opts
, format
);
690 val_print (register_type (current_gdbarch
, regnum
), buffer
, 0, 0,
691 stb
->stream
, 0, &opts
, current_language
);
692 ui_out_field_stream (uiout
, "value", stb
);
693 ui_out_stream_delete (stb
);
697 /* Write given values into registers. The registers and values are
698 given as pairs. The corresponding MI command is
699 -data-write-register-values <format> [<regnum1> <value1>...<regnumN> <valueN>]*/
701 mi_cmd_data_write_register_values (char *command
, char **argv
, int argc
)
706 /* Note that the test for a valid register must include checking the
707 gdbarch_register_name because gdbarch_num_regs may be allocated for
708 the union of the register sets within a family of related processors.
709 In this case, some entries of gdbarch_register_name will change depending
710 upon the particular processor being debugged. */
712 numregs
= gdbarch_num_regs (current_gdbarch
)
713 + gdbarch_num_pseudo_regs (current_gdbarch
);
716 error ("mi_cmd_data_write_register_values: Usage: -data-write-register-values <format> [<regnum1> <value1>...<regnumN> <valueN>]");
718 format
= (int) argv
[0][0];
720 if (!target_has_registers
)
721 error ("mi_cmd_data_write_register_values: No registers.");
724 error ("mi_cmd_data_write_register_values: No regs and values specified.");
727 error ("mi_cmd_data_write_register_values: Regs and vals are not in pairs.");
729 for (i
= 1; i
< argc
; i
= i
+ 2)
731 int regnum
= atoi (argv
[i
]);
733 if (regnum
>= 0 && regnum
< numregs
734 && gdbarch_register_name (current_gdbarch
, regnum
)
735 && *gdbarch_register_name (current_gdbarch
, regnum
))
739 /* Get the value as a number. */
740 value
= parse_and_eval_address (argv
[i
+ 1]);
743 regcache_cooked_write_signed (get_current_regcache (), regnum
, value
);
746 error ("bad register number");
750 /* Evaluate the value of the argument. The argument is an
751 expression. If the expression contains spaces it needs to be
752 included in double quotes. */
754 mi_cmd_data_evaluate_expression (char *command
, char **argv
, int argc
)
756 struct expression
*expr
;
757 struct cleanup
*old_chain
= NULL
;
759 struct ui_stream
*stb
= NULL
;
760 struct value_print_options opts
;
762 stb
= ui_out_stream_new (uiout
);
766 ui_out_stream_delete (stb
);
767 error ("mi_cmd_data_evaluate_expression: Usage: -data-evaluate-expression expression");
770 expr
= parse_expression (argv
[0]);
772 old_chain
= make_cleanup (free_current_contents
, &expr
);
774 val
= evaluate_expression (expr
);
776 /* Print the result of the expression evaluation. */
777 get_user_print_options (&opts
);
779 val_print (value_type (val
), value_contents (val
),
780 value_embedded_offset (val
), VALUE_ADDRESS (val
),
781 stb
->stream
, 0, &opts
, current_language
);
783 ui_out_field_stream (uiout
, "value", stb
);
784 ui_out_stream_delete (stb
);
786 do_cleanups (old_chain
);
791 ADDR: start address of data to be dumped.
792 WORD-FORMAT: a char indicating format for the ``word''. See
794 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes.
795 NR_ROW: Number of rows.
796 NR_COL: The number of colums (words per row).
797 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
798 ASCHAR for unprintable characters.
800 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
801 displayes them. Returns:
803 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
806 The number of bytes read is SIZE*ROW*COL. */
809 mi_cmd_data_read_memory (char *command
, char **argv
, int argc
)
811 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
817 struct type
*word_type
;
830 static struct mi_opt opts
[] =
832 {"o", OFFSET_OPT
, 1},
838 int opt
= mi_getopt ("mi_cmd_data_read_memory", argc
, argv
, opts
,
842 switch ((enum opt
) opt
)
845 offset
= atol (optarg
);
852 if (argc
< 5 || argc
> 6)
853 error ("mi_cmd_data_read_memory: Usage: ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR].");
855 /* Extract all the arguments. */
857 /* Start address of the memory dump. */
858 addr
= parse_and_eval_address (argv
[0]) + offset
;
859 /* The format character to use when displaying a memory word. See
860 the ``x'' command. */
861 word_format
= argv
[1][0];
862 /* The size of the memory word. */
863 word_size
= atol (argv
[2]);
867 word_type
= builtin_type_int8
;
871 word_type
= builtin_type_int16
;
875 word_type
= builtin_type_int32
;
879 word_type
= builtin_type_int64
;
883 word_type
= builtin_type_int8
;
886 /* The number of rows. */
887 nr_rows
= atol (argv
[3]);
889 error ("mi_cmd_data_read_memory: invalid number of rows.");
891 /* Number of bytes per row. */
892 nr_cols
= atol (argv
[4]);
894 error ("mi_cmd_data_read_memory: invalid number of columns.");
896 /* The un-printable character when printing ascii. */
902 /* Create a buffer and read it in. */
903 total_bytes
= word_size
* nr_rows
* nr_cols
;
904 mbuf
= xcalloc (total_bytes
, 1);
905 make_cleanup (xfree
, mbuf
);
907 nr_bytes
= target_read_until_error (¤t_target
, TARGET_OBJECT_MEMORY
,
908 NULL
, mbuf
, addr
, total_bytes
);
910 error ("Unable to read memory.");
912 /* Output the header information. */
913 ui_out_field_core_addr (uiout
, "addr", addr
);
914 ui_out_field_int (uiout
, "nr-bytes", nr_bytes
);
915 ui_out_field_int (uiout
, "total-bytes", total_bytes
);
916 ui_out_field_core_addr (uiout
, "next-row", addr
+ word_size
* nr_cols
);
917 ui_out_field_core_addr (uiout
, "prev-row", addr
- word_size
* nr_cols
);
918 ui_out_field_core_addr (uiout
, "next-page", addr
+ total_bytes
);
919 ui_out_field_core_addr (uiout
, "prev-page", addr
- total_bytes
);
921 /* Build the result as a two dimentional table. */
923 struct ui_stream
*stream
= ui_out_stream_new (uiout
);
924 struct cleanup
*cleanup_list_memory
;
927 cleanup_list_memory
= make_cleanup_ui_out_list_begin_end (uiout
, "memory");
928 for (row
= 0, row_byte
= 0;
930 row
++, row_byte
+= nr_cols
* word_size
)
934 struct cleanup
*cleanup_tuple
;
935 struct cleanup
*cleanup_list_data
;
936 struct value_print_options opts
;
938 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
939 ui_out_field_core_addr (uiout
, "addr", addr
+ row_byte
);
940 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr + row_byte); */
941 cleanup_list_data
= make_cleanup_ui_out_list_begin_end (uiout
, "data");
942 get_formatted_print_options (&opts
, word_format
);
943 for (col
= 0, col_byte
= row_byte
;
945 col
++, col_byte
+= word_size
)
947 if (col_byte
+ word_size
> nr_bytes
)
949 ui_out_field_string (uiout
, NULL
, "N/A");
953 ui_file_rewind (stream
->stream
);
954 print_scalar_formatted (mbuf
+ col_byte
, word_type
, &opts
,
955 word_asize
, stream
->stream
);
956 ui_out_field_stream (uiout
, NULL
, stream
);
959 do_cleanups (cleanup_list_data
);
963 ui_file_rewind (stream
->stream
);
964 for (byte
= row_byte
; byte
< row_byte
+ word_size
* nr_cols
; byte
++)
966 if (byte
>= nr_bytes
)
968 fputc_unfiltered ('X', stream
->stream
);
970 else if (mbuf
[byte
] < 32 || mbuf
[byte
] > 126)
972 fputc_unfiltered (aschar
, stream
->stream
);
975 fputc_unfiltered (mbuf
[byte
], stream
->stream
);
977 ui_out_field_stream (uiout
, "ascii", stream
);
979 do_cleanups (cleanup_tuple
);
981 ui_out_stream_delete (stream
);
982 do_cleanups (cleanup_list_memory
);
984 do_cleanups (cleanups
);
987 /* DATA-MEMORY-WRITE:
989 COLUMN_OFFSET: optional argument. Must be preceeded by '-o'. The
990 offset from the beginning of the memory grid row where the cell to
992 ADDR: start address of the row in the memory grid where the memory
993 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
994 the location to write to.
995 FORMAT: a char indicating format for the ``word''. See
997 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
998 VALUE: value to be written into the memory address.
1000 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
1004 mi_cmd_data_write_memory (char *command
, char **argv
, int argc
)
1009 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
1010 enough when using a compiler other than GCC. */
1013 struct cleanup
*old_chain
;
1021 static struct mi_opt opts
[] =
1023 {"o", OFFSET_OPT
, 1},
1029 int opt
= mi_getopt ("mi_cmd_data_write_memory", argc
, argv
, opts
,
1033 switch ((enum opt
) opt
)
1036 offset
= atol (optarg
);
1044 error ("mi_cmd_data_write_memory: Usage: [-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE.");
1046 /* Extract all the arguments. */
1047 /* Start address of the memory dump. */
1048 addr
= parse_and_eval_address (argv
[0]);
1049 /* The format character to use when displaying a memory word. See
1050 the ``x'' command. */
1051 word_format
= argv
[1][0];
1052 /* The size of the memory word. */
1053 word_size
= atol (argv
[2]);
1055 /* Calculate the real address of the write destination. */
1056 addr
+= (offset
* word_size
);
1058 /* Get the value as a number. */
1059 value
= parse_and_eval_address (argv
[3]);
1060 /* Get the value into an array. */
1061 buffer
= xmalloc (word_size
);
1062 old_chain
= make_cleanup (xfree
, buffer
);
1063 store_signed_integer (buffer
, word_size
, value
);
1064 /* Write it down to memory. */
1065 write_memory (addr
, buffer
, word_size
);
1066 /* Free the buffer. */
1067 do_cleanups (old_chain
);
1071 mi_cmd_enable_timings (char *command
, char **argv
, int argc
)
1077 if (strcmp (argv
[0], "yes") == 0)
1079 else if (strcmp (argv
[0], "no") == 0)
1090 error ("mi_cmd_enable_timings: Usage: %s {yes|no}", command
);
1094 mi_cmd_list_features (char *command
, char **argv
, int argc
)
1098 struct cleanup
*cleanup
= NULL
;
1099 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "features");
1101 ui_out_field_string (uiout
, NULL
, "frozen-varobjs");
1102 ui_out_field_string (uiout
, NULL
, "pending-breakpoints");
1103 ui_out_field_string (uiout
, NULL
, "thread-info");
1105 do_cleanups (cleanup
);
1109 error ("-list-features should be passed no arguments");
1113 mi_cmd_list_target_features (char *command
, char **argv
, int argc
)
1117 struct cleanup
*cleanup
= NULL
;
1118 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "features");
1120 if (target_can_async_p ())
1121 ui_out_field_string (uiout
, NULL
, "async");
1123 do_cleanups (cleanup
);
1127 error ("-list-target-features should be passed no arguments");
1130 /* Execute a command within a safe environment.
1131 Return <0 for error; >=0 for ok.
1133 args->action will tell mi_execute_command what action
1134 to perfrom after the given command has executed (display/suppress
1135 prompt, display error). */
1138 captured_mi_execute_command (struct ui_out
*uiout
, void *data
)
1140 struct mi_parse
*context
= (struct mi_parse
*) data
;
1143 current_command_ts
= context
->cmd_start
;
1145 running_result_record_printed
= 0;
1146 switch (context
->op
)
1149 /* A MI command was read from the input stream. */
1151 /* FIXME: gdb_???? */
1152 fprintf_unfiltered (raw_stdout
, " token=`%s' command=`%s' args=`%s'\n",
1153 context
->token
, context
->command
, context
->args
);
1156 mi_cmd_execute (context
);
1158 /* Print the result if there were no errors.
1160 Remember that on the way out of executing a command, you have
1161 to directly use the mi_interp's uiout, since the command could
1162 have reset the interpreter, in which case the current uiout
1163 will most likely crash in the mi_out_* routines. */
1164 if (!running_result_record_printed
)
1166 fputs_unfiltered (context
->token
, raw_stdout
);
1167 /* There's no particularly good reason why target-connect results
1168 in not ^done. Should kill ^connected for MI3. */
1169 fputs_unfiltered (strcmp (context
->command
, "target-select") == 0
1170 ? "^connected" : "^done", raw_stdout
);
1171 mi_out_put (uiout
, raw_stdout
);
1172 mi_out_rewind (uiout
);
1173 mi_print_timing_maybe ();
1174 fputs_unfiltered ("\n", raw_stdout
);
1177 /* The command does not want anything to be printed. In that
1178 case, the command probably should not have written anything
1179 to uiout, but in case it has written something, discard it. */
1180 mi_out_rewind (uiout
);
1186 /* A CLI command was read from the input stream. */
1187 /* This "feature" will be removed as soon as we have a
1188 complete set of mi commands. */
1189 /* Echo the command on the console. */
1190 fprintf_unfiltered (gdb_stdlog
, "%s\n", context
->command
);
1191 /* Call the "console" interpreter. */
1192 argv
[0] = "console";
1193 argv
[1] = context
->command
;
1194 mi_cmd_interpreter_exec ("-interpreter-exec", argv
, 2);
1196 /* If we changed interpreters, DON'T print out anything. */
1197 if (current_interp_named_p (INTERP_MI
)
1198 || current_interp_named_p (INTERP_MI1
)
1199 || current_interp_named_p (INTERP_MI2
)
1200 || current_interp_named_p (INTERP_MI3
))
1202 if (!running_result_record_printed
)
1204 fputs_unfiltered (context
->token
, raw_stdout
);
1205 fputs_unfiltered ("^done", raw_stdout
);
1206 mi_out_put (uiout
, raw_stdout
);
1207 mi_out_rewind (uiout
);
1208 mi_print_timing_maybe ();
1209 fputs_unfiltered ("\n", raw_stdout
);
1212 mi_out_rewind (uiout
);
1224 mi_execute_command (char *cmd
, int from_tty
)
1226 struct mi_parse
*command
;
1227 struct ui_out
*saved_uiout
= uiout
;
1229 /* This is to handle EOF (^D). We just quit gdb. */
1230 /* FIXME: we should call some API function here. */
1232 quit_force (NULL
, from_tty
);
1234 command
= mi_parse (cmd
);
1236 if (command
!= NULL
)
1238 struct gdb_exception result
;
1239 ptid_t previous_ptid
= inferior_ptid
;
1243 command
->cmd_start
= (struct mi_timestamp
*)
1244 xmalloc (sizeof (struct mi_timestamp
));
1245 timestamp (command
->cmd_start
);
1248 result
= catch_exception (uiout
, captured_mi_execute_command
, command
,
1250 if (result
.reason
< 0)
1252 /* The command execution failed and error() was called
1254 fputs_unfiltered (command
->token
, raw_stdout
);
1255 fputs_unfiltered ("^error,msg=\"", raw_stdout
);
1256 if (result
.message
== NULL
)
1257 fputs_unfiltered ("unknown error", raw_stdout
);
1259 fputstr_unfiltered (result
.message
, '"', raw_stdout
);
1260 fputs_unfiltered ("\"\n", raw_stdout
);
1261 mi_out_rewind (uiout
);
1264 if (/* The notifications are only output when the top-level
1265 interpreter (specified on the command line) is MI. */
1266 ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ()))
1267 /* Don't try report anything if there are no threads --
1268 the program is dead. */
1269 && thread_count () != 0
1270 /* -thread-select explicitly changes thread. If frontend uses that
1271 internally, we don't want to emit =thread-selected, since
1272 =thread-selected is supposed to indicate user's intentions. */
1273 && strcmp (command
->command
, "thread-select") != 0)
1275 struct mi_interp
*mi
= top_level_interpreter_data ();
1276 struct thread_info
*ti
= inferior_thread ();
1279 if (command
->thread
== -1)
1281 report_change
= !ptid_equal (previous_ptid
, null_ptid
)
1282 && !ptid_equal (inferior_ptid
, previous_ptid
);
1286 report_change
= (ti
->num
!= command
->thread
);
1291 target_terminal_ours ();
1292 fprintf_unfiltered (mi
->event_channel
,
1293 "thread-selected,id=\"%d\"",
1295 gdb_flush (mi
->event_channel
);
1299 mi_parse_free (command
);
1302 fputs_unfiltered ("(gdb) \n", raw_stdout
);
1303 gdb_flush (raw_stdout
);
1304 /* Print any buffered hook code. */
1309 mi_cmd_execute (struct mi_parse
*parse
)
1311 struct cleanup
*cleanup
;
1315 current_token
= xstrdup (parse
->token
);
1316 cleanup
= make_cleanup (free_current_contents
, ¤t_token
);
1318 if (parse
->frame
!= -1 && parse
->thread
== -1)
1319 error (_("Cannot specify --frame without --thread"));
1321 if (parse
->thread
!= -1)
1323 struct thread_info
*tp
= find_thread_id (parse
->thread
);
1325 error (_("Invalid thread id: %d"), parse
->thread
);
1327 if (is_exited (tp
->ptid
))
1328 error (_("Thread id: %d has terminated"), parse
->thread
);
1330 switch_to_thread (tp
->ptid
);
1333 if (parse
->frame
!= -1)
1335 struct frame_info
*fid
;
1336 int frame
= parse
->frame
;
1337 fid
= find_relative_frame (get_current_frame (), &frame
);
1339 /* find_relative_frame was successful */
1342 error (_("Invalid frame id: %d"), frame
);
1345 if (parse
->cmd
->argv_func
!= NULL
)
1347 if (target_can_async_p ()
1348 && target_has_execution
1349 && is_exited (inferior_ptid
)
1350 && (strcmp (parse
->command
, "thread-info") != 0
1351 && strcmp (parse
->command
, "thread-list-ids") != 0
1352 && strcmp (parse
->command
, "thread-select") != 0
1353 && strcmp (parse
->command
, "list-thread-groups") != 0))
1355 struct ui_file
*stb
;
1356 stb
= mem_fileopen ();
1358 fputs_unfiltered ("Cannot execute command ", stb
);
1359 fputstr_unfiltered (parse
->command
, '"', stb
);
1360 fputs_unfiltered (" without a selected thread", stb
);
1362 make_cleanup_ui_file_delete (stb
);
1366 parse
->cmd
->argv_func (parse
->command
, parse
->argv
, parse
->argc
);
1368 else if (parse
->cmd
->cli
.cmd
!= 0)
1370 /* FIXME: DELETE THIS. */
1371 /* The operation is still implemented by a cli command. */
1372 /* Must be a synchronous one. */
1373 mi_execute_cli_command (parse
->cmd
->cli
.cmd
, parse
->cmd
->cli
.args_p
,
1378 /* FIXME: DELETE THIS. */
1379 struct ui_file
*stb
;
1381 stb
= mem_fileopen ();
1383 fputs_unfiltered ("Undefined mi command: ", stb
);
1384 fputstr_unfiltered (parse
->command
, '"', stb
);
1385 fputs_unfiltered (" (missing implementation)", stb
);
1387 make_cleanup_ui_file_delete (stb
);
1390 do_cleanups (cleanup
);
1393 /* FIXME: This is just a hack so we can get some extra commands going.
1394 We don't want to channel things through the CLI, but call libgdb directly.
1395 Use only for synchronous commands. */
1398 mi_execute_cli_command (const char *cmd
, int args_p
, const char *args
)
1402 struct cleanup
*old_cleanups
;
1405 run
= xstrprintf ("%s %s", cmd
, args
);
1407 run
= xstrdup (cmd
);
1409 /* FIXME: gdb_???? */
1410 fprintf_unfiltered (gdb_stdout
, "cli=%s run=%s\n",
1412 old_cleanups
= make_cleanup (xfree
, run
);
1413 execute_command ( /*ui */ run
, 0 /*from_tty */ );
1414 do_cleanups (old_cleanups
);
1420 mi_execute_async_cli_command (char *cli_command
, char **argv
, int argc
)
1422 struct cleanup
*old_cleanups
;
1425 if (target_can_async_p ())
1426 run
= xstrprintf ("%s %s&", cli_command
, argc
? *argv
: "");
1428 run
= xstrprintf ("%s %s", cli_command
, argc
? *argv
: "");
1429 old_cleanups
= make_cleanup (xfree
, run
);
1431 execute_command ( /*ui */ run
, 0 /*from_tty */ );
1433 if (target_can_async_p ())
1435 /* If we're not executing, an exception should have been throw. */
1436 gdb_assert (is_running (inferior_ptid
));
1437 do_cleanups (old_cleanups
);
1441 /* Do this before doing any printing. It would appear that some
1442 print code leaves garbage around in the buffer. */
1443 do_cleanups (old_cleanups
);
1448 mi_load_progress (const char *section_name
,
1449 unsigned long sent_so_far
,
1450 unsigned long total_section
,
1451 unsigned long total_sent
,
1452 unsigned long grand_total
)
1454 struct timeval time_now
, delta
, update_threshold
;
1455 static struct timeval last_update
;
1456 static char *previous_sect_name
= NULL
;
1458 struct ui_out
*saved_uiout
;
1460 /* This function is called through deprecated_show_load_progress
1461 which means uiout may not be correct. Fix it for the duration
1462 of this function. */
1463 saved_uiout
= uiout
;
1465 if (current_interp_named_p (INTERP_MI
)
1466 || current_interp_named_p (INTERP_MI2
))
1467 uiout
= mi_out_new (2);
1468 else if (current_interp_named_p (INTERP_MI1
))
1469 uiout
= mi_out_new (1);
1470 else if (current_interp_named_p (INTERP_MI3
))
1471 uiout
= mi_out_new (3);
1475 update_threshold
.tv_sec
= 0;
1476 update_threshold
.tv_usec
= 500000;
1477 gettimeofday (&time_now
, NULL
);
1479 delta
.tv_usec
= time_now
.tv_usec
- last_update
.tv_usec
;
1480 delta
.tv_sec
= time_now
.tv_sec
- last_update
.tv_sec
;
1482 if (delta
.tv_usec
< 0)
1485 delta
.tv_usec
+= 1000000L;
1488 new_section
= (previous_sect_name
?
1489 strcmp (previous_sect_name
, section_name
) : 1);
1492 struct cleanup
*cleanup_tuple
;
1493 xfree (previous_sect_name
);
1494 previous_sect_name
= xstrdup (section_name
);
1497 fputs_unfiltered (current_token
, raw_stdout
);
1498 fputs_unfiltered ("+download", raw_stdout
);
1499 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1500 ui_out_field_string (uiout
, "section", section_name
);
1501 ui_out_field_int (uiout
, "section-size", total_section
);
1502 ui_out_field_int (uiout
, "total-size", grand_total
);
1503 do_cleanups (cleanup_tuple
);
1504 mi_out_put (uiout
, raw_stdout
);
1505 fputs_unfiltered ("\n", raw_stdout
);
1506 gdb_flush (raw_stdout
);
1509 if (delta
.tv_sec
>= update_threshold
.tv_sec
&&
1510 delta
.tv_usec
>= update_threshold
.tv_usec
)
1512 struct cleanup
*cleanup_tuple
;
1513 last_update
.tv_sec
= time_now
.tv_sec
;
1514 last_update
.tv_usec
= time_now
.tv_usec
;
1516 fputs_unfiltered (current_token
, raw_stdout
);
1517 fputs_unfiltered ("+download", raw_stdout
);
1518 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1519 ui_out_field_string (uiout
, "section", section_name
);
1520 ui_out_field_int (uiout
, "section-sent", sent_so_far
);
1521 ui_out_field_int (uiout
, "section-size", total_section
);
1522 ui_out_field_int (uiout
, "total-sent", total_sent
);
1523 ui_out_field_int (uiout
, "total-size", grand_total
);
1524 do_cleanups (cleanup_tuple
);
1525 mi_out_put (uiout
, raw_stdout
);
1526 fputs_unfiltered ("\n", raw_stdout
);
1527 gdb_flush (raw_stdout
);
1531 uiout
= saved_uiout
;
1535 timestamp (struct mi_timestamp
*tv
)
1538 gettimeofday (&tv
->wallclock
, NULL
);
1539 #ifdef HAVE_GETRUSAGE
1540 getrusage (RUSAGE_SELF
, &rusage
);
1541 tv
->utime
.tv_sec
= rusage
.ru_utime
.tv_sec
;
1542 tv
->utime
.tv_usec
= rusage
.ru_utime
.tv_usec
;
1543 tv
->stime
.tv_sec
= rusage
.ru_stime
.tv_sec
;
1544 tv
->stime
.tv_usec
= rusage
.ru_stime
.tv_usec
;
1546 usec
= get_run_time ();
1547 tv
->utime
.tv_sec
= usec
/1000000L;
1548 tv
->utime
.tv_usec
= usec
- 1000000L*tv
->utime
.tv_sec
;
1549 tv
->stime
.tv_sec
= 0;
1550 tv
->stime
.tv_usec
= 0;
1555 print_diff_now (struct mi_timestamp
*start
)
1557 struct mi_timestamp now
;
1559 print_diff (start
, &now
);
1563 mi_print_timing_maybe (void)
1565 /* If the command is -enable-timing then do_timings may be
1566 true whilst current_command_ts is not initialized. */
1567 if (do_timings
&& current_command_ts
)
1568 print_diff_now (current_command_ts
);
1572 timeval_diff (struct timeval start
, struct timeval end
)
1574 return ((end
.tv_sec
- start
.tv_sec
) * 1000000L)
1575 + (end
.tv_usec
- start
.tv_usec
);
1579 print_diff (struct mi_timestamp
*start
, struct mi_timestamp
*end
)
1583 ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
1584 timeval_diff (start
->wallclock
, end
->wallclock
) / 1000000.0,
1585 timeval_diff (start
->utime
, end
->utime
) / 1000000.0,
1586 timeval_diff (start
->stime
, end
->stime
) / 1000000.0);