package/boot/uboot-oxnas/patches/420-gcc-7-compiler.patch

   1 --- /dev/null
   2 +++ b/include/linux/compiler-gcc7.h
   3 @@ -0,0 +1,284 @@
   4 +#ifndef __LINUX_COMPILER_H
   5 +#error "Please don't include <linux/compiler-gcc.h> directly, include <linux/compiler.h> instead."
   6 +#endif
   7 +
   8 +/*
   9 + * Common definitions for all gcc versions go here.
  10 + */
  11 +#define GCC_VERSION (__GNUC__ * 10000          \
  12 +                    + __GNUC_MINOR__ * 100     \
  13 +                    + __GNUC_PATCHLEVEL__)
  14 +
  15 +/* Optimization barrier */
  16 +
  17 +/* The "volatile" is due to gcc bugs */
  18 +#define barrier() __asm__ __volatile__("": : :"memory")
  19 +/*
  20 + * This version is i.e. to prevent dead stores elimination on @ptr
  21 + * where gcc and llvm may behave differently when otherwise using
  22 + * normal barrier(): while gcc behavior gets along with a normal
  23 + * barrier(), llvm needs an explicit input variable to be assumed
  24 + * clobbered. The issue is as follows: while the inline asm might
  25 + * access any memory it wants, the compiler could have fit all of
  26 + * @ptr into memory registers instead, and since @ptr never escaped
  27 + * from that, it proofed that the inline asm wasn't touching any of
  28 + * it. This version works well with both compilers, i.e. we're telling
  29 + * the compiler that the inline asm absolutely may see the contents
  30 + * of @ptr. See also: https://llvm.org/bugs/show_bug.cgi?id=15495
  31 + */
  32 +#define barrier_data(ptr) __asm__ __volatile__("": :"r"(ptr) :"memory")
  33 +
  34 +/*
  35 + * This macro obfuscates arithmetic on a variable address so that gcc
  36 + * shouldn't recognize the original var, and make assumptions about it.
  37 + *
  38 + * This is needed because the C standard makes it undefined to do
  39 + * pointer arithmetic on "objects" outside their boundaries and the
  40 + * gcc optimizers assume this is the case. In particular they
  41 + * assume such arithmetic does not wrap.
  42 + *
  43 + * A miscompilation has been observed because of this on PPC.
  44 + * To work around it we hide the relationship of the pointer and the object
  45 + * using this macro.
  46 + *
  47 + * Versions of the ppc64 compiler before 4.1 had a bug where use of
  48 + * RELOC_HIDE could trash r30. The bug can be worked around by changing
  49 + * the inline assembly constraint from =g to =r, in this particular
  50 + * case either is valid.
  51 + */
  52 +#define RELOC_HIDE(ptr, off)                                           \
  53 +({                                                                     \
  54 +       unsigned long __ptr;                                            \
  55 +       __asm__ ("" : "=r"(__ptr) : "0"(ptr));                          \
  56 +       (typeof(ptr)) (__ptr + (off));                                  \
  57 +})
  58 +
  59 +/* Make the optimizer believe the variable can be manipulated arbitrarily. */
  60 +#define OPTIMIZER_HIDE_VAR(var)                                                \
  61 +       __asm__ ("" : "=r" (var) : "0" (var))
  62 +
  63 +#ifdef __CHECKER__
  64 +#define __must_be_array(a)     0
  65 +#else
  66 +/* &a[0] degrades to a pointer: a different type from an array */
  67 +#define __must_be_array(a)     BUILD_BUG_ON_ZERO(__same_type((a), &(a)[0]))
  68 +#endif
  69 +
  70 +/*
  71 + * Force always-inline if the user requests it so via the .config,
  72 + * or if gcc is too old:
  73 + */
  74 +#if !defined(CONFIG_ARCH_SUPPORTS_OPTIMIZED_INLINING) ||               \
  75 +    !defined(CONFIG_OPTIMIZE_INLINING) || (__GNUC__ < 4)
  76 +#define inline         inline          __attribute__((always_inline)) notrace
  77 +#define __inline__     __inline__      __attribute__((always_inline)) notrace
  78 +#define __inline       __inline        __attribute__((always_inline)) notrace
  79 +#else
  80 +/* A lot of inline functions can cause havoc with function tracing */
  81 +#define inline         inline          notrace
  82 +#define __inline__     __inline__      notrace
  83 +#define __inline       __inline        notrace
  84 +#endif
  85 +
  86 +#define __always_inline        inline __attribute__((always_inline))
  87 +#define  noinline      __attribute__((noinline))
  88 +
  89 +#define __deprecated   __attribute__((deprecated))
  90 +#define __packed       __attribute__((packed))
  91 +#define __weak         __attribute__((weak))
  92 +#define __alias(symbol)        __attribute__((alias(#symbol)))
  93 +
  94 +/*
  95 + * it doesn't make sense on ARM (currently the only user of __naked)
  96 + * to trace naked functions because then mcount is called without
  97 + * stack and frame pointer being set up and there is no chance to
  98 + * restore the lr register to the value before mcount was called.
  99 + *
 100 + * The asm() bodies of naked functions often depend on standard calling
 101 + * conventions, therefore they must be noinline and noclone.
 102 + *
 103 + * GCC 4.[56] currently fail to enforce this, so we must do so ourselves.
 104 + * See GCC PR44290.
 105 + */
 106 +#define __naked                __attribute__((naked)) noinline __noclone notrace
 107 +
 108 +#define __noreturn     __attribute__((noreturn))
 109 +
 110 +/*
 111 + * From the GCC manual:
 112 + *
 113 + * Many functions have no effects except the return value and their
 114 + * return value depends only on the parameters and/or global
 115 + * variables.  Such a function can be subject to common subexpression
 116 + * elimination and loop optimization just as an arithmetic operator
 117 + * would be.
 118 + * [...]
 119 + */
 120 +#define __pure                 __attribute__((pure))
 121 +#define __aligned(x)           __attribute__((aligned(x)))
 122 +#define __printf(a, b)         __attribute__((format(printf, a, b)))
 123 +#define __scanf(a, b)          __attribute__((format(scanf, a, b)))
 124 +#define __attribute_const__    __attribute__((__const__))
 125 +#define __maybe_unused         __attribute__((unused))
 126 +#define __always_unused                __attribute__((unused))
 127 +
 128 +/* gcc version specific checks */
 129 +
 130 +#if GCC_VERSION < 30200
 131 +# error Sorry, your compiler is too old - please upgrade it.
 132 +#endif
 133 +
 134 +#if GCC_VERSION < 30300
 135 +# define __used                        __attribute__((__unused__))
 136 +#else
 137 +# define __used                        __attribute__((__used__))
 138 +#endif
 139 +
 140 +#ifdef CONFIG_GCOV_KERNEL
 141 +# if GCC_VERSION < 30400
 142 +#   error "GCOV profiling support for gcc versions below 3.4 not included"
 143 +# endif /* __GNUC_MINOR__ */
 144 +#endif /* CONFIG_GCOV_KERNEL */
 145 +
 146 +#if GCC_VERSION >= 30400
 147 +#define __must_check           __attribute__((warn_unused_result))
 148 +#define __malloc               __attribute__((__malloc__))
 149 +#endif
 150 +
 151 +#if GCC_VERSION >= 40000
 152 +
 153 +/* GCC 4.1.[01] miscompiles __weak */
 154 +#ifdef __KERNEL__
 155 +# if GCC_VERSION >= 40100 &&  GCC_VERSION <= 40101
 156 +#  error Your version of gcc miscompiles the __weak directive
 157 +# endif
 158 +#endif
 159 +
 160 +#define __used                 __attribute__((__used__))
 161 +#define __compiler_offsetof(a, b)                                      \
 162 +       __builtin_offsetof(a, b)
 163 +
 164 +#if GCC_VERSION >= 40100 && GCC_VERSION < 40600
 165 +# define __compiletime_object_size(obj) __builtin_object_size(obj, 0)
 166 +#endif
 167 +
 168 +#if GCC_VERSION >= 40300
 169 +/* Mark functions as cold. gcc will assume any path leading to a call
 170 + * to them will be unlikely.  This means a lot of manual unlikely()s
 171 + * are unnecessary now for any paths leading to the usual suspects
 172 + * like BUG(), printk(), panic() etc. [but let's keep them for now for
 173 + * older compilers]
 174 + *
 175 + * Early snapshots of gcc 4.3 don't support this and we can't detect this
 176 + * in the preprocessor, but we can live with this because they're unreleased.
 177 + * Maketime probing would be overkill here.
 178 + *
 179 + * gcc also has a __attribute__((__hot__)) to move hot functions into
 180 + * a special section, but I don't see any sense in this right now in
 181 + * the kernel context
 182 + */
 183 +#define __cold                 __attribute__((__cold__))
 184 +
 185 +#define __UNIQUE_ID(prefix) __PASTE(__PASTE(__UNIQUE_ID_, prefix), __COUNTER__)
 186 +
 187 +#ifndef __CHECKER__
 188 +# define __compiletime_warning(message) __attribute__((warning(message)))
 189 +# define __compiletime_error(message) __attribute__((error(message)))
 190 +#endif /* __CHECKER__ */
 191 +#endif /* GCC_VERSION >= 40300 */
 192 +
 193 +#if GCC_VERSION >= 40500
 194 +/*
 195 + * Mark a position in code as unreachable.  This can be used to
 196 + * suppress control flow warnings after asm blocks that transfer
 197 + * control elsewhere.
 198 + *
 199 + * Early snapshots of gcc 4.5 don't support this and we can't detect
 200 + * this in the preprocessor, but we can live with this because they're
 201 + * unreleased.  Really, we need to have autoconf for the kernel.
 202 + */
 203 +#define unreachable() __builtin_unreachable()
 204 +
 205 +/* Mark a function definition as prohibited from being cloned. */
 206 +#define __noclone      __attribute__((__noclone__, __optimize__("no-tracer")))
 207 +
 208 +#endif /* GCC_VERSION >= 40500 */
 209 +
 210 +#if GCC_VERSION >= 40600
 211 +/*
 212 + * When used with Link Time Optimization, gcc can optimize away C functions or
 213 + * variables which are referenced only from assembly code.  __visible tells the
 214 + * optimizer that something else uses this function or variable, thus preventing
 215 + * this.
 216 + */
 217 +#define __visible      __attribute__((externally_visible))
 218 +#endif
 219 +
 220 +
 221 +#if GCC_VERSION >= 40900 && !defined(__CHECKER__)
 222 +/*
 223 + * __assume_aligned(n, k): Tell the optimizer that the returned
 224 + * pointer can be assumed to be k modulo n. The second argument is
 225 + * optional (default 0), so we use a variadic macro to make the
 226 + * shorthand.
 227 + *
 228 + * Beware: Do not apply this to functions which may return
 229 + * ERR_PTRs. Also, it is probably unwise to apply it to functions
 230 + * returning extra information in the low bits (but in that case the
 231 + * compiler should see some alignment anyway, when the return value is
 232 + * massaged by 'flags = ptr & 3; ptr &= ~3;').
 233 + */
 234 +#define __assume_aligned(a, ...) __attribute__((__assume_aligned__(a, ## __VA_ARGS__)))
 235 +#endif
 236 +
 237 +/*
 238 + * GCC 'asm goto' miscompiles certain code sequences:
 239 + *
 240 + *   http://gcc.gnu.org/bugzilla/show_bug.cgi?id=58670
 241 + *
 242 + * Work it around via a compiler barrier quirk suggested by Jakub Jelinek.
 243 + *
 244 + * (asm goto is automatically volatile - the naming reflects this.)
 245 + */
 246 +#define asm_volatile_goto(x...)        do { asm goto(x); asm (""); } while (0)
 247 +
 248 +#ifdef CONFIG_ARCH_USE_BUILTIN_BSWAP
 249 +#if GCC_VERSION >= 40400
 250 +#define __HAVE_BUILTIN_BSWAP32__
 251 +#define __HAVE_BUILTIN_BSWAP64__
 252 +#endif
 253 +#if GCC_VERSION >= 40800
 254 +#define __HAVE_BUILTIN_BSWAP16__
 255 +#endif
 256 +#endif /* CONFIG_ARCH_USE_BUILTIN_BSWAP */
 257 +
 258 +#if GCC_VERSION >= 50000
 259 +#define KASAN_ABI_VERSION 4
 260 +#elif GCC_VERSION >= 40902
 261 +#define KASAN_ABI_VERSION 3
 262 +#endif
 263 +
 264 +#if GCC_VERSION >= 40902
 265 +/*
 266 + * Tell the compiler that address safety instrumentation (KASAN)
 267 + * should not be applied to that function.
 268 + * Conflicts with inlining: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=67368
 269 + */
 270 +#define __no_sanitize_address __attribute__((no_sanitize_address))
 271 +#endif
 272 +
 273 +#endif /* gcc version >= 40000 specific checks */
 274 +
 275 +#if !defined(__noclone)
 276 +#define __noclone      /* not needed */
 277 +#endif
 278 +
 279 +#if !defined(__no_sanitize_address)
 280 +#define __no_sanitize_address
 281 +#endif
 282 +
 283 +/*
 284 + * A trick to suppress uninitialized variable warning without generating any
 285 + * code
 286 + */
 287 +#define uninitialized_var(x) x = x