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 #else
  21 # define __kernel_insbl(val, shift)                                     \
  22   ({ unsigned long __kir;                                               \
  23      __asm__("insbl %2,%1,%0" : "=r"(__kir) : "rI"(shift), "r"(val));   \
  24      __kir; })
  25 # define __kernel_inswl(val, shift)                                     \
  26   ({ unsigned long __kir;                                               \
  27      __asm__("inswl %2,%1,%0" : "=r"(__kir) : "rI"(shift), "r"(val));   \
  28      __kir; })
  29 # define __kernel_insql(val, shift)                                     \
  30   ({ unsigned long __kir;                                               \
  31      __asm__("insql %2,%1,%0" : "=r"(__kir) : "rI"(shift), "r"(val));   \
  32      __kir; })
  33 # define __kernel_inslh(val, shift)                                     \
  34   ({ unsigned long __kir;                                               \
  35      __asm__("inslh %2,%1,%0" : "=r"(__kir) : "rI"(shift), "r"(val));   \
  36      __kir; })
  37 # define __kernel_extbl(val, shift)                                     \
  38   ({ unsigned long __kir;                                               \
  39      __asm__("extbl %2,%1,%0" : "=r"(__kir) : "rI"(shift), "r"(val));   \
  40      __kir; })
  41 # define __kernel_extwl(val, shift)                                     \
  42   ({ unsigned long __kir;                                               \
  43      __asm__("extwl %2,%1,%0" : "=r"(__kir) : "rI"(shift), "r"(val));   \
  44      __kir; })
  45 # define __kernel_cmpbge(a, b)                                          \
  46   ({ unsigned long __kir;                                               \
  47      __asm__("cmpbge %r2,%1,%0" : "=r"(__kir) : "rI"(b), "rJ"(a));      \
  48      __kir; })
  49 #endif
  50
  51 #ifdef __alpha_cix__
  52 # if __GNUC__ == 3 && __GNUC_MINOR__ >= 4 || __GNUC__ > 3
  53 #  define __kernel_cttz(x)              __builtin_ctzl(x)
  54 #  define __kernel_ctlz(x)              __builtin_clzl(x)
  55 #  define __kernel_ctpop(x)             __builtin_popcountl(x)
  56 # else
  57 #  define __kernel_cttz(x)                                              \
  58    ({ unsigned long __kir;                                              \
  59       __asm__("cttz %1,%0" : "=r"(__kir) : "r"(x));                     \
  60       __kir; })
  61 #  define __kernel_ctlz(x)                                              \
  62    ({ unsigned long __kir;                                              \
  63       __asm__("ctlz %1,%0" : "=r"(__kir) : "r"(x));                     \
  64       __kir; })
  65 #  define __kernel_ctpop(x)                                             \
  66    ({ unsigned long __kir;                                              \
  67       __asm__("ctpop %1,%0" : "=r"(__kir) : "r"(x));                    \
  68       __kir; })
  69 # endif
  70 #else
  71 # define __kernel_cttz(x)                                               \
  72   ({ unsigned long __kir;                                               \
  73      __asm__(".arch ev67; cttz %1,%0" : "=r"(__kir) : "r"(x));          \
  74      __kir; })
  75 # define __kernel_ctlz(x)                                               \
  76   ({ unsigned long __kir;                                               \
  77      __asm__(".arch ev67; ctlz %1,%0" : "=r"(__kir) : "r"(x));          \
  78      __kir; })
  79 # define __kernel_ctpop(x)                                              \
  80   ({ unsigned long __kir;                                               \
  81      __asm__(".arch ev67; ctpop %1,%0" : "=r"(__kir) : "r"(x));         \
  82      __kir; })
  83 #endif
  84
  85
  86 /*
  87  * Beginning with EGCS 1.1, GCC defines __alpha_bwx__ when the BWX
  88  * extension is enabled.  Previous versions did not define anything
  89  * we could test during compilation -- too bad, so sad.
  90  */
  91
  92 #if defined(__alpha_bwx__)
  93 #define __kernel_ldbu(mem)      (mem)
  94 #define __kernel_ldwu(mem)      (mem)
  95 #define __kernel_stb(val,mem)   ((mem) = (val))
  96 #define __kernel_stw(val,mem)   ((mem) = (val))
  97 #else
  98 #define __kernel_ldbu(mem)                              \
  99   ({ unsigned char __kir;                               \
 100      __asm__(".arch ev56;                               \
 101               ldbu %0,%1" : "=r"(__kir) : "m"(mem));    \
 102      __kir; })
 103 #define __kernel_ldwu(mem)                              \
 104   ({ unsigned short __kir;                              \
 105      __asm__(".arch ev56;                               \
 106               ldwu %0,%1" : "=r"(__kir) : "m"(mem));    \
 107      __kir; })
 108 #define __kernel_stb(val,mem)                           \
 109   __asm__(".arch ev56;                                  \
 110            stb %1,%0" : "=m"(mem) : "r"(val))
 111 #define __kernel_stw(val,mem)                           \
 112   __asm__(".arch ev56;                                  \
 113            stw %1,%0" : "=m"(mem) : "r"(val))
 114 #endif
 115
 116 #ifdef __KERNEL__
 117 /* Some idiots over in <linux/compiler.h> thought inline should imply
 118    always_inline.  This breaks stuff.  We'll include this file whenever
 119    we run into such problems.  */
 120
 121 #include <linux/compiler.h>
 122 #undef inline
 123 #undef __inline__
 124 #undef __inline
 125 #undef __always_inline
 126 #define __always_inline         inline __attribute__((always_inline))
 127
 128 #endif /* __KERNEL__ */
 129
 130 #endif /* __ALPHA_COMPILER_H */