1//===-- tsan_interface.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// The functions declared in this header will be inserted by the instrumentation 13// module. 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 18 19#include <sanitizer_common/sanitizer_internal_defs.h> 20 21// This header should NOT include any other headers. 22// All functions in this header are extern "C" and start with __tsan_. 23 24#ifdef __cplusplus 25extern "C" { 26#endif 27 28#ifndef SANITIZER_GO 29 30// This function should be called at the very beginning of the process, 31// before any instrumented code is executed and before any call to malloc. 32SANITIZER_INTERFACE_ATTRIBUTE void __tsan_init(); 33 34SANITIZER_INTERFACE_ATTRIBUTE void __tsan_read1(void *addr); 35SANITIZER_INTERFACE_ATTRIBUTE void __tsan_read2(void *addr); 36SANITIZER_INTERFACE_ATTRIBUTE void __tsan_read4(void *addr); 37SANITIZER_INTERFACE_ATTRIBUTE void __tsan_read8(void *addr); 38SANITIZER_INTERFACE_ATTRIBUTE void __tsan_read16(void *addr); 39 40SANITIZER_INTERFACE_ATTRIBUTE void __tsan_write1(void *addr); 41SANITIZER_INTERFACE_ATTRIBUTE void __tsan_write2(void *addr); 42SANITIZER_INTERFACE_ATTRIBUTE void __tsan_write4(void *addr); 43SANITIZER_INTERFACE_ATTRIBUTE void __tsan_write8(void *addr); 44SANITIZER_INTERFACE_ATTRIBUTE void __tsan_write16(void *addr); 45 46SANITIZER_INTERFACE_ATTRIBUTE void __tsan_unaligned_read2(const void *addr); 47SANITIZER_INTERFACE_ATTRIBUTE void __tsan_unaligned_read4(const void *addr); 48SANITIZER_INTERFACE_ATTRIBUTE void __tsan_unaligned_read8(const void *addr); 49SANITIZER_INTERFACE_ATTRIBUTE void __tsan_unaligned_read16(const void *addr); 50 51SANITIZER_INTERFACE_ATTRIBUTE void __tsan_unaligned_write2(void *addr); 52SANITIZER_INTERFACE_ATTRIBUTE void __tsan_unaligned_write4(void *addr); 53SANITIZER_INTERFACE_ATTRIBUTE void __tsan_unaligned_write8(void *addr); 54SANITIZER_INTERFACE_ATTRIBUTE void __tsan_unaligned_write16(void *addr); 55 56SANITIZER_INTERFACE_ATTRIBUTE void __tsan_read1_pc(void *addr, void *pc); 57SANITIZER_INTERFACE_ATTRIBUTE void __tsan_read2_pc(void *addr, void *pc); 58SANITIZER_INTERFACE_ATTRIBUTE void __tsan_read4_pc(void *addr, void *pc); 59SANITIZER_INTERFACE_ATTRIBUTE void __tsan_read8_pc(void *addr, void *pc); 60SANITIZER_INTERFACE_ATTRIBUTE void __tsan_read16_pc(void *addr, void *pc); 61 62SANITIZER_INTERFACE_ATTRIBUTE void __tsan_write1_pc(void *addr, void *pc); 63SANITIZER_INTERFACE_ATTRIBUTE void __tsan_write2_pc(void *addr, void *pc); 64SANITIZER_INTERFACE_ATTRIBUTE void __tsan_write4_pc(void *addr, void *pc); 65SANITIZER_INTERFACE_ATTRIBUTE void __tsan_write8_pc(void *addr, void *pc); 66SANITIZER_INTERFACE_ATTRIBUTE void __tsan_write16_pc(void *addr, void *pc); 67 68SANITIZER_INTERFACE_ATTRIBUTE void __tsan_vptr_read(void **vptr_p); 69SANITIZER_INTERFACE_ATTRIBUTE 70void __tsan_vptr_update(void **vptr_p, void *new_val); 71 72SANITIZER_INTERFACE_ATTRIBUTE void __tsan_func_entry(void *call_pc); 73SANITIZER_INTERFACE_ATTRIBUTE void __tsan_func_exit(); 74 75SANITIZER_INTERFACE_ATTRIBUTE 76void __tsan_read_range(void *addr, unsigned long size); // NOLINT 77SANITIZER_INTERFACE_ATTRIBUTE 78void __tsan_write_range(void *addr, unsigned long size); // NOLINT 79 80// User may provide function that would be called right when TSan detects 81// an error. The argument 'report' is an opaque pointer that can be used to 82// gather additional information using other TSan report API functions. 83SANITIZER_INTERFACE_ATTRIBUTE 84void __tsan_on_report(void *report); 85 86// If TSan is currently reporting a detected issue on the current thread, 87// returns an opaque pointer to the current report. Otherwise returns NULL. 88SANITIZER_INTERFACE_ATTRIBUTE 89void *__tsan_get_current_report(); 90 91// Returns a report's description (issue type), number of duplicate issues 92// found, counts of array data (stack traces, memory operations, locations, 93// mutexes, threads, unique thread IDs) and a stack trace of a sleep() call (if 94// one was involved in the issue). 95SANITIZER_INTERFACE_ATTRIBUTE 96int __tsan_get_report_data(void *report, const char **description, int *count, 97 int *stack_count, int *mop_count, int *loc_count, 98 int *mutex_count, int *thread_count, 99 int *unique_tid_count, void **sleep_trace, 100 uptr trace_size); 101 102// Returns information about stack traces included in the report. 103SANITIZER_INTERFACE_ATTRIBUTE 104int __tsan_get_report_stack(void *report, uptr idx, void **trace, 105 uptr trace_size); 106 107// Returns information about memory operations included in the report. 108SANITIZER_INTERFACE_ATTRIBUTE 109int __tsan_get_report_mop(void *report, uptr idx, int *tid, void **addr, 110 int *size, int *write, int *atomic, void **trace, 111 uptr trace_size); 112 113// Returns information about locations included in the report. 114SANITIZER_INTERFACE_ATTRIBUTE 115int __tsan_get_report_loc(void *report, uptr idx, const char **type, 116 void **addr, uptr *start, uptr *size, int *tid, 117 int *fd, int *suppressable, void **trace, 118 uptr trace_size); 119 120// Returns information about mutexes included in the report. 121SANITIZER_INTERFACE_ATTRIBUTE 122int __tsan_get_report_mutex(void *report, uptr idx, uptr *mutex_id, void **addr, 123 int *destroyed, void **trace, uptr trace_size); 124 125// Returns information about threads included in the report. 126SANITIZER_INTERFACE_ATTRIBUTE 127int __tsan_get_report_thread(void *report, uptr idx, int *tid, uptr *os_id, 128 int *running, const char **name, int *parent_tid, 129 void **trace, uptr trace_size); 130 131// Returns information about unique thread IDs included in the report. 132SANITIZER_INTERFACE_ATTRIBUTE 133int __tsan_get_report_unique_tid(void *report, uptr idx, int *tid); 134 135#endif // SANITIZER_GO 136 137#ifdef __cplusplus 138} // extern "C" 139#endif 140 141namespace __tsan { 142 143// These should match declarations from public tsan_interface_atomic.h header. 144typedef unsigned char a8; 145typedef unsigned short a16; // NOLINT 146typedef unsigned int a32; 147typedef unsigned long long a64; // NOLINT 148#if !defined(SANITIZER_GO) && (defined(__SIZEOF_INT128__) \ 149 || (__clang_major__ * 100 + __clang_minor__ >= 302)) && !defined(__mips64) 150__extension__ typedef __int128 a128; 151# define __TSAN_HAS_INT128 1 152#else 153# define __TSAN_HAS_INT128 0 154#endif 155 156// Part of ABI, do not change. 157// http://llvm.org/viewvc/llvm-project/libcxx/trunk/include/atomic?view=markup 158typedef enum { 159 mo_relaxed, 160 mo_consume, 161 mo_acquire, 162 mo_release, 163 mo_acq_rel, 164 mo_seq_cst 165} morder; 166 167struct ThreadState; 168 169extern "C" { 170SANITIZER_INTERFACE_ATTRIBUTE 171a8 __tsan_atomic8_load(const volatile a8 *a, morder mo); 172SANITIZER_INTERFACE_ATTRIBUTE 173a16 __tsan_atomic16_load(const volatile a16 *a, morder mo); 174SANITIZER_INTERFACE_ATTRIBUTE 175a32 __tsan_atomic32_load(const volatile a32 *a, morder mo); 176SANITIZER_INTERFACE_ATTRIBUTE 177a64 __tsan_atomic64_load(const volatile a64 *a, morder mo); 178#if __TSAN_HAS_INT128 179SANITIZER_INTERFACE_ATTRIBUTE 180a128 __tsan_atomic128_load(const volatile a128 *a, morder mo); 181#endif 182 183SANITIZER_INTERFACE_ATTRIBUTE 184void __tsan_atomic8_store(volatile a8 *a, a8 v, morder mo); 185SANITIZER_INTERFACE_ATTRIBUTE 186void __tsan_atomic16_store(volatile a16 *a, a16 v, morder mo); 187SANITIZER_INTERFACE_ATTRIBUTE 188void __tsan_atomic32_store(volatile a32 *a, a32 v, morder mo); 189SANITIZER_INTERFACE_ATTRIBUTE 190void __tsan_atomic64_store(volatile a64 *a, a64 v, morder mo); 191#if __TSAN_HAS_INT128 192SANITIZER_INTERFACE_ATTRIBUTE 193void __tsan_atomic128_store(volatile a128 *a, a128 v, morder mo); 194#endif 195 196SANITIZER_INTERFACE_ATTRIBUTE 197a8 __tsan_atomic8_exchange(volatile a8 *a, a8 v, morder mo); 198SANITIZER_INTERFACE_ATTRIBUTE 199a16 __tsan_atomic16_exchange(volatile a16 *a, a16 v, morder mo); 200SANITIZER_INTERFACE_ATTRIBUTE 201a32 __tsan_atomic32_exchange(volatile a32 *a, a32 v, morder mo); 202SANITIZER_INTERFACE_ATTRIBUTE 203a64 __tsan_atomic64_exchange(volatile a64 *a, a64 v, morder mo); 204#if __TSAN_HAS_INT128 205SANITIZER_INTERFACE_ATTRIBUTE 206a128 __tsan_atomic128_exchange(volatile a128 *a, a128 v, morder mo); 207#endif 208 209SANITIZER_INTERFACE_ATTRIBUTE 210a8 __tsan_atomic8_fetch_add(volatile a8 *a, a8 v, morder mo); 211SANITIZER_INTERFACE_ATTRIBUTE 212a16 __tsan_atomic16_fetch_add(volatile a16 *a, a16 v, morder mo); 213SANITIZER_INTERFACE_ATTRIBUTE 214a32 __tsan_atomic32_fetch_add(volatile a32 *a, a32 v, morder mo); 215SANITIZER_INTERFACE_ATTRIBUTE 216a64 __tsan_atomic64_fetch_add(volatile a64 *a, a64 v, morder mo); 217#if __TSAN_HAS_INT128 218SANITIZER_INTERFACE_ATTRIBUTE 219a128 __tsan_atomic128_fetch_add(volatile a128 *a, a128 v, morder mo); 220#endif 221 222SANITIZER_INTERFACE_ATTRIBUTE 223a8 __tsan_atomic8_fetch_sub(volatile a8 *a, a8 v, morder mo); 224SANITIZER_INTERFACE_ATTRIBUTE 225a16 __tsan_atomic16_fetch_sub(volatile a16 *a, a16 v, morder mo); 226SANITIZER_INTERFACE_ATTRIBUTE 227a32 __tsan_atomic32_fetch_sub(volatile a32 *a, a32 v, morder mo); 228SANITIZER_INTERFACE_ATTRIBUTE 229a64 __tsan_atomic64_fetch_sub(volatile a64 *a, a64 v, morder mo); 230#if __TSAN_HAS_INT128 231SANITIZER_INTERFACE_ATTRIBUTE 232a128 __tsan_atomic128_fetch_sub(volatile a128 *a, a128 v, morder mo); 233#endif 234 235SANITIZER_INTERFACE_ATTRIBUTE 236a8 __tsan_atomic8_fetch_and(volatile a8 *a, a8 v, morder mo); 237SANITIZER_INTERFACE_ATTRIBUTE 238a16 __tsan_atomic16_fetch_and(volatile a16 *a, a16 v, morder mo); 239SANITIZER_INTERFACE_ATTRIBUTE 240a32 __tsan_atomic32_fetch_and(volatile a32 *a, a32 v, morder mo); 241SANITIZER_INTERFACE_ATTRIBUTE 242a64 __tsan_atomic64_fetch_and(volatile a64 *a, a64 v, morder mo); 243#if __TSAN_HAS_INT128 244SANITIZER_INTERFACE_ATTRIBUTE 245a128 __tsan_atomic128_fetch_and(volatile a128 *a, a128 v, morder mo); 246#endif 247 248SANITIZER_INTERFACE_ATTRIBUTE 249a8 __tsan_atomic8_fetch_or(volatile a8 *a, a8 v, morder mo); 250SANITIZER_INTERFACE_ATTRIBUTE 251a16 __tsan_atomic16_fetch_or(volatile a16 *a, a16 v, morder mo); 252SANITIZER_INTERFACE_ATTRIBUTE 253a32 __tsan_atomic32_fetch_or(volatile a32 *a, a32 v, morder mo); 254SANITIZER_INTERFACE_ATTRIBUTE 255a64 __tsan_atomic64_fetch_or(volatile a64 *a, a64 v, morder mo); 256#if __TSAN_HAS_INT128 257SANITIZER_INTERFACE_ATTRIBUTE 258a128 __tsan_atomic128_fetch_or(volatile a128 *a, a128 v, morder mo); 259#endif 260 261SANITIZER_INTERFACE_ATTRIBUTE 262a8 __tsan_atomic8_fetch_xor(volatile a8 *a, a8 v, morder mo); 263SANITIZER_INTERFACE_ATTRIBUTE 264a16 __tsan_atomic16_fetch_xor(volatile a16 *a, a16 v, morder mo); 265SANITIZER_INTERFACE_ATTRIBUTE 266a32 __tsan_atomic32_fetch_xor(volatile a32 *a, a32 v, morder mo); 267SANITIZER_INTERFACE_ATTRIBUTE 268a64 __tsan_atomic64_fetch_xor(volatile a64 *a, a64 v, morder mo); 269#if __TSAN_HAS_INT128 270SANITIZER_INTERFACE_ATTRIBUTE 271a128 __tsan_atomic128_fetch_xor(volatile a128 *a, a128 v, morder mo); 272#endif 273 274SANITIZER_INTERFACE_ATTRIBUTE 275a8 __tsan_atomic8_fetch_nand(volatile a8 *a, a8 v, morder mo); 276SANITIZER_INTERFACE_ATTRIBUTE 277a16 __tsan_atomic16_fetch_nand(volatile a16 *a, a16 v, morder mo); 278SANITIZER_INTERFACE_ATTRIBUTE 279a32 __tsan_atomic32_fetch_nand(volatile a32 *a, a32 v, morder mo); 280SANITIZER_INTERFACE_ATTRIBUTE 281a64 __tsan_atomic64_fetch_nand(volatile a64 *a, a64 v, morder mo); 282#if __TSAN_HAS_INT128 283SANITIZER_INTERFACE_ATTRIBUTE 284a128 __tsan_atomic128_fetch_nand(volatile a128 *a, a128 v, morder mo); 285#endif 286 287SANITIZER_INTERFACE_ATTRIBUTE 288int __tsan_atomic8_compare_exchange_strong(volatile a8 *a, a8 *c, a8 v, 289 morder mo, morder fmo); 290SANITIZER_INTERFACE_ATTRIBUTE 291int __tsan_atomic16_compare_exchange_strong(volatile a16 *a, a16 *c, a16 v, 292 morder mo, morder fmo); 293SANITIZER_INTERFACE_ATTRIBUTE 294int __tsan_atomic32_compare_exchange_strong(volatile a32 *a, a32 *c, a32 v, 295 morder mo, morder fmo); 296SANITIZER_INTERFACE_ATTRIBUTE 297int __tsan_atomic64_compare_exchange_strong(volatile a64 *a, a64 *c, a64 v, 298 morder mo, morder fmo); 299#if __TSAN_HAS_INT128 300SANITIZER_INTERFACE_ATTRIBUTE 301int __tsan_atomic128_compare_exchange_strong(volatile a128 *a, a128 *c, a128 v, 302 morder mo, morder fmo); 303#endif 304 305SANITIZER_INTERFACE_ATTRIBUTE 306int __tsan_atomic8_compare_exchange_weak(volatile a8 *a, a8 *c, a8 v, morder mo, 307 morder fmo); 308SANITIZER_INTERFACE_ATTRIBUTE 309int __tsan_atomic16_compare_exchange_weak(volatile a16 *a, a16 *c, a16 v, 310 morder mo, morder fmo); 311SANITIZER_INTERFACE_ATTRIBUTE 312int __tsan_atomic32_compare_exchange_weak(volatile a32 *a, a32 *c, a32 v, 313 morder mo, morder fmo); 314SANITIZER_INTERFACE_ATTRIBUTE 315int __tsan_atomic64_compare_exchange_weak(volatile a64 *a, a64 *c, a64 v, 316 morder mo, morder fmo); 317#if __TSAN_HAS_INT128 318SANITIZER_INTERFACE_ATTRIBUTE 319int __tsan_atomic128_compare_exchange_weak(volatile a128 *a, a128 *c, a128 v, 320 morder mo, morder fmo); 321#endif 322 323SANITIZER_INTERFACE_ATTRIBUTE 324a8 __tsan_atomic8_compare_exchange_val(volatile a8 *a, a8 c, a8 v, morder mo, 325 morder fmo); 326SANITIZER_INTERFACE_ATTRIBUTE 327a16 __tsan_atomic16_compare_exchange_val(volatile a16 *a, a16 c, a16 v, 328 morder mo, morder fmo); 329SANITIZER_INTERFACE_ATTRIBUTE 330a32 __tsan_atomic32_compare_exchange_val(volatile a32 *a, a32 c, a32 v, 331 morder mo, morder fmo); 332SANITIZER_INTERFACE_ATTRIBUTE 333a64 __tsan_atomic64_compare_exchange_val(volatile a64 *a, a64 c, a64 v, 334 morder mo, morder fmo); 335#if __TSAN_HAS_INT128 336SANITIZER_INTERFACE_ATTRIBUTE 337a128 __tsan_atomic128_compare_exchange_val(volatile a128 *a, a128 c, a128 v, 338 morder mo, morder fmo); 339#endif 340 341SANITIZER_INTERFACE_ATTRIBUTE 342void __tsan_atomic_thread_fence(morder mo); 343SANITIZER_INTERFACE_ATTRIBUTE 344void __tsan_atomic_signal_fence(morder mo); 345 346SANITIZER_INTERFACE_ATTRIBUTE 347void __tsan_go_atomic32_load(ThreadState *thr, uptr cpc, uptr pc, u8 *a); 348SANITIZER_INTERFACE_ATTRIBUTE 349void __tsan_go_atomic64_load(ThreadState *thr, uptr cpc, uptr pc, u8 *a); 350SANITIZER_INTERFACE_ATTRIBUTE 351void __tsan_go_atomic32_store(ThreadState *thr, uptr cpc, uptr pc, u8 *a); 352SANITIZER_INTERFACE_ATTRIBUTE 353void __tsan_go_atomic64_store(ThreadState *thr, uptr cpc, uptr pc, u8 *a); 354SANITIZER_INTERFACE_ATTRIBUTE 355void __tsan_go_atomic32_fetch_add(ThreadState *thr, uptr cpc, uptr pc, u8 *a); 356SANITIZER_INTERFACE_ATTRIBUTE 357void __tsan_go_atomic64_fetch_add(ThreadState *thr, uptr cpc, uptr pc, u8 *a); 358SANITIZER_INTERFACE_ATTRIBUTE 359void __tsan_go_atomic32_exchange(ThreadState *thr, uptr cpc, uptr pc, u8 *a); 360SANITIZER_INTERFACE_ATTRIBUTE 361void __tsan_go_atomic64_exchange(ThreadState *thr, uptr cpc, uptr pc, u8 *a); 362SANITIZER_INTERFACE_ATTRIBUTE 363void __tsan_go_atomic32_compare_exchange(ThreadState *thr, uptr cpc, uptr pc, 364 u8 *a); 365SANITIZER_INTERFACE_ATTRIBUTE 366void __tsan_go_atomic64_compare_exchange(ThreadState *thr, uptr cpc, uptr pc, 367 u8 *a); 368} // extern "C" 369 370} // namespace __tsan 371 372#endif // TSAN_INTERFACE_H 373