[gdbserver] linux-low.c: better starvation avoidance, handle non-stop mode too

[deliverable/binutils-gdb.git] / gdb / gdbserver / target.h

diff --git a/gdb/gdbserver/target.h b/gdb/gdbserver/target.h
index dcf02306c89b00ba489054db5810c7fd1f73641c..bbb056733e29b20d6177ac8ea14ee19990e5e2d7 100644 (file)
--- a/gdb/gdbserver/target.h
+++ b/gdb/gdbserver/target.h
@@ -1,5 +1,5 @@
 /* Target operations for the remote server for GDB.
 /* Target operations for the remote server for GDB.

-   Copyright (C) 2002-2005, 2007-2012 Free Software Foundation, Inc.
+   Copyright (C) 2002-2015 Free Software Foundation, Inc.

 
    Contributed by MontaVista Software.
 
 
    Contributed by MontaVista Software.
 


@@ -21,21 +21,16 @@
 #ifndef TARGET_H
 #define TARGET_H
 
 #ifndef TARGET_H
 #define TARGET_H
 

-struct emit_ops;
-
-/* Ways to "resume" a thread.  */
-
-enum resume_kind
-{
-  /* Thread should continue.  */
-  resume_continue,
+#include "target/target.h"
+#include "target/resume.h"
+#include "target/wait.h"
+#include "target/waitstatus.h"
+#include "mem-break.h"

 
 

-  /* Thread should single-step.  */
-  resume_step,
-
-  /* Thread should be stopped.  */
-  resume_stop
-};
+struct emit_ops;
+struct btrace_target_info;
+struct buffer;
+struct process_info;

 
 /* This structure describes how to resume a particular thread (or all
    threads) based on the client's request.  If thread is -1, then this
 
 /* This structure describes how to resume a particular thread (or all
    threads) based on the client's request.  If thread is -1, then this


@@ -53,60 +48,18 @@ struct thread_resume
      thread.  If stopping a thread, and this is 0, the target should
      stop the thread however it best decides to (e.g., SIGSTOP on
      linux; SuspendThread on win32).  This is a host signal value (not
      thread.  If stopping a thread, and this is 0, the target should
      stop the thread however it best decides to (e.g., SIGSTOP on
      linux; SuspendThread on win32).  This is a host signal value (not

-     enum target_signal).  */
+     enum gdb_signal).  */

   int sig;
   int sig;

-};

 
 

-/* 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.  */
-    TARGET_WAITKIND_LOADED,
-
-    /* The program has exec'ed a new executable file.  The new file's
-       pathname is pointed to by value.execd_pathname.  */
-    TARGET_WAITKIND_EXECD,
-
-    /* Nothing of interest to GDB happened, but we stopped anyway.  */
-    TARGET_WAITKIND_SPURIOUS,
-
-    /* An event has occurred, but we should wait again.  In this case,
-       we want to go back to the event loop and wait there for another
-       event from the inferior.  */
-    TARGET_WAITKIND_IGNORE
-  };
-
-struct target_waitstatus
-  {
-    enum target_waitkind kind;
-
-    /* Forked child pid, execd pathname, exit status or signal number.  */
-    union
-      {
-       int integer;
-       enum target_signal sig;
-       ptid_t related_pid;
-       char *execd_pathname;
-      }
-    value;
-  };
-
-/* Options that can be passed to target_ops->wait.  */
-
-#define TARGET_WNOHANG 1
+  /* Range to single step within.  Valid only iff KIND is resume_step.
+
+     Single-step once, and then continuing stepping as long as the
+     thread stops in this range.  (If the range is empty
+     [STEP_RANGE_START == STEP_RANGE_END], then this is a single-step
+     request.)  */
+  CORE_ADDR step_range_start;  /* Inclusive */
+  CORE_ADDR step_range_end;    /* Exclusive */
+};

 
 struct target_ops
 {
 
 struct target_ops
 {


@@ -185,8 +138,8 @@ struct target_ops
      inferior such that it is possible to access memory.
 
      This should generally only be called from client facing routines,
      inferior such that it is possible to access memory.
 
      This should generally only be called from client facing routines,

-     such as gdb_read_memory/gdb_write_memory, or the insert_point
-     callbacks.
+     such as gdb_read_memory/gdb_write_memory, or the GDB breakpoint
+     insertion routine.

 
      Like `read_memory' and `write_memory' below, returns 0 on success
      and errno on failure.  */
 
      Like `read_memory' and `write_memory' below, returns 0 on success
      and errno on failure.  */


@@ -236,17 +189,23 @@ struct target_ops
   int (*read_auxv) (CORE_ADDR offset, unsigned char *myaddr,
                    unsigned int len);
 
   int (*read_auxv) (CORE_ADDR offset, unsigned char *myaddr,
                    unsigned int len);
 

-  /* Insert and remove a break or watchpoint.
-     Returns 0 on success, -1 on failure and 1 on unsupported.
-     The type is coded as follows:
+  /* Returns true if GDB Z breakpoint type TYPE is supported, false
+     otherwise.  The type is coded as follows:

        '0' - software-breakpoint
        '1' - hardware-breakpoint
        '2' - write watchpoint
        '3' - read watchpoint
        '0' - software-breakpoint
        '1' - hardware-breakpoint
        '2' - write watchpoint
        '3' - read watchpoint

-       '4' - access watchpoint  */
+       '4' - access watchpoint
+  */
+  int (*supports_z_point_type) (char z_type);

 
 

-  int (*insert_point) (char type, CORE_ADDR addr, int len);
-  int (*remove_point) (char type, CORE_ADDR addr, int len);
+  /* Insert and remove a break or watchpoint.
+     Returns 0 on success, -1 on failure and 1 on unsupported.  */
+
+  int (*insert_point) (enum raw_bkpt_type type, CORE_ADDR addr,
+                      int size, struct raw_breakpoint *bp);
+  int (*remove_point) (enum raw_bkpt_type type, CORE_ADDR addr,
+                      int size, struct raw_breakpoint *bp);

 
   /* Returns 1 if target was stopped due to a watchpoint hit, 0 otherwise.  */
 
 
   /* Returns 1 if target was stopped due to a watchpoint hit, 0 otherwise.  */
 


@@ -345,9 +304,6 @@ struct target_ops
      the pause call.  */
   void (*unpause_all) (int unfreeze);
 
      the pause call.  */
   void (*unpause_all) (int unfreeze);
 

-  /* Cancel all pending breakpoints hits in all threads.  */
-  void (*cancel_breakpoints) (void);
-

   /* Stabilize all threads.  That is, force them out of jump pads.  */
   void (*stabilize_threads) (void);
 
   /* Stabilize all threads.  That is, force them out of jump pads.  */
   void (*stabilize_threads) (void);
 


@@ -397,6 +353,26 @@ struct target_ops
 
   /* Return true if target supports debugging agent.  */
   int (*supports_agent) (void);
 
   /* Return true if target supports debugging agent.  */
   int (*supports_agent) (void);

+
+  /* Check whether the target supports branch tracing.  */
+  int (*supports_btrace) (struct target_ops *);
+
+  /* Enable branch tracing for @ptid and allocate a branch trace target
+     information struct for reading and for disabling branch trace.  */
+  struct btrace_target_info *(*enable_btrace) (ptid_t ptid);
+
+  /* Disable branch tracing.
+     Returns zero on success, non-zero otherwise.  */
+  int (*disable_btrace) (struct btrace_target_info *tinfo);
+
+  /* Read branch trace data into buffer.  We use an int to specify the type
+     to break a cyclic dependency.
+     Return 0 on success; print an error message into BUFFER and return -1,
+     otherwise.  */
+  int (*read_btrace) (struct btrace_target_info *, struct buffer *, int type);
+
+  /* Return true if target supports range stepping.  */
+  int (*supports_range_stepping) (void);

 };
 
 extern struct target_ops *the_target;
 };
 
 extern struct target_ops *the_target;


