10b57cec5SDimitry Andric //===-- tsan_interface.h ----------------------------------------*- C++ -*-===// 20b57cec5SDimitry Andric // 30b57cec5SDimitry Andric // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 40b57cec5SDimitry Andric // See https://llvm.org/LICENSE.txt for license information. 50b57cec5SDimitry Andric // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 60b57cec5SDimitry Andric // 70b57cec5SDimitry Andric //===----------------------------------------------------------------------===// 80b57cec5SDimitry Andric // 90b57cec5SDimitry Andric // This file is a part of ThreadSanitizer (TSan), a race detector. 100b57cec5SDimitry Andric // 110b57cec5SDimitry Andric // The functions declared in this header will be inserted by the instrumentation 120b57cec5SDimitry Andric // module. 130b57cec5SDimitry Andric // This header can be included by the instrumented program or by TSan tests. 140b57cec5SDimitry Andric //===----------------------------------------------------------------------===// 150b57cec5SDimitry Andric #ifndef TSAN_INTERFACE_H 160b57cec5SDimitry Andric #define TSAN_INTERFACE_H 170b57cec5SDimitry Andric 180b57cec5SDimitry Andric #include <sanitizer_common/sanitizer_internal_defs.h> 190b57cec5SDimitry Andric using __sanitizer::uptr; 200b57cec5SDimitry Andric using __sanitizer::tid_t; 210b57cec5SDimitry Andric 220b57cec5SDimitry Andric // This header should NOT include any other headers. 230b57cec5SDimitry Andric // All functions in this header are extern "C" and start with __tsan_. 240b57cec5SDimitry Andric 250b57cec5SDimitry Andric #ifdef __cplusplus 260b57cec5SDimitry Andric extern "C" { 270b57cec5SDimitry Andric #endif 280b57cec5SDimitry Andric 290b57cec5SDimitry Andric #if !SANITIZER_GO 300b57cec5SDimitry Andric 310b57cec5SDimitry Andric // This function should be called at the very beginning of the process, 320b57cec5SDimitry Andric // before any instrumented code is executed and before any call to malloc. 330b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE void __tsan_init(); 340b57cec5SDimitry Andric 3506c3fb27SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE const char * 3606c3fb27SDimitry Andric __tsan_default_options(); 3706c3fb27SDimitry Andric 380b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE void __tsan_flush_memory(); 390b57cec5SDimitry Andric 400b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE void __tsan_read1(void *addr); 410b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE void __tsan_read2(void *addr); 420b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE void __tsan_read4(void *addr); 430b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE void __tsan_read8(void *addr); 440b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE void __tsan_read16(void *addr); 450b57cec5SDimitry Andric 460b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE void __tsan_write1(void *addr); 470b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE void __tsan_write2(void *addr); 480b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE void __tsan_write4(void *addr); 490b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE void __tsan_write8(void *addr); 500b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE void __tsan_write16(void *addr); 510b57cec5SDimitry Andric 520b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE void __tsan_unaligned_read2(const void *addr); 530b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE void __tsan_unaligned_read4(const void *addr); 540b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE void __tsan_unaligned_read8(const void *addr); 550b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE void __tsan_unaligned_read16(const void *addr); 560b57cec5SDimitry Andric 570b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE void __tsan_unaligned_write2(void *addr); 580b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE void __tsan_unaligned_write4(void *addr); 590b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE void __tsan_unaligned_write8(void *addr); 600b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE void __tsan_unaligned_write16(void *addr); 610b57cec5SDimitry Andric 620b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE void __tsan_read1_pc(void *addr, void *pc); 630b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE void __tsan_read2_pc(void *addr, void *pc); 640b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE void __tsan_read4_pc(void *addr, void *pc); 650b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE void __tsan_read8_pc(void *addr, void *pc); 660b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE void __tsan_read16_pc(void *addr, void *pc); 670b57cec5SDimitry Andric 680b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE void __tsan_write1_pc(void *addr, void *pc); 690b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE void __tsan_write2_pc(void *addr, void *pc); 700b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE void __tsan_write4_pc(void *addr, void *pc); 710b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE void __tsan_write8_pc(void *addr, void *pc); 720b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE void __tsan_write16_pc(void *addr, void *pc); 730b57cec5SDimitry Andric 740b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE void __tsan_vptr_read(void **vptr_p); 750b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 760b57cec5SDimitry Andric void __tsan_vptr_update(void **vptr_p, void *new_val); 770b57cec5SDimitry Andric 78bdd1243dSDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 79bdd1243dSDimitry Andric void *__tsan_memcpy(void *dest, const void *src, uptr count); 80bdd1243dSDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 81bdd1243dSDimitry Andric void *__tsan_memset(void *dest, int ch, uptr count); 82bdd1243dSDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 83bdd1243dSDimitry Andric void *__tsan_memmove(void *dest, const void *src, uptr count); 84bdd1243dSDimitry Andric 850b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE void __tsan_func_entry(void *call_pc); 860b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE void __tsan_func_exit(); 870b57cec5SDimitry Andric 880b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE void __tsan_ignore_thread_begin(); 890b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE void __tsan_ignore_thread_end(); 900b57cec5SDimitry Andric 9106c3fb27SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE void __tsan_on_thread_idle(); 9206c3fb27SDimitry Andric 930b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 940b57cec5SDimitry Andric void *__tsan_external_register_tag(const char *object_type); 950b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 960b57cec5SDimitry Andric void __tsan_external_register_header(void *tag, const char *header); 970b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 980b57cec5SDimitry Andric void __tsan_external_assign_tag(void *addr, void *tag); 990b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 1000b57cec5SDimitry Andric void __tsan_external_read(void *addr, void *caller_pc, void *tag); 1010b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 1020b57cec5SDimitry Andric void __tsan_external_write(void *addr, void *caller_pc, void *tag); 1030b57cec5SDimitry Andric 1040b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 10568d75effSDimitry Andric void __tsan_read_range(void *addr, unsigned long size); 1060b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 10768d75effSDimitry Andric void __tsan_write_range(void *addr, unsigned long size); 10868d75effSDimitry Andric 10968d75effSDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 110349cc55cSDimitry Andric void __tsan_read_range_pc(void *addr, unsigned long size, void *pc); 11168d75effSDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 112349cc55cSDimitry Andric void __tsan_write_range_pc(void *addr, unsigned long size, void *pc); 1130b57cec5SDimitry Andric 1140b57cec5SDimitry Andric // User may provide function that would be called right when TSan detects 1150b57cec5SDimitry Andric // an error. The argument 'report' is an opaque pointer that can be used to 1160b57cec5SDimitry Andric // gather additional information using other TSan report API functions. 1170b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 1180b57cec5SDimitry Andric void __tsan_on_report(void *report); 1190b57cec5SDimitry Andric 1200b57cec5SDimitry Andric // If TSan is currently reporting a detected issue on the current thread, 1210b57cec5SDimitry Andric // returns an opaque pointer to the current report. Otherwise returns NULL. 1220b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 1230b57cec5SDimitry Andric void *__tsan_get_current_report(); 1240b57cec5SDimitry Andric 1250b57cec5SDimitry Andric // Returns a report's description (issue type), number of duplicate issues 1260b57cec5SDimitry Andric // found, counts of array data (stack traces, memory operations, locations, 1270b57cec5SDimitry Andric // mutexes, threads, unique thread IDs) and a stack trace of a sleep() call (if 1280b57cec5SDimitry Andric // one was involved in the issue). 1290b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 1300b57cec5SDimitry Andric int __tsan_get_report_data(void *report, const char **description, int *count, 1310b57cec5SDimitry Andric int *stack_count, int *mop_count, int *loc_count, 1320b57cec5SDimitry Andric int *mutex_count, int *thread_count, 1330b57cec5SDimitry Andric int *unique_tid_count, void **sleep_trace, 1340b57cec5SDimitry Andric uptr trace_size); 1350b57cec5SDimitry Andric 1360b57cec5SDimitry Andric /// Retrieves the "tag" from a report (for external-race report types). External 1370b57cec5SDimitry Andric /// races can be associated with a tag which give them more meaning. For example 1380b57cec5SDimitry Andric /// tag value '1' means "Swift access race". Tag value '0' indicated a plain 1390b57cec5SDimitry Andric /// external race. 1400b57cec5SDimitry Andric /// 1410b57cec5SDimitry Andric /// \param report opaque pointer to the current report (obtained as argument in 1420b57cec5SDimitry Andric /// __tsan_on_report, or from __tsan_get_current_report) 1430b57cec5SDimitry Andric /// \param [out] tag points to storage that will be filled with the tag value 1440b57cec5SDimitry Andric /// 1450b57cec5SDimitry Andric /// \returns non-zero value on success, zero on failure 1460b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 1470b57cec5SDimitry Andric int __tsan_get_report_tag(void *report, uptr *tag); 1480b57cec5SDimitry Andric 1490b57cec5SDimitry Andric // Returns information about stack traces included in the report. 1500b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 1510b57cec5SDimitry Andric int __tsan_get_report_stack(void *report, uptr idx, void **trace, 1520b57cec5SDimitry Andric uptr trace_size); 1530b57cec5SDimitry Andric 1540b57cec5SDimitry Andric // Returns information about memory operations included in the report. 1550b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 1560b57cec5SDimitry Andric int __tsan_get_report_mop(void *report, uptr idx, int *tid, void **addr, 1570b57cec5SDimitry Andric int *size, int *write, int *atomic, void **trace, 1580b57cec5SDimitry Andric uptr trace_size); 1590b57cec5SDimitry Andric 1600b57cec5SDimitry Andric // Returns information about locations included in the report. 1610b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 1620b57cec5SDimitry Andric int __tsan_get_report_loc(void *report, uptr idx, const char **type, 1630b57cec5SDimitry Andric void **addr, uptr *start, uptr *size, int *tid, 1640b57cec5SDimitry Andric int *fd, int *suppressable, void **trace, 1650b57cec5SDimitry Andric uptr trace_size); 1660b57cec5SDimitry Andric 1670b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 1680b57cec5SDimitry Andric int __tsan_get_report_loc_object_type(void *report, uptr idx, 1690b57cec5SDimitry Andric const char **object_type); 1700b57cec5SDimitry Andric 1710b57cec5SDimitry Andric // Returns information about mutexes included in the report. 1720b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 1730b57cec5SDimitry Andric int __tsan_get_report_mutex(void *report, uptr idx, uptr *mutex_id, void **addr, 1740b57cec5SDimitry Andric int *destroyed, void **trace, uptr trace_size); 1750b57cec5SDimitry Andric 1760b57cec5SDimitry Andric // Returns information about threads included in the report. 1770b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 1780b57cec5SDimitry Andric int __tsan_get_report_thread(void *report, uptr idx, int *tid, tid_t *os_id, 1790b57cec5SDimitry Andric int *running, const char **name, int *parent_tid, 1800b57cec5SDimitry Andric void **trace, uptr trace_size); 1810b57cec5SDimitry Andric 1820b57cec5SDimitry Andric // Returns information about unique thread IDs included in the report. 1830b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 1840b57cec5SDimitry Andric int __tsan_get_report_unique_tid(void *report, uptr idx, int *tid); 1850b57cec5SDimitry Andric 1860b57cec5SDimitry Andric // Returns the type of the pointer (heap, stack, global, ...) and if possible 1870b57cec5SDimitry Andric // also the starting address (e.g. of a heap allocation) and size. 1880b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 1890b57cec5SDimitry Andric const char *__tsan_locate_address(uptr addr, char *name, uptr name_size, 1900b57cec5SDimitry Andric uptr *region_address, uptr *region_size); 1910b57cec5SDimitry Andric 1920b57cec5SDimitry Andric // Returns the allocation stack for a heap pointer. 1930b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 1940b57cec5SDimitry Andric int __tsan_get_alloc_stack(uptr addr, uptr *trace, uptr size, int *thread_id, 1950b57cec5SDimitry Andric tid_t *os_id); 1960b57cec5SDimitry Andric 1970b57cec5SDimitry Andric #endif // SANITIZER_GO 1980b57cec5SDimitry Andric 1990b57cec5SDimitry Andric #ifdef __cplusplus 2000b57cec5SDimitry Andric } // extern "C" 2010b57cec5SDimitry Andric #endif 2020b57cec5SDimitry Andric 2030b57cec5SDimitry Andric namespace __tsan { 2040b57cec5SDimitry Andric 2050b57cec5SDimitry Andric // These should match declarations from public tsan_interface_atomic.h header. 2060b57cec5SDimitry Andric typedef unsigned char a8; 20768d75effSDimitry Andric typedef unsigned short a16; 2080b57cec5SDimitry Andric typedef unsigned int a32; 20968d75effSDimitry Andric typedef unsigned long long a64; 2100b57cec5SDimitry Andric #if !SANITIZER_GO && (defined(__SIZEOF_INT128__) \ 211fe6060f1SDimitry Andric || (__clang_major__ * 100 + __clang_minor__ >= 302)) && \ 212fe6060f1SDimitry Andric !defined(__mips64) && !defined(__s390x__) 2130b57cec5SDimitry Andric __extension__ typedef __int128 a128; 2140b57cec5SDimitry Andric # define __TSAN_HAS_INT128 1 2150b57cec5SDimitry Andric #else 2160b57cec5SDimitry Andric # define __TSAN_HAS_INT128 0 2170b57cec5SDimitry Andric #endif 2180b57cec5SDimitry Andric 2190b57cec5SDimitry Andric // Part of ABI, do not change. 220fe6060f1SDimitry Andric // https://github.com/llvm/llvm-project/blob/main/libcxx/include/atomic 2210b57cec5SDimitry Andric typedef enum { 2220b57cec5SDimitry Andric mo_relaxed, 2230b57cec5SDimitry Andric mo_consume, 2240b57cec5SDimitry Andric mo_acquire, 2250b57cec5SDimitry Andric mo_release, 2260b57cec5SDimitry Andric mo_acq_rel, 2270b57cec5SDimitry Andric mo_seq_cst 2280b57cec5SDimitry Andric } morder; 2290b57cec5SDimitry Andric 2300b57cec5SDimitry Andric struct ThreadState; 2310b57cec5SDimitry Andric 2320b57cec5SDimitry Andric extern "C" { 2330b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 2340b57cec5SDimitry Andric a8 __tsan_atomic8_load(const volatile a8 *a, morder mo); 2350b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 2360b57cec5SDimitry Andric a16 __tsan_atomic16_load(const volatile a16 *a, morder mo); 2370b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 2380b57cec5SDimitry Andric a32 __tsan_atomic32_load(const volatile a32 *a, morder mo); 2390b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 2400b57cec5SDimitry Andric a64 __tsan_atomic64_load(const volatile a64 *a, morder mo); 2410b57cec5SDimitry Andric #if __TSAN_HAS_INT128 2420b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 2430b57cec5SDimitry Andric a128 __tsan_atomic128_load(const volatile a128 *a, morder mo); 2440b57cec5SDimitry Andric #endif 2450b57cec5SDimitry Andric 2460b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 2470b57cec5SDimitry Andric void __tsan_atomic8_store(volatile a8 *a, a8 v, morder mo); 2480b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 2490b57cec5SDimitry Andric void __tsan_atomic16_store(volatile a16 *a, a16 v, morder mo); 2500b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 2510b57cec5SDimitry Andric void __tsan_atomic32_store(volatile a32 *a, a32 v, morder mo); 2520b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 2530b57cec5SDimitry Andric void __tsan_atomic64_store(volatile a64 *a, a64 v, morder mo); 2540b57cec5SDimitry Andric #if __TSAN_HAS_INT128 2550b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 2560b57cec5SDimitry Andric void __tsan_atomic128_store(volatile a128 *a, a128 v, morder mo); 2570b57cec5SDimitry Andric #endif 2580b57cec5SDimitry Andric 2590b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 2600b57cec5SDimitry Andric a8 __tsan_atomic8_exchange(volatile a8 *a, a8 v, morder mo); 2610b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 2620b57cec5SDimitry Andric a16 __tsan_atomic16_exchange(volatile a16 *a, a16 v, morder mo); 2630b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 2640b57cec5SDimitry Andric a32 __tsan_atomic32_exchange(volatile a32 *a, a32 v, morder mo); 2650b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 2660b57cec5SDimitry Andric a64 __tsan_atomic64_exchange(volatile a64 *a, a64 v, morder mo); 2670b57cec5SDimitry Andric #if __TSAN_HAS_INT128 2680b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 2690b57cec5SDimitry Andric a128 __tsan_atomic128_exchange(volatile a128 *a, a128 v, morder mo); 2700b57cec5SDimitry Andric #endif 2710b57cec5SDimitry Andric 2720b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 2730b57cec5SDimitry Andric a8 __tsan_atomic8_fetch_add(volatile a8 *a, a8 v, morder mo); 2740b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 2750b57cec5SDimitry Andric a16 __tsan_atomic16_fetch_add(volatile a16 *a, a16 v, morder mo); 2760b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 2770b57cec5SDimitry Andric a32 __tsan_atomic32_fetch_add(volatile a32 *a, a32 v, morder mo); 2780b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 2790b57cec5SDimitry Andric a64 __tsan_atomic64_fetch_add(volatile a64 *a, a64 v, morder mo); 2800b57cec5SDimitry Andric #if __TSAN_HAS_INT128 2810b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 2820b57cec5SDimitry Andric a128 __tsan_atomic128_fetch_add(volatile a128 *a, a128 v, morder mo); 2830b57cec5SDimitry Andric #endif 2840b57cec5SDimitry Andric 2850b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 2860b57cec5SDimitry Andric a8 __tsan_atomic8_fetch_sub(volatile a8 *a, a8 v, morder mo); 2870b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 2880b57cec5SDimitry Andric a16 __tsan_atomic16_fetch_sub(volatile a16 *a, a16 v, morder mo); 2890b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 2900b57cec5SDimitry Andric a32 __tsan_atomic32_fetch_sub(volatile a32 *a, a32 v, morder mo); 2910b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 2920b57cec5SDimitry Andric a64 __tsan_atomic64_fetch_sub(volatile a64 *a, a64 v, morder mo); 2930b57cec5SDimitry Andric #if __TSAN_HAS_INT128 2940b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 2950b57cec5SDimitry Andric a128 __tsan_atomic128_fetch_sub(volatile a128 *a, a128 v, morder mo); 2960b57cec5SDimitry Andric #endif 2970b57cec5SDimitry Andric 2980b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 2990b57cec5SDimitry Andric a8 __tsan_atomic8_fetch_and(volatile a8 *a, a8 v, morder mo); 3000b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 3010b57cec5SDimitry Andric a16 __tsan_atomic16_fetch_and(volatile a16 *a, a16 v, morder mo); 3020b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 3030b57cec5SDimitry Andric a32 __tsan_atomic32_fetch_and(volatile a32 *a, a32 v, morder mo); 3040b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 3050b57cec5SDimitry Andric a64 __tsan_atomic64_fetch_and(volatile a64 *a, a64 v, morder mo); 3060b57cec5SDimitry Andric #if __TSAN_HAS_INT128 3070b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 3080b57cec5SDimitry Andric a128 __tsan_atomic128_fetch_and(volatile a128 *a, a128 v, morder mo); 3090b57cec5SDimitry Andric #endif 3100b57cec5SDimitry Andric 3110b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 3120b57cec5SDimitry Andric a8 __tsan_atomic8_fetch_or(volatile a8 *a, a8 v, morder mo); 3130b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 3140b57cec5SDimitry Andric a16 __tsan_atomic16_fetch_or(volatile a16 *a, a16 v, morder mo); 3150b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 3160b57cec5SDimitry Andric a32 __tsan_atomic32_fetch_or(volatile a32 *a, a32 v, morder mo); 3170b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 3180b57cec5SDimitry Andric a64 __tsan_atomic64_fetch_or(volatile a64 *a, a64 v, morder mo); 3190b57cec5SDimitry Andric #if __TSAN_HAS_INT128 3200b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 3210b57cec5SDimitry Andric a128 __tsan_atomic128_fetch_or(volatile a128 *a, a128 v, morder mo); 3220b57cec5SDimitry Andric #endif 3230b57cec5SDimitry Andric 3240b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 3250b57cec5SDimitry Andric a8 __tsan_atomic8_fetch_xor(volatile a8 *a, a8 v, morder mo); 3260b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 3270b57cec5SDimitry Andric a16 __tsan_atomic16_fetch_xor(volatile a16 *a, a16 v, morder mo); 3280b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 3290b57cec5SDimitry Andric a32 __tsan_atomic32_fetch_xor(volatile a32 *a, a32 v, morder mo); 3300b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 3310b57cec5SDimitry Andric a64 __tsan_atomic64_fetch_xor(volatile a64 *a, a64 v, morder mo); 3320b57cec5SDimitry Andric #if __TSAN_HAS_INT128 3330b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 3340b57cec5SDimitry Andric a128 __tsan_atomic128_fetch_xor(volatile a128 *a, a128 v, morder mo); 3350b57cec5SDimitry Andric #endif 3360b57cec5SDimitry Andric 3370b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 3380b57cec5SDimitry Andric a8 __tsan_atomic8_fetch_nand(volatile a8 *a, a8 v, morder mo); 3390b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 3400b57cec5SDimitry Andric a16 __tsan_atomic16_fetch_nand(volatile a16 *a, a16 v, morder mo); 3410b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 3420b57cec5SDimitry Andric a32 __tsan_atomic32_fetch_nand(volatile a32 *a, a32 v, morder mo); 3430b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 3440b57cec5SDimitry Andric a64 __tsan_atomic64_fetch_nand(volatile a64 *a, a64 v, morder mo); 3450b57cec5SDimitry Andric #if __TSAN_HAS_INT128 3460b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 3470b57cec5SDimitry Andric a128 __tsan_atomic128_fetch_nand(volatile a128 *a, a128 v, morder mo); 3480b57cec5SDimitry Andric #endif 3490b57cec5SDimitry Andric 3500b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 3510b57cec5SDimitry Andric int __tsan_atomic8_compare_exchange_strong(volatile a8 *a, a8 *c, a8 v, 3520b57cec5SDimitry Andric morder mo, morder fmo); 3530b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 3540b57cec5SDimitry Andric int __tsan_atomic16_compare_exchange_strong(volatile a16 *a, a16 *c, a16 v, 3550b57cec5SDimitry Andric morder mo, morder fmo); 3560b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 3570b57cec5SDimitry Andric int __tsan_atomic32_compare_exchange_strong(volatile a32 *a, a32 *c, a32 v, 3580b57cec5SDimitry Andric morder mo, morder fmo); 3590b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 3600b57cec5SDimitry Andric int __tsan_atomic64_compare_exchange_strong(volatile a64 *a, a64 *c, a64 v, 3610b57cec5SDimitry Andric morder mo, morder fmo); 3620b57cec5SDimitry Andric #if __TSAN_HAS_INT128 3630b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 3640b57cec5SDimitry Andric int __tsan_atomic128_compare_exchange_strong(volatile a128 *a, a128 *c, a128 v, 3650b57cec5SDimitry Andric morder mo, morder fmo); 3660b57cec5SDimitry Andric #endif 3670b57cec5SDimitry Andric 3680b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 3690b57cec5SDimitry Andric int __tsan_atomic8_compare_exchange_weak(volatile a8 *a, a8 *c, a8 v, morder mo, 3700b57cec5SDimitry Andric morder fmo); 3710b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 3720b57cec5SDimitry Andric int __tsan_atomic16_compare_exchange_weak(volatile a16 *a, a16 *c, a16 v, 3730b57cec5SDimitry Andric morder mo, morder fmo); 3740b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 3750b57cec5SDimitry Andric int __tsan_atomic32_compare_exchange_weak(volatile a32 *a, a32 *c, a32 v, 3760b57cec5SDimitry Andric morder mo, morder fmo); 3770b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 3780b57cec5SDimitry Andric int __tsan_atomic64_compare_exchange_weak(volatile a64 *a, a64 *c, a64 v, 3790b57cec5SDimitry Andric morder mo, morder fmo); 3800b57cec5SDimitry Andric #if __TSAN_HAS_INT128 3810b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 3820b57cec5SDimitry Andric int __tsan_atomic128_compare_exchange_weak(volatile a128 *a, a128 *c, a128 v, 3830b57cec5SDimitry Andric morder mo, morder fmo); 3840b57cec5SDimitry Andric #endif 3850b57cec5SDimitry Andric 3860b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 3870b57cec5SDimitry Andric a8 __tsan_atomic8_compare_exchange_val(volatile a8 *a, a8 c, a8 v, morder mo, 3880b57cec5SDimitry Andric morder fmo); 3890b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 3900b57cec5SDimitry Andric a16 __tsan_atomic16_compare_exchange_val(volatile a16 *a, a16 c, a16 v, 3910b57cec5SDimitry Andric morder mo, morder fmo); 3920b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 3930b57cec5SDimitry Andric a32 __tsan_atomic32_compare_exchange_val(volatile a32 *a, a32 c, a32 v, 3940b57cec5SDimitry Andric morder mo, morder fmo); 3950b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 3960b57cec5SDimitry Andric a64 __tsan_atomic64_compare_exchange_val(volatile a64 *a, a64 c, a64 v, 3970b57cec5SDimitry Andric morder mo, morder fmo); 3980b57cec5SDimitry Andric #if __TSAN_HAS_INT128 3990b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 4000b57cec5SDimitry Andric a128 __tsan_atomic128_compare_exchange_val(volatile a128 *a, a128 c, a128 v, 4010b57cec5SDimitry Andric morder mo, morder fmo); 4020b57cec5SDimitry Andric #endif 4030b57cec5SDimitry Andric 4040b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 4050b57cec5SDimitry Andric void __tsan_atomic_thread_fence(morder mo); 4060b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 4070b57cec5SDimitry Andric void __tsan_atomic_signal_fence(morder mo); 4080b57cec5SDimitry Andric 4090b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 4100b57cec5SDimitry Andric void __tsan_go_atomic32_load(ThreadState *thr, uptr cpc, uptr pc, u8 *a); 4110b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 4120b57cec5SDimitry Andric void __tsan_go_atomic64_load(ThreadState *thr, uptr cpc, uptr pc, u8 *a); 4130b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 4140b57cec5SDimitry Andric void __tsan_go_atomic32_store(ThreadState *thr, uptr cpc, uptr pc, u8 *a); 4150b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 4160b57cec5SDimitry Andric void __tsan_go_atomic64_store(ThreadState *thr, uptr cpc, uptr pc, u8 *a); 4170b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 4180b57cec5SDimitry Andric void __tsan_go_atomic32_fetch_add(ThreadState *thr, uptr cpc, uptr pc, u8 *a); 4190b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 4200b57cec5SDimitry Andric void __tsan_go_atomic64_fetch_add(ThreadState *thr, uptr cpc, uptr pc, u8 *a); 4210b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 422*5f757f3fSDimitry Andric void __tsan_go_atomic32_fetch_and(ThreadState *thr, uptr cpc, uptr pc, u8 *a); 423*5f757f3fSDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 424*5f757f3fSDimitry Andric void __tsan_go_atomic64_fetch_and(ThreadState *thr, uptr cpc, uptr pc, u8 *a); 425*5f757f3fSDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 426*5f757f3fSDimitry Andric void __tsan_go_atomic32_fetch_or(ThreadState *thr, uptr cpc, uptr pc, u8 *a); 427*5f757f3fSDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 428*5f757f3fSDimitry Andric void __tsan_go_atomic64_fetch_or(ThreadState *thr, uptr cpc, uptr pc, u8 *a); 429*5f757f3fSDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 4300b57cec5SDimitry Andric void __tsan_go_atomic32_exchange(ThreadState *thr, uptr cpc, uptr pc, u8 *a); 4310b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 4320b57cec5SDimitry Andric void __tsan_go_atomic64_exchange(ThreadState *thr, uptr cpc, uptr pc, u8 *a); 4330b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 4340b57cec5SDimitry Andric void __tsan_go_atomic32_compare_exchange(ThreadState *thr, uptr cpc, uptr pc, 4350b57cec5SDimitry Andric u8 *a); 4360b57cec5SDimitry Andric SANITIZER_INTERFACE_ATTRIBUTE 4370b57cec5SDimitry Andric void __tsan_go_atomic64_compare_exchange(ThreadState *thr, uptr cpc, uptr pc, 4380b57cec5SDimitry Andric u8 *a); 439fe6060f1SDimitry Andric 4400b57cec5SDimitry Andric } // extern "C" 4410b57cec5SDimitry Andric 4420b57cec5SDimitry Andric } // namespace __tsan 4430b57cec5SDimitry Andric 4440b57cec5SDimitry Andric #endif // TSAN_INTERFACE_H 445