Greg Kroah-Hartman | b244131 | 2017-11-01 15:07:57 +0100 | [diff] [blame] | 1 | /* SPDX-License-Identifier: GPL-2.0 */ |
Will Deacon | d151558 | 2017-10-24 11:22:46 +0100 | [diff] [blame] | 2 | #ifndef __LINUX_COMPILER_TYPES_H |
Robert P. J. Day | 94f582f | 2007-10-16 23:26:11 -0700 | [diff] [blame] | 3 | #error "Please don't include <linux/compiler-gcc.h> directly, include <linux/compiler.h> instead." |
| 4 | #endif |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 5 | |
| 6 | /* |
| 7 | * Common definitions for all gcc versions go here. |
| 8 | */ |
Joe Perches | f6d133f8 | 2015-06-25 15:01:00 -0700 | [diff] [blame] | 9 | #define GCC_VERSION (__GNUC__ * 10000 \ |
| 10 | + __GNUC_MINOR__ * 100 \ |
| 11 | + __GNUC_PATCHLEVEL__) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 12 | |
Joe Perches | cafa001 | 2018-08-20 13:15:26 -0700 | [diff] [blame^] | 13 | #if GCC_VERSION < 40600 |
| 14 | # error Sorry, your compiler is too old - please upgrade it. |
| 15 | #endif |
| 16 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 17 | /* Optimization barrier */ |
Daniel Borkmann | 7829fb0 | 2015-04-30 04:13:52 +0200 | [diff] [blame] | 18 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 19 | /* The "volatile" is due to gcc bugs */ |
| 20 | #define barrier() __asm__ __volatile__("": : :"memory") |
Daniel Borkmann | 7829fb0 | 2015-04-30 04:13:52 +0200 | [diff] [blame] | 21 | /* |
| 22 | * This version is i.e. to prevent dead stores elimination on @ptr |
| 23 | * where gcc and llvm may behave differently when otherwise using |
| 24 | * normal barrier(): while gcc behavior gets along with a normal |
| 25 | * barrier(), llvm needs an explicit input variable to be assumed |
| 26 | * clobbered. The issue is as follows: while the inline asm might |
| 27 | * access any memory it wants, the compiler could have fit all of |
| 28 | * @ptr into memory registers instead, and since @ptr never escaped |
Benjamin Peterson | 8e8780a | 2016-12-12 16:45:38 -0800 | [diff] [blame] | 29 | * from that, it proved that the inline asm wasn't touching any of |
Daniel Borkmann | 7829fb0 | 2015-04-30 04:13:52 +0200 | [diff] [blame] | 30 | * it. This version works well with both compilers, i.e. we're telling |
| 31 | * the compiler that the inline asm absolutely may see the contents |
| 32 | * of @ptr. See also: https://llvm.org/bugs/show_bug.cgi?id=15495 |
| 33 | */ |
| 34 | #define barrier_data(ptr) __asm__ __volatile__("": :"r"(ptr) :"memory") |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 35 | |
Anton Blanchard | c8d5246 | 2006-01-10 18:21:20 +1100 | [diff] [blame] | 36 | /* |
Andi Kleen | 85c210e | 2009-01-09 16:40:53 -0800 | [diff] [blame] | 37 | * This macro obfuscates arithmetic on a variable address so that gcc |
| 38 | * shouldn't recognize the original var, and make assumptions about it. |
| 39 | * |
| 40 | * This is needed because the C standard makes it undefined to do |
| 41 | * pointer arithmetic on "objects" outside their boundaries and the |
| 42 | * gcc optimizers assume this is the case. In particular they |
| 43 | * assume such arithmetic does not wrap. |
| 44 | * |
| 45 | * A miscompilation has been observed because of this on PPC. |
| 46 | * To work around it we hide the relationship of the pointer and the object |
| 47 | * using this macro. |
| 48 | * |
Anton Blanchard | c8d5246 | 2006-01-10 18:21:20 +1100 | [diff] [blame] | 49 | * Versions of the ppc64 compiler before 4.1 had a bug where use of |
| 50 | * RELOC_HIDE could trash r30. The bug can be worked around by changing |
| 51 | * the inline assembly constraint from =g to =r, in this particular |
| 52 | * case either is valid. |
| 53 | */ |
Joe Perches | f6d133f8 | 2015-06-25 15:01:00 -0700 | [diff] [blame] | 54 | #define RELOC_HIDE(ptr, off) \ |
| 55 | ({ \ |
| 56 | unsigned long __ptr; \ |
| 57 | __asm__ ("" : "=r"(__ptr) : "0"(ptr)); \ |
| 58 | (typeof(ptr)) (__ptr + (off)); \ |
| 59 | }) |
Andrew Morton | a136564 | 2006-01-08 01:04:09 -0800 | [diff] [blame] | 60 | |
Cesar Eduardo Barros | fe8c8a1 | 2013-11-25 22:00:41 -0200 | [diff] [blame] | 61 | /* Make the optimizer believe the variable can be manipulated arbitrarily. */ |
Joe Perches | f6d133f8 | 2015-06-25 15:01:00 -0700 | [diff] [blame] | 62 | #define OPTIMIZER_HIDE_VAR(var) \ |
| 63 | __asm__ ("" : "=r" (var) : "0" (var)) |
Cesar Eduardo Barros | fe8c8a1 | 2013-11-25 22:00:41 -0200 | [diff] [blame] | 64 | |
Joe Perches | cafa001 | 2018-08-20 13:15:26 -0700 | [diff] [blame^] | 65 | /* |
| 66 | * A trick to suppress uninitialized variable warning without generating any |
| 67 | * code |
| 68 | */ |
| 69 | #define uninitialized_var(x) x = x |
| 70 | |
KOSAKI Motohiro | 5bd7e6a | 2011-05-24 17:13:17 -0700 | [diff] [blame] | 71 | #ifdef __CHECKER__ |
Joe Perches | f6d133f8 | 2015-06-25 15:01:00 -0700 | [diff] [blame] | 72 | #define __must_be_array(a) 0 |
KOSAKI Motohiro | 5bd7e6a | 2011-05-24 17:13:17 -0700 | [diff] [blame] | 73 | #else |
Rusty Russell | c5e631cf | 2007-05-06 14:51:05 -0700 | [diff] [blame] | 74 | /* &a[0] degrades to a pointer: a different type from an array */ |
Joe Perches | f6d133f8 | 2015-06-25 15:01:00 -0700 | [diff] [blame] | 75 | #define __must_be_array(a) BUILD_BUG_ON_ZERO(__same_type((a), &(a)[0])) |
KOSAKI Motohiro | 5bd7e6a | 2011-05-24 17:13:17 -0700 | [diff] [blame] | 76 | #endif |
Andrew Morton | a136564 | 2006-01-08 01:04:09 -0800 | [diff] [blame] | 77 | |
Ingo Molnar | 60a3cdd | 2008-03-03 12:38:52 +0100 | [diff] [blame] | 78 | /* |
Nick Desaulniers | d03db2b | 2018-06-21 09:23:22 -0700 | [diff] [blame] | 79 | * Feature detection for gnu_inline (gnu89 extern inline semantics). Either |
| 80 | * __GNUC_STDC_INLINE__ is defined (not using gnu89 extern inline semantics, |
| 81 | * and we opt in to the gnu89 semantics), or __GNUC_STDC_INLINE__ is not |
| 82 | * defined so the gnu89 semantics are the default. |
| 83 | */ |
| 84 | #ifdef __GNUC_STDC_INLINE__ |
| 85 | # define __gnu_inline __attribute__((gnu_inline)) |
| 86 | #else |
| 87 | # define __gnu_inline |
| 88 | #endif |
| 89 | |
| 90 | /* |
Ingo Molnar | ae3a006 | 2008-04-30 00:15:31 +0200 | [diff] [blame] | 91 | * Force always-inline if the user requests it so via the .config, |
David Rientjes | 9a04dbc | 2017-07-06 15:35:24 -0700 | [diff] [blame] | 92 | * or if gcc is too old. |
| 93 | * GCC does not warn about unused static inline functions for |
| 94 | * -Wunused-function. This turns out to avoid the need for complex #ifdef |
| 95 | * directives. Suppress the warning in clang as well by using "unused" |
| 96 | * function attribute, which is redundant but not harmful for gcc. |
Nick Desaulniers | d03db2b | 2018-06-21 09:23:22 -0700 | [diff] [blame] | 97 | * Prefer gnu_inline, so that extern inline functions do not emit an |
| 98 | * externally visible function. This makes extern inline behave as per gnu89 |
| 99 | * semantics rather than c99. This prevents multiple symbol definition errors |
| 100 | * of extern inline functions at link time. |
| 101 | * A lot of inline functions can cause havoc with function tracing. |
Ingo Molnar | 60a3cdd | 2008-03-03 12:38:52 +0100 | [diff] [blame] | 102 | */ |
Joe Perches | f6d133f8 | 2015-06-25 15:01:00 -0700 | [diff] [blame] | 103 | #if !defined(CONFIG_ARCH_SUPPORTS_OPTIMIZED_INLINING) || \ |
Joe Perches | cafa001 | 2018-08-20 13:15:26 -0700 | [diff] [blame^] | 104 | !defined(CONFIG_OPTIMIZE_INLINING) |
Nick Desaulniers | d03db2b | 2018-06-21 09:23:22 -0700 | [diff] [blame] | 105 | #define inline \ |
| 106 | inline __attribute__((always_inline, unused)) notrace __gnu_inline |
Steven Rostedt | 45959ee | 2011-12-12 15:22:41 -0500 | [diff] [blame] | 107 | #else |
Nick Desaulniers | d03db2b | 2018-06-21 09:23:22 -0700 | [diff] [blame] | 108 | #define inline inline __attribute__((unused)) notrace __gnu_inline |
Ingo Molnar | 60a3cdd | 2008-03-03 12:38:52 +0100 | [diff] [blame] | 109 | #endif |
| 110 | |
Nick Desaulniers | d03db2b | 2018-06-21 09:23:22 -0700 | [diff] [blame] | 111 | #define __inline__ inline |
| 112 | #define __inline inline |
Joe Perches | f6d133f8 | 2015-06-25 15:01:00 -0700 | [diff] [blame] | 113 | #define __always_inline inline __attribute__((always_inline)) |
| 114 | #define noinline __attribute__((noinline)) |
| 115 | |
Joe Perches | f6d133f8 | 2015-06-25 15:01:00 -0700 | [diff] [blame] | 116 | #define __packed __attribute__((packed)) |
| 117 | #define __weak __attribute__((weak)) |
| 118 | #define __alias(symbol) __attribute__((alias(#symbol))) |
Uwe Kleine-König | 446c92b | 2009-03-12 18:03:16 +0100 | [diff] [blame] | 119 | |
David Woodhouse | 8735871 | 2018-02-19 10:50:57 +0000 | [diff] [blame] | 120 | #ifdef RETPOLINE |
| 121 | #define __noretpoline __attribute__((indirect_branch("keep"))) |
| 122 | #endif |
| 123 | |
Uwe Kleine-König | 446c92b | 2009-03-12 18:03:16 +0100 | [diff] [blame] | 124 | /* |
Joe Perches | f6d133f8 | 2015-06-25 15:01:00 -0700 | [diff] [blame] | 125 | * it doesn't make sense on ARM (currently the only user of __naked) |
| 126 | * to trace naked functions because then mcount is called without |
| 127 | * stack and frame pointer being set up and there is no chance to |
| 128 | * restore the lr register to the value before mcount was called. |
Mikael Pettersson | 9c69520 | 2010-06-29 15:05:25 -0700 | [diff] [blame] | 129 | * |
Joe Perches | f6d133f8 | 2015-06-25 15:01:00 -0700 | [diff] [blame] | 130 | * The asm() bodies of naked functions often depend on standard calling |
| 131 | * conventions, therefore they must be noinline and noclone. |
| 132 | * |
| 133 | * GCC 4.[56] currently fail to enforce this, so we must do so ourselves. |
| 134 | * See GCC PR44290. |
Uwe Kleine-König | 446c92b | 2009-03-12 18:03:16 +0100 | [diff] [blame] | 135 | */ |
Joe Perches | f6d133f8 | 2015-06-25 15:01:00 -0700 | [diff] [blame] | 136 | #define __naked __attribute__((naked)) noinline __noclone notrace |
Uwe Kleine-König | 446c92b | 2009-03-12 18:03:16 +0100 | [diff] [blame] | 137 | |
Joe Perches | f6d133f8 | 2015-06-25 15:01:00 -0700 | [diff] [blame] | 138 | #define __noreturn __attribute__((noreturn)) |
Ralf Baechle | e8c4431 | 2007-10-18 03:07:07 -0700 | [diff] [blame] | 139 | |
| 140 | /* |
| 141 | * From the GCC manual: |
| 142 | * |
| 143 | * Many functions have no effects except the return value and their |
| 144 | * return value depends only on the parameters and/or global |
| 145 | * variables. Such a function can be subject to common subexpression |
| 146 | * elimination and loop optimization just as an arithmetic operator |
| 147 | * would be. |
| 148 | * [...] |
| 149 | */ |
Joe Perches | f6d133f8 | 2015-06-25 15:01:00 -0700 | [diff] [blame] | 150 | #define __pure __attribute__((pure)) |
| 151 | #define __aligned(x) __attribute__((aligned(x))) |
Gideon Israel Dsouza | d8c34b9 | 2016-12-31 21:26:23 +0530 | [diff] [blame] | 152 | #define __aligned_largest __attribute__((aligned)) |
Joe Perches | f6d133f8 | 2015-06-25 15:01:00 -0700 | [diff] [blame] | 153 | #define __printf(a, b) __attribute__((format(printf, a, b))) |
| 154 | #define __scanf(a, b) __attribute__((format(scanf, a, b))) |
| 155 | #define __attribute_const__ __attribute__((__const__)) |
| 156 | #define __maybe_unused __attribute__((unused)) |
| 157 | #define __always_unused __attribute__((unused)) |
Gideon Israel Dsouza | a3f0825 | 2017-02-24 15:00:32 -0800 | [diff] [blame] | 158 | #define __mode(x) __attribute__((mode(x))) |
Linus Torvalds | f153b82 | 2009-01-02 09:23:03 -0800 | [diff] [blame] | 159 | |
Joe Perches | cb984d1 | 2015-06-25 15:01:02 -0700 | [diff] [blame] | 160 | #define __must_check __attribute__((warn_unused_result)) |
Rasmus Villemoes | d64e85d | 2016-05-19 17:10:52 -0700 | [diff] [blame] | 161 | #define __malloc __attribute__((__malloc__)) |
Joe Perches | cb984d1 | 2015-06-25 15:01:02 -0700 | [diff] [blame] | 162 | |
| 163 | #define __used __attribute__((__used__)) |
| 164 | #define __compiler_offsetof(a, b) \ |
| 165 | __builtin_offsetof(a, b) |
| 166 | |
Joe Perches | cb984d1 | 2015-06-25 15:01:02 -0700 | [diff] [blame] | 167 | /* Mark functions as cold. gcc will assume any path leading to a call |
| 168 | * to them will be unlikely. This means a lot of manual unlikely()s |
| 169 | * are unnecessary now for any paths leading to the usual suspects |
| 170 | * like BUG(), printk(), panic() etc. [but let's keep them for now for |
| 171 | * older compilers] |
| 172 | * |
| 173 | * Early snapshots of gcc 4.3 don't support this and we can't detect this |
| 174 | * in the preprocessor, but we can live with this because they're unreleased. |
| 175 | * Maketime probing would be overkill here. |
| 176 | * |
| 177 | * gcc also has a __attribute__((__hot__)) to move hot functions into |
| 178 | * a special section, but I don't see any sense in this right now in |
| 179 | * the kernel context |
| 180 | */ |
| 181 | #define __cold __attribute__((__cold__)) |
| 182 | |
| 183 | #define __UNIQUE_ID(prefix) __PASTE(__PASTE(__UNIQUE_ID_, prefix), __COUNTER__) |
| 184 | |
Geert Uytterhoeven | df5d45a | 2018-02-01 11:21:58 +0100 | [diff] [blame] | 185 | #define __optimize(level) __attribute__((__optimize__(level))) |
Geert Uytterhoeven | d9afaaa | 2018-02-01 11:21:59 +0100 | [diff] [blame] | 186 | #define __nostackprotector __optimize("no-stack-protector") |
Geert Uytterhoeven | df5d45a | 2018-02-01 11:21:58 +0100 | [diff] [blame] | 187 | |
Joe Perches | cafa001 | 2018-08-20 13:15:26 -0700 | [diff] [blame^] | 188 | #define __compiletime_object_size(obj) __builtin_object_size(obj, 0) |
Emese Revfy | 0766f78 | 2016-06-20 20:42:34 +0200 | [diff] [blame] | 189 | |
| 190 | #ifndef __CHECKER__ |
Joe Perches | cafa001 | 2018-08-20 13:15:26 -0700 | [diff] [blame^] | 191 | #define __compiletime_warning(message) __attribute__((warning(message))) |
| 192 | #define __compiletime_error(message) __attribute__((error(message))) |
| 193 | |
Emese Revfy | 0766f78 | 2016-06-20 20:42:34 +0200 | [diff] [blame] | 194 | #ifdef LATENT_ENTROPY_PLUGIN |
| 195 | #define __latent_entropy __attribute__((latent_entropy)) |
| 196 | #endif |
Joe Perches | cafa001 | 2018-08-20 13:15:26 -0700 | [diff] [blame^] | 197 | #endif /* __CHECKER__ */ |
Emese Revfy | 0766f78 | 2016-06-20 20:42:34 +0200 | [diff] [blame] | 198 | |
Joe Perches | cb984d1 | 2015-06-25 15:01:02 -0700 | [diff] [blame] | 199 | /* |
Arnd Bergmann | 173a3ef | 2018-02-21 14:45:54 -0800 | [diff] [blame] | 200 | * calling noreturn functions, __builtin_unreachable() and __builtin_trap() |
| 201 | * confuse the stack allocation in gcc, leading to overly large stack |
| 202 | * frames, see https://gcc.gnu.org/bugzilla/show_bug.cgi?id=82365 |
| 203 | * |
| 204 | * Adding an empty inline assembly before it works around the problem |
| 205 | */ |
| 206 | #define barrier_before_unreachable() asm volatile("") |
| 207 | |
| 208 | /* |
Joe Perches | cb984d1 | 2015-06-25 15:01:02 -0700 | [diff] [blame] | 209 | * Mark a position in code as unreachable. This can be used to |
| 210 | * suppress control flow warnings after asm blocks that transfer |
| 211 | * control elsewhere. |
| 212 | * |
| 213 | * Early snapshots of gcc 4.5 don't support this and we can't detect |
| 214 | * this in the preprocessor, but we can live with this because they're |
| 215 | * unreleased. Really, we need to have autoconf for the kernel. |
| 216 | */ |
Josh Poimboeuf | 4e4636c | 2017-02-27 22:21:16 -0600 | [diff] [blame] | 217 | #define unreachable() \ |
Arnd Bergmann | 173a3ef | 2018-02-21 14:45:54 -0800 | [diff] [blame] | 218 | do { \ |
| 219 | annotate_unreachable(); \ |
| 220 | barrier_before_unreachable(); \ |
| 221 | __builtin_unreachable(); \ |
| 222 | } while (0) |
Joe Perches | cb984d1 | 2015-06-25 15:01:02 -0700 | [diff] [blame] | 223 | |
| 224 | /* Mark a function definition as prohibited from being cloned. */ |
Paolo Bonzini | 95272c2 | 2016-03-31 09:38:51 +0200 | [diff] [blame] | 225 | #define __noclone __attribute__((__noclone__, __optimize__("no-tracer"))) |
Joe Perches | cb984d1 | 2015-06-25 15:01:02 -0700 | [diff] [blame] | 226 | |
Matthew Wilcox | a3d6c97 | 2018-01-18 16:34:08 -0800 | [diff] [blame] | 227 | #if defined(RANDSTRUCT_PLUGIN) && !defined(__CHECKER__) |
Kees Cook | 313dd1b6 | 2017-05-05 23:37:45 -0700 | [diff] [blame] | 228 | #define __randomize_layout __attribute__((randomize_layout)) |
| 229 | #define __no_randomize_layout __attribute__((no_randomize_layout)) |
Kees Cook | 2cfe0d3 | 2018-04-10 16:32:44 -0700 | [diff] [blame] | 230 | /* This anon struct can add padding, so only enable it under randstruct. */ |
| 231 | #define randomized_struct_fields_start struct { |
| 232 | #define randomized_struct_fields_end } __randomize_layout; |
Kees Cook | 313dd1b6 | 2017-05-05 23:37:45 -0700 | [diff] [blame] | 233 | #endif |
| 234 | |
Joe Perches | cb984d1 | 2015-06-25 15:01:02 -0700 | [diff] [blame] | 235 | /* |
Andrew Morton | 9add850 | 2015-11-06 16:30:09 -0800 | [diff] [blame] | 236 | * When used with Link Time Optimization, gcc can optimize away C functions or |
| 237 | * variables which are referenced only from assembly code. __visible tells the |
| 238 | * optimizer that something else uses this function or variable, thus preventing |
| 239 | * this. |
Joe Perches | cb984d1 | 2015-06-25 15:01:02 -0700 | [diff] [blame] | 240 | */ |
| 241 | #define __visible __attribute__((externally_visible)) |
Kees Cook | 29e48ce | 2017-04-05 22:43:33 -0700 | [diff] [blame] | 242 | |
Joe Perches | cafa001 | 2018-08-20 13:15:26 -0700 | [diff] [blame^] | 243 | /* gcc version specific checks */ |
Rasmus Villemoes | a744fd1 | 2015-11-05 18:45:02 -0800 | [diff] [blame] | 244 | |
Rasmus Villemoes | 8748dd5 | 2015-11-05 18:45:05 -0800 | [diff] [blame] | 245 | #if GCC_VERSION >= 40900 && !defined(__CHECKER__) |
Rasmus Villemoes | a744fd1 | 2015-11-05 18:45:02 -0800 | [diff] [blame] | 246 | /* |
| 247 | * __assume_aligned(n, k): Tell the optimizer that the returned |
| 248 | * pointer can be assumed to be k modulo n. The second argument is |
| 249 | * optional (default 0), so we use a variadic macro to make the |
| 250 | * shorthand. |
| 251 | * |
| 252 | * Beware: Do not apply this to functions which may return |
| 253 | * ERR_PTRs. Also, it is probably unwise to apply it to functions |
| 254 | * returning extra information in the low bits (but in that case the |
| 255 | * compiler should see some alignment anyway, when the return value is |
| 256 | * massaged by 'flags = ptr & 3; ptr &= ~3;'). |
| 257 | */ |
| 258 | #define __assume_aligned(a, ...) __attribute__((__assume_aligned__(a, ## __VA_ARGS__))) |
| 259 | #endif |
| 260 | |
Joe Perches | cb984d1 | 2015-06-25 15:01:02 -0700 | [diff] [blame] | 261 | /* |
| 262 | * GCC 'asm goto' miscompiles certain code sequences: |
| 263 | * |
| 264 | * http://gcc.gnu.org/bugzilla/show_bug.cgi?id=58670 |
| 265 | * |
| 266 | * Work it around via a compiler barrier quirk suggested by Jakub Jelinek. |
| 267 | * |
| 268 | * (asm goto is automatically volatile - the naming reflects this.) |
| 269 | */ |
| 270 | #define asm_volatile_goto(x...) do { asm goto(x); asm (""); } while (0) |
| 271 | |
Johannes Berg | 101b29a | 2016-08-25 15:16:45 -0700 | [diff] [blame] | 272 | /* |
| 273 | * sparse (__CHECKER__) pretends to be gcc, but can't do constant |
| 274 | * folding in __builtin_bswap*() (yet), so don't set these for it. |
| 275 | */ |
| 276 | #if defined(CONFIG_ARCH_USE_BUILTIN_BSWAP) && !defined(__CHECKER__) |
Joe Perches | cb984d1 | 2015-06-25 15:01:02 -0700 | [diff] [blame] | 277 | #define __HAVE_BUILTIN_BSWAP32__ |
| 278 | #define __HAVE_BUILTIN_BSWAP64__ |
Josh Poimboeuf | 8634de6 | 2016-05-06 09:22:25 -0500 | [diff] [blame] | 279 | #if GCC_VERSION >= 40800 |
Joe Perches | cb984d1 | 2015-06-25 15:01:02 -0700 | [diff] [blame] | 280 | #define __HAVE_BUILTIN_BSWAP16__ |
| 281 | #endif |
Johannes Berg | 101b29a | 2016-08-25 15:16:45 -0700 | [diff] [blame] | 282 | #endif /* CONFIG_ARCH_USE_BUILTIN_BSWAP && !__CHECKER__ */ |
Joe Perches | cb984d1 | 2015-06-25 15:01:02 -0700 | [diff] [blame] | 283 | |
Dmitry Vyukov | 045d599 | 2016-11-30 15:54:13 -0800 | [diff] [blame] | 284 | #if GCC_VERSION >= 70000 |
| 285 | #define KASAN_ABI_VERSION 5 |
| 286 | #elif GCC_VERSION >= 50000 |
Joe Perches | cb984d1 | 2015-06-25 15:01:02 -0700 | [diff] [blame] | 287 | #define KASAN_ABI_VERSION 4 |
| 288 | #elif GCC_VERSION >= 40902 |
| 289 | #define KASAN_ABI_VERSION 3 |
| 290 | #endif |
| 291 | |
Andrey Ryabinin | d976441 | 2015-10-19 11:37:17 +0300 | [diff] [blame] | 292 | #if GCC_VERSION >= 40902 |
| 293 | /* |
| 294 | * Tell the compiler that address safety instrumentation (KASAN) |
| 295 | * should not be applied to that function. |
| 296 | * Conflicts with inlining: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=67368 |
| 297 | */ |
| 298 | #define __no_sanitize_address __attribute__((no_sanitize_address)) |
| 299 | #endif |
| 300 | |
Kees Cook | 0aa5e49 | 2017-04-05 09:49:19 -0700 | [diff] [blame] | 301 | #if GCC_VERSION >= 50100 |
| 302 | /* |
| 303 | * Mark structures as requiring designated initializers. |
| 304 | * https://gcc.gnu.org/onlinedocs/gcc/Designated-Inits.html |
| 305 | */ |
| 306 | #define __designated_init __attribute__((designated_init)) |
Joe Perches | cafa001 | 2018-08-20 13:15:26 -0700 | [diff] [blame^] | 307 | #define COMPILER_HAS_GENERIC_BUILTIN_OVERFLOW 1 |
Kees Cook | 0aa5e49 | 2017-04-05 09:49:19 -0700 | [diff] [blame] | 308 | #endif |
| 309 | |
Mikael Pettersson | 9c69520 | 2010-06-29 15:05:25 -0700 | [diff] [blame] | 310 | #if !defined(__noclone) |
| 311 | #define __noclone /* not needed */ |
| 312 | #endif |
Borislav Petkov | c837fb3 | 2011-03-22 16:33:55 -0700 | [diff] [blame] | 313 | |
Andrey Ryabinin | d976441 | 2015-10-19 11:37:17 +0300 | [diff] [blame] | 314 | #if !defined(__no_sanitize_address) |
| 315 | #define __no_sanitize_address |
| 316 | #endif |
| 317 | |
Borislav Petkov | c837fb3 | 2011-03-22 16:33:55 -0700 | [diff] [blame] | 318 | /* |
Arnd Bergmann | 8793bb7 | 2018-06-19 13:14:56 -0700 | [diff] [blame] | 319 | * Turn individual warnings and errors on and off locally, depending |
| 320 | * on version. |
| 321 | */ |
| 322 | #define __diag_GCC(version, severity, s) \ |
| 323 | __diag_GCC_ ## version(__diag_GCC_ ## severity s) |
| 324 | |
| 325 | /* Severity used in pragma directives */ |
| 326 | #define __diag_GCC_ignore ignored |
| 327 | #define __diag_GCC_warn warning |
| 328 | #define __diag_GCC_error error |
| 329 | |
Arnd Bergmann | 8793bb7 | 2018-06-19 13:14:56 -0700 | [diff] [blame] | 330 | #define __diag_str1(s) #s |
| 331 | #define __diag_str(s) __diag_str1(s) |
| 332 | #define __diag(s) _Pragma(__diag_str(GCC diagnostic s)) |
Arnd Bergmann | 8793bb7 | 2018-06-19 13:14:56 -0700 | [diff] [blame] | 333 | |
| 334 | #if GCC_VERSION >= 80000 |
| 335 | #define __diag_GCC_8(s) __diag(s) |
| 336 | #else |
| 337 | #define __diag_GCC_8(s) |
| 338 | #endif |