src/third_party/webrtc/base/thread_annotations.h

   1 //
   2 // Copyright (c) 2013 The WebRTC project authors. All Rights Reserved.
   3 //
   4 // Use of this source code is governed by a BSD-style license
   5 // that can be found in the LICENSE file in the root of the source
   6 // tree. An additional intellectual property rights grant can be found
   7 // in the file PATENTS.  All contributing project authors may
   8 // be found in the AUTHORS file in the root of the source tree.
   9 //
  10 // Borrowed from
  11 // https://code.google.com/p/gperftools/source/browse/src/base/thread_annotations.h
  12 // but adapted for clang attributes instead of the gcc.
  13 //
  14 // This header file contains the macro definitions for thread safety
  15 // annotations that allow the developers to document the locking policies
  16 // of their multi-threaded code. The annotations can also help program
  17 // analysis tools to identify potential thread safety issues.
  18
  19 #ifndef BASE_THREAD_ANNOTATIONS_H_
  20 #define BASE_THREAD_ANNOTATIONS_H_
  21
  22 #if defined(__clang__) && (!defined(SWIG))
  23 #define THREAD_ANNOTATION_ATTRIBUTE__(x) __attribute__((x))
  24 #else
  25 #define THREAD_ANNOTATION_ATTRIBUTE__(x)  // no-op
  26 #endif
  27
  28 // Document if a shared variable/field needs to be protected by a lock.
  29 // GUARDED_BY allows the user to specify a particular lock that should be
  30 // held when accessing the annotated variable, while GUARDED_VAR only
  31 // indicates a shared variable should be guarded (by any lock). GUARDED_VAR
  32 // is primarily used when the client cannot express the name of the lock.
  33 #define GUARDED_BY(x) THREAD_ANNOTATION_ATTRIBUTE__(guarded_by(x))
  34 #define GUARDED_VAR THREAD_ANNOTATION_ATTRIBUTE__(guarded)
  35
  36 // Document if the memory location pointed to by a pointer should be guarded
  37 // by a lock when dereferencing the pointer. Similar to GUARDED_VAR,
  38 // PT_GUARDED_VAR is primarily used when the client cannot express the name
  39 // of the lock. Note that a pointer variable to a shared memory location
  40 // could itself be a shared variable. For example, if a shared global pointer
  41 // q, which is guarded by mu1, points to a shared memory location that is
  42 // guarded by mu2, q should be annotated as follows:
  43 //     int *q GUARDED_BY(mu1) PT_GUARDED_BY(mu2);
  44 #define PT_GUARDED_BY(x) THREAD_ANNOTATION_ATTRIBUTE__(point_to_guarded_by(x))
  45 #define PT_GUARDED_VAR THREAD_ANNOTATION_ATTRIBUTE__(point_to_guarded)
  46
  47 // Document the acquisition order between locks that can be held
  48 // simultaneously by a thread. For any two locks that need to be annotated
  49 // to establish an acquisition order, only one of them needs the annotation.
  50 // (i.e. You don't have to annotate both locks with both ACQUIRED_AFTER
  51 // and ACQUIRED_BEFORE.)
  52 #define ACQUIRED_AFTER(x) THREAD_ANNOTATION_ATTRIBUTE__(acquired_after(x))
  53 #define ACQUIRED_BEFORE(x) THREAD_ANNOTATION_ATTRIBUTE__(acquired_before(x))
  54
  55 // The following three annotations document the lock requirements for
  56 // functions/methods.
  57
  58 // Document if a function expects certain locks to be held before it is called
  59 #define EXCLUSIVE_LOCKS_REQUIRED(...) \
  60   THREAD_ANNOTATION_ATTRIBUTE__(exclusive_locks_required(__VA_ARGS__))
  61
  62 #define SHARED_LOCKS_REQUIRED(...) \
  63   THREAD_ANNOTATION_ATTRIBUTE__(shared_locks_required(__VA_ARGS__))
  64
  65 // Document the locks acquired in the body of the function. These locks
  66 // cannot be held when calling this function (as google3's Mutex locks are
  67 // non-reentrant).
  68 #define LOCKS_EXCLUDED(x) THREAD_ANNOTATION_ATTRIBUTE__(locks_excluded(x))
  69
  70 // Document the lock the annotated function returns without acquiring it.
  71 #define LOCK_RETURNED(x) THREAD_ANNOTATION_ATTRIBUTE__(lock_returned(x))
  72
  73 // Document if a class/type is a lockable type (such as the Mutex class).
  74 #define LOCKABLE THREAD_ANNOTATION_ATTRIBUTE__(lockable)
  75
  76 // Document if a class is a scoped lockable type (such as the MutexLock class).
  77 #define SCOPED_LOCKABLE THREAD_ANNOTATION_ATTRIBUTE__(scoped_lockable)
  78
  79 // The following annotations specify lock and unlock primitives.
  80 #define EXCLUSIVE_LOCK_FUNCTION(...) \
  81   THREAD_ANNOTATION_ATTRIBUTE__(exclusive_lock_function(__VA_ARGS__))
  82
  83 #define SHARED_LOCK_FUNCTION(...) \
  84   THREAD_ANNOTATION_ATTRIBUTE__(shared_lock_function(__VA_ARGS__))
  85
  86 #define EXCLUSIVE_TRYLOCK_FUNCTION(...) \
  87   THREAD_ANNOTATION_ATTRIBUTE__(exclusive_trylock_function(__VA_ARGS__))
  88
  89 #define SHARED_TRYLOCK_FUNCTION(...) \
  90   THREAD_ANNOTATION_ATTRIBUTE__(shared_trylock_function(__VA_ARGS__))
  91
  92 #define UNLOCK_FUNCTION(...) \
  93   THREAD_ANNOTATION_ATTRIBUTE__(unlock_function(__VA_ARGS__))
  94
  95 // An escape hatch for thread safety analysis to ignore the annotated function.
  96 #define NO_THREAD_SAFETY_ANALYSIS \
  97   THREAD_ANNOTATION_ATTRIBUTE__(no_thread_safety_analysis)
  98
  99 #endif  // BASE_THREAD_ANNOTATIONS_H_