1 | /* SPDX-License-Identifier: GPL-2.0 */ |
2 | #ifndef _TOOLS_LINUX_COMPILER_H_ |
3 | #define _TOOLS_LINUX_COMPILER_H_ |
4 | |
5 | #include <linux/compiler_types.h> |
6 | |
7 | #ifndef __compiletime_error |
8 | # define __compiletime_error(message) |
9 | #endif |
10 | |
11 | #ifdef __OPTIMIZE__ |
12 | # define __compiletime_assert(condition, msg, prefix, suffix) \ |
13 | do { \ |
14 | extern void prefix ## suffix(void) __compiletime_error(msg); \ |
15 | if (!(condition)) \ |
16 | prefix ## suffix(); \ |
17 | } while (0) |
18 | #else |
19 | # define __compiletime_assert(condition, msg, prefix, suffix) do { } while (0) |
20 | #endif |
21 | |
22 | #define _compiletime_assert(condition, msg, prefix, suffix) \ |
23 | __compiletime_assert(condition, msg, prefix, suffix) |
24 | |
25 | /** |
26 | * compiletime_assert - break build and emit msg if condition is false |
27 | * @condition: a compile-time constant condition to check |
28 | * @msg: a message to emit if condition is false |
29 | * |
30 | * In tradition of POSIX assert, this macro will break the build if the |
31 | * supplied condition is *false*, emitting the supplied error message if the |
32 | * compiler has support to do so. |
33 | */ |
34 | #define compiletime_assert(condition, msg) \ |
35 | _compiletime_assert(condition, msg, __compiletime_assert_, __COUNTER__) |
36 | |
37 | /* Optimization barrier */ |
38 | /* The "volatile" is due to gcc bugs */ |
39 | #define barrier() __asm__ __volatile__("": : :"memory") |
40 | |
41 | #ifndef __always_inline |
42 | # define __always_inline inline __attribute__((always_inline)) |
43 | #endif |
44 | |
45 | #ifndef __always_unused |
46 | #define __always_unused __attribute__((__unused__)) |
47 | #endif |
48 | |
49 | #ifndef __noreturn |
50 | #define __noreturn __attribute__((__noreturn__)) |
51 | #endif |
52 | |
53 | #ifndef unreachable |
54 | #define unreachable() __builtin_unreachable() |
55 | #endif |
56 | |
57 | #ifndef noinline |
58 | #define noinline |
59 | #endif |
60 | |
61 | /* Are two types/vars the same type (ignoring qualifiers)? */ |
62 | #ifndef __same_type |
63 | # define __same_type(a, b) __builtin_types_compatible_p(typeof(a), typeof(b)) |
64 | #endif |
65 | |
66 | /* |
67 | * This returns a constant expression while determining if an argument is |
68 | * a constant expression, most importantly without evaluating the argument. |
69 | * Glory to Martin Uecker <Martin.Uecker@med.uni-goettingen.de> |
70 | */ |
71 | #define __is_constexpr(x) \ |
72 | (sizeof(int) == sizeof(*(8 ? ((void *)((long)(x) * 0l)) : (int *)8))) |
73 | |
74 | #ifdef __ANDROID__ |
75 | /* |
76 | * FIXME: Big hammer to get rid of tons of: |
77 | * "warning: always_inline function might not be inlinable" |
78 | * |
79 | * At least on android-ndk-r12/platforms/android-24/arch-arm |
80 | */ |
81 | #undef __always_inline |
82 | #define __always_inline inline |
83 | #endif |
84 | |
85 | #define __user |
86 | #define __rcu |
87 | #define __read_mostly |
88 | |
89 | #ifndef __attribute_const__ |
90 | # define __attribute_const__ |
91 | #endif |
92 | |
93 | #ifndef __maybe_unused |
94 | # define __maybe_unused __attribute__((unused)) |
95 | #endif |
96 | |
97 | #ifndef __used |
98 | # define __used __attribute__((__unused__)) |
99 | #endif |
100 | |
101 | #ifndef __packed |
102 | # define __packed __attribute__((__packed__)) |
103 | #endif |
104 | |
105 | #ifndef __force |
106 | # define __force |
107 | #endif |
108 | |
109 | #ifndef __weak |
110 | # define __weak __attribute__((weak)) |
111 | #endif |
112 | |
113 | #ifndef likely |
114 | # define likely(x) __builtin_expect(!!(x), 1) |
115 | #endif |
116 | |
117 | #ifndef unlikely |
118 | # define unlikely(x) __builtin_expect(!!(x), 0) |
119 | #endif |
120 | |
121 | #ifndef __init |
122 | # define __init |
123 | #endif |
124 | |
125 | #include <linux/types.h> |
126 | |
127 | /* |
128 | * Following functions are taken from kernel sources and |
129 | * break aliasing rules in their original form. |
130 | * |
131 | * While kernel is compiled with -fno-strict-aliasing, |
132 | * perf uses -Wstrict-aliasing=3 which makes build fail |
133 | * under gcc 4.4. |
134 | * |
135 | * Using extra __may_alias__ type to allow aliasing |
136 | * in this case. |
137 | */ |
138 | typedef __u8 __attribute__((__may_alias__)) __u8_alias_t; |
139 | typedef __u16 __attribute__((__may_alias__)) __u16_alias_t; |
140 | typedef __u32 __attribute__((__may_alias__)) __u32_alias_t; |
141 | typedef __u64 __attribute__((__may_alias__)) __u64_alias_t; |
142 | |
143 | static __always_inline void __read_once_size(const volatile void *p, void *res, int size) |
144 | { |
145 | switch (size) { |
146 | case 1: *(__u8_alias_t *) res = *(volatile __u8_alias_t *) p; break; |
147 | case 2: *(__u16_alias_t *) res = *(volatile __u16_alias_t *) p; break; |
148 | case 4: *(__u32_alias_t *) res = *(volatile __u32_alias_t *) p; break; |
149 | case 8: *(__u64_alias_t *) res = *(volatile __u64_alias_t *) p; break; |
150 | default: |
151 | barrier(); |
152 | __builtin_memcpy((void *)res, (const void *)p, size); |
153 | barrier(); |
154 | } |
155 | } |
156 | |
157 | static __always_inline void __write_once_size(volatile void *p, void *res, int size) |
158 | { |
159 | switch (size) { |
160 | case 1: *(volatile __u8_alias_t *) p = *(__u8_alias_t *) res; break; |
161 | case 2: *(volatile __u16_alias_t *) p = *(__u16_alias_t *) res; break; |
162 | case 4: *(volatile __u32_alias_t *) p = *(__u32_alias_t *) res; break; |
163 | case 8: *(volatile __u64_alias_t *) p = *(__u64_alias_t *) res; break; |
164 | default: |
165 | barrier(); |
166 | __builtin_memcpy((void *)p, (const void *)res, size); |
167 | barrier(); |
168 | } |
169 | } |
170 | |
171 | /* |
172 | * Prevent the compiler from merging or refetching reads or writes. The |
173 | * compiler is also forbidden from reordering successive instances of |
174 | * READ_ONCE and WRITE_ONCE, but only when the compiler is aware of some |
175 | * particular ordering. One way to make the compiler aware of ordering is to |
176 | * put the two invocations of READ_ONCE or WRITE_ONCE in different C |
177 | * statements. |
178 | * |
179 | * These two macros will also work on aggregate data types like structs or |
180 | * unions. If the size of the accessed data type exceeds the word size of |
181 | * the machine (e.g., 32 bits or 64 bits) READ_ONCE() and WRITE_ONCE() will |
182 | * fall back to memcpy and print a compile-time warning. |
183 | * |
184 | * Their two major use cases are: (1) Mediating communication between |
185 | * process-level code and irq/NMI handlers, all running on the same CPU, |
186 | * and (2) Ensuring that the compiler does not fold, spindle, or otherwise |
187 | * mutilate accesses that either do not require ordering or that interact |
188 | * with an explicit memory barrier or atomic instruction that provides the |
189 | * required ordering. |
190 | */ |
191 | |
192 | #define READ_ONCE(x) \ |
193 | ({ \ |
194 | union { typeof(x) __val; char __c[1]; } __u = \ |
195 | { .__c = { 0 } }; \ |
196 | __read_once_size(&(x), __u.__c, sizeof(x)); \ |
197 | __u.__val; \ |
198 | }) |
199 | |
200 | #define WRITE_ONCE(x, val) \ |
201 | ({ \ |
202 | union { typeof(x) __val; char __c[1]; } __u = \ |
203 | { .__val = (val) }; \ |
204 | __write_once_size(&(x), __u.__c, sizeof(x)); \ |
205 | __u.__val; \ |
206 | }) |
207 | |
208 | |
209 | /* Indirect macros required for expanded argument pasting, eg. __LINE__. */ |
210 | #define ___PASTE(a, b) a##b |
211 | #define __PASTE(a, b) ___PASTE(a, b) |
212 | |
213 | #ifndef OPTIMIZER_HIDE_VAR |
214 | /* Make the optimizer believe the variable can be manipulated arbitrarily. */ |
215 | #define OPTIMIZER_HIDE_VAR(var) \ |
216 | __asm__ ("" : "=r" (var) : "0" (var)) |
217 | #endif |
218 | |
219 | #endif /* _TOOLS_LINUX_COMPILER_H */ |
220 | |