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] + 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] + 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");
1116 do_cleanups (cleanup
);
1120 error ("-list-features should be passed no arguments");
1124 mi_cmd_list_target_features (char *command
, char **argv
, int argc
)
1128 struct cleanup
*cleanup
= NULL
;
1129 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "features");
1131 if (target_can_async_p ())
1132 ui_out_field_string (uiout
, NULL
, "async");
1134 do_cleanups (cleanup
);
1138 error ("-list-target-features should be passed no arguments");
1141 /* Execute a command within a safe environment.
1142 Return <0 for error; >=0 for ok.
1144 args->action will tell mi_execute_command what action
1145 to perfrom after the given command has executed (display/suppress
1146 prompt, display error). */
1149 captured_mi_execute_command (struct ui_out
*uiout
, void *data
)
1151 struct cleanup
*cleanup
;
1152 struct mi_parse
*context
= (struct mi_parse
*) data
;
1155 current_command_ts
= context
->cmd_start
;
1157 current_token
= xstrdup (context
->token
);
1158 cleanup
= make_cleanup (free_current_contents
, ¤t_token
);
1160 running_result_record_printed
= 0;
1162 switch (context
->op
)
1165 /* A MI command was read from the input stream. */
1167 /* FIXME: gdb_???? */
1168 fprintf_unfiltered (raw_stdout
, " token=`%s' command=`%s' args=`%s'\n",
1169 context
->token
, context
->command
, context
->args
);
1172 mi_cmd_execute (context
);
1174 /* Print the result if there were no errors.
1176 Remember that on the way out of executing a command, you have
1177 to directly use the mi_interp's uiout, since the command could
1178 have reset the interpreter, in which case the current uiout
1179 will most likely crash in the mi_out_* routines. */
1180 if (!running_result_record_printed
)
1182 fputs_unfiltered (context
->token
, raw_stdout
);
1183 /* There's no particularly good reason why target-connect results
1184 in not ^done. Should kill ^connected for MI3. */
1185 fputs_unfiltered (strcmp (context
->command
, "target-select") == 0
1186 ? "^connected" : "^done", raw_stdout
);
1187 mi_out_put (uiout
, raw_stdout
);
1188 mi_out_rewind (uiout
);
1189 mi_print_timing_maybe ();
1190 fputs_unfiltered ("\n", raw_stdout
);
1193 /* The command does not want anything to be printed. In that
1194 case, the command probably should not have written anything
1195 to uiout, but in case it has written something, discard it. */
1196 mi_out_rewind (uiout
);
1202 /* A CLI command was read from the input stream. */
1203 /* This "feature" will be removed as soon as we have a
1204 complete set of mi commands. */
1205 /* Echo the command on the console. */
1206 fprintf_unfiltered (gdb_stdlog
, "%s\n", context
->command
);
1207 /* Call the "console" interpreter. */
1208 argv
[0] = "console";
1209 argv
[1] = context
->command
;
1210 mi_cmd_interpreter_exec ("-interpreter-exec", argv
, 2);
1212 /* If we changed interpreters, DON'T print out anything. */
1213 if (current_interp_named_p (INTERP_MI
)
1214 || current_interp_named_p (INTERP_MI1
)
1215 || current_interp_named_p (INTERP_MI2
)
1216 || current_interp_named_p (INTERP_MI3
))
1218 if (!running_result_record_printed
)
1220 fputs_unfiltered (context
->token
, raw_stdout
);
1221 fputs_unfiltered ("^done", raw_stdout
);
1222 mi_out_put (uiout
, raw_stdout
);
1223 mi_out_rewind (uiout
);
1224 mi_print_timing_maybe ();
1225 fputs_unfiltered ("\n", raw_stdout
);
1228 mi_out_rewind (uiout
);
1235 do_cleanups (cleanup
);
1242 mi_execute_command (char *cmd
, int from_tty
)
1244 struct mi_parse
*command
;
1245 struct ui_out
*saved_uiout
= uiout
;
1247 /* This is to handle EOF (^D). We just quit gdb. */
1248 /* FIXME: we should call some API function here. */
1250 quit_force (NULL
, from_tty
);
1252 command
= mi_parse (cmd
);
1254 if (command
!= NULL
)
1256 struct gdb_exception result
;
1257 ptid_t previous_ptid
= inferior_ptid
;
1261 command
->cmd_start
= (struct mi_timestamp
*)
1262 xmalloc (sizeof (struct mi_timestamp
));
1263 timestamp (command
->cmd_start
);
1266 result
= catch_exception (uiout
, captured_mi_execute_command
, command
,
1268 if (result
.reason
< 0)
1270 /* The command execution failed and error() was called
1272 fputs_unfiltered (command
->token
, raw_stdout
);
1273 fputs_unfiltered ("^error,msg=\"", raw_stdout
);
1274 if (result
.message
== NULL
)
1275 fputs_unfiltered ("unknown error", raw_stdout
);
1277 fputstr_unfiltered (result
.message
, '"', raw_stdout
);
1278 fputs_unfiltered ("\"\n", raw_stdout
);
1279 mi_out_rewind (uiout
);
1282 if (/* The notifications are only output when the top-level
1283 interpreter (specified on the command line) is MI. */
1284 ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ()))
1285 /* Don't try report anything if there are no threads --
1286 the program is dead. */
1287 && thread_count () != 0
1288 /* -thread-select explicitly changes thread. If frontend uses that
1289 internally, we don't want to emit =thread-selected, since
1290 =thread-selected is supposed to indicate user's intentions. */
1291 && strcmp (command
->command
, "thread-select") != 0)
1293 struct mi_interp
*mi
= top_level_interpreter_data ();
1294 int report_change
= 0;
1296 if (command
->thread
== -1)
1298 report_change
= (!ptid_equal (previous_ptid
, null_ptid
)
1299 && !ptid_equal (inferior_ptid
, previous_ptid
)
1300 && !ptid_equal (inferior_ptid
, null_ptid
));
1302 else if (!ptid_equal (inferior_ptid
, null_ptid
))
1304 struct thread_info
*ti
= inferior_thread ();
1305 report_change
= (ti
->num
!= command
->thread
);
1310 struct thread_info
*ti
= inferior_thread ();
1311 target_terminal_ours ();
1312 fprintf_unfiltered (mi
->event_channel
,
1313 "thread-selected,id=\"%d\"",
1315 gdb_flush (mi
->event_channel
);
1319 mi_parse_free (command
);
1322 fputs_unfiltered ("(gdb) \n", raw_stdout
);
1323 gdb_flush (raw_stdout
);
1324 /* Print any buffered hook code. */
1329 mi_cmd_execute (struct mi_parse
*parse
)
1331 struct cleanup
*cleanup
;
1335 cleanup
= make_cleanup (null_cleanup
, NULL
);
1337 if (parse
->frame
!= -1 && parse
->thread
== -1)
1338 error (_("Cannot specify --frame without --thread"));
1340 if (parse
->thread
!= -1)
1342 struct thread_info
*tp
= find_thread_id (parse
->thread
);
1344 error (_("Invalid thread id: %d"), parse
->thread
);
1346 if (is_exited (tp
->ptid
))
1347 error (_("Thread id: %d has terminated"), parse
->thread
);
1349 switch_to_thread (tp
->ptid
);
1352 if (parse
->frame
!= -1)
1354 struct frame_info
*fid
;
1355 int frame
= parse
->frame
;
1356 fid
= find_relative_frame (get_current_frame (), &frame
);
1358 /* find_relative_frame was successful */
1361 error (_("Invalid frame id: %d"), frame
);
1364 if (parse
->cmd
->argv_func
!= NULL
)
1365 parse
->cmd
->argv_func (parse
->command
, parse
->argv
, parse
->argc
);
1366 else if (parse
->cmd
->cli
.cmd
!= 0)
1368 /* FIXME: DELETE THIS. */
1369 /* The operation is still implemented by a cli command. */
1370 /* Must be a synchronous one. */
1371 mi_execute_cli_command (parse
->cmd
->cli
.cmd
, parse
->cmd
->cli
.args_p
,
1376 /* FIXME: DELETE THIS. */
1377 struct ui_file
*stb
;
1379 stb
= mem_fileopen ();
1381 fputs_unfiltered ("Undefined mi command: ", stb
);
1382 fputstr_unfiltered (parse
->command
, '"', stb
);
1383 fputs_unfiltered (" (missing implementation)", stb
);
1385 make_cleanup_ui_file_delete (stb
);
1388 do_cleanups (cleanup
);
1391 /* FIXME: This is just a hack so we can get some extra commands going.
1392 We don't want to channel things through the CLI, but call libgdb directly.
1393 Use only for synchronous commands. */
1396 mi_execute_cli_command (const char *cmd
, int args_p
, const char *args
)
1400 struct cleanup
*old_cleanups
;
1403 run
= xstrprintf ("%s %s", cmd
, args
);
1405 run
= xstrdup (cmd
);
1407 /* FIXME: gdb_???? */
1408 fprintf_unfiltered (gdb_stdout
, "cli=%s run=%s\n",
1410 old_cleanups
= make_cleanup (xfree
, run
);
1411 execute_command ( /*ui */ run
, 0 /*from_tty */ );
1412 do_cleanups (old_cleanups
);
1418 mi_execute_async_cli_command (char *cli_command
, char **argv
, int argc
)
1420 struct cleanup
*old_cleanups
;
1423 if (target_can_async_p ())
1424 run
= xstrprintf ("%s %s&", cli_command
, argc
? *argv
: "");
1426 run
= xstrprintf ("%s %s", cli_command
, argc
? *argv
: "");
1427 old_cleanups
= make_cleanup (xfree
, run
);
1429 execute_command ( /*ui */ run
, 0 /*from_tty */ );
1431 if (target_can_async_p ())
1433 /* If we're not executing, an exception should have been throw. */
1434 gdb_assert (is_running (inferior_ptid
));
1435 do_cleanups (old_cleanups
);
1439 /* Do this before doing any printing. It would appear that some
1440 print code leaves garbage around in the buffer. */
1441 do_cleanups (old_cleanups
);
1446 mi_load_progress (const char *section_name
,
1447 unsigned long sent_so_far
,
1448 unsigned long total_section
,
1449 unsigned long total_sent
,
1450 unsigned long grand_total
)
1452 struct timeval time_now
, delta
, update_threshold
;
1453 static struct timeval last_update
;
1454 static char *previous_sect_name
= NULL
;
1456 struct ui_out
*saved_uiout
;
1458 /* This function is called through deprecated_show_load_progress
1459 which means uiout may not be correct. Fix it for the duration
1460 of this function. */
1461 saved_uiout
= uiout
;
1463 if (current_interp_named_p (INTERP_MI
)
1464 || current_interp_named_p (INTERP_MI2
))
1465 uiout
= mi_out_new (2);
1466 else if (current_interp_named_p (INTERP_MI1
))
1467 uiout
= mi_out_new (1);
1468 else if (current_interp_named_p (INTERP_MI3
))
1469 uiout
= mi_out_new (3);
1473 update_threshold
.tv_sec
= 0;
1474 update_threshold
.tv_usec
= 500000;
1475 gettimeofday (&time_now
, NULL
);
1477 delta
.tv_usec
= time_now
.tv_usec
- last_update
.tv_usec
;
1478 delta
.tv_sec
= time_now
.tv_sec
- last_update
.tv_sec
;
1480 if (delta
.tv_usec
< 0)
1483 delta
.tv_usec
+= 1000000L;
1486 new_section
= (previous_sect_name
?
1487 strcmp (previous_sect_name
, section_name
) : 1);
1490 struct cleanup
*cleanup_tuple
;
1491 xfree (previous_sect_name
);
1492 previous_sect_name
= xstrdup (section_name
);
1495 fputs_unfiltered (current_token
, raw_stdout
);
1496 fputs_unfiltered ("+download", raw_stdout
);
1497 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1498 ui_out_field_string (uiout
, "section", section_name
);
1499 ui_out_field_int (uiout
, "section-size", total_section
);
1500 ui_out_field_int (uiout
, "total-size", grand_total
);
1501 do_cleanups (cleanup_tuple
);
1502 mi_out_put (uiout
, raw_stdout
);
1503 fputs_unfiltered ("\n", raw_stdout
);
1504 gdb_flush (raw_stdout
);
1507 if (delta
.tv_sec
>= update_threshold
.tv_sec
&&
1508 delta
.tv_usec
>= update_threshold
.tv_usec
)
1510 struct cleanup
*cleanup_tuple
;
1511 last_update
.tv_sec
= time_now
.tv_sec
;
1512 last_update
.tv_usec
= time_now
.tv_usec
;
1514 fputs_unfiltered (current_token
, raw_stdout
);
1515 fputs_unfiltered ("+download", raw_stdout
);
1516 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1517 ui_out_field_string (uiout
, "section", section_name
);
1518 ui_out_field_int (uiout
, "section-sent", sent_so_far
);
1519 ui_out_field_int (uiout
, "section-size", total_section
);
1520 ui_out_field_int (uiout
, "total-sent", total_sent
);
1521 ui_out_field_int (uiout
, "total-size", grand_total
);
1522 do_cleanups (cleanup_tuple
);
1523 mi_out_put (uiout
, raw_stdout
);
1524 fputs_unfiltered ("\n", raw_stdout
);
1525 gdb_flush (raw_stdout
);
1529 uiout
= saved_uiout
;
1533 timestamp (struct mi_timestamp
*tv
)
1536 gettimeofday (&tv
->wallclock
, NULL
);
1537 #ifdef HAVE_GETRUSAGE
1538 getrusage (RUSAGE_SELF
, &rusage
);
1539 tv
->utime
.tv_sec
= rusage
.ru_utime
.tv_sec
;
1540 tv
->utime
.tv_usec
= rusage
.ru_utime
.tv_usec
;
1541 tv
->stime
.tv_sec
= rusage
.ru_stime
.tv_sec
;
1542 tv
->stime
.tv_usec
= rusage
.ru_stime
.tv_usec
;
1544 usec
= get_run_time ();
1545 tv
->utime
.tv_sec
= usec
/1000000L;
1546 tv
->utime
.tv_usec
= usec
- 1000000L*tv
->utime
.tv_sec
;
1547 tv
->stime
.tv_sec
= 0;
1548 tv
->stime
.tv_usec
= 0;
1553 print_diff_now (struct mi_timestamp
*start
)
1555 struct mi_timestamp now
;
1557 print_diff (start
, &now
);
1561 mi_print_timing_maybe (void)
1563 /* If the command is -enable-timing then do_timings may be
1564 true whilst current_command_ts is not initialized. */
1565 if (do_timings
&& current_command_ts
)
1566 print_diff_now (current_command_ts
);
1570 timeval_diff (struct timeval start
, struct timeval end
)
1572 return ((end
.tv_sec
- start
.tv_sec
) * 1000000L)
1573 + (end
.tv_usec
- start
.tv_usec
);
1577 print_diff (struct mi_timestamp
*start
, struct mi_timestamp
*end
)
1581 ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
1582 timeval_diff (start
->wallclock
, end
->wallclock
) / 1000000.0,
1583 timeval_diff (start
->utime
, end
->utime
) / 1000000.0,
1584 timeval_diff (start
->stime
, end
->stime
) / 1000000.0);