diff options
Diffstat (limited to 'gdb/infrun.c')
| -rw-r--r-- | gdb/infrun.c | 984 |
1 files changed, 592 insertions, 392 deletions
diff --git a/gdb/infrun.c b/gdb/infrun.c index 67b0c17..d08a1bf 100644 --- a/gdb/infrun.c +++ b/gdb/infrun.c @@ -18,8 +18,106 @@ In other words, go ahead and share GDB, but don't try to stop anyone else from sharing it farther. Help stamp out software hoarding! */ +/* Notes on the algorithm used in wait_for_inferior to determine if we + just did a subroutine call when stepping. We have the following + information at that point: + + Current and previous (just before this step) pc. + Current and previous sp. + Current and previous start of current function. + + If the start's of the functions don't match, then + + a) We did a subroutine call. + + In this case, the pc will be at the beginning of a function. + + b) We did a subroutine return. + + Otherwise. + + c) We did a longjmp. + + If we did a longjump, we were doing "nexti", since a next would + have attempted to skip over the assembly language routine in which + the longjmp is coded and would have simply been the equivalent of a + continue. I consider this ok behaivior. We'd like one of two + things to happen if we are doing a nexti through the longjmp() + routine: 1) It behaves as a stepi, or 2) It acts like a continue as + above. Given that this is a special case, and that anybody who + thinks that the concept of sub calls is meaningful in the context + of a longjmp, I'll take either one. Let's see what happens. + + Acts like a subroutine return. I can handle that with no problem + at all. + + -->So: If the current and previous beginnings of the current + function don't match, *and* the pc is at the start of a function, + we've done a subroutine call. If the pc is not at the start of a + function, we *didn't* do a subroutine call. + + -->If the beginnings of the current and previous function do match, + either: + + a) We just did a recursive call. + + In this case, we would be at the very beginning of a + function and 1) it will have a prologue (don't jump to + before prologue, or 2) (we assume here that it doesn't have + a prologue) there will have been a change in the stack + pointer over the last instruction. (Ie. it's got to put + the saved pc somewhere. The stack is the usual place. In + a recursive call a register is only an option if there's a + prologue to do something with it. This is even true on + register window machines; the prologue sets up the new + window. It might not be true on a register window machine + where the call instruction moved the register window + itself. Hmmm. One would hope that the stack pointer would + also change. If it doesn't, somebody send me a note, and + I'll work out a more general theory. + randy@wheaties.ai.mit.edu). This is true (albeit slipperly + so) on all machines I'm aware of: + + m68k: Call changes stack pointer. Regular jumps don't. + + sparc: Recursive calls must have frames and therefor, + prologues. + + vax: All calls have frames and hence change the + stack pointer. + + b) We did a return from a recursive call. I don't see that we + have either the ability or the need to distinguish this + from an ordinary jump. The stack frame will be printed + when and if the frame pointer changes; if we are in a + function without a frame pointer, it's the users own + lookout. + + c) We did a jump within a function. We assume that this is + true if we didn't do a recursive call. + + d) We are in no-man's land ("I see no symbols here"). We + don't worry about this; it will make calls look like simple + jumps (and the stack frames will be printed when the frame + pointer moves), which is a reasonably non-violent response. + +#if 0 + We skip this; it causes more problems than it's worth. +#ifdef SUN4_COMPILER_FEATURE + We do a special ifdef for the sun 4, forcing it to single step + into calls which don't have prologues. This means that we can't + nexti over leaf nodes, we can probably next over them (since they + won't have debugging symbols, usually), and we can next out of + functions returning structures (with a "call .stret4" at the end). +#endif +#endif +*/ + + + + + #include "defs.h" -#include "initialize.h" #include "param.h" #include "symtab.h" #include "frame.h" @@ -28,12 +126,23 @@ anyone else from sharing it farther. Help stamp out software hoarding! #include <stdio.h> #include <signal.h> -#include <a.out.h> + +/* unistd.h is needed to #define X_OK */ +#ifdef USG +#include <unistd.h> +#else +#include <sys/file.h> +#endif + +/* The idiots at Apple only define X_OK if POSIX is defined. Fuck 'em. */ +#ifndef X_OK +#define X_OK 1 /* Execute permission for access() */ +#endif #ifdef UMAX_PTRACE #include <sys/param.h> #include <sys/ptrace.h> -#endif UMAX_PTRACE +#endif /* UMAX_PTRACE */ extern char *sys_siglist[]; extern int errno; @@ -56,7 +165,7 @@ static struct symbol *step_start_function; static char break_insn[] = BREAKPOINT; -/* Nonzero => address for special breakpoint for resuming stepping. */ +/* Nonzero => address for special breakpoint for resuming stepping. */ static CORE_ADDR step_resume_break_address; @@ -85,11 +194,11 @@ static int trap_expected_after_continue; /* Nonzero means expecting a trace trap and should stop the inferior and return silently when it happens. */ -static int stop_after_trap; +int stop_after_trap; /* Nonzero means expecting a trace trap due to attaching to a process. */ -static int stop_after_attach; +int stop_after_attach; /* Nonzero if pc has been changed by the debugger since the inferior stopped. */ @@ -117,11 +226,8 @@ static int running_in_shell; static int stop_print_frame; #ifdef NO_SINGLE_STEP -/* Non-zero if we just simulated a single-step ptrace call. This is - needed because we cannot remove the breakpoints in the inferior - process until after the `wait' in `wait_for_inferior'. - Used for sun4. */ -int one_stepped; +extern int one_stepped; /* From machine dependent code */ +extern void single_step (); /* Same. */ #endif /* NO_SINGLE_STEP */ static void insert_step_breakpoint (); @@ -129,7 +235,6 @@ static void remove_step_breakpoint (); static void wait_for_inferior (); static void normal_stop (); -START_FILE /* Clear out all variables saying what to do when inferior is continued. First do this, then set the ones you want, then call `proceed'. */ @@ -140,7 +245,7 @@ clear_proceed_status () trap_expected = 0; step_range_start = 0; step_range_end = 0; - step_frame = 0; + step_frame_address = 0; step_over_calls = -1; step_resume_break_address = 0; stop_after_trap = 0; @@ -188,7 +293,7 @@ proceed (addr, signal, step) { write_register (PC_REGNUM, addr); #ifdef NPC_REGNUM - write_register (NPC_REGNUM, addr+4); + write_register (NPC_REGNUM, addr + 4); #endif } @@ -241,6 +346,7 @@ The same program may be running in another process."); /* Writing the inferior pc as a register calls this function to inform infrun that the pc has been set in the debugger. */ +void writing_pc (val) CORE_ADDR val; { @@ -253,12 +359,19 @@ writing_pc (val) but it will have stopped one instruction after execing sh. Here we must get it up to actual execution of the real program. */ +void start_inferior () { /* 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 + trap_expected = START_INFERIOR_TRAPS_EXPECTED; +#else trap_expected = 2; +#endif + running_in_shell = 0; /* Set to 1 at first SIGTRAP, 0 at second. */ trap_expected_after_continue = 0; breakpoints_inserted = 0; @@ -275,8 +388,9 @@ start_inferior () { trap_expected = 0; fetch_inferior_registers(); - set_current_frame (read_register(FP_REGNUM)); - stop_frame = get_current_frame(); + set_current_frame (create_new_frame (read_register (FP_REGNUM), + read_pc ())); + stop_frame_address = FRAME_FP (get_current_frame()); inferior_pid = 3; if (insert_breakpoints()) fatal("Can't insert breakpoints"); @@ -342,18 +456,28 @@ wait_for_inferior () int tem; int another_trap; int random_signal; - CORE_ADDR stop_sp; + CORE_ADDR stop_sp, prev_sp; + CORE_ADDR prev_func_start, stop_func_start; + CORE_ADDR prologue_pc; int stop_step_resume_break; + CORE_ADDR step_resume_break_sp; int newmisc; int newfun_pc; struct symbol *newfun; struct symtab_and_line sal; int prev_pc; + extern CORE_ADDR text_end; prev_pc = read_pc (); + prev_func_start = get_pc_function_start (prev_pc) + FUNCTION_START_OFFSET; + prev_sp = read_register (SP_REGNUM); while (1) { + /* Clean up saved state that will become invalid */ + pc_changed = 0; + flush_cached_frames (); + if (remote_debugging) remote_wait (&w); else @@ -363,36 +487,7 @@ wait_for_inferior () continue; } -#ifdef NO_SINGLE_STEP - if (one_stepped) - { - single_step (0); - } -#endif /* NO_SINGLE_STEP */ - - pc_changed = 0; - fetch_inferior_registers (); - stop_pc = read_pc (); - set_current_frame (read_register (FP_REGNUM)); - stop_frame = get_current_frame (); - stop_sp = read_register (SP_REGNUM); - another_trap = 0; - stop_breakpoint = 0; - stop_step = 0; - stop_stack_dummy = 0; - stop_print_frame = 1; - stop_step_resume_break = 0; - random_signal = 0; - breakpoints_failed = 0; - - /* Look at the cause of the stop, and decide what to do. - The alternatives are: - 1) break; to really stop and return to the debugger, - 2) drop through to start up again - (set another_trap to 1 to single step once) - 3) set random_signal to 1, and the decision between 1 and 2 - will be made according to the signal handling tables. */ - + /* See if the process still exists; clean up if it doesn't. */ if (WIFEXITED (w)) { terminal_ours_for_output (); @@ -402,6 +497,9 @@ wait_for_inferior () printf ("\nProgram exited normally.\n"); fflush (stdout); inferior_died (); +#ifdef NO_SINGLE_STEP + one_stepped = 0; /* Clear single_step state since proc gone */ +#endif /* NO_SINGLE_STEP */ stop_print_frame = 0; break; } @@ -418,254 +516,377 @@ wait_for_inferior () : "(undocumented)"); printf ("The inferior process no longer exists.\n"); fflush (stdout); +#ifdef NO_SINGLE_STEP + one_stepped = 0; /* Clear single_step state since proc gone */ +#endif /* NO_SINGLE_STEP */ break; } - else + +#ifdef NO_SINGLE_STEP + if (one_stepped) + single_step (0); /* This actually cleans up the ss */ +#endif /* NO_SINGLE_STEP */ + + fetch_inferior_registers (); + stop_pc = read_pc (); + set_current_frame ( create_new_frame (read_register (FP_REGNUM), + read_pc ())); +#ifdef CONVEX_PTRACE + /* pop frame stored by user-mode trap, if present */ + if (stop_pc == BREAK_TRAP_ADDR) + { + POP_FRAME; + stop_pc = read_pc () - 2; + write_register (PC_REGNUM, stop_pc); +#ifdef NPC_REGNUM + write_register (NPC_REGNUM, stop_pc + 4); +#endif + pc_changed = 0; + } + else if (stop_pc > STACK_END_ADDR) + { + POP_FRAME; + stop_pc = read_pc (); + } +#endif /* CONVEX_PTRACE */ + stop_frame_address = FRAME_FP (get_current_frame ()); + stop_sp = read_register (SP_REGNUM); + stop_func_start = + get_pc_function_start (stop_pc) + FUNCTION_START_OFFSET; + another_trap = 0; + stop_breakpoint = 0; + 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; + + /* Look at the cause of the stop, and decide what to do. + The alternatives are: + 1) break; to really stop and return to the debugger, + 2) drop through to start up again + (set another_trap to 1 to single step once) + 3) set random_signal to 1, and the decision between 1 and 2 + will be made according to the signal handling tables. */ + + stop_signal = WSTOPSIG (w); + + /* First, distinguish signals caused by the debugger from signals + that have to do with the program's own actions. + Note that breakpoint insns may cause SIGTRAP or SIGILL + or SIGEMT, depending on the operating system version. + Here we detect when a SIGILL or SIGEMT is really a breakpoint + and change it to SIGTRAP. */ + + if (stop_signal == SIGTRAP +#ifndef CONVEX_PTRACE + || (breakpoints_inserted && + (stop_signal == SIGILL + || stop_signal == SIGEMT)) +#endif /* not CONVEX_PTRACE */ + || stop_after_attach) { - stop_signal = WSTOPSIG (w); - - /* First, distinguish signals caused by the debugger from signals - that have to do with the program's own actions. - Note that breakpoint insns may cause SIGTRAP or SIGILL - or SIGEMT, depending on the operating system version. - Here we detect when a SIGILL or SIGEMT is really a breakpoint - and change it to SIGTRAP. */ - - if (stop_signal == SIGTRAP - || (breakpoints_inserted && - (stop_signal == SIGILL - || stop_signal == SIGEMT)) - || stop_after_attach) + if (stop_signal == SIGTRAP && stop_after_trap) { - if (stop_signal == SIGTRAP && stop_after_trap) - { - stop_print_frame = 0; - break; - } - if (stop_after_attach) - break; - /* Don't even think about breakpoints - if still running the shell that will exec the program - or if just proceeded over a breakpoint. */ - if (stop_signal == SIGTRAP && trap_expected) - stop_breakpoint = 0; - else - /* See if there is a breakpoint at the current PC. */ + stop_print_frame = 0; + break; + } + if (stop_after_attach) + break; + /* Don't even think about breakpoints + if still running the shell that will exec the program + or if just proceeded over a breakpoint. */ + if (stop_signal == SIGTRAP && trap_expected) + stop_breakpoint = 0; + else + { + /* See if there is a breakpoint at the current PC. */ #if DECR_PC_AFTER_BREAK - /* Notice the case of stepping through a jump - that leads 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)) + /* Notice the case of stepping through a jump + that leads 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)) #endif /* DECR_PC_AFTER_BREAK not zero */ - { - select_frame (stop_frame, 0); /* For condition exprs. */ - stop_breakpoint = breakpoint_stop_status (stop_pc, stop_frame); - /* Following in case break condition called a function. */ - stop_print_frame = 1; - if (stop_breakpoint && DECR_PC_AFTER_BREAK) - { - stop_pc -= DECR_PC_AFTER_BREAK; - write_register (PC_REGNUM, stop_pc); + { + /* For condition exprs. */ + select_frame (get_current_frame (), 0); + stop_breakpoint = + breakpoint_stop_status (stop_pc, stop_frame_address); + /* Following in case break condition called a + function. */ + stop_print_frame = 1; + if (stop_breakpoint && DECR_PC_AFTER_BREAK) + { + stop_pc -= DECR_PC_AFTER_BREAK; + write_register (PC_REGNUM, stop_pc); #ifdef NPC_REGNUM - write_register (NPC_REGNUM, stop_pc + 4); + write_register (NPC_REGNUM, stop_pc + 4); #endif - pc_changed = 0; - } - } + pc_changed = 0; + } + } /* See if we stopped at the special breakpoint for stepping over a subroutine call. */ - if (stop_pc - DECR_PC_AFTER_BREAK == step_resume_break_address) + if (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); -#ifdef NPC_REGNUM - write_register (PC_REGNUM, stop_pc + 4); -#endif pc_changed = 0; } } - - if (stop_signal == SIGTRAP) - random_signal - = !(stop_breakpoint || trap_expected - || stop_step_resume_break - || (stop_sp INNER_THAN stop_pc && stop_pc INNER_THAN stop_frame) - || (step_range_end && !step_resume_break_address)); - else - { - random_signal - = !(stop_breakpoint || stop_step_resume_break); - if (!random_signal) - stop_signal = SIGTRAP; - } } + + if (stop_signal == SIGTRAP) + random_signal + = !(stop_breakpoint || trap_expected + || stop_step_resume_break +#ifndef CONVEX_PTRACE + || (stop_sp INNER_THAN stop_pc + && stop_pc INNER_THAN stop_frame_address) +#else + || stop_pc == text_end - 2 +#endif + || (step_range_end && !step_resume_break_address)); else - random_signal = 1; + { + random_signal + = !(stop_breakpoint + || stop_step_resume_break +#ifdef news800 + || (stop_sp INNER_THAN stop_pc + && stop_pc INNER_THAN stop_frame_address) +#endif + + ); + if (!random_signal) + stop_signal = SIGTRAP; + } + } + else + random_signal = 1; - /* For the program's own signals, act according to - the signal handling tables. */ + /* For the program's own signals, act according to + the signal handling tables. */ - if (random_signal - && !(running_in_shell && stop_signal == SIGSEGV)) - { - /* Signal not for debugging purposes. */ - int printed = 0; + if (random_signal + && !(running_in_shell && stop_signal == SIGSEGV)) + { + /* Signal not for debugging purposes. */ + int printed = 0; - if (stop_signal >= NSIG - || signal_print[stop_signal]) - { - printed = 1; - terminal_ours_for_output (); - printf ("\nProgram received signal %d, %s\n", - stop_signal, - stop_signal < NSIG - ? sys_siglist[stop_signal] - : "(undocumented)"); - fflush (stdout); - } - if (stop_signal >= NSIG - || signal_stop[stop_signal]) - break; - /* If not going to stop, give terminal back - if we took it away. */ - else if (printed) - terminal_inferior (); + stopped_by_random_signal = 1; + + if (stop_signal >= NSIG + || signal_print[stop_signal]) + { + printed = 1; + terminal_ours_for_output (); + printf ("\nProgram received signal %d, %s\n", + stop_signal, + stop_signal < NSIG + ? sys_siglist[stop_signal] + : "(undocumented)"); + fflush (stdout); } + if (stop_signal >= NSIG + || signal_stop[stop_signal]) + break; + /* If not going to stop, give terminal back + if we took it away. */ + else if (printed) + terminal_inferior (); + } - /* Handle cases caused by hitting a breakpoint. */ + /* Handle cases caused by hitting a breakpoint. */ - if (!random_signal - && (stop_breakpoint || stop_step_resume_break)) + if (!random_signal + && (stop_breakpoint || stop_step_resume_break)) + { + /* Does a breakpoint want us to stop? */ + if (stop_breakpoint && stop_breakpoint != -1 + && stop_breakpoint != -0x1000001) { - /* Does a breakpoint want us to stop? */ - if (stop_breakpoint && stop_breakpoint != -1) - { - /* 0x1000000 is set in stop_breakpoint as returned by - breakpoint_status_p to indicate a silent breakpoint. */ - if (stop_breakpoint > 0 && stop_breakpoint & 0x1000000) - { - stop_breakpoint &= ~0x1000000; - stop_print_frame = 0; - } - break; - } - /* But if we have hit the step-resumption breakpoint, - remove it. It has done its job getting us here. */ - if (stop_step_resume_break - && (step_frame == 0 || stop_frame == step_frame)) - { - remove_step_breakpoint (); - step_resume_break_address = 0; - } - /* Otherwise, must remove breakpoints and single-step - to get us past the one we hit. */ - else + /* 0x1000000 is set in stop_breakpoint as returned by + breakpoint_stop_status to indicate a silent + breakpoint. */ + if ((stop_breakpoint > 0 ? stop_breakpoint : + -stop_breakpoint) + & 0x1000000) { - remove_breakpoints (); - remove_step_breakpoint (); - breakpoints_inserted = 0; - another_trap = 1; + stop_print_frame = 0; + if (stop_breakpoint > 0) + stop_breakpoint -= 0x1000000; + else + stop_breakpoint += 0x1000000; } - - /* We come here if we hit a breakpoint but should not - stop for it. Possibly we also were stepping - and should stop for that. So fall through and - test for stepping. But, if not stepping, - do not stop. */ + break; } - - /* If this is the breakpoint at the end of a stack dummy, - just stop silently. */ - if (stop_sp INNER_THAN stop_pc && stop_pc INNER_THAN stop_frame) + /* 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. */ + if (stop_step_resume_break + && (step_frame_address == 0 + || (stop_frame_address == step_frame_address +#if 0 +#ifndef HAVE_REGISTER_WINDOWS + && step_resume_break_sp INNER_THAN stop_sp +#endif +#endif + ))) { - stop_print_frame = 0; - stop_stack_dummy = 1; + remove_step_breakpoint (); + step_resume_break_address = 0; + } + /* 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; + } + + /* We come here if we hit a breakpoint but should not + stop for it. Possibly we also were stepping + and should stop for that. So fall through and + test for stepping. But, if not stepping, + do not stop. */ + } + + /* If this is the breakpoint at the end of a stack dummy, + just stop silently. */ +#ifndef CONVEX_PTRACE + if (stop_sp INNER_THAN stop_pc + && stop_pc INNER_THAN stop_frame_address) +#else + /* "stack" dummy must be in text segment for Convex Unix */ + if (stop_pc == text_end - 2) +#endif + { + stop_print_frame = 0; + stop_stack_dummy = 1; #ifdef HP9K320 - trap_expected_after_continue = 1; + trap_expected_after_continue = 1; #endif + break; + } + + if (step_resume_break_address) + /* Having a step-resume breakpoint overrides anything + else having to do with stepping commands until + that breakpoint is reached. */ + ; + /* 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 != prev_sp + || stop_frame_address != step_frame_address))) + { + /* Don't step through the return from a function + unless that is the first instruction stepped through. */ + if (ABOUT_TO_RETURN (stop_pc)) + { + stop_step = 1; break; } + } - if (step_resume_break_address) - /* Having a step-resume breakpoint overrides anything - else having to do with stepping commands until - that breakpoint is reached. */ - ; - /* 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) + /* 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) + { + if (stop_func_start) { - /* Don't step through the return from a function - unless that is the first instruction stepped through. */ - if (ABOUT_TO_RETURN (stop_pc)) - { - stop_step = 1; - break; - } + prologue_pc = stop_func_start; + SKIP_PROLOGUE (prologue_pc); } - /* 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) + /* ==> 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)) { newfun = find_pc_function (stop_pc); - newmisc = -1; - if (newfun) - { - newfun_pc = BLOCK_START (SYMBOL_BLOCK_VALUE (newfun)) - + FUNCTION_START_OFFSET; - } - else - { - newmisc = find_pc_misc_function (stop_pc); - if (newmisc >= 0) - newfun_pc = misc_function_vector[newmisc].address - + FUNCTION_START_OFFSET; - else newfun_pc = 0; - } - if (stop_pc == newfun_pc - && (step_over_calls > 0 || (step_over_calls && newfun == 0))) + /* It's a subroutine call */ + if (step_over_calls > 0 || (step_over_calls && newfun == 0)) { /* A subroutine call has happened. */ /* Set a special breakpoint after the return */ - step_resume_break_address = SAVED_PC_AFTER_CALL (stop_frame); + step_resume_break_address = + SAVED_PC_AFTER_CALL (get_current_frame ()); step_resume_break_duplicate = breakpoint_here_p (step_resume_break_address); + step_resume_break_sp = stop_sp; if (breakpoints_inserted) insert_step_breakpoint (); } /* Subroutine call with source code we should not step over. Do step to the first line of code in it. */ - else if (stop_pc == newfun_pc && step_over_calls) + else if (step_over_calls) { - SKIP_PROLOGUE (newfun_pc); - sal = find_pc_line (newfun_pc, 0); + 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. */ - if (sal.end && sal.pc != newfun_pc) - newfun_pc = sal.end; - - if (newfun_pc == stop_pc) - /* We are already there: stop now. */ - stop_step = 1; +#ifdef convex + /* 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; +#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. */ + /* Put the step-breakpoint there and go until there. */ { - step_resume_break_address = newfun_pc; - + step_resume_break_address = stop_func_start; + step_resume_break_sp = stop_sp; + step_resume_break_duplicate = breakpoint_here_p (step_resume_break_address); if (breakpoints_inserted) @@ -673,22 +894,38 @@ wait_for_inferior () /* 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 = 0; + step_frame_address = 0; /* And make sure stepping stops right away then. */ step_range_end = step_range_start; } } - /* No subroutince call; stop now. */ else { + /* We get here only if step_over_calls is 0 and we + just stepped into a subroutine. 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; } } + /* No subroutince call; stop now. */ + else + { + stop_step = 1; + break; + } } /* Save the pc before execution, to compare with pc after stop. */ - prev_pc = read_pc (); + prev_pc = read_pc (); /* Might have been DECR_AFTER_BREAK */ + prev_func_start = stop_func_start; /* Ok, since if DECR_PC_AFTER + BREAK is defined, the + original pc would not have + been at the start of a + function. */ + prev_sp = stop_sp; /* If we did not do break;, it means we should keep running the inferior and not return to debugger. */ @@ -748,9 +985,19 @@ wait_for_inferior () BREAKPOINTS_FAILED nonzero means stop was due to error attempting to insert breakpoints. */ +/* FIXME, normal_stop is ALWAYS called immediately after wait_for_inferior. + They should probably be merged into a single function, since that + would avoid numerous tests (e.g. of inferior_pid). */ + static void normal_stop () { + /* Make sure that the current_frame's pc is correct. This + is a correction for setting up the frame info before doing + DECR_PC_AFTER_BREAK */ + if (inferior_pid) + (get_current_frame ())->pc = read_pc (); + if (breakpoints_failed) { terminal_ours_for_output (); @@ -781,7 +1028,8 @@ Further execution is probably impossible.\n"); /* If an auto-display called a function and that got a signal, delete that auto-display to avoid an infinite recursion. */ - delete_current_display (); + if (stopped_by_random_signal) + delete_current_display (); if (step_multi && stop_step) return; @@ -791,7 +1039,13 @@ Further execution is probably impossible.\n"); if (running_in_shell) { if (stop_signal == SIGSEGV) - printf ("\ + { + char *exec_file = (char *) get_exec_file (1); + + if (access (exec_file, X_OK) != 0) + printf ("The file \"%s\" is not executable.\n", exec_file); + else + printf ("\ You have just encountered a bug in \"sh\". GDB starts your program\n\ by running \"sh\" with a command to exec your program.\n\ This is so that \"sh\" will process wildcards and I/O redirection.\n\ @@ -803,6 +1057,7 @@ some variables whose values are large; then do \"run\" again.\n\ \n\ If that works, you might want to put those \"unset-env\" commands\n\ into a \".gdbinit\" file in this directory so they will happen every time.\n"); + } /* Don't confuse user with his program's symbols on sh's data. */ stop_print_frame = 0; } @@ -814,14 +1069,14 @@ into a \".gdbinit\" file in this directory so they will happen every time.\n"); or if the program has exited. */ if (!stop_stack_dummy) { - select_frame (stop_frame, 0); + select_frame (get_current_frame (), 0); if (stop_print_frame) { if (stop_breakpoint > 0) printf ("\nBpt %d, ", stop_breakpoint); print_sel_frame (stop_step - && step_frame == stop_frame + && step_frame_address == stop_frame_address && step_start_function == find_pc_function (stop_pc)); /* Display the auto-display expressions. */ do_displays (); @@ -834,9 +1089,11 @@ into a \".gdbinit\" file in this directory so they will happen every time.\n"); if (stop_stack_dummy) { - /* Pop the empty frame that contains the stack dummy. */ + /* Pop the empty frame that contains the stack dummy. + POP_FRAME ends with a setting of the current frame, so we + can use that next. */ POP_FRAME; - select_frame (read_register (FP_REGNUM), 0); + select_frame (get_current_frame (), 0); } } @@ -868,7 +1125,7 @@ handle_command (args, from_tty) int from_tty; { register char *p = args; - int signum; + int signum = 0; register int digits, wordlen; if (!args) @@ -885,6 +1142,11 @@ handle_command (args, from_tty) if (digits == wordlen) { signum = atoi (p); + if (signum <= 0 || signum >= NSIG) + { + p[wordlen] = '\0'; + error ("Invalid signal %s given as argument to \"handle\".", p); + } if (signum == SIGTRAP || signum == SIGINT) { if (!query ("Signal %d is used by the debugger.\nAre you sure you want to change it? ", signum)) @@ -970,7 +1232,7 @@ signals_info (signum_exp) { printf ("[Type Return to see more]"); fflush (stdout); - read_line (); + gdb_read_line (0, 0); } printf ("%d\t", i); printf ("%s\t", signal_stop[i] ? "Yes" : "No"); @@ -982,8 +1244,91 @@ signals_info (signum_exp) printf ("\nUse the \"handle\" command to change these tables.\n"); } -static -initialize () +/* Save all of the information associated with the inferior<==>gdb + connection. INF_STATUS is a pointer to a "struct inferior_status" + (defined in inferior.h). */ + +struct command_line *get_breakpoint_commands (); + +void +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; + inf_status->stop_breakpoint = stop_breakpoint; + inf_status->stop_step = stop_step; + inf_status->stop_stack_dummy = stop_stack_dummy; + inf_status->stopped_by_random_signal = stopped_by_random_signal; + inf_status->trap_expected = trap_expected; + inf_status->step_range_start = step_range_start; + 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_after_attach = stop_after_attach; + inf_status->breakpoint_commands = get_breakpoint_commands (); + inf_status->restore_stack_info = restore_stack_info; + + bcopy (stop_registers, inf_status->stop_registers, REGISTER_BYTES); + + record_selected_frame (&(inf_status->selected_frame_address), + &(inf_status->selected_level)); + return; +} + +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; + stop_breakpoint = inf_status->stop_breakpoint; + stop_step = inf_status->stop_step; + stop_stack_dummy = inf_status->stop_stack_dummy; + stopped_by_random_signal = inf_status->stopped_by_random_signal; + trap_expected = inf_status->trap_expected; + step_range_start = inf_status->step_range_start; + 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_after_attach = inf_status->stop_after_attach; + set_breakpoint_commands (inf_status->breakpoint_commands); + + bcopy (inf_status->stop_registers, stop_registers, REGISTER_BYTES); + + if (inf_status->restore_stack_info) + { + fid = find_relative_frame (get_current_frame (), + &level); + + if (FRAME_FP (fid) != inf_status->selected_frame_address || + level != 0) + { + fprintf (stderr, "Unable to restore previously selected frame.\n"); + select_frame (get_current_frame (), 0); + return; + } + + select_frame (fid, inf_status->selected_level); + } + return; +} + + +void +_initialize_infrun () { register int i; @@ -1044,148 +1389,3 @@ Pass and Stop may be combined."); #endif /* SIGURG */ } -#ifdef NO_SINGLE_STEP -/* This code was written by Gary Beihl (beihl@mcc.com). - It was modified by Michael Tiemann (tiemann@corto.inria.fr). */ - -/* Simulate single-step ptrace call for sun4. */ - -typedef enum -{ - b_error, not_branch, bicc, bicca, ba, baa, ticc, ta, -} branch_type; - -static CORE_ADDR next_pc, pc8, target; -static int brkpc8, brktrg; -typedef char binsn_quantum[sizeof break_insn]; -static binsn_quantum break_mem[3]; - -int -single_step (signal) - int signal; -{ - branch_type br, isabranch(); - - next_pc = read_register (NPC_REGNUM); - pc8 = read_register (PC_REGNUM) + 8; /* branch not taken */ - - if (!one_stepped) - { - /* Always set breakpoint for NPC. */ - read_memory (next_pc, break_mem[0], sizeof break_insn); - write_memory (next_pc, break_insn, sizeof break_insn); - - /* printf ("set break at %x\n",next_pc); */ - br = isabranch (pc8 - 8, &target); - brkpc8 = brktrg = 0; - - if (br == bicca && pc8 != next_pc) - { - /* Handle branches with care */ - brkpc8 = 1; - read_memory (pc8, break_mem[1], sizeof break_insn); - write_memory (pc8, break_insn, sizeof break_insn); - } - else if (br == baa && target != next_pc) - { - brktrg = 1; - read_memory (target, break_mem[2], sizeof break_insn); - write_memory (target, break_insn, sizeof break_insn); - } - - /* Let it go */ - ptrace (7, inferior_pid, 1, signal); - one_stepped = 1; - return; - } - else - { - /* Remove breakpoints */ - write_memory (next_pc, break_mem[0], sizeof break_insn); - - if (brkpc8) - { - write_memory (pc8, break_mem[1], sizeof break_insn); - } - if (brktrg) - { - write_memory (target, break_mem[2], sizeof break_insn); - } - one_stepped = 0; - } -} - -#endif /* NO_SINGLE_STEP */ - -static int save_insn_opcodes[] = { 0x03000000, 0x82007ee0, 0x9de38001, 0x03000000, 0x82007ee0, 0x91d02001, 0x01000000 }; - -void -do_save_insn (size) - int size; -{ - int g1 = read_register (1); - CORE_ADDR sp = read_register (SP_REGNUM); - CORE_ADDR pc = read_register (PC_REGNUM); -#ifdef NPC_REGNUM - CORE_ADDR npc = read_register (NPC_REGNUM); -#endif - CORE_ADDR fake_pc = sp - sizeof (save_insn_opcodes); - save_insn_opcodes[0] = 0x03000000 | ((-size >> 12) & 0x3fffff); - save_insn_opcodes[1] = 0x82006000 | (-size & 0x3ff); - save_insn_opcodes[3] = 0x03000000 | ((g1 >> 12) & 0x3fffff); - save_insn_opcodes[4] = 0x82006000 | (g1 & 0x3ff); - write_memory (fake_pc, save_insn_opcodes, sizeof (save_insn_opcodes)); - clear_proceed_status (); - stop_after_trap = 1; - - proceed (fake_pc, 0, 0); - - write_register (PC_REGNUM, pc); -#ifdef NPC_REGNUM - write_register (NPC_REGNUM, npc); -#endif -} - -static int restore_insn_opcodes[] = { 0x81e80000, 0x91d02001, 0x01000000 }; - -void -do_restore_insn (raw_buffer) - char raw_buffer[]; -{ - CORE_ADDR pc = read_memory_integer (*(int *)&raw_buffer[REGISTER_BYTE (PC_REGNUM)], 4); - CORE_ADDR sp = read_register (SP_REGNUM); -#ifdef NPC_REGNUM - CORE_ADDR npc = *(int *)&raw_buffer[REGISTER_BYTE (NPC_REGNUM)] != 0 - ? read_memory_integer (*(int *)&raw_buffer[REGISTER_BYTE (NPC_REGNUM)], 4) : pc + 4; -#endif - CORE_ADDR fake_pc = sp - sizeof (restore_insn_opcodes); - int saved_stop_stack_dummy = stop_stack_dummy; - - if (*(int *)&raw_buffer[REGISTER_BYTE (PC_REGNUM)] == 0) - abort (); - - write_memory (fake_pc, restore_insn_opcodes, sizeof (restore_insn_opcodes)); - clear_proceed_status (); - stop_after_trap = 1; - - proceed (fake_pc, 0, 0); - - stop_stack_dummy = saved_stop_stack_dummy; - write_register (PC_REGNUM, pc); -#ifdef NPC_REGNUM - write_register (NPC_REGNUM, npc); -#endif - - /* Select innermost stack frame except on return from a stack dummy routine, - or if the program has exited. */ - if (!stop_stack_dummy) - { - select_frame (stop_frame, 0); - } - else - { - select_frame (read_register (FP_REGNUM), 0); - } -} - -END_FILE |