[mirror_ubuntu-hirsute-kernel.git] / include / linux / compiler_types.h

/* SPDX-License-Identifier: GPL-2.0 */
#ifndef __LINUX_COMPILER_TYPES_H
#define __LINUX_COMPILER_TYPES_H

#ifndef __ASSEMBLY__

#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)))
extern void __chk_user_ptr(const volatile void __user *);
extern void __chk_io_ptr(const volatile void __iomem *);
/* context/locking */
# define __must_hold(x)	__attribute__((context(x,1,1)))
# define __acquires(x)	__attribute__((context(x,0,1)))
# define __releases(x)	__attribute__((context(x,1,0)))
# define __acquire(x)	__context__(x,1)
# define __release(x)	__context__(x,-1)
# define __cond_lock(x,c)	((c) ? ({ __acquire(x); 1; }) : 0)
/* 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
# endif
# define __iomem
# define __percpu
# define __rcu
# define __chk_user_ptr(x)	(void)0
# define __chk_io_ptr(x)	(void)0
/* context/locking */
# define __must_hold(x)
# define __acquires(x)
# define __releases(x)
# define __acquire(x)	(void)0
# define __release(x)	(void)0
# define __cond_lock(x,c) (c)
/* other */
# define __force
# define __nocast
# define __safe
# define __private
# define ACCESS_PRIVATE(p, member) ((p)->member)
# define __builtin_warning(x, y...) (1)
#endif /* __CHECKER__ */

/* Indirect macros required for expanded argument pasting, eg. __LINE__. */
#define ___PASTE(a,b) a##b
#define __PASTE(a,b) ___PASTE(a,b)

#ifdef __KERNEL__

/* Attributes */
#include <linux/compiler_attributes.h>

/* Compiler specific macros. */
#ifdef __clang__
#include <linux/compiler-clang.h>
#elif defined(__INTEL_COMPILER)
#include <linux/compiler-intel.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;
};

#ifdef CONFIG_ENABLE_MUST_CHECK
#define __must_check		__attribute__((__warn_unused_result__))
#else
#define __must_check
#endif

#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

#define __compiler_offsetof(a, b)	__builtin_offsetof(a, b)

/*
 * 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=1 build. This will allow clang to find unused functions. Remove the
 * __inline_maybe_unused entirely after fixing most of -Wunused-function warnings.
 */
#ifdef KBUILD_EXTRA_WARN1
#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

/*
 * 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

#define __no_kcsan __no_sanitize_thread
#ifdef __SANITIZE_THREAD__
# define __no_sanitize_or_inline __no_kcsan notrace __maybe_unused
#endif

#ifndef __no_sanitize_or_inline
#define __no_sanitize_or_inline __always_inline
#endif

/* Section for code which can't be instrumented at all */
#define noinstr								\
	noinline notrace __attribute((__section__(".noinstr.text")))	\
	__no_kcsan __no_sanitize_address

#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

#ifndef __randomize_layout
# define __randomize_layout __designated_init
#endif

#ifndef __no_randomize_layout
# define __no_randomize_layout
#endif

#ifndef randomized_struct_fields_start
# define randomized_struct_fields_start
# define randomized_struct_fields_end
#endif

#ifndef __noscs
# define __noscs
#endif

#ifndef asm_volatile_goto
#define asm_volatile_goto(x...) asm goto(x)
#endif

#ifdef CONFIG_CC_HAS_ASM_INLINE
#define asm_inline asm __inline
#else
#define asm_inline asm
#endif

#ifndef __no_fgcse
# define __no_fgcse
#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.
 */
/*
 * 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)))

/* 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))

/* Compile time object size, -1 for unknown */
#ifndef __compiletime_object_size
# define __compiletime_object_size(obj) -1
#endif
#ifndef __compiletime_warning
# define __compiletime_warning(message)
#endif
#ifndef __compiletime_error
# define __compiletime_error(message)
#endif

