mirror of
https://sourceware.org/git/binutils-gdb.git
synced 2024-12-15 04:31:49 +08:00
114dfbe13e
(class Initialize_lock): Rewrite as child of Once. * gold-threads.cc (class Once_initialize): Define. (once_pointer_control): New static variable. (once_pointer, once_arg): New static variables. (c_run_once): New static function. (Once::Once, Once::run_once, Once::internal_run): New functions. (class Initialize_lock_once): Remove. (initialize_lock_control): Remove. (initialize_lock_pointer): Remove. (initialize_lock_once): Remove. (Initialize_lock::Initialize_lock): Move to gold-threads.h. (Initialize_lock::initialize): Rewrite. (Initialize_lock::do_run_once): New function. * archive.cc (Archive::interpret_header): Only clear name if it is not already empty. * fileread.cc: Include "gold-threads.h" (file_counts_lock): New static variable. (file_counts_initialize_lock): Likewise. (File_read::release): Only increment counts when using --stats. Use a lock around the increment. * parameters.cc (class Set_parameters_target_once): Define. (set_parameters_target_once): New static variable. (Parameters::Parameters): Move here from parameters.h. (Parameters::set_target): Rewrite. (Parameters::set_target_once): New function. (Parameters::clear_target): Move here and rewrite. * parameters.h (class Parameters): Update declarations. Add set_parameters_target_once_ field. (Parameters::Parameters): Move to parameters.cc. (Parameters::clear_target): Likewise. * readsyms.cc (Read_symbols::do_group): Create a Start_group task. (Start_group::~Start_group): New function. (Start_group::is_runnable): New function. (Start_group::locks, Start_group::run): New functions. (Finish_group::run): Change saw_undefined to size_t. * readsyms.h (class Start_group): Define. (class Finish_group): Change saw_undefined_ field to size_t. (Finish_group::Finish_group): Remove saw_undefined and this_blocker parameters. Change all callers. (Finish_group::set_saw_undefined): New function. (Finish_group::set_blocker): New function. * symtab.h (class Symbol_table): Change saw_undefined to return size_t. Change saw_undefined_ field to size_t. * target-select.cc (Set_target_once::do_run_once): New function. (Target_selector::Target_selector): Initialize set_target_once_ field. Don't initialize lock_ and initialize_lock_ fields. (Target_selector::instantiate_target): Rewrite. (Target_selector::set_target): New function. * target-select.h (class Set_target_once): Define. (class Target_selector): Update declarations. Make Set_target_once a friend. Remove lock_ and initialize_lock_ fields. Add set_target_once_ field.
448 lines
9.0 KiB
C++
448 lines
9.0 KiB
C++
// gold-threads.cc -- thread support for gold
|
|
|
|
// Copyright 2006, 2007, 2008, 2009, 2010 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_MUTEXT_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), was_run_lock_(0)
|
|
{
|
|
#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 falied: %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.
|