Green shading in the line number column means the source is part of the translation unit, red means it is conditionally excluded. Highlighted line numbers link to the translation unit page. Highlighted macros link to the macro page.
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: /* Ignore/forbid kprobes attach on very low level functions marked by this attribute: */ 355: #ifdef CONFIG_KPROBES 356: # define __kprobes __attribute__((__section__(".kprobes.text"))) 357: #else 358: # define __kprobes 359: #endif 360: #endif /* __LINUX_COMPILER_H */ 361: