1 /* Memory-access and commands for "inferior" process, for GDB.
3 Copyright (C) 1986-2012 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"
23 #include "gdb_string.h"
37 #include "completer.h"
39 #include "event-top.h"
40 #include "parser-defs.h"
42 #include "reggroups.h"
46 #include "gdb_assert.h"
48 #include "target-descriptions.h"
49 #include "user-regs.h"
50 #include "exceptions.h"
51 #include "cli/cli-decode.h"
52 #include "gdbthread.h"
54 #include "inline-frame.h"
55 #include "tracepoint.h"
57 #include "continuations.h"
60 /* Functions exported for general use, in inferior.h: */
62 void all_registers_info (char *, int);
64 void registers_info (char *, int);
66 void nexti_command (char *, int);
68 void stepi_command (char *, int);
70 void continue_command (char *, int);
72 void interrupt_target_command (char *args
, int from_tty
);
74 /* Local functions: */
76 static void nofp_registers_info (char *, int);
78 static void print_return_value (struct value
*function
,
79 struct type
*value_type
);
81 static void until_next_command (int);
83 static void until_command (char *, int);
85 static void path_info (char *, int);
87 static void path_command (char *, int);
89 static void unset_command (char *, int);
91 static void float_info (char *, int);
93 static void disconnect_command (char *, int);
95 static void unset_environment_command (char *, int);
97 static void set_environment_command (char *, int);
99 static void environment_info (char *, int);
101 static void program_info (char *, int);
103 static void finish_command (char *, int);
105 static void signal_command (char *, int);
107 static void jump_command (char *, int);
109 static void step_1 (int, int, char *);
110 static void step_once (int skip_subroutines
, int single_inst
,
111 int count
, int thread
);
113 static void next_command (char *, int);
115 static void step_command (char *, int);
117 static void run_command (char *, int);
119 static void run_no_args_command (char *args
, int from_tty
);
121 static void go_command (char *line_no
, int from_tty
);
123 static int strip_bg_char (char **);
125 void _initialize_infcmd (void);
127 #define ERROR_NO_INFERIOR \
128 if (!target_has_execution) error (_("The program is not being run."));
130 /* Scratch area where string containing arguments to give to the
131 program will be stored by 'set args'. As soon as anything is
132 stored, notice_args_set will move it into per-inferior storage.
133 Arguments are separated by spaces. Empty string (pointer to '\0')
136 static char *inferior_args_scratch
;
138 /* Scratch area where 'set inferior-tty' will store user-provided value.
139 We'll immediate copy it into per-inferior storage. */
141 static char *inferior_io_terminal_scratch
;
143 /* Pid of our debugged inferior, or 0 if no inferior now.
144 Since various parts of infrun.c test this to see whether there is a program
145 being debugged it should be nonzero (currently 3 is used) for remote
148 ptid_t inferior_ptid
;
150 /* Address at which inferior stopped. */
154 /* Flag indicating that a command has proceeded the inferior past the
155 current breakpoint. */
157 int breakpoint_proceeded
;
159 /* Nonzero if stopped due to completion of a stack dummy routine. */
161 enum stop_stack_kind stop_stack_dummy
;
163 /* Nonzero if stopped due to a random (unexpected) signal in inferior
166 int stopped_by_random_signal
;
169 /* Accessor routines. */
171 /* Set the io terminal for the current inferior. Ownership of
172 TERMINAL_NAME is not transferred. */
175 set_inferior_io_terminal (const char *terminal_name
)
177 xfree (current_inferior ()->terminal
);
178 current_inferior ()->terminal
= terminal_name
? xstrdup (terminal_name
) : 0;
182 get_inferior_io_terminal (void)
184 return current_inferior ()->terminal
;
188 set_inferior_tty_command (char *args
, int from_tty
,
189 struct cmd_list_element
*c
)
191 /* CLI has assigned the user-provided value to inferior_io_terminal_scratch.
192 Now route it to current inferior. */
193 set_inferior_io_terminal (inferior_io_terminal_scratch
);
197 show_inferior_tty_command (struct ui_file
*file
, int from_tty
,
198 struct cmd_list_element
*c
, const char *value
)
200 /* Note that we ignore the passed-in value in favor of computing it
202 const char *inferior_io_terminal
= get_inferior_io_terminal ();
204 if (inferior_io_terminal
== NULL
)
205 inferior_io_terminal
= "";
206 fprintf_filtered (gdb_stdout
,
207 _("Terminal for future runs of program being debugged "
208 "is \"%s\".\n"), inferior_io_terminal
);
212 get_inferior_args (void)
214 if (current_inferior ()->argc
!= 0)
218 n
= construct_inferior_arguments (current_inferior ()->argc
,
219 current_inferior ()->argv
);
220 set_inferior_args (n
);
224 if (current_inferior ()->args
== NULL
)
225 current_inferior ()->args
= xstrdup ("");
227 return current_inferior ()->args
;
230 /* Set the arguments for the current inferior. Ownership of
231 NEWARGS is not transferred. */
234 set_inferior_args (char *newargs
)
236 xfree (current_inferior ()->args
);
237 current_inferior ()->args
= newargs
? xstrdup (newargs
) : NULL
;
238 current_inferior ()->argc
= 0;
239 current_inferior ()->argv
= 0;
243 set_inferior_args_vector (int argc
, char **argv
)
245 current_inferior ()->argc
= argc
;
246 current_inferior ()->argv
= argv
;
249 /* Notice when `set args' is run. */
251 set_args_command (char *args
, int from_tty
, struct cmd_list_element
*c
)
253 /* CLI has assigned the user-provided value to inferior_args_scratch.
254 Now route it to current inferior. */
255 set_inferior_args (inferior_args_scratch
);
258 /* Notice when `show args' is run. */
260 show_args_command (struct ui_file
*file
, int from_tty
,
261 struct cmd_list_element
*c
, const char *value
)
263 /* Note that we ignore the passed-in value in favor of computing it
265 deprecated_show_value_hack (file
, from_tty
, c
, get_inferior_args ());
269 /* Compute command-line string given argument vector. This does the
270 same shell processing as fork_inferior. */
272 construct_inferior_arguments (int argc
, char **argv
)
276 if (STARTUP_WITH_SHELL
)
279 /* This holds all the characters considered special to the
281 char *special
= "\"!&*|[]{}<>?`~^=;, \t\n";
282 const char quote
= '"';
284 /* This holds all the characters considered special to the
285 typical Unix shells. We include `^' because the SunOS
286 /bin/sh treats it as a synonym for `|'. */
287 char *special
= "\"!#$&*()\\|[]{}<>?'`~^; \t\n";
288 const char quote
= '\'';
294 /* We over-compute the size. It shouldn't matter. */
295 for (i
= 0; i
< argc
; ++i
)
296 length
+= 3 * strlen (argv
[i
]) + 1 + 2 * (argv
[i
][0] == '\0');
298 result
= (char *) xmalloc (length
);
301 for (i
= 0; i
< argc
; ++i
)
306 /* Need to handle empty arguments specially. */
307 if (argv
[i
][0] == '\0')
317 if (strpbrk (argv
[i
], special
))
323 for (cp
= argv
[i
]; *cp
; ++cp
)
327 /* A newline cannot be quoted with a backslash (it
328 just disappears), only by putting it inside
339 if (strchr (special
, *cp
) != NULL
)
355 /* In this case we can't handle arguments that contain spaces,
356 tabs, or newlines -- see breakup_args(). */
360 for (i
= 0; i
< argc
; ++i
)
362 char *cp
= strchr (argv
[i
], ' ');
364 cp
= strchr (argv
[i
], '\t');
366 cp
= strchr (argv
[i
], '\n');
368 error (_("can't handle command-line "
369 "argument containing whitespace"));
370 length
+= strlen (argv
[i
]) + 1;
373 result
= (char *) xmalloc (length
);
375 for (i
= 0; i
< argc
; ++i
)
378 strcat (result
, " ");
379 strcat (result
, argv
[i
]);
387 /* This function detects whether or not a '&' character (indicating
388 background execution) has been added as *the last* of the arguments ARGS
389 of a command. If it has, it removes it and returns 1. Otherwise it
390 does nothing and returns 0. */
392 strip_bg_char (char **args
)
396 p
= strchr (*args
, '&');
400 if (p
== (*args
+ strlen (*args
) - 1))
402 if (strlen (*args
) > 1)
406 while (*p
== ' ' || *p
== '\t');
417 /* Common actions to take after creating any sort of inferior, by any
418 means (running, attaching, connecting, et cetera). The target
419 should be stopped. */
422 post_create_inferior (struct target_ops
*target
, int from_tty
)
424 volatile struct gdb_exception ex
;
426 /* Be sure we own the terminal in case write operations are performed. */
427 target_terminal_ours ();
429 /* If the target hasn't taken care of this already, do it now.
430 Targets which need to access registers during to_open,
431 to_create_inferior, or to_attach should do it earlier; but many
433 target_find_description ();
435 /* Now that we know the register layout, retrieve current PC. But
436 if the PC is unavailable (e.g., we're opening a core file with
437 missing registers info), ignore it. */
439 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
441 stop_pc
= regcache_read_pc (get_current_regcache ());
443 if (ex
.reason
< 0 && ex
.error
!= NOT_AVAILABLE_ERROR
)
444 throw_exception (ex
);
448 const unsigned solib_add_generation
449 = current_program_space
->solib_add_generation
;
451 /* Create the hooks to handle shared library load and unload
453 #ifdef SOLIB_CREATE_INFERIOR_HOOK
454 SOLIB_CREATE_INFERIOR_HOOK (PIDGET (inferior_ptid
));
456 solib_create_inferior_hook (from_tty
);
459 if (current_program_space
->solib_add_generation
== solib_add_generation
)
461 /* The platform-specific hook should load initial shared libraries,
462 but didn't. FROM_TTY will be incorrectly 0 but such solib
463 targets should be fixed anyway. Call it only after the solib
464 target has been initialized by solib_create_inferior_hook. */
467 warning (_("platform-specific solib_create_inferior_hook did "
468 "not load initial shared libraries."));
470 /* If the solist is global across processes, there's no need to
472 if (!gdbarch_has_global_solist (target_gdbarch ()))
475 SOLIB_ADD (NULL
, 0, target
, auto_solib_add
);
477 solib_add (NULL
, 0, target
, auto_solib_add
);
483 /* If the user sets watchpoints before execution having started,
484 then she gets software watchpoints, because GDB can't know which
485 target will end up being pushed, or if it supports hardware
486 watchpoints or not. breakpoint_re_set takes care of promoting
487 watchpoints to hardware watchpoints if possible, however, if this
488 new inferior doesn't load shared libraries or we don't pull in
489 symbols from any other source on this target/arch,
490 breakpoint_re_set is never called. Call it now so that software
491 watchpoints get a chance to be promoted to hardware watchpoints
492 if the now pushed target supports hardware watchpoints. */
493 breakpoint_re_set ();
495 observer_notify_inferior_created (target
, from_tty
);
498 /* Kill the inferior if already running. This function is designed
499 to be called when we are about to start the execution of the program
500 from the beginning. Ask the user to confirm that he wants to restart
501 the program being debugged when FROM_TTY is non-null. */
504 kill_if_already_running (int from_tty
)
506 if (! ptid_equal (inferior_ptid
, null_ptid
) && target_has_execution
)
508 /* Bail out before killing the program if we will not be able to
510 target_require_runnable ();
513 && !query (_("The program being debugged has been started already.\n\
514 Start it from the beginning? ")))
515 error (_("Program not restarted."));
520 /* Implement the "run" command. If TBREAK_AT_MAIN is set, then insert
521 a temporary breakpoint at the begining of the main program before
522 running the program. */
525 run_command_1 (char *args
, int from_tty
, int tbreak_at_main
)
528 struct cleanup
*old_chain
;
530 struct ui_out
*uiout
= current_uiout
;
534 kill_if_already_running (from_tty
);
536 init_wait_for_inferior ();
537 clear_breakpoint_hit_counts ();
539 /* Clean up any leftovers from other runs. Some other things from
540 this function should probably be moved into target_pre_inferior. */
541 target_pre_inferior (from_tty
);
543 /* The comment here used to read, "The exec file is re-read every
544 time we do a generic_mourn_inferior, so we just have to worry
545 about the symbol file." The `generic_mourn_inferior' function
546 gets called whenever the program exits. However, suppose the
547 program exits, and *then* the executable file changes? We need
548 to check again here. Since reopen_exec_file doesn't do anything
549 if the timestamp hasn't changed, I don't see the harm. */
553 /* Insert the temporary breakpoint if a location was specified. */
555 tbreak_command (main_name (), 0);
557 exec_file
= (char *) get_exec_file (0);
559 if (non_stop
&& !target_supports_non_stop ())
560 error (_("The target does not support running in non-stop mode."));
562 /* We keep symbols from add-symbol-file, on the grounds that the
563 user might want to add some symbols before running the program
564 (right?). But sometimes (dynamic loading where the user manually
565 introduces the new symbols with add-symbol-file), the code which
566 the symbols describe does not persist between runs. Currently
567 the user has to manually nuke all symbols between runs if they
568 want them to go away (PR 2207). This is probably reasonable. */
572 if (target_can_async_p ())
573 async_disable_stdin ();
577 int async_exec
= strip_bg_char (&args
);
579 /* If we get a request for running in the bg but the target
580 doesn't support it, error out. */
581 if (async_exec
&& !target_can_async_p ())
582 error (_("Asynchronous execution not supported on this target."));
584 /* If we don't get a request of running in the bg, then we need
585 to simulate synchronous (fg) execution. */
586 if (!async_exec
&& target_can_async_p ())
588 /* Simulate synchronous execution. */
589 async_disable_stdin ();
592 /* If there were other args, beside '&', process them. */
594 set_inferior_args (args
);
599 ui_out_field_string (uiout
, NULL
, "Starting program");
600 ui_out_text (uiout
, ": ");
602 ui_out_field_string (uiout
, "execfile", exec_file
);
603 ui_out_spaces (uiout
, 1);
604 /* We call get_inferior_args() because we might need to compute
606 ui_out_field_string (uiout
, "infargs", get_inferior_args ());
607 ui_out_text (uiout
, "\n");
608 ui_out_flush (uiout
);
611 /* We call get_inferior_args() because we might need to compute
613 target_create_inferior (exec_file
, get_inferior_args (),
614 environ_vector (current_inferior ()->environment
),
617 /* We're starting off a new process. When we get out of here, in
618 non-stop mode, finish the state of all threads of that process,
619 but leave other threads alone, as they may be stopped in internal
620 events --- the frontend shouldn't see them as stopped. In
621 all-stop, always finish the state of all threads, as we may be
622 resuming more than just the new process. */
624 ptid
= pid_to_ptid (ptid_get_pid (inferior_ptid
));
626 ptid
= minus_one_ptid
;
627 old_chain
= make_cleanup (finish_thread_state_cleanup
, &ptid
);
629 /* Pass zero for FROM_TTY, because at this point the "run" command
630 has done its thing; now we are setting up the running program. */
631 post_create_inferior (¤t_target
, 0);
633 /* Start the target running. Do not use -1 continuation as it would skip
634 breakpoint right at the entry point. */
635 proceed (regcache_read_pc (get_current_regcache ()), GDB_SIGNAL_0
, 0);
637 /* Since there was no error, there's no need to finish the thread
639 discard_cleanups (old_chain
);
643 run_command (char *args
, int from_tty
)
645 run_command_1 (args
, from_tty
, 0);
649 run_no_args_command (char *args
, int from_tty
)
651 set_inferior_args ("");
655 /* Start the execution of the program up until the beginning of the main
659 start_command (char *args
, int from_tty
)
661 /* Some languages such as Ada need to search inside the program
662 minimal symbols for the location where to put the temporary
663 breakpoint before starting. */
664 if (!have_minimal_symbols ())
665 error (_("No symbol table loaded. Use the \"file\" command."));
667 /* Run the program until reaching the main procedure... */
668 run_command_1 (args
, from_tty
, 1);
672 proceed_thread_callback (struct thread_info
*thread
, void *arg
)
674 /* We go through all threads individually instead of compressing
675 into a single target `resume_all' request, because some threads
676 may be stopped in internal breakpoints/events, or stopped waiting
677 for its turn in the displaced stepping queue (that is, they are
678 running && !executing). The target side has no idea about why
679 the thread is stopped, so a `resume_all' command would resume too
680 much. If/when GDB gains a way to tell the target `hold this
681 thread stopped until I say otherwise', then we can optimize
683 if (!is_stopped (thread
->ptid
))
686 switch_to_thread (thread
->ptid
);
687 clear_proceed_status ();
688 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
, 0);
693 ensure_valid_thread (void)
695 if (ptid_equal (inferior_ptid
, null_ptid
)
696 || is_exited (inferior_ptid
))
697 error (_("Cannot execute this command without a live selected thread."));
700 /* If the user is looking at trace frames, any resumption of execution
701 is likely to mix up recorded and live target data. So simply
702 disallow those commands. */
705 ensure_not_tfind_mode (void)
707 if (get_traceframe_number () >= 0)
708 error (_("Cannot execute this command while looking at trace frames."));
711 /* Throw an error indicating the current thread is running. */
714 error_is_running (void)
716 error (_("Cannot execute this command while "
717 "the selected thread is running."));
720 /* Calls error_is_running if the current thread is running. */
723 ensure_not_running (void)
725 if (is_running (inferior_ptid
))
730 continue_1 (int all_threads
)
733 ensure_not_tfind_mode ();
735 if (non_stop
&& all_threads
)
737 /* Don't error out if the current thread is running, because
738 there may be other stopped threads. */
739 struct cleanup
*old_chain
;
741 /* Backup current thread and selected frame. */
742 old_chain
= make_cleanup_restore_current_thread ();
744 iterate_over_threads (proceed_thread_callback
, NULL
);
746 /* Restore selected ptid. */
747 do_cleanups (old_chain
);
751 ensure_valid_thread ();
752 ensure_not_running ();
753 clear_proceed_status ();
754 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
, 0);
758 /* continue [-a] [proceed-count] [&] */
760 continue_command (char *args
, int from_tty
)
766 /* Find out whether we must run in the background. */
768 async_exec
= strip_bg_char (&args
);
770 /* If we must run in the background, but the target can't do it,
772 if (async_exec
&& !target_can_async_p ())
773 error (_("Asynchronous execution not supported on this target."));
775 /* If we are not asked to run in the bg, then prepare to run in the
776 foreground, synchronously. */
777 if (!async_exec
&& target_can_async_p ())
779 /* Simulate synchronous execution. */
780 async_disable_stdin ();
785 if (strncmp (args
, "-a", sizeof ("-a") - 1) == 0)
788 args
+= sizeof ("-a") - 1;
794 if (!non_stop
&& all_threads
)
795 error (_("`-a' is meaningless in all-stop mode."));
797 if (args
!= NULL
&& all_threads
)
798 error (_("Can't resume all threads and specify "
799 "proceed count simultaneously."));
801 /* If we have an argument left, set proceed count of breakpoint we
808 struct thread_info
*tp
;
811 tp
= find_thread_ptid (inferior_ptid
);
815 struct target_waitstatus ws
;
817 get_last_target_status (&last_ptid
, &ws
);
818 tp
= find_thread_ptid (last_ptid
);
821 bs
= tp
->control
.stop_bpstat
;
823 while ((stat
= bpstat_num (&bs
, &num
)) != 0)
826 set_ignore_count (num
,
827 parse_and_eval_long (args
) - 1,
829 /* set_ignore_count prints a message ending with a period.
830 So print two spaces before "Continuing.". */
832 printf_filtered (" ");
836 if (!stopped
&& from_tty
)
839 ("Not stopped at any breakpoint; argument ignored.\n");
844 printf_filtered (_("Continuing.\n"));
846 continue_1 (all_threads
);
849 /* Record the starting point of a "step" or "next" command. */
852 set_step_frame (void)
854 struct symtab_and_line sal
;
856 find_frame_sal (get_current_frame (), &sal
);
857 set_step_info (get_current_frame (), sal
);
860 /* Step until outside of current statement. */
863 step_command (char *count_string
, int from_tty
)
865 step_1 (0, 0, count_string
);
868 /* Likewise, but skip over subroutine calls as if single instructions. */
871 next_command (char *count_string
, int from_tty
)
873 step_1 (1, 0, count_string
);
876 /* Likewise, but step only one instruction. */
879 stepi_command (char *count_string
, int from_tty
)
881 step_1 (0, 1, count_string
);
885 nexti_command (char *count_string
, int from_tty
)
887 step_1 (1, 1, count_string
);
891 delete_longjmp_breakpoint_cleanup (void *arg
)
893 int thread
= * (int *) arg
;
894 delete_longjmp_breakpoint (thread
);
898 step_1 (int skip_subroutines
, int single_inst
, char *count_string
)
901 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
906 ensure_not_tfind_mode ();
907 ensure_valid_thread ();
908 ensure_not_running ();
911 async_exec
= strip_bg_char (&count_string
);
913 /* If we get a request for running in the bg but the target
914 doesn't support it, error out. */
915 if (async_exec
&& !target_can_async_p ())
916 error (_("Asynchronous execution not supported on this target."));
918 /* If we don't get a request of running in the bg, then we need
919 to simulate synchronous (fg) execution. */
920 if (!async_exec
&& target_can_async_p ())
922 /* Simulate synchronous execution. */
923 async_disable_stdin ();
926 count
= count_string
? parse_and_eval_long (count_string
) : 1;
928 if (!single_inst
|| skip_subroutines
) /* Leave si command alone. */
930 struct thread_info
*tp
= inferior_thread ();
932 if (in_thread_list (inferior_ptid
))
933 thread
= pid_to_thread_id (inferior_ptid
);
935 set_longjmp_breakpoint (tp
, get_frame_id (get_current_frame ()));
937 make_cleanup (delete_longjmp_breakpoint_cleanup
, &thread
);
940 /* In synchronous case, all is well; each step_once call will step once. */
941 if (!target_can_async_p ())
943 for (; count
> 0; count
--)
945 step_once (skip_subroutines
, single_inst
, count
, thread
);
947 if (!target_has_execution
)
951 struct thread_info
*tp
= inferior_thread ();
953 if (!tp
->control
.stop_step
|| !tp
->step_multi
)
955 /* If we stopped for some reason that is not stepping
956 there are no further steps to make. */
963 do_cleanups (cleanups
);
967 /* In the case of an asynchronous target things get complicated;
968 do only one step for now, before returning control to the
969 event loop. Let the continuation figure out how many other
970 steps we need to do, and handle them one at the time, through
972 step_once (skip_subroutines
, single_inst
, count
, thread
);
974 /* We are running, and the continuation is installed. It will
975 disable the longjmp breakpoint as appropriate. */
976 discard_cleanups (cleanups
);
980 struct step_1_continuation_args
983 int skip_subroutines
;
988 /* Called after we are done with one step operation, to check whether
989 we need to step again, before we print the prompt and return control
990 to the user. If count is > 1, we will need to do one more call to
991 proceed(), via step_once(). Basically it is like step_once and
992 step_1_continuation are co-recursive. */
994 step_1_continuation (void *args
, int err
)
996 struct step_1_continuation_args
*a
= args
;
998 if (target_has_execution
)
1000 struct thread_info
*tp
;
1002 tp
= inferior_thread ();
1004 && tp
->step_multi
&& tp
->control
.stop_step
)
1006 /* There are more steps to make, and we did stop due to
1007 ending a stepping range. Do another step. */
1008 step_once (a
->skip_subroutines
, a
->single_inst
,
1009 a
->count
- 1, a
->thread
);
1015 /* We either hit an error, or stopped for some reason that is
1016 not stepping, or there are no further steps to make.
1018 if (!a
->single_inst
|| a
->skip_subroutines
)
1019 delete_longjmp_breakpoint (a
->thread
);
1022 /* Do just one step operation. This is useful to implement the 'step
1023 n' kind of commands. In case of asynchronous targets, we will have
1024 to set up a continuation to be done after the target stops (after
1025 this one step). For synch targets, the caller handles further
1029 step_once (int skip_subroutines
, int single_inst
, int count
, int thread
)
1031 struct frame_info
*frame
= get_current_frame ();
1035 /* Don't assume THREAD is a valid thread id. It is set to -1 if
1036 the longjmp breakpoint was not required. Use the
1037 INFERIOR_PTID thread instead, which is the same thread when
1039 struct thread_info
*tp
= inferior_thread ();
1041 clear_proceed_status ();
1048 /* Step at an inlined function behaves like "down". */
1049 if (!skip_subroutines
&& !single_inst
1050 && inline_skipped_frames (inferior_ptid
))
1054 /* Pretend that we've ran. */
1055 resume_ptid
= user_visible_resume_ptid (1);
1056 set_running (resume_ptid
, 1);
1058 step_into_inline_frame (inferior_ptid
);
1060 step_once (skip_subroutines
, single_inst
, count
- 1, thread
);
1063 /* Pretend that we've stopped. */
1066 if (target_can_async_p ())
1067 inferior_event_handler (INF_EXEC_COMPLETE
, NULL
);
1072 pc
= get_frame_pc (frame
);
1073 find_pc_line_pc_range (pc
,
1074 &tp
->control
.step_range_start
,
1075 &tp
->control
.step_range_end
);
1077 /* If we have no line info, switch to stepi mode. */
1078 if (tp
->control
.step_range_end
== 0 && step_stop_if_no_debug
)
1079 tp
->control
.step_range_start
= tp
->control
.step_range_end
= 1;
1080 else if (tp
->control
.step_range_end
== 0)
1084 if (find_pc_partial_function (pc
, &name
,
1085 &tp
->control
.step_range_start
,
1086 &tp
->control
.step_range_end
) == 0)
1087 error (_("Cannot find bounds of current function"));
1089 target_terminal_ours ();
1090 printf_filtered (_("Single stepping until exit from function %s,"
1091 "\nwhich has no line number information.\n"),
1097 /* Say we are stepping, but stop after one insn whatever it does. */
1098 tp
->control
.step_range_start
= tp
->control
.step_range_end
= 1;
1099 if (!skip_subroutines
)
1101 Don't step over function calls, not even to functions lacking
1103 tp
->control
.step_over_calls
= STEP_OVER_NONE
;
1106 if (skip_subroutines
)
1107 tp
->control
.step_over_calls
= STEP_OVER_ALL
;
1109 tp
->step_multi
= (count
> 1);
1110 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
, 1);
1112 /* For async targets, register a continuation to do any
1113 additional steps. For sync targets, the caller will handle
1114 further stepping. */
1115 if (target_can_async_p ())
1117 struct step_1_continuation_args
*args
;
1119 args
= xmalloc (sizeof (*args
));
1120 args
->skip_subroutines
= skip_subroutines
;
1121 args
->single_inst
= single_inst
;
1122 args
->count
= count
;
1123 args
->thread
= thread
;
1125 add_intermediate_continuation (tp
, step_1_continuation
, args
, xfree
);
1131 /* Continue program at specified address. */
1134 jump_command (char *arg
, int from_tty
)
1136 struct gdbarch
*gdbarch
= get_current_arch ();
1138 struct symtabs_and_lines sals
;
1139 struct symtab_and_line sal
;
1145 ensure_not_tfind_mode ();
1146 ensure_valid_thread ();
1147 ensure_not_running ();
1149 /* Find out whether we must run in the background. */
1151 async_exec
= strip_bg_char (&arg
);
1153 /* If we must run in the background, but the target can't do it,
1155 if (async_exec
&& !target_can_async_p ())
1156 error (_("Asynchronous execution not supported on this target."));
1159 error_no_arg (_("starting address"));
1161 sals
= decode_line_with_last_displayed (arg
, DECODE_LINE_FUNFIRSTLINE
);
1162 if (sals
.nelts
!= 1)
1164 error (_("Unreasonable jump request"));
1170 if (sal
.symtab
== 0 && sal
.pc
== 0)
1171 error (_("No source file has been specified."));
1173 resolve_sal_pc (&sal
); /* May error out. */
1175 /* See if we are trying to jump to another function. */
1176 fn
= get_frame_function (get_current_frame ());
1177 sfn
= find_pc_function (sal
.pc
);
1178 if (fn
!= NULL
&& sfn
!= fn
)
1180 if (!query (_("Line %d is not in `%s'. Jump anyway? "), sal
.line
,
1181 SYMBOL_PRINT_NAME (fn
)))
1183 error (_("Not confirmed."));
1190 fixup_symbol_section (sfn
, 0);
1191 if (section_is_overlay (SYMBOL_OBJ_SECTION (sfn
)) &&
1192 !section_is_mapped (SYMBOL_OBJ_SECTION (sfn
)))
1194 if (!query (_("WARNING!!! Destination is in "
1195 "unmapped overlay! Jump anyway? ")))
1197 error (_("Not confirmed."));
1207 printf_filtered (_("Continuing at "));
1208 fputs_filtered (paddress (gdbarch
, addr
), gdb_stdout
);
1209 printf_filtered (".\n");
1212 /* If we are not asked to run in the bg, then prepare to run in the
1213 foreground, synchronously. */
1214 if (!async_exec
&& target_can_async_p ())
1216 /* Simulate synchronous execution. */
1217 async_disable_stdin ();
1220 clear_proceed_status ();
1221 proceed (addr
, GDB_SIGNAL_0
, 0);
1225 /* Go to line or address in current procedure. */
1227 go_command (char *line_no
, int from_tty
)
1229 if (line_no
== (char *) NULL
|| !*line_no
)
1230 printf_filtered (_("Usage: go <location>\n"));
1233 tbreak_command (line_no
, from_tty
);
1234 jump_command (line_no
, from_tty
);
1239 /* Continue program giving it specified signal. */
1242 signal_command (char *signum_exp
, int from_tty
)
1244 enum gdb_signal oursig
;
1247 dont_repeat (); /* Too dangerous. */
1249 ensure_not_tfind_mode ();
1250 ensure_valid_thread ();
1251 ensure_not_running ();
1253 /* Find out whether we must run in the background. */
1254 if (signum_exp
!= NULL
)
1255 async_exec
= strip_bg_char (&signum_exp
);
1257 /* If we must run in the background, but the target can't do it,
1259 if (async_exec
&& !target_can_async_p ())
1260 error (_("Asynchronous execution not supported on this target."));
1262 /* If we are not asked to run in the bg, then prepare to run in the
1263 foreground, synchronously. */
1264 if (!async_exec
&& target_can_async_p ())
1266 /* Simulate synchronous execution. */
1267 async_disable_stdin ();
1271 error_no_arg (_("signal number"));
1273 /* It would be even slicker to make signal names be valid expressions,
1274 (the type could be "enum $signal" or some such), then the user could
1275 assign them to convenience variables. */
1276 oursig
= gdb_signal_from_name (signum_exp
);
1278 if (oursig
== GDB_SIGNAL_UNKNOWN
)
1280 /* No, try numeric. */
1281 int num
= parse_and_eval_long (signum_exp
);
1284 oursig
= GDB_SIGNAL_0
;
1286 oursig
= gdb_signal_from_command (num
);
1291 if (oursig
== GDB_SIGNAL_0
)
1292 printf_filtered (_("Continuing with no signal.\n"));
1294 printf_filtered (_("Continuing with signal %s.\n"),
1295 gdb_signal_to_name (oursig
));
1298 clear_proceed_status ();
1299 proceed ((CORE_ADDR
) -1, oursig
, 0);
1302 /* Continuation args to be passed to the "until" command
1304 struct until_next_continuation_args
1306 /* The thread that was current when the command was executed. */
1310 /* A continuation callback for until_next_command. */
1313 until_next_continuation (void *arg
, int err
)
1315 struct until_next_continuation_args
*a
= arg
;
1317 delete_longjmp_breakpoint (a
->thread
);
1320 /* Proceed until we reach a different source line with pc greater than
1321 our current one or exit the function. We skip calls in both cases.
1323 Note that eventually this command should probably be changed so
1324 that only source lines are printed out when we hit the breakpoint
1325 we set. This may involve changes to wait_for_inferior and the
1326 proceed status code. */
1329 until_next_command (int from_tty
)
1331 struct frame_info
*frame
;
1333 struct symbol
*func
;
1334 struct symtab_and_line sal
;
1335 struct thread_info
*tp
= inferior_thread ();
1336 int thread
= tp
->num
;
1337 struct cleanup
*old_chain
;
1339 clear_proceed_status ();
1342 frame
= get_current_frame ();
1344 /* Step until either exited from this function or greater
1345 than the current line (if in symbolic section) or pc (if
1348 pc
= get_frame_pc (frame
);
1349 func
= find_pc_function (pc
);
1353 struct minimal_symbol
*msymbol
= lookup_minimal_symbol_by_pc (pc
);
1355 if (msymbol
== NULL
)
1356 error (_("Execution is not within a known function."));
1358 tp
->control
.step_range_start
= SYMBOL_VALUE_ADDRESS (msymbol
);
1359 tp
->control
.step_range_end
= pc
;
1363 sal
= find_pc_line (pc
, 0);
1365 tp
->control
.step_range_start
= BLOCK_START (SYMBOL_BLOCK_VALUE (func
));
1366 tp
->control
.step_range_end
= sal
.end
;
1369 tp
->control
.step_over_calls
= STEP_OVER_ALL
;
1371 tp
->step_multi
= 0; /* Only one call to proceed */
1373 set_longjmp_breakpoint (tp
, get_frame_id (frame
));
1374 old_chain
= make_cleanup (delete_longjmp_breakpoint_cleanup
, &thread
);
1376 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
, 1);
1378 if (target_can_async_p () && is_running (inferior_ptid
))
1380 struct until_next_continuation_args
*cont_args
;
1382 discard_cleanups (old_chain
);
1383 cont_args
= XNEW (struct until_next_continuation_args
);
1384 cont_args
->thread
= inferior_thread ()->num
;
1386 add_continuation (tp
, until_next_continuation
, cont_args
, xfree
);
1389 do_cleanups (old_chain
);
1393 until_command (char *arg
, int from_tty
)
1398 ensure_not_tfind_mode ();
1399 ensure_valid_thread ();
1400 ensure_not_running ();
1402 /* Find out whether we must run in the background. */
1404 async_exec
= strip_bg_char (&arg
);
1406 /* If we must run in the background, but the target can't do it,
1408 if (async_exec
&& !target_can_async_p ())
1409 error (_("Asynchronous execution not supported on this target."));
1411 /* If we are not asked to run in the bg, then prepare to run in the
1412 foreground, synchronously. */
1413 if (!async_exec
&& target_can_async_p ())
1415 /* Simulate synchronous execution. */
1416 async_disable_stdin ();
1420 until_break_command (arg
, from_tty
, 0);
1422 until_next_command (from_tty
);
1426 advance_command (char *arg
, int from_tty
)
1431 ensure_not_tfind_mode ();
1432 ensure_valid_thread ();
1433 ensure_not_running ();
1436 error_no_arg (_("a location"));
1438 /* Find out whether we must run in the background. */
1440 async_exec
= strip_bg_char (&arg
);
1442 /* If we must run in the background, but the target can't do it,
1444 if (async_exec
&& !target_can_async_p ())
1445 error (_("Asynchronous execution not supported on this target."));
1447 /* If we are not asked to run in the bg, then prepare to run in the
1448 foreground, synchronously. */
1449 if (!async_exec
&& target_can_async_p ())
1451 /* Simulate synchronous execution. */
1452 async_disable_stdin ();
1455 until_break_command (arg
, from_tty
, 1);
1458 /* Return the value of the result of a function at the end of a 'finish'
1462 get_return_value (struct value
*function
, struct type
*value_type
)
1464 struct regcache
*stop_regs
= stop_registers
;
1465 struct gdbarch
*gdbarch
;
1466 struct value
*value
;
1467 struct ui_out
*uiout
= current_uiout
;
1468 struct cleanup
*cleanup
= make_cleanup (null_cleanup
, NULL
);
1470 /* If stop_registers were not saved, use the current registers. */
1473 stop_regs
= regcache_dup (get_current_regcache ());
1474 cleanup
= make_cleanup_regcache_xfree (stop_regs
);
1477 gdbarch
= get_regcache_arch (stop_regs
);
1479 CHECK_TYPEDEF (value_type
);
1480 gdb_assert (TYPE_CODE (value_type
) != TYPE_CODE_VOID
);
1482 /* FIXME: 2003-09-27: When returning from a nested inferior function
1483 call, it's possible (with no help from the architecture vector)
1484 to locate and return/print a "struct return" value. This is just
1485 a more complicated case of what is already being done in the
1486 inferior function call code. In fact, when inferior function
1487 calls are made async, this will likely be made the norm. */
1489 switch (gdbarch_return_value (gdbarch
, function
, value_type
,
1492 case RETURN_VALUE_REGISTER_CONVENTION
:
1493 case RETURN_VALUE_ABI_RETURNS_ADDRESS
:
1494 case RETURN_VALUE_ABI_PRESERVES_ADDRESS
:
1495 value
= allocate_value (value_type
);
1496 gdbarch_return_value (gdbarch
, function
, value_type
, stop_regs
,
1497 value_contents_raw (value
), NULL
);
1499 case RETURN_VALUE_STRUCT_CONVENTION
:
1503 internal_error (__FILE__
, __LINE__
, _("bad switch"));
1506 do_cleanups (cleanup
);
1511 /* Print the result of a function at the end of a 'finish' command. */
1514 print_return_value (struct value
*function
, struct type
*value_type
)
1516 struct value
*value
= get_return_value (function
, value_type
);
1517 struct ui_out
*uiout
= current_uiout
;
1521 struct value_print_options opts
;
1522 struct ui_file
*stb
;
1523 struct cleanup
*old_chain
;
1526 stb
= mem_fileopen ();
1527 old_chain
= make_cleanup_ui_file_delete (stb
);
1528 ui_out_text (uiout
, "Value returned is ");
1529 ui_out_field_fmt (uiout
, "gdb-result-var", "$%d",
1530 record_latest_value (value
));
1531 ui_out_text (uiout
, " = ");
1532 get_raw_print_options (&opts
);
1533 value_print (value
, stb
, &opts
);
1534 ui_out_field_stream (uiout
, "return-value", stb
);
1535 ui_out_text (uiout
, "\n");
1536 do_cleanups (old_chain
);
1540 ui_out_text (uiout
, "Value returned has type: ");
1541 ui_out_field_string (uiout
, "return-type", TYPE_NAME (value_type
));
1542 ui_out_text (uiout
, ".");
1543 ui_out_text (uiout
, " Cannot determine contents\n");
1547 /* Stuff that needs to be done by the finish command after the target
1548 has stopped. In asynchronous mode, we wait for the target to stop
1549 in the call to poll or select in the event loop, so it is
1550 impossible to do all the stuff as part of the finish_command
1551 function itself. The only chance we have to complete this command
1552 is in fetch_inferior_event, which is called by the event loop as
1553 soon as it detects that the target has stopped. */
1555 struct finish_command_continuation_args
1557 /* The thread that as current when the command was executed. */
1559 struct breakpoint
*breakpoint
;
1560 struct symbol
*function
;
1564 finish_command_continuation (void *arg
, int err
)
1566 struct finish_command_continuation_args
*a
= arg
;
1570 struct thread_info
*tp
= NULL
;
1573 if (!ptid_equal (inferior_ptid
, null_ptid
)
1574 && target_has_execution
1575 && is_stopped (inferior_ptid
))
1577 tp
= inferior_thread ();
1578 bs
= tp
->control
.stop_bpstat
;
1581 if (bpstat_find_breakpoint (bs
, a
->breakpoint
) != NULL
1582 && a
->function
!= NULL
)
1584 struct type
*value_type
;
1586 value_type
= TYPE_TARGET_TYPE (SYMBOL_TYPE (a
->function
));
1588 internal_error (__FILE__
, __LINE__
,
1589 _("finish_command: function has no target type"));
1591 if (TYPE_CODE (value_type
) != TYPE_CODE_VOID
)
1593 volatile struct gdb_exception ex
;
1596 func
= read_var_value (a
->function
, get_current_frame ());
1597 TRY_CATCH (ex
, RETURN_MASK_ALL
)
1599 /* print_return_value can throw an exception in some
1600 circumstances. We need to catch this so that we still
1601 delete the breakpoint. */
1602 print_return_value (func
, value_type
);
1605 exception_print (gdb_stdout
, ex
);
1609 /* We suppress normal call of normal_stop observer and do it
1610 here so that the *stopped notification includes the return
1612 if (bs
!= NULL
&& tp
->control
.proceed_to_finish
)
1613 observer_notify_normal_stop (bs
, 1 /* print frame */);
1616 delete_breakpoint (a
->breakpoint
);
1617 delete_longjmp_breakpoint (a
->thread
);
1621 finish_command_continuation_free_arg (void *arg
)
1626 /* finish_backward -- helper function for finish_command. */
1629 finish_backward (struct symbol
*function
)
1631 struct symtab_and_line sal
;
1632 struct thread_info
*tp
= inferior_thread ();
1634 CORE_ADDR func_addr
;
1636 pc
= get_frame_pc (get_current_frame ());
1638 if (find_pc_partial_function (pc
, NULL
, &func_addr
, NULL
) == 0)
1639 internal_error (__FILE__
, __LINE__
,
1640 _("Finish: couldn't find function."));
1642 sal
= find_pc_line (func_addr
, 0);
1644 tp
->control
.proceed_to_finish
= 1;
1645 /* Special case: if we're sitting at the function entry point,
1646 then all we need to do is take a reverse singlestep. We
1647 don't need to set a breakpoint, and indeed it would do us
1650 Note that this can only happen at frame #0, since there's
1651 no way that a function up the stack can have a return address
1652 that's equal to its entry point. */
1656 struct frame_info
*frame
= get_selected_frame (NULL
);
1657 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1658 struct symtab_and_line sr_sal
;
1660 /* Set a step-resume at the function's entry point. Once that's
1661 hit, we'll do one more step backwards. */
1664 sr_sal
.pspace
= get_frame_program_space (frame
);
1665 insert_step_resume_breakpoint_at_sal (gdbarch
,
1666 sr_sal
, null_frame_id
);
1668 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
, 0);
1672 /* We're almost there -- we just need to back up by one more
1674 tp
->control
.step_range_start
= tp
->control
.step_range_end
= 1;
1675 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
, 1);
1679 /* finish_forward -- helper function for finish_command. */
1682 finish_forward (struct symbol
*function
, struct frame_info
*frame
)
1684 struct frame_id frame_id
= get_frame_id (frame
);
1685 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1686 struct symtab_and_line sal
;
1687 struct thread_info
*tp
= inferior_thread ();
1688 struct breakpoint
*breakpoint
;
1689 struct cleanup
*old_chain
;
1690 struct finish_command_continuation_args
*cargs
;
1691 int thread
= tp
->num
;
1693 sal
= find_pc_line (get_frame_pc (frame
), 0);
1694 sal
.pc
= get_frame_pc (frame
);
1696 breakpoint
= set_momentary_breakpoint (gdbarch
, sal
,
1697 get_stack_frame_id (frame
),
1700 /* set_momentary_breakpoint invalidates FRAME. */
1703 old_chain
= make_cleanup_delete_breakpoint (breakpoint
);
1705 set_longjmp_breakpoint (tp
, frame_id
);
1706 make_cleanup (delete_longjmp_breakpoint_cleanup
, &thread
);
1708 /* We want stop_registers, please... */
1709 tp
->control
.proceed_to_finish
= 1;
1710 cargs
= xmalloc (sizeof (*cargs
));
1712 cargs
->thread
= thread
;
1713 cargs
->breakpoint
= breakpoint
;
1714 cargs
->function
= function
;
1715 add_continuation (tp
, finish_command_continuation
, cargs
,
1716 finish_command_continuation_free_arg
);
1717 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
, 0);
1719 discard_cleanups (old_chain
);
1720 if (!target_can_async_p ())
1721 do_all_continuations (0);
1724 /* "finish": Set a temporary breakpoint at the place the selected
1725 frame will return to, then continue. */
1728 finish_command (char *arg
, int from_tty
)
1730 struct frame_info
*frame
;
1731 struct symbol
*function
;
1736 ensure_not_tfind_mode ();
1737 ensure_valid_thread ();
1738 ensure_not_running ();
1740 /* Find out whether we must run in the background. */
1742 async_exec
= strip_bg_char (&arg
);
1744 /* If we must run in the background, but the target can't do it,
1746 if (async_exec
&& !target_can_async_p ())
1747 error (_("Asynchronous execution not supported on this target."));
1749 /* If we are not asked to run in the bg, then prepare to run in the
1750 foreground, synchronously. */
1751 if (!async_exec
&& target_can_async_p ())
1753 /* Simulate synchronous execution. */
1754 async_disable_stdin ();
1758 error (_("The \"finish\" command does not take any arguments."));
1760 frame
= get_prev_frame (get_selected_frame (_("No selected frame.")));
1762 error (_("\"finish\" not meaningful in the outermost frame."));
1764 clear_proceed_status ();
1766 /* Finishing from an inline frame is completely different. We don't
1767 try to show the "return value" - no way to locate it. So we do
1768 not need a completion. */
1769 if (get_frame_type (get_selected_frame (_("No selected frame.")))
1772 /* Claim we are stepping in the calling frame. An empty step
1773 range means that we will stop once we aren't in a function
1774 called by that frame. We don't use the magic "1" value for
1775 step_range_end, because then infrun will think this is nexti,
1776 and not step over the rest of this inlined function call. */
1777 struct thread_info
*tp
= inferior_thread ();
1778 struct symtab_and_line empty_sal
;
1780 init_sal (&empty_sal
);
1781 set_step_info (frame
, empty_sal
);
1782 tp
->control
.step_range_start
= get_frame_pc (frame
);
1783 tp
->control
.step_range_end
= tp
->control
.step_range_start
;
1784 tp
->control
.step_over_calls
= STEP_OVER_ALL
;
1786 /* Print info on the selected frame, including level number but not
1790 printf_filtered (_("Run till exit from "));
1791 print_stack_frame (get_selected_frame (NULL
), 1, LOCATION
);
1794 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
, 1);
1798 /* Ignore TAILCALL_FRAME type frames, they were executed already before
1799 entering THISFRAME. */
1800 while (get_frame_type (frame
) == TAILCALL_FRAME
)
1801 frame
= get_prev_frame (frame
);
1803 /* Find the function we will return from. */
1805 function
= find_pc_function (get_frame_pc (get_selected_frame (NULL
)));
1807 /* Print info on the selected frame, including level number but not
1811 if (execution_direction
== EXEC_REVERSE
)
1812 printf_filtered (_("Run back to call of "));
1814 printf_filtered (_("Run till exit from "));
1816 print_stack_frame (get_selected_frame (NULL
), 1, LOCATION
);
1819 if (execution_direction
== EXEC_REVERSE
)
1820 finish_backward (function
);
1822 finish_forward (function
, frame
);
1827 program_info (char *args
, int from_tty
)
1831 struct thread_info
*tp
;
1834 if (!target_has_execution
)
1836 printf_filtered (_("The program being debugged is not being run.\n"));
1841 ptid
= inferior_ptid
;
1844 struct target_waitstatus ws
;
1846 get_last_target_status (&ptid
, &ws
);
1849 if (ptid_equal (ptid
, null_ptid
) || is_exited (ptid
))
1850 error (_("Invalid selected thread."));
1851 else if (is_running (ptid
))
1852 error (_("Selected thread is running."));
1854 tp
= find_thread_ptid (ptid
);
1855 bs
= tp
->control
.stop_bpstat
;
1856 stat
= bpstat_num (&bs
, &num
);
1858 target_files_info ();
1859 printf_filtered (_("Program stopped at %s.\n"),
1860 paddress (target_gdbarch (), stop_pc
));
1861 if (tp
->control
.stop_step
)
1862 printf_filtered (_("It stopped after being stepped.\n"));
1865 /* There may be several breakpoints in the same place, so this
1866 isn't as strange as it seems. */
1871 printf_filtered (_("It stopped at a breakpoint "
1872 "that has since been deleted.\n"));
1875 printf_filtered (_("It stopped at breakpoint %d.\n"), num
);
1876 stat
= bpstat_num (&bs
, &num
);
1879 else if (tp
->suspend
.stop_signal
!= GDB_SIGNAL_0
)
1881 printf_filtered (_("It stopped with signal %s, %s.\n"),
1882 gdb_signal_to_name (tp
->suspend
.stop_signal
),
1883 gdb_signal_to_string (tp
->suspend
.stop_signal
));
1888 printf_filtered (_("Type \"info stack\" or \"info "
1889 "registers\" for more information.\n"));
1894 environment_info (char *var
, int from_tty
)
1898 char *val
= get_in_environ (current_inferior ()->environment
, var
);
1902 puts_filtered (var
);
1903 puts_filtered (" = ");
1904 puts_filtered (val
);
1905 puts_filtered ("\n");
1909 puts_filtered ("Environment variable \"");
1910 puts_filtered (var
);
1911 puts_filtered ("\" not defined.\n");
1916 char **vector
= environ_vector (current_inferior ()->environment
);
1920 puts_filtered (*vector
++);
1921 puts_filtered ("\n");
1927 set_environment_command (char *arg
, int from_tty
)
1929 char *p
, *val
, *var
;
1933 error_no_arg (_("environment variable and value"));
1935 /* Find seperation between variable name and value. */
1936 p
= (char *) strchr (arg
, '=');
1937 val
= (char *) strchr (arg
, ' ');
1939 if (p
!= 0 && val
!= 0)
1941 /* We have both a space and an equals. If the space is before the
1942 equals, walk forward over the spaces til we see a nonspace
1943 (possibly the equals). */
1948 /* Now if the = is after the char following the spaces,
1949 take the char following the spaces. */
1953 else if (val
!= 0 && p
== 0)
1957 error_no_arg (_("environment variable to set"));
1959 if (p
== 0 || p
[1] == 0)
1963 p
= arg
+ strlen (arg
); /* So that savestring below will work. */
1967 /* Not setting variable value to null. */
1969 while (*val
== ' ' || *val
== '\t')
1973 while (p
!= arg
&& (p
[-1] == ' ' || p
[-1] == '\t'))
1976 var
= savestring (arg
, p
- arg
);
1979 printf_filtered (_("Setting environment variable "
1980 "\"%s\" to null value.\n"),
1982 set_in_environ (current_inferior ()->environment
, var
, "");
1985 set_in_environ (current_inferior ()->environment
, var
, val
);
1990 unset_environment_command (char *var
, int from_tty
)
1994 /* If there is no argument, delete all environment variables.
1995 Ask for confirmation if reading from the terminal. */
1996 if (!from_tty
|| query (_("Delete all environment variables? ")))
1998 free_environ (current_inferior ()->environment
);
1999 current_inferior ()->environment
= make_environ ();
2003 unset_in_environ (current_inferior ()->environment
, var
);
2006 /* Handle the execution path (PATH variable). */
2008 static const char path_var_name
[] = "PATH";
2011 path_info (char *args
, int from_tty
)
2013 puts_filtered ("Executable and object file path: ");
2014 puts_filtered (get_in_environ (current_inferior ()->environment
,
2016 puts_filtered ("\n");
2019 /* Add zero or more directories to the front of the execution path. */
2022 path_command (char *dirname
, int from_tty
)
2028 env
= get_in_environ (current_inferior ()->environment
, path_var_name
);
2029 /* Can be null if path is not set. */
2032 exec_path
= xstrdup (env
);
2033 mod_path (dirname
, &exec_path
);
2034 set_in_environ (current_inferior ()->environment
, path_var_name
, exec_path
);
2037 path_info ((char *) NULL
, from_tty
);
2041 /* Print out the register NAME with value VAL, to FILE, in the default
2045 default_print_one_register_info (struct ui_file
*file
,
2049 struct type
*regtype
= value_type (val
);
2051 fputs_filtered (name
, file
);
2052 print_spaces_filtered (15 - strlen (name
), file
);
2054 if (!value_entirely_available (val
))
2056 fprintf_filtered (file
, "*value not available*\n");
2060 /* If virtual format is floating, print it that way, and in raw
2062 if (TYPE_CODE (regtype
) == TYPE_CODE_FLT
2063 || TYPE_CODE (regtype
) == TYPE_CODE_DECFLOAT
)
2066 struct value_print_options opts
;
2067 const gdb_byte
*valaddr
= value_contents_for_printing (val
);
2068 enum bfd_endian byte_order
= gdbarch_byte_order (get_type_arch (regtype
));
2070 get_user_print_options (&opts
);
2074 value_contents_for_printing (val
),
2075 value_embedded_offset (val
), 0,
2076 file
, 0, val
, &opts
, current_language
);
2078 fprintf_filtered (file
, "\t(raw 0x");
2079 for (j
= 0; j
< TYPE_LENGTH (regtype
); j
++)
2083 if (byte_order
== BFD_ENDIAN_BIG
)
2086 idx
= TYPE_LENGTH (regtype
) - 1 - j
;
2087 fprintf_filtered (file
, "%02x", (unsigned char) valaddr
[idx
]);
2089 fprintf_filtered (file
, ")");
2093 struct value_print_options opts
;
2095 /* Print the register in hex. */
2096 get_formatted_print_options (&opts
, 'x');
2099 value_contents_for_printing (val
),
2100 value_embedded_offset (val
), 0,
2101 file
, 0, val
, &opts
, current_language
);
2102 /* If not a vector register, print it also according to its
2104 if (TYPE_VECTOR (regtype
) == 0)
2106 get_user_print_options (&opts
);
2108 fprintf_filtered (file
, "\t");
2110 value_contents_for_printing (val
),
2111 value_embedded_offset (val
), 0,
2112 file
, 0, val
, &opts
, current_language
);
2116 fprintf_filtered (file
, "\n");
2119 /* Print out the machine register regnum. If regnum is -1, print all
2120 registers (print_all == 1) or all non-float and non-vector
2121 registers (print_all == 0).
2123 For most machines, having all_registers_info() print the
2124 register(s) one per line is good enough. If a different format is
2125 required, (eg, for MIPS or Pyramid 90x, which both have lots of
2126 regs), or there is an existing convention for showing all the
2127 registers, define the architecture method PRINT_REGISTERS_INFO to
2128 provide that format. */
2131 default_print_registers_info (struct gdbarch
*gdbarch
,
2132 struct ui_file
*file
,
2133 struct frame_info
*frame
,
2134 int regnum
, int print_all
)
2137 const int numregs
= gdbarch_num_regs (gdbarch
)
2138 + gdbarch_num_pseudo_regs (gdbarch
);
2140 for (i
= 0; i
< numregs
; i
++)
2142 struct type
*regtype
;
2145 /* Decide between printing all regs, non-float / vector regs, or
2151 if (!gdbarch_register_reggroup_p (gdbarch
, i
, all_reggroup
))
2156 if (!gdbarch_register_reggroup_p (gdbarch
, i
, general_reggroup
))
2166 /* If the register name is empty, it is undefined for this
2167 processor, so don't display anything. */
2168 if (gdbarch_register_name (gdbarch
, i
) == NULL
2169 || *(gdbarch_register_name (gdbarch
, i
)) == '\0')
2172 regtype
= register_type (gdbarch
, i
);
2173 val
= allocate_value (regtype
);
2175 /* Get the data in raw format. */
2176 if (! deprecated_frame_register_read (frame
, i
, value_contents_raw (val
)))
2177 mark_value_bytes_unavailable (val
, 0, TYPE_LENGTH (value_type (val
)));
2179 default_print_one_register_info (file
,
2180 gdbarch_register_name (gdbarch
, i
),
2186 registers_info (char *addr_exp
, int fpregs
)
2188 struct frame_info
*frame
;
2189 struct gdbarch
*gdbarch
;
2191 if (!target_has_registers
)
2192 error (_("The program has no registers now."));
2193 frame
= get_selected_frame (NULL
);
2194 gdbarch
= get_frame_arch (frame
);
2198 gdbarch_print_registers_info (gdbarch
, gdb_stdout
,
2203 while (*addr_exp
!= '\0')
2208 /* Keep skipping leading white space. */
2209 if (isspace ((*addr_exp
)))
2215 /* Discard any leading ``$''. Check that there is something
2216 resembling a register following it. */
2217 if (addr_exp
[0] == '$')
2219 if (isspace ((*addr_exp
)) || (*addr_exp
) == '\0')
2220 error (_("Missing register name"));
2222 /* Find the start/end of this register name/num/group. */
2224 while ((*addr_exp
) != '\0' && !isspace ((*addr_exp
)))
2228 /* Figure out what we've found and display it. */
2230 /* A register name? */
2232 int regnum
= user_reg_map_name_to_regnum (gdbarch
, start
, end
- start
);
2236 /* User registers lie completely outside of the range of
2237 normal registers. Catch them early so that the target
2239 if (regnum
>= gdbarch_num_regs (gdbarch
)
2240 + gdbarch_num_pseudo_regs (gdbarch
))
2242 struct value
*regval
= value_of_user_reg (regnum
, frame
);
2243 const char *regname
= user_reg_map_regnum_to_name (gdbarch
,
2246 /* Print in the same fashion
2247 gdbarch_print_registers_info's default
2248 implementation prints. */
2249 default_print_one_register_info (gdb_stdout
,
2254 gdbarch_print_registers_info (gdbarch
, gdb_stdout
,
2255 frame
, regnum
, fpregs
);
2260 /* A register group? */
2262 struct reggroup
*group
;
2264 for (group
= reggroup_next (gdbarch
, NULL
);
2266 group
= reggroup_next (gdbarch
, group
))
2268 /* Don't bother with a length check. Should the user
2269 enter a short register group name, go with the first
2270 group that matches. */
2271 if (strncmp (start
, reggroup_name (group
), end
- start
) == 0)
2279 regnum
< gdbarch_num_regs (gdbarch
)
2280 + gdbarch_num_pseudo_regs (gdbarch
);
2283 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, group
))
2284 gdbarch_print_registers_info (gdbarch
,
2292 /* Nothing matched. */
2293 error (_("Invalid register `%.*s'"), (int) (end
- start
), start
);
2298 all_registers_info (char *addr_exp
, int from_tty
)
2300 registers_info (addr_exp
, 1);
2304 nofp_registers_info (char *addr_exp
, int from_tty
)
2306 registers_info (addr_exp
, 0);
2310 print_vector_info (struct ui_file
*file
,
2311 struct frame_info
*frame
, const char *args
)
2313 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
2315 if (gdbarch_print_vector_info_p (gdbarch
))
2316 gdbarch_print_vector_info (gdbarch
, file
, frame
, args
);
2320 int printed_something
= 0;
2323 regnum
< gdbarch_num_regs (gdbarch
)
2324 + gdbarch_num_pseudo_regs (gdbarch
);
2327 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, vector_reggroup
))
2329 printed_something
= 1;
2330 gdbarch_print_registers_info (gdbarch
, file
, frame
, regnum
, 1);
2333 if (!printed_something
)
2334 fprintf_filtered (file
, "No vector information\n");
2339 vector_info (char *args
, int from_tty
)
2341 if (!target_has_registers
)
2342 error (_("The program has no registers now."));
2344 print_vector_info (gdb_stdout
, get_selected_frame (NULL
), args
);
2347 /* Kill the inferior process. Make us have no inferior. */
2350 kill_command (char *arg
, int from_tty
)
2352 /* FIXME: This should not really be inferior_ptid (or target_has_execution).
2353 It should be a distinct flag that indicates that a target is active, cuz
2354 some targets don't have processes! */
2356 if (ptid_equal (inferior_ptid
, null_ptid
))
2357 error (_("The program is not being run."));
2358 if (!query (_("Kill the program being debugged? ")))
2359 error (_("Not confirmed."));
2362 /* If we still have other inferiors to debug, then don't mess with
2363 with their threads. */
2364 if (!have_inferiors ())
2366 init_thread_list (); /* Destroy thread info. */
2368 /* Killing off the inferior can leave us with a core file. If
2369 so, print the state we are left in. */
2370 if (target_has_stack
)
2372 printf_filtered (_("In %s,\n"), target_longname
);
2373 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
2376 bfd_cache_close_all ();
2379 /* Used in `attach&' command. ARG is a point to an integer
2380 representing a process id. Proceed threads of this process iff
2381 they stopped due to debugger request, and when they did, they
2382 reported a clean stop (GDB_SIGNAL_0). Do not proceed threads
2383 that have been explicitly been told to stop. */
2386 proceed_after_attach_callback (struct thread_info
*thread
,
2389 int pid
= * (int *) arg
;
2391 if (ptid_get_pid (thread
->ptid
) == pid
2392 && !is_exited (thread
->ptid
)
2393 && !is_executing (thread
->ptid
)
2394 && !thread
->stop_requested
2395 && thread
->suspend
.stop_signal
== GDB_SIGNAL_0
)
2397 switch_to_thread (thread
->ptid
);
2398 clear_proceed_status ();
2399 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
, 0);
2406 proceed_after_attach (int pid
)
2408 /* Don't error out if the current thread is running, because
2409 there may be other stopped threads. */
2410 struct cleanup
*old_chain
;
2412 /* Backup current thread and selected frame. */
2413 old_chain
= make_cleanup_restore_current_thread ();
2415 iterate_over_threads (proceed_after_attach_callback
, &pid
);
2417 /* Restore selected ptid. */
2418 do_cleanups (old_chain
);
2423 * Should save/restore the tty state since it might be that the
2424 * program to be debugged was started on this tty and it wants
2425 * the tty in some state other than what we want. If it's running
2426 * on another terminal or without a terminal, then saving and
2427 * restoring the tty state is a harmless no-op.
2428 * This only needs to be done if we are attaching to a process.
2431 /* attach_command --
2432 takes a program started up outside of gdb and ``attaches'' to it.
2433 This stops it cold in its tracks and allows us to start debugging it.
2434 and wait for the trace-trap that results from attaching. */
2437 attach_command_post_wait (char *args
, int from_tty
, int async_exec
)
2440 char *full_exec_path
= NULL
;
2441 struct inferior
*inferior
;
2443 inferior
= current_inferior ();
2444 inferior
->control
.stop_soon
= NO_STOP_QUIETLY
;
2446 /* If no exec file is yet known, try to determine it from the
2448 exec_file
= (char *) get_exec_file (0);
2451 exec_file
= target_pid_to_exec_file (PIDGET (inferior_ptid
));
2454 /* It's possible we don't have a full path, but rather just a
2455 filename. Some targets, such as HP-UX, don't provide the
2458 Attempt to qualify the filename against the source path.
2459 (If that fails, we'll just fall back on the original
2460 filename. Not much more we can do...) */
2462 if (!source_full_path_of (exec_file
, &full_exec_path
))
2463 full_exec_path
= xstrdup (exec_file
);
2465 exec_file_attach (full_exec_path
, from_tty
);
2466 symbol_file_add_main (full_exec_path
, from_tty
);
2471 reopen_exec_file ();
2475 /* Take any necessary post-attaching actions for this platform. */
2476 target_post_attach (PIDGET (inferior_ptid
));
2478 post_create_inferior (¤t_target
, from_tty
);
2480 /* Install inferior's terminal modes. */
2481 target_terminal_inferior ();
2485 /* The user requested an `attach&', so be sure to leave threads
2486 that didn't get a signal running. */
2488 /* Immediatelly resume all suspended threads of this inferior,
2489 and this inferior only. This should have no effect on
2490 already running threads. If a thread has been stopped with a
2491 signal, leave it be. */
2493 proceed_after_attach (inferior
->pid
);
2496 if (inferior_thread ()->suspend
.stop_signal
== GDB_SIGNAL_0
)
2498 clear_proceed_status ();
2499 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
, 0);
2505 /* The user requested a plain `attach', so be sure to leave
2506 the inferior stopped. */
2508 if (target_can_async_p ())
2509 async_enable_stdin ();
2511 /* At least the current thread is already stopped. */
2513 /* In all-stop, by definition, all threads have to be already
2514 stopped at this point. In non-stop, however, although the
2515 selected thread is stopped, others may still be executing.
2516 Be sure to explicitly stop all threads of the process. This
2517 should have no effect on already stopped threads. */
2519 target_stop (pid_to_ptid (inferior
->pid
));
2521 /* Tell the user/frontend where we're stopped. */
2523 if (deprecated_attach_hook
)
2524 deprecated_attach_hook ();
2528 struct attach_command_continuation_args
2536 attach_command_continuation (void *args
, int err
)
2538 struct attach_command_continuation_args
*a
= args
;
2543 attach_command_post_wait (a
->args
, a
->from_tty
, a
->async_exec
);
2547 attach_command_continuation_free_args (void *args
)
2549 struct attach_command_continuation_args
*a
= args
;
2556 attach_command (char *args
, int from_tty
)
2559 struct cleanup
*back_to
= make_cleanup (null_cleanup
, NULL
);
2561 dont_repeat (); /* Not for the faint of heart */
2563 if (gdbarch_has_global_solist (target_gdbarch ()))
2564 /* Don't complain if all processes share the same symbol
2567 else if (target_has_execution
)
2569 if (query (_("A program is being debugged already. Kill it? ")))
2572 error (_("Not killed."));
2575 /* Clean up any leftovers from other runs. Some other things from
2576 this function should probably be moved into target_pre_inferior. */
2577 target_pre_inferior (from_tty
);
2579 if (non_stop
&& !target_supports_non_stop ())
2580 error (_("Cannot attach to this target in non-stop mode"));
2584 async_exec
= strip_bg_char (&args
);
2586 /* If we get a request for running in the bg but the target
2587 doesn't support it, error out. */
2588 if (async_exec
&& !target_can_async_p ())
2589 error (_("Asynchronous execution not supported on this target."));
2592 /* If we don't get a request of running in the bg, then we need
2593 to simulate synchronous (fg) execution. */
2594 if (!async_exec
&& target_can_async_p ())
2596 /* Simulate synchronous execution. */
2597 async_disable_stdin ();
2598 make_cleanup ((make_cleanup_ftype
*)async_enable_stdin
, NULL
);
2601 target_attach (args
, from_tty
);
2603 /* Set up the "saved terminal modes" of the inferior
2604 based on what modes we are starting it with. */
2605 target_terminal_init ();
2607 /* Set up execution context to know that we should return from
2608 wait_for_inferior as soon as the target reports a stop. */
2609 init_wait_for_inferior ();
2610 clear_proceed_status ();
2614 /* If we find that the current thread isn't stopped, explicitly
2615 do so now, because we're going to install breakpoints and
2619 /* The user requested an `attach&'; stop just one thread. */
2620 target_stop (inferior_ptid
);
2622 /* The user requested an `attach', so stop all threads of this
2624 target_stop (pid_to_ptid (ptid_get_pid (inferior_ptid
)));
2627 /* Some system don't generate traps when attaching to inferior.
2628 E.g. Mach 3 or GNU hurd. */
2629 if (!target_attach_no_wait
)
2631 struct inferior
*inferior
= current_inferior ();
2633 /* Careful here. See comments in inferior.h. Basically some
2634 OSes don't ignore SIGSTOPs on continue requests anymore. We
2635 need a way for handle_inferior_event to reset the stop_signal
2636 variable after an attach, and this is what
2637 STOP_QUIETLY_NO_SIGSTOP is for. */
2638 inferior
->control
.stop_soon
= STOP_QUIETLY_NO_SIGSTOP
;
2640 if (target_can_async_p ())
2642 /* sync_execution mode. Wait for stop. */
2643 struct attach_command_continuation_args
*a
;
2645 a
= xmalloc (sizeof (*a
));
2646 a
->args
= xstrdup (args
);
2647 a
->from_tty
= from_tty
;
2648 a
->async_exec
= async_exec
;
2649 add_inferior_continuation (attach_command_continuation
, a
,
2650 attach_command_continuation_free_args
);
2651 discard_cleanups (back_to
);
2655 wait_for_inferior ();
2658 attach_command_post_wait (args
, from_tty
, async_exec
);
2659 discard_cleanups (back_to
);
2662 /* We had just found out that the target was already attached to an
2663 inferior. PTID points at a thread of this new inferior, that is
2664 the most likely to be stopped right now, but not necessarily so.
2665 The new inferior is assumed to be already added to the inferior
2666 list at this point. If LEAVE_RUNNING, then leave the threads of
2667 this inferior running, except those we've explicitly seen reported
2671 notice_new_inferior (ptid_t ptid
, int leave_running
, int from_tty
)
2673 struct cleanup
* old_chain
;
2676 old_chain
= make_cleanup (null_cleanup
, NULL
);
2678 /* If in non-stop, leave threads as running as they were. If
2679 they're stopped for some reason other than us telling it to, the
2680 target reports a signal != GDB_SIGNAL_0. We don't try to
2681 resume threads with such a stop signal. */
2682 async_exec
= non_stop
;
2684 if (!ptid_equal (inferior_ptid
, null_ptid
))
2685 make_cleanup_restore_current_thread ();
2687 switch_to_thread (ptid
);
2689 /* When we "notice" a new inferior we need to do all the things we
2690 would normally do if we had just attached to it. */
2692 if (is_executing (inferior_ptid
))
2694 struct inferior
*inferior
= current_inferior ();
2696 /* We're going to install breakpoints, and poke at memory,
2697 ensure that the inferior is stopped for a moment while we do
2699 target_stop (inferior_ptid
);
2701 inferior
->control
.stop_soon
= STOP_QUIETLY_REMOTE
;
2703 /* Wait for stop before proceeding. */
2704 if (target_can_async_p ())
2706 struct attach_command_continuation_args
*a
;
2708 a
= xmalloc (sizeof (*a
));
2709 a
->args
= xstrdup ("");
2710 a
->from_tty
= from_tty
;
2711 a
->async_exec
= async_exec
;
2712 add_inferior_continuation (attach_command_continuation
, a
,
2713 attach_command_continuation_free_args
);
2715 do_cleanups (old_chain
);
2719 wait_for_inferior ();
2722 async_exec
= leave_running
;
2723 attach_command_post_wait ("" /* args */, from_tty
, async_exec
);
2725 do_cleanups (old_chain
);
2730 * takes a program previously attached to and detaches it.
2731 * The program resumes execution and will no longer stop
2732 * on signals, etc. We better not have left any breakpoints
2733 * in the program or it'll die when it hits one. For this
2734 * to work, it may be necessary for the process to have been
2735 * previously attached. It *might* work if the program was
2736 * started via the normal ptrace (PTRACE_TRACEME).
2740 detach_command (char *args
, int from_tty
)
2742 dont_repeat (); /* Not for the faint of heart. */
2744 if (ptid_equal (inferior_ptid
, null_ptid
))
2745 error (_("The program is not being run."));
2747 disconnect_tracing (from_tty
);
2749 target_detach (args
, from_tty
);
2751 /* If the solist is global across inferiors, don't clear it when we
2752 detach from a single inferior. */
2753 if (!gdbarch_has_global_solist (target_gdbarch ()))
2754 no_shared_libraries (NULL
, from_tty
);
2756 /* If we still have inferiors to debug, then don't mess with their
2758 if (!have_inferiors ())
2759 init_thread_list ();
2761 if (deprecated_detach_hook
)
2762 deprecated_detach_hook ();
2765 /* Disconnect from the current target without resuming it (leaving it
2766 waiting for a debugger).
2768 We'd better not have left any breakpoints in the program or the
2769 next debugger will get confused. Currently only supported for some
2770 remote targets, since the normal attach mechanisms don't work on
2771 stopped processes on some native platforms (e.g. GNU/Linux). */
2774 disconnect_command (char *args
, int from_tty
)
2776 dont_repeat (); /* Not for the faint of heart. */
2777 disconnect_tracing (from_tty
);
2778 target_disconnect (args
, from_tty
);
2779 no_shared_libraries (NULL
, from_tty
);
2780 init_thread_list ();
2781 if (deprecated_detach_hook
)
2782 deprecated_detach_hook ();
2786 interrupt_target_1 (int all_threads
)
2791 ptid
= minus_one_ptid
;
2793 ptid
= inferior_ptid
;
2796 /* Tag the thread as having been explicitly requested to stop, so
2797 other parts of gdb know not to resume this thread automatically,
2798 if it was stopped due to an internal event. Limit this to
2799 non-stop mode, as when debugging a multi-threaded application in
2800 all-stop mode, we will only get one stop event --- it's undefined
2801 which thread will report the event. */
2803 set_stop_requested (ptid
, 1);
2806 /* Stop the execution of the target while running in async mode, in
2807 the backgound. In all-stop, stop the whole process. In non-stop
2808 mode, stop the current thread only by default, or stop all threads
2809 if the `-a' switch is used. */
2811 /* interrupt [-a] */
2813 interrupt_target_command (char *args
, int from_tty
)
2815 if (target_can_async_p ())
2817 int all_threads
= 0;
2819 dont_repeat (); /* Not for the faint of heart. */
2822 && strncmp (args
, "-a", sizeof ("-a") - 1) == 0)
2825 if (!non_stop
&& all_threads
)
2826 error (_("-a is meaningless in all-stop mode."));
2828 interrupt_target_1 (all_threads
);
2833 print_float_info (struct ui_file
*file
,
2834 struct frame_info
*frame
, const char *args
)
2836 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
2838 if (gdbarch_print_float_info_p (gdbarch
))
2839 gdbarch_print_float_info (gdbarch
, file
, frame
, args
);
2843 int printed_something
= 0;
2846 regnum
< gdbarch_num_regs (gdbarch
)
2847 + gdbarch_num_pseudo_regs (gdbarch
);
2850 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, float_reggroup
))
2852 printed_something
= 1;
2853 gdbarch_print_registers_info (gdbarch
, file
, frame
, regnum
, 1);
2856 if (!printed_something
)
2857 fprintf_filtered (file
, "No floating-point info "
2858 "available for this processor.\n");
2863 float_info (char *args
, int from_tty
)
2865 if (!target_has_registers
)
2866 error (_("The program has no registers now."));
2868 print_float_info (gdb_stdout
, get_selected_frame (NULL
), args
);
2872 unset_command (char *args
, int from_tty
)
2874 printf_filtered (_("\"unset\" must be followed by the "
2875 "name of an unset subcommand.\n"));
2876 help_list (unsetlist
, "unset ", -1, gdb_stdout
);
2879 /* Implement `info proc' family of commands. */
2882 info_proc_cmd_1 (char *args
, enum info_proc_what what
, int from_tty
)
2884 struct gdbarch
*gdbarch
= get_current_arch ();
2886 if (gdbarch_info_proc_p (gdbarch
))
2887 gdbarch_info_proc (gdbarch
, args
, what
);
2889 target_info_proc (args
, what
);
2892 /* Implement `info proc' when given without any futher parameters. */
2895 info_proc_cmd (char *args
, int from_tty
)
2897 info_proc_cmd_1 (args
, IP_MINIMAL
, from_tty
);
2900 /* Implement `info proc mappings'. */
2903 info_proc_cmd_mappings (char *args
, int from_tty
)
2905 info_proc_cmd_1 (args
, IP_MAPPINGS
, from_tty
);
2908 /* Implement `info proc stat'. */
2911 info_proc_cmd_stat (char *args
, int from_tty
)
2913 info_proc_cmd_1 (args
, IP_STAT
, from_tty
);
2916 /* Implement `info proc status'. */
2919 info_proc_cmd_status (char *args
, int from_tty
)
2921 info_proc_cmd_1 (args
, IP_STATUS
, from_tty
);
2924 /* Implement `info proc cwd'. */
2927 info_proc_cmd_cwd (char *args
, int from_tty
)
2929 info_proc_cmd_1 (args
, IP_CWD
, from_tty
);
2932 /* Implement `info proc cmdline'. */
2935 info_proc_cmd_cmdline (char *args
, int from_tty
)
2937 info_proc_cmd_1 (args
, IP_CMDLINE
, from_tty
);
2940 /* Implement `info proc exe'. */
2943 info_proc_cmd_exe (char *args
, int from_tty
)
2945 info_proc_cmd_1 (args
, IP_EXE
, from_tty
);
2948 /* Implement `info proc all'. */
2951 info_proc_cmd_all (char *args
, int from_tty
)
2953 info_proc_cmd_1 (args
, IP_ALL
, from_tty
);
2957 _initialize_infcmd (void)
2959 static struct cmd_list_element
*info_proc_cmdlist
;
2960 struct cmd_list_element
*c
= NULL
;
2963 /* Add the filename of the terminal connected to inferior I/O. */
2964 add_setshow_filename_cmd ("inferior-tty", class_run
,
2965 &inferior_io_terminal_scratch
, _("\
2966 Set terminal for future runs of program being debugged."), _("\
2967 Show terminal for future runs of program being debugged."), _("\
2968 Usage: set inferior-tty /dev/pts/1"),
2969 set_inferior_tty_command
,
2970 show_inferior_tty_command
,
2971 &setlist
, &showlist
);
2972 add_com_alias ("tty", "set inferior-tty", class_alias
, 0);
2975 add_setshow_string_noescape_cmd (cmd_name
, class_run
,
2976 &inferior_args_scratch
, _("\
2977 Set argument list to give program being debugged when it is started."), _("\
2978 Show argument list to give program being debugged when it is started."), _("\
2979 Follow this command with any number of args, to be passed to the program."),
2982 &setlist
, &showlist
);
2983 c
= lookup_cmd (&cmd_name
, setlist
, "", -1, 1);
2984 gdb_assert (c
!= NULL
);
2985 set_cmd_completer (c
, filename_completer
);
2987 c
= add_cmd ("environment", no_class
, environment_info
, _("\
2988 The environment to give the program, or one variable's value.\n\
2989 With an argument VAR, prints the value of environment variable VAR to\n\
2990 give the program being debugged. With no arguments, prints the entire\n\
2991 environment to be given to the program."), &showlist
);
2992 set_cmd_completer (c
, noop_completer
);
2994 add_prefix_cmd ("unset", no_class
, unset_command
,
2995 _("Complement to certain \"set\" commands."),
2996 &unsetlist
, "unset ", 0, &cmdlist
);
2998 c
= add_cmd ("environment", class_run
, unset_environment_command
, _("\
2999 Cancel environment variable VAR for the program.\n\
3000 This does not affect the program until the next \"run\" command."),
3002 set_cmd_completer (c
, noop_completer
);
3004 c
= add_cmd ("environment", class_run
, set_environment_command
, _("\
3005 Set environment variable value to give the program.\n\
3006 Arguments are VAR VALUE where VAR is variable name and VALUE is value.\n\
3007 VALUES of environment variables are uninterpreted strings.\n\
3008 This does not affect the program until the next \"run\" command."),
3010 set_cmd_completer (c
, noop_completer
);
3012 c
= add_com ("path", class_files
, path_command
, _("\
3013 Add directory DIR(s) to beginning of search path for object files.\n\
3014 $cwd in the path means the current working directory.\n\
3015 This path is equivalent to the $PATH shell variable. It is a list of\n\
3016 directories, separated by colons. These directories are searched to find\n\
3017 fully linked executable files and separately compiled object files as \
3019 set_cmd_completer (c
, filename_completer
);
3021 c
= add_cmd ("paths", no_class
, path_info
, _("\
3022 Current search path for finding object files.\n\
3023 $cwd in the path means the current working directory.\n\
3024 This path is equivalent to the $PATH shell variable. It is a list of\n\
3025 directories, separated by colons. These directories are searched to find\n\
3026 fully linked executable files and separately compiled object files as \
3029 set_cmd_completer (c
, noop_completer
);
3031 add_prefix_cmd ("kill", class_run
, kill_command
,
3032 _("Kill execution of program being debugged."),
3033 &killlist
, "kill ", 0, &cmdlist
);
3035 add_com ("attach", class_run
, attach_command
, _("\
3036 Attach to a process or file outside of GDB.\n\
3037 This command attaches to another target, of the same type as your last\n\
3038 \"target\" command (\"info files\" will show your target stack).\n\
3039 The command may take as argument a process id or a device file.\n\
3040 For a process id, you must have permission to send the process a signal,\n\
3041 and it must have the same effective uid as the debugger.\n\
3042 When using \"attach\" with a process id, the debugger finds the\n\
3043 program running in the process, looking first in the current working\n\
3044 directory, or (if not found there) using the source file search path\n\
3045 (see the \"directory\" command). You can also use the \"file\" command\n\
3046 to specify the program, and to load its symbol table."));
3048 add_prefix_cmd ("detach", class_run
, detach_command
, _("\
3049 Detach a process or file previously attached.\n\
3050 If a process, it is no longer traced, and it continues its execution. If\n\
3051 you were debugging a file, the file is closed and gdb no longer accesses it."),
3052 &detachlist
, "detach ", 0, &cmdlist
);
3054 add_com ("disconnect", class_run
, disconnect_command
, _("\
3055 Disconnect from a target.\n\
3056 The target will wait for another debugger to connect. Not available for\n\
3059 c
= add_com ("signal", class_run
, signal_command
, _("\
3060 Continue program with the specified signal.\n\
3061 Usage: signal SIGNAL\n\
3062 The SIGNAL argument is processed the same as the handle command.\n\
3064 An argument of \"0\" means continue the program without sending it a signal.\n\
3065 This is useful in cases where the program stopped because of a signal,\n\
3066 and you want to resume the program while discarding the signal."));
3067 set_cmd_completer (c
, signal_completer
);
3069 add_com ("stepi", class_run
, stepi_command
, _("\
3070 Step one instruction exactly.\n\
3072 Argument N means step N times (or till program stops for another \
3074 add_com_alias ("si", "stepi", class_alias
, 0);
3076 add_com ("nexti", class_run
, nexti_command
, _("\
3077 Step one instruction, but proceed through subroutine calls.\n\
3079 Argument N means step N times (or till program stops for another \
3081 add_com_alias ("ni", "nexti", class_alias
, 0);
3083 add_com ("finish", class_run
, finish_command
, _("\
3084 Execute until selected stack frame returns.\n\
3086 Upon return, the value returned is printed and put in the value history."));
3087 add_com_alias ("fin", "finish", class_run
, 1);
3089 add_com ("next", class_run
, next_command
, _("\
3090 Step program, proceeding through subroutine calls.\n\
3092 Unlike \"step\", if the current source line calls a subroutine,\n\
3093 this command does not enter the subroutine, but instead steps over\n\
3094 the call, in effect treating it as a single source line."));
3095 add_com_alias ("n", "next", class_run
, 1);
3097 add_com_alias ("S", "next", class_run
, 1);
3099 add_com ("step", class_run
, step_command
, _("\
3100 Step program until it reaches a different source line.\n\
3102 Argument N means step N times (or till program stops for another \
3104 add_com_alias ("s", "step", class_run
, 1);
3106 c
= add_com ("until", class_run
, until_command
, _("\
3107 Execute until the program reaches a source line greater than the current\n\
3108 or a specified location (same args as break command) within the current \
3110 set_cmd_completer (c
, location_completer
);
3111 add_com_alias ("u", "until", class_run
, 1);
3113 c
= add_com ("advance", class_run
, advance_command
, _("\
3114 Continue the program up to the given location (same form as args for break \
3116 Execution will also stop upon exit from the current stack frame."));
3117 set_cmd_completer (c
, location_completer
);
3119 c
= add_com ("jump", class_run
, jump_command
, _("\
3120 Continue program being debugged at specified line or address.\n\
3121 Usage: jump <location>\n\
3122 Give as argument either LINENUM or *ADDR, where ADDR is an expression\n\
3123 for an address to start at."));
3124 set_cmd_completer (c
, location_completer
);
3125 add_com_alias ("j", "jump", class_run
, 1);
3129 c
= add_com ("go", class_run
, go_command
, _("\
3130 Usage: go <location>\n\
3131 Continue program being debugged, stopping at specified line or \n\
3133 Give as argument either LINENUM or *ADDR, where ADDR is an \n\
3134 expression for an address to start at.\n\
3135 This command is a combination of tbreak and jump."));
3136 set_cmd_completer (c
, location_completer
);
3140 add_com_alias ("g", "go", class_run
, 1);
3142 add_com ("continue", class_run
, continue_command
, _("\
3143 Continue program being debugged, after signal or breakpoint.\n\
3144 Usage: continue [N]\n\
3145 If proceeding from breakpoint, a number N may be used as an argument,\n\
3146 which means to set the ignore count of that breakpoint to N - 1 (so that\n\
3147 the breakpoint won't break until the Nth time it is reached).\n\
3149 If non-stop mode is enabled, continue only the current thread,\n\
3150 otherwise all the threads in the program are continued. To \n\
3151 continue all stopped threads in non-stop mode, use the -a option.\n\
3152 Specifying -a and an ignore count simultaneously is an error."));
3153 add_com_alias ("c", "cont", class_run
, 1);
3154 add_com_alias ("fg", "cont", class_run
, 1);
3156 c
= add_com ("run", class_run
, run_command
, _("\
3157 Start debugged program. You may specify arguments to give it.\n\
3158 Args may include \"*\", or \"[...]\"; they are expanded using \"sh\".\n\
3159 Input and output redirection with \">\", \"<\", or \">>\" are also \
3161 With no arguments, uses arguments last specified (with \"run\" \
3162 or \"set args\").\n\
3163 To cancel previous arguments and run with no arguments,\n\
3164 use \"set args\" without arguments."));
3165 set_cmd_completer (c
, filename_completer
);
3166 add_com_alias ("r", "run", class_run
, 1);
3168 add_com ("R", class_run
, run_no_args_command
,
3169 _("Start debugged program with no arguments."));
3171 c
= add_com ("start", class_run
, start_command
, _("\
3172 Run the debugged program until the beginning of the main procedure.\n\
3173 You may specify arguments to give to your program, just as with the\n\
3174 \"run\" command."));
3175 set_cmd_completer (c
, filename_completer
);
3177 add_com ("interrupt", class_run
, interrupt_target_command
,
3178 _("Interrupt the execution of the debugged program.\n\
3179 If non-stop mode is enabled, interrupt only the current thread,\n\
3180 otherwise all the threads in the program are stopped. To \n\
3181 interrupt all running threads in non-stop mode, use the -a option."));
3183 add_info ("registers", nofp_registers_info
, _("\
3184 List of integer registers and their contents, for selected stack frame.\n\
3185 Register name as argument means describe only that register."));
3186 add_info_alias ("r", "registers", 1);
3189 add_com ("lr", class_info
, nofp_registers_info
, _("\
3190 List of integer registers and their contents, for selected stack frame.\n\
3191 Register name as argument means describe only that register."));
3192 add_info ("all-registers", all_registers_info
, _("\
3193 List of all registers and their contents, for selected stack frame.\n\
3194 Register name as argument means describe only that register."));
3196 add_info ("program", program_info
,
3197 _("Execution status of the program."));
3199 add_info ("float", float_info
,
3200 _("Print the status of the floating point unit\n"));
3202 add_info ("vector", vector_info
,
3203 _("Print the status of the vector unit\n"));
3205 add_prefix_cmd ("proc", class_info
, info_proc_cmd
,
3207 Show /proc process information about any running process.\n\
3208 Specify any process id, or use the program being debugged by default."),
3209 &info_proc_cmdlist
, "info proc ",
3210 1/*allow-unknown*/, &infolist
);
3212 add_cmd ("mappings", class_info
, info_proc_cmd_mappings
, _("\
3213 List of mapped memory regions."),
3214 &info_proc_cmdlist
);
3216 add_cmd ("stat", class_info
, info_proc_cmd_stat
, _("\
3217 List process info from /proc/PID/stat."),
3218 &info_proc_cmdlist
);
3220 add_cmd ("status", class_info
, info_proc_cmd_status
, _("\
3221 List process info from /proc/PID/status."),
3222 &info_proc_cmdlist
);
3224 add_cmd ("cwd", class_info
, info_proc_cmd_cwd
, _("\
3225 List current working directory of the process."),
3226 &info_proc_cmdlist
);
3228 add_cmd ("cmdline", class_info
, info_proc_cmd_cmdline
, _("\
3229 List command line arguments of the process."),
3230 &info_proc_cmdlist
);
3232 add_cmd ("exe", class_info
, info_proc_cmd_exe
, _("\
3233 List absolute filename for executable of the process."),
3234 &info_proc_cmdlist
);
3236 add_cmd ("all", class_info
, info_proc_cmd_all
, _("\
3237 List all available /proc info."),
3238 &info_proc_cmdlist
);