1 /* Memory-access and commands for "inferior" process, for GDB.
3 Copyright (C) 1986-2024 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/>. */
20 #include "arch-utils.h"
26 #include "gdbsupport/environ.h"
34 #include "completer.h"
37 #include "reggroups.h"
41 #include "observable.h"
42 #include "target-descriptions.h"
43 #include "user-regs.h"
44 #include "gdbthread.h"
46 #include "inline-frame.h"
47 #include "tracepoint.h"
50 #include "thread-fsm.h"
56 #include "cli/cli-style.h"
57 #include "dwarf2/loc.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 /* Pid of our debugged inferior, or 0 if no inferior now.
69 Since various parts of infrun.c test this to see whether there is a program
70 being debugged it should be nonzero (currently 3 is used) for remote
75 /* Nonzero if stopped due to completion of a stack dummy routine. */
77 enum stop_stack_kind stop_stack_dummy
;
79 /* Nonzero if stopped due to a random (unexpected) signal in inferior
82 int stopped_by_random_signal
;
85 /* Whether "finish" should print the value. */
87 static bool finish_print
= true;
91 /* Store the new value passed to 'set inferior-tty'. */
94 set_tty_value (const std::string
&tty
)
96 current_inferior ()->set_tty (tty
);
99 /* Get the current 'inferior-tty' value. */
101 static const std::string
&
104 return current_inferior ()->tty ();
107 /* Implement 'show inferior-tty' command. */
110 show_inferior_tty_command (struct ui_file
*file
, int from_tty
,
111 struct cmd_list_element
*c
, const char *value
)
113 /* Note that we ignore the passed-in value in favor of computing it
115 const std::string
&inferior_tty
= current_inferior ()->tty ();
118 _("Terminal for future runs of program being debugged "
119 "is \"%s\".\n"), inferior_tty
.c_str ());
122 /* Store the new value passed to 'set args'. */
125 set_args_value (const std::string
&args
)
127 current_inferior ()->set_args (args
);
130 /* Return the value for 'show args' to display. */
132 static const std::string
&
135 return current_inferior ()->args ();
138 /* Callback to implement 'show args' command. */
141 show_args_command (struct ui_file
*file
, int from_tty
,
142 struct cmd_list_element
*c
, const char *value
)
144 /* Ignore the passed in value, pull the argument directly from the
145 inferior. However, these should always be the same. */
146 gdb_printf (file
, _("\
147 Argument list to give program being debugged when it is started is \"%s\".\n"),
148 current_inferior ()->args ().c_str ());
151 /* See gdbsupport/common-inferior.h. */
156 return current_inferior ()->cwd ();
159 /* Store the new value passed to 'set cwd'. */
162 set_cwd_value (const std::string
&args
)
164 current_inferior ()->set_cwd (args
);
167 /* Handle the 'show cwd' command. */
170 show_cwd_command (struct ui_file
*file
, int from_tty
,
171 struct cmd_list_element
*c
, const char *value
)
173 const std::string
&cwd
= current_inferior ()->cwd ();
178 You have not set the inferior's current working directory.\n\
179 The inferior will inherit GDB's cwd if native debugging, or the remote\n\
180 server's cwd if remote debugging.\n"));
183 _("Current working directory that will be used "
184 "when starting the inferior is \"%s\".\n"),
189 /* This function strips the '&' character (indicating background
190 execution) that is added as *the last* of the arguments ARGS of a
191 command. A copy of the incoming ARGS without the '&' is returned,
192 unless the resulting string after stripping is empty, in which case
193 NULL is returned. *BG_CHAR_P is an output boolean that indicates
194 whether the '&' character was found. */
196 static gdb::unique_xmalloc_ptr
<char>
197 strip_bg_char (const char *args
, int *bg_char_p
)
201 if (args
== nullptr || *args
== '\0')
207 p
= args
+ strlen (args
);
211 while (p
> args
&& isspace (p
[-1]))
216 return gdb::unique_xmalloc_ptr
<char>
217 (savestring (args
, p
- args
));
219 return gdb::unique_xmalloc_ptr
<char> (nullptr);
223 return make_unique_xstrdup (args
);
226 /* Common actions to take after creating any sort of inferior, by any
227 means (running, attaching, connecting, et cetera). The target
228 should be stopped. */
231 post_create_inferior (int from_tty
)
234 /* Be sure we own the terminal in case write operations are performed. */
235 target_terminal::ours_for_output ();
237 infrun_debug_show_threads ("threads in the newly created inferior",
238 current_inferior ()->non_exited_threads ());
240 /* If the target hasn't taken care of this already, do it now.
241 Targets which need to access registers during to_open,
242 to_create_inferior, or to_attach should do it earlier; but many
244 target_find_description ();
246 /* Now that we know the register layout, retrieve current PC. But
247 if the PC is unavailable (e.g., we're opening a core file with
248 missing registers info), ignore it. */
249 thread_info
*thr
= inferior_thread ();
251 thr
->clear_stop_pc ();
254 regcache
*rc
= get_thread_regcache (thr
);
255 thr
->set_stop_pc (regcache_read_pc (rc
));
257 catch (const gdb_exception_error
&ex
)
259 if (ex
.error
!= NOT_AVAILABLE_ERROR
)
263 if (current_program_space
->exec_bfd ())
265 const unsigned solib_add_generation
266 = current_program_space
->solib_add_generation
;
268 scoped_restore restore_in_initial_library_scan
269 = make_scoped_restore (¤t_inferior ()->in_initial_library_scan
,
272 /* Create the hooks to handle shared library load and unload
274 solib_create_inferior_hook (from_tty
);
276 if (current_program_space
->solib_add_generation
== solib_add_generation
)
278 /* The platform-specific hook should load initial shared libraries,
279 but didn't. FROM_TTY will be incorrectly 0 but such solib
280 targets should be fixed anyway. Call it only after the solib
281 target has been initialized by solib_create_inferior_hook. */
284 warning (_("platform-specific solib_create_inferior_hook did "
285 "not load initial shared libraries."));
287 /* If the solist is global across processes, there's no need to
289 if (!gdbarch_has_global_solist (current_inferior ()->arch ()))
290 solib_add (nullptr, 0, auto_solib_add
);
294 /* If the user sets watchpoints before execution having started,
295 then she gets software watchpoints, because GDB can't know which
296 target will end up being pushed, or if it supports hardware
297 watchpoints or not. breakpoint_re_set takes care of promoting
298 watchpoints to hardware watchpoints if possible, however, if this
299 new inferior doesn't load shared libraries or we don't pull in
300 symbols from any other source on this target/arch,
301 breakpoint_re_set is never called. Call it now so that software
302 watchpoints get a chance to be promoted to hardware watchpoints
303 if the now pushed target supports hardware watchpoints. */
304 breakpoint_re_set ();
306 gdb::observers::inferior_created
.notify (current_inferior ());
309 /* Kill the inferior if already running. This function is designed
310 to be called when we are about to start the execution of the program
311 from the beginning. Ask the user to confirm that he wants to restart
312 the program being debugged when FROM_TTY is non-null. */
315 kill_if_already_running (int from_tty
)
317 if (inferior_ptid
!= null_ptid
&& target_has_execution ())
319 /* Bail out before killing the program if we will not be able to
321 target_require_runnable ();
324 && !query (_("The program being debugged has been started already.\n\
325 Start it from the beginning? ")))
326 error (_("Program not restarted."));
331 /* See inferior.h. */
334 prepare_execution_command (struct target_ops
*target
, int background
)
336 /* If we get a request for running in the bg but the target
337 doesn't support it, error out. */
338 if (background
&& !target_can_async_p (target
))
339 error (_("Asynchronous execution not supported on this target."));
343 /* If we get a request for running in the fg, then we need to
344 simulate synchronous (fg) execution. Note no cleanup is
345 necessary for this. stdin is re-enabled whenever an error
346 reaches the top level. */
347 all_uis_on_sync_execution_starting ();
351 /* Determine how the new inferior will behave. */
355 /* Run program without any explicit stop during startup. */
358 /* Stop at the beginning of the program's main function. */
361 /* Stop at the first instruction of the program. */
362 RUN_STOP_AT_FIRST_INSN
365 /* Implement the "run" command. Force a stop during program start if
366 requested by RUN_HOW. */
369 run_command_1 (const char *args
, int from_tty
, enum run_how run_how
)
371 const char *exec_file
;
372 struct ui_out
*uiout
= current_uiout
;
373 struct target_ops
*run_target
;
378 scoped_disable_commit_resumed
disable_commit_resumed ("running");
380 kill_if_already_running (from_tty
);
382 init_wait_for_inferior ();
383 clear_breakpoint_hit_counts ();
385 /* Clean up any leftovers from other runs. Some other things from
386 this function should probably be moved into target_pre_inferior. */
387 target_pre_inferior (from_tty
);
389 /* The comment here used to read, "The exec file is re-read every
390 time we do a generic_mourn_inferior, so we just have to worry
391 about the symbol file." The `generic_mourn_inferior' function
392 gets called whenever the program exits. However, suppose the
393 program exits, and *then* the executable file changes? We need
394 to check again here. Since reopen_exec_file doesn't do anything
395 if the timestamp hasn't changed, I don't see the harm. */
397 reread_symbols (from_tty
);
399 gdb::unique_xmalloc_ptr
<char> stripped
= strip_bg_char (args
, &async_exec
);
400 args
= stripped
.get ();
402 /* Do validation and preparation before possibly changing anything
405 run_target
= find_run_target ();
407 prepare_execution_command (run_target
, async_exec
);
409 if (non_stop
&& !run_target
->supports_non_stop ())
410 error (_("The target does not support running in non-stop mode."));
412 /* Done. Can now set breakpoints, change inferior args, etc. */
414 /* Insert temporary breakpoint in main function if requested. */
415 if (run_how
== RUN_STOP_AT_MAIN
)
417 /* To avoid other inferiors hitting this breakpoint, make it
418 inferior-specific. */
419 std::string arg
= string_printf ("-qualified %s inferior %d",
421 current_inferior ()->num
);
422 tbreak_command (arg
.c_str (), 0);
425 exec_file
= get_exec_file (0);
427 /* We keep symbols from add-symbol-file, on the grounds that the
428 user might want to add some symbols before running the program
429 (right?). But sometimes (dynamic loading where the user manually
430 introduces the new symbols with add-symbol-file), the code which
431 the symbols describe does not persist between runs. Currently
432 the user has to manually nuke all symbols between runs if they
433 want them to go away (PR 2207). This is probably reasonable. */
435 /* If there were other args, beside '&', process them. */
437 current_inferior ()->set_args (args
);
441 uiout
->field_string (nullptr, "Starting program");
444 uiout
->field_string ("execfile", exec_file
,
445 file_name_style
.style ());
447 uiout
->field_string ("infargs", current_inferior ()->args ());
452 run_target
->create_inferior (exec_file
,
453 current_inferior ()->args (),
454 current_inferior ()->environment
.envp (),
456 /* to_create_inferior should push the target, so after this point we
457 shouldn't refer to run_target again. */
458 run_target
= nullptr;
460 infrun_debug_show_threads ("immediately after create_process",
461 current_inferior ()->non_exited_threads ());
463 /* We're starting off a new process. When we get out of here, in
464 non-stop mode, finish the state of all threads of that process,
465 but leave other threads alone, as they may be stopped in internal
466 events --- the frontend shouldn't see them as stopped. In
467 all-stop, always finish the state of all threads, as we may be
468 resuming more than just the new process. */
469 process_stratum_target
*finish_target
;
473 finish_target
= current_inferior ()->process_target ();
474 finish_ptid
= ptid_t (current_inferior ()->pid
);
478 finish_target
= nullptr;
479 finish_ptid
= minus_one_ptid
;
481 scoped_finish_thread_state
finish_state (finish_target
, finish_ptid
);
483 /* Pass zero for FROM_TTY, because at this point the "run" command
484 has done its thing; now we are setting up the running program. */
485 post_create_inferior (0);
487 /* Queue a pending event so that the program stops immediately. */
488 if (run_how
== RUN_STOP_AT_FIRST_INSN
)
490 thread_info
*thr
= inferior_thread ();
491 target_waitstatus ws
;
492 ws
.set_stopped (GDB_SIGNAL_0
);
493 thr
->set_pending_waitstatus (ws
);
496 /* Start the target running. Do not use -1 continuation as it would skip
497 breakpoint right at the entry point. */
498 proceed (regcache_read_pc (get_thread_regcache (inferior_thread ())),
501 /* Since there was no error, there's no need to finish the thread
503 finish_state
.release ();
505 disable_commit_resumed
.reset_and_commit ();
509 run_command (const char *args
, int from_tty
)
511 run_command_1 (args
, from_tty
, RUN_NORMAL
);
514 /* Start the execution of the program up until the beginning of the main
518 start_command (const char *args
, int from_tty
)
520 /* Some languages such as Ada need to search inside the program
521 minimal symbols for the location where to put the temporary
522 breakpoint before starting. */
523 if (!have_minimal_symbols ())
524 error (_("No symbol table loaded. Use the \"file\" command."));
526 /* Run the program until reaching the main procedure... */
527 run_command_1 (args
, from_tty
, RUN_STOP_AT_MAIN
);
530 /* Start the execution of the program stopping at the first
534 starti_command (const char *args
, int from_tty
)
536 run_command_1 (args
, from_tty
, RUN_STOP_AT_FIRST_INSN
);
540 proceed_thread_callback (struct thread_info
*thread
, void *arg
)
542 /* We go through all threads individually instead of compressing
543 into a single target `resume_all' request, because some threads
544 may be stopped in internal breakpoints/events, or stopped waiting
545 for its turn in the displaced stepping queue (that is, they are
546 running && !executing). The target side has no idea about why
547 the thread is stopped, so a `resume_all' command would resume too
548 much. If/when GDB gains a way to tell the target `hold this
549 thread stopped until I say otherwise', then we can optimize
551 if (thread
->state
!= THREAD_STOPPED
)
554 if (!thread
->inf
->has_execution ())
557 switch_to_thread (thread
);
558 clear_proceed_status (0);
559 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
);
564 ensure_valid_thread (void)
566 if (inferior_ptid
== null_ptid
567 || inferior_thread ()->state
== THREAD_EXITED
)
568 error (_("Cannot execute this command without a live selected thread."));
571 /* If the user is looking at trace frames, any resumption of execution
572 is likely to mix up recorded and live target data. So simply
573 disallow those commands. */
576 ensure_not_tfind_mode (void)
578 if (get_traceframe_number () >= 0)
579 error (_("Cannot execute this command while looking at trace frames."));
582 /* Throw an error indicating the current thread is running. */
585 error_is_running (void)
587 error (_("Cannot execute this command while "
588 "the selected thread is running."));
591 /* Calls error_is_running if the current thread is running. */
594 ensure_not_running (void)
596 if (inferior_thread ()->state
== THREAD_RUNNING
)
601 continue_1 (int all_threads
)
604 ensure_not_tfind_mode ();
606 if (non_stop
&& all_threads
)
608 /* Don't error out if the current thread is running, because
609 there may be other stopped threads. */
611 /* Backup current thread and selected frame and restore on scope
613 scoped_restore_current_thread restore_thread
;
614 scoped_disable_commit_resumed disable_commit_resumed
615 ("continue all threads in non-stop");
617 iterate_over_threads (proceed_thread_callback
, nullptr);
619 if (current_ui
->prompt_state
== PROMPT_BLOCKED
)
621 /* If all threads in the target were already running,
622 proceed_thread_callback ends up never calling proceed,
623 and so nothing calls this to put the inferior's terminal
624 settings in effect and remove stdin from the event loop,
625 which we must when running a foreground command. E.g.:
629 <all threads are running now>
632 <no thread was resumed, but the inferior now owns the terminal>
634 target_terminal::inferior ();
637 disable_commit_resumed
.reset_and_commit ();
641 ensure_valid_thread ();
642 ensure_not_running ();
643 clear_proceed_status (0);
644 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
);
648 /* continue [-a] [proceed-count] [&] */
651 continue_command (const char *args
, int from_tty
)
654 bool all_threads_p
= false;
658 /* Find out whether we must run in the background. */
659 gdb::unique_xmalloc_ptr
<char> stripped
= strip_bg_char (args
, &async_exec
);
660 args
= stripped
.get ();
664 if (startswith (args
, "-a"))
666 all_threads_p
= true;
667 args
+= sizeof ("-a") - 1;
673 if (!non_stop
&& all_threads_p
)
674 error (_("`-a' is meaningless in all-stop mode."));
676 if (args
!= nullptr && all_threads_p
)
677 error (_("Can't resume all threads and specify "
678 "proceed count simultaneously."));
680 /* If we have an argument left, set proceed count of breakpoint we
684 bpstat
*bs
= nullptr;
687 struct thread_info
*tp
;
690 tp
= inferior_thread ();
693 process_stratum_target
*last_target
;
696 get_last_target_status (&last_target
, &last_ptid
, nullptr);
697 tp
= last_target
->find_thread (last_ptid
);
700 bs
= tp
->control
.stop_bpstat
;
702 while ((stat
= bpstat_num (&bs
, &num
)) != 0)
705 set_ignore_count (num
,
706 parse_and_eval_long (args
) - 1,
708 /* set_ignore_count prints a message ending with a period.
709 So print two spaces before "Continuing.". */
715 if (!stopped
&& from_tty
)
718 ("Not stopped at any breakpoint; argument ignored.\n");
722 ensure_not_tfind_mode ();
724 if (!non_stop
|| !all_threads_p
)
726 ensure_valid_thread ();
727 ensure_not_running ();
730 prepare_execution_command (current_inferior ()->top_target (), async_exec
);
733 gdb_printf (_("Continuing.\n"));
735 continue_1 (all_threads_p
);
738 /* Record in TP the starting point of a "step" or "next" command. */
741 set_step_frame (thread_info
*tp
)
743 /* This can be removed once this function no longer implicitly relies on the
744 inferior_ptid value. */
745 gdb_assert (inferior_ptid
== tp
->ptid
);
747 frame_info_ptr frame
= get_current_frame ();
749 symtab_and_line sal
= find_frame_sal (frame
);
750 set_step_info (tp
, frame
, sal
);
752 CORE_ADDR pc
= get_frame_pc (frame
);
753 tp
->control
.step_start_function
= find_pc_function (pc
);
756 /* Step until outside of current statement. */
759 step_command (const char *count_string
, int from_tty
)
761 step_1 (0, 0, count_string
);
764 /* Likewise, but skip over subroutine calls as if single instructions. */
767 next_command (const char *count_string
, int from_tty
)
769 step_1 (1, 0, count_string
);
772 /* Likewise, but step only one instruction. */
775 stepi_command (const char *count_string
, int from_tty
)
777 step_1 (0, 1, count_string
);
781 nexti_command (const char *count_string
, int from_tty
)
783 step_1 (1, 1, count_string
);
786 /* Data for the FSM that manages the step/next/stepi/nexti
789 struct step_command_fsm
: public thread_fsm
791 /* How many steps left in a "step N"-like command. */
794 /* If true, this is a next/nexti, otherwise a step/stepi. */
795 int skip_subroutines
;
797 /* If true, this is a stepi/nexti, otherwise a step/step. */
800 explicit step_command_fsm (struct interp
*cmd_interp
)
801 : thread_fsm (cmd_interp
)
805 void clean_up (struct thread_info
*thread
) override
;
806 bool should_stop (struct thread_info
*thread
) override
;
807 enum async_reply_reason
do_async_reply_reason () override
;
810 /* Prepare for a step/next/etc. command. Any target resource
811 allocated here is undone in the FSM's clean_up method. */
814 step_command_fsm_prepare (struct step_command_fsm
*sm
,
815 int skip_subroutines
, int single_inst
,
816 int count
, struct thread_info
*thread
)
818 sm
->skip_subroutines
= skip_subroutines
;
819 sm
->single_inst
= single_inst
;
822 /* Leave the si command alone. */
823 if (!sm
->single_inst
|| sm
->skip_subroutines
)
824 set_longjmp_breakpoint (thread
, get_frame_id (get_current_frame ()));
826 thread
->control
.stepping_command
= 1;
829 static int prepare_one_step (thread_info
*, struct step_command_fsm
*sm
);
832 step_1 (int skip_subroutines
, int single_inst
, const char *count_string
)
836 struct thread_info
*thr
;
837 struct step_command_fsm
*step_sm
;
840 ensure_not_tfind_mode ();
841 ensure_valid_thread ();
842 ensure_not_running ();
844 gdb::unique_xmalloc_ptr
<char> stripped
845 = strip_bg_char (count_string
, &async_exec
);
846 count_string
= stripped
.get ();
848 prepare_execution_command (current_inferior ()->top_target (), async_exec
);
850 count
= count_string
? parse_and_eval_long (count_string
) : 1;
852 clear_proceed_status (1);
854 /* Setup the execution command state machine to handle all the COUNT
856 thr
= inferior_thread ();
857 step_sm
= new step_command_fsm (command_interp ());
858 thr
->set_thread_fsm (std::unique_ptr
<thread_fsm
> (step_sm
));
860 step_command_fsm_prepare (step_sm
, skip_subroutines
,
861 single_inst
, count
, thr
);
863 /* Do only one step for now, before returning control to the event
864 loop. Let the continuation figure out how many other steps we
865 need to do, and handle them one at the time, through
867 if (!prepare_one_step (thr
, step_sm
))
868 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
);
871 /* Stepped into an inline frame. Pretend that we've
873 thr
->thread_fsm ()->clean_up (thr
);
874 bool proceeded
= normal_stop ();
876 inferior_event_handler (INF_EXEC_COMPLETE
);
877 all_uis_check_sync_execution_done ();
881 /* Implementation of the 'should_stop' FSM method for stepping
882 commands. Called after we are done with one step operation, to
883 check whether we need to step again, before we print the prompt and
884 return control to the user. If count is > 1, returns false, as we
885 will need to keep going. */
888 step_command_fsm::should_stop (struct thread_info
*tp
)
890 if (tp
->control
.stop_step
)
892 /* There are more steps to make, and we did stop due to
893 ending a stepping range. Do another step. */
895 return prepare_one_step (tp
, this);
903 /* Implementation of the 'clean_up' FSM method for stepping commands. */
906 step_command_fsm::clean_up (struct thread_info
*thread
)
908 if (!single_inst
|| skip_subroutines
)
909 delete_longjmp_breakpoint (thread
->global_num
);
912 /* Implementation of the 'async_reply_reason' FSM method for stepping
915 enum async_reply_reason
916 step_command_fsm::do_async_reply_reason ()
918 return EXEC_ASYNC_END_STEPPING_RANGE
;
921 /* Prepare for one step in "step N". The actual target resumption is
922 done by the caller. Return true if we're done and should thus
923 report a stop to the user. Returns false if the target needs to be
927 prepare_one_step (thread_info
*tp
, struct step_command_fsm
*sm
)
929 /* This can be removed once this function no longer implicitly relies on the
930 inferior_ptid value. */
931 gdb_assert (inferior_ptid
== tp
->ptid
);
935 frame_info_ptr frame
= get_current_frame ();
939 if (!sm
->single_inst
)
943 /* Step at an inlined function behaves like "down". */
944 if (!sm
->skip_subroutines
945 && inline_skipped_frames (tp
))
948 const char *fn
= nullptr;
952 /* Pretend that we've ran. */
953 resume_ptid
= user_visible_resume_ptid (1);
954 set_running (tp
->inf
->process_target (), resume_ptid
, true);
956 step_into_inline_frame (tp
);
958 frame
= get_current_frame ();
959 sal
= find_frame_sal (frame
);
960 sym
= get_frame_function (frame
);
963 fn
= sym
->print_name ();
966 || !function_name_is_marked_for_skip (fn
, sal
))
969 return prepare_one_step (tp
, sm
);
973 pc
= get_frame_pc (frame
);
974 find_pc_line_pc_range (pc
,
975 &tp
->control
.step_range_start
,
976 &tp
->control
.step_range_end
);
978 if (execution_direction
== EXEC_REVERSE
)
980 symtab_and_line sal
= find_pc_line (pc
, 0);
981 symtab_and_line sal_start
982 = find_pc_line (tp
->control
.step_range_start
, 0);
984 if (sal
.line
== sal_start
.line
)
985 /* Executing in reverse, the step_range_start address is in
986 the same line. We want to stop in the previous line so
987 move step_range_start before the current line. */
988 tp
->control
.step_range_start
--;
991 /* There's a problem in gcc (PR gcc/98780) that causes missing line
992 table entries, which results in a too large stepping range.
993 Use inlined_subroutine info to make the range more narrow. */
994 if (inline_skipped_frames (tp
) > 0)
996 symbol
*sym
= inline_skipped_symbol (tp
);
997 if (sym
->aclass () == LOC_BLOCK
)
999 const block
*block
= sym
->value_block ();
1000 if (block
->end () < tp
->control
.step_range_end
)
1001 tp
->control
.step_range_end
= block
->end ();
1005 tp
->control
.may_range_step
= 1;
1007 /* If we have no line info, switch to stepi mode. */
1008 if (tp
->control
.step_range_end
== 0 && step_stop_if_no_debug
)
1010 tp
->control
.step_range_start
= tp
->control
.step_range_end
= 1;
1011 tp
->control
.may_range_step
= 0;
1013 else if (tp
->control
.step_range_end
== 0)
1017 if (find_pc_partial_function (pc
, &name
,
1018 &tp
->control
.step_range_start
,
1019 &tp
->control
.step_range_end
) == 0)
1020 error (_("Cannot find bounds of current function"));
1022 target_terminal::ours_for_output ();
1023 gdb_printf (_("Single stepping until exit from function %s,"
1024 "\nwhich has no line number information.\n"),
1030 /* Say we are stepping, but stop after one insn whatever it does. */
1031 tp
->control
.step_range_start
= tp
->control
.step_range_end
= 1;
1032 if (!sm
->skip_subroutines
)
1034 Don't step over function calls, not even to functions lacking
1036 tp
->control
.step_over_calls
= STEP_OVER_NONE
;
1039 if (sm
->skip_subroutines
)
1040 tp
->control
.step_over_calls
= STEP_OVER_ALL
;
1046 sm
->set_finished ();
1051 /* Continue program at specified address. */
1054 jump_command (const char *arg
, int from_tty
)
1056 struct gdbarch
*gdbarch
= get_current_arch ();
1063 ensure_not_tfind_mode ();
1064 ensure_valid_thread ();
1065 ensure_not_running ();
1067 /* Find out whether we must run in the background. */
1068 gdb::unique_xmalloc_ptr
<char> stripped
= strip_bg_char (arg
, &async_exec
);
1069 arg
= stripped
.get ();
1071 prepare_execution_command (current_inferior ()->top_target (), async_exec
);
1074 error_no_arg (_("starting address"));
1076 std::vector
<symtab_and_line
> sals
1077 = decode_line_with_current_source (arg
, DECODE_LINE_FUNFIRSTLINE
);
1078 if (sals
.size () != 1)
1080 /* If multiple sal-objects were found, try dropping those that aren't
1081 from the current symtab. */
1082 struct symtab_and_line cursal
= get_current_source_symtab_and_line ();
1083 sals
.erase (std::remove_if (sals
.begin (), sals
.end (),
1084 [&] (const symtab_and_line
&sal
)
1086 return sal
.symtab
!= cursal
.symtab
;
1088 if (sals
.size () != 1)
1089 error (_("Jump request is ambiguous: "
1090 "does not resolve to a single address"));
1093 symtab_and_line
&sal
= sals
[0];
1095 if (sal
.symtab
== 0 && sal
.pc
== 0)
1096 error (_("No source file has been specified."));
1098 resolve_sal_pc (&sal
); /* May error out. */
1100 /* See if we are trying to jump to another function. */
1101 fn
= get_frame_function (get_current_frame ());
1102 sfn
= find_pc_sect_containing_function (sal
.pc
,
1103 find_pc_mapped_section (sal
.pc
));
1104 if (fn
!= nullptr && sfn
!= fn
)
1106 if (!query (_("Line %d is not in `%s'. Jump anyway? "), sal
.line
,
1109 error (_("Not confirmed."));
1116 struct obj_section
*section
;
1118 section
= sfn
->obj_section (sfn
->objfile ());
1119 if (section_is_overlay (section
)
1120 && !section_is_mapped (section
))
1122 if (!query (_("WARNING!!! Destination is in "
1123 "unmapped overlay! Jump anyway? ")))
1125 error (_("Not confirmed."));
1135 gdb_printf (_("Continuing at "));
1136 gdb_puts (paddress (gdbarch
, addr
));
1140 clear_proceed_status (0);
1141 proceed (addr
, GDB_SIGNAL_0
);
1144 /* Continue program giving it specified signal. */
1147 signal_command (const char *signum_exp
, int from_tty
)
1149 enum gdb_signal oursig
;
1152 dont_repeat (); /* Too dangerous. */
1154 ensure_not_tfind_mode ();
1155 ensure_valid_thread ();
1156 ensure_not_running ();
1158 /* Find out whether we must run in the background. */
1159 gdb::unique_xmalloc_ptr
<char> stripped
1160 = strip_bg_char (signum_exp
, &async_exec
);
1161 signum_exp
= stripped
.get ();
1163 prepare_execution_command (current_inferior ()->top_target (), async_exec
);
1166 error_no_arg (_("signal number"));
1168 /* It would be even slicker to make signal names be valid expressions,
1169 (the type could be "enum $signal" or some such), then the user could
1170 assign them to convenience variables. */
1171 oursig
= gdb_signal_from_name (signum_exp
);
1173 if (oursig
== GDB_SIGNAL_UNKNOWN
)
1175 /* No, try numeric. */
1176 int num
= parse_and_eval_long (signum_exp
);
1179 oursig
= GDB_SIGNAL_0
;
1181 oursig
= gdb_signal_from_command (num
);
1184 /* Look for threads other than the current that this command ends up
1185 resuming too (due to schedlock off), and warn if they'll get a
1186 signal delivered. "signal 0" is used to suppress a previous
1187 signal, but if the current thread is no longer the one that got
1188 the signal, then the user is potentially suppressing the signal
1189 of the wrong thread. */
1192 int must_confirm
= 0;
1194 /* This indicates what will be resumed. Either a single thread,
1195 a whole process, or all threads of all processes. */
1196 ptid_t resume_ptid
= user_visible_resume_ptid (0);
1197 process_stratum_target
*resume_target
1198 = user_visible_resume_target (resume_ptid
);
1200 thread_info
*current
= inferior_thread ();
1202 for (thread_info
*tp
: all_non_exited_threads (resume_target
, resume_ptid
))
1207 if (tp
->stop_signal () != GDB_SIGNAL_0
1208 && signal_pass_state (tp
->stop_signal ()))
1211 gdb_printf (_("Note:\n"));
1212 gdb_printf (_(" Thread %s previously stopped with signal %s, %s.\n"),
1213 print_thread_id (tp
),
1214 gdb_signal_to_name (tp
->stop_signal ()),
1215 gdb_signal_to_string (tp
->stop_signal ()));
1221 && !query (_("Continuing thread %s (the current thread) with specified signal will\n"
1222 "still deliver the signals noted above to their respective threads.\n"
1223 "Continue anyway? "),
1224 print_thread_id (inferior_thread ())))
1225 error (_("Not confirmed."));
1230 if (oursig
== GDB_SIGNAL_0
)
1231 gdb_printf (_("Continuing with no signal.\n"));
1233 gdb_printf (_("Continuing with signal %s.\n"),
1234 gdb_signal_to_name (oursig
));
1237 clear_proceed_status (0);
1238 proceed ((CORE_ADDR
) -1, oursig
);
1241 /* Queue a signal to be delivered to the current thread. */
1244 queue_signal_command (const char *signum_exp
, int from_tty
)
1246 enum gdb_signal oursig
;
1247 struct thread_info
*tp
;
1250 ensure_not_tfind_mode ();
1251 ensure_valid_thread ();
1252 ensure_not_running ();
1254 if (signum_exp
== nullptr)
1255 error_no_arg (_("signal number"));
1257 /* It would be even slicker to make signal names be valid expressions,
1258 (the type could be "enum $signal" or some such), then the user could
1259 assign them to convenience variables. */
1260 oursig
= gdb_signal_from_name (signum_exp
);
1262 if (oursig
== GDB_SIGNAL_UNKNOWN
)
1264 /* No, try numeric. */
1265 int num
= parse_and_eval_long (signum_exp
);
1268 oursig
= GDB_SIGNAL_0
;
1270 oursig
= gdb_signal_from_command (num
);
1273 if (oursig
!= GDB_SIGNAL_0
1274 && !signal_pass_state (oursig
))
1275 error (_("Signal handling set to not pass this signal to the program."));
1277 tp
= inferior_thread ();
1278 tp
->set_stop_signal (oursig
);
1281 /* Data for the FSM that manages the until (with no argument)
1284 struct until_next_fsm
: public thread_fsm
1286 /* The thread that as current when the command was executed. */
1289 until_next_fsm (struct interp
*cmd_interp
, int thread
)
1290 : thread_fsm (cmd_interp
),
1295 bool should_stop (struct thread_info
*thread
) override
;
1296 void clean_up (struct thread_info
*thread
) override
;
1297 enum async_reply_reason
do_async_reply_reason () override
;
1300 /* Implementation of the 'should_stop' FSM method for the until (with
1304 until_next_fsm::should_stop (struct thread_info
*tp
)
1306 if (tp
->control
.stop_step
)
1312 /* Implementation of the 'clean_up' FSM method for the until (with no
1316 until_next_fsm::clean_up (struct thread_info
*thread
)
1318 delete_longjmp_breakpoint (thread
->global_num
);
1321 /* Implementation of the 'async_reply_reason' FSM method for the until
1322 (with no arg) command. */
1324 enum async_reply_reason
1325 until_next_fsm::do_async_reply_reason ()
1327 return EXEC_ASYNC_END_STEPPING_RANGE
;
1330 /* Proceed until we reach a different source line with pc greater than
1331 our current one or exit the function. We skip calls in both cases.
1333 Note that eventually this command should probably be changed so
1334 that only source lines are printed out when we hit the breakpoint
1335 we set. This may involve changes to wait_for_inferior and the
1336 proceed status code. */
1339 until_next_command (int from_tty
)
1341 frame_info_ptr frame
;
1343 struct symbol
*func
;
1344 struct symtab_and_line sal
;
1345 struct thread_info
*tp
= inferior_thread ();
1346 int thread
= tp
->global_num
;
1347 struct until_next_fsm
*sm
;
1349 clear_proceed_status (0);
1350 set_step_frame (tp
);
1352 frame
= get_current_frame ();
1354 /* Step until either exited from this function or greater
1355 than the current line (if in symbolic section) or pc (if
1358 pc
= get_frame_pc (frame
);
1359 func
= find_pc_function (pc
);
1363 struct bound_minimal_symbol msymbol
= lookup_minimal_symbol_by_pc (pc
);
1365 if (msymbol
.minsym
== nullptr)
1366 error (_("Execution is not within a known function."));
1368 tp
->control
.step_range_start
= msymbol
.value_address ();
1369 /* The upper-bound of step_range is exclusive. In order to make PC
1370 within the range, set the step_range_end with PC + 1. */
1371 tp
->control
.step_range_end
= pc
+ 1;
1375 sal
= find_pc_line (pc
, 0);
1377 tp
->control
.step_range_start
= func
->value_block ()->entry_pc ();
1378 tp
->control
.step_range_end
= sal
.end
;
1380 tp
->control
.may_range_step
= 1;
1382 tp
->control
.step_over_calls
= STEP_OVER_ALL
;
1384 set_longjmp_breakpoint (tp
, get_frame_id (frame
));
1385 delete_longjmp_breakpoint_cleanup
lj_deleter (thread
);
1387 sm
= new until_next_fsm (command_interp (), tp
->global_num
);
1388 tp
->set_thread_fsm (std::unique_ptr
<thread_fsm
> (sm
));
1389 lj_deleter
.release ();
1391 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
);
1395 until_command (const char *arg
, int from_tty
)
1400 ensure_not_tfind_mode ();
1401 ensure_valid_thread ();
1402 ensure_not_running ();
1404 /* Find out whether we must run in the background. */
1405 gdb::unique_xmalloc_ptr
<char> stripped
= strip_bg_char (arg
, &async_exec
);
1406 arg
= stripped
.get ();
1408 prepare_execution_command (current_inferior ()->top_target (), async_exec
);
1411 until_break_command (arg
, from_tty
, 0);
1413 until_next_command (from_tty
);
1417 advance_command (const char *arg
, int from_tty
)
1422 ensure_not_tfind_mode ();
1423 ensure_valid_thread ();
1424 ensure_not_running ();
1427 error_no_arg (_("a location"));
1429 /* Find out whether we must run in the background. */
1430 gdb::unique_xmalloc_ptr
<char> stripped
= strip_bg_char (arg
, &async_exec
);
1431 arg
= stripped
.get ();
1433 prepare_execution_command (current_inferior ()->top_target (), async_exec
);
1435 until_break_command (arg
, from_tty
, 1);
1438 /* See inferior.h. */
1441 get_return_value (struct symbol
*func_symbol
, struct value
*function
)
1443 regcache
*stop_regs
= get_thread_regcache (inferior_thread ());
1444 struct gdbarch
*gdbarch
= stop_regs
->arch ();
1445 struct value
*value
;
1447 struct type
*value_type
1448 = check_typedef (func_symbol
->type ()->target_type ());
1449 gdb_assert (value_type
->code () != TYPE_CODE_VOID
);
1451 if (is_nocall_function (check_typedef (function
->type ())))
1453 warning (_("Function '%s' does not follow the target calling "
1454 "convention, cannot determine its returned value."),
1455 func_symbol
->print_name ());
1460 /* FIXME: 2003-09-27: When returning from a nested inferior function
1461 call, it's possible (with no help from the architecture vector)
1462 to locate and return/print a "struct return" value. This is just
1463 a more complicated case of what is already being done in the
1464 inferior function call code. In fact, when inferior function
1465 calls are made async, this will likely be made the norm. */
1467 switch (gdbarch_return_value_as_value (gdbarch
, function
, value_type
,
1468 nullptr, nullptr, nullptr))
1470 case RETURN_VALUE_REGISTER_CONVENTION
:
1471 case RETURN_VALUE_ABI_RETURNS_ADDRESS
:
1472 case RETURN_VALUE_ABI_PRESERVES_ADDRESS
:
1473 gdbarch_return_value_as_value (gdbarch
, function
, value_type
, stop_regs
,
1476 case RETURN_VALUE_STRUCT_CONVENTION
:
1480 internal_error (_("bad switch"));
1486 /* Helper for print_return_value. */
1489 print_return_value_1 (struct ui_out
*uiout
, struct return_value_info
*rv
)
1491 if (rv
->value
!= nullptr)
1494 uiout
->text ("Value returned is ");
1495 uiout
->field_fmt ("gdb-result-var", "$%d",
1496 rv
->value_history_index
);
1497 uiout
->text (" = ");
1501 struct value_print_options opts
;
1502 get_user_print_options (&opts
);
1505 value_print (rv
->value
, &stb
, &opts
);
1506 uiout
->field_stream ("return-value", stb
);
1509 uiout
->field_string ("return-value", _("<not displayed>"),
1510 metadata_style
.style ());
1515 std::string type_name
= type_to_string (rv
->type
);
1516 uiout
->text ("Value returned has type: ");
1517 uiout
->field_string ("return-type", type_name
);
1519 uiout
->text (" Cannot determine contents\n");
1523 /* Print the result of a function at the end of a 'finish' command.
1524 RV points at an object representing the captured return value/type
1525 and its position in the value history. */
1528 print_return_value (struct ui_out
*uiout
, struct return_value_info
*rv
)
1530 if (rv
->type
== nullptr
1531 || check_typedef (rv
->type
)->code () == TYPE_CODE_VOID
)
1536 /* print_return_value_1 can throw an exception in some
1537 circumstances. We need to catch this so that we still
1538 delete the breakpoint. */
1539 print_return_value_1 (uiout
, rv
);
1541 catch (const gdb_exception_error
&ex
)
1543 exception_print (gdb_stdout
, ex
);
1547 /* Data for the FSM that manages the finish command. */
1549 struct finish_command_fsm
: public thread_fsm
1551 /* The momentary breakpoint set at the function's return address in
1553 breakpoint_up breakpoint
;
1555 /* The function that we're stepping out of. */
1556 struct symbol
*function
= nullptr;
1558 /* If the FSM finishes successfully, this stores the function's
1560 struct return_value_info return_value_info
{};
1562 /* If the current function uses the "struct return convention",
1563 this holds the address at which the value being returned will
1564 be stored, or zero if that address could not be determined or
1565 the "struct return convention" is not being used. */
1566 CORE_ADDR return_buf
;
1568 explicit finish_command_fsm (struct interp
*cmd_interp
)
1569 : thread_fsm (cmd_interp
)
1573 bool should_stop (struct thread_info
*thread
) override
;
1574 void clean_up (struct thread_info
*thread
) override
;
1575 struct return_value_info
*return_value () override
;
1576 enum async_reply_reason
do_async_reply_reason () override
;
1579 /* Implementation of the 'should_stop' FSM method for the finish
1580 commands. Detects whether the thread stepped out of the function
1581 successfully, and if so, captures the function's return value and
1582 marks the FSM finished. */
1585 finish_command_fsm::should_stop (struct thread_info
*tp
)
1587 struct return_value_info
*rv
= &return_value_info
;
1589 if (function
!= nullptr
1590 && bpstat_find_breakpoint (tp
->control
.stop_bpstat
,
1591 breakpoint
.get ()) != nullptr)
1596 rv
->type
= function
->type ()->target_type ();
1597 if (rv
->type
== nullptr)
1598 internal_error (_("finish_command: function has no target type"));
1600 if (check_typedef (rv
->type
)->code () != TYPE_CODE_VOID
)
1604 func
= read_var_value (function
, nullptr, get_current_frame ());
1606 if (return_buf
!= 0)
1607 /* Retrieve return value from the buffer where it was saved. */
1608 rv
->value
= value_at (rv
->type
, return_buf
);
1610 rv
->value
= get_return_value (function
, func
);
1612 if (rv
->value
!= nullptr)
1613 rv
->value_history_index
= rv
->value
->record_latest ();
1616 else if (tp
->control
.stop_step
)
1618 /* Finishing from an inline frame, or reverse finishing. In
1619 either case, there's no way to retrieve the return value. */
1626 /* Implementation of the 'clean_up' FSM method for the finish
1630 finish_command_fsm::clean_up (struct thread_info
*thread
)
1632 breakpoint
.reset ();
1633 delete_longjmp_breakpoint (thread
->global_num
);
1636 /* Implementation of the 'return_value' FSM method for the finish
1639 struct return_value_info
*
1640 finish_command_fsm::return_value ()
1642 return &return_value_info
;
1645 /* Implementation of the 'async_reply_reason' FSM method for the
1648 enum async_reply_reason
1649 finish_command_fsm::do_async_reply_reason ()
1651 if (execution_direction
== EXEC_REVERSE
)
1652 return EXEC_ASYNC_END_STEPPING_RANGE
;
1654 return EXEC_ASYNC_FUNCTION_FINISHED
;
1657 /* finish_backward -- helper function for finish_command. */
1660 finish_backward (struct finish_command_fsm
*sm
)
1662 struct symtab_and_line sal
;
1663 struct thread_info
*tp
= inferior_thread ();
1665 CORE_ADDR func_addr
;
1666 CORE_ADDR alt_entry_point
;
1667 CORE_ADDR entry_point
;
1668 frame_info_ptr frame
= get_selected_frame (nullptr);
1669 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1671 pc
= get_frame_pc (get_current_frame ());
1673 if (find_pc_partial_function (pc
, nullptr, &func_addr
, nullptr) == 0)
1674 error (_("Cannot find bounds of current function"));
1676 sal
= find_pc_line (func_addr
, 0);
1677 alt_entry_point
= sal
.pc
;
1678 entry_point
= alt_entry_point
;
1680 if (gdbarch_skip_entrypoint_p (gdbarch
))
1681 /* Some architectures, like PowerPC use local and global entry points.
1682 There is only one Entry Point (GEP = LEP) for other architectures.
1683 The GEP is an alternate entry point. The LEP is the normal entry point.
1684 The value of entry_point was initialized to the alternate entry point
1685 (GEP). It will be adjusted to the normal entry point if the function
1686 has two entry points. */
1687 entry_point
= gdbarch_skip_entrypoint (gdbarch
, sal
.pc
);
1689 tp
->control
.proceed_to_finish
= 1;
1690 /* Special case: if we're sitting at the function entry point,
1691 then all we need to do is take a reverse singlestep. We
1692 don't need to set a breakpoint, and indeed it would do us
1695 Note that this can only happen at frame #0, since there's
1696 no way that a function up the stack can have a return address
1697 that's equal to its entry point. */
1699 if ((pc
< alt_entry_point
) || (pc
> entry_point
))
1701 /* We are in the body of the function. Set a breakpoint to go back to
1702 the normal entry point. */
1703 symtab_and_line sr_sal
;
1704 sr_sal
.pc
= entry_point
;
1705 sr_sal
.pspace
= get_frame_program_space (frame
);
1706 insert_step_resume_breakpoint_at_sal (gdbarch
,
1707 sr_sal
, null_frame_id
);
1709 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
);
1713 /* We are either at one of the entry points or between the entry points.
1714 If we are not at the alt_entry point, go back to the alt_entry_point
1715 If we at the normal entry point step back one instruction, when we
1716 stop we will determine if we entered via the entry point or the
1717 alternate entry point. If we are at the alternate entry point,
1718 single step back to the function call. */
1719 tp
->control
.step_range_start
= tp
->control
.step_range_end
= 1;
1720 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
);
1724 /* finish_forward -- helper function for finish_command. FRAME is the
1725 frame that called the function we're about to step out of. */
1728 finish_forward (struct finish_command_fsm
*sm
, const frame_info_ptr
&frame
)
1730 struct frame_id frame_id
= get_frame_id (frame
);
1731 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1732 struct symtab_and_line sal
;
1733 struct thread_info
*tp
= inferior_thread ();
1735 sal
= find_pc_line (get_frame_pc (frame
), 0);
1736 sal
.pc
= get_frame_pc (frame
);
1738 sm
->breakpoint
= set_momentary_breakpoint (gdbarch
, sal
,
1739 get_stack_frame_id (frame
),
1742 set_longjmp_breakpoint (tp
, frame_id
);
1744 /* We want to print return value, please... */
1745 tp
->control
.proceed_to_finish
= 1;
1747 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
);
1750 /* Skip frames for "finish". */
1752 static frame_info_ptr
1753 skip_finish_frames (const frame_info_ptr
&initial_frame
)
1755 frame_info_ptr start
;
1756 frame_info_ptr frame
= initial_frame
;
1762 frame
= skip_tailcall_frames (frame
);
1763 if (frame
== nullptr)
1766 frame
= skip_unwritable_frames (frame
);
1767 if (frame
== nullptr)
1770 while (start
!= frame
);
1775 /* "finish": Set a temporary breakpoint at the place the selected
1776 frame will return to, then continue. */
1779 finish_command (const char *arg
, int from_tty
)
1781 frame_info_ptr frame
;
1783 struct finish_command_fsm
*sm
;
1784 struct thread_info
*tp
;
1787 ensure_not_tfind_mode ();
1788 ensure_valid_thread ();
1789 ensure_not_running ();
1791 /* Find out whether we must run in the background. */
1792 gdb::unique_xmalloc_ptr
<char> stripped
= strip_bg_char (arg
, &async_exec
);
1793 arg
= stripped
.get ();
1795 prepare_execution_command (current_inferior ()->top_target (), async_exec
);
1798 error (_("The \"finish\" command does not take any arguments."));
1800 frame
= get_prev_frame (get_selected_frame (_("No selected frame.")));
1802 error (_("\"finish\" not meaningful in the outermost frame."));
1804 clear_proceed_status (0);
1806 tp
= inferior_thread ();
1808 sm
= new finish_command_fsm (command_interp ());
1810 tp
->set_thread_fsm (std::unique_ptr
<thread_fsm
> (sm
));
1812 /* Finishing from an inline frame is completely different. We don't
1813 try to show the "return value" - no way to locate it. */
1814 if (get_frame_type (get_selected_frame (_("No selected frame.")))
1817 /* Claim we are stepping in the calling frame. An empty step
1818 range means that we will stop once we aren't in a function
1819 called by that frame. We don't use the magic "1" value for
1820 step_range_end, because then infrun will think this is nexti,
1821 and not step over the rest of this inlined function call. */
1822 set_step_info (tp
, frame
, {});
1823 tp
->control
.step_range_start
= get_frame_pc (frame
);
1824 tp
->control
.step_range_end
= tp
->control
.step_range_start
;
1825 tp
->control
.step_over_calls
= STEP_OVER_ALL
;
1827 /* Print info on the selected frame, including level number but not
1831 gdb_printf (_("Run till exit from "));
1832 print_stack_frame (get_selected_frame (nullptr), 1, LOCATION
, 0);
1835 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
);
1839 /* Find the function we will return from. */
1840 frame_info_ptr callee_frame
= get_selected_frame (nullptr);
1841 sm
->function
= find_pc_function (get_frame_pc (callee_frame
));
1842 sm
->return_buf
= 0; /* Initialize buffer address is not available. */
1844 /* Determine the return convention. If it is RETURN_VALUE_STRUCT_CONVENTION,
1845 attempt to determine the address of the return buffer. */
1846 if (sm
->function
!= nullptr)
1848 enum return_value_convention return_value
;
1849 struct gdbarch
*gdbarch
= get_frame_arch (callee_frame
);
1851 struct type
* val_type
1852 = check_typedef (sm
->function
->type ()->target_type ());
1855 = gdbarch_return_value_as_value (gdbarch
,
1856 read_var_value (sm
->function
, nullptr,
1858 val_type
, nullptr, nullptr, nullptr);
1860 if (return_value
== RETURN_VALUE_STRUCT_CONVENTION
1861 && val_type
->code () != TYPE_CODE_VOID
)
1862 sm
->return_buf
= gdbarch_get_return_buf_addr (gdbarch
, val_type
,
1866 /* Print info on the selected frame, including level number but not
1870 if (execution_direction
== EXEC_REVERSE
)
1871 gdb_printf (_("Run back to call of "));
1874 if (sm
->function
!= nullptr && TYPE_NO_RETURN (sm
->function
->type ())
1875 && !query (_("warning: Function %s does not return normally.\n"
1876 "Try to finish anyway? "),
1877 sm
->function
->print_name ()))
1878 error (_("Not confirmed."));
1879 gdb_printf (_("Run till exit from "));
1882 print_stack_frame (callee_frame
, 1, LOCATION
, 0);
1885 if (execution_direction
== EXEC_REVERSE
)
1886 finish_backward (sm
);
1889 frame
= skip_finish_frames (frame
);
1891 if (frame
== nullptr)
1892 error (_("Cannot find the caller frame."));
1894 finish_forward (sm
, frame
);
1900 info_program_command (const char *args
, int from_tty
)
1902 scoped_restore_current_thread restore_thread
;
1906 /* In non-stop, since every thread is controlled individually, we'll
1907 show execution info about the current thread. In all-stop, we'll
1908 show execution info about the last stop. */
1912 if (!target_has_execution ())
1914 gdb_printf (_("The program being debugged is not being run.\n"));
1918 if (inferior_ptid
== null_ptid
)
1919 error (_("No selected thread."));
1921 tp
= inferior_thread ();
1923 gdb_printf (_("Selected thread %s (%s).\n"),
1924 print_thread_id (tp
),
1925 target_pid_to_str (tp
->ptid
).c_str ());
1927 if (tp
->state
== THREAD_EXITED
)
1929 gdb_printf (_("Selected thread has exited.\n"));
1932 else if (tp
->state
== THREAD_RUNNING
)
1934 gdb_printf (_("Selected thread is running.\n"));
1940 tp
= get_previous_thread ();
1944 gdb_printf (_("The program being debugged is not being run.\n"));
1948 switch_to_thread (tp
);
1950 gdb_printf (_("Last stopped for thread %s (%s).\n"),
1951 print_thread_id (tp
),
1952 target_pid_to_str (tp
->ptid
).c_str ());
1954 if (tp
->state
== THREAD_EXITED
)
1956 gdb_printf (_("Thread has since exited.\n"));
1960 if (tp
->state
== THREAD_RUNNING
)
1962 gdb_printf (_("Thread is now running.\n"));
1968 bpstat
*bs
= tp
->control
.stop_bpstat
;
1969 int stat
= bpstat_num (&bs
, &num
);
1971 target_files_info ();
1972 gdb_printf (_("Program stopped at %s.\n"),
1973 paddress (current_inferior ()->arch (), tp
->stop_pc ()));
1974 if (tp
->control
.stop_step
)
1975 gdb_printf (_("It stopped after being stepped.\n"));
1978 /* There may be several breakpoints in the same place, so this
1979 isn't as strange as it seems. */
1984 gdb_printf (_("It stopped at a breakpoint "
1985 "that has since been deleted.\n"));
1988 gdb_printf (_("It stopped at breakpoint %d.\n"), num
);
1989 stat
= bpstat_num (&bs
, &num
);
1992 else if (tp
->stop_signal () != GDB_SIGNAL_0
)
1994 gdb_printf (_("It stopped with signal %s, %s.\n"),
1995 gdb_signal_to_name (tp
->stop_signal ()),
1996 gdb_signal_to_string (tp
->stop_signal ()));
2001 gdb_printf (_("Type \"info stack\" or \"info "
2002 "registers\" for more information.\n"));
2007 environment_info (const char *var
, int from_tty
)
2011 const char *val
= current_inferior ()->environment
.get (var
);
2022 gdb_puts ("Environment variable \"");
2024 gdb_puts ("\" not defined.\n");
2029 char **envp
= current_inferior ()->environment
.envp ();
2031 for (int idx
= 0; envp
[idx
] != nullptr; ++idx
)
2033 gdb_puts (envp
[idx
]);
2040 set_environment_command (const char *arg
, int from_tty
)
2042 const char *p
, *val
;
2046 error_no_arg (_("environment variable and value"));
2048 /* Find separation between variable name and value. */
2049 p
= (char *) strchr (arg
, '=');
2050 val
= (char *) strchr (arg
, ' ');
2052 if (p
!= 0 && val
!= 0)
2054 /* We have both a space and an equals. If the space is before the
2055 equals, walk forward over the spaces til we see a nonspace
2056 (possibly the equals). */
2061 /* Now if the = is after the char following the spaces,
2062 take the char following the spaces. */
2066 else if (val
!= 0 && p
== 0)
2070 error_no_arg (_("environment variable to set"));
2072 if (p
== 0 || p
[1] == 0)
2076 p
= arg
+ strlen (arg
); /* So that savestring below will work. */
2080 /* Not setting variable value to null. */
2082 while (*val
== ' ' || *val
== '\t')
2086 while (p
!= arg
&& (p
[-1] == ' ' || p
[-1] == '\t'))
2089 std::string
var (arg
, p
- arg
);
2092 gdb_printf (_("Setting environment variable "
2093 "\"%s\" to null value.\n"),
2095 current_inferior ()->environment
.set (var
.c_str (), "");
2098 current_inferior ()->environment
.set (var
.c_str (), val
);
2102 unset_environment_command (const char *var
, int from_tty
)
2106 /* If there is no argument, delete all environment variables.
2107 Ask for confirmation if reading from the terminal. */
2108 if (!from_tty
|| query (_("Delete all environment variables? ")))
2109 current_inferior ()->environment
.clear ();
2112 current_inferior ()->environment
.unset (var
);
2115 /* Handle the execution path (PATH variable). */
2117 static const char path_var_name
[] = "PATH";
2120 path_info (const char *args
, int from_tty
)
2122 gdb_puts ("Executable and object file path: ");
2123 gdb_puts (current_inferior ()->environment
.get (path_var_name
));
2127 /* Add zero or more directories to the front of the execution path. */
2130 path_command (const char *dirname
, int from_tty
)
2135 env
= current_inferior ()->environment
.get (path_var_name
);
2136 /* Can be null if path is not set. */
2139 std::string exec_path
= env
;
2140 mod_path (dirname
, exec_path
);
2141 current_inferior ()->environment
.set (path_var_name
, exec_path
.c_str ());
2143 path_info (nullptr, from_tty
);
2148 pad_to_column (string_file
&stream
, int col
)
2150 /* At least one space must be printed to separate columns. */
2152 const int size
= stream
.size ();
2154 stream
.puts (n_spaces (col
- size
));
2157 /* Print out the register NAME with value VAL, to FILE, in the default
2161 default_print_one_register_info (struct ui_file
*file
,
2165 struct type
*regtype
= val
->type ();
2166 int print_raw_format
;
2167 string_file format_stream
;
2170 value_column_1
= 15,
2171 /* Give enough room for "0x", 16 hex digits and two spaces in
2172 preceding column. */
2173 value_column_2
= value_column_1
+ 2 + 16 + 2,
2176 format_stream
.puts (name
);
2177 pad_to_column (format_stream
, value_column_1
);
2179 print_raw_format
= (val
->entirely_available ()
2180 && !val
->optimized_out ());
2182 /* If virtual format is floating, print it that way, and in raw
2184 if (regtype
->code () == TYPE_CODE_FLT
2185 || regtype
->code () == TYPE_CODE_DECFLOAT
)
2187 struct value_print_options opts
;
2188 const gdb_byte
*valaddr
= val
->contents_for_printing ().data ();
2189 enum bfd_endian byte_order
= type_byte_order (regtype
);
2191 get_user_print_options (&opts
);
2192 opts
.deref_ref
= true;
2194 common_val_print (val
, &format_stream
, 0, &opts
, current_language
);
2196 if (print_raw_format
)
2198 pad_to_column (format_stream
, value_column_2
);
2199 format_stream
.puts ("(raw ");
2200 print_hex_chars (&format_stream
, valaddr
, regtype
->length (),
2202 format_stream
.putc (')');
2207 struct value_print_options opts
;
2209 /* Print the register in hex. */
2210 get_formatted_print_options (&opts
, 'x');
2211 opts
.deref_ref
= true;
2212 common_val_print (val
, &format_stream
, 0, &opts
, current_language
);
2213 /* If not a vector register, print it also according to its
2215 if (print_raw_format
&& regtype
->is_vector () == 0)
2217 pad_to_column (format_stream
, value_column_2
);
2218 get_user_print_options (&opts
);
2219 opts
.deref_ref
= true;
2220 common_val_print (val
, &format_stream
, 0, &opts
, current_language
);
2224 gdb_puts (format_stream
.c_str (), file
);
2225 gdb_printf (file
, "\n");
2228 /* Print out the machine register regnum. If regnum is -1, print all
2229 registers (print_all == 1) or all non-float and non-vector
2230 registers (print_all == 0).
2232 For most machines, having all_registers_info() print the
2233 register(s) one per line is good enough. If a different format is
2234 required, (eg, for MIPS or Pyramid 90x, which both have lots of
2235 regs), or there is an existing convention for showing all the
2236 registers, define the architecture method PRINT_REGISTERS_INFO to
2237 provide that format. */
2240 default_print_registers_info (struct gdbarch
*gdbarch
,
2241 struct ui_file
*file
,
2242 const frame_info_ptr
&frame
,
2243 int regnum
, int print_all
)
2246 const int numregs
= gdbarch_num_cooked_regs (gdbarch
);
2248 for (i
= 0; i
< numregs
; i
++)
2250 /* Decide between printing all regs, non-float / vector regs, or
2256 if (!gdbarch_register_reggroup_p (gdbarch
, i
, all_reggroup
))
2261 if (!gdbarch_register_reggroup_p (gdbarch
, i
, general_reggroup
))
2271 /* If the register name is empty, it is undefined for this
2272 processor, so don't display anything. */
2273 if (*(gdbarch_register_name (gdbarch
, i
)) == '\0')
2276 default_print_one_register_info
2277 (file
, gdbarch_register_name (gdbarch
, i
),
2278 value_of_register (i
, get_next_frame_sentinel_okay (frame
)));
2283 registers_info (const char *addr_exp
, int fpregs
)
2285 frame_info_ptr frame
;
2286 struct gdbarch
*gdbarch
;
2288 if (!target_has_registers ())
2289 error (_("The program has no registers now."));
2290 frame
= get_selected_frame (nullptr);
2291 gdbarch
= get_frame_arch (frame
);
2295 gdbarch_print_registers_info (gdbarch
, gdb_stdout
,
2300 while (*addr_exp
!= '\0')
2305 /* Skip leading white space. */
2306 addr_exp
= skip_spaces (addr_exp
);
2308 /* Discard any leading ``$''. Check that there is something
2309 resembling a register following it. */
2310 if (addr_exp
[0] == '$')
2312 if (isspace ((*addr_exp
)) || (*addr_exp
) == '\0')
2313 error (_("Missing register name"));
2315 /* Find the start/end of this register name/num/group. */
2317 while ((*addr_exp
) != '\0' && !isspace ((*addr_exp
)))
2321 /* Figure out what we've found and display it. */
2323 /* A register name? */
2325 int regnum
= user_reg_map_name_to_regnum (gdbarch
, start
, end
- start
);
2329 /* User registers lie completely outside of the range of
2330 normal registers. Catch them early so that the target
2332 if (regnum
>= gdbarch_num_cooked_regs (gdbarch
))
2334 struct value
*regval
= value_of_user_reg (regnum
, frame
);
2335 const char *regname
= user_reg_map_regnum_to_name (gdbarch
,
2338 /* Print in the same fashion
2339 gdbarch_print_registers_info's default
2340 implementation prints. */
2341 default_print_one_register_info (gdb_stdout
,
2346 gdbarch_print_registers_info (gdbarch
, gdb_stdout
,
2347 frame
, regnum
, fpregs
);
2352 /* A register group? */
2354 const struct reggroup
*group
= nullptr;
2355 for (const struct reggroup
*g
: gdbarch_reggroups (gdbarch
))
2357 /* Don't bother with a length check. Should the user
2358 enter a short register group name, go with the first
2359 group that matches. */
2360 if (strncmp (start
, g
->name (), end
- start
) == 0)
2366 if (group
!= nullptr)
2371 regnum
< gdbarch_num_cooked_regs (gdbarch
);
2374 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, group
))
2375 gdbarch_print_registers_info (gdbarch
,
2383 /* Nothing matched. */
2384 error (_("Invalid register `%.*s'"), (int) (end
- start
), start
);
2389 info_all_registers_command (const char *addr_exp
, int from_tty
)
2391 registers_info (addr_exp
, 1);
2395 info_registers_command (const char *addr_exp
, int from_tty
)
2397 registers_info (addr_exp
, 0);
2401 print_vector_info (struct ui_file
*file
,
2402 const frame_info_ptr
&frame
, const char *args
)
2404 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
2406 if (gdbarch_print_vector_info_p (gdbarch
))
2407 gdbarch_print_vector_info (gdbarch
, file
, frame
, args
);
2411 int printed_something
= 0;
2413 for (regnum
= 0; regnum
< gdbarch_num_cooked_regs (gdbarch
); regnum
++)
2415 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, vector_reggroup
))
2417 printed_something
= 1;
2418 gdbarch_print_registers_info (gdbarch
, file
, frame
, regnum
, 1);
2421 if (!printed_something
)
2422 gdb_printf (file
, "No vector information\n");
2427 info_vector_command (const char *args
, int from_tty
)
2429 if (!target_has_registers ())
2430 error (_("The program has no registers now."));
2432 print_vector_info (gdb_stdout
, get_selected_frame (nullptr), args
);
2435 /* Kill the inferior process. Make us have no inferior. */
2438 kill_command (const char *arg
, int from_tty
)
2440 /* FIXME: This should not really be inferior_ptid (or target_has_execution).
2441 It should be a distinct flag that indicates that a target is active, cuz
2442 some targets don't have processes! */
2444 if (inferior_ptid
== null_ptid
)
2445 error (_("The program is not being run."));
2446 if (!query (_("Kill the program being debugged? ")))
2447 error (_("Not confirmed."));
2449 int pid
= current_inferior ()->pid
;
2450 /* Save the pid as a string before killing the inferior, since that
2451 may unpush the current target, and we need the string after. */
2452 std::string pid_str
= target_pid_to_str (ptid_t (pid
));
2453 int infnum
= current_inferior ()->num
;
2457 update_previous_thread ();
2459 if (print_inferior_events
)
2460 gdb_printf (_("[Inferior %d (%s) killed]\n"),
2461 infnum
, pid_str
.c_str ());
2464 /* Used in `attach&' command. Proceed threads of inferior INF iff
2465 they stopped due to debugger request, and when they did, they
2466 reported a clean stop (GDB_SIGNAL_0). Do not proceed threads that
2467 have been explicitly been told to stop. */
2470 proceed_after_attach (inferior
*inf
)
2472 /* Don't error out if the current thread is running, because
2473 there may be other stopped threads. */
2475 /* Backup current thread and selected frame. */
2476 scoped_restore_current_thread restore_thread
;
2478 for (thread_info
*thread
: inf
->non_exited_threads ())
2479 if (!thread
->executing ()
2480 && !thread
->stop_requested
2481 && thread
->stop_signal () == GDB_SIGNAL_0
)
2483 switch_to_thread (thread
);
2484 clear_proceed_status (0);
2485 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
);
2489 /* See inferior.h. */
2492 setup_inferior (int from_tty
)
2494 struct inferior
*inferior
;
2496 inferior
= current_inferior ();
2497 inferior
->needs_setup
= false;
2499 /* If no exec file is yet known, try to determine it from the
2501 if (get_exec_file (0) == nullptr)
2502 exec_file_locate_attach (inferior_ptid
.pid (), 1, from_tty
);
2505 reopen_exec_file ();
2506 reread_symbols (from_tty
);
2509 /* Take any necessary post-attaching actions for this platform. */
2510 target_post_attach (inferior_ptid
.pid ());
2512 post_create_inferior (from_tty
);
2515 /* What to do after the first program stops after attaching. */
2516 enum attach_post_wait_mode
2518 /* Do nothing. Leaves threads as they are. */
2519 ATTACH_POST_WAIT_NOTHING
,
2521 /* Re-resume threads that are marked running. */
2522 ATTACH_POST_WAIT_RESUME
,
2524 /* Stop all threads. */
2525 ATTACH_POST_WAIT_STOP
,
2528 /* Called after we've attached to a process and we've seen it stop for
2529 the first time. Resume, stop, or don't touch the threads according
2533 attach_post_wait (int from_tty
, enum attach_post_wait_mode mode
)
2535 struct inferior
*inferior
;
2537 inferior
= current_inferior ();
2538 inferior
->control
.stop_soon
= NO_STOP_QUIETLY
;
2540 if (inferior
->needs_setup
)
2541 setup_inferior (from_tty
);
2543 if (mode
== ATTACH_POST_WAIT_RESUME
)
2545 /* The user requested an `attach&', so be sure to leave threads
2546 that didn't get a signal running. */
2548 /* Immediately resume all suspended threads of this inferior,
2549 and this inferior only. This should have no effect on
2550 already running threads. If a thread has been stopped with a
2551 signal, leave it be. */
2553 proceed_after_attach (inferior
);
2556 if (inferior_thread ()->stop_signal () == GDB_SIGNAL_0
)
2558 clear_proceed_status (0);
2559 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
);
2563 else if (mode
== ATTACH_POST_WAIT_STOP
)
2565 /* The user requested a plain `attach', so be sure to leave
2566 the inferior stopped. */
2568 /* At least the current thread is already stopped. */
2570 /* In all-stop, by definition, all threads have to be already
2571 stopped at this point. In non-stop, however, although the
2572 selected thread is stopped, others may still be executing.
2573 Be sure to explicitly stop all threads of the process. This
2574 should have no effect on already stopped threads. */
2576 target_stop (ptid_t (inferior
->pid
));
2577 else if (target_is_non_stop_p ())
2579 struct thread_info
*lowest
= inferior_thread ();
2581 stop_all_threads ("attaching");
2583 /* It's not defined which thread will report the attach
2584 stop. For consistency, always select the thread with
2585 lowest GDB number, which should be the main thread, if it
2587 for (thread_info
*thread
: current_inferior ()->non_exited_threads ())
2588 if (thread
->inf
->num
< lowest
->inf
->num
2589 || thread
->per_inf_num
< lowest
->per_inf_num
)
2592 switch_to_thread (lowest
);
2595 /* Tell the user/frontend where we're stopped. */
2597 if (deprecated_attach_hook
)
2598 deprecated_attach_hook ();
2602 /* "attach" command entry point. Takes a program started up outside
2603 of gdb and ``attaches'' to it. This stops it cold in its tracks
2604 and allows us to start debugging it. */
2607 attach_command (const char *args
, int from_tty
)
2610 struct target_ops
*attach_target
;
2611 struct inferior
*inferior
= current_inferior ();
2612 enum attach_post_wait_mode mode
;
2614 dont_repeat (); /* Not for the faint of heart */
2616 scoped_disable_commit_resumed
disable_commit_resumed ("attaching");
2618 if (gdbarch_has_global_solist (current_inferior ()->arch ()))
2619 /* Don't complain if all processes share the same symbol
2622 else if (target_has_execution ())
2624 if (query (_("A program is being debugged already. Kill it? ")))
2627 error (_("Not killed."));
2630 /* Clean up any leftovers from other runs. Some other things from
2631 this function should probably be moved into target_pre_inferior. */
2632 target_pre_inferior (from_tty
);
2634 gdb::unique_xmalloc_ptr
<char> stripped
= strip_bg_char (args
, &async_exec
);
2635 args
= stripped
.get ();
2637 attach_target
= find_attach_target ();
2639 prepare_execution_command (attach_target
, async_exec
);
2641 if (non_stop
&& !attach_target
->supports_non_stop ())
2642 error (_("Cannot attach to this target in non-stop mode"));
2644 attach_target
->attach (args
, from_tty
);
2645 /* to_attach should push the target, so after this point we
2646 shouldn't refer to attach_target again. */
2647 attach_target
= nullptr;
2649 infrun_debug_show_threads ("immediately after attach",
2650 current_inferior ()->non_exited_threads ());
2652 /* Enable async mode if it is supported by the target. */
2653 if (target_can_async_p ())
2654 target_async (true);
2656 /* Set up the "saved terminal modes" of the inferior
2657 based on what modes we are starting it with. */
2658 target_terminal::init ();
2660 /* Install inferior's terminal modes. This may look like a no-op,
2661 as we've just saved them above, however, this does more than
2662 restore terminal settings:
2664 - installs a SIGINT handler that forwards SIGINT to the inferior.
2665 Otherwise a Ctrl-C pressed just while waiting for the initial
2666 stop would end up as a spurious Quit.
2668 - removes stdin from the event loop, which we need if attaching
2669 in the foreground, otherwise on targets that report an initial
2670 stop on attach (which are most) we'd process input/commands
2671 while we're in the event loop waiting for that stop. That is,
2672 before the attach continuation runs and the command is really
2674 target_terminal::inferior ();
2676 /* Set up execution context to know that we should return from
2677 wait_for_inferior as soon as the target reports a stop. */
2678 init_wait_for_inferior ();
2680 inferior
->needs_setup
= true;
2682 if (target_is_non_stop_p ())
2684 /* If we find that the current thread isn't stopped, explicitly
2685 do so now, because we're going to install breakpoints and
2689 /* The user requested an `attach&'; stop just one thread. */
2690 target_stop (inferior_ptid
);
2692 /* The user requested an `attach', so stop all threads of this
2694 target_stop (ptid_t (inferior_ptid
.pid ()));
2697 /* Check for exec file mismatch, and let the user solve it. */
2698 validate_exec_file (from_tty
);
2700 mode
= async_exec
? ATTACH_POST_WAIT_RESUME
: ATTACH_POST_WAIT_STOP
;
2702 /* Some system don't generate traps when attaching to inferior.
2703 E.g. Mach 3 or GNU hurd. */
2704 if (!target_attach_no_wait ())
2706 /* Careful here. See comments in inferior.h. Basically some
2707 OSes don't ignore SIGSTOPs on continue requests anymore. We
2708 need a way for handle_inferior_event to reset the stop_signal
2709 variable after an attach, and this is what
2710 STOP_QUIETLY_NO_SIGSTOP is for. */
2711 inferior
->control
.stop_soon
= STOP_QUIETLY_NO_SIGSTOP
;
2713 /* Wait for stop. */
2714 inferior
->add_continuation ([=] ()
2716 attach_post_wait (from_tty
, mode
);
2719 /* Let infrun consider waiting for events out of this
2721 inferior
->process_target ()->threads_executing
= true;
2723 if (!target_is_async_p ())
2724 mark_infrun_async_event_handler ();
2728 attach_post_wait (from_tty
, mode
);
2730 disable_commit_resumed
.reset_and_commit ();
2733 /* We had just found out that the target was already attached to an
2734 inferior. PTID points at a thread of this new inferior, that is
2735 the most likely to be stopped right now, but not necessarily so.
2736 The new inferior is assumed to be already added to the inferior
2737 list at this point. If LEAVE_RUNNING, then leave the threads of
2738 this inferior running, except those we've explicitly seen reported
2742 notice_new_inferior (thread_info
*thr
, bool leave_running
, int from_tty
)
2744 enum attach_post_wait_mode mode
2745 = leave_running
? ATTACH_POST_WAIT_RESUME
: ATTACH_POST_WAIT_NOTHING
;
2747 std::optional
<scoped_restore_current_thread
> restore_thread
;
2749 if (inferior_ptid
!= null_ptid
)
2750 restore_thread
.emplace ();
2752 /* Avoid reading registers -- we haven't fetched the target
2754 switch_to_thread_no_regs (thr
);
2756 /* When we "notice" a new inferior we need to do all the things we
2757 would normally do if we had just attached to it. */
2759 if (thr
->executing ())
2761 struct inferior
*inferior
= current_inferior ();
2763 /* We're going to install breakpoints, and poke at memory,
2764 ensure that the inferior is stopped for a moment while we do
2766 target_stop (inferior_ptid
);
2768 inferior
->control
.stop_soon
= STOP_QUIETLY_REMOTE
;
2770 /* Wait for stop before proceeding. */
2771 inferior
->add_continuation ([=] ()
2773 attach_post_wait (from_tty
, mode
);
2779 attach_post_wait (from_tty
, mode
);
2784 * takes a program previously attached to and detaches it.
2785 * The program resumes execution and will no longer stop
2786 * on signals, etc. We better not have left any breakpoints
2787 * in the program or it'll die when it hits one. For this
2788 * to work, it may be necessary for the process to have been
2789 * previously attached. It *might* work if the program was
2790 * started via the normal ptrace (PTRACE_TRACEME).
2794 detach_command (const char *args
, int from_tty
)
2796 dont_repeat (); /* Not for the faint of heart. */
2798 if (inferior_ptid
== null_ptid
)
2799 error (_("The program is not being run."));
2801 scoped_disable_commit_resumed
disable_commit_resumed ("detaching");
2803 query_if_trace_running (from_tty
);
2805 disconnect_tracing ();
2807 /* Hold a strong reference to the target while (maybe)
2808 detaching the parent. Otherwise detaching could close the
2810 inferior
*inf
= current_inferior ();
2811 auto target_ref
= target_ops_ref::new_reference (inf
->process_target ());
2813 /* Save this before detaching, since detaching may unpush the
2814 process_stratum target. */
2815 bool was_non_stop_p
= target_is_non_stop_p ();
2817 target_detach (inf
, from_tty
);
2819 update_previous_thread ();
2821 /* The current inferior process was just detached successfully. Get
2822 rid of breakpoints that no longer make sense. Note we don't do
2823 this within target_detach because that is also used when
2824 following child forks, and in that case we will want to transfer
2825 breakpoints to the child, not delete them. */
2826 breakpoint_init_inferior (inf
, inf_exited
);
2828 /* If the solist is global across inferiors, don't clear it when we
2829 detach from a single inferior. */
2830 if (!gdbarch_has_global_solist (inf
->arch ()))
2831 no_shared_libraries (nullptr, from_tty
);
2833 if (deprecated_detach_hook
)
2834 deprecated_detach_hook ();
2836 if (!was_non_stop_p
)
2837 restart_after_all_stop_detach (as_process_stratum_target (target_ref
.get ()));
2839 disable_commit_resumed
.reset_and_commit ();
2842 /* Disconnect from the current target without resuming it (leaving it
2843 waiting for a debugger).
2845 We'd better not have left any breakpoints in the program or the
2846 next debugger will get confused. Currently only supported for some
2847 remote targets, since the normal attach mechanisms don't work on
2848 stopped processes on some native platforms (e.g. GNU/Linux). */
2851 disconnect_command (const char *args
, int from_tty
)
2853 dont_repeat (); /* Not for the faint of heart. */
2854 query_if_trace_running (from_tty
);
2855 disconnect_tracing ();
2856 target_disconnect (args
, from_tty
);
2857 no_shared_libraries (nullptr, from_tty
);
2858 init_thread_list ();
2859 update_previous_thread ();
2860 if (deprecated_detach_hook
)
2861 deprecated_detach_hook ();
2864 /* Stop PTID in the current target, and tag the PTID threads as having
2865 been explicitly requested to stop. PTID can be a thread, a
2866 process, or minus_one_ptid, meaning all threads of all inferiors of
2867 the current target. */
2870 stop_current_target_threads_ns (ptid_t ptid
)
2874 /* Tag the thread as having been explicitly requested to stop, so
2875 other parts of gdb know not to resume this thread automatically,
2876 if it was stopped due to an internal event. Limit this to
2877 non-stop mode, as when debugging a multi-threaded application in
2878 all-stop mode, we will only get one stop event --- it's undefined
2879 which thread will report the event. */
2880 set_stop_requested (current_inferior ()->process_target (),
2884 /* See inferior.h. */
2887 interrupt_target_1 (bool all_threads
)
2889 scoped_disable_commit_resumed
disable_commit_resumed ("interrupting");
2895 scoped_restore_current_thread restore_thread
;
2897 for (inferior
*inf
: all_inferiors ())
2899 switch_to_inferior_no_thread (inf
);
2900 stop_current_target_threads_ns (minus_one_ptid
);
2904 stop_current_target_threads_ns (inferior_ptid
);
2907 target_interrupt ();
2909 disable_commit_resumed
.reset_and_commit ();
2913 Stop the execution of the target while running in async mode, in
2914 the background. In all-stop, stop the whole process. In non-stop
2915 mode, stop the current thread only by default, or stop all threads
2916 if the `-a' switch is used. */
2919 interrupt_command (const char *args
, int from_tty
)
2921 if (target_can_async_p ())
2923 int all_threads
= 0;
2925 dont_repeat (); /* Not for the faint of heart. */
2928 && startswith (args
, "-a"))
2931 interrupt_target_1 (all_threads
);
2935 /* See inferior.h. */
2938 default_print_float_info (struct gdbarch
*gdbarch
, struct ui_file
*file
,
2939 const frame_info_ptr
&frame
, const char *args
)
2942 int printed_something
= 0;
2944 for (regnum
= 0; regnum
< gdbarch_num_cooked_regs (gdbarch
); regnum
++)
2946 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, float_reggroup
))
2948 printed_something
= 1;
2949 gdbarch_print_registers_info (gdbarch
, file
, frame
, regnum
, 1);
2952 if (!printed_something
)
2953 gdb_printf (file
, "No floating-point info "
2954 "available for this processor.\n");
2958 info_float_command (const char *args
, int from_tty
)
2960 frame_info_ptr frame
;
2962 if (!target_has_registers ())
2963 error (_("The program has no registers now."));
2965 frame
= get_selected_frame (nullptr);
2966 gdbarch_print_float_info (get_frame_arch (frame
), gdb_stdout
, frame
, args
);
2969 /* Implement `info proc' family of commands. */
2972 info_proc_cmd_1 (const char *args
, enum info_proc_what what
, int from_tty
)
2974 struct gdbarch
*gdbarch
= get_current_arch ();
2976 if (!target_info_proc (args
, what
))
2978 if (gdbarch_info_proc_p (gdbarch
))
2979 gdbarch_info_proc (gdbarch
, args
, what
);
2981 error (_("Not supported on this target."));
2985 /* Implement `info proc' when given without any further parameters. */
2988 info_proc_cmd (const char *args
, int from_tty
)
2990 info_proc_cmd_1 (args
, IP_MINIMAL
, from_tty
);
2993 /* Implement `info proc mappings'. */
2996 info_proc_cmd_mappings (const char *args
, int from_tty
)
2998 info_proc_cmd_1 (args
, IP_MAPPINGS
, from_tty
);
3001 /* Implement `info proc stat'. */
3004 info_proc_cmd_stat (const char *args
, int from_tty
)
3006 info_proc_cmd_1 (args
, IP_STAT
, from_tty
);
3009 /* Implement `info proc status'. */
3012 info_proc_cmd_status (const char *args
, int from_tty
)
3014 info_proc_cmd_1 (args
, IP_STATUS
, from_tty
);
3017 /* Implement `info proc cwd'. */
3020 info_proc_cmd_cwd (const char *args
, int from_tty
)
3022 info_proc_cmd_1 (args
, IP_CWD
, from_tty
);
3025 /* Implement `info proc cmdline'. */
3028 info_proc_cmd_cmdline (const char *args
, int from_tty
)
3030 info_proc_cmd_1 (args
, IP_CMDLINE
, from_tty
);
3033 /* Implement `info proc exe'. */
3036 info_proc_cmd_exe (const char *args
, int from_tty
)
3038 info_proc_cmd_1 (args
, IP_EXE
, from_tty
);
3041 /* Implement `info proc files'. */
3044 info_proc_cmd_files (const char *args
, int from_tty
)
3046 info_proc_cmd_1 (args
, IP_FILES
, from_tty
);
3049 /* Implement `info proc all'. */
3052 info_proc_cmd_all (const char *args
, int from_tty
)
3054 info_proc_cmd_1 (args
, IP_ALL
, from_tty
);
3057 /* Implement `show print finish'. */
3060 show_print_finish (struct ui_file
*file
, int from_tty
,
3061 struct cmd_list_element
*c
,
3064 gdb_printf (file
, _("\
3065 Printing of return value after `finish' is %s.\n"),
3070 /* This help string is used for the run, start, and starti commands.
3071 It is defined as a macro to prevent duplication. */
3073 #define RUN_ARGS_HELP \
3074 "You may specify arguments to give it.\n\
3075 Args may include \"*\", or \"[...]\"; they are expanded using the\n\
3076 shell that will start the program (specified by the \"$SHELL\" environment\n\
3077 variable). Input and output redirection with \">\", \"<\", or \">>\"\n\
3078 are also allowed.\n\
3080 With no arguments, uses arguments last specified (with \"run\" or \n\
3081 \"set args\"). To cancel previous arguments and run with no arguments,\n\
3082 use \"set args\" without arguments.\n\
3084 To start the inferior without using a shell, use \"set startup-with-shell off\"."
3086 void _initialize_infcmd ();
3088 _initialize_infcmd ()
3090 static struct cmd_list_element
*info_proc_cmdlist
;
3091 struct cmd_list_element
*c
= nullptr;
3093 /* Add the filename of the terminal connected to inferior I/O. */
3095 = add_setshow_optional_filename_cmd ("inferior-tty", class_run
, _("\
3096 Set terminal for future runs of program being debugged."), _(" \
3097 Show terminal for future runs of program being debugged."), _(" \
3098 Usage: set inferior-tty [TTY]\n\n \
3099 If TTY is omitted, the default behavior of using the same terminal as GDB\n \
3103 show_inferior_tty_command
,
3104 &setlist
, &showlist
);
3105 add_alias_cmd ("tty", tty_set_show
.set
, class_run
, 0, &cmdlist
);
3108 = add_setshow_string_noescape_cmd ("args", class_run
, _("\
3109 Set argument list to give program being debugged when it is started."), _("\
3110 Show argument list to give program being debugged when it is started."), _("\
3111 Follow this command with any number of args, to be passed to the program."),
3115 &setlist
, &showlist
);
3116 set_cmd_completer (args_set_show
.set
, filename_completer
);
3119 = add_setshow_string_noescape_cmd ("cwd", class_run
, _("\
3120 Set the current working directory to be used when the inferior is started.\n \
3121 Changing this setting does not have any effect on inferiors that are\n \
3124 Show the current working directory that is used when the inferior is started."),
3126 Use this command to change the current working directory that will be used\n\
3127 when the inferior is started. This setting does not affect GDB's current\n\
3128 working directory."),
3129 set_cwd_value
, get_inferior_cwd
,
3131 &setlist
, &showlist
);
3132 set_cmd_completer (cwd_set_show
.set
, filename_completer
);
3134 c
= add_cmd ("environment", no_class
, environment_info
, _("\
3135 The environment to give the program, or one variable's value.\n\
3136 With an argument VAR, prints the value of environment variable VAR to\n\
3137 give the program being debugged. With no arguments, prints the entire\n\
3138 environment to be given to the program."), &showlist
);
3139 set_cmd_completer (c
, noop_completer
);
3141 add_basic_prefix_cmd ("unset", no_class
,
3142 _("Complement to certain \"set\" commands."),
3143 &unsetlist
, 0, &cmdlist
);
3145 c
= add_cmd ("environment", class_run
, unset_environment_command
, _("\
3146 Cancel environment variable VAR for the program.\n\
3147 This does not affect the program until the next \"run\" command."),
3149 set_cmd_completer (c
, noop_completer
);
3151 c
= add_cmd ("environment", class_run
, set_environment_command
, _("\
3152 Set environment variable value to give the program.\n\
3153 Arguments are VAR VALUE where VAR is variable name and VALUE is value.\n\
3154 VALUES of environment variables are uninterpreted strings.\n\
3155 This does not affect the program until the next \"run\" command."),
3157 set_cmd_completer (c
, noop_completer
);
3159 c
= add_com ("path", class_files
, path_command
, _("\
3160 Add directory DIR(s) to beginning of search path for object files.\n\
3161 $cwd in the path means the current working directory.\n\
3162 This path is equivalent to the $PATH shell variable. It is a list of\n\
3163 directories, separated by colons. These directories are searched to find\n\
3164 fully linked executable files and separately compiled object files as \
3166 set_cmd_completer (c
, filename_completer
);
3168 c
= add_cmd ("paths", no_class
, path_info
, _("\
3169 Current search path for finding object files.\n\
3170 $cwd in the path means the current working directory.\n\
3171 This path is equivalent to the $PATH shell variable. It is a list of\n\
3172 directories, separated by colons. These directories are searched to find\n\
3173 fully linked executable files and separately compiled object files as \
3176 set_cmd_completer (c
, noop_completer
);
3178 add_prefix_cmd ("kill", class_run
, kill_command
,
3179 _("Kill execution of program being debugged."),
3180 &killlist
, 0, &cmdlist
);
3182 add_com ("attach", class_run
, attach_command
, _("\
3183 Attach to a process or file outside of GDB.\n\
3184 This command attaches to another target, of the same type as your last\n\
3185 \"target\" command (\"info files\" will show your target stack).\n\
3186 The command may take as argument a process id or a device file.\n\
3187 For a process id, you must have permission to send the process a signal,\n\
3188 and it must have the same effective uid as the debugger.\n\
3189 When using \"attach\" with a process id, the debugger finds the\n\
3190 program running in the process, looking first in the current working\n\
3191 directory, or (if not found there) using the source file search path\n\
3192 (see the \"directory\" command). You can also use the \"file\" command\n\
3193 to specify the program, and to load its symbol table."));
3195 add_prefix_cmd ("detach", class_run
, detach_command
, _("\
3196 Detach a process or file previously attached.\n\
3197 If a process, it is no longer traced, and it continues its execution. If\n\
3198 you were debugging a file, the file is closed and gdb no longer accesses it."),
3199 &detachlist
, 0, &cmdlist
);
3201 add_com ("disconnect", class_run
, disconnect_command
, _("\
3202 Disconnect from a target.\n\
3203 The target will wait for another debugger to connect. Not available for\n\
3206 c
= add_com ("signal", class_run
, signal_command
, _("\
3207 Continue program with the specified signal.\n\
3208 Usage: signal SIGNAL\n\
3209 The SIGNAL argument is processed the same as the handle command.\n\
3211 An argument of \"0\" means continue the program without sending it a signal.\n\
3212 This is useful in cases where the program stopped because of a signal,\n\
3213 and you want to resume the program while discarding the signal.\n\
3215 In a multi-threaded program the signal is delivered to, or discarded from,\n\
3216 the current thread only."));
3217 set_cmd_completer (c
, signal_completer
);
3219 c
= add_com ("queue-signal", class_run
, queue_signal_command
, _("\
3220 Queue a signal to be delivered to the current thread when it is resumed.\n\
3221 Usage: queue-signal SIGNAL\n\
3222 The SIGNAL argument is processed the same as the handle command.\n\
3223 It is an error if the handling state of SIGNAL is \"nopass\".\n\
3225 An argument of \"0\" means remove any currently queued signal from\n\
3226 the current thread. This is useful in cases where the program stopped\n\
3227 because of a signal, and you want to resume it while discarding the signal.\n\
3229 In a multi-threaded program the signal is queued with, or discarded from,\n\
3230 the current thread only."));
3231 set_cmd_completer (c
, signal_completer
);
3233 cmd_list_element
*stepi_cmd
3234 = add_com ("stepi", class_run
, stepi_command
, _("\
3235 Step one instruction exactly.\n\
3237 Argument N means step N times (or till program stops for another \
3239 add_com_alias ("si", stepi_cmd
, class_run
, 0);
3241 cmd_list_element
*nexti_cmd
3242 = add_com ("nexti", class_run
, nexti_command
, _("\
3243 Step one instruction, but proceed through subroutine calls.\n\
3245 Argument N means step N times (or till program stops for another \
3247 add_com_alias ("ni", nexti_cmd
, class_run
, 0);
3249 cmd_list_element
*finish_cmd
3250 = add_com ("finish", class_run
, finish_command
, _("\
3251 Execute until selected stack frame returns.\n\
3253 Upon return, the value returned is printed and put in the value history."));
3254 add_com_alias ("fin", finish_cmd
, class_run
, 1);
3256 cmd_list_element
*next_cmd
3257 = add_com ("next", class_run
, next_command
, _("\
3258 Step program, proceeding through subroutine calls.\n\
3260 Unlike \"step\", if the current source line calls a subroutine,\n\
3261 this command does not enter the subroutine, but instead steps over\n\
3262 the call, in effect treating it as a single source line."));
3263 add_com_alias ("n", next_cmd
, class_run
, 1);
3265 cmd_list_element
*step_cmd
3266 = add_com ("step", class_run
, step_command
, _("\
3267 Step program until it reaches a different source line.\n\
3269 Argument N means step N times (or till program stops for another \
3271 add_com_alias ("s", step_cmd
, class_run
, 1);
3273 cmd_list_element
*until_cmd
3274 = add_com ("until", class_run
, until_command
, _("\
3275 Execute until past the current line or past a LOCATION.\n\
3276 Execute until the program reaches a source line greater than the current\n\
3277 or a specified location (same args as break command) within the current \
3279 set_cmd_completer (until_cmd
, location_completer
);
3280 add_com_alias ("u", until_cmd
, class_run
, 1);
3282 c
= add_com ("advance", class_run
, advance_command
, _("\
3283 Continue the program up to the given location (same form as args for break \
3285 Execution will also stop upon exit from the current stack frame."));
3286 set_cmd_completer (c
, location_completer
);
3288 cmd_list_element
*jump_cmd
3289 = add_com ("jump", class_run
, jump_command
, _("\
3290 Continue program being debugged at specified line or address.\n\
3291 Usage: jump LOCATION\n\
3292 Give as argument either LINENUM or *ADDR, where ADDR is an expression\n\
3293 for an address to start at."));
3294 set_cmd_completer (jump_cmd
, location_completer
);
3295 add_com_alias ("j", jump_cmd
, class_run
, 1);
3297 cmd_list_element
*continue_cmd
3298 = add_com ("continue", class_run
, continue_command
, _("\
3299 Continue program being debugged, after signal or breakpoint.\n\
3300 Usage: continue [N]\n\
3301 If proceeding from breakpoint, a number N may be used as an argument,\n\
3302 which means to set the ignore count of that breakpoint to N - 1 (so that\n\
3303 the breakpoint won't break until the Nth time it is reached).\n\
3305 If non-stop mode is enabled, continue only the current thread,\n\
3306 otherwise all the threads in the program are continued. To \n\
3307 continue all stopped threads in non-stop mode, use the -a option.\n\
3308 Specifying -a and an ignore count simultaneously is an error."));
3309 add_com_alias ("c", continue_cmd
, class_run
, 1);
3310 add_com_alias ("fg", continue_cmd
, class_run
, 1);
3312 cmd_list_element
*run_cmd
3313 = add_com ("run", class_run
, run_command
, _("\
3314 Start debugged program.\n"
3316 set_cmd_completer (run_cmd
, filename_completer
);
3317 add_com_alias ("r", run_cmd
, class_run
, 1);
3319 c
= add_com ("start", class_run
, start_command
, _("\
3320 Start the debugged program stopping at the beginning of the main procedure.\n"
3322 set_cmd_completer (c
, filename_completer
);
3324 c
= add_com ("starti", class_run
, starti_command
, _("\
3325 Start the debugged program stopping at the first instruction.\n"
3327 set_cmd_completer (c
, filename_completer
);
3329 add_com ("interrupt", class_run
, interrupt_command
,
3330 _("Interrupt the execution of the debugged program.\n\
3331 If non-stop mode is enabled, interrupt only the current thread,\n\
3332 otherwise all the threads in the program are stopped. To \n\
3333 interrupt all running threads in non-stop mode, use the -a option."));
3335 cmd_list_element
*info_registers_cmd
3336 = add_info ("registers", info_registers_command
, _("\
3337 List of integer registers and their contents, for selected stack frame.\n\
3338 One or more register names as argument means describe the given registers.\n\
3339 One or more register group names as argument means describe the registers\n\
3340 in the named register groups."));
3341 add_info_alias ("r", info_registers_cmd
, 1);
3342 set_cmd_completer (info_registers_cmd
, reg_or_group_completer
);
3344 c
= add_info ("all-registers", info_all_registers_command
, _("\
3345 List of all registers and their contents, for selected stack frame.\n\
3346 One or more register names as argument means describe the given registers.\n\
3347 One or more register group names as argument means describe the registers\n\
3348 in the named register groups."));
3349 set_cmd_completer (c
, reg_or_group_completer
);
3351 add_info ("program", info_program_command
,
3352 _("Execution status of the program."));
3354 add_info ("float", info_float_command
,
3355 _("Print the status of the floating point unit."));
3357 add_info ("vector", info_vector_command
,
3358 _("Print the status of the vector unit."));
3360 add_prefix_cmd ("proc", class_info
, info_proc_cmd
,
3362 Show additional information about a process.\n\
3363 Specify any process id, or use the program being debugged by default."),
3365 1/*allow-unknown*/, &infolist
);
3367 add_cmd ("mappings", class_info
, info_proc_cmd_mappings
, _("\
3368 List memory regions mapped by the specified process."),
3369 &info_proc_cmdlist
);
3371 add_cmd ("stat", class_info
, info_proc_cmd_stat
, _("\
3372 List process info from /proc/PID/stat."),
3373 &info_proc_cmdlist
);
3375 add_cmd ("status", class_info
, info_proc_cmd_status
, _("\
3376 List process info from /proc/PID/status."),
3377 &info_proc_cmdlist
);
3379 add_cmd ("cwd", class_info
, info_proc_cmd_cwd
, _("\
3380 List current working directory of the specified process."),
3381 &info_proc_cmdlist
);
3383 add_cmd ("cmdline", class_info
, info_proc_cmd_cmdline
, _("\
3384 List command line arguments of the specified process."),
3385 &info_proc_cmdlist
);
3387 add_cmd ("exe", class_info
, info_proc_cmd_exe
, _("\
3388 List absolute filename for executable of the specified process."),
3389 &info_proc_cmdlist
);
3391 add_cmd ("files", class_info
, info_proc_cmd_files
, _("\
3392 List files opened by the specified process."),
3393 &info_proc_cmdlist
);
3395 add_cmd ("all", class_info
, info_proc_cmd_all
, _("\
3396 List all available info about the specified process."),
3397 &info_proc_cmdlist
);
3399 add_setshow_boolean_cmd ("finish", class_support
,
3401 Set whether `finish' prints the return value."), _("\
3402 Show whether `finish' prints the return value."), nullptr,
3405 &setprintlist
, &showprintlist
);