WebSVN – Kolibri OS – Diff – /drivers/include/linux/compiler.h


#ifndef __LINUX_COMPILER_H
#define __LINUX_COMPILER_H
 
#ifndef __ASSEMBLY__
 
#ifdef __CHECKER__
# define __user		__attribute__((noderef, address_space(1)))
# define __kernel	__attribute__((address_space(0)))
# define __safe		__attribute__((safe))
# define __force	__attribute__((force))
# define __nocast	__attribute__((nocast))
# define __iomem	__attribute__((noderef, address_space(2)))
# 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)
# define __percpu	__attribute__((noderef, address_space(3)))
#ifdef CONFIG_SPARSE_RCU_POINTER
# define __rcu		__attribute__((noderef, address_space(4)))
#else
# define __rcu
#endif
extern void __chk_user_ptr(const volatile void __user *);
extern void __chk_io_ptr(const volatile void __iomem *);
#else
# define __user
# define __kernel
# define __safe
# define __force
# define __nocast
# define __iomem
# define __chk_user_ptr(x) (void)0
# define __chk_io_ptr(x) (void)0
# define __builtin_warning(x, y...) (1)
# 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)
# define __percpu
# define __rcu
#endif
 
/* Indirect macros required for expanded argument pasting, eg. __LINE__. */
#define ___PASTE(a,b) a##b
#define __PASTE(a,b) ___PASTE(a,b)
 
#ifdef __KERNEL__
 
#ifdef __GNUC__
#include 
#endif
 
#define notrace __attribute__((no_instrument_function))
 
/* Intel compiler defines __GNUC__. So we will overwrite implementations
 * coming from above header files here
 */
#ifdef __INTEL_COMPILER
# include 
#endif
 
/*
 * Generic compiler-dependent macros required for kernel
 * build go below this comment. Actual compiler/compiler version
 * specific implementations come from the above header files
 */
 
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];
	};
};
 
/*
 * Note: DISABLE_BRANCH_PROFILING can be used by special lowlevel code
 * to disable branch tracing on a per file basis.
 */
#if defined(CONFIG_TRACE_BRANCH_PROFILING) \
    && !defined(DISABLE_BRANCH_PROFILING) && !defined(__CHECKER__)
void ftrace_likely_update(struct ftrace_branch_data *f, int val, int expect);
 
#define likely_notrace(x)	__builtin_expect(!!(x), 1)
#define unlikely_notrace(x)	__builtin_expect(!!(x), 0)
 
#define __branch_check__(x, expect) ({					\
			int ______r;					\
			static struct ftrace_branch_data		\
				__attribute__((__aligned__(4)))		\
				__attribute__((section("_ftrace_annotated_branch"))) \
				______f = {				\
				.func = __func__,			\
				.file = __FILE__,			\
				.line = __LINE__,			\
			};						\
			______r = likely_notrace(x);			\
			ftrace_likely_update(&______f, ______r, expect); \
			______r;					\
		})
 
/*
 * Using __builtin_constant_p(x) to ignore cases where the return
 * value is always the same.  This idea is taken from a similar patch
 * written by Daniel Walker.
 */
# ifndef likely
#  define likely(x)	(__builtin_constant_p(x) ? !!(x) : __branch_check__(x, 1))
# endif
# ifndef unlikely
#  define unlikely(x)	(__builtin_constant_p(x) ? !!(x) : __branch_check__(x, 0))
# endif
 
#ifdef CONFIG_PROFILE_ALL_BRANCHES
/*
 * "Define 'is'", Bill Clinton
 * "Define 'if'", Steven Rostedt
 */
#define if(cond, ...) __trace_if( (cond , ## __VA_ARGS__) )
#define __trace_if(cond) \
	if (__builtin_constant_p((cond)) ? !!(cond) :			\
	({								\
		int ______r;						\
		static struct ftrace_branch_data			\
			__attribute__((__aligned__(4)))			\
			__attribute__((section("_ftrace_branch")))	\
			______f = {					\
				.func = __func__,			\
				.file = __FILE__,			\
				.line = __LINE__,			\
			};						\
		______r = !!(cond);					\
		______f.miss_hit[______r]++;					\
		______r;						\
	}))
