ODR warnings for "struct coff_symbol"

[binutils-gdb.git] / gdb / fbsd-nat.h

diff --git a/gdb/fbsd-nat.h b/gdb/fbsd-nat.h
index 772655d320e6a5cd4e14cfc4d73acf62b3c63423..3a13bc8711f12a6e553e5350d2606ea22b20b477 100644 (file)
--- a/gdb/fbsd-nat.h
+++ b/gdb/fbsd-nat.h
@@ -1,6 +1,6 @@
 /* Native-dependent code for FreeBSD.
 
-   Copyright (C) 2004-2021 Free Software Foundation, Inc.
+   Copyright (C) 2004-2022 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
@@ -21,6 +21,8 @@
 #define FBSD_NAT_H
 
 #include "inf-ptrace.h"
+#include "regcache.h"
+#include "regset.h"
 #include <osreldate.h>
 #include <sys/proc.h>
 
@@ -42,7 +44,7 @@
 class fbsd_nat_target : public inf_ptrace_target
 {
 public:
-  char *pid_to_exec_file (int pid) override;
+  const char *pid_to_exec_file (int pid) override;
 
   int find_memory_regions (find_memory_region_ftype func, void *data) override;
 
@@ -64,14 +66,20 @@ public:
 
   void update_thread_list () override;
 
+  bool can_async_p () override;
+
+  void async (int) override;
+
   thread_control_capabilities get_thread_control_capabilities () override
   { return tc_schedlock; }
 
+  void create_inferior (const char *, const std::string &,
+                       char **, int) override;
+
   void resume (ptid_t, int, enum gdb_signal) override;
 
   ptid_t wait (ptid_t, struct target_waitstatus *, target_wait_flags) override;
 
-  void post_startup_inferior (ptid_t) override;
   void post_attach (int) override;
 
 #ifdef USE_SIGTRAP_SIGINFO
@@ -80,7 +88,7 @@ public:
 #endif
 
 #ifdef TDP_RFPPWAIT
-  void follow_fork (bool, bool) override;
+  void follow_fork (inferior *, ptid_t, target_waitkind, bool, bool) override;
 
   int insert_fork_catchpoint (int) override;
   int remove_fork_catchpoint (int) override;
@@ -98,6 +106,114 @@ public:
 #endif
 
   bool supports_multi_process () override;
+
+  bool supports_disable_randomization () override;
+
+  /* Methods meant to be overridden by arch-specific target
+     classes.  */
+
+  virtual void low_new_fork (ptid_t parent, pid_t child)
+  {}
+
+  /* The method to call, if any, when a thread is destroyed.  */
+  virtual void low_delete_thread (thread_info *)
+  {}
+
+  /* Hook to call prior to resuming a thread.  */
+  virtual void low_prepare_to_resume (thread_info *)
+  {}
+
+protected:
+
+  void post_startup_inferior (ptid_t) override;
+
+private:
+  ptid_t wait_1 (ptid_t, struct target_waitstatus *, target_wait_flags);
+
+  /* Helper routines for use in fetch_registers and store_registers in
+     subclasses.  These routines fetch and store a single set of
+     registers described by REGSET.  The REGSET's 'regmap' field must
+     point to an array of 'struct regcache_map_entry'.
+
+     FETCH_OP is a ptrace operation to fetch the set of registers from
+     a native thread.  STORE_OP is a ptrace operation to store the set
+     of registers to a native thread.
+
+     The caller must provide storage for the set of registers in REGS,
+     and SIZE is the size of the storage.
+
+     Returns true if the register set was transferred due to a
+     matching REGNUM.*/
+
+  bool fetch_register_set (struct regcache *regcache, int regnum, int fetch_op,
+                          const struct regset *regset, void *regs, size_t size);
+
+  bool store_register_set (struct regcache *regcache, int regnum, int fetch_op,
+                          int store_op, const struct regset *regset,
+                          void *regs, size_t size);
+
+  /* Helper routines which use PT_GETREGSET and PT_SETREGSET for the
+     specified NOTE instead of regset-specific fetch and store
+     ops.  */
+
+  bool fetch_regset (struct regcache *regcache, int regnum, int note,
+                    const struct regset *regset, void *regs, size_t size);
+
+  bool store_regset (struct regcache *regcache, int regnum, int note,
+                    const struct regset *regset, void *regs, size_t size);
+
+protected:
+  /* Wrapper versions of the above helpers which accept a register set
+     type such as 'struct reg' or 'struct fpreg'.  */
+
+  template <class Regset>
+  bool fetch_register_set (struct regcache *regcache, int regnum, int fetch_op,
+                          const struct regset *regset)
+  {
+    Regset regs;
+    return fetch_register_set (regcache, regnum, fetch_op, regset, &regs,
+                              sizeof (regs));
+  }
+
+  template <class Regset>
+  bool store_register_set (struct regcache *regcache, int regnum, int fetch_op,
+                          int store_op, const struct regset *regset)
+  {
+    Regset regs;
+    return store_register_set (regcache, regnum, fetch_op, store_op, regset,
+                              &regs, sizeof (regs));
+  }
+
+  /* Helper routine for use in read_description in subclasses.  This
+     routine checks if the register set for the specified NOTE is
+     present for a given PTID.  If the register set is present, the
+     the size of the register set is returned.  If the register set is
+     not present, zero is returned.  */
+
+  bool have_regset (ptid_t ptid, int note);
+
+  /* Wrapper versions of the PT_GETREGSET and PT_REGSET helpers which
+     accept a register set type.  */
+
+  template <class Regset>
+  bool fetch_regset (struct regcache *regcache, int regnum, int note,
+                    const struct regset *regset)
+  {
+    Regset regs;
+    return fetch_regset (regcache, regnum, note, regset, &regs, sizeof (regs));
+  }
+
+  template <class Regset>
+  bool store_regset (struct regcache *regcache, int regnum, int note,
+                    const struct regset *regset)
+  {
+    Regset regs;
+    return store_regset (regcache, regnum, note, regset, &regs, sizeof (regs));
+  }
 };
 
+/* Fetch the signal information for PTID and store it in *SIGINFO.
+   Return true if successful.  */
+bool fbsd_nat_get_siginfo (ptid_t ptid, siginfo_t *siginfo);
+
 #endif /* fbsd-nat.h */