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