#ifdef __OPTIMIZE__
# define __compiletime_assert(condition, msg, prefix, suffix)		\
	do {								\
		extern void prefix ## suffix(void) __compiletime_error(msg); \
		if (!(condition))					\
			prefix ## suffix();				\
	} while (0)
#else
# define __compiletime_assert(condition, msg, prefix, suffix) do { } while (0)
#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

#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)

#endif /* __LINUX_COMPILER_TYPES_H */
Commit	Line	Data
66dbeef9	1	/* SPDX-License-Identifier: GPL-2.0 */
d1515582 WD	2	#ifndef __LINUX_COMPILER_TYPES_H
	3	#define __LINUX_COMPILER_TYPES_H
	4
	5	#ifndef __ASSEMBLY__
	6
	7	#ifdef __CHECKER__
25fd529c	8	/* address spaces */
d1515582	9	# define __kernel __attribute__((address_space(0)))
670d0a4b	10	# define __user __attribute__((noderef, address_space(__user)))
670d0a4b	11	# define __iomem __attribute__((noderef, address_space(__iomem)))
25fd529c LVO	12	# define __percpu __attribute__((noderef, address_space(__percpu)))
	13	# define __rcu __attribute__((noderef, address_space(__rcu)))
	14	extern void __chk_user_ptr(const volatile void __user *);
	15	extern void __chk_io_ptr(const volatile void __iomem *);
	16	/* context/locking */
d1515582 WD	17	# define __must_hold(x) __attribute__((context(x,1,1)))
	18	# define __acquires(x) __attribute__((context(x,0,1)))
	19	# define __releases(x) __attribute__((context(x,1,0)))
	20	# define __acquire(x) __context__(x,1)
	21	# define __release(x) __context__(x,-1)
	22	# define __cond_lock(x,c) ((c) ? ({ __acquire(x); 1; }) : 0)
25fd529c LVO	23	/* other */
	24	# define __force __attribute__((force))
	25	# define __nocast __attribute__((nocast))
	26	# define __safe __attribute__((safe))
d1515582	27	# define __private __attribute__((noderef))
d1515582 WD	28	# define ACCESS_PRIVATE(p, member) (((typeof((p)->member) __force ) &(p)->member))
d1515582 WD	29	#else /* __CHECKER__ */
25fd529c LVO	30	/* address spaces */
25fd529c LVO	31	# define __kernel
d1515582	32	# ifdef STRUCTLEAK_PLUGIN
25fd529c	33	# define __user __attribute__((user))
d1515582 WD	34	# else
	35	# define __user
	36	# endif
d1515582	37	# define __iomem
25fd529c LVO	38	# define __percpu
	39	# define __rcu
	40	# define __chk_user_ptr(x) (void)0
	41	# define __chk_io_ptr(x) (void)0
	42	/* context/locking */
d1515582 WD	43	# define __must_hold(x)
	44	# define __acquires(x)
	45	# define __releases(x)
25fd529c LVO	46	# define __acquire(x) (void)0
25fd529c LVO	47	# define __release(x) (void)0
d1515582	48	# define __cond_lock(x,c) (c)
25fd529c LVO	49	/* other */
	50	# define __force
	51	# define __nocast
	52	# define __safe
d1515582 WD	53	# define __private
d1515582 WD	54	# define ACCESS_PRIVATE(p, member) ((p)->member)
25fd529c	55	# define __builtin_warning(x, y...) (1)
d1515582 WD	56	#endif /* __CHECKER__ */
	57
	58	/* Indirect macros required for expanded argument pasting, eg. __LINE__. */
	59	#define ___PASTE(a,b) a##b
	60	#define __PASTE(a,b) ___PASTE(a,b)
	61
	62	#ifdef __KERNEL__
	63
a3f8a30f MO	64	/* Attributes */
	65	#include <linux/compiler_attributes.h>
	66
