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 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
)
453 && !query ("The program being debugged has been started already.\n\
454 Start it from the beginning? "))
455 error (_("Program not restarted."));
457 #if defined(SOLIB_RESTART)
460 init_wait_for_inferior ();
464 /* Implement the "run" command. If TBREAK_AT_MAIN is set, then insert
465 a temporary breakpoint at the begining of the main program before
466 running the program. */
469 run_command_1 (char *args
, int from_tty
, int tbreak_at_main
)
475 kill_if_already_running (from_tty
);
476 clear_breakpoint_hit_counts ();
478 /* Clean up any leftovers from other runs. Some other things from
479 this function should probably be moved into target_pre_inferior. */
480 target_pre_inferior (from_tty
);
482 /* Purge old solib objfiles. */
483 objfile_purge_solibs ();
487 /* The comment here used to read, "The exec file is re-read every
488 time we do a generic_mourn_inferior, so we just have to worry
489 about the symbol file." The `generic_mourn_inferior' function
490 gets called whenever the program exits. However, suppose the
491 program exits, and *then* the executable file changes? We need
492 to check again here. Since reopen_exec_file doesn't do anything
493 if the timestamp hasn't changed, I don't see the harm. */
497 /* Insert the temporary breakpoint if a location was specified. */
499 tbreak_command (main_name (), 0);
501 exec_file
= (char *) get_exec_file (0);
503 /* We keep symbols from add-symbol-file, on the grounds that the
504 user might want to add some symbols before running the program
505 (right?). But sometimes (dynamic loading where the user manually
506 introduces the new symbols with add-symbol-file), the code which
507 the symbols describe does not persist between runs. Currently
508 the user has to manually nuke all symbols between runs if they
509 want them to go away (PR 2207). This is probably reasonable. */
513 if (target_can_async_p ())
514 async_disable_stdin ();
518 int async_exec
= strip_bg_char (&args
);
520 /* If we get a request for running in the bg but the target
521 doesn't support it, error out. */
522 if (async_exec
&& !target_can_async_p ())
523 error (_("Asynchronous execution not supported on this target."));
525 /* If we don't get a request of running in the bg, then we need
526 to simulate synchronous (fg) execution. */
527 if (!async_exec
&& target_can_async_p ())
529 /* Simulate synchronous execution */
530 async_disable_stdin ();
533 /* If there were other args, beside '&', process them. */
536 char *old_args
= set_inferior_args (xstrdup (args
));
543 ui_out_field_string (uiout
, NULL
, "Starting program");
544 ui_out_text (uiout
, ": ");
546 ui_out_field_string (uiout
, "execfile", exec_file
);
547 ui_out_spaces (uiout
, 1);
548 /* We call get_inferior_args() because we might need to compute
550 ui_out_field_string (uiout
, "infargs", get_inferior_args ());
551 ui_out_text (uiout
, "\n");
552 ui_out_flush (uiout
);
555 /* We call get_inferior_args() because we might need to compute
557 target_create_inferior (exec_file
, get_inferior_args (),
558 environ_vector (inferior_environ
), from_tty
);
560 /* Pass zero for FROM_TTY, because at this point the "run" command
561 has done its thing; now we are setting up the running program. */
562 post_create_inferior (¤t_target
, 0);
564 /* Start the target running. */
565 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_0
, 0);
570 run_command (char *args
, int from_tty
)
572 run_command_1 (args
, from_tty
, 0);
576 run_no_args_command (char *args
, int from_tty
)
578 char *old_args
= set_inferior_args (xstrdup (""));
583 /* Start the execution of the program up until the beginning of the main
587 start_command (char *args
, int from_tty
)
589 /* Some languages such as Ada need to search inside the program
590 minimal symbols for the location where to put the temporary
591 breakpoint before starting. */
592 if (!have_minimal_symbols ())
593 error (_("No symbol table loaded. Use the \"file\" command."));
595 /* Run the program until reaching the main procedure... */
596 run_command_1 (args
, from_tty
, 1);
600 continue_command (char *proc_count_exp
, int from_tty
)
605 /* Find out whether we must run in the background. */
606 if (proc_count_exp
!= NULL
)
607 async_exec
= strip_bg_char (&proc_count_exp
);
609 /* If we must run in the background, but the target can't do it,
611 if (async_exec
&& !target_can_async_p ())
612 error (_("Asynchronous execution not supported on this target."));
614 /* If we are not asked to run in the bg, then prepare to run in the
615 foreground, synchronously. */
616 if (!async_exec
&& target_can_async_p ())
618 /* Simulate synchronous execution */
619 async_disable_stdin ();
622 /* If have argument (besides '&'), set proceed count of breakpoint
624 if (proc_count_exp
!= NULL
)
626 bpstat bs
= stop_bpstat
;
630 while ((stat
= bpstat_num (&bs
, &num
)) != 0)
633 set_ignore_count (num
,
634 parse_and_eval_long (proc_count_exp
) - 1,
636 /* set_ignore_count prints a message ending with a period.
637 So print two spaces before "Continuing.". */
639 printf_filtered (" ");
643 if (!stopped
&& from_tty
)
646 ("Not stopped at any breakpoint; argument ignored.\n");
651 printf_filtered (_("Continuing.\n"));
653 clear_proceed_status ();
655 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 0);
658 /* Step until outside of current statement. */
661 step_command (char *count_string
, int from_tty
)
663 step_1 (0, 0, count_string
);
666 /* Likewise, but skip over subroutine calls as if single instructions. */
669 next_command (char *count_string
, int from_tty
)
671 step_1 (1, 0, count_string
);
674 /* Likewise, but step only one instruction. */
677 stepi_command (char *count_string
, int from_tty
)
679 step_1 (0, 1, count_string
);
683 nexti_command (char *count_string
, int from_tty
)
685 step_1 (1, 1, count_string
);
689 disable_longjmp_breakpoint_cleanup (void *ignore
)
691 disable_longjmp_breakpoint ();
695 step_1 (int skip_subroutines
, int single_inst
, char *count_string
)
698 struct frame_info
*frame
;
699 struct cleanup
*cleanups
= 0;
705 async_exec
= strip_bg_char (&count_string
);
707 /* If we get a request for running in the bg but the target
708 doesn't support it, error out. */
709 if (async_exec
&& !target_can_async_p ())
710 error (_("Asynchronous execution not supported on this target."));
712 /* If we don't get a request of running in the bg, then we need
713 to simulate synchronous (fg) execution. */
714 if (!async_exec
&& target_can_async_p ())
716 /* Simulate synchronous execution */
717 async_disable_stdin ();
720 count
= count_string
? parse_and_eval_long (count_string
) : 1;
722 if (!single_inst
|| skip_subroutines
) /* leave si command alone */
724 enable_longjmp_breakpoint ();
725 if (!target_can_async_p ())
726 cleanups
= make_cleanup (disable_longjmp_breakpoint_cleanup
, 0 /*ignore*/);
728 make_exec_cleanup (disable_longjmp_breakpoint_cleanup
, 0 /*ignore*/);
731 /* In synchronous case, all is well, just use the regular for loop. */
732 if (!target_can_async_p ())
734 for (; count
> 0; count
--)
736 clear_proceed_status ();
738 frame
= get_current_frame ();
739 if (!frame
) /* Avoid coredump here. Why tho? */
740 error (_("No current frame"));
741 step_frame_id
= get_frame_id (frame
);
745 find_pc_line_pc_range (stop_pc
, &step_range_start
, &step_range_end
);
746 if (step_range_end
== 0)
749 if (find_pc_partial_function (stop_pc
, &name
, &step_range_start
,
750 &step_range_end
) == 0)
751 error (_("Cannot find bounds of current function"));
753 target_terminal_ours ();
754 printf_filtered (_("\
755 Single stepping until exit from function %s, \n\
756 which has no line number information.\n"), name
);
761 /* Say we are stepping, but stop after one insn whatever it does. */
762 step_range_start
= step_range_end
= 1;
763 if (!skip_subroutines
)
765 Don't step over function calls, not even to functions lacking
767 step_over_calls
= STEP_OVER_NONE
;
770 if (skip_subroutines
)
771 step_over_calls
= STEP_OVER_ALL
;
773 step_multi
= (count
> 1);
774 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 1);
780 if (!single_inst
|| skip_subroutines
)
781 do_cleanups (cleanups
);
784 /* In case of asynchronous target things get complicated, do only
785 one step for now, before returning control to the event loop. Let
786 the continuation figure out how many other steps we need to do,
787 and handle them one at the time, through step_once(). */
790 if (target_can_async_p ())
791 step_once (skip_subroutines
, single_inst
, count
);
795 /* Called after we are done with one step operation, to check whether
796 we need to step again, before we print the prompt and return control
797 to the user. If count is > 1, we will need to do one more call to
798 proceed(), via step_once(). Basically it is like step_once and
799 step_1_continuation are co-recursive. */
801 step_1_continuation (struct continuation_arg
*arg
)
804 int skip_subroutines
;
807 skip_subroutines
= arg
->data
.integer
;
808 single_inst
= arg
->next
->data
.integer
;
809 count
= arg
->next
->next
->data
.integer
;
812 step_once (skip_subroutines
, single_inst
, count
- 1);
814 if (!single_inst
|| skip_subroutines
)
815 do_exec_cleanups (ALL_CLEANUPS
);
818 /* Do just one step operation. If count >1 we will have to set up a
819 continuation to be done after the target stops (after this one
820 step). This is useful to implement the 'step n' kind of commands, in
821 case of asynchronous targets. We had to split step_1 into two parts,
822 one to be done before proceed() and one afterwards. This function is
823 called in case of step n with n>1, after the first step operation has
826 step_once (int skip_subroutines
, int single_inst
, int count
)
828 struct continuation_arg
*arg1
;
829 struct continuation_arg
*arg2
;
830 struct continuation_arg
*arg3
;
831 struct frame_info
*frame
;
835 clear_proceed_status ();
837 frame
= get_current_frame ();
838 if (!frame
) /* Avoid coredump here. Why tho? */
839 error (_("No current frame"));
840 step_frame_id
= get_frame_id (frame
);
844 find_pc_line_pc_range (stop_pc
, &step_range_start
, &step_range_end
);
846 /* If we have no line info, switch to stepi mode. */
847 if (step_range_end
== 0 && step_stop_if_no_debug
)
849 step_range_start
= step_range_end
= 1;
851 else if (step_range_end
== 0)
854 if (find_pc_partial_function (stop_pc
, &name
, &step_range_start
,
855 &step_range_end
) == 0)
856 error (_("Cannot find bounds of current function"));
858 target_terminal_ours ();
859 printf_filtered (_("\
860 Single stepping until exit from function %s, \n\
861 which has no line number information.\n"), name
);
866 /* Say we are stepping, but stop after one insn whatever it does. */
867 step_range_start
= step_range_end
= 1;
868 if (!skip_subroutines
)
870 Don't step over function calls, not even to functions lacking
872 step_over_calls
= STEP_OVER_NONE
;
875 if (skip_subroutines
)
876 step_over_calls
= STEP_OVER_ALL
;
878 step_multi
= (count
> 1);
880 (struct continuation_arg
*) xmalloc (sizeof (struct continuation_arg
));
882 (struct continuation_arg
*) xmalloc (sizeof (struct continuation_arg
));
884 (struct continuation_arg
*) xmalloc (sizeof (struct continuation_arg
));
886 arg1
->data
.integer
= skip_subroutines
;
888 arg2
->data
.integer
= single_inst
;
890 arg3
->data
.integer
= count
;
891 add_intermediate_continuation (step_1_continuation
, arg1
);
892 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 1);
897 /* Continue program at specified address. */
900 jump_command (char *arg
, int from_tty
)
903 struct symtabs_and_lines sals
;
904 struct symtab_and_line sal
;
911 /* Find out whether we must run in the background. */
913 async_exec
= strip_bg_char (&arg
);
915 /* If we must run in the background, but the target can't do it,
917 if (async_exec
&& !target_can_async_p ())
918 error (_("Asynchronous execution not supported on this target."));
920 /* If we are not asked to run in the bg, then prepare to run in the
921 foreground, synchronously. */
922 if (!async_exec
&& target_can_async_p ())
924 /* Simulate synchronous execution */
925 async_disable_stdin ();
929 error_no_arg (_("starting address"));
931 sals
= decode_line_spec_1 (arg
, 1);
934 error (_("Unreasonable jump request"));
940 if (sal
.symtab
== 0 && sal
.pc
== 0)
941 error (_("No source file has been specified."));
943 resolve_sal_pc (&sal
); /* May error out */
945 /* See if we are trying to jump to another function. */
946 fn
= get_frame_function (get_current_frame ());
947 sfn
= find_pc_function (sal
.pc
);
948 if (fn
!= NULL
&& sfn
!= fn
)
950 if (!query ("Line %d is not in `%s'. Jump anyway? ", sal
.line
,
951 SYMBOL_PRINT_NAME (fn
)))
953 error (_("Not confirmed."));
960 fixup_symbol_section (sfn
, 0);
961 if (section_is_overlay (SYMBOL_BFD_SECTION (sfn
)) &&
962 !section_is_mapped (SYMBOL_BFD_SECTION (sfn
)))
964 if (!query ("WARNING!!! Destination is in unmapped overlay! Jump anyway? "))
966 error (_("Not confirmed."));
976 printf_filtered (_("Continuing at "));
977 deprecated_print_address_numeric (addr
, 1, gdb_stdout
);
978 printf_filtered (".\n");
981 clear_proceed_status ();
982 proceed (addr
, TARGET_SIGNAL_0
, 0);
986 /* Go to line or address in current procedure */
988 go_command (char *line_no
, int from_tty
)
990 if (line_no
== (char *) NULL
|| !*line_no
)
991 printf_filtered (GO_USAGE
);
994 tbreak_command (line_no
, from_tty
);
995 jump_command (line_no
, from_tty
);
1000 /* Continue program giving it specified signal. */
1003 signal_command (char *signum_exp
, int from_tty
)
1005 enum target_signal oursig
;
1007 dont_repeat (); /* Too dangerous. */
1011 error_no_arg (_("signal number"));
1013 /* It would be even slicker to make signal names be valid expressions,
1014 (the type could be "enum $signal" or some such), then the user could
1015 assign them to convenience variables. */
1016 oursig
= target_signal_from_name (signum_exp
);
1018 if (oursig
== TARGET_SIGNAL_UNKNOWN
)
1020 /* No, try numeric. */
1021 int num
= parse_and_eval_long (signum_exp
);
1024 oursig
= TARGET_SIGNAL_0
;
1026 oursig
= target_signal_from_command (num
);
1031 if (oursig
== TARGET_SIGNAL_0
)
1032 printf_filtered (_("Continuing with no signal.\n"));
1034 printf_filtered (_("Continuing with signal %s.\n"),
1035 target_signal_to_name (oursig
));
1038 clear_proceed_status ();
1039 /* "signal 0" should not get stuck if we are stopped at a breakpoint.
1040 FIXME: Neither should "signal foo" but when I tried passing
1041 (CORE_ADDR)-1 unconditionally I got a testsuite failure which I haven't
1042 tried to track down yet. */
1043 proceed (oursig
== TARGET_SIGNAL_0
? (CORE_ADDR
) -1 : stop_pc
, oursig
, 0);
1046 /* Proceed until we reach a different source line with pc greater than
1047 our current one or exit the function. We skip calls in both cases.
1049 Note that eventually this command should probably be changed so
1050 that only source lines are printed out when we hit the breakpoint
1051 we set. This may involve changes to wait_for_inferior and the
1052 proceed status code. */
1055 until_next_command (int from_tty
)
1057 struct frame_info
*frame
;
1059 struct symbol
*func
;
1060 struct symtab_and_line sal
;
1062 clear_proceed_status ();
1064 frame
= get_current_frame ();
1066 /* Step until either exited from this function or greater
1067 than the current line (if in symbolic section) or pc (if
1071 func
= find_pc_function (pc
);
1075 struct minimal_symbol
*msymbol
= lookup_minimal_symbol_by_pc (pc
);
1077 if (msymbol
== NULL
)
1078 error (_("Execution is not within a known function."));
1080 step_range_start
= SYMBOL_VALUE_ADDRESS (msymbol
);
1081 step_range_end
= pc
;
1085 sal
= find_pc_line (pc
, 0);
1087 step_range_start
= BLOCK_START (SYMBOL_BLOCK_VALUE (func
));
1088 step_range_end
= sal
.end
;
1091 step_over_calls
= STEP_OVER_ALL
;
1092 step_frame_id
= get_frame_id (frame
);
1094 step_multi
= 0; /* Only one call to proceed */
1096 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 1);
1100 until_command (char *arg
, int from_tty
)
1104 if (!target_has_execution
)
1105 error (_("The program is not running."));
1107 /* Find out whether we must run in the background. */
1109 async_exec
= strip_bg_char (&arg
);
1111 /* If we must run in the background, but the target can't do it,
1113 if (async_exec
&& !target_can_async_p ())
1114 error (_("Asynchronous execution not supported on this target."));
1116 /* If we are not asked to run in the bg, then prepare to run in the
1117 foreground, synchronously. */
1118 if (!async_exec
&& target_can_async_p ())
1120 /* Simulate synchronous execution */
1121 async_disable_stdin ();
1125 until_break_command (arg
, from_tty
, 0);
1127 until_next_command (from_tty
);
1131 advance_command (char *arg
, int from_tty
)
1135 if (!target_has_execution
)
1136 error (_("The program is not running."));
1139 error_no_arg (_("a location"));
1141 /* Find out whether we must run in the background. */
1143 async_exec
= strip_bg_char (&arg
);
1145 /* If we must run in the background, but the target can't do it,
1147 if (async_exec
&& !target_can_async_p ())
1148 error (_("Asynchronous execution not supported on this target."));
1150 /* If we are not asked to run in the bg, then prepare to run in the
1151 foreground, synchronously. */
1152 if (!async_exec
&& target_can_async_p ())
1154 /* Simulate synchronous execution. */
1155 async_disable_stdin ();
1158 until_break_command (arg
, from_tty
, 1);
1161 /* Print the result of a function at the end of a 'finish' command. */
1164 print_return_value (struct type
*value_type
)
1166 struct gdbarch
*gdbarch
= current_gdbarch
;
1167 struct cleanup
*old_chain
;
1168 struct ui_stream
*stb
;
1169 struct value
*value
;
1171 CHECK_TYPEDEF (value_type
);
1172 gdb_assert (TYPE_CODE (value_type
) != TYPE_CODE_VOID
);
1174 /* FIXME: 2003-09-27: When returning from a nested inferior function
1175 call, it's possible (with no help from the architecture vector)
1176 to locate and return/print a "struct return" value. This is just
1177 a more complicated case of what is already being done in in the
1178 inferior function call code. In fact, when inferior function
1179 calls are made async, this will likely be made the norm. */
1181 switch (gdbarch_return_value (gdbarch
, value_type
, NULL
, NULL
, NULL
))
1183 case RETURN_VALUE_REGISTER_CONVENTION
:
1184 case RETURN_VALUE_ABI_RETURNS_ADDRESS
:
1185 case RETURN_VALUE_ABI_PRESERVES_ADDRESS
:
1186 value
= allocate_value (value_type
);
1187 gdbarch_return_value (gdbarch
, value_type
, stop_registers
,
1188 value_contents_raw (value
), NULL
);
1190 case RETURN_VALUE_STRUCT_CONVENTION
:
1194 internal_error (__FILE__
, __LINE__
, _("bad switch"));
1200 stb
= ui_out_stream_new (uiout
);
1201 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
1202 ui_out_text (uiout
, "Value returned is ");
1203 ui_out_field_fmt (uiout
, "gdb-result-var", "$%d",
1204 record_latest_value (value
));
1205 ui_out_text (uiout
, " = ");
1206 value_print (value
, stb
->stream
, 0, Val_no_prettyprint
);
1207 ui_out_field_stream (uiout
, "return-value", stb
);
1208 ui_out_text (uiout
, "\n");
1209 do_cleanups (old_chain
);
1213 ui_out_text (uiout
, "Value returned has type: ");
1214 ui_out_field_string (uiout
, "return-type", TYPE_NAME (value_type
));
1215 ui_out_text (uiout
, ".");
1216 ui_out_text (uiout
, " Cannot determine contents\n");
1220 /* Stuff that needs to be done by the finish command after the target
1221 has stopped. In asynchronous mode, we wait for the target to stop
1222 in the call to poll or select in the event loop, so it is
1223 impossible to do all the stuff as part of the finish_command
1224 function itself. The only chance we have to complete this command
1225 is in fetch_inferior_event, which is called by the event loop as
1226 soon as it detects that the target has stopped. This function is
1227 called via the cmd_continuation pointer. */
1230 finish_command_continuation (struct continuation_arg
*arg
)
1232 struct symbol
*function
;
1233 struct breakpoint
*breakpoint
;
1234 struct cleanup
*cleanups
;
1236 breakpoint
= (struct breakpoint
*) arg
->data
.pointer
;
1237 function
= (struct symbol
*) arg
->next
->data
.pointer
;
1238 cleanups
= (struct cleanup
*) arg
->next
->next
->data
.pointer
;
1240 if (bpstat_find_breakpoint (stop_bpstat
, breakpoint
) != NULL
1241 && function
!= NULL
)
1243 struct type
*value_type
;
1245 value_type
= TYPE_TARGET_TYPE (SYMBOL_TYPE (function
));
1247 internal_error (__FILE__
, __LINE__
,
1248 _("finish_command: function has no target type"));
1250 if (TYPE_CODE (value_type
) != TYPE_CODE_VOID
)
1251 print_return_value (value_type
);
1254 do_exec_cleanups (cleanups
);
1257 /* "finish": Set a temporary breakpoint at the place the selected
1258 frame will return to, then continue. */
1261 finish_command (char *arg
, int from_tty
)
1263 struct symtab_and_line sal
;
1264 struct frame_info
*frame
;
1265 struct symbol
*function
;
1266 struct breakpoint
*breakpoint
;
1267 struct cleanup
*old_chain
;
1268 struct continuation_arg
*arg1
, *arg2
, *arg3
;
1272 /* Find out whether we must run in the background. */
1274 async_exec
= strip_bg_char (&arg
);
1276 /* If we must run in the background, but the target can't do it,
1278 if (async_exec
&& !target_can_async_p ())
1279 error (_("Asynchronous execution not supported on this target."));
1281 /* If we are not asked to run in the bg, then prepare to run in the
1282 foreground, synchronously. */
1283 if (!async_exec
&& target_can_async_p ())
1285 /* Simulate synchronous execution. */
1286 async_disable_stdin ();
1290 error (_("The \"finish\" command does not take any arguments."));
1291 if (!target_has_execution
)
1292 error (_("The program is not running."));
1294 frame
= get_prev_frame (get_selected_frame (_("No selected frame.")));
1296 error (_("\"finish\" not meaningful in the outermost frame."));
1298 clear_proceed_status ();
1300 sal
= find_pc_line (get_frame_pc (frame
), 0);
1301 sal
.pc
= get_frame_pc (frame
);
1303 breakpoint
= set_momentary_breakpoint (sal
, get_frame_id (frame
), bp_finish
);
1305 if (!target_can_async_p ())
1306 old_chain
= make_cleanup_delete_breakpoint (breakpoint
);
1308 old_chain
= make_exec_cleanup_delete_breakpoint (breakpoint
);
1310 /* Find the function we will return from. */
1312 function
= find_pc_function (get_frame_pc (get_selected_frame (NULL
)));
1314 /* Print info on the selected frame, including level number but not
1318 printf_filtered (_("Run till exit from "));
1319 print_stack_frame (get_selected_frame (NULL
), 1, LOCATION
);
1322 /* If running asynchronously and the target support asynchronous
1323 execution, set things up for the rest of the finish command to be
1324 completed later on, when gdb has detected that the target has
1325 stopped, in fetch_inferior_event. */
1326 if (target_can_async_p ())
1329 (struct continuation_arg
*) xmalloc (sizeof (struct continuation_arg
));
1331 (struct continuation_arg
*) xmalloc (sizeof (struct continuation_arg
));
1333 (struct continuation_arg
*) xmalloc (sizeof (struct continuation_arg
));
1337 arg1
->data
.pointer
= breakpoint
;
1338 arg2
->data
.pointer
= function
;
1339 arg3
->data
.pointer
= old_chain
;
1340 add_continuation (finish_command_continuation
, arg1
);
1343 proceed_to_finish
= 1; /* We want stop_registers, please... */
1344 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 0);
1346 /* Do this only if not running asynchronously or if the target
1347 cannot do async execution. Otherwise, complete this command when
1348 the target actually stops, in fetch_inferior_event. */
1349 if (!target_can_async_p ())
1351 /* Did we stop at our breakpoint? */
1352 if (bpstat_find_breakpoint (stop_bpstat
, breakpoint
) != NULL
1353 && function
!= NULL
)
1355 struct type
*value_type
;
1357 value_type
= TYPE_TARGET_TYPE (SYMBOL_TYPE (function
));
1359 internal_error (__FILE__
, __LINE__
,
1360 _("finish_command: function has no target type"));
1362 if (TYPE_CODE (value_type
) != TYPE_CODE_VOID
)
1363 print_return_value (value_type
);
1366 do_cleanups (old_chain
);
1372 program_info (char *args
, int from_tty
)
1374 bpstat bs
= stop_bpstat
;
1376 int stat
= bpstat_num (&bs
, &num
);
1378 if (!target_has_execution
)
1380 printf_filtered (_("The program being debugged is not being run.\n"));
1384 target_files_info ();
1385 printf_filtered (_("Program stopped at %s.\n"),
1386 hex_string ((unsigned long) stop_pc
));
1388 printf_filtered (_("It stopped after being stepped.\n"));
1391 /* There may be several breakpoints in the same place, so this
1392 isn't as strange as it seems. */
1397 printf_filtered (_("\
1398 It stopped at a breakpoint that has since been deleted.\n"));
1401 printf_filtered (_("It stopped at breakpoint %d.\n"), num
);
1402 stat
= bpstat_num (&bs
, &num
);
1405 else if (stop_signal
!= TARGET_SIGNAL_0
)
1407 printf_filtered (_("It stopped with signal %s, %s.\n"),
1408 target_signal_to_name (stop_signal
),
1409 target_signal_to_string (stop_signal
));
1414 printf_filtered (_("\
1415 Type \"info stack\" or \"info registers\" for more information.\n"));
1420 environment_info (char *var
, int from_tty
)
1424 char *val
= get_in_environ (inferior_environ
, var
);
1427 puts_filtered (var
);
1428 puts_filtered (" = ");
1429 puts_filtered (val
);
1430 puts_filtered ("\n");
1434 puts_filtered ("Environment variable \"");
1435 puts_filtered (var
);
1436 puts_filtered ("\" not defined.\n");
1441 char **vector
= environ_vector (inferior_environ
);
1444 puts_filtered (*vector
++);
1445 puts_filtered ("\n");
1451 set_environment_command (char *arg
, int from_tty
)
1453 char *p
, *val
, *var
;
1457 error_no_arg (_("environment variable and value"));
1459 /* Find seperation between variable name and value */
1460 p
= (char *) strchr (arg
, '=');
1461 val
= (char *) strchr (arg
, ' ');
1463 if (p
!= 0 && val
!= 0)
1465 /* We have both a space and an equals. If the space is before the
1466 equals, walk forward over the spaces til we see a nonspace
1467 (possibly the equals). */
1472 /* Now if the = is after the char following the spaces,
1473 take the char following the spaces. */
1477 else if (val
!= 0 && p
== 0)
1481 error_no_arg (_("environment variable to set"));
1483 if (p
== 0 || p
[1] == 0)
1487 p
= arg
+ strlen (arg
); /* So that savestring below will work */
1491 /* Not setting variable value to null */
1493 while (*val
== ' ' || *val
== '\t')
1497 while (p
!= arg
&& (p
[-1] == ' ' || p
[-1] == '\t'))
1500 var
= savestring (arg
, p
- arg
);
1503 printf_filtered (_("\
1504 Setting environment variable \"%s\" to null value.\n"),
1506 set_in_environ (inferior_environ
, var
, "");
1509 set_in_environ (inferior_environ
, var
, val
);
1514 unset_environment_command (char *var
, int from_tty
)
1518 /* If there is no argument, delete all environment variables.
1519 Ask for confirmation if reading from the terminal. */
1520 if (!from_tty
|| query (_("Delete all environment variables? ")))
1522 free_environ (inferior_environ
);
1523 inferior_environ
= make_environ ();
1527 unset_in_environ (inferior_environ
, var
);
1530 /* Handle the execution path (PATH variable) */
1532 static const char path_var_name
[] = "PATH";
1535 path_info (char *args
, int from_tty
)
1537 puts_filtered ("Executable and object file path: ");
1538 puts_filtered (get_in_environ (inferior_environ
, path_var_name
));
1539 puts_filtered ("\n");
1542 /* Add zero or more directories to the front of the execution path. */
1545 path_command (char *dirname
, int from_tty
)
1550 env
= get_in_environ (inferior_environ
, path_var_name
);
1551 /* Can be null if path is not set */
1554 exec_path
= xstrdup (env
);
1555 mod_path (dirname
, &exec_path
);
1556 set_in_environ (inferior_environ
, path_var_name
, exec_path
);
1559 path_info ((char *) NULL
, from_tty
);
1563 /* Print out the machine register regnum. If regnum is -1, print all
1564 registers (print_all == 1) or all non-float and non-vector
1565 registers (print_all == 0).
1567 For most machines, having all_registers_info() print the
1568 register(s) one per line is good enough. If a different format is
1569 required, (eg, for MIPS or Pyramid 90x, which both have lots of
1570 regs), or there is an existing convention for showing all the
1571 registers, define the architecture method PRINT_REGISTERS_INFO to
1572 provide that format. */
1575 default_print_registers_info (struct gdbarch
*gdbarch
,
1576 struct ui_file
*file
,
1577 struct frame_info
*frame
,
1578 int regnum
, int print_all
)
1581 const int numregs
= gdbarch_num_regs (gdbarch
)
1582 + gdbarch_num_pseudo_regs (gdbarch
);
1583 gdb_byte buffer
[MAX_REGISTER_SIZE
];
1585 for (i
= 0; i
< numregs
; i
++)
1587 /* Decide between printing all regs, non-float / vector regs, or
1593 if (!gdbarch_register_reggroup_p (gdbarch
, i
, all_reggroup
))
1598 if (!gdbarch_register_reggroup_p (gdbarch
, i
, general_reggroup
))
1608 /* If the register name is empty, it is undefined for this
1609 processor, so don't display anything. */
1610 if (gdbarch_register_name (gdbarch
, i
) == NULL
1611 || *(gdbarch_register_name (gdbarch
, i
)) == '\0')
1614 fputs_filtered (gdbarch_register_name (gdbarch
, i
), file
);
1615 print_spaces_filtered (15 - strlen (gdbarch_register_name
1616 (gdbarch
, i
)), file
);
1618 /* Get the data in raw format. */
1619 if (! frame_register_read (frame
, i
, buffer
))
1621 fprintf_filtered (file
, "*value not available*\n");
1625 /* If virtual format is floating, print it that way, and in raw
1627 if (TYPE_CODE (register_type (gdbarch
, i
)) == TYPE_CODE_FLT
)
1631 val_print (register_type (gdbarch
, i
), buffer
, 0, 0,
1632 file
, 0, 1, 0, Val_pretty_default
);
1634 fprintf_filtered (file
, "\t(raw 0x");
1635 for (j
= 0; j
< register_size (gdbarch
, i
); j
++)
1638 if (gdbarch_byte_order (gdbarch
) == BFD_ENDIAN_BIG
)
1641 idx
= register_size (gdbarch
, i
) - 1 - j
;
1642 fprintf_filtered (file
, "%02x", (unsigned char) buffer
[idx
]);
1644 fprintf_filtered (file
, ")");
1648 /* Print the register in hex. */
1649 val_print (register_type (gdbarch
, i
), buffer
, 0, 0,
1650 file
, 'x', 1, 0, Val_pretty_default
);
1651 /* If not a vector register, print it also according to its
1653 if (TYPE_VECTOR (register_type (gdbarch
, i
)) == 0)
1655 fprintf_filtered (file
, "\t");
1656 val_print (register_type (gdbarch
, i
), buffer
, 0, 0,
1657 file
, 0, 1, 0, Val_pretty_default
);
1661 fprintf_filtered (file
, "\n");
1666 registers_info (char *addr_exp
, int fpregs
)
1668 struct frame_info
*frame
;
1669 struct gdbarch
*gdbarch
;
1670 int regnum
, numregs
;
1673 if (!target_has_registers
)
1674 error (_("The program has no registers now."));
1675 frame
= get_selected_frame (NULL
);
1676 gdbarch
= get_frame_arch (frame
);
1680 gdbarch_print_registers_info (gdbarch
, gdb_stdout
,
1685 while (*addr_exp
!= '\0')
1690 /* Keep skipping leading white space. */
1691 if (isspace ((*addr_exp
)))
1697 /* Discard any leading ``$''. Check that there is something
1698 resembling a register following it. */
1699 if (addr_exp
[0] == '$')
1701 if (isspace ((*addr_exp
)) || (*addr_exp
) == '\0')
1702 error (_("Missing register name"));
1704 /* Find the start/end of this register name/num/group. */
1706 while ((*addr_exp
) != '\0' && !isspace ((*addr_exp
)))
1710 /* Figure out what we've found and display it. */
1712 /* A register name? */
1714 int regnum
= frame_map_name_to_regnum (frame
, start
, end
- start
);
1717 /* User registers lie completely outside of the range of
1718 normal registers. Catch them early so that the target
1720 if (regnum
>= gdbarch_num_regs (gdbarch
)
1721 + gdbarch_num_pseudo_regs (gdbarch
))
1723 struct value
*val
= value_of_user_reg (regnum
, frame
);
1725 printf_filtered ("%s: ", start
);
1726 print_scalar_formatted (value_contents (val
),
1727 check_typedef (value_type (val
)),
1728 'x', 0, gdb_stdout
);
1729 printf_filtered ("\n");
1732 gdbarch_print_registers_info (gdbarch
, gdb_stdout
,
1733 frame
, regnum
, fpregs
);
1738 /* A register number? (how portable is this one?). */
1741 int regnum
= strtol (start
, &endptr
, 0);
1744 && regnum
< gdbarch_num_regs (gdbarch
)
1745 + gdbarch_num_pseudo_regs (gdbarch
))
1747 gdbarch_print_registers_info (gdbarch
, gdb_stdout
,
1748 frame
, regnum
, fpregs
);
1753 /* A register group? */
1755 struct reggroup
*group
;
1756 for (group
= reggroup_next (gdbarch
, NULL
);
1758 group
= reggroup_next (gdbarch
, group
))
1760 /* Don't bother with a length check. Should the user
1761 enter a short register group name, go with the first
1762 group that matches. */
1763 if (strncmp (start
, reggroup_name (group
), end
- start
) == 0)
1770 regnum
< gdbarch_num_regs (gdbarch
)
1771 + gdbarch_num_pseudo_regs (gdbarch
);
1774 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, group
))
1775 gdbarch_print_registers_info (gdbarch
,
1783 /* Nothing matched. */
1784 error (_("Invalid register `%.*s'"), (int) (end
- start
), start
);
1789 all_registers_info (char *addr_exp
, int from_tty
)
1791 registers_info (addr_exp
, 1);
1795 nofp_registers_info (char *addr_exp
, int from_tty
)
1797 registers_info (addr_exp
, 0);
1801 print_vector_info (struct gdbarch
*gdbarch
, struct ui_file
*file
,
1802 struct frame_info
*frame
, const char *args
)
1804 if (gdbarch_print_vector_info_p (gdbarch
))
1805 gdbarch_print_vector_info (gdbarch
, file
, frame
, args
);
1809 int printed_something
= 0;
1812 regnum
< gdbarch_num_regs (gdbarch
)
1813 + gdbarch_num_pseudo_regs (gdbarch
);
1816 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, vector_reggroup
))
1818 printed_something
= 1;
1819 gdbarch_print_registers_info (gdbarch
, file
, frame
, regnum
, 1);
1822 if (!printed_something
)
1823 fprintf_filtered (file
, "No vector information\n");
1828 vector_info (char *args
, int from_tty
)
1830 if (!target_has_registers
)
1831 error (_("The program has no registers now."));
1833 print_vector_info (current_gdbarch
, gdb_stdout
,
1834 get_selected_frame (NULL
), args
);
1840 * Should save/restore the tty state since it might be that the
1841 * program to be debugged was started on this tty and it wants
1842 * the tty in some state other than what we want. If it's running
1843 * on another terminal or without a terminal, then saving and
1844 * restoring the tty state is a harmless no-op.
1845 * This only needs to be done if we are attaching to a process.
1850 takes a program started up outside of gdb and ``attaches'' to it.
1851 This stops it cold in its tracks and allows us to start debugging it.
1852 and wait for the trace-trap that results from attaching. */
1855 attach_command (char *args
, int from_tty
)
1858 char *full_exec_path
= NULL
;
1860 dont_repeat (); /* Not for the faint of heart */
1862 if (target_has_execution
)
1864 if (query ("A program is being debugged already. Kill it? "))
1867 error (_("Not killed."));
1870 /* Clean up any leftovers from other runs. Some other things from
1871 this function should probably be moved into target_pre_inferior. */
1872 target_pre_inferior (from_tty
);
1874 /* Clear out solib state. Otherwise the solib state of the previous
1875 inferior might have survived and is entirely wrong for the new
1876 target. This has been observed on GNU/Linux using glibc 2.3. How
1888 Cannot access memory at address 0xdeadbeef
1892 target_attach (args
, from_tty
);
1894 /* Set up the "saved terminal modes" of the inferior
1895 based on what modes we are starting it with. */
1896 target_terminal_init ();
1898 /* Set up execution context to know that we should return from
1899 wait_for_inferior as soon as the target reports a stop. */
1900 init_wait_for_inferior ();
1901 clear_proceed_status ();
1903 /* No traps are generated when attaching to inferior under Mach 3
1905 #ifndef ATTACH_NO_WAIT
1906 /* Careful here. See comments in inferior.h. Basically some OSes
1907 don't ignore SIGSTOPs on continue requests anymore. We need a
1908 way for handle_inferior_event to reset the stop_signal variable
1909 after an attach, and this is what STOP_QUIETLY_NO_SIGSTOP is for. */
1910 stop_soon
= STOP_QUIETLY_NO_SIGSTOP
;
1911 wait_for_inferior ();
1912 stop_soon
= NO_STOP_QUIETLY
;
1916 * If no exec file is yet known, try to determine it from the
1919 exec_file
= (char *) get_exec_file (0);
1922 exec_file
= target_pid_to_exec_file (PIDGET (inferior_ptid
));
1925 /* It's possible we don't have a full path, but rather just a
1926 filename. Some targets, such as HP-UX, don't provide the
1929 Attempt to qualify the filename against the source path.
1930 (If that fails, we'll just fall back on the original
1931 filename. Not much more we can do...)
1933 if (!source_full_path_of (exec_file
, &full_exec_path
))
1934 full_exec_path
= savestring (exec_file
, strlen (exec_file
));
1936 exec_file_attach (full_exec_path
, from_tty
);
1937 symbol_file_add_main (full_exec_path
, from_tty
);
1942 reopen_exec_file ();
1946 /* Take any necessary post-attaching actions for this platform.
1948 target_post_attach (PIDGET (inferior_ptid
));
1950 post_create_inferior (¤t_target
, from_tty
);
1952 /* Install inferior's terminal modes. */
1953 target_terminal_inferior ();
1957 if (deprecated_attach_hook
)
1958 deprecated_attach_hook ();
1963 * takes a program previously attached to and detaches it.
1964 * The program resumes execution and will no longer stop
1965 * on signals, etc. We better not have left any breakpoints
1966 * in the program or it'll die when it hits one. For this
1967 * to work, it may be necessary for the process to have been
1968 * previously attached. It *might* work if the program was
1969 * started via the normal ptrace (PTRACE_TRACEME).
1973 detach_command (char *args
, int from_tty
)
1975 dont_repeat (); /* Not for the faint of heart. */
1976 target_detach (args
, from_tty
);
1977 #if defined(SOLIB_RESTART)
1980 if (deprecated_detach_hook
)
1981 deprecated_detach_hook ();
1984 /* Disconnect from the current target without resuming it (leaving it
1985 waiting for a debugger).
1987 We'd better not have left any breakpoints in the program or the
1988 next debugger will get confused. Currently only supported for some
1989 remote targets, since the normal attach mechanisms don't work on
1990 stopped processes on some native platforms (e.g. GNU/Linux). */
1993 disconnect_command (char *args
, int from_tty
)
1995 dont_repeat (); /* Not for the faint of heart */
1996 target_disconnect (args
, from_tty
);
1997 #if defined(SOLIB_RESTART)
2000 if (deprecated_detach_hook
)
2001 deprecated_detach_hook ();
2004 /* Stop the execution of the target while running in async mode, in
2007 interrupt_target_command (char *args
, int from_tty
)
2009 if (target_can_async_p ())
2011 dont_repeat (); /* Not for the faint of heart */
2017 print_float_info (struct gdbarch
*gdbarch
, struct ui_file
*file
,
2018 struct frame_info
*frame
, const char *args
)
2020 if (gdbarch_print_float_info_p (gdbarch
))
2021 gdbarch_print_float_info (gdbarch
, file
, frame
, args
);
2025 int printed_something
= 0;
2028 regnum
< gdbarch_num_regs (gdbarch
)
2029 + gdbarch_num_pseudo_regs (gdbarch
);
2032 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, float_reggroup
))
2034 printed_something
= 1;
2035 gdbarch_print_registers_info (gdbarch
, file
, frame
, regnum
, 1);
2038 if (!printed_something
)
2039 fprintf_filtered (file
, "\
2040 No floating-point info available for this processor.\n");
2045 float_info (char *args
, int from_tty
)
2047 if (!target_has_registers
)
2048 error (_("The program has no registers now."));
2050 print_float_info (current_gdbarch
, gdb_stdout
,
2051 get_selected_frame (NULL
), args
);
2055 unset_command (char *args
, int from_tty
)
2057 printf_filtered (_("\
2058 \"unset\" must be followed by the name of an unset subcommand.\n"));
2059 help_list (unsetlist
, "unset ", -1, gdb_stdout
);
2063 _initialize_infcmd (void)
2065 struct cmd_list_element
*c
= NULL
;
2067 /* add the filename of the terminal connected to inferior I/O */
2068 add_setshow_filename_cmd ("inferior-tty", class_run
,
2069 &inferior_io_terminal
, _("\
2070 Set terminal for future runs of program being debugged."), _("\
2071 Show terminal for future runs of program being debugged."), _("\
2072 Usage: set inferior-tty /dev/pts/1"), NULL
, NULL
, &setlist
, &showlist
);
2073 add_com_alias ("tty", "set inferior-tty", class_alias
, 0);
2075 add_setshow_optional_filename_cmd ("args", class_run
,
2076 &inferior_args
, _("\
2077 Set argument list to give program being debugged when it is started."), _("\
2078 Show argument list to give program being debugged when it is started."), _("\
2079 Follow this command with any number of args, to be passed to the program."),
2082 &setlist
, &showlist
);
2084 c
= add_cmd ("environment", no_class
, environment_info
, _("\
2085 The environment to give the program, or one variable's value.\n\
2086 With an argument VAR, prints the value of environment variable VAR to\n\
2087 give the program being debugged. With no arguments, prints the entire\n\
2088 environment to be given to the program."), &showlist
);
2089 set_cmd_completer (c
, noop_completer
);
2091 add_prefix_cmd ("unset", no_class
, unset_command
,
2092 _("Complement to certain \"set\" commands."),
2093 &unsetlist
, "unset ", 0, &cmdlist
);
2095 c
= add_cmd ("environment", class_run
, unset_environment_command
, _("\
2096 Cancel environment variable VAR for the program.\n\
2097 This does not affect the program until the next \"run\" command."),
2099 set_cmd_completer (c
, noop_completer
);
2101 c
= add_cmd ("environment", class_run
, set_environment_command
, _("\
2102 Set environment variable value to give the program.\n\
2103 Arguments are VAR VALUE where VAR is variable name and VALUE is value.\n\
2104 VALUES of environment variables are uninterpreted strings.\n\
2105 This does not affect the program until the next \"run\" command."),
2107 set_cmd_completer (c
, noop_completer
);
2109 c
= add_com ("path", class_files
, path_command
, _("\
2110 Add directory DIR(s) to beginning of search path for object files.\n\
2111 $cwd in the path means the current working directory.\n\
2112 This path is equivalent to the $PATH shell variable. It is a list of\n\
2113 directories, separated by colons. These directories are searched to find\n\
2114 fully linked executable files and separately compiled object files as needed."));
2115 set_cmd_completer (c
, filename_completer
);
2117 c
= add_cmd ("paths", no_class
, path_info
, _("\
2118 Current search path for finding object files.\n\
2119 $cwd in the path means the current working directory.\n\
2120 This path is equivalent to the $PATH shell variable. It is a list of\n\
2121 directories, separated by colons. These directories are searched to find\n\
2122 fully linked executable files and separately compiled object files as needed."),
2124 set_cmd_completer (c
, noop_completer
);
2126 add_com ("attach", class_run
, attach_command
, _("\
2127 Attach to a process or file outside of GDB.\n\
2128 This command attaches to another target, of the same type as your last\n\
2129 \"target\" command (\"info files\" will show your target stack).\n\
2130 The command may take as argument a process id or a device file.\n\
2131 For a process id, you must have permission to send the process a signal,\n\
2132 and it must have the same effective uid as the debugger.\n\
2133 When using \"attach\" with a process id, the debugger finds the\n\
2134 program running in the process, looking first in the current working\n\
2135 directory, or (if not found there) using the source file search path\n\
2136 (see the \"directory\" command). You can also use the \"file\" command\n\
2137 to specify the program, and to load its symbol table."));
2139 add_prefix_cmd ("detach", class_run
, detach_command
, _("\
2140 Detach a process or file previously attached.\n\
2141 If a process, it is no longer traced, and it continues its execution. If\n\
2142 you were debugging a file, the file is closed and gdb no longer accesses it."),
2143 &detachlist
, "detach ", 0, &cmdlist
);
2145 add_com ("disconnect", class_run
, disconnect_command
, _("\
2146 Disconnect from a target.\n\
2147 The target will wait for another debugger to connect. Not available for\n\
2150 add_com ("signal", class_run
, signal_command
, _("\
2151 Continue program giving it signal specified by the argument.\n\
2152 An argument of \"0\" means continue program without giving it a signal."));
2154 add_com ("stepi", class_run
, stepi_command
, _("\
2155 Step one instruction exactly.\n\
2156 Argument N means do this N times (or till program stops for another reason)."));
2157 add_com_alias ("si", "stepi", class_alias
, 0);
2159 add_com ("nexti", class_run
, nexti_command
, _("\
2160 Step one instruction, but proceed through subroutine calls.\n\
2161 Argument N means do this N times (or till program stops for another reason)."));
2162 add_com_alias ("ni", "nexti", class_alias
, 0);
2164 add_com ("finish", class_run
, finish_command
, _("\
2165 Execute until selected stack frame returns.\n\
2166 Upon return, the value returned is printed and put in the value history."));
2168 add_com ("next", class_run
, next_command
, _("\
2169 Step program, proceeding through subroutine calls.\n\
2170 Like the \"step\" command as long as subroutine calls do not happen;\n\
2171 when they do, the call is treated as one instruction.\n\
2172 Argument N means do this N times (or till program stops for another reason)."));
2173 add_com_alias ("n", "next", class_run
, 1);
2175 add_com_alias ("S", "next", class_run
, 1);
2177 add_com ("step", class_run
, step_command
, _("\
2178 Step program until it reaches a different source line.\n\
2179 Argument N means do this N times (or till program stops for another reason)."));
2180 add_com_alias ("s", "step", class_run
, 1);
2182 c
= add_com ("until", class_run
, until_command
, _("\
2183 Execute until the program reaches a source line greater than the current\n\
2184 or a specified location (same args as break command) within the current frame."));
2185 set_cmd_completer (c
, location_completer
);
2186 add_com_alias ("u", "until", class_run
, 1);
2188 c
= add_com ("advance", class_run
, advance_command
, _("\
2189 Continue the program up to the given location (same form as args for break command).\n\
2190 Execution will also stop upon exit from the current stack frame."));
2191 set_cmd_completer (c
, location_completer
);
2193 c
= add_com ("jump", class_run
, jump_command
, _("\
2194 Continue program being debugged at specified line or address.\n\
2195 Give as argument either LINENUM or *ADDR, where ADDR is an expression\n\
2196 for an address to start at."));
2197 set_cmd_completer (c
, location_completer
);
2201 c
= add_com ("go", class_run
, go_command
, _("\
2202 Usage: go <location>\n\
2203 Continue program being debugged, stopping at specified line or \n\
2205 Give as argument either LINENUM or *ADDR, where ADDR is an \n\
2206 expression for an address to start at.\n\
2207 This command is a combination of tbreak and jump."));
2208 set_cmd_completer (c
, location_completer
);
2212 add_com_alias ("g", "go", class_run
, 1);
2214 add_com ("continue", class_run
, continue_command
, _("\
2215 Continue program being debugged, after signal or breakpoint.\n\
2216 If proceeding from breakpoint, a number N may be used as an argument,\n\
2217 which means to set the ignore count of that breakpoint to N - 1 (so that\n\
2218 the breakpoint won't break until the Nth time it is reached)."));
2219 add_com_alias ("c", "cont", class_run
, 1);
2220 add_com_alias ("fg", "cont", class_run
, 1);
2222 c
= add_com ("run", class_run
, run_command
, _("\
2223 Start debugged program. You may specify arguments to give it.\n\
2224 Args may include \"*\", or \"[...]\"; they are expanded using \"sh\".\n\
2225 Input and output redirection with \">\", \"<\", or \">>\" are also allowed.\n\n\
2226 With no arguments, uses arguments last specified (with \"run\" or \"set args\").\n\
2227 To cancel previous arguments and run with no arguments,\n\
2228 use \"set args\" without arguments."));
2229 set_cmd_completer (c
, filename_completer
);
2230 add_com_alias ("r", "run", class_run
, 1);
2232 add_com ("R", class_run
, run_no_args_command
,
2233 _("Start debugged program with no arguments."));
2235 c
= add_com ("start", class_run
, start_command
, _("\
2236 Run the debugged program until the beginning of the main procedure.\n\
2237 You may specify arguments to give to your program, just as with the\n\
2238 \"run\" command."));
2239 set_cmd_completer (c
, filename_completer
);
2241 add_com ("interrupt", class_run
, interrupt_target_command
,
2242 _("Interrupt the execution of the debugged program."));
2244 add_info ("registers", nofp_registers_info
, _("\
2245 List of integer registers and their contents, for selected stack frame.\n\
2246 Register name as argument means describe only that register."));
2247 add_info_alias ("r", "registers", 1);
2250 add_com ("lr", class_info
, nofp_registers_info
, _("\
2251 List of integer registers and their contents, for selected stack frame.\n\
2252 Register name as argument means describe only that register."));
2253 add_info ("all-registers", all_registers_info
, _("\
2254 List of all registers and their contents, for selected stack frame.\n\
2255 Register name as argument means describe only that register."));
2257 add_info ("program", program_info
,
2258 _("Execution status of the program."));
2260 add_info ("float", float_info
,
2261 _("Print the status of the floating point unit\n"));
2263 add_info ("vector", vector_info
,
2264 _("Print the status of the vector unit\n"));
2266 inferior_environ
= make_environ ();
2267 init_environ (inferior_environ
);