Initial revision

1 files changed, 406 insertions, 0 deletions

diff --git a/gdb/target.h b/gdb/target.h
new file mode 100644
index 0000000..924f4aa
--- /dev/null
+++ b/gdb/target.h
@@ -0,0 +1,406 @@
+/* Interface between GDB and target environments, including files and processes
+   Copyright 1990, 1991 Free Software Foundation, Inc.
+   Contributed by Cygnus Support.  Written by John Gilmore.
+
+This file is part of GDB.
+
+GDB 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.
+
+GDB 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.  */
+
+/* This include file defines the interface between the main part
+   of the debugger, and the part which is target-specific, or
+   specific to the communications interface between us and the
+   target.
+
+   A TARGET is an interface between the debugger and a particular 
+   kind of file or process.  Targets can be STACKED in STRATA, 
+   so that more than one target can potentially respond to a request.
+   In particular, memory accesses will walk down the stack of targets
+   until they find a target that is interested in handling that particular
+   address.  STRATA are artificial boundaries on the stack, within
+   which particular kinds of targets live.  Strata exist so that
+   people don't get confused by pushing e.g. a process target and then
+   a file target, and wondering why they can't see the current values
+   of variables any more (the file target is handling them and they
+   never get to the process target).  So when you push a file target,
+   it goes into the file stratum, which is always below the process
+   stratum.  */
+
+enum strata {
+	dummy_stratum,		/* The lowest of the low */
+	file_stratum,		/* Executable files, etc */
+	core_stratum,		/* Core dump files */
+	process_stratum,	/* Executing processes */
+};
+
+struct target_ops {
+	char  *to_shortname;		/* Name this target type */
+	char  *to_longname;		/* Name for printing */
+#ifdef __STDC__
+	void (*to_open) (char *name, int from_tty);
+	void (*to_close) (int quitting);
+	void (*to_attach) (char *name, int from_tty);
+	void (*to_detach) (char *args, int from_tty);
+	void (*to_resume) (int step, int siggnal);
+	int  (*to_wait)   (int *status);
+	int  (*to_fetch_registers) (int regno);
+	int  (*to_store_registers) (int regno);
+	void (*to_prepare_to_store) ();
+	void (*to_convert_to_virtual) (int regnum, char *from, char *to);
+	void (*to_convert_from_virtual) (int regnum, char *from, char *to);
+	int  (*to_xfer_memory) (CORE_ADDR memaddr, char *myaddr, int len, int w);
+	void (*to_files_info) ();
+	int  (*to_insert_breakpoint) (CORE_ADDR addr, char *save);
+	int  (*to_remove_breakpoint) (CORE_ADDR addr, char *save);
+	void  (*to_terminal_init) ();
+	void  (*to_terminal_inferior) ();
+	void  (*to_terminal_ours_for_output) ();
+	void  (*to_terminal_ours) ();
+	void  (*to_terminal_info) (char *arg, int from_tty);
+	void  (*to_kill) (char *arg, int from_tty);
+	void  (*to_load) (char *arg, int from_tty);
+	void  (*to_add_syms) (char *arg, int from_tty);
+struct value *(*to_call_function) (struct value *function,
+				   int nargs, struct value **args);
+	int   (*to_lookup_symbol) (char *name, CORE_ADDR *addrp);
+	void  (*to_create_inferior) (char *exec, char *args, char **env);
+	void  (*to_mourn_inferior) ();
+    enum strata to_stratum;
+struct target_ops *to_next;
+	int	to_has_all_memory;
+	int	to_has_memory;
+	int	to_has_stack;
+	int	to_has_registers;
+	int	to_has_execution;
+	int     to_magic;
+/* Need sub-structure for target machine related rather than comm related? */
+#else  /* STDC */
+	void (*to_open) ();
+	void (*to_close) ();
+	void (*to_attach) ();
+	void (*to_detach) ();
+	void (*to_resume) ();
+	int  (*to_wait)   ();
+	int  (*to_fetch_registers) ();
+	int  (*to_store_registers) ();
+	void (*to_prepare_to_store) ();
+	void (*to_convert_to_virtual) ();
+	void (*to_convert_from_virtual) ();
+	int  (*to_xfer_memory) ();
+	void (*to_files_info) ();
+	int  (*to_insert_breakpoint) ();
+	int  (*to_remove_breakpoint) ();
+	void  (*to_terminal_init) ();
+	void  (*to_terminal_inferior) ();
+	void  (*to_terminal_ours_for_output) ();
+	void  (*to_terminal_ours) ();
+	void  (*to_terminal_info) ();
+	void  (*to_kill) ();
+	void  (*to_load) ();
+	void  (*to_add_syms) ();
+struct value *(*to_call_function) ();
+	int   (*to_lookup_symbol) ();
+	void  (*to_create_inferior) ();
+	void  (*to_mourn_inferior) ();
+    enum strata to_stratum;
+struct target_ops *to_next;
+	int	to_has_all_memory;
+	int	to_has_memory;
+	int	to_has_stack;
+	int	to_has_registers;
+	int	to_has_execution;
+	int     to_magic;
+/* Need sub-structure for target machine related rather than comm related? */
+#endif
+};
+
+/* Magic number for checking ops size.  If a struct doesn't end with this
+   number, somebody changed the declaration but didn't change all the
+   places that initialize one.  */
+
+#define	OPS_MAGIC	3840
+
+/* The ops structure for our "current" target process.  */
+
+extern struct target_ops	*current_target;
+
+/* 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_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
+   should not get hung in case of errors, or whether we want a clean
+   termination even if it takes a while.  This routine is automatically
+   always called just before a routine is popped off the target stack.
+   Closing file descriptors and freeing memory are typical things it should
+   do.  */
+
+#define	target_close(quitting)	\
+	(*current_target->to_close) (quitting)
+
+/* Attaches to a process on the target side.  */
+
+#define	target_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
+   no longer stop on signals, etc.  We better not have left any breakpoints
+   in the program or it'll die when it hits one.  ARGS is arguments
+   typed by the user (e.g. a signal to send the process).  FROM_TTY
+   says whether to be verbose or not.  */
+
+#define	target_detach(args, from_tty)		\
+	(*current_target->to_detach) (args, from_tty)
+
+/* Resume execution of the target process.  STEP says whether to single-step
+   or to run free; SIGGNAL is the signal value (e.g. SIGINT) to be given
+   to the target, or zero for no signal.  */
+
+#define	target_resume(step, siggnal)	\
+	(*current_target->to_resume) (step, siggnal)
+
+/* Wait for inferior process to do something.  Return pid of child,
+   or -1 in case of error; store status through argument pointer STATUS.  */
+
+#define	target_wait(status)		\
+	(*current_target->to_wait) (status)
+
+/* Fetch register REGNO, or all regs if regno == -1.  Result is 0
+   for success, -1 for problems.  */
+
+#define	target_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 the entire registers
+   array must be valid.  Result is 0 for success, -1 for problems.  */
+
+#define	target_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
+   which store all the registers in one fell swoop, this makes sure
+   that REGISTERS contains all the registers from the program being
+   debugged.  */
+
+#define	target_prepare_to_store()	\
+	(*current_target->to_prepare_to_store) ()
+
+/* Convert data from raw format for register REGNUM
+   to virtual format for register REGNUM.  */
+
+#define	target_convert_to_virtual(regnum, from, to)	\
+	(*current_target->to_convert_to_virtual) (regnum, from, to)
+	
+/* Convert data from virtual format for register REGNUM
+   to raw format for register REGNUM.  */
+
+#define	target_convert_from_virtual(regnum, from, to)	\
+	(*current_target->to_convert_from_virtual) (regnum, from, to)
+
+/* Reading and writing memory actually happens through a glue
+   function which iterates across the various targets.  Result is
+   0 for success, or an errno value.  */
+
+#ifdef __STDC__
+/* Needs defs.h for CORE_ADDR */
+extern int target_read_memory(CORE_ADDR memaddr, char *myaddr, int len);
+extern int target_write_memory(CORE_ADDR memaddr, char *myaddr, int len);
+extern int target_xfer_memory(CORE_ADDR memaddr, char *myaddr, int len,
+			      int write);
+#else
+extern int target_read_memory();
+extern int target_write_memory();
+extern int target_xfer_memory();
+#endif
+
+/* Print a line about the current target.  */
+
+#define	target_files_info()	\
+	(*current_target->to_files_info) ()
+
+/* Insert a breakpoint at address ADDR in the target machine.
+   SAVE is a pointer to memory allocated for saving the
+   target contents.  It is guaranteed by the caller to be long enough
+   to save "sizeof BREAKPOINT" bytes.  Result is 0 for success, or
+   an errno value.  */
+
+#define	target_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 
+   that was previously passed to target_insert_breakpoint.  
+   Result is 0 for success, or an errno value.  */
+
+#define	target_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) ()
+	
+/* 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) ()
+
+/* Put some of our terminal settings into effect,
+   enough to get proper results from our output,
+   but do not change into or out of RAW mode
+   so that no input is discarded.
+
+   After doing this, either terminal_ours or terminal_inferior
+   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) ()
+
+/* 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) ()
+
+/* 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)
+
+/* Kill the inferior process.   Make it go away.  */
+
+#define target_kill(arg, from_tty) \
+	(*current_target->to_kill) (arg, from_tty)
+
+/* 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)
+
+/* Add the symbols from an executable file into GDB's symbol table, as if
+   the file had been loaded at a particular address (or set of addresses).
+   This does not change any state in the target system, only in GDB.  */
+
+#define target_add_syms(arg, from_tty) \
+	(*current_target->to_add_syms) (arg, from_tty)
+
+/* Perform a function call in the inferior.
+   ARGS is a vector of values of arguments (NARGS of them).
+   FUNCTION is a value, the function to be called.
+   Returns a value representing what the function returned.
+   May fail to return, if a breakpoint or signal is hit
+   during the execution of the function.  */
+
+#define target_call_function(function, nargs, args) 	\
+  (*current_target->to_call_function) (function, nargs, args)
+
+/* 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
+   should be returned.  The result is 0 if successful, nonzero if the
+   symbol does not exist in the target environment.  This function should
+   not call error() if communication with the target is interrupted, since
+   it is called from symbol reading, but should return nonzero, possibly
+   doing a complain().  */
+
+#define target_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.
+   ALLARGS is a string containing the arguments to the program.
+   ENV is the environment vector to pass.  Errors reported with error().
+   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)
+
+/* The inferior process has died.  Do what is right.  */
+
+#define	target_mourn_inferior()	\
+	(*current_target->to_mourn_inferior) ()
+
+/* Pointer to next target in the chain, e.g. a core file and an exec file.  */
+
+#define	target_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)
+
+/* Does the target include memory?  (Dummy targets don't.)  */
+
+#define	target_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)
+
+/* Does the target have registers?  (Exec files don't.)  */
+
+#define	target_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, or set breakpoints?  */
+
+#define	target_has_execution	\
+	(current_target->to_has_execution)
+
+/* Routines for maintenance of the target structures...
+
+   add_target:   Add a target to the list of all possible targets.
+
+   push_target:  Make this target the top of the stack of currently used
+		 targets, within its particular stratum of the stack.  Result
+		 is 0 if now atop the stack, nonzero if not on top (maybe
+		 should warn user).
+
+   unpush_target: Remove this from the stack of currently used targets,
+		 no matter where it is on the list.  Returns 0 if no
+		 change, 1 if removed from stack.
+
+   pop_target:	 Remove the top thing on the stack of current targets.  */
+
+#ifdef __STDC__
+void add_target (struct target_ops *);
+int push_target (struct target_ops *);
+int unpush_target (struct target_ops *);
+void pop_target ();
+#else
+void add_target ();
+int push_target ();
+int unpush_target ();
+void pop_target ();
+#endif