815f0ddb	67	/* Compiler specific macros. */
d1515582 WD	68	#ifdef __clang__
d1515582 WD	69	#include <linux/compiler-clang.h>
815f0ddb ND	70	#elif defined(__INTEL_COMPILER)
	71	#include <linux/compiler-intel.h>
	72	#elif defined(__GNUC__)
	73	/* The above compilers also define __GNUC__, so order is important here. */
	74	#include <linux/compiler-gcc.h>
	75	#else
	76	#error "Unknown compiler"
d1515582 WD	77	#endif
d1515582 WD	78
04f264d3 PB	79	/*
	80	* Some architectures need to provide custom definitions of macros provided
	81	* by linux/compiler-*.h, and can do so using asm/compiler.h. We include that
	82	* conditionally rather than using an asm-generic wrapper in order to avoid
	83	* build failures if any C compilation, which will include this file via an
	84	* -include argument in c_flags, occurs prior to the asm-generic wrappers being
	85	* generated.
	86	*/
	87	#ifdef CONFIG_HAVE_ARCH_COMPILER_H
	88	#include <asm/compiler.h>
	89	#endif
	90
d1515582 WD	91	struct ftrace_branch_data {
	92	const char *func;
	93	const char *file;
	94	unsigned line;
	95	union {
	96	struct {
	97	unsigned long correct;
	98	unsigned long incorrect;
	99	};
	100	struct {
	101	unsigned long miss;
	102	unsigned long hit;
	103	};
	104	unsigned long miss_hit[2];
	105	};
	106	};
	107
	108	struct ftrace_likely_data {
	109	struct ftrace_branch_data data;
	110	unsigned long constant;
	111	};
	112
71391bdd XL	113	#ifdef CONFIG_ENABLE_MUST_CHECK
	114	#define __must_check __attribute__((__warn_unused_result__))
	115	#else
	116	#define __must_check
	117	#endif
	118
	119	#if defined(CC_USING_HOTPATCH)
	120	#define notrace __attribute__((hotpatch(0, 0)))
2809b392 SS	121	#elif defined(CC_USING_PATCHABLE_FUNCTION_ENTRY)
2809b392 SS	122	#define notrace __attribute__((patchable_function_entry(0, 0)))
71391bdd XL	123	#else
	124	#define notrace __attribute__((__no_instrument_function__))
	125	#endif
	126
	127	/*
	128	* it doesn't make sense on ARM (currently the only user of __naked)
	129	* to trace naked functions because then mcount is called without
	130	* stack and frame pointer being set up and there is no chance to
	131	* restore the lr register to the value before mcount was called.
	132	*/
	133	#define __naked __attribute__((__naked__)) notrace
	134
	135	#define __compiler_offsetof(a, b) __builtin_offsetof(a, b)
	136
	137	/*
71391bdd XL	138	* Prefer gnu_inline, so that extern inline functions do not emit an
	139	* externally visible function. This makes extern inline behave as per gnu89
	140	* semantics rather than c99. This prevents multiple symbol definition errors
	141	* of extern inline functions at link time.
	142	* A lot of inline functions can cause havoc with function tracing.
71391bdd	143	*/
889b3c12	144	#define inline inline __gnu_inline __inline_maybe_unused notrace
71391bdd	145
c30724e9 RV	146	/*
	147	* gcc provides both __inline__ and __inline as alternate spellings of
	148	* the inline keyword, though the latter is undocumented. New kernel
	149	* code should only use the inline spelling, but some existing code
	150	* uses __inline__. Since we #define inline above, to ensure
	151	* __inline__ has the same semantics, we need this #define.
	152	*
	153	* However, the spelling __inline is strictly reserved for referring
	154	* to the bare keyword.
	155	*/
71391bdd	156	#define __inline__ inline
71391bdd	157
6863f564 MY	158	/*
	159	* GCC does not warn about unused static inline functions for -Wunused-function.
	160	* Suppress the warning in clang as well by using __maybe_unused, but enable it
	161	* for W=1 build. This will allow clang to find unused functions. Remove the
	162	* __inline_maybe_unused entirely after fixing most of -Wunused-function warnings.
	163	*/
	164	#ifdef KBUILD_EXTRA_WARN1
	165	#define __inline_maybe_unused
	166	#else
	167	#define __inline_maybe_unused __maybe_unused
	168	#endif
	169
