13cab2bb3Spatrick //===-- tsan_interface.h ----------------------------------------*- C++ -*-===// 23cab2bb3Spatrick // 33cab2bb3Spatrick // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 43cab2bb3Spatrick // See https://llvm.org/LICENSE.txt for license information. 53cab2bb3Spatrick // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 63cab2bb3Spatrick // 73cab2bb3Spatrick //===----------------------------------------------------------------------===// 83cab2bb3Spatrick // 93cab2bb3Spatrick // This file is a part of ThreadSanitizer (TSan), a race detector. 103cab2bb3Spatrick // 113cab2bb3Spatrick // The functions declared in this header will be inserted by the instrumentation 123cab2bb3Spatrick // module. 133cab2bb3Spatrick // This header can be included by the instrumented program or by TSan tests. 143cab2bb3Spatrick //===----------------------------------------------------------------------===// 153cab2bb3Spatrick #ifndef TSAN_INTERFACE_H 163cab2bb3Spatrick #define TSAN_INTERFACE_H 173cab2bb3Spatrick 183cab2bb3Spatrick #include <sanitizer_common/sanitizer_internal_defs.h> 193cab2bb3Spatrick using __sanitizer::uptr; 203cab2bb3Spatrick using __sanitizer::tid_t; 213cab2bb3Spatrick 223cab2bb3Spatrick // This header should NOT include any other headers. 233cab2bb3Spatrick // All functions in this header are extern "C" and start with __tsan_. 243cab2bb3Spatrick 253cab2bb3Spatrick #ifdef __cplusplus 263cab2bb3Spatrick extern "C" { 273cab2bb3Spatrick #endif 283cab2bb3Spatrick 293cab2bb3Spatrick #if !SANITIZER_GO 303cab2bb3Spatrick 313cab2bb3Spatrick // This function should be called at the very beginning of the process, 323cab2bb3Spatrick // before any instrumented code is executed and before any call to malloc. 333cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE void __tsan_init(); 343cab2bb3Spatrick 353cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE void __tsan_flush_memory(); 363cab2bb3Spatrick 373cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE void __tsan_read1(void *addr); 383cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE void __tsan_read2(void *addr); 393cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE void __tsan_read4(void *addr); 403cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE void __tsan_read8(void *addr); 413cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE void __tsan_read16(void *addr); 423cab2bb3Spatrick 433cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE void __tsan_write1(void *addr); 443cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE void __tsan_write2(void *addr); 453cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE void __tsan_write4(void *addr); 463cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE void __tsan_write8(void *addr); 473cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE void __tsan_write16(void *addr); 483cab2bb3Spatrick 493cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE void __tsan_unaligned_read2(const void *addr); 503cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE void __tsan_unaligned_read4(const void *addr); 513cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE void __tsan_unaligned_read8(const void *addr); 523cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE void __tsan_unaligned_read16(const void *addr); 533cab2bb3Spatrick 543cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE void __tsan_unaligned_write2(void *addr); 553cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE void __tsan_unaligned_write4(void *addr); 563cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE void __tsan_unaligned_write8(void *addr); 573cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE void __tsan_unaligned_write16(void *addr); 583cab2bb3Spatrick 593cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE void __tsan_read1_pc(void *addr, void *pc); 603cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE void __tsan_read2_pc(void *addr, void *pc); 613cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE void __tsan_read4_pc(void *addr, void *pc); 623cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE void __tsan_read8_pc(void *addr, void *pc); 633cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE void __tsan_read16_pc(void *addr, void *pc); 643cab2bb3Spatrick 653cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE void __tsan_write1_pc(void *addr, void *pc); 663cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE void __tsan_write2_pc(void *addr, void *pc); 673cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE void __tsan_write4_pc(void *addr, void *pc); 683cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE void __tsan_write8_pc(void *addr, void *pc); 693cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE void __tsan_write16_pc(void *addr, void *pc); 703cab2bb3Spatrick 713cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE void __tsan_vptr_read(void **vptr_p); 723cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 733cab2bb3Spatrick void __tsan_vptr_update(void **vptr_p, void *new_val); 743cab2bb3Spatrick 75*810390e3Srobert SANITIZER_INTERFACE_ATTRIBUTE 76*810390e3Srobert void *__tsan_memcpy(void *dest, const void *src, uptr count); 77*810390e3Srobert SANITIZER_INTERFACE_ATTRIBUTE 78*810390e3Srobert void *__tsan_memset(void *dest, int ch, uptr count); 79*810390e3Srobert SANITIZER_INTERFACE_ATTRIBUTE 80*810390e3Srobert void *__tsan_memmove(void *dest, const void *src, uptr count); 81*810390e3Srobert 823cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE void __tsan_func_entry(void *call_pc); 833cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE void __tsan_func_exit(); 843cab2bb3Spatrick 853cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE void __tsan_ignore_thread_begin(); 863cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE void __tsan_ignore_thread_end(); 873cab2bb3Spatrick 883cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 893cab2bb3Spatrick void *__tsan_external_register_tag(const char *object_type); 903cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 913cab2bb3Spatrick void __tsan_external_register_header(void *tag, const char *header); 923cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 933cab2bb3Spatrick void __tsan_external_assign_tag(void *addr, void *tag); 943cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 953cab2bb3Spatrick void __tsan_external_read(void *addr, void *caller_pc, void *tag); 963cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 973cab2bb3Spatrick void __tsan_external_write(void *addr, void *caller_pc, void *tag); 983cab2bb3Spatrick 993cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 1003cab2bb3Spatrick void __tsan_read_range(void *addr, unsigned long size); 1013cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 1023cab2bb3Spatrick void __tsan_write_range(void *addr, unsigned long size); 1033cab2bb3Spatrick 1043cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 105*810390e3Srobert void __tsan_read_range_pc(void *addr, unsigned long size, void *pc); 1063cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 107*810390e3Srobert void __tsan_write_range_pc(void *addr, unsigned long size, void *pc); 1083cab2bb3Spatrick 1093cab2bb3Spatrick // User may provide function that would be called right when TSan detects 1103cab2bb3Spatrick // an error. The argument 'report' is an opaque pointer that can be used to 1113cab2bb3Spatrick // gather additional information using other TSan report API functions. 1123cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 1133cab2bb3Spatrick void __tsan_on_report(void *report); 1143cab2bb3Spatrick 1153cab2bb3Spatrick // If TSan is currently reporting a detected issue on the current thread, 1163cab2bb3Spatrick // returns an opaque pointer to the current report. Otherwise returns NULL. 1173cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 1183cab2bb3Spatrick void *__tsan_get_current_report(); 1193cab2bb3Spatrick 1203cab2bb3Spatrick // Returns a report's description (issue type), number of duplicate issues 1213cab2bb3Spatrick // found, counts of array data (stack traces, memory operations, locations, 1223cab2bb3Spatrick // mutexes, threads, unique thread IDs) and a stack trace of a sleep() call (if 1233cab2bb3Spatrick // one was involved in the issue). 1243cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 1253cab2bb3Spatrick int __tsan_get_report_data(void *report, const char **description, int *count, 1263cab2bb3Spatrick int *stack_count, int *mop_count, int *loc_count, 1273cab2bb3Spatrick int *mutex_count, int *thread_count, 1283cab2bb3Spatrick int *unique_tid_count, void **sleep_trace, 1293cab2bb3Spatrick uptr trace_size); 1303cab2bb3Spatrick 1313cab2bb3Spatrick /// Retrieves the "tag" from a report (for external-race report types). External 1323cab2bb3Spatrick /// races can be associated with a tag which give them more meaning. For example 1333cab2bb3Spatrick /// tag value '1' means "Swift access race". Tag value '0' indicated a plain 1343cab2bb3Spatrick /// external race. 1353cab2bb3Spatrick /// 1363cab2bb3Spatrick /// \param report opaque pointer to the current report (obtained as argument in 1373cab2bb3Spatrick /// __tsan_on_report, or from __tsan_get_current_report) 1383cab2bb3Spatrick /// \param [out] tag points to storage that will be filled with the tag value 1393cab2bb3Spatrick /// 1403cab2bb3Spatrick /// \returns non-zero value on success, zero on failure 1413cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 1423cab2bb3Spatrick int __tsan_get_report_tag(void *report, uptr *tag); 1433cab2bb3Spatrick 1443cab2bb3Spatrick // Returns information about stack traces included in the report. 1453cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 1463cab2bb3Spatrick int __tsan_get_report_stack(void *report, uptr idx, void **trace, 1473cab2bb3Spatrick uptr trace_size); 1483cab2bb3Spatrick 1493cab2bb3Spatrick // Returns information about memory operations included in the report. 1503cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 1513cab2bb3Spatrick int __tsan_get_report_mop(void *report, uptr idx, int *tid, void **addr, 1523cab2bb3Spatrick int *size, int *write, int *atomic, void **trace, 1533cab2bb3Spatrick uptr trace_size); 1543cab2bb3Spatrick 1553cab2bb3Spatrick // Returns information about locations included in the report. 1563cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 1573cab2bb3Spatrick int __tsan_get_report_loc(void *report, uptr idx, const char **type, 1583cab2bb3Spatrick void **addr, uptr *start, uptr *size, int *tid, 1593cab2bb3Spatrick int *fd, int *suppressable, void **trace, 1603cab2bb3Spatrick uptr trace_size); 1613cab2bb3Spatrick 1623cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 1633cab2bb3Spatrick int __tsan_get_report_loc_object_type(void *report, uptr idx, 1643cab2bb3Spatrick const char **object_type); 1653cab2bb3Spatrick 1663cab2bb3Spatrick // Returns information about mutexes included in the report. 1673cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 1683cab2bb3Spatrick int __tsan_get_report_mutex(void *report, uptr idx, uptr *mutex_id, void **addr, 1693cab2bb3Spatrick int *destroyed, void **trace, uptr trace_size); 1703cab2bb3Spatrick 1713cab2bb3Spatrick // Returns information about threads included in the report. 1723cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 1733cab2bb3Spatrick int __tsan_get_report_thread(void *report, uptr idx, int *tid, tid_t *os_id, 1743cab2bb3Spatrick int *running, const char **name, int *parent_tid, 1753cab2bb3Spatrick void **trace, uptr trace_size); 1763cab2bb3Spatrick 1773cab2bb3Spatrick // Returns information about unique thread IDs included in the report. 1783cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 1793cab2bb3Spatrick int __tsan_get_report_unique_tid(void *report, uptr idx, int *tid); 1803cab2bb3Spatrick 1813cab2bb3Spatrick // Returns the type of the pointer (heap, stack, global, ...) and if possible 1823cab2bb3Spatrick // also the starting address (e.g. of a heap allocation) and size. 1833cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 1843cab2bb3Spatrick const char *__tsan_locate_address(uptr addr, char *name, uptr name_size, 1853cab2bb3Spatrick uptr *region_address, uptr *region_size); 1863cab2bb3Spatrick 1873cab2bb3Spatrick // Returns the allocation stack for a heap pointer. 1883cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 1893cab2bb3Spatrick int __tsan_get_alloc_stack(uptr addr, uptr *trace, uptr size, int *thread_id, 1903cab2bb3Spatrick tid_t *os_id); 1913cab2bb3Spatrick 1923cab2bb3Spatrick #endif // SANITIZER_GO 1933cab2bb3Spatrick 1943cab2bb3Spatrick #ifdef __cplusplus 1953cab2bb3Spatrick } // extern "C" 1963cab2bb3Spatrick #endif 1973cab2bb3Spatrick 1983cab2bb3Spatrick namespace __tsan { 1993cab2bb3Spatrick 2003cab2bb3Spatrick // These should match declarations from public tsan_interface_atomic.h header. 2013cab2bb3Spatrick typedef unsigned char a8; 2023cab2bb3Spatrick typedef unsigned short a16; 2033cab2bb3Spatrick typedef unsigned int a32; 2043cab2bb3Spatrick typedef unsigned long long a64; 2053cab2bb3Spatrick #if !SANITIZER_GO && (defined(__SIZEOF_INT128__) \ 206d89ec533Spatrick || (__clang_major__ * 100 + __clang_minor__ >= 302)) && \ 207d89ec533Spatrick !defined(__mips64) && !defined(__s390x__) 2083cab2bb3Spatrick __extension__ typedef __int128 a128; 2093cab2bb3Spatrick # define __TSAN_HAS_INT128 1 2103cab2bb3Spatrick #else 2113cab2bb3Spatrick # define __TSAN_HAS_INT128 0 2123cab2bb3Spatrick #endif 2133cab2bb3Spatrick 2143cab2bb3Spatrick // Part of ABI, do not change. 215d89ec533Spatrick // https://github.com/llvm/llvm-project/blob/main/libcxx/include/atomic 2163cab2bb3Spatrick typedef enum { 2173cab2bb3Spatrick mo_relaxed, 2183cab2bb3Spatrick mo_consume, 2193cab2bb3Spatrick mo_acquire, 2203cab2bb3Spatrick mo_release, 2213cab2bb3Spatrick mo_acq_rel, 2223cab2bb3Spatrick mo_seq_cst 2233cab2bb3Spatrick } morder; 2243cab2bb3Spatrick 2253cab2bb3Spatrick struct ThreadState; 2263cab2bb3Spatrick 2273cab2bb3Spatrick extern "C" { 2283cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 2293cab2bb3Spatrick a8 __tsan_atomic8_load(const volatile a8 *a, morder mo); 2303cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 2313cab2bb3Spatrick a16 __tsan_atomic16_load(const volatile a16 *a, morder mo); 2323cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 2333cab2bb3Spatrick a32 __tsan_atomic32_load(const volatile a32 *a, morder mo); 2343cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 2353cab2bb3Spatrick a64 __tsan_atomic64_load(const volatile a64 *a, morder mo); 2363cab2bb3Spatrick #if __TSAN_HAS_INT128 2373cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 2383cab2bb3Spatrick a128 __tsan_atomic128_load(const volatile a128 *a, morder mo); 2393cab2bb3Spatrick #endif 2403cab2bb3Spatrick 2413cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 2423cab2bb3Spatrick void __tsan_atomic8_store(volatile a8 *a, a8 v, morder mo); 2433cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 2443cab2bb3Spatrick void __tsan_atomic16_store(volatile a16 *a, a16 v, morder mo); 2453cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 2463cab2bb3Spatrick void __tsan_atomic32_store(volatile a32 *a, a32 v, morder mo); 2473cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 2483cab2bb3Spatrick void __tsan_atomic64_store(volatile a64 *a, a64 v, morder mo); 2493cab2bb3Spatrick #if __TSAN_HAS_INT128 2503cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 2513cab2bb3Spatrick void __tsan_atomic128_store(volatile a128 *a, a128 v, morder mo); 2523cab2bb3Spatrick #endif 2533cab2bb3Spatrick 2543cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 2553cab2bb3Spatrick a8 __tsan_atomic8_exchange(volatile a8 *a, a8 v, morder mo); 2563cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 2573cab2bb3Spatrick a16 __tsan_atomic16_exchange(volatile a16 *a, a16 v, morder mo); 2583cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 2593cab2bb3Spatrick a32 __tsan_atomic32_exchange(volatile a32 *a, a32 v, morder mo); 2603cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 2613cab2bb3Spatrick a64 __tsan_atomic64_exchange(volatile a64 *a, a64 v, morder mo); 2623cab2bb3Spatrick #if __TSAN_HAS_INT128 2633cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 2643cab2bb3Spatrick a128 __tsan_atomic128_exchange(volatile a128 *a, a128 v, morder mo); 2653cab2bb3Spatrick #endif 2663cab2bb3Spatrick 2673cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 2683cab2bb3Spatrick a8 __tsan_atomic8_fetch_add(volatile a8 *a, a8 v, morder mo); 2693cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 2703cab2bb3Spatrick a16 __tsan_atomic16_fetch_add(volatile a16 *a, a16 v, morder mo); 2713cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 2723cab2bb3Spatrick a32 __tsan_atomic32_fetch_add(volatile a32 *a, a32 v, morder mo); 2733cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 2743cab2bb3Spatrick a64 __tsan_atomic64_fetch_add(volatile a64 *a, a64 v, morder mo); 2753cab2bb3Spatrick #if __TSAN_HAS_INT128 2763cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 2773cab2bb3Spatrick a128 __tsan_atomic128_fetch_add(volatile a128 *a, a128 v, morder mo); 2783cab2bb3Spatrick #endif 2793cab2bb3Spatrick 2803cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 2813cab2bb3Spatrick a8 __tsan_atomic8_fetch_sub(volatile a8 *a, a8 v, morder mo); 2823cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 2833cab2bb3Spatrick a16 __tsan_atomic16_fetch_sub(volatile a16 *a, a16 v, morder mo); 2843cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 2853cab2bb3Spatrick a32 __tsan_atomic32_fetch_sub(volatile a32 *a, a32 v, morder mo); 2863cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 2873cab2bb3Spatrick a64 __tsan_atomic64_fetch_sub(volatile a64 *a, a64 v, morder mo); 2883cab2bb3Spatrick #if __TSAN_HAS_INT128 2893cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 2903cab2bb3Spatrick a128 __tsan_atomic128_fetch_sub(volatile a128 *a, a128 v, morder mo); 2913cab2bb3Spatrick #endif 2923cab2bb3Spatrick 2933cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 2943cab2bb3Spatrick a8 __tsan_atomic8_fetch_and(volatile a8 *a, a8 v, morder mo); 2953cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 2963cab2bb3Spatrick a16 __tsan_atomic16_fetch_and(volatile a16 *a, a16 v, morder mo); 2973cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 2983cab2bb3Spatrick a32 __tsan_atomic32_fetch_and(volatile a32 *a, a32 v, morder mo); 2993cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 3003cab2bb3Spatrick a64 __tsan_atomic64_fetch_and(volatile a64 *a, a64 v, morder mo); 3013cab2bb3Spatrick #if __TSAN_HAS_INT128 3023cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 3033cab2bb3Spatrick a128 __tsan_atomic128_fetch_and(volatile a128 *a, a128 v, morder mo); 3043cab2bb3Spatrick #endif 3053cab2bb3Spatrick 3063cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 3073cab2bb3Spatrick a8 __tsan_atomic8_fetch_or(volatile a8 *a, a8 v, morder mo); 3083cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 3093cab2bb3Spatrick a16 __tsan_atomic16_fetch_or(volatile a16 *a, a16 v, morder mo); 3103cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 3113cab2bb3Spatrick a32 __tsan_atomic32_fetch_or(volatile a32 *a, a32 v, morder mo); 3123cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 3133cab2bb3Spatrick a64 __tsan_atomic64_fetch_or(volatile a64 *a, a64 v, morder mo); 3143cab2bb3Spatrick #if __TSAN_HAS_INT128 3153cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 3163cab2bb3Spatrick a128 __tsan_atomic128_fetch_or(volatile a128 *a, a128 v, morder mo); 3173cab2bb3Spatrick #endif 3183cab2bb3Spatrick 3193cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 3203cab2bb3Spatrick a8 __tsan_atomic8_fetch_xor(volatile a8 *a, a8 v, morder mo); 3213cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 3223cab2bb3Spatrick a16 __tsan_atomic16_fetch_xor(volatile a16 *a, a16 v, morder mo); 3233cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 3243cab2bb3Spatrick a32 __tsan_atomic32_fetch_xor(volatile a32 *a, a32 v, morder mo); 3253cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 3263cab2bb3Spatrick a64 __tsan_atomic64_fetch_xor(volatile a64 *a, a64 v, morder mo); 3273cab2bb3Spatrick #if __TSAN_HAS_INT128 3283cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 3293cab2bb3Spatrick a128 __tsan_atomic128_fetch_xor(volatile a128 *a, a128 v, morder mo); 3303cab2bb3Spatrick #endif 3313cab2bb3Spatrick 3323cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 3333cab2bb3Spatrick a8 __tsan_atomic8_fetch_nand(volatile a8 *a, a8 v, morder mo); 3343cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 3353cab2bb3Spatrick a16 __tsan_atomic16_fetch_nand(volatile a16 *a, a16 v, morder mo); 3363cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 3373cab2bb3Spatrick a32 __tsan_atomic32_fetch_nand(volatile a32 *a, a32 v, morder mo); 3383cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 3393cab2bb3Spatrick a64 __tsan_atomic64_fetch_nand(volatile a64 *a, a64 v, morder mo); 3403cab2bb3Spatrick #if __TSAN_HAS_INT128 3413cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 3423cab2bb3Spatrick a128 __tsan_atomic128_fetch_nand(volatile a128 *a, a128 v, morder mo); 3433cab2bb3Spatrick #endif 3443cab2bb3Spatrick 3453cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 3463cab2bb3Spatrick int __tsan_atomic8_compare_exchange_strong(volatile a8 *a, a8 *c, a8 v, 3473cab2bb3Spatrick morder mo, morder fmo); 3483cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 3493cab2bb3Spatrick int __tsan_atomic16_compare_exchange_strong(volatile a16 *a, a16 *c, a16 v, 3503cab2bb3Spatrick morder mo, morder fmo); 3513cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 3523cab2bb3Spatrick int __tsan_atomic32_compare_exchange_strong(volatile a32 *a, a32 *c, a32 v, 3533cab2bb3Spatrick morder mo, morder fmo); 3543cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 3553cab2bb3Spatrick int __tsan_atomic64_compare_exchange_strong(volatile a64 *a, a64 *c, a64 v, 3563cab2bb3Spatrick morder mo, morder fmo); 3573cab2bb3Spatrick #if __TSAN_HAS_INT128 3583cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 3593cab2bb3Spatrick int __tsan_atomic128_compare_exchange_strong(volatile a128 *a, a128 *c, a128 v, 3603cab2bb3Spatrick morder mo, morder fmo); 3613cab2bb3Spatrick #endif 3623cab2bb3Spatrick 3633cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 3643cab2bb3Spatrick int __tsan_atomic8_compare_exchange_weak(volatile a8 *a, a8 *c, a8 v, morder mo, 3653cab2bb3Spatrick morder fmo); 3663cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 3673cab2bb3Spatrick int __tsan_atomic16_compare_exchange_weak(volatile a16 *a, a16 *c, a16 v, 3683cab2bb3Spatrick morder mo, morder fmo); 3693cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 3703cab2bb3Spatrick int __tsan_atomic32_compare_exchange_weak(volatile a32 *a, a32 *c, a32 v, 3713cab2bb3Spatrick morder mo, morder fmo); 3723cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 3733cab2bb3Spatrick int __tsan_atomic64_compare_exchange_weak(volatile a64 *a, a64 *c, a64 v, 3743cab2bb3Spatrick morder mo, morder fmo); 3753cab2bb3Spatrick #if __TSAN_HAS_INT128 3763cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 3773cab2bb3Spatrick int __tsan_atomic128_compare_exchange_weak(volatile a128 *a, a128 *c, a128 v, 3783cab2bb3Spatrick morder mo, morder fmo); 3793cab2bb3Spatrick #endif 3803cab2bb3Spatrick 3813cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 3823cab2bb3Spatrick a8 __tsan_atomic8_compare_exchange_val(volatile a8 *a, a8 c, a8 v, morder mo, 3833cab2bb3Spatrick morder fmo); 3843cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 3853cab2bb3Spatrick a16 __tsan_atomic16_compare_exchange_val(volatile a16 *a, a16 c, a16 v, 3863cab2bb3Spatrick morder mo, morder fmo); 3873cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 3883cab2bb3Spatrick a32 __tsan_atomic32_compare_exchange_val(volatile a32 *a, a32 c, a32 v, 3893cab2bb3Spatrick morder mo, morder fmo); 3903cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 3913cab2bb3Spatrick a64 __tsan_atomic64_compare_exchange_val(volatile a64 *a, a64 c, a64 v, 3923cab2bb3Spatrick morder mo, morder fmo); 3933cab2bb3Spatrick #if __TSAN_HAS_INT128 3943cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 3953cab2bb3Spatrick a128 __tsan_atomic128_compare_exchange_val(volatile a128 *a, a128 c, a128 v, 3963cab2bb3Spatrick morder mo, morder fmo); 3973cab2bb3Spatrick #endif 3983cab2bb3Spatrick 3993cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 4003cab2bb3Spatrick void __tsan_atomic_thread_fence(morder mo); 4013cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 4023cab2bb3Spatrick void __tsan_atomic_signal_fence(morder mo); 4033cab2bb3Spatrick 4043cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 4053cab2bb3Spatrick void __tsan_go_atomic32_load(ThreadState *thr, uptr cpc, uptr pc, u8 *a); 4063cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 4073cab2bb3Spatrick void __tsan_go_atomic64_load(ThreadState *thr, uptr cpc, uptr pc, u8 *a); 4083cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 4093cab2bb3Spatrick void __tsan_go_atomic32_store(ThreadState *thr, uptr cpc, uptr pc, u8 *a); 4103cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 4113cab2bb3Spatrick void __tsan_go_atomic64_store(ThreadState *thr, uptr cpc, uptr pc, u8 *a); 4123cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 4133cab2bb3Spatrick void __tsan_go_atomic32_fetch_add(ThreadState *thr, uptr cpc, uptr pc, u8 *a); 4143cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 4153cab2bb3Spatrick void __tsan_go_atomic64_fetch_add(ThreadState *thr, uptr cpc, uptr pc, u8 *a); 4163cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 4173cab2bb3Spatrick void __tsan_go_atomic32_exchange(ThreadState *thr, uptr cpc, uptr pc, u8 *a); 4183cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 4193cab2bb3Spatrick void __tsan_go_atomic64_exchange(ThreadState *thr, uptr cpc, uptr pc, u8 *a); 4203cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 4213cab2bb3Spatrick void __tsan_go_atomic32_compare_exchange(ThreadState *thr, uptr cpc, uptr pc, 4223cab2bb3Spatrick u8 *a); 4233cab2bb3Spatrick SANITIZER_INTERFACE_ATTRIBUTE 4243cab2bb3Spatrick void __tsan_go_atomic64_compare_exchange(ThreadState *thr, uptr cpc, uptr pc, 4253cab2bb3Spatrick u8 *a); 426d89ec533Spatrick 4273cab2bb3Spatrick } // extern "C" 4283cab2bb3Spatrick 4293cab2bb3Spatrick } // namespace __tsan 4303cab2bb3Spatrick 4313cab2bb3Spatrick #endif // TSAN_INTERFACE_H 432