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