71391bdd XL	170	/*
	171	* Rather then using noinline to prevent stack consumption, use
	172	* noinline_for_stack instead. For documentation reasons.
	173	*/
	174	#define noinline_for_stack noinline
	175
1f44328e ME	176	/*
	177	* Sanitizer helper attributes: Because using __always_inline and
	178	* __no_sanitize_* conflict, provide helper attributes that will either expand
	179	* to __no_sanitize_* in compilation units where instrumentation is enabled
	180	* (__SANITIZE_*__), or __always_inline in compilation units without
	181	* instrumentation (__SANITIZE_*__ undefined).
	182	*/
	183	#ifdef __SANITIZE_ADDRESS__
eb73876c ME	184	/*
	185	* We can't declare function 'inline' because __no_sanitize_address conflicts
	186	* with inlining. Attempt to inline it may cause a build failure.
	187	* https://gcc.gnu.org/bugzilla/show_bug.cgi?id=67368
	188	* '__maybe_unused' allows us to avoid defined-but-not-used warnings.
	189	*/
	190	# define __no_kasan_or_inline __no_sanitize_address notrace __maybe_unused
	191	# define __no_sanitize_or_inline __no_kasan_or_inline
	192	#else
	193	# define __no_kasan_or_inline __always_inline
	194	#endif
	195
	196	#define __no_kcsan __no_sanitize_thread
	197	#ifdef __SANITIZE_THREAD__
e79302ae	198	# define __no_sanitize_or_inline __no_kcsan notrace __maybe_unused
eb73876c ME	199	#endif
	200
	201	#ifndef __no_sanitize_or_inline
	202	#define __no_sanitize_or_inline __always_inline
	203	#endif
	204
5ddbc408 PZ	205	/* Section for code which can't be instrumented at all */
5ddbc408 PZ	206	#define noinstr \
5144f8a8	207	noinline notrace __attribute((__section__(".noinstr.text"))) \
6b643a07	208	__no_kcsan __no_sanitize_address
5ddbc408	209
d1515582 WD	210	#endif /* __KERNEL__ */
d1515582 WD	211
815f0ddb ND	212	#endif /* __ASSEMBLY__ */
815f0ddb ND	213
d1515582	214	/*
815f0ddb ND	215	* The below symbols may be defined for one or more, but not ALL, of the above
	216	* compilers. We don't consider that to be an error, so set them to nothing.
	217	* For example, some of them are for compiler specific plugins.
d1515582	218	*/
d1515582 WD	219	#ifndef __latent_entropy
	220	# define __latent_entropy
	221	#endif
	222
	223	#ifndef __randomize_layout
	224	# define __randomize_layout __designated_init
	225	#endif
	226
	227	#ifndef __no_randomize_layout
	228	# define __no_randomize_layout
	229	#endif
	230
	231	#ifndef randomized_struct_fields_start
	232	# define randomized_struct_fields_start
	233	# define randomized_struct_fields_end
	234	#endif
	235
d08b9f0c ST	236	#ifndef __noscs
	237	# define __noscs
	238	#endif
	239
8bd66d14	240	#ifndef asm_volatile_goto
	241	#define asm_volatile_goto(x...) asm goto(x)
	242	#endif
	243
eb111869 RV	244	#ifdef CONFIG_CC_HAS_ASM_INLINE
	245	#define asm_inline asm __inline
	246	#else
	247	#define asm_inline asm
	248	#endif
	249
3193c083 JP	250	#ifndef __no_fgcse
	251	# define __no_fgcse
	252	#endif
	253
