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"
52 /* Functions exported for general use, in inferior.h: */
54 void all_registers_info (char *, int);
56 void registers_info (char *, int);
58 void nexti_command (char *, int);
60 void stepi_command (char *, int);
62 void continue_command (char *, int);
64 void interrupt_target_command (char *args
, int from_tty
);
66 /* Local functions: */
68 static void nofp_registers_info (char *, int);
70 static void print_return_value (struct type
*value_type
);
72 static void finish_command_continuation (struct continuation_arg
*);
74 static void until_next_command (int);
76 static void until_command (char *, int);
78 static void path_info (char *, int);
80 static void path_command (char *, int);
82 static void unset_command (char *, int);
84 static void float_info (char *, int);
86 static void detach_command (char *, int);
88 static void disconnect_command (char *, int);
90 static void unset_environment_command (char *, int);
92 static void set_environment_command (char *, int);
94 static void environment_info (char *, int);
96 static void program_info (char *, int);
98 static void finish_command (char *, int);
100 static void signal_command (char *, int);
102 static void jump_command (char *, int);
104 static void step_1 (int, int, char *);
105 static void step_once (int skip_subroutines
, int single_inst
, int count
);
106 static void step_1_continuation (struct continuation_arg
*arg
);
108 static void next_command (char *, int);
110 static void step_command (char *, int);
112 static void run_command (char *, int);
114 static void run_no_args_command (char *args
, int from_tty
);
116 static void go_command (char *line_no
, int from_tty
);
118 static int strip_bg_char (char **);
120 void _initialize_infcmd (void);
122 #define GO_USAGE "Usage: go <location>\n"
124 #define ERROR_NO_INFERIOR \
125 if (!target_has_execution) error (_("The program is not being run."));
127 /* String containing arguments to give to the program, separated by spaces.
128 Empty string (pointer to '\0') means no args. */
130 static char *inferior_args
;
132 /* The inferior arguments as a vector. If INFERIOR_ARGC is nonzero,
133 then we must compute INFERIOR_ARGS from this (via the target). */
135 static int inferior_argc
;
136 static char **inferior_argv
;
138 /* File name for default use for standard in/out in the inferior. */
140 static char *inferior_io_terminal
;
142 /* Pid of our debugged inferior, or 0 if no inferior now.
143 Since various parts of infrun.c test this to see whether there is a program
144 being debugged it should be nonzero (currently 3 is used) for remote
147 ptid_t inferior_ptid
;
149 /* Last signal that the inferior received (why it stopped). */
151 enum target_signal stop_signal
;
153 /* Address at which inferior stopped. */
157 /* Chain containing status of breakpoint(s) that we have stopped at. */
161 /* Flag indicating that a command has proceeded the inferior past the
162 current breakpoint. */
164 int breakpoint_proceeded
;
166 /* Nonzero if stopped due to a step command. */
170 /* Nonzero if stopped due to completion of a stack dummy routine. */
172 int stop_stack_dummy
;
174 /* Nonzero if stopped due to a random (unexpected) signal in inferior
177 int stopped_by_random_signal
;
179 /* Range to single step within.
180 If this is nonzero, respond to a single-step signal
181 by continuing to step if the pc is in this range. */
183 CORE_ADDR step_range_start
; /* Inclusive */
184 CORE_ADDR step_range_end
; /* Exclusive */
186 /* Stack frame address as of when stepping command was issued.
187 This is how we know when we step into a subroutine call,
188 and how to set the frame for the breakpoint used to step out. */
190 struct frame_id step_frame_id
;
192 enum step_over_calls_kind step_over_calls
;
194 /* If stepping, nonzero means step count is > 1
195 so don't print frame next time inferior stops
196 if it stops due to stepping. */
200 /* Environment to use for running inferior,
201 in format described in environ.h. */
203 struct gdb_environ
*inferior_environ
;
205 /* Accessor routines. */
208 set_inferior_io_terminal (const char *terminal_name
)
210 if (inferior_io_terminal
)
211 xfree (inferior_io_terminal
);
214 inferior_io_terminal
= NULL
;
216 inferior_io_terminal
= savestring (terminal_name
, strlen (terminal_name
));
220 get_inferior_io_terminal (void)
222 return inferior_io_terminal
;
226 get_inferior_args (void)
228 if (inferior_argc
!= 0)
232 n
= gdbarch_construct_inferior_arguments (current_gdbarch
,
233 inferior_argc
, inferior_argv
);
234 old
= set_inferior_args (n
);
238 if (inferior_args
== NULL
)
239 inferior_args
= xstrdup ("");
241 return inferior_args
;
245 set_inferior_args (char *newargs
)
247 char *saved_args
= inferior_args
;
249 inferior_args
= newargs
;
257 set_inferior_args_vector (int argc
, char **argv
)
259 inferior_argc
= argc
;
260 inferior_argv
= argv
;
263 /* Notice when `set args' is run. */
265 notice_args_set (char *args
, int from_tty
, struct cmd_list_element
*c
)
271 /* Notice when `show args' is run. */
273 notice_args_read (struct ui_file
*file
, int from_tty
,
274 struct cmd_list_element
*c
, const char *value
)
276 deprecated_show_value_hack (file
, from_tty
, c
, value
);
277 /* Might compute the value. */
278 get_inferior_args ();
282 /* Compute command-line string given argument vector. This does the
283 same shell processing as fork_inferior. */
285 construct_inferior_arguments (struct gdbarch
*gdbarch
, int argc
, char **argv
)
289 if (STARTUP_WITH_SHELL
)
291 /* This holds all the characters considered special to the
292 typical Unix shells. We include `^' because the SunOS
293 /bin/sh treats it as a synonym for `|'. */
294 char *special
= "\"!#$&*()\\|[]{}<>?'\"`~^; \t\n";
299 /* We over-compute the size. It shouldn't matter. */
300 for (i
= 0; i
< argc
; ++i
)
301 length
+= 2 * strlen (argv
[i
]) + 1 + 2 * (argv
[i
][0] == '\0');
303 result
= (char *) xmalloc (length
);
306 for (i
= 0; i
< argc
; ++i
)
311 /* Need to handle empty arguments specially. */
312 if (argv
[i
][0] == '\0')
319 for (cp
= argv
[i
]; *cp
; ++cp
)
321 if (strchr (special
, *cp
) != NULL
)
331 /* In this case we can't handle arguments that contain spaces,
332 tabs, or newlines -- see breakup_args(). */
336 for (i
= 0; i
< argc
; ++i
)
338 char *cp
= strchr (argv
[i
], ' ');
340 cp
= strchr (argv
[i
], '\t');
342 cp
= strchr (argv
[i
], '\n');
344 error (_("can't handle command-line argument containing whitespace"));
345 length
+= strlen (argv
[i
]) + 1;
348 result
= (char *) xmalloc (length
);
350 for (i
= 0; i
< argc
; ++i
)
353 strcat (result
, " ");
354 strcat (result
, argv
[i
]);
362 /* This function detects whether or not a '&' character (indicating
363 background execution) has been added as *the last* of the arguments ARGS
364 of a command. If it has, it removes it and returns 1. Otherwise it
365 does nothing and returns 0. */
367 strip_bg_char (char **args
)
371 p
= strchr (*args
, '&');
375 if (p
== (*args
+ strlen (*args
) - 1))
377 if (strlen (*args
) > 1)
381 while (*p
== ' ' || *p
== '\t');
393 tty_command (char *file
, int from_tty
)
396 error_no_arg (_("terminal name for running target process"));
398 set_inferior_io_terminal (file
);
401 /* Common actions to take after creating any sort of inferior, by any
402 means (running, attaching, connecting, et cetera). The target
403 should be stopped. */
406 post_create_inferior (struct target_ops
*target
, int from_tty
)
408 /* Be sure we own the terminal in case write operations are performed. */
409 target_terminal_ours ();
411 /* If the target hasn't taken care of this already, do it now.
412 Targets which need to access registers during to_open,
413 to_create_inferior, or to_attach should do it earlier; but many
415 target_find_description ();
419 /* Sometimes the platform-specific hook loads initial shared
420 libraries, and sometimes it doesn't. Try to do so first, so
421 that we can add them with the correct value for FROM_TTY.
422 If we made all the inferior hook methods consistent,
423 this call could be removed. */
425 SOLIB_ADD (NULL
, from_tty
, target
, auto_solib_add
);
427 solib_add (NULL
, from_tty
, target
, auto_solib_add
);
430 /* Create the hooks to handle shared library load and unload
432 #ifdef SOLIB_CREATE_INFERIOR_HOOK
433 SOLIB_CREATE_INFERIOR_HOOK (PIDGET (inferior_ptid
));
435 solib_create_inferior_hook ();
439 observer_notify_inferior_created (target
, from_tty
);
442 /* Kill the inferior if already running. This function is designed
443 to be called when we are about to start the execution of the program
444 from the beginning. Ask the user to confirm that he wants to restart
445 the program being debugged when FROM_TTY is non-null. */
448 kill_if_already_running (int from_tty
)
450 if (! ptid_equal (inferior_ptid
, null_ptid
) && target_has_execution
)
452 /* Bail out before killing the program if we will not be able to
454 target_require_runnable ();
457 && !query ("The program being debugged has been started already.\n\
458 Start it from the beginning? "))
459 error (_("Program not restarted."));
461 no_shared_libraries (NULL
, from_tty
);
462 init_wait_for_inferior ();
466 /* Implement the "run" command. If TBREAK_AT_MAIN is set, then insert
467 a temporary breakpoint at the begining of the main program before
468 running the program. */
471 run_command_1 (char *args
, int from_tty
, int tbreak_at_main
)
477 kill_if_already_running (from_tty
);
478 clear_breakpoint_hit_counts ();
480 /* Clean up any leftovers from other runs. Some other things from
481 this function should probably be moved into target_pre_inferior. */
482 target_pre_inferior (from_tty
);
484 /* Purge old solib objfiles. */
485 objfile_purge_solibs ();
489 /* The comment here used to read, "The exec file is re-read every
490 time we do a generic_mourn_inferior, so we just have to worry
491 about the symbol file." The `generic_mourn_inferior' function
492 gets called whenever the program exits. However, suppose the
493 program exits, and *then* the executable file changes? We need
494 to check again here. Since reopen_exec_file doesn't do anything
495 if the timestamp hasn't changed, I don't see the harm. */
499 /* Insert the temporary breakpoint if a location was specified. */
501 tbreak_command (main_name (), 0);
503 exec_file
= (char *) get_exec_file (0);
505 /* We keep symbols from add-symbol-file, on the grounds that the
506 user might want to add some symbols before running the program
507 (right?). But sometimes (dynamic loading where the user manually
508 introduces the new symbols with add-symbol-file), the code which
509 the symbols describe does not persist between runs. Currently
510 the user has to manually nuke all symbols between runs if they
511 want them to go away (PR 2207). This is probably reasonable. */
515 if (target_can_async_p ())
516 async_disable_stdin ();
520 int async_exec
= strip_bg_char (&args
);
522 /* If we get a request for running in the bg but the target
523 doesn't support it, error out. */
524 if (async_exec
&& !target_can_async_p ())
525 error (_("Asynchronous execution not supported on this target."));
527 /* If we don't get a request of running in the bg, then we need
528 to simulate synchronous (fg) execution. */
529 if (!async_exec
&& target_can_async_p ())
531 /* Simulate synchronous execution */
532 async_disable_stdin ();
535 /* If there were other args, beside '&', process them. */
538 char *old_args
= set_inferior_args (xstrdup (args
));
545 ui_out_field_string (uiout
, NULL
, "Starting program");
546 ui_out_text (uiout
, ": ");
548 ui_out_field_string (uiout
, "execfile", exec_file
);
549 ui_out_spaces (uiout
, 1);
550 /* We call get_inferior_args() because we might need to compute
552 ui_out_field_string (uiout
, "infargs", get_inferior_args ());
553 ui_out_text (uiout
, "\n");
554 ui_out_flush (uiout
);
557 /* We call get_inferior_args() because we might need to compute
559 target_create_inferior (exec_file
, get_inferior_args (),
560 environ_vector (inferior_environ
), from_tty
);
562 /* Pass zero for FROM_TTY, because at this point the "run" command
563 has done its thing; now we are setting up the running program. */
564 post_create_inferior (¤t_target
, 0);
566 /* Start the target running. */
567 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_0
, 0);
572 run_command (char *args
, int from_tty
)
574 run_command_1 (args
, from_tty
, 0);
578 run_no_args_command (char *args
, int from_tty
)
580 char *old_args
= set_inferior_args (xstrdup (""));
585 /* Start the execution of the program up until the beginning of the main
589 start_command (char *args
, int from_tty
)
591 /* Some languages such as Ada need to search inside the program
592 minimal symbols for the location where to put the temporary
593 breakpoint before starting. */
594 if (!have_minimal_symbols ())
595 error (_("No symbol table loaded. Use the \"file\" command."));
597 /* Run the program until reaching the main procedure... */
598 run_command_1 (args
, from_tty
, 1);
602 continue_command (char *proc_count_exp
, int from_tty
)
607 /* Find out whether we must run in the background. */
608 if (proc_count_exp
!= NULL
)
609 async_exec
= strip_bg_char (&proc_count_exp
);
611 /* If we must run in the background, but the target can't do it,
613 if (async_exec
&& !target_can_async_p ())
614 error (_("Asynchronous execution not supported on this target."));
616 /* If we are not asked to run in the bg, then prepare to run in the
617 foreground, synchronously. */
618 if (!async_exec
&& target_can_async_p ())
620 /* Simulate synchronous execution */
621 async_disable_stdin ();
624 /* If have argument (besides '&'), set proceed count of breakpoint
626 if (proc_count_exp
!= NULL
)
628 bpstat bs
= stop_bpstat
;
632 while ((stat
= bpstat_num (&bs
, &num
)) != 0)
635 set_ignore_count (num
,
636 parse_and_eval_long (proc_count_exp
) - 1,
638 /* set_ignore_count prints a message ending with a period.
639 So print two spaces before "Continuing.". */
641 printf_filtered (" ");
645 if (!stopped
&& from_tty
)
648 ("Not stopped at any breakpoint; argument ignored.\n");
653 printf_filtered (_("Continuing.\n"));
655 clear_proceed_status ();
657 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 0);
660 /* Step until outside of current statement. */
663 step_command (char *count_string
, int from_tty
)
665 step_1 (0, 0, count_string
);
668 /* Likewise, but skip over subroutine calls as if single instructions. */
671 next_command (char *count_string
, int from_tty
)
673 step_1 (1, 0, count_string
);
676 /* Likewise, but step only one instruction. */
679 stepi_command (char *count_string
, int from_tty
)
681 step_1 (0, 1, count_string
);
685 nexti_command (char *count_string
, int from_tty
)
687 step_1 (1, 1, count_string
);
691 disable_longjmp_breakpoint_cleanup (void *ignore
)
693 disable_longjmp_breakpoint ();
697 step_1 (int skip_subroutines
, int single_inst
, char *count_string
)
700 struct frame_info
*frame
;
701 struct cleanup
*cleanups
= 0;
707 async_exec
= strip_bg_char (&count_string
);
709 /* If we get a request for running in the bg but the target
710 doesn't support it, error out. */
711 if (async_exec
&& !target_can_async_p ())
712 error (_("Asynchronous execution not supported on this target."));
714 /* If we don't get a request of running in the bg, then we need
715 to simulate synchronous (fg) execution. */
716 if (!async_exec
&& target_can_async_p ())
718 /* Simulate synchronous execution */
719 async_disable_stdin ();
722 count
= count_string
? parse_and_eval_long (count_string
) : 1;
724 if (!single_inst
|| skip_subroutines
) /* leave si command alone */
726 enable_longjmp_breakpoint ();
727 if (!target_can_async_p ())
728 cleanups
= make_cleanup (disable_longjmp_breakpoint_cleanup
, 0 /*ignore*/);
730 make_exec_cleanup (disable_longjmp_breakpoint_cleanup
, 0 /*ignore*/);
733 /* In synchronous case, all is well, just use the regular for loop. */
734 if (!target_can_async_p ())
736 for (; count
> 0; count
--)
738 clear_proceed_status ();
740 frame
= get_current_frame ();
741 if (!frame
) /* Avoid coredump here. Why tho? */
742 error (_("No current frame"));
743 step_frame_id
= get_frame_id (frame
);
747 find_pc_line_pc_range (stop_pc
, &step_range_start
, &step_range_end
);
748 if (step_range_end
== 0)
751 if (find_pc_partial_function (stop_pc
, &name
, &step_range_start
,
752 &step_range_end
) == 0)
753 error (_("Cannot find bounds of current function"));
755 target_terminal_ours ();
756 printf_filtered (_("\
757 Single stepping until exit from function %s, \n\
758 which has no line number information.\n"), name
);
763 /* Say we are stepping, but stop after one insn whatever it does. */
764 step_range_start
= step_range_end
= 1;
765 if (!skip_subroutines
)
767 Don't step over function calls, not even to functions lacking
769 step_over_calls
= STEP_OVER_NONE
;
772 if (skip_subroutines
)
773 step_over_calls
= STEP_OVER_ALL
;
775 step_multi
= (count
> 1);
776 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 1);
782 if (!single_inst
|| skip_subroutines
)
783 do_cleanups (cleanups
);
786 /* In case of asynchronous target things get complicated, do only
787 one step for now, before returning control to the event loop. Let
788 the continuation figure out how many other steps we need to do,
789 and handle them one at the time, through step_once(). */
792 if (target_can_async_p ())
793 step_once (skip_subroutines
, single_inst
, count
);
797 /* Called after we are done with one step operation, to check whether
798 we need to step again, before we print the prompt and return control
799 to the user. If count is > 1, we will need to do one more call to
800 proceed(), via step_once(). Basically it is like step_once and
801 step_1_continuation are co-recursive. */
803 step_1_continuation (struct continuation_arg
*arg
)
806 int skip_subroutines
;
809 skip_subroutines
= arg
->data
.integer
;
810 single_inst
= arg
->next
->data
.integer
;
811 count
= arg
->next
->next
->data
.integer
;
814 step_once (skip_subroutines
, single_inst
, count
- 1);
816 if (!single_inst
|| skip_subroutines
)
817 do_exec_cleanups (ALL_CLEANUPS
);
820 /* Do just one step operation. If count >1 we will have to set up a
821 continuation to be done after the target stops (after this one
822 step). This is useful to implement the 'step n' kind of commands, in
823 case of asynchronous targets. We had to split step_1 into two parts,
824 one to be done before proceed() and one afterwards. This function is
825 called in case of step n with n>1, after the first step operation has
828 step_once (int skip_subroutines
, int single_inst
, int count
)
830 struct continuation_arg
*arg1
;
831 struct continuation_arg
*arg2
;
832 struct continuation_arg
*arg3
;
833 struct frame_info
*frame
;
837 clear_proceed_status ();
839 frame
= get_current_frame ();
840 if (!frame
) /* Avoid coredump here. Why tho? */
841 error (_("No current frame"));
842 step_frame_id
= get_frame_id (frame
);
846 find_pc_line_pc_range (stop_pc
, &step_range_start
, &step_range_end
);
848 /* If we have no line info, switch to stepi mode. */
849 if (step_range_end
== 0 && step_stop_if_no_debug
)
851 step_range_start
= step_range_end
= 1;
853 else if (step_range_end
== 0)
856 if (find_pc_partial_function (stop_pc
, &name
, &step_range_start
,
857 &step_range_end
) == 0)
858 error (_("Cannot find bounds of current function"));
860 target_terminal_ours ();
861 printf_filtered (_("\
862 Single stepping until exit from function %s, \n\
863 which has no line number information.\n"), name
);
868 /* Say we are stepping, but stop after one insn whatever it does. */
869 step_range_start
= step_range_end
= 1;
870 if (!skip_subroutines
)
872 Don't step over function calls, not even to functions lacking
874 step_over_calls
= STEP_OVER_NONE
;
877 if (skip_subroutines
)
878 step_over_calls
= STEP_OVER_ALL
;
880 step_multi
= (count
> 1);
882 (struct continuation_arg
*) xmalloc (sizeof (struct continuation_arg
));
884 (struct continuation_arg
*) xmalloc (sizeof (struct continuation_arg
));
886 (struct continuation_arg
*) xmalloc (sizeof (struct continuation_arg
));
888 arg1
->data
.integer
= skip_subroutines
;
890 arg2
->data
.integer
= single_inst
;
892 arg3
->data
.integer
= count
;
893 add_intermediate_continuation (step_1_continuation
, arg1
);
894 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 1);
899 /* Continue program at specified address. */
902 jump_command (char *arg
, int from_tty
)
905 struct symtabs_and_lines sals
;
906 struct symtab_and_line sal
;
913 /* Find out whether we must run in the background. */
915 async_exec
= strip_bg_char (&arg
);
917 /* If we must run in the background, but the target can't do it,
919 if (async_exec
&& !target_can_async_p ())
920 error (_("Asynchronous execution not supported on this target."));
922 /* If we are not asked to run in the bg, then prepare to run in the
923 foreground, synchronously. */
924 if (!async_exec
&& target_can_async_p ())
926 /* Simulate synchronous execution */
927 async_disable_stdin ();
931 error_no_arg (_("starting address"));
933 sals
= decode_line_spec_1 (arg
, 1);
936 error (_("Unreasonable jump request"));
942 if (sal
.symtab
== 0 && sal
.pc
== 0)
943 error (_("No source file has been specified."));
945 resolve_sal_pc (&sal
); /* May error out */
947 /* See if we are trying to jump to another function. */
948 fn
= get_frame_function (get_current_frame ());
949 sfn
= find_pc_function (sal
.pc
);
950 if (fn
!= NULL
&& sfn
!= fn
)
952 if (!query ("Line %d is not in `%s'. Jump anyway? ", sal
.line
,
953 SYMBOL_PRINT_NAME (fn
)))
955 error (_("Not confirmed."));
962 fixup_symbol_section (sfn
, 0);
963 if (section_is_overlay (SYMBOL_BFD_SECTION (sfn
)) &&
964 !section_is_mapped (SYMBOL_BFD_SECTION (sfn
)))
966 if (!query ("WARNING!!! Destination is in unmapped overlay! Jump anyway? "))
968 error (_("Not confirmed."));
978 printf_filtered (_("Continuing at "));
979 fputs_filtered (paddress (addr
), gdb_stdout
);
980 printf_filtered (".\n");
983 clear_proceed_status ();
984 proceed (addr
, TARGET_SIGNAL_0
, 0);
988 /* Go to line or address in current procedure */
990 go_command (char *line_no
, int from_tty
)
992 if (line_no
== (char *) NULL
|| !*line_no
)
993 printf_filtered (GO_USAGE
);
996 tbreak_command (line_no
, from_tty
);
997 jump_command (line_no
, from_tty
);
1002 /* Continue program giving it specified signal. */
1005 signal_command (char *signum_exp
, int from_tty
)
1007 enum target_signal oursig
;
1009 dont_repeat (); /* Too dangerous. */
1013 error_no_arg (_("signal number"));
1015 /* It would be even slicker to make signal names be valid expressions,
1016 (the type could be "enum $signal" or some such), then the user could
1017 assign them to convenience variables. */
1018 oursig
= target_signal_from_name (signum_exp
);
1020 if (oursig
== TARGET_SIGNAL_UNKNOWN
)
1022 /* No, try numeric. */
1023 int num
= parse_and_eval_long (signum_exp
);
1026 oursig
= TARGET_SIGNAL_0
;
1028 oursig
= target_signal_from_command (num
);
1033 if (oursig
== TARGET_SIGNAL_0
)
1034 printf_filtered (_("Continuing with no signal.\n"));
1036 printf_filtered (_("Continuing with signal %s.\n"),
1037 target_signal_to_name (oursig
));
1040 clear_proceed_status ();
1041 /* "signal 0" should not get stuck if we are stopped at a breakpoint.
1042 FIXME: Neither should "signal foo" but when I tried passing
1043 (CORE_ADDR)-1 unconditionally I got a testsuite failure which I haven't
1044 tried to track down yet. */
1045 proceed (oursig
== TARGET_SIGNAL_0
? (CORE_ADDR
) -1 : stop_pc
, oursig
, 0);
1048 /* Proceed until we reach a different source line with pc greater than
1049 our current one or exit the function. We skip calls in both cases.
1051 Note that eventually this command should probably be changed so
1052 that only source lines are printed out when we hit the breakpoint
1053 we set. This may involve changes to wait_for_inferior and the
1054 proceed status code. */
1057 until_next_command (int from_tty
)
1059 struct frame_info
*frame
;
1061 struct symbol
*func
;
1062 struct symtab_and_line sal
;
1064 clear_proceed_status ();
1066 frame
= get_current_frame ();
1068 /* Step until either exited from this function or greater
1069 than the current line (if in symbolic section) or pc (if
1073 func
= find_pc_function (pc
);
1077 struct minimal_symbol
*msymbol
= lookup_minimal_symbol_by_pc (pc
);
1079 if (msymbol
== NULL
)
1080 error (_("Execution is not within a known function."));
1082 step_range_start
= SYMBOL_VALUE_ADDRESS (msymbol
);
1083 step_range_end
= pc
;
1087 sal
= find_pc_line (pc
, 0);
1089 step_range_start
= BLOCK_START (SYMBOL_BLOCK_VALUE (func
));
1090 step_range_end
= sal
.end
;
1093 step_over_calls
= STEP_OVER_ALL
;
1094 step_frame_id
= get_frame_id (frame
);
1096 step_multi
= 0; /* Only one call to proceed */
1098 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 1);
1102 until_command (char *arg
, int from_tty
)
1106 if (!target_has_execution
)
1107 error (_("The program is not running."));
1109 /* Find out whether we must run in the background. */
1111 async_exec
= strip_bg_char (&arg
);
1113 /* If we must run in the background, but the target can't do it,
1115 if (async_exec
&& !target_can_async_p ())
1116 error (_("Asynchronous execution not supported on this target."));
1118 /* If we are not asked to run in the bg, then prepare to run in the
1119 foreground, synchronously. */
1120 if (!async_exec
&& target_can_async_p ())
1122 /* Simulate synchronous execution */
1123 async_disable_stdin ();
1127 until_break_command (arg
, from_tty
, 0);
1129 until_next_command (from_tty
);
1133 advance_command (char *arg
, int from_tty
)
1137 if (!target_has_execution
)
1138 error (_("The program is not running."));
1141 error_no_arg (_("a location"));
1143 /* Find out whether we must run in the background. */
1145 async_exec
= strip_bg_char (&arg
);
1147 /* If we must run in the background, but the target can't do it,
1149 if (async_exec
&& !target_can_async_p ())
1150 error (_("Asynchronous execution not supported on this target."));
1152 /* If we are not asked to run in the bg, then prepare to run in the
1153 foreground, synchronously. */
1154 if (!async_exec
&& target_can_async_p ())
1156 /* Simulate synchronous execution. */
1157 async_disable_stdin ();
1160 until_break_command (arg
, from_tty
, 1);
1163 /* Print the result of a function at the end of a 'finish' command. */
1166 print_return_value (struct type
*value_type
)
1168 struct gdbarch
*gdbarch
= current_gdbarch
;
1169 struct cleanup
*old_chain
;
1170 struct ui_stream
*stb
;
1171 struct value
*value
;
1173 CHECK_TYPEDEF (value_type
);
1174 gdb_assert (TYPE_CODE (value_type
) != TYPE_CODE_VOID
);
1176 /* FIXME: 2003-09-27: When returning from a nested inferior function
1177 call, it's possible (with no help from the architecture vector)
1178 to locate and return/print a "struct return" value. This is just
1179 a more complicated case of what is already being done in in the
1180 inferior function call code. In fact, when inferior function
1181 calls are made async, this will likely be made the norm. */
1183 switch (gdbarch_return_value (gdbarch
, value_type
, NULL
, NULL
, NULL
))
1185 case RETURN_VALUE_REGISTER_CONVENTION
:
1186 case RETURN_VALUE_ABI_RETURNS_ADDRESS
:
1187 case RETURN_VALUE_ABI_PRESERVES_ADDRESS
:
1188 value
= allocate_value (value_type
);
1189 gdbarch_return_value (gdbarch
, value_type
, stop_registers
,
1190 value_contents_raw (value
), NULL
);
1192 case RETURN_VALUE_STRUCT_CONVENTION
:
1196 internal_error (__FILE__
, __LINE__
, _("bad switch"));
1202 stb
= ui_out_stream_new (uiout
);
1203 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
1204 ui_out_text (uiout
, "Value returned is ");
1205 ui_out_field_fmt (uiout
, "gdb-result-var", "$%d",
1206 record_latest_value (value
));
1207 ui_out_text (uiout
, " = ");
1208 value_print (value
, stb
->stream
, 0, Val_no_prettyprint
);
1209 ui_out_field_stream (uiout
, "return-value", stb
);
1210 ui_out_text (uiout
, "\n");
1211 do_cleanups (old_chain
);
1215 ui_out_text (uiout
, "Value returned has type: ");
1216 ui_out_field_string (uiout
, "return-type", TYPE_NAME (value_type
));
1217 ui_out_text (uiout
, ".");
1218 ui_out_text (uiout
, " Cannot determine contents\n");
1222 /* Stuff that needs to be done by the finish command after the target
1223 has stopped. In asynchronous mode, we wait for the target to stop
1224 in the call to poll or select in the event loop, so it is
1225 impossible to do all the stuff as part of the finish_command
1226 function itself. The only chance we have to complete this command
1227 is in fetch_inferior_event, which is called by the event loop as
1228 soon as it detects that the target has stopped. This function is
1229 called via the cmd_continuation pointer. */
1232 finish_command_continuation (struct continuation_arg
*arg
)
1234 struct symbol
*function
;
1235 struct breakpoint
*breakpoint
;
1236 struct cleanup
*cleanups
;
1238 breakpoint
= (struct breakpoint
*) arg
->data
.pointer
;
1239 function
= (struct symbol
*) arg
->next
->data
.pointer
;
1240 cleanups
= (struct cleanup
*) arg
->next
->next
->data
.pointer
;
1242 if (bpstat_find_breakpoint (stop_bpstat
, breakpoint
) != NULL
1243 && function
!= NULL
)
1245 struct type
*value_type
;
1247 value_type
= TYPE_TARGET_TYPE (SYMBOL_TYPE (function
));
1249 internal_error (__FILE__
, __LINE__
,
1250 _("finish_command: function has no target type"));
1252 if (TYPE_CODE (value_type
) != TYPE_CODE_VOID
)
1253 print_return_value (value_type
);
1256 do_exec_cleanups (cleanups
);
1259 /* "finish": Set a temporary breakpoint at the place the selected
1260 frame will return to, then continue. */
1263 finish_command (char *arg
, int from_tty
)
1265 struct symtab_and_line sal
;
1266 struct frame_info
*frame
;
1267 struct symbol
*function
;
1268 struct breakpoint
*breakpoint
;
1269 struct cleanup
*old_chain
;
1270 struct continuation_arg
*arg1
, *arg2
, *arg3
;
1274 /* Find out whether we must run in the background. */
1276 async_exec
= strip_bg_char (&arg
);
1278 /* If we must run in the background, but the target can't do it,
1280 if (async_exec
&& !target_can_async_p ())
1281 error (_("Asynchronous execution not supported on this target."));
1283 /* If we are not asked to run in the bg, then prepare to run in the
1284 foreground, synchronously. */
1285 if (!async_exec
&& target_can_async_p ())
1287 /* Simulate synchronous execution. */
1288 async_disable_stdin ();
1292 error (_("The \"finish\" command does not take any arguments."));
1293 if (!target_has_execution
)
1294 error (_("The program is not running."));
1296 frame
= get_prev_frame (get_selected_frame (_("No selected frame.")));
1298 error (_("\"finish\" not meaningful in the outermost frame."));
1300 clear_proceed_status ();
1302 sal
= find_pc_line (get_frame_pc (frame
), 0);
1303 sal
.pc
= get_frame_pc (frame
);
1305 breakpoint
= set_momentary_breakpoint (sal
, get_frame_id (frame
), bp_finish
);
1307 if (!target_can_async_p ())
1308 old_chain
= make_cleanup_delete_breakpoint (breakpoint
);
1310 old_chain
= make_exec_cleanup_delete_breakpoint (breakpoint
);
1312 /* Find the function we will return from. */
1314 function
= find_pc_function (get_frame_pc (get_selected_frame (NULL
)));
1316 /* Print info on the selected frame, including level number but not
1320 printf_filtered (_("Run till exit from "));
1321 print_stack_frame (get_selected_frame (NULL
), 1, LOCATION
);
1324 /* If running asynchronously and the target support asynchronous
1325 execution, set things up for the rest of the finish command to be
1326 completed later on, when gdb has detected that the target has
1327 stopped, in fetch_inferior_event. */
1328 if (target_can_async_p ())
1331 (struct continuation_arg
*) xmalloc (sizeof (struct continuation_arg
));
1333 (struct continuation_arg
*) xmalloc (sizeof (struct continuation_arg
));
1335 (struct continuation_arg
*) xmalloc (sizeof (struct continuation_arg
));
1339 arg1
->data
.pointer
= breakpoint
;
1340 arg2
->data
.pointer
= function
;
1341 arg3
->data
.pointer
= old_chain
;
1342 add_continuation (finish_command_continuation
, arg1
);
1345 proceed_to_finish
= 1; /* We want stop_registers, please... */
1346 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 0);
1348 /* Do this only if not running asynchronously or if the target
1349 cannot do async execution. Otherwise, complete this command when
1350 the target actually stops, in fetch_inferior_event. */
1351 if (!target_can_async_p ())
1353 /* Did we stop at our breakpoint? */
1354 if (bpstat_find_breakpoint (stop_bpstat
, breakpoint
) != NULL
1355 && function
!= NULL
)
1357 struct type
*value_type
;
1359 value_type
= TYPE_TARGET_TYPE (SYMBOL_TYPE (function
));
1361 internal_error (__FILE__
, __LINE__
,
1362 _("finish_command: function has no target type"));
1364 if (TYPE_CODE (value_type
) != TYPE_CODE_VOID
)
1365 print_return_value (value_type
);
1368 do_cleanups (old_chain
);
1374 program_info (char *args
, int from_tty
)
1376 bpstat bs
= stop_bpstat
;
1378 int stat
= bpstat_num (&bs
, &num
);
1380 if (!target_has_execution
)
1382 printf_filtered (_("The program being debugged is not being run.\n"));
1386 target_files_info ();
1387 printf_filtered (_("Program stopped at %s.\n"),
1388 hex_string ((unsigned long) stop_pc
));
1390 printf_filtered (_("It stopped after being stepped.\n"));
1393 /* There may be several breakpoints in the same place, so this
1394 isn't as strange as it seems. */
1399 printf_filtered (_("\
1400 It stopped at a breakpoint that has since been deleted.\n"));
1403 printf_filtered (_("It stopped at breakpoint %d.\n"), num
);
1404 stat
= bpstat_num (&bs
, &num
);
1407 else if (stop_signal
!= TARGET_SIGNAL_0
)
1409 printf_filtered (_("It stopped with signal %s, %s.\n"),
1410 target_signal_to_name (stop_signal
),
1411 target_signal_to_string (stop_signal
));
1416 printf_filtered (_("\
1417 Type \"info stack\" or \"info registers\" for more information.\n"));
1422 environment_info (char *var
, int from_tty
)
1426 char *val
= get_in_environ (inferior_environ
, var
);
1429 puts_filtered (var
);
1430 puts_filtered (" = ");
1431 puts_filtered (val
);
1432 puts_filtered ("\n");
1436 puts_filtered ("Environment variable \"");
1437 puts_filtered (var
);
1438 puts_filtered ("\" not defined.\n");
1443 char **vector
= environ_vector (inferior_environ
);
1446 puts_filtered (*vector
++);
1447 puts_filtered ("\n");
1453 set_environment_command (char *arg
, int from_tty
)
1455 char *p
, *val
, *var
;
1459 error_no_arg (_("environment variable and value"));
1461 /* Find seperation between variable name and value */
1462 p
= (char *) strchr (arg
, '=');
1463 val
= (char *) strchr (arg
, ' ');
1465 if (p
!= 0 && val
!= 0)
1467 /* We have both a space and an equals. If the space is before the
1468 equals, walk forward over the spaces til we see a nonspace
1469 (possibly the equals). */
1474 /* Now if the = is after the char following the spaces,
1475 take the char following the spaces. */
1479 else if (val
!= 0 && p
== 0)
1483 error_no_arg (_("environment variable to set"));
1485 if (p
== 0 || p
[1] == 0)
1489 p
= arg
+ strlen (arg
); /* So that savestring below will work */
1493 /* Not setting variable value to null */
1495 while (*val
== ' ' || *val
== '\t')
1499 while (p
!= arg
&& (p
[-1] == ' ' || p
[-1] == '\t'))
1502 var
= savestring (arg
, p
- arg
);
1505 printf_filtered (_("\
1506 Setting environment variable \"%s\" to null value.\n"),
1508 set_in_environ (inferior_environ
, var
, "");
1511 set_in_environ (inferior_environ
, var
, val
);
1516 unset_environment_command (char *var
, int from_tty
)
1520 /* If there is no argument, delete all environment variables.
1521 Ask for confirmation if reading from the terminal. */
1522 if (!from_tty
|| query (_("Delete all environment variables? ")))
1524 free_environ (inferior_environ
);
1525 inferior_environ
= make_environ ();
1529 unset_in_environ (inferior_environ
, var
);
1532 /* Handle the execution path (PATH variable) */
1534 static const char path_var_name
[] = "PATH";
1537 path_info (char *args
, int from_tty
)
1539 puts_filtered ("Executable and object file path: ");
1540 puts_filtered (get_in_environ (inferior_environ
, path_var_name
));
1541 puts_filtered ("\n");
1544 /* Add zero or more directories to the front of the execution path. */
1547 path_command (char *dirname
, int from_tty
)
1552 env
= get_in_environ (inferior_environ
, path_var_name
);
1553 /* Can be null if path is not set */
1556 exec_path
= xstrdup (env
);
1557 mod_path (dirname
, &exec_path
);
1558 set_in_environ (inferior_environ
, path_var_name
, exec_path
);
1561 path_info ((char *) NULL
, from_tty
);
1565 /* Print out the machine register regnum. If regnum is -1, print all
1566 registers (print_all == 1) or all non-float and non-vector
1567 registers (print_all == 0).
1569 For most machines, having all_registers_info() print the
1570 register(s) one per line is good enough. If a different format is
1571 required, (eg, for MIPS or Pyramid 90x, which both have lots of
1572 regs), or there is an existing convention for showing all the
1573 registers, define the architecture method PRINT_REGISTERS_INFO to
1574 provide that format. */
1577 default_print_registers_info (struct gdbarch
*gdbarch
,
1578 struct ui_file
*file
,
1579 struct frame_info
*frame
,
1580 int regnum
, int print_all
)
1583 const int numregs
= gdbarch_num_regs (gdbarch
)
1584 + gdbarch_num_pseudo_regs (gdbarch
);
1585 gdb_byte buffer
[MAX_REGISTER_SIZE
];
1587 for (i
= 0; i
< numregs
; i
++)
1589 /* Decide between printing all regs, non-float / vector regs, or
1595 if (!gdbarch_register_reggroup_p (gdbarch
, i
, all_reggroup
))
1600 if (!gdbarch_register_reggroup_p (gdbarch
, i
, general_reggroup
))
1610 /* If the register name is empty, it is undefined for this
1611 processor, so don't display anything. */
1612 if (gdbarch_register_name (gdbarch
, i
) == NULL
1613 || *(gdbarch_register_name (gdbarch
, i
)) == '\0')
1616 fputs_filtered (gdbarch_register_name (gdbarch
, i
), file
);
1617 print_spaces_filtered (15 - strlen (gdbarch_register_name
1618 (gdbarch
, i
)), file
);
1620 /* Get the data in raw format. */
1621 if (! frame_register_read (frame
, i
, buffer
))
1623 fprintf_filtered (file
, "*value not available*\n");
1627 /* If virtual format is floating, print it that way, and in raw
1629 if (TYPE_CODE (register_type (gdbarch
, i
)) == TYPE_CODE_FLT
1630 || TYPE_CODE (register_type (gdbarch
, i
)) == TYPE_CODE_DECFLOAT
)
1634 val_print (register_type (gdbarch
, i
), buffer
, 0, 0,
1635 file
, 0, 1, 0, Val_pretty_default
);
1637 fprintf_filtered (file
, "\t(raw 0x");
1638 for (j
= 0; j
< register_size (gdbarch
, i
); j
++)
1641 if (gdbarch_byte_order (gdbarch
) == BFD_ENDIAN_BIG
)
1644 idx
= register_size (gdbarch
, i
) - 1 - j
;
1645 fprintf_filtered (file
, "%02x", (unsigned char) buffer
[idx
]);
1647 fprintf_filtered (file
, ")");
1651 /* Print the register in hex. */
1652 val_print (register_type (gdbarch
, i
), buffer
, 0, 0,
1653 file
, 'x', 1, 0, Val_pretty_default
);
1654 /* If not a vector register, print it also according to its
1656 if (TYPE_VECTOR (register_type (gdbarch
, i
)) == 0)
1658 fprintf_filtered (file
, "\t");
1659 val_print (register_type (gdbarch
, i
), buffer
, 0, 0,
1660 file
, 0, 1, 0, Val_pretty_default
);
1664 fprintf_filtered (file
, "\n");
1669 registers_info (char *addr_exp
, int fpregs
)
1671 struct frame_info
*frame
;
1672 struct gdbarch
*gdbarch
;
1673 int regnum
, numregs
;
1676 if (!target_has_registers
)
1677 error (_("The program has no registers now."));
1678 frame
= get_selected_frame (NULL
);
1679 gdbarch
= get_frame_arch (frame
);
1683 gdbarch_print_registers_info (gdbarch
, gdb_stdout
,
1688 while (*addr_exp
!= '\0')
1693 /* Keep skipping leading white space. */
1694 if (isspace ((*addr_exp
)))
1700 /* Discard any leading ``$''. Check that there is something
1701 resembling a register following it. */
1702 if (addr_exp
[0] == '$')
1704 if (isspace ((*addr_exp
)) || (*addr_exp
) == '\0')
1705 error (_("Missing register name"));
1707 /* Find the start/end of this register name/num/group. */
1709 while ((*addr_exp
) != '\0' && !isspace ((*addr_exp
)))
1713 /* Figure out what we've found and display it. */
1715 /* A register name? */
1717 int regnum
= frame_map_name_to_regnum (frame
, start
, end
- start
);
1720 /* User registers lie completely outside of the range of
1721 normal registers. Catch them early so that the target
1723 if (regnum
>= gdbarch_num_regs (gdbarch
)
1724 + gdbarch_num_pseudo_regs (gdbarch
))
1726 struct value
*val
= value_of_user_reg (regnum
, frame
);
1728 printf_filtered ("%s: ", start
);
1729 print_scalar_formatted (value_contents (val
),
1730 check_typedef (value_type (val
)),
1731 'x', 0, gdb_stdout
);
1732 printf_filtered ("\n");
1735 gdbarch_print_registers_info (gdbarch
, gdb_stdout
,
1736 frame
, regnum
, fpregs
);
1741 /* A register number? (how portable is this one?). */
1744 int regnum
= strtol (start
, &endptr
, 0);
1747 && regnum
< gdbarch_num_regs (gdbarch
)
1748 + gdbarch_num_pseudo_regs (gdbarch
))
1750 gdbarch_print_registers_info (gdbarch
, gdb_stdout
,
1751 frame
, regnum
, fpregs
);
1756 /* A register group? */
1758 struct reggroup
*group
;
1759 for (group
= reggroup_next (gdbarch
, NULL
);
1761 group
= reggroup_next (gdbarch
, group
))
1763 /* Don't bother with a length check. Should the user
1764 enter a short register group name, go with the first
1765 group that matches. */
1766 if (strncmp (start
, reggroup_name (group
), end
- start
) == 0)
1773 regnum
< gdbarch_num_regs (gdbarch
)
1774 + gdbarch_num_pseudo_regs (gdbarch
);
1777 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, group
))
1778 gdbarch_print_registers_info (gdbarch
,
1786 /* Nothing matched. */
1787 error (_("Invalid register `%.*s'"), (int) (end
- start
), start
);
1792 all_registers_info (char *addr_exp
, int from_tty
)
1794 registers_info (addr_exp
, 1);
1798 nofp_registers_info (char *addr_exp
, int from_tty
)
1800 registers_info (addr_exp
, 0);
1804 print_vector_info (struct gdbarch
*gdbarch
, struct ui_file
*file
,
1805 struct frame_info
*frame
, const char *args
)
1807 if (gdbarch_print_vector_info_p (gdbarch
))
1808 gdbarch_print_vector_info (gdbarch
, file
, frame
, args
);
1812 int printed_something
= 0;
1815 regnum
< gdbarch_num_regs (gdbarch
)
1816 + gdbarch_num_pseudo_regs (gdbarch
);
1819 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, vector_reggroup
))
1821 printed_something
= 1;
1822 gdbarch_print_registers_info (gdbarch
, file
, frame
, regnum
, 1);
1825 if (!printed_something
)
1826 fprintf_filtered (file
, "No vector information\n");
1831 vector_info (char *args
, int from_tty
)
1833 if (!target_has_registers
)
1834 error (_("The program has no registers now."));
1836 print_vector_info (current_gdbarch
, gdb_stdout
,
1837 get_selected_frame (NULL
), args
);
1843 * Should save/restore the tty state since it might be that the
1844 * program to be debugged was started on this tty and it wants
1845 * the tty in some state other than what we want. If it's running
1846 * on another terminal or without a terminal, then saving and
1847 * restoring the tty state is a harmless no-op.
1848 * This only needs to be done if we are attaching to a process.
1853 takes a program started up outside of gdb and ``attaches'' to it.
1854 This stops it cold in its tracks and allows us to start debugging it.
1855 and wait for the trace-trap that results from attaching. */
1858 attach_command (char *args
, int from_tty
)
1861 char *full_exec_path
= NULL
;
1863 dont_repeat (); /* Not for the faint of heart */
1865 if (target_has_execution
)
1867 if (query ("A program is being debugged already. Kill it? "))
1870 error (_("Not killed."));
1873 /* Clean up any leftovers from other runs. Some other things from
1874 this function should probably be moved into target_pre_inferior. */
1875 target_pre_inferior (from_tty
);
1877 /* Clear out solib state. Otherwise the solib state of the previous
1878 inferior might have survived and is entirely wrong for the new
1879 target. This has been observed on GNU/Linux using glibc 2.3. How
1891 Cannot access memory at address 0xdeadbeef
1895 target_attach (args
, from_tty
);
1897 /* Set up the "saved terminal modes" of the inferior
1898 based on what modes we are starting it with. */
1899 target_terminal_init ();
1901 /* Set up execution context to know that we should return from
1902 wait_for_inferior as soon as the target reports a stop. */
1903 init_wait_for_inferior ();
1904 clear_proceed_status ();
1906 /* No traps are generated when attaching to inferior under Mach 3
1908 #ifndef ATTACH_NO_WAIT
1909 /* Careful here. See comments in inferior.h. Basically some OSes
1910 don't ignore SIGSTOPs on continue requests anymore. We need a
1911 way for handle_inferior_event to reset the stop_signal variable
1912 after an attach, and this is what STOP_QUIETLY_NO_SIGSTOP is for. */
1913 stop_soon
= STOP_QUIETLY_NO_SIGSTOP
;
1914 wait_for_inferior (0);
1915 stop_soon
= NO_STOP_QUIETLY
;
1919 * If no exec file is yet known, try to determine it from the
1922 exec_file
= (char *) get_exec_file (0);
1925 exec_file
= target_pid_to_exec_file (PIDGET (inferior_ptid
));
1928 /* It's possible we don't have a full path, but rather just a
1929 filename. Some targets, such as HP-UX, don't provide the
1932 Attempt to qualify the filename against the source path.
1933 (If that fails, we'll just fall back on the original
1934 filename. Not much more we can do...)
1936 if (!source_full_path_of (exec_file
, &full_exec_path
))
1937 full_exec_path
= savestring (exec_file
, strlen (exec_file
));
1939 exec_file_attach (full_exec_path
, from_tty
);
1940 symbol_file_add_main (full_exec_path
, from_tty
);
1945 reopen_exec_file ();
1949 /* Take any necessary post-attaching actions for this platform.
1951 target_post_attach (PIDGET (inferior_ptid
));
1953 post_create_inferior (¤t_target
, from_tty
);
1955 /* Install inferior's terminal modes. */
1956 target_terminal_inferior ();
1960 if (deprecated_attach_hook
)
1961 deprecated_attach_hook ();
1966 * takes a program previously attached to and detaches it.
1967 * The program resumes execution and will no longer stop
1968 * on signals, etc. We better not have left any breakpoints
1969 * in the program or it'll die when it hits one. For this
1970 * to work, it may be necessary for the process to have been
1971 * previously attached. It *might* work if the program was
1972 * started via the normal ptrace (PTRACE_TRACEME).
1976 detach_command (char *args
, int from_tty
)
1978 dont_repeat (); /* Not for the faint of heart. */
1979 target_detach (args
, from_tty
);
1980 no_shared_libraries (NULL
, from_tty
);
1981 if (deprecated_detach_hook
)
1982 deprecated_detach_hook ();
1985 /* Disconnect from the current target without resuming it (leaving it
1986 waiting for a debugger).
1988 We'd better not have left any breakpoints in the program or the
1989 next debugger will get confused. Currently only supported for some
1990 remote targets, since the normal attach mechanisms don't work on
1991 stopped processes on some native platforms (e.g. GNU/Linux). */
1994 disconnect_command (char *args
, int from_tty
)
1996 dont_repeat (); /* Not for the faint of heart */
1997 target_disconnect (args
, from_tty
);
1998 no_shared_libraries (NULL
, from_tty
);
1999 if (deprecated_detach_hook
)
2000 deprecated_detach_hook ();
2003 /* Stop the execution of the target while running in async mode, in
2006 interrupt_target_command (char *args
, int from_tty
)
2008 if (target_can_async_p ())
2010 dont_repeat (); /* Not for the faint of heart */
2016 print_float_info (struct gdbarch
*gdbarch
, struct ui_file
*file
,
2017 struct frame_info
*frame
, const char *args
)
2019 if (gdbarch_print_float_info_p (gdbarch
))
2020 gdbarch_print_float_info (gdbarch
, file
, frame
, args
);
2024 int printed_something
= 0;
2027 regnum
< gdbarch_num_regs (gdbarch
)
2028 + gdbarch_num_pseudo_regs (gdbarch
);
2031 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, float_reggroup
))
2033 printed_something
= 1;
2034 gdbarch_print_registers_info (gdbarch
, file
, frame
, regnum
, 1);
2037 if (!printed_something
)
2038 fprintf_filtered (file
, "\
2039 No floating-point info available for this processor.\n");
2044 float_info (char *args
, int from_tty
)
2046 if (!target_has_registers
)
2047 error (_("The program has no registers now."));
2049 print_float_info (current_gdbarch
, gdb_stdout
,
2050 get_selected_frame (NULL
), args
);
2054 unset_command (char *args
, int from_tty
)
2056 printf_filtered (_("\
2057 \"unset\" must be followed by the name of an unset subcommand.\n"));
2058 help_list (unsetlist
, "unset ", -1, gdb_stdout
);
2062 _initialize_infcmd (void)
2064 struct cmd_list_element
*c
= NULL
;
2066 /* add the filename of the terminal connected to inferior I/O */
2067 add_setshow_filename_cmd ("inferior-tty", class_run
,
2068 &inferior_io_terminal
, _("\
2069 Set terminal for future runs of program being debugged."), _("\
2070 Show terminal for future runs of program being debugged."), _("\
2071 Usage: set inferior-tty /dev/pts/1"), NULL
, NULL
, &setlist
, &showlist
);
2072 add_com_alias ("tty", "set inferior-tty", class_alias
, 0);
2074 add_setshow_optional_filename_cmd ("args", class_run
,
2075 &inferior_args
, _("\
2076 Set argument list to give program being debugged when it is started."), _("\
2077 Show argument list to give program being debugged when it is started."), _("\
2078 Follow this command with any number of args, to be passed to the program."),
2081 &setlist
, &showlist
);
2083 c
= add_cmd ("environment", no_class
, environment_info
, _("\
2084 The environment to give the program, or one variable's value.\n\
2085 With an argument VAR, prints the value of environment variable VAR to\n\
2086 give the program being debugged. With no arguments, prints the entire\n\
2087 environment to be given to the program."), &showlist
);
2088 set_cmd_completer (c
, noop_completer
);
2090 add_prefix_cmd ("unset", no_class
, unset_command
,
2091 _("Complement to certain \"set\" commands."),
2092 &unsetlist
, "unset ", 0, &cmdlist
);
2094 c
= add_cmd ("environment", class_run
, unset_environment_command
, _("\
2095 Cancel environment variable VAR for the program.\n\
2096 This does not affect the program until the next \"run\" command."),
2098 set_cmd_completer (c
, noop_completer
);
2100 c
= add_cmd ("environment", class_run
, set_environment_command
, _("\
2101 Set environment variable value to give the program.\n\
2102 Arguments are VAR VALUE where VAR is variable name and VALUE is value.\n\
2103 VALUES of environment variables are uninterpreted strings.\n\
2104 This does not affect the program until the next \"run\" command."),
2106 set_cmd_completer (c
, noop_completer
);
2108 c
= add_com ("path", class_files
, path_command
, _("\
2109 Add directory DIR(s) to beginning of search path for object files.\n\
2110 $cwd in the path means the current working directory.\n\
2111 This path is equivalent to the $PATH shell variable. It is a list of\n\
2112 directories, separated by colons. These directories are searched to find\n\
2113 fully linked executable files and separately compiled object files as needed."));
2114 set_cmd_completer (c
, filename_completer
);
2116 c
= add_cmd ("paths", no_class
, path_info
, _("\
2117 Current search path for finding object files.\n\
2118 $cwd in the path means the current working directory.\n\
2119 This path is equivalent to the $PATH shell variable. It is a list of\n\
2120 directories, separated by colons. These directories are searched to find\n\
2121 fully linked executable files and separately compiled object files as needed."),
2123 set_cmd_completer (c
, noop_completer
);
2125 add_com ("attach", class_run
, attach_command
, _("\
2126 Attach to a process or file outside of GDB.\n\
2127 This command attaches to another target, of the same type as your last\n\
2128 \"target\" command (\"info files\" will show your target stack).\n\
2129 The command may take as argument a process id or a device file.\n\
2130 For a process id, you must have permission to send the process a signal,\n\
2131 and it must have the same effective uid as the debugger.\n\
2132 When using \"attach\" with a process id, the debugger finds the\n\
2133 program running in the process, looking first in the current working\n\
2134 directory, or (if not found there) using the source file search path\n\
2135 (see the \"directory\" command). You can also use the \"file\" command\n\
2136 to specify the program, and to load its symbol table."));
2138 add_prefix_cmd ("detach", class_run
, detach_command
, _("\
2139 Detach a process or file previously attached.\n\
2140 If a process, it is no longer traced, and it continues its execution. If\n\
2141 you were debugging a file, the file is closed and gdb no longer accesses it."),
2142 &detachlist
, "detach ", 0, &cmdlist
);
2144 add_com ("disconnect", class_run
, disconnect_command
, _("\
2145 Disconnect from a target.\n\
2146 The target will wait for another debugger to connect. Not available for\n\
2149 add_com ("signal", class_run
, signal_command
, _("\
2150 Continue program giving it signal specified by the argument.\n\
2151 An argument of \"0\" means continue program without giving it a signal."));
2153 add_com ("stepi", class_run
, stepi_command
, _("\
2154 Step one instruction exactly.\n\
2155 Argument N means do this N times (or till program stops for another reason)."));
2156 add_com_alias ("si", "stepi", class_alias
, 0);
2158 add_com ("nexti", class_run
, nexti_command
, _("\
2159 Step one instruction, but proceed through subroutine calls.\n\
2160 Argument N means do this N times (or till program stops for another reason)."));
2161 add_com_alias ("ni", "nexti", class_alias
, 0);
2163 add_com ("finish", class_run
, finish_command
, _("\
2164 Execute until selected stack frame returns.\n\
2165 Upon return, the value returned is printed and put in the value history."));
2167 add_com ("next", class_run
, next_command
, _("\
2168 Step program, proceeding through subroutine calls.\n\
2169 Like the \"step\" command as long as subroutine calls do not happen;\n\
2170 when they do, the call is treated as one instruction.\n\
2171 Argument N means do this N times (or till program stops for another reason)."));
2172 add_com_alias ("n", "next", class_run
, 1);
2174 add_com_alias ("S", "next", class_run
, 1);
2176 add_com ("step", class_run
, step_command
, _("\
2177 Step program until it reaches a different source line.\n\
2178 Argument N means do this N times (or till program stops for another reason)."));
2179 add_com_alias ("s", "step", class_run
, 1);
2181 c
= add_com ("until", class_run
, until_command
, _("\
2182 Execute until the program reaches a source line greater than the current\n\
2183 or a specified location (same args as break command) within the current frame."));
2184 set_cmd_completer (c
, location_completer
);
2185 add_com_alias ("u", "until", class_run
, 1);
2187 c
= add_com ("advance", class_run
, advance_command
, _("\
2188 Continue the program up to the given location (same form as args for break command).\n\
2189 Execution will also stop upon exit from the current stack frame."));
2190 set_cmd_completer (c
, location_completer
);
2192 c
= add_com ("jump", class_run
, jump_command
, _("\
2193 Continue program being debugged at specified line or address.\n\
2194 Give as argument either LINENUM or *ADDR, where ADDR is an expression\n\
2195 for an address to start at."));
2196 set_cmd_completer (c
, location_completer
);
2200 c
= add_com ("go", class_run
, go_command
, _("\
2201 Usage: go <location>\n\
2202 Continue program being debugged, stopping at specified line or \n\
2204 Give as argument either LINENUM or *ADDR, where ADDR is an \n\
2205 expression for an address to start at.\n\
2206 This command is a combination of tbreak and jump."));
2207 set_cmd_completer (c
, location_completer
);
2211 add_com_alias ("g", "go", class_run
, 1);
2213 add_com ("continue", class_run
, continue_command
, _("\
2214 Continue program being debugged, after signal or breakpoint.\n\
2215 If proceeding from breakpoint, a number N may be used as an argument,\n\
2216 which means to set the ignore count of that breakpoint to N - 1 (so that\n\
2217 the breakpoint won't break until the Nth time it is reached)."));
2218 add_com_alias ("c", "cont", class_run
, 1);
2219 add_com_alias ("fg", "cont", class_run
, 1);
2221 c
= add_com ("run", class_run
, run_command
, _("\
2222 Start debugged program. You may specify arguments to give it.\n\
2223 Args may include \"*\", or \"[...]\"; they are expanded using \"sh\".\n\
2224 Input and output redirection with \">\", \"<\", or \">>\" are also allowed.\n\n\
2225 With no arguments, uses arguments last specified (with \"run\" or \"set args\").\n\
2226 To cancel previous arguments and run with no arguments,\n\
2227 use \"set args\" without arguments."));
2228 set_cmd_completer (c
, filename_completer
);
2229 add_com_alias ("r", "run", class_run
, 1);
2231 add_com ("R", class_run
, run_no_args_command
,
2232 _("Start debugged program with no arguments."));
2234 c
= add_com ("start", class_run
, start_command
, _("\
2235 Run the debugged program until the beginning of the main procedure.\n\
2236 You may specify arguments to give to your program, just as with the\n\
2237 \"run\" command."));
2238 set_cmd_completer (c
, filename_completer
);
2240 add_com ("interrupt", class_run
, interrupt_target_command
,
2241 _("Interrupt the execution of the debugged program."));
2243 add_info ("registers", nofp_registers_info
, _("\
2244 List of integer registers and their contents, for selected stack frame.\n\
2245 Register name as argument means describe only that register."));
2246 add_info_alias ("r", "registers", 1);
2249 add_com ("lr", class_info
, nofp_registers_info
, _("\
2250 List of integer registers and their contents, for selected stack frame.\n\
2251 Register name as argument means describe only that register."));
2252 add_info ("all-registers", all_registers_info
, _("\
2253 List of all registers and their contents, for selected stack frame.\n\
2254 Register name as argument means describe only that register."));
2256 add_info ("program", program_info
,
2257 _("Execution status of the program."));
2259 add_info ("float", float_info
,
2260 _("Print the status of the floating point unit\n"));
2262 add_info ("vector", vector_info
,
2263 _("Print the status of the vector unit\n"));
2265 inferior_environ
= make_environ ();
2266 init_environ (inferior_environ
);