* remote.c, remote-mon.c, remote-utils.c, remote-utils.h,
[deliverable/binutils-gdb.git] / gdb / target.h
index 4a680b16a2ff7d0cb42f697b8ada50ac42836c55..31e6e89e690657ef5664492dca20d8a2a9fc1948 100644 (file)
@@ -1,5 +1,5 @@
 /* Interface between GDB and target environments, including files and processes
 /* 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.
    Contributed by Cygnus Support.  Written by John Gilmore.
 
 This file is part of GDB.
@@ -49,6 +49,131 @@ enum strata {
        process_stratum         /* Executing processes */
 };
 
        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 *));
+\f
 struct target_ops
 {
   char        *to_shortname;   /* Name this target type */
 struct target_ops
 {
   char        *to_shortname;   /* Name this target type */
@@ -60,13 +185,55 @@ struct target_ops
   void               (*to_close) PARAMS ((int));
   void               (*to_attach) PARAMS ((char *, int));
   void               (*to_detach) PARAMS ((char *, int));
   void               (*to_close) PARAMS ((int));
   void               (*to_attach) PARAMS ((char *, int));
   void               (*to_detach) PARAMS ((char *, int));
-  void               (*to_resume) PARAMS ((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));
   void               (*to_fetch_registers) PARAMS ((int));
   void               (*to_store_registers) PARAMS ((int));
   void               (*to_prepare_to_store) PARAMS ((void));
-  int                (*to_xfer_memory) PARAMS ((CORE_ADDR, char *, int, int,
-                                        struct target_ops *));
+
+  /* Transfer LEN bytes of memory between GDB address MYADDR and
+     target address MEMADDR.  If WRITE, transfer them to the target, else
+     transfer them from the target.  TARGET is the target from which we
+     get this function.
+
+     Return value, N, is one of the following:
+
+     0 means that we can't handle this.  If errno has been set, it is the
+     error which prevented us from doing it (FIXME: What about bfd_error?).
+
+     positive (call it N) means that we have transferred N bytes
+     starting at MEMADDR.  We might be able to handle more bytes
+     beyond this length, but no promises.
+
+     negative (call its absolute value N) means that we cannot
+     transfer right at MEMADDR, but we could transfer at least
+     something at MEMADDR + N.  */
+
+  int                (*to_xfer_memory) PARAMS ((CORE_ADDR memaddr, char *myaddr,
+                                        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 *));
   void               (*to_files_info) PARAMS ((struct target_ops *));
   int                (*to_insert_breakpoint) PARAMS ((CORE_ADDR, char *));
   int        (*to_remove_breakpoint) PARAMS ((CORE_ADDR, char *));
@@ -81,6 +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_create_inferior) PARAMS ((char *, char *, char **));
   void               (*to_mourn_inferior) PARAMS ((void));
   int        (*to_can_run) PARAMS ((void));
+  void       (*to_notice_signals) PARAMS ((int pid));
   enum strata   to_stratum;
   struct target_ops
               *to_next;
   enum strata   to_stratum;
   struct target_ops
               *to_next;
@@ -103,7 +271,8 @@ struct target_ops
 
 #define        OPS_MAGIC       3840
 
 
 #define        OPS_MAGIC       3840
 
-/* The ops structure for our "current" target process.  */
+/* 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;
 
@@ -147,21 +316,27 @@ extern struct target_ops  *current_target;
    typed by the user (e.g. a signal to send the process).  FROM_TTY
    says whether to be verbose or not.  */
 
    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)
+extern void
+target_detach PARAMS ((char *, int));
 
 
-/* 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.  */
+/* Resume execution of the target process PID.  STEP says whether to
+   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(step, siggnal)    \
-       (*current_target->to_resume) (step, siggnal)
+#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.  */
 
 
 /* Fetch register REGNO, or all regs if regno == -1.  No result.  */
 
@@ -169,8 +344,8 @@ extern struct target_ops    *current_target;
        (*current_target->to_fetch_registers) (regno)
 
 /* Store at least register REGNO, or all regs if REGNO == -1.
        (*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.  */
