1 /* Memory-access and commands for "inferior" process, for GDB.
3 Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
5 2008 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "gdb_string.h"
38 #include "completer.h"
40 #include "event-top.h"
41 #include "parser-defs.h"
43 #include "reggroups.h"
47 #include "gdb_assert.h"
49 #include "target-descriptions.h"
50 #include "user-regs.h"
51 #include "exceptions.h"
53 /* Functions exported for general use, in inferior.h: */
55 void all_registers_info (char *, int);
57 void registers_info (char *, int);
59 void nexti_command (char *, int);
61 void stepi_command (char *, int);
63 void continue_command (char *, int);
65 void interrupt_target_command (char *args
, int from_tty
);
67 /* Local functions: */
69 static void nofp_registers_info (char *, int);
71 static void print_return_value (struct type
*value_type
);
73 static void finish_command_continuation (struct continuation_arg
*);
75 static void until_next_command (int);
77 static void until_command (char *, int);
79 static void path_info (char *, int);
81 static void path_command (char *, int);
83 static void unset_command (char *, int);
85 static void float_info (char *, int);
87 static void detach_command (char *, int);
89 static void disconnect_command (char *, int);
91 static void unset_environment_command (char *, int);
93 static void set_environment_command (char *, int);
95 static void environment_info (char *, int);
97 static void program_info (char *, int);
99 static void finish_command (char *, int);
101 static void signal_command (char *, int);
103 static void jump_command (char *, int);
105 static void step_1 (int, int, char *);
106 static void step_once (int skip_subroutines
, int single_inst
, int count
);
107 static void step_1_continuation (struct continuation_arg
*arg
);
109 static void next_command (char *, int);
111 static void step_command (char *, int);
113 static void run_command (char *, int);
115 static void run_no_args_command (char *args
, int from_tty
);
117 static void go_command (char *line_no
, int from_tty
);
119 static int strip_bg_char (char **);
121 void _initialize_infcmd (void);
123 #define GO_USAGE "Usage: go <location>\n"
125 #define ERROR_NO_INFERIOR \
126 if (!target_has_execution) error (_("The program is not being run."));
128 /* String containing arguments to give to the program, separated by spaces.
129 Empty string (pointer to '\0') means no args. */
131 static char *inferior_args
;
133 /* The inferior arguments as a vector. If INFERIOR_ARGC is nonzero,
134 then we must compute INFERIOR_ARGS from this (via the target). */
136 static int inferior_argc
;
137 static char **inferior_argv
;
139 /* File name for default use for standard in/out in the inferior. */
141 static char *inferior_io_terminal
;
143 /* Pid of our debugged inferior, or 0 if no inferior now.
144 Since various parts of infrun.c test this to see whether there is a program
145 being debugged it should be nonzero (currently 3 is used) for remote
148 ptid_t inferior_ptid
;
150 /* Last signal that the inferior received (why it stopped). */
152 enum target_signal stop_signal
;
154 /* Address at which inferior stopped. */
158 /* Chain containing status of breakpoint(s) that we have stopped at. */
162 /* Flag indicating that a command has proceeded the inferior past the
163 current breakpoint. */
165 int breakpoint_proceeded
;
167 /* Nonzero if stopped due to a step command. */
171 /* Nonzero if stopped due to completion of a stack dummy routine. */
173 int stop_stack_dummy
;
175 /* Nonzero if stopped due to a random (unexpected) signal in inferior
178 int stopped_by_random_signal
;
180 /* Range to single step within.
181 If this is nonzero, respond to a single-step signal
182 by continuing to step if the pc is in this range. */
184 CORE_ADDR step_range_start
; /* Inclusive */
185 CORE_ADDR step_range_end
; /* Exclusive */
187 /* Stack frame address as of when stepping command was issued.
188 This is how we know when we step into a subroutine call,
189 and how to set the frame for the breakpoint used to step out. */
191 struct frame_id step_frame_id
;
193 enum step_over_calls_kind step_over_calls
;
195 /* If stepping, nonzero means step count is > 1
196 so don't print frame next time inferior stops
197 if it stops due to stepping. */
201 /* Environment to use for running inferior,
202 in format described in environ.h. */
204 struct gdb_environ
*inferior_environ
;
206 /* Accessor routines. */
209 set_inferior_io_terminal (const char *terminal_name
)
211 if (inferior_io_terminal
)
212 xfree (inferior_io_terminal
);
215 inferior_io_terminal
= NULL
;
217 inferior_io_terminal
= savestring (terminal_name
, strlen (terminal_name
));
221 get_inferior_io_terminal (void)
223 return inferior_io_terminal
;
227 get_inferior_args (void)
229 if (inferior_argc
!= 0)
233 n
= gdbarch_construct_inferior_arguments (current_gdbarch
,
234 inferior_argc
, inferior_argv
);
235 old
= set_inferior_args (n
);
239 if (inferior_args
== NULL
)
240 inferior_args
= xstrdup ("");
242 return inferior_args
;
246 set_inferior_args (char *newargs
)
248 char *saved_args
= inferior_args
;
250 inferior_args
= newargs
;
258 set_inferior_args_vector (int argc
, char **argv
)
260 inferior_argc
= argc
;
261 inferior_argv
= argv
;
264 /* Notice when `set args' is run. */
266 notice_args_set (char *args
, int from_tty
, struct cmd_list_element
*c
)
272 /* Notice when `show args' is run. */
274 notice_args_read (struct ui_file
*file
, int from_tty
,
275 struct cmd_list_element
*c
, const char *value
)
277 /* Note that we ignore the passed-in value in favor of computing it
279 deprecated_show_value_hack (file
, from_tty
, c
, get_inferior_args ());
283 /* Compute command-line string given argument vector. This does the
284 same shell processing as fork_inferior. */
286 construct_inferior_arguments (struct gdbarch
*gdbarch
, int argc
, char **argv
)
290 if (STARTUP_WITH_SHELL
)
292 /* This holds all the characters considered special to the
293 typical Unix shells. We include `^' because the SunOS
294 /bin/sh treats it as a synonym for `|'. */
295 char *special
= "\"!#$&*()\\|[]{}<>?'\"`~^; \t\n";
300 /* We over-compute the size. It shouldn't matter. */
301 for (i
= 0; i
< argc
; ++i
)
302 length
+= 2 * strlen (argv
[i
]) + 1 + 2 * (argv
[i
][0] == '\0');
304 result
= (char *) xmalloc (length
);
307 for (i
= 0; i
< argc
; ++i
)
312 /* Need to handle empty arguments specially. */
313 if (argv
[i
][0] == '\0')
320 for (cp
= argv
[i
]; *cp
; ++cp
)
322 if (strchr (special
, *cp
) != NULL
)
332 /* In this case we can't handle arguments that contain spaces,
333 tabs, or newlines -- see breakup_args(). */
337 for (i
= 0; i
< argc
; ++i
)
339 char *cp
= strchr (argv
[i
], ' ');
341 cp
= strchr (argv
[i
], '\t');
343 cp
= strchr (argv
[i
], '\n');
345 error (_("can't handle command-line argument containing whitespace"));
346 length
+= strlen (argv
[i
]) + 1;
349 result
= (char *) xmalloc (length
);
351 for (i
= 0; i
< argc
; ++i
)
354 strcat (result
, " ");
355 strcat (result
, argv
[i
]);
363 /* This function detects whether or not a '&' character (indicating
364 background execution) has been added as *the last* of the arguments ARGS
365 of a command. If it has, it removes it and returns 1. Otherwise it
366 does nothing and returns 0. */
368 strip_bg_char (char **args
)
372 p
= strchr (*args
, '&');
376 if (p
== (*args
+ strlen (*args
) - 1))
378 if (strlen (*args
) > 1)
382 while (*p
== ' ' || *p
== '\t');
394 tty_command (char *file
, int from_tty
)
397 error_no_arg (_("terminal name for running target process"));
399 set_inferior_io_terminal (file
);
402 /* Common actions to take after creating any sort of inferior, by any
403 means (running, attaching, connecting, et cetera). The target
404 should be stopped. */
407 post_create_inferior (struct target_ops
*target
, int from_tty
)
409 /* Be sure we own the terminal in case write operations are performed. */
410 target_terminal_ours ();
412 /* If the target hasn't taken care of this already, do it now.
413 Targets which need to access registers during to_open,
414 to_create_inferior, or to_attach should do it earlier; but many
416 target_find_description ();
420 /* Sometimes the platform-specific hook loads initial shared
421 libraries, and sometimes it doesn't. Try to do so first, so
422 that we can add them with the correct value for FROM_TTY.
423 If we made all the inferior hook methods consistent,
424 this call could be removed. */
426 SOLIB_ADD (NULL
, from_tty
, target
, auto_solib_add
);
428 solib_add (NULL
, from_tty
, target
, auto_solib_add
);
431 /* Create the hooks to handle shared library load and unload
433 #ifdef SOLIB_CREATE_INFERIOR_HOOK
434 SOLIB_CREATE_INFERIOR_HOOK (PIDGET (inferior_ptid
));
436 solib_create_inferior_hook ();
440 observer_notify_inferior_created (target
, from_tty
);
443 /* Kill the inferior if already running. This function is designed
444 to be called when we are about to start the execution of the program
445 from the beginning. Ask the user to confirm that he wants to restart
446 the program being debugged when FROM_TTY is non-null. */
449 kill_if_already_running (int from_tty
)
451 if (! ptid_equal (inferior_ptid
, null_ptid
) && target_has_execution
)
453 /* Bail out before killing the program if we will not be able to
455 target_require_runnable ();
458 && !query ("The program being debugged has been started already.\n\
459 Start it from the beginning? "))
460 error (_("Program not restarted."));
462 no_shared_libraries (NULL
, from_tty
);
463 init_wait_for_inferior ();
467 /* Implement the "run" command. If TBREAK_AT_MAIN is set, then insert
468 a temporary breakpoint at the begining of the main program before
469 running the program. */
472 run_command_1 (char *args
, int from_tty
, int tbreak_at_main
)
478 kill_if_already_running (from_tty
);
479 clear_breakpoint_hit_counts ();
481 /* Clean up any leftovers from other runs. Some other things from
482 this function should probably be moved into target_pre_inferior. */
483 target_pre_inferior (from_tty
);
485 /* Purge old solib objfiles. */
486 objfile_purge_solibs ();
490 /* The comment here used to read, "The exec file is re-read every
491 time we do a generic_mourn_inferior, so we just have to worry
492 about the symbol file." The `generic_mourn_inferior' function
493 gets called whenever the program exits. However, suppose the
494 program exits, and *then* the executable file changes? We need
495 to check again here. Since reopen_exec_file doesn't do anything
496 if the timestamp hasn't changed, I don't see the harm. */
500 /* Insert the temporary breakpoint if a location was specified. */
502 tbreak_command (main_name (), 0);
504 exec_file
= (char *) get_exec_file (0);
506 /* We keep symbols from add-symbol-file, on the grounds that the
507 user might want to add some symbols before running the program
508 (right?). But sometimes (dynamic loading where the user manually
509 introduces the new symbols with add-symbol-file), the code which
510 the symbols describe does not persist between runs. Currently
511 the user has to manually nuke all symbols between runs if they
512 want them to go away (PR 2207). This is probably reasonable. */
516 if (target_can_async_p ())
517 async_disable_stdin ();
521 int async_exec
= strip_bg_char (&args
);
523 /* If we get a request for running in the bg but the target
524 doesn't support it, error out. */
525 if (async_exec
&& !target_can_async_p ())
526 error (_("Asynchronous execution not supported on this target."));
528 /* If we don't get a request of running in the bg, then we need
529 to simulate synchronous (fg) execution. */
530 if (!async_exec
&& target_can_async_p ())
532 /* Simulate synchronous execution */
533 async_disable_stdin ();
536 /* If there were other args, beside '&', process them. */
539 char *old_args
= set_inferior_args (xstrdup (args
));
546 ui_out_field_string (uiout
, NULL
, "Starting program");
547 ui_out_text (uiout
, ": ");
549 ui_out_field_string (uiout
, "execfile", exec_file
);
550 ui_out_spaces (uiout
, 1);
551 /* We call get_inferior_args() because we might need to compute
553 ui_out_field_string (uiout
, "infargs", get_inferior_args ());
554 ui_out_text (uiout
, "\n");
555 ui_out_flush (uiout
);
558 /* We call get_inferior_args() because we might need to compute
560 target_create_inferior (exec_file
, get_inferior_args (),
561 environ_vector (inferior_environ
), from_tty
);
563 /* Pass zero for FROM_TTY, because at this point the "run" command
564 has done its thing; now we are setting up the running program. */
565 post_create_inferior (¤t_target
, 0);
567 /* Start the target running. */
568 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_0
, 0);
573 run_command (char *args
, int from_tty
)
575 run_command_1 (args
, from_tty
, 0);
579 run_no_args_command (char *args
, int from_tty
)
581 char *old_args
= set_inferior_args (xstrdup (""));
586 /* Start the execution of the program up until the beginning of the main
590 start_command (char *args
, int from_tty
)
592 /* Some languages such as Ada need to search inside the program
593 minimal symbols for the location where to put the temporary
594 breakpoint before starting. */
595 if (!have_minimal_symbols ())
596 error (_("No symbol table loaded. Use the \"file\" command."));
598 /* Run the program until reaching the main procedure... */
599 run_command_1 (args
, from_tty
, 1);
603 continue_command (char *proc_count_exp
, int from_tty
)
608 /* Find out whether we must run in the background. */
609 if (proc_count_exp
!= NULL
)
610 async_exec
= strip_bg_char (&proc_count_exp
);
612 /* If we must run in the background, but the target can't do it,
614 if (async_exec
&& !target_can_async_p ())
615 error (_("Asynchronous execution not supported on this target."));
617 /* If we are not asked to run in the bg, then prepare to run in the
618 foreground, synchronously. */
619 if (!async_exec
&& target_can_async_p ())
621 /* Simulate synchronous execution */
622 async_disable_stdin ();
625 /* If have argument (besides '&'), set proceed count of breakpoint
627 if (proc_count_exp
!= NULL
)
629 bpstat bs
= stop_bpstat
;
633 while ((stat
= bpstat_num (&bs
, &num
)) != 0)
636 set_ignore_count (num
,
637 parse_and_eval_long (proc_count_exp
) - 1,
639 /* set_ignore_count prints a message ending with a period.
640 So print two spaces before "Continuing.". */
642 printf_filtered (" ");
646 if (!stopped
&& from_tty
)
649 ("Not stopped at any breakpoint; argument ignored.\n");
654 printf_filtered (_("Continuing.\n"));
656 clear_proceed_status ();
658 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 0);
661 /* Step until outside of current statement. */
664 step_command (char *count_string
, int from_tty
)
666 step_1 (0, 0, count_string
);
669 /* Likewise, but skip over subroutine calls as if single instructions. */
672 next_command (char *count_string
, int from_tty
)
674 step_1 (1, 0, count_string
);
677 /* Likewise, but step only one instruction. */
680 stepi_command (char *count_string
, int from_tty
)
682 step_1 (0, 1, count_string
);
686 nexti_command (char *count_string
, int from_tty
)
688 step_1 (1, 1, count_string
);
692 disable_longjmp_breakpoint_cleanup (void *ignore
)
694 disable_longjmp_breakpoint ();
698 step_1 (int skip_subroutines
, int single_inst
, char *count_string
)
701 struct frame_info
*frame
;
702 struct cleanup
*cleanups
= 0;
708 async_exec
= strip_bg_char (&count_string
);
710 /* If we get a request for running in the bg but the target
711 doesn't support it, error out. */
712 if (async_exec
&& !target_can_async_p ())
713 error (_("Asynchronous execution not supported on this target."));
715 /* If we don't get a request of running in the bg, then we need
716 to simulate synchronous (fg) execution. */
717 if (!async_exec
&& target_can_async_p ())
719 /* Simulate synchronous execution */
720 async_disable_stdin ();
723 count
= count_string
? parse_and_eval_long (count_string
) : 1;
725 if (!single_inst
|| skip_subroutines
) /* leave si command alone */
727 enable_longjmp_breakpoint ();
728 if (!target_can_async_p ())
729 cleanups
= make_cleanup (disable_longjmp_breakpoint_cleanup
, 0 /*ignore*/);
731 make_exec_cleanup (disable_longjmp_breakpoint_cleanup
, 0 /*ignore*/);
734 /* In synchronous case, all is well, just use the regular for loop. */
735 if (!target_can_async_p ())
737 for (; count
> 0; count
--)
739 clear_proceed_status ();
741 frame
= get_current_frame ();
742 if (!frame
) /* Avoid coredump here. Why tho? */
743 error (_("No current frame"));
744 step_frame_id
= get_frame_id (frame
);
748 find_pc_line_pc_range (stop_pc
, &step_range_start
, &step_range_end
);
749 if (step_range_end
== 0)
752 if (find_pc_partial_function (stop_pc
, &name
, &step_range_start
,
753 &step_range_end
) == 0)
754 error (_("Cannot find bounds of current function"));
756 target_terminal_ours ();
757 printf_filtered (_("\
758 Single stepping until exit from function %s, \n\
759 which has no line number information.\n"), name
);
764 /* Say we are stepping, but stop after one insn whatever it does. */
765 step_range_start
= step_range_end
= 1;
766 if (!skip_subroutines
)
768 Don't step over function calls, not even to functions lacking
770 step_over_calls
= STEP_OVER_NONE
;
773 if (skip_subroutines
)
774 step_over_calls
= STEP_OVER_ALL
;
776 step_multi
= (count
> 1);
777 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 1);
783 if (!single_inst
|| skip_subroutines
)
784 do_cleanups (cleanups
);
787 /* In case of asynchronous target things get complicated, do only
788 one step for now, before returning control to the event loop. Let
789 the continuation figure out how many other steps we need to do,
790 and handle them one at the time, through step_once(). */
793 if (target_can_async_p ())
794 step_once (skip_subroutines
, single_inst
, count
);
798 /* Called after we are done with one step operation, to check whether
799 we need to step again, before we print the prompt and return control
800 to the user. If count is > 1, we will need to do one more call to
801 proceed(), via step_once(). Basically it is like step_once and
802 step_1_continuation are co-recursive. */
804 step_1_continuation (struct continuation_arg
*arg
)
807 int skip_subroutines
;
810 skip_subroutines
= arg
->data
.integer
;
811 single_inst
= arg
->next
->data
.integer
;
812 count
= arg
->next
->next
->data
.integer
;
815 step_once (skip_subroutines
, single_inst
, count
- 1);
817 if (!single_inst
|| skip_subroutines
)
818 do_exec_cleanups (ALL_CLEANUPS
);
821 /* Do just one step operation. If count >1 we will have to set up a
822 continuation to be done after the target stops (after this one
823 step). This is useful to implement the 'step n' kind of commands, in
824 case of asynchronous targets. We had to split step_1 into two parts,
825 one to be done before proceed() and one afterwards. This function is
826 called in case of step n with n>1, after the first step operation has
829 step_once (int skip_subroutines
, int single_inst
, int count
)
831 struct continuation_arg
*arg1
;
832 struct continuation_arg
*arg2
;
833 struct continuation_arg
*arg3
;
834 struct frame_info
*frame
;
838 clear_proceed_status ();
840 frame
= get_current_frame ();
841 if (!frame
) /* Avoid coredump here. Why tho? */
842 error (_("No current frame"));
843 step_frame_id
= get_frame_id (frame
);
847 find_pc_line_pc_range (stop_pc
, &step_range_start
, &step_range_end
);
849 /* If we have no line info, switch to stepi mode. */
850 if (step_range_end
== 0 && step_stop_if_no_debug
)
852 step_range_start
= step_range_end
= 1;
854 else if (step_range_end
== 0)
857 if (find_pc_partial_function (stop_pc
, &name
, &step_range_start
,
858 &step_range_end
) == 0)
859 error (_("Cannot find bounds of current function"));
861 target_terminal_ours ();
862 printf_filtered (_("\
863 Single stepping until exit from function %s, \n\
864 which has no line number information.\n"), name
);
869 /* Say we are stepping, but stop after one insn whatever it does. */
870 step_range_start
= step_range_end
= 1;
871 if (!skip_subroutines
)
873 Don't step over function calls, not even to functions lacking
875 step_over_calls
= STEP_OVER_NONE
;
878 if (skip_subroutines
)
879 step_over_calls
= STEP_OVER_ALL
;
881 step_multi
= (count
> 1);
883 (struct continuation_arg
*) xmalloc (sizeof (struct continuation_arg
));
885 (struct continuation_arg
*) xmalloc (sizeof (struct continuation_arg
));
887 (struct continuation_arg
*) xmalloc (sizeof (struct continuation_arg
));
889 arg1
->data
.integer
= skip_subroutines
;
891 arg2
->data
.integer
= single_inst
;
893 arg3
->data
.integer
= count
;
894 add_intermediate_continuation (step_1_continuation
, arg1
);
895 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 1);
900 /* Continue program at specified address. */
903 jump_command (char *arg
, int from_tty
)
906 struct symtabs_and_lines sals
;
907 struct symtab_and_line sal
;
914 /* Find out whether we must run in the background. */
916 async_exec
= strip_bg_char (&arg
);
918 /* If we must run in the background, but the target can't do it,
920 if (async_exec
&& !target_can_async_p ())
921 error (_("Asynchronous execution not supported on this target."));
924 error_no_arg (_("starting address"));
926 sals
= decode_line_spec_1 (arg
, 1);
929 error (_("Unreasonable jump request"));
935 if (sal
.symtab
== 0 && sal
.pc
== 0)
936 error (_("No source file has been specified."));
938 resolve_sal_pc (&sal
); /* May error out */
940 /* See if we are trying to jump to another function. */
941 fn
= get_frame_function (get_current_frame ());
942 sfn
= find_pc_function (sal
.pc
);
943 if (fn
!= NULL
&& sfn
!= fn
)
945 if (!query ("Line %d is not in `%s'. Jump anyway? ", sal
.line
,
946 SYMBOL_PRINT_NAME (fn
)))
948 error (_("Not confirmed."));
955 fixup_symbol_section (sfn
, 0);
956 if (section_is_overlay (SYMBOL_BFD_SECTION (sfn
)) &&
957 !section_is_mapped (SYMBOL_BFD_SECTION (sfn
)))
959 if (!query ("WARNING!!! Destination is in unmapped overlay! Jump anyway? "))
961 error (_("Not confirmed."));
971 printf_filtered (_("Continuing at "));
972 fputs_filtered (paddress (addr
), gdb_stdout
);
973 printf_filtered (".\n");
976 /* If we are not asked to run in the bg, then prepare to run in the
977 foreground, synchronously. */
978 if (!async_exec
&& target_can_async_p ())
980 /* Simulate synchronous execution */
981 async_disable_stdin ();
984 clear_proceed_status ();
985 proceed (addr
, TARGET_SIGNAL_0
, 0);
989 /* Go to line or address in current procedure */
991 go_command (char *line_no
, int from_tty
)
993 if (line_no
== (char *) NULL
|| !*line_no
)
994 printf_filtered (GO_USAGE
);
997 tbreak_command (line_no
, from_tty
);
998 jump_command (line_no
, from_tty
);
1003 /* Continue program giving it specified signal. */
1006 signal_command (char *signum_exp
, int from_tty
)
1008 enum target_signal oursig
;
1011 dont_repeat (); /* Too dangerous. */
1014 /* Find out whether we must run in the background. */
1015 if (signum_exp
!= NULL
)
1016 async_exec
= strip_bg_char (&signum_exp
);
1018 /* If we must run in the background, but the target can't do it,
1020 if (async_exec
&& !target_can_async_p ())
1021 error (_("Asynchronous execution not supported on this target."));
1023 /* If we are not asked to run in the bg, then prepare to run in the
1024 foreground, synchronously. */
1025 if (!async_exec
&& target_can_async_p ())
1027 /* Simulate synchronous execution. */
1028 async_disable_stdin ();
1032 error_no_arg (_("signal number"));
1034 /* It would be even slicker to make signal names be valid expressions,
1035 (the type could be "enum $signal" or some such), then the user could
1036 assign them to convenience variables. */
1037 oursig
= target_signal_from_name (signum_exp
);
1039 if (oursig
== TARGET_SIGNAL_UNKNOWN
)
1041 /* No, try numeric. */
1042 int num
= parse_and_eval_long (signum_exp
);
1045 oursig
= TARGET_SIGNAL_0
;
1047 oursig
= target_signal_from_command (num
);
1052 if (oursig
== TARGET_SIGNAL_0
)
1053 printf_filtered (_("Continuing with no signal.\n"));
1055 printf_filtered (_("Continuing with signal %s.\n"),
1056 target_signal_to_name (oursig
));
1059 clear_proceed_status ();
1060 /* "signal 0" should not get stuck if we are stopped at a breakpoint.
1061 FIXME: Neither should "signal foo" but when I tried passing
1062 (CORE_ADDR)-1 unconditionally I got a testsuite failure which I haven't
1063 tried to track down yet. */
1064 proceed (oursig
== TARGET_SIGNAL_0
? (CORE_ADDR
) -1 : stop_pc
, oursig
, 0);
1067 /* Proceed until we reach a different source line with pc greater than
1068 our current one or exit the function. We skip calls in both cases.
1070 Note that eventually this command should probably be changed so
1071 that only source lines are printed out when we hit the breakpoint
1072 we set. This may involve changes to wait_for_inferior and the
1073 proceed status code. */
1076 until_next_command (int from_tty
)
1078 struct frame_info
*frame
;
1080 struct symbol
*func
;
1081 struct symtab_and_line sal
;
1083 clear_proceed_status ();
1085 frame
= get_current_frame ();
1087 /* Step until either exited from this function or greater
1088 than the current line (if in symbolic section) or pc (if
1092 func
= find_pc_function (pc
);
1096 struct minimal_symbol
*msymbol
= lookup_minimal_symbol_by_pc (pc
);
1098 if (msymbol
== NULL
)
1099 error (_("Execution is not within a known function."));
1101 step_range_start
= SYMBOL_VALUE_ADDRESS (msymbol
);
1102 step_range_end
= pc
;
1106 sal
= find_pc_line (pc
, 0);
1108 step_range_start
= BLOCK_START (SYMBOL_BLOCK_VALUE (func
));
1109 step_range_end
= sal
.end
;
1112 step_over_calls
= STEP_OVER_ALL
;
1113 step_frame_id
= get_frame_id (frame
);
1115 step_multi
= 0; /* Only one call to proceed */
1117 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 1);
1121 until_command (char *arg
, int from_tty
)
1125 if (!target_has_execution
)
1126 error (_("The program is not running."));
1128 /* Find out whether we must run in the background. */
1130 async_exec
= strip_bg_char (&arg
);
1132 /* If we must run in the background, but the target can't do it,
1134 if (async_exec
&& !target_can_async_p ())
1135 error (_("Asynchronous execution not supported on this target."));
1137 /* If we are not asked to run in the bg, then prepare to run in the
1138 foreground, synchronously. */
1139 if (!async_exec
&& target_can_async_p ())
1141 /* Simulate synchronous execution */
1142 async_disable_stdin ();
1146 until_break_command (arg
, from_tty
, 0);
1148 until_next_command (from_tty
);
1152 advance_command (char *arg
, int from_tty
)
1156 if (!target_has_execution
)
1157 error (_("The program is not running."));
1160 error_no_arg (_("a location"));
1162 /* Find out whether we must run in the background. */
1164 async_exec
= strip_bg_char (&arg
);
1166 /* If we must run in the background, but the target can't do it,
1168 if (async_exec
&& !target_can_async_p ())
1169 error (_("Asynchronous execution not supported on this target."));
1171 /* If we are not asked to run in the bg, then prepare to run in the
1172 foreground, synchronously. */
1173 if (!async_exec
&& target_can_async_p ())
1175 /* Simulate synchronous execution. */
1176 async_disable_stdin ();
1179 until_break_command (arg
, from_tty
, 1);
1182 /* Print the result of a function at the end of a 'finish' command. */
1185 print_return_value (struct type
*value_type
)
1187 struct gdbarch
*gdbarch
= current_gdbarch
;
1188 struct cleanup
*old_chain
;
1189 struct ui_stream
*stb
;
1190 struct value
*value
;
1192 CHECK_TYPEDEF (value_type
);
1193 gdb_assert (TYPE_CODE (value_type
) != TYPE_CODE_VOID
);
1195 /* FIXME: 2003-09-27: When returning from a nested inferior function
1196 call, it's possible (with no help from the architecture vector)
1197 to locate and return/print a "struct return" value. This is just
1198 a more complicated case of what is already being done in in the
1199 inferior function call code. In fact, when inferior function
1200 calls are made async, this will likely be made the norm. */
1202 switch (gdbarch_return_value (gdbarch
, value_type
, NULL
, NULL
, NULL
))
1204 case RETURN_VALUE_REGISTER_CONVENTION
:
1205 case RETURN_VALUE_ABI_RETURNS_ADDRESS
:
1206 case RETURN_VALUE_ABI_PRESERVES_ADDRESS
:
1207 value
= allocate_value (value_type
);
1208 gdbarch_return_value (gdbarch
, value_type
, stop_registers
,
1209 value_contents_raw (value
), NULL
);
1211 case RETURN_VALUE_STRUCT_CONVENTION
:
1215 internal_error (__FILE__
, __LINE__
, _("bad switch"));
1221 stb
= ui_out_stream_new (uiout
);
1222 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
1223 ui_out_text (uiout
, "Value returned is ");
1224 ui_out_field_fmt (uiout
, "gdb-result-var", "$%d",
1225 record_latest_value (value
));
1226 ui_out_text (uiout
, " = ");
1227 value_print (value
, stb
->stream
, 0, Val_no_prettyprint
);
1228 ui_out_field_stream (uiout
, "return-value", stb
);
1229 ui_out_text (uiout
, "\n");
1230 do_cleanups (old_chain
);
1234 ui_out_text (uiout
, "Value returned has type: ");
1235 ui_out_field_string (uiout
, "return-type", TYPE_NAME (value_type
));
1236 ui_out_text (uiout
, ".");
1237 ui_out_text (uiout
, " Cannot determine contents\n");
1241 /* Stuff that needs to be done by the finish command after the target
1242 has stopped. In asynchronous mode, we wait for the target to stop
1243 in the call to poll or select in the event loop, so it is
1244 impossible to do all the stuff as part of the finish_command
1245 function itself. The only chance we have to complete this command
1246 is in fetch_inferior_event, which is called by the event loop as
1247 soon as it detects that the target has stopped. This function is
1248 called via the cmd_continuation pointer. */
1251 finish_command_continuation (struct continuation_arg
*arg
)
1253 struct symbol
*function
;
1254 struct breakpoint
*breakpoint
;
1255 struct cleanup
*cleanups
;
1257 breakpoint
= (struct breakpoint
*) arg
->data
.pointer
;
1258 function
= (struct symbol
*) arg
->next
->data
.pointer
;
1259 cleanups
= (struct cleanup
*) arg
->next
->next
->data
.pointer
;
1261 if (bpstat_find_breakpoint (stop_bpstat
, breakpoint
) != NULL
1262 && function
!= NULL
)
1264 struct type
*value_type
;
1266 value_type
= TYPE_TARGET_TYPE (SYMBOL_TYPE (function
));
1268 internal_error (__FILE__
, __LINE__
,
1269 _("finish_command: function has no target type"));
1271 if (TYPE_CODE (value_type
) != TYPE_CODE_VOID
)
1272 print_return_value (value_type
);
1275 do_exec_cleanups (cleanups
);
1278 /* "finish": Set a temporary breakpoint at the place the selected
1279 frame will return to, then continue. */
1282 finish_command (char *arg
, int from_tty
)
1284 struct symtab_and_line sal
;
1285 struct frame_info
*frame
;
1286 struct symbol
*function
;
1287 struct breakpoint
*breakpoint
;
1288 struct cleanup
*old_chain
;
1289 struct continuation_arg
*arg1
, *arg2
, *arg3
;
1293 /* Find out whether we must run in the background. */
1295 async_exec
= strip_bg_char (&arg
);
1297 /* If we must run in the background, but the target can't do it,
1299 if (async_exec
&& !target_can_async_p ())
1300 error (_("Asynchronous execution not supported on this target."));
1302 /* If we are not asked to run in the bg, then prepare to run in the
1303 foreground, synchronously. */
1304 if (!async_exec
&& target_can_async_p ())
1306 /* Simulate synchronous execution. */
1307 async_disable_stdin ();
1311 error (_("The \"finish\" command does not take any arguments."));
1312 if (!target_has_execution
)
1313 error (_("The program is not running."));
1315 frame
= get_prev_frame (get_selected_frame (_("No selected frame.")));
1317 error (_("\"finish\" not meaningful in the outermost frame."));
1319 clear_proceed_status ();
1321 sal
= find_pc_line (get_frame_pc (frame
), 0);
1322 sal
.pc
= get_frame_pc (frame
);
1324 breakpoint
= set_momentary_breakpoint (sal
, get_frame_id (frame
), bp_finish
);
1326 if (!target_can_async_p ())
1327 old_chain
= make_cleanup_delete_breakpoint (breakpoint
);
1329 old_chain
= make_exec_cleanup_delete_breakpoint (breakpoint
);
1331 /* Find the function we will return from. */
1333 function
= find_pc_function (get_frame_pc (get_selected_frame (NULL
)));
1335 /* Print info on the selected frame, including level number but not
1339 printf_filtered (_("Run till exit from "));
1340 print_stack_frame (get_selected_frame (NULL
), 1, LOCATION
);
1343 proceed_to_finish
= 1; /* We want stop_registers, please... */
1344 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 0);
1346 /* If running asynchronously and the target support asynchronous
1347 execution, set things up for the rest of the finish command to be
1348 completed later on, when gdb has detected that the target has
1349 stopped, in fetch_inferior_event.
1350 Setup it only after proceed, so that if proceed throws, we don't
1351 set continuation. */
1352 if (target_can_async_p ())
1355 (struct continuation_arg
*) xmalloc (sizeof (struct continuation_arg
));
1357 (struct continuation_arg
*) xmalloc (sizeof (struct continuation_arg
));
1359 (struct continuation_arg
*) xmalloc (sizeof (struct continuation_arg
));
1363 arg1
->data
.pointer
= breakpoint
;
1364 arg2
->data
.pointer
= function
;
1365 arg3
->data
.pointer
= old_chain
;
1366 add_continuation (finish_command_continuation
, arg1
);
1369 /* Do this only if not running asynchronously or if the target
1370 cannot do async execution. Otherwise, complete this command when
1371 the target actually stops, in fetch_inferior_event. */
1372 if (!target_can_async_p ())
1374 /* Did we stop at our breakpoint? */
1375 if (bpstat_find_breakpoint (stop_bpstat
, breakpoint
) != NULL
1376 && function
!= NULL
)
1378 struct type
*value_type
;
1380 value_type
= TYPE_TARGET_TYPE (SYMBOL_TYPE (function
));
1382 internal_error (__FILE__
, __LINE__
,
1383 _("finish_command: function has no target type"));
1385 if (TYPE_CODE (value_type
) != TYPE_CODE_VOID
)
1386 print_return_value (value_type
);
1389 do_cleanups (old_chain
);
1395 program_info (char *args
, int from_tty
)
1397 bpstat bs
= stop_bpstat
;
1399 int stat
= bpstat_num (&bs
, &num
);
1401 if (!target_has_execution
)
1403 printf_filtered (_("The program being debugged is not being run.\n"));
1407 target_files_info ();
1408 printf_filtered (_("Program stopped at %s.\n"),
1409 hex_string ((unsigned long) stop_pc
));
1411 printf_filtered (_("It stopped after being stepped.\n"));
1414 /* There may be several breakpoints in the same place, so this
1415 isn't as strange as it seems. */
1420 printf_filtered (_("\
1421 It stopped at a breakpoint that has since been deleted.\n"));
1424 printf_filtered (_("It stopped at breakpoint %d.\n"), num
);
1425 stat
= bpstat_num (&bs
, &num
);
1428 else if (stop_signal
!= TARGET_SIGNAL_0
)
1430 printf_filtered (_("It stopped with signal %s, %s.\n"),
1431 target_signal_to_name (stop_signal
),
1432 target_signal_to_string (stop_signal
));
1437 printf_filtered (_("\
1438 Type \"info stack\" or \"info registers\" for more information.\n"));
1443 environment_info (char *var
, int from_tty
)
1447 char *val
= get_in_environ (inferior_environ
, var
);
1450 puts_filtered (var
);
1451 puts_filtered (" = ");
1452 puts_filtered (val
);
1453 puts_filtered ("\n");
1457 puts_filtered ("Environment variable \"");
1458 puts_filtered (var
);
1459 puts_filtered ("\" not defined.\n");
1464 char **vector
= environ_vector (inferior_environ
);
1467 puts_filtered (*vector
++);
1468 puts_filtered ("\n");
1474 set_environment_command (char *arg
, int from_tty
)
1476 char *p
, *val
, *var
;
1480 error_no_arg (_("environment variable and value"));
1482 /* Find seperation between variable name and value */
1483 p
= (char *) strchr (arg
, '=');
1484 val
= (char *) strchr (arg
, ' ');
1486 if (p
!= 0 && val
!= 0)
1488 /* We have both a space and an equals. If the space is before the
1489 equals, walk forward over the spaces til we see a nonspace
1490 (possibly the equals). */
1495 /* Now if the = is after the char following the spaces,
1496 take the char following the spaces. */
1500 else if (val
!= 0 && p
== 0)
1504 error_no_arg (_("environment variable to set"));
1506 if (p
== 0 || p
[1] == 0)
1510 p
= arg
+ strlen (arg
); /* So that savestring below will work */
1514 /* Not setting variable value to null */
1516 while (*val
== ' ' || *val
== '\t')
1520 while (p
!= arg
&& (p
[-1] == ' ' || p
[-1] == '\t'))
1523 var
= savestring (arg
, p
- arg
);
1526 printf_filtered (_("\
1527 Setting environment variable \"%s\" to null value.\n"),
1529 set_in_environ (inferior_environ
, var
, "");
1532 set_in_environ (inferior_environ
, var
, val
);
1537 unset_environment_command (char *var
, int from_tty
)
1541 /* If there is no argument, delete all environment variables.
1542 Ask for confirmation if reading from the terminal. */
1543 if (!from_tty
|| query (_("Delete all environment variables? ")))
1545 free_environ (inferior_environ
);
1546 inferior_environ
= make_environ ();
1550 unset_in_environ (inferior_environ
, var
);
1553 /* Handle the execution path (PATH variable) */
1555 static const char path_var_name
[] = "PATH";
1558 path_info (char *args
, int from_tty
)
1560 puts_filtered ("Executable and object file path: ");
1561 puts_filtered (get_in_environ (inferior_environ
, path_var_name
));
1562 puts_filtered ("\n");
1565 /* Add zero or more directories to the front of the execution path. */
1568 path_command (char *dirname
, int from_tty
)
1573 env
= get_in_environ (inferior_environ
, path_var_name
);
1574 /* Can be null if path is not set */
1577 exec_path
= xstrdup (env
);
1578 mod_path (dirname
, &exec_path
);
1579 set_in_environ (inferior_environ
, path_var_name
, exec_path
);
1582 path_info ((char *) NULL
, from_tty
);
1586 /* Print out the machine register regnum. If regnum is -1, print all
1587 registers (print_all == 1) or all non-float and non-vector
1588 registers (print_all == 0).
1590 For most machines, having all_registers_info() print the
1591 register(s) one per line is good enough. If a different format is
1592 required, (eg, for MIPS or Pyramid 90x, which both have lots of
1593 regs), or there is an existing convention for showing all the
1594 registers, define the architecture method PRINT_REGISTERS_INFO to
1595 provide that format. */
1598 default_print_registers_info (struct gdbarch
*gdbarch
,
1599 struct ui_file
*file
,
1600 struct frame_info
*frame
,
1601 int regnum
, int print_all
)
1604 const int numregs
= gdbarch_num_regs (gdbarch
)
1605 + gdbarch_num_pseudo_regs (gdbarch
);
1606 gdb_byte buffer
[MAX_REGISTER_SIZE
];
1608 for (i
= 0; i
< numregs
; i
++)
1610 /* Decide between printing all regs, non-float / vector regs, or
1616 if (!gdbarch_register_reggroup_p (gdbarch
, i
, all_reggroup
))
1621 if (!gdbarch_register_reggroup_p (gdbarch
, i
, general_reggroup
))
1631 /* If the register name is empty, it is undefined for this
1632 processor, so don't display anything. */
1633 if (gdbarch_register_name (gdbarch
, i
) == NULL
1634 || *(gdbarch_register_name (gdbarch
, i
)) == '\0')
1637 fputs_filtered (gdbarch_register_name (gdbarch
, i
), file
);
1638 print_spaces_filtered (15 - strlen (gdbarch_register_name
1639 (gdbarch
, i
)), file
);
1641 /* Get the data in raw format. */
1642 if (! frame_register_read (frame
, i
, buffer
))
1644 fprintf_filtered (file
, "*value not available*\n");
1648 /* If virtual format is floating, print it that way, and in raw
1650 if (TYPE_CODE (register_type (gdbarch
, i
)) == TYPE_CODE_FLT
1651 || TYPE_CODE (register_type (gdbarch
, i
)) == TYPE_CODE_DECFLOAT
)
1655 val_print (register_type (gdbarch
, i
), buffer
, 0, 0,
1656 file
, 0, 1, 0, Val_pretty_default
);
1658 fprintf_filtered (file
, "\t(raw 0x");
1659 for (j
= 0; j
< register_size (gdbarch
, i
); j
++)
1662 if (gdbarch_byte_order (gdbarch
) == BFD_ENDIAN_BIG
)
1665 idx
= register_size (gdbarch
, i
) - 1 - j
;
1666 fprintf_filtered (file
, "%02x", (unsigned char) buffer
[idx
]);
1668 fprintf_filtered (file
, ")");
1672 /* Print the register in hex. */
1673 val_print (register_type (gdbarch
, i
), buffer
, 0, 0,
1674 file
, 'x', 1, 0, Val_pretty_default
);
1675 /* If not a vector register, print it also according to its
1677 if (TYPE_VECTOR (register_type (gdbarch
, i
)) == 0)
1679 fprintf_filtered (file
, "\t");
1680 val_print (register_type (gdbarch
, i
), buffer
, 0, 0,
1681 file
, 0, 1, 0, Val_pretty_default
);
1685 fprintf_filtered (file
, "\n");
1690 registers_info (char *addr_exp
, int fpregs
)
1692 struct frame_info
*frame
;
1693 struct gdbarch
*gdbarch
;
1694 int regnum
, numregs
;
1697 if (!target_has_registers
)
1698 error (_("The program has no registers now."));
1699 frame
= get_selected_frame (NULL
);
1700 gdbarch
= get_frame_arch (frame
);
1704 gdbarch_print_registers_info (gdbarch
, gdb_stdout
,
1709 while (*addr_exp
!= '\0')
1714 /* Keep skipping leading white space. */
1715 if (isspace ((*addr_exp
)))
1721 /* Discard any leading ``$''. Check that there is something
1722 resembling a register following it. */
1723 if (addr_exp
[0] == '$')
1725 if (isspace ((*addr_exp
)) || (*addr_exp
) == '\0')
1726 error (_("Missing register name"));
1728 /* Find the start/end of this register name/num/group. */
1730 while ((*addr_exp
) != '\0' && !isspace ((*addr_exp
)))
1734 /* Figure out what we've found and display it. */
1736 /* A register name? */
1738 int regnum
= frame_map_name_to_regnum (frame
, start
, end
- start
);
1741 /* User registers lie completely outside of the range of
1742 normal registers. Catch them early so that the target
1744 if (regnum
>= gdbarch_num_regs (gdbarch
)
1745 + gdbarch_num_pseudo_regs (gdbarch
))
1747 struct value
*val
= value_of_user_reg (regnum
, frame
);
1749 printf_filtered ("%s: ", start
);
1750 print_scalar_formatted (value_contents (val
),
1751 check_typedef (value_type (val
)),
1752 'x', 0, gdb_stdout
);
1753 printf_filtered ("\n");
1756 gdbarch_print_registers_info (gdbarch
, gdb_stdout
,
1757 frame
, regnum
, fpregs
);
1762 /* A register number? (how portable is this one?). */
1765 int regnum
= strtol (start
, &endptr
, 0);
1768 && regnum
< gdbarch_num_regs (gdbarch
)
1769 + gdbarch_num_pseudo_regs (gdbarch
))
1771 gdbarch_print_registers_info (gdbarch
, gdb_stdout
,
1772 frame
, regnum
, fpregs
);
1777 /* A register group? */
1779 struct reggroup
*group
;
1780 for (group
= reggroup_next (gdbarch
, NULL
);
1782 group
= reggroup_next (gdbarch
, group
))
1784 /* Don't bother with a length check. Should the user
1785 enter a short register group name, go with the first
1786 group that matches. */
1787 if (strncmp (start
, reggroup_name (group
), end
- start
) == 0)
1794 regnum
< gdbarch_num_regs (gdbarch
)
1795 + gdbarch_num_pseudo_regs (gdbarch
);
1798 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, group
))
1799 gdbarch_print_registers_info (gdbarch
,
1807 /* Nothing matched. */
1808 error (_("Invalid register `%.*s'"), (int) (end
- start
), start
);
1813 all_registers_info (char *addr_exp
, int from_tty
)
1815 registers_info (addr_exp
, 1);
1819 nofp_registers_info (char *addr_exp
, int from_tty
)
1821 registers_info (addr_exp
, 0);
1825 print_vector_info (struct gdbarch
*gdbarch
, struct ui_file
*file
,
1826 struct frame_info
*frame
, const char *args
)
1828 if (gdbarch_print_vector_info_p (gdbarch
))
1829 gdbarch_print_vector_info (gdbarch
, file
, frame
, args
);
1833 int printed_something
= 0;
1836 regnum
< gdbarch_num_regs (gdbarch
)
1837 + gdbarch_num_pseudo_regs (gdbarch
);
1840 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, vector_reggroup
))
1842 printed_something
= 1;
1843 gdbarch_print_registers_info (gdbarch
, file
, frame
, regnum
, 1);
1846 if (!printed_something
)
1847 fprintf_filtered (file
, "No vector information\n");
1852 vector_info (char *args
, int from_tty
)
1854 if (!target_has_registers
)
1855 error (_("The program has no registers now."));
1857 print_vector_info (current_gdbarch
, gdb_stdout
,
1858 get_selected_frame (NULL
), args
);
1864 * Should save/restore the tty state since it might be that the
1865 * program to be debugged was started on this tty and it wants
1866 * the tty in some state other than what we want. If it's running
1867 * on another terminal or without a terminal, then saving and
1868 * restoring the tty state is a harmless no-op.
1869 * This only needs to be done if we are attaching to a process.
1874 takes a program started up outside of gdb and ``attaches'' to it.
1875 This stops it cold in its tracks and allows us to start debugging it.
1876 and wait for the trace-trap that results from attaching. */
1879 attach_command (char *args
, int from_tty
)
1882 char *full_exec_path
= NULL
;
1884 dont_repeat (); /* Not for the faint of heart */
1886 if (target_has_execution
)
1888 if (query ("A program is being debugged already. Kill it? "))
1891 error (_("Not killed."));
1894 /* Clean up any leftovers from other runs. Some other things from
1895 this function should probably be moved into target_pre_inferior. */
1896 target_pre_inferior (from_tty
);
1898 /* Clear out solib state. Otherwise the solib state of the previous
1899 inferior might have survived and is entirely wrong for the new
1900 target. This has been observed on GNU/Linux using glibc 2.3. How
1912 Cannot access memory at address 0xdeadbeef
1916 target_attach (args
, from_tty
);
1918 /* Set up the "saved terminal modes" of the inferior
1919 based on what modes we are starting it with. */
1920 target_terminal_init ();
1922 /* Set up execution context to know that we should return from
1923 wait_for_inferior as soon as the target reports a stop. */
1924 init_wait_for_inferior ();
1925 clear_proceed_status ();
1927 /* No traps are generated when attaching to inferior under Mach 3
1929 #ifndef ATTACH_NO_WAIT
1930 /* Careful here. See comments in inferior.h. Basically some OSes
1931 don't ignore SIGSTOPs on continue requests anymore. We need a
1932 way for handle_inferior_event to reset the stop_signal variable
1933 after an attach, and this is what STOP_QUIETLY_NO_SIGSTOP is for. */
1934 stop_soon
= STOP_QUIETLY_NO_SIGSTOP
;
1935 wait_for_inferior (0);
1936 stop_soon
= NO_STOP_QUIETLY
;
1940 * If no exec file is yet known, try to determine it from the
1943 exec_file
= (char *) get_exec_file (0);
1946 exec_file
= target_pid_to_exec_file (PIDGET (inferior_ptid
));
1949 /* It's possible we don't have a full path, but rather just a
1950 filename. Some targets, such as HP-UX, don't provide the
1953 Attempt to qualify the filename against the source path.
1954 (If that fails, we'll just fall back on the original
1955 filename. Not much more we can do...)
1957 if (!source_full_path_of (exec_file
, &full_exec_path
))
1958 full_exec_path
= savestring (exec_file
, strlen (exec_file
));
1960 exec_file_attach (full_exec_path
, from_tty
);
1961 symbol_file_add_main (full_exec_path
, from_tty
);
1966 reopen_exec_file ();
1970 /* Take any necessary post-attaching actions for this platform.
1972 target_post_attach (PIDGET (inferior_ptid
));
1974 post_create_inferior (¤t_target
, from_tty
);
1976 /* Install inferior's terminal modes. */
1977 target_terminal_inferior ();
1981 if (deprecated_attach_hook
)
1982 deprecated_attach_hook ();
1987 * takes a program previously attached to and detaches it.
1988 * The program resumes execution and will no longer stop
1989 * on signals, etc. We better not have left any breakpoints
1990 * in the program or it'll die when it hits one. For this
1991 * to work, it may be necessary for the process to have been
1992 * previously attached. It *might* work if the program was
1993 * started via the normal ptrace (PTRACE_TRACEME).
1997 detach_command (char *args
, int from_tty
)
1999 dont_repeat (); /* Not for the faint of heart. */
2000 target_detach (args
, from_tty
);
2001 no_shared_libraries (NULL
, from_tty
);
2002 if (deprecated_detach_hook
)
2003 deprecated_detach_hook ();
2006 /* Disconnect from the current target without resuming it (leaving it
2007 waiting for a debugger).
2009 We'd better not have left any breakpoints in the program or the
2010 next debugger will get confused. Currently only supported for some
2011 remote targets, since the normal attach mechanisms don't work on
2012 stopped processes on some native platforms (e.g. GNU/Linux). */
2015 disconnect_command (char *args
, int from_tty
)
2017 dont_repeat (); /* Not for the faint of heart */
2018 target_disconnect (args
, from_tty
);
2019 no_shared_libraries (NULL
, from_tty
);
2020 if (deprecated_detach_hook
)
2021 deprecated_detach_hook ();
2024 /* Stop the execution of the target while running in async mode, in
2027 interrupt_target_command (char *args
, int from_tty
)
2029 if (target_can_async_p ())
2031 dont_repeat (); /* Not for the faint of heart */
2037 print_float_info (struct gdbarch
*gdbarch
, struct ui_file
*file
,
2038 struct frame_info
*frame
, const char *args
)
2040 if (gdbarch_print_float_info_p (gdbarch
))
2041 gdbarch_print_float_info (gdbarch
, file
, frame
, args
);
2045 int printed_something
= 0;
2048 regnum
< gdbarch_num_regs (gdbarch
)
2049 + gdbarch_num_pseudo_regs (gdbarch
);
2052 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, float_reggroup
))
2054 printed_something
= 1;
2055 gdbarch_print_registers_info (gdbarch
, file
, frame
, regnum
, 1);
2058 if (!printed_something
)
2059 fprintf_filtered (file
, "\
2060 No floating-point info available for this processor.\n");
2065 float_info (char *args
, int from_tty
)
2067 if (!target_has_registers
)
2068 error (_("The program has no registers now."));
2070 print_float_info (current_gdbarch
, gdb_stdout
,
2071 get_selected_frame (NULL
), args
);
2075 unset_command (char *args
, int from_tty
)
2077 printf_filtered (_("\
2078 \"unset\" must be followed by the name of an unset subcommand.\n"));
2079 help_list (unsetlist
, "unset ", -1, gdb_stdout
);
2083 _initialize_infcmd (void)
2085 struct cmd_list_element
*c
= NULL
;
2087 /* add the filename of the terminal connected to inferior I/O */
2088 add_setshow_filename_cmd ("inferior-tty", class_run
,
2089 &inferior_io_terminal
, _("\
2090 Set terminal for future runs of program being debugged."), _("\
2091 Show terminal for future runs of program being debugged."), _("\
2092 Usage: set inferior-tty /dev/pts/1"), NULL
, NULL
, &setlist
, &showlist
);
2093 add_com_alias ("tty", "set inferior-tty", class_alias
, 0);
2095 add_setshow_optional_filename_cmd ("args", class_run
,
2096 &inferior_args
, _("\
2097 Set argument list to give program being debugged when it is started."), _("\
2098 Show argument list to give program being debugged when it is started."), _("\
2099 Follow this command with any number of args, to be passed to the program."),
2102 &setlist
, &showlist
);
2104 c
= add_cmd ("environment", no_class
, environment_info
, _("\
2105 The environment to give the program, or one variable's value.\n\
2106 With an argument VAR, prints the value of environment variable VAR to\n\
2107 give the program being debugged. With no arguments, prints the entire\n\
2108 environment to be given to the program."), &showlist
);
2109 set_cmd_completer (c
, noop_completer
);
2111 add_prefix_cmd ("unset", no_class
, unset_command
,
2112 _("Complement to certain \"set\" commands."),
2113 &unsetlist
, "unset ", 0, &cmdlist
);
2115 c
= add_cmd ("environment", class_run
, unset_environment_command
, _("\
2116 Cancel environment variable VAR for the program.\n\
2117 This does not affect the program until the next \"run\" command."),
2119 set_cmd_completer (c
, noop_completer
);
2121 c
= add_cmd ("environment", class_run
, set_environment_command
, _("\
2122 Set environment variable value to give the program.\n\
2123 Arguments are VAR VALUE where VAR is variable name and VALUE is value.\n\
2124 VALUES of environment variables are uninterpreted strings.\n\
2125 This does not affect the program until the next \"run\" command."),
2127 set_cmd_completer (c
, noop_completer
);
2129 c
= add_com ("path", class_files
, path_command
, _("\
2130 Add directory DIR(s) to beginning of search path for object files.\n\
2131 $cwd in the path means the current working directory.\n\
2132 This path is equivalent to the $PATH shell variable. It is a list of\n\
2133 directories, separated by colons. These directories are searched to find\n\
2134 fully linked executable files and separately compiled object files as needed."));
2135 set_cmd_completer (c
, filename_completer
);
2137 c
= add_cmd ("paths", no_class
, path_info
, _("\
2138 Current search path for finding object files.\n\
2139 $cwd in the path means the current working directory.\n\
2140 This path is equivalent to the $PATH shell variable. It is a list of\n\
2141 directories, separated by colons. These directories are searched to find\n\
2142 fully linked executable files and separately compiled object files as needed."),
2144 set_cmd_completer (c
, noop_completer
);
2146 add_com ("attach", class_run
, attach_command
, _("\
2147 Attach to a process or file outside of GDB.\n\
2148 This command attaches to another target, of the same type as your last\n\
2149 \"target\" command (\"info files\" will show your target stack).\n\
2150 The command may take as argument a process id or a device file.\n\
2151 For a process id, you must have permission to send the process a signal,\n\
2152 and it must have the same effective uid as the debugger.\n\
2153 When using \"attach\" with a process id, the debugger finds the\n\
2154 program running in the process, looking first in the current working\n\
2155 directory, or (if not found there) using the source file search path\n\
2156 (see the \"directory\" command). You can also use the \"file\" command\n\
2157 to specify the program, and to load its symbol table."));
2159 add_prefix_cmd ("detach", class_run
, detach_command
, _("\
2160 Detach a process or file previously attached.\n\
2161 If a process, it is no longer traced, and it continues its execution. If\n\
2162 you were debugging a file, the file is closed and gdb no longer accesses it."),
2163 &detachlist
, "detach ", 0, &cmdlist
);
2165 add_com ("disconnect", class_run
, disconnect_command
, _("\
2166 Disconnect from a target.\n\
2167 The target will wait for another debugger to connect. Not available for\n\
2170 add_com ("signal", class_run
, signal_command
, _("\
2171 Continue program giving it signal specified by the argument.\n\
2172 An argument of \"0\" means continue program without giving it a signal."));
2174 add_com ("stepi", class_run
, stepi_command
, _("\
2175 Step one instruction exactly.\n\
2176 Argument N means do this N times (or till program stops for another reason)."));
2177 add_com_alias ("si", "stepi", class_alias
, 0);
2179 add_com ("nexti", class_run
, nexti_command
, _("\
2180 Step one instruction, but proceed through subroutine calls.\n\
2181 Argument N means do this N times (or till program stops for another reason)."));
2182 add_com_alias ("ni", "nexti", class_alias
, 0);
2184 add_com ("finish", class_run
, finish_command
, _("\
2185 Execute until selected stack frame returns.\n\
2186 Upon return, the value returned is printed and put in the value history."));
2188 add_com ("next", class_run
, next_command
, _("\
2189 Step program, proceeding through subroutine calls.\n\
2190 Like the \"step\" command as long as subroutine calls do not happen;\n\
2191 when they do, the call is treated as one instruction.\n\
2192 Argument N means do this N times (or till program stops for another reason)."));
2193 add_com_alias ("n", "next", class_run
, 1);
2195 add_com_alias ("S", "next", class_run
, 1);
2197 add_com ("step", class_run
, step_command
, _("\
2198 Step program until it reaches a different source line.\n\
2199 Argument N means do this N times (or till program stops for another reason)."));
2200 add_com_alias ("s", "step", class_run
, 1);
2202 c
= add_com ("until", class_run
, until_command
, _("\
2203 Execute until the program reaches a source line greater than the current\n\
2204 or a specified location (same args as break command) within the current frame."));
2205 set_cmd_completer (c
, location_completer
);
2206 add_com_alias ("u", "until", class_run
, 1);
2208 c
= add_com ("advance", class_run
, advance_command
, _("\
2209 Continue the program up to the given location (same form as args for break command).\n\
2210 Execution will also stop upon exit from the current stack frame."));
2211 set_cmd_completer (c
, location_completer
);
2213 c
= add_com ("jump", class_run
, jump_command
, _("\
2214 Continue program being debugged at specified line or address.\n\
2215 Give as argument either LINENUM or *ADDR, where ADDR is an expression\n\
2216 for an address to start at."));
2217 set_cmd_completer (c
, location_completer
);
2221 c
= add_com ("go", class_run
, go_command
, _("\
2222 Usage: go <location>\n\
2223 Continue program being debugged, stopping at specified line or \n\
2225 Give as argument either LINENUM or *ADDR, where ADDR is an \n\
2226 expression for an address to start at.\n\
2227 This command is a combination of tbreak and jump."));
2228 set_cmd_completer (c
, location_completer
);
2232 add_com_alias ("g", "go", class_run
, 1);
2234 add_com ("continue", class_run
, continue_command
, _("\
2235 Continue program being debugged, after signal or breakpoint.\n\
2236 If proceeding from breakpoint, a number N may be used as an argument,\n\
2237 which means to set the ignore count of that breakpoint to N - 1 (so that\n\
2238 the breakpoint won't break until the Nth time it is reached)."));
2239 add_com_alias ("c", "cont", class_run
, 1);
2240 add_com_alias ("fg", "cont", class_run
, 1);
2242 c
= add_com ("run", class_run
, run_command
, _("\
2243 Start debugged program. You may specify arguments to give it.\n\
2244 Args may include \"*\", or \"[...]\"; they are expanded using \"sh\".\n\
2245 Input and output redirection with \">\", \"<\", or \">>\" are also allowed.\n\n\
2246 With no arguments, uses arguments last specified (with \"run\" or \"set args\").\n\
2247 To cancel previous arguments and run with no arguments,\n\
2248 use \"set args\" without arguments."));
2249 set_cmd_completer (c
, filename_completer
);
2250 add_com_alias ("r", "run", class_run
, 1);
2252 add_com ("R", class_run
, run_no_args_command
,
2253 _("Start debugged program with no arguments."));
2255 c
= add_com ("start", class_run
, start_command
, _("\
2256 Run the debugged program until the beginning of the main procedure.\n\
2257 You may specify arguments to give to your program, just as with the\n\
2258 \"run\" command."));
2259 set_cmd_completer (c
, filename_completer
);
2261 add_com ("interrupt", class_run
, interrupt_target_command
,
2262 _("Interrupt the execution of the debugged program."));
2264 add_info ("registers", nofp_registers_info
, _("\
2265 List of integer registers and their contents, for selected stack frame.\n\
2266 Register name as argument means describe only that register."));
2267 add_info_alias ("r", "registers", 1);
2270 add_com ("lr", class_info
, nofp_registers_info
, _("\
2271 List of integer registers and their contents, for selected stack frame.\n\
2272 Register name as argument means describe only that register."));
2273 add_info ("all-registers", all_registers_info
, _("\
2274 List of all registers and their contents, for selected stack frame.\n\
2275 Register name as argument means describe only that register."));
2277 add_info ("program", program_info
,
2278 _("Execution status of the program."));
2280 add_info ("float", float_info
,
2281 _("Print the status of the floating point unit\n"));
2283 add_info ("vector", vector_info
,
2284 _("Print the status of the vector unit\n"));
2286 inferior_environ
= make_environ ();
2287 init_environ (inferior_environ
);