[deliverable/linux.git] / 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	/* default address space */
# define __safe		__attribute__((safe))
# define __force	__attribute__((force))
# define __nocast	__attribute__((nocast))
# define __iomem	__attribute__((noderef, address_space(2)))
# define __acquires(x)	__attribute__((context(0,1)))
# define __releases(x)	__attribute__((context(1,0)))
# define __acquire(x)	__context__(1)
# define __release(x)	__context__(-1)
# define __cond_lock(x)	((x) ? ({ __context__(1); 1; }) : 0)
extern void __chk_user_ptr(void __user *);
extern void __chk_io_ptr(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 __acquires(x)
# define __releases(x)
# define __acquire(x) (void)0
# define __release(x) (void)0
# define __cond_lock(x) (x)
#endif

#ifdef __KERNEL__

#if __GNUC__ > 4
#error no compiler-gcc.h file for this gcc version
#elif __GNUC__ == 4
# include <linux/compiler-gcc4.h>
#elif __GNUC__ == 3
# include <linux/compiler-gcc3.h>
#else
# error Sorry, your compiler is too old/not recognized.
#endif

/* Intel compiler defines __GNUC__. So we will overwrite implementations
 * coming from above header files here
 */
#ifdef __INTEL_COMPILER
# include <linux/compiler-intel.h>
#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
 */

#define likely(x)	__builtin_expect(!!(x), 1)
#define unlikely(x)	__builtin_expect(!!(x), 0)

/* Optimization barrier */
#ifndef barrier
# define barrier() __memory_barrier()
#endif

#ifndef RELOC_HIDE
# define RELOC_HIDE(ptr, off)					\
  ({ unsigned long __ptr;					\
     __ptr = (unsigned long) (ptr);				\
    (typeof(ptr)) (__ptr + (off)); })
#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

/*
 * 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.3, static functions that are not marked with attribute((used))
 * may be elided from the assembly file.  As of gcc 3.3, static data not so
 * marked will not be elided, but this may change in a future gcc version.
 *
 * In prior versions of gcc, such functions and data would be emitted, but
 * would be warned about except with attribute((unused)).
 */
#ifndef __attribute_used__
# define __attribute_used__	/* unimplemented */
#endif

/*
 * From the GCC manual:
 *
 * Many functions have no effects except the return value and their
 * return value depends only on the parameters and/or global
 * variables.  Such a function can be subject to common subexpression
 * elimination and loop optimization just as an arithmetic operator
 * would be.
 * [...]
 */
#ifndef __attribute_pure__
# define __attribute_pure__	/* unimplemented */
#endif

#ifndef noinline
#define noinline
#endif

#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

#endif /* __LINUX_COMPILER_H */
Commit	Line	Data
1da177e4 LT	1	#ifndef __LINUX_COMPILER_H
	2	#define __LINUX_COMPILER_H
	3
	4	#ifndef __ASSEMBLY__
	5
	6	#ifdef __CHECKER__
	7	# define __user __attribute__((noderef, address_space(1)))
	8	# define __kernel /* default address space */
	9	# define __safe __attribute__((safe))
	10	# define __force __attribute__((force))
	11	# define __nocast __attribute__((nocast))
	12	# define __iomem __attribute__((noderef, address_space(2)))
	13	# define __acquires(x) __attribute__((context(0,1)))
	14	# define __releases(x) __attribute__((context(1,0)))
	15	# define __acquire(x) __context__(1)
	16	# define __release(x) __context__(-1)
	17	# define __cond_lock(x) ((x) ? ({ __context__(1); 1; }) : 0)
	18	extern void __chk_user_ptr(void __user *);
	19	extern void __chk_io_ptr(void __iomem *);
	20	#else
	21	# define __user
	22	# define __kernel
	23	# define __safe
	24	# define __force
	25	# define __nocast
	26	# define __iomem
	27	# define __chk_user_ptr(x) (void)0
	28	# define __chk_io_ptr(x) (void)0
	29	# define __builtin_warning(x, y...) (1)
	30	# define __acquires(x)
	31	# define __releases(x)
	32	# define __acquire(x) (void)0
	33	# define __release(x) (void)0
	34	# define __cond_lock(x) (x)
	35	#endif
	36
	37	#ifdef __KERNEL__
	38
	39	#if __GNUC__ > 4
	40	#error no compiler-gcc.h file for this gcc version
	41	#elif __GNUC__ == 4
	42	# include <linux/compiler-gcc4.h>
	43	#elif __GNUC__ == 3
	44	# include <linux/compiler-gcc3.h>
1da177e4 LT	45	#else
	46	# error Sorry, your compiler is too old/not recognized.
	47	#endif
	48
	49	/* Intel compiler defines __GNUC__. So we will overwrite implementations
	50	* coming from above header files here
	51	*/
	52	#ifdef __INTEL_COMPILER
	53	# include <linux/compiler-intel.h>
	54	#endif
	55
	56	/*
	57	* Generic compiler-dependent macros required for kernel
	58	* build go below this comment. Actual compiler/compiler version
	59	* specific implementations come from the above header files
	60	*/
	61
	62	#define likely(x) __builtin_expect(!!(x), 1)
	63	#define unlikely(x) __builtin_expect(!!(x), 0)
	64
	65	/* Optimization barrier */
	66	#ifndef barrier
	67	# define barrier() __memory_barrier()
	68	#endif
	69
	70	#ifndef RELOC_HIDE
	71	# define RELOC_HIDE(ptr, off) \
	72	({ unsigned long __ptr; \
	73	__ptr = (unsigned long) (ptr); \
	74	(typeof(ptr)) (__ptr + (off)); })
	75	#endif
	76
	77	#endif /* __KERNEL__ */
	78
	79	#endif /* __ASSEMBLY__ */
	80
4f79c3ff	81	#ifdef __KERNEL__
1da177e4 LT	82	/*
	83	* Allow us to mark functions as 'deprecated' and have gcc emit a nice
	84	* warning for each use, in hopes of speeding the functions removal.
	85	* Usage is:
	86	* int __deprecated foo(void)
	87	*/
	88	#ifndef __deprecated
	89	# define __deprecated /* unimplemented */
	90	#endif
	91
512345be PM	92	#ifdef MODULE
	93	#define __deprecated_for_modules __deprecated
	94	#else
	95	#define __deprecated_for_modules
	96	#endif
	97
1da177e4 LT	98	#ifndef __must_check
	99	#define __must_check
	100	#endif
	101
	102	/*
	103	* Allow us to avoid 'defined but not used' warnings on functions and data,
	104	* as well as force them to be emitted to the assembly file.
	105	*
	106	* As of gcc 3.3, static functions that are not marked with attribute((used))
	107	* may be elided from the assembly file. As of gcc 3.3, static data not so
	108	* marked will not be elided, but this may change in a future gcc version.
	109	*
	110	* In prior versions of gcc, such functions and data would be emitted, but
	111	* would be warned about except with attribute((unused)).
	112	*/
	113	#ifndef __attribute_used__
	114	# define __attribute_used__ /* unimplemented */
	115	#endif
	116
	117	/*
	118	* From the GCC manual:
	119	*
	120	* Many functions have no effects except the return value and their
	121	* return value depends only on the parameters and/or global
	122	* variables. Such a function can be subject to common subexpression
	123	* elimination and loop optimization just as an arithmetic operator
	124	* would be.
	125	* [...]
	126	*/
	127	#ifndef __attribute_pure__
	128	# define __attribute_pure__ /* unimplemented */
	129	#endif
	130
423bc7b2 DW	131	#ifndef noinline
	132	#define noinline
	133	#endif
	134
	135	#ifndef __always_inline
	136	#define __always_inline inline
	137	#endif
	138
	139	#endif /* __KERNEL__ */
	140
1da177e4 LT	141	/*
	142	* From the GCC manual:
	143	*
	144	* Many functions do not examine any values except their arguments,
	145	* and have no effects except the return value. Basically this is
	146	* just slightly more strict class than the `pure' attribute above,
	147	* since function is not allowed to read global memory.
	148	*
	149	* Note that a function that has pointer arguments and examines the
	150	* data pointed to must _not_ be declared `const'. Likewise, a
	151	* function that calls a non-`const' function usually must not be
	152	* `const'. It does not make sense for a `const' function to return
	153	* `void'.
	154	*/
	155	#ifndef __attribute_const__
	156	# define __attribute_const__ /* unimplemented */
	157	#endif
	158
1da177e4	159	#endif /* __LINUX_COMPILER_H */