+   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)
 
 #define        target_store_registers(regs)    \
        (*current_target->to_store_registers) (regs)
@@ -184,16 +359,15 @@ extern struct target_ops  *current_target;
 #define        target_prepare_to_store()       \
        (*current_target->to_prepare_to_store) ()
 
 #define        target_prepare_to_store()       \
        (*current_target->to_prepare_to_store) ()
 
-/* 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.  */
-
 extern int
 target_read_string PARAMS ((CORE_ADDR, char *, int));
 
 extern int
 target_read_memory PARAMS ((CORE_ADDR, char *, int));
 
 extern int
 target_read_string PARAMS ((CORE_ADDR, char *, int));
 
 extern int
 target_read_memory PARAMS ((CORE_ADDR, char *, int));
 
+extern int
+target_read_memory_partial PARAMS ((CORE_ADDR, char *, int, int *));
+
 extern int
 target_write_memory PARAMS ((CORE_ADDR, char *, int));
 
 extern int
 target_write_memory PARAMS ((CORE_ADDR, char *, int));
 
@@ -203,8 +377,13 @@ xfer_memory PARAMS ((CORE_ADDR, char *, int, int, struct target_ops *));
 extern int
 child_xfer_memory PARAMS ((CORE_ADDR, char *, int, int, struct target_ops *));
 
 extern int
 child_xfer_memory PARAMS ((CORE_ADDR, char *, int, int, struct target_ops *));
 
-extern int
-target_xfer_memory PARAMS ((CORE_ADDR, char *, int, int));
+/* 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 */
 
 
 /* From exec.c */
 
@@ -238,7 +417,7 @@ print_section_info PARAMS ((struct target_ops *, bfd *));
 
 #define target_terminal_init() \
        (*current_target->to_terminal_init) ()
 
 #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.  */
 
 /* Put the inferior's terminal settings into effect.
    This is preparation for starting or resuming the inferior.  */
 
@@ -311,6 +490,11 @@ print_section_info PARAMS ((struct target_ops *, bfd *));
 #define target_can_run(t) \
        ((t)->to_can_run) ()
 
 #define target_can_run(t) \
        ((t)->to_can_run) ()
 
+/* post process changes to signal handling in the inferior.  */
+
+#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.  */
 
 #define        target_next \
 /* Pointer to next target in the chain, e.g. a core file and an exec file.  */
 
 #define        target_next \
@@ -339,12 +523,26 @@ print_section_info PARAMS ((struct target_ops *, bfd *));
 #define        target_has_registers    \
        (current_target->to_has_registers)
 
 #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?  */
+/* 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
+   way, it needs to check whether an inferior actually exists.
+   remote-udi.c and probably other targets can be the current target
+   when the inferior doesn't actually exist at the moment.  Right now
+   this just tells us whether this target is *capable* of execution.  */
 
 #define        target_has_execution    \
        (current_target->to_has_execution)
 
 
 #define        target_has_execution    \
        (current_target->to_has_execution)
 
+/* Converts a process id to a string.  Usually, the string just contains
+   `process xyz', but on some systems it may contain
+   `process xyz thread abc'.  */
+
+#ifndef target_pid_to_str
+#define target_pid_to_str(PID) \
+       normal_pid_to_str (PID)
+extern char *normal_pid_to_str PARAMS ((int pid));
+#endif
+
 /* Routines for maintenance of the target structures...
 
    add_target:   Add a target to the list of all possible targets.
 /* Routines for maintenance of the target structures...
 
    add_target:   Add a target to the list of all possible targets.
@@ -412,4 +610,25 @@ find_default_attach PARAMS ((char *, int));
 void
 find_default_create_inferior PARAMS ((char *, char *, char **));
 
 void
 find_default_create_inferior PARAMS ((char *, char *, char **));
 
+struct target_ops *
+find_core_target PARAMS ((void));
+\f
+/* 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;
+\f
+/* 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) */
 #endif /* !defined (TARGET_H) */
This page took 0.028028 seconds and 4 git commands to generate.