X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Finfrun.c;h=37447334eb0d5c34857e02a02019c107191de5fc;hb=cf3e377e61e7861677252feb4d06ba8fcea1e5c1;hp=1cca59277d30ee016b93165a3b82fef084e1d49b;hpb=3c0c9328b9c299580bcf8cb6fdb3b71d5a0525ff;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/infrun.c b/gdb/infrun.c index 1cca59277d..37447334eb 100644 --- a/gdb/infrun.c +++ b/gdb/infrun.c @@ -1,21 +1,22 @@ -/* Start (run) and stop the inferior process, for GDB. - Copyright (C) 1986, 1987, 1988, 1989, 1991 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. -GDB is free software; you can redistribute it and/or modify +This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by -the Free Software Foundation; either version 1, or (at your option) -any later version. +the Free Software Foundation; either version 2 of the License, or +(at your option) any later version. -GDB is distributed in the hope that it will be useful, +This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License -along with GDB; see the file COPYING. If not, write to -the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ +along with this program; if not, write to the Free Software +Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ /* Notes on the algorithm used in wait_for_inferior to determine if we just did a subroutine call when stepping. We have the following @@ -25,7 +26,7 @@ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ Current and previous sp. Current and previous start of current function. - If the start's of the functions don't match, then + If the starts of the functions don't match, then a) We did a subroutine call. @@ -99,36 +100,18 @@ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ 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 -#include #include "defs.h" -#include "param.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 @@ -140,71 +123,92 @@ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ #include #endif -#ifdef SET_STACK_LIMIT_HUGE -extern int original_stack_limit; -#endif /* SET_STACK_LIMIT_HUGE */ +/* Prototypes for local functions */ -/* Required by . */ -#include -/* Required by , at least on system V. */ -#include -/* Needed by IN_SIGTRAMP on some machines (e.g. vax). */ -#include -/* Needed by IN_SIGTRAMP on some machines (e.g. vax). */ -#include +static void +signals_info PARAMS ((char *, int)); -extern char *getenv (); +static void +handle_command PARAMS ((char *, int)); -extern struct target_ops child_ops; /* In inftarg.c */ +static void +sig_print_info PARAMS ((int)); -/* Copy of inferior_io_terminal when inferior was last started. */ +static void +sig_print_header PARAMS ((void)); -extern char *inferior_thisrun_terminal; +static void +resume_cleanups PARAMS ((int)); +static int +hook_stop_stub PARAMS ((char *)); -/* 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. +/* 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 + from it. The return value is non-zero on success, zero otherwise. */ +#ifndef GET_LONGJMP_TARGET +#define GET_LONGJMP_TARGET(PC_ADDR) 0 +#endif - 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) +/* Some machines have trampoline code that sits between function callers + and the actual functions themselves. If this machine doesn't have + such things, disable their processing. */ +#ifndef SKIP_TRAMPOLINE_CODE +#define SKIP_TRAMPOLINE_CODE(pc) 0 #endif -/* Tables of how to react to signals; the user sets them. */ +/* 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 -static char signal_stop[NSIG]; -static char signal_print[NSIG]; -static char signal_program[NSIG]; +/* 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. */ -/* Nonzero if breakpoints are now inserted in the inferior. */ -/* Nonstatic for initialization during xxx_create_inferior. FIXME. */ +#ifndef INSTRUCTION_NULLIFIED +#define INSTRUCTION_NULLIFIED 0 +#endif -/*static*/ int breakpoints_inserted; +/* Tables of how to react to signals; the user sets them. */ -/* Function inferior was in as of last step command. */ +static unsigned char *signal_stop; +static unsigned char *signal_print; +static unsigned char *signal_program; + +#define SET_SIGS(nsigs,sigs,flags) \ + do { \ + int signum = (nsigs); \ + while (signum-- > 0) \ + if ((sigs)[signum]) \ + (flags)[signum] = 1; \ + } while (0) + +#define UNSET_SIGS(nsigs,sigs,flags) \ + do { \ + int signum = (nsigs); \ + while (signum-- > 0) \ + if ((sigs)[signum]) \ + (flags)[signum] = 0; \ + } while (0) -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. */ @@ -228,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. */ @@ -258,11 +257,55 @@ extern int one_stepped; /* From machine dependent code */ extern void single_step (); /* Same. */ #endif /* NO_SINGLE_STEP */ -static void insert_step_breakpoint (); -static void remove_step_breakpoint (); -/*static*/ void wait_for_inferior (); -void init_wait_for_inferior (); -void normal_stop (); + +/* Things to clean up if we QUIT out of resume (). */ +/* ARGSUSED */ +static void +resume_cleanups (arg) + int arg; +{ + normal_stop (); +} + +/* Resume the inferior, but allow a QUIT. This is useful if the user + wants to interrupt some lengthy single-stepping operation + (for child processes, the SIGINT goes to the inferior, and so + we get a SIGINT random_signal, but for remote debugging and perhaps + other targets, that's not true). + + STEP nonzero if we should step (zero to continue instead). + SIG is the signal to give the inferior (zero for none). */ +void +resume (step, sig) + int step; + int 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 */ + step = 0; /* ...and don't ask hardware to do it. */ + } +#endif + + /* Handle any optimized stores to the inferior NOW... */ +#ifdef DO_DEFERRED_STORES + DO_DEFERRED_STORES; +#endif + + target_resume (inferior_pid, step, sig); + discard_cleanups (old_cleanups); +} /* Clear out all variables saying what to do when inferior is continued. @@ -276,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; @@ -311,25 +353,17 @@ proceed (addr, siggnal, step) if (step < 0) stop_after_trap = 1; - if (addr == -1) + if (addr == (CORE_ADDR)-1) { /* If there is a breakpoint at the address we will resume at, 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) { @@ -367,13 +401,8 @@ The same program may be running in another process."); else if (stop_signal < NSIG && !signal_program[stop_signal]) stop_signal= 0; - /* Handle any optimized stores to the inferior NOW... */ -#ifdef DO_DEFERRED_STORES - DO_DEFERRED_STORES; -#endif - /* Resume inferior. */ - target_resume (oneproc || step || bpstat_should_step (), stop_signal); + resume (oneproc || step || bpstat_should_step (), stop_signal); /* Wait for it to stop (if not standalone) and in any case decode why it stopped, and act accordingly. */ @@ -382,21 +411,6 @@ The same program may be running in another process."); normal_stop (); } -#if 0 -/* This might be useful (not sure), but isn't currently used. See also - write_pc(). */ -/* 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; -{ - stop_pc = val; - pc_changed = 1; -} -#endif - /* Record the pc and sp of the program the last time it stopped. These are just used internally by wait_for_inferior, but need to be preserved over calls to it and cleared when the inferior @@ -406,190 +420,7 @@ static CORE_ADDR prev_sp; 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; - - /* 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 (); - -#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. */ - debug_setpgrp = setpgrp (getpid (), getpid ()); - if (0 != debug_setpgrp) - 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 */ - - /* Tell the terminal handling subsystem what tty we plan to run on; - it will now switch to that one if non-null. */ - - new_tty (inferior_io_terminal); - - /* 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. */ - - call_ptrace (0, 0, 0, 0); /* "Trace me, Dr. Memory!" */ - execle (shell_file, shell_file, "-c", shell_command, (char *)0, env); - - fprintf (stderr, "Cannot exec %s: %s.\n", shell_file, - errno < sys_nerr ? sys_errlist[errno] : "unknown error"); - fflush (stderr); - _exit (0177); - } - - /* 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 (); - -#if defined (START_INFERIOR_HOOK) - START_INFERIOR_HOOK (); -#endif - - /* 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 */ - target_resume (0, stop_signal); - } - else - { - /* We handle SIGTRAP, however; it means child did an exec. */ - if (0 == --pending_execs) - break; - target_resume (0, 0); /* Just make it go on */ - } - } - stop_soon_quietly = 0; - - /* 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. */ - target_resume (bpstat_should_step (), 0); - wait_for_inferior (); - normal_stop (); - } -} - + /* Start remote-debugging of a machine over a serial link. */ void @@ -599,6 +430,8 @@ start_remote () clear_proceed_status (); stop_soon_quietly = 1; trap_expected = 0; + wait_for_inferior (); + normal_stop (); } /* Initialize static vars when a new inferior begins. */ @@ -614,62 +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 ((char *)0, from_tty); - 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 (); - 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. @@ -681,46 +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; - 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; -#if 0 - /* This no longer works now that read_register is lazy; - it might try to ptrace when the process is not stopped. */ - prev_pc = read_pc (); - (void) find_pc_partial_function (prev_pc, &prev_func_name, - &prev_func_start); - prev_func_start += FUNCTION_START_OFFSET; - prev_sp = read_register (SP_REGNUM); -#endif /* 0 */ + 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 @@ -731,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 ((char *)0, 0); /* kill mourns as well */ + 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; @@ -753,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; @@ -801,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) @@ -816,69 +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 == NULL) + && 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 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 */ - { - /* 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 (stop_pc - DECR_PC_AFTER_BREAK - == step_resume_break_address - && 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. */ - || (stop_sp INNER_THAN stop_pc - && stop_pc INNER_THAN stop_frame_address) +#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; @@ -886,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. */ @@ -900,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); } @@ -920,247 +794,415 @@ wait_for_inferior () if we took it away. */ else if (printed) target_terminal_inferior (); + + /* 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. */ - - if (!random_signal - && (bpstat_explains_signal (stop_bpstat) || stop_step_resume_break)) - { - /* Does a breakpoint want us to stop? */ - if (bpstat_stop (stop_bpstat)) - { - stop_print_frame = bpstat_should_print (stop_bpstat); - break; - } - /* 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))) - { - remove_step_breakpoint (); - step_resume_break_address = 0; + { + CORE_ADDR jmp_buf_pc; + struct bpstat_what what; - /* If were waiting for a trap, hitting the step_resume_break - doesn't count as getting it. */ - if (trap_expected) - another_trap = 1; - } - /* 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. */ - if (PC_IN_CALL_DUMMY (stop_pc, stop_sp, stop_frame_address)) + what = bpstat_what (stop_bpstat); + + if (what.call_dummy) { - stop_print_frame = 0; stop_stack_dummy = 1; #ifdef HP_OS_BUG trap_expected_after_continue = 1; #endif + } + + 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) + { + 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 */ + 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; + } +#endif /* 0 */ + disable_longjmp_breakpoint(); + handling_longjmp = 0; /* FIXME */ + if (what.main_action == BPSTAT_WHAT_CLEAR_LONGJMP_RESUME) + break; + /* else fallthrough */ + + 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; } - - if (step_resume_break_address) + + if (what.step_resume) + { + 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; + } + } + + /* 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. */ + +#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, 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; +#endif + 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))) { -#if 0 - /* When "next"ing through a function, - This causes an extra stop at the end. - Is there any reason for this? - It's confusing to the user. */ - /* 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; - } -#endif + /* 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 (); + } + + /* 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; + + 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. <==*/ - /* Did we just take a signal? */ - if (IN_SIGTRAMP (stop_pc, stop_func_name) - && !IN_SIGTRAMP (prev_pc, prev_func_name)) + 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) { - /* 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; + /* 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; } - /* ==> See comments at top of file on this algorithm. <==*/ - - else 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 */ - if (step_over_calls > 0 - || (step_over_calls && find_pc_function (stop_pc) == 0)) - { - /* 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 (); - } - /* Subroutine call with source code we should not step over. - Do step to the first line of code in it. */ - else if (step_over_calls) - { - 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 (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; + + 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 */ + 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. */ #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; - } - } - 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 + + 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 (); + + /* And make sure stepping stops right away then. */ + step_range_end = step_range_start; + } + goto keep_going; + } + + /* 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; } - else if (trap_expected - && IN_SIGTRAMP (stop_pc, stop_func_name) - && !IN_SIGTRAMP (prev_pc, prev_func_name)) + 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)) { /* What has happened here is that we have just stepped the inferior with a signal (because it is a signal which shouldn't make 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; } + 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 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 @@ -1179,10 +1221,7 @@ wait_for_inferior () /* 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. */ - target_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 { @@ -1199,7 +1238,7 @@ wait_for_inferior () 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; @@ -1207,9 +1246,8 @@ wait_for_inferior () breakpoints_inserted = 0; } else if (!breakpoints_inserted && - (step_resume_break_address != NULL || !another_trap)) + (step_resume_breakpoint != NULL || !another_trap)) { - insert_step_breakpoint (); breakpoints_failed = insert_breakpoints (); if (breakpoints_failed) break; @@ -1225,26 +1263,20 @@ wait_for_inferior () /* 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 (!stop_breakpoint && (stop_signal != SIGCLD) + 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 */ - target_resume ((step_range_end && !step_resume_break_address) - || (trap_expected && !step_resume_break_address) - || bpstat_should_step (), - stop_signal); + resume (CURRENTLY_STEPPING (), stop_signal); } } + + stop_stepping: if (target_has_execution) { /* Assuming the inferior still exists, set these up for next @@ -1255,6 +1287,7 @@ wait_for_inferior () 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. @@ -1278,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"); } @@ -1312,23 +1342,36 @@ 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; /* Select innermost stack frame except on return from a stack dummy routine, - or if the program has exited. */ + or if the program has exited. Print it without a level number if + we have changed functions or hit a breakpoint. Print source line + if we have one. */ if (!stop_stack_dummy) { select_frame (get_current_frame (), 0); if (stop_print_frame) { - int source_only = bpstat_print (stop_bpstat); - print_sel_frame - (source_only - || (stop_step + int source_only; + + source_only = bpstat_print (stop_bpstat); + source_only = source_only || + ( stop_step && step_frame_address == stop_frame_address - && step_start_function == find_pc_function (stop_pc))); + && step_start_function == find_pc_function (stop_pc)); + + print_stack_frame (selected_frame, -1, source_only? -1: 1); /* Display the auto-display expressions. */ do_displays (); @@ -1349,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 () { @@ -1376,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. */ @@ -1394,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"); + } - if (!args) - error_no_arg ("signal to handle"); + /* Allocate and zero an array of flags for which signals to handle. */ - while (*p) + nsigs = signo_max () + 1; + sigs = (unsigned char *) alloca (nsigs); + memset (sigs, 0, nsigs); + + /* Break the command line up into args. */ + + 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 -. */ - if (signum == 0) + while (*argv != NULL) + { + wordlen = strlen (*argv); + for (digits = 0; isdigit ((*argv)[digits]); digits++) {;} + allsigs = 0; + sigfirst = siglast = -1; + + if (wordlen >= 1 && !strncmp (*argv, "all", 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) { - /* It is the first argument--must be the signal to operate on. */ - if (digits == wordlen) + 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) { - 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", sigfirst, nsigs - 1); + } + if (siglast < 0 || siglast >= nsigs) + { + 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 (); @@ -1503,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. */ @@ -1536,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; @@ -1548,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. @@ -1560,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; @@ -1586,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); @@ -1594,34 +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 (fid == 0 || - FRAME_FP (fid) != inf_status->selected_frame_address || - level != 0) - { -#if 0 - /* 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); } } @@ -1630,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; @@ -1687,4 +1861,3 @@ Pass and Stop may be combined."); signal_print[SIGURG] = 0; #endif /* SIGURG */ } -