1 /* Memory-access and commands for "inferior" process, for GDB.
3 Copyright (C) 1986-2014 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"
37 #include "completer.h"
39 #include "event-top.h"
40 #include "parser-defs.h"
42 #include "reggroups.h"
46 #include "gdb_assert.h"
48 #include "target-descriptions.h"
49 #include "user-regs.h"
50 #include "exceptions.h"
51 #include "cli/cli-decode.h"
52 #include "gdbthread.h"
54 #include "inline-frame.h"
55 #include "tracepoint.h"
57 #include "continuations.h"
59 #include "cli/cli-utils.h"
61 /* Local functions: */
63 static void nofp_registers_info (char *, int);
65 static void print_return_value (struct value *function,
66 struct type *value_type);
68 static void until_next_command (int);
70 static void until_command (char *, int);
72 static void path_info (char *, int);
74 static void path_command (char *, int);
76 static void unset_command (char *, int);
78 static void float_info (char *, int);
80 static void disconnect_command (char *, int);
82 static void unset_environment_command (char *, int);
84 static void set_environment_command (char *, int);
86 static void environment_info (char *, int);
88 static void program_info (char *, int);
90 static void finish_command (char *, int);
92 static void signal_command (char *, int);
94 static void jump_command (char *, int);
96 static void step_1 (int, int, char *);
97 static void step_once (int skip_subroutines, int single_inst,
98 int count, int thread);
100 static void next_command (char *, int);
102 static void step_command (char *, int);
104 static void run_command (char *, int);
106 static void run_no_args_command (char *args, int from_tty);
108 static void go_command (char *line_no, int from_tty);
110 void _initialize_infcmd (void);
112 #define ERROR_NO_INFERIOR \
113 if (!target_has_execution) error (_("The program is not being run."));
115 /* Scratch area where string containing arguments to give to the
116 program will be stored by 'set args'. As soon as anything is
117 stored, notice_args_set will move it into per-inferior storage.
118 Arguments are separated by spaces. Empty string (pointer to '\0')
121 static char *inferior_args_scratch;
123 /* Scratch area where 'set inferior-tty' will store user-provided value.
124 We'll immediate copy it into per-inferior storage. */
126 static char *inferior_io_terminal_scratch;
128 /* Pid of our debugged inferior, or 0 if no inferior now.
129 Since various parts of infrun.c test this to see whether there is a program
130 being debugged it should be nonzero (currently 3 is used) for remote
133 ptid_t inferior_ptid;
135 /* Address at which inferior stopped. */
139 /* Nonzero if stopped due to completion of a stack dummy routine. */
141 enum stop_stack_kind stop_stack_dummy;
143 /* Nonzero if stopped due to a random (unexpected) signal in inferior
146 int stopped_by_random_signal;
148 /* See inferior.h. */
150 int startup_with_shell = 1;
153 /* Accessor routines. */
155 /* Set the io terminal for the current inferior. Ownership of
156 TERMINAL_NAME is not transferred. */
159 set_inferior_io_terminal (const char *terminal_name)
161 xfree (current_inferior ()->terminal);
162 current_inferior ()->terminal = terminal_name ? xstrdup (terminal_name) : 0;
166 get_inferior_io_terminal (void)
168 return current_inferior ()->terminal;
172 set_inferior_tty_command (char *args, int from_tty,
173 struct cmd_list_element *c)
175 /* CLI has assigned the user-provided value to inferior_io_terminal_scratch.
176 Now route it to current inferior. */
177 set_inferior_io_terminal (inferior_io_terminal_scratch);
181 show_inferior_tty_command (struct ui_file *file, int from_tty,
182 struct cmd_list_element *c, const char *value)
184 /* Note that we ignore the passed-in value in favor of computing it
186 const char *inferior_io_terminal = get_inferior_io_terminal ();
188 if (inferior_io_terminal == NULL)
189 inferior_io_terminal = "";
190 fprintf_filtered (gdb_stdout,
191 _("Terminal for future runs of program being debugged "
192 "is \"%s\".\n"), inferior_io_terminal);
196 get_inferior_args (void)
198 if (current_inferior ()->argc != 0)
202 n = construct_inferior_arguments (current_inferior ()->argc,
203 current_inferior ()->argv);
204 set_inferior_args (n);
208 if (current_inferior ()->args == NULL)
209 current_inferior ()->args = xstrdup ("");
211 return current_inferior ()->args;
214 /* Set the arguments for the current inferior. Ownership of
215 NEWARGS is not transferred. */
218 set_inferior_args (char *newargs)
220 xfree (current_inferior ()->args);
221 current_inferior ()->args = newargs ? xstrdup (newargs) : NULL;
222 current_inferior ()->argc = 0;
223 current_inferior ()->argv = 0;
227 set_inferior_args_vector (int argc, char **argv)
229 current_inferior ()->argc = argc;
230 current_inferior ()->argv = argv;
233 /* Notice when `set args' is run. */
236 set_args_command (char *args, int from_tty, struct cmd_list_element *c)
238 /* CLI has assigned the user-provided value to inferior_args_scratch.
239 Now route it to current inferior. */
240 set_inferior_args (inferior_args_scratch);
243 /* Notice when `show args' is run. */
246 show_args_command (struct ui_file *file, int from_tty,
247 struct cmd_list_element *c, const char *value)
249 /* Note that we ignore the passed-in value in favor of computing it
251 deprecated_show_value_hack (file, from_tty, c, get_inferior_args ());
255 /* Compute command-line string given argument vector. This does the
256 same shell processing as fork_inferior. */
259 construct_inferior_arguments (int argc, char **argv)
263 if (startup_with_shell)
266 /* This holds all the characters considered special to the
268 char *special = "\"!&*|[]{}<>?`~^=;, \t\n";
269 const char quote = '"';
271 /* This holds all the characters considered special to the
272 typical Unix shells. We include `^' because the SunOS
273 /bin/sh treats it as a synonym for `|'. */
274 char *special = "\"!#$&*()\\|[]{}<>?'`~^; \t\n";
275 const char quote = '\'';
281 /* We over-compute the size. It shouldn't matter. */
282 for (i = 0; i < argc; ++i)
283 length += 3 * strlen (argv[i]) + 1 + 2 * (argv[i][0] == '\0');
285 result = (char *) xmalloc (length);
288 for (i = 0; i < argc; ++i)
293 /* Need to handle empty arguments specially. */
294 if (argv[i][0] == '\0')
304 if (strpbrk (argv[i], special))
310 for (cp = argv[i]; *cp; ++cp)
314 /* A newline cannot be quoted with a backslash (it
315 just disappears), only by putting it inside
326 if (strchr (special, *cp) != NULL)
342 /* In this case we can't handle arguments that contain spaces,
343 tabs, or newlines -- see breakup_args(). */
347 for (i = 0; i < argc; ++i)
349 char *cp = strchr (argv[i], ' ');
351 cp = strchr (argv[i], '\t');
353 cp = strchr (argv[i], '\n');
355 error (_("can't handle command-line "
356 "argument containing whitespace"));
357 length += strlen (argv[i]) + 1;
360 result = (char *) xmalloc (length);
362 for (i = 0; i < argc; ++i)
365 strcat (result, " ");
366 strcat (result, argv[i]);
374 /* This function strips the '&' character (indicating background
375 execution) that is added as *the last* of the arguments ARGS of a
376 command. A copy of the incoming ARGS without the '&' is returned,
377 unless the resulting string after stripping is empty, in which case
378 NULL is returned. *BG_CHAR_P is an output boolean that indicates
379 whether the '&' character was found. */
382 strip_bg_char (const char *args, int *bg_char_p)
386 if (args == NULL || *args == '\0')
392 p = args + strlen (args);
396 while (p > args && isspace (p[-1]))
401 return savestring (args, p - args);
407 return xstrdup (args);
410 /* Common actions to take after creating any sort of inferior, by any
411 means (running, attaching, connecting, et cetera). The target
412 should be stopped. */
415 post_create_inferior (struct target_ops *target, int from_tty)
417 volatile struct gdb_exception ex;
419 /* Be sure we own the terminal in case write operations are performed. */
420 target_terminal_ours ();
422 /* If the target hasn't taken care of this already, do it now.
423 Targets which need to access registers during to_open,
424 to_create_inferior, or to_attach should do it earlier; but many
426 target_find_description ();
428 /* Now that we know the register layout, retrieve current PC. But
429 if the PC is unavailable (e.g., we're opening a core file with
430 missing registers info), ignore it. */
432 TRY_CATCH (ex, RETURN_MASK_ERROR)
434 stop_pc = regcache_read_pc (get_current_regcache ());
436 if (ex.reason < 0 && ex.error != NOT_AVAILABLE_ERROR)
437 throw_exception (ex);
441 const unsigned solib_add_generation
442 = current_program_space->solib_add_generation;
444 /* Create the hooks to handle shared library load and unload
446 solib_create_inferior_hook (from_tty);
448 if (current_program_space->solib_add_generation == solib_add_generation)
450 /* The platform-specific hook should load initial shared libraries,
451 but didn't. FROM_TTY will be incorrectly 0 but such solib
452 targets should be fixed anyway. Call it only after the solib
453 target has been initialized by solib_create_inferior_hook. */
456 warning (_("platform-specific solib_create_inferior_hook did "
457 "not load initial shared libraries."));
459 /* If the solist is global across processes, there's no need to
461 if (!gdbarch_has_global_solist (target_gdbarch ()))
462 solib_add (NULL, 0, target, auto_solib_add);
466 /* If the user sets watchpoints before execution having started,
467 then she gets software watchpoints, because GDB can't know which
468 target will end up being pushed, or if it supports hardware
469 watchpoints or not. breakpoint_re_set takes care of promoting
470 watchpoints to hardware watchpoints if possible, however, if this
471 new inferior doesn't load shared libraries or we don't pull in
472 symbols from any other source on this target/arch,
473 breakpoint_re_set is never called. Call it now so that software
474 watchpoints get a chance to be promoted to hardware watchpoints
475 if the now pushed target supports hardware watchpoints. */
476 breakpoint_re_set ();
478 observer_notify_inferior_created (target, from_tty);
481 /* Kill the inferior if already running. This function is designed
482 to be called when we are about to start the execution of the program
483 from the beginning. Ask the user to confirm that he wants to restart
484 the program being debugged when FROM_TTY is non-null. */
487 kill_if_already_running (int from_tty)
489 if (! ptid_equal (inferior_ptid, null_ptid) && target_has_execution)
491 /* Bail out before killing the program if we will not be able to
493 target_require_runnable ();
496 && !query (_("The program being debugged has been started already.\n\
497 Start it from the beginning? ")))
498 error (_("Program not restarted."));
503 /* See inferior.h. */
506 prepare_execution_command (struct target_ops *target, int background)
508 /* If we get a request for running in the bg but the target
509 doesn't support it, error out. */
510 if (background && !target->to_can_async_p (target))
511 error (_("Asynchronous execution not supported on this target."));
513 /* If we don't get a request of running in the bg, then we need
514 to simulate synchronous (fg) execution. */
515 if (!background && target->to_can_async_p (target))
517 /* Simulate synchronous execution. Note no cleanup is necessary
518 for this. stdin is re-enabled whenever an error reaches the
520 async_disable_stdin ();
524 /* Implement the "run" command. If TBREAK_AT_MAIN is set, then insert
525 a temporary breakpoint at the begining of the main program before
526 running the program. */
529 run_command_1 (char *args, int from_tty, int tbreak_at_main)
532 struct cleanup *old_chain;
534 struct ui_out *uiout = current_uiout;
535 struct target_ops *run_target;
537 struct cleanup *args_chain;
541 kill_if_already_running (from_tty);
543 init_wait_for_inferior ();
544 clear_breakpoint_hit_counts ();
546 /* Clean up any leftovers from other runs. Some other things from
547 this function should probably be moved into target_pre_inferior. */
548 target_pre_inferior (from_tty);
550 /* The comment here used to read, "The exec file is re-read every
551 time we do a generic_mourn_inferior, so we just have to worry
552 about the symbol file." The `generic_mourn_inferior' function
553 gets called whenever the program exits. However, suppose the
554 program exits, and *then* the executable file changes? We need
555 to check again here. Since reopen_exec_file doesn't do anything
556 if the timestamp hasn't changed, I don't see the harm. */
560 args = strip_bg_char (args, &async_exec);
561 args_chain = make_cleanup (xfree, args);
563 /* Do validation and preparation before possibly changing anything
566 run_target = find_run_target ();
568 prepare_execution_command (run_target, async_exec);
570 if (non_stop && !run_target->to_supports_non_stop (run_target))
571 error (_("The target does not support running in non-stop mode."));
573 /* Done. Can now set breakpoints, change inferior args, etc. */
575 /* Insert the temporary breakpoint if a location was specified. */
577 tbreak_command (main_name (), 0);
579 exec_file = (char *) get_exec_file (0);
581 /* We keep symbols from add-symbol-file, on the grounds that the
582 user might want to add some symbols before running the program
583 (right?). But sometimes (dynamic loading where the user manually
584 introduces the new symbols with add-symbol-file), the code which
585 the symbols describe does not persist between runs. Currently
586 the user has to manually nuke all symbols between runs if they
587 want them to go away (PR 2207). This is probably reasonable. */
589 /* If there were other args, beside '&', process them. */
591 set_inferior_args (args);
595 ui_out_field_string (uiout, NULL, "Starting program");
596 ui_out_text (uiout, ": ");
598 ui_out_field_string (uiout, "execfile", exec_file);
599 ui_out_spaces (uiout, 1);
600 /* We call get_inferior_args() because we might need to compute
602 ui_out_field_string (uiout, "infargs", get_inferior_args ());
603 ui_out_text (uiout, "\n");
604 ui_out_flush (uiout);
607 /* Done with ARGS. */
608 do_cleanups (args_chain);
610 /* We call get_inferior_args() because we might need to compute
612 run_target->to_create_inferior (run_target, exec_file, get_inferior_args (),
613 environ_vector (current_inferior ()->environment),
615 /* to_create_inferior should push the target, so after this point we
616 shouldn't refer to run_target again. */
619 /* We're starting off a new process. When we get out of here, in
620 non-stop mode, finish the state of all threads of that process,
621 but leave other threads alone, as they may be stopped in internal
622 events --- the frontend shouldn't see them as stopped. In
623 all-stop, always finish the state of all threads, as we may be
624 resuming more than just the new process. */
626 ptid = pid_to_ptid (ptid_get_pid (inferior_ptid));
628 ptid = minus_one_ptid;
629 old_chain = make_cleanup (finish_thread_state_cleanup, &ptid);
631 /* Pass zero for FROM_TTY, because at this point the "run" command
632 has done its thing; now we are setting up the running program. */
633 post_create_inferior (¤t_target, 0);
635 /* Start the target running. Do not use -1 continuation as it would skip
636 breakpoint right at the entry point. */
637 proceed (regcache_read_pc (get_current_regcache ()), GDB_SIGNAL_0, 0);
639 /* Since there was no error, there's no need to finish the thread
641 discard_cleanups (old_chain);
645 run_command (char *args, int from_tty)
647 run_command_1 (args, from_tty, 0);
651 run_no_args_command (char *args, int from_tty)
653 set_inferior_args ("");
657 /* Start the execution of the program up until the beginning of the main
661 start_command (char *args, int from_tty)
663 /* Some languages such as Ada need to search inside the program
664 minimal symbols for the location where to put the temporary
665 breakpoint before starting. */
666 if (!have_minimal_symbols ())
667 error (_("No symbol table loaded. Use the \"file\" command."));
669 /* Run the program until reaching the main procedure... */
670 run_command_1 (args, from_tty, 1);
674 proceed_thread_callback (struct thread_info *thread, void *arg)
676 /* We go through all threads individually instead of compressing
677 into a single target `resume_all' request, because some threads
678 may be stopped in internal breakpoints/events, or stopped waiting
679 for its turn in the displaced stepping queue (that is, they are
680 running && !executing). The target side has no idea about why
681 the thread is stopped, so a `resume_all' command would resume too
682 much. If/when GDB gains a way to tell the target `hold this
683 thread stopped until I say otherwise', then we can optimize
685 if (!is_stopped (thread->ptid))
688 switch_to_thread (thread->ptid);
689 clear_proceed_status ();
690 proceed ((CORE_ADDR) -1, GDB_SIGNAL_DEFAULT, 0);
695 ensure_valid_thread (void)
697 if (ptid_equal (inferior_ptid, null_ptid)
698 || is_exited (inferior_ptid))
699 error (_("Cannot execute this command without a live selected thread."));
702 /* If the user is looking at trace frames, any resumption of execution
703 is likely to mix up recorded and live target data. So simply
704 disallow those commands. */
707 ensure_not_tfind_mode (void)
709 if (get_traceframe_number () >= 0)
710 error (_("Cannot execute this command while looking at trace frames."));
713 /* Throw an error indicating the current thread is running. */
716 error_is_running (void)
718 error (_("Cannot execute this command while "
719 "the selected thread is running."));
722 /* Calls error_is_running if the current thread is running. */
725 ensure_not_running (void)
727 if (is_running (inferior_ptid))
732 continue_1 (int all_threads)
735 ensure_not_tfind_mode ();
737 if (non_stop && all_threads)
739 /* Don't error out if the current thread is running, because
740 there may be other stopped threads. */
741 struct cleanup *old_chain;
743 /* Backup current thread and selected frame. */
744 old_chain = make_cleanup_restore_current_thread ();
746 iterate_over_threads (proceed_thread_callback, NULL);
750 /* If all threads in the target were already running,
751 proceed_thread_callback ends up never calling proceed,
752 and so nothing calls this to put the inferior's terminal
753 settings in effect and remove stdin from the event loop,
754 which we must when running a foreground command. E.g.:
758 <all threads are running now>
761 <no thread was resumed, but the inferior now owns the terminal>
763 target_terminal_inferior ();
766 /* Restore selected ptid. */
767 do_cleanups (old_chain);
771 ensure_valid_thread ();
772 ensure_not_running ();
773 clear_proceed_status ();
774 proceed ((CORE_ADDR) -1, GDB_SIGNAL_DEFAULT, 0);
778 /* continue [-a] [proceed-count] [&] */
781 continue_command (char *args, int from_tty)
785 struct cleanup *args_chain;
789 /* Find out whether we must run in the background. */
790 args = strip_bg_char (args, &async_exec);
791 args_chain = make_cleanup (xfree, args);
793 prepare_execution_command (¤t_target, async_exec);
797 if (strncmp (args, "-a", sizeof ("-a") - 1) == 0)
800 args += sizeof ("-a") - 1;
806 if (!non_stop && all_threads)
807 error (_("`-a' is meaningless in all-stop mode."));
809 if (args != NULL && all_threads)
810 error (_("Can't resume all threads and specify "
811 "proceed count simultaneously."));
813 /* If we have an argument left, set proceed count of breakpoint we
820 struct thread_info *tp;
823 tp = find_thread_ptid (inferior_ptid);
827 struct target_waitstatus ws;
829 get_last_target_status (&last_ptid, &ws);
830 tp = find_thread_ptid (last_ptid);
833 bs = tp->control.stop_bpstat;
835 while ((stat = bpstat_num (&bs, &num)) != 0)
838 set_ignore_count (num,
839 parse_and_eval_long (args) - 1,
841 /* set_ignore_count prints a message ending with a period.
842 So print two spaces before "Continuing.". */
844 printf_filtered (" ");
848 if (!stopped && from_tty)
851 ("Not stopped at any breakpoint; argument ignored.\n");
855 /* Done with ARGS. */
856 do_cleanups (args_chain);
859 printf_filtered (_("Continuing.\n"));
861 continue_1 (all_threads);
864 /* Record the starting point of a "step" or "next" command. */
867 set_step_frame (void)
869 struct symtab_and_line sal;
871 find_frame_sal (get_current_frame (), &sal);
872 set_step_info (get_current_frame (), sal);
875 /* Step until outside of current statement. */
878 step_command (char *count_string, int from_tty)
880 step_1 (0, 0, count_string);
883 /* Likewise, but skip over subroutine calls as if single instructions. */
886 next_command (char *count_string, int from_tty)
888 step_1 (1, 0, count_string);
891 /* Likewise, but step only one instruction. */
894 stepi_command (char *count_string, int from_tty)
896 step_1 (0, 1, count_string);
900 nexti_command (char *count_string, int from_tty)
902 step_1 (1, 1, count_string);
906 delete_longjmp_breakpoint_cleanup (void *arg)
908 int thread = * (int *) arg;
909 delete_longjmp_breakpoint (thread);
913 step_1 (int skip_subroutines, int single_inst, char *count_string)
916 struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
919 struct cleanup *args_chain;
922 ensure_not_tfind_mode ();
923 ensure_valid_thread ();
924 ensure_not_running ();
926 count_string = strip_bg_char (count_string, &async_exec);
927 args_chain = make_cleanup (xfree, count_string);
929 prepare_execution_command (¤t_target, async_exec);
931 count = count_string ? parse_and_eval_long (count_string) : 1;
933 /* Done with ARGS. */
934 do_cleanups (args_chain);
936 if (!single_inst || skip_subroutines) /* Leave si command alone. */
938 struct thread_info *tp = inferior_thread ();
940 if (in_thread_list (inferior_ptid))
941 thread = pid_to_thread_id (inferior_ptid);
943 set_longjmp_breakpoint (tp, get_frame_id (get_current_frame ()));
945 make_cleanup (delete_longjmp_breakpoint_cleanup, &thread);
948 /* In synchronous case, all is well; each step_once call will step once. */
949 if (!target_can_async_p ())
951 for (; count > 0; count--)
953 step_once (skip_subroutines, single_inst, count, thread);
955 if (!target_has_execution)
959 struct thread_info *tp = inferior_thread ();
961 if (!tp->control.stop_step || !tp->step_multi)
963 /* If we stopped for some reason that is not stepping
964 there are no further steps to make. */
971 do_cleanups (cleanups);
975 /* In the case of an asynchronous target things get complicated;
976 do only one step for now, before returning control to the
977 event loop. Let the continuation figure out how many other
978 steps we need to do, and handle them one at the time, through
980 step_once (skip_subroutines, single_inst, count, thread);
982 /* We are running, and the continuation is installed. It will
983 disable the longjmp breakpoint as appropriate. */
984 discard_cleanups (cleanups);
988 struct step_1_continuation_args
991 int skip_subroutines;
996 /* Called after we are done with one step operation, to check whether
997 we need to step again, before we print the prompt and return control
998 to the user. If count is > 1, we will need to do one more call to
999 proceed(), via step_once(). Basically it is like step_once and
1000 step_1_continuation are co-recursive. */
1003 step_1_continuation (void *args, int err)
1005 struct step_1_continuation_args *a = args;
1007 if (target_has_execution)
1009 struct thread_info *tp;
1011 tp = inferior_thread ();
1013 && tp->step_multi && tp->control.stop_step)
1015 /* There are more steps to make, and we did stop due to
1016 ending a stepping range. Do another step. */
1017 step_once (a->skip_subroutines, a->single_inst,
1018 a->count - 1, a->thread);
1024 /* We either hit an error, or stopped for some reason that is
1025 not stepping, or there are no further steps to make.
1027 if (!a->single_inst || a->skip_subroutines)
1028 delete_longjmp_breakpoint (a->thread);
1031 /* Do just one step operation. This is useful to implement the 'step
1032 n' kind of commands. In case of asynchronous targets, we will have
1033 to set up a continuation to be done after the target stops (after
1034 this one step). For synch targets, the caller handles further
1038 step_once (int skip_subroutines, int single_inst, int count, int thread)
1040 struct frame_info *frame = get_current_frame ();
1044 /* Don't assume THREAD is a valid thread id. It is set to -1 if
1045 the longjmp breakpoint was not required. Use the
1046 INFERIOR_PTID thread instead, which is the same thread when
1048 struct thread_info *tp = inferior_thread ();
1050 clear_proceed_status ();
1057 /* Step at an inlined function behaves like "down". */
1058 if (!skip_subroutines
1059 && inline_skipped_frames (inferior_ptid))
1063 /* Pretend that we've ran. */
1064 resume_ptid = user_visible_resume_ptid (1);
1065 set_running (resume_ptid, 1);
1067 step_into_inline_frame (inferior_ptid);
1069 step_once (skip_subroutines, single_inst, count - 1, thread);
1072 /* Pretend that we've stopped. */
1075 if (target_can_async_p ())
1076 inferior_event_handler (INF_EXEC_COMPLETE, NULL);
1081 pc = get_frame_pc (frame);
1082 find_pc_line_pc_range (pc,
1083 &tp->control.step_range_start,
1084 &tp->control.step_range_end);
1086 tp->control.may_range_step = 1;
1088 /* If we have no line info, switch to stepi mode. */
1089 if (tp->control.step_range_end == 0 && step_stop_if_no_debug)
1091 tp->control.step_range_start = tp->control.step_range_end = 1;
1092 tp->control.may_range_step = 0;
1094 else if (tp->control.step_range_end == 0)
1098 if (find_pc_partial_function (pc, &name,
1099 &tp->control.step_range_start,
1100 &tp->control.step_range_end) == 0)
1101 error (_("Cannot find bounds of current function"));
1103 target_terminal_ours ();
1104 printf_filtered (_("Single stepping until exit from function %s,"
1105 "\nwhich has no line number information.\n"),
1111 /* Say we are stepping, but stop after one insn whatever it does. */
1112 tp->control.step_range_start = tp->control.step_range_end = 1;
1113 if (!skip_subroutines)
1115 Don't step over function calls, not even to functions lacking
1117 tp->control.step_over_calls = STEP_OVER_NONE;
1120 if (skip_subroutines)
1121 tp->control.step_over_calls = STEP_OVER_ALL;
1123 tp->step_multi = (count > 1);
1124 proceed ((CORE_ADDR) -1, GDB_SIGNAL_DEFAULT, 1);
1126 /* For async targets, register a continuation to do any
1127 additional steps. For sync targets, the caller will handle
1128 further stepping. */
1129 if (target_can_async_p ())
1131 struct step_1_continuation_args *args;
1133 args = xmalloc (sizeof (*args));
1134 args->skip_subroutines = skip_subroutines;
1135 args->single_inst = single_inst;
1136 args->count = count;
1137 args->thread = thread;
1139 add_intermediate_continuation (tp, step_1_continuation, args, xfree);
1145 /* Continue program at specified address. */
1148 jump_command (char *arg, int from_tty)
1150 struct gdbarch *gdbarch = get_current_arch ();
1152 struct symtabs_and_lines sals;
1153 struct symtab_and_line sal;
1157 struct cleanup *args_chain;
1160 ensure_not_tfind_mode ();
1161 ensure_valid_thread ();
1162 ensure_not_running ();
1164 /* Find out whether we must run in the background. */
1165 arg = strip_bg_char (arg, &async_exec);
1166 args_chain = make_cleanup (xfree, arg);
1168 prepare_execution_command (¤t_target, async_exec);
1171 error_no_arg (_("starting address"));
1173 sals = decode_line_with_last_displayed (arg, DECODE_LINE_FUNFIRSTLINE);
1174 if (sals.nelts != 1)
1176 error (_("Unreasonable jump request"));
1182 /* Done with ARGS. */
1183 do_cleanups (args_chain);
1185 if (sal.symtab == 0 && sal.pc == 0)
1186 error (_("No source file has been specified."));
1188 resolve_sal_pc (&sal); /* May error out. */
1190 /* See if we are trying to jump to another function. */
1191 fn = get_frame_function (get_current_frame ());
1192 sfn = find_pc_function (sal.pc);
1193 if (fn != NULL && sfn != fn)
1195 if (!query (_("Line %d is not in `%s'. Jump anyway? "), sal.line,
1196 SYMBOL_PRINT_NAME (fn)))
1198 error (_("Not confirmed."));
1205 fixup_symbol_section (sfn, 0);
1206 if (section_is_overlay (SYMBOL_OBJ_SECTION (SYMBOL_OBJFILE (sfn), sfn)) &&
1207 !section_is_mapped (SYMBOL_OBJ_SECTION (SYMBOL_OBJFILE (sfn), sfn)))
1209 if (!query (_("WARNING!!! Destination is in "
1210 "unmapped overlay! Jump anyway? ")))
1212 error (_("Not confirmed."));
1222 printf_filtered (_("Continuing at "));
1223 fputs_filtered (paddress (gdbarch, addr), gdb_stdout);
1224 printf_filtered (".\n");
1227 clear_proceed_status ();
1228 proceed (addr, GDB_SIGNAL_0, 0);
1232 /* Go to line or address in current procedure. */
1235 go_command (char *line_no, int from_tty)
1237 if (line_no == (char *) NULL || !*line_no)
1238 printf_filtered (_("Usage: go <location>\n"));
1241 tbreak_command (line_no, from_tty);
1242 jump_command (line_no, from_tty);
1247 /* Continue program giving it specified signal. */
1250 signal_command (char *signum_exp, int from_tty)
1252 enum gdb_signal oursig;
1254 struct cleanup *args_chain;
1256 dont_repeat (); /* Too dangerous. */
1258 ensure_not_tfind_mode ();
1259 ensure_valid_thread ();
1260 ensure_not_running ();
1262 /* Find out whether we must run in the background. */
1263 signum_exp = strip_bg_char (signum_exp, &async_exec);
1264 args_chain = make_cleanup (xfree, signum_exp);
1266 prepare_execution_command (¤t_target, async_exec);
1269 error_no_arg (_("signal number"));
1271 /* It would be even slicker to make signal names be valid expressions,
1272 (the type could be "enum $signal" or some such), then the user could
1273 assign them to convenience variables. */
1274 oursig = gdb_signal_from_name (signum_exp);
1276 if (oursig == GDB_SIGNAL_UNKNOWN)
1278 /* No, try numeric. */
1279 int num = parse_and_eval_long (signum_exp);
1282 oursig = GDB_SIGNAL_0;
1284 oursig = gdb_signal_from_command (num);
1289 if (oursig == GDB_SIGNAL_0)
1290 printf_filtered (_("Continuing with no signal.\n"));
1292 printf_filtered (_("Continuing with signal %s.\n"),
1293 gdb_signal_to_name (oursig));
1296 clear_proceed_status ();
1297 proceed ((CORE_ADDR) -1, oursig, 0);
1300 /* Continuation args to be passed to the "until" command
1302 struct until_next_continuation_args
1304 /* The thread that was current when the command was executed. */
1308 /* A continuation callback for until_next_command. */
1311 until_next_continuation (void *arg, int err)
1313 struct until_next_continuation_args *a = arg;
1315 delete_longjmp_breakpoint (a->thread);
1318 /* Proceed until we reach a different source line with pc greater than
1319 our current one or exit the function. We skip calls in both cases.
1321 Note that eventually this command should probably be changed so
1322 that only source lines are printed out when we hit the breakpoint
1323 we set. This may involve changes to wait_for_inferior and the
1324 proceed status code. */
1327 until_next_command (int from_tty)
1329 struct frame_info *frame;
1331 struct symbol *func;
1332 struct symtab_and_line sal;
1333 struct thread_info *tp = inferior_thread ();
1334 int thread = tp->num;
1335 struct cleanup *old_chain;
1337 clear_proceed_status ();
1340 frame = get_current_frame ();
1342 /* Step until either exited from this function or greater
1343 than the current line (if in symbolic section) or pc (if
1346 pc = get_frame_pc (frame);
1347 func = find_pc_function (pc);
1351 struct bound_minimal_symbol msymbol = lookup_minimal_symbol_by_pc (pc);
1353 if (msymbol.minsym == NULL)
1354 error (_("Execution is not within a known function."));
1356 tp->control.step_range_start = BMSYMBOL_VALUE_ADDRESS (msymbol);
1357 /* The upper-bound of step_range is exclusive. In order to make PC
1358 within the range, set the step_range_end with PC + 1. */
1359 tp->control.step_range_end = pc + 1;
1363 sal = find_pc_line (pc, 0);
1365 tp->control.step_range_start = BLOCK_START (SYMBOL_BLOCK_VALUE (func));
1366 tp->control.step_range_end = sal.end;
1368 tp->control.may_range_step = 1;
1370 tp->control.step_over_calls = STEP_OVER_ALL;
1372 tp->step_multi = 0; /* Only one call to proceed */
1374 set_longjmp_breakpoint (tp, get_frame_id (frame));
1375 old_chain = make_cleanup (delete_longjmp_breakpoint_cleanup, &thread);
1377 proceed ((CORE_ADDR) -1, GDB_SIGNAL_DEFAULT, 1);
1379 if (target_can_async_p () && is_running (inferior_ptid))
1381 struct until_next_continuation_args *cont_args;
1383 discard_cleanups (old_chain);
1384 cont_args = XNEW (struct until_next_continuation_args);
1385 cont_args->thread = inferior_thread ()->num;
1387 add_continuation (tp, until_next_continuation, cont_args, xfree);
1390 do_cleanups (old_chain);
1394 until_command (char *arg, int from_tty)
1397 struct cleanup *args_chain;
1400 ensure_not_tfind_mode ();
1401 ensure_valid_thread ();
1402 ensure_not_running ();
1404 /* Find out whether we must run in the background. */
1405 arg = strip_bg_char (arg, &async_exec);
1406 args_chain = make_cleanup (xfree, arg);
1408 prepare_execution_command (¤t_target, async_exec);
1411 until_break_command (arg, from_tty, 0);
1413 until_next_command (from_tty);
1415 /* Done with ARGS. */
1416 do_cleanups (args_chain);
1420 advance_command (char *arg, int from_tty)
1423 struct cleanup *args_chain;
1426 ensure_not_tfind_mode ();
1427 ensure_valid_thread ();
1428 ensure_not_running ();
1431 error_no_arg (_("a location"));
1433 /* Find out whether we must run in the background. */
1434 arg = strip_bg_char (arg, &async_exec);
1435 args_chain = make_cleanup (xfree, arg);
1437 prepare_execution_command (¤t_target, async_exec);
1439 until_break_command (arg, from_tty, 1);
1441 /* Done with ARGS. */
1442 do_cleanups (args_chain);
1445 /* Return the value of the result of a function at the end of a 'finish'
1449 get_return_value (struct value *function, struct type *value_type)
1451 struct regcache *stop_regs = stop_registers;
1452 struct gdbarch *gdbarch;
1453 struct value *value;
1454 struct cleanup *cleanup = make_cleanup (null_cleanup, NULL);
1456 /* If stop_registers were not saved, use the current registers. */
1459 stop_regs = regcache_dup (get_current_regcache ());
1460 make_cleanup_regcache_xfree (stop_regs);
1463 gdbarch = get_regcache_arch (stop_regs);
1465 CHECK_TYPEDEF (value_type);
1466 gdb_assert (TYPE_CODE (value_type) != TYPE_CODE_VOID);
1468 /* FIXME: 2003-09-27: When returning from a nested inferior function
1469 call, it's possible (with no help from the architecture vector)
1470 to locate and return/print a "struct return" value. This is just
1471 a more complicated case of what is already being done in the
1472 inferior function call code. In fact, when inferior function
1473 calls are made async, this will likely be made the norm. */
1475 switch (gdbarch_return_value (gdbarch, function, value_type,
1478 case RETURN_VALUE_REGISTER_CONVENTION:
1479 case RETURN_VALUE_ABI_RETURNS_ADDRESS:
1480 case RETURN_VALUE_ABI_PRESERVES_ADDRESS:
1481 value = allocate_value (value_type);
1482 gdbarch_return_value (gdbarch, function, value_type, stop_regs,
1483 value_contents_raw (value), NULL);
1485 case RETURN_VALUE_STRUCT_CONVENTION:
1489 internal_error (__FILE__, __LINE__, _("bad switch"));
1492 do_cleanups (cleanup);
1497 /* Print the result of a function at the end of a 'finish' command. */
1500 print_return_value (struct value *function, struct type *value_type)
1502 struct value *value = get_return_value (function, value_type);
1503 struct ui_out *uiout = current_uiout;
1507 struct value_print_options opts;
1508 struct ui_file *stb;
1509 struct cleanup *old_chain;
1512 stb = mem_fileopen ();
1513 old_chain = make_cleanup_ui_file_delete (stb);
1514 ui_out_text (uiout, "Value returned is ");
1515 ui_out_field_fmt (uiout, "gdb-result-var", "$%d",
1516 record_latest_value (value));
1517 ui_out_text (uiout, " = ");
1518 get_no_prettyformat_print_options (&opts);
1519 value_print (value, stb, &opts);
1520 ui_out_field_stream (uiout, "return-value", stb);
1521 ui_out_text (uiout, "\n");
1522 do_cleanups (old_chain);
1526 ui_out_text (uiout, "Value returned has type: ");
1527 ui_out_field_string (uiout, "return-type", TYPE_NAME (value_type));
1528 ui_out_text (uiout, ".");
1529 ui_out_text (uiout, " Cannot determine contents\n");
1533 /* Stuff that needs to be done by the finish command after the target
1534 has stopped. In asynchronous mode, we wait for the target to stop
1535 in the call to poll or select in the event loop, so it is
1536 impossible to do all the stuff as part of the finish_command
1537 function itself. The only chance we have to complete this command
1538 is in fetch_inferior_event, which is called by the event loop as
1539 soon as it detects that the target has stopped. */
1541 struct finish_command_continuation_args
1543 /* The thread that as current when the command was executed. */
1545 struct breakpoint *breakpoint;
1546 struct symbol *function;
1550 finish_command_continuation (void *arg, int err)
1552 struct finish_command_continuation_args *a = arg;
1556 struct thread_info *tp = NULL;
1559 if (!ptid_equal (inferior_ptid, null_ptid)
1560 && target_has_execution
1561 && is_stopped (inferior_ptid))
1563 tp = inferior_thread ();
1564 bs = tp->control.stop_bpstat;
1567 if (bpstat_find_breakpoint (bs, a->breakpoint) != NULL
1568 && a->function != NULL)
1570 struct type *value_type;
1572 value_type = TYPE_TARGET_TYPE (SYMBOL_TYPE (a->function));
1574 internal_error (__FILE__, __LINE__,
1575 _("finish_command: function has no target type"));
1577 if (TYPE_CODE (value_type) != TYPE_CODE_VOID)
1579 volatile struct gdb_exception ex;
1582 func = read_var_value (a->function, get_current_frame ());
1583 TRY_CATCH (ex, RETURN_MASK_ALL)
1585 /* print_return_value can throw an exception in some
1586 circumstances. We need to catch this so that we still
1587 delete the breakpoint. */
1588 print_return_value (func, value_type);
1591 exception_print (gdb_stdout, ex);
1595 /* We suppress normal call of normal_stop observer and do it
1596 here so that the *stopped notification includes the return
1598 if (bs != NULL && tp->control.proceed_to_finish)
1599 observer_notify_normal_stop (bs, 1 /* print frame */);
1602 delete_breakpoint (a->breakpoint);
1603 delete_longjmp_breakpoint (a->thread);
1607 finish_command_continuation_free_arg (void *arg)
1612 /* finish_backward -- helper function for finish_command. */
1615 finish_backward (struct symbol *function)
1617 struct symtab_and_line sal;
1618 struct thread_info *tp = inferior_thread ();
1620 CORE_ADDR func_addr;
1622 pc = get_frame_pc (get_current_frame ());
1624 if (find_pc_partial_function (pc, NULL, &func_addr, NULL) == 0)
1625 internal_error (__FILE__, __LINE__,
1626 _("Finish: couldn't find function."));
1628 sal = find_pc_line (func_addr, 0);
1630 tp->control.proceed_to_finish = 1;
1631 /* Special case: if we're sitting at the function entry point,
1632 then all we need to do is take a reverse singlestep. We
1633 don't need to set a breakpoint, and indeed it would do us
1636 Note that this can only happen at frame #0, since there's
1637 no way that a function up the stack can have a return address
1638 that's equal to its entry point. */
1642 struct frame_info *frame = get_selected_frame (NULL);
1643 struct gdbarch *gdbarch = get_frame_arch (frame);
1644 struct symtab_and_line sr_sal;
1646 /* Set a step-resume at the function's entry point. Once that's
1647 hit, we'll do one more step backwards. */
1650 sr_sal.pspace = get_frame_program_space (frame);
1651 insert_step_resume_breakpoint_at_sal (gdbarch,
1652 sr_sal, null_frame_id);
1654 proceed ((CORE_ADDR) -1, GDB_SIGNAL_DEFAULT, 0);
1658 /* We're almost there -- we just need to back up by one more
1660 tp->control.step_range_start = tp->control.step_range_end = 1;
1661 proceed ((CORE_ADDR) -1, GDB_SIGNAL_DEFAULT, 1);
1665 /* finish_forward -- helper function for finish_command. */
1668 finish_forward (struct symbol *function, struct frame_info *frame)
1670 struct frame_id frame_id = get_frame_id (frame);
1671 struct gdbarch *gdbarch = get_frame_arch (frame);
1672 struct symtab_and_line sal;
1673 struct thread_info *tp = inferior_thread ();
1674 struct breakpoint *breakpoint;
1675 struct cleanup *old_chain;
1676 struct finish_command_continuation_args *cargs;
1677 int thread = tp->num;
1679 sal = find_pc_line (get_frame_pc (frame), 0);
1680 sal.pc = get_frame_pc (frame);
1682 breakpoint = set_momentary_breakpoint (gdbarch, sal,
1683 get_stack_frame_id (frame),
1686 /* set_momentary_breakpoint invalidates FRAME. */
1689 old_chain = make_cleanup_delete_breakpoint (breakpoint);
1691 set_longjmp_breakpoint (tp, frame_id);
1692 make_cleanup (delete_longjmp_breakpoint_cleanup, &thread);
1694 /* We want stop_registers, please... */
1695 tp->control.proceed_to_finish = 1;
1696 cargs = xmalloc (sizeof (*cargs));
1698 cargs->thread = thread;
1699 cargs->breakpoint = breakpoint;
1700 cargs->function = function;
1701 add_continuation (tp, finish_command_continuation, cargs,
1702 finish_command_continuation_free_arg);
1703 proceed ((CORE_ADDR) -1, GDB_SIGNAL_DEFAULT, 0);
1705 discard_cleanups (old_chain);
1706 if (!target_can_async_p ())
1707 do_all_continuations (0);
1710 /* "finish": Set a temporary breakpoint at the place the selected
1711 frame will return to, then continue. */
1714 finish_command (char *arg, int from_tty)
1716 struct frame_info *frame;
1717 struct symbol *function;
1719 struct cleanup *args_chain;
1722 ensure_not_tfind_mode ();
1723 ensure_valid_thread ();
1724 ensure_not_running ();
1726 /* Find out whether we must run in the background. */
1727 arg = strip_bg_char (arg, &async_exec);
1728 args_chain = make_cleanup (xfree, arg);
1730 prepare_execution_command (¤t_target, async_exec);
1733 error (_("The \"finish\" command does not take any arguments."));
1735 /* Done with ARGS. */
1736 do_cleanups (args_chain);
1738 frame = get_prev_frame (get_selected_frame (_("No selected frame.")));
1740 error (_("\"finish\" not meaningful in the outermost frame."));
1742 clear_proceed_status ();
1744 /* Finishing from an inline frame is completely different. We don't
1745 try to show the "return value" - no way to locate it. So we do
1746 not need a completion. */
1747 if (get_frame_type (get_selected_frame (_("No selected frame.")))
1750 /* Claim we are stepping in the calling frame. An empty step
1751 range means that we will stop once we aren't in a function
1752 called by that frame. We don't use the magic "1" value for
1753 step_range_end, because then infrun will think this is nexti,
1754 and not step over the rest of this inlined function call. */
1755 struct thread_info *tp = inferior_thread ();
1756 struct symtab_and_line empty_sal;
1758 init_sal (&empty_sal);
1759 set_step_info (frame, empty_sal);
1760 tp->control.step_range_start = get_frame_pc (frame);
1761 tp->control.step_range_end = tp->control.step_range_start;
1762 tp->control.step_over_calls = STEP_OVER_ALL;
1764 /* Print info on the selected frame, including level number but not
1768 printf_filtered (_("Run till exit from "));
1769 print_stack_frame (get_selected_frame (NULL), 1, LOCATION, 0);
1772 proceed ((CORE_ADDR) -1, GDB_SIGNAL_DEFAULT, 1);
1776 /* Ignore TAILCALL_FRAME type frames, they were executed already before
1777 entering THISFRAME. */
1778 while (get_frame_type (frame) == TAILCALL_FRAME)
1779 frame = get_prev_frame (frame);
1781 /* Find the function we will return from. */
1783 function = find_pc_function (get_frame_pc (get_selected_frame (NULL)));
1785 /* Print info on the selected frame, including level number but not
1789 if (execution_direction == EXEC_REVERSE)
1790 printf_filtered (_("Run back to call of "));
1792 printf_filtered (_("Run till exit from "));
1794 print_stack_frame (get_selected_frame (NULL), 1, LOCATION, 0);
1797 if (execution_direction == EXEC_REVERSE)
1798 finish_backward (function);
1800 finish_forward (function, frame);
1805 program_info (char *args, int from_tty)
1809 struct thread_info *tp;
1812 if (!target_has_execution)
1814 printf_filtered (_("The program being debugged is not being run.\n"));
1819 ptid = inferior_ptid;
1822 struct target_waitstatus ws;
1824 get_last_target_status (&ptid, &ws);
1827 if (ptid_equal (ptid, null_ptid) || is_exited (ptid))
1828 error (_("Invalid selected thread."));
1829 else if (is_running (ptid))
1830 error (_("Selected thread is running."));
1832 tp = find_thread_ptid (ptid);
1833 bs = tp->control.stop_bpstat;
1834 stat = bpstat_num (&bs, &num);
1836 target_files_info ();
1837 printf_filtered (_("Program stopped at %s.\n"),
1838 paddress (target_gdbarch (), stop_pc));
1839 if (tp->control.stop_step)
1840 printf_filtered (_("It stopped after being stepped.\n"));
1843 /* There may be several breakpoints in the same place, so this
1844 isn't as strange as it seems. */
1849 printf_filtered (_("It stopped at a breakpoint "
1850 "that has since been deleted.\n"));
1853 printf_filtered (_("It stopped at breakpoint %d.\n"), num);
1854 stat = bpstat_num (&bs, &num);
1857 else if (tp->suspend.stop_signal != GDB_SIGNAL_0)
1859 printf_filtered (_("It stopped with signal %s, %s.\n"),
1860 gdb_signal_to_name (tp->suspend.stop_signal),
1861 gdb_signal_to_string (tp->suspend.stop_signal));
1866 printf_filtered (_("Type \"info stack\" or \"info "
1867 "registers\" for more information.\n"));
1872 environment_info (char *var, int from_tty)
1876 char *val = get_in_environ (current_inferior ()->environment, var);
1880 puts_filtered (var);
1881 puts_filtered (" = ");
1882 puts_filtered (val);
1883 puts_filtered ("\n");
1887 puts_filtered ("Environment variable \"");
1888 puts_filtered (var);
1889 puts_filtered ("\" not defined.\n");
1894 char **vector = environ_vector (current_inferior ()->environment);
1898 puts_filtered (*vector++);
1899 puts_filtered ("\n");
1905 set_environment_command (char *arg, int from_tty)
1907 char *p, *val, *var;
1911 error_no_arg (_("environment variable and value"));
1913 /* Find seperation between variable name and value. */
1914 p = (char *) strchr (arg, '=');
1915 val = (char *) strchr (arg, ' ');
1917 if (p != 0 && val != 0)
1919 /* We have both a space and an equals. If the space is before the
1920 equals, walk forward over the spaces til we see a nonspace
1921 (possibly the equals). */
1926 /* Now if the = is after the char following the spaces,
1927 take the char following the spaces. */
1931 else if (val != 0 && p == 0)
1935 error_no_arg (_("environment variable to set"));
1937 if (p == 0 || p[1] == 0)
1941 p = arg + strlen (arg); /* So that savestring below will work. */
1945 /* Not setting variable value to null. */
1947 while (*val == ' ' || *val == '\t')
1951 while (p != arg && (p[-1] == ' ' || p[-1] == '\t'))
1954 var = savestring (arg, p - arg);
1957 printf_filtered (_("Setting environment variable "
1958 "\"%s\" to null value.\n"),
1960 set_in_environ (current_inferior ()->environment, var, "");
1963 set_in_environ (current_inferior ()->environment, var, val);
1968 unset_environment_command (char *var, int from_tty)
1972 /* If there is no argument, delete all environment variables.
1973 Ask for confirmation if reading from the terminal. */
1974 if (!from_tty || query (_("Delete all environment variables? ")))
1976 free_environ (current_inferior ()->environment);
1977 current_inferior ()->environment = make_environ ();
1981 unset_in_environ (current_inferior ()->environment, var);
1984 /* Handle the execution path (PATH variable). */
1986 static const char path_var_name[] = "PATH";
1989 path_info (char *args, int from_tty)
1991 puts_filtered ("Executable and object file path: ");
1992 puts_filtered (get_in_environ (current_inferior ()->environment,
1994 puts_filtered ("\n");
1997 /* Add zero or more directories to the front of the execution path. */
2000 path_command (char *dirname, int from_tty)
2006 env = get_in_environ (current_inferior ()->environment, path_var_name);
2007 /* Can be null if path is not set. */
2010 exec_path = xstrdup (env);
2011 mod_path (dirname, &exec_path);
2012 set_in_environ (current_inferior ()->environment, path_var_name, exec_path);
2015 path_info ((char *) NULL, from_tty);
2019 /* Print out the register NAME with value VAL, to FILE, in the default
2023 default_print_one_register_info (struct ui_file *file,
2027 struct type *regtype = value_type (val);
2028 int print_raw_format;
2030 fputs_filtered (name, file);
2031 print_spaces_filtered (15 - strlen (name), file);
2033 print_raw_format = (value_entirely_available (val)
2034 && !value_optimized_out (val));
2036 /* If virtual format is floating, print it that way, and in raw
2038 if (TYPE_CODE (regtype) == TYPE_CODE_FLT
2039 || TYPE_CODE (regtype) == TYPE_CODE_DECFLOAT)
2042 struct value_print_options opts;
2043 const gdb_byte *valaddr = value_contents_for_printing (val);
2044 enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (regtype));
2046 get_user_print_options (&opts);
2050 value_contents_for_printing (val),
2051 value_embedded_offset (val), 0,
2052 file, 0, val, &opts, current_language);
2054 if (print_raw_format)
2056 fprintf_filtered (file, "\t(raw ");
2057 print_hex_chars (file, valaddr, TYPE_LENGTH (regtype), byte_order);
2058 fprintf_filtered (file, ")");
2063 struct value_print_options opts;
2065 /* Print the register in hex. */
2066 get_formatted_print_options (&opts, 'x');
2069 value_contents_for_printing (val),
2070 value_embedded_offset (val), 0,
2071 file, 0, val, &opts, current_language);
2072 /* If not a vector register, print it also according to its
2074 if (print_raw_format && TYPE_VECTOR (regtype) == 0)
2076 get_user_print_options (&opts);
2078 fprintf_filtered (file, "\t");
2080 value_contents_for_printing (val),
2081 value_embedded_offset (val), 0,
2082 file, 0, val, &opts, current_language);
2086 fprintf_filtered (file, "\n");
2089 /* Print out the machine register regnum. If regnum is -1, print all
2090 registers (print_all == 1) or all non-float and non-vector
2091 registers (print_all == 0).
2093 For most machines, having all_registers_info() print the
2094 register(s) one per line is good enough. If a different format is
2095 required, (eg, for MIPS or Pyramid 90x, which both have lots of
2096 regs), or there is an existing convention for showing all the
2097 registers, define the architecture method PRINT_REGISTERS_INFO to
2098 provide that format. */
2101 default_print_registers_info (struct gdbarch *gdbarch,
2102 struct ui_file *file,
2103 struct frame_info *frame,
2104 int regnum, int print_all)
2107 const int numregs = gdbarch_num_regs (gdbarch)
2108 + gdbarch_num_pseudo_regs (gdbarch);
2110 for (i = 0; i < numregs; i++)
2112 /* Decide between printing all regs, non-float / vector regs, or
2118 if (!gdbarch_register_reggroup_p (gdbarch, i, all_reggroup))
2123 if (!gdbarch_register_reggroup_p (gdbarch, i, general_reggroup))
2133 /* If the register name is empty, it is undefined for this
2134 processor, so don't display anything. */
2135 if (gdbarch_register_name (gdbarch, i) == NULL
2136 || *(gdbarch_register_name (gdbarch, i)) == '\0')
2139 default_print_one_register_info (file,
2140 gdbarch_register_name (gdbarch, i),
2141 value_of_register (i, frame));
2146 registers_info (char *addr_exp, int fpregs)
2148 struct frame_info *frame;
2149 struct gdbarch *gdbarch;
2151 if (!target_has_registers)
2152 error (_("The program has no registers now."));
2153 frame = get_selected_frame (NULL);
2154 gdbarch = get_frame_arch (frame);
2158 gdbarch_print_registers_info (gdbarch, gdb_stdout,
2163 while (*addr_exp != '\0')
2168 /* Skip leading white space. */
2169 addr_exp = skip_spaces (addr_exp);
2171 /* Discard any leading ``$''. Check that there is something
2172 resembling a register following it. */
2173 if (addr_exp[0] == '$')
2175 if (isspace ((*addr_exp)) || (*addr_exp) == '\0')
2176 error (_("Missing register name"));
2178 /* Find the start/end of this register name/num/group. */
2180 while ((*addr_exp) != '\0' && !isspace ((*addr_exp)))
2184 /* Figure out what we've found and display it. */
2186 /* A register name? */
2188 int regnum = user_reg_map_name_to_regnum (gdbarch, start, end - start);
2192 /* User registers lie completely outside of the range of
2193 normal registers. Catch them early so that the target
2195 if (regnum >= gdbarch_num_regs (gdbarch)
2196 + gdbarch_num_pseudo_regs (gdbarch))
2198 struct value *regval = value_of_user_reg (regnum, frame);
2199 const char *regname = user_reg_map_regnum_to_name (gdbarch,
2202 /* Print in the same fashion
2203 gdbarch_print_registers_info's default
2204 implementation prints. */
2205 default_print_one_register_info (gdb_stdout,
2210 gdbarch_print_registers_info (gdbarch, gdb_stdout,
2211 frame, regnum, fpregs);
2216 /* A register group? */
2218 struct reggroup *group;
2220 for (group = reggroup_next (gdbarch, NULL);
2222 group = reggroup_next (gdbarch, group))
2224 /* Don't bother with a length check. Should the user
2225 enter a short register group name, go with the first
2226 group that matches. */
2227 if (strncmp (start, reggroup_name (group), end - start) == 0)
2235 regnum < gdbarch_num_regs (gdbarch)
2236 + gdbarch_num_pseudo_regs (gdbarch);
2239 if (gdbarch_register_reggroup_p (gdbarch, regnum, group))
2240 gdbarch_print_registers_info (gdbarch,
2248 /* Nothing matched. */
2249 error (_("Invalid register `%.*s'"), (int) (end - start), start);
2254 all_registers_info (char *addr_exp, int from_tty)
2256 registers_info (addr_exp, 1);
2260 nofp_registers_info (char *addr_exp, int from_tty)
2262 registers_info (addr_exp, 0);
2266 print_vector_info (struct ui_file *file,
2267 struct frame_info *frame, const char *args)
2269 struct gdbarch *gdbarch = get_frame_arch (frame);
2271 if (gdbarch_print_vector_info_p (gdbarch))
2272 gdbarch_print_vector_info (gdbarch, file, frame, args);
2276 int printed_something = 0;
2279 regnum < gdbarch_num_regs (gdbarch)
2280 + gdbarch_num_pseudo_regs (gdbarch);
2283 if (gdbarch_register_reggroup_p (gdbarch, regnum, vector_reggroup))
2285 printed_something = 1;
2286 gdbarch_print_registers_info (gdbarch, file, frame, regnum, 1);
2289 if (!printed_something)
2290 fprintf_filtered (file, "No vector information\n");
2295 vector_info (char *args, int from_tty)
2297 if (!target_has_registers)
2298 error (_("The program has no registers now."));
2300 print_vector_info (gdb_stdout, get_selected_frame (NULL), args);
2303 /* Kill the inferior process. Make us have no inferior. */
2306 kill_command (char *arg, int from_tty)
2308 /* FIXME: This should not really be inferior_ptid (or target_has_execution).
2309 It should be a distinct flag that indicates that a target is active, cuz
2310 some targets don't have processes! */
2312 if (ptid_equal (inferior_ptid, null_ptid))
2313 error (_("The program is not being run."));
2314 if (!query (_("Kill the program being debugged? ")))
2315 error (_("Not confirmed."));
2318 /* If we still have other inferiors to debug, then don't mess with
2319 with their threads. */
2320 if (!have_inferiors ())
2322 init_thread_list (); /* Destroy thread info. */
2324 /* Killing off the inferior can leave us with a core file. If
2325 so, print the state we are left in. */
2326 if (target_has_stack)
2328 printf_filtered (_("In %s,\n"), target_longname);
2329 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1);
2332 bfd_cache_close_all ();
2335 /* Used in `attach&' command. ARG is a point to an integer
2336 representing a process id. Proceed threads of this process iff
2337 they stopped due to debugger request, and when they did, they
2338 reported a clean stop (GDB_SIGNAL_0). Do not proceed threads
2339 that have been explicitly been told to stop. */
2342 proceed_after_attach_callback (struct thread_info *thread,
2345 int pid = * (int *) arg;
2347 if (ptid_get_pid (thread->ptid) == pid
2348 && !is_exited (thread->ptid)
2349 && !is_executing (thread->ptid)
2350 && !thread->stop_requested
2351 && thread->suspend.stop_signal == GDB_SIGNAL_0)
2353 switch_to_thread (thread->ptid);
2354 clear_proceed_status ();
2355 proceed ((CORE_ADDR) -1, GDB_SIGNAL_DEFAULT, 0);
2362 proceed_after_attach (int pid)
2364 /* Don't error out if the current thread is running, because
2365 there may be other stopped threads. */
2366 struct cleanup *old_chain;
2368 /* Backup current thread and selected frame. */
2369 old_chain = make_cleanup_restore_current_thread ();
2371 iterate_over_threads (proceed_after_attach_callback, &pid);
2373 /* Restore selected ptid. */
2374 do_cleanups (old_chain);
2379 * Should save/restore the tty state since it might be that the
2380 * program to be debugged was started on this tty and it wants
2381 * the tty in some state other than what we want. If it's running
2382 * on another terminal or without a terminal, then saving and
2383 * restoring the tty state is a harmless no-op.
2384 * This only needs to be done if we are attaching to a process.
2387 /* attach_command --
2388 takes a program started up outside of gdb and ``attaches'' to it.
2389 This stops it cold in its tracks and allows us to start debugging it.
2390 and wait for the trace-trap that results from attaching. */
2393 attach_command_post_wait (char *args, int from_tty, int async_exec)
2396 char *full_exec_path = NULL;
2397 struct inferior *inferior;
2399 inferior = current_inferior ();
2400 inferior->control.stop_soon = NO_STOP_QUIETLY;
2402 /* If no exec file is yet known, try to determine it from the
2404 exec_file = (char *) get_exec_file (0);
2407 exec_file = target_pid_to_exec_file (ptid_get_pid (inferior_ptid));
2410 /* It's possible we don't have a full path, but rather just a
2411 filename. Some targets, such as HP-UX, don't provide the
2414 Attempt to qualify the filename against the source path.
2415 (If that fails, we'll just fall back on the original
2416 filename. Not much more we can do...) */
2418 if (!source_full_path_of (exec_file, &full_exec_path))
2419 full_exec_path = xstrdup (exec_file);
2421 exec_file_attach (full_exec_path, from_tty);
2422 symbol_file_add_main (full_exec_path, from_tty);
2427 reopen_exec_file ();
2431 /* Take any necessary post-attaching actions for this platform. */
2432 target_post_attach (ptid_get_pid (inferior_ptid));
2434 post_create_inferior (¤t_target, from_tty);
2438 /* The user requested an `attach&', so be sure to leave threads
2439 that didn't get a signal running. */
2441 /* Immediatelly resume all suspended threads of this inferior,
2442 and this inferior only. This should have no effect on
2443 already running threads. If a thread has been stopped with a
2444 signal, leave it be. */
2446 proceed_after_attach (inferior->pid);
2449 if (inferior_thread ()->suspend.stop_signal == GDB_SIGNAL_0)
2451 clear_proceed_status ();
2452 proceed ((CORE_ADDR) -1, GDB_SIGNAL_DEFAULT, 0);
2458 /* The user requested a plain `attach', so be sure to leave
2459 the inferior stopped. */
2461 if (target_can_async_p ())
2462 async_enable_stdin ();
2464 /* At least the current thread is already stopped. */
2466 /* In all-stop, by definition, all threads have to be already
2467 stopped at this point. In non-stop, however, although the
2468 selected thread is stopped, others may still be executing.
2469 Be sure to explicitly stop all threads of the process. This
2470 should have no effect on already stopped threads. */
2472 target_stop (pid_to_ptid (inferior->pid));
2474 /* Tell the user/frontend where we're stopped. */
2476 if (deprecated_attach_hook)
2477 deprecated_attach_hook ();
2481 struct attach_command_continuation_args
2489 attach_command_continuation (void *args, int err)
2491 struct attach_command_continuation_args *a = args;
2496 attach_command_post_wait (a->args, a->from_tty, a->async_exec);
2500 attach_command_continuation_free_args (void *args)
2502 struct attach_command_continuation_args *a = args;
2509 attach_command (char *args, int from_tty)
2512 struct cleanup *args_chain;
2513 struct target_ops *attach_target;
2515 dont_repeat (); /* Not for the faint of heart */
2517 if (gdbarch_has_global_solist (target_gdbarch ()))
2518 /* Don't complain if all processes share the same symbol
2521 else if (target_has_execution)
2523 if (query (_("A program is being debugged already. Kill it? ")))
2526 error (_("Not killed."));
2529 /* Clean up any leftovers from other runs. Some other things from
2530 this function should probably be moved into target_pre_inferior. */
2531 target_pre_inferior (from_tty);
2533 args = strip_bg_char (args, &async_exec);
2534 args_chain = make_cleanup (xfree, args);
2536 attach_target = find_attach_target ();
2538 prepare_execution_command (attach_target, async_exec);
2540 if (non_stop && !attach_target->to_supports_non_stop (attach_target))
2541 error (_("Cannot attach to this target in non-stop mode"));
2543 attach_target->to_attach (attach_target, args, from_tty);
2544 /* to_attach should push the target, so after this point we
2545 shouldn't refer to attach_target again. */
2546 attach_target = NULL;
2548 /* Done with ARGS. */
2549 do_cleanups (args_chain);
2551 /* Set up the "saved terminal modes" of the inferior
2552 based on what modes we are starting it with. */
2553 target_terminal_init ();
2555 /* Install inferior's terminal modes. This may look like a no-op,
2556 as we've just saved them above, however, this does more than
2557 restore terminal settings:
2559 - installs a SIGINT handler that forwards SIGINT to the inferior.
2560 Otherwise a Ctrl-C pressed just while waiting for the initial
2561 stop would end up as a spurious Quit.
2563 - removes stdin from the event loop, which we need if attaching
2564 in the foreground, otherwise on targets that report an initial
2565 stop on attach (which are most) we'd process input/commands
2566 while we're in the event loop waiting for that stop. That is,
2567 before the attach continuation runs and the command is really
2569 target_terminal_inferior ();
2571 /* Set up execution context to know that we should return from
2572 wait_for_inferior as soon as the target reports a stop. */
2573 init_wait_for_inferior ();
2574 clear_proceed_status ();
2578 /* If we find that the current thread isn't stopped, explicitly
2579 do so now, because we're going to install breakpoints and
2583 /* The user requested an `attach&'; stop just one thread. */
2584 target_stop (inferior_ptid);
2586 /* The user requested an `attach', so stop all threads of this
2588 target_stop (pid_to_ptid (ptid_get_pid (inferior_ptid)));
2591 /* Some system don't generate traps when attaching to inferior.
2592 E.g. Mach 3 or GNU hurd. */
2593 if (!target_attach_no_wait)
2595 struct inferior *inferior = current_inferior ();
2597 /* Careful here. See comments in inferior.h. Basically some
2598 OSes don't ignore SIGSTOPs on continue requests anymore. We
2599 need a way for handle_inferior_event to reset the stop_signal
2600 variable after an attach, and this is what
2601 STOP_QUIETLY_NO_SIGSTOP is for. */
2602 inferior->control.stop_soon = STOP_QUIETLY_NO_SIGSTOP;
2604 if (target_can_async_p ())
2606 /* sync_execution mode. Wait for stop. */
2607 struct attach_command_continuation_args *a;
2609 a = xmalloc (sizeof (*a));
2610 a->args = xstrdup (args);
2611 a->from_tty = from_tty;
2612 a->async_exec = async_exec;
2613 add_inferior_continuation (attach_command_continuation, a,
2614 attach_command_continuation_free_args);
2618 wait_for_inferior ();
2621 attach_command_post_wait (args, from_tty, async_exec);
2624 /* We had just found out that the target was already attached to an
2625 inferior. PTID points at a thread of this new inferior, that is
2626 the most likely to be stopped right now, but not necessarily so.
2627 The new inferior is assumed to be already added to the inferior
2628 list at this point. If LEAVE_RUNNING, then leave the threads of
2629 this inferior running, except those we've explicitly seen reported
2633 notice_new_inferior (ptid_t ptid, int leave_running, int from_tty)
2635 struct cleanup* old_chain;
2638 old_chain = make_cleanup (null_cleanup, NULL);
2640 /* If in non-stop, leave threads as running as they were. If
2641 they're stopped for some reason other than us telling it to, the
2642 target reports a signal != GDB_SIGNAL_0. We don't try to
2643 resume threads with such a stop signal. */
2644 async_exec = non_stop;
2646 if (!ptid_equal (inferior_ptid, null_ptid))
2647 make_cleanup_restore_current_thread ();
2649 switch_to_thread (ptid);
2651 /* When we "notice" a new inferior we need to do all the things we
2652 would normally do if we had just attached to it. */
2654 if (is_executing (inferior_ptid))
2656 struct inferior *inferior = current_inferior ();
2658 /* We're going to install breakpoints, and poke at memory,
2659 ensure that the inferior is stopped for a moment while we do
2661 target_stop (inferior_ptid);
2663 inferior->control.stop_soon = STOP_QUIETLY_REMOTE;
2665 /* Wait for stop before proceeding. */
2666 if (target_can_async_p ())
2668 struct attach_command_continuation_args *a;
2670 a = xmalloc (sizeof (*a));
2671 a->args = xstrdup ("");
2672 a->from_tty = from_tty;
2673 a->async_exec = async_exec;
2674 add_inferior_continuation (attach_command_continuation, a,
2675 attach_command_continuation_free_args);
2677 do_cleanups (old_chain);
2681 wait_for_inferior ();
2684 async_exec = leave_running;
2685 attach_command_post_wait ("" /* args */, from_tty, async_exec);
2687 do_cleanups (old_chain);
2692 * takes a program previously attached to and detaches it.
2693 * The program resumes execution and will no longer stop
2694 * on signals, etc. We better not have left any breakpoints
2695 * in the program or it'll die when it hits one. For this
2696 * to work, it may be necessary for the process to have been
2697 * previously attached. It *might* work if the program was
2698 * started via the normal ptrace (PTRACE_TRACEME).
2702 detach_command (char *args, int from_tty)
2704 dont_repeat (); /* Not for the faint of heart. */
2706 if (ptid_equal (inferior_ptid, null_ptid))
2707 error (_("The program is not being run."));
2709 query_if_trace_running (from_tty);
2711 disconnect_tracing ();
2713 target_detach (args, from_tty);
2715 /* If the solist is global across inferiors, don't clear it when we
2716 detach from a single inferior. */
2717 if (!gdbarch_has_global_solist (target_gdbarch ()))
2718 no_shared_libraries (NULL, from_tty);
2720 /* If we still have inferiors to debug, then don't mess with their
2722 if (!have_inferiors ())
2723 init_thread_list ();
2725 if (deprecated_detach_hook)
2726 deprecated_detach_hook ();
2729 /* Disconnect from the current target without resuming it (leaving it
2730 waiting for a debugger).
2732 We'd better not have left any breakpoints in the program or the
2733 next debugger will get confused. Currently only supported for some
2734 remote targets, since the normal attach mechanisms don't work on
2735 stopped processes on some native platforms (e.g. GNU/Linux). */
2738 disconnect_command (char *args, int from_tty)
2740 dont_repeat (); /* Not for the faint of heart. */
2741 query_if_trace_running (from_tty);
2742 disconnect_tracing ();
2743 target_disconnect (args, from_tty);
2744 no_shared_libraries (NULL, from_tty);
2745 init_thread_list ();
2746 if (deprecated_detach_hook)
2747 deprecated_detach_hook ();
2751 interrupt_target_1 (int all_threads)
2756 ptid = minus_one_ptid;
2758 ptid = inferior_ptid;
2761 /* Tag the thread as having been explicitly requested to stop, so
2762 other parts of gdb know not to resume this thread automatically,
2763 if it was stopped due to an internal event. Limit this to
2764 non-stop mode, as when debugging a multi-threaded application in
2765 all-stop mode, we will only get one stop event --- it's undefined
2766 which thread will report the event. */
2768 set_stop_requested (ptid, 1);
2772 Stop the execution of the target while running in async mode, in
2773 the backgound. In all-stop, stop the whole process. In non-stop
2774 mode, stop the current thread only by default, or stop all threads
2775 if the `-a' switch is used. */
2778 interrupt_command (char *args, int from_tty)
2780 if (target_can_async_p ())
2782 int all_threads = 0;
2784 dont_repeat (); /* Not for the faint of heart. */
2787 && strncmp (args, "-a", sizeof ("-a") - 1) == 0)
2790 if (!non_stop && all_threads)
2791 error (_("-a is meaningless in all-stop mode."));
2793 interrupt_target_1 (all_threads);
2798 print_float_info (struct ui_file *file,
2799 struct frame_info *frame, const char *args)
2801 struct gdbarch *gdbarch = get_frame_arch (frame);
2803 if (gdbarch_print_float_info_p (gdbarch))
2804 gdbarch_print_float_info (gdbarch, file, frame, args);
2808 int printed_something = 0;
2811 regnum < gdbarch_num_regs (gdbarch)
2812 + gdbarch_num_pseudo_regs (gdbarch);
2815 if (gdbarch_register_reggroup_p (gdbarch, regnum, float_reggroup))
2817 printed_something = 1;
2818 gdbarch_print_registers_info (gdbarch, file, frame, regnum, 1);
2821 if (!printed_something)
2822 fprintf_filtered (file, "No floating-point info "
2823 "available for this processor.\n");
2828 float_info (char *args, int from_tty)
2830 if (!target_has_registers)
2831 error (_("The program has no registers now."));
2833 print_float_info (gdb_stdout, get_selected_frame (NULL), args);
2837 unset_command (char *args, int from_tty)
2839 printf_filtered (_("\"unset\" must be followed by the "
2840 "name of an unset subcommand.\n"));
2841 help_list (unsetlist, "unset ", -1, gdb_stdout);
2844 /* Implement `info proc' family of commands. */
2847 info_proc_cmd_1 (char *args, enum info_proc_what what, int from_tty)
2849 struct gdbarch *gdbarch = get_current_arch ();
2851 if (!target_info_proc (args, what))
2853 if (gdbarch_info_proc_p (gdbarch))
2854 gdbarch_info_proc (gdbarch, args, what);
2856 error (_("Not supported on this target."));
2860 /* Implement `info proc' when given without any futher parameters. */
2863 info_proc_cmd (char *args, int from_tty)
2865 info_proc_cmd_1 (args, IP_MINIMAL, from_tty);
2868 /* Implement `info proc mappings'. */
2871 info_proc_cmd_mappings (char *args, int from_tty)
2873 info_proc_cmd_1 (args, IP_MAPPINGS, from_tty);
2876 /* Implement `info proc stat'. */
2879 info_proc_cmd_stat (char *args, int from_tty)
2881 info_proc_cmd_1 (args, IP_STAT, from_tty);
2884 /* Implement `info proc status'. */
2887 info_proc_cmd_status (char *args, int from_tty)
2889 info_proc_cmd_1 (args, IP_STATUS, from_tty);
2892 /* Implement `info proc cwd'. */
2895 info_proc_cmd_cwd (char *args, int from_tty)
2897 info_proc_cmd_1 (args, IP_CWD, from_tty);
2900 /* Implement `info proc cmdline'. */
2903 info_proc_cmd_cmdline (char *args, int from_tty)
2905 info_proc_cmd_1 (args, IP_CMDLINE, from_tty);
2908 /* Implement `info proc exe'. */
2911 info_proc_cmd_exe (char *args, int from_tty)
2913 info_proc_cmd_1 (args, IP_EXE, from_tty);
2916 /* Implement `info proc all'. */
2919 info_proc_cmd_all (char *args, int from_tty)
2921 info_proc_cmd_1 (args, IP_ALL, from_tty);
2925 _initialize_infcmd (void)
2927 static struct cmd_list_element *info_proc_cmdlist;
2928 struct cmd_list_element *c = NULL;
2929 const char *cmd_name;
2931 /* Add the filename of the terminal connected to inferior I/O. */
2932 add_setshow_filename_cmd ("inferior-tty", class_run,
2933 &inferior_io_terminal_scratch, _("\
2934 Set terminal for future runs of program being debugged."), _("\
2935 Show terminal for future runs of program being debugged."), _("\
2936 Usage: set inferior-tty /dev/pts/1"),
2937 set_inferior_tty_command,
2938 show_inferior_tty_command,
2939 &setlist, &showlist);
2940 add_com_alias ("tty", "set inferior-tty", class_alias, 0);
2943 add_setshow_string_noescape_cmd (cmd_name, class_run,
2944 &inferior_args_scratch, _("\
2945 Set argument list to give program being debugged when it is started."), _("\
2946 Show argument list to give program being debugged when it is started."), _("\
2947 Follow this command with any number of args, to be passed to the program."),
2950 &setlist, &showlist);
2951 c = lookup_cmd (&cmd_name, setlist, "", -1, 1);
2952 gdb_assert (c != NULL);
2953 set_cmd_completer (c, filename_completer);
2955 c = add_cmd ("environment", no_class, environment_info, _("\
2956 The environment to give the program, or one variable's value.\n\
2957 With an argument VAR, prints the value of environment variable VAR to\n\
2958 give the program being debugged. With no arguments, prints the entire\n\
2959 environment to be given to the program."), &showlist);
2960 set_cmd_completer (c, noop_completer);
2962 add_prefix_cmd ("unset", no_class, unset_command,
2963 _("Complement to certain \"set\" commands."),
2964 &unsetlist, "unset ", 0, &cmdlist);
2966 c = add_cmd ("environment", class_run, unset_environment_command, _("\
2967 Cancel environment variable VAR for the program.\n\
2968 This does not affect the program until the next \"run\" command."),
2970 set_cmd_completer (c, noop_completer);
2972 c = add_cmd ("environment", class_run, set_environment_command, _("\
2973 Set environment variable value to give the program.\n\
2974 Arguments are VAR VALUE where VAR is variable name and VALUE is value.\n\
2975 VALUES of environment variables are uninterpreted strings.\n\
2976 This does not affect the program until the next \"run\" command."),
2978 set_cmd_completer (c, noop_completer);
2980 c = add_com ("path", class_files, path_command, _("\
2981 Add directory DIR(s) to beginning of search path for object files.\n\
2982 $cwd in the path means the current working directory.\n\
2983 This path is equivalent to the $PATH shell variable. It is a list of\n\
2984 directories, separated by colons. These directories are searched to find\n\
2985 fully linked executable files and separately compiled object files as \
2987 set_cmd_completer (c, filename_completer);
2989 c = add_cmd ("paths", no_class, path_info, _("\
2990 Current search path for finding object files.\n\
2991 $cwd in the path means the current working directory.\n\
2992 This path is equivalent to the $PATH shell variable. It is a list of\n\
2993 directories, separated by colons. These directories are searched to find\n\
2994 fully linked executable files and separately compiled object files as \
2997 set_cmd_completer (c, noop_completer);
2999 add_prefix_cmd ("kill", class_run, kill_command,
3000 _("Kill execution of program being debugged."),
3001 &killlist, "kill ", 0, &cmdlist);
3003 add_com ("attach", class_run, attach_command, _("\
3004 Attach to a process or file outside of GDB.\n\
3005 This command attaches to another target, of the same type as your last\n\
3006 \"target\" command (\"info files\" will show your target stack).\n\
3007 The command may take as argument a process id or a device file.\n\
3008 For a process id, you must have permission to send the process a signal,\n\
3009 and it must have the same effective uid as the debugger.\n\
3010 When using \"attach\" with a process id, the debugger finds the\n\
3011 program running in the process, looking first in the current working\n\
3012 directory, or (if not found there) using the source file search path\n\
3013 (see the \"directory\" command). You can also use the \"file\" command\n\
3014 to specify the program, and to load its symbol table."));
3016 add_prefix_cmd ("detach", class_run, detach_command, _("\
3017 Detach a process or file previously attached.\n\
3018 If a process, it is no longer traced, and it continues its execution. If\n\
3019 you were debugging a file, the file is closed and gdb no longer accesses it."),
3020 &detachlist, "detach ", 0, &cmdlist);
3022 add_com ("disconnect", class_run, disconnect_command, _("\
3023 Disconnect from a target.\n\
3024 The target will wait for another debugger to connect. Not available for\n\
3027 c = add_com ("signal", class_run, signal_command, _("\
3028 Continue program with the specified signal.\n\
3029 Usage: signal SIGNAL\n\
3030 The SIGNAL argument is processed the same as the handle command.\n\
3032 An argument of \"0\" means continue the program without sending it a signal.\n\
3033 This is useful in cases where the program stopped because of a signal,\n\
3034 and you want to resume the program while discarding the signal."));
3035 set_cmd_completer (c, signal_completer);
3037 add_com ("stepi", class_run, stepi_command, _("\
3038 Step one instruction exactly.\n\
3040 Argument N means step N times (or till program stops for another \
3042 add_com_alias ("si", "stepi", class_alias, 0);
3044 add_com ("nexti", class_run, nexti_command, _("\
3045 Step one instruction, but proceed through subroutine calls.\n\
3047 Argument N means step N times (or till program stops for another \
3049 add_com_alias ("ni", "nexti", class_alias, 0);
3051 add_com ("finish", class_run, finish_command, _("\
3052 Execute until selected stack frame returns.\n\
3054 Upon return, the value returned is printed and put in the value history."));
3055 add_com_alias ("fin", "finish", class_run, 1);
3057 add_com ("next", class_run, next_command, _("\
3058 Step program, proceeding through subroutine calls.\n\
3060 Unlike \"step\", if the current source line calls a subroutine,\n\
3061 this command does not enter the subroutine, but instead steps over\n\
3062 the call, in effect treating it as a single source line."));
3063 add_com_alias ("n", "next", class_run, 1);
3065 add_com_alias ("S", "next", class_run, 1);
3067 add_com ("step", class_run, step_command, _("\
3068 Step program until it reaches a different source line.\n\
3070 Argument N means step N times (or till program stops for another \
3072 add_com_alias ("s", "step", class_run, 1);
3074 c = add_com ("until", class_run, until_command, _("\
3075 Execute until the program reaches a source line greater than the current\n\
3076 or a specified location (same args as break command) within the current \
3078 set_cmd_completer (c, location_completer);
3079 add_com_alias ("u", "until", class_run, 1);
3081 c = add_com ("advance", class_run, advance_command, _("\
3082 Continue the program up to the given location (same form as args for break \
3084 Execution will also stop upon exit from the current stack frame."));
3085 set_cmd_completer (c, location_completer);
3087 c = add_com ("jump", class_run, jump_command, _("\
3088 Continue program being debugged at specified line or address.\n\
3089 Usage: jump <location>\n\
3090 Give as argument either LINENUM or *ADDR, where ADDR is an expression\n\
3091 for an address to start at."));
3092 set_cmd_completer (c, location_completer);
3093 add_com_alias ("j", "jump", class_run, 1);
3097 c = add_com ("go", class_run, go_command, _("\
3098 Usage: go <location>\n\
3099 Continue program being debugged, stopping at specified line or \n\
3101 Give as argument either LINENUM or *ADDR, where ADDR is an \n\
3102 expression for an address to start at.\n\
3103 This command is a combination of tbreak and jump."));
3104 set_cmd_completer (c, location_completer);
3108 add_com_alias ("g", "go", class_run, 1);
3110 add_com ("continue", class_run, continue_command, _("\
3111 Continue program being debugged, after signal or breakpoint.\n\
3112 Usage: continue [N]\n\
3113 If proceeding from breakpoint, a number N may be used as an argument,\n\
3114 which means to set the ignore count of that breakpoint to N - 1 (so that\n\
3115 the breakpoint won't break until the Nth time it is reached).\n\
3117 If non-stop mode is enabled, continue only the current thread,\n\
3118 otherwise all the threads in the program are continued. To \n\
3119 continue all stopped threads in non-stop mode, use the -a option.\n\
3120 Specifying -a and an ignore count simultaneously is an error."));
3121 add_com_alias ("c", "cont", class_run, 1);
3122 add_com_alias ("fg", "cont", class_run, 1);
3124 c = add_com ("run", class_run, run_command, _("\
3125 Start debugged program. You may specify arguments to give it.\n\
3126 Args may include \"*\", or \"[...]\"; they are expanded using \"sh\".\n\
3127 Input and output redirection with \">\", \"<\", or \">>\" are also \
3129 With no arguments, uses arguments last specified (with \"run\" \
3130 or \"set args\").\n\
3131 To cancel previous arguments and run with no arguments,\n\
3132 use \"set args\" without arguments."));
3133 set_cmd_completer (c, filename_completer);
3134 add_com_alias ("r", "run", class_run, 1);
3136 add_com ("R", class_run, run_no_args_command,
3137 _("Start debugged program with no arguments."));
3139 c = add_com ("start", class_run, start_command, _("\
3140 Run the debugged program until the beginning of the main procedure.\n\
3141 You may specify arguments to give to your program, just as with the\n\
3142 \"run\" command."));
3143 set_cmd_completer (c, filename_completer);
3145 add_com ("interrupt", class_run, interrupt_command,
3146 _("Interrupt the execution of the debugged program.\n\
3147 If non-stop mode is enabled, interrupt only the current thread,\n\
3148 otherwise all the threads in the program are stopped. To \n\
3149 interrupt all running threads in non-stop mode, use the -a option."));
3151 add_info ("registers", nofp_registers_info, _("\
3152 List of integer registers and their contents, for selected stack frame.\n\
3153 Register name as argument means describe only that register."));
3154 add_info_alias ("r", "registers", 1);
3157 add_com ("lr", class_info, nofp_registers_info, _("\
3158 List of integer registers and their contents, for selected stack frame.\n\
3159 Register name as argument means describe only that register."));
3160 add_info ("all-registers", all_registers_info, _("\
3161 List of all registers and their contents, for selected stack frame.\n\
3162 Register name as argument means describe only that register."));
3164 add_info ("program", program_info,
3165 _("Execution status of the program."));
3167 add_info ("float", float_info,
3168 _("Print the status of the floating point unit\n"));
3170 add_info ("vector", vector_info,
3171 _("Print the status of the vector unit\n"));
3173 add_prefix_cmd ("proc", class_info, info_proc_cmd,
3175 Show /proc process information about any running process.\n\
3176 Specify any process id, or use the program being debugged by default."),
3177 &info_proc_cmdlist, "info proc ",
3178 1/*allow-unknown*/, &infolist);
3180 add_cmd ("mappings", class_info, info_proc_cmd_mappings, _("\
3181 List of mapped memory regions."),
3182 &info_proc_cmdlist);
3184 add_cmd ("stat", class_info, info_proc_cmd_stat, _("\
3185 List process info from /proc/PID/stat."),
3186 &info_proc_cmdlist);
3188 add_cmd ("status", class_info, info_proc_cmd_status, _("\
3189 List process info from /proc/PID/status."),
3190 &info_proc_cmdlist);
3192 add_cmd ("cwd", class_info, info_proc_cmd_cwd, _("\
3193 List current working directory of the process."),
3194 &info_proc_cmdlist);
3196 add_cmd ("cmdline", class_info, info_proc_cmd_cmdline, _("\
3197 List command line arguments of the process."),
3198 &info_proc_cmdlist);
3200 add_cmd ("exe", class_info, info_proc_cmd_exe, _("\
3201 List absolute filename for executable of the process."),
3202 &info_proc_cmdlist);
3204 add_cmd ("all", class_info, info_proc_cmd_all, _("\
3205 List all available /proc info."),
3206 &info_proc_cmdlist);