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, 2009 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "gdb_string.h"
38 #include "completer.h"
40 #include "event-top.h"
41 #include "parser-defs.h"
43 #include "reggroups.h"
47 #include "gdb_assert.h"
49 #include "target-descriptions.h"
50 #include "user-regs.h"
51 #include "exceptions.h"
52 #include "cli/cli-decode.h"
53 #include "gdbthread.h"
56 /* Functions exported for general use, in inferior.h: */
58 void all_registers_info (char *, int);
60 void registers_info (char *, int);
62 void nexti_command (char *, int);
64 void stepi_command (char *, int);
66 void continue_command (char *, int);
68 void interrupt_target_command (char *args
, int from_tty
);
70 /* Local functions: */
72 static void nofp_registers_info (char *, int);
74 static void print_return_value (struct type
*func_type
,
75 struct type
*value_type
);
77 static void until_next_command (int);
79 static void until_command (char *, int);
81 static void path_info (char *, int);
83 static void path_command (char *, int);
85 static void unset_command (char *, int);
87 static void float_info (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
, int thread
);
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 ERROR_NO_INFERIOR \
123 if (!target_has_execution) error (_("The program is not being run."));
125 /* String containing arguments to give to the program, separated by spaces.
126 Empty string (pointer to '\0') means no args. */
128 static char *inferior_args
;
130 /* The inferior arguments as a vector. If INFERIOR_ARGC is nonzero,
131 then we must compute INFERIOR_ARGS from this (via the target). */
133 static int inferior_argc
;
134 static char **inferior_argv
;
136 /* File name for default use for standard in/out in the inferior. */
138 static char *inferior_io_terminal
;
140 /* Pid of our debugged inferior, or 0 if no inferior now.
141 Since various parts of infrun.c test this to see whether there is a program
142 being debugged it should be nonzero (currently 3 is used) for remote
145 ptid_t inferior_ptid
;
147 /* Address at which inferior stopped. */
151 /* Flag indicating that a command has proceeded the inferior past the
152 current breakpoint. */
154 int breakpoint_proceeded
;
156 /* Nonzero if stopped due to completion of a stack dummy routine. */
158 int stop_stack_dummy
;
160 /* Nonzero if stopped due to a random (unexpected) signal in inferior
163 int stopped_by_random_signal
;
165 /* Environment to use for running inferior,
166 in format described in environ.h. */
168 struct gdb_environ
*inferior_environ
;
170 /* Accessor routines. */
173 set_inferior_io_terminal (const char *terminal_name
)
175 if (inferior_io_terminal
)
176 xfree (inferior_io_terminal
);
179 inferior_io_terminal
= NULL
;
181 inferior_io_terminal
= savestring (terminal_name
, strlen (terminal_name
));
185 get_inferior_io_terminal (void)
187 return inferior_io_terminal
;
191 get_inferior_args (void)
193 if (inferior_argc
!= 0)
197 n
= gdbarch_construct_inferior_arguments (current_gdbarch
,
198 inferior_argc
, inferior_argv
);
199 old
= set_inferior_args (n
);
203 if (inferior_args
== NULL
)
204 inferior_args
= xstrdup ("");
206 return inferior_args
;
210 set_inferior_args (char *newargs
)
212 char *saved_args
= inferior_args
;
214 inferior_args
= newargs
;
222 set_inferior_args_vector (int argc
, char **argv
)
224 inferior_argc
= argc
;
225 inferior_argv
= argv
;
228 /* Notice when `set args' is run. */
230 notice_args_set (char *args
, int from_tty
, struct cmd_list_element
*c
)
236 /* Notice when `show args' is run. */
238 notice_args_read (struct ui_file
*file
, int from_tty
,
239 struct cmd_list_element
*c
, const char *value
)
241 /* Note that we ignore the passed-in value in favor of computing it
243 deprecated_show_value_hack (file
, from_tty
, c
, get_inferior_args ());
247 /* Compute command-line string given argument vector. This does the
248 same shell processing as fork_inferior. */
250 construct_inferior_arguments (struct gdbarch
*gdbarch
, int argc
, char **argv
)
254 if (STARTUP_WITH_SHELL
)
256 /* This holds all the characters considered special to the
257 typical Unix shells. We include `^' because the SunOS
258 /bin/sh treats it as a synonym for `|'. */
259 char *special
= "\"!#$&*()\\|[]{}<>?'\"`~^; \t\n";
264 /* We over-compute the size. It shouldn't matter. */
265 for (i
= 0; i
< argc
; ++i
)
266 length
+= 3 * strlen (argv
[i
]) + 1 + 2 * (argv
[i
][0] == '\0');
268 result
= (char *) xmalloc (length
);
271 for (i
= 0; i
< argc
; ++i
)
276 /* Need to handle empty arguments specially. */
277 if (argv
[i
][0] == '\0')
284 for (cp
= argv
[i
]; *cp
; ++cp
)
288 /* A newline cannot be quoted with a backslash (it
289 just disappears), only by putting it inside
297 if (strchr (special
, *cp
) != NULL
)
308 /* In this case we can't handle arguments that contain spaces,
309 tabs, or newlines -- see breakup_args(). */
313 for (i
= 0; i
< argc
; ++i
)
315 char *cp
= strchr (argv
[i
], ' ');
317 cp
= strchr (argv
[i
], '\t');
319 cp
= strchr (argv
[i
], '\n');
321 error (_("can't handle command-line argument containing whitespace"));
322 length
+= strlen (argv
[i
]) + 1;
325 result
= (char *) xmalloc (length
);
327 for (i
= 0; i
< argc
; ++i
)
330 strcat (result
, " ");
331 strcat (result
, argv
[i
]);
339 /* This function detects whether or not a '&' character (indicating
340 background execution) has been added as *the last* of the arguments ARGS
341 of a command. If it has, it removes it and returns 1. Otherwise it
342 does nothing and returns 0. */
344 strip_bg_char (char **args
)
348 p
= strchr (*args
, '&');
352 if (p
== (*args
+ strlen (*args
) - 1))
354 if (strlen (*args
) > 1)
358 while (*p
== ' ' || *p
== '\t');
370 tty_command (char *file
, int from_tty
)
373 error_no_arg (_("terminal name for running target process"));
375 set_inferior_io_terminal (file
);
378 /* Common actions to take after creating any sort of inferior, by any
379 means (running, attaching, connecting, et cetera). The target
380 should be stopped. */
383 post_create_inferior (struct target_ops
*target
, int from_tty
)
385 /* Be sure we own the terminal in case write operations are performed. */
386 target_terminal_ours ();
388 /* If the target hasn't taken care of this already, do it now.
389 Targets which need to access registers during to_open,
390 to_create_inferior, or to_attach should do it earlier; but many
392 target_find_description ();
394 /* If the solist is global across processes, there's no need to
396 if (exec_bfd
&& !gdbarch_has_global_solist (target_gdbarch
))
398 /* Sometimes the platform-specific hook loads initial shared
399 libraries, and sometimes it doesn't. Try to do so first, so
400 that we can add them with the correct value for FROM_TTY.
401 If we made all the inferior hook methods consistent,
402 this call could be removed. */
404 SOLIB_ADD (NULL
, from_tty
, target
, auto_solib_add
);
406 solib_add (NULL
, from_tty
, target
, auto_solib_add
);
412 /* Create the hooks to handle shared library load and unload
414 #ifdef SOLIB_CREATE_INFERIOR_HOOK
415 SOLIB_CREATE_INFERIOR_HOOK (PIDGET (inferior_ptid
));
417 solib_create_inferior_hook ();
421 observer_notify_inferior_created (target
, from_tty
);
424 /* Kill the inferior if already running. This function is designed
425 to be called when we are about to start the execution of the program
426 from the beginning. Ask the user to confirm that he wants to restart
427 the program being debugged when FROM_TTY is non-null. */
430 kill_if_already_running (int from_tty
)
432 if (! ptid_equal (inferior_ptid
, null_ptid
) && target_has_execution
)
434 /* Bail out before killing the program if we will not be able to
436 target_require_runnable ();
439 && !query (_("The program being debugged has been started already.\n\
440 Start it from the beginning? ")))
441 error (_("Program not restarted."));
446 /* Implement the "run" command. If TBREAK_AT_MAIN is set, then insert
447 a temporary breakpoint at the begining of the main program before
448 running the program. */
451 run_command_1 (char *args
, int from_tty
, int tbreak_at_main
)
454 struct cleanup
*old_chain
;
459 kill_if_already_running (from_tty
);
461 init_wait_for_inferior ();
462 clear_breakpoint_hit_counts ();
464 /* Clean up any leftovers from other runs. Some other things from
465 this function should probably be moved into target_pre_inferior. */
466 target_pre_inferior (from_tty
);
468 /* The comment here used to read, "The exec file is re-read every
469 time we do a generic_mourn_inferior, so we just have to worry
470 about the symbol file." The `generic_mourn_inferior' function
471 gets called whenever the program exits. However, suppose the
472 program exits, and *then* the executable file changes? We need
473 to check again here. Since reopen_exec_file doesn't do anything
474 if the timestamp hasn't changed, I don't see the harm. */
478 /* Insert the temporary breakpoint if a location was specified. */
480 tbreak_command (main_name (), 0);
482 exec_file
= (char *) get_exec_file (0);
484 if (non_stop
&& !target_supports_non_stop ())
485 error (_("The target does not support running in non-stop mode."));
487 /* We keep symbols from add-symbol-file, on the grounds that the
488 user might want to add some symbols before running the program
489 (right?). But sometimes (dynamic loading where the user manually
490 introduces the new symbols with add-symbol-file), the code which
491 the symbols describe does not persist between runs. Currently
492 the user has to manually nuke all symbols between runs if they
493 want them to go away (PR 2207). This is probably reasonable. */
497 if (target_can_async_p ())
498 async_disable_stdin ();
502 int async_exec
= strip_bg_char (&args
);
504 /* If we get a request for running in the bg but the target
505 doesn't support it, error out. */
506 if (async_exec
&& !target_can_async_p ())
507 error (_("Asynchronous execution not supported on this target."));
509 /* If we don't get a request of running in the bg, then we need
510 to simulate synchronous (fg) execution. */
511 if (!async_exec
&& target_can_async_p ())
513 /* Simulate synchronous execution */
514 async_disable_stdin ();
517 /* If there were other args, beside '&', process them. */
520 char *old_args
= set_inferior_args (xstrdup (args
));
527 ui_out_field_string (uiout
, NULL
, "Starting program");
528 ui_out_text (uiout
, ": ");
530 ui_out_field_string (uiout
, "execfile", exec_file
);
531 ui_out_spaces (uiout
, 1);
532 /* We call get_inferior_args() because we might need to compute
534 ui_out_field_string (uiout
, "infargs", get_inferior_args ());
535 ui_out_text (uiout
, "\n");
536 ui_out_flush (uiout
);
539 /* We call get_inferior_args() because we might need to compute
541 target_create_inferior (exec_file
, get_inferior_args (),
542 environ_vector (inferior_environ
), from_tty
);
544 /* We're starting off a new process. When we get out of here, in
545 non-stop mode, finish the state of all threads of that process,
546 but leave other threads alone, as they may be stopped in internal
547 events --- the frontend shouldn't see them as stopped. In
548 all-stop, always finish the state of all threads, as we may be
549 resuming more than just the new process. */
551 ptid
= pid_to_ptid (ptid_get_pid (inferior_ptid
));
553 ptid
= minus_one_ptid
;
554 old_chain
= make_cleanup (finish_thread_state_cleanup
, &ptid
);
556 /* Pass zero for FROM_TTY, because at this point the "run" command
557 has done its thing; now we are setting up the running program. */
558 post_create_inferior (¤t_target
, 0);
560 /* Start the target running. */
561 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_0
, 0);
563 /* Since there was no error, there's no need to finish the thread
565 discard_cleanups (old_chain
);
569 run_command (char *args
, int from_tty
)
571 run_command_1 (args
, from_tty
, 0);
575 run_no_args_command (char *args
, int from_tty
)
577 char *old_args
= set_inferior_args (xstrdup (""));
582 /* Start the execution of the program up until the beginning of the main
586 start_command (char *args
, int from_tty
)
588 /* Some languages such as Ada need to search inside the program
589 minimal symbols for the location where to put the temporary
590 breakpoint before starting. */
591 if (!have_minimal_symbols ())
592 error (_("No symbol table loaded. Use the \"file\" command."));
594 /* Run the program until reaching the main procedure... */
595 run_command_1 (args
, from_tty
, 1);
599 proceed_thread_callback (struct thread_info
*thread
, void *arg
)
601 /* We go through all threads individually instead of compressing
602 into a single target `resume_all' request, because some threads
603 may be stopped in internal breakpoints/events, or stopped waiting
604 for its turn in the displaced stepping queue (that is, they are
605 running && !executing). The target side has no idea about why
606 the thread is stopped, so a `resume_all' command would resume too
607 much. If/when GDB gains a way to tell the target `hold this
608 thread stopped until I say otherwise', then we can optimize
610 if (!is_stopped (thread
->ptid
))
613 switch_to_thread (thread
->ptid
);
614 clear_proceed_status ();
615 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 0);
620 continue_1 (int all_threads
)
624 if (non_stop
&& all_threads
)
626 /* Don't error out if the current thread is running, because
627 there may be other stopped threads. */
628 struct cleanup
*old_chain
;
630 /* Backup current thread and selected frame. */
631 old_chain
= make_cleanup_restore_current_thread ();
633 iterate_over_threads (proceed_thread_callback
, NULL
);
635 /* Restore selected ptid. */
636 do_cleanups (old_chain
);
640 ensure_not_running ();
641 clear_proceed_status ();
642 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 0);
646 /* continue [-a] [proceed-count] [&] */
648 continue_command (char *args
, int from_tty
)
654 /* Find out whether we must run in the background. */
656 async_exec
= strip_bg_char (&args
);
658 /* If we must run in the background, but the target can't do it,
660 if (async_exec
&& !target_can_async_p ())
661 error (_("Asynchronous execution not supported on this target."));
663 /* If we are not asked to run in the bg, then prepare to run in the
664 foreground, synchronously. */
665 if (!async_exec
&& target_can_async_p ())
667 /* Simulate synchronous execution */
668 async_disable_stdin ();
673 if (strncmp (args
, "-a", sizeof ("-a") - 1) == 0)
676 args
+= sizeof ("-a") - 1;
682 if (!non_stop
&& all_threads
)
683 error (_("`-a' is meaningless in all-stop mode."));
685 if (args
!= NULL
&& all_threads
)
687 Can't resume all threads and specify proceed count simultaneously."));
689 /* If we have an argument left, set proceed count of breakpoint we
696 struct thread_info
*tp
;
699 tp
= find_thread_pid (inferior_ptid
);
703 struct target_waitstatus ws
;
705 get_last_target_status (&last_ptid
, &ws
);
706 tp
= find_thread_pid (last_ptid
);
709 bs
= tp
->stop_bpstat
;
711 while ((stat
= bpstat_num (&bs
, &num
)) != 0)
714 set_ignore_count (num
,
715 parse_and_eval_long (args
) - 1,
717 /* set_ignore_count prints a message ending with a period.
718 So print two spaces before "Continuing.". */
720 printf_filtered (" ");
724 if (!stopped
&& from_tty
)
727 ("Not stopped at any breakpoint; argument ignored.\n");
732 printf_filtered (_("Continuing.\n"));
734 continue_1 (all_threads
);
737 /* Step until outside of current statement. */
740 step_command (char *count_string
, int from_tty
)
742 step_1 (0, 0, count_string
);
745 /* Likewise, but skip over subroutine calls as if single instructions. */
748 next_command (char *count_string
, int from_tty
)
750 step_1 (1, 0, count_string
);
753 /* Likewise, but step only one instruction. */
756 stepi_command (char *count_string
, int from_tty
)
758 step_1 (0, 1, count_string
);
762 nexti_command (char *count_string
, int from_tty
)
764 step_1 (1, 1, count_string
);
768 delete_longjmp_breakpoint_cleanup (void *arg
)
770 int thread
= * (int *) arg
;
771 delete_longjmp_breakpoint (thread
);
775 step_1 (int skip_subroutines
, int single_inst
, char *count_string
)
778 struct frame_info
*frame
;
779 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
784 ensure_not_running ();
787 async_exec
= strip_bg_char (&count_string
);
789 /* If we get a request for running in the bg but the target
790 doesn't support it, error out. */
791 if (async_exec
&& !target_can_async_p ())
792 error (_("Asynchronous execution not supported on this target."));
794 /* If we don't get a request of running in the bg, then we need
795 to simulate synchronous (fg) execution. */
796 if (!async_exec
&& target_can_async_p ())
798 /* Simulate synchronous execution */
799 async_disable_stdin ();
802 count
= count_string
? parse_and_eval_long (count_string
) : 1;
804 if (!single_inst
|| skip_subroutines
) /* leave si command alone */
806 if (in_thread_list (inferior_ptid
))
807 thread
= pid_to_thread_id (inferior_ptid
);
809 set_longjmp_breakpoint ();
811 make_cleanup (delete_longjmp_breakpoint_cleanup
, &thread
);
814 /* In synchronous case, all is well; each step_once call will step once. */
815 if (!target_can_async_p ())
817 for (; count
> 0; count
--)
819 struct thread_info
*tp
;
820 step_once (skip_subroutines
, single_inst
, count
, thread
);
822 if (target_has_execution
823 && !ptid_equal (inferior_ptid
, null_ptid
))
824 tp
= inferior_thread ();
828 if (!tp
|| !tp
->stop_step
|| !tp
->step_multi
)
830 /* If we stopped for some reason that is not stepping
831 there are no further steps to make. */
838 do_cleanups (cleanups
);
842 /* In the case of an asynchronous target things get complicated;
843 do only one step for now, before returning control to the
844 event loop. Let the continuation figure out how many other
845 steps we need to do, and handle them one at the time, through
847 step_once (skip_subroutines
, single_inst
, count
, thread
);
849 /* We are running, and the continuation is installed. It will
850 disable the longjmp breakpoint as appropriate. */
851 discard_cleanups (cleanups
);
855 struct step_1_continuation_args
858 int skip_subroutines
;
863 /* Called after we are done with one step operation, to check whether
864 we need to step again, before we print the prompt and return control
865 to the user. If count is > 1, we will need to do one more call to
866 proceed(), via step_once(). Basically it is like step_once and
867 step_1_continuation are co-recursive. */
869 step_1_continuation (void *args
)
871 struct step_1_continuation_args
*a
= args
;
873 if (target_has_execution
)
875 struct thread_info
*tp
;
877 tp
= inferior_thread ();
878 if (tp
->step_multi
&& tp
->stop_step
)
880 /* There are more steps to make, and we did stop due to
881 ending a stepping range. Do another step. */
882 step_once (a
->skip_subroutines
, a
->single_inst
,
883 a
->count
- 1, a
->thread
);
889 /* We either stopped for some reason that is not stepping, or there
890 are no further steps to make. Cleanup. */
891 if (!a
->single_inst
|| a
->skip_subroutines
)
892 delete_longjmp_breakpoint (a
->thread
);
895 /* Do just one step operation. This is useful to implement the 'step
896 n' kind of commands. In case of asynchronous targets, we will have
897 to set up a continuation to be done after the target stops (after
898 this one step). For synch targets, the caller handles further
902 step_once (int skip_subroutines
, int single_inst
, int count
, int thread
)
904 struct frame_info
*frame
;
908 /* Don't assume THREAD is a valid thread id. It is set to -1 if
909 the longjmp breakpoint was not required. Use the
910 INFERIOR_PTID thread instead, which is the same thread when
912 struct thread_info
*tp
= inferior_thread ();
913 clear_proceed_status ();
915 frame
= get_current_frame ();
916 tp
->step_frame_id
= get_frame_id (frame
);
922 pc
= get_frame_pc (frame
);
923 find_pc_line_pc_range (pc
,
924 &tp
->step_range_start
, &tp
->step_range_end
);
926 /* If we have no line info, switch to stepi mode. */
927 if (tp
->step_range_end
== 0 && step_stop_if_no_debug
)
929 tp
->step_range_start
= tp
->step_range_end
= 1;
931 else if (tp
->step_range_end
== 0)
934 if (find_pc_partial_function (pc
, &name
,
935 &tp
->step_range_start
,
936 &tp
->step_range_end
) == 0)
937 error (_("Cannot find bounds of current function"));
939 target_terminal_ours ();
940 printf_filtered (_("\
941 Single stepping until exit from function %s, \n\
942 which has no line number information.\n"), name
);
947 /* Say we are stepping, but stop after one insn whatever it does. */
948 tp
->step_range_start
= tp
->step_range_end
= 1;
949 if (!skip_subroutines
)
951 Don't step over function calls, not even to functions lacking
953 tp
->step_over_calls
= STEP_OVER_NONE
;
956 if (skip_subroutines
)
957 tp
->step_over_calls
= STEP_OVER_ALL
;
959 tp
->step_multi
= (count
> 1);
960 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 1);
962 /* For async targets, register a continuation to do any
963 additional steps. For sync targets, the caller will handle
965 if (target_can_async_p ())
967 struct step_1_continuation_args
*args
;
969 args
= xmalloc (sizeof (*args
));
970 args
->skip_subroutines
= skip_subroutines
;
971 args
->single_inst
= single_inst
;
973 args
->thread
= thread
;
975 add_intermediate_continuation (tp
, step_1_continuation
, args
, xfree
);
981 /* Continue program at specified address. */
984 jump_command (char *arg
, int from_tty
)
987 struct symtabs_and_lines sals
;
988 struct symtab_and_line sal
;
994 ensure_not_running ();
996 /* Find out whether we must run in the background. */
998 async_exec
= strip_bg_char (&arg
);
1000 /* If we must run in the background, but the target can't do it,
1002 if (async_exec
&& !target_can_async_p ())
1003 error (_("Asynchronous execution not supported on this target."));
1006 error_no_arg (_("starting address"));
1008 sals
= decode_line_spec_1 (arg
, 1);
1009 if (sals
.nelts
!= 1)
1011 error (_("Unreasonable jump request"));
1017 if (sal
.symtab
== 0 && sal
.pc
== 0)
1018 error (_("No source file has been specified."));
1020 resolve_sal_pc (&sal
); /* May error out */
1022 /* See if we are trying to jump to another function. */
1023 fn
= get_frame_function (get_current_frame ());
1024 sfn
= find_pc_function (sal
.pc
);
1025 if (fn
!= NULL
&& sfn
!= fn
)
1027 if (!query (_("Line %d is not in `%s'. Jump anyway? "), sal
.line
,
1028 SYMBOL_PRINT_NAME (fn
)))
1030 error (_("Not confirmed."));
1037 fixup_symbol_section (sfn
, 0);
1038 if (section_is_overlay (SYMBOL_OBJ_SECTION (sfn
)) &&
1039 !section_is_mapped (SYMBOL_OBJ_SECTION (sfn
)))
1041 if (!query (_("WARNING!!! Destination is in unmapped overlay! Jump anyway? ")))
1043 error (_("Not confirmed."));
1053 printf_filtered (_("Continuing at "));
1054 fputs_filtered (paddress (addr
), gdb_stdout
);
1055 printf_filtered (".\n");
1058 /* If we are not asked to run in the bg, then prepare to run in the
1059 foreground, synchronously. */
1060 if (!async_exec
&& target_can_async_p ())
1062 /* Simulate synchronous execution */
1063 async_disable_stdin ();
1066 clear_proceed_status ();
1067 proceed (addr
, TARGET_SIGNAL_0
, 0);
1071 /* Go to line or address in current procedure */
1073 go_command (char *line_no
, int from_tty
)
1075 if (line_no
== (char *) NULL
|| !*line_no
)
1076 printf_filtered (_("Usage: go <location>\n"));
1079 tbreak_command (line_no
, from_tty
);
1080 jump_command (line_no
, from_tty
);
1085 /* Continue program giving it specified signal. */
1088 signal_command (char *signum_exp
, int from_tty
)
1090 enum target_signal oursig
;
1093 dont_repeat (); /* Too dangerous. */
1095 ensure_not_running ();
1097 /* Find out whether we must run in the background. */
1098 if (signum_exp
!= NULL
)
1099 async_exec
= strip_bg_char (&signum_exp
);
1101 /* If we must run in the background, but the target can't do it,
1103 if (async_exec
&& !target_can_async_p ())
1104 error (_("Asynchronous execution not supported on this target."));
1106 /* If we are not asked to run in the bg, then prepare to run in the
1107 foreground, synchronously. */
1108 if (!async_exec
&& target_can_async_p ())
1110 /* Simulate synchronous execution. */
1111 async_disable_stdin ();
1115 error_no_arg (_("signal number"));
1117 /* It would be even slicker to make signal names be valid expressions,
1118 (the type could be "enum $signal" or some such), then the user could
1119 assign them to convenience variables. */
1120 oursig
= target_signal_from_name (signum_exp
);
1122 if (oursig
== TARGET_SIGNAL_UNKNOWN
)
1124 /* No, try numeric. */
1125 int num
= parse_and_eval_long (signum_exp
);
1128 oursig
= TARGET_SIGNAL_0
;
1130 oursig
= target_signal_from_command (num
);
1135 if (oursig
== TARGET_SIGNAL_0
)
1136 printf_filtered (_("Continuing with no signal.\n"));
1138 printf_filtered (_("Continuing with signal %s.\n"),
1139 target_signal_to_name (oursig
));
1142 clear_proceed_status ();
1143 proceed ((CORE_ADDR
) -1, oursig
, 0);
1146 /* Proceed until we reach a different source line with pc greater than
1147 our current one or exit the function. We skip calls in both cases.
1149 Note that eventually this command should probably be changed so
1150 that only source lines are printed out when we hit the breakpoint
1151 we set. This may involve changes to wait_for_inferior and the
1152 proceed status code. */
1155 until_next_command (int from_tty
)
1157 struct frame_info
*frame
;
1159 struct symbol
*func
;
1160 struct symtab_and_line sal
;
1161 struct thread_info
*tp
= inferior_thread ();
1163 clear_proceed_status ();
1165 frame
= get_current_frame ();
1167 /* Step until either exited from this function or greater
1168 than the current line (if in symbolic section) or pc (if
1171 pc
= get_frame_pc (frame
);
1172 func
= find_pc_function (pc
);
1176 struct minimal_symbol
*msymbol
= lookup_minimal_symbol_by_pc (pc
);
1178 if (msymbol
== NULL
)
1179 error (_("Execution is not within a known function."));
1181 tp
->step_range_start
= SYMBOL_VALUE_ADDRESS (msymbol
);
1182 tp
->step_range_end
= pc
;
1186 sal
= find_pc_line (pc
, 0);
1188 tp
->step_range_start
= BLOCK_START (SYMBOL_BLOCK_VALUE (func
));
1189 tp
->step_range_end
= sal
.end
;
1192 tp
->step_over_calls
= STEP_OVER_ALL
;
1193 tp
->step_frame_id
= get_frame_id (frame
);
1195 tp
->step_multi
= 0; /* Only one call to proceed */
1197 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 1);
1201 until_command (char *arg
, int from_tty
)
1205 if (!target_has_execution
)
1206 error (_("The program is not running."));
1208 /* Find out whether we must run in the background. */
1210 async_exec
= strip_bg_char (&arg
);
1212 /* If we must run in the background, but the target can't do it,
1214 if (async_exec
&& !target_can_async_p ())
1215 error (_("Asynchronous execution not supported on this target."));
1217 /* If we are not asked to run in the bg, then prepare to run in the
1218 foreground, synchronously. */
1219 if (!async_exec
&& target_can_async_p ())
1221 /* Simulate synchronous execution */
1222 async_disable_stdin ();
1226 until_break_command (arg
, from_tty
, 0);
1228 until_next_command (from_tty
);
1232 advance_command (char *arg
, int from_tty
)
1236 if (!target_has_execution
)
1237 error (_("The program is not running."));
1240 error_no_arg (_("a location"));
1242 /* Find out whether we must run in the background. */
1244 async_exec
= strip_bg_char (&arg
);
1246 /* If we must run in the background, but the target can't do it,
1248 if (async_exec
&& !target_can_async_p ())
1249 error (_("Asynchronous execution not supported on this target."));
1251 /* If we are not asked to run in the bg, then prepare to run in the
1252 foreground, synchronously. */
1253 if (!async_exec
&& target_can_async_p ())
1255 /* Simulate synchronous execution. */
1256 async_disable_stdin ();
1259 until_break_command (arg
, from_tty
, 1);
1262 /* Print the result of a function at the end of a 'finish' command. */
1265 print_return_value (struct type
*func_type
, struct type
*value_type
)
1267 struct gdbarch
*gdbarch
= current_gdbarch
;
1268 struct cleanup
*old_chain
;
1269 struct ui_stream
*stb
;
1270 struct value
*value
;
1272 CHECK_TYPEDEF (value_type
);
1273 gdb_assert (TYPE_CODE (value_type
) != TYPE_CODE_VOID
);
1275 /* FIXME: 2003-09-27: When returning from a nested inferior function
1276 call, it's possible (with no help from the architecture vector)
1277 to locate and return/print a "struct return" value. This is just
1278 a more complicated case of what is already being done in in the
1279 inferior function call code. In fact, when inferior function
1280 calls are made async, this will likely be made the norm. */
1282 switch (gdbarch_return_value (gdbarch
, func_type
, value_type
,
1285 case RETURN_VALUE_REGISTER_CONVENTION
:
1286 case RETURN_VALUE_ABI_RETURNS_ADDRESS
:
1287 case RETURN_VALUE_ABI_PRESERVES_ADDRESS
:
1288 value
= allocate_value (value_type
);
1289 gdbarch_return_value (gdbarch
, func_type
, value_type
, stop_registers
,
1290 value_contents_raw (value
), NULL
);
1292 case RETURN_VALUE_STRUCT_CONVENTION
:
1296 internal_error (__FILE__
, __LINE__
, _("bad switch"));
1301 struct value_print_options opts
;
1304 stb
= ui_out_stream_new (uiout
);
1305 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
1306 ui_out_text (uiout
, "Value returned is ");
1307 ui_out_field_fmt (uiout
, "gdb-result-var", "$%d",
1308 record_latest_value (value
));
1309 ui_out_text (uiout
, " = ");
1310 get_raw_print_options (&opts
);
1311 value_print (value
, stb
->stream
, &opts
);
1312 ui_out_field_stream (uiout
, "return-value", stb
);
1313 ui_out_text (uiout
, "\n");
1314 do_cleanups (old_chain
);
1318 ui_out_text (uiout
, "Value returned has type: ");
1319 ui_out_field_string (uiout
, "return-type", TYPE_NAME (value_type
));
1320 ui_out_text (uiout
, ".");
1321 ui_out_text (uiout
, " Cannot determine contents\n");
1325 /* Stuff that needs to be done by the finish command after the target
1326 has stopped. In asynchronous mode, we wait for the target to stop
1327 in the call to poll or select in the event loop, so it is
1328 impossible to do all the stuff as part of the finish_command
1329 function itself. The only chance we have to complete this command
1330 is in fetch_inferior_event, which is called by the event loop as
1331 soon as it detects that the target has stopped. This function is
1332 called via the cmd_continuation pointer. */
1334 struct finish_command_continuation_args
1336 struct breakpoint
*breakpoint
;
1337 struct symbol
*function
;
1341 finish_command_continuation (void *arg
)
1343 struct finish_command_continuation_args
*a
= arg
;
1344 struct thread_info
*tp
= NULL
;
1347 if (!ptid_equal (inferior_ptid
, null_ptid
)
1348 && target_has_execution
1349 && is_stopped (inferior_ptid
))
1351 tp
= inferior_thread ();
1352 bs
= tp
->stop_bpstat
;
1355 if (bpstat_find_breakpoint (bs
, a
->breakpoint
) != NULL
1356 && a
->function
!= NULL
)
1358 struct type
*value_type
;
1360 value_type
= TYPE_TARGET_TYPE (SYMBOL_TYPE (a
->function
));
1362 internal_error (__FILE__
, __LINE__
,
1363 _("finish_command: function has no target type"));
1365 if (TYPE_CODE (value_type
) != TYPE_CODE_VOID
)
1366 print_return_value (SYMBOL_TYPE (a
->function
), value_type
);
1369 /* We suppress normal call of normal_stop observer and do it here so
1370 that the *stopped notification includes the return value. */
1371 if (bs
!= NULL
&& tp
->proceed_to_finish
)
1372 observer_notify_normal_stop (bs
, 1 /* print frame */);
1373 delete_breakpoint (a
->breakpoint
);
1377 finish_command_continuation_free_arg (void *arg
)
1382 /* finish_backward -- helper function for finish_command. */
1385 finish_backward (struct symbol
*function
)
1387 struct symtab_and_line sal
;
1388 struct thread_info
*tp
= inferior_thread ();
1389 struct breakpoint
*breakpoint
;
1390 struct cleanup
*old_chain
;
1392 CORE_ADDR func_addr
;
1395 pc
= get_frame_pc (get_current_frame ());
1397 if (find_pc_partial_function (pc
, NULL
, &func_addr
, NULL
) == 0)
1398 internal_error (__FILE__
, __LINE__
,
1399 _("Finish: couldn't find function."));
1401 sal
= find_pc_line (func_addr
, 0);
1403 /* We don't need a return value. */
1404 tp
->proceed_to_finish
= 0;
1405 /* Special case: if we're sitting at the function entry point,
1406 then all we need to do is take a reverse singlestep. We
1407 don't need to set a breakpoint, and indeed it would do us
1410 Note that this can only happen at frame #0, since there's
1411 no way that a function up the stack can have a return address
1412 that's equal to its entry point. */
1416 /* Set breakpoint and continue. */
1418 set_momentary_breakpoint (sal
,
1419 get_frame_id (get_selected_frame (NULL
)),
1421 /* Tell the breakpoint to keep quiet. We won't be done
1422 until we've done another reverse single-step. */
1423 make_breakpoint_silent (breakpoint
);
1424 old_chain
= make_cleanup_delete_breakpoint (breakpoint
);
1425 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 0);
1426 /* We will be stopped when proceed returns. */
1427 back_up
= bpstat_find_breakpoint (tp
->stop_bpstat
, breakpoint
) != NULL
;
1428 do_cleanups (old_chain
);
1434 /* If in fact we hit the step-resume breakpoint (and not
1435 some other breakpoint), then we're almost there --
1436 we just need to back up by one more single-step. */
1437 tp
->step_range_start
= tp
->step_range_end
= 1;
1438 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 1);
1443 /* finish_forward -- helper function for finish_command. */
1446 finish_forward (struct symbol
*function
, struct frame_info
*frame
)
1448 struct symtab_and_line sal
;
1449 struct thread_info
*tp
= inferior_thread ();
1450 struct breakpoint
*breakpoint
;
1451 struct cleanup
*old_chain
;
1452 struct finish_command_continuation_args
*cargs
;
1454 sal
= find_pc_line (get_frame_pc (frame
), 0);
1455 sal
.pc
= get_frame_pc (frame
);
1457 breakpoint
= set_momentary_breakpoint (sal
, get_frame_id (frame
),
1460 old_chain
= make_cleanup_delete_breakpoint (breakpoint
);
1462 tp
->proceed_to_finish
= 1; /* We want stop_registers, please... */
1463 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 0);
1465 cargs
= xmalloc (sizeof (*cargs
));
1467 cargs
->breakpoint
= breakpoint
;
1468 cargs
->function
= function
;
1469 add_continuation (tp
, finish_command_continuation
, cargs
,
1470 finish_command_continuation_free_arg
);
1472 discard_cleanups (old_chain
);
1473 if (!target_can_async_p ())
1474 do_all_continuations ();
1477 /* "finish": Set a temporary breakpoint at the place the selected
1478 frame will return to, then continue. */
1481 finish_command (char *arg
, int from_tty
)
1483 struct frame_info
*frame
;
1484 struct symbol
*function
;
1488 /* Find out whether we must run in the background. */
1490 async_exec
= strip_bg_char (&arg
);
1492 /* If we must run in the background, but the target can't do it,
1494 if (async_exec
&& !target_can_async_p ())
1495 error (_("Asynchronous execution not supported on this target."));
1497 /* Don't try to async in reverse. */
1498 if (async_exec
&& execution_direction
== EXEC_REVERSE
)
1499 error (_("Asynchronous 'finish' not supported in reverse."));
1501 /* If we are not asked to run in the bg, then prepare to run in the
1502 foreground, synchronously. */
1503 if (!async_exec
&& target_can_async_p ())
1505 /* Simulate synchronous execution. */
1506 async_disable_stdin ();
1510 error (_("The \"finish\" command does not take any arguments."));
1511 if (!target_has_execution
)
1512 error (_("The program is not running."));
1514 frame
= get_prev_frame (get_selected_frame (_("No selected frame.")));
1516 error (_("\"finish\" not meaningful in the outermost frame."));
1518 clear_proceed_status ();
1520 /* Find the function we will return from. */
1522 function
= find_pc_function (get_frame_pc (get_selected_frame (NULL
)));
1524 /* Print info on the selected frame, including level number but not
1528 if (execution_direction
== EXEC_REVERSE
)
1529 printf_filtered (_("Run back to call of "));
1531 printf_filtered (_("Run till exit from "));
1533 print_stack_frame (get_selected_frame (NULL
), 1, LOCATION
);
1536 if (execution_direction
== EXEC_REVERSE
)
1537 finish_backward (function
);
1539 finish_forward (function
, frame
);
1544 program_info (char *args
, int from_tty
)
1548 struct thread_info
*tp
;
1551 if (!target_has_execution
)
1553 printf_filtered (_("The program being debugged is not being run.\n"));
1558 ptid
= inferior_ptid
;
1561 struct target_waitstatus ws
;
1562 get_last_target_status (&ptid
, &ws
);
1565 if (ptid_equal (ptid
, null_ptid
) || is_exited (ptid
))
1566 error (_("Invalid selected thread."));
1567 else if (is_running (ptid
))
1568 error (_("Selected thread is running."));
1570 tp
= find_thread_pid (ptid
);
1571 bs
= tp
->stop_bpstat
;
1572 stat
= bpstat_num (&bs
, &num
);
1574 target_files_info ();
1575 printf_filtered (_("Program stopped at %s.\n"), paddress (stop_pc
));
1577 printf_filtered (_("It stopped after being stepped.\n"));
1580 /* There may be several breakpoints in the same place, so this
1581 isn't as strange as it seems. */
1586 printf_filtered (_("\
1587 It stopped at a breakpoint that has since been deleted.\n"));
1590 printf_filtered (_("It stopped at breakpoint %d.\n"), num
);
1591 stat
= bpstat_num (&bs
, &num
);
1594 else if (tp
->stop_signal
!= TARGET_SIGNAL_0
)
1596 printf_filtered (_("It stopped with signal %s, %s.\n"),
1597 target_signal_to_name (tp
->stop_signal
),
1598 target_signal_to_string (tp
->stop_signal
));
1603 printf_filtered (_("\
1604 Type \"info stack\" or \"info registers\" for more information.\n"));
1609 environment_info (char *var
, int from_tty
)
1613 char *val
= get_in_environ (inferior_environ
, var
);
1616 puts_filtered (var
);
1617 puts_filtered (" = ");
1618 puts_filtered (val
);
1619 puts_filtered ("\n");
1623 puts_filtered ("Environment variable \"");
1624 puts_filtered (var
);
1625 puts_filtered ("\" not defined.\n");
1630 char **vector
= environ_vector (inferior_environ
);
1633 puts_filtered (*vector
++);
1634 puts_filtered ("\n");
1640 set_environment_command (char *arg
, int from_tty
)
1642 char *p
, *val
, *var
;
1646 error_no_arg (_("environment variable and value"));
1648 /* Find seperation between variable name and value */
1649 p
= (char *) strchr (arg
, '=');
1650 val
= (char *) strchr (arg
, ' ');
1652 if (p
!= 0 && val
!= 0)
1654 /* We have both a space and an equals. If the space is before the
1655 equals, walk forward over the spaces til we see a nonspace
1656 (possibly the equals). */
1661 /* Now if the = is after the char following the spaces,
1662 take the char following the spaces. */
1666 else if (val
!= 0 && p
== 0)
1670 error_no_arg (_("environment variable to set"));
1672 if (p
== 0 || p
[1] == 0)
1676 p
= arg
+ strlen (arg
); /* So that savestring below will work */
1680 /* Not setting variable value to null */
1682 while (*val
== ' ' || *val
== '\t')
1686 while (p
!= arg
&& (p
[-1] == ' ' || p
[-1] == '\t'))
1689 var
= savestring (arg
, p
- arg
);
1692 printf_filtered (_("\
1693 Setting environment variable \"%s\" to null value.\n"),
1695 set_in_environ (inferior_environ
, var
, "");
1698 set_in_environ (inferior_environ
, var
, val
);
1703 unset_environment_command (char *var
, int from_tty
)
1707 /* If there is no argument, delete all environment variables.
1708 Ask for confirmation if reading from the terminal. */
1709 if (!from_tty
|| query (_("Delete all environment variables? ")))
1711 free_environ (inferior_environ
);
1712 inferior_environ
= make_environ ();
1716 unset_in_environ (inferior_environ
, var
);
1719 /* Handle the execution path (PATH variable) */
1721 static const char path_var_name
[] = "PATH";
1724 path_info (char *args
, int from_tty
)
1726 puts_filtered ("Executable and object file path: ");
1727 puts_filtered (get_in_environ (inferior_environ
, path_var_name
));
1728 puts_filtered ("\n");
1731 /* Add zero or more directories to the front of the execution path. */
1734 path_command (char *dirname
, int from_tty
)
1739 env
= get_in_environ (inferior_environ
, path_var_name
);
1740 /* Can be null if path is not set */
1743 exec_path
= xstrdup (env
);
1744 mod_path (dirname
, &exec_path
);
1745 set_in_environ (inferior_environ
, path_var_name
, exec_path
);
1748 path_info ((char *) NULL
, from_tty
);
1752 /* Print out the machine register regnum. If regnum is -1, print all
1753 registers (print_all == 1) or all non-float and non-vector
1754 registers (print_all == 0).
1756 For most machines, having all_registers_info() print the
1757 register(s) one per line is good enough. If a different format is
1758 required, (eg, for MIPS or Pyramid 90x, which both have lots of
1759 regs), or there is an existing convention for showing all the
1760 registers, define the architecture method PRINT_REGISTERS_INFO to
1761 provide that format. */
1764 default_print_registers_info (struct gdbarch
*gdbarch
,
1765 struct ui_file
*file
,
1766 struct frame_info
*frame
,
1767 int regnum
, int print_all
)
1770 const int numregs
= gdbarch_num_regs (gdbarch
)
1771 + gdbarch_num_pseudo_regs (gdbarch
);
1772 gdb_byte buffer
[MAX_REGISTER_SIZE
];
1774 for (i
= 0; i
< numregs
; i
++)
1776 /* Decide between printing all regs, non-float / vector regs, or
1782 if (!gdbarch_register_reggroup_p (gdbarch
, i
, all_reggroup
))
1787 if (!gdbarch_register_reggroup_p (gdbarch
, i
, general_reggroup
))
1797 /* If the register name is empty, it is undefined for this
1798 processor, so don't display anything. */
1799 if (gdbarch_register_name (gdbarch
, i
) == NULL
1800 || *(gdbarch_register_name (gdbarch
, i
)) == '\0')
1803 fputs_filtered (gdbarch_register_name (gdbarch
, i
), file
);
1804 print_spaces_filtered (15 - strlen (gdbarch_register_name
1805 (gdbarch
, i
)), file
);
1807 /* Get the data in raw format. */
1808 if (! frame_register_read (frame
, i
, buffer
))
1810 fprintf_filtered (file
, "*value not available*\n");
1814 /* If virtual format is floating, print it that way, and in raw
1816 if (TYPE_CODE (register_type (gdbarch
, i
)) == TYPE_CODE_FLT
1817 || TYPE_CODE (register_type (gdbarch
, i
)) == TYPE_CODE_DECFLOAT
)
1820 struct value_print_options opts
;
1822 get_user_print_options (&opts
);
1824 val_print (register_type (gdbarch
, i
), buffer
, 0, 0,
1825 file
, 0, &opts
, current_language
);
1827 fprintf_filtered (file
, "\t(raw 0x");
1828 for (j
= 0; j
< register_size (gdbarch
, i
); j
++)
1831 if (gdbarch_byte_order (gdbarch
) == BFD_ENDIAN_BIG
)
1834 idx
= register_size (gdbarch
, i
) - 1 - j
;
1835 fprintf_filtered (file
, "%02x", (unsigned char) buffer
[idx
]);
1837 fprintf_filtered (file
, ")");
1841 struct value_print_options opts
;
1843 /* Print the register in hex. */
1844 get_formatted_print_options (&opts
, 'x');
1846 val_print (register_type (gdbarch
, i
), buffer
, 0, 0,
1849 /* If not a vector register, print it also according to its
1851 if (TYPE_VECTOR (register_type (gdbarch
, i
)) == 0)
1853 get_user_print_options (&opts
);
1855 fprintf_filtered (file
, "\t");
1856 val_print (register_type (gdbarch
, i
), buffer
, 0, 0,
1857 file
, 0, &opts
, current_language
);
1861 fprintf_filtered (file
, "\n");
1866 registers_info (char *addr_exp
, int fpregs
)
1868 struct frame_info
*frame
;
1869 struct gdbarch
*gdbarch
;
1870 int regnum
, numregs
;
1873 if (!target_has_registers
)
1874 error (_("The program has no registers now."));
1875 frame
= get_selected_frame (NULL
);
1876 gdbarch
= get_frame_arch (frame
);
1880 gdbarch_print_registers_info (gdbarch
, gdb_stdout
,
1885 while (*addr_exp
!= '\0')
1890 /* Keep skipping leading white space. */
1891 if (isspace ((*addr_exp
)))
1897 /* Discard any leading ``$''. Check that there is something
1898 resembling a register following it. */
1899 if (addr_exp
[0] == '$')
1901 if (isspace ((*addr_exp
)) || (*addr_exp
) == '\0')
1902 error (_("Missing register name"));
1904 /* Find the start/end of this register name/num/group. */
1906 while ((*addr_exp
) != '\0' && !isspace ((*addr_exp
)))
1910 /* Figure out what we've found and display it. */
1912 /* A register name? */
1914 int regnum
= user_reg_map_name_to_regnum (gdbarch
, start
, end
- start
);
1917 /* User registers lie completely outside of the range of
1918 normal registers. Catch them early so that the target
1920 if (regnum
>= gdbarch_num_regs (gdbarch
)
1921 + gdbarch_num_pseudo_regs (gdbarch
))
1923 struct value_print_options opts
;
1924 struct value
*val
= value_of_user_reg (regnum
, frame
);
1926 printf_filtered ("%s: ", start
);
1927 get_formatted_print_options (&opts
, 'x');
1928 print_scalar_formatted (value_contents (val
),
1929 check_typedef (value_type (val
)),
1930 &opts
, 0, gdb_stdout
);
1931 printf_filtered ("\n");
1934 gdbarch_print_registers_info (gdbarch
, gdb_stdout
,
1935 frame
, regnum
, fpregs
);
1940 /* A register group? */
1942 struct reggroup
*group
;
1943 for (group
= reggroup_next (gdbarch
, NULL
);
1945 group
= reggroup_next (gdbarch
, group
))
1947 /* Don't bother with a length check. Should the user
1948 enter a short register group name, go with the first
1949 group that matches. */
1950 if (strncmp (start
, reggroup_name (group
), end
- start
) == 0)
1957 regnum
< gdbarch_num_regs (gdbarch
)
1958 + gdbarch_num_pseudo_regs (gdbarch
);
1961 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, group
))
1962 gdbarch_print_registers_info (gdbarch
,
1970 /* Nothing matched. */
1971 error (_("Invalid register `%.*s'"), (int) (end
- start
), start
);
1976 all_registers_info (char *addr_exp
, int from_tty
)
1978 registers_info (addr_exp
, 1);
1982 nofp_registers_info (char *addr_exp
, int from_tty
)
1984 registers_info (addr_exp
, 0);
1988 print_vector_info (struct gdbarch
*gdbarch
, struct ui_file
*file
,
1989 struct frame_info
*frame
, const char *args
)
1991 if (gdbarch_print_vector_info_p (gdbarch
))
1992 gdbarch_print_vector_info (gdbarch
, file
, frame
, args
);
1996 int printed_something
= 0;
1999 regnum
< gdbarch_num_regs (gdbarch
)
2000 + gdbarch_num_pseudo_regs (gdbarch
);
2003 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, vector_reggroup
))
2005 printed_something
= 1;
2006 gdbarch_print_registers_info (gdbarch
, file
, frame
, regnum
, 1);
2009 if (!printed_something
)
2010 fprintf_filtered (file
, "No vector information\n");
2015 vector_info (char *args
, int from_tty
)
2017 if (!target_has_registers
)
2018 error (_("The program has no registers now."));
2020 print_vector_info (current_gdbarch
, gdb_stdout
,
2021 get_selected_frame (NULL
), args
);
2025 /* Used in `attach&' command. ARG is a point to an integer
2026 representing a process id. Proceed threads of this process iff
2027 they stopped due to debugger request, and when they did, they
2028 reported a clean stop (TARGET_SIGNAL_0). Do not proceed threads
2029 that have been explicitly been told to stop. */
2032 proceed_after_attach_callback (struct thread_info
*thread
,
2035 int pid
= * (int *) arg
;
2037 if (ptid_get_pid (thread
->ptid
) == pid
2038 && !is_exited (thread
->ptid
)
2039 && !is_executing (thread
->ptid
)
2040 && !thread
->stop_requested
2041 && thread
->stop_signal
== TARGET_SIGNAL_0
)
2043 switch_to_thread (thread
->ptid
);
2044 clear_proceed_status ();
2045 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 0);
2052 proceed_after_attach (int pid
)
2054 /* Don't error out if the current thread is running, because
2055 there may be other stopped threads. */
2056 struct cleanup
*old_chain
;
2058 /* Backup current thread and selected frame. */
2059 old_chain
= make_cleanup_restore_current_thread ();
2061 iterate_over_threads (proceed_after_attach_callback
, &pid
);
2063 /* Restore selected ptid. */
2064 do_cleanups (old_chain
);
2069 * Should save/restore the tty state since it might be that the
2070 * program to be debugged was started on this tty and it wants
2071 * the tty in some state other than what we want. If it's running
2072 * on another terminal or without a terminal, then saving and
2073 * restoring the tty state is a harmless no-op.
2074 * This only needs to be done if we are attaching to a process.
2079 takes a program started up outside of gdb and ``attaches'' to it.
2080 This stops it cold in its tracks and allows us to start debugging it.
2081 and wait for the trace-trap that results from attaching. */
2084 attach_command_post_wait (char *args
, int from_tty
, int async_exec
)
2087 char *full_exec_path
= NULL
;
2088 struct inferior
*inferior
;
2090 inferior
= current_inferior ();
2091 inferior
->stop_soon
= NO_STOP_QUIETLY
;
2093 /* If no exec file is yet known, try to determine it from the
2095 exec_file
= (char *) get_exec_file (0);
2098 exec_file
= target_pid_to_exec_file (PIDGET (inferior_ptid
));
2101 /* It's possible we don't have a full path, but rather just a
2102 filename. Some targets, such as HP-UX, don't provide the
2105 Attempt to qualify the filename against the source path.
2106 (If that fails, we'll just fall back on the original
2107 filename. Not much more we can do...)
2109 if (!source_full_path_of (exec_file
, &full_exec_path
))
2110 full_exec_path
= savestring (exec_file
, strlen (exec_file
));
2112 exec_file_attach (full_exec_path
, from_tty
);
2113 symbol_file_add_main (full_exec_path
, from_tty
);
2118 reopen_exec_file ();
2122 /* Take any necessary post-attaching actions for this platform. */
2123 target_post_attach (PIDGET (inferior_ptid
));
2125 post_create_inferior (¤t_target
, from_tty
);
2127 /* Install inferior's terminal modes. */
2128 target_terminal_inferior ();
2132 /* The user requested an `attach&', so be sure to leave threads
2133 that didn't get a signal running. */
2135 /* Immediatelly resume all suspended threads of this inferior,
2136 and this inferior only. This should have no effect on
2137 already running threads. If a thread has been stopped with a
2138 signal, leave it be. */
2140 proceed_after_attach (inferior
->pid
);
2143 if (inferior_thread ()->stop_signal
== TARGET_SIGNAL_0
)
2145 clear_proceed_status ();
2146 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 0);
2152 /* The user requested a plain `attach', so be sure to leave
2153 the inferior stopped. */
2155 if (target_can_async_p ())
2156 async_enable_stdin ();
2158 /* At least the current thread is already stopped. */
2160 /* In all-stop, by definition, all threads have to be already
2161 stopped at this point. In non-stop, however, although the
2162 selected thread is stopped, others may still be executing.
2163 Be sure to explicitly stop all threads of the process. This
2164 should have no effect on already stopped threads. */
2166 target_stop (pid_to_ptid (inferior
->pid
));
2168 /* Tell the user/frontend where we're stopped. */
2170 if (deprecated_attach_hook
)
2171 deprecated_attach_hook ();
2175 struct attach_command_continuation_args
2183 attach_command_continuation (void *args
)
2185 struct attach_command_continuation_args
*a
= args
;
2186 attach_command_post_wait (a
->args
, a
->from_tty
, a
->async_exec
);
2190 attach_command_continuation_free_args (void *args
)
2192 struct attach_command_continuation_args
*a
= args
;
2198 attach_command (char *args
, int from_tty
)
2201 char *full_exec_path
= NULL
;
2203 struct cleanup
*back_to
= make_cleanup (null_cleanup
, NULL
);
2205 dont_repeat (); /* Not for the faint of heart */
2207 if (target_supports_multi_process ())
2208 /* Don't complain if we can be attached to multiple processes. */
2210 else if (target_has_execution
)
2212 if (query (_("A program is being debugged already. Kill it? ")))
2215 error (_("Not killed."));
2218 /* Clean up any leftovers from other runs. Some other things from
2219 this function should probably be moved into target_pre_inferior. */
2220 target_pre_inferior (from_tty
);
2222 if (non_stop
&& !target_supports_non_stop ())
2223 error (_("Cannot attach to this target in non-stop mode"));
2227 async_exec
= strip_bg_char (&args
);
2229 /* If we get a request for running in the bg but the target
2230 doesn't support it, error out. */
2231 if (async_exec
&& !target_can_async_p ())
2232 error (_("Asynchronous execution not supported on this target."));
2235 /* If we don't get a request of running in the bg, then we need
2236 to simulate synchronous (fg) execution. */
2237 if (!async_exec
&& target_can_async_p ())
2239 /* Simulate synchronous execution */
2240 async_disable_stdin ();
2241 make_cleanup ((make_cleanup_ftype
*)async_enable_stdin
, NULL
);
2244 target_attach (args
, from_tty
);
2246 /* Set up the "saved terminal modes" of the inferior
2247 based on what modes we are starting it with. */
2248 target_terminal_init ();
2250 /* Set up execution context to know that we should return from
2251 wait_for_inferior as soon as the target reports a stop. */
2252 init_wait_for_inferior ();
2253 clear_proceed_status ();
2257 /* If we find that the current thread isn't stopped, explicitly
2258 do so now, because we're going to install breakpoints and
2262 /* The user requested an `attach&'; stop just one thread. */
2263 target_stop (inferior_ptid
);
2265 /* The user requested an `attach', so stop all threads of this
2267 target_stop (pid_to_ptid (ptid_get_pid (inferior_ptid
)));
2270 /* Some system don't generate traps when attaching to inferior.
2271 E.g. Mach 3 or GNU hurd. */
2272 if (!target_attach_no_wait
)
2274 struct inferior
*inferior
= current_inferior ();
2276 /* Careful here. See comments in inferior.h. Basically some
2277 OSes don't ignore SIGSTOPs on continue requests anymore. We
2278 need a way for handle_inferior_event to reset the stop_signal
2279 variable after an attach, and this is what
2280 STOP_QUIETLY_NO_SIGSTOP is for. */
2281 inferior
->stop_soon
= STOP_QUIETLY_NO_SIGSTOP
;
2283 if (target_can_async_p ())
2285 /* sync_execution mode. Wait for stop. */
2286 struct attach_command_continuation_args
*a
;
2288 a
= xmalloc (sizeof (*a
));
2289 a
->args
= xstrdup (args
);
2290 a
->from_tty
= from_tty
;
2291 a
->async_exec
= async_exec
;
2292 add_inferior_continuation (attach_command_continuation
, a
,
2293 attach_command_continuation_free_args
);
2294 discard_cleanups (back_to
);
2298 wait_for_inferior (0);
2301 attach_command_post_wait (args
, from_tty
, async_exec
);
2302 discard_cleanups (back_to
);
2305 /* We had just found out that the target was already attached to an
2306 inferior. PTID points at a thread of this new inferior, that is
2307 the most likely to be stopped right now, but not necessarily so.
2308 The new inferior is assumed to be already added to the inferior
2309 list at this point. If LEAVE_RUNNING, then leave the threads of
2310 this inferior running, except those we've explicitly seen reported
2314 notice_new_inferior (ptid_t ptid
, int leave_running
, int from_tty
)
2316 struct cleanup
* old_chain
;
2319 old_chain
= make_cleanup (null_cleanup
, NULL
);
2321 /* If in non-stop, leave threads as running as they were. If
2322 they're stopped for some reason other than us telling it to, the
2323 target reports a signal != TARGET_SIGNAL_0. We don't try to
2324 resume threads with such a stop signal. */
2325 async_exec
= non_stop
;
2327 if (!ptid_equal (inferior_ptid
, null_ptid
))
2328 make_cleanup_restore_current_thread ();
2330 switch_to_thread (ptid
);
2332 /* When we "notice" a new inferior we need to do all the things we
2333 would normally do if we had just attached to it. */
2335 if (is_executing (inferior_ptid
))
2337 struct inferior
*inferior
= current_inferior ();
2339 /* We're going to install breakpoints, and poke at memory,
2340 ensure that the inferior is stopped for a moment while we do
2342 target_stop (inferior_ptid
);
2344 inferior
->stop_soon
= STOP_QUIETLY_REMOTE
;
2346 /* Wait for stop before proceeding. */
2347 if (target_can_async_p ())
2349 struct attach_command_continuation_args
*a
;
2351 a
= xmalloc (sizeof (*a
));
2352 a
->args
= xstrdup ("");
2353 a
->from_tty
= from_tty
;
2354 a
->async_exec
= async_exec
;
2355 add_inferior_continuation (attach_command_continuation
, a
,
2356 attach_command_continuation_free_args
);
2358 do_cleanups (old_chain
);
2362 wait_for_inferior (0);
2365 async_exec
= leave_running
;
2366 attach_command_post_wait ("" /* args */, from_tty
, async_exec
);
2368 do_cleanups (old_chain
);
2373 * takes a program previously attached to and detaches it.
2374 * The program resumes execution and will no longer stop
2375 * on signals, etc. We better not have left any breakpoints
2376 * in the program or it'll die when it hits one. For this
2377 * to work, it may be necessary for the process to have been
2378 * previously attached. It *might* work if the program was
2379 * started via the normal ptrace (PTRACE_TRACEME).
2383 detach_command (char *args
, int from_tty
)
2385 dont_repeat (); /* Not for the faint of heart. */
2386 target_detach (args
, from_tty
);
2388 /* If the solist is global across inferiors, don't clear it when we
2389 detach from a single inferior. */
2390 if (!gdbarch_has_global_solist (target_gdbarch
))
2391 no_shared_libraries (NULL
, from_tty
);
2393 /* If the current target interface claims there's still execution,
2394 then don't mess with threads of other processes. */
2395 if (!target_has_execution
)
2396 init_thread_list ();
2398 if (deprecated_detach_hook
)
2399 deprecated_detach_hook ();
2402 /* Disconnect from the current target without resuming it (leaving it
2403 waiting for a debugger).
2405 We'd better not have left any breakpoints in the program or the
2406 next debugger will get confused. Currently only supported for some
2407 remote targets, since the normal attach mechanisms don't work on
2408 stopped processes on some native platforms (e.g. GNU/Linux). */
2411 disconnect_command (char *args
, int from_tty
)
2413 dont_repeat (); /* Not for the faint of heart */
2414 target_disconnect (args
, from_tty
);
2415 no_shared_libraries (NULL
, from_tty
);
2416 init_thread_list ();
2417 if (deprecated_detach_hook
)
2418 deprecated_detach_hook ();
2422 interrupt_target_1 (int all_threads
)
2426 ptid
= minus_one_ptid
;
2428 ptid
= inferior_ptid
;
2431 /* Tag the thread as having been explicitly requested to stop, so
2432 other parts of gdb know not to resume this thread automatically,
2433 if it was stopped due to an internal event. Limit this to
2434 non-stop mode, as when debugging a multi-threaded application in
2435 all-stop mode, we will only get one stop event --- it's undefined
2436 which thread will report the event. */
2438 set_stop_requested (ptid
, 1);
2441 /* Stop the execution of the target while running in async mode, in
2442 the backgound. In all-stop, stop the whole process. In non-stop
2443 mode, stop the current thread only by default, or stop all threads
2444 if the `-a' switch is used. */
2446 /* interrupt [-a] */
2448 interrupt_target_command (char *args
, int from_tty
)
2450 if (target_can_async_p ())
2452 int all_threads
= 0;
2454 dont_repeat (); /* Not for the faint of heart */
2457 && strncmp (args
, "-a", sizeof ("-a") - 1) == 0)
2460 if (!non_stop
&& all_threads
)
2461 error (_("-a is meaningless in all-stop mode."));
2463 interrupt_target_1 (all_threads
);
2468 print_float_info (struct gdbarch
*gdbarch
, struct ui_file
*file
,
2469 struct frame_info
*frame
, const char *args
)
2471 if (gdbarch_print_float_info_p (gdbarch
))
2472 gdbarch_print_float_info (gdbarch
, file
, frame
, args
);
2476 int printed_something
= 0;
2479 regnum
< gdbarch_num_regs (gdbarch
)
2480 + gdbarch_num_pseudo_regs (gdbarch
);
2483 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, float_reggroup
))
2485 printed_something
= 1;
2486 gdbarch_print_registers_info (gdbarch
, file
, frame
, regnum
, 1);
2489 if (!printed_something
)
2490 fprintf_filtered (file
, "\
2491 No floating-point info available for this processor.\n");
2496 float_info (char *args
, int from_tty
)
2498 if (!target_has_registers
)
2499 error (_("The program has no registers now."));
2501 print_float_info (current_gdbarch
, gdb_stdout
,
2502 get_selected_frame (NULL
), args
);
2506 unset_command (char *args
, int from_tty
)
2508 printf_filtered (_("\
2509 \"unset\" must be followed by the name of an unset subcommand.\n"));
2510 help_list (unsetlist
, "unset ", -1, gdb_stdout
);
2514 _initialize_infcmd (void)
2516 struct cmd_list_element
*c
= NULL
;
2518 /* add the filename of the terminal connected to inferior I/O */
2519 add_setshow_filename_cmd ("inferior-tty", class_run
,
2520 &inferior_io_terminal
, _("\
2521 Set terminal for future runs of program being debugged."), _("\
2522 Show terminal for future runs of program being debugged."), _("\
2523 Usage: set inferior-tty /dev/pts/1"), NULL
, NULL
, &setlist
, &showlist
);
2524 add_com_alias ("tty", "set inferior-tty", class_alias
, 0);
2526 add_setshow_optional_filename_cmd ("args", class_run
,
2527 &inferior_args
, _("\
2528 Set argument list to give program being debugged when it is started."), _("\
2529 Show argument list to give program being debugged when it is started."), _("\
2530 Follow this command with any number of args, to be passed to the program."),
2533 &setlist
, &showlist
);
2535 c
= add_cmd ("environment", no_class
, environment_info
, _("\
2536 The environment to give the program, or one variable's value.\n\
2537 With an argument VAR, prints the value of environment variable VAR to\n\
2538 give the program being debugged. With no arguments, prints the entire\n\
2539 environment to be given to the program."), &showlist
);
2540 set_cmd_completer (c
, noop_completer
);
2542 add_prefix_cmd ("unset", no_class
, unset_command
,
2543 _("Complement to certain \"set\" commands."),
2544 &unsetlist
, "unset ", 0, &cmdlist
);
2546 c
= add_cmd ("environment", class_run
, unset_environment_command
, _("\
2547 Cancel environment variable VAR for the program.\n\
2548 This does not affect the program until the next \"run\" command."),
2550 set_cmd_completer (c
, noop_completer
);
2552 c
= add_cmd ("environment", class_run
, set_environment_command
, _("\
2553 Set environment variable value to give the program.\n\
2554 Arguments are VAR VALUE where VAR is variable name and VALUE is value.\n\
2555 VALUES of environment variables are uninterpreted strings.\n\
2556 This does not affect the program until the next \"run\" command."),
2558 set_cmd_completer (c
, noop_completer
);
2560 c
= add_com ("path", class_files
, path_command
, _("\
2561 Add directory DIR(s) to beginning of search path for object files.\n\
2562 $cwd in the path means the current working directory.\n\
2563 This path is equivalent to the $PATH shell variable. It is a list of\n\
2564 directories, separated by colons. These directories are searched to find\n\
2565 fully linked executable files and separately compiled object files as needed."));
2566 set_cmd_completer (c
, filename_completer
);
2568 c
= add_cmd ("paths", no_class
, path_info
, _("\
2569 Current search path for finding object files.\n\
2570 $cwd in the path means the current working directory.\n\
2571 This path is equivalent to the $PATH shell variable. It is a list of\n\
2572 directories, separated by colons. These directories are searched to find\n\
2573 fully linked executable files and separately compiled object files as needed."),
2575 set_cmd_completer (c
, noop_completer
);
2577 add_com ("attach", class_run
, attach_command
, _("\
2578 Attach to a process or file outside of GDB.\n\
2579 This command attaches to another target, of the same type as your last\n\
2580 \"target\" command (\"info files\" will show your target stack).\n\
2581 The command may take as argument a process id or a device file.\n\
2582 For a process id, you must have permission to send the process a signal,\n\
2583 and it must have the same effective uid as the debugger.\n\
2584 When using \"attach\" with a process id, the debugger finds the\n\
2585 program running in the process, looking first in the current working\n\
2586 directory, or (if not found there) using the source file search path\n\
2587 (see the \"directory\" command). You can also use the \"file\" command\n\
2588 to specify the program, and to load its symbol table."));
2590 add_prefix_cmd ("detach", class_run
, detach_command
, _("\
2591 Detach a process or file previously attached.\n\
2592 If a process, it is no longer traced, and it continues its execution. If\n\
2593 you were debugging a file, the file is closed and gdb no longer accesses it."),
2594 &detachlist
, "detach ", 0, &cmdlist
);
2596 add_com ("disconnect", class_run
, disconnect_command
, _("\
2597 Disconnect from a target.\n\
2598 The target will wait for another debugger to connect. Not available for\n\
2601 add_com ("signal", class_run
, signal_command
, _("\
2602 Continue program giving it signal specified by the argument.\n\
2603 An argument of \"0\" means continue program without giving it a signal."));
2605 add_com ("stepi", class_run
, stepi_command
, _("\
2606 Step one instruction exactly.\n\
2607 Argument N means do this N times (or till program stops for another reason)."));
2608 add_com_alias ("si", "stepi", class_alias
, 0);
2610 add_com ("nexti", class_run
, nexti_command
, _("\
2611 Step one instruction, but proceed through subroutine calls.\n\
2612 Argument N means do this N times (or till program stops for another reason)."));
2613 add_com_alias ("ni", "nexti", class_alias
, 0);
2615 add_com ("finish", class_run
, finish_command
, _("\
2616 Execute until selected stack frame returns.\n\
2617 Upon return, the value returned is printed and put in the value history."));
2618 add_com_alias ("fin", "finish", class_run
, 1);
2620 add_com ("next", class_run
, next_command
, _("\
2621 Step program, proceeding through subroutine calls.\n\
2622 Like the \"step\" command as long as subroutine calls do not happen;\n\
2623 when they do, the call is treated as one instruction.\n\
2624 Argument N means do this N times (or till program stops for another reason)."));
2625 add_com_alias ("n", "next", class_run
, 1);
2627 add_com_alias ("S", "next", class_run
, 1);
2629 add_com ("step", class_run
, step_command
, _("\
2630 Step program until it reaches a different source line.\n\
2631 Argument N means do this N times (or till program stops for another reason)."));
2632 add_com_alias ("s", "step", class_run
, 1);
2634 c
= add_com ("until", class_run
, until_command
, _("\
2635 Execute until the program reaches a source line greater than the current\n\
2636 or a specified location (same args as break command) within the current frame."));
2637 set_cmd_completer (c
, location_completer
);
2638 add_com_alias ("u", "until", class_run
, 1);
2640 c
= add_com ("advance", class_run
, advance_command
, _("\
2641 Continue the program up to the given location (same form as args for break command).\n\
2642 Execution will also stop upon exit from the current stack frame."));
2643 set_cmd_completer (c
, location_completer
);
2645 c
= add_com ("jump", class_run
, jump_command
, _("\
2646 Continue program being debugged at specified line or address.\n\
2647 Give as argument either LINENUM or *ADDR, where ADDR is an expression\n\
2648 for an address to start at."));
2649 set_cmd_completer (c
, location_completer
);
2653 c
= add_com ("go", class_run
, go_command
, _("\
2654 Usage: go <location>\n\
2655 Continue program being debugged, stopping at specified line or \n\
2657 Give as argument either LINENUM or *ADDR, where ADDR is an \n\
2658 expression for an address to start at.\n\
2659 This command is a combination of tbreak and jump."));
2660 set_cmd_completer (c
, location_completer
);
2664 add_com_alias ("g", "go", class_run
, 1);
2666 c
= add_com ("continue", class_run
, continue_command
, _("\
2667 Continue program being debugged, after signal or breakpoint.\n\
2668 If proceeding from breakpoint, a number N may be used as an argument,\n\
2669 which means to set the ignore count of that breakpoint to N - 1 (so that\n\
2670 the breakpoint won't break until the Nth time it is reached).\n\
2672 If non-stop mode is enabled, continue only the current thread,\n\
2673 otherwise all the threads in the program are continued. To \n\
2674 continue all stopped threads in non-stop mode, use the -a option.\n\
2675 Specifying -a and an ignore count simultaneously is an error."));
2676 add_com_alias ("c", "cont", class_run
, 1);
2677 add_com_alias ("fg", "cont", class_run
, 1);
2679 c
= add_com ("run", class_run
, run_command
, _("\
2680 Start debugged program. You may specify arguments to give it.\n\
2681 Args may include \"*\", or \"[...]\"; they are expanded using \"sh\".\n\
2682 Input and output redirection with \">\", \"<\", or \">>\" are also allowed.\n\n\
2683 With no arguments, uses arguments last specified (with \"run\" or \"set args\").\n\
2684 To cancel previous arguments and run with no arguments,\n\
2685 use \"set args\" without arguments."));
2686 set_cmd_completer (c
, filename_completer
);
2687 add_com_alias ("r", "run", class_run
, 1);
2689 add_com ("R", class_run
, run_no_args_command
,
2690 _("Start debugged program with no arguments."));
2692 c
= add_com ("start", class_run
, start_command
, _("\
2693 Run the debugged program until the beginning of the main procedure.\n\
2694 You may specify arguments to give to your program, just as with the\n\
2695 \"run\" command."));
2696 set_cmd_completer (c
, filename_completer
);
2698 c
= add_com ("interrupt", class_run
, interrupt_target_command
,
2699 _("Interrupt the execution of the debugged program.\n\
2700 If non-stop mode is enabled, interrupt only the current thread,\n\
2701 otherwise all the threads in the program are stopped. To \n\
2702 interrupt all running threads in non-stop mode, use the -a option."));
2704 add_info ("registers", nofp_registers_info
, _("\
2705 List of integer registers and their contents, for selected stack frame.\n\
2706 Register name as argument means describe only that register."));
2707 add_info_alias ("r", "registers", 1);
2710 add_com ("lr", class_info
, nofp_registers_info
, _("\
2711 List of integer registers and their contents, for selected stack frame.\n\
2712 Register name as argument means describe only that register."));
2713 add_info ("all-registers", all_registers_info
, _("\
2714 List of all registers and their contents, for selected stack frame.\n\
2715 Register name as argument means describe only that register."));
2717 add_info ("program", program_info
,
2718 _("Execution status of the program."));
2720 add_info ("float", float_info
,
2721 _("Print the status of the floating point unit\n"));
2723 add_info ("vector", vector_info
,
2724 _("Print the status of the vector unit\n"));
2726 inferior_environ
= make_environ ();
2727 init_environ (inferior_environ
);