LXR linux/arch/alpha/include/asm/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 */
 131