1 /* Memory-access and commands for "inferior" process, for GDB.
3 Copyright (C) 1986-2013 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 /* Local functions: */
62 static void nofp_registers_info (char *, int);
64 static void print_return_value (struct value
*function
,
65 struct type
*value_type
);
67 static void until_next_command (int);
69 static void until_command (char *, int);
71 static void path_info (char *, int);
73 static void path_command (char *, int);
75 static void unset_command (char *, int);
77 static void float_info (char *, int);
79 static void disconnect_command (char *, int);
81 static void unset_environment_command (char *, int);
83 static void set_environment_command (char *, int);
85 static void environment_info (char *, int);
87 static void program_info (char *, int);
89 static void finish_command (char *, int);
91 static void signal_command (char *, int);
93 static void jump_command (char *, int);
95 static void step_1 (int, int, char *);
96 static void step_once (int skip_subroutines
, int single_inst
,
97 int count
, int thread
);
99 static void next_command (char *, int);
101 static void step_command (char *, int);
103 static void run_command (char *, int);
105 static void run_no_args_command (char *args
, int from_tty
);
107 static void go_command (char *line_no
, int from_tty
);
109 static int strip_bg_char (char **);
111 void _initialize_infcmd (void);
113 #define ERROR_NO_INFERIOR \
114 if (!target_has_execution) error (_("The program is not being run."));
116 /* Scratch area where string containing arguments to give to the
117 program will be stored by 'set args'. As soon as anything is
118 stored, notice_args_set will move it into per-inferior storage.
119 Arguments are separated by spaces. Empty string (pointer to '\0')
122 static char *inferior_args_scratch
;
124 /* Scratch area where 'set inferior-tty' will store user-provided value.
125 We'll immediate copy it into per-inferior storage. */
127 static char *inferior_io_terminal_scratch
;
129 /* Pid of our debugged inferior, or 0 if no inferior now.
130 Since various parts of infrun.c test this to see whether there is a program
131 being debugged it should be nonzero (currently 3 is used) for remote
134 ptid_t inferior_ptid
;
136 /* Address at which inferior stopped. */
140 /* Nonzero if stopped due to completion of a stack dummy routine. */
142 enum stop_stack_kind stop_stack_dummy
;
144 /* Nonzero if stopped due to a random (unexpected) signal in inferior
147 int stopped_by_random_signal
;
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. */
232 set_args_command (char *args
, int from_tty
, struct cmd_list_element
*c
)
234 /* CLI has assigned the user-provided value to inferior_args_scratch.
235 Now route it to current inferior. */
236 set_inferior_args (inferior_args_scratch
);
239 /* Notice when `show args' is run. */
241 show_args_command (struct ui_file
*file
, int from_tty
,
242 struct cmd_list_element
*c
, const char *value
)
244 /* Note that we ignore the passed-in value in favor of computing it
246 deprecated_show_value_hack (file
, from_tty
, c
, get_inferior_args ());
250 /* Compute command-line string given argument vector. This does the
251 same shell processing as fork_inferior. */
253 construct_inferior_arguments (int argc
, char **argv
)
257 if (STARTUP_WITH_SHELL
)
260 /* This holds all the characters considered special to the
262 char *special
= "\"!&*|[]{}<>?`~^=;, \t\n";
263 const char quote
= '"';
265 /* This holds all the characters considered special to the
266 typical Unix shells. We include `^' because the SunOS
267 /bin/sh treats it as a synonym for `|'. */
268 char *special
= "\"!#$&*()\\|[]{}<>?'`~^; \t\n";
269 const char quote
= '\'';
275 /* We over-compute the size. It shouldn't matter. */
276 for (i
= 0; i
< argc
; ++i
)
277 length
+= 3 * strlen (argv
[i
]) + 1 + 2 * (argv
[i
][0] == '\0');
279 result
= (char *) xmalloc (length
);
282 for (i
= 0; i
< argc
; ++i
)
287 /* Need to handle empty arguments specially. */
288 if (argv
[i
][0] == '\0')
298 if (strpbrk (argv
[i
], special
))
304 for (cp
= argv
[i
]; *cp
; ++cp
)
308 /* A newline cannot be quoted with a backslash (it
309 just disappears), only by putting it inside
320 if (strchr (special
, *cp
) != NULL
)
336 /* In this case we can't handle arguments that contain spaces,
337 tabs, or newlines -- see breakup_args(). */
341 for (i
= 0; i
< argc
; ++i
)
343 char *cp
= strchr (argv
[i
], ' ');
345 cp
= strchr (argv
[i
], '\t');
347 cp
= strchr (argv
[i
], '\n');
349 error (_("can't handle command-line "
350 "argument containing whitespace"));
351 length
+= strlen (argv
[i
]) + 1;
354 result
= (char *) xmalloc (length
);
356 for (i
= 0; i
< argc
; ++i
)
359 strcat (result
, " ");
360 strcat (result
, argv
[i
]);
368 /* This function detects whether or not a '&' character (indicating
369 background execution) has been added as *the last* of the arguments ARGS
370 of a command. If it has, it removes it and returns 1. Otherwise it
371 does nothing and returns 0. */
373 strip_bg_char (char **args
)
377 p
= strchr (*args
, '&');
381 if (p
== (*args
+ strlen (*args
) - 1))
383 if (strlen (*args
) > 1)
387 while (*p
== ' ' || *p
== '\t');
398 /* Common actions to take after creating any sort of inferior, by any
399 means (running, attaching, connecting, et cetera). The target
400 should be stopped. */
403 post_create_inferior (struct target_ops
*target
, int from_tty
)
405 volatile struct gdb_exception ex
;
407 /* Be sure we own the terminal in case write operations are performed. */
408 target_terminal_ours ();
410 /* If the target hasn't taken care of this already, do it now.
411 Targets which need to access registers during to_open,
412 to_create_inferior, or to_attach should do it earlier; but many
414 target_find_description ();
416 /* Now that we know the register layout, retrieve current PC. But
417 if the PC is unavailable (e.g., we're opening a core file with
418 missing registers info), ignore it. */
420 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
422 stop_pc
= regcache_read_pc (get_current_regcache ());
424 if (ex
.reason
< 0 && ex
.error
!= NOT_AVAILABLE_ERROR
)
425 throw_exception (ex
);
429 const unsigned solib_add_generation
430 = current_program_space
->solib_add_generation
;
432 /* Create the hooks to handle shared library load and unload
434 #ifdef SOLIB_CREATE_INFERIOR_HOOK
435 SOLIB_CREATE_INFERIOR_HOOK (PIDGET (inferior_ptid
));
437 solib_create_inferior_hook (from_tty
);
440 if (current_program_space
->solib_add_generation
== solib_add_generation
)
442 /* The platform-specific hook should load initial shared libraries,
443 but didn't. FROM_TTY will be incorrectly 0 but such solib
444 targets should be fixed anyway. Call it only after the solib
445 target has been initialized by solib_create_inferior_hook. */
448 warning (_("platform-specific solib_create_inferior_hook did "
449 "not load initial shared libraries."));
451 /* If the solist is global across processes, there's no need to
453 if (!gdbarch_has_global_solist (target_gdbarch ()))
456 SOLIB_ADD (NULL
, 0, target
, auto_solib_add
);
458 solib_add (NULL
, 0, target
, auto_solib_add
);
464 /* If the user sets watchpoints before execution having started,
465 then she gets software watchpoints, because GDB can't know which
466 target will end up being pushed, or if it supports hardware
467 watchpoints or not. breakpoint_re_set takes care of promoting
468 watchpoints to hardware watchpoints if possible, however, if this
469 new inferior doesn't load shared libraries or we don't pull in
470 symbols from any other source on this target/arch,
471 breakpoint_re_set is never called. Call it now so that software
472 watchpoints get a chance to be promoted to hardware watchpoints
473 if the now pushed target supports hardware watchpoints. */
474 breakpoint_re_set ();
476 observer_notify_inferior_created (target
, from_tty
);
479 /* Kill the inferior if already running. This function is designed
480 to be called when we are about to start the execution of the program
481 from the beginning. Ask the user to confirm that he wants to restart
482 the program being debugged when FROM_TTY is non-null. */
485 kill_if_already_running (int from_tty
)
487 if (! ptid_equal (inferior_ptid
, null_ptid
) && target_has_execution
)
489 /* Bail out before killing the program if we will not be able to
491 target_require_runnable ();
494 && !query (_("The program being debugged has been started already.\n\
495 Start it from the beginning? ")))
496 error (_("Program not restarted."));
501 /* Implement the "run" command. If TBREAK_AT_MAIN is set, then insert
502 a temporary breakpoint at the begining of the main program before
503 running the program. */
506 run_command_1 (char *args
, int from_tty
, int tbreak_at_main
)
509 struct cleanup
*old_chain
;
511 struct ui_out
*uiout
= current_uiout
;
515 kill_if_already_running (from_tty
);
517 init_wait_for_inferior ();
518 clear_breakpoint_hit_counts ();
520 /* Clean up any leftovers from other runs. Some other things from
521 this function should probably be moved into target_pre_inferior. */
522 target_pre_inferior (from_tty
);
524 /* The comment here used to read, "The exec file is re-read every
525 time we do a generic_mourn_inferior, so we just have to worry
526 about the symbol file." The `generic_mourn_inferior' function
527 gets called whenever the program exits. However, suppose the
528 program exits, and *then* the executable file changes? We need
529 to check again here. Since reopen_exec_file doesn't do anything
530 if the timestamp hasn't changed, I don't see the harm. */
534 /* Insert the temporary breakpoint if a location was specified. */
536 tbreak_command (main_name (), 0);
538 exec_file
= (char *) get_exec_file (0);
540 if (non_stop
&& !target_supports_non_stop ())
541 error (_("The target does not support running in non-stop mode."));
543 /* We keep symbols from add-symbol-file, on the grounds that the
544 user might want to add some symbols before running the program
545 (right?). But sometimes (dynamic loading where the user manually
546 introduces the new symbols with add-symbol-file), the code which
547 the symbols describe does not persist between runs. Currently
548 the user has to manually nuke all symbols between runs if they
549 want them to go away (PR 2207). This is probably reasonable. */
553 if (target_can_async_p ())
554 async_disable_stdin ();
558 int async_exec
= strip_bg_char (&args
);
560 /* If we get a request for running in the bg but the target
561 doesn't support it, error out. */
562 if (async_exec
&& !target_can_async_p ())
563 error (_("Asynchronous execution not supported on this target."));
565 /* If we don't get a request of running in the bg, then we need
566 to simulate synchronous (fg) execution. */
567 if (!async_exec
&& target_can_async_p ())
569 /* Simulate synchronous execution. */
570 async_disable_stdin ();
573 /* If there were other args, beside '&', process them. */
575 set_inferior_args (args
);
580 ui_out_field_string (uiout
, NULL
, "Starting program");
581 ui_out_text (uiout
, ": ");
583 ui_out_field_string (uiout
, "execfile", exec_file
);
584 ui_out_spaces (uiout
, 1);
585 /* We call get_inferior_args() because we might need to compute
587 ui_out_field_string (uiout
, "infargs", get_inferior_args ());
588 ui_out_text (uiout
, "\n");
589 ui_out_flush (uiout
);
592 /* We call get_inferior_args() because we might need to compute
594 target_create_inferior (exec_file
, get_inferior_args (),
595 environ_vector (current_inferior ()->environment
),
598 /* We're starting off a new process. When we get out of here, in
599 non-stop mode, finish the state of all threads of that process,
600 but leave other threads alone, as they may be stopped in internal
601 events --- the frontend shouldn't see them as stopped. In
602 all-stop, always finish the state of all threads, as we may be
603 resuming more than just the new process. */
605 ptid
= pid_to_ptid (ptid_get_pid (inferior_ptid
));
607 ptid
= minus_one_ptid
;
608 old_chain
= make_cleanup (finish_thread_state_cleanup
, &ptid
);
610 /* Pass zero for FROM_TTY, because at this point the "run" command
611 has done its thing; now we are setting up the running program. */
612 post_create_inferior (¤t_target
, 0);
614 /* Start the target running. Do not use -1 continuation as it would skip
615 breakpoint right at the entry point. */
616 proceed (regcache_read_pc (get_current_regcache ()), GDB_SIGNAL_0
, 0);
618 /* Since there was no error, there's no need to finish the thread
620 discard_cleanups (old_chain
);
624 run_command (char *args
, int from_tty
)
626 run_command_1 (args
, from_tty
, 0);
630 run_no_args_command (char *args
, int from_tty
)
632 set_inferior_args ("");
636 /* Start the execution of the program up until the beginning of the main
640 start_command (char *args
, int from_tty
)
642 /* Some languages such as Ada need to search inside the program
643 minimal symbols for the location where to put the temporary
644 breakpoint before starting. */
645 if (!have_minimal_symbols ())
646 error (_("No symbol table loaded. Use the \"file\" command."));
648 /* Run the program until reaching the main procedure... */
649 run_command_1 (args
, from_tty
, 1);
653 proceed_thread_callback (struct thread_info
*thread
, void *arg
)
655 /* We go through all threads individually instead of compressing
656 into a single target `resume_all' request, because some threads
657 may be stopped in internal breakpoints/events, or stopped waiting
658 for its turn in the displaced stepping queue (that is, they are
659 running && !executing). The target side has no idea about why
660 the thread is stopped, so a `resume_all' command would resume too
661 much. If/when GDB gains a way to tell the target `hold this
662 thread stopped until I say otherwise', then we can optimize
664 if (!is_stopped (thread
->ptid
))
667 switch_to_thread (thread
->ptid
);
668 clear_proceed_status ();
669 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
, 0);
674 ensure_valid_thread (void)
676 if (ptid_equal (inferior_ptid
, null_ptid
)
677 || is_exited (inferior_ptid
))
678 error (_("Cannot execute this command without a live selected thread."));
681 /* If the user is looking at trace frames, any resumption of execution
682 is likely to mix up recorded and live target data. So simply
683 disallow those commands. */
686 ensure_not_tfind_mode (void)
688 if (get_traceframe_number () >= 0)
689 error (_("Cannot execute this command while looking at trace frames."));
692 /* Throw an error indicating the current thread is running. */
695 error_is_running (void)
697 error (_("Cannot execute this command while "
698 "the selected thread is running."));
701 /* Calls error_is_running if the current thread is running. */
704 ensure_not_running (void)
706 if (is_running (inferior_ptid
))
711 continue_1 (int all_threads
)
714 ensure_not_tfind_mode ();
716 if (non_stop
&& all_threads
)
718 /* Don't error out if the current thread is running, because
719 there may be other stopped threads. */
720 struct cleanup
*old_chain
;
722 /* Backup current thread and selected frame. */
723 old_chain
= make_cleanup_restore_current_thread ();
725 iterate_over_threads (proceed_thread_callback
, NULL
);
727 /* Restore selected ptid. */
728 do_cleanups (old_chain
);
732 ensure_valid_thread ();
733 ensure_not_running ();
734 clear_proceed_status ();
735 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
, 0);
739 /* continue [-a] [proceed-count] [&] */
741 continue_command (char *args
, int from_tty
)
747 /* Find out whether we must run in the background. */
749 async_exec
= strip_bg_char (&args
);
751 /* If we must run in the background, but the target can't do it,
753 if (async_exec
&& !target_can_async_p ())
754 error (_("Asynchronous execution not supported on this target."));
756 /* If we are not asked to run in the bg, then prepare to run in the
757 foreground, synchronously. */
758 if (!async_exec
&& target_can_async_p ())
760 /* Simulate synchronous execution. */
761 async_disable_stdin ();
766 if (strncmp (args
, "-a", sizeof ("-a") - 1) == 0)
769 args
+= sizeof ("-a") - 1;
775 if (!non_stop
&& all_threads
)
776 error (_("`-a' is meaningless in all-stop mode."));
778 if (args
!= NULL
&& all_threads
)
779 error (_("Can't resume all threads and specify "
780 "proceed count simultaneously."));
782 /* If we have an argument left, set proceed count of breakpoint we
789 struct thread_info
*tp
;
792 tp
= find_thread_ptid (inferior_ptid
);
796 struct target_waitstatus ws
;
798 get_last_target_status (&last_ptid
, &ws
);
799 tp
= find_thread_ptid (last_ptid
);
802 bs
= tp
->control
.stop_bpstat
;
804 while ((stat
= bpstat_num (&bs
, &num
)) != 0)
807 set_ignore_count (num
,
808 parse_and_eval_long (args
) - 1,
810 /* set_ignore_count prints a message ending with a period.
811 So print two spaces before "Continuing.". */
813 printf_filtered (" ");
817 if (!stopped
&& from_tty
)
820 ("Not stopped at any breakpoint; argument ignored.\n");
825 printf_filtered (_("Continuing.\n"));
827 continue_1 (all_threads
);
830 /* Record the starting point of a "step" or "next" command. */
833 set_step_frame (void)
835 struct symtab_and_line sal
;
837 find_frame_sal (get_current_frame (), &sal
);
838 set_step_info (get_current_frame (), sal
);
841 /* Step until outside of current statement. */
844 step_command (char *count_string
, int from_tty
)
846 step_1 (0, 0, count_string
);
849 /* Likewise, but skip over subroutine calls as if single instructions. */
852 next_command (char *count_string
, int from_tty
)
854 step_1 (1, 0, count_string
);
857 /* Likewise, but step only one instruction. */
860 stepi_command (char *count_string
, int from_tty
)
862 step_1 (0, 1, count_string
);
866 nexti_command (char *count_string
, int from_tty
)
868 step_1 (1, 1, count_string
);
872 delete_longjmp_breakpoint_cleanup (void *arg
)
874 int thread
= * (int *) arg
;
875 delete_longjmp_breakpoint (thread
);
879 step_1 (int skip_subroutines
, int single_inst
, char *count_string
)
882 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
887 ensure_not_tfind_mode ();
888 ensure_valid_thread ();
889 ensure_not_running ();
892 async_exec
= strip_bg_char (&count_string
);
894 /* If we get a request for running in the bg but the target
895 doesn't support it, error out. */
896 if (async_exec
&& !target_can_async_p ())
897 error (_("Asynchronous execution not supported on this target."));
899 /* If we don't get a request of running in the bg, then we need
900 to simulate synchronous (fg) execution. */
901 if (!async_exec
&& target_can_async_p ())
903 /* Simulate synchronous execution. */
904 async_disable_stdin ();
907 count
= count_string
? parse_and_eval_long (count_string
) : 1;
909 if (!single_inst
|| skip_subroutines
) /* Leave si command alone. */
911 struct thread_info
*tp
= inferior_thread ();
913 if (in_thread_list (inferior_ptid
))
914 thread
= pid_to_thread_id (inferior_ptid
);
916 set_longjmp_breakpoint (tp
, get_frame_id (get_current_frame ()));
918 make_cleanup (delete_longjmp_breakpoint_cleanup
, &thread
);
921 /* In synchronous case, all is well; each step_once call will step once. */
922 if (!target_can_async_p ())
924 for (; count
> 0; count
--)
926 step_once (skip_subroutines
, single_inst
, count
, thread
);
928 if (!target_has_execution
)
932 struct thread_info
*tp
= inferior_thread ();
934 if (!tp
->control
.stop_step
|| !tp
->step_multi
)
936 /* If we stopped for some reason that is not stepping
937 there are no further steps to make. */
944 do_cleanups (cleanups
);
948 /* In the case of an asynchronous target things get complicated;
949 do only one step for now, before returning control to the
950 event loop. Let the continuation figure out how many other
951 steps we need to do, and handle them one at the time, through
953 step_once (skip_subroutines
, single_inst
, count
, thread
);
955 /* We are running, and the continuation is installed. It will
956 disable the longjmp breakpoint as appropriate. */
957 discard_cleanups (cleanups
);
961 struct step_1_continuation_args
964 int skip_subroutines
;
969 /* Called after we are done with one step operation, to check whether
970 we need to step again, before we print the prompt and return control
971 to the user. If count is > 1, we will need to do one more call to
972 proceed(), via step_once(). Basically it is like step_once and
973 step_1_continuation are co-recursive. */
975 step_1_continuation (void *args
, int err
)
977 struct step_1_continuation_args
*a
= args
;
979 if (target_has_execution
)
981 struct thread_info
*tp
;
983 tp
= inferior_thread ();
985 && tp
->step_multi
&& tp
->control
.stop_step
)
987 /* There are more steps to make, and we did stop due to
988 ending a stepping range. Do another step. */
989 step_once (a
->skip_subroutines
, a
->single_inst
,
990 a
->count
- 1, a
->thread
);
996 /* We either hit an error, or stopped for some reason that is
997 not stepping, or there are no further steps to make.
999 if (!a
->single_inst
|| a
->skip_subroutines
)
1000 delete_longjmp_breakpoint (a
->thread
);
1003 /* Do just one step operation. This is useful to implement the 'step
1004 n' kind of commands. In case of asynchronous targets, we will have
1005 to set up a continuation to be done after the target stops (after
1006 this one step). For synch targets, the caller handles further
1010 step_once (int skip_subroutines
, int single_inst
, int count
, int thread
)
1012 struct frame_info
*frame
= get_current_frame ();
1016 /* Don't assume THREAD is a valid thread id. It is set to -1 if
1017 the longjmp breakpoint was not required. Use the
1018 INFERIOR_PTID thread instead, which is the same thread when
1020 struct thread_info
*tp
= inferior_thread ();
1022 clear_proceed_status ();
1029 /* Step at an inlined function behaves like "down". */
1030 if (!skip_subroutines
1031 && inline_skipped_frames (inferior_ptid
))
1035 /* Pretend that we've ran. */
1036 resume_ptid
= user_visible_resume_ptid (1);
1037 set_running (resume_ptid
, 1);
1039 step_into_inline_frame (inferior_ptid
);
1041 step_once (skip_subroutines
, single_inst
, count
- 1, thread
);
1044 /* Pretend that we've stopped. */
1047 if (target_can_async_p ())
1048 inferior_event_handler (INF_EXEC_COMPLETE
, NULL
);
1053 pc
= get_frame_pc (frame
);
1054 find_pc_line_pc_range (pc
,
1055 &tp
->control
.step_range_start
,
1056 &tp
->control
.step_range_end
);
1058 /* If we have no line info, switch to stepi mode. */
1059 if (tp
->control
.step_range_end
== 0 && step_stop_if_no_debug
)
1060 tp
->control
.step_range_start
= tp
->control
.step_range_end
= 1;
1061 else if (tp
->control
.step_range_end
== 0)
1065 if (find_pc_partial_function (pc
, &name
,
1066 &tp
->control
.step_range_start
,
1067 &tp
->control
.step_range_end
) == 0)
1068 error (_("Cannot find bounds of current function"));
1070 target_terminal_ours ();
1071 printf_filtered (_("Single stepping until exit from function %s,"
1072 "\nwhich has no line number information.\n"),
1078 /* Say we are stepping, but stop after one insn whatever it does. */
1079 tp
->control
.step_range_start
= tp
->control
.step_range_end
= 1;
1080 if (!skip_subroutines
)
1082 Don't step over function calls, not even to functions lacking
1084 tp
->control
.step_over_calls
= STEP_OVER_NONE
;
1087 if (skip_subroutines
)
1088 tp
->control
.step_over_calls
= STEP_OVER_ALL
;
1090 tp
->step_multi
= (count
> 1);
1091 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
, 1);
1093 /* For async targets, register a continuation to do any
1094 additional steps. For sync targets, the caller will handle
1095 further stepping. */
1096 if (target_can_async_p ())
1098 struct step_1_continuation_args
*args
;
1100 args
= xmalloc (sizeof (*args
));
1101 args
->skip_subroutines
= skip_subroutines
;
1102 args
->single_inst
= single_inst
;
1103 args
->count
= count
;
1104 args
->thread
= thread
;
1106 add_intermediate_continuation (tp
, step_1_continuation
, args
, xfree
);
1112 /* Continue program at specified address. */
1115 jump_command (char *arg
, int from_tty
)
1117 struct gdbarch
*gdbarch
= get_current_arch ();
1119 struct symtabs_and_lines sals
;
1120 struct symtab_and_line sal
;
1126 ensure_not_tfind_mode ();
1127 ensure_valid_thread ();
1128 ensure_not_running ();
1130 /* Find out whether we must run in the background. */
1132 async_exec
= strip_bg_char (&arg
);
1134 /* If we must run in the background, but the target can't do it,
1136 if (async_exec
&& !target_can_async_p ())
1137 error (_("Asynchronous execution not supported on this target."));
1140 error_no_arg (_("starting address"));
1142 sals
= decode_line_with_last_displayed (arg
, DECODE_LINE_FUNFIRSTLINE
);
1143 if (sals
.nelts
!= 1)
1145 error (_("Unreasonable jump request"));
1151 if (sal
.symtab
== 0 && sal
.pc
== 0)
1152 error (_("No source file has been specified."));
1154 resolve_sal_pc (&sal
); /* May error out. */
1156 /* See if we are trying to jump to another function. */
1157 fn
= get_frame_function (get_current_frame ());
1158 sfn
= find_pc_function (sal
.pc
);
1159 if (fn
!= NULL
&& sfn
!= fn
)
1161 if (!query (_("Line %d is not in `%s'. Jump anyway? "), sal
.line
,
1162 SYMBOL_PRINT_NAME (fn
)))
1164 error (_("Not confirmed."));
1171 fixup_symbol_section (sfn
, 0);
1172 if (section_is_overlay (SYMBOL_OBJ_SECTION (sfn
)) &&
1173 !section_is_mapped (SYMBOL_OBJ_SECTION (sfn
)))
1175 if (!query (_("WARNING!!! Destination is in "
1176 "unmapped overlay! Jump anyway? ")))
1178 error (_("Not confirmed."));
1188 printf_filtered (_("Continuing at "));
1189 fputs_filtered (paddress (gdbarch
, addr
), gdb_stdout
);
1190 printf_filtered (".\n");
1193 /* If we are not asked to run in the bg, then prepare to run in the
1194 foreground, synchronously. */
1195 if (!async_exec
&& target_can_async_p ())
1197 /* Simulate synchronous execution. */
1198 async_disable_stdin ();
1201 clear_proceed_status ();
1202 proceed (addr
, GDB_SIGNAL_0
, 0);
1206 /* Go to line or address in current procedure. */
1208 go_command (char *line_no
, int from_tty
)
1210 if (line_no
== (char *) NULL
|| !*line_no
)
1211 printf_filtered (_("Usage: go <location>\n"));
1214 tbreak_command (line_no
, from_tty
);
1215 jump_command (line_no
, from_tty
);
1220 /* Continue program giving it specified signal. */
1223 signal_command (char *signum_exp
, int from_tty
)
1225 enum gdb_signal oursig
;
1228 dont_repeat (); /* Too dangerous. */
1230 ensure_not_tfind_mode ();
1231 ensure_valid_thread ();
1232 ensure_not_running ();
1234 /* Find out whether we must run in the background. */
1235 if (signum_exp
!= NULL
)
1236 async_exec
= strip_bg_char (&signum_exp
);
1238 /* If we must run in the background, but the target can't do it,
1240 if (async_exec
&& !target_can_async_p ())
1241 error (_("Asynchronous execution not supported on this target."));
1243 /* If we are not asked to run in the bg, then prepare to run in the
1244 foreground, synchronously. */
1245 if (!async_exec
&& target_can_async_p ())
1247 /* Simulate synchronous execution. */
1248 async_disable_stdin ();
1252 error_no_arg (_("signal number"));
1254 /* It would be even slicker to make signal names be valid expressions,
1255 (the type could be "enum $signal" or some such), then the user could
1256 assign them to convenience variables. */
1257 oursig
= gdb_signal_from_name (signum_exp
);
1259 if (oursig
== GDB_SIGNAL_UNKNOWN
)
1261 /* No, try numeric. */
1262 int num
= parse_and_eval_long (signum_exp
);
1265 oursig
= GDB_SIGNAL_0
;
1267 oursig
= gdb_signal_from_command (num
);
1272 if (oursig
== GDB_SIGNAL_0
)
1273 printf_filtered (_("Continuing with no signal.\n"));
1275 printf_filtered (_("Continuing with signal %s.\n"),
1276 gdb_signal_to_name (oursig
));
1279 clear_proceed_status ();
1280 proceed ((CORE_ADDR
) -1, oursig
, 0);
1283 /* Continuation args to be passed to the "until" command
1285 struct until_next_continuation_args
1287 /* The thread that was current when the command was executed. */
1291 /* A continuation callback for until_next_command. */
1294 until_next_continuation (void *arg
, int err
)
1296 struct until_next_continuation_args
*a
= arg
;
1298 delete_longjmp_breakpoint (a
->thread
);
1301 /* Proceed until we reach a different source line with pc greater than
1302 our current one or exit the function. We skip calls in both cases.
1304 Note that eventually this command should probably be changed so
1305 that only source lines are printed out when we hit the breakpoint
1306 we set. This may involve changes to wait_for_inferior and the
1307 proceed status code. */
1310 until_next_command (int from_tty
)
1312 struct frame_info
*frame
;
1314 struct symbol
*func
;
1315 struct symtab_and_line sal
;
1316 struct thread_info
*tp
= inferior_thread ();
1317 int thread
= tp
->num
;
1318 struct cleanup
*old_chain
;
1320 clear_proceed_status ();
1323 frame
= get_current_frame ();
1325 /* Step until either exited from this function or greater
1326 than the current line (if in symbolic section) or pc (if
1329 pc
= get_frame_pc (frame
);
1330 func
= find_pc_function (pc
);
1334 struct minimal_symbol
*msymbol
= lookup_minimal_symbol_by_pc (pc
);
1336 if (msymbol
== NULL
)
1337 error (_("Execution is not within a known function."));
1339 tp
->control
.step_range_start
= SYMBOL_VALUE_ADDRESS (msymbol
);
1340 tp
->control
.step_range_end
= pc
;
1344 sal
= find_pc_line (pc
, 0);
1346 tp
->control
.step_range_start
= BLOCK_START (SYMBOL_BLOCK_VALUE (func
));
1347 tp
->control
.step_range_end
= sal
.end
;
1350 tp
->control
.step_over_calls
= STEP_OVER_ALL
;
1352 tp
->step_multi
= 0; /* Only one call to proceed */
1354 set_longjmp_breakpoint (tp
, get_frame_id (frame
));
1355 old_chain
= make_cleanup (delete_longjmp_breakpoint_cleanup
, &thread
);
1357 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
, 1);
1359 if (target_can_async_p () && is_running (inferior_ptid
))
1361 struct until_next_continuation_args
*cont_args
;
1363 discard_cleanups (old_chain
);
1364 cont_args
= XNEW (struct until_next_continuation_args
);
1365 cont_args
->thread
= inferior_thread ()->num
;
1367 add_continuation (tp
, until_next_continuation
, cont_args
, xfree
);
1370 do_cleanups (old_chain
);
1374 until_command (char *arg
, int from_tty
)
1379 ensure_not_tfind_mode ();
1380 ensure_valid_thread ();
1381 ensure_not_running ();
1383 /* Find out whether we must run in the background. */
1385 async_exec
= strip_bg_char (&arg
);
1387 /* If we must run in the background, but the target can't do it,
1389 if (async_exec
&& !target_can_async_p ())
1390 error (_("Asynchronous execution not supported on this target."));
1392 /* If we are not asked to run in the bg, then prepare to run in the
1393 foreground, synchronously. */
1394 if (!async_exec
&& target_can_async_p ())
1396 /* Simulate synchronous execution. */
1397 async_disable_stdin ();
1401 until_break_command (arg
, from_tty
, 0);
1403 until_next_command (from_tty
);
1407 advance_command (char *arg
, int from_tty
)
1412 ensure_not_tfind_mode ();
1413 ensure_valid_thread ();
1414 ensure_not_running ();
1417 error_no_arg (_("a location"));
1419 /* Find out whether we must run in the background. */
1421 async_exec
= strip_bg_char (&arg
);
1423 /* If we must run in the background, but the target can't do it,
1425 if (async_exec
&& !target_can_async_p ())
1426 error (_("Asynchronous execution not supported on this target."));
1428 /* If we are not asked to run in the bg, then prepare to run in the
1429 foreground, synchronously. */
1430 if (!async_exec
&& target_can_async_p ())
1432 /* Simulate synchronous execution. */
1433 async_disable_stdin ();
1436 until_break_command (arg
, from_tty
, 1);
1439 /* Return the value of the result of a function at the end of a 'finish'
1443 get_return_value (struct value
*function
, struct type
*value_type
)
1445 struct regcache
*stop_regs
= stop_registers
;
1446 struct gdbarch
*gdbarch
;
1447 struct value
*value
;
1448 struct cleanup
*cleanup
= make_cleanup (null_cleanup
, NULL
);
1450 /* If stop_registers were not saved, use the current registers. */
1453 stop_regs
= regcache_dup (get_current_regcache ());
1454 cleanup
= make_cleanup_regcache_xfree (stop_regs
);
1457 gdbarch
= get_regcache_arch (stop_regs
);
1459 CHECK_TYPEDEF (value_type
);
1460 gdb_assert (TYPE_CODE (value_type
) != TYPE_CODE_VOID
);
1462 /* FIXME: 2003-09-27: When returning from a nested inferior function
1463 call, it's possible (with no help from the architecture vector)
1464 to locate and return/print a "struct return" value. This is just
1465 a more complicated case of what is already being done in the
1466 inferior function call code. In fact, when inferior function
1467 calls are made async, this will likely be made the norm. */
1469 switch (gdbarch_return_value (gdbarch
, function
, value_type
,
1472 case RETURN_VALUE_REGISTER_CONVENTION
:
1473 case RETURN_VALUE_ABI_RETURNS_ADDRESS
:
1474 case RETURN_VALUE_ABI_PRESERVES_ADDRESS
:
1475 value
= allocate_value (value_type
);
1476 gdbarch_return_value (gdbarch
, function
, value_type
, stop_regs
,
1477 value_contents_raw (value
), NULL
);
1479 case RETURN_VALUE_STRUCT_CONVENTION
:
1483 internal_error (__FILE__
, __LINE__
, _("bad switch"));
1486 do_cleanups (cleanup
);
1491 /* Print the result of a function at the end of a 'finish' command. */
1494 print_return_value (struct value
*function
, struct type
*value_type
)
1496 struct value
*value
= get_return_value (function
, value_type
);
1497 struct ui_out
*uiout
= current_uiout
;
1501 struct value_print_options opts
;
1502 struct ui_file
*stb
;
1503 struct cleanup
*old_chain
;
1506 stb
= mem_fileopen ();
1507 old_chain
= make_cleanup_ui_file_delete (stb
);
1508 ui_out_text (uiout
, "Value returned is ");
1509 ui_out_field_fmt (uiout
, "gdb-result-var", "$%d",
1510 record_latest_value (value
));
1511 ui_out_text (uiout
, " = ");
1512 get_raw_print_options (&opts
);
1513 value_print (value
, stb
, &opts
);
1514 ui_out_field_stream (uiout
, "return-value", stb
);
1515 ui_out_text (uiout
, "\n");
1516 do_cleanups (old_chain
);
1520 ui_out_text (uiout
, "Value returned has type: ");
1521 ui_out_field_string (uiout
, "return-type", TYPE_NAME (value_type
));
1522 ui_out_text (uiout
, ".");
1523 ui_out_text (uiout
, " Cannot determine contents\n");
1527 /* Stuff that needs to be done by the finish command after the target
1528 has stopped. In asynchronous mode, we wait for the target to stop
1529 in the call to poll or select in the event loop, so it is
1530 impossible to do all the stuff as part of the finish_command
1531 function itself. The only chance we have to complete this command
1532 is in fetch_inferior_event, which is called by the event loop as
1533 soon as it detects that the target has stopped. */
1535 struct finish_command_continuation_args
1537 /* The thread that as current when the command was executed. */
1539 struct breakpoint
*breakpoint
;
1540 struct symbol
*function
;
1544 finish_command_continuation (void *arg
, int err
)
1546 struct finish_command_continuation_args
*a
= arg
;
1550 struct thread_info
*tp
= NULL
;
1553 if (!ptid_equal (inferior_ptid
, null_ptid
)
1554 && target_has_execution
1555 && is_stopped (inferior_ptid
))
1557 tp
= inferior_thread ();
1558 bs
= tp
->control
.stop_bpstat
;
1561 if (bpstat_find_breakpoint (bs
, a
->breakpoint
) != NULL
1562 && a
->function
!= NULL
)
1564 struct type
*value_type
;
1566 value_type
= TYPE_TARGET_TYPE (SYMBOL_TYPE (a
->function
));
1568 internal_error (__FILE__
, __LINE__
,
1569 _("finish_command: function has no target type"));
1571 if (TYPE_CODE (value_type
) != TYPE_CODE_VOID
)
1573 volatile struct gdb_exception ex
;
1576 func
= read_var_value (a
->function
, get_current_frame ());
1577 TRY_CATCH (ex
, RETURN_MASK_ALL
)
1579 /* print_return_value can throw an exception in some
1580 circumstances. We need to catch this so that we still
1581 delete the breakpoint. */
1582 print_return_value (func
, value_type
);
1585 exception_print (gdb_stdout
, ex
);
1589 /* We suppress normal call of normal_stop observer and do it
1590 here so that the *stopped notification includes the return
1592 if (bs
!= NULL
&& tp
->control
.proceed_to_finish
)
1593 observer_notify_normal_stop (bs
, 1 /* print frame */);
1596 delete_breakpoint (a
->breakpoint
);
1597 delete_longjmp_breakpoint (a
->thread
);
1601 finish_command_continuation_free_arg (void *arg
)
1606 /* finish_backward -- helper function for finish_command. */
1609 finish_backward (struct symbol
*function
)
1611 struct symtab_and_line sal
;
1612 struct thread_info
*tp
= inferior_thread ();
1614 CORE_ADDR func_addr
;
1616 pc
= get_frame_pc (get_current_frame ());
1618 if (find_pc_partial_function (pc
, NULL
, &func_addr
, NULL
) == 0)
1619 internal_error (__FILE__
, __LINE__
,
1620 _("Finish: couldn't find function."));
1622 sal
= find_pc_line (func_addr
, 0);
1624 tp
->control
.proceed_to_finish
= 1;
1625 /* Special case: if we're sitting at the function entry point,
1626 then all we need to do is take a reverse singlestep. We
1627 don't need to set a breakpoint, and indeed it would do us
1630 Note that this can only happen at frame #0, since there's
1631 no way that a function up the stack can have a return address
1632 that's equal to its entry point. */
1636 struct frame_info
*frame
= get_selected_frame (NULL
);
1637 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1638 struct symtab_and_line sr_sal
;
1640 /* Set a step-resume at the function's entry point. Once that's
1641 hit, we'll do one more step backwards. */
1644 sr_sal
.pspace
= get_frame_program_space (frame
);
1645 insert_step_resume_breakpoint_at_sal (gdbarch
,
1646 sr_sal
, null_frame_id
);
1648 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
, 0);
1652 /* We're almost there -- we just need to back up by one more
1654 tp
->control
.step_range_start
= tp
->control
.step_range_end
= 1;
1655 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
, 1);
1659 /* finish_forward -- helper function for finish_command. */
1662 finish_forward (struct symbol
*function
, struct frame_info
*frame
)
1664 struct frame_id frame_id
= get_frame_id (frame
);
1665 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1666 struct symtab_and_line sal
;
1667 struct thread_info
*tp
= inferior_thread ();
1668 struct breakpoint
*breakpoint
;
1669 struct cleanup
*old_chain
;
1670 struct finish_command_continuation_args
*cargs
;
1671 int thread
= tp
->num
;
1673 sal
= find_pc_line (get_frame_pc (frame
), 0);
1674 sal
.pc
= get_frame_pc (frame
);
1676 breakpoint
= set_momentary_breakpoint (gdbarch
, sal
,
1677 get_stack_frame_id (frame
),
1680 /* set_momentary_breakpoint invalidates FRAME. */
1683 old_chain
= make_cleanup_delete_breakpoint (breakpoint
);
1685 set_longjmp_breakpoint (tp
, frame_id
);
1686 make_cleanup (delete_longjmp_breakpoint_cleanup
, &thread
);
1688 /* We want stop_registers, please... */
1689 tp
->control
.proceed_to_finish
= 1;
1690 cargs
= xmalloc (sizeof (*cargs
));
1692 cargs
->thread
= thread
;
1693 cargs
->breakpoint
= breakpoint
;
1694 cargs
->function
= function
;
1695 add_continuation (tp
, finish_command_continuation
, cargs
,
1696 finish_command_continuation_free_arg
);
1697 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
, 0);
1699 discard_cleanups (old_chain
);
1700 if (!target_can_async_p ())
1701 do_all_continuations (0);
1704 /* "finish": Set a temporary breakpoint at the place the selected
1705 frame will return to, then continue. */
1708 finish_command (char *arg
, int from_tty
)
1710 struct frame_info
*frame
;
1711 struct symbol
*function
;
1716 ensure_not_tfind_mode ();
1717 ensure_valid_thread ();
1718 ensure_not_running ();
1720 /* Find out whether we must run in the background. */
1722 async_exec
= strip_bg_char (&arg
);
1724 /* If we must run in the background, but the target can't do it,
1726 if (async_exec
&& !target_can_async_p ())
1727 error (_("Asynchronous execution not supported on this target."));
1729 /* If we are not asked to run in the bg, then prepare to run in the
1730 foreground, synchronously. */
1731 if (!async_exec
&& target_can_async_p ())
1733 /* Simulate synchronous execution. */
1734 async_disable_stdin ();
1738 error (_("The \"finish\" command does not take any arguments."));
1740 frame
= get_prev_frame (get_selected_frame (_("No selected frame.")));
1742 error (_("\"finish\" not meaningful in the outermost frame."));
1744 clear_proceed_status ();
1746 /* Finishing from an inline frame is completely different. We don't
1747 try to show the "return value" - no way to locate it. So we do
1748 not need a completion. */
1749 if (get_frame_type (get_selected_frame (_("No selected frame.")))
1752 /* Claim we are stepping in the calling frame. An empty step
1753 range means that we will stop once we aren't in a function
1754 called by that frame. We don't use the magic "1" value for
1755 step_range_end, because then infrun will think this is nexti,
1756 and not step over the rest of this inlined function call. */
1757 struct thread_info
*tp
= inferior_thread ();
1758 struct symtab_and_line empty_sal
;
1760 init_sal (&empty_sal
);
1761 set_step_info (frame
, empty_sal
);
1762 tp
->control
.step_range_start
= get_frame_pc (frame
);
1763 tp
->control
.step_range_end
= tp
->control
.step_range_start
;
1764 tp
->control
.step_over_calls
= STEP_OVER_ALL
;
1766 /* Print info on the selected frame, including level number but not
1770 printf_filtered (_("Run till exit from "));
1771 print_stack_frame (get_selected_frame (NULL
), 1, LOCATION
);
1774 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
, 1);
1778 /* Ignore TAILCALL_FRAME type frames, they were executed already before
1779 entering THISFRAME. */
1780 while (get_frame_type (frame
) == TAILCALL_FRAME
)
1781 frame
= get_prev_frame (frame
);
1783 /* Find the function we will return from. */
1785 function
= find_pc_function (get_frame_pc (get_selected_frame (NULL
)));
1787 /* Print info on the selected frame, including level number but not
1791 if (execution_direction
== EXEC_REVERSE
)
1792 printf_filtered (_("Run back to call of "));
1794 printf_filtered (_("Run till exit from "));
1796 print_stack_frame (get_selected_frame (NULL
), 1, LOCATION
);
1799 if (execution_direction
== EXEC_REVERSE
)
1800 finish_backward (function
);
1802 finish_forward (function
, frame
);
1807 program_info (char *args
, int from_tty
)
1811 struct thread_info
*tp
;
1814 if (!target_has_execution
)
1816 printf_filtered (_("The program being debugged is not being run.\n"));
1821 ptid
= inferior_ptid
;
1824 struct target_waitstatus ws
;
1826 get_last_target_status (&ptid
, &ws
);
1829 if (ptid_equal (ptid
, null_ptid
) || is_exited (ptid
))
1830 error (_("Invalid selected thread."));
1831 else if (is_running (ptid
))
1832 error (_("Selected thread is running."));
1834 tp
= find_thread_ptid (ptid
);
1835 bs
= tp
->control
.stop_bpstat
;
1836 stat
= bpstat_num (&bs
, &num
);
1838 target_files_info ();
1839 printf_filtered (_("Program stopped at %s.\n"),
1840 paddress (target_gdbarch (), stop_pc
));
1841 if (tp
->control
.stop_step
)
1842 printf_filtered (_("It stopped after being stepped.\n"));
1845 /* There may be several breakpoints in the same place, so this
1846 isn't as strange as it seems. */
1851 printf_filtered (_("It stopped at a breakpoint "
1852 "that has since been deleted.\n"));
1855 printf_filtered (_("It stopped at breakpoint %d.\n"), num
);
1856 stat
= bpstat_num (&bs
, &num
);
1859 else if (tp
->suspend
.stop_signal
!= GDB_SIGNAL_0
)
1861 printf_filtered (_("It stopped with signal %s, %s.\n"),
1862 gdb_signal_to_name (tp
->suspend
.stop_signal
),
1863 gdb_signal_to_string (tp
->suspend
.stop_signal
));
1868 printf_filtered (_("Type \"info stack\" or \"info "
1869 "registers\" for more information.\n"));
1874 environment_info (char *var
, int from_tty
)
1878 char *val
= get_in_environ (current_inferior ()->environment
, var
);
1882 puts_filtered (var
);
1883 puts_filtered (" = ");
1884 puts_filtered (val
);
1885 puts_filtered ("\n");
1889 puts_filtered ("Environment variable \"");
1890 puts_filtered (var
);
1891 puts_filtered ("\" not defined.\n");
1896 char **vector
= environ_vector (current_inferior ()->environment
);
1900 puts_filtered (*vector
++);
1901 puts_filtered ("\n");
1907 set_environment_command (char *arg
, int from_tty
)
1909 char *p
, *val
, *var
;
1913 error_no_arg (_("environment variable and value"));
1915 /* Find seperation between variable name and value. */
1916 p
= (char *) strchr (arg
, '=');
1917 val
= (char *) strchr (arg
, ' ');
1919 if (p
!= 0 && val
!= 0)
1921 /* We have both a space and an equals. If the space is before the
1922 equals, walk forward over the spaces til we see a nonspace
1923 (possibly the equals). */
1928 /* Now if the = is after the char following the spaces,
1929 take the char following the spaces. */
1933 else if (val
!= 0 && p
== 0)
1937 error_no_arg (_("environment variable to set"));
1939 if (p
== 0 || p
[1] == 0)
1943 p
= arg
+ strlen (arg
); /* So that savestring below will work. */
1947 /* Not setting variable value to null. */
1949 while (*val
== ' ' || *val
== '\t')
1953 while (p
!= arg
&& (p
[-1] == ' ' || p
[-1] == '\t'))
1956 var
= savestring (arg
, p
- arg
);
1959 printf_filtered (_("Setting environment variable "
1960 "\"%s\" to null value.\n"),
1962 set_in_environ (current_inferior ()->environment
, var
, "");
1965 set_in_environ (current_inferior ()->environment
, var
, val
);
1970 unset_environment_command (char *var
, int from_tty
)
1974 /* If there is no argument, delete all environment variables.
1975 Ask for confirmation if reading from the terminal. */
1976 if (!from_tty
|| query (_("Delete all environment variables? ")))
1978 free_environ (current_inferior ()->environment
);
1979 current_inferior ()->environment
= make_environ ();
1983 unset_in_environ (current_inferior ()->environment
, var
);
1986 /* Handle the execution path (PATH variable). */
1988 static const char path_var_name
[] = "PATH";
1991 path_info (char *args
, int from_tty
)
1993 puts_filtered ("Executable and object file path: ");
1994 puts_filtered (get_in_environ (current_inferior ()->environment
,
1996 puts_filtered ("\n");
1999 /* Add zero or more directories to the front of the execution path. */
2002 path_command (char *dirname
, int from_tty
)
2008 env
= get_in_environ (current_inferior ()->environment
, path_var_name
);
2009 /* Can be null if path is not set. */
2012 exec_path
= xstrdup (env
);
2013 mod_path (dirname
, &exec_path
);
2014 set_in_environ (current_inferior ()->environment
, path_var_name
, exec_path
);
2017 path_info ((char *) NULL
, from_tty
);
2021 /* Print out the register NAME with value VAL, to FILE, in the default
2025 default_print_one_register_info (struct ui_file
*file
,
2029 struct type
*regtype
= value_type (val
);
2031 fputs_filtered (name
, file
);
2032 print_spaces_filtered (15 - strlen (name
), file
);
2034 if (!value_entirely_available (val
))
2036 fprintf_filtered (file
, "*value not available*\n");
2040 /* If virtual format is floating, print it that way, and in raw
2042 if (TYPE_CODE (regtype
) == TYPE_CODE_FLT
2043 || TYPE_CODE (regtype
) == TYPE_CODE_DECFLOAT
)
2046 struct value_print_options opts
;
2047 const gdb_byte
*valaddr
= value_contents_for_printing (val
);
2048 enum bfd_endian byte_order
= gdbarch_byte_order (get_type_arch (regtype
));
2050 get_user_print_options (&opts
);
2054 value_contents_for_printing (val
),
2055 value_embedded_offset (val
), 0,
2056 file
, 0, val
, &opts
, current_language
);
2058 fprintf_filtered (file
, "\t(raw 0x");
2059 for (j
= 0; j
< TYPE_LENGTH (regtype
); j
++)
2063 if (byte_order
== BFD_ENDIAN_BIG
)
2066 idx
= TYPE_LENGTH (regtype
) - 1 - j
;
2067 fprintf_filtered (file
, "%02x", (unsigned char) valaddr
[idx
]);
2069 fprintf_filtered (file
, ")");
2073 struct value_print_options opts
;
2075 /* Print the register in hex. */
2076 get_formatted_print_options (&opts
, 'x');
2079 value_contents_for_printing (val
),
2080 value_embedded_offset (val
), 0,
2081 file
, 0, val
, &opts
, current_language
);
2082 /* If not a vector register, print it also according to its
2084 if (TYPE_VECTOR (regtype
) == 0)
2086 get_user_print_options (&opts
);
2088 fprintf_filtered (file
, "\t");
2090 value_contents_for_printing (val
),
2091 value_embedded_offset (val
), 0,
2092 file
, 0, val
, &opts
, current_language
);
2096 fprintf_filtered (file
, "\n");
2099 /* Print out the machine register regnum. If regnum is -1, print all
2100 registers (print_all == 1) or all non-float and non-vector
2101 registers (print_all == 0).
2103 For most machines, having all_registers_info() print the
2104 register(s) one per line is good enough. If a different format is
2105 required, (eg, for MIPS or Pyramid 90x, which both have lots of
2106 regs), or there is an existing convention for showing all the
2107 registers, define the architecture method PRINT_REGISTERS_INFO to
2108 provide that format. */
2111 default_print_registers_info (struct gdbarch
*gdbarch
,
2112 struct ui_file
*file
,
2113 struct frame_info
*frame
,
2114 int regnum
, int print_all
)
2117 const int numregs
= gdbarch_num_regs (gdbarch
)
2118 + gdbarch_num_pseudo_regs (gdbarch
);
2120 for (i
= 0; i
< numregs
; i
++)
2122 struct type
*regtype
;
2125 /* Decide between printing all regs, non-float / vector regs, or
2131 if (!gdbarch_register_reggroup_p (gdbarch
, i
, all_reggroup
))
2136 if (!gdbarch_register_reggroup_p (gdbarch
, i
, general_reggroup
))
2146 /* If the register name is empty, it is undefined for this
2147 processor, so don't display anything. */
2148 if (gdbarch_register_name (gdbarch
, i
) == NULL
2149 || *(gdbarch_register_name (gdbarch
, i
)) == '\0')
2152 regtype
= register_type (gdbarch
, i
);
2153 val
= allocate_value (regtype
);
2155 /* Get the data in raw format. */
2156 if (! deprecated_frame_register_read (frame
, i
, value_contents_raw (val
)))
2157 mark_value_bytes_unavailable (val
, 0, TYPE_LENGTH (value_type (val
)));
2159 default_print_one_register_info (file
,
2160 gdbarch_register_name (gdbarch
, i
),
2166 registers_info (char *addr_exp
, int fpregs
)
2168 struct frame_info
*frame
;
2169 struct gdbarch
*gdbarch
;
2171 if (!target_has_registers
)
2172 error (_("The program has no registers now."));
2173 frame
= get_selected_frame (NULL
);
2174 gdbarch
= get_frame_arch (frame
);
2178 gdbarch_print_registers_info (gdbarch
, gdb_stdout
,
2183 while (*addr_exp
!= '\0')
2188 /* Keep skipping leading white space. */
2189 if (isspace ((*addr_exp
)))
2195 /* Discard any leading ``$''. Check that there is something
2196 resembling a register following it. */
2197 if (addr_exp
[0] == '$')
2199 if (isspace ((*addr_exp
)) || (*addr_exp
) == '\0')
2200 error (_("Missing register name"));
2202 /* Find the start/end of this register name/num/group. */
2204 while ((*addr_exp
) != '\0' && !isspace ((*addr_exp
)))
2208 /* Figure out what we've found and display it. */
2210 /* A register name? */
2212 int regnum
= user_reg_map_name_to_regnum (gdbarch
, start
, end
- start
);
2216 /* User registers lie completely outside of the range of
2217 normal registers. Catch them early so that the target
2219 if (regnum
>= gdbarch_num_regs (gdbarch
)
2220 + gdbarch_num_pseudo_regs (gdbarch
))
2222 struct value
*regval
= value_of_user_reg (regnum
, frame
);
2223 const char *regname
= user_reg_map_regnum_to_name (gdbarch
,
2226 /* Print in the same fashion
2227 gdbarch_print_registers_info's default
2228 implementation prints. */
2229 default_print_one_register_info (gdb_stdout
,
2234 gdbarch_print_registers_info (gdbarch
, gdb_stdout
,
2235 frame
, regnum
, fpregs
);
2240 /* A register group? */
2242 struct reggroup
*group
;
2244 for (group
= reggroup_next (gdbarch
, NULL
);
2246 group
= reggroup_next (gdbarch
, group
))
2248 /* Don't bother with a length check. Should the user
2249 enter a short register group name, go with the first
2250 group that matches. */
2251 if (strncmp (start
, reggroup_name (group
), end
- start
) == 0)
2259 regnum
< gdbarch_num_regs (gdbarch
)
2260 + gdbarch_num_pseudo_regs (gdbarch
);
2263 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, group
))
2264 gdbarch_print_registers_info (gdbarch
,
2272 /* Nothing matched. */
2273 error (_("Invalid register `%.*s'"), (int) (end
- start
), start
);
2278 all_registers_info (char *addr_exp
, int from_tty
)
2280 registers_info (addr_exp
, 1);
2284 nofp_registers_info (char *addr_exp
, int from_tty
)
2286 registers_info (addr_exp
, 0);
2290 print_vector_info (struct ui_file
*file
,
2291 struct frame_info
*frame
, const char *args
)
2293 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
2295 if (gdbarch_print_vector_info_p (gdbarch
))
2296 gdbarch_print_vector_info (gdbarch
, file
, frame
, args
);
2300 int printed_something
= 0;
2303 regnum
< gdbarch_num_regs (gdbarch
)
2304 + gdbarch_num_pseudo_regs (gdbarch
);
2307 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, vector_reggroup
))
2309 printed_something
= 1;
2310 gdbarch_print_registers_info (gdbarch
, file
, frame
, regnum
, 1);
2313 if (!printed_something
)
2314 fprintf_filtered (file
, "No vector information\n");
2319 vector_info (char *args
, int from_tty
)
2321 if (!target_has_registers
)
2322 error (_("The program has no registers now."));
2324 print_vector_info (gdb_stdout
, get_selected_frame (NULL
), args
);
2327 /* Kill the inferior process. Make us have no inferior. */
2330 kill_command (char *arg
, int from_tty
)
2332 /* FIXME: This should not really be inferior_ptid (or target_has_execution).
2333 It should be a distinct flag that indicates that a target is active, cuz
2334 some targets don't have processes! */
2336 if (ptid_equal (inferior_ptid
, null_ptid
))
2337 error (_("The program is not being run."));
2338 if (!query (_("Kill the program being debugged? ")))
2339 error (_("Not confirmed."));
2342 /* If we still have other inferiors to debug, then don't mess with
2343 with their threads. */
2344 if (!have_inferiors ())
2346 init_thread_list (); /* Destroy thread info. */
2348 /* Killing off the inferior can leave us with a core file. If
2349 so, print the state we are left in. */
2350 if (target_has_stack
)
2352 printf_filtered (_("In %s,\n"), target_longname
);
2353 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
2356 bfd_cache_close_all ();
2359 /* Used in `attach&' command. ARG is a point to an integer
2360 representing a process id. Proceed threads of this process iff
2361 they stopped due to debugger request, and when they did, they
2362 reported a clean stop (GDB_SIGNAL_0). Do not proceed threads
2363 that have been explicitly been told to stop. */
2366 proceed_after_attach_callback (struct thread_info
*thread
,
2369 int pid
= * (int *) arg
;
2371 if (ptid_get_pid (thread
->ptid
) == pid
2372 && !is_exited (thread
->ptid
)
2373 && !is_executing (thread
->ptid
)
2374 && !thread
->stop_requested
2375 && thread
->suspend
.stop_signal
== GDB_SIGNAL_0
)
2377 switch_to_thread (thread
->ptid
);
2378 clear_proceed_status ();
2379 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
, 0);
2386 proceed_after_attach (int pid
)
2388 /* Don't error out if the current thread is running, because
2389 there may be other stopped threads. */
2390 struct cleanup
*old_chain
;
2392 /* Backup current thread and selected frame. */
2393 old_chain
= make_cleanup_restore_current_thread ();
2395 iterate_over_threads (proceed_after_attach_callback
, &pid
);
2397 /* Restore selected ptid. */
2398 do_cleanups (old_chain
);
2403 * Should save/restore the tty state since it might be that the
2404 * program to be debugged was started on this tty and it wants
2405 * the tty in some state other than what we want. If it's running
2406 * on another terminal or without a terminal, then saving and
2407 * restoring the tty state is a harmless no-op.
2408 * This only needs to be done if we are attaching to a process.
2411 /* attach_command --
2412 takes a program started up outside of gdb and ``attaches'' to it.
2413 This stops it cold in its tracks and allows us to start debugging it.
2414 and wait for the trace-trap that results from attaching. */
2417 attach_command_post_wait (char *args
, int from_tty
, int async_exec
)
2420 char *full_exec_path
= NULL
;
2421 struct inferior
*inferior
;
2423 inferior
= current_inferior ();
2424 inferior
->control
.stop_soon
= NO_STOP_QUIETLY
;
2426 /* If no exec file is yet known, try to determine it from the
2428 exec_file
= (char *) get_exec_file (0);
2431 exec_file
= target_pid_to_exec_file (PIDGET (inferior_ptid
));
2434 /* It's possible we don't have a full path, but rather just a
2435 filename. Some targets, such as HP-UX, don't provide the
2438 Attempt to qualify the filename against the source path.
2439 (If that fails, we'll just fall back on the original
2440 filename. Not much more we can do...) */
2442 if (!source_full_path_of (exec_file
, &full_exec_path
))
2443 full_exec_path
= xstrdup (exec_file
);
2445 exec_file_attach (full_exec_path
, from_tty
);
2446 symbol_file_add_main (full_exec_path
, from_tty
);
2451 reopen_exec_file ();
2455 /* Take any necessary post-attaching actions for this platform. */
2456 target_post_attach (PIDGET (inferior_ptid
));
2458 post_create_inferior (¤t_target
, from_tty
);
2460 /* Install inferior's terminal modes. */
2461 target_terminal_inferior ();
2465 /* The user requested an `attach&', so be sure to leave threads
2466 that didn't get a signal running. */
2468 /* Immediatelly resume all suspended threads of this inferior,
2469 and this inferior only. This should have no effect on
2470 already running threads. If a thread has been stopped with a
2471 signal, leave it be. */
2473 proceed_after_attach (inferior
->pid
);
2476 if (inferior_thread ()->suspend
.stop_signal
== GDB_SIGNAL_0
)
2478 clear_proceed_status ();
2479 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
, 0);
2485 /* The user requested a plain `attach', so be sure to leave
2486 the inferior stopped. */
2488 if (target_can_async_p ())
2489 async_enable_stdin ();
2491 /* At least the current thread is already stopped. */
2493 /* In all-stop, by definition, all threads have to be already
2494 stopped at this point. In non-stop, however, although the
2495 selected thread is stopped, others may still be executing.
2496 Be sure to explicitly stop all threads of the process. This
2497 should have no effect on already stopped threads. */
2499 target_stop (pid_to_ptid (inferior
->pid
));
2501 /* Tell the user/frontend where we're stopped. */
2503 if (deprecated_attach_hook
)
2504 deprecated_attach_hook ();
2508 struct attach_command_continuation_args
2516 attach_command_continuation (void *args
, int err
)
2518 struct attach_command_continuation_args
*a
= args
;
2523 attach_command_post_wait (a
->args
, a
->from_tty
, a
->async_exec
);
2527 attach_command_continuation_free_args (void *args
)
2529 struct attach_command_continuation_args
*a
= args
;
2536 attach_command (char *args
, int from_tty
)
2539 struct cleanup
*back_to
= make_cleanup (null_cleanup
, NULL
);
2541 dont_repeat (); /* Not for the faint of heart */
2543 if (gdbarch_has_global_solist (target_gdbarch ()))
2544 /* Don't complain if all processes share the same symbol
2547 else if (target_has_execution
)
2549 if (query (_("A program is being debugged already. Kill it? ")))
2552 error (_("Not killed."));
2555 /* Clean up any leftovers from other runs. Some other things from
2556 this function should probably be moved into target_pre_inferior. */
2557 target_pre_inferior (from_tty
);
2559 if (non_stop
&& !target_supports_non_stop ())
2560 error (_("Cannot attach to this target in non-stop mode"));
2564 async_exec
= strip_bg_char (&args
);
2566 /* If we get a request for running in the bg but the target
2567 doesn't support it, error out. */
2568 if (async_exec
&& !target_can_async_p ())
2569 error (_("Asynchronous execution not supported on this target."));
2572 /* If we don't get a request of running in the bg, then we need
2573 to simulate synchronous (fg) execution. */
2574 if (!async_exec
&& target_can_async_p ())
2576 /* Simulate synchronous execution. */
2577 async_disable_stdin ();
2578 make_cleanup ((make_cleanup_ftype
*)async_enable_stdin
, NULL
);
2581 target_attach (args
, from_tty
);
2583 /* Set up the "saved terminal modes" of the inferior
2584 based on what modes we are starting it with. */
2585 target_terminal_init ();
2587 /* Set up execution context to know that we should return from
2588 wait_for_inferior as soon as the target reports a stop. */
2589 init_wait_for_inferior ();
2590 clear_proceed_status ();
2594 /* If we find that the current thread isn't stopped, explicitly
2595 do so now, because we're going to install breakpoints and
2599 /* The user requested an `attach&'; stop just one thread. */
2600 target_stop (inferior_ptid
);
2602 /* The user requested an `attach', so stop all threads of this
2604 target_stop (pid_to_ptid (ptid_get_pid (inferior_ptid
)));
2607 /* Some system don't generate traps when attaching to inferior.
2608 E.g. Mach 3 or GNU hurd. */
2609 if (!target_attach_no_wait
)
2611 struct inferior
*inferior
= current_inferior ();
2613 /* Careful here. See comments in inferior.h. Basically some
2614 OSes don't ignore SIGSTOPs on continue requests anymore. We
2615 need a way for handle_inferior_event to reset the stop_signal
2616 variable after an attach, and this is what
2617 STOP_QUIETLY_NO_SIGSTOP is for. */
2618 inferior
->control
.stop_soon
= STOP_QUIETLY_NO_SIGSTOP
;
2620 if (target_can_async_p ())
2622 /* sync_execution mode. Wait for stop. */
2623 struct attach_command_continuation_args
*a
;
2625 a
= xmalloc (sizeof (*a
));
2626 a
->args
= xstrdup (args
);
2627 a
->from_tty
= from_tty
;
2628 a
->async_exec
= async_exec
;
2629 add_inferior_continuation (attach_command_continuation
, a
,
2630 attach_command_continuation_free_args
);
2631 discard_cleanups (back_to
);
2635 wait_for_inferior ();
2638 attach_command_post_wait (args
, from_tty
, async_exec
);
2639 discard_cleanups (back_to
);
2642 /* We had just found out that the target was already attached to an
2643 inferior. PTID points at a thread of this new inferior, that is
2644 the most likely to be stopped right now, but not necessarily so.
2645 The new inferior is assumed to be already added to the inferior
2646 list at this point. If LEAVE_RUNNING, then leave the threads of
2647 this inferior running, except those we've explicitly seen reported
2651 notice_new_inferior (ptid_t ptid
, int leave_running
, int from_tty
)
2653 struct cleanup
* old_chain
;
2656 old_chain
= make_cleanup (null_cleanup
, NULL
);
2658 /* If in non-stop, leave threads as running as they were. If
2659 they're stopped for some reason other than us telling it to, the
2660 target reports a signal != GDB_SIGNAL_0. We don't try to
2661 resume threads with such a stop signal. */
2662 async_exec
= non_stop
;
2664 if (!ptid_equal (inferior_ptid
, null_ptid
))
2665 make_cleanup_restore_current_thread ();
2667 switch_to_thread (ptid
);
2669 /* When we "notice" a new inferior we need to do all the things we
2670 would normally do if we had just attached to it. */
2672 if (is_executing (inferior_ptid
))
2674 struct inferior
*inferior
= current_inferior ();
2676 /* We're going to install breakpoints, and poke at memory,
2677 ensure that the inferior is stopped for a moment while we do
2679 target_stop (inferior_ptid
);
2681 inferior
->control
.stop_soon
= STOP_QUIETLY_REMOTE
;
2683 /* Wait for stop before proceeding. */
2684 if (target_can_async_p ())
2686 struct attach_command_continuation_args
*a
;
2688 a
= xmalloc (sizeof (*a
));
2689 a
->args
= xstrdup ("");
2690 a
->from_tty
= from_tty
;
2691 a
->async_exec
= async_exec
;
2692 add_inferior_continuation (attach_command_continuation
, a
,
2693 attach_command_continuation_free_args
);
2695 do_cleanups (old_chain
);
2699 wait_for_inferior ();
2702 async_exec
= leave_running
;
2703 attach_command_post_wait ("" /* args */, from_tty
, async_exec
);
2705 do_cleanups (old_chain
);
2710 * takes a program previously attached to and detaches it.
2711 * The program resumes execution and will no longer stop
2712 * on signals, etc. We better not have left any breakpoints
2713 * in the program or it'll die when it hits one. For this
2714 * to work, it may be necessary for the process to have been
2715 * previously attached. It *might* work if the program was
2716 * started via the normal ptrace (PTRACE_TRACEME).
2720 detach_command (char *args
, int from_tty
)
2722 dont_repeat (); /* Not for the faint of heart. */
2724 if (ptid_equal (inferior_ptid
, null_ptid
))
2725 error (_("The program is not being run."));
2727 disconnect_tracing (from_tty
);
2729 target_detach (args
, from_tty
);
2731 /* If the solist is global across inferiors, don't clear it when we
2732 detach from a single inferior. */
2733 if (!gdbarch_has_global_solist (target_gdbarch ()))
2734 no_shared_libraries (NULL
, from_tty
);
2736 /* If we still have inferiors to debug, then don't mess with their
2738 if (!have_inferiors ())
2739 init_thread_list ();
2741 if (deprecated_detach_hook
)
2742 deprecated_detach_hook ();
2745 /* Disconnect from the current target without resuming it (leaving it
2746 waiting for a debugger).
2748 We'd better not have left any breakpoints in the program or the
2749 next debugger will get confused. Currently only supported for some
2750 remote targets, since the normal attach mechanisms don't work on
2751 stopped processes on some native platforms (e.g. GNU/Linux). */
2754 disconnect_command (char *args
, int from_tty
)
2756 dont_repeat (); /* Not for the faint of heart. */
2757 disconnect_tracing (from_tty
);
2758 target_disconnect (args
, from_tty
);
2759 no_shared_libraries (NULL
, from_tty
);
2760 init_thread_list ();
2761 if (deprecated_detach_hook
)
2762 deprecated_detach_hook ();
2766 interrupt_target_1 (int all_threads
)
2771 ptid
= minus_one_ptid
;
2773 ptid
= inferior_ptid
;
2776 /* Tag the thread as having been explicitly requested to stop, so
2777 other parts of gdb know not to resume this thread automatically,
2778 if it was stopped due to an internal event. Limit this to
2779 non-stop mode, as when debugging a multi-threaded application in
2780 all-stop mode, we will only get one stop event --- it's undefined
2781 which thread will report the event. */
2783 set_stop_requested (ptid
, 1);
2786 /* Stop the execution of the target while running in async mode, in
2787 the backgound. In all-stop, stop the whole process. In non-stop
2788 mode, stop the current thread only by default, or stop all threads
2789 if the `-a' switch is used. */
2791 /* interrupt [-a] */
2793 interrupt_target_command (char *args
, int from_tty
)
2795 if (target_can_async_p ())
2797 int all_threads
= 0;
2799 dont_repeat (); /* Not for the faint of heart. */
2802 && strncmp (args
, "-a", sizeof ("-a") - 1) == 0)
2805 if (!non_stop
&& all_threads
)
2806 error (_("-a is meaningless in all-stop mode."));
2808 interrupt_target_1 (all_threads
);
2813 print_float_info (struct ui_file
*file
,
2814 struct frame_info
*frame
, const char *args
)
2816 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
2818 if (gdbarch_print_float_info_p (gdbarch
))
2819 gdbarch_print_float_info (gdbarch
, file
, frame
, args
);
2823 int printed_something
= 0;
2826 regnum
< gdbarch_num_regs (gdbarch
)
2827 + gdbarch_num_pseudo_regs (gdbarch
);
2830 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, float_reggroup
))
2832 printed_something
= 1;
2833 gdbarch_print_registers_info (gdbarch
, file
, frame
, regnum
, 1);
2836 if (!printed_something
)
2837 fprintf_filtered (file
, "No floating-point info "
2838 "available for this processor.\n");
2843 float_info (char *args
, int from_tty
)
2845 if (!target_has_registers
)
2846 error (_("The program has no registers now."));
2848 print_float_info (gdb_stdout
, get_selected_frame (NULL
), args
);
2852 unset_command (char *args
, int from_tty
)
2854 printf_filtered (_("\"unset\" must be followed by the "
2855 "name of an unset subcommand.\n"));
2856 help_list (unsetlist
, "unset ", -1, gdb_stdout
);
2859 /* Implement `info proc' family of commands. */
2862 info_proc_cmd_1 (char *args
, enum info_proc_what what
, int from_tty
)
2864 struct gdbarch
*gdbarch
= get_current_arch ();
2866 if (!target_info_proc (args
, what
))
2868 if (gdbarch_info_proc_p (gdbarch
))
2869 gdbarch_info_proc (gdbarch
, args
, what
);
2871 error (_("Not supported on this target."));
2875 /* Implement `info proc' when given without any futher parameters. */
2878 info_proc_cmd (char *args
, int from_tty
)
2880 info_proc_cmd_1 (args
, IP_MINIMAL
, from_tty
);
2883 /* Implement `info proc mappings'. */
2886 info_proc_cmd_mappings (char *args
, int from_tty
)
2888 info_proc_cmd_1 (args
, IP_MAPPINGS
, from_tty
);
2891 /* Implement `info proc stat'. */
2894 info_proc_cmd_stat (char *args
, int from_tty
)
2896 info_proc_cmd_1 (args
, IP_STAT
, from_tty
);
2899 /* Implement `info proc status'. */
2902 info_proc_cmd_status (char *args
, int from_tty
)
2904 info_proc_cmd_1 (args
, IP_STATUS
, from_tty
);
2907 /* Implement `info proc cwd'. */
2910 info_proc_cmd_cwd (char *args
, int from_tty
)
2912 info_proc_cmd_1 (args
, IP_CWD
, from_tty
);
2915 /* Implement `info proc cmdline'. */
2918 info_proc_cmd_cmdline (char *args
, int from_tty
)
2920 info_proc_cmd_1 (args
, IP_CMDLINE
, from_tty
);
2923 /* Implement `info proc exe'. */
2926 info_proc_cmd_exe (char *args
, int from_tty
)
2928 info_proc_cmd_1 (args
, IP_EXE
, from_tty
);
2931 /* Implement `info proc all'. */
2934 info_proc_cmd_all (char *args
, int from_tty
)
2936 info_proc_cmd_1 (args
, IP_ALL
, from_tty
);
2940 _initialize_infcmd (void)
2942 static struct cmd_list_element
*info_proc_cmdlist
;
2943 struct cmd_list_element
*c
= NULL
;
2946 /* Add the filename of the terminal connected to inferior I/O. */
2947 add_setshow_filename_cmd ("inferior-tty", class_run
,
2948 &inferior_io_terminal_scratch
, _("\
2949 Set terminal for future runs of program being debugged."), _("\
2950 Show terminal for future runs of program being debugged."), _("\
2951 Usage: set inferior-tty /dev/pts/1"),
2952 set_inferior_tty_command
,
2953 show_inferior_tty_command
,
2954 &setlist
, &showlist
);
2955 add_com_alias ("tty", "set inferior-tty", class_alias
, 0);
2958 add_setshow_string_noescape_cmd (cmd_name
, class_run
,
2959 &inferior_args_scratch
, _("\
2960 Set argument list to give program being debugged when it is started."), _("\
2961 Show argument list to give program being debugged when it is started."), _("\
2962 Follow this command with any number of args, to be passed to the program."),
2965 &setlist
, &showlist
);
2966 c
= lookup_cmd (&cmd_name
, setlist
, "", -1, 1);
2967 gdb_assert (c
!= NULL
);
2968 set_cmd_completer (c
, filename_completer
);
2970 c
= add_cmd ("environment", no_class
, environment_info
, _("\
2971 The environment to give the program, or one variable's value.\n\
2972 With an argument VAR, prints the value of environment variable VAR to\n\
2973 give the program being debugged. With no arguments, prints the entire\n\
2974 environment to be given to the program."), &showlist
);
2975 set_cmd_completer (c
, noop_completer
);
2977 add_prefix_cmd ("unset", no_class
, unset_command
,
2978 _("Complement to certain \"set\" commands."),
2979 &unsetlist
, "unset ", 0, &cmdlist
);
2981 c
= add_cmd ("environment", class_run
, unset_environment_command
, _("\
2982 Cancel environment variable VAR for the program.\n\
2983 This does not affect the program until the next \"run\" command."),
2985 set_cmd_completer (c
, noop_completer
);
2987 c
= add_cmd ("environment", class_run
, set_environment_command
, _("\
2988 Set environment variable value to give the program.\n\
2989 Arguments are VAR VALUE where VAR is variable name and VALUE is value.\n\
2990 VALUES of environment variables are uninterpreted strings.\n\
2991 This does not affect the program until the next \"run\" command."),
2993 set_cmd_completer (c
, noop_completer
);
2995 c
= add_com ("path", class_files
, path_command
, _("\
2996 Add directory DIR(s) to beginning of search path for object files.\n\
2997 $cwd in the path means the current working directory.\n\
2998 This path is equivalent to the $PATH shell variable. It is a list of\n\
2999 directories, separated by colons. These directories are searched to find\n\
3000 fully linked executable files and separately compiled object files as \
3002 set_cmd_completer (c
, filename_completer
);
3004 c
= add_cmd ("paths", no_class
, path_info
, _("\
3005 Current search path for finding object files.\n\
3006 $cwd in the path means the current working directory.\n\
3007 This path is equivalent to the $PATH shell variable. It is a list of\n\
3008 directories, separated by colons. These directories are searched to find\n\
3009 fully linked executable files and separately compiled object files as \
3012 set_cmd_completer (c
, noop_completer
);
3014 add_prefix_cmd ("kill", class_run
, kill_command
,
3015 _("Kill execution of program being debugged."),
3016 &killlist
, "kill ", 0, &cmdlist
);
3018 add_com ("attach", class_run
, attach_command
, _("\
3019 Attach to a process or file outside of GDB.\n\
3020 This command attaches to another target, of the same type as your last\n\
3021 \"target\" command (\"info files\" will show your target stack).\n\
3022 The command may take as argument a process id or a device file.\n\
3023 For a process id, you must have permission to send the process a signal,\n\
3024 and it must have the same effective uid as the debugger.\n\
3025 When using \"attach\" with a process id, the debugger finds the\n\
3026 program running in the process, looking first in the current working\n\
3027 directory, or (if not found there) using the source file search path\n\
3028 (see the \"directory\" command). You can also use the \"file\" command\n\
3029 to specify the program, and to load its symbol table."));
3031 add_prefix_cmd ("detach", class_run
, detach_command
, _("\
3032 Detach a process or file previously attached.\n\
3033 If a process, it is no longer traced, and it continues its execution. If\n\
3034 you were debugging a file, the file is closed and gdb no longer accesses it."),
3035 &detachlist
, "detach ", 0, &cmdlist
);
3037 add_com ("disconnect", class_run
, disconnect_command
, _("\
3038 Disconnect from a target.\n\
3039 The target will wait for another debugger to connect. Not available for\n\
3042 c
= add_com ("signal", class_run
, signal_command
, _("\
3043 Continue program with the specified signal.\n\
3044 Usage: signal SIGNAL\n\
3045 The SIGNAL argument is processed the same as the handle command.\n\
3047 An argument of \"0\" means continue the program without sending it a signal.\n\
3048 This is useful in cases where the program stopped because of a signal,\n\
3049 and you want to resume the program while discarding the signal."));
3050 set_cmd_completer (c
, signal_completer
);
3052 add_com ("stepi", class_run
, stepi_command
, _("\
3053 Step one instruction exactly.\n\
3055 Argument N means step N times (or till program stops for another \
3057 add_com_alias ("si", "stepi", class_alias
, 0);
3059 add_com ("nexti", class_run
, nexti_command
, _("\
3060 Step one instruction, but proceed through subroutine calls.\n\
3062 Argument N means step N times (or till program stops for another \
3064 add_com_alias ("ni", "nexti", class_alias
, 0);
3066 add_com ("finish", class_run
, finish_command
, _("\
3067 Execute until selected stack frame returns.\n\
3069 Upon return, the value returned is printed and put in the value history."));
3070 add_com_alias ("fin", "finish", class_run
, 1);
3072 add_com ("next", class_run
, next_command
, _("\
3073 Step program, proceeding through subroutine calls.\n\
3075 Unlike \"step\", if the current source line calls a subroutine,\n\
3076 this command does not enter the subroutine, but instead steps over\n\
3077 the call, in effect treating it as a single source line."));
3078 add_com_alias ("n", "next", class_run
, 1);
3080 add_com_alias ("S", "next", class_run
, 1);
3082 add_com ("step", class_run
, step_command
, _("\
3083 Step program until it reaches a different source line.\n\
3085 Argument N means step N times (or till program stops for another \
3087 add_com_alias ("s", "step", class_run
, 1);
3089 c
= add_com ("until", class_run
, until_command
, _("\
3090 Execute until the program reaches a source line greater than the current\n\
3091 or a specified location (same args as break command) within the current \
3093 set_cmd_completer (c
, location_completer
);
3094 add_com_alias ("u", "until", class_run
, 1);
3096 c
= add_com ("advance", class_run
, advance_command
, _("\
3097 Continue the program up to the given location (same form as args for break \
3099 Execution will also stop upon exit from the current stack frame."));
3100 set_cmd_completer (c
, location_completer
);
3102 c
= add_com ("jump", class_run
, jump_command
, _("\
3103 Continue program being debugged at specified line or address.\n\
3104 Usage: jump <location>\n\
3105 Give as argument either LINENUM or *ADDR, where ADDR is an expression\n\
3106 for an address to start at."));
3107 set_cmd_completer (c
, location_completer
);
3108 add_com_alias ("j", "jump", class_run
, 1);
3112 c
= add_com ("go", class_run
, go_command
, _("\
3113 Usage: go <location>\n\
3114 Continue program being debugged, stopping at specified line or \n\
3116 Give as argument either LINENUM or *ADDR, where ADDR is an \n\
3117 expression for an address to start at.\n\
3118 This command is a combination of tbreak and jump."));
3119 set_cmd_completer (c
, location_completer
);
3123 add_com_alias ("g", "go", class_run
, 1);
3125 add_com ("continue", class_run
, continue_command
, _("\
3126 Continue program being debugged, after signal or breakpoint.\n\
3127 Usage: continue [N]\n\
3128 If proceeding from breakpoint, a number N may be used as an argument,\n\
3129 which means to set the ignore count of that breakpoint to N - 1 (so that\n\
3130 the breakpoint won't break until the Nth time it is reached).\n\
3132 If non-stop mode is enabled, continue only the current thread,\n\
3133 otherwise all the threads in the program are continued. To \n\
3134 continue all stopped threads in non-stop mode, use the -a option.\n\
3135 Specifying -a and an ignore count simultaneously is an error."));
3136 add_com_alias ("c", "cont", class_run
, 1);
3137 add_com_alias ("fg", "cont", class_run
, 1);
3139 c
= add_com ("run", class_run
, run_command
, _("\
3140 Start debugged program. You may specify arguments to give it.\n\
3141 Args may include \"*\", or \"[...]\"; they are expanded using \"sh\".\n\
3142 Input and output redirection with \">\", \"<\", or \">>\" are also \
3144 With no arguments, uses arguments last specified (with \"run\" \
3145 or \"set args\").\n\
3146 To cancel previous arguments and run with no arguments,\n\
3147 use \"set args\" without arguments."));
3148 set_cmd_completer (c
, filename_completer
);
3149 add_com_alias ("r", "run", class_run
, 1);
3151 add_com ("R", class_run
, run_no_args_command
,
3152 _("Start debugged program with no arguments."));
3154 c
= add_com ("start", class_run
, start_command
, _("\
3155 Run the debugged program until the beginning of the main procedure.\n\
3156 You may specify arguments to give to your program, just as with the\n\
3157 \"run\" command."));
3158 set_cmd_completer (c
, filename_completer
);
3160 add_com ("interrupt", class_run
, interrupt_target_command
,
3161 _("Interrupt the execution of the debugged program.\n\
3162 If non-stop mode is enabled, interrupt only the current thread,\n\
3163 otherwise all the threads in the program are stopped. To \n\
3164 interrupt all running threads in non-stop mode, use the -a option."));
3166 add_info ("registers", nofp_registers_info
, _("\
3167 List of integer registers and their contents, for selected stack frame.\n\
3168 Register name as argument means describe only that register."));
3169 add_info_alias ("r", "registers", 1);
3172 add_com ("lr", class_info
, nofp_registers_info
, _("\
3173 List of integer registers and their contents, for selected stack frame.\n\
3174 Register name as argument means describe only that register."));
3175 add_info ("all-registers", all_registers_info
, _("\
3176 List of all registers and their contents, for selected stack frame.\n\
3177 Register name as argument means describe only that register."));
3179 add_info ("program", program_info
,
3180 _("Execution status of the program."));
3182 add_info ("float", float_info
,
3183 _("Print the status of the floating point unit\n"));
3185 add_info ("vector", vector_info
,
3186 _("Print the status of the vector unit\n"));
3188 add_prefix_cmd ("proc", class_info
, info_proc_cmd
,
3190 Show /proc process information about any running process.\n\
3191 Specify any process id, or use the program being debugged by default."),
3192 &info_proc_cmdlist
, "info proc ",
3193 1/*allow-unknown*/, &infolist
);
3195 add_cmd ("mappings", class_info
, info_proc_cmd_mappings
, _("\
3196 List of mapped memory regions."),
3197 &info_proc_cmdlist
);
3199 add_cmd ("stat", class_info
, info_proc_cmd_stat
, _("\
3200 List process info from /proc/PID/stat."),
3201 &info_proc_cmdlist
);
3203 add_cmd ("status", class_info
, info_proc_cmd_status
, _("\
3204 List process info from /proc/PID/status."),
3205 &info_proc_cmdlist
);
3207 add_cmd ("cwd", class_info
, info_proc_cmd_cwd
, _("\
3208 List current working directory of the process."),
3209 &info_proc_cmdlist
);
3211 add_cmd ("cmdline", class_info
, info_proc_cmd_cmdline
, _("\
3212 List command line arguments of the process."),
3213 &info_proc_cmdlist
);
3215 add_cmd ("exe", class_info
, info_proc_cmd_exe
, _("\
3216 List absolute filename for executable of the process."),
3217 &info_proc_cmdlist
);
3219 add_cmd ("all", class_info
, info_proc_cmd_all
, _("\
3220 List all available /proc info."),
3221 &info_proc_cmdlist
);