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 #endif 311 #ifndef __linktime_error 312 # define __linktime_error(message) 313 #endif 314 /* 315 * Prevent the compiler from merging or refetching accesses. The compiler 316 * is also forbidden from reordering successive instances of ACCESS_ONCE(), 317 * but only when the compiler is aware of some particular ordering. One way 318 * to make the compiler aware of ordering is to put the two invocations of 319 * ACCESS_ONCE() in different C statements. 320 * 321 * This macro does absolutely -nothing- to prevent the CPU from reordering, 322 * merging, or refetching absolutely anything at any time. Its main intended 323 * use is to mediate communication between process-level code and irq/NMI 324 * handlers, all running on the same CPU. 325 */ 326 #define ACCESS_ONCE(x) (*(volatile typeof(x) *)&(x)) 327 328 #endif /* __LINUX_COMPILER_H */ 329