diff options
author | Ben Cheng <bccheng@google.com> | 2014-03-26 11:03:35 -0700 |
---|---|---|
committer | Ben Cheng <bccheng@google.com> | 2014-03-26 11:03:35 -0700 |
commit | 09797ba54abf3683ea66eedddf6afbe7653f9cb9 (patch) | |
tree | 8030b2ed79c7463c89d6da294782e9d503c84f50 /binutils-2.24/gold/gold-threads.cc | |
parent | 5a2caf34e4995860baf405552163df288000b7bf (diff) | |
download | toolchain_binutils-09797ba54abf3683ea66eedddf6afbe7653f9cb9.zip toolchain_binutils-09797ba54abf3683ea66eedddf6afbe7653f9cb9.tar.gz toolchain_binutils-09797ba54abf3683ea66eedddf6afbe7653f9cb9.tar.bz2 |
Initial checkin of binutils 2.24.
Change-Id: I0dfcbae6608dded6c3586bf5f4ac27e9612e70a2
Diffstat (limited to 'binutils-2.24/gold/gold-threads.cc')
-rw-r--r-- | binutils-2.24/gold/gold-threads.cc | 450 |
1 files changed, 450 insertions, 0 deletions
diff --git a/binutils-2.24/gold/gold-threads.cc b/binutils-2.24/gold/gold-threads.cc new file mode 100644 index 0000000..2cb293e --- /dev/null +++ b/binutils-2.24/gold/gold-threads.cc @@ -0,0 +1,450 @@ +// gold-threads.cc -- thread support for gold + +// Copyright 2006, 2007, 2008, 2009, 2010, 2013 Free Software Foundation, Inc. +// Written by Ian Lance Taylor <iant@google.com>. + +// This file is part of gold. + +// This program is free software; you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation; either version 3 of the License, or +// (at your option) any later version. + +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, +// MA 02110-1301, USA. + +#include "gold.h" + +#include <cstring> + +#ifdef ENABLE_THREADS +#include <pthread.h> +#endif + +#include "options.h" +#include "parameters.h" +#include "gold-threads.h" + +namespace gold +{ + +class Condvar_impl_nothreads; + +// The non-threaded version of Lock_impl. + +class Lock_impl_nothreads : public Lock_impl +{ + public: + Lock_impl_nothreads() + : acquired_(false) + { } + + ~Lock_impl_nothreads() + { gold_assert(!this->acquired_); } + + void + acquire() + { + gold_assert(!this->acquired_); + this->acquired_ = true; + } + + void + release() + { + gold_assert(this->acquired_); + this->acquired_ = false; + } + + private: + friend class Condvar_impl_nothreads; + + bool acquired_; +}; + +#ifdef ENABLE_THREADS + +class Condvar_impl_threads; + +// The threaded version of Lock_impl. + +class Lock_impl_threads : public Lock_impl +{ + public: + Lock_impl_threads(); + ~Lock_impl_threads(); + + void acquire(); + + void release(); + +private: + // This class can not be copied. + Lock_impl_threads(const Lock_impl_threads&); + Lock_impl_threads& operator=(const Lock_impl_threads&); + + friend class Condvar_impl_threads; + + pthread_mutex_t mutex_; +}; + +Lock_impl_threads::Lock_impl_threads() +{ + pthread_mutexattr_t attr; + int err = pthread_mutexattr_init(&attr); + if (err != 0) + gold_fatal(_("pthead_mutextattr_init failed: %s"), strerror(err)); +#ifdef PTHREAD_MUTEX_ADAPTIVE_NP + err = pthread_mutextattr_settype(&attr, PTHREAD_MUTEX_ADAPTIVE_NP); + if (err != 0) + gold_fatal(_("pthread_mutextattr_settype failed: %s"), strerror(err)); +#endif + + err = pthread_mutex_init(&this->mutex_, &attr); + if (err != 0) + gold_fatal(_("pthread_mutex_init failed: %s"), strerror(err)); + + err = pthread_mutexattr_destroy(&attr); + if (err != 0) + gold_fatal(_("pthread_mutexattr_destroy failed: %s"), strerror(err)); +} + +Lock_impl_threads::~Lock_impl_threads() +{ + int err = pthread_mutex_destroy(&this->mutex_); + if (err != 0) + gold_fatal(_("pthread_mutex_destroy failed: %s"), strerror(err)); +} + +void +Lock_impl_threads::acquire() +{ + int err = pthread_mutex_lock(&this->mutex_); + if (err != 0) + gold_fatal(_("pthread_mutex_lock failed: %s"), strerror(err)); +} + +void +Lock_impl_threads::release() +{ + int err = pthread_mutex_unlock(&this->mutex_); + if (err != 0) + gold_fatal(_("pthread_mutex_unlock failed: %s"), strerror(err)); +} + +#endif // defined(ENABLE_THREADS) + +// Class Lock. + +Lock::Lock() +{ + if (!parameters->options().threads()) + this->lock_ = new Lock_impl_nothreads; + else + { +#ifdef ENABLE_THREADS + this->lock_ = new Lock_impl_threads; +#else + gold_unreachable(); +#endif + } +} + +Lock::~Lock() +{ + delete this->lock_; +} + +// The non-threaded version of Condvar_impl. + +class Condvar_impl_nothreads : public Condvar_impl +{ + public: + Condvar_impl_nothreads() + { } + + ~Condvar_impl_nothreads() + { } + + void + wait(Lock_impl* li) + { gold_assert(static_cast<Lock_impl_nothreads*>(li)->acquired_); } + + void + signal() + { } + + void + broadcast() + { } +}; + +#ifdef ENABLE_THREADS + +// The threaded version of Condvar_impl. + +class Condvar_impl_threads : public Condvar_impl +{ + public: + Condvar_impl_threads(); + ~Condvar_impl_threads(); + + void + wait(Lock_impl*); + + void + signal(); + + void + broadcast(); + + private: + // This class can not be copied. + Condvar_impl_threads(const Condvar_impl_threads&); + Condvar_impl_threads& operator=(const Condvar_impl_threads&); + + pthread_cond_t cond_; +}; + +Condvar_impl_threads::Condvar_impl_threads() +{ + int err = pthread_cond_init(&this->cond_, NULL); + if (err != 0) + gold_fatal(_("pthread_cond_init failed: %s"), strerror(err)); +} + +Condvar_impl_threads::~Condvar_impl_threads() +{ + int err = pthread_cond_destroy(&this->cond_); + if (err != 0) + gold_fatal(_("pthread_cond_destroy failed: %s"), strerror(err)); +} + +void +Condvar_impl_threads::wait(Lock_impl* li) +{ + Lock_impl_threads* lit = static_cast<Lock_impl_threads*>(li); + int err = pthread_cond_wait(&this->cond_, &lit->mutex_); + if (err != 0) + gold_fatal(_("pthread_cond_wait failed: %s"), strerror(err)); +} + +void +Condvar_impl_threads::signal() +{ + int err = pthread_cond_signal(&this->cond_); + if (err != 0) + gold_fatal(_("pthread_cond_signal failed: %s"), strerror(err)); +} + +void +Condvar_impl_threads::broadcast() +{ + int err = pthread_cond_broadcast(&this->cond_); + if (err != 0) + gold_fatal(_("pthread_cond_broadcast failed: %s"), strerror(err)); +} + +#endif // defined(ENABLE_THREADS) + +// Methods for Condvar class. + +Condvar::Condvar(Lock& lock) + : lock_(lock) +{ + if (!parameters->options().threads()) + this->condvar_ = new Condvar_impl_nothreads; + else + { +#ifdef ENABLE_THREADS + this->condvar_ = new Condvar_impl_threads; +#else + gold_unreachable(); +#endif + } +} + +Condvar::~Condvar() +{ + delete this->condvar_; +} + +#ifdef ENABLE_THREADS + +// Class Once_initialize. This exists to hold a pthread_once_t +// structure for Once. + +class Once_initialize +{ + public: + Once_initialize() + : once_(PTHREAD_ONCE_INIT) + { } + + // Return a pointer to the pthread_once_t variable. + pthread_once_t* + once_control() + { return &this->once_; } + + private: + pthread_once_t once_; +}; + +#endif // defined(ENABLE_THREADS) + +#ifdef ENABLE_THREADS + +// A single lock which controls access to once_pointer. This is used +// because we can't pass parameters to functions passed to +// pthread_once. + +static pthread_mutex_t once_pointer_control = PTHREAD_MUTEX_INITIALIZER; + +// A pointer to Once structure we want to run. Access to this is +// controlled by once_pointer_control. + +static Once* once_pointer; + +// The argument to pass to the Once structure. Access to this is +// controlled by once_pointer_control. + +static void* once_arg; + +// A routine passed to pthread_once which runs the Once pointer. + +extern "C" +{ + +static void +c_run_once(void) +{ + once_pointer->internal_run(once_arg); +} + +} + +#endif // defined(ENABLE_THREADS) + +// Class Once. + +Once::Once() + : was_run_(false) +#if defined(ENABLE_THREADS) && defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4) + , was_run_lock_(0) +#endif +{ +#ifndef ENABLE_THREADS + this->once_ = NULL; +#else + this->once_ = new Once_initialize(); +#endif +} + +// Run the function once. + +void +Once::run_once(void* arg) +{ +#ifndef ENABLE_THREADS + + // If there is no threads support, we don't need to use pthread_once. + if (!this->was_run_) + this->internal_run(arg); + +#else // defined(ENABLE_THREADS) + + if (parameters->options_valid() && !parameters->options().threads()) + { + // If we are not using threads, we don't need to lock. + if (!this->was_run_) + this->internal_run(arg); + return; + } + + // If we have the sync builtins, use them to skip the lock if the + // value has already been initialized. +#ifdef __GCC_HAVE_SYNC_COMPARE_AND_SWAP_4 + while (true) + { + if (__sync_bool_compare_and_swap(&this->was_run_lock_, 0, 1)) + break; + } + bool was_run = this->was_run_; + while (true) + { + if (__sync_bool_compare_and_swap(&this->was_run_lock_, 1, 0)) + break; + } + if (was_run) + return; +#endif + + // Since we can't pass parameters to routines called by + // pthread_once, we use a static variable: once_pointer. This in + // turns means that we need to use a mutex to control access to + // once_pointer. + + int err = pthread_mutex_lock(&once_pointer_control); + if (err != 0) + gold_fatal(_("pthread_mutex_lock failed: %s"), strerror(err)); + + once_pointer = this; + once_arg = arg; + + err = pthread_once(this->once_->once_control(), c_run_once); + if (err != 0) + gold_fatal(_("pthread_once failed: %s"), strerror(err)); + + once_pointer = NULL; + once_arg = NULL; + + err = pthread_mutex_unlock(&once_pointer_control); + if (err != 0) + gold_fatal(_("pthread_mutex_unlock failed: %s"), strerror(err)); + +#endif // defined(ENABLE_THREADS) +} + +// Actually run the function in the child class. This function will +// be run only once. + +void +Once::internal_run(void* arg) +{ + this->do_run_once(arg); + this->was_run_ = true; +} + +// Class Initialize_lock. + +// Initialize the lock. + +bool +Initialize_lock::initialize() +{ + // We can't initialize the lock until we have read the options. + if (!parameters->options_valid()) + return false; + else + { + this->run_once(NULL); + return true; + } +} + +// Initialize the lock exactly once. + +void +Initialize_lock::do_run_once(void*) +{ + *this->pplock_ = new Lock(); +} + +} // End namespace gold. |