1 /* Memory-access and commands for "inferior" process, for GDB.
3 Copyright (C) 1986-2017 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 #include "arch-utils.h"
36 #include "completer.h"
38 #include "event-top.h"
39 #include "parser-defs.h"
41 #include "reggroups.h"
46 #include "target-descriptions.h"
47 #include "user-regs.h"
48 #include "cli/cli-decode.h"
49 #include "gdbthread.h"
51 #include "inline-frame.h"
52 #include "tracepoint.h"
54 #include "continuations.h"
56 #include "cli/cli-utils.h"
58 #include "thread-fsm.h"
61 #include "common/gdb_optional.h"
63 /* Local functions: */
65 static void until_next_command (int);
67 static void step_1 (int, int, const char *);
69 #define ERROR_NO_INFERIOR \
70 if (!target_has_execution) error (_("The program is not being run."));
72 /* Scratch area where string containing arguments to give to the
73 program will be stored by 'set args'. As soon as anything is
74 stored, notice_args_set will move it into per-inferior storage.
75 Arguments are separated by spaces. Empty string (pointer to '\0')
78 static char *inferior_args_scratch
;
80 /* Scratch area where the new cwd will be stored by 'set cwd'. */
82 static char *inferior_cwd_scratch
;
84 /* Scratch area where 'set inferior-tty' will store user-provided value.
85 We'll immediate copy it into per-inferior storage. */
87 static char *inferior_io_terminal_scratch
;
89 /* Pid of our debugged inferior, or 0 if no inferior now.
90 Since various parts of infrun.c test this to see whether there is a program
91 being debugged it should be nonzero (currently 3 is used) for remote
96 /* Address at which inferior stopped. */
100 /* Nonzero if stopped due to completion of a stack dummy routine. */
102 enum stop_stack_kind stop_stack_dummy
;
104 /* Nonzero if stopped due to a random (unexpected) signal in inferior
107 int stopped_by_random_signal
;
109 /* See inferior.h. */
111 int startup_with_shell
= 1;
114 /* Accessor routines. */
116 /* Set the io terminal for the current inferior. Ownership of
117 TERMINAL_NAME is not transferred. */
120 set_inferior_io_terminal (const char *terminal_name
)
122 xfree (current_inferior ()->terminal
);
124 if (terminal_name
!= NULL
&& *terminal_name
!= '\0')
125 current_inferior ()->terminal
= xstrdup (terminal_name
);
127 current_inferior ()->terminal
= NULL
;
131 get_inferior_io_terminal (void)
133 return current_inferior ()->terminal
;
137 set_inferior_tty_command (const char *args
, int from_tty
,
138 struct cmd_list_element
*c
)
140 /* CLI has assigned the user-provided value to inferior_io_terminal_scratch.
141 Now route it to current inferior. */
142 set_inferior_io_terminal (inferior_io_terminal_scratch
);
146 show_inferior_tty_command (struct ui_file
*file
, int from_tty
,
147 struct cmd_list_element
*c
, const char *value
)
149 /* Note that we ignore the passed-in value in favor of computing it
151 const char *inferior_io_terminal
= get_inferior_io_terminal ();
153 if (inferior_io_terminal
== NULL
)
154 inferior_io_terminal
= "";
155 fprintf_filtered (gdb_stdout
,
156 _("Terminal for future runs of program being debugged "
157 "is \"%s\".\n"), inferior_io_terminal
);
161 get_inferior_args (void)
163 if (current_inferior ()->argc
!= 0)
167 n
= construct_inferior_arguments (current_inferior ()->argc
,
168 current_inferior ()->argv
);
169 set_inferior_args (n
);
173 if (current_inferior ()->args
== NULL
)
174 current_inferior ()->args
= xstrdup ("");
176 return current_inferior ()->args
;
179 /* Set the arguments for the current inferior. Ownership of
180 NEWARGS is not transferred. */
183 set_inferior_args (const char *newargs
)
185 xfree (current_inferior ()->args
);
186 current_inferior ()->args
= newargs
? xstrdup (newargs
) : NULL
;
187 current_inferior ()->argc
= 0;
188 current_inferior ()->argv
= 0;
192 set_inferior_args_vector (int argc
, char **argv
)
194 current_inferior ()->argc
= argc
;
195 current_inferior ()->argv
= argv
;
198 /* Notice when `set args' is run. */
201 set_args_command (const char *args
, int from_tty
, struct cmd_list_element
*c
)
203 /* CLI has assigned the user-provided value to inferior_args_scratch.
204 Now route it to current inferior. */
205 set_inferior_args (inferior_args_scratch
);
208 /* Notice when `show args' is run. */
211 show_args_command (struct ui_file
*file
, int from_tty
,
212 struct cmd_list_element
*c
, const char *value
)
214 /* Note that we ignore the passed-in value in favor of computing it
216 deprecated_show_value_hack (file
, from_tty
, c
, get_inferior_args ());
219 /* See common/common-inferior.h. */
222 set_inferior_cwd (const char *cwd
)
224 struct inferior
*inf
= current_inferior ();
226 gdb_assert (inf
!= NULL
);
231 inf
->cwd
.reset (xstrdup (cwd
));
234 /* See common/common-inferior.h. */
239 return current_inferior ()->cwd
.get ();
242 /* Handle the 'set cwd' command. */
245 set_cwd_command (const char *args
, int from_tty
, struct cmd_list_element
*c
)
247 if (*inferior_cwd_scratch
== '\0')
248 set_inferior_cwd (NULL
);
250 set_inferior_cwd (inferior_cwd_scratch
);
253 /* Handle the 'show cwd' command. */
256 show_cwd_command (struct ui_file
*file
, int from_tty
,
257 struct cmd_list_element
*c
, const char *value
)
259 const char *cwd
= get_inferior_cwd ();
262 fprintf_filtered (gdb_stdout
,
264 You have not set the inferior's current working directory.\n\
265 The inferior will inherit GDB's cwd if native debugging, or the remote\n\
266 server's cwd if remote debugging.\n"));
268 fprintf_filtered (gdb_stdout
,
269 _("Current working directory that will be used "
270 "when starting the inferior is \"%s\".\n"), cwd
);
274 /* Compute command-line string given argument vector. This does the
275 same shell processing as fork_inferior. */
278 construct_inferior_arguments (int argc
, char **argv
)
282 if (startup_with_shell
)
285 /* This holds all the characters considered special to the
287 static const char special
[] = "\"!&*|[]{}<>?`~^=;, \t\n";
288 static const char quote
= '"';
290 /* This holds all the characters considered special to the
291 typical Unix shells. We include `^' because the SunOS
292 /bin/sh treats it as a synonym for `|'. */
293 static const char special
[] = "\"!#$&*()\\|[]{}<>?'`~^; \t\n";
294 static const char quote
= '\'';
300 /* We over-compute the size. It shouldn't matter. */
301 for (i
= 0; i
< argc
; ++i
)
302 length
+= 3 * strlen (argv
[i
]) + 1 + 2 * (argv
[i
][0] == '\0');
304 result
= (char *) xmalloc (length
);
307 for (i
= 0; i
< argc
; ++i
)
312 /* Need to handle empty arguments specially. */
313 if (argv
[i
][0] == '\0')
323 if (strpbrk (argv
[i
], special
))
329 for (cp
= argv
[i
]; *cp
; ++cp
)
333 /* A newline cannot be quoted with a backslash (it
334 just disappears), only by putting it inside
345 if (strchr (special
, *cp
) != NULL
)
361 /* In this case we can't handle arguments that contain spaces,
362 tabs, or newlines -- see breakup_args(). */
366 for (i
= 0; i
< argc
; ++i
)
368 char *cp
= strchr (argv
[i
], ' ');
370 cp
= strchr (argv
[i
], '\t');
372 cp
= strchr (argv
[i
], '\n');
374 error (_("can't handle command-line "
375 "argument containing whitespace"));
376 length
+= strlen (argv
[i
]) + 1;
379 result
= (char *) xmalloc (length
);
381 for (i
= 0; i
< argc
; ++i
)
384 strcat (result
, " ");
385 strcat (result
, argv
[i
]);
393 /* This function strips the '&' character (indicating background
394 execution) that is added as *the last* of the arguments ARGS of a
395 command. A copy of the incoming ARGS without the '&' is returned,
396 unless the resulting string after stripping is empty, in which case
397 NULL is returned. *BG_CHAR_P is an output boolean that indicates
398 whether the '&' character was found. */
400 static gdb::unique_xmalloc_ptr
<char>
401 strip_bg_char (const char *args
, int *bg_char_p
)
405 if (args
== NULL
|| *args
== '\0')
411 p
= args
+ strlen (args
);
415 while (p
> args
&& isspace (p
[-1]))
420 return gdb::unique_xmalloc_ptr
<char>
421 (savestring (args
, p
- args
));
423 return gdb::unique_xmalloc_ptr
<char> (nullptr);
427 return gdb::unique_xmalloc_ptr
<char> (xstrdup (args
));
430 /* Common actions to take after creating any sort of inferior, by any
431 means (running, attaching, connecting, et cetera). The target
432 should be stopped. */
435 post_create_inferior (struct target_ops
*target
, int from_tty
)
438 /* Be sure we own the terminal in case write operations are performed. */
439 target_terminal::ours_for_output ();
441 /* If the target hasn't taken care of this already, do it now.
442 Targets which need to access registers during to_open,
443 to_create_inferior, or to_attach should do it earlier; but many
445 target_find_description ();
447 /* Now that we know the register layout, retrieve current PC. But
448 if the PC is unavailable (e.g., we're opening a core file with
449 missing registers info), ignore it. */
453 stop_pc
= regcache_read_pc (get_current_regcache ());
455 CATCH (ex
, RETURN_MASK_ERROR
)
457 if (ex
.error
!= NOT_AVAILABLE_ERROR
)
458 throw_exception (ex
);
464 const unsigned solib_add_generation
465 = current_program_space
->solib_add_generation
;
467 /* Create the hooks to handle shared library load and unload
469 solib_create_inferior_hook (from_tty
);
471 if (current_program_space
->solib_add_generation
== solib_add_generation
)
473 /* The platform-specific hook should load initial shared libraries,
474 but didn't. FROM_TTY will be incorrectly 0 but such solib
475 targets should be fixed anyway. Call it only after the solib
476 target has been initialized by solib_create_inferior_hook. */
479 warning (_("platform-specific solib_create_inferior_hook did "
480 "not load initial shared libraries."));
482 /* If the solist is global across processes, there's no need to
484 if (!gdbarch_has_global_solist (target_gdbarch ()))
485 solib_add (NULL
, 0, auto_solib_add
);
489 /* If the user sets watchpoints before execution having started,
490 then she gets software watchpoints, because GDB can't know which
491 target will end up being pushed, or if it supports hardware
492 watchpoints or not. breakpoint_re_set takes care of promoting
493 watchpoints to hardware watchpoints if possible, however, if this
494 new inferior doesn't load shared libraries or we don't pull in
495 symbols from any other source on this target/arch,
496 breakpoint_re_set is never called. Call it now so that software
497 watchpoints get a chance to be promoted to hardware watchpoints
498 if the now pushed target supports hardware watchpoints. */
499 breakpoint_re_set ();
501 observer_notify_inferior_created (target
, from_tty
);
504 /* Kill the inferior if already running. This function is designed
505 to be called when we are about to start the execution of the program
506 from the beginning. Ask the user to confirm that he wants to restart
507 the program being debugged when FROM_TTY is non-null. */
510 kill_if_already_running (int from_tty
)
512 if (! ptid_equal (inferior_ptid
, null_ptid
) && target_has_execution
)
514 /* Bail out before killing the program if we will not be able to
516 target_require_runnable ();
519 && !query (_("The program being debugged has been started already.\n\
520 Start it from the beginning? ")))
521 error (_("Program not restarted."));
526 /* See inferior.h. */
529 prepare_execution_command (struct target_ops
*target
, int background
)
531 /* If we get a request for running in the bg but the target
532 doesn't support it, error out. */
533 if (background
&& !target
->to_can_async_p (target
))
534 error (_("Asynchronous execution not supported on this target."));
538 /* If we get a request for running in the fg, then we need to
539 simulate synchronous (fg) execution. Note no cleanup is
540 necessary for this. stdin is re-enabled whenever an error
541 reaches the top level. */
542 all_uis_on_sync_execution_starting ();
546 /* Determine how the new inferior will behave. */
550 /* Run program without any explicit stop during startup. */
553 /* Stop at the beginning of the program's main function. */
556 /* Stop at the first instruction of the program. */
557 RUN_STOP_AT_FIRST_INSN
560 /* Implement the "run" command. Force a stop during program start if
561 requested by RUN_HOW. */
564 run_command_1 (const char *args
, int from_tty
, enum run_how run_how
)
566 const char *exec_file
;
567 struct cleanup
*old_chain
;
569 struct ui_out
*uiout
= current_uiout
;
570 struct target_ops
*run_target
;
576 kill_if_already_running (from_tty
);
578 init_wait_for_inferior ();
579 clear_breakpoint_hit_counts ();
581 /* Clean up any leftovers from other runs. Some other things from
582 this function should probably be moved into target_pre_inferior. */
583 target_pre_inferior (from_tty
);
585 /* The comment here used to read, "The exec file is re-read every
586 time we do a generic_mourn_inferior, so we just have to worry
587 about the symbol file." The `generic_mourn_inferior' function
588 gets called whenever the program exits. However, suppose the
589 program exits, and *then* the executable file changes? We need
590 to check again here. Since reopen_exec_file doesn't do anything
591 if the timestamp hasn't changed, I don't see the harm. */
595 gdb::unique_xmalloc_ptr
<char> stripped
= strip_bg_char (args
, &async_exec
);
596 args
= stripped
.get ();
598 /* Do validation and preparation before possibly changing anything
601 run_target
= find_run_target ();
603 prepare_execution_command (run_target
, async_exec
);
605 if (non_stop
&& !run_target
->to_supports_non_stop (run_target
))
606 error (_("The target does not support running in non-stop mode."));
608 /* Done. Can now set breakpoints, change inferior args, etc. */
610 /* Insert temporary breakpoint in main function if requested. */
611 if (run_how
== RUN_STOP_AT_MAIN
)
612 tbreak_command (main_name (), 0);
614 exec_file
= get_exec_file (0);
616 /* We keep symbols from add-symbol-file, on the grounds that the
617 user might want to add some symbols before running the program
618 (right?). But sometimes (dynamic loading where the user manually
619 introduces the new symbols with add-symbol-file), the code which
620 the symbols describe does not persist between runs. Currently
621 the user has to manually nuke all symbols between runs if they
622 want them to go away (PR 2207). This is probably reasonable. */
624 /* If there were other args, beside '&', process them. */
626 set_inferior_args (args
);
630 uiout
->field_string (NULL
, "Starting program");
633 uiout
->field_string ("execfile", exec_file
);
635 /* We call get_inferior_args() because we might need to compute
637 uiout
->field_string ("infargs", get_inferior_args ());
642 /* We call get_inferior_args() because we might need to compute
644 run_target
->to_create_inferior (run_target
, exec_file
,
645 std::string (get_inferior_args ()),
646 current_inferior ()->environment
.envp (),
648 /* to_create_inferior should push the target, so after this point we
649 shouldn't refer to run_target again. */
652 /* We're starting off a new process. When we get out of here, in
653 non-stop mode, finish the state of all threads of that process,
654 but leave other threads alone, as they may be stopped in internal
655 events --- the frontend shouldn't see them as stopped. In
656 all-stop, always finish the state of all threads, as we may be
657 resuming more than just the new process. */
659 ptid
= pid_to_ptid (ptid_get_pid (inferior_ptid
));
661 ptid
= minus_one_ptid
;
662 old_chain
= make_cleanup (finish_thread_state_cleanup
, &ptid
);
664 /* Pass zero for FROM_TTY, because at this point the "run" command
665 has done its thing; now we are setting up the running program. */
666 post_create_inferior (¤t_target
, 0);
668 /* Queue a pending event so that the program stops immediately. */
669 if (run_how
== RUN_STOP_AT_FIRST_INSN
)
671 thread_info
*thr
= inferior_thread ();
672 thr
->suspend
.waitstatus_pending_p
= 1;
673 thr
->suspend
.waitstatus
.kind
= TARGET_WAITKIND_STOPPED
;
674 thr
->suspend
.waitstatus
.value
.sig
= GDB_SIGNAL_0
;
677 /* Start the target running. Do not use -1 continuation as it would skip
678 breakpoint right at the entry point. */
679 proceed (regcache_read_pc (get_current_regcache ()), GDB_SIGNAL_0
);
681 /* Since there was no error, there's no need to finish the thread
683 discard_cleanups (old_chain
);
687 run_command (const char *args
, int from_tty
)
689 run_command_1 (args
, from_tty
, RUN_NORMAL
);
692 /* Start the execution of the program up until the beginning of the main
696 start_command (const char *args
, int from_tty
)
698 /* Some languages such as Ada need to search inside the program
699 minimal symbols for the location where to put the temporary
700 breakpoint before starting. */
701 if (!have_minimal_symbols ())
702 error (_("No symbol table loaded. Use the \"file\" command."));
704 /* Run the program until reaching the main procedure... */
705 run_command_1 (args
, from_tty
, RUN_STOP_AT_MAIN
);
708 /* Start the execution of the program stopping at the first
712 starti_command (const char *args
, int from_tty
)
714 run_command_1 (args
, from_tty
, RUN_STOP_AT_FIRST_INSN
);
718 proceed_thread_callback (struct thread_info
*thread
, void *arg
)
720 /* We go through all threads individually instead of compressing
721 into a single target `resume_all' request, because some threads
722 may be stopped in internal breakpoints/events, or stopped waiting
723 for its turn in the displaced stepping queue (that is, they are
724 running && !executing). The target side has no idea about why
725 the thread is stopped, so a `resume_all' command would resume too
726 much. If/when GDB gains a way to tell the target `hold this
727 thread stopped until I say otherwise', then we can optimize
729 if (!is_stopped (thread
->ptid
))
732 switch_to_thread (thread
->ptid
);
733 clear_proceed_status (0);
734 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
);
739 ensure_valid_thread (void)
741 if (ptid_equal (inferior_ptid
, null_ptid
)
742 || is_exited (inferior_ptid
))
743 error (_("Cannot execute this command without a live selected thread."));
746 /* If the user is looking at trace frames, any resumption of execution
747 is likely to mix up recorded and live target data. So simply
748 disallow those commands. */
751 ensure_not_tfind_mode (void)
753 if (get_traceframe_number () >= 0)
754 error (_("Cannot execute this command while looking at trace frames."));
757 /* Throw an error indicating the current thread is running. */
760 error_is_running (void)
762 error (_("Cannot execute this command while "
763 "the selected thread is running."));
766 /* Calls error_is_running if the current thread is running. */
769 ensure_not_running (void)
771 if (is_running (inferior_ptid
))
776 continue_1 (int all_threads
)
779 ensure_not_tfind_mode ();
781 if (non_stop
&& all_threads
)
783 /* Don't error out if the current thread is running, because
784 there may be other stopped threads. */
786 /* Backup current thread and selected frame and restore on scope
788 scoped_restore_current_thread restore_thread
;
790 iterate_over_threads (proceed_thread_callback
, NULL
);
792 if (current_ui
->prompt_state
== PROMPT_BLOCKED
)
794 /* If all threads in the target were already running,
795 proceed_thread_callback ends up never calling proceed,
796 and so nothing calls this to put the inferior's terminal
797 settings in effect and remove stdin from the event loop,
798 which we must when running a foreground command. E.g.:
802 <all threads are running now>
805 <no thread was resumed, but the inferior now owns the terminal>
807 target_terminal::inferior ();
812 ensure_valid_thread ();
813 ensure_not_running ();
814 clear_proceed_status (0);
815 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
);
819 /* continue [-a] [proceed-count] [&] */
822 continue_command (const char *args
, int from_tty
)
829 /* Find out whether we must run in the background. */
830 gdb::unique_xmalloc_ptr
<char> stripped
= strip_bg_char (args
, &async_exec
);
831 args
= stripped
.get ();
835 if (startswith (args
, "-a"))
838 args
+= sizeof ("-a") - 1;
844 if (!non_stop
&& all_threads
)
845 error (_("`-a' is meaningless in all-stop mode."));
847 if (args
!= NULL
&& all_threads
)
848 error (_("Can't resume all threads and specify "
849 "proceed count simultaneously."));
851 /* If we have an argument left, set proceed count of breakpoint we
858 struct thread_info
*tp
;
861 tp
= find_thread_ptid (inferior_ptid
);
865 struct target_waitstatus ws
;
867 get_last_target_status (&last_ptid
, &ws
);
868 tp
= find_thread_ptid (last_ptid
);
871 bs
= tp
->control
.stop_bpstat
;
873 while ((stat
= bpstat_num (&bs
, &num
)) != 0)
876 set_ignore_count (num
,
877 parse_and_eval_long (args
) - 1,
879 /* set_ignore_count prints a message ending with a period.
880 So print two spaces before "Continuing.". */
882 printf_filtered (" ");
886 if (!stopped
&& from_tty
)
889 ("Not stopped at any breakpoint; argument ignored.\n");
894 ensure_not_tfind_mode ();
896 if (!non_stop
|| !all_threads
)
898 ensure_valid_thread ();
899 ensure_not_running ();
902 prepare_execution_command (¤t_target
, async_exec
);
905 printf_filtered (_("Continuing.\n"));
907 continue_1 (all_threads
);
910 /* Record the starting point of a "step" or "next" command. */
913 set_step_frame (void)
915 frame_info
*frame
= get_current_frame ();
917 symtab_and_line sal
= find_frame_sal (frame
);
918 set_step_info (frame
, sal
);
920 CORE_ADDR pc
= get_frame_pc (frame
);
921 thread_info
*tp
= inferior_thread ();
922 tp
->control
.step_start_function
= find_pc_function (pc
);
925 /* Step until outside of current statement. */
928 step_command (const char *count_string
, int from_tty
)
930 step_1 (0, 0, count_string
);
933 /* Likewise, but skip over subroutine calls as if single instructions. */
936 next_command (const char *count_string
, int from_tty
)
938 step_1 (1, 0, count_string
);
941 /* Likewise, but step only one instruction. */
944 stepi_command (const char *count_string
, int from_tty
)
946 step_1 (0, 1, count_string
);
950 nexti_command (const char *count_string
, int from_tty
)
952 step_1 (1, 1, count_string
);
956 delete_longjmp_breakpoint_cleanup (void *arg
)
958 int thread
= * (int *) arg
;
959 delete_longjmp_breakpoint (thread
);
962 /* Data for the FSM that manages the step/next/stepi/nexti
965 struct step_command_fsm
967 /* The base class. */
968 struct thread_fsm thread_fsm
;
970 /* How many steps left in a "step N"-like command. */
973 /* If true, this is a next/nexti, otherwise a step/stepi. */
974 int skip_subroutines
;
976 /* If true, this is a stepi/nexti, otherwise a step/step. */
980 static void step_command_fsm_clean_up (struct thread_fsm
*self
,
981 struct thread_info
*thread
);
982 static int step_command_fsm_should_stop (struct thread_fsm
*self
,
983 struct thread_info
*thread
);
984 static enum async_reply_reason
985 step_command_fsm_async_reply_reason (struct thread_fsm
*self
);
987 /* step_command_fsm's vtable. */
989 static struct thread_fsm_ops step_command_fsm_ops
=
992 step_command_fsm_clean_up
,
993 step_command_fsm_should_stop
,
994 NULL
, /* return_value */
995 step_command_fsm_async_reply_reason
,
998 /* Allocate a new step_command_fsm. */
1000 static struct step_command_fsm
*
1001 new_step_command_fsm (struct interp
*cmd_interp
)
1003 struct step_command_fsm
*sm
;
1005 sm
= XCNEW (struct step_command_fsm
);
1006 thread_fsm_ctor (&sm
->thread_fsm
, &step_command_fsm_ops
, cmd_interp
);
1011 /* Prepare for a step/next/etc. command. Any target resource
1012 allocated here is undone in the FSM's clean_up method. */
1015 step_command_fsm_prepare (struct step_command_fsm
*sm
,
1016 int skip_subroutines
, int single_inst
,
1017 int count
, struct thread_info
*thread
)
1019 sm
->skip_subroutines
= skip_subroutines
;
1020 sm
->single_inst
= single_inst
;
1023 /* Leave the si command alone. */
1024 if (!sm
->single_inst
|| sm
->skip_subroutines
)
1025 set_longjmp_breakpoint (thread
, get_frame_id (get_current_frame ()));
1027 thread
->control
.stepping_command
= 1;
1030 static int prepare_one_step (struct step_command_fsm
*sm
);
1033 step_1 (int skip_subroutines
, int single_inst
, const char *count_string
)
1037 struct thread_info
*thr
;
1038 struct step_command_fsm
*step_sm
;
1041 ensure_not_tfind_mode ();
1042 ensure_valid_thread ();
1043 ensure_not_running ();
1045 gdb::unique_xmalloc_ptr
<char> stripped
1046 = strip_bg_char (count_string
, &async_exec
);
1047 count_string
= stripped
.get ();
1049 prepare_execution_command (¤t_target
, async_exec
);
1051 count
= count_string
? parse_and_eval_long (count_string
) : 1;
1053 clear_proceed_status (1);
1055 /* Setup the execution command state machine to handle all the COUNT
1057 thr
= inferior_thread ();
1058 step_sm
= new_step_command_fsm (command_interp ());
1059 thr
->thread_fsm
= &step_sm
->thread_fsm
;
1061 step_command_fsm_prepare (step_sm
, skip_subroutines
,
1062 single_inst
, count
, thr
);
1064 /* Do only one step for now, before returning control to the event
1065 loop. Let the continuation figure out how many other steps we
1066 need to do, and handle them one at the time, through
1068 if (!prepare_one_step (step_sm
))
1069 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
);
1074 /* Stepped into an inline frame. Pretend that we've
1076 thread_fsm_clean_up (thr
->thread_fsm
, thr
);
1077 proceeded
= normal_stop ();
1079 inferior_event_handler (INF_EXEC_COMPLETE
, NULL
);
1080 all_uis_check_sync_execution_done ();
1084 /* Implementation of the 'should_stop' FSM method for stepping
1085 commands. Called after we are done with one step operation, to
1086 check whether we need to step again, before we print the prompt and
1087 return control to the user. If count is > 1, returns false, as we
1088 will need to keep going. */
1091 step_command_fsm_should_stop (struct thread_fsm
*self
, struct thread_info
*tp
)
1093 struct step_command_fsm
*sm
= (struct step_command_fsm
*) self
;
1095 if (tp
->control
.stop_step
)
1097 /* There are more steps to make, and we did stop due to
1098 ending a stepping range. Do another step. */
1099 if (--sm
->count
> 0)
1100 return prepare_one_step (sm
);
1102 thread_fsm_set_finished (self
);
1108 /* Implementation of the 'clean_up' FSM method for stepping commands. */
1111 step_command_fsm_clean_up (struct thread_fsm
*self
, struct thread_info
*thread
)
1113 struct step_command_fsm
*sm
= (struct step_command_fsm
*) self
;
1115 if (!sm
->single_inst
|| sm
->skip_subroutines
)
1116 delete_longjmp_breakpoint (thread
->global_num
);
1119 /* Implementation of the 'async_reply_reason' FSM method for stepping
1122 static enum async_reply_reason
1123 step_command_fsm_async_reply_reason (struct thread_fsm
*self
)
1125 return EXEC_ASYNC_END_STEPPING_RANGE
;
1128 /* Prepare for one step in "step N". The actual target resumption is
1129 done by the caller. Return true if we're done and should thus
1130 report a stop to the user. Returns false if the target needs to be
1134 prepare_one_step (struct step_command_fsm
*sm
)
1138 struct frame_info
*frame
= get_current_frame ();
1140 /* Don't assume THREAD is a valid thread id. It is set to -1 if
1141 the longjmp breakpoint was not required. Use the
1142 INFERIOR_PTID thread instead, which is the same thread when
1144 struct thread_info
*tp
= inferior_thread ();
1148 if (!sm
->single_inst
)
1152 /* Step at an inlined function behaves like "down". */
1153 if (!sm
->skip_subroutines
1154 && inline_skipped_frames (inferior_ptid
))
1158 /* Pretend that we've ran. */
1159 resume_ptid
= user_visible_resume_ptid (1);
1160 set_running (resume_ptid
, 1);
1162 step_into_inline_frame (inferior_ptid
);
1164 return prepare_one_step (sm
);
1167 pc
= get_frame_pc (frame
);
1168 find_pc_line_pc_range (pc
,
1169 &tp
->control
.step_range_start
,
1170 &tp
->control
.step_range_end
);
1172 tp
->control
.may_range_step
= 1;
1174 /* If we have no line info, switch to stepi mode. */
1175 if (tp
->control
.step_range_end
== 0 && step_stop_if_no_debug
)
1177 tp
->control
.step_range_start
= tp
->control
.step_range_end
= 1;
1178 tp
->control
.may_range_step
= 0;
1180 else if (tp
->control
.step_range_end
== 0)
1184 if (find_pc_partial_function (pc
, &name
,
1185 &tp
->control
.step_range_start
,
1186 &tp
->control
.step_range_end
) == 0)
1187 error (_("Cannot find bounds of current function"));
1189 target_terminal::ours_for_output ();
1190 printf_filtered (_("Single stepping until exit from function %s,"
1191 "\nwhich has no line number information.\n"),
1197 /* Say we are stepping, but stop after one insn whatever it does. */
1198 tp
->control
.step_range_start
= tp
->control
.step_range_end
= 1;
1199 if (!sm
->skip_subroutines
)
1201 Don't step over function calls, not even to functions lacking
1203 tp
->control
.step_over_calls
= STEP_OVER_NONE
;
1206 if (sm
->skip_subroutines
)
1207 tp
->control
.step_over_calls
= STEP_OVER_ALL
;
1213 thread_fsm_set_finished (&sm
->thread_fsm
);
1218 /* Continue program at specified address. */
1221 jump_command (const char *arg
, int from_tty
)
1223 struct gdbarch
*gdbarch
= get_current_arch ();
1230 ensure_not_tfind_mode ();
1231 ensure_valid_thread ();
1232 ensure_not_running ();
1234 /* Find out whether we must run in the background. */
1235 gdb::unique_xmalloc_ptr
<char> stripped
= strip_bg_char (arg
, &async_exec
);
1236 arg
= stripped
.get ();
1238 prepare_execution_command (¤t_target
, async_exec
);
1241 error_no_arg (_("starting address"));
1243 std::vector
<symtab_and_line
> sals
1244 = decode_line_with_last_displayed (arg
, DECODE_LINE_FUNFIRSTLINE
);
1245 if (sals
.size () != 1)
1246 error (_("Unreasonable jump request"));
1248 symtab_and_line
&sal
= sals
[0];
1250 if (sal
.symtab
== 0 && sal
.pc
== 0)
1251 error (_("No source file has been specified."));
1253 resolve_sal_pc (&sal
); /* May error out. */
1255 /* See if we are trying to jump to another function. */
1256 fn
= get_frame_function (get_current_frame ());
1257 sfn
= find_pc_function (sal
.pc
);
1258 if (fn
!= NULL
&& sfn
!= fn
)
1260 if (!query (_("Line %d is not in `%s'. Jump anyway? "), sal
.line
,
1261 SYMBOL_PRINT_NAME (fn
)))
1263 error (_("Not confirmed."));
1270 struct obj_section
*section
;
1272 fixup_symbol_section (sfn
, 0);
1273 section
= SYMBOL_OBJ_SECTION (symbol_objfile (sfn
), sfn
);
1274 if (section_is_overlay (section
)
1275 && !section_is_mapped (section
))
1277 if (!query (_("WARNING!!! Destination is in "
1278 "unmapped overlay! Jump anyway? ")))
1280 error (_("Not confirmed."));
1290 printf_filtered (_("Continuing at "));
1291 fputs_filtered (paddress (gdbarch
, addr
), gdb_stdout
);
1292 printf_filtered (".\n");
1295 clear_proceed_status (0);
1296 proceed (addr
, GDB_SIGNAL_0
);
1299 /* Continue program giving it specified signal. */
1302 signal_command (const char *signum_exp
, int from_tty
)
1304 enum gdb_signal oursig
;
1307 dont_repeat (); /* Too dangerous. */
1309 ensure_not_tfind_mode ();
1310 ensure_valid_thread ();
1311 ensure_not_running ();
1313 /* Find out whether we must run in the background. */
1314 gdb::unique_xmalloc_ptr
<char> stripped
1315 = strip_bg_char (signum_exp
, &async_exec
);
1316 signum_exp
= stripped
.get ();
1318 prepare_execution_command (¤t_target
, async_exec
);
1321 error_no_arg (_("signal number"));
1323 /* It would be even slicker to make signal names be valid expressions,
1324 (the type could be "enum $signal" or some such), then the user could
1325 assign them to convenience variables. */
1326 oursig
= gdb_signal_from_name (signum_exp
);
1328 if (oursig
== GDB_SIGNAL_UNKNOWN
)
1330 /* No, try numeric. */
1331 int num
= parse_and_eval_long (signum_exp
);
1334 oursig
= GDB_SIGNAL_0
;
1336 oursig
= gdb_signal_from_command (num
);
1339 /* Look for threads other than the current that this command ends up
1340 resuming too (due to schedlock off), and warn if they'll get a
1341 signal delivered. "signal 0" is used to suppress a previous
1342 signal, but if the current thread is no longer the one that got
1343 the signal, then the user is potentially suppressing the signal
1344 of the wrong thread. */
1347 struct thread_info
*tp
;
1349 int must_confirm
= 0;
1351 /* This indicates what will be resumed. Either a single thread,
1352 a whole process, or all threads of all processes. */
1353 resume_ptid
= user_visible_resume_ptid (0);
1355 ALL_NON_EXITED_THREADS (tp
)
1357 if (ptid_equal (tp
->ptid
, inferior_ptid
))
1359 if (!ptid_match (tp
->ptid
, resume_ptid
))
1362 if (tp
->suspend
.stop_signal
!= GDB_SIGNAL_0
1363 && signal_pass_state (tp
->suspend
.stop_signal
))
1366 printf_unfiltered (_("Note:\n"));
1367 printf_unfiltered (_(" Thread %s previously stopped with signal %s, %s.\n"),
1368 print_thread_id (tp
),
1369 gdb_signal_to_name (tp
->suspend
.stop_signal
),
1370 gdb_signal_to_string (tp
->suspend
.stop_signal
));
1376 && !query (_("Continuing thread %s (the current thread) with specified signal will\n"
1377 "still deliver the signals noted above to their respective threads.\n"
1378 "Continue anyway? "),
1379 print_thread_id (inferior_thread ())))
1380 error (_("Not confirmed."));
1385 if (oursig
== GDB_SIGNAL_0
)
1386 printf_filtered (_("Continuing with no signal.\n"));
1388 printf_filtered (_("Continuing with signal %s.\n"),
1389 gdb_signal_to_name (oursig
));
1392 clear_proceed_status (0);
1393 proceed ((CORE_ADDR
) -1, oursig
);
1396 /* Queue a signal to be delivered to the current thread. */
1399 queue_signal_command (const char *signum_exp
, int from_tty
)
1401 enum gdb_signal oursig
;
1402 struct thread_info
*tp
;
1405 ensure_not_tfind_mode ();
1406 ensure_valid_thread ();
1407 ensure_not_running ();
1409 if (signum_exp
== NULL
)
1410 error_no_arg (_("signal number"));
1412 /* It would be even slicker to make signal names be valid expressions,
1413 (the type could be "enum $signal" or some such), then the user could
1414 assign them to convenience variables. */
1415 oursig
= gdb_signal_from_name (signum_exp
);
1417 if (oursig
== GDB_SIGNAL_UNKNOWN
)
1419 /* No, try numeric. */
1420 int num
= parse_and_eval_long (signum_exp
);
1423 oursig
= GDB_SIGNAL_0
;
1425 oursig
= gdb_signal_from_command (num
);
1428 if (oursig
!= GDB_SIGNAL_0
1429 && !signal_pass_state (oursig
))
1430 error (_("Signal handling set to not pass this signal to the program."));
1432 tp
= inferior_thread ();
1433 tp
->suspend
.stop_signal
= oursig
;
1436 /* Data for the FSM that manages the until (with no argument)
1439 struct until_next_fsm
1441 /* The base class. */
1442 struct thread_fsm thread_fsm
;
1444 /* The thread that as current when the command was executed. */
1448 static int until_next_fsm_should_stop (struct thread_fsm
*self
,
1449 struct thread_info
*thread
);
1450 static void until_next_fsm_clean_up (struct thread_fsm
*self
,
1451 struct thread_info
*thread
);
1452 static enum async_reply_reason
1453 until_next_fsm_async_reply_reason (struct thread_fsm
*self
);
1455 /* until_next_fsm's vtable. */
1457 static struct thread_fsm_ops until_next_fsm_ops
=
1460 until_next_fsm_clean_up
,
1461 until_next_fsm_should_stop
,
1462 NULL
, /* return_value */
1463 until_next_fsm_async_reply_reason
,
1466 /* Allocate a new until_next_fsm. */
1468 static struct until_next_fsm
*
1469 new_until_next_fsm (struct interp
*cmd_interp
, int thread
)
1471 struct until_next_fsm
*sm
;
1473 sm
= XCNEW (struct until_next_fsm
);
1474 thread_fsm_ctor (&sm
->thread_fsm
, &until_next_fsm_ops
, cmd_interp
);
1476 sm
->thread
= thread
;
1481 /* Implementation of the 'should_stop' FSM method for the until (with
1485 until_next_fsm_should_stop (struct thread_fsm
*self
,
1486 struct thread_info
*tp
)
1488 if (tp
->control
.stop_step
)
1489 thread_fsm_set_finished (self
);
1494 /* Implementation of the 'clean_up' FSM method for the until (with no
1498 until_next_fsm_clean_up (struct thread_fsm
*self
, struct thread_info
*thread
)
1500 struct until_next_fsm
*sm
= (struct until_next_fsm
*) self
;
1502 delete_longjmp_breakpoint (thread
->global_num
);
1505 /* Implementation of the 'async_reply_reason' FSM method for the until
1506 (with no arg) command. */
1508 static enum async_reply_reason
1509 until_next_fsm_async_reply_reason (struct thread_fsm
*self
)
1511 return EXEC_ASYNC_END_STEPPING_RANGE
;
1514 /* Proceed until we reach a different source line with pc greater than
1515 our current one or exit the function. We skip calls in both cases.
1517 Note that eventually this command should probably be changed so
1518 that only source lines are printed out when we hit the breakpoint
1519 we set. This may involve changes to wait_for_inferior and the
1520 proceed status code. */
1523 until_next_command (int from_tty
)
1525 struct frame_info
*frame
;
1527 struct symbol
*func
;
1528 struct symtab_and_line sal
;
1529 struct thread_info
*tp
= inferior_thread ();
1530 int thread
= tp
->global_num
;
1531 struct cleanup
*old_chain
;
1532 struct until_next_fsm
*sm
;
1534 clear_proceed_status (0);
1537 frame
= get_current_frame ();
1539 /* Step until either exited from this function or greater
1540 than the current line (if in symbolic section) or pc (if
1543 pc
= get_frame_pc (frame
);
1544 func
= find_pc_function (pc
);
1548 struct bound_minimal_symbol msymbol
= lookup_minimal_symbol_by_pc (pc
);
1550 if (msymbol
.minsym
== NULL
)
1551 error (_("Execution is not within a known function."));
1553 tp
->control
.step_range_start
= BMSYMBOL_VALUE_ADDRESS (msymbol
);
1554 /* The upper-bound of step_range is exclusive. In order to make PC
1555 within the range, set the step_range_end with PC + 1. */
1556 tp
->control
.step_range_end
= pc
+ 1;
1560 sal
= find_pc_line (pc
, 0);
1562 tp
->control
.step_range_start
= BLOCK_START (SYMBOL_BLOCK_VALUE (func
));
1563 tp
->control
.step_range_end
= sal
.end
;
1565 tp
->control
.may_range_step
= 1;
1567 tp
->control
.step_over_calls
= STEP_OVER_ALL
;
1569 set_longjmp_breakpoint (tp
, get_frame_id (frame
));
1570 old_chain
= make_cleanup (delete_longjmp_breakpoint_cleanup
, &thread
);
1572 sm
= new_until_next_fsm (command_interp (), tp
->global_num
);
1573 tp
->thread_fsm
= &sm
->thread_fsm
;
1574 discard_cleanups (old_chain
);
1576 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
);
1580 until_command (const char *arg
, int from_tty
)
1585 ensure_not_tfind_mode ();
1586 ensure_valid_thread ();
1587 ensure_not_running ();
1589 /* Find out whether we must run in the background. */
1590 gdb::unique_xmalloc_ptr
<char> stripped
= strip_bg_char (arg
, &async_exec
);
1591 arg
= stripped
.get ();
1593 prepare_execution_command (¤t_target
, async_exec
);
1596 until_break_command (arg
, from_tty
, 0);
1598 until_next_command (from_tty
);
1602 advance_command (const char *arg
, int from_tty
)
1607 ensure_not_tfind_mode ();
1608 ensure_valid_thread ();
1609 ensure_not_running ();
1612 error_no_arg (_("a location"));
1614 /* Find out whether we must run in the background. */
1615 gdb::unique_xmalloc_ptr
<char> stripped
= strip_bg_char (arg
, &async_exec
);
1616 arg
= stripped
.get ();
1618 prepare_execution_command (¤t_target
, async_exec
);
1620 until_break_command (arg
, from_tty
, 1);
1623 /* Return the value of the result of a function at the end of a 'finish'
1624 command/BP. DTOR_DATA (if not NULL) can represent inferior registers
1625 right after an inferior call has finished. */
1628 get_return_value (struct value
*function
, struct type
*value_type
)
1630 regcache
stop_regs (regcache::readonly
, *get_current_regcache ());
1631 struct gdbarch
*gdbarch
= stop_regs
.arch ();
1632 struct value
*value
;
1634 value_type
= check_typedef (value_type
);
1635 gdb_assert (TYPE_CODE (value_type
) != TYPE_CODE_VOID
);
1637 /* FIXME: 2003-09-27: When returning from a nested inferior function
1638 call, it's possible (with no help from the architecture vector)
1639 to locate and return/print a "struct return" value. This is just
1640 a more complicated case of what is already being done in the
1641 inferior function call code. In fact, when inferior function
1642 calls are made async, this will likely be made the norm. */
1644 switch (gdbarch_return_value (gdbarch
, function
, value_type
,
1647 case RETURN_VALUE_REGISTER_CONVENTION
:
1648 case RETURN_VALUE_ABI_RETURNS_ADDRESS
:
1649 case RETURN_VALUE_ABI_PRESERVES_ADDRESS
:
1650 value
= allocate_value (value_type
);
1651 gdbarch_return_value (gdbarch
, function
, value_type
, &stop_regs
,
1652 value_contents_raw (value
), NULL
);
1654 case RETURN_VALUE_STRUCT_CONVENTION
:
1658 internal_error (__FILE__
, __LINE__
, _("bad switch"));
1664 /* The captured function return value/type and its position in the
1667 struct return_value_info
1669 /* The captured return value. May be NULL if we weren't able to
1670 retrieve it. See get_return_value. */
1671 struct value
*value
;
1673 /* The return type. In some cases, we'll not be able extract the
1674 return value, but we always know the type. */
1677 /* If we captured a value, this is the value history index. */
1678 int value_history_index
;
1681 /* Helper for print_return_value. */
1684 print_return_value_1 (struct ui_out
*uiout
, struct return_value_info
*rv
)
1686 if (rv
->value
!= NULL
)
1688 struct value_print_options opts
;
1691 uiout
->text ("Value returned is ");
1692 uiout
->field_fmt ("gdb-result-var", "$%d",
1693 rv
->value_history_index
);
1694 uiout
->text (" = ");
1695 get_no_prettyformat_print_options (&opts
);
1699 value_print (rv
->value
, &stb
, &opts
);
1700 uiout
->field_stream ("return-value", stb
);
1705 std::string type_name
= type_to_string (rv
->type
);
1706 uiout
->text ("Value returned has type: ");
1707 uiout
->field_string ("return-type", type_name
.c_str ());
1709 uiout
->text (" Cannot determine contents\n");
1713 /* Print the result of a function at the end of a 'finish' command.
1714 RV points at an object representing the captured return value/type
1715 and its position in the value history. */
1718 print_return_value (struct ui_out
*uiout
, struct return_value_info
*rv
)
1720 if (rv
->type
== NULL
|| TYPE_CODE (rv
->type
) == TYPE_CODE_VOID
)
1725 /* print_return_value_1 can throw an exception in some
1726 circumstances. We need to catch this so that we still
1727 delete the breakpoint. */
1728 print_return_value_1 (uiout
, rv
);
1730 CATCH (ex
, RETURN_MASK_ALL
)
1732 exception_print (gdb_stdout
, ex
);
1737 /* Data for the FSM that manages the finish command. */
1739 struct finish_command_fsm
1741 /* The base class. */
1742 struct thread_fsm thread_fsm
;
1744 /* The momentary breakpoint set at the function's return address in
1746 struct breakpoint
*breakpoint
;
1748 /* The function that we're stepping out of. */
1749 struct symbol
*function
;
1751 /* If the FSM finishes successfully, this stores the function's
1753 struct return_value_info return_value
;
1756 static int finish_command_fsm_should_stop (struct thread_fsm
*self
,
1757 struct thread_info
*thread
);
1758 static void finish_command_fsm_clean_up (struct thread_fsm
*self
,
1759 struct thread_info
*thread
);
1760 static struct return_value_info
*
1761 finish_command_fsm_return_value (struct thread_fsm
*self
);
1762 static enum async_reply_reason
1763 finish_command_fsm_async_reply_reason (struct thread_fsm
*self
);
1765 /* finish_command_fsm's vtable. */
1767 static struct thread_fsm_ops finish_command_fsm_ops
=
1770 finish_command_fsm_clean_up
,
1771 finish_command_fsm_should_stop
,
1772 finish_command_fsm_return_value
,
1773 finish_command_fsm_async_reply_reason
,
1774 NULL
, /* should_notify_stop */
1777 /* Allocate a new finish_command_fsm. */
1779 static struct finish_command_fsm
*
1780 new_finish_command_fsm (struct interp
*cmd_interp
)
1782 struct finish_command_fsm
*sm
;
1784 sm
= XCNEW (struct finish_command_fsm
);
1785 thread_fsm_ctor (&sm
->thread_fsm
, &finish_command_fsm_ops
, cmd_interp
);
1790 /* Implementation of the 'should_stop' FSM method for the finish
1791 commands. Detects whether the thread stepped out of the function
1792 successfully, and if so, captures the function's return value and
1793 marks the FSM finished. */
1796 finish_command_fsm_should_stop (struct thread_fsm
*self
,
1797 struct thread_info
*tp
)
1799 struct finish_command_fsm
*f
= (struct finish_command_fsm
*) self
;
1800 struct return_value_info
*rv
= &f
->return_value
;
1802 if (f
->function
!= NULL
1803 && bpstat_find_breakpoint (tp
->control
.stop_bpstat
,
1804 f
->breakpoint
) != NULL
)
1807 thread_fsm_set_finished (self
);
1809 rv
->type
= TYPE_TARGET_TYPE (SYMBOL_TYPE (f
->function
));
1810 if (rv
->type
== NULL
)
1811 internal_error (__FILE__
, __LINE__
,
1812 _("finish_command: function has no target type"));
1814 if (TYPE_CODE (rv
->type
) != TYPE_CODE_VOID
)
1818 func
= read_var_value (f
->function
, NULL
, get_current_frame ());
1819 rv
->value
= get_return_value (func
, rv
->type
);
1820 if (rv
->value
!= NULL
)
1821 rv
->value_history_index
= record_latest_value (rv
->value
);
1824 else if (tp
->control
.stop_step
)
1826 /* Finishing from an inline frame, or reverse finishing. In
1827 either case, there's no way to retrieve the return value. */
1828 thread_fsm_set_finished (self
);
1834 /* Implementation of the 'clean_up' FSM method for the finish
1838 finish_command_fsm_clean_up (struct thread_fsm
*self
,
1839 struct thread_info
*thread
)
1841 struct finish_command_fsm
*f
= (struct finish_command_fsm
*) self
;
1843 if (f
->breakpoint
!= NULL
)
1845 delete_breakpoint (f
->breakpoint
);
1846 f
->breakpoint
= NULL
;
1848 delete_longjmp_breakpoint (thread
->global_num
);
1851 /* Implementation of the 'return_value' FSM method for the finish
1854 static struct return_value_info
*
1855 finish_command_fsm_return_value (struct thread_fsm
*self
)
1857 struct finish_command_fsm
*f
= (struct finish_command_fsm
*) self
;
1859 return &f
->return_value
;
1862 /* Implementation of the 'async_reply_reason' FSM method for the
1865 static enum async_reply_reason
1866 finish_command_fsm_async_reply_reason (struct thread_fsm
*self
)
1868 if (execution_direction
== EXEC_REVERSE
)
1869 return EXEC_ASYNC_END_STEPPING_RANGE
;
1871 return EXEC_ASYNC_FUNCTION_FINISHED
;
1874 /* finish_backward -- helper function for finish_command. */
1877 finish_backward (struct finish_command_fsm
*sm
)
1879 struct symtab_and_line sal
;
1880 struct thread_info
*tp
= inferior_thread ();
1882 CORE_ADDR func_addr
;
1884 pc
= get_frame_pc (get_current_frame ());
1886 if (find_pc_partial_function (pc
, NULL
, &func_addr
, NULL
) == 0)
1887 error (_("Cannot find bounds of current function"));
1889 sal
= find_pc_line (func_addr
, 0);
1891 tp
->control
.proceed_to_finish
= 1;
1892 /* Special case: if we're sitting at the function entry point,
1893 then all we need to do is take a reverse singlestep. We
1894 don't need to set a breakpoint, and indeed it would do us
1897 Note that this can only happen at frame #0, since there's
1898 no way that a function up the stack can have a return address
1899 that's equal to its entry point. */
1903 struct frame_info
*frame
= get_selected_frame (NULL
);
1904 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1906 /* Set a step-resume at the function's entry point. Once that's
1907 hit, we'll do one more step backwards. */
1908 symtab_and_line sr_sal
;
1910 sr_sal
.pspace
= get_frame_program_space (frame
);
1911 insert_step_resume_breakpoint_at_sal (gdbarch
,
1912 sr_sal
, null_frame_id
);
1914 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
);
1918 /* We're almost there -- we just need to back up by one more
1920 tp
->control
.step_range_start
= tp
->control
.step_range_end
= 1;
1921 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
);
1925 /* finish_forward -- helper function for finish_command. FRAME is the
1926 frame that called the function we're about to step out of. */
1929 finish_forward (struct finish_command_fsm
*sm
, struct frame_info
*frame
)
1931 struct frame_id frame_id
= get_frame_id (frame
);
1932 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1933 struct symtab_and_line sal
;
1934 struct thread_info
*tp
= inferior_thread ();
1936 sal
= find_pc_line (get_frame_pc (frame
), 0);
1937 sal
.pc
= get_frame_pc (frame
);
1939 sm
->breakpoint
= set_momentary_breakpoint (gdbarch
, sal
,
1940 get_stack_frame_id (frame
),
1941 bp_finish
).release ();
1943 /* set_momentary_breakpoint invalidates FRAME. */
1946 set_longjmp_breakpoint (tp
, frame_id
);
1948 /* We want to print return value, please... */
1949 tp
->control
.proceed_to_finish
= 1;
1951 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
);
1954 /* Skip frames for "finish". */
1956 static struct frame_info
*
1957 skip_finish_frames (struct frame_info
*frame
)
1959 struct frame_info
*start
;
1965 frame
= skip_tailcall_frames (frame
);
1969 frame
= skip_unwritable_frames (frame
);
1973 while (start
!= frame
);
1978 /* "finish": Set a temporary breakpoint at the place the selected
1979 frame will return to, then continue. */
1982 finish_command (const char *arg
, int from_tty
)
1984 struct frame_info
*frame
;
1986 struct finish_command_fsm
*sm
;
1987 struct thread_info
*tp
;
1990 ensure_not_tfind_mode ();
1991 ensure_valid_thread ();
1992 ensure_not_running ();
1994 /* Find out whether we must run in the background. */
1995 gdb::unique_xmalloc_ptr
<char> stripped
= strip_bg_char (arg
, &async_exec
);
1996 arg
= stripped
.get ();
1998 prepare_execution_command (¤t_target
, async_exec
);
2001 error (_("The \"finish\" command does not take any arguments."));
2003 frame
= get_prev_frame (get_selected_frame (_("No selected frame.")));
2005 error (_("\"finish\" not meaningful in the outermost frame."));
2007 clear_proceed_status (0);
2009 tp
= inferior_thread ();
2011 sm
= new_finish_command_fsm (command_interp ());
2013 tp
->thread_fsm
= &sm
->thread_fsm
;
2015 /* Finishing from an inline frame is completely different. We don't
2016 try to show the "return value" - no way to locate it. */
2017 if (get_frame_type (get_selected_frame (_("No selected frame.")))
2020 /* Claim we are stepping in the calling frame. An empty step
2021 range means that we will stop once we aren't in a function
2022 called by that frame. We don't use the magic "1" value for
2023 step_range_end, because then infrun will think this is nexti,
2024 and not step over the rest of this inlined function call. */
2025 set_step_info (frame
, {});
2026 tp
->control
.step_range_start
= get_frame_pc (frame
);
2027 tp
->control
.step_range_end
= tp
->control
.step_range_start
;
2028 tp
->control
.step_over_calls
= STEP_OVER_ALL
;
2030 /* Print info on the selected frame, including level number but not
2034 printf_filtered (_("Run till exit from "));
2035 print_stack_frame (get_selected_frame (NULL
), 1, LOCATION
, 0);
2038 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
);
2042 /* Find the function we will return from. */
2044 sm
->function
= find_pc_function (get_frame_pc (get_selected_frame (NULL
)));
2046 /* Print info on the selected frame, including level number but not
2050 if (execution_direction
== EXEC_REVERSE
)
2051 printf_filtered (_("Run back to call of "));
2054 if (sm
->function
!= NULL
&& TYPE_NO_RETURN (sm
->function
->type
)
2055 && !query (_("warning: Function %s does not return normally.\n"
2056 "Try to finish anyway? "),
2057 SYMBOL_PRINT_NAME (sm
->function
)))
2058 error (_("Not confirmed."));
2059 printf_filtered (_("Run till exit from "));
2062 print_stack_frame (get_selected_frame (NULL
), 1, LOCATION
, 0);
2065 if (execution_direction
== EXEC_REVERSE
)
2066 finish_backward (sm
);
2069 frame
= skip_finish_frames (frame
);
2072 error (_("Cannot find the caller frame."));
2074 finish_forward (sm
, frame
);
2080 info_program_command (const char *args
, int from_tty
)
2084 struct thread_info
*tp
;
2087 if (!target_has_execution
)
2089 printf_filtered (_("The program being debugged is not being run.\n"));
2094 ptid
= inferior_ptid
;
2097 struct target_waitstatus ws
;
2099 get_last_target_status (&ptid
, &ws
);
2102 if (ptid_equal (ptid
, null_ptid
) || is_exited (ptid
))
2103 error (_("Invalid selected thread."));
2104 else if (is_running (ptid
))
2105 error (_("Selected thread is running."));
2107 tp
= find_thread_ptid (ptid
);
2108 bs
= tp
->control
.stop_bpstat
;
2109 stat
= bpstat_num (&bs
, &num
);
2111 target_files_info ();
2112 printf_filtered (_("Program stopped at %s.\n"),
2113 paddress (target_gdbarch (), stop_pc
));
2114 if (tp
->control
.stop_step
)
2115 printf_filtered (_("It stopped after being stepped.\n"));
2118 /* There may be several breakpoints in the same place, so this
2119 isn't as strange as it seems. */
2124 printf_filtered (_("It stopped at a breakpoint "
2125 "that has since been deleted.\n"));
2128 printf_filtered (_("It stopped at breakpoint %d.\n"), num
);
2129 stat
= bpstat_num (&bs
, &num
);
2132 else if (tp
->suspend
.stop_signal
!= GDB_SIGNAL_0
)
2134 printf_filtered (_("It stopped with signal %s, %s.\n"),
2135 gdb_signal_to_name (tp
->suspend
.stop_signal
),
2136 gdb_signal_to_string (tp
->suspend
.stop_signal
));
2141 printf_filtered (_("Type \"info stack\" or \"info "
2142 "registers\" for more information.\n"));
2147 environment_info (const char *var
, int from_tty
)
2151 const char *val
= current_inferior ()->environment
.get (var
);
2155 puts_filtered (var
);
2156 puts_filtered (" = ");
2157 puts_filtered (val
);
2158 puts_filtered ("\n");
2162 puts_filtered ("Environment variable \"");
2163 puts_filtered (var
);
2164 puts_filtered ("\" not defined.\n");
2169 char **envp
= current_inferior ()->environment
.envp ();
2171 for (int idx
= 0; envp
[idx
] != NULL
; ++idx
)
2173 puts_filtered (envp
[idx
]);
2174 puts_filtered ("\n");
2180 set_environment_command (const char *arg
, int from_tty
)
2182 const char *p
, *val
;
2186 error_no_arg (_("environment variable and value"));
2188 /* Find seperation between variable name and value. */
2189 p
= (char *) strchr (arg
, '=');
2190 val
= (char *) strchr (arg
, ' ');
2192 if (p
!= 0 && val
!= 0)
2194 /* We have both a space and an equals. If the space is before the
2195 equals, walk forward over the spaces til we see a nonspace
2196 (possibly the equals). */
2201 /* Now if the = is after the char following the spaces,
2202 take the char following the spaces. */
2206 else if (val
!= 0 && p
== 0)
2210 error_no_arg (_("environment variable to set"));
2212 if (p
== 0 || p
[1] == 0)
2216 p
= arg
+ strlen (arg
); /* So that savestring below will work. */
2220 /* Not setting variable value to null. */
2222 while (*val
== ' ' || *val
== '\t')
2226 while (p
!= arg
&& (p
[-1] == ' ' || p
[-1] == '\t'))
2229 std::string
var (arg
, p
- arg
);
2232 printf_filtered (_("Setting environment variable "
2233 "\"%s\" to null value.\n"),
2235 current_inferior ()->environment
.set (var
.c_str (), "");
2238 current_inferior ()->environment
.set (var
.c_str (), val
);
2242 unset_environment_command (const char *var
, int from_tty
)
2246 /* If there is no argument, delete all environment variables.
2247 Ask for confirmation if reading from the terminal. */
2248 if (!from_tty
|| query (_("Delete all environment variables? ")))
2249 current_inferior ()->environment
.clear ();
2252 current_inferior ()->environment
.unset (var
);
2255 /* Handle the execution path (PATH variable). */
2257 static const char path_var_name
[] = "PATH";
2260 path_info (const char *args
, int from_tty
)
2262 puts_filtered ("Executable and object file path: ");
2263 puts_filtered (current_inferior ()->environment
.get (path_var_name
));
2264 puts_filtered ("\n");
2267 /* Add zero or more directories to the front of the execution path. */
2270 path_command (const char *dirname
, int from_tty
)
2276 env
= current_inferior ()->environment
.get (path_var_name
);
2277 /* Can be null if path is not set. */
2280 exec_path
= xstrdup (env
);
2281 mod_path (dirname
, &exec_path
);
2282 current_inferior ()->environment
.set (path_var_name
, exec_path
);
2285 path_info ((char *) NULL
, from_tty
);
2289 /* Print out the register NAME with value VAL, to FILE, in the default
2293 default_print_one_register_info (struct ui_file
*file
,
2297 struct type
*regtype
= value_type (val
);
2298 int print_raw_format
;
2300 fputs_filtered (name
, file
);
2301 print_spaces_filtered (15 - strlen (name
), file
);
2303 print_raw_format
= (value_entirely_available (val
)
2304 && !value_optimized_out (val
));
2306 /* If virtual format is floating, print it that way, and in raw
2308 if (TYPE_CODE (regtype
) == TYPE_CODE_FLT
2309 || TYPE_CODE (regtype
) == TYPE_CODE_DECFLOAT
)
2311 struct value_print_options opts
;
2312 const gdb_byte
*valaddr
= value_contents_for_printing (val
);
2313 enum bfd_endian byte_order
= gdbarch_byte_order (get_type_arch (regtype
));
2315 get_user_print_options (&opts
);
2319 value_embedded_offset (val
), 0,
2320 file
, 0, val
, &opts
, current_language
);
2322 if (print_raw_format
)
2324 fprintf_filtered (file
, "\t(raw ");
2325 print_hex_chars (file
, valaddr
, TYPE_LENGTH (regtype
), byte_order
,
2327 fprintf_filtered (file
, ")");
2332 struct value_print_options opts
;
2334 /* Print the register in hex. */
2335 get_formatted_print_options (&opts
, 'x');
2338 value_embedded_offset (val
), 0,
2339 file
, 0, val
, &opts
, current_language
);
2340 /* If not a vector register, print it also according to its
2342 if (print_raw_format
&& TYPE_VECTOR (regtype
) == 0)
2344 get_user_print_options (&opts
);
2346 fprintf_filtered (file
, "\t");
2348 value_embedded_offset (val
), 0,
2349 file
, 0, val
, &opts
, current_language
);
2353 fprintf_filtered (file
, "\n");
2356 /* Print out the machine register regnum. If regnum is -1, print all
2357 registers (print_all == 1) or all non-float and non-vector
2358 registers (print_all == 0).
2360 For most machines, having all_registers_info() print the
2361 register(s) one per line is good enough. If a different format is
2362 required, (eg, for MIPS or Pyramid 90x, which both have lots of
2363 regs), or there is an existing convention for showing all the
2364 registers, define the architecture method PRINT_REGISTERS_INFO to
2365 provide that format. */
2368 default_print_registers_info (struct gdbarch
*gdbarch
,
2369 struct ui_file
*file
,
2370 struct frame_info
*frame
,
2371 int regnum
, int print_all
)
2374 const int numregs
= gdbarch_num_regs (gdbarch
)
2375 + gdbarch_num_pseudo_regs (gdbarch
);
2377 for (i
= 0; i
< numregs
; i
++)
2379 /* Decide between printing all regs, non-float / vector regs, or
2385 if (!gdbarch_register_reggroup_p (gdbarch
, i
, all_reggroup
))
2390 if (!gdbarch_register_reggroup_p (gdbarch
, i
, general_reggroup
))
2400 /* If the register name is empty, it is undefined for this
2401 processor, so don't display anything. */
2402 if (gdbarch_register_name (gdbarch
, i
) == NULL
2403 || *(gdbarch_register_name (gdbarch
, i
)) == '\0')
2406 default_print_one_register_info (file
,
2407 gdbarch_register_name (gdbarch
, i
),
2408 value_of_register (i
, frame
));
2413 registers_info (const char *addr_exp
, int fpregs
)
2415 struct frame_info
*frame
;
2416 struct gdbarch
*gdbarch
;
2418 if (!target_has_registers
)
2419 error (_("The program has no registers now."));
2420 frame
= get_selected_frame (NULL
);
2421 gdbarch
= get_frame_arch (frame
);
2425 gdbarch_print_registers_info (gdbarch
, gdb_stdout
,
2430 while (*addr_exp
!= '\0')
2435 /* Skip leading white space. */
2436 addr_exp
= skip_spaces (addr_exp
);
2438 /* Discard any leading ``$''. Check that there is something
2439 resembling a register following it. */
2440 if (addr_exp
[0] == '$')
2442 if (isspace ((*addr_exp
)) || (*addr_exp
) == '\0')
2443 error (_("Missing register name"));
2445 /* Find the start/end of this register name/num/group. */
2447 while ((*addr_exp
) != '\0' && !isspace ((*addr_exp
)))
2451 /* Figure out what we've found and display it. */
2453 /* A register name? */
2455 int regnum
= user_reg_map_name_to_regnum (gdbarch
, start
, end
- start
);
2459 /* User registers lie completely outside of the range of
2460 normal registers. Catch them early so that the target
2462 if (regnum
>= gdbarch_num_regs (gdbarch
)
2463 + gdbarch_num_pseudo_regs (gdbarch
))
2465 struct value
*regval
= value_of_user_reg (regnum
, frame
);
2466 const char *regname
= user_reg_map_regnum_to_name (gdbarch
,
2469 /* Print in the same fashion
2470 gdbarch_print_registers_info's default
2471 implementation prints. */
2472 default_print_one_register_info (gdb_stdout
,
2477 gdbarch_print_registers_info (gdbarch
, gdb_stdout
,
2478 frame
, regnum
, fpregs
);
2483 /* A register group? */
2485 struct reggroup
*group
;
2487 for (group
= reggroup_next (gdbarch
, NULL
);
2489 group
= reggroup_next (gdbarch
, group
))
2491 /* Don't bother with a length check. Should the user
2492 enter a short register group name, go with the first
2493 group that matches. */
2494 if (strncmp (start
, reggroup_name (group
), end
- start
) == 0)
2502 regnum
< gdbarch_num_regs (gdbarch
)
2503 + gdbarch_num_pseudo_regs (gdbarch
);
2506 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, group
))
2507 gdbarch_print_registers_info (gdbarch
,
2515 /* Nothing matched. */
2516 error (_("Invalid register `%.*s'"), (int) (end
- start
), start
);
2521 info_all_registers_command (const char *addr_exp
, int from_tty
)
2523 registers_info (addr_exp
, 1);
2527 info_registers_command (const char *addr_exp
, int from_tty
)
2529 registers_info (addr_exp
, 0);
2533 print_vector_info (struct ui_file
*file
,
2534 struct frame_info
*frame
, const char *args
)
2536 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
2538 if (gdbarch_print_vector_info_p (gdbarch
))
2539 gdbarch_print_vector_info (gdbarch
, file
, frame
, args
);
2543 int printed_something
= 0;
2546 regnum
< gdbarch_num_regs (gdbarch
)
2547 + gdbarch_num_pseudo_regs (gdbarch
);
2550 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, vector_reggroup
))
2552 printed_something
= 1;
2553 gdbarch_print_registers_info (gdbarch
, file
, frame
, regnum
, 1);
2556 if (!printed_something
)
2557 fprintf_filtered (file
, "No vector information\n");
2562 info_vector_command (const char *args
, int from_tty
)
2564 if (!target_has_registers
)
2565 error (_("The program has no registers now."));
2567 print_vector_info (gdb_stdout
, get_selected_frame (NULL
), args
);
2570 /* Kill the inferior process. Make us have no inferior. */
2573 kill_command (const char *arg
, int from_tty
)
2575 /* FIXME: This should not really be inferior_ptid (or target_has_execution).
2576 It should be a distinct flag that indicates that a target is active, cuz
2577 some targets don't have processes! */
2579 if (ptid_equal (inferior_ptid
, null_ptid
))
2580 error (_("The program is not being run."));
2581 if (!query (_("Kill the program being debugged? ")))
2582 error (_("Not confirmed."));
2585 /* If we still have other inferiors to debug, then don't mess with
2586 with their threads. */
2587 if (!have_inferiors ())
2589 init_thread_list (); /* Destroy thread info. */
2591 /* Killing off the inferior can leave us with a core file. If
2592 so, print the state we are left in. */
2593 if (target_has_stack
)
2595 printf_filtered (_("In %s,\n"), target_longname
);
2596 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
, 1);
2599 bfd_cache_close_all ();
2602 /* Used in `attach&' command. ARG is a point to an integer
2603 representing a process id. Proceed threads of this process iff
2604 they stopped due to debugger request, and when they did, they
2605 reported a clean stop (GDB_SIGNAL_0). Do not proceed threads
2606 that have been explicitly been told to stop. */
2609 proceed_after_attach_callback (struct thread_info
*thread
,
2612 int pid
= * (int *) arg
;
2614 if (ptid_get_pid (thread
->ptid
) == pid
2615 && !is_exited (thread
->ptid
)
2616 && !is_executing (thread
->ptid
)
2617 && !thread
->stop_requested
2618 && thread
->suspend
.stop_signal
== GDB_SIGNAL_0
)
2620 switch_to_thread (thread
->ptid
);
2621 clear_proceed_status (0);
2622 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
);
2629 proceed_after_attach (int pid
)
2631 /* Don't error out if the current thread is running, because
2632 there may be other stopped threads. */
2634 /* Backup current thread and selected frame. */
2635 scoped_restore_current_thread restore_thread
;
2637 iterate_over_threads (proceed_after_attach_callback
, &pid
);
2640 /* See inferior.h. */
2643 setup_inferior (int from_tty
)
2645 struct inferior
*inferior
;
2647 inferior
= current_inferior ();
2648 inferior
->needs_setup
= 0;
2650 /* If no exec file is yet known, try to determine it from the
2652 if (get_exec_file (0) == NULL
)
2653 exec_file_locate_attach (ptid_get_pid (inferior_ptid
), 1, from_tty
);
2656 reopen_exec_file ();
2660 /* Take any necessary post-attaching actions for this platform. */
2661 target_post_attach (ptid_get_pid (inferior_ptid
));
2663 post_create_inferior (¤t_target
, from_tty
);
2666 /* What to do after the first program stops after attaching. */
2667 enum attach_post_wait_mode
2669 /* Do nothing. Leaves threads as they are. */
2670 ATTACH_POST_WAIT_NOTHING
,
2672 /* Re-resume threads that are marked running. */
2673 ATTACH_POST_WAIT_RESUME
,
2675 /* Stop all threads. */
2676 ATTACH_POST_WAIT_STOP
,
2679 /* Called after we've attached to a process and we've seen it stop for
2680 the first time. If ASYNC_EXEC is true, re-resume threads that
2681 should be running. Else if ATTACH, */
2684 attach_post_wait (const char *args
, int from_tty
, enum attach_post_wait_mode mode
)
2686 struct inferior
*inferior
;
2688 inferior
= current_inferior ();
2689 inferior
->control
.stop_soon
= NO_STOP_QUIETLY
;
2691 if (inferior
->needs_setup
)
2692 setup_inferior (from_tty
);
2694 if (mode
== ATTACH_POST_WAIT_RESUME
)
2696 /* The user requested an `attach&', so be sure to leave threads
2697 that didn't get a signal running. */
2699 /* Immediatelly resume all suspended threads of this inferior,
2700 and this inferior only. This should have no effect on
2701 already running threads. If a thread has been stopped with a
2702 signal, leave it be. */
2704 proceed_after_attach (inferior
->pid
);
2707 if (inferior_thread ()->suspend
.stop_signal
== GDB_SIGNAL_0
)
2709 clear_proceed_status (0);
2710 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
);
2714 else if (mode
== ATTACH_POST_WAIT_STOP
)
2716 /* The user requested a plain `attach', so be sure to leave
2717 the inferior stopped. */
2719 /* At least the current thread is already stopped. */
2721 /* In all-stop, by definition, all threads have to be already
2722 stopped at this point. In non-stop, however, although the
2723 selected thread is stopped, others may still be executing.
2724 Be sure to explicitly stop all threads of the process. This
2725 should have no effect on already stopped threads. */
2727 target_stop (pid_to_ptid (inferior
->pid
));
2728 else if (target_is_non_stop_p ())
2730 struct thread_info
*thread
;
2731 struct thread_info
*lowest
= inferior_thread ();
2732 int pid
= current_inferior ()->pid
;
2734 stop_all_threads ();
2736 /* It's not defined which thread will report the attach
2737 stop. For consistency, always select the thread with
2738 lowest GDB number, which should be the main thread, if it
2740 ALL_NON_EXITED_THREADS (thread
)
2742 if (ptid_get_pid (thread
->ptid
) == pid
)
2744 if (thread
->inf
->num
< lowest
->inf
->num
2745 || thread
->per_inf_num
< lowest
->per_inf_num
)
2750 switch_to_thread (lowest
->ptid
);
2753 /* Tell the user/frontend where we're stopped. */
2755 if (deprecated_attach_hook
)
2756 deprecated_attach_hook ();
2760 struct attach_command_continuation_args
2764 enum attach_post_wait_mode mode
;
2768 attach_command_continuation (void *args
, int err
)
2770 struct attach_command_continuation_args
*a
2771 = (struct attach_command_continuation_args
*) args
;
2776 attach_post_wait (a
->args
, a
->from_tty
, a
->mode
);
2780 attach_command_continuation_free_args (void *args
)
2782 struct attach_command_continuation_args
*a
2783 = (struct attach_command_continuation_args
*) args
;
2789 /* "attach" command entry point. Takes a program started up outside
2790 of gdb and ``attaches'' to it. This stops it cold in its tracks
2791 and allows us to start debugging it. */
2794 attach_command (const char *args
, int from_tty
)
2797 struct target_ops
*attach_target
;
2798 struct inferior
*inferior
= current_inferior ();
2799 enum attach_post_wait_mode mode
;
2801 dont_repeat (); /* Not for the faint of heart */
2803 if (gdbarch_has_global_solist (target_gdbarch ()))
2804 /* Don't complain if all processes share the same symbol
2807 else if (target_has_execution
)
2809 if (query (_("A program is being debugged already. Kill it? ")))
2812 error (_("Not killed."));
2815 /* Clean up any leftovers from other runs. Some other things from
2816 this function should probably be moved into target_pre_inferior. */
2817 target_pre_inferior (from_tty
);
2819 gdb::unique_xmalloc_ptr
<char> stripped
= strip_bg_char (args
, &async_exec
);
2820 args
= stripped
.get ();
2822 attach_target
= find_attach_target ();
2824 prepare_execution_command (attach_target
, async_exec
);
2826 if (non_stop
&& !attach_target
->to_supports_non_stop (attach_target
))
2827 error (_("Cannot attach to this target in non-stop mode"));
2829 attach_target
->to_attach (attach_target
, args
, from_tty
);
2830 /* to_attach should push the target, so after this point we
2831 shouldn't refer to attach_target again. */
2832 attach_target
= NULL
;
2834 /* Set up the "saved terminal modes" of the inferior
2835 based on what modes we are starting it with. */
2836 target_terminal::init ();
2838 /* Install inferior's terminal modes. This may look like a no-op,
2839 as we've just saved them above, however, this does more than
2840 restore terminal settings:
2842 - installs a SIGINT handler that forwards SIGINT to the inferior.
2843 Otherwise a Ctrl-C pressed just while waiting for the initial
2844 stop would end up as a spurious Quit.
2846 - removes stdin from the event loop, which we need if attaching
2847 in the foreground, otherwise on targets that report an initial
2848 stop on attach (which are most) we'd process input/commands
2849 while we're in the event loop waiting for that stop. That is,
2850 before the attach continuation runs and the command is really
2852 target_terminal::inferior ();
2854 /* Set up execution context to know that we should return from
2855 wait_for_inferior as soon as the target reports a stop. */
2856 init_wait_for_inferior ();
2857 clear_proceed_status (0);
2859 inferior
->needs_setup
= 1;
2861 if (target_is_non_stop_p ())
2863 /* If we find that the current thread isn't stopped, explicitly
2864 do so now, because we're going to install breakpoints and
2868 /* The user requested an `attach&'; stop just one thread. */
2869 target_stop (inferior_ptid
);
2871 /* The user requested an `attach', so stop all threads of this
2873 target_stop (pid_to_ptid (ptid_get_pid (inferior_ptid
)));
2876 mode
= async_exec
? ATTACH_POST_WAIT_RESUME
: ATTACH_POST_WAIT_STOP
;
2878 /* Some system don't generate traps when attaching to inferior.
2879 E.g. Mach 3 or GNU hurd. */
2880 if (!target_attach_no_wait
)
2882 struct attach_command_continuation_args
*a
;
2884 /* Careful here. See comments in inferior.h. Basically some
2885 OSes don't ignore SIGSTOPs on continue requests anymore. We
2886 need a way for handle_inferior_event to reset the stop_signal
2887 variable after an attach, and this is what
2888 STOP_QUIETLY_NO_SIGSTOP is for. */
2889 inferior
->control
.stop_soon
= STOP_QUIETLY_NO_SIGSTOP
;
2891 /* Wait for stop. */
2892 a
= XNEW (struct attach_command_continuation_args
);
2893 a
->args
= xstrdup (args
);
2894 a
->from_tty
= from_tty
;
2896 add_inferior_continuation (attach_command_continuation
, a
,
2897 attach_command_continuation_free_args
);
2899 if (!target_is_async_p ())
2900 mark_infrun_async_event_handler ();
2904 attach_post_wait (args
, from_tty
, mode
);
2907 /* We had just found out that the target was already attached to an
2908 inferior. PTID points at a thread of this new inferior, that is
2909 the most likely to be stopped right now, but not necessarily so.
2910 The new inferior is assumed to be already added to the inferior
2911 list at this point. If LEAVE_RUNNING, then leave the threads of
2912 this inferior running, except those we've explicitly seen reported
2916 notice_new_inferior (ptid_t ptid
, int leave_running
, int from_tty
)
2918 enum attach_post_wait_mode mode
2919 = leave_running
? ATTACH_POST_WAIT_RESUME
: ATTACH_POST_WAIT_NOTHING
;
2921 gdb::optional
<scoped_restore_current_thread
> restore_thread
;
2923 if (inferior_ptid
!= null_ptid
)
2924 restore_thread
.emplace ();
2926 /* Avoid reading registers -- we haven't fetched the target
2928 switch_to_thread_no_regs (find_thread_ptid (ptid
));
2930 /* When we "notice" a new inferior we need to do all the things we
2931 would normally do if we had just attached to it. */
2933 if (is_executing (inferior_ptid
))
2935 struct attach_command_continuation_args
*a
;
2936 struct inferior
*inferior
= current_inferior ();
2938 /* We're going to install breakpoints, and poke at memory,
2939 ensure that the inferior is stopped for a moment while we do
2941 target_stop (inferior_ptid
);
2943 inferior
->control
.stop_soon
= STOP_QUIETLY_REMOTE
;
2945 /* Wait for stop before proceeding. */
2946 a
= XNEW (struct attach_command_continuation_args
);
2947 a
->args
= xstrdup ("");
2948 a
->from_tty
= from_tty
;
2950 add_inferior_continuation (attach_command_continuation
, a
,
2951 attach_command_continuation_free_args
);
2956 attach_post_wait ("" /* args */, from_tty
, mode
);
2961 * takes a program previously attached to and detaches it.
2962 * The program resumes execution and will no longer stop
2963 * on signals, etc. We better not have left any breakpoints
2964 * in the program or it'll die when it hits one. For this
2965 * to work, it may be necessary for the process to have been
2966 * previously attached. It *might* work if the program was
2967 * started via the normal ptrace (PTRACE_TRACEME).
2971 detach_command (const char *args
, int from_tty
)
2973 dont_repeat (); /* Not for the faint of heart. */
2975 if (ptid_equal (inferior_ptid
, null_ptid
))
2976 error (_("The program is not being run."));
2978 query_if_trace_running (from_tty
);
2980 disconnect_tracing ();
2982 target_detach (args
, from_tty
);
2984 /* The current inferior process was just detached successfully. Get
2985 rid of breakpoints that no longer make sense. Note we don't do
2986 this within target_detach because that is also used when
2987 following child forks, and in that case we will want to transfer
2988 breakpoints to the child, not delete them. */
2989 breakpoint_init_inferior (inf_exited
);
2991 /* If the solist is global across inferiors, don't clear it when we
2992 detach from a single inferior. */
2993 if (!gdbarch_has_global_solist (target_gdbarch ()))
2994 no_shared_libraries (NULL
, from_tty
);
2996 /* If we still have inferiors to debug, then don't mess with their
2998 if (!have_inferiors ())
2999 init_thread_list ();
3001 if (deprecated_detach_hook
)
3002 deprecated_detach_hook ();
3005 /* Disconnect from the current target without resuming it (leaving it
3006 waiting for a debugger).
3008 We'd better not have left any breakpoints in the program or the
3009 next debugger will get confused. Currently only supported for some
3010 remote targets, since the normal attach mechanisms don't work on
3011 stopped processes on some native platforms (e.g. GNU/Linux). */
3014 disconnect_command (const char *args
, int from_tty
)
3016 dont_repeat (); /* Not for the faint of heart. */
3017 query_if_trace_running (from_tty
);
3018 disconnect_tracing ();
3019 target_disconnect (args
, from_tty
);
3020 no_shared_libraries (NULL
, from_tty
);
3021 init_thread_list ();
3022 if (deprecated_detach_hook
)
3023 deprecated_detach_hook ();
3027 interrupt_target_1 (int all_threads
)
3032 ptid
= minus_one_ptid
;
3034 ptid
= inferior_ptid
;
3039 target_interrupt (ptid
);
3041 /* Tag the thread as having been explicitly requested to stop, so
3042 other parts of gdb know not to resume this thread automatically,
3043 if it was stopped due to an internal event. Limit this to
3044 non-stop mode, as when debugging a multi-threaded application in
3045 all-stop mode, we will only get one stop event --- it's undefined
3046 which thread will report the event. */
3048 set_stop_requested (ptid
, 1);
3052 Stop the execution of the target while running in async mode, in
3053 the background. In all-stop, stop the whole process. In non-stop
3054 mode, stop the current thread only by default, or stop all threads
3055 if the `-a' switch is used. */
3058 interrupt_command (const char *args
, int from_tty
)
3060 if (target_can_async_p ())
3062 int all_threads
= 0;
3064 dont_repeat (); /* Not for the faint of heart. */
3067 && startswith (args
, "-a"))
3070 if (!non_stop
&& all_threads
)
3071 error (_("-a is meaningless in all-stop mode."));
3073 interrupt_target_1 (all_threads
);
3077 /* See inferior.h. */
3080 default_print_float_info (struct gdbarch
*gdbarch
, struct ui_file
*file
,
3081 struct frame_info
*frame
, const char *args
)
3084 int printed_something
= 0;
3087 regnum
< gdbarch_num_regs (gdbarch
)
3088 + gdbarch_num_pseudo_regs (gdbarch
);
3091 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, float_reggroup
))
3093 printed_something
= 1;
3094 gdbarch_print_registers_info (gdbarch
, file
, frame
, regnum
, 1);
3097 if (!printed_something
)
3098 fprintf_filtered (file
, "No floating-point info "
3099 "available for this processor.\n");
3103 info_float_command (const char *args
, int from_tty
)
3105 struct frame_info
*frame
;
3107 if (!target_has_registers
)
3108 error (_("The program has no registers now."));
3110 frame
= get_selected_frame (NULL
);
3111 gdbarch_print_float_info (get_frame_arch (frame
), gdb_stdout
, frame
, args
);
3115 unset_command (const char *args
, int from_tty
)
3117 printf_filtered (_("\"unset\" must be followed by the "
3118 "name of an unset subcommand.\n"));
3119 help_list (unsetlist
, "unset ", all_commands
, gdb_stdout
);
3122 /* Implement `info proc' family of commands. */
3125 info_proc_cmd_1 (const char *args
, enum info_proc_what what
, int from_tty
)
3127 struct gdbarch
*gdbarch
= get_current_arch ();
3129 if (!target_info_proc (args
, what
))
3131 if (gdbarch_info_proc_p (gdbarch
))
3132 gdbarch_info_proc (gdbarch
, args
, what
);
3134 error (_("Not supported on this target."));
3138 /* Implement `info proc' when given without any futher parameters. */
3141 info_proc_cmd (const char *args
, int from_tty
)
3143 info_proc_cmd_1 (args
, IP_MINIMAL
, from_tty
);
3146 /* Implement `info proc mappings'. */
3149 info_proc_cmd_mappings (const char *args
, int from_tty
)
3151 info_proc_cmd_1 (args
, IP_MAPPINGS
, from_tty
);
3154 /* Implement `info proc stat'. */
3157 info_proc_cmd_stat (const char *args
, int from_tty
)
3159 info_proc_cmd_1 (args
, IP_STAT
, from_tty
);
3162 /* Implement `info proc status'. */
3165 info_proc_cmd_status (const char *args
, int from_tty
)
3167 info_proc_cmd_1 (args
, IP_STATUS
, from_tty
);
3170 /* Implement `info proc cwd'. */
3173 info_proc_cmd_cwd (const char *args
, int from_tty
)
3175 info_proc_cmd_1 (args
, IP_CWD
, from_tty
);
3178 /* Implement `info proc cmdline'. */
3181 info_proc_cmd_cmdline (const char *args
, int from_tty
)
3183 info_proc_cmd_1 (args
, IP_CMDLINE
, from_tty
);
3186 /* Implement `info proc exe'. */
3189 info_proc_cmd_exe (const char *args
, int from_tty
)
3191 info_proc_cmd_1 (args
, IP_EXE
, from_tty
);
3194 /* Implement `info proc all'. */
3197 info_proc_cmd_all (const char *args
, int from_tty
)
3199 info_proc_cmd_1 (args
, IP_ALL
, from_tty
);
3202 /* This help string is used for the run, start, and starti commands.
3203 It is defined as a macro to prevent duplication. */
3205 #define RUN_ARGS_HELP \
3206 "You may specify arguments to give it.\n\
3207 Args may include \"*\", or \"[...]\"; they are expanded using the\n\
3208 shell that will start the program (specified by the \"$SHELL\" environment\n\
3209 variable). Input and output redirection with \">\", \"<\", or \">>\"\n\
3210 are also allowed.\n\
3212 With no arguments, uses arguments last specified (with \"run\" or \n\
3213 \"set args\"). To cancel previous arguments and run with no arguments,\n\
3214 use \"set args\" without arguments.\n\
3216 To start the inferior without using a shell, use \"set startup-with-shell off\"."
3219 _initialize_infcmd (void)
3221 static struct cmd_list_element
*info_proc_cmdlist
;
3222 struct cmd_list_element
*c
= NULL
;
3223 const char *cmd_name
;
3225 /* Add the filename of the terminal connected to inferior I/O. */
3226 add_setshow_optional_filename_cmd ("inferior-tty", class_run
,
3227 &inferior_io_terminal_scratch
, _("\
3228 Set terminal for future runs of program being debugged."), _("\
3229 Show terminal for future runs of program being debugged."), _("\
3230 Usage: set inferior-tty [TTY]\n\n\
3231 If TTY is omitted, the default behavior of using the same terminal as GDB\n\
3233 set_inferior_tty_command
,
3234 show_inferior_tty_command
,
3235 &setlist
, &showlist
);
3236 cmd_name
= "inferior-tty";
3237 c
= lookup_cmd (&cmd_name
, setlist
, "", -1, 1);
3238 gdb_assert (c
!= NULL
);
3239 add_alias_cmd ("tty", c
, class_alias
, 0, &cmdlist
);
3242 add_setshow_string_noescape_cmd (cmd_name
, class_run
,
3243 &inferior_args_scratch
, _("\
3244 Set argument list to give program being debugged when it is started."), _("\
3245 Show argument list to give program being debugged when it is started."), _("\
3246 Follow this command with any number of args, to be passed to the program."),
3249 &setlist
, &showlist
);
3250 c
= lookup_cmd (&cmd_name
, setlist
, "", -1, 1);
3251 gdb_assert (c
!= NULL
);
3252 set_cmd_completer (c
, filename_completer
);
3255 add_setshow_string_noescape_cmd (cmd_name
, class_run
,
3256 &inferior_cwd_scratch
, _("\
3257 Set the current working directory to be used when the inferior is started.\n\
3258 Changing this setting does not have any effect on inferiors that are\n\
3261 Show the current working directory that is used when the inferior is started."),
3263 Use this command to change the current working directory that will be used\n\
3264 when the inferior is started. This setting does not affect GDB's current\n\
3265 working directory."),
3268 &setlist
, &showlist
);
3269 c
= lookup_cmd (&cmd_name
, setlist
, "", -1, 1);
3270 gdb_assert (c
!= NULL
);
3271 set_cmd_completer (c
, filename_completer
);
3273 c
= add_cmd ("environment", no_class
, environment_info
, _("\
3274 The environment to give the program, or one variable's value.\n\
3275 With an argument VAR, prints the value of environment variable VAR to\n\
3276 give the program being debugged. With no arguments, prints the entire\n\
3277 environment to be given to the program."), &showlist
);
3278 set_cmd_completer (c
, noop_completer
);
3280 add_prefix_cmd ("unset", no_class
, unset_command
,
3281 _("Complement to certain \"set\" commands."),
3282 &unsetlist
, "unset ", 0, &cmdlist
);
3284 c
= add_cmd ("environment", class_run
, unset_environment_command
, _("\
3285 Cancel environment variable VAR for the program.\n\
3286 This does not affect the program until the next \"run\" command."),
3288 set_cmd_completer (c
, noop_completer
);
3290 c
= add_cmd ("environment", class_run
, set_environment_command
, _("\
3291 Set environment variable value to give the program.\n\
3292 Arguments are VAR VALUE where VAR is variable name and VALUE is value.\n\
3293 VALUES of environment variables are uninterpreted strings.\n\
3294 This does not affect the program until the next \"run\" command."),
3296 set_cmd_completer (c
, noop_completer
);
3298 c
= add_com ("path", class_files
, path_command
, _("\
3299 Add directory DIR(s) to beginning of search path for object files.\n\
3300 $cwd in the path means the current working directory.\n\
3301 This path is equivalent to the $PATH shell variable. It is a list of\n\
3302 directories, separated by colons. These directories are searched to find\n\
3303 fully linked executable files and separately compiled object files as \
3305 set_cmd_completer (c
, filename_completer
);
3307 c
= add_cmd ("paths", no_class
, path_info
, _("\
3308 Current search path for finding object files.\n\
3309 $cwd in the path means the current working directory.\n\
3310 This path is equivalent to the $PATH shell variable. It is a list of\n\
3311 directories, separated by colons. These directories are searched to find\n\
3312 fully linked executable files and separately compiled object files as \
3315 set_cmd_completer (c
, noop_completer
);
3317 add_prefix_cmd ("kill", class_run
, kill_command
,
3318 _("Kill execution of program being debugged."),
3319 &killlist
, "kill ", 0, &cmdlist
);
3321 add_com ("attach", class_run
, attach_command
, _("\
3322 Attach to a process or file outside of GDB.\n\
3323 This command attaches to another target, of the same type as your last\n\
3324 \"target\" command (\"info files\" will show your target stack).\n\
3325 The command may take as argument a process id or a device file.\n\
3326 For a process id, you must have permission to send the process a signal,\n\
3327 and it must have the same effective uid as the debugger.\n\
3328 When using \"attach\" with a process id, the debugger finds the\n\
3329 program running in the process, looking first in the current working\n\
3330 directory, or (if not found there) using the source file search path\n\
3331 (see the \"directory\" command). You can also use the \"file\" command\n\
3332 to specify the program, and to load its symbol table."));
3334 add_prefix_cmd ("detach", class_run
, detach_command
, _("\
3335 Detach a process or file previously attached.\n\
3336 If a process, it is no longer traced, and it continues its execution. If\n\
3337 you were debugging a file, the file is closed and gdb no longer accesses it."),
3338 &detachlist
, "detach ", 0, &cmdlist
);
3340 add_com ("disconnect", class_run
, disconnect_command
, _("\
3341 Disconnect from a target.\n\
3342 The target will wait for another debugger to connect. Not available for\n\
3345 c
= add_com ("signal", class_run
, signal_command
, _("\
3346 Continue program with the specified signal.\n\
3347 Usage: signal SIGNAL\n\
3348 The SIGNAL argument is processed the same as the handle command.\n\
3350 An argument of \"0\" means continue the program without sending it a signal.\n\
3351 This is useful in cases where the program stopped because of a signal,\n\
3352 and you want to resume the program while discarding the signal.\n\
3354 In a multi-threaded program the signal is delivered to, or discarded from,\n\
3355 the current thread only."));
3356 set_cmd_completer (c
, signal_completer
);
3358 c
= add_com ("queue-signal", class_run
, queue_signal_command
, _("\
3359 Queue a signal to be delivered to the current thread when it is resumed.\n\
3360 Usage: queue-signal SIGNAL\n\
3361 The SIGNAL argument is processed the same as the handle command.\n\
3362 It is an error if the handling state of SIGNAL is \"nopass\".\n\
3364 An argument of \"0\" means remove any currently queued signal from\n\
3365 the current thread. This is useful in cases where the program stopped\n\
3366 because of a signal, and you want to resume it while discarding the signal.\n\
3368 In a multi-threaded program the signal is queued with, or discarded from,\n\
3369 the current thread only."));
3370 set_cmd_completer (c
, signal_completer
);
3372 add_com ("stepi", class_run
, stepi_command
, _("\
3373 Step one instruction exactly.\n\
3375 Argument N means step N times (or till program stops for another \
3377 add_com_alias ("si", "stepi", class_alias
, 0);
3379 add_com ("nexti", class_run
, nexti_command
, _("\
3380 Step one instruction, but proceed through subroutine calls.\n\
3382 Argument N means step N times (or till program stops for another \
3384 add_com_alias ("ni", "nexti", class_alias
, 0);
3386 add_com ("finish", class_run
, finish_command
, _("\
3387 Execute until selected stack frame returns.\n\
3389 Upon return, the value returned is printed and put in the value history."));
3390 add_com_alias ("fin", "finish", class_run
, 1);
3392 add_com ("next", class_run
, next_command
, _("\
3393 Step program, proceeding through subroutine calls.\n\
3395 Unlike \"step\", if the current source line calls a subroutine,\n\
3396 this command does not enter the subroutine, but instead steps over\n\
3397 the call, in effect treating it as a single source line."));
3398 add_com_alias ("n", "next", class_run
, 1);
3400 add_com ("step", class_run
, step_command
, _("\
3401 Step program until it reaches a different source line.\n\
3403 Argument N means step N times (or till program stops for another \
3405 add_com_alias ("s", "step", class_run
, 1);
3407 c
= add_com ("until", class_run
, until_command
, _("\
3408 Execute until the program reaches a source line greater than the current\n\
3409 or a specified location (same args as break command) within the current \
3411 set_cmd_completer (c
, location_completer
);
3412 add_com_alias ("u", "until", class_run
, 1);
3414 c
= add_com ("advance", class_run
, advance_command
, _("\
3415 Continue the program up to the given location (same form as args for break \
3417 Execution will also stop upon exit from the current stack frame."));
3418 set_cmd_completer (c
, location_completer
);
3420 c
= add_com ("jump", class_run
, jump_command
, _("\
3421 Continue program being debugged at specified line or address.\n\
3422 Usage: jump <location>\n\
3423 Give as argument either LINENUM or *ADDR, where ADDR is an expression\n\
3424 for an address to start at."));
3425 set_cmd_completer (c
, location_completer
);
3426 add_com_alias ("j", "jump", class_run
, 1);
3428 add_com ("continue", class_run
, continue_command
, _("\
3429 Continue program being debugged, after signal or breakpoint.\n\
3430 Usage: continue [N]\n\
3431 If proceeding from breakpoint, a number N may be used as an argument,\n\
3432 which means to set the ignore count of that breakpoint to N - 1 (so that\n\
3433 the breakpoint won't break until the Nth time it is reached).\n\
3435 If non-stop mode is enabled, continue only the current thread,\n\
3436 otherwise all the threads in the program are continued. To \n\
3437 continue all stopped threads in non-stop mode, use the -a option.\n\
3438 Specifying -a and an ignore count simultaneously is an error."));
3439 add_com_alias ("c", "cont", class_run
, 1);
3440 add_com_alias ("fg", "cont", class_run
, 1);
3442 c
= add_com ("run", class_run
, run_command
, _("\
3443 Start debugged program.\n"
3445 set_cmd_completer (c
, filename_completer
);
3446 add_com_alias ("r", "run", class_run
, 1);
3448 c
= add_com ("start", class_run
, start_command
, _("\
3449 Start the debugged program stopping at the beginning of the main procedure.\n"
3451 set_cmd_completer (c
, filename_completer
);
3453 c
= add_com ("starti", class_run
, starti_command
, _("\
3454 Start the debugged program stopping at the first instruction.\n"
3456 set_cmd_completer (c
, filename_completer
);
3458 add_com ("interrupt", class_run
, interrupt_command
,
3459 _("Interrupt the execution of the debugged program.\n\
3460 If non-stop mode is enabled, interrupt only the current thread,\n\
3461 otherwise all the threads in the program are stopped. To \n\
3462 interrupt all running threads in non-stop mode, use the -a option."));
3464 c
= add_info ("registers", info_registers_command
, _("\
3465 List of integer registers and their contents, for selected stack frame.\n\
3466 Register name as argument means describe only that register."));
3467 add_info_alias ("r", "registers", 1);
3468 set_cmd_completer (c
, reg_or_group_completer
);
3470 c
= add_info ("all-registers", info_all_registers_command
, _("\
3471 List of all registers and their contents, for selected stack frame.\n\
3472 Register name as argument means describe only that register."));
3473 set_cmd_completer (c
, reg_or_group_completer
);
3475 add_info ("program", info_program_command
,
3476 _("Execution status of the program."));
3478 add_info ("float", info_float_command
,
3479 _("Print the status of the floating point unit\n"));
3481 add_info ("vector", info_vector_command
,
3482 _("Print the status of the vector unit\n"));
3484 add_prefix_cmd ("proc", class_info
, info_proc_cmd
,
3486 Show /proc process information about any running process.\n\
3487 Specify any process id, or use the program being debugged by default."),
3488 &info_proc_cmdlist
, "info proc ",
3489 1/*allow-unknown*/, &infolist
);
3491 add_cmd ("mappings", class_info
, info_proc_cmd_mappings
, _("\
3492 List of mapped memory regions."),
3493 &info_proc_cmdlist
);
3495 add_cmd ("stat", class_info
, info_proc_cmd_stat
, _("\
3496 List process info from /proc/PID/stat."),
3497 &info_proc_cmdlist
);
3499 add_cmd ("status", class_info
, info_proc_cmd_status
, _("\
3500 List process info from /proc/PID/status."),
3501 &info_proc_cmdlist
);
3503 add_cmd ("cwd", class_info
, info_proc_cmd_cwd
, _("\
3504 List current working directory of the process."),
3505 &info_proc_cmdlist
);
3507 add_cmd ("cmdline", class_info
, info_proc_cmd_cmdline
, _("\
3508 List command line arguments of the process."),
3509 &info_proc_cmdlist
);
3511 add_cmd ("exe", class_info
, info_proc_cmd_exe
, _("\
3512 List absolute filename for executable of the process."),
3513 &info_proc_cmdlist
);
3515 add_cmd ("all", class_info
, info_proc_cmd_all
, _("\
3516 List all available /proc info."),
3517 &info_proc_cmdlist
);