#endif /* CONFIG_PROFILE_ALL_BRANCHES */
 
#else
# define likely(x)	__builtin_expect(!!(x), 1)
# define unlikely(x)	__builtin_expect(!!(x), 0)
#endif
 
/* Optimization barrier */
#ifndef barrier
# define barrier() __memory_barrier()
#endif
 
/* Unreachable code */
#ifndef unreachable
# define unreachable() do { } while (1)
#endif
 
#ifndef RELOC_HIDE
# define RELOC_HIDE(ptr, off)					\
  ({ unsigned long __ptr;					\
     __ptr = (unsigned long) (ptr);				\
    (typeof(ptr)) (__ptr + (off)); })
#endif
 
/* Not-quite-unique ID. */
#ifndef __UNIQUE_ID
# define __UNIQUE_ID(prefix) __PASTE(__PASTE(__UNIQUE_ID_, prefix), __LINE__)
#endif
 
#endif /* __KERNEL__ */
 
#endif /* __ASSEMBLY__ */
 
#ifdef __KERNEL__
/*
 * Allow us to mark functions as 'deprecated' and have gcc emit a nice
 * warning for each use, in hopes of speeding the functions removal.
 * Usage is:
 * 		int __deprecated foo(void)
 */
#ifndef __deprecated
# define __deprecated		/* unimplemented */
#endif
 
#ifdef MODULE
#define __deprecated_for_modules __deprecated
#else
#define __deprecated_for_modules
#endif
 
#ifndef __must_check
#define __must_check
#endif
 
#ifndef CONFIG_ENABLE_MUST_CHECK
#undef __must_check
#define __must_check
#endif
#ifndef CONFIG_ENABLE_WARN_DEPRECATED
#undef __deprecated
#undef __deprecated_for_modules
#define __deprecated
#define __deprecated_for_modules
#endif
 
/*
 * Allow us to avoid 'defined but not used' warnings on functions and data,
 * as well as force them to be emitted to the assembly file.
 *
 * As of gcc 3.4, static functions that are not marked with attribute((used))
 * may be elided from the assembly file.  As of gcc 3.4, static data not so
 * marked will not be elided, but this may change in a future gcc version.
 *
 * NOTE: Because distributions shipped with a backported unit-at-a-time
 * compiler in gcc 3.3, we must define __used to be __attribute__((used))
 * for gcc >=3.3 instead of 3.4.
 *
 * In prior versions of gcc, such functions and data would be emitted, but
 * would be warned about except with attribute((unused)).
 *
 * Mark functions that are referenced only in inline assembly as __used so
 * the code is emitted even though it appears to be unreferenced.
 */
#ifndef __used
# define __used			/* unimplemented */
#endif
 
#ifndef __maybe_unused
# define __maybe_unused		/* unimplemented */
#endif
 
#ifndef __always_unused
# define __always_unused	/* unimplemented */
#endif
 
#ifndef noinline
#define noinline
#endif
 
/*
 * Rather then using noinline to prevent stack consumption, use
 * noinline_for_stack instead.  For documentation reasons.
 */
#define noinline_for_stack noinline
 
#ifndef __always_inline
#define __always_inline inline
#endif
 
#endif /* __KERNEL__ */
 
/*
 * From the GCC manual:
 *
 * Many functions do not examine any values except their arguments,
 * and have no effects except the return value.  Basically this is
 * just slightly more strict class than the `pure' attribute above,
 * since function is not allowed to read global memory.
 *
 * Note that a function that has pointer arguments and examines the
 * data pointed to must _not_ be declared `const'.  Likewise, a
 * function that calls a non-`const' function usually must not be
 * `const'.  It does not make sense for a `const' function to return
 * `void'.
 */
#ifndef __attribute_const__
# define __attribute_const__	/* unimplemented */
#endif
 
/*
 * Tell gcc if a function is cold. The compiler will assume any path
 * directly leading to the call is unlikely.
 */
 
#ifndef __cold
#define __cold
#endif
 
/* Simple shorthand for a section definition */
#ifndef __section
# define __section(S) __attribute__ ((__section__(#S)))
#endif
 
#ifndef __visible
#define __visible
#endif
 
