#define LLVM_SYSTEM_MUTEX_H
#include "llvm/System/Threading.h"
+#include <cassert>
namespace llvm
{
/// @name Platform Dependent Data
/// @{
private:
-#ifdef ENABLE_THREADS
void* data_; ///< We don't know what the data will be
-#endif
/// @}
/// @name Do Not Implement
/// running in multithreaded mode.
template<bool mt_only>
class SmartMutex : public MutexImpl {
+ unsigned acquired;
+ bool recursive;
public:
- explicit SmartMutex(bool recursive = true) : MutexImpl(recursive) { }
+ explicit SmartMutex(bool rec = true) :
+ MutexImpl(rec), acquired(0), recursive(rec) { }
bool acquire() {
- if (!mt_only && llvm_is_multithreaded())
+ if (!mt_only || llvm_is_multithreaded()) {
return MutexImpl::acquire();
- return true;
+ } else {
+ // Single-threaded debugging code. This would be racy in
+ // multithreaded mode, but provides not sanity checks in single
+ // threaded mode.
+ assert((recursive || acquired == 0) && "Lock already acquired!!");
+ ++acquired;
+ return true;
+ }
}
bool release() {
- if (!mt_only || llvm_is_multithreaded())
+ if (!mt_only || llvm_is_multithreaded()) {
return MutexImpl::release();
- return true;
+ } else {
+ // Single-threaded debugging code. This would be racy in
+ // multithreaded mode, but provides not sanity checks in single
+ // threaded mode.
+ assert(((recursive && acquired) || (acquired == 1)) &&
+ "Lock not acquired before release!");
+ --acquired;
+ return true;
+ }
}
bool tryacquire() {
if (!mt_only || llvm_is_multithreaded())
return MutexImpl::tryacquire();
- return true;
+ else return true;
}
private:
template<bool mt_only>
class SmartScopedLock {
- SmartMutex<mt_only>* mtx;
+ SmartMutex<mt_only>& mtx;
public:
- SmartScopedLock(SmartMutex<mt_only>* m) : mtx(m) {
- mtx->acquire();
+ SmartScopedLock(SmartMutex<mt_only>& m) : mtx(m) {
+ mtx.acquire();
}
~SmartScopedLock() {
- mtx->release();
+ mtx.release();
}
};