← Back to branch summary

~ubuntu-branches/ubuntu/utopic/binutils-arm64-cross/utopic

« back to all changes in this revision

Viewing changes to binutils-2.23.52.20130611/gold/gold-threads.cc

  • Committer: Package Import Robot
  • Author(s): Matthias Klose
  • Date: 2013-06-20 17:38:09 UTC
  • Revision ID: package-import@ubuntu.com-20130620173809-app8lzgvymy5fg6c
Tags: 0.7
Build-depend on binutils-source (>= 2.23.52.20130620-1~).

Show diffs side-by-side

added added

removed removed

Lines of Context:
binutils-2.23.52.20130611/gold/gold-threads.cc
 
1
// gold-threads.cc -- thread support for gold
 
2
 
 
3
// Copyright 2006, 2007, 2008, 2009, 2010 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_mutextattr_init failed: %s"), strerror(err));
 
104
#ifdef PTHREAD_MUTEX_ADAPTIVE_NP
 
105
  err = pthread_mutextattr_settype(&attr, PTHREAD_MUTEX_ADAPTIVE_NP);
 
106
  if (err != 0)
 
107
    gold_fatal(_("pthread_mutextattr_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), was_run_lock_(0)
 
339
{
 
340
#ifndef ENABLE_THREADS
 
341
  this->once_ = NULL;
 
342
#else
 
343
  this->once_ = new Once_initialize();
 
344
#endif
 
345
}
 
346
 
 
347
// Run the function once.
 
348
 
 
349
void
 
350
Once::run_once(void* arg)
 
351
{
 
352
#ifndef ENABLE_THREADS
 
353
 
 
354
  // If there is no threads support, we don't need to use pthread_once.
 
355
  if (!this->was_run_)
 
356
    this->internal_run(arg);
 
357
 
 
358
#else // defined(ENABLE_THREADS)
 
359
 
 
360
  if (parameters->options_valid() && !parameters->options().threads())
 
361
    {
 
362
      // If we are not using threads, we don't need to lock.
 
363
      if (!this->was_run_)
 
364
        this->internal_run(arg);
 
365
      return;
 
366
    }
 
367
 
 
368
  // If we have the sync builtins, use them to skip the lock if the
 
369
  // value has already been initialized.
 
370
#ifdef __GCC_HAVE_SYNC_COMPARE_AND_SWAP_4
 
371
  while (true)
 
372
    {
 
373
      if (__sync_bool_compare_and_swap(&this->was_run_lock_, 0, 1))
 
374
        break;
 
375
    }
 
376
  bool was_run = this->was_run_;
 
377
  while (true)
 
378
    {
 
379
      if (__sync_bool_compare_and_swap(&this->was_run_lock_, 1, 0))
 
380
        break;
 
381
    }
 
382
  if (was_run)
 
383
    return;
 
384
#endif
 
385
 
 
386
  // Since we can't pass parameters to routines called by
 
387
  // pthread_once, we use a static variable: once_pointer.  This in
 
388
  // turns means that we need to use a mutex to control access to
 
389
  // once_pointer.
 
390
 
 
391
  int err = pthread_mutex_lock(&once_pointer_control);
 
392
  if (err != 0)
 
393
    gold_fatal(_("pthread_mutex_lock failed: %s"), strerror(err));
 
394
 
 
395
  once_pointer = this;
 
396
  once_arg = arg;
 
397
 
 
398
  err = pthread_once(this->once_->once_control(), c_run_once);
 
399
  if (err != 0)
 
400
    gold_fatal(_("pthread_once failed: %s"), strerror(err));
 
401
 
 
402
  once_pointer = NULL;
 
403
  once_arg = NULL;
 
404
 
 
405
  err = pthread_mutex_unlock(&once_pointer_control);
 
406
  if (err != 0)
 
407
    gold_fatal(_("pthread_mutex_unlock failed: %s"), strerror(err));
 
408
 
 
409
#endif // defined(ENABLE_THREADS)
 
410
}
 
411
 
 
412
// Actually run the function in the child class.  This function will
 
413
// be run only once.
 
414
 
 
415
void
 
416
Once::internal_run(void* arg)
 
417
{
 
418
  this->do_run_once(arg);
 
419
  this->was_run_ = true;
 
420
}
 
421
 
 
422
// Class Initialize_lock.
 
423
 
 
424
// Initialize the lock.
 
425
 
 
426
bool
 
427
Initialize_lock::initialize()
 
428
{
 
429
  // We can't initialize the lock until we have read the options.
 
430
  if (!parameters->options_valid())
 
431
    return false;
 
432
  else
 
433
    {
 
434
      this->run_once(NULL);
 
435
      return true;
 
436
    }
 
437
}
 
438
 
 
439
// Initialize the lock exactly once.
 
440
 
 
441
void
 
442
Initialize_lock::do_run_once(void*)
 
443
{
 
444
  *this->pplock_ = new Lock();
 
445
}
 
446
 
 
447
} // End namespace gold.