hc
2023-11-22 983d7f83616922a6439b4352d1b3af488ee27f95
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
#ifndef _UAPI__ALPHA_COMPILER_H
#define _UAPI__ALPHA_COMPILER_H
 
/* 
 * Herein are macros we use when describing various patterns we want to GCC.
 * In all cases we can get better schedules out of the compiler if we hide
 * as little as possible inside inline assembly.  However, we want to be
 * able to know what we'll get out before giving up inline assembly.  Thus
 * these tests and macros.
 */
 
#if __GNUC__ == 3 && __GNUC_MINOR__ >= 4 || __GNUC__ > 3
# define __kernel_insbl(val, shift)    __builtin_alpha_insbl(val, shift)
# define __kernel_inswl(val, shift)    __builtin_alpha_inswl(val, shift)
# define __kernel_insql(val, shift)    __builtin_alpha_insql(val, shift)
# define __kernel_inslh(val, shift)    __builtin_alpha_inslh(val, shift)
# define __kernel_extbl(val, shift)    __builtin_alpha_extbl(val, shift)
# define __kernel_extwl(val, shift)    __builtin_alpha_extwl(val, shift)
# define __kernel_cmpbge(a, b)        __builtin_alpha_cmpbge(a, b)
#else
# define __kernel_insbl(val, shift)                    \
  ({ unsigned long __kir;                        \
     __asm__("insbl %2,%1,%0" : "=r"(__kir) : "rI"(shift), "r"(val));    \
     __kir; })
# define __kernel_inswl(val, shift)                    \
  ({ unsigned long __kir;                        \
     __asm__("inswl %2,%1,%0" : "=r"(__kir) : "rI"(shift), "r"(val));    \
     __kir; })
# define __kernel_insql(val, shift)                    \
  ({ unsigned long __kir;                        \
     __asm__("insql %2,%1,%0" : "=r"(__kir) : "rI"(shift), "r"(val));    \
     __kir; })
# define __kernel_inslh(val, shift)                    \
  ({ unsigned long __kir;                        \
     __asm__("inslh %2,%1,%0" : "=r"(__kir) : "rI"(shift), "r"(val));    \
     __kir; })
# define __kernel_extbl(val, shift)                    \
  ({ unsigned long __kir;                        \
     __asm__("extbl %2,%1,%0" : "=r"(__kir) : "rI"(shift), "r"(val));    \
     __kir; })
# define __kernel_extwl(val, shift)                    \
  ({ unsigned long __kir;                        \
     __asm__("extwl %2,%1,%0" : "=r"(__kir) : "rI"(shift), "r"(val));    \
     __kir; })
# define __kernel_cmpbge(a, b)                        \
  ({ unsigned long __kir;                        \
     __asm__("cmpbge %r2,%1,%0" : "=r"(__kir) : "rI"(b), "rJ"(a));    \
     __kir; })
#endif
 
#ifdef __alpha_cix__
# if __GNUC__ == 3 && __GNUC_MINOR__ >= 4 || __GNUC__ > 3
#  define __kernel_cttz(x)        __builtin_ctzl(x)
#  define __kernel_ctlz(x)        __builtin_clzl(x)
#  define __kernel_ctpop(x)        __builtin_popcountl(x)
# else
#  define __kernel_cttz(x)                        \
   ({ unsigned long __kir;                        \
      __asm__("cttz %1,%0" : "=r"(__kir) : "r"(x));            \
      __kir; })
#  define __kernel_ctlz(x)                        \
   ({ unsigned long __kir;                        \
      __asm__("ctlz %1,%0" : "=r"(__kir) : "r"(x));            \
      __kir; })
#  define __kernel_ctpop(x)                        \
   ({ unsigned long __kir;                        \
      __asm__("ctpop %1,%0" : "=r"(__kir) : "r"(x));            \
      __kir; })
# endif
#else
# define __kernel_cttz(x)                        \
  ({ unsigned long __kir;                        \
     __asm__(".arch ev67; cttz %1,%0" : "=r"(__kir) : "r"(x));        \
     __kir; })
# define __kernel_ctlz(x)                        \
  ({ unsigned long __kir;                        \
     __asm__(".arch ev67; ctlz %1,%0" : "=r"(__kir) : "r"(x));        \
     __kir; })
# define __kernel_ctpop(x)                        \
  ({ unsigned long __kir;                        \
     __asm__(".arch ev67; ctpop %1,%0" : "=r"(__kir) : "r"(x));        \
     __kir; })
#endif
 
 
/* 
 * Beginning with EGCS 1.1, GCC defines __alpha_bwx__ when the BWX 
 * extension is enabled.  Previous versions did not define anything
 * we could test during compilation -- too bad, so sad.
 */
 
#if defined(__alpha_bwx__)
#define __kernel_ldbu(mem)    (mem)
#define __kernel_ldwu(mem)    (mem)
#define __kernel_stb(val,mem)    ((mem) = (val))
#define __kernel_stw(val,mem)    ((mem) = (val))
#else
#define __kernel_ldbu(mem)                \
  ({ unsigned char __kir;                \
     __asm__(".arch ev56;                \
         ldbu %0,%1" : "=r"(__kir) : "m"(mem));    \
     __kir; })
#define __kernel_ldwu(mem)                \
  ({ unsigned short __kir;                \
     __asm__(".arch ev56;                \
         ldwu %0,%1" : "=r"(__kir) : "m"(mem));    \
     __kir; })
#define __kernel_stb(val,mem)                \
  __asm__(".arch ev56;                    \
      stb %1,%0" : "=m"(mem) : "r"(val))
#define __kernel_stw(val,mem)                \
  __asm__(".arch ev56;                    \
      stw %1,%0" : "=m"(mem) : "r"(val))
#endif
 
 
#endif /* _UAPI__ALPHA_COMPILER_H */