1 //===-- tsan_interface.h ----------------------------------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file is a part of ThreadSanitizer (TSan), a race detector.
12 // The functions declared in this header will be inserted by the instrumentation
14 // This header can be included by the instrumented program or by TSan tests.
15 //===----------------------------------------------------------------------===//
16 #ifndef TSAN_INTERFACE_H
17 #define TSAN_INTERFACE_H
19 #include <sanitizer_common/sanitizer_internal_defs.h>
20 using __sanitizer::uptr
;
22 // This header should NOT include any other headers.
23 // All functions in this header are extern "C" and start with __tsan_.
31 // This function should be called at the very beginning of the process,
32 // before any instrumented code is executed and before any call to malloc.
33 SANITIZER_INTERFACE_ATTRIBUTE
void __tsan_init();
35 SANITIZER_INTERFACE_ATTRIBUTE
void __tsan_flush_memory();
37 SANITIZER_INTERFACE_ATTRIBUTE
void __tsan_read1(void *addr
);
38 SANITIZER_INTERFACE_ATTRIBUTE
void __tsan_read2(void *addr
);
39 SANITIZER_INTERFACE_ATTRIBUTE
void __tsan_read4(void *addr
);
40 SANITIZER_INTERFACE_ATTRIBUTE
void __tsan_read8(void *addr
);
41 SANITIZER_INTERFACE_ATTRIBUTE
void __tsan_read16(void *addr
);
43 SANITIZER_INTERFACE_ATTRIBUTE
void __tsan_write1(void *addr
);
44 SANITIZER_INTERFACE_ATTRIBUTE
void __tsan_write2(void *addr
);
45 SANITIZER_INTERFACE_ATTRIBUTE
void __tsan_write4(void *addr
);
46 SANITIZER_INTERFACE_ATTRIBUTE
void __tsan_write8(void *addr
);
47 SANITIZER_INTERFACE_ATTRIBUTE
void __tsan_write16(void *addr
);
49 SANITIZER_INTERFACE_ATTRIBUTE
void __tsan_unaligned_read2(const void *addr
);
50 SANITIZER_INTERFACE_ATTRIBUTE
void __tsan_unaligned_read4(const void *addr
);
51 SANITIZER_INTERFACE_ATTRIBUTE
void __tsan_unaligned_read8(const void *addr
);
52 SANITIZER_INTERFACE_ATTRIBUTE
void __tsan_unaligned_read16(const void *addr
);
54 SANITIZER_INTERFACE_ATTRIBUTE
void __tsan_unaligned_write2(void *addr
);
55 SANITIZER_INTERFACE_ATTRIBUTE
void __tsan_unaligned_write4(void *addr
);
56 SANITIZER_INTERFACE_ATTRIBUTE
void __tsan_unaligned_write8(void *addr
);
57 SANITIZER_INTERFACE_ATTRIBUTE
void __tsan_unaligned_write16(void *addr
);
59 SANITIZER_INTERFACE_ATTRIBUTE
void __tsan_read1_pc(void *addr
, void *pc
);
60 SANITIZER_INTERFACE_ATTRIBUTE
void __tsan_read2_pc(void *addr
, void *pc
);
61 SANITIZER_INTERFACE_ATTRIBUTE
void __tsan_read4_pc(void *addr
, void *pc
);
62 SANITIZER_INTERFACE_ATTRIBUTE
void __tsan_read8_pc(void *addr
, void *pc
);
63 SANITIZER_INTERFACE_ATTRIBUTE
void __tsan_read16_pc(void *addr
, void *pc
);
65 SANITIZER_INTERFACE_ATTRIBUTE
void __tsan_write1_pc(void *addr
, void *pc
);
66 SANITIZER_INTERFACE_ATTRIBUTE
void __tsan_write2_pc(void *addr
, void *pc
);
67 SANITIZER_INTERFACE_ATTRIBUTE
void __tsan_write4_pc(void *addr
, void *pc
);
68 SANITIZER_INTERFACE_ATTRIBUTE
void __tsan_write8_pc(void *addr
, void *pc
);
69 SANITIZER_INTERFACE_ATTRIBUTE
void __tsan_write16_pc(void *addr
, void *pc
);
71 SANITIZER_INTERFACE_ATTRIBUTE
void __tsan_vptr_read(void **vptr_p
);
72 SANITIZER_INTERFACE_ATTRIBUTE
73 void __tsan_vptr_update(void **vptr_p
, void *new_val
);
75 SANITIZER_INTERFACE_ATTRIBUTE
void __tsan_func_entry(void *call_pc
);
76 SANITIZER_INTERFACE_ATTRIBUTE
void __tsan_func_exit();
78 SANITIZER_INTERFACE_ATTRIBUTE
void __tsan_ignore_thread_begin();
79 SANITIZER_INTERFACE_ATTRIBUTE
void __tsan_ignore_thread_end();
81 SANITIZER_INTERFACE_ATTRIBUTE
82 void __tsan_read_range(void *addr
, unsigned long size
); // NOLINT
83 SANITIZER_INTERFACE_ATTRIBUTE
84 void __tsan_write_range(void *addr
, unsigned long size
); // NOLINT
86 // User may provide function that would be called right when TSan detects
87 // an error. The argument 'report' is an opaque pointer that can be used to
88 // gather additional information using other TSan report API functions.
89 SANITIZER_INTERFACE_ATTRIBUTE
90 void __tsan_on_report(void *report
);
92 // If TSan is currently reporting a detected issue on the current thread,
93 // returns an opaque pointer to the current report. Otherwise returns NULL.
94 SANITIZER_INTERFACE_ATTRIBUTE
95 void *__tsan_get_current_report();
97 // Returns a report's description (issue type), number of duplicate issues
98 // found, counts of array data (stack traces, memory operations, locations,
99 // mutexes, threads, unique thread IDs) and a stack trace of a sleep() call (if
100 // one was involved in the issue).
101 SANITIZER_INTERFACE_ATTRIBUTE
102 int __tsan_get_report_data(void *report
, const char **description
, int *count
,
103 int *stack_count
, int *mop_count
, int *loc_count
,
104 int *mutex_count
, int *thread_count
,
105 int *unique_tid_count
, void **sleep_trace
,
108 // Returns information about stack traces included in the report.
109 SANITIZER_INTERFACE_ATTRIBUTE
110 int __tsan_get_report_stack(void *report
, uptr idx
, void **trace
,
113 // Returns information about memory operations included in the report.
114 SANITIZER_INTERFACE_ATTRIBUTE
115 int __tsan_get_report_mop(void *report
, uptr idx
, int *tid
, void **addr
,
116 int *size
, int *write
, int *atomic
, void **trace
,
119 // Returns information about locations included in the report.
120 SANITIZER_INTERFACE_ATTRIBUTE
121 int __tsan_get_report_loc(void *report
, uptr idx
, const char **type
,
122 void **addr
, uptr
*start
, uptr
*size
, int *tid
,
123 int *fd
, int *suppressable
, void **trace
,
126 // Returns information about mutexes included in the report.
127 SANITIZER_INTERFACE_ATTRIBUTE
128 int __tsan_get_report_mutex(void *report
, uptr idx
, uptr
*mutex_id
, void **addr
,
129 int *destroyed
, void **trace
, uptr trace_size
);
131 // Returns information about threads included in the report.
132 SANITIZER_INTERFACE_ATTRIBUTE
133 int __tsan_get_report_thread(void *report
, uptr idx
, int *tid
, uptr
*os_id
,
134 int *running
, const char **name
, int *parent_tid
,
135 void **trace
, uptr trace_size
);
137 // Returns information about unique thread IDs included in the report.
138 SANITIZER_INTERFACE_ATTRIBUTE
139 int __tsan_get_report_unique_tid(void *report
, uptr idx
, int *tid
);
141 // Returns the type of the pointer (heap, stack, global, ...) and if possible
142 // also the starting address (e.g. of a heap allocation) and size.
143 SANITIZER_INTERFACE_ATTRIBUTE
144 const char *__tsan_locate_address(uptr addr
, char *name
, uptr name_size
,
145 uptr
*region_address
, uptr
*region_size
);
147 // Returns the allocation stack for a heap pointer.
148 SANITIZER_INTERFACE_ATTRIBUTE
149 int __tsan_get_alloc_stack(uptr addr
, uptr
*trace
, uptr size
, int *thread_id
,
152 #endif // SANITIZER_GO
160 // These should match declarations from public tsan_interface_atomic.h header.
161 typedef unsigned char a8
;
162 typedef unsigned short a16
; // NOLINT
163 typedef unsigned int a32
;
164 typedef unsigned long long a64
; // NOLINT
165 #if !SANITIZER_GO && (defined(__SIZEOF_INT128__) \
166 || (__clang_major__ * 100 + __clang_minor__ >= 302)) && !defined(__mips64)
167 __extension__
typedef __int128 a128
;
168 # define __TSAN_HAS_INT128 1
170 # define __TSAN_HAS_INT128 0
173 // Part of ABI, do not change.
174 // http://llvm.org/viewvc/llvm-project/libcxx/trunk/include/atomic?view=markup
187 SANITIZER_INTERFACE_ATTRIBUTE
188 a8
__tsan_atomic8_load(const volatile a8
*a
, morder mo
);
189 SANITIZER_INTERFACE_ATTRIBUTE
190 a16
__tsan_atomic16_load(const volatile a16
*a
, morder mo
);
191 SANITIZER_INTERFACE_ATTRIBUTE
192 a32
__tsan_atomic32_load(const volatile a32
*a
, morder mo
);
193 SANITIZER_INTERFACE_ATTRIBUTE
194 a64
__tsan_atomic64_load(const volatile a64
*a
, morder mo
);
195 #if __TSAN_HAS_INT128
196 SANITIZER_INTERFACE_ATTRIBUTE
197 a128
__tsan_atomic128_load(const volatile a128
*a
, morder mo
);
200 SANITIZER_INTERFACE_ATTRIBUTE
201 void __tsan_atomic8_store(volatile a8
*a
, a8 v
, morder mo
);
202 SANITIZER_INTERFACE_ATTRIBUTE
203 void __tsan_atomic16_store(volatile a16
*a
, a16 v
, morder mo
);
204 SANITIZER_INTERFACE_ATTRIBUTE
205 void __tsan_atomic32_store(volatile a32
*a
, a32 v
, morder mo
);
206 SANITIZER_INTERFACE_ATTRIBUTE
207 void __tsan_atomic64_store(volatile a64
*a
, a64 v
, morder mo
);
208 #if __TSAN_HAS_INT128
209 SANITIZER_INTERFACE_ATTRIBUTE
210 void __tsan_atomic128_store(volatile a128
*a
, a128 v
, morder mo
);
213 SANITIZER_INTERFACE_ATTRIBUTE
214 a8
__tsan_atomic8_exchange(volatile a8
*a
, a8 v
, morder mo
);
215 SANITIZER_INTERFACE_ATTRIBUTE
216 a16
__tsan_atomic16_exchange(volatile a16
*a
, a16 v
, morder mo
);
217 SANITIZER_INTERFACE_ATTRIBUTE
218 a32
__tsan_atomic32_exchange(volatile a32
*a
, a32 v
, morder mo
);
219 SANITIZER_INTERFACE_ATTRIBUTE
220 a64
__tsan_atomic64_exchange(volatile a64
*a
, a64 v
, morder mo
);
221 #if __TSAN_HAS_INT128
222 SANITIZER_INTERFACE_ATTRIBUTE
223 a128
__tsan_atomic128_exchange(volatile a128
*a
, a128 v
, morder mo
);
226 SANITIZER_INTERFACE_ATTRIBUTE
227 a8
__tsan_atomic8_fetch_add(volatile a8
*a
, a8 v
, morder mo
);
228 SANITIZER_INTERFACE_ATTRIBUTE
229 a16
__tsan_atomic16_fetch_add(volatile a16
*a
, a16 v
, morder mo
);
230 SANITIZER_INTERFACE_ATTRIBUTE
231 a32
__tsan_atomic32_fetch_add(volatile a32
*a
, a32 v
, morder mo
);
232 SANITIZER_INTERFACE_ATTRIBUTE
233 a64
__tsan_atomic64_fetch_add(volatile a64
*a
, a64 v
, morder mo
);
234 #if __TSAN_HAS_INT128
235 SANITIZER_INTERFACE_ATTRIBUTE
236 a128
__tsan_atomic128_fetch_add(volatile a128
*a
, a128 v
, morder mo
);
239 SANITIZER_INTERFACE_ATTRIBUTE
240 a8
__tsan_atomic8_fetch_sub(volatile a8
*a
, a8 v
, morder mo
);
241 SANITIZER_INTERFACE_ATTRIBUTE
242 a16
__tsan_atomic16_fetch_sub(volatile a16
*a
, a16 v
, morder mo
);
243 SANITIZER_INTERFACE_ATTRIBUTE
244 a32
__tsan_atomic32_fetch_sub(volatile a32
*a
, a32 v
, morder mo
);
245 SANITIZER_INTERFACE_ATTRIBUTE
246 a64
__tsan_atomic64_fetch_sub(volatile a64
*a
, a64 v
, morder mo
);
247 #if __TSAN_HAS_INT128
248 SANITIZER_INTERFACE_ATTRIBUTE
249 a128
__tsan_atomic128_fetch_sub(volatile a128
*a
, a128 v
, morder mo
);
252 SANITIZER_INTERFACE_ATTRIBUTE
253 a8
__tsan_atomic8_fetch_and(volatile a8
*a
, a8 v
, morder mo
);
254 SANITIZER_INTERFACE_ATTRIBUTE
255 a16
__tsan_atomic16_fetch_and(volatile a16
*a
, a16 v
, morder mo
);
256 SANITIZER_INTERFACE_ATTRIBUTE
257 a32
__tsan_atomic32_fetch_and(volatile a32
*a
, a32 v
, morder mo
);
258 SANITIZER_INTERFACE_ATTRIBUTE
259 a64
__tsan_atomic64_fetch_and(volatile a64
*a
, a64 v
, morder mo
);
260 #if __TSAN_HAS_INT128
261 SANITIZER_INTERFACE_ATTRIBUTE
262 a128
__tsan_atomic128_fetch_and(volatile a128
*a
, a128 v
, morder mo
);
265 SANITIZER_INTERFACE_ATTRIBUTE
266 a8
__tsan_atomic8_fetch_or(volatile a8
*a
, a8 v
, morder mo
);
267 SANITIZER_INTERFACE_ATTRIBUTE
268 a16
__tsan_atomic16_fetch_or(volatile a16
*a
, a16 v
, morder mo
);
269 SANITIZER_INTERFACE_ATTRIBUTE
270 a32
__tsan_atomic32_fetch_or(volatile a32
*a
, a32 v
, morder mo
);
271 SANITIZER_INTERFACE_ATTRIBUTE
272 a64
__tsan_atomic64_fetch_or(volatile a64
*a
, a64 v
, morder mo
);
273 #if __TSAN_HAS_INT128
274 SANITIZER_INTERFACE_ATTRIBUTE
275 a128
__tsan_atomic128_fetch_or(volatile a128
*a
, a128 v
, morder mo
);
278 SANITIZER_INTERFACE_ATTRIBUTE
279 a8
__tsan_atomic8_fetch_xor(volatile a8
*a
, a8 v
, morder mo
);
280 SANITIZER_INTERFACE_ATTRIBUTE
281 a16
__tsan_atomic16_fetch_xor(volatile a16
*a
, a16 v
, morder mo
);
282 SANITIZER_INTERFACE_ATTRIBUTE
283 a32
__tsan_atomic32_fetch_xor(volatile a32
*a
, a32 v
, morder mo
);
284 SANITIZER_INTERFACE_ATTRIBUTE
285 a64
__tsan_atomic64_fetch_xor(volatile a64
*a
, a64 v
, morder mo
);
286 #if __TSAN_HAS_INT128
287 SANITIZER_INTERFACE_ATTRIBUTE
288 a128
__tsan_atomic128_fetch_xor(volatile a128
*a
, a128 v
, morder mo
);
291 SANITIZER_INTERFACE_ATTRIBUTE
292 a8
__tsan_atomic8_fetch_nand(volatile a8
*a
, a8 v
, morder mo
);
293 SANITIZER_INTERFACE_ATTRIBUTE
294 a16
__tsan_atomic16_fetch_nand(volatile a16
*a
, a16 v
, morder mo
);
295 SANITIZER_INTERFACE_ATTRIBUTE
296 a32
__tsan_atomic32_fetch_nand(volatile a32
*a
, a32 v
, morder mo
);
297 SANITIZER_INTERFACE_ATTRIBUTE
298 a64
__tsan_atomic64_fetch_nand(volatile a64
*a
, a64 v
, morder mo
);
299 #if __TSAN_HAS_INT128
300 SANITIZER_INTERFACE_ATTRIBUTE
301 a128
__tsan_atomic128_fetch_nand(volatile a128
*a
, a128 v
, morder mo
);
304 SANITIZER_INTERFACE_ATTRIBUTE
305 int __tsan_atomic8_compare_exchange_strong(volatile a8
*a
, a8
*c
, a8 v
,
306 morder mo
, morder fmo
);
307 SANITIZER_INTERFACE_ATTRIBUTE
308 int __tsan_atomic16_compare_exchange_strong(volatile a16
*a
, a16
*c
, a16 v
,
309 morder mo
, morder fmo
);
310 SANITIZER_INTERFACE_ATTRIBUTE
311 int __tsan_atomic32_compare_exchange_strong(volatile a32
*a
, a32
*c
, a32 v
,
312 morder mo
, morder fmo
);
313 SANITIZER_INTERFACE_ATTRIBUTE
314 int __tsan_atomic64_compare_exchange_strong(volatile a64
*a
, a64
*c
, a64 v
,
315 morder mo
, morder fmo
);
316 #if __TSAN_HAS_INT128
317 SANITIZER_INTERFACE_ATTRIBUTE
318 int __tsan_atomic128_compare_exchange_strong(volatile a128
*a
, a128
*c
, a128 v
,
319 morder mo
, morder fmo
);
322 SANITIZER_INTERFACE_ATTRIBUTE
323 int __tsan_atomic8_compare_exchange_weak(volatile a8
*a
, a8
*c
, a8 v
, morder mo
,
325 SANITIZER_INTERFACE_ATTRIBUTE
326 int __tsan_atomic16_compare_exchange_weak(volatile a16
*a
, a16
*c
, a16 v
,
327 morder mo
, morder fmo
);
328 SANITIZER_INTERFACE_ATTRIBUTE
329 int __tsan_atomic32_compare_exchange_weak(volatile a32
*a
, a32
*c
, a32 v
,
330 morder mo
, morder fmo
);
331 SANITIZER_INTERFACE_ATTRIBUTE
332 int __tsan_atomic64_compare_exchange_weak(volatile a64
*a
, a64
*c
, a64 v
,
333 morder mo
, morder fmo
);
334 #if __TSAN_HAS_INT128
335 SANITIZER_INTERFACE_ATTRIBUTE
336 int __tsan_atomic128_compare_exchange_weak(volatile a128
*a
, a128
*c
, a128 v
,
337 morder mo
, morder fmo
);
340 SANITIZER_INTERFACE_ATTRIBUTE
341 a8
__tsan_atomic8_compare_exchange_val(volatile a8
*a
, a8 c
, a8 v
, morder mo
,
343 SANITIZER_INTERFACE_ATTRIBUTE
344 a16
__tsan_atomic16_compare_exchange_val(volatile a16
*a
, a16 c
, a16 v
,
345 morder mo
, morder fmo
);
346 SANITIZER_INTERFACE_ATTRIBUTE
347 a32
__tsan_atomic32_compare_exchange_val(volatile a32
*a
, a32 c
, a32 v
,
348 morder mo
, morder fmo
);
349 SANITIZER_INTERFACE_ATTRIBUTE
350 a64
__tsan_atomic64_compare_exchange_val(volatile a64
*a
, a64 c
, a64 v
,
351 morder mo
, morder fmo
);
352 #if __TSAN_HAS_INT128
353 SANITIZER_INTERFACE_ATTRIBUTE
354 a128
__tsan_atomic128_compare_exchange_val(volatile a128
*a
, a128 c
, a128 v
,
355 morder mo
, morder fmo
);
358 SANITIZER_INTERFACE_ATTRIBUTE
359 void __tsan_atomic_thread_fence(morder mo
);
360 SANITIZER_INTERFACE_ATTRIBUTE
361 void __tsan_atomic_signal_fence(morder mo
);
363 SANITIZER_INTERFACE_ATTRIBUTE
364 void __tsan_go_atomic32_load(ThreadState
*thr
, uptr cpc
, uptr pc
, u8
*a
);
365 SANITIZER_INTERFACE_ATTRIBUTE
366 void __tsan_go_atomic64_load(ThreadState
*thr
, uptr cpc
, uptr pc
, u8
*a
);
367 SANITIZER_INTERFACE_ATTRIBUTE
368 void __tsan_go_atomic32_store(ThreadState
*thr
, uptr cpc
, uptr pc
, u8
*a
);
369 SANITIZER_INTERFACE_ATTRIBUTE
370 void __tsan_go_atomic64_store(ThreadState
*thr
, uptr cpc
, uptr pc
, u8
*a
);
371 SANITIZER_INTERFACE_ATTRIBUTE
372 void __tsan_go_atomic32_fetch_add(ThreadState
*thr
, uptr cpc
, uptr pc
, u8
*a
);
373 SANITIZER_INTERFACE_ATTRIBUTE
374 void __tsan_go_atomic64_fetch_add(ThreadState
*thr
, uptr cpc
, uptr pc
, u8
*a
);
375 SANITIZER_INTERFACE_ATTRIBUTE
376 void __tsan_go_atomic32_exchange(ThreadState
*thr
, uptr cpc
, uptr pc
, u8
*a
);
377 SANITIZER_INTERFACE_ATTRIBUTE
378 void __tsan_go_atomic64_exchange(ThreadState
*thr
, uptr cpc
, uptr pc
, u8
*a
);
379 SANITIZER_INTERFACE_ATTRIBUTE
380 void __tsan_go_atomic32_compare_exchange(ThreadState
*thr
, uptr cpc
, uptr pc
,
382 SANITIZER_INTERFACE_ATTRIBUTE
383 void __tsan_go_atomic64_compare_exchange(ThreadState
*thr
, uptr cpc
, uptr pc
,
387 } // namespace __tsan
389 #endif // TSAN_INTERFACE_H