diff options
Diffstat (limited to 'gdb/target.h')
| -rw-r--r-- | gdb/target.h | 406 |
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 |