[PATCH] remove gcc-2 checks
[linux-2.6.git] / include / asm-alpha / compiler.h
1 #ifndef __ALPHA_COMPILER_H
2 #define __ALPHA_COMPILER_H
3
4 /* 
5  * Herein are macros we use when describing various patterns we want to GCC.
6  * In all cases we can get better schedules out of the compiler if we hide
7  * as little as possible inside inline assembly.  However, we want to be
8  * able to know what we'll get out before giving up inline assembly.  Thus
9  * these tests and macros.
10  */
11
12 #if __GNUC__ == 3 && __GNUC_MINOR__ >= 4 || __GNUC__ > 3
13 # define __kernel_insbl(val, shift)     __builtin_alpha_insbl(val, shift)
14 # define __kernel_inswl(val, shift)     __builtin_alpha_inswl(val, shift)
15 # define __kernel_insql(val, shift)     __builtin_alpha_insql(val, shift)
16 # define __kernel_inslh(val, shift)     __builtin_alpha_inslh(val, shift)
17 # define __kernel_extbl(val, shift)     __builtin_alpha_extbl(val, shift)
18 # define __kernel_extwl(val, shift)     __builtin_alpha_extwl(val, shift)
19 # define __kernel_cmpbge(a, b)          __builtin_alpha_cmpbge(a, b)
20 # define __kernel_cttz(x)               __builtin_ctzl(x)
21 # define __kernel_ctlz(x)               __builtin_clzl(x)
22 # define __kernel_ctpop(x)              __builtin_popcountl(x)
23 #else
24 # define __kernel_insbl(val, shift)                                     \
25   ({ unsigned long __kir;                                               \
26      __asm__("insbl %2,%1,%0" : "=r"(__kir) : "rI"(shift), "r"(val));   \
27      __kir; })
28 # define __kernel_inswl(val, shift)                                     \
29   ({ unsigned long __kir;                                               \
30      __asm__("inswl %2,%1,%0" : "=r"(__kir) : "rI"(shift), "r"(val));   \
31      __kir; })
32 # define __kernel_insql(val, shift)                                     \
33   ({ unsigned long __kir;                                               \
34      __asm__("insql %2,%1,%0" : "=r"(__kir) : "rI"(shift), "r"(val));   \
35      __kir; })
36 # define __kernel_inslh(val, shift)                                     \
37   ({ unsigned long __kir;                                               \
38      __asm__("inslh %2,%1,%0" : "=r"(__kir) : "rI"(shift), "r"(val));   \
39      __kir; })
40 # define __kernel_extbl(val, shift)                                     \
41   ({ unsigned long __kir;                                               \
42      __asm__("extbl %2,%1,%0" : "=r"(__kir) : "rI"(shift), "r"(val));   \
43      __kir; })
44 # define __kernel_extwl(val, shift)                                     \
45   ({ unsigned long __kir;                                               \
46      __asm__("extwl %2,%1,%0" : "=r"(__kir) : "rI"(shift), "r"(val));   \
47      __kir; })
48 # define __kernel_cmpbge(a, b)                                          \
49   ({ unsigned long __kir;                                               \
50      __asm__("cmpbge %r2,%1,%0" : "=r"(__kir) : "rI"(b), "rJ"(a));      \
51      __kir; })
52 # define __kernel_cttz(x)                                               \
53   ({ unsigned long __kir;                                               \
54      __asm__("cttz %1,%0" : "=r"(__kir) : "r"(x));                      \
55      __kir; })
56 # define __kernel_ctlz(x)                                               \
57   ({ unsigned long __kir;                                               \
58      __asm__("ctlz %1,%0" : "=r"(__kir) : "r"(x));                      \
59      __kir; })
60 # define __kernel_ctpop(x)                                              \
61   ({ unsigned long __kir;                                               \
62      __asm__("ctpop %1,%0" : "=r"(__kir) : "r"(x));                     \
63      __kir; })
64 #endif
65
66
67 /* 
68  * Beginning with EGCS 1.1, GCC defines __alpha_bwx__ when the BWX 
69  * extension is enabled.  Previous versions did not define anything
70  * we could test during compilation -- too bad, so sad.
71  */
72
73 #if defined(__alpha_bwx__)
74 #define __kernel_ldbu(mem)      (mem)
75 #define __kernel_ldwu(mem)      (mem)
76 #define __kernel_stb(val,mem)   ((mem) = (val))
77 #define __kernel_stw(val,mem)   ((mem) = (val))
78 #else
79 #define __kernel_ldbu(mem)                              \
80   ({ unsigned char __kir;                               \
81      __asm__("ldbu %0,%1" : "=r"(__kir) : "m"(mem));    \
82      __kir; })
83 #define __kernel_ldwu(mem)                              \
84   ({ unsigned short __kir;                              \
85      __asm__("ldwu %0,%1" : "=r"(__kir) : "m"(mem));    \
86      __kir; })
87 #define __kernel_stb(val,mem) \
88   __asm__("stb %1,%0" : "=m"(mem) : "r"(val))
89 #define __kernel_stw(val,mem) \
90   __asm__("stw %1,%0" : "=m"(mem) : "r"(val))
91 #endif
92
93 /* Some idiots over in <linux/compiler.h> thought inline should imply
94    always_inline.  This breaks stuff.  We'll include this file whenever
95    we run into such problems.  */
96
97 #include <linux/compiler.h>
98 #undef inline
99 #undef __inline__
100 #undef __inline
101 #undef __always_inline
102 #define __always_inline         inline __attribute__((always_inline))
103
104 #endif /* __ALPHA_COMPILER_H */