Statistics
| Branch: | Revision:

root / target-i386 / ops_sse_header.h @ 5af45186

History | View | Annotate | Download (8.3 kB)

1
/*
2
 *  MMX/3DNow!/SSE/SSE2/SSE3/PNI support
3
 *
4
 *  Copyright (c) 2005 Fabrice Bellard
5
 *
6
 * This library is free software; you can redistribute it and/or
7
 * modify it under the terms of the GNU Lesser General Public
8
 * License as published by the Free Software Foundation; either
9
 * version 2 of the License, or (at your option) any later version.
10
 *
11
 * This library is distributed in the hope that it will be useful,
12
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14
 * Lesser General Public License for more details.
15
 *
16
 * You should have received a copy of the GNU Lesser General Public
17
 * License along with this library; if not, write to the Free Software
18
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19
 */
20
#if SHIFT == 0
21
#define Reg MMXReg
22
#define SUFFIX _mmx
23
#else
24
#define Reg XMMReg
25
#define SUFFIX _xmm
26
#endif
27

    
28
void glue(helper_psrlw, SUFFIX)(Reg *d, Reg *s);
29
void glue(helper_psraw, SUFFIX)(Reg *d, Reg *s);
30
void glue(helper_psllw, SUFFIX)(Reg *d, Reg *s);
31
void glue(helper_psrld, SUFFIX)(Reg *d, Reg *s);
32
void glue(helper_psrad, SUFFIX)(Reg *d, Reg *s);
33
void glue(helper_pslld, SUFFIX)(Reg *d, Reg *s);
34
void glue(helper_psrlq, SUFFIX)(Reg *d, Reg *s);
35
void glue(helper_psllq, SUFFIX)(Reg *d, Reg *s);
36

    
37
#if SHIFT == 1
38
void glue(helper_psrldq, SUFFIX)(Reg *d, Reg *s);
39
void glue(helper_pslldq, SUFFIX)(Reg *d, Reg *s);
40
#endif
41

    
42
#define SSE_HELPER_B(name, F)\
43
    void glue(name, SUFFIX) (Reg *d, Reg *s);
44

    
45
#define SSE_HELPER_W(name, F)\
46
    void glue(name, SUFFIX) (Reg *d, Reg *s);
47

    
48
#define SSE_HELPER_L(name, F)\
49
    void glue(name, SUFFIX) (Reg *d, Reg *s);
50

    
51
#define SSE_HELPER_Q(name, F)\
52
    void glue(name, SUFFIX) (Reg *d, Reg *s);
53

    
54
SSE_HELPER_B(helper_paddb, FADD);
55
SSE_HELPER_W(helper_paddw, FADD);
56
SSE_HELPER_L(helper_paddl, FADD);
57
SSE_HELPER_Q(helper_paddq, FADD);
58

    
59
SSE_HELPER_B(helper_psubb, FSUB);
60
SSE_HELPER_W(helper_psubw, FSUB);
61
SSE_HELPER_L(helper_psubl, FSUB);
62
SSE_HELPER_Q(helper_psubq, FSUB);
63

    
64
SSE_HELPER_B(helper_paddusb, FADDUB);
65
SSE_HELPER_B(helper_paddsb, FADDSB);
66
SSE_HELPER_B(helper_psubusb, FSUBUB);
67
SSE_HELPER_B(helper_psubsb, FSUBSB);
68

    
69
SSE_HELPER_W(helper_paddusw, FADDUW);
70
SSE_HELPER_W(helper_paddsw, FADDSW);
71
SSE_HELPER_W(helper_psubusw, FSUBUW);
72
SSE_HELPER_W(helper_psubsw, FSUBSW);
73

    
74
SSE_HELPER_B(helper_pminub, FMINUB);
75
SSE_HELPER_B(helper_pmaxub, FMAXUB);
76

    
77
SSE_HELPER_W(helper_pminsw, FMINSW);
78
SSE_HELPER_W(helper_pmaxsw, FMAXSW);
79

    
80
SSE_HELPER_Q(helper_pand, FAND);
81
SSE_HELPER_Q(helper_pandn, FANDN);
82
SSE_HELPER_Q(helper_por, FOR);
83
SSE_HELPER_Q(helper_pxor, FXOR);
84

    
85
SSE_HELPER_B(helper_pcmpgtb, FCMPGTB);
86
SSE_HELPER_W(helper_pcmpgtw, FCMPGTW);
87
SSE_HELPER_L(helper_pcmpgtl, FCMPGTL);
88

    
89
SSE_HELPER_B(helper_pcmpeqb, FCMPEQ);
90
SSE_HELPER_W(helper_pcmpeqw, FCMPEQ);
91
SSE_HELPER_L(helper_pcmpeql, FCMPEQ);
92

    
93
SSE_HELPER_W(helper_pmullw, FMULLW);
94
#if SHIFT == 0
95
SSE_HELPER_W(helper_pmulhrw, FMULHRW);
96
#endif
97
SSE_HELPER_W(helper_pmulhuw, FMULHUW);
98
SSE_HELPER_W(helper_pmulhw, FMULHW);
99

    
100
SSE_HELPER_B(helper_pavgb, FAVG);
101
SSE_HELPER_W(helper_pavgw, FAVG);
102

    
103
void glue(helper_pmuludq, SUFFIX) (Reg *d, Reg *s);
104
void glue(helper_pmaddwd, SUFFIX) (Reg *d, Reg *s);
105

    
106
void glue(helper_psadbw, SUFFIX) (Reg *d, Reg *s);
107
void glue(helper_maskmov, SUFFIX) (Reg *d, Reg *s);
108
void glue(helper_movl_mm_T0, SUFFIX) (Reg *d, uint32_t val);
109
#ifdef TARGET_X86_64
110
void glue(helper_movq_mm_T0, SUFFIX) (Reg *d, uint64_t val);
111
#endif
112

    
113
#if SHIFT == 0
114
void glue(helper_pshufw, SUFFIX) (Reg *d, Reg *s, int order);
115
#else
116
void helper_shufps(Reg *d, Reg *s, int order);
117
void helper_shufpd(Reg *d, Reg *s, int order);
118
void glue(helper_pshufd, SUFFIX) (Reg *d, Reg *s, int order);
119
void glue(helper_pshuflw, SUFFIX) (Reg *d, Reg *s, int order);
120
void glue(helper_pshufhw, SUFFIX) (Reg *d, Reg *s, int order);
121
#endif
122

    
123
#if SHIFT == 1
124
/* FPU ops */
125
/* XXX: not accurate */
126

    
127
#define SSE_HELPER_S(name, F)\
128
    void helper_ ## name ## ps (Reg *d, Reg *s);        \
