1 /* Memory-access and commands for "inferior" process, for GDB.
3 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
4 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
5 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
26 #include "gdb_string.h"
40 #include "completer.h"
42 #include "event-top.h"
43 #include "parser-defs.h"
45 #include "reggroups.h"
49 #include "gdb_assert.h"
51 /* Functions exported for general use, in inferior.h: */
53 void all_registers_info (char *, int);
55 void registers_info (char *, int);
57 void nexti_command (char *, int);
59 void stepi_command (char *, int);
61 void continue_command (char *, int);
63 void interrupt_target_command (char *args
, int from_tty
);
65 /* Local functions: */
67 static void nofp_registers_info (char *, int);
69 static void print_return_value (int struct_return
, struct type
*value_type
);
71 static void finish_command_continuation (struct continuation_arg
*);
73 static void until_next_command (int);
75 static void until_command (char *, int);
77 static void path_info (char *, int);
79 static void path_command (char *, int);
81 static void unset_command (char *, int);
83 static void float_info (char *, int);
85 static void detach_command (char *, int);
87 static void disconnect_command (char *, int);
89 static void unset_environment_command (char *, int);
91 static void set_environment_command (char *, int);
93 static void environment_info (char *, int);
95 static void program_info (char *, int);
97 static void finish_command (char *, int);
99 static void signal_command (char *, int);
101 static void jump_command (char *, int);
103 static void step_1 (int, int, char *);
104 static void step_once (int skip_subroutines
, int single_inst
, int count
);
105 static void step_1_continuation (struct continuation_arg
*arg
);
107 static void next_command (char *, int);
109 static void step_command (char *, int);
111 static void run_command (char *, int);
113 static void run_no_args_command (char *args
, int from_tty
);
115 static void go_command (char *line_no
, int from_tty
);
117 static int strip_bg_char (char **);
119 void _initialize_infcmd (void);
121 #define GO_USAGE "Usage: go <location>\n"
123 #define ERROR_NO_INFERIOR \
124 if (!target_has_execution) error (_("The program is not being run."));
126 /* String containing arguments to give to the program, separated by spaces.
127 Empty string (pointer to '\0') means no args. */
129 static char *inferior_args
;
131 /* The inferior arguments as a vector. If INFERIOR_ARGC is nonzero,
132 then we must compute INFERIOR_ARGS from this (via the target). */
134 static int inferior_argc
;
135 static char **inferior_argv
;
137 /* File name for default use for standard in/out in the inferior. */
139 static char *inferior_io_terminal
;
141 /* Pid of our debugged inferior, or 0 if no inferior now.
142 Since various parts of infrun.c test this to see whether there is a program
143 being debugged it should be nonzero (currently 3 is used) for remote
146 ptid_t inferior_ptid
;
148 /* Last signal that the inferior received (why it stopped). */
150 enum target_signal stop_signal
;
152 /* Address at which inferior stopped. */
156 /* Chain containing status of breakpoint(s) that we have stopped at. */
160 /* Flag indicating that a command has proceeded the inferior past the
161 current breakpoint. */
163 int breakpoint_proceeded
;
165 /* Nonzero if stopped due to a step command. */
169 /* Nonzero if stopped due to completion of a stack dummy routine. */
171 int stop_stack_dummy
;
173 /* Nonzero if stopped due to a random (unexpected) signal in inferior
176 int stopped_by_random_signal
;
178 /* Range to single step within.
179 If this is nonzero, respond to a single-step signal
180 by continuing to step if the pc is in this range. */
182 CORE_ADDR step_range_start
; /* Inclusive */
183 CORE_ADDR step_range_end
; /* Exclusive */
185 /* Stack frame address as of when stepping command was issued.
186 This is how we know when we step into a subroutine call,
187 and how to set the frame for the breakpoint used to step out. */
189 struct frame_id step_frame_id
;
191 enum step_over_calls_kind step_over_calls
;
193 /* If stepping, nonzero means step count is > 1
194 so don't print frame next time inferior stops
195 if it stops due to stepping. */
199 /* Environment to use for running inferior,
200 in format described in environ.h. */
202 struct gdb_environ
*inferior_environ
;
204 /* Accessor routines. */
207 set_inferior_io_terminal (const char *terminal_name
)
209 if (inferior_io_terminal
)
210 xfree (inferior_io_terminal
);
213 inferior_io_terminal
= NULL
;
215 inferior_io_terminal
= savestring (terminal_name
, strlen (terminal_name
));
219 get_inferior_io_terminal (void)
221 return inferior_io_terminal
;
225 get_inferior_args (void)
227 if (inferior_argc
!= 0)
231 n
= gdbarch_construct_inferior_arguments (current_gdbarch
,
232 inferior_argc
, inferior_argv
);
233 old
= set_inferior_args (n
);
237 if (inferior_args
== NULL
)
238 inferior_args
= xstrdup ("");
240 return inferior_args
;
244 set_inferior_args (char *newargs
)
246 char *saved_args
= inferior_args
;
248 inferior_args
= newargs
;
256 set_inferior_args_vector (int argc
, char **argv
)
258 inferior_argc
= argc
;
259 inferior_argv
= argv
;
262 /* Notice when `set args' is run. */
264 notice_args_set (char *args
, int from_tty
, struct cmd_list_element
*c
)
270 /* Notice when `show args' is run. */
272 notice_args_read (struct ui_file
*file
, int from_tty
,
273 struct cmd_list_element
*c
, const char *value
)
275 deprecated_show_value_hack (file
, from_tty
, c
, value
);
276 /* Might compute the value. */
277 get_inferior_args ();
281 /* Compute command-line string given argument vector. This does the
282 same shell processing as fork_inferior. */
284 construct_inferior_arguments (struct gdbarch
*gdbarch
, int argc
, char **argv
)
288 if (STARTUP_WITH_SHELL
)
290 /* This holds all the characters considered special to the
291 typical Unix shells. We include `^' because the SunOS
292 /bin/sh treats it as a synonym for `|'. */
293 char *special
= "\"!#$&*()\\|[]{}<>?'\"`~^; \t\n";
298 /* We over-compute the size. It shouldn't matter. */
299 for (i
= 0; i
< argc
; ++i
)
300 length
+= 2 * strlen (argv
[i
]) + 1 + 2 * (argv
[i
][0] == '\0');
302 result
= (char *) xmalloc (length
);
305 for (i
= 0; i
< argc
; ++i
)
310 /* Need to handle empty arguments specially. */
311 if (argv
[i
][0] == '\0')
318 for (cp
= argv
[i
]; *cp
; ++cp
)
320 if (strchr (special
, *cp
) != NULL
)
330 /* In this case we can't handle arguments that contain spaces,
331 tabs, or newlines -- see breakup_args(). */
335 for (i
= 0; i
< argc
; ++i
)
337 char *cp
= strchr (argv
[i
], ' ');
339 cp
= strchr (argv
[i
], '\t');
341 cp
= strchr (argv
[i
], '\n');
343 error (_("can't handle command-line argument containing whitespace"));
344 length
+= strlen (argv
[i
]) + 1;
347 result
= (char *) xmalloc (length
);
349 for (i
= 0; i
< argc
; ++i
)
352 strcat (result
, " ");
353 strcat (result
, argv
[i
]);
361 /* This function detects whether or not a '&' character (indicating
362 background execution) has been added as *the last* of the arguments ARGS
363 of a command. If it has, it removes it and returns 1. Otherwise it
364 does nothing and returns 0. */
366 strip_bg_char (char **args
)
370 p
= strchr (*args
, '&');
374 if (p
== (*args
+ strlen (*args
) - 1))
376 if (strlen (*args
) > 1)
380 while (*p
== ' ' || *p
== '\t');
392 tty_command (char *file
, int from_tty
)
395 error_no_arg (_("terminal name for running target process"));
397 set_inferior_io_terminal (file
);
400 /* Kill the inferior if already running. This function is designed
401 to be called when we are about to start the execution of the program
402 from the beginning. Ask the user to confirm that he wants to restart
403 the program being debugged when FROM_TTY is non-null. */
406 kill_if_already_running (int from_tty
)
408 if (! ptid_equal (inferior_ptid
, null_ptid
) && target_has_execution
)
411 && !query ("The program being debugged has been started already.\n\
412 Start it from the beginning? "))
413 error (_("Program not restarted."));
415 #if defined(SOLIB_RESTART)
418 init_wait_for_inferior ();
422 /* Implement the "run" command. If TBREAK_AT_MAIN is set, then insert
423 a temporary breakpoint at the begining of the main program before
424 running the program. */
427 run_command_1 (char *args
, int from_tty
, int tbreak_at_main
)
433 kill_if_already_running (from_tty
);
434 clear_breakpoint_hit_counts ();
436 /* Purge old solib objfiles. */
437 objfile_purge_solibs ();
439 do_run_cleanups (NULL
);
441 /* The comment here used to read, "The exec file is re-read every
442 time we do a generic_mourn_inferior, so we just have to worry
443 about the symbol file." The `generic_mourn_inferior' function
444 gets called whenever the program exits. However, suppose the
445 program exits, and *then* the executable file changes? We need
446 to check again here. Since reopen_exec_file doesn't do anything
447 if the timestamp hasn't changed, I don't see the harm. */
451 /* Insert the temporary breakpoint if a location was specified. */
453 tbreak_command (main_name (), 0);
455 exec_file
= (char *) get_exec_file (0);
457 /* We keep symbols from add-symbol-file, on the grounds that the
458 user might want to add some symbols before running the program
459 (right?). But sometimes (dynamic loading where the user manually
460 introduces the new symbols with add-symbol-file), the code which
461 the symbols describe does not persist between runs. Currently
462 the user has to manually nuke all symbols between runs if they
463 want them to go away (PR 2207). This is probably reasonable. */
467 if (target_can_async_p ())
468 async_disable_stdin ();
472 int async_exec
= strip_bg_char (&args
);
474 /* If we get a request for running in the bg but the target
475 doesn't support it, error out. */
476 if (async_exec
&& !target_can_async_p ())
477 error (_("Asynchronous execution not supported on this target."));
479 /* If we don't get a request of running in the bg, then we need
480 to simulate synchronous (fg) execution. */
481 if (!async_exec
&& target_can_async_p ())
483 /* Simulate synchronous execution */
484 async_disable_stdin ();
487 /* If there were other args, beside '&', process them. */
490 char *old_args
= set_inferior_args (xstrdup (args
));
497 ui_out_field_string (uiout
, NULL
, "Starting program");
498 ui_out_text (uiout
, ": ");
500 ui_out_field_string (uiout
, "execfile", exec_file
);
501 ui_out_spaces (uiout
, 1);
502 /* We call get_inferior_args() because we might need to compute
504 ui_out_field_string (uiout
, "infargs", get_inferior_args ());
505 ui_out_text (uiout
, "\n");
506 ui_out_flush (uiout
);
509 /* We call get_inferior_args() because we might need to compute
511 target_create_inferior (exec_file
, get_inferior_args (),
512 environ_vector (inferior_environ
), from_tty
);
517 run_command (char *args
, int from_tty
)
519 run_command_1 (args
, from_tty
, 0);
523 run_no_args_command (char *args
, int from_tty
)
525 char *old_args
= set_inferior_args (xstrdup (""));
530 /* Start the execution of the program up until the beginning of the main
534 start_command (char *args
, int from_tty
)
536 /* Some languages such as Ada need to search inside the program
537 minimal symbols for the location where to put the temporary
538 breakpoint before starting. */
539 if (!have_minimal_symbols ())
540 error (_("No symbol table loaded. Use the \"file\" command."));
542 /* Run the program until reaching the main procedure... */
543 run_command_1 (args
, from_tty
, 1);
547 continue_command (char *proc_count_exp
, int from_tty
)
552 /* Find out whether we must run in the background. */
553 if (proc_count_exp
!= NULL
)
554 async_exec
= strip_bg_char (&proc_count_exp
);
556 /* If we must run in the background, but the target can't do it,
558 if (async_exec
&& !target_can_async_p ())
559 error (_("Asynchronous execution not supported on this target."));
561 /* If we are not asked to run in the bg, then prepare to run in the
562 foreground, synchronously. */
563 if (!async_exec
&& target_can_async_p ())
565 /* Simulate synchronous execution */
566 async_disable_stdin ();
569 /* If have argument (besides '&'), set proceed count of breakpoint
571 if (proc_count_exp
!= NULL
)
573 bpstat bs
= stop_bpstat
;
574 int num
= bpstat_num (&bs
);
575 if (num
== 0 && from_tty
)
578 ("Not stopped at any breakpoint; argument ignored.\n");
582 set_ignore_count (num
,
583 parse_and_eval_long (proc_count_exp
) - 1,
585 /* set_ignore_count prints a message ending with a period.
586 So print two spaces before "Continuing.". */
588 printf_filtered (" ");
589 num
= bpstat_num (&bs
);
594 printf_filtered (_("Continuing.\n"));
596 clear_proceed_status ();
598 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 0);
601 /* Step until outside of current statement. */
604 step_command (char *count_string
, int from_tty
)
606 step_1 (0, 0, count_string
);
609 /* Likewise, but skip over subroutine calls as if single instructions. */
612 next_command (char *count_string
, int from_tty
)
614 step_1 (1, 0, count_string
);
617 /* Likewise, but step only one instruction. */
620 stepi_command (char *count_string
, int from_tty
)
622 step_1 (0, 1, count_string
);
626 nexti_command (char *count_string
, int from_tty
)
628 step_1 (1, 1, count_string
);
632 disable_longjmp_breakpoint_cleanup (void *ignore
)
634 disable_longjmp_breakpoint ();
638 step_1 (int skip_subroutines
, int single_inst
, char *count_string
)
641 struct frame_info
*frame
;
642 struct cleanup
*cleanups
= 0;
648 async_exec
= strip_bg_char (&count_string
);
650 /* If we get a request for running in the bg but the target
651 doesn't support it, error out. */
652 if (async_exec
&& !target_can_async_p ())
653 error (_("Asynchronous execution not supported on this target."));
655 /* If we don't get a request of running in the bg, then we need
656 to simulate synchronous (fg) execution. */
657 if (!async_exec
&& target_can_async_p ())
659 /* Simulate synchronous execution */
660 async_disable_stdin ();
663 count
= count_string
? parse_and_eval_long (count_string
) : 1;
665 if (!single_inst
|| skip_subroutines
) /* leave si command alone */
667 enable_longjmp_breakpoint ();
668 if (!target_can_async_p ())
669 cleanups
= make_cleanup (disable_longjmp_breakpoint_cleanup
, 0 /*ignore*/);
671 make_exec_cleanup (disable_longjmp_breakpoint_cleanup
, 0 /*ignore*/);
674 /* In synchronous case, all is well, just use the regular for loop. */
675 if (!target_can_async_p ())
677 for (; count
> 0; count
--)
679 clear_proceed_status ();
681 frame
= get_current_frame ();
682 if (!frame
) /* Avoid coredump here. Why tho? */
683 error (_("No current frame"));
684 step_frame_id
= get_frame_id (frame
);
688 find_pc_line_pc_range (stop_pc
, &step_range_start
, &step_range_end
);
689 if (step_range_end
== 0)
692 if (find_pc_partial_function (stop_pc
, &name
, &step_range_start
,
693 &step_range_end
) == 0)
694 error (_("Cannot find bounds of current function"));
696 target_terminal_ours ();
697 printf_filtered (_("\
698 Single stepping until exit from function %s, \n\
699 which has no line number information.\n"), name
);
704 /* Say we are stepping, but stop after one insn whatever it does. */
705 step_range_start
= step_range_end
= 1;
706 if (!skip_subroutines
)
708 Don't step over function calls, not even to functions lacking
710 step_over_calls
= STEP_OVER_NONE
;
713 if (skip_subroutines
)
714 step_over_calls
= STEP_OVER_ALL
;
716 step_multi
= (count
> 1);
717 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 1);
723 if (!single_inst
|| skip_subroutines
)
724 do_cleanups (cleanups
);
727 /* In case of asynchronous target things get complicated, do only
728 one step for now, before returning control to the event loop. Let
729 the continuation figure out how many other steps we need to do,
730 and handle them one at the time, through step_once(). */
733 if (target_can_async_p ())
734 step_once (skip_subroutines
, single_inst
, count
);
738 /* Called after we are done with one step operation, to check whether
739 we need to step again, before we print the prompt and return control
740 to the user. If count is > 1, we will need to do one more call to
741 proceed(), via step_once(). Basically it is like step_once and
742 step_1_continuation are co-recursive. */
744 step_1_continuation (struct continuation_arg
*arg
)
747 int skip_subroutines
;
750 skip_subroutines
= arg
->data
.integer
;
751 single_inst
= arg
->next
->data
.integer
;
752 count
= arg
->next
->next
->data
.integer
;
755 step_once (skip_subroutines
, single_inst
, count
- 1);
757 if (!single_inst
|| skip_subroutines
)
758 do_exec_cleanups (ALL_CLEANUPS
);
761 /* Do just one step operation. If count >1 we will have to set up a
762 continuation to be done after the target stops (after this one
763 step). This is useful to implement the 'step n' kind of commands, in
764 case of asynchronous targets. We had to split step_1 into two parts,
765 one to be done before proceed() and one afterwards. This function is
766 called in case of step n with n>1, after the first step operation has
769 step_once (int skip_subroutines
, int single_inst
, int count
)
771 struct continuation_arg
*arg1
;
772 struct continuation_arg
*arg2
;
773 struct continuation_arg
*arg3
;
774 struct frame_info
*frame
;
778 clear_proceed_status ();
780 frame
= get_current_frame ();
781 if (!frame
) /* Avoid coredump here. Why tho? */
782 error (_("No current frame"));
783 step_frame_id
= get_frame_id (frame
);
787 find_pc_line_pc_range (stop_pc
, &step_range_start
, &step_range_end
);
789 /* If we have no line info, switch to stepi mode. */
790 if (step_range_end
== 0 && step_stop_if_no_debug
)
792 step_range_start
= step_range_end
= 1;
794 else if (step_range_end
== 0)
797 if (find_pc_partial_function (stop_pc
, &name
, &step_range_start
,
798 &step_range_end
) == 0)
799 error (_("Cannot find bounds of current function"));
801 target_terminal_ours ();
802 printf_filtered (_("\
803 Single stepping until exit from function %s, \n\
804 which has no line number information.\n"), name
);
809 /* Say we are stepping, but stop after one insn whatever it does. */
810 step_range_start
= step_range_end
= 1;
811 if (!skip_subroutines
)
813 Don't step over function calls, not even to functions lacking
815 step_over_calls
= STEP_OVER_NONE
;
818 if (skip_subroutines
)
819 step_over_calls
= STEP_OVER_ALL
;
821 step_multi
= (count
> 1);
823 (struct continuation_arg
*) xmalloc (sizeof (struct continuation_arg
));
825 (struct continuation_arg
*) xmalloc (sizeof (struct continuation_arg
));
827 (struct continuation_arg
*) xmalloc (sizeof (struct continuation_arg
));
829 arg1
->data
.integer
= skip_subroutines
;
831 arg2
->data
.integer
= single_inst
;
833 arg3
->data
.integer
= count
;
834 add_intermediate_continuation (step_1_continuation
, arg1
);
835 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 1);
840 /* Continue program at specified address. */
843 jump_command (char *arg
, int from_tty
)
846 struct symtabs_and_lines sals
;
847 struct symtab_and_line sal
;
854 /* Find out whether we must run in the background. */
856 async_exec
= strip_bg_char (&arg
);
858 /* If we must run in the background, but the target can't do it,
860 if (async_exec
&& !target_can_async_p ())
861 error (_("Asynchronous execution not supported on this target."));
863 /* If we are not asked to run in the bg, then prepare to run in the
864 foreground, synchronously. */
865 if (!async_exec
&& target_can_async_p ())
867 /* Simulate synchronous execution */
868 async_disable_stdin ();
872 error_no_arg (_("starting address"));
874 sals
= decode_line_spec_1 (arg
, 1);
877 error (_("Unreasonable jump request"));
883 if (sal
.symtab
== 0 && sal
.pc
== 0)
884 error (_("No source file has been specified."));
886 resolve_sal_pc (&sal
); /* May error out */
888 /* See if we are trying to jump to another function. */
889 fn
= get_frame_function (get_current_frame ());
890 sfn
= find_pc_function (sal
.pc
);
891 if (fn
!= NULL
&& sfn
!= fn
)
893 if (!query ("Line %d is not in `%s'. Jump anyway? ", sal
.line
,
894 SYMBOL_PRINT_NAME (fn
)))
896 error (_("Not confirmed."));
903 fixup_symbol_section (sfn
, 0);
904 if (section_is_overlay (SYMBOL_BFD_SECTION (sfn
)) &&
905 !section_is_mapped (SYMBOL_BFD_SECTION (sfn
)))
907 if (!query ("WARNING!!! Destination is in unmapped overlay! Jump anyway? "))
909 error (_("Not confirmed."));
919 printf_filtered (_("Continuing at "));
920 deprecated_print_address_numeric (addr
, 1, gdb_stdout
);
921 printf_filtered (".\n");
924 clear_proceed_status ();
925 proceed (addr
, TARGET_SIGNAL_0
, 0);
929 /* Go to line or address in current procedure */
931 go_command (char *line_no
, int from_tty
)
933 if (line_no
== (char *) NULL
|| !*line_no
)
934 printf_filtered (GO_USAGE
);
937 tbreak_command (line_no
, from_tty
);
938 jump_command (line_no
, from_tty
);
943 /* Continue program giving it specified signal. */
946 signal_command (char *signum_exp
, int from_tty
)
948 enum target_signal oursig
;
950 dont_repeat (); /* Too dangerous. */
954 error_no_arg (_("signal number"));
956 /* It would be even slicker to make signal names be valid expressions,
957 (the type could be "enum $signal" or some such), then the user could
958 assign them to convenience variables. */
959 oursig
= target_signal_from_name (signum_exp
);
961 if (oursig
== TARGET_SIGNAL_UNKNOWN
)
963 /* No, try numeric. */
964 int num
= parse_and_eval_long (signum_exp
);
967 oursig
= TARGET_SIGNAL_0
;
969 oursig
= target_signal_from_command (num
);
974 if (oursig
== TARGET_SIGNAL_0
)
975 printf_filtered (_("Continuing with no signal.\n"));
977 printf_filtered (_("Continuing with signal %s.\n"),
978 target_signal_to_name (oursig
));
981 clear_proceed_status ();
982 /* "signal 0" should not get stuck if we are stopped at a breakpoint.
983 FIXME: Neither should "signal foo" but when I tried passing
984 (CORE_ADDR)-1 unconditionally I got a testsuite failure which I haven't
985 tried to track down yet. */
986 proceed (oursig
== TARGET_SIGNAL_0
? (CORE_ADDR
) -1 : stop_pc
, oursig
, 0);
989 /* Proceed until we reach a different source line with pc greater than
990 our current one or exit the function. We skip calls in both cases.
992 Note that eventually this command should probably be changed so
993 that only source lines are printed out when we hit the breakpoint
994 we set. This may involve changes to wait_for_inferior and the
995 proceed status code. */
998 until_next_command (int from_tty
)
1000 struct frame_info
*frame
;
1002 struct symbol
*func
;
1003 struct symtab_and_line sal
;
1005 clear_proceed_status ();
1007 frame
= get_current_frame ();
1009 /* Step until either exited from this function or greater
1010 than the current line (if in symbolic section) or pc (if
1014 func
= find_pc_function (pc
);
1018 struct minimal_symbol
*msymbol
= lookup_minimal_symbol_by_pc (pc
);
1020 if (msymbol
== NULL
)
1021 error (_("Execution is not within a known function."));
1023 step_range_start
= SYMBOL_VALUE_ADDRESS (msymbol
);
1024 step_range_end
= pc
;
1028 sal
= find_pc_line (pc
, 0);
1030 step_range_start
= BLOCK_START (SYMBOL_BLOCK_VALUE (func
));
1031 step_range_end
= sal
.end
;
1034 step_over_calls
= STEP_OVER_ALL
;
1035 step_frame_id
= get_frame_id (frame
);
1037 step_multi
= 0; /* Only one call to proceed */
1039 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 1);
1043 until_command (char *arg
, int from_tty
)
1047 if (!target_has_execution
)
1048 error (_("The program is not running."));
1050 /* Find out whether we must run in the background. */
1052 async_exec
= strip_bg_char (&arg
);
1054 /* If we must run in the background, but the target can't do it,
1056 if (async_exec
&& !target_can_async_p ())
1057 error (_("Asynchronous execution not supported on this target."));
1059 /* If we are not asked to run in the bg, then prepare to run in the
1060 foreground, synchronously. */
1061 if (!async_exec
&& target_can_async_p ())
1063 /* Simulate synchronous execution */
1064 async_disable_stdin ();
1068 until_break_command (arg
, from_tty
, 0);
1070 until_next_command (from_tty
);
1074 advance_command (char *arg
, int from_tty
)
1078 if (!target_has_execution
)
1079 error (_("The program is not running."));
1082 error_no_arg (_("a location"));
1084 /* Find out whether we must run in the background. */
1086 async_exec
= strip_bg_char (&arg
);
1088 /* If we must run in the background, but the target can't do it,
1090 if (async_exec
&& !target_can_async_p ())
1091 error (_("Asynchronous execution not supported on this target."));
1093 /* If we are not asked to run in the bg, then prepare to run in the
1094 foreground, synchronously. */
1095 if (!async_exec
&& target_can_async_p ())
1097 /* Simulate synchronous execution. */
1098 async_disable_stdin ();
1101 until_break_command (arg
, from_tty
, 1);
1104 /* Print the result of a function at the end of a 'finish' command. */
1107 print_return_value (int struct_return
, struct type
*value_type
)
1109 struct gdbarch
*gdbarch
= current_gdbarch
;
1110 struct cleanup
*old_chain
;
1111 struct ui_stream
*stb
;
1112 struct value
*value
;
1114 gdb_assert (TYPE_CODE (value_type
) != TYPE_CODE_VOID
);
1116 /* FIXME: 2003-09-27: When returning from a nested inferior function
1117 call, it's possible (with no help from the architecture vector)
1118 to locate and return/print a "struct return" value. This is just
1119 a more complicated case of what is already being done in in the
1120 inferior function call code. In fact, when inferior function
1121 calls are made async, this will likely be made the norm. */
1123 switch (gdbarch_return_value (gdbarch
, value_type
, NULL
, NULL
, NULL
))
1125 case RETURN_VALUE_REGISTER_CONVENTION
:
1126 case RETURN_VALUE_ABI_RETURNS_ADDRESS
:
1127 value
= allocate_value (value_type
);
1128 CHECK_TYPEDEF (value_type
);
1129 gdbarch_return_value (current_gdbarch
, value_type
, stop_registers
,
1130 value_contents_raw (value
), NULL
);
1132 case RETURN_VALUE_STRUCT_CONVENTION
:
1136 internal_error (__FILE__
, __LINE__
, _("bad switch"));
1142 stb
= ui_out_stream_new (uiout
);
1143 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
1144 ui_out_text (uiout
, "Value returned is ");
1145 ui_out_field_fmt (uiout
, "gdb-result-var", "$%d",
1146 record_latest_value (value
));
1147 ui_out_text (uiout
, " = ");
1148 value_print (value
, stb
->stream
, 0, Val_no_prettyprint
);
1149 ui_out_field_stream (uiout
, "return-value", stb
);
1150 ui_out_text (uiout
, "\n");
1151 do_cleanups (old_chain
);
1155 ui_out_text (uiout
, "Value returned has type: ");
1156 ui_out_field_string (uiout
, "return-type", TYPE_NAME (value_type
));
1157 ui_out_text (uiout
, ".");
1158 ui_out_text (uiout
, " Cannot determine contents\n");
1162 /* Stuff that needs to be done by the finish command after the target
1163 has stopped. In asynchronous mode, we wait for the target to stop
1164 in the call to poll or select in the event loop, so it is
1165 impossible to do all the stuff as part of the finish_command
1166 function itself. The only chance we have to complete this command
1167 is in fetch_inferior_event, which is called by the event loop as
1168 soon as it detects that the target has stopped. This function is
1169 called via the cmd_continuation pointer. */
1172 finish_command_continuation (struct continuation_arg
*arg
)
1174 struct symbol
*function
;
1175 struct breakpoint
*breakpoint
;
1176 struct cleanup
*cleanups
;
1178 breakpoint
= (struct breakpoint
*) arg
->data
.pointer
;
1179 function
= (struct symbol
*) arg
->next
->data
.pointer
;
1180 cleanups
= (struct cleanup
*) arg
->next
->next
->data
.pointer
;
1182 if (bpstat_find_breakpoint (stop_bpstat
, breakpoint
) != NULL
1183 && function
!= NULL
)
1185 struct type
*value_type
;
1189 value_type
= TYPE_TARGET_TYPE (SYMBOL_TYPE (function
));
1191 internal_error (__FILE__
, __LINE__
,
1192 _("finish_command: function has no target type"));
1194 if (TYPE_CODE (value_type
) == TYPE_CODE_VOID
)
1196 do_exec_cleanups (cleanups
);
1200 CHECK_TYPEDEF (value_type
);
1201 gcc_compiled
= BLOCK_GCC_COMPILED (SYMBOL_BLOCK_VALUE (function
));
1202 struct_return
= using_struct_return (value_type
, gcc_compiled
);
1204 print_return_value (struct_return
, value_type
);
1207 do_exec_cleanups (cleanups
);
1210 /* "finish": Set a temporary breakpoint at the place the selected
1211 frame will return to, then continue. */
1214 finish_command (char *arg
, int from_tty
)
1216 struct symtab_and_line sal
;
1217 struct frame_info
*frame
;
1218 struct symbol
*function
;
1219 struct breakpoint
*breakpoint
;
1220 struct cleanup
*old_chain
;
1221 struct continuation_arg
*arg1
, *arg2
, *arg3
;
1225 /* Find out whether we must run in the background. */
1227 async_exec
= strip_bg_char (&arg
);
1229 /* If we must run in the background, but the target can't do it,
1231 if (async_exec
&& !target_can_async_p ())
1232 error (_("Asynchronous execution not supported on this target."));
1234 /* If we are not asked to run in the bg, then prepare to run in the
1235 foreground, synchronously. */
1236 if (!async_exec
&& target_can_async_p ())
1238 /* Simulate synchronous execution. */
1239 async_disable_stdin ();
1243 error (_("The \"finish\" command does not take any arguments."));
1244 if (!target_has_execution
)
1245 error (_("The program is not running."));
1246 if (deprecated_selected_frame
== NULL
)
1247 error (_("No selected frame."));
1249 frame
= get_prev_frame (deprecated_selected_frame
);
1251 error (_("\"finish\" not meaningful in the outermost frame."));
1253 clear_proceed_status ();
1255 sal
= find_pc_line (get_frame_pc (frame
), 0);
1256 sal
.pc
= get_frame_pc (frame
);
1258 breakpoint
= set_momentary_breakpoint (sal
, get_frame_id (frame
), bp_finish
);
1260 if (!target_can_async_p ())
1261 old_chain
= make_cleanup_delete_breakpoint (breakpoint
);
1263 old_chain
= make_exec_cleanup_delete_breakpoint (breakpoint
);
1265 /* Find the function we will return from. */
1267 function
= find_pc_function (get_frame_pc (deprecated_selected_frame
));
1269 /* Print info on the selected frame, including level number but not
1273 printf_filtered (_("Run till exit from "));
1274 print_stack_frame (get_selected_frame (NULL
), 1, LOCATION
);
1277 /* If running asynchronously and the target support asynchronous
1278 execution, set things up for the rest of the finish command to be
1279 completed later on, when gdb has detected that the target has
1280 stopped, in fetch_inferior_event. */
1281 if (target_can_async_p ())
1284 (struct continuation_arg
*) xmalloc (sizeof (struct continuation_arg
));
1286 (struct continuation_arg
*) xmalloc (sizeof (struct continuation_arg
));
1288 (struct continuation_arg
*) xmalloc (sizeof (struct continuation_arg
));
1292 arg1
->data
.pointer
= breakpoint
;
1293 arg2
->data
.pointer
= function
;
1294 arg3
->data
.pointer
= old_chain
;
1295 add_continuation (finish_command_continuation
, arg1
);
1298 proceed_to_finish
= 1; /* We want stop_registers, please... */
1299 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 0);
1301 /* Do this only if not running asynchronously or if the target
1302 cannot do async execution. Otherwise, complete this command when
1303 the target actually stops, in fetch_inferior_event. */
1304 if (!target_can_async_p ())
1306 /* Did we stop at our breakpoint? */
1307 if (bpstat_find_breakpoint (stop_bpstat
, breakpoint
) != NULL
1308 && function
!= NULL
)
1310 struct type
*value_type
;
1314 value_type
= TYPE_TARGET_TYPE (SYMBOL_TYPE (function
));
1316 internal_error (__FILE__
, __LINE__
,
1317 _("finish_command: function has no target type"));
1319 /* FIXME: Shouldn't we do the cleanups before returning? */
1320 if (TYPE_CODE (value_type
) == TYPE_CODE_VOID
)
1323 CHECK_TYPEDEF (value_type
);
1324 gcc_compiled
= BLOCK_GCC_COMPILED (SYMBOL_BLOCK_VALUE (function
));
1325 struct_return
= using_struct_return (value_type
, gcc_compiled
);
1327 print_return_value (struct_return
, value_type
);
1330 do_cleanups (old_chain
);
1336 program_info (char *args
, int from_tty
)
1338 bpstat bs
= stop_bpstat
;
1339 int num
= bpstat_num (&bs
);
1341 if (!target_has_execution
)
1343 printf_filtered (_("The program being debugged is not being run.\n"));
1347 target_files_info ();
1348 printf_filtered (_("Program stopped at %s.\n"),
1349 hex_string ((unsigned long) stop_pc
));
1351 printf_filtered (_("It stopped after being stepped.\n"));
1354 /* There may be several breakpoints in the same place, so this
1355 isn't as strange as it seems. */
1360 printf_filtered (_("\
1361 It stopped at a breakpoint that has since been deleted.\n"));
1364 printf_filtered (_("It stopped at breakpoint %d.\n"), num
);
1365 num
= bpstat_num (&bs
);
1368 else if (stop_signal
!= TARGET_SIGNAL_0
)
1370 printf_filtered (_("It stopped with signal %s, %s.\n"),
1371 target_signal_to_name (stop_signal
),
1372 target_signal_to_string (stop_signal
));
1377 printf_filtered (_("\
1378 Type \"info stack\" or \"info registers\" for more information.\n"));
1383 environment_info (char *var
, int from_tty
)
1387 char *val
= get_in_environ (inferior_environ
, var
);
1390 puts_filtered (var
);
1391 puts_filtered (" = ");
1392 puts_filtered (val
);
1393 puts_filtered ("\n");
1397 puts_filtered ("Environment variable \"");
1398 puts_filtered (var
);
1399 puts_filtered ("\" not defined.\n");
1404 char **vector
= environ_vector (inferior_environ
);
1407 puts_filtered (*vector
++);
1408 puts_filtered ("\n");
1414 set_environment_command (char *arg
, int from_tty
)
1416 char *p
, *val
, *var
;
1420 error_no_arg (_("environment variable and value"));
1422 /* Find seperation between variable name and value */
1423 p
= (char *) strchr (arg
, '=');
1424 val
= (char *) strchr (arg
, ' ');
1426 if (p
!= 0 && val
!= 0)
1428 /* We have both a space and an equals. If the space is before the
1429 equals, walk forward over the spaces til we see a nonspace
1430 (possibly the equals). */
1435 /* Now if the = is after the char following the spaces,
1436 take the char following the spaces. */
1440 else if (val
!= 0 && p
== 0)
1444 error_no_arg (_("environment variable to set"));
1446 if (p
== 0 || p
[1] == 0)
1450 p
= arg
+ strlen (arg
); /* So that savestring below will work */
1454 /* Not setting variable value to null */
1456 while (*val
== ' ' || *val
== '\t')
1460 while (p
!= arg
&& (p
[-1] == ' ' || p
[-1] == '\t'))
1463 var
= savestring (arg
, p
- arg
);
1466 printf_filtered (_("\
1467 Setting environment variable \"%s\" to null value.\n"),
1469 set_in_environ (inferior_environ
, var
, "");
1472 set_in_environ (inferior_environ
, var
, val
);
1477 unset_environment_command (char *var
, int from_tty
)
1481 /* If there is no argument, delete all environment variables.
1482 Ask for confirmation if reading from the terminal. */
1483 if (!from_tty
|| query (_("Delete all environment variables? ")))
1485 free_environ (inferior_environ
);
1486 inferior_environ
= make_environ ();
1490 unset_in_environ (inferior_environ
, var
);
1493 /* Handle the execution path (PATH variable) */
1495 static const char path_var_name
[] = "PATH";
1498 path_info (char *args
, int from_tty
)
1500 puts_filtered ("Executable and object file path: ");
1501 puts_filtered (get_in_environ (inferior_environ
, path_var_name
));
1502 puts_filtered ("\n");
1505 /* Add zero or more directories to the front of the execution path. */
1508 path_command (char *dirname
, int from_tty
)
1513 env
= get_in_environ (inferior_environ
, path_var_name
);
1514 /* Can be null if path is not set */
1517 exec_path
= xstrdup (env
);
1518 mod_path (dirname
, &exec_path
);
1519 set_in_environ (inferior_environ
, path_var_name
, exec_path
);
1522 path_info ((char *) NULL
, from_tty
);
1526 /* Print out the machine register regnum. If regnum is -1, print all
1527 registers (print_all == 1) or all non-float and non-vector
1528 registers (print_all == 0).
1530 For most machines, having all_registers_info() print the
1531 register(s) one per line is good enough. If a different format is
1532 required, (eg, for MIPS or Pyramid 90x, which both have lots of
1533 regs), or there is an existing convention for showing all the
1534 registers, define the architecture method PRINT_REGISTERS_INFO to
1535 provide that format. */
1538 default_print_registers_info (struct gdbarch
*gdbarch
,
1539 struct ui_file
*file
,
1540 struct frame_info
*frame
,
1541 int regnum
, int print_all
)
1544 const int numregs
= NUM_REGS
+ NUM_PSEUDO_REGS
;
1545 gdb_byte buffer
[MAX_REGISTER_SIZE
];
1547 for (i
= 0; i
< numregs
; i
++)
1549 /* Decide between printing all regs, non-float / vector regs, or
1555 if (!gdbarch_register_reggroup_p (gdbarch
, i
, all_reggroup
))
1560 if (!gdbarch_register_reggroup_p (gdbarch
, i
, general_reggroup
))
1570 /* If the register name is empty, it is undefined for this
1571 processor, so don't display anything. */
1572 if (REGISTER_NAME (i
) == NULL
|| *(REGISTER_NAME (i
)) == '\0')
1575 fputs_filtered (REGISTER_NAME (i
), file
);
1576 print_spaces_filtered (15 - strlen (REGISTER_NAME (i
)), file
);
1578 /* Get the data in raw format. */
1579 if (! frame_register_read (frame
, i
, buffer
))
1581 fprintf_filtered (file
, "*value not available*\n");
1585 /* If virtual format is floating, print it that way, and in raw
1587 if (TYPE_CODE (register_type (current_gdbarch
, i
)) == TYPE_CODE_FLT
)
1591 val_print (register_type (current_gdbarch
, i
), buffer
, 0, 0,
1592 file
, 0, 1, 0, Val_pretty_default
);
1594 fprintf_filtered (file
, "\t(raw 0x");
1595 for (j
= 0; j
< register_size (current_gdbarch
, i
); j
++)
1598 if (TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
)
1601 idx
= register_size (current_gdbarch
, i
) - 1 - j
;
1602 fprintf_filtered (file
, "%02x", (unsigned char) buffer
[idx
]);
1604 fprintf_filtered (file
, ")");
1608 /* Print the register in hex. */
1609 val_print (register_type (current_gdbarch
, i
), buffer
, 0, 0,
1610 file
, 'x', 1, 0, Val_pretty_default
);
1611 /* If not a vector register, print it also according to its
1613 if (TYPE_VECTOR (register_type (current_gdbarch
, i
)) == 0)
1615 fprintf_filtered (file
, "\t");
1616 val_print (register_type (current_gdbarch
, i
), buffer
, 0, 0,
1617 file
, 0, 1, 0, Val_pretty_default
);
1621 fprintf_filtered (file
, "\n");
1626 registers_info (char *addr_exp
, int fpregs
)
1628 int regnum
, numregs
;
1631 if (!target_has_registers
)
1632 error (_("The program has no registers now."));
1633 if (deprecated_selected_frame
== NULL
)
1634 error (_("No selected frame."));
1638 gdbarch_print_registers_info (current_gdbarch
, gdb_stdout
,
1639 deprecated_selected_frame
, -1, fpregs
);
1643 while (*addr_exp
!= '\0')
1648 /* Keep skipping leading white space. */
1649 if (isspace ((*addr_exp
)))
1655 /* Discard any leading ``$''. Check that there is something
1656 resembling a register following it. */
1657 if (addr_exp
[0] == '$')
1659 if (isspace ((*addr_exp
)) || (*addr_exp
) == '\0')
1660 error (_("Missing register name"));
1662 /* Find the start/end of this register name/num/group. */
1664 while ((*addr_exp
) != '\0' && !isspace ((*addr_exp
)))
1668 /* Figure out what we've found and display it. */
1670 /* A register name? */
1672 int regnum
= frame_map_name_to_regnum (deprecated_selected_frame
,
1673 start
, end
- start
);
1676 gdbarch_print_registers_info (current_gdbarch
, gdb_stdout
,
1677 deprecated_selected_frame
, regnum
, fpregs
);
1682 /* A register number? (how portable is this one?). */
1685 int regnum
= strtol (start
, &endptr
, 0);
1688 && regnum
< NUM_REGS
+ NUM_PSEUDO_REGS
)
1690 gdbarch_print_registers_info (current_gdbarch
, gdb_stdout
,
1691 deprecated_selected_frame
, regnum
, fpregs
);
1696 /* A register group? */
1698 struct reggroup
*group
;
1699 for (group
= reggroup_next (current_gdbarch
, NULL
);
1701 group
= reggroup_next (current_gdbarch
, group
))
1703 /* Don't bother with a length check. Should the user
1704 enter a short register group name, go with the first
1705 group that matches. */
1706 if (strncmp (start
, reggroup_name (group
), end
- start
) == 0)
1712 for (regnum
= 0; regnum
< NUM_REGS
+ NUM_PSEUDO_REGS
; regnum
++)
1714 if (gdbarch_register_reggroup_p (current_gdbarch
, regnum
,
1716 gdbarch_print_registers_info (current_gdbarch
,
1717 gdb_stdout
, deprecated_selected_frame
,
1724 /* Nothing matched. */
1725 error (_("Invalid register `%.*s'"), (int) (end
- start
), start
);
1730 all_registers_info (char *addr_exp
, int from_tty
)
1732 registers_info (addr_exp
, 1);
1736 nofp_registers_info (char *addr_exp
, int from_tty
)
1738 registers_info (addr_exp
, 0);
1742 print_vector_info (struct gdbarch
*gdbarch
, struct ui_file
*file
,
1743 struct frame_info
*frame
, const char *args
)
1745 if (!target_has_registers
)
1746 error (_("The program has no registers now."));
1747 if (deprecated_selected_frame
== NULL
)
1748 error (_("No selected frame."));
1750 if (gdbarch_print_vector_info_p (gdbarch
))
1751 gdbarch_print_vector_info (gdbarch
, file
, frame
, args
);
1755 int printed_something
= 0;
1757 for (regnum
= 0; regnum
< NUM_REGS
+ NUM_PSEUDO_REGS
; regnum
++)
1759 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, vector_reggroup
))
1761 printed_something
= 1;
1762 gdbarch_print_registers_info (gdbarch
, file
, frame
, regnum
, 1);
1765 if (!printed_something
)
1766 fprintf_filtered (file
, "No vector information\n");
1771 vector_info (char *args
, int from_tty
)
1773 print_vector_info (current_gdbarch
, gdb_stdout
, deprecated_selected_frame
, args
);
1779 * Should save/restore the tty state since it might be that the
1780 * program to be debugged was started on this tty and it wants
1781 * the tty in some state other than what we want. If it's running
1782 * on another terminal or without a terminal, then saving and
1783 * restoring the tty state is a harmless no-op.
1784 * This only needs to be done if we are attaching to a process.
1789 takes a program started up outside of gdb and ``attaches'' to it.
1790 This stops it cold in its tracks and allows us to start debugging it.
1791 and wait for the trace-trap that results from attaching. */
1794 attach_command (char *args
, int from_tty
)
1797 char *full_exec_path
= NULL
;
1799 dont_repeat (); /* Not for the faint of heart */
1801 if (target_has_execution
)
1803 if (query ("A program is being debugged already. Kill it? "))
1806 error (_("Not killed."));
1809 /* Clear out solib state. Otherwise the solib state of the previous
1810 inferior might have survived and is entirely wrong for the new
1811 target. This has been observed on Linux using glibc 2.3. How to
1823 Cannot access memory at address 0xdeadbeef
1831 target_attach (args
, from_tty
);
1833 /* Set up the "saved terminal modes" of the inferior
1834 based on what modes we are starting it with. */
1835 target_terminal_init ();
1837 /* Set up execution context to know that we should return from
1838 wait_for_inferior as soon as the target reports a stop. */
1839 init_wait_for_inferior ();
1840 clear_proceed_status ();
1842 /* No traps are generated when attaching to inferior under Mach 3
1844 #ifndef ATTACH_NO_WAIT
1845 /* Careful here. See comments in inferior.h. Basically some OSes
1846 don't ignore SIGSTOPs on continue requests anymore. We need a
1847 way for handle_inferior_event to reset the stop_signal variable
1848 after an attach, and this is what STOP_QUIETLY_NO_SIGSTOP is for. */
1849 stop_soon
= STOP_QUIETLY_NO_SIGSTOP
;
1850 wait_for_inferior ();
1851 stop_soon
= NO_STOP_QUIETLY
;
1855 * If no exec file is yet known, try to determine it from the
1858 exec_file
= (char *) get_exec_file (0);
1861 exec_file
= target_pid_to_exec_file (PIDGET (inferior_ptid
));
1864 /* It's possible we don't have a full path, but rather just a
1865 filename. Some targets, such as HP-UX, don't provide the
1868 Attempt to qualify the filename against the source path.
1869 (If that fails, we'll just fall back on the original
1870 filename. Not much more we can do...)
1872 if (!source_full_path_of (exec_file
, &full_exec_path
))
1873 full_exec_path
= savestring (exec_file
, strlen (exec_file
));
1875 exec_file_attach (full_exec_path
, from_tty
);
1876 symbol_file_add_main (full_exec_path
, from_tty
);
1881 reopen_exec_file ();
1886 /* Add shared library symbols from the newly attached process, if any. */
1887 SOLIB_ADD ((char *) 0, from_tty
, ¤t_target
, auto_solib_add
);
1889 solib_add (NULL
, from_tty
, ¤t_target
, auto_solib_add
);
1891 re_enable_breakpoints_in_shlibs ();
1893 /* Take any necessary post-attaching actions for this platform.
1895 target_post_attach (PIDGET (inferior_ptid
));
1897 /* Install inferior's terminal modes. */
1898 target_terminal_inferior ();
1902 if (deprecated_attach_hook
)
1903 deprecated_attach_hook ();
1908 * takes a program previously attached to and detaches it.
1909 * The program resumes execution and will no longer stop
1910 * on signals, etc. We better not have left any breakpoints
1911 * in the program or it'll die when it hits one. For this
1912 * to work, it may be necessary for the process to have been
1913 * previously attached. It *might* work if the program was
1914 * started via the normal ptrace (PTRACE_TRACEME).
1918 detach_command (char *args
, int from_tty
)
1920 dont_repeat (); /* Not for the faint of heart. */
1921 target_detach (args
, from_tty
);
1922 #if defined(SOLIB_RESTART)
1925 if (deprecated_detach_hook
)
1926 deprecated_detach_hook ();
1929 /* Disconnect from the current target without resuming it (leaving it
1930 waiting for a debugger).
1932 We'd better not have left any breakpoints in the program or the
1933 next debugger will get confused. Currently only supported for some
1934 remote targets, since the normal attach mechanisms don't work on
1935 stopped processes on some native platforms (e.g. GNU/Linux). */
1938 disconnect_command (char *args
, int from_tty
)
1940 dont_repeat (); /* Not for the faint of heart */
1941 target_disconnect (args
, from_tty
);
1942 #if defined(SOLIB_RESTART)
1945 if (deprecated_detach_hook
)
1946 deprecated_detach_hook ();
1949 /* Stop the execution of the target while running in async mode, in
1952 interrupt_target_command (char *args
, int from_tty
)
1954 if (target_can_async_p ())
1956 dont_repeat (); /* Not for the faint of heart */
1962 print_float_info (struct gdbarch
*gdbarch
, struct ui_file
*file
,
1963 struct frame_info
*frame
, const char *args
)
1965 if (!target_has_registers
)
1966 error (_("The program has no registers now."));
1967 if (deprecated_selected_frame
== NULL
)
1968 error (_("No selected frame."));
1970 if (gdbarch_print_float_info_p (gdbarch
))
1971 gdbarch_print_float_info (gdbarch
, file
, frame
, args
);
1975 int printed_something
= 0;
1977 for (regnum
= 0; regnum
< NUM_REGS
+ NUM_PSEUDO_REGS
; regnum
++)
1979 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, float_reggroup
))
1981 printed_something
= 1;
1982 gdbarch_print_registers_info (gdbarch
, file
, frame
, regnum
, 1);
1985 if (!printed_something
)
1986 fprintf_filtered (file
, "\
1987 No floating-point info available for this processor.\n");
1992 float_info (char *args
, int from_tty
)
1994 print_float_info (current_gdbarch
, gdb_stdout
,
1995 deprecated_selected_frame
, args
);
1999 unset_command (char *args
, int from_tty
)
2001 printf_filtered (_("\
2002 \"unset\" must be followed by the name of an unset subcommand.\n"));
2003 help_list (unsetlist
, "unset ", -1, gdb_stdout
);
2007 _initialize_infcmd (void)
2009 struct cmd_list_element
*c
= NULL
;
2011 /* add the filename of the terminal connected to inferior I/O */
2012 add_setshow_filename_cmd ("inferior-tty", class_run
,
2013 &inferior_io_terminal
, _("\
2014 Set terminal for future runs of program being debugged."), _("\
2015 Show terminal for future runs of program being debugged."), _("\
2016 Usage: set inferior-tty /dev/pts/1"), NULL
, NULL
, &setlist
, &showlist
);
2017 add_com_alias ("tty", "set inferior-tty", class_alias
, 0);
2019 add_setshow_optional_filename_cmd ("args", class_run
,
2020 &inferior_args
, _("\
2021 Set argument list to give program being debugged when it is started."), _("\
2022 Show argument list to give program being debugged when it is started."), _("\
2023 Follow this command with any number of args, to be passed to the program."),
2026 &setlist
, &showlist
);
2028 c
= add_cmd ("environment", no_class
, environment_info
, _("\
2029 The environment to give the program, or one variable's value.\n\
2030 With an argument VAR, prints the value of environment variable VAR to\n\
2031 give the program being debugged. With no arguments, prints the entire\n\
2032 environment to be given to the program."), &showlist
);
2033 set_cmd_completer (c
, noop_completer
);
2035 add_prefix_cmd ("unset", no_class
, unset_command
,
2036 _("Complement to certain \"set\" commands."),
2037 &unsetlist
, "unset ", 0, &cmdlist
);
2039 c
= add_cmd ("environment", class_run
, unset_environment_command
, _("\
2040 Cancel environment variable VAR for the program.\n\
2041 This does not affect the program until the next \"run\" command."),
2043 set_cmd_completer (c
, noop_completer
);
2045 c
= add_cmd ("environment", class_run
, set_environment_command
, _("\
2046 Set environment variable value to give the program.\n\
2047 Arguments are VAR VALUE where VAR is variable name and VALUE is value.\n\
2048 VALUES of environment variables are uninterpreted strings.\n\
2049 This does not affect the program until the next \"run\" command."),
2051 set_cmd_completer (c
, noop_completer
);
2053 c
= add_com ("path", class_files
, path_command
, _("\
2054 Add directory DIR(s) to beginning of search path for object files.\n\
2055 $cwd in the path means the current working directory.\n\
2056 This path is equivalent to the $PATH shell variable. It is a list of\n\
2057 directories, separated by colons. These directories are searched to find\n\
2058 fully linked executable files and separately compiled object files as needed."));
2059 set_cmd_completer (c
, filename_completer
);
2061 c
= add_cmd ("paths", no_class
, path_info
, _("\
2062 Current search path for finding object files.\n\
2063 $cwd in the path means the current working directory.\n\
2064 This path is equivalent to the $PATH shell variable. It is a list of\n\
2065 directories, separated by colons. These directories are searched to find\n\
2066 fully linked executable files and separately compiled object files as needed."),
2068 set_cmd_completer (c
, noop_completer
);
2070 add_com ("attach", class_run
, attach_command
, _("\
2071 Attach to a process or file outside of GDB.\n\
2072 This command attaches to another target, of the same type as your last\n\
2073 \"target\" command (\"info files\" will show your target stack).\n\
2074 The command may take as argument a process id or a device file.\n\
2075 For a process id, you must have permission to send the process a signal,\n\
2076 and it must have the same effective uid as the debugger.\n\
2077 When using \"attach\" with a process id, the debugger finds the\n\
2078 program running in the process, looking first in the current working\n\
2079 directory, or (if not found there) using the source file search path\n\
2080 (see the \"directory\" command). You can also use the \"file\" command\n\
2081 to specify the program, and to load its symbol table."));
2083 add_com ("detach", class_run
, detach_command
, _("\
2084 Detach a process or file previously attached.\n\
2085 If a process, it is no longer traced, and it continues its execution. If\n\
2086 you were debugging a file, the file is closed and gdb no longer accesses it."));
2088 add_com ("disconnect", class_run
, disconnect_command
, _("\
2089 Disconnect from a target.\n\
2090 The target will wait for another debugger to connect. Not available for\n\
2093 add_com ("signal", class_run
, signal_command
, _("\
2094 Continue program giving it signal specified by the argument.\n\
2095 An argument of \"0\" means continue program without giving it a signal."));
2097 add_com ("stepi", class_run
, stepi_command
, _("\
2098 Step one instruction exactly.\n\
2099 Argument N means do this N times (or till program stops for another reason)."));
2100 add_com_alias ("si", "stepi", class_alias
, 0);
2102 add_com ("nexti", class_run
, nexti_command
, _("\
2103 Step one instruction, but proceed through subroutine calls.\n\
2104 Argument N means do this N times (or till program stops for another reason)."));
2105 add_com_alias ("ni", "nexti", class_alias
, 0);
2107 add_com ("finish", class_run
, finish_command
, _("\
2108 Execute until selected stack frame returns.\n\
2109 Upon return, the value returned is printed and put in the value history."));
2111 add_com ("next", class_run
, next_command
, _("\
2112 Step program, proceeding through subroutine calls.\n\
2113 Like the \"step\" command as long as subroutine calls do not happen;\n\
2114 when they do, the call is treated as one instruction.\n\
2115 Argument N means do this N times (or till program stops for another reason)."));
2116 add_com_alias ("n", "next", class_run
, 1);
2118 add_com_alias ("S", "next", class_run
, 1);
2120 add_com ("step", class_run
, step_command
, _("\
2121 Step program until it reaches a different source line.\n\
2122 Argument N means do this N times (or till program stops for another reason)."));
2123 add_com_alias ("s", "step", class_run
, 1);
2125 c
= add_com ("until", class_run
, until_command
, _("\
2126 Execute until the program reaches a source line greater than the current\n\
2127 or a specified location (same args as break command) within the current frame."));
2128 set_cmd_completer (c
, location_completer
);
2129 add_com_alias ("u", "until", class_run
, 1);
2131 c
= add_com ("advance", class_run
, advance_command
, _("\
2132 Continue the program up to the given location (same form as args for break command).\n\
2133 Execution will also stop upon exit from the current stack frame."));
2134 set_cmd_completer (c
, location_completer
);
2136 c
= add_com ("jump", class_run
, jump_command
, _("\
2137 Continue program being debugged at specified line or address.\n\
2138 Give as argument either LINENUM or *ADDR, where ADDR is an expression\n\
2139 for an address to start at."));
2140 set_cmd_completer (c
, location_completer
);
2144 c
= add_com ("go", class_run
, go_command
, _("\
2145 Usage: go <location>\n\
2146 Continue program being debugged, stopping at specified line or \n\
2148 Give as argument either LINENUM or *ADDR, where ADDR is an \n\
2149 expression for an address to start at.\n\
2150 This command is a combination of tbreak and jump."));
2151 set_cmd_completer (c
, location_completer
);
2155 add_com_alias ("g", "go", class_run
, 1);
2157 add_com ("continue", class_run
, continue_command
, _("\
2158 Continue program being debugged, after signal or breakpoint.\n\
2159 If proceeding from breakpoint, a number N may be used as an argument,\n\
2160 which means to set the ignore count of that breakpoint to N - 1 (so that\n\
2161 the breakpoint won't break until the Nth time it is reached)."));
2162 add_com_alias ("c", "cont", class_run
, 1);
2163 add_com_alias ("fg", "cont", class_run
, 1);
2165 c
= add_com ("run", class_run
, run_command
, _("\
2166 Start debugged program. You may specify arguments to give it.\n\
2167 Args may include \"*\", or \"[...]\"; they are expanded using \"sh\".\n\
2168 Input and output redirection with \">\", \"<\", or \">>\" are also allowed.\n\n\
2169 With no arguments, uses arguments last specified (with \"run\" or \"set args\").\n\
2170 To cancel previous arguments and run with no arguments,\n\
2171 use \"set args\" without arguments."));
2172 set_cmd_completer (c
, filename_completer
);
2173 add_com_alias ("r", "run", class_run
, 1);
2175 add_com ("R", class_run
, run_no_args_command
,
2176 _("Start debugged program with no arguments."));
2178 c
= add_com ("start", class_run
, start_command
, _("\
2179 Run the debugged program until the beginning of the main procedure.\n\
2180 You may specify arguments to give to your program, just as with the\n\
2181 \"run\" command."));
2182 set_cmd_completer (c
, filename_completer
);
2184 add_com ("interrupt", class_run
, interrupt_target_command
,
2185 _("Interrupt the execution of the debugged program."));
2187 add_info ("registers", nofp_registers_info
, _("\
2188 List of integer registers and their contents, for selected stack frame.\n\
2189 Register name as argument means describe only that register."));
2190 add_info_alias ("r", "registers", 1);
2193 add_com ("lr", class_info
, nofp_registers_info
, _("\
2194 List of integer registers and their contents, for selected stack frame.\n\
2195 Register name as argument means describe only that register."));
2196 add_info ("all-registers", all_registers_info
, _("\
2197 List of all registers and their contents, for selected stack frame.\n\
2198 Register name as argument means describe only that register."));
2200 add_info ("program", program_info
,
2201 _("Execution status of the program."));
2203 add_info ("float", float_info
,
2204 _("Print the status of the floating point unit\n"));
2206 add_info ("vector", vector_info
,
2207 _("Print the status of the vector unit\n"));
2209 inferior_environ
= make_environ ();
2210 init_environ (inferior_environ
);