← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-lowlatency/precise

« back to all changes in this revision

Viewing changes to arch/alpha/include/asm/compiler.h

  • Committer: Package Import Robot
  • Author(s): Alessio Igor Bogani
  • Date: 2011-10-26 11:13:05 UTC
  • Revision ID: package-import@ubuntu.com-20111026111305-tz023xykf0i6eosh
Tags: upstream-3.2.0
Import upstream version 3.2.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
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 */