зеркало из https://github.com/microsoft/clang-1.git
2261 строка
49 KiB
C++
2261 строка
49 KiB
C++
// RUN: %clang_cc1 -fsyntax-only -verify -Wthread-safety %s
|
|
// RUN: %clang_cc1 -fsyntax-only -verify -Wthread-safety -std=c++11 -Wc++98-compat %s
|
|
|
|
#define LOCKABLE __attribute__ ((lockable))
|
|
#define SCOPED_LOCKABLE __attribute__ ((scoped_lockable))
|
|
#define GUARDED_BY(x) __attribute__ ((guarded_by(x)))
|
|
#define GUARDED_VAR __attribute__ ((guarded_var))
|
|
#define PT_GUARDED_BY(x) __attribute__ ((pt_guarded_by(x)))
|
|
#define PT_GUARDED_VAR __attribute__ ((pt_guarded_var))
|
|
#define ACQUIRED_AFTER(...) __attribute__ ((acquired_after(__VA_ARGS__)))
|
|
#define ACQUIRED_BEFORE(...) __attribute__ ((acquired_before(__VA_ARGS__)))
|
|
#define EXCLUSIVE_LOCK_FUNCTION(...) __attribute__ ((exclusive_lock_function(__VA_ARGS__)))
|
|
#define SHARED_LOCK_FUNCTION(...) __attribute__ ((shared_lock_function(__VA_ARGS__)))
|
|
#define EXCLUSIVE_TRYLOCK_FUNCTION(...) __attribute__ ((exclusive_trylock_function(__VA_ARGS__)))
|
|
#define SHARED_TRYLOCK_FUNCTION(...) __attribute__ ((shared_trylock_function(__VA_ARGS__)))
|
|
#define UNLOCK_FUNCTION(...) __attribute__ ((unlock_function(__VA_ARGS__)))
|
|
#define LOCK_RETURNED(x) __attribute__ ((lock_returned(x)))
|
|
#define LOCKS_EXCLUDED(...) __attribute__ ((locks_excluded(__VA_ARGS__)))
|
|
#define EXCLUSIVE_LOCKS_REQUIRED(...) \
|
|
__attribute__ ((exclusive_locks_required(__VA_ARGS__)))
|
|
#define SHARED_LOCKS_REQUIRED(...) \
|
|
__attribute__ ((shared_locks_required(__VA_ARGS__)))
|
|
#define NO_THREAD_SAFETY_ANALYSIS __attribute__ ((no_thread_safety_analysis))
|
|
|
|
//-----------------------------------------//
|
|
// Helper fields
|
|
//-----------------------------------------//
|
|
|
|
|
|
class __attribute__((lockable)) Mutex {
|
|
public:
|
|
void Lock() __attribute__((exclusive_lock_function));
|
|
void ReaderLock() __attribute__((shared_lock_function));
|
|
void Unlock() __attribute__((unlock_function));
|
|
bool TryLock() __attribute__((exclusive_trylock_function(true)));
|
|
bool ReaderTryLock() __attribute__((shared_trylock_function(true)));
|
|
void LockWhen(const int &cond) __attribute__((exclusive_lock_function));
|
|
};
|
|
|
|
class __attribute__((scoped_lockable)) MutexLock {
|
|
public:
|
|
MutexLock(Mutex *mu) __attribute__((exclusive_lock_function(mu)));
|
|
~MutexLock() __attribute__((unlock_function));
|
|
};
|
|
|
|
class __attribute__((scoped_lockable)) ReaderMutexLock {
|
|
public:
|
|
ReaderMutexLock(Mutex *mu) __attribute__((exclusive_lock_function(mu)));
|
|
~ReaderMutexLock() __attribute__((unlock_function));
|
|
};
|
|
|
|
|
|
Mutex sls_mu;
|
|
|
|
Mutex sls_mu2 __attribute__((acquired_after(sls_mu)));
|
|
int sls_guard_var __attribute__((guarded_var)) = 0;
|
|
int sls_guardby_var __attribute__((guarded_by(sls_mu))) = 0;
|
|
|
|
bool getBool();
|
|
|
|
class MutexWrapper {
|
|
public:
|
|
Mutex mu;
|
|
int x __attribute__((guarded_by(mu)));
|
|
void MyLock() __attribute__((exclusive_lock_function(mu)));
|
|
};
|
|
|
|
MutexWrapper sls_mw;
|
|
|
|
void sls_fun_0() {
|
|
sls_mw.mu.Lock();
|
|
sls_mw.x = 5;
|
|
sls_mw.mu.Unlock();
|
|
}
|
|
|
|
void sls_fun_2() {
|
|
sls_mu.Lock();
|
|
int x = sls_guard_var;
|
|
sls_mu.Unlock();
|
|
}
|
|
|
|
void sls_fun_3() {
|
|
sls_mu.Lock();
|
|
sls_guard_var = 2;
|
|
sls_mu.Unlock();
|
|
}
|
|
|
|
void sls_fun_4() {
|
|
sls_mu2.Lock();
|
|
sls_guard_var = 2;
|
|
sls_mu2.Unlock();
|
|
}
|
|
|
|
void sls_fun_5() {
|
|
sls_mu.Lock();
|
|
int x = sls_guardby_var;
|
|
sls_mu.Unlock();
|
|
}
|
|
|
|
void sls_fun_6() {
|
|
sls_mu.Lock();
|
|
sls_guardby_var = 2;
|
|
sls_mu.Unlock();
|
|
}
|
|
|
|
void sls_fun_7() {
|
|
sls_mu.Lock();
|
|
sls_mu2.Lock();
|
|
sls_mu2.Unlock();
|
|
sls_mu.Unlock();
|
|
}
|
|
|
|
void sls_fun_8() {
|
|
sls_mu.Lock();
|
|
if (getBool())
|
|
sls_mu.Unlock();
|
|
else
|
|
sls_mu.Unlock();
|
|
}
|
|
|
|
void sls_fun_9() {
|
|
if (getBool())
|
|
sls_mu.Lock();
|
|
else
|
|
sls_mu.Lock();
|
|
sls_mu.Unlock();
|
|
}
|
|
|
|
void sls_fun_good_6() {
|
|
if (getBool()) {
|
|
sls_mu.Lock();
|
|
} else {
|
|
if (getBool()) {
|
|
getBool(); // EMPTY
|
|
} else {
|
|
getBool(); // EMPTY
|
|
}
|
|
sls_mu.Lock();
|
|
}
|
|
sls_mu.Unlock();
|
|
}
|
|
|
|
void sls_fun_good_7() {
|
|
sls_mu.Lock();
|
|
while (getBool()) {
|
|
sls_mu.Unlock();
|
|
if (getBool()) {
|
|
if (getBool()) {
|
|
sls_mu.Lock();
|
|
continue;
|
|
}
|
|
}
|
|
sls_mu.Lock();
|
|
}
|
|
sls_mu.Unlock();
|
|
}
|
|
|
|
void sls_fun_good_8() {
|
|
sls_mw.MyLock();
|
|
sls_mw.mu.Unlock();
|
|
}
|
|
|
|
void sls_fun_bad_1() {
|
|
sls_mu.Unlock(); // \
|
|
// expected-warning{{unlocking 'sls_mu' that was not locked}}
|
|
}
|
|
|
|
void sls_fun_bad_2() {
|
|
sls_mu.Lock();
|
|
sls_mu.Lock(); // \
|
|
// expected-warning{{locking 'sls_mu' that is already locked}}
|
|
sls_mu.Unlock();
|
|
}
|
|
|
|
void sls_fun_bad_3() {
|
|
sls_mu.Lock(); // expected-note {{mutex acquired here}}
|
|
} // expected-warning{{mutex 'sls_mu' is still locked at the end of function}}
|
|
|
|
void sls_fun_bad_4() {
|
|
if (getBool())
|
|
sls_mu.Lock(); // expected-note{{mutex acquired here}}
|
|
else
|
|
sls_mu2.Lock(); // expected-note{{mutex acquired here}}
|
|
} // expected-warning{{mutex 'sls_mu' is not locked on every path through here}} \
|
|
// expected-warning{{mutex 'sls_mu2' is not locked on every path through here}}
|
|
|
|
void sls_fun_bad_5() {
|
|
sls_mu.Lock(); // expected-note {{mutex acquired here}}
|
|
if (getBool())
|
|
sls_mu.Unlock();
|
|
} // expected-warning{{mutex 'sls_mu' is not locked on every path through here}}
|
|
|
|
void sls_fun_bad_6() {
|
|
if (getBool()) {
|
|
sls_mu.Lock(); // expected-note {{mutex acquired here}}
|
|
} else {
|
|
if (getBool()) {
|
|
getBool(); // EMPTY
|
|
} else {
|
|
getBool(); // EMPTY
|
|
}
|
|
}
|
|
sls_mu.Unlock(); // \
|
|
expected-warning{{mutex 'sls_mu' is not locked on every path through here}}\
|
|
expected-warning{{unlocking 'sls_mu' that was not locked}}
|
|
}
|
|
|
|
void sls_fun_bad_7() {
|
|
sls_mu.Lock();
|
|
while (getBool()) {
|
|
sls_mu.Unlock();
|
|
if (getBool()) {
|
|
if (getBool()) {
|
|
continue; // \
|
|
expected-warning{{expecting mutex 'sls_mu' to be locked at start of each loop}}
|
|
}
|
|
}
|
|
sls_mu.Lock(); // expected-note {{mutex acquired here}}
|
|
}
|
|
sls_mu.Unlock();
|
|
}
|
|
|
|
void sls_fun_bad_8() {
|
|
sls_mu.Lock(); // expected-note{{mutex acquired here}}
|
|
|
|
do {
|
|
sls_mu.Unlock(); // expected-warning{{expecting mutex 'sls_mu' to be locked at start of each loop}}
|
|
} while (getBool());
|
|
}
|
|
|
|
void sls_fun_bad_9() {
|
|
do {
|
|
sls_mu.Lock(); // \
|
|
// expected-warning{{expecting mutex 'sls_mu' to be locked at start of each loop}} \
|
|
// expected-note{{mutex acquired here}}
|
|
} while (getBool());
|
|
sls_mu.Unlock();
|
|
}
|
|
|
|
void sls_fun_bad_10() {
|
|
sls_mu.Lock(); // expected-note 2{{mutex acquired here}}
|
|
while(getBool()) { // expected-warning{{expecting mutex 'sls_mu' to be locked at start of each loop}}
|
|
sls_mu.Unlock();
|
|
}
|
|
} // expected-warning{{mutex 'sls_mu' is still locked at the end of function}}
|
|
|
|
void sls_fun_bad_11() {
|
|
while (getBool()) { // \
|
|
expected-warning{{expecting mutex 'sls_mu' to be locked at start of each loop}}
|
|
sls_mu.Lock(); // expected-note {{mutex acquired here}}
|
|
}
|
|
sls_mu.Unlock(); // \
|
|
// expected-warning{{unlocking 'sls_mu' that was not locked}}
|
|
}
|
|
|
|
void sls_fun_bad_12() {
|
|
sls_mu.Lock(); // expected-note {{mutex acquired here}}
|
|
while (getBool()) {
|
|
sls_mu.Unlock();
|
|
if (getBool()) {
|
|
if (getBool()) {
|
|
break; // expected-warning{{mutex 'sls_mu' is not locked on every path through here}}
|
|
}
|
|
}
|
|
sls_mu.Lock();
|
|
}
|
|
sls_mu.Unlock();
|
|
}
|
|
|
|
//-----------------------------------------//
|
|
// Handling lock expressions in attribute args
|
|
// -------------------------------------------//
|
|
|
|
Mutex aa_mu;
|
|
|
|
class GlobalLocker {
|
|
public:
|
|
void globalLock() __attribute__((exclusive_lock_function(aa_mu)));
|
|
void globalUnlock() __attribute__((unlock_function(aa_mu)));
|
|
};
|
|
|
|
GlobalLocker glock;
|
|
|
|
void aa_fun_1() {
|
|
glock.globalLock();
|
|
glock.globalUnlock();
|
|
}
|
|
|
|
void aa_fun_bad_1() {
|
|
glock.globalUnlock(); // \
|
|
// expected-warning{{unlocking 'aa_mu' that was not locked}}
|
|
}
|
|
|
|
void aa_fun_bad_2() {
|
|
glock.globalLock();
|
|
glock.globalLock(); // \
|
|
// expected-warning{{locking 'aa_mu' that is already locked}}
|
|
glock.globalUnlock();
|
|
}
|
|
|
|
void aa_fun_bad_3() {
|
|
glock.globalLock(); // expected-note{{mutex acquired here}}
|
|
} // expected-warning{{mutex 'aa_mu' is still locked at the end of function}}
|
|
|
|
//--------------------------------------------------//
|
|
// Regression tests for unusual method names
|
|
//--------------------------------------------------//
|
|
|
|
Mutex wmu;
|
|
|
|
// Test diagnostics for other method names.
|
|
class WeirdMethods {
|
|
// FIXME: can't currently check inside constructors and destructors.
|
|
WeirdMethods() {
|
|
wmu.Lock(); // EXPECTED-NOTE {{mutex acquired here}}
|
|
} // EXPECTED-WARNING {{mutex 'wmu' is still locked at the end of function}}
|
|
~WeirdMethods() {
|
|
wmu.Lock(); // EXPECTED-NOTE {{mutex acquired here}}
|
|
} // EXPECTED-WARNING {{mutex 'wmu' is still locked at the end of function}}
|
|
void operator++() {
|
|
wmu.Lock(); // expected-note {{mutex acquired here}}
|
|
} // expected-warning {{mutex 'wmu' is still locked at the end of function}}
|
|
operator int*() {
|
|
wmu.Lock(); // expected-note {{mutex acquired here}}
|
|
return 0;
|
|
} // expected-warning {{mutex 'wmu' is still locked at the end of function}}
|
|
};
|
|
|
|
//-----------------------------------------------//
|
|
// Errors for guarded by or guarded var variables
|
|
// ----------------------------------------------//
|
|
|
|
int *pgb_gvar __attribute__((pt_guarded_var));
|
|
int *pgb_var __attribute__((pt_guarded_by(sls_mu)));
|
|
|
|
class PGBFoo {
|
|
public:
|
|
int x;
|
|
int *pgb_field __attribute__((guarded_by(sls_mu2)))
|
|
__attribute__((pt_guarded_by(sls_mu)));
|
|
void testFoo() {
|
|
pgb_field = &x; // \
|
|
// expected-warning {{writing variable 'pgb_field' requires locking 'sls_mu2' exclusively}}
|
|
*pgb_field = x; // expected-warning {{reading variable 'pgb_field' requires locking 'sls_mu2'}} \
|
|
// expected-warning {{writing the value pointed to by 'pgb_field' requires locking 'sls_mu' exclusively}}
|
|
x = *pgb_field; // expected-warning {{reading variable 'pgb_field' requires locking 'sls_mu2'}} \
|
|
// expected-warning {{reading the value pointed to by 'pgb_field' requires locking 'sls_mu'}}
|
|
(*pgb_field)++; // expected-warning {{reading variable 'pgb_field' requires locking 'sls_mu2'}} \
|
|
// expected-warning {{writing the value pointed to by 'pgb_field' requires locking 'sls_mu' exclusively}}
|
|
}
|
|
};
|
|
|
|
class GBFoo {
|
|
public:
|
|
int gb_field __attribute__((guarded_by(sls_mu)));
|
|
|
|
void testFoo() {
|
|
gb_field = 0; // \
|
|
// expected-warning {{writing variable 'gb_field' requires locking 'sls_mu' exclusively}}
|
|
}
|
|
|
|
void testNoAnal() __attribute__((no_thread_safety_analysis)) {
|
|
gb_field = 0;
|
|
}
|
|
};
|
|
|
|
GBFoo GlobalGBFoo __attribute__((guarded_by(sls_mu)));
|
|
|
|
void gb_fun_0() {
|
|
sls_mu.Lock();
|
|
int x = *pgb_var;
|
|
sls_mu.Unlock();
|
|
}
|
|
|
|
void gb_fun_1() {
|
|
sls_mu.Lock();
|
|
*pgb_var = 2;
|
|
sls_mu.Unlock();
|
|
}
|
|
|
|
void gb_fun_2() {
|
|
int x;
|
|
pgb_var = &x;
|
|
}
|
|
|
|
void gb_fun_3() {
|
|
int *x = pgb_var;
|
|
}
|
|
|
|
void gb_bad_0() {
|
|
sls_guard_var = 1; // \
|
|
// expected-warning{{writing variable 'sls_guard_var' requires locking any mutex exclusively}}
|
|
}
|
|
|
|
void gb_bad_1() {
|
|
int x = sls_guard_var; // \
|
|
// expected-warning{{reading variable 'sls_guard_var' requires locking any mutex}}
|
|
}
|
|
|
|
void gb_bad_2() {
|
|
sls_guardby_var = 1; // \
|
|
// expected-warning {{writing variable 'sls_guardby_var' requires locking 'sls_mu' exclusively}}
|
|
}
|
|
|
|
void gb_bad_3() {
|
|
int x = sls_guardby_var; // \
|
|
// expected-warning {{reading variable 'sls_guardby_var' requires locking 'sls_mu'}}
|
|
}
|
|
|
|
void gb_bad_4() {
|
|
*pgb_gvar = 1; // \
|
|
// expected-warning {{writing the value pointed to by 'pgb_gvar' requires locking any mutex exclusively}}
|
|
}
|
|
|
|
void gb_bad_5() {
|
|
int x = *pgb_gvar; // \
|
|
// expected-warning {{reading the value pointed to by 'pgb_gvar' requires locking any mutex}}
|
|
}
|
|
|
|
void gb_bad_6() {
|
|
*pgb_var = 1; // \
|
|
// expected-warning {{writing the value pointed to by 'pgb_var' requires locking 'sls_mu' exclusively}}
|
|
}
|
|
|
|
void gb_bad_7() {
|
|
int x = *pgb_var; // \
|
|
// expected-warning {{reading the value pointed to by 'pgb_var' requires locking 'sls_mu'}}
|
|
}
|
|
|
|
void gb_bad_8() {
|
|
GBFoo G;
|
|
G.gb_field = 0; // \
|
|
// expected-warning {{writing variable 'gb_field' requires locking 'sls_mu'}}
|
|
}
|
|
|
|
void gb_bad_9() {
|
|
sls_guard_var++; // \
|
|
// expected-warning{{writing variable 'sls_guard_var' requires locking any mutex exclusively}}
|
|
sls_guard_var--; // \
|
|
// expected-warning{{writing variable 'sls_guard_var' requires locking any mutex exclusively}}
|
|
++sls_guard_var; // \
|
|
// expected-warning{{writing variable 'sls_guard_var' requires locking any mutex exclusively}}
|
|
--sls_guard_var;// \
|
|
// expected-warning{{writing variable 'sls_guard_var' requires locking any mutex exclusively}}
|
|
}
|
|
|
|
//-----------------------------------------------//
|
|
// Warnings on variables with late parsed attributes
|
|
// ----------------------------------------------//
|
|
|
|
class LateFoo {
|
|
public:
|
|
int a __attribute__((guarded_by(mu)));
|
|
int b;
|
|
|
|
void foo() __attribute__((exclusive_locks_required(mu))) { }
|
|
|
|
void test() {
|
|
a = 0; // \
|
|
// expected-warning{{writing variable 'a' requires locking 'mu' exclusively}}
|
|
b = a; // \
|
|
// expected-warning {{reading variable 'a' requires locking 'mu'}}
|
|
c = 0; // \
|
|
// expected-warning {{writing variable 'c' requires locking 'mu' exclusively}}
|
|
}
|
|
|
|
int c __attribute__((guarded_by(mu)));
|
|
|
|
Mutex mu;
|
|
};
|
|
|
|
class LateBar {
|
|
public:
|
|
int a_ __attribute__((guarded_by(mu1_)));
|
|
int b_;
|
|
int *q __attribute__((pt_guarded_by(mu)));
|
|
Mutex mu1_;
|
|
Mutex mu;
|
|
LateFoo Foo;
|
|
LateFoo Foo2;
|
|
LateFoo *FooPointer;
|
|
};
|
|
|
|
LateBar b1, *b3;
|
|
|
|
void late_0() {
|
|
LateFoo FooA;
|
|
LateFoo FooB;
|
|
FooA.mu.Lock();
|
|
FooA.a = 5;
|
|
FooA.mu.Unlock();
|
|
}
|
|
|
|
void late_1() {
|
|
LateBar BarA;
|
|
BarA.FooPointer->mu.Lock();
|
|
BarA.FooPointer->a = 2;
|
|
BarA.FooPointer->mu.Unlock();
|
|
}
|
|
|
|
void late_bad_0() {
|
|
LateFoo fooA;
|
|
LateFoo fooB;
|
|
fooA.mu.Lock();
|
|
fooB.a = 5; // \
|
|
// expected-warning{{writing variable 'a' requires locking 'mu' exclusively}}
|
|
fooA.mu.Unlock();
|
|
}
|
|
|
|
void late_bad_1() {
|
|
Mutex mu;
|
|
mu.Lock();
|
|
b1.mu1_.Lock();
|
|
int res = b1.a_ + b3->b_;
|
|
b3->b_ = *b1.q; // \
|
|
// expected-warning{{reading the value pointed to by 'q' requires locking 'mu'}}
|
|
b1.mu1_.Unlock();
|
|
b1.b_ = res;
|
|
mu.Unlock();
|
|
}
|
|
|
|
void late_bad_2() {
|
|
LateBar BarA;
|
|
BarA.FooPointer->mu.Lock();
|
|
BarA.Foo.a = 2; // \
|
|
// expected-warning{{writing variable 'a' requires locking 'mu' exclusively}}
|
|
BarA.FooPointer->mu.Unlock();
|
|
}
|
|
|
|
void late_bad_3() {
|
|
LateBar BarA;
|
|
BarA.Foo.mu.Lock();
|
|
BarA.FooPointer->a = 2; // \
|
|
// expected-warning{{writing variable 'a' requires locking 'mu' exclusively}}
|
|
BarA.Foo.mu.Unlock();
|
|
}
|
|
|
|
void late_bad_4() {
|
|
LateBar BarA;
|
|
BarA.Foo.mu.Lock();
|
|
BarA.Foo2.a = 2; // \
|
|
// expected-warning{{writing variable 'a' requires locking 'mu' exclusively}}
|
|
BarA.Foo.mu.Unlock();
|
|
}
|
|
|
|
//-----------------------------------------------//
|
|
// Extra warnings for shared vs. exclusive locks
|
|
// ----------------------------------------------//
|
|
|
|
void shared_fun_0() {
|
|
sls_mu.Lock();
|
|
do {
|
|
sls_mu.Unlock();
|
|
sls_mu.Lock();
|
|
} while (getBool());
|
|
sls_mu.Unlock();
|
|
}
|
|
|
|
void shared_fun_1() {
|
|
sls_mu.ReaderLock(); // \
|
|
// expected-warning {{mutex 'sls_mu' is locked exclusively and shared in the same scope}}
|
|
do {
|
|
sls_mu.Unlock();
|
|
sls_mu.Lock(); // \
|
|
// expected-note {{the other lock of mutex 'sls_mu' is here}}
|
|
} while (getBool());
|
|
sls_mu.Unlock();
|
|
}
|
|
|
|
void shared_fun_3() {
|
|
if (getBool())
|
|
sls_mu.Lock();
|
|
else
|
|
sls_mu.Lock();
|
|
*pgb_var = 1;
|
|
sls_mu.Unlock();
|
|
}
|
|
|
|
void shared_fun_4() {
|
|
if (getBool())
|
|
sls_mu.ReaderLock();
|
|
else
|
|
sls_mu.ReaderLock();
|
|
int x = sls_guardby_var;
|
|
sls_mu.Unlock();
|
|
}
|
|
|
|
void shared_fun_8() {
|
|
if (getBool())
|
|
sls_mu.Lock(); // \
|
|
// expected-warning {{mutex 'sls_mu' is locked exclusively and shared in the same scope}}
|
|
else
|
|
sls_mu.ReaderLock(); // \
|
|
// expected-note {{the other lock of mutex 'sls_mu' is here}}
|
|
sls_mu.Unlock();
|
|
}
|
|
|
|
void shared_bad_0() {
|
|
sls_mu.Lock(); // \
|
|
// expected-warning {{mutex 'sls_mu' is locked exclusively and shared in the same scope}}
|
|
do {
|
|
sls_mu.Unlock();
|
|
sls_mu.ReaderLock(); // \
|
|
// expected-note {{the other lock of mutex 'sls_mu' is here}}
|
|
} while (getBool());
|
|
sls_mu.Unlock();
|
|
}
|
|
|
|
void shared_bad_1() {
|
|
if (getBool())
|
|
sls_mu.Lock(); // \
|
|
// expected-warning {{mutex 'sls_mu' is locked exclusively and shared in the same scope}}
|
|
else
|
|
sls_mu.ReaderLock(); // \
|
|
// expected-note {{the other lock of mutex 'sls_mu' is here}}
|
|
*pgb_var = 1;
|
|
sls_mu.Unlock();
|
|
}
|
|
|
|
void shared_bad_2() {
|
|
if (getBool())
|
|
sls_mu.ReaderLock(); // \
|
|
// expected-warning {{mutex 'sls_mu' is locked exclusively and shared in the same scope}}
|
|
else
|
|
sls_mu.Lock(); // \
|
|
// expected-note {{the other lock of mutex 'sls_mu' is here}}
|
|
*pgb_var = 1;
|
|
sls_mu.Unlock();
|
|
}
|
|
|
|
// FIXME: Add support for functions (not only methods)
|
|
class LRBar {
|
|
public:
|
|
void aa_elr_fun() __attribute__((exclusive_locks_required(aa_mu)));
|
|
void aa_elr_fun_s() __attribute__((shared_locks_required(aa_mu)));
|
|
void le_fun() __attribute__((locks_excluded(sls_mu)));
|
|
};
|
|
|
|
class LRFoo {
|
|
public:
|
|
void test() __attribute__((exclusive_locks_required(sls_mu)));
|
|
void testShared() __attribute__((shared_locks_required(sls_mu2)));
|
|
};
|
|
|
|
void elr_fun() __attribute__((exclusive_locks_required(sls_mu)));
|
|
void elr_fun() {}
|
|
|
|
LRFoo MyLRFoo;
|
|
LRBar Bar;
|
|
|
|
void es_fun_0() {
|
|
aa_mu.Lock();
|
|
Bar.aa_elr_fun();
|
|
aa_mu.Unlock();
|
|
}
|
|
|
|
void es_fun_1() {
|
|
aa_mu.Lock();
|
|
Bar.aa_elr_fun_s();
|
|
aa_mu.Unlock();
|
|
}
|
|
|
|
void es_fun_2() {
|
|
aa_mu.ReaderLock();
|
|
Bar.aa_elr_fun_s();
|
|
aa_mu.Unlock();
|
|
}
|
|
|
|
void es_fun_3() {
|
|
sls_mu.Lock();
|
|
MyLRFoo.test();
|
|
sls_mu.Unlock();
|
|
}
|
|
|
|
void es_fun_4() {
|
|
sls_mu2.Lock();
|
|
MyLRFoo.testShared();
|
|
sls_mu2.Unlock();
|
|
}
|
|
|
|
void es_fun_5() {
|
|
sls_mu2.ReaderLock();
|
|
MyLRFoo.testShared();
|
|
sls_mu2.Unlock();
|
|
}
|
|
|
|
void es_fun_6() {
|
|
Bar.le_fun();
|
|
}
|
|
|
|
void es_fun_7() {
|
|
sls_mu.Lock();
|
|
elr_fun();
|
|
sls_mu.Unlock();
|
|
}
|
|
|
|
void es_fun_8() __attribute__((no_thread_safety_analysis));
|
|
|
|
void es_fun_8() {
|
|
Bar.aa_elr_fun_s();
|
|
}
|
|
|
|
void es_fun_9() __attribute__((shared_locks_required(aa_mu)));
|
|
void es_fun_9() {
|
|
Bar.aa_elr_fun_s();
|
|
}
|
|
|
|
void es_fun_10() __attribute__((exclusive_locks_required(aa_mu)));
|
|
void es_fun_10() {
|
|
Bar.aa_elr_fun_s();
|
|
}
|
|
|
|
void es_bad_0() {
|
|
Bar.aa_elr_fun(); // \
|
|
// expected-warning {{calling function 'aa_elr_fun' requires exclusive lock on 'aa_mu'}}
|
|
}
|
|
|
|
void es_bad_1() {
|
|
aa_mu.ReaderLock();
|
|
Bar.aa_elr_fun(); // \
|
|
// expected-warning {{calling function 'aa_elr_fun' requires exclusive lock on 'aa_mu'}}
|
|
aa_mu.Unlock();
|
|
}
|
|
|
|
void es_bad_2() {
|
|
Bar.aa_elr_fun_s(); // \
|
|
// expected-warning {{calling function 'aa_elr_fun_s' requires shared lock on 'aa_mu'}}
|
|
}
|
|
|
|
void es_bad_3() {
|
|
MyLRFoo.test(); // \
|
|
// expected-warning {{calling function 'test' requires exclusive lock on 'sls_mu'}}
|
|
}
|
|
|
|
void es_bad_4() {
|
|
MyLRFoo.testShared(); // \
|
|
// expected-warning {{calling function 'testShared' requires shared lock on 'sls_mu2'}}
|
|
}
|
|
|
|
void es_bad_5() {
|
|
sls_mu.ReaderLock();
|
|
MyLRFoo.test(); // \
|
|
// expected-warning {{calling function 'test' requires exclusive lock on 'sls_mu'}}
|
|
sls_mu.Unlock();
|
|
}
|
|
|
|
void es_bad_6() {
|
|
sls_mu.Lock();
|
|
Bar.le_fun(); // \
|
|
// expected-warning {{cannot call function 'le_fun' while mutex 'sls_mu' is locked}}
|
|
sls_mu.Unlock();
|
|
}
|
|
|
|
void es_bad_7() {
|
|
sls_mu.ReaderLock();
|
|
Bar.le_fun(); // \
|
|
// expected-warning {{cannot call function 'le_fun' while mutex 'sls_mu' is locked}}
|
|
sls_mu.Unlock();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------//
|
|
// Unparseable lock expressions
|
|
// ----------------------------------------------//
|
|
|
|
// FIXME -- derive new tests for unhandled expressions
|
|
|
|
|
|
//----------------------------------------------------------------------------//
|
|
// The following test cases are ported from the gcc thread safety implementation
|
|
// They are each wrapped inside a namespace with the test number of the gcc test
|
|
//
|
|
// FIXME: add all the gcc tests, once this analysis passes them.
|
|
//----------------------------------------------------------------------------//
|
|
|
|
//-----------------------------------------//
|
|
// Good testcases (no errors)
|
|
//-----------------------------------------//
|
|
|
|
namespace thread_annot_lock_20 {
|
|
class Bar {
|
|
public:
|
|
static int func1() EXCLUSIVE_LOCKS_REQUIRED(mu1_);
|
|
static int b_ GUARDED_BY(mu1_);
|
|
static Mutex mu1_;
|
|
static int a_ GUARDED_BY(mu1_);
|
|
};
|
|
|
|
Bar b1;
|
|
|
|
int Bar::func1()
|
|
{
|
|
int res = 5;
|
|
|
|
if (a_ == 4)
|
|
res = b_;
|
|
return res;
|
|
}
|
|
} // end namespace thread_annot_lock_20
|
|
|
|
namespace thread_annot_lock_22 {
|
|
// Test various usage of GUARDED_BY and PT_GUARDED_BY annotations, especially
|
|
// uses in class definitions.
|
|
Mutex mu;
|
|
|
|
class Bar {
|
|
public:
|
|
int a_ GUARDED_BY(mu1_);
|
|
int b_;
|
|
int *q PT_GUARDED_BY(mu);
|
|
Mutex mu1_ ACQUIRED_AFTER(mu);
|
|
};
|
|
|
|
Bar b1, *b3;
|
|
int *p GUARDED_BY(mu) PT_GUARDED_BY(mu);
|
|
int res GUARDED_BY(mu) = 5;
|
|
|
|
int func(int i)
|
|
{
|
|
int x;
|
|
mu.Lock();
|
|
b1.mu1_.Lock();
|
|
res = b1.a_ + b3->b_;
|
|
*p = i;
|
|
b1.a_ = res + b3->b_;
|
|
b3->b_ = *b1.q;
|
|
b1.mu1_.Unlock();
|
|
b1.b_ = res;
|
|
x = res;
|
|
mu.Unlock();
|
|
return x;
|
|
}
|
|
} // end namespace thread_annot_lock_22
|
|
|
|
namespace thread_annot_lock_27_modified {
|
|
// test lock annotations applied to function definitions
|
|
// Modified: applied annotations only to function declarations
|
|
Mutex mu1;
|
|
Mutex mu2 ACQUIRED_AFTER(mu1);
|
|
|
|
class Foo {
|
|
public:
|
|
int method1(int i) SHARED_LOCKS_REQUIRED(mu2) EXCLUSIVE_LOCKS_REQUIRED(mu1);
|
|
};
|
|
|
|
int Foo::method1(int i) {
|
|
return i;
|
|
}
|
|
|
|
|
|
int foo(int i) EXCLUSIVE_LOCKS_REQUIRED(mu2) SHARED_LOCKS_REQUIRED(mu1);
|
|
int foo(int i) {
|
|
return i;
|
|
}
|
|
|
|
static int bar(int i) EXCLUSIVE_LOCKS_REQUIRED(mu1);
|
|
static int bar(int i) {
|
|
return i;
|
|
}
|
|
|
|
void main() {
|
|
Foo a;
|
|
|
|
mu1.Lock();
|
|
mu2.Lock();
|
|
a.method1(1);
|
|
foo(2);
|
|
mu2.Unlock();
|
|
bar(3);
|
|
mu1.Unlock();
|
|
}
|
|
} // end namespace thread_annot_lock_27_modified
|
|
|
|
|
|
namespace thread_annot_lock_38 {
|
|
// Test the case where a template member function is annotated with lock
|
|
// attributes in a non-template class.
|
|
class Foo {
|
|
public:
|
|
void func1(int y) LOCKS_EXCLUDED(mu_);
|
|
template <typename T> void func2(T x) LOCKS_EXCLUDED(mu_);
|
|
private:
|
|
Mutex mu_;
|
|
};
|
|
|
|
Foo *foo;
|
|
|
|
void main()
|
|
{
|
|
foo->func1(5);
|
|
foo->func2(5);
|
|
}
|
|
} // end namespace thread_annot_lock_38
|
|
|
|
namespace thread_annot_lock_43 {
|
|
// Tests lock canonicalization
|
|
class Foo {
|
|
public:
|
|
Mutex *mu_;
|
|
};
|
|
|
|
class FooBar {
|
|
public:
|
|
Foo *foo_;
|
|
int GetA() EXCLUSIVE_LOCKS_REQUIRED(foo_->mu_) { return a_; }
|
|
int a_ GUARDED_BY(foo_->mu_);
|
|
};
|
|
|
|
FooBar *fb;
|
|
|
|
void main()
|
|
{
|
|
int x;
|
|
fb->foo_->mu_->Lock();
|
|
x = fb->GetA();
|
|
fb->foo_->mu_->Unlock();
|
|
}
|
|
} // end namespace thread_annot_lock_43
|
|
|
|
namespace thread_annot_lock_49 {
|
|
// Test the support for use of lock expression in the annotations
|
|
class Foo {
|
|
public:
|
|
Mutex foo_mu_;
|
|
};
|
|
|
|
class Bar {
|
|
private:
|
|
Foo *foo;
|
|
Mutex bar_mu_ ACQUIRED_AFTER(foo->foo_mu_);
|
|
|
|
public:
|
|
void Test1() {
|
|
foo->foo_mu_.Lock();
|
|
bar_mu_.Lock();
|
|
bar_mu_.Unlock();
|
|
foo->foo_mu_.Unlock();
|
|
}
|
|
};
|
|
|
|
void main() {
|
|
Bar bar;
|
|
bar.Test1();
|
|
}
|
|
} // end namespace thread_annot_lock_49
|
|
|
|
namespace thread_annot_lock_61_modified {
|
|
// Modified to fix the compiler errors
|
|
// Test the fix for a bug introduced by the support of pass-by-reference
|
|
// paramters.
|
|
struct Foo { Foo &operator<< (bool) {return *this;} };
|
|
Foo &getFoo();
|
|
struct Bar { Foo &func () {return getFoo();} };
|
|
struct Bas { void operator& (Foo &) {} };
|
|
void mumble()
|
|
{
|
|
Bas() & Bar().func() << "" << "";
|
|
Bas() & Bar().func() << "";
|
|
}
|
|
} // end namespace thread_annot_lock_61_modified
|
|
|
|
|
|
namespace thread_annot_lock_65 {
|
|
// Test the fix for a bug in the support of allowing reader locks for
|
|
// non-const, non-modifying overload functions. (We didn't handle the builtin
|
|
// properly.)
|
|
enum MyFlags {
|
|
Zero,
|
|
One,
|
|
Two,
|
|
Three,
|
|
Four,
|
|
Five,
|
|
Six,
|
|
Seven,
|
|
Eight,
|
|
Nine
|
|
};
|
|
|
|
inline MyFlags
|
|
operator|(MyFlags a, MyFlags b)
|
|
{
|
|
return MyFlags(static_cast<int>(a) | static_cast<int>(b));
|
|
}
|
|
|
|
inline MyFlags&
|
|
operator|=(MyFlags& a, MyFlags b)
|
|
{
|
|
return a = a | b;
|
|
}
|
|
} // end namespace thread_annot_lock_65
|
|
|
|
namespace thread_annot_lock_66_modified {
|
|
// Modified: Moved annotation to function defn
|
|
// Test annotations on out-of-line definitions of member functions where the
|
|
// annotations refer to locks that are also data members in the class.
|
|
Mutex mu;
|
|
|
|
class Foo {
|
|
public:
|
|
int method1(int i) SHARED_LOCKS_REQUIRED(mu1, mu, mu2);
|
|
int data GUARDED_BY(mu1);
|
|
Mutex *mu1;
|
|
Mutex *mu2;
|
|
};
|
|
|
|
int Foo::method1(int i)
|
|
{
|
|
return data + i;
|
|
}
|
|
|
|
void main()
|
|
{
|
|
Foo a;
|
|
|
|
a.mu2->Lock();
|
|
a.mu1->Lock();
|
|
mu.Lock();
|
|
a.method1(1);
|
|
mu.Unlock();
|
|
a.mu1->Unlock();
|
|
a.mu2->Unlock();
|
|
}
|
|
} // end namespace thread_annot_lock_66_modified
|
|
|
|
namespace thread_annot_lock_68_modified {
|
|
// Test a fix to a bug in the delayed name binding with nested template
|
|
// instantiation. We use a stack to make sure a name is not resolved to an
|
|
// inner context.
|
|
template <typename T>
|
|
class Bar {
|
|
Mutex mu_;
|
|
};
|
|
|
|
template <typename T>
|
|
class Foo {
|
|
public:
|
|
void func(T x) {
|
|
mu_.Lock();
|
|
count_ = x;
|
|
mu_.Unlock();
|
|
}
|
|
|
|
private:
|
|
T count_ GUARDED_BY(mu_);
|
|
Bar<T> bar_;
|
|
Mutex mu_;
|
|
};
|
|
|
|
void main()
|
|
{
|
|
Foo<int> *foo;
|
|
foo->func(5);
|
|
}
|
|
} // end namespace thread_annot_lock_68_modified
|
|
|
|
namespace thread_annot_lock_30_modified {
|
|
// Test delay parsing of lock attribute arguments with nested classes.
|
|
// Modified: trylocks replaced with exclusive_lock_fun
|
|
int a = 0;
|
|
|
|
class Bar {
|
|
struct Foo;
|
|
|
|
public:
|
|
void MyLock() EXCLUSIVE_LOCK_FUNCTION(mu);
|
|
|
|
int func() {
|
|
MyLock();
|
|
// if (foo == 0) {
|
|
// return 0;
|
|
// }
|
|
a = 5;
|
|
mu.Unlock();
|
|
return 1;
|
|
}
|
|
|
|
class FooBar {
|
|
int x;
|
|
int y;
|
|
};
|
|
|
|
private:
|
|
Mutex mu;
|
|
};
|
|
|
|
Bar *bar;
|
|
|
|
void main()
|
|
{
|
|
bar->func();
|
|
}
|
|
} // end namespace thread_annot_lock_30_modified
|
|
|
|
namespace thread_annot_lock_47 {
|
|
// Test the support for annotations on virtual functions.
|
|
// This is a good test case. (i.e. There should be no warning emitted by the
|
|
// compiler.)
|
|
class Base {
|
|
public:
|
|
virtual void func1() EXCLUSIVE_LOCKS_REQUIRED(mu_);
|
|
virtual void func2() LOCKS_EXCLUDED(mu_);
|
|
Mutex mu_;
|
|
};
|
|
|
|
class Child : public Base {
|
|
public:
|
|
virtual void func1() EXCLUSIVE_LOCKS_REQUIRED(mu_);
|
|
virtual void func2() LOCKS_EXCLUDED(mu_);
|
|
};
|
|
|
|
void main() {
|
|
Child *c;
|
|
Base *b = c;
|
|
|
|
b->mu_.Lock();
|
|
b->func1();
|
|
b->mu_.Unlock();
|
|
b->func2();
|
|
|
|
c->mu_.Lock();
|
|
c->func1();
|
|
c->mu_.Unlock();
|
|
c->func2();
|
|
}
|
|
} // end namespace thread_annot_lock_47
|
|
|
|
//-----------------------------------------//
|
|
// Tests which produce errors
|
|
//-----------------------------------------//
|
|
|
|
namespace thread_annot_lock_13 {
|
|
Mutex mu1;
|
|
Mutex mu2;
|
|
|
|
int g GUARDED_BY(mu1);
|
|
int w GUARDED_BY(mu2);
|
|
|
|
class Foo {
|
|
public:
|
|
void bar() LOCKS_EXCLUDED(mu_, mu1);
|
|
int foo() SHARED_LOCKS_REQUIRED(mu_) EXCLUSIVE_LOCKS_REQUIRED(mu2);
|
|
|
|
private:
|
|
int a_ GUARDED_BY(mu_);
|
|
public:
|
|
Mutex mu_ ACQUIRED_AFTER(mu1);
|
|
};
|
|
|
|
int Foo::foo()
|
|
{
|
|
int res;
|
|
w = 5;
|
|
res = a_ + 5;
|
|
return res;
|
|
}
|
|
|
|
void Foo::bar()
|
|
{
|
|
int x;
|
|
mu_.Lock();
|
|
x = foo(); // expected-warning {{calling function 'foo' requires exclusive lock on 'mu2'}}
|
|
a_ = x + 1;
|
|
mu_.Unlock();
|
|
if (x > 5) {
|
|
mu1.Lock();
|
|
g = 2;
|
|
mu1.Unlock();
|
|
}
|
|
}
|
|
|
|
void main()
|
|
{
|
|
Foo f1, *f2;
|
|
f1.mu_.Lock();
|
|
f1.bar(); // expected-warning {{cannot call function 'bar' while mutex 'mu_' is locked}}
|
|
mu2.Lock();
|
|
f1.foo();
|
|
mu2.Unlock();
|
|
f1.mu_.Unlock();
|
|
f2->mu_.Lock();
|
|
f2->bar(); // expected-warning {{cannot call function 'bar' while mutex 'mu_' is locked}}
|
|
f2->mu_.Unlock();
|
|
mu2.Lock();
|
|
w = 2;
|
|
mu2.Unlock();
|
|
}
|
|
} // end namespace thread_annot_lock_13
|
|
|
|
namespace thread_annot_lock_18_modified {
|
|
// Modified: Trylocks removed
|
|
// Test the ability to distnguish between the same lock field of
|
|
// different objects of a class.
|
|
class Bar {
|
|
public:
|
|
bool MyLock() EXCLUSIVE_LOCK_FUNCTION(mu1_);
|
|
void MyUnlock() UNLOCK_FUNCTION(mu1_);
|
|
int a_ GUARDED_BY(mu1_);
|
|
|
|
private:
|
|
Mutex mu1_;
|
|
};
|
|
|
|
Bar *b1, *b2;
|
|
|
|
void func()
|
|
{
|
|
b1->MyLock();
|
|
b1->a_ = 5;
|
|
b2->a_ = 3; // expected-warning {{writing variable 'a_' requires locking 'mu1_' exclusively}}
|
|
b2->MyLock();
|
|
b2->MyUnlock();
|
|
b1->MyUnlock();
|
|
}
|
|
} // end namespace thread_annot_lock_18_modified
|
|
|
|
namespace thread_annot_lock_21 {
|
|
// Test various usage of GUARDED_BY and PT_GUARDED_BY annotations, especially
|
|
// uses in class definitions.
|
|
Mutex mu;
|
|
|
|
class Bar {
|
|
public:
|
|
int a_ GUARDED_BY(mu1_);
|
|
int b_;
|
|
int *q PT_GUARDED_BY(mu);
|
|
Mutex mu1_ ACQUIRED_AFTER(mu);
|
|
};
|
|
|
|
Bar b1, *b3;
|
|
int *p GUARDED_BY(mu) PT_GUARDED_BY(mu);
|
|
|
|
int res GUARDED_BY(mu) = 5;
|
|
|
|
int func(int i)
|
|
{
|
|
int x;
|
|
b3->mu1_.Lock();
|
|
res = b1.a_ + b3->b_; // expected-warning {{reading variable 'a_' requires locking 'mu1_'}} \
|
|
// expected-warning {{writing variable 'res' requires locking 'mu' exclusively}}
|
|
*p = i; // expected-warning {{reading variable 'p' requires locking 'mu'}} \
|
|
// expected-warning {{writing the value pointed to by 'p' requires locking 'mu' exclusively}}
|
|
b1.a_ = res + b3->b_; // expected-warning {{reading variable 'res' requires locking 'mu'}} \
|
|
// expected-warning {{writing variable 'a_' requires locking 'mu1_' exclusively}}
|
|
b3->b_ = *b1.q; // expected-warning {{reading the value pointed to by 'q' requires locking 'mu'}}
|
|
b3->mu1_.Unlock();
|
|
b1.b_ = res; // expected-warning {{reading variable 'res' requires locking 'mu'}}
|
|
x = res; // expected-warning {{reading variable 'res' requires locking 'mu'}}
|
|
return x;
|
|
}
|
|
} // end namespace thread_annot_lock_21
|
|
|
|
namespace thread_annot_lock_35_modified {
|
|
// Test the analyzer's ability to distinguish the lock field of different
|
|
// objects.
|
|
class Foo {
|
|
private:
|
|
Mutex lock_;
|
|
int a_ GUARDED_BY(lock_);
|
|
|
|
public:
|
|
void Func(Foo* child) LOCKS_EXCLUDED(lock_) {
|
|
Foo *new_foo = new Foo;
|
|
|
|
lock_.Lock();
|
|
|
|
child->Func(new_foo); // There shouldn't be any warning here as the
|
|
// acquired lock is not in child.
|
|
child->bar(7); // expected-warning {{calling function 'bar' requires exclusive lock on 'lock_'}}
|
|
child->a_ = 5; // expected-warning {{writing variable 'a_' requires locking 'lock_' exclusively}}
|
|
lock_.Unlock();
|
|
}
|
|
|
|
void bar(int y) EXCLUSIVE_LOCKS_REQUIRED(lock_) {
|
|
a_ = y;
|
|
}
|
|
};
|
|
|
|
Foo *x;
|
|
|
|
void main() {
|
|
Foo *child = new Foo;
|
|
x->Func(child);
|
|
}
|
|
} // end namespace thread_annot_lock_35_modified
|
|
|
|
namespace thread_annot_lock_36_modified {
|
|
// Modified to move the annotations to function defns.
|
|
// Test the analyzer's ability to distinguish the lock field of different
|
|
// objects
|
|
class Foo {
|
|
private:
|
|
Mutex lock_;
|
|
int a_ GUARDED_BY(lock_);
|
|
|
|
public:
|
|
void Func(Foo* child) LOCKS_EXCLUDED(lock_);
|
|
void bar(int y) EXCLUSIVE_LOCKS_REQUIRED(lock_);
|
|
};
|
|
|
|
void Foo::Func(Foo* child) {
|
|
Foo *new_foo = new Foo;
|
|
|
|
lock_.Lock();
|
|
|
|
child->lock_.Lock();
|
|
child->Func(new_foo); // expected-warning {{cannot call function 'Func' while mutex 'lock_' is locked}}
|
|
child->bar(7);
|
|
child->a_ = 5;
|
|
child->lock_.Unlock();
|
|
|
|
lock_.Unlock();
|
|
}
|
|
|
|
void Foo::bar(int y) {
|
|
a_ = y;
|
|
}
|
|
|
|
|
|
Foo *x;
|
|
|
|
void main() {
|
|
Foo *child = new Foo;
|
|
x->Func(child);
|
|
}
|
|
} // end namespace thread_annot_lock_36_modified
|
|
|
|
|
|
namespace thread_annot_lock_42 {
|
|
// Test support of multiple lock attributes of the same kind on a decl.
|
|
class Foo {
|
|
private:
|
|
Mutex mu1, mu2, mu3;
|
|
int x GUARDED_BY(mu1) GUARDED_BY(mu2);
|
|
int y GUARDED_BY(mu2);
|
|
|
|
void f2() LOCKS_EXCLUDED(mu1) LOCKS_EXCLUDED(mu2) LOCKS_EXCLUDED(mu3) {
|
|
mu2.Lock();
|
|
y = 2;
|
|
mu2.Unlock();
|
|
}
|
|
|
|
public:
|
|
void f1() EXCLUSIVE_LOCKS_REQUIRED(mu2) EXCLUSIVE_LOCKS_REQUIRED(mu1) {
|
|
x = 5;
|
|
f2(); // expected-warning {{cannot call function 'f2' while mutex 'mu1' is locked}} \
|
|
// expected-warning {{cannot call function 'f2' while mutex 'mu2' is locked}}
|
|
}
|
|
};
|
|
|
|
Foo *foo;
|
|
|
|
void func()
|
|
{
|
|
foo->f1(); // expected-warning {{calling function 'f1' requires exclusive lock on 'mu2'}} \
|
|
// expected-warning {{calling function 'f1' requires exclusive lock on 'mu1'}}
|
|
}
|
|
} // end namespace thread_annot_lock_42
|
|
|
|
namespace thread_annot_lock_46 {
|
|
// Test the support for annotations on virtual functions.
|
|
class Base {
|
|
public:
|
|
virtual void func1() EXCLUSIVE_LOCKS_REQUIRED(mu_);
|
|
virtual void func2() LOCKS_EXCLUDED(mu_);
|
|
Mutex mu_;
|
|
};
|
|
|
|
class Child : public Base {
|
|
public:
|
|
virtual void func1() EXCLUSIVE_LOCKS_REQUIRED(mu_);
|
|
virtual void func2() LOCKS_EXCLUDED(mu_);
|
|
};
|
|
|
|
void main() {
|
|
Child *c;
|
|
Base *b = c;
|
|
|
|
b->func1(); // expected-warning {{calling function 'func1' requires exclusive lock on 'mu_'}}
|
|
b->mu_.Lock();
|
|
b->func2(); // expected-warning {{cannot call function 'func2' while mutex 'mu_' is locked}}
|
|
b->mu_.Unlock();
|
|
|
|
c->func1(); // expected-warning {{calling function 'func1' requires exclusive lock on 'mu_'}}
|
|
c->mu_.Lock();
|
|
c->func2(); // expected-warning {{cannot call function 'func2' while mutex 'mu_' is locked}}
|
|
c->mu_.Unlock();
|
|
}
|
|
} // end namespace thread_annot_lock_46
|
|
|
|
namespace thread_annot_lock_67_modified {
|
|
// Modified: attributes on definitions moved to declarations
|
|
// Test annotations on out-of-line definitions of member functions where the
|
|
// annotations refer to locks that are also data members in the class.
|
|
Mutex mu;
|
|
Mutex mu3;
|
|
|
|
class Foo {
|
|
public:
|
|
int method1(int i) SHARED_LOCKS_REQUIRED(mu1, mu, mu2, mu3);
|
|
int data GUARDED_BY(mu1);
|
|
Mutex *mu1;
|
|
Mutex *mu2;
|
|
};
|
|
|
|
int Foo::method1(int i) {
|
|
return data + i;
|
|
}
|
|
|
|
void main()
|
|
{
|
|
Foo a;
|
|
a.method1(1); // expected-warning {{calling function 'method1' requires shared lock on 'mu1'}} \
|
|
// expected-warning {{calling function 'method1' requires shared lock on 'mu'}} \
|
|
// expected-warning {{calling function 'method1' requires shared lock on 'mu2'}} \
|
|
// expected-warning {{calling function 'method1' requires shared lock on 'mu3'}}
|
|
}
|
|
} // end namespace thread_annot_lock_67_modified
|
|
|
|
|
|
namespace substitution_test {
|
|
class MyData {
|
|
public:
|
|
Mutex mu;
|
|
|
|
void lockData() __attribute__((exclusive_lock_function(mu))) { }
|
|
void unlockData() __attribute__((unlock_function(mu))) { }
|
|
|
|
void doSomething() __attribute__((exclusive_locks_required(mu))) { }
|
|
};
|
|
|
|
|
|
class DataLocker {
|
|
public:
|
|
void lockData (MyData *d) __attribute__((exclusive_lock_function(d->mu))) { }
|
|
void unlockData(MyData *d) __attribute__((unlock_function(d->mu))) { }
|
|
};
|
|
|
|
|
|
class Foo {
|
|
public:
|
|
void foo(MyData* d) __attribute__((exclusive_locks_required(d->mu))) { }
|
|
|
|
void bar1(MyData* d) {
|
|
d->lockData();
|
|
foo(d);
|
|
d->unlockData();
|
|
}
|
|
|
|
void bar2(MyData* d) {
|
|
DataLocker dlr;
|
|
dlr.lockData(d);
|
|
foo(d);
|
|
dlr.unlockData(d);
|
|
}
|
|
|
|
void bar3(MyData* d1, MyData* d2) {
|
|
DataLocker dlr;
|
|
dlr.lockData(d1); // expected-note {{mutex acquired here}}
|
|
dlr.unlockData(d2); // \
|
|
// expected-warning {{unlocking 'mu' that was not locked}}
|
|
} // expected-warning {{mutex 'mu' is still locked at the end of function}}
|
|
|
|
void bar4(MyData* d1, MyData* d2) {
|
|
DataLocker dlr;
|
|
dlr.lockData(d1);
|
|
foo(d2); // \
|
|
// expected-warning {{calling function 'foo' requires exclusive lock on 'mu'}}
|
|
dlr.unlockData(d1);
|
|
}
|
|
};
|
|
} // end namespace substituation_test
|
|
|
|
|
|
|
|
namespace constructor_destructor_tests {
|
|
Mutex fooMu;
|
|
int myVar GUARDED_BY(fooMu);
|
|
|
|
class Foo {
|
|
public:
|
|
Foo() __attribute__((exclusive_lock_function(fooMu))) { }
|
|
~Foo() __attribute__((unlock_function(fooMu))) { }
|
|
};
|
|
|
|
void fooTest() {
|
|
Foo foo;
|
|
myVar = 0;
|
|
}
|
|
}
|
|
|
|
|
|
namespace invalid_lock_expression_test {
|
|
|
|
class LOCKABLE MyLockable {
|
|
public:
|
|
MyLockable() __attribute__((exclusive_lock_function)) { }
|
|
~MyLockable() { }
|
|
};
|
|
|
|
// create an empty lock expression
|
|
void foo() {
|
|
MyLockable lock; // \
|
|
// expected-warning {{cannot resolve lock expression}}
|
|
}
|
|
|
|
} // end namespace invalid_lock_expression_test
|
|
|
|
namespace template_member_test {
|
|
|
|
struct S { int n; };
|
|
struct T {
|
|
Mutex m;
|
|
S *s GUARDED_BY(this->m);
|
|
};
|
|
Mutex m;
|
|
struct U {
|
|
union {
|
|
int n;
|
|
};
|
|
} *u GUARDED_BY(m);
|
|
|
|
template<typename U>
|
|
struct IndirectLock {
|
|
int DoNaughtyThings(T *t) {
|
|
u->n = 0; // expected-warning {{reading variable 'u' requires locking 'm'}}
|
|
return t->s->n; // expected-warning {{reading variable 's' requires locking 'm'}}
|
|
}
|
|
};
|
|
|
|
template struct IndirectLock<int>; // expected-note {{here}}
|
|
|
|
struct V {
|
|
void f(int);
|
|
void f(double);
|
|
|
|
Mutex m;
|
|
V *p GUARDED_BY(this->m);
|
|
};
|
|
template<typename U> struct W {
|
|
V v;
|
|
void f(U u) {
|
|
v.p->f(u); // expected-warning {{reading variable 'p' requires locking 'm'}}
|
|
}
|
|
};
|
|
template struct W<int>; // expected-note {{here}}
|
|
|
|
}
|
|
|
|
namespace test_scoped_lockable {
|
|
|
|
struct TestScopedLockable {
|
|
Mutex mu1;
|
|
Mutex mu2;
|
|
int a __attribute__((guarded_by(mu1)));
|
|
int b __attribute__((guarded_by(mu2)));
|
|
|
|
bool getBool();
|
|
|
|
void foo1() {
|
|
MutexLock mulock(&mu1);
|
|
a = 5;
|
|
}
|
|
|
|
void foo2() {
|
|
ReaderMutexLock mulock1(&mu1);
|
|
if (getBool()) {
|
|
MutexLock mulock2a(&mu2);
|
|
b = a + 1;
|
|
}
|
|
else {
|
|
MutexLock mulock2b(&mu2);
|
|
b = a + 2;
|
|
}
|
|
}
|
|
|
|
void foo3() {
|
|
MutexLock mulock_a(&mu1);
|
|
MutexLock mulock_b(&mu1); // \
|
|
// expected-warning {{locking 'mu1' that is already locked}}
|
|
} // expected-warning {{unlocking 'mu1' that was not locked}}
|
|
|
|
void foo4() {
|
|
MutexLock mulock1(&mu1), mulock2(&mu2);
|
|
a = b+1;
|
|
b = a+1;
|
|
}
|
|
};
|
|
|
|
} // end namespace test_scoped_lockable
|
|
|
|
|
|
namespace FunctionAttrTest {
|
|
|
|
class Foo {
|
|
public:
|
|
Mutex mu_;
|
|
int a GUARDED_BY(mu_);
|
|
};
|
|
|
|
Foo fooObj;
|
|
|
|
void foo() EXCLUSIVE_LOCKS_REQUIRED(fooObj.mu_);
|
|
|
|
void bar() {
|
|
foo(); // expected-warning {{calling function 'foo' requires exclusive lock on 'mu_'}}
|
|
fooObj.mu_.Lock();
|
|
foo();
|
|
fooObj.mu_.Unlock();
|
|
}
|
|
|
|
}; // end namespace FunctionAttrTest
|
|
|
|
|
|
struct TestTryLock {
|
|
Mutex mu;
|
|
int a GUARDED_BY(mu);
|
|
bool cond;
|
|
|
|
void foo1() {
|
|
if (mu.TryLock()) {
|
|
a = 1;
|
|
mu.Unlock();
|
|
}
|
|
}
|
|
|
|
void foo2() {
|
|
if (!mu.TryLock()) return;
|
|
a = 2;
|
|
mu.Unlock();
|
|
}
|
|
|
|
void foo3() {
|
|
bool b = mu.TryLock();
|
|
if (b) {
|
|
a = 3;
|
|
mu.Unlock();
|
|
}
|
|
}
|
|
|
|
void foo4() {
|
|
bool b = mu.TryLock();
|
|
if (!b) return;
|
|
a = 4;
|
|
mu.Unlock();
|
|
}
|
|
|
|
void foo5() {
|
|
while (mu.TryLock()) {
|
|
a = a + 1;
|
|
mu.Unlock();
|
|
}
|
|
}
|
|
|
|
void foo6() {
|
|
bool b = mu.TryLock();
|
|
b = !b;
|
|
if (b) return;
|
|
a = 6;
|
|
mu.Unlock();
|
|
}
|
|
|
|
void foo7() {
|
|
bool b1 = mu.TryLock();
|
|
bool b2 = !b1;
|
|
bool b3 = !b2;
|
|
if (b3) {
|
|
a = 7;
|
|
mu.Unlock();
|
|
}
|
|
}
|
|
|
|
// Test use-def chains: join points
|
|
void foo8() {
|
|
bool b = mu.TryLock();
|
|
bool b2 = b;
|
|
if (cond)
|
|
b = true;
|
|
if (b) { // b should be unknown at this point, becuase of the join point
|
|
a = 8; // expected-warning {{writing variable 'a' requires locking 'mu' exclusively}}
|
|
}
|
|
if (b2) { // b2 should be known at this point.
|
|
a = 8;
|
|
mu.Unlock();
|
|
}
|
|
}
|
|
|
|
// Test use-def-chains: back edges
|
|
void foo9() {
|
|
bool b = mu.TryLock();
|
|
|
|
for (int i = 0; i < 10; ++i);
|
|
|
|
if (b) { // b is still known, because the loop doesn't alter it
|
|
a = 9;
|
|
mu.Unlock();
|
|
}
|
|
}
|
|
|
|
// Test use-def chains: back edges
|
|
void foo10() {
|
|
bool b = mu.TryLock();
|
|
|
|
while (cond) {
|
|
if (b) { // b should be uknown at this point b/c of the loop
|
|
a = 10; // expected-warning {{writing variable 'a' requires locking 'mu' exclusively}}
|
|
}
|
|
b = !b;
|
|
}
|
|
}
|
|
}; // end TestTrylock
|
|
|
|
|
|
namespace TestTemplateAttributeInstantiation {
|
|
|
|
class Foo1 {
|
|
public:
|
|
Mutex mu_;
|
|
int a GUARDED_BY(mu_);
|
|
};
|
|
|
|
class Foo2 {
|
|
public:
|
|
int a GUARDED_BY(mu_);
|
|
Mutex mu_;
|
|
};
|
|
|
|
|
|
class Bar {
|
|
public:
|
|
// Test non-dependent expressions in attributes on template functions
|
|
template <class T>
|
|
void barND(Foo1 *foo, T *fooT) EXCLUSIVE_LOCKS_REQUIRED(foo->mu_) {
|
|
foo->a = 0;
|
|
}
|
|
|
|
// Test dependent expressions in attributes on template functions
|
|
template <class T>
|
|
void barD(Foo1 *foo, T *fooT) EXCLUSIVE_LOCKS_REQUIRED(fooT->mu_) {
|
|
fooT->a = 0;
|
|
}
|
|
};
|
|
|
|
|
|
template <class T>
|
|
class BarT {
|
|
public:
|
|
Foo1 fooBase;
|
|
T fooBaseT;
|
|
|
|
// Test non-dependent expression in ordinary method on template class
|
|
void barND() EXCLUSIVE_LOCKS_REQUIRED(fooBase.mu_) {
|
|
fooBase.a = 0;
|
|
}
|
|
|
|
// Test dependent expressions in ordinary methods on template class
|
|
void barD() EXCLUSIVE_LOCKS_REQUIRED(fooBaseT.mu_) {
|
|
fooBaseT.a = 0;
|
|
}
|
|
|
|
// Test dependent expressions in template method in template class
|
|
template <class T2>
|
|
void barTD(T2 *fooT) EXCLUSIVE_LOCKS_REQUIRED(fooBaseT.mu_, fooT->mu_) {
|
|
fooBaseT.a = 0;
|
|
fooT->a = 0;
|
|
}
|
|
};
|
|
|
|
template <class T>
|
|
class Cell {
|
|
public:
|
|
Mutex mu_;
|
|
// Test dependent guarded_by
|
|
T data GUARDED_BY(mu_);
|
|
|
|
void fooEx() EXCLUSIVE_LOCKS_REQUIRED(mu_) {
|
|
data = 0;
|
|
}
|
|
|
|
void foo() {
|
|
mu_.Lock();
|
|
data = 0;
|
|
mu_.Unlock();
|
|
}
|
|
};
|
|
|
|
void test() {
|
|
Bar b;
|
|
BarT<Foo2> bt;
|
|
Foo1 f1;
|
|
Foo2 f2;
|
|
|
|
f1.mu_.Lock();
|
|
f2.mu_.Lock();
|
|
bt.fooBase.mu_.Lock();
|
|
bt.fooBaseT.mu_.Lock();
|
|
|
|
b.barND(&f1, &f2);
|
|
b.barD(&f1, &f2);
|
|
bt.barND();
|
|
bt.barD();
|
|
bt.barTD(&f2);
|
|
|
|
f1.mu_.Unlock();
|
|
bt.barTD(&f1); // \
|
|
// expected-warning {{calling function 'barTD' requires exclusive lock on 'mu_'}}
|
|
|
|
bt.fooBase.mu_.Unlock();
|
|
bt.fooBaseT.mu_.Unlock();
|
|
f2.mu_.Unlock();
|
|
|
|
Cell<int> cell;
|
|
cell.data = 0; // \
|
|
// expected-warning {{writing variable 'data' requires locking 'mu_' exclusively}}
|
|
cell.foo();
|
|
cell.mu_.Lock();
|
|
cell.fooEx();
|
|
cell.mu_.Unlock();
|
|
}
|
|
|
|
|
|
template <class T>
|
|
class CellDelayed {
|
|
public:
|
|
// Test dependent guarded_by
|
|
T data GUARDED_BY(mu_);
|
|
static T static_data GUARDED_BY(static_mu_);
|
|
|
|
void fooEx(CellDelayed<T> *other) EXCLUSIVE_LOCKS_REQUIRED(mu_, other->mu_) {
|
|
this->data = other->data;
|
|
}
|
|
|
|
template <class T2>
|
|
void fooExT(CellDelayed<T2> *otherT) EXCLUSIVE_LOCKS_REQUIRED(mu_, otherT->mu_) {
|
|
this->data = otherT->data;
|
|
}
|
|
|
|
void foo() {
|
|
mu_.Lock();
|
|
data = 0;
|
|
mu_.Unlock();
|
|
}
|
|
|
|
Mutex mu_;
|
|
static Mutex static_mu_;
|
|
};
|
|
|
|
void testDelayed() {
|
|
CellDelayed<int> celld;
|
|
CellDelayed<int> celld2;
|
|
celld.foo();
|
|
celld.mu_.Lock();
|
|
celld2.mu_.Lock();
|
|
|
|
celld.fooEx(&celld2);
|
|
celld.fooExT(&celld2);
|
|
|
|
celld2.mu_.Unlock();
|
|
celld.mu_.Unlock();
|
|
}
|
|
|
|
}; // end namespace TestTemplateAttributeInstantiation
|
|
|
|
|
|
namespace FunctionDeclDefTest {
|
|
|
|
class Foo {
|
|
public:
|
|
Mutex mu_;
|
|
int a GUARDED_BY(mu_);
|
|
|
|
virtual void foo1(Foo *f_declared) EXCLUSIVE_LOCKS_REQUIRED(f_declared->mu_);
|
|
};
|
|
|
|
// EXCLUSIVE_LOCKS_REQUIRED should be applied, and rewritten to f_defined->mu_
|
|
void Foo::foo1(Foo *f_defined) {
|
|
f_defined->a = 0;
|
|
};
|
|
|
|
void test() {
|
|
Foo myfoo;
|
|
myfoo.foo1(&myfoo); // \
|
|
// expected-warning {{calling function 'foo1' requires exclusive lock on 'mu_'}}
|
|
myfoo.mu_.Lock();
|
|
myfoo.foo1(&myfoo);
|
|
myfoo.mu_.Unlock();
|
|
}
|
|
|
|
};
|
|
|
|
namespace GoingNative {
|
|
|
|
struct __attribute__((lockable)) mutex {
|
|
void lock() __attribute__((exclusive_lock_function));
|
|
void unlock() __attribute__((unlock_function));
|
|
// ...
|
|
};
|
|
bool foo();
|
|
bool bar();
|
|
mutex m;
|
|
void test() {
|
|
m.lock();
|
|
while (foo()) {
|
|
m.unlock();
|
|
// ...
|
|
if (bar()) {
|
|
// ...
|
|
if (foo())
|
|
continue; // expected-warning {{expecting mutex 'm' to be locked at start of each loop}}
|
|
//...
|
|
}
|
|
// ...
|
|
m.lock(); // expected-note {{mutex acquired here}}
|
|
}
|
|
m.unlock();
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
namespace FunctionDefinitionTest {
|
|
|
|
class Foo {
|
|
public:
|
|
void foo1();
|
|
void foo2();
|
|
void foo3(Foo *other);
|
|
|
|
template<class T>
|
|
void fooT1(const T& dummy1);
|
|
|
|
template<class T>
|
|
void fooT2(const T& dummy2) EXCLUSIVE_LOCKS_REQUIRED(mu_);
|
|
|
|
Mutex mu_;
|
|
int a GUARDED_BY(mu_);
|
|
};
|
|
|
|
template<class T>
|
|
class FooT {
|
|
public:
|
|
void foo();
|
|
|
|
Mutex mu_;
|
|
T a GUARDED_BY(mu_);
|
|
};
|
|
|
|
|
|
void Foo::foo1() NO_THREAD_SAFETY_ANALYSIS {
|
|
a = 1;
|
|
}
|
|
|
|
void Foo::foo2() EXCLUSIVE_LOCKS_REQUIRED(mu_) {
|
|
a = 2;
|
|
}
|
|
|
|
void Foo::foo3(Foo *other) EXCLUSIVE_LOCKS_REQUIRED(other->mu_) {
|
|
other->a = 3;
|
|
}
|
|
|
|
template<class T>
|
|
void Foo::fooT1(const T& dummy1) EXCLUSIVE_LOCKS_REQUIRED(mu_) {
|
|
a = dummy1;
|
|
}
|
|
|
|
/* TODO -- uncomment with template instantiation of attributes.
|
|
template<class T>
|
|
void Foo::fooT2(const T& dummy2) {
|
|
a = dummy2;
|
|
}
|
|
*/
|
|
|
|
void fooF1(Foo *f) EXCLUSIVE_LOCKS_REQUIRED(f->mu_) {
|
|
f->a = 1;
|
|
}
|
|
|
|
void fooF2(Foo *f);
|
|
void fooF2(Foo *f) EXCLUSIVE_LOCKS_REQUIRED(f->mu_) {
|
|
f->a = 2;
|
|
}
|
|
|
|
void fooF3(Foo *f) EXCLUSIVE_LOCKS_REQUIRED(f->mu_);
|
|
void fooF3(Foo *f) {
|
|
f->a = 3;
|
|
}
|
|
|
|
template<class T>
|
|
void FooT<T>::foo() EXCLUSIVE_LOCKS_REQUIRED(mu_) {
|
|
a = 0;
|
|
}
|
|
|
|
void test() {
|
|
int dummy = 0;
|
|
Foo myFoo;
|
|
|
|
myFoo.foo2(); // \
|
|
// expected-warning {{calling function 'foo2' requires exclusive lock on 'mu_'}}
|
|
myFoo.foo3(&myFoo); // \
|
|
// expected-warning {{calling function 'foo3' requires exclusive lock on 'mu_'}}
|
|
myFoo.fooT1(dummy); // \
|
|
// expected-warning {{calling function 'fooT1' requires exclusive lock on 'mu_'}}
|
|
|
|
// FIXME: uncomment with template instantiation of attributes patch
|
|
// myFoo.fooT2(dummy); // expected warning
|
|
|
|
fooF1(&myFoo); // \
|
|
// expected-warning {{calling function 'fooF1' requires exclusive lock on 'mu_'}}
|
|
fooF2(&myFoo); // \
|
|
// expected-warning {{calling function 'fooF2' requires exclusive lock on 'mu_'}}
|
|
fooF3(&myFoo); // \
|
|
// expected-warning {{calling function 'fooF3' requires exclusive lock on 'mu_'}}
|
|
|
|
myFoo.mu_.Lock();
|
|
myFoo.foo2();
|
|
myFoo.foo3(&myFoo);
|
|
myFoo.fooT1(dummy);
|
|
|
|
// FIXME: uncomment with template instantiation of attributes patch
|
|
// myFoo.fooT2(dummy);
|
|
|
|
fooF1(&myFoo);
|
|
fooF2(&myFoo);
|
|
fooF3(&myFoo);
|
|
myFoo.mu_.Unlock();
|
|
|
|
FooT<int> myFooT;
|
|
myFooT.foo(); // \
|
|
// expected-warning {{calling function 'foo' requires exclusive lock on 'mu_'}}
|
|
}
|
|
|
|
} // end namespace FunctionDefinitionTest
|
|
|
|
|
|
namespace SelfLockingTest {
|
|
|
|
class LOCKABLE MyLock {
|
|
public:
|
|
int foo GUARDED_BY(this);
|
|
|
|
void lock() EXCLUSIVE_LOCK_FUNCTION();
|
|
void unlock() UNLOCK_FUNCTION();
|
|
|
|
void doSomething() {
|
|
this->lock(); // allow 'this' as a lock expression
|
|
foo = 0;
|
|
doSomethingElse();
|
|
this->unlock();
|
|
}
|
|
|
|
void doSomethingElse() EXCLUSIVE_LOCKS_REQUIRED(this) {
|
|
foo = 1;
|
|
};
|
|
|
|
void test() {
|
|
foo = 2; // \
|
|
// expected-warning {{writing variable 'foo' requires locking 'this' exclusively}}
|
|
}
|
|
};
|
|
|
|
|
|
class LOCKABLE MyLock2 {
|
|
public:
|
|
Mutex mu_;
|
|
int foo GUARDED_BY(this);
|
|
|
|
// don't check inside lock and unlock functions
|
|
void lock() EXCLUSIVE_LOCK_FUNCTION() { mu_.Lock(); }
|
|
void unlock() UNLOCK_FUNCTION() { mu_.Unlock(); }
|
|
|
|
// don't check inside constructors and destructors
|
|
MyLock2() { foo = 1; }
|
|
~MyLock2() { foo = 0; }
|
|
};
|
|
|
|
|
|
} // end namespace SelfLockingTest
|
|
|
|
|
|
namespace InvalidNonstatic {
|
|
|
|
// Forward decl here causes bogus "invalid use of non-static data member"
|
|
// on reference to mutex_ in guarded_by attribute.
|
|
class Foo;
|
|
|
|
class Foo {
|
|
Mutex* mutex_;
|
|
|
|
int foo __attribute__((guarded_by(mutex_)));
|
|
};
|
|
|
|
} // end namespace InvalidNonStatic
|
|
|
|
|
|
namespace NoReturnTest {
|
|
|
|
bool condition();
|
|
void fatal() __attribute__((noreturn));
|
|
|
|
Mutex mu_;
|
|
|
|
void test1() {
|
|
MutexLock lock(&mu_);
|
|
if (condition()) {
|
|
fatal();
|
|
return;
|
|
}
|
|
}
|
|
|
|
} // end namespace NoReturnTest
|
|
|
|
|
|
namespace TestMultiDecl {
|
|
|
|
class Foo {
|
|
public:
|
|
int GUARDED_BY(mu_) a;
|
|
int GUARDED_BY(mu_) b, c;
|
|
|
|
void foo() {
|
|
a = 0; // \
|
|
// expected-warning {{writing variable 'a' requires locking 'mu_' exclusively}}
|
|
b = 0; // \
|
|
// expected-warning {{writing variable 'b' requires locking 'mu_' exclusively}}
|
|
c = 0; // \
|
|
// expected-warning {{writing variable 'c' requires locking 'mu_' exclusively}}
|
|
}
|
|
|
|
private:
|
|
Mutex mu_;
|
|
};
|
|
|
|
} // end namespace TestMultiDecl
|
|
|
|
|
|
namespace WarnNoDecl {
|
|
|
|
class Foo {
|
|
void foo(int a); __attribute__(( // \
|
|
// expected-warning {{declaration does not declare anything}}
|
|
exclusive_locks_required(a))); // \
|
|
// expected-warning {{attribute exclusive_locks_required ignored}}
|
|
};
|
|
|
|
} // end namespace WarnNoDecl
|
|
|
|
|
|
|
|
namespace MoreLockExpressions {
|
|
|
|
class Foo {
|
|
public:
|
|
Mutex mu_;
|
|
int a GUARDED_BY(mu_);
|
|
};
|
|
|
|
class Bar {
|
|
public:
|
|
int b;
|
|
Foo* f;
|
|
|
|
Foo& getFoo() { return *f; }
|
|
Foo& getFoo2(int c) { return *f; }
|
|
Foo& getFoo3(int c, int d) { return *f; }
|
|
|
|
Foo& getFooey() { return *f; }
|
|
};
|
|
|
|
Foo& getBarFoo(Bar &bar, int c) { return bar.getFoo2(c); }
|
|
|
|
void test() {
|
|
Foo foo;
|
|
Foo *fooArray;
|
|
Bar bar;
|
|
int a;
|
|
int b;
|
|
int c;
|
|
|
|
bar.getFoo().mu_.Lock();
|
|
bar.getFoo().a = 0;
|
|
bar.getFoo().mu_.Unlock();
|
|
|
|
(bar.getFoo().mu_).Lock(); // test parenthesis
|
|
bar.getFoo().a = 0;
|
|
(bar.getFoo().mu_).Unlock();
|
|
|
|
bar.getFoo2(a).mu_.Lock();
|
|
bar.getFoo2(a).a = 0;
|
|
bar.getFoo2(a).mu_.Unlock();
|
|
|
|
bar.getFoo3(a, b).mu_.Lock();
|
|
bar.getFoo3(a, b).a = 0;
|
|
bar.getFoo3(a, b).mu_.Unlock();
|
|
|
|
getBarFoo(bar, a).mu_.Lock();
|
|
getBarFoo(bar, a).a = 0;
|
|
getBarFoo(bar, a).mu_.Unlock();
|
|
|
|
bar.getFoo2(10).mu_.Lock();
|
|
bar.getFoo2(10).a = 0;
|
|
bar.getFoo2(10).mu_.Unlock();
|
|
|
|
bar.getFoo2(a + 1).mu_.Lock();
|
|
bar.getFoo2(a + 1).a = 0;
|
|
bar.getFoo2(a + 1).mu_.Unlock();
|
|
|
|
(a > 0 ? fooArray[1] : fooArray[b]).mu_.Lock();
|
|
(a > 0 ? fooArray[1] : fooArray[b]).a = 0;
|
|
(a > 0 ? fooArray[1] : fooArray[b]).mu_.Unlock();
|
|
|
|
bar.getFoo().mu_.Lock();
|
|
bar.getFooey().a = 0; // \
|
|
// expected-warning {{writing variable 'a' requires locking 'mu_' exclusively}}
|
|
bar.getFoo().mu_.Unlock();
|
|
|
|
bar.getFoo2(a).mu_.Lock();
|
|
bar.getFoo2(b).a = 0; // \
|
|
// expected-warning {{writing variable 'a' requires locking 'mu_' exclusively}}
|
|
bar.getFoo2(a).mu_.Unlock();
|
|
|
|
bar.getFoo3(a, b).mu_.Lock();
|
|
bar.getFoo3(a, c).a = 0; // \
|
|
// expected-warning {{writing variable 'a' requires locking 'mu_' exclusively}}
|
|
bar.getFoo3(a, b).mu_.Unlock();
|
|
|
|
getBarFoo(bar, a).mu_.Lock();
|
|
getBarFoo(bar, b).a = 0; // \
|
|
// expected-warning {{writing variable 'a' requires locking 'mu_' exclusively}}
|
|
getBarFoo(bar, a).mu_.Unlock();
|
|
|
|
(a > 0 ? fooArray[1] : fooArray[b]).mu_.Lock();
|
|
(a > 0 ? fooArray[b] : fooArray[c]).a = 0; // \
|
|
// expected-warning {{writing variable 'a' requires locking 'mu_' exclusively}}
|
|
(a > 0 ? fooArray[1] : fooArray[b]).mu_.Unlock();
|
|
}
|
|
|
|
|
|
} // end namespace MoreLockExpressions
|
|
|
|
|
|
namespace TrylockJoinPoint {
|
|
|
|
class Foo {
|
|
Mutex mu;
|
|
bool c;
|
|
|
|
void foo() {
|
|
if (c) {
|
|
if (!mu.TryLock())
|
|
return;
|
|
} else {
|
|
mu.Lock();
|
|
}
|
|
mu.Unlock();
|
|
}
|
|
};
|
|
|
|
} // end namespace TrylockJoinPoint
|
|
|
|
|