diff options
| -rw-r--r-- | gdb/infrun.c | 330 |
1 files changed, 186 insertions, 144 deletions
diff --git a/gdb/infrun.c b/gdb/infrun.c index 2f1df81..73efc2d 100644 --- a/gdb/infrun.c +++ b/gdb/infrun.c @@ -387,7 +387,8 @@ follow_inferior_fork (parent_pid, child_pid, has_forked, has_vforked) from the breakpoint package's viewpoint, that's a switch of "threads". We must update the bp's notion of which thread it is for, or it'll be ignored when it triggers... */ - if (step_resume_breakpoint && (! has_vforked || ! follow_vfork_when_exec)) + if (step_resume_breakpoint && + (! has_vforked || ! follow_vfork_when_exec)) breakpoint_re_set_thread (step_resume_breakpoint); /* Reinsert all breakpoints in the child. (The user may've set @@ -503,7 +504,8 @@ follow_exec (pid, execd_pathname) /* Did this exec() follow a vfork()? If so, we must follow the vfork now too. Do it before following the exec. */ - if (follow_vfork_when_exec && (pending_follow.kind == TARGET_WAITKIND_VFORKED)) + if (follow_vfork_when_exec && + (pending_follow.kind == TARGET_WAITKIND_VFORKED)) { pending_follow.kind = TARGET_WAITKIND_SPURIOUS; follow_vfork (inferior_pid, pending_follow.fork_event.child_pid); @@ -659,7 +661,8 @@ resume (step, sig) If so, then it actually ought to be waiting for us; we respond to parent vfork events. We don't actually want to resume the child in this situation; we want to just get its exec event. */ - if (! saw_child_exec && (inferior_pid == pending_follow.fork_event.child_pid)) + if (! saw_child_exec && + (inferior_pid == pending_follow.fork_event.child_pid)) should_resume = 0; } break; @@ -993,8 +996,8 @@ wait_for_inferior () || trap_expected)) \ || stepping_through_solib_after_catch \ || bpstat_should_step ()) - -thread_step_needed = 0; + ; + thread_step_needed = 0; #ifdef HPUXHPPA /* We'll update this if & when we switch to a new thread. */ @@ -1058,20 +1061,32 @@ stepped_after_stopped_by_watchpoint = 0; #ifdef HPUXHPPA - fprintf_unfiltered (gdb_stderr, "[New %s]\n", target_pid_or_tid_to_str (pid)); + fprintf_unfiltered (gdb_stderr, "[New %s]\n", + target_pid_or_tid_to_str (pid)); #else printf_filtered ("[New %s]\n", target_pid_to_str (pid)); #endif #if 0 - /* We may want to consider not doing a resume here in order to give - the user a chance to play with the new thread. It might be good - to make that a user-settable option. */ - - /* At this point, all threads are stopped (happens automatically in - either the OS or the native code). Therefore we need to continue - all threads in order to make progress. */ + /* NOTE: This block is ONLY meant to be invoked in case of a + "thread creation event"! If it is invoked for any other + sort of event (such as a new thread landing on a breakpoint), + the event will be discarded, which is almost certainly + a bad thing! + + To avoid this, the low-level module (eg. target_wait) + should call in_thread_list and add_thread, so that the + new thread is known by the time we get here. */ + + /* We may want to consider not doing a resume here in order + to give the user a chance to play with the new thread. + It might be good to make that a user-settable option. */ + + /* At this point, all threads are stopped (happens + automatically in either the OS or the native code). + Therefore we need to continue all threads in order to + make progress. */ target_resume (-1, 0, TARGET_SIGNAL_0); continue; @@ -1192,14 +1207,15 @@ stepped_after_stopped_by_watchpoint = 0; stop_pc = read_pc_pid (pid); saved_inferior_pid = inferior_pid; inferior_pid = pid; - stop_bpstat = bpstat_stop_status (&stop_pc, + stop_bpstat = bpstat_stop_status + (&stop_pc, #if DECR_PC_AFTER_BREAK - (prev_pc != stop_pc - DECR_PC_AFTER_BREAK - && CURRENTLY_STEPPING ()) + (prev_pc != stop_pc - DECR_PC_AFTER_BREAK + && CURRENTLY_STEPPING ()) #else /* DECR_PC_AFTER_BREAK zero */ - 0 + 0 #endif /* DECR_PC_AFTER_BREAK zero */ - ); + ); random_signal = ! bpstat_explains_signal (stop_bpstat); inferior_pid = saved_inferior_pid; goto process_event_stop_test; @@ -1246,14 +1262,15 @@ stepped_after_stopped_by_watchpoint = 0; } stop_pc = read_pc (); - stop_bpstat = bpstat_stop_status (&stop_pc, + stop_bpstat = bpstat_stop_status + (&stop_pc, #if DECR_PC_AFTER_BREAK - (prev_pc != stop_pc - DECR_PC_AFTER_BREAK - && CURRENTLY_STEPPING ()) + (prev_pc != stop_pc - DECR_PC_AFTER_BREAK + && CURRENTLY_STEPPING ()) #else /* DECR_PC_AFTER_BREAK zero */ - 0 + 0 #endif /* DECR_PC_AFTER_BREAK zero */ - ); + ); random_signal = ! bpstat_explains_signal (stop_bpstat); goto process_event_stop_test; @@ -1303,7 +1320,8 @@ stepped_after_stopped_by_watchpoint = 0; suffices. */ if (RESUME_EXECD_VFORKING_CHILD_TO_GET_PARENT_VFORK()) target_resume (pid, 1, TARGET_SIGNAL_0); - continue; /* We expect the parent vfork event to be available now. */ + /* We expect the parent vfork event to be available now. */ + continue; } /* This causes the eventpoints and symbol table to be reset. Must @@ -1314,14 +1332,15 @@ stepped_after_stopped_by_watchpoint = 0; stop_pc = read_pc_pid (pid); saved_inferior_pid = inferior_pid; inferior_pid = pid; - stop_bpstat = bpstat_stop_status (&stop_pc, + stop_bpstat = bpstat_stop_status + (&stop_pc, #if DECR_PC_AFTER_BREAK - (prev_pc != stop_pc - DECR_PC_AFTER_BREAK - && CURRENTLY_STEPPING ()) + (prev_pc != stop_pc - DECR_PC_AFTER_BREAK + && CURRENTLY_STEPPING ()) #else /* DECR_PC_AFTER_BREAK zero */ - 0 + 0 #endif /* DECR_PC_AFTER_BREAK zero */ - ); + ); random_signal = ! bpstat_explains_signal (stop_bpstat); inferior_pid = saved_inferior_pid; goto process_event_stop_test; @@ -1353,19 +1372,19 @@ stepped_after_stopped_by_watchpoint = 0; continue; /* Before examining the threads further, step this thread to - get it entirely out of the syscall. (We get notice of the - event when the thread is just on the verge of exiting a - syscall. Stepping one instruction seems to get it back - into user code.) - - Note that although the logical place to reenable h/w watches - is here, we cannot. We cannot reenable them before stepping - the thread (this causes the next wait on the thread to hang). - - Nor can we enable them after stepping until we've done a - wait. Thus, we simply set the flag enable_hw_watchpoints_after_wait - here, which will be serviced immediately after the target - is waited on. */ + get it entirely out of the syscall. (We get notice of the + event when the thread is just on the verge of exiting a + syscall. Stepping one instruction seems to get it back + into user code.) + + Note that although the logical place to reenable h/w watches + is here, we cannot. We cannot reenable them before stepping + the thread (this causes the next wait on the thread to hang). + + Nor can we enable them after stepping until we've done a wait. + Thus, we simply set the flag enable_hw_watchpoints_after_wait + here, which will be serviced immediately after the target + is waited on. */ case TARGET_WAITKIND_SYSCALL_RETURN: target_resume (pid, 1, TARGET_SIGNAL_0); @@ -1410,50 +1429,53 @@ stepped_after_stopped_by_watchpoint = 0; && breakpoint_here_p (stop_pc - DECR_PC_AFTER_BREAK)) { random_signal = 0; - if (!breakpoint_thread_match (stop_pc - DECR_PC_AFTER_BREAK, pid)) + if (!breakpoint_thread_match (stop_pc - DECR_PC_AFTER_BREAK, + pid)) { int remove_status; - /* Saw a breakpoint, but it was hit by the wrong thread. Just continue. */ + /* Saw a breakpoint, but it was hit by the wrong thread. + Just continue. */ write_pc_pid (stop_pc - DECR_PC_AFTER_BREAK, pid); remove_status = remove_breakpoints (); - /* Did we fail to remove breakpoints? If so, try to set the - PC past the bp. (There's at least one situation in which - we can fail to remove the bp's: On HP-UX's that use ttrace, - we can't change the address space of a vforking child process - until the child exits (well, okay, not then either :-) or - execs. */ - if (remove_status != 0) - { - write_pc_pid (stop_pc - DECR_PC_AFTER_BREAK + 4, pid); - } - else - { - target_resume (pid, 1, TARGET_SIGNAL_0); /* Single step */ - /* FIXME: What if a signal arrives instead of the single-step - happening? */ - - if (target_wait_hook) - target_wait_hook (pid, &w); + /* Did we fail to remove breakpoints? If so, try + to set the PC past the bp. (There's at least + one situation in which we can fail to remove + the bp's: On HP-UX's that use ttrace, we can't + change the address space of a vforking child + process until the child exits (well, okay, not + then either :-) or execs. */ + if (remove_status != 0) + { + write_pc_pid (stop_pc - DECR_PC_AFTER_BREAK + 4, pid); + } else - target_wait (pid, &w); - insert_breakpoints (); - } + { /* Single step */ + target_resume (pid, 1, TARGET_SIGNAL_0); + /* FIXME: What if a signal arrives instead of the + single-step happening? */ + + if (target_wait_hook) + target_wait_hook (pid, &w); + else + target_wait (pid, &w); + insert_breakpoints (); + } /* We need to restart all the threads now. */ target_resume (-1, 0, TARGET_SIGNAL_0); continue; } - else - { - /* This breakpoint matches--either it is the right - thread or it's a generic breakpoint for all threads. - Remember that we'll need to step just _this_ thread - on any following user continuation! */ - thread_step_needed = 1; - } - } + else + { + /* This breakpoint matches--either it is the right + thread or it's a generic breakpoint for all threads. + Remember that we'll need to step just _this_ thread + on any following user continuation! */ + thread_step_needed = 1; + } + } } else random_signal = 1; @@ -1962,13 +1984,15 @@ process_event_stop_test: /* This proably demands a more elegant solution, but, yeah right... - This function's use of the simple variable step_resume_breakpoint - doesn't seem to accomodate simultaneously active step-resume bp's, - although the breakpoint list certainly can. + This function's use of the simple variable + step_resume_breakpoint doesn't seem to accomodate + simultaneously active step-resume bp's, although the + breakpoint list certainly can. - If we reach here and step_resume_breakpoint is already NULL, then - apparently we have multiple active step-resume bp's. We'll just - delete the breakpoint we stopped at, and carry on. */ + If we reach here and step_resume_breakpoint is already + NULL, then apparently we have multiple active + step-resume bp's. We'll just delete the breakpoint we + stopped at, and carry on. */ if (step_resume_breakpoint == NULL) { step_resume_breakpoint = @@ -2117,7 +2141,8 @@ process_event_stop_test: just stop silently, unless the user was doing an si/ni, in which case she'd better know what she's doing. */ - if (CALL_DUMMY_HAS_COMPLETED (stop_pc, read_sp (), FRAME_FP (get_current_frame ())) + if (CALL_DUMMY_HAS_COMPLETED (stop_pc, read_sp (), + FRAME_FP (get_current_frame ())) && !step_range_end) { stop_print_frame = 0; @@ -2151,8 +2176,8 @@ process_event_stop_test: if (stop_pc >= step_range_start && stop_pc < step_range_end #if 0 -/* I haven't a clue what might trigger this clause, and it seems wrong anyway, - so I've disabled it until someone complains. -Stu 10/24/95 */ +/* I haven't a clue what might trigger this clause, and it seems wrong + anyway, so I've disabled it until someone complains. -Stu 10/24/95 */ /* The step range might include the start of the function, so if we are at the start of the @@ -2201,7 +2226,7 @@ process_event_stop_test: { - CORE_ADDR current_frame = FRAME_FP (get_current_frame()); + CORE_ADDR current_frame = FRAME_FP (get_current_frame()); if (INNER_THAN (current_frame, step_frame_address)) { @@ -2223,7 +2248,8 @@ process_event_stop_test: sr_sal.line = 0; sr_sal.pc = prev_pc; /* We could probably be setting the frame to - step_frame_address; I don't think anyone thought to try it. */ + step_frame_address; I don't think anyone thought to + try it. */ step_resume_breakpoint = set_momentary_breakpoint (sr_sal, NULL, bp_step_resume); if (breakpoints_inserted) @@ -2231,18 +2257,21 @@ process_event_stop_test: } else { - /* We just stepped out of a signal handler and into its calling - trampoline. - - Normally, we'd jump to step_over_function from here, - but for some reason GDB can't unwind the stack correctly to find - the real PC for the point user code where the signal trampoline will - return -- FRAME_SAVED_PC fails, at least on HP-UX 10.20. But signal - trampolines are pretty small stubs of code, anyway, so it's OK instead - to just single-step out. Note: assuming such trampolines don't - exhibit recursion on any platform... */ - find_pc_partial_function (stop_pc, &stop_func_name, &stop_func_start, - &stop_func_end); + /* We just stepped out of a signal handler and into + its calling trampoline. + + Normally, we'd jump to step_over_function from + here, but for some reason GDB can't unwind the + stack correctly to find the real PC for the point + user code where the signal trampoline will return + -- FRAME_SAVED_PC fails, at least on HP-UX 10.20. + But signal trampolines are pretty small stubs of + code, anyway, so it's OK instead to just + single-step out. Note: assuming such trampolines + don't exhibit recursion on any platform... */ + find_pc_partial_function (stop_pc, &stop_func_name, + &stop_func_start, + &stop_func_end); /* Readjust stepping range */ step_range_start = stop_func_start; step_range_end = stop_func_end; @@ -2264,11 +2293,12 @@ process_event_stop_test: } #if 0 - /* I disabled this test because it was too complicated and slow. The - SKIP_PROLOGUE was especially slow, because it caused unnecessary - prologue examination on various architectures. The code in the #else - clause has been tested on the Sparc, Mips, PA, and Power - architectures, so it's pretty likely to be correct. -Stu 10/24/95 */ + /* I disabled this test because it was too complicated and slow. + The SKIP_PROLOGUE was especially slow, because it caused + unnecessary prologue examination on various architectures. + The code in the #else clause has been tested on the Sparc, + Mips, PA, and Power architectures, so it's pretty likely to + be correct. -Stu 10/24/95 */ /* See if we left the step range due to a subroutine call that we should proceed to the end of. */ @@ -2287,7 +2317,8 @@ process_event_stop_test: SKIP_PROLOGUE (prologue_pc); } - if (!(INNER_THAN (step_sp, read_sp ())) /* don't mistake (sig)return as a call */ + if (!(INNER_THAN (step_sp, read_sp ())) /* don't mistake (sig)return + as a call */ && (/* Might be a non-recursive call. If the symbols are missing enough that stop_func_start == prev_func_start even though they are really two functions, we will treat some calls as @@ -2421,29 +2452,32 @@ step_over_function: step_resume_breakpoint = set_momentary_breakpoint (sr_sal, - stopped_by_random_signal ? NULL : get_current_frame (), + stopped_by_random_signal ? + NULL : get_current_frame (), bp_step_resume); /* We've just entered a callee, and we wish to resume until it returns to the caller. Setting a step_resume bp on the return PC will catch a return from the callee. - However, if the callee is recursing, we want to be careful - not to catch returns of those recursive calls, but of THIS - instance of the call. + However, if the callee is recursing, we want to be + careful not to catch returns of those recursive calls, + but of THIS instance of the call. - To do this, we set the step_resume bp's frame to our current - caller's frame (step_frame_address, which is set by the "next" - or "until" command, before execution begins). + To do this, we set the step_resume bp's frame to our + current caller's frame (step_frame_address, which is + set by the "next" or "until" command, before execution + begins). - But ... don't do it if we're single-stepping out of a sigtramp, - because the reason we're single-stepping is precisely because - unwinding is a problem (HP-UX 10.20, e.g.) and the frame address - is likely to be incorrect. No danger of sigtramp recursion */ + But ... don't do it if we're single-stepping out of a + sigtramp, because the reason we're single-stepping is + precisely because unwinding is a problem (HP-UX 10.20, + e.g.) and the frame address is likely to be incorrect. + No danger of sigtramp recursion. */ if (stepping_through_sigtramp) { - step_resume_breakpoint->frame = NULL; + step_resume_breakpoint->frame = (CORE_ADDR) NULL; stepping_through_sigtramp = 0; } else if (!IN_SOLIB_DYNSYM_RESOLVE_CODE (sr_sal.pc)) @@ -2717,9 +2751,9 @@ step_into_function: stop_signal = TARGET_SIGNAL_0; #ifdef SHIFT_INST_REGS - /* 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. */ + /* 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). */ @@ -2857,7 +2891,8 @@ normal_stop () target_has_execution) { target_terminal_ours_for_output (); - printf_filtered ("[Switched to %s]\n", target_pid_or_tid_to_str (inferior_pid)); + printf_filtered ("[Switched to %s]\n", + target_pid_or_tid_to_str (inferior_pid)); switched_from_inferior_pid = inferior_pid; } #endif @@ -2881,9 +2916,10 @@ The same program may be running in another process.\n"); if (remove_breakpoints ()) { target_terminal_ours_for_output (); - 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"); + printf_filtered ("Cannot remove breakpoints because "); + printf_filtered ("program is no longer writable.\n"); + printf_filtered ("It might be running in another process.\n"); + printf_filtered ("Further execution is probably impossible.\n"); } } breakpoints_inserted = 0; @@ -2990,9 +3026,9 @@ Further execution is probably impossible.\n"); POP_FRAME ends with a setting of the current frame, so we can use that next. */ POP_FRAME; - /* Set stop_pc to what it was before we called the function. Can't rely - on restore_inferior_status because that only gets called if we don't - stop in the called function. */ + /* Set stop_pc to what it was before we called the function. + Can't rely on restore_inferior_status because that only gets + called if we don't stop in the called function. */ stop_pc = read_pc(); select_frame (get_current_frame (), 0); } @@ -3047,7 +3083,8 @@ sig_print_info (oursig) name_padding = 0; printf_filtered ("%s", name); - printf_filtered ("%*.*s ", name_padding, name_padding, " "); + printf_filtered ("%*.*s ", name_padding, name_padding, + " "); printf_filtered ("%s\t", signal_stop[oursig] ? "Yes" : "No"); printf_filtered ("%s\t", signal_print[oursig] ? "Yes" : "No"); printf_filtered ("%s\t\t", signal_program[oursig] ? "Yes" : "No"); @@ -3146,17 +3183,18 @@ handle_command (args, from_tty) } else if (digits > 0) { - /* It is numeric. The numeric signal refers to our own internal - signal numbering from target.h, not to host/target signal number. - This is a feature; users really should be using symbolic names - anyway, and the common ones like SIGHUP, SIGINT, SIGALRM, etc. - will work right anyway. */ - - sigfirst = siglast = (int) target_signal_from_command (atoi (*argv)); + /* It is numeric. The numeric signal refers to our own + internal signal numbering from target.h, not to host/target + signal number. This is a feature; users really should be + using symbolic names anyway, and the common ones like + SIGHUP, SIGINT, SIGALRM, etc. will work right anyway. */ + + sigfirst = siglast = (int) + target_signal_from_command (atoi (*argv)); if ((*argv)[digits] == '-') { - siglast = - (int) target_signal_from_command (atoi ((*argv) + digits + 1)); + siglast = (int) + target_signal_from_command (atoi ((*argv) + digits + 1)); } if (sigfirst > siglast) { @@ -3252,7 +3290,7 @@ xdb_handle_command (args, from_tty) { nomem (0); } - old_chain = make_cleanup (freeargv, (char *) argv); + old_chain = make_cleanup ((make_cleanup_func) freeargv, (char *) argv); if (argv[1] != (char *)NULL) { char *argBuf; @@ -3415,11 +3453,13 @@ restore_selected_frame (args) /* If inf_status->selected_frame_address is NULL, there was no previously selected frame. */ if (frame == NULL || - /* FRAME_FP (frame) != fr->frame_address ||*/ /* elz: deleted this check as a quick fix - to the problem that for function called by hand - gdb creates no internal frame structure - and the real stack and gdb's idea of stack - are different if nested calls by hands are made*/ + /* FRAME_FP (frame) != fr->frame_address || */ + /* elz: deleted this check as a quick fix to the problem that + for function called by hand gdb creates no internal frame + structure and the real stack and gdb's idea of stack are + different if nested calls by hands are made. + + mvs: this worries me. */ level != 0) { warning ("Unable to restore previously selected frame.\n"); @@ -3620,8 +3660,9 @@ to the user would be loading/unloading of a new library.\n", /* ??rehrauer: The "both" option is broken, by what may be a 10.20 kernel problem. It's also not terribly useful without a GUI to help the user drive two debuggers. So for now, I'm disabling - the "both" option. -/* "Set debugger response to a program call of fork or vfork.\n\ + the "both" option. */ +/* "Set debugger response to a program call of fork \ +or vfork.\n\ A fork or vfork creates a new process. follow-fork-mode can be:\n\ parent - the original process is debugged after a fork\n\ child - the new process is debugged after a fork\n\ @@ -3634,7 +3675,8 @@ debugger copy's prompt will be changed.\n\ For \"parent\" or \"child\", the unfollowed process will run free.\n\ By default, the debugger will follow the parent process.", */ - "Set debugger response to a program call of fork or vfork.\n\ + "Set debugger response to a program call of fork \ +or vfork.\n\ A fork or vfork creates a new process. follow-fork-mode can be:\n\ parent - the original process is debugged after a fork\n\ child - the new process is debugged after a fork\n\ |