X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Ftarget.h;h=31e6e89e690657ef5664492dca20d8a2a9fc1948;hb=c20c1bdf992a90db69c4abb73594b2ff58154ef6;hp=0df69a3088e42607635872575d6cf5a35a5c297b;hpb=f1e7bafcec44c1c8d9a062127d11ba8906539b4d;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/target.h b/gdb/target.h index 0df69a3088..31e6e89e69 100644 --- a/gdb/target.h +++ b/gdb/target.h @@ -1,5 +1,5 @@ /* Interface between GDB and target environments, including files and processes - Copyright 1990, 1991, 1992 Free Software Foundation, Inc. + Copyright 1990, 1991, 1992, 1993, 1994 Free Software Foundation, Inc. Contributed by Cygnus Support. Written by John Gilmore. This file is part of GDB. @@ -49,6 +49,131 @@ enum strata { process_stratum /* Executing processes */ }; +/* Stuff for target_wait. */ + +/* Generally, what has the program done? */ +enum target_waitkind { + /* The program has exited. The exit status is in value.integer. */ + TARGET_WAITKIND_EXITED, + + /* The program has stopped with a signal. Which signal is in value.sig. */ + TARGET_WAITKIND_STOPPED, + + /* The program has terminated with a signal. Which signal is in + value.sig. */ + TARGET_WAITKIND_SIGNALLED, + + /* The program is letting us know that it dynamically loaded something + (e.g. it called load(2) on AIX). */ + TARGET_WAITKIND_LOADED, + + /* Nothing happened, but we stopped anyway. This perhaps should be handled + within target_wait, but I'm not sure target_wait should be resuming the + inferior. */ + TARGET_WAITKIND_SPURIOUS + }; + +/* The numbering of these signals is chosen to match traditional unix + signals (insofar as various unices use the same numbers, anyway). + It is also the numbering of the GDB remote protocol. Other remote + protocols, if they use a different numbering, should make sure to + translate appropriately. */ + +/* This is based strongly on Unix/POSIX signals for several reasons: + (1) This set of signals represents a widely-accepted attempt to + represent events of this sort in a portable fashion, (2) we want a + signal to make it from wait to child_wait to the user intact, (3) many + remote protocols use a similar encoding. However, it is + recognized that this set of signals has limitations (such as not + distinguishing between various kinds of SIGSEGV, or not + distinguishing hitting a breakpoint from finishing a single step). + So in the future we may get around this either by adding additional + signals for breakpoint, single-step, etc., or by adding signal + codes; the latter seems more in the spirit of what BSD, System V, + etc. are doing to address these issues. */ + +/* For an explanation of what each signal means, see + target_signal_to_string. */ + +enum target_signal { + /* Used some places (e.g. stop_signal) to record the concept that + there is no signal. */ + TARGET_SIGNAL_0 = 0, + TARGET_SIGNAL_HUP = 1, + TARGET_SIGNAL_INT = 2, + TARGET_SIGNAL_QUIT = 3, + TARGET_SIGNAL_ILL = 4, + TARGET_SIGNAL_TRAP = 5, + TARGET_SIGNAL_ABRT = 6, + TARGET_SIGNAL_EMT = 7, + TARGET_SIGNAL_FPE = 8, + TARGET_SIGNAL_KILL = 9, + TARGET_SIGNAL_BUS = 10, + TARGET_SIGNAL_SEGV = 11, + TARGET_SIGNAL_SYS = 12, + TARGET_SIGNAL_PIPE = 13, + TARGET_SIGNAL_ALRM = 14, + TARGET_SIGNAL_TERM = 15, + TARGET_SIGNAL_URG = 16, + TARGET_SIGNAL_STOP = 17, + TARGET_SIGNAL_TSTP = 18, + TARGET_SIGNAL_CONT = 19, + TARGET_SIGNAL_CHLD = 20, + TARGET_SIGNAL_TTIN = 21, + TARGET_SIGNAL_TTOU = 22, + TARGET_SIGNAL_IO = 23, + TARGET_SIGNAL_XCPU = 24, + TARGET_SIGNAL_XFSZ = 25, + TARGET_SIGNAL_VTALRM = 26, + TARGET_SIGNAL_PROF = 27, + TARGET_SIGNAL_WINCH = 28, + TARGET_SIGNAL_LOST = 29, + TARGET_SIGNAL_USR1 = 30, + TARGET_SIGNAL_USR2 = 31, + TARGET_SIGNAL_PWR = 32, + /* Similar to SIGIO. Perhaps they should have the same number. */ + TARGET_SIGNAL_POLL = 33, + TARGET_SIGNAL_WIND = 34, + TARGET_SIGNAL_PHONE = 35, + TARGET_SIGNAL_WAITING = 36, + TARGET_SIGNAL_LWP = 37, + TARGET_SIGNAL_DANGER = 38, + TARGET_SIGNAL_GRANT = 39, + TARGET_SIGNAL_RETRACT = 40, + TARGET_SIGNAL_MSG = 41, + TARGET_SIGNAL_SOUND = 42, + TARGET_SIGNAL_SAK = 43, + + /* Some signal we don't know about. */ + TARGET_SIGNAL_UNKNOWN, + + /* Use whatever signal we use when one is not specifically specified + (for passing to proceed and so on). */ + TARGET_SIGNAL_DEFAULT, + + /* Last and unused enum value, for sizing arrays, etc. */ + TARGET_SIGNAL_LAST +}; + +struct target_waitstatus { + enum target_waitkind kind; + + /* Exit status or signal number. */ + union { + int integer; + enum target_signal sig; + } value; +}; + +/* Return the string for a signal. */ +extern char *target_signal_to_string PARAMS ((enum target_signal)); + +/* Return the name (SIGHUP, etc.) for a signal. */ +extern char *target_signal_to_name PARAMS ((enum target_signal)); + +/* Given a name (SIGHUP, etc.), return its signal. */ +enum target_signal target_signal_from_name PARAMS ((char *)); + struct target_ops { char *to_shortname; /* Name this target type */ @@ -60,8 +185,8 @@ struct target_ops void (*to_close) PARAMS ((int)); void (*to_attach) PARAMS ((char *, int)); void (*to_detach) PARAMS ((char *, int)); - void (*to_resume) PARAMS ((int, int, int)); - int (*to_wait) PARAMS ((int *)); + void (*to_resume) PARAMS ((int, int, enum target_signal)); + int (*to_wait) PARAMS ((int, struct target_waitstatus *)); void (*to_fetch_registers) PARAMS ((int)); void (*to_store_registers) PARAMS ((int)); void (*to_prepare_to_store) PARAMS ((void)); @@ -88,6 +213,27 @@ struct target_ops int len, int write, struct target_ops * target)); +#if 0 + /* Enable this after 4.12. */ + + /* Search target memory. Start at STARTADDR and take LEN bytes of + target memory, and them with MASK, and compare to DATA. If they + match, set *ADDR_FOUND to the address we found it at, store the data + we found at LEN bytes starting at DATA_FOUND, and return. If + not, add INCREMENT to the search address and keep trying until + the search address is outside of the range [LORANGE,HIRANGE). + + If we don't find anything, set *ADDR_FOUND to (CORE_ADDR)0 and return. */ + void (*to_search) PARAMS ((int len, char *data, char *mask, + CORE_ADDR startaddr, int increment, + CORE_ADDR lorange, CORE_ADDR hirange, + 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, \ + lorange, hirange, addr_found, data_found) +#endif /* 0 */ + void (*to_files_info) PARAMS ((struct target_ops *)); int (*to_insert_breakpoint) PARAMS ((CORE_ADDR, char *)); int (*to_remove_breakpoint) PARAMS ((CORE_ADDR, char *)); @@ -102,7 +248,7 @@ struct target_ops void (*to_create_inferior) PARAMS ((char *, char *, char **)); void (*to_mourn_inferior) PARAMS ((void)); int (*to_can_run) PARAMS ((void)); - void (*to_notice_signals) PARAMS ((void)); + void (*to_notice_signals) PARAMS ((int pid)); enum strata to_stratum; struct target_ops *to_next; @@ -174,17 +320,23 @@ extern void target_detach PARAMS ((char *, int)); /* Resume execution of the target process PID. 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. */ + single-step or to run free; SIGGNAL is the signal to be given to + the target, or TARGET_SIGNAL_0 for no signal. The caller may not + pass TARGET_SIGNAL_DEFAULT. */ #define target_resume(pid, step, siggnal) \ (*current_target->to_resume) (pid, 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. */ +/* 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; + store status through argument pointer STATUS. Note that it is + *not* OK to return_to_top_level out of target_wait without popping + the debugging target from the stack; GDB isn't prepared to get back + to the prompt with a debugging target but without the frame cache, + stop_pc, etc., set up. */ -#define target_wait(status) \ - (*current_target->to_wait) (status) +#define target_wait(pid, status) \ + (*current_target->to_wait) (pid, status) /* Fetch register REGNO, or all regs if regno == -1. No result. */ @@ -340,8 +492,8 @@ print_section_info PARAMS ((struct target_ops *, bfd *)); /* post process changes to signal handling in the inferior. */ -#define target_notice_signals() \ - (*current_target->to_notice_signals) () +#define target_notice_signals(pid) \ + (*current_target->to_notice_signals) (pid) /* Pointer to next target in the chain, e.g. a core file and an exec file. */ @@ -461,4 +613,22 @@ find_default_create_inferior PARAMS ((char *, char *, char **)); struct target_ops * find_core_target PARAMS ((void)); +/* Stuff that should be shared among the various remote targets. */ + +/* Debugging level. 0 is off, and non-zero values mean to print some debug + information (higher values, more information). */ +extern int remote_debug; + +/* Speed in bits per second, or -1 which means don't mess with the speed. */ +extern int baud_rate; + +/* Functions for helping to write a native target. */ + +/* This is for native targets which use a unix/POSIX-style waitstatus. */ +extern void store_waitstatus PARAMS ((struct target_waitstatus *, int)); + +/* Convert between host signal numbers and enum target_signal's. */ +extern enum target_signal target_signal_from_host PARAMS ((int)); +extern int target_signal_to_host PARAMS ((enum target_signal)); + #endif /* !defined (TARGET_H) */