Automatic date update in version.in
[external/binutils.git] / gold / gold-threads.cc
1 // gold-threads.cc -- thread support for gold
2
3 // Copyright (C) 2006-2019 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 #include "gold.h"
24
25 #include <cstring>
26
27 #ifdef ENABLE_THREADS
28 #include <pthread.h>
29 #endif
30
31 #include "options.h"
32 #include "parameters.h"
33 #include "gold-threads.h"
34
35 namespace gold
36 {
37
38 class Condvar_impl_nothreads;
39
40 // The non-threaded version of Lock_impl.
41
42 class Lock_impl_nothreads : public Lock_impl
43 {
44  public:
45   Lock_impl_nothreads()
46     : acquired_(false)
47   { }
48
49   ~Lock_impl_nothreads()
50   { gold_assert(!this->acquired_); }
51
52   void
53   acquire()
54   {
55     gold_assert(!this->acquired_);
56     this->acquired_ = true;
57   }
58
59   void
60   release()
61   {
62     gold_assert(this->acquired_);
63     this->acquired_ = false;
64   }
65
66  private:
67   friend class Condvar_impl_nothreads;
68
69   bool acquired_;
70 };
71
72 #ifdef ENABLE_THREADS
73
74 class Condvar_impl_threads;
75
76 // The threaded version of Lock_impl.
77
78 class Lock_impl_threads : public Lock_impl
79 {
80  public:
81   Lock_impl_threads();
82   ~Lock_impl_threads();
83
84   void acquire();
85
86   void release();
87
88 private:
89   // This class can not be copied.
90   Lock_impl_threads(const Lock_impl_threads&);
91   Lock_impl_threads& operator=(const Lock_impl_threads&);
92
93   friend class Condvar_impl_threads;
94
95   pthread_mutex_t mutex_;
96 };
97
98 Lock_impl_threads::Lock_impl_threads()
99 {
100   pthread_mutexattr_t attr;
101   int err = pthread_mutexattr_init(&attr);
102   if (err != 0)
103     gold_fatal(_("pthead_mutexattr_init failed: %s"), strerror(err));
104 #ifdef PTHREAD_MUTEX_ADAPTIVE_NP
105   err = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ADAPTIVE_NP);
106   if (err != 0)
107     gold_fatal(_("pthread_mutexattr_settype failed: %s"), strerror(err));
108 #endif
109
110   err = pthread_mutex_init(&this->mutex_, &attr);
111   if (err != 0)
112     gold_fatal(_("pthread_mutex_init failed: %s"), strerror(err));
113
114   err = pthread_mutexattr_destroy(&attr);
115   if (err != 0)
116     gold_fatal(_("pthread_mutexattr_destroy failed: %s"), strerror(err));
117 }
118
119 Lock_impl_threads::~Lock_impl_threads()
120 {
121   int err = pthread_mutex_destroy(&this->mutex_);
122   if (err != 0)
123     gold_fatal(_("pthread_mutex_destroy failed: %s"), strerror(err));
124 }
125
126 void
127 Lock_impl_threads::acquire()
128 {
129   int err = pthread_mutex_lock(&this->mutex_);
130   if (err != 0)
131     gold_fatal(_("pthread_mutex_lock failed: %s"), strerror(err));
132 }
133
134 void
135 Lock_impl_threads::release()
136 {
137   int err = pthread_mutex_unlock(&this->mutex_);
138   if (err != 0)
139     gold_fatal(_("pthread_mutex_unlock failed: %s"), strerror(err));
140 }
141
142 #endif // defined(ENABLE_THREADS)
143
144 // Class Lock.
145
146 Lock::Lock()
147 {
148   if (!parameters->options().threads())
149     this->lock_ = new Lock_impl_nothreads;
150   else
151     {
152 #ifdef ENABLE_THREADS
153       this->lock_ = new Lock_impl_threads;
154 #else
155       gold_unreachable();
156 #endif
157     }
158 }
159
160 Lock::~Lock()
161 {
162   delete this->lock_;
163 }
164
165 // The non-threaded version of Condvar_impl.
166
167 class Condvar_impl_nothreads : public Condvar_impl
168 {
169  public:
170   Condvar_impl_nothreads()
171   { }
172
173   ~Condvar_impl_nothreads()
174   { }
175
176   void
177   wait(Lock_impl* li)
178   { gold_assert(static_cast<Lock_impl_nothreads*>(li)->acquired_); }
179
180   void
181   signal()
182   { }
183
184   void
185   broadcast()
186   { }
187 };
188
189 #ifdef ENABLE_THREADS
190
191 // The threaded version of Condvar_impl.
192
193 class Condvar_impl_threads : public Condvar_impl
194 {
195  public:
196   Condvar_impl_threads();
197   ~Condvar_impl_threads();
198
199   void
200   wait(Lock_impl*);
201
202   void
203   signal();
204
205   void
206   broadcast();
207
208  private:
209   // This class can not be copied.
210   Condvar_impl_threads(const Condvar_impl_threads&);
211   Condvar_impl_threads& operator=(const Condvar_impl_threads&);
212
213   pthread_cond_t cond_;
214 };
215
216 Condvar_impl_threads::Condvar_impl_threads()
217 {
218   int err = pthread_cond_init(&this->cond_, NULL);
219   if (err != 0)
220     gold_fatal(_("pthread_cond_init failed: %s"), strerror(err));
221 }
222
223 Condvar_impl_threads::~Condvar_impl_threads()
224 {
225   int err = pthread_cond_destroy(&this->cond_);
226   if (err != 0)
227     gold_fatal(_("pthread_cond_destroy failed: %s"), strerror(err));
228 }
229
230 void
231 Condvar_impl_threads::wait(Lock_impl* li)
232 {
233   Lock_impl_threads* lit = static_cast<Lock_impl_threads*>(li);
234   int err = pthread_cond_wait(&this->cond_, &lit->mutex_);
235   if (err != 0)
236     gold_fatal(_("pthread_cond_wait failed: %s"), strerror(err));
237 }
238
239 void
240 Condvar_impl_threads::signal()
241 {
242   int err = pthread_cond_signal(&this->cond_);
243   if (err != 0)
244     gold_fatal(_("pthread_cond_signal failed: %s"), strerror(err));
245 }
246
247 void
248 Condvar_impl_threads::broadcast()
249 {
250   int err = pthread_cond_broadcast(&this->cond_);
251   if (err != 0)
252     gold_fatal(_("pthread_cond_broadcast failed: %s"), strerror(err));
253 }
254
255 #endif // defined(ENABLE_THREADS)
256
257 // Methods for Condvar class.
258
259 Condvar::Condvar(Lock& lock)
260   : lock_(lock)
261 {
262   if (!parameters->options().threads())
263     this->condvar_ = new Condvar_impl_nothreads;
264   else
265     {
266 #ifdef ENABLE_THREADS
267       this->condvar_ = new Condvar_impl_threads;
268 #else
269       gold_unreachable();
270 #endif
271     }
272 }
273
274 Condvar::~Condvar()
275 {
276   delete this->condvar_;
277 }
278
279 #ifdef ENABLE_THREADS
280
281 // Class Once_initialize.  This exists to hold a pthread_once_t
282 // structure for Once.
283
284 class Once_initialize
285 {
286  public:
287   Once_initialize()
288     : once_(PTHREAD_ONCE_INIT)
289   { }
290
291   // Return a pointer to the pthread_once_t variable.
292   pthread_once_t*
293   once_control()
294   { return &this->once_; }
295
296  private:
297   pthread_once_t once_;
298 };
299
300 #endif // defined(ENABLE_THREADS)
301
302 #ifdef ENABLE_THREADS
303
304 // A single lock which controls access to once_pointer.  This is used
305 // because we can't pass parameters to functions passed to
306 // pthread_once.
307
308 static pthread_mutex_t once_pointer_control = PTHREAD_MUTEX_INITIALIZER;
309
310 // A pointer to Once structure we want to run.  Access to this is
311 // controlled by once_pointer_control.
312
313 static Once* once_pointer;
314
315 // The argument to pass to the Once structure.  Access to this is
316 // controlled by once_pointer_control.
317
318 static void* once_arg;
319
320 // A routine passed to pthread_once which runs the Once pointer.
321
322 extern "C"
323 {
324
325 static void
326 c_run_once(void)
327 {
328   once_pointer->internal_run(once_arg);
329 }
330
331 }
332
333 #endif // defined(ENABLE_THREADS)
334
335 // Class Once.
336
337 Once::Once()
338   : was_run_(false)
339 #if defined(ENABLE_THREADS) && defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4)
340     , was_run_lock_(0)
341 #endif
342 {
343 #ifndef ENABLE_THREADS
344   this->once_ = NULL;
345 #else
346   this->once_ = new Once_initialize();
347 #endif
348 }
349
350 // Run the function once.
351
352 void
353 Once::run_once(void* arg)
354 {
355 #ifndef ENABLE_THREADS
356
357   // If there is no threads support, we don't need to use pthread_once.
358   if (!this->was_run_)
359     this->internal_run(arg);
360
361 #else // defined(ENABLE_THREADS)
362
363   if (parameters->options_valid() && !parameters->options().threads())
364     {
365       // If we are not using threads, we don't need to lock.
366       if (!this->was_run_)
367         this->internal_run(arg);
368       return;
369     }
370
371   // If we have the sync builtins, use them to skip the lock if the
372   // value has already been initialized.
373 #ifdef __GCC_HAVE_SYNC_COMPARE_AND_SWAP_4
374   while (true)
375     {
376       if (__sync_bool_compare_and_swap(&this->was_run_lock_, 0, 1))
377         break;
378     }
379   bool was_run = this->was_run_;
380   while (true)
381     {
382       if (__sync_bool_compare_and_swap(&this->was_run_lock_, 1, 0))
383         break;
384     }
385   if (was_run)
386     return;
387 #endif
388
389   // Since we can't pass parameters to routines called by
390   // pthread_once, we use a static variable: once_pointer.  This in
391   // turns means that we need to use a mutex to control access to
392   // once_pointer.
393
394   int err = pthread_mutex_lock(&once_pointer_control);
395   if (err != 0)
396     gold_fatal(_("pthread_mutex_lock failed: %s"), strerror(err));
397
398   once_pointer = this;
399   once_arg = arg;
400
401   err = pthread_once(this->once_->once_control(), c_run_once);
402   if (err != 0)
403     gold_fatal(_("pthread_once failed: %s"), strerror(err));
404
405   once_pointer = NULL;
406   once_arg = NULL;
407
408   err = pthread_mutex_unlock(&once_pointer_control);
409   if (err != 0)
410     gold_fatal(_("pthread_mutex_unlock failed: %s"), strerror(err));
411
412 #endif // defined(ENABLE_THREADS)
413 }
414
415 // Actually run the function in the child class.  This function will
416 // be run only once.
417
418 void
419 Once::internal_run(void* arg)
420 {
421   this->do_run_once(arg);
422   this->was_run_ = true;
423 }
424
425 // Class Initialize_lock.
426
427 // Initialize the lock.
428
429 bool
430 Initialize_lock::initialize()
431 {
432   // We can't initialize the lock until we have read the options.
433   if (!parameters->options_valid())
434     return false;
435   else
436     {
437       this->run_once(NULL);
438       return true;
439     }
440 }
441
442 // Initialize the lock exactly once.
443
444 void
445 Initialize_lock::do_run_once(void*)
446 {
447   *this->pplock_ = new Lock();
448 }
449
450 } // End namespace gold.