]> git.proxmox.com Git - mirror_qemu.git/blob - target/loongarch/vec_helper.c
projects / mirror_qemu.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge tag 'gpu-pull-request' of https://gitlab.com/marcandre.lureau/qemu into staging
[mirror_qemu.git] / target / loongarch / vec_helper.c
1 /* SPDX-License-Identifier: GPL-2.0-or-later */
2 /*
3 * QEMU LoongArch vector helper functions.
4 *
5 * Copyright (c) 2022-2023 Loongson Technology Corporation Limited
6 */
7
8 #include "qemu/osdep.h"
9 #include "cpu.h"
10 #include "exec/exec-all.h"
11 #include "exec/helper-proto.h"
12 #include "fpu/softfloat.h"
13 #include "internals.h"
14 #include "tcg/tcg.h"
15 #include "vec.h"
16 #include "tcg/tcg-gvec-desc.h"
17
18 #define DO_ODD_EVEN(NAME, BIT, E1, E2, DO_OP) \
19 void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \
20 { \
21 int i; \
22 VReg *Vd = (VReg *)vd; \
23 VReg *Vj = (VReg *)vj; \
24 VReg *Vk = (VReg *)vk; \
25 typedef __typeof(Vd->E1(0)) TD; \
26 int oprsz = simd_oprsz(desc); \
27 \
28 for (i = 0; i < oprsz / (BIT / 8); i++) { \
29 Vd->E1(i) = DO_OP((TD)Vj->E2(2 * i + 1), (TD)Vk->E2(2 * i)); \
30 } \
31 }
32
33 DO_ODD_EVEN(vhaddw_h_b, 16, H, B, DO_ADD)
34 DO_ODD_EVEN(vhaddw_w_h, 32, W, H, DO_ADD)
35 DO_ODD_EVEN(vhaddw_d_w, 64, D, W, DO_ADD)
36
37 void HELPER(vhaddw_q_d)(void *vd, void *vj, void *vk, uint32_t desc)
38 {
39 int i;
40 VReg *Vd = (VReg *)vd;
41 VReg *Vj = (VReg *)vj;
42 VReg *Vk = (VReg *)vk;
43 int oprsz = simd_oprsz(desc);
44
45 for (i = 0; i < oprsz / 16 ; i++) {
46 Vd->Q(i) = int128_add(int128_makes64(Vj->D(2 * i + 1)),
47 int128_makes64(Vk->D(2 * i)));
48 }
49 }
50
51 DO_ODD_EVEN(vhsubw_h_b, 16, H, B, DO_SUB)
52 DO_ODD_EVEN(vhsubw_w_h, 32, W, H, DO_SUB)
53 DO_ODD_EVEN(vhsubw_d_w, 64, D, W, DO_SUB)
54
55 void HELPER(vhsubw_q_d)(void *vd, void *vj, void *vk, uint32_t desc)
56 {
57 int i;
58 VReg *Vd = (VReg *)vd;
59 VReg *Vj = (VReg *)vj;
60 VReg *Vk = (VReg *)vk;
61 int oprsz = simd_oprsz(desc);
62
63 for (i = 0; i < oprsz / 16; i++) {
64 Vd->Q(i) = int128_sub(int128_makes64(Vj->D(2 * i + 1)),
65 int128_makes64(Vk->D(2 * i)));
66 }
67 }
68
69 DO_ODD_EVEN(vhaddw_hu_bu, 16, UH, UB, DO_ADD)
70 DO_ODD_EVEN(vhaddw_wu_hu, 32, UW, UH, DO_ADD)
71 DO_ODD_EVEN(vhaddw_du_wu, 64, UD, UW, DO_ADD)
72
73 void HELPER(vhaddw_qu_du)(void *vd, void *vj, void *vk, uint32_t desc)
74 {
75 int i;
76 VReg *Vd = (VReg *)vd;
77 VReg *Vj = (VReg *)vj;
78 VReg *Vk = (VReg *)vk;
79 int oprsz = simd_oprsz(desc);
80
81 for (i = 0; i < oprsz / 16; i ++) {
82 Vd->Q(i) = int128_add(int128_make64(Vj->UD(2 * i + 1)),
83 int128_make64(Vk->UD(2 * i)));
84 }
85 }
86
87 DO_ODD_EVEN(vhsubw_hu_bu, 16, UH, UB, DO_SUB)
88 DO_ODD_EVEN(vhsubw_wu_hu, 32, UW, UH, DO_SUB)
89 DO_ODD_EVEN(vhsubw_du_wu, 64, UD, UW, DO_SUB)
90
91 void HELPER(vhsubw_qu_du)(void *vd, void *vj, void *vk, uint32_t desc)
92 {
93 int i;
94 VReg *Vd = (VReg *)vd;
95 VReg *Vj = (VReg *)vj;
96 VReg *Vk = (VReg *)vk;
97 int oprsz = simd_oprsz(desc);
98
99 for (i = 0; i < oprsz / 16; i++) {
100 Vd->Q(i) = int128_sub(int128_make64(Vj->UD(2 * i + 1)),
101 int128_make64(Vk->UD(2 * i)));
102 }
103 }
104
105 #define DO_EVEN(NAME, BIT, E1, E2, DO_OP) \
106 void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \
107 { \
108 int i; \
109 VReg *Vd = (VReg *)vd; \
110 VReg *Vj = (VReg *)vj; \
111 VReg *Vk = (VReg *)vk; \
112 typedef __typeof(Vd->E1(0)) TD; \
113 int oprsz = simd_oprsz(desc); \
114 \
115 for (i = 0; i < oprsz / (BIT / 8); i++) { \
116 Vd->E1(i) = DO_OP((TD)Vj->E2(2 * i) ,(TD)Vk->E2(2 * i)); \
117 } \
118 }
119
120 #define DO_ODD(NAME, BIT, E1, E2, DO_OP) \
121 void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \
122 { \
123 int i; \
124 VReg *Vd = (VReg *)vd; \
125 VReg *Vj = (VReg *)vj; \
126 VReg *Vk = (VReg *)vk; \
127 typedef __typeof(Vd->E1(0)) TD; \
128 int oprsz = simd_oprsz(desc); \
129 \
130 for (i = 0; i < oprsz / (BIT / 8); i++) { \
131 Vd->E1(i) = DO_OP((TD)Vj->E2(2 * i + 1), (TD)Vk->E2(2 * i + 1)); \
132 } \
133 }
134
135 void HELPER(vaddwev_q_d)(void *vd, void *vj, void *vk, uint32_t desc)
136 {
137 int i;
138 VReg *Vd = (VReg *)vd;
139 VReg *Vj = (VReg *)vj;
140 VReg *Vk = (VReg *)vk;
141 int oprsz = simd_oprsz(desc);
142
143 for (i = 0; i < oprsz / 16; i++) {
144 Vd->Q(i) = int128_add(int128_makes64(Vj->D(2 * i)),
145 int128_makes64(Vk->D(2 * i)));
146 }
147 }
148
149 DO_EVEN(vaddwev_h_b, 16, H, B, DO_ADD)
150 DO_EVEN(vaddwev_w_h, 32, W, H, DO_ADD)
151 DO_EVEN(vaddwev_d_w, 64, D, W, DO_ADD)
152
153 void HELPER(vaddwod_q_d)(void *vd, void *vj, void *vk, uint32_t desc)
154 {
155 int i;
156 VReg *Vd = (VReg *)vd;
157 VReg *Vj = (VReg *)vj;
158 VReg *Vk = (VReg *)vk;
159 int oprsz = simd_oprsz(desc);
160
161 for (i = 0; i < oprsz / 16; i++) {
162 Vd->Q(i) = int128_add(int128_makes64(Vj->D(2 * i +1)),
163 int128_makes64(Vk->D(2 * i +1)));
164 }
165 }
166
167 DO_ODD(vaddwod_h_b, 16, H, B, DO_ADD)
168 DO_ODD(vaddwod_w_h, 32, W, H, DO_ADD)
169 DO_ODD(vaddwod_d_w, 64, D, W, DO_ADD)
170
171 void HELPER(vsubwev_q_d)(void *vd, void *vj, void *vk, uint32_t desc)
172 {
173 int i;
174 VReg *Vd = (VReg *)vd;
175 VReg *Vj = (VReg *)vj;
176 VReg *Vk = (VReg *)vk;
177 int oprsz = simd_oprsz(desc);
178
179 for (i = 0; i < oprsz / 16; i++) {
180 Vd->Q(i) = int128_sub(int128_makes64(Vj->D(2 * i)),
181 int128_makes64(Vk->D(2 * i)));
182 }
183 }
184
185 DO_EVEN(vsubwev_h_b, 16, H, B, DO_SUB)
186 DO_EVEN(vsubwev_w_h, 32, W, H, DO_SUB)
187 DO_EVEN(vsubwev_d_w, 64, D, W, DO_SUB)
188
189 void HELPER(vsubwod_q_d)(void *vd, void *vj, void *vk, uint32_t desc)
190 {
191 int i;
192 VReg *Vd = (VReg *)vd;
193 VReg *Vj = (VReg *)vj;
194 VReg *Vk = (VReg *)vk;
195 int oprsz = simd_oprsz(desc);
196
197 for (i = 0; i < oprsz / 16; i++) {
198 Vd->Q(i) = int128_sub(int128_makes64(Vj->D(2 * i + 1)),
199 int128_makes64(Vk->D(2 * i + 1)));
200 }
201 }
202
203 DO_ODD(vsubwod_h_b, 16, H, B, DO_SUB)
204 DO_ODD(vsubwod_w_h, 32, W, H, DO_SUB)
205 DO_ODD(vsubwod_d_w, 64, D, W, DO_SUB)
206
207 void HELPER(vaddwev_q_du)(void *vd, void *vj, void *vk, uint32_t desc)
208 {
209 int i;
210 VReg *Vd = (VReg *)vd;
211 VReg *Vj = (VReg *)vj;
212 VReg *Vk = (VReg *)vk;
213 int oprsz = simd_oprsz(desc);
214
215 for (i = 0; i < oprsz / 16; i++) {
216 Vd->Q(i) = int128_add(int128_make64(Vj->UD(2 * i)),
217 int128_make64(Vk->UD(2 * i)));
218 }
219 }
220
221 DO_EVEN(vaddwev_h_bu, 16, UH, UB, DO_ADD)
222 DO_EVEN(vaddwev_w_hu, 32, UW, UH, DO_ADD)
223 DO_EVEN(vaddwev_d_wu, 64, UD, UW, DO_ADD)
224
225 void HELPER(vaddwod_q_du)(void *vd, void *vj, void *vk, uint32_t desc)
226 {
227 int i;
228 VReg *Vd = (VReg *)vd;
229 VReg *Vj = (VReg *)vj;
230 VReg *Vk = (VReg *)vk;
231 int oprsz = simd_oprsz(desc);
232
233 for (i = 0; i < oprsz / 16; i++) {
234 Vd->Q(i) = int128_add(int128_make64(Vj->UD(2 * i + 1)),
235 int128_make64(Vk->UD(2 * i + 1)));
236 }
237 }
238
239 DO_ODD(vaddwod_h_bu, 16, UH, UB, DO_ADD)
240 DO_ODD(vaddwod_w_hu, 32, UW, UH, DO_ADD)
241 DO_ODD(vaddwod_d_wu, 64, UD, UW, DO_ADD)
242
243 void HELPER(vsubwev_q_du)(void *vd, void *vj, void *vk, uint32_t desc)
244 {
245 int i;
246 VReg *Vd = (VReg *)vd;
247 VReg *Vj = (VReg *)vj;
248 VReg *Vk = (VReg *)vk;
249 int oprsz = simd_oprsz(desc);
250
251 for (i = 0; i < oprsz / 16; i++) {
252 Vd->Q(i) = int128_sub(int128_make64(Vj->UD(2 * i)),
253 int128_make64(Vk->UD(2 * i)));
254 }
255 }
256
257 DO_EVEN(vsubwev_h_bu, 16, UH, UB, DO_SUB)
258 DO_EVEN(vsubwev_w_hu, 32, UW, UH, DO_SUB)
259 DO_EVEN(vsubwev_d_wu, 64, UD, UW, DO_SUB)
260
261 void HELPER(vsubwod_q_du)(void *vd, void *vj, void *vk, uint32_t desc)
262 {
263 int i;
264 VReg *Vd = (VReg *)vd;
265 VReg *Vj = (VReg *)vj;
266 VReg *Vk = (VReg *)vk;
267 int oprsz = simd_oprsz(desc);
268
269 for (i = 0; i < oprsz / 16; i++) {
270 Vd->Q(i) = int128_sub(int128_make64(Vj->UD(2 * i + 1)),
271 int128_make64(Vk->UD(2 * i + 1)));
272 }
273 }
274
275 DO_ODD(vsubwod_h_bu, 16, UH, UB, DO_SUB)
276 DO_ODD(vsubwod_w_hu, 32, UW, UH, DO_SUB)
277 DO_ODD(vsubwod_d_wu, 64, UD, UW, DO_SUB)
278
279 #define DO_EVEN_U_S(NAME, BIT, ES1, EU1, ES2, EU2, DO_OP) \
280 void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \
281 { \
282 int i; \
283 VReg *Vd = (VReg *)vd; \
284 VReg *Vj = (VReg *)vj; \
285 VReg *Vk = (VReg *)vk; \
286 typedef __typeof(Vd->ES1(0)) TDS; \
287 typedef __typeof(Vd->EU1(0)) TDU; \
288 int oprsz = simd_oprsz(desc); \
289 \
290 for (i = 0; i < oprsz / (BIT / 8); i++) { \
291 Vd->ES1(i) = DO_OP((TDU)Vj->EU2(2 * i) ,(TDS)Vk->ES2(2 * i)); \
292 } \
293 }
294
295 #define DO_ODD_U_S(NAME, BIT, ES1, EU1, ES2, EU2, DO_OP) \
296 void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \
297 { \
298 int i; \
299 VReg *Vd = (VReg *)vd; \
300 VReg *Vj = (VReg *)vj; \
301 VReg *Vk = (VReg *)vk; \
302 typedef __typeof(Vd->ES1(0)) TDS; \
303 typedef __typeof(Vd->EU1(0)) TDU; \
304 int oprsz = simd_oprsz(desc); \
305 \
306 for (i = 0; i < oprsz / (BIT / 8); i++) { \
307 Vd->ES1(i) = DO_OP((TDU)Vj->EU2(2 * i + 1), (TDS)Vk->ES2(2 * i + 1)); \
308 } \
309 }
310
311 void HELPER(vaddwev_q_du_d)(void *vd, void *vj, void *vk, uint32_t desc)
312 {
313 int i;
314 VReg *Vd = (VReg *)vd;
315 VReg *Vj = (VReg *)vj;
316 VReg *Vk = (VReg *)vk;
317 int oprsz = simd_oprsz(desc);
318
319 for (i = 0; i < oprsz / 16; i++) {
320 Vd->Q(i) = int128_add(int128_make64(Vj->UD(2 * i)),
321 int128_makes64(Vk->D(2 * i)));
322 }
323 }
324
325 DO_EVEN_U_S(vaddwev_h_bu_b, 16, H, UH, B, UB, DO_ADD)
326 DO_EVEN_U_S(vaddwev_w_hu_h, 32, W, UW, H, UH, DO_ADD)
327 DO_EVEN_U_S(vaddwev_d_wu_w, 64, D, UD, W, UW, DO_ADD)
328
329 void HELPER(vaddwod_q_du_d)(void *vd, void *vj, void *vk, uint32_t desc)
330 {
331 int i;
332 VReg *Vd = (VReg *)vd;
333 VReg *Vj = (VReg *)vj;
334 VReg *Vk = (VReg *)vk;
335 int oprsz = simd_oprsz(desc);
336
337 for (i = 0; i < oprsz / 16; i++) {
338 Vd->Q(i) = int128_add(int128_make64(Vj->UD(2 * i + 1)),
339 int128_makes64(Vk->D(2 * i + 1)));
340 }
341 }
342
343 DO_ODD_U_S(vaddwod_h_bu_b, 16, H, UH, B, UB, DO_ADD)
344 DO_ODD_U_S(vaddwod_w_hu_h, 32, W, UW, H, UH, DO_ADD)
345 DO_ODD_U_S(vaddwod_d_wu_w, 64, D, UD, W, UW, DO_ADD)
346
347 #define DO_3OP(NAME, BIT, E, DO_OP) \
348 void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \
349 { \
350 int i; \
351 VReg *Vd = (VReg *)vd; \
352 VReg *Vj = (VReg *)vj; \
353 VReg *Vk = (VReg *)vk; \
354 int oprsz = simd_oprsz(desc); \
355 \
356 for (i = 0; i < oprsz / (BIT / 8); i++) { \
357 Vd->E(i) = DO_OP(Vj->E(i), Vk->E(i)); \
358 } \
359 }
360
361 DO_3OP(vavg_b, 8, B, DO_VAVG)
362 DO_3OP(vavg_h, 16, H, DO_VAVG)
363 DO_3OP(vavg_w, 32, W, DO_VAVG)
364 DO_3OP(vavg_d, 64, D, DO_VAVG)
365 DO_3OP(vavgr_b, 8, B, DO_VAVGR)
366 DO_3OP(vavgr_h, 16, H, DO_VAVGR)
367 DO_3OP(vavgr_w, 32, W, DO_VAVGR)
368 DO_3OP(vavgr_d, 64, D, DO_VAVGR)
369 DO_3OP(vavg_bu, 8, UB, DO_VAVG)
370 DO_3OP(vavg_hu, 16, UH, DO_VAVG)
371 DO_3OP(vavg_wu, 32, UW, DO_VAVG)
372 DO_3OP(vavg_du, 64, UD, DO_VAVG)
373 DO_3OP(vavgr_bu, 8, UB, DO_VAVGR)
374 DO_3OP(vavgr_hu, 16, UH, DO_VAVGR)
375 DO_3OP(vavgr_wu, 32, UW, DO_VAVGR)
376 DO_3OP(vavgr_du, 64, UD, DO_VAVGR)
377
378 DO_3OP(vabsd_b, 8, B, DO_VABSD)
379 DO_3OP(vabsd_h, 16, H, DO_VABSD)
380 DO_3OP(vabsd_w, 32, W, DO_VABSD)
381 DO_3OP(vabsd_d, 64, D, DO_VABSD)
382 DO_3OP(vabsd_bu, 8, UB, DO_VABSD)
383 DO_3OP(vabsd_hu, 16, UH, DO_VABSD)
384 DO_3OP(vabsd_wu, 32, UW, DO_VABSD)
385 DO_3OP(vabsd_du, 64, UD, DO_VABSD)
386
387 #define DO_VADDA(NAME, BIT, E) \
388 void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \
389 { \
390 int i; \
391 VReg *Vd = (VReg *)vd; \
392 VReg *Vj = (VReg *)vj; \
393 VReg *Vk = (VReg *)vk; \
394 int oprsz = simd_oprsz(desc); \
395 \
396 for (i = 0; i < oprsz / (BIT / 8); i++) { \
397 Vd->E(i) = DO_VABS(Vj->E(i)) + DO_VABS(Vk->E(i)); \
398 } \
399 }
400
401 DO_VADDA(vadda_b, 8, B)
402 DO_VADDA(vadda_h, 16, H)
403 DO_VADDA(vadda_w, 32, W)
404 DO_VADDA(vadda_d, 64, D)
405
406 #define VMINMAXI(NAME, BIT, E, DO_OP) \
407 void HELPER(NAME)(void *vd, void *vj, uint64_t imm, uint32_t desc) \
408 { \
409 int i; \
410 VReg *Vd = (VReg *)vd; \
411 VReg *Vj = (VReg *)vj; \
412 typedef __typeof(Vd->E(0)) TD; \
413 int oprsz = simd_oprsz(desc); \
414 \
415 for (i = 0; i < oprsz / (BIT / 8); i++) { \
416 Vd->E(i) = DO_OP(Vj->E(i), (TD)imm); \
417 } \
418 }
419
420 VMINMAXI(vmini_b, 8, B, DO_MIN)
421 VMINMAXI(vmini_h, 16, H, DO_MIN)
422 VMINMAXI(vmini_w, 32, W, DO_MIN)
423 VMINMAXI(vmini_d, 64, D, DO_MIN)
424 VMINMAXI(vmaxi_b, 8, B, DO_MAX)
425 VMINMAXI(vmaxi_h, 16, H, DO_MAX)
426 VMINMAXI(vmaxi_w, 32, W, DO_MAX)
427 VMINMAXI(vmaxi_d, 64, D, DO_MAX)
428 VMINMAXI(vmini_bu, 8, UB, DO_MIN)
429 VMINMAXI(vmini_hu, 16, UH, DO_MIN)
430 VMINMAXI(vmini_wu, 32, UW, DO_MIN)
431 VMINMAXI(vmini_du, 64, UD, DO_MIN)
432 VMINMAXI(vmaxi_bu, 8, UB, DO_MAX)
433 VMINMAXI(vmaxi_hu, 16, UH, DO_MAX)
434 VMINMAXI(vmaxi_wu, 32, UW, DO_MAX)
435 VMINMAXI(vmaxi_du, 64, UD, DO_MAX)
436
437 #define DO_VMUH(NAME, BIT, E1, E2, DO_OP) \
438 void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \
439 { \
440 int i; \
441 VReg *Vd = (VReg *)vd; \
442 VReg *Vj = (VReg *)vj; \
443 VReg *Vk = (VReg *)vk; \
444 typedef __typeof(Vd->E1(0)) T; \
445 int oprsz = simd_oprsz(desc); \
446 \
447 for (i = 0; i < oprsz / (BIT / 8); i++) { \
448 Vd->E2(i) = ((T)Vj->E2(i)) * ((T)Vk->E2(i)) >> BIT; \
449 } \
450 }
451
452 void HELPER(vmuh_d)(void *vd, void *vj, void *vk, uint32_t desc)
453 {
454 int i;
455 uint64_t l, h;
456 VReg *Vd = (VReg *)vd;
457 VReg *Vj = (VReg *)vj;
458 VReg *Vk = (VReg *)vk;
459 int oprsz = simd_oprsz(desc);
460
461 for (i = 0; i < oprsz / 8; i++) {
462 muls64(&l, &h, Vj->D(i), Vk->D(i));
463 Vd->D(i) = h;
464 }
465 }
466
467 DO_VMUH(vmuh_b, 8, H, B, DO_MUH)
468 DO_VMUH(vmuh_h, 16, W, H, DO_MUH)
469 DO_VMUH(vmuh_w, 32, D, W, DO_MUH)
470
471 void HELPER(vmuh_du)(void *vd, void *vj, void *vk, uint32_t desc)
472 {
473 int i;
474 uint64_t l, h;
475 VReg *Vd = (VReg *)vd;
476 VReg *Vj = (VReg *)vj;
477 VReg *Vk = (VReg *)vk;
478 int oprsz = simd_oprsz(desc);
479
480 for (i = 0; i < oprsz / 8; i++) {
481 mulu64(&l, &h, Vj->D(i), Vk->D(i));
482 Vd->D(i) = h;
483 }
484 }
485
486 DO_VMUH(vmuh_bu, 8, UH, UB, DO_MUH)
487 DO_VMUH(vmuh_hu, 16, UW, UH, DO_MUH)
488 DO_VMUH(vmuh_wu, 32, UD, UW, DO_MUH)
489
490 DO_EVEN(vmulwev_h_b, 16, H, B, DO_MUL)
491 DO_EVEN(vmulwev_w_h, 32, W, H, DO_MUL)
492 DO_EVEN(vmulwev_d_w, 64, D, W, DO_MUL)
493
494 DO_ODD(vmulwod_h_b, 16, H, B, DO_MUL)
495 DO_ODD(vmulwod_w_h, 32, W, H, DO_MUL)
496 DO_ODD(vmulwod_d_w, 64, D, W, DO_MUL)
497
498 DO_EVEN(vmulwev_h_bu, 16, UH, UB, DO_MUL)
499 DO_EVEN(vmulwev_w_hu, 32, UW, UH, DO_MUL)
500 DO_EVEN(vmulwev_d_wu, 64, UD, UW, DO_MUL)
501
502 DO_ODD(vmulwod_h_bu, 16, UH, UB, DO_MUL)
503 DO_ODD(vmulwod_w_hu, 32, UW, UH, DO_MUL)
504 DO_ODD(vmulwod_d_wu, 64, UD, UW, DO_MUL)
505
506 DO_EVEN_U_S(vmulwev_h_bu_b, 16, H, UH, B, UB, DO_MUL)
507 DO_EVEN_U_S(vmulwev_w_hu_h, 32, W, UW, H, UH, DO_MUL)
508 DO_EVEN_U_S(vmulwev_d_wu_w, 64, D, UD, W, UW, DO_MUL)
509
510 DO_ODD_U_S(vmulwod_h_bu_b, 16, H, UH, B, UB, DO_MUL)
511 DO_ODD_U_S(vmulwod_w_hu_h, 32, W, UW, H, UH, DO_MUL)
512 DO_ODD_U_S(vmulwod_d_wu_w, 64, D, UD, W, UW, DO_MUL)
513
514 #define VMADDSUB(NAME, BIT, E, DO_OP) \
515 void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \
516 { \
517 int i; \
518 VReg *Vd = (VReg *)vd; \
519 VReg *Vj = (VReg *)vj; \
520 VReg *Vk = (VReg *)vk; \
521 int oprsz = simd_oprsz(desc); \
522 \
523 for (i = 0; i < oprsz / (BIT / 8); i++) { \
524 Vd->E(i) = DO_OP(Vd->E(i), Vj->E(i) ,Vk->E(i)); \
525 } \
526 }
527
528 VMADDSUB(vmadd_b, 8, B, DO_MADD)
529 VMADDSUB(vmadd_h, 16, H, DO_MADD)
530 VMADDSUB(vmadd_w, 32, W, DO_MADD)
531 VMADDSUB(vmadd_d, 64, D, DO_MADD)
532 VMADDSUB(vmsub_b, 8, B, DO_MSUB)
533 VMADDSUB(vmsub_h, 16, H, DO_MSUB)
534 VMADDSUB(vmsub_w, 32, W, DO_MSUB)
535 VMADDSUB(vmsub_d, 64, D, DO_MSUB)
536
537 #define VMADDWEV(NAME, BIT, E1, E2, DO_OP) \
538 void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \
539 { \
540 int i; \
541 VReg *Vd = (VReg *)vd; \
542 VReg *Vj = (VReg *)vj; \
543 VReg *Vk = (VReg *)vk; \
544 typedef __typeof(Vd->E1(0)) TD; \
545 int oprsz = simd_oprsz(desc); \
546 \
547 for (i = 0; i < oprsz / (BIT / 8); i++) { \
548 Vd->E1(i) += DO_OP((TD)Vj->E2(2 * i), (TD)Vk->E2(2 * i)); \
549 } \
550 }
551
552 VMADDWEV(vmaddwev_h_b, 16, H, B, DO_MUL)
553 VMADDWEV(vmaddwev_w_h, 32, W, H, DO_MUL)
554 VMADDWEV(vmaddwev_d_w, 64, D, W, DO_MUL)
555 VMADDWEV(vmaddwev_h_bu, 16, UH, UB, DO_MUL)
556 VMADDWEV(vmaddwev_w_hu, 32, UW, UH, DO_MUL)
557 VMADDWEV(vmaddwev_d_wu, 64, UD, UW, DO_MUL)
558
559 #define VMADDWOD(NAME, BIT, E1, E2, DO_OP) \
560 void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \
561 { \
562 int i; \
563 VReg *Vd = (VReg *)vd; \
564 VReg *Vj = (VReg *)vj; \
565 VReg *Vk = (VReg *)vk; \
566 typedef __typeof(Vd->E1(0)) TD; \
567 int oprsz = simd_oprsz(desc); \
568 \
569 for (i = 0; i < oprsz / (BIT / 8); i++) { \
570 Vd->E1(i) += DO_OP((TD)Vj->E2(2 * i + 1), \
571 (TD)Vk->E2(2 * i + 1)); \
572 } \
573 }
574
575 VMADDWOD(vmaddwod_h_b, 16, H, B, DO_MUL)
576 VMADDWOD(vmaddwod_w_h, 32, W, H, DO_MUL)
577 VMADDWOD(vmaddwod_d_w, 64, D, W, DO_MUL)
578 VMADDWOD(vmaddwod_h_bu, 16, UH, UB, DO_MUL)
579 VMADDWOD(vmaddwod_w_hu, 32, UW, UH, DO_MUL)
580 VMADDWOD(vmaddwod_d_wu, 64, UD, UW, DO_MUL)
581
582 #define VMADDWEV_U_S(NAME, BIT, ES1, EU1, ES2, EU2, DO_OP) \
583 void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \
584 { \
585 int i; \
586 VReg *Vd = (VReg *)vd; \
587 VReg *Vj = (VReg *)vj; \
588 VReg *Vk = (VReg *)vk; \
589 typedef __typeof(Vd->ES1(0)) TS1; \
590 typedef __typeof(Vd->EU1(0)) TU1; \
591 int oprsz = simd_oprsz(desc); \
592 \
593 for (i = 0; i < oprsz / (BIT / 8); i++) { \
594 Vd->ES1(i) += DO_OP((TU1)Vj->EU2(2 * i), \
595 (TS1)Vk->ES2(2 * i)); \
596 } \
597 }
598
599 VMADDWEV_U_S(vmaddwev_h_bu_b, 16, H, UH, B, UB, DO_MUL)
600 VMADDWEV_U_S(vmaddwev_w_hu_h, 32, W, UW, H, UH, DO_MUL)
601 VMADDWEV_U_S(vmaddwev_d_wu_w, 64, D, UD, W, UW, DO_MUL)
602
603 #define VMADDWOD_U_S(NAME, BIT, ES1, EU1, ES2, EU2, DO_OP) \
604 void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \
605 { \
606 int i; \
607 VReg *Vd = (VReg *)vd; \
608 VReg *Vj = (VReg *)vj; \
609 VReg *Vk = (VReg *)vk; \
610 typedef __typeof(Vd->ES1(0)) TS1; \
611 typedef __typeof(Vd->EU1(0)) TU1; \
612 int oprsz = simd_oprsz(desc); \
613 \
614 for (i = 0; i < oprsz / (BIT / 8); i++) { \
615 Vd->ES1(i) += DO_OP((TU1)Vj->EU2(2 * i + 1), \
616 (TS1)Vk->ES2(2 * i + 1)); \
617 } \
618 }
619
620 VMADDWOD_U_S(vmaddwod_h_bu_b, 16, H, UH, B, UB, DO_MUL)
621 VMADDWOD_U_S(vmaddwod_w_hu_h, 32, W, UW, H, UH, DO_MUL)
622 VMADDWOD_U_S(vmaddwod_d_wu_w, 64, D, UD, W, UW, DO_MUL)
623
624 #define VDIV(NAME, BIT, E, DO_OP) \
625 void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \
626 { \
627 int i; \
628 VReg *Vd = (VReg *)vd; \
629 VReg *Vj = (VReg *)vj; \
630 VReg *Vk = (VReg *)vk; \
631 int oprsz = simd_oprsz(desc); \
632 \
633 for (i = 0; i < oprsz / (BIT / 8); i++) { \
634 Vd->E(i) = DO_OP(Vj->E(i), Vk->E(i)); \
635 } \
636 }
637
638 VDIV(vdiv_b, 8, B, DO_DIV)
639 VDIV(vdiv_h, 16, H, DO_DIV)
640 VDIV(vdiv_w, 32, W, DO_DIV)
641 VDIV(vdiv_d, 64, D, DO_DIV)
642 VDIV(vdiv_bu, 8, UB, DO_DIVU)
643 VDIV(vdiv_hu, 16, UH, DO_DIVU)
644 VDIV(vdiv_wu, 32, UW, DO_DIVU)
645 VDIV(vdiv_du, 64, UD, DO_DIVU)
646 VDIV(vmod_b, 8, B, DO_REM)
647 VDIV(vmod_h, 16, H, DO_REM)
648 VDIV(vmod_w, 32, W, DO_REM)
649 VDIV(vmod_d, 64, D, DO_REM)
650 VDIV(vmod_bu, 8, UB, DO_REMU)
651 VDIV(vmod_hu, 16, UH, DO_REMU)
652 VDIV(vmod_wu, 32, UW, DO_REMU)
653 VDIV(vmod_du, 64, UD, DO_REMU)
654
655 #define VSAT_S(NAME, BIT, E) \
656 void HELPER(NAME)(void *vd, void *vj, uint64_t max, uint32_t desc) \
657 { \
658 int i; \
659 VReg *Vd = (VReg *)vd; \
660 VReg *Vj = (VReg *)vj; \
661 typedef __typeof(Vd->E(0)) TD; \
662 int oprsz = simd_oprsz(desc); \
663 \
664 for (i = 0; i < oprsz / (BIT / 8); i++) { \
665 Vd->E(i) = Vj->E(i) > (TD)max ? (TD)max : \
666 Vj->E(i) < (TD)~max ? (TD)~max: Vj->E(i); \
667 } \
668 }
669
670 VSAT_S(vsat_b, 8, B)
671 VSAT_S(vsat_h, 16, H)
672 VSAT_S(vsat_w, 32, W)
673 VSAT_S(vsat_d, 64, D)
674
675 #define VSAT_U(NAME, BIT, E) \
676 void HELPER(NAME)(void *vd, void *vj, uint64_t max, uint32_t desc) \
677 { \
678 int i; \
679 VReg *Vd = (VReg *)vd; \
680 VReg *Vj = (VReg *)vj; \
681 typedef __typeof(Vd->E(0)) TD; \
682 int oprsz = simd_oprsz(desc); \
683 \
684 for (i = 0; i < oprsz / (BIT / 8); i++) { \
685 Vd->E(i) = Vj->E(i) > (TD)max ? (TD)max : Vj->E(i); \
686 } \
687 }
688
689 VSAT_U(vsat_bu, 8, UB)
690 VSAT_U(vsat_hu, 16, UH)
691 VSAT_U(vsat_wu, 32, UW)
692 VSAT_U(vsat_du, 64, UD)
693
694 #define VEXTH(NAME, BIT, E1, E2) \
695 void HELPER(NAME)(void *vd, void *vj, uint32_t desc) \
696 { \
697 int i, j, ofs; \
698 VReg *Vd = (VReg *)vd; \
699 VReg *Vj = (VReg *)vj; \
700 int oprsz = simd_oprsz(desc); \
701 \
702 ofs = LSX_LEN / BIT; \
703 for (i = 0; i < oprsz / 16; i++) { \
704 for (j = 0; j < ofs; j++) { \
705 Vd->E1(j + i * ofs) = Vj->E2(j + ofs + ofs * 2 * i); \
706 } \
707 } \
708 }
709
710 void HELPER(vexth_q_d)(void *vd, void *vj, uint32_t desc)
711 {
712 int i;
713 VReg *Vd = (VReg *)vd;
714 VReg *Vj = (VReg *)vj;
715 int oprsz = simd_oprsz(desc);
716
717 for (i = 0; i < oprsz / 16; i++) {
718 Vd->Q(i) = int128_makes64(Vj->D(2 * i + 1));
719 }
720 }
721
722 void HELPER(vexth_qu_du)(void *vd, void *vj, uint32_t desc)
723 {
724 int i;
725 VReg *Vd = (VReg *)vd;
726 VReg *Vj = (VReg *)vj;
727 int oprsz = simd_oprsz(desc);
728
729 for (i = 0; i < oprsz / 16; i++) {
730 Vd->Q(i) = int128_make64(Vj->UD(2 * i + 1));
731 }
732 }
733
734 VEXTH(vexth_h_b, 16, H, B)
735 VEXTH(vexth_w_h, 32, W, H)
736 VEXTH(vexth_d_w, 64, D, W)
737 VEXTH(vexth_hu_bu, 16, UH, UB)
738 VEXTH(vexth_wu_hu, 32, UW, UH)
739 VEXTH(vexth_du_wu, 64, UD, UW)
740
741 #define VEXT2XV(NAME, BIT, E1, E2) \
742 void HELPER(NAME)(void *vd, void *vj, uint32_t desc) \
743 { \
744 int i; \
745 VReg temp = {}; \
746 VReg *Vd = (VReg *)vd; \
747 VReg *Vj = (VReg *)vj; \
748 int oprsz = simd_oprsz(desc); \
749 \
750 for (i = 0; i < oprsz / (BIT / 8); i++) { \
751 temp.E1(i) = Vj->E2(i); \
752 } \
753 *Vd = temp; \
754 }
755
756 VEXT2XV(vext2xv_h_b, 16, H, B)
757 VEXT2XV(vext2xv_w_b, 32, W, B)
758 VEXT2XV(vext2xv_d_b, 64, D, B)
759 VEXT2XV(vext2xv_w_h, 32, W, H)
760 VEXT2XV(vext2xv_d_h, 64, D, H)
761 VEXT2XV(vext2xv_d_w, 64, D, W)
762 VEXT2XV(vext2xv_hu_bu, 16, UH, UB)
763 VEXT2XV(vext2xv_wu_bu, 32, UW, UB)
764 VEXT2XV(vext2xv_du_bu, 64, UD, UB)
765 VEXT2XV(vext2xv_wu_hu, 32, UW, UH)
766 VEXT2XV(vext2xv_du_hu, 64, UD, UH)
767 VEXT2XV(vext2xv_du_wu, 64, UD, UW)
768
769 DO_3OP(vsigncov_b, 8, B, DO_SIGNCOV)
770 DO_3OP(vsigncov_h, 16, H, DO_SIGNCOV)
771 DO_3OP(vsigncov_w, 32, W, DO_SIGNCOV)
772 DO_3OP(vsigncov_d, 64, D, DO_SIGNCOV)
773
774 static uint64_t do_vmskltz_b(int64_t val)
775 {
776 uint64_t m = 0x8080808080808080ULL;
777 uint64_t c = val & m;
778 c |= c << 7;
779 c |= c << 14;
780 c |= c << 28;
781 return c >> 56;
782 }
783
784 void HELPER(vmskltz_b)(void *vd, void *vj, uint32_t desc)
785 {
786 int i;
787 uint16_t temp = 0;
788 VReg *Vd = (VReg *)vd;
789 VReg *Vj = (VReg *)vj;
790 int oprsz = simd_oprsz(desc);
791
792 for (i = 0; i < oprsz / 16; i++) {
793 temp = 0;
794 temp = do_vmskltz_b(Vj->D(2 * i));
795 temp |= (do_vmskltz_b(Vj->D(2 * i + 1)) << 8);
796 Vd->D(2 * i) = temp;
797 Vd->D(2 * i + 1) = 0;
798 }
799 }
800
801 static uint64_t do_vmskltz_h(int64_t val)
802 {
803 uint64_t m = 0x8000800080008000ULL;
804 uint64_t c = val & m;
805 c |= c << 15;
806 c |= c << 30;
807 return c >> 60;
808 }
809
810 void HELPER(vmskltz_h)(void *vd, void *vj, uint32_t desc)
811 {
812 int i;
813 uint16_t temp = 0;
814 VReg *Vd = (VReg *)vd;
815 VReg *Vj = (VReg *)vj;
816 int oprsz = simd_oprsz(desc);
817
818 for (i = 0; i < oprsz / 16; i++) {
819 temp = 0;
820 temp = do_vmskltz_h(Vj->D(2 * i));
821 temp |= (do_vmskltz_h(Vj->D(2 * i + 1)) << 4);
822 Vd->D(2 * i) = temp;
823 Vd->D(2 * i + 1) = 0;
824 }
825 }
826
827 static uint64_t do_vmskltz_w(int64_t val)
828 {
829 uint64_t m = 0x8000000080000000ULL;
830 uint64_t c = val & m;
831 c |= c << 31;
832 return c >> 62;
833 }
834
835 void HELPER(vmskltz_w)(void *vd, void *vj, uint32_t desc)
836 {
837 int i;
838 uint16_t temp = 0;
839 VReg *Vd = (VReg *)vd;
840 VReg *Vj = (VReg *)vj;
841 int oprsz = simd_oprsz(desc);
842
843 for (i = 0; i < oprsz / 16; i++) {
844 temp = 0;
845 temp = do_vmskltz_w(Vj->D(2 * i));
846 temp |= (do_vmskltz_w(Vj->D(2 * i + 1)) << 2);
847 Vd->D(2 * i) = temp;
848 Vd->D(2 * i + 1) = 0;
849 }
850 }
851
852 static uint64_t do_vmskltz_d(int64_t val)
853 {
854 return (uint64_t)val >> 63;
855 }
856 void HELPER(vmskltz_d)(void *vd, void *vj, uint32_t desc)
857 {
858 int i;
859 uint16_t temp = 0;
860 VReg *Vd = (VReg *)vd;
861 VReg *Vj = (VReg *)vj;
862 int oprsz = simd_oprsz(desc);
863
864 for (i = 0; i < oprsz / 16; i++) {
865 temp = 0;
866 temp = do_vmskltz_d(Vj->D(2 * i));
867 temp |= (do_vmskltz_d(Vj->D(2 * i + 1)) << 1);
868 Vd->D(2 * i) = temp;
869 Vd->D(2 * i + 1) = 0;
870 }
871 }
872
873 void HELPER(vmskgez_b)(void *vd, void *vj, uint32_t desc)
874 {
875 int i;
876 uint16_t temp = 0;
877 VReg *Vd = (VReg *)vd;
878 VReg *Vj = (VReg *)vj;
879 int oprsz = simd_oprsz(desc);
880
881 for (i = 0; i < oprsz / 16; i++) {
882 temp = 0;
883 temp = do_vmskltz_b(Vj->D(2 * i));
884 temp |= (do_vmskltz_b(Vj->D(2 * i + 1)) << 8);
885 Vd->D(2 * i) = (uint16_t)(~temp);
886 Vd->D(2 * i + 1) = 0;
887 }
888 }
889
890 static uint64_t do_vmskez_b(uint64_t a)
891 {
892 uint64_t m = 0x7f7f7f7f7f7f7f7fULL;
893 uint64_t c = ~(((a & m) + m) | a | m);
894 c |= c << 7;
895 c |= c << 14;
896 c |= c << 28;
897 return c >> 56;
898 }
899
900 void HELPER(vmsknz_b)(void *vd, void *vj, uint32_t desc)
901 {
902 int i;
903 uint16_t temp = 0;
904 VReg *Vd = (VReg *)vd;
905 VReg *Vj = (VReg *)vj;
906 int oprsz = simd_oprsz(desc);
907
908 for (i = 0; i < oprsz / 16; i++) {
909 temp = 0;
910 temp = do_vmskez_b(Vj->D(2 * i));
911 temp |= (do_vmskez_b(Vj->D(2 * i + 1)) << 8);
912 Vd->D(2 * i) = (uint16_t)(~temp);
913 Vd->D(2 * i + 1) = 0;
914 }
915 }
916
917 void HELPER(vnori_b)(void *vd, void *vj, uint64_t imm, uint32_t desc)
918 {
919 int i;
920 VReg *Vd = (VReg *)vd;
921 VReg *Vj = (VReg *)vj;
922
923 for (i = 0; i < simd_oprsz(desc); i++) {
924 Vd->B(i) = ~(Vj->B(i) | (uint8_t)imm);
925 }
926 }
927
928 #define VSLLWIL(NAME, BIT, E1, E2) \
929 void HELPER(NAME)(void *vd, void *vj, uint64_t imm, uint32_t desc) \
930 { \
931 int i, j, ofs; \
932 VReg temp = {}; \
933 VReg *Vd = (VReg *)vd; \
934 VReg *Vj = (VReg *)vj; \
935 int oprsz = simd_oprsz(desc); \
936 typedef __typeof(temp.E1(0)) TD; \
937 \
938 ofs = LSX_LEN / BIT; \
939 for (i = 0; i < oprsz / 16; i++) { \
940 for (j = 0; j < ofs; j++) { \
941 temp.E1(j + ofs * i) = (TD)Vj->E2(j + ofs * 2 * i) << (imm % BIT); \
942 } \
943 } \
944 *Vd = temp; \
945 }
946
947
948 void HELPER(vextl_q_d)(void *vd, void *vj, uint32_t desc)
949 {
950 int i;
951 VReg *Vd = (VReg *)vd;
952 VReg *Vj = (VReg *)vj;
953 int oprsz = simd_oprsz(desc);
954
955 for (i = 0; i < oprsz / 16; i++) {
956 Vd->Q(i) = int128_makes64(Vj->D(2 * i));
957 }
958 }
959
960 void HELPER(vextl_qu_du)(void *vd, void *vj, uint32_t desc)
961 {
962 int i;
963 VReg *Vd = (VReg *)vd;
964 VReg *Vj = (VReg *)vj;
965 int oprsz = simd_oprsz(desc);
966
967 for (i = 0; i < oprsz / 16; i++) {
968 Vd->Q(i) = int128_make64(Vj->UD(2 * i));
969 }
970 }
971
972 VSLLWIL(vsllwil_h_b, 16, H, B)
973 VSLLWIL(vsllwil_w_h, 32, W, H)
974 VSLLWIL(vsllwil_d_w, 64, D, W)
975 VSLLWIL(vsllwil_hu_bu, 16, UH, UB)
976 VSLLWIL(vsllwil_wu_hu, 32, UW, UH)
977 VSLLWIL(vsllwil_du_wu, 64, UD, UW)
978
979 #define do_vsrlr(E, T) \
980 static T do_vsrlr_ ##E(T s1, int sh) \
981 { \
982 if (sh == 0) { \
983 return s1; \
984 } else { \
985 return (s1 >> sh) + ((s1 >> (sh - 1)) & 0x1); \
986 } \
987 }
988
989 do_vsrlr(B, uint8_t)
990 do_vsrlr(H, uint16_t)
991 do_vsrlr(W, uint32_t)
992 do_vsrlr(D, uint64_t)
993
994 #define VSRLR(NAME, BIT, T, E) \
995 void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \
996 { \
997 int i; \
998 VReg *Vd = (VReg *)vd; \
999 VReg *Vj = (VReg *)vj; \
1000 VReg *Vk = (VReg *)vk; \
1001 int oprsz = simd_oprsz(desc); \
1002 \
1003 for (i = 0; i < oprsz / (BIT / 8); i++) { \
1004 Vd->E(i) = do_vsrlr_ ## E(Vj->E(i), ((T)Vk->E(i))%BIT); \
1005 } \
1006 }
1007
1008 VSRLR(vsrlr_b, 8, uint8_t, B)
1009 VSRLR(vsrlr_h, 16, uint16_t, H)
1010 VSRLR(vsrlr_w, 32, uint32_t, W)
1011 VSRLR(vsrlr_d, 64, uint64_t, D)
1012
1013 #define VSRLRI(NAME, BIT, E) \
1014 void HELPER(NAME)(void *vd, void *vj, uint64_t imm, uint32_t desc) \
1015 { \
1016 int i; \
1017 VReg *Vd = (VReg *)vd; \
1018 VReg *Vj = (VReg *)vj; \
1019 int oprsz = simd_oprsz(desc); \
1020 \
1021 for (i = 0; i < oprsz / (BIT / 8); i++) { \
1022 Vd->E(i) = do_vsrlr_ ## E(Vj->E(i), imm); \
1023 } \
1024 }
1025
1026 VSRLRI(vsrlri_b, 8, B)
1027 VSRLRI(vsrlri_h, 16, H)
1028 VSRLRI(vsrlri_w, 32, W)
1029 VSRLRI(vsrlri_d, 64, D)
1030
1031 #define do_vsrar(E, T) \
1032 static T do_vsrar_ ##E(T s1, int sh) \
1033 { \
1034 if (sh == 0) { \
1035 return s1; \
1036 } else { \
1037 return (s1 >> sh) + ((s1 >> (sh - 1)) & 0x1); \
1038 } \
1039 }
1040
1041 do_vsrar(B, int8_t)
1042 do_vsrar(H, int16_t)
1043 do_vsrar(W, int32_t)
1044 do_vsrar(D, int64_t)
1045
1046 #define VSRAR(NAME, BIT, T, E) \
1047 void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \
1048 { \
1049 int i; \
1050 VReg *Vd = (VReg *)vd; \
1051 VReg *Vj = (VReg *)vj; \
1052 VReg *Vk = (VReg *)vk; \
1053 int oprsz = simd_oprsz(desc); \
1054 \
1055 for (i = 0; i < oprsz / (BIT / 8); i++) { \
1056 Vd->E(i) = do_vsrar_ ## E(Vj->E(i), ((T)Vk->E(i))%BIT); \
1057 } \
1058 }
1059
1060 VSRAR(vsrar_b, 8, uint8_t, B)
1061 VSRAR(vsrar_h, 16, uint16_t, H)
1062 VSRAR(vsrar_w, 32, uint32_t, W)
1063 VSRAR(vsrar_d, 64, uint64_t, D)
1064
1065 #define VSRARI(NAME, BIT, E) \
1066 void HELPER(NAME)(void *vd, void *vj, uint64_t imm, uint32_t desc) \
1067 { \
1068 int i; \
1069 VReg *Vd = (VReg *)vd; \
1070 VReg *Vj = (VReg *)vj; \
1071 int oprsz = simd_oprsz(desc); \
1072 \
1073 for (i = 0; i < oprsz / (BIT / 8); i++) { \
1074 Vd->E(i) = do_vsrar_ ## E(Vj->E(i), imm); \
1075 } \
1076 }
1077
1078 VSRARI(vsrari_b, 8, B)
1079 VSRARI(vsrari_h, 16, H)
1080 VSRARI(vsrari_w, 32, W)
1081 VSRARI(vsrari_d, 64, D)
1082
1083 #define VSRLN(NAME, BIT, E1, E2) \
1084 void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \
1085 { \
1086 int i, j, ofs; \
1087 VReg *Vd = (VReg *)vd; \
1088 VReg *Vj = (VReg *)vj; \
1089 VReg *Vk = (VReg *)vk; \
1090 int oprsz = simd_oprsz(desc); \
1091 \
1092 ofs = LSX_LEN / BIT; \
1093 for (i = 0; i < oprsz / 16; i++) { \
1094 for (j = 0; j < ofs; j++) { \
1095 Vd->E1(j + ofs * 2 * i) = R_SHIFT(Vj->E2(j + ofs * i), \
1096 Vk->E2(j + ofs * i) % BIT); \
1097 } \
1098 Vd->D(2 * i + 1) = 0; \
1099 } \
1100 }
1101
1102 VSRLN(vsrln_b_h, 16, B, UH)
1103 VSRLN(vsrln_h_w, 32, H, UW)
1104 VSRLN(vsrln_w_d, 64, W, UD)
1105
1106 #define VSRAN(NAME, BIT, E1, E2, E3) \
1107 void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \
1108 { \
1109 int i, j, ofs; \
1110 VReg *Vd = (VReg *)vd; \
1111 VReg *Vj = (VReg *)vj; \
1112 VReg *Vk = (VReg *)vk; \
1113 int oprsz = simd_oprsz(desc); \
1114 \
1115 ofs = LSX_LEN / BIT; \
1116 for (i = 0; i < oprsz / 16; i++) { \
1117 for (j = 0; j < ofs; j++) { \
1118 Vd->E1(j + ofs * 2 * i) = R_SHIFT(Vj->E2(j + ofs * i), \
1119 Vk->E3(j + ofs * i) % BIT); \
1120 } \
1121 Vd->D(2 * i + 1) = 0; \
1122 } \
1123 }
1124
1125 VSRAN(vsran_b_h, 16, B, H, UH)
1126 VSRAN(vsran_h_w, 32, H, W, UW)
1127 VSRAN(vsran_w_d, 64, W, D, UD)
1128
1129 #define VSRLNI(NAME, BIT, E1, E2) \
1130 void HELPER(NAME)(void *vd, void *vj, uint64_t imm, uint32_t desc) \
1131 { \
1132 int i, j, ofs; \
1133 VReg temp = {}; \
1134 VReg *Vd = (VReg *)vd; \
1135 VReg *Vj = (VReg *)vj; \
1136 int oprsz = simd_oprsz(desc); \
1137 \
1138 ofs = LSX_LEN / BIT; \
1139 for (i = 0; i < oprsz / 16; i++) { \
1140 for (j = 0; j < ofs; j++) { \
1141 temp.E1(j + ofs * 2 * i) = R_SHIFT(Vj->E2(j + ofs * i), imm); \
1142 temp.E1(j + ofs * (2 * i + 1)) = R_SHIFT(Vd->E2(j + ofs * i), \
1143 imm); \
1144 } \
1145 } \
1146 *Vd = temp; \
1147 }
1148
1149 void HELPER(vsrlni_d_q)(void *vd, void *vj, uint64_t imm, uint32_t desc)
1150 {
1151 int i;
1152 VReg temp = {};
1153 VReg *Vd = (VReg *)vd;
1154 VReg *Vj = (VReg *)vj;
1155
1156 for (i = 0; i < 2; i++) {
1157 temp.D(2 * i) = int128_getlo(int128_urshift(Vj->Q(i), imm % 128));
1158 temp.D(2 * i +1) = int128_getlo(int128_urshift(Vd->Q(i), imm % 128));
1159 }
1160 *Vd = temp;
1161 }
1162
1163 VSRLNI(vsrlni_b_h, 16, B, UH)
1164 VSRLNI(vsrlni_h_w, 32, H, UW)
1165 VSRLNI(vsrlni_w_d, 64, W, UD)
1166
1167 #define VSRANI(NAME, BIT, E1, E2) \
1168 void HELPER(NAME)(void *vd, void *vj, uint64_t imm, uint32_t desc) \
1169 { \
1170 int i, j, ofs; \
1171 VReg temp = {}; \
1172 VReg *Vd = (VReg *)vd; \
1173 VReg *Vj = (VReg *)vj; \
1174 int oprsz = simd_oprsz(desc); \
1175 \
1176 ofs = LSX_LEN / BIT; \
1177 for (i = 0; i < oprsz / 16; i++) { \
1178 for (j = 0; j < ofs; j++) { \
1179 temp.E1(j + ofs * 2 * i) = R_SHIFT(Vj->E2(j + ofs * i), imm); \
1180 temp.E1(j + ofs * (2 * i + 1)) = R_SHIFT(Vd->E2(j + ofs * i), \
1181 imm); \
1182 } \
1183 } \
1184 *Vd = temp; \
1185 }
1186
1187 void HELPER(vsrani_d_q)(void *vd, void *vj, uint64_t imm, uint32_t desc)
1188 {
1189 int i;
1190 VReg temp = {};
1191 VReg *Vd = (VReg *)vd;
1192 VReg *Vj = (VReg *)vj;
1193
1194 for (i = 0; i < 2; i++) {
1195 temp.D(2 * i) = int128_getlo(int128_rshift(Vj->Q(i), imm % 128));
1196 temp.D(2 * i + 1) = int128_getlo(int128_rshift(Vd->Q(i), imm % 128));
1197 }
1198 *Vd = temp;
1199 }
1200
1201 VSRANI(vsrani_b_h, 16, B, H)
1202 VSRANI(vsrani_h_w, 32, H, W)
1203 VSRANI(vsrani_w_d, 64, W, D)
1204
1205 #define VSRLRN(NAME, BIT, E1, E2, E3) \
1206 void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \
1207 { \
1208 int i, j, ofs; \
1209 VReg *Vd = (VReg *)vd; \
1210 VReg *Vj = (VReg *)vj; \
1211 VReg *Vk = (VReg *)vk; \
1212 int oprsz = simd_oprsz(desc); \
1213 \
1214 ofs = LSX_LEN / BIT; \
1215 for (i = 0; i < oprsz / 16; i++) { \
1216 for (j = 0; j < ofs; j++) { \
1217 Vd->E1(j + ofs * 2 * i) = do_vsrlr_ ##E2(Vj->E2(j + ofs * i), \
1218 Vk->E3(j + ofs * i) % BIT); \
1219 } \
1220 Vd->D(2 * i + 1) = 0; \
1221 } \
1222 }
1223
1224 VSRLRN(vsrlrn_b_h, 16, B, H, UH)
1225 VSRLRN(vsrlrn_h_w, 32, H, W, UW)
1226 VSRLRN(vsrlrn_w_d, 64, W, D, UD)
1227
1228 #define VSRARN(NAME, BIT, E1, E2, E3) \
1229 void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \
1230 { \
1231 int i, j, ofs; \
1232 VReg *Vd = (VReg *)vd; \
1233 VReg *Vj = (VReg *)vj; \
1234 VReg *Vk = (VReg *)vk; \
1235 int oprsz = simd_oprsz(desc); \
1236 \
1237 ofs = LSX_LEN / BIT; \
1238 for (i = 0; i < oprsz / 16; i++) { \
1239 for (j = 0; j < ofs; j++) { \
1240 Vd->E1(j + ofs * 2 * i) = do_vsrar_ ## E2(Vj->E2(j + ofs * i), \
1241 Vk->E3(j + ofs * i) % BIT); \
1242 } \
1243 Vd->D(2 * i + 1) = 0; \
1244 } \
1245 }
1246
1247 VSRARN(vsrarn_b_h, 16, B, H, UH)
1248 VSRARN(vsrarn_h_w, 32, H, W, UW)
1249 VSRARN(vsrarn_w_d, 64, W, D, UD)
1250
1251 #define VSRLRNI(NAME, BIT, E1, E2) \
1252 void HELPER(NAME)(void *vd, void *vj, uint64_t imm, uint32_t desc) \
1253 { \
1254 int i, j, ofs; \
1255 VReg temp = {}; \
1256 VReg *Vd = (VReg *)vd; \
1257 VReg *Vj = (VReg *)vj; \
1258 int oprsz = simd_oprsz(desc); \
1259 \
1260 ofs = LSX_LEN / BIT; \
1261 for (i = 0; i < oprsz / 16; i++) { \
1262 for (j = 0; j < ofs; j++) { \
1263 temp.E1(j + ofs * 2 * i) = do_vsrlr_ ## E2(Vj->E2(j + ofs * i), imm); \
1264 temp.E1(j + ofs * (2 * i + 1)) = do_vsrlr_ ## E2(Vd->E2(j + ofs * i), \
1265 imm); \
1266 } \
1267 } \
1268 *Vd = temp; \
1269 }
1270
1271 void HELPER(vsrlrni_d_q)(void *vd, void *vj, uint64_t imm, uint32_t desc)
1272 {
1273 int i;
1274 VReg temp = {};
1275 VReg *Vd = (VReg *)vd;
1276 VReg *Vj = (VReg *)vj;
1277 Int128 r[4];
1278 int oprsz = simd_oprsz(desc);
1279
1280 for (i = 0; i < oprsz / 16; i++) {
1281 if (imm == 0) {
1282 temp.D(2 * i) = int128_getlo(Vj->Q(i));
1283 temp.D(2 * i + 1) = int128_getlo(Vd->Q(i));
1284 } else {
1285 r[2 * i] = int128_and(int128_urshift(Vj->Q(i), (imm - 1)),
1286 int128_one());
1287 r[2 * i + 1] = int128_and(int128_urshift(Vd->Q(i), (imm - 1)),
1288 int128_one());
1289 temp.D(2 * i) = int128_getlo(int128_add(int128_urshift(Vj->Q(i),
1290 imm), r[2 * i]));
1291 temp.D(2 * i + 1) = int128_getlo(int128_add(int128_urshift(Vd->Q(i),
1292 imm), r[ 2 * i + 1]));
1293 }
1294 }
1295 *Vd = temp;
1296 }
1297
1298 VSRLRNI(vsrlrni_b_h, 16, B, H)
1299 VSRLRNI(vsrlrni_h_w, 32, H, W)
1300 VSRLRNI(vsrlrni_w_d, 64, W, D)
1301
1302 #define VSRARNI(NAME, BIT, E1, E2) \
1303 void HELPER(NAME)(void *vd, void *vj, uint64_t imm, uint32_t desc) \
1304 { \
1305 int i, j, ofs; \
1306 VReg temp = {}; \
1307 VReg *Vd = (VReg *)vd; \
1308 VReg *Vj = (VReg *)vj; \
1309 int oprsz = simd_oprsz(desc); \
1310 \
1311 ofs = LSX_LEN / BIT; \
1312 for (i = 0; i < oprsz / 16; i++) { \
1313 for (j = 0; j < ofs; j++) { \
1314 temp.E1(j + ofs * 2 * i) = do_vsrar_ ## E2(Vj->E2(j + ofs * i), imm); \
1315 temp.E1(j + ofs * (2 * i + 1)) = do_vsrar_ ## E2(Vd->E2(j + ofs * i), \
1316 imm); \
1317 } \
1318 } \
1319 *Vd = temp; \
1320 }
1321
1322 void HELPER(vsrarni_d_q)(void *vd, void *vj, uint64_t imm, uint32_t desc)
1323 {
1324 int i;
1325 VReg temp = {};
1326 VReg *Vd = (VReg *)vd;
1327 VReg *Vj = (VReg *)vj;
1328 Int128 r[4];
1329 int oprsz = simd_oprsz(desc);
1330
1331 for (i = 0; i < oprsz / 16; i++) {
1332 if (imm == 0) {
1333 temp.D(2 * i) = int128_getlo(Vj->Q(i));
1334 temp.D(2 * i + 1) = int128_getlo(Vd->Q(i));
1335 } else {
1336 r[2 * i] = int128_and(int128_rshift(Vj->Q(i), (imm - 1)),
1337 int128_one());
1338 r[2 * i + 1] = int128_and(int128_rshift(Vd->Q(i), (imm - 1)),
1339 int128_one());
1340 temp.D(2 * i) = int128_getlo(int128_add(int128_rshift(Vj->Q(i),
1341 imm), r[2 * i]));
1342 temp.D(2 * i + 1) = int128_getlo(int128_add(int128_rshift(Vd->Q(i),
1343 imm), r[2 * i + 1]));
1344 }
1345 }
1346 *Vd = temp;
1347 }
1348
1349 VSRARNI(vsrarni_b_h, 16, B, H)
1350 VSRARNI(vsrarni_h_w, 32, H, W)
1351 VSRARNI(vsrarni_w_d, 64, W, D)
1352
1353 #define SSRLNS(NAME, T1, T2, T3) \
1354 static T1 do_ssrlns_ ## NAME(T2 e2, int sa, int sh) \
1355 { \
1356 T1 shft_res; \
1357 if (sa == 0) { \
1358 shft_res = e2; \
1359 } else { \
1360 shft_res = (((T1)e2) >> sa); \
1361 } \
1362 T3 mask; \
1363 mask = (1ull << sh) -1; \
1364 if (shft_res > mask) { \
1365 return mask; \
1366 } else { \
1367 return shft_res; \
1368 } \
1369 }
1370
1371 SSRLNS(B, uint16_t, int16_t, uint8_t)
1372 SSRLNS(H, uint32_t, int32_t, uint16_t)
1373 SSRLNS(W, uint64_t, int64_t, uint32_t)
1374
1375 #define VSSRLN(NAME, BIT, E1, E2, E3) \
1376 void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \
1377 { \
1378 int i, j, ofs; \
1379 VReg *Vd = (VReg *)vd; \
1380 VReg *Vj = (VReg *)vj; \
1381 VReg *Vk = (VReg *)vk; \
1382 int oprsz = simd_oprsz(desc); \
1383 \
1384 ofs = LSX_LEN / BIT; \
1385 for (i = 0; i < oprsz / 16; i++) { \
1386 for (j = 0; j < ofs; j++) { \
1387 Vd->E1(j + ofs * 2 * i) = do_ssrlns_ ## E1(Vj->E2(j + ofs * i), \
1388 Vk->E3(j + ofs * i) % BIT, \
1389 BIT / 2 - 1); \
1390 } \
1391 Vd->D(2 * i + 1) = 0; \
1392 } \
1393 }
1394
1395 VSSRLN(vssrln_b_h, 16, B, H, UH)
1396 VSSRLN(vssrln_h_w, 32, H, W, UW)
1397 VSSRLN(vssrln_w_d, 64, W, D, UD)
1398
1399 #define SSRANS(E, T1, T2) \
1400 static T1 do_ssrans_ ## E(T1 e2, int sa, int sh) \
1401 { \
1402 T1 shft_res; \
1403 if (sa == 0) { \
1404 shft_res = e2; \
1405 } else { \
1406 shft_res = e2 >> sa; \
1407 } \
1408 T2 mask; \
1409 mask = (1ll << sh) - 1; \
1410 if (shft_res > mask) { \
1411 return mask; \
1412 } else if (shft_res < -(mask + 1)) { \
1413 return ~mask; \
1414 } else { \
1415 return shft_res; \
1416 } \
1417 }
1418
1419 SSRANS(B, int16_t, int8_t)
1420 SSRANS(H, int32_t, int16_t)
1421 SSRANS(W, int64_t, int32_t)
1422
1423 #define VSSRAN(NAME, BIT, E1, E2, E3) \
1424 void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \
1425 { \
1426 int i, j, ofs; \
1427 VReg *Vd = (VReg *)vd; \
1428 VReg *Vj = (VReg *)vj; \
1429 VReg *Vk = (VReg *)vk; \
1430 int oprsz = simd_oprsz(desc); \
1431 \
1432 ofs = LSX_LEN / BIT; \
1433 for (i = 0; i < oprsz / 16; i++) { \
1434 for (j = 0; j < ofs; j++) { \
1435 Vd->E1(j + ofs * 2 * i) = do_ssrans_ ## E1(Vj->E2(j + ofs * i), \
1436 Vk->E3(j + ofs * i) % BIT, \
1437 BIT / 2 - 1); \
1438 } \
1439 Vd->D(2 * i + 1) = 0; \
1440 } \
1441 }
1442
1443 VSSRAN(vssran_b_h, 16, B, H, UH)
1444 VSSRAN(vssran_h_w, 32, H, W, UW)
1445 VSSRAN(vssran_w_d, 64, W, D, UD)
1446
1447 #define SSRLNU(E, T1, T2, T3) \
1448 static T1 do_ssrlnu_ ## E(T3 e2, int sa, int sh) \
1449 { \
1450 T1 shft_res; \
1451 if (sa == 0) { \
1452 shft_res = e2; \
1453 } else { \
1454 shft_res = (((T1)e2) >> sa); \
1455 } \
1456 T2 mask; \
1457 mask = (1ull << sh) - 1; \
1458 if (shft_res > mask) { \
1459 return mask; \
1460 } else { \
1461 return shft_res; \
1462 } \
1463 }
1464
1465 SSRLNU(B, uint16_t, uint8_t, int16_t)
1466 SSRLNU(H, uint32_t, uint16_t, int32_t)
1467 SSRLNU(W, uint64_t, uint32_t, int64_t)
1468
1469 #define VSSRLNU(NAME, BIT, E1, E2, E3) \
1470 void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \
1471 { \
1472 int i, j, ofs; \
1473 VReg *Vd = (VReg *)vd; \
1474 VReg *Vj = (VReg *)vj; \
1475 VReg *Vk = (VReg *)vk; \
1476 int oprsz = simd_oprsz(desc); \
1477 \
1478 ofs = LSX_LEN / BIT; \
1479 for (i = 0; i < oprsz / 16; i++) { \
1480 for (j = 0; j < ofs; j++) { \
1481 Vd->E1(j + ofs * 2 * i) = do_ssrlnu_ ## E1(Vj->E2(j + ofs * i), \
1482 Vk->E3(j + ofs * i) % BIT, \
1483 BIT / 2); \
1484 } \
1485 Vd->D(2 * i + 1) = 0; \
1486 } \
1487 }
1488
1489 VSSRLNU(vssrln_bu_h, 16, B, H, UH)
1490 VSSRLNU(vssrln_hu_w, 32, H, W, UW)
1491 VSSRLNU(vssrln_wu_d, 64, W, D, UD)
1492
1493 #define SSRANU(E, T1, T2, T3) \
1494 static T1 do_ssranu_ ## E(T3 e2, int sa, int sh) \
1495 { \
1496 T1 shft_res; \
1497 if (sa == 0) { \
1498 shft_res = e2; \
1499 } else { \
1500 shft_res = e2 >> sa; \
1501 } \
1502 if (e2 < 0) { \
1503 shft_res = 0; \
1504 } \
1505 T2 mask; \
1506 mask = (1ull << sh) - 1; \
1507 if (shft_res > mask) { \
1508 return mask; \
1509 } else { \
1510 return shft_res; \
1511 } \
1512 }
1513
1514 SSRANU(B, uint16_t, uint8_t, int16_t)
1515 SSRANU(H, uint32_t, uint16_t, int32_t)
1516 SSRANU(W, uint64_t, uint32_t, int64_t)
1517
1518 #define VSSRANU(NAME, BIT, E1, E2, E3) \
1519 void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \
1520 { \
1521 int i, j, ofs; \
1522 VReg *Vd = (VReg *)vd; \
1523 VReg *Vj = (VReg *)vj; \
1524 VReg *Vk = (VReg *)vk; \
1525 int oprsz = simd_oprsz(desc); \
1526 \
1527 ofs = LSX_LEN / BIT; \
1528 for (i = 0; i < oprsz / 16; i++) { \
1529 for (j = 0; j < ofs; j++) { \
1530 Vd->E1(j + ofs * 2 * i) = do_ssranu_ ## E1(Vj->E2(j + ofs * i), \
1531 Vk->E3(j + ofs * i) % BIT, \
1532 BIT / 2); \
1533 } \
1534 Vd->D(2 * i + 1) = 0; \
1535 } \
1536 }
1537
1538 VSSRANU(vssran_bu_h, 16, B, H, UH)
1539 VSSRANU(vssran_hu_w, 32, H, W, UW)
1540 VSSRANU(vssran_wu_d, 64, W, D, UD)
1541
1542 #define VSSRLNI(NAME, BIT, E1, E2) \
1543 void HELPER(NAME)(void *vd, void *vj, uint64_t imm, uint32_t desc) \
1544 { \
1545 int i, j, ofs; \
1546 VReg temp = {}; \
1547 VReg *Vd = (VReg *)vd; \
1548 VReg *Vj = (VReg *)vj; \
1549 int oprsz = simd_oprsz(desc); \
1550 \
1551 ofs = LSX_LEN / BIT; \
1552 for (i = 0; i < oprsz / 16; i++) { \
1553 for (j = 0; j < ofs; j++) { \
1554 temp.E1(j + ofs * 2 * i) = do_ssrlns_ ## E1(Vj->E2(j + ofs * i), \
1555 imm, BIT / 2 - 1); \
1556 temp.E1(j + ofs * (2 * i + 1)) = do_ssrlns_ ## E1(Vd->E2(j + ofs * i), \
1557 imm, BIT / 2 - 1); \
1558 } \
1559 } \
1560 *Vd = temp; \
1561 }
1562
1563 static void do_vssrlni_q(VReg *Vd, VReg *Vj,
1564 uint64_t imm, int idx, Int128 mask)
1565 {
1566 Int128 shft_res1, shft_res2;
1567
1568 if (imm == 0) {
1569 shft_res1 = Vj->Q(idx);
1570 shft_res2 = Vd->Q(idx);
1571 } else {
1572 shft_res1 = int128_urshift(Vj->Q(idx), imm);
1573 shft_res2 = int128_urshift(Vd->Q(idx), imm);
1574 }
1575
1576 if (int128_ult(mask, shft_res1)) {
1577 Vd->D(idx * 2) = int128_getlo(mask);
1578 }else {
1579 Vd->D(idx * 2) = int128_getlo(shft_res1);
1580 }
1581
1582 if (int128_ult(mask, shft_res2)) {
1583 Vd->D(idx * 2 + 1) = int128_getlo(mask);
1584 }else {
1585 Vd->D(idx * 2 + 1) = int128_getlo(shft_res2);
1586 }
1587 }
1588
1589 void HELPER(vssrlni_d_q)(void *vd, void *vj, uint64_t imm, uint32_t desc)
1590 {
1591 int i;
1592 Int128 mask;
1593 VReg *Vd = (VReg *)vd;
1594 VReg *Vj = (VReg *)vj;
1595 int oprsz = simd_oprsz(desc);
1596
1597 mask = int128_sub(int128_lshift(int128_one(), 63), int128_one());
1598
1599 for (i = 0; i < oprsz / 16; i++) {
1600 do_vssrlni_q(Vd, Vj, imm, i, mask);
1601 }
1602 }
1603
1604 VSSRLNI(vssrlni_b_h, 16, B, H)
1605 VSSRLNI(vssrlni_h_w, 32, H, W)
1606 VSSRLNI(vssrlni_w_d, 64, W, D)
1607
1608 #define VSSRANI(NAME, BIT, E1, E2) \
1609 void HELPER(NAME)(void *vd, void *vj, uint64_t imm, uint32_t desc) \
1610 { \
1611 int i, j, ofs; \
1612 VReg temp = {}; \
1613 VReg *Vd = (VReg *)vd; \
1614 VReg *Vj = (VReg *)vj; \
1615 int oprsz = simd_oprsz(desc); \
1616 \
1617 ofs = LSX_LEN / BIT; \
1618 for (i = 0; i < oprsz / 16; i++) { \
1619 for (j = 0; j < ofs; j++) { \
1620 temp.E1(j + ofs * 2 * i) = do_ssrans_ ## E1(Vj->E2(j + ofs * i), \
1621 imm, BIT / 2 - 1); \
1622 temp.E1(j + ofs * (2 * i + 1)) = do_ssrans_ ## E1(Vd->E2(j + ofs * i), \
1623 imm, BIT / 2 - 1); \
1624 } \
1625 } \
1626 *Vd = temp; \
1627 }
1628
1629 static void do_vssrani_d_q(VReg *Vd, VReg *Vj,
1630 uint64_t imm, int idx, Int128 mask, Int128 min)
1631 {
1632 Int128 shft_res1, shft_res2;
1633
1634 if (imm == 0) {
1635 shft_res1 = Vj->Q(idx);
1636 shft_res2 = Vd->Q(idx);
1637 } else {
1638 shft_res1 = int128_rshift(Vj->Q(idx), imm);
1639 shft_res2 = int128_rshift(Vd->Q(idx), imm);
1640 }
1641
1642 if (int128_gt(shft_res1, mask)) {
1643 Vd->D(idx * 2) = int128_getlo(mask);
1644 } else if (int128_lt(shft_res1, int128_neg(min))) {
1645 Vd->D(idx * 2) = int128_getlo(min);
1646 } else {
1647 Vd->D(idx * 2) = int128_getlo(shft_res1);
1648 }
1649
1650 if (int128_gt(shft_res2, mask)) {
1651 Vd->D(idx * 2 + 1) = int128_getlo(mask);
1652 } else if (int128_lt(shft_res2, int128_neg(min))) {
1653 Vd->D(idx * 2 + 1) = int128_getlo(min);
1654 } else {
1655 Vd->D(idx * 2 + 1) = int128_getlo(shft_res2);
1656 }
1657 }
1658
1659 void HELPER(vssrani_d_q)(void *vd, void *vj, uint64_t imm, uint32_t desc)
1660 {
1661 int i;
1662 Int128 mask, min;
1663 VReg *Vd = (VReg *)vd;
1664 VReg *Vj = (VReg *)vj;
1665 int oprsz = simd_oprsz(desc);
1666
1667 mask = int128_sub(int128_lshift(int128_one(), 63), int128_one());
1668 min = int128_lshift(int128_one(), 63);
1669
1670 for (i = 0; i < oprsz / 16; i++) {
1671 do_vssrani_d_q(Vd, Vj, imm, i, mask, min);
1672 }
1673 }
1674
1675
1676 VSSRANI(vssrani_b_h, 16, B, H)
1677 VSSRANI(vssrani_h_w, 32, H, W)
1678 VSSRANI(vssrani_w_d, 64, W, D)
1679
1680 #define VSSRLNUI(NAME, BIT, E1, E2) \
1681 void HELPER(NAME)(void *vd, void *vj, uint64_t imm, uint32_t desc) \
1682 { \
1683 int i, j, ofs; \
1684 VReg temp = {}; \
1685 VReg *Vd = (VReg *)vd; \
1686 VReg *Vj = (VReg *)vj; \
1687 int oprsz = simd_oprsz(desc); \
1688 \
1689 ofs = LSX_LEN / BIT; \
1690 for (i = 0; i < oprsz / 16; i++) { \
1691 for (j = 0; j < ofs; j++) { \
1692 temp.E1(j + ofs * 2 * i) = do_ssrlnu_ ## E1(Vj->E2(j + ofs * i), \
1693 imm, BIT / 2); \
1694 temp.E1(j + ofs * (2 * i + 1)) = do_ssrlnu_ ## E1(Vd->E2(j + ofs * i), \
1695 imm, BIT / 2); \
1696 } \
1697 } \
1698 *Vd = temp; \
1699 }
1700
1701 void HELPER(vssrlni_du_q)(void *vd, void *vj, uint64_t imm, uint32_t desc)
1702 {
1703 int i;
1704 Int128 mask;
1705 VReg *Vd = (VReg *)vd;
1706 VReg *Vj = (VReg *)vj;
1707 int oprsz = simd_oprsz(desc);
1708
1709 mask = int128_sub(int128_lshift(int128_one(), 64), int128_one());
1710
1711 for (i = 0; i < oprsz / 16; i++) {
1712 do_vssrlni_q(Vd, Vj, imm, i, mask);
1713 }
1714 }
1715
1716 VSSRLNUI(vssrlni_bu_h, 16, B, H)
1717 VSSRLNUI(vssrlni_hu_w, 32, H, W)
1718 VSSRLNUI(vssrlni_wu_d, 64, W, D)
1719
1720 #define VSSRANUI(NAME, BIT, E1, E2) \
1721 void HELPER(NAME)(void *vd, void *vj, uint64_t imm, uint32_t desc) \
1722 { \
1723 int i, j, ofs; \
1724 VReg temp = {}; \
1725 VReg *Vd = (VReg *)vd; \
1726 VReg *Vj = (VReg *)vj; \
1727 int oprsz = simd_oprsz(desc); \
1728 \
1729 ofs = LSX_LEN / BIT; \
1730 for (i = 0; i < oprsz / 16; i++) { \
1731 for (j = 0; j < ofs; j++) { \
1732 temp.E1(j + ofs * 2 * i) = do_ssranu_ ## E1(Vj->E2(j + ofs * i), \
1733 imm, BIT / 2); \
1734 temp.E1(j + ofs * (2 * i + 1)) = do_ssranu_ ## E1(Vd->E2(j + ofs * i), \
1735 imm, BIT / 2); \
1736 } \
1737 } \
1738 *Vd = temp; \
1739 }
1740
1741 static void do_vssrani_du_q(VReg *Vd, VReg *Vj,
1742 uint64_t imm, int idx, Int128 mask)
1743 {
1744 Int128 shft_res1, shft_res2;
1745
1746 if (imm == 0) {
1747 shft_res1 = Vj->Q(idx);
1748 shft_res2 = Vd->Q(idx);
1749 } else {
1750 shft_res1 = int128_rshift(Vj->Q(idx), imm);
1751 shft_res2 = int128_rshift(Vd->Q(idx), imm);
1752 }
1753
1754 if (int128_lt(Vj->Q(idx), int128_zero())) {
1755 shft_res1 = int128_zero();
1756 }
1757
1758 if (int128_lt(Vd->Q(idx), int128_zero())) {
1759 shft_res2 = int128_zero();
1760 }
1761 if (int128_ult(mask, shft_res1)) {
1762 Vd->D(idx * 2) = int128_getlo(mask);
1763 }else {
1764 Vd->D(idx * 2) = int128_getlo(shft_res1);
1765 }
1766
1767 if (int128_ult(mask, shft_res2)) {
1768 Vd->D(idx * 2 + 1) = int128_getlo(mask);
1769 }else {
1770 Vd->D(idx * 2 + 1) = int128_getlo(shft_res2);
1771 }
1772
1773 }
1774
1775 void HELPER(vssrani_du_q)(void *vd, void *vj, uint64_t imm, uint32_t desc)
1776 {
1777 int i;
1778 Int128 mask;
1779 VReg *Vd = (VReg *)vd;
1780 VReg *Vj = (VReg *)vj;
1781 int oprsz = simd_oprsz(desc);
1782
1783 mask = int128_sub(int128_lshift(int128_one(), 64), int128_one());
1784
1785 for (i = 0; i < oprsz / 16; i++) {
1786 do_vssrani_du_q(Vd, Vj, imm, i, mask);
1787 }
1788 }
1789
1790 VSSRANUI(vssrani_bu_h, 16, B, H)
1791 VSSRANUI(vssrani_hu_w, 32, H, W)
1792 VSSRANUI(vssrani_wu_d, 64, W, D)
1793
1794 #define SSRLRNS(E1, E2, T1, T2, T3) \
1795 static T1 do_ssrlrns_ ## E1(T2 e2, int sa, int sh) \
1796 { \
1797 T1 shft_res; \
1798 \
1799 shft_res = do_vsrlr_ ## E2(e2, sa); \
1800 T1 mask; \
1801 mask = (1ull << sh) - 1; \
1802 if (shft_res > mask) { \
1803 return mask; \
1804 } else { \
1805 return shft_res; \
1806 } \
1807 }
1808
1809 SSRLRNS(B, H, uint16_t, int16_t, uint8_t)
1810 SSRLRNS(H, W, uint32_t, int32_t, uint16_t)
1811 SSRLRNS(W, D, uint64_t, int64_t, uint32_t)
1812
1813 #define VSSRLRN(NAME, BIT, E1, E2, E3) \
1814 void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \
1815 { \
1816 int i, j, ofs; \
1817 VReg *Vd = (VReg *)vd; \
1818 VReg *Vj = (VReg *)vj; \
1819 VReg *Vk = (VReg *)vk; \
1820 int oprsz = simd_oprsz(desc); \
1821 \
1822 ofs = LSX_LEN / BIT; \
1823 for (i = 0; i < oprsz / 16; i++) { \
1824 for (j = 0; j < ofs; j++) { \
1825 Vd->E1(j + ofs * 2 * i) = do_ssrlrns_ ## E1(Vj->E2(j + ofs * i), \
1826 Vk->E3(j + ofs * i) % BIT, \
1827 BIT / 2 - 1); \
1828 } \
1829 Vd->D(2 * i + 1) = 0; \
1830 } \
1831 }
1832
1833 VSSRLRN(vssrlrn_b_h, 16, B, H, UH)
1834 VSSRLRN(vssrlrn_h_w, 32, H, W, UW)
1835 VSSRLRN(vssrlrn_w_d, 64, W, D, UD)
1836
1837 #define SSRARNS(E1, E2, T1, T2) \
1838 static T1 do_ssrarns_ ## E1(T1 e2, int sa, int sh) \
1839 { \
1840 T1 shft_res; \
1841 \
1842 shft_res = do_vsrar_ ## E2(e2, sa); \
1843 T2 mask; \
1844 mask = (1ll << sh) - 1; \
1845 if (shft_res > mask) { \
1846 return mask; \
1847 } else if (shft_res < -(mask +1)) { \
1848 return ~mask; \
1849 } else { \
1850 return shft_res; \
1851 } \
1852 }
1853
1854 SSRARNS(B, H, int16_t, int8_t)
1855 SSRARNS(H, W, int32_t, int16_t)
1856 SSRARNS(W, D, int64_t, int32_t)
1857
1858 #define VSSRARN(NAME, BIT, E1, E2, E3) \
1859 void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \
1860 { \
1861 int i, j, ofs; \
1862 VReg *Vd = (VReg *)vd; \
1863 VReg *Vj = (VReg *)vj; \
1864 VReg *Vk = (VReg *)vk; \
1865 int oprsz = simd_oprsz(desc); \
1866 \
1867 ofs = LSX_LEN / BIT; \
1868 for (i = 0; i < oprsz / 16; i++) { \
1869 for (j = 0; j < ofs; j++) { \
1870 Vd->E1(j + ofs * 2 * i) = do_ssrarns_ ## E1(Vj->E2(j + ofs * i), \
1871 Vk->E3(j + ofs * i) % BIT, \
1872 BIT/ 2 - 1); \
1873 } \
1874 Vd->D(2 * i + 1) = 0; \
1875 } \
1876 }
1877
1878 VSSRARN(vssrarn_b_h, 16, B, H, UH)
1879 VSSRARN(vssrarn_h_w, 32, H, W, UW)
1880 VSSRARN(vssrarn_w_d, 64, W, D, UD)
1881
1882 #define SSRLRNU(E1, E2, T1, T2, T3) \
1883 static T1 do_ssrlrnu_ ## E1(T3 e2, int sa, int sh) \
1884 { \
1885 T1 shft_res; \
1886 \
1887 shft_res = do_vsrlr_ ## E2(e2, sa); \
1888 \
1889 T2 mask; \
1890 mask = (1ull << sh) - 1; \
1891 if (shft_res > mask) { \
1892 return mask; \
1893 } else { \
1894 return shft_res; \
1895 } \
1896 }
1897
1898 SSRLRNU(B, H, uint16_t, uint8_t, int16_t)
1899 SSRLRNU(H, W, uint32_t, uint16_t, int32_t)
1900 SSRLRNU(W, D, uint64_t, uint32_t, int64_t)
1901
1902 #define VSSRLRNU(NAME, BIT, E1, E2, E3) \
1903 void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \
1904 { \
1905 int i, j, ofs; \
1906 VReg *Vd = (VReg *)vd; \
1907 VReg *Vj = (VReg *)vj; \
1908 VReg *Vk = (VReg *)vk; \
1909 int oprsz = simd_oprsz(desc); \
1910 \
1911 ofs = LSX_LEN / BIT; \
1912 for (i = 0; i < oprsz / 16; i++) { \
1913 for (j = 0; j < ofs; j++) { \
1914 Vd->E1(j + ofs * 2 * i) = do_ssrlrnu_ ## E1(Vj->E2(j + ofs * i), \
1915 Vk->E3(j + ofs * i) % BIT, \
1916 BIT / 2); \
1917 } \
1918 Vd->D(2 * i + 1) = 0; \
1919 } \
1920 }
1921
1922 VSSRLRNU(vssrlrn_bu_h, 16, B, H, UH)
1923 VSSRLRNU(vssrlrn_hu_w, 32, H, W, UW)
1924 VSSRLRNU(vssrlrn_wu_d, 64, W, D, UD)
1925
1926 #define SSRARNU(E1, E2, T1, T2, T3) \
1927 static T1 do_ssrarnu_ ## E1(T3 e2, int sa, int sh) \
1928 { \
1929 T1 shft_res; \
1930 \
1931 if (e2 < 0) { \
1932 shft_res = 0; \
1933 } else { \
1934 shft_res = do_vsrar_ ## E2(e2, sa); \
1935 } \
1936 T2 mask; \
1937 mask = (1ull << sh) - 1; \
1938 if (shft_res > mask) { \
1939 return mask; \
1940 } else { \
1941 return shft_res; \
1942 } \
1943 }
1944
1945 SSRARNU(B, H, uint16_t, uint8_t, int16_t)
1946 SSRARNU(H, W, uint32_t, uint16_t, int32_t)
1947 SSRARNU(W, D, uint64_t, uint32_t, int64_t)
1948
1949 #define VSSRARNU(NAME, BIT, E1, E2, E3) \
1950 void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \
1951 { \
1952 int i, j, ofs; \
1953 VReg *Vd = (VReg *)vd; \
1954 VReg *Vj = (VReg *)vj; \
1955 VReg *Vk = (VReg *)vk; \
1956 int oprsz = simd_oprsz(desc); \
1957 \
1958 ofs = LSX_LEN / BIT; \
1959 for (i = 0; i < oprsz / 16; i++) { \
1960 for (j = 0; j < ofs; j++) { \
1961 Vd->E1(j + ofs * 2 * i) = do_ssrarnu_ ## E1(Vj->E2(j + ofs * i), \
1962 Vk->E3(j + ofs * i) % BIT, \
1963 BIT / 2); \
1964 } \
1965 Vd->D(2 * i + 1) = 0; \
1966 } \
1967 }
1968
1969 VSSRARNU(vssrarn_bu_h, 16, B, H, UH)
1970 VSSRARNU(vssrarn_hu_w, 32, H, W, UW)
1971 VSSRARNU(vssrarn_wu_d, 64, W, D, UD)
1972
1973 #define VSSRLRNI(NAME, BIT, E1, E2) \
1974 void HELPER(NAME)(void *vd, void *vj, uint64_t imm, uint32_t desc) \
1975 { \
1976 int i, j, ofs; \
1977 VReg temp = {}; \
1978 VReg *Vd = (VReg *)vd; \
1979 VReg *Vj = (VReg *)vj; \
1980 int oprsz = simd_oprsz(desc); \
1981 \
1982 ofs = LSX_LEN / BIT; \
1983 for (i = 0; i < oprsz / 16; i++) { \
1984 for (j = 0; j < ofs; j++) { \
1985 temp.E1(j + ofs * 2 * i) = do_ssrlrns_ ## E1(Vj->E2(j + ofs * i), \
1986 imm, BIT / 2 - 1); \
1987 temp.E1(j + ofs * (2 * i + 1)) = do_ssrlrns_ ## E1(Vd->E2(j + ofs * i), \
1988 imm, BIT / 2 - 1); \
1989 } \
1990 } \
1991 *Vd = temp; \
1992 }
1993
1994 static void do_vssrlrni_q(VReg *Vd, VReg * Vj,
1995 uint64_t imm, int idx, Int128 mask)
1996 {
1997 Int128 shft_res1, shft_res2, r1, r2;
1998 if (imm == 0) {
1999 shft_res1 = Vj->Q(idx);
2000 shft_res2 = Vd->Q(idx);
2001 } else {
2002 r1 = int128_and(int128_urshift(Vj->Q(idx), (imm - 1)), int128_one());
2003 r2 = int128_and(int128_urshift(Vd->Q(idx), (imm - 1)), int128_one());
2004 shft_res1 = (int128_add(int128_urshift(Vj->Q(idx), imm), r1));
2005 shft_res2 = (int128_add(int128_urshift(Vd->Q(idx), imm), r2));
2006 }
2007
2008 if (int128_ult(mask, shft_res1)) {
2009 Vd->D(idx * 2) = int128_getlo(mask);
2010 }else {
2011 Vd->D(idx * 2) = int128_getlo(shft_res1);
2012 }
2013
2014 if (int128_ult(mask, shft_res2)) {
2015 Vd->D(idx * 2 + 1) = int128_getlo(mask);
2016 }else {
2017 Vd->D(idx * 2 + 1) = int128_getlo(shft_res2);
2018 }
2019 }
2020
2021 void HELPER(vssrlrni_d_q)(void *vd, void *vj, uint64_t imm, uint32_t desc)
2022 {
2023 int i;
2024 Int128 mask;
2025 VReg *Vd = (VReg *)vd;
2026 VReg *Vj = (VReg *)vj;
2027 int oprsz = simd_oprsz(desc);
2028
2029 mask = int128_sub(int128_lshift(int128_one(), 63), int128_one());
2030
2031 for (i = 0; i < oprsz / 16; i++) {
2032 do_vssrlrni_q(Vd, Vj, imm, i, mask);
2033 }
2034 }
2035
2036 VSSRLRNI(vssrlrni_b_h, 16, B, H)
2037 VSSRLRNI(vssrlrni_h_w, 32, H, W)
2038 VSSRLRNI(vssrlrni_w_d, 64, W, D)
2039
2040 #define VSSRARNI(NAME, BIT, E1, E2) \
2041 void HELPER(NAME)(void *vd, void *vj, uint64_t imm, uint32_t desc) \
2042 { \
2043 int i, j, ofs; \
2044 VReg temp = {}; \
2045 VReg *Vd = (VReg *)vd; \
2046 VReg *Vj = (VReg *)vj; \
2047 int oprsz = simd_oprsz(desc); \
2048 \
2049 ofs = LSX_LEN / BIT; \
2050 for (i = 0; i < oprsz / 16; i++) { \
2051 for (j = 0; j < ofs; j++) { \
2052 temp.E1(j + ofs * 2 * i) = do_ssrarns_ ## E1(Vj->E2(j + ofs * i), \
2053 imm, BIT / 2 - 1); \
2054 temp.E1(j + ofs * (2 * i + 1)) = do_ssrarns_ ## E1(Vd->E2(j + ofs * i), \
2055 imm, BIT / 2 - 1); \
2056 } \
2057 } \
2058 *Vd = temp; \
2059 }
2060
2061 static void do_vssrarni_d_q(VReg *Vd, VReg *Vj,
2062 uint64_t imm, int idx, Int128 mask1, Int128 mask2)
2063 {
2064 Int128 shft_res1, shft_res2, r1, r2;
2065
2066 if (imm == 0) {
2067 shft_res1 = Vj->Q(idx);
2068 shft_res2 = Vd->Q(idx);
2069 } else {
2070 r1 = int128_and(int128_rshift(Vj->Q(idx), (imm - 1)), int128_one());
2071 r2 = int128_and(int128_rshift(Vd->Q(idx), (imm - 1)), int128_one());
2072 shft_res1 = int128_add(int128_rshift(Vj->Q(idx), imm), r1);
2073 shft_res2 = int128_add(int128_rshift(Vd->Q(idx), imm), r2);
2074 }
2075 if (int128_gt(shft_res1, mask1)) {
2076 Vd->D(idx * 2) = int128_getlo(mask1);
2077 } else if (int128_lt(shft_res1, int128_neg(mask2))) {
2078 Vd->D(idx * 2) = int128_getlo(mask2);
2079 } else {
2080 Vd->D(idx * 2) = int128_getlo(shft_res1);
2081 }
2082
2083 if (int128_gt(shft_res2, mask1)) {
2084 Vd->D(idx * 2 + 1) = int128_getlo(mask1);
2085 } else if (int128_lt(shft_res2, int128_neg(mask2))) {
2086 Vd->D(idx * 2 + 1) = int128_getlo(mask2);
2087 } else {
2088 Vd->D(idx * 2 + 1) = int128_getlo(shft_res2);
2089 }
2090 }
2091
2092 void HELPER(vssrarni_d_q)(void *vd, void *vj, uint64_t imm, uint32_t desc)
2093 {
2094 int i;
2095 Int128 mask1, mask2;
2096 VReg *Vd = (VReg *)vd;
2097 VReg *Vj = (VReg *)vj;
2098 int oprsz = simd_oprsz(desc);
2099
2100 mask1 = int128_sub(int128_lshift(int128_one(), 63), int128_one());
2101 mask2 = int128_lshift(int128_one(), 63);
2102
2103 for (i = 0; i < oprsz / 16; i++) {
2104 do_vssrarni_d_q(Vd, Vj, imm, i, mask1, mask2);
2105 }
2106 }
2107
2108 VSSRARNI(vssrarni_b_h, 16, B, H)
2109 VSSRARNI(vssrarni_h_w, 32, H, W)
2110 VSSRARNI(vssrarni_w_d, 64, W, D)
2111
2112 #define VSSRLRNUI(NAME, BIT, E1, E2) \
2113 void HELPER(NAME)(void *vd, void *vj, uint64_t imm, uint32_t desc) \
2114 { \
2115 int i, j, ofs; \
2116 VReg temp = {}; \
2117 VReg *Vd = (VReg *)vd; \
2118 VReg *Vj = (VReg *)vj; \
2119 int oprsz = simd_oprsz(desc); \
2120 \
2121 ofs = LSX_LEN / BIT; \
2122 for (i = 0; i < oprsz / 16; i++) { \
2123 for (j = 0; j < ofs; j++) { \
2124 temp.E1(j + ofs * 2 * i) = do_ssrlrnu_ ## E1(Vj->E2(j + ofs * i), \
2125 imm, BIT / 2); \
2126 temp.E1(j + ofs * (2 * i + 1)) = do_ssrlrnu_ ## E1(Vd->E2(j + ofs * i), \
2127 imm, BIT / 2); \
2128 } \
2129 } \
2130 *Vd = temp; \
2131 }
2132
2133 void HELPER(vssrlrni_du_q)(void *vd, void *vj, uint64_t imm, uint32_t desc)
2134 {
2135 int i;
2136 Int128 mask;
2137 VReg *Vd = (VReg *)vd;
2138 VReg *Vj = (VReg *)vj;
2139 int oprsz = simd_oprsz(desc);
2140
2141 mask = int128_sub(int128_lshift(int128_one(), 64), int128_one());
2142
2143 for (i = 0; i < oprsz / 16; i++) {
2144 do_vssrlrni_q(Vd, Vj, imm, i, mask);
2145 }
2146 }
2147
2148 VSSRLRNUI(vssrlrni_bu_h, 16, B, H)
2149 VSSRLRNUI(vssrlrni_hu_w, 32, H, W)
2150 VSSRLRNUI(vssrlrni_wu_d, 64, W, D)
2151
2152 #define VSSRARNUI(NAME, BIT, E1, E2) \
2153 void HELPER(NAME)(void *vd, void *vj, uint64_t imm, uint32_t desc) \
2154 { \
2155 int i, j, ofs; \
2156 VReg temp = {}; \
2157 VReg *Vd = (VReg *)vd; \
2158 VReg *Vj = (VReg *)vj; \
2159 int oprsz = simd_oprsz(desc); \
2160 \
2161 ofs = LSX_LEN / BIT; \
2162 for (i = 0; i < oprsz / 16; i++) { \
2163 for (j = 0; j < ofs; j++) { \
2164 temp.E1(j + ofs * 2 * i) = do_ssrarnu_ ## E1(Vj->E2(j + ofs * i), \
2165 imm, BIT / 2); \
2166 temp.E1(j + ofs * (2 * i + 1)) = do_ssrarnu_ ## E1(Vd->E2(j + ofs * i), \
2167 imm, BIT / 2); \
2168 } \
2169 } \
2170 *Vd = temp; \
2171 }
2172
2173 static void do_vssrarni_du_q(VReg *Vd, VReg *Vj,
2174 uint64_t imm, int idx, Int128 mask1, Int128 mask2)
2175 {
2176 Int128 shft_res1, shft_res2, r1, r2;
2177
2178 if (imm == 0) {
2179 shft_res1 = Vj->Q(idx);
2180 shft_res2 = Vd->Q(idx);
2181 } else {
2182 r1 = int128_and(int128_rshift(Vj->Q(idx), (imm - 1)), int128_one());
2183 r2 = int128_and(int128_rshift(Vd->Q(idx), (imm - 1)), int128_one());
2184 shft_res1 = int128_add(int128_rshift(Vj->Q(idx), imm), r1);
2185 shft_res2 = int128_add(int128_rshift(Vd->Q(idx), imm), r2);
2186 }
2187
2188 if (int128_lt(Vj->Q(idx), int128_zero())) {
2189 shft_res1 = int128_zero();
2190 }
2191 if (int128_lt(Vd->Q(idx), int128_zero())) {
2192 shft_res2 = int128_zero();
2193 }
2194
2195 if (int128_gt(shft_res1, mask1)) {
2196 Vd->D(idx * 2) = int128_getlo(mask1);
2197 } else if (int128_lt(shft_res1, int128_neg(mask2))) {
2198 Vd->D(idx * 2) = int128_getlo(mask2);
2199 } else {
2200 Vd->D(idx * 2) = int128_getlo(shft_res1);
2201 }
2202
2203 if (int128_gt(shft_res2, mask1)) {
2204 Vd->D(idx * 2 + 1) = int128_getlo(mask1);
2205 } else if (int128_lt(shft_res2, int128_neg(mask2))) {
2206 Vd->D(idx * 2 + 1) = int128_getlo(mask2);
2207 } else {
2208 Vd->D(idx * 2 + 1) = int128_getlo(shft_res2);
2209 }
2210 }
2211
2212 void HELPER(vssrarni_du_q)(void *vd, void *vj, uint64_t imm, uint32_t desc)
2213 {
2214 int i;
2215 Int128 mask1, mask2;
2216 VReg *Vd = (VReg *)vd;
2217 VReg *Vj = (VReg *)vj;
2218 int oprsz = simd_oprsz(desc);
2219
2220 mask1 = int128_sub(int128_lshift(int128_one(), 64), int128_one());
2221 mask2 = int128_lshift(int128_one(), 64);
2222
2223 for (i = 0; i < oprsz / 16; i++) {
2224 do_vssrarni_du_q(Vd, Vj, imm, i, mask1, mask2);
2225 }
2226 }
2227
2228 VSSRARNUI(vssrarni_bu_h, 16, B, H)
2229 VSSRARNUI(vssrarni_hu_w, 32, H, W)
2230 VSSRARNUI(vssrarni_wu_d, 64, W, D)
2231
2232 #define DO_2OP(NAME, BIT, E, DO_OP) \
2233 void HELPER(NAME)(void *vd, void *vj, uint32_t desc) \
2234 { \
2235 int i; \
2236 VReg *Vd = (VReg *)vd; \
2237 VReg *Vj = (VReg *)vj; \
2238 int oprsz = simd_oprsz(desc); \
2239 \
2240 for (i = 0; i < oprsz / (BIT / 8); i++) \
2241 { \
2242 Vd->E(i) = DO_OP(Vj->E(i)); \
2243 } \
2244 }
2245
2246 DO_2OP(vclo_b, 8, UB, DO_CLO_B)
2247 DO_2OP(vclo_h, 16, UH, DO_CLO_H)
2248 DO_2OP(vclo_w, 32, UW, DO_CLO_W)
2249 DO_2OP(vclo_d, 64, UD, DO_CLO_D)
2250 DO_2OP(vclz_b, 8, UB, DO_CLZ_B)
2251 DO_2OP(vclz_h, 16, UH, DO_CLZ_H)
2252 DO_2OP(vclz_w, 32, UW, DO_CLZ_W)
2253 DO_2OP(vclz_d, 64, UD, DO_CLZ_D)
2254
2255 #define VPCNT(NAME, BIT, E, FN) \
2256 void HELPER(NAME)(void *vd, void *vj, uint32_t desc) \
2257 { \
2258 int i; \
2259 VReg *Vd = (VReg *)vd; \
2260 VReg *Vj = (VReg *)vj; \
2261 int oprsz = simd_oprsz(desc); \
2262 \
2263 for (i = 0; i < oprsz / (BIT / 8); i++) \
2264 { \
2265 Vd->E(i) = FN(Vj->E(i)); \
2266 } \
2267 }
2268
2269 VPCNT(vpcnt_b, 8, UB, ctpop8)
2270 VPCNT(vpcnt_h, 16, UH, ctpop16)
2271 VPCNT(vpcnt_w, 32, UW, ctpop32)
2272 VPCNT(vpcnt_d, 64, UD, ctpop64)
2273
2274 #define DO_BIT(NAME, BIT, E, DO_OP) \
2275 void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \
2276 { \
2277 int i; \
2278 VReg *Vd = (VReg *)vd; \
2279 VReg *Vj = (VReg *)vj; \
2280 VReg *Vk = (VReg *)vk; \
2281 int oprsz = simd_oprsz(desc); \
2282 \
2283 for (i = 0; i < oprsz / (BIT / 8); i++) { \
2284 Vd->E(i) = DO_OP(Vj->E(i), Vk->E(i)%BIT); \
2285 } \
2286 }
2287
2288 DO_BIT(vbitclr_b, 8, UB, DO_BITCLR)
2289 DO_BIT(vbitclr_h, 16, UH, DO_BITCLR)
2290 DO_BIT(vbitclr_w, 32, UW, DO_BITCLR)
2291 DO_BIT(vbitclr_d, 64, UD, DO_BITCLR)
2292 DO_BIT(vbitset_b, 8, UB, DO_BITSET)
2293 DO_BIT(vbitset_h, 16, UH, DO_BITSET)
2294 DO_BIT(vbitset_w, 32, UW, DO_BITSET)
2295 DO_BIT(vbitset_d, 64, UD, DO_BITSET)
2296 DO_BIT(vbitrev_b, 8, UB, DO_BITREV)
2297 DO_BIT(vbitrev_h, 16, UH, DO_BITREV)
2298 DO_BIT(vbitrev_w, 32, UW, DO_BITREV)
2299 DO_BIT(vbitrev_d, 64, UD, DO_BITREV)
2300
2301 #define DO_BITI(NAME, BIT, E, DO_OP) \
2302 void HELPER(NAME)(void *vd, void *vj, uint64_t imm, uint32_t desc) \
2303 { \
2304 int i; \
2305 VReg *Vd = (VReg *)vd; \
2306 VReg *Vj = (VReg *)vj; \
2307 int oprsz = simd_oprsz(desc); \
2308 \
2309 for (i = 0; i < oprsz / (BIT / 8); i++) { \
2310 Vd->E(i) = DO_OP(Vj->E(i), imm); \
2311 } \
2312 }
2313
2314 DO_BITI(vbitclri_b, 8, UB, DO_BITCLR)
2315 DO_BITI(vbitclri_h, 16, UH, DO_BITCLR)
2316 DO_BITI(vbitclri_w, 32, UW, DO_BITCLR)
2317 DO_BITI(vbitclri_d, 64, UD, DO_BITCLR)
2318 DO_BITI(vbitseti_b, 8, UB, DO_BITSET)
2319 DO_BITI(vbitseti_h, 16, UH, DO_BITSET)
2320 DO_BITI(vbitseti_w, 32, UW, DO_BITSET)
2321 DO_BITI(vbitseti_d, 64, UD, DO_BITSET)
2322 DO_BITI(vbitrevi_b, 8, UB, DO_BITREV)
2323 DO_BITI(vbitrevi_h, 16, UH, DO_BITREV)
2324 DO_BITI(vbitrevi_w, 32, UW, DO_BITREV)
2325 DO_BITI(vbitrevi_d, 64, UD, DO_BITREV)
2326
2327 #define VFRSTP(NAME, BIT, MASK, E) \
2328 void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \
2329 { \
2330 int i, j, m, ofs; \
2331 VReg *Vd = (VReg *)vd; \
2332 VReg *Vj = (VReg *)vj; \
2333 VReg *Vk = (VReg *)vk; \
2334 int oprsz = simd_oprsz(desc); \
2335 \
2336 ofs = LSX_LEN / BIT; \
2337 for (i = 0; i < oprsz / 16; i++) { \
2338 m = Vk->E(i * ofs) & MASK; \
2339 for (j = 0; j < ofs; j++) { \
2340 if (Vj->E(j + ofs * i) < 0) { \
2341 break; \
2342 } \
2343 } \
2344 Vd->E(m + i * ofs) = j; \
2345 } \
2346 }
2347
2348 VFRSTP(vfrstp_b, 8, 0xf, B)
2349 VFRSTP(vfrstp_h, 16, 0x7, H)
2350
2351 #define VFRSTPI(NAME, BIT, E) \
2352 void HELPER(NAME)(void *vd, void *vj, uint64_t imm, uint32_t desc) \
2353 { \
2354 int i, j, m, ofs; \
2355 VReg *Vd = (VReg *)vd; \
2356 VReg *Vj = (VReg *)vj; \
2357 int oprsz = simd_oprsz(desc); \
2358 \
2359 ofs = LSX_LEN / BIT; \
2360 m = imm % ofs; \
2361 for (i = 0; i < oprsz / 16; i++) { \
2362 for (j = 0; j < ofs; j++) { \
2363 if (Vj->E(j + ofs * i) < 0) { \
2364 break; \
2365 } \
2366 } \
2367 Vd->E(m + i * ofs) = j; \
2368 } \
2369 }
2370
2371 VFRSTPI(vfrstpi_b, 8, B)
2372 VFRSTPI(vfrstpi_h, 16, H)
2373
2374 static void vec_update_fcsr0_mask(CPULoongArchState *env,
2375 uintptr_t pc, int mask)
2376 {
2377 int flags = get_float_exception_flags(&env->fp_status);
2378
2379 set_float_exception_flags(0, &env->fp_status);
2380
2381 flags &= ~mask;
2382
2383 if (flags) {
2384 flags = ieee_ex_to_loongarch(flags);
2385 UPDATE_FP_CAUSE(env->fcsr0, flags);
2386 }
2387
2388 if (GET_FP_ENABLES(env->fcsr0) & flags) {
2389 do_raise_exception(env, EXCCODE_FPE, pc);
2390 } else {
2391 UPDATE_FP_FLAGS(env->fcsr0, flags);
2392 }
2393 }
2394
2395 static void vec_update_fcsr0(CPULoongArchState *env, uintptr_t pc)
2396 {
2397 vec_update_fcsr0_mask(env, pc, 0);
2398 }
2399
2400 static inline void vec_clear_cause(CPULoongArchState *env)
2401 {
2402 SET_FP_CAUSE(env->fcsr0, 0);
2403 }
2404
2405 #define DO_3OP_F(NAME, BIT, E, FN) \
2406 void HELPER(NAME)(void *vd, void *vj, void *vk, \
2407 CPULoongArchState *env, uint32_t desc) \
2408 { \
2409 int i; \
2410 VReg *Vd = (VReg *)vd; \
2411 VReg *Vj = (VReg *)vj; \
2412 VReg *Vk = (VReg *)vk; \
2413 int oprsz = simd_oprsz(desc); \
2414 \
2415 vec_clear_cause(env); \
2416 for (i = 0; i < oprsz / (BIT / 8); i++) { \
2417 Vd->E(i) = FN(Vj->E(i), Vk->E(i), &env->fp_status); \
2418 vec_update_fcsr0(env, GETPC()); \
2419 } \
2420 }
2421
2422 DO_3OP_F(vfadd_s, 32, UW, float32_add)
2423 DO_3OP_F(vfadd_d, 64, UD, float64_add)
2424 DO_3OP_F(vfsub_s, 32, UW, float32_sub)
2425 DO_3OP_F(vfsub_d, 64, UD, float64_sub)
2426 DO_3OP_F(vfmul_s, 32, UW, float32_mul)
2427 DO_3OP_F(vfmul_d, 64, UD, float64_mul)
2428 DO_3OP_F(vfdiv_s, 32, UW, float32_div)
2429 DO_3OP_F(vfdiv_d, 64, UD, float64_div)
2430 DO_3OP_F(vfmax_s, 32, UW, float32_maxnum)
2431 DO_3OP_F(vfmax_d, 64, UD, float64_maxnum)
2432 DO_3OP_F(vfmin_s, 32, UW, float32_minnum)
2433 DO_3OP_F(vfmin_d, 64, UD, float64_minnum)
2434 DO_3OP_F(vfmaxa_s, 32, UW, float32_maxnummag)
2435 DO_3OP_F(vfmaxa_d, 64, UD, float64_maxnummag)
2436 DO_3OP_F(vfmina_s, 32, UW, float32_minnummag)
2437 DO_3OP_F(vfmina_d, 64, UD, float64_minnummag)
2438
2439 #define DO_4OP_F(NAME, BIT, E, FN, flags) \
2440 void HELPER(NAME)(void *vd, void *vj, void *vk, void *va, \
2441 CPULoongArchState *env, uint32_t desc) \
2442 { \
2443 int i; \
2444 VReg *Vd = (VReg *)vd; \
2445 VReg *Vj = (VReg *)vj; \
2446 VReg *Vk = (VReg *)vk; \
2447 VReg *Va = (VReg *)va; \
2448 int oprsz = simd_oprsz(desc); \
2449 \
2450 vec_clear_cause(env); \
2451 for (i = 0; i < oprsz / (BIT / 8); i++) { \
2452 Vd->E(i) = FN(Vj->E(i), Vk->E(i), Va->E(i), flags, &env->fp_status); \
2453 vec_update_fcsr0(env, GETPC()); \
2454 } \
2455 }
2456
2457 DO_4OP_F(vfmadd_s, 32, UW, float32_muladd, 0)
2458 DO_4OP_F(vfmadd_d, 64, UD, float64_muladd, 0)
2459 DO_4OP_F(vfmsub_s, 32, UW, float32_muladd, float_muladd_negate_c)
2460 DO_4OP_F(vfmsub_d, 64, UD, float64_muladd, float_muladd_negate_c)
2461 DO_4OP_F(vfnmadd_s, 32, UW, float32_muladd, float_muladd_negate_result)
2462 DO_4OP_F(vfnmadd_d, 64, UD, float64_muladd, float_muladd_negate_result)
2463 DO_4OP_F(vfnmsub_s, 32, UW, float32_muladd,
2464 float_muladd_negate_c | float_muladd_negate_result)
2465 DO_4OP_F(vfnmsub_d, 64, UD, float64_muladd,
2466 float_muladd_negate_c | float_muladd_negate_result)
2467
2468 #define DO_2OP_F(NAME, BIT, E, FN) \
2469 void HELPER(NAME)(void *vd, void *vj, \
2470 CPULoongArchState *env, uint32_t desc) \
2471 { \
2472 int i; \
2473 VReg *Vd = (VReg *)vd; \
2474 VReg *Vj = (VReg *)vj; \
2475 int oprsz = simd_oprsz(desc); \
2476 \
2477 vec_clear_cause(env); \
2478 for (i = 0; i < oprsz / (BIT / 8); i++) { \
2479 Vd->E(i) = FN(env, Vj->E(i)); \
2480 } \
2481 }
2482
2483 #define FLOGB(BIT, T) \
2484 static T do_flogb_## BIT(CPULoongArchState *env, T fj) \
2485 { \
2486 T fp, fd; \
2487 float_status *status = &env->fp_status; \
2488 FloatRoundMode old_mode = get_float_rounding_mode(status); \
2489 \
2490 set_float_rounding_mode(float_round_down, status); \
2491 fp = float ## BIT ##_log2(fj, status); \
2492 fd = float ## BIT ##_round_to_int(fp, status); \
2493 set_float_rounding_mode(old_mode, status); \
2494 vec_update_fcsr0_mask(env, GETPC(), float_flag_inexact); \
2495 return fd; \
2496 }
2497
2498 FLOGB(32, uint32_t)
2499 FLOGB(64, uint64_t)
2500
2501 #define FCLASS(NAME, BIT, E, FN) \
2502 void HELPER(NAME)(void *vd, void *vj, \
2503 CPULoongArchState *env, uint32_t desc) \
2504 { \
2505 int i; \
2506 VReg *Vd = (VReg *)vd; \
2507 VReg *Vj = (VReg *)vj; \
2508 int oprsz = simd_oprsz(desc); \
2509 \
2510 for (i = 0; i < oprsz / (BIT / 8); i++) { \
2511 Vd->E(i) = FN(env, Vj->E(i)); \
2512 } \
2513 }
2514
2515 FCLASS(vfclass_s, 32, UW, helper_fclass_s)
2516 FCLASS(vfclass_d, 64, UD, helper_fclass_d)
2517
2518 #define FSQRT(BIT, T) \
2519 static T do_fsqrt_## BIT(CPULoongArchState *env, T fj) \
2520 { \
2521 T fd; \
2522 fd = float ## BIT ##_sqrt(fj, &env->fp_status); \
2523 vec_update_fcsr0(env, GETPC()); \
2524 return fd; \
2525 }
2526
2527 FSQRT(32, uint32_t)
2528 FSQRT(64, uint64_t)
2529
2530 #define FRECIP(BIT, T) \
2531 static T do_frecip_## BIT(CPULoongArchState *env, T fj) \
2532 { \
2533 T fd; \
2534 fd = float ## BIT ##_div(float ## BIT ##_one, fj, &env->fp_status); \
2535 vec_update_fcsr0(env, GETPC()); \
2536 return fd; \
2537 }
2538
2539 FRECIP(32, uint32_t)
2540 FRECIP(64, uint64_t)
2541
2542 #define FRSQRT(BIT, T) \
2543 static T do_frsqrt_## BIT(CPULoongArchState *env, T fj) \
2544 { \
2545 T fd, fp; \
2546 fp = float ## BIT ##_sqrt(fj, &env->fp_status); \
2547 fd = float ## BIT ##_div(float ## BIT ##_one, fp, &env->fp_status); \
2548 vec_update_fcsr0(env, GETPC()); \
2549 return fd; \
2550 }
2551
2552 FRSQRT(32, uint32_t)
2553 FRSQRT(64, uint64_t)
2554
2555 DO_2OP_F(vflogb_s, 32, UW, do_flogb_32)
2556 DO_2OP_F(vflogb_d, 64, UD, do_flogb_64)
2557 DO_2OP_F(vfsqrt_s, 32, UW, do_fsqrt_32)
2558 DO_2OP_F(vfsqrt_d, 64, UD, do_fsqrt_64)
2559 DO_2OP_F(vfrecip_s, 32, UW, do_frecip_32)
2560 DO_2OP_F(vfrecip_d, 64, UD, do_frecip_64)
2561 DO_2OP_F(vfrsqrt_s, 32, UW, do_frsqrt_32)
2562 DO_2OP_F(vfrsqrt_d, 64, UD, do_frsqrt_64)
2563
2564 static uint32_t float16_cvt_float32(uint16_t h, float_status *status)
2565 {
2566 return float16_to_float32(h, true, status);
2567 }
2568 static uint64_t float32_cvt_float64(uint32_t s, float_status *status)
2569 {
2570 return float32_to_float64(s, status);
2571 }
2572
2573 static uint16_t float32_cvt_float16(uint32_t s, float_status *status)
2574 {
2575 return float32_to_float16(s, true, status);
2576 }
2577 static uint32_t float64_cvt_float32(uint64_t d, float_status *status)
2578 {
2579 return float64_to_float32(d, status);
2580 }
2581
2582 void HELPER(vfcvtl_s_h)(void *vd, void *vj,
2583 CPULoongArchState *env, uint32_t desc)
2584 {
2585 int i, j, ofs;
2586 VReg temp = {};
2587 VReg *Vd = (VReg *)vd;
2588 VReg *Vj = (VReg *)vj;
2589 int oprsz = simd_oprsz(desc);
2590
2591 ofs = LSX_LEN / 32;
2592 vec_clear_cause(env);
2593 for (i = 0; i < oprsz / 16; i++) {
2594 for (j = 0; j < ofs; j++) {
2595 temp.UW(j + ofs * i) =float16_cvt_float32(Vj->UH(j + ofs * 2 * i),
2596 &env->fp_status);
2597 }
2598 vec_update_fcsr0(env, GETPC());
2599 }
2600 *Vd = temp;
2601 }
2602
2603 void HELPER(vfcvtl_d_s)(void *vd, void *vj,
2604 CPULoongArchState *env, uint32_t desc)
2605 {
2606 int i, j, ofs;
2607 VReg temp = {};
2608 VReg *Vd = (VReg *)vd;
2609 VReg *Vj = (VReg *)vj;
2610 int oprsz = simd_oprsz(desc);
2611
2612 ofs = LSX_LEN / 64;
2613 vec_clear_cause(env);
2614 for (i = 0; i < oprsz / 16; i++) {
2615 for (j = 0; j < ofs; j++) {
2616 temp.UD(j + ofs * i) = float32_cvt_float64(Vj->UW(j + ofs * 2 * i),
2617 &env->fp_status);
2618 }
2619 vec_update_fcsr0(env, GETPC());
2620 }
2621 *Vd = temp;
2622 }
2623
2624 void HELPER(vfcvth_s_h)(void *vd, void *vj,
2625 CPULoongArchState *env, uint32_t desc)
2626 {
2627 int i, j, ofs;
2628 VReg temp = {};
2629 VReg *Vd = (VReg *)vd;
2630 VReg *Vj = (VReg *)vj;
2631 int oprsz = simd_oprsz(desc);
2632
2633 ofs = LSX_LEN / 32;
2634 vec_clear_cause(env);
2635 for (i = 0; i < oprsz / 16; i++) {
2636 for (j = 0; j < ofs; j++) {
2637 temp.UW(j + ofs * i) = float16_cvt_float32(Vj->UH(j + ofs * (2 * i + 1)),
2638 &env->fp_status);
2639 }
2640 vec_update_fcsr0(env, GETPC());
2641 }
2642 *Vd = temp;
2643 }
2644
2645 void HELPER(vfcvth_d_s)(void *vd, void *vj,
2646 CPULoongArchState *env, uint32_t desc)
2647 {
2648 int i, j, ofs;
2649 VReg temp = {};
2650 VReg *Vd = (VReg *)vd;
2651 VReg *Vj = (VReg *)vj;
2652 int oprsz = simd_oprsz(desc);
2653
2654 ofs = LSX_LEN / 64;
2655 vec_clear_cause(env);
2656 for (i = 0; i < oprsz / 16; i++) {
2657 for (j = 0; j < ofs; j++) {
2658 temp.UD(j + ofs * i) = float32_cvt_float64(Vj->UW(j + ofs * (2 * i + 1)),
2659 &env->fp_status);
2660 }
2661 vec_update_fcsr0(env, GETPC());
2662 }
2663 *Vd = temp;
2664 }
2665
2666 void HELPER(vfcvt_h_s)(void *vd, void *vj, void *vk,
2667 CPULoongArchState *env, uint32_t desc)
2668 {
2669 int i, j, ofs;
2670 VReg temp = {};
2671 VReg *Vd = (VReg *)vd;
2672 VReg *Vj = (VReg *)vj;
2673 VReg *Vk = (VReg *)vk;
2674 int oprsz = simd_oprsz(desc);
2675
2676 ofs = LSX_LEN / 32;
2677 vec_clear_cause(env);
2678 for(i = 0; i < oprsz / 16; i++) {
2679 for (j = 0; j < ofs; j++) {
2680 temp.UH(j + ofs * (2 * i + 1)) = float32_cvt_float16(Vj->UW(j + ofs * i),
2681 &env->fp_status);
2682 temp.UH(j + ofs * 2 * i) = float32_cvt_float16(Vk->UW(j + ofs * i),
2683 &env->fp_status);
2684 }
2685 vec_update_fcsr0(env, GETPC());
2686 }
2687 *Vd = temp;
2688 }
2689
2690 void HELPER(vfcvt_s_d)(void *vd, void *vj, void *vk,
2691 CPULoongArchState *env, uint32_t desc)
2692 {
2693 int i, j, ofs;
2694 VReg temp = {};
2695 VReg *Vd = (VReg *)vd;
2696 VReg *Vj = (VReg *)vj;
2697 VReg *Vk = (VReg *)vk;
2698 int oprsz = simd_oprsz(desc);
2699
2700 ofs = LSX_LEN / 64;
2701 vec_clear_cause(env);
2702 for(i = 0; i < oprsz / 16; i++) {
2703 for (j = 0; j < ofs; j++) {
2704 temp.UW(j + ofs * (2 * i + 1)) = float64_cvt_float32(Vj->UD(j + ofs * i),
2705 &env->fp_status);
2706 temp.UW(j + ofs * 2 * i) = float64_cvt_float32(Vk->UD(j + ofs * i),
2707 &env->fp_status);
2708 }
2709 vec_update_fcsr0(env, GETPC());
2710 }
2711 *Vd = temp;
2712 }
2713
2714 void HELPER(vfrint_s)(void *vd, void *vj,
2715 CPULoongArchState *env, uint32_t desc)
2716 {
2717 int i;
2718 VReg *Vd = (VReg *)vd;
2719 VReg *Vj = (VReg *)vj;
2720 int oprsz = simd_oprsz(desc);
2721
2722 vec_clear_cause(env);
2723 for (i = 0; i < oprsz / 4; i++) {
2724 Vd->W(i) = float32_round_to_int(Vj->UW(i), &env->fp_status);
2725 vec_update_fcsr0(env, GETPC());
2726 }
2727 }
2728
2729 void HELPER(vfrint_d)(void *vd, void *vj,
2730 CPULoongArchState *env, uint32_t desc)
2731 {
2732 int i;
2733 VReg *Vd = (VReg *)vd;
2734 VReg *Vj = (VReg *)vj;
2735 int oprsz = simd_oprsz(desc);
2736
2737 vec_clear_cause(env);
2738 for (i = 0; i < oprsz / 8; i++) {
2739 Vd->D(i) = float64_round_to_int(Vj->UD(i), &env->fp_status);
2740 vec_update_fcsr0(env, GETPC());
2741 }
2742 }
2743
2744 #define FCVT_2OP(NAME, BIT, E, MODE) \
2745 void HELPER(NAME)(void *vd, void *vj, \
2746 CPULoongArchState *env, uint32_t desc) \
2747 { \
2748 int i; \
2749 VReg *Vd = (VReg *)vd; \
2750 VReg *Vj = (VReg *)vj; \
2751 int oprsz = simd_oprsz(desc); \
2752 \
2753 vec_clear_cause(env); \
2754 for (i = 0; i < oprsz / (BIT / 8); i++) { \
2755 FloatRoundMode old_mode = get_float_rounding_mode(&env->fp_status); \
2756 set_float_rounding_mode(MODE, &env->fp_status); \
2757 Vd->E(i) = float## BIT ## _round_to_int(Vj->E(i), &env->fp_status); \
2758 set_float_rounding_mode(old_mode, &env->fp_status); \
2759 vec_update_fcsr0(env, GETPC()); \
2760 } \
2761 }
2762
2763 FCVT_2OP(vfrintrne_s, 32, UW, float_round_nearest_even)
2764 FCVT_2OP(vfrintrne_d, 64, UD, float_round_nearest_even)
2765 FCVT_2OP(vfrintrz_s, 32, UW, float_round_to_zero)
2766 FCVT_2OP(vfrintrz_d, 64, UD, float_round_to_zero)
2767 FCVT_2OP(vfrintrp_s, 32, UW, float_round_up)
2768 FCVT_2OP(vfrintrp_d, 64, UD, float_round_up)
2769 FCVT_2OP(vfrintrm_s, 32, UW, float_round_down)
2770 FCVT_2OP(vfrintrm_d, 64, UD, float_round_down)
2771
2772 #define FTINT(NAME, FMT1, FMT2, T1, T2, MODE) \
2773 static T2 do_ftint ## NAME(CPULoongArchState *env, T1 fj) \
2774 { \
2775 T2 fd; \
2776 FloatRoundMode old_mode = get_float_rounding_mode(&env->fp_status); \
2777 \
2778 set_float_rounding_mode(MODE, &env->fp_status); \
2779 fd = do_## FMT1 ##_to_## FMT2(env, fj); \
2780 set_float_rounding_mode(old_mode, &env->fp_status); \
2781 return fd; \
2782 }
2783
2784 #define DO_FTINT(FMT1, FMT2, T1, T2) \
2785 static T2 do_## FMT1 ##_to_## FMT2(CPULoongArchState *env, T1 fj) \
2786 { \
2787 T2 fd; \
2788 \
2789 fd = FMT1 ##_to_## FMT2(fj, &env->fp_status); \
2790 if (get_float_exception_flags(&env->fp_status) & (float_flag_invalid)) { \
2791 if (FMT1 ##_is_any_nan(fj)) { \
2792 fd = 0; \
2793 } \
2794 } \
2795 vec_update_fcsr0(env, GETPC()); \
2796 return fd; \
2797 }
2798
2799 DO_FTINT(float32, int32, uint32_t, uint32_t)
2800 DO_FTINT(float64, int64, uint64_t, uint64_t)
2801 DO_FTINT(float32, uint32, uint32_t, uint32_t)
2802 DO_FTINT(float64, uint64, uint64_t, uint64_t)
2803 DO_FTINT(float64, int32, uint64_t, uint32_t)
2804 DO_FTINT(float32, int64, uint32_t, uint64_t)
2805
2806 FTINT(rne_w_s, float32, int32, uint32_t, uint32_t, float_round_nearest_even)
2807 FTINT(rne_l_d, float64, int64, uint64_t, uint64_t, float_round_nearest_even)
2808 FTINT(rp_w_s, float32, int32, uint32_t, uint32_t, float_round_up)
2809 FTINT(rp_l_d, float64, int64, uint64_t, uint64_t, float_round_up)
2810 FTINT(rz_w_s, float32, int32, uint32_t, uint32_t, float_round_to_zero)
2811 FTINT(rz_l_d, float64, int64, uint64_t, uint64_t, float_round_to_zero)
2812 FTINT(rm_w_s, float32, int32, uint32_t, uint32_t, float_round_down)
2813 FTINT(rm_l_d, float64, int64, uint64_t, uint64_t, float_round_down)
2814
2815 DO_2OP_F(vftintrne_w_s, 32, UW, do_ftintrne_w_s)
2816 DO_2OP_F(vftintrne_l_d, 64, UD, do_ftintrne_l_d)
2817 DO_2OP_F(vftintrp_w_s, 32, UW, do_ftintrp_w_s)
2818 DO_2OP_F(vftintrp_l_d, 64, UD, do_ftintrp_l_d)
2819 DO_2OP_F(vftintrz_w_s, 32, UW, do_ftintrz_w_s)
2820 DO_2OP_F(vftintrz_l_d, 64, UD, do_ftintrz_l_d)
2821 DO_2OP_F(vftintrm_w_s, 32, UW, do_ftintrm_w_s)
2822 DO_2OP_F(vftintrm_l_d, 64, UD, do_ftintrm_l_d)
2823 DO_2OP_F(vftint_w_s, 32, UW, do_float32_to_int32)
2824 DO_2OP_F(vftint_l_d, 64, UD, do_float64_to_int64)
2825
2826 FTINT(rz_wu_s, float32, uint32, uint32_t, uint32_t, float_round_to_zero)
2827 FTINT(rz_lu_d, float64, uint64, uint64_t, uint64_t, float_round_to_zero)
2828
2829 DO_2OP_F(vftintrz_wu_s, 32, UW, do_ftintrz_wu_s)
2830 DO_2OP_F(vftintrz_lu_d, 64, UD, do_ftintrz_lu_d)
2831 DO_2OP_F(vftint_wu_s, 32, UW, do_float32_to_uint32)
2832 DO_2OP_F(vftint_lu_d, 64, UD, do_float64_to_uint64)
2833
2834 FTINT(rm_w_d, float64, int32, uint64_t, uint32_t, float_round_down)
2835 FTINT(rp_w_d, float64, int32, uint64_t, uint32_t, float_round_up)
2836 FTINT(rz_w_d, float64, int32, uint64_t, uint32_t, float_round_to_zero)
2837 FTINT(rne_w_d, float64, int32, uint64_t, uint32_t, float_round_nearest_even)
2838
2839 #define FTINT_W_D(NAME, FN) \
2840 void HELPER(NAME)(void *vd, void *vj, void *vk, \
2841 CPULoongArchState *env, uint32_t desc) \
2842 { \
2843 int i, j, ofs; \
2844 VReg temp = {}; \
2845 VReg *Vd = (VReg *)vd; \
2846 VReg *Vj = (VReg *)vj; \
2847 VReg *Vk = (VReg *)vk; \
2848 int oprsz = simd_oprsz(desc); \
2849 \
2850 ofs = LSX_LEN / 64; \
2851 vec_clear_cause(env); \
2852 for (i = 0; i < oprsz / 16; i++) { \
2853 for (j = 0; j < ofs; j++) { \
2854 temp.W(j + ofs * (2 * i + 1)) = FN(env, Vj->UD(j + ofs * i)); \
2855 temp.W(j + ofs * 2 * i) = FN(env, Vk->UD(j + ofs * i)); \
2856 } \
2857 } \
2858 *Vd = temp; \
2859 }
2860
2861 FTINT_W_D(vftint_w_d, do_float64_to_int32)
2862 FTINT_W_D(vftintrm_w_d, do_ftintrm_w_d)
2863 FTINT_W_D(vftintrp_w_d, do_ftintrp_w_d)
2864 FTINT_W_D(vftintrz_w_d, do_ftintrz_w_d)
2865 FTINT_W_D(vftintrne_w_d, do_ftintrne_w_d)
2866
2867 FTINT(rml_l_s, float32, int64, uint32_t, uint64_t, float_round_down)
2868 FTINT(rpl_l_s, float32, int64, uint32_t, uint64_t, float_round_up)
2869 FTINT(rzl_l_s, float32, int64, uint32_t, uint64_t, float_round_to_zero)
2870 FTINT(rnel_l_s, float32, int64, uint32_t, uint64_t, float_round_nearest_even)
2871 FTINT(rmh_l_s, float32, int64, uint32_t, uint64_t, float_round_down)
2872 FTINT(rph_l_s, float32, int64, uint32_t, uint64_t, float_round_up)
2873 FTINT(rzh_l_s, float32, int64, uint32_t, uint64_t, float_round_to_zero)
2874 FTINT(rneh_l_s, float32, int64, uint32_t, uint64_t, float_round_nearest_even)
2875
2876 #define FTINTL_L_S(NAME, FN) \
2877 void HELPER(NAME)(void *vd, void *vj, \
2878 CPULoongArchState *env, uint32_t desc) \
2879 { \
2880 int i, j, ofs; \
2881 VReg temp; \
2882 VReg *Vd = (VReg *)vd; \
2883 VReg *Vj = (VReg *)vj; \
2884 int oprsz = simd_oprsz(desc); \
2885 \
2886 ofs = LSX_LEN / 64; \
2887 vec_clear_cause(env); \
2888 for (i = 0; i < oprsz / 16; i++) { \
2889 for (j = 0; j < ofs; j++) { \
2890 temp.D(j + ofs * i) = FN(env, Vj->UW(j + ofs * 2 * i)); \
2891 } \
2892 } \
2893 *Vd = temp; \
2894 }
2895
2896 FTINTL_L_S(vftintl_l_s, do_float32_to_int64)
2897 FTINTL_L_S(vftintrml_l_s, do_ftintrml_l_s)
2898 FTINTL_L_S(vftintrpl_l_s, do_ftintrpl_l_s)
2899 FTINTL_L_S(vftintrzl_l_s, do_ftintrzl_l_s)
2900 FTINTL_L_S(vftintrnel_l_s, do_ftintrnel_l_s)
2901
2902 #define FTINTH_L_S(NAME, FN) \
2903 void HELPER(NAME)(void *vd, void *vj, \
2904 CPULoongArchState *env, uint32_t desc) \
2905 { \
2906 int i, j, ofs; \
2907 VReg temp = {}; \
2908 VReg *Vd = (VReg *)vd; \
2909 VReg *Vj = (VReg *)vj; \
2910 int oprsz = simd_oprsz(desc); \
2911 \
2912 ofs = LSX_LEN / 64; \
2913 vec_clear_cause(env); \
2914 for (i = 0; i < oprsz / 16; i++) { \
2915 for (j = 0; j < ofs; j++) { \
2916 temp.D(j + ofs * i) = FN(env, Vj->UW(j + ofs * (2 * i + 1))); \
2917 } \
2918 } \
2919 *Vd = temp; \
2920 }
2921
2922 FTINTH_L_S(vftinth_l_s, do_float32_to_int64)
2923 FTINTH_L_S(vftintrmh_l_s, do_ftintrmh_l_s)
2924 FTINTH_L_S(vftintrph_l_s, do_ftintrph_l_s)
2925 FTINTH_L_S(vftintrzh_l_s, do_ftintrzh_l_s)
2926 FTINTH_L_S(vftintrneh_l_s, do_ftintrneh_l_s)
2927
2928 #define FFINT(NAME, FMT1, FMT2, T1, T2) \
2929 static T2 do_ffint_ ## NAME(CPULoongArchState *env, T1 fj) \
2930 { \
2931 T2 fd; \
2932 \
2933 fd = FMT1 ##_to_## FMT2(fj, &env->fp_status); \
2934 vec_update_fcsr0(env, GETPC()); \
2935 return fd; \
2936 }
2937
2938 FFINT(s_w, int32, float32, int32_t, uint32_t)
2939 FFINT(d_l, int64, float64, int64_t, uint64_t)
2940 FFINT(s_wu, uint32, float32, uint32_t, uint32_t)
2941 FFINT(d_lu, uint64, float64, uint64_t, uint64_t)
2942
2943 DO_2OP_F(vffint_s_w, 32, W, do_ffint_s_w)
2944 DO_2OP_F(vffint_d_l, 64, D, do_ffint_d_l)
2945 DO_2OP_F(vffint_s_wu, 32, UW, do_ffint_s_wu)
2946 DO_2OP_F(vffint_d_lu, 64, UD, do_ffint_d_lu)
2947
2948 void HELPER(vffintl_d_w)(void *vd, void *vj,
2949 CPULoongArchState *env, uint32_t desc)
2950 {
2951 int i, j, ofs;
2952 VReg temp = {};
2953 VReg *Vd = (VReg *)vd;
2954 VReg *Vj = (VReg *)vj;
2955 int oprsz = simd_oprsz(desc);
2956
2957 ofs = LSX_LEN / 64;
2958 vec_clear_cause(env);
2959 for (i = 0; i < oprsz / 16; i++) {
2960 for (j = 0; j < ofs; j++) {
2961 temp.D(j + ofs * i) = int32_to_float64(Vj->W(j + ofs * 2 * i),
2962 &env->fp_status);
2963 }
2964 vec_update_fcsr0(env, GETPC());
2965 }
2966 *Vd = temp;
2967 }
2968
2969 void HELPER(vffinth_d_w)(void *vd, void *vj,
2970 CPULoongArchState *env, uint32_t desc)
2971 {
2972 int i, j, ofs;
2973 VReg temp = {};
2974 VReg *Vd = (VReg *)vd;
2975 VReg *Vj = (VReg *)vj;
2976 int oprsz = simd_oprsz(desc);
2977
2978 ofs = LSX_LEN / 64;
2979 vec_clear_cause(env);
2980 for (i = 0; i < oprsz /16; i++) {
2981 for (j = 0; j < ofs; j++) {
2982 temp.D(j + ofs * i) = int32_to_float64(Vj->W(j + ofs * (2 * i + 1)),
2983 &env->fp_status);
2984 }
2985 vec_update_fcsr0(env, GETPC());
2986 }
2987 *Vd = temp;
2988 }
2989
2990 void HELPER(vffint_s_l)(void *vd, void *vj, void *vk,
2991 CPULoongArchState *env, uint32_t desc)
2992 {
2993 int i, j, ofs;
2994 VReg temp = {};
2995 VReg *Vd = (VReg *)vd;
2996 VReg *Vj = (VReg *)vj;
2997 VReg *Vk = (VReg *)vk;
2998 int oprsz = simd_oprsz(desc);
2999
3000 ofs = LSX_LEN / 64;
3001 vec_clear_cause(env);
3002 for (i = 0; i < oprsz / 16; i++) {
3003 for (j = 0; j < ofs; j++) {
3004 temp.W(j + ofs * (2 * i + 1)) = int64_to_float32(Vj->D(j + ofs * i),
3005 &env->fp_status);
3006 temp.W(j + ofs * 2 * i) = int64_to_float32(Vk->D(j + ofs * i),
3007 &env->fp_status);
3008 }
3009 vec_update_fcsr0(env, GETPC());
3010 }
3011 *Vd = temp;
3012 }
3013
3014 #define VCMPI(NAME, BIT, E, DO_OP) \
3015 void HELPER(NAME)(void *vd, void *vj, uint64_t imm, uint32_t desc) \
3016 { \
3017 int i; \
3018 VReg *Vd = (VReg *)vd; \
3019 VReg *Vj = (VReg *)vj; \
3020 typedef __typeof(Vd->E(0)) TD; \
3021 int oprsz = simd_oprsz(desc); \
3022 \
3023 for (i = 0; i < oprsz / (BIT / 8); i++) { \
3024 Vd->E(i) = DO_OP(Vj->E(i), (TD)imm); \
3025 } \
3026 }
3027
3028 VCMPI(vseqi_b, 8, B, VSEQ)
3029 VCMPI(vseqi_h, 16, H, VSEQ)
3030 VCMPI(vseqi_w, 32, W, VSEQ)
3031 VCMPI(vseqi_d, 64, D, VSEQ)
3032 VCMPI(vslei_b, 8, B, VSLE)
3033 VCMPI(vslei_h, 16, H, VSLE)
3034 VCMPI(vslei_w, 32, W, VSLE)
3035 VCMPI(vslei_d, 64, D, VSLE)
3036 VCMPI(vslei_bu, 8, UB, VSLE)
3037 VCMPI(vslei_hu, 16, UH, VSLE)
3038 VCMPI(vslei_wu, 32, UW, VSLE)
3039 VCMPI(vslei_du, 64, UD, VSLE)
3040 VCMPI(vslti_b, 8, B, VSLT)
3041 VCMPI(vslti_h, 16, H, VSLT)
3042 VCMPI(vslti_w, 32, W, VSLT)
3043 VCMPI(vslti_d, 64, D, VSLT)
3044 VCMPI(vslti_bu, 8, UB, VSLT)
3045 VCMPI(vslti_hu, 16, UH, VSLT)
3046 VCMPI(vslti_wu, 32, UW, VSLT)
3047 VCMPI(vslti_du, 64, UD, VSLT)
3048
3049 static uint64_t vfcmp_common(CPULoongArchState *env,
3050 FloatRelation cmp, uint32_t flags)
3051 {
3052 uint64_t ret = 0;
3053
3054 switch (cmp) {
3055 case float_relation_less:
3056 ret = (flags & FCMP_LT);
3057 break;
3058 case float_relation_equal:
3059 ret = (flags & FCMP_EQ);
3060 break;
3061 case float_relation_greater:
3062 ret = (flags & FCMP_GT);
3063 break;
3064 case float_relation_unordered:
3065 ret = (flags & FCMP_UN);
3066 break;
3067 default:
3068 g_assert_not_reached();
3069 }
3070
3071 if (ret) {
3072 ret = -1;
3073 }
3074
3075 return ret;
3076 }
3077
3078 #define VFCMP(NAME, BIT, E, FN) \
3079 void HELPER(NAME)(CPULoongArchState *env, uint32_t oprsz, \
3080 uint32_t vd, uint32_t vj, uint32_t vk, uint32_t flags) \
3081 { \
3082 int i; \
3083 VReg t; \
3084 VReg *Vd = &(env->fpr[vd].vreg); \
3085 VReg *Vj = &(env->fpr[vj].vreg); \
3086 VReg *Vk = &(env->fpr[vk].vreg); \
3087 \
3088 vec_clear_cause(env); \
3089 for (i = 0; i < oprsz / (BIT / 8); i++) { \
3090 FloatRelation cmp; \
3091 cmp = FN(Vj->E(i), Vk->E(i), &env->fp_status); \
3092 t.E(i) = vfcmp_common(env, cmp, flags); \
3093 vec_update_fcsr0(env, GETPC()); \
3094 } \
3095 *Vd = t; \
3096 }
3097
3098 VFCMP(vfcmp_c_s, 32, UW, float32_compare_quiet)
3099 VFCMP(vfcmp_s_s, 32, UW, float32_compare)
3100 VFCMP(vfcmp_c_d, 64, UD, float64_compare_quiet)
3101 VFCMP(vfcmp_s_d, 64, UD, float64_compare)
3102
3103 void HELPER(vbitseli_b)(void *vd, void *vj, uint64_t imm, uint32_t desc)
3104 {
3105 int i;
3106 VReg *Vd = (VReg *)vd;
3107 VReg *Vj = (VReg *)vj;
3108
3109 for (i = 0; i < simd_oprsz(desc); i++) {
3110 Vd->B(i) = (~Vd->B(i) & Vj->B(i)) | (Vd->B(i) & imm);
3111 }
3112 }
3113
3114 /* Copy from target/arm/tcg/sve_helper.c */
3115 static inline bool do_match2(uint64_t n, uint64_t m0, uint64_t m1, int esz)
3116 {
3117 int bits = 8 << esz;
3118 uint64_t ones = dup_const(esz, 1);
3119 uint64_t signs = ones << (bits - 1);
3120 uint64_t cmp0, cmp1;
3121
3122 cmp1 = dup_const(esz, n);
3123 cmp0 = cmp1 ^ m0;
3124 cmp1 = cmp1 ^ m1;
3125 cmp0 = (cmp0 - ones) & ~cmp0;
3126 cmp1 = (cmp1 - ones) & ~cmp1;
3127 return (cmp0 | cmp1) & signs;
3128 }
3129
3130 #define SETANYEQZ(NAME, MO) \
3131 void HELPER(NAME)(CPULoongArchState *env, \
3132 uint32_t oprsz, uint32_t cd, uint32_t vj) \
3133 { \
3134 VReg *Vj = &(env->fpr[vj].vreg); \
3135 \
3136 env->cf[cd & 0x7] = do_match2(0, Vj->D(0), Vj->D(1), MO); \
3137 if (oprsz == 32) { \
3138 env->cf[cd & 0x7] = env->cf[cd & 0x7] || \
3139 do_match2(0, Vj->D(2), Vj->D(3), MO); \
3140 } \
3141 }
3142
3143 SETANYEQZ(vsetanyeqz_b, MO_8)
3144 SETANYEQZ(vsetanyeqz_h, MO_16)
3145 SETANYEQZ(vsetanyeqz_w, MO_32)
3146 SETANYEQZ(vsetanyeqz_d, MO_64)
3147
3148 #define SETALLNEZ(NAME, MO) \
3149 void HELPER(NAME)(CPULoongArchState *env, \
3150 uint32_t oprsz, uint32_t cd, uint32_t vj) \
3151 { \
3152 VReg *Vj = &(env->fpr[vj].vreg); \
3153 \
3154 env->cf[cd & 0x7]= !do_match2(0, Vj->D(0), Vj->D(1), MO); \
3155 if (oprsz == 32) { \
3156 env->cf[cd & 0x7] = env->cf[cd & 0x7] && \
3157 !do_match2(0, Vj->D(2), Vj->D(3), MO); \
3158 } \
3159 }
3160
3161 SETALLNEZ(vsetallnez_b, MO_8)
3162 SETALLNEZ(vsetallnez_h, MO_16)
3163 SETALLNEZ(vsetallnez_w, MO_32)
3164 SETALLNEZ(vsetallnez_d, MO_64)
3165
3166 #define XVINSVE0(NAME, E, MASK) \
3167 void HELPER(NAME)(void *vd, void *vj, uint64_t imm, uint32_t desc) \
3168 { \
3169 VReg *Vd = (VReg *)vd; \
3170 VReg *Vj = (VReg *)vj; \
3171 Vd->E(imm & MASK) = Vj->E(0); \
3172 }
3173
3174 XVINSVE0(xvinsve0_w, W, 0x7)
3175 XVINSVE0(xvinsve0_d, D, 0x3)
3176
3177 #define XVPICKVE(NAME, E, BIT, MASK) \
3178 void HELPER(NAME)(void *vd, void *vj, uint64_t imm, uint32_t desc) \
3179 { \
3180 int i; \
3181 VReg *Vd = (VReg *)vd; \
3182 VReg *Vj = (VReg *)vj; \
3183 int oprsz = simd_oprsz(desc); \
3184 \
3185 Vd->E(0) = Vj->E(imm & MASK); \
3186 for (i = 1; i < oprsz / (BIT / 8); i++) { \
3187 Vd->E(i) = 0; \
3188 } \
3189 }
3190
3191 XVPICKVE(xvpickve_w, W, 32, 0x7)
3192 XVPICKVE(xvpickve_d, D, 64, 0x3)
3193
3194 #define VPACKEV(NAME, BIT, E) \
3195 void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \
3196 { \
3197 int i; \
3198 VReg temp = {}; \
3199 VReg *Vd = (VReg *)vd; \
3200 VReg *Vj = (VReg *)vj; \
3201 VReg *Vk = (VReg *)vk; \
3202 int oprsz = simd_oprsz(desc); \
3203 \
3204 for (i = 0; i < oprsz / (BIT / 8); i++) { \
3205 temp.E(2 * i + 1) = Vj->E(2 * i); \
3206 temp.E(2 *i) = Vk->E(2 * i); \
3207 } \
3208 *Vd = temp; \
3209 }
3210
3211 VPACKEV(vpackev_b, 16, B)
3212 VPACKEV(vpackev_h, 32, H)
3213 VPACKEV(vpackev_w, 64, W)
3214 VPACKEV(vpackev_d, 128, D)
3215
3216 #define VPACKOD(NAME, BIT, E) \
3217 void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \
3218 { \
3219 int i; \
3220 VReg temp = {}; \
3221 VReg *Vd = (VReg *)vd; \
3222 VReg *Vj = (VReg *)vj; \
3223 VReg *Vk = (VReg *)vk; \
3224 int oprsz = simd_oprsz(desc); \
3225 \
3226 for (i = 0; i < oprsz / (BIT / 8); i++) { \
3227 temp.E(2 * i + 1) = Vj->E(2 * i + 1); \
3228 temp.E(2 * i) = Vk->E(2 * i + 1); \
3229 } \
3230 *Vd = temp; \
3231 }
3232
3233 VPACKOD(vpackod_b, 16, B)
3234 VPACKOD(vpackod_h, 32, H)
3235 VPACKOD(vpackod_w, 64, W)
3236 VPACKOD(vpackod_d, 128, D)
3237
3238 #define VPICKEV(NAME, BIT, E) \
3239 void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \
3240 { \
3241 int i, j, ofs; \
3242 VReg temp = {}; \
3243 VReg *Vd = (VReg *)vd; \
3244 VReg *Vj = (VReg *)vj; \
3245 VReg *Vk = (VReg *)vk; \
3246 int oprsz = simd_oprsz(desc); \
3247 \
3248 ofs = LSX_LEN / BIT; \
3249 for (i = 0; i < oprsz / 16; i++) { \
3250 for (j = 0; j < ofs; j++) { \
3251 temp.E(j + ofs * (2 * i + 1)) = Vj->E(2 * (j + ofs * i)); \
3252 temp.E(j + ofs * 2 * i) = Vk->E(2 * (j + ofs * i)); \
3253 } \
3254 } \
3255 *Vd = temp; \
3256 }
3257
3258 VPICKEV(vpickev_b, 16, B)
3259 VPICKEV(vpickev_h, 32, H)
3260 VPICKEV(vpickev_w, 64, W)
3261 VPICKEV(vpickev_d, 128, D)
3262
3263 #define VPICKOD(NAME, BIT, E) \
3264 void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \
3265 { \
3266 int i, j, ofs; \
3267 VReg temp = {}; \
3268 VReg *Vd = (VReg *)vd; \
3269 VReg *Vj = (VReg *)vj; \
3270 VReg *Vk = (VReg *)vk; \
3271 int oprsz = simd_oprsz(desc); \
3272 \
3273 ofs = LSX_LEN / BIT; \
3274 for (i = 0; i < oprsz / 16; i++) { \
3275 for (j = 0; j < ofs; j++) { \
3276 temp.E(j + ofs * (2 * i + 1)) = Vj->E(2 * (j + ofs * i) + 1); \
3277 temp.E(j + ofs * 2 * i) = Vk->E(2 * (j + ofs * i) + 1); \
3278 } \
3279 } \
3280 *Vd = temp; \
3281 }
3282
3283 VPICKOD(vpickod_b, 16, B)
3284 VPICKOD(vpickod_h, 32, H)
3285 VPICKOD(vpickod_w, 64, W)
3286 VPICKOD(vpickod_d, 128, D)
3287
3288 #define VILVL(NAME, BIT, E) \
3289 void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \
3290 { \
3291 int i, j, ofs; \
3292 VReg temp = {}; \
3293 VReg *Vd = (VReg *)vd; \
3294 VReg *Vj = (VReg *)vj; \
3295 VReg *Vk = (VReg *)vk; \
3296 int oprsz = simd_oprsz(desc); \
3297 \
3298 ofs = LSX_LEN / BIT; \
3299 for (i = 0; i < oprsz / 16; i++) { \
3300 for (j = 0; j < ofs; j++) { \
3301 temp.E(2 * (j + ofs * i) + 1) = Vj->E(j + ofs * 2 * i); \
3302 temp.E(2 * (j + ofs * i)) = Vk->E(j + ofs * 2 * i); \
3303 } \
3304 } \
3305 *Vd = temp; \
3306 }
3307
3308 VILVL(vilvl_b, 16, B)
3309 VILVL(vilvl_h, 32, H)
3310 VILVL(vilvl_w, 64, W)
3311 VILVL(vilvl_d, 128, D)
3312
3313 #define VILVH(NAME, BIT, E) \
3314 void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \
3315 { \
3316 int i, j, ofs; \
3317 VReg temp = {}; \
3318 VReg *Vd = (VReg *)vd; \
3319 VReg *Vj = (VReg *)vj; \
3320 VReg *Vk = (VReg *)vk; \
3321 int oprsz = simd_oprsz(desc); \
3322 \
3323 ofs = LSX_LEN / BIT; \
3324 for (i = 0; i < oprsz / 16; i++) { \
3325 for (j = 0; j < ofs; j++) { \
3326 temp.E(2 * (j + ofs * i) + 1) = Vj->E(j + ofs * (2 * i + 1)); \
3327 temp.E(2 * (j + ofs * i)) = Vk->E(j + ofs * (2 * i + 1)); \
3328 } \
3329 } \
3330 *Vd = temp; \
3331 }
3332
3333 VILVH(vilvh_b, 16, B)
3334 VILVH(vilvh_h, 32, H)
3335 VILVH(vilvh_w, 64, W)
3336 VILVH(vilvh_d, 128, D)
3337
3338 void HELPER(vshuf_b)(void *vd, void *vj, void *vk, void *va, uint32_t desc)
3339 {
3340 int i, j, m;
3341 VReg temp = {};
3342 VReg *Vd = (VReg *)vd;
3343 VReg *Vj = (VReg *)vj;
3344 VReg *Vk = (VReg *)vk;
3345 VReg *Va = (VReg *)va;
3346 int oprsz = simd_oprsz(desc);
3347
3348 m = LSX_LEN / 8;
3349 for (i = 0; i < (oprsz / 16) * m; i++) {
3350 j = i < m ? 0 : 1;
3351 uint64_t k = (uint8_t)Va->B(i) % (2 * m);
3352 temp.B(i) = k < m ? Vk->B(k + j * m): Vj->B(k + (j - 1) * m);
3353 }
3354 *Vd = temp;
3355 }
3356
3357 #define VSHUF(NAME, BIT, E) \
3358 void HELPER(NAME)(void *vd, void *vj, void *vk, uint32_t desc) \
3359 { \
3360 int i, j, m; \
3361 VReg temp = {}; \
3362 VReg *Vd = (VReg *)vd; \
3363 VReg *Vj = (VReg *)vj; \
3364 VReg *Vk = (VReg *)vk; \
3365 int oprsz = simd_oprsz(desc); \
3366 \
3367 m = LSX_LEN / BIT; \
3368 for (i = 0; i < (oprsz / 16) * m; i++) { \
3369 j = i < m ? 0 : 1; \
3370 uint64_t k = ((uint8_t)Vd->E(i)) % (2 * m); \
3371 temp.E(i) = k < m ? Vk->E(k + j * m) : Vj->E(k + (j - 1) * m); \
3372 } \
3373 *Vd = temp; \
3374 }
3375
3376 VSHUF(vshuf_h, 16, H)
3377 VSHUF(vshuf_w, 32, W)
3378 VSHUF(vshuf_d, 64, D)
3379
3380 #define VSHUF4I(NAME, BIT, E) \
3381 void HELPER(NAME)(void *vd, void *vj, uint64_t imm, uint32_t desc) \
3382 { \
3383 int i, j, max; \
3384 VReg temp = {}; \
3385 VReg *Vd = (VReg *)vd; \
3386 VReg *Vj = (VReg *)vj; \
3387 int oprsz = simd_oprsz(desc); \
3388 \
3389 max = LSX_LEN / BIT; \
3390 for (i = 0; i < oprsz / (BIT / 8); i++) { \
3391 j = i < max ? 1 : 2; \
3392 temp.E(i) = Vj->E(SHF_POS(i - ((j -1)* max), imm) + (j - 1) * max); \
3393 } \
3394 *Vd = temp; \
3395 }
3396
3397 VSHUF4I(vshuf4i_b, 8, B)
3398 VSHUF4I(vshuf4i_h, 16, H)
3399 VSHUF4I(vshuf4i_w, 32, W)
3400
3401 void HELPER(vshuf4i_d)(void *vd, void *vj, uint64_t imm, uint32_t desc)
3402 {
3403 int i;
3404 VReg temp = {};
3405 VReg *Vd = (VReg *)vd;
3406 VReg *Vj = (VReg *)vj;
3407 int oprsz = simd_oprsz(desc);
3408
3409 for (i = 0; i < oprsz / 16; i++) {
3410 temp.D(2 * i) = (imm & 2 ? Vj : Vd)->D((imm & 1) + 2 * i);
3411 temp.D(2 * i + 1) = (imm & 8 ? Vj : Vd)->D(((imm >> 2) & 1) + 2 * i);
3412 }
3413 *Vd = temp;
3414 }
3415
3416 void HELPER(vperm_w)(void *vd, void *vj, void *vk, uint32_t desc)
3417 {
3418 int i, m;
3419 VReg temp = {};
3420 VReg *Vd = (VReg *)vd;
3421 VReg *Vj = (VReg *)vj;
3422 VReg *Vk = (VReg *)vk;
3423
3424 m = LASX_LEN / 32;
3425 for (i = 0; i < m ; i++) {
3426 uint64_t k = (uint8_t)Vk->W(i) % 8;
3427 temp.W(i) = Vj->W(k);
3428 }
3429 *Vd = temp;
3430 }
3431
3432 void HELPER(vpermi_w)(void *vd, void *vj, uint64_t imm, uint32_t desc)
3433 {
3434 int i;
3435 VReg temp = {};
3436 VReg *Vd = (VReg *)vd;
3437 VReg *Vj = (VReg *)vj;
3438 int oprsz = simd_oprsz(desc);
3439
3440 for (i = 0; i < oprsz / 16; i++) {
3441 temp.W(4 * i) = Vj->W((imm & 0x3) + 4 * i);
3442 temp.W(4 * i + 1) = Vj->W(((imm >> 2) & 0x3) + 4 * i);
3443 temp.W(4 * i + 2) = Vd->W(((imm >> 4) & 0x3) + 4 * i);
3444 temp.W(4 * i + 3) = Vd->W(((imm >> 6) & 0x3) + 4 * i);
3445 }
3446 *Vd = temp;
3447 }
3448
3449 void HELPER(vpermi_d)(void *vd, void *vj, uint64_t imm, uint32_t desc)
3450 {
3451 VReg temp = {};
3452 VReg *Vd = (VReg *)vd;
3453 VReg *Vj = (VReg *)vj;
3454
3455 temp.D(0) = Vj->D(imm & 0x3);
3456 temp.D(1) = Vj->D((imm >> 2) & 0x3);
3457 temp.D(2) = Vj->D((imm >> 4) & 0x3);
3458 temp.D(3) = Vj->D((imm >> 6) & 0x3);
3459 *Vd = temp;
3460 }
3461
3462 void HELPER(vpermi_q)(void *vd, void *vj, uint64_t imm, uint32_t desc)
3463 {
3464 int i;
3465 VReg temp;
3466 VReg *Vd = (VReg *)vd;
3467 VReg *Vj = (VReg *)vj;
3468
3469 for (i = 0; i < 2; i++, imm >>= 4) {
3470 temp.Q(i) = (imm & 2 ? Vd: Vj)->Q(imm & 1);
3471 }
3472 *Vd = temp;
3473 }
3474
3475 #define VEXTRINS(NAME, BIT, E, MASK) \
3476 void HELPER(NAME)(void *vd, void *vj, uint64_t imm, uint32_t desc) \
3477 { \
3478 int i, ins, extr, max; \
3479 VReg *Vd = (VReg *)vd; \
3480 VReg *Vj = (VReg *)vj; \
3481 int oprsz = simd_oprsz(desc); \
3482 \
3483 max = LSX_LEN / BIT; \
3484 ins = (imm >> 4) & MASK; \
3485 extr = imm & MASK; \
3486 for (i = 0; i < oprsz / 16; i++) { \
3487 Vd->E(ins + i * max) = Vj->E(extr + i * max); \
3488 } \
3489 }
3490
3491 VEXTRINS(vextrins_b, 8, B, 0xf)
3492 VEXTRINS(vextrins_h, 16, H, 0x7)
3493 VEXTRINS(vextrins_w, 32, W, 0x3)
3494 VEXTRINS(vextrins_d, 64, D, 0x1)
QEMU mirror