-//===- llvm/System/Mutex.h - Mutex Operating System Concept -----*- C++ -*-===//
+//===- llvm/Support/Mutex.h - Mutex Operating System Concept -----*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
//
//===----------------------------------------------------------------------===//
-#ifndef LLVM_SYSTEM_MUTEX_H
-#define LLVM_SYSTEM_MUTEX_H
+#ifndef LLVM_SUPPORT_MUTEX_H
+#define LLVM_SUPPORT_MUTEX_H
+#include "llvm/Support/Compiler.h"
#include "llvm/Support/Threading.h"
#include <cassert>
/// @name Platform Dependent Data
/// @{
private:
+#if defined(LLVM_ENABLE_THREADS) && LLVM_ENABLE_THREADS != 0
void* data_; ///< We don't know what the data will be
+#endif
/// @}
/// @name Do Not Implement
/// @{
private:
- MutexImpl(const MutexImpl & original);
- void operator=(const MutexImpl &);
+ MutexImpl(const MutexImpl &) = delete;
+ void operator=(const MutexImpl &) = delete;
/// @}
};
/// indicates whether this mutex should become a no-op when we're not
/// running in multithreaded mode.
template<bool mt_only>
- class SmartMutex : public MutexImpl {
+ class SmartMutex {
+ MutexImpl impl;
unsigned acquired;
bool recursive;
public:
explicit SmartMutex(bool rec = true) :
- MutexImpl(rec), acquired(0), recursive(rec) { }
+ impl(rec), acquired(0), recursive(rec) { }
- bool acquire() {
+ bool lock() {
if (!mt_only || llvm_is_multithreaded()) {
- return MutexImpl::acquire();
+ return impl.acquire();
} else {
// Single-threaded debugging code. This would be racy in
// multithreaded mode, but provides not sanity checks in single
}
}
- bool release() {
+ bool unlock() {
if (!mt_only || llvm_is_multithreaded()) {
- return MutexImpl::release();
+ return impl.release();
} else {
// Single-threaded debugging code. This would be racy in
// multithreaded mode, but provides not sanity checks in single
}
}
- bool tryacquire() {
+ bool try_lock() {
if (!mt_only || llvm_is_multithreaded())
- return MutexImpl::tryacquire();
+ return impl.tryacquire();
else return true;
}
public:
SmartScopedLock(SmartMutex<mt_only>& m) : mtx(m) {
- mtx.acquire();
+ mtx.lock();
}
~SmartScopedLock() {
- mtx.release();
+ mtx.unlock();
}
};