Checkin gdb.arch/i386-avx.exp.

[deliverable/binutils-gdb.git] / gdb / gdbserver / linux-low.h

diff --git a/gdb/gdbserver/linux-low.h b/gdb/gdbserver/linux-low.h
index f3f8a609d8551c6eec7eacd3530c1d41129192e2..d7aa41876b12e3ff964d3eebd71ec11793dacc47 100644 (file)
--- a/gdb/gdbserver/linux-low.h
+++ b/gdb/gdbserver/linux-low.h
@@ -24,8 +24,8 @@
 #include "gdb_proc_service.h"
 
 #ifdef HAVE_LINUX_REGSETS
-typedef void (*regset_fill_func) (void *);
-typedef void (*regset_store_func) (const void *);
+typedef void (*regset_fill_func) (struct regcache *, void *);
+typedef void (*regset_store_func) (struct regcache *, const void *);
 enum regset_type {
   GENERAL_REGS,
   FP_REGS,
@@ -70,8 +70,8 @@ struct linux_target_ops
      store the register, and 2 if failure to store the register
      is acceptable.  */
   int (*cannot_store_register) (int);
-  CORE_ADDR (*get_pc) (void);
-  void (*set_pc) (CORE_ADDR newpc);
+  CORE_ADDR (*get_pc) (struct regcache *regcache);
+  void (*set_pc) (struct regcache *regcache, CORE_ADDR newpc);
   const unsigned char *breakpoint;
   int breakpoint_len;
   CORE_ADDR (*breakpoint_reinsert_addr) (void);
@@ -88,8 +88,10 @@ struct linux_target_ops
 
   /* Hooks to reformat register data for PEEKUSR/POKEUSR (in particular
      for registers smaller than an xfer unit).  */
-  void (*collect_ptrace_register) (int regno, char *buf);
-  void (*supply_ptrace_register) (int regno, const char *buf);
+  void (*collect_ptrace_register) (struct regcache *regcache,
+                                  int regno, char *buf);
+  void (*supply_ptrace_register) (struct regcache *regcache,
+                                 int regno, const char *buf);
 
   /* Hook to convert from target format to ptrace format and back.
      Returns true if any conversion was done; false otherwise.
@@ -135,7 +137,8 @@ struct lwp_info
      yet.  */
   int stop_expected;
 
-  /* True if this thread was suspended (with vCont;t).  */
+  /* When this is true, we shall not try to resume this thread, even
+     if last_resume_kind isn't resume_stop.  */
   int suspended;
 
   /* If this flag is set, the lwp is known to be stopped right now (stop
@@ -150,21 +153,31 @@ struct lwp_info
   /* When stopped is set, the last wait status recorded for this lwp.  */
   int last_status;
 
+  /* When stopped is set, this is where the lwp stopped, with
+     decr_pc_after_break already accounted for.  */
+  CORE_ADDR stop_pc;
+
   /* If this flag is set, STATUS_PENDING is a waitstatus that has not yet
      been reported.  */
   int status_pending_p;
   int status_pending;
 
-  /* If this flag is set, the pending status is a (GDB-placed) breakpoint.  */
-  int pending_is_breakpoint;
-  CORE_ADDR pending_stop_pc;
+  /* STOPPED_BY_WATCHPOINT is non-zero if this LWP stopped with a data
+     watchpoint trap.  */
+  int stopped_by_watchpoint;
+
+  /* On architectures where it is possible to know the data address of
+     a triggered watchpoint, STOPPED_DATA_ADDRESS is non-zero, and
+     contains such data address.  Only valid if STOPPED_BY_WATCHPOINT
+     is true.  */
+  CORE_ADDR stopped_data_address;
 
   /* If this is non-zero, it is a breakpoint to be reinserted at our next
      stop (SIGTRAP stops only).  */
   CORE_ADDR bp_reinsert;
 
-  /* If this flag is set, the last continue operation on this process
-     was a single-step.  */
+  /* If this flag is set, the last continue operation at the ptrace
+     level on this process was a single-step.  */
   int stepping;
 
   /* If this flag is set, we need to set the event request flags the
@@ -177,9 +190,15 @@ struct lwp_info
 
   /* A link used when resuming.  It is initialized from the resume request,
      and then processed and cleared in linux_resume_one_lwp.  */
-
   struct thread_resume *resume;
 
+  /* The last resume GDB requested on this thread.  */
+  enum resume_kind last_resume_kind;
+
+  /* True if the LWP was seen stop at an internal breakpoint and needs
+     stepping over later when it is resumed.  */
+  int need_step_over;
+
   int thread_known;
 #ifdef HAVE_THREAD_DB_H
   /* The thread handle, used for e.g. TLS access.  Only valid if