Index: third_party/tcmalloc/chromium/src/base/thread_annotations.h |
=================================================================== |
--- third_party/tcmalloc/chromium/src/base/thread_annotations.h (revision 88335) |
+++ third_party/tcmalloc/chromium/src/base/thread_annotations.h (working copy) |
@@ -45,15 +45,23 @@ |
#ifndef BASE_THREAD_ANNOTATIONS_H_ |
#define BASE_THREAD_ANNOTATIONS_H_ |
-#if defined(__GNUC__) && defined(__SUPPORT_TS_ANNOTATION__) && (!defined(SWIG)) |
+#if defined(__GNUC__) \ |
+ && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4)) \ |
+ && defined(__SUPPORT_TS_ANNOTATION__) && (!defined(SWIG)) |
+#define THREAD_ANNOTATION_ATTRIBUTE__(x) __attribute__((x)) |
+#else |
+#define THREAD_ANNOTATION_ATTRIBUTE__(x) // no-op |
+#endif |
+ |
+ |
// Document if a shared variable/field needs to be protected by a lock. |
// GUARDED_BY allows the user to specify a particular lock that should be |
// held when accessing the annotated variable, while GUARDED_VAR only |
// indicates a shared variable should be guarded (by any lock). GUARDED_VAR |
// is primarily used when the client cannot express the name of the lock. |
-#define GUARDED_BY(x) __attribute__ ((guarded_by(x))) |
-#define GUARDED_VAR __attribute__ ((guarded)) |
+#define GUARDED_BY(x) THREAD_ANNOTATION_ATTRIBUTE__(guarded_by(x)) |
+#define GUARDED_VAR THREAD_ANNOTATION_ATTRIBUTE__(guarded) |
// Document if the memory location pointed to by a pointer should be guarded |
// by a lock when dereferencing the pointer. Similar to GUARDED_VAR, |
@@ -63,90 +71,64 @@ |
// q, which is guarded by mu1, points to a shared memory location that is |
// guarded by mu2, q should be annotated as follows: |
// int *q GUARDED_BY(mu1) PT_GUARDED_BY(mu2); |
-#define PT_GUARDED_BY(x) __attribute__ ((point_to_guarded_by(x))) |
-#define PT_GUARDED_VAR __attribute__ ((point_to_guarded)) |
+#define PT_GUARDED_BY(x) \ |
+ THREAD_ANNOTATION_ATTRIBUTE__(point_to_guarded_by(x)) |
+#define PT_GUARDED_VAR \ |
+ THREAD_ANNOTATION_ATTRIBUTE__(point_to_guarded) |
// Document the acquisition order between locks that can be held |
// simultaneously by a thread. For any two locks that need to be annotated |
// to establish an acquisition order, only one of them needs the annotation. |
// (i.e. You don't have to annotate both locks with both ACQUIRED_AFTER |
// and ACQUIRED_BEFORE.) |
-#define ACQUIRED_AFTER(...) __attribute__ ((acquired_after(__VA_ARGS__))) |
-#define ACQUIRED_BEFORE(...) __attribute__ ((acquired_before(__VA_ARGS__))) |
+#define ACQUIRED_AFTER(x) \ |
+ THREAD_ANNOTATION_ATTRIBUTE__(acquired_after(x)) |
+#define ACQUIRED_BEFORE(x) \ |
+ THREAD_ANNOTATION_ATTRIBUTE__(acquired_before(x)) |
// The following three annotations document the lock requirements for |
// functions/methods. |
// Document if a function expects certain locks to be held before it is called |
-#define EXCLUSIVE_LOCKS_REQUIRED(...) \ |
- __attribute__ ((exclusive_locks_required(__VA_ARGS__))) |
+#define EXCLUSIVE_LOCKS_REQUIRED(x) \ |
+ THREAD_ANNOTATION_ATTRIBUTE__(exclusive_locks_required(x)) |
-#define SHARED_LOCKS_REQUIRED(...) \ |
- __attribute__ ((shared_locks_required(__VA_ARGS__))) |
+#define SHARED_LOCKS_REQUIRED(x) \ |
+ THREAD_ANNOTATION_ATTRIBUTE__(shared_locks_required(x)) |
// Document the locks acquired in the body of the function. These locks |
// cannot be held when calling this function (as google3's Mutex locks are |
// non-reentrant). |
-#define LOCKS_EXCLUDED(...) __attribute__ ((locks_excluded(__VA_ARGS__))) |
+#define LOCKS_EXCLUDED(x) \ |
+ THREAD_ANNOTATION_ATTRIBUTE__(locks_excluded(x)) |
// Document the lock the annotated function returns without acquiring it. |
-#define LOCK_RETURNED(x) __attribute__ ((lock_returned(x))) |
+#define LOCK_RETURNED(x) THREAD_ANNOTATION_ATTRIBUTE__(lock_returned(x)) |
// Document if a class/type is a lockable type (such as the Mutex class). |
-#define LOCKABLE __attribute__ ((lockable)) |
+#define LOCKABLE THREAD_ANNOTATION_ATTRIBUTE__(lockable) |
// Document if a class is a scoped lockable type (such as the MutexLock class). |
-#define SCOPED_LOCKABLE __attribute__ ((scoped_lockable)) |
+#define SCOPED_LOCKABLE THREAD_ANNOTATION_ATTRIBUTE__(scoped_lockable) |
// The following annotations specify lock and unlock primitives. |
-#define EXCLUSIVE_LOCK_FUNCTION(...) \ |
- __attribute__ ((exclusive_lock(__VA_ARGS__))) |
+#define EXCLUSIVE_LOCK_FUNCTION(x) \ |
+ THREAD_ANNOTATION_ATTRIBUTE__(exclusive_lock(x)) |
-#define SHARED_LOCK_FUNCTION(...) \ |
- __attribute__ ((shared_lock(__VA_ARGS__))) |
+#define SHARED_LOCK_FUNCTION(x) \ |
+ THREAD_ANNOTATION_ATTRIBUTE__(shared_lock(x)) |
-#define EXCLUSIVE_TRYLOCK_FUNCTION(...) \ |
- __attribute__ ((exclusive_trylock(__VA_ARGS__))) |
+#define EXCLUSIVE_TRYLOCK_FUNCTION(x) \ |
+ THREAD_ANNOTATION_ATTRIBUTE__(exclusive_trylock(x)) |
-#define SHARED_TRYLOCK_FUNCTION(...) \ |
- __attribute__ ((shared_trylock(__VA_ARGS__))) |
+#define SHARED_TRYLOCK_FUNCTION(x) \ |
+ THREAD_ANNOTATION_ATTRIBUTE__(shared_trylock(x)) |
-#define UNLOCK_FUNCTION(...) __attribute__ ((unlock(__VA_ARGS__))) |
+#define UNLOCK_FUNCTION(x) \ |
+ THREAD_ANNOTATION_ATTRIBUTE__(unlock(x)) |
// An escape hatch for thread safety analysis to ignore the annotated function. |
-#define NO_THREAD_SAFETY_ANALYSIS __attribute__ ((no_thread_safety_analysis)) |
+#define NO_THREAD_SAFETY_ANALYSIS \ |
+ THREAD_ANNOTATION_ATTRIBUTE__(no_thread_safety_analysis) |
- |
-#else |
- |
-// When the compiler is not GCC, these annotations are simply no-ops. |
- |
-// NOTE: in theory, the macros that take "arg" below *could* take |
-// multiple arguments, but in practice so far they only take one. |
-// Since not all non-gcc compilers support ... -- notably MSVC 7.1 -- |
-// I just hard-code in a single arg. If this assumption ever breaks, |
-// we can change it back to "...", or handle it some other way. |
- |
-#define GUARDED_BY(x) // no-op |
-#define GUARDED_VAR // no-op |
-#define PT_GUARDED_BY(x) // no-op |
-#define PT_GUARDED_VAR // no-op |
-#define ACQUIRED_AFTER(arg) // no-op |
-#define ACQUIRED_BEFORE(arg) // no-op |
-#define EXCLUSIVE_LOCKS_REQUIRED(arg) // no-op |
-#define SHARED_LOCKS_REQUIRED(arg) // no-op |
-#define LOCKS_EXCLUDED(arg) // no-op |
-#define LOCK_RETURNED(x) // no-op |
-#define LOCKABLE // no-op |
-#define SCOPED_LOCKABLE // no-op |
-#define EXCLUSIVE_LOCK_FUNCTION(arg) // no-op |
-#define SHARED_LOCK_FUNCTION(arg) // no-op |
-#define EXCLUSIVE_TRYLOCK_FUNCTION(arg) // no-op |
-#define SHARED_TRYLOCK_FUNCTION(arg) // no-op |
-#define UNLOCK_FUNCTION(arg) // no-op |
-#define NO_THREAD_SAFETY_ANALYSIS // no-op |
- |
-#endif // defined(__GNUC__) && defined(__SUPPORT_TS_ANNOTATION__) |
- // && !defined(SWIG) |
- |
#endif // BASE_THREAD_ANNOTATIONS_H_ |