Something went wrong. Try again.
(I'm so sorry!) Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
Something went wrong. Try again.
C
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736/* SPDX-License-Identifier: GPL-2.0 */#ifndef __LINUX_COMPILER_TYPES_H#define __LINUX_COMPILER_TYPES_H
/* * __has_builtin is supported on gcc >= 10, clang >= 3 and icc >= 21. * In the meantime, to support gcc < 10, we implement __has_builtin * by hand. */#ifndef __has_builtin#define __has_builtin(x) (0)#endif
/* Indirect macros required for expanded argument pasting, eg. __LINE__. */#define ___PASTE(a, b) a##b#define __PASTE(a, b) ___PASTE(a, b)
#ifndef __ASSEMBLY__
/* * C23 introduces "auto" as a standard way to define type-inferred * variables, but "auto" has been a (useless) keyword even since K&R C, * so it has always been "namespace reserved." * * Until at some future time we require C23 support, we need the gcc * extension __auto_type, but there is no reason to put that elsewhere * in the source code. */#if __STDC_VERSION__ < 202311L# define auto __auto_type#endif
/* * Skipped when running bindgen due to a libclang issue; * see https://github.com/rust-lang/rust-bindgen/issues/2244. */#if defined(CONFIG_DEBUG_INFO_BTF) && defined(CONFIG_PAHOLE_HAS_BTF_TAG) && \ __has_attribute(btf_type_tag) && !defined(__BINDGEN__)# define BTF_TYPE_TAG(value) __attribute__((btf_type_tag(#value)))#else# define BTF_TYPE_TAG(value) /* nothing */#endif
#include <linux/compiler-context-analysis.h>
/* sparse defines __CHECKER__; see Documentation/dev-tools/sparse.rst */#ifdef __CHECKER__/* address spaces */# define __kernel __attribute__((address_space(0)))# define __user __attribute__((noderef, address_space(__user)))# define __iomem __attribute__((noderef, address_space(__iomem)))# define __percpu __attribute__((noderef, address_space(__percpu)))# define __rcu __attribute__((noderef, address_space(__rcu)))static inline void __chk_user_ptr(const volatile void __user *ptr) { }static inline void __chk_io_ptr(const volatile void __iomem *ptr) { }/* other */# define __force __attribute__((force))# define __nocast __attribute__((nocast))# define __safe __attribute__((safe))# define __private __attribute__((noderef))# define ACCESS_PRIVATE(p, member) (*((typeof((p)->member) __force *) &(p)->member))#else /* __CHECKER__ *//* address spaces */# define __kernel# ifdef STRUCTLEAK_PLUGIN# define __user __attribute__((user))# else# define __user BTF_TYPE_TAG(user)# endif# define __iomem# define __percpu __percpu_qual BTF_TYPE_TAG(percpu)# define __rcu BTF_TYPE_TAG(rcu)
# define __chk_user_ptr(x) (void)0# define __chk_io_ptr(x) (void)0/* other */# define __force# define __nocast# define __safe# define __private# define ACCESS_PRIVATE(p, member) ((p)->member)# define __builtin_warning(x, y...) (1)#endif /* __CHECKER__ */
#ifdef __KERNEL__
/* Attributes */#include <linux/compiler_attributes.h>
#if CONFIG_FUNCTION_ALIGNMENT > 0#define __function_aligned __aligned(CONFIG_FUNCTION_ALIGNMENT)#else#define __function_aligned#endif
/* * gcc: https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html#index-cold-function-attribute * gcc: https://gcc.gnu.org/onlinedocs/gcc/Label-Attributes.html#index-cold-label-attribute * * When -falign-functions=N is in use, we must avoid the cold attribute as * GCC drops the alignment for cold functions. Worse, GCC can implicitly mark * callees of cold functions as cold themselves, so it's not sufficient to add * __function_aligned here as that will not ensure that callees are correctly * aligned. * * See: * * https://lore.kernel.org/lkml/Y77%2FqVgvaJidFpYt@FVFF77S0Q05N * https://gcc.gnu.org/bugzilla/show_bug.cgi?id=88345#c9 */#if defined(CONFIG_CC_HAS_SANE_FUNCTION_ALIGNMENT) || (CONFIG_FUNCTION_ALIGNMENT == 0)#define __cold __attribute__((__cold__))#else#define __cold#endif
/* * On x86-64 and arm64 targets, __preserve_most changes the calling convention * of a function to make the code in the caller as unintrusive as possible. This * convention behaves identically to the C calling convention on how arguments * and return values are passed, but uses a different set of caller- and callee- * saved registers. * * The purpose is to alleviates the burden of saving and recovering a large * register set before and after the call in the caller. This is beneficial for * rarely taken slow paths, such as error-reporting functions that may be called * from hot paths. * * Note: This may conflict with instrumentation inserted on function entry which * does not use __preserve_most or equivalent convention (if in assembly). Since * function tracing assumes the normal C calling convention, where the attribute * is supported, __preserve_most implies notrace. It is recommended to restrict * use of the attribute to functions that should or already disable tracing. * * Optional: not supported by gcc. * * clang: https://clang.llvm.org/docs/AttributeReference.html#preserve-most */#if __has_attribute(__preserve_most__) && (defined(CONFIG_X86_64) || defined(CONFIG_ARM64))# define __preserve_most notrace __attribute__((__preserve_most__))#else# define __preserve_most#endif
/* * Annotating a function/variable with __retain tells the compiler to place * the object in its own section and set the flag SHF_GNU_RETAIN. This flag * instructs the linker to retain the object during garbage-cleanup or LTO * phases. * * Note that the __used macro is also used to prevent functions or data * being optimized out, but operates at the compiler/IR-level and may still * allow unintended removal of objects during linking. * * Optional: only supported since gcc >= 11, clang >= 13 * * gcc: https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html#index-retain-function-attribute * clang: https://clang.llvm.org/docs/AttributeReference.html#retain */#if __has_attribute(__retain__) && \ (defined(CONFIG_LD_DEAD_CODE_DATA_ELIMINATION) || \ defined(CONFIG_LTO_CLANG))# define __retain __attribute__((__retain__))#else# define __retain#endif
/* Compiler specific macros. */#ifdef __clang__#include <linux/compiler-clang.h>#elif defined(__GNUC__)/* The above compilers also define __GNUC__, so order is important here. */#include <linux/compiler-gcc.h>#else#error "Unknown compiler"#endif
/* * Some architectures need to provide custom definitions of macros provided * by linux/compiler-*.h, and can do so using asm/compiler.h. We include that * conditionally rather than using an asm-generic wrapper in order to avoid * build failures if any C compilation, which will include this file via an * -include argument in c_flags, occurs prior to the asm-generic wrappers being * generated. */#ifdef CONFIG_HAVE_ARCH_COMPILER_H#include <asm/compiler.h>#endif
struct ftrace_branch_data { const char *func; const char *file; unsigned line; union { struct { unsigned long correct; unsigned long incorrect; }; struct { unsigned long miss; unsigned long hit; }; unsigned long miss_hit[2]; };};
struct ftrace_likely_data { struct ftrace_branch_data data; unsigned long constant;};
#if defined(CC_USING_HOTPATCH)#define notrace __attribute__((hotpatch(0, 0)))#elif defined(CC_USING_PATCHABLE_FUNCTION_ENTRY)#define notrace __attribute__((patchable_function_entry(0, 0)))#else#define notrace __attribute__((__no_instrument_function__))#endif
/* * it doesn't make sense on ARM (currently the only user of __naked) * to trace naked functions because then mcount is called without * stack and frame pointer being set up and there is no chance to * restore the lr register to the value before mcount was called. */#define __naked __attribute__((__naked__)) notrace
/* * Prefer gnu_inline, so that extern inline functions do not emit an * externally visible function. This makes extern inline behave as per gnu89 * semantics rather than c99. This prevents multiple symbol definition errors * of extern inline functions at link time. * A lot of inline functions can cause havoc with function tracing. */#define inline inline __gnu_inline __inline_maybe_unused notrace
/* * gcc provides both __inline__ and __inline as alternate spellings of * the inline keyword, though the latter is undocumented. New kernel * code should only use the inline spelling, but some existing code * uses __inline__. Since we #define inline above, to ensure * __inline__ has the same semantics, we need this #define. * * However, the spelling __inline is strictly reserved for referring * to the bare keyword. */#define __inline__ inline
/* * GCC does not warn about unused static inline functions for -Wunused-function. * Suppress the warning in clang as well by using __maybe_unused, but enable it * for W=2 build. This will allow clang to find unused functions. */#ifdef KBUILD_EXTRA_WARN2#define __inline_maybe_unused#else#define __inline_maybe_unused __maybe_unused#endif
/* * Rather then using noinline to prevent stack consumption, use * noinline_for_stack instead. For documentation reasons. */#define noinline_for_stack noinline
/* * Use noinline_for_tracing for functions that should not be inlined. * For tracing reasons. */#define noinline_for_tracing noinline
/* * Sanitizer helper attributes: Because using __always_inline and * __no_sanitize_* conflict, provide helper attributes that will either expand * to __no_sanitize_* in compilation units where instrumentation is enabled * (__SANITIZE_*__), or __always_inline in compilation units without * instrumentation (__SANITIZE_*__ undefined). */#ifdef __SANITIZE_ADDRESS__/* * We can't declare function 'inline' because __no_sanitize_address conflicts * with inlining. Attempt to inline it may cause a build failure. * https://gcc.gnu.org/bugzilla/show_bug.cgi?id=67368 * '__maybe_unused' allows us to avoid defined-but-not-used warnings. */# define __no_kasan_or_inline __no_sanitize_address notrace __maybe_unused# define __no_sanitize_or_inline __no_kasan_or_inline#else# define __no_kasan_or_inline __always_inline#endif
#ifdef CONFIG_KCSAN/* * Type qualifier to mark variables where all data-racy accesses should be * ignored by KCSAN. Note, the implementation simply marks these variables as * volatile, since KCSAN will treat such accesses as "marked". * * Defined here because defining __data_racy as volatile for KCSAN objects only * causes problems in BPF Type Format (BTF) generation since struct members * of core kernel data structs will be volatile in some objects and not in * others. Instead define it globally for KCSAN kernels. */# define __data_racy volatile#else# define __data_racy#endif
#ifdef __SANITIZE_THREAD__/* * Clang still emits instrumentation for __tsan_func_{entry,exit}() and builtin * atomics even with __no_sanitize_thread (to avoid false positives in userspace * ThreadSanitizer). The kernel's requirements are stricter and we really do not * want any instrumentation with __no_kcsan. * * Therefore we add __disable_sanitizer_instrumentation where available to * disable all instrumentation. See Kconfig.kcsan where this is mandatory. */# define __no_kcsan __no_sanitize_thread __disable_sanitizer_instrumentation# define __no_sanitize_or_inline __no_kcsan notrace __maybe_unused#else# define __no_kcsan#endif
#ifdef __SANITIZE_MEMORY__/* * Similarly to KASAN and KCSAN, KMSAN loses function attributes of inlined * functions, therefore disabling KMSAN checks also requires disabling inlining. * * __no_sanitize_or_inline effectively prevents KMSAN from reporting errors * within the function and marks all its outputs as initialized. */# define __no_sanitize_or_inline __no_kmsan_checks notrace __maybe_unused#endif
#ifndef __no_sanitize_or_inline#define __no_sanitize_or_inline __always_inline#endif
/* * The assume attribute is used to indicate that a certain condition is * assumed to be true. If this condition is violated at runtime, the behavior * is undefined. Compilers may or may not use this indication to generate * optimized code. * * Note that the clang documentation states that optimizers may react * differently to this attribute, and this may even have a negative * performance impact. Therefore this attribute should be used with care. * * Optional: only supported since gcc >= 13 * Optional: only supported since clang >= 19 * * gcc: https://gcc.gnu.org/onlinedocs/gcc/Statement-Attributes.html#index-assume-statement-attribute * clang: https://clang.llvm.org/docs/AttributeReference.html#id13 * */#ifdef CONFIG_CC_HAS_ASSUME# define __assume(expr) __attribute__((__assume__(expr)))#else# define __assume(expr)#endif
/* * Optional: only supported since gcc >= 15 * Optional: only supported since clang >= 18 * * gcc: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=108896 * clang: https://clang.llvm.org/docs/AttributeReference.html#counted-by-counted-by-or-null-sized-by-sized-by-or-null * * __bdos on clang < 19.1.2 can erroneously return 0: * https://github.com/llvm/llvm-project/pull/110497 * * __bdos on clang < 19.1.3 can be off by 4: * https://github.com/llvm/llvm-project/pull/112636 */#ifdef CONFIG_CC_HAS_COUNTED_BY# define __counted_by(member) __attribute__((__counted_by__(member)))#else# define __counted_by(member)#endif
/* * Runtime track number of objects pointed to by a pointer member for use by * CONFIG_FORTIFY_SOURCE and CONFIG_UBSAN_BOUNDS. * * Optional: only supported since gcc >= 16 * Optional: only supported since clang >= 22 * * gcc: https://gcc.gnu.org/pipermail/gcc-patches/2025-April/681727.html * clang: https://clang.llvm.org/docs/AttributeReference.html#counted-by-counted-by-or-null-sized-by-sized-by-or-null */#ifdef CONFIG_CC_HAS_COUNTED_BY_PTR#define __counted_by_ptr(member) __attribute__((__counted_by__(member)))#else#define __counted_by_ptr(member)#endif
/* * Optional: only supported since gcc >= 15 * Optional: not supported by Clang * * gcc: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=117178 */#ifdef CONFIG_CC_HAS_MULTIDIMENSIONAL_NONSTRING# define __nonstring_array __attribute__((__nonstring__))#else# define __nonstring_array#endif
/* * Apply __counted_by() when the Endianness matches to increase test coverage. */#ifdef __LITTLE_ENDIAN#define __counted_by_le(member) __counted_by(member)#define __counted_by_be(member)#else#define __counted_by_le(member)#define __counted_by_be(member) __counted_by(member)#endif
/* * This designates the minimum number of elements a passed array parameter must * have. For example: * * void some_function(u8 param[at_least 7]); * * If a caller passes an array with fewer than 7 elements, the compiler will * emit a warning. */#ifndef __CHECKER__#define at_least static#else#define at_least#endif
/* Section for code which can't be instrumented at all */#define __noinstr_section(section) \ noinline notrace __attribute((__section__(section))) \ __no_kcsan __no_sanitize_address __no_profile __no_sanitize_coverage \ __no_sanitize_memory
#define noinstr __noinstr_section(".noinstr.text")
/* * The __cpuidle section is used twofold: * * 1) the original use -- identifying if a CPU is 'stuck' in idle state based * on it's instruction pointer. See cpu_in_idle(). * * 2) supressing instrumentation around where cpuidle disables RCU; where the * function isn't strictly required for #1, this is interchangeable with * noinstr. */#define __cpuidle __noinstr_section(".cpuidle.text")
#endif /* __KERNEL__ */
#endif /* __ASSEMBLY__ */
/* * The below symbols may be defined for one or more, but not ALL, of the above * compilers. We don't consider that to be an error, so set them to nothing. * For example, some of them are for compiler specific plugins. */#ifndef __latent_entropy# define __latent_entropy#endif
#if defined(RANDSTRUCT) && !defined(__CHECKER__)# define __randomize_layout __designated_init __attribute__((randomize_layout))# define __no_randomize_layout __attribute__((no_randomize_layout))/* This anon struct can add padding, so only enable it under randstruct. */# define randomized_struct_fields_start struct {# define randomized_struct_fields_end } __randomize_layout;#else# define __randomize_layout __designated_init# define __no_randomize_layout# define randomized_struct_fields_start# define randomized_struct_fields_end#endif
#ifndef __no_kstack_erase# define __no_kstack_erase#endif
#ifndef __noscs# define __noscs#endif
#if defined(CONFIG_CFI)# define __nocfi __attribute__((__no_sanitize__("kcfi")))#else# define __nocfi#endif
#if defined(CONFIG_ARCH_USES_CFI_GENERIC_LLVM_PASS)# define __nocfi_generic __nocfi#else# define __nocfi_generic#endif
/* * Any place that could be marked with the "alloc_size" attribute is also * a place to be marked with the "malloc" attribute, except those that may * be performing a _reallocation_, as that may alias the existing pointer. * For these, use __realloc_size(). */#ifdef __alloc_size__# define __alloc_size(x, ...) __alloc_size__(x, ## __VA_ARGS__) __malloc# define __realloc_size(x, ...) __alloc_size__(x, ## __VA_ARGS__)#else# define __alloc_size(x, ...) __malloc# define __realloc_size(x, ...)#endif
/* * When the size of an allocated object is needed, use the best available * mechanism to find it. (For cases where sizeof() cannot be used.) * * Optional: only supported since gcc >= 12 * * gcc: https://gcc.gnu.org/onlinedocs/gcc/Object-Size-Checking.html * clang: https://clang.llvm.org/docs/LanguageExtensions.html#evaluating-object-size */#if __has_builtin(__builtin_dynamic_object_size)#define __struct_size(p) __builtin_dynamic_object_size(p, 0)#define __member_size(p) __builtin_dynamic_object_size(p, 1)#else#define __struct_size(p) __builtin_object_size(p, 0)#define __member_size(p) __builtin_object_size(p, 1)#endif
/* * Determine if an attribute has been applied to a variable. * Using __annotated needs to check for __annotated being available, * or negative tests may fail when annotation cannot be checked. For * example, see the definition of __is_cstr(). */#if __has_builtin(__builtin_has_attribute)#define __annotated(var, attr) __builtin_has_attribute(var, attr)#endif
/* * Optional: only supported since gcc >= 15, clang >= 19 * * gcc: https://gcc.gnu.org/onlinedocs/gcc/Other-Builtins.html#index-_005f_005fbuiltin_005fcounted_005fby_005fref * clang: https://clang.llvm.org/docs/LanguageExtensions.html#builtin-counted-by-ref */#if __has_builtin(__builtin_counted_by_ref) && \ !defined(CONFIG_CC_HAS_BROKEN_COUNTED_BY_REF)/** * __flex_counter() - Get pointer to counter member for the given * flexible array, if it was annotated with __counted_by() * @FAM: Pointer to flexible array member of an addressable struct instance * * For example, with: * * struct foo { * int counter; * short array[] __counted_by(counter); * } *p; * * __flex_counter(p->array) will resolve to &p->counter. * * Note that Clang may not allow this to be assigned to a separate * variable; it must be used directly. * * If p->array is unannotated, this returns (void *)NULL. */#define __flex_counter(FAM) __builtin_counted_by_ref(FAM)#else#define __flex_counter(FAM) ((void *)NULL)#endif
/* * Some versions of gcc do not mark 'asm goto' volatile: * * https://gcc.gnu.org/bugzilla/show_bug.cgi?id=103979 * * We do it here by hand, because it doesn't hurt. */#ifndef asm_goto_output#define asm_goto_output(x...) asm volatile goto(x)#endif
/* * Clang has trouble with constraints with multiple * alternative behaviors ("g" , "rm" and "=rm"). */#ifndef ASM_INPUT_G #define ASM_INPUT_G "g" #define ASM_INPUT_RM "rm" #define ASM_OUTPUT_RM "=rm"#endif
#ifdef CONFIG_CC_HAS_ASM_INLINE#define asm_inline asm __inline#else#define asm_inline asm#endif
#ifndef __ASSEMBLY__/* * Use __typeof_unqual__() when available. */#if CC_HAS_TYPEOF_UNQUAL || defined(__CHECKER__)# define USE_TYPEOF_UNQUAL 1#endif
/* Are two types/vars the same type (ignoring qualifiers)? */#define __same_type(a, b) __builtin_types_compatible_p(typeof(a), typeof(b))
/* * __unqual_scalar_typeof(x) - Declare an unqualified scalar type, leaving * non-scalar types unchanged. */#ifndef USE_TYPEOF_UNQUAL/* * Prefer C11 _Generic for better compile-times and simpler code. Note: 'char' * is not type-compatible with 'signed char', and we define a separate case. */#define __scalar_type_to_expr_cases(type) \ unsigned type: (unsigned type)0, \ signed type: (signed type)0
#define __unqual_scalar_typeof(x) typeof( \ _Generic((x), \ char: (char)0, \ __scalar_type_to_expr_cases(char), \ __scalar_type_to_expr_cases(short), \ __scalar_type_to_expr_cases(int), \ __scalar_type_to_expr_cases(long), \ __scalar_type_to_expr_cases(long long), \ default: (x)))#else#define __unqual_scalar_typeof(x) __typeof_unqual__(x)#endif
#include <asm/percpu_types.h>
#endif /* !__ASSEMBLY__ */
/* * __signed_scalar_typeof(x) - Declare a signed scalar type, leaving * non-scalar types unchanged. */
#define __scalar_type_to_signed_cases(type) \ unsigned type: (signed type)0, \ signed type: (signed type)0
#define __signed_scalar_typeof(x) typeof( \ _Generic((x), \ char: (signed char)0, \ __scalar_type_to_signed_cases(char), \ __scalar_type_to_signed_cases(short), \ __scalar_type_to_signed_cases(int), \ __scalar_type_to_signed_cases(long), \ __scalar_type_to_signed_cases(long long), \ default: (x)))
/* Is this type a native word size -- useful for atomic operations */#define __native_word(t) \ (sizeof(t) == sizeof(char) || sizeof(t) == sizeof(short) || \ sizeof(t) == sizeof(int) || sizeof(t) == sizeof(long))
#ifdef __OPTIMIZE__/* * #ifdef __OPTIMIZE__ is only a good approximation; for instance "make * CFLAGS_foo.o=-Og" defines __OPTIMIZE__, does not elide the conditional code * and can break compilation with wrong error message(s). Combine with * -U__OPTIMIZE__ when needed. */# define __compiletime_assert(condition, msg, prefix, suffix) \ do { \ /* \ * __noreturn is needed to give the compiler enough \ * information to avoid certain possibly-uninitialized \ * warnings (regardless of the build failing). \ */ \ __noreturn extern void prefix ## suffix(void) \ __compiletime_error(msg); \ if (!(condition)) \ prefix ## suffix(); \ } while (0)#else# define __compiletime_assert(condition, msg, prefix, suffix) ((void)(condition))#endif
#define _compiletime_assert(condition, msg, prefix, suffix) \ __compiletime_assert(condition, msg, prefix, suffix)
/** * compiletime_assert - break build and emit msg if condition is false * @condition: a compile-time constant condition to check * @msg: a message to emit if condition is false * * In tradition of POSIX assert, this macro will break the build if the * supplied condition is *false*, emitting the supplied error message if the * compiler has support to do so. */#define compiletime_assert(condition, msg) \ _compiletime_assert(condition, msg, __compiletime_assert_, __COUNTER__)
#define compiletime_assert_atomic_type(t) \ compiletime_assert(__native_word(t), \ "Need native word sized stores/loads for atomicity.")
/* Helpers for emitting diagnostics in pragmas. */#ifndef __diag#define __diag(string)#endif
#ifndef __diag_GCC#define __diag_GCC(version, severity, string)#endif
#ifndef __diag_clang#define __diag_clang(version, severity, string)#endif
#define __diag_push() __diag(push)#define __diag_pop() __diag(pop)
#define __diag_ignore(compiler, version, option, comment) \ __diag_ ## compiler(version, ignore, option)#define __diag_warn(compiler, version, option, comment) \ __diag_ ## compiler(version, warn, option)#define __diag_error(compiler, version, option, comment) \ __diag_ ## compiler(version, error, option)
#ifndef __diag_ignore_all#define __diag_ignore_all(option, comment)#endif
#endif /* __LINUX_COMPILER_TYPES_H */