diff options
| author | Ingo Molnar <mingo@kernel.org> | 2017-11-29 01:11:24 -0500 |
|---|---|---|
| committer | Ingo Molnar <mingo@kernel.org> | 2017-11-29 01:11:24 -0500 |
| commit | 4fc31ba13d052c2933bf91095c063cf9a39effd0 (patch) | |
| tree | beabb73c2fe245e6541126732895da62e55bc8ee /include/linux/compiler.h | |
| parent | 0e18dd12064e07519f7cbff4149ca7fff620cbed (diff) | |
| parent | b29c6ef7bb1257853c1e31616d84f55e561cf631 (diff) | |
Merge branch 'linus' into perf/urgent, to pick up dependent commits
Signed-off-by: Ingo Molnar <mingo@kernel.org>
Diffstat (limited to 'include/linux/compiler.h')
| -rw-r--r-- | include/linux/compiler.h | 286 |
1 files changed, 4 insertions, 282 deletions
diff --git a/include/linux/compiler.h b/include/linux/compiler.h index 202710420d6d..3672353a0acd 100644 --- a/include/linux/compiler.h +++ b/include/linux/compiler.h | |||
| @@ -2,111 +2,12 @@ | |||
| 2 | #ifndef __LINUX_COMPILER_H | 2 | #ifndef __LINUX_COMPILER_H |
| 3 | #define __LINUX_COMPILER_H | 3 | #define __LINUX_COMPILER_H |
| 4 | 4 | ||
| 5 | #ifndef __ASSEMBLY__ | 5 | #include <linux/compiler_types.h> |
| 6 | 6 | ||
| 7 | #ifdef __CHECKER__ | 7 | #ifndef __ASSEMBLY__ |
| 8 | # define __user __attribute__((noderef, address_space(1))) | ||
| 9 | # define __kernel __attribute__((address_space(0))) | ||
| 10 | # define __safe __attribute__((safe)) | ||
| 11 | # define __force __attribute__((force)) | ||
| 12 | # define __nocast __attribute__((nocast)) | ||
| 13 | # define __iomem __attribute__((noderef, address_space(2))) | ||
| 14 | # define __must_hold(x) __attribute__((context(x,1,1))) | ||
| 15 | # define __acquires(x) __attribute__((context(x,0,1))) | ||
| 16 | # define __releases(x) __attribute__((context(x,1,0))) | ||
| 17 | # define __acquire(x) __context__(x,1) | ||
| 18 | # define __release(x) __context__(x,-1) | ||
| 19 | # define __cond_lock(x,c) ((c) ? ({ __acquire(x); 1; }) : 0) | ||
| 20 | # define __percpu __attribute__((noderef, address_space(3))) | ||
| 21 | # define __rcu __attribute__((noderef, address_space(4))) | ||
| 22 | # define __private __attribute__((noderef)) | ||
| 23 | extern void __chk_user_ptr(const volatile void __user *); | ||
| 24 | extern void __chk_io_ptr(const volatile void __iomem *); | ||
| 25 | # define ACCESS_PRIVATE(p, member) (*((typeof((p)->member) __force *) &(p)->member)) | ||
| 26 | #else /* __CHECKER__ */ | ||
| 27 | # ifdef STRUCTLEAK_PLUGIN | ||
| 28 | # define __user __attribute__((user)) | ||
| 29 | # else | ||
| 30 | # define __user | ||
| 31 | # endif | ||
| 32 | # define __kernel | ||
| 33 | # define __safe | ||
| 34 | # define __force | ||
| 35 | # define __nocast | ||
| 36 | # define __iomem | ||
| 37 | # define __chk_user_ptr(x) (void)0 | ||
| 38 | # define __chk_io_ptr(x) (void)0 | ||
| 39 | # define __builtin_warning(x, y...) (1) | ||
| 40 | # define __must_hold(x) | ||
| 41 | # define __acquires(x) | ||
| 42 | # define __releases(x) | ||
| 43 | # define __acquire(x) (void)0 | ||
| 44 | # define __release(x) (void)0 | ||
| 45 | # define __cond_lock(x,c) (c) | ||
| 46 | # define __percpu | ||
| 47 | # define __rcu | ||
| 48 | # define __private | ||
| 49 | # define ACCESS_PRIVATE(p, member) ((p)->member) | ||
| 50 | #endif /* __CHECKER__ */ | ||
| 51 | |||
| 52 | /* Indirect macros required for expanded argument pasting, eg. __LINE__. */ | ||
| 53 | #define ___PASTE(a,b) a##b | ||
| 54 | #define __PASTE(a,b) ___PASTE(a,b) | ||
| 55 | 8 | ||
| 56 | #ifdef __KERNEL__ | 9 | #ifdef __KERNEL__ |
| 57 | 10 | ||
| 58 | #ifdef __GNUC__ | ||
| 59 | #include <linux/compiler-gcc.h> | ||
| 60 | #endif | ||
| 61 | |||
| 62 | #if defined(CC_USING_HOTPATCH) && !defined(__CHECKER__) | ||
| 63 | #define notrace __attribute__((hotpatch(0,0))) | ||
| 64 | #else | ||
| 65 | #define notrace __attribute__((no_instrument_function)) | ||
| 66 | #endif | ||
| 67 | |||
| 68 | /* Intel compiler defines __GNUC__. So we will overwrite implementations | ||
| 69 | * coming from above header files here | ||
| 70 | */ | ||
| 71 | #ifdef __INTEL_COMPILER | ||
| 72 | # include <linux/compiler-intel.h> | ||
| 73 | #endif | ||
| 74 | |||
| 75 | /* Clang compiler defines __GNUC__. So we will overwrite implementations | ||
| 76 | * coming from above header files here | ||
| 77 | */ | ||
| 78 | #ifdef __clang__ | ||
| 79 | #include <linux/compiler-clang.h> | ||
| 80 | #endif | ||
| 81 | |||
| 82 | /* | ||
| 83 | * Generic compiler-dependent macros required for kernel | ||
| 84 | * build go below this comment. Actual compiler/compiler version | ||
| 85 | * specific implementations come from the above header files | ||
| 86 | */ | ||
| 87 | |||
| 88 | struct ftrace_branch_data { | ||
| 89 | const char *func; | ||
| 90 | const char *file; | ||
| 91 | unsigned line; | ||
| 92 | union { | ||
| 93 | struct { | ||
| 94 | unsigned long correct; | ||
| 95 | unsigned long incorrect; | ||
| 96 | }; | ||
| 97 | struct { | ||
| 98 | unsigned long miss; | ||
| 99 | unsigned long hit; | ||
| 100 | }; | ||
| 101 | unsigned long miss_hit[2]; | ||
| 102 | }; | ||
| 103 | }; | ||
| 104 | |||
| 105 | struct ftrace_likely_data { | ||
| 106 | struct ftrace_branch_data data; | ||
| 107 | unsigned long constant; | ||
| 108 | }; | ||
| 109 | |||
| 110 | /* | 11 | /* |
| 111 | * Note: DISABLE_BRANCH_PROFILING can be used by special lowlevel code | 12 | * Note: DISABLE_BRANCH_PROFILING can be used by special lowlevel code |
| 112 | * to disable branch tracing on a per file basis. | 13 | * to disable branch tracing on a per file basis. |
| @@ -333,6 +234,7 @@ static __always_inline void __write_once_size(volatile void *p, void *res, int s | |||
| 333 | * with an explicit memory barrier or atomic instruction that provides the | 234 | * with an explicit memory barrier or atomic instruction that provides the |
| 334 | * required ordering. | 235 | * required ordering. |
| 335 | */ | 236 | */ |
| 237 | #include <asm/barrier.h> | ||
| 336 | 238 | ||
| 337 | #define __READ_ONCE(x, check) \ | 239 | #define __READ_ONCE(x, check) \ |
| 338 | ({ \ | 240 | ({ \ |
| @@ -341,6 +243,7 @@ static __always_inline void __write_once_size(volatile void *p, void *res, int s | |||
| 341 | __read_once_size(&(x), __u.__c, sizeof(x)); \ | 243 | __read_once_size(&(x), __u.__c, sizeof(x)); \ |
| 342 | else \ | 244 | else \ |
| 343 | __read_once_size_nocheck(&(x), __u.__c, sizeof(x)); \ | 245 | __read_once_size_nocheck(&(x), __u.__c, sizeof(x)); \ |
| 246 | smp_read_barrier_depends(); /* Enforce dependency ordering from x */ \ | ||
| 344 | __u.__val; \ | 247 | __u.__val; \ |
| 345 | }) | 248 | }) |
| 346 | #define READ_ONCE(x) __READ_ONCE(x, 1) | 249 | #define READ_ONCE(x) __READ_ONCE(x, 1) |
| @@ -363,167 +266,6 @@ static __always_inline void __write_once_size(volatile void *p, void *res, int s | |||
| 363 | 266 | ||
| 364 | #endif /* __ASSEMBLY__ */ | 267 | #endif /* __ASSEMBLY__ */ |
| 365 | 268 | ||
| 366 | #ifdef __KERNEL__ | ||
| 367 | /* | ||
| 368 | * Allow us to mark functions as 'deprecated' and have gcc emit a nice | ||
| 369 | * warning for each use, in hopes of speeding the functions removal. | ||
| 370 | * Usage is: | ||
| 371 | * int __deprecated foo(void) | ||
| 372 | */ | ||
| 373 | #ifndef __deprecated | ||
| 374 | # define __deprecated /* unimplemented */ | ||
| 375 | #endif | ||
| 376 | |||
| 377 | #ifdef MODULE | ||
| 378 | #define __deprecated_for_modules __deprecated | ||
| 379 | #else | ||
| 380 | #define __deprecated_for_modules | ||
| 381 | #endif | ||
| 382 | |||
| 383 | #ifndef __must_check | ||
| 384 | #define __must_check | ||
| 385 | #endif | ||
| 386 | |||
| 387 | #ifndef CONFIG_ENABLE_MUST_CHECK | ||
| 388 | #undef __must_check | ||
| 389 | #define __must_check | ||
| 390 | #endif | ||
| 391 | #ifndef CONFIG_ENABLE_WARN_DEPRECATED | ||
| 392 | #undef __deprecated | ||
| 393 | #undef __deprecated_for_modules | ||
| 394 | #define __deprecated | ||
| 395 | #define __deprecated_for_modules | ||
| 396 | #endif | ||
| 397 | |||
| 398 | #ifndef __malloc | ||
| 399 | #define __malloc | ||
| 400 | #endif | ||
| 401 | |||
| 402 | /* | ||
| 403 | * Allow us to avoid 'defined but not used' warnings on functions and data, | ||
| 404 | * as well as force them to be emitted to the assembly file. | ||
| 405 | * | ||
| 406 | * As of gcc 3.4, static functions that are not marked with attribute((used)) | ||
| 407 | * may be elided from the assembly file. As of gcc 3.4, static data not so | ||
| 408 | * marked will not be elided, but this may change in a future gcc version. | ||
| 409 | * | ||
| 410 | * NOTE: Because distributions shipped with a backported unit-at-a-time | ||
| 411 | * compiler in gcc 3.3, we must define __used to be __attribute__((used)) | ||
| 412 | * for gcc >=3.3 instead of 3.4. | ||
| 413 | * | ||
| 414 | * In prior versions of gcc, such functions and data would be emitted, but | ||
| 415 | * would be warned about except with attribute((unused)). | ||
| 416 | * | ||
| 417 | * Mark functions that are referenced only in inline assembly as __used so | ||
| 418 | * the code is emitted even though it appears to be unreferenced. | ||
| 419 | */ | ||
| 420 | #ifndef __used | ||
| 421 | # define __used /* unimplemented */ | ||
| 422 | #endif | ||
| 423 | |||
| 424 | #ifndef __maybe_unused | ||
| 425 | # define __maybe_unused /* unimplemented */ | ||
| 426 | #endif | ||
| 427 | |||
| 428 | #ifndef __always_unused | ||
| 429 | # define __always_unused /* unimplemented */ | ||
| 430 | #endif | ||
| 431 | |||
| 432 | #ifndef noinline | ||
| 433 | #define noinline | ||
| 434 | #endif | ||
| 435 | |||
| 436 | /* | ||
| 437 | * Rather then using noinline to prevent stack consumption, use | ||
| 438 | * noinline_for_stack instead. For documentation reasons. | ||
| 439 | */ | ||
| 440 | #define noinline_for_stack noinline | ||
| 441 | |||
| 442 | #ifndef __always_inline | ||
| 443 | #define __always_inline inline | ||
| 444 | #endif | ||
| 445 | |||
| 446 | #endif /* __KERNEL__ */ | ||
| 447 | |||
| 448 | /* | ||
| 449 | * From the GCC manual: | ||
| 450 | * | ||
| 451 | * Many functions do not examine any values except their arguments, | ||
| 452 | * and have no effects except the return value. Basically this is | ||
| 453 | * just slightly more strict class than the `pure' attribute above, | ||
| 454 | * since function is not allowed to read global memory. | ||
| 455 | * | ||
| 456 | * Note that a function that has pointer arguments and examines the | ||
| 457 | * data pointed to must _not_ be declared `const'. Likewise, a | ||
| 458 | * function that calls a non-`const' function usually must not be | ||
| 459 | * `const'. It does not make sense for a `const' function to return | ||
| 460 | * `void'. | ||
| 461 | */ | ||
| 462 | #ifndef __attribute_const__ | ||
| 463 | # define __attribute_const__ /* unimplemented */ | ||
| 464 | #endif | ||
| 465 | |||
| 466 | #ifndef __designated_init | ||
| 467 | # define __designated_init | ||
| 468 | #endif | ||
| 469 | |||
| 470 | #ifndef __latent_entropy | ||
| 471 | # define __latent_entropy | ||
| 472 | #endif | ||
| 473 | |||
| 474 | #ifndef __randomize_layout | ||
| 475 | # define __randomize_layout __designated_init | ||
| 476 | #endif | ||
| 477 | |||
| 478 | #ifndef __no_randomize_layout | ||
| 479 | # define __no_randomize_layout | ||
| 480 | #endif | ||
| 481 | |||
| 482 | #ifndef randomized_struct_fields_start | ||
| 483 | # define randomized_struct_fields_start | ||
| 484 | # define randomized_struct_fields_end | ||
| 485 | #endif | ||
| 486 | |||
| 487 | /* | ||
| 488 | * Tell gcc if a function is cold. The compiler will assume any path | ||
| 489 | * directly leading to the call is unlikely. | ||
| 490 | */ | ||
| 491 | |||
| 492 | #ifndef __cold | ||
| 493 | #define __cold | ||
| 494 | #endif | ||
| 495 | |||
| 496 | /* Simple shorthand for a section definition */ | ||
| 497 | #ifndef __section | ||
| 498 | # define __section(S) __attribute__ ((__section__(#S))) | ||
| 499 | #endif | ||
| 500 | |||
| 501 | #ifndef __visible | ||
| 502 | #define __visible | ||
| 503 | #endif | ||
| 504 | |||
| 505 | #ifndef __nostackprotector | ||
| 506 | # define __nostackprotector | ||
| 507 | #endif | ||
| 508 | |||
| 509 | /* | ||
| 510 | * Assume alignment of return value. | ||
| 511 | */ | ||
| 512 | #ifndef __assume_aligned | ||
| 513 | #define __assume_aligned(a, ...) | ||
| 514 | #endif | ||
| 515 | |||
| 516 | |||
| 517 | /* Are two types/vars the same type (ignoring qualifiers)? */ | ||
| 518 | #ifndef __same_type | ||
| 519 | # define __same_type(a, b) __builtin_types_compatible_p(typeof(a), typeof(b)) | ||
| 520 | #endif | ||
| 521 | |||
| 522 | /* Is this type a native word size -- useful for atomic operations */ | ||
| 523 | #ifndef __native_word | ||
| 524 | # define __native_word(t) (sizeof(t) == sizeof(char) || sizeof(t) == sizeof(short) || sizeof(t) == sizeof(int) || sizeof(t) == sizeof(long)) | ||
| 525 | #endif | ||
| 526 | |||
| 527 | /* Compile time object size, -1 for unknown */ | 269 | /* Compile time object size, -1 for unknown */ |
| 528 | #ifndef __compiletime_object_size | 270 | #ifndef __compiletime_object_size |
| 529 | # define __compiletime_object_size(obj) -1 | 271 | # define __compiletime_object_size(obj) -1 |
| @@ -605,24 +347,4 @@ static __always_inline void __write_once_size(volatile void *p, void *res, int s | |||
| 605 | (volatile typeof(x) *)&(x); }) | 347 | (volatile typeof(x) *)&(x); }) |
| 606 | #define ACCESS_ONCE(x) (*__ACCESS_ONCE(x)) | 348 | #define ACCESS_ONCE(x) (*__ACCESS_ONCE(x)) |
| 607 | 349 | ||
| 608 | /** | ||
| 609 | * lockless_dereference() - safely load a pointer for later dereference | ||
| 610 | * @p: The pointer to load | ||
| 611 | * | ||
| 612 | * Similar to rcu_dereference(), but for situations where the pointed-to | ||
| 613 | * object's lifetime is managed by something other than RCU. That | ||
| 614 | * "something other" might be reference counting or simple immortality. | ||
| 615 | * | ||
| 616 | * The seemingly unused variable ___typecheck_p validates that @p is | ||
| 617 | * indeed a pointer type by using a pointer to typeof(*p) as the type. | ||
| 618 | * Taking a pointer to typeof(*p) again is needed in case p is void *. | ||
| 619 | */ | ||
| 620 | #define lockless_dereference(p) \ | ||
| 621 | ({ \ | ||
| 622 | typeof(p) _________p1 = READ_ONCE(p); \ | ||
| 623 | typeof(*(p)) *___typecheck_p __maybe_unused; \ | ||
| 624 | smp_read_barrier_depends(); /* Dependency order vs. p above. */ \ | ||
| 625 | (_________p1); \ | ||
| 626 | }) | ||
| 627 | |||
| 628 | #endif /* __LINUX_COMPILER_H */ | 350 | #endif /* __LINUX_COMPILER_H */ |
