1 /* Memory-access and commands for "inferior" process, for GDB.
3 Copyright (C) 1986-2018 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 #include "arch-utils.h"
36 #include "completer.h"
38 #include "event-top.h"
39 #include "parser-defs.h"
41 #include "reggroups.h"
46 #include "target-descriptions.h"
47 #include "user-regs.h"
48 #include "cli/cli-decode.h"
49 #include "gdbthread.h"
51 #include "inline-frame.h"
52 #include "tracepoint.h"
54 #include "continuations.h"
56 #include "cli/cli-utils.h"
58 #include "thread-fsm.h"
61 #include "common/gdb_optional.h"
63 /* Local functions: */
65 static void until_next_command (int);
67 static void step_1 (int, int, const char *);
69 #define ERROR_NO_INFERIOR \
70 if (!target_has_execution) error (_("The program is not being run."));
72 /* Scratch area where string containing arguments to give to the
73 program will be stored by 'set args'. As soon as anything is
74 stored, notice_args_set will move it into per-inferior storage.
75 Arguments are separated by spaces. Empty string (pointer to '\0')
78 static char *inferior_args_scratch;
80 /* Scratch area where the new cwd will be stored by 'set cwd'. */
82 static char *inferior_cwd_scratch;
84 /* Scratch area where 'set inferior-tty' will store user-provided value.
85 We'll immediate copy it into per-inferior storage. */
87 static char *inferior_io_terminal_scratch;
89 /* Pid of our debugged inferior, or 0 if no inferior now.
90 Since various parts of infrun.c test this to see whether there is a program
91 being debugged it should be nonzero (currently 3 is used) for remote
96 /* Address at which inferior stopped. */
100 /* Nonzero if stopped due to completion of a stack dummy routine. */
102 enum stop_stack_kind stop_stack_dummy;
104 /* Nonzero if stopped due to a random (unexpected) signal in inferior
107 int stopped_by_random_signal;
109 /* See inferior.h. */
111 int startup_with_shell = 1;
114 /* Accessor routines. */
116 /* Set the io terminal for the current inferior. Ownership of
117 TERMINAL_NAME is not transferred. */
120 set_inferior_io_terminal (const char *terminal_name)
122 xfree (current_inferior ()->terminal);
124 if (terminal_name != NULL && *terminal_name != '\0')
125 current_inferior ()->terminal = xstrdup (terminal_name);
127 current_inferior ()->terminal = NULL;
131 get_inferior_io_terminal (void)
133 return current_inferior ()->terminal;
137 set_inferior_tty_command (const char *args, int from_tty,
138 struct cmd_list_element *c)
140 /* CLI has assigned the user-provided value to inferior_io_terminal_scratch.
141 Now route it to current inferior. */
142 set_inferior_io_terminal (inferior_io_terminal_scratch);
146 show_inferior_tty_command (struct ui_file *file, int from_tty,
147 struct cmd_list_element *c, const char *value)
149 /* Note that we ignore the passed-in value in favor of computing it
151 const char *inferior_io_terminal = get_inferior_io_terminal ();
153 if (inferior_io_terminal == NULL)
154 inferior_io_terminal = "";
155 fprintf_filtered (gdb_stdout,
156 _("Terminal for future runs of program being debugged "
157 "is \"%s\".\n"), inferior_io_terminal);
161 get_inferior_args (void)
163 if (current_inferior ()->argc != 0)
167 n = construct_inferior_arguments (current_inferior ()->argc,
168 current_inferior ()->argv);
169 set_inferior_args (n);
173 if (current_inferior ()->args == NULL)
174 current_inferior ()->args = xstrdup ("");
176 return current_inferior ()->args;
179 /* Set the arguments for the current inferior. Ownership of
180 NEWARGS is not transferred. */
183 set_inferior_args (const char *newargs)
185 xfree (current_inferior ()->args);
186 current_inferior ()->args = newargs ? xstrdup (newargs) : NULL;
187 current_inferior ()->argc = 0;
188 current_inferior ()->argv = 0;
192 set_inferior_args_vector (int argc, char **argv)
194 current_inferior ()->argc = argc;
195 current_inferior ()->argv = argv;
198 /* Notice when `set args' is run. */
201 set_args_command (const char *args, int from_tty, struct cmd_list_element *c)
203 /* CLI has assigned the user-provided value to inferior_args_scratch.
204 Now route it to current inferior. */
205 set_inferior_args (inferior_args_scratch);
208 /* Notice when `show args' is run. */
211 show_args_command (struct ui_file *file, int from_tty,
212 struct cmd_list_element *c, const char *value)
214 /* Note that we ignore the passed-in value in favor of computing it
216 deprecated_show_value_hack (file, from_tty, c, get_inferior_args ());
219 /* See common/common-inferior.h. */
222 set_inferior_cwd (const char *cwd)
224 struct inferior *inf = current_inferior ();
226 gdb_assert (inf != NULL);
231 inf->cwd.reset (xstrdup (cwd));
234 /* See common/common-inferior.h. */
239 return current_inferior ()->cwd.get ();
242 /* Handle the 'set cwd' command. */
245 set_cwd_command (const char *args, int from_tty, struct cmd_list_element *c)
247 if (*inferior_cwd_scratch == '\0')
248 set_inferior_cwd (NULL);
250 set_inferior_cwd (inferior_cwd_scratch);
253 /* Handle the 'show cwd' command. */
256 show_cwd_command (struct ui_file *file, int from_tty,
257 struct cmd_list_element *c, const char *value)
259 const char *cwd = get_inferior_cwd ();
262 fprintf_filtered (gdb_stdout,
264 You have not set the inferior's current working directory.\n\
265 The inferior will inherit GDB's cwd if native debugging, or the remote\n\
266 server's cwd if remote debugging.\n"));
268 fprintf_filtered (gdb_stdout,
269 _("Current working directory that will be used "
270 "when starting the inferior is \"%s\".\n"), cwd);
274 /* Compute command-line string given argument vector. This does the
275 same shell processing as fork_inferior. */
278 construct_inferior_arguments (int argc, char **argv)
282 if (startup_with_shell)
285 /* This holds all the characters considered special to the
287 static const char special[] = "\"!&*|[]{}<>?`~^=;, \t\n";
288 static const char quote = '"';
290 /* This holds all the characters considered special to the
291 typical Unix shells. We include `^' because the SunOS
292 /bin/sh treats it as a synonym for `|'. */
293 static const char special[] = "\"!#$&*()\\|[]{}<>?'`~^; \t\n";
294 static const char quote = '\'';
300 /* We over-compute the size. It shouldn't matter. */
301 for (i = 0; i < argc; ++i)
302 length += 3 * strlen (argv[i]) + 1 + 2 * (argv[i][0] == '\0');
304 result = (char *) xmalloc (length);
307 for (i = 0; i < argc; ++i)
312 /* Need to handle empty arguments specially. */
313 if (argv[i][0] == '\0')
323 if (strpbrk (argv[i], special))
329 for (cp = argv[i]; *cp; ++cp)
333 /* A newline cannot be quoted with a backslash (it
334 just disappears), only by putting it inside
345 if (strchr (special, *cp) != NULL)
361 /* In this case we can't handle arguments that contain spaces,
362 tabs, or newlines -- see breakup_args(). */
366 for (i = 0; i < argc; ++i)
368 char *cp = strchr (argv[i], ' ');
370 cp = strchr (argv[i], '\t');
372 cp = strchr (argv[i], '\n');
374 error (_("can't handle command-line "
375 "argument containing whitespace"));
376 length += strlen (argv[i]) + 1;
379 result = (char *) xmalloc (length);
381 for (i = 0; i < argc; ++i)
384 strcat (result, " ");
385 strcat (result, argv[i]);
393 /* This function strips the '&' character (indicating background
394 execution) that is added as *the last* of the arguments ARGS of a
395 command. A copy of the incoming ARGS without the '&' is returned,
396 unless the resulting string after stripping is empty, in which case
397 NULL is returned. *BG_CHAR_P is an output boolean that indicates
398 whether the '&' character was found. */
400 static gdb::unique_xmalloc_ptr<char>
401 strip_bg_char (const char *args, int *bg_char_p)
405 if (args == NULL || *args == '\0')
411 p = args + strlen (args);
415 while (p > args && isspace (p[-1]))
420 return gdb::unique_xmalloc_ptr<char>
421 (savestring (args, p - args));
423 return gdb::unique_xmalloc_ptr<char> (nullptr);
427 return gdb::unique_xmalloc_ptr<char> (xstrdup (args));
430 /* Common actions to take after creating any sort of inferior, by any
431 means (running, attaching, connecting, et cetera). The target
432 should be stopped. */
435 post_create_inferior (struct target_ops *target, int from_tty)
438 /* Be sure we own the terminal in case write operations are performed. */
439 target_terminal::ours_for_output ();
441 /* If the target hasn't taken care of this already, do it now.
442 Targets which need to access registers during to_open,
443 to_create_inferior, or to_attach should do it earlier; but many
445 target_find_description ();
447 /* Now that we know the register layout, retrieve current PC. But
448 if the PC is unavailable (e.g., we're opening a core file with
449 missing registers info), ignore it. */
453 stop_pc = regcache_read_pc (get_current_regcache ());
455 CATCH (ex, RETURN_MASK_ERROR)
457 if (ex.error != NOT_AVAILABLE_ERROR)
458 throw_exception (ex);
464 const unsigned solib_add_generation
465 = current_program_space->solib_add_generation;
467 /* Create the hooks to handle shared library load and unload
469 solib_create_inferior_hook (from_tty);
471 if (current_program_space->solib_add_generation == solib_add_generation)
473 /* The platform-specific hook should load initial shared libraries,
474 but didn't. FROM_TTY will be incorrectly 0 but such solib
475 targets should be fixed anyway. Call it only after the solib
476 target has been initialized by solib_create_inferior_hook. */
479 warning (_("platform-specific solib_create_inferior_hook did "
480 "not load initial shared libraries."));
482 /* If the solist is global across processes, there's no need to
484 if (!gdbarch_has_global_solist (target_gdbarch ()))
485 solib_add (NULL, 0, auto_solib_add);
489 /* If the user sets watchpoints before execution having started,
490 then she gets software watchpoints, because GDB can't know which
491 target will end up being pushed, or if it supports hardware
492 watchpoints or not. breakpoint_re_set takes care of promoting
493 watchpoints to hardware watchpoints if possible, however, if this
494 new inferior doesn't load shared libraries or we don't pull in
495 symbols from any other source on this target/arch,
496 breakpoint_re_set is never called. Call it now so that software
497 watchpoints get a chance to be promoted to hardware watchpoints
498 if the now pushed target supports hardware watchpoints. */
499 breakpoint_re_set ();
501 observer_notify_inferior_created (target, from_tty);
504 /* Kill the inferior if already running. This function is designed
505 to be called when we are about to start the execution of the program
506 from the beginning. Ask the user to confirm that he wants to restart
507 the program being debugged when FROM_TTY is non-null. */
510 kill_if_already_running (int from_tty)
512 if (! ptid_equal (inferior_ptid, null_ptid) && target_has_execution)
514 /* Bail out before killing the program if we will not be able to
516 target_require_runnable ();
519 && !query (_("The program being debugged has been started already.\n\
520 Start it from the beginning? ")))
521 error (_("Program not restarted."));
526 /* See inferior.h. */
529 prepare_execution_command (struct target_ops *target, int background)
531 /* If we get a request for running in the bg but the target
532 doesn't support it, error out. */
533 if (background && !target->to_can_async_p (target))
534 error (_("Asynchronous execution not supported on this target."));
538 /* If we get a request for running in the fg, then we need to
539 simulate synchronous (fg) execution. Note no cleanup is
540 necessary for this. stdin is re-enabled whenever an error
541 reaches the top level. */
542 all_uis_on_sync_execution_starting ();
546 /* Determine how the new inferior will behave. */
550 /* Run program without any explicit stop during startup. */
553 /* Stop at the beginning of the program's main function. */
556 /* Stop at the first instruction of the program. */
557 RUN_STOP_AT_FIRST_INSN
560 /* Implement the "run" command. Force a stop during program start if
561 requested by RUN_HOW. */
564 run_command_1 (const char *args, int from_tty, enum run_how run_how)
566 const char *exec_file;
567 struct cleanup *old_chain;
569 struct ui_out *uiout = current_uiout;
570 struct target_ops *run_target;
575 kill_if_already_running (from_tty);
577 init_wait_for_inferior ();
578 clear_breakpoint_hit_counts ();
580 /* Clean up any leftovers from other runs. Some other things from
581 this function should probably be moved into target_pre_inferior. */
582 target_pre_inferior (from_tty);
584 /* The comment here used to read, "The exec file is re-read every
585 time we do a generic_mourn_inferior, so we just have to worry
586 about the symbol file." The `generic_mourn_inferior' function
587 gets called whenever the program exits. However, suppose the
588 program exits, and *then* the executable file changes? We need
589 to check again here. Since reopen_exec_file doesn't do anything
590 if the timestamp hasn't changed, I don't see the harm. */
594 gdb::unique_xmalloc_ptr<char> stripped = strip_bg_char (args, &async_exec);
595 args = stripped.get ();
597 /* Do validation and preparation before possibly changing anything
600 run_target = find_run_target ();
602 prepare_execution_command (run_target, async_exec);
604 if (non_stop && !run_target->to_supports_non_stop (run_target))
605 error (_("The target does not support running in non-stop mode."));
607 /* Done. Can now set breakpoints, change inferior args, etc. */
609 /* Insert temporary breakpoint in main function if requested. */
610 if (run_how == RUN_STOP_AT_MAIN)
611 tbreak_command (main_name (), 0);
613 exec_file = get_exec_file (0);
615 /* We keep symbols from add-symbol-file, on the grounds that the
616 user might want to add some symbols before running the program
617 (right?). But sometimes (dynamic loading where the user manually
618 introduces the new symbols with add-symbol-file), the code which
619 the symbols describe does not persist between runs. Currently
620 the user has to manually nuke all symbols between runs if they
621 want them to go away (PR 2207). This is probably reasonable. */
623 /* If there were other args, beside '&', process them. */
625 set_inferior_args (args);
629 uiout->field_string (NULL, "Starting program");
632 uiout->field_string ("execfile", exec_file);
634 /* We call get_inferior_args() because we might need to compute
636 uiout->field_string ("infargs", get_inferior_args ());
641 /* We call get_inferior_args() because we might need to compute
643 run_target->to_create_inferior (run_target, exec_file,
644 std::string (get_inferior_args ()),
645 current_inferior ()->environment.envp (),
647 /* to_create_inferior should push the target, so after this point we
648 shouldn't refer to run_target again. */
651 /* We're starting off a new process. When we get out of here, in
652 non-stop mode, finish the state of all threads of that process,
653 but leave other threads alone, as they may be stopped in internal
654 events --- the frontend shouldn't see them as stopped. In
655 all-stop, always finish the state of all threads, as we may be
656 resuming more than just the new process. */
658 ptid = pid_to_ptid (ptid_get_pid (inferior_ptid));
660 ptid = minus_one_ptid;
661 old_chain = make_cleanup (finish_thread_state_cleanup, &ptid);
663 /* Pass zero for FROM_TTY, because at this point the "run" command
664 has done its thing; now we are setting up the running program. */
665 post_create_inferior (¤t_target, 0);
667 /* Queue a pending event so that the program stops immediately. */
668 if (run_how == RUN_STOP_AT_FIRST_INSN)
670 thread_info *thr = inferior_thread ();
671 thr->suspend.waitstatus_pending_p = 1;
672 thr->suspend.waitstatus.kind = TARGET_WAITKIND_STOPPED;
673 thr->suspend.waitstatus.value.sig = GDB_SIGNAL_0;
676 /* Start the target running. Do not use -1 continuation as it would skip
677 breakpoint right at the entry point. */
678 proceed (regcache_read_pc (get_current_regcache ()), GDB_SIGNAL_0);
680 /* Since there was no error, there's no need to finish the thread
682 discard_cleanups (old_chain);
686 run_command (const char *args, int from_tty)
688 run_command_1 (args, from_tty, RUN_NORMAL);
691 /* Start the execution of the program up until the beginning of the main
695 start_command (const char *args, int from_tty)
697 /* Some languages such as Ada need to search inside the program
698 minimal symbols for the location where to put the temporary
699 breakpoint before starting. */
700 if (!have_minimal_symbols ())
701 error (_("No symbol table loaded. Use the \"file\" command."));
703 /* Run the program until reaching the main procedure... */
704 run_command_1 (args, from_tty, RUN_STOP_AT_MAIN);
707 /* Start the execution of the program stopping at the first
711 starti_command (const char *args, int from_tty)
713 run_command_1 (args, from_tty, RUN_STOP_AT_FIRST_INSN);
717 proceed_thread_callback (struct thread_info *thread, void *arg)
719 /* We go through all threads individually instead of compressing
720 into a single target `resume_all' request, because some threads
721 may be stopped in internal breakpoints/events, or stopped waiting
722 for its turn in the displaced stepping queue (that is, they are
723 running && !executing). The target side has no idea about why
724 the thread is stopped, so a `resume_all' command would resume too
725 much. If/when GDB gains a way to tell the target `hold this
726 thread stopped until I say otherwise', then we can optimize
728 if (!is_stopped (thread->ptid))
731 switch_to_thread (thread->ptid);
732 clear_proceed_status (0);
733 proceed ((CORE_ADDR) -1, GDB_SIGNAL_DEFAULT);
738 ensure_valid_thread (void)
740 if (ptid_equal (inferior_ptid, null_ptid)
741 || is_exited (inferior_ptid))
742 error (_("Cannot execute this command without a live selected thread."));
745 /* If the user is looking at trace frames, any resumption of execution
746 is likely to mix up recorded and live target data. So simply
747 disallow those commands. */
750 ensure_not_tfind_mode (void)
752 if (get_traceframe_number () >= 0)
753 error (_("Cannot execute this command while looking at trace frames."));
756 /* Throw an error indicating the current thread is running. */
759 error_is_running (void)
761 error (_("Cannot execute this command while "
762 "the selected thread is running."));
765 /* Calls error_is_running if the current thread is running. */
768 ensure_not_running (void)
770 if (is_running (inferior_ptid))
775 continue_1 (int all_threads)
778 ensure_not_tfind_mode ();
780 if (non_stop && all_threads)
782 /* Don't error out if the current thread is running, because
783 there may be other stopped threads. */
785 /* Backup current thread and selected frame and restore on scope
787 scoped_restore_current_thread restore_thread;
789 iterate_over_threads (proceed_thread_callback, NULL);
791 if (current_ui->prompt_state == PROMPT_BLOCKED)
793 /* If all threads in the target were already running,
794 proceed_thread_callback ends up never calling proceed,
795 and so nothing calls this to put the inferior's terminal
796 settings in effect and remove stdin from the event loop,
797 which we must when running a foreground command. E.g.:
801 <all threads are running now>
804 <no thread was resumed, but the inferior now owns the terminal>
806 target_terminal::inferior ();
811 ensure_valid_thread ();
812 ensure_not_running ();
813 clear_proceed_status (0);
814 proceed ((CORE_ADDR) -1, GDB_SIGNAL_DEFAULT);
818 /* continue [-a] [proceed-count] [&] */
821 continue_command (const char *args, int from_tty)
828 /* Find out whether we must run in the background. */
829 gdb::unique_xmalloc_ptr<char> stripped = strip_bg_char (args, &async_exec);
830 args = stripped.get ();
834 if (startswith (args, "-a"))
837 args += sizeof ("-a") - 1;
843 if (!non_stop && all_threads)
844 error (_("`-a' is meaningless in all-stop mode."));
846 if (args != NULL && all_threads)
847 error (_("Can't resume all threads and specify "
848 "proceed count simultaneously."));
850 /* If we have an argument left, set proceed count of breakpoint we
857 struct thread_info *tp;
860 tp = find_thread_ptid (inferior_ptid);
864 struct target_waitstatus ws;
866 get_last_target_status (&last_ptid, &ws);
867 tp = find_thread_ptid (last_ptid);
870 bs = tp->control.stop_bpstat;
872 while ((stat = bpstat_num (&bs, &num)) != 0)
875 set_ignore_count (num,
876 parse_and_eval_long (args) - 1,
878 /* set_ignore_count prints a message ending with a period.
879 So print two spaces before "Continuing.". */
881 printf_filtered (" ");
885 if (!stopped && from_tty)
888 ("Not stopped at any breakpoint; argument ignored.\n");
893 ensure_not_tfind_mode ();
895 if (!non_stop || !all_threads)
897 ensure_valid_thread ();
898 ensure_not_running ();
901 prepare_execution_command (¤t_target, async_exec);
904 printf_filtered (_("Continuing.\n"));
906 continue_1 (all_threads);
909 /* Record the starting point of a "step" or "next" command. */
912 set_step_frame (void)
914 frame_info *frame = get_current_frame ();
916 symtab_and_line sal = find_frame_sal (frame);
917 set_step_info (frame, sal);
919 CORE_ADDR pc = get_frame_pc (frame);
920 thread_info *tp = inferior_thread ();
921 tp->control.step_start_function = find_pc_function (pc);
924 /* Step until outside of current statement. */
927 step_command (const char *count_string, int from_tty)
929 step_1 (0, 0, count_string);
932 /* Likewise, but skip over subroutine calls as if single instructions. */
935 next_command (const char *count_string, int from_tty)
937 step_1 (1, 0, count_string);
940 /* Likewise, but step only one instruction. */
943 stepi_command (const char *count_string, int from_tty)
945 step_1 (0, 1, count_string);
949 nexti_command (const char *count_string, int from_tty)
951 step_1 (1, 1, count_string);
955 delete_longjmp_breakpoint_cleanup (void *arg)
957 int thread = * (int *) arg;
958 delete_longjmp_breakpoint (thread);
961 /* Data for the FSM that manages the step/next/stepi/nexti
964 struct step_command_fsm
966 /* The base class. */
967 struct thread_fsm thread_fsm;
969 /* How many steps left in a "step N"-like command. */
972 /* If true, this is a next/nexti, otherwise a step/stepi. */
973 int skip_subroutines;
975 /* If true, this is a stepi/nexti, otherwise a step/step. */
979 static void step_command_fsm_clean_up (struct thread_fsm *self,
980 struct thread_info *thread);
981 static int step_command_fsm_should_stop (struct thread_fsm *self,
982 struct thread_info *thread);
983 static enum async_reply_reason
984 step_command_fsm_async_reply_reason (struct thread_fsm *self);
986 /* step_command_fsm's vtable. */
988 static struct thread_fsm_ops step_command_fsm_ops =
991 step_command_fsm_clean_up,
992 step_command_fsm_should_stop,
993 NULL, /* return_value */
994 step_command_fsm_async_reply_reason,
997 /* Allocate a new step_command_fsm. */
999 static struct step_command_fsm *
1000 new_step_command_fsm (struct interp *cmd_interp)
1002 struct step_command_fsm *sm;
1004 sm = XCNEW (struct step_command_fsm);
1005 thread_fsm_ctor (&sm->thread_fsm, &step_command_fsm_ops, cmd_interp);
1010 /* Prepare for a step/next/etc. command. Any target resource
1011 allocated here is undone in the FSM's clean_up method. */
1014 step_command_fsm_prepare (struct step_command_fsm *sm,
1015 int skip_subroutines, int single_inst,
1016 int count, struct thread_info *thread)
1018 sm->skip_subroutines = skip_subroutines;
1019 sm->single_inst = single_inst;
1022 /* Leave the si command alone. */
1023 if (!sm->single_inst || sm->skip_subroutines)
1024 set_longjmp_breakpoint (thread, get_frame_id (get_current_frame ()));
1026 thread->control.stepping_command = 1;
1029 static int prepare_one_step (struct step_command_fsm *sm);
1032 step_1 (int skip_subroutines, int single_inst, const char *count_string)
1036 struct thread_info *thr;
1037 struct step_command_fsm *step_sm;
1040 ensure_not_tfind_mode ();
1041 ensure_valid_thread ();
1042 ensure_not_running ();
1044 gdb::unique_xmalloc_ptr<char> stripped
1045 = strip_bg_char (count_string, &async_exec);
1046 count_string = stripped.get ();
1048 prepare_execution_command (¤t_target, async_exec);
1050 count = count_string ? parse_and_eval_long (count_string) : 1;
1052 clear_proceed_status (1);
1054 /* Setup the execution command state machine to handle all the COUNT
1056 thr = inferior_thread ();
1057 step_sm = new_step_command_fsm (command_interp ());
1058 thr->thread_fsm = &step_sm->thread_fsm;
1060 step_command_fsm_prepare (step_sm, skip_subroutines,
1061 single_inst, count, thr);
1063 /* Do only one step for now, before returning control to the event
1064 loop. Let the continuation figure out how many other steps we
1065 need to do, and handle them one at the time, through
1067 if (!prepare_one_step (step_sm))
1068 proceed ((CORE_ADDR) -1, GDB_SIGNAL_DEFAULT);
1073 /* Stepped into an inline frame. Pretend that we've
1075 thread_fsm_clean_up (thr->thread_fsm, thr);
1076 proceeded = normal_stop ();
1078 inferior_event_handler (INF_EXEC_COMPLETE, NULL);
1079 all_uis_check_sync_execution_done ();
1083 /* Implementation of the 'should_stop' FSM method for stepping
1084 commands. Called after we are done with one step operation, to
1085 check whether we need to step again, before we print the prompt and
1086 return control to the user. If count is > 1, returns false, as we
1087 will need to keep going. */
1090 step_command_fsm_should_stop (struct thread_fsm *self, struct thread_info *tp)
1092 struct step_command_fsm *sm = (struct step_command_fsm *) self;
1094 if (tp->control.stop_step)
1096 /* There are more steps to make, and we did stop due to
1097 ending a stepping range. Do another step. */
1098 if (--sm->count > 0)
1099 return prepare_one_step (sm);
1101 thread_fsm_set_finished (self);
1107 /* Implementation of the 'clean_up' FSM method for stepping commands. */
1110 step_command_fsm_clean_up (struct thread_fsm *self, struct thread_info *thread)
1112 struct step_command_fsm *sm = (struct step_command_fsm *) self;
1114 if (!sm->single_inst || sm->skip_subroutines)
1115 delete_longjmp_breakpoint (thread->global_num);
1118 /* Implementation of the 'async_reply_reason' FSM method for stepping
1121 static enum async_reply_reason
1122 step_command_fsm_async_reply_reason (struct thread_fsm *self)
1124 return EXEC_ASYNC_END_STEPPING_RANGE;
1127 /* Prepare for one step in "step N". The actual target resumption is
1128 done by the caller. Return true if we're done and should thus
1129 report a stop to the user. Returns false if the target needs to be
1133 prepare_one_step (struct step_command_fsm *sm)
1137 struct frame_info *frame = get_current_frame ();
1139 /* Don't assume THREAD is a valid thread id. It is set to -1 if
1140 the longjmp breakpoint was not required. Use the
1141 INFERIOR_PTID thread instead, which is the same thread when
1143 struct thread_info *tp = inferior_thread ();
1147 if (!sm->single_inst)
1151 /* Step at an inlined function behaves like "down". */
1152 if (!sm->skip_subroutines
1153 && inline_skipped_frames (inferior_ptid))
1157 /* Pretend that we've ran. */
1158 resume_ptid = user_visible_resume_ptid (1);
1159 set_running (resume_ptid, 1);
1161 step_into_inline_frame (inferior_ptid);
1163 return prepare_one_step (sm);
1166 pc = get_frame_pc (frame);
1167 find_pc_line_pc_range (pc,
1168 &tp->control.step_range_start,
1169 &tp->control.step_range_end);
1171 tp->control.may_range_step = 1;
1173 /* If we have no line info, switch to stepi mode. */
1174 if (tp->control.step_range_end == 0 && step_stop_if_no_debug)
1176 tp->control.step_range_start = tp->control.step_range_end = 1;
1177 tp->control.may_range_step = 0;
1179 else if (tp->control.step_range_end == 0)
1183 if (find_pc_partial_function (pc, &name,
1184 &tp->control.step_range_start,
1185 &tp->control.step_range_end) == 0)
1186 error (_("Cannot find bounds of current function"));
1188 target_terminal::ours_for_output ();
1189 printf_filtered (_("Single stepping until exit from function %s,"
1190 "\nwhich has no line number information.\n"),
1196 /* Say we are stepping, but stop after one insn whatever it does. */
1197 tp->control.step_range_start = tp->control.step_range_end = 1;
1198 if (!sm->skip_subroutines)
1200 Don't step over function calls, not even to functions lacking
1202 tp->control.step_over_calls = STEP_OVER_NONE;
1205 if (sm->skip_subroutines)
1206 tp->control.step_over_calls = STEP_OVER_ALL;
1212 thread_fsm_set_finished (&sm->thread_fsm);
1217 /* Continue program at specified address. */
1220 jump_command (const char *arg, int from_tty)
1222 struct gdbarch *gdbarch = get_current_arch ();
1229 ensure_not_tfind_mode ();
1230 ensure_valid_thread ();
1231 ensure_not_running ();
1233 /* Find out whether we must run in the background. */
1234 gdb::unique_xmalloc_ptr<char> stripped = strip_bg_char (arg, &async_exec);
1235 arg = stripped.get ();
1237 prepare_execution_command (¤t_target, async_exec);
1240 error_no_arg (_("starting address"));
1242 std::vector<symtab_and_line> sals
1243 = decode_line_with_last_displayed (arg, DECODE_LINE_FUNFIRSTLINE);
1244 if (sals.size () != 1)
1245 error (_("Unreasonable jump request"));
1247 symtab_and_line &sal = sals[0];
1249 if (sal.symtab == 0 && sal.pc == 0)
1250 error (_("No source file has been specified."));
1252 resolve_sal_pc (&sal); /* May error out. */
1254 /* See if we are trying to jump to another function. */
1255 fn = get_frame_function (get_current_frame ());
1256 sfn = find_pc_function (sal.pc);
1257 if (fn != NULL && sfn != fn)
1259 if (!query (_("Line %d is not in `%s'. Jump anyway? "), sal.line,
1260 SYMBOL_PRINT_NAME (fn)))
1262 error (_("Not confirmed."));
1269 struct obj_section *section;
1271 fixup_symbol_section (sfn, 0);
1272 section = SYMBOL_OBJ_SECTION (symbol_objfile (sfn), sfn);
1273 if (section_is_overlay (section)
1274 && !section_is_mapped (section))
1276 if (!query (_("WARNING!!! Destination is in "
1277 "unmapped overlay! Jump anyway? ")))
1279 error (_("Not confirmed."));
1289 printf_filtered (_("Continuing at "));
1290 fputs_filtered (paddress (gdbarch, addr), gdb_stdout);
1291 printf_filtered (".\n");
1294 clear_proceed_status (0);
1295 proceed (addr, GDB_SIGNAL_0);
1298 /* Continue program giving it specified signal. */
1301 signal_command (const char *signum_exp, int from_tty)
1303 enum gdb_signal oursig;
1306 dont_repeat (); /* Too dangerous. */
1308 ensure_not_tfind_mode ();
1309 ensure_valid_thread ();
1310 ensure_not_running ();
1312 /* Find out whether we must run in the background. */
1313 gdb::unique_xmalloc_ptr<char> stripped
1314 = strip_bg_char (signum_exp, &async_exec);
1315 signum_exp = stripped.get ();
1317 prepare_execution_command (¤t_target, async_exec);
1320 error_no_arg (_("signal number"));
1322 /* It would be even slicker to make signal names be valid expressions,
1323 (the type could be "enum $signal" or some such), then the user could
1324 assign them to convenience variables. */
1325 oursig = gdb_signal_from_name (signum_exp);
1327 if (oursig == GDB_SIGNAL_UNKNOWN)
1329 /* No, try numeric. */
1330 int num = parse_and_eval_long (signum_exp);
1333 oursig = GDB_SIGNAL_0;
1335 oursig = gdb_signal_from_command (num);
1338 /* Look for threads other than the current that this command ends up
1339 resuming too (due to schedlock off), and warn if they'll get a
1340 signal delivered. "signal 0" is used to suppress a previous
1341 signal, but if the current thread is no longer the one that got
1342 the signal, then the user is potentially suppressing the signal
1343 of the wrong thread. */
1346 struct thread_info *tp;
1348 int must_confirm = 0;
1350 /* This indicates what will be resumed. Either a single thread,
1351 a whole process, or all threads of all processes. */
1352 resume_ptid = user_visible_resume_ptid (0);
1354 ALL_NON_EXITED_THREADS (tp)
1356 if (ptid_equal (tp->ptid, inferior_ptid))
1358 if (!ptid_match (tp->ptid, resume_ptid))
1361 if (tp->suspend.stop_signal != GDB_SIGNAL_0
1362 && signal_pass_state (tp->suspend.stop_signal))
1365 printf_unfiltered (_("Note:\n"));
1366 printf_unfiltered (_(" Thread %s previously stopped with signal %s, %s.\n"),
1367 print_thread_id (tp),
1368 gdb_signal_to_name (tp->suspend.stop_signal),
1369 gdb_signal_to_string (tp->suspend.stop_signal));
1375 && !query (_("Continuing thread %s (the current thread) with specified signal will\n"
1376 "still deliver the signals noted above to their respective threads.\n"
1377 "Continue anyway? "),
1378 print_thread_id (inferior_thread ())))
1379 error (_("Not confirmed."));
1384 if (oursig == GDB_SIGNAL_0)
1385 printf_filtered (_("Continuing with no signal.\n"));
1387 printf_filtered (_("Continuing with signal %s.\n"),
1388 gdb_signal_to_name (oursig));
1391 clear_proceed_status (0);
1392 proceed ((CORE_ADDR) -1, oursig);
1395 /* Queue a signal to be delivered to the current thread. */
1398 queue_signal_command (const char *signum_exp, int from_tty)
1400 enum gdb_signal oursig;
1401 struct thread_info *tp;
1404 ensure_not_tfind_mode ();
1405 ensure_valid_thread ();
1406 ensure_not_running ();
1408 if (signum_exp == NULL)
1409 error_no_arg (_("signal number"));
1411 /* It would be even slicker to make signal names be valid expressions,
1412 (the type could be "enum $signal" or some such), then the user could
1413 assign them to convenience variables. */
1414 oursig = gdb_signal_from_name (signum_exp);
1416 if (oursig == GDB_SIGNAL_UNKNOWN)
1418 /* No, try numeric. */
1419 int num = parse_and_eval_long (signum_exp);
1422 oursig = GDB_SIGNAL_0;
1424 oursig = gdb_signal_from_command (num);
1427 if (oursig != GDB_SIGNAL_0
1428 && !signal_pass_state (oursig))
1429 error (_("Signal handling set to not pass this signal to the program."));
1431 tp = inferior_thread ();
1432 tp->suspend.stop_signal = oursig;
1435 /* Data for the FSM that manages the until (with no argument)
1438 struct until_next_fsm
1440 /* The base class. */
1441 struct thread_fsm thread_fsm;
1443 /* The thread that as current when the command was executed. */
1447 static int until_next_fsm_should_stop (struct thread_fsm *self,
1448 struct thread_info *thread);
1449 static void until_next_fsm_clean_up (struct thread_fsm *self,
1450 struct thread_info *thread);
1451 static enum async_reply_reason
1452 until_next_fsm_async_reply_reason (struct thread_fsm *self);
1454 /* until_next_fsm's vtable. */
1456 static struct thread_fsm_ops until_next_fsm_ops =
1459 until_next_fsm_clean_up,
1460 until_next_fsm_should_stop,
1461 NULL, /* return_value */
1462 until_next_fsm_async_reply_reason,
1465 /* Allocate a new until_next_fsm. */
1467 static struct until_next_fsm *
1468 new_until_next_fsm (struct interp *cmd_interp, int thread)
1470 struct until_next_fsm *sm;
1472 sm = XCNEW (struct until_next_fsm);
1473 thread_fsm_ctor (&sm->thread_fsm, &until_next_fsm_ops, cmd_interp);
1475 sm->thread = thread;
1480 /* Implementation of the 'should_stop' FSM method for the until (with
1484 until_next_fsm_should_stop (struct thread_fsm *self,
1485 struct thread_info *tp)
1487 if (tp->control.stop_step)
1488 thread_fsm_set_finished (self);
1493 /* Implementation of the 'clean_up' FSM method for the until (with no
1497 until_next_fsm_clean_up (struct thread_fsm *self, struct thread_info *thread)
1499 delete_longjmp_breakpoint (thread->global_num);
1502 /* Implementation of the 'async_reply_reason' FSM method for the until
1503 (with no arg) command. */
1505 static enum async_reply_reason
1506 until_next_fsm_async_reply_reason (struct thread_fsm *self)
1508 return EXEC_ASYNC_END_STEPPING_RANGE;
1511 /* Proceed until we reach a different source line with pc greater than
1512 our current one or exit the function. We skip calls in both cases.
1514 Note that eventually this command should probably be changed so
1515 that only source lines are printed out when we hit the breakpoint
1516 we set. This may involve changes to wait_for_inferior and the
1517 proceed status code. */
1520 until_next_command (int from_tty)
1522 struct frame_info *frame;
1524 struct symbol *func;
1525 struct symtab_and_line sal;
1526 struct thread_info *tp = inferior_thread ();
1527 int thread = tp->global_num;
1528 struct cleanup *old_chain;
1529 struct until_next_fsm *sm;
1531 clear_proceed_status (0);
1534 frame = get_current_frame ();
1536 /* Step until either exited from this function or greater
1537 than the current line (if in symbolic section) or pc (if
1540 pc = get_frame_pc (frame);
1541 func = find_pc_function (pc);
1545 struct bound_minimal_symbol msymbol = lookup_minimal_symbol_by_pc (pc);
1547 if (msymbol.minsym == NULL)
1548 error (_("Execution is not within a known function."));
1550 tp->control.step_range_start = BMSYMBOL_VALUE_ADDRESS (msymbol);
1551 /* The upper-bound of step_range is exclusive. In order to make PC
1552 within the range, set the step_range_end with PC + 1. */
1553 tp->control.step_range_end = pc + 1;
1557 sal = find_pc_line (pc, 0);
1559 tp->control.step_range_start = BLOCK_START (SYMBOL_BLOCK_VALUE (func));
1560 tp->control.step_range_end = sal.end;
1562 tp->control.may_range_step = 1;
1564 tp->control.step_over_calls = STEP_OVER_ALL;
1566 set_longjmp_breakpoint (tp, get_frame_id (frame));
1567 old_chain = make_cleanup (delete_longjmp_breakpoint_cleanup, &thread);
1569 sm = new_until_next_fsm (command_interp (), tp->global_num);
1570 tp->thread_fsm = &sm->thread_fsm;
1571 discard_cleanups (old_chain);
1573 proceed ((CORE_ADDR) -1, GDB_SIGNAL_DEFAULT);
1577 until_command (const char *arg, int from_tty)
1582 ensure_not_tfind_mode ();
1583 ensure_valid_thread ();
1584 ensure_not_running ();
1586 /* Find out whether we must run in the background. */
1587 gdb::unique_xmalloc_ptr<char> stripped = strip_bg_char (arg, &async_exec);
1588 arg = stripped.get ();
1590 prepare_execution_command (¤t_target, async_exec);
1593 until_break_command (arg, from_tty, 0);
1595 until_next_command (from_tty);
1599 advance_command (const char *arg, int from_tty)
1604 ensure_not_tfind_mode ();
1605 ensure_valid_thread ();
1606 ensure_not_running ();
1609 error_no_arg (_("a location"));
1611 /* Find out whether we must run in the background. */
1612 gdb::unique_xmalloc_ptr<char> stripped = strip_bg_char (arg, &async_exec);
1613 arg = stripped.get ();
1615 prepare_execution_command (¤t_target, async_exec);
1617 until_break_command (arg, from_tty, 1);
1620 /* Return the value of the result of a function at the end of a 'finish'
1621 command/BP. DTOR_DATA (if not NULL) can represent inferior registers
1622 right after an inferior call has finished. */
1625 get_return_value (struct value *function, struct type *value_type)
1627 regcache stop_regs (regcache::readonly, *get_current_regcache ());
1628 struct gdbarch *gdbarch = stop_regs.arch ();
1629 struct value *value;
1631 value_type = check_typedef (value_type);
1632 gdb_assert (TYPE_CODE (value_type) != TYPE_CODE_VOID);
1634 /* FIXME: 2003-09-27: When returning from a nested inferior function
1635 call, it's possible (with no help from the architecture vector)
1636 to locate and return/print a "struct return" value. This is just
1637 a more complicated case of what is already being done in the
1638 inferior function call code. In fact, when inferior function
1639 calls are made async, this will likely be made the norm. */
1641 switch (gdbarch_return_value (gdbarch, function, value_type,
1644 case RETURN_VALUE_REGISTER_CONVENTION:
1645 case RETURN_VALUE_ABI_RETURNS_ADDRESS:
1646 case RETURN_VALUE_ABI_PRESERVES_ADDRESS:
1647 value = allocate_value (value_type);
1648 gdbarch_return_value (gdbarch, function, value_type, &stop_regs,
1649 value_contents_raw (value), NULL);
1651 case RETURN_VALUE_STRUCT_CONVENTION:
1655 internal_error (__FILE__, __LINE__, _("bad switch"));
1661 /* The captured function return value/type and its position in the
1664 struct return_value_info
1666 /* The captured return value. May be NULL if we weren't able to
1667 retrieve it. See get_return_value. */
1668 struct value *value;
1670 /* The return type. In some cases, we'll not be able extract the
1671 return value, but we always know the type. */
1674 /* If we captured a value, this is the value history index. */
1675 int value_history_index;
1678 /* Helper for print_return_value. */
1681 print_return_value_1 (struct ui_out *uiout, struct return_value_info *rv)
1683 if (rv->value != NULL)
1685 struct value_print_options opts;
1688 uiout->text ("Value returned is ");
1689 uiout->field_fmt ("gdb-result-var", "$%d",
1690 rv->value_history_index);
1691 uiout->text (" = ");
1692 get_no_prettyformat_print_options (&opts);
1696 value_print (rv->value, &stb, &opts);
1697 uiout->field_stream ("return-value", stb);
1702 std::string type_name = type_to_string (rv->type);
1703 uiout->text ("Value returned has type: ");
1704 uiout->field_string ("return-type", type_name.c_str ());
1706 uiout->text (" Cannot determine contents\n");
1710 /* Print the result of a function at the end of a 'finish' command.
1711 RV points at an object representing the captured return value/type
1712 and its position in the value history. */
1715 print_return_value (struct ui_out *uiout, struct return_value_info *rv)
1717 if (rv->type == NULL || TYPE_CODE (rv->type) == TYPE_CODE_VOID)
1722 /* print_return_value_1 can throw an exception in some
1723 circumstances. We need to catch this so that we still
1724 delete the breakpoint. */
1725 print_return_value_1 (uiout, rv);
1727 CATCH (ex, RETURN_MASK_ALL)
1729 exception_print (gdb_stdout, ex);
1734 /* Data for the FSM that manages the finish command. */
1736 struct finish_command_fsm
1738 /* The base class. */
1739 struct thread_fsm thread_fsm;
1741 /* The momentary breakpoint set at the function's return address in
1743 struct breakpoint *breakpoint;
1745 /* The function that we're stepping out of. */
1746 struct symbol *function;
1748 /* If the FSM finishes successfully, this stores the function's
1750 struct return_value_info return_value;
1753 static int finish_command_fsm_should_stop (struct thread_fsm *self,
1754 struct thread_info *thread);
1755 static void finish_command_fsm_clean_up (struct thread_fsm *self,
1756 struct thread_info *thread);
1757 static struct return_value_info *
1758 finish_command_fsm_return_value (struct thread_fsm *self);
1759 static enum async_reply_reason
1760 finish_command_fsm_async_reply_reason (struct thread_fsm *self);
1762 /* finish_command_fsm's vtable. */
1764 static struct thread_fsm_ops finish_command_fsm_ops =
1767 finish_command_fsm_clean_up,
1768 finish_command_fsm_should_stop,
1769 finish_command_fsm_return_value,
1770 finish_command_fsm_async_reply_reason,
1771 NULL, /* should_notify_stop */
1774 /* Allocate a new finish_command_fsm. */
1776 static struct finish_command_fsm *
1777 new_finish_command_fsm (struct interp *cmd_interp)
1779 struct finish_command_fsm *sm;
1781 sm = XCNEW (struct finish_command_fsm);
1782 thread_fsm_ctor (&sm->thread_fsm, &finish_command_fsm_ops, cmd_interp);
1787 /* Implementation of the 'should_stop' FSM method for the finish
1788 commands. Detects whether the thread stepped out of the function
1789 successfully, and if so, captures the function's return value and
1790 marks the FSM finished. */
1793 finish_command_fsm_should_stop (struct thread_fsm *self,
1794 struct thread_info *tp)
1796 struct finish_command_fsm *f = (struct finish_command_fsm *) self;
1797 struct return_value_info *rv = &f->return_value;
1799 if (f->function != NULL
1800 && bpstat_find_breakpoint (tp->control.stop_bpstat,
1801 f->breakpoint) != NULL)
1804 thread_fsm_set_finished (self);
1806 rv->type = TYPE_TARGET_TYPE (SYMBOL_TYPE (f->function));
1807 if (rv->type == NULL)
1808 internal_error (__FILE__, __LINE__,
1809 _("finish_command: function has no target type"));
1811 if (TYPE_CODE (rv->type) != TYPE_CODE_VOID)
1815 func = read_var_value (f->function, NULL, get_current_frame ());
1816 rv->value = get_return_value (func, rv->type);
1817 if (rv->value != NULL)
1818 rv->value_history_index = record_latest_value (rv->value);
1821 else if (tp->control.stop_step)
1823 /* Finishing from an inline frame, or reverse finishing. In
1824 either case, there's no way to retrieve the return value. */
1825 thread_fsm_set_finished (self);
1831 /* Implementation of the 'clean_up' FSM method for the finish
1835 finish_command_fsm_clean_up (struct thread_fsm *self,
1836 struct thread_info *thread)
1838 struct finish_command_fsm *f = (struct finish_command_fsm *) self;
1840 if (f->breakpoint != NULL)
1842 delete_breakpoint (f->breakpoint);
1843 f->breakpoint = NULL;
1845 delete_longjmp_breakpoint (thread->global_num);
1848 /* Implementation of the 'return_value' FSM method for the finish
1851 static struct return_value_info *
1852 finish_command_fsm_return_value (struct thread_fsm *self)
1854 struct finish_command_fsm *f = (struct finish_command_fsm *) self;
1856 return &f->return_value;
1859 /* Implementation of the 'async_reply_reason' FSM method for the
1862 static enum async_reply_reason
1863 finish_command_fsm_async_reply_reason (struct thread_fsm *self)
1865 if (execution_direction == EXEC_REVERSE)
1866 return EXEC_ASYNC_END_STEPPING_RANGE;
1868 return EXEC_ASYNC_FUNCTION_FINISHED;
1871 /* finish_backward -- helper function for finish_command. */
1874 finish_backward (struct finish_command_fsm *sm)
1876 struct symtab_and_line sal;
1877 struct thread_info *tp = inferior_thread ();
1879 CORE_ADDR func_addr;
1881 pc = get_frame_pc (get_current_frame ());
1883 if (find_pc_partial_function (pc, NULL, &func_addr, NULL) == 0)
1884 error (_("Cannot find bounds of current function"));
1886 sal = find_pc_line (func_addr, 0);
1888 tp->control.proceed_to_finish = 1;
1889 /* Special case: if we're sitting at the function entry point,
1890 then all we need to do is take a reverse singlestep. We
1891 don't need to set a breakpoint, and indeed it would do us
1894 Note that this can only happen at frame #0, since there's
1895 no way that a function up the stack can have a return address
1896 that's equal to its entry point. */
1900 struct frame_info *frame = get_selected_frame (NULL);
1901 struct gdbarch *gdbarch = get_frame_arch (frame);
1903 /* Set a step-resume at the function's entry point. Once that's
1904 hit, we'll do one more step backwards. */
1905 symtab_and_line sr_sal;
1907 sr_sal.pspace = get_frame_program_space (frame);
1908 insert_step_resume_breakpoint_at_sal (gdbarch,
1909 sr_sal, null_frame_id);
1911 proceed ((CORE_ADDR) -1, GDB_SIGNAL_DEFAULT);
1915 /* We're almost there -- we just need to back up by one more
1917 tp->control.step_range_start = tp->control.step_range_end = 1;
1918 proceed ((CORE_ADDR) -1, GDB_SIGNAL_DEFAULT);
1922 /* finish_forward -- helper function for finish_command. FRAME is the
1923 frame that called the function we're about to step out of. */
1926 finish_forward (struct finish_command_fsm *sm, struct frame_info *frame)
1928 struct frame_id frame_id = get_frame_id (frame);
1929 struct gdbarch *gdbarch = get_frame_arch (frame);
1930 struct symtab_and_line sal;
1931 struct thread_info *tp = inferior_thread ();
1933 sal = find_pc_line (get_frame_pc (frame), 0);
1934 sal.pc = get_frame_pc (frame);
1936 sm->breakpoint = set_momentary_breakpoint (gdbarch, sal,
1937 get_stack_frame_id (frame),
1938 bp_finish).release ();
1940 /* set_momentary_breakpoint invalidates FRAME. */
1943 set_longjmp_breakpoint (tp, frame_id);
1945 /* We want to print return value, please... */
1946 tp->control.proceed_to_finish = 1;
1948 proceed ((CORE_ADDR) -1, GDB_SIGNAL_DEFAULT);
1951 /* Skip frames for "finish". */
1953 static struct frame_info *
1954 skip_finish_frames (struct frame_info *frame)
1956 struct frame_info *start;
1962 frame = skip_tailcall_frames (frame);
1966 frame = skip_unwritable_frames (frame);
1970 while (start != frame);
1975 /* "finish": Set a temporary breakpoint at the place the selected
1976 frame will return to, then continue. */
1979 finish_command (const char *arg, int from_tty)
1981 struct frame_info *frame;
1983 struct finish_command_fsm *sm;
1984 struct thread_info *tp;
1987 ensure_not_tfind_mode ();
1988 ensure_valid_thread ();
1989 ensure_not_running ();
1991 /* Find out whether we must run in the background. */
1992 gdb::unique_xmalloc_ptr<char> stripped = strip_bg_char (arg, &async_exec);
1993 arg = stripped.get ();
1995 prepare_execution_command (¤t_target, async_exec);
1998 error (_("The \"finish\" command does not take any arguments."));
2000 frame = get_prev_frame (get_selected_frame (_("No selected frame.")));
2002 error (_("\"finish\" not meaningful in the outermost frame."));
2004 clear_proceed_status (0);
2006 tp = inferior_thread ();
2008 sm = new_finish_command_fsm (command_interp ());
2010 tp->thread_fsm = &sm->thread_fsm;
2012 /* Finishing from an inline frame is completely different. We don't
2013 try to show the "return value" - no way to locate it. */
2014 if (get_frame_type (get_selected_frame (_("No selected frame.")))
2017 /* Claim we are stepping in the calling frame. An empty step
2018 range means that we will stop once we aren't in a function
2019 called by that frame. We don't use the magic "1" value for
2020 step_range_end, because then infrun will think this is nexti,
2021 and not step over the rest of this inlined function call. */
2022 set_step_info (frame, {});
2023 tp->control.step_range_start = get_frame_pc (frame);
2024 tp->control.step_range_end = tp->control.step_range_start;
2025 tp->control.step_over_calls = STEP_OVER_ALL;
2027 /* Print info on the selected frame, including level number but not
2031 printf_filtered (_("Run till exit from "));
2032 print_stack_frame (get_selected_frame (NULL), 1, LOCATION, 0);
2035 proceed ((CORE_ADDR) -1, GDB_SIGNAL_DEFAULT);
2039 /* Find the function we will return from. */
2041 sm->function = find_pc_function (get_frame_pc (get_selected_frame (NULL)));
2043 /* Print info on the selected frame, including level number but not
2047 if (execution_direction == EXEC_REVERSE)
2048 printf_filtered (_("Run back to call of "));
2051 if (sm->function != NULL && TYPE_NO_RETURN (sm->function->type)
2052 && !query (_("warning: Function %s does not return normally.\n"
2053 "Try to finish anyway? "),
2054 SYMBOL_PRINT_NAME (sm->function)))
2055 error (_("Not confirmed."));
2056 printf_filtered (_("Run till exit from "));
2059 print_stack_frame (get_selected_frame (NULL), 1, LOCATION, 0);
2062 if (execution_direction == EXEC_REVERSE)
2063 finish_backward (sm);
2066 frame = skip_finish_frames (frame);
2069 error (_("Cannot find the caller frame."));
2071 finish_forward (sm, frame);
2077 info_program_command (const char *args, int from_tty)
2081 struct thread_info *tp;
2084 if (!target_has_execution)
2086 printf_filtered (_("The program being debugged is not being run.\n"));
2091 ptid = inferior_ptid;
2094 struct target_waitstatus ws;
2096 get_last_target_status (&ptid, &ws);
2099 if (ptid_equal (ptid, null_ptid) || is_exited (ptid))
2100 error (_("Invalid selected thread."));
2101 else if (is_running (ptid))
2102 error (_("Selected thread is running."));
2104 tp = find_thread_ptid (ptid);
2105 bs = tp->control.stop_bpstat;
2106 stat = bpstat_num (&bs, &num);
2108 target_files_info ();
2109 printf_filtered (_("Program stopped at %s.\n"),
2110 paddress (target_gdbarch (), stop_pc));
2111 if (tp->control.stop_step)
2112 printf_filtered (_("It stopped after being stepped.\n"));
2115 /* There may be several breakpoints in the same place, so this
2116 isn't as strange as it seems. */
2121 printf_filtered (_("It stopped at a breakpoint "
2122 "that has since been deleted.\n"));
2125 printf_filtered (_("It stopped at breakpoint %d.\n"), num);
2126 stat = bpstat_num (&bs, &num);
2129 else if (tp->suspend.stop_signal != GDB_SIGNAL_0)
2131 printf_filtered (_("It stopped with signal %s, %s.\n"),
2132 gdb_signal_to_name (tp->suspend.stop_signal),
2133 gdb_signal_to_string (tp->suspend.stop_signal));
2138 printf_filtered (_("Type \"info stack\" or \"info "
2139 "registers\" for more information.\n"));
2144 environment_info (const char *var, int from_tty)
2148 const char *val = current_inferior ()->environment.get (var);
2152 puts_filtered (var);
2153 puts_filtered (" = ");
2154 puts_filtered (val);
2155 puts_filtered ("\n");
2159 puts_filtered ("Environment variable \"");
2160 puts_filtered (var);
2161 puts_filtered ("\" not defined.\n");
2166 char **envp = current_inferior ()->environment.envp ();
2168 for (int idx = 0; envp[idx] != NULL; ++idx)
2170 puts_filtered (envp[idx]);
2171 puts_filtered ("\n");
2177 set_environment_command (const char *arg, int from_tty)
2179 const char *p, *val;
2183 error_no_arg (_("environment variable and value"));
2185 /* Find seperation between variable name and value. */
2186 p = (char *) strchr (arg, '=');
2187 val = (char *) strchr (arg, ' ');
2189 if (p != 0 && val != 0)
2191 /* We have both a space and an equals. If the space is before the
2192 equals, walk forward over the spaces til we see a nonspace
2193 (possibly the equals). */
2198 /* Now if the = is after the char following the spaces,
2199 take the char following the spaces. */
2203 else if (val != 0 && p == 0)
2207 error_no_arg (_("environment variable to set"));
2209 if (p == 0 || p[1] == 0)
2213 p = arg + strlen (arg); /* So that savestring below will work. */
2217 /* Not setting variable value to null. */
2219 while (*val == ' ' || *val == '\t')
2223 while (p != arg && (p[-1] == ' ' || p[-1] == '\t'))
2226 std::string var (arg, p - arg);
2229 printf_filtered (_("Setting environment variable "
2230 "\"%s\" to null value.\n"),
2232 current_inferior ()->environment.set (var.c_str (), "");
2235 current_inferior ()->environment.set (var.c_str (), val);
2239 unset_environment_command (const char *var, int from_tty)
2243 /* If there is no argument, delete all environment variables.
2244 Ask for confirmation if reading from the terminal. */
2245 if (!from_tty || query (_("Delete all environment variables? ")))
2246 current_inferior ()->environment.clear ();
2249 current_inferior ()->environment.unset (var);
2252 /* Handle the execution path (PATH variable). */
2254 static const char path_var_name[] = "PATH";
2257 path_info (const char *args, int from_tty)
2259 puts_filtered ("Executable and object file path: ");
2260 puts_filtered (current_inferior ()->environment.get (path_var_name));
2261 puts_filtered ("\n");
2264 /* Add zero or more directories to the front of the execution path. */
2267 path_command (const char *dirname, int from_tty)
2273 env = current_inferior ()->environment.get (path_var_name);
2274 /* Can be null if path is not set. */
2277 exec_path = xstrdup (env);
2278 mod_path (dirname, &exec_path);
2279 current_inferior ()->environment.set (path_var_name, exec_path);
2282 path_info ((char *) NULL, from_tty);
2287 pad_to_column (string_file &stream, int col)
2289 /* At least one space must be printed to separate columns. */
2291 const int size = stream.size ();
2293 stream.puts (n_spaces (col - size));
2296 /* Print out the register NAME with value VAL, to FILE, in the default
2300 default_print_one_register_info (struct ui_file *file,
2304 struct type *regtype = value_type (val);
2305 int print_raw_format;
2306 string_file format_stream;
2309 value_column_1 = 15,
2310 /* Give enough room for "0x", 16 hex digits and two spaces in
2311 preceding column. */
2312 value_column_2 = value_column_1 + 2 + 16 + 2,
2315 format_stream.puts (name);
2316 pad_to_column (format_stream, value_column_1);
2318 print_raw_format = (value_entirely_available (val)
2319 && !value_optimized_out (val));
2321 /* If virtual format is floating, print it that way, and in raw
2323 if (TYPE_CODE (regtype) == TYPE_CODE_FLT
2324 || TYPE_CODE (regtype) == TYPE_CODE_DECFLOAT)
2326 struct value_print_options opts;
2327 const gdb_byte *valaddr = value_contents_for_printing (val);
2328 enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (regtype));
2330 get_user_print_options (&opts);
2334 value_embedded_offset (val), 0,
2335 &format_stream, 0, val, &opts, current_language);
2337 if (print_raw_format)
2339 pad_to_column (format_stream, value_column_2);
2340 format_stream.puts ("(raw ");
2341 print_hex_chars (&format_stream, valaddr, TYPE_LENGTH (regtype),
2343 format_stream.putc (')');
2348 struct value_print_options opts;
2350 /* Print the register in hex. */
2351 get_formatted_print_options (&opts, 'x');
2354 value_embedded_offset (val), 0,
2355 &format_stream, 0, val, &opts, current_language);
2356 /* If not a vector register, print it also according to its
2358 if (print_raw_format && TYPE_VECTOR (regtype) == 0)
2360 pad_to_column (format_stream, value_column_2);
2361 get_user_print_options (&opts);
2364 value_embedded_offset (val), 0,
2365 &format_stream, 0, val, &opts, current_language);
2369 fputs_filtered (format_stream.c_str (), file);
2370 fprintf_filtered (file, "\n");
2373 /* Print out the machine register regnum. If regnum is -1, print all
2374 registers (print_all == 1) or all non-float and non-vector
2375 registers (print_all == 0).
2377 For most machines, having all_registers_info() print the
2378 register(s) one per line is good enough. If a different format is
2379 required, (eg, for MIPS or Pyramid 90x, which both have lots of
2380 regs), or there is an existing convention for showing all the
2381 registers, define the architecture method PRINT_REGISTERS_INFO to
2382 provide that format. */
2385 default_print_registers_info (struct gdbarch *gdbarch,
2386 struct ui_file *file,
2387 struct frame_info *frame,
2388 int regnum, int print_all)
2391 const int numregs = gdbarch_num_regs (gdbarch)
2392 + gdbarch_num_pseudo_regs (gdbarch);
2394 for (i = 0; i < numregs; i++)
2396 /* Decide between printing all regs, non-float / vector regs, or
2402 if (!gdbarch_register_reggroup_p (gdbarch, i, all_reggroup))
2407 if (!gdbarch_register_reggroup_p (gdbarch, i, general_reggroup))
2417 /* If the register name is empty, it is undefined for this
2418 processor, so don't display anything. */
2419 if (gdbarch_register_name (gdbarch, i) == NULL
2420 || *(gdbarch_register_name (gdbarch, i)) == '\0')
2423 default_print_one_register_info (file,
2424 gdbarch_register_name (gdbarch, i),
2425 value_of_register (i, frame));
2430 registers_info (const char *addr_exp, int fpregs)
2432 struct frame_info *frame;
2433 struct gdbarch *gdbarch;
2435 if (!target_has_registers)
2436 error (_("The program has no registers now."));
2437 frame = get_selected_frame (NULL);
2438 gdbarch = get_frame_arch (frame);
2442 gdbarch_print_registers_info (gdbarch, gdb_stdout,
2447 while (*addr_exp != '\0')
2452 /* Skip leading white space. */
2453 addr_exp = skip_spaces (addr_exp);
2455 /* Discard any leading ``$''. Check that there is something
2456 resembling a register following it. */
2457 if (addr_exp[0] == '$')
2459 if (isspace ((*addr_exp)) || (*addr_exp) == '\0')
2460 error (_("Missing register name"));
2462 /* Find the start/end of this register name/num/group. */
2464 while ((*addr_exp) != '\0' && !isspace ((*addr_exp)))
2468 /* Figure out what we've found and display it. */
2470 /* A register name? */
2472 int regnum = user_reg_map_name_to_regnum (gdbarch, start, end - start);
2476 /* User registers lie completely outside of the range of
2477 normal registers. Catch them early so that the target
2479 if (regnum >= gdbarch_num_regs (gdbarch)
2480 + gdbarch_num_pseudo_regs (gdbarch))
2482 struct value *regval = value_of_user_reg (regnum, frame);
2483 const char *regname = user_reg_map_regnum_to_name (gdbarch,
2486 /* Print in the same fashion
2487 gdbarch_print_registers_info's default
2488 implementation prints. */
2489 default_print_one_register_info (gdb_stdout,
2494 gdbarch_print_registers_info (gdbarch, gdb_stdout,
2495 frame, regnum, fpregs);
2500 /* A register group? */
2502 struct reggroup *group;
2504 for (group = reggroup_next (gdbarch, NULL);
2506 group = reggroup_next (gdbarch, group))
2508 /* Don't bother with a length check. Should the user
2509 enter a short register group name, go with the first
2510 group that matches. */
2511 if (strncmp (start, reggroup_name (group), end - start) == 0)
2519 regnum < gdbarch_num_regs (gdbarch)
2520 + gdbarch_num_pseudo_regs (gdbarch);
2523 if (gdbarch_register_reggroup_p (gdbarch, regnum, group))
2524 gdbarch_print_registers_info (gdbarch,
2532 /* Nothing matched. */
2533 error (_("Invalid register `%.*s'"), (int) (end - start), start);
2538 info_all_registers_command (const char *addr_exp, int from_tty)
2540 registers_info (addr_exp, 1);
2544 info_registers_command (const char *addr_exp, int from_tty)
2546 registers_info (addr_exp, 0);
2550 print_vector_info (struct ui_file *file,
2551 struct frame_info *frame, const char *args)
2553 struct gdbarch *gdbarch = get_frame_arch (frame);
2555 if (gdbarch_print_vector_info_p (gdbarch))
2556 gdbarch_print_vector_info (gdbarch, file, frame, args);
2560 int printed_something = 0;
2563 regnum < gdbarch_num_regs (gdbarch)
2564 + gdbarch_num_pseudo_regs (gdbarch);
2567 if (gdbarch_register_reggroup_p (gdbarch, regnum, vector_reggroup))
2569 printed_something = 1;
2570 gdbarch_print_registers_info (gdbarch, file, frame, regnum, 1);
2573 if (!printed_something)
2574 fprintf_filtered (file, "No vector information\n");
2579 info_vector_command (const char *args, int from_tty)
2581 if (!target_has_registers)
2582 error (_("The program has no registers now."));
2584 print_vector_info (gdb_stdout, get_selected_frame (NULL), args);
2587 /* Kill the inferior process. Make us have no inferior. */
2590 kill_command (const char *arg, int from_tty)
2592 /* FIXME: This should not really be inferior_ptid (or target_has_execution).
2593 It should be a distinct flag that indicates that a target is active, cuz
2594 some targets don't have processes! */
2596 if (ptid_equal (inferior_ptid, null_ptid))
2597 error (_("The program is not being run."));
2598 if (!query (_("Kill the program being debugged? ")))
2599 error (_("Not confirmed."));
2602 /* If we still have other inferiors to debug, then don't mess with
2603 with their threads. */
2604 if (!have_inferiors ())
2606 init_thread_list (); /* Destroy thread info. */
2608 /* Killing off the inferior can leave us with a core file. If
2609 so, print the state we are left in. */
2610 if (target_has_stack)
2612 printf_filtered (_("In %s,\n"), target_longname);
2613 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1);
2616 bfd_cache_close_all ();
2619 /* Used in `attach&' command. ARG is a point to an integer
2620 representing a process id. Proceed threads of this process iff
2621 they stopped due to debugger request, and when they did, they
2622 reported a clean stop (GDB_SIGNAL_0). Do not proceed threads
2623 that have been explicitly been told to stop. */
2626 proceed_after_attach_callback (struct thread_info *thread,
2629 int pid = * (int *) arg;
2631 if (ptid_get_pid (thread->ptid) == pid
2632 && !is_exited (thread->ptid)
2633 && !is_executing (thread->ptid)
2634 && !thread->stop_requested
2635 && thread->suspend.stop_signal == GDB_SIGNAL_0)
2637 switch_to_thread (thread->ptid);
2638 clear_proceed_status (0);
2639 proceed ((CORE_ADDR) -1, GDB_SIGNAL_DEFAULT);
2646 proceed_after_attach (int pid)
2648 /* Don't error out if the current thread is running, because
2649 there may be other stopped threads. */
2651 /* Backup current thread and selected frame. */
2652 scoped_restore_current_thread restore_thread;
2654 iterate_over_threads (proceed_after_attach_callback, &pid);
2657 /* See inferior.h. */
2660 setup_inferior (int from_tty)
2662 struct inferior *inferior;
2664 inferior = current_inferior ();
2665 inferior->needs_setup = 0;
2667 /* If no exec file is yet known, try to determine it from the
2669 if (get_exec_file (0) == NULL)
2670 exec_file_locate_attach (ptid_get_pid (inferior_ptid), 1, from_tty);
2673 reopen_exec_file ();
2677 /* Take any necessary post-attaching actions for this platform. */
2678 target_post_attach (ptid_get_pid (inferior_ptid));
2680 post_create_inferior (¤t_target, from_tty);
2683 /* What to do after the first program stops after attaching. */
2684 enum attach_post_wait_mode
2686 /* Do nothing. Leaves threads as they are. */
2687 ATTACH_POST_WAIT_NOTHING,
2689 /* Re-resume threads that are marked running. */
2690 ATTACH_POST_WAIT_RESUME,
2692 /* Stop all threads. */
2693 ATTACH_POST_WAIT_STOP,
2696 /* Called after we've attached to a process and we've seen it stop for
2697 the first time. If ASYNC_EXEC is true, re-resume threads that
2698 should be running. Else if ATTACH, */
2701 attach_post_wait (const char *args, int from_tty, enum attach_post_wait_mode mode)
2703 struct inferior *inferior;
2705 inferior = current_inferior ();
2706 inferior->control.stop_soon = NO_STOP_QUIETLY;
2708 if (inferior->needs_setup)
2709 setup_inferior (from_tty);
2711 if (mode == ATTACH_POST_WAIT_RESUME)
2713 /* The user requested an `attach&', so be sure to leave threads
2714 that didn't get a signal running. */
2716 /* Immediatelly resume all suspended threads of this inferior,
2717 and this inferior only. This should have no effect on
2718 already running threads. If a thread has been stopped with a
2719 signal, leave it be. */
2721 proceed_after_attach (inferior->pid);
2724 if (inferior_thread ()->suspend.stop_signal == GDB_SIGNAL_0)
2726 clear_proceed_status (0);
2727 proceed ((CORE_ADDR) -1, GDB_SIGNAL_DEFAULT);
2731 else if (mode == ATTACH_POST_WAIT_STOP)
2733 /* The user requested a plain `attach', so be sure to leave
2734 the inferior stopped. */
2736 /* At least the current thread is already stopped. */
2738 /* In all-stop, by definition, all threads have to be already
2739 stopped at this point. In non-stop, however, although the
2740 selected thread is stopped, others may still be executing.
2741 Be sure to explicitly stop all threads of the process. This
2742 should have no effect on already stopped threads. */
2744 target_stop (pid_to_ptid (inferior->pid));
2745 else if (target_is_non_stop_p ())
2747 struct thread_info *thread;
2748 struct thread_info *lowest = inferior_thread ();
2749 int pid = current_inferior ()->pid;
2751 stop_all_threads ();
2753 /* It's not defined which thread will report the attach
2754 stop. For consistency, always select the thread with
2755 lowest GDB number, which should be the main thread, if it
2757 ALL_NON_EXITED_THREADS (thread)
2759 if (ptid_get_pid (thread->ptid) == pid)
2761 if (thread->inf->num < lowest->inf->num
2762 || thread->per_inf_num < lowest->per_inf_num)
2767 switch_to_thread (lowest->ptid);
2770 /* Tell the user/frontend where we're stopped. */
2772 if (deprecated_attach_hook)
2773 deprecated_attach_hook ();
2777 struct attach_command_continuation_args
2781 enum attach_post_wait_mode mode;
2785 attach_command_continuation (void *args, int err)
2787 struct attach_command_continuation_args *a
2788 = (struct attach_command_continuation_args *) args;
2793 attach_post_wait (a->args, a->from_tty, a->mode);
2797 attach_command_continuation_free_args (void *args)
2799 struct attach_command_continuation_args *a
2800 = (struct attach_command_continuation_args *) args;
2806 /* "attach" command entry point. Takes a program started up outside
2807 of gdb and ``attaches'' to it. This stops it cold in its tracks
2808 and allows us to start debugging it. */
2811 attach_command (const char *args, int from_tty)
2814 struct target_ops *attach_target;
2815 struct inferior *inferior = current_inferior ();
2816 enum attach_post_wait_mode mode;
2818 dont_repeat (); /* Not for the faint of heart */
2820 if (gdbarch_has_global_solist (target_gdbarch ()))
2821 /* Don't complain if all processes share the same symbol
2824 else if (target_has_execution)
2826 if (query (_("A program is being debugged already. Kill it? ")))
2829 error (_("Not killed."));
2832 /* Clean up any leftovers from other runs. Some other things from
2833 this function should probably be moved into target_pre_inferior. */
2834 target_pre_inferior (from_tty);
2836 gdb::unique_xmalloc_ptr<char> stripped = strip_bg_char (args, &async_exec);
2837 args = stripped.get ();
2839 attach_target = find_attach_target ();
2841 prepare_execution_command (attach_target, async_exec);
2843 if (non_stop && !attach_target->to_supports_non_stop (attach_target))
2844 error (_("Cannot attach to this target in non-stop mode"));
2846 attach_target->to_attach (attach_target, args, from_tty);
2847 /* to_attach should push the target, so after this point we
2848 shouldn't refer to attach_target again. */
2849 attach_target = NULL;
2851 /* Set up the "saved terminal modes" of the inferior
2852 based on what modes we are starting it with. */
2853 target_terminal::init ();
2855 /* Install inferior's terminal modes. This may look like a no-op,
2856 as we've just saved them above, however, this does more than
2857 restore terminal settings:
2859 - installs a SIGINT handler that forwards SIGINT to the inferior.
2860 Otherwise a Ctrl-C pressed just while waiting for the initial
2861 stop would end up as a spurious Quit.
2863 - removes stdin from the event loop, which we need if attaching
2864 in the foreground, otherwise on targets that report an initial
2865 stop on attach (which are most) we'd process input/commands
2866 while we're in the event loop waiting for that stop. That is,
2867 before the attach continuation runs and the command is really
2869 target_terminal::inferior ();
2871 /* Set up execution context to know that we should return from
2872 wait_for_inferior as soon as the target reports a stop. */
2873 init_wait_for_inferior ();
2874 clear_proceed_status (0);
2876 inferior->needs_setup = 1;
2878 if (target_is_non_stop_p ())
2880 /* If we find that the current thread isn't stopped, explicitly
2881 do so now, because we're going to install breakpoints and
2885 /* The user requested an `attach&'; stop just one thread. */
2886 target_stop (inferior_ptid);
2888 /* The user requested an `attach', so stop all threads of this
2890 target_stop (pid_to_ptid (ptid_get_pid (inferior_ptid)));
2893 mode = async_exec ? ATTACH_POST_WAIT_RESUME : ATTACH_POST_WAIT_STOP;
2895 /* Some system don't generate traps when attaching to inferior.
2896 E.g. Mach 3 or GNU hurd. */
2897 if (!target_attach_no_wait)
2899 struct attach_command_continuation_args *a;
2901 /* Careful here. See comments in inferior.h. Basically some
2902 OSes don't ignore SIGSTOPs on continue requests anymore. We
2903 need a way for handle_inferior_event to reset the stop_signal
2904 variable after an attach, and this is what
2905 STOP_QUIETLY_NO_SIGSTOP is for. */
2906 inferior->control.stop_soon = STOP_QUIETLY_NO_SIGSTOP;
2908 /* Wait for stop. */
2909 a = XNEW (struct attach_command_continuation_args);
2910 a->args = xstrdup (args);
2911 a->from_tty = from_tty;
2913 add_inferior_continuation (attach_command_continuation, a,
2914 attach_command_continuation_free_args);
2916 if (!target_is_async_p ())
2917 mark_infrun_async_event_handler ();
2921 attach_post_wait (args, from_tty, mode);
2924 /* We had just found out that the target was already attached to an
2925 inferior. PTID points at a thread of this new inferior, that is
2926 the most likely to be stopped right now, but not necessarily so.
2927 The new inferior is assumed to be already added to the inferior
2928 list at this point. If LEAVE_RUNNING, then leave the threads of
2929 this inferior running, except those we've explicitly seen reported
2933 notice_new_inferior (ptid_t ptid, int leave_running, int from_tty)
2935 enum attach_post_wait_mode mode
2936 = leave_running ? ATTACH_POST_WAIT_RESUME : ATTACH_POST_WAIT_NOTHING;
2938 gdb::optional<scoped_restore_current_thread> restore_thread;
2940 if (inferior_ptid != null_ptid)
2941 restore_thread.emplace ();
2943 /* Avoid reading registers -- we haven't fetched the target
2945 switch_to_thread_no_regs (find_thread_ptid (ptid));
2947 /* When we "notice" a new inferior we need to do all the things we
2948 would normally do if we had just attached to it. */
2950 if (is_executing (inferior_ptid))
2952 struct attach_command_continuation_args *a;
2953 struct inferior *inferior = current_inferior ();
2955 /* We're going to install breakpoints, and poke at memory,
2956 ensure that the inferior is stopped for a moment while we do
2958 target_stop (inferior_ptid);
2960 inferior->control.stop_soon = STOP_QUIETLY_REMOTE;
2962 /* Wait for stop before proceeding. */
2963 a = XNEW (struct attach_command_continuation_args);
2964 a->args = xstrdup ("");
2965 a->from_tty = from_tty;
2967 add_inferior_continuation (attach_command_continuation, a,
2968 attach_command_continuation_free_args);
2973 attach_post_wait ("" /* args */, from_tty, mode);
2978 * takes a program previously attached to and detaches it.
2979 * The program resumes execution and will no longer stop
2980 * on signals, etc. We better not have left any breakpoints
2981 * in the program or it'll die when it hits one. For this
2982 * to work, it may be necessary for the process to have been
2983 * previously attached. It *might* work if the program was
2984 * started via the normal ptrace (PTRACE_TRACEME).
2988 detach_command (const char *args, int from_tty)
2990 dont_repeat (); /* Not for the faint of heart. */
2992 if (ptid_equal (inferior_ptid, null_ptid))
2993 error (_("The program is not being run."));
2995 query_if_trace_running (from_tty);
2997 disconnect_tracing ();
2999 target_detach (current_inferior (), from_tty);
3001 /* The current inferior process was just detached successfully. Get
3002 rid of breakpoints that no longer make sense. Note we don't do
3003 this within target_detach because that is also used when
3004 following child forks, and in that case we will want to transfer
3005 breakpoints to the child, not delete them. */
3006 breakpoint_init_inferior (inf_exited);
3008 /* If the solist is global across inferiors, don't clear it when we
3009 detach from a single inferior. */
3010 if (!gdbarch_has_global_solist (target_gdbarch ()))
3011 no_shared_libraries (NULL, from_tty);
3013 /* If we still have inferiors to debug, then don't mess with their
3015 if (!have_inferiors ())
3016 init_thread_list ();
3018 if (deprecated_detach_hook)
3019 deprecated_detach_hook ();
3022 /* Disconnect from the current target without resuming it (leaving it
3023 waiting for a debugger).
3025 We'd better not have left any breakpoints in the program or the
3026 next debugger will get confused. Currently only supported for some
3027 remote targets, since the normal attach mechanisms don't work on
3028 stopped processes on some native platforms (e.g. GNU/Linux). */
3031 disconnect_command (const char *args, int from_tty)
3033 dont_repeat (); /* Not for the faint of heart. */
3034 query_if_trace_running (from_tty);
3035 disconnect_tracing ();
3036 target_disconnect (args, from_tty);
3037 no_shared_libraries (NULL, from_tty);
3038 init_thread_list ();
3039 if (deprecated_detach_hook)
3040 deprecated_detach_hook ();
3044 interrupt_target_1 (int all_threads)
3049 ptid = minus_one_ptid;
3051 ptid = inferior_ptid;
3056 target_interrupt ();
3058 /* Tag the thread as having been explicitly requested to stop, so
3059 other parts of gdb know not to resume this thread automatically,
3060 if it was stopped due to an internal event. Limit this to
3061 non-stop mode, as when debugging a multi-threaded application in
3062 all-stop mode, we will only get one stop event --- it's undefined
3063 which thread will report the event. */
3065 set_stop_requested (ptid, 1);
3069 Stop the execution of the target while running in async mode, in
3070 the background. In all-stop, stop the whole process. In non-stop
3071 mode, stop the current thread only by default, or stop all threads
3072 if the `-a' switch is used. */
3075 interrupt_command (const char *args, int from_tty)
3077 if (target_can_async_p ())
3079 int all_threads = 0;
3081 dont_repeat (); /* Not for the faint of heart. */
3084 && startswith (args, "-a"))
3087 if (!non_stop && all_threads)
3088 error (_("-a is meaningless in all-stop mode."));
3090 interrupt_target_1 (all_threads);
3094 /* See inferior.h. */
3097 default_print_float_info (struct gdbarch *gdbarch, struct ui_file *file,
3098 struct frame_info *frame, const char *args)
3101 int printed_something = 0;
3104 regnum < gdbarch_num_regs (gdbarch)
3105 + gdbarch_num_pseudo_regs (gdbarch);
3108 if (gdbarch_register_reggroup_p (gdbarch, regnum, float_reggroup))
3110 printed_something = 1;
3111 gdbarch_print_registers_info (gdbarch, file, frame, regnum, 1);
3114 if (!printed_something)
3115 fprintf_filtered (file, "No floating-point info "
3116 "available for this processor.\n");
3120 info_float_command (const char *args, int from_tty)
3122 struct frame_info *frame;
3124 if (!target_has_registers)
3125 error (_("The program has no registers now."));
3127 frame = get_selected_frame (NULL);
3128 gdbarch_print_float_info (get_frame_arch (frame), gdb_stdout, frame, args);
3132 unset_command (const char *args, int from_tty)
3134 printf_filtered (_("\"unset\" must be followed by the "
3135 "name of an unset subcommand.\n"));
3136 help_list (unsetlist, "unset ", all_commands, gdb_stdout);
3139 /* Implement `info proc' family of commands. */
3142 info_proc_cmd_1 (const char *args, enum info_proc_what what, int from_tty)
3144 struct gdbarch *gdbarch = get_current_arch ();
3146 if (!target_info_proc (args, what))
3148 if (gdbarch_info_proc_p (gdbarch))
3149 gdbarch_info_proc (gdbarch, args, what);
3151 error (_("Not supported on this target."));
3155 /* Implement `info proc' when given without any futher parameters. */
3158 info_proc_cmd (const char *args, int from_tty)
3160 info_proc_cmd_1 (args, IP_MINIMAL, from_tty);
3163 /* Implement `info proc mappings'. */
3166 info_proc_cmd_mappings (const char *args, int from_tty)
3168 info_proc_cmd_1 (args, IP_MAPPINGS, from_tty);
3171 /* Implement `info proc stat'. */
3174 info_proc_cmd_stat (const char *args, int from_tty)
3176 info_proc_cmd_1 (args, IP_STAT, from_tty);
3179 /* Implement `info proc status'. */
3182 info_proc_cmd_status (const char *args, int from_tty)
3184 info_proc_cmd_1 (args, IP_STATUS, from_tty);
3187 /* Implement `info proc cwd'. */
3190 info_proc_cmd_cwd (const char *args, int from_tty)
3192 info_proc_cmd_1 (args, IP_CWD, from_tty);
3195 /* Implement `info proc cmdline'. */
3198 info_proc_cmd_cmdline (const char *args, int from_tty)
3200 info_proc_cmd_1 (args, IP_CMDLINE, from_tty);
3203 /* Implement `info proc exe'. */
3206 info_proc_cmd_exe (const char *args, int from_tty)
3208 info_proc_cmd_1 (args, IP_EXE, from_tty);
3211 /* Implement `info proc all'. */
3214 info_proc_cmd_all (const char *args, int from_tty)
3216 info_proc_cmd_1 (args, IP_ALL, from_tty);
3219 /* This help string is used for the run, start, and starti commands.
3220 It is defined as a macro to prevent duplication. */
3222 #define RUN_ARGS_HELP \
3223 "You may specify arguments to give it.\n\
3224 Args may include \"*\", or \"[...]\"; they are expanded using the\n\
3225 shell that will start the program (specified by the \"$SHELL\" environment\n\
3226 variable). Input and output redirection with \">\", \"<\", or \">>\"\n\
3227 are also allowed.\n\
3229 With no arguments, uses arguments last specified (with \"run\" or \n\
3230 \"set args\"). To cancel previous arguments and run with no arguments,\n\
3231 use \"set args\" without arguments.\n\
3233 To start the inferior without using a shell, use \"set startup-with-shell off\"."
3236 _initialize_infcmd (void)
3238 static struct cmd_list_element *info_proc_cmdlist;
3239 struct cmd_list_element *c = NULL;
3240 const char *cmd_name;
3242 /* Add the filename of the terminal connected to inferior I/O. */
3243 add_setshow_optional_filename_cmd ("inferior-tty", class_run,
3244 &inferior_io_terminal_scratch, _("\
3245 Set terminal for future runs of program being debugged."), _("\
3246 Show terminal for future runs of program being debugged."), _("\
3247 Usage: set inferior-tty [TTY]\n\n\
3248 If TTY is omitted, the default behavior of using the same terminal as GDB\n\
3250 set_inferior_tty_command,
3251 show_inferior_tty_command,
3252 &setlist, &showlist);
3253 cmd_name = "inferior-tty";
3254 c = lookup_cmd (&cmd_name, setlist, "", -1, 1);
3255 gdb_assert (c != NULL);
3256 add_alias_cmd ("tty", c, class_alias, 0, &cmdlist);
3259 add_setshow_string_noescape_cmd (cmd_name, class_run,
3260 &inferior_args_scratch, _("\
3261 Set argument list to give program being debugged when it is started."), _("\
3262 Show argument list to give program being debugged when it is started."), _("\
3263 Follow this command with any number of args, to be passed to the program."),
3266 &setlist, &showlist);
3267 c = lookup_cmd (&cmd_name, setlist, "", -1, 1);
3268 gdb_assert (c != NULL);
3269 set_cmd_completer (c, filename_completer);
3272 add_setshow_string_noescape_cmd (cmd_name, class_run,
3273 &inferior_cwd_scratch, _("\
3274 Set the current working directory to be used when the inferior is started.\n\
3275 Changing this setting does not have any effect on inferiors that are\n\
3278 Show the current working directory that is used when the inferior is started."),
3280 Use this command to change the current working directory that will be used\n\
3281 when the inferior is started. This setting does not affect GDB's current\n\
3282 working directory."),
3285 &setlist, &showlist);
3286 c = lookup_cmd (&cmd_name, setlist, "", -1, 1);
3287 gdb_assert (c != NULL);
3288 set_cmd_completer (c, filename_completer);
3290 c = add_cmd ("environment", no_class, environment_info, _("\
3291 The environment to give the program, or one variable's value.\n\
3292 With an argument VAR, prints the value of environment variable VAR to\n\
3293 give the program being debugged. With no arguments, prints the entire\n\
3294 environment to be given to the program."), &showlist);
3295 set_cmd_completer (c, noop_completer);
3297 add_prefix_cmd ("unset", no_class, unset_command,
3298 _("Complement to certain \"set\" commands."),
3299 &unsetlist, "unset ", 0, &cmdlist);
3301 c = add_cmd ("environment", class_run, unset_environment_command, _("\
3302 Cancel environment variable VAR for the program.\n\
3303 This does not affect the program until the next \"run\" command."),
3305 set_cmd_completer (c, noop_completer);
3307 c = add_cmd ("environment", class_run, set_environment_command, _("\
3308 Set environment variable value to give the program.\n\
3309 Arguments are VAR VALUE where VAR is variable name and VALUE is value.\n\
3310 VALUES of environment variables are uninterpreted strings.\n\
3311 This does not affect the program until the next \"run\" command."),
3313 set_cmd_completer (c, noop_completer);
3315 c = add_com ("path", class_files, path_command, _("\
3316 Add directory DIR(s) to beginning of search path for object files.\n\
3317 $cwd in the path means the current working directory.\n\
3318 This path is equivalent to the $PATH shell variable. It is a list of\n\
3319 directories, separated by colons. These directories are searched to find\n\
3320 fully linked executable files and separately compiled object files as \
3322 set_cmd_completer (c, filename_completer);
3324 c = add_cmd ("paths", no_class, path_info, _("\
3325 Current search path for finding object files.\n\
3326 $cwd in the path means the current working directory.\n\
3327 This path is equivalent to the $PATH shell variable. It is a list of\n\
3328 directories, separated by colons. These directories are searched to find\n\
3329 fully linked executable files and separately compiled object files as \
3332 set_cmd_completer (c, noop_completer);
3334 add_prefix_cmd ("kill", class_run, kill_command,
3335 _("Kill execution of program being debugged."),
3336 &killlist, "kill ", 0, &cmdlist);
3338 add_com ("attach", class_run, attach_command, _("\
3339 Attach to a process or file outside of GDB.\n\
3340 This command attaches to another target, of the same type as your last\n\
3341 \"target\" command (\"info files\" will show your target stack).\n\
3342 The command may take as argument a process id or a device file.\n\
3343 For a process id, you must have permission to send the process a signal,\n\
3344 and it must have the same effective uid as the debugger.\n\
3345 When using \"attach\" with a process id, the debugger finds the\n\
3346 program running in the process, looking first in the current working\n\
3347 directory, or (if not found there) using the source file search path\n\
3348 (see the \"directory\" command). You can also use the \"file\" command\n\
3349 to specify the program, and to load its symbol table."));
3351 add_prefix_cmd ("detach", class_run, detach_command, _("\
3352 Detach a process or file previously attached.\n\
3353 If a process, it is no longer traced, and it continues its execution. If\n\
3354 you were debugging a file, the file is closed and gdb no longer accesses it."),
3355 &detachlist, "detach ", 0, &cmdlist);
3357 add_com ("disconnect", class_run, disconnect_command, _("\
3358 Disconnect from a target.\n\
3359 The target will wait for another debugger to connect. Not available for\n\
3362 c = add_com ("signal", class_run, signal_command, _("\
3363 Continue program with the specified signal.\n\
3364 Usage: signal SIGNAL\n\
3365 The SIGNAL argument is processed the same as the handle command.\n\
3367 An argument of \"0\" means continue the program without sending it a signal.\n\
3368 This is useful in cases where the program stopped because of a signal,\n\
3369 and you want to resume the program while discarding the signal.\n\
3371 In a multi-threaded program the signal is delivered to, or discarded from,\n\
3372 the current thread only."));
3373 set_cmd_completer (c, signal_completer);
3375 c = add_com ("queue-signal", class_run, queue_signal_command, _("\
3376 Queue a signal to be delivered to the current thread when it is resumed.\n\
3377 Usage: queue-signal SIGNAL\n\
3378 The SIGNAL argument is processed the same as the handle command.\n\
3379 It is an error if the handling state of SIGNAL is \"nopass\".\n\
3381 An argument of \"0\" means remove any currently queued signal from\n\
3382 the current thread. This is useful in cases where the program stopped\n\
3383 because of a signal, and you want to resume it while discarding the signal.\n\
3385 In a multi-threaded program the signal is queued with, or discarded from,\n\
3386 the current thread only."));
3387 set_cmd_completer (c, signal_completer);
3389 add_com ("stepi", class_run, stepi_command, _("\
3390 Step one instruction exactly.\n\
3392 Argument N means step N times (or till program stops for another \
3394 add_com_alias ("si", "stepi", class_alias, 0);
3396 add_com ("nexti", class_run, nexti_command, _("\
3397 Step one instruction, but proceed through subroutine calls.\n\
3399 Argument N means step N times (or till program stops for another \
3401 add_com_alias ("ni", "nexti", class_alias, 0);
3403 add_com ("finish", class_run, finish_command, _("\
3404 Execute until selected stack frame returns.\n\
3406 Upon return, the value returned is printed and put in the value history."));
3407 add_com_alias ("fin", "finish", class_run, 1);
3409 add_com ("next", class_run, next_command, _("\
3410 Step program, proceeding through subroutine calls.\n\
3412 Unlike \"step\", if the current source line calls a subroutine,\n\
3413 this command does not enter the subroutine, but instead steps over\n\
3414 the call, in effect treating it as a single source line."));
3415 add_com_alias ("n", "next", class_run, 1);
3417 add_com ("step", class_run, step_command, _("\
3418 Step program until it reaches a different source line.\n\
3420 Argument N means step N times (or till program stops for another \
3422 add_com_alias ("s", "step", class_run, 1);
3424 c = add_com ("until", class_run, until_command, _("\
3425 Execute until the program reaches a source line greater than the current\n\
3426 or a specified location (same args as break command) within the current \
3428 set_cmd_completer (c, location_completer);
3429 add_com_alias ("u", "until", class_run, 1);
3431 c = add_com ("advance", class_run, advance_command, _("\
3432 Continue the program up to the given location (same form as args for break \
3434 Execution will also stop upon exit from the current stack frame."));
3435 set_cmd_completer (c, location_completer);
3437 c = add_com ("jump", class_run, jump_command, _("\
3438 Continue program being debugged at specified line or address.\n\
3439 Usage: jump <location>\n\
3440 Give as argument either LINENUM or *ADDR, where ADDR is an expression\n\
3441 for an address to start at."));
3442 set_cmd_completer (c, location_completer);
3443 add_com_alias ("j", "jump", class_run, 1);
3445 add_com ("continue", class_run, continue_command, _("\
3446 Continue program being debugged, after signal or breakpoint.\n\
3447 Usage: continue [N]\n\
3448 If proceeding from breakpoint, a number N may be used as an argument,\n\
3449 which means to set the ignore count of that breakpoint to N - 1 (so that\n\
3450 the breakpoint won't break until the Nth time it is reached).\n\
3452 If non-stop mode is enabled, continue only the current thread,\n\
3453 otherwise all the threads in the program are continued. To \n\
3454 continue all stopped threads in non-stop mode, use the -a option.\n\
3455 Specifying -a and an ignore count simultaneously is an error."));
3456 add_com_alias ("c", "cont", class_run, 1);
3457 add_com_alias ("fg", "cont", class_run, 1);
3459 c = add_com ("run", class_run, run_command, _("\
3460 Start debugged program.\n"
3462 set_cmd_completer (c, filename_completer);
3463 add_com_alias ("r", "run", class_run, 1);
3465 c = add_com ("start", class_run, start_command, _("\
3466 Start the debugged program stopping at the beginning of the main procedure.\n"
3468 set_cmd_completer (c, filename_completer);
3470 c = add_com ("starti", class_run, starti_command, _("\
3471 Start the debugged program stopping at the first instruction.\n"
3473 set_cmd_completer (c, filename_completer);
3475 add_com ("interrupt", class_run, interrupt_command,
3476 _("Interrupt the execution of the debugged program.\n\
3477 If non-stop mode is enabled, interrupt only the current thread,\n\
3478 otherwise all the threads in the program are stopped. To \n\
3479 interrupt all running threads in non-stop mode, use the -a option."));
3481 c = add_info ("registers", info_registers_command, _("\
3482 List of integer registers and their contents, for selected stack frame.\n\
3483 One or more register names as argument means describe the given registers.\n\
3484 One or more register group names as argument means describe the registers\n\
3485 in the named register groups."));
3486 add_info_alias ("r", "registers", 1);
3487 set_cmd_completer (c, reg_or_group_completer);
3489 c = add_info ("all-registers", info_all_registers_command, _("\
3490 List of all registers and their contents, for selected stack frame.\n\
3491 One or more register names as argument means describe the given registers.\n\
3492 One or more register group names as argument means describe the registers\n\
3493 in the named register groups."));
3494 set_cmd_completer (c, reg_or_group_completer);
3496 add_info ("program", info_program_command,
3497 _("Execution status of the program."));
3499 add_info ("float", info_float_command,
3500 _("Print the status of the floating point unit\n"));
3502 add_info ("vector", info_vector_command,
3503 _("Print the status of the vector unit\n"));
3505 add_prefix_cmd ("proc", class_info, info_proc_cmd,
3507 Show /proc process information about any running process.\n\
3508 Specify any process id, or use the program being debugged by default."),
3509 &info_proc_cmdlist, "info proc ",
3510 1/*allow-unknown*/, &infolist);
3512 add_cmd ("mappings", class_info, info_proc_cmd_mappings, _("\
3513 List of mapped memory regions."),
3514 &info_proc_cmdlist);
3516 add_cmd ("stat", class_info, info_proc_cmd_stat, _("\
3517 List process info from /proc/PID/stat."),
3518 &info_proc_cmdlist);
3520 add_cmd ("status", class_info, info_proc_cmd_status, _("\
3521 List process info from /proc/PID/status."),
3522 &info_proc_cmdlist);
3524 add_cmd ("cwd", class_info, info_proc_cmd_cwd, _("\
3525 List current working directory of the process."),
3526 &info_proc_cmdlist);
3528 add_cmd ("cmdline", class_info, info_proc_cmd_cmdline, _("\
3529 List command line arguments of the process."),
3530 &info_proc_cmdlist);
3532 add_cmd ("exe", class_info, info_proc_cmd_exe, _("\
3533 List absolute filename for executable of the process."),
3534 &info_proc_cmdlist);
3536 add_cmd ("all", class_info, info_proc_cmd_all, _("\
3537 List all available /proc info."),
3538 &info_proc_cmdlist);