d1515582	254	/* Are two types/vars the same type (ignoring qualifiers)? */
815f0ddb	255	#define __same_type(a, b) __builtin_types_compatible_p(typeof(a), typeof(b))
d1515582	256
dee081bf WD	257	/*
	258	* __unqual_scalar_typeof(x) - Declare an unqualified scalar type, leaving
	259	* non-scalar types unchanged.
1fd76043	260	*/
1fd76043	261	/*
6ec4476a	262	* Prefer C11 _Generic for better compile-times and simpler code. Note: 'char'
1fd76043 ME	263	* is not type-compatible with 'signed char', and we define a separate case.
	264	*/
	265	#define __scalar_type_to_expr_cases(type) \
	266	unsigned type: (unsigned type)0, \
	267	signed type: (signed type)0
	268
	269	#define __unqual_scalar_typeof(x) typeof( \
	270	_Generic((x), \
	271	char: (char)0, \
	272	__scalar_type_to_expr_cases(char), \
	273	__scalar_type_to_expr_cases(short), \
	274	__scalar_type_to_expr_cases(int), \
	275	__scalar_type_to_expr_cases(long), \
	276	__scalar_type_to_expr_cases(long long), \
	277	default: (x)))
dee081bf	278
d1515582	279	/* Is this type a native word size -- useful for atomic operations */
815f0ddb ND	280	#define __native_word(t) \
	281	(sizeof(t) == sizeof(char) \|\| sizeof(t) == sizeof(short) \|\| \
	282	sizeof(t) == sizeof(int) \|\| sizeof(t) == sizeof(long))
	283
eb5c2d4b WD	284	/* Compile time object size, -1 for unknown */
	285	#ifndef __compiletime_object_size
	286	# define __compiletime_object_size(obj) -1
	287	#endif
	288	#ifndef __compiletime_warning
	289	# define __compiletime_warning(message)
	290	#endif
	291	#ifndef __compiletime_error
	292	# define __compiletime_error(message)
	293	#endif
	294
	295	#ifdef __OPTIMIZE__
	296	# define __compiletime_assert(condition, msg, prefix, suffix) \
	297	do { \
	298	extern void prefix ## suffix(void) __compiletime_error(msg); \
	299	if (!(condition)) \
	300	prefix ## suffix(); \
	301	} while (0)
	302	#else
	303	# define __compiletime_assert(condition, msg, prefix, suffix) do { } while (0)
	304	#endif
	305
	306	#define _compiletime_assert(condition, msg, prefix, suffix) \
	307	__compiletime_assert(condition, msg, prefix, suffix)
	308
	309	/**
	310	* compiletime_assert - break build and emit msg if condition is false
	311	* @condition: a compile-time constant condition to check
	312	* @msg: a message to emit if condition is false
	313	*
	314	* In tradition of POSIX assert, this macro will break the build if the
	315	* supplied condition is false, emitting the supplied error message if the
	316	* compiler has support to do so.
	317	*/
	318	#define compiletime_assert(condition, msg) \
	319	_compiletime_assert(condition, msg, __compiletime_assert_, __COUNTER__)
	320
	321	#define compiletime_assert_atomic_type(t) \
	322	compiletime_assert(__native_word(t), \
	323	"Need native word sized stores/loads for atomicity.")
	324
815f0ddb	325	/* Helpers for emitting diagnostics in pragmas. */
8793bb7f AB	326	#ifndef __diag
	327	#define __diag(string)
	328	#endif
	329
	330	#ifndef __diag_GCC
	331	#define __diag_GCC(version, severity, string)
	332	#endif
	333
	334	#define __diag_push() __diag(push)
	335	#define __diag_pop() __diag(pop)
	336
	337	#define __diag_ignore(compiler, version, option, comment) \
	338	__diag_ ## compiler(version, ignore, option)
	339	#define __diag_warn(compiler, version, option, comment) \
	340	__diag_ ## compiler(version, warn, option)
	341	#define __diag_error(compiler, version, option, comment) \
	342	__diag_ ## compiler(version, error, option)
	343
d1515582	344	#endif /* __LINUX_COMPILER_TYPES_H */