1 /* Memory-access and commands for "inferior" process, for GDB.
3 Copyright (C) 1986-2015 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 /* Local functions: */
60 static void nofp_registers_info (char *, int);
62 static void print_return_value (struct value
*function
,
63 struct type
*value_type
);
65 static void until_next_command (int);
67 static void until_command (char *, int);
69 static void path_info (char *, int);
71 static void path_command (char *, int);
73 static void unset_command (char *, int);
75 static void float_info (char *, int);
77 static void disconnect_command (char *, int);
79 static void unset_environment_command (char *, int);
81 static void set_environment_command (char *, int);
83 static void environment_info (char *, int);
85 static void program_info (char *, int);
87 static void finish_command (char *, int);
89 static void signal_command (char *, int);
91 static void jump_command (char *, int);
93 static void step_1 (int, int, char *);
94 static void step_once (int skip_subroutines
, int single_inst
,
95 int count
, int thread
);
97 static void next_command (char *, int);
99 static void step_command (char *, int);
101 static void run_command (char *, int);
103 static void run_no_args_command (char *args
, int from_tty
);
105 static void go_command (char *line_no
, int from_tty
);
107 void _initialize_infcmd (void);
109 #define ERROR_NO_INFERIOR \
110 if (!target_has_execution) error (_("The program is not being run."));
112 /* Scratch area where string containing arguments to give to the
113 program will be stored by 'set args'. As soon as anything is
114 stored, notice_args_set will move it into per-inferior storage.
115 Arguments are separated by spaces. Empty string (pointer to '\0')
118 static char *inferior_args_scratch
;
120 /* Scratch area where 'set inferior-tty' will store user-provided value.
121 We'll immediate copy it into per-inferior storage. */
123 static char *inferior_io_terminal_scratch
;
125 /* Pid of our debugged inferior, or 0 if no inferior now.
126 Since various parts of infrun.c test this to see whether there is a program
127 being debugged it should be nonzero (currently 3 is used) for remote
130 ptid_t inferior_ptid
;
132 /* Address at which inferior stopped. */
136 /* Nonzero if stopped due to completion of a stack dummy routine. */
138 enum stop_stack_kind stop_stack_dummy
;
140 /* Nonzero if stopped due to a random (unexpected) signal in inferior
143 int stopped_by_random_signal
;
145 /* See inferior.h. */
147 int startup_with_shell
= 1;
150 /* Accessor routines. */
152 /* Set the io terminal for the current inferior. Ownership of
153 TERMINAL_NAME is not transferred. */
156 set_inferior_io_terminal (const char *terminal_name
)
158 xfree (current_inferior ()->terminal
);
159 current_inferior ()->terminal
= terminal_name
? xstrdup (terminal_name
) : 0;
163 get_inferior_io_terminal (void)
165 return current_inferior ()->terminal
;
169 set_inferior_tty_command (char *args
, int from_tty
,
170 struct cmd_list_element
*c
)
172 /* CLI has assigned the user-provided value to inferior_io_terminal_scratch.
173 Now route it to current inferior. */
174 set_inferior_io_terminal (inferior_io_terminal_scratch
);
178 show_inferior_tty_command (struct ui_file
*file
, int from_tty
,
179 struct cmd_list_element
*c
, const char *value
)
181 /* Note that we ignore the passed-in value in favor of computing it
183 const char *inferior_io_terminal
= get_inferior_io_terminal ();
185 if (inferior_io_terminal
== NULL
)
186 inferior_io_terminal
= "";
187 fprintf_filtered (gdb_stdout
,
188 _("Terminal for future runs of program being debugged "
189 "is \"%s\".\n"), inferior_io_terminal
);
193 get_inferior_args (void)
195 if (current_inferior ()->argc
!= 0)
199 n
= construct_inferior_arguments (current_inferior ()->argc
,
200 current_inferior ()->argv
);
201 set_inferior_args (n
);
205 if (current_inferior ()->args
== NULL
)
206 current_inferior ()->args
= xstrdup ("");
208 return current_inferior ()->args
;
211 /* Set the arguments for the current inferior. Ownership of
212 NEWARGS is not transferred. */
215 set_inferior_args (char *newargs
)
217 xfree (current_inferior ()->args
);
218 current_inferior ()->args
= newargs
? xstrdup (newargs
) : NULL
;
219 current_inferior ()->argc
= 0;
220 current_inferior ()->argv
= 0;
224 set_inferior_args_vector (int argc
, char **argv
)
226 current_inferior ()->argc
= argc
;
227 current_inferior ()->argv
= argv
;
230 /* Notice when `set args' is run. */
233 set_args_command (char *args
, int from_tty
, struct cmd_list_element
*c
)
235 /* CLI has assigned the user-provided value to inferior_args_scratch.
236 Now route it to current inferior. */
237 set_inferior_args (inferior_args_scratch
);
240 /* Notice when `show args' is run. */
243 show_args_command (struct ui_file
*file
, int from_tty
,
244 struct cmd_list_element
*c
, const char *value
)
246 /* Note that we ignore the passed-in value in favor of computing it
248 deprecated_show_value_hack (file
, from_tty
, c
, get_inferior_args ());
252 /* Compute command-line string given argument vector. This does the
253 same shell processing as fork_inferior. */
256 construct_inferior_arguments (int argc
, char **argv
)
260 if (startup_with_shell
)
263 /* This holds all the characters considered special to the
265 char *special
= "\"!&*|[]{}<>?`~^=;, \t\n";
266 const char quote
= '"';
268 /* This holds all the characters considered special to the
269 typical Unix shells. We include `^' because the SunOS
270 /bin/sh treats it as a synonym for `|'. */
271 char *special
= "\"!#$&*()\\|[]{}<>?'`~^; \t\n";
272 const char quote
= '\'';
278 /* We over-compute the size. It shouldn't matter. */
279 for (i
= 0; i
< argc
; ++i
)
280 length
+= 3 * strlen (argv
[i
]) + 1 + 2 * (argv
[i
][0] == '\0');
282 result
= (char *) xmalloc (length
);
285 for (i
= 0; i
< argc
; ++i
)
290 /* Need to handle empty arguments specially. */
291 if (argv
[i
][0] == '\0')
301 if (strpbrk (argv
[i
], special
))
307 for (cp
= argv
[i
]; *cp
; ++cp
)
311 /* A newline cannot be quoted with a backslash (it
312 just disappears), only by putting it inside
323 if (strchr (special
, *cp
) != NULL
)
339 /* In this case we can't handle arguments that contain spaces,
340 tabs, or newlines -- see breakup_args(). */
344 for (i
= 0; i
< argc
; ++i
)
346 char *cp
= strchr (argv
[i
], ' ');
348 cp
= strchr (argv
[i
], '\t');
350 cp
= strchr (argv
[i
], '\n');
352 error (_("can't handle command-line "
353 "argument containing whitespace"));
354 length
+= strlen (argv
[i
]) + 1;
357 result
= (char *) xmalloc (length
);
359 for (i
= 0; i
< argc
; ++i
)
362 strcat (result
, " ");
363 strcat (result
, argv
[i
]);
371 /* This function strips the '&' character (indicating background
372 execution) that is added as *the last* of the arguments ARGS of a
373 command. A copy of the incoming ARGS without the '&' is returned,
374 unless the resulting string after stripping is empty, in which case
375 NULL is returned. *BG_CHAR_P is an output boolean that indicates
376 whether the '&' character was found. */
379 strip_bg_char (const char *args
, int *bg_char_p
)
383 if (args
== NULL
|| *args
== '\0')
389 p
= args
+ strlen (args
);
393 while (p
> args
&& isspace (p
[-1]))
398 return savestring (args
, p
- args
);
404 return xstrdup (args
);
407 /* Common actions to take after creating any sort of inferior, by any
408 means (running, attaching, connecting, et cetera). The target
409 should be stopped. */
412 post_create_inferior (struct target_ops
*target
, int from_tty
)
414 volatile struct gdb_exception ex
;
416 /* Be sure we own the terminal in case write operations are performed. */
417 target_terminal_ours ();
419 /* If the target hasn't taken care of this already, do it now.
420 Targets which need to access registers during to_open,
421 to_create_inferior, or to_attach should do it earlier; but many
423 target_find_description ();
425 /* Now that we know the register layout, retrieve current PC. But
426 if the PC is unavailable (e.g., we're opening a core file with
427 missing registers info), ignore it. */
429 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
431 stop_pc
= regcache_read_pc (get_current_regcache ());
435 if (ex
.error
!= NOT_AVAILABLE_ERROR
)
436 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 (0);
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 (0);
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 (startswith (args
, "-a"))
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 (!skip_subroutines
);
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 struct obj_section
*section
;
1207 fixup_symbol_section (sfn
, 0);
1208 section
= SYMBOL_OBJ_SECTION (symbol_objfile (sfn
), sfn
);
1209 if (section_is_overlay (section
)
1210 && !section_is_mapped (section
))
1212 if (!query (_("WARNING!!! Destination is in "
1213 "unmapped overlay! Jump anyway? ")))
1215 error (_("Not confirmed."));
1225 printf_filtered (_("Continuing at "));
1226 fputs_filtered (paddress (gdbarch
, addr
), gdb_stdout
);
1227 printf_filtered (".\n");
1230 clear_proceed_status (0);
1231 proceed (addr
, GDB_SIGNAL_0
, 0);
1235 /* Go to line or address in current procedure. */
1238 go_command (char *line_no
, int from_tty
)
1240 if (line_no
== (char *) NULL
|| !*line_no
)
1241 printf_filtered (_("Usage: go <location>\n"));
1244 tbreak_command (line_no
, from_tty
);
1245 jump_command (line_no
, from_tty
);
1250 /* Continue program giving it specified signal. */
1253 signal_command (char *signum_exp
, int from_tty
)
1255 enum gdb_signal oursig
;
1257 struct cleanup
*args_chain
;
1259 dont_repeat (); /* Too dangerous. */
1261 ensure_not_tfind_mode ();
1262 ensure_valid_thread ();
1263 ensure_not_running ();
1265 /* Find out whether we must run in the background. */
1266 signum_exp
= strip_bg_char (signum_exp
, &async_exec
);
1267 args_chain
= make_cleanup (xfree
, signum_exp
);
1269 prepare_execution_command (¤t_target
, async_exec
);
1272 error_no_arg (_("signal number"));
1274 /* It would be even slicker to make signal names be valid expressions,
1275 (the type could be "enum $signal" or some such), then the user could
1276 assign them to convenience variables. */
1277 oursig
= gdb_signal_from_name (signum_exp
);
1279 if (oursig
== GDB_SIGNAL_UNKNOWN
)
1281 /* No, try numeric. */
1282 int num
= parse_and_eval_long (signum_exp
);
1285 oursig
= GDB_SIGNAL_0
;
1287 oursig
= gdb_signal_from_command (num
);
1290 /* Look for threads other than the current that this command ends up
1291 resuming too (due to schedlock off), and warn if they'll get a
1292 signal delivered. "signal 0" is used to suppress a previous
1293 signal, but if the current thread is no longer the one that got
1294 the signal, then the user is potentially suppressing the signal
1295 of the wrong thread. */
1298 struct thread_info
*tp
;
1300 int must_confirm
= 0;
1302 /* This indicates what will be resumed. Either a single thread,
1303 a whole process, or all threads of all processes. */
1304 resume_ptid
= user_visible_resume_ptid (0);
1306 ALL_NON_EXITED_THREADS (tp
)
1308 if (ptid_equal (tp
->ptid
, inferior_ptid
))
1310 if (!ptid_match (tp
->ptid
, resume_ptid
))
1313 if (tp
->suspend
.stop_signal
!= GDB_SIGNAL_0
1314 && signal_pass_state (tp
->suspend
.stop_signal
))
1317 printf_unfiltered (_("Note:\n"));
1318 printf_unfiltered (_(" Thread %d previously stopped with signal %s, %s.\n"),
1320 gdb_signal_to_name (tp
->suspend
.stop_signal
),
1321 gdb_signal_to_string (tp
->suspend
.stop_signal
));
1327 && !query (_("Continuing thread %d (the current thread) with specified signal will\n"
1328 "still deliver the signals noted above to their respective threads.\n"
1329 "Continue anyway? "),
1330 inferior_thread ()->num
))
1331 error (_("Not confirmed."));
1336 if (oursig
== GDB_SIGNAL_0
)
1337 printf_filtered (_("Continuing with no signal.\n"));
1339 printf_filtered (_("Continuing with signal %s.\n"),
1340 gdb_signal_to_name (oursig
));
1343 clear_proceed_status (0);
1344 proceed ((CORE_ADDR
) -1, oursig
, 0);
1347 /* Queue a signal to be delivered to the current thread. */
1350 queue_signal_command (char *signum_exp
, int from_tty
)
1352 enum gdb_signal oursig
;
1353 struct thread_info
*tp
;
1356 ensure_not_tfind_mode ();
1357 ensure_valid_thread ();
1358 ensure_not_running ();
1360 if (signum_exp
== NULL
)
1361 error_no_arg (_("signal number"));
1363 /* It would be even slicker to make signal names be valid expressions,
1364 (the type could be "enum $signal" or some such), then the user could
1365 assign them to convenience variables. */
1366 oursig
= gdb_signal_from_name (signum_exp
);
1368 if (oursig
== GDB_SIGNAL_UNKNOWN
)
1370 /* No, try numeric. */
1371 int num
= parse_and_eval_long (signum_exp
);
1374 oursig
= GDB_SIGNAL_0
;
1376 oursig
= gdb_signal_from_command (num
);
1379 if (oursig
!= GDB_SIGNAL_0
1380 && !signal_pass_state (oursig
))
1381 error (_("Signal handling set to not pass this signal to the program."));
1383 tp
= inferior_thread ();
1384 tp
->suspend
.stop_signal
= oursig
;
1387 /* Continuation args to be passed to the "until" command
1389 struct until_next_continuation_args
1391 /* The thread that was current when the command was executed. */
1395 /* A continuation callback for until_next_command. */
1398 until_next_continuation (void *arg
, int err
)
1400 struct until_next_continuation_args
*a
= arg
;
1402 delete_longjmp_breakpoint (a
->thread
);
1405 /* Proceed until we reach a different source line with pc greater than
1406 our current one or exit the function. We skip calls in both cases.
1408 Note that eventually this command should probably be changed so
1409 that only source lines are printed out when we hit the breakpoint
1410 we set. This may involve changes to wait_for_inferior and the
1411 proceed status code. */
1414 until_next_command (int from_tty
)
1416 struct frame_info
*frame
;
1418 struct symbol
*func
;
1419 struct symtab_and_line sal
;
1420 struct thread_info
*tp
= inferior_thread ();
1421 int thread
= tp
->num
;
1422 struct cleanup
*old_chain
;
1424 clear_proceed_status (0);
1427 frame
= get_current_frame ();
1429 /* Step until either exited from this function or greater
1430 than the current line (if in symbolic section) or pc (if
1433 pc
= get_frame_pc (frame
);
1434 func
= find_pc_function (pc
);
1438 struct bound_minimal_symbol msymbol
= lookup_minimal_symbol_by_pc (pc
);
1440 if (msymbol
.minsym
== NULL
)
1441 error (_("Execution is not within a known function."));
1443 tp
->control
.step_range_start
= BMSYMBOL_VALUE_ADDRESS (msymbol
);
1444 /* The upper-bound of step_range is exclusive. In order to make PC
1445 within the range, set the step_range_end with PC + 1. */
1446 tp
->control
.step_range_end
= pc
+ 1;
1450 sal
= find_pc_line (pc
, 0);
1452 tp
->control
.step_range_start
= BLOCK_START (SYMBOL_BLOCK_VALUE (func
));
1453 tp
->control
.step_range_end
= sal
.end
;
1455 tp
->control
.may_range_step
= 1;
1457 tp
->control
.step_over_calls
= STEP_OVER_ALL
;
1459 tp
->step_multi
= 0; /* Only one call to proceed */
1461 set_longjmp_breakpoint (tp
, get_frame_id (frame
));
1462 old_chain
= make_cleanup (delete_longjmp_breakpoint_cleanup
, &thread
);
1464 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
, 1);
1466 if (target_can_async_p () && is_running (inferior_ptid
))
1468 struct until_next_continuation_args
*cont_args
;
1470 discard_cleanups (old_chain
);
1471 cont_args
= XNEW (struct until_next_continuation_args
);
1472 cont_args
->thread
= inferior_thread ()->num
;
1474 add_continuation (tp
, until_next_continuation
, cont_args
, xfree
);
1477 do_cleanups (old_chain
);
1481 until_command (char *arg
, int from_tty
)
1484 struct cleanup
*args_chain
;
1487 ensure_not_tfind_mode ();
1488 ensure_valid_thread ();
1489 ensure_not_running ();
1491 /* Find out whether we must run in the background. */
1492 arg
= strip_bg_char (arg
, &async_exec
);
1493 args_chain
= make_cleanup (xfree
, arg
);
1495 prepare_execution_command (¤t_target
, async_exec
);
1498 until_break_command (arg
, from_tty
, 0);
1500 until_next_command (from_tty
);
1502 /* Done with ARGS. */
1503 do_cleanups (args_chain
);
1507 advance_command (char *arg
, int from_tty
)
1510 struct cleanup
*args_chain
;
1513 ensure_not_tfind_mode ();
1514 ensure_valid_thread ();
1515 ensure_not_running ();
1518 error_no_arg (_("a location"));
1520 /* Find out whether we must run in the background. */
1521 arg
= strip_bg_char (arg
, &async_exec
);
1522 args_chain
= make_cleanup (xfree
, arg
);
1524 prepare_execution_command (¤t_target
, async_exec
);
1526 until_break_command (arg
, from_tty
, 1);
1528 /* Done with ARGS. */
1529 do_cleanups (args_chain
);
1532 /* Return the value of the result of a function at the end of a 'finish'
1536 get_return_value (struct value
*function
, struct type
*value_type
)
1538 struct regcache
*stop_regs
= stop_registers
;
1539 struct gdbarch
*gdbarch
;
1540 struct value
*value
;
1541 struct cleanup
*cleanup
= make_cleanup (null_cleanup
, NULL
);
1543 /* If stop_registers were not saved, use the current registers. */
1546 stop_regs
= regcache_dup (get_current_regcache ());
1547 make_cleanup_regcache_xfree (stop_regs
);
1550 gdbarch
= get_regcache_arch (stop_regs
);
1552 CHECK_TYPEDEF (value_type
);
1553 gdb_assert (TYPE_CODE (value_type
) != TYPE_CODE_VOID
);
1555 /* FIXME: 2003-09-27: When returning from a nested inferior function
1556 call, it's possible (with no help from the architecture vector)
1557 to locate and return/print a "struct return" value. This is just
1558 a more complicated case of what is already being done in the
1559 inferior function call code. In fact, when inferior function
1560 calls are made async, this will likely be made the norm. */
1562 switch (gdbarch_return_value (gdbarch
, function
, value_type
,
1565 case RETURN_VALUE_REGISTER_CONVENTION
:
1566 case RETURN_VALUE_ABI_RETURNS_ADDRESS
:
1567 case RETURN_VALUE_ABI_PRESERVES_ADDRESS
:
1568 value
= allocate_value (value_type
);
1569 gdbarch_return_value (gdbarch
, function
, value_type
, stop_regs
,
1570 value_contents_raw (value
), NULL
);
1572 case RETURN_VALUE_STRUCT_CONVENTION
:
1576 internal_error (__FILE__
, __LINE__
, _("bad switch"));
1579 do_cleanups (cleanup
);
1584 /* Print the result of a function at the end of a 'finish' command. */
1587 print_return_value (struct value
*function
, struct type
*value_type
)
1589 struct value
*value
= get_return_value (function
, value_type
);
1590 struct ui_out
*uiout
= current_uiout
;
1594 struct value_print_options opts
;
1595 struct ui_file
*stb
;
1596 struct cleanup
*old_chain
;
1599 stb
= mem_fileopen ();
1600 old_chain
= make_cleanup_ui_file_delete (stb
);
1601 ui_out_text (uiout
, "Value returned is ");
1602 ui_out_field_fmt (uiout
, "gdb-result-var", "$%d",
1603 record_latest_value (value
));
1604 ui_out_text (uiout
, " = ");
1605 get_no_prettyformat_print_options (&opts
);
1606 value_print (value
, stb
, &opts
);
1607 ui_out_field_stream (uiout
, "return-value", stb
);
1608 ui_out_text (uiout
, "\n");
1609 do_cleanups (old_chain
);
1613 struct cleanup
*oldchain
;
1616 type_name
= type_to_string (value_type
);
1617 oldchain
= make_cleanup (xfree
, type_name
);
1618 ui_out_text (uiout
, "Value returned has type: ");
1619 ui_out_field_string (uiout
, "return-type", type_name
);
1620 ui_out_text (uiout
, ".");
1621 ui_out_text (uiout
, " Cannot determine contents\n");
1622 do_cleanups (oldchain
);
1626 /* Stuff that needs to be done by the finish command after the target
1627 has stopped. In asynchronous mode, we wait for the target to stop
1628 in the call to poll or select in the event loop, so it is
1629 impossible to do all the stuff as part of the finish_command
1630 function itself. The only chance we have to complete this command
1631 is in fetch_inferior_event, which is called by the event loop as
1632 soon as it detects that the target has stopped. */
1634 struct finish_command_continuation_args
1636 /* The thread that as current when the command was executed. */
1638 struct breakpoint
*breakpoint
;
1639 struct symbol
*function
;
1643 finish_command_continuation (void *arg
, int err
)
1645 struct finish_command_continuation_args
*a
= arg
;
1649 struct thread_info
*tp
= NULL
;
1652 if (!ptid_equal (inferior_ptid
, null_ptid
)
1653 && target_has_execution
1654 && is_stopped (inferior_ptid
))
1656 tp
= inferior_thread ();
1657 bs
= tp
->control
.stop_bpstat
;
1660 if (bpstat_find_breakpoint (bs
, a
->breakpoint
) != NULL
1661 && a
->function
!= NULL
)
1663 struct type
*value_type
;
1665 value_type
= TYPE_TARGET_TYPE (SYMBOL_TYPE (a
->function
));
1667 internal_error (__FILE__
, __LINE__
,
1668 _("finish_command: function has no target type"));
1670 if (TYPE_CODE (value_type
) != TYPE_CODE_VOID
)
1672 volatile struct gdb_exception ex
;
1675 func
= read_var_value (a
->function
, get_current_frame ());
1676 TRY_CATCH (ex
, RETURN_MASK_ALL
)
1678 /* print_return_value can throw an exception in some
1679 circumstances. We need to catch this so that we still
1680 delete the breakpoint. */
1681 print_return_value (func
, value_type
);
1684 exception_print (gdb_stdout
, ex
);
1688 /* We suppress normal call of normal_stop observer and do it
1689 here so that the *stopped notification includes the return
1691 if (bs
!= NULL
&& tp
->control
.proceed_to_finish
)
1692 observer_notify_normal_stop (bs
, 1 /* print frame */);
1695 delete_breakpoint (a
->breakpoint
);
1696 delete_longjmp_breakpoint (a
->thread
);
1700 finish_command_continuation_free_arg (void *arg
)
1705 /* finish_backward -- helper function for finish_command. */
1708 finish_backward (struct symbol
*function
)
1710 struct symtab_and_line sal
;
1711 struct thread_info
*tp
= inferior_thread ();
1713 CORE_ADDR func_addr
;
1715 pc
= get_frame_pc (get_current_frame ());
1717 if (find_pc_partial_function (pc
, NULL
, &func_addr
, NULL
) == 0)
1718 error (_("Cannot find bounds of current function"));
1720 sal
= find_pc_line (func_addr
, 0);
1722 tp
->control
.proceed_to_finish
= 1;
1723 /* Special case: if we're sitting at the function entry point,
1724 then all we need to do is take a reverse singlestep. We
1725 don't need to set a breakpoint, and indeed it would do us
1728 Note that this can only happen at frame #0, since there's
1729 no way that a function up the stack can have a return address
1730 that's equal to its entry point. */
1734 struct frame_info
*frame
= get_selected_frame (NULL
);
1735 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1736 struct symtab_and_line sr_sal
;
1738 /* Set a step-resume at the function's entry point. Once that's
1739 hit, we'll do one more step backwards. */
1742 sr_sal
.pspace
= get_frame_program_space (frame
);
1743 insert_step_resume_breakpoint_at_sal (gdbarch
,
1744 sr_sal
, null_frame_id
);
1746 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
, 0);
1750 /* We're almost there -- we just need to back up by one more
1752 tp
->control
.step_range_start
= tp
->control
.step_range_end
= 1;
1753 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
, 1);
1757 /* finish_forward -- helper function for finish_command. */
1760 finish_forward (struct symbol
*function
, struct frame_info
*frame
)
1762 struct frame_id frame_id
= get_frame_id (frame
);
1763 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1764 struct symtab_and_line sal
;
1765 struct thread_info
*tp
= inferior_thread ();
1766 struct breakpoint
*breakpoint
;
1767 struct cleanup
*old_chain
;
1768 struct finish_command_continuation_args
*cargs
;
1769 int thread
= tp
->num
;
1771 sal
= find_pc_line (get_frame_pc (frame
), 0);
1772 sal
.pc
= get_frame_pc (frame
);
1774 breakpoint
= set_momentary_breakpoint (gdbarch
, sal
,
1775 get_stack_frame_id (frame
),
1778 /* set_momentary_breakpoint invalidates FRAME. */
1781 old_chain
= make_cleanup_delete_breakpoint (breakpoint
);
1783 set_longjmp_breakpoint (tp
, frame_id
);
1784 make_cleanup (delete_longjmp_breakpoint_cleanup
, &thread
);
1786 /* We want stop_registers, please... */
1787 tp
->control
.proceed_to_finish
= 1;
1788 cargs
= xmalloc (sizeof (*cargs
));
1790 cargs
->thread
= thread
;
1791 cargs
->breakpoint
= breakpoint
;
1792 cargs
->function
= function
;
1793 add_continuation (tp
, finish_command_continuation
, cargs
,
1794 finish_command_continuation_free_arg
);
1795 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
, 0);
1797 discard_cleanups (old_chain
);
1798 if (!target_can_async_p ())
1799 do_all_continuations (0);
1802 /* "finish": Set a temporary breakpoint at the place the selected
1803 frame will return to, then continue. */
1806 finish_command (char *arg
, int from_tty
)
1808 struct frame_info
*frame
;
1809 struct symbol
*function
;
1811 struct cleanup
*args_chain
;
1814 ensure_not_tfind_mode ();
1815 ensure_valid_thread ();
1816 ensure_not_running ();
1818 /* Find out whether we must run in the background. */
1819 arg
= strip_bg_char (arg
, &async_exec
);
1820 args_chain
= make_cleanup (xfree
, arg
);
1822 prepare_execution_command (¤t_target
, async_exec
);
1825 error (_("The \"finish\" command does not take any arguments."));
1827 /* Done with ARGS. */
1828 do_cleanups (args_chain
);
1830 frame
= get_prev_frame (get_selected_frame (_("No selected frame.")));
1832 error (_("\"finish\" not meaningful in the outermost frame."));
1834 clear_proceed_status (0);
1836 /* Finishing from an inline frame is completely different. We don't
1837 try to show the "return value" - no way to locate it. So we do
1838 not need a completion. */
1839 if (get_frame_type (get_selected_frame (_("No selected frame.")))
1842 /* Claim we are stepping in the calling frame. An empty step
1843 range means that we will stop once we aren't in a function
1844 called by that frame. We don't use the magic "1" value for
1845 step_range_end, because then infrun will think this is nexti,
1846 and not step over the rest of this inlined function call. */
1847 struct thread_info
*tp
= inferior_thread ();
1848 struct symtab_and_line empty_sal
;
1850 init_sal (&empty_sal
);
1851 set_step_info (frame
, empty_sal
);
1852 tp
->control
.step_range_start
= get_frame_pc (frame
);
1853 tp
->control
.step_range_end
= tp
->control
.step_range_start
;
1854 tp
->control
.step_over_calls
= STEP_OVER_ALL
;
1856 /* Print info on the selected frame, including level number but not
1860 printf_filtered (_("Run till exit from "));
1861 print_stack_frame (get_selected_frame (NULL
), 1, LOCATION
, 0);
1864 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
, 1);
1868 /* Ignore TAILCALL_FRAME type frames, they were executed already before
1869 entering THISFRAME. */
1870 while (get_frame_type (frame
) == TAILCALL_FRAME
)
1871 frame
= get_prev_frame (frame
);
1873 /* Find the function we will return from. */
1875 function
= find_pc_function (get_frame_pc (get_selected_frame (NULL
)));
1877 /* Print info on the selected frame, including level number but not
1881 if (execution_direction
== EXEC_REVERSE
)
1882 printf_filtered (_("Run back to call of "));
1885 if (function
!= NULL
&& TYPE_NO_RETURN (function
->type
)
1886 && !query (_("warning: Function %s does not return normally.\n"
1887 "Try to finish anyway? "),
1888 SYMBOL_PRINT_NAME (function
)))
1889 error (_("Not confirmed."));
1890 printf_filtered (_("Run till exit from "));
1893 print_stack_frame (get_selected_frame (NULL
), 1, LOCATION
, 0);
1896 if (execution_direction
== EXEC_REVERSE
)
1897 finish_backward (function
);
1899 finish_forward (function
, frame
);
1904 program_info (char *args
, int from_tty
)
1908 struct thread_info
*tp
;
1911 if (!target_has_execution
)
1913 printf_filtered (_("The program being debugged is not being run.\n"));
1918 ptid
= inferior_ptid
;
1921 struct target_waitstatus ws
;
1923 get_last_target_status (&ptid
, &ws
);
1926 if (ptid_equal (ptid
, null_ptid
) || is_exited (ptid
))
1927 error (_("Invalid selected thread."));
1928 else if (is_running (ptid
))
1929 error (_("Selected thread is running."));
1931 tp
= find_thread_ptid (ptid
);
1932 bs
= tp
->control
.stop_bpstat
;
1933 stat
= bpstat_num (&bs
, &num
);
1935 target_files_info ();
1936 printf_filtered (_("Program stopped at %s.\n"),
1937 paddress (target_gdbarch (), stop_pc
));
1938 if (tp
->control
.stop_step
)
1939 printf_filtered (_("It stopped after being stepped.\n"));
1942 /* There may be several breakpoints in the same place, so this
1943 isn't as strange as it seems. */
1948 printf_filtered (_("It stopped at a breakpoint "
1949 "that has since been deleted.\n"));
1952 printf_filtered (_("It stopped at breakpoint %d.\n"), num
);
1953 stat
= bpstat_num (&bs
, &num
);
1956 else if (tp
->suspend
.stop_signal
!= GDB_SIGNAL_0
)
1958 printf_filtered (_("It stopped with signal %s, %s.\n"),
1959 gdb_signal_to_name (tp
->suspend
.stop_signal
),
1960 gdb_signal_to_string (tp
->suspend
.stop_signal
));
1965 printf_filtered (_("Type \"info stack\" or \"info "
1966 "registers\" for more information.\n"));
1971 environment_info (char *var
, int from_tty
)
1975 char *val
= get_in_environ (current_inferior ()->environment
, var
);
1979 puts_filtered (var
);
1980 puts_filtered (" = ");
1981 puts_filtered (val
);
1982 puts_filtered ("\n");
1986 puts_filtered ("Environment variable \"");
1987 puts_filtered (var
);
1988 puts_filtered ("\" not defined.\n");
1993 char **vector
= environ_vector (current_inferior ()->environment
);
1997 puts_filtered (*vector
++);
1998 puts_filtered ("\n");
2004 set_environment_command (char *arg
, int from_tty
)
2006 char *p
, *val
, *var
;
2010 error_no_arg (_("environment variable and value"));
2012 /* Find seperation between variable name and value. */
2013 p
= (char *) strchr (arg
, '=');
2014 val
= (char *) strchr (arg
, ' ');
2016 if (p
!= 0 && val
!= 0)
2018 /* We have both a space and an equals. If the space is before the
2019 equals, walk forward over the spaces til we see a nonspace
2020 (possibly the equals). */
2025 /* Now if the = is after the char following the spaces,
2026 take the char following the spaces. */
2030 else if (val
!= 0 && p
== 0)
2034 error_no_arg (_("environment variable to set"));
2036 if (p
== 0 || p
[1] == 0)
2040 p
= arg
+ strlen (arg
); /* So that savestring below will work. */
2044 /* Not setting variable value to null. */
2046 while (*val
== ' ' || *val
== '\t')
2050 while (p
!= arg
&& (p
[-1] == ' ' || p
[-1] == '\t'))
2053 var
= savestring (arg
, p
- arg
);
2056 printf_filtered (_("Setting environment variable "
2057 "\"%s\" to null value.\n"),
2059 set_in_environ (current_inferior ()->environment
, var
, "");
2062 set_in_environ (current_inferior ()->environment
, var
, val
);
2067 unset_environment_command (char *var
, int from_tty
)
2071 /* If there is no argument, delete all environment variables.
2072 Ask for confirmation if reading from the terminal. */
2073 if (!from_tty
|| query (_("Delete all environment variables? ")))
2075 free_environ (current_inferior ()->environment
);
2076 current_inferior ()->environment
= make_environ ();
2080 unset_in_environ (current_inferior ()->environment
, var
);
2083 /* Handle the execution path (PATH variable). */
2085 static const char path_var_name
[] = "PATH";
2088 path_info (char *args
, int from_tty
)
2090 puts_filtered ("Executable and object file path: ");
2091 puts_filtered (get_in_environ (current_inferior ()->environment
,
2093 puts_filtered ("\n");
2096 /* Add zero or more directories to the front of the execution path. */
2099 path_command (char *dirname
, int from_tty
)
2105 env
= get_in_environ (current_inferior ()->environment
, path_var_name
);
2106 /* Can be null if path is not set. */
2109 exec_path
= xstrdup (env
);
2110 mod_path (dirname
, &exec_path
);
2111 set_in_environ (current_inferior ()->environment
, path_var_name
, exec_path
);
2114 path_info ((char *) NULL
, from_tty
);
2118 /* Print out the register NAME with value VAL, to FILE, in the default
2122 default_print_one_register_info (struct ui_file
*file
,
2126 struct type
*regtype
= value_type (val
);
2127 int print_raw_format
;
2129 fputs_filtered (name
, file
);
2130 print_spaces_filtered (15 - strlen (name
), file
);
2132 print_raw_format
= (value_entirely_available (val
)
2133 && !value_optimized_out (val
));
2135 /* If virtual format is floating, print it that way, and in raw
2137 if (TYPE_CODE (regtype
) == TYPE_CODE_FLT
2138 || TYPE_CODE (regtype
) == TYPE_CODE_DECFLOAT
)
2141 struct value_print_options opts
;
2142 const gdb_byte
*valaddr
= value_contents_for_printing (val
);
2143 enum bfd_endian byte_order
= gdbarch_byte_order (get_type_arch (regtype
));
2145 get_user_print_options (&opts
);
2149 value_contents_for_printing (val
),
2150 value_embedded_offset (val
), 0,
2151 file
, 0, val
, &opts
, current_language
);
2153 if (print_raw_format
)
2155 fprintf_filtered (file
, "\t(raw ");
2156 print_hex_chars (file
, valaddr
, TYPE_LENGTH (regtype
), byte_order
);
2157 fprintf_filtered (file
, ")");
2162 struct value_print_options opts
;
2164 /* Print the register in hex. */
2165 get_formatted_print_options (&opts
, 'x');
2168 value_contents_for_printing (val
),
2169 value_embedded_offset (val
), 0,
2170 file
, 0, val
, &opts
, current_language
);
2171 /* If not a vector register, print it also according to its
2173 if (print_raw_format
&& TYPE_VECTOR (regtype
) == 0)
2175 get_user_print_options (&opts
);
2177 fprintf_filtered (file
, "\t");
2179 value_contents_for_printing (val
),
2180 value_embedded_offset (val
), 0,
2181 file
, 0, val
, &opts
, current_language
);
2185 fprintf_filtered (file
, "\n");
2188 /* Print out the machine register regnum. If regnum is -1, print all
2189 registers (print_all == 1) or all non-float and non-vector
2190 registers (print_all == 0).
2192 For most machines, having all_registers_info() print the
2193 register(s) one per line is good enough. If a different format is
2194 required, (eg, for MIPS or Pyramid 90x, which both have lots of
2195 regs), or there is an existing convention for showing all the
2196 registers, define the architecture method PRINT_REGISTERS_INFO to
2197 provide that format. */
2200 default_print_registers_info (struct gdbarch
*gdbarch
,
2201 struct ui_file
*file
,
2202 struct frame_info
*frame
,
2203 int regnum
, int print_all
)
2206 const int numregs
= gdbarch_num_regs (gdbarch
)
2207 + gdbarch_num_pseudo_regs (gdbarch
);
2209 for (i
= 0; i
< numregs
; i
++)
2211 /* Decide between printing all regs, non-float / vector regs, or
2217 if (!gdbarch_register_reggroup_p (gdbarch
, i
, all_reggroup
))
2222 if (!gdbarch_register_reggroup_p (gdbarch
, i
, general_reggroup
))
2232 /* If the register name is empty, it is undefined for this
2233 processor, so don't display anything. */
2234 if (gdbarch_register_name (gdbarch
, i
) == NULL
2235 || *(gdbarch_register_name (gdbarch
, i
)) == '\0')
2238 default_print_one_register_info (file
,
2239 gdbarch_register_name (gdbarch
, i
),
2240 value_of_register (i
, frame
));
2245 registers_info (char *addr_exp
, int fpregs
)
2247 struct frame_info
*frame
;
2248 struct gdbarch
*gdbarch
;
2250 if (!target_has_registers
)
2251 error (_("The program has no registers now."));
2252 frame
= get_selected_frame (NULL
);
2253 gdbarch
= get_frame_arch (frame
);
2257 gdbarch_print_registers_info (gdbarch
, gdb_stdout
,
2262 while (*addr_exp
!= '\0')
2267 /* Skip leading white space. */
2268 addr_exp
= skip_spaces (addr_exp
);
2270 /* Discard any leading ``$''. Check that there is something
2271 resembling a register following it. */
2272 if (addr_exp
[0] == '$')
2274 if (isspace ((*addr_exp
)) || (*addr_exp
) == '\0')
2275 error (_("Missing register name"));
2277 /* Find the start/end of this register name/num/group. */
2279 while ((*addr_exp
) != '\0' && !isspace ((*addr_exp
)))
2283 /* Figure out what we've found and display it. */
2285 /* A register name? */
2287 int regnum
= user_reg_map_name_to_regnum (gdbarch
, start
, end
- start
);
2291 /* User registers lie completely outside of the range of
2292 normal registers. Catch them early so that the target
2294 if (regnum
>= gdbarch_num_regs (gdbarch
)
2295 + gdbarch_num_pseudo_regs (gdbarch
))
2297 struct value
*regval
= value_of_user_reg (regnum
, frame
);
2298 const char *regname
= user_reg_map_regnum_to_name (gdbarch
,
2301 /* Print in the same fashion
2302 gdbarch_print_registers_info's default
2303 implementation prints. */
2304 default_print_one_register_info (gdb_stdout
,
2309 gdbarch_print_registers_info (gdbarch
, gdb_stdout
,
2310 frame
, regnum
, fpregs
);
2315 /* A register group? */
2317 struct reggroup
*group
;
2319 for (group
= reggroup_next (gdbarch
, NULL
);
2321 group
= reggroup_next (gdbarch
, group
))
2323 /* Don't bother with a length check. Should the user
2324 enter a short register group name, go with the first
2325 group that matches. */
2326 if (strncmp (start
, reggroup_name (group
), end
- start
) == 0)
2334 regnum
< gdbarch_num_regs (gdbarch
)
2335 + gdbarch_num_pseudo_regs (gdbarch
);
2338 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, group
))
2339 gdbarch_print_registers_info (gdbarch
,
2347 /* Nothing matched. */
2348 error (_("Invalid register `%.*s'"), (int) (end
- start
), start
);
2353 all_registers_info (char *addr_exp
, int from_tty
)
2355 registers_info (addr_exp
, 1);
2359 nofp_registers_info (char *addr_exp
, int from_tty
)
2361 registers_info (addr_exp
, 0);
2365 print_vector_info (struct ui_file
*file
,
2366 struct frame_info
*frame
, const char *args
)
2368 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
2370 if (gdbarch_print_vector_info_p (gdbarch
))
2371 gdbarch_print_vector_info (gdbarch
, file
, frame
, args
);
2375 int printed_something
= 0;
2378 regnum
< gdbarch_num_regs (gdbarch
)
2379 + gdbarch_num_pseudo_regs (gdbarch
);
2382 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, vector_reggroup
))
2384 printed_something
= 1;
2385 gdbarch_print_registers_info (gdbarch
, file
, frame
, regnum
, 1);
2388 if (!printed_something
)
2389 fprintf_filtered (file
, "No vector information\n");
2394 vector_info (char *args
, int from_tty
)
2396 if (!target_has_registers
)
2397 error (_("The program has no registers now."));
2399 print_vector_info (gdb_stdout
, get_selected_frame (NULL
), args
);
2402 /* Kill the inferior process. Make us have no inferior. */
2405 kill_command (char *arg
, int from_tty
)
2407 /* FIXME: This should not really be inferior_ptid (or target_has_execution).
2408 It should be a distinct flag that indicates that a target is active, cuz
2409 some targets don't have processes! */
2411 if (ptid_equal (inferior_ptid
, null_ptid
))
2412 error (_("The program is not being run."));
2413 if (!query (_("Kill the program being debugged? ")))
2414 error (_("Not confirmed."));
2417 /* If we still have other inferiors to debug, then don't mess with
2418 with their threads. */
2419 if (!have_inferiors ())
2421 init_thread_list (); /* Destroy thread info. */
2423 /* Killing off the inferior can leave us with a core file. If
2424 so, print the state we are left in. */
2425 if (target_has_stack
)
2427 printf_filtered (_("In %s,\n"), target_longname
);
2428 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
, 1);
2431 bfd_cache_close_all ();
2434 /* Used in `attach&' command. ARG is a point to an integer
2435 representing a process id. Proceed threads of this process iff
2436 they stopped due to debugger request, and when they did, they
2437 reported a clean stop (GDB_SIGNAL_0). Do not proceed threads
2438 that have been explicitly been told to stop. */
2441 proceed_after_attach_callback (struct thread_info
*thread
,
2444 int pid
= * (int *) arg
;
2446 if (ptid_get_pid (thread
->ptid
) == pid
2447 && !is_exited (thread
->ptid
)
2448 && !is_executing (thread
->ptid
)
2449 && !thread
->stop_requested
2450 && thread
->suspend
.stop_signal
== GDB_SIGNAL_0
)
2452 switch_to_thread (thread
->ptid
);
2453 clear_proceed_status (0);
2454 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
, 0);
2461 proceed_after_attach (int pid
)
2463 /* Don't error out if the current thread is running, because
2464 there may be other stopped threads. */
2465 struct cleanup
*old_chain
;
2467 /* Backup current thread and selected frame. */
2468 old_chain
= make_cleanup_restore_current_thread ();
2470 iterate_over_threads (proceed_after_attach_callback
, &pid
);
2472 /* Restore selected ptid. */
2473 do_cleanups (old_chain
);
2476 /* attach_command --
2477 takes a program started up outside of gdb and ``attaches'' to it.
2478 This stops it cold in its tracks and allows us to start debugging it.
2479 and wait for the trace-trap that results from attaching. */
2482 attach_command_post_wait (char *args
, int from_tty
, int async_exec
)
2485 char *full_exec_path
= NULL
;
2486 struct inferior
*inferior
;
2488 inferior
= current_inferior ();
2489 inferior
->control
.stop_soon
= NO_STOP_QUIETLY
;
2491 /* If no exec file is yet known, try to determine it from the
2493 exec_file
= (char *) get_exec_file (0);
2496 exec_file
= target_pid_to_exec_file (ptid_get_pid (inferior_ptid
));
2499 /* It's possible we don't have a full path, but rather just a
2500 filename. Some targets, such as HP-UX, don't provide the
2503 Attempt to qualify the filename against the source path.
2504 (If that fails, we'll just fall back on the original
2505 filename. Not much more we can do...) */
2507 if (!source_full_path_of (exec_file
, &full_exec_path
))
2508 full_exec_path
= xstrdup (exec_file
);
2510 exec_file_attach (full_exec_path
, from_tty
);
2511 symbol_file_add_main (full_exec_path
, from_tty
);
2516 reopen_exec_file ();
2520 /* Take any necessary post-attaching actions for this platform. */
2521 target_post_attach (ptid_get_pid (inferior_ptid
));
2523 post_create_inferior (¤t_target
, from_tty
);
2527 /* The user requested an `attach&', so be sure to leave threads
2528 that didn't get a signal running. */
2530 /* Immediatelly resume all suspended threads of this inferior,
2531 and this inferior only. This should have no effect on
2532 already running threads. If a thread has been stopped with a
2533 signal, leave it be. */
2535 proceed_after_attach (inferior
->pid
);
2538 if (inferior_thread ()->suspend
.stop_signal
== GDB_SIGNAL_0
)
2540 clear_proceed_status (0);
2541 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
, 0);
2547 /* The user requested a plain `attach', so be sure to leave
2548 the inferior stopped. */
2550 if (target_can_async_p ())
2551 async_enable_stdin ();
2553 /* At least the current thread is already stopped. */
2555 /* In all-stop, by definition, all threads have to be already
2556 stopped at this point. In non-stop, however, although the
2557 selected thread is stopped, others may still be executing.
2558 Be sure to explicitly stop all threads of the process. This
2559 should have no effect on already stopped threads. */
2561 target_stop (pid_to_ptid (inferior
->pid
));
2563 /* Tell the user/frontend where we're stopped. */
2565 if (deprecated_attach_hook
)
2566 deprecated_attach_hook ();
2570 struct attach_command_continuation_args
2578 attach_command_continuation (void *args
, int err
)
2580 struct attach_command_continuation_args
*a
= args
;
2585 attach_command_post_wait (a
->args
, a
->from_tty
, a
->async_exec
);
2589 attach_command_continuation_free_args (void *args
)
2591 struct attach_command_continuation_args
*a
= args
;
2598 attach_command (char *args
, int from_tty
)
2601 struct cleanup
*args_chain
;
2602 struct target_ops
*attach_target
;
2604 dont_repeat (); /* Not for the faint of heart */
2606 if (gdbarch_has_global_solist (target_gdbarch ()))
2607 /* Don't complain if all processes share the same symbol
2610 else if (target_has_execution
)
2612 if (query (_("A program is being debugged already. Kill it? ")))
2615 error (_("Not killed."));
2618 /* Clean up any leftovers from other runs. Some other things from
2619 this function should probably be moved into target_pre_inferior. */
2620 target_pre_inferior (from_tty
);
2622 args
= strip_bg_char (args
, &async_exec
);
2623 args_chain
= make_cleanup (xfree
, args
);
2625 attach_target
= find_attach_target ();
2627 prepare_execution_command (attach_target
, async_exec
);
2629 if (non_stop
&& !attach_target
->to_supports_non_stop (attach_target
))
2630 error (_("Cannot attach to this target in non-stop mode"));
2632 attach_target
->to_attach (attach_target
, args
, from_tty
);
2633 /* to_attach should push the target, so after this point we
2634 shouldn't refer to attach_target again. */
2635 attach_target
= NULL
;
2637 /* Done with ARGS. */
2638 do_cleanups (args_chain
);
2640 /* Set up the "saved terminal modes" of the inferior
2641 based on what modes we are starting it with. */
2642 target_terminal_init ();
2644 /* Install inferior's terminal modes. This may look like a no-op,
2645 as we've just saved them above, however, this does more than
2646 restore terminal settings:
2648 - installs a SIGINT handler that forwards SIGINT to the inferior.
2649 Otherwise a Ctrl-C pressed just while waiting for the initial
2650 stop would end up as a spurious Quit.
2652 - removes stdin from the event loop, which we need if attaching
2653 in the foreground, otherwise on targets that report an initial
2654 stop on attach (which are most) we'd process input/commands
2655 while we're in the event loop waiting for that stop. That is,
2656 before the attach continuation runs and the command is really
2658 target_terminal_inferior ();
2660 /* Set up execution context to know that we should return from
2661 wait_for_inferior as soon as the target reports a stop. */
2662 init_wait_for_inferior ();
2663 clear_proceed_status (0);
2667 /* If we find that the current thread isn't stopped, explicitly
2668 do so now, because we're going to install breakpoints and
2672 /* The user requested an `attach&'; stop just one thread. */
2673 target_stop (inferior_ptid
);
2675 /* The user requested an `attach', so stop all threads of this
2677 target_stop (pid_to_ptid (ptid_get_pid (inferior_ptid
)));
2680 /* Some system don't generate traps when attaching to inferior.
2681 E.g. Mach 3 or GNU hurd. */
2682 if (!target_attach_no_wait
)
2684 struct inferior
*inferior
= current_inferior ();
2686 /* Careful here. See comments in inferior.h. Basically some
2687 OSes don't ignore SIGSTOPs on continue requests anymore. We
2688 need a way for handle_inferior_event to reset the stop_signal
2689 variable after an attach, and this is what
2690 STOP_QUIETLY_NO_SIGSTOP is for. */
2691 inferior
->control
.stop_soon
= STOP_QUIETLY_NO_SIGSTOP
;
2693 if (target_can_async_p ())
2695 /* sync_execution mode. Wait for stop. */
2696 struct attach_command_continuation_args
*a
;
2698 a
= xmalloc (sizeof (*a
));
2699 a
->args
= xstrdup (args
);
2700 a
->from_tty
= from_tty
;
2701 a
->async_exec
= async_exec
;
2702 add_inferior_continuation (attach_command_continuation
, a
,
2703 attach_command_continuation_free_args
);
2707 wait_for_inferior ();
2710 attach_command_post_wait (args
, from_tty
, async_exec
);
2713 /* We had just found out that the target was already attached to an
2714 inferior. PTID points at a thread of this new inferior, that is
2715 the most likely to be stopped right now, but not necessarily so.
2716 The new inferior is assumed to be already added to the inferior
2717 list at this point. If LEAVE_RUNNING, then leave the threads of
2718 this inferior running, except those we've explicitly seen reported
2722 notice_new_inferior (ptid_t ptid
, int leave_running
, int from_tty
)
2724 struct cleanup
* old_chain
;
2727 old_chain
= make_cleanup (null_cleanup
, NULL
);
2729 /* If in non-stop, leave threads as running as they were. If
2730 they're stopped for some reason other than us telling it to, the
2731 target reports a signal != GDB_SIGNAL_0. We don't try to
2732 resume threads with such a stop signal. */
2733 async_exec
= non_stop
;
2735 if (!ptid_equal (inferior_ptid
, null_ptid
))
2736 make_cleanup_restore_current_thread ();
2738 switch_to_thread (ptid
);
2740 /* When we "notice" a new inferior we need to do all the things we
2741 would normally do if we had just attached to it. */
2743 if (is_executing (inferior_ptid
))
2745 struct inferior
*inferior
= current_inferior ();
2747 /* We're going to install breakpoints, and poke at memory,
2748 ensure that the inferior is stopped for a moment while we do
2750 target_stop (inferior_ptid
);
2752 inferior
->control
.stop_soon
= STOP_QUIETLY_REMOTE
;
2754 /* Wait for stop before proceeding. */
2755 if (target_can_async_p ())
2757 struct attach_command_continuation_args
*a
;
2759 a
= xmalloc (sizeof (*a
));
2760 a
->args
= xstrdup ("");
2761 a
->from_tty
= from_tty
;
2762 a
->async_exec
= async_exec
;
2763 add_inferior_continuation (attach_command_continuation
, a
,
2764 attach_command_continuation_free_args
);
2766 do_cleanups (old_chain
);
2770 wait_for_inferior ();
2773 async_exec
= leave_running
;
2774 attach_command_post_wait ("" /* args */, from_tty
, async_exec
);
2776 do_cleanups (old_chain
);
2781 * takes a program previously attached to and detaches it.
2782 * The program resumes execution and will no longer stop
2783 * on signals, etc. We better not have left any breakpoints
2784 * in the program or it'll die when it hits one. For this
2785 * to work, it may be necessary for the process to have been
2786 * previously attached. It *might* work if the program was
2787 * started via the normal ptrace (PTRACE_TRACEME).
2791 detach_command (char *args
, int from_tty
)
2793 dont_repeat (); /* Not for the faint of heart. */
2795 if (ptid_equal (inferior_ptid
, null_ptid
))
2796 error (_("The program is not being run."));
2798 query_if_trace_running (from_tty
);
2800 disconnect_tracing ();
2802 target_detach (args
, from_tty
);
2804 /* If the solist is global across inferiors, don't clear it when we
2805 detach from a single inferior. */
2806 if (!gdbarch_has_global_solist (target_gdbarch ()))
2807 no_shared_libraries (NULL
, from_tty
);
2809 /* If we still have inferiors to debug, then don't mess with their
2811 if (!have_inferiors ())
2812 init_thread_list ();
2814 if (deprecated_detach_hook
)
2815 deprecated_detach_hook ();
2818 /* Disconnect from the current target without resuming it (leaving it
2819 waiting for a debugger).
2821 We'd better not have left any breakpoints in the program or the
2822 next debugger will get confused. Currently only supported for some
2823 remote targets, since the normal attach mechanisms don't work on
2824 stopped processes on some native platforms (e.g. GNU/Linux). */
2827 disconnect_command (char *args
, int from_tty
)
2829 dont_repeat (); /* Not for the faint of heart. */
2830 query_if_trace_running (from_tty
);
2831 disconnect_tracing ();
2832 target_disconnect (args
, from_tty
);
2833 no_shared_libraries (NULL
, from_tty
);
2834 init_thread_list ();
2835 if (deprecated_detach_hook
)
2836 deprecated_detach_hook ();
2840 interrupt_target_1 (int all_threads
)
2845 ptid
= minus_one_ptid
;
2847 ptid
= inferior_ptid
;
2850 /* Tag the thread as having been explicitly requested to stop, so
2851 other parts of gdb know not to resume this thread automatically,
2852 if it was stopped due to an internal event. Limit this to
2853 non-stop mode, as when debugging a multi-threaded application in
2854 all-stop mode, we will only get one stop event --- it's undefined
2855 which thread will report the event. */
2857 set_stop_requested (ptid
, 1);
2861 Stop the execution of the target while running in async mode, in
2862 the backgound. In all-stop, stop the whole process. In non-stop
2863 mode, stop the current thread only by default, or stop all threads
2864 if the `-a' switch is used. */
2867 interrupt_command (char *args
, int from_tty
)
2869 if (target_can_async_p ())
2871 int all_threads
= 0;
2873 dont_repeat (); /* Not for the faint of heart. */
2876 && startswith (args
, "-a"))
2879 if (!non_stop
&& all_threads
)
2880 error (_("-a is meaningless in all-stop mode."));
2882 interrupt_target_1 (all_threads
);
2886 /* See inferior.h. */
2889 default_print_float_info (struct gdbarch
*gdbarch
, struct ui_file
*file
,
2890 struct frame_info
*frame
, const char *args
)
2893 int printed_something
= 0;
2896 regnum
< gdbarch_num_regs (gdbarch
)
2897 + gdbarch_num_pseudo_regs (gdbarch
);
2900 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, float_reggroup
))
2902 printed_something
= 1;
2903 gdbarch_print_registers_info (gdbarch
, file
, frame
, regnum
, 1);
2906 if (!printed_something
)
2907 fprintf_filtered (file
, "No floating-point info "
2908 "available for this processor.\n");
2912 float_info (char *args
, int from_tty
)
2914 struct frame_info
*frame
;
2916 if (!target_has_registers
)
2917 error (_("The program has no registers now."));
2919 frame
= get_selected_frame (NULL
);
2920 gdbarch_print_float_info (get_frame_arch (frame
), gdb_stdout
, frame
, args
);
2924 unset_command (char *args
, int from_tty
)
2926 printf_filtered (_("\"unset\" must be followed by the "
2927 "name of an unset subcommand.\n"));
2928 help_list (unsetlist
, "unset ", all_commands
, gdb_stdout
);
2931 /* Implement `info proc' family of commands. */
2934 info_proc_cmd_1 (char *args
, enum info_proc_what what
, int from_tty
)
2936 struct gdbarch
*gdbarch
= get_current_arch ();
2938 if (!target_info_proc (args
, what
))
2940 if (gdbarch_info_proc_p (gdbarch
))
2941 gdbarch_info_proc (gdbarch
, args
, what
);
2943 error (_("Not supported on this target."));
2947 /* Implement `info proc' when given without any futher parameters. */
2950 info_proc_cmd (char *args
, int from_tty
)
2952 info_proc_cmd_1 (args
, IP_MINIMAL
, from_tty
);
2955 /* Implement `info proc mappings'. */
2958 info_proc_cmd_mappings (char *args
, int from_tty
)
2960 info_proc_cmd_1 (args
, IP_MAPPINGS
, from_tty
);
2963 /* Implement `info proc stat'. */
2966 info_proc_cmd_stat (char *args
, int from_tty
)
2968 info_proc_cmd_1 (args
, IP_STAT
, from_tty
);
2971 /* Implement `info proc status'. */
2974 info_proc_cmd_status (char *args
, int from_tty
)
2976 info_proc_cmd_1 (args
, IP_STATUS
, from_tty
);
2979 /* Implement `info proc cwd'. */
2982 info_proc_cmd_cwd (char *args
, int from_tty
)
2984 info_proc_cmd_1 (args
, IP_CWD
, from_tty
);
2987 /* Implement `info proc cmdline'. */
2990 info_proc_cmd_cmdline (char *args
, int from_tty
)
2992 info_proc_cmd_1 (args
, IP_CMDLINE
, from_tty
);
2995 /* Implement `info proc exe'. */
2998 info_proc_cmd_exe (char *args
, int from_tty
)
3000 info_proc_cmd_1 (args
, IP_EXE
, from_tty
);
3003 /* Implement `info proc all'. */
3006 info_proc_cmd_all (char *args
, int from_tty
)
3008 info_proc_cmd_1 (args
, IP_ALL
, from_tty
);
3012 _initialize_infcmd (void)
3014 static struct cmd_list_element
*info_proc_cmdlist
;
3015 struct cmd_list_element
*c
= NULL
;
3016 const char *cmd_name
;
3018 /* Add the filename of the terminal connected to inferior I/O. */
3019 add_setshow_filename_cmd ("inferior-tty", class_run
,
3020 &inferior_io_terminal_scratch
, _("\
3021 Set terminal for future runs of program being debugged."), _("\
3022 Show terminal for future runs of program being debugged."), _("\
3023 Usage: set inferior-tty /dev/pts/1"),
3024 set_inferior_tty_command
,
3025 show_inferior_tty_command
,
3026 &setlist
, &showlist
);
3027 add_com_alias ("tty", "set inferior-tty", class_alias
, 0);
3030 add_setshow_string_noescape_cmd (cmd_name
, class_run
,
3031 &inferior_args_scratch
, _("\
3032 Set argument list to give program being debugged when it is started."), _("\
3033 Show argument list to give program being debugged when it is started."), _("\
3034 Follow this command with any number of args, to be passed to the program."),
3037 &setlist
, &showlist
);
3038 c
= lookup_cmd (&cmd_name
, setlist
, "", -1, 1);
3039 gdb_assert (c
!= NULL
);
3040 set_cmd_completer (c
, filename_completer
);
3042 c
= add_cmd ("environment", no_class
, environment_info
, _("\
3043 The environment to give the program, or one variable's value.\n\
3044 With an argument VAR, prints the value of environment variable VAR to\n\
3045 give the program being debugged. With no arguments, prints the entire\n\
3046 environment to be given to the program."), &showlist
);
3047 set_cmd_completer (c
, noop_completer
);
3049 add_prefix_cmd ("unset", no_class
, unset_command
,
3050 _("Complement to certain \"set\" commands."),
3051 &unsetlist
, "unset ", 0, &cmdlist
);
3053 c
= add_cmd ("environment", class_run
, unset_environment_command
, _("\
3054 Cancel environment variable VAR for the program.\n\
3055 This does not affect the program until the next \"run\" command."),
3057 set_cmd_completer (c
, noop_completer
);
3059 c
= add_cmd ("environment", class_run
, set_environment_command
, _("\
3060 Set environment variable value to give the program.\n\
3061 Arguments are VAR VALUE where VAR is variable name and VALUE is value.\n\
3062 VALUES of environment variables are uninterpreted strings.\n\
3063 This does not affect the program until the next \"run\" command."),
3065 set_cmd_completer (c
, noop_completer
);
3067 c
= add_com ("path", class_files
, path_command
, _("\
3068 Add directory DIR(s) to beginning of search path for object files.\n\
3069 $cwd in the path means the current working directory.\n\
3070 This path is equivalent to the $PATH shell variable. It is a list of\n\
3071 directories, separated by colons. These directories are searched to find\n\
3072 fully linked executable files and separately compiled object files as \
3074 set_cmd_completer (c
, filename_completer
);
3076 c
= add_cmd ("paths", no_class
, path_info
, _("\
3077 Current search path for finding object files.\n\
3078 $cwd in the path means the current working directory.\n\
3079 This path is equivalent to the $PATH shell variable. It is a list of\n\
3080 directories, separated by colons. These directories are searched to find\n\
3081 fully linked executable files and separately compiled object files as \
3084 set_cmd_completer (c
, noop_completer
);
3086 add_prefix_cmd ("kill", class_run
, kill_command
,
3087 _("Kill execution of program being debugged."),
3088 &killlist
, "kill ", 0, &cmdlist
);
3090 add_com ("attach", class_run
, attach_command
, _("\
3091 Attach to a process or file outside of GDB.\n\
3092 This command attaches to another target, of the same type as your last\n\
3093 \"target\" command (\"info files\" will show your target stack).\n\
3094 The command may take as argument a process id or a device file.\n\
3095 For a process id, you must have permission to send the process a signal,\n\
3096 and it must have the same effective uid as the debugger.\n\
3097 When using \"attach\" with a process id, the debugger finds the\n\
3098 program running in the process, looking first in the current working\n\
3099 directory, or (if not found there) using the source file search path\n\
3100 (see the \"directory\" command). You can also use the \"file\" command\n\
3101 to specify the program, and to load its symbol table."));
3103 add_prefix_cmd ("detach", class_run
, detach_command
, _("\
3104 Detach a process or file previously attached.\n\
3105 If a process, it is no longer traced, and it continues its execution. If\n\
3106 you were debugging a file, the file is closed and gdb no longer accesses it."),
3107 &detachlist
, "detach ", 0, &cmdlist
);
3109 add_com ("disconnect", class_run
, disconnect_command
, _("\
3110 Disconnect from a target.\n\
3111 The target will wait for another debugger to connect. Not available for\n\
3114 c
= add_com ("signal", class_run
, signal_command
, _("\
3115 Continue program with the specified signal.\n\
3116 Usage: signal SIGNAL\n\
3117 The SIGNAL argument is processed the same as the handle command.\n\
3119 An argument of \"0\" means continue the program without sending it a signal.\n\
3120 This is useful in cases where the program stopped because of a signal,\n\
3121 and you want to resume the program while discarding the signal.\n\
3123 In a multi-threaded program the signal is delivered to, or discarded from,\n\
3124 the current thread only."));
3125 set_cmd_completer (c
, signal_completer
);
3127 c
= add_com ("queue-signal", class_run
, queue_signal_command
, _("\
3128 Queue a signal to be delivered to the current thread when it is resumed.\n\
3129 Usage: queue-signal SIGNAL\n\
3130 The SIGNAL argument is processed the same as the handle command.\n\
3131 It is an error if the handling state of SIGNAL is \"nopass\".\n\
3133 An argument of \"0\" means remove any currently queued signal from\n\
3134 the current thread. This is useful in cases where the program stopped\n\
3135 because of a signal, and you want to resume it while discarding the signal.\n\
3137 In a multi-threaded program the signal is queued with, or discarded from,\n\
3138 the current thread only."));
3139 set_cmd_completer (c
, signal_completer
);
3141 add_com ("stepi", class_run
, stepi_command
, _("\
3142 Step one instruction exactly.\n\
3144 Argument N means step N times (or till program stops for another \
3146 add_com_alias ("si", "stepi", class_alias
, 0);
3148 add_com ("nexti", class_run
, nexti_command
, _("\
3149 Step one instruction, but proceed through subroutine calls.\n\
3151 Argument N means step N times (or till program stops for another \
3153 add_com_alias ("ni", "nexti", class_alias
, 0);
3155 add_com ("finish", class_run
, finish_command
, _("\
3156 Execute until selected stack frame returns.\n\
3158 Upon return, the value returned is printed and put in the value history."));
3159 add_com_alias ("fin", "finish", class_run
, 1);
3161 add_com ("next", class_run
, next_command
, _("\
3162 Step program, proceeding through subroutine calls.\n\
3164 Unlike \"step\", if the current source line calls a subroutine,\n\
3165 this command does not enter the subroutine, but instead steps over\n\
3166 the call, in effect treating it as a single source line."));
3167 add_com_alias ("n", "next", class_run
, 1);
3169 add_com_alias ("S", "next", class_run
, 1);
3171 add_com ("step", class_run
, step_command
, _("\
3172 Step program until it reaches a different source line.\n\
3174 Argument N means step N times (or till program stops for another \
3176 add_com_alias ("s", "step", class_run
, 1);
3178 c
= add_com ("until", class_run
, until_command
, _("\
3179 Execute until the program reaches a source line greater than the current\n\
3180 or a specified location (same args as break command) within the current \
3182 set_cmd_completer (c
, location_completer
);
3183 add_com_alias ("u", "until", class_run
, 1);
3185 c
= add_com ("advance", class_run
, advance_command
, _("\
3186 Continue the program up to the given location (same form as args for break \
3188 Execution will also stop upon exit from the current stack frame."));
3189 set_cmd_completer (c
, location_completer
);
3191 c
= add_com ("jump", class_run
, jump_command
, _("\
3192 Continue program being debugged at specified line or address.\n\
3193 Usage: jump <location>\n\
3194 Give as argument either LINENUM or *ADDR, where ADDR is an expression\n\
3195 for an address to start at."));
3196 set_cmd_completer (c
, location_completer
);
3197 add_com_alias ("j", "jump", class_run
, 1);
3201 c
= add_com ("go", class_run
, go_command
, _("\
3202 Usage: go <location>\n\
3203 Continue program being debugged, stopping at specified line or \n\
3205 Give as argument either LINENUM or *ADDR, where ADDR is an \n\
3206 expression for an address to start at.\n\
3207 This command is a combination of tbreak and jump."));
3208 set_cmd_completer (c
, location_completer
);
3212 add_com_alias ("g", "go", class_run
, 1);
3214 add_com ("continue", class_run
, continue_command
, _("\
3215 Continue program being debugged, after signal or breakpoint.\n\
3216 Usage: continue [N]\n\
3217 If proceeding from breakpoint, a number N may be used as an argument,\n\
3218 which means to set the ignore count of that breakpoint to N - 1 (so that\n\
3219 the breakpoint won't break until the Nth time it is reached).\n\
3221 If non-stop mode is enabled, continue only the current thread,\n\
3222 otherwise all the threads in the program are continued. To \n\
3223 continue all stopped threads in non-stop mode, use the -a option.\n\
3224 Specifying -a and an ignore count simultaneously is an error."));
3225 add_com_alias ("c", "cont", class_run
, 1);
3226 add_com_alias ("fg", "cont", class_run
, 1);
3228 c
= add_com ("run", class_run
, run_command
, _("\
3229 Start debugged program. You may specify arguments to give it.\n\
3230 Args may include \"*\", or \"[...]\"; they are expanded using \"sh\".\n\
3231 Input and output redirection with \">\", \"<\", or \">>\" are also \
3233 With no arguments, uses arguments last specified (with \"run\" \
3234 or \"set args\").\n\
3235 To cancel previous arguments and run with no arguments,\n\
3236 use \"set args\" without arguments."));
3237 set_cmd_completer (c
, filename_completer
);
3238 add_com_alias ("r", "run", class_run
, 1);
3240 add_com ("R", class_run
, run_no_args_command
,
3241 _("Start debugged program with no arguments."));
3243 c
= add_com ("start", class_run
, start_command
, _("\
3244 Run the debugged program until the beginning of the main procedure.\n\
3245 You may specify arguments to give to your program, just as with the\n\
3246 \"run\" command."));
3247 set_cmd_completer (c
, filename_completer
);
3249 add_com ("interrupt", class_run
, interrupt_command
,
3250 _("Interrupt the execution of the debugged program.\n\
3251 If non-stop mode is enabled, interrupt only the current thread,\n\
3252 otherwise all the threads in the program are stopped. To \n\
3253 interrupt all running threads in non-stop mode, use the -a option."));
3255 c
= add_info ("registers", nofp_registers_info
, _("\
3256 List of integer registers and their contents, for selected stack frame.\n\
3257 Register name as argument means describe only that register."));
3258 add_info_alias ("r", "registers", 1);
3259 set_cmd_completer (c
, reg_or_group_completer
);
3263 c
= add_com ("lr", class_info
, nofp_registers_info
, _("\
3264 List of integer registers and their contents, for selected stack frame.\n\
3265 Register name as argument means describe only that register."));
3266 set_cmd_completer (c
, reg_or_group_completer
);
3269 c
= add_info ("all-registers", all_registers_info
, _("\
3270 List of all registers and their contents, for selected stack frame.\n\
3271 Register name as argument means describe only that register."));
3272 set_cmd_completer (c
, reg_or_group_completer
);
3274 add_info ("program", program_info
,
3275 _("Execution status of the program."));
3277 add_info ("float", float_info
,
3278 _("Print the status of the floating point unit\n"));
3280 add_info ("vector", vector_info
,
3281 _("Print the status of the vector unit\n"));
3283 add_prefix_cmd ("proc", class_info
, info_proc_cmd
,
3285 Show /proc process information about any running process.\n\
3286 Specify any process id, or use the program being debugged by default."),
3287 &info_proc_cmdlist
, "info proc ",
3288 1/*allow-unknown*/, &infolist
);
3290 add_cmd ("mappings", class_info
, info_proc_cmd_mappings
, _("\
3291 List of mapped memory regions."),
3292 &info_proc_cmdlist
);
3294 add_cmd ("stat", class_info
, info_proc_cmd_stat
, _("\
3295 List process info from /proc/PID/stat."),
3296 &info_proc_cmdlist
);
3298 add_cmd ("status", class_info
, info_proc_cmd_status
, _("\
3299 List process info from /proc/PID/status."),
3300 &info_proc_cmdlist
);
3302 add_cmd ("cwd", class_info
, info_proc_cmd_cwd
, _("\
3303 List current working directory of the process."),
3304 &info_proc_cmdlist
);
3306 add_cmd ("cmdline", class_info
, info_proc_cmd_cmdline
, _("\
3307 List command line arguments of the process."),
3308 &info_proc_cmdlist
);
3310 add_cmd ("exe", class_info
, info_proc_cmd_exe
, _("\
3311 List absolute filename for executable of the process."),
3312 &info_proc_cmdlist
);
3314 add_cmd ("all", class_info
, info_proc_cmd_all
, _("\
3315 List all available /proc info."),
3316 &info_proc_cmdlist
);