-/* Start (run) and stop the inferior process, for GDB.
- Copyright 1986, 1987, 1988, 1989, 1991, 1992 Free Software Foundation, Inc.
+/* Target-struct-independent code to start (run) and stop an inferior process.
+ Copyright 1986, 1987, 1988, 1989, 1991, 1992, 1993
+ Free Software Foundation, Inc.
This file is part of GDB.
#include "defs.h"
#include <string.h>
+#include <ctype.h>
#include "symtab.h"
#include "frame.h"
#include "inferior.h"
#include "breakpoint.h"
#include "wait.h"
#include "gdbcore.h"
-#include "command.h"
-#include "terminal.h" /* For #ifdef TIOCGPGRP and new_tty */
+#include "gdbcmd.h"
#include "target.h"
#include <signal.h>
#include <sys/file.h>
#endif
-#ifdef SET_STACK_LIMIT_HUGE
-#include <sys/time.h>
-#include <sys/resource.h>
-
-extern int original_stack_limit;
-#endif /* SET_STACK_LIMIT_HUGE */
-
/* Prototypes for local functions */
static void
static void
insert_step_breakpoint PARAMS ((void));
-static void
-resume PARAMS ((int, int));
-
static void
resume_cleanups PARAMS ((int));
-extern char **environ;
-
-extern struct target_ops child_ops; /* In inftarg.c */
-
-/* Sigtramp is a routine that the kernel calls (which then calls the
- signal handler). On most machines it is a library routine that
- is linked into the executable.
-
- This macro, given a program counter value and the name of the
- function in which that PC resides (which can be null if the
- name is not known), returns nonzero if the PC and name show
- that we are in sigtramp.
-
- On most machines just see if the name is sigtramp (and if we have
- no name, assume we are not in sigtramp). */
-#if !defined (IN_SIGTRAMP)
-#define IN_SIGTRAMP(pc, name) \
- (name && !strcmp ("_sigtramp", name))
-#endif
+static int
+hook_stop_stub PARAMS ((char *));
/* GET_LONGJMP_TARGET returns the PC at which longjmp() will resume the
program. It needs to examine the jmp_buf argument and extract the PC
#define IN_SOLIB_TRAMPOLINE(pc,name) 0
#endif
-/* Notify other parts of gdb that might care that signal handling may
- have changed for one or more signals. */
-#ifndef NOTICE_SIGNAL_HANDLING_CHANGE
-#define NOTICE_SIGNAL_HANDLING_CHANGE /* No actions */
+/* 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. */
+
+#ifndef INSTRUCTION_NULLIFIED
+#define INSTRUCTION_NULLIFIED 0
#endif
#ifdef TDESC
(flags)[signum] = 0; \
} while (0)
+
+/* Command list pointer for the "stop" placeholder. */
+
+static struct cmd_list_element *stop_command;
+
/* Nonzero if breakpoints are now inserted in the inferior. */
-/* Nonstatic for initialization during xxx_create_inferior. FIXME. */
-/*static*/ int breakpoints_inserted;
+static int breakpoints_inserted;
/* Function inferior was in as of last step command. */
STEP nonzero if we should step (zero to continue instead).
SIG is the signal to give the inferior (zero for none). */
-static void
+void
resume (step, sig)
int step;
int sig;
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)
{
static char *prev_func_name;
\f
-/* 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;
- char *shell_file;
- static char default_shell_file[] = SHELL_FILE;
- int len;
- int pending_execs;
- /* Set debug_fork then attach to the child while it sleeps, to debug. */
- static int debug_fork = 0;
- /* This is set to the result of setpgrp, which if vforked, will be visible
- to you in the parent process. It's only used by humans for debugging. */
- static int debug_setpgrp = 657473;
- char **save_our_env;
-
- /* The user might want tilde-expansion, and in general probably wants
- the program to behave the same way as if run from
- his/her favorite shell. So we let the shell run it for us.
- FIXME, this should probably search the local environment (as
- modified by the setenv command), not the env gdb inherited. */
- shell_file = getenv ("SHELL");
- if (shell_file == NULL)
- shell_file = default_shell_file;
-
- len = 5 + strlen (exec_file) + 1 + strlen (allargs) + 1 + /*slop*/ 10;
- /* If desired, concat something onto the front of ALLARGS.
- SHELL_COMMAND is the result. */
-#ifdef SHELL_COMMAND_CONCAT
- shell_command = (char *) alloca (strlen (SHELL_COMMAND_CONCAT) + len);
- strcpy (shell_command, SHELL_COMMAND_CONCAT);
-#else
- shell_command = (char *) alloca (len);
- shell_command[0] = '\0';
-#endif
- strcat (shell_command, "exec ");
- strcat (shell_command, exec_file);
- strcat (shell_command, " ");
- strcat (shell_command, allargs);
-
- /* exec is said to fail if the executable is open. */
- close_exec_file ();
-
- /* Retain a copy of our environment variables, since the child will
- replace the value of environ and if we're vforked, we have to
- restore it. */
- save_our_env = environ;
-
- /* Tell the terminal handling subsystem what tty we plan to run on;
- it will just record the information for later. */
-
- new_tty_prefork (inferior_io_terminal);
-
- /* It is generally good practice to flush any possible pending stdio
- output prior to doing a fork, to avoid the possibility of both the
- parent and child flushing the same data after the fork. */
-
- fflush (stdout);
- fflush (stderr);
-
-#if defined(USG) && !defined(HAVE_VFORK)
- pid = fork ();
-#else
- if (debug_fork)
- pid = fork ();
- else
- pid = vfork ();
-#endif
-
- if (pid < 0)
- perror_with_name ("vfork");
-
- if (pid == 0)
- {
- if (debug_fork)
- sleep (debug_fork);
-
-#ifdef TIOCGPGRP
- /* Run inferior in a separate process group. */
-#ifdef NEED_POSIX_SETPGID
- debug_setpgrp = setpgid (0, 0);
-#else
-#if defined(USG) && !defined(SETPGRP_ARGS)
- debug_setpgrp = setpgrp ();
-#else
- debug_setpgrp = setpgrp (getpid (), getpid ());
-#endif /* USG */
-#endif /* NEED_POSIX_SETPGID */
- if (debug_setpgrp == -1)
- perror("setpgrp failed in child");
-#endif /* TIOCGPGRP */
-
-#ifdef SET_STACK_LIMIT_HUGE
- /* Reset the stack limit back to what it was. */
- {
- struct rlimit rlim;
-
- getrlimit (RLIMIT_STACK, &rlim);
- rlim.rlim_cur = original_stack_limit;
- setrlimit (RLIMIT_STACK, &rlim);
- }
-#endif /* SET_STACK_LIMIT_HUGE */
-
- /* Ask the tty subsystem to switch to the one we specified earlier
- (or to share the current terminal, if none was specified). */
-
- new_tty ();
-
- /* Changing the signal handlers for the inferior after
- a vfork can also change them for the superior, so we don't mess
- with signals here. See comments in
- initialize_signals for how we get the right signal handlers
- for the inferior. */
-
-#ifdef USE_PROC_FS
- /* Use SVR4 /proc interface */
- proc_set_exec_trap ();
-#else
- /* "Trace me, Dr. Memory!" */
- call_ptrace (0, 0, (PTRACE_ARG3_TYPE) 0, 0);
-#endif
-
- /* There is no execlpe call, so we have to set the environment
- for our child in the global variable. If we've vforked, this
- clobbers the parent, but environ is restored a few lines down
- in the parent. By the way, yes we do need to look down the
- path to find $SHELL. Rich Pixley says so, and I agree. */
- environ = env;
- execlp (shell_file, shell_file, "-c", shell_command, (char *)0);
-
- fprintf (stderr, "Cannot exec %s: %s.\n", shell_file,
- safe_strerror (errno));
- fflush (stderr);
- _exit (0177);
- }
-
- /* Restore our environment in case a vforked child clob'd it. */
- environ = save_our_env;
-
- /* Now that we have a child process, make it our target. */
- push_target (&child_ops);
-
-#ifdef CREATE_INFERIOR_HOOK
- CREATE_INFERIOR_HOOK (pid);
-#endif
-
-/* The process was started by the fork that created it,
- but it will have stopped one instruction after execing the shell.
- Here we must get it up to actual execution of the real program. */
-
- inferior_pid = pid; /* Needed for wait_for_inferior stuff below */
-
- clear_proceed_status ();
-
- /* We will get a trace trap after one instruction.
- Continue it automatically. Eventually (after shell does an exec)
- it will get another trace trap. Then insert breakpoints and continue. */
-
-#ifdef START_INFERIOR_TRAPS_EXPECTED
- pending_execs = START_INFERIOR_TRAPS_EXPECTED;
-#else
- pending_execs = 2;
-#endif
-
- init_wait_for_inferior ();
-
- /* Set up the "saved terminal modes" of the inferior
- based on what modes we are starting it with. */
- target_terminal_init ();
-
- /* Install inferior's terminal modes. */
- target_terminal_inferior ();
-
- while (1)
- {
- stop_soon_quietly = 1; /* Make wait_for_inferior be quiet */
- wait_for_inferior ();
- if (stop_signal != SIGTRAP)
- {
- /* Let shell child handle its own signals in its own way */
- /* FIXME, what if child has exit()ed? Must exit loop somehow */
- resume (0, stop_signal);
- }
- else
- {
- /* We handle SIGTRAP, however; it means child did an exec. */
- if (0 == --pending_execs)
- break;
- resume (0, 0); /* Just make it go on */
- }
- }
- stop_soon_quietly = 0;
-
- /* We are now in the child process of interest, having exec'd the
- correct program, and are poised at the first instruction of the
- new program. */
-#ifdef SOLIB_CREATE_INFERIOR_HOOK
- SOLIB_CREATE_INFERIOR_HOOK (pid);
-#endif
-
- /* Pedal to the metal. Away we go. */
- proceed ((CORE_ADDR) -1, 0, 0);
-}
-
/* Start remote-debugging of a machine over a serial link. */
void
}
-/* 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;
-{
- 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 (pid == getpid()) /* Trying to masturbate? */
- error ("I refuse to debug myself!");
-
- if (target_has_execution)
- {
- if (query ("A program is being debugged already. Kill it? "))
- target_kill ();
- else
- error ("Inferior not killed.");
- }
-
- exec_file = (char *) get_exec_file (1);
-
- if (from_tty)
- {
- printf ("Attaching program: %s pid %d\n",
- exec_file, pid);
- fflush (stdout);
- }
-
- attach (pid);
- inferior_pid = pid;
- push_target (&child_ops);
-
- mark_breakpoints_out ();
- target_terminal_init ();
- clear_proceed_status ();
- stop_soon_quietly = 1;
- /*proceed (-1, 0, -2);*/
- target_terminal_inferior ();
- wait_for_inferior ();
-#ifdef SOLIB_ADD
- SOLIB_ADD ((char *)0, from_tty, (struct target_ops *)0);
-#endif
- normal_stop ();
-#endif /* ATTACH_DETACH */
-}
\f
/* Wait for control to return from inferior to debugger.
If inferior gets a signal, we may decide to start it up again
int remove_breakpoints_on_following_step = 0;
int current_line;
int handling_longjmp = 0; /* FIXME */
+ struct symtab *symtab;
sal = find_pc_line(prev_pc, 0);
current_line = sal.line;
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 ()));
stop_frame_address = FRAME_FP (get_current_frame ());
stop_sp = read_register (SP_REGNUM);
+/* XXX - FIXME. Need to figure out a better way to grab the stack seg reg. */
+#ifdef GDB_TARGET_IS_H8500
+ stop_sp |= read_register (SEG_T_REGNUM) << 16;
+#endif
stop_func_start = 0;
stop_func_name = 0;
/* Don't care about return value; stop_func_start and stop_func_name
if (DECR_PC_AFTER_BREAK)
{
stop_pc -= DECR_PC_AFTER_BREAK;
- write_register (PC_REGNUM, stop_pc);
- pc_changed = 0;
+ write_pc (stop_pc);
}
}
else
else if (printed)
target_terminal_inferior ();
+ /* Clear the signal if it should not be passed. */
+ if (signal_program[stop_signal] == 0)
+ stop_signal = 0;
+
/* Note that virtually all the code below does `if !random_signal'.
Perhaps this code should end with a goto or continue. At least
one (now fixed) bug was caused by this -- a !random_signal was
/* Handle cases caused by hitting a breakpoint. */
if (!random_signal)
- if (bpstat_explains_signal (stop_bpstat))
- {
- CORE_ADDR jmp_buf_pc;
+ {
+ CORE_ADDR jmp_buf_pc;
+ enum bpstat_what what = bpstat_what (stop_bpstat);
- switch (stop_bpstat->breakpoint_at->type) /* FIXME */
- {
- /* If we hit the breakpoint at longjmp, disable it for the
- duration of this command. Then, install a temporary
- breakpoint at the target of the jmp_buf. */
- case bp_longjmp:
- disable_longjmp_breakpoint();
- remove_breakpoints ();
- breakpoints_inserted = 0;
- if (!GET_LONGJMP_TARGET(&jmp_buf_pc)) goto keep_going;
+ switch (what)
+ {
+ 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 */
- remove_step_breakpoint ();
- step_resume_break_address = 0;
- stop_step_resume_break = 0;
+ /* Need to blow away step-resume breakpoint, as it
+ interferes with us */
+ remove_step_breakpoint ();
+ step_resume_break_address = 0;
+ stop_step_resume_break = 0;
-#if 0 /* FIXME - Need to implement nested temporary breakpoints */
- if (step_over_calls > 0)
- set_longjmp_resume_breakpoint(jmp_buf_pc,
- get_current_frame());
- else
+#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;
+ set_longjmp_resume_breakpoint(jmp_buf_pc, NULL);
+ handling_longjmp = 1; /* FIXME */
+ goto keep_going;
- case bp_longjmp_resume:
- remove_breakpoints ();
- breakpoints_inserted = 0;
-#if 0 /* FIXME - Need to implement nested temporary breakpoints */
- if (step_over_calls
- && (stop_frame_address
- INNER_THAN step_frame_address))
- {
- another_trap = 1;
- goto keep_going;
- }
+ 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 */
+ disable_longjmp_breakpoint();
+ handling_longjmp = 0; /* FIXME */
+ if (what == BPSTAT_WHAT_CLEAR_LONGJMP_RESUME)
break;
+ /* else fallthrough */
- default:
- fprintf(stderr, "Unknown breakpoint type %d\n",
- stop_bpstat->breakpoint_at->type);
- case bp_watchpoint:
- case bp_breakpoint:
- case bp_until:
- case bp_finish:
- /* Does a breakpoint want us to stop? */
- if (bpstat_stop (stop_bpstat))
- {
- stop_print_frame = bpstat_should_print (stop_bpstat);
- goto stop_stepping;
- }
- /* Otherwise, must remove breakpoints and single-step
- to get us past the one we hit. */
- else
- {
- remove_breakpoints ();
- remove_step_breakpoint ();
- breakpoints_inserted = 0;
- another_trap = 1;
- }
- break;
- }
- }
- else if (stop_step_resume_break)
+ case BPSTAT_WHAT_SINGLE:
+ if (breakpoints_inserted)
+ remove_breakpoints ();
+ remove_step_breakpoint ();
+ 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;
+ goto stop_stepping;
+
+ case BPSTAT_WHAT_STOP_SILENT:
+ stop_print_frame = 0;
+ goto stop_stepping;
+
+ case BPSTAT_WHAT_KEEP_CHECKING:
+ break;
+ }
+
+ if (stop_step_resume_break)
{
/* But if we have hit the step-resumption breakpoint,
remove it. It has done its job getting us here.
another_trap = 1;
}
}
+ }
/* We come here if we hit a breakpoint but should not
stop for it. Possibly we also were stepping
to a subroutine call that we should proceed to the end of. */
else if (!random_signal && step_range_end)
{
- if (stop_func_start)
- {
- prologue_pc = stop_func_start;
- SKIP_PROLOGUE (prologue_pc);
- }
-
/* Did we just take a signal? */
if (IN_SIGTRAMP (stop_pc, stop_func_name)
&& !IN_SIGTRAMP (prev_pc, prev_func_name))
goto save_pc;
}
+ if (stop_func_start)
+ {
+ /* Do this after the IN_SIGTRAMP check; it might give
+ an error. */
+ prologue_pc = stop_func_start;
+ SKIP_PROLOGUE (prologue_pc);
+ }
+
/* ==> See comments at top of file on this algorithm. <==*/
if ((stop_pc == stop_func_start
if (tmp != 0)
stop_func_start = tmp;
- if (find_pc_function (stop_func_start) != 0)
- goto step_into_function;
+ symtab = find_pc_symtab (stop_func_start);
+ if (symtab && LINETABLE (symtab))
+ goto step_into_function;
step_over_function:
/* A subroutine call has happened. */
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");
+ }
+
if (!target_has_stack)
return;
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);
+}
+
\f
static void
insert_step_breakpoint ()
argv++;
}
- NOTICE_SIGNAL_HANDLING_CHANGE;
+ target_notice_signals();
if (from_tty)
{
Ignore is a synonym for nopass and noignore is a synonym for pass.\n\
Pass and Stop may be combined.");
+ 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 inferior program stops.", &cmdlist);
+
numsigs = signo_max () + 1;
signal_stop = (unsigned char *)
xmalloc (sizeof (signal_stop[0]) * numsigs);