contrib/compiler-rt/lib/tsan/rtl/tsan_defs.h

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