maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

Thread safety: small formatting change in test comments 

llvm-svn: 139306
This commit is contained in:
Caitlin Sadowski 2011-09-08 18:07:26 +00:00
parent fb113a0051
commit bc1f11162a
2 changed files with 225 additions and 226 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

89
clang/test/SemaCXX/warn-thread-safety-analysis.cpp
View File

@ -39,7 +39,6 @@ void sls_fun_0() {
sls_mw.mu.Unlock(); sls_mw.mu.Unlock();
} }
void sls_fun_2() { void sls_fun_2() {
sls_mu.Lock(); sls_mu.Lock();
int x = sls_guard_var; int x = sls_guard_var;
@ -124,33 +123,33 @@ void sls_fun_good_7() {
void sls_fun_bad_1() { void sls_fun_bad_1() {
sls_mu.Unlock(); // \ sls_mu.Unlock(); // \
expected-warning {{unlocking 'sls_mu' that was not acquired}} // expected-warning{{unlocking 'sls_mu' that was not acquired}}
} }
void sls_fun_bad_2() { void sls_fun_bad_2() {
sls_mu.Lock(); sls_mu.Lock();
sls_mu.Lock(); // \ sls_mu.Lock(); // \
expected-warning {{locking 'sls_mu' that is already acquired}} // expected-warning{{locking 'sls_mu' that is already acquired}}
sls_mu.Unlock(); sls_mu.Unlock();
} }
void sls_fun_bad_3() { void sls_fun_bad_3() {
sls_mu.Lock(); // \ sls_mu.Lock(); // \
expected-warning {{lock 'sls_mu' is not released at the end of function 'sls_fun_bad_3'}} // expected-warning{{lock 'sls_mu' is not released at the end of function 'sls_fun_bad_3'}}
} }
void sls_fun_bad_4() { void sls_fun_bad_4() {
if (getBool()) if (getBool())
sls_mu.Lock(); // \ sls_mu.Lock(); // \
expected-warning {{lock 'sls_mu' is not released at the end of its scope}} // expected-warning{{lock 'sls_mu' is not released at the end of its scope}}
else else
sls_mu2.Lock(); // \ sls_mu2.Lock(); // \
expected-warning {{lock 'sls_mu2' is not released at the end of its scope}} // expected-warning{{lock 'sls_mu2' is not released at the end of its scope}}
} }
void sls_fun_bad_5() { void sls_fun_bad_5() {
sls_mu.Lock(); // \ sls_mu.Lock(); // \
expected-warning {{lock 'sls_mu' is not released at the end of its scope}} // expected-warning{{lock 'sls_mu' is not released at the end of its scope}}
if (getBool()) if (getBool())
sls_mu.Unlock(); sls_mu.Unlock();
} }
@ -158,7 +157,7 @@ void sls_fun_bad_5() {
void sls_fun_bad_6() { void sls_fun_bad_6() {
if (getBool()) { if (getBool()) {
sls_mu.Lock(); // \ sls_mu.Lock(); // \
expected-warning {{lock 'sls_mu' is not released at the end of its scope}} // expected-warning{{lock 'sls_mu' is not released at the end of its scope}}
} else { } else {
if (getBool()) { if (getBool()) {
getBool(); // EMPTY getBool(); // EMPTY
@ -167,13 +166,13 @@ void sls_fun_bad_6() {
} }
} }
sls_mu.Unlock(); // \ sls_mu.Unlock(); // \
expected-warning {{unlocking 'sls_mu' that was not acquired}} // expected-warning{{unlocking 'sls_mu' that was not acquired}}
} }
void sls_fun_bad_7() { void sls_fun_bad_7() {
sls_mu.Lock(); sls_mu.Lock();
while (getBool()) { // \ while (getBool()) { // \
expected-warning {{expecting lock 'sls_mu' to be held at start of each loop}} // expected-warning{{expecting lock 'sls_mu' to be held at start of each loop}}
sls_mu.Unlock(); sls_mu.Unlock();
if (getBool()) { if (getBool()) {
if (getBool()) { if (getBool()) {
@ -181,7 +180,7 @@ void sls_fun_bad_7() {
} }
} }
sls_mu.Lock(); // \ sls_mu.Lock(); // \
expected-warning {{lock 'sls_mu' is not released at the end of its scope}} // expected-warning{{lock 'sls_mu' is not released at the end of its scope}}
} }
sls_mu.Unlock(); sls_mu.Unlock();
} }
@ -190,23 +189,23 @@ void sls_fun_bad_8() {
sls_mu.Lock(); sls_mu.Lock();
do { do {
sls_mu.Unlock(); // \ sls_mu.Unlock(); // \
expected-warning {{expecting lock 'sls_mu' to be held at start of each loop}} // expected-warning{{expecting lock 'sls_mu' to be held at start of each loop}}
} while (getBool()); } while (getBool());
} }
void sls_fun_bad_9() { void sls_fun_bad_9() {
do { do {
sls_mu.Lock(); // \ sls_mu.Lock(); // \
expected-warning {{lock 'sls_mu' is not released at the end of its scope}} // expected-warning{{lock 'sls_mu' is not released at the end of its scope}}
} while (getBool()); } while (getBool());
sls_mu.Unlock(); sls_mu.Unlock();
} }
void sls_fun_bad_10() { void sls_fun_bad_10() {
sls_mu.Lock(); // \ sls_mu.Lock(); // \
expected-warning {{lock 'sls_mu' is not released at the end of function 'sls_fun_bad_10'}} // expected-warning{{lock 'sls_mu' is not released at the end of function 'sls_fun_bad_10'}}
while(getBool()) { // \ while(getBool()) { // \
expected-warning {{expecting lock 'sls_mu' to be held at start of each loop}} // expected-warning{{expecting lock 'sls_mu' to be held at start of each loop}}
sls_mu.Unlock(); sls_mu.Unlock();
} }
} }
@ -214,10 +213,10 @@ void sls_fun_bad_10() {
void sls_fun_bad_11() { void sls_fun_bad_11() {
while (getBool()) { while (getBool()) {
sls_mu.Lock(); // \ sls_mu.Lock(); // \
expected-warning {{lock 'sls_mu' is not released at the end of its scope}} // expected-warning{{lock 'sls_mu' is not released at the end of its scope}}
} }
sls_mu.Unlock(); // \ sls_mu.Unlock(); // \
expected-warning {{unlocking 'sls_mu' that was not acquired}} // expected-warning{{unlocking 'sls_mu' that was not acquired}}
} }
@ -251,19 +250,19 @@ void aa_fun_2() {
void aa_fun_bad_1() { void aa_fun_bad_1() {
glock.globalUnlock(); // \ glock.globalUnlock(); // \
expected-warning {{unlocking 'aa_mu' that was not acquired}} // expected-warning{{unlocking 'aa_mu' that was not acquired}}
} }
void aa_fun_bad_2() { void aa_fun_bad_2() {
glock.globalLock(); glock.globalLock();
glock.globalLock(); // \ glock.globalLock(); // \
expected-warning {{locking 'aa_mu' that is already acquired}} // expected-warning{{locking 'aa_mu' that is already acquired}}
glock.globalUnlock(); glock.globalUnlock();
} }
void aa_fun_bad_3() { void aa_fun_bad_3() {
glock.globalLock(); // \ glock.globalLock(); // \
expected-warning {{lock 'aa_mu' is not released at the end of function 'aa_fun_bad_3'}} // expected-warning{{lock 'aa_mu' is not released at the end of function 'aa_fun_bad_3'}}
} }
//--------------------------------------------------// //--------------------------------------------------//
@ -276,19 +275,19 @@ Mutex wmu;
class WeirdMethods { class WeirdMethods {
WeirdMethods() { WeirdMethods() {
wmu.Lock(); // \ wmu.Lock(); // \
expected-warning {{lock 'wmu' is not released at the end of function 'WeirdMethods'}} // expected-warning {{lock 'wmu' is not released at the end of function 'WeirdMethods'}}
} }
~WeirdMethods() { ~WeirdMethods() {
wmu.Lock(); // \ wmu.Lock(); // \
expected-warning {{lock 'wmu' is not released at the end of function '~WeirdMethods'}} // expected-warning {{lock 'wmu' is not released at the end of function '~WeirdMethods'}}
} }
void operator++() { void operator++() {
wmu.Lock(); // \ wmu.Lock(); // \
expected-warning {{lock 'wmu' is not released at the end of function 'operator++'}} // expected-warning {{lock 'wmu' is not released at the end of function 'operator++'}}
} }
operator int*() { operator int*() {
wmu.Lock(); // \ wmu.Lock(); // \
expected-warning {{lock 'wmu' is not released at the end of function 'operator int *'}} // expected-warning {{lock 'wmu' is not released at the end of function 'operator int *'}}
return 0; return 0;
} }
}; };
@ -307,13 +306,13 @@ class PGBFoo {
__attribute__((pt_guarded_by(sls_mu))); __attribute__((pt_guarded_by(sls_mu)));
void testFoo() { void testFoo() {
pgb_field = &x; // \ pgb_field = &x; // \
expected-warning {{accessing variable 'pgb_field' requires lock 'sls_mu2'}} // expected-warning{{accessing variable 'pgb_field' requires lock 'sls_mu2'}}
*pgb_field = x; // expected-warning {{accessing variable 'pgb_field' requires lock 'sls_mu2'}} \ *pgb_field = x; // expected-warning {{accessing variable 'pgb_field' requires lock 'sls_mu2'}} \
expected-warning {{accessing the value pointed to by 'pgb_field' requires lock 'sls_mu'}} // expected-warning {{accessing the value pointed to by 'pgb_field' requires lock 'sls_mu'}}
x = *pgb_field; // expected-warning {{accessing variable 'pgb_field' requires lock 'sls_mu2'}} \ x = *pgb_field; // expected-warning {{accessing variable 'pgb_field' requires lock 'sls_mu2'}} \
expected-warning {{accessing the value pointed to by 'pgb_field' requires lock 'sls_mu'}} // expected-warning {{accessing the value pointed to by 'pgb_field' requires lock 'sls_mu'}}
(*pgb_field)++; // expected-warning {{accessing variable 'pgb_field' requires lock 'sls_mu2'}} \ (*pgb_field)++; // expected-warning {{accessing variable 'pgb_field' requires lock 'sls_mu2'}} \
expected-warning {{accessing the value pointed to by 'pgb_field' requires lock 'sls_mu'}} // expected-warning {{accessing the value pointed to by 'pgb_field' requires lock 'sls_mu'}}
} }
}; };
@ -323,7 +322,7 @@ class GBFoo {
void testFoo() { void testFoo() {
gb_field = 0; // \ gb_field = 0; // \
expected-warning {{accessing variable 'gb_field' requires lock 'sls_mu'}} // expected-warning{{accessing variable 'gb_field' requires lock 'sls_mu'}}
} }
}; };
@ -352,59 +351,59 @@ void gb_fun_3() {
void gb_bad_0() { void gb_bad_0() {
sls_guard_var = 1; // \ sls_guard_var = 1; // \
expected-warning {{accessing variable 'sls_guard_var' requires some lock}} // expected-warning{{accessing variable 'sls_guard_var' requires some lock}}
} }
void gb_bad_1() { void gb_bad_1() {
int x = sls_guard_var; // \ int x = sls_guard_var; // \
expected-warning {{accessing variable 'sls_guard_var' requires some lock}} // expected-warning{{accessing variable 'sls_guard_var' requires some lock}}
} }
void gb_bad_2() { void gb_bad_2() {
sls_guardby_var = 1; // \ sls_guardby_var = 1; // \
expected-warning {{accessing variable 'sls_guardby_var' requires lock 'sls_mu'}} // expected-warning{{accessing variable 'sls_guardby_var' requires lock 'sls_mu'}}
} }
void gb_bad_3() { void gb_bad_3() {
int x = sls_guardby_var; // \ int x = sls_guardby_var; // \
expected-warning {{accessing variable 'sls_guardby_var' requires lock 'sls_mu'}} // expected-warning{{accessing variable 'sls_guardby_var' requires lock 'sls_mu'}}
} }
void gb_bad_4() { void gb_bad_4() {
*pgb_gvar = 1; // \ *pgb_gvar = 1; // \
expected-warning {{accessing the value pointed to by 'pgb_gvar' requires some lock}} // expected-warning {{accessing the value pointed to by 'pgb_gvar' requires some lock}}
} }
void gb_bad_5() { void gb_bad_5() {
int x = *pgb_gvar; // \ int x = *pgb_gvar; // \
expected-warning {{accessing the value pointed to by 'pgb_gvar' requires some lock}} // expected-warning {{accessing the value pointed to by 'pgb_gvar' requires some lock}}
} }
void gb_bad_6() { void gb_bad_6() {
*pgb_var = 1; // \ *pgb_var = 1; // \
expected-warning {{accessing the value pointed to by 'pgb_var' requires lock 'sls_mu'}} // expected-warning {{accessing the value pointed to by 'pgb_var' requires lock 'sls_mu'}}
} }
void gb_bad_7() { void gb_bad_7() {
int x = *pgb_var; // \ int x = *pgb_var; // \
expected-warning {{accessing the value pointed to by 'pgb_var' requires lock 'sls_mu'}} // expected-warning {{accessing the value pointed to by 'pgb_var' requires lock 'sls_mu'}}
} }
void gb_bad_8() { void gb_bad_8() {
GBFoo G; GBFoo G;
G.gb_field = 0; // \ G.gb_field = 0; // \
expected-warning {{accessing variable 'gb_field' requires lock 'sls_mu'}} // expected-warning{{accessing variable 'gb_field' requires lock 'sls_mu'}}
} }
void gb_bad_9() { void gb_bad_9() {
sls_guard_var++; // \ sls_guard_var++; // \
expected-warning {{accessing variable 'sls_guard_var' requires some lock}} // expected-warning{{accessing variable 'sls_guard_var' requires some lock}}
sls_guard_var--; // \ sls_guard_var--; // \
expected-warning {{accessing variable 'sls_guard_var' requires some lock}} // expected-warning{{accessing variable 'sls_guard_var' requires some lock}}
++sls_guard_var; // \ ++sls_guard_var; // \
expected-warning {{accessing variable 'sls_guard_var' requires some lock}} // expected-warning{{accessing variable 'sls_guard_var' requires some lock}}
--sls_guard_var; // \ --sls_guard_var; // \
expected-warning {{accessing variable 'sls_guard_var' requires some lock}} // expected-warning{{accessing variable 'sls_guard_var' requires some lock}}
} }
//-----------------------------------------------// //-----------------------------------------------//
@ -420,11 +419,11 @@ public:
void test() { void test() {
a = 0; // \ a = 0; // \
expected-warning {{accessing variable 'a' requires lock 'mu'}} // expected-warning{{accessing variable 'a' requires lock 'mu'}}
b = a; // \ b = a; // \
expected-warning {{accessing variable 'a' requires lock 'mu'}} // expected-warning {{accessing variable 'a' requires lock 'mu'}}
c = 0; // \ c = 0; // \
expected-warning {{accessing variable 'c' requires lock 'mu'}} // expected-warning {{accessing variable 'c' requires lock 'mu'}}
} }
int c __attribute__((guarded_by(mu))); int c __attribute__((guarded_by(mu)));

362
clang/test/SemaCXX/warn-thread-safety-parsing.cpp
View File

@ -76,32 +76,32 @@ class Bar {
void noanal_fun() __attribute__((no_thread_safety_analysis)); void noanal_fun() __attribute__((no_thread_safety_analysis));
void noanal_fun_args() __attribute__((no_thread_safety_analysis(1))); // \ void noanal_fun_args() __attribute__((no_thread_safety_analysis(1))); // \
expected-error {{attribute takes no arguments}} // expected-error {{attribute takes no arguments}}
int noanal_testfn(int y) __attribute__((no_thread_safety_analysis)); int noanal_testfn(int y) __attribute__((no_thread_safety_analysis));
int noanal_testfn(int y) { int noanal_testfn(int y) {
int x __attribute__((no_thread_safety_analysis)) = y; // \ int x __attribute__((no_thread_safety_analysis)) = y; // \
expected-warning {{'no_thread_safety_analysis' attribute only applies to functions and methods}} // expected-warning {{'no_thread_safety_analysis' attribute only applies to functions and methods}}
return x; return x;
}; };
int noanal_test_var __attribute__((no_thread_safety_analysis)); // \ int noanal_test_var __attribute__((no_thread_safety_analysis)); // \
expected-warning {{'no_thread_safety_analysis' attribute only applies to functions and methods}} // expected-warning {{'no_thread_safety_analysis' attribute only applies to functions and methods}}
class NoanalFoo { class NoanalFoo {
private: private:
int test_field __attribute__((no_thread_safety_analysis)); // \ int test_field __attribute__((no_thread_safety_analysis)); // \
expected-warning {{'no_thread_safety_analysis' attribute only applies to functions and methods}} // expected-warning {{'no_thread_safety_analysis' attribute only applies to functions and methods}}
void test_method() __attribute__((no_thread_safety_analysis)); void test_method() __attribute__((no_thread_safety_analysis));
}; };
class __attribute__((no_thread_safety_analysis)) NoanalTestClass { // \ class __attribute__((no_thread_safety_analysis)) NoanalTestClass { // \
expected-warning {{'no_thread_safety_analysis' attribute only applies to functions and methods}} // expected-warning {{'no_thread_safety_analysis' attribute only applies to functions and methods}}
}; };
void noanal_fun_params(int lvar __attribute__((no_thread_safety_analysis))); // \ void noanal_fun_params(int lvar __attribute__((no_thread_safety_analysis))); // \
expected-warning {{'no_thread_safety_analysis' attribute only applies to functions and methods}} // expected-warning {{'no_thread_safety_analysis' attribute only applies to functions and methods}}
//-----------------------------------------// //-----------------------------------------//
@ -115,28 +115,28 @@ void noanal_fun_params(int lvar __attribute__((no_thread_safety_analysis))); //
int gv_var_noargs __attribute__((guarded_var)); int gv_var_noargs __attribute__((guarded_var));
int gv_var_args __attribute__((guarded_var(1))); // \ int gv_var_args __attribute__((guarded_var(1))); // \
expected-error {{attribute takes no arguments}} // expected-error {{attribute takes no arguments}}
class GVFoo { class GVFoo {
private: private:
int gv_field_noargs __attribute__((guarded_var)); int gv_field_noargs __attribute__((guarded_var));
int gv_field_args __attribute__((guarded_var(1))); // \ int gv_field_args __attribute__((guarded_var(1))); // \
expected-error {{attribute takes no arguments}} // expected-error {{attribute takes no arguments}}
}; };
class __attribute__((guarded_var)) GV { // \ class __attribute__((guarded_var)) GV { // \
expected-warning {{'guarded_var' attribute only applies to fields and global variables}} // expected-warning {{'guarded_var' attribute only applies to fields and global variables}}
}; };
void gv_function() __attribute__((guarded_var)); // \ void gv_function() __attribute__((guarded_var)); // \
expected-warning {{'guarded_var' attribute only applies to fields and global variables}} // expected-warning {{'guarded_var' attribute only applies to fields and global variables}}
void gv_function_params(int gv_lvar __attribute__((guarded_var))); // \ void gv_function_params(int gv_lvar __attribute__((guarded_var))); // \
expected-warning {{'guarded_var' attribute only applies to fields and global variables}} // expected-warning {{'guarded_var' attribute only applies to fields and global variables}}
int gv_testfn(int y){ int gv_testfn(int y){
int x __attribute__((guarded_var)) = y; // \ int x __attribute__((guarded_var)) = y; // \
expected-warning {{'guarded_var' attribute only applies to fields and global variables}} // expected-warning {{'guarded_var' attribute only applies to fields and global variables}}
return x; return x;
} }
@ -153,34 +153,34 @@ int gv_testfn(int y){
int *pgv_pt_var_noargs __attribute__((pt_guarded_var)); int *pgv_pt_var_noargs __attribute__((pt_guarded_var));
int pgv_var_noargs __attribute__((pt_guarded_var)); // \ int pgv_var_noargs __attribute__((pt_guarded_var)); // \
expected-warning {{'pt_guarded_var' only applies to pointer types; type here is 'int'}} // expected-warning {{'pt_guarded_var' only applies to pointer types; type here is 'int'}}
class PGVFoo { class PGVFoo {
private: private:
int *pt_field_noargs __attribute__((pt_guarded_var)); int *pt_field_noargs __attribute__((pt_guarded_var));
int field_noargs __attribute__((pt_guarded_var)); // \ int field_noargs __attribute__((pt_guarded_var)); // \
expected-warning {{'pt_guarded_var' only applies to pointer types; type here is 'int'}} // expected-warning {{'pt_guarded_var' only applies to pointer types; type here is 'int'}}
int *gv_field_args __attribute__((pt_guarded_var(1))); // \ int *gv_field_args __attribute__((pt_guarded_var(1))); // \
expected-error {{attribute takes no arguments}} // expected-error {{attribute takes no arguments}}
}; };
class __attribute__((pt_guarded_var)) PGV { // \ class __attribute__((pt_guarded_var)) PGV { // \
expected-warning {{'pt_guarded_var' attribute only applies to fields and global variables}} // expected-warning {{'pt_guarded_var' attribute only applies to fields and global variables}}
}; };
int *pgv_var_args __attribute__((pt_guarded_var(1))); // \ int *pgv_var_args __attribute__((pt_guarded_var(1))); // \
expected-error {{attribute takes no arguments}} // expected-error {{attribute takes no arguments}}
void pgv_function() __attribute__((pt_guarded_var)); // \ void pgv_function() __attribute__((pt_guarded_var)); // \
expected-warning {{'pt_guarded_var' attribute only applies to fields and global variables}} // expected-warning {{'pt_guarded_var' attribute only applies to fields and global variables}}
void pgv_function_params(int *gv_lvar __attribute__((pt_guarded_var))); // \ void pgv_function_params(int *gv_lvar __attribute__((pt_guarded_var))); // \
expected-warning {{'pt_guarded_var' attribute only applies to fields and global variables}} // expected-warning {{'pt_guarded_var' attribute only applies to fields and global variables}}
void pgv_testfn(int y){ void pgv_testfn(int y){
int *x __attribute__((pt_guarded_var)) = new int(0); // \ int *x __attribute__((pt_guarded_var)) = new int(0); // \
expected-warning {{'pt_guarded_var' attribute only applies to fields and global variables}} // expected-warning {{'pt_guarded_var' attribute only applies to fields and global variables}}
delete x; delete x;
} }
@ -198,32 +198,32 @@ class __attribute__((lockable)) LTestClass {
}; };
class __attribute__((lockable (1))) LTestClass_args { // \ class __attribute__((lockable (1))) LTestClass_args { // \
expected-error {{attribute takes no arguments}} // expected-error {{attribute takes no arguments}}
}; };
void l_test_function() __attribute__((lockable)); // \ void l_test_function() __attribute__((lockable)); // \
expected-warning {{'lockable' attribute only applies to classes}} // expected-warning {{'lockable' attribute only applies to classes}}
int l_testfn(int y) { int l_testfn(int y) {
int x __attribute__((lockable)) = y; // \ int x __attribute__((lockable)) = y; // \
expected-warning {{'lockable' attribute only applies to classes}} // expected-warning {{'lockable' attribute only applies to classes}}
return x; return x;
} }
int l_test_var __attribute__((lockable)); // \ int l_test_var __attribute__((lockable)); // \
expected-warning {{'lockable' attribute only applies to classes}} // expected-warning {{'lockable' attribute only applies to classes}}
class LFoo { class LFoo {
private: private:
int test_field __attribute__((lockable)); // \ int test_field __attribute__((lockable)); // \
expected-warning {{'lockable' attribute only applies to classes}} // expected-warning {{'lockable' attribute only applies to classes}}
void test_method() __attribute__((lockable)); // \ void test_method() __attribute__((lockable)); // \
expected-warning {{'lockable' attribute only applies to classes}} // expected-warning {{'lockable' attribute only applies to classes}}
}; };
void l_function_params(int lvar __attribute__((lockable))); // \ void l_function_params(int lvar __attribute__((lockable))); // \
expected-warning {{'lockable' attribute only applies to classes}} // expected-warning {{'lockable' attribute only applies to classes}}
//-----------------------------------------// //-----------------------------------------//
@ -238,32 +238,32 @@ class __attribute__((scoped_lockable)) SLTestClass {
}; };
class __attribute__((scoped_lockable (1))) SLTestClass_args { // \ class __attribute__((scoped_lockable (1))) SLTestClass_args { // \
expected-error {{attribute takes no arguments}} // expected-error {{attribute takes no arguments}}
}; };
void sl_test_function() __attribute__((scoped_lockable)); // \ void sl_test_function() __attribute__((scoped_lockable)); // \
expected-warning {{'scoped_lockable' attribute only applies to classes}} // expected-warning {{'scoped_lockable' attribute only applies to classes}}
int sl_testfn(int y) { int sl_testfn(int y) {
int x __attribute__((scoped_lockable)) = y; // \ int x __attribute__((scoped_lockable)) = y; // \
expected-warning {{'scoped_lockable' attribute only applies to classes}} // expected-warning {{'scoped_lockable' attribute only applies to classes}}
return x; return x;
} }
int sl_test_var __attribute__((scoped_lockable)); // \ int sl_test_var __attribute__((scoped_lockable)); // \
expected-warning {{'scoped_lockable' attribute only applies to classes}} // expected-warning {{'scoped_lockable' attribute only applies to classes}}
class SLFoo { class SLFoo {
private: private:
int test_field __attribute__((scoped_lockable)); // \ int test_field __attribute__((scoped_lockable)); // \
expected-warning {{'scoped_lockable' attribute only applies to classes}} // expected-warning {{'scoped_lockable' attribute only applies to classes}}
void test_method() __attribute__((scoped_lockable)); // \ void test_method() __attribute__((scoped_lockable)); // \
expected-warning {{'scoped_lockable' attribute only applies to classes}} // expected-warning {{'scoped_lockable' attribute only applies to classes}}
}; };
void sl_function_params(int lvar __attribute__((scoped_lockable))); // \ void sl_function_params(int lvar __attribute__((scoped_lockable))); // \
expected-warning {{'scoped_lockable' attribute only applies to classes}} // expected-warning {{'scoped_lockable' attribute only applies to classes}}
//-----------------------------------------// //-----------------------------------------//
@ -281,31 +281,31 @@ void sl_function_params(int lvar __attribute__((scoped_lockable))); // \
int gb_var_arg __attribute__((guarded_by(mu1))); int gb_var_arg __attribute__((guarded_by(mu1)));
int gb_var_args __attribute__((guarded_by(mu1, mu2))); // \ int gb_var_args __attribute__((guarded_by(mu1, mu2))); // \
expected-error {{attribute takes one argument}} // expected-error {{attribute takes one argument}}
int gb_var_noargs __attribute__((guarded_by)); // \ int gb_var_noargs __attribute__((guarded_by)); // \
expected-error {{attribute takes one argument}} // expected-error {{attribute takes one argument}}
class GBFoo { class GBFoo {
private: private:
int gb_field_noargs __attribute__((guarded_by)); // \ int gb_field_noargs __attribute__((guarded_by)); // \
expected-error {{attribute takes one argument}} // expected-error {{attribute takes one argument}}
int gb_field_args __attribute__((guarded_by(mu1))); int gb_field_args __attribute__((guarded_by(mu1)));
}; };
class __attribute__((guarded_by(mu1))) GB { // \ class __attribute__((guarded_by(mu1))) GB { // \
expected-warning {{'guarded_by' attribute only applies to fields and global variables}} // expected-warning {{'guarded_by' attribute only applies to fields and global variables}}
}; };
void gb_function() __attribute__((guarded_by(mu1))); // \ void gb_function() __attribute__((guarded_by(mu1))); // \
expected-warning {{'guarded_by' attribute only applies to fields and global variables}} // expected-warning {{'guarded_by' attribute only applies to fields and global variables}}
void gb_function_params(int gv_lvar __attribute__((guarded_by(mu1)))); // \ void gb_function_params(int gv_lvar __attribute__((guarded_by(mu1)))); // \
expected-warning {{'guarded_by' attribute only applies to fields and global variables}} // expected-warning {{'guarded_by' attribute only applies to fields and global variables}}
int gb_testfn(int y){ int gb_testfn(int y){
int x __attribute__((guarded_by(mu1))) = y; // \ int x __attribute__((guarded_by(mu1))) = y; // \
expected-warning {{'guarded_by' attribute only applies to fields and global variables}} // expected-warning {{'guarded_by' attribute only applies to fields and global variables}}
return x; return x;
} }
@ -324,13 +324,13 @@ int gb_var_arg_8 __attribute__((guarded_by(muPointer)));
// illegal attribute arguments // illegal attribute arguments
int gb_var_arg_bad_1 __attribute__((guarded_by(1))); // \ int gb_var_arg_bad_1 __attribute__((guarded_by(1))); // \
expected-error {{'guarded_by' attribute requires arguments that are class type or point to class type}} // expected-error {{'guarded_by' attribute requires arguments that are class type or point to class type}}
int gb_var_arg_bad_2 __attribute__((guarded_by("mu"))); // \ int gb_var_arg_bad_2 __attribute__((guarded_by("mu"))); // \
expected-error {{'guarded_by' attribute requires arguments that are class type or point to class type}} // expected-error {{'guarded_by' attribute requires arguments that are class type or point to class type}}
int gb_var_arg_bad_3 __attribute__((guarded_by(muDoublePointer))); // \ int gb_var_arg_bad_3 __attribute__((guarded_by(muDoublePointer))); // \
expected-error {{'guarded_by' attribute requires arguments that are class type or point to class type}} // expected-error {{'guarded_by' attribute requires arguments that are class type or point to class type}}
int gb_var_arg_bad_4 __attribute__((guarded_by(umu))); // \ int gb_var_arg_bad_4 __attribute__((guarded_by(umu))); // \
expected-error {{'guarded_by' attribute requires arguments whose type is annotated with 'lockable' attribute}} // expected-error {{'guarded_by' attribute requires arguments whose type is annotated with 'lockable' attribute}}
//3. //3.
// Thread Safety analysis tests // Thread Safety analysis tests
@ -347,36 +347,36 @@ int gb_var_arg_bad_4 __attribute__((guarded_by(umu))); // \
//1. Check applied to the right types & argument number //1. Check applied to the right types & argument number
int *pgb_var_noargs __attribute__((pt_guarded_by)); // \ int *pgb_var_noargs __attribute__((pt_guarded_by)); // \
expected-error {{attribute takes one argument}} // expected-error {{attribute takes one argument}}
int *pgb_ptr_var_arg __attribute__((pt_guarded_by(mu1))); int *pgb_ptr_var_arg __attribute__((pt_guarded_by(mu1)));
int *pgb_ptr_var_args __attribute__((guarded_by(mu1, mu2))); // \ int *pgb_ptr_var_args __attribute__((guarded_by(mu1, mu2))); // \
expected-error {{attribute takes one argument}} // expected-error {{attribute takes one argument}}
int pgb_var_args __attribute__((pt_guarded_by(mu1))); // \ int pgb_var_args __attribute__((pt_guarded_by(mu1))); // \
expected-warning {{'pt_guarded_by' only applies to pointer types; type here is 'int'}} // expected-warning {{'pt_guarded_by' only applies to pointer types; type here is 'int'}}
class PGBFoo { class PGBFoo {
private: private:
int *pgb_field_noargs __attribute__((pt_guarded_by)); // \ int *pgb_field_noargs __attribute__((pt_guarded_by)); // \
expected-error {{attribute takes one argument}} // expected-error {{attribute takes one argument}}
int *pgb_field_args __attribute__((pt_guarded_by(mu1))); int *pgb_field_args __attribute__((pt_guarded_by(mu1)));
}; };
class __attribute__((pt_guarded_by(mu1))) PGB { // \ class __attribute__((pt_guarded_by(mu1))) PGB { // \
expected-warning {{'pt_guarded_by' attribute only applies to fields and global variables}} // expected-warning {{'pt_guarded_by' attribute only applies to fields and global variables}}
}; };
void pgb_function() __attribute__((pt_guarded_by(mu1))); // \ void pgb_function() __attribute__((pt_guarded_by(mu1))); // \
expected-warning {{'pt_guarded_by' attribute only applies to fields and global variables}} // expected-warning {{'pt_guarded_by' attribute only applies to fields and global variables}}
void pgb_function_params(int gv_lvar __attribute__((pt_guarded_by(mu1)))); // \ void pgb_function_params(int gv_lvar __attribute__((pt_guarded_by(mu1)))); // \
expected-warning {{'pt_guarded_by' attribute only applies to fields and global variables}} // expected-warning {{'pt_guarded_by' attribute only applies to fields and global variables}}
void pgb_testfn(int y){ void pgb_testfn(int y){
int *x __attribute__((pt_guarded_by(mu1))) = new int(0); // \ int *x __attribute__((pt_guarded_by(mu1))) = new int(0); // \
expected-warning {{'pt_guarded_by' attribute only applies to fields and global variables}} // expected-warning {{'pt_guarded_by' attribute only applies to fields and global variables}}
delete x; delete x;
} }
@ -395,13 +395,13 @@ int * pgb_var_arg_8 __attribute__((pt_guarded_by(muPointer)));
// illegal attribute arguments // illegal attribute arguments
int * pgb_var_arg_bad_1 __attribute__((pt_guarded_by(1))); // \ int * pgb_var_arg_bad_1 __attribute__((pt_guarded_by(1))); // \
expected-error {{'pt_guarded_by' attribute requires arguments that are class type or point to class type}} // expected-error {{'pt_guarded_by' attribute requires arguments that are class type or point to class type}}
int * pgb_var_arg_bad_2 __attribute__((pt_guarded_by("mu"))); // \ int * pgb_var_arg_bad_2 __attribute__((pt_guarded_by("mu"))); // \
expected-error {{'pt_guarded_by' attribute requires arguments that are class type or point to class type}} // expected-error {{'pt_guarded_by' attribute requires arguments that are class type or point to class type}}
int * pgb_var_arg_bad_3 __attribute__((pt_guarded_by(muDoublePointer))); // \ int * pgb_var_arg_bad_3 __attribute__((pt_guarded_by(muDoublePointer))); // \
expected-error {{'pt_guarded_by' attribute requires arguments that are class type or point to class type}} // expected-error {{'pt_guarded_by' attribute requires arguments that are class type or point to class type}}
int * pgb_var_arg_bad_4 __attribute__((pt_guarded_by(umu))); // \ int * pgb_var_arg_bad_4 __attribute__((pt_guarded_by(umu))); // \
expected-error {{'pt_guarded_by' attribute requires arguments whose type is annotated with 'lockable' attribute}} // expected-error {{'pt_guarded_by' attribute requires arguments whose type is annotated with 'lockable' attribute}}
//-----------------------------------------// //-----------------------------------------//
@ -417,28 +417,28 @@ int * pgb_var_arg_bad_4 __attribute__((pt_guarded_by(umu))); // \
Mu mu_aa __attribute__((acquired_after(mu1))); Mu mu_aa __attribute__((acquired_after(mu1)));
Mu aa_var_noargs __attribute__((acquired_after)); // \ Mu aa_var_noargs __attribute__((acquired_after)); // \
expected-error {{attribute takes at least 1 argument}} // expected-error {{attribute takes at least 1 argument}}
class AAFoo { class AAFoo {
private: private:
Mu aa_field_noargs __attribute__((acquired_after)); // \ Mu aa_field_noargs __attribute__((acquired_after)); // \
expected-error {{attribute takes at least 1 argument}} // expected-error {{attribute takes at least 1 argument}}
Mu aa_field_args __attribute__((acquired_after(mu1))); Mu aa_field_args __attribute__((acquired_after(mu1)));
}; };
class __attribute__((acquired_after(mu1))) AA { // \ class __attribute__((acquired_after(mu1))) AA { // \
expected-warning {{'acquired_after' attribute only applies to fields and global variables}} // expected-warning {{'acquired_after' attribute only applies to fields and global variables}}
}; };
void aa_function() __attribute__((acquired_after(mu1))); // \ void aa_function() __attribute__((acquired_after(mu1))); // \
expected-warning {{'acquired_after' attribute only applies to fields and global variables}} // expected-warning {{'acquired_after' attribute only applies to fields and global variables}}
void aa_function_params(int gv_lvar __attribute__((acquired_after(mu1)))); // \ void aa_function_params(int gv_lvar __attribute__((acquired_after(mu1)))); // \
expected-warning {{'acquired_after' attribute only applies to fields and global variables}} // expected-warning {{'acquired_after' attribute only applies to fields and global variables}}
void aa_testfn(int y){ void aa_testfn(int y){
Mu x __attribute__((acquired_after(mu1))) = Mu(); // \ Mu x __attribute__((acquired_after(mu1))) = Mu(); // \
expected-warning {{'acquired_after' attribute only applies to fields and global variables}} // expected-warning {{'acquired_after' attribute only applies to fields and global variables}}
} }
//Check argument parsing. //Check argument parsing.
@ -456,15 +456,15 @@ Mu aa_var_arg_8 __attribute__((acquired_after(muPointer)));
// illegal attribute arguments // illegal attribute arguments
Mu aa_var_arg_bad_1 __attribute__((acquired_after(1))); // \ Mu aa_var_arg_bad_1 __attribute__((acquired_after(1))); // \
expected-error {{'acquired_after' attribute requires arguments that are class type or point to class type}} // expected-error {{'acquired_after' attribute requires arguments that are class type or point to class type}}
Mu aa_var_arg_bad_2 __attribute__((acquired_after("mu"))); // \ Mu aa_var_arg_bad_2 __attribute__((acquired_after("mu"))); // \
expected-error {{'acquired_after' attribute requires arguments that are class type or point to class type}} // expected-error {{'acquired_after' attribute requires arguments that are class type or point to class type}}
Mu aa_var_arg_bad_3 __attribute__((acquired_after(muDoublePointer))); // \ Mu aa_var_arg_bad_3 __attribute__((acquired_after(muDoublePointer))); // \
expected-error {{'acquired_after' attribute requires arguments that are class type or point to class type}} // expected-error {{'acquired_after' attribute requires arguments that are class type or point to class type}}
Mu aa_var_arg_bad_4 __attribute__((acquired_after(umu))); // \ Mu aa_var_arg_bad_4 __attribute__((acquired_after(umu))); // \
expected-error {{'acquired_after' attribute requires arguments whose type is annotated with 'lockable' attribute}} // expected-error {{'acquired_after' attribute requires arguments whose type is annotated with 'lockable' attribute}}
UnlockableMu aa_var_arg_bad_5 __attribute__((acquired_after(mu_aa))); // \ UnlockableMu aa_var_arg_bad_5 __attribute__((acquired_after(mu_aa))); // \
expected-error {{'acquired_after' attribute can only be applied in a context annotated with 'lockable' attribute}} // expected-error {{'acquired_after' attribute can only be applied in a context annotated with 'lockable' attribute}}
//-----------------------------------------// //-----------------------------------------//
// Acquired Before (ab) // Acquired Before (ab)
@ -477,28 +477,28 @@ UnlockableMu aa_var_arg_bad_5 __attribute__((acquired_after(mu_aa))); // \
Mu mu_ab __attribute__((acquired_before(mu1))); Mu mu_ab __attribute__((acquired_before(mu1)));
Mu ab_var_noargs __attribute__((acquired_before)); // \ Mu ab_var_noargs __attribute__((acquired_before)); // \
expected-error {{attribute takes at least 1 argument}} // expected-error {{attribute takes at least 1 argument}}
class ABFoo { class ABFoo {
private: private:
Mu ab_field_noargs __attribute__((acquired_before)); // \ Mu ab_field_noargs __attribute__((acquired_before)); // \
expected-error {{attribute takes at least 1 argument}} // expected-error {{attribute takes at least 1 argument}}
Mu ab_field_args __attribute__((acquired_before(mu1))); Mu ab_field_args __attribute__((acquired_before(mu1)));
}; };
class __attribute__((acquired_before(mu1))) AB { // \ class __attribute__((acquired_before(mu1))) AB { // \
expected-warning {{'acquired_before' attribute only applies to fields and global variables}} // expected-warning {{'acquired_before' attribute only applies to fields and global variables}}
}; };
void ab_function() __attribute__((acquired_before(mu1))); // \ void ab_function() __attribute__((acquired_before(mu1))); // \
expected-warning {{'acquired_before' attribute only applies to fields and global variables}} // expected-warning {{'acquired_before' attribute only applies to fields and global variables}}
void ab_function_params(int gv_lvar __attribute__((acquired_before(mu1)))); // \ void ab_function_params(int gv_lvar __attribute__((acquired_before(mu1)))); // \
expected-warning {{'acquired_before' attribute only applies to fields and global variables}} // expected-warning {{'acquired_before' attribute only applies to fields and global variables}}
void ab_testfn(int y){ void ab_testfn(int y){
Mu x __attribute__((acquired_before(mu1))) = Mu(); // \ Mu x __attribute__((acquired_before(mu1))) = Mu(); // \
expected-warning {{'acquired_before' attribute only applies to fields and global variables}} // expected-warning {{'acquired_before' attribute only applies to fields and global variables}}
} }
// Note: illegal int ab_int __attribute__((acquired_before(mu1))) will // Note: illegal int ab_int __attribute__((acquired_before(mu1))) will
@ -519,15 +519,15 @@ Mu ab_var_arg_8 __attribute__((acquired_before(muPointer)));
// illegal attribute arguments // illegal attribute arguments
Mu ab_var_arg_bad_1 __attribute__((acquired_before(1))); // \ Mu ab_var_arg_bad_1 __attribute__((acquired_before(1))); // \
expected-error {{'acquired_before' attribute requires arguments that are class type or point to class type}} // expected-error {{'acquired_before' attribute requires arguments that are class type or point to class type}}
Mu ab_var_arg_bad_2 __attribute__((acquired_before("mu"))); // \ Mu ab_var_arg_bad_2 __attribute__((acquired_before("mu"))); // \
expected-error {{'acquired_before' attribute requires arguments that are class type or point to class type}} // expected-error {{'acquired_before' attribute requires arguments that are class type or point to class type}}
Mu ab_var_arg_bad_3 __attribute__((acquired_before(muDoublePointer))); // \ Mu ab_var_arg_bad_3 __attribute__((acquired_before(muDoublePointer))); // \
expected-error {{'acquired_before' attribute requires arguments that are class type or point to class type}} // expected-error {{'acquired_before' attribute requires arguments that are class type or point to class type}}
Mu ab_var_arg_bad_4 __attribute__((acquired_before(umu))); // \ Mu ab_var_arg_bad_4 __attribute__((acquired_before(umu))); // \
expected-error {{'acquired_before' attribute requires arguments whose type is annotated with 'lockable' attribute}} // expected-error {{'acquired_before' attribute requires arguments whose type is annotated with 'lockable' attribute}}
UnlockableMu ab_var_arg_bad_5 __attribute__((acquired_before(mu_ab))); // \ UnlockableMu ab_var_arg_bad_5 __attribute__((acquired_before(mu_ab))); // \
expected-error {{'acquired_before' attribute can only be applied in a context annotated with 'lockable' attribute}} // expected-error {{'acquired_before' attribute can only be applied in a context annotated with 'lockable' attribute}}
//-----------------------------------------// //-----------------------------------------//
@ -548,26 +548,26 @@ int elf_testfn(int y) __attribute__((exclusive_lock_function));
int elf_testfn(int y) { int elf_testfn(int y) {
int x __attribute__((exclusive_lock_function)) = y; // \ int x __attribute__((exclusive_lock_function)) = y; // \
expected-warning {{'exclusive_lock_function' attribute only applies to functions and methods}} // expected-warning {{'exclusive_lock_function' attribute only applies to functions and methods}}
return x; return x;
}; };
int elf_test_var __attribute__((exclusive_lock_function)); // \ int elf_test_var __attribute__((exclusive_lock_function)); // \
expected-warning {{'exclusive_lock_function' attribute only applies to functions and methods}} // expected-warning {{'exclusive_lock_function' attribute only applies to functions and methods}}
class ElfFoo { class ElfFoo {
private: private:
int test_field __attribute__((exclusive_lock_function)); // \ int test_field __attribute__((exclusive_lock_function)); // \
expected-warning {{'exclusive_lock_function' attribute only applies to functions and methods}} // expected-warning {{'exclusive_lock_function' attribute only applies to functions and methods}}
void test_method() __attribute__((exclusive_lock_function)); void test_method() __attribute__((exclusive_lock_function));
}; };
class __attribute__((exclusive_lock_function)) ElfTestClass { // \ class __attribute__((exclusive_lock_function)) ElfTestClass { // \
expected-warning {{'exclusive_lock_function' attribute only applies to functions and methods}} // expected-warning {{'exclusive_lock_function' attribute only applies to functions and methods}}
}; };
void elf_fun_params(int lvar __attribute__((exclusive_lock_function))); // \ void elf_fun_params(int lvar __attribute__((exclusive_lock_function))); // \
expected-warning {{'exclusive_lock_function' attribute only applies to functions and methods}} // expected-warning {{'exclusive_lock_function' attribute only applies to functions and methods}}
// Check argument parsing. // Check argument parsing.
@ -586,20 +586,20 @@ int elf_function_9(Mu x, Mu y) __attribute__((exclusive_lock_function(1,2)));
// illegal attribute arguments // illegal attribute arguments
int elf_function_bad_2() __attribute__((exclusive_lock_function("mu"))); // \ int elf_function_bad_2() __attribute__((exclusive_lock_function("mu"))); // \
expected-error {{'exclusive_lock_function' attribute requires arguments that are class type or point to class type}} // expected-error {{'exclusive_lock_function' attribute requires arguments that are class type or point to class type}}
int elf_function_bad_3() __attribute__((exclusive_lock_function(muDoublePointer))); // \ int elf_function_bad_3() __attribute__((exclusive_lock_function(muDoublePointer))); // \
expected-error {{'exclusive_lock_function' attribute requires arguments that are class type or point to class type}} // expected-error {{'exclusive_lock_function' attribute requires arguments that are class type or point to class type}}
int elf_function_bad_4() __attribute__((exclusive_lock_function(umu))); // \ int elf_function_bad_4() __attribute__((exclusive_lock_function(umu))); // \
expected-error {{'exclusive_lock_function' attribute requires arguments whose type is annotated with 'lockable' attribute}} // expected-error {{'exclusive_lock_function' attribute requires arguments whose type is annotated with 'lockable' attribute}}
int elf_function_bad_1() __attribute__((exclusive_lock_function(1))); // \ int elf_function_bad_1() __attribute__((exclusive_lock_function(1))); // \
expected-error {{'exclusive_lock_function' attribute parameter 1 is out of bounds: no parameters to index into}} // expected-error {{'exclusive_lock_function' attribute parameter 1 is out of bounds: no parameters to index into}}
int elf_function_bad_5(Mu x) __attribute__((exclusive_lock_function(0))); // \ int elf_function_bad_5(Mu x) __attribute__((exclusive_lock_function(0))); // \
expected-error {{'exclusive_lock_function' attribute parameter 1 is out of bounds: can only be 1, since there is one parameter}} // expected-error {{'exclusive_lock_function' attribute parameter 1 is out of bounds: can only be 1, since there is one parameter}}
int elf_function_bad_6(Mu x, Mu y) __attribute__((exclusive_lock_function(0))); // \ int elf_function_bad_6(Mu x, Mu y) __attribute__((exclusive_lock_function(0))); // \
expected-error {{'exclusive_lock_function' attribute parameter 1 is out of bounds: must be between 1 and 2}} // expected-error {{'exclusive_lock_function' attribute parameter 1 is out of bounds: must be between 1 and 2}}
int elf_function_bad_7() __attribute__((exclusive_lock_function(0))); // \ int elf_function_bad_7() __attribute__((exclusive_lock_function(0))); // \
expected-error {{'exclusive_lock_function' attribute parameter 1 is out of bounds: no parameters to index into}} // expected-error {{'exclusive_lock_function' attribute parameter 1 is out of bounds: no parameters to index into}}
//-----------------------------------------// //-----------------------------------------//
@ -620,25 +620,25 @@ int slf_testfn(int y) __attribute__((shared_lock_function));
int slf_testfn(int y) { int slf_testfn(int y) {
int x __attribute__((shared_lock_function)) = y; // \ int x __attribute__((shared_lock_function)) = y; // \
expected-warning {{'shared_lock_function' attribute only applies to functions and methods}} // expected-warning {{'shared_lock_function' attribute only applies to functions and methods}}
return x; return x;
}; };
int slf_test_var __attribute__((shared_lock_function)); // \ int slf_test_var __attribute__((shared_lock_function)); // \
expected-warning {{'shared_lock_function' attribute only applies to functions and methods}} // expected-warning {{'shared_lock_function' attribute only applies to functions and methods}}
void slf_fun_params(int lvar __attribute__((shared_lock_function))); // \ void slf_fun_params(int lvar __attribute__((shared_lock_function))); // \
expected-warning {{'shared_lock_function' attribute only applies to functions and methods}} // expected-warning {{'shared_lock_function' attribute only applies to functions and methods}}
class SlfFoo { class SlfFoo {
private: private:
int test_field __attribute__((shared_lock_function)); // \ int test_field __attribute__((shared_lock_function)); // \
expected-warning {{'shared_lock_function' attribute only applies to functions and methods}} // expected-warning {{'shared_lock_function' attribute only applies to functions and methods}}
void test_method() __attribute__((shared_lock_function)); void test_method() __attribute__((shared_lock_function));
}; };
class __attribute__((shared_lock_function)) SlfTestClass { // \ class __attribute__((shared_lock_function)) SlfTestClass { // \
expected-warning {{'shared_lock_function' attribute only applies to functions and methods}} // expected-warning {{'shared_lock_function' attribute only applies to functions and methods}}
}; };
// Check argument parsing. // Check argument parsing.
@ -658,20 +658,20 @@ int slf_function_9(Mu x, Mu y) __attribute__((shared_lock_function(1,2)));
// illegal attribute arguments // illegal attribute arguments
int slf_function_bad_2() __attribute__((shared_lock_function("mu"))); // \ int slf_function_bad_2() __attribute__((shared_lock_function("mu"))); // \
expected-error {{'shared_lock_function' attribute requires arguments that are class type or point to class type}} // expected-error {{'shared_lock_function' attribute requires arguments that are class type or point to class type}}
int slf_function_bad_3() __attribute__((shared_lock_function(muDoublePointer))); // \ int slf_function_bad_3() __attribute__((shared_lock_function(muDoublePointer))); // \
expected-error {{'shared_lock_function' attribute requires arguments that are class type or point to class type}} // expected-error {{'shared_lock_function' attribute requires arguments that are class type or point to class type}}
int slf_function_bad_4() __attribute__((shared_lock_function(umu))); // \ int slf_function_bad_4() __attribute__((shared_lock_function(umu))); // \
expected-error {{'shared_lock_function' attribute requires arguments whose type is annotated with 'lockable' attribute}} // expected-error {{'shared_lock_function' attribute requires arguments whose type is annotated with 'lockable' attribute}}
int slf_function_bad_1() __attribute__((shared_lock_function(1))); // \ int slf_function_bad_1() __attribute__((shared_lock_function(1))); // \
expected-error {{'shared_lock_function' attribute parameter 1 is out of bounds: no parameters to index into}} // expected-error {{'shared_lock_function' attribute parameter 1 is out of bounds: no parameters to index into}}
int slf_function_bad_5(Mu x) __attribute__((shared_lock_function(0))); // \ int slf_function_bad_5(Mu x) __attribute__((shared_lock_function(0))); // \
expected-error {{'shared_lock_function' attribute parameter 1 is out of bounds: can only be 1, since there is one parameter}} // expected-error {{'shared_lock_function' attribute parameter 1 is out of bounds: can only be 1, since there is one parameter}}
int slf_function_bad_6(Mu x, Mu y) __attribute__((shared_lock_function(0))); // \ int slf_function_bad_6(Mu x, Mu y) __attribute__((shared_lock_function(0))); // \
expected-error {{'shared_lock_function' attribute parameter 1 is out of bounds: must be between 1 and 2}} // expected-error {{'shared_lock_function' attribute parameter 1 is out of bounds: must be between 1 and 2}}
int slf_function_bad_7() __attribute__((shared_lock_function(0))); // \ int slf_function_bad_7() __attribute__((shared_lock_function(0))); // \
expected-error {{'shared_lock_function' attribute parameter 1 is out of bounds: no parameters to index into}} // expected-error {{'shared_lock_function' attribute parameter 1 is out of bounds: no parameters to index into}}
//-----------------------------------------// //-----------------------------------------//
@ -686,7 +686,7 @@ int slf_function_bad_7() __attribute__((shared_lock_function(0))); // \
// plus an optional list of locks (vars/fields) // plus an optional list of locks (vars/fields)
void etf_function() __attribute__((exclusive_trylock_function)); // \ void etf_function() __attribute__((exclusive_trylock_function)); // \
expected-error {{attribute takes attribute takes at least 1 argument arguments}} // expected-error {{attribute takes attribute takes at least 1 argument arguments}}
void etf_function_args() __attribute__((exclusive_trylock_function(1, mu2))); void etf_function_args() __attribute__((exclusive_trylock_function(1, mu2)));
@ -696,26 +696,26 @@ int etf_testfn(int y) __attribute__((exclusive_trylock_function(1)));
int etf_testfn(int y) { int etf_testfn(int y) {
int x __attribute__((exclusive_trylock_function(1))) = y; // \ int x __attribute__((exclusive_trylock_function(1))) = y; // \
expected-warning {{'exclusive_trylock_function' attribute only applies to functions and methods}} // expected-warning {{'exclusive_trylock_function' attribute only applies to functions and methods}}
return x; return x;
}; };
int etf_test_var __attribute__((exclusive_trylock_function(1))); // \ int etf_test_var __attribute__((exclusive_trylock_function(1))); // \
expected-warning {{'exclusive_trylock_function' attribute only applies to functions and methods}} // expected-warning {{'exclusive_trylock_function' attribute only applies to functions and methods}}
class EtfFoo { class EtfFoo {
private: private:
int test_field __attribute__((exclusive_trylock_function(1))); // \ int test_field __attribute__((exclusive_trylock_function(1))); // \
expected-warning {{'exclusive_trylock_function' attribute only applies to functions and methods}} // expected-warning {{'exclusive_trylock_function' attribute only applies to functions and methods}}
void test_method() __attribute__((exclusive_trylock_function(1))); void test_method() __attribute__((exclusive_trylock_function(1)));
}; };
class __attribute__((exclusive_trylock_function(1))) EtfTestClass { // \ class __attribute__((exclusive_trylock_function(1))) EtfTestClass { // \
expected-warning {{'exclusive_trylock_function' attribute only applies to functions and methods}} // expected-warning {{'exclusive_trylock_function' attribute only applies to functions and methods}}
}; };
void etf_fun_params(int lvar __attribute__((exclusive_trylock_function(1)))); // \ void etf_fun_params(int lvar __attribute__((exclusive_trylock_function(1)))); // \
expected-warning {{'exclusive_trylock_function' attribute only applies to functions and methods}} // expected-warning {{'exclusive_trylock_function' attribute only applies to functions and methods}}
// Check argument parsing. // Check argument parsing.
@ -733,18 +733,18 @@ int etf_function_9() __attribute__((exclusive_trylock_function(true)));
// illegal attribute arguments // illegal attribute arguments
int etf_function_bad_1() __attribute__((exclusive_trylock_function(mu1))); // \ int etf_function_bad_1() __attribute__((exclusive_trylock_function(mu1))); // \
expected-error {{'exclusive_trylock_function' attribute first argument must be of int or bool type}} // expected-error {{'exclusive_trylock_function' attribute first argument must be of int or bool type}}
int etf_function_bad_2() __attribute__((exclusive_trylock_function("mu"))); // \ int etf_function_bad_2() __attribute__((exclusive_trylock_function("mu"))); // \
expected-error {{'exclusive_trylock_function' attribute first argument must be of int or bool type}} // expected-error {{'exclusive_trylock_function' attribute first argument must be of int or bool type}}
int etf_function_bad_3() __attribute__((exclusive_trylock_function(muDoublePointer))); // \ int etf_function_bad_3() __attribute__((exclusive_trylock_function(muDoublePointer))); // \
expected-error {{'exclusive_trylock_function' attribute first argument must be of int or bool type}} // expected-error {{'exclusive_trylock_function' attribute first argument must be of int or bool type}}
int etf_function_bad_4() __attribute__((exclusive_trylock_function(1, "mu"))); // \ int etf_function_bad_4() __attribute__((exclusive_trylock_function(1, "mu"))); // \
expected-error {{'exclusive_trylock_function' attribute requires arguments that are class type or point to class type}} // expected-error {{'exclusive_trylock_function' attribute requires arguments that are class type or point to class type}}
int etf_function_bad_5() __attribute__((exclusive_trylock_function(1, muDoublePointer))); // \ int etf_function_bad_5() __attribute__((exclusive_trylock_function(1, muDoublePointer))); // \
expected-error {{'exclusive_trylock_function' attribute requires arguments that are class type or point to class type}} // expected-error {{'exclusive_trylock_function' attribute requires arguments that are class type or point to class type}}
int etf_function_bad_6() __attribute__((exclusive_trylock_function(1, umu))); // \ int etf_function_bad_6() __attribute__((exclusive_trylock_function(1, umu))); // \
expected-error {{'exclusive_trylock_function' attribute requires arguments whose type is annotated with 'lockable' attribute}} // expected-error {{'exclusive_trylock_function' attribute requires arguments whose type is annotated with 'lockable' attribute}}
//-----------------------------------------// //-----------------------------------------//
@ -759,7 +759,7 @@ int etf_function_bad_6() __attribute__((exclusive_trylock_function(1, umu))); //
// plus an optional list of locks (vars/fields) // plus an optional list of locks (vars/fields)
void stf_function() __attribute__((shared_trylock_function)); // \ void stf_function() __attribute__((shared_trylock_function)); // \
expected-error {{attribute takes at least 1 argument}} // expected-error {{attribute takes at least 1 argument}}
void stf_function_args() __attribute__((shared_trylock_function(1, mu2))); void stf_function_args() __attribute__((shared_trylock_function(1, mu2)));
@ -769,26 +769,26 @@ int stf_testfn(int y) __attribute__((shared_trylock_function(1)));
int stf_testfn(int y) { int stf_testfn(int y) {
int x __attribute__((shared_trylock_function(1))) = y; // \ int x __attribute__((shared_trylock_function(1))) = y; // \
expected-warning {{'shared_trylock_function' attribute only applies to functions and methods}} // expected-warning {{'shared_trylock_function' attribute only applies to functions and methods}}
return x; return x;
}; };
int stf_test_var __attribute__((shared_trylock_function(1))); // \ int stf_test_var __attribute__((shared_trylock_function(1))); // \
expected-warning {{'shared_trylock_function' attribute only applies to functions and methods}} // expected-warning {{'shared_trylock_function' attribute only applies to functions and methods}}
void stf_fun_params(int lvar __attribute__((shared_trylock_function(1)))); // \ void stf_fun_params(int lvar __attribute__((shared_trylock_function(1)))); // \
expected-warning {{'shared_trylock_function' attribute only applies to functions and methods}} // expected-warning {{'shared_trylock_function' attribute only applies to functions and methods}}
class StfFoo { class StfFoo {
private: private:
int test_field __attribute__((shared_trylock_function(1))); // \ int test_field __attribute__((shared_trylock_function(1))); // \
expected-warning {{'shared_trylock_function' attribute only applies to functions and methods}} // expected-warning {{'shared_trylock_function' attribute only applies to functions and methods}}
void test_method() __attribute__((shared_trylock_function(1))); void test_method() __attribute__((shared_trylock_function(1)));
}; };
class __attribute__((shared_trylock_function(1))) StfTestClass { // \ class __attribute__((shared_trylock_function(1))) StfTestClass { // \
expected-warning {{'shared_trylock_function' attribute only applies to functions and methods}} // expected-warning {{'shared_trylock_function' attribute only applies to functions and methods}}
}; };
// Check argument parsing. // Check argument parsing.
@ -807,18 +807,18 @@ int stf_function_9() __attribute__((shared_trylock_function(true)));
// illegal attribute arguments // illegal attribute arguments
int stf_function_bad_1() __attribute__((shared_trylock_function(mu1))); // \ int stf_function_bad_1() __attribute__((shared_trylock_function(mu1))); // \
expected-error {{'shared_trylock_function' attribute first argument must be of int or bool type}} // expected-error {{'shared_trylock_function' attribute first argument must be of int or bool type}}
int stf_function_bad_2() __attribute__((shared_trylock_function("mu"))); // \ int stf_function_bad_2() __attribute__((shared_trylock_function("mu"))); // \
expected-error {{'shared_trylock_function' attribute first argument must be of int or bool type}} // expected-error {{'shared_trylock_function' attribute first argument must be of int or bool type}}
int stf_function_bad_3() __attribute__((shared_trylock_function(muDoublePointer))); // \ int stf_function_bad_3() __attribute__((shared_trylock_function(muDoublePointer))); // \
expected-error {{'shared_trylock_function' attribute first argument must be of int or bool type}} // expected-error {{'shared_trylock_function' attribute first argument must be of int or bool type}}
int stf_function_bad_4() __attribute__((shared_trylock_function(1, "mu"))); // \ int stf_function_bad_4() __attribute__((shared_trylock_function(1, "mu"))); // \
expected-error {{'shared_trylock_function' attribute requires arguments that are class type or point to class type}} // expected-error {{'shared_trylock_function' attribute requires arguments that are class type or point to class type}}
int stf_function_bad_5() __attribute__((shared_trylock_function(1, muDoublePointer))); // \ int stf_function_bad_5() __attribute__((shared_trylock_function(1, muDoublePointer))); // \
expected-error {{'shared_trylock_function' attribute requires arguments that are class type or point to class type}} // expected-error {{'shared_trylock_function' attribute requires arguments that are class type or point to class type}}
int stf_function_bad_6() __attribute__((shared_trylock_function(1, umu))); // \ int stf_function_bad_6() __attribute__((shared_trylock_function(1, umu))); // \
expected-error {{'shared_trylock_function' attribute requires arguments whose type is annotated with 'lockable' attribute}} // expected-error {{'shared_trylock_function' attribute requires arguments whose type is annotated with 'lockable' attribute}}
//-----------------------------------------// //-----------------------------------------//
@ -839,26 +839,26 @@ int uf_testfn(int y) __attribute__((unlock_function));
int uf_testfn(int y) { int uf_testfn(int y) {
int x __attribute__((unlock_function)) = y; // \ int x __attribute__((unlock_function)) = y; // \
expected-warning {{'unlock_function' attribute only applies to functions and methods}} // expected-warning {{'unlock_function' attribute only applies to functions and methods}}
return x; return x;
}; };
int uf_test_var __attribute__((unlock_function)); // \ int uf_test_var __attribute__((unlock_function)); // \
expected-warning {{'unlock_function' attribute only applies to functions and methods}} // expected-warning {{'unlock_function' attribute only applies to functions and methods}}
class UfFoo { class UfFoo {
private: private:
int test_field __attribute__((unlock_function)); // \ int test_field __attribute__((unlock_function)); // \
expected-warning {{'unlock_function' attribute only applies to functions and methods}} // expected-warning {{'unlock_function' attribute only applies to functions and methods}}
void test_method() __attribute__((unlock_function)); void test_method() __attribute__((unlock_function));
}; };
class __attribute__((no_thread_safety_analysis)) UfTestClass { // \ class __attribute__((no_thread_safety_analysis)) UfTestClass { // \
expected-warning {{'no_thread_safety_analysis' attribute only applies to functions and methods}} // expected-warning {{'no_thread_safety_analysis' attribute only applies to functions and methods}}
}; };
void uf_fun_params(int lvar __attribute__((unlock_function))); // \ void uf_fun_params(int lvar __attribute__((unlock_function))); // \
expected-warning {{'unlock_function' attribute only applies to functions and methods}} // expected-warning {{'unlock_function' attribute only applies to functions and methods}}
// Check argument parsing. // Check argument parsing.
@ -877,20 +877,20 @@ int uf_function_9(Mu x, Mu y) __attribute__((unlock_function(1,2)));
// illegal attribute arguments // illegal attribute arguments
int uf_function_bad_2() __attribute__((unlock_function("mu"))); // \ int uf_function_bad_2() __attribute__((unlock_function("mu"))); // \
expected-error {{'unlock_function' attribute requires arguments that are class type or point to class type}} // expected-error {{'unlock_function' attribute requires arguments that are class type or point to class type}}
int uf_function_bad_3() __attribute__((unlock_function(muDoublePointer))); // \ int uf_function_bad_3() __attribute__((unlock_function(muDoublePointer))); // \
expected-error {{'unlock_function' attribute requires arguments that are class type or point to class type}} // expected-error {{'unlock_function' attribute requires arguments that are class type or point to class type}}
int uf_function_bad_4() __attribute__((unlock_function(umu))); // \ int uf_function_bad_4() __attribute__((unlock_function(umu))); // \
expected-error {{'unlock_function' attribute requires arguments whose type is annotated with 'lockable' attribute}} // expected-error {{'unlock_function' attribute requires arguments whose type is annotated with 'lockable' attribute}}
int uf_function_bad_1() __attribute__((unlock_function(1))); // \ int uf_function_bad_1() __attribute__((unlock_function(1))); // \
expected-error {{'unlock_function' attribute parameter 1 is out of bounds: no parameters to index into}} // expected-error {{'unlock_function' attribute parameter 1 is out of bounds: no parameters to index into}}
int uf_function_bad_5(Mu x) __attribute__((unlock_function(0))); // \ int uf_function_bad_5(Mu x) __attribute__((unlock_function(0))); // \
expected-error {{'unlock_function' attribute parameter 1 is out of bounds: can only be 1, since there is one parameter}} // expected-error {{'unlock_function' attribute parameter 1 is out of bounds: can only be 1, since there is one parameter}}
int uf_function_bad_6(Mu x, Mu y) __attribute__((unlock_function(0))); // \ int uf_function_bad_6(Mu x, Mu y) __attribute__((unlock_function(0))); // \
expected-error {{'unlock_function' attribute parameter 1 is out of bounds: must be between 1 and 2}} // expected-error {{'unlock_function' attribute parameter 1 is out of bounds: must be between 1 and 2}}
int uf_function_bad_7() __attribute__((unlock_function(0))); // \ int uf_function_bad_7() __attribute__((unlock_function(0))); // \
expected-error {{'unlock_function' attribute parameter 1 is out of bounds: no parameters to index into}} // expected-error {{'unlock_function' attribute parameter 1 is out of bounds: no parameters to index into}}
//-----------------------------------------// //-----------------------------------------//
@ -904,36 +904,36 @@ int uf_function_bad_7() __attribute__((unlock_function(0))); // \
// Takes exactly one argument, a var/field // Takes exactly one argument, a var/field
void lr_function() __attribute__((lock_returned)); // \ void lr_function() __attribute__((lock_returned)); // \
expected-error {{attribute takes one argument}} // expected-error {{attribute takes one argument}}
void lr_function_arg() __attribute__((lock_returned(mu1))); void lr_function_arg() __attribute__((lock_returned(mu1)));
void lr_function_args() __attribute__((lock_returned(mu1, mu2))); // \ void lr_function_args() __attribute__((lock_returned(mu1, mu2))); // \
expected-error {{attribute takes one argument}} // expected-error {{attribute takes one argument}}
int lr_testfn(int y) __attribute__((lock_returned(mu1))); int lr_testfn(int y) __attribute__((lock_returned(mu1)));
int lr_testfn(int y) { int lr_testfn(int y) {
int x __attribute__((lock_returned(mu1))) = y; // \ int x __attribute__((lock_returned(mu1))) = y; // \
expected-warning {{'lock_returned' attribute only applies to functions and methods}} // expected-warning {{'lock_returned' attribute only applies to functions and methods}}
return x; return x;
}; };
int lr_test_var __attribute__((lock_returned(mu1))); // \ int lr_test_var __attribute__((lock_returned(mu1))); // \
expected-warning {{'lock_returned' attribute only applies to functions and methods}} // expected-warning {{'lock_returned' attribute only applies to functions and methods}}
void lr_fun_params(int lvar __attribute__((lock_returned(mu1)))); // \ void lr_fun_params(int lvar __attribute__((lock_returned(mu1)))); // \
expected-warning {{'lock_returned' attribute only applies to functions and methods}} // expected-warning {{'lock_returned' attribute only applies to functions and methods}}
class LrFoo { class LrFoo {
private: private:
int test_field __attribute__((lock_returned(mu1))); // \ int test_field __attribute__((lock_returned(mu1))); // \
expected-warning {{'lock_returned' attribute only applies to functions and methods}} // expected-warning {{'lock_returned' attribute only applies to functions and methods}}
void test_method() __attribute__((lock_returned(mu1))); void test_method() __attribute__((lock_returned(mu1)));
}; };
class __attribute__((lock_returned(mu1))) LrTestClass { // \ class __attribute__((lock_returned(mu1))) LrTestClass { // \
expected-warning {{'lock_returned' attribute only applies to functions and methods}} // expected-warning {{'lock_returned' attribute only applies to functions and methods}}
}; };
// Check argument parsing. // Check argument parsing.
@ -951,13 +951,13 @@ int lr_function_8() __attribute__((lock_returned(muPointer)));
// illegal attribute arguments // illegal attribute arguments
int lr_function_bad_1() __attribute__((lock_returned(1))); // \ int lr_function_bad_1() __attribute__((lock_returned(1))); // \
expected-error {{'lock_returned' attribute requires arguments that are class type or point to class type}} // expected-error {{'lock_returned' attribute requires arguments that are class type or point to class type}}
int lr_function_bad_2() __attribute__((lock_returned("mu"))); // \ int lr_function_bad_2() __attribute__((lock_returned("mu"))); // \
expected-error {{'lock_returned' attribute requires arguments that are class type or point to class type}} // expected-error {{'lock_returned' attribute requires arguments that are class type or point to class type}}
int lr_function_bad_3() __attribute__((lock_returned(muDoublePointer))); // \ int lr_function_bad_3() __attribute__((lock_returned(muDoublePointer))); // \
expected-error {{'lock_returned' attribute requires arguments that are class type or point to class type}} // expected-error {{'lock_returned' attribute requires arguments that are class type or point to class type}}
int lr_function_bad_4() __attribute__((lock_returned(umu))); // \ int lr_function_bad_4() __attribute__((lock_returned(umu))); // \
expected-error {{'lock_returned' attribute requires arguments whose type is annotated with 'lockable' attribute}} // expected-error {{'lock_returned' attribute requires arguments whose type is annotated with 'lockable' attribute}}
@ -972,7 +972,7 @@ int lr_function_bad_4() __attribute__((lock_returned(umu))); // \
// takes one or more arguments, all locks (vars/fields) // takes one or more arguments, all locks (vars/fields)
void le_function() __attribute__((locks_excluded)); // \ void le_function() __attribute__((locks_excluded)); // \
expected-error {{attribute takes at least 1 argument}} // expected-error {{attribute takes at least 1 argument}}
void le_function_arg() __attribute__((locks_excluded(mu1))); void le_function_arg() __attribute__((locks_excluded(mu1)));
@ -982,25 +982,25 @@ int le_testfn(int y) __attribute__((locks_excluded(mu1)));
int le_testfn(int y) { int le_testfn(int y) {
int x __attribute__((locks_excluded(mu1))) = y; // \ int x __attribute__((locks_excluded(mu1))) = y; // \
expected-warning {{'locks_excluded' attribute only applies to functions and methods}} // expected-warning {{'locks_excluded' attribute only applies to functions and methods}}
return x; return x;
}; };
int le_test_var __attribute__((locks_excluded(mu1))); // \ int le_test_var __attribute__((locks_excluded(mu1))); // \
expected-warning {{'locks_excluded' attribute only applies to functions and methods}} // expected-warning {{'locks_excluded' attribute only applies to functions and methods}}
void le_fun_params(int lvar __attribute__((locks_excluded(mu1)))); // \ void le_fun_params(int lvar __attribute__((locks_excluded(mu1)))); // \
expected-warning {{'locks_excluded' attribute only applies to functions and methods}} // expected-warning {{'locks_excluded' attribute only applies to functions and methods}}
class LeFoo { class LeFoo {
private: private:
int test_field __attribute__((locks_excluded(mu1))); // \ int test_field __attribute__((locks_excluded(mu1))); // \
expected-warning {{'locks_excluded' attribute only applies to functions and methods}} // expected-warning {{'locks_excluded' attribute only applies to functions and methods}}
void test_method() __attribute__((locks_excluded(mu1))); void test_method() __attribute__((locks_excluded(mu1)));
}; };
class __attribute__((locks_excluded(mu1))) LeTestClass { // \ class __attribute__((locks_excluded(mu1))) LeTestClass { // \
expected-warning {{'locks_excluded' attribute only applies to functions and methods}} // expected-warning {{'locks_excluded' attribute only applies to functions and methods}}
}; };
// Check argument parsing. // Check argument parsing.
@ -1018,13 +1018,13 @@ int le_function_8() __attribute__((locks_excluded(muPointer)));
// illegal attribute arguments // illegal attribute arguments
int le_function_bad_1() __attribute__((locks_excluded(1))); // \ int le_function_bad_1() __attribute__((locks_excluded(1))); // \
expected-error {{'locks_excluded' attribute requires arguments that are class type or point to class type}} // expected-error {{'locks_excluded' attribute requires arguments that are class type or point to class type}}
int le_function_bad_2() __attribute__((locks_excluded("mu"))); // \ int le_function_bad_2() __attribute__((locks_excluded("mu"))); // \
expected-error {{'locks_excluded' attribute requires arguments that are class type or point to class type}} // expected-error {{'locks_excluded' attribute requires arguments that are class type or point to class type}}
int le_function_bad_3() __attribute__((locks_excluded(muDoublePointer))); // \ int le_function_bad_3() __attribute__((locks_excluded(muDoublePointer))); // \
expected-error {{'locks_excluded' attribute requires arguments that are class type or point to class type}} // expected-error {{'locks_excluded' attribute requires arguments that are class type or point to class type}}
int le_function_bad_4() __attribute__((locks_excluded(umu))); // \ int le_function_bad_4() __attribute__((locks_excluded(umu))); // \
expected-error {{'locks_excluded' attribute requires arguments whose type is annotated with 'lockable' attribute}} // expected-error {{'locks_excluded' attribute requires arguments whose type is annotated with 'lockable' attribute}}
@ -1039,7 +1039,7 @@ int le_function_bad_4() __attribute__((locks_excluded(umu))); // \
// takes one or more arguments, all locks (vars/fields) // takes one or more arguments, all locks (vars/fields)
void elr_function() __attribute__((exclusive_locks_required)); // \ void elr_function() __attribute__((exclusive_locks_required)); // \
expected-error {{attribute takes at least 1 argument}} // expected-error {{attribute takes at least 1 argument}}
void elr_function_arg() __attribute__((exclusive_locks_required(mu1))); void elr_function_arg() __attribute__((exclusive_locks_required(mu1)));
@ -1049,25 +1049,25 @@ int elr_testfn(int y) __attribute__((exclusive_locks_required(mu1)));
int elr_testfn(int y) { int elr_testfn(int y) {
int x __attribute__((exclusive_locks_required(mu1))) = y; // \ int x __attribute__((exclusive_locks_required(mu1))) = y; // \
expected-warning {{'exclusive_locks_required' attribute only applies to functions and methods}} // expected-warning {{'exclusive_locks_required' attribute only applies to functions and methods}}
return x; return x;
}; };
int elr_test_var __attribute__((exclusive_locks_required(mu1))); // \ int elr_test_var __attribute__((exclusive_locks_required(mu1))); // \
expected-warning {{'exclusive_locks_required' attribute only applies to functions and methods}} // expected-warning {{'exclusive_locks_required' attribute only applies to functions and methods}}
void elr_fun_params(int lvar __attribute__((exclusive_locks_required(mu1)))); // \ void elr_fun_params(int lvar __attribute__((exclusive_locks_required(mu1)))); // \
expected-warning {{'exclusive_locks_required' attribute only applies to functions and methods}} // expected-warning {{'exclusive_locks_required' attribute only applies to functions and methods}}
class ElrFoo { class ElrFoo {
private: private:
int test_field __attribute__((exclusive_locks_required(mu1))); // \ int test_field __attribute__((exclusive_locks_required(mu1))); // \
expected-warning {{'exclusive_locks_required' attribute only applies to functions and methods}} // expected-warning {{'exclusive_locks_required' attribute only applies to functions and methods}}
void test_method() __attribute__((exclusive_locks_required(mu1))); void test_method() __attribute__((exclusive_locks_required(mu1)));
}; };
class __attribute__((exclusive_locks_required(mu1))) ElrTestClass { // \ class __attribute__((exclusive_locks_required(mu1))) ElrTestClass { // \
expected-warning {{'exclusive_locks_required' attribute only applies to functions and methods}} // expected-warning {{'exclusive_locks_required' attribute only applies to functions and methods}}
}; };
// Check argument parsing. // Check argument parsing.
@ -1085,13 +1085,13 @@ int elr_function_8() __attribute__((exclusive_locks_required(muPointer)));
// illegal attribute arguments // illegal attribute arguments
int elr_function_bad_1() __attribute__((exclusive_locks_required(1))); // \ int elr_function_bad_1() __attribute__((exclusive_locks_required(1))); // \
expected-error {{'exclusive_locks_required' attribute requires arguments that are class type or point to class type}} // expected-error {{'exclusive_locks_required' attribute requires arguments that are class type or point to class type}}
int elr_function_bad_2() __attribute__((exclusive_locks_required("mu"))); // \ int elr_function_bad_2() __attribute__((exclusive_locks_required("mu"))); // \
expected-error {{'exclusive_locks_required' attribute requires arguments that are class type or point to class type}} // expected-error {{'exclusive_locks_required' attribute requires arguments that are class type or point to class type}}
int elr_function_bad_3() __attribute__((exclusive_locks_required(muDoublePointer))); // \ int elr_function_bad_3() __attribute__((exclusive_locks_required(muDoublePointer))); // \
expected-error {{'exclusive_locks_required' attribute requires arguments that are class type or point to class type}} // expected-error {{'exclusive_locks_required' attribute requires arguments that are class type or point to class type}}
int elr_function_bad_4() __attribute__((exclusive_locks_required(umu))); // \ int elr_function_bad_4() __attribute__((exclusive_locks_required(umu))); // \
expected-error {{'exclusive_locks_required' attribute requires arguments whose type is annotated with 'lockable' attribute}} // expected-error {{'exclusive_locks_required' attribute requires arguments whose type is annotated with 'lockable' attribute}}
@ -1107,7 +1107,7 @@ int elr_function_bad_4() __attribute__((exclusive_locks_required(umu))); // \
// takes one or more arguments, all locks (vars/fields) // takes one or more arguments, all locks (vars/fields)
void slr_function() __attribute__((shared_locks_required)); // \ void slr_function() __attribute__((shared_locks_required)); // \
expected-error {{attribute takes at least 1 argument}} // expected-error {{attribute takes at least 1 argument}}
void slr_function_arg() __attribute__((shared_locks_required(mu1))); void slr_function_arg() __attribute__((shared_locks_required(mu1)));
@ -1117,25 +1117,25 @@ int slr_testfn(int y) __attribute__((shared_locks_required(mu1)));
int slr_testfn(int y) { int slr_testfn(int y) {
int x __attribute__((shared_locks_required(mu1))) = y; // \ int x __attribute__((shared_locks_required(mu1))) = y; // \
expected-warning {{'shared_locks_required' attribute only applies to functions and methods}} // expected-warning {{'shared_locks_required' attribute only applies to functions and methods}}
return x; return x;
}; };
int slr_test_var __attribute__((shared_locks_required(mu1))); // \ int slr_test_var __attribute__((shared_locks_required(mu1))); // \
expected-warning {{'shared_locks_required' attribute only applies to functions and methods}} // expected-warning {{'shared_locks_required' attribute only applies to functions and methods}}
void slr_fun_params(int lvar __attribute__((shared_locks_required(mu1)))); // \ void slr_fun_params(int lvar __attribute__((shared_locks_required(mu1)))); // \
expected-warning {{'shared_locks_required' attribute only applies to functions and methods}} // expected-warning {{'shared_locks_required' attribute only applies to functions and methods}}
class SlrFoo { class SlrFoo {
private: private:
int test_field __attribute__((shared_locks_required(mu1))); // \ int test_field __attribute__((shared_locks_required(mu1))); // \
expected-warning {{'shared_locks_required' attribute only applies to functions and methods}} // expected-warning {{'shared_locks_required' attribute only applies to functions and methods}}
void test_method() __attribute__((shared_locks_required(mu1))); void test_method() __attribute__((shared_locks_required(mu1)));
}; };
class __attribute__((shared_locks_required(mu1))) SlrTestClass { // \ class __attribute__((shared_locks_required(mu1))) SlrTestClass { // \
expected-warning {{'shared_locks_required' attribute only applies to functions and methods}} // expected-warning {{'shared_locks_required' attribute only applies to functions and methods}}
}; };
// Check argument parsing. // Check argument parsing.
@ -1153,13 +1153,13 @@ int slr_function_8() __attribute__((shared_locks_required(muPointer)));
// illegal attribute arguments // illegal attribute arguments
int slr_function_bad_1() __attribute__((shared_locks_required(1))); // \ int slr_function_bad_1() __attribute__((shared_locks_required(1))); // \
expected-error {{'shared_locks_required' attribute requires arguments that are class type or point to class type}} // expected-error {{'shared_locks_required' attribute requires arguments that are class type or point to class type}}
int slr_function_bad_2() __attribute__((shared_locks_required("mu"))); // \ int slr_function_bad_2() __attribute__((shared_locks_required("mu"))); // \
expected-error {{'shared_locks_required' attribute requires arguments that are class type or point to class type}} // expected-error {{'shared_locks_required' attribute requires arguments that are class type or point to class type}}
int slr_function_bad_3() __attribute__((shared_locks_required(muDoublePointer))); // \ int slr_function_bad_3() __attribute__((shared_locks_required(muDoublePointer))); // \
expected-error {{'shared_locks_required' attribute requires arguments that are class type or point to class type}} // expected-error {{'shared_locks_required' attribute requires arguments that are class type or point to class type}}
int slr_function_bad_4() __attribute__((shared_locks_required(umu))); // \ int slr_function_bad_4() __attribute__((shared_locks_required(umu))); // \
expected-error {{'shared_locks_required' attribute requires arguments whose type is annotated with 'lockable' attribute}} // expected-error {{'shared_locks_required' attribute requires arguments whose type is annotated with 'lockable' attribute}}
//-----------------------------------------// //-----------------------------------------//
@ -1238,7 +1238,7 @@ public:
void foo4(FooLate *f) __attribute__((exclusive_locks_required(f->mu))); void foo4(FooLate *f) __attribute__((exclusive_locks_required(f->mu)));
static void foo5() __attribute__((exclusive_locks_required(mu))); // \ static void foo5() __attribute__((exclusive_locks_required(mu))); // \
expected-error {{invalid use of member 'mu' in static member function}} // expected-error {{invalid use of member 'mu' in static member function}}
template <class T> template <class T>
void foo6() __attribute__((exclusive_locks_required(T::statmu))) { } void foo6() __attribute__((exclusive_locks_required(T::statmu))) { }