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


#ifndef __LINUX_COMPILER_H
#error "Please don't include  directly, include  instead."
#endif
 
/* GCC 4.1.[01] miscompiles __weak */
#ifdef __KERNEL__
# if GCC_VERSION >= 40100 &&  GCC_VERSION <= 40101
#  error Your version of gcc miscompiles the __weak directive
# endif
#endif
 
#define __used			__attribute__((__used__))
#define __must_check 		__attribute__((warn_unused_result))
#define __compiler_offsetof(a,b) __builtin_offsetof(a,b)
 
#if GCC_VERSION >= 40100 && GCC_VERSION < 40600
# define __compiletime_object_size(obj) __builtin_object_size(obj, 0)
#endif
 
#if GCC_VERSION >= 40300
/* Mark functions as cold. gcc will assume any path leading to a call
   to them will be unlikely.  This means a lot of manual unlikely()s
   are unnecessary now for any paths leading to the usual suspects
   like BUG(), printk(), panic() etc. [but let's keep them for now for
   older compilers]
 
   Early snapshots of gcc 4.3 don't support this and we can't detect this
   in the preprocessor, but we can live with this because they're unreleased.
   Maketime probing would be overkill here.
 
   gcc also has a __attribute__((__hot__)) to move hot functions into
   a special section, but I don't see any sense in this right now in
   the kernel context */
#define __cold			__attribute__((__cold__))
 
#define __UNIQUE_ID(prefix) __PASTE(__PASTE(__UNIQUE_ID_, prefix), __COUNTER__)
 
#ifndef __CHECKER__
# define __compiletime_warning(message) __attribute__((warning(message)))
# define __compiletime_error(message) __attribute__((error(message)))
#endif /* __CHECKER__ */
#endif /* GCC_VERSION >= 40300 */
 
#if GCC_VERSION >= 40500
/*
 * Mark a position in code as unreachable.  This can be used to
 * suppress control flow warnings after asm blocks that transfer
 * control elsewhere.
 *
 * Early snapshots of gcc 4.5 don't support this and we can't detect
 * this in the preprocessor, but we can live with this because they're
 * unreleased.  Really, we need to have autoconf for the kernel.
 */
#define unreachable() __builtin_unreachable()
 
/* Mark a function definition as prohibited from being cloned. */
#define __noclone	__attribute__((__noclone__))
 
#endif /* GCC_VERSION >= 40500 */
 
#if GCC_VERSION >= 40600
/*
 * Tell the optimizer that something else uses this function or variable.
 */
#define __visible __attribute__((externally_visible))
#endif
 
/*
 * GCC 'asm goto' miscompiles certain code sequences:
 *
 *   http://gcc.gnu.org/bugzilla/show_bug.cgi?id=58670
 *
 * Work it around via a compiler barrier quirk suggested by Jakub Jelinek.
 
 *
 * (asm goto is automatically volatile - the naming reflects this.)
 */
#define asm_volatile_goto(x...)	do { asm goto(x); asm (""); } while (0)
 
#ifdef CONFIG_ARCH_USE_BUILTIN_BSWAP
#if GCC_VERSION >= 40400
#define __HAVE_BUILTIN_BSWAP32__
#define __HAVE_BUILTIN_BSWAP64__
#endif
#if GCC_VERSION >= 40800 || (defined(__powerpc__) && GCC_VERSION >= 40600)
#define __HAVE_BUILTIN_BSWAP16__
#endif
#endif /* CONFIG_ARCH_USE_BUILTIN_BSWAP */

Subversion Repositories Kolibri OS

(root)/drivers/include/linux/compiler-gcc4.h – Rev 5056 → 5270

