X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Finfrun.c;h=37447334eb0d5c34857e02a02019c107191de5fc;hb=cf3e377e61e7861677252feb4d06ba8fcea1e5c1;hp=07083f0757b0ca7807dc3115851e546c2950ab98;hpb=d747e0af3d41f19815ab972f6fc9527fbf52804a;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/infrun.c b/gdb/infrun.c index 07083f0757..37447334eb 100644 --- a/gdb/infrun.c +++ b/gdb/infrun.c @@ -1,5 +1,6 @@ -/* Start (run) and stop the inferior process, for GDB. - Copyright 1986, 1987, 1988, 1989, 1991, 1992 Free Software Foundation, Inc. +/* Target-struct-independent code to start (run) and stop an inferior process. + Copyright 1986, 1987, 1988, 1989, 1991, 1992, 1993 + Free Software Foundation, Inc. This file is part of GDB. @@ -103,15 +104,14 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "defs.h" #include +#include #include "symtab.h" #include "frame.h" #include "inferior.h" #include "breakpoint.h" #include "wait.h" #include "gdbcore.h" -#include "signame.h" -#include "command.h" -#include "terminal.h" /* For #ifdef TIOCGPGRP and new_tty */ +#include "gdbcmd.h" #include "target.h" #include @@ -123,17 +123,10 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include #endif -#ifdef SET_STACK_LIMIT_HUGE -#include -#include - -extern int original_stack_limit; -#endif /* SET_STACK_LIMIT_HUGE */ - /* Prototypes for local functions */ static void -signals_info PARAMS ((char *)); +signals_info PARAMS ((char *, int)); static void handle_command PARAMS ((char *, int)); @@ -144,37 +137,11 @@ sig_print_info PARAMS ((int)); static void sig_print_header PARAMS ((void)); -static void -remove_step_breakpoint PARAMS ((void)); - -static void -insert_step_breakpoint PARAMS ((void)); - -static void -resume PARAMS ((int, int)); - static void resume_cleanups PARAMS ((int)); -extern char **environ; - -extern struct target_ops child_ops; /* In inftarg.c */ - -/* Sigtramp is a routine that the kernel calls (which then calls the - signal handler). On most machines it is a library routine that - is linked into the executable. - - This macro, given a program counter value and the name of the - function in which that PC resides (which can be null if the - name is not known), returns nonzero if the PC and name show - that we are in sigtramp. - - On most machines just see if the name is sigtramp (and if we have - no name, assume we are not in sigtramp). */ -#if !defined (IN_SIGTRAMP) -#define IN_SIGTRAMP(pc, name) \ - (name && !strcmp ("_sigtramp", name)) -#endif +static int +hook_stop_stub PARAMS ((char *)); /* GET_LONGJMP_TARGET returns the PC at which longjmp() will resume the program. It needs to examine the jmp_buf argument and extract the PC @@ -191,40 +158,57 @@ extern struct target_ops child_ops; /* In inftarg.c */ #define SKIP_TRAMPOLINE_CODE(pc) 0 #endif +/* For SVR4 shared libraries, each call goes through a small piece of + trampoline code in the ".init" section. IN_SOLIB_TRAMPOLINE evaluates + to nonzero if we are current stopped in one of these. */ +#ifndef IN_SOLIB_TRAMPOLINE +#define IN_SOLIB_TRAMPOLINE(pc,name) 0 +#endif + +/* On some systems, the PC may be left pointing at an instruction that won't + actually be executed. This is usually indicated by a bit in the PSW. If + we find ourselves in such a state, then we step the target beyond the + nullified instruction before returning control to the user so as to avoid + confusion. */ -#ifdef TDESC -#include "tdesc.h" -int safe_to_init_tdesc_context = 0; -extern dc_dcontext_t current_context; +#ifndef INSTRUCTION_NULLIFIED +#define INSTRUCTION_NULLIFIED 0 #endif /* Tables of how to react to signals; the user sets them. */ -static char signal_stop[NSIG]; -static char signal_print[NSIG]; -static char signal_program[NSIG]; +static unsigned char *signal_stop; +static unsigned char *signal_print; +static unsigned char *signal_program; -/* Nonzero if breakpoints are now inserted in the inferior. */ -/* Nonstatic for initialization during xxx_create_inferior. FIXME. */ +#define SET_SIGS(nsigs,sigs,flags) \ + do { \ + int signum = (nsigs); \ + while (signum-- > 0) \ + if ((sigs)[signum]) \ + (flags)[signum] = 1; \ + } while (0) -/*static*/ int breakpoints_inserted; +#define UNSET_SIGS(nsigs,sigs,flags) \ + do { \ + int signum = (nsigs); \ + while (signum-- > 0) \ + if ((sigs)[signum]) \ + (flags)[signum] = 0; \ + } while (0) -/* Function inferior was in as of last step command. */ -static struct symbol *step_start_function; - -/* Nonzero => address for special breakpoint for resuming stepping. */ +/* Command list pointer for the "stop" placeholder. */ -static CORE_ADDR step_resume_break_address; +static struct cmd_list_element *stop_command; -/* Pointer to orig contents of the byte where the special breakpoint is. */ +/* Nonzero if breakpoints are now inserted in the inferior. */ -static char step_resume_break_shadow[BREAKPOINT_MAX]; +static int breakpoints_inserted; -/* Nonzero means the special breakpoint is a duplicate - so it has not itself been inserted. */ +/* Function inferior was in as of last step command. */ -static int step_resume_break_duplicate; +static struct symbol *step_start_function; /* Nonzero if we are expecting a trace trap and should proceed from it. */ @@ -248,11 +232,6 @@ int stop_after_trap; int stop_soon_quietly; -/* Nonzero if pc has been changed by the debugger - since the inferior stopped. */ - -int pc_changed; - /* Nonzero if proceed is being used for a "finish" command or a similar situation when stop_registers should be saved. */ @@ -296,7 +275,7 @@ resume_cleanups (arg) STEP nonzero if we should step (zero to continue instead). SIG is the signal to give the inferior (zero for none). */ -static void +void resume (step, sig) int step; int sig; @@ -304,6 +283,14 @@ resume (step, sig) struct cleanup *old_cleanups = make_cleanup (resume_cleanups, 0); QUIT; +#ifdef CANNOT_STEP_BREAKPOINT + /* Most targets can step a breakpoint instruction, thus executing it + normally. But if this one cannot, just continue and we will hit + it anyway. */ + if (step && breakpoints_inserted && breakpoint_here_p (read_pc ())) + step = 0; +#endif + #ifdef NO_SINGLE_STEP if (step) { single_step(sig); /* Do it the hard way, w/temp breakpoints */ @@ -316,7 +303,7 @@ resume (step, sig) DO_DEFERRED_STORES; #endif - target_resume (step, sig); + target_resume (inferior_pid, step, sig); discard_cleanups (old_cleanups); } @@ -332,7 +319,6 @@ clear_proceed_status () step_range_end = 0; step_frame_address = 0; step_over_calls = -1; - step_resume_break_address = 0; stop_after_trap = 0; stop_soon_quietly = 0; proceed_to_finish = 0; @@ -373,19 +359,11 @@ proceed (addr, siggnal, step) step one instruction before inserting breakpoints so that we do not stop right away. */ - if (!pc_changed && breakpoint_here_p (read_pc ())) + if (breakpoint_here_p (read_pc ())) oneproc = 1; } else - { - write_register (PC_REGNUM, addr); -#ifdef NPC_REGNUM - write_register (NPC_REGNUM, addr + 4); -#ifdef NNPC_REGNUM - write_register (NNPC_REGNUM, addr + 8); -#endif -#endif - } + write_pc (addr); if (trap_expected_after_continue) { @@ -443,233 +421,6 @@ static CORE_ADDR prev_func_start; static char *prev_func_name; -/* Start an inferior Unix child process and sets inferior_pid to its pid. - EXEC_FILE is the file to run. - ALLARGS is a string containing the arguments to the program. - ENV is the environment vector to pass. Errors reported with error(). */ - -#ifndef SHELL_FILE -#define SHELL_FILE "/bin/sh" -#endif - -void -child_create_inferior (exec_file, allargs, env) - char *exec_file; - char *allargs; - char **env; -{ - int pid; - char *shell_command; - extern int sys_nerr; - extern char *sys_errlist[]; - char *shell_file; - static char default_shell_file[] = SHELL_FILE; - int len; - int pending_execs; - /* Set debug_fork then attach to the child while it sleeps, to debug. */ - static int debug_fork = 0; - /* This is set to the result of setpgrp, which if vforked, will be visible - to you in the parent process. It's only used by humans for debugging. */ - static int debug_setpgrp = 657473; - char **save_our_env; - - /* The user might want tilde-expansion, and in general probably wants - the program to behave the same way as if run from - his/her favorite shell. So we let the shell run it for us. - FIXME, this should probably search the local environment (as - modified by the setenv command), not the env gdb inherited. */ - shell_file = getenv ("SHELL"); - if (shell_file == NULL) - shell_file = default_shell_file; - - len = 5 + strlen (exec_file) + 1 + strlen (allargs) + 1 + /*slop*/ 10; - /* If desired, concat something onto the front of ALLARGS. - SHELL_COMMAND is the result. */ -#ifdef SHELL_COMMAND_CONCAT - shell_command = (char *) alloca (strlen (SHELL_COMMAND_CONCAT) + len); - strcpy (shell_command, SHELL_COMMAND_CONCAT); -#else - shell_command = (char *) alloca (len); - shell_command[0] = '\0'; -#endif - strcat (shell_command, "exec "); - strcat (shell_command, exec_file); - strcat (shell_command, " "); - strcat (shell_command, allargs); - - /* exec is said to fail if the executable is open. */ - close_exec_file (); - - /* Retain a copy of our environment variables, since the child will - replace the value of environ and if we're vforked, we have to - restore it. */ - save_our_env = environ; - - /* Tell the terminal handling subsystem what tty we plan to run on; - it will just record the information for later. */ - - new_tty_prefork (inferior_io_terminal); - - /* It is generally good practice to flush any possible pending stdio - output prior to doing a fork, to avoid the possibility of both the - parent and child flushing the same data after the fork. */ - - fflush (stdout); - fflush (stderr); - -#if defined(USG) && !defined(HAVE_VFORK) - pid = fork (); -#else - if (debug_fork) - pid = fork (); - else - pid = vfork (); -#endif - - if (pid < 0) - perror_with_name ("vfork"); - - if (pid == 0) - { - if (debug_fork) - sleep (debug_fork); - -#ifdef TIOCGPGRP - /* Run inferior in a separate process group. */ -#ifdef NEED_POSIX_SETPGID - debug_setpgrp = setpgid (0, 0); -#else -#if defined(USG) && !defined(SETPGRP_ARGS) - debug_setpgrp = setpgrp (); -#else - debug_setpgrp = setpgrp (getpid (), getpid ()); -#endif /* USG */ -#endif /* NEED_POSIX_SETPGID */ - if (debug_setpgrp == -1) - perror("setpgrp failed in child"); -#endif /* TIOCGPGRP */ - -#ifdef SET_STACK_LIMIT_HUGE - /* Reset the stack limit back to what it was. */ - { - struct rlimit rlim; - - getrlimit (RLIMIT_STACK, &rlim); - rlim.rlim_cur = original_stack_limit; - setrlimit (RLIMIT_STACK, &rlim); - } -#endif /* SET_STACK_LIMIT_HUGE */ - - /* Ask the tty subsystem to switch to the one we specified earlier - (or to share the current terminal, if none was specified). */ - - new_tty (); - - /* Changing the signal handlers for the inferior after - a vfork can also change them for the superior, so we don't mess - with signals here. See comments in - initialize_signals for how we get the right signal handlers - for the inferior. */ - -#ifdef USE_PROC_FS - proc_set_exec_trap (); /* Use SVR4 /proc interface */ -#else - call_ptrace (0, 0, 0, 0); /* "Trace me, Dr. Memory!" */ -#endif - - /* There is no execlpe call, so we have to set the environment - for our child in the global variable. If we've vforked, this - clobbers the parent, but environ is restored a few lines down - in the parent. By the way, yes we do need to look down the - path to find $SHELL. Rich Pixley says so, and I agree. */ - environ = env; - execlp (shell_file, shell_file, "-c", shell_command, (char *)0); - - fprintf (stderr, "Cannot exec %s: %s.\n", shell_file, - errno < sys_nerr ? sys_errlist[errno] : "unknown error"); - fflush (stderr); - _exit (0177); - } - - /* Restore our environment in case a vforked child clob'd it. */ - environ = save_our_env; - - /* Now that we have a child process, make it our target. */ - push_target (&child_ops); - -#ifdef CREATE_INFERIOR_HOOK - CREATE_INFERIOR_HOOK (pid); -#endif - -/* The process was started by the fork that created it, - but it will have stopped one instruction after execing the shell. - Here we must get it up to actual execution of the real program. */ - - inferior_pid = pid; /* Needed for wait_for_inferior stuff below */ - - clear_proceed_status (); - - /* We will get a trace trap after one instruction. - Continue it automatically. Eventually (after shell does an exec) - it will get another trace trap. Then insert breakpoints and continue. */ - -#ifdef START_INFERIOR_TRAPS_EXPECTED - pending_execs = START_INFERIOR_TRAPS_EXPECTED; -#else - pending_execs = 2; -#endif - - init_wait_for_inferior (); - - /* Set up the "saved terminal modes" of the inferior - based on what modes we are starting it with. */ - target_terminal_init (); - - /* Install inferior's terminal modes. */ - target_terminal_inferior (); - - while (1) - { - stop_soon_quietly = 1; /* Make wait_for_inferior be quiet */ - wait_for_inferior (); - if (stop_signal != SIGTRAP) - { - /* Let shell child handle its own signals in its own way */ - /* FIXME, what if child has exit()ed? Must exit loop somehow */ - resume (0, stop_signal); - } - else - { - /* We handle SIGTRAP, however; it means child did an exec. */ - if (0 == --pending_execs) - break; - resume (0, 0); /* Just make it go on */ - } - } - stop_soon_quietly = 0; - - /* We are now in the child process of interest, having exec'd the - correct program, and are poised at the first instruction of the - new program. */ -#ifdef SOLIB_CREATE_INFERIOR_HOOK - SOLIB_CREATE_INFERIOR_HOOK (); -#endif - - /* Should this perhaps just be a "proceed" call? FIXME */ - insert_step_breakpoint (); - breakpoints_failed = insert_breakpoints (); - if (!breakpoints_failed) - { - breakpoints_inserted = 1; - target_terminal_inferior(); - /* Start the child program going on its first instruction, single- - stepping if we need to. */ - resume (bpstat_should_step (), 0); - wait_for_inferior (); - normal_stop (); - } -} - /* Start remote-debugging of a machine over a serial link. */ void @@ -696,65 +447,17 @@ init_wait_for_inferior () trap_expected_after_continue = 0; breakpoints_inserted = 0; - mark_breakpoints_out (); + breakpoint_init_inferior (); stop_signal = 0; /* Don't confuse first call to proceed(). */ } - -/* Attach to process PID, then initialize for debugging it - and wait for the trace-trap that results from attaching. */ - -void -child_attach (args, from_tty) - char *args; - int from_tty; +static void +delete_breakpoint_current_contents (arg) + PTR arg; { - char *exec_file; - int pid; - - dont_repeat(); - - if (!args) - error_no_arg ("process-id to attach"); - -#ifndef ATTACH_DETACH - error ("Can't attach to a process on this machine."); -#else - pid = atoi (args); - - if (target_has_execution) - { - if (query ("A program is being debugged already. Kill it? ")) - target_kill (); - else - error ("Inferior not killed."); - } - - exec_file = (char *) get_exec_file (1); - - if (from_tty) - { - printf ("Attaching program: %s pid %d\n", - exec_file, pid); - fflush (stdout); - } - - attach (pid); - inferior_pid = pid; - push_target (&child_ops); - - mark_breakpoints_out (); - target_terminal_init (); - clear_proceed_status (); - stop_soon_quietly = 1; - /*proceed (-1, 0, -2);*/ - target_terminal_inferior (); - wait_for_inferior (); -#ifdef SOLIB_ADD - SOLIB_ADD ((char *)0, from_tty, (struct target_ops *)0); -#endif - normal_stop (); -#endif /* ATTACH_DETACH */ + struct breakpoint **breakpointp = (struct breakpoint **)arg; + if (*breakpointp != NULL) + delete_breakpoint (*breakpointp); } /* Wait for control to return from inferior to debugger. @@ -766,41 +469,59 @@ child_attach (args, from_tty) void wait_for_inferior () { + struct cleanup *old_cleanups; WAITTYPE w; int another_trap; int random_signal; - CORE_ADDR stop_sp; + CORE_ADDR stop_sp = 0; CORE_ADDR stop_func_start; char *stop_func_name; - CORE_ADDR prologue_pc, tmp; - int stop_step_resume_break; + CORE_ADDR prologue_pc = 0, tmp; struct symtab_and_line sal; int remove_breakpoints_on_following_step = 0; int current_line; int handling_longjmp = 0; /* FIXME */ + struct breakpoint *step_resume_breakpoint = NULL; + int pid; + old_cleanups = make_cleanup (delete_breakpoint_current_contents, + &step_resume_breakpoint); sal = find_pc_line(prev_pc, 0); current_line = sal.line; + /* Are we stepping? */ +#define CURRENTLY_STEPPING() ((step_resume_breakpoint == NULL \ + && !handling_longjmp \ + && (step_range_end \ + || trap_expected)) \ + || bpstat_should_step ()) + while (1) { /* Clean up saved state that will become invalid. */ - pc_changed = 0; flush_cached_frames (); registers_changed (); - target_wait (&w); + pid = target_wait (&w); + +#ifdef SIGTRAP_STOP_AFTER_LOAD + + /* Somebody called load(2), and it gave us a "trap signal after load". + Ignore it gracefully. */ + + SIGTRAP_STOP_AFTER_LOAD (w); +#endif /* See if the process still exists; clean up if it doesn't. */ if (WIFEXITED (w)) { target_terminal_ours (); /* Must do this before mourn anyway */ if (WEXITSTATUS (w)) - printf ("\nProgram exited with code 0%o.\n", + printf_filtered ("\nProgram exited with code 0%o.\n", (unsigned int)WEXITSTATUS (w)); else if (!batch_mode()) - printf ("\nProgram exited normally.\n"); + printf_filtered ("\nProgram exited normally.\n"); fflush (stdout); target_mourn_inferior (); #ifdef NO_SINGLE_STEP @@ -811,21 +532,26 @@ wait_for_inferior () } else if (!WIFSTOPPED (w)) { + char *signame; + stop_print_frame = 0; stop_signal = WTERMSIG (w); target_terminal_ours (); /* Must do this before mourn anyway */ target_kill (); /* kill mourns as well */ #ifdef PRINT_RANDOM_SIGNAL - printf ("\nProgram terminated: "); + printf_filtered ("\nProgram terminated: "); PRINT_RANDOM_SIGNAL (stop_signal); #else - printf ("\nProgram terminated with signal %d, %s\n", - stop_signal, - stop_signal < NSIG - ? sys_siglist[stop_signal] - : "(undocumented)"); + printf_filtered ("\nProgram terminated with signal "); + signame = strsigno (stop_signal); + if (signame == NULL) + printf_filtered ("%d", stop_signal); + else + /* Do we need to print the number in addition to the name? */ + printf_filtered ("%s (%d)", signame, stop_signal); + printf_filtered (", %s\n", safe_strsignal (stop_signal)); #endif - printf ("The inferior process no longer exists.\n"); + printf_filtered ("The program no longer exists.\n"); fflush (stdout); #ifdef NO_SINGLE_STEP one_stepped = 0; @@ -833,30 +559,107 @@ wait_for_inferior () break; } + if (pid != inferior_pid) + { + int printed = 0; + + if (!in_thread_list (pid)) + { + fprintf (stderr, "[New %s]\n", target_pid_to_str (pid)); + add_thread (pid); + + target_resume (pid, 0, 0); + continue; + } + else + { + stop_signal = WSTOPSIG (w); + + if (stop_signal >= NSIG || signal_print[stop_signal]) + { + char *signame; + + printed = 1; + target_terminal_ours_for_output (); + printf_filtered ("\nProgram received signal "); + signame = strsigno (stop_signal); + if (signame == NULL) + printf_filtered ("%d", stop_signal); + else + printf_filtered ("%s (%d)", signame, stop_signal); + printf_filtered (", %s\n", safe_strsignal (stop_signal)); + + fflush (stdout); + } + + if (stop_signal >= NSIG || signal_stop[stop_signal]) + { + inferior_pid = pid; + printf_filtered ("[Switching to %s]\n", target_pid_to_str (pid)); + + flush_cached_frames (); + registers_changed (); + trap_expected = 0; + if (step_resume_breakpoint) + { + delete_breakpoint (step_resume_breakpoint); + step_resume_breakpoint = NULL; + } + prev_pc = 0; + prev_sp = 0; + prev_func_name = NULL; + step_range_start = 0; + step_range_end = 0; + step_frame_address = 0; + handling_longjmp = 0; + another_trap = 0; + } + else + { + if (printed) + target_terminal_inferior (); + + /* Clear the signal if it should not be passed. */ + if (signal_program[stop_signal] == 0) + stop_signal = 0; + + target_resume (pid, 0, stop_signal); + continue; + } + } + } + #ifdef NO_SINGLE_STEP if (one_stepped) single_step (0); /* This actually cleans up the ss */ #endif /* NO_SINGLE_STEP */ +/* If PC is pointing at a nullified instruction, then step beyond it so that + the user won't be confused when GDB appears to be ready to execute it. */ + + if (INSTRUCTION_NULLIFIED) + { + resume (1, 0); + continue; + } + stop_pc = read_pc (); - set_current_frame ( create_new_frame (read_register (FP_REGNUM), - read_pc ())); - + set_current_frame ( create_new_frame (read_fp (), stop_pc)); + stop_frame_address = FRAME_FP (get_current_frame ()); - stop_sp = read_register (SP_REGNUM); + stop_sp = read_sp (); stop_func_start = 0; stop_func_name = 0; /* Don't care about return value; stop_func_start and stop_func_name will both be 0 if it doesn't work. */ - (void) find_pc_partial_function (stop_pc, &stop_func_name, - &stop_func_start); + find_pc_partial_function (stop_pc, &stop_func_name, &stop_func_start, + (CORE_ADDR *)NULL); stop_func_start += FUNCTION_START_OFFSET; another_trap = 0; bpstat_clear (&stop_bpstat); stop_step = 0; stop_stack_dummy = 0; stop_print_frame = 1; - stop_step_resume_break = 0; random_signal = 0; stopped_by_random_signal = 0; breakpoints_failed = 0; @@ -881,7 +684,10 @@ wait_for_inferior () if (stop_signal == SIGTRAP || (breakpoints_inserted && (stop_signal == SIGILL - || stop_signal == SIGEMT)) +#ifdef SIGEMT + || stop_signal == SIGEMT +#endif + )) || stop_soon_quietly) { if (stop_signal == SIGTRAP && stop_after_trap) @@ -896,70 +702,53 @@ wait_for_inferior () if just proceeded over a breakpoint. However, if we are trying to proceed over a breakpoint - and end up in sigtramp, then step_resume_break_address + and end up in sigtramp, then step_resume_breakpoint will be set and we should check whether we've hit the step breakpoint. */ if (stop_signal == SIGTRAP && trap_expected - && step_resume_break_address == 0) + && step_resume_breakpoint == NULL) bpstat_clear (&stop_bpstat); else { /* See if there is a breakpoint at the current PC. */ + stop_bpstat = bpstat_stop_status + (&stop_pc, stop_frame_address, #if DECR_PC_AFTER_BREAK - /* Notice the case of stepping through a jump - that lands just after a breakpoint. - Don't confuse that with hitting the breakpoint. - What we check for is that 1) stepping is going on - and 2) the pc before the last insn does not match - the address of the breakpoint before the current pc. */ - if (prev_pc == stop_pc - DECR_PC_AFTER_BREAK - || !step_range_end - || step_resume_break_address - || handling_longjmp /* FIXME */) -#endif /* DECR_PC_AFTER_BREAK not zero */ - { - /* See if we stopped at the special breakpoint for - stepping over a subroutine call. If both are zero, - this wasn't the reason for the stop. */ - if (step_resume_break_address - && stop_pc - DECR_PC_AFTER_BREAK - == step_resume_break_address) - { - stop_step_resume_break = 1; - if (DECR_PC_AFTER_BREAK) - { - stop_pc -= DECR_PC_AFTER_BREAK; - write_register (PC_REGNUM, stop_pc); - pc_changed = 0; - } - } - else - { - stop_bpstat = - bpstat_stop_status (&stop_pc, stop_frame_address); - /* Following in case break condition called a - function. */ - stop_print_frame = 1; - } - } + /* Notice the case of stepping through a jump + that lands just after a breakpoint. + Don't confuse that with hitting the breakpoint. + What we check for is that 1) stepping is going on + and 2) the pc before the last insn does not match + the address of the breakpoint before the current pc. */ + (prev_pc != stop_pc - DECR_PC_AFTER_BREAK + && CURRENTLY_STEPPING ()) +#else /* DECR_PC_AFTER_BREAK zero */ + 0 +#endif /* DECR_PC_AFTER_BREAK zero */ + ); + /* Following in case break condition called a + function. */ + stop_print_frame = 1; } - + if (stop_signal == SIGTRAP) random_signal = !(bpstat_explains_signal (stop_bpstat) || trap_expected - || stop_step_resume_break +#ifndef CALL_DUMMY_BREAKPOINT_OFFSET || PC_IN_CALL_DUMMY (stop_pc, stop_sp, stop_frame_address) - || (step_range_end && !step_resume_break_address)); +#endif /* No CALL_DUMMY_BREAKPOINT_OFFSET. */ + || (step_range_end && step_resume_breakpoint == NULL)); else { random_signal = !(bpstat_explains_signal (stop_bpstat) - || stop_step_resume_break /* End of a stack dummy. Some systems (e.g. Sony news) give another signal besides SIGTRAP, so check here as well as above. */ +#ifndef CALL_DUMMY_BREAKPOINT_OFFSET || PC_IN_CALL_DUMMY (stop_pc, stop_sp, stop_frame_address) +#endif /* No CALL_DUMMY_BREAKPOINT_OFFSET. */ ); if (!random_signal) stop_signal = SIGTRAP; @@ -967,10 +756,10 @@ wait_for_inferior () } else random_signal = 1; - + /* For the program's own signals, act according to the signal handling tables. */ - + if (random_signal) { /* Signal not for debugging purposes. */ @@ -981,16 +770,20 @@ wait_for_inferior () if (stop_signal >= NSIG || signal_print[stop_signal]) { + char *signame; printed = 1; target_terminal_ours_for_output (); #ifdef PRINT_RANDOM_SIGNAL PRINT_RANDOM_SIGNAL (stop_signal); #else - printf ("\nProgram received signal %d, %s\n", - stop_signal, - stop_signal < NSIG - ? sys_siglist[stop_signal] - : "(undocumented)"); + printf_filtered ("\nProgram received signal "); + signame = strsigno (stop_signal); + if (signame == NULL) + printf_filtered ("%d", stop_signal); + else + /* Do we need to print the number as well as the name? */ + printf_filtered ("%s (%d)", signame, stop_signal); + printf_filtered (", %s\n", safe_strsignal (stop_signal)); #endif /* PRINT_RANDOM_SIGNAL */ fflush (stdout); } @@ -1002,129 +795,117 @@ wait_for_inferior () else if (printed) target_terminal_inferior (); - /* Note that virtually all the code below does `if !random_signal'. - Perhaps this code should end with a goto or continue. At least - one (now fixed) bug was caused by this -- a !random_signal was - missing in one of the tests below. */ + /* Clear the signal if it should not be passed. */ + if (signal_program[stop_signal] == 0) + stop_signal = 0; + + /* I'm not sure whether this needs to be check_sigtramp2 or + whether it could/should be keep_going. */ + goto check_sigtramp2; } /* Handle cases caused by hitting a breakpoint. */ + { + CORE_ADDR jmp_buf_pc; + struct bpstat_what what; + + what = bpstat_what (stop_bpstat); - if (!random_signal) - if (bpstat_explains_signal (stop_bpstat)) + if (what.call_dummy) { - CORE_ADDR jmp_buf_pc; + stop_stack_dummy = 1; +#ifdef HP_OS_BUG + trap_expected_after_continue = 1; +#endif + } - switch (stop_bpstat->breakpoint_at->type) /* FIXME */ + switch (what.main_action) + { + case BPSTAT_WHAT_SET_LONGJMP_RESUME: + /* If we hit the breakpoint at longjmp, disable it for the + duration of this command. Then, install a temporary + breakpoint at the target of the jmp_buf. */ + disable_longjmp_breakpoint(); + remove_breakpoints (); + breakpoints_inserted = 0; + if (!GET_LONGJMP_TARGET(&jmp_buf_pc)) goto keep_going; + + /* Need to blow away step-resume breakpoint, as it + interferes with us */ + if (step_resume_breakpoint != NULL) { - /* If we hit the breakpoint at longjmp, disable it for the - duration of this command. Then, install a temporary - breakpoint at the target of the jmp_buf. */ - case bp_longjmp: - disable_longjmp_breakpoint(); - remove_breakpoints (); - breakpoints_inserted = 0; - if (!GET_LONGJMP_TARGET(&jmp_buf_pc)) goto keep_going; - - /* Need to blow away step-resume breakpoint, as it - interferes with us */ - remove_step_breakpoint (); - step_resume_break_address = 0; - stop_step_resume_break = 0; - -#if 0 /* FIXME - Need to implement nested temporary breakpoints */ - if (step_over_calls > 0) - set_longjmp_resume_breakpoint(jmp_buf_pc, - get_current_frame()); - else + delete_breakpoint (step_resume_breakpoint); + step_resume_breakpoint = NULL; + what.step_resume = 0; + } + +#if 0 + /* FIXME - Need to implement nested temporary breakpoints */ + if (step_over_calls > 0) + set_longjmp_resume_breakpoint(jmp_buf_pc, + get_current_frame()); + else #endif /* 0 */ - set_longjmp_resume_breakpoint(jmp_buf_pc, NULL); - handling_longjmp = 1; /* FIXME */ + set_longjmp_resume_breakpoint(jmp_buf_pc, NULL); + handling_longjmp = 1; /* FIXME */ + goto keep_going; + + case BPSTAT_WHAT_CLEAR_LONGJMP_RESUME: + case BPSTAT_WHAT_CLEAR_LONGJMP_RESUME_SINGLE: + remove_breakpoints (); + breakpoints_inserted = 0; +#if 0 + /* FIXME - Need to implement nested temporary breakpoints */ + if (step_over_calls + && (stop_frame_address + INNER_THAN step_frame_address)) + { + another_trap = 1; goto keep_going; - - case bp_longjmp_resume: - remove_breakpoints (); - breakpoints_inserted = 0; -#if 0 /* FIXME - Need to implement nested temporary breakpoints */ - if (step_over_calls - && (stop_frame_address - INNER_THAN step_frame_address)) - { - another_trap = 1; - goto keep_going; - } + } #endif /* 0 */ - disable_longjmp_breakpoint(); - handling_longjmp = 0; /* FIXME */ - break; + disable_longjmp_breakpoint(); + handling_longjmp = 0; /* FIXME */ + if (what.main_action == BPSTAT_WHAT_CLEAR_LONGJMP_RESUME) + break; + /* else fallthrough */ - default: - fprintf(stderr, "Unknown breakpoint type %d\n", - stop_bpstat->breakpoint_at->type); - case bp_watchpoint: - case bp_breakpoint: - case bp_until: - case bp_finish: - /* Does a breakpoint want us to stop? */ - if (bpstat_stop (stop_bpstat)) - { - stop_print_frame = bpstat_should_print (stop_bpstat); - goto stop_stepping; - } - /* Otherwise, must remove breakpoints and single-step - to get us past the one we hit. */ - else - { - remove_breakpoints (); - remove_step_breakpoint (); - breakpoints_inserted = 0; - another_trap = 1; - } - break; - } + case BPSTAT_WHAT_SINGLE: + if (breakpoints_inserted) + remove_breakpoints (); + breakpoints_inserted = 0; + another_trap = 1; + /* Still need to check other stuff, at least the case + where we are stepping and step out of the right range. */ + break; + + case BPSTAT_WHAT_STOP_NOISY: + stop_print_frame = 1; + /* We are about to nuke the step_resume_breakpoint via the + cleanup chain, so no need to worry about it here. */ + goto stop_stepping; + + case BPSTAT_WHAT_STOP_SILENT: + stop_print_frame = 0; + /* We are about to nuke the step_resume_breakpoint via the + cleanup chain, so no need to worry about it here. */ + goto stop_stepping; + + case BPSTAT_WHAT_KEEP_CHECKING: + break; } - else if (stop_step_resume_break) + + if (what.step_resume) { - /* But if we have hit the step-resumption breakpoint, - remove it. It has done its job getting us here. - The sp test is to make sure that we don't get hung - up in recursive calls in functions without frame - pointers. If the stack pointer isn't outside of - where the breakpoint was set (within a routine to be - stepped over), we're in the middle of a recursive - call. Not true for reg window machines (sparc) - because the must change frames to call things and - the stack pointer doesn't have to change if it - the bp was set in a routine without a frame (pc can - be stored in some other window). - - The removal of the sp test is to allow calls to - alloca. Nasty things were happening. Oh, well, - gdb can only handle one level deep of lack of - frame pointer. */ - - /* - Disable test for step_frame_address match so that we always stop even if the - frames don't match. Reason: if we hit the step_resume_breakpoint, there is - no way to temporarily disable it so that we can step past it. If we leave - the breakpoint in, then we loop forever repeatedly hitting, but never - getting past the breakpoint. This change keeps nexting over recursive - function calls from hanging gdb. - */ -#if 0 - if (* step_frame_address == 0 - || (step_frame_address == stop_frame_address)) -#endif 0 - { - remove_step_breakpoint (); - step_resume_break_address = 0; + delete_breakpoint (step_resume_breakpoint); + step_resume_breakpoint = NULL; - /* If were waiting for a trap, hitting the step_resume_break - doesn't count as getting it. */ - if (trap_expected) - another_trap = 1; - } + /* If were waiting for a trap, hitting the step_resume_break + doesn't count as getting it. */ + if (trap_expected) + another_trap = 1; } + } /* We come here if we hit a breakpoint but should not stop for it. Possibly we also were stepping @@ -1132,193 +913,262 @@ wait_for_inferior () test for stepping. But, if not stepping, do not stop. */ +#ifndef CALL_DUMMY_BREAKPOINT_OFFSET + /* This is the old way of detecting the end of the stack dummy. + An architecture which defines CALL_DUMMY_BREAKPOINT_OFFSET gets + handled above. As soon as we can test it on all of them, all + architectures should define it. */ + /* If this is the breakpoint at the end of a stack dummy, - just stop silently. */ - if (!random_signal - && PC_IN_CALL_DUMMY (stop_pc, stop_sp, stop_frame_address)) - { - stop_print_frame = 0; - stop_stack_dummy = 1; + just stop silently, unless the user was doing an si/ni, in which + case she'd better know what she's doing. */ + + if (PC_IN_CALL_DUMMY (stop_pc, stop_sp, stop_frame_address) + && !step_range_end) + { + stop_print_frame = 0; + stop_stack_dummy = 1; #ifdef HP_OS_BUG - trap_expected_after_continue = 1; + trap_expected_after_continue = 1; #endif - break; - } - - if (step_resume_break_address) + break; + } +#endif /* No CALL_DUMMY_BREAKPOINT_OFFSET. */ + + if (step_resume_breakpoint) /* Having a step-resume breakpoint overrides anything else having to do with stepping commands until that breakpoint is reached. */ - ; + /* I suspect this could/should be keep_going, because if the + check_sigtramp2 check succeeds, then it will put in another + step_resume_breakpoint, and we aren't (yet) prepared to nest + them. */ + goto check_sigtramp2; + + if (step_range_end == 0) + /* Likewise if we aren't even stepping. */ + /* I'm not sure whether this needs to be check_sigtramp2 or + whether it could/should be keep_going. */ + goto check_sigtramp2; + /* If stepping through a line, keep going if still within it. */ - else if (!random_signal - && step_range_end - && stop_pc >= step_range_start - && stop_pc < step_range_end - /* The step range might include the start of the - function, so if we are at the start of the - step range and either the stack or frame pointers - just changed, we've stepped outside */ - && !(stop_pc == step_range_start - && stop_frame_address - && (stop_sp INNER_THAN prev_sp - || stop_frame_address != step_frame_address))) + if (stop_pc >= step_range_start + && stop_pc < step_range_end + /* The step range might include the start of the + function, so if we are at the start of the + step range and either the stack or frame pointers + just changed, we've stepped outside */ + && !(stop_pc == step_range_start + && stop_frame_address + && (stop_sp INNER_THAN prev_sp + || stop_frame_address != step_frame_address))) { - ; + /* We might be doing a BPSTAT_WHAT_SINGLE and getting a signal. + So definately need to check for sigtramp here. */ + goto check_sigtramp2; } - + /* We stepped out of the stepping range. See if that was due to a subroutine call that we should proceed to the end of. */ - else if (!random_signal && step_range_end) + + /* Did we just take a signal? */ + if (IN_SIGTRAMP (stop_pc, stop_func_name) + && !IN_SIGTRAMP (prev_pc, prev_func_name)) { - if (stop_func_start) - { - prologue_pc = stop_func_start; - SKIP_PROLOGUE (prologue_pc); - } + /* This code is needed at least in the following case: + The user types "next" and then a signal arrives (before + the "next" is done). */ + /* We've just taken a signal; go until we are back to + the point where we took it and one more. */ + { + struct symtab_and_line sr_sal; + + sr_sal.pc = prev_pc; + sr_sal.symtab = NULL; + sr_sal.line = 0; + step_resume_breakpoint = + set_momentary_breakpoint (sr_sal, get_current_frame (), + bp_step_resume); + if (breakpoints_inserted) + insert_breakpoints (); + } - /* Did we just take a signal? */ - if (IN_SIGTRAMP (stop_pc, stop_func_name) - && !IN_SIGTRAMP (prev_pc, prev_func_name)) - { - /* This code is needed at least in the following case: - The user types "next" and then a signal arrives (before - the "next" is done). */ - /* We've just taken a signal; go until we are back to - the point where we took it and one more. */ - step_resume_break_address = prev_pc; - step_resume_break_duplicate = - breakpoint_here_p (step_resume_break_address); - if (breakpoints_inserted) - insert_step_breakpoint (); - /* Make sure that the stepping range gets us past - that instruction. */ - if (step_range_end == 1) - step_range_end = (step_range_start = prev_pc) + 1; - remove_breakpoints_on_following_step = 1; - goto save_pc; - } + /* If this is stepi or nexti, make sure that the stepping range + gets us past that instruction. */ + if (step_range_end == 1) + /* FIXME: Does this run afoul of the code below which, if + we step into the middle of a line, resets the stepping + range? */ + step_range_end = (step_range_start = prev_pc) + 1; - /* ==> See comments at top of file on this algorithm. <==*/ - - if (stop_pc == stop_func_start - && (stop_func_start != prev_func_start - || prologue_pc != stop_func_start - || stop_sp != prev_sp)) - { - /* It's a subroutine call. - (0) If we are not stepping over any calls ("stepi"), we - just stop. - (1) If we're doing a "next", we want to continue through - the call ("step over the call"). - (2) If we are in a function-call trampoline (a stub between - the calling routine and the real function), locate - the real function and change stop_func_start. - (3) If we're doing a "step", and there are no debug symbols - at the target of the call, we want to continue through - it ("step over the call"). - (4) Otherwise, we want to stop soon, after the function - prologue ("step into the call"). */ - - if (step_over_calls == 0) - { - /* I presume that step_over_calls is only 0 when we're - supposed to be stepping at the assembly language level. */ - stop_step = 1; - break; - } + remove_breakpoints_on_following_step = 1; + goto keep_going; + } + + if (stop_func_start) + { + /* Do this after the IN_SIGTRAMP check; it might give + an error. */ + prologue_pc = stop_func_start; + SKIP_PROLOGUE (prologue_pc); + } + + /* ==> See comments at top of file on this algorithm. <==*/ + + if ((stop_pc == stop_func_start + || IN_SOLIB_TRAMPOLINE (stop_pc, stop_func_name)) + && (stop_func_start != prev_func_start + || prologue_pc != stop_func_start + || stop_sp != prev_sp)) + { + /* It's a subroutine call. */ - if (step_over_calls > 0) - goto step_over_function; + if (step_over_calls == 0) + { + /* I presume that step_over_calls is only 0 when we're + supposed to be stepping at the assembly language level + ("stepi"). Just stop. */ + stop_step = 1; + break; + } - tmp = SKIP_TRAMPOLINE_CODE (stop_pc); - if (tmp != NULL) - stop_func_start = tmp; + if (step_over_calls > 0) + /* We're doing a "next". */ + goto step_over_function; + + /* If we are in a function call trampoline (a stub between + the calling routine and the real function), locate the real + function. That's what tells us (a) whether we want to step + into it at all, and (b) what prologue we want to run to + the end of, if we do step into it. */ + tmp = SKIP_TRAMPOLINE_CODE (stop_pc); + if (tmp != 0) + stop_func_start = tmp; + + /* If we have line number information for the function we + are thinking of stepping into, step into it. + + If there are several symtabs at that PC (e.g. with include + files), just want to know whether *any* of them have line + numbers. find_pc_line handles this. */ + { + struct symtab_and_line tmp_sal; - if (find_pc_function (stop_func_start) != 0) - goto step_into_function; + tmp_sal = find_pc_line (stop_func_start, 0); + if (tmp_sal.line != 0) + goto step_into_function; + } step_over_function: - /* A subroutine call has happened. */ - /* Set a special breakpoint after the return */ - step_resume_break_address = - ADDR_BITS_REMOVE - (SAVED_PC_AFTER_CALL (get_current_frame ())); - step_resume_break_duplicate - = breakpoint_here_p (step_resume_break_address); - if (breakpoints_inserted) - insert_step_breakpoint (); - goto save_pc; + /* A subroutine call has happened. */ + { + /* Set a special breakpoint after the return */ + struct symtab_and_line sr_sal; + sr_sal.pc = + ADDR_BITS_REMOVE + (SAVED_PC_AFTER_CALL (get_current_frame ())); + sr_sal.symtab = NULL; + sr_sal.line = 0; + step_resume_breakpoint = + set_momentary_breakpoint (sr_sal, get_current_frame (), + bp_step_resume); + if (breakpoints_inserted) + insert_breakpoints (); + } + goto keep_going; step_into_function: - /* Subroutine call with source code we should not step over. - Do step to the first line of code in it. */ - SKIP_PROLOGUE (stop_func_start); - sal = find_pc_line (stop_func_start, 0); - /* Use the step_resume_break to step until - the end of the prologue, even if that involves jumps - (as it seems to on the vax under 4.2). */ - /* If the prologue ends in the middle of a source line, - continue to the end of that source line. - Otherwise, just go to end of prologue. */ + /* Subroutine call with source code we should not step over. + Do step to the first line of code in it. */ + SKIP_PROLOGUE (stop_func_start); + sal = find_pc_line (stop_func_start, 0); + /* Use the step_resume_break to step until + the end of the prologue, even if that involves jumps + (as it seems to on the vax under 4.2). */ + /* If the prologue ends in the middle of a source line, + continue to the end of that source line. + Otherwise, just go to end of prologue. */ #ifdef PROLOGUE_FIRSTLINE_OVERLAP - /* no, don't either. It skips any code that's - legitimately on the first line. */ + /* no, don't either. It skips any code that's + legitimately on the first line. */ #else - if (sal.end && sal.pc != stop_func_start) - stop_func_start = sal.end; + if (sal.end && sal.pc != stop_func_start) + stop_func_start = sal.end; #endif - if (stop_func_start == stop_pc) - { - /* We are already there: stop now. */ - stop_step = 1; - break; - } - else - /* Put the step-breakpoint there and go until there. */ - { - step_resume_break_address = stop_func_start; - - step_resume_break_duplicate - = breakpoint_here_p (step_resume_break_address); - if (breakpoints_inserted) - insert_step_breakpoint (); - /* Do not specify what the fp should be when we stop - since on some machines the prologue - is where the new fp value is established. */ - step_frame_address = 0; - /* And make sure stepping stops right away then. */ - step_range_end = step_range_start; - } - goto save_pc; + if (stop_func_start == stop_pc) + { + /* We are already there: stop now. */ + stop_step = 1; + break; } + else + /* Put the step-breakpoint there and go until there. */ + { + struct symtab_and_line sr_sal; + + sr_sal.pc = stop_func_start; + sr_sal.symtab = NULL; + sr_sal.line = 0; + /* Do not specify what the fp should be when we stop + since on some machines the prologue + is where the new fp value is established. */ + step_resume_breakpoint = + set_momentary_breakpoint (sr_sal, NULL, bp_step_resume); + if (breakpoints_inserted) + insert_breakpoints (); - /* We've wandered out of the step range (but haven't done a - subroutine call or return). */ + /* And make sure stepping stops right away then. */ + step_range_end = step_range_start; + } + goto keep_going; + } - sal = find_pc_line(stop_pc, 0); - - if (step_range_end == 1 || /* stepi or nexti */ - sal.line == 0 || /* ...or no line # info */ - (stop_pc == sal.pc /* ...or we're at the start */ - && current_line != sal.line)) { /* of a different line */ - /* Stop because we're done stepping. */ - stop_step = 1; - break; - } else { - /* We aren't done stepping, and we have line number info for $pc. - Optimize by setting the step_range for the line. - (We might not be in the original line, but if we entered a - new line in mid-statement, we continue stepping. This makes - things like for(;;) statements work better.) */ - step_range_start = sal.pc; - step_range_end = sal.end; - goto save_pc; - } - abort(); /* We never fall through here */ + /* We've wandered out of the step range (but haven't done a + subroutine call or return). (Is that true? I think we get + here if we did a return and maybe a longjmp). */ + + sal = find_pc_line(stop_pc, 0); + + if (step_range_end == 1) + { + /* It is stepi or nexti. We always want to stop stepping after + one instruction. */ + stop_step = 1; + break; + } + + if (sal.line == 0) + { + /* We have no line number information. That means to stop + stepping (does this always happen right after one instruction, + when we do "s" in a function with no line numbers, + or can this happen as a result of a return or longjmp?). */ + stop_step = 1; + break; + } + + if (stop_pc == sal.pc && current_line != sal.line) + { + /* We are at the start of a different line. So stop. Note that + we don't stop if we step into the middle of a different line. + That is said to make things like for (;;) statements work + better. */ + stop_step = 1; + break; } + /* We aren't done stepping. + + Optimize by setting the stepping range to the line. + (We might not be in the original line, but if we entered a + new line in mid-statement, we continue stepping. This makes + things like for(;;) statements work better.) */ + step_range_start = sal.pc; + step_range_end = sal.end; + goto keep_going; + + check_sigtramp2: if (trap_expected && IN_SIGTRAMP (stop_pc, stop_func_name) && !IN_SIGTRAMP (prev_pc, prev_func_name)) @@ -1328,27 +1178,31 @@ step_into_function: us stop), thus stepping into sigtramp. So we need to set a step_resume_break_address breakpoint - and continue until we hit it, and then step. */ - step_resume_break_address = prev_pc; - /* Always 1, I think, but it's probably easier to have - the step_resume_break as usual rather than trying to - re-use the breakpoint which is already there. */ - step_resume_break_duplicate = - breakpoint_here_p (step_resume_break_address); + and continue until we hit it, and then step. FIXME: This should + be more enduring than a step_resume breakpoint; we should know + that we will later need to keep going rather than re-hitting + the breakpoint here (see testsuite/gdb.t06/signals.exp where + it says "exceedingly difficult"). */ + struct symtab_and_line sr_sal; + + sr_sal.pc = prev_pc; + sr_sal.symtab = NULL; + sr_sal.line = 0; + step_resume_breakpoint = + set_momentary_breakpoint (sr_sal, get_current_frame (), + bp_step_resume); if (breakpoints_inserted) - insert_step_breakpoint (); + insert_breakpoints (); + remove_breakpoints_on_following_step = 1; another_trap = 1; } -/* My apologies to the gods of structured programming. */ -/* Come to this label when you need to resume the inferior. It's really much - cleaner at this time to do a goto than to try and figure out what the - if-else chain ought to look like!! */ - keep_going: + /* Come to this label when you need to resume the inferior. + It's really much cleaner to do a goto than a maze of if-else + conditions. */ -save_pc: /* Save the pc before execution, to compare with pc after stop. */ prev_pc = read_pc (); /* Might have been DECR_AFTER_BREAK */ prev_func_start = stop_func_start; /* Ok, since if DECR_PC_AFTER @@ -1367,10 +1221,7 @@ save_pc: /* We took a signal (which we are supposed to pass through to the inferior, else we'd have done a break above) and we haven't yet gotten our trap. Simply continue. */ - resume ((step_range_end && !step_resume_break_address) - || (trap_expected && !step_resume_break_address) - || bpstat_should_step (), - stop_signal); + resume (CURRENTLY_STEPPING (), stop_signal); } else { @@ -1387,7 +1238,7 @@ save_pc: to one-proceed past a breakpoint. */ /* If we've just finished a special step resume and we don't want to hit a breakpoint, pull em out. */ - if (!step_resume_break_address && + if (step_resume_breakpoint == NULL && remove_breakpoints_on_following_step) { remove_breakpoints_on_following_step = 0; @@ -1395,9 +1246,8 @@ save_pc: breakpoints_inserted = 0; } else if (!breakpoints_inserted && - (step_resume_break_address != 0 || !another_trap)) + (step_resume_breakpoint != NULL || !another_trap)) { - insert_step_breakpoint (); breakpoints_failed = insert_breakpoints (); if (breakpoints_failed) break; @@ -1413,27 +1263,16 @@ save_pc: /* I'm not sure when this following segment applies. I do know, now, that we shouldn't rewrite the regs when we were stopped by a random signal from the inferior process. */ + /* FIXME: Shouldn't this be based on the valid bit of the SXIP? + (this is only used on the 88k). */ if (!bpstat_explains_signal (stop_bpstat) && (stop_signal != SIGCLD) && !stopped_by_random_signal) - { - CORE_ADDR pc_contents = read_register (PC_REGNUM); - CORE_ADDR npc_contents = read_register (NPC_REGNUM); - if (pc_contents != npc_contents) - { - write_register (NNPC_REGNUM, npc_contents); - write_register (NPC_REGNUM, pc_contents); - } - } + SHIFT_INST_REGS(); #endif /* SHIFT_INST_REGS */ - resume ((!step_resume_break_address - && !handling_longjmp - && (step_range_end - || trap_expected)) - || bpstat_should_step (), - stop_signal); + resume (CURRENTLY_STEPPING (), stop_signal); } } @@ -1448,6 +1287,7 @@ save_pc: prev_func_name = stop_func_name; prev_sp = stop_sp; } + do_cleanups (old_cleanups); } /* Here to return control to GDB when the inferior stops for real. @@ -1471,18 +1311,15 @@ normal_stop () { target_terminal_ours_for_output (); print_sys_errmsg ("ptrace", breakpoints_failed); - printf ("Stopped; cannot insert breakpoints.\n\ + printf_filtered ("Stopped; cannot insert breakpoints.\n\ The same program may be running in another process.\n"); } - if (target_has_execution) - remove_step_breakpoint (); - if (target_has_execution && breakpoints_inserted) if (remove_breakpoints ()) { target_terminal_ours_for_output (); - printf ("Cannot remove breakpoints because program is no longer writable.\n\ + printf_filtered ("Cannot remove breakpoints because program is no longer writable.\n\ It might be running in another process.\n\ Further execution is probably impossible.\n"); } @@ -1505,6 +1342,14 @@ Further execution is probably impossible.\n"); target_terminal_ours (); + /* Look up the hook_stop and run it if it exists. */ + + if (stop_command->hook) + { + catch_errors (hook_stop_stub, (char *)stop_command->hook, + "Error while running hook_stop:\n", RETURN_MASK_ALL); + } + if (!target_has_stack) return; @@ -1547,23 +1392,33 @@ Further execution is probably impossible.\n"); select_frame (get_current_frame (), 0); } } + +static int +hook_stop_stub (cmd) + char *cmd; +{ + execute_user_command ((struct cmd_list_element *)cmd, 0); + return (0); +} -static void -insert_step_breakpoint () +int signal_stop_state (signo) + int signo; { - if (step_resume_break_address && !step_resume_break_duplicate) - target_insert_breakpoint (step_resume_break_address, - step_resume_break_shadow); + return ((signo >= 0 && signo < NSIG) ? signal_stop[signo] : 0); } -static void -remove_step_breakpoint () +int signal_print_state (signo) + int signo; { - if (step_resume_break_address && !step_resume_break_duplicate) - target_remove_breakpoint (step_resume_break_address, - step_resume_break_shadow); + return ((signo >= 0 && signo < NSIG) ? signal_print[signo] : 0); } - + +int signal_pass_state (signo) + int signo; +{ + return ((signo >= 0 && signo < NSIG) ? signal_program[signo] : 0); +} + static void sig_print_header () { @@ -1574,15 +1429,16 @@ static void sig_print_info (number) int number; { - char *abbrev = sig_abbrev(number); - if (abbrev == NULL) + char *name; + + if ((name = strsigno (number)) == NULL) printf_filtered ("%d\t\t", number); else - printf_filtered ("SIG%s (%d)\t", abbrev, number); + printf_filtered ("%s (%d)\t", name, number); printf_filtered ("%s\t", signal_stop[number] ? "Yes" : "No"); printf_filtered ("%s\t", signal_print[number] ? "Yes" : "No"); printf_filtered ("%s\t\t", signal_program[number] ? "Yes" : "No"); - printf_filtered ("%s\n", sys_siglist[number]); + printf_filtered ("%s\n", safe_strsignal (number)); } /* Specify how various signals in the inferior should be handled. */ @@ -1592,108 +1448,176 @@ handle_command (args, from_tty) char *args; int from_tty; { - register char *p = args; - int signum = 0; - register int digits, wordlen; - char *nextarg; + char **argv; + int digits, wordlen; + int sigfirst, signum, siglast; + int allsigs; + int nsigs; + unsigned char *sigs; + struct cleanup *old_chain; + + if (args == NULL) + { + error_no_arg ("signal to handle"); + } + + /* Allocate and zero an array of flags for which signals to handle. */ + + nsigs = signo_max () + 1; + sigs = (unsigned char *) alloca (nsigs); + memset (sigs, 0, nsigs); - if (!args) - error_no_arg ("signal to handle"); + /* Break the command line up into args. */ - while (*p) + argv = buildargv (args); + if (argv == NULL) { - /* Find the end of the next word in the args. */ - for (wordlen = 0; - p[wordlen] && p[wordlen] != ' ' && p[wordlen] != '\t'; - wordlen++); - /* Set nextarg to the start of the word after the one we just - found, and null-terminate this one. */ - if (p[wordlen] == '\0') - nextarg = p + wordlen; - else - { - p[wordlen] = '\0'; - nextarg = p + wordlen + 1; - } - + nomem (0); + } + old_chain = make_cleanup (freeargv, (char *) argv); - for (digits = 0; p[digits] >= '0' && p[digits] <= '9'; digits++); + /* Walk through the args, looking for signal numbers, signal names, and + actions. Signal numbers and signal names may be interspersed with + actions, with the actions being performed for all signals cumulatively + specified. Signal ranges can be specified as -. */ + + while (*argv != NULL) + { + wordlen = strlen (*argv); + for (digits = 0; isdigit ((*argv)[digits]); digits++) {;} + allsigs = 0; + sigfirst = siglast = -1; - if (signum == 0) + if (wordlen >= 1 && !strncmp (*argv, "all", wordlen)) { - /* It is the first argument--must be the signal to operate on. */ - if (digits == wordlen) + /* Apply action to all signals except those used by the + debugger. Silently skip those. */ + allsigs = 1; + sigfirst = 0; + siglast = nsigs - 1; + } + else if (wordlen >= 1 && !strncmp (*argv, "stop", wordlen)) + { + SET_SIGS (nsigs, sigs, signal_stop); + SET_SIGS (nsigs, sigs, signal_print); + } + else if (wordlen >= 1 && !strncmp (*argv, "ignore", wordlen)) + { + UNSET_SIGS (nsigs, sigs, signal_program); + } + else if (wordlen >= 2 && !strncmp (*argv, "print", wordlen)) + { + SET_SIGS (nsigs, sigs, signal_print); + } + else if (wordlen >= 2 && !strncmp (*argv, "pass", wordlen)) + { + SET_SIGS (nsigs, sigs, signal_program); + } + else if (wordlen >= 3 && !strncmp (*argv, "nostop", wordlen)) + { + UNSET_SIGS (nsigs, sigs, signal_stop); + } + else if (wordlen >= 3 && !strncmp (*argv, "noignore", wordlen)) + { + SET_SIGS (nsigs, sigs, signal_program); + } + else if (wordlen >= 4 && !strncmp (*argv, "noprint", wordlen)) + { + UNSET_SIGS (nsigs, sigs, signal_print); + UNSET_SIGS (nsigs, sigs, signal_stop); + } + else if (wordlen >= 4 && !strncmp (*argv, "nopass", wordlen)) + { + UNSET_SIGS (nsigs, sigs, signal_program); + } + else if (digits > 0) + { + sigfirst = siglast = atoi (*argv); + if ((*argv)[digits] == '-') { - /* Numeric. */ - signum = atoi (p); - if (signum <= 0 || signum >= NSIG) - { - p[wordlen] = '\0'; - error ("Invalid signal %s given as argument to \"handle\".", p); - } + siglast = atoi ((*argv) + digits + 1); } - else + if (sigfirst > siglast) { - /* Symbolic. */ - signum = sig_number (p); - if (signum == -1) - error ("No such signal \"%s\"", p); + /* Bet he didn't figure we'd think of this case... */ + signum = sigfirst; + sigfirst = siglast; + siglast = signum; } - - if (signum == SIGTRAP || signum == SIGINT) + if (sigfirst < 0 || sigfirst >= nsigs) + { + error ("Signal %d not in range 0-%d", sigfirst, nsigs - 1); + } + if (siglast < 0 || siglast >= nsigs) { - if (!query ("SIG%s is used by the debugger.\nAre you sure you want to change it? ", sig_abbrev (signum))) - error ("Not confirmed."); + error ("Signal %d not in range 0-%d", siglast, nsigs - 1); } } - /* Else, if already got a signal number, look for flag words - saying what to do for it. */ - else if (!strncmp (p, "stop", wordlen)) + else if ((signum = strtosigno (*argv)) != 0) { - signal_stop[signum] = 1; - signal_print[signum] = 1; + sigfirst = siglast = signum; } - else if (wordlen >= 2 && !strncmp (p, "print", wordlen)) - signal_print[signum] = 1; - else if (wordlen >= 2 && !strncmp (p, "pass", wordlen)) - signal_program[signum] = 1; - else if (!strncmp (p, "ignore", wordlen)) - signal_program[signum] = 0; - else if (wordlen >= 3 && !strncmp (p, "nostop", wordlen)) - signal_stop[signum] = 0; - else if (wordlen >= 4 && !strncmp (p, "noprint", wordlen)) + else { - signal_print[signum] = 0; - signal_stop[signum] = 0; + /* Not a number and not a recognized flag word => complain. */ + error ("Unrecognized or ambiguous flag word: \"%s\".", *argv); } - else if (wordlen >= 4 && !strncmp (p, "nopass", wordlen)) - signal_program[signum] = 0; - else if (wordlen >= 3 && !strncmp (p, "noignore", wordlen)) - signal_program[signum] = 1; - /* Not a number and not a recognized flag word => complain. */ - else + + /* If any signal numbers or symbol names were found, set flags for + which signals to apply actions to. */ + + for (signum = sigfirst; signum >= 0 && signum <= siglast; signum++) { - error ("Unrecognized flag word: \"%s\".", p); + switch (signum) + { + case SIGTRAP: + case SIGINT: + if (!allsigs && !sigs[signum]) + { + if (query ("%s is used by the debugger.\nAre you sure you want to change it? ", strsigno (signum))) + { + sigs[signum] = 1; + } + else + { + printf ("Not confirmed, unchanged.\n"); + fflush (stdout); + } + } + break; + default: + sigs[signum] = 1; + break; + } } - /* Find start of next word. */ - p = nextarg; - while (*p == ' ' || *p == '\t') p++; + argv++; } + target_notice_signals(); + if (from_tty) { /* Show the results. */ sig_print_header (); - sig_print_info (signum); + for (signum = 0; signum < nsigs; signum++) + { + if (sigs[signum]) + { + sig_print_info (signum); + } + } } + + do_cleanups (old_chain); } /* Print current contents of the tables set by the handle command. */ static void -signals_info (signum_exp) +signals_info (signum_exp, from_tty) char *signum_exp; + int from_tty; { register int i; sig_print_header (); @@ -1701,8 +1625,8 @@ signals_info (signum_exp) if (signum_exp) { /* First see if this is a symbol name. */ - i = sig_number (signum_exp); - if (i == -1) + i = strtosigno (signum_exp); + if (i == 0) { /* Nope, maybe it's an address which evaluates to a signal number. */ @@ -1734,7 +1658,6 @@ save_inferior_status (inf_status, restore_stack_info) struct inferior_status *inf_status; int restore_stack_info; { - inf_status->pc_changed = pc_changed; inf_status->stop_signal = stop_signal; inf_status->stop_pc = stop_pc; inf_status->stop_frame_address = stop_frame_address; @@ -1746,7 +1669,6 @@ save_inferior_status (inf_status, restore_stack_info) inf_status->step_range_end = step_range_end; inf_status->step_frame_address = step_frame_address; inf_status->step_over_calls = step_over_calls; - inf_status->step_resume_break_address = step_resume_break_address; inf_status->stop_after_trap = stop_after_trap; inf_status->stop_soon_quietly = stop_soon_quietly; /* Save original bpstat chain here; replace it with copy of chain. @@ -1758,21 +1680,54 @@ save_inferior_status (inf_status, restore_stack_info) inf_status->restore_stack_info = restore_stack_info; inf_status->proceed_to_finish = proceed_to_finish; - bcopy (stop_registers, inf_status->stop_registers, REGISTER_BYTES); - + memcpy (inf_status->stop_registers, stop_registers, REGISTER_BYTES); + + read_register_bytes (0, inf_status->registers, REGISTER_BYTES); + record_selected_frame (&(inf_status->selected_frame_address), &(inf_status->selected_level)); return; } +struct restore_selected_frame_args { + FRAME_ADDR frame_address; + int level; +}; + +static int restore_selected_frame PARAMS ((char *)); + +/* Restore the selected frame. args is really a struct + restore_selected_frame_args * (declared as char * for catch_errors) + telling us what frame to restore. Returns 1 for success, or 0 for + failure. An error message will have been printed on error. */ +static int +restore_selected_frame (args) + char *args; +{ + struct restore_selected_frame_args *fr = + (struct restore_selected_frame_args *) args; + FRAME fid; + int level = fr->level; + + fid = find_relative_frame (get_current_frame (), &level); + + /* If inf_status->selected_frame_address is NULL, there was no + previously selected frame. */ + if (fid == 0 || + FRAME_FP (fid) != fr->frame_address || + level != 0) + { + warning ("Unable to restore previously selected frame.\n"); + return 0; + } + select_frame (fid, fr->level); + return(1); +} + void restore_inferior_status (inf_status) struct inferior_status *inf_status; { - FRAME fid; - int level = inf_status->selected_level; - - pc_changed = inf_status->pc_changed; stop_signal = inf_status->stop_signal; stop_pc = inf_status->stop_pc; stop_frame_address = inf_status->stop_frame_address; @@ -1784,7 +1739,6 @@ restore_inferior_status (inf_status) step_range_end = inf_status->step_range_end; step_frame_address = inf_status->step_frame_address; step_over_calls = inf_status->step_over_calls; - step_resume_break_address = inf_status->step_resume_break_address; stop_after_trap = inf_status->stop_after_trap; stop_soon_quietly = inf_status->stop_soon_quietly; bpstat_clear (&stop_bpstat); @@ -1792,36 +1746,37 @@ restore_inferior_status (inf_status) breakpoint_proceeded = inf_status->breakpoint_proceeded; proceed_to_finish = inf_status->proceed_to_finish; - bcopy (inf_status->stop_registers, stop_registers, REGISTER_BYTES); + memcpy (stop_registers, inf_status->stop_registers, REGISTER_BYTES); /* The inferior can be gone if the user types "print exit(0)" (and perhaps other times). */ + if (target_has_execution) + write_register_bytes (0, inf_status->registers, REGISTER_BYTES); + + /* The inferior can be gone if the user types "print exit(0)" + (and perhaps other times). */ + + /* FIXME: If we are being called after stopping in a function which + is called from gdb, we should not be trying to restore the + selected frame; it just prints a spurious error message (The + message is useful, however, in detecting bugs in gdb (like if gdb + clobbers the stack)). In fact, should we be restoring the + inferior status at all in that case? . */ + if (target_has_stack && inf_status->restore_stack_info) { - fid = find_relative_frame (get_current_frame (), - &level); - - /* If inf_status->selected_frame_address is NULL, there was no - previously selected frame. */ - if (fid == 0 || - FRAME_FP (fid) != inf_status->selected_frame_address || - level != 0) - { -#if 1 - /* I'm not sure this error message is a good idea. I have - only seen it occur after "Can't continue previously - requested operation" (we get called from do_cleanups), in - which case it just adds insult to injury (one confusing - error message after another. Besides which, does the - user really care if we can't restore the previously - selected frame? */ - fprintf (stderr, "Unable to restore previously selected frame.\n"); -#endif - select_frame (get_current_frame (), 0); - return; - } - - select_frame (fid, inf_status->selected_level); + struct restore_selected_frame_args fr; + fr.level = inf_status->selected_level; + fr.frame_address = inf_status->selected_frame_address; + /* The point of catch_errors is that if the stack is clobbered, + walking the stack might encounter a garbage pointer and error() + trying to dereference it. */ + if (catch_errors (restore_selected_frame, &fr, + "Unable to restore previously selected frame:\n", + RETURN_MASK_ERROR) == 0) + /* Error in restoring the selected frame. Select the innermost + frame. */ + select_frame (get_current_frame (), 0); } } @@ -1830,22 +1785,41 @@ void _initialize_infrun () { register int i; + register int numsigs; add_info ("signals", signals_info, "What debugger does when program gets various signals.\n\ Specify a signal number as argument to print info on that signal only."); + add_info_alias ("handle", "signals", 0); add_com ("handle", class_run, handle_command, "Specify how to handle a signal.\n\ -Args are signal number followed by flags.\n\ -Flags allowed are \"stop\", \"print\", \"pass\",\n\ - \"nostop\", \"noprint\" or \"nopass\".\n\ -Print means print a message if this signal happens.\n\ +Args are signal numbers and actions to apply to those signals.\n\ +Signal numbers may be numeric (ex. 11) or symbolic (ex. SIGSEGV).\n\ +Numeric ranges may be specified with the form LOW-HIGH (ex. 14-21).\n\ +The special arg \"all\" is recognized to mean all signals except those\n\ +used by the debugger, typically SIGTRAP and SIGINT.\n\ +Recognized actions include \"stop\", \"nostop\", \"print\", \"noprint\",\n\ +\"pass\", \"nopass\", \"ignore\", or \"noignore\".\n\ Stop means reenter debugger if this signal happens (implies print).\n\ +Print means print a message if this signal happens.\n\ Pass means let program see this signal; otherwise program doesn't know.\n\ +Ignore is a synonym for nopass and noignore is a synonym for pass.\n\ Pass and Stop may be combined."); - for (i = 0; i < NSIG; i++) + stop_command = add_cmd ("stop", class_obscure, not_just_help_class_command, + "There is no `stop' command, but you can set a hook on `stop'.\n\ +This allows you to set a list of commands to be run each time execution\n\ +of the program stops.", &cmdlist); + + numsigs = signo_max () + 1; + signal_stop = (unsigned char *) + xmalloc (sizeof (signal_stop[0]) * numsigs); + signal_print = (unsigned char *) + xmalloc (sizeof (signal_print[0]) * numsigs); + signal_program = (unsigned char *) + xmalloc (sizeof (signal_program[0]) * numsigs); + for (i = 0; i < numsigs; i++) { signal_stop[i] = 1; signal_print[i] = 1;