446 lines · c
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-exception6//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 instrumentation12// module.13// This header can be included by the instrumented program or by TSan tests.14//===----------------------------------------------------------------------===//15#ifndef TSAN_INTERFACE_H16#define TSAN_INTERFACE_H17 18#include <sanitizer_common/sanitizer_internal_defs.h>19using __sanitizer::ThreadID;20using __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 __cplusplus26extern "C" {27#endif28 29#if !SANITIZER_GO30 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.33SANITIZER_INTERFACE_ATTRIBUTE void __tsan_init();34 35SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE const char *36__tsan_default_options();37 38SANITIZER_INTERFACE_ATTRIBUTE void __tsan_flush_memory();39 40SANITIZER_INTERFACE_ATTRIBUTE void __tsan_read1(void *addr);41SANITIZER_INTERFACE_ATTRIBUTE void __tsan_read2(void *addr);42SANITIZER_INTERFACE_ATTRIBUTE void __tsan_read4(void *addr);43SANITIZER_INTERFACE_ATTRIBUTE void __tsan_read8(void *addr);44SANITIZER_INTERFACE_ATTRIBUTE void __tsan_read16(void *addr);45 46SANITIZER_INTERFACE_ATTRIBUTE void __tsan_write1(void *addr);47SANITIZER_INTERFACE_ATTRIBUTE void __tsan_write2(void *addr);48SANITIZER_INTERFACE_ATTRIBUTE void __tsan_write4(void *addr);49SANITIZER_INTERFACE_ATTRIBUTE void __tsan_write8(void *addr);50SANITIZER_INTERFACE_ATTRIBUTE void __tsan_write16(void *addr);51 52SANITIZER_INTERFACE_ATTRIBUTE void __tsan_unaligned_read2(const void *addr);53SANITIZER_INTERFACE_ATTRIBUTE void __tsan_unaligned_read4(const void *addr);54SANITIZER_INTERFACE_ATTRIBUTE void __tsan_unaligned_read8(const void *addr);55SANITIZER_INTERFACE_ATTRIBUTE void __tsan_unaligned_read16(const void *addr);56 57SANITIZER_INTERFACE_ATTRIBUTE void __tsan_unaligned_write2(void *addr);58SANITIZER_INTERFACE_ATTRIBUTE void __tsan_unaligned_write4(void *addr);59SANITIZER_INTERFACE_ATTRIBUTE void __tsan_unaligned_write8(void *addr);60SANITIZER_INTERFACE_ATTRIBUTE void __tsan_unaligned_write16(void *addr);61 62SANITIZER_INTERFACE_ATTRIBUTE void __tsan_read1_pc(void *addr, void *pc);63SANITIZER_INTERFACE_ATTRIBUTE void __tsan_read2_pc(void *addr, void *pc);64SANITIZER_INTERFACE_ATTRIBUTE void __tsan_read4_pc(void *addr, void *pc);65SANITIZER_INTERFACE_ATTRIBUTE void __tsan_read8_pc(void *addr, void *pc);66SANITIZER_INTERFACE_ATTRIBUTE void __tsan_read16_pc(void *addr, void *pc);67 68SANITIZER_INTERFACE_ATTRIBUTE void __tsan_write1_pc(void *addr, void *pc);69SANITIZER_INTERFACE_ATTRIBUTE void __tsan_write2_pc(void *addr, void *pc);70SANITIZER_INTERFACE_ATTRIBUTE void __tsan_write4_pc(void *addr, void *pc);71SANITIZER_INTERFACE_ATTRIBUTE void __tsan_write8_pc(void *addr, void *pc);72SANITIZER_INTERFACE_ATTRIBUTE void __tsan_write16_pc(void *addr, void *pc);73 74SANITIZER_INTERFACE_ATTRIBUTE void __tsan_vptr_read(void **vptr_p);75SANITIZER_INTERFACE_ATTRIBUTE76void __tsan_vptr_update(void **vptr_p, void *new_val);77 78SANITIZER_INTERFACE_ATTRIBUTE79void *__tsan_memcpy(void *dest, const void *src, uptr count);80SANITIZER_INTERFACE_ATTRIBUTE81void *__tsan_memset(void *dest, int ch, uptr count);82SANITIZER_INTERFACE_ATTRIBUTE83void *__tsan_memmove(void *dest, const void *src, uptr count);84 85SANITIZER_INTERFACE_ATTRIBUTE void __tsan_func_entry(void *call_pc);86SANITIZER_INTERFACE_ATTRIBUTE void __tsan_func_exit();87 88SANITIZER_INTERFACE_ATTRIBUTE void __tsan_ignore_thread_begin();89SANITIZER_INTERFACE_ATTRIBUTE void __tsan_ignore_thread_end();90 91SANITIZER_INTERFACE_ATTRIBUTE void __tsan_on_thread_idle();92 93SANITIZER_INTERFACE_ATTRIBUTE94void *__tsan_external_register_tag(const char *object_type);95SANITIZER_INTERFACE_ATTRIBUTE96void __tsan_external_register_header(void *tag, const char *header);97SANITIZER_INTERFACE_ATTRIBUTE98void __tsan_external_assign_tag(void *addr, void *tag);99SANITIZER_INTERFACE_ATTRIBUTE100void __tsan_external_read(void *addr, void *caller_pc, void *tag);101SANITIZER_INTERFACE_ATTRIBUTE102void __tsan_external_write(void *addr, void *caller_pc, void *tag);103 104SANITIZER_INTERFACE_ATTRIBUTE105void __tsan_read_range(void *addr, unsigned long size);106SANITIZER_INTERFACE_ATTRIBUTE107void __tsan_write_range(void *addr, unsigned long size);108 109SANITIZER_INTERFACE_ATTRIBUTE110void __tsan_read_range_pc(void *addr, unsigned long size, void *pc);111SANITIZER_INTERFACE_ATTRIBUTE112void __tsan_write_range_pc(void *addr, unsigned long size, void *pc);113 114// User may provide function that would be called right when TSan detects115// an error. The argument 'report' is an opaque pointer that can be used to116// gather additional information using other TSan report API functions.117SANITIZER_INTERFACE_ATTRIBUTE118void __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.122SANITIZER_INTERFACE_ATTRIBUTE123void *__tsan_get_current_report();124 125// Returns a report's description (issue type), number of duplicate issues126// found, counts of array data (stack traces, memory operations, locations,127// mutexes, threads, unique thread IDs) and a stack trace of a sleep() call (if128// one was involved in the issue).129SANITIZER_INTERFACE_ATTRIBUTE130int __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). External137/// races can be associated with a tag which give them more meaning. For example138/// tag value '1' means "Swift access race". Tag value '0' indicated a plain139/// external race.140///141/// \param report opaque pointer to the current report (obtained as argument in142/// __tsan_on_report, or from __tsan_get_current_report)143/// \param [out] tag points to storage that will be filled with the tag value144///145/// \returns non-zero value on success, zero on failure146SANITIZER_INTERFACE_ATTRIBUTE147int __tsan_get_report_tag(void *report, uptr *tag);148 149// Returns information about stack traces included in the report.150SANITIZER_INTERFACE_ATTRIBUTE151int __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.155SANITIZER_INTERFACE_ATTRIBUTE156int __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.161SANITIZER_INTERFACE_ATTRIBUTE162int __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 167SANITIZER_INTERFACE_ATTRIBUTE168int __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.172SANITIZER_INTERFACE_ATTRIBUTE173int __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.177SANITIZER_INTERFACE_ATTRIBUTE178int __tsan_get_report_thread(void *report, uptr idx, int *tid, ThreadID *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.183SANITIZER_INTERFACE_ATTRIBUTE184int __tsan_get_report_unique_tid(void *report, uptr idx, int *tid);185 186// Returns the type of the pointer (heap, stack, global, ...) and if possible187// also the starting address (e.g. of a heap allocation) and size.188SANITIZER_INTERFACE_ATTRIBUTE189const 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.193SANITIZER_INTERFACE_ATTRIBUTE194int __tsan_get_alloc_stack(uptr addr, uptr *trace, uptr size, int *thread_id,195 ThreadID *os_id);196 197#endif // SANITIZER_GO198 199#ifdef __cplusplus200} // extern "C"201#endif202 203namespace __tsan {204 205// These should match declarations from public tsan_interface_atomic.h header.206typedef unsigned char a8;207typedef unsigned short a16;208typedef unsigned int a32;209typedef 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 1216#else217# define __TSAN_HAS_INT128 0218#endif219 220// Part of ABI, do not change.221// https://github.com/llvm/llvm-project/blob/main/libcxx/include/atomic222typedef enum {223 mo_relaxed,224 mo_consume,225 mo_acquire,226 mo_release,227 mo_acq_rel,228 mo_seq_cst229} morder;230 231struct ThreadState;232 233extern "C" {234SANITIZER_INTERFACE_ATTRIBUTE235a8 __tsan_atomic8_load(const volatile a8 *a, int mo);236SANITIZER_INTERFACE_ATTRIBUTE237a16 __tsan_atomic16_load(const volatile a16 *a, int mo);238SANITIZER_INTERFACE_ATTRIBUTE239a32 __tsan_atomic32_load(const volatile a32 *a, int mo);240SANITIZER_INTERFACE_ATTRIBUTE241a64 __tsan_atomic64_load(const volatile a64 *a, int mo);242#if __TSAN_HAS_INT128243SANITIZER_INTERFACE_ATTRIBUTE244a128 __tsan_atomic128_load(const volatile a128 *a, int mo);245#endif246 247SANITIZER_INTERFACE_ATTRIBUTE248void __tsan_atomic8_store(volatile a8 *a, a8 v, int mo);249SANITIZER_INTERFACE_ATTRIBUTE250void __tsan_atomic16_store(volatile a16 *a, a16 v, int mo);251SANITIZER_INTERFACE_ATTRIBUTE252void __tsan_atomic32_store(volatile a32 *a, a32 v, int mo);253SANITIZER_INTERFACE_ATTRIBUTE254void __tsan_atomic64_store(volatile a64 *a, a64 v, int mo);255#if __TSAN_HAS_INT128256SANITIZER_INTERFACE_ATTRIBUTE257void __tsan_atomic128_store(volatile a128 *a, a128 v, int mo);258#endif259 260SANITIZER_INTERFACE_ATTRIBUTE261a8 __tsan_atomic8_exchange(volatile a8 *a, a8 v, int mo);262SANITIZER_INTERFACE_ATTRIBUTE263a16 __tsan_atomic16_exchange(volatile a16 *a, a16 v, int mo);264SANITIZER_INTERFACE_ATTRIBUTE265a32 __tsan_atomic32_exchange(volatile a32 *a, a32 v, int mo);266SANITIZER_INTERFACE_ATTRIBUTE267a64 __tsan_atomic64_exchange(volatile a64 *a, a64 v, int mo);268#if __TSAN_HAS_INT128269SANITIZER_INTERFACE_ATTRIBUTE270a128 __tsan_atomic128_exchange(volatile a128 *a, a128 v, int mo);271#endif272 273SANITIZER_INTERFACE_ATTRIBUTE274a8 __tsan_atomic8_fetch_add(volatile a8 *a, a8 v, int mo);275SANITIZER_INTERFACE_ATTRIBUTE276a16 __tsan_atomic16_fetch_add(volatile a16 *a, a16 v, int mo);277SANITIZER_INTERFACE_ATTRIBUTE278a32 __tsan_atomic32_fetch_add(volatile a32 *a, a32 v, int mo);279SANITIZER_INTERFACE_ATTRIBUTE280a64 __tsan_atomic64_fetch_add(volatile a64 *a, a64 v, int mo);281#if __TSAN_HAS_INT128282SANITIZER_INTERFACE_ATTRIBUTE283a128 __tsan_atomic128_fetch_add(volatile a128 *a, a128 v, int mo);284#endif285 286SANITIZER_INTERFACE_ATTRIBUTE287a8 __tsan_atomic8_fetch_sub(volatile a8 *a, a8 v, int mo);288SANITIZER_INTERFACE_ATTRIBUTE289a16 __tsan_atomic16_fetch_sub(volatile a16 *a, a16 v, int mo);290SANITIZER_INTERFACE_ATTRIBUTE291a32 __tsan_atomic32_fetch_sub(volatile a32 *a, a32 v, int mo);292SANITIZER_INTERFACE_ATTRIBUTE293a64 __tsan_atomic64_fetch_sub(volatile a64 *a, a64 v, int mo);294#if __TSAN_HAS_INT128295SANITIZER_INTERFACE_ATTRIBUTE296a128 __tsan_atomic128_fetch_sub(volatile a128 *a, a128 v, int mo);297#endif298 299SANITIZER_INTERFACE_ATTRIBUTE300a8 __tsan_atomic8_fetch_and(volatile a8 *a, a8 v, int mo);301SANITIZER_INTERFACE_ATTRIBUTE302a16 __tsan_atomic16_fetch_and(volatile a16 *a, a16 v, int mo);303SANITIZER_INTERFACE_ATTRIBUTE304a32 __tsan_atomic32_fetch_and(volatile a32 *a, a32 v, int mo);305SANITIZER_INTERFACE_ATTRIBUTE306a64 __tsan_atomic64_fetch_and(volatile a64 *a, a64 v, int mo);307#if __TSAN_HAS_INT128308SANITIZER_INTERFACE_ATTRIBUTE309a128 __tsan_atomic128_fetch_and(volatile a128 *a, a128 v, int mo);310#endif311 312SANITIZER_INTERFACE_ATTRIBUTE313a8 __tsan_atomic8_fetch_or(volatile a8 *a, a8 v, int mo);314SANITIZER_INTERFACE_ATTRIBUTE315a16 __tsan_atomic16_fetch_or(volatile a16 *a, a16 v, int mo);316SANITIZER_INTERFACE_ATTRIBUTE317a32 __tsan_atomic32_fetch_or(volatile a32 *a, a32 v, int mo);318SANITIZER_INTERFACE_ATTRIBUTE319a64 __tsan_atomic64_fetch_or(volatile a64 *a, a64 v, int mo);320#if __TSAN_HAS_INT128321SANITIZER_INTERFACE_ATTRIBUTE322a128 __tsan_atomic128_fetch_or(volatile a128 *a, a128 v, int mo);323#endif324 325SANITIZER_INTERFACE_ATTRIBUTE326a8 __tsan_atomic8_fetch_xor(volatile a8 *a, a8 v, int mo);327SANITIZER_INTERFACE_ATTRIBUTE328a16 __tsan_atomic16_fetch_xor(volatile a16 *a, a16 v, int mo);329SANITIZER_INTERFACE_ATTRIBUTE330a32 __tsan_atomic32_fetch_xor(volatile a32 *a, a32 v, int mo);331SANITIZER_INTERFACE_ATTRIBUTE332a64 __tsan_atomic64_fetch_xor(volatile a64 *a, a64 v, int mo);333#if __TSAN_HAS_INT128334SANITIZER_INTERFACE_ATTRIBUTE335a128 __tsan_atomic128_fetch_xor(volatile a128 *a, a128 v, int mo);336#endif337 338SANITIZER_INTERFACE_ATTRIBUTE339a8 __tsan_atomic8_fetch_nand(volatile a8 *a, a8 v, int mo);340SANITIZER_INTERFACE_ATTRIBUTE341a16 __tsan_atomic16_fetch_nand(volatile a16 *a, a16 v, int mo);342SANITIZER_INTERFACE_ATTRIBUTE343a32 __tsan_atomic32_fetch_nand(volatile a32 *a, a32 v, int mo);344SANITIZER_INTERFACE_ATTRIBUTE345a64 __tsan_atomic64_fetch_nand(volatile a64 *a, a64 v, int mo);346#if __TSAN_HAS_INT128347SANITIZER_INTERFACE_ATTRIBUTE348a128 __tsan_atomic128_fetch_nand(volatile a128 *a, a128 v, int mo);349#endif350 351SANITIZER_INTERFACE_ATTRIBUTE352int __tsan_atomic8_compare_exchange_strong(volatile a8 *a, a8 *c, a8 v, int mo,353 int fmo);354SANITIZER_INTERFACE_ATTRIBUTE355int __tsan_atomic16_compare_exchange_strong(volatile a16 *a, a16 *c, a16 v,356 int mo, int fmo);357SANITIZER_INTERFACE_ATTRIBUTE358int __tsan_atomic32_compare_exchange_strong(volatile a32 *a, a32 *c, a32 v,359 int mo, int fmo);360SANITIZER_INTERFACE_ATTRIBUTE361int __tsan_atomic64_compare_exchange_strong(volatile a64 *a, a64 *c, a64 v,362 int mo, int fmo);363#if __TSAN_HAS_INT128364SANITIZER_INTERFACE_ATTRIBUTE365int __tsan_atomic128_compare_exchange_strong(volatile a128 *a, a128 *c, a128 v,366 int mo, int fmo);367#endif368 369SANITIZER_INTERFACE_ATTRIBUTE370int __tsan_atomic8_compare_exchange_weak(volatile a8 *a, a8 *c, a8 v, int mo,371 int fmo);372SANITIZER_INTERFACE_ATTRIBUTE373int __tsan_atomic16_compare_exchange_weak(volatile a16 *a, a16 *c, a16 v,374 int mo, int fmo);375SANITIZER_INTERFACE_ATTRIBUTE376int __tsan_atomic32_compare_exchange_weak(volatile a32 *a, a32 *c, a32 v,377 int mo, int fmo);378SANITIZER_INTERFACE_ATTRIBUTE379int __tsan_atomic64_compare_exchange_weak(volatile a64 *a, a64 *c, a64 v,380 int mo, int fmo);381#if __TSAN_HAS_INT128382SANITIZER_INTERFACE_ATTRIBUTE383int __tsan_atomic128_compare_exchange_weak(volatile a128 *a, a128 *c, a128 v,384 int mo, int fmo);385#endif386 387SANITIZER_INTERFACE_ATTRIBUTE388a8 __tsan_atomic8_compare_exchange_val(volatile a8 *a, a8 c, a8 v, int mo,389 int fmo);390SANITIZER_INTERFACE_ATTRIBUTE391a16 __tsan_atomic16_compare_exchange_val(volatile a16 *a, a16 c, a16 v, int mo,392 int fmo);393SANITIZER_INTERFACE_ATTRIBUTE394a32 __tsan_atomic32_compare_exchange_val(volatile a32 *a, a32 c, a32 v, int mo,395 int fmo);396SANITIZER_INTERFACE_ATTRIBUTE397a64 __tsan_atomic64_compare_exchange_val(volatile a64 *a, a64 c, a64 v, int mo,398 int fmo);399#if __TSAN_HAS_INT128400SANITIZER_INTERFACE_ATTRIBUTE401a128 __tsan_atomic128_compare_exchange_val(volatile a128 *a, a128 c, a128 v,402 int mo, int fmo);403#endif404 405SANITIZER_INTERFACE_ATTRIBUTE406void __tsan_atomic_thread_fence(int mo);407SANITIZER_INTERFACE_ATTRIBUTE408void __tsan_atomic_signal_fence(int mo);409 410SANITIZER_INTERFACE_ATTRIBUTE411void __tsan_go_atomic32_load(ThreadState *thr, uptr cpc, uptr pc, u8 *a);412SANITIZER_INTERFACE_ATTRIBUTE413void __tsan_go_atomic64_load(ThreadState *thr, uptr cpc, uptr pc, u8 *a);414SANITIZER_INTERFACE_ATTRIBUTE415void __tsan_go_atomic32_store(ThreadState *thr, uptr cpc, uptr pc, u8 *a);416SANITIZER_INTERFACE_ATTRIBUTE417void __tsan_go_atomic64_store(ThreadState *thr, uptr cpc, uptr pc, u8 *a);418SANITIZER_INTERFACE_ATTRIBUTE419void __tsan_go_atomic32_fetch_add(ThreadState *thr, uptr cpc, uptr pc, u8 *a);420SANITIZER_INTERFACE_ATTRIBUTE421void __tsan_go_atomic64_fetch_add(ThreadState *thr, uptr cpc, uptr pc, u8 *a);422SANITIZER_INTERFACE_ATTRIBUTE423void __tsan_go_atomic32_fetch_and(ThreadState *thr, uptr cpc, uptr pc, u8 *a);424SANITIZER_INTERFACE_ATTRIBUTE425void __tsan_go_atomic64_fetch_and(ThreadState *thr, uptr cpc, uptr pc, u8 *a);426SANITIZER_INTERFACE_ATTRIBUTE427void __tsan_go_atomic32_fetch_or(ThreadState *thr, uptr cpc, uptr pc, u8 *a);428SANITIZER_INTERFACE_ATTRIBUTE429void __tsan_go_atomic64_fetch_or(ThreadState *thr, uptr cpc, uptr pc, u8 *a);430SANITIZER_INTERFACE_ATTRIBUTE431void __tsan_go_atomic32_exchange(ThreadState *thr, uptr cpc, uptr pc, u8 *a);432SANITIZER_INTERFACE_ATTRIBUTE433void __tsan_go_atomic64_exchange(ThreadState *thr, uptr cpc, uptr pc, u8 *a);434SANITIZER_INTERFACE_ATTRIBUTE435void __tsan_go_atomic32_compare_exchange(ThreadState *thr, uptr cpc, uptr pc,436 u8 *a);437SANITIZER_INTERFACE_ATTRIBUTE438void __tsan_go_atomic64_compare_exchange(ThreadState *thr, uptr cpc, uptr pc,439 u8 *a);440 441} // extern "C"442 443} // namespace __tsan444 445#endif // TSAN_INTERFACE_H446