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