From: David Blaikie Date: Mon, 29 Jul 2013 18:24:03 +0000 (+0000) Subject: Support for Thread Safety Analysis in C X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=88c4b5efc604b982ca9083548d568b02b1abd2ab;p=clang Support for Thread Safety Analysis in C Patch by Ethan Jackson. git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@187365 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/lib/Lex/PPMacroExpansion.cpp b/lib/Lex/PPMacroExpansion.cpp index 899fba600d..a9d76c357c 100644 --- a/lib/Lex/PPMacroExpansion.cpp +++ b/lib/Lex/PPMacroExpansion.cpp @@ -902,6 +902,7 @@ static bool HasFeature(const Preprocessor &PP, const IdentifierInfo *II) { .Case("attribute_unavailable_with_message", true) .Case("attribute_unused_on_fields", true) .Case("blocks", LangOpts.Blocks) + .Case("c_thread_safety_attributes", true) .Case("cxx_exceptions", LangOpts.Exceptions) .Case("cxx_rtti", LangOpts.RTTI) .Case("enumerator_attributes", true) diff --git a/lib/Sema/SemaDeclAttr.cpp b/lib/Sema/SemaDeclAttr.cpp index d255b2916c..016c0f1c0b 100644 --- a/lib/Sema/SemaDeclAttr.cpp +++ b/lib/Sema/SemaDeclAttr.cpp @@ -597,7 +597,7 @@ static bool checkLockableAttrCommon(Sema &S, Decl *D, return false; // FIXME: Lockable structs for C code. - if (!isa(D)) { + if (!isa(D)) { S.Diag(Attr.getLoc(), diag::warn_thread_attribute_wrong_decl_type) << Attr.getName() << ThreadExpectedClassOrStruct; return false; diff --git a/test/Sema/warn-thread-safety-analysis.c b/test/Sema/warn-thread-safety-analysis.c new file mode 100644 index 0000000000..404374739b --- /dev/null +++ b/test/Sema/warn-thread-safety-analysis.c @@ -0,0 +1,125 @@ +// RUN: %clang -fsyntax-only -verify -Wthread-safety -Wthread-safety-beta -fcxx-exceptions %s + +#include + +#define LOCKABLE __attribute__ ((lockable)) +#define SCOPED_LOCKABLE __attribute__ ((scoped_lockable)) +#define GUARDED_BY(x) __attribute__ ((guarded_by(x))) +#define GUARDED_VAR __attribute__ ((guarded_var)) +#define PT_GUARDED_BY(x) __attribute__ ((pt_guarded_by(x))) +#define PT_GUARDED_VAR __attribute__ ((pt_guarded_var)) +#define ACQUIRED_AFTER(...) __attribute__ ((acquired_after(__VA_ARGS__))) +#define ACQUIRED_BEFORE(...) __attribute__ ((acquired_before(__VA_ARGS__))) +#define EXCLUSIVE_LOCK_FUNCTION(...) __attribute__ ((exclusive_lock_function(__VA_ARGS__))) +#define SHARED_LOCK_FUNCTION(...) __attribute__ ((shared_lock_function(__VA_ARGS__))) +#define ASSERT_EXCLUSIVE_LOCK(...) __attribute__ ((assert_exclusive_lock(__VA_ARGS__))) +#define ASSERT_SHARED_LOCK(...) __attribute__ ((assert_shared_lock(__VA_ARGS__))) +#define EXCLUSIVE_TRYLOCK_FUNCTION(...) __attribute__ ((exclusive_trylock_function(__VA_ARGS__))) +#define SHARED_TRYLOCK_FUNCTION(...) __attribute__ ((shared_trylock_function(__VA_ARGS__))) +#define UNLOCK_FUNCTION(...) __attribute__ ((unlock_function(__VA_ARGS__))) +#define LOCK_RETURNED(x) __attribute__ ((lock_returned(x))) +#define LOCKS_EXCLUDED(...) __attribute__ ((locks_excluded(__VA_ARGS__))) +#define EXCLUSIVE_LOCKS_REQUIRED(...) \ + __attribute__ ((exclusive_locks_required(__VA_ARGS__))) +#define SHARED_LOCKS_REQUIRED(...) \ + __attribute__ ((shared_locks_required(__VA_ARGS__))) +#define NO_THREAD_SAFETY_ANALYSIS __attribute__ ((no_thread_safety_analysis)) + +// Define the mutex struct. +// Simplified only for test purpose. +struct LOCKABLE Mutex {}; + +struct Foo { + struct Mutex *mu_; +}; + +// Define mutex lock/unlock functions. +void mutex_exclusive_lock(struct Mutex *mu) EXCLUSIVE_LOCK_FUNCTION(mu) { +} + +void mutex_shared_lock(struct Mutex *mu) SHARED_LOCK_FUNCTION(mu) { +} + +void mutex_unlock(struct Mutex *mu) UNLOCK_FUNCTION(mu) { +} + +// Define global variables. +struct Mutex mu1; +struct Mutex mu2 ACQUIRED_AFTER(mu1); +struct Foo foo_ = {&mu1}; +int a_ GUARDED_BY(foo_.mu_); +int *b_ PT_GUARDED_BY(foo_.mu_) = &a_; +int c_ GUARDED_VAR; +int *d_ PT_GUARDED_VAR = &c_; + +// Define test functions. +int Foo_fun1(int i) SHARED_LOCKS_REQUIRED(mu2) EXCLUSIVE_LOCKS_REQUIRED(mu1) { + return i; +} + +int Foo_fun2(int i) EXCLUSIVE_LOCKS_REQUIRED(mu2) SHARED_LOCKS_REQUIRED(mu1) { + return i; +} + +int Foo_func3(int i) LOCKS_EXCLUDED(mu1, mu2) { + return i; +} + +static int Bar_fun1(int i) EXCLUSIVE_LOCKS_REQUIRED(mu1) { + return i; +} + +void set_value(int *a, int value) EXCLUSIVE_LOCKS_REQUIRED(foo_.mu_) { + *a = value; +} + +int get_value(int *p) SHARED_LOCKS_REQUIRED(foo_.mu_){ + return *p; +} + +int main() { + + Foo_fun1(1); // expected-warning{{calling function 'Foo_fun1' requires shared lock on 'mu2'}} \ + expected-warning{{calling function 'Foo_fun1' requires exclusive lock on 'mu1'}} + + mutex_exclusive_lock(&mu1); + mutex_shared_lock(&mu2); + Foo_fun1(1); + + mutex_shared_lock(&mu1); // expected-warning{{locking 'mu1' that is already locked}} + mutex_unlock(&mu1); + mutex_unlock(&mu2); + mutex_shared_lock(&mu1); + mutex_exclusive_lock(&mu2); + Foo_fun2(2); + + mutex_unlock(&mu2); + mutex_unlock(&mu1); + mutex_exclusive_lock(&mu1); + Bar_fun1(3); + mutex_unlock(&mu1); + + mutex_exclusive_lock(&mu1); + Foo_func3(4); // expected-warning{{cannot call function 'Foo_func3' while mutex 'mu1' is locked}} + mutex_unlock(&mu1); + + Foo_func3(5); + + set_value(&a_, 0); // expected-warning{{calling function 'setA' requires exclusive lock on 'foo_.mu_'}} + get_value(b_); // expected-warning{{calling function 'getB' requires shared lock on 'foo_.mu_'}} + mutex_exclusive_lock(foo_.mu_); + set_value(&a_, 1); + mutex_unlock(foo_.mu_); + mutex_shared_lock(foo_.mu_); + assert(get_value(b_) == 1); + mutex_unlock(foo_.mu_); + + c_ = 0; // expected-warning{{writing variable 'c_' requires locking any mutex exclusively}} + assert(*d_ == 0); // expected-warning{{reading the value pointed to by 'd_' requires locking any mutex}} + mutex_exclusive_lock(foo_.mu_); + c_ = 1; + assert(*d_ == 1); + mutex_unlock(foo_.mu_); + + return 0; +}