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
= xstrdup (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
= construct_inferior_arguments (inferior_argc
, inferior_argv
);
198 old
= set_inferior_args (n
);
202 if (inferior_args
== NULL
)
203 inferior_args
= xstrdup ("");
205 return inferior_args
;
209 set_inferior_args (char *newargs
)
211 char *saved_args
= inferior_args
;
213 inferior_args
= newargs
;
221 set_inferior_args_vector (int argc
, char **argv
)
223 inferior_argc
= argc
;
224 inferior_argv
= argv
;
227 /* Notice when `set args' is run. */
229 notice_args_set (char *args
, int from_tty
, struct cmd_list_element
*c
)
235 /* Notice when `show args' is run. */
237 notice_args_read (struct ui_file
*file
, int from_tty
,
238 struct cmd_list_element
*c
, const char *value
)
240 /* Note that we ignore the passed-in value in favor of computing it
242 deprecated_show_value_hack (file
, from_tty
, c
, get_inferior_args ());
246 /* Compute command-line string given argument vector. This does the
247 same shell processing as fork_inferior. */
249 construct_inferior_arguments (int argc
, char **argv
)
253 if (STARTUP_WITH_SHELL
)
255 /* This holds all the characters considered special to the
256 typical Unix shells. We include `^' because the SunOS
257 /bin/sh treats it as a synonym for `|'. */
258 char *special
= "\"!#$&*()\\|[]{}<>?'\"`~^; \t\n";
263 /* We over-compute the size. It shouldn't matter. */
264 for (i
= 0; i
< argc
; ++i
)
265 length
+= 3 * strlen (argv
[i
]) + 1 + 2 * (argv
[i
][0] == '\0');
267 result
= (char *) xmalloc (length
);
270 for (i
= 0; i
< argc
; ++i
)
275 /* Need to handle empty arguments specially. */
276 if (argv
[i
][0] == '\0')
283 for (cp
= argv
[i
]; *cp
; ++cp
)
287 /* A newline cannot be quoted with a backslash (it
288 just disappears), only by putting it inside
296 if (strchr (special
, *cp
) != NULL
)
307 /* In this case we can't handle arguments that contain spaces,
308 tabs, or newlines -- see breakup_args(). */
312 for (i
= 0; i
< argc
; ++i
)
314 char *cp
= strchr (argv
[i
], ' ');
316 cp
= strchr (argv
[i
], '\t');
318 cp
= strchr (argv
[i
], '\n');
320 error (_("can't handle command-line argument containing whitespace"));
321 length
+= strlen (argv
[i
]) + 1;
324 result
= (char *) xmalloc (length
);
326 for (i
= 0; i
< argc
; ++i
)
329 strcat (result
, " ");
330 strcat (result
, argv
[i
]);
338 /* This function detects whether or not a '&' character (indicating
339 background execution) has been added as *the last* of the arguments ARGS
340 of a command. If it has, it removes it and returns 1. Otherwise it
341 does nothing and returns 0. */
343 strip_bg_char (char **args
)
347 p
= strchr (*args
, '&');
351 if (p
== (*args
+ strlen (*args
) - 1))
353 if (strlen (*args
) > 1)
357 while (*p
== ' ' || *p
== '\t');
369 tty_command (char *file
, int from_tty
)
372 error_no_arg (_("terminal name for running target process"));
374 set_inferior_io_terminal (file
);
377 /* Common actions to take after creating any sort of inferior, by any
378 means (running, attaching, connecting, et cetera). The target
379 should be stopped. */
382 post_create_inferior (struct target_ops
*target
, int from_tty
)
384 /* Be sure we own the terminal in case write operations are performed. */
385 target_terminal_ours ();
387 /* If the target hasn't taken care of this already, do it now.
388 Targets which need to access registers during to_open,
389 to_create_inferior, or to_attach should do it earlier; but many
391 target_find_description ();
393 /* Now that we know the register layout, retrieve current PC. */
394 stop_pc
= regcache_read_pc (get_current_regcache ());
396 /* If the solist is global across processes, there's no need to
398 if (exec_bfd
&& !gdbarch_has_global_solist (target_gdbarch
))
400 /* Sometimes the platform-specific hook loads initial shared
401 libraries, and sometimes it doesn't. Try to do so first, so
402 that we can add them with the correct value for FROM_TTY.
403 If we made all the inferior hook methods consistent,
404 this call could be removed. */
406 SOLIB_ADD (NULL
, from_tty
, target
, auto_solib_add
);
408 solib_add (NULL
, from_tty
, target
, auto_solib_add
);
414 /* Create the hooks to handle shared library load and unload
416 #ifdef SOLIB_CREATE_INFERIOR_HOOK
417 SOLIB_CREATE_INFERIOR_HOOK (PIDGET (inferior_ptid
));
419 solib_create_inferior_hook ();
423 /* If the user sets watchpoints before execution having started,
424 then she gets software watchpoints, because GDB can't know which
425 target will end up being pushed, or if it supports hardware
426 watchpoints or not. breakpoint_re_set takes care of promoting
427 watchpoints to hardware watchpoints if possible, however, if this
428 new inferior doesn't load shared libraries or we don't pull in
429 symbols from any other source on this target/arch,
430 breakpoint_re_set is never called. Call it now so that software
431 watchpoints get a chance to be promoted to hardware watchpoints
432 if the now pushed target supports hardware watchpoints. */
433 breakpoint_re_set ();
435 observer_notify_inferior_created (target
, from_tty
);
438 /* Kill the inferior if already running. This function is designed
439 to be called when we are about to start the execution of the program
440 from the beginning. Ask the user to confirm that he wants to restart
441 the program being debugged when FROM_TTY is non-null. */
444 kill_if_already_running (int from_tty
)
446 if (! ptid_equal (inferior_ptid
, null_ptid
) && target_has_execution
)
448 /* Bail out before killing the program if we will not be able to
450 target_require_runnable ();
453 && !query (_("The program being debugged has been started already.\n\
454 Start it from the beginning? ")))
455 error (_("Program not restarted."));
460 /* Implement the "run" command. If TBREAK_AT_MAIN is set, then insert
461 a temporary breakpoint at the begining of the main program before
462 running the program. */
465 run_command_1 (char *args
, int from_tty
, int tbreak_at_main
)
468 struct cleanup
*old_chain
;
473 kill_if_already_running (from_tty
);
475 init_wait_for_inferior ();
476 clear_breakpoint_hit_counts ();
478 /* Clean up any leftovers from other runs. Some other things from
479 this function should probably be moved into target_pre_inferior. */
480 target_pre_inferior (from_tty
);
482 /* The comment here used to read, "The exec file is re-read every
483 time we do a generic_mourn_inferior, so we just have to worry
484 about the symbol file." The `generic_mourn_inferior' function
485 gets called whenever the program exits. However, suppose the
486 program exits, and *then* the executable file changes? We need
487 to check again here. Since reopen_exec_file doesn't do anything
488 if the timestamp hasn't changed, I don't see the harm. */
492 /* Insert the temporary breakpoint if a location was specified. */
494 tbreak_command (main_name (), 0);
496 exec_file
= (char *) get_exec_file (0);
498 if (non_stop
&& !target_supports_non_stop ())
499 error (_("The target does not support running in non-stop mode."));
501 /* We keep symbols from add-symbol-file, on the grounds that the
502 user might want to add some symbols before running the program
503 (right?). But sometimes (dynamic loading where the user manually
504 introduces the new symbols with add-symbol-file), the code which
505 the symbols describe does not persist between runs. Currently
506 the user has to manually nuke all symbols between runs if they
507 want them to go away (PR 2207). This is probably reasonable. */
511 if (target_can_async_p ())
512 async_disable_stdin ();
516 int async_exec
= strip_bg_char (&args
);
518 /* If we get a request for running in the bg but the target
519 doesn't support it, error out. */
520 if (async_exec
&& !target_can_async_p ())
521 error (_("Asynchronous execution not supported on this target."));
523 /* If we don't get a request of running in the bg, then we need
524 to simulate synchronous (fg) execution. */
525 if (!async_exec
&& target_can_async_p ())
527 /* Simulate synchronous execution */
528 async_disable_stdin ();
531 /* If there were other args, beside '&', process them. */
534 char *old_args
= set_inferior_args (xstrdup (args
));
541 ui_out_field_string (uiout
, NULL
, "Starting program");
542 ui_out_text (uiout
, ": ");
544 ui_out_field_string (uiout
, "execfile", exec_file
);
545 ui_out_spaces (uiout
, 1);
546 /* We call get_inferior_args() because we might need to compute
548 ui_out_field_string (uiout
, "infargs", get_inferior_args ());
549 ui_out_text (uiout
, "\n");
550 ui_out_flush (uiout
);
553 /* We call get_inferior_args() because we might need to compute
555 target_create_inferior (exec_file
, get_inferior_args (),
556 environ_vector (inferior_environ
), from_tty
);
558 /* We're starting off a new process. When we get out of here, in
559 non-stop mode, finish the state of all threads of that process,
560 but leave other threads alone, as they may be stopped in internal
561 events --- the frontend shouldn't see them as stopped. In
562 all-stop, always finish the state of all threads, as we may be
563 resuming more than just the new process. */
565 ptid
= pid_to_ptid (ptid_get_pid (inferior_ptid
));
567 ptid
= minus_one_ptid
;
568 old_chain
= make_cleanup (finish_thread_state_cleanup
, &ptid
);
570 /* Pass zero for FROM_TTY, because at this point the "run" command
571 has done its thing; now we are setting up the running program. */
572 post_create_inferior (¤t_target
, 0);
574 /* Start the target running. */
575 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_0
, 0);
577 /* Since there was no error, there's no need to finish the thread
579 discard_cleanups (old_chain
);
583 run_command (char *args
, int from_tty
)
585 run_command_1 (args
, from_tty
, 0);
589 run_no_args_command (char *args
, int from_tty
)
591 char *old_args
= set_inferior_args (xstrdup (""));
596 /* Start the execution of the program up until the beginning of the main
600 start_command (char *args
, int from_tty
)
602 /* Some languages such as Ada need to search inside the program
603 minimal symbols for the location where to put the temporary
604 breakpoint before starting. */
605 if (!have_minimal_symbols ())
606 error (_("No symbol table loaded. Use the \"file\" command."));
608 /* Run the program until reaching the main procedure... */
609 run_command_1 (args
, from_tty
, 1);
613 proceed_thread_callback (struct thread_info
*thread
, void *arg
)
615 /* We go through all threads individually instead of compressing
616 into a single target `resume_all' request, because some threads
617 may be stopped in internal breakpoints/events, or stopped waiting
618 for its turn in the displaced stepping queue (that is, they are
619 running && !executing). The target side has no idea about why
620 the thread is stopped, so a `resume_all' command would resume too
621 much. If/when GDB gains a way to tell the target `hold this
622 thread stopped until I say otherwise', then we can optimize
624 if (!is_stopped (thread
->ptid
))
627 switch_to_thread (thread
->ptid
);
628 clear_proceed_status ();
629 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 0);
634 ensure_valid_thread (void)
636 if (ptid_equal (inferior_ptid
, null_ptid
)
637 || is_exited (inferior_ptid
))
639 Cannot execute this command without a live selected thread."));
643 continue_1 (int all_threads
)
647 if (non_stop
&& all_threads
)
649 /* Don't error out if the current thread is running, because
650 there may be other stopped threads. */
651 struct cleanup
*old_chain
;
653 /* Backup current thread and selected frame. */
654 old_chain
= make_cleanup_restore_current_thread ();
656 iterate_over_threads (proceed_thread_callback
, NULL
);
658 /* Restore selected ptid. */
659 do_cleanups (old_chain
);
663 ensure_valid_thread ();
664 ensure_not_running ();
665 clear_proceed_status ();
666 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 0);
670 /* continue [-a] [proceed-count] [&] */
672 continue_command (char *args
, int from_tty
)
678 /* Find out whether we must run in the background. */
680 async_exec
= strip_bg_char (&args
);
682 /* If we must run in the background, but the target can't do it,
684 if (async_exec
&& !target_can_async_p ())
685 error (_("Asynchronous execution not supported on this target."));
687 /* If we are not asked to run in the bg, then prepare to run in the
688 foreground, synchronously. */
689 if (!async_exec
&& target_can_async_p ())
691 /* Simulate synchronous execution */
692 async_disable_stdin ();
697 if (strncmp (args
, "-a", sizeof ("-a") - 1) == 0)
700 args
+= sizeof ("-a") - 1;
706 if (!non_stop
&& all_threads
)
707 error (_("`-a' is meaningless in all-stop mode."));
709 if (args
!= NULL
&& all_threads
)
711 Can't resume all threads and specify proceed count simultaneously."));
713 /* If we have an argument left, set proceed count of breakpoint we
720 struct thread_info
*tp
;
723 tp
= find_thread_ptid (inferior_ptid
);
727 struct target_waitstatus ws
;
729 get_last_target_status (&last_ptid
, &ws
);
730 tp
= find_thread_ptid (last_ptid
);
733 bs
= tp
->stop_bpstat
;
735 while ((stat
= bpstat_num (&bs
, &num
)) != 0)
738 set_ignore_count (num
,
739 parse_and_eval_long (args
) - 1,
741 /* set_ignore_count prints a message ending with a period.
742 So print two spaces before "Continuing.". */
744 printf_filtered (" ");
748 if (!stopped
&& from_tty
)
751 ("Not stopped at any breakpoint; argument ignored.\n");
756 printf_filtered (_("Continuing.\n"));
758 continue_1 (all_threads
);
761 /* Step until outside of current statement. */
764 step_command (char *count_string
, int from_tty
)
766 step_1 (0, 0, count_string
);
769 /* Likewise, but skip over subroutine calls as if single instructions. */
772 next_command (char *count_string
, int from_tty
)
774 step_1 (1, 0, count_string
);
777 /* Likewise, but step only one instruction. */
780 stepi_command (char *count_string
, int from_tty
)
782 step_1 (0, 1, count_string
);
786 nexti_command (char *count_string
, int from_tty
)
788 step_1 (1, 1, count_string
);
792 delete_longjmp_breakpoint_cleanup (void *arg
)
794 int thread
= * (int *) arg
;
795 delete_longjmp_breakpoint (thread
);
799 step_1 (int skip_subroutines
, int single_inst
, char *count_string
)
802 struct frame_info
*frame
;
803 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
808 ensure_valid_thread ();
809 ensure_not_running ();
812 async_exec
= strip_bg_char (&count_string
);
814 /* If we get a request for running in the bg but the target
815 doesn't support it, error out. */
816 if (async_exec
&& !target_can_async_p ())
817 error (_("Asynchronous execution not supported on this target."));
819 /* If we don't get a request of running in the bg, then we need
820 to simulate synchronous (fg) execution. */
821 if (!async_exec
&& target_can_async_p ())
823 /* Simulate synchronous execution */
824 async_disable_stdin ();
827 count
= count_string
? parse_and_eval_long (count_string
) : 1;
829 if (!single_inst
|| skip_subroutines
) /* leave si command alone */
831 if (in_thread_list (inferior_ptid
))
832 thread
= pid_to_thread_id (inferior_ptid
);
834 set_longjmp_breakpoint (thread
);
836 make_cleanup (delete_longjmp_breakpoint_cleanup
, &thread
);
839 /* In synchronous case, all is well; each step_once call will step once. */
840 if (!target_can_async_p ())
842 for (; count
> 0; count
--)
844 struct thread_info
*tp
;
845 step_once (skip_subroutines
, single_inst
, count
, thread
);
847 if (target_has_execution
848 && !ptid_equal (inferior_ptid
, null_ptid
))
849 tp
= inferior_thread ();
853 if (!tp
|| !tp
->stop_step
|| !tp
->step_multi
)
855 /* If we stopped for some reason that is not stepping
856 there are no further steps to make. */
863 do_cleanups (cleanups
);
867 /* In the case of an asynchronous target things get complicated;
868 do only one step for now, before returning control to the
869 event loop. Let the continuation figure out how many other
870 steps we need to do, and handle them one at the time, through
872 step_once (skip_subroutines
, single_inst
, count
, thread
);
874 /* We are running, and the continuation is installed. It will
875 disable the longjmp breakpoint as appropriate. */
876 discard_cleanups (cleanups
);
880 struct step_1_continuation_args
883 int skip_subroutines
;
888 /* Called after we are done with one step operation, to check whether
889 we need to step again, before we print the prompt and return control
890 to the user. If count is > 1, we will need to do one more call to
891 proceed(), via step_once(). Basically it is like step_once and
892 step_1_continuation are co-recursive. */
894 step_1_continuation (void *args
)
896 struct step_1_continuation_args
*a
= args
;
898 if (target_has_execution
)
900 struct thread_info
*tp
;
902 tp
= inferior_thread ();
903 if (tp
->step_multi
&& tp
->stop_step
)
905 /* There are more steps to make, and we did stop due to
906 ending a stepping range. Do another step. */
907 step_once (a
->skip_subroutines
, a
->single_inst
,
908 a
->count
- 1, a
->thread
);
914 /* We either stopped for some reason that is not stepping, or there
915 are no further steps to make. Cleanup. */
916 if (!a
->single_inst
|| a
->skip_subroutines
)
917 delete_longjmp_breakpoint (a
->thread
);
920 /* Do just one step operation. This is useful to implement the 'step
921 n' kind of commands. In case of asynchronous targets, we will have
922 to set up a continuation to be done after the target stops (after
923 this one step). For synch targets, the caller handles further
927 step_once (int skip_subroutines
, int single_inst
, int count
, int thread
)
929 struct frame_info
*frame
;
933 /* Don't assume THREAD is a valid thread id. It is set to -1 if
934 the longjmp breakpoint was not required. Use the
935 INFERIOR_PTID thread instead, which is the same thread when
937 struct thread_info
*tp
= inferior_thread ();
938 clear_proceed_status ();
940 frame
= get_current_frame ();
941 tp
->step_frame_id
= get_frame_id (frame
);
947 pc
= get_frame_pc (frame
);
948 find_pc_line_pc_range (pc
,
949 &tp
->step_range_start
, &tp
->step_range_end
);
951 /* If we have no line info, switch to stepi mode. */
952 if (tp
->step_range_end
== 0 && step_stop_if_no_debug
)
954 tp
->step_range_start
= tp
->step_range_end
= 1;
956 else if (tp
->step_range_end
== 0)
959 if (find_pc_partial_function (pc
, &name
,
960 &tp
->step_range_start
,
961 &tp
->step_range_end
) == 0)
962 error (_("Cannot find bounds of current function"));
964 target_terminal_ours ();
965 printf_filtered (_("\
966 Single stepping until exit from function %s, \n\
967 which has no line number information.\n"), name
);
972 /* Say we are stepping, but stop after one insn whatever it does. */
973 tp
->step_range_start
= tp
->step_range_end
= 1;
974 if (!skip_subroutines
)
976 Don't step over function calls, not even to functions lacking
978 tp
->step_over_calls
= STEP_OVER_NONE
;
981 if (skip_subroutines
)
982 tp
->step_over_calls
= STEP_OVER_ALL
;
984 tp
->step_multi
= (count
> 1);
985 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 1);
987 /* For async targets, register a continuation to do any
988 additional steps. For sync targets, the caller will handle
990 if (target_can_async_p ())
992 struct step_1_continuation_args
*args
;
994 args
= xmalloc (sizeof (*args
));
995 args
->skip_subroutines
= skip_subroutines
;
996 args
->single_inst
= single_inst
;
998 args
->thread
= thread
;
1000 add_intermediate_continuation (tp
, step_1_continuation
, args
, xfree
);
1006 /* Continue program at specified address. */
1009 jump_command (char *arg
, int from_tty
)
1012 struct symtabs_and_lines sals
;
1013 struct symtab_and_line sal
;
1019 ensure_valid_thread ();
1020 ensure_not_running ();
1022 /* Find out whether we must run in the background. */
1024 async_exec
= strip_bg_char (&arg
);
1026 /* If we must run in the background, but the target can't do it,
1028 if (async_exec
&& !target_can_async_p ())
1029 error (_("Asynchronous execution not supported on this target."));
1032 error_no_arg (_("starting address"));
1034 sals
= decode_line_spec_1 (arg
, 1);
1035 if (sals
.nelts
!= 1)
1037 error (_("Unreasonable jump request"));
1043 if (sal
.symtab
== 0 && sal
.pc
== 0)
1044 error (_("No source file has been specified."));
1046 resolve_sal_pc (&sal
); /* May error out */
1048 /* See if we are trying to jump to another function. */
1049 fn
= get_frame_function (get_current_frame ());
1050 sfn
= find_pc_function (sal
.pc
);
1051 if (fn
!= NULL
&& sfn
!= fn
)
1053 if (!query (_("Line %d is not in `%s'. Jump anyway? "), sal
.line
,
1054 SYMBOL_PRINT_NAME (fn
)))
1056 error (_("Not confirmed."));
1063 fixup_symbol_section (sfn
, 0);
1064 if (section_is_overlay (SYMBOL_OBJ_SECTION (sfn
)) &&
1065 !section_is_mapped (SYMBOL_OBJ_SECTION (sfn
)))
1067 if (!query (_("WARNING!!! Destination is in unmapped overlay! Jump anyway? ")))
1069 error (_("Not confirmed."));
1079 printf_filtered (_("Continuing at "));
1080 fputs_filtered (paddress (addr
), gdb_stdout
);
1081 printf_filtered (".\n");
1084 /* If we are not asked to run in the bg, then prepare to run in the
1085 foreground, synchronously. */
1086 if (!async_exec
&& target_can_async_p ())
1088 /* Simulate synchronous execution */
1089 async_disable_stdin ();
1092 clear_proceed_status ();
1093 proceed (addr
, TARGET_SIGNAL_0
, 0);
1097 /* Go to line or address in current procedure */
1099 go_command (char *line_no
, int from_tty
)
1101 if (line_no
== (char *) NULL
|| !*line_no
)
1102 printf_filtered (_("Usage: go <location>\n"));
1105 tbreak_command (line_no
, from_tty
);
1106 jump_command (line_no
, from_tty
);
1111 /* Continue program giving it specified signal. */
1114 signal_command (char *signum_exp
, int from_tty
)
1116 enum target_signal oursig
;
1119 dont_repeat (); /* Too dangerous. */
1121 ensure_valid_thread ();
1122 ensure_not_running ();
1124 /* Find out whether we must run in the background. */
1125 if (signum_exp
!= NULL
)
1126 async_exec
= strip_bg_char (&signum_exp
);
1128 /* If we must run in the background, but the target can't do it,
1130 if (async_exec
&& !target_can_async_p ())
1131 error (_("Asynchronous execution not supported on this target."));
1133 /* If we are not asked to run in the bg, then prepare to run in the
1134 foreground, synchronously. */
1135 if (!async_exec
&& target_can_async_p ())
1137 /* Simulate synchronous execution. */
1138 async_disable_stdin ();
1142 error_no_arg (_("signal number"));
1144 /* It would be even slicker to make signal names be valid expressions,
1145 (the type could be "enum $signal" or some such), then the user could
1146 assign them to convenience variables. */
1147 oursig
= target_signal_from_name (signum_exp
);
1149 if (oursig
== TARGET_SIGNAL_UNKNOWN
)
1151 /* No, try numeric. */
1152 int num
= parse_and_eval_long (signum_exp
);
1155 oursig
= TARGET_SIGNAL_0
;
1157 oursig
= target_signal_from_command (num
);
1162 if (oursig
== TARGET_SIGNAL_0
)
1163 printf_filtered (_("Continuing with no signal.\n"));
1165 printf_filtered (_("Continuing with signal %s.\n"),
1166 target_signal_to_name (oursig
));
1169 clear_proceed_status ();
1170 proceed ((CORE_ADDR
) -1, oursig
, 0);
1173 /* Proceed until we reach a different source line with pc greater than
1174 our current one or exit the function. We skip calls in both cases.
1176 Note that eventually this command should probably be changed so
1177 that only source lines are printed out when we hit the breakpoint
1178 we set. This may involve changes to wait_for_inferior and the
1179 proceed status code. */
1182 until_next_command (int from_tty
)
1184 struct frame_info
*frame
;
1186 struct symbol
*func
;
1187 struct symtab_and_line sal
;
1188 struct thread_info
*tp
= inferior_thread ();
1190 clear_proceed_status ();
1192 frame
= get_current_frame ();
1194 /* Step until either exited from this function or greater
1195 than the current line (if in symbolic section) or pc (if
1198 pc
= get_frame_pc (frame
);
1199 func
= find_pc_function (pc
);
1203 struct minimal_symbol
*msymbol
= lookup_minimal_symbol_by_pc (pc
);
1205 if (msymbol
== NULL
)
1206 error (_("Execution is not within a known function."));
1208 tp
->step_range_start
= SYMBOL_VALUE_ADDRESS (msymbol
);
1209 tp
->step_range_end
= pc
;
1213 sal
= find_pc_line (pc
, 0);
1215 tp
->step_range_start
= BLOCK_START (SYMBOL_BLOCK_VALUE (func
));
1216 tp
->step_range_end
= sal
.end
;
1219 tp
->step_over_calls
= STEP_OVER_ALL
;
1220 tp
->step_frame_id
= get_frame_id (frame
);
1222 tp
->step_multi
= 0; /* Only one call to proceed */
1224 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 1);
1228 until_command (char *arg
, int from_tty
)
1232 if (!target_has_execution
)
1233 error (_("The program is not running."));
1235 /* Find out whether we must run in the background. */
1237 async_exec
= strip_bg_char (&arg
);
1239 /* If we must run in the background, but the target can't do it,
1241 if (async_exec
&& !target_can_async_p ())
1242 error (_("Asynchronous execution not supported on this target."));
1244 /* If we are not asked to run in the bg, then prepare to run in the
1245 foreground, synchronously. */
1246 if (!async_exec
&& target_can_async_p ())
1248 /* Simulate synchronous execution */
1249 async_disable_stdin ();
1253 until_break_command (arg
, from_tty
, 0);
1255 until_next_command (from_tty
);
1259 advance_command (char *arg
, int from_tty
)
1263 if (!target_has_execution
)
1264 error (_("The program is not running."));
1267 error_no_arg (_("a location"));
1269 /* Find out whether we must run in the background. */
1271 async_exec
= strip_bg_char (&arg
);
1273 /* If we must run in the background, but the target can't do it,
1275 if (async_exec
&& !target_can_async_p ())
1276 error (_("Asynchronous execution not supported on this target."));
1278 /* If we are not asked to run in the bg, then prepare to run in the
1279 foreground, synchronously. */
1280 if (!async_exec
&& target_can_async_p ())
1282 /* Simulate synchronous execution. */
1283 async_disable_stdin ();
1286 until_break_command (arg
, from_tty
, 1);
1289 /* Print the result of a function at the end of a 'finish' command. */
1292 print_return_value (struct type
*func_type
, struct type
*value_type
)
1294 struct gdbarch
*gdbarch
= get_regcache_arch (stop_registers
);
1295 struct cleanup
*old_chain
;
1296 struct ui_stream
*stb
;
1297 struct value
*value
;
1299 CHECK_TYPEDEF (value_type
);
1300 gdb_assert (TYPE_CODE (value_type
) != TYPE_CODE_VOID
);
1302 /* FIXME: 2003-09-27: When returning from a nested inferior function
1303 call, it's possible (with no help from the architecture vector)
1304 to locate and return/print a "struct return" value. This is just
1305 a more complicated case of what is already being done in in the
1306 inferior function call code. In fact, when inferior function
1307 calls are made async, this will likely be made the norm. */
1309 switch (gdbarch_return_value (gdbarch
, func_type
, value_type
,
1312 case RETURN_VALUE_REGISTER_CONVENTION
:
1313 case RETURN_VALUE_ABI_RETURNS_ADDRESS
:
1314 case RETURN_VALUE_ABI_PRESERVES_ADDRESS
:
1315 value
= allocate_value (value_type
);
1316 gdbarch_return_value (gdbarch
, func_type
, value_type
, stop_registers
,
1317 value_contents_raw (value
), NULL
);
1319 case RETURN_VALUE_STRUCT_CONVENTION
:
1323 internal_error (__FILE__
, __LINE__
, _("bad switch"));
1328 struct value_print_options opts
;
1331 stb
= ui_out_stream_new (uiout
);
1332 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
1333 ui_out_text (uiout
, "Value returned is ");
1334 ui_out_field_fmt (uiout
, "gdb-result-var", "$%d",
1335 record_latest_value (value
));
1336 ui_out_text (uiout
, " = ");
1337 get_raw_print_options (&opts
);
1338 value_print (value
, stb
->stream
, &opts
);
1339 ui_out_field_stream (uiout
, "return-value", stb
);
1340 ui_out_text (uiout
, "\n");
1341 do_cleanups (old_chain
);
1345 ui_out_text (uiout
, "Value returned has type: ");
1346 ui_out_field_string (uiout
, "return-type", TYPE_NAME (value_type
));
1347 ui_out_text (uiout
, ".");
1348 ui_out_text (uiout
, " Cannot determine contents\n");
1352 /* Stuff that needs to be done by the finish command after the target
1353 has stopped. In asynchronous mode, we wait for the target to stop
1354 in the call to poll or select in the event loop, so it is
1355 impossible to do all the stuff as part of the finish_command
1356 function itself. The only chance we have to complete this command
1357 is in fetch_inferior_event, which is called by the event loop as
1358 soon as it detects that the target has stopped. This function is
1359 called via the cmd_continuation pointer. */
1361 struct finish_command_continuation_args
1363 struct breakpoint
*breakpoint
;
1364 struct symbol
*function
;
1368 finish_command_continuation (void *arg
)
1370 struct finish_command_continuation_args
*a
= arg
;
1371 struct thread_info
*tp
= NULL
;
1374 if (!ptid_equal (inferior_ptid
, null_ptid
)
1375 && target_has_execution
1376 && is_stopped (inferior_ptid
))
1378 tp
= inferior_thread ();
1379 bs
= tp
->stop_bpstat
;
1382 if (bpstat_find_breakpoint (bs
, a
->breakpoint
) != NULL
1383 && a
->function
!= NULL
)
1385 struct type
*value_type
;
1387 value_type
= TYPE_TARGET_TYPE (SYMBOL_TYPE (a
->function
));
1389 internal_error (__FILE__
, __LINE__
,
1390 _("finish_command: function has no target type"));
1392 if (TYPE_CODE (value_type
) != TYPE_CODE_VOID
)
1393 print_return_value (SYMBOL_TYPE (a
->function
), value_type
);
1396 /* We suppress normal call of normal_stop observer and do it here so
1397 that the *stopped notification includes the return value. */
1398 if (bs
!= NULL
&& tp
->proceed_to_finish
)
1399 observer_notify_normal_stop (bs
, 1 /* print frame */);
1400 delete_breakpoint (a
->breakpoint
);
1404 finish_command_continuation_free_arg (void *arg
)
1409 /* finish_backward -- helper function for finish_command. */
1412 finish_backward (struct symbol
*function
)
1414 struct symtab_and_line sal
;
1415 struct thread_info
*tp
= inferior_thread ();
1416 struct breakpoint
*breakpoint
;
1417 struct cleanup
*old_chain
;
1419 CORE_ADDR func_addr
;
1422 pc
= get_frame_pc (get_current_frame ());
1424 if (find_pc_partial_function (pc
, NULL
, &func_addr
, NULL
) == 0)
1425 internal_error (__FILE__
, __LINE__
,
1426 _("Finish: couldn't find function."));
1428 sal
= find_pc_line (func_addr
, 0);
1430 /* We don't need a return value. */
1431 tp
->proceed_to_finish
= 0;
1432 /* Special case: if we're sitting at the function entry point,
1433 then all we need to do is take a reverse singlestep. We
1434 don't need to set a breakpoint, and indeed it would do us
1437 Note that this can only happen at frame #0, since there's
1438 no way that a function up the stack can have a return address
1439 that's equal to its entry point. */
1443 /* Set breakpoint and continue. */
1445 set_momentary_breakpoint (sal
,
1446 get_frame_id (get_selected_frame (NULL
)),
1448 /* Tell the breakpoint to keep quiet. We won't be done
1449 until we've done another reverse single-step. */
1450 make_breakpoint_silent (breakpoint
);
1451 old_chain
= make_cleanup_delete_breakpoint (breakpoint
);
1452 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 0);
1453 /* We will be stopped when proceed returns. */
1454 back_up
= bpstat_find_breakpoint (tp
->stop_bpstat
, breakpoint
) != NULL
;
1455 do_cleanups (old_chain
);
1461 /* If in fact we hit the step-resume breakpoint (and not
1462 some other breakpoint), then we're almost there --
1463 we just need to back up by one more single-step. */
1464 tp
->step_range_start
= tp
->step_range_end
= 1;
1465 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 1);
1470 /* finish_forward -- helper function for finish_command. */
1473 finish_forward (struct symbol
*function
, struct frame_info
*frame
)
1475 struct symtab_and_line sal
;
1476 struct thread_info
*tp
= inferior_thread ();
1477 struct breakpoint
*breakpoint
;
1478 struct cleanup
*old_chain
;
1479 struct finish_command_continuation_args
*cargs
;
1481 sal
= find_pc_line (get_frame_pc (frame
), 0);
1482 sal
.pc
= get_frame_pc (frame
);
1484 breakpoint
= set_momentary_breakpoint (sal
, get_frame_id (frame
),
1487 old_chain
= make_cleanup_delete_breakpoint (breakpoint
);
1489 tp
->proceed_to_finish
= 1; /* We want stop_registers, please... */
1490 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 0);
1492 cargs
= xmalloc (sizeof (*cargs
));
1494 cargs
->breakpoint
= breakpoint
;
1495 cargs
->function
= function
;
1496 add_continuation (tp
, finish_command_continuation
, cargs
,
1497 finish_command_continuation_free_arg
);
1499 discard_cleanups (old_chain
);
1500 if (!target_can_async_p ())
1501 do_all_continuations ();
1504 /* "finish": Set a temporary breakpoint at the place the selected
1505 frame will return to, then continue. */
1508 finish_command (char *arg
, int from_tty
)
1510 struct frame_info
*frame
;
1511 struct symbol
*function
;
1515 /* Find out whether we must run in the background. */
1517 async_exec
= strip_bg_char (&arg
);
1519 /* If we must run in the background, but the target can't do it,
1521 if (async_exec
&& !target_can_async_p ())
1522 error (_("Asynchronous execution not supported on this target."));
1524 /* Don't try to async in reverse. */
1525 if (async_exec
&& execution_direction
== EXEC_REVERSE
)
1526 error (_("Asynchronous 'finish' not supported in reverse."));
1528 /* If we are not asked to run in the bg, then prepare to run in the
1529 foreground, synchronously. */
1530 if (!async_exec
&& target_can_async_p ())
1532 /* Simulate synchronous execution. */
1533 async_disable_stdin ();
1537 error (_("The \"finish\" command does not take any arguments."));
1538 if (!target_has_execution
)
1539 error (_("The program is not running."));
1541 frame
= get_prev_frame (get_selected_frame (_("No selected frame.")));
1543 error (_("\"finish\" not meaningful in the outermost frame."));
1545 clear_proceed_status ();
1547 /* Find the function we will return from. */
1549 function
= find_pc_function (get_frame_pc (get_selected_frame (NULL
)));
1551 /* Print info on the selected frame, including level number but not
1555 if (execution_direction
== EXEC_REVERSE
)
1556 printf_filtered (_("Run back to call of "));
1558 printf_filtered (_("Run till exit from "));
1560 print_stack_frame (get_selected_frame (NULL
), 1, LOCATION
);
1563 if (execution_direction
== EXEC_REVERSE
)
1564 finish_backward (function
);
1566 finish_forward (function
, frame
);
1571 program_info (char *args
, int from_tty
)
1575 struct thread_info
*tp
;
1578 if (!target_has_execution
)
1580 printf_filtered (_("The program being debugged is not being run.\n"));
1585 ptid
= inferior_ptid
;
1588 struct target_waitstatus ws
;
1589 get_last_target_status (&ptid
, &ws
);
1592 if (ptid_equal (ptid
, null_ptid
) || is_exited (ptid
))
1593 error (_("Invalid selected thread."));
1594 else if (is_running (ptid
))
1595 error (_("Selected thread is running."));
1597 tp
= find_thread_ptid (ptid
);
1598 bs
= tp
->stop_bpstat
;
1599 stat
= bpstat_num (&bs
, &num
);
1601 target_files_info ();
1602 printf_filtered (_("Program stopped at %s.\n"), paddress (stop_pc
));
1604 printf_filtered (_("It stopped after being stepped.\n"));
1607 /* There may be several breakpoints in the same place, so this
1608 isn't as strange as it seems. */
1613 printf_filtered (_("\
1614 It stopped at a breakpoint that has since been deleted.\n"));
1617 printf_filtered (_("It stopped at breakpoint %d.\n"), num
);
1618 stat
= bpstat_num (&bs
, &num
);
1621 else if (tp
->stop_signal
!= TARGET_SIGNAL_0
)
1623 printf_filtered (_("It stopped with signal %s, %s.\n"),
1624 target_signal_to_name (tp
->stop_signal
),
1625 target_signal_to_string (tp
->stop_signal
));
1630 printf_filtered (_("\
1631 Type \"info stack\" or \"info registers\" for more information.\n"));
1636 environment_info (char *var
, int from_tty
)
1640 char *val
= get_in_environ (inferior_environ
, var
);
1643 puts_filtered (var
);
1644 puts_filtered (" = ");
1645 puts_filtered (val
);
1646 puts_filtered ("\n");
1650 puts_filtered ("Environment variable \"");
1651 puts_filtered (var
);
1652 puts_filtered ("\" not defined.\n");
1657 char **vector
= environ_vector (inferior_environ
);
1660 puts_filtered (*vector
++);
1661 puts_filtered ("\n");
1667 set_environment_command (char *arg
, int from_tty
)
1669 char *p
, *val
, *var
;
1673 error_no_arg (_("environment variable and value"));
1675 /* Find seperation between variable name and value */
1676 p
= (char *) strchr (arg
, '=');
1677 val
= (char *) strchr (arg
, ' ');
1679 if (p
!= 0 && val
!= 0)
1681 /* We have both a space and an equals. If the space is before the
1682 equals, walk forward over the spaces til we see a nonspace
1683 (possibly the equals). */
1688 /* Now if the = is after the char following the spaces,
1689 take the char following the spaces. */
1693 else if (val
!= 0 && p
== 0)
1697 error_no_arg (_("environment variable to set"));
1699 if (p
== 0 || p
[1] == 0)
1703 p
= arg
+ strlen (arg
); /* So that savestring below will work */
1707 /* Not setting variable value to null */
1709 while (*val
== ' ' || *val
== '\t')
1713 while (p
!= arg
&& (p
[-1] == ' ' || p
[-1] == '\t'))
1716 var
= savestring (arg
, p
- arg
);
1719 printf_filtered (_("\
1720 Setting environment variable \"%s\" to null value.\n"),
1722 set_in_environ (inferior_environ
, var
, "");
1725 set_in_environ (inferior_environ
, var
, val
);
1730 unset_environment_command (char *var
, int from_tty
)
1734 /* If there is no argument, delete all environment variables.
1735 Ask for confirmation if reading from the terminal. */
1736 if (!from_tty
|| query (_("Delete all environment variables? ")))
1738 free_environ (inferior_environ
);
1739 inferior_environ
= make_environ ();
1743 unset_in_environ (inferior_environ
, var
);
1746 /* Handle the execution path (PATH variable) */
1748 static const char path_var_name
[] = "PATH";
1751 path_info (char *args
, int from_tty
)
1753 puts_filtered ("Executable and object file path: ");
1754 puts_filtered (get_in_environ (inferior_environ
, path_var_name
));
1755 puts_filtered ("\n");
1758 /* Add zero or more directories to the front of the execution path. */
1761 path_command (char *dirname
, int from_tty
)
1766 env
= get_in_environ (inferior_environ
, path_var_name
);
1767 /* Can be null if path is not set */
1770 exec_path
= xstrdup (env
);
1771 mod_path (dirname
, &exec_path
);
1772 set_in_environ (inferior_environ
, path_var_name
, exec_path
);
1775 path_info ((char *) NULL
, from_tty
);
1779 /* Print out the machine register regnum. If regnum is -1, print all
1780 registers (print_all == 1) or all non-float and non-vector
1781 registers (print_all == 0).
1783 For most machines, having all_registers_info() print the
1784 register(s) one per line is good enough. If a different format is
1785 required, (eg, for MIPS or Pyramid 90x, which both have lots of
1786 regs), or there is an existing convention for showing all the
1787 registers, define the architecture method PRINT_REGISTERS_INFO to
1788 provide that format. */
1791 default_print_registers_info (struct gdbarch
*gdbarch
,
1792 struct ui_file
*file
,
1793 struct frame_info
*frame
,
1794 int regnum
, int print_all
)
1797 const int numregs
= gdbarch_num_regs (gdbarch
)
1798 + gdbarch_num_pseudo_regs (gdbarch
);
1799 gdb_byte buffer
[MAX_REGISTER_SIZE
];
1801 for (i
= 0; i
< numregs
; i
++)
1803 /* Decide between printing all regs, non-float / vector regs, or
1809 if (!gdbarch_register_reggroup_p (gdbarch
, i
, all_reggroup
))
1814 if (!gdbarch_register_reggroup_p (gdbarch
, i
, general_reggroup
))
1824 /* If the register name is empty, it is undefined for this
1825 processor, so don't display anything. */
1826 if (gdbarch_register_name (gdbarch
, i
) == NULL
1827 || *(gdbarch_register_name (gdbarch
, i
)) == '\0')
1830 fputs_filtered (gdbarch_register_name (gdbarch
, i
), file
);
1831 print_spaces_filtered (15 - strlen (gdbarch_register_name
1832 (gdbarch
, i
)), file
);
1834 /* Get the data in raw format. */
1835 if (! frame_register_read (frame
, i
, buffer
))
1837 fprintf_filtered (file
, "*value not available*\n");
1841 /* If virtual format is floating, print it that way, and in raw
1843 if (TYPE_CODE (register_type (gdbarch
, i
)) == TYPE_CODE_FLT
1844 || TYPE_CODE (register_type (gdbarch
, i
)) == TYPE_CODE_DECFLOAT
)
1847 struct value_print_options opts
;
1849 get_user_print_options (&opts
);
1851 val_print (register_type (gdbarch
, i
), buffer
, 0, 0,
1852 file
, 0, &opts
, current_language
);
1854 fprintf_filtered (file
, "\t(raw 0x");
1855 for (j
= 0; j
< register_size (gdbarch
, i
); j
++)
1858 if (gdbarch_byte_order (gdbarch
) == BFD_ENDIAN_BIG
)
1861 idx
= register_size (gdbarch
, i
) - 1 - j
;
1862 fprintf_filtered (file
, "%02x", (unsigned char) buffer
[idx
]);
1864 fprintf_filtered (file
, ")");
1868 struct value_print_options opts
;
1870 /* Print the register in hex. */
1871 get_formatted_print_options (&opts
, 'x');
1873 val_print (register_type (gdbarch
, i
), buffer
, 0, 0,
1876 /* If not a vector register, print it also according to its
1878 if (TYPE_VECTOR (register_type (gdbarch
, i
)) == 0)
1880 get_user_print_options (&opts
);
1882 fprintf_filtered (file
, "\t");
1883 val_print (register_type (gdbarch
, i
), buffer
, 0, 0,
1884 file
, 0, &opts
, current_language
);
1888 fprintf_filtered (file
, "\n");
1893 registers_info (char *addr_exp
, int fpregs
)
1895 struct frame_info
*frame
;
1896 struct gdbarch
*gdbarch
;
1897 int regnum
, numregs
;
1900 if (!target_has_registers
)
1901 error (_("The program has no registers now."));
1902 frame
= get_selected_frame (NULL
);
1903 gdbarch
= get_frame_arch (frame
);
1907 gdbarch_print_registers_info (gdbarch
, gdb_stdout
,
1912 while (*addr_exp
!= '\0')
1917 /* Keep skipping leading white space. */
1918 if (isspace ((*addr_exp
)))
1924 /* Discard any leading ``$''. Check that there is something
1925 resembling a register following it. */
1926 if (addr_exp
[0] == '$')
1928 if (isspace ((*addr_exp
)) || (*addr_exp
) == '\0')
1929 error (_("Missing register name"));
1931 /* Find the start/end of this register name/num/group. */
1933 while ((*addr_exp
) != '\0' && !isspace ((*addr_exp
)))
1937 /* Figure out what we've found and display it. */
1939 /* A register name? */
1941 int regnum
= user_reg_map_name_to_regnum (gdbarch
, start
, end
- start
);
1944 /* User registers lie completely outside of the range of
1945 normal registers. Catch them early so that the target
1947 if (regnum
>= gdbarch_num_regs (gdbarch
)
1948 + gdbarch_num_pseudo_regs (gdbarch
))
1950 struct value_print_options opts
;
1951 struct value
*val
= value_of_user_reg (regnum
, frame
);
1953 printf_filtered ("%s: ", start
);
1954 get_formatted_print_options (&opts
, 'x');
1955 print_scalar_formatted (value_contents (val
),
1956 check_typedef (value_type (val
)),
1957 &opts
, 0, gdb_stdout
);
1958 printf_filtered ("\n");
1961 gdbarch_print_registers_info (gdbarch
, gdb_stdout
,
1962 frame
, regnum
, fpregs
);
1967 /* A register group? */
1969 struct reggroup
*group
;
1970 for (group
= reggroup_next (gdbarch
, NULL
);
1972 group
= reggroup_next (gdbarch
, group
))
1974 /* Don't bother with a length check. Should the user
1975 enter a short register group name, go with the first
1976 group that matches. */
1977 if (strncmp (start
, reggroup_name (group
), end
- start
) == 0)
1984 regnum
< gdbarch_num_regs (gdbarch
)
1985 + gdbarch_num_pseudo_regs (gdbarch
);
1988 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, group
))
1989 gdbarch_print_registers_info (gdbarch
,
1997 /* Nothing matched. */
1998 error (_("Invalid register `%.*s'"), (int) (end
- start
), start
);
2003 all_registers_info (char *addr_exp
, int from_tty
)
2005 registers_info (addr_exp
, 1);
2009 nofp_registers_info (char *addr_exp
, int from_tty
)
2011 registers_info (addr_exp
, 0);
2015 print_vector_info (struct ui_file
*file
,
2016 struct frame_info
*frame
, const char *args
)
2018 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
2020 if (gdbarch_print_vector_info_p (gdbarch
))
2021 gdbarch_print_vector_info (gdbarch
, file
, frame
, args
);
2025 int printed_something
= 0;
2028 regnum
< gdbarch_num_regs (gdbarch
)
2029 + gdbarch_num_pseudo_regs (gdbarch
);
2032 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, vector_reggroup
))
2034 printed_something
= 1;
2035 gdbarch_print_registers_info (gdbarch
, file
, frame
, regnum
, 1);
2038 if (!printed_something
)
2039 fprintf_filtered (file
, "No vector information\n");
2044 vector_info (char *args
, int from_tty
)
2046 if (!target_has_registers
)
2047 error (_("The program has no registers now."));
2049 print_vector_info (gdb_stdout
, get_selected_frame (NULL
), args
);
2052 /* Kill the inferior process. Make us have no inferior. */
2055 kill_command (char *arg
, int from_tty
)
2057 /* FIXME: This should not really be inferior_ptid (or target_has_execution).
2058 It should be a distinct flag that indicates that a target is active, cuz
2059 some targets don't have processes! */
2061 if (ptid_equal (inferior_ptid
, null_ptid
))
2062 error (_("The program is not being run."));
2063 if (!query (_("Kill the program being debugged? ")))
2064 error (_("Not confirmed."));
2067 /* If we still have other inferiors to debug, then don't mess with
2068 with their threads. */
2069 if (!have_inferiors ())
2071 init_thread_list (); /* Destroy thread info */
2073 /* Killing off the inferior can leave us with a core file. If
2074 so, print the state we are left in. */
2075 if (target_has_stack
)
2077 printf_filtered (_("In %s,\n"), target_longname
);
2078 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
2081 bfd_cache_close_all ();
2084 /* Used in `attach&' command. ARG is a point to an integer
2085 representing a process id. Proceed threads of this process iff
2086 they stopped due to debugger request, and when they did, they
2087 reported a clean stop (TARGET_SIGNAL_0). Do not proceed threads
2088 that have been explicitly been told to stop. */
2091 proceed_after_attach_callback (struct thread_info
*thread
,
2094 int pid
= * (int *) arg
;
2096 if (ptid_get_pid (thread
->ptid
) == pid
2097 && !is_exited (thread
->ptid
)
2098 && !is_executing (thread
->ptid
)
2099 && !thread
->stop_requested
2100 && thread
->stop_signal
== TARGET_SIGNAL_0
)
2102 switch_to_thread (thread
->ptid
);
2103 clear_proceed_status ();
2104 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 0);
2111 proceed_after_attach (int pid
)
2113 /* Don't error out if the current thread is running, because
2114 there may be other stopped threads. */
2115 struct cleanup
*old_chain
;
2117 /* Backup current thread and selected frame. */
2118 old_chain
= make_cleanup_restore_current_thread ();
2120 iterate_over_threads (proceed_after_attach_callback
, &pid
);
2122 /* Restore selected ptid. */
2123 do_cleanups (old_chain
);
2128 * Should save/restore the tty state since it might be that the
2129 * program to be debugged was started on this tty and it wants
2130 * the tty in some state other than what we want. If it's running
2131 * on another terminal or without a terminal, then saving and
2132 * restoring the tty state is a harmless no-op.
2133 * This only needs to be done if we are attaching to a process.
2138 takes a program started up outside of gdb and ``attaches'' to it.
2139 This stops it cold in its tracks and allows us to start debugging it.
2140 and wait for the trace-trap that results from attaching. */
2143 attach_command_post_wait (char *args
, int from_tty
, int async_exec
)
2146 char *full_exec_path
= NULL
;
2147 struct inferior
*inferior
;
2149 inferior
= current_inferior ();
2150 inferior
->stop_soon
= NO_STOP_QUIETLY
;
2152 /* If no exec file is yet known, try to determine it from the
2154 exec_file
= (char *) get_exec_file (0);
2157 exec_file
= target_pid_to_exec_file (PIDGET (inferior_ptid
));
2160 /* It's possible we don't have a full path, but rather just a
2161 filename. Some targets, such as HP-UX, don't provide the
2164 Attempt to qualify the filename against the source path.
2165 (If that fails, we'll just fall back on the original
2166 filename. Not much more we can do...)
2168 if (!source_full_path_of (exec_file
, &full_exec_path
))
2169 full_exec_path
= xstrdup (exec_file
);
2171 exec_file_attach (full_exec_path
, from_tty
);
2172 symbol_file_add_main (full_exec_path
, from_tty
);
2177 reopen_exec_file ();
2181 /* Take any necessary post-attaching actions for this platform. */
2182 target_post_attach (PIDGET (inferior_ptid
));
2184 post_create_inferior (¤t_target
, from_tty
);
2186 /* Install inferior's terminal modes. */
2187 target_terminal_inferior ();
2191 /* The user requested an `attach&', so be sure to leave threads
2192 that didn't get a signal running. */
2194 /* Immediatelly resume all suspended threads of this inferior,
2195 and this inferior only. This should have no effect on
2196 already running threads. If a thread has been stopped with a
2197 signal, leave it be. */
2199 proceed_after_attach (inferior
->pid
);
2202 if (inferior_thread ()->stop_signal
== TARGET_SIGNAL_0
)
2204 clear_proceed_status ();
2205 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 0);
2211 /* The user requested a plain `attach', so be sure to leave
2212 the inferior stopped. */
2214 if (target_can_async_p ())
2215 async_enable_stdin ();
2217 /* At least the current thread is already stopped. */
2219 /* In all-stop, by definition, all threads have to be already
2220 stopped at this point. In non-stop, however, although the
2221 selected thread is stopped, others may still be executing.
2222 Be sure to explicitly stop all threads of the process. This
2223 should have no effect on already stopped threads. */
2225 target_stop (pid_to_ptid (inferior
->pid
));
2227 /* Tell the user/frontend where we're stopped. */
2229 if (deprecated_attach_hook
)
2230 deprecated_attach_hook ();
2234 struct attach_command_continuation_args
2242 attach_command_continuation (void *args
)
2244 struct attach_command_continuation_args
*a
= args
;
2245 attach_command_post_wait (a
->args
, a
->from_tty
, a
->async_exec
);
2249 attach_command_continuation_free_args (void *args
)
2251 struct attach_command_continuation_args
*a
= args
;
2257 attach_command (char *args
, int from_tty
)
2260 char *full_exec_path
= NULL
;
2262 struct cleanup
*back_to
= make_cleanup (null_cleanup
, NULL
);
2264 dont_repeat (); /* Not for the faint of heart */
2266 if (gdbarch_has_global_solist (target_gdbarch
))
2267 /* Don't complain if all processes share the same symbol
2270 else if (target_has_execution
)
2272 if (query (_("A program is being debugged already. Kill it? ")))
2275 error (_("Not killed."));
2278 /* Clean up any leftovers from other runs. Some other things from
2279 this function should probably be moved into target_pre_inferior. */
2280 target_pre_inferior (from_tty
);
2282 if (non_stop
&& !target_supports_non_stop ())
2283 error (_("Cannot attach to this target in non-stop mode"));
2287 async_exec
= strip_bg_char (&args
);
2289 /* If we get a request for running in the bg but the target
2290 doesn't support it, error out. */
2291 if (async_exec
&& !target_can_async_p ())
2292 error (_("Asynchronous execution not supported on this target."));
2295 /* If we don't get a request of running in the bg, then we need
2296 to simulate synchronous (fg) execution. */
2297 if (!async_exec
&& target_can_async_p ())
2299 /* Simulate synchronous execution */
2300 async_disable_stdin ();
2301 make_cleanup ((make_cleanup_ftype
*)async_enable_stdin
, NULL
);
2304 target_attach (args
, from_tty
);
2306 /* Set up the "saved terminal modes" of the inferior
2307 based on what modes we are starting it with. */
2308 target_terminal_init ();
2310 /* Set up execution context to know that we should return from
2311 wait_for_inferior as soon as the target reports a stop. */
2312 init_wait_for_inferior ();
2313 clear_proceed_status ();
2317 /* If we find that the current thread isn't stopped, explicitly
2318 do so now, because we're going to install breakpoints and
2322 /* The user requested an `attach&'; stop just one thread. */
2323 target_stop (inferior_ptid
);
2325 /* The user requested an `attach', so stop all threads of this
2327 target_stop (pid_to_ptid (ptid_get_pid (inferior_ptid
)));
2330 /* Some system don't generate traps when attaching to inferior.
2331 E.g. Mach 3 or GNU hurd. */
2332 if (!target_attach_no_wait
)
2334 struct inferior
*inferior
= current_inferior ();
2336 /* Careful here. See comments in inferior.h. Basically some
2337 OSes don't ignore SIGSTOPs on continue requests anymore. We
2338 need a way for handle_inferior_event to reset the stop_signal
2339 variable after an attach, and this is what
2340 STOP_QUIETLY_NO_SIGSTOP is for. */
2341 inferior
->stop_soon
= STOP_QUIETLY_NO_SIGSTOP
;
2343 if (target_can_async_p ())
2345 /* sync_execution mode. Wait for stop. */
2346 struct attach_command_continuation_args
*a
;
2348 a
= xmalloc (sizeof (*a
));
2349 a
->args
= xstrdup (args
);
2350 a
->from_tty
= from_tty
;
2351 a
->async_exec
= async_exec
;
2352 add_inferior_continuation (attach_command_continuation
, a
,
2353 attach_command_continuation_free_args
);
2354 discard_cleanups (back_to
);
2358 wait_for_inferior (0);
2361 attach_command_post_wait (args
, from_tty
, async_exec
);
2362 discard_cleanups (back_to
);
2365 /* We had just found out that the target was already attached to an
2366 inferior. PTID points at a thread of this new inferior, that is
2367 the most likely to be stopped right now, but not necessarily so.
2368 The new inferior is assumed to be already added to the inferior
2369 list at this point. If LEAVE_RUNNING, then leave the threads of
2370 this inferior running, except those we've explicitly seen reported
2374 notice_new_inferior (ptid_t ptid
, int leave_running
, int from_tty
)
2376 struct cleanup
* old_chain
;
2379 old_chain
= make_cleanup (null_cleanup
, NULL
);
2381 /* If in non-stop, leave threads as running as they were. If
2382 they're stopped for some reason other than us telling it to, the
2383 target reports a signal != TARGET_SIGNAL_0. We don't try to
2384 resume threads with such a stop signal. */
2385 async_exec
= non_stop
;
2387 if (!ptid_equal (inferior_ptid
, null_ptid
))
2388 make_cleanup_restore_current_thread ();
2390 switch_to_thread (ptid
);
2392 /* When we "notice" a new inferior we need to do all the things we
2393 would normally do if we had just attached to it. */
2395 if (is_executing (inferior_ptid
))
2397 struct inferior
*inferior
= current_inferior ();
2399 /* We're going to install breakpoints, and poke at memory,
2400 ensure that the inferior is stopped for a moment while we do
2402 target_stop (inferior_ptid
);
2404 inferior
->stop_soon
= STOP_QUIETLY_REMOTE
;
2406 /* Wait for stop before proceeding. */
2407 if (target_can_async_p ())
2409 struct attach_command_continuation_args
*a
;
2411 a
= xmalloc (sizeof (*a
));
2412 a
->args
= xstrdup ("");
2413 a
->from_tty
= from_tty
;
2414 a
->async_exec
= async_exec
;
2415 add_inferior_continuation (attach_command_continuation
, a
,
2416 attach_command_continuation_free_args
);
2418 do_cleanups (old_chain
);
2422 wait_for_inferior (0);
2425 async_exec
= leave_running
;
2426 attach_command_post_wait ("" /* args */, from_tty
, async_exec
);
2428 do_cleanups (old_chain
);
2433 * takes a program previously attached to and detaches it.
2434 * The program resumes execution and will no longer stop
2435 * on signals, etc. We better not have left any breakpoints
2436 * in the program or it'll die when it hits one. For this
2437 * to work, it may be necessary for the process to have been
2438 * previously attached. It *might* work if the program was
2439 * started via the normal ptrace (PTRACE_TRACEME).
2443 detach_command (char *args
, int from_tty
)
2445 dont_repeat (); /* Not for the faint of heart. */
2447 if (ptid_equal (inferior_ptid
, null_ptid
))
2448 error (_("The program is not being run."));
2450 target_detach (args
, from_tty
);
2452 /* If the solist is global across inferiors, don't clear it when we
2453 detach from a single inferior. */
2454 if (!gdbarch_has_global_solist (target_gdbarch
))
2455 no_shared_libraries (NULL
, from_tty
);
2457 /* If we still have inferiors to debug, then don't mess with their
2459 if (!have_inferiors ())
2460 init_thread_list ();
2462 if (deprecated_detach_hook
)
2463 deprecated_detach_hook ();
2466 /* Disconnect from the current target without resuming it (leaving it
2467 waiting for a debugger).
2469 We'd better not have left any breakpoints in the program or the
2470 next debugger will get confused. Currently only supported for some
2471 remote targets, since the normal attach mechanisms don't work on
2472 stopped processes on some native platforms (e.g. GNU/Linux). */
2475 disconnect_command (char *args
, int from_tty
)
2477 dont_repeat (); /* Not for the faint of heart */
2478 target_disconnect (args
, from_tty
);
2479 no_shared_libraries (NULL
, from_tty
);
2480 init_thread_list ();
2481 if (deprecated_detach_hook
)
2482 deprecated_detach_hook ();
2486 interrupt_target_1 (int all_threads
)
2490 ptid
= minus_one_ptid
;
2492 ptid
= inferior_ptid
;
2495 /* Tag the thread as having been explicitly requested to stop, so
2496 other parts of gdb know not to resume this thread automatically,
2497 if it was stopped due to an internal event. Limit this to
2498 non-stop mode, as when debugging a multi-threaded application in
2499 all-stop mode, we will only get one stop event --- it's undefined
2500 which thread will report the event. */
2502 set_stop_requested (ptid
, 1);
2505 /* Stop the execution of the target while running in async mode, in
2506 the backgound. In all-stop, stop the whole process. In non-stop
2507 mode, stop the current thread only by default, or stop all threads
2508 if the `-a' switch is used. */
2510 /* interrupt [-a] */
2512 interrupt_target_command (char *args
, int from_tty
)
2514 if (target_can_async_p ())
2516 int all_threads
= 0;
2518 dont_repeat (); /* Not for the faint of heart */
2521 && strncmp (args
, "-a", sizeof ("-a") - 1) == 0)
2524 if (!non_stop
&& all_threads
)
2525 error (_("-a is meaningless in all-stop mode."));
2527 interrupt_target_1 (all_threads
);
2532 print_float_info (struct ui_file
*file
,
2533 struct frame_info
*frame
, const char *args
)
2535 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
2537 if (gdbarch_print_float_info_p (gdbarch
))
2538 gdbarch_print_float_info (gdbarch
, file
, frame
, args
);
2542 int printed_something
= 0;
2545 regnum
< gdbarch_num_regs (gdbarch
)
2546 + gdbarch_num_pseudo_regs (gdbarch
);
2549 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, float_reggroup
))
2551 printed_something
= 1;
2552 gdbarch_print_registers_info (gdbarch
, file
, frame
, regnum
, 1);
2555 if (!printed_something
)
2556 fprintf_filtered (file
, "\
2557 No floating-point info available for this processor.\n");
2562 float_info (char *args
, int from_tty
)
2564 if (!target_has_registers
)
2565 error (_("The program has no registers now."));
2567 print_float_info (gdb_stdout
, get_selected_frame (NULL
), args
);
2571 unset_command (char *args
, int from_tty
)
2573 printf_filtered (_("\
2574 \"unset\" must be followed by the name of an unset subcommand.\n"));
2575 help_list (unsetlist
, "unset ", -1, gdb_stdout
);
2579 _initialize_infcmd (void)
2581 struct cmd_list_element
*c
= NULL
;
2583 /* add the filename of the terminal connected to inferior I/O */
2584 add_setshow_filename_cmd ("inferior-tty", class_run
,
2585 &inferior_io_terminal
, _("\
2586 Set terminal for future runs of program being debugged."), _("\
2587 Show terminal for future runs of program being debugged."), _("\
2588 Usage: set inferior-tty /dev/pts/1"), NULL
, NULL
, &setlist
, &showlist
);
2589 add_com_alias ("tty", "set inferior-tty", class_alias
, 0);
2591 add_setshow_optional_filename_cmd ("args", class_run
,
2592 &inferior_args
, _("\
2593 Set argument list to give program being debugged when it is started."), _("\
2594 Show argument list to give program being debugged when it is started."), _("\
2595 Follow this command with any number of args, to be passed to the program."),
2598 &setlist
, &showlist
);
2600 c
= add_cmd ("environment", no_class
, environment_info
, _("\
2601 The environment to give the program, or one variable's value.\n\
2602 With an argument VAR, prints the value of environment variable VAR to\n\
2603 give the program being debugged. With no arguments, prints the entire\n\
2604 environment to be given to the program."), &showlist
);
2605 set_cmd_completer (c
, noop_completer
);
2607 add_prefix_cmd ("unset", no_class
, unset_command
,
2608 _("Complement to certain \"set\" commands."),
2609 &unsetlist
, "unset ", 0, &cmdlist
);
2611 c
= add_cmd ("environment", class_run
, unset_environment_command
, _("\
2612 Cancel environment variable VAR for the program.\n\
2613 This does not affect the program until the next \"run\" command."),
2615 set_cmd_completer (c
, noop_completer
);
2617 c
= add_cmd ("environment", class_run
, set_environment_command
, _("\
2618 Set environment variable value to give the program.\n\
2619 Arguments are VAR VALUE where VAR is variable name and VALUE is value.\n\
2620 VALUES of environment variables are uninterpreted strings.\n\
2621 This does not affect the program until the next \"run\" command."),
2623 set_cmd_completer (c
, noop_completer
);
2625 c
= add_com ("path", class_files
, path_command
, _("\
2626 Add directory DIR(s) to beginning of search path for object files.\n\
2627 $cwd in the path means the current working directory.\n\
2628 This path is equivalent to the $PATH shell variable. It is a list of\n\
2629 directories, separated by colons. These directories are searched to find\n\
2630 fully linked executable files and separately compiled object files as needed."));
2631 set_cmd_completer (c
, filename_completer
);
2633 c
= add_cmd ("paths", no_class
, path_info
, _("\
2634 Current search path for finding object files.\n\
2635 $cwd in the path means the current working directory.\n\
2636 This path is equivalent to the $PATH shell variable. It is a list of\n\
2637 directories, separated by colons. These directories are searched to find\n\
2638 fully linked executable files and separately compiled object files as needed."),
2640 set_cmd_completer (c
, noop_completer
);
2642 add_com ("kill", class_run
, kill_command
,
2643 _("Kill execution of program being debugged."));
2645 add_com ("attach", class_run
, attach_command
, _("\
2646 Attach to a process or file outside of GDB.\n\
2647 This command attaches to another target, of the same type as your last\n\
2648 \"target\" command (\"info files\" will show your target stack).\n\
2649 The command may take as argument a process id or a device file.\n\
2650 For a process id, you must have permission to send the process a signal,\n\
2651 and it must have the same effective uid as the debugger.\n\
2652 When using \"attach\" with a process id, the debugger finds the\n\
2653 program running in the process, looking first in the current working\n\
2654 directory, or (if not found there) using the source file search path\n\
2655 (see the \"directory\" command). You can also use the \"file\" command\n\
2656 to specify the program, and to load its symbol table."));
2658 add_prefix_cmd ("detach", class_run
, detach_command
, _("\
2659 Detach a process or file previously attached.\n\
2660 If a process, it is no longer traced, and it continues its execution. If\n\
2661 you were debugging a file, the file is closed and gdb no longer accesses it."),
2662 &detachlist
, "detach ", 0, &cmdlist
);
2664 add_com ("disconnect", class_run
, disconnect_command
, _("\
2665 Disconnect from a target.\n\
2666 The target will wait for another debugger to connect. Not available for\n\
2669 add_com ("signal", class_run
, signal_command
, _("\
2670 Continue program giving it signal specified by the argument.\n\
2671 An argument of \"0\" means continue program without giving it a signal."));
2673 add_com ("stepi", class_run
, stepi_command
, _("\
2674 Step one instruction exactly.\n\
2675 Argument N means do this N times (or till program stops for another reason)."));
2676 add_com_alias ("si", "stepi", class_alias
, 0);
2678 add_com ("nexti", class_run
, nexti_command
, _("\
2679 Step one instruction, but proceed through subroutine calls.\n\
2680 Argument N means do this N times (or till program stops for another reason)."));
2681 add_com_alias ("ni", "nexti", class_alias
, 0);
2683 add_com ("finish", class_run
, finish_command
, _("\
2684 Execute until selected stack frame returns.\n\
2685 Upon return, the value returned is printed and put in the value history."));
2686 add_com_alias ("fin", "finish", class_run
, 1);
2688 add_com ("next", class_run
, next_command
, _("\
2689 Step program, proceeding through subroutine calls.\n\
2690 Like the \"step\" command as long as subroutine calls do not happen;\n\
2691 when they do, the call is treated as one instruction.\n\
2692 Argument N means do this N times (or till program stops for another reason)."));
2693 add_com_alias ("n", "next", class_run
, 1);
2695 add_com_alias ("S", "next", class_run
, 1);
2697 add_com ("step", class_run
, step_command
, _("\
2698 Step program until it reaches a different source line.\n\
2699 Argument N means do this N times (or till program stops for another reason)."));
2700 add_com_alias ("s", "step", class_run
, 1);
2702 c
= add_com ("until", class_run
, until_command
, _("\
2703 Execute until the program reaches a source line greater than the current\n\
2704 or a specified location (same args as break command) within the current frame."));
2705 set_cmd_completer (c
, location_completer
);
2706 add_com_alias ("u", "until", class_run
, 1);
2708 c
= add_com ("advance", class_run
, advance_command
, _("\
2709 Continue the program up to the given location (same form as args for break command).\n\
2710 Execution will also stop upon exit from the current stack frame."));
2711 set_cmd_completer (c
, location_completer
);
2713 c
= add_com ("jump", class_run
, jump_command
, _("\
2714 Continue program being debugged at specified line or address.\n\
2715 Give as argument either LINENUM or *ADDR, where ADDR is an expression\n\
2716 for an address to start at."));
2717 set_cmd_completer (c
, location_completer
);
2721 c
= add_com ("go", class_run
, go_command
, _("\
2722 Usage: go <location>\n\
2723 Continue program being debugged, stopping at specified line or \n\
2725 Give as argument either LINENUM or *ADDR, where ADDR is an \n\
2726 expression for an address to start at.\n\
2727 This command is a combination of tbreak and jump."));
2728 set_cmd_completer (c
, location_completer
);
2732 add_com_alias ("g", "go", class_run
, 1);
2734 c
= add_com ("continue", class_run
, continue_command
, _("\
2735 Continue program being debugged, after signal or breakpoint.\n\
2736 If proceeding from breakpoint, a number N may be used as an argument,\n\
2737 which means to set the ignore count of that breakpoint to N - 1 (so that\n\
2738 the breakpoint won't break until the Nth time it is reached).\n\
2740 If non-stop mode is enabled, continue only the current thread,\n\
2741 otherwise all the threads in the program are continued. To \n\
2742 continue all stopped threads in non-stop mode, use the -a option.\n\
2743 Specifying -a and an ignore count simultaneously is an error."));
2744 add_com_alias ("c", "cont", class_run
, 1);
2745 add_com_alias ("fg", "cont", class_run
, 1);
2747 c
= add_com ("run", class_run
, run_command
, _("\
2748 Start debugged program. You may specify arguments to give it.\n\
2749 Args may include \"*\", or \"[...]\"; they are expanded using \"sh\".\n\
2750 Input and output redirection with \">\", \"<\", or \">>\" are also allowed.\n\n\
2751 With no arguments, uses arguments last specified (with \"run\" or \"set args\").\n\
2752 To cancel previous arguments and run with no arguments,\n\
2753 use \"set args\" without arguments."));
2754 set_cmd_completer (c
, filename_completer
);
2755 add_com_alias ("r", "run", class_run
, 1);
2757 add_com ("R", class_run
, run_no_args_command
,
2758 _("Start debugged program with no arguments."));
2760 c
= add_com ("start", class_run
, start_command
, _("\
2761 Run the debugged program until the beginning of the main procedure.\n\
2762 You may specify arguments to give to your program, just as with the\n\
2763 \"run\" command."));
2764 set_cmd_completer (c
, filename_completer
);
2766 c
= add_com ("interrupt", class_run
, interrupt_target_command
,
2767 _("Interrupt the execution of the debugged program.\n\
2768 If non-stop mode is enabled, interrupt only the current thread,\n\
2769 otherwise all the threads in the program are stopped. To \n\
2770 interrupt all running threads in non-stop mode, use the -a option."));
2772 add_info ("registers", nofp_registers_info
, _("\
2773 List of integer registers and their contents, for selected stack frame.\n\
2774 Register name as argument means describe only that register."));
2775 add_info_alias ("r", "registers", 1);
2778 add_com ("lr", class_info
, nofp_registers_info
, _("\
2779 List of integer registers and their contents, for selected stack frame.\n\
2780 Register name as argument means describe only that register."));
2781 add_info ("all-registers", all_registers_info
, _("\
2782 List of all registers and their contents, for selected stack frame.\n\
2783 Register name as argument means describe only that register."));
2785 add_info ("program", program_info
,
2786 _("Execution status of the program."));
2788 add_info ("float", float_info
,
2789 _("Print the status of the floating point unit\n"));
2791 add_info ("vector", vector_info
,
2792 _("Print the status of the vector unit\n"));
2794 inferior_environ
= make_environ ();
2795 init_environ (inferior_environ
);