From bc1f11162a36397ef6b29c50ec585c14c42cd604 Mon Sep 17 00:00:00 2001 From: Caitlin Sadowski Date: Thu, 8 Sep 2011 18:07:26 +0000 Subject: [PATCH] Thread safety: small formatting change in test comments llvm-svn: 139306 --- .../SemaCXX/warn-thread-safety-analysis.cpp | 89 +++-- .../SemaCXX/warn-thread-safety-parsing.cpp | 362 +++++++++--------- 2 files changed, 225 insertions(+), 226 deletions(-) diff --git a/clang/test/SemaCXX/warn-thread-safety-analysis.cpp b/clang/test/SemaCXX/warn-thread-safety-analysis.cpp index 6483a90a3c04..4990627728f6 100644 --- a/clang/test/SemaCXX/warn-thread-safety-analysis.cpp +++ b/clang/test/SemaCXX/warn-thread-safety-analysis.cpp @@ -39,7 +39,6 @@ void sls_fun_0() { sls_mw.mu.Unlock(); } - void sls_fun_2() { sls_mu.Lock(); int x = sls_guard_var; @@ -124,33 +123,33 @@ void sls_fun_good_7() { void sls_fun_bad_1() { 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() { 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(); } void sls_fun_bad_3() { 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() { if (getBool()) 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 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() { 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()) sls_mu.Unlock(); } @@ -158,7 +157,7 @@ void sls_fun_bad_5() { void sls_fun_bad_6() { if (getBool()) { 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 { if (getBool()) { getBool(); // EMPTY @@ -167,13 +166,13 @@ void sls_fun_bad_6() { } } 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() { sls_mu.Lock(); 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(); if (getBool()) { if (getBool()) { @@ -181,7 +180,7 @@ void sls_fun_bad_7() { } } 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(); } @@ -190,23 +189,23 @@ void sls_fun_bad_8() { sls_mu.Lock(); do { 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()); } void sls_fun_bad_9() { do { 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()); sls_mu.Unlock(); } void sls_fun_bad_10() { 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()) { // \ - 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(); } } @@ -214,10 +213,10 @@ void sls_fun_bad_10() { void sls_fun_bad_11() { while (getBool()) { 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(); // \ - 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() { 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() { glock.globalLock(); glock.globalLock(); // \ - expected-warning {{locking 'aa_mu' that is already acquired}} + // expected-warning{{locking 'aa_mu' that is already acquired}} glock.globalUnlock(); } void aa_fun_bad_3() { 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 { WeirdMethods() { 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() { 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++() { 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*() { 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; } }; @@ -307,13 +306,13 @@ class PGBFoo { __attribute__((pt_guarded_by(sls_mu))); void testFoo() { 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'}} \ - 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'}} \ - 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'}} \ - 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() { 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() { 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() { 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() { 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() { 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() { *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() { 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() { *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() { 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() { GBFoo G; 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() { 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--; // \ - expected-warning {{accessing variable 'sls_guard_var' requires some lock}} + // expected-warning{{accessing variable 'sls_guard_var' requires some lock}} ++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; // \ - 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() { a = 0; // \ - expected-warning {{accessing variable 'a' requires lock 'mu'}} + // expected-warning{{accessing variable 'a' requires lock 'mu'}} b = a; // \ - expected-warning {{accessing variable 'a' requires lock 'mu'}} + // expected-warning {{accessing variable 'a' requires lock 'mu'}} c = 0; // \ - expected-warning {{accessing variable 'c' requires lock 'mu'}} + // expected-warning {{accessing variable 'c' requires lock 'mu'}} } int c __attribute__((guarded_by(mu))); diff --git a/clang/test/SemaCXX/warn-thread-safety-parsing.cpp b/clang/test/SemaCXX/warn-thread-safety-parsing.cpp index 8fcac408e374..67882d08996e 100644 --- a/clang/test/SemaCXX/warn-thread-safety-parsing.cpp +++ b/clang/test/SemaCXX/warn-thread-safety-parsing.cpp @@ -76,32 +76,32 @@ class Bar { void noanal_fun() __attribute__((no_thread_safety_analysis)); 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) { 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; }; 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 { private: 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)); }; 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))); // \ - 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_args __attribute__((guarded_var(1))); // \ - expected-error {{attribute takes no arguments}} + // expected-error {{attribute takes no arguments}} class GVFoo { private: int gv_field_noargs __attribute__((guarded_var)); 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 { // \ - 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)); // \ - 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))); // \ - 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 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; } @@ -153,34 +153,34 @@ int gv_testfn(int y){ int *pgv_pt_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 { private: int *pt_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))); // \ - expected-error {{attribute takes no arguments}} + // expected-error {{attribute takes no arguments}} }; 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))); // \ - expected-error {{attribute takes no arguments}} + // expected-error {{attribute takes no arguments}} 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))); // \ - 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){ 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; } @@ -198,32 +198,32 @@ class __attribute__((lockable)) LTestClass { }; class __attribute__((lockable (1))) LTestClass_args { // \ - expected-error {{attribute takes no arguments}} + // expected-error {{attribute takes no arguments}} }; 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 x __attribute__((lockable)) = y; // \ - expected-warning {{'lockable' attribute only applies to classes}} + // expected-warning {{'lockable' attribute only applies to classes}} return x; } int l_test_var __attribute__((lockable)); // \ - expected-warning {{'lockable' attribute only applies to classes}} + // expected-warning {{'lockable' attribute only applies to classes}} class LFoo { private: 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)); // \ - expected-warning {{'lockable' attribute only applies to classes}} + // expected-warning {{'lockable' attribute only applies to classes}} }; 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 { // \ - expected-error {{attribute takes no arguments}} + // expected-error {{attribute takes no arguments}} }; 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 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; } 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 { private: 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)); // \ - 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))); // \ - 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_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)); // \ - expected-error {{attribute takes one argument}} + // expected-error {{attribute takes one argument}} class GBFoo { private: 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))); }; 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))); // \ - 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)))); // \ - 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 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; } @@ -324,13 +324,13 @@ int gb_var_arg_8 __attribute__((guarded_by(muPointer))); // illegal attribute arguments 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"))); // \ - 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))); // \ - 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))); // \ - 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. // 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 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_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))); // \ - 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 { private: 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))); }; 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))); // \ - 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)))); // \ - 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){ 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; } @@ -395,13 +395,13 @@ int * pgb_var_arg_8 __attribute__((pt_guarded_by(muPointer))); // illegal attribute arguments 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"))); // \ - 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))); // \ - 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))); // \ - 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 aa_var_noargs __attribute__((acquired_after)); // \ - expected-error {{attribute takes at least 1 argument}} + // expected-error {{attribute takes at least 1 argument}} class AAFoo { private: 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))); }; 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))); // \ - 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)))); // \ - 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){ 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. @@ -456,15 +456,15 @@ Mu aa_var_arg_8 __attribute__((acquired_after(muPointer))); // illegal attribute arguments 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"))); // \ - 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))); // \ - 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))); // \ - 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))); // \ - 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) @@ -477,28 +477,28 @@ UnlockableMu aa_var_arg_bad_5 __attribute__((acquired_after(mu_aa))); // \ Mu mu_ab __attribute__((acquired_before(mu1))); 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 { private: 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))); }; 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))); // \ - 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)))); // \ - 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){ 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 @@ -519,15 +519,15 @@ Mu ab_var_arg_8 __attribute__((acquired_before(muPointer))); // illegal attribute arguments 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"))); // \ - 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))); // \ - 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))); // \ - 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))); // \ - 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 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; }; 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 { private: 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)); }; 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))); // \ - 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. @@ -586,20 +586,20 @@ int elf_function_9(Mu x, Mu y) __attribute__((exclusive_lock_function(1,2))); // illegal attribute arguments 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))); // \ - 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))); // \ - 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))); // \ - 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))); // \ - 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))); // \ - 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))); // \ - 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 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; }; 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))); // \ - 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 { private: 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)); }; 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. @@ -658,20 +658,20 @@ int slf_function_9(Mu x, Mu y) __attribute__((shared_lock_function(1,2))); // illegal attribute arguments 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))); // \ - 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))); // \ - 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))); // \ - 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))); // \ - 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))); // \ - 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))); // \ - 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) 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))); @@ -696,26 +696,26 @@ int etf_testfn(int y) __attribute__((exclusive_trylock_function(1))); int etf_testfn(int 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; }; 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 { private: 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))); }; 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)))); // \ - 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. @@ -733,18 +733,18 @@ int etf_function_9() __attribute__((exclusive_trylock_function(true))); // illegal attribute arguments 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"))); // \ - 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))); // \ - 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"))); // \ - 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))); // \ - 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))); // \ - 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) 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))); @@ -769,26 +769,26 @@ int stf_testfn(int y) __attribute__((shared_trylock_function(1))); int stf_testfn(int 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; }; 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)))); // \ - 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 { private: 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))); }; 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. @@ -807,18 +807,18 @@ int stf_function_9() __attribute__((shared_trylock_function(true))); // illegal attribute arguments 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"))); // \ - 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))); // \ - 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"))); // \ - 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))); // \ - 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))); // \ - 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 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; }; 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 { private: 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)); }; 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))); // \ - 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. @@ -877,20 +877,20 @@ int uf_function_9(Mu x, Mu y) __attribute__((unlock_function(1,2))); // illegal attribute arguments 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))); // \ -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))); // \ - 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))); // \ - 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))); // \ - 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))); // \ - 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))); // \ - 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 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_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) { 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; }; 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)))); // \ - expected-warning {{'lock_returned' attribute only applies to functions and methods}} + // expected-warning {{'lock_returned' attribute only applies to functions and methods}} class LrFoo { private: 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))); }; 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. @@ -951,13 +951,13 @@ int lr_function_8() __attribute__((lock_returned(muPointer))); // illegal attribute arguments 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"))); // \ - 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))); // \ - 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))); // \ - 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) 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))); @@ -982,25 +982,25 @@ int le_testfn(int y) __attribute__((locks_excluded(mu1))); int le_testfn(int 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; }; 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)))); // \ - expected-warning {{'locks_excluded' attribute only applies to functions and methods}} + // expected-warning {{'locks_excluded' attribute only applies to functions and methods}} class LeFoo { private: 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))); }; 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. @@ -1018,13 +1018,13 @@ int le_function_8() __attribute__((locks_excluded(muPointer))); // illegal attribute arguments 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"))); // \ - 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))); // \ - 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))); // \ - 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) 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))); @@ -1049,25 +1049,25 @@ int elr_testfn(int y) __attribute__((exclusive_locks_required(mu1))); int elr_testfn(int 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; }; 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)))); // \ - 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 { private: 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))); }; 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. @@ -1085,13 +1085,13 @@ int elr_function_8() __attribute__((exclusive_locks_required(muPointer))); // illegal attribute arguments 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"))); // \ - 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))); // \ - 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))); // \ - 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) 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))); @@ -1117,25 +1117,25 @@ int slr_testfn(int y) __attribute__((shared_locks_required(mu1))); int slr_testfn(int 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; }; 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)))); // \ - 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 { private: 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))); }; 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. @@ -1153,13 +1153,13 @@ int slr_function_8() __attribute__((shared_locks_required(muPointer))); // illegal attribute arguments 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"))); // \ - 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))); // \ - 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))); // \ - 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))); 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 void foo6() __attribute__((exclusive_locks_required(T::statmu))) { }