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 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 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 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 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 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");
920 mi_cmd_list_target_features (char *command
, char **argv
, int argc
)
924 struct cleanup
*cleanup
= NULL
;
925 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "features");
927 if (target_can_async_p ())
928 ui_out_field_string (uiout
, NULL
, "async");
930 do_cleanups (cleanup
);
934 error ("-list-target-features should be passed no arguments");
937 /* Execute a command within a safe environment.
938 Return <0 for error; >=0 for ok.
940 args->action will tell mi_execute_command what action
941 to perfrom after the given command has executed (display/suppress
942 prompt, display error). */
945 captured_mi_execute_command (struct ui_out
*uiout
, void *data
)
947 struct mi_parse
*context
= (struct mi_parse
*) data
;
949 struct mi_timestamp cmd_finished
;
951 running_result_record_printed
= 0;
955 /* A MI command was read from the input stream. */
957 /* FIXME: gdb_???? */
958 fprintf_unfiltered (raw_stdout
, " token=`%s' command=`%s' args=`%s'\n",
959 context
->token
, context
->command
, context
->args
);
962 current_command_ts
= context
->cmd_start
;
964 mi_cmd_execute (context
);
967 timestamp (&cmd_finished
);
969 /* Print the result if there were no errors.
971 Remember that on the way out of executing a command, you have
972 to directly use the mi_interp's uiout, since the command could
973 have reset the interpreter, in which case the current uiout
974 will most likely crash in the mi_out_* routines. */
975 if (!running_result_record_printed
)
977 fputs_unfiltered (context
->token
, raw_stdout
);
978 /* There's no particularly good reason why target-connect results
979 in not ^done. Should kill ^connected for MI3. */
980 fputs_unfiltered (strcmp (context
->command
, "target-select") == 0
981 ? "^connected" : "^done", raw_stdout
);
982 mi_out_put (uiout
, raw_stdout
);
983 mi_out_rewind (uiout
);
984 /* Have to check cmd_start, since the command could be
986 if (do_timings
&& context
->cmd_start
)
987 print_diff (context
->cmd_start
, &cmd_finished
);
988 fputs_unfiltered ("\n", raw_stdout
);
991 /* The command does not want anything to be printed. In that
992 case, the command probably should not have written anything
993 to uiout, but in case it has written something, discard it. */
994 mi_out_rewind (uiout
);
1000 /* A CLI command was read from the input stream. */
1001 /* This "feature" will be removed as soon as we have a
1002 complete set of mi commands. */
1003 /* Echo the command on the console. */
1004 fprintf_unfiltered (gdb_stdlog
, "%s\n", context
->command
);
1005 /* Call the "console" interpreter. */
1006 argv
[0] = "console";
1007 argv
[1] = context
->command
;
1008 mi_cmd_interpreter_exec ("-interpreter-exec", argv
, 2);
1010 /* If we changed interpreters, DON'T print out anything. */
1011 if (current_interp_named_p (INTERP_MI
)
1012 || current_interp_named_p (INTERP_MI1
)
1013 || current_interp_named_p (INTERP_MI2
)
1014 || current_interp_named_p (INTERP_MI3
))
1016 if (!running_result_record_printed
)
1018 fputs_unfiltered (context
->token
, raw_stdout
);
1019 fputs_unfiltered ("^done", raw_stdout
);
1020 mi_out_put (uiout
, raw_stdout
);
1021 mi_out_rewind (uiout
);
1022 fputs_unfiltered ("\n", raw_stdout
);
1025 mi_out_rewind (uiout
);
1037 mi_execute_command (char *cmd
, int from_tty
)
1039 struct mi_parse
*command
;
1040 struct ui_out
*saved_uiout
= uiout
;
1042 /* This is to handle EOF (^D). We just quit gdb. */
1043 /* FIXME: we should call some API function here. */
1045 quit_force (NULL
, from_tty
);
1047 command
= mi_parse (cmd
);
1049 if (command
!= NULL
)
1051 struct gdb_exception result
;
1055 command
->cmd_start
= (struct mi_timestamp
*)
1056 xmalloc (sizeof (struct mi_timestamp
));
1057 timestamp (command
->cmd_start
);
1060 result
= catch_exception (uiout
, captured_mi_execute_command
, command
,
1062 if (result
.reason
< 0)
1064 /* The command execution failed and error() was called
1066 fputs_unfiltered (command
->token
, raw_stdout
);
1067 fputs_unfiltered ("^error,msg=\"", raw_stdout
);
1068 if (result
.message
== NULL
)
1069 fputs_unfiltered ("unknown error", raw_stdout
);
1071 fputstr_unfiltered (result
.message
, '"', raw_stdout
);
1072 fputs_unfiltered ("\"\n", raw_stdout
);
1073 mi_out_rewind (uiout
);
1076 mi_parse_free (command
);
1079 fputs_unfiltered ("(gdb) \n", raw_stdout
);
1080 gdb_flush (raw_stdout
);
1081 /* Print any buffered hook code. */
1086 mi_cmd_execute (struct mi_parse
*parse
)
1088 struct cleanup
*cleanup
;
1092 current_token
= xstrdup (parse
->token
);
1093 cleanup
= make_cleanup (free_current_contents
, ¤t_token
);
1095 if (parse
->frame
!= -1 && parse
->thread
== -1)
1096 error (_("Cannot specify --frame without --thread"));
1098 if (parse
->thread
!= -1)
1100 struct thread_info
*tp
= find_thread_id (parse
->thread
);
1102 error (_("Invalid thread id: %d"), parse
->thread
);
1105 context_switch_to (tp
->ptid
);
1107 switch_to_thread (tp
->ptid
);
1110 if (parse
->frame
!= -1)
1112 struct frame_info
*fid
;
1113 int frame
= parse
->frame
;
1114 fid
= find_relative_frame (get_current_frame (), &frame
);
1116 /* find_relative_frame was successful */
1119 error (_("Invalid frame id: %d"), frame
);
1122 if (parse
->cmd
->argv_func
!= NULL
)
1124 if (target_can_async_p ()
1125 && target_has_execution
1126 && (is_exited (inferior_ptid
))
1127 && (strcmp (parse
->command
, "thread-info") != 0
1128 && strcmp (parse
->command
, "thread-list-ids") != 0
1129 && strcmp (parse
->command
, "thread-select") != 0))
1131 struct ui_file
*stb
;
1132 stb
= mem_fileopen ();
1134 fputs_unfiltered ("Cannot execute command ", stb
);
1135 fputstr_unfiltered (parse
->command
, '"', stb
);
1136 fputs_unfiltered (" without a selected thread", stb
);
1138 make_cleanup_ui_file_delete (stb
);
1142 parse
->cmd
->argv_func (parse
->command
, parse
->argv
, parse
->argc
);
1144 else if (parse
->cmd
->cli
.cmd
!= 0)
1146 /* FIXME: DELETE THIS. */
1147 /* The operation is still implemented by a cli command. */
1148 /* Must be a synchronous one. */
1149 mi_execute_cli_command (parse
->cmd
->cli
.cmd
, parse
->cmd
->cli
.args_p
,
1154 /* FIXME: DELETE THIS. */
1155 struct ui_file
*stb
;
1157 stb
= mem_fileopen ();
1159 fputs_unfiltered ("Undefined mi command: ", stb
);
1160 fputstr_unfiltered (parse
->command
, '"', stb
);
1161 fputs_unfiltered (" (missing implementation)", stb
);
1163 make_cleanup_ui_file_delete (stb
);
1166 do_cleanups (cleanup
);
1169 /* FIXME: This is just a hack so we can get some extra commands going.
1170 We don't want to channel things through the CLI, but call libgdb directly.
1171 Use only for synchronous commands. */
1174 mi_execute_cli_command (const char *cmd
, int args_p
, const char *args
)
1178 struct cleanup
*old_cleanups
;
1181 run
= xstrprintf ("%s %s", cmd
, args
);
1183 run
= xstrdup (cmd
);
1185 /* FIXME: gdb_???? */
1186 fprintf_unfiltered (gdb_stdout
, "cli=%s run=%s\n",
1188 old_cleanups
= make_cleanup (xfree
, run
);
1189 execute_command ( /*ui */ run
, 0 /*from_tty */ );
1190 do_cleanups (old_cleanups
);
1196 mi_execute_async_cli_command (char *cli_command
, char **argv
, int argc
)
1198 struct cleanup
*old_cleanups
;
1201 if (target_can_async_p ())
1202 run
= xstrprintf ("%s %s&", cli_command
, argc
? *argv
: "");
1204 run
= xstrprintf ("%s %s", cli_command
, argc
? *argv
: "");
1205 old_cleanups
= make_cleanup (xfree
, run
);
1207 execute_command ( /*ui */ run
, 0 /*from_tty */ );
1209 if (target_can_async_p ())
1211 /* If we're not executing, an exception should have been throw. */
1212 gdb_assert (is_running (inferior_ptid
));
1213 do_cleanups (old_cleanups
);
1217 /* Do this before doing any printing. It would appear that some
1218 print code leaves garbage around in the buffer. */
1219 do_cleanups (old_cleanups
);
1221 print_diff_now (current_command_ts
);
1226 mi_load_progress (const char *section_name
,
1227 unsigned long sent_so_far
,
1228 unsigned long total_section
,
1229 unsigned long total_sent
,
1230 unsigned long grand_total
)
1232 struct timeval time_now
, delta
, update_threshold
;
1233 static struct timeval last_update
;
1234 static char *previous_sect_name
= NULL
;
1236 struct ui_out
*saved_uiout
;
1238 /* This function is called through deprecated_show_load_progress
1239 which means uiout may not be correct. Fix it for the duration
1240 of this function. */
1241 saved_uiout
= uiout
;
1243 if (current_interp_named_p (INTERP_MI
)
1244 || current_interp_named_p (INTERP_MI2
))
1245 uiout
= mi_out_new (2);
1246 else if (current_interp_named_p (INTERP_MI1
))
1247 uiout
= mi_out_new (1);
1248 else if (current_interp_named_p (INTERP_MI3
))
1249 uiout
= mi_out_new (3);
1253 update_threshold
.tv_sec
= 0;
1254 update_threshold
.tv_usec
= 500000;
1255 gettimeofday (&time_now
, NULL
);
1257 delta
.tv_usec
= time_now
.tv_usec
- last_update
.tv_usec
;
1258 delta
.tv_sec
= time_now
.tv_sec
- last_update
.tv_sec
;
1260 if (delta
.tv_usec
< 0)
1263 delta
.tv_usec
+= 1000000L;
1266 new_section
= (previous_sect_name
?
1267 strcmp (previous_sect_name
, section_name
) : 1);
1270 struct cleanup
*cleanup_tuple
;
1271 xfree (previous_sect_name
);
1272 previous_sect_name
= xstrdup (section_name
);
1275 fputs_unfiltered (current_token
, raw_stdout
);
1276 fputs_unfiltered ("+download", raw_stdout
);
1277 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1278 ui_out_field_string (uiout
, "section", section_name
);
1279 ui_out_field_int (uiout
, "section-size", total_section
);
1280 ui_out_field_int (uiout
, "total-size", grand_total
);
1281 do_cleanups (cleanup_tuple
);
1282 mi_out_put (uiout
, raw_stdout
);
1283 fputs_unfiltered ("\n", raw_stdout
);
1284 gdb_flush (raw_stdout
);
1287 if (delta
.tv_sec
>= update_threshold
.tv_sec
&&
1288 delta
.tv_usec
>= update_threshold
.tv_usec
)
1290 struct cleanup
*cleanup_tuple
;
1291 last_update
.tv_sec
= time_now
.tv_sec
;
1292 last_update
.tv_usec
= time_now
.tv_usec
;
1294 fputs_unfiltered (current_token
, raw_stdout
);
1295 fputs_unfiltered ("+download", raw_stdout
);
1296 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1297 ui_out_field_string (uiout
, "section", section_name
);
1298 ui_out_field_int (uiout
, "section-sent", sent_so_far
);
1299 ui_out_field_int (uiout
, "section-size", total_section
);
1300 ui_out_field_int (uiout
, "total-sent", total_sent
);
1301 ui_out_field_int (uiout
, "total-size", grand_total
);
1302 do_cleanups (cleanup_tuple
);
1303 mi_out_put (uiout
, raw_stdout
);
1304 fputs_unfiltered ("\n", raw_stdout
);
1305 gdb_flush (raw_stdout
);
1309 uiout
= saved_uiout
;
1313 timestamp (struct mi_timestamp
*tv
)
1316 gettimeofday (&tv
->wallclock
, NULL
);
1317 #ifdef HAVE_GETRUSAGE
1318 getrusage (RUSAGE_SELF
, &rusage
);
1319 tv
->utime
.tv_sec
= rusage
.ru_utime
.tv_sec
;
1320 tv
->utime
.tv_usec
= rusage
.ru_utime
.tv_usec
;
1321 tv
->stime
.tv_sec
= rusage
.ru_stime
.tv_sec
;
1322 tv
->stime
.tv_usec
= rusage
.ru_stime
.tv_usec
;
1324 usec
= get_run_time ();
1325 tv
->utime
.tv_sec
= usec
/1000000L;
1326 tv
->utime
.tv_usec
= usec
- 1000000L*tv
->utime
.tv_sec
;
1327 tv
->stime
.tv_sec
= 0;
1328 tv
->stime
.tv_usec
= 0;
1333 print_diff_now (struct mi_timestamp
*start
)
1335 struct mi_timestamp now
;
1337 print_diff (start
, &now
);
1341 timeval_diff (struct timeval start
, struct timeval end
)
1343 return ((end
.tv_sec
- start
.tv_sec
) * 1000000L)
1344 + (end
.tv_usec
- start
.tv_usec
);
1348 print_diff (struct mi_timestamp
*start
, struct mi_timestamp
*end
)
1352 ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
1353 timeval_diff (start
->wallclock
, end
->wallclock
) / 1000000.0,
1354 timeval_diff (start
->utime
, end
->utime
) / 1000000.0,
1355 timeval_diff (start
->stime
, end
->stime
) / 1000000.0);