compiler-gcc.h 5.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174
  1. /* SPDX-License-Identifier: GPL-2.0 */
  2. #ifndef __LINUX_COMPILER_TYPES_H
  3. #error "Please don't include <linux/compiler-gcc.h> directly, include <linux/compiler.h> instead."
  4. #endif
  5. /*
  6. * Common definitions for all gcc versions go here.
  7. */
  8. #define GCC_VERSION (__GNUC__ * 10000 \
  9. + __GNUC_MINOR__ * 100 \
  10. + __GNUC_PATCHLEVEL__)
  11. #if GCC_VERSION < 40600
  12. # error Sorry, your compiler is too old - please upgrade it.
  13. #endif
  14. /* Optimization barrier */
  15. /* The "volatile" is due to gcc bugs */
  16. #define barrier() __asm__ __volatile__("": : :"memory")
  17. /*
  18. * This version is i.e. to prevent dead stores elimination on @ptr
  19. * where gcc and llvm may behave differently when otherwise using
  20. * normal barrier(): while gcc behavior gets along with a normal
  21. * barrier(), llvm needs an explicit input variable to be assumed
  22. * clobbered. The issue is as follows: while the inline asm might
  23. * access any memory it wants, the compiler could have fit all of
  24. * @ptr into memory registers instead, and since @ptr never escaped
  25. * from that, it proved that the inline asm wasn't touching any of
  26. * it. This version works well with both compilers, i.e. we're telling
  27. * the compiler that the inline asm absolutely may see the contents
  28. * of @ptr. See also: https://llvm.org/bugs/show_bug.cgi?id=15495
  29. */
  30. #define barrier_data(ptr) __asm__ __volatile__("": :"r"(ptr) :"memory")
  31. /*
  32. * This macro obfuscates arithmetic on a variable address so that gcc
  33. * shouldn't recognize the original var, and make assumptions about it.
  34. *
  35. * This is needed because the C standard makes it undefined to do
  36. * pointer arithmetic on "objects" outside their boundaries and the
  37. * gcc optimizers assume this is the case. In particular they
  38. * assume such arithmetic does not wrap.
  39. *
  40. * A miscompilation has been observed because of this on PPC.
  41. * To work around it we hide the relationship of the pointer and the object
  42. * using this macro.
  43. *
  44. * Versions of the ppc64 compiler before 4.1 had a bug where use of
  45. * RELOC_HIDE could trash r30. The bug can be worked around by changing
  46. * the inline assembly constraint from =g to =r, in this particular
  47. * case either is valid.
  48. */
  49. #define RELOC_HIDE(ptr, off) \
  50. ({ \
  51. unsigned long __ptr; \
  52. __asm__ ("" : "=r"(__ptr) : "0"(ptr)); \
  53. (typeof(ptr)) (__ptr + (off)); \
  54. })
  55. /*
  56. * A trick to suppress uninitialized variable warning without generating any
  57. * code
  58. */
  59. #define uninitialized_var(x) x = x
  60. #ifdef CONFIG_RETPOLINE
  61. #define __noretpoline __attribute__((__indirect_branch__("keep")))
  62. #endif
  63. #define __UNIQUE_ID(prefix) __PASTE(__PASTE(__UNIQUE_ID_, prefix), __COUNTER__)
  64. #define __compiletime_object_size(obj) __builtin_object_size(obj, 0)
  65. #define __compiletime_warning(message) __attribute__((__warning__(message)))
  66. #define __compiletime_error(message) __attribute__((__error__(message)))
  67. #if defined(LATENT_ENTROPY_PLUGIN) && !defined(__CHECKER__)
  68. #define __latent_entropy __attribute__((latent_entropy))
  69. #endif
  70. /*
  71. * calling noreturn functions, __builtin_unreachable() and __builtin_trap()
  72. * confuse the stack allocation in gcc, leading to overly large stack
  73. * frames, see https://gcc.gnu.org/bugzilla/show_bug.cgi?id=82365
  74. *
  75. * Adding an empty inline assembly before it works around the problem
  76. */
  77. #define barrier_before_unreachable() asm volatile("")
  78. /*
  79. * Mark a position in code as unreachable. This can be used to
  80. * suppress control flow warnings after asm blocks that transfer
  81. * control elsewhere.
  82. */
  83. #define unreachable() \
  84. do { \
  85. annotate_unreachable(); \
  86. barrier_before_unreachable(); \
  87. __builtin_unreachable(); \
  88. } while (0)
  89. #if defined(RANDSTRUCT_PLUGIN) && !defined(__CHECKER__)
  90. #define __randomize_layout __attribute__((randomize_layout))
  91. #define __no_randomize_layout __attribute__((no_randomize_layout))
  92. /* This anon struct can add padding, so only enable it under randstruct. */
  93. #define randomized_struct_fields_start struct {
  94. #define randomized_struct_fields_end } __randomize_layout;
  95. #endif
  96. /*
  97. * GCC 'asm goto' miscompiles certain code sequences:
  98. *
  99. * http://gcc.gnu.org/bugzilla/show_bug.cgi?id=58670
  100. *
  101. * Work it around via a compiler barrier quirk suggested by Jakub Jelinek.
  102. *
  103. * (asm goto is automatically volatile - the naming reflects this.)
  104. */
  105. #define asm_volatile_goto(x...) do { asm goto(x); asm (""); } while (0)
  106. /*
  107. * sparse (__CHECKER__) pretends to be gcc, but can't do constant
  108. * folding in __builtin_bswap*() (yet), so don't set these for it.
  109. */
  110. #if defined(CONFIG_ARCH_USE_BUILTIN_BSWAP) && !defined(__CHECKER__)
  111. #define __HAVE_BUILTIN_BSWAP32__
  112. #define __HAVE_BUILTIN_BSWAP64__
  113. #if GCC_VERSION >= 40800
  114. #define __HAVE_BUILTIN_BSWAP16__
  115. #endif
  116. #endif /* CONFIG_ARCH_USE_BUILTIN_BSWAP && !__CHECKER__ */
  117. #if GCC_VERSION >= 70000
  118. #define KASAN_ABI_VERSION 5
  119. #elif GCC_VERSION >= 50000
  120. #define KASAN_ABI_VERSION 4
  121. #elif GCC_VERSION >= 40902
  122. #define KASAN_ABI_VERSION 3
  123. #endif
  124. #if __has_attribute(__no_sanitize_address__)
  125. #define __no_sanitize_address __attribute__((no_sanitize_address))
  126. #else
  127. #define __no_sanitize_address
  128. #endif
  129. #if GCC_VERSION >= 50100
  130. #define COMPILER_HAS_GENERIC_BUILTIN_OVERFLOW 1
  131. #endif
  132. /*
  133. * Turn individual warnings and errors on and off locally, depending
  134. * on version.
  135. */
  136. #define __diag_GCC(version, severity, s) \
  137. __diag_GCC_ ## version(__diag_GCC_ ## severity s)
  138. /* Severity used in pragma directives */
  139. #define __diag_GCC_ignore ignored
  140. #define __diag_GCC_warn warning
  141. #define __diag_GCC_error error
  142. #define __diag_str1(s) #s
  143. #define __diag_str(s) __diag_str1(s)
  144. #define __diag(s) _Pragma(__diag_str(GCC diagnostic s))
  145. #if GCC_VERSION >= 80000
  146. #define __diag_GCC_8(s) __diag(s)
  147. #else
  148. #define __diag_GCC_8(s)
  149. #endif
  150. #define __no_fgcse __attribute__((optimize("-fno-gcse")))