diff --git a/clang/docs/LanguageExtensions.html b/clang/docs/LanguageExtensions.html
index 37ea0396e0e1434d2a3e63c438770ab5c41fae8a..804080d32668917971e9668560463953add9bde2 100644
--- a/clang/docs/LanguageExtensions.html
+++ b/clang/docs/LanguageExtensions.html
@@ -89,11 +89,24 @@
Static Analysis-Specific Extensions
Thread Safety Annotation Checking
@@ -1109,15 +1122,12 @@ For more details, see the
GCC implementation.
-guarded_var
-
-Use __attribute__((guarded_var)) on a variable declaration to
-specify that the variable must be accessed while holding some lock.
-
-pt_guarded_var
+no_thread_safety_analysis
-Use __attribute__((pt_guarded_var)) on a pointer declaration to
-specify that the pointer must be dereferenced while holding some lock.
+Use __attribute__((no_thread_safety_analysis)) on a function
+declaration to specify that the thread safety analysis should not be run on that
+function. This attribute provides an escape hatch (e.g. for situations when it
+is difficult to annotate the locking policy).
lockable
@@ -1133,12 +1143,119 @@ the lock upon construction and release it upon going out of scope.
This annotation is primarily used to check
consistency.
-no_thread_safety_analysis
+guarded_var
-Use __attribute__((no_thread_safety_analysis)) on a function
-declaration to specify that the thread safety analysis should not be run on that
-function. This attribute provides an escape hatch (e.g. for situations when it
-is difficult to annotate the locking policy).
+Use __attribute__((guarded_var)) on a variable declaration to
+specify that the variable must be accessed while holding some lock.
+
+pt_guarded_var
+
+Use __attribute__((pt_guarded_var)) on a pointer declaration to
+specify that the pointer must be dereferenced while holding some lock.
+
+guarded_by(l)
+
+Use __attribute__((guarded_by(l))) on a variable declaration to
+specify that the variable must be accessed while holding lock l.
+
+pt_guarded_by(l)
+
+Use __attribute__((pt_guarded_by(l))) on a pointer declaration to
+specify that the pointer must be dereferenced while holding lock l.
+
+acquired_before(...)
+
+Use __attribute__((acquired_before(...))) on a declaration
+of a lockable variable to specify that the lock must be acquired before all
+attribute arguments. Arguments must be lockable type, and there must be at
+least one argument.
+
+acquired_after(...)
+
+Use __attribute__((acquired_after(...))) on a declaration
+of a lockable variable to specify that the lock must be acquired after all
+attribute arguments. Arguments must be lockable type, and there must be at
+least one argument.
+
+exclusive_lock_function(...)
+
+Use __attribute__((exclusive_lock_function(...))) on a function
+declaration to specify that the function acquires all listed locks
+exclusively. This attribute takes zero or more
+arguments: either of lockable type or integers indexing into
+function parameters of lockable type. If no arguments are given, the acquired
+lock is implicitly this of the enclosing object.
+
+shared_lock_function(...)
+
+Use __attribute__((shared_lock_function(...))) on a function
+declaration to specify that the function acquires all listed locks, although
+ the locks may be shared (e.g. read locks).
+This attribute takes zero or more
+arguments: either of lockable type or integers indexing into
+function parameters of lockable type. If no arguments are given, the acquired
+lock is implicitly this of the enclosing object.
+
+exclusive_trylock_function(...)
+
+Use __attribute__((exclusive_lock_function(...))) on a function
+declaration to specify that the function will try (without blocking) to acquire
+all listed locks exclusively. This attribute takes one or more
+arguments. The first argument is an integer or boolean value specifying the
+return value of a successful lock acquisition. The remaining arugments are
+either of lockable type or integers indexing into
+function parameters of lockable type. If only one argument is given, the
+acquired lock is implicitly this of the enclosing object.
+
+shared_trylock_function(...)
+
+Use __attribute__((shared_lock_function(...))) on a function
+declaration to specify that the function will try (without blocking) to acquire
+all listed locks, although
+ the locks may be shared (e.g. read locks).
+This attribute takes one or more
+arguments. The first argument is an integer or boolean value specifying the
+return value of a successful lock acquisition. The remaining arugments are
+either of lockable type or integers indexing into
+function parameters of lockable type. If only one argument is given, the
+acquired lock is implicitly this of the enclosing object.
+
+unlock_function(...)
+
+Use __attribute__((unlock_function(...))) on a function
+declaration to specify that the function release all listed locks.
+ This attribute takes zero or more
+arguments: either of lockable type or integers indexing into
+function parameters of lockable type. If no arguments are given, the acquired
+lock is implicitly this of the enclosing object.
+
+lock_returned(l)
+
+Use __attribute__((lock_returned(l))) on a function
+declaration to specify that the function returns lock l (l must be of lockable
+type). This annotation is used
+to aid in resolving lock expressions.
+
+locks_excluded(...)
+
+Use __attribute__((locks_excluded(...))) on a function declaration
+to specify that the function must not be called with the listed locks.
+Arguments must be lockable type, and there must be at
+least one argument.
+
+exclusive_locks_required(...)
+
+Use __attribute__((exclusive_locks_required(...))) on a function
+declaration to specify that the function must be called while holding the listed
+exclusive locks. Arguments must be lockable type, and there must be at
+least one argument.
+
+shared_locks_required(...)
+
+Use __attribute__((shared_locks_required(...))) on a function
+declaration to specify that the function must be called while holding the listed
+shared locks. Arguments must be lockable type, and there must be at
+least one argument.
diff --git a/clang/include/clang/Basic/Attr.td b/clang/include/clang/Basic/Attr.td
index 8f52a5b246f3751dc34726b08df7e28c58260140..2b0ed3d6691254661b58e8b4cc8314dc439eda62 100644
--- a/clang/include/clang/Basic/Attr.td
+++ b/clang/include/clang/Basic/Attr.td
@@ -561,3 +561,55 @@ def ScopedLockable : InheritableAttr {
def NoThreadSafetyAnalysis : InheritableAttr {
let Spellings = ["no_thread_safety_analysis"];
}
+
+def GuardedBy : InheritableAttr {
+ let Spellings = ["guarded_by"];
+}
+
+def PtGuardedBy : InheritableAttr {
+ let Spellings = ["pt_guarded_by"];
+}
+
+def AcquiredAfter : InheritableAttr {
+ let Spellings = ["acquired_after"];
+}
+
+def AcquiredBefore : InheritableAttr {
+ let Spellings = ["acquired_before"];
+}
+
+def ExclusiveLockFunction : InheritableAttr {
+ let Spellings = ["exclusive_lock_function"];
+}
+
+def SharedLockFunction : InheritableAttr {
+ let Spellings = ["shared_lock_function"];
+}
+
+def ExclusiveTrylockFunction : InheritableAttr {
+ let Spellings = ["exclusive_trylock_function"];
+}
+
+def SharedTrylockFunction : InheritableAttr {
+ let Spellings = ["shared_trylock_function"];
+}
+
+def UnlockFunction : InheritableAttr {
+ let Spellings = ["unlock_function"];
+}
+
+def LockReturned : InheritableAttr {
+ let Spellings = ["lock_returned"];
+}
+
+def LocksExcluded : InheritableAttr {
+ let Spellings = ["locks_excluded"];
+}
+
+def ExclusiveLocksRequired : InheritableAttr {
+ let Spellings = ["exclusive_locks_required"];
+}
+
+def SharedLocksRequired : InheritableAttr {
+ let Spellings = ["shared_locks_required"];
+}
diff --git a/clang/include/clang/Basic/DiagnosticSemaKinds.td b/clang/include/clang/Basic/DiagnosticSemaKinds.td
index 1bb24a46fc87a40a19f2041efdf60c2d8ef2f255..660528a2c14697c8dc95226b774018f371b0f607 100644
--- a/clang/include/clang/Basic/DiagnosticSemaKinds.td
+++ b/clang/include/clang/Basic/DiagnosticSemaKinds.td
@@ -1128,6 +1128,8 @@ def err_attribute_wrong_number_arguments : Error<
":requires exactly %0 arguments}0">;
def err_attribute_too_many_arguments : Error<
"attribute takes no more than %0 argument%s0">;
+def err_attribute_too_few_arguments : Error<
+ "attribute takes at least %0 argument%s0">;
def err_iboutletcollection_type : Error<
"invalid type %0 as argument of iboutletcollection attribute">;
def err_iboutletcollection_object_type : Error<
diff --git a/clang/include/clang/Sema/AttributeList.h b/clang/include/clang/Sema/AttributeList.h
index d741e89bc8f4e43ec3a4be8018b15cc23df8f6ee..674e13a3dff7801cd19f779d65514b4628891485 100644
--- a/clang/include/clang/Sema/AttributeList.h
+++ b/clang/include/clang/Sema/AttributeList.h
@@ -152,6 +152,8 @@ private:
public:
enum Kind { // Please keep this list alphabetized.
+ AT_acquired_after,
+ AT_acquired_before,
AT_address_space,
AT_alias,
AT_aligned,
@@ -178,12 +180,16 @@ public:
AT_device,
AT_dllexport,
AT_dllimport,
+ AT_exclusive_lock_function,
+ AT_exclusive_locks_required,
+ AT_exclusive_trylock_function,
AT_ext_vector_type,
AT_fastcall,
AT_format,
AT_format_arg,
AT_global,
AT_gnu_inline,
+ AT_guarded_by,
AT_guarded_var,
AT_host,
AT_IBAction, // Clang-specific.
@@ -191,7 +197,9 @@ public:
AT_IBOutletCollection, // Clang-specific.
AT_init_priority,
AT_launch_bounds,
+ AT_lock_returned,
AT_lockable,
+ AT_locks_excluded,
AT_malloc,
AT_may_alias,
AT_mode,
@@ -228,6 +236,7 @@ public:
AT_packed,
AT_pascal,
AT_pcs, // ARM specific
+ AT_pt_guarded_by,
AT_pt_guarded_var,
AT_pure,
AT_regparm,
@@ -236,10 +245,14 @@ public:
AT_section,
AT_sentinel,
AT_shared,
+ AT_shared_lock_function,
+ AT_shared_locks_required,
+ AT_shared_trylock_function,
AT_stdcall,
AT_thiscall,
AT_transparent_union,
AT_unavailable,
+ AT_unlock_function,
AT_unused,
AT_used,
AT_uuid,
diff --git a/clang/lib/Sema/AttributeList.cpp b/clang/lib/Sema/AttributeList.cpp
index babf491b949a3d7be66a60f39aed894388e80fb1..d9f17b42da4b40f1fe7ceb7fdd0b7b7a2519380b 100644
--- a/clang/lib/Sema/AttributeList.cpp
+++ b/clang/lib/Sema/AttributeList.cpp
@@ -215,5 +215,18 @@ AttributeList::Kind AttributeList::getKind(const IdentifierInfo *Name) {
.Case("scoped_lockable", AT_scoped_lockable)
.Case("lockable", AT_lockable)
.Case("no_thread_safety_analysis", AT_no_thread_safety_analysis)
+ .Case("guarded_by", AT_guarded_by)
+ .Case("pt_guarded_by", AT_pt_guarded_by)
+ .Case("acquired_after", AT_acquired_after)
+ .Case("acquired_before", AT_acquired_before)
+ .Case("exclusive_lock_function", AT_exclusive_lock_function)
+ .Case("exclusive_locks_required", AT_exclusive_locks_required)
+ .Case("exclusive_trylock_function", AT_exclusive_trylock_function)
+ .Case("lock_returned", AT_lock_returned)
+ .Case("locks_excluded", AT_locks_excluded)
+ .Case("shared_lock_function", AT_shared_lock_function)
+ .Case("shared_locks_required", AT_shared_locks_required)
+ .Case("shared_trylock_function", AT_shared_trylock_function)
+ .Case("unlock_function", AT_unlock_function)
.Default(UnknownAttribute);
}
diff --git a/clang/lib/Sema/SemaDeclAttr.cpp b/clang/lib/Sema/SemaDeclAttr.cpp
index 694d38b4a1f9c51339bf204124154092d6c7fa78..0f02ed31df2149fdbcb4ddaf9c6c001794d2d392 100644
--- a/clang/lib/Sema/SemaDeclAttr.cpp
+++ b/clang/lib/Sema/SemaDeclAttr.cpp
@@ -27,7 +27,7 @@ using namespace sema;
/// These constants match the enumerated choices of
/// warn_attribute_wrong_decl_type and err_attribute_wrong_decl_type.
-enum {
+enum AttributeDeclType {
ExpectedFunction,
ExpectedUnion,
ExpectedVariableOrFunction,
@@ -42,7 +42,8 @@ enum {
ExpectedClassMember,
ExpectedVariable,
ExpectedMethod,
- ExpectedVariableFunctionOrLabel
+ ExpectedVariableFunctionOrLabel,
+ ExpectedFieldOrGlobalVar
};
//===----------------------------------------------------------------------===//
@@ -204,6 +205,34 @@ static bool checkAttributeNumArgs(Sema &S, const AttributeList &Attr,
return true;
}
+///
+/// \brief Check the total number of argumenation, whether parsed by clang
+/// as arguments or parameters. Outputs a warning.
+/// \return false if the number of argumenation units does not match expectation
+///
+static bool checkAttributeNumArgsPlusParams(Sema &S, const AttributeList &Attr,
+ unsigned int Num,
+ bool moreok = false) {
+ unsigned int numArgsPlusParams = 0;
+
+ if (Attr.getParameterName())
+ numArgsPlusParams++;
+
+ numArgsPlusParams += Attr.getNumArgs();
+
+ if (moreok && numArgsPlusParams < Num) {
+ S.Diag(Attr.getLoc(), diag::err_attribute_too_few_arguments) << Num;
+ return false;
+ }
+
+ if (!moreok && numArgsPlusParams != Num) {
+ S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << Num;
+ return false;
+ }
+
+ return true;
+}
+
///
/// \brief Check if passed in Decl is a field or potentially shared global var
/// \return true if the Decl is a field or potentially shared global variable
@@ -225,7 +254,7 @@ static bool mayBeSharedVariable(Decl *D) {
bool checkIsPointer(Sema & S, Decl * D, const AttributeList & Attr) {
if(ValueDecl * vd = dyn_cast