1 /* Memory-access and commands for "inferior" process, for GDB.
3 Copyright (C) 1986-2017 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 #include "arch-utils.h"
36 #include "completer.h"
38 #include "event-top.h"
39 #include "parser-defs.h"
41 #include "reggroups.h"
46 #include "target-descriptions.h"
47 #include "user-regs.h"
48 #include "cli/cli-decode.h"
49 #include "gdbthread.h"
51 #include "inline-frame.h"
52 #include "tracepoint.h"
54 #include "continuations.h"
56 #include "cli/cli-utils.h"
58 #include "thread-fsm.h"
61 #include "common/gdb_optional.h"
63 /* Local functions: */
65 static void until_next_command (int);
67 static void step_1 (int, int, const char *);
69 #define ERROR_NO_INFERIOR \
70 if (!target_has_execution) error (_("The program is not being run."));
72 /* Scratch area where string containing arguments to give to the
73 program will be stored by 'set args'. As soon as anything is
74 stored, notice_args_set will move it into per-inferior storage.
75 Arguments are separated by spaces. Empty string (pointer to '\0')
78 static char *inferior_args_scratch;
80 /* Scratch area where the new cwd will be stored by 'set cwd'. */
82 static char *inferior_cwd_scratch;
84 /* Scratch area where 'set inferior-tty' will store user-provided value.
85 We'll immediate copy it into per-inferior storage. */
87 static char *inferior_io_terminal_scratch;
89 /* Pid of our debugged inferior, or 0 if no inferior now.
90 Since various parts of infrun.c test this to see whether there is a program
91 being debugged it should be nonzero (currently 3 is used) for remote
96 /* Address at which inferior stopped. */
100 /* Nonzero if stopped due to completion of a stack dummy routine. */
102 enum stop_stack_kind stop_stack_dummy;
104 /* Nonzero if stopped due to a random (unexpected) signal in inferior
107 int stopped_by_random_signal;
109 /* See inferior.h. */
111 int startup_with_shell = 1;
114 /* Accessor routines. */
116 /* Set the io terminal for the current inferior. Ownership of
117 TERMINAL_NAME is not transferred. */
120 set_inferior_io_terminal (const char *terminal_name)
122 xfree (current_inferior ()->terminal);
124 if (terminal_name != NULL && *terminal_name != '\0')
125 current_inferior ()->terminal = xstrdup (terminal_name);
127 current_inferior ()->terminal = NULL;
131 get_inferior_io_terminal (void)
133 return current_inferior ()->terminal;
137 set_inferior_tty_command (const char *args, int from_tty,
138 struct cmd_list_element *c)
140 /* CLI has assigned the user-provided value to inferior_io_terminal_scratch.
141 Now route it to current inferior. */
142 set_inferior_io_terminal (inferior_io_terminal_scratch);
146 show_inferior_tty_command (struct ui_file *file, int from_tty,
147 struct cmd_list_element *c, const char *value)
149 /* Note that we ignore the passed-in value in favor of computing it
151 const char *inferior_io_terminal = get_inferior_io_terminal ();
153 if (inferior_io_terminal == NULL)
154 inferior_io_terminal = "";
155 fprintf_filtered (gdb_stdout,
156 _("Terminal for future runs of program being debugged "
157 "is \"%s\".\n"), inferior_io_terminal);
161 get_inferior_args (void)
163 if (current_inferior ()->argc != 0)
167 n = construct_inferior_arguments (current_inferior ()->argc,
168 current_inferior ()->argv);
169 set_inferior_args (n);
173 if (current_inferior ()->args == NULL)
174 current_inferior ()->args = xstrdup ("");
176 return current_inferior ()->args;
179 /* Set the arguments for the current inferior. Ownership of
180 NEWARGS is not transferred. */
183 set_inferior_args (const char *newargs)
185 xfree (current_inferior ()->args);
186 current_inferior ()->args = newargs ? xstrdup (newargs) : NULL;
187 current_inferior ()->argc = 0;
188 current_inferior ()->argv = 0;
192 set_inferior_args_vector (int argc, char **argv)
194 current_inferior ()->argc = argc;
195 current_inferior ()->argv = argv;
198 /* Notice when `set args' is run. */
201 set_args_command (const char *args, int from_tty, struct cmd_list_element *c)
203 /* CLI has assigned the user-provided value to inferior_args_scratch.
204 Now route it to current inferior. */
205 set_inferior_args (inferior_args_scratch);
208 /* Notice when `show args' is run. */
211 show_args_command (struct ui_file *file, int from_tty,
212 struct cmd_list_element *c, const char *value)
214 /* Note that we ignore the passed-in value in favor of computing it
216 deprecated_show_value_hack (file, from_tty, c, get_inferior_args ());
219 /* See common/common-inferior.h. */
222 set_inferior_cwd (const char *cwd)
224 struct inferior *inf = current_inferior ();
226 gdb_assert (inf != NULL);
231 inf->cwd.reset (xstrdup (cwd));
234 /* See common/common-inferior.h. */
239 return current_inferior ()->cwd.get ();
242 /* Handle the 'set cwd' command. */
245 set_cwd_command (const char *args, int from_tty, struct cmd_list_element *c)
247 if (*inferior_cwd_scratch == '\0')
248 set_inferior_cwd (NULL);
250 set_inferior_cwd (inferior_cwd_scratch);
253 /* Handle the 'show cwd' command. */
256 show_cwd_command (struct ui_file *file, int from_tty,
257 struct cmd_list_element *c, const char *value)
259 const char *cwd = get_inferior_cwd ();
262 fprintf_filtered (gdb_stdout,
264 You have not set the inferior's current working directory.\n\
265 The inferior will inherit GDB's cwd if native debugging, or the remote\n\
266 server's cwd if remote debugging.\n"));
268 fprintf_filtered (gdb_stdout,
269 _("Current working directory that will be used "
270 "when starting the inferior is \"%s\".\n"), cwd);
274 /* Compute command-line string given argument vector. This does the
275 same shell processing as fork_inferior. */
278 construct_inferior_arguments (int argc, char **argv)
282 if (startup_with_shell)
285 /* This holds all the characters considered special to the
287 static const char special[] = "\"!&*|[]{}<>?`~^=;, \t\n";
288 static const char quote = '"';
290 /* This holds all the characters considered special to the
291 typical Unix shells. We include `^' because the SunOS
292 /bin/sh treats it as a synonym for `|'. */
293 static const char special[] = "\"!#$&*()\\|[]{}<>?'`~^; \t\n";
294 static const char quote = '\'';
300 /* We over-compute the size. It shouldn't matter. */
301 for (i = 0; i < argc; ++i)
302 length += 3 * strlen (argv[i]) + 1 + 2 * (argv[i][0] == '\0');
304 result = (char *) xmalloc (length);
307 for (i = 0; i < argc; ++i)
312 /* Need to handle empty arguments specially. */
313 if (argv[i][0] == '\0')
323 if (strpbrk (argv[i], special))
329 for (cp = argv[i]; *cp; ++cp)
333 /* A newline cannot be quoted with a backslash (it
334 just disappears), only by putting it inside
345 if (strchr (special, *cp) != NULL)
361 /* In this case we can't handle arguments that contain spaces,
362 tabs, or newlines -- see breakup_args(). */
366 for (i = 0; i < argc; ++i)
368 char *cp = strchr (argv[i], ' ');
370 cp = strchr (argv[i], '\t');
372 cp = strchr (argv[i], '\n');
374 error (_("can't handle command-line "
375 "argument containing whitespace"));
376 length += strlen (argv[i]) + 1;
379 result = (char *) xmalloc (length);
381 for (i = 0; i < argc; ++i)
384 strcat (result, " ");
385 strcat (result, argv[i]);
393 /* This function strips the '&' character (indicating background
394 execution) that is added as *the last* of the arguments ARGS of a
395 command. A copy of the incoming ARGS without the '&' is returned,
396 unless the resulting string after stripping is empty, in which case
397 NULL is returned. *BG_CHAR_P is an output boolean that indicates
398 whether the '&' character was found. */
400 static gdb::unique_xmalloc_ptr<char>
401 strip_bg_char (const char *args, int *bg_char_p)
405 if (args == NULL || *args == '\0')
411 p = args + strlen (args);
415 while (p > args && isspace (p[-1]))
420 return gdb::unique_xmalloc_ptr<char>
421 (savestring (args, p - args));
423 return gdb::unique_xmalloc_ptr<char> (nullptr);
427 return gdb::unique_xmalloc_ptr<char> (xstrdup (args));
430 /* Common actions to take after creating any sort of inferior, by any
431 means (running, attaching, connecting, et cetera). The target
432 should be stopped. */
435 post_create_inferior (struct target_ops *target, int from_tty)
438 /* Be sure we own the terminal in case write operations are performed. */
439 target_terminal::ours_for_output ();
441 /* If the target hasn't taken care of this already, do it now.
442 Targets which need to access registers during to_open,
443 to_create_inferior, or to_attach should do it earlier; but many
445 target_find_description ();
447 /* Now that we know the register layout, retrieve current PC. But
448 if the PC is unavailable (e.g., we're opening a core file with
449 missing registers info), ignore it. */
453 stop_pc = regcache_read_pc (get_current_regcache ());
455 CATCH (ex, RETURN_MASK_ERROR)
457 if (ex.error != NOT_AVAILABLE_ERROR)
458 throw_exception (ex);
464 const unsigned solib_add_generation
465 = current_program_space->solib_add_generation;
467 /* Create the hooks to handle shared library load and unload
469 solib_create_inferior_hook (from_tty);
471 if (current_program_space->solib_add_generation == solib_add_generation)
473 /* The platform-specific hook should load initial shared libraries,
474 but didn't. FROM_TTY will be incorrectly 0 but such solib
475 targets should be fixed anyway. Call it only after the solib
476 target has been initialized by solib_create_inferior_hook. */
479 warning (_("platform-specific solib_create_inferior_hook did "
480 "not load initial shared libraries."));
482 /* If the solist is global across processes, there's no need to
484 if (!gdbarch_has_global_solist (target_gdbarch ()))
485 solib_add (NULL, 0, auto_solib_add);
489 /* If the user sets watchpoints before execution having started,
490 then she gets software watchpoints, because GDB can't know which
491 target will end up being pushed, or if it supports hardware
492 watchpoints or not. breakpoint_re_set takes care of promoting
493 watchpoints to hardware watchpoints if possible, however, if this
494 new inferior doesn't load shared libraries or we don't pull in
495 symbols from any other source on this target/arch,
496 breakpoint_re_set is never called. Call it now so that software
497 watchpoints get a chance to be promoted to hardware watchpoints
498 if the now pushed target supports hardware watchpoints. */
499 breakpoint_re_set ();
501 observer_notify_inferior_created (target, from_tty);
504 /* Kill the inferior if already running. This function is designed
505 to be called when we are about to start the execution of the program
506 from the beginning. Ask the user to confirm that he wants to restart
507 the program being debugged when FROM_TTY is non-null. */
510 kill_if_already_running (int from_tty)
512 if (! ptid_equal (inferior_ptid, null_ptid) && target_has_execution)
514 /* Bail out before killing the program if we will not be able to
516 target_require_runnable ();
519 && !query (_("The program being debugged has been started already.\n\
520 Start it from the beginning? ")))
521 error (_("Program not restarted."));
526 /* See inferior.h. */
529 prepare_execution_command (struct target_ops *target, int background)
531 /* If we get a request for running in the bg but the target
532 doesn't support it, error out. */
533 if (background && !target->to_can_async_p (target))
534 error (_("Asynchronous execution not supported on this target."));
538 /* If we get a request for running in the fg, then we need to
539 simulate synchronous (fg) execution. Note no cleanup is
540 necessary for this. stdin is re-enabled whenever an error
541 reaches the top level. */
542 all_uis_on_sync_execution_starting ();
546 /* Determine how the new inferior will behave. */
550 /* Run program without any explicit stop during startup. */
553 /* Stop at the beginning of the program's main function. */
556 /* Stop at the first instruction of the program. */
557 RUN_STOP_AT_FIRST_INSN
560 /* Implement the "run" command. Force a stop during program start if
561 requested by RUN_HOW. */
564 run_command_1 (const char *args, int from_tty, enum run_how run_how)
566 const char *exec_file;
567 struct cleanup *old_chain;
569 struct ui_out *uiout = current_uiout;
570 struct target_ops *run_target;
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);
2286 /* Print out the register NAME with value VAL, to FILE, in the default
2290 default_print_one_register_info (struct ui_file *file,
2294 struct type *regtype = value_type (val);
2295 int print_raw_format;
2297 fputs_filtered (name, file);
2298 print_spaces_filtered (15 - strlen (name), file);
2300 print_raw_format = (value_entirely_available (val)
2301 && !value_optimized_out (val));
2303 /* If virtual format is floating, print it that way, and in raw
2305 if (TYPE_CODE (regtype) == TYPE_CODE_FLT
2306 || TYPE_CODE (regtype) == TYPE_CODE_DECFLOAT)
2308 struct value_print_options opts;
2309 const gdb_byte *valaddr = value_contents_for_printing (val);
2310 enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (regtype));
2312 get_user_print_options (&opts);
2316 value_embedded_offset (val), 0,
2317 file, 0, val, &opts, current_language);
2319 if (print_raw_format)
2321 fprintf_filtered (file, "\t(raw ");
2322 print_hex_chars (file, valaddr, TYPE_LENGTH (regtype), byte_order,
2324 fprintf_filtered (file, ")");
2329 struct value_print_options opts;
2331 /* Print the register in hex. */
2332 get_formatted_print_options (&opts, 'x');
2335 value_embedded_offset (val), 0,
2336 file, 0, val, &opts, current_language);
2337 /* If not a vector register, print it also according to its
2339 if (print_raw_format && TYPE_VECTOR (regtype) == 0)
2341 get_user_print_options (&opts);
2343 fprintf_filtered (file, "\t");
2345 value_embedded_offset (val), 0,
2346 file, 0, val, &opts, current_language);
2350 fprintf_filtered (file, "\n");
2353 /* Print out the machine register regnum. If regnum is -1, print all
2354 registers (print_all == 1) or all non-float and non-vector
2355 registers (print_all == 0).
2357 For most machines, having all_registers_info() print the
2358 register(s) one per line is good enough. If a different format is
2359 required, (eg, for MIPS or Pyramid 90x, which both have lots of
2360 regs), or there is an existing convention for showing all the
2361 registers, define the architecture method PRINT_REGISTERS_INFO to
2362 provide that format. */
2365 default_print_registers_info (struct gdbarch *gdbarch,
2366 struct ui_file *file,
2367 struct frame_info *frame,
2368 int regnum, int print_all)
2371 const int numregs = gdbarch_num_regs (gdbarch)
2372 + gdbarch_num_pseudo_regs (gdbarch);
2374 for (i = 0; i < numregs; i++)
2376 /* Decide between printing all regs, non-float / vector regs, or
2382 if (!gdbarch_register_reggroup_p (gdbarch, i, all_reggroup))
2387 if (!gdbarch_register_reggroup_p (gdbarch, i, general_reggroup))
2397 /* If the register name is empty, it is undefined for this
2398 processor, so don't display anything. */
2399 if (gdbarch_register_name (gdbarch, i) == NULL
2400 || *(gdbarch_register_name (gdbarch, i)) == '\0')
2403 default_print_one_register_info (file,
2404 gdbarch_register_name (gdbarch, i),
2405 value_of_register (i, frame));
2410 registers_info (const char *addr_exp, int fpregs)
2412 struct frame_info *frame;
2413 struct gdbarch *gdbarch;
2415 if (!target_has_registers)
2416 error (_("The program has no registers now."));
2417 frame = get_selected_frame (NULL);
2418 gdbarch = get_frame_arch (frame);
2422 gdbarch_print_registers_info (gdbarch, gdb_stdout,
2427 while (*addr_exp != '\0')
2432 /* Skip leading white space. */
2433 addr_exp = skip_spaces (addr_exp);
2435 /* Discard any leading ``$''. Check that there is something
2436 resembling a register following it. */
2437 if (addr_exp[0] == '$')
2439 if (isspace ((*addr_exp)) || (*addr_exp) == '\0')
2440 error (_("Missing register name"));
2442 /* Find the start/end of this register name/num/group. */
2444 while ((*addr_exp) != '\0' && !isspace ((*addr_exp)))
2448 /* Figure out what we've found and display it. */
2450 /* A register name? */
2452 int regnum = user_reg_map_name_to_regnum (gdbarch, start, end - start);
2456 /* User registers lie completely outside of the range of
2457 normal registers. Catch them early so that the target
2459 if (regnum >= gdbarch_num_regs (gdbarch)
2460 + gdbarch_num_pseudo_regs (gdbarch))
2462 struct value *regval = value_of_user_reg (regnum, frame);
2463 const char *regname = user_reg_map_regnum_to_name (gdbarch,
2466 /* Print in the same fashion
2467 gdbarch_print_registers_info's default
2468 implementation prints. */
2469 default_print_one_register_info (gdb_stdout,
2474 gdbarch_print_registers_info (gdbarch, gdb_stdout,
2475 frame, regnum, fpregs);
2480 /* A register group? */
2482 struct reggroup *group;
2484 for (group = reggroup_next (gdbarch, NULL);
2486 group = reggroup_next (gdbarch, group))
2488 /* Don't bother with a length check. Should the user
2489 enter a short register group name, go with the first
2490 group that matches. */
2491 if (strncmp (start, reggroup_name (group), end - start) == 0)
2499 regnum < gdbarch_num_regs (gdbarch)
2500 + gdbarch_num_pseudo_regs (gdbarch);
2503 if (gdbarch_register_reggroup_p (gdbarch, regnum, group))
2504 gdbarch_print_registers_info (gdbarch,
2512 /* Nothing matched. */
2513 error (_("Invalid register `%.*s'"), (int) (end - start), start);
2518 info_all_registers_command (const char *addr_exp, int from_tty)
2520 registers_info (addr_exp, 1);
2524 info_registers_command (const char *addr_exp, int from_tty)
2526 registers_info (addr_exp, 0);
2530 print_vector_info (struct ui_file *file,
2531 struct frame_info *frame, const char *args)
2533 struct gdbarch *gdbarch = get_frame_arch (frame);
2535 if (gdbarch_print_vector_info_p (gdbarch))
2536 gdbarch_print_vector_info (gdbarch, file, frame, args);
2540 int printed_something = 0;
2543 regnum < gdbarch_num_regs (gdbarch)
2544 + gdbarch_num_pseudo_regs (gdbarch);
2547 if (gdbarch_register_reggroup_p (gdbarch, regnum, vector_reggroup))
2549 printed_something = 1;
2550 gdbarch_print_registers_info (gdbarch, file, frame, regnum, 1);
2553 if (!printed_something)
2554 fprintf_filtered (file, "No vector information\n");
2559 info_vector_command (const char *args, int from_tty)
2561 if (!target_has_registers)
2562 error (_("The program has no registers now."));
2564 print_vector_info (gdb_stdout, get_selected_frame (NULL), args);
2567 /* Kill the inferior process. Make us have no inferior. */
2570 kill_command (const char *arg, int from_tty)
2572 /* FIXME: This should not really be inferior_ptid (or target_has_execution).
2573 It should be a distinct flag that indicates that a target is active, cuz
2574 some targets don't have processes! */
2576 if (ptid_equal (inferior_ptid, null_ptid))
2577 error (_("The program is not being run."));
2578 if (!query (_("Kill the program being debugged? ")))
2579 error (_("Not confirmed."));
2582 /* If we still have other inferiors to debug, then don't mess with
2583 with their threads. */
2584 if (!have_inferiors ())
2586 init_thread_list (); /* Destroy thread info. */
2588 /* Killing off the inferior can leave us with a core file. If
2589 so, print the state we are left in. */
2590 if (target_has_stack)
2592 printf_filtered (_("In %s,\n"), target_longname);
2593 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1);
2596 bfd_cache_close_all ();
2599 /* Used in `attach&' command. ARG is a point to an integer
2600 representing a process id. Proceed threads of this process iff
2601 they stopped due to debugger request, and when they did, they
2602 reported a clean stop (GDB_SIGNAL_0). Do not proceed threads
2603 that have been explicitly been told to stop. */
2606 proceed_after_attach_callback (struct thread_info *thread,
2609 int pid = * (int *) arg;
2611 if (ptid_get_pid (thread->ptid) == pid
2612 && !is_exited (thread->ptid)
2613 && !is_executing (thread->ptid)
2614 && !thread->stop_requested
2615 && thread->suspend.stop_signal == GDB_SIGNAL_0)
2617 switch_to_thread (thread->ptid);
2618 clear_proceed_status (0);
2619 proceed ((CORE_ADDR) -1, GDB_SIGNAL_DEFAULT);
2626 proceed_after_attach (int pid)
2628 /* Don't error out if the current thread is running, because
2629 there may be other stopped threads. */
2631 /* Backup current thread and selected frame. */
2632 scoped_restore_current_thread restore_thread;
2634 iterate_over_threads (proceed_after_attach_callback, &pid);
2637 /* See inferior.h. */
2640 setup_inferior (int from_tty)
2642 struct inferior *inferior;
2644 inferior = current_inferior ();
2645 inferior->needs_setup = 0;
2647 /* If no exec file is yet known, try to determine it from the
2649 if (get_exec_file (0) == NULL)
2650 exec_file_locate_attach (ptid_get_pid (inferior_ptid), 1, from_tty);
2653 reopen_exec_file ();
2657 /* Take any necessary post-attaching actions for this platform. */
2658 target_post_attach (ptid_get_pid (inferior_ptid));
2660 post_create_inferior (¤t_target, from_tty);
2663 /* What to do after the first program stops after attaching. */
2664 enum attach_post_wait_mode
2666 /* Do nothing. Leaves threads as they are. */
2667 ATTACH_POST_WAIT_NOTHING,
2669 /* Re-resume threads that are marked running. */
2670 ATTACH_POST_WAIT_RESUME,
2672 /* Stop all threads. */
2673 ATTACH_POST_WAIT_STOP,
2676 /* Called after we've attached to a process and we've seen it stop for
2677 the first time. If ASYNC_EXEC is true, re-resume threads that
2678 should be running. Else if ATTACH, */
2681 attach_post_wait (const char *args, int from_tty, enum attach_post_wait_mode mode)
2683 struct inferior *inferior;
2685 inferior = current_inferior ();
2686 inferior->control.stop_soon = NO_STOP_QUIETLY;
2688 if (inferior->needs_setup)
2689 setup_inferior (from_tty);
2691 if (mode == ATTACH_POST_WAIT_RESUME)
2693 /* The user requested an `attach&', so be sure to leave threads
2694 that didn't get a signal running. */
2696 /* Immediatelly resume all suspended threads of this inferior,
2697 and this inferior only. This should have no effect on
2698 already running threads. If a thread has been stopped with a
2699 signal, leave it be. */
2701 proceed_after_attach (inferior->pid);
2704 if (inferior_thread ()->suspend.stop_signal == GDB_SIGNAL_0)
2706 clear_proceed_status (0);
2707 proceed ((CORE_ADDR) -1, GDB_SIGNAL_DEFAULT);
2711 else if (mode == ATTACH_POST_WAIT_STOP)
2713 /* The user requested a plain `attach', so be sure to leave
2714 the inferior stopped. */
2716 /* At least the current thread is already stopped. */
2718 /* In all-stop, by definition, all threads have to be already
2719 stopped at this point. In non-stop, however, although the
2720 selected thread is stopped, others may still be executing.
2721 Be sure to explicitly stop all threads of the process. This
2722 should have no effect on already stopped threads. */
2724 target_stop (pid_to_ptid (inferior->pid));
2725 else if (target_is_non_stop_p ())
2727 struct thread_info *thread;
2728 struct thread_info *lowest = inferior_thread ();
2729 int pid = current_inferior ()->pid;
2731 stop_all_threads ();
2733 /* It's not defined which thread will report the attach
2734 stop. For consistency, always select the thread with
2735 lowest GDB number, which should be the main thread, if it
2737 ALL_NON_EXITED_THREADS (thread)
2739 if (ptid_get_pid (thread->ptid) == pid)
2741 if (thread->inf->num < lowest->inf->num
2742 || thread->per_inf_num < lowest->per_inf_num)
2747 switch_to_thread (lowest->ptid);
2750 /* Tell the user/frontend where we're stopped. */
2752 if (deprecated_attach_hook)
2753 deprecated_attach_hook ();
2757 struct attach_command_continuation_args
2761 enum attach_post_wait_mode mode;
2765 attach_command_continuation (void *args, int err)
2767 struct attach_command_continuation_args *a
2768 = (struct attach_command_continuation_args *) args;
2773 attach_post_wait (a->args, a->from_tty, a->mode);
2777 attach_command_continuation_free_args (void *args)
2779 struct attach_command_continuation_args *a
2780 = (struct attach_command_continuation_args *) args;
2786 /* "attach" command entry point. Takes a program started up outside
2787 of gdb and ``attaches'' to it. This stops it cold in its tracks
2788 and allows us to start debugging it. */
2791 attach_command (const char *args, int from_tty)
2794 struct target_ops *attach_target;
2795 struct inferior *inferior = current_inferior ();
2796 enum attach_post_wait_mode mode;
2798 dont_repeat (); /* Not for the faint of heart */
2800 if (gdbarch_has_global_solist (target_gdbarch ()))
2801 /* Don't complain if all processes share the same symbol
2804 else if (target_has_execution)
2806 if (query (_("A program is being debugged already. Kill it? ")))
2809 error (_("Not killed."));
2812 /* Clean up any leftovers from other runs. Some other things from
2813 this function should probably be moved into target_pre_inferior. */
2814 target_pre_inferior (from_tty);
2816 gdb::unique_xmalloc_ptr<char> stripped = strip_bg_char (args, &async_exec);
2817 args = stripped.get ();
2819 attach_target = find_attach_target ();
2821 prepare_execution_command (attach_target, async_exec);
2823 if (non_stop && !attach_target->to_supports_non_stop (attach_target))
2824 error (_("Cannot attach to this target in non-stop mode"));
2826 attach_target->to_attach (attach_target, args, from_tty);
2827 /* to_attach should push the target, so after this point we
2828 shouldn't refer to attach_target again. */
2829 attach_target = NULL;
2831 /* Set up the "saved terminal modes" of the inferior
2832 based on what modes we are starting it with. */
2833 target_terminal::init ();
2835 /* Install inferior's terminal modes. This may look like a no-op,
2836 as we've just saved them above, however, this does more than
2837 restore terminal settings:
2839 - installs a SIGINT handler that forwards SIGINT to the inferior.
2840 Otherwise a Ctrl-C pressed just while waiting for the initial
2841 stop would end up as a spurious Quit.
2843 - removes stdin from the event loop, which we need if attaching
2844 in the foreground, otherwise on targets that report an initial
2845 stop on attach (which are most) we'd process input/commands
2846 while we're in the event loop waiting for that stop. That is,
2847 before the attach continuation runs and the command is really
2849 target_terminal::inferior ();
2851 /* Set up execution context to know that we should return from
2852 wait_for_inferior as soon as the target reports a stop. */
2853 init_wait_for_inferior ();
2854 clear_proceed_status (0);
2856 inferior->needs_setup = 1;
2858 if (target_is_non_stop_p ())
2860 /* If we find that the current thread isn't stopped, explicitly
2861 do so now, because we're going to install breakpoints and
2865 /* The user requested an `attach&'; stop just one thread. */
2866 target_stop (inferior_ptid);
2868 /* The user requested an `attach', so stop all threads of this
2870 target_stop (pid_to_ptid (ptid_get_pid (inferior_ptid)));
2873 mode = async_exec ? ATTACH_POST_WAIT_RESUME : ATTACH_POST_WAIT_STOP;
2875 /* Some system don't generate traps when attaching to inferior.
2876 E.g. Mach 3 or GNU hurd. */
2877 if (!target_attach_no_wait)
2879 struct attach_command_continuation_args *a;
2881 /* Careful here. See comments in inferior.h. Basically some
2882 OSes don't ignore SIGSTOPs on continue requests anymore. We
2883 need a way for handle_inferior_event to reset the stop_signal
2884 variable after an attach, and this is what
2885 STOP_QUIETLY_NO_SIGSTOP is for. */
2886 inferior->control.stop_soon = STOP_QUIETLY_NO_SIGSTOP;
2888 /* Wait for stop. */
2889 a = XNEW (struct attach_command_continuation_args);
2890 a->args = xstrdup (args);
2891 a->from_tty = from_tty;
2893 add_inferior_continuation (attach_command_continuation, a,
2894 attach_command_continuation_free_args);
2896 if (!target_is_async_p ())
2897 mark_infrun_async_event_handler ();
2901 attach_post_wait (args, from_tty, mode);
2904 /* We had just found out that the target was already attached to an
2905 inferior. PTID points at a thread of this new inferior, that is
2906 the most likely to be stopped right now, but not necessarily so.
2907 The new inferior is assumed to be already added to the inferior
2908 list at this point. If LEAVE_RUNNING, then leave the threads of
2909 this inferior running, except those we've explicitly seen reported
2913 notice_new_inferior (ptid_t ptid, int leave_running, int from_tty)
2915 enum attach_post_wait_mode mode
2916 = leave_running ? ATTACH_POST_WAIT_RESUME : ATTACH_POST_WAIT_NOTHING;
2918 gdb::optional<scoped_restore_current_thread> restore_thread;
2920 if (inferior_ptid != null_ptid)
2921 restore_thread.emplace ();
2923 /* Avoid reading registers -- we haven't fetched the target
2925 switch_to_thread_no_regs (find_thread_ptid (ptid));
2927 /* When we "notice" a new inferior we need to do all the things we
2928 would normally do if we had just attached to it. */
2930 if (is_executing (inferior_ptid))
2932 struct attach_command_continuation_args *a;
2933 struct inferior *inferior = current_inferior ();
2935 /* We're going to install breakpoints, and poke at memory,
2936 ensure that the inferior is stopped for a moment while we do
2938 target_stop (inferior_ptid);
2940 inferior->control.stop_soon = STOP_QUIETLY_REMOTE;
2942 /* Wait for stop before proceeding. */
2943 a = XNEW (struct attach_command_continuation_args);
2944 a->args = xstrdup ("");
2945 a->from_tty = from_tty;
2947 add_inferior_continuation (attach_command_continuation, a,
2948 attach_command_continuation_free_args);
2953 attach_post_wait ("" /* args */, from_tty, mode);
2958 * takes a program previously attached to and detaches it.
2959 * The program resumes execution and will no longer stop
2960 * on signals, etc. We better not have left any breakpoints
2961 * in the program or it'll die when it hits one. For this
2962 * to work, it may be necessary for the process to have been
2963 * previously attached. It *might* work if the program was
2964 * started via the normal ptrace (PTRACE_TRACEME).
2968 detach_command (const char *args, int from_tty)
2970 dont_repeat (); /* Not for the faint of heart. */
2972 if (ptid_equal (inferior_ptid, null_ptid))
2973 error (_("The program is not being run."));
2975 query_if_trace_running (from_tty);
2977 disconnect_tracing ();
2979 target_detach (args, from_tty);
2981 /* The current inferior process was just detached successfully. Get
2982 rid of breakpoints that no longer make sense. Note we don't do
2983 this within target_detach because that is also used when
2984 following child forks, and in that case we will want to transfer
2985 breakpoints to the child, not delete them. */
2986 breakpoint_init_inferior (inf_exited);
2988 /* If the solist is global across inferiors, don't clear it when we
2989 detach from a single inferior. */
2990 if (!gdbarch_has_global_solist (target_gdbarch ()))
2991 no_shared_libraries (NULL, from_tty);
2993 /* If we still have inferiors to debug, then don't mess with their
2995 if (!have_inferiors ())
2996 init_thread_list ();
2998 if (deprecated_detach_hook)
2999 deprecated_detach_hook ();
3002 /* Disconnect from the current target without resuming it (leaving it
3003 waiting for a debugger).
3005 We'd better not have left any breakpoints in the program or the
3006 next debugger will get confused. Currently only supported for some
3007 remote targets, since the normal attach mechanisms don't work on
3008 stopped processes on some native platforms (e.g. GNU/Linux). */
3011 disconnect_command (const char *args, int from_tty)
3013 dont_repeat (); /* Not for the faint of heart. */
3014 query_if_trace_running (from_tty);
3015 disconnect_tracing ();
3016 target_disconnect (args, from_tty);
3017 no_shared_libraries (NULL, from_tty);
3018 init_thread_list ();
3019 if (deprecated_detach_hook)
3020 deprecated_detach_hook ();
3024 interrupt_target_1 (int all_threads)
3029 ptid = minus_one_ptid;
3031 ptid = inferior_ptid;
3036 target_interrupt (ptid);
3038 /* Tag the thread as having been explicitly requested to stop, so
3039 other parts of gdb know not to resume this thread automatically,
3040 if it was stopped due to an internal event. Limit this to
3041 non-stop mode, as when debugging a multi-threaded application in
3042 all-stop mode, we will only get one stop event --- it's undefined
3043 which thread will report the event. */
3045 set_stop_requested (ptid, 1);
3049 Stop the execution of the target while running in async mode, in
3050 the background. In all-stop, stop the whole process. In non-stop
3051 mode, stop the current thread only by default, or stop all threads
3052 if the `-a' switch is used. */
3055 interrupt_command (const char *args, int from_tty)
3057 if (target_can_async_p ())
3059 int all_threads = 0;
3061 dont_repeat (); /* Not for the faint of heart. */
3064 && startswith (args, "-a"))
3067 if (!non_stop && all_threads)
3068 error (_("-a is meaningless in all-stop mode."));
3070 interrupt_target_1 (all_threads);
3074 /* See inferior.h. */
3077 default_print_float_info (struct gdbarch *gdbarch, struct ui_file *file,
3078 struct frame_info *frame, const char *args)
3081 int printed_something = 0;
3084 regnum < gdbarch_num_regs (gdbarch)
3085 + gdbarch_num_pseudo_regs (gdbarch);
3088 if (gdbarch_register_reggroup_p (gdbarch, regnum, float_reggroup))
3090 printed_something = 1;
3091 gdbarch_print_registers_info (gdbarch, file, frame, regnum, 1);
3094 if (!printed_something)
3095 fprintf_filtered (file, "No floating-point info "
3096 "available for this processor.\n");
3100 info_float_command (const char *args, int from_tty)
3102 struct frame_info *frame;
3104 if (!target_has_registers)
3105 error (_("The program has no registers now."));
3107 frame = get_selected_frame (NULL);
3108 gdbarch_print_float_info (get_frame_arch (frame), gdb_stdout, frame, args);
3112 unset_command (const char *args, int from_tty)
3114 printf_filtered (_("\"unset\" must be followed by the "
3115 "name of an unset subcommand.\n"));
3116 help_list (unsetlist, "unset ", all_commands, gdb_stdout);
3119 /* Implement `info proc' family of commands. */
3122 info_proc_cmd_1 (const char *args, enum info_proc_what what, int from_tty)
3124 struct gdbarch *gdbarch = get_current_arch ();
3126 if (!target_info_proc (args, what))
3128 if (gdbarch_info_proc_p (gdbarch))
3129 gdbarch_info_proc (gdbarch, args, what);
3131 error (_("Not supported on this target."));
3135 /* Implement `info proc' when given without any futher parameters. */
3138 info_proc_cmd (const char *args, int from_tty)
3140 info_proc_cmd_1 (args, IP_MINIMAL, from_tty);
3143 /* Implement `info proc mappings'. */
3146 info_proc_cmd_mappings (const char *args, int from_tty)
3148 info_proc_cmd_1 (args, IP_MAPPINGS, from_tty);
3151 /* Implement `info proc stat'. */
3154 info_proc_cmd_stat (const char *args, int from_tty)
3156 info_proc_cmd_1 (args, IP_STAT, from_tty);
3159 /* Implement `info proc status'. */
3162 info_proc_cmd_status (const char *args, int from_tty)
3164 info_proc_cmd_1 (args, IP_STATUS, from_tty);
3167 /* Implement `info proc cwd'. */
3170 info_proc_cmd_cwd (const char *args, int from_tty)
3172 info_proc_cmd_1 (args, IP_CWD, from_tty);
3175 /* Implement `info proc cmdline'. */
3178 info_proc_cmd_cmdline (const char *args, int from_tty)
3180 info_proc_cmd_1 (args, IP_CMDLINE, from_tty);
3183 /* Implement `info proc exe'. */
3186 info_proc_cmd_exe (const char *args, int from_tty)
3188 info_proc_cmd_1 (args, IP_EXE, from_tty);
3191 /* Implement `info proc all'. */
3194 info_proc_cmd_all (const char *args, int from_tty)
3196 info_proc_cmd_1 (args, IP_ALL, from_tty);
3199 /* This help string is used for the run, start, and starti commands.
3200 It is defined as a macro to prevent duplication. */
3202 #define RUN_ARGS_HELP \
3203 "You may specify arguments to give it.\n\
3204 Args may include \"*\", or \"[...]\"; they are expanded using the\n\
3205 shell that will start the program (specified by the \"$SHELL\" environment\n\
3206 variable). Input and output redirection with \">\", \"<\", or \">>\"\n\
3207 are also allowed.\n\
3209 With no arguments, uses arguments last specified (with \"run\" or \n\
3210 \"set args\"). To cancel previous arguments and run with no arguments,\n\
3211 use \"set args\" without arguments.\n\
3213 To start the inferior without using a shell, use \"set startup-with-shell off\"."
3216 _initialize_infcmd (void)
3218 static struct cmd_list_element *info_proc_cmdlist;
3219 struct cmd_list_element *c = NULL;
3220 const char *cmd_name;
3222 /* Add the filename of the terminal connected to inferior I/O. */
3223 add_setshow_optional_filename_cmd ("inferior-tty", class_run,
3224 &inferior_io_terminal_scratch, _("\
3225 Set terminal for future runs of program being debugged."), _("\
3226 Show terminal for future runs of program being debugged."), _("\
3227 Usage: set inferior-tty [TTY]\n\n\
3228 If TTY is omitted, the default behavior of using the same terminal as GDB\n\
3230 set_inferior_tty_command,
3231 show_inferior_tty_command,
3232 &setlist, &showlist);
3233 cmd_name = "inferior-tty";
3234 c = lookup_cmd (&cmd_name, setlist, "", -1, 1);
3235 gdb_assert (c != NULL);
3236 add_alias_cmd ("tty", c, class_alias, 0, &cmdlist);
3239 add_setshow_string_noescape_cmd (cmd_name, class_run,
3240 &inferior_args_scratch, _("\
3241 Set argument list to give program being debugged when it is started."), _("\
3242 Show argument list to give program being debugged when it is started."), _("\
3243 Follow this command with any number of args, to be passed to the program."),
3246 &setlist, &showlist);
3247 c = lookup_cmd (&cmd_name, setlist, "", -1, 1);
3248 gdb_assert (c != NULL);
3249 set_cmd_completer (c, filename_completer);
3252 add_setshow_string_noescape_cmd (cmd_name, class_run,
3253 &inferior_cwd_scratch, _("\
3254 Set the current working directory to be used when the inferior is started.\n\
3255 Changing this setting does not have any effect on inferiors that are\n\
3258 Show the current working directory that is used when the inferior is started."),
3260 Use this command to change the current working directory that will be used\n\
3261 when the inferior is started. This setting does not affect GDB's current\n\
3262 working directory."),
3265 &setlist, &showlist);
3266 c = lookup_cmd (&cmd_name, setlist, "", -1, 1);
3267 gdb_assert (c != NULL);
3268 set_cmd_completer (c, filename_completer);
3270 c = add_cmd ("environment", no_class, environment_info, _("\
3271 The environment to give the program, or one variable's value.\n\
3272 With an argument VAR, prints the value of environment variable VAR to\n\
3273 give the program being debugged. With no arguments, prints the entire\n\
3274 environment to be given to the program."), &showlist);
3275 set_cmd_completer (c, noop_completer);
3277 add_prefix_cmd ("unset", no_class, unset_command,
3278 _("Complement to certain \"set\" commands."),
3279 &unsetlist, "unset ", 0, &cmdlist);
3281 c = add_cmd ("environment", class_run, unset_environment_command, _("\
3282 Cancel environment variable VAR for the program.\n\
3283 This does not affect the program until the next \"run\" command."),
3285 set_cmd_completer (c, noop_completer);
3287 c = add_cmd ("environment", class_run, set_environment_command, _("\
3288 Set environment variable value to give the program.\n\
3289 Arguments are VAR VALUE where VAR is variable name and VALUE is value.\n\
3290 VALUES of environment variables are uninterpreted strings.\n\
3291 This does not affect the program until the next \"run\" command."),
3293 set_cmd_completer (c, noop_completer);
3295 c = add_com ("path", class_files, path_command, _("\
3296 Add directory DIR(s) to beginning of search path for object files.\n\
3297 $cwd in the path means the current working directory.\n\
3298 This path is equivalent to the $PATH shell variable. It is a list of\n\
3299 directories, separated by colons. These directories are searched to find\n\
3300 fully linked executable files and separately compiled object files as \
3302 set_cmd_completer (c, filename_completer);
3304 c = add_cmd ("paths", no_class, path_info, _("\
3305 Current search path for finding object files.\n\
3306 $cwd in the path means the current working directory.\n\
3307 This path is equivalent to the $PATH shell variable. It is a list of\n\
3308 directories, separated by colons. These directories are searched to find\n\
3309 fully linked executable files and separately compiled object files as \
3312 set_cmd_completer (c, noop_completer);
3314 add_prefix_cmd ("kill", class_run, kill_command,
3315 _("Kill execution of program being debugged."),
3316 &killlist, "kill ", 0, &cmdlist);
3318 add_com ("attach", class_run, attach_command, _("\
3319 Attach to a process or file outside of GDB.\n\
3320 This command attaches to another target, of the same type as your last\n\
3321 \"target\" command (\"info files\" will show your target stack).\n\
3322 The command may take as argument a process id or a device file.\n\
3323 For a process id, you must have permission to send the process a signal,\n\
3324 and it must have the same effective uid as the debugger.\n\
3325 When using \"attach\" with a process id, the debugger finds the\n\
3326 program running in the process, looking first in the current working\n\
3327 directory, or (if not found there) using the source file search path\n\
3328 (see the \"directory\" command). You can also use the \"file\" command\n\
3329 to specify the program, and to load its symbol table."));
3331 add_prefix_cmd ("detach", class_run, detach_command, _("\
3332 Detach a process or file previously attached.\n\
3333 If a process, it is no longer traced, and it continues its execution. If\n\
3334 you were debugging a file, the file is closed and gdb no longer accesses it."),
3335 &detachlist, "detach ", 0, &cmdlist);
3337 add_com ("disconnect", class_run, disconnect_command, _("\
3338 Disconnect from a target.\n\
3339 The target will wait for another debugger to connect. Not available for\n\
3342 c = add_com ("signal", class_run, signal_command, _("\
3343 Continue program with the specified signal.\n\
3344 Usage: signal SIGNAL\n\
3345 The SIGNAL argument is processed the same as the handle command.\n\
3347 An argument of \"0\" means continue the program without sending it a signal.\n\
3348 This is useful in cases where the program stopped because of a signal,\n\
3349 and you want to resume the program while discarding the signal.\n\
3351 In a multi-threaded program the signal is delivered to, or discarded from,\n\
3352 the current thread only."));
3353 set_cmd_completer (c, signal_completer);
3355 c = add_com ("queue-signal", class_run, queue_signal_command, _("\
3356 Queue a signal to be delivered to the current thread when it is resumed.\n\
3357 Usage: queue-signal SIGNAL\n\
3358 The SIGNAL argument is processed the same as the handle command.\n\
3359 It is an error if the handling state of SIGNAL is \"nopass\".\n\
3361 An argument of \"0\" means remove any currently queued signal from\n\
3362 the current thread. This is useful in cases where the program stopped\n\
3363 because of a signal, and you want to resume it while discarding the signal.\n\
3365 In a multi-threaded program the signal is queued with, or discarded from,\n\
3366 the current thread only."));
3367 set_cmd_completer (c, signal_completer);
3369 add_com ("stepi", class_run, stepi_command, _("\
3370 Step one instruction exactly.\n\
3372 Argument N means step N times (or till program stops for another \
3374 add_com_alias ("si", "stepi", class_alias, 0);
3376 add_com ("nexti", class_run, nexti_command, _("\
3377 Step one instruction, but proceed through subroutine calls.\n\
3379 Argument N means step N times (or till program stops for another \
3381 add_com_alias ("ni", "nexti", class_alias, 0);
3383 add_com ("finish", class_run, finish_command, _("\
3384 Execute until selected stack frame returns.\n\
3386 Upon return, the value returned is printed and put in the value history."));
3387 add_com_alias ("fin", "finish", class_run, 1);
3389 add_com ("next", class_run, next_command, _("\
3390 Step program, proceeding through subroutine calls.\n\
3392 Unlike \"step\", if the current source line calls a subroutine,\n\
3393 this command does not enter the subroutine, but instead steps over\n\
3394 the call, in effect treating it as a single source line."));
3395 add_com_alias ("n", "next", class_run, 1);
3397 add_com ("step", class_run, step_command, _("\
3398 Step program until it reaches a different source line.\n\
3400 Argument N means step N times (or till program stops for another \
3402 add_com_alias ("s", "step", class_run, 1);
3404 c = add_com ("until", class_run, until_command, _("\
3405 Execute until the program reaches a source line greater than the current\n\
3406 or a specified location (same args as break command) within the current \
3408 set_cmd_completer (c, location_completer);
3409 add_com_alias ("u", "until", class_run, 1);
3411 c = add_com ("advance", class_run, advance_command, _("\
3412 Continue the program up to the given location (same form as args for break \
3414 Execution will also stop upon exit from the current stack frame."));
3415 set_cmd_completer (c, location_completer);
3417 c = add_com ("jump", class_run, jump_command, _("\
3418 Continue program being debugged at specified line or address.\n\
3419 Usage: jump <location>\n\
3420 Give as argument either LINENUM or *ADDR, where ADDR is an expression\n\
3421 for an address to start at."));
3422 set_cmd_completer (c, location_completer);
3423 add_com_alias ("j", "jump", class_run, 1);
3425 add_com ("continue", class_run, continue_command, _("\
3426 Continue program being debugged, after signal or breakpoint.\n\
3427 Usage: continue [N]\n\
3428 If proceeding from breakpoint, a number N may be used as an argument,\n\
3429 which means to set the ignore count of that breakpoint to N - 1 (so that\n\
3430 the breakpoint won't break until the Nth time it is reached).\n\
3432 If non-stop mode is enabled, continue only the current thread,\n\
3433 otherwise all the threads in the program are continued. To \n\
3434 continue all stopped threads in non-stop mode, use the -a option.\n\
3435 Specifying -a and an ignore count simultaneously is an error."));
3436 add_com_alias ("c", "cont", class_run, 1);
3437 add_com_alias ("fg", "cont", class_run, 1);
3439 c = add_com ("run", class_run, run_command, _("\
3440 Start debugged program.\n"
3442 set_cmd_completer (c, filename_completer);
3443 add_com_alias ("r", "run", class_run, 1);
3445 c = add_com ("start", class_run, start_command, _("\
3446 Start the debugged program stopping at the beginning of the main procedure.\n"
3448 set_cmd_completer (c, filename_completer);
3450 c = add_com ("starti", class_run, starti_command, _("\
3451 Start the debugged program stopping at the first instruction.\n"
3453 set_cmd_completer (c, filename_completer);
3455 add_com ("interrupt", class_run, interrupt_command,
3456 _("Interrupt the execution of the debugged program.\n\
3457 If non-stop mode is enabled, interrupt only the current thread,\n\
3458 otherwise all the threads in the program are stopped. To \n\
3459 interrupt all running threads in non-stop mode, use the -a option."));
3461 c = add_info ("registers", info_registers_command, _("\
3462 List of integer registers and their contents, for selected stack frame.\n\
3463 Register name as argument means describe only that register."));
3464 add_info_alias ("r", "registers", 1);
3465 set_cmd_completer (c, reg_or_group_completer);
3467 c = add_info ("all-registers", info_all_registers_command, _("\
3468 List of all registers and their contents, for selected stack frame.\n\
3469 Register name as argument means describe only that register."));
3470 set_cmd_completer (c, reg_or_group_completer);
3472 add_info ("program", info_program_command,
3473 _("Execution status of the program."));
3475 add_info ("float", info_float_command,
3476 _("Print the status of the floating point unit\n"));
3478 add_info ("vector", info_vector_command,
3479 _("Print the status of the vector unit\n"));
3481 add_prefix_cmd ("proc", class_info, info_proc_cmd,
3483 Show /proc process information about any running process.\n\
3484 Specify any process id, or use the program being debugged by default."),
3485 &info_proc_cmdlist, "info proc ",
3486 1/*allow-unknown*/, &infolist);
3488 add_cmd ("mappings", class_info, info_proc_cmd_mappings, _("\
3489 List of mapped memory regions."),
3490 &info_proc_cmdlist);
3492 add_cmd ("stat", class_info, info_proc_cmd_stat, _("\
3493 List process info from /proc/PID/stat."),
3494 &info_proc_cmdlist);
3496 add_cmd ("status", class_info, info_proc_cmd_status, _("\
3497 List process info from /proc/PID/status."),
3498 &info_proc_cmdlist);
3500 add_cmd ("cwd", class_info, info_proc_cmd_cwd, _("\
3501 List current working directory of the process."),
3502 &info_proc_cmdlist);
3504 add_cmd ("cmdline", class_info, info_proc_cmd_cmdline, _("\
3505 List command line arguments of the process."),
3506 &info_proc_cmdlist);
3508 add_cmd ("exe", class_info, info_proc_cmd_exe, _("\
3509 List absolute filename for executable of the process."),
3510 &info_proc_cmdlist);
3512 add_cmd ("all", class_info, info_proc_cmd_all, _("\
3513 List all available /proc info."),
3514 &info_proc_cmdlist);