1 /* Memory-access and commands for "inferior" process, for GDB.
3 Copyright (C) 1986-2021 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"
27 #include "gdbsupport/environ.h"
35 #include "completer.h"
38 #include "reggroups.h"
42 #include "observable.h"
43 #include "target-descriptions.h"
44 #include "user-regs.h"
45 #include "gdbthread.h"
47 #include "inline-frame.h"
48 #include "tracepoint.h"
51 #include "thread-fsm.h"
55 #include "gdbsupport/gdb_optional.h"
57 #include "cli/cli-style.h"
59 /* Local functions: */
61 static void until_next_command (int);
63 static void step_1 (int, int, const char *);
65 #define ERROR_NO_INFERIOR \
66 if (!target_has_execution ()) error (_("The program is not being run."));
68 /* Scratch area where string containing arguments to give to the
69 program will be stored by 'set args'. As soon as anything is
70 stored, notice_args_set will move it into per-inferior storage.
71 Arguments are separated by spaces. Empty string (pointer to '\0')
74 static std::string inferior_args_scratch
;
76 /* Scratch area where the new cwd will be stored by 'set cwd'. */
78 static std::string inferior_cwd_scratch
;
80 /* Scratch area where 'set inferior-tty' will store user-provided value.
81 We'll immediate copy it into per-inferior storage. */
83 static std::string inferior_io_terminal_scratch
;
85 /* Pid of our debugged inferior, or 0 if no inferior now.
86 Since various parts of infrun.c test this to see whether there is a program
87 being debugged it should be nonzero (currently 3 is used) for remote
92 /* Nonzero if stopped due to completion of a stack dummy routine. */
94 enum stop_stack_kind stop_stack_dummy
;
96 /* Nonzero if stopped due to a random (unexpected) signal in inferior
99 int stopped_by_random_signal
;
104 set_inferior_tty_command (const char *args
, int from_tty
,
105 struct cmd_list_element
*c
)
107 /* CLI has assigned the user-provided value to inferior_io_terminal_scratch.
108 Now route it to current inferior. */
109 current_inferior ()->set_tty (inferior_io_terminal_scratch
);
113 show_inferior_tty_command (struct ui_file
*file
, int from_tty
,
114 struct cmd_list_element
*c
, const char *value
)
116 /* Note that we ignore the passed-in value in favor of computing it
118 const std::string
&inferior_tty
= current_inferior ()->tty ();
120 fprintf_filtered (gdb_stdout
,
121 _("Terminal for future runs of program being debugged "
122 "is \"%s\".\n"), inferior_tty
.c_str ());
126 set_inferior_args_vector (int argc
, char **argv
)
128 gdb::array_view
<char * const> args (argv
, argc
);
129 std::string n
= construct_inferior_arguments (args
);
130 current_inferior ()->set_args (std::move (n
));
133 /* Notice when `set args' is run. */
136 set_args_command (const char *args
, int from_tty
, struct cmd_list_element
*c
)
138 /* CLI has assigned the user-provided value to inferior_args_scratch.
139 Now route it to current inferior. */
140 current_inferior ()->set_args (inferior_args_scratch
);
143 /* Notice when `show args' is run. */
146 show_args_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 deprecated_show_value_hack (file
, from_tty
, c
,
152 current_inferior ()->args ().c_str ());
155 /* See gdbsupport/common-inferior.h. */
160 return current_inferior ()->cwd ();
163 /* Handle the 'set cwd' command. */
166 set_cwd_command (const char *args
, int from_tty
, struct cmd_list_element
*c
)
168 current_inferior ()->set_cwd (inferior_cwd_scratch
);
171 /* Handle the 'show cwd' command. */
174 show_cwd_command (struct ui_file
*file
, int from_tty
,
175 struct cmd_list_element
*c
, const char *value
)
177 const std::string
&cwd
= current_inferior ()->cwd ();
180 fprintf_filtered (gdb_stdout
,
182 You have not set the inferior's current working directory.\n\
183 The inferior will inherit GDB's cwd if native debugging, or the remote\n\
184 server's cwd if remote debugging.\n"));
186 fprintf_filtered (gdb_stdout
,
187 _("Current working directory that will be used "
188 "when starting the inferior is \"%s\".\n"),
193 /* This function strips the '&' character (indicating background
194 execution) that is added as *the last* of the arguments ARGS of a
195 command. A copy of the incoming ARGS without the '&' is returned,
196 unless the resulting string after stripping is empty, in which case
197 NULL is returned. *BG_CHAR_P is an output boolean that indicates
198 whether the '&' character was found. */
200 static gdb::unique_xmalloc_ptr
<char>
201 strip_bg_char (const char *args
, int *bg_char_p
)
205 if (args
== NULL
|| *args
== '\0')
211 p
= args
+ strlen (args
);
215 while (p
> args
&& isspace (p
[-1]))
220 return gdb::unique_xmalloc_ptr
<char>
221 (savestring (args
, p
- args
));
223 return gdb::unique_xmalloc_ptr
<char> (nullptr);
227 return make_unique_xstrdup (args
);
230 /* Common actions to take after creating any sort of inferior, by any
231 means (running, attaching, connecting, et cetera). The target
232 should be stopped. */
235 post_create_inferior (int from_tty
)
238 /* Be sure we own the terminal in case write operations are performed. */
239 target_terminal::ours_for_output ();
241 /* If the target hasn't taken care of this already, do it now.
242 Targets which need to access registers during to_open,
243 to_create_inferior, or to_attach should do it earlier; but many
245 target_find_description ();
247 /* Now that we know the register layout, retrieve current PC. But
248 if the PC is unavailable (e.g., we're opening a core file with
249 missing registers info), ignore it. */
250 thread_info
*thr
= inferior_thread ();
252 thr
->clear_stop_pc ();
255 regcache
*rc
= get_thread_regcache (thr
);
256 thr
->set_stop_pc (regcache_read_pc (rc
));
258 catch (const gdb_exception_error
&ex
)
260 if (ex
.error
!= NOT_AVAILABLE_ERROR
)
264 if (current_program_space
->exec_bfd ())
266 const unsigned solib_add_generation
267 = current_program_space
->solib_add_generation
;
269 scoped_restore restore_in_initial_library_scan
270 = make_scoped_restore (¤t_inferior ()->in_initial_library_scan
,
273 /* Create the hooks to handle shared library load and unload
275 solib_create_inferior_hook (from_tty
);
277 if (current_program_space
->solib_add_generation
== solib_add_generation
)
279 /* The platform-specific hook should load initial shared libraries,
280 but didn't. FROM_TTY will be incorrectly 0 but such solib
281 targets should be fixed anyway. Call it only after the solib
282 target has been initialized by solib_create_inferior_hook. */
285 warning (_("platform-specific solib_create_inferior_hook did "
286 "not load initial shared libraries."));
288 /* If the solist is global across processes, there's no need to
290 if (!gdbarch_has_global_solist (target_gdbarch ()))
291 solib_add (NULL
, 0, auto_solib_add
);
295 /* If the user sets watchpoints before execution having started,
296 then she gets software watchpoints, because GDB can't know which
297 target will end up being pushed, or if it supports hardware
298 watchpoints or not. breakpoint_re_set takes care of promoting
299 watchpoints to hardware watchpoints if possible, however, if this
300 new inferior doesn't load shared libraries or we don't pull in
301 symbols from any other source on this target/arch,
302 breakpoint_re_set is never called. Call it now so that software
303 watchpoints get a chance to be promoted to hardware watchpoints
304 if the now pushed target supports hardware watchpoints. */
305 breakpoint_re_set ();
307 gdb::observers::inferior_created
.notify (current_inferior ());
310 /* Kill the inferior if already running. This function is designed
311 to be called when we are about to start the execution of the program
312 from the beginning. Ask the user to confirm that he wants to restart
313 the program being debugged when FROM_TTY is non-null. */
316 kill_if_already_running (int from_tty
)
318 if (inferior_ptid
!= null_ptid
&& target_has_execution ())
320 /* Bail out before killing the program if we will not be able to
322 target_require_runnable ();
325 && !query (_("The program being debugged has been started already.\n\
326 Start it from the beginning? ")))
327 error (_("Program not restarted."));
332 /* See inferior.h. */
335 prepare_execution_command (struct target_ops
*target
, int background
)
337 /* If we get a request for running in the bg but the target
338 doesn't support it, error out. */
339 if (background
&& !target
->can_async_p ())
340 error (_("Asynchronous execution not supported on this target."));
344 /* If we get a request for running in the fg, then we need to
345 simulate synchronous (fg) execution. Note no cleanup is
346 necessary for this. stdin is re-enabled whenever an error
347 reaches the top level. */
348 all_uis_on_sync_execution_starting ();
352 /* Determine how the new inferior will behave. */
356 /* Run program without any explicit stop during startup. */
359 /* Stop at the beginning of the program's main function. */
362 /* Stop at the first instruction of the program. */
363 RUN_STOP_AT_FIRST_INSN
366 /* Implement the "run" command. Force a stop during program start if
367 requested by RUN_HOW. */
370 run_command_1 (const char *args
, int from_tty
, enum run_how run_how
)
372 const char *exec_file
;
373 struct ui_out
*uiout
= current_uiout
;
374 struct target_ops
*run_target
;
379 scoped_disable_commit_resumed
disable_commit_resumed ("running");
381 kill_if_already_running (from_tty
);
383 init_wait_for_inferior ();
384 clear_breakpoint_hit_counts ();
386 /* Clean up any leftovers from other runs. Some other things from
387 this function should probably be moved into target_pre_inferior. */
388 target_pre_inferior (from_tty
);
390 /* The comment here used to read, "The exec file is re-read every
391 time we do a generic_mourn_inferior, so we just have to worry
392 about the symbol file." The `generic_mourn_inferior' function
393 gets called whenever the program exits. However, suppose the
394 program exits, and *then* the executable file changes? We need
395 to check again here. Since reopen_exec_file doesn't do anything
396 if the timestamp hasn't changed, I don't see the harm. */
400 gdb::unique_xmalloc_ptr
<char> stripped
= strip_bg_char (args
, &async_exec
);
401 args
= stripped
.get ();
403 /* Do validation and preparation before possibly changing anything
406 run_target
= find_run_target ();
408 prepare_execution_command (run_target
, async_exec
);
410 if (non_stop
&& !run_target
->supports_non_stop ())
411 error (_("The target does not support running in non-stop mode."));
413 /* Done. Can now set breakpoints, change inferior args, etc. */
415 /* Insert temporary breakpoint in main function if requested. */
416 if (run_how
== RUN_STOP_AT_MAIN
)
418 std::string arg
= string_printf ("-qualified %s", main_name ());
419 tbreak_command (arg
.c_str (), 0);
422 exec_file
= get_exec_file (0);
424 /* We keep symbols from add-symbol-file, on the grounds that the
425 user might want to add some symbols before running the program
426 (right?). But sometimes (dynamic loading where the user manually
427 introduces the new symbols with add-symbol-file), the code which
428 the symbols describe does not persist between runs. Currently
429 the user has to manually nuke all symbols between runs if they
430 want them to go away (PR 2207). This is probably reasonable. */
432 /* If there were other args, beside '&', process them. */
434 current_inferior ()->set_args (args
);
438 uiout
->field_string (NULL
, "Starting program");
441 uiout
->field_string ("execfile", exec_file
);
443 uiout
->field_string ("infargs", current_inferior ()->args ());
448 run_target
->create_inferior (exec_file
,
449 current_inferior ()->args (),
450 current_inferior ()->environment
.envp (),
452 /* to_create_inferior should push the target, so after this point we
453 shouldn't refer to run_target again. */
456 /* We're starting off a new process. When we get out of here, in
457 non-stop mode, finish the state of all threads of that process,
458 but leave other threads alone, as they may be stopped in internal
459 events --- the frontend shouldn't see them as stopped. In
460 all-stop, always finish the state of all threads, as we may be
461 resuming more than just the new process. */
462 process_stratum_target
*finish_target
;
466 finish_target
= current_inferior ()->process_target ();
467 finish_ptid
= ptid_t (current_inferior ()->pid
);
471 finish_target
= nullptr;
472 finish_ptid
= minus_one_ptid
;
474 scoped_finish_thread_state
finish_state (finish_target
, finish_ptid
);
476 /* Pass zero for FROM_TTY, because at this point the "run" command
477 has done its thing; now we are setting up the running program. */
478 post_create_inferior (0);
480 /* Queue a pending event so that the program stops immediately. */
481 if (run_how
== RUN_STOP_AT_FIRST_INSN
)
483 thread_info
*thr
= inferior_thread ();
484 target_waitstatus ws
;
485 ws
.set_stopped (GDB_SIGNAL_0
);
486 thr
->set_pending_waitstatus (ws
);
489 /* Start the target running. Do not use -1 continuation as it would skip
490 breakpoint right at the entry point. */
491 proceed (regcache_read_pc (get_current_regcache ()), GDB_SIGNAL_0
);
493 /* Since there was no error, there's no need to finish the thread
495 finish_state
.release ();
497 disable_commit_resumed
.reset_and_commit ();
501 run_command (const char *args
, int from_tty
)
503 run_command_1 (args
, from_tty
, RUN_NORMAL
);
506 /* Start the execution of the program up until the beginning of the main
510 start_command (const char *args
, int from_tty
)
512 /* Some languages such as Ada need to search inside the program
513 minimal symbols for the location where to put the temporary
514 breakpoint before starting. */
515 if (!have_minimal_symbols ())
516 error (_("No symbol table loaded. Use the \"file\" command."));
518 /* Run the program until reaching the main procedure... */
519 run_command_1 (args
, from_tty
, RUN_STOP_AT_MAIN
);
522 /* Start the execution of the program stopping at the first
526 starti_command (const char *args
, int from_tty
)
528 run_command_1 (args
, from_tty
, RUN_STOP_AT_FIRST_INSN
);
532 proceed_thread_callback (struct thread_info
*thread
, void *arg
)
534 /* We go through all threads individually instead of compressing
535 into a single target `resume_all' request, because some threads
536 may be stopped in internal breakpoints/events, or stopped waiting
537 for its turn in the displaced stepping queue (that is, they are
538 running && !executing). The target side has no idea about why
539 the thread is stopped, so a `resume_all' command would resume too
540 much. If/when GDB gains a way to tell the target `hold this
541 thread stopped until I say otherwise', then we can optimize
543 if (thread
->state
!= THREAD_STOPPED
)
546 if (!thread
->inf
->has_execution ())
549 switch_to_thread (thread
);
550 clear_proceed_status (0);
551 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
);
556 ensure_valid_thread (void)
558 if (inferior_ptid
== null_ptid
559 || inferior_thread ()->state
== THREAD_EXITED
)
560 error (_("Cannot execute this command without a live selected thread."));
563 /* If the user is looking at trace frames, any resumption of execution
564 is likely to mix up recorded and live target data. So simply
565 disallow those commands. */
568 ensure_not_tfind_mode (void)
570 if (get_traceframe_number () >= 0)
571 error (_("Cannot execute this command while looking at trace frames."));
574 /* Throw an error indicating the current thread is running. */
577 error_is_running (void)
579 error (_("Cannot execute this command while "
580 "the selected thread is running."));
583 /* Calls error_is_running if the current thread is running. */
586 ensure_not_running (void)
588 if (inferior_thread ()->state
== THREAD_RUNNING
)
593 continue_1 (int all_threads
)
596 ensure_not_tfind_mode ();
598 if (non_stop
&& all_threads
)
600 /* Don't error out if the current thread is running, because
601 there may be other stopped threads. */
603 /* Backup current thread and selected frame and restore on scope
605 scoped_restore_current_thread restore_thread
;
607 iterate_over_threads (proceed_thread_callback
, NULL
);
609 if (current_ui
->prompt_state
== PROMPT_BLOCKED
)
611 /* If all threads in the target were already running,
612 proceed_thread_callback ends up never calling proceed,
613 and so nothing calls this to put the inferior's terminal
614 settings in effect and remove stdin from the event loop,
615 which we must when running a foreground command. E.g.:
619 <all threads are running now>
622 <no thread was resumed, but the inferior now owns the terminal>
624 target_terminal::inferior ();
629 ensure_valid_thread ();
630 ensure_not_running ();
631 clear_proceed_status (0);
632 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
);
636 /* continue [-a] [proceed-count] [&] */
639 continue_command (const char *args
, int from_tty
)
642 bool all_threads_p
= false;
646 /* Find out whether we must run in the background. */
647 gdb::unique_xmalloc_ptr
<char> stripped
= strip_bg_char (args
, &async_exec
);
648 args
= stripped
.get ();
652 if (startswith (args
, "-a"))
654 all_threads_p
= true;
655 args
+= sizeof ("-a") - 1;
661 if (!non_stop
&& all_threads_p
)
662 error (_("`-a' is meaningless in all-stop mode."));
664 if (args
!= NULL
&& all_threads_p
)
665 error (_("Can't resume all threads and specify "
666 "proceed count simultaneously."));
668 /* If we have an argument left, set proceed count of breakpoint we
675 struct thread_info
*tp
;
678 tp
= inferior_thread ();
681 process_stratum_target
*last_target
;
684 get_last_target_status (&last_target
, &last_ptid
, nullptr);
685 tp
= find_thread_ptid (last_target
, last_ptid
);
688 bs
= tp
->control
.stop_bpstat
;
690 while ((stat
= bpstat_num (&bs
, &num
)) != 0)
693 set_ignore_count (num
,
694 parse_and_eval_long (args
) - 1,
696 /* set_ignore_count prints a message ending with a period.
697 So print two spaces before "Continuing.". */
699 printf_filtered (" ");
703 if (!stopped
&& from_tty
)
706 ("Not stopped at any breakpoint; argument ignored.\n");
711 ensure_not_tfind_mode ();
713 if (!non_stop
|| !all_threads_p
)
715 ensure_valid_thread ();
716 ensure_not_running ();
719 prepare_execution_command (current_inferior ()->top_target (), async_exec
);
722 printf_filtered (_("Continuing.\n"));
724 continue_1 (all_threads_p
);
727 /* Record in TP the starting point of a "step" or "next" command. */
730 set_step_frame (thread_info
*tp
)
732 /* This can be removed once this function no longer implicitly relies on the
733 inferior_ptid value. */
734 gdb_assert (inferior_ptid
== tp
->ptid
);
736 frame_info
*frame
= get_current_frame ();
738 symtab_and_line sal
= find_frame_sal (frame
);
739 set_step_info (tp
, frame
, sal
);
741 CORE_ADDR pc
= get_frame_pc (frame
);
742 tp
->control
.step_start_function
= find_pc_function (pc
);
745 /* Step until outside of current statement. */
748 step_command (const char *count_string
, int from_tty
)
750 step_1 (0, 0, count_string
);
753 /* Likewise, but skip over subroutine calls as if single instructions. */
756 next_command (const char *count_string
, int from_tty
)
758 step_1 (1, 0, count_string
);
761 /* Likewise, but step only one instruction. */
764 stepi_command (const char *count_string
, int from_tty
)
766 step_1 (0, 1, count_string
);
770 nexti_command (const char *count_string
, int from_tty
)
772 step_1 (1, 1, count_string
);
775 /* Data for the FSM that manages the step/next/stepi/nexti
778 struct step_command_fsm
: public thread_fsm
780 /* How many steps left in a "step N"-like command. */
783 /* If true, this is a next/nexti, otherwise a step/stepi. */
784 int skip_subroutines
;
786 /* If true, this is a stepi/nexti, otherwise a step/step. */
789 explicit step_command_fsm (struct interp
*cmd_interp
)
790 : thread_fsm (cmd_interp
)
794 void clean_up (struct thread_info
*thread
) override
;
795 bool should_stop (struct thread_info
*thread
) override
;
796 enum async_reply_reason
do_async_reply_reason () override
;
799 /* Prepare for a step/next/etc. command. Any target resource
800 allocated here is undone in the FSM's clean_up method. */
803 step_command_fsm_prepare (struct step_command_fsm
*sm
,
804 int skip_subroutines
, int single_inst
,
805 int count
, struct thread_info
*thread
)
807 sm
->skip_subroutines
= skip_subroutines
;
808 sm
->single_inst
= single_inst
;
811 /* Leave the si command alone. */
812 if (!sm
->single_inst
|| sm
->skip_subroutines
)
813 set_longjmp_breakpoint (thread
, get_frame_id (get_current_frame ()));
815 thread
->control
.stepping_command
= 1;
818 static int prepare_one_step (thread_info
*, struct step_command_fsm
*sm
);
821 step_1 (int skip_subroutines
, int single_inst
, const char *count_string
)
825 struct thread_info
*thr
;
826 struct step_command_fsm
*step_sm
;
829 ensure_not_tfind_mode ();
830 ensure_valid_thread ();
831 ensure_not_running ();
833 gdb::unique_xmalloc_ptr
<char> stripped
834 = strip_bg_char (count_string
, &async_exec
);
835 count_string
= stripped
.get ();
837 prepare_execution_command (current_inferior ()->top_target (), async_exec
);
839 count
= count_string
? parse_and_eval_long (count_string
) : 1;
841 clear_proceed_status (1);
843 /* Setup the execution command state machine to handle all the COUNT
845 thr
= inferior_thread ();
846 step_sm
= new step_command_fsm (command_interp ());
847 thr
->thread_fsm
= step_sm
;
849 step_command_fsm_prepare (step_sm
, skip_subroutines
,
850 single_inst
, count
, thr
);
852 /* Do only one step for now, before returning control to the event
853 loop. Let the continuation figure out how many other steps we
854 need to do, and handle them one at the time, through
856 if (!prepare_one_step (thr
, step_sm
))
857 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
);
862 /* Stepped into an inline frame. Pretend that we've
864 thr
->thread_fsm
->clean_up (thr
);
865 proceeded
= normal_stop ();
867 inferior_event_handler (INF_EXEC_COMPLETE
);
868 all_uis_check_sync_execution_done ();
872 /* Implementation of the 'should_stop' FSM method for stepping
873 commands. Called after we are done with one step operation, to
874 check whether we need to step again, before we print the prompt and
875 return control to the user. If count is > 1, returns false, as we
876 will need to keep going. */
879 step_command_fsm::should_stop (struct thread_info
*tp
)
881 if (tp
->control
.stop_step
)
883 /* There are more steps to make, and we did stop due to
884 ending a stepping range. Do another step. */
886 return prepare_one_step (tp
, this);
894 /* Implementation of the 'clean_up' FSM method for stepping commands. */
897 step_command_fsm::clean_up (struct thread_info
*thread
)
899 if (!single_inst
|| skip_subroutines
)
900 delete_longjmp_breakpoint (thread
->global_num
);
903 /* Implementation of the 'async_reply_reason' FSM method for stepping
906 enum async_reply_reason
907 step_command_fsm::do_async_reply_reason ()
909 return EXEC_ASYNC_END_STEPPING_RANGE
;
912 /* Prepare for one step in "step N". The actual target resumption is
913 done by the caller. Return true if we're done and should thus
914 report a stop to the user. Returns false if the target needs to be
918 prepare_one_step (thread_info
*tp
, struct step_command_fsm
*sm
)
920 /* This can be removed once this function no longer implicitly relies on the
921 inferior_ptid value. */
922 gdb_assert (inferior_ptid
== tp
->ptid
);
926 struct frame_info
*frame
= get_current_frame ();
930 if (!sm
->single_inst
)
934 /* Step at an inlined function behaves like "down". */
935 if (!sm
->skip_subroutines
936 && inline_skipped_frames (tp
))
939 const char *fn
= NULL
;
943 /* Pretend that we've ran. */
944 resume_ptid
= user_visible_resume_ptid (1);
945 set_running (tp
->inf
->process_target (), resume_ptid
, true);
947 step_into_inline_frame (tp
);
949 frame
= get_current_frame ();
950 sal
= find_frame_sal (frame
);
951 sym
= get_frame_function (frame
);
954 fn
= sym
->print_name ();
957 || !function_name_is_marked_for_skip (fn
, sal
))
960 return prepare_one_step (tp
, sm
);
964 pc
= get_frame_pc (frame
);
965 find_pc_line_pc_range (pc
,
966 &tp
->control
.step_range_start
,
967 &tp
->control
.step_range_end
);
969 /* There's a problem in gcc (PR gcc/98780) that causes missing line
970 table entries, which results in a too large stepping range.
971 Use inlined_subroutine info to make the range more narrow. */
972 if (inline_skipped_frames (tp
) > 0)
974 symbol
*sym
= inline_skipped_symbol (tp
);
975 if (SYMBOL_CLASS (sym
) == LOC_BLOCK
)
977 const block
*block
= SYMBOL_BLOCK_VALUE (sym
);
978 if (BLOCK_END (block
) < tp
->control
.step_range_end
)
979 tp
->control
.step_range_end
= BLOCK_END (block
);
983 tp
->control
.may_range_step
= 1;
985 /* If we have no line info, switch to stepi mode. */
986 if (tp
->control
.step_range_end
== 0 && step_stop_if_no_debug
)
988 tp
->control
.step_range_start
= tp
->control
.step_range_end
= 1;
989 tp
->control
.may_range_step
= 0;
991 else if (tp
->control
.step_range_end
== 0)
995 if (find_pc_partial_function (pc
, &name
,
996 &tp
->control
.step_range_start
,
997 &tp
->control
.step_range_end
) == 0)
998 error (_("Cannot find bounds of current function"));
1000 target_terminal::ours_for_output ();
1001 printf_filtered (_("Single stepping until exit from function %s,"
1002 "\nwhich has no line number information.\n"),
1008 /* Say we are stepping, but stop after one insn whatever it does. */
1009 tp
->control
.step_range_start
= tp
->control
.step_range_end
= 1;
1010 if (!sm
->skip_subroutines
)
1012 Don't step over function calls, not even to functions lacking
1014 tp
->control
.step_over_calls
= STEP_OVER_NONE
;
1017 if (sm
->skip_subroutines
)
1018 tp
->control
.step_over_calls
= STEP_OVER_ALL
;
1024 sm
->set_finished ();
1029 /* Continue program at specified address. */
1032 jump_command (const char *arg
, int from_tty
)
1034 struct gdbarch
*gdbarch
= get_current_arch ();
1041 ensure_not_tfind_mode ();
1042 ensure_valid_thread ();
1043 ensure_not_running ();
1045 /* Find out whether we must run in the background. */
1046 gdb::unique_xmalloc_ptr
<char> stripped
= strip_bg_char (arg
, &async_exec
);
1047 arg
= stripped
.get ();
1049 prepare_execution_command (current_inferior ()->top_target (), async_exec
);
1052 error_no_arg (_("starting address"));
1054 std::vector
<symtab_and_line
> sals
1055 = decode_line_with_last_displayed (arg
, DECODE_LINE_FUNFIRSTLINE
);
1056 if (sals
.size () != 1)
1057 error (_("Unreasonable jump request"));
1059 symtab_and_line
&sal
= sals
[0];
1061 if (sal
.symtab
== 0 && sal
.pc
== 0)
1062 error (_("No source file has been specified."));
1064 resolve_sal_pc (&sal
); /* May error out. */
1066 /* See if we are trying to jump to another function. */
1067 fn
= get_frame_function (get_current_frame ());
1068 sfn
= find_pc_function (sal
.pc
);
1069 if (fn
!= NULL
&& sfn
!= fn
)
1071 if (!query (_("Line %d is not in `%s'. Jump anyway? "), sal
.line
,
1074 error (_("Not confirmed."));
1081 struct obj_section
*section
;
1083 fixup_symbol_section (sfn
, 0);
1084 section
= sfn
->obj_section (symbol_objfile (sfn
));
1085 if (section_is_overlay (section
)
1086 && !section_is_mapped (section
))
1088 if (!query (_("WARNING!!! Destination is in "
1089 "unmapped overlay! Jump anyway? ")))
1091 error (_("Not confirmed."));
1101 printf_filtered (_("Continuing at "));
1102 fputs_filtered (paddress (gdbarch
, addr
), gdb_stdout
);
1103 printf_filtered (".\n");
1106 clear_proceed_status (0);
1107 proceed (addr
, GDB_SIGNAL_0
);
1110 /* Continue program giving it specified signal. */
1113 signal_command (const char *signum_exp
, int from_tty
)
1115 enum gdb_signal oursig
;
1118 dont_repeat (); /* Too dangerous. */
1120 ensure_not_tfind_mode ();
1121 ensure_valid_thread ();
1122 ensure_not_running ();
1124 /* Find out whether we must run in the background. */
1125 gdb::unique_xmalloc_ptr
<char> stripped
1126 = strip_bg_char (signum_exp
, &async_exec
);
1127 signum_exp
= stripped
.get ();
1129 prepare_execution_command (current_inferior ()->top_target (), async_exec
);
1132 error_no_arg (_("signal number"));
1134 /* It would be even slicker to make signal names be valid expressions,
1135 (the type could be "enum $signal" or some such), then the user could
1136 assign them to convenience variables. */
1137 oursig
= gdb_signal_from_name (signum_exp
);
1139 if (oursig
== GDB_SIGNAL_UNKNOWN
)
1141 /* No, try numeric. */
1142 int num
= parse_and_eval_long (signum_exp
);
1145 oursig
= GDB_SIGNAL_0
;
1147 oursig
= gdb_signal_from_command (num
);
1150 /* Look for threads other than the current that this command ends up
1151 resuming too (due to schedlock off), and warn if they'll get a
1152 signal delivered. "signal 0" is used to suppress a previous
1153 signal, but if the current thread is no longer the one that got
1154 the signal, then the user is potentially suppressing the signal
1155 of the wrong thread. */
1158 int must_confirm
= 0;
1160 /* This indicates what will be resumed. Either a single thread,
1161 a whole process, or all threads of all processes. */
1162 ptid_t resume_ptid
= user_visible_resume_ptid (0);
1163 process_stratum_target
*resume_target
1164 = user_visible_resume_target (resume_ptid
);
1166 thread_info
*current
= inferior_thread ();
1168 for (thread_info
*tp
: all_non_exited_threads (resume_target
, resume_ptid
))
1173 if (tp
->stop_signal () != GDB_SIGNAL_0
1174 && signal_pass_state (tp
->stop_signal ()))
1177 printf_unfiltered (_("Note:\n"));
1178 printf_unfiltered (_(" Thread %s previously stopped with signal %s, %s.\n"),
1179 print_thread_id (tp
),
1180 gdb_signal_to_name (tp
->stop_signal ()),
1181 gdb_signal_to_string (tp
->stop_signal ()));
1187 && !query (_("Continuing thread %s (the current thread) with specified signal will\n"
1188 "still deliver the signals noted above to their respective threads.\n"
1189 "Continue anyway? "),
1190 print_thread_id (inferior_thread ())))
1191 error (_("Not confirmed."));
1196 if (oursig
== GDB_SIGNAL_0
)
1197 printf_filtered (_("Continuing with no signal.\n"));
1199 printf_filtered (_("Continuing with signal %s.\n"),
1200 gdb_signal_to_name (oursig
));
1203 clear_proceed_status (0);
1204 proceed ((CORE_ADDR
) -1, oursig
);
1207 /* Queue a signal to be delivered to the current thread. */
1210 queue_signal_command (const char *signum_exp
, int from_tty
)
1212 enum gdb_signal oursig
;
1213 struct thread_info
*tp
;
1216 ensure_not_tfind_mode ();
1217 ensure_valid_thread ();
1218 ensure_not_running ();
1220 if (signum_exp
== NULL
)
1221 error_no_arg (_("signal number"));
1223 /* It would be even slicker to make signal names be valid expressions,
1224 (the type could be "enum $signal" or some such), then the user could
1225 assign them to convenience variables. */
1226 oursig
= gdb_signal_from_name (signum_exp
);
1228 if (oursig
== GDB_SIGNAL_UNKNOWN
)
1230 /* No, try numeric. */
1231 int num
= parse_and_eval_long (signum_exp
);
1234 oursig
= GDB_SIGNAL_0
;
1236 oursig
= gdb_signal_from_command (num
);
1239 if (oursig
!= GDB_SIGNAL_0
1240 && !signal_pass_state (oursig
))
1241 error (_("Signal handling set to not pass this signal to the program."));
1243 tp
= inferior_thread ();
1244 tp
->set_stop_signal (oursig
);
1247 /* Data for the FSM that manages the until (with no argument)
1250 struct until_next_fsm
: public thread_fsm
1252 /* The thread that as current when the command was executed. */
1255 until_next_fsm (struct interp
*cmd_interp
, int thread
)
1256 : thread_fsm (cmd_interp
),
1261 bool should_stop (struct thread_info
*thread
) override
;
1262 void clean_up (struct thread_info
*thread
) override
;
1263 enum async_reply_reason
do_async_reply_reason () override
;
1266 /* Implementation of the 'should_stop' FSM method for the until (with
1270 until_next_fsm::should_stop (struct thread_info
*tp
)
1272 if (tp
->control
.stop_step
)
1278 /* Implementation of the 'clean_up' FSM method for the until (with no
1282 until_next_fsm::clean_up (struct thread_info
*thread
)
1284 delete_longjmp_breakpoint (thread
->global_num
);
1287 /* Implementation of the 'async_reply_reason' FSM method for the until
1288 (with no arg) command. */
1290 enum async_reply_reason
1291 until_next_fsm::do_async_reply_reason ()
1293 return EXEC_ASYNC_END_STEPPING_RANGE
;
1296 /* Proceed until we reach a different source line with pc greater than
1297 our current one or exit the function. We skip calls in both cases.
1299 Note that eventually this command should probably be changed so
1300 that only source lines are printed out when we hit the breakpoint
1301 we set. This may involve changes to wait_for_inferior and the
1302 proceed status code. */
1305 until_next_command (int from_tty
)
1307 struct frame_info
*frame
;
1309 struct symbol
*func
;
1310 struct symtab_and_line sal
;
1311 struct thread_info
*tp
= inferior_thread ();
1312 int thread
= tp
->global_num
;
1313 struct until_next_fsm
*sm
;
1315 clear_proceed_status (0);
1316 set_step_frame (tp
);
1318 frame
= get_current_frame ();
1320 /* Step until either exited from this function or greater
1321 than the current line (if in symbolic section) or pc (if
1324 pc
= get_frame_pc (frame
);
1325 func
= find_pc_function (pc
);
1329 struct bound_minimal_symbol msymbol
= lookup_minimal_symbol_by_pc (pc
);
1331 if (msymbol
.minsym
== NULL
)
1332 error (_("Execution is not within a known function."));
1334 tp
->control
.step_range_start
= BMSYMBOL_VALUE_ADDRESS (msymbol
);
1335 /* The upper-bound of step_range is exclusive. In order to make PC
1336 within the range, set the step_range_end with PC + 1. */
1337 tp
->control
.step_range_end
= pc
+ 1;
1341 sal
= find_pc_line (pc
, 0);
1343 tp
->control
.step_range_start
= BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (func
));
1344 tp
->control
.step_range_end
= sal
.end
;
1346 tp
->control
.may_range_step
= 1;
1348 tp
->control
.step_over_calls
= STEP_OVER_ALL
;
1350 set_longjmp_breakpoint (tp
, get_frame_id (frame
));
1351 delete_longjmp_breakpoint_cleanup
lj_deleter (thread
);
1353 sm
= new until_next_fsm (command_interp (), tp
->global_num
);
1354 tp
->thread_fsm
= sm
;
1355 lj_deleter
.release ();
1357 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
);
1361 until_command (const char *arg
, int from_tty
)
1366 ensure_not_tfind_mode ();
1367 ensure_valid_thread ();
1368 ensure_not_running ();
1370 /* Find out whether we must run in the background. */
1371 gdb::unique_xmalloc_ptr
<char> stripped
= strip_bg_char (arg
, &async_exec
);
1372 arg
= stripped
.get ();
1374 prepare_execution_command (current_inferior ()->top_target (), async_exec
);
1377 until_break_command (arg
, from_tty
, 0);
1379 until_next_command (from_tty
);
1383 advance_command (const char *arg
, int from_tty
)
1388 ensure_not_tfind_mode ();
1389 ensure_valid_thread ();
1390 ensure_not_running ();
1393 error_no_arg (_("a location"));
1395 /* Find out whether we must run in the background. */
1396 gdb::unique_xmalloc_ptr
<char> stripped
= strip_bg_char (arg
, &async_exec
);
1397 arg
= stripped
.get ();
1399 prepare_execution_command (current_inferior ()->top_target (), async_exec
);
1401 until_break_command (arg
, from_tty
, 1);
1404 /* Return the value of the result of a function at the end of a 'finish'
1405 command/BP. DTOR_DATA (if not NULL) can represent inferior registers
1406 right after an inferior call has finished. */
1409 get_return_value (struct value
*function
, struct type
*value_type
)
1411 regcache
*stop_regs
= get_current_regcache ();
1412 struct gdbarch
*gdbarch
= stop_regs
->arch ();
1413 struct value
*value
;
1415 value_type
= check_typedef (value_type
);
1416 gdb_assert (value_type
->code () != TYPE_CODE_VOID
);
1418 /* FIXME: 2003-09-27: When returning from a nested inferior function
1419 call, it's possible (with no help from the architecture vector)
1420 to locate and return/print a "struct return" value. This is just
1421 a more complicated case of what is already being done in the
1422 inferior function call code. In fact, when inferior function
1423 calls are made async, this will likely be made the norm. */
1425 switch (gdbarch_return_value (gdbarch
, function
, value_type
,
1428 case RETURN_VALUE_REGISTER_CONVENTION
:
1429 case RETURN_VALUE_ABI_RETURNS_ADDRESS
:
1430 case RETURN_VALUE_ABI_PRESERVES_ADDRESS
:
1431 value
= allocate_value (value_type
);
1432 gdbarch_return_value (gdbarch
, function
, value_type
, stop_regs
,
1433 value_contents_raw (value
), NULL
);
1435 case RETURN_VALUE_STRUCT_CONVENTION
:
1439 internal_error (__FILE__
, __LINE__
, _("bad switch"));
1445 /* The captured function return value/type and its position in the
1448 struct return_value_info
1450 /* The captured return value. May be NULL if we weren't able to
1451 retrieve it. See get_return_value. */
1452 struct value
*value
;
1454 /* The return type. In some cases, we'll not be able extract the
1455 return value, but we always know the type. */
1458 /* If we captured a value, this is the value history index. */
1459 int value_history_index
;
1462 /* Helper for print_return_value. */
1465 print_return_value_1 (struct ui_out
*uiout
, struct return_value_info
*rv
)
1467 if (rv
->value
!= NULL
)
1469 struct value_print_options opts
;
1472 uiout
->text ("Value returned is ");
1473 uiout
->field_fmt ("gdb-result-var", "$%d",
1474 rv
->value_history_index
);
1475 uiout
->text (" = ");
1476 get_user_print_options (&opts
);
1478 if (opts
.finish_print
)
1481 value_print (rv
->value
, &stb
, &opts
);
1482 uiout
->field_stream ("return-value", stb
);
1485 uiout
->field_string ("return-value", _("<not displayed>"),
1486 metadata_style
.style ());
1491 std::string type_name
= type_to_string (rv
->type
);
1492 uiout
->text ("Value returned has type: ");
1493 uiout
->field_string ("return-type", type_name
);
1495 uiout
->text (" Cannot determine contents\n");
1499 /* Print the result of a function at the end of a 'finish' command.
1500 RV points at an object representing the captured return value/type
1501 and its position in the value history. */
1504 print_return_value (struct ui_out
*uiout
, struct return_value_info
*rv
)
1506 if (rv
->type
== NULL
1507 || check_typedef (rv
->type
)->code () == TYPE_CODE_VOID
)
1512 /* print_return_value_1 can throw an exception in some
1513 circumstances. We need to catch this so that we still
1514 delete the breakpoint. */
1515 print_return_value_1 (uiout
, rv
);
1517 catch (const gdb_exception
&ex
)
1519 exception_print (gdb_stdout
, ex
);
1523 /* Data for the FSM that manages the finish command. */
1525 struct finish_command_fsm
: public thread_fsm
1527 /* The momentary breakpoint set at the function's return address in
1529 breakpoint_up breakpoint
;
1531 /* The function that we're stepping out of. */
1532 struct symbol
*function
= nullptr;
1534 /* If the FSM finishes successfully, this stores the function's
1536 struct return_value_info return_value_info
{};
1538 explicit finish_command_fsm (struct interp
*cmd_interp
)
1539 : thread_fsm (cmd_interp
)
1543 bool should_stop (struct thread_info
*thread
) override
;
1544 void clean_up (struct thread_info
*thread
) override
;
1545 struct return_value_info
*return_value () override
;
1546 enum async_reply_reason
do_async_reply_reason () override
;
1549 /* Implementation of the 'should_stop' FSM method for the finish
1550 commands. Detects whether the thread stepped out of the function
1551 successfully, and if so, captures the function's return value and
1552 marks the FSM finished. */
1555 finish_command_fsm::should_stop (struct thread_info
*tp
)
1557 struct return_value_info
*rv
= &return_value_info
;
1559 if (function
!= NULL
1560 && bpstat_find_breakpoint (tp
->control
.stop_bpstat
,
1561 breakpoint
.get ()) != NULL
)
1566 rv
->type
= TYPE_TARGET_TYPE (SYMBOL_TYPE (function
));
1567 if (rv
->type
== NULL
)
1568 internal_error (__FILE__
, __LINE__
,
1569 _("finish_command: function has no target type"));
1571 if (check_typedef (rv
->type
)->code () != TYPE_CODE_VOID
)
1575 func
= read_var_value (function
, NULL
, get_current_frame ());
1576 rv
->value
= get_return_value (func
, rv
->type
);
1577 if (rv
->value
!= NULL
)
1578 rv
->value_history_index
= record_latest_value (rv
->value
);
1581 else if (tp
->control
.stop_step
)
1583 /* Finishing from an inline frame, or reverse finishing. In
1584 either case, there's no way to retrieve the return value. */
1591 /* Implementation of the 'clean_up' FSM method for the finish
1595 finish_command_fsm::clean_up (struct thread_info
*thread
)
1597 breakpoint
.reset ();
1598 delete_longjmp_breakpoint (thread
->global_num
);
1601 /* Implementation of the 'return_value' FSM method for the finish
1604 struct return_value_info
*
1605 finish_command_fsm::return_value ()
1607 return &return_value_info
;
1610 /* Implementation of the 'async_reply_reason' FSM method for the
1613 enum async_reply_reason
1614 finish_command_fsm::do_async_reply_reason ()
1616 if (execution_direction
== EXEC_REVERSE
)
1617 return EXEC_ASYNC_END_STEPPING_RANGE
;
1619 return EXEC_ASYNC_FUNCTION_FINISHED
;
1622 /* finish_backward -- helper function for finish_command. */
1625 finish_backward (struct finish_command_fsm
*sm
)
1627 struct symtab_and_line sal
;
1628 struct thread_info
*tp
= inferior_thread ();
1630 CORE_ADDR func_addr
;
1632 pc
= get_frame_pc (get_current_frame ());
1634 if (find_pc_partial_function (pc
, NULL
, &func_addr
, NULL
) == 0)
1635 error (_("Cannot find bounds of current function"));
1637 sal
= find_pc_line (func_addr
, 0);
1639 tp
->control
.proceed_to_finish
= 1;
1640 /* Special case: if we're sitting at the function entry point,
1641 then all we need to do is take a reverse singlestep. We
1642 don't need to set a breakpoint, and indeed it would do us
1645 Note that this can only happen at frame #0, since there's
1646 no way that a function up the stack can have a return address
1647 that's equal to its entry point. */
1651 struct frame_info
*frame
= get_selected_frame (NULL
);
1652 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1654 /* Set a step-resume at the function's entry point. Once that's
1655 hit, we'll do one more step backwards. */
1656 symtab_and_line sr_sal
;
1658 sr_sal
.pspace
= get_frame_program_space (frame
);
1659 insert_step_resume_breakpoint_at_sal (gdbarch
,
1660 sr_sal
, null_frame_id
);
1662 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
);
1666 /* We're almost there -- we just need to back up by one more
1668 tp
->control
.step_range_start
= tp
->control
.step_range_end
= 1;
1669 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
);
1673 /* finish_forward -- helper function for finish_command. FRAME is the
1674 frame that called the function we're about to step out of. */
1677 finish_forward (struct finish_command_fsm
*sm
, struct frame_info
*frame
)
1679 struct frame_id frame_id
= get_frame_id (frame
);
1680 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1681 struct symtab_and_line sal
;
1682 struct thread_info
*tp
= inferior_thread ();
1684 sal
= find_pc_line (get_frame_pc (frame
), 0);
1685 sal
.pc
= get_frame_pc (frame
);
1687 sm
->breakpoint
= set_momentary_breakpoint (gdbarch
, sal
,
1688 get_stack_frame_id (frame
),
1691 /* set_momentary_breakpoint invalidates FRAME. */
1694 set_longjmp_breakpoint (tp
, frame_id
);
1696 /* We want to print return value, please... */
1697 tp
->control
.proceed_to_finish
= 1;
1699 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
);
1702 /* Skip frames for "finish". */
1704 static struct frame_info
*
1705 skip_finish_frames (struct frame_info
*frame
)
1707 struct frame_info
*start
;
1713 frame
= skip_tailcall_frames (frame
);
1717 frame
= skip_unwritable_frames (frame
);
1721 while (start
!= frame
);
1726 /* "finish": Set a temporary breakpoint at the place the selected
1727 frame will return to, then continue. */
1730 finish_command (const char *arg
, int from_tty
)
1732 struct frame_info
*frame
;
1734 struct finish_command_fsm
*sm
;
1735 struct thread_info
*tp
;
1738 ensure_not_tfind_mode ();
1739 ensure_valid_thread ();
1740 ensure_not_running ();
1742 /* Find out whether we must run in the background. */
1743 gdb::unique_xmalloc_ptr
<char> stripped
= strip_bg_char (arg
, &async_exec
);
1744 arg
= stripped
.get ();
1746 prepare_execution_command (current_inferior ()->top_target (), async_exec
);
1749 error (_("The \"finish\" command does not take any arguments."));
1751 frame
= get_prev_frame (get_selected_frame (_("No selected frame.")));
1753 error (_("\"finish\" not meaningful in the outermost frame."));
1755 clear_proceed_status (0);
1757 tp
= inferior_thread ();
1759 sm
= new finish_command_fsm (command_interp ());
1761 tp
->thread_fsm
= sm
;
1763 /* Finishing from an inline frame is completely different. We don't
1764 try to show the "return value" - no way to locate it. */
1765 if (get_frame_type (get_selected_frame (_("No selected frame.")))
1768 /* Claim we are stepping in the calling frame. An empty step
1769 range means that we will stop once we aren't in a function
1770 called by that frame. We don't use the magic "1" value for
1771 step_range_end, because then infrun will think this is nexti,
1772 and not step over the rest of this inlined function call. */
1773 set_step_info (tp
, frame
, {});
1774 tp
->control
.step_range_start
= get_frame_pc (frame
);
1775 tp
->control
.step_range_end
= tp
->control
.step_range_start
;
1776 tp
->control
.step_over_calls
= STEP_OVER_ALL
;
1778 /* Print info on the selected frame, including level number but not
1782 printf_filtered (_("Run till exit from "));
1783 print_stack_frame (get_selected_frame (NULL
), 1, LOCATION
, 0);
1786 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
);
1790 /* Find the function we will return from. */
1792 sm
->function
= find_pc_function (get_frame_pc (get_selected_frame (NULL
)));
1794 /* Print info on the selected frame, including level number but not
1798 if (execution_direction
== EXEC_REVERSE
)
1799 printf_filtered (_("Run back to call of "));
1802 if (sm
->function
!= NULL
&& TYPE_NO_RETURN (sm
->function
->type
)
1803 && !query (_("warning: Function %s does not return normally.\n"
1804 "Try to finish anyway? "),
1805 sm
->function
->print_name ()))
1806 error (_("Not confirmed."));
1807 printf_filtered (_("Run till exit from "));
1810 print_stack_frame (get_selected_frame (NULL
), 1, LOCATION
, 0);
1813 if (execution_direction
== EXEC_REVERSE
)
1814 finish_backward (sm
);
1817 frame
= skip_finish_frames (frame
);
1820 error (_("Cannot find the caller frame."));
1822 finish_forward (sm
, frame
);
1828 info_program_command (const char *args
, int from_tty
)
1833 process_stratum_target
*proc_target
;
1835 if (!target_has_execution ())
1837 printf_filtered (_("The program being debugged is not being run.\n"));
1843 ptid
= inferior_ptid
;
1844 proc_target
= current_inferior ()->process_target ();
1847 get_last_target_status (&proc_target
, &ptid
, nullptr);
1849 if (ptid
== null_ptid
|| ptid
== minus_one_ptid
)
1850 error (_("No selected thread."));
1852 thread_info
*tp
= find_thread_ptid (proc_target
, ptid
);
1854 if (tp
->state
== THREAD_EXITED
)
1855 error (_("Invalid selected thread."));
1856 else if (tp
->state
== THREAD_RUNNING
)
1857 error (_("Selected thread is running."));
1859 bs
= tp
->control
.stop_bpstat
;
1860 stat
= bpstat_num (&bs
, &num
);
1862 target_files_info ();
1863 printf_filtered (_("Program stopped at %s.\n"),
1864 paddress (target_gdbarch (), tp
->stop_pc ()));
1865 if (tp
->control
.stop_step
)
1866 printf_filtered (_("It stopped after being stepped.\n"));
1869 /* There may be several breakpoints in the same place, so this
1870 isn't as strange as it seems. */
1875 printf_filtered (_("It stopped at a breakpoint "
1876 "that has since been deleted.\n"));
1879 printf_filtered (_("It stopped at breakpoint %d.\n"), num
);
1880 stat
= bpstat_num (&bs
, &num
);
1883 else if (tp
->stop_signal () != GDB_SIGNAL_0
)
1885 printf_filtered (_("It stopped with signal %s, %s.\n"),
1886 gdb_signal_to_name (tp
->stop_signal ()),
1887 gdb_signal_to_string (tp
->stop_signal ()));
1892 printf_filtered (_("Type \"info stack\" or \"info "
1893 "registers\" for more information.\n"));
1898 environment_info (const char *var
, int from_tty
)
1902 const char *val
= current_inferior ()->environment
.get (var
);
1906 puts_filtered (var
);
1907 puts_filtered (" = ");
1908 puts_filtered (val
);
1909 puts_filtered ("\n");
1913 puts_filtered ("Environment variable \"");
1914 puts_filtered (var
);
1915 puts_filtered ("\" not defined.\n");
1920 char **envp
= current_inferior ()->environment
.envp ();
1922 for (int idx
= 0; envp
[idx
] != NULL
; ++idx
)
1924 puts_filtered (envp
[idx
]);
1925 puts_filtered ("\n");
1931 set_environment_command (const char *arg
, int from_tty
)
1933 const char *p
, *val
;
1937 error_no_arg (_("environment variable and value"));
1939 /* Find separation between variable name and value. */
1940 p
= (char *) strchr (arg
, '=');
1941 val
= (char *) strchr (arg
, ' ');
1943 if (p
!= 0 && val
!= 0)
1945 /* We have both a space and an equals. If the space is before the
1946 equals, walk forward over the spaces til we see a nonspace
1947 (possibly the equals). */
1952 /* Now if the = is after the char following the spaces,
1953 take the char following the spaces. */
1957 else if (val
!= 0 && p
== 0)
1961 error_no_arg (_("environment variable to set"));
1963 if (p
== 0 || p
[1] == 0)
1967 p
= arg
+ strlen (arg
); /* So that savestring below will work. */
1971 /* Not setting variable value to null. */
1973 while (*val
== ' ' || *val
== '\t')
1977 while (p
!= arg
&& (p
[-1] == ' ' || p
[-1] == '\t'))
1980 std::string
var (arg
, p
- arg
);
1983 printf_filtered (_("Setting environment variable "
1984 "\"%s\" to null value.\n"),
1986 current_inferior ()->environment
.set (var
.c_str (), "");
1989 current_inferior ()->environment
.set (var
.c_str (), val
);
1993 unset_environment_command (const char *var
, int from_tty
)
1997 /* If there is no argument, delete all environment variables.
1998 Ask for confirmation if reading from the terminal. */
1999 if (!from_tty
|| query (_("Delete all environment variables? ")))
2000 current_inferior ()->environment
.clear ();
2003 current_inferior ()->environment
.unset (var
);
2006 /* Handle the execution path (PATH variable). */
2008 static const char path_var_name
[] = "PATH";
2011 path_info (const char *args
, int from_tty
)
2013 puts_filtered ("Executable and object file path: ");
2014 puts_filtered (current_inferior ()->environment
.get (path_var_name
));
2015 puts_filtered ("\n");
2018 /* Add zero or more directories to the front of the execution path. */
2021 path_command (const char *dirname
, int from_tty
)
2026 env
= current_inferior ()->environment
.get (path_var_name
);
2027 /* Can be null if path is not set. */
2030 std::string exec_path
= env
;
2031 mod_path (dirname
, exec_path
);
2032 current_inferior ()->environment
.set (path_var_name
, exec_path
.c_str ());
2034 path_info (NULL
, from_tty
);
2039 pad_to_column (string_file
&stream
, int col
)
2041 /* At least one space must be printed to separate columns. */
2043 const int size
= stream
.size ();
2045 stream
.puts (n_spaces (col
- size
));
2048 /* Print out the register NAME with value VAL, to FILE, in the default
2052 default_print_one_register_info (struct ui_file
*file
,
2056 struct type
*regtype
= value_type (val
);
2057 int print_raw_format
;
2058 string_file format_stream
;
2061 value_column_1
= 15,
2062 /* Give enough room for "0x", 16 hex digits and two spaces in
2063 preceding column. */
2064 value_column_2
= value_column_1
+ 2 + 16 + 2,
2067 format_stream
.puts (name
);
2068 pad_to_column (format_stream
, value_column_1
);
2070 print_raw_format
= (value_entirely_available (val
)
2071 && !value_optimized_out (val
));
2073 /* If virtual format is floating, print it that way, and in raw
2075 if (regtype
->code () == TYPE_CODE_FLT
2076 || regtype
->code () == TYPE_CODE_DECFLOAT
)
2078 struct value_print_options opts
;
2079 const gdb_byte
*valaddr
= value_contents_for_printing (val
);
2080 enum bfd_endian byte_order
= type_byte_order (regtype
);
2082 get_user_print_options (&opts
);
2085 common_val_print (val
, &format_stream
, 0, &opts
, current_language
);
2087 if (print_raw_format
)
2089 pad_to_column (format_stream
, value_column_2
);
2090 format_stream
.puts ("(raw ");
2091 print_hex_chars (&format_stream
, valaddr
, TYPE_LENGTH (regtype
),
2093 format_stream
.putc (')');
2098 struct value_print_options opts
;
2100 /* Print the register in hex. */
2101 get_formatted_print_options (&opts
, 'x');
2103 common_val_print (val
, &format_stream
, 0, &opts
, current_language
);
2104 /* If not a vector register, print it also according to its
2106 if (print_raw_format
&& regtype
->is_vector () == 0)
2108 pad_to_column (format_stream
, value_column_2
);
2109 get_user_print_options (&opts
);
2111 common_val_print (val
, &format_stream
, 0, &opts
, current_language
);
2115 fputs_filtered (format_stream
.c_str (), file
);
2116 fprintf_filtered (file
, "\n");
2119 /* Print out the machine register regnum. If regnum is -1, print all
2120 registers (print_all == 1) or all non-float and non-vector
2121 registers (print_all == 0).
2123 For most machines, having all_registers_info() print the
2124 register(s) one per line is good enough. If a different format is
2125 required, (eg, for MIPS or Pyramid 90x, which both have lots of
2126 regs), or there is an existing convention for showing all the
2127 registers, define the architecture method PRINT_REGISTERS_INFO to
2128 provide that format. */
2131 default_print_registers_info (struct gdbarch
*gdbarch
,
2132 struct ui_file
*file
,
2133 struct frame_info
*frame
,
2134 int regnum
, int print_all
)
2137 const int numregs
= gdbarch_num_cooked_regs (gdbarch
);
2139 for (i
= 0; i
< numregs
; i
++)
2141 /* Decide between printing all regs, non-float / vector regs, or
2147 if (!gdbarch_register_reggroup_p (gdbarch
, i
, all_reggroup
))
2152 if (!gdbarch_register_reggroup_p (gdbarch
, i
, general_reggroup
))
2162 /* If the register name is empty, it is undefined for this
2163 processor, so don't display anything. */
2164 if (gdbarch_register_name (gdbarch
, i
) == NULL
2165 || *(gdbarch_register_name (gdbarch
, i
)) == '\0')
2168 default_print_one_register_info (file
,
2169 gdbarch_register_name (gdbarch
, i
),
2170 value_of_register (i
, frame
));
2175 registers_info (const char *addr_exp
, int fpregs
)
2177 struct frame_info
*frame
;
2178 struct gdbarch
*gdbarch
;
2180 if (!target_has_registers ())
2181 error (_("The program has no registers now."));
2182 frame
= get_selected_frame (NULL
);
2183 gdbarch
= get_frame_arch (frame
);
2187 gdbarch_print_registers_info (gdbarch
, gdb_stdout
,
2192 while (*addr_exp
!= '\0')
2197 /* Skip leading white space. */
2198 addr_exp
= skip_spaces (addr_exp
);
2200 /* Discard any leading ``$''. Check that there is something
2201 resembling a register following it. */
2202 if (addr_exp
[0] == '$')
2204 if (isspace ((*addr_exp
)) || (*addr_exp
) == '\0')
2205 error (_("Missing register name"));
2207 /* Find the start/end of this register name/num/group. */
2209 while ((*addr_exp
) != '\0' && !isspace ((*addr_exp
)))
2213 /* Figure out what we've found and display it. */
2215 /* A register name? */
2217 int regnum
= user_reg_map_name_to_regnum (gdbarch
, start
, end
- start
);
2221 /* User registers lie completely outside of the range of
2222 normal registers. Catch them early so that the target
2224 if (regnum
>= gdbarch_num_cooked_regs (gdbarch
))
2226 struct value
*regval
= value_of_user_reg (regnum
, frame
);
2227 const char *regname
= user_reg_map_regnum_to_name (gdbarch
,
2230 /* Print in the same fashion
2231 gdbarch_print_registers_info's default
2232 implementation prints. */
2233 default_print_one_register_info (gdb_stdout
,
2238 gdbarch_print_registers_info (gdbarch
, gdb_stdout
,
2239 frame
, regnum
, fpregs
);
2244 /* A register group? */
2246 struct reggroup
*group
;
2248 for (group
= reggroup_next (gdbarch
, NULL
);
2250 group
= reggroup_next (gdbarch
, group
))
2252 /* Don't bother with a length check. Should the user
2253 enter a short register group name, go with the first
2254 group that matches. */
2255 if (strncmp (start
, reggroup_name (group
), end
- start
) == 0)
2263 regnum
< gdbarch_num_cooked_regs (gdbarch
);
2266 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, group
))
2267 gdbarch_print_registers_info (gdbarch
,
2275 /* Nothing matched. */
2276 error (_("Invalid register `%.*s'"), (int) (end
- start
), start
);
2281 info_all_registers_command (const char *addr_exp
, int from_tty
)
2283 registers_info (addr_exp
, 1);
2287 info_registers_command (const char *addr_exp
, int from_tty
)
2289 registers_info (addr_exp
, 0);
2293 print_vector_info (struct ui_file
*file
,
2294 struct frame_info
*frame
, const char *args
)
2296 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
2298 if (gdbarch_print_vector_info_p (gdbarch
))
2299 gdbarch_print_vector_info (gdbarch
, file
, frame
, args
);
2303 int printed_something
= 0;
2305 for (regnum
= 0; regnum
< gdbarch_num_cooked_regs (gdbarch
); regnum
++)
2307 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, vector_reggroup
))
2309 printed_something
= 1;
2310 gdbarch_print_registers_info (gdbarch
, file
, frame
, regnum
, 1);
2313 if (!printed_something
)
2314 fprintf_filtered (file
, "No vector information\n");
2319 info_vector_command (const char *args
, int from_tty
)
2321 if (!target_has_registers ())
2322 error (_("The program has no registers now."));
2324 print_vector_info (gdb_stdout
, get_selected_frame (NULL
), args
);
2327 /* Kill the inferior process. Make us have no inferior. */
2330 kill_command (const char *arg
, int from_tty
)
2332 /* FIXME: This should not really be inferior_ptid (or target_has_execution).
2333 It should be a distinct flag that indicates that a target is active, cuz
2334 some targets don't have processes! */
2336 if (inferior_ptid
== null_ptid
)
2337 error (_("The program is not being run."));
2338 if (!query (_("Kill the program being debugged? ")))
2339 error (_("Not confirmed."));
2341 int pid
= current_inferior ()->pid
;
2342 /* Save the pid as a string before killing the inferior, since that
2343 may unpush the current target, and we need the string after. */
2344 std::string pid_str
= target_pid_to_str (ptid_t (pid
));
2345 int infnum
= current_inferior ()->num
;
2349 if (print_inferior_events
)
2350 printf_unfiltered (_("[Inferior %d (%s) killed]\n"),
2351 infnum
, pid_str
.c_str ());
2353 bfd_cache_close_all ();
2356 /* Used in `attach&' command. Proceed threads of inferior INF iff
2357 they stopped due to debugger request, and when they did, they
2358 reported a clean stop (GDB_SIGNAL_0). Do not proceed threads that
2359 have been explicitly been told to stop. */
2362 proceed_after_attach (inferior
*inf
)
2364 /* Don't error out if the current thread is running, because
2365 there may be other stopped threads. */
2367 /* Backup current thread and selected frame. */
2368 scoped_restore_current_thread restore_thread
;
2370 for (thread_info
*thread
: inf
->non_exited_threads ())
2371 if (!thread
->executing ()
2372 && !thread
->stop_requested
2373 && thread
->stop_signal () == GDB_SIGNAL_0
)
2375 switch_to_thread (thread
);
2376 clear_proceed_status (0);
2377 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
);
2381 /* See inferior.h. */
2384 setup_inferior (int from_tty
)
2386 struct inferior
*inferior
;
2388 inferior
= current_inferior ();
2389 inferior
->needs_setup
= 0;
2391 /* If no exec file is yet known, try to determine it from the
2393 if (get_exec_file (0) == NULL
)
2394 exec_file_locate_attach (inferior_ptid
.pid (), 1, from_tty
);
2397 reopen_exec_file ();
2401 /* Take any necessary post-attaching actions for this platform. */
2402 target_post_attach (inferior_ptid
.pid ());
2404 post_create_inferior (from_tty
);
2407 /* What to do after the first program stops after attaching. */
2408 enum attach_post_wait_mode
2410 /* Do nothing. Leaves threads as they are. */
2411 ATTACH_POST_WAIT_NOTHING
,
2413 /* Re-resume threads that are marked running. */
2414 ATTACH_POST_WAIT_RESUME
,
2416 /* Stop all threads. */
2417 ATTACH_POST_WAIT_STOP
,
2420 /* Called after we've attached to a process and we've seen it stop for
2421 the first time. Resume, stop, or don't touch the threads according
2425 attach_post_wait (int from_tty
, enum attach_post_wait_mode mode
)
2427 struct inferior
*inferior
;
2429 inferior
= current_inferior ();
2430 inferior
->control
.stop_soon
= NO_STOP_QUIETLY
;
2432 if (inferior
->needs_setup
)
2433 setup_inferior (from_tty
);
2435 if (mode
== ATTACH_POST_WAIT_RESUME
)
2437 /* The user requested an `attach&', so be sure to leave threads
2438 that didn't get a signal running. */
2440 /* Immediately resume all suspended threads of this inferior,
2441 and this inferior only. This should have no effect on
2442 already running threads. If a thread has been stopped with a
2443 signal, leave it be. */
2445 proceed_after_attach (inferior
);
2448 if (inferior_thread ()->stop_signal () == GDB_SIGNAL_0
)
2450 clear_proceed_status (0);
2451 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
);
2455 else if (mode
== ATTACH_POST_WAIT_STOP
)
2457 /* The user requested a plain `attach', so be sure to leave
2458 the inferior stopped. */
2460 /* At least the current thread is already stopped. */
2462 /* In all-stop, by definition, all threads have to be already
2463 stopped at this point. In non-stop, however, although the
2464 selected thread is stopped, others may still be executing.
2465 Be sure to explicitly stop all threads of the process. This
2466 should have no effect on already stopped threads. */
2468 target_stop (ptid_t (inferior
->pid
));
2469 else if (target_is_non_stop_p ())
2471 struct thread_info
*lowest
= inferior_thread ();
2473 stop_all_threads ();
2475 /* It's not defined which thread will report the attach
2476 stop. For consistency, always select the thread with
2477 lowest GDB number, which should be the main thread, if it
2479 for (thread_info
*thread
: current_inferior ()->non_exited_threads ())
2480 if (thread
->inf
->num
< lowest
->inf
->num
2481 || thread
->per_inf_num
< lowest
->per_inf_num
)
2484 switch_to_thread (lowest
);
2487 /* Tell the user/frontend where we're stopped. */
2489 if (deprecated_attach_hook
)
2490 deprecated_attach_hook ();
2494 /* "attach" command entry point. Takes a program started up outside
2495 of gdb and ``attaches'' to it. This stops it cold in its tracks
2496 and allows us to start debugging it. */
2499 attach_command (const char *args
, int from_tty
)
2502 struct target_ops
*attach_target
;
2503 struct inferior
*inferior
= current_inferior ();
2504 enum attach_post_wait_mode mode
;
2506 dont_repeat (); /* Not for the faint of heart */
2508 scoped_disable_commit_resumed
disable_commit_resumed ("attaching");
2510 if (gdbarch_has_global_solist (target_gdbarch ()))
2511 /* Don't complain if all processes share the same symbol
2514 else if (target_has_execution ())
2516 if (query (_("A program is being debugged already. Kill it? ")))
2519 error (_("Not killed."));
2522 /* Clean up any leftovers from other runs. Some other things from
2523 this function should probably be moved into target_pre_inferior. */
2524 target_pre_inferior (from_tty
);
2526 gdb::unique_xmalloc_ptr
<char> stripped
= strip_bg_char (args
, &async_exec
);
2527 args
= stripped
.get ();
2529 attach_target
= find_attach_target ();
2531 prepare_execution_command (attach_target
, async_exec
);
2533 if (non_stop
&& !attach_target
->supports_non_stop ())
2534 error (_("Cannot attach to this target in non-stop mode"));
2536 attach_target
->attach (args
, from_tty
);
2537 /* to_attach should push the target, so after this point we
2538 shouldn't refer to attach_target again. */
2539 attach_target
= NULL
;
2541 /* Set up the "saved terminal modes" of the inferior
2542 based on what modes we are starting it with. */
2543 target_terminal::init ();
2545 /* Install inferior's terminal modes. This may look like a no-op,
2546 as we've just saved them above, however, this does more than
2547 restore terminal settings:
2549 - installs a SIGINT handler that forwards SIGINT to the inferior.
2550 Otherwise a Ctrl-C pressed just while waiting for the initial
2551 stop would end up as a spurious Quit.
2553 - removes stdin from the event loop, which we need if attaching
2554 in the foreground, otherwise on targets that report an initial
2555 stop on attach (which are most) we'd process input/commands
2556 while we're in the event loop waiting for that stop. That is,
2557 before the attach continuation runs and the command is really
2559 target_terminal::inferior ();
2561 /* Set up execution context to know that we should return from
2562 wait_for_inferior as soon as the target reports a stop. */
2563 init_wait_for_inferior ();
2565 inferior
->needs_setup
= 1;
2567 if (target_is_non_stop_p ())
2569 /* If we find that the current thread isn't stopped, explicitly
2570 do so now, because we're going to install breakpoints and
2574 /* The user requested an `attach&'; stop just one thread. */
2575 target_stop (inferior_ptid
);
2577 /* The user requested an `attach', so stop all threads of this
2579 target_stop (ptid_t (inferior_ptid
.pid ()));
2582 /* Check for exec file mismatch, and let the user solve it. */
2583 validate_exec_file (from_tty
);
2585 mode
= async_exec
? ATTACH_POST_WAIT_RESUME
: ATTACH_POST_WAIT_STOP
;
2587 /* Some system don't generate traps when attaching to inferior.
2588 E.g. Mach 3 or GNU hurd. */
2589 if (!target_attach_no_wait ())
2591 /* Careful here. See comments in inferior.h. Basically some
2592 OSes don't ignore SIGSTOPs on continue requests anymore. We
2593 need a way for handle_inferior_event to reset the stop_signal
2594 variable after an attach, and this is what
2595 STOP_QUIETLY_NO_SIGSTOP is for. */
2596 inferior
->control
.stop_soon
= STOP_QUIETLY_NO_SIGSTOP
;
2598 /* Wait for stop. */
2599 inferior
->add_continuation ([=] ()
2601 attach_post_wait (from_tty
, mode
);
2604 /* Let infrun consider waiting for events out of this
2606 inferior
->process_target ()->threads_executing
= true;
2608 if (!target_is_async_p ())
2609 mark_infrun_async_event_handler ();
2613 attach_post_wait (from_tty
, mode
);
2615 disable_commit_resumed
.reset_and_commit ();
2618 /* We had just found out that the target was already attached to an
2619 inferior. PTID points at a thread of this new inferior, that is
2620 the most likely to be stopped right now, but not necessarily so.
2621 The new inferior is assumed to be already added to the inferior
2622 list at this point. If LEAVE_RUNNING, then leave the threads of
2623 this inferior running, except those we've explicitly seen reported
2627 notice_new_inferior (thread_info
*thr
, bool leave_running
, int from_tty
)
2629 enum attach_post_wait_mode mode
2630 = leave_running
? ATTACH_POST_WAIT_RESUME
: ATTACH_POST_WAIT_NOTHING
;
2632 gdb::optional
<scoped_restore_current_thread
> restore_thread
;
2634 if (inferior_ptid
!= null_ptid
)
2635 restore_thread
.emplace ();
2637 /* Avoid reading registers -- we haven't fetched the target
2639 switch_to_thread_no_regs (thr
);
2641 /* When we "notice" a new inferior we need to do all the things we
2642 would normally do if we had just attached to it. */
2644 if (thr
->executing ())
2646 struct inferior
*inferior
= current_inferior ();
2648 /* We're going to install breakpoints, and poke at memory,
2649 ensure that the inferior is stopped for a moment while we do
2651 target_stop (inferior_ptid
);
2653 inferior
->control
.stop_soon
= STOP_QUIETLY_REMOTE
;
2655 /* Wait for stop before proceeding. */
2656 inferior
->add_continuation ([=] ()
2658 attach_post_wait (from_tty
, mode
);
2664 attach_post_wait (from_tty
, mode
);
2669 * takes a program previously attached to and detaches it.
2670 * The program resumes execution and will no longer stop
2671 * on signals, etc. We better not have left any breakpoints
2672 * in the program or it'll die when it hits one. For this
2673 * to work, it may be necessary for the process to have been
2674 * previously attached. It *might* work if the program was
2675 * started via the normal ptrace (PTRACE_TRACEME).
2679 detach_command (const char *args
, int from_tty
)
2681 dont_repeat (); /* Not for the faint of heart. */
2683 if (inferior_ptid
== null_ptid
)
2684 error (_("The program is not being run."));
2686 scoped_disable_commit_resumed
disable_commit_resumed ("detaching");
2688 query_if_trace_running (from_tty
);
2690 disconnect_tracing ();
2692 /* Hold a strong reference to the target while (maybe)
2693 detaching the parent. Otherwise detaching could close the
2696 = target_ops_ref::new_reference (current_inferior ()->process_target ());
2698 /* Save this before detaching, since detaching may unpush the
2699 process_stratum target. */
2700 bool was_non_stop_p
= target_is_non_stop_p ();
2702 target_detach (current_inferior (), from_tty
);
2704 /* The current inferior process was just detached successfully. Get
2705 rid of breakpoints that no longer make sense. Note we don't do
2706 this within target_detach because that is also used when
2707 following child forks, and in that case we will want to transfer
2708 breakpoints to the child, not delete them. */
2709 breakpoint_init_inferior (inf_exited
);
2711 /* If the solist is global across inferiors, don't clear it when we
2712 detach from a single inferior. */
2713 if (!gdbarch_has_global_solist (target_gdbarch ()))
2714 no_shared_libraries (NULL
, from_tty
);
2716 if (deprecated_detach_hook
)
2717 deprecated_detach_hook ();
2719 if (!was_non_stop_p
)
2720 restart_after_all_stop_detach (as_process_stratum_target (target_ref
.get ()));
2722 disable_commit_resumed
.reset_and_commit ();
2725 /* Disconnect from the current target without resuming it (leaving it
2726 waiting for a debugger).
2728 We'd better not have left any breakpoints in the program or the
2729 next debugger will get confused. Currently only supported for some
2730 remote targets, since the normal attach mechanisms don't work on
2731 stopped processes on some native platforms (e.g. GNU/Linux). */
2734 disconnect_command (const char *args
, int from_tty
)
2736 dont_repeat (); /* Not for the faint of heart. */
2737 query_if_trace_running (from_tty
);
2738 disconnect_tracing ();
2739 target_disconnect (args
, from_tty
);
2740 no_shared_libraries (NULL
, from_tty
);
2741 init_thread_list ();
2742 if (deprecated_detach_hook
)
2743 deprecated_detach_hook ();
2746 /* Stop PTID in the current target, and tag the PTID threads as having
2747 been explicitly requested to stop. PTID can be a thread, a
2748 process, or minus_one_ptid, meaning all threads of all inferiors of
2749 the current target. */
2752 stop_current_target_threads_ns (ptid_t ptid
)
2756 /* Tag the thread as having been explicitly requested to stop, so
2757 other parts of gdb know not to resume this thread automatically,
2758 if it was stopped due to an internal event. Limit this to
2759 non-stop mode, as when debugging a multi-threaded application in
2760 all-stop mode, we will only get one stop event --- it's undefined
2761 which thread will report the event. */
2762 set_stop_requested (current_inferior ()->process_target (),
2766 /* See inferior.h. */
2769 interrupt_target_1 (bool all_threads
)
2771 scoped_disable_commit_resumed
disable_commit_resumed ("interrupting");
2777 scoped_restore_current_thread restore_thread
;
2779 for (inferior
*inf
: all_inferiors ())
2781 switch_to_inferior_no_thread (inf
);
2782 stop_current_target_threads_ns (minus_one_ptid
);
2786 stop_current_target_threads_ns (inferior_ptid
);
2789 target_interrupt ();
2791 disable_commit_resumed
.reset_and_commit ();
2795 Stop the execution of the target while running in async mode, in
2796 the background. In all-stop, stop the whole process. In non-stop
2797 mode, stop the current thread only by default, or stop all threads
2798 if the `-a' switch is used. */
2801 interrupt_command (const char *args
, int from_tty
)
2803 if (target_can_async_p ())
2805 int all_threads
= 0;
2807 dont_repeat (); /* Not for the faint of heart. */
2810 && startswith (args
, "-a"))
2813 if (!non_stop
&& all_threads
)
2814 error (_("-a is meaningless in all-stop mode."));
2816 interrupt_target_1 (all_threads
);
2820 /* See inferior.h. */
2823 default_print_float_info (struct gdbarch
*gdbarch
, struct ui_file
*file
,
2824 struct frame_info
*frame
, const char *args
)
2827 int printed_something
= 0;
2829 for (regnum
= 0; regnum
< gdbarch_num_cooked_regs (gdbarch
); regnum
++)
2831 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, float_reggroup
))
2833 printed_something
= 1;
2834 gdbarch_print_registers_info (gdbarch
, file
, frame
, regnum
, 1);
2837 if (!printed_something
)
2838 fprintf_filtered (file
, "No floating-point info "
2839 "available for this processor.\n");
2843 info_float_command (const char *args
, int from_tty
)
2845 struct frame_info
*frame
;
2847 if (!target_has_registers ())
2848 error (_("The program has no registers now."));
2850 frame
= get_selected_frame (NULL
);
2851 gdbarch_print_float_info (get_frame_arch (frame
), gdb_stdout
, frame
, args
);
2854 /* Implement `info proc' family of commands. */
2857 info_proc_cmd_1 (const char *args
, enum info_proc_what what
, int from_tty
)
2859 struct gdbarch
*gdbarch
= get_current_arch ();
2861 if (!target_info_proc (args
, what
))
2863 if (gdbarch_info_proc_p (gdbarch
))
2864 gdbarch_info_proc (gdbarch
, args
, what
);
2866 error (_("Not supported on this target."));
2870 /* Implement `info proc' when given without any further parameters. */
2873 info_proc_cmd (const char *args
, int from_tty
)
2875 info_proc_cmd_1 (args
, IP_MINIMAL
, from_tty
);
2878 /* Implement `info proc mappings'. */
2881 info_proc_cmd_mappings (const char *args
, int from_tty
)
2883 info_proc_cmd_1 (args
, IP_MAPPINGS
, from_tty
);
2886 /* Implement `info proc stat'. */
2889 info_proc_cmd_stat (const char *args
, int from_tty
)
2891 info_proc_cmd_1 (args
, IP_STAT
, from_tty
);
2894 /* Implement `info proc status'. */
2897 info_proc_cmd_status (const char *args
, int from_tty
)
2899 info_proc_cmd_1 (args
, IP_STATUS
, from_tty
);
2902 /* Implement `info proc cwd'. */
2905 info_proc_cmd_cwd (const char *args
, int from_tty
)
2907 info_proc_cmd_1 (args
, IP_CWD
, from_tty
);
2910 /* Implement `info proc cmdline'. */
2913 info_proc_cmd_cmdline (const char *args
, int from_tty
)
2915 info_proc_cmd_1 (args
, IP_CMDLINE
, from_tty
);
2918 /* Implement `info proc exe'. */
2921 info_proc_cmd_exe (const char *args
, int from_tty
)
2923 info_proc_cmd_1 (args
, IP_EXE
, from_tty
);
2926 /* Implement `info proc files'. */
2929 info_proc_cmd_files (const char *args
, int from_tty
)
2931 info_proc_cmd_1 (args
, IP_FILES
, from_tty
);
2934 /* Implement `info proc all'. */
2937 info_proc_cmd_all (const char *args
, int from_tty
)
2939 info_proc_cmd_1 (args
, IP_ALL
, from_tty
);
2942 /* Implement `show print finish'. */
2945 show_print_finish (struct ui_file
*file
, int from_tty
,
2946 struct cmd_list_element
*c
,
2949 fprintf_filtered (file
, _("\
2950 Printing of return value after `finish' is %s.\n"),
2955 /* This help string is used for the run, start, and starti commands.
2956 It is defined as a macro to prevent duplication. */
2958 #define RUN_ARGS_HELP \
2959 "You may specify arguments to give it.\n\
2960 Args may include \"*\", or \"[...]\"; they are expanded using the\n\
2961 shell that will start the program (specified by the \"$SHELL\" environment\n\
2962 variable). Input and output redirection with \">\", \"<\", or \">>\"\n\
2963 are also allowed.\n\
2965 With no arguments, uses arguments last specified (with \"run\" or \n\
2966 \"set args\"). To cancel previous arguments and run with no arguments,\n\
2967 use \"set args\" without arguments.\n\
2969 To start the inferior without using a shell, use \"set startup-with-shell off\"."
2971 void _initialize_infcmd ();
2973 _initialize_infcmd ()
2975 static struct cmd_list_element
*info_proc_cmdlist
;
2976 struct cmd_list_element
*c
= NULL
;
2977 const char *cmd_name
;
2979 /* Add the filename of the terminal connected to inferior I/O. */
2980 add_setshow_optional_filename_cmd ("inferior-tty", class_run
,
2981 &inferior_io_terminal_scratch
, _("\
2982 Set terminal for future runs of program being debugged."), _("\
2983 Show terminal for future runs of program being debugged."), _("\
2984 Usage: set inferior-tty [TTY]\n\n\
2985 If TTY is omitted, the default behavior of using the same terminal as GDB\n\
2987 set_inferior_tty_command
,
2988 show_inferior_tty_command
,
2989 &setlist
, &showlist
);
2990 cmd_name
= "inferior-tty";
2991 c
= lookup_cmd (&cmd_name
, setlist
, "", NULL
, -1, 1);
2992 gdb_assert (c
!= NULL
);
2993 add_alias_cmd ("tty", c
, class_run
, 0, &cmdlist
);
2996 add_setshow_string_noescape_cmd (cmd_name
, class_run
,
2997 &inferior_args_scratch
, _("\
2998 Set argument list to give program being debugged when it is started."), _("\
2999 Show argument list to give program being debugged when it is started."), _("\
3000 Follow this command with any number of args, to be passed to the program."),
3003 &setlist
, &showlist
);
3004 c
= lookup_cmd (&cmd_name
, setlist
, "", NULL
, -1, 1);
3005 gdb_assert (c
!= NULL
);
3006 set_cmd_completer (c
, filename_completer
);
3009 add_setshow_string_noescape_cmd (cmd_name
, class_run
,
3010 &inferior_cwd_scratch
, _("\
3011 Set the current working directory to be used when the inferior is started.\n\
3012 Changing this setting does not have any effect on inferiors that are\n\
3015 Show the current working directory that is used when the inferior is started."),
3017 Use this command to change the current working directory that will be used\n\
3018 when the inferior is started. This setting does not affect GDB's current\n\
3019 working directory."),
3022 &setlist
, &showlist
);
3023 c
= lookup_cmd (&cmd_name
, setlist
, "", NULL
, -1, 1);
3024 gdb_assert (c
!= NULL
);
3025 set_cmd_completer (c
, filename_completer
);
3027 c
= add_cmd ("environment", no_class
, environment_info
, _("\
3028 The environment to give the program, or one variable's value.\n\
3029 With an argument VAR, prints the value of environment variable VAR to\n\
3030 give the program being debugged. With no arguments, prints the entire\n\
3031 environment to be given to the program."), &showlist
);
3032 set_cmd_completer (c
, noop_completer
);
3034 add_basic_prefix_cmd ("unset", no_class
,
3035 _("Complement to certain \"set\" commands."),
3036 &unsetlist
, 0, &cmdlist
);
3038 c
= add_cmd ("environment", class_run
, unset_environment_command
, _("\
3039 Cancel environment variable VAR for the program.\n\
3040 This does not affect the program until the next \"run\" command."),
3042 set_cmd_completer (c
, noop_completer
);
3044 c
= add_cmd ("environment", class_run
, set_environment_command
, _("\
3045 Set environment variable value to give the program.\n\
3046 Arguments are VAR VALUE where VAR is variable name and VALUE is value.\n\
3047 VALUES of environment variables are uninterpreted strings.\n\
3048 This does not affect the program until the next \"run\" command."),
3050 set_cmd_completer (c
, noop_completer
);
3052 c
= add_com ("path", class_files
, path_command
, _("\
3053 Add directory DIR(s) to beginning of search path for object files.\n\
3054 $cwd in the path means the current working directory.\n\
3055 This path is equivalent to the $PATH shell variable. It is a list of\n\
3056 directories, separated by colons. These directories are searched to find\n\
3057 fully linked executable files and separately compiled object files as \
3059 set_cmd_completer (c
, filename_completer
);
3061 c
= add_cmd ("paths", no_class
, path_info
, _("\
3062 Current search path for finding object files.\n\
3063 $cwd in the path means the current working directory.\n\
3064 This path is equivalent to the $PATH shell variable. It is a list of\n\
3065 directories, separated by colons. These directories are searched to find\n\
3066 fully linked executable files and separately compiled object files as \
3069 set_cmd_completer (c
, noop_completer
);
3071 add_prefix_cmd ("kill", class_run
, kill_command
,
3072 _("Kill execution of program being debugged."),
3073 &killlist
, 0, &cmdlist
);
3075 add_com ("attach", class_run
, attach_command
, _("\
3076 Attach to a process or file outside of GDB.\n\
3077 This command attaches to another target, of the same type as your last\n\
3078 \"target\" command (\"info files\" will show your target stack).\n\
3079 The command may take as argument a process id or a device file.\n\
3080 For a process id, you must have permission to send the process a signal,\n\
3081 and it must have the same effective uid as the debugger.\n\
3082 When using \"attach\" with a process id, the debugger finds the\n\
3083 program running in the process, looking first in the current working\n\
3084 directory, or (if not found there) using the source file search path\n\
3085 (see the \"directory\" command). You can also use the \"file\" command\n\
3086 to specify the program, and to load its symbol table."));
3088 add_prefix_cmd ("detach", class_run
, detach_command
, _("\
3089 Detach a process or file previously attached.\n\
3090 If a process, it is no longer traced, and it continues its execution. If\n\
3091 you were debugging a file, the file is closed and gdb no longer accesses it."),
3092 &detachlist
, 0, &cmdlist
);
3094 add_com ("disconnect", class_run
, disconnect_command
, _("\
3095 Disconnect from a target.\n\
3096 The target will wait for another debugger to connect. Not available for\n\
3099 c
= add_com ("signal", class_run
, signal_command
, _("\
3100 Continue program with the specified signal.\n\
3101 Usage: signal SIGNAL\n\
3102 The SIGNAL argument is processed the same as the handle command.\n\
3104 An argument of \"0\" means continue the program without sending it a signal.\n\
3105 This is useful in cases where the program stopped because of a signal,\n\
3106 and you want to resume the program while discarding the signal.\n\
3108 In a multi-threaded program the signal is delivered to, or discarded from,\n\
3109 the current thread only."));
3110 set_cmd_completer (c
, signal_completer
);
3112 c
= add_com ("queue-signal", class_run
, queue_signal_command
, _("\
3113 Queue a signal to be delivered to the current thread when it is resumed.\n\
3114 Usage: queue-signal SIGNAL\n\
3115 The SIGNAL argument is processed the same as the handle command.\n\
3116 It is an error if the handling state of SIGNAL is \"nopass\".\n\
3118 An argument of \"0\" means remove any currently queued signal from\n\
3119 the current thread. This is useful in cases where the program stopped\n\
3120 because of a signal, and you want to resume it while discarding the signal.\n\
3122 In a multi-threaded program the signal is queued with, or discarded from,\n\
3123 the current thread only."));
3124 set_cmd_completer (c
, signal_completer
);
3126 cmd_list_element
*stepi_cmd
3127 = add_com ("stepi", class_run
, stepi_command
, _("\
3128 Step one instruction exactly.\n\
3130 Argument N means step N times (or till program stops for another \
3132 add_com_alias ("si", stepi_cmd
, class_run
, 0);
3134 cmd_list_element
*nexti_cmd
3135 = add_com ("nexti", class_run
, nexti_command
, _("\
3136 Step one instruction, but proceed through subroutine calls.\n\
3138 Argument N means step N times (or till program stops for another \
3140 add_com_alias ("ni", nexti_cmd
, class_run
, 0);
3142 cmd_list_element
*finish_cmd
3143 = add_com ("finish", class_run
, finish_command
, _("\
3144 Execute until selected stack frame returns.\n\
3146 Upon return, the value returned is printed and put in the value history."));
3147 add_com_alias ("fin", finish_cmd
, class_run
, 1);
3149 cmd_list_element
*next_cmd
3150 = add_com ("next", class_run
, next_command
, _("\
3151 Step program, proceeding through subroutine calls.\n\
3153 Unlike \"step\", if the current source line calls a subroutine,\n\
3154 this command does not enter the subroutine, but instead steps over\n\
3155 the call, in effect treating it as a single source line."));
3156 add_com_alias ("n", next_cmd
, class_run
, 1);
3158 cmd_list_element
*step_cmd
3159 = add_com ("step", class_run
, step_command
, _("\
3160 Step program until it reaches a different source line.\n\
3162 Argument N means step N times (or till program stops for another \
3164 add_com_alias ("s", step_cmd
, class_run
, 1);
3166 cmd_list_element
*until_cmd
3167 = add_com ("until", class_run
, until_command
, _("\
3168 Execute until past the current line or past a LOCATION.\n\
3169 Execute until the program reaches a source line greater than the current\n\
3170 or a specified location (same args as break command) within the current \
3172 set_cmd_completer (until_cmd
, location_completer
);
3173 add_com_alias ("u", until_cmd
, class_run
, 1);
3175 c
= add_com ("advance", class_run
, advance_command
, _("\
3176 Continue the program up to the given location (same form as args for break \
3178 Execution will also stop upon exit from the current stack frame."));
3179 set_cmd_completer (c
, location_completer
);
3181 cmd_list_element
*jump_cmd
3182 = add_com ("jump", class_run
, jump_command
, _("\
3183 Continue program being debugged at specified line or address.\n\
3184 Usage: jump LOCATION\n\
3185 Give as argument either LINENUM or *ADDR, where ADDR is an expression\n\
3186 for an address to start at."));
3187 set_cmd_completer (jump_cmd
, location_completer
);
3188 add_com_alias ("j", jump_cmd
, class_run
, 1);
3190 cmd_list_element
*continue_cmd
3191 = add_com ("continue", class_run
, continue_command
, _("\
3192 Continue program being debugged, after signal or breakpoint.\n\
3193 Usage: continue [N]\n\
3194 If proceeding from breakpoint, a number N may be used as an argument,\n\
3195 which means to set the ignore count of that breakpoint to N - 1 (so that\n\
3196 the breakpoint won't break until the Nth time it is reached).\n\
3198 If non-stop mode is enabled, continue only the current thread,\n\
3199 otherwise all the threads in the program are continued. To \n\
3200 continue all stopped threads in non-stop mode, use the -a option.\n\
3201 Specifying -a and an ignore count simultaneously is an error."));
3202 add_com_alias ("c", continue_cmd
, class_run
, 1);
3203 add_com_alias ("fg", continue_cmd
, class_run
, 1);
3205 cmd_list_element
*run_cmd
3206 = add_com ("run", class_run
, run_command
, _("\
3207 Start debugged program.\n"
3209 set_cmd_completer (run_cmd
, filename_completer
);
3210 add_com_alias ("r", run_cmd
, class_run
, 1);
3212 c
= add_com ("start", class_run
, start_command
, _("\
3213 Start the debugged program stopping at the beginning of the main procedure.\n"
3215 set_cmd_completer (c
, filename_completer
);
3217 c
= add_com ("starti", class_run
, starti_command
, _("\
3218 Start the debugged program stopping at the first instruction.\n"
3220 set_cmd_completer (c
, filename_completer
);
3222 add_com ("interrupt", class_run
, interrupt_command
,
3223 _("Interrupt the execution of the debugged program.\n\
3224 If non-stop mode is enabled, interrupt only the current thread,\n\
3225 otherwise all the threads in the program are stopped. To \n\
3226 interrupt all running threads in non-stop mode, use the -a option."));
3228 cmd_list_element
*info_registers_cmd
3229 = add_info ("registers", info_registers_command
, _("\
3230 List of integer registers and their contents, for selected stack frame.\n\
3231 One or more register names as argument means describe the given registers.\n\
3232 One or more register group names as argument means describe the registers\n\
3233 in the named register groups."));
3234 add_info_alias ("r", info_registers_cmd
, 1);
3235 set_cmd_completer (info_registers_cmd
, reg_or_group_completer
);
3237 c
= add_info ("all-registers", info_all_registers_command
, _("\
3238 List of all registers and their contents, for selected stack frame.\n\
3239 One or more register names as argument means describe the given registers.\n\
3240 One or more register group names as argument means describe the registers\n\
3241 in the named register groups."));
3242 set_cmd_completer (c
, reg_or_group_completer
);
3244 add_info ("program", info_program_command
,
3245 _("Execution status of the program."));
3247 add_info ("float", info_float_command
,
3248 _("Print the status of the floating point unit."));
3250 add_info ("vector", info_vector_command
,
3251 _("Print the status of the vector unit."));
3253 add_prefix_cmd ("proc", class_info
, info_proc_cmd
,
3255 Show additional information about a process.\n\
3256 Specify any process id, or use the program being debugged by default."),
3258 1/*allow-unknown*/, &infolist
);
3260 add_cmd ("mappings", class_info
, info_proc_cmd_mappings
, _("\
3261 List memory regions mapped by the specified process."),
3262 &info_proc_cmdlist
);
3264 add_cmd ("stat", class_info
, info_proc_cmd_stat
, _("\
3265 List process info from /proc/PID/stat."),
3266 &info_proc_cmdlist
);
3268 add_cmd ("status", class_info
, info_proc_cmd_status
, _("\
3269 List process info from /proc/PID/status."),
3270 &info_proc_cmdlist
);
3272 add_cmd ("cwd", class_info
, info_proc_cmd_cwd
, _("\
3273 List current working directory of the specified process."),
3274 &info_proc_cmdlist
);
3276 add_cmd ("cmdline", class_info
, info_proc_cmd_cmdline
, _("\
3277 List command line arguments of the specified process."),
3278 &info_proc_cmdlist
);
3280 add_cmd ("exe", class_info
, info_proc_cmd_exe
, _("\
3281 List absolute filename for executable of the specified process."),
3282 &info_proc_cmdlist
);
3284 add_cmd ("files", class_info
, info_proc_cmd_files
, _("\
3285 List files opened by the specified process."),
3286 &info_proc_cmdlist
);
3288 add_cmd ("all", class_info
, info_proc_cmd_all
, _("\
3289 List all available info about the specified process."),
3290 &info_proc_cmdlist
);
3292 add_setshow_boolean_cmd ("finish", class_support
,
3293 &user_print_options
.finish_print
, _("\
3294 Set whether `finish' prints the return value."), _("\
3295 Show whether `finish' prints the return value."), NULL
,
3298 &setprintlist
, &showprintlist
);