1 /* Memory-access and commands for "inferior" process, for GDB.
3 Copyright (C) 1986-2014 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 #include "arch-utils.h"
36 #include "completer.h"
38 #include "event-top.h"
39 #include "parser-defs.h"
41 #include "reggroups.h"
46 #include "target-descriptions.h"
47 #include "user-regs.h"
48 #include "cli/cli-decode.h"
49 #include "gdbthread.h"
51 #include "inline-frame.h"
52 #include "tracepoint.h"
54 #include "continuations.h"
56 #include "cli/cli-utils.h"
58 /* Local functions: */
60 static void nofp_registers_info (char *, int);
62 static void print_return_value (struct value
*function
,
63 struct type
*value_type
);
65 static void until_next_command (int);
67 static void until_command (char *, int);
69 static void path_info (char *, int);
71 static void path_command (char *, int);
73 static void unset_command (char *, int);
75 static void float_info (char *, int);
77 static void disconnect_command (char *, int);
79 static void unset_environment_command (char *, int);
81 static void set_environment_command (char *, int);
83 static void environment_info (char *, int);
85 static void program_info (char *, int);
87 static void finish_command (char *, int);
89 static void signal_command (char *, int);
91 static void jump_command (char *, int);
93 static void step_1 (int, int, char *);
94 static void step_once (int skip_subroutines
, int single_inst
,
95 int count
, int thread
);
97 static void next_command (char *, int);
99 static void step_command (char *, int);
101 static void run_command (char *, int);
103 static void run_no_args_command (char *args
, int from_tty
);
105 static void go_command (char *line_no
, int from_tty
);
107 static int strip_bg_char (char **);
109 void _initialize_infcmd (void);
111 #define ERROR_NO_INFERIOR \
112 if (!target_has_execution) error (_("The program is not being run."));
114 /* Scratch area where string containing arguments to give to the
115 program will be stored by 'set args'. As soon as anything is
116 stored, notice_args_set will move it into per-inferior storage.
117 Arguments are separated by spaces. Empty string (pointer to '\0')
120 static char *inferior_args_scratch
;
122 /* Scratch area where 'set inferior-tty' will store user-provided value.
123 We'll immediate copy it into per-inferior storage. */
125 static char *inferior_io_terminal_scratch
;
127 /* Pid of our debugged inferior, or 0 if no inferior now.
128 Since various parts of infrun.c test this to see whether there is a program
129 being debugged it should be nonzero (currently 3 is used) for remote
132 ptid_t inferior_ptid
;
134 /* Address at which inferior stopped. */
138 /* Nonzero if stopped due to completion of a stack dummy routine. */
140 enum stop_stack_kind stop_stack_dummy
;
142 /* Nonzero if stopped due to a random (unexpected) signal in inferior
145 int stopped_by_random_signal
;
147 /* See inferior.h. */
149 int startup_with_shell
= 1;
152 /* Accessor routines. */
154 /* Set the io terminal for the current inferior. Ownership of
155 TERMINAL_NAME is not transferred. */
158 set_inferior_io_terminal (const char *terminal_name
)
160 xfree (current_inferior ()->terminal
);
161 current_inferior ()->terminal
= terminal_name
? xstrdup (terminal_name
) : 0;
165 get_inferior_io_terminal (void)
167 return current_inferior ()->terminal
;
171 set_inferior_tty_command (char *args
, int from_tty
,
172 struct cmd_list_element
*c
)
174 /* CLI has assigned the user-provided value to inferior_io_terminal_scratch.
175 Now route it to current inferior. */
176 set_inferior_io_terminal (inferior_io_terminal_scratch
);
180 show_inferior_tty_command (struct ui_file
*file
, int from_tty
,
181 struct cmd_list_element
*c
, const char *value
)
183 /* Note that we ignore the passed-in value in favor of computing it
185 const char *inferior_io_terminal
= get_inferior_io_terminal ();
187 if (inferior_io_terminal
== NULL
)
188 inferior_io_terminal
= "";
189 fprintf_filtered (gdb_stdout
,
190 _("Terminal for future runs of program being debugged "
191 "is \"%s\".\n"), inferior_io_terminal
);
195 get_inferior_args (void)
197 if (current_inferior ()->argc
!= 0)
201 n
= construct_inferior_arguments (current_inferior ()->argc
,
202 current_inferior ()->argv
);
203 set_inferior_args (n
);
207 if (current_inferior ()->args
== NULL
)
208 current_inferior ()->args
= xstrdup ("");
210 return current_inferior ()->args
;
213 /* Set the arguments for the current inferior. Ownership of
214 NEWARGS is not transferred. */
217 set_inferior_args (char *newargs
)
219 xfree (current_inferior ()->args
);
220 current_inferior ()->args
= newargs
? xstrdup (newargs
) : NULL
;
221 current_inferior ()->argc
= 0;
222 current_inferior ()->argv
= 0;
226 set_inferior_args_vector (int argc
, char **argv
)
228 current_inferior ()->argc
= argc
;
229 current_inferior ()->argv
= argv
;
232 /* Notice when `set args' is run. */
235 set_args_command (char *args
, int from_tty
, struct cmd_list_element
*c
)
237 /* CLI has assigned the user-provided value to inferior_args_scratch.
238 Now route it to current inferior. */
239 set_inferior_args (inferior_args_scratch
);
242 /* Notice when `show args' is run. */
245 show_args_command (struct ui_file
*file
, int from_tty
,
246 struct cmd_list_element
*c
, const char *value
)
248 /* Note that we ignore the passed-in value in favor of computing it
250 deprecated_show_value_hack (file
, from_tty
, c
, get_inferior_args ());
254 /* Compute command-line string given argument vector. This does the
255 same shell processing as fork_inferior. */
258 construct_inferior_arguments (int argc
, char **argv
)
262 if (startup_with_shell
)
265 /* This holds all the characters considered special to the
267 char *special
= "\"!&*|[]{}<>?`~^=;, \t\n";
268 const char quote
= '"';
270 /* This holds all the characters considered special to the
271 typical Unix shells. We include `^' because the SunOS
272 /bin/sh treats it as a synonym for `|'. */
273 char *special
= "\"!#$&*()\\|[]{}<>?'`~^; \t\n";
274 const char quote
= '\'';
280 /* We over-compute the size. It shouldn't matter. */
281 for (i
= 0; i
< argc
; ++i
)
282 length
+= 3 * strlen (argv
[i
]) + 1 + 2 * (argv
[i
][0] == '\0');
284 result
= (char *) xmalloc (length
);
287 for (i
= 0; i
< argc
; ++i
)
292 /* Need to handle empty arguments specially. */
293 if (argv
[i
][0] == '\0')
303 if (strpbrk (argv
[i
], special
))
309 for (cp
= argv
[i
]; *cp
; ++cp
)
313 /* A newline cannot be quoted with a backslash (it
314 just disappears), only by putting it inside
325 if (strchr (special
, *cp
) != NULL
)
341 /* In this case we can't handle arguments that contain spaces,
342 tabs, or newlines -- see breakup_args(). */
346 for (i
= 0; i
< argc
; ++i
)
348 char *cp
= strchr (argv
[i
], ' ');
350 cp
= strchr (argv
[i
], '\t');
352 cp
= strchr (argv
[i
], '\n');
354 error (_("can't handle command-line "
355 "argument containing whitespace"));
356 length
+= strlen (argv
[i
]) + 1;
359 result
= (char *) xmalloc (length
);
361 for (i
= 0; i
< argc
; ++i
)
364 strcat (result
, " ");
365 strcat (result
, argv
[i
]);
373 /* This function detects whether or not a '&' character (indicating
374 background execution) has been added as *the last* of the arguments ARGS
375 of a command. If it has, it removes it and returns 1. Otherwise it
376 does nothing and returns 0. */
379 strip_bg_char (char **args
)
383 p
= strchr (*args
, '&');
387 if (p
== (*args
+ strlen (*args
) - 1))
389 if (strlen (*args
) > 1)
393 while (*p
== ' ' || *p
== '\t');
404 /* Common actions to take after creating any sort of inferior, by any
405 means (running, attaching, connecting, et cetera). The target
406 should be stopped. */
409 post_create_inferior (struct target_ops
*target
, int from_tty
)
411 volatile struct gdb_exception ex
;
413 /* Be sure we own the terminal in case write operations are performed. */
414 target_terminal_ours ();
416 /* If the target hasn't taken care of this already, do it now.
417 Targets which need to access registers during to_open,
418 to_create_inferior, or to_attach should do it earlier; but many
420 target_find_description ();
422 /* Now that we know the register layout, retrieve current PC. But
423 if the PC is unavailable (e.g., we're opening a core file with
424 missing registers info), ignore it. */
426 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
428 stop_pc
= regcache_read_pc (get_current_regcache ());
430 if (ex
.reason
< 0 && ex
.error
!= NOT_AVAILABLE_ERROR
)
431 throw_exception (ex
);
435 const unsigned solib_add_generation
436 = current_program_space
->solib_add_generation
;
438 /* Create the hooks to handle shared library load and unload
440 solib_create_inferior_hook (from_tty
);
442 if (current_program_space
->solib_add_generation
== solib_add_generation
)
444 /* The platform-specific hook should load initial shared libraries,
445 but didn't. FROM_TTY will be incorrectly 0 but such solib
446 targets should be fixed anyway. Call it only after the solib
447 target has been initialized by solib_create_inferior_hook. */
450 warning (_("platform-specific solib_create_inferior_hook did "
451 "not load initial shared libraries."));
453 /* If the solist is global across processes, there's no need to
455 if (!gdbarch_has_global_solist (target_gdbarch ()))
456 solib_add (NULL
, 0, target
, auto_solib_add
);
460 /* If the user sets watchpoints before execution having started,
461 then she gets software watchpoints, because GDB can't know which
462 target will end up being pushed, or if it supports hardware
463 watchpoints or not. breakpoint_re_set takes care of promoting
464 watchpoints to hardware watchpoints if possible, however, if this
465 new inferior doesn't load shared libraries or we don't pull in
466 symbols from any other source on this target/arch,
467 breakpoint_re_set is never called. Call it now so that software
468 watchpoints get a chance to be promoted to hardware watchpoints
469 if the now pushed target supports hardware watchpoints. */
470 breakpoint_re_set ();
472 observer_notify_inferior_created (target
, from_tty
);
475 /* Kill the inferior if already running. This function is designed
476 to be called when we are about to start the execution of the program
477 from the beginning. Ask the user to confirm that he wants to restart
478 the program being debugged when FROM_TTY is non-null. */
481 kill_if_already_running (int from_tty
)
483 if (! ptid_equal (inferior_ptid
, null_ptid
) && target_has_execution
)
485 /* Bail out before killing the program if we will not be able to
487 target_require_runnable ();
490 && !query (_("The program being debugged has been started already.\n\
491 Start it from the beginning? ")))
492 error (_("Program not restarted."));
497 /* See inferior.h. */
500 prepare_execution_command (struct target_ops
*target
, int background
)
502 /* If we get a request for running in the bg but the target
503 doesn't support it, error out. */
504 if (background
&& !target
->to_can_async_p (target
))
505 error (_("Asynchronous execution not supported on this target."));
507 /* If we don't get a request of running in the bg, then we need
508 to simulate synchronous (fg) execution. */
509 if (!background
&& target
->to_can_async_p (target
))
511 /* Simulate synchronous execution. Note no cleanup is necessary
512 for this. stdin is re-enabled whenever an error reaches the
514 async_disable_stdin ();
518 /* Implement the "run" command. If TBREAK_AT_MAIN is set, then insert
519 a temporary breakpoint at the begining of the main program before
520 running the program. */
523 run_command_1 (char *args
, int from_tty
, int tbreak_at_main
)
526 struct cleanup
*old_chain
;
528 struct ui_out
*uiout
= current_uiout
;
529 struct target_ops
*run_target
;
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. */
554 async_exec
= strip_bg_char (&args
);
556 /* Do validation and preparation before possibly changing anything
559 run_target
= find_run_target ();
561 prepare_execution_command (run_target
, async_exec
);
563 if (non_stop
&& !run_target
->to_supports_non_stop (run_target
))
564 error (_("The target does not support running in non-stop mode."));
566 /* Done. Can now set breakpoints, change inferior args, etc. */
568 /* Insert the temporary breakpoint if a location was specified. */
570 tbreak_command (main_name (), 0);
572 exec_file
= (char *) get_exec_file (0);
574 /* We keep symbols from add-symbol-file, on the grounds that the
575 user might want to add some symbols before running the program
576 (right?). But sometimes (dynamic loading where the user manually
577 introduces the new symbols with add-symbol-file), the code which
578 the symbols describe does not persist between runs. Currently
579 the user has to manually nuke all symbols between runs if they
580 want them to go away (PR 2207). This is probably reasonable. */
582 /* If there were other args, beside '&', process them. */
584 set_inferior_args (args
);
588 ui_out_field_string (uiout
, NULL
, "Starting program");
589 ui_out_text (uiout
, ": ");
591 ui_out_field_string (uiout
, "execfile", exec_file
);
592 ui_out_spaces (uiout
, 1);
593 /* We call get_inferior_args() because we might need to compute
595 ui_out_field_string (uiout
, "infargs", get_inferior_args ());
596 ui_out_text (uiout
, "\n");
597 ui_out_flush (uiout
);
600 /* We call get_inferior_args() because we might need to compute
602 run_target
->to_create_inferior (run_target
, exec_file
, get_inferior_args (),
603 environ_vector (current_inferior ()->environment
),
605 /* to_create_inferior should push the target, so after this point we
606 shouldn't refer to run_target again. */
609 /* We're starting off a new process. When we get out of here, in
610 non-stop mode, finish the state of all threads of that process,
611 but leave other threads alone, as they may be stopped in internal
612 events --- the frontend shouldn't see them as stopped. In
613 all-stop, always finish the state of all threads, as we may be
614 resuming more than just the new process. */
616 ptid
= pid_to_ptid (ptid_get_pid (inferior_ptid
));
618 ptid
= minus_one_ptid
;
619 old_chain
= make_cleanup (finish_thread_state_cleanup
, &ptid
);
621 /* Pass zero for FROM_TTY, because at this point the "run" command
622 has done its thing; now we are setting up the running program. */
623 post_create_inferior (¤t_target
, 0);
625 /* Start the target running. Do not use -1 continuation as it would skip
626 breakpoint right at the entry point. */
627 proceed (regcache_read_pc (get_current_regcache ()), GDB_SIGNAL_0
, 0);
629 /* Since there was no error, there's no need to finish the thread
631 discard_cleanups (old_chain
);
635 run_command (char *args
, int from_tty
)
637 run_command_1 (args
, from_tty
, 0);
641 run_no_args_command (char *args
, int from_tty
)
643 set_inferior_args ("");
647 /* Start the execution of the program up until the beginning of the main
651 start_command (char *args
, int from_tty
)
653 /* Some languages such as Ada need to search inside the program
654 minimal symbols for the location where to put the temporary
655 breakpoint before starting. */
656 if (!have_minimal_symbols ())
657 error (_("No symbol table loaded. Use the \"file\" command."));
659 /* Run the program until reaching the main procedure... */
660 run_command_1 (args
, from_tty
, 1);
664 proceed_thread_callback (struct thread_info
*thread
, void *arg
)
666 /* We go through all threads individually instead of compressing
667 into a single target `resume_all' request, because some threads
668 may be stopped in internal breakpoints/events, or stopped waiting
669 for its turn in the displaced stepping queue (that is, they are
670 running && !executing). The target side has no idea about why
671 the thread is stopped, so a `resume_all' command would resume too
672 much. If/when GDB gains a way to tell the target `hold this
673 thread stopped until I say otherwise', then we can optimize
675 if (!is_stopped (thread
->ptid
))
678 switch_to_thread (thread
->ptid
);
679 clear_proceed_status (0);
680 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
, 0);
685 ensure_valid_thread (void)
687 if (ptid_equal (inferior_ptid
, null_ptid
)
688 || is_exited (inferior_ptid
))
689 error (_("Cannot execute this command without a live selected thread."));
692 /* If the user is looking at trace frames, any resumption of execution
693 is likely to mix up recorded and live target data. So simply
694 disallow those commands. */
697 ensure_not_tfind_mode (void)
699 if (get_traceframe_number () >= 0)
700 error (_("Cannot execute this command while looking at trace frames."));
703 /* Throw an error indicating the current thread is running. */
706 error_is_running (void)
708 error (_("Cannot execute this command while "
709 "the selected thread is running."));
712 /* Calls error_is_running if the current thread is running. */
715 ensure_not_running (void)
717 if (is_running (inferior_ptid
))
722 continue_1 (int all_threads
)
725 ensure_not_tfind_mode ();
727 if (non_stop
&& all_threads
)
729 /* Don't error out if the current thread is running, because
730 there may be other stopped threads. */
731 struct cleanup
*old_chain
;
733 /* Backup current thread and selected frame. */
734 old_chain
= make_cleanup_restore_current_thread ();
736 iterate_over_threads (proceed_thread_callback
, NULL
);
738 /* Restore selected ptid. */
739 do_cleanups (old_chain
);
743 ensure_valid_thread ();
744 ensure_not_running ();
745 clear_proceed_status (0);
746 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
, 0);
750 /* continue [-a] [proceed-count] [&] */
753 continue_command (char *args
, int from_tty
)
759 /* Find out whether we must run in the background. */
761 async_exec
= strip_bg_char (&args
);
763 prepare_execution_command (¤t_target
, async_exec
);
767 if (strncmp (args
, "-a", sizeof ("-a") - 1) == 0)
770 args
+= sizeof ("-a") - 1;
776 if (!non_stop
&& all_threads
)
777 error (_("`-a' is meaningless in all-stop mode."));
779 if (args
!= NULL
&& all_threads
)
780 error (_("Can't resume all threads and specify "
781 "proceed count simultaneously."));
783 /* If we have an argument left, set proceed count of breakpoint we
790 struct thread_info
*tp
;
793 tp
= find_thread_ptid (inferior_ptid
);
797 struct target_waitstatus ws
;
799 get_last_target_status (&last_ptid
, &ws
);
800 tp
= find_thread_ptid (last_ptid
);
803 bs
= tp
->control
.stop_bpstat
;
805 while ((stat
= bpstat_num (&bs
, &num
)) != 0)
808 set_ignore_count (num
,
809 parse_and_eval_long (args
) - 1,
811 /* set_ignore_count prints a message ending with a period.
812 So print two spaces before "Continuing.". */
814 printf_filtered (" ");
818 if (!stopped
&& from_tty
)
821 ("Not stopped at any breakpoint; argument ignored.\n");
826 printf_filtered (_("Continuing.\n"));
828 continue_1 (all_threads
);
831 /* Record the starting point of a "step" or "next" command. */
834 set_step_frame (void)
836 struct symtab_and_line sal
;
838 find_frame_sal (get_current_frame (), &sal
);
839 set_step_info (get_current_frame (), sal
);
842 /* Step until outside of current statement. */
845 step_command (char *count_string
, int from_tty
)
847 step_1 (0, 0, count_string
);
850 /* Likewise, but skip over subroutine calls as if single instructions. */
853 next_command (char *count_string
, int from_tty
)
855 step_1 (1, 0, count_string
);
858 /* Likewise, but step only one instruction. */
861 stepi_command (char *count_string
, int from_tty
)
863 step_1 (0, 1, count_string
);
867 nexti_command (char *count_string
, int from_tty
)
869 step_1 (1, 1, count_string
);
873 delete_longjmp_breakpoint_cleanup (void *arg
)
875 int thread
= * (int *) arg
;
876 delete_longjmp_breakpoint (thread
);
880 step_1 (int skip_subroutines
, int single_inst
, char *count_string
)
883 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
888 ensure_not_tfind_mode ();
889 ensure_valid_thread ();
890 ensure_not_running ();
893 async_exec
= strip_bg_char (&count_string
);
895 prepare_execution_command (¤t_target
, async_exec
);
897 count
= count_string
? parse_and_eval_long (count_string
) : 1;
899 if (!single_inst
|| skip_subroutines
) /* Leave si command alone. */
901 struct thread_info
*tp
= inferior_thread ();
903 if (in_thread_list (inferior_ptid
))
904 thread
= pid_to_thread_id (inferior_ptid
);
906 set_longjmp_breakpoint (tp
, get_frame_id (get_current_frame ()));
908 make_cleanup (delete_longjmp_breakpoint_cleanup
, &thread
);
911 /* In synchronous case, all is well; each step_once call will step once. */
912 if (!target_can_async_p ())
914 for (; count
> 0; count
--)
916 step_once (skip_subroutines
, single_inst
, count
, thread
);
918 if (!target_has_execution
)
922 struct thread_info
*tp
= inferior_thread ();
924 if (!tp
->control
.stop_step
|| !tp
->step_multi
)
926 /* If we stopped for some reason that is not stepping
927 there are no further steps to make. */
934 do_cleanups (cleanups
);
938 /* In the case of an asynchronous target things get complicated;
939 do only one step for now, before returning control to the
940 event loop. Let the continuation figure out how many other
941 steps we need to do, and handle them one at the time, through
943 step_once (skip_subroutines
, single_inst
, count
, thread
);
945 /* We are running, and the continuation is installed. It will
946 disable the longjmp breakpoint as appropriate. */
947 discard_cleanups (cleanups
);
951 struct step_1_continuation_args
954 int skip_subroutines
;
959 /* Called after we are done with one step operation, to check whether
960 we need to step again, before we print the prompt and return control
961 to the user. If count is > 1, we will need to do one more call to
962 proceed(), via step_once(). Basically it is like step_once and
963 step_1_continuation are co-recursive. */
966 step_1_continuation (void *args
, int err
)
968 struct step_1_continuation_args
*a
= args
;
970 if (target_has_execution
)
972 struct thread_info
*tp
;
974 tp
= inferior_thread ();
976 && tp
->step_multi
&& tp
->control
.stop_step
)
978 /* There are more steps to make, and we did stop due to
979 ending a stepping range. Do another step. */
980 step_once (a
->skip_subroutines
, a
->single_inst
,
981 a
->count
- 1, a
->thread
);
987 /* We either hit an error, or stopped for some reason that is
988 not stepping, or there are no further steps to make.
990 if (!a
->single_inst
|| a
->skip_subroutines
)
991 delete_longjmp_breakpoint (a
->thread
);
994 /* Do just one step operation. This is useful to implement the 'step
995 n' kind of commands. In case of asynchronous targets, we will have
996 to set up a continuation to be done after the target stops (after
997 this one step). For synch targets, the caller handles further
1001 step_once (int skip_subroutines
, int single_inst
, int count
, int thread
)
1003 struct frame_info
*frame
= get_current_frame ();
1007 /* Don't assume THREAD is a valid thread id. It is set to -1 if
1008 the longjmp breakpoint was not required. Use the
1009 INFERIOR_PTID thread instead, which is the same thread when
1011 struct thread_info
*tp
= inferior_thread ();
1013 clear_proceed_status (!skip_subroutines
);
1020 /* Step at an inlined function behaves like "down". */
1021 if (!skip_subroutines
1022 && inline_skipped_frames (inferior_ptid
))
1026 /* Pretend that we've ran. */
1027 resume_ptid
= user_visible_resume_ptid (1);
1028 set_running (resume_ptid
, 1);
1030 step_into_inline_frame (inferior_ptid
);
1032 step_once (skip_subroutines
, single_inst
, count
- 1, thread
);
1035 /* Pretend that we've stopped. */
1038 if (target_can_async_p ())
1039 inferior_event_handler (INF_EXEC_COMPLETE
, NULL
);
1044 pc
= get_frame_pc (frame
);
1045 find_pc_line_pc_range (pc
,
1046 &tp
->control
.step_range_start
,
1047 &tp
->control
.step_range_end
);
1049 tp
->control
.may_range_step
= 1;
1051 /* If we have no line info, switch to stepi mode. */
1052 if (tp
->control
.step_range_end
== 0 && step_stop_if_no_debug
)
1054 tp
->control
.step_range_start
= tp
->control
.step_range_end
= 1;
1055 tp
->control
.may_range_step
= 0;
1057 else if (tp
->control
.step_range_end
== 0)
1061 if (find_pc_partial_function (pc
, &name
,
1062 &tp
->control
.step_range_start
,
1063 &tp
->control
.step_range_end
) == 0)
1064 error (_("Cannot find bounds of current function"));
1066 target_terminal_ours ();
1067 printf_filtered (_("Single stepping until exit from function %s,"
1068 "\nwhich has no line number information.\n"),
1074 /* Say we are stepping, but stop after one insn whatever it does. */
1075 tp
->control
.step_range_start
= tp
->control
.step_range_end
= 1;
1076 if (!skip_subroutines
)
1078 Don't step over function calls, not even to functions lacking
1080 tp
->control
.step_over_calls
= STEP_OVER_NONE
;
1083 if (skip_subroutines
)
1084 tp
->control
.step_over_calls
= STEP_OVER_ALL
;
1086 tp
->step_multi
= (count
> 1);
1087 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
, 1);
1089 /* For async targets, register a continuation to do any
1090 additional steps. For sync targets, the caller will handle
1091 further stepping. */
1092 if (target_can_async_p ())
1094 struct step_1_continuation_args
*args
;
1096 args
= xmalloc (sizeof (*args
));
1097 args
->skip_subroutines
= skip_subroutines
;
1098 args
->single_inst
= single_inst
;
1099 args
->count
= count
;
1100 args
->thread
= thread
;
1102 add_intermediate_continuation (tp
, step_1_continuation
, args
, xfree
);
1108 /* Continue program at specified address. */
1111 jump_command (char *arg
, int from_tty
)
1113 struct gdbarch
*gdbarch
= get_current_arch ();
1115 struct symtabs_and_lines sals
;
1116 struct symtab_and_line sal
;
1122 ensure_not_tfind_mode ();
1123 ensure_valid_thread ();
1124 ensure_not_running ();
1126 /* Find out whether we must run in the background. */
1128 async_exec
= strip_bg_char (&arg
);
1130 prepare_execution_command (¤t_target
, async_exec
);
1133 error_no_arg (_("starting address"));
1135 sals
= decode_line_with_last_displayed (arg
, DECODE_LINE_FUNFIRSTLINE
);
1136 if (sals
.nelts
!= 1)
1138 error (_("Unreasonable jump request"));
1144 if (sal
.symtab
== 0 && sal
.pc
== 0)
1145 error (_("No source file has been specified."));
1147 resolve_sal_pc (&sal
); /* May error out. */
1149 /* See if we are trying to jump to another function. */
1150 fn
= get_frame_function (get_current_frame ());
1151 sfn
= find_pc_function (sal
.pc
);
1152 if (fn
!= NULL
&& sfn
!= fn
)
1154 if (!query (_("Line %d is not in `%s'. Jump anyway? "), sal
.line
,
1155 SYMBOL_PRINT_NAME (fn
)))
1157 error (_("Not confirmed."));
1164 fixup_symbol_section (sfn
, 0);
1165 if (section_is_overlay (SYMBOL_OBJ_SECTION (SYMBOL_OBJFILE (sfn
), sfn
)) &&
1166 !section_is_mapped (SYMBOL_OBJ_SECTION (SYMBOL_OBJFILE (sfn
), sfn
)))
1168 if (!query (_("WARNING!!! Destination is in "
1169 "unmapped overlay! Jump anyway? ")))
1171 error (_("Not confirmed."));
1181 printf_filtered (_("Continuing at "));
1182 fputs_filtered (paddress (gdbarch
, addr
), gdb_stdout
);
1183 printf_filtered (".\n");
1186 clear_proceed_status (0);
1187 proceed (addr
, GDB_SIGNAL_0
, 0);
1191 /* Go to line or address in current procedure. */
1194 go_command (char *line_no
, int from_tty
)
1196 if (line_no
== (char *) NULL
|| !*line_no
)
1197 printf_filtered (_("Usage: go <location>\n"));
1200 tbreak_command (line_no
, from_tty
);
1201 jump_command (line_no
, from_tty
);
1206 /* Continue program giving it specified signal. */
1209 signal_command (char *signum_exp
, int from_tty
)
1211 enum gdb_signal oursig
;
1214 dont_repeat (); /* Too dangerous. */
1216 ensure_not_tfind_mode ();
1217 ensure_valid_thread ();
1218 ensure_not_running ();
1220 /* Find out whether we must run in the background. */
1221 if (signum_exp
!= NULL
)
1222 async_exec
= strip_bg_char (&signum_exp
);
1224 prepare_execution_command (¤t_target
, async_exec
);
1227 error_no_arg (_("signal number"));
1229 /* It would be even slicker to make signal names be valid expressions,
1230 (the type could be "enum $signal" or some such), then the user could
1231 assign them to convenience variables. */
1232 oursig
= gdb_signal_from_name (signum_exp
);
1234 if (oursig
== GDB_SIGNAL_UNKNOWN
)
1236 /* No, try numeric. */
1237 int num
= parse_and_eval_long (signum_exp
);
1240 oursig
= GDB_SIGNAL_0
;
1242 oursig
= gdb_signal_from_command (num
);
1245 /* Look for threads other than the current that this command ends up
1246 resuming too (due to schedlock off), and warn if they'll get a
1247 signal delivered. "signal 0" is used to suppress a previous
1248 signal, but if the current thread is no longer the one that got
1249 the signal, then the user is potentially suppressing the signal
1250 of the wrong thread. */
1253 struct thread_info
*tp
;
1255 int must_confirm
= 0;
1257 /* This indicates what will be resumed. Either a single thread,
1258 a whole process, or all threads of all processes. */
1259 resume_ptid
= user_visible_resume_ptid (0);
1261 ALL_NON_EXITED_THREADS (tp
)
1263 if (ptid_equal (tp
->ptid
, inferior_ptid
))
1265 if (!ptid_match (tp
->ptid
, resume_ptid
))
1268 if (tp
->suspend
.stop_signal
!= GDB_SIGNAL_0
1269 && signal_pass_state (tp
->suspend
.stop_signal
))
1272 printf_unfiltered (_("Note:\n"));
1273 printf_unfiltered (_(" Thread %d previously stopped with signal %s, %s.\n"),
1275 gdb_signal_to_name (tp
->suspend
.stop_signal
),
1276 gdb_signal_to_string (tp
->suspend
.stop_signal
));
1282 && !query (_("Continuing thread %d (the current thread) with specified signal will\n"
1283 "still deliver the signals noted above to their respective threads.\n"
1284 "Continue anyway? "),
1285 inferior_thread ()->num
))
1286 error (_("Not confirmed."));
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 (0);
1299 proceed ((CORE_ADDR
) -1, oursig
, 0);
1302 /* Queue a signal to be delivered to the current thread. */
1305 queue_signal_command (char *signum_exp
, int from_tty
)
1307 enum gdb_signal oursig
;
1308 struct thread_info
*tp
;
1311 ensure_not_tfind_mode ();
1312 ensure_valid_thread ();
1313 ensure_not_running ();
1315 if (signum_exp
== NULL
)
1316 error_no_arg (_("signal number"));
1318 /* It would be even slicker to make signal names be valid expressions,
1319 (the type could be "enum $signal" or some such), then the user could
1320 assign them to convenience variables. */
1321 oursig
= gdb_signal_from_name (signum_exp
);
1323 if (oursig
== GDB_SIGNAL_UNKNOWN
)
1325 /* No, try numeric. */
1326 int num
= parse_and_eval_long (signum_exp
);
1329 oursig
= GDB_SIGNAL_0
;
1331 oursig
= gdb_signal_from_command (num
);
1334 if (oursig
!= GDB_SIGNAL_0
1335 && !signal_pass_state (oursig
))
1336 error (_("Signal handling set to not pass this signal to the program."));
1338 tp
= inferior_thread ();
1339 tp
->suspend
.stop_signal
= oursig
;
1342 /* Continuation args to be passed to the "until" command
1344 struct until_next_continuation_args
1346 /* The thread that was current when the command was executed. */
1350 /* A continuation callback for until_next_command. */
1353 until_next_continuation (void *arg
, int err
)
1355 struct until_next_continuation_args
*a
= arg
;
1357 delete_longjmp_breakpoint (a
->thread
);
1360 /* Proceed until we reach a different source line with pc greater than
1361 our current one or exit the function. We skip calls in both cases.
1363 Note that eventually this command should probably be changed so
1364 that only source lines are printed out when we hit the breakpoint
1365 we set. This may involve changes to wait_for_inferior and the
1366 proceed status code. */
1369 until_next_command (int from_tty
)
1371 struct frame_info
*frame
;
1373 struct symbol
*func
;
1374 struct symtab_and_line sal
;
1375 struct thread_info
*tp
= inferior_thread ();
1376 int thread
= tp
->num
;
1377 struct cleanup
*old_chain
;
1379 clear_proceed_status (0);
1382 frame
= get_current_frame ();
1384 /* Step until either exited from this function or greater
1385 than the current line (if in symbolic section) or pc (if
1388 pc
= get_frame_pc (frame
);
1389 func
= find_pc_function (pc
);
1393 struct bound_minimal_symbol msymbol
= lookup_minimal_symbol_by_pc (pc
);
1395 if (msymbol
.minsym
== NULL
)
1396 error (_("Execution is not within a known function."));
1398 tp
->control
.step_range_start
= BMSYMBOL_VALUE_ADDRESS (msymbol
);
1399 /* The upper-bound of step_range is exclusive. In order to make PC
1400 within the range, set the step_range_end with PC + 1. */
1401 tp
->control
.step_range_end
= pc
+ 1;
1405 sal
= find_pc_line (pc
, 0);
1407 tp
->control
.step_range_start
= BLOCK_START (SYMBOL_BLOCK_VALUE (func
));
1408 tp
->control
.step_range_end
= sal
.end
;
1410 tp
->control
.may_range_step
= 1;
1412 tp
->control
.step_over_calls
= STEP_OVER_ALL
;
1414 tp
->step_multi
= 0; /* Only one call to proceed */
1416 set_longjmp_breakpoint (tp
, get_frame_id (frame
));
1417 old_chain
= make_cleanup (delete_longjmp_breakpoint_cleanup
, &thread
);
1419 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
, 1);
1421 if (target_can_async_p () && is_running (inferior_ptid
))
1423 struct until_next_continuation_args
*cont_args
;
1425 discard_cleanups (old_chain
);
1426 cont_args
= XNEW (struct until_next_continuation_args
);
1427 cont_args
->thread
= inferior_thread ()->num
;
1429 add_continuation (tp
, until_next_continuation
, cont_args
, xfree
);
1432 do_cleanups (old_chain
);
1436 until_command (char *arg
, int from_tty
)
1441 ensure_not_tfind_mode ();
1442 ensure_valid_thread ();
1443 ensure_not_running ();
1445 /* Find out whether we must run in the background. */
1447 async_exec
= strip_bg_char (&arg
);
1449 prepare_execution_command (¤t_target
, async_exec
);
1452 until_break_command (arg
, from_tty
, 0);
1454 until_next_command (from_tty
);
1458 advance_command (char *arg
, int from_tty
)
1463 ensure_not_tfind_mode ();
1464 ensure_valid_thread ();
1465 ensure_not_running ();
1468 error_no_arg (_("a location"));
1470 /* Find out whether we must run in the background. */
1472 async_exec
= strip_bg_char (&arg
);
1474 prepare_execution_command (¤t_target
, async_exec
);
1476 until_break_command (arg
, from_tty
, 1);
1479 /* Return the value of the result of a function at the end of a 'finish'
1483 get_return_value (struct value
*function
, struct type
*value_type
)
1485 struct regcache
*stop_regs
= stop_registers
;
1486 struct gdbarch
*gdbarch
;
1487 struct value
*value
;
1488 struct cleanup
*cleanup
= make_cleanup (null_cleanup
, NULL
);
1490 /* If stop_registers were not saved, use the current registers. */
1493 stop_regs
= regcache_dup (get_current_regcache ());
1494 make_cleanup_regcache_xfree (stop_regs
);
1497 gdbarch
= get_regcache_arch (stop_regs
);
1499 CHECK_TYPEDEF (value_type
);
1500 gdb_assert (TYPE_CODE (value_type
) != TYPE_CODE_VOID
);
1502 /* FIXME: 2003-09-27: When returning from a nested inferior function
1503 call, it's possible (with no help from the architecture vector)
1504 to locate and return/print a "struct return" value. This is just
1505 a more complicated case of what is already being done in the
1506 inferior function call code. In fact, when inferior function
1507 calls are made async, this will likely be made the norm. */
1509 switch (gdbarch_return_value (gdbarch
, function
, value_type
,
1512 case RETURN_VALUE_REGISTER_CONVENTION
:
1513 case RETURN_VALUE_ABI_RETURNS_ADDRESS
:
1514 case RETURN_VALUE_ABI_PRESERVES_ADDRESS
:
1515 value
= allocate_value (value_type
);
1516 gdbarch_return_value (gdbarch
, function
, value_type
, stop_regs
,
1517 value_contents_raw (value
), NULL
);
1519 case RETURN_VALUE_STRUCT_CONVENTION
:
1523 internal_error (__FILE__
, __LINE__
, _("bad switch"));
1526 do_cleanups (cleanup
);
1531 /* Print the result of a function at the end of a 'finish' command. */
1534 print_return_value (struct value
*function
, struct type
*value_type
)
1536 struct value
*value
= get_return_value (function
, value_type
);
1537 struct ui_out
*uiout
= current_uiout
;
1541 struct value_print_options opts
;
1542 struct ui_file
*stb
;
1543 struct cleanup
*old_chain
;
1546 stb
= mem_fileopen ();
1547 old_chain
= make_cleanup_ui_file_delete (stb
);
1548 ui_out_text (uiout
, "Value returned is ");
1549 ui_out_field_fmt (uiout
, "gdb-result-var", "$%d",
1550 record_latest_value (value
));
1551 ui_out_text (uiout
, " = ");
1552 get_no_prettyformat_print_options (&opts
);
1553 value_print (value
, stb
, &opts
);
1554 ui_out_field_stream (uiout
, "return-value", stb
);
1555 ui_out_text (uiout
, "\n");
1556 do_cleanups (old_chain
);
1560 ui_out_text (uiout
, "Value returned has type: ");
1561 ui_out_field_string (uiout
, "return-type", TYPE_NAME (value_type
));
1562 ui_out_text (uiout
, ".");
1563 ui_out_text (uiout
, " Cannot determine contents\n");
1567 /* Stuff that needs to be done by the finish command after the target
1568 has stopped. In asynchronous mode, we wait for the target to stop
1569 in the call to poll or select in the event loop, so it is
1570 impossible to do all the stuff as part of the finish_command
1571 function itself. The only chance we have to complete this command
1572 is in fetch_inferior_event, which is called by the event loop as
1573 soon as it detects that the target has stopped. */
1575 struct finish_command_continuation_args
1577 /* The thread that as current when the command was executed. */
1579 struct breakpoint
*breakpoint
;
1580 struct symbol
*function
;
1584 finish_command_continuation (void *arg
, int err
)
1586 struct finish_command_continuation_args
*a
= arg
;
1590 struct thread_info
*tp
= NULL
;
1593 if (!ptid_equal (inferior_ptid
, null_ptid
)
1594 && target_has_execution
1595 && is_stopped (inferior_ptid
))
1597 tp
= inferior_thread ();
1598 bs
= tp
->control
.stop_bpstat
;
1601 if (bpstat_find_breakpoint (bs
, a
->breakpoint
) != NULL
1602 && a
->function
!= NULL
)
1604 struct type
*value_type
;
1606 value_type
= TYPE_TARGET_TYPE (SYMBOL_TYPE (a
->function
));
1608 internal_error (__FILE__
, __LINE__
,
1609 _("finish_command: function has no target type"));
1611 if (TYPE_CODE (value_type
) != TYPE_CODE_VOID
)
1613 volatile struct gdb_exception ex
;
1616 func
= read_var_value (a
->function
, get_current_frame ());
1617 TRY_CATCH (ex
, RETURN_MASK_ALL
)
1619 /* print_return_value can throw an exception in some
1620 circumstances. We need to catch this so that we still
1621 delete the breakpoint. */
1622 print_return_value (func
, value_type
);
1625 exception_print (gdb_stdout
, ex
);
1629 /* We suppress normal call of normal_stop observer and do it
1630 here so that the *stopped notification includes the return
1632 if (bs
!= NULL
&& tp
->control
.proceed_to_finish
)
1633 observer_notify_normal_stop (bs
, 1 /* print frame */);
1636 delete_breakpoint (a
->breakpoint
);
1637 delete_longjmp_breakpoint (a
->thread
);
1641 finish_command_continuation_free_arg (void *arg
)
1646 /* finish_backward -- helper function for finish_command. */
1649 finish_backward (struct symbol
*function
)
1651 struct symtab_and_line sal
;
1652 struct thread_info
*tp
= inferior_thread ();
1654 CORE_ADDR func_addr
;
1656 pc
= get_frame_pc (get_current_frame ());
1658 if (find_pc_partial_function (pc
, NULL
, &func_addr
, NULL
) == 0)
1659 error (_("Cannot find bounds of current function"));
1661 sal
= find_pc_line (func_addr
, 0);
1663 tp
->control
.proceed_to_finish
= 1;
1664 /* Special case: if we're sitting at the function entry point,
1665 then all we need to do is take a reverse singlestep. We
1666 don't need to set a breakpoint, and indeed it would do us
1669 Note that this can only happen at frame #0, since there's
1670 no way that a function up the stack can have a return address
1671 that's equal to its entry point. */
1675 struct frame_info
*frame
= get_selected_frame (NULL
);
1676 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1677 struct symtab_and_line sr_sal
;
1679 /* Set a step-resume at the function's entry point. Once that's
1680 hit, we'll do one more step backwards. */
1683 sr_sal
.pspace
= get_frame_program_space (frame
);
1684 insert_step_resume_breakpoint_at_sal (gdbarch
,
1685 sr_sal
, null_frame_id
);
1687 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
, 0);
1691 /* We're almost there -- we just need to back up by one more
1693 tp
->control
.step_range_start
= tp
->control
.step_range_end
= 1;
1694 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
, 1);
1698 /* finish_forward -- helper function for finish_command. */
1701 finish_forward (struct symbol
*function
, struct frame_info
*frame
)
1703 struct frame_id frame_id
= get_frame_id (frame
);
1704 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1705 struct symtab_and_line sal
;
1706 struct thread_info
*tp
= inferior_thread ();
1707 struct breakpoint
*breakpoint
;
1708 struct cleanup
*old_chain
;
1709 struct finish_command_continuation_args
*cargs
;
1710 int thread
= tp
->num
;
1712 sal
= find_pc_line (get_frame_pc (frame
), 0);
1713 sal
.pc
= get_frame_pc (frame
);
1715 breakpoint
= set_momentary_breakpoint (gdbarch
, sal
,
1716 get_stack_frame_id (frame
),
1719 /* set_momentary_breakpoint invalidates FRAME. */
1722 old_chain
= make_cleanup_delete_breakpoint (breakpoint
);
1724 set_longjmp_breakpoint (tp
, frame_id
);
1725 make_cleanup (delete_longjmp_breakpoint_cleanup
, &thread
);
1727 /* We want stop_registers, please... */
1728 tp
->control
.proceed_to_finish
= 1;
1729 cargs
= xmalloc (sizeof (*cargs
));
1731 cargs
->thread
= thread
;
1732 cargs
->breakpoint
= breakpoint
;
1733 cargs
->function
= function
;
1734 add_continuation (tp
, finish_command_continuation
, cargs
,
1735 finish_command_continuation_free_arg
);
1736 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
, 0);
1738 discard_cleanups (old_chain
);
1739 if (!target_can_async_p ())
1740 do_all_continuations (0);
1743 /* "finish": Set a temporary breakpoint at the place the selected
1744 frame will return to, then continue. */
1747 finish_command (char *arg
, int from_tty
)
1749 struct frame_info
*frame
;
1750 struct symbol
*function
;
1755 ensure_not_tfind_mode ();
1756 ensure_valid_thread ();
1757 ensure_not_running ();
1759 /* Find out whether we must run in the background. */
1761 async_exec
= strip_bg_char (&arg
);
1763 prepare_execution_command (¤t_target
, async_exec
);
1766 error (_("The \"finish\" command does not take any arguments."));
1768 frame
= get_prev_frame (get_selected_frame (_("No selected frame.")));
1770 error (_("\"finish\" not meaningful in the outermost frame."));
1772 clear_proceed_status (0);
1774 /* Finishing from an inline frame is completely different. We don't
1775 try to show the "return value" - no way to locate it. So we do
1776 not need a completion. */
1777 if (get_frame_type (get_selected_frame (_("No selected frame.")))
1780 /* Claim we are stepping in the calling frame. An empty step
1781 range means that we will stop once we aren't in a function
1782 called by that frame. We don't use the magic "1" value for
1783 step_range_end, because then infrun will think this is nexti,
1784 and not step over the rest of this inlined function call. */
1785 struct thread_info
*tp
= inferior_thread ();
1786 struct symtab_and_line empty_sal
;
1788 init_sal (&empty_sal
);
1789 set_step_info (frame
, empty_sal
);
1790 tp
->control
.step_range_start
= get_frame_pc (frame
);
1791 tp
->control
.step_range_end
= tp
->control
.step_range_start
;
1792 tp
->control
.step_over_calls
= STEP_OVER_ALL
;
1794 /* Print info on the selected frame, including level number but not
1798 printf_filtered (_("Run till exit from "));
1799 print_stack_frame (get_selected_frame (NULL
), 1, LOCATION
, 0);
1802 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
, 1);
1806 /* Ignore TAILCALL_FRAME type frames, they were executed already before
1807 entering THISFRAME. */
1808 while (get_frame_type (frame
) == TAILCALL_FRAME
)
1809 frame
= get_prev_frame (frame
);
1811 /* Find the function we will return from. */
1813 function
= find_pc_function (get_frame_pc (get_selected_frame (NULL
)));
1815 /* Print info on the selected frame, including level number but not
1819 if (execution_direction
== EXEC_REVERSE
)
1820 printf_filtered (_("Run back to call of "));
1822 printf_filtered (_("Run till exit from "));
1824 print_stack_frame (get_selected_frame (NULL
), 1, LOCATION
, 0);
1827 if (execution_direction
== EXEC_REVERSE
)
1828 finish_backward (function
);
1830 finish_forward (function
, frame
);
1835 program_info (char *args
, int from_tty
)
1839 struct thread_info
*tp
;
1842 if (!target_has_execution
)
1844 printf_filtered (_("The program being debugged is not being run.\n"));
1849 ptid
= inferior_ptid
;
1852 struct target_waitstatus ws
;
1854 get_last_target_status (&ptid
, &ws
);
1857 if (ptid_equal (ptid
, null_ptid
) || is_exited (ptid
))
1858 error (_("Invalid selected thread."));
1859 else if (is_running (ptid
))
1860 error (_("Selected thread is running."));
1862 tp
= find_thread_ptid (ptid
);
1863 bs
= tp
->control
.stop_bpstat
;
1864 stat
= bpstat_num (&bs
, &num
);
1866 target_files_info ();
1867 printf_filtered (_("Program stopped at %s.\n"),
1868 paddress (target_gdbarch (), stop_pc
));
1869 if (tp
->control
.stop_step
)
1870 printf_filtered (_("It stopped after being stepped.\n"));
1873 /* There may be several breakpoints in the same place, so this
1874 isn't as strange as it seems. */
1879 printf_filtered (_("It stopped at a breakpoint "
1880 "that has since been deleted.\n"));
1883 printf_filtered (_("It stopped at breakpoint %d.\n"), num
);
1884 stat
= bpstat_num (&bs
, &num
);
1887 else if (tp
->suspend
.stop_signal
!= GDB_SIGNAL_0
)
1889 printf_filtered (_("It stopped with signal %s, %s.\n"),
1890 gdb_signal_to_name (tp
->suspend
.stop_signal
),
1891 gdb_signal_to_string (tp
->suspend
.stop_signal
));
1896 printf_filtered (_("Type \"info stack\" or \"info "
1897 "registers\" for more information.\n"));
1902 environment_info (char *var
, int from_tty
)
1906 char *val
= get_in_environ (current_inferior ()->environment
, var
);
1910 puts_filtered (var
);
1911 puts_filtered (" = ");
1912 puts_filtered (val
);
1913 puts_filtered ("\n");
1917 puts_filtered ("Environment variable \"");
1918 puts_filtered (var
);
1919 puts_filtered ("\" not defined.\n");
1924 char **vector
= environ_vector (current_inferior ()->environment
);
1928 puts_filtered (*vector
++);
1929 puts_filtered ("\n");
1935 set_environment_command (char *arg
, int from_tty
)
1937 char *p
, *val
, *var
;
1941 error_no_arg (_("environment variable and value"));
1943 /* Find seperation between variable name and value. */
1944 p
= (char *) strchr (arg
, '=');
1945 val
= (char *) strchr (arg
, ' ');
1947 if (p
!= 0 && val
!= 0)
1949 /* We have both a space and an equals. If the space is before the
1950 equals, walk forward over the spaces til we see a nonspace
1951 (possibly the equals). */
1956 /* Now if the = is after the char following the spaces,
1957 take the char following the spaces. */
1961 else if (val
!= 0 && p
== 0)
1965 error_no_arg (_("environment variable to set"));
1967 if (p
== 0 || p
[1] == 0)
1971 p
= arg
+ strlen (arg
); /* So that savestring below will work. */
1975 /* Not setting variable value to null. */
1977 while (*val
== ' ' || *val
== '\t')
1981 while (p
!= arg
&& (p
[-1] == ' ' || p
[-1] == '\t'))
1984 var
= savestring (arg
, p
- arg
);
1987 printf_filtered (_("Setting environment variable "
1988 "\"%s\" to null value.\n"),
1990 set_in_environ (current_inferior ()->environment
, var
, "");
1993 set_in_environ (current_inferior ()->environment
, var
, val
);
1998 unset_environment_command (char *var
, int from_tty
)
2002 /* If there is no argument, delete all environment variables.
2003 Ask for confirmation if reading from the terminal. */
2004 if (!from_tty
|| query (_("Delete all environment variables? ")))
2006 free_environ (current_inferior ()->environment
);
2007 current_inferior ()->environment
= make_environ ();
2011 unset_in_environ (current_inferior ()->environment
, var
);
2014 /* Handle the execution path (PATH variable). */
2016 static const char path_var_name
[] = "PATH";
2019 path_info (char *args
, int from_tty
)
2021 puts_filtered ("Executable and object file path: ");
2022 puts_filtered (get_in_environ (current_inferior ()->environment
,
2024 puts_filtered ("\n");
2027 /* Add zero or more directories to the front of the execution path. */
2030 path_command (char *dirname
, int from_tty
)
2036 env
= get_in_environ (current_inferior ()->environment
, path_var_name
);
2037 /* Can be null if path is not set. */
2040 exec_path
= xstrdup (env
);
2041 mod_path (dirname
, &exec_path
);
2042 set_in_environ (current_inferior ()->environment
, path_var_name
, exec_path
);
2045 path_info ((char *) NULL
, from_tty
);
2049 /* Print out the register NAME with value VAL, to FILE, in the default
2053 default_print_one_register_info (struct ui_file
*file
,
2057 struct type
*regtype
= value_type (val
);
2058 int print_raw_format
;
2060 fputs_filtered (name
, file
);
2061 print_spaces_filtered (15 - strlen (name
), file
);
2063 print_raw_format
= (value_entirely_available (val
)
2064 && !value_optimized_out (val
));
2066 /* If virtual format is floating, print it that way, and in raw
2068 if (TYPE_CODE (regtype
) == TYPE_CODE_FLT
2069 || TYPE_CODE (regtype
) == TYPE_CODE_DECFLOAT
)
2072 struct value_print_options opts
;
2073 const gdb_byte
*valaddr
= value_contents_for_printing (val
);
2074 enum bfd_endian byte_order
= gdbarch_byte_order (get_type_arch (regtype
));
2076 get_user_print_options (&opts
);
2080 value_contents_for_printing (val
),
2081 value_embedded_offset (val
), 0,
2082 file
, 0, val
, &opts
, current_language
);
2084 if (print_raw_format
)
2086 fprintf_filtered (file
, "\t(raw ");
2087 print_hex_chars (file
, valaddr
, TYPE_LENGTH (regtype
), byte_order
);
2088 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 (print_raw_format
&& 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 /* Decide between printing all regs, non-float / vector regs, or
2148 if (!gdbarch_register_reggroup_p (gdbarch
, i
, all_reggroup
))
2153 if (!gdbarch_register_reggroup_p (gdbarch
, i
, general_reggroup
))
2163 /* If the register name is empty, it is undefined for this
2164 processor, so don't display anything. */
2165 if (gdbarch_register_name (gdbarch
, i
) == NULL
2166 || *(gdbarch_register_name (gdbarch
, i
)) == '\0')
2169 default_print_one_register_info (file
,
2170 gdbarch_register_name (gdbarch
, i
),
2171 value_of_register (i
, frame
));
2176 registers_info (char *addr_exp
, int fpregs
)
2178 struct frame_info
*frame
;
2179 struct gdbarch
*gdbarch
;
2181 if (!target_has_registers
)
2182 error (_("The program has no registers now."));
2183 frame
= get_selected_frame (NULL
);
2184 gdbarch
= get_frame_arch (frame
);
2188 gdbarch_print_registers_info (gdbarch
, gdb_stdout
,
2193 while (*addr_exp
!= '\0')
2198 /* Skip leading white space. */
2199 addr_exp
= skip_spaces (addr_exp
);
2201 /* Discard any leading ``$''. Check that there is something
2202 resembling a register following it. */
2203 if (addr_exp
[0] == '$')
2205 if (isspace ((*addr_exp
)) || (*addr_exp
) == '\0')
2206 error (_("Missing register name"));
2208 /* Find the start/end of this register name/num/group. */
2210 while ((*addr_exp
) != '\0' && !isspace ((*addr_exp
)))
2214 /* Figure out what we've found and display it. */
2216 /* A register name? */
2218 int regnum
= user_reg_map_name_to_regnum (gdbarch
, start
, end
- start
);
2222 /* User registers lie completely outside of the range of
2223 normal registers. Catch them early so that the target
2225 if (regnum
>= gdbarch_num_regs (gdbarch
)
2226 + gdbarch_num_pseudo_regs (gdbarch
))
2228 struct value
*regval
= value_of_user_reg (regnum
, frame
);
2229 const char *regname
= user_reg_map_regnum_to_name (gdbarch
,
2232 /* Print in the same fashion
2233 gdbarch_print_registers_info's default
2234 implementation prints. */
2235 default_print_one_register_info (gdb_stdout
,
2240 gdbarch_print_registers_info (gdbarch
, gdb_stdout
,
2241 frame
, regnum
, fpregs
);
2246 /* A register group? */
2248 struct reggroup
*group
;
2250 for (group
= reggroup_next (gdbarch
, NULL
);
2252 group
= reggroup_next (gdbarch
, group
))
2254 /* Don't bother with a length check. Should the user
2255 enter a short register group name, go with the first
2256 group that matches. */
2257 if (strncmp (start
, reggroup_name (group
), end
- start
) == 0)
2265 regnum
< gdbarch_num_regs (gdbarch
)
2266 + gdbarch_num_pseudo_regs (gdbarch
);
2269 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, group
))
2270 gdbarch_print_registers_info (gdbarch
,
2278 /* Nothing matched. */
2279 error (_("Invalid register `%.*s'"), (int) (end
- start
), start
);
2284 all_registers_info (char *addr_exp
, int from_tty
)
2286 registers_info (addr_exp
, 1);
2290 nofp_registers_info (char *addr_exp
, int from_tty
)
2292 registers_info (addr_exp
, 0);
2296 print_vector_info (struct ui_file
*file
,
2297 struct frame_info
*frame
, const char *args
)
2299 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
2301 if (gdbarch_print_vector_info_p (gdbarch
))
2302 gdbarch_print_vector_info (gdbarch
, file
, frame
, args
);
2306 int printed_something
= 0;
2309 regnum
< gdbarch_num_regs (gdbarch
)
2310 + gdbarch_num_pseudo_regs (gdbarch
);
2313 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, vector_reggroup
))
2315 printed_something
= 1;
2316 gdbarch_print_registers_info (gdbarch
, file
, frame
, regnum
, 1);
2319 if (!printed_something
)
2320 fprintf_filtered (file
, "No vector information\n");
2325 vector_info (char *args
, int from_tty
)
2327 if (!target_has_registers
)
2328 error (_("The program has no registers now."));
2330 print_vector_info (gdb_stdout
, get_selected_frame (NULL
), args
);
2333 /* Kill the inferior process. Make us have no inferior. */
2336 kill_command (char *arg
, int from_tty
)
2338 /* FIXME: This should not really be inferior_ptid (or target_has_execution).
2339 It should be a distinct flag that indicates that a target is active, cuz
2340 some targets don't have processes! */
2342 if (ptid_equal (inferior_ptid
, null_ptid
))
2343 error (_("The program is not being run."));
2344 if (!query (_("Kill the program being debugged? ")))
2345 error (_("Not confirmed."));
2348 /* If we still have other inferiors to debug, then don't mess with
2349 with their threads. */
2350 if (!have_inferiors ())
2352 init_thread_list (); /* Destroy thread info. */
2354 /* Killing off the inferior can leave us with a core file. If
2355 so, print the state we are left in. */
2356 if (target_has_stack
)
2358 printf_filtered (_("In %s,\n"), target_longname
);
2359 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
, 1);
2362 bfd_cache_close_all ();
2365 /* Used in `attach&' command. ARG is a point to an integer
2366 representing a process id. Proceed threads of this process iff
2367 they stopped due to debugger request, and when they did, they
2368 reported a clean stop (GDB_SIGNAL_0). Do not proceed threads
2369 that have been explicitly been told to stop. */
2372 proceed_after_attach_callback (struct thread_info
*thread
,
2375 int pid
= * (int *) arg
;
2377 if (ptid_get_pid (thread
->ptid
) == pid
2378 && !is_exited (thread
->ptid
)
2379 && !is_executing (thread
->ptid
)
2380 && !thread
->stop_requested
2381 && thread
->suspend
.stop_signal
== GDB_SIGNAL_0
)
2383 switch_to_thread (thread
->ptid
);
2384 clear_proceed_status (0);
2385 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
, 0);
2392 proceed_after_attach (int pid
)
2394 /* Don't error out if the current thread is running, because
2395 there may be other stopped threads. */
2396 struct cleanup
*old_chain
;
2398 /* Backup current thread and selected frame. */
2399 old_chain
= make_cleanup_restore_current_thread ();
2401 iterate_over_threads (proceed_after_attach_callback
, &pid
);
2403 /* Restore selected ptid. */
2404 do_cleanups (old_chain
);
2407 /* attach_command --
2408 takes a program started up outside of gdb and ``attaches'' to it.
2409 This stops it cold in its tracks and allows us to start debugging it.
2410 and wait for the trace-trap that results from attaching. */
2413 attach_command_post_wait (char *args
, int from_tty
, int async_exec
)
2416 char *full_exec_path
= NULL
;
2417 struct inferior
*inferior
;
2419 inferior
= current_inferior ();
2420 inferior
->control
.stop_soon
= NO_STOP_QUIETLY
;
2422 /* If no exec file is yet known, try to determine it from the
2424 exec_file
= (char *) get_exec_file (0);
2427 exec_file
= target_pid_to_exec_file (ptid_get_pid (inferior_ptid
));
2430 /* It's possible we don't have a full path, but rather just a
2431 filename. Some targets, such as HP-UX, don't provide the
2434 Attempt to qualify the filename against the source path.
2435 (If that fails, we'll just fall back on the original
2436 filename. Not much more we can do...) */
2438 if (!source_full_path_of (exec_file
, &full_exec_path
))
2439 full_exec_path
= xstrdup (exec_file
);
2441 exec_file_attach (full_exec_path
, from_tty
);
2442 symbol_file_add_main (full_exec_path
, from_tty
);
2447 reopen_exec_file ();
2451 /* Take any necessary post-attaching actions for this platform. */
2452 target_post_attach (ptid_get_pid (inferior_ptid
));
2454 post_create_inferior (¤t_target
, from_tty
);
2458 /* The user requested an `attach&', so be sure to leave threads
2459 that didn't get a signal running. */
2461 /* Immediatelly resume all suspended threads of this inferior,
2462 and this inferior only. This should have no effect on
2463 already running threads. If a thread has been stopped with a
2464 signal, leave it be. */
2466 proceed_after_attach (inferior
->pid
);
2469 if (inferior_thread ()->suspend
.stop_signal
== GDB_SIGNAL_0
)
2471 clear_proceed_status (0);
2472 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
, 0);
2478 /* The user requested a plain `attach', so be sure to leave
2479 the inferior stopped. */
2481 if (target_can_async_p ())
2482 async_enable_stdin ();
2484 /* At least the current thread is already stopped. */
2486 /* In all-stop, by definition, all threads have to be already
2487 stopped at this point. In non-stop, however, although the
2488 selected thread is stopped, others may still be executing.
2489 Be sure to explicitly stop all threads of the process. This
2490 should have no effect on already stopped threads. */
2492 target_stop (pid_to_ptid (inferior
->pid
));
2494 /* Tell the user/frontend where we're stopped. */
2496 if (deprecated_attach_hook
)
2497 deprecated_attach_hook ();
2501 struct attach_command_continuation_args
2509 attach_command_continuation (void *args
, int err
)
2511 struct attach_command_continuation_args
*a
= args
;
2516 attach_command_post_wait (a
->args
, a
->from_tty
, a
->async_exec
);
2520 attach_command_continuation_free_args (void *args
)
2522 struct attach_command_continuation_args
*a
= args
;
2529 attach_command (char *args
, int from_tty
)
2532 struct target_ops
*attach_target
;
2534 dont_repeat (); /* Not for the faint of heart */
2536 if (gdbarch_has_global_solist (target_gdbarch ()))
2537 /* Don't complain if all processes share the same symbol
2540 else if (target_has_execution
)
2542 if (query (_("A program is being debugged already. Kill it? ")))
2545 error (_("Not killed."));
2548 /* Clean up any leftovers from other runs. Some other things from
2549 this function should probably be moved into target_pre_inferior. */
2550 target_pre_inferior (from_tty
);
2553 async_exec
= strip_bg_char (&args
);
2555 attach_target
= find_attach_target ();
2557 prepare_execution_command (attach_target
, async_exec
);
2559 if (non_stop
&& !attach_target
->to_supports_non_stop (attach_target
))
2560 error (_("Cannot attach to this target in non-stop mode"));
2562 attach_target
->to_attach (attach_target
, args
, from_tty
);
2563 /* to_attach should push the target, so after this point we
2564 shouldn't refer to attach_target again. */
2565 attach_target
= NULL
;
2567 /* Set up the "saved terminal modes" of the inferior
2568 based on what modes we are starting it with. */
2569 target_terminal_init ();
2571 /* Install inferior's terminal modes. This may look like a no-op,
2572 as we've just saved them above, however, this does more than
2573 restore terminal settings:
2575 - installs a SIGINT handler that forwards SIGINT to the inferior.
2576 Otherwise a Ctrl-C pressed just while waiting for the initial
2577 stop would end up as a spurious Quit.
2579 - removes stdin from the event loop, which we need if attaching
2580 in the foreground, otherwise on targets that report an initial
2581 stop on attach (which are most) we'd process input/commands
2582 while we're in the event loop waiting for that stop. That is,
2583 before the attach continuation runs and the command is really
2585 target_terminal_inferior ();
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 (0);
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
);
2634 wait_for_inferior ();
2637 attach_command_post_wait (args
, from_tty
, async_exec
);
2640 /* We had just found out that the target was already attached to an
2641 inferior. PTID points at a thread of this new inferior, that is
2642 the most likely to be stopped right now, but not necessarily so.
2643 The new inferior is assumed to be already added to the inferior
2644 list at this point. If LEAVE_RUNNING, then leave the threads of
2645 this inferior running, except those we've explicitly seen reported
2649 notice_new_inferior (ptid_t ptid
, int leave_running
, int from_tty
)
2651 struct cleanup
* old_chain
;
2654 old_chain
= make_cleanup (null_cleanup
, NULL
);
2656 /* If in non-stop, leave threads as running as they were. If
2657 they're stopped for some reason other than us telling it to, the
2658 target reports a signal != GDB_SIGNAL_0. We don't try to
2659 resume threads with such a stop signal. */
2660 async_exec
= non_stop
;
2662 if (!ptid_equal (inferior_ptid
, null_ptid
))
2663 make_cleanup_restore_current_thread ();
2665 switch_to_thread (ptid
);
2667 /* When we "notice" a new inferior we need to do all the things we
2668 would normally do if we had just attached to it. */
2670 if (is_executing (inferior_ptid
))
2672 struct inferior
*inferior
= current_inferior ();
2674 /* We're going to install breakpoints, and poke at memory,
2675 ensure that the inferior is stopped for a moment while we do
2677 target_stop (inferior_ptid
);
2679 inferior
->control
.stop_soon
= STOP_QUIETLY_REMOTE
;
2681 /* Wait for stop before proceeding. */
2682 if (target_can_async_p ())
2684 struct attach_command_continuation_args
*a
;
2686 a
= xmalloc (sizeof (*a
));
2687 a
->args
= xstrdup ("");
2688 a
->from_tty
= from_tty
;
2689 a
->async_exec
= async_exec
;
2690 add_inferior_continuation (attach_command_continuation
, a
,
2691 attach_command_continuation_free_args
);
2693 do_cleanups (old_chain
);
2697 wait_for_inferior ();
2700 async_exec
= leave_running
;
2701 attach_command_post_wait ("" /* args */, from_tty
, async_exec
);
2703 do_cleanups (old_chain
);
2708 * takes a program previously attached to and detaches it.
2709 * The program resumes execution and will no longer stop
2710 * on signals, etc. We better not have left any breakpoints
2711 * in the program or it'll die when it hits one. For this
2712 * to work, it may be necessary for the process to have been
2713 * previously attached. It *might* work if the program was
2714 * started via the normal ptrace (PTRACE_TRACEME).
2718 detach_command (char *args
, int from_tty
)
2720 dont_repeat (); /* Not for the faint of heart. */
2722 if (ptid_equal (inferior_ptid
, null_ptid
))
2723 error (_("The program is not being run."));
2725 query_if_trace_running (from_tty
);
2727 disconnect_tracing ();
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 query_if_trace_running (from_tty
);
2758 disconnect_tracing ();
2759 target_disconnect (args
, from_tty
);
2760 no_shared_libraries (NULL
, from_tty
);
2761 init_thread_list ();
2762 if (deprecated_detach_hook
)
2763 deprecated_detach_hook ();
2767 interrupt_target_1 (int all_threads
)
2772 ptid
= minus_one_ptid
;
2774 ptid
= inferior_ptid
;
2777 /* Tag the thread as having been explicitly requested to stop, so
2778 other parts of gdb know not to resume this thread automatically,
2779 if it was stopped due to an internal event. Limit this to
2780 non-stop mode, as when debugging a multi-threaded application in
2781 all-stop mode, we will only get one stop event --- it's undefined
2782 which thread will report the event. */
2784 set_stop_requested (ptid
, 1);
2788 Stop the execution of the target while running in async mode, in
2789 the backgound. In all-stop, stop the whole process. In non-stop
2790 mode, stop the current thread only by default, or stop all threads
2791 if the `-a' switch is used. */
2794 interrupt_command (char *args
, int from_tty
)
2796 if (target_can_async_p ())
2798 int all_threads
= 0;
2800 dont_repeat (); /* Not for the faint of heart. */
2803 && strncmp (args
, "-a", sizeof ("-a") - 1) == 0)
2806 if (!non_stop
&& all_threads
)
2807 error (_("-a is meaningless in all-stop mode."));
2809 interrupt_target_1 (all_threads
);
2814 print_float_info (struct ui_file
*file
,
2815 struct frame_info
*frame
, const char *args
)
2817 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
2819 if (gdbarch_print_float_info_p (gdbarch
))
2820 gdbarch_print_float_info (gdbarch
, file
, frame
, args
);
2824 int printed_something
= 0;
2827 regnum
< gdbarch_num_regs (gdbarch
)
2828 + gdbarch_num_pseudo_regs (gdbarch
);
2831 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, float_reggroup
))
2833 printed_something
= 1;
2834 gdbarch_print_registers_info (gdbarch
, file
, frame
, regnum
, 1);
2837 if (!printed_something
)
2838 fprintf_filtered (file
, "No floating-point info "
2839 "available for this processor.\n");
2844 float_info (char *args
, int from_tty
)
2846 if (!target_has_registers
)
2847 error (_("The program has no registers now."));
2849 print_float_info (gdb_stdout
, get_selected_frame (NULL
), args
);
2853 unset_command (char *args
, int from_tty
)
2855 printf_filtered (_("\"unset\" must be followed by the "
2856 "name of an unset subcommand.\n"));
2857 help_list (unsetlist
, "unset ", all_commands
, gdb_stdout
);
2860 /* Implement `info proc' family of commands. */
2863 info_proc_cmd_1 (char *args
, enum info_proc_what what
, int from_tty
)
2865 struct gdbarch
*gdbarch
= get_current_arch ();
2867 if (!target_info_proc (args
, what
))
2869 if (gdbarch_info_proc_p (gdbarch
))
2870 gdbarch_info_proc (gdbarch
, args
, what
);
2872 error (_("Not supported on this target."));
2876 /* Implement `info proc' when given without any futher parameters. */
2879 info_proc_cmd (char *args
, int from_tty
)
2881 info_proc_cmd_1 (args
, IP_MINIMAL
, from_tty
);
2884 /* Implement `info proc mappings'. */
2887 info_proc_cmd_mappings (char *args
, int from_tty
)
2889 info_proc_cmd_1 (args
, IP_MAPPINGS
, from_tty
);
2892 /* Implement `info proc stat'. */
2895 info_proc_cmd_stat (char *args
, int from_tty
)
2897 info_proc_cmd_1 (args
, IP_STAT
, from_tty
);
2900 /* Implement `info proc status'. */
2903 info_proc_cmd_status (char *args
, int from_tty
)
2905 info_proc_cmd_1 (args
, IP_STATUS
, from_tty
);
2908 /* Implement `info proc cwd'. */
2911 info_proc_cmd_cwd (char *args
, int from_tty
)
2913 info_proc_cmd_1 (args
, IP_CWD
, from_tty
);
2916 /* Implement `info proc cmdline'. */
2919 info_proc_cmd_cmdline (char *args
, int from_tty
)
2921 info_proc_cmd_1 (args
, IP_CMDLINE
, from_tty
);
2924 /* Implement `info proc exe'. */
2927 info_proc_cmd_exe (char *args
, int from_tty
)
2929 info_proc_cmd_1 (args
, IP_EXE
, from_tty
);
2932 /* Implement `info proc all'. */
2935 info_proc_cmd_all (char *args
, int from_tty
)
2937 info_proc_cmd_1 (args
, IP_ALL
, from_tty
);
2941 _initialize_infcmd (void)
2943 static struct cmd_list_element
*info_proc_cmdlist
;
2944 struct cmd_list_element
*c
= NULL
;
2945 const char *cmd_name
;
2947 /* Add the filename of the terminal connected to inferior I/O. */
2948 add_setshow_filename_cmd ("inferior-tty", class_run
,
2949 &inferior_io_terminal_scratch
, _("\
2950 Set terminal for future runs of program being debugged."), _("\
2951 Show terminal for future runs of program being debugged."), _("\
2952 Usage: set inferior-tty /dev/pts/1"),
2953 set_inferior_tty_command
,
2954 show_inferior_tty_command
,
2955 &setlist
, &showlist
);
2956 add_com_alias ("tty", "set inferior-tty", class_alias
, 0);
2959 add_setshow_string_noescape_cmd (cmd_name
, class_run
,
2960 &inferior_args_scratch
, _("\
2961 Set argument list to give program being debugged when it is started."), _("\
2962 Show argument list to give program being debugged when it is started."), _("\
2963 Follow this command with any number of args, to be passed to the program."),
2966 &setlist
, &showlist
);
2967 c
= lookup_cmd (&cmd_name
, setlist
, "", -1, 1);
2968 gdb_assert (c
!= NULL
);
2969 set_cmd_completer (c
, filename_completer
);
2971 c
= add_cmd ("environment", no_class
, environment_info
, _("\
2972 The environment to give the program, or one variable's value.\n\
2973 With an argument VAR, prints the value of environment variable VAR to\n\
2974 give the program being debugged. With no arguments, prints the entire\n\
2975 environment to be given to the program."), &showlist
);
2976 set_cmd_completer (c
, noop_completer
);
2978 add_prefix_cmd ("unset", no_class
, unset_command
,
2979 _("Complement to certain \"set\" commands."),
2980 &unsetlist
, "unset ", 0, &cmdlist
);
2982 c
= add_cmd ("environment", class_run
, unset_environment_command
, _("\
2983 Cancel environment variable VAR for the program.\n\
2984 This does not affect the program until the next \"run\" command."),
2986 set_cmd_completer (c
, noop_completer
);
2988 c
= add_cmd ("environment", class_run
, set_environment_command
, _("\
2989 Set environment variable value to give the program.\n\
2990 Arguments are VAR VALUE where VAR is variable name and VALUE is value.\n\
2991 VALUES of environment variables are uninterpreted strings.\n\
2992 This does not affect the program until the next \"run\" command."),
2994 set_cmd_completer (c
, noop_completer
);
2996 c
= add_com ("path", class_files
, path_command
, _("\
2997 Add directory DIR(s) to beginning of search path for object files.\n\
2998 $cwd in the path means the current working directory.\n\
2999 This path is equivalent to the $PATH shell variable. It is a list of\n\
3000 directories, separated by colons. These directories are searched to find\n\
3001 fully linked executable files and separately compiled object files as \
3003 set_cmd_completer (c
, filename_completer
);
3005 c
= add_cmd ("paths", no_class
, path_info
, _("\
3006 Current search path for finding object files.\n\
3007 $cwd in the path means the current working directory.\n\
3008 This path is equivalent to the $PATH shell variable. It is a list of\n\
3009 directories, separated by colons. These directories are searched to find\n\
3010 fully linked executable files and separately compiled object files as \
3013 set_cmd_completer (c
, noop_completer
);
3015 add_prefix_cmd ("kill", class_run
, kill_command
,
3016 _("Kill execution of program being debugged."),
3017 &killlist
, "kill ", 0, &cmdlist
);
3019 add_com ("attach", class_run
, attach_command
, _("\
3020 Attach to a process or file outside of GDB.\n\
3021 This command attaches to another target, of the same type as your last\n\
3022 \"target\" command (\"info files\" will show your target stack).\n\
3023 The command may take as argument a process id or a device file.\n\
3024 For a process id, you must have permission to send the process a signal,\n\
3025 and it must have the same effective uid as the debugger.\n\
3026 When using \"attach\" with a process id, the debugger finds the\n\
3027 program running in the process, looking first in the current working\n\
3028 directory, or (if not found there) using the source file search path\n\
3029 (see the \"directory\" command). You can also use the \"file\" command\n\
3030 to specify the program, and to load its symbol table."));
3032 add_prefix_cmd ("detach", class_run
, detach_command
, _("\
3033 Detach a process or file previously attached.\n\
3034 If a process, it is no longer traced, and it continues its execution. If\n\
3035 you were debugging a file, the file is closed and gdb no longer accesses it."),
3036 &detachlist
, "detach ", 0, &cmdlist
);
3038 add_com ("disconnect", class_run
, disconnect_command
, _("\
3039 Disconnect from a target.\n\
3040 The target will wait for another debugger to connect. Not available for\n\
3043 c
= add_com ("signal", class_run
, signal_command
, _("\
3044 Continue program with the specified signal.\n\
3045 Usage: signal SIGNAL\n\
3046 The SIGNAL argument is processed the same as the handle command.\n\
3048 An argument of \"0\" means continue the program without sending it a signal.\n\
3049 This is useful in cases where the program stopped because of a signal,\n\
3050 and you want to resume the program while discarding the signal.\n\
3052 In a multi-threaded program the signal is delivered to, or discarded from,\n\
3053 the current thread only."));
3054 set_cmd_completer (c
, signal_completer
);
3056 c
= add_com ("queue-signal", class_run
, queue_signal_command
, _("\
3057 Queue a signal to be delivered to the current thread when it is resumed.\n\
3058 Usage: queue-signal SIGNAL\n\
3059 The SIGNAL argument is processed the same as the handle command.\n\
3060 It is an error if the handling state of SIGNAL is \"nopass\".\n\
3062 An argument of \"0\" means remove any currently queued signal from\n\
3063 the current thread. This is useful in cases where the program stopped\n\
3064 because of a signal, and you want to resume it while discarding the signal.\n\
3066 In a multi-threaded program the signal is queued with, or discarded from,\n\
3067 the current thread only."));
3068 set_cmd_completer (c
, signal_completer
);
3070 add_com ("stepi", class_run
, stepi_command
, _("\
3071 Step one instruction exactly.\n\
3073 Argument N means step N times (or till program stops for another \
3075 add_com_alias ("si", "stepi", class_alias
, 0);
3077 add_com ("nexti", class_run
, nexti_command
, _("\
3078 Step one instruction, but proceed through subroutine calls.\n\
3080 Argument N means step N times (or till program stops for another \
3082 add_com_alias ("ni", "nexti", class_alias
, 0);
3084 add_com ("finish", class_run
, finish_command
, _("\
3085 Execute until selected stack frame returns.\n\
3087 Upon return, the value returned is printed and put in the value history."));
3088 add_com_alias ("fin", "finish", class_run
, 1);
3090 add_com ("next", class_run
, next_command
, _("\
3091 Step program, proceeding through subroutine calls.\n\
3093 Unlike \"step\", if the current source line calls a subroutine,\n\
3094 this command does not enter the subroutine, but instead steps over\n\
3095 the call, in effect treating it as a single source line."));
3096 add_com_alias ("n", "next", class_run
, 1);
3098 add_com_alias ("S", "next", class_run
, 1);
3100 add_com ("step", class_run
, step_command
, _("\
3101 Step program until it reaches a different source line.\n\
3103 Argument N means step N times (or till program stops for another \
3105 add_com_alias ("s", "step", class_run
, 1);
3107 c
= add_com ("until", class_run
, until_command
, _("\
3108 Execute until the program reaches a source line greater than the current\n\
3109 or a specified location (same args as break command) within the current \
3111 set_cmd_completer (c
, location_completer
);
3112 add_com_alias ("u", "until", class_run
, 1);
3114 c
= add_com ("advance", class_run
, advance_command
, _("\
3115 Continue the program up to the given location (same form as args for break \
3117 Execution will also stop upon exit from the current stack frame."));
3118 set_cmd_completer (c
, location_completer
);
3120 c
= add_com ("jump", class_run
, jump_command
, _("\
3121 Continue program being debugged at specified line or address.\n\
3122 Usage: jump <location>\n\
3123 Give as argument either LINENUM or *ADDR, where ADDR is an expression\n\
3124 for an address to start at."));
3125 set_cmd_completer (c
, location_completer
);
3126 add_com_alias ("j", "jump", class_run
, 1);
3130 c
= add_com ("go", class_run
, go_command
, _("\
3131 Usage: go <location>\n\
3132 Continue program being debugged, stopping at specified line or \n\
3134 Give as argument either LINENUM or *ADDR, where ADDR is an \n\
3135 expression for an address to start at.\n\
3136 This command is a combination of tbreak and jump."));
3137 set_cmd_completer (c
, location_completer
);
3141 add_com_alias ("g", "go", class_run
, 1);
3143 add_com ("continue", class_run
, continue_command
, _("\
3144 Continue program being debugged, after signal or breakpoint.\n\
3145 Usage: continue [N]\n\
3146 If proceeding from breakpoint, a number N may be used as an argument,\n\
3147 which means to set the ignore count of that breakpoint to N - 1 (so that\n\
3148 the breakpoint won't break until the Nth time it is reached).\n\
3150 If non-stop mode is enabled, continue only the current thread,\n\
3151 otherwise all the threads in the program are continued. To \n\
3152 continue all stopped threads in non-stop mode, use the -a option.\n\
3153 Specifying -a and an ignore count simultaneously is an error."));
3154 add_com_alias ("c", "cont", class_run
, 1);
3155 add_com_alias ("fg", "cont", class_run
, 1);
3157 c
= add_com ("run", class_run
, run_command
, _("\
3158 Start debugged program. You may specify arguments to give it.\n\
3159 Args may include \"*\", or \"[...]\"; they are expanded using \"sh\".\n\
3160 Input and output redirection with \">\", \"<\", or \">>\" are also \
3162 With no arguments, uses arguments last specified (with \"run\" \
3163 or \"set args\").\n\
3164 To cancel previous arguments and run with no arguments,\n\
3165 use \"set args\" without arguments."));
3166 set_cmd_completer (c
, filename_completer
);
3167 add_com_alias ("r", "run", class_run
, 1);
3169 add_com ("R", class_run
, run_no_args_command
,
3170 _("Start debugged program with no arguments."));
3172 c
= add_com ("start", class_run
, start_command
, _("\
3173 Run the debugged program until the beginning of the main procedure.\n\
3174 You may specify arguments to give to your program, just as with the\n\
3175 \"run\" command."));
3176 set_cmd_completer (c
, filename_completer
);
3178 add_com ("interrupt", class_run
, interrupt_command
,
3179 _("Interrupt the execution of the debugged program.\n\
3180 If non-stop mode is enabled, interrupt only the current thread,\n\
3181 otherwise all the threads in the program are stopped. To \n\
3182 interrupt all running threads in non-stop mode, use the -a option."));
3184 add_info ("registers", nofp_registers_info
, _("\
3185 List of integer registers and their contents, for selected stack frame.\n\
3186 Register name as argument means describe only that register."));
3187 add_info_alias ("r", "registers", 1);
3190 add_com ("lr", class_info
, nofp_registers_info
, _("\
3191 List of integer registers and their contents, for selected stack frame.\n\
3192 Register name as argument means describe only that register."));
3193 add_info ("all-registers", all_registers_info
, _("\
3194 List of all registers and their contents, for selected stack frame.\n\
3195 Register name as argument means describe only that register."));
3197 add_info ("program", program_info
,
3198 _("Execution status of the program."));
3200 add_info ("float", float_info
,
3201 _("Print the status of the floating point unit\n"));
3203 add_info ("vector", vector_info
,
3204 _("Print the status of the vector unit\n"));
3206 add_prefix_cmd ("proc", class_info
, info_proc_cmd
,
3208 Show /proc process information about any running process.\n\
3209 Specify any process id, or use the program being debugged by default."),
3210 &info_proc_cmdlist
, "info proc ",
3211 1/*allow-unknown*/, &infolist
);
3213 add_cmd ("mappings", class_info
, info_proc_cmd_mappings
, _("\
3214 List of mapped memory regions."),
3215 &info_proc_cmdlist
);
3217 add_cmd ("stat", class_info
, info_proc_cmd_stat
, _("\
3218 List process info from /proc/PID/stat."),
3219 &info_proc_cmdlist
);
3221 add_cmd ("status", class_info
, info_proc_cmd_status
, _("\
3222 List process info from /proc/PID/status."),
3223 &info_proc_cmdlist
);
3225 add_cmd ("cwd", class_info
, info_proc_cmd_cwd
, _("\
3226 List current working directory of the process."),
3227 &info_proc_cmdlist
);
3229 add_cmd ("cmdline", class_info
, info_proc_cmd_cmdline
, _("\
3230 List command line arguments of the process."),
3231 &info_proc_cmdlist
);
3233 add_cmd ("exe", class_info
, info_proc_cmd_exe
, _("\
3234 List absolute filename for executable of the process."),
3235 &info_proc_cmdlist
);
3237 add_cmd ("all", class_info
, info_proc_cmd_all
, _("\
3238 List all available /proc info."),
3239 &info_proc_cmdlist
);