/* Are two types/vars the same type (ignoring qualifiers)? */
#ifndef __same_type
# define __same_type(a, b) __builtin_types_compatible_p(typeof(a), typeof(b))
#endif
 
/* 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)
# define __compiletime_error_fallback(condition) \
	do { ((void)sizeof(char[1 - 2 * condition])); } while (0)
#else
# define __compiletime_error_fallback(condition) do { } while (0)
#endif
 
#define __compiletime_assert(condition, msg, prefix, suffix)		\
	do {								\
		bool __cond = !(condition);				\
		extern void prefix ## suffix(void) __compiletime_error(msg); \
		if (__cond)						\
			prefix ## suffix();				\
		__compiletime_error_fallback(__cond);			\
	} while (0)
 
#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_, __LINE__)
 
/*
 * Prevent the compiler from merging or refetching accesses.  The compiler
 * is also forbidden from reordering successive instances of ACCESS_ONCE(),
 * but only when the compiler is aware of some particular ordering.  One way
 * to make the compiler aware of ordering is to put the two invocations of
 * ACCESS_ONCE() in different C statements.
 *
 * This macro does absolutely -nothing- to prevent the CPU from reordering,
 * merging, or refetching absolutely anything at any time.  Its main intended
 * use is to mediate communication between process-level code and irq/NMI
 * handlers, all running on the same CPU.
 */
#define ACCESS_ONCE(x) (*(volatile typeof(x) *)&(x))
 
#endif /* __LINUX_COMPILER_H */

