1 /* Memory-access and commands for "inferior" process, for GDB.
3 Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
5 2008 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 3 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, see <http://www.gnu.org/licenses/>. */
24 #include "gdb_string.h"
38 #include "completer.h"
40 #include "event-top.h"
41 #include "parser-defs.h"
43 #include "reggroups.h"
47 #include "gdb_assert.h"
49 #include "target-descriptions.h"
50 #include "user-regs.h"
51 #include "exceptions.h"
52 #include "cli/cli-decode.h"
53 #include "gdbthread.h"
55 /* Functions exported for general use, in inferior.h: */
57 void all_registers_info (char *, int);
59 void registers_info (char *, int);
61 void nexti_command (char *, int);
63 void stepi_command (char *, int);
65 void continue_command (char *, int);
67 void interrupt_target_command (char *args
, int from_tty
);
69 /* Local functions: */
71 static void nofp_registers_info (char *, int);
73 static void print_return_value (struct type
*func_type
,
74 struct type
*value_type
);
76 static void until_next_command (int);
78 static void until_command (char *, int);
80 static void path_info (char *, int);
82 static void path_command (char *, int);
84 static void unset_command (char *, int);
86 static void float_info (char *, int);
88 static void detach_command (char *, int);
90 static void disconnect_command (char *, int);
92 static void unset_environment_command (char *, int);
94 static void set_environment_command (char *, int);
96 static void environment_info (char *, int);
98 static void program_info (char *, int);
100 static void finish_command (char *, int);
102 static void signal_command (char *, int);
104 static void jump_command (char *, int);
106 static void step_1 (int, int, char *);
107 static void step_once (int skip_subroutines
, int single_inst
, int count
, int thread
);
109 static void next_command (char *, int);
111 static void step_command (char *, int);
113 static void run_command (char *, int);
115 static void run_no_args_command (char *args
, int from_tty
);
117 static void go_command (char *line_no
, int from_tty
);
119 static int strip_bg_char (char **);
121 void _initialize_infcmd (void);
123 #define GO_USAGE "Usage: go <location>\n"
125 #define ERROR_NO_INFERIOR \
126 if (!target_has_execution) error (_("The program is not being run."));
128 /* String containing arguments to give to the program, separated by spaces.
129 Empty string (pointer to '\0') means no args. */
131 static char *inferior_args
;
133 /* The inferior arguments as a vector. If INFERIOR_ARGC is nonzero,
134 then we must compute INFERIOR_ARGS from this (via the target). */
136 static int inferior_argc
;
137 static char **inferior_argv
;
139 /* File name for default use for standard in/out in the inferior. */
141 static char *inferior_io_terminal
;
143 /* Pid of our debugged inferior, or 0 if no inferior now.
144 Since various parts of infrun.c test this to see whether there is a program
145 being debugged it should be nonzero (currently 3 is used) for remote
148 ptid_t inferior_ptid
;
150 /* Last signal that the inferior received (why it stopped). */
152 enum target_signal stop_signal
;
154 /* Address at which inferior stopped. */
158 /* Chain containing status of breakpoint(s) that we have stopped at. */
162 /* Flag indicating that a command has proceeded the inferior past the
163 current breakpoint. */
165 int breakpoint_proceeded
;
167 /* Nonzero if stopped due to a step command. */
171 /* Nonzero if stopped due to completion of a stack dummy routine. */
173 int stop_stack_dummy
;
175 /* Nonzero if stopped due to a random (unexpected) signal in inferior
178 int stopped_by_random_signal
;
180 /* Range to single step within.
181 If this is nonzero, respond to a single-step signal
182 by continuing to step if the pc is in this range. */
184 CORE_ADDR step_range_start
; /* Inclusive */
185 CORE_ADDR step_range_end
; /* Exclusive */
187 /* Stack frame address as of when stepping command was issued.
188 This is how we know when we step into a subroutine call,
189 and how to set the frame for the breakpoint used to step out. */
191 struct frame_id step_frame_id
;
193 enum step_over_calls_kind step_over_calls
;
195 /* If stepping, nonzero means step count is > 1
196 so don't print frame next time inferior stops
197 if it stops due to stepping. */
201 /* Environment to use for running inferior,
202 in format described in environ.h. */
204 struct gdb_environ
*inferior_environ
;
206 /* When set, no calls to target_resumed observer will be made. */
207 int suppress_resume_observer
= 0;
208 /* When set, normal_stop will not call the normal_stop observer. */
209 int suppress_stop_observer
= 0;
211 /* Accessor routines. */
214 set_inferior_io_terminal (const char *terminal_name
)
216 if (inferior_io_terminal
)
217 xfree (inferior_io_terminal
);
220 inferior_io_terminal
= NULL
;
222 inferior_io_terminal
= savestring (terminal_name
, strlen (terminal_name
));
226 get_inferior_io_terminal (void)
228 return inferior_io_terminal
;
232 get_inferior_args (void)
234 if (inferior_argc
!= 0)
238 n
= gdbarch_construct_inferior_arguments (current_gdbarch
,
239 inferior_argc
, inferior_argv
);
240 old
= set_inferior_args (n
);
244 if (inferior_args
== NULL
)
245 inferior_args
= xstrdup ("");
247 return inferior_args
;
251 set_inferior_args (char *newargs
)
253 char *saved_args
= inferior_args
;
255 inferior_args
= newargs
;
263 set_inferior_args_vector (int argc
, char **argv
)
265 inferior_argc
= argc
;
266 inferior_argv
= argv
;
269 /* Notice when `set args' is run. */
271 notice_args_set (char *args
, int from_tty
, struct cmd_list_element
*c
)
277 /* Notice when `show args' is run. */
279 notice_args_read (struct ui_file
*file
, int from_tty
,
280 struct cmd_list_element
*c
, const char *value
)
282 /* Note that we ignore the passed-in value in favor of computing it
284 deprecated_show_value_hack (file
, from_tty
, c
, get_inferior_args ());
288 /* Compute command-line string given argument vector. This does the
289 same shell processing as fork_inferior. */
291 construct_inferior_arguments (struct gdbarch
*gdbarch
, int argc
, char **argv
)
295 if (STARTUP_WITH_SHELL
)
297 /* This holds all the characters considered special to the
298 typical Unix shells. We include `^' because the SunOS
299 /bin/sh treats it as a synonym for `|'. */
300 char *special
= "\"!#$&*()\\|[]{}<>?'\"`~^; \t\n";
305 /* We over-compute the size. It shouldn't matter. */
306 for (i
= 0; i
< argc
; ++i
)
307 length
+= 2 * strlen (argv
[i
]) + 1 + 2 * (argv
[i
][0] == '\0');
309 result
= (char *) xmalloc (length
);
312 for (i
= 0; i
< argc
; ++i
)
317 /* Need to handle empty arguments specially. */
318 if (argv
[i
][0] == '\0')
325 for (cp
= argv
[i
]; *cp
; ++cp
)
327 if (strchr (special
, *cp
) != NULL
)
337 /* In this case we can't handle arguments that contain spaces,
338 tabs, or newlines -- see breakup_args(). */
342 for (i
= 0; i
< argc
; ++i
)
344 char *cp
= strchr (argv
[i
], ' ');
346 cp
= strchr (argv
[i
], '\t');
348 cp
= strchr (argv
[i
], '\n');
350 error (_("can't handle command-line argument containing whitespace"));
351 length
+= strlen (argv
[i
]) + 1;
354 result
= (char *) xmalloc (length
);
356 for (i
= 0; i
< argc
; ++i
)
359 strcat (result
, " ");
360 strcat (result
, argv
[i
]);
368 /* This function detects whether or not a '&' character (indicating
369 background execution) has been added as *the last* of the arguments ARGS
370 of a command. If it has, it removes it and returns 1. Otherwise it
371 does nothing and returns 0. */
373 strip_bg_char (char **args
)
377 p
= strchr (*args
, '&');
381 if (p
== (*args
+ strlen (*args
) - 1))
383 if (strlen (*args
) > 1)
387 while (*p
== ' ' || *p
== '\t');
399 tty_command (char *file
, int from_tty
)
402 error_no_arg (_("terminal name for running target process"));
404 set_inferior_io_terminal (file
);
407 /* Common actions to take after creating any sort of inferior, by any
408 means (running, attaching, connecting, et cetera). The target
409 should be stopped. */
412 post_create_inferior (struct target_ops
*target
, int from_tty
)
414 /* Be sure we own the terminal in case write operations are performed. */
415 target_terminal_ours ();
417 /* If the target hasn't taken care of this already, do it now.
418 Targets which need to access registers during to_open,
419 to_create_inferior, or to_attach should do it earlier; but many
421 target_find_description ();
425 /* Sometimes the platform-specific hook loads initial shared
426 libraries, and sometimes it doesn't. Try to do so first, so
427 that we can add them with the correct value for FROM_TTY.
428 If we made all the inferior hook methods consistent,
429 this call could be removed. */
431 SOLIB_ADD (NULL
, from_tty
, target
, auto_solib_add
);
433 solib_add (NULL
, from_tty
, target
, auto_solib_add
);
436 /* Create the hooks to handle shared library load and unload
438 #ifdef SOLIB_CREATE_INFERIOR_HOOK
439 SOLIB_CREATE_INFERIOR_HOOK (PIDGET (inferior_ptid
));
441 solib_create_inferior_hook ();
445 observer_notify_inferior_created (target
, from_tty
);
448 /* Kill the inferior if already running. This function is designed
449 to be called when we are about to start the execution of the program
450 from the beginning. Ask the user to confirm that he wants to restart
451 the program being debugged when FROM_TTY is non-null. */
454 kill_if_already_running (int from_tty
)
456 if (! ptid_equal (inferior_ptid
, null_ptid
) && target_has_execution
)
458 /* Bail out before killing the program if we will not be able to
460 target_require_runnable ();
463 && !query ("The program being debugged has been started already.\n\
464 Start it from the beginning? "))
465 error (_("Program not restarted."));
467 no_shared_libraries (NULL
, from_tty
);
468 init_wait_for_inferior ();
472 /* Implement the "run" command. If TBREAK_AT_MAIN is set, then insert
473 a temporary breakpoint at the begining of the main program before
474 running the program. */
477 run_command_1 (char *args
, int from_tty
, int tbreak_at_main
)
483 kill_if_already_running (from_tty
);
484 clear_breakpoint_hit_counts ();
486 /* Clean up any leftovers from other runs. Some other things from
487 this function should probably be moved into target_pre_inferior. */
488 target_pre_inferior (from_tty
);
490 /* The comment here used to read, "The exec file is re-read every
491 time we do a generic_mourn_inferior, so we just have to worry
492 about the symbol file." The `generic_mourn_inferior' function
493 gets called whenever the program exits. However, suppose the
494 program exits, and *then* the executable file changes? We need
495 to check again here. Since reopen_exec_file doesn't do anything
496 if the timestamp hasn't changed, I don't see the harm. */
500 /* Insert the temporary breakpoint if a location was specified. */
502 tbreak_command (main_name (), 0);
504 exec_file
= (char *) get_exec_file (0);
506 /* We keep symbols from add-symbol-file, on the grounds that the
507 user might want to add some symbols before running the program
508 (right?). But sometimes (dynamic loading where the user manually
509 introduces the new symbols with add-symbol-file), the code which
510 the symbols describe does not persist between runs. Currently
511 the user has to manually nuke all symbols between runs if they
512 want them to go away (PR 2207). This is probably reasonable. */
516 if (target_can_async_p ())
517 async_disable_stdin ();
521 int async_exec
= strip_bg_char (&args
);
523 /* If we get a request for running in the bg but the target
524 doesn't support it, error out. */
525 if (async_exec
&& !target_can_async_p ())
526 error (_("Asynchronous execution not supported on this target."));
528 /* If we don't get a request of running in the bg, then we need
529 to simulate synchronous (fg) execution. */
530 if (!async_exec
&& target_can_async_p ())
532 /* Simulate synchronous execution */
533 async_disable_stdin ();
536 /* If there were other args, beside '&', process them. */
539 char *old_args
= set_inferior_args (xstrdup (args
));
546 ui_out_field_string (uiout
, NULL
, "Starting program");
547 ui_out_text (uiout
, ": ");
549 ui_out_field_string (uiout
, "execfile", exec_file
);
550 ui_out_spaces (uiout
, 1);
551 /* We call get_inferior_args() because we might need to compute
553 ui_out_field_string (uiout
, "infargs", get_inferior_args ());
554 ui_out_text (uiout
, "\n");
555 ui_out_flush (uiout
);
558 /* We call get_inferior_args() because we might need to compute
560 target_create_inferior (exec_file
, get_inferior_args (),
561 environ_vector (inferior_environ
), from_tty
);
563 /* Pass zero for FROM_TTY, because at this point the "run" command
564 has done its thing; now we are setting up the running program. */
565 post_create_inferior (¤t_target
, 0);
567 /* Start the target running. */
568 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_0
, 0);
573 run_command (char *args
, int from_tty
)
575 run_command_1 (args
, from_tty
, 0);
579 run_no_args_command (char *args
, int from_tty
)
581 char *old_args
= set_inferior_args (xstrdup (""));
586 /* Start the execution of the program up until the beginning of the main
590 start_command (char *args
, int from_tty
)
592 /* Some languages such as Ada need to search inside the program
593 minimal symbols for the location where to put the temporary
594 breakpoint before starting. */
595 if (!have_minimal_symbols ())
596 error (_("No symbol table loaded. Use the \"file\" command."));
598 /* Run the program until reaching the main procedure... */
599 run_command_1 (args
, from_tty
, 1);
603 proceed_thread_callback (struct thread_info
*thread
, void *arg
)
605 if (!is_stopped (thread
->ptid
))
608 context_switch_to (thread
->ptid
);
609 clear_proceed_status ();
610 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 0);
615 continue_1 (int all_threads
)
619 if (non_stop
&& all_threads
)
621 /* Don't error out if the current thread is running, because
622 there may be other stopped threads. */
623 struct cleanup
*old_chain
;
625 /* Backup current thread and selected frame. */
626 old_chain
= make_cleanup_restore_current_thread ();
628 iterate_over_threads (proceed_thread_callback
, NULL
);
630 /* Restore selected ptid. */
631 do_cleanups (old_chain
);
635 ensure_not_running ();
636 clear_proceed_status ();
637 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 0);
641 /* continue [-a] [proceed-count] [&] */
643 continue_command (char *args
, int from_tty
)
649 /* Find out whether we must run in the background. */
651 async_exec
= strip_bg_char (&args
);
653 /* If we must run in the background, but the target can't do it,
655 if (async_exec
&& !target_can_async_p ())
656 error (_("Asynchronous execution not supported on this target."));
658 /* If we are not asked to run in the bg, then prepare to run in the
659 foreground, synchronously. */
660 if (!async_exec
&& target_can_async_p ())
662 /* Simulate synchronous execution */
663 async_disable_stdin ();
668 if (strncmp (args
, "-a", sizeof ("-a") - 1) == 0)
671 args
+= sizeof ("-a") - 1;
677 if (!non_stop
&& all_threads
)
678 error (_("`-a' is meaningless in all-stop mode."));
680 if (args
!= NULL
&& all_threads
)
682 Can't resume all threads and specify proceed count simultaneously."));
684 /* If we have an argument left, set proceed count of breakpoint we
688 bpstat bs
= stop_bpstat
;
692 while ((stat
= bpstat_num (&bs
, &num
)) != 0)
695 set_ignore_count (num
,
696 parse_and_eval_long (args
) - 1,
698 /* set_ignore_count prints a message ending with a period.
699 So print two spaces before "Continuing.". */
701 printf_filtered (" ");
705 if (!stopped
&& from_tty
)
708 ("Not stopped at any breakpoint; argument ignored.\n");
713 printf_filtered (_("Continuing.\n"));
715 continue_1 (all_threads
);
718 /* Step until outside of current statement. */
721 step_command (char *count_string
, int from_tty
)
723 step_1 (0, 0, count_string
);
726 /* Likewise, but skip over subroutine calls as if single instructions. */
729 next_command (char *count_string
, int from_tty
)
731 step_1 (1, 0, count_string
);
734 /* Likewise, but step only one instruction. */
737 stepi_command (char *count_string
, int from_tty
)
739 step_1 (0, 1, count_string
);
743 nexti_command (char *count_string
, int from_tty
)
745 step_1 (1, 1, count_string
);
749 delete_longjmp_breakpoint_cleanup (void *arg
)
751 int thread
= * (int *) arg
;
752 delete_longjmp_breakpoint (thread
);
756 step_1 (int skip_subroutines
, int single_inst
, char *count_string
)
759 struct frame_info
*frame
;
760 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
765 ensure_not_running ();
768 async_exec
= strip_bg_char (&count_string
);
770 /* If we get a request for running in the bg but the target
771 doesn't support it, error out. */
772 if (async_exec
&& !target_can_async_p ())
773 error (_("Asynchronous execution not supported on this target."));
775 /* If we don't get a request of running in the bg, then we need
776 to simulate synchronous (fg) execution. */
777 if (!async_exec
&& target_can_async_p ())
779 /* Simulate synchronous execution */
780 async_disable_stdin ();
783 count
= count_string
? parse_and_eval_long (count_string
) : 1;
785 if (!single_inst
|| skip_subroutines
) /* leave si command alone */
787 if (in_thread_list (inferior_ptid
))
788 thread
= pid_to_thread_id (inferior_ptid
);
790 set_longjmp_breakpoint ();
792 make_cleanup (delete_longjmp_breakpoint_cleanup
, &thread
);
795 /* In synchronous case, all is well, just use the regular for loop. */
796 if (!target_can_async_p ())
798 for (; count
> 0; count
--)
800 clear_proceed_status ();
802 frame
= get_current_frame ();
803 if (!frame
) /* Avoid coredump here. Why tho? */
804 error (_("No current frame"));
805 step_frame_id
= get_frame_id (frame
);
809 find_pc_line_pc_range (stop_pc
, &step_range_start
, &step_range_end
);
810 if (step_range_end
== 0)
813 if (find_pc_partial_function (stop_pc
, &name
, &step_range_start
,
814 &step_range_end
) == 0)
815 error (_("Cannot find bounds of current function"));
817 target_terminal_ours ();
818 printf_filtered (_("\
819 Single stepping until exit from function %s, \n\
820 which has no line number information.\n"), name
);
825 /* Say we are stepping, but stop after one insn whatever it does. */
826 step_range_start
= step_range_end
= 1;
827 if (!skip_subroutines
)
829 Don't step over function calls, not even to functions lacking
831 step_over_calls
= STEP_OVER_NONE
;
834 if (skip_subroutines
)
835 step_over_calls
= STEP_OVER_ALL
;
837 step_multi
= (count
> 1);
838 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 1);
844 do_cleanups (cleanups
);
847 /* In case of asynchronous target things get complicated, do only
848 one step for now, before returning control to the event loop. Let
849 the continuation figure out how many other steps we need to do,
850 and handle them one at the time, through step_once(). */
853 step_once (skip_subroutines
, single_inst
, count
, thread
);
854 /* We are running, and the continuation is installed. It will
855 disable the longjmp breakpoint as appropriate. */
856 discard_cleanups (cleanups
);
860 struct step_1_continuation_args
863 int skip_subroutines
;
868 /* Called after we are done with one step operation, to check whether
869 we need to step again, before we print the prompt and return control
870 to the user. If count is > 1, we will need to do one more call to
871 proceed(), via step_once(). Basically it is like step_once and
872 step_1_continuation are co-recursive. */
874 step_1_continuation (void *args
)
876 struct step_1_continuation_args
*a
= args
;
878 if (!step_multi
|| !stop_step
)
880 /* If we stopped for some reason that is not stepping there are
881 no further steps to make. Cleanup. */
882 if (!a
->single_inst
|| a
->skip_subroutines
)
883 delete_longjmp_breakpoint (a
->thread
);
887 step_once (a
->skip_subroutines
, a
->single_inst
, a
->count
- 1, a
->thread
);
890 /* Do just one step operation. If count >1 we will have to set up a
891 continuation to be done after the target stops (after this one
892 step). This is useful to implement the 'step n' kind of commands, in
893 case of asynchronous targets. We had to split step_1 into two parts,
894 one to be done before proceed() and one afterwards. This function is
895 called in case of step n with n>1, after the first step operation has
898 step_once (int skip_subroutines
, int single_inst
, int count
, int thread
)
900 struct frame_info
*frame
;
901 struct step_1_continuation_args
*args
;
905 clear_proceed_status ();
907 frame
= get_current_frame ();
908 if (!frame
) /* Avoid coredump here. Why tho? */
909 error (_("No current frame"));
910 step_frame_id
= get_frame_id (frame
);
914 find_pc_line_pc_range (stop_pc
, &step_range_start
, &step_range_end
);
916 /* If we have no line info, switch to stepi mode. */
917 if (step_range_end
== 0 && step_stop_if_no_debug
)
919 step_range_start
= step_range_end
= 1;
921 else if (step_range_end
== 0)
924 if (find_pc_partial_function (stop_pc
, &name
, &step_range_start
,
925 &step_range_end
) == 0)
926 error (_("Cannot find bounds of current function"));
928 target_terminal_ours ();
929 printf_filtered (_("\
930 Single stepping until exit from function %s, \n\
931 which has no line number information.\n"), name
);
936 /* Say we are stepping, but stop after one insn whatever it does. */
937 step_range_start
= step_range_end
= 1;
938 if (!skip_subroutines
)
940 Don't step over function calls, not even to functions lacking
942 step_over_calls
= STEP_OVER_NONE
;
945 if (skip_subroutines
)
946 step_over_calls
= STEP_OVER_ALL
;
948 step_multi
= (count
> 1);
949 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 1);
951 args
= xmalloc (sizeof (*args
));
952 args
->skip_subroutines
= skip_subroutines
;
953 args
->single_inst
= single_inst
;
955 args
->thread
= thread
;
956 add_intermediate_continuation (step_1_continuation
, args
, xfree
);
961 /* Continue program at specified address. */
964 jump_command (char *arg
, int from_tty
)
967 struct symtabs_and_lines sals
;
968 struct symtab_and_line sal
;
974 ensure_not_running ();
976 /* Find out whether we must run in the background. */
978 async_exec
= strip_bg_char (&arg
);
980 /* If we must run in the background, but the target can't do it,
982 if (async_exec
&& !target_can_async_p ())
983 error (_("Asynchronous execution not supported on this target."));
986 error_no_arg (_("starting address"));
988 sals
= decode_line_spec_1 (arg
, 1);
991 error (_("Unreasonable jump request"));
997 if (sal
.symtab
== 0 && sal
.pc
== 0)
998 error (_("No source file has been specified."));
1000 resolve_sal_pc (&sal
); /* May error out */
1002 /* See if we are trying to jump to another function. */
1003 fn
= get_frame_function (get_current_frame ());
1004 sfn
= find_pc_function (sal
.pc
);
1005 if (fn
!= NULL
&& sfn
!= fn
)
1007 if (!query ("Line %d is not in `%s'. Jump anyway? ", sal
.line
,
1008 SYMBOL_PRINT_NAME (fn
)))
1010 error (_("Not confirmed."));
1017 fixup_symbol_section (sfn
, 0);
1018 if (section_is_overlay (SYMBOL_BFD_SECTION (sfn
)) &&
1019 !section_is_mapped (SYMBOL_BFD_SECTION (sfn
)))
1021 if (!query ("WARNING!!! Destination is in unmapped overlay! Jump anyway? "))
1023 error (_("Not confirmed."));
1033 printf_filtered (_("Continuing at "));
1034 fputs_filtered (paddress (addr
), gdb_stdout
);
1035 printf_filtered (".\n");
1038 /* If we are not asked to run in the bg, then prepare to run in the
1039 foreground, synchronously. */
1040 if (!async_exec
&& target_can_async_p ())
1042 /* Simulate synchronous execution */
1043 async_disable_stdin ();
1046 clear_proceed_status ();
1047 proceed (addr
, TARGET_SIGNAL_0
, 0);
1051 /* Go to line or address in current procedure */
1053 go_command (char *line_no
, int from_tty
)
1055 if (line_no
== (char *) NULL
|| !*line_no
)
1056 printf_filtered (GO_USAGE
);
1059 tbreak_command (line_no
, from_tty
);
1060 jump_command (line_no
, from_tty
);
1065 /* Continue program giving it specified signal. */
1068 signal_command (char *signum_exp
, int from_tty
)
1070 enum target_signal oursig
;
1073 dont_repeat (); /* Too dangerous. */
1075 ensure_not_running ();
1077 /* Find out whether we must run in the background. */
1078 if (signum_exp
!= NULL
)
1079 async_exec
= strip_bg_char (&signum_exp
);
1081 /* If we must run in the background, but the target can't do it,
1083 if (async_exec
&& !target_can_async_p ())
1084 error (_("Asynchronous execution not supported on this target."));
1086 /* If we are not asked to run in the bg, then prepare to run in the
1087 foreground, synchronously. */
1088 if (!async_exec
&& target_can_async_p ())
1090 /* Simulate synchronous execution. */
1091 async_disable_stdin ();
1095 error_no_arg (_("signal number"));
1097 /* It would be even slicker to make signal names be valid expressions,
1098 (the type could be "enum $signal" or some such), then the user could
1099 assign them to convenience variables. */
1100 oursig
= target_signal_from_name (signum_exp
);
1102 if (oursig
== TARGET_SIGNAL_UNKNOWN
)
1104 /* No, try numeric. */
1105 int num
= parse_and_eval_long (signum_exp
);
1108 oursig
= TARGET_SIGNAL_0
;
1110 oursig
= target_signal_from_command (num
);
1115 if (oursig
== TARGET_SIGNAL_0
)
1116 printf_filtered (_("Continuing with no signal.\n"));
1118 printf_filtered (_("Continuing with signal %s.\n"),
1119 target_signal_to_name (oursig
));
1122 clear_proceed_status ();
1123 /* "signal 0" should not get stuck if we are stopped at a breakpoint.
1124 FIXME: Neither should "signal foo" but when I tried passing
1125 (CORE_ADDR)-1 unconditionally I got a testsuite failure which I haven't
1126 tried to track down yet. */
1127 proceed (oursig
== TARGET_SIGNAL_0
? (CORE_ADDR
) -1 : stop_pc
, oursig
, 0);
1130 /* Proceed until we reach a different source line with pc greater than
1131 our current one or exit the function. We skip calls in both cases.
1133 Note that eventually this command should probably be changed so
1134 that only source lines are printed out when we hit the breakpoint
1135 we set. This may involve changes to wait_for_inferior and the
1136 proceed status code. */
1139 until_next_command (int from_tty
)
1141 struct frame_info
*frame
;
1143 struct symbol
*func
;
1144 struct symtab_and_line sal
;
1146 clear_proceed_status ();
1148 frame
= get_current_frame ();
1150 /* Step until either exited from this function or greater
1151 than the current line (if in symbolic section) or pc (if
1155 func
= find_pc_function (pc
);
1159 struct minimal_symbol
*msymbol
= lookup_minimal_symbol_by_pc (pc
);
1161 if (msymbol
== NULL
)
1162 error (_("Execution is not within a known function."));
1164 step_range_start
= SYMBOL_VALUE_ADDRESS (msymbol
);
1165 step_range_end
= pc
;
1169 sal
= find_pc_line (pc
, 0);
1171 step_range_start
= BLOCK_START (SYMBOL_BLOCK_VALUE (func
));
1172 step_range_end
= sal
.end
;
1175 step_over_calls
= STEP_OVER_ALL
;
1176 step_frame_id
= get_frame_id (frame
);
1178 step_multi
= 0; /* Only one call to proceed */
1180 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 1);
1184 until_command (char *arg
, int from_tty
)
1188 if (!target_has_execution
)
1189 error (_("The program is not running."));
1191 /* Find out whether we must run in the background. */
1193 async_exec
= strip_bg_char (&arg
);
1195 /* If we must run in the background, but the target can't do it,
1197 if (async_exec
&& !target_can_async_p ())
1198 error (_("Asynchronous execution not supported on this target."));
1200 /* If we are not asked to run in the bg, then prepare to run in the
1201 foreground, synchronously. */
1202 if (!async_exec
&& target_can_async_p ())
1204 /* Simulate synchronous execution */
1205 async_disable_stdin ();
1209 until_break_command (arg
, from_tty
, 0);
1211 until_next_command (from_tty
);
1215 advance_command (char *arg
, int from_tty
)
1219 if (!target_has_execution
)
1220 error (_("The program is not running."));
1223 error_no_arg (_("a location"));
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 ();
1242 until_break_command (arg
, from_tty
, 1);
1245 /* Print the result of a function at the end of a 'finish' command. */
1248 print_return_value (struct type
*func_type
, struct type
*value_type
)
1250 struct gdbarch
*gdbarch
= current_gdbarch
;
1251 struct cleanup
*old_chain
;
1252 struct ui_stream
*stb
;
1253 struct value
*value
;
1255 CHECK_TYPEDEF (value_type
);
1256 gdb_assert (TYPE_CODE (value_type
) != TYPE_CODE_VOID
);
1258 /* FIXME: 2003-09-27: When returning from a nested inferior function
1259 call, it's possible (with no help from the architecture vector)
1260 to locate and return/print a "struct return" value. This is just
1261 a more complicated case of what is already being done in in the
1262 inferior function call code. In fact, when inferior function
1263 calls are made async, this will likely be made the norm. */
1265 switch (gdbarch_return_value (gdbarch
, func_type
, value_type
,
1268 case RETURN_VALUE_REGISTER_CONVENTION
:
1269 case RETURN_VALUE_ABI_RETURNS_ADDRESS
:
1270 case RETURN_VALUE_ABI_PRESERVES_ADDRESS
:
1271 value
= allocate_value (value_type
);
1272 gdbarch_return_value (gdbarch
, func_type
, value_type
, stop_registers
,
1273 value_contents_raw (value
), NULL
);
1275 case RETURN_VALUE_STRUCT_CONVENTION
:
1279 internal_error (__FILE__
, __LINE__
, _("bad switch"));
1285 stb
= ui_out_stream_new (uiout
);
1286 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
1287 ui_out_text (uiout
, "Value returned is ");
1288 ui_out_field_fmt (uiout
, "gdb-result-var", "$%d",
1289 record_latest_value (value
));
1290 ui_out_text (uiout
, " = ");
1291 value_print (value
, stb
->stream
, 0, Val_no_prettyprint
);
1292 ui_out_field_stream (uiout
, "return-value", stb
);
1293 ui_out_text (uiout
, "\n");
1294 do_cleanups (old_chain
);
1298 ui_out_text (uiout
, "Value returned has type: ");
1299 ui_out_field_string (uiout
, "return-type", TYPE_NAME (value_type
));
1300 ui_out_text (uiout
, ".");
1301 ui_out_text (uiout
, " Cannot determine contents\n");
1305 /* Stuff that needs to be done by the finish command after the target
1306 has stopped. In asynchronous mode, we wait for the target to stop
1307 in the call to poll or select in the event loop, so it is
1308 impossible to do all the stuff as part of the finish_command
1309 function itself. The only chance we have to complete this command
1310 is in fetch_inferior_event, which is called by the event loop as
1311 soon as it detects that the target has stopped. This function is
1312 called via the cmd_continuation pointer. */
1314 struct finish_command_continuation_args
1316 struct breakpoint
*breakpoint
;
1317 struct symbol
*function
;
1321 finish_command_continuation (void *arg
)
1323 struct finish_command_continuation_args
*a
= arg
;
1325 if (bpstat_find_breakpoint (stop_bpstat
, a
->breakpoint
) != NULL
1326 && a
->function
!= NULL
)
1328 struct type
*value_type
;
1330 value_type
= TYPE_TARGET_TYPE (SYMBOL_TYPE (a
->function
));
1332 internal_error (__FILE__
, __LINE__
,
1333 _("finish_command: function has no target type"));
1335 if (TYPE_CODE (value_type
) != TYPE_CODE_VOID
)
1336 print_return_value (SYMBOL_TYPE (a
->function
), value_type
);
1339 /* We suppress normal call of normal_stop observer and do it here so
1340 that that *stopped notification includes the return value. */
1341 /* NOTE: This is broken in non-stop mode. There is no guarantee the
1342 next stop will be in the same thread that we started doing a
1343 finish on. This suppressing (or some other replacement means)
1344 should be a thread property. */
1345 observer_notify_normal_stop (stop_bpstat
);
1346 suppress_stop_observer
= 0;
1347 delete_breakpoint (a
->breakpoint
);
1351 finish_command_continuation_free_arg (void *arg
)
1353 /* NOTE: See finish_command_continuation. This would go away, if
1354 this suppressing is made a thread property. */
1355 suppress_stop_observer
= 0;
1359 /* "finish": Set a temporary breakpoint at the place the selected
1360 frame will return to, then continue. */
1363 finish_command (char *arg
, int from_tty
)
1365 struct symtab_and_line sal
;
1366 struct frame_info
*frame
;
1367 struct symbol
*function
;
1368 struct breakpoint
*breakpoint
;
1369 struct cleanup
*old_chain
;
1370 struct finish_command_continuation_args
*cargs
;
1374 /* Find out whether we must run in the background. */
1376 async_exec
= strip_bg_char (&arg
);
1378 /* If we must run in the background, but the target can't do it,
1380 if (async_exec
&& !target_can_async_p ())
1381 error (_("Asynchronous execution not supported on this target."));
1383 /* If we are not asked to run in the bg, then prepare to run in the
1384 foreground, synchronously. */
1385 if (!async_exec
&& target_can_async_p ())
1387 /* Simulate synchronous execution. */
1388 async_disable_stdin ();
1392 error (_("The \"finish\" command does not take any arguments."));
1393 if (!target_has_execution
)
1394 error (_("The program is not running."));
1396 frame
= get_prev_frame (get_selected_frame (_("No selected frame.")));
1398 error (_("\"finish\" not meaningful in the outermost frame."));
1400 clear_proceed_status ();
1402 sal
= find_pc_line (get_frame_pc (frame
), 0);
1403 sal
.pc
= get_frame_pc (frame
);
1405 breakpoint
= set_momentary_breakpoint (sal
, get_frame_id (frame
), bp_finish
);
1407 old_chain
= make_cleanup_delete_breakpoint (breakpoint
);
1409 /* Find the function we will return from. */
1411 function
= find_pc_function (get_frame_pc (get_selected_frame (NULL
)));
1413 /* Print info on the selected frame, including level number but not
1417 printf_filtered (_("Run till exit from "));
1418 print_stack_frame (get_selected_frame (NULL
), 1, LOCATION
);
1421 proceed_to_finish
= 1; /* We want stop_registers, please... */
1422 make_cleanup_restore_integer (&suppress_stop_observer
);
1423 suppress_stop_observer
= 1;
1424 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 0);
1426 cargs
= xmalloc (sizeof (*cargs
));
1428 cargs
->breakpoint
= breakpoint
;
1429 cargs
->function
= function
;
1430 add_continuation (finish_command_continuation
, cargs
,
1431 finish_command_continuation_free_arg
);
1433 discard_cleanups (old_chain
);
1434 if (!target_can_async_p ())
1435 do_all_continuations ();
1440 program_info (char *args
, int from_tty
)
1442 bpstat bs
= stop_bpstat
;
1444 int stat
= bpstat_num (&bs
, &num
);
1446 if (!target_has_execution
)
1448 printf_filtered (_("The program being debugged is not being run.\n"));
1452 target_files_info ();
1453 printf_filtered (_("Program stopped at %s.\n"),
1454 hex_string ((unsigned long) stop_pc
));
1456 printf_filtered (_("It stopped after being stepped.\n"));
1459 /* There may be several breakpoints in the same place, so this
1460 isn't as strange as it seems. */
1465 printf_filtered (_("\
1466 It stopped at a breakpoint that has since been deleted.\n"));
1469 printf_filtered (_("It stopped at breakpoint %d.\n"), num
);
1470 stat
= bpstat_num (&bs
, &num
);
1473 else if (stop_signal
!= TARGET_SIGNAL_0
)
1475 printf_filtered (_("It stopped with signal %s, %s.\n"),
1476 target_signal_to_name (stop_signal
),
1477 target_signal_to_string (stop_signal
));
1482 printf_filtered (_("\
1483 Type \"info stack\" or \"info registers\" for more information.\n"));
1488 environment_info (char *var
, int from_tty
)
1492 char *val
= get_in_environ (inferior_environ
, var
);
1495 puts_filtered (var
);
1496 puts_filtered (" = ");
1497 puts_filtered (val
);
1498 puts_filtered ("\n");
1502 puts_filtered ("Environment variable \"");
1503 puts_filtered (var
);
1504 puts_filtered ("\" not defined.\n");
1509 char **vector
= environ_vector (inferior_environ
);
1512 puts_filtered (*vector
++);
1513 puts_filtered ("\n");
1519 set_environment_command (char *arg
, int from_tty
)
1521 char *p
, *val
, *var
;
1525 error_no_arg (_("environment variable and value"));
1527 /* Find seperation between variable name and value */
1528 p
= (char *) strchr (arg
, '=');
1529 val
= (char *) strchr (arg
, ' ');
1531 if (p
!= 0 && val
!= 0)
1533 /* We have both a space and an equals. If the space is before the
1534 equals, walk forward over the spaces til we see a nonspace
1535 (possibly the equals). */
1540 /* Now if the = is after the char following the spaces,
1541 take the char following the spaces. */
1545 else if (val
!= 0 && p
== 0)
1549 error_no_arg (_("environment variable to set"));
1551 if (p
== 0 || p
[1] == 0)
1555 p
= arg
+ strlen (arg
); /* So that savestring below will work */
1559 /* Not setting variable value to null */
1561 while (*val
== ' ' || *val
== '\t')
1565 while (p
!= arg
&& (p
[-1] == ' ' || p
[-1] == '\t'))
1568 var
= savestring (arg
, p
- arg
);
1571 printf_filtered (_("\
1572 Setting environment variable \"%s\" to null value.\n"),
1574 set_in_environ (inferior_environ
, var
, "");
1577 set_in_environ (inferior_environ
, var
, val
);
1582 unset_environment_command (char *var
, int from_tty
)
1586 /* If there is no argument, delete all environment variables.
1587 Ask for confirmation if reading from the terminal. */
1588 if (!from_tty
|| query (_("Delete all environment variables? ")))
1590 free_environ (inferior_environ
);
1591 inferior_environ
= make_environ ();
1595 unset_in_environ (inferior_environ
, var
);
1598 /* Handle the execution path (PATH variable) */
1600 static const char path_var_name
[] = "PATH";
1603 path_info (char *args
, int from_tty
)
1605 puts_filtered ("Executable and object file path: ");
1606 puts_filtered (get_in_environ (inferior_environ
, path_var_name
));
1607 puts_filtered ("\n");
1610 /* Add zero or more directories to the front of the execution path. */
1613 path_command (char *dirname
, int from_tty
)
1618 env
= get_in_environ (inferior_environ
, path_var_name
);
1619 /* Can be null if path is not set */
1622 exec_path
= xstrdup (env
);
1623 mod_path (dirname
, &exec_path
);
1624 set_in_environ (inferior_environ
, path_var_name
, exec_path
);
1627 path_info ((char *) NULL
, from_tty
);
1631 /* Print out the machine register regnum. If regnum is -1, print all
1632 registers (print_all == 1) or all non-float and non-vector
1633 registers (print_all == 0).
1635 For most machines, having all_registers_info() print the
1636 register(s) one per line is good enough. If a different format is
1637 required, (eg, for MIPS or Pyramid 90x, which both have lots of
1638 regs), or there is an existing convention for showing all the
1639 registers, define the architecture method PRINT_REGISTERS_INFO to
1640 provide that format. */
1643 default_print_registers_info (struct gdbarch
*gdbarch
,
1644 struct ui_file
*file
,
1645 struct frame_info
*frame
,
1646 int regnum
, int print_all
)
1649 const int numregs
= gdbarch_num_regs (gdbarch
)
1650 + gdbarch_num_pseudo_regs (gdbarch
);
1651 gdb_byte buffer
[MAX_REGISTER_SIZE
];
1653 for (i
= 0; i
< numregs
; i
++)
1655 /* Decide between printing all regs, non-float / vector regs, or
1661 if (!gdbarch_register_reggroup_p (gdbarch
, i
, all_reggroup
))
1666 if (!gdbarch_register_reggroup_p (gdbarch
, i
, general_reggroup
))
1676 /* If the register name is empty, it is undefined for this
1677 processor, so don't display anything. */
1678 if (gdbarch_register_name (gdbarch
, i
) == NULL
1679 || *(gdbarch_register_name (gdbarch
, i
)) == '\0')
1682 fputs_filtered (gdbarch_register_name (gdbarch
, i
), file
);
1683 print_spaces_filtered (15 - strlen (gdbarch_register_name
1684 (gdbarch
, i
)), file
);
1686 /* Get the data in raw format. */
1687 if (! frame_register_read (frame
, i
, buffer
))
1689 fprintf_filtered (file
, "*value not available*\n");
1693 /* If virtual format is floating, print it that way, and in raw
1695 if (TYPE_CODE (register_type (gdbarch
, i
)) == TYPE_CODE_FLT
1696 || TYPE_CODE (register_type (gdbarch
, i
)) == TYPE_CODE_DECFLOAT
)
1700 val_print (register_type (gdbarch
, i
), buffer
, 0, 0,
1701 file
, 0, 1, 0, Val_pretty_default
, current_language
);
1703 fprintf_filtered (file
, "\t(raw 0x");
1704 for (j
= 0; j
< register_size (gdbarch
, i
); j
++)
1707 if (gdbarch_byte_order (gdbarch
) == BFD_ENDIAN_BIG
)
1710 idx
= register_size (gdbarch
, i
) - 1 - j
;
1711 fprintf_filtered (file
, "%02x", (unsigned char) buffer
[idx
]);
1713 fprintf_filtered (file
, ")");
1717 /* Print the register in hex. */
1718 val_print (register_type (gdbarch
, i
), buffer
, 0, 0,
1719 file
, 'x', 1, 0, Val_pretty_default
, current_language
);
1720 /* If not a vector register, print it also according to its
1722 if (TYPE_VECTOR (register_type (gdbarch
, i
)) == 0)
1724 fprintf_filtered (file
, "\t");
1725 val_print (register_type (gdbarch
, i
), buffer
, 0, 0,
1726 file
, 0, 1, 0, Val_pretty_default
, current_language
);
1730 fprintf_filtered (file
, "\n");
1735 registers_info (char *addr_exp
, int fpregs
)
1737 struct frame_info
*frame
;
1738 struct gdbarch
*gdbarch
;
1739 int regnum
, numregs
;
1742 if (!target_has_registers
)
1743 error (_("The program has no registers now."));
1744 frame
= get_selected_frame (NULL
);
1745 gdbarch
= get_frame_arch (frame
);
1749 gdbarch_print_registers_info (gdbarch
, gdb_stdout
,
1754 while (*addr_exp
!= '\0')
1759 /* Keep skipping leading white space. */
1760 if (isspace ((*addr_exp
)))
1766 /* Discard any leading ``$''. Check that there is something
1767 resembling a register following it. */
1768 if (addr_exp
[0] == '$')
1770 if (isspace ((*addr_exp
)) || (*addr_exp
) == '\0')
1771 error (_("Missing register name"));
1773 /* Find the start/end of this register name/num/group. */
1775 while ((*addr_exp
) != '\0' && !isspace ((*addr_exp
)))
1779 /* Figure out what we've found and display it. */
1781 /* A register name? */
1783 int regnum
= frame_map_name_to_regnum (frame
, start
, end
- start
);
1786 /* User registers lie completely outside of the range of
1787 normal registers. Catch them early so that the target
1789 if (regnum
>= gdbarch_num_regs (gdbarch
)
1790 + gdbarch_num_pseudo_regs (gdbarch
))
1792 struct value
*val
= value_of_user_reg (regnum
, frame
);
1794 printf_filtered ("%s: ", start
);
1795 print_scalar_formatted (value_contents (val
),
1796 check_typedef (value_type (val
)),
1797 'x', 0, gdb_stdout
);
1798 printf_filtered ("\n");
1801 gdbarch_print_registers_info (gdbarch
, gdb_stdout
,
1802 frame
, regnum
, fpregs
);
1807 /* A register number? (how portable is this one?). */
1810 int regnum
= strtol (start
, &endptr
, 0);
1813 && regnum
< gdbarch_num_regs (gdbarch
)
1814 + gdbarch_num_pseudo_regs (gdbarch
))
1816 gdbarch_print_registers_info (gdbarch
, gdb_stdout
,
1817 frame
, regnum
, fpregs
);
1822 /* A register group? */
1824 struct reggroup
*group
;
1825 for (group
= reggroup_next (gdbarch
, NULL
);
1827 group
= reggroup_next (gdbarch
, group
))
1829 /* Don't bother with a length check. Should the user
1830 enter a short register group name, go with the first
1831 group that matches. */
1832 if (strncmp (start
, reggroup_name (group
), end
- start
) == 0)
1839 regnum
< gdbarch_num_regs (gdbarch
)
1840 + gdbarch_num_pseudo_regs (gdbarch
);
1843 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, group
))
1844 gdbarch_print_registers_info (gdbarch
,
1852 /* Nothing matched. */
1853 error (_("Invalid register `%.*s'"), (int) (end
- start
), start
);
1858 all_registers_info (char *addr_exp
, int from_tty
)
1860 registers_info (addr_exp
, 1);
1864 nofp_registers_info (char *addr_exp
, int from_tty
)
1866 registers_info (addr_exp
, 0);
1870 print_vector_info (struct gdbarch
*gdbarch
, struct ui_file
*file
,
1871 struct frame_info
*frame
, const char *args
)
1873 if (gdbarch_print_vector_info_p (gdbarch
))
1874 gdbarch_print_vector_info (gdbarch
, file
, frame
, args
);
1878 int printed_something
= 0;
1881 regnum
< gdbarch_num_regs (gdbarch
)
1882 + gdbarch_num_pseudo_regs (gdbarch
);
1885 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, vector_reggroup
))
1887 printed_something
= 1;
1888 gdbarch_print_registers_info (gdbarch
, file
, frame
, regnum
, 1);
1891 if (!printed_something
)
1892 fprintf_filtered (file
, "No vector information\n");
1897 vector_info (char *args
, int from_tty
)
1899 if (!target_has_registers
)
1900 error (_("The program has no registers now."));
1902 print_vector_info (current_gdbarch
, gdb_stdout
,
1903 get_selected_frame (NULL
), args
);
1909 * Should save/restore the tty state since it might be that the
1910 * program to be debugged was started on this tty and it wants
1911 * the tty in some state other than what we want. If it's running
1912 * on another terminal or without a terminal, then saving and
1913 * restoring the tty state is a harmless no-op.
1914 * This only needs to be done if we are attaching to a process.
1919 takes a program started up outside of gdb and ``attaches'' to it.
1920 This stops it cold in its tracks and allows us to start debugging it.
1921 and wait for the trace-trap that results from attaching. */
1924 attach_command_post_wait (char *args
, int from_tty
, int async_exec
)
1927 char *full_exec_path
= NULL
;
1929 stop_soon
= NO_STOP_QUIETLY
;
1931 /* If no exec file is yet known, try to determine it from the
1933 exec_file
= (char *) get_exec_file (0);
1936 exec_file
= target_pid_to_exec_file (PIDGET (inferior_ptid
));
1939 /* It's possible we don't have a full path, but rather just a
1940 filename. Some targets, such as HP-UX, don't provide the
1943 Attempt to qualify the filename against the source path.
1944 (If that fails, we'll just fall back on the original
1945 filename. Not much more we can do...)
1947 if (!source_full_path_of (exec_file
, &full_exec_path
))
1948 full_exec_path
= savestring (exec_file
, strlen (exec_file
));
1950 exec_file_attach (full_exec_path
, from_tty
);
1951 symbol_file_add_main (full_exec_path
, from_tty
);
1956 reopen_exec_file ();
1960 /* Take any necessary post-attaching actions for this platform. */
1961 target_post_attach (PIDGET (inferior_ptid
));
1963 post_create_inferior (¤t_target
, from_tty
);
1965 /* Install inferior's terminal modes. */
1966 target_terminal_inferior ();
1969 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_0
, 0);
1972 if (target_can_async_p ())
1973 async_enable_stdin ();
1975 if (deprecated_attach_hook
)
1976 deprecated_attach_hook ();
1980 struct attach_command_continuation_args
1988 attach_command_continuation (void *args
)
1990 struct attach_command_continuation_args
*a
= args
;
1991 attach_command_post_wait (a
->args
, a
->from_tty
, a
->async_exec
);
1995 attach_command_continuation_free_args (void *args
)
1997 struct attach_command_continuation_args
*a
= args
;
2003 attach_command (char *args
, int from_tty
)
2006 char *full_exec_path
= NULL
;
2009 dont_repeat (); /* Not for the faint of heart */
2011 if (target_has_execution
)
2013 if (query ("A program is being debugged already. Kill it? "))
2016 error (_("Not killed."));
2019 /* Clean up any leftovers from other runs. Some other things from
2020 this function should probably be moved into target_pre_inferior. */
2021 target_pre_inferior (from_tty
);
2025 async_exec
= strip_bg_char (&args
);
2027 /* If we get a request for running in the bg but the target
2028 doesn't support it, error out. */
2029 if (async_exec
&& !target_can_async_p ())
2030 error (_("Asynchronous execution not supported on this target."));
2033 /* If we don't get a request of running in the bg, then we need
2034 to simulate synchronous (fg) execution. */
2035 if (!async_exec
&& target_can_async_p ())
2037 /* Simulate synchronous execution */
2038 async_disable_stdin ();
2041 target_attach (args
, from_tty
);
2043 /* Set up the "saved terminal modes" of the inferior
2044 based on what modes we are starting it with. */
2045 target_terminal_init ();
2047 /* Set up execution context to know that we should return from
2048 wait_for_inferior as soon as the target reports a stop. */
2049 init_wait_for_inferior ();
2050 clear_proceed_status ();
2052 /* Some system don't generate traps when attaching to inferior.
2053 E.g. Mach 3 or GNU hurd. */
2054 if (!target_attach_no_wait
)
2056 /* Careful here. See comments in inferior.h. Basically some
2057 OSes don't ignore SIGSTOPs on continue requests anymore. We
2058 need a way for handle_inferior_event to reset the stop_signal
2059 variable after an attach, and this is what
2060 STOP_QUIETLY_NO_SIGSTOP is for. */
2061 stop_soon
= STOP_QUIETLY_NO_SIGSTOP
;
2063 if (target_can_async_p ())
2065 /* sync_execution mode. Wait for stop. */
2066 struct attach_command_continuation_args
*a
;
2068 a
= xmalloc (sizeof (*a
));
2069 a
->args
= xstrdup (args
);
2070 a
->from_tty
= from_tty
;
2071 a
->async_exec
= async_exec
;
2072 add_continuation (attach_command_continuation
, a
,
2073 attach_command_continuation_free_args
);
2077 wait_for_inferior (0);
2080 attach_command_post_wait (args
, from_tty
, async_exec
);
2085 * takes a program previously attached to and detaches it.
2086 * The program resumes execution and will no longer stop
2087 * on signals, etc. We better not have left any breakpoints
2088 * in the program or it'll die when it hits one. For this
2089 * to work, it may be necessary for the process to have been
2090 * previously attached. It *might* work if the program was
2091 * started via the normal ptrace (PTRACE_TRACEME).
2095 detach_command (char *args
, int from_tty
)
2097 dont_repeat (); /* Not for the faint of heart. */
2098 target_detach (args
, from_tty
);
2099 no_shared_libraries (NULL
, from_tty
);
2100 init_thread_list ();
2101 if (deprecated_detach_hook
)
2102 deprecated_detach_hook ();
2105 /* Disconnect from the current target without resuming it (leaving it
2106 waiting for a debugger).
2108 We'd better not have left any breakpoints in the program or the
2109 next debugger will get confused. Currently only supported for some
2110 remote targets, since the normal attach mechanisms don't work on
2111 stopped processes on some native platforms (e.g. GNU/Linux). */
2114 disconnect_command (char *args
, int from_tty
)
2116 dont_repeat (); /* Not for the faint of heart */
2117 target_disconnect (args
, from_tty
);
2118 no_shared_libraries (NULL
, from_tty
);
2119 init_thread_list ();
2120 if (deprecated_detach_hook
)
2121 deprecated_detach_hook ();
2125 interrupt_target_1 (int all_threads
)
2129 ptid
= minus_one_ptid
;
2131 ptid
= inferior_ptid
;
2135 /* Stop the execution of the target while running in async mode, in
2136 the backgound. In all-stop, stop the whole process. In non-stop
2137 mode, stop the current thread only by default, or stop all threads
2138 if the `-a' switch is used. */
2140 /* interrupt [-a] */
2142 interrupt_target_command (char *args
, int from_tty
)
2144 if (target_can_async_p ())
2146 int all_threads
= 0;
2148 dont_repeat (); /* Not for the faint of heart */
2151 && strncmp (args
, "-a", sizeof ("-a") - 1) == 0)
2154 if (!non_stop
&& all_threads
)
2155 error (_("-a is meaningless in all-stop mode."));
2157 interrupt_target_1 (all_threads
);
2162 print_float_info (struct gdbarch
*gdbarch
, struct ui_file
*file
,
2163 struct frame_info
*frame
, const char *args
)
2165 if (gdbarch_print_float_info_p (gdbarch
))
2166 gdbarch_print_float_info (gdbarch
, file
, frame
, args
);
2170 int printed_something
= 0;
2173 regnum
< gdbarch_num_regs (gdbarch
)
2174 + gdbarch_num_pseudo_regs (gdbarch
);
2177 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, float_reggroup
))
2179 printed_something
= 1;
2180 gdbarch_print_registers_info (gdbarch
, file
, frame
, regnum
, 1);
2183 if (!printed_something
)
2184 fprintf_filtered (file
, "\
2185 No floating-point info available for this processor.\n");
2190 float_info (char *args
, int from_tty
)
2192 if (!target_has_registers
)
2193 error (_("The program has no registers now."));
2195 print_float_info (current_gdbarch
, gdb_stdout
,
2196 get_selected_frame (NULL
), args
);
2200 unset_command (char *args
, int from_tty
)
2202 printf_filtered (_("\
2203 \"unset\" must be followed by the name of an unset subcommand.\n"));
2204 help_list (unsetlist
, "unset ", -1, gdb_stdout
);
2208 _initialize_infcmd (void)
2210 struct cmd_list_element
*c
= NULL
;
2212 /* add the filename of the terminal connected to inferior I/O */
2213 add_setshow_filename_cmd ("inferior-tty", class_run
,
2214 &inferior_io_terminal
, _("\
2215 Set terminal for future runs of program being debugged."), _("\
2216 Show terminal for future runs of program being debugged."), _("\
2217 Usage: set inferior-tty /dev/pts/1"), NULL
, NULL
, &setlist
, &showlist
);
2218 add_com_alias ("tty", "set inferior-tty", class_alias
, 0);
2220 add_setshow_optional_filename_cmd ("args", class_run
,
2221 &inferior_args
, _("\
2222 Set argument list to give program being debugged when it is started."), _("\
2223 Show argument list to give program being debugged when it is started."), _("\
2224 Follow this command with any number of args, to be passed to the program."),
2227 &setlist
, &showlist
);
2229 c
= add_cmd ("environment", no_class
, environment_info
, _("\
2230 The environment to give the program, or one variable's value.\n\
2231 With an argument VAR, prints the value of environment variable VAR to\n\
2232 give the program being debugged. With no arguments, prints the entire\n\
2233 environment to be given to the program."), &showlist
);
2234 set_cmd_completer (c
, noop_completer
);
2236 add_prefix_cmd ("unset", no_class
, unset_command
,
2237 _("Complement to certain \"set\" commands."),
2238 &unsetlist
, "unset ", 0, &cmdlist
);
2240 c
= add_cmd ("environment", class_run
, unset_environment_command
, _("\
2241 Cancel environment variable VAR for the program.\n\
2242 This does not affect the program until the next \"run\" command."),
2244 set_cmd_completer (c
, noop_completer
);
2246 c
= add_cmd ("environment", class_run
, set_environment_command
, _("\
2247 Set environment variable value to give the program.\n\
2248 Arguments are VAR VALUE where VAR is variable name and VALUE is value.\n\
2249 VALUES of environment variables are uninterpreted strings.\n\
2250 This does not affect the program until the next \"run\" command."),
2252 set_cmd_completer (c
, noop_completer
);
2254 c
= add_com ("path", class_files
, path_command
, _("\
2255 Add directory DIR(s) to beginning of search path for object files.\n\
2256 $cwd in the path means the current working directory.\n\
2257 This path is equivalent to the $PATH shell variable. It is a list of\n\
2258 directories, separated by colons. These directories are searched to find\n\
2259 fully linked executable files and separately compiled object files as needed."));
2260 set_cmd_completer (c
, filename_completer
);
2262 c
= add_cmd ("paths", no_class
, path_info
, _("\
2263 Current search path for finding object files.\n\
2264 $cwd in the path means the current working directory.\n\
2265 This path is equivalent to the $PATH shell variable. It is a list of\n\
2266 directories, separated by colons. These directories are searched to find\n\
2267 fully linked executable files and separately compiled object files as needed."),
2269 set_cmd_completer (c
, noop_completer
);
2271 add_com ("attach", class_run
, attach_command
, _("\
2272 Attach to a process or file outside of GDB.\n\
2273 This command attaches to another target, of the same type as your last\n\
2274 \"target\" command (\"info files\" will show your target stack).\n\
2275 The command may take as argument a process id or a device file.\n\
2276 For a process id, you must have permission to send the process a signal,\n\
2277 and it must have the same effective uid as the debugger.\n\
2278 When using \"attach\" with a process id, the debugger finds the\n\
2279 program running in the process, looking first in the current working\n\
2280 directory, or (if not found there) using the source file search path\n\
2281 (see the \"directory\" command). You can also use the \"file\" command\n\
2282 to specify the program, and to load its symbol table."));
2284 add_prefix_cmd ("detach", class_run
, detach_command
, _("\
2285 Detach a process or file previously attached.\n\
2286 If a process, it is no longer traced, and it continues its execution. If\n\
2287 you were debugging a file, the file is closed and gdb no longer accesses it."),
2288 &detachlist
, "detach ", 0, &cmdlist
);
2290 add_com ("disconnect", class_run
, disconnect_command
, _("\
2291 Disconnect from a target.\n\
2292 The target will wait for another debugger to connect. Not available for\n\
2295 add_com ("signal", class_run
, signal_command
, _("\
2296 Continue program giving it signal specified by the argument.\n\
2297 An argument of \"0\" means continue program without giving it a signal."));
2299 add_com ("stepi", class_run
, stepi_command
, _("\
2300 Step one instruction exactly.\n\
2301 Argument N means do this N times (or till program stops for another reason)."));
2302 add_com_alias ("si", "stepi", class_alias
, 0);
2304 add_com ("nexti", class_run
, nexti_command
, _("\
2305 Step one instruction, but proceed through subroutine calls.\n\
2306 Argument N means do this N times (or till program stops for another reason)."));
2307 add_com_alias ("ni", "nexti", class_alias
, 0);
2309 add_com ("finish", class_run
, finish_command
, _("\
2310 Execute until selected stack frame returns.\n\
2311 Upon return, the value returned is printed and put in the value history."));
2312 add_com_alias ("fin", "finish", class_run
, 1);
2314 add_com ("next", class_run
, next_command
, _("\
2315 Step program, proceeding through subroutine calls.\n\
2316 Like the \"step\" command as long as subroutine calls do not happen;\n\
2317 when they do, the call is treated as one instruction.\n\
2318 Argument N means do this N times (or till program stops for another reason)."));
2319 add_com_alias ("n", "next", class_run
, 1);
2321 add_com_alias ("S", "next", class_run
, 1);
2323 add_com ("step", class_run
, step_command
, _("\
2324 Step program until it reaches a different source line.\n\
2325 Argument N means do this N times (or till program stops for another reason)."));
2326 add_com_alias ("s", "step", class_run
, 1);
2328 c
= add_com ("until", class_run
, until_command
, _("\
2329 Execute until the program reaches a source line greater than the current\n\
2330 or a specified location (same args as break command) within the current frame."));
2331 set_cmd_completer (c
, location_completer
);
2332 add_com_alias ("u", "until", class_run
, 1);
2334 c
= add_com ("advance", class_run
, advance_command
, _("\
2335 Continue the program up to the given location (same form as args for break command).\n\
2336 Execution will also stop upon exit from the current stack frame."));
2337 set_cmd_completer (c
, location_completer
);
2339 c
= add_com ("jump", class_run
, jump_command
, _("\
2340 Continue program being debugged at specified line or address.\n\
2341 Give as argument either LINENUM or *ADDR, where ADDR is an expression\n\
2342 for an address to start at."));
2343 set_cmd_completer (c
, location_completer
);
2347 c
= add_com ("go", class_run
, go_command
, _("\
2348 Usage: go <location>\n\
2349 Continue program being debugged, stopping at specified line or \n\
2351 Give as argument either LINENUM or *ADDR, where ADDR is an \n\
2352 expression for an address to start at.\n\
2353 This command is a combination of tbreak and jump."));
2354 set_cmd_completer (c
, location_completer
);
2358 add_com_alias ("g", "go", class_run
, 1);
2360 c
= add_com ("continue", class_run
, continue_command
, _("\
2361 Continue program being debugged, after signal or breakpoint.\n\
2362 If proceeding from breakpoint, a number N may be used as an argument,\n\
2363 which means to set the ignore count of that breakpoint to N - 1 (so that\n\
2364 the breakpoint won't break until the Nth time it is reached).\n\
2366 If non-stop mode is enabled, continue only the current thread,\n\
2367 otherwise all the threads in the program are continued. To \n\
2368 continue all stopped threads in non-stop mode, use the -a option.\n\
2369 Specifying -a and an ignore count simultaneously is an error."));
2370 add_com_alias ("c", "cont", class_run
, 1);
2371 add_com_alias ("fg", "cont", class_run
, 1);
2373 c
= add_com ("run", class_run
, run_command
, _("\
2374 Start debugged program. You may specify arguments to give it.\n\
2375 Args may include \"*\", or \"[...]\"; they are expanded using \"sh\".\n\
2376 Input and output redirection with \">\", \"<\", or \">>\" are also allowed.\n\n\
2377 With no arguments, uses arguments last specified (with \"run\" or \"set args\").\n\
2378 To cancel previous arguments and run with no arguments,\n\
2379 use \"set args\" without arguments."));
2380 set_cmd_completer (c
, filename_completer
);
2381 add_com_alias ("r", "run", class_run
, 1);
2383 add_com ("R", class_run
, run_no_args_command
,
2384 _("Start debugged program with no arguments."));
2386 c
= add_com ("start", class_run
, start_command
, _("\
2387 Run the debugged program until the beginning of the main procedure.\n\
2388 You may specify arguments to give to your program, just as with the\n\
2389 \"run\" command."));
2390 set_cmd_completer (c
, filename_completer
);
2392 c
= add_com ("interrupt", class_run
, interrupt_target_command
,
2393 _("Interrupt the execution of the debugged program.\n\
2394 If non-stop mode is enabled, interrupt only the current thread,\n\
2395 otherwise all the threads in the program are stopped. To \n\
2396 interrupt all running threads in non-stop mode, use the -a option."));
2398 add_info ("registers", nofp_registers_info
, _("\
2399 List of integer registers and their contents, for selected stack frame.\n\
2400 Register name as argument means describe only that register."));
2401 add_info_alias ("r", "registers", 1);
2404 add_com ("lr", class_info
, nofp_registers_info
, _("\
2405 List of integer registers and their contents, for selected stack frame.\n\
2406 Register name as argument means describe only that register."));
2407 add_info ("all-registers", all_registers_info
, _("\
2408 List of all registers and their contents, for selected stack frame.\n\
2409 Register name as argument means describe only that register."));
2411 add_info ("program", program_info
,
2412 _("Execution status of the program."));
2414 add_info ("float", float_info
,
2415 _("Print the status of the floating point unit\n"));
2417 add_info ("vector", vector_info
,
2418 _("Print the status of the vector unit\n"));
2420 inferior_environ
= make_environ ();
2421 init_environ (inferior_environ
);