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 /* If stepping, nonzero means step count is > 1
181 so don't print frame next time inferior stops
182 if it stops due to stepping. */
186 /* Environment to use for running inferior,
187 in format described in environ.h. */
189 struct gdb_environ
*inferior_environ
;
191 /* When set, no calls to target_resumed observer will be made. */
192 int suppress_resume_observer
= 0;
193 /* When set, normal_stop will not call the normal_stop observer. */
194 int suppress_stop_observer
= 0;
196 /* Accessor routines. */
199 set_inferior_io_terminal (const char *terminal_name
)
201 if (inferior_io_terminal
)
202 xfree (inferior_io_terminal
);
205 inferior_io_terminal
= NULL
;
207 inferior_io_terminal
= savestring (terminal_name
, strlen (terminal_name
));
211 get_inferior_io_terminal (void)
213 return inferior_io_terminal
;
217 get_inferior_args (void)
219 if (inferior_argc
!= 0)
223 n
= gdbarch_construct_inferior_arguments (current_gdbarch
,
224 inferior_argc
, inferior_argv
);
225 old
= set_inferior_args (n
);
229 if (inferior_args
== NULL
)
230 inferior_args
= xstrdup ("");
232 return inferior_args
;
236 set_inferior_args (char *newargs
)
238 char *saved_args
= inferior_args
;
240 inferior_args
= newargs
;
248 set_inferior_args_vector (int argc
, char **argv
)
250 inferior_argc
= argc
;
251 inferior_argv
= argv
;
254 /* Notice when `set args' is run. */
256 notice_args_set (char *args
, int from_tty
, struct cmd_list_element
*c
)
262 /* Notice when `show args' is run. */
264 notice_args_read (struct ui_file
*file
, int from_tty
,
265 struct cmd_list_element
*c
, const char *value
)
267 /* Note that we ignore the passed-in value in favor of computing it
269 deprecated_show_value_hack (file
, from_tty
, c
, get_inferior_args ());
273 /* Compute command-line string given argument vector. This does the
274 same shell processing as fork_inferior. */
276 construct_inferior_arguments (struct gdbarch
*gdbarch
, int argc
, char **argv
)
280 if (STARTUP_WITH_SHELL
)
282 /* This holds all the characters considered special to the
283 typical Unix shells. We include `^' because the SunOS
284 /bin/sh treats it as a synonym for `|'. */
285 char *special
= "\"!#$&*()\\|[]{}<>?'\"`~^; \t\n";
290 /* We over-compute the size. It shouldn't matter. */
291 for (i
= 0; i
< argc
; ++i
)
292 length
+= 2 * strlen (argv
[i
]) + 1 + 2 * (argv
[i
][0] == '\0');
294 result
= (char *) xmalloc (length
);
297 for (i
= 0; i
< argc
; ++i
)
302 /* Need to handle empty arguments specially. */
303 if (argv
[i
][0] == '\0')
310 for (cp
= argv
[i
]; *cp
; ++cp
)
312 if (strchr (special
, *cp
) != NULL
)
322 /* In this case we can't handle arguments that contain spaces,
323 tabs, or newlines -- see breakup_args(). */
327 for (i
= 0; i
< argc
; ++i
)
329 char *cp
= strchr (argv
[i
], ' ');
331 cp
= strchr (argv
[i
], '\t');
333 cp
= strchr (argv
[i
], '\n');
335 error (_("can't handle command-line argument containing whitespace"));
336 length
+= strlen (argv
[i
]) + 1;
339 result
= (char *) xmalloc (length
);
341 for (i
= 0; i
< argc
; ++i
)
344 strcat (result
, " ");
345 strcat (result
, argv
[i
]);
353 /* This function detects whether or not a '&' character (indicating
354 background execution) has been added as *the last* of the arguments ARGS
355 of a command. If it has, it removes it and returns 1. Otherwise it
356 does nothing and returns 0. */
358 strip_bg_char (char **args
)
362 p
= strchr (*args
, '&');
366 if (p
== (*args
+ strlen (*args
) - 1))
368 if (strlen (*args
) > 1)
372 while (*p
== ' ' || *p
== '\t');
384 tty_command (char *file
, int from_tty
)
387 error_no_arg (_("terminal name for running target process"));
389 set_inferior_io_terminal (file
);
392 /* Common actions to take after creating any sort of inferior, by any
393 means (running, attaching, connecting, et cetera). The target
394 should be stopped. */
397 post_create_inferior (struct target_ops
*target
, int from_tty
)
399 /* Be sure we own the terminal in case write operations are performed. */
400 target_terminal_ours ();
402 /* If the target hasn't taken care of this already, do it now.
403 Targets which need to access registers during to_open,
404 to_create_inferior, or to_attach should do it earlier; but many
406 target_find_description ();
410 /* Sometimes the platform-specific hook loads initial shared
411 libraries, and sometimes it doesn't. Try to do so first, so
412 that we can add them with the correct value for FROM_TTY.
413 If we made all the inferior hook methods consistent,
414 this call could be removed. */
416 SOLIB_ADD (NULL
, from_tty
, target
, auto_solib_add
);
418 solib_add (NULL
, from_tty
, target
, auto_solib_add
);
421 /* Create the hooks to handle shared library load and unload
423 #ifdef SOLIB_CREATE_INFERIOR_HOOK
424 SOLIB_CREATE_INFERIOR_HOOK (PIDGET (inferior_ptid
));
426 solib_create_inferior_hook ();
430 observer_notify_inferior_created (target
, from_tty
);
433 /* Kill the inferior if already running. This function is designed
434 to be called when we are about to start the execution of the program
435 from the beginning. Ask the user to confirm that he wants to restart
436 the program being debugged when FROM_TTY is non-null. */
439 kill_if_already_running (int from_tty
)
441 if (! ptid_equal (inferior_ptid
, null_ptid
) && target_has_execution
)
443 /* Bail out before killing the program if we will not be able to
445 target_require_runnable ();
448 && !query ("The program being debugged has been started already.\n\
449 Start it from the beginning? "))
450 error (_("Program not restarted."));
452 no_shared_libraries (NULL
, from_tty
);
453 init_wait_for_inferior ();
457 /* Implement the "run" command. If TBREAK_AT_MAIN is set, then insert
458 a temporary breakpoint at the begining of the main program before
459 running the program. */
462 run_command_1 (char *args
, int from_tty
, int tbreak_at_main
)
468 kill_if_already_running (from_tty
);
469 clear_breakpoint_hit_counts ();
471 /* Clean up any leftovers from other runs. Some other things from
472 this function should probably be moved into target_pre_inferior. */
473 target_pre_inferior (from_tty
);
475 /* The comment here used to read, "The exec file is re-read every
476 time we do a generic_mourn_inferior, so we just have to worry
477 about the symbol file." The `generic_mourn_inferior' function
478 gets called whenever the program exits. However, suppose the
479 program exits, and *then* the executable file changes? We need
480 to check again here. Since reopen_exec_file doesn't do anything
481 if the timestamp hasn't changed, I don't see the harm. */
485 /* Insert the temporary breakpoint if a location was specified. */
487 tbreak_command (main_name (), 0);
489 exec_file
= (char *) get_exec_file (0);
491 if (non_stop
&& !target_supports_non_stop ())
492 error (_("The target does not support running in non-stop mode."));
494 /* We keep symbols from add-symbol-file, on the grounds that the
495 user might want to add some symbols before running the program
496 (right?). But sometimes (dynamic loading where the user manually
497 introduces the new symbols with add-symbol-file), the code which
498 the symbols describe does not persist between runs. Currently
499 the user has to manually nuke all symbols between runs if they
500 want them to go away (PR 2207). This is probably reasonable. */
504 if (target_can_async_p ())
505 async_disable_stdin ();
509 int async_exec
= strip_bg_char (&args
);
511 /* If we get a request for running in the bg but the target
512 doesn't support it, error out. */
513 if (async_exec
&& !target_can_async_p ())
514 error (_("Asynchronous execution not supported on this target."));
516 /* If we don't get a request of running in the bg, then we need
517 to simulate synchronous (fg) execution. */
518 if (!async_exec
&& target_can_async_p ())
520 /* Simulate synchronous execution */
521 async_disable_stdin ();
524 /* If there were other args, beside '&', process them. */
527 char *old_args
= set_inferior_args (xstrdup (args
));
534 ui_out_field_string (uiout
, NULL
, "Starting program");
535 ui_out_text (uiout
, ": ");
537 ui_out_field_string (uiout
, "execfile", exec_file
);
538 ui_out_spaces (uiout
, 1);
539 /* We call get_inferior_args() because we might need to compute
541 ui_out_field_string (uiout
, "infargs", get_inferior_args ());
542 ui_out_text (uiout
, "\n");
543 ui_out_flush (uiout
);
546 /* We call get_inferior_args() because we might need to compute
548 target_create_inferior (exec_file
, get_inferior_args (),
549 environ_vector (inferior_environ
), from_tty
);
551 /* Pass zero for FROM_TTY, because at this point the "run" command
552 has done its thing; now we are setting up the running program. */
553 post_create_inferior (¤t_target
, 0);
555 /* Start the target running. */
556 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_0
, 0);
561 run_command (char *args
, int from_tty
)
563 run_command_1 (args
, from_tty
, 0);
567 run_no_args_command (char *args
, int from_tty
)
569 char *old_args
= set_inferior_args (xstrdup (""));
574 /* Start the execution of the program up until the beginning of the main
578 start_command (char *args
, int from_tty
)
580 /* Some languages such as Ada need to search inside the program
581 minimal symbols for the location where to put the temporary
582 breakpoint before starting. */
583 if (!have_minimal_symbols ())
584 error (_("No symbol table loaded. Use the \"file\" command."));
586 /* Run the program until reaching the main procedure... */
587 run_command_1 (args
, from_tty
, 1);
591 proceed_thread_callback (struct thread_info
*thread
, void *arg
)
593 if (!is_stopped (thread
->ptid
))
596 context_switch_to (thread
->ptid
);
597 clear_proceed_status ();
598 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 0);
603 continue_1 (int all_threads
)
607 if (non_stop
&& all_threads
)
609 /* Don't error out if the current thread is running, because
610 there may be other stopped threads. */
611 struct cleanup
*old_chain
;
613 /* Backup current thread and selected frame. */
614 old_chain
= make_cleanup_restore_current_thread ();
616 iterate_over_threads (proceed_thread_callback
, NULL
);
618 /* Restore selected ptid. */
619 do_cleanups (old_chain
);
623 ensure_not_running ();
624 clear_proceed_status ();
625 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 0);
629 /* continue [-a] [proceed-count] [&] */
631 continue_command (char *args
, int from_tty
)
637 /* Find out whether we must run in the background. */
639 async_exec
= strip_bg_char (&args
);
641 /* If we must run in the background, but the target can't do it,
643 if (async_exec
&& !target_can_async_p ())
644 error (_("Asynchronous execution not supported on this target."));
646 /* If we are not asked to run in the bg, then prepare to run in the
647 foreground, synchronously. */
648 if (!async_exec
&& target_can_async_p ())
650 /* Simulate synchronous execution */
651 async_disable_stdin ();
656 if (strncmp (args
, "-a", sizeof ("-a") - 1) == 0)
659 args
+= sizeof ("-a") - 1;
665 if (!non_stop
&& all_threads
)
666 error (_("`-a' is meaningless in all-stop mode."));
668 if (args
!= NULL
&& all_threads
)
670 Can't resume all threads and specify proceed count simultaneously."));
672 /* If we have an argument left, set proceed count of breakpoint we
676 bpstat bs
= stop_bpstat
;
680 while ((stat
= bpstat_num (&bs
, &num
)) != 0)
683 set_ignore_count (num
,
684 parse_and_eval_long (args
) - 1,
686 /* set_ignore_count prints a message ending with a period.
687 So print two spaces before "Continuing.". */
689 printf_filtered (" ");
693 if (!stopped
&& from_tty
)
696 ("Not stopped at any breakpoint; argument ignored.\n");
701 printf_filtered (_("Continuing.\n"));
703 continue_1 (all_threads
);
706 /* Step until outside of current statement. */
709 step_command (char *count_string
, int from_tty
)
711 step_1 (0, 0, count_string
);
714 /* Likewise, but skip over subroutine calls as if single instructions. */
717 next_command (char *count_string
, int from_tty
)
719 step_1 (1, 0, count_string
);
722 /* Likewise, but step only one instruction. */
725 stepi_command (char *count_string
, int from_tty
)
727 step_1 (0, 1, count_string
);
731 nexti_command (char *count_string
, int from_tty
)
733 step_1 (1, 1, count_string
);
737 delete_longjmp_breakpoint_cleanup (void *arg
)
739 int thread
= * (int *) arg
;
740 delete_longjmp_breakpoint (thread
);
744 step_1 (int skip_subroutines
, int single_inst
, char *count_string
)
747 struct frame_info
*frame
;
748 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
753 ensure_not_running ();
756 async_exec
= strip_bg_char (&count_string
);
758 /* If we get a request for running in the bg but the target
759 doesn't support it, error out. */
760 if (async_exec
&& !target_can_async_p ())
761 error (_("Asynchronous execution not supported on this target."));
763 /* If we don't get a request of running in the bg, then we need
764 to simulate synchronous (fg) execution. */
765 if (!async_exec
&& target_can_async_p ())
767 /* Simulate synchronous execution */
768 async_disable_stdin ();
771 count
= count_string
? parse_and_eval_long (count_string
) : 1;
773 if (!single_inst
|| skip_subroutines
) /* leave si command alone */
775 if (in_thread_list (inferior_ptid
))
776 thread
= pid_to_thread_id (inferior_ptid
);
778 set_longjmp_breakpoint ();
780 make_cleanup (delete_longjmp_breakpoint_cleanup
, &thread
);
783 /* In synchronous case, all is well, just use the regular for loop. */
784 if (!target_can_async_p ())
786 for (; count
> 0; count
--)
788 struct thread_info
*tp
= inferior_thread ();
789 clear_proceed_status ();
791 frame
= get_current_frame ();
792 tp
->step_frame_id
= get_frame_id (frame
);
796 find_pc_line_pc_range (stop_pc
,
797 &tp
->step_range_start
, &tp
->step_range_end
);
798 if (tp
->step_range_end
== 0)
801 if (find_pc_partial_function (stop_pc
, &name
,
802 &tp
->step_range_start
,
803 &tp
->step_range_end
) == 0)
804 error (_("Cannot find bounds of current function"));
806 target_terminal_ours ();
807 printf_filtered (_("\
808 Single stepping until exit from function %s, \n\
809 which has no line number information.\n"), name
);
814 /* Say we are stepping, but stop after one insn whatever it does. */
815 tp
->step_range_start
= tp
->step_range_end
= 1;
816 if (!skip_subroutines
)
818 Don't step over function calls, not even to functions lacking
820 tp
->step_over_calls
= STEP_OVER_NONE
;
823 if (skip_subroutines
)
824 tp
->step_over_calls
= STEP_OVER_ALL
;
826 step_multi
= (count
> 1);
827 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 1);
833 do_cleanups (cleanups
);
836 /* In case of asynchronous target things get complicated, do only
837 one step for now, before returning control to the event loop. Let
838 the continuation figure out how many other steps we need to do,
839 and handle them one at the time, through step_once(). */
842 step_once (skip_subroutines
, single_inst
, count
, thread
);
843 /* We are running, and the continuation is installed. It will
844 disable the longjmp breakpoint as appropriate. */
845 discard_cleanups (cleanups
);
849 struct step_1_continuation_args
852 int skip_subroutines
;
857 /* Called after we are done with one step operation, to check whether
858 we need to step again, before we print the prompt and return control
859 to the user. If count is > 1, we will need to do one more call to
860 proceed(), via step_once(). Basically it is like step_once and
861 step_1_continuation are co-recursive. */
863 step_1_continuation (void *args
)
865 struct step_1_continuation_args
*a
= args
;
867 if (!step_multi
|| !stop_step
)
869 /* If we stopped for some reason that is not stepping there are
870 no further steps to make. Cleanup. */
871 if (!a
->single_inst
|| a
->skip_subroutines
)
872 delete_longjmp_breakpoint (a
->thread
);
876 step_once (a
->skip_subroutines
, a
->single_inst
, a
->count
- 1, a
->thread
);
879 /* Do just one step operation. If count >1 we will have to set up a
880 continuation to be done after the target stops (after this one
881 step). This is useful to implement the 'step n' kind of commands, in
882 case of asynchronous targets. We had to split step_1 into two parts,
883 one to be done before proceed() and one afterwards. This function is
884 called in case of step n with n>1, after the first step operation has
887 step_once (int skip_subroutines
, int single_inst
, int count
, int thread
)
889 struct frame_info
*frame
;
890 struct step_1_continuation_args
*args
;
894 /* Don't assume THREAD is a valid thread id. It is set to -1 if
895 the longjmp breakpoint was not required. Use the
896 INFERIOR_PTID thread instead, which is the same thread when
898 struct thread_info
*tp
= inferior_thread ();
899 clear_proceed_status ();
901 frame
= get_current_frame ();
902 if (!frame
) /* Avoid coredump here. Why tho? */
903 error (_("No current frame"));
904 tp
->step_frame_id
= get_frame_id (frame
);
908 find_pc_line_pc_range (stop_pc
,
909 &tp
->step_range_start
, &tp
->step_range_end
);
911 /* If we have no line info, switch to stepi mode. */
912 if (tp
->step_range_end
== 0 && step_stop_if_no_debug
)
914 tp
->step_range_start
= tp
->step_range_end
= 1;
916 else if (tp
->step_range_end
== 0)
919 if (find_pc_partial_function (stop_pc
, &name
,
920 &tp
->step_range_start
,
921 &tp
->step_range_end
) == 0)
922 error (_("Cannot find bounds of current function"));
924 target_terminal_ours ();
925 printf_filtered (_("\
926 Single stepping until exit from function %s, \n\
927 which has no line number information.\n"), name
);
932 /* Say we are stepping, but stop after one insn whatever it does. */
933 tp
->step_range_start
= tp
->step_range_end
= 1;
934 if (!skip_subroutines
)
936 Don't step over function calls, not even to functions lacking
938 tp
->step_over_calls
= STEP_OVER_NONE
;
941 if (skip_subroutines
)
942 tp
->step_over_calls
= STEP_OVER_ALL
;
944 step_multi
= (count
> 1);
945 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 1);
947 args
= xmalloc (sizeof (*args
));
948 args
->skip_subroutines
= skip_subroutines
;
949 args
->single_inst
= single_inst
;
951 args
->thread
= thread
;
952 add_intermediate_continuation (step_1_continuation
, args
, xfree
);
957 /* Continue program at specified address. */
960 jump_command (char *arg
, int from_tty
)
963 struct symtabs_and_lines sals
;
964 struct symtab_and_line sal
;
970 ensure_not_running ();
972 /* Find out whether we must run in the background. */
974 async_exec
= strip_bg_char (&arg
);
976 /* If we must run in the background, but the target can't do it,
978 if (async_exec
&& !target_can_async_p ())
979 error (_("Asynchronous execution not supported on this target."));
982 error_no_arg (_("starting address"));
984 sals
= decode_line_spec_1 (arg
, 1);
987 error (_("Unreasonable jump request"));
993 if (sal
.symtab
== 0 && sal
.pc
== 0)
994 error (_("No source file has been specified."));
996 resolve_sal_pc (&sal
); /* May error out */
998 /* See if we are trying to jump to another function. */
999 fn
= get_frame_function (get_current_frame ());
1000 sfn
= find_pc_function (sal
.pc
);
1001 if (fn
!= NULL
&& sfn
!= fn
)
1003 if (!query ("Line %d is not in `%s'. Jump anyway? ", sal
.line
,
1004 SYMBOL_PRINT_NAME (fn
)))
1006 error (_("Not confirmed."));
1013 fixup_symbol_section (sfn
, 0);
1014 if (section_is_overlay (SYMBOL_OBJ_SECTION (sfn
)) &&
1015 !section_is_mapped (SYMBOL_OBJ_SECTION (sfn
)))
1017 if (!query ("WARNING!!! Destination is in unmapped overlay! Jump anyway? "))
1019 error (_("Not confirmed."));
1029 printf_filtered (_("Continuing at "));
1030 fputs_filtered (paddress (addr
), gdb_stdout
);
1031 printf_filtered (".\n");
1034 /* If we are not asked to run in the bg, then prepare to run in the
1035 foreground, synchronously. */
1036 if (!async_exec
&& target_can_async_p ())
1038 /* Simulate synchronous execution */
1039 async_disable_stdin ();
1042 clear_proceed_status ();
1043 proceed (addr
, TARGET_SIGNAL_0
, 0);
1047 /* Go to line or address in current procedure */
1049 go_command (char *line_no
, int from_tty
)
1051 if (line_no
== (char *) NULL
|| !*line_no
)
1052 printf_filtered (GO_USAGE
);
1055 tbreak_command (line_no
, from_tty
);
1056 jump_command (line_no
, from_tty
);
1061 /* Continue program giving it specified signal. */
1064 signal_command (char *signum_exp
, int from_tty
)
1066 enum target_signal oursig
;
1069 dont_repeat (); /* Too dangerous. */
1071 ensure_not_running ();
1073 /* Find out whether we must run in the background. */
1074 if (signum_exp
!= NULL
)
1075 async_exec
= strip_bg_char (&signum_exp
);
1077 /* If we must run in the background, but the target can't do it,
1079 if (async_exec
&& !target_can_async_p ())
1080 error (_("Asynchronous execution not supported on this target."));
1082 /* If we are not asked to run in the bg, then prepare to run in the
1083 foreground, synchronously. */
1084 if (!async_exec
&& target_can_async_p ())
1086 /* Simulate synchronous execution. */
1087 async_disable_stdin ();
1091 error_no_arg (_("signal number"));
1093 /* It would be even slicker to make signal names be valid expressions,
1094 (the type could be "enum $signal" or some such), then the user could
1095 assign them to convenience variables. */
1096 oursig
= target_signal_from_name (signum_exp
);
1098 if (oursig
== TARGET_SIGNAL_UNKNOWN
)
1100 /* No, try numeric. */
1101 int num
= parse_and_eval_long (signum_exp
);
1104 oursig
= TARGET_SIGNAL_0
;
1106 oursig
= target_signal_from_command (num
);
1111 if (oursig
== TARGET_SIGNAL_0
)
1112 printf_filtered (_("Continuing with no signal.\n"));
1114 printf_filtered (_("Continuing with signal %s.\n"),
1115 target_signal_to_name (oursig
));
1118 clear_proceed_status ();
1119 /* "signal 0" should not get stuck if we are stopped at a breakpoint.
1120 FIXME: Neither should "signal foo" but when I tried passing
1121 (CORE_ADDR)-1 unconditionally I got a testsuite failure which I haven't
1122 tried to track down yet. */
1123 proceed (oursig
== TARGET_SIGNAL_0
? (CORE_ADDR
) -1 : stop_pc
, oursig
, 0);
1126 /* Proceed until we reach a different source line with pc greater than
1127 our current one or exit the function. We skip calls in both cases.
1129 Note that eventually this command should probably be changed so
1130 that only source lines are printed out when we hit the breakpoint
1131 we set. This may involve changes to wait_for_inferior and the
1132 proceed status code. */
1135 until_next_command (int from_tty
)
1137 struct frame_info
*frame
;
1139 struct symbol
*func
;
1140 struct symtab_and_line sal
;
1141 struct thread_info
*tp
= inferior_thread ();
1143 clear_proceed_status ();
1145 frame
= get_current_frame ();
1147 /* Step until either exited from this function or greater
1148 than the current line (if in symbolic section) or pc (if
1152 func
= find_pc_function (pc
);
1156 struct minimal_symbol
*msymbol
= lookup_minimal_symbol_by_pc (pc
);
1158 if (msymbol
== NULL
)
1159 error (_("Execution is not within a known function."));
1161 tp
->step_range_start
= SYMBOL_VALUE_ADDRESS (msymbol
);
1162 tp
->step_range_end
= pc
;
1166 sal
= find_pc_line (pc
, 0);
1168 tp
->step_range_start
= BLOCK_START (SYMBOL_BLOCK_VALUE (func
));
1169 tp
->step_range_end
= sal
.end
;
1172 tp
->step_over_calls
= STEP_OVER_ALL
;
1173 tp
->step_frame_id
= get_frame_id (frame
);
1175 step_multi
= 0; /* Only one call to proceed */
1177 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 1);
1181 until_command (char *arg
, int from_tty
)
1185 if (!target_has_execution
)
1186 error (_("The program is not running."));
1188 /* Find out whether we must run in the background. */
1190 async_exec
= strip_bg_char (&arg
);
1192 /* If we must run in the background, but the target can't do it,
1194 if (async_exec
&& !target_can_async_p ())
1195 error (_("Asynchronous execution not supported on this target."));
1197 /* If we are not asked to run in the bg, then prepare to run in the
1198 foreground, synchronously. */
1199 if (!async_exec
&& target_can_async_p ())
1201 /* Simulate synchronous execution */
1202 async_disable_stdin ();
1206 until_break_command (arg
, from_tty
, 0);
1208 until_next_command (from_tty
);
1212 advance_command (char *arg
, int from_tty
)
1216 if (!target_has_execution
)
1217 error (_("The program is not running."));
1220 error_no_arg (_("a location"));
1222 /* Find out whether we must run in the background. */
1224 async_exec
= strip_bg_char (&arg
);
1226 /* If we must run in the background, but the target can't do it,
1228 if (async_exec
&& !target_can_async_p ())
1229 error (_("Asynchronous execution not supported on this target."));
1231 /* If we are not asked to run in the bg, then prepare to run in the
1232 foreground, synchronously. */
1233 if (!async_exec
&& target_can_async_p ())
1235 /* Simulate synchronous execution. */
1236 async_disable_stdin ();
1239 until_break_command (arg
, from_tty
, 1);
1242 /* Print the result of a function at the end of a 'finish' command. */
1245 print_return_value (struct type
*func_type
, struct type
*value_type
)
1247 struct gdbarch
*gdbarch
= current_gdbarch
;
1248 struct cleanup
*old_chain
;
1249 struct ui_stream
*stb
;
1250 struct value
*value
;
1252 CHECK_TYPEDEF (value_type
);
1253 gdb_assert (TYPE_CODE (value_type
) != TYPE_CODE_VOID
);
1255 /* FIXME: 2003-09-27: When returning from a nested inferior function
1256 call, it's possible (with no help from the architecture vector)
1257 to locate and return/print a "struct return" value. This is just
1258 a more complicated case of what is already being done in in the
1259 inferior function call code. In fact, when inferior function
1260 calls are made async, this will likely be made the norm. */
1262 switch (gdbarch_return_value (gdbarch
, func_type
, value_type
,
1265 case RETURN_VALUE_REGISTER_CONVENTION
:
1266 case RETURN_VALUE_ABI_RETURNS_ADDRESS
:
1267 case RETURN_VALUE_ABI_PRESERVES_ADDRESS
:
1268 value
= allocate_value (value_type
);
1269 gdbarch_return_value (gdbarch
, func_type
, value_type
, stop_registers
,
1270 value_contents_raw (value
), NULL
);
1272 case RETURN_VALUE_STRUCT_CONVENTION
:
1276 internal_error (__FILE__
, __LINE__
, _("bad switch"));
1282 stb
= ui_out_stream_new (uiout
);
1283 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
1284 ui_out_text (uiout
, "Value returned is ");
1285 ui_out_field_fmt (uiout
, "gdb-result-var", "$%d",
1286 record_latest_value (value
));
1287 ui_out_text (uiout
, " = ");
1288 value_print (value
, stb
->stream
, 0, Val_no_prettyprint
);
1289 ui_out_field_stream (uiout
, "return-value", stb
);
1290 ui_out_text (uiout
, "\n");
1291 do_cleanups (old_chain
);
1295 ui_out_text (uiout
, "Value returned has type: ");
1296 ui_out_field_string (uiout
, "return-type", TYPE_NAME (value_type
));
1297 ui_out_text (uiout
, ".");
1298 ui_out_text (uiout
, " Cannot determine contents\n");
1302 /* Stuff that needs to be done by the finish command after the target
1303 has stopped. In asynchronous mode, we wait for the target to stop
1304 in the call to poll or select in the event loop, so it is
1305 impossible to do all the stuff as part of the finish_command
1306 function itself. The only chance we have to complete this command
1307 is in fetch_inferior_event, which is called by the event loop as
1308 soon as it detects that the target has stopped. This function is
1309 called via the cmd_continuation pointer. */
1311 struct finish_command_continuation_args
1313 struct breakpoint
*breakpoint
;
1314 struct symbol
*function
;
1318 finish_command_continuation (void *arg
)
1320 struct finish_command_continuation_args
*a
= arg
;
1322 if (bpstat_find_breakpoint (stop_bpstat
, a
->breakpoint
) != NULL
1323 && a
->function
!= NULL
)
1325 struct type
*value_type
;
1327 value_type
= TYPE_TARGET_TYPE (SYMBOL_TYPE (a
->function
));
1329 internal_error (__FILE__
, __LINE__
,
1330 _("finish_command: function has no target type"));
1332 if (TYPE_CODE (value_type
) != TYPE_CODE_VOID
)
1333 print_return_value (SYMBOL_TYPE (a
->function
), value_type
);
1336 /* We suppress normal call of normal_stop observer and do it here so
1337 that that *stopped notification includes the return value. */
1338 /* NOTE: This is broken in non-stop mode. There is no guarantee the
1339 next stop will be in the same thread that we started doing a
1340 finish on. This suppressing (or some other replacement means)
1341 should be a thread property. */
1342 observer_notify_normal_stop (stop_bpstat
);
1343 suppress_stop_observer
= 0;
1344 delete_breakpoint (a
->breakpoint
);
1348 finish_command_continuation_free_arg (void *arg
)
1350 /* NOTE: See finish_command_continuation. This would go away, if
1351 this suppressing is made a thread property. */
1352 suppress_stop_observer
= 0;
1356 /* "finish": Set a temporary breakpoint at the place the selected
1357 frame will return to, then continue. */
1360 finish_command (char *arg
, int from_tty
)
1362 struct symtab_and_line sal
;
1363 struct frame_info
*frame
;
1364 struct symbol
*function
;
1365 struct breakpoint
*breakpoint
;
1366 struct cleanup
*old_chain
;
1367 struct finish_command_continuation_args
*cargs
;
1371 /* Find out whether we must run in the background. */
1373 async_exec
= strip_bg_char (&arg
);
1375 /* If we must run in the background, but the target can't do it,
1377 if (async_exec
&& !target_can_async_p ())
1378 error (_("Asynchronous execution not supported on this target."));
1380 /* If we are not asked to run in the bg, then prepare to run in the
1381 foreground, synchronously. */
1382 if (!async_exec
&& target_can_async_p ())
1384 /* Simulate synchronous execution. */
1385 async_disable_stdin ();
1389 error (_("The \"finish\" command does not take any arguments."));
1390 if (!target_has_execution
)
1391 error (_("The program is not running."));
1393 frame
= get_prev_frame (get_selected_frame (_("No selected frame.")));
1395 error (_("\"finish\" not meaningful in the outermost frame."));
1397 clear_proceed_status ();
1399 sal
= find_pc_line (get_frame_pc (frame
), 0);
1400 sal
.pc
= get_frame_pc (frame
);
1402 breakpoint
= set_momentary_breakpoint (sal
, get_frame_id (frame
), bp_finish
);
1404 old_chain
= make_cleanup_delete_breakpoint (breakpoint
);
1406 /* Find the function we will return from. */
1408 function
= find_pc_function (get_frame_pc (get_selected_frame (NULL
)));
1410 /* Print info on the selected frame, including level number but not
1414 printf_filtered (_("Run till exit from "));
1415 print_stack_frame (get_selected_frame (NULL
), 1, LOCATION
);
1418 proceed_to_finish
= 1; /* We want stop_registers, please... */
1419 make_cleanup_restore_integer (&suppress_stop_observer
);
1420 suppress_stop_observer
= 1;
1421 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 0);
1423 cargs
= xmalloc (sizeof (*cargs
));
1425 cargs
->breakpoint
= breakpoint
;
1426 cargs
->function
= function
;
1427 add_continuation (finish_command_continuation
, cargs
,
1428 finish_command_continuation_free_arg
);
1430 discard_cleanups (old_chain
);
1431 if (!target_can_async_p ())
1432 do_all_continuations ();
1437 program_info (char *args
, int from_tty
)
1439 bpstat bs
= stop_bpstat
;
1441 int stat
= bpstat_num (&bs
, &num
);
1443 if (!target_has_execution
)
1445 printf_filtered (_("The program being debugged is not being run.\n"));
1449 target_files_info ();
1450 printf_filtered (_("Program stopped at %s.\n"),
1451 hex_string ((unsigned long) stop_pc
));
1453 printf_filtered (_("It stopped after being stepped.\n"));
1456 /* There may be several breakpoints in the same place, so this
1457 isn't as strange as it seems. */
1462 printf_filtered (_("\
1463 It stopped at a breakpoint that has since been deleted.\n"));
1466 printf_filtered (_("It stopped at breakpoint %d.\n"), num
);
1467 stat
= bpstat_num (&bs
, &num
);
1470 else if (stop_signal
!= TARGET_SIGNAL_0
)
1472 printf_filtered (_("It stopped with signal %s, %s.\n"),
1473 target_signal_to_name (stop_signal
),
1474 target_signal_to_string (stop_signal
));
1479 printf_filtered (_("\
1480 Type \"info stack\" or \"info registers\" for more information.\n"));
1485 environment_info (char *var
, int from_tty
)
1489 char *val
= get_in_environ (inferior_environ
, var
);
1492 puts_filtered (var
);
1493 puts_filtered (" = ");
1494 puts_filtered (val
);
1495 puts_filtered ("\n");
1499 puts_filtered ("Environment variable \"");
1500 puts_filtered (var
);
1501 puts_filtered ("\" not defined.\n");
1506 char **vector
= environ_vector (inferior_environ
);
1509 puts_filtered (*vector
++);
1510 puts_filtered ("\n");
1516 set_environment_command (char *arg
, int from_tty
)
1518 char *p
, *val
, *var
;
1522 error_no_arg (_("environment variable and value"));
1524 /* Find seperation between variable name and value */
1525 p
= (char *) strchr (arg
, '=');
1526 val
= (char *) strchr (arg
, ' ');
1528 if (p
!= 0 && val
!= 0)
1530 /* We have both a space and an equals. If the space is before the
1531 equals, walk forward over the spaces til we see a nonspace
1532 (possibly the equals). */
1537 /* Now if the = is after the char following the spaces,
1538 take the char following the spaces. */
1542 else if (val
!= 0 && p
== 0)
1546 error_no_arg (_("environment variable to set"));
1548 if (p
== 0 || p
[1] == 0)
1552 p
= arg
+ strlen (arg
); /* So that savestring below will work */
1556 /* Not setting variable value to null */
1558 while (*val
== ' ' || *val
== '\t')
1562 while (p
!= arg
&& (p
[-1] == ' ' || p
[-1] == '\t'))
1565 var
= savestring (arg
, p
- arg
);
1568 printf_filtered (_("\
1569 Setting environment variable \"%s\" to null value.\n"),
1571 set_in_environ (inferior_environ
, var
, "");
1574 set_in_environ (inferior_environ
, var
, val
);
1579 unset_environment_command (char *var
, int from_tty
)
1583 /* If there is no argument, delete all environment variables.
1584 Ask for confirmation if reading from the terminal. */
1585 if (!from_tty
|| query (_("Delete all environment variables? ")))
1587 free_environ (inferior_environ
);
1588 inferior_environ
= make_environ ();
1592 unset_in_environ (inferior_environ
, var
);
1595 /* Handle the execution path (PATH variable) */
1597 static const char path_var_name
[] = "PATH";
1600 path_info (char *args
, int from_tty
)
1602 puts_filtered ("Executable and object file path: ");
1603 puts_filtered (get_in_environ (inferior_environ
, path_var_name
));
1604 puts_filtered ("\n");
1607 /* Add zero or more directories to the front of the execution path. */
1610 path_command (char *dirname
, int from_tty
)
1615 env
= get_in_environ (inferior_environ
, path_var_name
);
1616 /* Can be null if path is not set */
1619 exec_path
= xstrdup (env
);
1620 mod_path (dirname
, &exec_path
);
1621 set_in_environ (inferior_environ
, path_var_name
, exec_path
);
1624 path_info ((char *) NULL
, from_tty
);
1628 /* Print out the machine register regnum. If regnum is -1, print all
1629 registers (print_all == 1) or all non-float and non-vector
1630 registers (print_all == 0).
1632 For most machines, having all_registers_info() print the
1633 register(s) one per line is good enough. If a different format is
1634 required, (eg, for MIPS or Pyramid 90x, which both have lots of
1635 regs), or there is an existing convention for showing all the
1636 registers, define the architecture method PRINT_REGISTERS_INFO to
1637 provide that format. */
1640 default_print_registers_info (struct gdbarch
*gdbarch
,
1641 struct ui_file
*file
,
1642 struct frame_info
*frame
,
1643 int regnum
, int print_all
)
1646 const int numregs
= gdbarch_num_regs (gdbarch
)
1647 + gdbarch_num_pseudo_regs (gdbarch
);
1648 gdb_byte buffer
[MAX_REGISTER_SIZE
];
1650 for (i
= 0; i
< numregs
; i
++)
1652 /* Decide between printing all regs, non-float / vector regs, or
1658 if (!gdbarch_register_reggroup_p (gdbarch
, i
, all_reggroup
))
1663 if (!gdbarch_register_reggroup_p (gdbarch
, i
, general_reggroup
))
1673 /* If the register name is empty, it is undefined for this
1674 processor, so don't display anything. */
1675 if (gdbarch_register_name (gdbarch
, i
) == NULL
1676 || *(gdbarch_register_name (gdbarch
, i
)) == '\0')
1679 fputs_filtered (gdbarch_register_name (gdbarch
, i
), file
);
1680 print_spaces_filtered (15 - strlen (gdbarch_register_name
1681 (gdbarch
, i
)), file
);
1683 /* Get the data in raw format. */
1684 if (! frame_register_read (frame
, i
, buffer
))
1686 fprintf_filtered (file
, "*value not available*\n");
1690 /* If virtual format is floating, print it that way, and in raw
1692 if (TYPE_CODE (register_type (gdbarch
, i
)) == TYPE_CODE_FLT
1693 || TYPE_CODE (register_type (gdbarch
, i
)) == TYPE_CODE_DECFLOAT
)
1697 val_print (register_type (gdbarch
, i
), buffer
, 0, 0,
1698 file
, 0, 1, 0, Val_pretty_default
, current_language
);
1700 fprintf_filtered (file
, "\t(raw 0x");
1701 for (j
= 0; j
< register_size (gdbarch
, i
); j
++)
1704 if (gdbarch_byte_order (gdbarch
) == BFD_ENDIAN_BIG
)
1707 idx
= register_size (gdbarch
, i
) - 1 - j
;
1708 fprintf_filtered (file
, "%02x", (unsigned char) buffer
[idx
]);
1710 fprintf_filtered (file
, ")");
1714 /* Print the register in hex. */
1715 val_print (register_type (gdbarch
, i
), buffer
, 0, 0,
1716 file
, 'x', 1, 0, Val_pretty_default
, current_language
);
1717 /* If not a vector register, print it also according to its
1719 if (TYPE_VECTOR (register_type (gdbarch
, i
)) == 0)
1721 fprintf_filtered (file
, "\t");
1722 val_print (register_type (gdbarch
, i
), buffer
, 0, 0,
1723 file
, 0, 1, 0, Val_pretty_default
, current_language
);
1727 fprintf_filtered (file
, "\n");
1732 registers_info (char *addr_exp
, int fpregs
)
1734 struct frame_info
*frame
;
1735 struct gdbarch
*gdbarch
;
1736 int regnum
, numregs
;
1739 if (!target_has_registers
)
1740 error (_("The program has no registers now."));
1741 frame
= get_selected_frame (NULL
);
1742 gdbarch
= get_frame_arch (frame
);
1746 gdbarch_print_registers_info (gdbarch
, gdb_stdout
,
1751 while (*addr_exp
!= '\0')
1756 /* Keep skipping leading white space. */
1757 if (isspace ((*addr_exp
)))
1763 /* Discard any leading ``$''. Check that there is something
1764 resembling a register following it. */
1765 if (addr_exp
[0] == '$')
1767 if (isspace ((*addr_exp
)) || (*addr_exp
) == '\0')
1768 error (_("Missing register name"));
1770 /* Find the start/end of this register name/num/group. */
1772 while ((*addr_exp
) != '\0' && !isspace ((*addr_exp
)))
1776 /* Figure out what we've found and display it. */
1778 /* A register name? */
1780 int regnum
= user_reg_map_name_to_regnum (gdbarch
, start
, end
- start
);
1783 /* User registers lie completely outside of the range of
1784 normal registers. Catch them early so that the target
1786 if (regnum
>= gdbarch_num_regs (gdbarch
)
1787 + gdbarch_num_pseudo_regs (gdbarch
))
1789 struct value
*val
= value_of_user_reg (regnum
, frame
);
1791 printf_filtered ("%s: ", start
);
1792 print_scalar_formatted (value_contents (val
),
1793 check_typedef (value_type (val
)),
1794 'x', 0, gdb_stdout
);
1795 printf_filtered ("\n");
1798 gdbarch_print_registers_info (gdbarch
, gdb_stdout
,
1799 frame
, regnum
, fpregs
);
1804 /* A register number? (how portable is this one?). */
1807 int regnum
= strtol (start
, &endptr
, 0);
1810 && regnum
< gdbarch_num_regs (gdbarch
)
1811 + gdbarch_num_pseudo_regs (gdbarch
))
1813 gdbarch_print_registers_info (gdbarch
, gdb_stdout
,
1814 frame
, regnum
, fpregs
);
1819 /* A register group? */
1821 struct reggroup
*group
;
1822 for (group
= reggroup_next (gdbarch
, NULL
);
1824 group
= reggroup_next (gdbarch
, group
))
1826 /* Don't bother with a length check. Should the user
1827 enter a short register group name, go with the first
1828 group that matches. */
1829 if (strncmp (start
, reggroup_name (group
), end
- start
) == 0)
1836 regnum
< gdbarch_num_regs (gdbarch
)
1837 + gdbarch_num_pseudo_regs (gdbarch
);
1840 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, group
))
1841 gdbarch_print_registers_info (gdbarch
,
1849 /* Nothing matched. */
1850 error (_("Invalid register `%.*s'"), (int) (end
- start
), start
);
1855 all_registers_info (char *addr_exp
, int from_tty
)
1857 registers_info (addr_exp
, 1);
1861 nofp_registers_info (char *addr_exp
, int from_tty
)
1863 registers_info (addr_exp
, 0);
1867 print_vector_info (struct gdbarch
*gdbarch
, struct ui_file
*file
,
1868 struct frame_info
*frame
, const char *args
)
1870 if (gdbarch_print_vector_info_p (gdbarch
))
1871 gdbarch_print_vector_info (gdbarch
, file
, frame
, args
);
1875 int printed_something
= 0;
1878 regnum
< gdbarch_num_regs (gdbarch
)
1879 + gdbarch_num_pseudo_regs (gdbarch
);
1882 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, vector_reggroup
))
1884 printed_something
= 1;
1885 gdbarch_print_registers_info (gdbarch
, file
, frame
, regnum
, 1);
1888 if (!printed_something
)
1889 fprintf_filtered (file
, "No vector information\n");
1894 vector_info (char *args
, int from_tty
)
1896 if (!target_has_registers
)
1897 error (_("The program has no registers now."));
1899 print_vector_info (current_gdbarch
, gdb_stdout
,
1900 get_selected_frame (NULL
), args
);
1906 * Should save/restore the tty state since it might be that the
1907 * program to be debugged was started on this tty and it wants
1908 * the tty in some state other than what we want. If it's running
1909 * on another terminal or without a terminal, then saving and
1910 * restoring the tty state is a harmless no-op.
1911 * This only needs to be done if we are attaching to a process.
1916 takes a program started up outside of gdb and ``attaches'' to it.
1917 This stops it cold in its tracks and allows us to start debugging it.
1918 and wait for the trace-trap that results from attaching. */
1921 attach_command_post_wait (char *args
, int from_tty
, int async_exec
)
1924 char *full_exec_path
= NULL
;
1926 stop_soon
= NO_STOP_QUIETLY
;
1928 /* If no exec file is yet known, try to determine it from the
1930 exec_file
= (char *) get_exec_file (0);
1933 exec_file
= target_pid_to_exec_file (PIDGET (inferior_ptid
));
1936 /* It's possible we don't have a full path, but rather just a
1937 filename. Some targets, such as HP-UX, don't provide the
1940 Attempt to qualify the filename against the source path.
1941 (If that fails, we'll just fall back on the original
1942 filename. Not much more we can do...)
1944 if (!source_full_path_of (exec_file
, &full_exec_path
))
1945 full_exec_path
= savestring (exec_file
, strlen (exec_file
));
1947 exec_file_attach (full_exec_path
, from_tty
);
1948 symbol_file_add_main (full_exec_path
, from_tty
);
1953 reopen_exec_file ();
1957 /* Take any necessary post-attaching actions for this platform. */
1958 target_post_attach (PIDGET (inferior_ptid
));
1960 post_create_inferior (¤t_target
, from_tty
);
1962 /* Install inferior's terminal modes. */
1963 target_terminal_inferior ();
1966 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_0
, 0);
1969 if (target_can_async_p ())
1970 async_enable_stdin ();
1972 if (deprecated_attach_hook
)
1973 deprecated_attach_hook ();
1977 struct attach_command_continuation_args
1985 attach_command_continuation (void *args
)
1987 struct attach_command_continuation_args
*a
= args
;
1988 attach_command_post_wait (a
->args
, a
->from_tty
, a
->async_exec
);
1992 attach_command_continuation_free_args (void *args
)
1994 struct attach_command_continuation_args
*a
= args
;
2000 attach_command (char *args
, int from_tty
)
2003 char *full_exec_path
= NULL
;
2006 dont_repeat (); /* Not for the faint of heart */
2008 if (target_has_execution
)
2010 if (query ("A program is being debugged already. Kill it? "))
2013 error (_("Not killed."));
2016 /* Clean up any leftovers from other runs. Some other things from
2017 this function should probably be moved into target_pre_inferior. */
2018 target_pre_inferior (from_tty
);
2020 if (non_stop
&& !target_supports_non_stop ())
2021 error (_("Cannot attach to this target in non-stop mode"));
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
);