Merge branch 'vendor/GCC50'
[dragonfly.git] / contrib / binutils-2.25 / gold / gold-threads.h
1 // gold-threads.h -- thread support for gold  -*- C++ -*-
2
3 // Copyright (C) 2006-2014 Free Software Foundation, Inc.
4 // Written by Ian Lance Taylor <iant@google.com>.
5
6 // This file is part of gold.
7
8 // This program is free software; you can redistribute it and/or modify
9 // it under the terms of the GNU General Public License as published by
10 // the Free Software Foundation; either version 3 of the License, or
11 // (at your option) any later version.
12
13 // This program is distributed in the hope that it will be useful,
14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 // GNU General Public License for more details.
17
18 // You should have received a copy of the GNU General Public License
19 // along with this program; if not, write to the Free Software
20 // Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 // MA 02110-1301, USA.
22
23 // gold can be configured to support threads.  If threads are
24 // supported, the user can specify at runtime whether or not to
25 // support them.  This provides an interface to manage locking
26 // accordingly.
27
28 // Lock
29 //   A simple lock class.
30
31 #ifndef GOLD_THREADS_H
32 #define GOLD_THREADS_H
33
34 namespace gold
35 {
36
37 class Condvar;
38 class Once_initialize;
39 class Initialize_lock_once;
40
41 // The interface for the implementation of a Lock.
42
43 class Lock_impl
44 {
45  public:
46   Lock_impl()
47   { }
48
49   virtual
50   ~Lock_impl()
51   { }
52
53   virtual void
54   acquire() = 0;
55
56   virtual void
57   release() = 0;
58 };
59
60 // A simple lock class.
61
62 class Lock
63 {
64  public:
65   Lock();
66
67   ~Lock();
68
69   // Acquire the lock.
70   void
71   acquire()
72   { this->lock_->acquire(); }
73
74   // Release the lock.
75   void
76   release()
77   { this->lock_->release(); }
78
79  private:
80   // This class can not be copied.
81   Lock(const Lock&);
82   Lock& operator=(const Lock&);
83
84   friend class Condvar;
85   Lock_impl*
86   get_impl() const
87   { return this->lock_; }
88
89   Lock_impl* lock_;
90 };
91
92 // RAII for Lock.
93
94 class Hold_lock
95 {
96  public:
97   Hold_lock(Lock& lock)
98     : lock_(lock)
99   { this->lock_.acquire(); }
100
101   ~Hold_lock()
102   { this->lock_.release(); }
103
104  private:
105   // This class can not be copied.
106   Hold_lock(const Hold_lock&);
107   Hold_lock& operator=(const Hold_lock&);
108
109   Lock& lock_;
110 };
111
112 class Hold_optional_lock
113 {
114  public:
115   Hold_optional_lock(Lock* lock)
116     : lock_(lock)
117   {
118     if (this->lock_ != NULL)
119       this->lock_->acquire();
120   }
121
122   ~Hold_optional_lock()
123   {
124     if (this->lock_ != NULL)
125       this->lock_->release();
126   }
127
128  private:
129   Hold_optional_lock(const Hold_optional_lock&);
130   Hold_optional_lock& operator=(const Hold_optional_lock&);
131
132   Lock* lock_;
133 };
134
135 // The interface for the implementation of a condition variable.
136
137 class Condvar_impl
138 {
139  public:
140   Condvar_impl()
141   { }
142
143   virtual
144   ~Condvar_impl()
145   { }
146
147   virtual void
148   wait(Lock_impl*) = 0;
149
150   virtual void
151   signal() = 0;
152
153   virtual void
154   broadcast() = 0;
155 };
156
157 // A simple condition variable class.  It is always associated with a
158 // specific lock.
159
160 class Condvar
161 {
162  public:
163   Condvar(Lock& lock);
164   ~Condvar();
165
166   // Wait for the condition variable to be signalled.  This should
167   // only be called when the lock is held.
168   void
169   wait()
170   { this->condvar_->wait(this->lock_.get_impl()); }
171
172   // Signal the condition variable--wake up at least one thread
173   // waiting on the condition variable.  This should only be called
174   // when the lock is held.
175   void
176   signal()
177   { this->condvar_->signal(); }
178
179   // Broadcast the condition variable--wake up all threads waiting on
180   // the condition variable.  This should only be called when the lock
181   // is held.
182   void
183   broadcast()
184   { this->condvar_->broadcast(); }
185
186  private:
187   // This class can not be copied.
188   Condvar(const Condvar&);
189   Condvar& operator=(const Condvar&);
190
191   Lock& lock_;
192   Condvar_impl* condvar_;
193 };
194
195 // A class used to do something once.  This is an abstract parent
196 // class; any actual use will involve a child of this.
197
198 class Once
199 {
200  public:
201   Once();
202
203   virtual
204   ~Once()
205   { }
206
207   // Call this function to do whatever it is.  We pass an argument
208   // even though you have to use a child class because in some uses
209   // setting the argument would itself require a Once class.
210   void
211   run_once(void* arg);
212
213   // This is an internal function, which must be public because it is
214   // run by an extern "C" function called via pthread_once.
215   void
216   internal_run(void* arg);
217
218  protected:
219   // This must be implemented by the child class.
220   virtual void
221   do_run_once(void* arg) = 0;
222
223  private:
224   // True if we have already run the function.
225   bool was_run_;
226 #if defined(ENABLE_THREADS) && defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4)
227   // Internal compare-and-swap lock on was_run_;
228   uint32_t was_run_lock_;
229 #endif
230   // The lock to run the function only once.
231   Once_initialize* once_;
232 };
233
234 // A class used to initialize a lock exactly once, after the options
235 // have been read.  This is needed because the implementation of locks
236 // depends on whether we've seen the --threads option.  Before the
237 // options have been read, we know we are single-threaded, so we can
238 // get by without using a lock.  This class should be an instance
239 // variable of the class which has a lock which needs to be
240 // initialized.
241
242 class Initialize_lock : public Once
243 {
244  public:
245   // The class which uses this will have a pointer to a lock.  This
246   // must be constructed with a pointer to that pointer.
247   Initialize_lock(Lock** pplock)
248     : pplock_(pplock)
249   { }
250
251   // Initialize the lock.  Return true if the lock is now initialized,
252   // false if it is not (because the options have not yet been read).
253   bool
254   initialize();
255
256  protected:
257   void
258   do_run_once(void*);
259
260  private:
261   // A pointer to the lock pointer which must be initialized.
262   Lock** const pplock_;
263 };
264
265 } // End namespace gold.
266
267 #endif // !defined(GOLD_THREADS_H)