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