* elf32-xtensa.c (relax_section): Check for a reference to a discarded

[deliverable/binutils-gdb.git] / gold / gold-threads.cc

// gold-threads.cc -- thread support for gold

// Copyright 2006, 2007 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"

#ifdef ENABLE_THREADS
#include <pthread.h>
#endif

#include "gold-threads.h"

namespace gold
{

// Class Lock_impl. 

class Lock_impl
{
 public:
  Lock_impl();
  ~Lock_impl();

  void acquire();

  void release();

private:
  // This class can not be copied.
  Lock_impl(const Lock_impl&);
  Lock_impl& operator=(const Lock_impl&);

  friend class Condvar_impl;

#ifdef ENABLE_THREADS
  pthread_mutex_t mutex_;
#else
  bool acquired_;
#endif
};

#ifdef ENABLE_THREADS

Lock_impl::Lock_impl()
{
  pthread_mutexattr_t attr;
  if (pthread_mutexattr_init(&attr) != 0)
    gold_fatal(_("pthead_mutextattr_init failed"), true);
#ifdef PTHREAD_MUTEXT_ADAPTIVE_NP
  if (pthread_mutextattr_settype(&attr, PTHREAD_MUTEX_ADAPTIVE_NP) != 0)
    gold_fatal(_("pthread_mutextattr_settype failed"), true);
#endif

  if (pthread_mutex_init (&this->mutex_, &attr) != 0)
    gold_fatal(_("pthread_mutex_init failed"), true);

  if (pthread_mutexattr_destroy(&attr) != 0)
    gold_fatal(_("pthread_mutexattr_destroy failed"), true);
}

Lock_impl::~Lock_impl()
{
  if (pthread_mutex_destroy(&this->mutex_) != 0)
    gold_fatal(_("pthread_mutex_destroy failed"), true);
}

void
Lock_impl::acquire()
{
  if (pthread_mutex_lock(&this->mutex_) != 0)
    gold_fatal(_("pthread_mutex_lock failed"), true);
}

void
Lock_impl::release()
{
  if (pthread_mutex_unlock(&this->mutex_) != 0)
    gold_fatal(_("pthread_mutex_unlock failed"), true);
}

#else // !defined(ENABLE_THREADS)

Lock_impl::Lock_impl()
  : acquired_(false)
{
}

Lock_impl::~Lock_impl()
{
  gold_assert(!this->acquired_);
}

void
Lock_impl::acquire()
{
  gold_assert(!this->acquired_);
  this->acquired_ = true;
}

void
Lock_impl::release()
{
  gold_assert(this->acquired_);
  this->acquired_ = false;
}

#endif // !defined(ENABLE_THREADS)

// Methods for Lock class.

Lock::Lock()
{
  this->lock_ = new Lock_impl;
}

Lock::~Lock()
{
  delete this->lock_;
}

void
Lock::acquire()
{
  this->lock_->acquire();
}

void
Lock::release()
{
  this->lock_->release();
}

// Class Condvar_impl.

class Condvar_impl
{
 public:
  Condvar_impl();
  ~Condvar_impl();

  void wait(Lock_impl*);
  void signal();

 private:
  // This class can not be copied.
  Condvar_impl(const Condvar_impl&);
  Condvar_impl& operator=(const Condvar_impl&);

#ifdef ENABLE_THREADS
  pthread_cond_t cond_;
#endif
};

#ifdef ENABLE_THREADS

Condvar_impl::Condvar_impl()
{
  if (pthread_cond_init(&this->cond_, NULL) != 0)
    gold_fatal(_("pthread_cond_init failed"), true);
}

Condvar_impl::~Condvar_impl()
{
  if (pthread_cond_destroy(&this->cond_) != 0)
    gold_fatal(_("pthread_cond_destroy failed"), true);
}

void
Condvar_impl::wait(Lock_impl* li)
{
  if (pthread_cond_wait(&this->cond_, &li->mutex_) != 0)
    gold_fatal(_("pthread_cond_wait failed"), true);
}

void
Condvar_impl::signal()
{
  if (pthread_cond_signal(&this->cond_) != 0)
    gold_fatal(_("pthread_cond_signal failed"), true);
}

#else // !defined(ENABLE_THREADS)

Condvar_impl::Condvar_impl()
{
}

Condvar_impl::~Condvar_impl()
{
}

void
Condvar_impl::wait(Lock_impl* li)
{
  gold_assert(li->acquired_);
}

void
Condvar_impl::signal()
{
}

#endif // !defined(ENABLE_THREADS)

// Methods for Condvar class.

Condvar::Condvar(Lock& lock)
  : lock_(lock)
{
  this->condvar_ = new Condvar_impl;
}

Condvar::~Condvar()
{
  delete this->condvar_;
}

void
Condvar::wait()
{
  this->condvar_->wait(this->lock_.get_impl());
}

void
Condvar::signal()
{
  this->condvar_->signal();
}

} // End namespace gold.