X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Finferior.h;h=9beedf9eadbcde988b2523e6133e7d756b116fa3;hb=ab9d50c7a84d3313a3a8c0d23c8d2b01fc3c507e;hp=5db853eaca451dd45d5d3307cd2033b7b04d689a;hpb=34517ebc854c0fc0314823defa19c4d79e317e12;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/inferior.h b/gdb/inferior.h index 5db853eaca..9beedf9ead 100644 --- a/gdb/inferior.h +++ b/gdb/inferior.h @@ -1,73 +1,68 @@ /* Variables that describe the inferior process running under GDB: Where it is, why it stopped, and how to step it. - Copyright 1986, 1989, 1992 Free Software Foundation, Inc. + Copyright 1986, 1989, 1992, 1996, 1998 Free Software Foundation, Inc. -This file is part of GDB. + This file is part of GDB. -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 2 of the License, or -(at your option) any later version. + 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 2 of the License, or + (at your option) any later version. -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. + 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 this program; if not, write to the Free Software -Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ #if !defined (INFERIOR_H) #define INFERIOR_H 1 -/* For symtab_and_line */ -#include "symtab.h" - /* For bpstat. */ #include "breakpoint.h" -/* For FRAME_ADDR. */ -#include "frame.h" +/* For enum target_signal. */ +#include "target.h" -/* - * Structure in which to save the status of the inferior. Save - * through "save_inferior_status", restore through - * "restore_inferior_status". - * This pair of routines should be called around any transfer of - * control to the inferior which you don't want showing up in your - * control variables. - */ -struct inferior_status { - int pc_changed; - int stop_signal; - int stop_pc; - FRAME_ADDR stop_frame_address; - bpstat stop_bpstat; - int stop_step; - int stop_stack_dummy; - int stopped_by_random_signal; - int trap_expected; - CORE_ADDR step_range_start; - CORE_ADDR step_range_end; - FRAME_ADDR step_frame_address; - int step_over_calls; - CORE_ADDR step_resume_break_address; - int stop_after_trap; - int stop_soon_quietly; - FRAME_ADDR selected_frame_address; - int selected_level; - char stop_registers[REGISTER_BYTES]; - int breakpoint_proceeded; - int restore_stack_info; - int proceed_to_finish; -}; +/* Structure in which to save the status of the inferior. Create/Save + through "save_inferior_status", restore through + "restore_inferior_status". -extern void -save_inferior_status PARAMS ((struct inferior_status *, int)); + This pair of routines should be called around any transfer of + control to the inferior which you don't want showing up in your + control variables. */ -extern void -restore_inferior_status PARAMS ((struct inferior_status *)); +struct inferior_status; + +extern struct inferior_status *save_inferior_status PARAMS ((int)); + +extern void restore_inferior_status PARAMS ((struct inferior_status *)); + +extern struct cleanup *make_cleanup_restore_inferior_status (struct inferior_status *); + +extern void discard_inferior_status PARAMS ((struct inferior_status *)); + +extern void write_inferior_status_register PARAMS ((struct inferior_status * inf_status, int regno, LONGEST val)); + +/* This macro gives the number of registers actually in use by the + inferior. This may be less than the total number of registers, + perhaps depending on the actual CPU in use or program being run. */ + +#ifndef ARCH_NUM_REGS +#define ARCH_NUM_REGS NUM_REGS +#endif + +extern void set_sigint_trap PARAMS ((void)); + +extern void clear_sigint_trap PARAMS ((void)); + +extern void set_sigio_trap PARAMS ((void)); + +extern void clear_sigio_trap PARAMS ((void)); /* File name for default use for standard in/out in the inferior. */ @@ -77,157 +72,217 @@ extern char *inferior_io_terminal; extern int inferior_pid; -/* Character array containing an image of the inferior programs' registers. */ +/* Is the inferior running right now, as a result of a 'run&', + 'continue&' etc command? This is used in asycn gdb to determine + whether a command that the user enters while the target is running + is allowed or not. */ +extern int target_executing; -extern char registers[]; +/* Are we simulating synchronous execution? This is used in async gdb + to implement the 'run', 'continue' etc commands, which will not + redisplay the prompt until the execution is actually over. */ +extern int sync_execution; -/* Array of validity bits (one per register). Nonzero at position XXX_REGNUM - means that `registers' contains a valid copy of inferior register XXX. */ +/* This is only valid when inferior_pid is non-zero. -extern char register_valid[NUM_REGS]; + If this is 0, then exec events should be noticed and responded to + by the debugger (i.e., be reported to the user). -extern void -clear_proceed_status PARAMS ((void)); + If this is > 0, then that many subsequent exec events should be + ignored (i.e., not be reported to the user). + */ +extern int inferior_ignoring_startup_exec_events; -extern void -proceed PARAMS ((CORE_ADDR, int, int)); +/* This is only valid when inferior_ignoring_startup_exec_events is + zero. -extern void -kill_inferior PARAMS ((void)); + Some targets (stupidly) report more than one exec event per actual + call to an event() system call. If only the last such exec event + need actually be noticed and responded to by the debugger (i.e., + be reported to the user), then this is the number of "leading" + exec events which should be ignored. + */ +extern int inferior_ignoring_leading_exec_events; -extern void -generic_mourn_inferior PARAMS ((void)); +/* Inferior environment. */ -extern void -terminal_ours PARAMS ((void)); +extern struct environ *inferior_environ; -extern void -run_stack_dummy PARAMS ((CORE_ADDR, char [REGISTER_BYTES])); +/* Character array containing an image of the inferior programs' + registers. */ -extern CORE_ADDR -read_pc PARAMS ((void)); +extern char *registers; -extern void -write_pc PARAMS ((CORE_ADDR)); +/* Character array containing the current state of each register + (unavailable<0, valid=0, invalid>0). */ -extern void -wait_for_inferior PARAMS ((void)); +extern signed char *register_valid; -extern void -init_wait_for_inferior PARAMS ((void)); +extern void clear_proceed_status PARAMS ((void)); -extern void -close_exec_file PARAMS ((void)); +extern void proceed PARAMS ((CORE_ADDR, enum target_signal, int)); -extern void -reopen_exec_file PARAMS ((void)); +extern void kill_inferior PARAMS ((void)); + +extern void generic_mourn_inferior PARAMS ((void)); + +extern void terminal_ours PARAMS ((void)); + +extern int run_stack_dummy PARAMS ((CORE_ADDR, char *)); + +extern CORE_ADDR read_pc PARAMS ((void)); + +extern CORE_ADDR read_pc_pid PARAMS ((int)); + +extern CORE_ADDR generic_target_read_pc PARAMS ((int)); + +extern void write_pc PARAMS ((CORE_ADDR)); + +extern void write_pc_pid PARAMS ((CORE_ADDR, int)); + +extern void generic_target_write_pc PARAMS ((CORE_ADDR, int)); + +extern CORE_ADDR read_sp PARAMS ((void)); + +extern CORE_ADDR generic_target_read_sp PARAMS ((void)); + +extern void write_sp PARAMS ((CORE_ADDR)); + +extern void generic_target_write_sp PARAMS ((CORE_ADDR)); + +extern CORE_ADDR read_fp PARAMS ((void)); + +extern CORE_ADDR generic_target_read_fp PARAMS ((void)); + +extern void write_fp PARAMS ((CORE_ADDR)); + +extern void generic_target_write_fp PARAMS ((CORE_ADDR)); + +extern CORE_ADDR generic_pointer_to_address (struct type *type, char *buf); + +extern void generic_address_to_pointer (struct type *type, char *buf, + CORE_ADDR addr); + +extern void wait_for_inferior PARAMS ((void)); + +extern void fetch_inferior_event PARAMS ((void *)); + +extern void init_wait_for_inferior PARAMS ((void)); + +extern void close_exec_file PARAMS ((void)); + +extern void reopen_exec_file PARAMS ((void)); /* The `resume' routine should only be called in special circumstances. Normally, use `proceed', which handles a lot of bookkeeping. */ -extern void -resume PARAMS ((int, int)); + +extern void resume PARAMS ((int, enum target_signal)); /* From misc files */ -extern void -store_inferior_registers PARAMS ((int)); +extern void store_inferior_registers PARAMS ((int)); -extern void -fetch_inferior_registers PARAMS ((int)); +extern void fetch_inferior_registers PARAMS ((int)); -extern void -solib_create_inferior_hook PARAMS ((void)); +extern void solib_create_inferior_hook PARAMS ((void)); -extern void -child_terminal_info PARAMS ((char *, int)); +extern void child_terminal_info PARAMS ((char *, int)); -extern void -term_info PARAMS ((char *, int)); +extern void term_info PARAMS ((char *, int)); -extern void -terminal_ours_for_output PARAMS ((void)); +extern void terminal_ours_for_output PARAMS ((void)); -extern void -terminal_inferior PARAMS ((void)); +extern void terminal_inferior PARAMS ((void)); -extern void -terminal_init_inferior PARAMS ((void)); +extern void terminal_init_inferior PARAMS ((void)); -/* From infptrace.c */ +extern void terminal_init_inferior_with_pgrp PARAMS ((int pgrp)); -extern int -attach PARAMS ((int)); +/* From infptrace.c or infttrace.c */ -void -detach PARAMS ((int)); +extern int attach PARAMS ((int)); -extern void -child_resume PARAMS ((int, int)); +#if !defined(REQUIRE_ATTACH) +#define REQUIRE_ATTACH attach +#endif + +#if !defined(REQUIRE_DETACH) +#define REQUIRE_DETACH(pid,siggnal) detach (siggnal) +#endif + +extern void detach PARAMS ((int)); + +/* PTRACE method of waiting for inferior process. */ +int ptrace_wait PARAMS ((int, int *)); + +extern void child_resume PARAMS ((int, int, enum target_signal)); #ifndef PTRACE_ARG3_TYPE #define PTRACE_ARG3_TYPE int /* Correct definition for most systems. */ #endif -extern int -call_ptrace PARAMS ((int, int, PTRACE_ARG3_TYPE, int)); +extern int call_ptrace PARAMS ((int, int, PTRACE_ARG3_TYPE, int)); + +extern void pre_fork_inferior PARAMS ((void)); /* From procfs.c */ -extern int -proc_iterate_over_mappings PARAMS ((int (*) (int, CORE_ADDR))); +extern int proc_iterate_over_mappings PARAMS ((int (*)(int, CORE_ADDR))); -extern void -proc_signal_handling_change PARAMS ((void)); +extern int procfs_first_available PARAMS ((void)); /* From fork-child.c */ +extern void fork_inferior PARAMS ((char *, char *, char **, + void (*)(void), + void (*)(int), + void (*)(void), + char *)); + + extern void -fork_inferior PARAMS ((char *, char *, char **, - void (*) (void), - void (*) (int))); +clone_and_follow_inferior PARAMS ((int, int *)); + +extern void startup_inferior PARAMS ((int)); /* From inflow.c */ -extern void -new_tty_prefork PARAMS ((char *)); +extern void new_tty_prefork PARAMS ((char *)); + +extern int gdb_has_a_terminal PARAMS ((void)); /* From infrun.c */ -extern void -start_remote PARAMS ((void)); +extern void start_remote PARAMS ((void)); -extern void -normal_stop PARAMS ((void)); +extern void normal_stop PARAMS ((void)); + +extern int signal_stop_state PARAMS ((int)); + +extern int signal_print_state PARAMS ((int)); -extern int -signal_stop_state PARAMS ((int)); +extern int signal_pass_state PARAMS ((int)); -extern int -signal_print_state PARAMS ((int)); +extern int signal_stop_update PARAMS ((int, int)); -extern int -signal_pass_state PARAMS ((int)); +extern int signal_print_update PARAMS ((int, int)); + +extern int signal_pass_update PARAMS ((int, int)); /* From infcmd.c */ -extern void -tty_command PARAMS ((char *, int)); +extern void tty_command PARAMS ((char *, int)); -extern void -attach_command PARAMS ((char *, int)); +extern void attach_command PARAMS ((char *, int)); /* Last signal that the inferior received (why it stopped). */ -extern int stop_signal; +extern enum target_signal stop_signal; /* Address at which inferior stopped. */ extern CORE_ADDR stop_pc; -/* Stack frame when program stopped. */ - -extern FRAME_ADDR stop_frame_address; - /* Chain containing status of breakpoint(s) that we have stopped at. */ extern bpstat stop_bpstat; @@ -252,16 +307,25 @@ extern int stopped_by_random_signal; /* Range to single step within. If this is nonzero, respond to a single-step signal - by continuing to step if the pc is in this range. */ + by continuing to step if the pc is in this range. + + If step_range_start and step_range_end are both 1, it means to step for + a single instruction (FIXME: it might clean up wait_for_inferior in a + minor way if this were changed to the address of the instruction and + that address plus one. But maybe not.). */ -extern CORE_ADDR step_range_start; /* Inclusive */ -extern CORE_ADDR step_range_end; /* Exclusive */ +extern CORE_ADDR step_range_start; /* Inclusive */ +extern CORE_ADDR step_range_end; /* Exclusive */ /* Stack frame address as of when stepping command was issued. This is how we know when we step into a subroutine call, and how to set the frame for the breakpoint used to step out. */ -extern FRAME_ADDR step_frame_address; +extern CORE_ADDR step_frame_address; + +/* Our notion of the current stack pointer. */ + +extern CORE_ADDR step_sp; /* 1 means step over all subroutine calls. -1 means step over calls to undebuggable functions. */ @@ -291,47 +355,173 @@ extern int proceed_to_finish; Thus this contains the return value from the called function (assuming values are returned in a register). */ -extern char stop_registers[REGISTER_BYTES]; - -/* Nonzero if pc has been changed by the debugger - since the inferior stopped. */ - -extern int pc_changed; +extern char *stop_registers; /* Nonzero if the child process in inferior_pid was attached rather than forked. */ extern int attach_flag; +/* 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) +#if defined (SIGTRAMP_START) +#define IN_SIGTRAMP(pc, name) \ + ((pc) >= SIGTRAMP_START(pc) \ + && (pc) < SIGTRAMP_END(pc) \ + ) +#else +#define IN_SIGTRAMP(pc, name) \ + (name && STREQ ("_sigtramp", name)) +#endif +#endif + /* Possible values for CALL_DUMMY_LOCATION. */ #define ON_STACK 1 #define BEFORE_TEXT_END 2 #define AFTER_TEXT_END 3 +#define AT_ENTRY_POINT 4 + +#if !defined (USE_GENERIC_DUMMY_FRAMES) +#define USE_GENERIC_DUMMY_FRAMES 0 +#endif #if !defined (CALL_DUMMY_LOCATION) #define CALL_DUMMY_LOCATION ON_STACK #endif /* No CALL_DUMMY_LOCATION. */ -/* Are we in a call dummy? The code below which allows DECR_PC_AFTER_BREAK - below is for infrun.c, which may give the macro a pc without that - subtracted out. */ -#if !defined (PC_IN_CALL_DUMMY) -#if CALL_DUMMY_LOCATION == BEFORE_TEXT_END -extern CORE_ADDR text_end; -#define PC_IN_CALL_DUMMY(pc, sp, frame_address) \ - ((pc) >= text_end - CALL_DUMMY_LENGTH \ - && (pc) <= text_end + DECR_PC_AFTER_BREAK) -#else /* Not before text_end. */ -#if CALL_DUMMY_LOCATION == AFTER_TEXT_END -extern CORE_ADDR text_end; -#define PC_IN_CALL_DUMMY(pc, sp, frame_address) \ - ((pc) >= text_end \ - && (pc) <= text_end + CALL_DUMMY_LENGTH + DECR_PC_AFTER_BREAK) -#else /* On stack. */ -#define PC_IN_CALL_DUMMY(pc, sp, frame_address) \ - ((sp) INNER_THAN (pc) && (pc) INNER_THAN (frame_address)) -#endif /* On stack. */ -#endif /* Not before text_end. */ -#endif /* No PC_IN_CALL_DUMMY. */ - -#endif /* !defined (INFERIOR_H) */ +#if !defined (CALL_DUMMY_ADDRESS) +#define CALL_DUMMY_ADDRESS() (internal_error ("CALL_DUMMY_ADDRESS"), 0) +#endif +#if !defined (CALL_DUMMY_START_OFFSET) +#define CALL_DUMMY_START_OFFSET (internal_error ("CALL_DUMMY_START_OFFSET"), 0) +#endif +#if !defined (CALL_DUMMY_BREAKPOINT_OFFSET) +#define CALL_DUMMY_BREAKPOINT_OFFSET_P (0) +#define CALL_DUMMY_BREAKPOINT_OFFSET (internal_error ("CALL_DUMMY_BREAKPOINT_OFFSET"), 0) +#endif +#if !defined CALL_DUMMY_BREAKPOINT_OFFSET_P +#define CALL_DUMMY_BREAKPOINT_OFFSET_P (1) +#endif +#if !defined (CALL_DUMMY_LENGTH) +#define CALL_DUMMY_LENGTH (internal_error ("CALL_DUMMY_LENGTH"), 0) +#endif + +#if defined (CALL_DUMMY_STACK_ADJUST) +#if !defined (CALL_DUMMY_STACK_ADJUST_P) +#define CALL_DUMMY_STACK_ADJUST_P (1) +#endif +#endif +#if !defined (CALL_DUMMY_STACK_ADJUST) +#define CALL_DUMMY_STACK_ADJUST (internal_error ("CALL_DUMMY_STACK_ADJUST"), 0) +#endif +#if !defined (CALL_DUMMY_STACK_ADJUST_P) +#define CALL_DUMMY_STACK_ADJUST_P (0) +#endif + +/* FIXME: cagney/2000-04-17: gdbarch should manage this. The default + shouldn't be necessary. */ + +#if !defined (CALL_DUMMY_P) +#if defined (CALL_DUMMY) +#define CALL_DUMMY_P 1 +#else +#define CALL_DUMMY_P 0 +#endif +#endif + +#if !defined PUSH_DUMMY_FRAME +#define PUSH_DUMMY_FRAME (internal_error ("PUSH_DUMMY_FRAME"), 0) +#endif + +#if !defined FIX_CALL_DUMMY +#define FIX_CALL_DUMMY(a1,a2,a3,a4,a5,a6,a7) (internal_error ("FIX_CALL_DUMMY"), 0) +#endif + +#if !defined STORE_STRUCT_RETURN +#define STORE_STRUCT_RETURN(a1,a2) (internal_error ("STORE_STRUCT_RETURN"), 0) +#endif + + +/* Are we in a call dummy? */ + +extern int pc_in_call_dummy_before_text_end PARAMS ((CORE_ADDR pc, CORE_ADDR sp, CORE_ADDR frame_address)); +#if !GDB_MULTI_ARCH +#if !defined (PC_IN_CALL_DUMMY) && CALL_DUMMY_LOCATION == BEFORE_TEXT_END +#define PC_IN_CALL_DUMMY(pc, sp, frame_address) pc_in_call_dummy_before_text_end (pc, sp, frame_address) +#endif /* Before text_end. */ +#endif + +extern int pc_in_call_dummy_after_text_end PARAMS ((CORE_ADDR pc, CORE_ADDR sp, CORE_ADDR frame_address)); +#if !GDB_MULTI_ARCH +#if !defined (PC_IN_CALL_DUMMY) && CALL_DUMMY_LOCATION == AFTER_TEXT_END +#define PC_IN_CALL_DUMMY(pc, sp, frame_address) pc_in_call_dummy_after_text_end (pc, sp, frame_address) +#endif +#endif + +extern int pc_in_call_dummy_on_stack PARAMS ((CORE_ADDR pc, CORE_ADDR sp, CORE_ADDR frame_address)); +#if !GDB_MULTI_ARCH +#if !defined (PC_IN_CALL_DUMMY) && CALL_DUMMY_LOCATION == ON_STACK +#define PC_IN_CALL_DUMMY(pc, sp, frame_address) pc_in_call_dummy_on_stack (pc, sp, frame_address) +#endif +#endif + +extern int pc_in_call_dummy_at_entry_point PARAMS ((CORE_ADDR pc, CORE_ADDR sp, CORE_ADDR frame_address)); +#if !GDB_MULTI_ARCH +#if !defined (PC_IN_CALL_DUMMY) && CALL_DUMMY_LOCATION == AT_ENTRY_POINT +#define PC_IN_CALL_DUMMY(pc, sp, frame_address) pc_in_call_dummy_at_entry_point (pc, sp, frame_address) +#endif +#endif + +/* It's often not enough for our clients to know whether the PC is merely + somewhere within the call dummy. They may need to know whether the + call dummy has actually completed. (For example, wait_for_inferior + wants to know when it should truly stop because the call dummy has + completed. If we're single-stepping because of slow watchpoints, + then we may find ourselves stopped at the entry of the call dummy, + and want to continue stepping until we reach the end.) + + Note that this macro is intended for targets (like HP-UX) which + require more than a single breakpoint in their call dummies, and + therefore cannot use the CALL_DUMMY_BREAKPOINT_OFFSET mechanism. + + If a target does define CALL_DUMMY_BREAKPOINT_OFFSET, then this + default implementation of CALL_DUMMY_HAS_COMPLETED is sufficient. + Else, a target may wish to supply an implementation that works in + the presense of multiple breakpoints in its call dummy. + */ +#if !defined(CALL_DUMMY_HAS_COMPLETED) +#define CALL_DUMMY_HAS_COMPLETED(pc, sp, frame_address) \ + PC_IN_CALL_DUMMY((pc), (sp), (frame_address)) +#endif + +/* If STARTUP_WITH_SHELL is set, GDB's "run" + will attempts to start up the debugee under a shell. + This is in order for argument-expansion to occur. E.g., + (gdb) run * + The "*" gets expanded by the shell into a list of files. + While this is a nice feature, it turns out to interact badly + with some of the catch-fork/catch-exec features we have added. + In particular, if the shell does any fork/exec's before + the exec of the target program, that can confuse GDB. + To disable this feature, set STARTUP_WITH_SHELL to 0. + To enable this feature, set STARTUP_WITH_SHELL to 1. + The catch-exec traps expected during start-up will + be 1 if target is not started up with a shell, 2 if it is. + - RT + If you disable this, you need to decrement + START_INFERIOR_TRAPS_EXPECTED in tm.h. */ +#define STARTUP_WITH_SHELL 1 +#if !defined(START_INFERIOR_TRAPS_EXPECTED) +#define START_INFERIOR_TRAPS_EXPECTED 2 +#endif +#endif /* !defined (INFERIOR_H) */