Rev 3243	Rev 3480
1	#ifndef __LINUX_COMPILER_H	1	#ifndef __LINUX_COMPILER_H
2	#define __LINUX_COMPILER_H	2	#define __LINUX_COMPILER_H
3		3
4	#ifndef __ASSEMBLY__	4	#ifndef __ASSEMBLY__
5		5
6	#ifdef __CHECKER__	6	#ifdef __CHECKER__
7	# define __user __attribute__((noderef, address_space(1)))	7	# define __user __attribute__((noderef, address_space(1)))
8	# define __kernel __attribute__((address_space(0)))	8	# define __kernel __attribute__((address_space(0)))
9	# define __safe __attribute__((safe))	9	# define __safe __attribute__((safe))
10	# define __force __attribute__((force))	10	# define __force __attribute__((force))
11	# define __nocast __attribute__((nocast))	11	# define __nocast __attribute__((nocast))
12	# define __iomem __attribute__((noderef, address_space(2)))	12	# define __iomem __attribute__((noderef, address_space(2)))
13	# define __must_hold(x) __attribute__((context(x,1,1)))	13	# define __must_hold(x) __attribute__((context(x,1,1)))
14	# define __acquires(x) __attribute__((context(x,0,1)))	14	# define __acquires(x) __attribute__((context(x,0,1)))
15	# define __releases(x) __attribute__((context(x,1,0)))	15	# define __releases(x) __attribute__((context(x,1,0)))
16	# define __acquire(x) __context__(x,1)	16	# define __acquire(x) __context__(x,1)
17	# define __release(x) __context__(x,-1)	17	# define __release(x) __context__(x,-1)
18	# define __cond_lock(x,c) ((c) ? ({ __acquire(x); 1; }) : 0)	18	# define __cond_lock(x,c) ((c) ? ({ __acquire(x); 1; }) : 0)
19	# define __percpu __attribute__((noderef, address_space(3)))	19	# define __percpu __attribute__((noderef, address_space(3)))
20	#ifdef CONFIG_SPARSE_RCU_POINTER	20	#ifdef CONFIG_SPARSE_RCU_POINTER
21	# define __rcu __attribute__((noderef, address_space(4)))	21	# define __rcu __attribute__((noderef, address_space(4)))
22	#else	22	#else
23	# define __rcu	23	# define __rcu
24	#endif	24	#endif
25	extern void __chk_user_ptr(const volatile void __user *);	25	extern void __chk_user_ptr(const volatile void __user *);
26	extern void __chk_io_ptr(const volatile void __iomem *);	26	extern void __chk_io_ptr(const volatile void __iomem *);
27	#else	27	#else
28	# define __user	28	# define __user
29	# define __kernel	29	# define __kernel
30	# define __safe	30	# define __safe
31	# define __force	31	# define __force
32	# define __nocast	32	# define __nocast
33	# define __iomem	33	# define __iomem
34	# define __chk_user_ptr(x) (void)0	34	# define __chk_user_ptr(x) (void)0
35	# define __chk_io_ptr(x) (void)0	35	# define __chk_io_ptr(x) (void)0
36	# define __builtin_warning(x, y...) (1)	36	# define __builtin_warning(x, y...) (1)
37	# define __must_hold(x)	37	# define __must_hold(x)
38	# define __acquires(x)	38	# define __acquires(x)
39	# define __releases(x)	39	# define __releases(x)
40	# define __acquire(x) (void)0	40	# define __acquire(x) (void)0
41	# define __release(x) (void)0	41	# define __release(x) (void)0
42	# define __cond_lock(x,c) (c)	42	# define __cond_lock(x,c) (c)
43	# define __percpu	43	# define __percpu
44	# define __rcu	44	# define __rcu
45	#endif	45	#endif
46		46
47	/* Indirect macros required for expanded argument pasting, eg. __LINE__. */	47	/* Indirect macros required for expanded argument pasting, eg. __LINE__. */
48	#define ___PASTE(a,b) a##b	48	#define ___PASTE(a,b) a##b
49	#define __PASTE(a,b) ___PASTE(a,b)	49	#define __PASTE(a,b) ___PASTE(a,b)
50		50
51	#ifdef __KERNEL__	51	#ifdef __KERNEL__
52		52
53	#ifdef __GNUC__	53	#ifdef __GNUC__
54	#include	54	#include
55	#endif	55	#endif
56		56
57	#define notrace __attribute__((no_instrument_function))	57	#define notrace __attribute__((no_instrument_function))
58		58
59	/* Intel compiler defines __GNUC__. So we will overwrite implementations	59	/* Intel compiler defines __GNUC__. So we will overwrite implementations
60	* coming from above header files here	60	* coming from above header files here
61	*/	61	*/
62	#ifdef __INTEL_COMPILER	62	#ifdef __INTEL_COMPILER
63	# include	63	# include
64	#endif	64	#endif
65		65
66	/*	66	/*
67	* Generic compiler-dependent macros required for kernel	67	* Generic compiler-dependent macros required for kernel
68	* build go below this comment. Actual compiler/compiler version	68	* build go below this comment. Actual compiler/compiler version
69	* specific implementations come from the above header files	69	* specific implementations come from the above header files
70	*/	70	*/
71		71
72	struct ftrace_branch_data {	72	struct ftrace_branch_data {
73	const char *func;	73	const char *func;
74	const char *file;	74	const char *file;
75	unsigned line;	75	unsigned line;
76	union {	76	union {
77	struct {	77	struct {
78	unsigned long correct;	78	unsigned long correct;
79	unsigned long incorrect;	79	unsigned long incorrect;
80	};	80	};
81	struct {	81	struct {
82	unsigned long miss;	82	unsigned long miss;
83	unsigned long hit;	83	unsigned long hit;
84	};	84	};
85	unsigned long miss_hit[2];	85	unsigned long miss_hit[2];
86	};	86	};
87	};	87	};
88		88
89	/*	89	/*
90	* Note: DISABLE_BRANCH_PROFILING can be used by special lowlevel code	90	* Note: DISABLE_BRANCH_PROFILING can be used by special lowlevel code
91	* to disable branch tracing on a per file basis.	91	* to disable branch tracing on a per file basis.
92	*/	92	*/
93	#if defined(CONFIG_TRACE_BRANCH_PROFILING) \	93	#if defined(CONFIG_TRACE_BRANCH_PROFILING) \
94	&& !defined(DISABLE_BRANCH_PROFILING) && !defined(__CHECKER__)	94	&& !defined(DISABLE_BRANCH_PROFILING) && !defined(__CHECKER__)
95	void ftrace_likely_update(struct ftrace_branch_data *f, int val, int expect);	95	void ftrace_likely_update(struct ftrace_branch_data *f, int val, int expect);
96		96
97	#define likely_notrace(x) __builtin_expect(!!(x), 1)	97	#define likely_notrace(x) __builtin_expect(!!(x), 1)
98	#define unlikely_notrace(x) __builtin_expect(!!(x), 0)	98	#define unlikely_notrace(x) __builtin_expect(!!(x), 0)
99		99
100	#define __branch_check__(x, expect) ({ \	100	#define __branch_check__(x, expect) ({ \
101	int ______r; \	101	int ______r; \
102	static struct ftrace_branch_data \	102	static struct ftrace_branch_data \
103	__attribute__((__aligned__(4))) \	103	__attribute__((__aligned__(4))) \
104	__attribute__((section("_ftrace_annotated_branch"))) \	104	__attribute__((section("_ftrace_annotated_branch"))) \
105	______f = { \	105	______f = { \
106	.func = __func__, \	106	.func = __func__, \
107	.file = __FILE__, \	107	.file = __FILE__, \
108	.line = __LINE__, \	108	.line = __LINE__, \
109	}; \	109	}; \
110	______r = likely_notrace(x); \	110	______r = likely_notrace(x); \
111	ftrace_likely_update(&______f, ______r, expect); \	111	ftrace_likely_update(&______f, ______r, expect); \
112	______r; \	112	______r; \
113	})	113	})
114		114
115	/*	115	/*
116	* Using __builtin_constant_p(x) to ignore cases where the return	116	* Using __builtin_constant_p(x) to ignore cases where the return
117	* value is always the same. This idea is taken from a similar patch	117	* value is always the same. This idea is taken from a similar patch
118	* written by Daniel Walker.	118	* written by Daniel Walker.
119	*/	119	*/
120	# ifndef likely	120	# ifndef likely
121	# define likely(x) (__builtin_constant_p(x) ? !!(x) : __branch_check__(x, 1))	121	# define likely(x) (__builtin_constant_p(x) ? !!(x) : __branch_check__(x, 1))
122	# endif	122	# endif
123	# ifndef unlikely	123	# ifndef unlikely
124	# define unlikely(x) (__builtin_constant_p(x) ? !!(x) : __branch_check__(x, 0))	124	# define unlikely(x) (__builtin_constant_p(x) ? !!(x) : __branch_check__(x, 0))
125	# endif	125	# endif
126		126
127	#ifdef CONFIG_PROFILE_ALL_BRANCHES	127	#ifdef CONFIG_PROFILE_ALL_BRANCHES
128	/*	128	/*
129	* "Define 'is'", Bill Clinton	129	* "Define 'is'", Bill Clinton
130	* "Define 'if'", Steven Rostedt	130	* "Define 'if'", Steven Rostedt
131	*/	131	*/
132	#define if(cond, ...) __trace_if( (cond , ## __VA_ARGS__) )	132	#define if(cond, ...) __trace_if( (cond , ## __VA_ARGS__) )
133	#define __trace_if(cond) \	133	#define __trace_if(cond) \
134	if (__builtin_constant_p((cond)) ? !!(cond) : \	134	if (__builtin_constant_p((cond)) ? !!(cond) : \
135	({ \	135	({ \
136	int ______r; \	136	int ______r; \
137	static struct ftrace_branch_data \	137	static struct ftrace_branch_data \
138	__attribute__((__aligned__(4))) \	138	__attribute__((__aligned__(4))) \
139	__attribute__((section("_ftrace_branch"))) \	139	__attribute__((section("_ftrace_branch"))) \
140	______f = { \	140	______f = { \
141	.func = __func__, \	141	.func = __func__, \
142	.file = __FILE__, \	142	.file = __FILE__, \
143	.line = __LINE__, \	143	.line = __LINE__, \
144	}; \	144	}; \
145	______r = !!(cond); \	145	______r = !!(cond); \
146	______f.miss_hit[______r]++; \	146	______f.miss_hit[______r]++; \
147	______r; \	147	______r; \
148	}))	148	}))
149	#endif /* CONFIG_PROFILE_ALL_BRANCHES */	149	#endif /* CONFIG_PROFILE_ALL_BRANCHES */
150		150
151	#else	151	#else
152	# define likely(x) __builtin_expect(!!(x), 1)	152	# define likely(x) __builtin_expect(!!(x), 1)
153	# define unlikely(x) __builtin_expect(!!(x), 0)	153	# define unlikely(x) __builtin_expect(!!(x), 0)
154	#endif	154	#endif
155		155
156	/* Optimization barrier */	156	/* Optimization barrier */
157	#ifndef barrier	157	#ifndef barrier
158	# define barrier() __memory_barrier()	158	# define barrier() __memory_barrier()
159	#endif	159	#endif
160		160
161	/* Unreachable code */	161	/* Unreachable code */
162	#ifndef unreachable	162	#ifndef unreachable
163	# define unreachable() do { } while (1)	163	# define unreachable() do { } while (1)
164	#endif	164	#endif
165		165
166	#ifndef RELOC_HIDE	166	#ifndef RELOC_HIDE
167	# define RELOC_HIDE(ptr, off) \	167	# define RELOC_HIDE(ptr, off) \
168	({ unsigned long __ptr; \	168	({ unsigned long __ptr; \
169	__ptr = (unsigned long) (ptr); \	169	__ptr = (unsigned long) (ptr); \
170	(typeof(ptr)) (__ptr + (off)); })	170	(typeof(ptr)) (__ptr + (off)); })
171	#endif	171	#endif
-		172
-		173	/* Not-quite-unique ID. */
-		174	#ifndef __UNIQUE_ID
-		175	# define __UNIQUE_ID(prefix) __PASTE(__PASTE(__UNIQUE_ID_, prefix), __LINE__)
-		176	#endif
172		177
173	#endif /* __KERNEL__ */	178	#endif /* __KERNEL__ */
174		179
175	#endif /* __ASSEMBLY__ */	180	#endif /* __ASSEMBLY__ */
176		181
177	#ifdef __KERNEL__	182	#ifdef __KERNEL__
178	/*	183	/*
179	* Allow us to mark functions as 'deprecated' and have gcc emit a nice	184	* Allow us to mark functions as 'deprecated' and have gcc emit a nice
180	* warning for each use, in hopes of speeding the functions removal.	185	* warning for each use, in hopes of speeding the functions removal.
181	* Usage is:	186	* Usage is:
182	* int __deprecated foo(void)	187	* int __deprecated foo(void)
183	*/	188	*/
184	#ifndef __deprecated	189	#ifndef __deprecated
185	# define __deprecated /* unimplemented */	190	# define __deprecated /* unimplemented */
186	#endif	191	#endif
187		192
188	#ifdef MODULE	193	#ifdef MODULE
189	#define __deprecated_for_modules __deprecated	194	#define __deprecated_for_modules __deprecated
190	#else	195	#else
191	#define __deprecated_for_modules	196	#define __deprecated_for_modules
192	#endif	197	#endif
193		198
194	#ifndef __must_check	199	#ifndef __must_check
195	#define __must_check	200	#define __must_check
196	#endif	201	#endif
197		202
198	#ifndef CONFIG_ENABLE_MUST_CHECK	203	#ifndef CONFIG_ENABLE_MUST_CHECK
199	#undef __must_check	204	#undef __must_check
200	#define __must_check	205	#define __must_check
201	#endif	206	#endif
202	#ifndef CONFIG_ENABLE_WARN_DEPRECATED	207	#ifndef CONFIG_ENABLE_WARN_DEPRECATED
203	#undef __deprecated	208	#undef __deprecated
204	#undef __deprecated_for_modules	209	#undef __deprecated_for_modules
205	#define __deprecated	210	#define __deprecated
206	#define __deprecated_for_modules	211	#define __deprecated_for_modules
207	#endif	212	#endif
208		213
209	/*	214	/*
210	* Allow us to avoid 'defined but not used' warnings on functions and data,	215	* Allow us to avoid 'defined but not used' warnings on functions and data,
211	* as well as force them to be emitted to the assembly file.	216	* as well as force them to be emitted to the assembly file.
212	*	217	*
213	* As of gcc 3.4, static functions that are not marked with attribute((used))	218	* As of gcc 3.4, static functions that are not marked with attribute((used))
214	* may be elided from the assembly file. As of gcc 3.4, static data not so	219	* may be elided from the assembly file. As of gcc 3.4, static data not so
215	* marked will not be elided, but this may change in a future gcc version.	220	* marked will not be elided, but this may change in a future gcc version.
216	*	221	*
217	* NOTE: Because distributions shipped with a backported unit-at-a-time	222	* NOTE: Because distributions shipped with a backported unit-at-a-time
218	* compiler in gcc 3.3, we must define __used to be __attribute__((used))	223	* compiler in gcc 3.3, we must define __used to be __attribute__((used))
219	* for gcc >=3.3 instead of 3.4.	224	* for gcc >=3.3 instead of 3.4.
220	*	225	*
221	* In prior versions of gcc, such functions and data would be emitted, but	226	* In prior versions of gcc, such functions and data would be emitted, but
222	* would be warned about except with attribute((unused)).	227	* would be warned about except with attribute((unused)).
223	*	228	*
224	* Mark functions that are referenced only in inline assembly as __used so	229	* Mark functions that are referenced only in inline assembly as __used so
225	* the code is emitted even though it appears to be unreferenced.	230	* the code is emitted even though it appears to be unreferenced.
226	*/	231	*/
227	#ifndef __used	232	#ifndef __used
228	# define __used /* unimplemented */	233	# define __used /* unimplemented */
229	#endif	234	#endif
230		235
231	#ifndef __maybe_unused	236	#ifndef __maybe_unused
232	# define __maybe_unused /* unimplemented */	237	# define __maybe_unused /* unimplemented */
233	#endif	238	#endif
234		239
235	#ifndef __always_unused	240	#ifndef __always_unused
236	# define __always_unused /* unimplemented */	241	# define __always_unused /* unimplemented */
237	#endif	242	#endif
238		243
239	#ifndef noinline	244	#ifndef noinline
240	#define noinline	245	#define noinline
241	#endif	246	#endif
242		247
243	/*	248	/*
244	* Rather then using noinline to prevent stack consumption, use	249	* Rather then using noinline to prevent stack consumption, use
245	* noinline_for_stack instead. For documentation reasons.	250	* noinline_for_stack instead. For documentation reasons.
246	*/	251	*/
247	#define noinline_for_stack noinline	252	#define noinline_for_stack noinline
248		253
249	#ifndef __always_inline	254	#ifndef __always_inline
250	#define __always_inline inline	255	#define __always_inline inline
251	#endif	256	#endif
252		257
253	#endif /* __KERNEL__ */	258	#endif /* __KERNEL__ */
254		259
255	/*	260	/*
256	* From the GCC manual:	261	* From the GCC manual:
257	*	262	*
258	* Many functions do not examine any values except their arguments,	263	* Many functions do not examine any values except their arguments,
259	* and have no effects except the return value. Basically this is	264	* and have no effects except the return value. Basically this is
260	* just slightly more strict class than the `pure' attribute above,	265	* just slightly more strict class than the `pure' attribute above,
261	* since function is not allowed to read global memory.	266	* since function is not allowed to read global memory.
262	*	267	*
263	* Note that a function that has pointer arguments and examines the	268	* Note that a function that has pointer arguments and examines the
264	* data pointed to must _not_ be declared `const'. Likewise, a	269	* data pointed to must _not_ be declared `const'. Likewise, a
265	* function that calls a non-`const' function usually must not be	270	* function that calls a non-`const' function usually must not be
266	* `const'. It does not make sense for a `const' function to return	271	* `const'. It does not make sense for a `const' function to return
267	* `void'.	272	* `void'.
268	*/	273	*/
269	#ifndef __attribute_const__	274	#ifndef __attribute_const__
270	# define __attribute_const__ /* unimplemented */	275	# define __attribute_const__ /* unimplemented */
271	#endif	276	#endif
272		277
273	/*	278	/*
274	* Tell gcc if a function is cold. The compiler will assume any path	279	* Tell gcc if a function is cold. The compiler will assume any path
275	* directly leading to the call is unlikely.	280	* directly leading to the call is unlikely.
276	*/	281	*/
277		282
278	#ifndef __cold	283	#ifndef __cold
279	#define __cold	284	#define __cold
280	#endif	285	#endif
281		286
282	/* Simple shorthand for a section definition */	287	/* Simple shorthand for a section definition */
283	#ifndef __section	288	#ifndef __section
284	# define __section(S) __attribute__ ((__section__(#S)))	289	# define __section(S) __attribute__ ((__section__(#S)))
285	#endif	290	#endif
286		291
287	#ifndef __visible	292	#ifndef __visible
288	#define __visible	293	#define __visible
289	#endif	294	#endif
290		295
291	/* Are two types/vars the same type (ignoring qualifiers)? */	296	/* Are two types/vars the same type (ignoring qualifiers)? */
292	#ifndef __same_type	297	#ifndef __same_type
293	# define __same_type(a, b) __builtin_types_compatible_p(typeof(a), typeof(b))	298	# define __same_type(a, b) __builtin_types_compatible_p(typeof(a), typeof(b))
294	#endif	299	#endif
295		300
296	/* Compile time object size, -1 for unknown */	301	/* Compile time object size, -1 for unknown */
297	#ifndef __compiletime_object_size	302	#ifndef __compiletime_object_size
298	# define __compiletime_object_size(obj) -1	303	# define __compiletime_object_size(obj) -1
299	#endif	304	#endif
300	#ifndef __compiletime_warning	305	#ifndef __compiletime_warning
301	# define __compiletime_warning(message)	306	# define __compiletime_warning(message)
302	#endif	307	#endif
303	#ifndef __compiletime_error	308	#ifndef __compiletime_error
304	# define __compiletime_error(message)	309	# define __compiletime_error(message)
-		310	# define __compiletime_error_fallback(condition) \
-		311	do { ((void)sizeof(char[1 - 2 * condition])); } while (0)
-		312	#else
-		313	# define __compiletime_error_fallback(condition) do { } while (0)
305	#endif	314	#endif
-		315
-		316	#define __compiletime_assert(condition, msg, prefix, suffix) \
-		317	do { \
-		318	bool __cond = !(condition); \
-		319	extern void prefix ## suffix(void) __compiletime_error(msg); \
306	#ifndef __linktime_error	320	if (__cond) \
-		321	prefix ## suffix(); \
-		322	__compiletime_error_fallback(__cond); \
-		323	} while (0)
-		324
307	# define __linktime_error(message)	325	#define _compiletime_assert(condition, msg, prefix, suffix) \
-		326	__compiletime_assert(condition, msg, prefix, suffix)
-		327
-		328	/**
-		329	* compiletime_assert - break build and emit msg if condition is false
-		330	* @condition: a compile-time constant condition to check
-		331	* @msg: a message to emit if condition is false
-		332	*
-		333	* In tradition of POSIX assert, this macro will break the build if the
-		334	* supplied condition is false, emitting the supplied error message if the
-		335	* compiler has support to do so.
308	#endif	336	*/
-		337	#define compiletime_assert(condition, msg) \
-		338	_compiletime_assert(condition, msg, __compiletime_assert_, __LINE__)
-		339
309	/*	340	/*
310	* Prevent the compiler from merging or refetching accesses. The compiler	341	* Prevent the compiler from merging or refetching accesses. The compiler
311	* is also forbidden from reordering successive instances of ACCESS_ONCE(),	342	* is also forbidden from reordering successive instances of ACCESS_ONCE(),
312	* but only when the compiler is aware of some particular ordering. One way	343	* but only when the compiler is aware of some particular ordering. One way
313	* to make the compiler aware of ordering is to put the two invocations of	344	* to make the compiler aware of ordering is to put the two invocations of
314	* ACCESS_ONCE() in different C statements.	345	* ACCESS_ONCE() in different C statements.
315	*	346	*
316	* This macro does absolutely -nothing- to prevent the CPU from reordering,	347	* This macro does absolutely -nothing- to prevent the CPU from reordering,
317	* merging, or refetching absolutely anything at any time. Its main intended	348	* merging, or refetching absolutely anything at any time. Its main intended
318	* use is to mediate communication between process-level code and irq/NMI	349	* use is to mediate communication between process-level code and irq/NMI
319	* handlers, all running on the same CPU.	350	* handlers, all running on the same CPU.
320	*/	351	*/
321	#define ACCESS_ONCE(x) ((volatile typeof(x) )&(x))	352	#define ACCESS_ONCE(x) ((volatile typeof(x) )&(x))
322		353
323	#endif /* __LINUX_COMPILER_H */	354	#endif /* __LINUX_COMPILER_H */

Subversion Repositories Kolibri OS

(root)/drivers/include/linux/compiler.h – Rev 3243 → 3480