gdbserver/linux-low: turn 'get_syscall_trapinfo' into a method

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

diff --git a/gdbserver/linux-low.h b/gdbserver/linux-low.h
index 58e5e67c1982e9247f62b82cd65a6355318c0dfe..1f1c3820edbd71f90e2cc129e6916df40e3879de 100644 (file)
--- a/gdbserver/linux-low.h
+++ b/gdbserver/linux-low.h
@@ -131,39 +131,6 @@ struct lwp_info;
 
 struct linux_target_ops
 {
-  /* Install a fast tracepoint jump pad.  See target.h for
-     comments.  */
-  int (*install_fast_tracepoint_jump_pad) (CORE_ADDR tpoint, CORE_ADDR tpaddr,
-                                          CORE_ADDR collector,
-                                          CORE_ADDR lockaddr,
-                                          ULONGEST orig_size,
-                                          CORE_ADDR *jump_entry,
-                                          CORE_ADDR *trampoline,
-                                          ULONGEST *trampoline_size,
-                                          unsigned char *jjump_pad_insn,
-                                          ULONGEST *jjump_pad_insn_size,
-                                          CORE_ADDR *adjusted_insn_addr,
-                                          CORE_ADDR *adjusted_insn_addr_end,
-                                          char *err);
-
-  /* Return the bytecode operations vector for the current inferior.
-     Returns NULL if bytecode compilation is not supported.  */
-  struct emit_ops *(*emit_ops) (void);
-
-  /* Return the minimum length of an instruction that can be safely overwritten
-     for use as a fast tracepoint.  */
-  int (*get_min_fast_tracepoint_insn_len) (void);
-
-  /* Returns true if the low target supports range stepping.  */
-  int (*supports_range_stepping) (void);
-
-  /* See target.h.  */
-  int (*supports_hardware_single_step) (void);
-
-  /* Fill *SYSNO with the syscall nr trapped.  Only to be called when
-     inferior is stopped due to SYSCALL_SIGTRAP.  */
-  void (*get_syscall_trapinfo) (struct regcache *regcache, int *sysno);
-
   /* See target.h.  */
   int (*get_ipa_tdesc_idx) (void);
 };
@@ -303,26 +270,6 @@ public:
 
   void stabilize_threads () override;
 
-  bool supports_fast_tracepoints () override;
-
-  int install_fast_tracepoint_jump_pad (CORE_ADDR tpoint,
-                                       CORE_ADDR tpaddr,
-                                       CORE_ADDR collector,
-                                       CORE_ADDR lockaddr,
-                                       ULONGEST orig_size,
-                                       CORE_ADDR *jump_entry,
-                                       CORE_ADDR *trampoline,
-                                       ULONGEST *trampoline_size,
-                                       unsigned char *jjump_pad_insn,
-                                       ULONGEST *jjump_pad_insn_size,
-                                       CORE_ADDR *adjusted_insn_addr,
-                                       CORE_ADDR *adjusted_insn_addr_end,
-                                       char *err) override;
-
-  int get_min_fast_tracepoint_insn_len () override;
-
-  struct emit_ops *emit_ops () override;
-
   bool supports_disable_randomization () override;
 
   bool supports_qxfer_libraries_svr4 () override;
@@ -447,6 +394,12 @@ private:
      events.  */
   void complete_ongoing_step_over ();
 
+  /* Finish a step-over.  Reinsert the breakpoint we had uninserted in
+     start_step_over, if still there, and delete any single-step
+     breakpoints we've set, on non hardware single-step targets.
+     Return true if step over finished.  */
+  bool finish_step_over (lwp_info *lwp);
+
   /* When we finish a step-over, set threads running again.  If there's
      another thread that may need a step-over, now's the time to start
      it.  Eventually, we'll move all threads past their breakpoints.  */
@@ -565,6 +518,9 @@ private:
      or can't single step.  */
   int single_step (lwp_info* lwp);
 
+  /* Return true if THREAD is doing hardware single step.  */
+  bool maybe_hw_step (thread_info *thread);
+
   /* Install breakpoints for software single stepping.  */
   void install_software_single_step_breakpoints (lwp_info *lwp);
 
@@ -631,6 +587,14 @@ private: /* Back to private.  */
   fast_tpoint_collect_result linux_fast_tracepoint_collecting
     (lwp_info *lwp, fast_tpoint_collect_status *status);
 
+  /* This function should only be called if LWP got a SYSCALL_SIGTRAP.
+     Fill *SYSNO with the syscall nr trapped.  */
+  void get_syscall_trapinfo (lwp_info *lwp, int *sysno);
+
+  /* Returns true if GDB is interested in the event_child syscall.
+     Only to be called when stopped reason is SYSCALL_SIGTRAP.  */
+  bool gdb_catch_this_syscall (lwp_info *event_child);
+
 protected:
   /* The architecture-specific "low" methods are listed below.  */
 
@@ -721,6 +685,17 @@ protected:
      success, -1 on failure.  */
   virtual int low_get_thread_area (int lwpid, CORE_ADDR *addrp);
 
+  /* Returns true if the low target supports range stepping.  */
+  virtual bool low_supports_range_stepping ();
+
+  /* Return true if the target supports catch syscall.  Such targets
+     override the low_get_syscall_trapinfo method below.  */
+  virtual bool low_supports_catch_syscall ();
+
+  /* Fill *SYSNO with the syscall nr trapped.  Only to be called when
+     inferior is stopped due to SYSCALL_SIGTRAP.  */
+  virtual void low_get_syscall_trapinfo (regcache *regcache, int *sysno);
+
   /* How many bytes the PC should be decremented after a break.  */
   virtual int low_decr_pc_after_break ();
 };