f6870a2de293b3449d76c9c873236f0f46957dd0
[openssl.git] / include / internal / tsan_assist.h
1 /*
2  * Copyright 2018 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the OpenSSL license (the "License").  You may not use
5  * this file except in compliance with the License.  You can obtain a copy
6  * in the file LICENSE in the source distribution or at
7  * https://www.openssl.org/source/license.html
8  */
9  
10 /*
11  * Goal here is to facilitate writing "thread-opportunistic" code that
12  * withstands Thread Sanitizer's scrutiny. "Thread-opportunistic" is when
13  * exact result is not required, e.g. some statistics, or execution flow
14  * doesn't have to be unambiguous. Simplest example is lazy "constant"
15  * initialization when one can synchronize on variable itself, e.g.
16  *
17  * if (var == NOT_YET_INITIALIZED)
18  *     var = function_returning_same_value();
19  *
20  * This does work provided that loads and stores are single-instuction
21  * operations (and integer ones are on *all* supported platforms), but
22  * it upsets Thread Sanitizer. Suggested solution is
23  *
24  * if (tsan_load(&var) == NOT_YET_INITIALIZED)
25  *     tsan_store(&var, function_returning_same_value());
26  *
27  * Production machine code would be the same, so one can wonder why
28  * bother. Having Thread Sanitizer accept "thread-opportunistic" code
29  * allows to move on trouble-shooting real bugs.
30  *
31  * We utilize the fact that compilers that implement Thread Sanitizer
32  * implement even atomic operations. Then it's assumed that
33  * ATOMIC_{LONG|INT}_LOCK_FREE are assigned same value as
34  * ATOMIC_POINTER_LOCK_FREE. And check for >= 2 ensures that correspodning
35  * code is inlined. It should be noted that statistics counters become
36  * accurate in such case.
37  */
38
39 #if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L \
40     && !defined(__STDC_NO_ATOMICS__)
41 # include <stdatomic.h>
42
43 # if defined(ATOMIC_POINTER_LOCK_FREE) \
44           && ATOMIC_POINTER_LOCK_FREE >= 2
45 #  define TSAN_QUALIFIER _Atomic
46 #  define tsan_load(ptr) atomic_load_explicit((ptr), memory_order_relaxed)
47 #  define tsan_store(ptr, val) atomic_store_explicit((ptr), (val), memory_order_relaxed)
48 #  define tsan_counter(ptr) atomic_fetch_add_explicit((ptr), 1, memory_order_relaxed)
49 # endif
50
51 #elif defined(__GNUC__) && defined(__ATOMIC_RELAXED)
52
53 # if defined(__GCC_ATOMIC_POINTER_LOCK_FREE) \
54           && __GCC_ATOMIC_POINTER_LOCK_FREE >= 2
55 #  define TSAN_QUALIFIER volatile
56 #  define tsan_load(ptr) __atomic_load_n((ptr), __ATOMIC_RELAXED)
57 #  define tsan_store(ptr, val) __atomic_store_n((ptr), (val), __ATOMIC_RELAXED)
58 #  define tsan_counter(ptr) __atomic_fetch_add((ptr), 1, __ATOMIC_RELAXED)
59 # endif
60
61 #elif defined(_MSC_VER) && _MSC_VER>=1200
62
63 # define TSAN_QUALIFIER volatile
64 # define tsan_load(ptr) (*(ptr))
65 # define tsan_store(ptr, val) (*(ptr) = (val))
66 # pragma intrinsic(_InterlockedExchangeAdd)
67 # ifdef _WIN64
68 #  pragma intrinsic(_InterlockedExchangeAdd64)
69 #  define tsan_counter(ptr) (sizeof(*ptr) == 8 ? _InterlockedExchangeAdd64((ptr), 1) \
70                                                : _InterlockedExchangeAdd((ptr), 1))
71 # else
72 #  define tsan_counter(ptr) _InterlockedExchangeAdd((ptr), 1)
73 # endif
74
75 #endif
76
77 #ifndef TSAN_QUALIFIER
78
79 # define TSAN_QUALIFIER volatile
80 # define tsan_load(ptr) (*(ptr))
81 # define tsan_store(ptr, val) (*(ptr) = (val))
82 # define tsan_counter(ptr) ((*(ptr))++)
83
84 #endif