gdb: add target_ops::supports_displaced_step

[deliverable/binutils-gdb.git] / gold / gold-threads.h

diff --git a/gold/gold-threads.h b/gold/gold-threads.h
index 45f18ad2c5c0ffbd0447133c31b9ec92368883bf..48388aef6425d9afc836d40c2cf704c04367df35 100644 (file)
--- a/gold/gold-threads.h
+++ b/gold/gold-threads.h
@@ -1,6 +1,6 @@
 // gold-threads.h -- thread support for gold  -*- C++ -*-
 
-// Copyright 2006, 2007 Free Software Foundation, Inc.
+// Copyright (C) 2006-2020 Free Software Foundation, Inc.
 // Written by Ian Lance Taylor <iant@google.com>.
 
 // This file is part of gold.
@@ -35,6 +35,8 @@ namespace gold
 {
 
 class Condvar;
+class Once_initialize;
+class Initialize_lock_once;
 
 // The interface for the implementation of a Lock.
 
@@ -107,6 +109,29 @@ class Hold_lock
   Lock& lock_;
 };
 
+class Hold_optional_lock
+{
+ public:
+  Hold_optional_lock(Lock* lock)
+    : lock_(lock)
+  {
+    if (this->lock_ != NULL)
+      this->lock_->acquire();
+  }
+
+  ~Hold_optional_lock()
+  {
+    if (this->lock_ != NULL)
+      this->lock_->release();
+  }
+
+ private:
+  Hold_optional_lock(const Hold_optional_lock&);
+  Hold_optional_lock& operator=(const Hold_optional_lock&);
+
+  Lock* lock_;
+};
+
 // The interface for the implementation of a condition variable.
 
 class Condvar_impl
@@ -167,6 +192,76 @@ class Condvar
   Condvar_impl* condvar_;
 };
 
+// A class used to do something once.  This is an abstract parent
+// class; any actual use will involve a child of this.
+
+class Once
+{
+ public:
+  Once();
+
+  virtual
+  ~Once()
+  { }
+
+  // Call this function to do whatever it is.  We pass an argument
+  // even though you have to use a child class because in some uses
+  // setting the argument would itself require a Once class.
+  void
+  run_once(void* arg);
+
+  // This is an internal function, which must be public because it is
+  // run by an extern "C" function called via pthread_once.
+  void
+  internal_run(void* arg);
+
+ protected:
+  // This must be implemented by the child class.
+  virtual void
+  do_run_once(void* arg) = 0;
+
+ private:
+  // True if we have already run the function.
+  bool was_run_;
+#if defined(ENABLE_THREADS) && defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4)
+  // Internal compare-and-swap lock on was_run_;
+  uint32_t was_run_lock_;
+#endif
+  // The lock to run the function only once.
+  Once_initialize* once_;
+};
+
+// A class used to initialize a lock exactly once, after the options
+// have been read.  This is needed because the implementation of locks
+// depends on whether we've seen the --threads option.  Before the
+// options have been read, we know we are single-threaded, so we can
+// get by without using a lock.  This class should be an instance
+// variable of the class which has a lock which needs to be
+// initialized.
+
+class Initialize_lock : public Once
+{
+ public:
+  // The class which uses this will have a pointer to a lock.  This
+  // must be constructed with a pointer to that pointer.
+  Initialize_lock(Lock** pplock)
+    : pplock_(pplock)
+  { }
+
+  // Initialize the lock.  Return true if the lock is now initialized,
+  // false if it is not (because the options have not yet been read).
+  bool
+  initialize();
+
+ protected:
+  void
+  do_run_once(void*);
+
+ private:
+  // A pointer to the lock pointer which must be initialized.
+  Lock** const pplock_;
+};
+
 } // End namespace gold.
 
 #endif // !defined(GOLD_THREADS_H)