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
)
415 /* Be sure we own the terminal in case write operations are performed. */
416 target_terminal_ours ();
418 /* If the target hasn't taken care of this already, do it now.
419 Targets which need to access registers during to_open,
420 to_create_inferior, or to_attach should do it earlier; but many
422 target_find_description ();
424 /* Now that we know the register layout, retrieve current PC. But
425 if the PC is unavailable (e.g., we're opening a core file with
426 missing registers info), ignore it. */
430 stop_pc
= regcache_read_pc (get_current_regcache ());
432 CATCH (ex
, RETURN_MASK_ERROR
)
434 if (ex
.error
!= NOT_AVAILABLE_ERROR
)
435 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
)
1674 func
= read_var_value (a
->function
, get_current_frame ());
1677 /* print_return_value can throw an exception in some
1678 circumstances. We need to catch this so that we still
1679 delete the breakpoint. */
1680 print_return_value (func
, value_type
);
1682 CATCH (ex
, RETURN_MASK_ALL
)
1684 exception_print (gdb_stdout
, ex
);
1690 /* We suppress normal call of normal_stop observer and do it
1691 here so that the *stopped notification includes the return
1693 if (bs
!= NULL
&& tp
->control
.proceed_to_finish
)
1694 observer_notify_normal_stop (bs
, 1 /* print frame */);
1697 delete_breakpoint (a
->breakpoint
);
1698 delete_longjmp_breakpoint (a
->thread
);
1702 finish_command_continuation_free_arg (void *arg
)
1707 /* finish_backward -- helper function for finish_command. */
1710 finish_backward (struct symbol
*function
)
1712 struct symtab_and_line sal
;
1713 struct thread_info
*tp
= inferior_thread ();
1715 CORE_ADDR func_addr
;
1717 pc
= get_frame_pc (get_current_frame ());
1719 if (find_pc_partial_function (pc
, NULL
, &func_addr
, NULL
) == 0)
1720 error (_("Cannot find bounds of current function"));
1722 sal
= find_pc_line (func_addr
, 0);
1724 tp
->control
.proceed_to_finish
= 1;
1725 /* Special case: if we're sitting at the function entry point,
1726 then all we need to do is take a reverse singlestep. We
1727 don't need to set a breakpoint, and indeed it would do us
1730 Note that this can only happen at frame #0, since there's
1731 no way that a function up the stack can have a return address
1732 that's equal to its entry point. */
1736 struct frame_info
*frame
= get_selected_frame (NULL
);
1737 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1738 struct symtab_and_line sr_sal
;
1740 /* Set a step-resume at the function's entry point. Once that's
1741 hit, we'll do one more step backwards. */
1744 sr_sal
.pspace
= get_frame_program_space (frame
);
1745 insert_step_resume_breakpoint_at_sal (gdbarch
,
1746 sr_sal
, null_frame_id
);
1748 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
, 0);
1752 /* We're almost there -- we just need to back up by one more
1754 tp
->control
.step_range_start
= tp
->control
.step_range_end
= 1;
1755 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
, 1);
1759 /* finish_forward -- helper function for finish_command. */
1762 finish_forward (struct symbol
*function
, struct frame_info
*frame
)
1764 struct frame_id frame_id
= get_frame_id (frame
);
1765 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1766 struct symtab_and_line sal
;
1767 struct thread_info
*tp
= inferior_thread ();
1768 struct breakpoint
*breakpoint
;
1769 struct cleanup
*old_chain
;
1770 struct finish_command_continuation_args
*cargs
;
1771 int thread
= tp
->num
;
1773 sal
= find_pc_line (get_frame_pc (frame
), 0);
1774 sal
.pc
= get_frame_pc (frame
);
1776 breakpoint
= set_momentary_breakpoint (gdbarch
, sal
,
1777 get_stack_frame_id (frame
),
1780 /* set_momentary_breakpoint invalidates FRAME. */
1783 old_chain
= make_cleanup_delete_breakpoint (breakpoint
);
1785 set_longjmp_breakpoint (tp
, frame_id
);
1786 make_cleanup (delete_longjmp_breakpoint_cleanup
, &thread
);
1788 /* We want stop_registers, please... */
1789 tp
->control
.proceed_to_finish
= 1;
1790 cargs
= xmalloc (sizeof (*cargs
));
1792 cargs
->thread
= thread
;
1793 cargs
->breakpoint
= breakpoint
;
1794 cargs
->function
= function
;
1795 add_continuation (tp
, finish_command_continuation
, cargs
,
1796 finish_command_continuation_free_arg
);
1797 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
, 0);
1799 discard_cleanups (old_chain
);
1800 if (!target_can_async_p ())
1801 do_all_continuations (0);
1804 /* "finish": Set a temporary breakpoint at the place the selected
1805 frame will return to, then continue. */
1808 finish_command (char *arg
, int from_tty
)
1810 struct frame_info
*frame
;
1811 struct symbol
*function
;
1813 struct cleanup
*args_chain
;
1816 ensure_not_tfind_mode ();
1817 ensure_valid_thread ();
1818 ensure_not_running ();
1820 /* Find out whether we must run in the background. */
1821 arg
= strip_bg_char (arg
, &async_exec
);
1822 args_chain
= make_cleanup (xfree
, arg
);
1824 prepare_execution_command (¤t_target
, async_exec
);
1827 error (_("The \"finish\" command does not take any arguments."));
1829 /* Done with ARGS. */
1830 do_cleanups (args_chain
);
1832 frame
= get_prev_frame (get_selected_frame (_("No selected frame.")));
1834 error (_("\"finish\" not meaningful in the outermost frame."));
1836 clear_proceed_status (0);
1838 /* Finishing from an inline frame is completely different. We don't
1839 try to show the "return value" - no way to locate it. So we do
1840 not need a completion. */
1841 if (get_frame_type (get_selected_frame (_("No selected frame.")))
1844 /* Claim we are stepping in the calling frame. An empty step
1845 range means that we will stop once we aren't in a function
1846 called by that frame. We don't use the magic "1" value for
1847 step_range_end, because then infrun will think this is nexti,
1848 and not step over the rest of this inlined function call. */
1849 struct thread_info
*tp
= inferior_thread ();
1850 struct symtab_and_line empty_sal
;
1852 init_sal (&empty_sal
);
1853 set_step_info (frame
, empty_sal
);
1854 tp
->control
.step_range_start
= get_frame_pc (frame
);
1855 tp
->control
.step_range_end
= tp
->control
.step_range_start
;
1856 tp
->control
.step_over_calls
= STEP_OVER_ALL
;
1858 /* Print info on the selected frame, including level number but not
1862 printf_filtered (_("Run till exit from "));
1863 print_stack_frame (get_selected_frame (NULL
), 1, LOCATION
, 0);
1866 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
, 1);
1870 /* Ignore TAILCALL_FRAME type frames, they were executed already before
1871 entering THISFRAME. */
1872 while (get_frame_type (frame
) == TAILCALL_FRAME
)
1873 frame
= get_prev_frame (frame
);
1875 /* Find the function we will return from. */
1877 function
= find_pc_function (get_frame_pc (get_selected_frame (NULL
)));
1879 /* Print info on the selected frame, including level number but not
1883 if (execution_direction
== EXEC_REVERSE
)
1884 printf_filtered (_("Run back to call of "));
1887 if (function
!= NULL
&& TYPE_NO_RETURN (function
->type
)
1888 && !query (_("warning: Function %s does not return normally.\n"
1889 "Try to finish anyway? "),
1890 SYMBOL_PRINT_NAME (function
)))
1891 error (_("Not confirmed."));
1892 printf_filtered (_("Run till exit from "));
1895 print_stack_frame (get_selected_frame (NULL
), 1, LOCATION
, 0);
1898 if (execution_direction
== EXEC_REVERSE
)
1899 finish_backward (function
);
1901 finish_forward (function
, frame
);
1906 program_info (char *args
, int from_tty
)
1910 struct thread_info
*tp
;
1913 if (!target_has_execution
)
1915 printf_filtered (_("The program being debugged is not being run.\n"));
1920 ptid
= inferior_ptid
;
1923 struct target_waitstatus ws
;
1925 get_last_target_status (&ptid
, &ws
);
1928 if (ptid_equal (ptid
, null_ptid
) || is_exited (ptid
))
1929 error (_("Invalid selected thread."));
1930 else if (is_running (ptid
))
1931 error (_("Selected thread is running."));
1933 tp
= find_thread_ptid (ptid
);
1934 bs
= tp
->control
.stop_bpstat
;
1935 stat
= bpstat_num (&bs
, &num
);
1937 target_files_info ();
1938 printf_filtered (_("Program stopped at %s.\n"),
1939 paddress (target_gdbarch (), stop_pc
));
1940 if (tp
->control
.stop_step
)
1941 printf_filtered (_("It stopped after being stepped.\n"));
1944 /* There may be several breakpoints in the same place, so this
1945 isn't as strange as it seems. */
1950 printf_filtered (_("It stopped at a breakpoint "
1951 "that has since been deleted.\n"));
1954 printf_filtered (_("It stopped at breakpoint %d.\n"), num
);
1955 stat
= bpstat_num (&bs
, &num
);
1958 else if (tp
->suspend
.stop_signal
!= GDB_SIGNAL_0
)
1960 printf_filtered (_("It stopped with signal %s, %s.\n"),
1961 gdb_signal_to_name (tp
->suspend
.stop_signal
),
1962 gdb_signal_to_string (tp
->suspend
.stop_signal
));
1967 printf_filtered (_("Type \"info stack\" or \"info "
1968 "registers\" for more information.\n"));
1973 environment_info (char *var
, int from_tty
)
1977 char *val
= get_in_environ (current_inferior ()->environment
, var
);
1981 puts_filtered (var
);
1982 puts_filtered (" = ");
1983 puts_filtered (val
);
1984 puts_filtered ("\n");
1988 puts_filtered ("Environment variable \"");
1989 puts_filtered (var
);
1990 puts_filtered ("\" not defined.\n");
1995 char **vector
= environ_vector (current_inferior ()->environment
);
1999 puts_filtered (*vector
++);
2000 puts_filtered ("\n");
2006 set_environment_command (char *arg
, int from_tty
)
2008 char *p
, *val
, *var
;
2012 error_no_arg (_("environment variable and value"));
2014 /* Find seperation between variable name and value. */
2015 p
= (char *) strchr (arg
, '=');
2016 val
= (char *) strchr (arg
, ' ');
2018 if (p
!= 0 && val
!= 0)
2020 /* We have both a space and an equals. If the space is before the
2021 equals, walk forward over the spaces til we see a nonspace
2022 (possibly the equals). */
2027 /* Now if the = is after the char following the spaces,
2028 take the char following the spaces. */
2032 else if (val
!= 0 && p
== 0)
2036 error_no_arg (_("environment variable to set"));
2038 if (p
== 0 || p
[1] == 0)
2042 p
= arg
+ strlen (arg
); /* So that savestring below will work. */
2046 /* Not setting variable value to null. */
2048 while (*val
== ' ' || *val
== '\t')
2052 while (p
!= arg
&& (p
[-1] == ' ' || p
[-1] == '\t'))
2055 var
= savestring (arg
, p
- arg
);
2058 printf_filtered (_("Setting environment variable "
2059 "\"%s\" to null value.\n"),
2061 set_in_environ (current_inferior ()->environment
, var
, "");
2064 set_in_environ (current_inferior ()->environment
, var
, val
);
2069 unset_environment_command (char *var
, int from_tty
)
2073 /* If there is no argument, delete all environment variables.
2074 Ask for confirmation if reading from the terminal. */
2075 if (!from_tty
|| query (_("Delete all environment variables? ")))
2077 free_environ (current_inferior ()->environment
);
2078 current_inferior ()->environment
= make_environ ();
2082 unset_in_environ (current_inferior ()->environment
, var
);
2085 /* Handle the execution path (PATH variable). */
2087 static const char path_var_name
[] = "PATH";
2090 path_info (char *args
, int from_tty
)
2092 puts_filtered ("Executable and object file path: ");
2093 puts_filtered (get_in_environ (current_inferior ()->environment
,
2095 puts_filtered ("\n");
2098 /* Add zero or more directories to the front of the execution path. */
2101 path_command (char *dirname
, int from_tty
)
2107 env
= get_in_environ (current_inferior ()->environment
, path_var_name
);
2108 /* Can be null if path is not set. */
2111 exec_path
= xstrdup (env
);
2112 mod_path (dirname
, &exec_path
);
2113 set_in_environ (current_inferior ()->environment
, path_var_name
, exec_path
);
2116 path_info ((char *) NULL
, from_tty
);
2120 /* Print out the register NAME with value VAL, to FILE, in the default
2124 default_print_one_register_info (struct ui_file
*file
,
2128 struct type
*regtype
= value_type (val
);
2129 int print_raw_format
;
2131 fputs_filtered (name
, file
);
2132 print_spaces_filtered (15 - strlen (name
), file
);
2134 print_raw_format
= (value_entirely_available (val
)
2135 && !value_optimized_out (val
));
2137 /* If virtual format is floating, print it that way, and in raw
2139 if (TYPE_CODE (regtype
) == TYPE_CODE_FLT
2140 || TYPE_CODE (regtype
) == TYPE_CODE_DECFLOAT
)
2143 struct value_print_options opts
;
2144 const gdb_byte
*valaddr
= value_contents_for_printing (val
);
2145 enum bfd_endian byte_order
= gdbarch_byte_order (get_type_arch (regtype
));
2147 get_user_print_options (&opts
);
2151 value_contents_for_printing (val
),
2152 value_embedded_offset (val
), 0,
2153 file
, 0, val
, &opts
, current_language
);
2155 if (print_raw_format
)
2157 fprintf_filtered (file
, "\t(raw ");
2158 print_hex_chars (file
, valaddr
, TYPE_LENGTH (regtype
), byte_order
);
2159 fprintf_filtered (file
, ")");
2164 struct value_print_options opts
;
2166 /* Print the register in hex. */
2167 get_formatted_print_options (&opts
, 'x');
2170 value_contents_for_printing (val
),
2171 value_embedded_offset (val
), 0,
2172 file
, 0, val
, &opts
, current_language
);
2173 /* If not a vector register, print it also according to its
2175 if (print_raw_format
&& TYPE_VECTOR (regtype
) == 0)
2177 get_user_print_options (&opts
);
2179 fprintf_filtered (file
, "\t");
2181 value_contents_for_printing (val
),
2182 value_embedded_offset (val
), 0,
2183 file
, 0, val
, &opts
, current_language
);
2187 fprintf_filtered (file
, "\n");
2190 /* Print out the machine register regnum. If regnum is -1, print all
2191 registers (print_all == 1) or all non-float and non-vector
2192 registers (print_all == 0).
2194 For most machines, having all_registers_info() print the
2195 register(s) one per line is good enough. If a different format is
2196 required, (eg, for MIPS or Pyramid 90x, which both have lots of
2197 regs), or there is an existing convention for showing all the
2198 registers, define the architecture method PRINT_REGISTERS_INFO to
2199 provide that format. */
2202 default_print_registers_info (struct gdbarch
*gdbarch
,
2203 struct ui_file
*file
,
2204 struct frame_info
*frame
,
2205 int regnum
, int print_all
)
2208 const int numregs
= gdbarch_num_regs (gdbarch
)
2209 + gdbarch_num_pseudo_regs (gdbarch
);
2211 for (i
= 0; i
< numregs
; i
++)
2213 /* Decide between printing all regs, non-float / vector regs, or
2219 if (!gdbarch_register_reggroup_p (gdbarch
, i
, all_reggroup
))
2224 if (!gdbarch_register_reggroup_p (gdbarch
, i
, general_reggroup
))
2234 /* If the register name is empty, it is undefined for this
2235 processor, so don't display anything. */
2236 if (gdbarch_register_name (gdbarch
, i
) == NULL
2237 || *(gdbarch_register_name (gdbarch
, i
)) == '\0')
2240 default_print_one_register_info (file
,
2241 gdbarch_register_name (gdbarch
, i
),
2242 value_of_register (i
, frame
));
2247 registers_info (char *addr_exp
, int fpregs
)
2249 struct frame_info
*frame
;
2250 struct gdbarch
*gdbarch
;
2252 if (!target_has_registers
)
2253 error (_("The program has no registers now."));
2254 frame
= get_selected_frame (NULL
);
2255 gdbarch
= get_frame_arch (frame
);
2259 gdbarch_print_registers_info (gdbarch
, gdb_stdout
,
2264 while (*addr_exp
!= '\0')
2269 /* Skip leading white space. */
2270 addr_exp
= skip_spaces (addr_exp
);
2272 /* Discard any leading ``$''. Check that there is something
2273 resembling a register following it. */
2274 if (addr_exp
[0] == '$')
2276 if (isspace ((*addr_exp
)) || (*addr_exp
) == '\0')
2277 error (_("Missing register name"));
2279 /* Find the start/end of this register name/num/group. */
2281 while ((*addr_exp
) != '\0' && !isspace ((*addr_exp
)))
2285 /* Figure out what we've found and display it. */
2287 /* A register name? */
2289 int regnum
= user_reg_map_name_to_regnum (gdbarch
, start
, end
- start
);
2293 /* User registers lie completely outside of the range of
2294 normal registers. Catch them early so that the target
2296 if (regnum
>= gdbarch_num_regs (gdbarch
)
2297 + gdbarch_num_pseudo_regs (gdbarch
))
2299 struct value
*regval
= value_of_user_reg (regnum
, frame
);
2300 const char *regname
= user_reg_map_regnum_to_name (gdbarch
,
2303 /* Print in the same fashion
2304 gdbarch_print_registers_info's default
2305 implementation prints. */
2306 default_print_one_register_info (gdb_stdout
,
2311 gdbarch_print_registers_info (gdbarch
, gdb_stdout
,
2312 frame
, regnum
, fpregs
);
2317 /* A register group? */
2319 struct reggroup
*group
;
2321 for (group
= reggroup_next (gdbarch
, NULL
);
2323 group
= reggroup_next (gdbarch
, group
))
2325 /* Don't bother with a length check. Should the user
2326 enter a short register group name, go with the first
2327 group that matches. */
2328 if (strncmp (start
, reggroup_name (group
), end
- start
) == 0)
2336 regnum
< gdbarch_num_regs (gdbarch
)
2337 + gdbarch_num_pseudo_regs (gdbarch
);
2340 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, group
))
2341 gdbarch_print_registers_info (gdbarch
,
2349 /* Nothing matched. */
2350 error (_("Invalid register `%.*s'"), (int) (end
- start
), start
);
2355 all_registers_info (char *addr_exp
, int from_tty
)
2357 registers_info (addr_exp
, 1);
2361 nofp_registers_info (char *addr_exp
, int from_tty
)
2363 registers_info (addr_exp
, 0);
2367 print_vector_info (struct ui_file
*file
,
2368 struct frame_info
*frame
, const char *args
)
2370 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
2372 if (gdbarch_print_vector_info_p (gdbarch
))
2373 gdbarch_print_vector_info (gdbarch
, file
, frame
, args
);
2377 int printed_something
= 0;
2380 regnum
< gdbarch_num_regs (gdbarch
)
2381 + gdbarch_num_pseudo_regs (gdbarch
);
2384 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, vector_reggroup
))
2386 printed_something
= 1;
2387 gdbarch_print_registers_info (gdbarch
, file
, frame
, regnum
, 1);
2390 if (!printed_something
)
2391 fprintf_filtered (file
, "No vector information\n");
2396 vector_info (char *args
, int from_tty
)
2398 if (!target_has_registers
)
2399 error (_("The program has no registers now."));
2401 print_vector_info (gdb_stdout
, get_selected_frame (NULL
), args
);
2404 /* Kill the inferior process. Make us have no inferior. */
2407 kill_command (char *arg
, int from_tty
)
2409 /* FIXME: This should not really be inferior_ptid (or target_has_execution).
2410 It should be a distinct flag that indicates that a target is active, cuz
2411 some targets don't have processes! */
2413 if (ptid_equal (inferior_ptid
, null_ptid
))
2414 error (_("The program is not being run."));
2415 if (!query (_("Kill the program being debugged? ")))
2416 error (_("Not confirmed."));
2419 /* If we still have other inferiors to debug, then don't mess with
2420 with their threads. */
2421 if (!have_inferiors ())
2423 init_thread_list (); /* Destroy thread info. */
2425 /* Killing off the inferior can leave us with a core file. If
2426 so, print the state we are left in. */
2427 if (target_has_stack
)
2429 printf_filtered (_("In %s,\n"), target_longname
);
2430 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
, 1);
2433 bfd_cache_close_all ();
2436 /* Used in `attach&' command. ARG is a point to an integer
2437 representing a process id. Proceed threads of this process iff
2438 they stopped due to debugger request, and when they did, they
2439 reported a clean stop (GDB_SIGNAL_0). Do not proceed threads
2440 that have been explicitly been told to stop. */
2443 proceed_after_attach_callback (struct thread_info
*thread
,
2446 int pid
= * (int *) arg
;
2448 if (ptid_get_pid (thread
->ptid
) == pid
2449 && !is_exited (thread
->ptid
)
2450 && !is_executing (thread
->ptid
)
2451 && !thread
->stop_requested
2452 && thread
->suspend
.stop_signal
== GDB_SIGNAL_0
)
2454 switch_to_thread (thread
->ptid
);
2455 clear_proceed_status (0);
2456 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
, 0);
2463 proceed_after_attach (int pid
)
2465 /* Don't error out if the current thread is running, because
2466 there may be other stopped threads. */
2467 struct cleanup
*old_chain
;
2469 /* Backup current thread and selected frame. */
2470 old_chain
= make_cleanup_restore_current_thread ();
2472 iterate_over_threads (proceed_after_attach_callback
, &pid
);
2474 /* Restore selected ptid. */
2475 do_cleanups (old_chain
);
2478 /* attach_command --
2479 takes a program started up outside of gdb and ``attaches'' to it.
2480 This stops it cold in its tracks and allows us to start debugging it.
2481 and wait for the trace-trap that results from attaching. */
2484 attach_command_post_wait (char *args
, int from_tty
, int async_exec
)
2487 char *full_exec_path
= NULL
;
2488 struct inferior
*inferior
;
2490 inferior
= current_inferior ();
2491 inferior
->control
.stop_soon
= NO_STOP_QUIETLY
;
2493 /* If no exec file is yet known, try to determine it from the
2495 exec_file
= (char *) get_exec_file (0);
2498 exec_file
= target_pid_to_exec_file (ptid_get_pid (inferior_ptid
));
2501 /* It's possible we don't have a full path, but rather just a
2502 filename. Some targets, such as HP-UX, don't provide the
2505 Attempt to qualify the filename against the source path.
2506 (If that fails, we'll just fall back on the original
2507 filename. Not much more we can do...) */
2509 if (!source_full_path_of (exec_file
, &full_exec_path
))
2510 full_exec_path
= xstrdup (exec_file
);
2512 exec_file_attach (full_exec_path
, from_tty
);
2513 symbol_file_add_main (full_exec_path
, from_tty
);
2518 reopen_exec_file ();
2522 /* Take any necessary post-attaching actions for this platform. */
2523 target_post_attach (ptid_get_pid (inferior_ptid
));
2525 post_create_inferior (¤t_target
, from_tty
);
2529 /* The user requested an `attach&', so be sure to leave threads
2530 that didn't get a signal running. */
2532 /* Immediatelly resume all suspended threads of this inferior,
2533 and this inferior only. This should have no effect on
2534 already running threads. If a thread has been stopped with a
2535 signal, leave it be. */
2537 proceed_after_attach (inferior
->pid
);
2540 if (inferior_thread ()->suspend
.stop_signal
== GDB_SIGNAL_0
)
2542 clear_proceed_status (0);
2543 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
, 0);
2549 /* The user requested a plain `attach', so be sure to leave
2550 the inferior stopped. */
2552 if (target_can_async_p ())
2553 async_enable_stdin ();
2555 /* At least the current thread is already stopped. */
2557 /* In all-stop, by definition, all threads have to be already
2558 stopped at this point. In non-stop, however, although the
2559 selected thread is stopped, others may still be executing.
2560 Be sure to explicitly stop all threads of the process. This
2561 should have no effect on already stopped threads. */
2563 target_stop (pid_to_ptid (inferior
->pid
));
2565 /* Tell the user/frontend where we're stopped. */
2567 if (deprecated_attach_hook
)
2568 deprecated_attach_hook ();
2572 struct attach_command_continuation_args
2580 attach_command_continuation (void *args
, int err
)
2582 struct attach_command_continuation_args
*a
= args
;
2587 attach_command_post_wait (a
->args
, a
->from_tty
, a
->async_exec
);
2591 attach_command_continuation_free_args (void *args
)
2593 struct attach_command_continuation_args
*a
= args
;
2600 attach_command (char *args
, int from_tty
)
2603 struct cleanup
*args_chain
;
2604 struct target_ops
*attach_target
;
2606 dont_repeat (); /* Not for the faint of heart */
2608 if (gdbarch_has_global_solist (target_gdbarch ()))
2609 /* Don't complain if all processes share the same symbol
2612 else if (target_has_execution
)
2614 if (query (_("A program is being debugged already. Kill it? ")))
2617 error (_("Not killed."));
2620 /* Clean up any leftovers from other runs. Some other things from
2621 this function should probably be moved into target_pre_inferior. */
2622 target_pre_inferior (from_tty
);
2624 args
= strip_bg_char (args
, &async_exec
);
2625 args_chain
= make_cleanup (xfree
, args
);
2627 attach_target
= find_attach_target ();
2629 prepare_execution_command (attach_target
, async_exec
);
2631 if (non_stop
&& !attach_target
->to_supports_non_stop (attach_target
))
2632 error (_("Cannot attach to this target in non-stop mode"));
2634 attach_target
->to_attach (attach_target
, args
, from_tty
);
2635 /* to_attach should push the target, so after this point we
2636 shouldn't refer to attach_target again. */
2637 attach_target
= NULL
;
2639 /* Done with ARGS. */
2640 do_cleanups (args_chain
);
2642 /* Set up the "saved terminal modes" of the inferior
2643 based on what modes we are starting it with. */
2644 target_terminal_init ();
2646 /* Install inferior's terminal modes. This may look like a no-op,
2647 as we've just saved them above, however, this does more than
2648 restore terminal settings:
2650 - installs a SIGINT handler that forwards SIGINT to the inferior.
2651 Otherwise a Ctrl-C pressed just while waiting for the initial
2652 stop would end up as a spurious Quit.
2654 - removes stdin from the event loop, which we need if attaching
2655 in the foreground, otherwise on targets that report an initial
2656 stop on attach (which are most) we'd process input/commands
2657 while we're in the event loop waiting for that stop. That is,
2658 before the attach continuation runs and the command is really
2660 target_terminal_inferior ();
2662 /* Set up execution context to know that we should return from
2663 wait_for_inferior as soon as the target reports a stop. */
2664 init_wait_for_inferior ();
2665 clear_proceed_status (0);
2669 /* If we find that the current thread isn't stopped, explicitly
2670 do so now, because we're going to install breakpoints and
2674 /* The user requested an `attach&'; stop just one thread. */
2675 target_stop (inferior_ptid
);
2677 /* The user requested an `attach', so stop all threads of this
2679 target_stop (pid_to_ptid (ptid_get_pid (inferior_ptid
)));
2682 /* Some system don't generate traps when attaching to inferior.
2683 E.g. Mach 3 or GNU hurd. */
2684 if (!target_attach_no_wait
)
2686 struct inferior
*inferior
= current_inferior ();
2688 /* Careful here. See comments in inferior.h. Basically some
2689 OSes don't ignore SIGSTOPs on continue requests anymore. We
2690 need a way for handle_inferior_event to reset the stop_signal
2691 variable after an attach, and this is what
2692 STOP_QUIETLY_NO_SIGSTOP is for. */
2693 inferior
->control
.stop_soon
= STOP_QUIETLY_NO_SIGSTOP
;
2695 if (target_can_async_p ())
2697 /* sync_execution mode. Wait for stop. */
2698 struct attach_command_continuation_args
*a
;
2700 a
= xmalloc (sizeof (*a
));
2701 a
->args
= xstrdup (args
);
2702 a
->from_tty
= from_tty
;
2703 a
->async_exec
= async_exec
;
2704 add_inferior_continuation (attach_command_continuation
, a
,
2705 attach_command_continuation_free_args
);
2709 wait_for_inferior ();
2712 attach_command_post_wait (args
, from_tty
, async_exec
);
2715 /* We had just found out that the target was already attached to an
2716 inferior. PTID points at a thread of this new inferior, that is
2717 the most likely to be stopped right now, but not necessarily so.
2718 The new inferior is assumed to be already added to the inferior
2719 list at this point. If LEAVE_RUNNING, then leave the threads of
2720 this inferior running, except those we've explicitly seen reported
2724 notice_new_inferior (ptid_t ptid
, int leave_running
, int from_tty
)
2726 struct cleanup
* old_chain
;
2729 old_chain
= make_cleanup (null_cleanup
, NULL
);
2731 /* If in non-stop, leave threads as running as they were. If
2732 they're stopped for some reason other than us telling it to, the
2733 target reports a signal != GDB_SIGNAL_0. We don't try to
2734 resume threads with such a stop signal. */
2735 async_exec
= non_stop
;
2737 if (!ptid_equal (inferior_ptid
, null_ptid
))
2738 make_cleanup_restore_current_thread ();
2740 switch_to_thread (ptid
);
2742 /* When we "notice" a new inferior we need to do all the things we
2743 would normally do if we had just attached to it. */
2745 if (is_executing (inferior_ptid
))
2747 struct inferior
*inferior
= current_inferior ();
2749 /* We're going to install breakpoints, and poke at memory,
2750 ensure that the inferior is stopped for a moment while we do
2752 target_stop (inferior_ptid
);
2754 inferior
->control
.stop_soon
= STOP_QUIETLY_REMOTE
;
2756 /* Wait for stop before proceeding. */
2757 if (target_can_async_p ())
2759 struct attach_command_continuation_args
*a
;
2761 a
= xmalloc (sizeof (*a
));
2762 a
->args
= xstrdup ("");
2763 a
->from_tty
= from_tty
;
2764 a
->async_exec
= async_exec
;
2765 add_inferior_continuation (attach_command_continuation
, a
,
2766 attach_command_continuation_free_args
);
2768 do_cleanups (old_chain
);
2772 wait_for_inferior ();
2775 async_exec
= leave_running
;
2776 attach_command_post_wait ("" /* args */, from_tty
, async_exec
);
2778 do_cleanups (old_chain
);
2783 * takes a program previously attached to and detaches it.
2784 * The program resumes execution and will no longer stop
2785 * on signals, etc. We better not have left any breakpoints
2786 * in the program or it'll die when it hits one. For this
2787 * to work, it may be necessary for the process to have been
2788 * previously attached. It *might* work if the program was
2789 * started via the normal ptrace (PTRACE_TRACEME).
2793 detach_command (char *args
, int from_tty
)
2795 dont_repeat (); /* Not for the faint of heart. */
2797 if (ptid_equal (inferior_ptid
, null_ptid
))
2798 error (_("The program is not being run."));
2800 query_if_trace_running (from_tty
);
2802 disconnect_tracing ();
2804 target_detach (args
, from_tty
);
2806 /* If the solist is global across inferiors, don't clear it when we
2807 detach from a single inferior. */
2808 if (!gdbarch_has_global_solist (target_gdbarch ()))
2809 no_shared_libraries (NULL
, from_tty
);
2811 /* If we still have inferiors to debug, then don't mess with their
2813 if (!have_inferiors ())
2814 init_thread_list ();
2816 if (deprecated_detach_hook
)
2817 deprecated_detach_hook ();
2820 /* Disconnect from the current target without resuming it (leaving it
2821 waiting for a debugger).
2823 We'd better not have left any breakpoints in the program or the
2824 next debugger will get confused. Currently only supported for some
2825 remote targets, since the normal attach mechanisms don't work on
2826 stopped processes on some native platforms (e.g. GNU/Linux). */
2829 disconnect_command (char *args
, int from_tty
)
2831 dont_repeat (); /* Not for the faint of heart. */
2832 query_if_trace_running (from_tty
);
2833 disconnect_tracing ();
2834 target_disconnect (args
, from_tty
);
2835 no_shared_libraries (NULL
, from_tty
);
2836 init_thread_list ();
2837 if (deprecated_detach_hook
)
2838 deprecated_detach_hook ();
2842 interrupt_target_1 (int all_threads
)
2847 ptid
= minus_one_ptid
;
2849 ptid
= inferior_ptid
;
2852 /* Tag the thread as having been explicitly requested to stop, so
2853 other parts of gdb know not to resume this thread automatically,
2854 if it was stopped due to an internal event. Limit this to
2855 non-stop mode, as when debugging a multi-threaded application in
2856 all-stop mode, we will only get one stop event --- it's undefined
2857 which thread will report the event. */
2859 set_stop_requested (ptid
, 1);
2863 Stop the execution of the target while running in async mode, in
2864 the backgound. In all-stop, stop the whole process. In non-stop
2865 mode, stop the current thread only by default, or stop all threads
2866 if the `-a' switch is used. */
2869 interrupt_command (char *args
, int from_tty
)
2871 if (target_can_async_p ())
2873 int all_threads
= 0;
2875 dont_repeat (); /* Not for the faint of heart. */
2878 && startswith (args
, "-a"))
2881 if (!non_stop
&& all_threads
)
2882 error (_("-a is meaningless in all-stop mode."));
2884 interrupt_target_1 (all_threads
);
2888 /* See inferior.h. */
2891 default_print_float_info (struct gdbarch
*gdbarch
, struct ui_file
*file
,
2892 struct frame_info
*frame
, const char *args
)
2895 int printed_something
= 0;
2898 regnum
< gdbarch_num_regs (gdbarch
)
2899 + gdbarch_num_pseudo_regs (gdbarch
);
2902 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, float_reggroup
))
2904 printed_something
= 1;
2905 gdbarch_print_registers_info (gdbarch
, file
, frame
, regnum
, 1);
2908 if (!printed_something
)
2909 fprintf_filtered (file
, "No floating-point info "
2910 "available for this processor.\n");
2914 float_info (char *args
, int from_tty
)
2916 struct frame_info
*frame
;
2918 if (!target_has_registers
)
2919 error (_("The program has no registers now."));
2921 frame
= get_selected_frame (NULL
);
2922 gdbarch_print_float_info (get_frame_arch (frame
), gdb_stdout
, frame
, args
);
2926 unset_command (char *args
, int from_tty
)
2928 printf_filtered (_("\"unset\" must be followed by the "
2929 "name of an unset subcommand.\n"));
2930 help_list (unsetlist
, "unset ", all_commands
, gdb_stdout
);
2933 /* Implement `info proc' family of commands. */
2936 info_proc_cmd_1 (char *args
, enum info_proc_what what
, int from_tty
)
2938 struct gdbarch
*gdbarch
= get_current_arch ();
2940 if (!target_info_proc (args
, what
))
2942 if (gdbarch_info_proc_p (gdbarch
))
2943 gdbarch_info_proc (gdbarch
, args
, what
);
2945 error (_("Not supported on this target."));
2949 /* Implement `info proc' when given without any futher parameters. */
2952 info_proc_cmd (char *args
, int from_tty
)
2954 info_proc_cmd_1 (args
, IP_MINIMAL
, from_tty
);
2957 /* Implement `info proc mappings'. */
2960 info_proc_cmd_mappings (char *args
, int from_tty
)
2962 info_proc_cmd_1 (args
, IP_MAPPINGS
, from_tty
);
2965 /* Implement `info proc stat'. */
2968 info_proc_cmd_stat (char *args
, int from_tty
)
2970 info_proc_cmd_1 (args
, IP_STAT
, from_tty
);
2973 /* Implement `info proc status'. */
2976 info_proc_cmd_status (char *args
, int from_tty
)
2978 info_proc_cmd_1 (args
, IP_STATUS
, from_tty
);
2981 /* Implement `info proc cwd'. */
2984 info_proc_cmd_cwd (char *args
, int from_tty
)
2986 info_proc_cmd_1 (args
, IP_CWD
, from_tty
);
2989 /* Implement `info proc cmdline'. */
2992 info_proc_cmd_cmdline (char *args
, int from_tty
)
2994 info_proc_cmd_1 (args
, IP_CMDLINE
, from_tty
);
2997 /* Implement `info proc exe'. */
3000 info_proc_cmd_exe (char *args
, int from_tty
)
3002 info_proc_cmd_1 (args
, IP_EXE
, from_tty
);
3005 /* Implement `info proc all'. */
3008 info_proc_cmd_all (char *args
, int from_tty
)
3010 info_proc_cmd_1 (args
, IP_ALL
, from_tty
);
3014 _initialize_infcmd (void)
3016 static struct cmd_list_element
*info_proc_cmdlist
;
3017 struct cmd_list_element
*c
= NULL
;
3018 const char *cmd_name
;
3020 /* Add the filename of the terminal connected to inferior I/O. */
3021 add_setshow_filename_cmd ("inferior-tty", class_run
,
3022 &inferior_io_terminal_scratch
, _("\
3023 Set terminal for future runs of program being debugged."), _("\
3024 Show terminal for future runs of program being debugged."), _("\
3025 Usage: set inferior-tty /dev/pts/1"),
3026 set_inferior_tty_command
,
3027 show_inferior_tty_command
,
3028 &setlist
, &showlist
);
3029 add_com_alias ("tty", "set inferior-tty", class_alias
, 0);
3032 add_setshow_string_noescape_cmd (cmd_name
, class_run
,
3033 &inferior_args_scratch
, _("\
3034 Set argument list to give program being debugged when it is started."), _("\
3035 Show argument list to give program being debugged when it is started."), _("\
3036 Follow this command with any number of args, to be passed to the program."),
3039 &setlist
, &showlist
);
3040 c
= lookup_cmd (&cmd_name
, setlist
, "", -1, 1);
3041 gdb_assert (c
!= NULL
);
3042 set_cmd_completer (c
, filename_completer
);
3044 c
= add_cmd ("environment", no_class
, environment_info
, _("\
3045 The environment to give the program, or one variable's value.\n\
3046 With an argument VAR, prints the value of environment variable VAR to\n\
3047 give the program being debugged. With no arguments, prints the entire\n\
3048 environment to be given to the program."), &showlist
);
3049 set_cmd_completer (c
, noop_completer
);
3051 add_prefix_cmd ("unset", no_class
, unset_command
,
3052 _("Complement to certain \"set\" commands."),
3053 &unsetlist
, "unset ", 0, &cmdlist
);
3055 c
= add_cmd ("environment", class_run
, unset_environment_command
, _("\
3056 Cancel environment variable VAR for the program.\n\
3057 This does not affect the program until the next \"run\" command."),
3059 set_cmd_completer (c
, noop_completer
);
3061 c
= add_cmd ("environment", class_run
, set_environment_command
, _("\
3062 Set environment variable value to give the program.\n\
3063 Arguments are VAR VALUE where VAR is variable name and VALUE is value.\n\
3064 VALUES of environment variables are uninterpreted strings.\n\
3065 This does not affect the program until the next \"run\" command."),
3067 set_cmd_completer (c
, noop_completer
);
3069 c
= add_com ("path", class_files
, path_command
, _("\
3070 Add directory DIR(s) to beginning of search path for object files.\n\
3071 $cwd in the path means the current working directory.\n\
3072 This path is equivalent to the $PATH shell variable. It is a list of\n\
3073 directories, separated by colons. These directories are searched to find\n\
3074 fully linked executable files and separately compiled object files as \
3076 set_cmd_completer (c
, filename_completer
);
3078 c
= add_cmd ("paths", no_class
, path_info
, _("\
3079 Current search path for finding object files.\n\
3080 $cwd in the path means the current working directory.\n\
3081 This path is equivalent to the $PATH shell variable. It is a list of\n\
3082 directories, separated by colons. These directories are searched to find\n\
3083 fully linked executable files and separately compiled object files as \
3086 set_cmd_completer (c
, noop_completer
);
3088 add_prefix_cmd ("kill", class_run
, kill_command
,
3089 _("Kill execution of program being debugged."),
3090 &killlist
, "kill ", 0, &cmdlist
);
3092 add_com ("attach", class_run
, attach_command
, _("\
3093 Attach to a process or file outside of GDB.\n\
3094 This command attaches to another target, of the same type as your last\n\
3095 \"target\" command (\"info files\" will show your target stack).\n\
3096 The command may take as argument a process id or a device file.\n\
3097 For a process id, you must have permission to send the process a signal,\n\
3098 and it must have the same effective uid as the debugger.\n\
3099 When using \"attach\" with a process id, the debugger finds the\n\
3100 program running in the process, looking first in the current working\n\
3101 directory, or (if not found there) using the source file search path\n\
3102 (see the \"directory\" command). You can also use the \"file\" command\n\
3103 to specify the program, and to load its symbol table."));
3105 add_prefix_cmd ("detach", class_run
, detach_command
, _("\
3106 Detach a process or file previously attached.\n\
3107 If a process, it is no longer traced, and it continues its execution. If\n\
3108 you were debugging a file, the file is closed and gdb no longer accesses it."),
3109 &detachlist
, "detach ", 0, &cmdlist
);
3111 add_com ("disconnect", class_run
, disconnect_command
, _("\
3112 Disconnect from a target.\n\
3113 The target will wait for another debugger to connect. Not available for\n\
3116 c
= add_com ("signal", class_run
, signal_command
, _("\
3117 Continue program with the specified signal.\n\
3118 Usage: signal SIGNAL\n\
3119 The SIGNAL argument is processed the same as the handle command.\n\
3121 An argument of \"0\" means continue the program without sending it a signal.\n\
3122 This is useful in cases where the program stopped because of a signal,\n\
3123 and you want to resume the program while discarding the signal.\n\
3125 In a multi-threaded program the signal is delivered to, or discarded from,\n\
3126 the current thread only."));
3127 set_cmd_completer (c
, signal_completer
);
3129 c
= add_com ("queue-signal", class_run
, queue_signal_command
, _("\
3130 Queue a signal to be delivered to the current thread when it is resumed.\n\
3131 Usage: queue-signal SIGNAL\n\
3132 The SIGNAL argument is processed the same as the handle command.\n\
3133 It is an error if the handling state of SIGNAL is \"nopass\".\n\
3135 An argument of \"0\" means remove any currently queued signal from\n\
3136 the current thread. This is useful in cases where the program stopped\n\
3137 because of a signal, and you want to resume it while discarding the signal.\n\
3139 In a multi-threaded program the signal is queued with, or discarded from,\n\
3140 the current thread only."));
3141 set_cmd_completer (c
, signal_completer
);
3143 add_com ("stepi", class_run
, stepi_command
, _("\
3144 Step one instruction exactly.\n\
3146 Argument N means step N times (or till program stops for another \
3148 add_com_alias ("si", "stepi", class_alias
, 0);
3150 add_com ("nexti", class_run
, nexti_command
, _("\
3151 Step one instruction, but proceed through subroutine calls.\n\
3153 Argument N means step N times (or till program stops for another \
3155 add_com_alias ("ni", "nexti", class_alias
, 0);
3157 add_com ("finish", class_run
, finish_command
, _("\
3158 Execute until selected stack frame returns.\n\
3160 Upon return, the value returned is printed and put in the value history."));
3161 add_com_alias ("fin", "finish", class_run
, 1);
3163 add_com ("next", class_run
, next_command
, _("\
3164 Step program, proceeding through subroutine calls.\n\
3166 Unlike \"step\", if the current source line calls a subroutine,\n\
3167 this command does not enter the subroutine, but instead steps over\n\
3168 the call, in effect treating it as a single source line."));
3169 add_com_alias ("n", "next", class_run
, 1);
3171 add_com_alias ("S", "next", class_run
, 1);
3173 add_com ("step", class_run
, step_command
, _("\
3174 Step program until it reaches a different source line.\n\
3176 Argument N means step N times (or till program stops for another \
3178 add_com_alias ("s", "step", class_run
, 1);
3180 c
= add_com ("until", class_run
, until_command
, _("\
3181 Execute until the program reaches a source line greater than the current\n\
3182 or a specified location (same args as break command) within the current \
3184 set_cmd_completer (c
, location_completer
);
3185 add_com_alias ("u", "until", class_run
, 1);
3187 c
= add_com ("advance", class_run
, advance_command
, _("\
3188 Continue the program up to the given location (same form as args for break \
3190 Execution will also stop upon exit from the current stack frame."));
3191 set_cmd_completer (c
, location_completer
);
3193 c
= add_com ("jump", class_run
, jump_command
, _("\
3194 Continue program being debugged at specified line or address.\n\
3195 Usage: jump <location>\n\
3196 Give as argument either LINENUM or *ADDR, where ADDR is an expression\n\
3197 for an address to start at."));
3198 set_cmd_completer (c
, location_completer
);
3199 add_com_alias ("j", "jump", class_run
, 1);
3203 c
= add_com ("go", class_run
, go_command
, _("\
3204 Usage: go <location>\n\
3205 Continue program being debugged, stopping at specified line or \n\
3207 Give as argument either LINENUM or *ADDR, where ADDR is an \n\
3208 expression for an address to start at.\n\
3209 This command is a combination of tbreak and jump."));
3210 set_cmd_completer (c
, location_completer
);
3214 add_com_alias ("g", "go", class_run
, 1);
3216 add_com ("continue", class_run
, continue_command
, _("\
3217 Continue program being debugged, after signal or breakpoint.\n\
3218 Usage: continue [N]\n\
3219 If proceeding from breakpoint, a number N may be used as an argument,\n\
3220 which means to set the ignore count of that breakpoint to N - 1 (so that\n\
3221 the breakpoint won't break until the Nth time it is reached).\n\
3223 If non-stop mode is enabled, continue only the current thread,\n\
3224 otherwise all the threads in the program are continued. To \n\
3225 continue all stopped threads in non-stop mode, use the -a option.\n\
3226 Specifying -a and an ignore count simultaneously is an error."));
3227 add_com_alias ("c", "cont", class_run
, 1);
3228 add_com_alias ("fg", "cont", class_run
, 1);
3230 c
= add_com ("run", class_run
, run_command
, _("\
3231 Start debugged program. You may specify arguments to give it.\n\
3232 Args may include \"*\", or \"[...]\"; they are expanded using \"sh\".\n\
3233 Input and output redirection with \">\", \"<\", or \">>\" are also \
3235 With no arguments, uses arguments last specified (with \"run\" \
3236 or \"set args\").\n\
3237 To cancel previous arguments and run with no arguments,\n\
3238 use \"set args\" without arguments."));
3239 set_cmd_completer (c
, filename_completer
);
3240 add_com_alias ("r", "run", class_run
, 1);
3242 add_com ("R", class_run
, run_no_args_command
,
3243 _("Start debugged program with no arguments."));
3245 c
= add_com ("start", class_run
, start_command
, _("\
3246 Run the debugged program until the beginning of the main procedure.\n\
3247 You may specify arguments to give to your program, just as with the\n\
3248 \"run\" command."));
3249 set_cmd_completer (c
, filename_completer
);
3251 add_com ("interrupt", class_run
, interrupt_command
,
3252 _("Interrupt the execution of the debugged program.\n\
3253 If non-stop mode is enabled, interrupt only the current thread,\n\
3254 otherwise all the threads in the program are stopped. To \n\
3255 interrupt all running threads in non-stop mode, use the -a option."));
3257 c
= add_info ("registers", nofp_registers_info
, _("\
3258 List of integer registers and their contents, for selected stack frame.\n\
3259 Register name as argument means describe only that register."));
3260 add_info_alias ("r", "registers", 1);
3261 set_cmd_completer (c
, reg_or_group_completer
);
3265 c
= add_com ("lr", class_info
, nofp_registers_info
, _("\
3266 List of integer registers and their contents, for selected stack frame.\n\
3267 Register name as argument means describe only that register."));
3268 set_cmd_completer (c
, reg_or_group_completer
);
3271 c
= add_info ("all-registers", all_registers_info
, _("\
3272 List of all registers and their contents, for selected stack frame.\n\
3273 Register name as argument means describe only that register."));
3274 set_cmd_completer (c
, reg_or_group_completer
);
3276 add_info ("program", program_info
,
3277 _("Execution status of the program."));
3279 add_info ("float", float_info
,
3280 _("Print the status of the floating point unit\n"));
3282 add_info ("vector", vector_info
,
3283 _("Print the status of the vector unit\n"));
3285 add_prefix_cmd ("proc", class_info
, info_proc_cmd
,
3287 Show /proc process information about any running process.\n\
3288 Specify any process id, or use the program being debugged by default."),
3289 &info_proc_cmdlist
, "info proc ",
3290 1/*allow-unknown*/, &infolist
);
3292 add_cmd ("mappings", class_info
, info_proc_cmd_mappings
, _("\
3293 List of mapped memory regions."),
3294 &info_proc_cmdlist
);
3296 add_cmd ("stat", class_info
, info_proc_cmd_stat
, _("\
3297 List process info from /proc/PID/stat."),
3298 &info_proc_cmdlist
);
3300 add_cmd ("status", class_info
, info_proc_cmd_status
, _("\
3301 List process info from /proc/PID/status."),
3302 &info_proc_cmdlist
);
3304 add_cmd ("cwd", class_info
, info_proc_cmd_cwd
, _("\
3305 List current working directory of the process."),
3306 &info_proc_cmdlist
);
3308 add_cmd ("cmdline", class_info
, info_proc_cmd_cmdline
, _("\
3309 List command line arguments of the process."),
3310 &info_proc_cmdlist
);
3312 add_cmd ("exe", class_info
, info_proc_cmd_exe
, _("\
3313 List absolute filename for executable of the process."),
3314 &info_proc_cmdlist
);
3316 add_cmd ("all", class_info
, info_proc_cmd_all
, _("\
3317 List all available /proc info."),
3318 &info_proc_cmdlist
);