forked from OSchip/llvm-project
166 lines
4.0 KiB
C++
166 lines
4.0 KiB
C++
// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 -Wthread-safety -Wthread-safety-beta -Wthread-safety-negative -fcxx-exceptions -DUSE_CAPABILITY=0 %s
|
|
// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 -Wthread-safety -Wthread-safety-beta -Wthread-safety-negative -fcxx-exceptions -DUSE_CAPABILITY=1 %s
|
|
|
|
// FIXME: should also run %clang_cc1 -fsyntax-only -verify -Wthread-safety -std=c++11 -Wc++98-compat %s
|
|
// FIXME: should also run %clang_cc1 -fsyntax-only -verify -Wthread-safety %s
|
|
|
|
#include "thread-safety-annotations.h"
|
|
|
|
class LOCKABLE Mutex {
|
|
public:
|
|
void Lock() EXCLUSIVE_LOCK_FUNCTION();
|
|
void ReaderLock() SHARED_LOCK_FUNCTION();
|
|
void Unlock() UNLOCK_FUNCTION();
|
|
bool TryLock() EXCLUSIVE_TRYLOCK_FUNCTION(true);
|
|
bool ReaderTryLock() SHARED_TRYLOCK_FUNCTION(true);
|
|
|
|
// for negative capabilities
|
|
const Mutex& operator!() const { return *this; }
|
|
|
|
void AssertHeld() ASSERT_EXCLUSIVE_LOCK();
|
|
void AssertReaderHeld() ASSERT_SHARED_LOCK();
|
|
};
|
|
|
|
class SCOPED_LOCKABLE MutexLock {
|
|
public:
|
|
MutexLock(Mutex *mu) EXCLUSIVE_LOCK_FUNCTION(mu);
|
|
MutexLock(Mutex *mu, bool adopt) EXCLUSIVE_LOCKS_REQUIRED(mu);
|
|
~MutexLock() UNLOCK_FUNCTION();
|
|
};
|
|
|
|
namespace SimpleTest {
|
|
|
|
class Bar {
|
|
Mutex mu;
|
|
int a GUARDED_BY(mu);
|
|
|
|
public:
|
|
void baz() EXCLUSIVE_LOCKS_REQUIRED(!mu) {
|
|
mu.Lock();
|
|
a = 0;
|
|
mu.Unlock();
|
|
}
|
|
};
|
|
|
|
|
|
class Foo {
|
|
Mutex mu;
|
|
int a GUARDED_BY(mu);
|
|
|
|
public:
|
|
void foo() {
|
|
mu.Lock(); // expected-warning {{acquiring mutex 'mu' requires negative capability '!mu'}}
|
|
baz(); // expected-warning {{cannot call function 'baz' while mutex 'mu' is held}}
|
|
bar();
|
|
mu.Unlock();
|
|
}
|
|
|
|
void bar() {
|
|
baz(); // expected-warning {{calling function 'baz' requires negative capability '!mu'}}
|
|
}
|
|
|
|
void baz() EXCLUSIVE_LOCKS_REQUIRED(!mu) {
|
|
mu.Lock();
|
|
a = 0;
|
|
mu.Unlock();
|
|
}
|
|
|
|
void test() {
|
|
Bar b;
|
|
b.baz(); // no warning -- in different class.
|
|
}
|
|
|
|
void test2() {
|
|
mu.Lock(); // expected-warning {{acquiring mutex 'mu' requires negative capability '!mu'}}
|
|
a = 0;
|
|
mu.Unlock();
|
|
baz(); // no warning -- !mu in set.
|
|
}
|
|
|
|
void test3() EXCLUSIVE_LOCKS_REQUIRED(!mu) {
|
|
mu.Lock();
|
|
a = 0;
|
|
mu.Unlock();
|
|
baz(); // no warning -- !mu in set.
|
|
}
|
|
|
|
void test4() {
|
|
MutexLock lock(&mu); // expected-warning {{acquiring mutex 'mu' requires negative capability '!mu'}}
|
|
}
|
|
};
|
|
|
|
} // end namespace SimpleTest
|
|
|
|
Mutex globalMutex;
|
|
|
|
namespace ScopeTest {
|
|
|
|
void f() EXCLUSIVE_LOCKS_REQUIRED(!globalMutex);
|
|
void fq() EXCLUSIVE_LOCKS_REQUIRED(!::globalMutex);
|
|
|
|
namespace ns {
|
|
Mutex globalMutex;
|
|
void f() EXCLUSIVE_LOCKS_REQUIRED(!globalMutex);
|
|
void fq() EXCLUSIVE_LOCKS_REQUIRED(!ns::globalMutex);
|
|
}
|
|
|
|
void testGlobals() EXCLUSIVE_LOCKS_REQUIRED(!ns::globalMutex) {
|
|
f(); // expected-warning {{calling function 'f' requires negative capability '!globalMutex'}}
|
|
fq(); // expected-warning {{calling function 'fq' requires negative capability '!globalMutex'}}
|
|
ns::f();
|
|
ns::fq();
|
|
}
|
|
|
|
void testNamespaceGlobals() EXCLUSIVE_LOCKS_REQUIRED(!globalMutex) {
|
|
f();
|
|
fq();
|
|
ns::f(); // expected-warning {{calling function 'f' requires negative capability '!globalMutex'}}
|
|
ns::fq(); // expected-warning {{calling function 'fq' requires negative capability '!globalMutex'}}
|
|
}
|
|
|
|
class StaticMembers {
|
|
public:
|
|
void pub() EXCLUSIVE_LOCKS_REQUIRED(!publicMutex);
|
|
void prot() EXCLUSIVE_LOCKS_REQUIRED(!protectedMutex);
|
|
void priv() EXCLUSIVE_LOCKS_REQUIRED(!privateMutex);
|
|
void test() {
|
|
pub();
|
|
prot();
|
|
priv();
|
|
}
|
|
|
|
static Mutex publicMutex;
|
|
|
|
protected:
|
|
static Mutex protectedMutex;
|
|
|
|
private:
|
|
static Mutex privateMutex;
|
|
};
|
|
|
|
void testStaticMembers() {
|
|
StaticMembers x;
|
|
x.pub();
|
|
x.prot();
|
|
x.priv();
|
|
}
|
|
|
|
} // end namespace ScopeTest
|
|
|
|
namespace DoubleAttribute {
|
|
|
|
struct Foo {
|
|
Mutex &mutex();
|
|
};
|
|
|
|
template <typename A>
|
|
class TemplateClass {
|
|
template <typename B>
|
|
static void Function(Foo *F)
|
|
EXCLUSIVE_LOCKS_REQUIRED(F->mutex()) UNLOCK_FUNCTION(F->mutex()) {}
|
|
};
|
|
|
|
void test() { TemplateClass<int> TC; }
|
|
|
|
} // end namespace DoubleAttribute
|