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 finish_command_continuation (void *args
, int error_p
);
78 static void until_next_command (int);
80 static void until_command (char *, int);
82 static void path_info (char *, int);
84 static void path_command (char *, int);
86 static void unset_command (char *, int);
88 static void float_info (char *, int);
90 static void detach_command (char *, int);
92 static void disconnect_command (char *, int);
94 static void unset_environment_command (char *, int);
96 static void set_environment_command (char *, int);
98 static void environment_info (char *, int);
100 static void program_info (char *, int);
102 static void finish_command (char *, int);
104 static void signal_command (char *, int);
106 static void jump_command (char *, int);
108 static void step_1 (int, int, char *);
109 static void step_once (int skip_subroutines
, int single_inst
, int count
, int thread
);
110 static void step_1_continuation (void *args
, int error_p
);
112 static void next_command (char *, int);
114 static void step_command (char *, int);
116 static void run_command (char *, int);
118 static void run_no_args_command (char *args
, int from_tty
);
120 static void go_command (char *line_no
, int from_tty
);
122 static int strip_bg_char (char **);
124 void _initialize_infcmd (void);
126 #define GO_USAGE "Usage: go <location>\n"
128 #define ERROR_NO_INFERIOR \
129 if (!target_has_execution) error (_("The program is not being run."));
131 /* String containing arguments to give to the program, separated by spaces.
132 Empty string (pointer to '\0') means no args. */
134 static char *inferior_args
;
136 /* The inferior arguments as a vector. If INFERIOR_ARGC is nonzero,
137 then we must compute INFERIOR_ARGS from this (via the target). */
139 static int inferior_argc
;
140 static char **inferior_argv
;
142 /* File name for default use for standard in/out in the inferior. */
144 static char *inferior_io_terminal
;
146 /* Pid of our debugged inferior, or 0 if no inferior now.
147 Since various parts of infrun.c test this to see whether there is a program
148 being debugged it should be nonzero (currently 3 is used) for remote
151 ptid_t inferior_ptid
;
153 /* Last signal that the inferior received (why it stopped). */
155 enum target_signal stop_signal
;
157 /* Address at which inferior stopped. */
161 /* Chain containing status of breakpoint(s) that we have stopped at. */
165 /* Flag indicating that a command has proceeded the inferior past the
166 current breakpoint. */
168 int breakpoint_proceeded
;
170 /* Nonzero if stopped due to a step command. */
174 /* Nonzero if stopped due to completion of a stack dummy routine. */
176 int stop_stack_dummy
;
178 /* Nonzero if stopped due to a random (unexpected) signal in inferior
181 int stopped_by_random_signal
;
183 /* Range to single step within.
184 If this is nonzero, respond to a single-step signal
185 by continuing to step if the pc is in this range. */
187 CORE_ADDR step_range_start
; /* Inclusive */
188 CORE_ADDR step_range_end
; /* Exclusive */
190 /* Stack frame address as of when stepping command was issued.
191 This is how we know when we step into a subroutine call,
192 and how to set the frame for the breakpoint used to step out. */
194 struct frame_id step_frame_id
;
196 enum step_over_calls_kind step_over_calls
;
198 /* If stepping, nonzero means step count is > 1
199 so don't print frame next time inferior stops
200 if it stops due to stepping. */
204 /* Environment to use for running inferior,
205 in format described in environ.h. */
207 struct gdb_environ
*inferior_environ
;
209 /* When set, no calls to target_resumed observer will be made. */
210 int suppress_resume_observer
= 0;
211 /* When set, normal_stop will not call the normal_stop observer. */
212 int suppress_stop_observer
= 0;
214 /* Accessor routines. */
217 set_inferior_io_terminal (const char *terminal_name
)
219 if (inferior_io_terminal
)
220 xfree (inferior_io_terminal
);
223 inferior_io_terminal
= NULL
;
225 inferior_io_terminal
= savestring (terminal_name
, strlen (terminal_name
));
229 get_inferior_io_terminal (void)
231 return inferior_io_terminal
;
235 get_inferior_args (void)
237 if (inferior_argc
!= 0)
241 n
= gdbarch_construct_inferior_arguments (current_gdbarch
,
242 inferior_argc
, inferior_argv
);
243 old
= set_inferior_args (n
);
247 if (inferior_args
== NULL
)
248 inferior_args
= xstrdup ("");
250 return inferior_args
;
254 set_inferior_args (char *newargs
)
256 char *saved_args
= inferior_args
;
258 inferior_args
= newargs
;
266 set_inferior_args_vector (int argc
, char **argv
)
268 inferior_argc
= argc
;
269 inferior_argv
= argv
;
272 /* Notice when `set args' is run. */
274 notice_args_set (char *args
, int from_tty
, struct cmd_list_element
*c
)
280 /* Notice when `show args' is run. */
282 notice_args_read (struct ui_file
*file
, int from_tty
,
283 struct cmd_list_element
*c
, const char *value
)
285 /* Note that we ignore the passed-in value in favor of computing it
287 deprecated_show_value_hack (file
, from_tty
, c
, get_inferior_args ());
291 /* Compute command-line string given argument vector. This does the
292 same shell processing as fork_inferior. */
294 construct_inferior_arguments (struct gdbarch
*gdbarch
, int argc
, char **argv
)
298 if (STARTUP_WITH_SHELL
)
300 /* This holds all the characters considered special to the
301 typical Unix shells. We include `^' because the SunOS
302 /bin/sh treats it as a synonym for `|'. */
303 char *special
= "\"!#$&*()\\|[]{}<>?'\"`~^; \t\n";
308 /* We over-compute the size. It shouldn't matter. */
309 for (i
= 0; i
< argc
; ++i
)
310 length
+= 2 * strlen (argv
[i
]) + 1 + 2 * (argv
[i
][0] == '\0');
312 result
= (char *) xmalloc (length
);
315 for (i
= 0; i
< argc
; ++i
)
320 /* Need to handle empty arguments specially. */
321 if (argv
[i
][0] == '\0')
328 for (cp
= argv
[i
]; *cp
; ++cp
)
330 if (strchr (special
, *cp
) != NULL
)
340 /* In this case we can't handle arguments that contain spaces,
341 tabs, or newlines -- see breakup_args(). */
345 for (i
= 0; i
< argc
; ++i
)
347 char *cp
= strchr (argv
[i
], ' ');
349 cp
= strchr (argv
[i
], '\t');
351 cp
= strchr (argv
[i
], '\n');
353 error (_("can't handle command-line argument containing whitespace"));
354 length
+= strlen (argv
[i
]) + 1;
357 result
= (char *) xmalloc (length
);
359 for (i
= 0; i
< argc
; ++i
)
362 strcat (result
, " ");
363 strcat (result
, argv
[i
]);
371 /* This function detects whether or not a '&' character (indicating
372 background execution) has been added as *the last* of the arguments ARGS
373 of a command. If it has, it removes it and returns 1. Otherwise it
374 does nothing and returns 0. */
376 strip_bg_char (char **args
)
380 p
= strchr (*args
, '&');
384 if (p
== (*args
+ strlen (*args
) - 1))
386 if (strlen (*args
) > 1)
390 while (*p
== ' ' || *p
== '\t');
402 tty_command (char *file
, int from_tty
)
405 error_no_arg (_("terminal name for running target process"));
407 set_inferior_io_terminal (file
);
410 /* Common actions to take after creating any sort of inferior, by any
411 means (running, attaching, connecting, et cetera). The target
412 should be stopped. */
415 post_create_inferior (struct target_ops
*target
, int from_tty
)
417 /* Be sure we own the terminal in case write operations are performed. */
418 target_terminal_ours ();
420 /* If the target hasn't taken care of this already, do it now.
421 Targets which need to access registers during to_open,
422 to_create_inferior, or to_attach should do it earlier; but many
424 target_find_description ();
428 /* Sometimes the platform-specific hook loads initial shared
429 libraries, and sometimes it doesn't. Try to do so first, so
430 that we can add them with the correct value for FROM_TTY.
431 If we made all the inferior hook methods consistent,
432 this call could be removed. */
434 SOLIB_ADD (NULL
, from_tty
, target
, auto_solib_add
);
436 solib_add (NULL
, from_tty
, target
, auto_solib_add
);
439 /* Create the hooks to handle shared library load and unload
441 #ifdef SOLIB_CREATE_INFERIOR_HOOK
442 SOLIB_CREATE_INFERIOR_HOOK (PIDGET (inferior_ptid
));
444 solib_create_inferior_hook ();
448 observer_notify_inferior_created (target
, from_tty
);
451 /* Kill the inferior if already running. This function is designed
452 to be called when we are about to start the execution of the program
453 from the beginning. Ask the user to confirm that he wants to restart
454 the program being debugged when FROM_TTY is non-null. */
457 kill_if_already_running (int from_tty
)
459 if (! ptid_equal (inferior_ptid
, null_ptid
) && target_has_execution
)
461 /* Bail out before killing the program if we will not be able to
463 target_require_runnable ();
466 && !query ("The program being debugged has been started already.\n\
467 Start it from the beginning? "))
468 error (_("Program not restarted."));
470 no_shared_libraries (NULL
, from_tty
);
471 init_wait_for_inferior ();
475 /* Implement the "run" command. If TBREAK_AT_MAIN is set, then insert
476 a temporary breakpoint at the begining of the main program before
477 running the program. */
480 run_command_1 (char *args
, int from_tty
, int tbreak_at_main
)
486 kill_if_already_running (from_tty
);
487 clear_breakpoint_hit_counts ();
489 /* Clean up any leftovers from other runs. Some other things from
490 this function should probably be moved into target_pre_inferior. */
491 target_pre_inferior (from_tty
);
493 /* Purge old solib objfiles. */
494 objfile_purge_solibs ();
498 /* The comment here used to read, "The exec file is re-read every
499 time we do a generic_mourn_inferior, so we just have to worry
500 about the symbol file." The `generic_mourn_inferior' function
501 gets called whenever the program exits. However, suppose the
502 program exits, and *then* the executable file changes? We need
503 to check again here. Since reopen_exec_file doesn't do anything
504 if the timestamp hasn't changed, I don't see the harm. */
508 /* Insert the temporary breakpoint if a location was specified. */
510 tbreak_command (main_name (), 0);
512 exec_file
= (char *) get_exec_file (0);
514 /* We keep symbols from add-symbol-file, on the grounds that the
515 user might want to add some symbols before running the program
516 (right?). But sometimes (dynamic loading where the user manually
517 introduces the new symbols with add-symbol-file), the code which
518 the symbols describe does not persist between runs. Currently
519 the user has to manually nuke all symbols between runs if they
520 want them to go away (PR 2207). This is probably reasonable. */
524 if (target_can_async_p ())
525 async_disable_stdin ();
529 int async_exec
= strip_bg_char (&args
);
531 /* If we get a request for running in the bg but the target
532 doesn't support it, error out. */
533 if (async_exec
&& !target_can_async_p ())
534 error (_("Asynchronous execution not supported on this target."));
536 /* If we don't get a request of running in the bg, then we need
537 to simulate synchronous (fg) execution. */
538 if (!async_exec
&& target_can_async_p ())
540 /* Simulate synchronous execution */
541 async_disable_stdin ();
544 /* If there were other args, beside '&', process them. */
547 char *old_args
= set_inferior_args (xstrdup (args
));
554 ui_out_field_string (uiout
, NULL
, "Starting program");
555 ui_out_text (uiout
, ": ");
557 ui_out_field_string (uiout
, "execfile", exec_file
);
558 ui_out_spaces (uiout
, 1);
559 /* We call get_inferior_args() because we might need to compute
561 ui_out_field_string (uiout
, "infargs", get_inferior_args ());
562 ui_out_text (uiout
, "\n");
563 ui_out_flush (uiout
);
566 /* We call get_inferior_args() because we might need to compute
568 target_create_inferior (exec_file
, get_inferior_args (),
569 environ_vector (inferior_environ
), from_tty
);
571 /* Pass zero for FROM_TTY, because at this point the "run" command
572 has done its thing; now we are setting up the running program. */
573 post_create_inferior (¤t_target
, 0);
575 /* Start the target running. */
576 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_0
, 0);
581 run_command (char *args
, int from_tty
)
583 run_command_1 (args
, from_tty
, 0);
587 run_no_args_command (char *args
, int from_tty
)
589 char *old_args
= set_inferior_args (xstrdup (""));
594 /* Start the execution of the program up until the beginning of the main
598 start_command (char *args
, int from_tty
)
600 /* Some languages such as Ada need to search inside the program
601 minimal symbols for the location where to put the temporary
602 breakpoint before starting. */
603 if (!have_minimal_symbols ())
604 error (_("No symbol table loaded. Use the \"file\" command."));
606 /* Run the program until reaching the main procedure... */
607 run_command_1 (args
, from_tty
, 1);
611 proceed_thread_callback (struct thread_info
*thread
, void *arg
)
613 if (!is_stopped (thread
->ptid
))
616 context_switch_to (thread
->ptid
);
617 clear_proceed_status ();
618 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 0);
623 continue_1 (int all_threads
)
625 if (non_stop
&& all_threads
)
627 /* Don't error out if the current thread is running, because
628 there may be other stopped threads. */
629 struct cleanup
*old_chain
;
631 /* Backup current thread and selected frame. */
632 old_chain
= make_cleanup_restore_current_thread ();
634 iterate_over_threads (proceed_thread_callback
, NULL
);
636 /* Restore selected ptid. */
637 do_cleanups (old_chain
);
641 ensure_not_running ();
642 clear_proceed_status ();
643 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 0);
647 /* continue [-a] [proceed-count] [&] */
649 continue_command (char *args
, int from_tty
)
655 /* Find out whether we must run in the background. */
657 async_exec
= strip_bg_char (&args
);
659 /* If we must run in the background, but the target can't do it,
661 if (async_exec
&& !target_can_async_p ())
662 error (_("Asynchronous execution not supported on this target."));
664 /* If we are not asked to run in the bg, then prepare to run in the
665 foreground, synchronously. */
666 if (!async_exec
&& target_can_async_p ())
668 /* Simulate synchronous execution */
669 async_disable_stdin ();
674 if (strncmp (args
, "-a", sizeof ("-a") - 1) == 0)
677 args
+= sizeof ("-a") - 1;
683 if (!non_stop
&& all_threads
)
684 error (_("`-a' is meaningless in all-stop mode."));
686 if (args
!= NULL
&& all_threads
)
688 Can't resume all threads and specify proceed count simultaneously."));
690 /* If we have an argument left, set proceed count of breakpoint we
694 bpstat bs
= stop_bpstat
;
698 while ((stat
= bpstat_num (&bs
, &num
)) != 0)
701 set_ignore_count (num
,
702 parse_and_eval_long (args
) - 1,
704 /* set_ignore_count prints a message ending with a period.
705 So print two spaces before "Continuing.". */
707 printf_filtered (" ");
711 if (!stopped
&& from_tty
)
714 ("Not stopped at any breakpoint; argument ignored.\n");
719 printf_filtered (_("Continuing.\n"));
721 continue_1 (all_threads
);
724 /* Step until outside of current statement. */
727 step_command (char *count_string
, int from_tty
)
729 step_1 (0, 0, count_string
);
732 /* Likewise, but skip over subroutine calls as if single instructions. */
735 next_command (char *count_string
, int from_tty
)
737 step_1 (1, 0, count_string
);
740 /* Likewise, but step only one instruction. */
743 stepi_command (char *count_string
, int from_tty
)
745 step_1 (0, 1, count_string
);
749 nexti_command (char *count_string
, int from_tty
)
751 step_1 (1, 1, count_string
);
755 delete_longjmp_breakpoint_cleanup (void *arg
)
757 int thread
= * (int *) arg
;
758 delete_longjmp_breakpoint (thread
);
762 step_1 (int skip_subroutines
, int single_inst
, char *count_string
)
765 struct frame_info
*frame
;
766 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
771 ensure_not_running ();
774 async_exec
= strip_bg_char (&count_string
);
776 /* If we get a request for running in the bg but the target
777 doesn't support it, error out. */
778 if (async_exec
&& !target_can_async_p ())
779 error (_("Asynchronous execution not supported on this target."));
781 /* If we don't get a request of running in the bg, then we need
782 to simulate synchronous (fg) execution. */
783 if (!async_exec
&& target_can_async_p ())
785 /* Simulate synchronous execution */
786 async_disable_stdin ();
789 count
= count_string
? parse_and_eval_long (count_string
) : 1;
791 if (!single_inst
|| skip_subroutines
) /* leave si command alone */
793 if (in_thread_list (inferior_ptid
))
794 thread
= pid_to_thread_id (inferior_ptid
);
796 set_longjmp_breakpoint ();
798 make_cleanup (delete_longjmp_breakpoint_cleanup
, &thread
);
801 /* In synchronous case, all is well, just use the regular for loop. */
802 if (!target_can_async_p ())
804 for (; count
> 0; count
--)
806 clear_proceed_status ();
808 frame
= get_current_frame ();
809 if (!frame
) /* Avoid coredump here. Why tho? */
810 error (_("No current frame"));
811 step_frame_id
= get_frame_id (frame
);
815 find_pc_line_pc_range (stop_pc
, &step_range_start
, &step_range_end
);
816 if (step_range_end
== 0)
819 if (find_pc_partial_function (stop_pc
, &name
, &step_range_start
,
820 &step_range_end
) == 0)
821 error (_("Cannot find bounds of current function"));
823 target_terminal_ours ();
824 printf_filtered (_("\
825 Single stepping until exit from function %s, \n\
826 which has no line number information.\n"), name
);
831 /* Say we are stepping, but stop after one insn whatever it does. */
832 step_range_start
= step_range_end
= 1;
833 if (!skip_subroutines
)
835 Don't step over function calls, not even to functions lacking
837 step_over_calls
= STEP_OVER_NONE
;
840 if (skip_subroutines
)
841 step_over_calls
= STEP_OVER_ALL
;
843 step_multi
= (count
> 1);
844 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 1);
850 do_cleanups (cleanups
);
853 /* In case of asynchronous target things get complicated, do only
854 one step for now, before returning control to the event loop. Let
855 the continuation figure out how many other steps we need to do,
856 and handle them one at the time, through step_once(). */
859 step_once (skip_subroutines
, single_inst
, count
, thread
);
860 /* We are running, and the continuation is installed. It will
861 disable the longjmp breakpoint as appropriate. */
862 discard_cleanups (cleanups
);
866 struct step_1_continuation_args
869 int skip_subroutines
;
874 /* Called after we are done with one step operation, to check whether
875 we need to step again, before we print the prompt and return control
876 to the user. If count is > 1, we will need to do one more call to
877 proceed(), via step_once(). Basically it is like step_once and
878 step_1_continuation are co-recursive. */
880 step_1_continuation (void *args
, int error_p
)
882 struct step_1_continuation_args
*a
= args
;
884 if (error_p
|| !step_multi
|| !stop_step
)
886 /* We either hit an error, or stopped for some reason
887 that is not stepping, or there are no further steps
889 if (!a
->single_inst
|| a
->skip_subroutines
)
890 delete_longjmp_breakpoint (a
->thread
);
894 step_once (a
->skip_subroutines
, a
->single_inst
, a
->count
- 1, a
->thread
);
897 /* Do just one step operation. If count >1 we will have to set up a
898 continuation to be done after the target stops (after this one
899 step). This is useful to implement the 'step n' kind of commands, in
900 case of asynchronous targets. We had to split step_1 into two parts,
901 one to be done before proceed() and one afterwards. This function is
902 called in case of step n with n>1, after the first step operation has
905 step_once (int skip_subroutines
, int single_inst
, int count
, int thread
)
907 struct frame_info
*frame
;
908 struct step_1_continuation_args
*args
;
912 clear_proceed_status ();
914 frame
= get_current_frame ();
915 if (!frame
) /* Avoid coredump here. Why tho? */
916 error (_("No current frame"));
917 step_frame_id
= get_frame_id (frame
);
921 find_pc_line_pc_range (stop_pc
, &step_range_start
, &step_range_end
);
923 /* If we have no line info, switch to stepi mode. */
924 if (step_range_end
== 0 && step_stop_if_no_debug
)
926 step_range_start
= step_range_end
= 1;
928 else if (step_range_end
== 0)
931 if (find_pc_partial_function (stop_pc
, &name
, &step_range_start
,
932 &step_range_end
) == 0)
933 error (_("Cannot find bounds of current function"));
935 target_terminal_ours ();
936 printf_filtered (_("\
937 Single stepping until exit from function %s, \n\
938 which has no line number information.\n"), name
);
943 /* Say we are stepping, but stop after one insn whatever it does. */
944 step_range_start
= step_range_end
= 1;
945 if (!skip_subroutines
)
947 Don't step over function calls, not even to functions lacking
949 step_over_calls
= STEP_OVER_NONE
;
952 if (skip_subroutines
)
953 step_over_calls
= STEP_OVER_ALL
;
955 step_multi
= (count
> 1);
956 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 1);
958 args
= xmalloc (sizeof (*args
));
959 args
->skip_subroutines
= skip_subroutines
;
960 args
->single_inst
= single_inst
;
962 args
->thread
= thread
;
963 add_intermediate_continuation (step_1_continuation
, args
);
968 /* Continue program at specified address. */
971 jump_command (char *arg
, int from_tty
)
974 struct symtabs_and_lines sals
;
975 struct symtab_and_line sal
;
981 ensure_not_running ();
983 /* Find out whether we must run in the background. */
985 async_exec
= strip_bg_char (&arg
);
987 /* If we must run in the background, but the target can't do it,
989 if (async_exec
&& !target_can_async_p ())
990 error (_("Asynchronous execution not supported on this target."));
993 error_no_arg (_("starting address"));
995 sals
= decode_line_spec_1 (arg
, 1);
998 error (_("Unreasonable jump request"));
1004 if (sal
.symtab
== 0 && sal
.pc
== 0)
1005 error (_("No source file has been specified."));
1007 resolve_sal_pc (&sal
); /* May error out */
1009 /* See if we are trying to jump to another function. */
1010 fn
= get_frame_function (get_current_frame ());
1011 sfn
= find_pc_function (sal
.pc
);
1012 if (fn
!= NULL
&& sfn
!= fn
)
1014 if (!query ("Line %d is not in `%s'. Jump anyway? ", sal
.line
,
1015 SYMBOL_PRINT_NAME (fn
)))
1017 error (_("Not confirmed."));
1024 fixup_symbol_section (sfn
, 0);
1025 if (section_is_overlay (SYMBOL_BFD_SECTION (sfn
)) &&
1026 !section_is_mapped (SYMBOL_BFD_SECTION (sfn
)))
1028 if (!query ("WARNING!!! Destination is in unmapped overlay! Jump anyway? "))
1030 error (_("Not confirmed."));
1040 printf_filtered (_("Continuing at "));
1041 fputs_filtered (paddress (addr
), gdb_stdout
);
1042 printf_filtered (".\n");
1045 /* If we are not asked to run in the bg, then prepare to run in the
1046 foreground, synchronously. */
1047 if (!async_exec
&& target_can_async_p ())
1049 /* Simulate synchronous execution */
1050 async_disable_stdin ();
1053 clear_proceed_status ();
1054 proceed (addr
, TARGET_SIGNAL_0
, 0);
1058 /* Go to line or address in current procedure */
1060 go_command (char *line_no
, int from_tty
)
1062 if (line_no
== (char *) NULL
|| !*line_no
)
1063 printf_filtered (GO_USAGE
);
1066 tbreak_command (line_no
, from_tty
);
1067 jump_command (line_no
, from_tty
);
1072 /* Continue program giving it specified signal. */
1075 signal_command (char *signum_exp
, int from_tty
)
1077 enum target_signal oursig
;
1080 dont_repeat (); /* Too dangerous. */
1082 ensure_not_running ();
1084 /* Find out whether we must run in the background. */
1085 if (signum_exp
!= NULL
)
1086 async_exec
= strip_bg_char (&signum_exp
);
1088 /* If we must run in the background, but the target can't do it,
1090 if (async_exec
&& !target_can_async_p ())
1091 error (_("Asynchronous execution not supported on this target."));
1093 /* If we are not asked to run in the bg, then prepare to run in the
1094 foreground, synchronously. */
1095 if (!async_exec
&& target_can_async_p ())
1097 /* Simulate synchronous execution. */
1098 async_disable_stdin ();
1102 error_no_arg (_("signal number"));
1104 /* It would be even slicker to make signal names be valid expressions,
1105 (the type could be "enum $signal" or some such), then the user could
1106 assign them to convenience variables. */
1107 oursig
= target_signal_from_name (signum_exp
);
1109 if (oursig
== TARGET_SIGNAL_UNKNOWN
)
1111 /* No, try numeric. */
1112 int num
= parse_and_eval_long (signum_exp
);
1115 oursig
= TARGET_SIGNAL_0
;
1117 oursig
= target_signal_from_command (num
);
1122 if (oursig
== TARGET_SIGNAL_0
)
1123 printf_filtered (_("Continuing with no signal.\n"));
1125 printf_filtered (_("Continuing with signal %s.\n"),
1126 target_signal_to_name (oursig
));
1129 clear_proceed_status ();
1130 /* "signal 0" should not get stuck if we are stopped at a breakpoint.
1131 FIXME: Neither should "signal foo" but when I tried passing
1132 (CORE_ADDR)-1 unconditionally I got a testsuite failure which I haven't
1133 tried to track down yet. */
1134 proceed (oursig
== TARGET_SIGNAL_0
? (CORE_ADDR
) -1 : stop_pc
, oursig
, 0);
1137 /* Proceed until we reach a different source line with pc greater than
1138 our current one or exit the function. We skip calls in both cases.
1140 Note that eventually this command should probably be changed so
1141 that only source lines are printed out when we hit the breakpoint
1142 we set. This may involve changes to wait_for_inferior and the
1143 proceed status code. */
1146 until_next_command (int from_tty
)
1148 struct frame_info
*frame
;
1150 struct symbol
*func
;
1151 struct symtab_and_line sal
;
1153 clear_proceed_status ();
1155 frame
= get_current_frame ();
1157 /* Step until either exited from this function or greater
1158 than the current line (if in symbolic section) or pc (if
1162 func
= find_pc_function (pc
);
1166 struct minimal_symbol
*msymbol
= lookup_minimal_symbol_by_pc (pc
);
1168 if (msymbol
== NULL
)
1169 error (_("Execution is not within a known function."));
1171 step_range_start
= SYMBOL_VALUE_ADDRESS (msymbol
);
1172 step_range_end
= pc
;
1176 sal
= find_pc_line (pc
, 0);
1178 step_range_start
= BLOCK_START (SYMBOL_BLOCK_VALUE (func
));
1179 step_range_end
= sal
.end
;
1182 step_over_calls
= STEP_OVER_ALL
;
1183 step_frame_id
= get_frame_id (frame
);
1185 step_multi
= 0; /* Only one call to proceed */
1187 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 1);
1191 until_command (char *arg
, int from_tty
)
1195 if (!target_has_execution
)
1196 error (_("The program is not running."));
1198 /* Find out whether we must run in the background. */
1200 async_exec
= strip_bg_char (&arg
);
1202 /* If we must run in the background, but the target can't do it,
1204 if (async_exec
&& !target_can_async_p ())
1205 error (_("Asynchronous execution not supported on this target."));
1207 /* If we are not asked to run in the bg, then prepare to run in the
1208 foreground, synchronously. */
1209 if (!async_exec
&& target_can_async_p ())
1211 /* Simulate synchronous execution */
1212 async_disable_stdin ();
1216 until_break_command (arg
, from_tty
, 0);
1218 until_next_command (from_tty
);
1222 advance_command (char *arg
, int from_tty
)
1226 if (!target_has_execution
)
1227 error (_("The program is not running."));
1230 error_no_arg (_("a location"));
1232 /* Find out whether we must run in the background. */
1234 async_exec
= strip_bg_char (&arg
);
1236 /* If we must run in the background, but the target can't do it,
1238 if (async_exec
&& !target_can_async_p ())
1239 error (_("Asynchronous execution not supported on this target."));
1241 /* If we are not asked to run in the bg, then prepare to run in the
1242 foreground, synchronously. */
1243 if (!async_exec
&& target_can_async_p ())
1245 /* Simulate synchronous execution. */
1246 async_disable_stdin ();
1249 until_break_command (arg
, from_tty
, 1);
1252 /* Print the result of a function at the end of a 'finish' command. */
1255 print_return_value (struct type
*func_type
, struct type
*value_type
)
1257 struct gdbarch
*gdbarch
= current_gdbarch
;
1258 struct cleanup
*old_chain
;
1259 struct ui_stream
*stb
;
1260 struct value
*value
;
1262 CHECK_TYPEDEF (value_type
);
1263 gdb_assert (TYPE_CODE (value_type
) != TYPE_CODE_VOID
);
1265 /* FIXME: 2003-09-27: When returning from a nested inferior function
1266 call, it's possible (with no help from the architecture vector)
1267 to locate and return/print a "struct return" value. This is just
1268 a more complicated case of what is already being done in in the
1269 inferior function call code. In fact, when inferior function
1270 calls are made async, this will likely be made the norm. */
1272 switch (gdbarch_return_value (gdbarch
, func_type
, value_type
,
1275 case RETURN_VALUE_REGISTER_CONVENTION
:
1276 case RETURN_VALUE_ABI_RETURNS_ADDRESS
:
1277 case RETURN_VALUE_ABI_PRESERVES_ADDRESS
:
1278 value
= allocate_value (value_type
);
1279 gdbarch_return_value (gdbarch
, func_type
, value_type
, stop_registers
,
1280 value_contents_raw (value
), NULL
);
1282 case RETURN_VALUE_STRUCT_CONVENTION
:
1286 internal_error (__FILE__
, __LINE__
, _("bad switch"));
1292 stb
= ui_out_stream_new (uiout
);
1293 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
1294 ui_out_text (uiout
, "Value returned is ");
1295 ui_out_field_fmt (uiout
, "gdb-result-var", "$%d",
1296 record_latest_value (value
));
1297 ui_out_text (uiout
, " = ");
1298 value_print (value
, stb
->stream
, 0, Val_no_prettyprint
);
1299 ui_out_field_stream (uiout
, "return-value", stb
);
1300 ui_out_text (uiout
, "\n");
1301 do_cleanups (old_chain
);
1305 ui_out_text (uiout
, "Value returned has type: ");
1306 ui_out_field_string (uiout
, "return-type", TYPE_NAME (value_type
));
1307 ui_out_text (uiout
, ".");
1308 ui_out_text (uiout
, " Cannot determine contents\n");
1312 /* Stuff that needs to be done by the finish command after the target
1313 has stopped. In asynchronous mode, we wait for the target to stop
1314 in the call to poll or select in the event loop, so it is
1315 impossible to do all the stuff as part of the finish_command
1316 function itself. The only chance we have to complete this command
1317 is in fetch_inferior_event, which is called by the event loop as
1318 soon as it detects that the target has stopped. This function is
1319 called via the cmd_continuation pointer. */
1321 struct finish_command_continuation_args
1323 struct breakpoint
*breakpoint
;
1324 struct symbol
*function
;
1328 finish_command_continuation (void *arg
, int error_p
)
1330 struct finish_command_continuation_args
*a
= arg
;
1334 if (bpstat_find_breakpoint (stop_bpstat
, a
->breakpoint
) != NULL
1335 && a
->function
!= NULL
)
1337 struct type
*value_type
;
1339 value_type
= TYPE_TARGET_TYPE (SYMBOL_TYPE (a
->function
));
1341 internal_error (__FILE__
, __LINE__
,
1342 _("finish_command: function has no target type"));
1344 if (TYPE_CODE (value_type
) != TYPE_CODE_VOID
)
1345 print_return_value (SYMBOL_TYPE (a
->function
), value_type
);
1348 /* We suppress normal call of normal_stop observer and do it here so that
1349 that *stopped notification includes the return value. */
1350 observer_notify_normal_stop (stop_bpstat
);
1353 suppress_stop_observer
= 0;
1354 delete_breakpoint (a
->breakpoint
);
1357 /* "finish": Set a temporary breakpoint at the place the selected
1358 frame will return to, then continue. */
1361 finish_command (char *arg
, int from_tty
)
1363 struct symtab_and_line sal
;
1364 struct frame_info
*frame
;
1365 struct symbol
*function
;
1366 struct breakpoint
*breakpoint
;
1367 struct cleanup
*old_chain
;
1368 struct finish_command_continuation_args
*cargs
;
1372 /* Find out whether we must run in the background. */
1374 async_exec
= strip_bg_char (&arg
);
1376 /* If we must run in the background, but the target can't do it,
1378 if (async_exec
&& !target_can_async_p ())
1379 error (_("Asynchronous execution not supported on this target."));
1381 /* If we are not asked to run in the bg, then prepare to run in the
1382 foreground, synchronously. */
1383 if (!async_exec
&& target_can_async_p ())
1385 /* Simulate synchronous execution. */
1386 async_disable_stdin ();
1390 error (_("The \"finish\" command does not take any arguments."));
1391 if (!target_has_execution
)
1392 error (_("The program is not running."));
1394 frame
= get_prev_frame (get_selected_frame (_("No selected frame.")));
1396 error (_("\"finish\" not meaningful in the outermost frame."));
1398 clear_proceed_status ();
1400 sal
= find_pc_line (get_frame_pc (frame
), 0);
1401 sal
.pc
= get_frame_pc (frame
);
1403 breakpoint
= set_momentary_breakpoint (sal
, get_frame_id (frame
), bp_finish
);
1405 old_chain
= make_cleanup_delete_breakpoint (breakpoint
);
1407 /* Find the function we will return from. */
1409 function
= find_pc_function (get_frame_pc (get_selected_frame (NULL
)));
1411 /* Print info on the selected frame, including level number but not
1415 printf_filtered (_("Run till exit from "));
1416 print_stack_frame (get_selected_frame (NULL
), 1, LOCATION
);
1419 proceed_to_finish
= 1; /* We want stop_registers, please... */
1420 make_cleanup_restore_integer (&suppress_stop_observer
);
1421 suppress_stop_observer
= 1;
1422 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 0);
1424 cargs
= xmalloc (sizeof (*cargs
));
1426 cargs
->breakpoint
= breakpoint
;
1427 cargs
->function
= function
;
1428 add_continuation (finish_command_continuation
, cargs
);
1430 discard_cleanups (old_chain
);
1431 if (!target_can_async_p ())
1432 do_all_continuations (0);
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
= frame_map_name_to_regnum (frame
, 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
, int error_p
)
1987 struct attach_command_continuation_args
*a
= args
;
1988 attach_command_post_wait (a
->args
, a
->from_tty
, a
->async_exec
);
1992 attach_command (char *args
, int from_tty
)
1995 char *full_exec_path
= NULL
;
1998 dont_repeat (); /* Not for the faint of heart */
2000 if (target_has_execution
)
2002 if (query ("A program is being debugged already. Kill it? "))
2005 error (_("Not killed."));
2008 /* Clean up any leftovers from other runs. Some other things from
2009 this function should probably be moved into target_pre_inferior. */
2010 target_pre_inferior (from_tty
);
2012 /* Clear out solib state. Otherwise the solib state of the previous
2013 inferior might have survived and is entirely wrong for the new
2014 target. This has been observed on GNU/Linux using glibc 2.3. How
2026 Cannot access memory at address 0xdeadbeef
2032 async_exec
= strip_bg_char (&args
);
2034 /* If we get a request for running in the bg but the target
2035 doesn't support it, error out. */
2036 if (async_exec
&& !target_can_async_p ())
2037 error (_("Asynchronous execution not supported on this target."));
2040 /* If we don't get a request of running in the bg, then we need
2041 to simulate synchronous (fg) execution. */
2042 if (!async_exec
&& target_can_async_p ())
2044 /* Simulate synchronous execution */
2045 async_disable_stdin ();
2048 target_attach (args
, from_tty
);
2050 /* Set up the "saved terminal modes" of the inferior
2051 based on what modes we are starting it with. */
2052 target_terminal_init ();
2054 /* Set up execution context to know that we should return from
2055 wait_for_inferior as soon as the target reports a stop. */
2056 init_wait_for_inferior ();
2057 clear_proceed_status ();
2059 /* Some system don't generate traps when attaching to inferior.
2060 E.g. Mach 3 or GNU hurd. */
2061 if (!target_attach_no_wait
)
2063 /* Careful here. See comments in inferior.h. Basically some
2064 OSes don't ignore SIGSTOPs on continue requests anymore. We
2065 need a way for handle_inferior_event to reset the stop_signal
2066 variable after an attach, and this is what
2067 STOP_QUIETLY_NO_SIGSTOP is for. */
2068 stop_soon
= STOP_QUIETLY_NO_SIGSTOP
;
2070 if (target_can_async_p ())
2072 /* sync_execution mode. Wait for stop. */
2073 struct attach_command_continuation_args
*a
;
2075 a
= xmalloc (sizeof (*a
));
2076 a
->args
= xstrdup (args
);
2077 a
->from_tty
= from_tty
;
2078 a
->async_exec
= async_exec
;
2079 add_continuation (attach_command_continuation
, a
);
2083 wait_for_inferior (0);
2086 attach_command_post_wait (args
, from_tty
, async_exec
);
2091 * takes a program previously attached to and detaches it.
2092 * The program resumes execution and will no longer stop
2093 * on signals, etc. We better not have left any breakpoints
2094 * in the program or it'll die when it hits one. For this
2095 * to work, it may be necessary for the process to have been
2096 * previously attached. It *might* work if the program was
2097 * started via the normal ptrace (PTRACE_TRACEME).
2101 detach_command (char *args
, int from_tty
)
2103 dont_repeat (); /* Not for the faint of heart. */
2104 target_detach (args
, from_tty
);
2105 no_shared_libraries (NULL
, from_tty
);
2106 init_thread_list ();
2107 if (deprecated_detach_hook
)
2108 deprecated_detach_hook ();
2111 /* Disconnect from the current target without resuming it (leaving it
2112 waiting for a debugger).
2114 We'd better not have left any breakpoints in the program or the
2115 next debugger will get confused. Currently only supported for some
2116 remote targets, since the normal attach mechanisms don't work on
2117 stopped processes on some native platforms (e.g. GNU/Linux). */
2120 disconnect_command (char *args
, int from_tty
)
2122 dont_repeat (); /* Not for the faint of heart */
2123 target_disconnect (args
, from_tty
);
2124 no_shared_libraries (NULL
, from_tty
);
2125 init_thread_list ();
2126 if (deprecated_detach_hook
)
2127 deprecated_detach_hook ();
2131 interrupt_target_1 (int all_threads
)
2135 ptid
= minus_one_ptid
;
2137 ptid
= inferior_ptid
;
2141 /* Stop the execution of the target while running in async mode, in
2142 the backgound. In all-stop, stop the whole process. In non-stop
2143 mode, stop the current thread only by default, or stop all threads
2144 if the `-a' switch is used. */
2146 /* interrupt [-a] */
2148 interrupt_target_command (char *args
, int from_tty
)
2150 if (target_can_async_p ())
2152 int all_threads
= 0;
2154 dont_repeat (); /* Not for the faint of heart */
2157 && strncmp (args
, "-a", sizeof ("-a") - 1) == 0)
2160 if (!non_stop
&& all_threads
)
2161 error (_("-a is meaningless in all-stop mode."));
2163 interrupt_target_1 (all_threads
);
2168 print_float_info (struct gdbarch
*gdbarch
, struct ui_file
*file
,
2169 struct frame_info
*frame
, const char *args
)
2171 if (gdbarch_print_float_info_p (gdbarch
))
2172 gdbarch_print_float_info (gdbarch
, file
, frame
, args
);
2176 int printed_something
= 0;
2179 regnum
< gdbarch_num_regs (gdbarch
)
2180 + gdbarch_num_pseudo_regs (gdbarch
);
2183 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, float_reggroup
))
2185 printed_something
= 1;
2186 gdbarch_print_registers_info (gdbarch
, file
, frame
, regnum
, 1);
2189 if (!printed_something
)
2190 fprintf_filtered (file
, "\
2191 No floating-point info available for this processor.\n");
2196 float_info (char *args
, int from_tty
)
2198 if (!target_has_registers
)
2199 error (_("The program has no registers now."));
2201 print_float_info (current_gdbarch
, gdb_stdout
,
2202 get_selected_frame (NULL
), args
);
2206 unset_command (char *args
, int from_tty
)
2208 printf_filtered (_("\
2209 \"unset\" must be followed by the name of an unset subcommand.\n"));
2210 help_list (unsetlist
, "unset ", -1, gdb_stdout
);
2214 _initialize_infcmd (void)
2216 struct cmd_list_element
*c
= NULL
;
2218 /* add the filename of the terminal connected to inferior I/O */
2219 add_setshow_filename_cmd ("inferior-tty", class_run
,
2220 &inferior_io_terminal
, _("\
2221 Set terminal for future runs of program being debugged."), _("\
2222 Show terminal for future runs of program being debugged."), _("\
2223 Usage: set inferior-tty /dev/pts/1"), NULL
, NULL
, &setlist
, &showlist
);
2224 add_com_alias ("tty", "set inferior-tty", class_alias
, 0);
2226 add_setshow_optional_filename_cmd ("args", class_run
,
2227 &inferior_args
, _("\
2228 Set argument list to give program being debugged when it is started."), _("\
2229 Show argument list to give program being debugged when it is started."), _("\
2230 Follow this command with any number of args, to be passed to the program."),
2233 &setlist
, &showlist
);
2235 c
= add_cmd ("environment", no_class
, environment_info
, _("\
2236 The environment to give the program, or one variable's value.\n\
2237 With an argument VAR, prints the value of environment variable VAR to\n\
2238 give the program being debugged. With no arguments, prints the entire\n\
2239 environment to be given to the program."), &showlist
);
2240 set_cmd_completer (c
, noop_completer
);
2242 add_prefix_cmd ("unset", no_class
, unset_command
,
2243 _("Complement to certain \"set\" commands."),
2244 &unsetlist
, "unset ", 0, &cmdlist
);
2246 c
= add_cmd ("environment", class_run
, unset_environment_command
, _("\
2247 Cancel environment variable VAR for the program.\n\
2248 This does not affect the program until the next \"run\" command."),
2250 set_cmd_completer (c
, noop_completer
);
2252 c
= add_cmd ("environment", class_run
, set_environment_command
, _("\
2253 Set environment variable value to give the program.\n\
2254 Arguments are VAR VALUE where VAR is variable name and VALUE is value.\n\
2255 VALUES of environment variables are uninterpreted strings.\n\
2256 This does not affect the program until the next \"run\" command."),
2258 set_cmd_completer (c
, noop_completer
);
2260 c
= add_com ("path", class_files
, path_command
, _("\
2261 Add directory DIR(s) to beginning of search path for object files.\n\
2262 $cwd in the path means the current working directory.\n\
2263 This path is equivalent to the $PATH shell variable. It is a list of\n\
2264 directories, separated by colons. These directories are searched to find\n\
2265 fully linked executable files and separately compiled object files as needed."));
2266 set_cmd_completer (c
, filename_completer
);
2268 c
= add_cmd ("paths", no_class
, path_info
, _("\
2269 Current search path for finding object files.\n\
2270 $cwd in the path means the current working directory.\n\
2271 This path is equivalent to the $PATH shell variable. It is a list of\n\
2272 directories, separated by colons. These directories are searched to find\n\
2273 fully linked executable files and separately compiled object files as needed."),
2275 set_cmd_completer (c
, noop_completer
);
2277 add_com ("attach", class_run
, attach_command
, _("\
2278 Attach to a process or file outside of GDB.\n\
2279 This command attaches to another target, of the same type as your last\n\
2280 \"target\" command (\"info files\" will show your target stack).\n\
2281 The command may take as argument a process id or a device file.\n\
2282 For a process id, you must have permission to send the process a signal,\n\
2283 and it must have the same effective uid as the debugger.\n\
2284 When using \"attach\" with a process id, the debugger finds the\n\
2285 program running in the process, looking first in the current working\n\
2286 directory, or (if not found there) using the source file search path\n\
2287 (see the \"directory\" command). You can also use the \"file\" command\n\
2288 to specify the program, and to load its symbol table."));
2290 add_prefix_cmd ("detach", class_run
, detach_command
, _("\
2291 Detach a process or file previously attached.\n\
2292 If a process, it is no longer traced, and it continues its execution. If\n\
2293 you were debugging a file, the file is closed and gdb no longer accesses it."),
2294 &detachlist
, "detach ", 0, &cmdlist
);
2296 add_com ("disconnect", class_run
, disconnect_command
, _("\
2297 Disconnect from a target.\n\
2298 The target will wait for another debugger to connect. Not available for\n\
2301 add_com ("signal", class_run
, signal_command
, _("\
2302 Continue program giving it signal specified by the argument.\n\
2303 An argument of \"0\" means continue program without giving it a signal."));
2305 add_com ("stepi", class_run
, stepi_command
, _("\
2306 Step one instruction exactly.\n\
2307 Argument N means do this N times (or till program stops for another reason)."));
2308 add_com_alias ("si", "stepi", class_alias
, 0);
2310 add_com ("nexti", class_run
, nexti_command
, _("\
2311 Step one instruction, but proceed through subroutine calls.\n\
2312 Argument N means do this N times (or till program stops for another reason)."));
2313 add_com_alias ("ni", "nexti", class_alias
, 0);
2315 add_com ("finish", class_run
, finish_command
, _("\
2316 Execute until selected stack frame returns.\n\
2317 Upon return, the value returned is printed and put in the value history."));
2318 add_com_alias ("fin", "finish", class_run
, 1);
2320 add_com ("next", class_run
, next_command
, _("\
2321 Step program, proceeding through subroutine calls.\n\
2322 Like the \"step\" command as long as subroutine calls do not happen;\n\
2323 when they do, the call is treated as one instruction.\n\
2324 Argument N means do this N times (or till program stops for another reason)."));
2325 add_com_alias ("n", "next", class_run
, 1);
2327 add_com_alias ("S", "next", class_run
, 1);
2329 add_com ("step", class_run
, step_command
, _("\
2330 Step program until it reaches a different source line.\n\
2331 Argument N means do this N times (or till program stops for another reason)."));
2332 add_com_alias ("s", "step", class_run
, 1);
2334 c
= add_com ("until", class_run
, until_command
, _("\
2335 Execute until the program reaches a source line greater than the current\n\
2336 or a specified location (same args as break command) within the current frame."));
2337 set_cmd_completer (c
, location_completer
);
2338 add_com_alias ("u", "until", class_run
, 1);
2340 c
= add_com ("advance", class_run
, advance_command
, _("\
2341 Continue the program up to the given location (same form as args for break command).\n\
2342 Execution will also stop upon exit from the current stack frame."));
2343 set_cmd_completer (c
, location_completer
);
2345 c
= add_com ("jump", class_run
, jump_command
, _("\
2346 Continue program being debugged at specified line or address.\n\
2347 Give as argument either LINENUM or *ADDR, where ADDR is an expression\n\
2348 for an address to start at."));
2349 set_cmd_completer (c
, location_completer
);
2353 c
= add_com ("go", class_run
, go_command
, _("\
2354 Usage: go <location>\n\
2355 Continue program being debugged, stopping at specified line or \n\
2357 Give as argument either LINENUM or *ADDR, where ADDR is an \n\
2358 expression for an address to start at.\n\
2359 This command is a combination of tbreak and jump."));
2360 set_cmd_completer (c
, location_completer
);
2364 add_com_alias ("g", "go", class_run
, 1);
2366 c
= add_com ("continue", class_run
, continue_command
, _("\
2367 Continue program being debugged, after signal or breakpoint.\n\
2368 If proceeding from breakpoint, a number N may be used as an argument,\n\
2369 which means to set the ignore count of that breakpoint to N - 1 (so that\n\
2370 the breakpoint won't break until the Nth time it is reached).\n\
2372 If non-stop mode is enabled, continue only the current thread,\n\
2373 otherwise all the threads in the program are continued. To \n\
2374 continue all stopped threads in non-stop mode, use the -a option.\n\
2375 Specifying -a and an ignore count simultaneously is an error."));
2376 add_com_alias ("c", "cont", class_run
, 1);
2377 add_com_alias ("fg", "cont", class_run
, 1);
2378 set_cmd_async_ok (c
);
2380 c
= add_com ("run", class_run
, run_command
, _("\
2381 Start debugged program. You may specify arguments to give it.\n\
2382 Args may include \"*\", or \"[...]\"; they are expanded using \"sh\".\n\
2383 Input and output redirection with \">\", \"<\", or \">>\" are also allowed.\n\n\
2384 With no arguments, uses arguments last specified (with \"run\" or \"set args\").\n\
2385 To cancel previous arguments and run with no arguments,\n\
2386 use \"set args\" without arguments."));
2387 set_cmd_completer (c
, filename_completer
);
2388 add_com_alias ("r", "run", class_run
, 1);
2390 add_com ("R", class_run
, run_no_args_command
,
2391 _("Start debugged program with no arguments."));
2393 c
= add_com ("start", class_run
, start_command
, _("\
2394 Run the debugged program until the beginning of the main procedure.\n\
2395 You may specify arguments to give to your program, just as with the\n\
2396 \"run\" command."));
2397 set_cmd_completer (c
, filename_completer
);
2399 c
= add_com ("interrupt", class_run
, interrupt_target_command
,
2400 _("Interrupt the execution of the debugged program.\n\
2401 If non-stop mode is enabled, interrupt only the current thread,\n\
2402 otherwise all the threads in the program are stopped. To \n\
2403 interrupt all running threads in non-stop mode, use the -a option."));
2404 set_cmd_async_ok (c
);
2406 add_info ("registers", nofp_registers_info
, _("\
2407 List of integer registers and their contents, for selected stack frame.\n\
2408 Register name as argument means describe only that register."));
2409 add_info_alias ("r", "registers", 1);
2412 add_com ("lr", class_info
, nofp_registers_info
, _("\
2413 List of integer registers and their contents, for selected stack frame.\n\
2414 Register name as argument means describe only that register."));
2415 add_info ("all-registers", all_registers_info
, _("\
2416 List of all registers and their contents, for selected stack frame.\n\
2417 Register name as argument means describe only that register."));
2419 add_info ("program", program_info
,
2420 _("Execution status of the program."));
2422 add_info ("float", float_info
,
2423 _("Print the status of the floating point unit\n"));
2425 add_info ("vector", vector_info
,
2426 _("Print the status of the vector unit\n"));
2428 inferior_environ
= make_environ ();
2429 init_environ (inferior_environ
);