1 /* Memory-access and commands for "inferior" process, for GDB.
3 Copyright (C) 1986-2021 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 #include "arch-utils.h"
27 #include "gdbsupport/environ.h"
35 #include "completer.h"
38 #include "reggroups.h"
42 #include "observable.h"
43 #include "target-descriptions.h"
44 #include "user-regs.h"
45 #include "gdbthread.h"
47 #include "inline-frame.h"
48 #include "tracepoint.h"
51 #include "thread-fsm.h"
55 #include "gdbsupport/gdb_optional.h"
57 #include "cli/cli-style.h"
59 /* Local functions: */
61 static void until_next_command (int);
63 static void step_1 (int, int, const char *);
65 #define ERROR_NO_INFERIOR \
66 if (!target_has_execution ()) error (_("The program is not being run."));
68 /* Scratch area where string containing arguments to give to the
69 program will be stored by 'set args'. As soon as anything is
70 stored, notice_args_set will move it into per-inferior storage.
71 Arguments are separated by spaces. Empty string (pointer to '\0')
74 static char *inferior_args_scratch
;
76 /* Scratch area where the new cwd will be stored by 'set cwd'. */
78 static char *inferior_cwd_scratch
;
80 /* Scratch area where 'set inferior-tty' will store user-provided value.
81 We'll immediate copy it into per-inferior storage. */
83 static char *inferior_io_terminal_scratch
;
85 /* Pid of our debugged inferior, or 0 if no inferior now.
86 Since various parts of infrun.c test this to see whether there is a program
87 being debugged it should be nonzero (currently 3 is used) for remote
92 /* Nonzero if stopped due to completion of a stack dummy routine. */
94 enum stop_stack_kind stop_stack_dummy
;
96 /* Nonzero if stopped due to a random (unexpected) signal in inferior
99 int stopped_by_random_signal
;
104 set_inferior_tty_command (const char *args
, int from_tty
,
105 struct cmd_list_element
*c
)
107 /* CLI has assigned the user-provided value to inferior_io_terminal_scratch.
108 Now route it to current inferior. */
109 current_inferior ()->set_tty (inferior_io_terminal_scratch
);
113 show_inferior_tty_command (struct ui_file
*file
, int from_tty
,
114 struct cmd_list_element
*c
, const char *value
)
116 /* Note that we ignore the passed-in value in favor of computing it
118 const char *inferior_tty
= current_inferior ()->tty ();
120 if (inferior_tty
== nullptr)
122 fprintf_filtered (gdb_stdout
,
123 _("Terminal for future runs of program being debugged "
124 "is \"%s\".\n"), inferior_tty
);
128 set_inferior_args_vector (int argc
, char **argv
)
130 gdb::array_view
<char * const> args (argv
, argc
);
131 std::string n
= construct_inferior_arguments (args
);
132 current_inferior ()->set_args (std::move (n
));
135 /* Notice when `set args' is run. */
138 set_args_command (const char *args
, int from_tty
, struct cmd_list_element
*c
)
140 /* CLI has assigned the user-provided value to inferior_args_scratch.
141 Now route it to current inferior. */
142 current_inferior ()->set_args (inferior_args_scratch
);
145 /* Notice when `show args' is run. */
148 show_args_command (struct ui_file
*file
, int from_tty
,
149 struct cmd_list_element
*c
, const char *value
)
151 /* Note that we ignore the passed-in value in favor of computing it
153 deprecated_show_value_hack (file
, from_tty
, c
,
154 current_inferior ()->args ().c_str ());
157 /* See gdbsupport/common-inferior.h. */
162 return current_inferior ()->cwd ();
165 /* Handle the 'set cwd' command. */
168 set_cwd_command (const char *args
, int from_tty
, struct cmd_list_element
*c
)
170 current_inferior ()->set_cwd (inferior_cwd_scratch
);
173 /* Handle the 'show cwd' command. */
176 show_cwd_command (struct ui_file
*file
, int from_tty
,
177 struct cmd_list_element
*c
, const char *value
)
179 const std::string
&cwd
= current_inferior ()->cwd ();
182 fprintf_filtered (gdb_stdout
,
184 You have not set the inferior's current working directory.\n\
185 The inferior will inherit GDB's cwd if native debugging, or the remote\n\
186 server's cwd if remote debugging.\n"));
188 fprintf_filtered (gdb_stdout
,
189 _("Current working directory that will be used "
190 "when starting the inferior is \"%s\".\n"),
195 /* This function strips the '&' character (indicating background
196 execution) that is added as *the last* of the arguments ARGS of a
197 command. A copy of the incoming ARGS without the '&' is returned,
198 unless the resulting string after stripping is empty, in which case
199 NULL is returned. *BG_CHAR_P is an output boolean that indicates
200 whether the '&' character was found. */
202 static gdb::unique_xmalloc_ptr
<char>
203 strip_bg_char (const char *args
, int *bg_char_p
)
207 if (args
== NULL
|| *args
== '\0')
213 p
= args
+ strlen (args
);
217 while (p
> args
&& isspace (p
[-1]))
222 return gdb::unique_xmalloc_ptr
<char>
223 (savestring (args
, p
- args
));
225 return gdb::unique_xmalloc_ptr
<char> (nullptr);
229 return make_unique_xstrdup (args
);
232 /* Common actions to take after creating any sort of inferior, by any
233 means (running, attaching, connecting, et cetera). The target
234 should be stopped. */
237 post_create_inferior (int from_tty
)
240 /* Be sure we own the terminal in case write operations are performed. */
241 target_terminal::ours_for_output ();
243 /* If the target hasn't taken care of this already, do it now.
244 Targets which need to access registers during to_open,
245 to_create_inferior, or to_attach should do it earlier; but many
247 target_find_description ();
249 /* Now that we know the register layout, retrieve current PC. But
250 if the PC is unavailable (e.g., we're opening a core file with
251 missing registers info), ignore it. */
252 thread_info
*thr
= inferior_thread ();
254 thr
->set_stop_pc (0);
257 regcache
*rc
= get_thread_regcache (thr
);
258 thr
->set_stop_pc (regcache_read_pc (rc
));
260 catch (const gdb_exception_error
&ex
)
262 if (ex
.error
!= NOT_AVAILABLE_ERROR
)
266 if (current_program_space
->exec_bfd ())
268 const unsigned solib_add_generation
269 = current_program_space
->solib_add_generation
;
271 scoped_restore restore_in_initial_library_scan
272 = make_scoped_restore (¤t_inferior ()->in_initial_library_scan
,
275 /* Create the hooks to handle shared library load and unload
277 solib_create_inferior_hook (from_tty
);
279 if (current_program_space
->solib_add_generation
== solib_add_generation
)
281 /* The platform-specific hook should load initial shared libraries,
282 but didn't. FROM_TTY will be incorrectly 0 but such solib
283 targets should be fixed anyway. Call it only after the solib
284 target has been initialized by solib_create_inferior_hook. */
287 warning (_("platform-specific solib_create_inferior_hook did "
288 "not load initial shared libraries."));
290 /* If the solist is global across processes, there's no need to
292 if (!gdbarch_has_global_solist (target_gdbarch ()))
293 solib_add (NULL
, 0, auto_solib_add
);
297 /* If the user sets watchpoints before execution having started,
298 then she gets software watchpoints, because GDB can't know which
299 target will end up being pushed, or if it supports hardware
300 watchpoints or not. breakpoint_re_set takes care of promoting
301 watchpoints to hardware watchpoints if possible, however, if this
302 new inferior doesn't load shared libraries or we don't pull in
303 symbols from any other source on this target/arch,
304 breakpoint_re_set is never called. Call it now so that software
305 watchpoints get a chance to be promoted to hardware watchpoints
306 if the now pushed target supports hardware watchpoints. */
307 breakpoint_re_set ();
309 gdb::observers::inferior_created
.notify (current_inferior ());
312 /* Kill the inferior if already running. This function is designed
313 to be called when we are about to start the execution of the program
314 from the beginning. Ask the user to confirm that he wants to restart
315 the program being debugged when FROM_TTY is non-null. */
318 kill_if_already_running (int from_tty
)
320 if (inferior_ptid
!= null_ptid
&& target_has_execution ())
322 /* Bail out before killing the program if we will not be able to
324 target_require_runnable ();
327 && !query (_("The program being debugged has been started already.\n\
328 Start it from the beginning? ")))
329 error (_("Program not restarted."));
334 /* See inferior.h. */
337 prepare_execution_command (struct target_ops
*target
, int background
)
339 /* If we get a request for running in the bg but the target
340 doesn't support it, error out. */
341 if (background
&& !target
->can_async_p ())
342 error (_("Asynchronous execution not supported on this target."));
346 /* If we get a request for running in the fg, then we need to
347 simulate synchronous (fg) execution. Note no cleanup is
348 necessary for this. stdin is re-enabled whenever an error
349 reaches the top level. */
350 all_uis_on_sync_execution_starting ();
354 /* Determine how the new inferior will behave. */
358 /* Run program without any explicit stop during startup. */
361 /* Stop at the beginning of the program's main function. */
364 /* Stop at the first instruction of the program. */
365 RUN_STOP_AT_FIRST_INSN
368 /* Implement the "run" command. Force a stop during program start if
369 requested by RUN_HOW. */
372 run_command_1 (const char *args
, int from_tty
, enum run_how run_how
)
374 const char *exec_file
;
375 struct ui_out
*uiout
= current_uiout
;
376 struct target_ops
*run_target
;
381 scoped_disable_commit_resumed
disable_commit_resumed ("running");
383 kill_if_already_running (from_tty
);
385 init_wait_for_inferior ();
386 clear_breakpoint_hit_counts ();
388 /* Clean up any leftovers from other runs. Some other things from
389 this function should probably be moved into target_pre_inferior. */
390 target_pre_inferior (from_tty
);
392 /* The comment here used to read, "The exec file is re-read every
393 time we do a generic_mourn_inferior, so we just have to worry
394 about the symbol file." The `generic_mourn_inferior' function
395 gets called whenever the program exits. However, suppose the
396 program exits, and *then* the executable file changes? We need
397 to check again here. Since reopen_exec_file doesn't do anything
398 if the timestamp hasn't changed, I don't see the harm. */
402 gdb::unique_xmalloc_ptr
<char> stripped
= strip_bg_char (args
, &async_exec
);
403 args
= stripped
.get ();
405 /* Do validation and preparation before possibly changing anything
408 run_target
= find_run_target ();
410 prepare_execution_command (run_target
, async_exec
);
412 if (non_stop
&& !run_target
->supports_non_stop ())
413 error (_("The target does not support running in non-stop mode."));
415 /* Done. Can now set breakpoints, change inferior args, etc. */
417 /* Insert temporary breakpoint in main function if requested. */
418 if (run_how
== RUN_STOP_AT_MAIN
)
420 std::string arg
= string_printf ("-qualified %s", main_name ());
421 tbreak_command (arg
.c_str (), 0);
424 exec_file
= get_exec_file (0);
426 /* We keep symbols from add-symbol-file, on the grounds that the
427 user might want to add some symbols before running the program
428 (right?). But sometimes (dynamic loading where the user manually
429 introduces the new symbols with add-symbol-file), the code which
430 the symbols describe does not persist between runs. Currently
431 the user has to manually nuke all symbols between runs if they
432 want them to go away (PR 2207). This is probably reasonable. */
434 /* If there were other args, beside '&', process them. */
436 current_inferior ()->set_args (args
);
440 uiout
->field_string (NULL
, "Starting program");
443 uiout
->field_string ("execfile", exec_file
);
445 uiout
->field_string ("infargs", current_inferior ()->args ());
450 run_target
->create_inferior (exec_file
,
451 current_inferior ()->args (),
452 current_inferior ()->environment
.envp (),
454 /* to_create_inferior should push the target, so after this point we
455 shouldn't refer to run_target again. */
458 /* We're starting off a new process. When we get out of here, in
459 non-stop mode, finish the state of all threads of that process,
460 but leave other threads alone, as they may be stopped in internal
461 events --- the frontend shouldn't see them as stopped. In
462 all-stop, always finish the state of all threads, as we may be
463 resuming more than just the new process. */
464 process_stratum_target
*finish_target
;
468 finish_target
= current_inferior ()->process_target ();
469 finish_ptid
= ptid_t (current_inferior ()->pid
);
473 finish_target
= nullptr;
474 finish_ptid
= minus_one_ptid
;
476 scoped_finish_thread_state
finish_state (finish_target
, finish_ptid
);
478 /* Pass zero for FROM_TTY, because at this point the "run" command
479 has done its thing; now we are setting up the running program. */
480 post_create_inferior (0);
482 /* Queue a pending event so that the program stops immediately. */
483 if (run_how
== RUN_STOP_AT_FIRST_INSN
)
485 thread_info
*thr
= inferior_thread ();
486 target_waitstatus ws
;
487 ws
.kind
= TARGET_WAITKIND_STOPPED
;
488 ws
.value
.sig
= GDB_SIGNAL_0
;
489 thr
->set_pending_waitstatus (ws
);
492 /* Start the target running. Do not use -1 continuation as it would skip
493 breakpoint right at the entry point. */
494 proceed (regcache_read_pc (get_current_regcache ()), GDB_SIGNAL_0
);
496 /* Since there was no error, there's no need to finish the thread
498 finish_state
.release ();
500 disable_commit_resumed
.reset_and_commit ();
504 run_command (const char *args
, int from_tty
)
506 run_command_1 (args
, from_tty
, RUN_NORMAL
);
509 /* Start the execution of the program up until the beginning of the main
513 start_command (const char *args
, int from_tty
)
515 /* Some languages such as Ada need to search inside the program
516 minimal symbols for the location where to put the temporary
517 breakpoint before starting. */
518 if (!have_minimal_symbols ())
519 error (_("No symbol table loaded. Use the \"file\" command."));
521 /* Run the program until reaching the main procedure... */
522 run_command_1 (args
, from_tty
, RUN_STOP_AT_MAIN
);
525 /* Start the execution of the program stopping at the first
529 starti_command (const char *args
, int from_tty
)
531 run_command_1 (args
, from_tty
, RUN_STOP_AT_FIRST_INSN
);
535 proceed_thread_callback (struct thread_info
*thread
, void *arg
)
537 /* We go through all threads individually instead of compressing
538 into a single target `resume_all' request, because some threads
539 may be stopped in internal breakpoints/events, or stopped waiting
540 for its turn in the displaced stepping queue (that is, they are
541 running && !executing). The target side has no idea about why
542 the thread is stopped, so a `resume_all' command would resume too
543 much. If/when GDB gains a way to tell the target `hold this
544 thread stopped until I say otherwise', then we can optimize
546 if (thread
->state
!= THREAD_STOPPED
)
549 if (!thread
->inf
->has_execution ())
552 switch_to_thread (thread
);
553 clear_proceed_status (0);
554 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
);
559 ensure_valid_thread (void)
561 if (inferior_ptid
== null_ptid
562 || inferior_thread ()->state
== THREAD_EXITED
)
563 error (_("Cannot execute this command without a live selected thread."));
566 /* If the user is looking at trace frames, any resumption of execution
567 is likely to mix up recorded and live target data. So simply
568 disallow those commands. */
571 ensure_not_tfind_mode (void)
573 if (get_traceframe_number () >= 0)
574 error (_("Cannot execute this command while looking at trace frames."));
577 /* Throw an error indicating the current thread is running. */
580 error_is_running (void)
582 error (_("Cannot execute this command while "
583 "the selected thread is running."));
586 /* Calls error_is_running if the current thread is running. */
589 ensure_not_running (void)
591 if (inferior_thread ()->state
== THREAD_RUNNING
)
596 continue_1 (int all_threads
)
599 ensure_not_tfind_mode ();
601 if (non_stop
&& all_threads
)
603 /* Don't error out if the current thread is running, because
604 there may be other stopped threads. */
606 /* Backup current thread and selected frame and restore on scope
608 scoped_restore_current_thread restore_thread
;
610 iterate_over_threads (proceed_thread_callback
, NULL
);
612 if (current_ui
->prompt_state
== PROMPT_BLOCKED
)
614 /* If all threads in the target were already running,
615 proceed_thread_callback ends up never calling proceed,
616 and so nothing calls this to put the inferior's terminal
617 settings in effect and remove stdin from the event loop,
618 which we must when running a foreground command. E.g.:
622 <all threads are running now>
625 <no thread was resumed, but the inferior now owns the terminal>
627 target_terminal::inferior ();
632 ensure_valid_thread ();
633 ensure_not_running ();
634 clear_proceed_status (0);
635 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
);
639 /* continue [-a] [proceed-count] [&] */
642 continue_command (const char *args
, int from_tty
)
645 bool all_threads_p
= false;
649 /* Find out whether we must run in the background. */
650 gdb::unique_xmalloc_ptr
<char> stripped
= strip_bg_char (args
, &async_exec
);
651 args
= stripped
.get ();
655 if (startswith (args
, "-a"))
657 all_threads_p
= true;
658 args
+= sizeof ("-a") - 1;
664 if (!non_stop
&& all_threads_p
)
665 error (_("`-a' is meaningless in all-stop mode."));
667 if (args
!= NULL
&& all_threads_p
)
668 error (_("Can't resume all threads and specify "
669 "proceed count simultaneously."));
671 /* If we have an argument left, set proceed count of breakpoint we
678 struct thread_info
*tp
;
681 tp
= inferior_thread ();
684 process_stratum_target
*last_target
;
687 get_last_target_status (&last_target
, &last_ptid
, nullptr);
688 tp
= find_thread_ptid (last_target
, last_ptid
);
691 bs
= tp
->control
.stop_bpstat
;
693 while ((stat
= bpstat_num (&bs
, &num
)) != 0)
696 set_ignore_count (num
,
697 parse_and_eval_long (args
) - 1,
699 /* set_ignore_count prints a message ending with a period.
700 So print two spaces before "Continuing.". */
702 printf_filtered (" ");
706 if (!stopped
&& from_tty
)
709 ("Not stopped at any breakpoint; argument ignored.\n");
714 ensure_not_tfind_mode ();
716 if (!non_stop
|| !all_threads_p
)
718 ensure_valid_thread ();
719 ensure_not_running ();
722 prepare_execution_command (current_inferior ()->top_target (), async_exec
);
725 printf_filtered (_("Continuing.\n"));
727 continue_1 (all_threads_p
);
730 /* Record in TP the starting point of a "step" or "next" command. */
733 set_step_frame (thread_info
*tp
)
735 /* This can be removed once this function no longer implicitly relies on the
736 inferior_ptid value. */
737 gdb_assert (inferior_ptid
== tp
->ptid
);
739 frame_info
*frame
= get_current_frame ();
741 symtab_and_line sal
= find_frame_sal (frame
);
742 set_step_info (tp
, frame
, sal
);
744 CORE_ADDR pc
= get_frame_pc (frame
);
745 tp
->control
.step_start_function
= find_pc_function (pc
);
748 /* Step until outside of current statement. */
751 step_command (const char *count_string
, int from_tty
)
753 step_1 (0, 0, count_string
);
756 /* Likewise, but skip over subroutine calls as if single instructions. */
759 next_command (const char *count_string
, int from_tty
)
761 step_1 (1, 0, count_string
);
764 /* Likewise, but step only one instruction. */
767 stepi_command (const char *count_string
, int from_tty
)
769 step_1 (0, 1, count_string
);
773 nexti_command (const char *count_string
, int from_tty
)
775 step_1 (1, 1, count_string
);
778 /* Data for the FSM that manages the step/next/stepi/nexti
781 struct step_command_fsm
: public thread_fsm
783 /* How many steps left in a "step N"-like command. */
786 /* If true, this is a next/nexti, otherwise a step/stepi. */
787 int skip_subroutines
;
789 /* If true, this is a stepi/nexti, otherwise a step/step. */
792 explicit step_command_fsm (struct interp
*cmd_interp
)
793 : thread_fsm (cmd_interp
)
797 void clean_up (struct thread_info
*thread
) override
;
798 bool should_stop (struct thread_info
*thread
) override
;
799 enum async_reply_reason
do_async_reply_reason () override
;
802 /* Prepare for a step/next/etc. command. Any target resource
803 allocated here is undone in the FSM's clean_up method. */
806 step_command_fsm_prepare (struct step_command_fsm
*sm
,
807 int skip_subroutines
, int single_inst
,
808 int count
, struct thread_info
*thread
)
810 sm
->skip_subroutines
= skip_subroutines
;
811 sm
->single_inst
= single_inst
;
814 /* Leave the si command alone. */
815 if (!sm
->single_inst
|| sm
->skip_subroutines
)
816 set_longjmp_breakpoint (thread
, get_frame_id (get_current_frame ()));
818 thread
->control
.stepping_command
= 1;
821 static int prepare_one_step (thread_info
*, struct step_command_fsm
*sm
);
824 step_1 (int skip_subroutines
, int single_inst
, const char *count_string
)
828 struct thread_info
*thr
;
829 struct step_command_fsm
*step_sm
;
832 ensure_not_tfind_mode ();
833 ensure_valid_thread ();
834 ensure_not_running ();
836 gdb::unique_xmalloc_ptr
<char> stripped
837 = strip_bg_char (count_string
, &async_exec
);
838 count_string
= stripped
.get ();
840 prepare_execution_command (current_inferior ()->top_target (), async_exec
);
842 count
= count_string
? parse_and_eval_long (count_string
) : 1;
844 clear_proceed_status (1);
846 /* Setup the execution command state machine to handle all the COUNT
848 thr
= inferior_thread ();
849 step_sm
= new step_command_fsm (command_interp ());
850 thr
->thread_fsm
= step_sm
;
852 step_command_fsm_prepare (step_sm
, skip_subroutines
,
853 single_inst
, count
, thr
);
855 /* Do only one step for now, before returning control to the event
856 loop. Let the continuation figure out how many other steps we
857 need to do, and handle them one at the time, through
859 if (!prepare_one_step (thr
, step_sm
))
860 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
);
865 /* Stepped into an inline frame. Pretend that we've
867 thr
->thread_fsm
->clean_up (thr
);
868 proceeded
= normal_stop ();
870 inferior_event_handler (INF_EXEC_COMPLETE
);
871 all_uis_check_sync_execution_done ();
875 /* Implementation of the 'should_stop' FSM method for stepping
876 commands. Called after we are done with one step operation, to
877 check whether we need to step again, before we print the prompt and
878 return control to the user. If count is > 1, returns false, as we
879 will need to keep going. */
882 step_command_fsm::should_stop (struct thread_info
*tp
)
884 if (tp
->control
.stop_step
)
886 /* There are more steps to make, and we did stop due to
887 ending a stepping range. Do another step. */
889 return prepare_one_step (tp
, this);
897 /* Implementation of the 'clean_up' FSM method for stepping commands. */
900 step_command_fsm::clean_up (struct thread_info
*thread
)
902 if (!single_inst
|| skip_subroutines
)
903 delete_longjmp_breakpoint (thread
->global_num
);
906 /* Implementation of the 'async_reply_reason' FSM method for stepping
909 enum async_reply_reason
910 step_command_fsm::do_async_reply_reason ()
912 return EXEC_ASYNC_END_STEPPING_RANGE
;
915 /* Prepare for one step in "step N". The actual target resumption is
916 done by the caller. Return true if we're done and should thus
917 report a stop to the user. Returns false if the target needs to be
921 prepare_one_step (thread_info
*tp
, struct step_command_fsm
*sm
)
923 /* This can be removed once this function no longer implicitly relies on the
924 inferior_ptid value. */
925 gdb_assert (inferior_ptid
== tp
->ptid
);
929 struct frame_info
*frame
= get_current_frame ();
933 if (!sm
->single_inst
)
937 /* Step at an inlined function behaves like "down". */
938 if (!sm
->skip_subroutines
939 && inline_skipped_frames (tp
))
942 const char *fn
= NULL
;
946 /* Pretend that we've ran. */
947 resume_ptid
= user_visible_resume_ptid (1);
948 set_running (tp
->inf
->process_target (), resume_ptid
, true);
950 step_into_inline_frame (tp
);
952 frame
= get_current_frame ();
953 sal
= find_frame_sal (frame
);
954 sym
= get_frame_function (frame
);
957 fn
= sym
->print_name ();
960 || !function_name_is_marked_for_skip (fn
, sal
))
963 return prepare_one_step (tp
, sm
);
967 pc
= get_frame_pc (frame
);
968 find_pc_line_pc_range (pc
,
969 &tp
->control
.step_range_start
,
970 &tp
->control
.step_range_end
);
972 /* There's a problem in gcc (PR gcc/98780) that causes missing line
973 table entries, which results in a too large stepping range.
974 Use inlined_subroutine info to make the range more narrow. */
975 if (inline_skipped_frames (tp
) > 0)
977 symbol
*sym
= inline_skipped_symbol (tp
);
978 if (SYMBOL_CLASS (sym
) == LOC_BLOCK
)
980 const block
*block
= SYMBOL_BLOCK_VALUE (sym
);
981 if (BLOCK_END (block
) < tp
->control
.step_range_end
)
982 tp
->control
.step_range_end
= BLOCK_END (block
);
986 tp
->control
.may_range_step
= 1;
988 /* If we have no line info, switch to stepi mode. */
989 if (tp
->control
.step_range_end
== 0 && step_stop_if_no_debug
)
991 tp
->control
.step_range_start
= tp
->control
.step_range_end
= 1;
992 tp
->control
.may_range_step
= 0;
994 else if (tp
->control
.step_range_end
== 0)
998 if (find_pc_partial_function (pc
, &name
,
999 &tp
->control
.step_range_start
,
1000 &tp
->control
.step_range_end
) == 0)
1001 error (_("Cannot find bounds of current function"));
1003 target_terminal::ours_for_output ();
1004 printf_filtered (_("Single stepping until exit from function %s,"
1005 "\nwhich has no line number information.\n"),
1011 /* Say we are stepping, but stop after one insn whatever it does. */
1012 tp
->control
.step_range_start
= tp
->control
.step_range_end
= 1;
1013 if (!sm
->skip_subroutines
)
1015 Don't step over function calls, not even to functions lacking
1017 tp
->control
.step_over_calls
= STEP_OVER_NONE
;
1020 if (sm
->skip_subroutines
)
1021 tp
->control
.step_over_calls
= STEP_OVER_ALL
;
1027 sm
->set_finished ();
1032 /* Continue program at specified address. */
1035 jump_command (const char *arg
, int from_tty
)
1037 struct gdbarch
*gdbarch
= get_current_arch ();
1044 ensure_not_tfind_mode ();
1045 ensure_valid_thread ();
1046 ensure_not_running ();
1048 /* Find out whether we must run in the background. */
1049 gdb::unique_xmalloc_ptr
<char> stripped
= strip_bg_char (arg
, &async_exec
);
1050 arg
= stripped
.get ();
1052 prepare_execution_command (current_inferior ()->top_target (), async_exec
);
1055 error_no_arg (_("starting address"));
1057 std::vector
<symtab_and_line
> sals
1058 = decode_line_with_last_displayed (arg
, DECODE_LINE_FUNFIRSTLINE
);
1059 if (sals
.size () != 1)
1060 error (_("Unreasonable jump request"));
1062 symtab_and_line
&sal
= sals
[0];
1064 if (sal
.symtab
== 0 && sal
.pc
== 0)
1065 error (_("No source file has been specified."));
1067 resolve_sal_pc (&sal
); /* May error out. */
1069 /* See if we are trying to jump to another function. */
1070 fn
= get_frame_function (get_current_frame ());
1071 sfn
= find_pc_function (sal
.pc
);
1072 if (fn
!= NULL
&& sfn
!= fn
)
1074 if (!query (_("Line %d is not in `%s'. Jump anyway? "), sal
.line
,
1077 error (_("Not confirmed."));
1084 struct obj_section
*section
;
1086 fixup_symbol_section (sfn
, 0);
1087 section
= sfn
->obj_section (symbol_objfile (sfn
));
1088 if (section_is_overlay (section
)
1089 && !section_is_mapped (section
))
1091 if (!query (_("WARNING!!! Destination is in "
1092 "unmapped overlay! Jump anyway? ")))
1094 error (_("Not confirmed."));
1104 printf_filtered (_("Continuing at "));
1105 fputs_filtered (paddress (gdbarch
, addr
), gdb_stdout
);
1106 printf_filtered (".\n");
1109 clear_proceed_status (0);
1110 proceed (addr
, GDB_SIGNAL_0
);
1113 /* Continue program giving it specified signal. */
1116 signal_command (const char *signum_exp
, int from_tty
)
1118 enum gdb_signal oursig
;
1121 dont_repeat (); /* Too dangerous. */
1123 ensure_not_tfind_mode ();
1124 ensure_valid_thread ();
1125 ensure_not_running ();
1127 /* Find out whether we must run in the background. */
1128 gdb::unique_xmalloc_ptr
<char> stripped
1129 = strip_bg_char (signum_exp
, &async_exec
);
1130 signum_exp
= stripped
.get ();
1132 prepare_execution_command (current_inferior ()->top_target (), async_exec
);
1135 error_no_arg (_("signal number"));
1137 /* It would be even slicker to make signal names be valid expressions,
1138 (the type could be "enum $signal" or some such), then the user could
1139 assign them to convenience variables. */
1140 oursig
= gdb_signal_from_name (signum_exp
);
1142 if (oursig
== GDB_SIGNAL_UNKNOWN
)
1144 /* No, try numeric. */
1145 int num
= parse_and_eval_long (signum_exp
);
1148 oursig
= GDB_SIGNAL_0
;
1150 oursig
= gdb_signal_from_command (num
);
1153 /* Look for threads other than the current that this command ends up
1154 resuming too (due to schedlock off), and warn if they'll get a
1155 signal delivered. "signal 0" is used to suppress a previous
1156 signal, but if the current thread is no longer the one that got
1157 the signal, then the user is potentially suppressing the signal
1158 of the wrong thread. */
1161 int must_confirm
= 0;
1163 /* This indicates what will be resumed. Either a single thread,
1164 a whole process, or all threads of all processes. */
1165 ptid_t resume_ptid
= user_visible_resume_ptid (0);
1166 process_stratum_target
*resume_target
1167 = user_visible_resume_target (resume_ptid
);
1169 thread_info
*current
= inferior_thread ();
1171 for (thread_info
*tp
: all_non_exited_threads (resume_target
, resume_ptid
))
1176 if (tp
->stop_signal () != GDB_SIGNAL_0
1177 && signal_pass_state (tp
->stop_signal ()))
1180 printf_unfiltered (_("Note:\n"));
1181 printf_unfiltered (_(" Thread %s previously stopped with signal %s, %s.\n"),
1182 print_thread_id (tp
),
1183 gdb_signal_to_name (tp
->stop_signal ()),
1184 gdb_signal_to_string (tp
->stop_signal ()));
1190 && !query (_("Continuing thread %s (the current thread) with specified signal will\n"
1191 "still deliver the signals noted above to their respective threads.\n"
1192 "Continue anyway? "),
1193 print_thread_id (inferior_thread ())))
1194 error (_("Not confirmed."));
1199 if (oursig
== GDB_SIGNAL_0
)
1200 printf_filtered (_("Continuing with no signal.\n"));
1202 printf_filtered (_("Continuing with signal %s.\n"),
1203 gdb_signal_to_name (oursig
));
1206 clear_proceed_status (0);
1207 proceed ((CORE_ADDR
) -1, oursig
);
1210 /* Queue a signal to be delivered to the current thread. */
1213 queue_signal_command (const char *signum_exp
, int from_tty
)
1215 enum gdb_signal oursig
;
1216 struct thread_info
*tp
;
1219 ensure_not_tfind_mode ();
1220 ensure_valid_thread ();
1221 ensure_not_running ();
1223 if (signum_exp
== NULL
)
1224 error_no_arg (_("signal number"));
1226 /* It would be even slicker to make signal names be valid expressions,
1227 (the type could be "enum $signal" or some such), then the user could
1228 assign them to convenience variables. */
1229 oursig
= gdb_signal_from_name (signum_exp
);
1231 if (oursig
== GDB_SIGNAL_UNKNOWN
)
1233 /* No, try numeric. */
1234 int num
= parse_and_eval_long (signum_exp
);
1237 oursig
= GDB_SIGNAL_0
;
1239 oursig
= gdb_signal_from_command (num
);
1242 if (oursig
!= GDB_SIGNAL_0
1243 && !signal_pass_state (oursig
))
1244 error (_("Signal handling set to not pass this signal to the program."));
1246 tp
= inferior_thread ();
1247 tp
->set_stop_signal (oursig
);
1250 /* Data for the FSM that manages the until (with no argument)
1253 struct until_next_fsm
: public thread_fsm
1255 /* The thread that as current when the command was executed. */
1258 until_next_fsm (struct interp
*cmd_interp
, int thread
)
1259 : thread_fsm (cmd_interp
),
1264 bool should_stop (struct thread_info
*thread
) override
;
1265 void clean_up (struct thread_info
*thread
) override
;
1266 enum async_reply_reason
do_async_reply_reason () override
;
1269 /* Implementation of the 'should_stop' FSM method for the until (with
1273 until_next_fsm::should_stop (struct thread_info
*tp
)
1275 if (tp
->control
.stop_step
)
1281 /* Implementation of the 'clean_up' FSM method for the until (with no
1285 until_next_fsm::clean_up (struct thread_info
*thread
)
1287 delete_longjmp_breakpoint (thread
->global_num
);
1290 /* Implementation of the 'async_reply_reason' FSM method for the until
1291 (with no arg) command. */
1293 enum async_reply_reason
1294 until_next_fsm::do_async_reply_reason ()
1296 return EXEC_ASYNC_END_STEPPING_RANGE
;
1299 /* Proceed until we reach a different source line with pc greater than
1300 our current one or exit the function. We skip calls in both cases.
1302 Note that eventually this command should probably be changed so
1303 that only source lines are printed out when we hit the breakpoint
1304 we set. This may involve changes to wait_for_inferior and the
1305 proceed status code. */
1308 until_next_command (int from_tty
)
1310 struct frame_info
*frame
;
1312 struct symbol
*func
;
1313 struct symtab_and_line sal
;
1314 struct thread_info
*tp
= inferior_thread ();
1315 int thread
= tp
->global_num
;
1316 struct until_next_fsm
*sm
;
1318 clear_proceed_status (0);
1319 set_step_frame (tp
);
1321 frame
= get_current_frame ();
1323 /* Step until either exited from this function or greater
1324 than the current line (if in symbolic section) or pc (if
1327 pc
= get_frame_pc (frame
);
1328 func
= find_pc_function (pc
);
1332 struct bound_minimal_symbol msymbol
= lookup_minimal_symbol_by_pc (pc
);
1334 if (msymbol
.minsym
== NULL
)
1335 error (_("Execution is not within a known function."));
1337 tp
->control
.step_range_start
= BMSYMBOL_VALUE_ADDRESS (msymbol
);
1338 /* The upper-bound of step_range is exclusive. In order to make PC
1339 within the range, set the step_range_end with PC + 1. */
1340 tp
->control
.step_range_end
= pc
+ 1;
1344 sal
= find_pc_line (pc
, 0);
1346 tp
->control
.step_range_start
= BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (func
));
1347 tp
->control
.step_range_end
= sal
.end
;
1349 tp
->control
.may_range_step
= 1;
1351 tp
->control
.step_over_calls
= STEP_OVER_ALL
;
1353 set_longjmp_breakpoint (tp
, get_frame_id (frame
));
1354 delete_longjmp_breakpoint_cleanup
lj_deleter (thread
);
1356 sm
= new until_next_fsm (command_interp (), tp
->global_num
);
1357 tp
->thread_fsm
= sm
;
1358 lj_deleter
.release ();
1360 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
);
1364 until_command (const char *arg
, int from_tty
)
1369 ensure_not_tfind_mode ();
1370 ensure_valid_thread ();
1371 ensure_not_running ();
1373 /* Find out whether we must run in the background. */
1374 gdb::unique_xmalloc_ptr
<char> stripped
= strip_bg_char (arg
, &async_exec
);
1375 arg
= stripped
.get ();
1377 prepare_execution_command (current_inferior ()->top_target (), async_exec
);
1380 until_break_command (arg
, from_tty
, 0);
1382 until_next_command (from_tty
);
1386 advance_command (const char *arg
, int from_tty
)
1391 ensure_not_tfind_mode ();
1392 ensure_valid_thread ();
1393 ensure_not_running ();
1396 error_no_arg (_("a location"));
1398 /* Find out whether we must run in the background. */
1399 gdb::unique_xmalloc_ptr
<char> stripped
= strip_bg_char (arg
, &async_exec
);
1400 arg
= stripped
.get ();
1402 prepare_execution_command (current_inferior ()->top_target (), async_exec
);
1404 until_break_command (arg
, from_tty
, 1);
1407 /* Return the value of the result of a function at the end of a 'finish'
1408 command/BP. DTOR_DATA (if not NULL) can represent inferior registers
1409 right after an inferior call has finished. */
1412 get_return_value (struct value
*function
, struct type
*value_type
)
1414 regcache
*stop_regs
= get_current_regcache ();
1415 struct gdbarch
*gdbarch
= stop_regs
->arch ();
1416 struct value
*value
;
1418 value_type
= check_typedef (value_type
);
1419 gdb_assert (value_type
->code () != TYPE_CODE_VOID
);
1421 /* FIXME: 2003-09-27: When returning from a nested inferior function
1422 call, it's possible (with no help from the architecture vector)
1423 to locate and return/print a "struct return" value. This is just
1424 a more complicated case of what is already being done in the
1425 inferior function call code. In fact, when inferior function
1426 calls are made async, this will likely be made the norm. */
1428 switch (gdbarch_return_value (gdbarch
, function
, value_type
,
1431 case RETURN_VALUE_REGISTER_CONVENTION
:
1432 case RETURN_VALUE_ABI_RETURNS_ADDRESS
:
1433 case RETURN_VALUE_ABI_PRESERVES_ADDRESS
:
1434 value
= allocate_value (value_type
);
1435 gdbarch_return_value (gdbarch
, function
, value_type
, stop_regs
,
1436 value_contents_raw (value
), NULL
);
1438 case RETURN_VALUE_STRUCT_CONVENTION
:
1442 internal_error (__FILE__
, __LINE__
, _("bad switch"));
1448 /* The captured function return value/type and its position in the
1451 struct return_value_info
1453 /* The captured return value. May be NULL if we weren't able to
1454 retrieve it. See get_return_value. */
1455 struct value
*value
;
1457 /* The return type. In some cases, we'll not be able extract the
1458 return value, but we always know the type. */
1461 /* If we captured a value, this is the value history index. */
1462 int value_history_index
;
1465 /* Helper for print_return_value. */
1468 print_return_value_1 (struct ui_out
*uiout
, struct return_value_info
*rv
)
1470 if (rv
->value
!= NULL
)
1472 struct value_print_options opts
;
1475 uiout
->text ("Value returned is ");
1476 uiout
->field_fmt ("gdb-result-var", "$%d",
1477 rv
->value_history_index
);
1478 uiout
->text (" = ");
1479 get_user_print_options (&opts
);
1481 if (opts
.finish_print
)
1484 value_print (rv
->value
, &stb
, &opts
);
1485 uiout
->field_stream ("return-value", stb
);
1488 uiout
->field_string ("return-value", _("<not displayed>"),
1489 metadata_style
.style ());
1494 std::string type_name
= type_to_string (rv
->type
);
1495 uiout
->text ("Value returned has type: ");
1496 uiout
->field_string ("return-type", type_name
);
1498 uiout
->text (" Cannot determine contents\n");
1502 /* Print the result of a function at the end of a 'finish' command.
1503 RV points at an object representing the captured return value/type
1504 and its position in the value history. */
1507 print_return_value (struct ui_out
*uiout
, struct return_value_info
*rv
)
1509 if (rv
->type
== NULL
1510 || check_typedef (rv
->type
)->code () == TYPE_CODE_VOID
)
1515 /* print_return_value_1 can throw an exception in some
1516 circumstances. We need to catch this so that we still
1517 delete the breakpoint. */
1518 print_return_value_1 (uiout
, rv
);
1520 catch (const gdb_exception
&ex
)
1522 exception_print (gdb_stdout
, ex
);
1526 /* Data for the FSM that manages the finish command. */
1528 struct finish_command_fsm
: public thread_fsm
1530 /* The momentary breakpoint set at the function's return address in
1532 breakpoint_up breakpoint
;
1534 /* The function that we're stepping out of. */
1535 struct symbol
*function
= nullptr;
1537 /* If the FSM finishes successfully, this stores the function's
1539 struct return_value_info return_value_info
{};
1541 explicit finish_command_fsm (struct interp
*cmd_interp
)
1542 : thread_fsm (cmd_interp
)
1546 bool should_stop (struct thread_info
*thread
) override
;
1547 void clean_up (struct thread_info
*thread
) override
;
1548 struct return_value_info
*return_value () override
;
1549 enum async_reply_reason
do_async_reply_reason () override
;
1552 /* Implementation of the 'should_stop' FSM method for the finish
1553 commands. Detects whether the thread stepped out of the function
1554 successfully, and if so, captures the function's return value and
1555 marks the FSM finished. */
1558 finish_command_fsm::should_stop (struct thread_info
*tp
)
1560 struct return_value_info
*rv
= &return_value_info
;
1562 if (function
!= NULL
1563 && bpstat_find_breakpoint (tp
->control
.stop_bpstat
,
1564 breakpoint
.get ()) != NULL
)
1569 rv
->type
= TYPE_TARGET_TYPE (SYMBOL_TYPE (function
));
1570 if (rv
->type
== NULL
)
1571 internal_error (__FILE__
, __LINE__
,
1572 _("finish_command: function has no target type"));
1574 if (check_typedef (rv
->type
)->code () != TYPE_CODE_VOID
)
1578 func
= read_var_value (function
, NULL
, get_current_frame ());
1579 rv
->value
= get_return_value (func
, rv
->type
);
1580 if (rv
->value
!= NULL
)
1581 rv
->value_history_index
= record_latest_value (rv
->value
);
1584 else if (tp
->control
.stop_step
)
1586 /* Finishing from an inline frame, or reverse finishing. In
1587 either case, there's no way to retrieve the return value. */
1594 /* Implementation of the 'clean_up' FSM method for the finish
1598 finish_command_fsm::clean_up (struct thread_info
*thread
)
1600 breakpoint
.reset ();
1601 delete_longjmp_breakpoint (thread
->global_num
);
1604 /* Implementation of the 'return_value' FSM method for the finish
1607 struct return_value_info
*
1608 finish_command_fsm::return_value ()
1610 return &return_value_info
;
1613 /* Implementation of the 'async_reply_reason' FSM method for the
1616 enum async_reply_reason
1617 finish_command_fsm::do_async_reply_reason ()
1619 if (execution_direction
== EXEC_REVERSE
)
1620 return EXEC_ASYNC_END_STEPPING_RANGE
;
1622 return EXEC_ASYNC_FUNCTION_FINISHED
;
1625 /* finish_backward -- helper function for finish_command. */
1628 finish_backward (struct finish_command_fsm
*sm
)
1630 struct symtab_and_line sal
;
1631 struct thread_info
*tp
= inferior_thread ();
1633 CORE_ADDR func_addr
;
1635 pc
= get_frame_pc (get_current_frame ());
1637 if (find_pc_partial_function (pc
, NULL
, &func_addr
, NULL
) == 0)
1638 error (_("Cannot find bounds of current function"));
1640 sal
= find_pc_line (func_addr
, 0);
1642 tp
->control
.proceed_to_finish
= 1;
1643 /* Special case: if we're sitting at the function entry point,
1644 then all we need to do is take a reverse singlestep. We
1645 don't need to set a breakpoint, and indeed it would do us
1648 Note that this can only happen at frame #0, since there's
1649 no way that a function up the stack can have a return address
1650 that's equal to its entry point. */
1654 struct frame_info
*frame
= get_selected_frame (NULL
);
1655 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1657 /* Set a step-resume at the function's entry point. Once that's
1658 hit, we'll do one more step backwards. */
1659 symtab_and_line sr_sal
;
1661 sr_sal
.pspace
= get_frame_program_space (frame
);
1662 insert_step_resume_breakpoint_at_sal (gdbarch
,
1663 sr_sal
, null_frame_id
);
1665 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
);
1669 /* We're almost there -- we just need to back up by one more
1671 tp
->control
.step_range_start
= tp
->control
.step_range_end
= 1;
1672 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
);
1676 /* finish_forward -- helper function for finish_command. FRAME is the
1677 frame that called the function we're about to step out of. */
1680 finish_forward (struct finish_command_fsm
*sm
, struct frame_info
*frame
)
1682 struct frame_id frame_id
= get_frame_id (frame
);
1683 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1684 struct symtab_and_line sal
;
1685 struct thread_info
*tp
= inferior_thread ();
1687 sal
= find_pc_line (get_frame_pc (frame
), 0);
1688 sal
.pc
= get_frame_pc (frame
);
1690 sm
->breakpoint
= set_momentary_breakpoint (gdbarch
, sal
,
1691 get_stack_frame_id (frame
),
1694 /* set_momentary_breakpoint invalidates FRAME. */
1697 set_longjmp_breakpoint (tp
, frame_id
);
1699 /* We want to print return value, please... */
1700 tp
->control
.proceed_to_finish
= 1;
1702 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
);
1705 /* Skip frames for "finish". */
1707 static struct frame_info
*
1708 skip_finish_frames (struct frame_info
*frame
)
1710 struct frame_info
*start
;
1716 frame
= skip_tailcall_frames (frame
);
1720 frame
= skip_unwritable_frames (frame
);
1724 while (start
!= frame
);
1729 /* "finish": Set a temporary breakpoint at the place the selected
1730 frame will return to, then continue. */
1733 finish_command (const char *arg
, int from_tty
)
1735 struct frame_info
*frame
;
1737 struct finish_command_fsm
*sm
;
1738 struct thread_info
*tp
;
1741 ensure_not_tfind_mode ();
1742 ensure_valid_thread ();
1743 ensure_not_running ();
1745 /* Find out whether we must run in the background. */
1746 gdb::unique_xmalloc_ptr
<char> stripped
= strip_bg_char (arg
, &async_exec
);
1747 arg
= stripped
.get ();
1749 prepare_execution_command (current_inferior ()->top_target (), async_exec
);
1752 error (_("The \"finish\" command does not take any arguments."));
1754 frame
= get_prev_frame (get_selected_frame (_("No selected frame.")));
1756 error (_("\"finish\" not meaningful in the outermost frame."));
1758 clear_proceed_status (0);
1760 tp
= inferior_thread ();
1762 sm
= new finish_command_fsm (command_interp ());
1764 tp
->thread_fsm
= sm
;
1766 /* Finishing from an inline frame is completely different. We don't
1767 try to show the "return value" - no way to locate it. */
1768 if (get_frame_type (get_selected_frame (_("No selected frame.")))
1771 /* Claim we are stepping in the calling frame. An empty step
1772 range means that we will stop once we aren't in a function
1773 called by that frame. We don't use the magic "1" value for
1774 step_range_end, because then infrun will think this is nexti,
1775 and not step over the rest of this inlined function call. */
1776 set_step_info (tp
, frame
, {});
1777 tp
->control
.step_range_start
= get_frame_pc (frame
);
1778 tp
->control
.step_range_end
= tp
->control
.step_range_start
;
1779 tp
->control
.step_over_calls
= STEP_OVER_ALL
;
1781 /* Print info on the selected frame, including level number but not
1785 printf_filtered (_("Run till exit from "));
1786 print_stack_frame (get_selected_frame (NULL
), 1, LOCATION
, 0);
1789 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
);
1793 /* Find the function we will return from. */
1795 sm
->function
= find_pc_function (get_frame_pc (get_selected_frame (NULL
)));
1797 /* Print info on the selected frame, including level number but not
1801 if (execution_direction
== EXEC_REVERSE
)
1802 printf_filtered (_("Run back to call of "));
1805 if (sm
->function
!= NULL
&& TYPE_NO_RETURN (sm
->function
->type
)
1806 && !query (_("warning: Function %s does not return normally.\n"
1807 "Try to finish anyway? "),
1808 sm
->function
->print_name ()))
1809 error (_("Not confirmed."));
1810 printf_filtered (_("Run till exit from "));
1813 print_stack_frame (get_selected_frame (NULL
), 1, LOCATION
, 0);
1816 if (execution_direction
== EXEC_REVERSE
)
1817 finish_backward (sm
);
1820 frame
= skip_finish_frames (frame
);
1823 error (_("Cannot find the caller frame."));
1825 finish_forward (sm
, frame
);
1831 info_program_command (const char *args
, int from_tty
)
1836 process_stratum_target
*proc_target
;
1838 if (!target_has_execution ())
1840 printf_filtered (_("The program being debugged is not being run.\n"));
1846 ptid
= inferior_ptid
;
1847 proc_target
= current_inferior ()->process_target ();
1850 get_last_target_status (&proc_target
, &ptid
, nullptr);
1852 if (ptid
== null_ptid
|| ptid
== minus_one_ptid
)
1853 error (_("No selected thread."));
1855 thread_info
*tp
= find_thread_ptid (proc_target
, ptid
);
1857 if (tp
->state
== THREAD_EXITED
)
1858 error (_("Invalid selected thread."));
1859 else if (tp
->state
== THREAD_RUNNING
)
1860 error (_("Selected thread is running."));
1862 bs
= tp
->control
.stop_bpstat
;
1863 stat
= bpstat_num (&bs
, &num
);
1865 target_files_info ();
1866 printf_filtered (_("Program stopped at %s.\n"),
1867 paddress (target_gdbarch (), tp
->stop_pc ()));
1868 if (tp
->control
.stop_step
)
1869 printf_filtered (_("It stopped after being stepped.\n"));
1872 /* There may be several breakpoints in the same place, so this
1873 isn't as strange as it seems. */
1878 printf_filtered (_("It stopped at a breakpoint "
1879 "that has since been deleted.\n"));
1882 printf_filtered (_("It stopped at breakpoint %d.\n"), num
);
1883 stat
= bpstat_num (&bs
, &num
);
1886 else if (tp
->stop_signal () != GDB_SIGNAL_0
)
1888 printf_filtered (_("It stopped with signal %s, %s.\n"),
1889 gdb_signal_to_name (tp
->stop_signal ()),
1890 gdb_signal_to_string (tp
->stop_signal ()));
1895 printf_filtered (_("Type \"info stack\" or \"info "
1896 "registers\" for more information.\n"));
1901 environment_info (const char *var
, int from_tty
)
1905 const char *val
= current_inferior ()->environment
.get (var
);
1909 puts_filtered (var
);
1910 puts_filtered (" = ");
1911 puts_filtered (val
);
1912 puts_filtered ("\n");
1916 puts_filtered ("Environment variable \"");
1917 puts_filtered (var
);
1918 puts_filtered ("\" not defined.\n");
1923 char **envp
= current_inferior ()->environment
.envp ();
1925 for (int idx
= 0; envp
[idx
] != NULL
; ++idx
)
1927 puts_filtered (envp
[idx
]);
1928 puts_filtered ("\n");
1934 set_environment_command (const char *arg
, int from_tty
)
1936 const char *p
, *val
;
1940 error_no_arg (_("environment variable and value"));
1942 /* Find separation between variable name and value. */
1943 p
= (char *) strchr (arg
, '=');
1944 val
= (char *) strchr (arg
, ' ');
1946 if (p
!= 0 && val
!= 0)
1948 /* We have both a space and an equals. If the space is before the
1949 equals, walk forward over the spaces til we see a nonspace
1950 (possibly the equals). */
1955 /* Now if the = is after the char following the spaces,
1956 take the char following the spaces. */
1960 else if (val
!= 0 && p
== 0)
1964 error_no_arg (_("environment variable to set"));
1966 if (p
== 0 || p
[1] == 0)
1970 p
= arg
+ strlen (arg
); /* So that savestring below will work. */
1974 /* Not setting variable value to null. */
1976 while (*val
== ' ' || *val
== '\t')
1980 while (p
!= arg
&& (p
[-1] == ' ' || p
[-1] == '\t'))
1983 std::string
var (arg
, p
- arg
);
1986 printf_filtered (_("Setting environment variable "
1987 "\"%s\" to null value.\n"),
1989 current_inferior ()->environment
.set (var
.c_str (), "");
1992 current_inferior ()->environment
.set (var
.c_str (), val
);
1996 unset_environment_command (const char *var
, int from_tty
)
2000 /* If there is no argument, delete all environment variables.
2001 Ask for confirmation if reading from the terminal. */
2002 if (!from_tty
|| query (_("Delete all environment variables? ")))
2003 current_inferior ()->environment
.clear ();
2006 current_inferior ()->environment
.unset (var
);
2009 /* Handle the execution path (PATH variable). */
2011 static const char path_var_name
[] = "PATH";
2014 path_info (const char *args
, int from_tty
)
2016 puts_filtered ("Executable and object file path: ");
2017 puts_filtered (current_inferior ()->environment
.get (path_var_name
));
2018 puts_filtered ("\n");
2021 /* Add zero or more directories to the front of the execution path. */
2024 path_command (const char *dirname
, int from_tty
)
2030 env
= current_inferior ()->environment
.get (path_var_name
);
2031 /* Can be null if path is not set. */
2034 exec_path
= xstrdup (env
);
2035 mod_path (dirname
, &exec_path
);
2036 current_inferior ()->environment
.set (path_var_name
, exec_path
);
2039 path_info (NULL
, from_tty
);
2044 pad_to_column (string_file
&stream
, int col
)
2046 /* At least one space must be printed to separate columns. */
2048 const int size
= stream
.size ();
2050 stream
.puts (n_spaces (col
- size
));
2053 /* Print out the register NAME with value VAL, to FILE, in the default
2057 default_print_one_register_info (struct ui_file
*file
,
2061 struct type
*regtype
= value_type (val
);
2062 int print_raw_format
;
2063 string_file format_stream
;
2066 value_column_1
= 15,
2067 /* Give enough room for "0x", 16 hex digits and two spaces in
2068 preceding column. */
2069 value_column_2
= value_column_1
+ 2 + 16 + 2,
2072 format_stream
.puts (name
);
2073 pad_to_column (format_stream
, value_column_1
);
2075 print_raw_format
= (value_entirely_available (val
)
2076 && !value_optimized_out (val
));
2078 /* If virtual format is floating, print it that way, and in raw
2080 if (regtype
->code () == TYPE_CODE_FLT
2081 || regtype
->code () == TYPE_CODE_DECFLOAT
)
2083 struct value_print_options opts
;
2084 const gdb_byte
*valaddr
= value_contents_for_printing (val
);
2085 enum bfd_endian byte_order
= type_byte_order (regtype
);
2087 get_user_print_options (&opts
);
2090 common_val_print (val
, &format_stream
, 0, &opts
, current_language
);
2092 if (print_raw_format
)
2094 pad_to_column (format_stream
, value_column_2
);
2095 format_stream
.puts ("(raw ");
2096 print_hex_chars (&format_stream
, valaddr
, TYPE_LENGTH (regtype
),
2098 format_stream
.putc (')');
2103 struct value_print_options opts
;
2105 /* Print the register in hex. */
2106 get_formatted_print_options (&opts
, 'x');
2108 common_val_print (val
, &format_stream
, 0, &opts
, current_language
);
2109 /* If not a vector register, print it also according to its
2111 if (print_raw_format
&& regtype
->is_vector () == 0)
2113 pad_to_column (format_stream
, value_column_2
);
2114 get_user_print_options (&opts
);
2116 common_val_print (val
, &format_stream
, 0, &opts
, current_language
);
2120 fputs_filtered (format_stream
.c_str (), file
);
2121 fprintf_filtered (file
, "\n");
2124 /* Print out the machine register regnum. If regnum is -1, print all
2125 registers (print_all == 1) or all non-float and non-vector
2126 registers (print_all == 0).
2128 For most machines, having all_registers_info() print the
2129 register(s) one per line is good enough. If a different format is
2130 required, (eg, for MIPS or Pyramid 90x, which both have lots of
2131 regs), or there is an existing convention for showing all the
2132 registers, define the architecture method PRINT_REGISTERS_INFO to
2133 provide that format. */
2136 default_print_registers_info (struct gdbarch
*gdbarch
,
2137 struct ui_file
*file
,
2138 struct frame_info
*frame
,
2139 int regnum
, int print_all
)
2142 const int numregs
= gdbarch_num_cooked_regs (gdbarch
);
2144 for (i
= 0; i
< numregs
; i
++)
2146 /* Decide between printing all regs, non-float / vector regs, or
2152 if (!gdbarch_register_reggroup_p (gdbarch
, i
, all_reggroup
))
2157 if (!gdbarch_register_reggroup_p (gdbarch
, i
, general_reggroup
))
2167 /* If the register name is empty, it is undefined for this
2168 processor, so don't display anything. */
2169 if (gdbarch_register_name (gdbarch
, i
) == NULL
2170 || *(gdbarch_register_name (gdbarch
, i
)) == '\0')
2173 default_print_one_register_info (file
,
2174 gdbarch_register_name (gdbarch
, i
),
2175 value_of_register (i
, frame
));
2180 registers_info (const char *addr_exp
, int fpregs
)
2182 struct frame_info
*frame
;
2183 struct gdbarch
*gdbarch
;
2185 if (!target_has_registers ())
2186 error (_("The program has no registers now."));
2187 frame
= get_selected_frame (NULL
);
2188 gdbarch
= get_frame_arch (frame
);
2192 gdbarch_print_registers_info (gdbarch
, gdb_stdout
,
2197 while (*addr_exp
!= '\0')
2202 /* Skip leading white space. */
2203 addr_exp
= skip_spaces (addr_exp
);
2205 /* Discard any leading ``$''. Check that there is something
2206 resembling a register following it. */
2207 if (addr_exp
[0] == '$')
2209 if (isspace ((*addr_exp
)) || (*addr_exp
) == '\0')
2210 error (_("Missing register name"));
2212 /* Find the start/end of this register name/num/group. */
2214 while ((*addr_exp
) != '\0' && !isspace ((*addr_exp
)))
2218 /* Figure out what we've found and display it. */
2220 /* A register name? */
2222 int regnum
= user_reg_map_name_to_regnum (gdbarch
, start
, end
- start
);
2226 /* User registers lie completely outside of the range of
2227 normal registers. Catch them early so that the target
2229 if (regnum
>= gdbarch_num_cooked_regs (gdbarch
))
2231 struct value
*regval
= value_of_user_reg (regnum
, frame
);
2232 const char *regname
= user_reg_map_regnum_to_name (gdbarch
,
2235 /* Print in the same fashion
2236 gdbarch_print_registers_info's default
2237 implementation prints. */
2238 default_print_one_register_info (gdb_stdout
,
2243 gdbarch_print_registers_info (gdbarch
, gdb_stdout
,
2244 frame
, regnum
, fpregs
);
2249 /* A register group? */
2251 struct reggroup
*group
;
2253 for (group
= reggroup_next (gdbarch
, NULL
);
2255 group
= reggroup_next (gdbarch
, group
))
2257 /* Don't bother with a length check. Should the user
2258 enter a short register group name, go with the first
2259 group that matches. */
2260 if (strncmp (start
, reggroup_name (group
), end
- start
) == 0)
2268 regnum
< gdbarch_num_cooked_regs (gdbarch
);
2271 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, group
))
2272 gdbarch_print_registers_info (gdbarch
,
2280 /* Nothing matched. */
2281 error (_("Invalid register `%.*s'"), (int) (end
- start
), start
);
2286 info_all_registers_command (const char *addr_exp
, int from_tty
)
2288 registers_info (addr_exp
, 1);
2292 info_registers_command (const char *addr_exp
, int from_tty
)
2294 registers_info (addr_exp
, 0);
2298 print_vector_info (struct ui_file
*file
,
2299 struct frame_info
*frame
, const char *args
)
2301 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
2303 if (gdbarch_print_vector_info_p (gdbarch
))
2304 gdbarch_print_vector_info (gdbarch
, file
, frame
, args
);
2308 int printed_something
= 0;
2310 for (regnum
= 0; regnum
< gdbarch_num_cooked_regs (gdbarch
); regnum
++)
2312 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, vector_reggroup
))
2314 printed_something
= 1;
2315 gdbarch_print_registers_info (gdbarch
, file
, frame
, regnum
, 1);
2318 if (!printed_something
)
2319 fprintf_filtered (file
, "No vector information\n");
2324 info_vector_command (const char *args
, int from_tty
)
2326 if (!target_has_registers ())
2327 error (_("The program has no registers now."));
2329 print_vector_info (gdb_stdout
, get_selected_frame (NULL
), args
);
2332 /* Kill the inferior process. Make us have no inferior. */
2335 kill_command (const char *arg
, int from_tty
)
2337 /* FIXME: This should not really be inferior_ptid (or target_has_execution).
2338 It should be a distinct flag that indicates that a target is active, cuz
2339 some targets don't have processes! */
2341 if (inferior_ptid
== null_ptid
)
2342 error (_("The program is not being run."));
2343 if (!query (_("Kill the program being debugged? ")))
2344 error (_("Not confirmed."));
2346 int pid
= current_inferior ()->pid
;
2347 /* Save the pid as a string before killing the inferior, since that
2348 may unpush the current target, and we need the string after. */
2349 std::string pid_str
= target_pid_to_str (ptid_t (pid
));
2350 int infnum
= current_inferior ()->num
;
2354 if (print_inferior_events
)
2355 printf_unfiltered (_("[Inferior %d (%s) killed]\n"),
2356 infnum
, pid_str
.c_str ());
2358 bfd_cache_close_all ();
2361 /* Used in `attach&' command. Proceed threads of inferior INF iff
2362 they stopped due to debugger request, and when they did, they
2363 reported a clean stop (GDB_SIGNAL_0). Do not proceed threads that
2364 have been explicitly been told to stop. */
2367 proceed_after_attach (inferior
*inf
)
2369 /* Don't error out if the current thread is running, because
2370 there may be other stopped threads. */
2372 /* Backup current thread and selected frame. */
2373 scoped_restore_current_thread restore_thread
;
2375 for (thread_info
*thread
: inf
->non_exited_threads ())
2376 if (!thread
->executing
2377 && !thread
->stop_requested
2378 && thread
->stop_signal () == GDB_SIGNAL_0
)
2380 switch_to_thread (thread
);
2381 clear_proceed_status (0);
2382 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
);
2386 /* See inferior.h. */
2389 setup_inferior (int from_tty
)
2391 struct inferior
*inferior
;
2393 inferior
= current_inferior ();
2394 inferior
->needs_setup
= 0;
2396 /* If no exec file is yet known, try to determine it from the
2398 if (get_exec_file (0) == NULL
)
2399 exec_file_locate_attach (inferior_ptid
.pid (), 1, from_tty
);
2402 reopen_exec_file ();
2406 /* Take any necessary post-attaching actions for this platform. */
2407 target_post_attach (inferior_ptid
.pid ());
2409 post_create_inferior (from_tty
);
2412 /* What to do after the first program stops after attaching. */
2413 enum attach_post_wait_mode
2415 /* Do nothing. Leaves threads as they are. */
2416 ATTACH_POST_WAIT_NOTHING
,
2418 /* Re-resume threads that are marked running. */
2419 ATTACH_POST_WAIT_RESUME
,
2421 /* Stop all threads. */
2422 ATTACH_POST_WAIT_STOP
,
2425 /* Called after we've attached to a process and we've seen it stop for
2426 the first time. Resume, stop, or don't touch the threads according
2430 attach_post_wait (int from_tty
, enum attach_post_wait_mode mode
)
2432 struct inferior
*inferior
;
2434 inferior
= current_inferior ();
2435 inferior
->control
.stop_soon
= NO_STOP_QUIETLY
;
2437 if (inferior
->needs_setup
)
2438 setup_inferior (from_tty
);
2440 if (mode
== ATTACH_POST_WAIT_RESUME
)
2442 /* The user requested an `attach&', so be sure to leave threads
2443 that didn't get a signal running. */
2445 /* Immediately resume all suspended threads of this inferior,
2446 and this inferior only. This should have no effect on
2447 already running threads. If a thread has been stopped with a
2448 signal, leave it be. */
2450 proceed_after_attach (inferior
);
2453 if (inferior_thread ()->stop_signal () == GDB_SIGNAL_0
)
2455 clear_proceed_status (0);
2456 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
);
2460 else if (mode
== ATTACH_POST_WAIT_STOP
)
2462 /* The user requested a plain `attach', so be sure to leave
2463 the inferior stopped. */
2465 /* At least the current thread is already stopped. */
2467 /* In all-stop, by definition, all threads have to be already
2468 stopped at this point. In non-stop, however, although the
2469 selected thread is stopped, others may still be executing.
2470 Be sure to explicitly stop all threads of the process. This
2471 should have no effect on already stopped threads. */
2473 target_stop (ptid_t (inferior
->pid
));
2474 else if (target_is_non_stop_p ())
2476 struct thread_info
*lowest
= inferior_thread ();
2478 stop_all_threads ();
2480 /* It's not defined which thread will report the attach
2481 stop. For consistency, always select the thread with
2482 lowest GDB number, which should be the main thread, if it
2484 for (thread_info
*thread
: current_inferior ()->non_exited_threads ())
2485 if (thread
->inf
->num
< lowest
->inf
->num
2486 || thread
->per_inf_num
< lowest
->per_inf_num
)
2489 switch_to_thread (lowest
);
2492 /* Tell the user/frontend where we're stopped. */
2494 if (deprecated_attach_hook
)
2495 deprecated_attach_hook ();
2499 /* "attach" command entry point. Takes a program started up outside
2500 of gdb and ``attaches'' to it. This stops it cold in its tracks
2501 and allows us to start debugging it. */
2504 attach_command (const char *args
, int from_tty
)
2507 struct target_ops
*attach_target
;
2508 struct inferior
*inferior
= current_inferior ();
2509 enum attach_post_wait_mode mode
;
2511 dont_repeat (); /* Not for the faint of heart */
2513 scoped_disable_commit_resumed
disable_commit_resumed ("attaching");
2515 if (gdbarch_has_global_solist (target_gdbarch ()))
2516 /* Don't complain if all processes share the same symbol
2519 else if (target_has_execution ())
2521 if (query (_("A program is being debugged already. Kill it? ")))
2524 error (_("Not killed."));
2527 /* Clean up any leftovers from other runs. Some other things from
2528 this function should probably be moved into target_pre_inferior. */
2529 target_pre_inferior (from_tty
);
2531 gdb::unique_xmalloc_ptr
<char> stripped
= strip_bg_char (args
, &async_exec
);
2532 args
= stripped
.get ();
2534 attach_target
= find_attach_target ();
2536 prepare_execution_command (attach_target
, async_exec
);
2538 if (non_stop
&& !attach_target
->supports_non_stop ())
2539 error (_("Cannot attach to this target in non-stop mode"));
2541 attach_target
->attach (args
, from_tty
);
2542 /* to_attach should push the target, so after this point we
2543 shouldn't refer to attach_target again. */
2544 attach_target
= NULL
;
2546 /* Set up the "saved terminal modes" of the inferior
2547 based on what modes we are starting it with. */
2548 target_terminal::init ();
2550 /* Install inferior's terminal modes. This may look like a no-op,
2551 as we've just saved them above, however, this does more than
2552 restore terminal settings:
2554 - installs a SIGINT handler that forwards SIGINT to the inferior.
2555 Otherwise a Ctrl-C pressed just while waiting for the initial
2556 stop would end up as a spurious Quit.
2558 - removes stdin from the event loop, which we need if attaching
2559 in the foreground, otherwise on targets that report an initial
2560 stop on attach (which are most) we'd process input/commands
2561 while we're in the event loop waiting for that stop. That is,
2562 before the attach continuation runs and the command is really
2564 target_terminal::inferior ();
2566 /* Set up execution context to know that we should return from
2567 wait_for_inferior as soon as the target reports a stop. */
2568 init_wait_for_inferior ();
2570 inferior
->needs_setup
= 1;
2572 if (target_is_non_stop_p ())
2574 /* If we find that the current thread isn't stopped, explicitly
2575 do so now, because we're going to install breakpoints and
2579 /* The user requested an `attach&'; stop just one thread. */
2580 target_stop (inferior_ptid
);
2582 /* The user requested an `attach', so stop all threads of this
2584 target_stop (ptid_t (inferior_ptid
.pid ()));
2587 /* Check for exec file mismatch, and let the user solve it. */
2588 validate_exec_file (from_tty
);
2590 mode
= async_exec
? ATTACH_POST_WAIT_RESUME
: ATTACH_POST_WAIT_STOP
;
2592 /* Some system don't generate traps when attaching to inferior.
2593 E.g. Mach 3 or GNU hurd. */
2594 if (!target_attach_no_wait ())
2596 /* Careful here. See comments in inferior.h. Basically some
2597 OSes don't ignore SIGSTOPs on continue requests anymore. We
2598 need a way for handle_inferior_event to reset the stop_signal
2599 variable after an attach, and this is what
2600 STOP_QUIETLY_NO_SIGSTOP is for. */
2601 inferior
->control
.stop_soon
= STOP_QUIETLY_NO_SIGSTOP
;
2603 /* Wait for stop. */
2604 inferior
->add_continuation ([=] ()
2606 attach_post_wait (from_tty
, mode
);
2609 /* Let infrun consider waiting for events out of this
2611 inferior
->process_target ()->threads_executing
= true;
2613 if (!target_is_async_p ())
2614 mark_infrun_async_event_handler ();
2618 attach_post_wait (from_tty
, mode
);
2620 disable_commit_resumed
.reset_and_commit ();
2623 /* We had just found out that the target was already attached to an
2624 inferior. PTID points at a thread of this new inferior, that is
2625 the most likely to be stopped right now, but not necessarily so.
2626 The new inferior is assumed to be already added to the inferior
2627 list at this point. If LEAVE_RUNNING, then leave the threads of
2628 this inferior running, except those we've explicitly seen reported
2632 notice_new_inferior (thread_info
*thr
, bool leave_running
, int from_tty
)
2634 enum attach_post_wait_mode mode
2635 = leave_running
? ATTACH_POST_WAIT_RESUME
: ATTACH_POST_WAIT_NOTHING
;
2637 gdb::optional
<scoped_restore_current_thread
> restore_thread
;
2639 if (inferior_ptid
!= null_ptid
)
2640 restore_thread
.emplace ();
2642 /* Avoid reading registers -- we haven't fetched the target
2644 switch_to_thread_no_regs (thr
);
2646 /* When we "notice" a new inferior we need to do all the things we
2647 would normally do if we had just attached to it. */
2651 struct inferior
*inferior
= current_inferior ();
2653 /* We're going to install breakpoints, and poke at memory,
2654 ensure that the inferior is stopped for a moment while we do
2656 target_stop (inferior_ptid
);
2658 inferior
->control
.stop_soon
= STOP_QUIETLY_REMOTE
;
2660 /* Wait for stop before proceeding. */
2661 inferior
->add_continuation ([=] ()
2663 attach_post_wait (from_tty
, mode
);
2669 attach_post_wait (from_tty
, mode
);
2674 * takes a program previously attached to and detaches it.
2675 * The program resumes execution and will no longer stop
2676 * on signals, etc. We better not have left any breakpoints
2677 * in the program or it'll die when it hits one. For this
2678 * to work, it may be necessary for the process to have been
2679 * previously attached. It *might* work if the program was
2680 * started via the normal ptrace (PTRACE_TRACEME).
2684 detach_command (const char *args
, int from_tty
)
2686 dont_repeat (); /* Not for the faint of heart. */
2688 if (inferior_ptid
== null_ptid
)
2689 error (_("The program is not being run."));
2691 scoped_disable_commit_resumed
disable_commit_resumed ("detaching");
2693 query_if_trace_running (from_tty
);
2695 disconnect_tracing ();
2697 /* Hold a strong reference to the target while (maybe)
2698 detaching the parent. Otherwise detaching could close the
2701 = target_ops_ref::new_reference (current_inferior ()->process_target ());
2703 /* Save this before detaching, since detaching may unpush the
2704 process_stratum target. */
2705 bool was_non_stop_p
= target_is_non_stop_p ();
2707 target_detach (current_inferior (), from_tty
);
2709 /* The current inferior process was just detached successfully. Get
2710 rid of breakpoints that no longer make sense. Note we don't do
2711 this within target_detach because that is also used when
2712 following child forks, and in that case we will want to transfer
2713 breakpoints to the child, not delete them. */
2714 breakpoint_init_inferior (inf_exited
);
2716 /* If the solist is global across inferiors, don't clear it when we
2717 detach from a single inferior. */
2718 if (!gdbarch_has_global_solist (target_gdbarch ()))
2719 no_shared_libraries (NULL
, from_tty
);
2721 if (deprecated_detach_hook
)
2722 deprecated_detach_hook ();
2724 if (!was_non_stop_p
)
2725 restart_after_all_stop_detach (as_process_stratum_target (target_ref
.get ()));
2727 disable_commit_resumed
.reset_and_commit ();
2730 /* Disconnect from the current target without resuming it (leaving it
2731 waiting for a debugger).
2733 We'd better not have left any breakpoints in the program or the
2734 next debugger will get confused. Currently only supported for some
2735 remote targets, since the normal attach mechanisms don't work on
2736 stopped processes on some native platforms (e.g. GNU/Linux). */
2739 disconnect_command (const char *args
, int from_tty
)
2741 dont_repeat (); /* Not for the faint of heart. */
2742 query_if_trace_running (from_tty
);
2743 disconnect_tracing ();
2744 target_disconnect (args
, from_tty
);
2745 no_shared_libraries (NULL
, from_tty
);
2746 init_thread_list ();
2747 if (deprecated_detach_hook
)
2748 deprecated_detach_hook ();
2751 /* Stop PTID in the current target, and tag the PTID threads as having
2752 been explicitly requested to stop. PTID can be a thread, a
2753 process, or minus_one_ptid, meaning all threads of all inferiors of
2754 the current target. */
2757 stop_current_target_threads_ns (ptid_t ptid
)
2761 /* Tag the thread as having been explicitly requested to stop, so
2762 other parts of gdb know not to resume this thread automatically,
2763 if it was stopped due to an internal event. Limit this to
2764 non-stop mode, as when debugging a multi-threaded application in
2765 all-stop mode, we will only get one stop event --- it's undefined
2766 which thread will report the event. */
2767 set_stop_requested (current_inferior ()->process_target (),
2771 /* See inferior.h. */
2774 interrupt_target_1 (bool all_threads
)
2776 scoped_disable_commit_resumed
disable_commit_resumed ("interrupting");
2782 scoped_restore_current_thread restore_thread
;
2784 for (inferior
*inf
: all_inferiors ())
2786 switch_to_inferior_no_thread (inf
);
2787 stop_current_target_threads_ns (minus_one_ptid
);
2791 stop_current_target_threads_ns (inferior_ptid
);
2794 target_interrupt ();
2796 disable_commit_resumed
.reset_and_commit ();
2800 Stop the execution of the target while running in async mode, in
2801 the background. In all-stop, stop the whole process. In non-stop
2802 mode, stop the current thread only by default, or stop all threads
2803 if the `-a' switch is used. */
2806 interrupt_command (const char *args
, int from_tty
)
2808 if (target_can_async_p ())
2810 int all_threads
= 0;
2812 dont_repeat (); /* Not for the faint of heart. */
2815 && startswith (args
, "-a"))
2818 if (!non_stop
&& all_threads
)
2819 error (_("-a is meaningless in all-stop mode."));
2821 interrupt_target_1 (all_threads
);
2825 /* See inferior.h. */
2828 default_print_float_info (struct gdbarch
*gdbarch
, struct ui_file
*file
,
2829 struct frame_info
*frame
, const char *args
)
2832 int printed_something
= 0;
2834 for (regnum
= 0; regnum
< gdbarch_num_cooked_regs (gdbarch
); regnum
++)
2836 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, float_reggroup
))
2838 printed_something
= 1;
2839 gdbarch_print_registers_info (gdbarch
, file
, frame
, regnum
, 1);
2842 if (!printed_something
)
2843 fprintf_filtered (file
, "No floating-point info "
2844 "available for this processor.\n");
2848 info_float_command (const char *args
, int from_tty
)
2850 struct frame_info
*frame
;
2852 if (!target_has_registers ())
2853 error (_("The program has no registers now."));
2855 frame
= get_selected_frame (NULL
);
2856 gdbarch_print_float_info (get_frame_arch (frame
), gdb_stdout
, frame
, args
);
2859 /* Implement `info proc' family of commands. */
2862 info_proc_cmd_1 (const char *args
, enum info_proc_what what
, int from_tty
)
2864 struct gdbarch
*gdbarch
= get_current_arch ();
2866 if (!target_info_proc (args
, what
))
2868 if (gdbarch_info_proc_p (gdbarch
))
2869 gdbarch_info_proc (gdbarch
, args
, what
);
2871 error (_("Not supported on this target."));
2875 /* Implement `info proc' when given without any further parameters. */
2878 info_proc_cmd (const char *args
, int from_tty
)
2880 info_proc_cmd_1 (args
, IP_MINIMAL
, from_tty
);
2883 /* Implement `info proc mappings'. */
2886 info_proc_cmd_mappings (const char *args
, int from_tty
)
2888 info_proc_cmd_1 (args
, IP_MAPPINGS
, from_tty
);
2891 /* Implement `info proc stat'. */
2894 info_proc_cmd_stat (const char *args
, int from_tty
)
2896 info_proc_cmd_1 (args
, IP_STAT
, from_tty
);
2899 /* Implement `info proc status'. */
2902 info_proc_cmd_status (const char *args
, int from_tty
)
2904 info_proc_cmd_1 (args
, IP_STATUS
, from_tty
);
2907 /* Implement `info proc cwd'. */
2910 info_proc_cmd_cwd (const char *args
, int from_tty
)
2912 info_proc_cmd_1 (args
, IP_CWD
, from_tty
);
2915 /* Implement `info proc cmdline'. */
2918 info_proc_cmd_cmdline (const char *args
, int from_tty
)
2920 info_proc_cmd_1 (args
, IP_CMDLINE
, from_tty
);
2923 /* Implement `info proc exe'. */
2926 info_proc_cmd_exe (const char *args
, int from_tty
)
2928 info_proc_cmd_1 (args
, IP_EXE
, from_tty
);
2931 /* Implement `info proc files'. */
2934 info_proc_cmd_files (const char *args
, int from_tty
)
2936 info_proc_cmd_1 (args
, IP_FILES
, from_tty
);
2939 /* Implement `info proc all'. */
2942 info_proc_cmd_all (const char *args
, int from_tty
)
2944 info_proc_cmd_1 (args
, IP_ALL
, from_tty
);
2947 /* Implement `show print finish'. */
2950 show_print_finish (struct ui_file
*file
, int from_tty
,
2951 struct cmd_list_element
*c
,
2954 fprintf_filtered (file
, _("\
2955 Printing of return value after `finish' is %s.\n"),
2960 /* This help string is used for the run, start, and starti commands.
2961 It is defined as a macro to prevent duplication. */
2963 #define RUN_ARGS_HELP \
2964 "You may specify arguments to give it.\n\
2965 Args may include \"*\", or \"[...]\"; they are expanded using the\n\
2966 shell that will start the program (specified by the \"$SHELL\" environment\n\
2967 variable). Input and output redirection with \">\", \"<\", or \">>\"\n\
2968 are also allowed.\n\
2970 With no arguments, uses arguments last specified (with \"run\" or \n\
2971 \"set args\"). To cancel previous arguments and run with no arguments,\n\
2972 use \"set args\" without arguments.\n\
2974 To start the inferior without using a shell, use \"set startup-with-shell off\"."
2976 void _initialize_infcmd ();
2978 _initialize_infcmd ()
2980 static struct cmd_list_element
*info_proc_cmdlist
;
2981 struct cmd_list_element
*c
= NULL
;
2982 const char *cmd_name
;
2984 /* Add the filename of the terminal connected to inferior I/O. */
2985 add_setshow_optional_filename_cmd ("inferior-tty", class_run
,
2986 &inferior_io_terminal_scratch
, _("\
2987 Set terminal for future runs of program being debugged."), _("\
2988 Show terminal for future runs of program being debugged."), _("\
2989 Usage: set inferior-tty [TTY]\n\n\
2990 If TTY is omitted, the default behavior of using the same terminal as GDB\n\
2992 set_inferior_tty_command
,
2993 show_inferior_tty_command
,
2994 &setlist
, &showlist
);
2995 cmd_name
= "inferior-tty";
2996 c
= lookup_cmd (&cmd_name
, setlist
, "", NULL
, -1, 1);
2997 gdb_assert (c
!= NULL
);
2998 add_alias_cmd ("tty", c
, class_run
, 0, &cmdlist
);
3001 add_setshow_string_noescape_cmd (cmd_name
, class_run
,
3002 &inferior_args_scratch
, _("\
3003 Set argument list to give program being debugged when it is started."), _("\
3004 Show argument list to give program being debugged when it is started."), _("\
3005 Follow this command with any number of args, to be passed to the program."),
3008 &setlist
, &showlist
);
3009 c
= lookup_cmd (&cmd_name
, setlist
, "", NULL
, -1, 1);
3010 gdb_assert (c
!= NULL
);
3011 set_cmd_completer (c
, filename_completer
);
3014 add_setshow_string_noescape_cmd (cmd_name
, class_run
,
3015 &inferior_cwd_scratch
, _("\
3016 Set the current working directory to be used when the inferior is started.\n\
3017 Changing this setting does not have any effect on inferiors that are\n\
3020 Show the current working directory that is used when the inferior is started."),
3022 Use this command to change the current working directory that will be used\n\
3023 when the inferior is started. This setting does not affect GDB's current\n\
3024 working directory."),
3027 &setlist
, &showlist
);
3028 c
= lookup_cmd (&cmd_name
, setlist
, "", NULL
, -1, 1);
3029 gdb_assert (c
!= NULL
);
3030 set_cmd_completer (c
, filename_completer
);
3032 c
= add_cmd ("environment", no_class
, environment_info
, _("\
3033 The environment to give the program, or one variable's value.\n\
3034 With an argument VAR, prints the value of environment variable VAR to\n\
3035 give the program being debugged. With no arguments, prints the entire\n\
3036 environment to be given to the program."), &showlist
);
3037 set_cmd_completer (c
, noop_completer
);
3039 add_basic_prefix_cmd ("unset", no_class
,
3040 _("Complement to certain \"set\" commands."),
3041 &unsetlist
, 0, &cmdlist
);
3043 c
= add_cmd ("environment", class_run
, unset_environment_command
, _("\
3044 Cancel environment variable VAR for the program.\n\
3045 This does not affect the program until the next \"run\" command."),
3047 set_cmd_completer (c
, noop_completer
);
3049 c
= add_cmd ("environment", class_run
, set_environment_command
, _("\
3050 Set environment variable value to give the program.\n\
3051 Arguments are VAR VALUE where VAR is variable name and VALUE is value.\n\
3052 VALUES of environment variables are uninterpreted strings.\n\
3053 This does not affect the program until the next \"run\" command."),
3055 set_cmd_completer (c
, noop_completer
);
3057 c
= add_com ("path", class_files
, path_command
, _("\
3058 Add directory DIR(s) to beginning of search path for object files.\n\
3059 $cwd in the path means the current working directory.\n\
3060 This path is equivalent to the $PATH shell variable. It is a list of\n\
3061 directories, separated by colons. These directories are searched to find\n\
3062 fully linked executable files and separately compiled object files as \
3064 set_cmd_completer (c
, filename_completer
);
3066 c
= add_cmd ("paths", no_class
, path_info
, _("\
3067 Current search path for finding object files.\n\
3068 $cwd in the path means the current working directory.\n\
3069 This path is equivalent to the $PATH shell variable. It is a list of\n\
3070 directories, separated by colons. These directories are searched to find\n\
3071 fully linked executable files and separately compiled object files as \
3074 set_cmd_completer (c
, noop_completer
);
3076 add_prefix_cmd ("kill", class_run
, kill_command
,
3077 _("Kill execution of program being debugged."),
3078 &killlist
, 0, &cmdlist
);
3080 add_com ("attach", class_run
, attach_command
, _("\
3081 Attach to a process or file outside of GDB.\n\
3082 This command attaches to another target, of the same type as your last\n\
3083 \"target\" command (\"info files\" will show your target stack).\n\
3084 The command may take as argument a process id or a device file.\n\
3085 For a process id, you must have permission to send the process a signal,\n\
3086 and it must have the same effective uid as the debugger.\n\
3087 When using \"attach\" with a process id, the debugger finds the\n\
3088 program running in the process, looking first in the current working\n\
3089 directory, or (if not found there) using the source file search path\n\
3090 (see the \"directory\" command). You can also use the \"file\" command\n\
3091 to specify the program, and to load its symbol table."));
3093 add_prefix_cmd ("detach", class_run
, detach_command
, _("\
3094 Detach a process or file previously attached.\n\
3095 If a process, it is no longer traced, and it continues its execution. If\n\
3096 you were debugging a file, the file is closed and gdb no longer accesses it."),
3097 &detachlist
, 0, &cmdlist
);
3099 add_com ("disconnect", class_run
, disconnect_command
, _("\
3100 Disconnect from a target.\n\
3101 The target will wait for another debugger to connect. Not available for\n\
3104 c
= add_com ("signal", class_run
, signal_command
, _("\
3105 Continue program with the specified signal.\n\
3106 Usage: signal SIGNAL\n\
3107 The SIGNAL argument is processed the same as the handle command.\n\
3109 An argument of \"0\" means continue the program without sending it a signal.\n\
3110 This is useful in cases where the program stopped because of a signal,\n\
3111 and you want to resume the program while discarding the signal.\n\
3113 In a multi-threaded program the signal is delivered to, or discarded from,\n\
3114 the current thread only."));
3115 set_cmd_completer (c
, signal_completer
);
3117 c
= add_com ("queue-signal", class_run
, queue_signal_command
, _("\
3118 Queue a signal to be delivered to the current thread when it is resumed.\n\
3119 Usage: queue-signal SIGNAL\n\
3120 The SIGNAL argument is processed the same as the handle command.\n\
3121 It is an error if the handling state of SIGNAL is \"nopass\".\n\
3123 An argument of \"0\" means remove any currently queued signal from\n\
3124 the current thread. This is useful in cases where the program stopped\n\
3125 because of a signal, and you want to resume it while discarding the signal.\n\
3127 In a multi-threaded program the signal is queued with, or discarded from,\n\
3128 the current thread only."));
3129 set_cmd_completer (c
, signal_completer
);
3131 cmd_list_element
*stepi_cmd
3132 = add_com ("stepi", class_run
, stepi_command
, _("\
3133 Step one instruction exactly.\n\
3135 Argument N means step N times (or till program stops for another \
3137 add_com_alias ("si", stepi_cmd
, class_run
, 0);
3139 cmd_list_element
*nexti_cmd
3140 = add_com ("nexti", class_run
, nexti_command
, _("\
3141 Step one instruction, but proceed through subroutine calls.\n\
3143 Argument N means step N times (or till program stops for another \
3145 add_com_alias ("ni", nexti_cmd
, class_run
, 0);
3147 cmd_list_element
*finish_cmd
3148 = add_com ("finish", class_run
, finish_command
, _("\
3149 Execute until selected stack frame returns.\n\
3151 Upon return, the value returned is printed and put in the value history."));
3152 add_com_alias ("fin", finish_cmd
, class_run
, 1);
3154 cmd_list_element
*next_cmd
3155 = add_com ("next", class_run
, next_command
, _("\
3156 Step program, proceeding through subroutine calls.\n\
3158 Unlike \"step\", if the current source line calls a subroutine,\n\
3159 this command does not enter the subroutine, but instead steps over\n\
3160 the call, in effect treating it as a single source line."));
3161 add_com_alias ("n", next_cmd
, class_run
, 1);
3163 cmd_list_element
*step_cmd
3164 = add_com ("step", class_run
, step_command
, _("\
3165 Step program until it reaches a different source line.\n\
3167 Argument N means step N times (or till program stops for another \
3169 add_com_alias ("s", step_cmd
, class_run
, 1);
3171 cmd_list_element
*until_cmd
3172 = add_com ("until", class_run
, until_command
, _("\
3173 Execute until past the current line or past a LOCATION.\n\
3174 Execute until the program reaches a source line greater than the current\n\
3175 or a specified location (same args as break command) within the current \
3177 set_cmd_completer (until_cmd
, location_completer
);
3178 add_com_alias ("u", until_cmd
, class_run
, 1);
3180 c
= add_com ("advance", class_run
, advance_command
, _("\
3181 Continue the program up to the given location (same form as args for break \
3183 Execution will also stop upon exit from the current stack frame."));
3184 set_cmd_completer (c
, location_completer
);
3186 cmd_list_element
*jump_cmd
3187 = add_com ("jump", class_run
, jump_command
, _("\
3188 Continue program being debugged at specified line or address.\n\
3189 Usage: jump LOCATION\n\
3190 Give as argument either LINENUM or *ADDR, where ADDR is an expression\n\
3191 for an address to start at."));
3192 set_cmd_completer (jump_cmd
, location_completer
);
3193 add_com_alias ("j", jump_cmd
, class_run
, 1);
3195 cmd_list_element
*continue_cmd
3196 = add_com ("continue", class_run
, continue_command
, _("\
3197 Continue program being debugged, after signal or breakpoint.\n\
3198 Usage: continue [N]\n\
3199 If proceeding from breakpoint, a number N may be used as an argument,\n\
3200 which means to set the ignore count of that breakpoint to N - 1 (so that\n\
3201 the breakpoint won't break until the Nth time it is reached).\n\
3203 If non-stop mode is enabled, continue only the current thread,\n\
3204 otherwise all the threads in the program are continued. To \n\
3205 continue all stopped threads in non-stop mode, use the -a option.\n\
3206 Specifying -a and an ignore count simultaneously is an error."));
3207 add_com_alias ("c", continue_cmd
, class_run
, 1);
3208 add_com_alias ("fg", continue_cmd
, class_run
, 1);
3210 cmd_list_element
*run_cmd
3211 = add_com ("run", class_run
, run_command
, _("\
3212 Start debugged program.\n"
3214 set_cmd_completer (run_cmd
, filename_completer
);
3215 add_com_alias ("r", run_cmd
, class_run
, 1);
3217 c
= add_com ("start", class_run
, start_command
, _("\
3218 Start the debugged program stopping at the beginning of the main procedure.\n"
3220 set_cmd_completer (c
, filename_completer
);
3222 c
= add_com ("starti", class_run
, starti_command
, _("\
3223 Start the debugged program stopping at the first instruction.\n"
3225 set_cmd_completer (c
, filename_completer
);
3227 add_com ("interrupt", class_run
, interrupt_command
,
3228 _("Interrupt the execution of the debugged program.\n\
3229 If non-stop mode is enabled, interrupt only the current thread,\n\
3230 otherwise all the threads in the program are stopped. To \n\
3231 interrupt all running threads in non-stop mode, use the -a option."));
3233 cmd_list_element
*info_registers_cmd
3234 = add_info ("registers", info_registers_command
, _("\
3235 List of integer registers and their contents, for selected stack frame.\n\
3236 One or more register names as argument means describe the given registers.\n\
3237 One or more register group names as argument means describe the registers\n\
3238 in the named register groups."));
3239 add_info_alias ("r", info_registers_cmd
, 1);
3240 set_cmd_completer (info_registers_cmd
, reg_or_group_completer
);
3242 c
= add_info ("all-registers", info_all_registers_command
, _("\
3243 List of all registers and their contents, for selected stack frame.\n\
3244 One or more register names as argument means describe the given registers.\n\
3245 One or more register group names as argument means describe the registers\n\
3246 in the named register groups."));
3247 set_cmd_completer (c
, reg_or_group_completer
);
3249 add_info ("program", info_program_command
,
3250 _("Execution status of the program."));
3252 add_info ("float", info_float_command
,
3253 _("Print the status of the floating point unit."));
3255 add_info ("vector", info_vector_command
,
3256 _("Print the status of the vector unit."));
3258 add_prefix_cmd ("proc", class_info
, info_proc_cmd
,
3260 Show additional information about a process.\n\
3261 Specify any process id, or use the program being debugged by default."),
3263 1/*allow-unknown*/, &infolist
);
3265 add_cmd ("mappings", class_info
, info_proc_cmd_mappings
, _("\
3266 List memory regions mapped by the specified process."),
3267 &info_proc_cmdlist
);
3269 add_cmd ("stat", class_info
, info_proc_cmd_stat
, _("\
3270 List process info from /proc/PID/stat."),
3271 &info_proc_cmdlist
);
3273 add_cmd ("status", class_info
, info_proc_cmd_status
, _("\
3274 List process info from /proc/PID/status."),
3275 &info_proc_cmdlist
);
3277 add_cmd ("cwd", class_info
, info_proc_cmd_cwd
, _("\
3278 List current working directory of the specified process."),
3279 &info_proc_cmdlist
);
3281 add_cmd ("cmdline", class_info
, info_proc_cmd_cmdline
, _("\
3282 List command line arguments of the specified process."),
3283 &info_proc_cmdlist
);
3285 add_cmd ("exe", class_info
, info_proc_cmd_exe
, _("\
3286 List absolute filename for executable of the specified process."),
3287 &info_proc_cmdlist
);
3289 add_cmd ("files", class_info
, info_proc_cmd_files
, _("\
3290 List files opened by the specified process."),
3291 &info_proc_cmdlist
);
3293 add_cmd ("all", class_info
, info_proc_cmd_all
, _("\
3294 List all available info about the specified process."),
3295 &info_proc_cmdlist
);
3297 add_setshow_boolean_cmd ("finish", class_support
,
3298 &user_print_options
.finish_print
, _("\
3299 Set whether `finish' prints the return value."), _("\
3300 Show whether `finish' prints the return value."), NULL
,
3303 &setprintlist
, &showprintlist
);