bug.h, compiler.h: introduce compiletime_assert & BUILD_BUG_ON_MSG
[~shefty/rdma-dev.git] / include / linux / compiler.h
1 #ifndef __LINUX_COMPILER_H
2 #define __LINUX_COMPILER_H
3
4 #ifndef __ASSEMBLY__
5
6 #ifdef __CHECKER__
7 # define __user         __attribute__((noderef, address_space(1)))
8 # define __kernel       __attribute__((address_space(0)))
9 # define __safe         __attribute__((safe))
10 # define __force        __attribute__((force))
11 # define __nocast       __attribute__((nocast))
12 # define __iomem        __attribute__((noderef, address_space(2)))
13 # define __must_hold(x) __attribute__((context(x,1,1)))
14 # define __acquires(x)  __attribute__((context(x,0,1)))
15 # define __releases(x)  __attribute__((context(x,1,0)))
16 # define __acquire(x)   __context__(x,1)
17 # define __release(x)   __context__(x,-1)
18 # define __cond_lock(x,c)       ((c) ? ({ __acquire(x); 1; }) : 0)
19 # define __percpu       __attribute__((noderef, address_space(3)))
20 #ifdef CONFIG_SPARSE_RCU_POINTER
21 # define __rcu          __attribute__((noderef, address_space(4)))
22 #else
23 # define __rcu
24 #endif
25 extern void __chk_user_ptr(const volatile void __user *);
26 extern void __chk_io_ptr(const volatile void __iomem *);
27 #else
28 # define __user
29 # define __kernel
30 # define __safe
31 # define __force
32 # define __nocast
33 # define __iomem
34 # define __chk_user_ptr(x) (void)0
35 # define __chk_io_ptr(x) (void)0
36 # define __builtin_warning(x, y...) (1)
37 # define __must_hold(x)
38 # define __acquires(x)
39 # define __releases(x)
40 # define __acquire(x) (void)0
41 # define __release(x) (void)0
42 # define __cond_lock(x,c) (c)
43 # define __percpu
44 # define __rcu
45 #endif
46
47 /* Indirect macros required for expanded argument pasting, eg. __LINE__. */
48 #define ___PASTE(a,b) a##b
49 #define __PASTE(a,b) ___PASTE(a,b)
50
51 #ifdef __KERNEL__
52
53 #ifdef __GNUC__
54 #include <linux/compiler-gcc.h>
55 #endif
56
57 #define notrace __attribute__((no_instrument_function))
58
59 /* Intel compiler defines __GNUC__. So we will overwrite implementations
60  * coming from above header files here
61  */
62 #ifdef __INTEL_COMPILER
63 # include <linux/compiler-intel.h>
64 #endif
65
66 /*
67  * Generic compiler-dependent macros required for kernel
68  * build go below this comment. Actual compiler/compiler version
69  * specific implementations come from the above header files
70  */
71
72 struct ftrace_branch_data {
73         const char *func;
74         const char *file;
75         unsigned line;
76         union {
77                 struct {
78                         unsigned long correct;
79                         unsigned long incorrect;
80                 };
81                 struct {
82                         unsigned long miss;
83                         unsigned long hit;
84                 };
85                 unsigned long miss_hit[2];
86         };
87 };
88
89 /*
90  * Note: DISABLE_BRANCH_PROFILING can be used by special lowlevel code
91  * to disable branch tracing on a per file basis.
92  */
93 #if defined(CONFIG_TRACE_BRANCH_PROFILING) \
94     && !defined(DISABLE_BRANCH_PROFILING) && !defined(__CHECKER__)
95 void ftrace_likely_update(struct ftrace_branch_data *f, int val, int expect);
96
97 #define likely_notrace(x)       __builtin_expect(!!(x), 1)
98 #define unlikely_notrace(x)     __builtin_expect(!!(x), 0)
99
100 #define __branch_check__(x, expect) ({                                  \
101                         int ______r;                                    \
102                         static struct ftrace_branch_data                \
103                                 __attribute__((__aligned__(4)))         \
104                                 __attribute__((section("_ftrace_annotated_branch"))) \
105                                 ______f = {                             \
106                                 .func = __func__,                       \
107                                 .file = __FILE__,                       \
108                                 .line = __LINE__,                       \
109                         };                                              \
110                         ______r = likely_notrace(x);                    \
111                         ftrace_likely_update(&______f, ______r, expect); \
112                         ______r;                                        \
113                 })
114
115 /*
116  * Using __builtin_constant_p(x) to ignore cases where the return
117  * value is always the same.  This idea is taken from a similar patch
118  * written by Daniel Walker.
119  */
120 # ifndef likely
121 #  define likely(x)     (__builtin_constant_p(x) ? !!(x) : __branch_check__(x, 1))
122 # endif
123 # ifndef unlikely
124 #  define unlikely(x)   (__builtin_constant_p(x) ? !!(x) : __branch_check__(x, 0))
125 # endif
126
127 #ifdef CONFIG_PROFILE_ALL_BRANCHES
128 /*
129  * "Define 'is'", Bill Clinton
130  * "Define 'if'", Steven Rostedt
131  */
132 #define if(cond, ...) __trace_if( (cond , ## __VA_ARGS__) )
133 #define __trace_if(cond) \
134         if (__builtin_constant_p((cond)) ? !!(cond) :                   \
135         ({                                                              \
136                 int ______r;                                            \
137                 static struct ftrace_branch_data                        \
138                         __attribute__((__aligned__(4)))                 \
139                         __attribute__((section("_ftrace_branch")))      \
140                         ______f = {                                     \
141                                 .func = __func__,                       \
142                                 .file = __FILE__,                       \
143                                 .line = __LINE__,                       \
144                         };                                              \
145                 ______r = !!(cond);                                     \
146                 ______f.miss_hit[______r]++;                                    \
147                 ______r;                                                \
148         }))
149 #endif /* CONFIG_PROFILE_ALL_BRANCHES */
150
151 #else
152 # define likely(x)      __builtin_expect(!!(x), 1)
153 # define unlikely(x)    __builtin_expect(!!(x), 0)
154 #endif
155
156 /* Optimization barrier */
157 #ifndef barrier
158 # define barrier() __memory_barrier()
159 #endif
160
161 /* Unreachable code */
162 #ifndef unreachable
163 # define unreachable() do { } while (1)
164 #endif
165
166 #ifndef RELOC_HIDE
167 # define RELOC_HIDE(ptr, off)                                   \
168   ({ unsigned long __ptr;                                       \
169      __ptr = (unsigned long) (ptr);                             \
170     (typeof(ptr)) (__ptr + (off)); })
171 #endif
172
173 /* Not-quite-unique ID. */
174 #ifndef __UNIQUE_ID
175 # define __UNIQUE_ID(prefix) __PASTE(__PASTE(__UNIQUE_ID_, prefix), __LINE__)
176 #endif
177
178 #endif /* __KERNEL__ */
179
180 #endif /* __ASSEMBLY__ */
181
182 #ifdef __KERNEL__
183 /*
184  * Allow us to mark functions as 'deprecated' and have gcc emit a nice
185  * warning for each use, in hopes of speeding the functions removal.
186  * Usage is:
187  *              int __deprecated foo(void)
188  */
189 #ifndef __deprecated
190 # define __deprecated           /* unimplemented */
191 #endif
192
193 #ifdef MODULE
194 #define __deprecated_for_modules __deprecated
195 #else
196 #define __deprecated_for_modules
197 #endif
198
199 #ifndef __must_check
200 #define __must_check
201 #endif
202
203 #ifndef CONFIG_ENABLE_MUST_CHECK
204 #undef __must_check
205 #define __must_check
206 #endif
207 #ifndef CONFIG_ENABLE_WARN_DEPRECATED
208 #undef __deprecated
209 #undef __deprecated_for_modules
210 #define __deprecated
211 #define __deprecated_for_modules
212 #endif
213
214 /*
215  * Allow us to avoid 'defined but not used' warnings on functions and data,
216  * as well as force them to be emitted to the assembly file.
217  *
218  * As of gcc 3.4, static functions that are not marked with attribute((used))
219  * may be elided from the assembly file.  As of gcc 3.4, static data not so
220  * marked will not be elided, but this may change in a future gcc version.
221  *
222  * NOTE: Because distributions shipped with a backported unit-at-a-time
223  * compiler in gcc 3.3, we must define __used to be __attribute__((used))
224  * for gcc >=3.3 instead of 3.4.
225  *
226  * In prior versions of gcc, such functions and data would be emitted, but
227  * would be warned about except with attribute((unused)).
228  *
229  * Mark functions that are referenced only in inline assembly as __used so
230  * the code is emitted even though it appears to be unreferenced.
231  */
232 #ifndef __used
233 # define __used                 /* unimplemented */
234 #endif
235
236 #ifndef __maybe_unused
237 # define __maybe_unused         /* unimplemented */
238 #endif
239
240 #ifndef __always_unused
241 # define __always_unused        /* unimplemented */
242 #endif
243
244 #ifndef noinline
245 #define noinline
246 #endif
247
248 /*
249  * Rather then using noinline to prevent stack consumption, use
250  * noinline_for_stack instead.  For documentation reasons.
251  */
252 #define noinline_for_stack noinline
253
254 #ifndef __always_inline
255 #define __always_inline inline
256 #endif
257
258 #endif /* __KERNEL__ */
259
260 /*
261  * From the GCC manual:
262  *
263  * Many functions do not examine any values except their arguments,
264  * and have no effects except the return value.  Basically this is
265  * just slightly more strict class than the `pure' attribute above,
266  * since function is not allowed to read global memory.
267  *
268  * Note that a function that has pointer arguments and examines the
269  * data pointed to must _not_ be declared `const'.  Likewise, a
270  * function that calls a non-`const' function usually must not be
271  * `const'.  It does not make sense for a `const' function to return
272  * `void'.
273  */
274 #ifndef __attribute_const__
275 # define __attribute_const__    /* unimplemented */
276 #endif
277
278 /*
279  * Tell gcc if a function is cold. The compiler will assume any path
280  * directly leading to the call is unlikely.
281  */
282
283 #ifndef __cold
284 #define __cold
285 #endif
286
287 /* Simple shorthand for a section definition */
288 #ifndef __section
289 # define __section(S) __attribute__ ((__section__(#S)))
290 #endif
291
292 #ifndef __visible
293 #define __visible
294 #endif
295
296 /* Are two types/vars the same type (ignoring qualifiers)? */
297 #ifndef __same_type
298 # define __same_type(a, b) __builtin_types_compatible_p(typeof(a), typeof(b))
299 #endif
300
301 /* Compile time object size, -1 for unknown */
302 #ifndef __compiletime_object_size
303 # define __compiletime_object_size(obj) -1
304 #endif
305 #ifndef __compiletime_warning
306 # define __compiletime_warning(message)
307 #endif
308 #ifndef __compiletime_error
309 # define __compiletime_error(message)
310 # define __compiletime_error_fallback(condition) \
311         do { ((void)sizeof(char[1 - 2 * condition])); } while (0)
312 #else
313 # define __compiletime_error_fallback(condition) do { } while (0)
314 #endif
315
316 #define __compiletime_assert(condition, msg, prefix, suffix)            \
317         do {                                                            \
318                 bool __cond = !(condition);                             \
319                 extern void prefix ## suffix(void) __compiletime_error(msg); \
320                 if (__cond)                                             \
321                         prefix ## suffix();                             \
322                 __compiletime_error_fallback(__cond);                   \
323         } while (0)
324
325 #define _compiletime_assert(condition, msg, prefix, suffix) \
326         __compiletime_assert(condition, msg, prefix, suffix)
327
328 /**
329  * compiletime_assert - break build and emit msg if condition is false
330  * @condition: a compile-time constant condition to check
331  * @msg:       a message to emit if condition is false
332  *
333  * In tradition of POSIX assert, this macro will break the build if the
334  * supplied condition is *false*, emitting the supplied error message if the
335  * compiler has support to do so.
336  */
337 #define compiletime_assert(condition, msg) \
338         _compiletime_assert(condition, msg, __compiletime_assert_, __LINE__)
339
340 /*
341  * Prevent the compiler from merging or refetching accesses.  The compiler
342  * is also forbidden from reordering successive instances of ACCESS_ONCE(),
343  * but only when the compiler is aware of some particular ordering.  One way
344  * to make the compiler aware of ordering is to put the two invocations of
345  * ACCESS_ONCE() in different C statements.
346  *
347  * This macro does absolutely -nothing- to prevent the CPU from reordering,
348  * merging, or refetching absolutely anything at any time.  Its main intended
349  * use is to mediate communication between process-level code and irq/NMI
350  * handlers, all running on the same CPU.
351  */
352 #define ACCESS_ONCE(x) (*(volatile typeof(x) *)&(x))
353
354 #endif /* __LINUX_COMPILER_H */