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