129
    void helper_ ## name ## ss (Reg *d, Reg *s);        \
130
    void helper_ ## name ## pd (Reg *d, Reg *s);        \
131
    void helper_ ## name ## sd (Reg *d, Reg *s);
132

    
133
SSE_HELPER_S(add, FPU_ADD);
134
SSE_HELPER_S(sub, FPU_SUB);
135
SSE_HELPER_S(mul, FPU_MUL);
136
SSE_HELPER_S(div, FPU_DIV);
137
SSE_HELPER_S(min, FPU_MIN);
138
SSE_HELPER_S(max, FPU_MAX);
139
SSE_HELPER_S(sqrt, FPU_SQRT);
140

    
141

    
142
void helper_cvtps2pd(Reg *d, Reg *s);
143
void helper_cvtpd2ps(Reg *d, Reg *s);
144
void helper_cvtss2sd(Reg *d, Reg *s);
145
void helper_cvtsd2ss(Reg *d, Reg *s);
146
void helper_cvtdq2ps(Reg *d, Reg *s);
147
void helper_cvtdq2pd(Reg *d, Reg *s);
148
void helper_cvtpi2ps(XMMReg *d, MMXReg *s);
149
void helper_cvtpi2pd(XMMReg *d, MMXReg *s);
150
void helper_cvtsi2ss(XMMReg *d, uint32_t val);
151
void helper_cvtsi2sd(XMMReg *d, uint32_t val);
152

    
153
#ifdef TARGET_X86_64
154
void helper_cvtsq2ss(XMMReg *d, uint64_t val);
155
void helper_cvtsq2sd(XMMReg *d, uint64_t val);
156
#endif
157

    
158
void helper_cvtps2dq(XMMReg *d, XMMReg *s);
159
void helper_cvtpd2dq(XMMReg *d, XMMReg *s);
160
void helper_cvtps2pi(MMXReg *d, XMMReg *s);
161
void helper_cvtpd2pi(MMXReg *d, XMMReg *s);
162
int32_t helper_cvtss2si(XMMReg *s);
163
int32_t helper_cvtsd2si(XMMReg *s);
164
#ifdef TARGET_X86_64
165
int64_t helper_cvtss2sq(XMMReg *s);
166
int64_t helper_cvtsd2sq(XMMReg *s);
167
#endif
168

    
169
void helper_cvttps2dq(XMMReg *d, XMMReg *s);
170
void helper_cvttpd2dq(XMMReg *d, XMMReg *s);
171
void helper_cvttps2pi(MMXReg *d, XMMReg *s);
172
void helper_cvttpd2pi(MMXReg *d, XMMReg *s);
173
int32_t helper_cvttss2si(XMMReg *s);
174
int32_t helper_cvttsd2si(XMMReg *s);
175
#ifdef TARGET_X86_64
176
int64_t helper_cvttss2sq(XMMReg *s);
177
int64_t helper_cvttsd2sq(XMMReg *s);
178
#endif
179

    
180
void helper_rsqrtps(XMMReg *d, XMMReg *s);
181
void helper_rsqrtss(XMMReg *d, XMMReg *s);
182
void helper_rcpps(XMMReg *d, XMMReg *s);
183
void helper_rcpss(XMMReg *d, XMMReg *s);
184
void helper_haddps(XMMReg *d, XMMReg *s);
185
void helper_haddpd(XMMReg *d, XMMReg *s);
186
void helper_hsubps(XMMReg *d, XMMReg *s);
187
void helper_hsubpd(XMMReg *d, XMMReg *s);
188
void helper_addsubps(XMMReg *d, XMMReg *s);
189
void helper_addsubpd(XMMReg *d, XMMReg *s);
190

    
191
#define SSE_HELPER_CMP(name, F)\
192
    void helper_ ## name ## ps (Reg *d, Reg *s);        \
