1 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 -Wthread-safety -Wthread-safety-beta -Wthread-safety-negative -fcxx-exceptions %s
2 
3 // FIXME: should also run  %clang_cc1 -fsyntax-only -verify -Wthread-safety -std=c++11 -Wc++98-compat %s
4 // FIXME: should also run  %clang_cc1 -fsyntax-only -verify -Wthread-safety %s
5 
6 #define LOCKABLE            __attribute__ ((lockable))
7 #define SCOPED_LOCKABLE     __attribute__ ((scoped_lockable))
8 #define GUARDED_BY(x)       __attribute__ ((guarded_by(x)))
9 #define GUARDED_VAR         __attribute__ ((guarded_var))
10 #define PT_GUARDED_BY(x)    __attribute__ ((pt_guarded_by(x)))
11 #define PT_GUARDED_VAR      __attribute__ ((pt_guarded_var))
12 #define ACQUIRED_AFTER(...) __attribute__ ((acquired_after(__VA_ARGS__)))
13 #define ACQUIRED_BEFORE(...) __attribute__ ((acquired_before(__VA_ARGS__)))
14 #define EXCLUSIVE_LOCK_FUNCTION(...)    __attribute__ ((exclusive_lock_function(__VA_ARGS__)))
15 #define SHARED_LOCK_FUNCTION(...)       __attribute__ ((shared_lock_function(__VA_ARGS__)))
16 #define ASSERT_EXCLUSIVE_LOCK(...)      __attribute__ ((assert_exclusive_lock(__VA_ARGS__)))
17 #define ASSERT_SHARED_LOCK(...)         __attribute__ ((assert_shared_lock(__VA_ARGS__)))
18 #define EXCLUSIVE_TRYLOCK_FUNCTION(...) __attribute__ ((exclusive_trylock_function(__VA_ARGS__)))
19 #define SHARED_TRYLOCK_FUNCTION(...)    __attribute__ ((shared_trylock_function(__VA_ARGS__)))
20 #define UNLOCK_FUNCTION(...)            __attribute__ ((unlock_function(__VA_ARGS__)))
21 #define LOCK_RETURNED(x)    __attribute__ ((lock_returned(x)))
22 #define LOCKS_EXCLUDED(...) __attribute__ ((locks_excluded(__VA_ARGS__)))
23 #define EXCLUSIVE_LOCKS_REQUIRED(...) \
24   __attribute__ ((exclusive_locks_required(__VA_ARGS__)))
25 #define SHARED_LOCKS_REQUIRED(...) \
26   __attribute__ ((shared_locks_required(__VA_ARGS__)))
27 #define NO_THREAD_SAFETY_ANALYSIS  __attribute__ ((no_thread_safety_analysis))
28 
29 
30 class  __attribute__((lockable)) Mutex {
31  public:
32   void Lock() __attribute__((exclusive_lock_function));
33   void ReaderLock() __attribute__((shared_lock_function));
34   void Unlock() __attribute__((unlock_function));
35   bool TryLock() __attribute__((exclusive_trylock_function(true)));
36   bool ReaderTryLock() __attribute__((shared_trylock_function(true)));
37   void LockWhen(const int &cond) __attribute__((exclusive_lock_function));
38 
39   // for negative capabilities
operator !() const40   const Mutex& operator!() const { return *this; }
41 
42   void AssertHeld()       ASSERT_EXCLUSIVE_LOCK();
43   void AssertReaderHeld() ASSERT_SHARED_LOCK();
44 };
45 
46 
47 namespace SimpleTest {
48 
49 class Bar {
50   Mutex mu;
51   int a GUARDED_BY(mu);
52 
53 public:
baz()54   void baz() EXCLUSIVE_LOCKS_REQUIRED(!mu) {
55     mu.Lock();
56     a = 0;
57     mu.Unlock();
58   }
59 };
60 
61 
62 class Foo {
63   Mutex mu;
64   int a GUARDED_BY(mu);
65 
66 public:
foo()67   void foo() {
68     mu.Lock();    // expected-warning {{acquiring mutex 'mu' requires negative capability '!mu'}}
69     baz();        // expected-warning {{cannot call function 'baz' while mutex 'mu' is held}}
70     bar();
71     mu.Unlock();
72   }
73 
bar()74   void bar() {
75     baz();        // expected-warning {{calling function 'baz' requires holding  '!mu'}}
76   }
77 
baz()78   void baz() EXCLUSIVE_LOCKS_REQUIRED(!mu) {
79     mu.Lock();
80     a = 0;
81     mu.Unlock();
82   }
83 
test()84   void test() {
85     Bar b;
86     b.baz();     // no warning -- in different class.
87   }
88 
test2()89   void test2() {
90     mu.Lock();   // expected-warning {{acquiring mutex 'mu' requires negative capability '!mu'}}
91     a = 0;
92     mu.Unlock();
93     baz();       // no warning -- !mu in set.
94   }
95 
test3()96   void test3() EXCLUSIVE_LOCKS_REQUIRED(!mu) {
97     mu.Lock();
98     a = 0;
99     mu.Unlock();
100     baz();       // no warning -- !mu in set.
101   }
102 };
103 
104 }  // end namespace SimpleTest
105 
106 namespace DoubleAttribute {
107 
108 struct Foo {
109   Mutex &mutex();
110 };
111 
112 template <typename A>
113 class TemplateClass {
114   template <typename B>
Function(Foo * F)115   static void Function(Foo *F)
116       EXCLUSIVE_LOCKS_REQUIRED(F->mutex()) UNLOCK_FUNCTION(F->mutex()) {}
117 };
118 
test()119 void test() { TemplateClass<int> TC; }
120 
121 }  // end namespace DoubleAttribute
122