libsanitizer/tsan/tsan_defs.h

   1 //===-- tsan_defs.h ---------------------------------------------*- C++ -*-===//
   2 //
   3 // This file is distributed under the University of Illinois Open Source
   4 // License. See LICENSE.TXT for details.
   5 //
   6 //===----------------------------------------------------------------------===//
   7 //
   8 // This file is a part of ThreadSanitizer (TSan), a race detector.
   9 //
  10 //===----------------------------------------------------------------------===//
  11
  12 #ifndef TSAN_DEFS_H
  13 #define TSAN_DEFS_H
  14
  15 #include "sanitizer_common/sanitizer_internal_defs.h"
  16 #include "sanitizer_common/sanitizer_libc.h"
  17 #include "tsan_stat.h"
  18
  19 #ifndef TSAN_DEBUG
  20 #define TSAN_DEBUG 0
  21 #endif  // TSAN_DEBUG
  22
  23 namespace __tsan {
  24
  25 #ifdef TSAN_GO
  26 const bool kGoMode = true;
  27 const bool kCppMode = false;
  28 const char *const kTsanOptionsEnv = "GORACE";
  29 // Go linker does not support weak symbols.
  30 #define CPP_WEAK
  31 #else
  32 const bool kGoMode = false;
  33 const bool kCppMode = true;
  34 const char *const kTsanOptionsEnv = "TSAN_OPTIONS";
  35 #define CPP_WEAK WEAK
  36 #endif
  37
  38 const int kTidBits = 13;
  39 const unsigned kMaxTid = 1 << kTidBits;
  40 const unsigned kMaxTidInClock = kMaxTid * 2;  // This includes msb 'freed' bit.
  41 const int kClkBits = 42;
  42 const unsigned kMaxTidReuse = (1 << (64 - kClkBits)) - 1;
  43 const uptr kShadowStackSize = 64 * 1024;
  44 const uptr kTraceStackSize = 256;
  45
  46 #ifdef TSAN_SHADOW_COUNT
  47 # if TSAN_SHADOW_COUNT == 2 \
  48   || TSAN_SHADOW_COUNT == 4 || TSAN_SHADOW_COUNT == 8
  49 const uptr kShadowCnt = TSAN_SHADOW_COUNT;
  50 # else
  51 #   error "TSAN_SHADOW_COUNT must be one of 2,4,8"
  52 # endif
  53 #else
  54 // Count of shadow values in a shadow cell.
  55 #define TSAN_SHADOW_COUNT 4
  56 const uptr kShadowCnt = 4;
  57 #endif
  58
  59 // That many user bytes are mapped onto a single shadow cell.
  60 const uptr kShadowCell = 8;
  61
  62 // Size of a single shadow value (u64).
  63 const uptr kShadowSize = 8;
  64
  65 // Shadow memory is kShadowMultiplier times larger than user memory.
  66 const uptr kShadowMultiplier = kShadowSize * kShadowCnt / kShadowCell;
  67
  68 // That many user bytes are mapped onto a single meta shadow cell.
  69 // Must be less or equal to minimal memory allocator alignment.
  70 const uptr kMetaShadowCell = 8;
  71
  72 // Size of a single meta shadow value (u32).
  73 const uptr kMetaShadowSize = 4;
  74
  75 #if defined(TSAN_NO_HISTORY) && TSAN_NO_HISTORY
  76 const bool kCollectHistory = false;
  77 #else
  78 const bool kCollectHistory = true;
  79 #endif
  80
  81 #if defined(TSAN_COLLECT_STATS) && TSAN_COLLECT_STATS
  82 const bool kCollectStats = true;
  83 #else
  84 const bool kCollectStats = false;
  85 #endif
  86
  87 // The following "build consistency" machinery ensures that all source files
  88 // are built in the same configuration. Inconsistent builds lead to
  89 // hard to debug crashes.
  90 #if TSAN_DEBUG
  91 void build_consistency_debug();
  92 #else
  93 void build_consistency_release();
  94 #endif
  95
  96 #if TSAN_COLLECT_STATS
  97 void build_consistency_stats();
  98 #else
  99 void build_consistency_nostats();
 100 #endif
 101
 102 #if TSAN_SHADOW_COUNT == 1
 103 void build_consistency_shadow1();
 104 #elif TSAN_SHADOW_COUNT == 2
 105 void build_consistency_shadow2();
 106 #elif TSAN_SHADOW_COUNT == 4
 107 void build_consistency_shadow4();
 108 #else
 109 void build_consistency_shadow8();
 110 #endif
 111
 112 static inline void USED build_consistency() {
 113 #if TSAN_DEBUG
 114   build_consistency_debug();
 115 #else
 116   build_consistency_release();
 117 #endif
 118 #if TSAN_COLLECT_STATS
 119   build_consistency_stats();
 120 #else
 121   build_consistency_nostats();
 122 #endif
 123 #if TSAN_SHADOW_COUNT == 1
 124   build_consistency_shadow1();
 125 #elif TSAN_SHADOW_COUNT == 2
 126   build_consistency_shadow2();
 127 #elif TSAN_SHADOW_COUNT == 4
 128   build_consistency_shadow4();
 129 #else
 130   build_consistency_shadow8();
 131 #endif
 132 }
 133
 134 template<typename T>
 135 T min(T a, T b) {
 136   return a < b ? a : b;
 137 }
 138
 139 template<typename T>
 140 T max(T a, T b) {
 141   return a > b ? a : b;
 142 }
 143
 144 template<typename T>
 145 T RoundUp(T p, u64 align) {
 146   DCHECK_EQ(align & (align - 1), 0);
 147   return (T)(((u64)p + align - 1) & ~(align - 1));
 148 }
 149
 150 template<typename T>
 151 T RoundDown(T p, u64 align) {
 152   DCHECK_EQ(align & (align - 1), 0);
 153   return (T)((u64)p & ~(align - 1));
 154 }
 155
 156 // Zeroizes high part, returns 'bits' lsb bits.
 157 template<typename T>
 158 T GetLsb(T v, int bits) {
 159   return (T)((u64)v & ((1ull << bits) - 1));
 160 }
 161
 162 struct MD5Hash {
 163   u64 hash[2];
 164   bool operator==(const MD5Hash &other) const;
 165 };
 166
 167 MD5Hash md5_hash(const void *data, uptr size);
 168
 169 struct ThreadState;
 170 class ThreadContext;
 171 struct Context;
 172 struct ReportStack;
 173 class ReportDesc;
 174 class RegionAlloc;
 175 class StackTrace;
 176
 177 // Descriptor of user's memory block.
 178 struct MBlock {
 179   u64  siz;
 180   u32  stk;
 181   u16  tid;
 182 };
 183
 184 COMPILER_CHECK(sizeof(MBlock) == 16);
 185
 186 }  // namespace __tsan
 187
 188 #endif  // TSAN_DEFS_H