libsanitizer/tsan/tsan_defs.h

   1 //===-- tsan_defs.h ---------------------------------------------*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // This file is a part of ThreadSanitizer (TSan), a race detector.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #ifndef TSAN_DEFS_H
  14 #define TSAN_DEFS_H
  15
  16 #include "sanitizer_common/sanitizer_internal_defs.h"
  17 #include "sanitizer_common/sanitizer_libc.h"
  18 #include "sanitizer_common/sanitizer_mutex.h"
  19 #include "ubsan/ubsan_platform.h"
  20
  21 #ifndef TSAN_VECTORIZE
  22 #  define TSAN_VECTORIZE __SSE4_2__
  23 #endif
  24
  25 #if TSAN_VECTORIZE
  26 // <emmintrin.h> transitively includes <stdlib.h>,
  27 // and it's prohibited to include std headers into tsan runtime.
  28 // So we do this dirty trick.
  29 #  define _MM_MALLOC_H_INCLUDED
  30 #  define __MM_MALLOC_H
  31 #  include <emmintrin.h>
  32 #  include <smmintrin.h>
  33 #  define VECTOR_ALIGNED ALIGNED(16)
  34 typedef __m128i m128;
  35 #else
  36 #  define VECTOR_ALIGNED
  37 #endif
  38
  39 // Setup defaults for compile definitions.
  40 #ifndef TSAN_NO_HISTORY
  41 # define TSAN_NO_HISTORY 0
  42 #endif
  43
  44 #ifndef TSAN_CONTAINS_UBSAN
  45 # if CAN_SANITIZE_UB && !SANITIZER_GO
  46 #  define TSAN_CONTAINS_UBSAN 1
  47 # else
  48 #  define TSAN_CONTAINS_UBSAN 0
  49 # endif
  50 #endif
  51
  52 namespace __tsan {
  53
  54 constexpr uptr kByteBits = 8;
  55
  56 // Thread slot ID.
  57 enum class Sid : u8 {};
  58 constexpr uptr kThreadSlotCount = 256;
  59 constexpr Sid kFreeSid = static_cast<Sid>(255);
  60
  61 // Abstract time unit, vector clock element.
  62 enum class Epoch : u16 {};
  63 constexpr uptr kEpochBits = 14;
  64 constexpr Epoch kEpochZero = static_cast<Epoch>(0);
  65 constexpr Epoch kEpochOver = static_cast<Epoch>(1 << kEpochBits);
  66 constexpr Epoch kEpochLast = static_cast<Epoch>((1 << kEpochBits) - 1);
  67
  68 inline Epoch EpochInc(Epoch epoch) {
  69   return static_cast<Epoch>(static_cast<u16>(epoch) + 1);
  70 }
  71
  72 inline bool EpochOverflow(Epoch epoch) { return epoch == kEpochOver; }
  73
  74 const uptr kShadowStackSize = 64 * 1024;
  75
  76 // Count of shadow values in a shadow cell.
  77 const uptr kShadowCnt = 4;
  78
  79 // That many user bytes are mapped onto a single shadow cell.
  80 const uptr kShadowCell = 8;
  81
  82 // Single shadow value.
  83 enum class RawShadow : u32 {};
  84 const uptr kShadowSize = sizeof(RawShadow);
  85
  86 // Shadow memory is kShadowMultiplier times larger than user memory.
  87 const uptr kShadowMultiplier = kShadowSize * kShadowCnt / kShadowCell;
  88
  89 // That many user bytes are mapped onto a single meta shadow cell.
  90 // Must be less or equal to minimal memory allocator alignment.
  91 const uptr kMetaShadowCell = 8;
  92
  93 // Size of a single meta shadow value (u32).
  94 const uptr kMetaShadowSize = 4;
  95
  96 // All addresses and PCs are assumed to be compressable to that many bits.
  97 const uptr kCompressedAddrBits = 44;
  98
  99 #if TSAN_NO_HISTORY
 100 const bool kCollectHistory = false;
 101 #else
 102 const bool kCollectHistory = true;
 103 #endif
 104
 105 // The following "build consistency" machinery ensures that all source files
 106 // are built in the same configuration. Inconsistent builds lead to
 107 // hard to debug crashes.
 108 #if SANITIZER_DEBUG
 109 void build_consistency_debug();
 110 #else
 111 void build_consistency_release();
 112 #endif
 113
 114 static inline void USED build_consistency() {
 115 #if SANITIZER_DEBUG
 116   build_consistency_debug();
 117 #else
 118   build_consistency_release();
 119 #endif
 120 }
 121
 122 template<typename T>
 123 T min(T a, T b) {
 124   return a < b ? a : b;
 125 }
 126
 127 template<typename T>
 128 T max(T a, T b) {
 129   return a > b ? a : b;
 130 }
 131
 132 template<typename T>
 133 T RoundUp(T p, u64 align) {
 134   DCHECK_EQ(align & (align - 1), 0);
 135   return (T)(((u64)p + align - 1) & ~(align - 1));
 136 }
 137
 138 template<typename T>
 139 T RoundDown(T p, u64 align) {
 140   DCHECK_EQ(align & (align - 1), 0);
 141   return (T)((u64)p & ~(align - 1));
 142 }
 143
 144 // Zeroizes high part, returns 'bits' lsb bits.
 145 template<typename T>
 146 T GetLsb(T v, int bits) {
 147   return (T)((u64)v & ((1ull << bits) - 1));
 148 }
 149
 150 struct MD5Hash {
 151   u64 hash[2];
 152   bool operator==(const MD5Hash &other) const;
 153 };
 154
 155 MD5Hash md5_hash(const void *data, uptr size);
 156
 157 struct Processor;
 158 struct ThreadState;
 159 class ThreadContext;
 160 struct TidSlot;
 161 struct Context;
 162 struct ReportStack;
 163 class ReportDesc;
 164 class RegionAlloc;
 165 struct Trace;
 166 struct TracePart;
 167
 168 typedef uptr AccessType;
 169
 170 enum : AccessType {
 171   kAccessWrite = 0,
 172   kAccessRead = 1 << 0,
 173   kAccessAtomic = 1 << 1,
 174   kAccessVptr = 1 << 2,  // read or write of an object virtual table pointer
 175   kAccessFree = 1 << 3,  // synthetic memory access during memory freeing
 176   kAccessExternalPC = 1 << 4,  // access PC can have kExternalPCBit set
 177   kAccessCheckOnly = 1 << 5,   // check for races, but don't store
 178   kAccessNoRodata = 1 << 6,    // don't check for .rodata marker
 179   kAccessSlotLocked = 1 << 7,  // memory access with TidSlot locked
 180 };
 181
 182 // Descriptor of user's memory block.
 183 struct MBlock {
 184   u64  siz : 48;
 185   u64  tag : 16;
 186   StackID stk;
 187   Tid tid;
 188 };
 189
 190 COMPILER_CHECK(sizeof(MBlock) == 16);
 191
 192 enum ExternalTag : uptr {
 193   kExternalTagNone = 0,
 194   kExternalTagSwiftModifyingAccess = 1,
 195   kExternalTagFirstUserAvailable = 2,
 196   kExternalTagMax = 1024,
 197   // Don't set kExternalTagMax over 65,536, since MBlock only stores tags
 198   // as 16-bit values, see tsan_defs.h.
 199 };
 200
 201 enum {
 202   MutexTypeReport = MutexLastCommon,
 203   MutexTypeSyncVar,
 204   MutexTypeAnnotations,
 205   MutexTypeAtExit,
 206   MutexTypeFired,
 207   MutexTypeRacy,
 208   MutexTypeGlobalProc,
 209   MutexTypeInternalAlloc,
 210   MutexTypeTrace,
 211   MutexTypeSlot,
 212   MutexTypeSlots,
 213 };
 214
 215 }  // namespace __tsan
 216
 217 #endif  // TSAN_DEFS_H