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. */
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
#if !defined (TARGET_H)
#define TARGET_H
dummy_stratum, /* The lowest of the low */
file_stratum, /* Executable files, etc */
core_stratum, /* Core dump files */
+ download_stratum, /* Downloading of remote targets */
process_stratum /* Executing processes */
};
/* Used some places (e.g. stop_signal) to record the concept that
there is no signal. */
TARGET_SIGNAL_0 = 0,
+ TARGET_SIGNAL_FIRST = 0,
TARGET_SIGNAL_HUP = 1,
TARGET_SIGNAL_INT = 2,
TARGET_SIGNAL_QUIT = 3,
TARGET_SIGNAL_MSG = 41,
TARGET_SIGNAL_SOUND = 42,
TARGET_SIGNAL_SAK = 43,
-
+ TARGET_SIGNAL_PRIO = 44,
+ TARGET_SIGNAL_REALTIME_33 = 45,
+ TARGET_SIGNAL_REALTIME_34 = 46,
+ TARGET_SIGNAL_REALTIME_35 = 47,
+ TARGET_SIGNAL_REALTIME_36 = 48,
+ TARGET_SIGNAL_REALTIME_37 = 49,
+ TARGET_SIGNAL_REALTIME_38 = 50,
+ TARGET_SIGNAL_REALTIME_39 = 51,
+ TARGET_SIGNAL_REALTIME_40 = 52,
+ TARGET_SIGNAL_REALTIME_41 = 53,
+ TARGET_SIGNAL_REALTIME_42 = 54,
+ TARGET_SIGNAL_REALTIME_43 = 55,
+ TARGET_SIGNAL_REALTIME_44 = 56,
+ TARGET_SIGNAL_REALTIME_45 = 57,
+ TARGET_SIGNAL_REALTIME_46 = 58,
+ TARGET_SIGNAL_REALTIME_47 = 59,
+ TARGET_SIGNAL_REALTIME_48 = 60,
+ TARGET_SIGNAL_REALTIME_49 = 61,
+ TARGET_SIGNAL_REALTIME_50 = 62,
+ TARGET_SIGNAL_REALTIME_51 = 63,
+ TARGET_SIGNAL_REALTIME_52 = 64,
+ TARGET_SIGNAL_REALTIME_53 = 65,
+ TARGET_SIGNAL_REALTIME_54 = 66,
+ TARGET_SIGNAL_REALTIME_55 = 67,
+ TARGET_SIGNAL_REALTIME_56 = 68,
+ TARGET_SIGNAL_REALTIME_57 = 69,
+ TARGET_SIGNAL_REALTIME_58 = 70,
+ TARGET_SIGNAL_REALTIME_59 = 71,
+ TARGET_SIGNAL_REALTIME_60 = 72,
+ TARGET_SIGNAL_REALTIME_61 = 73,
+ TARGET_SIGNAL_REALTIME_62 = 74,
+ TARGET_SIGNAL_REALTIME_63 = 75,
+#if defined(MACH) || defined(__MACH__)
+ /* Mach exceptions */
+ TARGET_EXC_BAD_ACCESS = 76,
+ TARGET_EXC_BAD_INSTRUCTION = 77,
+ TARGET_EXC_ARITHMETIC = 78,
+ TARGET_EXC_EMULATION = 79,
+ TARGET_EXC_SOFTWARE = 80,
+ TARGET_EXC_BREAKPOINT = 81,
+#endif
/* Some signal we don't know about. */
TARGET_SIGNAL_UNKNOWN,
/* Given a name (SIGHUP, etc.), return its signal. */
enum target_signal target_signal_from_name PARAMS ((char *));
\f
+/* If certain kinds of activity happen, target_wait should perform
+ callbacks. */
+/* Right now we just call (*TARGET_ACTIVITY_FUNCTION) if I/O is possible
+ on TARGET_ACTIVITY_FD. */
+extern int target_activity_fd;
+/* Returns zero to leave the inferior alone, one to interrupt it. */
+extern int (*target_activity_function) PARAMS ((void));
+\f
struct target_ops
{
char *to_shortname; /* Name this target type */
CORE_ADDR *addr_found, char *data_found));
#define target_search(len, data, mask, startaddr, increment, lorange, hirange, addr_found, data_found) \
- (*current_target->to_search) (len, data, mask, startaddr, increment, \
+ (*current_target.to_search) (len, data, mask, startaddr, increment, \
lorange, hirange, addr_found, data_found)
#endif /* 0 */
void (*to_mourn_inferior) PARAMS ((void));
int (*to_can_run) PARAMS ((void));
void (*to_notice_signals) PARAMS ((int pid));
+ int (*to_thread_alive) PARAMS ((int pid));
+ void (*to_stop) PARAMS ((void));
enum strata to_stratum;
struct target_ops
- *to_next;
+ *DONT_USE; /* formerly to_next */
int to_has_all_memory;
int to_has_memory;
int to_has_stack;
/* The ops structure for our "current" target process. This should
never be NULL. If there is no target, it points to the dummy_target. */
-extern struct target_ops *current_target;
+extern struct target_ops current_target;
+
+/* An item on the target stack. */
+
+struct target_stack_item
+{
+ struct target_stack_item *next;
+ struct target_ops *target_ops;
+};
+
+/* The target stack. */
+
+extern struct target_stack_item *target_stack;
/* Define easy words for doing these operations on our current target. */
-#define target_shortname (current_target->to_shortname)
-#define target_longname (current_target->to_longname)
+#define target_shortname (current_target.to_shortname)
+#define target_longname (current_target.to_longname)
/* The open routine takes the rest of the parameters from the command,
and (if successful) pushes a new target onto the stack.
Targets should supply this routine, if only to provide an error message. */
#define target_open(name, from_tty) \
- (*current_target->to_open) (name, from_tty)
+ (*current_target.to_open) (name, from_tty)
/* Does whatever cleanup is required for a target that we are no longer
going to be calling. Argument says whether we are quitting gdb and
do. */
#define target_close(quitting) \
- (*current_target->to_close) (quitting)
+ (*current_target.to_close) (quitting)
/* Attaches to a process on the target side. Arguments are as passed
to the `attach' command by the user. This routine can be called
(without waiting) to an upcoming target_wait call. */
#define target_attach(args, from_tty) \
- (*current_target->to_attach) (args, from_tty)
+ (*current_target.to_attach) (args, from_tty)
/* Takes a program previously attached to and detaches it.
The program may resume execution (some targets do, some don't) and will
pass TARGET_SIGNAL_DEFAULT. */
#define target_resume(pid, step, siggnal) \
- (*current_target->to_resume) (pid, step, siggnal)
+ (*current_target.to_resume) (pid, step, siggnal)
/* Wait for process pid to do something. Pid = -1 to wait for any pid
to do something. Return pid of child, or -1 in case of error;
stop_pc, etc., set up. */
#define target_wait(pid, status) \
- (*current_target->to_wait) (pid, status)
+ (*current_target.to_wait) (pid, status)
/* Fetch register REGNO, or all regs if regno == -1. No result. */
#define target_fetch_registers(regno) \
- (*current_target->to_fetch_registers) (regno)
+ (*current_target.to_fetch_registers) (regno)
/* Store at least register REGNO, or all regs if REGNO == -1.
It can store as many registers as it wants to, so target_prepare_to_store
must have been previously called. Calls error() if there are problems. */
#define target_store_registers(regs) \
- (*current_target->to_store_registers) (regs)
+ (*current_target.to_store_registers) (regs)
/* Get ready to modify the registers array. On machines which store
individual registers, this doesn't need to do anything. On machines
debugged. */
#define target_prepare_to_store() \
- (*current_target->to_prepare_to_store) ()
+ (*current_target.to_prepare_to_store) ()
extern int target_read_string PARAMS ((CORE_ADDR, char **, int, int *));
extern int
-target_read_memory PARAMS ((CORE_ADDR, char *, int));
+target_read_memory PARAMS ((CORE_ADDR memaddr, char *myaddr, int len));
+
+extern int
+target_read_memory_section PARAMS ((CORE_ADDR memaddr, char *myaddr, int len,
+ asection *bfd_section));
extern int
target_read_memory_partial PARAMS ((CORE_ADDR, char *, int, int *));
extern int
child_xfer_memory PARAMS ((CORE_ADDR, char *, int, int, struct target_ops *));
-/* Transfer LEN bytes between target address MEMADDR and GDB address MYADDR.
- Returns 0 for success, errno code for failure (which includes partial
- transfers--if you want a more useful response to partial transfers, try
- target_read_memory_partial). */
-
-extern int target_xfer_memory PARAMS ((CORE_ADDR memaddr, char *myaddr,
- int len, int write));
-
/* From exec.c */
extern void
/* Print a line about the current target. */
#define target_files_info() \
- (*current_target->to_files_info) (current_target)
+ (*current_target.to_files_info) (¤t_target)
/* Insert a breakpoint at address ADDR in the target machine.
SAVE is a pointer to memory allocated for saving the
an errno value. */
#define target_insert_breakpoint(addr, save) \
- (*current_target->to_insert_breakpoint) (addr, save)
+ (*current_target.to_insert_breakpoint) (addr, save)
/* Remove a breakpoint at address ADDR in the target machine.
SAVE is a pointer to the same save area
Result is 0 for success, or an errno value. */
#define target_remove_breakpoint(addr, save) \
- (*current_target->to_remove_breakpoint) (addr, save)
+ (*current_target.to_remove_breakpoint) (addr, save)
/* Initialize the terminal settings we record for the inferior,
before we actually run the inferior. */
#define target_terminal_init() \
- (*current_target->to_terminal_init) ()
+ (*current_target.to_terminal_init) ()
/* Put the inferior's terminal settings into effect.
This is preparation for starting or resuming the inferior. */
#define target_terminal_inferior() \
- (*current_target->to_terminal_inferior) ()
+ (*current_target.to_terminal_inferior) ()
/* Put some of our terminal settings into effect,
enough to get proper results from our output,
should be called to get back to a normal state of affairs. */
#define target_terminal_ours_for_output() \
- (*current_target->to_terminal_ours_for_output) ()
+ (*current_target.to_terminal_ours_for_output) ()
/* Put our terminal settings into effect.
First record the inferior's terminal settings
so they can be restored properly later. */
#define target_terminal_ours() \
- (*current_target->to_terminal_ours) ()
+ (*current_target.to_terminal_ours) ()
/* Print useful information about our terminal status, if such a thing
exists. */
#define target_terminal_info(arg, from_tty) \
- (*current_target->to_terminal_info) (arg, from_tty)
+ (*current_target.to_terminal_info) (arg, from_tty)
/* Kill the inferior process. Make it go away. */
#define target_kill() \
- (*current_target->to_kill) ()
+ (*current_target.to_kill) ()
/* Load an executable file into the target process. This is expected to
not only bring new code into the target process, but also to update
GDB's symbol tables to match. */
#define target_load(arg, from_tty) \
- (*current_target->to_load) (arg, from_tty)
+ (*current_target.to_load) (arg, from_tty)
/* Look up a symbol in the target's symbol table. NAME is the symbol
name. ADDRP is a CORE_ADDR * pointing to where the value of the symbol
doing a complain(). */
#define target_lookup_symbol(name, addrp) \
- (*current_target->to_lookup_symbol) (name, addrp)
+ (*current_target.to_lookup_symbol) (name, addrp)
/* Start an inferior process and set inferior_pid to its pid.
EXEC_FILE is the file to run.
On VxWorks and various standalone systems, we ignore exec_file. */
#define target_create_inferior(exec_file, args, env) \
- (*current_target->to_create_inferior) (exec_file, args, env)
+ (*current_target.to_create_inferior) (exec_file, args, env)
/* The inferior process has died. Do what is right. */
#define target_mourn_inferior() \
- (*current_target->to_mourn_inferior) ()
+ (*current_target.to_mourn_inferior) ()
/* Does target have enough data to do a run or attach command? */
/* post process changes to signal handling in the inferior. */
#define target_notice_signals(pid) \
- (*current_target->to_notice_signals) (pid)
+ (*current_target.to_notice_signals) (pid)
+
+/* Check to see if a thread is still alive. */
+
+#define target_thread_alive(pid) \
+ (*current_target.to_thread_alive) (pid)
+
+/* Make target stop in a continuable fashion. (For instance, under Unix, this
+ should act like SIGSTOP). This function is normally used by GUIs to
+ implement a stop button. */
+
+#define target_stop current_target.to_stop
/* Pointer to next target in the chain, e.g. a core file and an exec file. */
#define target_next \
- (current_target->to_next)
+ (current_target.to_next)
/* Does the target include all of memory, or only part of it? This
determines whether we look up the target chain for other parts of
memory if this target can't satisfy a request. */
#define target_has_all_memory \
- (current_target->to_has_all_memory)
+ (current_target.to_has_all_memory)
/* Does the target include memory? (Dummy targets don't.) */
#define target_has_memory \
- (current_target->to_has_memory)
+ (current_target.to_has_memory)
/* Does the target have a stack? (Exec files don't, VxWorks doesn't, until
we start a process.) */
#define target_has_stack \
- (current_target->to_has_stack)
+ (current_target.to_has_stack)
/* Does the target have registers? (Exec files don't.) */
#define target_has_registers \
- (current_target->to_has_registers)
+ (current_target.to_has_registers)
/* Does the target have execution? Can we make it jump (through
hoops), or pop its stack a few times? FIXME: If this is to work that
this just tells us whether this target is *capable* of execution. */
#define target_has_execution \
- (current_target->to_has_execution)
+ (current_target.to_has_execution)
+
+extern void target_link PARAMS ((char *, CORE_ADDR *));
/* Converts a process id to a string. Usually, the string just contains
`process xyz', but on some systems it may contain
extern char *normal_pid_to_str PARAMS ((int pid));
#endif
+#ifndef target_new_objfile
+#define target_new_objfile(OBJFILE)
+#endif
+
+/* Hook to call target-dependant code after reading in a new symbol table. */
+
+#ifndef TARGET_SYMFILE_POSTREAD
+#define TARGET_SYMFILE_POSTREAD(OBJFILE)
+#endif
+
+/* Hook to call target dependant code just after inferior target process has
+ started. */
+
+#ifndef TARGET_CREATE_INFERIOR_HOOK
+#define TARGET_CREATE_INFERIOR_HOOK(PID)
+#endif
+
+/* Hardware watchpoint interfaces. */
+
+/* Returns non-zero if we were stopped by a hardware watchpoint (memory read or
+ write). */
+
+#ifndef STOPPED_BY_WATCHPOINT
+#define STOPPED_BY_WATCHPOINT(w) 0
+#endif
+
+/* Provide defaults for systems that don't support hardware watchpoints. */
+
+#ifndef TARGET_HAS_HARDWARE_WATCHPOINTS
+
+/* Returns non-zero if we can set a hardware watchpoint of type TYPE. TYPE is
+ one of bp_hardware_watchpoint, bp_read_watchpoint, bp_write_watchpoint, or
+ bp_hardware_breakpoint. CNT is the number of such watchpoints used so far
+ (including this one?). OTHERTYPE is who knows what... */
+
+#define TARGET_CAN_USE_HARDWARE_WATCHPOINT(TYPE,CNT,OTHERTYPE) 0
+
+/* Set/clear a hardware watchpoint starting at ADDR, for LEN bytes. TYPE is 0
+ for write, 1 for read, and 2 for read/write accesses. Returns 0 for
+ success, non-zero for failure. */
+
+#define target_remove_watchpoint(ADDR,LEN,TYPE) -1
+#define target_insert_watchpoint(ADDR,LEN,TYPE) -1
+
+#endif /* TARGET_HAS_HARDWARE_WATCHPOINTS */
+
+#ifndef target_insert_hw_breakpoint
+#define target_remove_hw_breakpoint(ADDR,SHADOW) -1
+#define target_insert_hw_breakpoint(ADDR,SHADOW) -1
+#endif
+
+#ifndef target_stopped_data_address
+#define target_stopped_data_address() 0
+#endif
+
+/* If defined, then we need to decr pc by this much after a hardware break-
+ point. Presumably this overrides DECR_PC_AFTER_BREAK... */
+
+#ifndef DECR_PC_AFTER_HW_BREAK
+#define DECR_PC_AFTER_HW_BREAK 0
+#endif
+
/* Routines for maintenance of the target structures...
add_target: Add a target to the list of all possible targets.
CORE_ADDR addr; /* Lowest address in section */
CORE_ADDR endaddr; /* 1+highest address in section */
- /* For the ptx compiler, we can't use the sec_ptr typedef when the field's
- name is sec_ptr. We really should rename the field (or better yet,
- the typedef should be bfd_sec_ptr). */
- struct sec *sec_ptr; /* BFD section pointer */
+ sec_ptr the_bfd_section;
bfd *bfd; /* BFD file pointer */
};
extern int
memory_insert_breakpoint PARAMS ((CORE_ADDR, char *));
+unsigned char *
+memory_breakpoint_from_pc PARAMS ((CORE_ADDR *pcptr, int *lenptr));
+
/* From target.c */
-void
+extern void
+initialize_targets PARAMS ((void));
+
+extern void
noprocess PARAMS ((void));
-void
+extern void
find_default_attach PARAMS ((char *, int));
-void
+extern void
find_default_create_inferior PARAMS ((char *, char *, char **));
-struct target_ops *
+extern struct target_ops *
find_core_target PARAMS ((void));
\f
/* Stuff that should be shared among the various remote targets. */
/* Speed in bits per second, or -1 which means don't mess with the speed. */
extern int baud_rate;
+/* Timeout limit for response from target. */
+extern int remote_timeout;
+
+extern asection *target_memory_bfd_section;
\f
/* Functions for helping to write a native target. */
extern enum target_signal target_signal_from_host PARAMS ((int));
extern int target_signal_to_host PARAMS ((enum target_signal));
+/* Convert from a number used in a GDB command to an enum target_signal. */
+extern enum target_signal target_signal_from_command PARAMS ((int));
+
+/* Any target can call this to switch to remote protocol (in remote.c). */
+extern void push_remote_target PARAMS ((char *name, int from_tty));
+
+/* Any target cah call this to open using the remote protocol */
+extern void open_remote_target PARAMS ((char *name, int from_tty, struct target_ops *target, int extended_p));
+
+\f
+/* Imported from machine dependent code */
+
+#ifdef NO_SINGLE_STEP
+extern int one_stepped;
+extern void single_step PARAMS ((enum target_signal));
+#endif /* NO_SINGLE_STEP */
+
#endif /* !defined (TARGET_H) */
projects / deliverable / binutils-gdb.git / blobdiff