Rev 5056		Rev 5270
1	#ifndef __LINUX_COMPILER_H	1	#ifndef __LINUX_COMPILER_H
2	#error "Please don't include directly, include instead."	2	#error "Please don't include directly, include instead."
3	#endif	3	#endif
4		4
5	/* GCC 4.1.[01] miscompiles __weak */	5	/* GCC 4.1.[01] miscompiles __weak */
6	#ifdef __KERNEL__	6	#ifdef __KERNEL__
7	# if GCC_VERSION >= 40100 && GCC_VERSION <= 40101	7	# if GCC_VERSION >= 40100 && GCC_VERSION <= 40101
8	# error Your version of gcc miscompiles the __weak directive	8	# error Your version of gcc miscompiles the __weak directive
9	# endif	9	# endif
10	#endif	10	#endif
11		11
12	#define __used __attribute__((__used__))	12	#define __used __attribute__((__used__))
13	#define __must_check __attribute__((warn_unused_result))	13	#define __must_check __attribute__((warn_unused_result))
14	#define __compiler_offsetof(a,b) __builtin_offsetof(a,b)	14	#define __compiler_offsetof(a,b) __builtin_offsetof(a,b)
15		15
16	#if GCC_VERSION >= 40100 && GCC_VERSION < 40600	16	#if GCC_VERSION >= 40100 && GCC_VERSION < 40600
17	# define __compiletime_object_size(obj) __builtin_object_size(obj, 0)	17	# define __compiletime_object_size(obj) __builtin_object_size(obj, 0)
18	#endif	18	#endif
19		19
20	#if GCC_VERSION >= 40300	20	#if GCC_VERSION >= 40300
21	/* Mark functions as cold. gcc will assume any path leading to a call	21	/* Mark functions as cold. gcc will assume any path leading to a call
22	to them will be unlikely. This means a lot of manual unlikely()s	22	to them will be unlikely. This means a lot of manual unlikely()s
23	are unnecessary now for any paths leading to the usual suspects	23	are unnecessary now for any paths leading to the usual suspects
24	like BUG(), printk(), panic() etc. [but let's keep them for now for	24	like BUG(), printk(), panic() etc. [but let's keep them for now for
25	older compilers]	25	older compilers]
26		26
27	Early snapshots of gcc 4.3 don't support this and we can't detect this	27	Early snapshots of gcc 4.3 don't support this and we can't detect this
28	in the preprocessor, but we can live with this because they're unreleased.	28	in the preprocessor, but we can live with this because they're unreleased.
29	Maketime probing would be overkill here.	29	Maketime probing would be overkill here.
30		30
31	gcc also has a __attribute__((__hot__)) to move hot functions into	31	gcc also has a __attribute__((__hot__)) to move hot functions into
32	a special section, but I don't see any sense in this right now in	32	a special section, but I don't see any sense in this right now in
33	the kernel context */	33	the kernel context */
34	#define __cold __attribute__((__cold__))	34	#define __cold __attribute__((__cold__))
35		35
36	#define __UNIQUE_ID(prefix) __PASTE(__PASTE(__UNIQUE_ID_, prefix), __COUNTER__)	36	#define __UNIQUE_ID(prefix) __PASTE(__PASTE(__UNIQUE_ID_, prefix), __COUNTER__)
37		37
38	#ifndef __CHECKER__	38	#ifndef __CHECKER__
39	# define __compiletime_warning(message) __attribute__((warning(message)))	39	# define __compiletime_warning(message) __attribute__((warning(message)))
40	# define __compiletime_error(message) __attribute__((error(message)))	40	# define __compiletime_error(message) __attribute__((error(message)))
41	#endif /* __CHECKER__ */	41	#endif /* __CHECKER__ */
42	#endif /* GCC_VERSION >= 40300 */	42	#endif /* GCC_VERSION >= 40300 */
43		43
44	#if GCC_VERSION >= 40500	44	#if GCC_VERSION >= 40500
45	/*	45	/*
46	* Mark a position in code as unreachable. This can be used to	46	* Mark a position in code as unreachable. This can be used to
47	* suppress control flow warnings after asm blocks that transfer	47	* suppress control flow warnings after asm blocks that transfer
48	* control elsewhere.	48	* control elsewhere.
49	*	49	*
50	* Early snapshots of gcc 4.5 don't support this and we can't detect	50	* Early snapshots of gcc 4.5 don't support this and we can't detect
51	* this in the preprocessor, but we can live with this because they're	51	* this in the preprocessor, but we can live with this because they're
52	* unreleased. Really, we need to have autoconf for the kernel.	52	* unreleased. Really, we need to have autoconf for the kernel.
53	*/	53	*/
54	#define unreachable() __builtin_unreachable()	54	#define unreachable() __builtin_unreachable()
55		55
56	/* Mark a function definition as prohibited from being cloned. */	56	/* Mark a function definition as prohibited from being cloned. */
57	#define __noclone __attribute__((__noclone__))	57	#define __noclone __attribute__((__noclone__))
58		58
59	#endif /* GCC_VERSION >= 40500 */	59	#endif /* GCC_VERSION >= 40500 */
60		60
61	#if GCC_VERSION >= 40600	61	#if GCC_VERSION >= 40600
62	/*	62	/*
63	* Tell the optimizer that something else uses this function or variable.	63	* Tell the optimizer that something else uses this function or variable.
64	*/	64	*/
65	#define __visible __attribute__((externally_visible))	65	#define __visible __attribute__((externally_visible))
66	#endif	66	#endif
67		67
68	/*	68	/*
69	* GCC 'asm goto' miscompiles certain code sequences:	69	* GCC 'asm goto' miscompiles certain code sequences:
70	*	70	*
71	* http://gcc.gnu.org/bugzilla/show_bug.cgi?id=58670	71	* http://gcc.gnu.org/bugzilla/show_bug.cgi?id=58670
72	*	72	*
73	* Work it around via a compiler barrier quirk suggested by Jakub Jelinek.	73	* Work it around via a compiler barrier quirk suggested by Jakub Jelinek.
74	* Fixed in GCC 4.8.2 and later versions.	-
75	*	74	*
76	* (asm goto is automatically volatile - the naming reflects this.)	75	* (asm goto is automatically volatile - the naming reflects this.)
77	*/	76	*/
78	#define asm_volatile_goto(x...) do { asm goto(x); asm (""); } while (0)	77	#define asm_volatile_goto(x...) do { asm goto(x); asm (""); } while (0)
79		78
80	#ifdef CONFIG_ARCH_USE_BUILTIN_BSWAP	79	#ifdef CONFIG_ARCH_USE_BUILTIN_BSWAP
81	#if GCC_VERSION >= 40400	80	#if GCC_VERSION >= 40400
82	#define __HAVE_BUILTIN_BSWAP32__	81	#define __HAVE_BUILTIN_BSWAP32__
83	#define __HAVE_BUILTIN_BSWAP64__	82	#define __HAVE_BUILTIN_BSWAP64__
84	#endif	83	#endif
85	#if GCC_VERSION >= 40800 \|\| (defined(__powerpc__) && GCC_VERSION >= 40600)	84	#if GCC_VERSION >= 40800 \|\| (defined(__powerpc__) && GCC_VERSION >= 40600)
86	#define __HAVE_BUILTIN_BSWAP16__	85	#define __HAVE_BUILTIN_BSWAP16__
87	#endif	86	#endif
88	#endif /* CONFIG_ARCH_USE_BUILTIN_BSWAP */	87	#endif /* CONFIG_ARCH_USE_BUILTIN_BSWAP */