@@ -409,8 +385,7 @@ void set_target_ops (struct target_ops *);
 #define myattach(pid) \
   (*the_target->attach) (pid)
 
 #define myattach(pid) \
   (*the_target->attach) (pid)
 

-#define kill_inferior(pid) \
-  (*the_target->kill) (pid)
+int kill_inferior (int);

 
 #define detach_inferior(pid) \
   (*the_target->detach) (pid)
 
 #define detach_inferior(pid) \
   (*the_target->detach) (pid)


@@ -475,13 +450,6 @@ void set_target_ops (struct target_ops *);
        (*the_target->unpause_all) (unfreeze);  \
     } while (0)
 
        (*the_target->unpause_all) (unfreeze);  \
     } while (0)
 

-#define cancel_breakpoints()                   \
-  do                                           \
-    {                                          \
-      if (the_target->cancel_breakpoints)      \
-       (*the_target->cancel_breakpoints) ();   \
-    } while (0)
-

 #define stabilize_threads()                    \
   do                                           \
     {                                          \
 #define stabilize_threads()                    \
   do                                           \
     {                                          \


@@ -521,6 +489,23 @@ void set_target_ops (struct target_ops *);
   (the_target->supports_agent ? \
    (*the_target->supports_agent) () : 0)
 
   (the_target->supports_agent ? \
    (*the_target->supports_agent) () : 0)
 

+#define target_supports_btrace()                       \
+  (the_target->supports_btrace                         \
+   ? (*the_target->supports_btrace) (the_target) : 0)
+
+#define target_enable_btrace(ptid) \
+  (*the_target->enable_btrace) (ptid)
+
+#define target_disable_btrace(tinfo) \
+  (*the_target->disable_btrace) (tinfo)
+
+#define target_read_btrace(tinfo, buffer, type)        \
+  (*the_target->read_btrace) (tinfo, buffer, type)
+
+#define target_supports_range_stepping() \
+  (the_target->supports_range_stepping ? \
+   (*the_target->supports_range_stepping) () : 0)
+

 /* Start non-stop mode, returns 0 on success, -1 on failure.   */
 
 int start_non_stop (int nonstop);
 /* Start non-stop mode, returns 0 on success, -1 on failure.   */
 
 int start_non_stop (int nonstop);


@@ -549,10 +534,8 @@ int read_inferior_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len);
 int write_inferior_memory (CORE_ADDR memaddr, const unsigned char *myaddr,
                           int len);
 
 int write_inferior_memory (CORE_ADDR memaddr, const unsigned char *myaddr,
                           int len);
 

-void set_desired_inferior (int id);
+void set_desired_thread (int id);

 
 const char *target_pid_to_str (ptid_t);
 
 
 const char *target_pid_to_str (ptid_t);
 

-const char *target_waitstatus_to_string (const struct target_waitstatus *);
-

 #endif /* TARGET_H */
 #endif /* TARGET_H */