1 /* Memory-access and commands for "inferior" process, for GDB.
3 Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
5 2008 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "gdb_string.h"
38 #include "completer.h"
40 #include "event-top.h"
41 #include "parser-defs.h"
43 #include "reggroups.h"
47 #include "gdb_assert.h"
49 #include "target-descriptions.h"
50 #include "user-regs.h"
51 #include "exceptions.h"
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 detach_command (char *, int);
91 static void disconnect_command (char *, int);
93 static void unset_environment_command (char *, int);
95 static void set_environment_command (char *, int);
97 static void environment_info (char *, int);
99 static void program_info (char *, int);
101 static void finish_command (char *, int);
103 static void signal_command (char *, int);
105 static void jump_command (char *, int);
107 static void step_1 (int, int, char *);
108 static void step_once (int skip_subroutines
, int single_inst
, int count
, int thread
);
110 static void next_command (char *, int);
112 static void step_command (char *, int);
114 static void run_command (char *, int);
116 static void run_no_args_command (char *args
, int from_tty
);
118 static void go_command (char *line_no
, int from_tty
);
120 static int strip_bg_char (char **);
122 void _initialize_infcmd (void);
124 #define ERROR_NO_INFERIOR \
125 if (!target_has_execution) error (_("The program is not being run."));
127 /* String containing arguments to give to the program, separated by spaces.
128 Empty string (pointer to '\0') means no args. */
130 static char *inferior_args
;
132 /* The inferior arguments as a vector. If INFERIOR_ARGC is nonzero,
133 then we must compute INFERIOR_ARGS from this (via the target). */
135 static int inferior_argc
;
136 static char **inferior_argv
;
138 /* File name for default use for standard in/out in the inferior. */
140 static char *inferior_io_terminal
;
142 /* Pid of our debugged inferior, or 0 if no inferior now.
143 Since various parts of infrun.c test this to see whether there is a program
144 being debugged it should be nonzero (currently 3 is used) for remote
147 ptid_t inferior_ptid
;
149 /* Address at which inferior stopped. */
153 /* Flag indicating that a command has proceeded the inferior past the
154 current breakpoint. */
156 int breakpoint_proceeded
;
158 /* Nonzero if stopped due to completion of a stack dummy routine. */
160 int stop_stack_dummy
;
162 /* Nonzero if stopped due to a random (unexpected) signal in inferior
165 int stopped_by_random_signal
;
167 /* Environment to use for running inferior,
168 in format described in environ.h. */
170 struct gdb_environ
*inferior_environ
;
172 /* When set, no calls to target_resumed observer will be made. */
173 int suppress_resume_observer
= 0;
174 /* When set, normal_stop will not call the normal_stop observer. */
175 int suppress_stop_observer
= 0;
177 /* Accessor routines. */
180 set_inferior_io_terminal (const char *terminal_name
)
182 if (inferior_io_terminal
)
183 xfree (inferior_io_terminal
);
186 inferior_io_terminal
= NULL
;
188 inferior_io_terminal
= savestring (terminal_name
, strlen (terminal_name
));
192 get_inferior_io_terminal (void)
194 return inferior_io_terminal
;
198 get_inferior_args (void)
200 if (inferior_argc
!= 0)
204 n
= gdbarch_construct_inferior_arguments (current_gdbarch
,
205 inferior_argc
, inferior_argv
);
206 old
= set_inferior_args (n
);
210 if (inferior_args
== NULL
)
211 inferior_args
= xstrdup ("");
213 return inferior_args
;
217 set_inferior_args (char *newargs
)
219 char *saved_args
= inferior_args
;
221 inferior_args
= newargs
;
229 set_inferior_args_vector (int argc
, char **argv
)
231 inferior_argc
= argc
;
232 inferior_argv
= argv
;
235 /* Notice when `set args' is run. */
237 notice_args_set (char *args
, int from_tty
, struct cmd_list_element
*c
)
243 /* Notice when `show args' is run. */
245 notice_args_read (struct ui_file
*file
, int from_tty
,
246 struct cmd_list_element
*c
, const char *value
)
248 /* Note that we ignore the passed-in value in favor of computing it
250 deprecated_show_value_hack (file
, from_tty
, c
, get_inferior_args ());
254 /* Compute command-line string given argument vector. This does the
255 same shell processing as fork_inferior. */
257 construct_inferior_arguments (struct gdbarch
*gdbarch
, int argc
, char **argv
)
261 if (STARTUP_WITH_SHELL
)
263 /* This holds all the characters considered special to the
264 typical Unix shells. We include `^' because the SunOS
265 /bin/sh treats it as a synonym for `|'. */
266 char *special
= "\"!#$&*()\\|[]{}<>?'\"`~^; \t\n";
271 /* We over-compute the size. It shouldn't matter. */
272 for (i
= 0; i
< argc
; ++i
)
273 length
+= 2 * strlen (argv
[i
]) + 1 + 2 * (argv
[i
][0] == '\0');
275 result
= (char *) xmalloc (length
);
278 for (i
= 0; i
< argc
; ++i
)
283 /* Need to handle empty arguments specially. */
284 if (argv
[i
][0] == '\0')
291 for (cp
= argv
[i
]; *cp
; ++cp
)
293 if (strchr (special
, *cp
) != NULL
)
303 /* In this case we can't handle arguments that contain spaces,
304 tabs, or newlines -- see breakup_args(). */
308 for (i
= 0; i
< argc
; ++i
)
310 char *cp
= strchr (argv
[i
], ' ');
312 cp
= strchr (argv
[i
], '\t');
314 cp
= strchr (argv
[i
], '\n');
316 error (_("can't handle command-line argument containing whitespace"));
317 length
+= strlen (argv
[i
]) + 1;
320 result
= (char *) xmalloc (length
);
322 for (i
= 0; i
< argc
; ++i
)
325 strcat (result
, " ");
326 strcat (result
, argv
[i
]);
334 /* This function detects whether or not a '&' character (indicating
335 background execution) has been added as *the last* of the arguments ARGS
336 of a command. If it has, it removes it and returns 1. Otherwise it
337 does nothing and returns 0. */
339 strip_bg_char (char **args
)
343 p
= strchr (*args
, '&');
347 if (p
== (*args
+ strlen (*args
) - 1))
349 if (strlen (*args
) > 1)
353 while (*p
== ' ' || *p
== '\t');
365 tty_command (char *file
, int from_tty
)
368 error_no_arg (_("terminal name for running target process"));
370 set_inferior_io_terminal (file
);
373 /* Common actions to take after creating any sort of inferior, by any
374 means (running, attaching, connecting, et cetera). The target
375 should be stopped. */
378 post_create_inferior (struct target_ops
*target
, int from_tty
)
380 /* Be sure we own the terminal in case write operations are performed. */
381 target_terminal_ours ();
383 /* If the target hasn't taken care of this already, do it now.
384 Targets which need to access registers during to_open,
385 to_create_inferior, or to_attach should do it earlier; but many
387 target_find_description ();
391 /* Sometimes the platform-specific hook loads initial shared
392 libraries, and sometimes it doesn't. Try to do so first, so
393 that we can add them with the correct value for FROM_TTY.
394 If we made all the inferior hook methods consistent,
395 this call could be removed. */
397 SOLIB_ADD (NULL
, from_tty
, target
, auto_solib_add
);
399 solib_add (NULL
, from_tty
, target
, auto_solib_add
);
402 /* Create the hooks to handle shared library load and unload
404 #ifdef SOLIB_CREATE_INFERIOR_HOOK
405 SOLIB_CREATE_INFERIOR_HOOK (PIDGET (inferior_ptid
));
407 solib_create_inferior_hook ();
411 observer_notify_inferior_created (target
, from_tty
);
414 /* Kill the inferior if already running. This function is designed
415 to be called when we are about to start the execution of the program
416 from the beginning. Ask the user to confirm that he wants to restart
417 the program being debugged when FROM_TTY is non-null. */
420 kill_if_already_running (int from_tty
)
422 if (! ptid_equal (inferior_ptid
, null_ptid
) && target_has_execution
)
424 /* Bail out before killing the program if we will not be able to
426 target_require_runnable ();
429 && !query ("The program being debugged has been started already.\n\
430 Start it from the beginning? "))
431 error (_("Program not restarted."));
436 /* Implement the "run" command. If TBREAK_AT_MAIN is set, then insert
437 a temporary breakpoint at the begining of the main program before
438 running the program. */
441 run_command_1 (char *args
, int from_tty
, int tbreak_at_main
)
447 kill_if_already_running (from_tty
);
449 init_wait_for_inferior ();
450 clear_breakpoint_hit_counts ();
452 /* Clean up any leftovers from other runs. Some other things from
453 this function should probably be moved into target_pre_inferior. */
454 target_pre_inferior (from_tty
);
456 /* The comment here used to read, "The exec file is re-read every
457 time we do a generic_mourn_inferior, so we just have to worry
458 about the symbol file." The `generic_mourn_inferior' function
459 gets called whenever the program exits. However, suppose the
460 program exits, and *then* the executable file changes? We need
461 to check again here. Since reopen_exec_file doesn't do anything
462 if the timestamp hasn't changed, I don't see the harm. */
466 /* Insert the temporary breakpoint if a location was specified. */
468 tbreak_command (main_name (), 0);
470 exec_file
= (char *) get_exec_file (0);
472 if (non_stop
&& !target_supports_non_stop ())
473 error (_("The target does not support running in non-stop mode."));
475 /* We keep symbols from add-symbol-file, on the grounds that the
476 user might want to add some symbols before running the program
477 (right?). But sometimes (dynamic loading where the user manually
478 introduces the new symbols with add-symbol-file), the code which
479 the symbols describe does not persist between runs. Currently
480 the user has to manually nuke all symbols between runs if they
481 want them to go away (PR 2207). This is probably reasonable. */
485 if (target_can_async_p ())
486 async_disable_stdin ();
490 int async_exec
= strip_bg_char (&args
);
492 /* If we get a request for running in the bg but the target
493 doesn't support it, error out. */
494 if (async_exec
&& !target_can_async_p ())
495 error (_("Asynchronous execution not supported on this target."));
497 /* If we don't get a request of running in the bg, then we need
498 to simulate synchronous (fg) execution. */
499 if (!async_exec
&& target_can_async_p ())
501 /* Simulate synchronous execution */
502 async_disable_stdin ();
505 /* If there were other args, beside '&', process them. */
508 char *old_args
= set_inferior_args (xstrdup (args
));
515 ui_out_field_string (uiout
, NULL
, "Starting program");
516 ui_out_text (uiout
, ": ");
518 ui_out_field_string (uiout
, "execfile", exec_file
);
519 ui_out_spaces (uiout
, 1);
520 /* We call get_inferior_args() because we might need to compute
522 ui_out_field_string (uiout
, "infargs", get_inferior_args ());
523 ui_out_text (uiout
, "\n");
524 ui_out_flush (uiout
);
527 /* We call get_inferior_args() because we might need to compute
529 target_create_inferior (exec_file
, get_inferior_args (),
530 environ_vector (inferior_environ
), from_tty
);
532 /* Pass zero for FROM_TTY, because at this point the "run" command
533 has done its thing; now we are setting up the running program. */
534 post_create_inferior (¤t_target
, 0);
536 /* Start the target running. */
537 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_0
, 0);
542 run_command (char *args
, int from_tty
)
544 run_command_1 (args
, from_tty
, 0);
548 run_no_args_command (char *args
, int from_tty
)
550 char *old_args
= set_inferior_args (xstrdup (""));
555 /* Start the execution of the program up until the beginning of the main
559 start_command (char *args
, int from_tty
)
561 /* Some languages such as Ada need to search inside the program
562 minimal symbols for the location where to put the temporary
563 breakpoint before starting. */
564 if (!have_minimal_symbols ())
565 error (_("No symbol table loaded. Use the \"file\" command."));
567 /* Run the program until reaching the main procedure... */
568 run_command_1 (args
, from_tty
, 1);
572 proceed_thread_callback (struct thread_info
*thread
, void *arg
)
574 /* We go through all threads individually instead of compressing
575 into a single target `resume_all' request, because some threads
576 may be stopped in internal breakpoints/events, or stopped waiting
577 for its turn in the displaced stepping queue (that is, they are
578 running && !executing). The target side has no idea about why
579 the thread is stopped, so a `resume_all' command would resume too
580 much. If/when GDB gains a way to tell the target `hold this
581 thread stopped until I say otherwise', then we can optimize
583 if (!is_stopped (thread
->ptid
))
586 switch_to_thread (thread
->ptid
);
587 clear_proceed_status ();
588 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 0);
593 continue_1 (int all_threads
)
597 if (non_stop
&& all_threads
)
599 /* Don't error out if the current thread is running, because
600 there may be other stopped threads. */
601 struct cleanup
*old_chain
;
603 /* Backup current thread and selected frame. */
604 old_chain
= make_cleanup_restore_current_thread ();
606 iterate_over_threads (proceed_thread_callback
, NULL
);
608 /* Restore selected ptid. */
609 do_cleanups (old_chain
);
613 ensure_not_running ();
614 clear_proceed_status ();
615 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 0);
619 /* continue [-a] [proceed-count] [&] */
621 continue_command (char *args
, int from_tty
)
627 /* Find out whether we must run in the background. */
629 async_exec
= strip_bg_char (&args
);
631 /* If we must run in the background, but the target can't do it,
633 if (async_exec
&& !target_can_async_p ())
634 error (_("Asynchronous execution not supported on this target."));
636 /* If we are not asked to run in the bg, then prepare to run in the
637 foreground, synchronously. */
638 if (!async_exec
&& target_can_async_p ())
640 /* Simulate synchronous execution */
641 async_disable_stdin ();
646 if (strncmp (args
, "-a", sizeof ("-a") - 1) == 0)
649 args
+= sizeof ("-a") - 1;
655 if (!non_stop
&& all_threads
)
656 error (_("`-a' is meaningless in all-stop mode."));
658 if (args
!= NULL
&& all_threads
)
660 Can't resume all threads and specify proceed count simultaneously."));
662 /* If we have an argument left, set proceed count of breakpoint we
669 struct thread_info
*tp
;
672 tp
= find_thread_pid (inferior_ptid
);
676 struct target_waitstatus ws
;
678 get_last_target_status (&last_ptid
, &ws
);
679 tp
= find_thread_pid (last_ptid
);
682 bs
= tp
->stop_bpstat
;
684 while ((stat
= bpstat_num (&bs
, &num
)) != 0)
687 set_ignore_count (num
,
688 parse_and_eval_long (args
) - 1,
690 /* set_ignore_count prints a message ending with a period.
691 So print two spaces before "Continuing.". */
693 printf_filtered (" ");
697 if (!stopped
&& from_tty
)
700 ("Not stopped at any breakpoint; argument ignored.\n");
705 printf_filtered (_("Continuing.\n"));
707 continue_1 (all_threads
);
710 /* Step until outside of current statement. */
713 step_command (char *count_string
, int from_tty
)
715 step_1 (0, 0, count_string
);
718 /* Likewise, but skip over subroutine calls as if single instructions. */
721 next_command (char *count_string
, int from_tty
)
723 step_1 (1, 0, count_string
);
726 /* Likewise, but step only one instruction. */
729 stepi_command (char *count_string
, int from_tty
)
731 step_1 (0, 1, count_string
);
735 nexti_command (char *count_string
, int from_tty
)
737 step_1 (1, 1, count_string
);
741 delete_longjmp_breakpoint_cleanup (void *arg
)
743 int thread
= * (int *) arg
;
744 delete_longjmp_breakpoint (thread
);
748 step_1 (int skip_subroutines
, int single_inst
, char *count_string
)
751 struct frame_info
*frame
;
752 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
757 ensure_not_running ();
760 async_exec
= strip_bg_char (&count_string
);
762 /* If we get a request for running in the bg but the target
763 doesn't support it, error out. */
764 if (async_exec
&& !target_can_async_p ())
765 error (_("Asynchronous execution not supported on this target."));
767 /* If we don't get a request of running in the bg, then we need
768 to simulate synchronous (fg) execution. */
769 if (!async_exec
&& target_can_async_p ())
771 /* Simulate synchronous execution */
772 async_disable_stdin ();
775 count
= count_string
? parse_and_eval_long (count_string
) : 1;
777 if (!single_inst
|| skip_subroutines
) /* leave si command alone */
779 if (in_thread_list (inferior_ptid
))
780 thread
= pid_to_thread_id (inferior_ptid
);
782 set_longjmp_breakpoint ();
784 make_cleanup (delete_longjmp_breakpoint_cleanup
, &thread
);
787 /* In synchronous case, all is well, just use the regular for loop. */
788 if (!target_can_async_p ())
790 for (; count
> 0; count
--)
792 struct thread_info
*tp
= inferior_thread ();
793 clear_proceed_status ();
795 frame
= get_current_frame ();
796 tp
->step_frame_id
= get_frame_id (frame
);
800 find_pc_line_pc_range (stop_pc
,
801 &tp
->step_range_start
, &tp
->step_range_end
);
802 if (tp
->step_range_end
== 0)
805 if (find_pc_partial_function (stop_pc
, &name
,
806 &tp
->step_range_start
,
807 &tp
->step_range_end
) == 0)
808 error (_("Cannot find bounds of current function"));
810 target_terminal_ours ();
811 printf_filtered (_("\
812 Single stepping until exit from function %s, \n\
813 which has no line number information.\n"), name
);
818 /* Say we are stepping, but stop after one insn whatever it does. */
819 tp
->step_range_start
= tp
->step_range_end
= 1;
820 if (!skip_subroutines
)
822 Don't step over function calls, not even to functions lacking
824 tp
->step_over_calls
= STEP_OVER_NONE
;
827 if (skip_subroutines
)
828 tp
->step_over_calls
= STEP_OVER_ALL
;
830 tp
->step_multi
= (count
> 1);
831 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 1);
833 if (!target_has_execution
834 || !inferior_thread ()->stop_step
)
838 do_cleanups (cleanups
);
841 /* In case of asynchronous target things get complicated, do only
842 one step for now, before returning control to the event loop. Let
843 the continuation figure out how many other steps we need to do,
844 and handle them one at the time, through step_once(). */
847 step_once (skip_subroutines
, single_inst
, count
, thread
);
848 /* We are running, and the continuation is installed. It will
849 disable the longjmp breakpoint as appropriate. */
850 discard_cleanups (cleanups
);
854 struct step_1_continuation_args
857 int skip_subroutines
;
862 /* Called after we are done with one step operation, to check whether
863 we need to step again, before we print the prompt and return control
864 to the user. If count is > 1, we will need to do one more call to
865 proceed(), via step_once(). Basically it is like step_once and
866 step_1_continuation are co-recursive. */
868 step_1_continuation (void *args
)
870 struct step_1_continuation_args
*a
= args
;
872 if (target_has_execution
)
874 struct thread_info
*tp
;
876 tp
= inferior_thread ();
877 if (tp
->step_multi
&& tp
->stop_step
)
879 /* There are more steps to make, and we did stop due to
880 ending a stepping range. Do another step. */
881 step_once (a
->skip_subroutines
, a
->single_inst
, a
->count
- 1, a
->thread
);
887 /* We either stopped for some reason that is not stepping, or there
888 are no further steps to make. Cleanup. */
889 if (!a
->single_inst
|| a
->skip_subroutines
)
890 delete_longjmp_breakpoint (a
->thread
);
893 /* Do just one step operation. If count >1 we will have to set up a
894 continuation to be done after the target stops (after this one
895 step). This is useful to implement the 'step n' kind of commands, in
896 case of asynchronous targets. We had to split step_1 into two parts,
897 one to be done before proceed() and one afterwards. This function is
898 called in case of step n with n>1, after the first step operation has
901 step_once (int skip_subroutines
, int single_inst
, int count
, int thread
)
903 struct frame_info
*frame
;
904 struct step_1_continuation_args
*args
;
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 if (!frame
) /* Avoid coredump here. Why tho? */
917 error (_("No current frame"));
918 tp
->step_frame_id
= get_frame_id (frame
);
922 find_pc_line_pc_range (stop_pc
,
923 &tp
->step_range_start
, &tp
->step_range_end
);
925 /* If we have no line info, switch to stepi mode. */
926 if (tp
->step_range_end
== 0 && step_stop_if_no_debug
)
928 tp
->step_range_start
= tp
->step_range_end
= 1;
930 else if (tp
->step_range_end
== 0)
933 if (find_pc_partial_function (stop_pc
, &name
,
934 &tp
->step_range_start
,
935 &tp
->step_range_end
) == 0)
936 error (_("Cannot find bounds of current function"));
938 target_terminal_ours ();
939 printf_filtered (_("\
940 Single stepping until exit from function %s, \n\
941 which has no line number information.\n"), name
);
946 /* Say we are stepping, but stop after one insn whatever it does. */
947 tp
->step_range_start
= tp
->step_range_end
= 1;
948 if (!skip_subroutines
)
950 Don't step over function calls, not even to functions lacking
952 tp
->step_over_calls
= STEP_OVER_NONE
;
955 if (skip_subroutines
)
956 tp
->step_over_calls
= STEP_OVER_ALL
;
958 tp
->step_multi
= (count
> 1);
959 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 1);
961 args
= xmalloc (sizeof (*args
));
962 args
->skip_subroutines
= skip_subroutines
;
963 args
->single_inst
= single_inst
;
965 args
->thread
= thread
;
966 add_intermediate_continuation (tp
, step_1_continuation
, args
, xfree
);
971 /* Continue program at specified address. */
974 jump_command (char *arg
, int from_tty
)
977 struct symtabs_and_lines sals
;
978 struct symtab_and_line sal
;
984 ensure_not_running ();
986 /* Find out whether we must run in the background. */
988 async_exec
= strip_bg_char (&arg
);
990 /* If we must run in the background, but the target can't do it,
992 if (async_exec
&& !target_can_async_p ())
993 error (_("Asynchronous execution not supported on this target."));
996 error_no_arg (_("starting address"));
998 sals
= decode_line_spec_1 (arg
, 1);
1001 error (_("Unreasonable jump request"));
1007 if (sal
.symtab
== 0 && sal
.pc
== 0)
1008 error (_("No source file has been specified."));
1010 resolve_sal_pc (&sal
); /* May error out */
1012 /* See if we are trying to jump to another function. */
1013 fn
= get_frame_function (get_current_frame ());
1014 sfn
= find_pc_function (sal
.pc
);
1015 if (fn
!= NULL
&& sfn
!= fn
)
1017 if (!query ("Line %d is not in `%s'. Jump anyway? ", sal
.line
,
1018 SYMBOL_PRINT_NAME (fn
)))
1020 error (_("Not confirmed."));
1027 fixup_symbol_section (sfn
, 0);
1028 if (section_is_overlay (SYMBOL_OBJ_SECTION (sfn
)) &&
1029 !section_is_mapped (SYMBOL_OBJ_SECTION (sfn
)))
1031 if (!query ("WARNING!!! Destination is in unmapped overlay! Jump anyway? "))
1033 error (_("Not confirmed."));
1043 printf_filtered (_("Continuing at "));
1044 fputs_filtered (paddress (addr
), gdb_stdout
);
1045 printf_filtered (".\n");
1048 /* If we are not asked to run in the bg, then prepare to run in the
1049 foreground, synchronously. */
1050 if (!async_exec
&& target_can_async_p ())
1052 /* Simulate synchronous execution */
1053 async_disable_stdin ();
1056 clear_proceed_status ();
1057 proceed (addr
, TARGET_SIGNAL_0
, 0);
1061 /* Go to line or address in current procedure */
1063 go_command (char *line_no
, int from_tty
)
1065 if (line_no
== (char *) NULL
|| !*line_no
)
1066 printf_filtered (_("Usage: go <location>\n"));
1069 tbreak_command (line_no
, from_tty
);
1070 jump_command (line_no
, from_tty
);
1075 /* Continue program giving it specified signal. */
1078 signal_command (char *signum_exp
, int from_tty
)
1080 enum target_signal oursig
;
1083 dont_repeat (); /* Too dangerous. */
1085 ensure_not_running ();
1087 /* Find out whether we must run in the background. */
1088 if (signum_exp
!= NULL
)
1089 async_exec
= strip_bg_char (&signum_exp
);
1091 /* If we must run in the background, but the target can't do it,
1093 if (async_exec
&& !target_can_async_p ())
1094 error (_("Asynchronous execution not supported on this target."));
1096 /* If we are not asked to run in the bg, then prepare to run in the
1097 foreground, synchronously. */
1098 if (!async_exec
&& target_can_async_p ())
1100 /* Simulate synchronous execution. */
1101 async_disable_stdin ();
1105 error_no_arg (_("signal number"));
1107 /* It would be even slicker to make signal names be valid expressions,
1108 (the type could be "enum $signal" or some such), then the user could
1109 assign them to convenience variables. */
1110 oursig
= target_signal_from_name (signum_exp
);
1112 if (oursig
== TARGET_SIGNAL_UNKNOWN
)
1114 /* No, try numeric. */
1115 int num
= parse_and_eval_long (signum_exp
);
1118 oursig
= TARGET_SIGNAL_0
;
1120 oursig
= target_signal_from_command (num
);
1125 if (oursig
== TARGET_SIGNAL_0
)
1126 printf_filtered (_("Continuing with no signal.\n"));
1128 printf_filtered (_("Continuing with signal %s.\n"),
1129 target_signal_to_name (oursig
));
1132 clear_proceed_status ();
1133 /* "signal 0" should not get stuck if we are stopped at a breakpoint.
1134 FIXME: Neither should "signal foo" but when I tried passing
1135 (CORE_ADDR)-1 unconditionally I got a testsuite failure which I haven't
1136 tried to track down yet. */
1137 proceed (oursig
== TARGET_SIGNAL_0
? (CORE_ADDR
) -1 : stop_pc
, oursig
, 0);
1140 /* Proceed until we reach a different source line with pc greater than
1141 our current one or exit the function. We skip calls in both cases.
1143 Note that eventually this command should probably be changed so
1144 that only source lines are printed out when we hit the breakpoint
1145 we set. This may involve changes to wait_for_inferior and the
1146 proceed status code. */
1149 until_next_command (int from_tty
)
1151 struct frame_info
*frame
;
1153 struct symbol
*func
;
1154 struct symtab_and_line sal
;
1155 struct thread_info
*tp
= inferior_thread ();
1157 clear_proceed_status ();
1159 frame
= get_current_frame ();
1161 /* Step until either exited from this function or greater
1162 than the current line (if in symbolic section) or pc (if
1166 func
= find_pc_function (pc
);
1170 struct minimal_symbol
*msymbol
= lookup_minimal_symbol_by_pc (pc
);
1172 if (msymbol
== NULL
)
1173 error (_("Execution is not within a known function."));
1175 tp
->step_range_start
= SYMBOL_VALUE_ADDRESS (msymbol
);
1176 tp
->step_range_end
= pc
;
1180 sal
= find_pc_line (pc
, 0);
1182 tp
->step_range_start
= BLOCK_START (SYMBOL_BLOCK_VALUE (func
));
1183 tp
->step_range_end
= sal
.end
;
1186 tp
->step_over_calls
= STEP_OVER_ALL
;
1187 tp
->step_frame_id
= get_frame_id (frame
);
1189 tp
->step_multi
= 0; /* Only one call to proceed */
1191 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 1);
1195 until_command (char *arg
, int from_tty
)
1199 if (!target_has_execution
)
1200 error (_("The program is not running."));
1202 /* Find out whether we must run in the background. */
1204 async_exec
= strip_bg_char (&arg
);
1206 /* If we must run in the background, but the target can't do it,
1208 if (async_exec
&& !target_can_async_p ())
1209 error (_("Asynchronous execution not supported on this target."));
1211 /* If we are not asked to run in the bg, then prepare to run in the
1212 foreground, synchronously. */
1213 if (!async_exec
&& target_can_async_p ())
1215 /* Simulate synchronous execution */
1216 async_disable_stdin ();
1220 until_break_command (arg
, from_tty
, 0);
1222 until_next_command (from_tty
);
1226 advance_command (char *arg
, int from_tty
)
1230 if (!target_has_execution
)
1231 error (_("The program is not running."));
1234 error_no_arg (_("a location"));
1236 /* Find out whether we must run in the background. */
1238 async_exec
= strip_bg_char (&arg
);
1240 /* If we must run in the background, but the target can't do it,
1242 if (async_exec
&& !target_can_async_p ())
1243 error (_("Asynchronous execution not supported on this target."));
1245 /* If we are not asked to run in the bg, then prepare to run in the
1246 foreground, synchronously. */
1247 if (!async_exec
&& target_can_async_p ())
1249 /* Simulate synchronous execution. */
1250 async_disable_stdin ();
1253 until_break_command (arg
, from_tty
, 1);
1256 /* Print the result of a function at the end of a 'finish' command. */
1259 print_return_value (struct type
*func_type
, struct type
*value_type
)
1261 struct gdbarch
*gdbarch
= current_gdbarch
;
1262 struct cleanup
*old_chain
;
1263 struct ui_stream
*stb
;
1264 struct value
*value
;
1266 CHECK_TYPEDEF (value_type
);
1267 gdb_assert (TYPE_CODE (value_type
) != TYPE_CODE_VOID
);
1269 /* FIXME: 2003-09-27: When returning from a nested inferior function
1270 call, it's possible (with no help from the architecture vector)
1271 to locate and return/print a "struct return" value. This is just
1272 a more complicated case of what is already being done in in the
1273 inferior function call code. In fact, when inferior function
1274 calls are made async, this will likely be made the norm. */
1276 switch (gdbarch_return_value (gdbarch
, func_type
, value_type
,
1279 case RETURN_VALUE_REGISTER_CONVENTION
:
1280 case RETURN_VALUE_ABI_RETURNS_ADDRESS
:
1281 case RETURN_VALUE_ABI_PRESERVES_ADDRESS
:
1282 value
= allocate_value (value_type
);
1283 gdbarch_return_value (gdbarch
, func_type
, value_type
, stop_registers
,
1284 value_contents_raw (value
), NULL
);
1286 case RETURN_VALUE_STRUCT_CONVENTION
:
1290 internal_error (__FILE__
, __LINE__
, _("bad switch"));
1295 struct value_print_options opts
;
1298 stb
= ui_out_stream_new (uiout
);
1299 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
1300 ui_out_text (uiout
, "Value returned is ");
1301 ui_out_field_fmt (uiout
, "gdb-result-var", "$%d",
1302 record_latest_value (value
));
1303 ui_out_text (uiout
, " = ");
1304 get_raw_print_options (&opts
);
1305 value_print (value
, stb
->stream
, &opts
);
1306 ui_out_field_stream (uiout
, "return-value", stb
);
1307 ui_out_text (uiout
, "\n");
1308 do_cleanups (old_chain
);
1312 ui_out_text (uiout
, "Value returned has type: ");
1313 ui_out_field_string (uiout
, "return-type", TYPE_NAME (value_type
));
1314 ui_out_text (uiout
, ".");
1315 ui_out_text (uiout
, " Cannot determine contents\n");
1319 /* Stuff that needs to be done by the finish command after the target
1320 has stopped. In asynchronous mode, we wait for the target to stop
1321 in the call to poll or select in the event loop, so it is
1322 impossible to do all the stuff as part of the finish_command
1323 function itself. The only chance we have to complete this command
1324 is in fetch_inferior_event, which is called by the event loop as
1325 soon as it detects that the target has stopped. This function is
1326 called via the cmd_continuation pointer. */
1328 struct finish_command_continuation_args
1330 struct breakpoint
*breakpoint
;
1331 struct symbol
*function
;
1335 finish_command_continuation (void *arg
)
1337 struct finish_command_continuation_args
*a
= arg
;
1341 if (!ptid_equal (inferior_ptid
, null_ptid
)
1342 && target_has_execution
1343 && is_stopped (inferior_ptid
))
1344 bs
= inferior_thread ()->stop_bpstat
;
1346 if (bpstat_find_breakpoint (bs
, a
->breakpoint
) != NULL
1347 && a
->function
!= NULL
)
1349 struct type
*value_type
;
1351 value_type
= TYPE_TARGET_TYPE (SYMBOL_TYPE (a
->function
));
1353 internal_error (__FILE__
, __LINE__
,
1354 _("finish_command: function has no target type"));
1356 if (TYPE_CODE (value_type
) != TYPE_CODE_VOID
)
1357 print_return_value (SYMBOL_TYPE (a
->function
), value_type
);
1360 /* We suppress normal call of normal_stop observer and do it here so
1361 that that *stopped notification includes the return value. */
1362 /* NOTE: This is broken in non-stop mode. There is no guarantee the
1363 next stop will be in the same thread that we started doing a
1364 finish on. This suppressing (or some other replacement means)
1365 should be a thread property. */
1366 observer_notify_normal_stop (bs
);
1367 suppress_stop_observer
= 0;
1368 delete_breakpoint (a
->breakpoint
);
1372 finish_command_continuation_free_arg (void *arg
)
1374 /* NOTE: See finish_command_continuation. This would go away, if
1375 this suppressing is made a thread property. */
1376 suppress_stop_observer
= 0;
1380 /* finish_backward -- helper function for finish_command. */
1383 finish_backward (struct symbol
*function
)
1385 struct symtab_and_line sal
;
1386 struct thread_info
*tp
= inferior_thread ();
1387 struct breakpoint
*breakpoint
;
1388 struct cleanup
*old_chain
;
1389 CORE_ADDR func_addr
;
1392 if (find_pc_partial_function (get_frame_pc (get_current_frame ()),
1393 NULL
, &func_addr
, NULL
) == 0)
1394 internal_error (__FILE__
, __LINE__
,
1395 _("Finish: couldn't find function."));
1397 sal
= find_pc_line (func_addr
, 0);
1399 /* We don't need a return value. */
1400 tp
->proceed_to_finish
= 0;
1401 /* Special case: if we're sitting at the function entry point,
1402 then all we need to do is take a reverse singlestep. We
1403 don't need to set a breakpoint, and indeed it would do us
1406 Note that this can only happen at frame #0, since there's
1407 no way that a function up the stack can have a return address
1408 that's equal to its entry point. */
1410 if (sal
.pc
!= read_pc ())
1412 /* Set breakpoint and continue. */
1414 set_momentary_breakpoint (sal
,
1415 get_frame_id (get_selected_frame (NULL
)),
1417 /* Tell the breakpoint to keep quiet. We won't be done
1418 until we've done another reverse single-step. */
1419 make_breakpoint_silent (breakpoint
);
1420 old_chain
= make_cleanup_delete_breakpoint (breakpoint
);
1421 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 0);
1422 /* We will be stopped when proceed returns. */
1423 back_up
= bpstat_find_breakpoint (tp
->stop_bpstat
, breakpoint
) != NULL
;
1424 do_cleanups (old_chain
);
1430 /* If in fact we hit the step-resume breakpoint (and not
1431 some other breakpoint), then we're almost there --
1432 we just need to back up by one more single-step. */
1433 tp
->step_range_start
= tp
->step_range_end
= 1;
1434 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 1);
1439 /* finish_forward -- helper function for finish_command. */
1442 finish_forward (struct symbol
*function
, struct frame_info
*frame
)
1444 struct symtab_and_line sal
;
1445 struct thread_info
*tp
= inferior_thread ();
1446 struct breakpoint
*breakpoint
;
1447 struct cleanup
*old_chain
;
1448 struct finish_command_continuation_args
*cargs
;
1450 sal
= find_pc_line (get_frame_pc (frame
), 0);
1451 sal
.pc
= get_frame_pc (frame
);
1453 breakpoint
= set_momentary_breakpoint (sal
, get_frame_id (frame
),
1456 old_chain
= make_cleanup_delete_breakpoint (breakpoint
);
1458 tp
->proceed_to_finish
= 1; /* We want stop_registers, please... */
1459 make_cleanup_restore_integer (&suppress_stop_observer
);
1460 suppress_stop_observer
= 1;
1461 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 0);
1463 cargs
= xmalloc (sizeof (*cargs
));
1465 cargs
->breakpoint
= breakpoint
;
1466 cargs
->function
= function
;
1467 add_continuation (tp
, finish_command_continuation
, cargs
,
1468 finish_command_continuation_free_arg
);
1470 discard_cleanups (old_chain
);
1471 if (!target_can_async_p ())
1472 do_all_continuations ();
1475 /* "finish": Set a temporary breakpoint at the place the selected
1476 frame will return to, then continue. */
1479 finish_command (char *arg
, int from_tty
)
1481 struct frame_info
*frame
;
1482 struct symbol
*function
;
1486 /* Find out whether we must run in the background. */
1488 async_exec
= strip_bg_char (&arg
);
1490 /* If we must run in the background, but the target can't do it,
1492 if (async_exec
&& !target_can_async_p ())
1493 error (_("Asynchronous execution not supported on this target."));
1495 /* Don't try to async in reverse. */
1496 if (async_exec
&& execution_direction
== EXEC_REVERSE
)
1497 error (_("Asynchronous 'finish' not supported in reverse."));
1499 /* If we are not asked to run in the bg, then prepare to run in the
1500 foreground, synchronously. */
1501 if (!async_exec
&& target_can_async_p ())
1503 /* Simulate synchronous execution. */
1504 async_disable_stdin ();
1508 error (_("The \"finish\" command does not take any arguments."));
1509 if (!target_has_execution
)
1510 error (_("The program is not running."));
1512 frame
= get_prev_frame (get_selected_frame (_("No selected frame.")));
1514 error (_("\"finish\" not meaningful in the outermost frame."));
1516 clear_proceed_status ();
1518 /* Find the function we will return from. */
1520 function
= find_pc_function (get_frame_pc (get_selected_frame (NULL
)));
1522 /* Print info on the selected frame, including level number but not
1526 if (execution_direction
== EXEC_REVERSE
)
1527 printf_filtered (_("Run back to call of "));
1529 printf_filtered (_("Run till exit from "));
1531 print_stack_frame (get_selected_frame (NULL
), 1, LOCATION
);
1534 if (execution_direction
== EXEC_REVERSE
)
1535 finish_backward (function
);
1537 finish_forward (function
, frame
);
1542 program_info (char *args
, int from_tty
)
1546 struct thread_info
*tp
;
1549 if (!target_has_execution
)
1551 printf_filtered (_("The program being debugged is not being run.\n"));
1556 ptid
= inferior_ptid
;
1559 struct target_waitstatus ws
;
1560 get_last_target_status (&ptid
, &ws
);
1563 if (ptid_equal (ptid
, null_ptid
) || is_exited (ptid
))
1564 error (_("Invalid selected thread."));
1565 else if (is_running (ptid
))
1566 error (_("Selected thread is running."));
1568 tp
= find_thread_pid (ptid
);
1569 bs
= tp
->stop_bpstat
;
1570 stat
= bpstat_num (&bs
, &num
);
1572 target_files_info ();
1573 printf_filtered (_("Program stopped at %s.\n"),
1574 hex_string ((unsigned long) stop_pc
));
1576 printf_filtered (_("It stopped after being stepped.\n"));
1579 /* There may be several breakpoints in the same place, so this
1580 isn't as strange as it seems. */
1585 printf_filtered (_("\
1586 It stopped at a breakpoint that has since been deleted.\n"));
1589 printf_filtered (_("It stopped at breakpoint %d.\n"), num
);
1590 stat
= bpstat_num (&bs
, &num
);
1593 else if (tp
->stop_signal
!= TARGET_SIGNAL_0
)
1595 printf_filtered (_("It stopped with signal %s, %s.\n"),
1596 target_signal_to_name (tp
->stop_signal
),
1597 target_signal_to_string (tp
->stop_signal
));
1602 printf_filtered (_("\
1603 Type \"info stack\" or \"info registers\" for more information.\n"));
1608 environment_info (char *var
, int from_tty
)
1612 char *val
= get_in_environ (inferior_environ
, var
);
1615 puts_filtered (var
);
1616 puts_filtered (" = ");
1617 puts_filtered (val
);
1618 puts_filtered ("\n");
1622 puts_filtered ("Environment variable \"");
1623 puts_filtered (var
);
1624 puts_filtered ("\" not defined.\n");
1629 char **vector
= environ_vector (inferior_environ
);
1632 puts_filtered (*vector
++);
1633 puts_filtered ("\n");
1639 set_environment_command (char *arg
, int from_tty
)
1641 char *p
, *val
, *var
;
1645 error_no_arg (_("environment variable and value"));
1647 /* Find seperation between variable name and value */
1648 p
= (char *) strchr (arg
, '=');
1649 val
= (char *) strchr (arg
, ' ');
1651 if (p
!= 0 && val
!= 0)
1653 /* We have both a space and an equals. If the space is before the
1654 equals, walk forward over the spaces til we see a nonspace
1655 (possibly the equals). */
1660 /* Now if the = is after the char following the spaces,
1661 take the char following the spaces. */
1665 else if (val
!= 0 && p
== 0)
1669 error_no_arg (_("environment variable to set"));
1671 if (p
== 0 || p
[1] == 0)
1675 p
= arg
+ strlen (arg
); /* So that savestring below will work */
1679 /* Not setting variable value to null */
1681 while (*val
== ' ' || *val
== '\t')
1685 while (p
!= arg
&& (p
[-1] == ' ' || p
[-1] == '\t'))
1688 var
= savestring (arg
, p
- arg
);
1691 printf_filtered (_("\
1692 Setting environment variable \"%s\" to null value.\n"),
1694 set_in_environ (inferior_environ
, var
, "");
1697 set_in_environ (inferior_environ
, var
, val
);
1702 unset_environment_command (char *var
, int from_tty
)
1706 /* If there is no argument, delete all environment variables.
1707 Ask for confirmation if reading from the terminal. */
1708 if (!from_tty
|| query (_("Delete all environment variables? ")))
1710 free_environ (inferior_environ
);
1711 inferior_environ
= make_environ ();
1715 unset_in_environ (inferior_environ
, var
);
1718 /* Handle the execution path (PATH variable) */
1720 static const char path_var_name
[] = "PATH";
1723 path_info (char *args
, int from_tty
)
1725 puts_filtered ("Executable and object file path: ");
1726 puts_filtered (get_in_environ (inferior_environ
, path_var_name
));
1727 puts_filtered ("\n");
1730 /* Add zero or more directories to the front of the execution path. */
1733 path_command (char *dirname
, int from_tty
)
1738 env
= get_in_environ (inferior_environ
, path_var_name
);
1739 /* Can be null if path is not set */
1742 exec_path
= xstrdup (env
);
1743 mod_path (dirname
, &exec_path
);
1744 set_in_environ (inferior_environ
, path_var_name
, exec_path
);
1747 path_info ((char *) NULL
, from_tty
);
1751 /* Print out the machine register regnum. If regnum is -1, print all
1752 registers (print_all == 1) or all non-float and non-vector
1753 registers (print_all == 0).
1755 For most machines, having all_registers_info() print the
1756 register(s) one per line is good enough. If a different format is
1757 required, (eg, for MIPS or Pyramid 90x, which both have lots of
1758 regs), or there is an existing convention for showing all the
1759 registers, define the architecture method PRINT_REGISTERS_INFO to
1760 provide that format. */
1763 default_print_registers_info (struct gdbarch
*gdbarch
,
1764 struct ui_file
*file
,
1765 struct frame_info
*frame
,
1766 int regnum
, int print_all
)
1769 const int numregs
= gdbarch_num_regs (gdbarch
)
1770 + gdbarch_num_pseudo_regs (gdbarch
);
1771 gdb_byte buffer
[MAX_REGISTER_SIZE
];
1773 for (i
= 0; i
< numregs
; i
++)
1775 /* Decide between printing all regs, non-float / vector regs, or
1781 if (!gdbarch_register_reggroup_p (gdbarch
, i
, all_reggroup
))
1786 if (!gdbarch_register_reggroup_p (gdbarch
, i
, general_reggroup
))
1796 /* If the register name is empty, it is undefined for this
1797 processor, so don't display anything. */
1798 if (gdbarch_register_name (gdbarch
, i
) == NULL
1799 || *(gdbarch_register_name (gdbarch
, i
)) == '\0')
1802 fputs_filtered (gdbarch_register_name (gdbarch
, i
), file
);
1803 print_spaces_filtered (15 - strlen (gdbarch_register_name
1804 (gdbarch
, i
)), file
);
1806 /* Get the data in raw format. */
1807 if (! frame_register_read (frame
, i
, buffer
))
1809 fprintf_filtered (file
, "*value not available*\n");
1813 /* If virtual format is floating, print it that way, and in raw
1815 if (TYPE_CODE (register_type (gdbarch
, i
)) == TYPE_CODE_FLT
1816 || TYPE_CODE (register_type (gdbarch
, i
)) == TYPE_CODE_DECFLOAT
)
1819 struct value_print_options opts
;
1821 get_user_print_options (&opts
);
1823 val_print (register_type (gdbarch
, i
), buffer
, 0, 0,
1824 file
, 0, &opts
, current_language
);
1826 fprintf_filtered (file
, "\t(raw 0x");
1827 for (j
= 0; j
< register_size (gdbarch
, i
); j
++)
1830 if (gdbarch_byte_order (gdbarch
) == BFD_ENDIAN_BIG
)
1833 idx
= register_size (gdbarch
, i
) - 1 - j
;
1834 fprintf_filtered (file
, "%02x", (unsigned char) buffer
[idx
]);
1836 fprintf_filtered (file
, ")");
1840 struct value_print_options opts
;
1842 /* Print the register in hex. */
1843 get_formatted_print_options (&opts
, 'x');
1845 val_print (register_type (gdbarch
, i
), buffer
, 0, 0,
1848 /* If not a vector register, print it also according to its
1850 if (TYPE_VECTOR (register_type (gdbarch
, i
)) == 0)
1852 get_user_print_options (&opts
);
1854 fprintf_filtered (file
, "\t");
1855 val_print (register_type (gdbarch
, i
), buffer
, 0, 0,
1856 file
, 0, &opts
, current_language
);
1860 fprintf_filtered (file
, "\n");
1865 registers_info (char *addr_exp
, int fpregs
)
1867 struct frame_info
*frame
;
1868 struct gdbarch
*gdbarch
;
1869 int regnum
, numregs
;
1872 if (!target_has_registers
)
1873 error (_("The program has no registers now."));
1874 frame
= get_selected_frame (NULL
);
1875 gdbarch
= get_frame_arch (frame
);
1879 gdbarch_print_registers_info (gdbarch
, gdb_stdout
,
1884 while (*addr_exp
!= '\0')
1889 /* Keep skipping leading white space. */
1890 if (isspace ((*addr_exp
)))
1896 /* Discard any leading ``$''. Check that there is something
1897 resembling a register following it. */
1898 if (addr_exp
[0] == '$')
1900 if (isspace ((*addr_exp
)) || (*addr_exp
) == '\0')
1901 error (_("Missing register name"));
1903 /* Find the start/end of this register name/num/group. */
1905 while ((*addr_exp
) != '\0' && !isspace ((*addr_exp
)))
1909 /* Figure out what we've found and display it. */
1911 /* A register name? */
1913 int regnum
= user_reg_map_name_to_regnum (gdbarch
, start
, end
- start
);
1916 /* User registers lie completely outside of the range of
1917 normal registers. Catch them early so that the target
1919 if (regnum
>= gdbarch_num_regs (gdbarch
)
1920 + gdbarch_num_pseudo_regs (gdbarch
))
1922 struct value_print_options opts
;
1923 struct value
*val
= value_of_user_reg (regnum
, frame
);
1925 printf_filtered ("%s: ", start
);
1926 get_formatted_print_options (&opts
, 'x');
1927 print_scalar_formatted (value_contents (val
),
1928 check_typedef (value_type (val
)),
1929 &opts
, 0, gdb_stdout
);
1930 printf_filtered ("\n");
1933 gdbarch_print_registers_info (gdbarch
, gdb_stdout
,
1934 frame
, regnum
, fpregs
);
1939 /* A register number? (how portable is this one?). */
1942 int regnum
= strtol (start
, &endptr
, 0);
1945 && regnum
< gdbarch_num_regs (gdbarch
)
1946 + gdbarch_num_pseudo_regs (gdbarch
))
1948 gdbarch_print_registers_info (gdbarch
, gdb_stdout
,
1949 frame
, regnum
, fpregs
);
1954 /* A register group? */
1956 struct reggroup
*group
;
1957 for (group
= reggroup_next (gdbarch
, NULL
);
1959 group
= reggroup_next (gdbarch
, group
))
1961 /* Don't bother with a length check. Should the user
1962 enter a short register group name, go with the first
1963 group that matches. */
1964 if (strncmp (start
, reggroup_name (group
), end
- start
) == 0)
1971 regnum
< gdbarch_num_regs (gdbarch
)
1972 + gdbarch_num_pseudo_regs (gdbarch
);
1975 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, group
))
1976 gdbarch_print_registers_info (gdbarch
,
1984 /* Nothing matched. */
1985 error (_("Invalid register `%.*s'"), (int) (end
- start
), start
);
1990 all_registers_info (char *addr_exp
, int from_tty
)
1992 registers_info (addr_exp
, 1);
1996 nofp_registers_info (char *addr_exp
, int from_tty
)
1998 registers_info (addr_exp
, 0);
2002 print_vector_info (struct gdbarch
*gdbarch
, struct ui_file
*file
,
2003 struct frame_info
*frame
, const char *args
)
2005 if (gdbarch_print_vector_info_p (gdbarch
))
2006 gdbarch_print_vector_info (gdbarch
, file
, frame
, args
);
2010 int printed_something
= 0;
2013 regnum
< gdbarch_num_regs (gdbarch
)
2014 + gdbarch_num_pseudo_regs (gdbarch
);
2017 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, vector_reggroup
))
2019 printed_something
= 1;
2020 gdbarch_print_registers_info (gdbarch
, file
, frame
, regnum
, 1);
2023 if (!printed_something
)
2024 fprintf_filtered (file
, "No vector information\n");
2029 vector_info (char *args
, int from_tty
)
2031 if (!target_has_registers
)
2032 error (_("The program has no registers now."));
2034 print_vector_info (current_gdbarch
, gdb_stdout
,
2035 get_selected_frame (NULL
), args
);
2039 /* Used in `attach&' command. ARG is a point to an integer
2040 representing a process id. Proceed threads of this process iff
2041 they stopped due to debugger request, and when they did, they
2042 reported a clean stop (TARGET_SIGNAL_0). Do not proceed threads
2043 that have been explicitly been told to stop. */
2046 proceed_after_attach_callback (struct thread_info
*thread
,
2049 int pid
= * (int *) arg
;
2051 if (ptid_get_pid (thread
->ptid
) == pid
2052 && !is_exited (thread
->ptid
)
2053 && !is_executing (thread
->ptid
)
2054 && !thread
->stop_requested
2055 && thread
->stop_signal
== TARGET_SIGNAL_0
)
2057 switch_to_thread (thread
->ptid
);
2058 clear_proceed_status ();
2059 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 0);
2066 proceed_after_attach (int pid
)
2068 /* Don't error out if the current thread is running, because
2069 there may be other stopped threads. */
2070 struct cleanup
*old_chain
;
2072 /* Backup current thread and selected frame. */
2073 old_chain
= make_cleanup_restore_current_thread ();
2075 iterate_over_threads (proceed_after_attach_callback
, &pid
);
2077 /* Restore selected ptid. */
2078 do_cleanups (old_chain
);
2083 * Should save/restore the tty state since it might be that the
2084 * program to be debugged was started on this tty and it wants
2085 * the tty in some state other than what we want. If it's running
2086 * on another terminal or without a terminal, then saving and
2087 * restoring the tty state is a harmless no-op.
2088 * This only needs to be done if we are attaching to a process.
2093 takes a program started up outside of gdb and ``attaches'' to it.
2094 This stops it cold in its tracks and allows us to start debugging it.
2095 and wait for the trace-trap that results from attaching. */
2098 attach_command_post_wait (char *args
, int from_tty
, int async_exec
)
2101 char *full_exec_path
= NULL
;
2102 struct inferior
*inferior
;
2104 inferior
= current_inferior ();
2105 inferior
->stop_soon
= NO_STOP_QUIETLY
;
2107 /* If no exec file is yet known, try to determine it from the
2109 exec_file
= (char *) get_exec_file (0);
2112 exec_file
= target_pid_to_exec_file (PIDGET (inferior_ptid
));
2115 /* It's possible we don't have a full path, but rather just a
2116 filename. Some targets, such as HP-UX, don't provide the
2119 Attempt to qualify the filename against the source path.
2120 (If that fails, we'll just fall back on the original
2121 filename. Not much more we can do...)
2123 if (!source_full_path_of (exec_file
, &full_exec_path
))
2124 full_exec_path
= savestring (exec_file
, strlen (exec_file
));
2126 exec_file_attach (full_exec_path
, from_tty
);
2127 symbol_file_add_main (full_exec_path
, from_tty
);
2132 reopen_exec_file ();
2136 /* Take any necessary post-attaching actions for this platform. */
2137 target_post_attach (PIDGET (inferior_ptid
));
2139 post_create_inferior (¤t_target
, from_tty
);
2141 /* Install inferior's terminal modes. */
2142 target_terminal_inferior ();
2146 /* The user requested an `attach&', so be sure to leave threads
2147 that didn't get a signal running. */
2149 /* Immediatelly resume all suspended threads of this inferior,
2150 and this inferior only. This should have no effect on
2151 already running threads. If a thread has been stopped with a
2152 signal, leave it be. */
2154 proceed_after_attach (inferior
->pid
);
2157 if (inferior_thread ()->stop_signal
== TARGET_SIGNAL_0
)
2159 clear_proceed_status ();
2160 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_DEFAULT
, 0);
2166 /* The user requested a plain `attach', so be sure to leave
2167 the inferior stopped. */
2169 if (target_can_async_p ())
2170 async_enable_stdin ();
2172 /* At least the current thread is already stopped. */
2174 /* In all-stop, by definition, all threads have to be already
2175 stopped at this point. In non-stop, however, although the
2176 selected thread is stopped, others may still be executing.
2177 Be sure to explicitly stop all threads of the process. This
2178 should have no effect on already stopped threads. */
2180 target_stop (pid_to_ptid (inferior
->pid
));
2182 /* Tell the user/frontend where we're stopped. */
2184 if (deprecated_attach_hook
)
2185 deprecated_attach_hook ();
2189 struct attach_command_continuation_args
2197 attach_command_continuation (void *args
)
2199 struct attach_command_continuation_args
*a
= args
;
2200 attach_command_post_wait (a
->args
, a
->from_tty
, a
->async_exec
);
2204 attach_command_continuation_free_args (void *args
)
2206 struct attach_command_continuation_args
*a
= args
;
2212 attach_command (char *args
, int from_tty
)
2215 char *full_exec_path
= NULL
;
2218 dont_repeat (); /* Not for the faint of heart */
2220 if (target_supports_multi_process ())
2221 /* Don't complain if we can be attached to multiple processes. */
2223 else if (target_has_execution
)
2225 if (query ("A program is being debugged already. Kill it? "))
2228 error (_("Not killed."));
2231 /* Clean up any leftovers from other runs. Some other things from
2232 this function should probably be moved into target_pre_inferior. */
2233 target_pre_inferior (from_tty
);
2235 if (non_stop
&& !target_supports_non_stop ())
2236 error (_("Cannot attach to this target in non-stop mode"));
2240 async_exec
= strip_bg_char (&args
);
2242 /* If we get a request for running in the bg but the target
2243 doesn't support it, error out. */
2244 if (async_exec
&& !target_can_async_p ())
2245 error (_("Asynchronous execution not supported on this target."));
2248 /* If we don't get a request of running in the bg, then we need
2249 to simulate synchronous (fg) execution. */
2250 if (!async_exec
&& target_can_async_p ())
2252 /* Simulate synchronous execution */
2253 async_disable_stdin ();
2256 target_attach (args
, from_tty
);
2258 /* Set up the "saved terminal modes" of the inferior
2259 based on what modes we are starting it with. */
2260 target_terminal_init ();
2262 /* Set up execution context to know that we should return from
2263 wait_for_inferior as soon as the target reports a stop. */
2264 init_wait_for_inferior ();
2265 clear_proceed_status ();
2269 /* If we find that the current thread isn't stopped, explicitly
2270 do so now, because we're going to install breakpoints and
2274 /* The user requested an `attach&'; stop just one thread. */
2275 target_stop (inferior_ptid
);
2277 /* The user requested an `attach', so stop all threads of this
2279 target_stop (pid_to_ptid (ptid_get_pid (inferior_ptid
)));
2282 /* Some system don't generate traps when attaching to inferior.
2283 E.g. Mach 3 or GNU hurd. */
2284 if (!target_attach_no_wait
)
2286 struct inferior
*inferior
= current_inferior ();
2288 /* Careful here. See comments in inferior.h. Basically some
2289 OSes don't ignore SIGSTOPs on continue requests anymore. We
2290 need a way for handle_inferior_event to reset the stop_signal
2291 variable after an attach, and this is what
2292 STOP_QUIETLY_NO_SIGSTOP is for. */
2293 inferior
->stop_soon
= STOP_QUIETLY_NO_SIGSTOP
;
2295 if (target_can_async_p ())
2297 /* sync_execution mode. Wait for stop. */
2298 struct attach_command_continuation_args
*a
;
2300 a
= xmalloc (sizeof (*a
));
2301 a
->args
= xstrdup (args
);
2302 a
->from_tty
= from_tty
;
2303 a
->async_exec
= async_exec
;
2304 add_continuation (inferior_thread (),
2305 attach_command_continuation
, a
,
2306 attach_command_continuation_free_args
);
2310 wait_for_inferior (0);
2313 attach_command_post_wait (args
, from_tty
, async_exec
);
2318 * takes a program previously attached to and detaches it.
2319 * The program resumes execution and will no longer stop
2320 * on signals, etc. We better not have left any breakpoints
2321 * in the program or it'll die when it hits one. For this
2322 * to work, it may be necessary for the process to have been
2323 * previously attached. It *might* work if the program was
2324 * started via the normal ptrace (PTRACE_TRACEME).
2328 detach_command (char *args
, int from_tty
)
2330 dont_repeat (); /* Not for the faint of heart. */
2331 target_detach (args
, from_tty
);
2332 no_shared_libraries (NULL
, from_tty
);
2334 /* If the current target interface claims there's still execution,
2335 then don't mess with threads of other processes. */
2336 if (!target_has_execution
)
2337 init_thread_list ();
2339 if (deprecated_detach_hook
)
2340 deprecated_detach_hook ();
2343 /* Disconnect from the current target without resuming it (leaving it
2344 waiting for a debugger).
2346 We'd better not have left any breakpoints in the program or the
2347 next debugger will get confused. Currently only supported for some
2348 remote targets, since the normal attach mechanisms don't work on
2349 stopped processes on some native platforms (e.g. GNU/Linux). */
2352 disconnect_command (char *args
, int from_tty
)
2354 dont_repeat (); /* Not for the faint of heart */
2355 target_disconnect (args
, from_tty
);
2356 no_shared_libraries (NULL
, from_tty
);
2357 init_thread_list ();
2358 if (deprecated_detach_hook
)
2359 deprecated_detach_hook ();
2363 interrupt_target_1 (int all_threads
)
2367 ptid
= minus_one_ptid
;
2369 ptid
= inferior_ptid
;
2372 /* Tag the thread as having been explicitly requested to stop, so
2373 other parts of gdb know not to resume this thread automatically,
2374 if it was stopped due to an internal event. Limit this to
2375 non-stop mode, as when debugging a multi-threaded application in
2376 all-stop mode, we will only get one stop event --- it's undefined
2377 which thread will report the event. */
2379 set_stop_requested (ptid
, 1);
2382 /* Stop the execution of the target while running in async mode, in
2383 the backgound. In all-stop, stop the whole process. In non-stop
2384 mode, stop the current thread only by default, or stop all threads
2385 if the `-a' switch is used. */
2387 /* interrupt [-a] */
2389 interrupt_target_command (char *args
, int from_tty
)
2391 if (target_can_async_p ())
2393 int all_threads
= 0;
2395 dont_repeat (); /* Not for the faint of heart */
2398 && strncmp (args
, "-a", sizeof ("-a") - 1) == 0)
2401 if (!non_stop
&& all_threads
)
2402 error (_("-a is meaningless in all-stop mode."));
2404 interrupt_target_1 (all_threads
);
2409 print_float_info (struct gdbarch
*gdbarch
, struct ui_file
*file
,
2410 struct frame_info
*frame
, const char *args
)
2412 if (gdbarch_print_float_info_p (gdbarch
))
2413 gdbarch_print_float_info (gdbarch
, file
, frame
, args
);
2417 int printed_something
= 0;
2420 regnum
< gdbarch_num_regs (gdbarch
)
2421 + gdbarch_num_pseudo_regs (gdbarch
);
2424 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, float_reggroup
))
2426 printed_something
= 1;
2427 gdbarch_print_registers_info (gdbarch
, file
, frame
, regnum
, 1);
2430 if (!printed_something
)
2431 fprintf_filtered (file
, "\
2432 No floating-point info available for this processor.\n");
2437 float_info (char *args
, int from_tty
)
2439 if (!target_has_registers
)
2440 error (_("The program has no registers now."));
2442 print_float_info (current_gdbarch
, gdb_stdout
,
2443 get_selected_frame (NULL
), args
);
2447 unset_command (char *args
, int from_tty
)
2449 printf_filtered (_("\
2450 \"unset\" must be followed by the name of an unset subcommand.\n"));
2451 help_list (unsetlist
, "unset ", -1, gdb_stdout
);
2455 _initialize_infcmd (void)
2457 struct cmd_list_element
*c
= NULL
;
2459 /* add the filename of the terminal connected to inferior I/O */
2460 add_setshow_filename_cmd ("inferior-tty", class_run
,
2461 &inferior_io_terminal
, _("\
2462 Set terminal for future runs of program being debugged."), _("\
2463 Show terminal for future runs of program being debugged."), _("\
2464 Usage: set inferior-tty /dev/pts/1"), NULL
, NULL
, &setlist
, &showlist
);
2465 add_com_alias ("tty", "set inferior-tty", class_alias
, 0);
2467 add_setshow_optional_filename_cmd ("args", class_run
,
2468 &inferior_args
, _("\
2469 Set argument list to give program being debugged when it is started."), _("\
2470 Show argument list to give program being debugged when it is started."), _("\
2471 Follow this command with any number of args, to be passed to the program."),
2474 &setlist
, &showlist
);
2476 c
= add_cmd ("environment", no_class
, environment_info
, _("\
2477 The environment to give the program, or one variable's value.\n\
2478 With an argument VAR, prints the value of environment variable VAR to\n\
2479 give the program being debugged. With no arguments, prints the entire\n\
2480 environment to be given to the program."), &showlist
);
2481 set_cmd_completer (c
, noop_completer
);
2483 add_prefix_cmd ("unset", no_class
, unset_command
,
2484 _("Complement to certain \"set\" commands."),
2485 &unsetlist
, "unset ", 0, &cmdlist
);
2487 c
= add_cmd ("environment", class_run
, unset_environment_command
, _("\
2488 Cancel environment variable VAR for the program.\n\
2489 This does not affect the program until the next \"run\" command."),
2491 set_cmd_completer (c
, noop_completer
);
2493 c
= add_cmd ("environment", class_run
, set_environment_command
, _("\
2494 Set environment variable value to give the program.\n\
2495 Arguments are VAR VALUE where VAR is variable name and VALUE is value.\n\
2496 VALUES of environment variables are uninterpreted strings.\n\
2497 This does not affect the program until the next \"run\" command."),
2499 set_cmd_completer (c
, noop_completer
);
2501 c
= add_com ("path", class_files
, path_command
, _("\
2502 Add directory DIR(s) to beginning of search path for object files.\n\
2503 $cwd in the path means the current working directory.\n\
2504 This path is equivalent to the $PATH shell variable. It is a list of\n\
2505 directories, separated by colons. These directories are searched to find\n\
2506 fully linked executable files and separately compiled object files as needed."));
2507 set_cmd_completer (c
, filename_completer
);
2509 c
= add_cmd ("paths", no_class
, path_info
, _("\
2510 Current search path for finding object files.\n\
2511 $cwd in the path means the current working directory.\n\
2512 This path is equivalent to the $PATH shell variable. It is a list of\n\
2513 directories, separated by colons. These directories are searched to find\n\
2514 fully linked executable files and separately compiled object files as needed."),
2516 set_cmd_completer (c
, noop_completer
);
2518 add_com ("attach", class_run
, attach_command
, _("\
2519 Attach to a process or file outside of GDB.\n\
2520 This command attaches to another target, of the same type as your last\n\
2521 \"target\" command (\"info files\" will show your target stack).\n\
2522 The command may take as argument a process id or a device file.\n\
2523 For a process id, you must have permission to send the process a signal,\n\
2524 and it must have the same effective uid as the debugger.\n\
2525 When using \"attach\" with a process id, the debugger finds the\n\
2526 program running in the process, looking first in the current working\n\
2527 directory, or (if not found there) using the source file search path\n\
2528 (see the \"directory\" command). You can also use the \"file\" command\n\
2529 to specify the program, and to load its symbol table."));
2531 add_prefix_cmd ("detach", class_run
, detach_command
, _("\
2532 Detach a process or file previously attached.\n\
2533 If a process, it is no longer traced, and it continues its execution. If\n\
2534 you were debugging a file, the file is closed and gdb no longer accesses it."),
2535 &detachlist
, "detach ", 0, &cmdlist
);
2537 add_com ("disconnect", class_run
, disconnect_command
, _("\
2538 Disconnect from a target.\n\
2539 The target will wait for another debugger to connect. Not available for\n\
2542 add_com ("signal", class_run
, signal_command
, _("\
2543 Continue program giving it signal specified by the argument.\n\
2544 An argument of \"0\" means continue program without giving it a signal."));
2546 add_com ("stepi", class_run
, stepi_command
, _("\
2547 Step one instruction exactly.\n\
2548 Argument N means do this N times (or till program stops for another reason)."));
2549 add_com_alias ("si", "stepi", class_alias
, 0);
2551 add_com ("nexti", class_run
, nexti_command
, _("\
2552 Step one instruction, but proceed through subroutine calls.\n\
2553 Argument N means do this N times (or till program stops for another reason)."));
2554 add_com_alias ("ni", "nexti", class_alias
, 0);
2556 add_com ("finish", class_run
, finish_command
, _("\
2557 Execute until selected stack frame returns.\n\
2558 Upon return, the value returned is printed and put in the value history."));
2559 add_com_alias ("fin", "finish", class_run
, 1);
2561 add_com ("next", class_run
, next_command
, _("\
2562 Step program, proceeding through subroutine calls.\n\
2563 Like the \"step\" command as long as subroutine calls do not happen;\n\
2564 when they do, the call is treated as one instruction.\n\
2565 Argument N means do this N times (or till program stops for another reason)."));
2566 add_com_alias ("n", "next", class_run
, 1);
2568 add_com_alias ("S", "next", class_run
, 1);
2570 add_com ("step", class_run
, step_command
, _("\
2571 Step program until it reaches a different source line.\n\
2572 Argument N means do this N times (or till program stops for another reason)."));
2573 add_com_alias ("s", "step", class_run
, 1);
2575 c
= add_com ("until", class_run
, until_command
, _("\
2576 Execute until the program reaches a source line greater than the current\n\
2577 or a specified location (same args as break command) within the current frame."));
2578 set_cmd_completer (c
, location_completer
);
2579 add_com_alias ("u", "until", class_run
, 1);
2581 c
= add_com ("advance", class_run
, advance_command
, _("\
2582 Continue the program up to the given location (same form as args for break command).\n\
2583 Execution will also stop upon exit from the current stack frame."));
2584 set_cmd_completer (c
, location_completer
);
2586 c
= add_com ("jump", class_run
, jump_command
, _("\
2587 Continue program being debugged at specified line or address.\n\
2588 Give as argument either LINENUM or *ADDR, where ADDR is an expression\n\
2589 for an address to start at."));
2590 set_cmd_completer (c
, location_completer
);
2594 c
= add_com ("go", class_run
, go_command
, _("\
2595 Usage: go <location>\n\
2596 Continue program being debugged, stopping at specified line or \n\
2598 Give as argument either LINENUM or *ADDR, where ADDR is an \n\
2599 expression for an address to start at.\n\
2600 This command is a combination of tbreak and jump."));
2601 set_cmd_completer (c
, location_completer
);
2605 add_com_alias ("g", "go", class_run
, 1);
2607 c
= add_com ("continue", class_run
, continue_command
, _("\
2608 Continue program being debugged, after signal or breakpoint.\n\
2609 If proceeding from breakpoint, a number N may be used as an argument,\n\
2610 which means to set the ignore count of that breakpoint to N - 1 (so that\n\
2611 the breakpoint won't break until the Nth time it is reached).\n\
2613 If non-stop mode is enabled, continue only the current thread,\n\
2614 otherwise all the threads in the program are continued. To \n\
2615 continue all stopped threads in non-stop mode, use the -a option.\n\
2616 Specifying -a and an ignore count simultaneously is an error."));
2617 add_com_alias ("c", "cont", class_run
, 1);
2618 add_com_alias ("fg", "cont", class_run
, 1);
2620 c
= add_com ("run", class_run
, run_command
, _("\
2621 Start debugged program. You may specify arguments to give it.\n\
2622 Args may include \"*\", or \"[...]\"; they are expanded using \"sh\".\n\
2623 Input and output redirection with \">\", \"<\", or \">>\" are also allowed.\n\n\
2624 With no arguments, uses arguments last specified (with \"run\" or \"set args\").\n\
2625 To cancel previous arguments and run with no arguments,\n\
2626 use \"set args\" without arguments."));
2627 set_cmd_completer (c
, filename_completer
);
2628 add_com_alias ("r", "run", class_run
, 1);
2630 add_com ("R", class_run
, run_no_args_command
,
2631 _("Start debugged program with no arguments."));
2633 c
= add_com ("start", class_run
, start_command
, _("\
2634 Run the debugged program until the beginning of the main procedure.\n\
2635 You may specify arguments to give to your program, just as with the\n\
2636 \"run\" command."));
2637 set_cmd_completer (c
, filename_completer
);
2639 c
= add_com ("interrupt", class_run
, interrupt_target_command
,
2640 _("Interrupt the execution of the debugged program.\n\
2641 If non-stop mode is enabled, interrupt only the current thread,\n\
2642 otherwise all the threads in the program are stopped. To \n\
2643 interrupt all running threads in non-stop mode, use the -a option."));
2645 add_info ("registers", nofp_registers_info
, _("\
2646 List of integer registers and their contents, for selected stack frame.\n\
2647 Register name as argument means describe only that register."));
2648 add_info_alias ("r", "registers", 1);
2651 add_com ("lr", class_info
, nofp_registers_info
, _("\
2652 List of integer registers and their contents, for selected stack frame.\n\
2653 Register name as argument means describe only that register."));
2654 add_info ("all-registers", all_registers_info
, _("\
2655 List of all registers and their contents, for selected stack frame.\n\
2656 Register name as argument means describe only that register."));
2658 add_info ("program", program_info
,
2659 _("Execution status of the program."));
2661 add_info ("float", float_info
,
2662 _("Print the status of the floating point unit\n"));
2664 add_info ("vector", vector_info
,
2665 _("Print the status of the vector unit\n"));
2667 inferior_environ
= make_environ ();
2668 init_environ (inferior_environ
);