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 #ifndef OPTIMIZER_HIDE_VAR 174 #define OPTIMIZER_HIDE_VAR(var) barrier() 175 #endif 176 177 /* Not-quite-unique ID. */ 178 #ifndef __UNIQUE_ID 179 # define __UNIQUE_ID(prefix) __PASTE(__PASTE(__UNIQUE_ID_, prefix), __LINE__) 180 #endif 181 182 #endif /* __KERNEL__ */ 183 184 #endif /* __ASSEMBLY__ */ 185 186 #ifdef __KERNEL__ 187 /* 188 * Allow us to mark functions as 'deprecated' and have gcc emit a nice 189 * warning for each use, in hopes of speeding the functions removal. 190 * Usage is: 191 * int __deprecated foo(void) 192 */ 193 #ifndef __deprecated 194 # define __deprecated /* unimplemented */ 195 #endif 196 197 #ifdef MODULE 198 #define __deprecated_for_modules __deprecated 199 #else 200 #define __deprecated_for_modules 201 #endif 202 203 #ifndef __must_check 204 #define __must_check 205 #endif 206 207 #ifndef CONFIG_ENABLE_MUST_CHECK 208 #undef __must_check 209 #define __must_check 210 #endif 211 #ifndef CONFIG_ENABLE_WARN_DEPRECATED 212 #undef __deprecated 213 #undef __deprecated_for_modules 214 #define __deprecated 215 #define __deprecated_for_modules 216 #endif 217 218 /* 219 * Allow us to avoid 'defined but not used' warnings on functions and data, 220 * as well as force them to be emitted to the assembly file. 221 * 222 * As of gcc 3.4, static functions that are not marked with attribute((used)) 223 * may be elided from the assembly file. As of gcc 3.4, static data not so 224 * marked will not be elided, but this may change in a future gcc version. 225 * 226 * NOTE: Because distributions shipped with a backported unit-at-a-time 227 * compiler in gcc 3.3, we must define __used to be __attribute__((used)) 228 * for gcc >=3.3 instead of 3.4. 229 * 230 * In prior versions of gcc, such functions and data would be emitted, but 231 * would be warned about except with attribute((unused)). 232 * 233 * Mark functions that are referenced only in inline assembly as __used so 234 * the code is emitted even though it appears to be unreferenced. 235 */ 236 #ifndef __used 237 # define __used /* unimplemented */ 238 #endif 239 240 #ifndef __maybe_unused 241 # define __maybe_unused /* unimplemented */ 242 #endif 243 244 #ifndef __always_unused 245 # define __always_unused /* unimplemented */ 246 #endif 247 248 #ifndef noinline 249 #define noinline 250 #endif 251 252 /* 253 * Rather then using noinline to prevent stack consumption, use 254 * noinline_for_stack instead. For documentation reasons. 255 */ 256 #define noinline_for_stack noinline 257 258 #ifndef __always_inline 259 #define __always_inline inline 260 #endif 261 262 #endif /* __KERNEL__ */ 263 264 /* 265 * From the GCC manual: 266 * 267 * Many functions do not examine any values except their arguments, 268 * and have no effects except the return value. Basically this is 269 * just slightly more strict class than the `pure' attribute above, 270 * since function is not allowed to read global memory. 271 * 272 * Note that a function that has pointer arguments and examines the 273 * data pointed to must _not_ be declared `const'. Likewise, a 274 * function that calls a non-`const' function usually must not be 275 * `const'. It does not make sense for a `const' function to return 276 * `void'. 277 */ 278 #ifndef __attribute_const__ 279 # define __attribute_const__ /* unimplemented */ 280 #endif 281 282 /* 283 * Tell gcc if a function is cold. The compiler will assume any path 284 * directly leading to the call is unlikely. 285 */ 286 287 #ifndef __cold 288 #define __cold 289 #endif 290 291 /* Simple shorthand for a section definition */ 292 #ifndef __section 293 # define __section(S) __attribute__ ((__section__(#S))) 294 #endif 295 296 #ifndef __visible 297 #define __visible 298 #endif 299 300 /* Are two types/vars the same type (ignoring qualifiers)? */ 301 #ifndef __same_type 302 # define __same_type(a, b) __builtin_types_compatible_p(typeof(a), typeof(b)) 303 #endif 304 305 /* Is this type a native word size -- useful for atomic operations */ 306 #ifndef __native_word 307 # define __native_word(t) (sizeof(t) == sizeof(int) || sizeof(t) == sizeof(long)) 308 #endif 309 310 /* Compile time object size, -1 for unknown */ 311 #ifndef __compiletime_object_size 312 # define __compiletime_object_size(obj) -1 313 #endif 314 #ifndef __compiletime_warning 315 # define __compiletime_warning(message) 316 #endif 317 #ifndef __compiletime_error 318 # define __compiletime_error(message) 319 # define __compiletime_error_fallback(condition) \ 320 do { ((void)sizeof(char[1 - 2 * condition])); } while (0) 321 #else 322 # define __compiletime_error_fallback(condition) do { } while (0) 323 #endif 324 325 #define __compiletime_assert(condition, msg, prefix, suffix) \ 326 do { \ 327 bool __cond = !(condition); \ 328 extern void prefix ## suffix(void) __compiletime_error(msg); \ 329 if (__cond) \ 330 prefix ## suffix(); \ 331 __compiletime_error_fallback(__cond); \ 332 } while (0) 333 334 #define _compiletime_assert(condition, msg, prefix, suffix) \ 335 __compiletime_assert(condition, msg, prefix, suffix) 336 337 /** 338 * compiletime_assert - break build and emit msg if condition is false 339 * @condition: a compile-time constant condition to check 340 * @msg: a message to emit if condition is false 341 * 342 * In tradition of POSIX assert, this macro will break the build if the 343 * supplied condition is *false*, emitting the supplied error message if the 344 * compiler has support to do so. 345 */ 346 #define compiletime_assert(condition, msg) \ 347 _compiletime_assert(condition, msg, __compiletime_assert_, __LINE__) 348 349 #define compiletime_assert_atomic_type(t) \ 350 compiletime_assert(__native_word(t), \ 351 "Need native word sized stores/loads for atomicity.") 352 353 /* 354 * Prevent the compiler from merging or refetching accesses. The compiler 355 * is also forbidden from reordering successive instances of ACCESS_ONCE(), 356 * but only when the compiler is aware of some particular ordering. One way 357 * to make the compiler aware of ordering is to put the two invocations of 358 * ACCESS_ONCE() in different C statements. 359 * 360 * This macro does absolutely -nothing- to prevent the CPU from reordering, 361 * merging, or refetching absolutely anything at any time. Its main intended 362 * use is to mediate communication between process-level code and irq/NMI 363 * handlers, all running on the same CPU. 364 */ 365 #define ACCESS_ONCE(x) (*(volatile typeof(x) *)&(x)) 366 367 /* Ignore/forbid kprobes attach on very low level functions marked by this attribute: */ 368 #ifdef CONFIG_KPROBES 369 # define __kprobes __attribute__((__section__(".kprobes.text"))) 370 #else 371 # define __kprobes 372 #endif 373 #endif /* __LINUX_COMPILER_H */ 374