compiler.h 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559
  1. #ifndef __LINUX_COMPILER_H
  2. #define __LINUX_COMPILER_H
  3. #ifndef __ASSEMBLY__
  4. #ifdef __CHECKER__
  5. # define __user __attribute__((noderef, address_space(1)))
  6. # define __kernel __attribute__((address_space(0)))
  7. # define __safe __attribute__((safe))
  8. # define __force __attribute__((force))
  9. # define __nocast __attribute__((nocast))
  10. # define __iomem __attribute__((noderef, address_space(2)))
  11. # define __must_hold(x) __attribute__((context(x,1,1)))
  12. # define __acquires(x) __attribute__((context(x,0,1)))
  13. # define __releases(x) __attribute__((context(x,1,0)))
  14. # define __acquire(x) __context__(x,1)
  15. # define __release(x) __context__(x,-1)
  16. # define __cond_lock(x,c) ((c) ? ({ __acquire(x); 1; }) : 0)
  17. # define __percpu __attribute__((noderef, address_space(3)))
  18. # define __pmem __attribute__((noderef, address_space(5)))
  19. #ifdef CONFIG_SPARSE_RCU_POINTER
  20. # define __rcu __attribute__((noderef, address_space(4)))
  21. #else
  22. # define __rcu
  23. #endif
  24. extern void __chk_user_ptr(const volatile void __user *);
  25. extern void __chk_io_ptr(const volatile void __iomem *);
  26. #else
  27. # define __user
  28. # define __kernel
  29. # define __safe
  30. # define __force
  31. # define __nocast
  32. # define __iomem
  33. # define __chk_user_ptr(x) (void)0
  34. # define __chk_io_ptr(x) (void)0
  35. # define __builtin_warning(x, y...) (1)
  36. # define __must_hold(x)
  37. # define __acquires(x)
  38. # define __releases(x)
  39. # define __acquire(x) (void)0
  40. # define __release(x) (void)0
  41. # define __cond_lock(x,c) (c)
  42. # define __percpu
  43. # define __rcu
  44. # define __pmem
  45. #endif
  46. /* Indirect macros required for expanded argument pasting, eg. __LINE__. */
  47. #define ___PASTE(a,b) a##b
  48. #define __PASTE(a,b) ___PASTE(a,b)
  49. #ifdef __KERNEL__
  50. #ifdef __GNUC__
  51. #include <linux/compiler-gcc.h>
  52. #endif
  53. #if defined(CC_USING_HOTPATCH) && !defined(__CHECKER__)
  54. #define notrace __attribute__((hotpatch(0,0)))
  55. #else
  56. #define notrace __attribute__((no_instrument_function))
  57. #endif
  58. /* Intel compiler defines __GNUC__. So we will overwrite implementations
  59. * coming from above header files here
  60. */
  61. #ifdef __INTEL_COMPILER
  62. # include <linux/compiler-intel.h>
  63. #endif
  64. /* Clang compiler defines __GNUC__. So we will overwrite implementations
  65. * coming from above header files here
  66. */
  67. #ifdef __clang__
  68. #include <linux/compiler-clang.h>
  69. #endif
  70. /*
  71. * Generic compiler-dependent macros required for kernel
  72. * build go below this comment. Actual compiler/compiler version
  73. * specific implementations come from the above header files
  74. */
  75. struct ftrace_branch_data {
  76. const char *func;
  77. const char *file;
  78. unsigned line;
  79. union {
  80. struct {
  81. unsigned long correct;
  82. unsigned long incorrect;
  83. };
  84. struct {
  85. unsigned long miss;
  86. unsigned long hit;
  87. };
  88. unsigned long miss_hit[2];
  89. };
  90. };
  91. /*
  92. * Note: DISABLE_BRANCH_PROFILING can be used by special lowlevel code
  93. * to disable branch tracing on a per file basis.
  94. */
  95. #if defined(CONFIG_TRACE_BRANCH_PROFILING) \
  96. && !defined(DISABLE_BRANCH_PROFILING) && !defined(__CHECKER__)
  97. void ftrace_likely_update(struct ftrace_branch_data *f, int val, int expect);
  98. #define likely_notrace(x) __builtin_expect(!!(x), 1)
  99. #define unlikely_notrace(x) __builtin_expect(!!(x), 0)
  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. * Using __builtin_constant_p(x) to ignore cases where the return
  116. * value is always the same. This idea is taken from a similar patch
  117. * written by Daniel Walker.
  118. */
  119. # ifndef likely
  120. # define likely(x) (__builtin_constant_p(x) ? !!(x) : __branch_check__(x, 1))
  121. # endif
  122. # ifndef unlikely
  123. # define unlikely(x) (__builtin_constant_p(x) ? !!(x) : __branch_check__(x, 0))
  124. # endif
  125. #ifdef CONFIG_PROFILE_ALL_BRANCHES
  126. /*
  127. * "Define 'is'", Bill Clinton
  128. * "Define 'if'", Steven Rostedt
  129. */
  130. #define if(cond, ...) __trace_if( (cond , ## __VA_ARGS__) )
  131. #define __trace_if(cond) \
  132. if (__builtin_constant_p(!!(cond)) ? !!(cond) : \
  133. ({ \
  134. int ______r; \
  135. static struct ftrace_branch_data \
  136. __attribute__((__aligned__(4))) \
  137. __attribute__((section("_ftrace_branch"))) \
  138. ______f = { \
  139. .func = __func__, \
  140. .file = __FILE__, \
  141. .line = __LINE__, \
  142. }; \
  143. ______r = !!(cond); \
  144. ______f.miss_hit[______r]++; \
  145. ______r; \
  146. }))
  147. #endif /* CONFIG_PROFILE_ALL_BRANCHES */
  148. #else
  149. # define likely(x) __builtin_expect(!!(x), 1)
  150. # define unlikely(x) __builtin_expect(!!(x), 0)
  151. #endif
  152. /* Optimization barrier */
  153. #ifndef barrier
  154. # define barrier() __memory_barrier()
  155. #endif
  156. #ifndef barrier_data
  157. # define barrier_data(ptr) barrier()
  158. #endif
  159. /* Unreachable code */
  160. #ifndef unreachable
  161. # define unreachable() do { } while (1)
  162. #endif
  163. #ifndef RELOC_HIDE
  164. # define RELOC_HIDE(ptr, off) \
  165. ({ unsigned long __ptr; \
  166. __ptr = (unsigned long) (ptr); \
  167. (typeof(ptr)) (__ptr + (off)); })
  168. #endif
  169. #ifndef OPTIMIZER_HIDE_VAR
  170. #define OPTIMIZER_HIDE_VAR(var) barrier()
  171. #endif
  172. /* Not-quite-unique ID. */
  173. #ifndef __UNIQUE_ID
  174. # define __UNIQUE_ID(prefix) __PASTE(__PASTE(__UNIQUE_ID_, prefix), __LINE__)
  175. #endif
  176. #include <linux/types.h>
  177. #define __READ_ONCE_SIZE \
  178. ({ \
  179. switch (size) { \
  180. case 1: *(__u8 *)res = *(volatile __u8 *)p; break; \
  181. case 2: *(__u16 *)res = *(volatile __u16 *)p; break; \
  182. case 4: *(__u32 *)res = *(volatile __u32 *)p; break; \
  183. case 8: *(__u64 *)res = *(volatile __u64 *)p; break; \
  184. default: \
  185. barrier(); \
  186. __builtin_memcpy((void *)res, (const void *)p, size); \
  187. barrier(); \
  188. } \
  189. })
  190. static __always_inline
  191. void __read_once_size(const volatile void *p, void *res, int size)
  192. {
  193. __READ_ONCE_SIZE;
  194. }
  195. #ifdef CONFIG_KASAN
  196. /*
  197. * This function is not 'inline' because __no_sanitize_address confilcts
  198. * with inlining. Attempt to inline it may cause a build failure.
  199. * https://gcc.gnu.org/bugzilla/show_bug.cgi?id=67368
  200. * '__maybe_unused' allows us to avoid defined-but-not-used warnings.
  201. */
  202. static __no_sanitize_address __maybe_unused
  203. void __read_once_size_nocheck(const volatile void *p, void *res, int size)
  204. {
  205. __READ_ONCE_SIZE;
  206. }
  207. #else
  208. static __always_inline
  209. void __read_once_size_nocheck(const volatile void *p, void *res, int size)
  210. {
  211. __READ_ONCE_SIZE;
  212. }
  213. #endif
  214. static __always_inline void __write_once_size(volatile void *p, void *res, int size)
  215. {
  216. switch (size) {
  217. case 1: *(volatile __u8 *)p = *(__u8 *)res; break;
  218. case 2: *(volatile __u16 *)p = *(__u16 *)res; break;
  219. case 4: *(volatile __u32 *)p = *(__u32 *)res; break;
  220. case 8: *(volatile __u64 *)p = *(__u64 *)res; break;
  221. default:
  222. barrier();
  223. __builtin_memcpy((void *)p, (const void *)res, size);
  224. barrier();
  225. }
  226. }
  227. /*
  228. * Prevent the compiler from merging or refetching reads or writes. The
  229. * compiler is also forbidden from reordering successive instances of
  230. * READ_ONCE, WRITE_ONCE and ACCESS_ONCE (see below), but only when the
  231. * compiler is aware of some particular ordering. One way to make the
  232. * compiler aware of ordering is to put the two invocations of READ_ONCE,
  233. * WRITE_ONCE or ACCESS_ONCE() in different C statements.
  234. *
  235. * In contrast to ACCESS_ONCE these two macros will also work on aggregate
  236. * data types like structs or unions. If the size of the accessed data
  237. * type exceeds the word size of the machine (e.g., 32 bits or 64 bits)
  238. * READ_ONCE() and WRITE_ONCE() will fall back to memcpy and print a
  239. * compile-time warning.
  240. *
  241. * Their two major use cases are: (1) Mediating communication between
  242. * process-level code and irq/NMI handlers, all running on the same CPU,
  243. * and (2) Ensuring that the compiler does not fold, spindle, or otherwise
  244. * mutilate accesses that either do not require ordering or that interact
  245. * with an explicit memory barrier or atomic instruction that provides the
  246. * required ordering.
  247. */
  248. #define __READ_ONCE(x, check) \
  249. ({ \
  250. union { typeof(x) __val; char __c[1]; } __u; \
  251. if (check) \
  252. __read_once_size(&(x), __u.__c, sizeof(x)); \
  253. else \
  254. __read_once_size_nocheck(&(x), __u.__c, sizeof(x)); \
  255. __u.__val; \
  256. })
  257. #define READ_ONCE(x) __READ_ONCE(x, 1)
  258. /*
  259. * Use READ_ONCE_NOCHECK() instead of READ_ONCE() if you need
  260. * to hide memory access from KASAN.
  261. */
  262. #define READ_ONCE_NOCHECK(x) __READ_ONCE(x, 0)
  263. #define WRITE_ONCE(x, val) \
  264. ({ \
  265. union { typeof(x) __val; char __c[1]; } __u = \
  266. { .__val = (__force typeof(x)) (val) }; \
  267. __write_once_size(&(x), __u.__c, sizeof(x)); \
  268. __u.__val; \
  269. })
  270. /**
  271. * smp_cond_acquire() - Spin wait for cond with ACQUIRE ordering
  272. * @cond: boolean expression to wait for
  273. *
  274. * Equivalent to using smp_load_acquire() on the condition variable but employs
  275. * the control dependency of the wait to reduce the barrier on many platforms.
  276. *
  277. * The control dependency provides a LOAD->STORE order, the additional RMB
  278. * provides LOAD->LOAD order, together they provide LOAD->{LOAD,STORE} order,
  279. * aka. ACQUIRE.
  280. */
  281. #define smp_cond_acquire(cond) do { \
  282. while (!(cond)) \
  283. cpu_relax(); \
  284. smp_rmb(); /* ctrl + rmb := acquire */ \
  285. } while (0)
  286. #endif /* __KERNEL__ */
  287. #endif /* __ASSEMBLY__ */
  288. #ifdef __KERNEL__
  289. /*
  290. * Allow us to mark functions as 'deprecated' and have gcc emit a nice
  291. * warning for each use, in hopes of speeding the functions removal.
  292. * Usage is:
  293. * int __deprecated foo(void)
  294. */
  295. #ifndef __deprecated
  296. # define __deprecated /* unimplemented */
  297. #endif
  298. #ifdef MODULE
  299. #define __deprecated_for_modules __deprecated
  300. #else
  301. #define __deprecated_for_modules
  302. #endif
  303. #ifndef __must_check
  304. #define __must_check
  305. #endif
  306. #ifndef CONFIG_ENABLE_MUST_CHECK
  307. #undef __must_check
  308. #define __must_check
  309. #endif
  310. #ifndef CONFIG_ENABLE_WARN_DEPRECATED
  311. #undef __deprecated
  312. #undef __deprecated_for_modules
  313. #define __deprecated
  314. #define __deprecated_for_modules
  315. #endif
  316. /*
  317. * Allow us to avoid 'defined but not used' warnings on functions and data,
  318. * as well as force them to be emitted to the assembly file.
  319. *
  320. * As of gcc 3.4, static functions that are not marked with attribute((used))
  321. * may be elided from the assembly file. As of gcc 3.4, static data not so
  322. * marked will not be elided, but this may change in a future gcc version.
  323. *
  324. * NOTE: Because distributions shipped with a backported unit-at-a-time
  325. * compiler in gcc 3.3, we must define __used to be __attribute__((used))
  326. * for gcc >=3.3 instead of 3.4.
  327. *
  328. * In prior versions of gcc, such functions and data would be emitted, but
  329. * would be warned about except with attribute((unused)).
  330. *
  331. * Mark functions that are referenced only in inline assembly as __used so
  332. * the code is emitted even though it appears to be unreferenced.
  333. */
  334. #ifndef __used
  335. # define __used /* unimplemented */
  336. #endif
  337. #ifndef __maybe_unused
  338. # define __maybe_unused /* unimplemented */
  339. #endif
  340. #ifndef __always_unused
  341. # define __always_unused /* unimplemented */
  342. #endif
  343. #ifndef noinline
  344. #define noinline
  345. #endif
  346. /*
  347. * Rather then using noinline to prevent stack consumption, use
  348. * noinline_for_stack instead. For documentation reasons.
  349. */
  350. #define noinline_for_stack noinline
  351. #ifndef __always_inline
  352. #define __always_inline inline
  353. #endif
  354. #endif /* __KERNEL__ */
  355. /*
  356. * From the GCC manual:
  357. *
  358. * Many functions do not examine any values except their arguments,
  359. * and have no effects except the return value. Basically this is
  360. * just slightly more strict class than the `pure' attribute above,
  361. * since function is not allowed to read global memory.
  362. *
  363. * Note that a function that has pointer arguments and examines the
  364. * data pointed to must _not_ be declared `const'. Likewise, a
  365. * function that calls a non-`const' function usually must not be
  366. * `const'. It does not make sense for a `const' function to return
  367. * `void'.
  368. */
  369. #ifndef __attribute_const__
  370. # define __attribute_const__ /* unimplemented */
  371. #endif
  372. /*
  373. * Tell gcc if a function is cold. The compiler will assume any path
  374. * directly leading to the call is unlikely.
  375. */
  376. #ifndef __cold
  377. #define __cold
  378. #endif
  379. /* Simple shorthand for a section definition */
  380. #ifndef __section
  381. # define __section(S) __attribute__ ((__section__(#S)))
  382. #endif
  383. #ifndef __visible
  384. #define __visible
  385. #endif
  386. /*
  387. * Assume alignment of return value.
  388. */
  389. #ifndef __assume_aligned
  390. #define __assume_aligned(a, ...)
  391. #endif
  392. /* Are two types/vars the same type (ignoring qualifiers)? */
  393. #ifndef __same_type
  394. # define __same_type(a, b) __builtin_types_compatible_p(typeof(a), typeof(b))
  395. #endif
  396. /* Is this type a native word size -- useful for atomic operations */
  397. #ifndef __native_word
  398. # define __native_word(t) (sizeof(t) == sizeof(char) || sizeof(t) == sizeof(short) || sizeof(t) == sizeof(int) || sizeof(t) == sizeof(long))
  399. #endif
  400. /* Compile time object size, -1 for unknown */
  401. #ifndef __compiletime_object_size
  402. # define __compiletime_object_size(obj) -1
  403. #endif
  404. #ifndef __compiletime_warning
  405. # define __compiletime_warning(message)
  406. #endif
  407. #ifndef __compiletime_error
  408. # define __compiletime_error(message)
  409. /*
  410. * Sparse complains of variable sized arrays due to the temporary variable in
  411. * __compiletime_assert. Unfortunately we can't just expand it out to make
  412. * sparse see a constant array size without breaking compiletime_assert on old
  413. * versions of GCC (e.g. 4.2.4), so hide the array from sparse altogether.
  414. */
  415. # ifndef __CHECKER__
  416. # define __compiletime_error_fallback(condition) \
  417. do { ((void)sizeof(char[1 - 2 * condition])); } while (0)
  418. # endif
  419. #endif
  420. #ifndef __compiletime_error_fallback
  421. # define __compiletime_error_fallback(condition) do { } while (0)
  422. #endif
  423. #ifdef __OPTIMIZE__
  424. # define __compiletime_assert(condition, msg, prefix, suffix) \
  425. do { \
  426. bool __cond = !(condition); \
  427. extern void prefix ## suffix(void) __compiletime_error(msg); \
  428. if (__cond) \
  429. prefix ## suffix(); \
  430. __compiletime_error_fallback(__cond); \
  431. } while (0)
  432. #else
  433. # define __compiletime_assert(condition, msg, prefix, suffix) do { } while (0)
  434. #endif
  435. #define _compiletime_assert(condition, msg, prefix, suffix) \
  436. __compiletime_assert(condition, msg, prefix, suffix)
  437. /**
  438. * compiletime_assert - break build and emit msg if condition is false
  439. * @condition: a compile-time constant condition to check
  440. * @msg: a message to emit if condition is false
  441. *
  442. * In tradition of POSIX assert, this macro will break the build if the
  443. * supplied condition is *false*, emitting the supplied error message if the
  444. * compiler has support to do so.
  445. */
  446. #define compiletime_assert(condition, msg) \
  447. _compiletime_assert(condition, msg, __compiletime_assert_, __LINE__)
  448. #define compiletime_assert_atomic_type(t) \
  449. compiletime_assert(__native_word(t), \
  450. "Need native word sized stores/loads for atomicity.")
  451. /*
  452. * Prevent the compiler from merging or refetching accesses. The compiler
  453. * is also forbidden from reordering successive instances of ACCESS_ONCE(),
  454. * but only when the compiler is aware of some particular ordering. One way
  455. * to make the compiler aware of ordering is to put the two invocations of
  456. * ACCESS_ONCE() in different C statements.
  457. *
  458. * ACCESS_ONCE will only work on scalar types. For union types, ACCESS_ONCE
  459. * on a union member will work as long as the size of the member matches the
  460. * size of the union and the size is smaller than word size.
  461. *
  462. * The major use cases of ACCESS_ONCE used to be (1) Mediating communication
  463. * between process-level code and irq/NMI handlers, all running on the same CPU,
  464. * and (2) Ensuring that the compiler does not fold, spindle, or otherwise
  465. * mutilate accesses that either do not require ordering or that interact
  466. * with an explicit memory barrier or atomic instruction that provides the
  467. * required ordering.
  468. *
  469. * If possible use READ_ONCE()/WRITE_ONCE() instead.
  470. */
  471. #define __ACCESS_ONCE(x) ({ \
  472. __maybe_unused typeof(x) __var = (__force typeof(x)) 0; \
  473. (volatile typeof(x) *)&(x); })
  474. #define ACCESS_ONCE(x) (*__ACCESS_ONCE(x))
  475. /**
  476. * lockless_dereference() - safely load a pointer for later dereference
  477. * @p: The pointer to load
  478. *
  479. * Similar to rcu_dereference(), but for situations where the pointed-to
  480. * object's lifetime is managed by something other than RCU. That
  481. * "something other" might be reference counting or simple immortality.
  482. */
  483. #define lockless_dereference(p) \
  484. ({ \
  485. typeof(p) _________p1 = READ_ONCE(p); \
  486. smp_read_barrier_depends(); /* Dependency order vs. p above. */ \
  487. (_________p1); \
  488. })
  489. /* Ignore/forbid kprobes attach on very low level functions marked by this attribute: */
  490. #ifdef CONFIG_KPROBES
  491. # define __kprobes __attribute__((__section__(".kprobes.text")))
  492. # define nokprobe_inline __always_inline
  493. #else
  494. # define __kprobes
  495. # define nokprobe_inline inline
  496. #endif
  497. #endif /* __LINUX_COMPILER_H */