193
    void helper_ ## name ## ss (Reg *d, Reg *s);        \
194
    void helper_ ## name ## pd (Reg *d, Reg *s);        \
195
    void helper_ ## name ## sd (Reg *d, Reg *s);
196

    
197
SSE_HELPER_CMP(cmpeq, FPU_CMPEQ);
198
SSE_HELPER_CMP(cmplt, FPU_CMPLT);
199
SSE_HELPER_CMP(cmple, FPU_CMPLE);
200
SSE_HELPER_CMP(cmpunord, FPU_CMPUNORD);
201
SSE_HELPER_CMP(cmpneq, FPU_CMPNEQ);
202
SSE_HELPER_CMP(cmpnlt, FPU_CMPNLT);
203
SSE_HELPER_CMP(cmpnle, FPU_CMPNLE);
204
SSE_HELPER_CMP(cmpord, FPU_CMPORD);
205

    
206
void helper_ucomiss(Reg *d, Reg *s);
207
void helper_comiss(Reg *d, Reg *s);
208
void helper_ucomisd(Reg *d, Reg *s);
209
void helper_comisd(Reg *d, Reg *s);
210
uint32_t helper_movmskps(Reg *s);
211
uint32_t helper_movmskpd(Reg *s);
212
#endif
213

    
214
uint32_t glue(helper_pmovmskb, SUFFIX)(Reg *s);
215
void glue(helper_packsswb, SUFFIX) (Reg *d, Reg *s);
216
void glue(helper_packuswb, SUFFIX) (Reg *d, Reg *s);
217
void glue(helper_packssdw, SUFFIX) (Reg *d, Reg *s);
218
#define UNPCK_OP(base_name, base)                               \
219
    void glue(helper_punpck ## base_name ## bw, SUFFIX) (Reg *d, Reg *s); \
220
    void glue(helper_punpck ## base_name ## wd, SUFFIX) (Reg *d, Reg *s); \
221
    void glue(helper_punpck ## base_name ## dq, SUFFIX) (Reg *d, Reg *s);
222

    
223
UNPCK_OP(l, 0);
224
UNPCK_OP(h, 1);
225

    
226
#if SHIFT == 1
227
void glue(helper_punpcklqdq, SUFFIX) (Reg *d, Reg *s);
228
void glue(helper_punpckhqdq, SUFFIX) (Reg *d, Reg *s);
229
#endif
230

    
231
/* 3DNow! float ops */
232
#if SHIFT == 0
233
void helper_pi2fd(MMXReg *d, MMXReg *s);
234
void helper_pi2fw(MMXReg *d, MMXReg *s);
235
void helper_pf2id(MMXReg *d, MMXReg *s);
236
void helper_pf2iw(MMXReg *d, MMXReg *s);
237
void helper_pfacc(MMXReg *d, MMXReg *s);
238
void helper_pfadd(MMXReg *d, MMXReg *s);
239
void helper_pfcmpeq(MMXReg *d, MMXReg *s);
240
void helper_pfcmpge(MMXReg *d, MMXReg *s);
241
void helper_pfcmpgt(MMXReg *d, MMXReg *s);
242
void helper_pfmax(MMXReg *d, MMXReg *s);
243
void helper_pfmin(MMXReg *d, MMXReg *s);
244
void helper_pfmul(MMXReg *d, MMXReg *s);
245
void helper_pfnacc(MMXReg *d, MMXReg *s);
246
void helper_pfpnacc(MMXReg *d, MMXReg *s);
247
void helper_pfrcp(MMXReg *d, MMXReg *s);
248
void helper_pfrsqrt(MMXReg *d, MMXReg *s);
249
void helper_pfsub(MMXReg *d, MMXReg *s);
250
void helper_pfsubr(MMXReg *d, MMXReg *s);
251
void helper_pswapd(MMXReg *d, MMXReg *s);
252
#endif
253

    
254
#undef SHIFT
255
#undef Reg
256
#undef SUFFIX
257

    
258
#undef SSE_HELPER_B
259
#undef SSE_HELPER_W
260
#undef SSE_HELPER_L
261
#undef SSE_HELPER_Q
262
#undef SSE_HELPER_S
263
#undef SSE_HELPER_CMP
264
#undef UNPCK_OP