1 //===-- tsan_interface.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 // The functions declared in this header will be inserted by the instrumentation 12 // module. 13 // This header can be included by the instrumented program or by TSan tests. 14 //===----------------------------------------------------------------------===// 15 #ifndef TSAN_INTERFACE_H 16 #define TSAN_INTERFACE_H 17 18 #include <sanitizer_common/sanitizer_internal_defs.h> 19 using __sanitizer::tid_t; 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 SANITIZER_WEAK_ATTRIBUTE const char * 36 __tsan_default_options(); 37 38 SANITIZER_INTERFACE_ATTRIBUTE void __tsan_flush_memory(); 39 40 SANITIZER_INTERFACE_ATTRIBUTE void __tsan_read1(void *addr); 41 SANITIZER_INTERFACE_ATTRIBUTE void __tsan_read2(void *addr); 42 SANITIZER_INTERFACE_ATTRIBUTE void __tsan_read4(void *addr); 43 SANITIZER_INTERFACE_ATTRIBUTE void __tsan_read8(void *addr); 44 SANITIZER_INTERFACE_ATTRIBUTE void __tsan_read16(void *addr); 45 46 SANITIZER_INTERFACE_ATTRIBUTE void __tsan_write1(void *addr); 47 SANITIZER_INTERFACE_ATTRIBUTE void __tsan_write2(void *addr); 48 SANITIZER_INTERFACE_ATTRIBUTE void __tsan_write4(void *addr); 49 SANITIZER_INTERFACE_ATTRIBUTE void __tsan_write8(void *addr); 50 SANITIZER_INTERFACE_ATTRIBUTE void __tsan_write16(void *addr); 51 52 SANITIZER_INTERFACE_ATTRIBUTE void __tsan_unaligned_read2(const void *addr); 53 SANITIZER_INTERFACE_ATTRIBUTE void __tsan_unaligned_read4(const void *addr); 54 SANITIZER_INTERFACE_ATTRIBUTE void __tsan_unaligned_read8(const void *addr); 55 SANITIZER_INTERFACE_ATTRIBUTE void __tsan_unaligned_read16(const void *addr); 56 57 SANITIZER_INTERFACE_ATTRIBUTE void __tsan_unaligned_write2(void *addr); 58 SANITIZER_INTERFACE_ATTRIBUTE void __tsan_unaligned_write4(void *addr); 59 SANITIZER_INTERFACE_ATTRIBUTE void __tsan_unaligned_write8(void *addr); 60 SANITIZER_INTERFACE_ATTRIBUTE void __tsan_unaligned_write16(void *addr); 61 62 SANITIZER_INTERFACE_ATTRIBUTE void __tsan_read1_pc(void *addr, void *pc); 63 SANITIZER_INTERFACE_ATTRIBUTE void __tsan_read2_pc(void *addr, void *pc); 64 SANITIZER_INTERFACE_ATTRIBUTE void __tsan_read4_pc(void *addr, void *pc); 65 SANITIZER_INTERFACE_ATTRIBUTE void __tsan_read8_pc(void *addr, void *pc); 66 SANITIZER_INTERFACE_ATTRIBUTE void __tsan_read16_pc(void *addr, void *pc); 67 68 SANITIZER_INTERFACE_ATTRIBUTE void __tsan_write1_pc(void *addr, void *pc); 69 SANITIZER_INTERFACE_ATTRIBUTE void __tsan_write2_pc(void *addr, void *pc); 70 SANITIZER_INTERFACE_ATTRIBUTE void __tsan_write4_pc(void *addr, void *pc); 71 SANITIZER_INTERFACE_ATTRIBUTE void __tsan_write8_pc(void *addr, void *pc); 72 SANITIZER_INTERFACE_ATTRIBUTE void __tsan_write16_pc(void *addr, void *pc); 73 74 SANITIZER_INTERFACE_ATTRIBUTE void __tsan_vptr_read(void **vptr_p); 75 SANITIZER_INTERFACE_ATTRIBUTE 76 void __tsan_vptr_update(void **vptr_p, void *new_val); 77 78 SANITIZER_INTERFACE_ATTRIBUTE 79 void *__tsan_memcpy(void *dest, const void *src, uptr count); 80 SANITIZER_INTERFACE_ATTRIBUTE 81 void *__tsan_memset(void *dest, int ch, uptr count); 82 SANITIZER_INTERFACE_ATTRIBUTE 83 void *__tsan_memmove(void *dest, const void *src, uptr count); 84 85 SANITIZER_INTERFACE_ATTRIBUTE void __tsan_func_entry(void *call_pc); 86 SANITIZER_INTERFACE_ATTRIBUTE void __tsan_func_exit(); 87 88 SANITIZER_INTERFACE_ATTRIBUTE void __tsan_ignore_thread_begin(); 89 SANITIZER_INTERFACE_ATTRIBUTE void __tsan_ignore_thread_end(); 90 91 SANITIZER_INTERFACE_ATTRIBUTE void __tsan_on_thread_idle(); 92 93 SANITIZER_INTERFACE_ATTRIBUTE 94 void *__tsan_external_register_tag(const char *object_type); 95 SANITIZER_INTERFACE_ATTRIBUTE 96 void __tsan_external_register_header(void *tag, const char *header); 97 SANITIZER_INTERFACE_ATTRIBUTE 98 void __tsan_external_assign_tag(void *addr, void *tag); 99 SANITIZER_INTERFACE_ATTRIBUTE 100 void __tsan_external_read(void *addr, void *caller_pc, void *tag); 101 SANITIZER_INTERFACE_ATTRIBUTE 102 void __tsan_external_write(void *addr, void *caller_pc, void *tag); 103 104 SANITIZER_INTERFACE_ATTRIBUTE 105 void __tsan_read_range(void *addr, unsigned long size); 106 SANITIZER_INTERFACE_ATTRIBUTE 107 void __tsan_write_range(void *addr, unsigned long size); 108 109 SANITIZER_INTERFACE_ATTRIBUTE 110 void __tsan_read_range_pc(void *addr, unsigned long size, void *pc); 111 SANITIZER_INTERFACE_ATTRIBUTE 112 void __tsan_write_range_pc(void *addr, unsigned long size, void *pc); 113 114 // User may provide function that would be called right when TSan detects 115 // an error. The argument 'report' is an opaque pointer that can be used to 116 // gather additional information using other TSan report API functions. 117 SANITIZER_INTERFACE_ATTRIBUTE 118 void __tsan_on_report(void *report); 119 120 // If TSan is currently reporting a detected issue on the current thread, 121 // returns an opaque pointer to the current report. Otherwise returns NULL. 122 SANITIZER_INTERFACE_ATTRIBUTE 123 void *__tsan_get_current_report(); 124 125 // Returns a report's description (issue type), number of duplicate issues 126 // found, counts of array data (stack traces, memory operations, locations, 127 // mutexes, threads, unique thread IDs) and a stack trace of a sleep() call (if 128 // one was involved in the issue). 129 SANITIZER_INTERFACE_ATTRIBUTE 130 int __tsan_get_report_data(void *report, const char **description, int *count, 131 int *stack_count, int *mop_count, int *loc_count, 132 int *mutex_count, int *thread_count, 133 int *unique_tid_count, void **sleep_trace, 134 uptr trace_size); 135 136 /// Retrieves the "tag" from a report (for external-race report types). External 137 /// races can be associated with a tag which give them more meaning. For example 138 /// tag value '1' means "Swift access race". Tag value '0' indicated a plain 139 /// external race. 140 /// 141 /// \param report opaque pointer to the current report (obtained as argument in 142 /// __tsan_on_report, or from __tsan_get_current_report) 143 /// \param [out] tag points to storage that will be filled with the tag value 144 /// 145 /// \returns non-zero value on success, zero on failure 146 SANITIZER_INTERFACE_ATTRIBUTE 147 int __tsan_get_report_tag(void *report, uptr *tag); 148 149 // Returns information about stack traces included in the report. 150 SANITIZER_INTERFACE_ATTRIBUTE 151 int __tsan_get_report_stack(void *report, uptr idx, void **trace, 152 uptr trace_size); 153 154 // Returns information about memory operations included in the report. 155 SANITIZER_INTERFACE_ATTRIBUTE 156 int __tsan_get_report_mop(void *report, uptr idx, int *tid, void **addr, 157 int *size, int *write, int *atomic, void **trace, 158 uptr trace_size); 159 160 // Returns information about locations included in the report. 161 SANITIZER_INTERFACE_ATTRIBUTE 162 int __tsan_get_report_loc(void *report, uptr idx, const char **type, 163 void **addr, uptr *start, uptr *size, int *tid, 164 int *fd, int *suppressable, void **trace, 165 uptr trace_size); 166 167 SANITIZER_INTERFACE_ATTRIBUTE 168 int __tsan_get_report_loc_object_type(void *report, uptr idx, 169 const char **object_type); 170 171 // Returns information about mutexes included in the report. 172 SANITIZER_INTERFACE_ATTRIBUTE 173 int __tsan_get_report_mutex(void *report, uptr idx, uptr *mutex_id, void **addr, 174 int *destroyed, void **trace, uptr trace_size); 175 176 // Returns information about threads included in the report. 177 SANITIZER_INTERFACE_ATTRIBUTE 178 int __tsan_get_report_thread(void *report, uptr idx, int *tid, tid_t *os_id, 179 int *running, const char **name, int *parent_tid, 180 void **trace, uptr trace_size); 181 182 // Returns information about unique thread IDs included in the report. 183 SANITIZER_INTERFACE_ATTRIBUTE 184 int __tsan_get_report_unique_tid(void *report, uptr idx, int *tid); 185 186 // Returns the type of the pointer (heap, stack, global, ...) and if possible 187 // also the starting address (e.g. of a heap allocation) and size. 188 SANITIZER_INTERFACE_ATTRIBUTE 189 const char *__tsan_locate_address(uptr addr, char *name, uptr name_size, 190 uptr *region_address, uptr *region_size); 191 192 // Returns the allocation stack for a heap pointer. 193 SANITIZER_INTERFACE_ATTRIBUTE 194 int __tsan_get_alloc_stack(uptr addr, uptr *trace, uptr size, int *thread_id, 195 tid_t *os_id); 196 197 #endif // SANITIZER_GO 198 199 #ifdef __cplusplus 200 } // extern "C" 201 #endif 202 203 namespace __tsan { 204 205 // These should match declarations from public tsan_interface_atomic.h header. 206 typedef unsigned char a8; 207 typedef unsigned short a16; 208 typedef unsigned int a32; 209 typedef unsigned long long a64; 210 #if !SANITIZER_GO && \ 211 (defined(__SIZEOF_INT128__) || \ 212 (__clang_major__ * 100 + __clang_minor__ >= 302)) && \ 213 !defined(__mips64) && !defined(__s390x__) 214 __extension__ typedef __int128 a128; 215 # define __TSAN_HAS_INT128 1 216 #else 217 # define __TSAN_HAS_INT128 0 218 #endif 219 220 // Part of ABI, do not change. 221 // https://github.com/llvm/llvm-project/blob/main/libcxx/include/atomic 222 typedef enum { 223 mo_relaxed, 224 mo_consume, 225 mo_acquire, 226 mo_release, 227 mo_acq_rel, 228 mo_seq_cst 229 } morder; 230 231 struct ThreadState; 232 233 extern "C" { 234 SANITIZER_INTERFACE_ATTRIBUTE 235 a8 __tsan_atomic8_load(const volatile a8 *a, int mo); 236 SANITIZER_INTERFACE_ATTRIBUTE 237 a16 __tsan_atomic16_load(const volatile a16 *a, int mo); 238 SANITIZER_INTERFACE_ATTRIBUTE 239 a32 __tsan_atomic32_load(const volatile a32 *a, int mo); 240 SANITIZER_INTERFACE_ATTRIBUTE 241 a64 __tsan_atomic64_load(const volatile a64 *a, int mo); 242 #if __TSAN_HAS_INT128 243 SANITIZER_INTERFACE_ATTRIBUTE 244 a128 __tsan_atomic128_load(const volatile a128 *a, int mo); 245 #endif 246 247 SANITIZER_INTERFACE_ATTRIBUTE 248 void __tsan_atomic8_store(volatile a8 *a, a8 v, int mo); 249 SANITIZER_INTERFACE_ATTRIBUTE 250 void __tsan_atomic16_store(volatile a16 *a, a16 v, int mo); 251 SANITIZER_INTERFACE_ATTRIBUTE 252 void __tsan_atomic32_store(volatile a32 *a, a32 v, int mo); 253 SANITIZER_INTERFACE_ATTRIBUTE 254 void __tsan_atomic64_store(volatile a64 *a, a64 v, int mo); 255 #if __TSAN_HAS_INT128 256 SANITIZER_INTERFACE_ATTRIBUTE 257 void __tsan_atomic128_store(volatile a128 *a, a128 v, int mo); 258 #endif 259 260 SANITIZER_INTERFACE_ATTRIBUTE 261 a8 __tsan_atomic8_exchange(volatile a8 *a, a8 v, int mo); 262 SANITIZER_INTERFACE_ATTRIBUTE 263 a16 __tsan_atomic16_exchange(volatile a16 *a, a16 v, int mo); 264 SANITIZER_INTERFACE_ATTRIBUTE 265 a32 __tsan_atomic32_exchange(volatile a32 *a, a32 v, int mo); 266 SANITIZER_INTERFACE_ATTRIBUTE 267 a64 __tsan_atomic64_exchange(volatile a64 *a, a64 v, int mo); 268 #if __TSAN_HAS_INT128 269 SANITIZER_INTERFACE_ATTRIBUTE 270 a128 __tsan_atomic128_exchange(volatile a128 *a, a128 v, int mo); 271 #endif 272 273 SANITIZER_INTERFACE_ATTRIBUTE 274 a8 __tsan_atomic8_fetch_add(volatile a8 *a, a8 v, int mo); 275 SANITIZER_INTERFACE_ATTRIBUTE 276 a16 __tsan_atomic16_fetch_add(volatile a16 *a, a16 v, int mo); 277 SANITIZER_INTERFACE_ATTRIBUTE 278 a32 __tsan_atomic32_fetch_add(volatile a32 *a, a32 v, int mo); 279 SANITIZER_INTERFACE_ATTRIBUTE 280 a64 __tsan_atomic64_fetch_add(volatile a64 *a, a64 v, int mo); 281 #if __TSAN_HAS_INT128 282 SANITIZER_INTERFACE_ATTRIBUTE 283 a128 __tsan_atomic128_fetch_add(volatile a128 *a, a128 v, int mo); 284 #endif 285 286 SANITIZER_INTERFACE_ATTRIBUTE 287 a8 __tsan_atomic8_fetch_sub(volatile a8 *a, a8 v, int mo); 288 SANITIZER_INTERFACE_ATTRIBUTE 289 a16 __tsan_atomic16_fetch_sub(volatile a16 *a, a16 v, int mo); 290 SANITIZER_INTERFACE_ATTRIBUTE 291 a32 __tsan_atomic32_fetch_sub(volatile a32 *a, a32 v, int mo); 292 SANITIZER_INTERFACE_ATTRIBUTE 293 a64 __tsan_atomic64_fetch_sub(volatile a64 *a, a64 v, int mo); 294 #if __TSAN_HAS_INT128 295 SANITIZER_INTERFACE_ATTRIBUTE 296 a128 __tsan_atomic128_fetch_sub(volatile a128 *a, a128 v, int mo); 297 #endif 298 299 SANITIZER_INTERFACE_ATTRIBUTE 300 a8 __tsan_atomic8_fetch_and(volatile a8 *a, a8 v, int mo); 301 SANITIZER_INTERFACE_ATTRIBUTE 302 a16 __tsan_atomic16_fetch_and(volatile a16 *a, a16 v, int mo); 303 SANITIZER_INTERFACE_ATTRIBUTE 304 a32 __tsan_atomic32_fetch_and(volatile a32 *a, a32 v, int mo); 305 SANITIZER_INTERFACE_ATTRIBUTE 306 a64 __tsan_atomic64_fetch_and(volatile a64 *a, a64 v, int mo); 307 #if __TSAN_HAS_INT128 308 SANITIZER_INTERFACE_ATTRIBUTE 309 a128 __tsan_atomic128_fetch_and(volatile a128 *a, a128 v, int mo); 310 #endif 311 312 SANITIZER_INTERFACE_ATTRIBUTE 313 a8 __tsan_atomic8_fetch_or(volatile a8 *a, a8 v, int mo); 314 SANITIZER_INTERFACE_ATTRIBUTE 315 a16 __tsan_atomic16_fetch_or(volatile a16 *a, a16 v, int mo); 316 SANITIZER_INTERFACE_ATTRIBUTE 317 a32 __tsan_atomic32_fetch_or(volatile a32 *a, a32 v, int mo); 318 SANITIZER_INTERFACE_ATTRIBUTE 319 a64 __tsan_atomic64_fetch_or(volatile a64 *a, a64 v, int mo); 320 #if __TSAN_HAS_INT128 321 SANITIZER_INTERFACE_ATTRIBUTE 322 a128 __tsan_atomic128_fetch_or(volatile a128 *a, a128 v, int mo); 323 #endif 324 325 SANITIZER_INTERFACE_ATTRIBUTE 326 a8 __tsan_atomic8_fetch_xor(volatile a8 *a, a8 v, int mo); 327 SANITIZER_INTERFACE_ATTRIBUTE 328 a16 __tsan_atomic16_fetch_xor(volatile a16 *a, a16 v, int mo); 329 SANITIZER_INTERFACE_ATTRIBUTE 330 a32 __tsan_atomic32_fetch_xor(volatile a32 *a, a32 v, int mo); 331 SANITIZER_INTERFACE_ATTRIBUTE 332 a64 __tsan_atomic64_fetch_xor(volatile a64 *a, a64 v, int mo); 333 #if __TSAN_HAS_INT128 334 SANITIZER_INTERFACE_ATTRIBUTE 335 a128 __tsan_atomic128_fetch_xor(volatile a128 *a, a128 v, int mo); 336 #endif 337 338 SANITIZER_INTERFACE_ATTRIBUTE 339 a8 __tsan_atomic8_fetch_nand(volatile a8 *a, a8 v, int mo); 340 SANITIZER_INTERFACE_ATTRIBUTE 341 a16 __tsan_atomic16_fetch_nand(volatile a16 *a, a16 v, int mo); 342 SANITIZER_INTERFACE_ATTRIBUTE 343 a32 __tsan_atomic32_fetch_nand(volatile a32 *a, a32 v, int mo); 344 SANITIZER_INTERFACE_ATTRIBUTE 345 a64 __tsan_atomic64_fetch_nand(volatile a64 *a, a64 v, int mo); 346 #if __TSAN_HAS_INT128 347 SANITIZER_INTERFACE_ATTRIBUTE 348 a128 __tsan_atomic128_fetch_nand(volatile a128 *a, a128 v, int mo); 349 #endif 350 351 SANITIZER_INTERFACE_ATTRIBUTE 352 int __tsan_atomic8_compare_exchange_strong(volatile a8 *a, a8 *c, a8 v, int mo, 353 int fmo); 354 SANITIZER_INTERFACE_ATTRIBUTE 355 int __tsan_atomic16_compare_exchange_strong(volatile a16 *a, a16 *c, a16 v, 356 int mo, int fmo); 357 SANITIZER_INTERFACE_ATTRIBUTE 358 int __tsan_atomic32_compare_exchange_strong(volatile a32 *a, a32 *c, a32 v, 359 int mo, int fmo); 360 SANITIZER_INTERFACE_ATTRIBUTE 361 int __tsan_atomic64_compare_exchange_strong(volatile a64 *a, a64 *c, a64 v, 362 int mo, int fmo); 363 #if __TSAN_HAS_INT128 364 SANITIZER_INTERFACE_ATTRIBUTE 365 int __tsan_atomic128_compare_exchange_strong(volatile a128 *a, a128 *c, a128 v, 366 int mo, int fmo); 367 #endif 368 369 SANITIZER_INTERFACE_ATTRIBUTE 370 int __tsan_atomic8_compare_exchange_weak(volatile a8 *a, a8 *c, a8 v, int mo, 371 int fmo); 372 SANITIZER_INTERFACE_ATTRIBUTE 373 int __tsan_atomic16_compare_exchange_weak(volatile a16 *a, a16 *c, a16 v, 374 int mo, int fmo); 375 SANITIZER_INTERFACE_ATTRIBUTE 376 int __tsan_atomic32_compare_exchange_weak(volatile a32 *a, a32 *c, a32 v, 377 int mo, int fmo); 378 SANITIZER_INTERFACE_ATTRIBUTE 379 int __tsan_atomic64_compare_exchange_weak(volatile a64 *a, a64 *c, a64 v, 380 int mo, int fmo); 381 #if __TSAN_HAS_INT128 382 SANITIZER_INTERFACE_ATTRIBUTE 383 int __tsan_atomic128_compare_exchange_weak(volatile a128 *a, a128 *c, a128 v, 384 int mo, int fmo); 385 #endif 386 387 SANITIZER_INTERFACE_ATTRIBUTE 388 a8 __tsan_atomic8_compare_exchange_val(volatile a8 *a, a8 c, a8 v, int mo, 389 int fmo); 390 SANITIZER_INTERFACE_ATTRIBUTE 391 a16 __tsan_atomic16_compare_exchange_val(volatile a16 *a, a16 c, a16 v, int mo, 392 int fmo); 393 SANITIZER_INTERFACE_ATTRIBUTE 394 a32 __tsan_atomic32_compare_exchange_val(volatile a32 *a, a32 c, a32 v, int mo, 395 int fmo); 396 SANITIZER_INTERFACE_ATTRIBUTE 397 a64 __tsan_atomic64_compare_exchange_val(volatile a64 *a, a64 c, a64 v, int mo, 398 int fmo); 399 #if __TSAN_HAS_INT128 400 SANITIZER_INTERFACE_ATTRIBUTE 401 a128 __tsan_atomic128_compare_exchange_val(volatile a128 *a, a128 c, a128 v, 402 int mo, int fmo); 403 #endif 404 405 SANITIZER_INTERFACE_ATTRIBUTE 406 void __tsan_atomic_thread_fence(int mo); 407 SANITIZER_INTERFACE_ATTRIBUTE 408 void __tsan_atomic_signal_fence(int mo); 409 410 SANITIZER_INTERFACE_ATTRIBUTE 411 void __tsan_go_atomic32_load(ThreadState *thr, uptr cpc, uptr pc, u8 *a); 412 SANITIZER_INTERFACE_ATTRIBUTE 413 void __tsan_go_atomic64_load(ThreadState *thr, uptr cpc, uptr pc, u8 *a); 414 SANITIZER_INTERFACE_ATTRIBUTE 415 void __tsan_go_atomic32_store(ThreadState *thr, uptr cpc, uptr pc, u8 *a); 416 SANITIZER_INTERFACE_ATTRIBUTE 417 void __tsan_go_atomic64_store(ThreadState *thr, uptr cpc, uptr pc, u8 *a); 418 SANITIZER_INTERFACE_ATTRIBUTE 419 void __tsan_go_atomic32_fetch_add(ThreadState *thr, uptr cpc, uptr pc, u8 *a); 420 SANITIZER_INTERFACE_ATTRIBUTE 421 void __tsan_go_atomic64_fetch_add(ThreadState *thr, uptr cpc, uptr pc, u8 *a); 422 SANITIZER_INTERFACE_ATTRIBUTE 423 void __tsan_go_atomic32_fetch_and(ThreadState *thr, uptr cpc, uptr pc, u8 *a); 424 SANITIZER_INTERFACE_ATTRIBUTE 425 void __tsan_go_atomic64_fetch_and(ThreadState *thr, uptr cpc, uptr pc, u8 *a); 426 SANITIZER_INTERFACE_ATTRIBUTE 427 void __tsan_go_atomic32_fetch_or(ThreadState *thr, uptr cpc, uptr pc, u8 *a); 428 SANITIZER_INTERFACE_ATTRIBUTE 429 void __tsan_go_atomic64_fetch_or(ThreadState *thr, uptr cpc, uptr pc, u8 *a); 430 SANITIZER_INTERFACE_ATTRIBUTE 431 void __tsan_go_atomic32_exchange(ThreadState *thr, uptr cpc, uptr pc, u8 *a); 432 SANITIZER_INTERFACE_ATTRIBUTE 433 void __tsan_go_atomic64_exchange(ThreadState *thr, uptr cpc, uptr pc, u8 *a); 434 SANITIZER_INTERFACE_ATTRIBUTE 435 void __tsan_go_atomic32_compare_exchange(ThreadState *thr, uptr cpc, uptr pc, 436 u8 *a); 437 SANITIZER_INTERFACE_ATTRIBUTE 438 void __tsan_go_atomic64_compare_exchange(ThreadState *thr, uptr cpc, uptr pc, 439 u8 *a); 440 441 } // extern "C" 442 443 } // namespace __tsan 444 445 #endif // TSAN_INTERFACE_H 446