1 #ifndef __LINUX_COMPILER_TYPES_H 2 #define __LINUX_COMPILER_TYPES_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 # define __rcu __attribute__((noderef, address_space(4))) 21 # define __private __attribute__((noderef)) 22 extern void __chk_user_ptr(const volatile void __user *); 23 extern void __chk_io_ptr(const volatile void __iomem *); 24 # define ACCESS_PRIVATE(p, member) (*((typeof((p)->member) __force *) &(p)->member)) 25 #else /* __CHECKER__ */ 26 # ifdef STRUCTLEAK_PLUGIN 27 # define __user __attribute__((user)) 28 # else 29 # define __user 30 # endif 31 # define __kernel 32 # define __safe 33 # define __force 34 # define __nocast 35 # define __iomem 36 # define __chk_user_ptr(x) (void)0 37 # define __chk_io_ptr(x) (void)0 38 # define __builtin_warning(x, y...) (1) 39 # define __must_hold(x) 40 # define __acquires(x) 41 # define __releases(x) 42 # define __acquire(x) (void)0 43 # define __release(x) (void)0 44 # define __cond_lock(x,c) (c) 45 # define __percpu 46 # define __rcu 47 # define __private 48 # define ACCESS_PRIVATE(p, member) ((p)->member) 49 #endif /* __CHECKER__ */ 50 51 /* Indirect macros required for expanded argument pasting, eg. __LINE__. */ 52 #define ___PASTE(a,b) a##b 53 #define __PASTE(a,b) ___PASTE(a,b) 54 55 #ifdef __KERNEL__ 56 57 #ifdef __GNUC__ 58 #include <linux/compiler-gcc.h> 59 #endif 60 61 #if defined(CC_USING_HOTPATCH) && !defined(__CHECKER__) 62 #define notrace __attribute__((hotpatch(0,0))) 63 #else 64 #define notrace __attribute__((no_instrument_function)) 65 #endif 66 67 /* Intel compiler defines __GNUC__. So we will overwrite implementations 68 * coming from above header files here 69 */ 70 #ifdef __INTEL_COMPILER 71 # include <linux/compiler-intel.h> 72 #endif 73 74 /* Clang compiler defines __GNUC__. So we will overwrite implementations 75 * coming from above header files here 76 */ 77 #ifdef __clang__ 78 #include <linux/compiler-clang.h> 79 #endif 80 81 /* 82 * Generic compiler-dependent macros required for kernel 83 * build go below this comment. Actual compiler/compiler version 84 * specific implementations come from the above header files 85 */ 86 87 struct ftrace_branch_data { 88 const char *func; 89 const char *file; 90 unsigned line; 91 union { 92 struct { 93 unsigned long correct; 94 unsigned long incorrect; 95 }; 96 struct { 97 unsigned long miss; 98 unsigned long hit; 99 }; 100 unsigned long miss_hit[2]; 101 }; 102 }; 103 104 struct ftrace_likely_data { 105 struct ftrace_branch_data data; 106 unsigned long constant; 107 }; 108 109 #endif /* __KERNEL__ */ 110 111 #endif /* __ASSEMBLY__ */ 112 113 #ifdef __KERNEL__ 114 /* 115 * Allow us to mark functions as 'deprecated' and have gcc emit a nice 116 * warning for each use, in hopes of speeding the functions removal. 117 * Usage is: 118 * int __deprecated foo(void) 119 */ 120 #ifndef __deprecated 121 # define __deprecated /* unimplemented */ 122 #endif 123 124 #ifdef MODULE 125 #define __deprecated_for_modules __deprecated 126 #else 127 #define __deprecated_for_modules 128 #endif 129 130 #ifndef __must_check 131 #define __must_check 132 #endif 133 134 #ifndef CONFIG_ENABLE_MUST_CHECK 135 #undef __must_check 136 #define __must_check 137 #endif 138 #ifndef CONFIG_ENABLE_WARN_DEPRECATED 139 #undef __deprecated 140 #undef __deprecated_for_modules 141 #define __deprecated 142 #define __deprecated_for_modules 143 #endif 144 145 #ifndef __malloc 146 #define __malloc 147 #endif 148 149 /* 150 * Allow us to avoid 'defined but not used' warnings on functions and data, 151 * as well as force them to be emitted to the assembly file. 152 * 153 * As of gcc 3.4, static functions that are not marked with attribute((used)) 154 * may be elided from the assembly file. As of gcc 3.4, static data not so 155 * marked will not be elided, but this may change in a future gcc version. 156 * 157 * NOTE: Because distributions shipped with a backported unit-at-a-time 158 * compiler in gcc 3.3, we must define __used to be __attribute__((used)) 159 * for gcc >=3.3 instead of 3.4. 160 * 161 * In prior versions of gcc, such functions and data would be emitted, but 162 * would be warned about except with attribute((unused)). 163 * 164 * Mark functions that are referenced only in inline assembly as __used so 165 * the code is emitted even though it appears to be unreferenced. 166 */ 167 #ifndef __used 168 # define __used /* unimplemented */ 169 #endif 170 171 #ifndef __maybe_unused 172 # define __maybe_unused /* unimplemented */ 173 #endif 174 175 #ifndef __always_unused 176 # define __always_unused /* unimplemented */ 177 #endif 178 179 #ifndef noinline 180 #define noinline 181 #endif 182 183 /* 184 * Rather then using noinline to prevent stack consumption, use 185 * noinline_for_stack instead. For documentation reasons. 186 */ 187 #define noinline_for_stack noinline 188 189 #ifndef __always_inline 190 #define __always_inline inline 191 #endif 192 193 #endif /* __KERNEL__ */ 194 195 /* 196 * From the GCC manual: 197 * 198 * Many functions do not examine any values except their arguments, 199 * and have no effects except the return value. Basically this is 200 * just slightly more strict class than the `pure' attribute above, 201 * since function is not allowed to read global memory. 202 * 203 * Note that a function that has pointer arguments and examines the 204 * data pointed to must _not_ be declared `const'. Likewise, a 205 * function that calls a non-`const' function usually must not be 206 * `const'. It does not make sense for a `const' function to return 207 * `void'. 208 */ 209 #ifndef __attribute_const__ 210 # define __attribute_const__ /* unimplemented */ 211 #endif 212 213 #ifndef __designated_init 214 # define __designated_init 215 #endif 216 217 #ifndef __latent_entropy 218 # define __latent_entropy 219 #endif 220 221 #ifndef __randomize_layout 222 # define __randomize_layout __designated_init 223 #endif 224 225 #ifndef __no_randomize_layout 226 # define __no_randomize_layout 227 #endif 228 229 #ifndef randomized_struct_fields_start 230 # define randomized_struct_fields_start 231 # define randomized_struct_fields_end 232 #endif 233 234 /* 235 * Tell gcc if a function is cold. The compiler will assume any path 236 * directly leading to the call is unlikely. 237 */ 238 239 #ifndef __cold 240 #define __cold 241 #endif 242 243 /* Simple shorthand for a section definition */ 244 #ifndef __section 245 # define __section(S) __attribute__ ((__section__(#S))) 246 #endif 247 248 #ifndef __visible 249 #define __visible 250 #endif 251 252 #ifndef __nostackprotector 253 # define __nostackprotector 254 #endif 255 256 /* 257 * Assume alignment of return value. 258 */ 259 #ifndef __assume_aligned 260 #define __assume_aligned(a, ...) 261 #endif 262 263 264 /* Are two types/vars the same type (ignoring qualifiers)? */ 265 #ifndef __same_type 266 # define __same_type(a, b) __builtin_types_compatible_p(typeof(a), typeof(b)) 267 #endif 268 269 /* Is this type a native word size -- useful for atomic operations */ 270 #ifndef __native_word 271 # define __native_word(t) (sizeof(t) == sizeof(char) || sizeof(t) == sizeof(short) || sizeof(t) == sizeof(int) || sizeof(t) == sizeof(long)) 272 #endif 273 274 #endif /* __LINUX_COMPILER_TYPES_H */ 275