1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20#include "qemu/osdep.h"
21#include "qemu/host-utils.h"
22#include "cpu.h"
23#include "exec/helper-proto.h"
24#include "tcg/tcg-gvec-desc.h"
25
26
27static inline void clear_high(void *d, intptr_t oprsz, uint32_t desc)
28{
29 intptr_t maxsz = simd_maxsz(desc);
30 intptr_t i;
31
32 if (unlikely(maxsz > oprsz)) {
33 for (i = oprsz; i < maxsz; i += sizeof(uint64_t)) {
34 *(uint64_t *)(d + i) = 0;
35 }
36 }
37}
38
39void HELPER(gvec_add8)(void *d, void *a, void *b, uint32_t desc)
40{
41 intptr_t oprsz = simd_oprsz(desc);
42 intptr_t i;
43
44 for (i = 0; i < oprsz; i += sizeof(uint8_t)) {
45 *(uint8_t *)(d + i) = *(uint8_t *)(a + i) + *(uint8_t *)(b + i);
46 }
47 clear_high(d, oprsz, desc);
48}
49
50void HELPER(gvec_add16)(void *d, void *a, void *b, uint32_t desc)
51{
52 intptr_t oprsz = simd_oprsz(desc);
53 intptr_t i;
54
55 for (i = 0; i < oprsz; i += sizeof(uint16_t)) {
56 *(uint16_t *)(d + i) = *(uint16_t *)(a + i) + *(uint16_t *)(b + i);
57 }
58 clear_high(d, oprsz, desc);
59}
60
61void HELPER(gvec_add32)(void *d, void *a, void *b, uint32_t desc)
62{
63 intptr_t oprsz = simd_oprsz(desc);
64 intptr_t i;
65
66 for (i = 0; i < oprsz; i += sizeof(uint32_t)) {
67 *(uint32_t *)(d + i) = *(uint32_t *)(a + i) + *(uint32_t *)(b + i);
68 }
69 clear_high(d, oprsz, desc);
70}
71
72void HELPER(gvec_add64)(void *d, void *a, void *b, uint32_t desc)
73{
74 intptr_t oprsz = simd_oprsz(desc);
75 intptr_t i;
76
77 for (i = 0; i < oprsz; i += sizeof(uint64_t)) {
78 *(uint64_t *)(d + i) = *(uint64_t *)(a + i) + *(uint64_t *)(b + i);
79 }
80 clear_high(d, oprsz, desc);
81}
82
83void HELPER(gvec_adds8)(void *d, void *a, uint64_t b, uint32_t desc)
84{
85 intptr_t oprsz = simd_oprsz(desc);
86 intptr_t i;
87
88 for (i = 0; i < oprsz; i += sizeof(uint8_t)) {
89 *(uint8_t *)(d + i) = *(uint8_t *)(a + i) + (uint8_t)b;
90 }
91 clear_high(d, oprsz, desc);
92}
93
94void HELPER(gvec_adds16)(void *d, void *a, uint64_t b, uint32_t desc)
95{
96 intptr_t oprsz = simd_oprsz(desc);
97 intptr_t i;
98
99 for (i = 0; i < oprsz; i += sizeof(uint16_t)) {
100 *(uint16_t *)(d + i) = *(uint16_t *)(a + i) + (uint16_t)b;
101 }
102 clear_high(d, oprsz, desc);
103}
104
105void HELPER(gvec_adds32)(void *d, void *a, uint64_t b, uint32_t desc)
106{
107 intptr_t oprsz = simd_oprsz(desc);
108 intptr_t i;
109
110 for (i = 0; i < oprsz; i += sizeof(uint32_t)) {
111 *(uint32_t *)(d + i) = *(uint32_t *)(a + i) + (uint32_t)b;
112 }
113 clear_high(d, oprsz, desc);
114}
115
116void HELPER(gvec_adds64)(void *d, void *a, uint64_t b, uint32_t desc)
117{
118 intptr_t oprsz = simd_oprsz(desc);
119 intptr_t i;
120
121 for (i = 0; i < oprsz; i += sizeof(uint64_t)) {
122 *(uint64_t *)(d + i) = *(uint64_t *)(a + i) + b;
123 }
124 clear_high(d, oprsz, desc);
125}
126
127void HELPER(gvec_sub8)(void *d, void *a, void *b, uint32_t desc)
128{
129 intptr_t oprsz = simd_oprsz(desc);
130 intptr_t i;
131
132 for (i = 0; i < oprsz; i += sizeof(uint8_t)) {
133 *(uint8_t *)(d + i) = *(uint8_t *)(a + i) - *(uint8_t *)(b + i);
134 }
135 clear_high(d, oprsz, desc);
136}
137
138void HELPER(gvec_sub16)(void *d, void *a, void *b, uint32_t desc)
139{
140 intptr_t oprsz = simd_oprsz(desc);
141 intptr_t i;
142
143 for (i = 0; i < oprsz; i += sizeof(uint16_t)) {
144 *(uint16_t *)(d + i) = *(uint16_t *)(a + i) - *(uint16_t *)(b + i);
145 }
146 clear_high(d, oprsz, desc);
147}
148
149void HELPER(gvec_sub32)(void *d, void *a, void *b, uint32_t desc)
150{
151 intptr_t oprsz = simd_oprsz(desc);
152 intptr_t i;
153
154 for (i = 0; i < oprsz; i += sizeof(uint32_t)) {
155 *(uint32_t *)(d + i) = *(uint32_t *)(a + i) - *(uint32_t *)(b + i);
156 }
157 clear_high(d, oprsz, desc);
158}
159
160void HELPER(gvec_sub64)(void *d, void *a, void *b, uint32_t desc)
161{
162 intptr_t oprsz = simd_oprsz(desc);
163 intptr_t i;
164
165 for (i = 0; i < oprsz; i += sizeof(uint64_t)) {
166 *(uint64_t *)(d + i) = *(uint64_t *)(a + i) - *(uint64_t *)(b + i);
167 }
168 clear_high(d, oprsz, desc);
169}
170
171void HELPER(gvec_subs8)(void *d, void *a, uint64_t b, uint32_t desc)
172{
173 intptr_t oprsz = simd_oprsz(desc);
174 intptr_t i;
175
176 for (i = 0; i < oprsz; i += sizeof(uint8_t)) {
177 *(uint8_t *)(d + i) = *(uint8_t *)(a + i) - (uint8_t)b;
178 }
179 clear_high(d, oprsz, desc);
180}
181
182void HELPER(gvec_subs16)(void *d, void *a, uint64_t b, uint32_t desc)
183{
184 intptr_t oprsz = simd_oprsz(desc);
185 intptr_t i;
186
187 for (i = 0; i < oprsz; i += sizeof(uint16_t)) {
188 *(uint16_t *)(d + i) = *(uint16_t *)(a + i) - (uint16_t)b;
189 }
190 clear_high(d, oprsz, desc);
191}
192
193void HELPER(gvec_subs32)(void *d, void *a, uint64_t b, uint32_t desc)
194{
195 intptr_t oprsz = simd_oprsz(desc);
196 intptr_t i;
197
198 for (i = 0; i < oprsz; i += sizeof(uint32_t)) {
199 *(uint32_t *)(d + i) = *(uint32_t *)(a + i) - (uint32_t)b;
200 }
201 clear_high(d, oprsz, desc);
202}
203
204void HELPER(gvec_subs64)(void *d, void *a, uint64_t b, uint32_t desc)
205{
206 intptr_t oprsz = simd_oprsz(desc);
207 intptr_t i;
208
209 for (i = 0; i < oprsz; i += sizeof(uint64_t)) {
210 *(uint64_t *)(d + i) = *(uint64_t *)(a + i) - b;
211 }
212 clear_high(d, oprsz, desc);
213}
214
215void HELPER(gvec_mul8)(void *d, void *a, void *b, uint32_t desc)
216{
217 intptr_t oprsz = simd_oprsz(desc);
218 intptr_t i;
219
220 for (i = 0; i < oprsz; i += sizeof(uint8_t)) {
221 *(uint8_t *)(d + i) = *(uint8_t *)(a + i) * *(uint8_t *)(b + i);
222 }
223 clear_high(d, oprsz, desc);
224}
225
226void HELPER(gvec_mul16)(void *d, void *a, void *b, uint32_t desc)
227{
228 intptr_t oprsz = simd_oprsz(desc);
229 intptr_t i;
230
231 for (i = 0; i < oprsz; i += sizeof(uint16_t)) {
232 *(uint16_t *)(d + i) = *(uint16_t *)(a + i) * *(uint16_t *)(b + i);
233 }
234 clear_high(d, oprsz, desc);
235}
236
237void HELPER(gvec_mul32)(void *d, void *a, void *b, uint32_t desc)
238{
239 intptr_t oprsz = simd_oprsz(desc);
240 intptr_t i;
241
242 for (i = 0; i < oprsz; i += sizeof(uint32_t)) {
243 *(uint32_t *)(d + i) = *(uint32_t *)(a + i) * *(uint32_t *)(b + i);
244 }
245 clear_high(d, oprsz, desc);
246}
247
248void HELPER(gvec_mul64)(void *d, void *a, void *b, uint32_t desc)
249{
250 intptr_t oprsz = simd_oprsz(desc);
251 intptr_t i;
252
253 for (i = 0; i < oprsz; i += sizeof(uint64_t)) {
254 *(uint64_t *)(d + i) = *(uint64_t *)(a + i) * *(uint64_t *)(b + i);
255 }
256 clear_high(d, oprsz, desc);
257}
258
259void HELPER(gvec_muls8)(void *d, void *a, uint64_t b, uint32_t desc)
260{
261 intptr_t oprsz = simd_oprsz(desc);
262 intptr_t i;
263
264 for (i = 0; i < oprsz; i += sizeof(uint8_t)) {
265 *(uint8_t *)(d + i) = *(uint8_t *)(a + i) * (uint8_t)b;
266 }
267 clear_high(d, oprsz, desc);
268}
269
270void HELPER(gvec_muls16)(void *d, void *a, uint64_t b, uint32_t desc)
271{
272 intptr_t oprsz = simd_oprsz(desc);
273 intptr_t i;
274
275 for (i = 0; i < oprsz; i += sizeof(uint16_t)) {
276 *(uint16_t *)(d + i) = *(uint16_t *)(a + i) * (uint16_t)b;
277 }
278 clear_high(d, oprsz, desc);
279}
280
281void HELPER(gvec_muls32)(void *d, void *a, uint64_t b, uint32_t desc)
282{
283 intptr_t oprsz = simd_oprsz(desc);
284 intptr_t i;
285
286 for (i = 0; i < oprsz; i += sizeof(uint32_t)) {
287 *(uint32_t *)(d + i) = *(uint32_t *)(a + i) * (uint32_t)b;
288 }
289 clear_high(d, oprsz, desc);
290}
291
292void HELPER(gvec_muls64)(void *d, void *a, uint64_t b, uint32_t desc)
293{
294 intptr_t oprsz = simd_oprsz(desc);
295 intptr_t i;
296
297 for (i = 0; i < oprsz; i += sizeof(uint64_t)) {
298 *(uint64_t *)(d + i) = *(uint64_t *)(a + i) * b;
299 }
300 clear_high(d, oprsz, desc);
301}
302
303void HELPER(gvec_neg8)(void *d, void *a, uint32_t desc)
304{
305 intptr_t oprsz = simd_oprsz(desc);
306 intptr_t i;
307
308 for (i = 0; i < oprsz; i += sizeof(uint8_t)) {
309 *(uint8_t *)(d + i) = -*(uint8_t *)(a + i);
310 }
311 clear_high(d, oprsz, desc);
312}
313
314void HELPER(gvec_neg16)(void *d, void *a, uint32_t desc)
315{
316 intptr_t oprsz = simd_oprsz(desc);
317 intptr_t i;
318
319 for (i = 0; i < oprsz; i += sizeof(uint16_t)) {
320 *(uint16_t *)(d + i) = -*(uint16_t *)(a + i);
321 }
322 clear_high(d, oprsz, desc);
323}
324
325void HELPER(gvec_neg32)(void *d, void *a, uint32_t desc)
326{
327 intptr_t oprsz = simd_oprsz(desc);
328 intptr_t i;
329
330 for (i = 0; i < oprsz; i += sizeof(uint32_t)) {
331 *(uint32_t *)(d + i) = -*(uint32_t *)(a + i);
332 }
333 clear_high(d, oprsz, desc);
334}
335
336void HELPER(gvec_neg64)(void *d, void *a, uint32_t desc)
337{
338 intptr_t oprsz = simd_oprsz(desc);
339 intptr_t i;
340
341 for (i = 0; i < oprsz; i += sizeof(uint64_t)) {
342 *(uint64_t *)(d + i) = -*(uint64_t *)(a + i);
343 }
344 clear_high(d, oprsz, desc);
345}
346
347void HELPER(gvec_abs8)(void *d, void *a, uint32_t desc)
348{
349 intptr_t oprsz = simd_oprsz(desc);
350 intptr_t i;
351
352 for (i = 0; i < oprsz; i += sizeof(int8_t)) {
353 int8_t aa = *(int8_t *)(a + i);
354 *(int8_t *)(d + i) = aa < 0 ? -aa : aa;
355 }
356 clear_high(d, oprsz, desc);
357}
358
359void HELPER(gvec_abs16)(void *d, void *a, uint32_t desc)
360{
361 intptr_t oprsz = simd_oprsz(desc);
362 intptr_t i;
363
364 for (i = 0; i < oprsz; i += sizeof(int16_t)) {
365 int16_t aa = *(int16_t *)(a + i);
366 *(int16_t *)(d + i) = aa < 0 ? -aa : aa;
367 }
368 clear_high(d, oprsz, desc);
369}
370
371void HELPER(gvec_abs32)(void *d, void *a, uint32_t desc)
372{
373 intptr_t oprsz = simd_oprsz(desc);
374 intptr_t i;
375
376 for (i = 0; i < oprsz; i += sizeof(int32_t)) {
377 int32_t aa = *(int32_t *)(a + i);
378 *(int32_t *)(d + i) = aa < 0 ? -aa : aa;
379 }
380 clear_high(d, oprsz, desc);
381}
382
383void HELPER(gvec_abs64)(void *d, void *a, uint32_t desc)
384{
385 intptr_t oprsz = simd_oprsz(desc);
386 intptr_t i;
387
388 for (i = 0; i < oprsz; i += sizeof(int64_t)) {
389 int64_t aa = *(int64_t *)(a + i);
390 *(int64_t *)(d + i) = aa < 0 ? -aa : aa;
391 }
392 clear_high(d, oprsz, desc);
393}
394
395void HELPER(gvec_mov)(void *d, void *a, uint32_t desc)
396{
397 intptr_t oprsz = simd_oprsz(desc);
398
399 memcpy(d, a, oprsz);
400 clear_high(d, oprsz, desc);
401}
402
403void HELPER(gvec_dup64)(void *d, uint32_t desc, uint64_t c)
404{
405 intptr_t oprsz = simd_oprsz(desc);
406 intptr_t i;
407
408 if (c == 0) {
409 oprsz = 0;
410 } else {
411 for (i = 0; i < oprsz; i += sizeof(uint64_t)) {
412 *(uint64_t *)(d + i) = c;
413 }
414 }
415 clear_high(d, oprsz, desc);
416}
417
418void HELPER(gvec_dup32)(void *d, uint32_t desc, uint32_t c)
419{
420 intptr_t oprsz = simd_oprsz(desc);
421 intptr_t i;
422
423 if (c == 0) {
424 oprsz = 0;
425 } else {
426 for (i = 0; i < oprsz; i += sizeof(uint32_t)) {
427 *(uint32_t *)(d + i) = c;
428 }
429 }
430 clear_high(d, oprsz, desc);
431}
432
433void HELPER(gvec_dup16)(void *d, uint32_t desc, uint32_t c)
434{
435 HELPER(gvec_dup32)(d, desc, 0x00010001 * (c & 0xffff));
436}
437
438void HELPER(gvec_dup8)(void *d, uint32_t desc, uint32_t c)
439{
440 HELPER(gvec_dup32)(d, desc, 0x01010101 * (c & 0xff));
441}
442
443void HELPER(gvec_not)(void *d, void *a, uint32_t desc)
444{
445 intptr_t oprsz = simd_oprsz(desc);
446 intptr_t i;
447
448 for (i = 0; i < oprsz; i += sizeof(uint64_t)) {
449 *(uint64_t *)(d + i) = ~*(uint64_t *)(a + i);
450 }
451 clear_high(d, oprsz, desc);
452}
453
454void HELPER(gvec_and)(void *d, void *a, void *b, uint32_t desc)
455{
456 intptr_t oprsz = simd_oprsz(desc);
457 intptr_t i;
458
459 for (i = 0; i < oprsz; i += sizeof(uint64_t)) {
460 *(uint64_t *)(d + i) = *(uint64_t *)(a + i) & *(uint64_t *)(b + i);
461 }
462 clear_high(d, oprsz, desc);
463}
464
465void HELPER(gvec_or)(void *d, void *a, void *b, uint32_t desc)
466{
467 intptr_t oprsz = simd_oprsz(desc);
468 intptr_t i;
469
470 for (i = 0; i < oprsz; i += sizeof(uint64_t)) {
471 *(uint64_t *)(d + i) = *(uint64_t *)(a + i) | *(uint64_t *)(b + i);
472 }
473 clear_high(d, oprsz, desc);
474}
475
476void HELPER(gvec_xor)(void *d, void *a, void *b, uint32_t desc)
477{
478 intptr_t oprsz = simd_oprsz(desc);
479 intptr_t i;
480
481 for (i = 0; i < oprsz; i += sizeof(uint64_t)) {
482 *(uint64_t *)(d + i) = *(uint64_t *)(a + i) ^ *(uint64_t *)(b + i);
483 }
484 clear_high(d, oprsz, desc);
485}
486
487void HELPER(gvec_andc)(void *d, void *a, void *b, uint32_t desc)
488{
489 intptr_t oprsz = simd_oprsz(desc);
490 intptr_t i;
491
492 for (i = 0; i < oprsz; i += sizeof(uint64_t)) {
493 *(uint64_t *)(d + i) = *(uint64_t *)(a + i) &~ *(uint64_t *)(b + i);
494 }
495 clear_high(d, oprsz, desc);
496}
497
498void HELPER(gvec_orc)(void *d, void *a, void *b, uint32_t desc)
499{
500 intptr_t oprsz = simd_oprsz(desc);
501 intptr_t i;
502
503 for (i = 0; i < oprsz; i += sizeof(uint64_t)) {
504 *(uint64_t *)(d + i) = *(uint64_t *)(a + i) |~ *(uint64_t *)(b + i);
505 }
506 clear_high(d, oprsz, desc);
507}
508
509void HELPER(gvec_nand)(void *d, void *a, void *b, uint32_t desc)
510{
511 intptr_t oprsz = simd_oprsz(desc);
512 intptr_t i;
513
514 for (i = 0; i < oprsz; i += sizeof(uint64_t)) {
515 *(uint64_t *)(d + i) = ~(*(uint64_t *)(a + i) & *(uint64_t *)(b + i));
516 }
517 clear_high(d, oprsz, desc);
518}
519
520void HELPER(gvec_nor)(void *d, void *a, void *b, uint32_t desc)
521{
522 intptr_t oprsz = simd_oprsz(desc);
523 intptr_t i;
524
525 for (i = 0; i < oprsz; i += sizeof(uint64_t)) {
526 *(uint64_t *)(d + i) = ~(*(uint64_t *)(a + i) | *(uint64_t *)(b + i));
527 }
528 clear_high(d, oprsz, desc);
529}
530
531void HELPER(gvec_eqv)(void *d, void *a, void *b, uint32_t desc)
532{
533 intptr_t oprsz = simd_oprsz(desc);
534 intptr_t i;
535
536 for (i = 0; i < oprsz; i += sizeof(uint64_t)) {
537 *(uint64_t *)(d + i) = ~(*(uint64_t *)(a + i) ^ *(uint64_t *)(b + i));
538 }
539 clear_high(d, oprsz, desc);
540}
541
542void HELPER(gvec_ands)(void *d, void *a, uint64_t b, uint32_t desc)
543{
544 intptr_t oprsz = simd_oprsz(desc);
545 intptr_t i;
546
547 for (i = 0; i < oprsz; i += sizeof(uint64_t)) {
548 *(uint64_t *)(d + i) = *(uint64_t *)(a + i) & b;
549 }
550 clear_high(d, oprsz, desc);
551}
552
553void HELPER(gvec_xors)(void *d, void *a, uint64_t b, uint32_t desc)
554{
555 intptr_t oprsz = simd_oprsz(desc);
556 intptr_t i;
557
558 for (i = 0; i < oprsz; i += sizeof(uint64_t)) {
559 *(uint64_t *)(d + i) = *(uint64_t *)(a + i) ^ b;
560 }
561 clear_high(d, oprsz, desc);
562}
563
564void HELPER(gvec_ors)(void *d, void *a, uint64_t b, uint32_t desc)
565{
566 intptr_t oprsz = simd_oprsz(desc);
567 intptr_t i;
568
569 for (i = 0; i < oprsz; i += sizeof(uint64_t)) {
570 *(uint64_t *)(d + i) = *(uint64_t *)(a + i) | b;
571 }
572 clear_high(d, oprsz, desc);
573}
574
575void HELPER(gvec_shl8i)(void *d, void *a, uint32_t desc)
576{
577 intptr_t oprsz = simd_oprsz(desc);
578 int shift = simd_data(desc);
579 intptr_t i;
580
581 for (i = 0; i < oprsz; i += sizeof(uint8_t)) {
582 *(uint8_t *)(d + i) = *(uint8_t *)(a + i) << shift;
583 }
584 clear_high(d, oprsz, desc);
585}
586
587void HELPER(gvec_shl16i)(void *d, void *a, uint32_t desc)
588{
589 intptr_t oprsz = simd_oprsz(desc);
590 int shift = simd_data(desc);
591 intptr_t i;
592
593 for (i = 0; i < oprsz; i += sizeof(uint16_t)) {
594 *(uint16_t *)(d + i) = *(uint16_t *)(a + i) << shift;
595 }
596 clear_high(d, oprsz, desc);
597}
598
599void HELPER(gvec_shl32i)(void *d, void *a, uint32_t desc)
600{
601 intptr_t oprsz = simd_oprsz(desc);
602 int shift = simd_data(desc);
603 intptr_t i;
604
605 for (i = 0; i < oprsz; i += sizeof(uint32_t)) {
606 *(uint32_t *)(d + i) = *(uint32_t *)(a + i) << shift;
607 }
608 clear_high(d, oprsz, desc);
609}
610
611void HELPER(gvec_shl64i)(void *d, void *a, uint32_t desc)
612{
613 intptr_t oprsz = simd_oprsz(desc);
614 int shift = simd_data(desc);
615 intptr_t i;
616
617 for (i = 0; i < oprsz; i += sizeof(uint64_t)) {
618 *(uint64_t *)(d + i) = *(uint64_t *)(a + i) << shift;
619 }
620 clear_high(d, oprsz, desc);
621}
622
623void HELPER(gvec_shr8i)(void *d, void *a, uint32_t desc)
624{
625 intptr_t oprsz = simd_oprsz(desc);
626 int shift = simd_data(desc);
627 intptr_t i;
628
629 for (i = 0; i < oprsz; i += sizeof(uint8_t)) {
630 *(uint8_t *)(d + i) = *(uint8_t *)(a + i) >> shift;
631 }
632 clear_high(d, oprsz, desc);
633}
634
635void HELPER(gvec_shr16i)(void *d, void *a, uint32_t desc)
636{
637 intptr_t oprsz = simd_oprsz(desc);
638 int shift = simd_data(desc);
639 intptr_t i;
640
641 for (i = 0; i < oprsz; i += sizeof(uint16_t)) {
642 *(uint16_t *)(d + i) = *(uint16_t *)(a + i) >> shift;
643 }
644 clear_high(d, oprsz, desc);
645}
646
647void HELPER(gvec_shr32i)(void *d, void *a, uint32_t desc)
648{
649 intptr_t oprsz = simd_oprsz(desc);
650 int shift = simd_data(desc);
651 intptr_t i;
652
653 for (i = 0; i < oprsz; i += sizeof(uint32_t)) {
654 *(uint32_t *)(d + i) = *(uint32_t *)(a + i) >> shift;
655 }
656 clear_high(d, oprsz, desc);
657}
658
659void HELPER(gvec_shr64i)(void *d, void *a, uint32_t desc)
660{
661 intptr_t oprsz = simd_oprsz(desc);
662 int shift = simd_data(desc);
663 intptr_t i;
664
665 for (i = 0; i < oprsz; i += sizeof(uint64_t)) {
666 *(uint64_t *)(d + i) = *(uint64_t *)(a + i) >> shift;
667 }
668 clear_high(d, oprsz, desc);
669}
670
671void HELPER(gvec_sar8i)(void *d, void *a, uint32_t desc)
672{
673 intptr_t oprsz = simd_oprsz(desc);
674 int shift = simd_data(desc);
675 intptr_t i;
676
677 for (i = 0; i < oprsz; i += sizeof(uint8_t)) {
678 *(int8_t *)(d + i) = *(int8_t *)(a + i) >> shift;
679 }
680 clear_high(d, oprsz, desc);
681}
682
683void HELPER(gvec_sar16i)(void *d, void *a, uint32_t desc)
684{
685 intptr_t oprsz = simd_oprsz(desc);
686 int shift = simd_data(desc);
687 intptr_t i;
688
689 for (i = 0; i < oprsz; i += sizeof(uint16_t)) {
690 *(int16_t *)(d + i) = *(int16_t *)(a + i) >> shift;
691 }
692 clear_high(d, oprsz, desc);
693}
694
695void HELPER(gvec_sar32i)(void *d, void *a, uint32_t desc)
696{
697 intptr_t oprsz = simd_oprsz(desc);
698 int shift = simd_data(desc);
699 intptr_t i;
700
701 for (i = 0; i < oprsz; i += sizeof(uint32_t)) {
702 *(int32_t *)(d + i) = *(int32_t *)(a + i) >> shift;
703 }
704 clear_high(d, oprsz, desc);
705}
706
707void HELPER(gvec_sar64i)(void *d, void *a, uint32_t desc)
708{
709 intptr_t oprsz = simd_oprsz(desc);
710 int shift = simd_data(desc);
711 intptr_t i;
712
713 for (i = 0; i < oprsz; i += sizeof(uint64_t)) {
714 *(int64_t *)(d + i) = *(int64_t *)(a + i) >> shift;
715 }
716 clear_high(d, oprsz, desc);
717}
718
719void HELPER(gvec_rotl8i)(void *d, void *a, uint32_t desc)
720{
721 intptr_t oprsz = simd_oprsz(desc);
722 int shift = simd_data(desc);
723 intptr_t i;
724
725 for (i = 0; i < oprsz; i += sizeof(uint8_t)) {
726 *(uint8_t *)(d + i) = rol8(*(uint8_t *)(a + i), shift);
727 }
728 clear_high(d, oprsz, desc);
729}
730
731void HELPER(gvec_rotl16i)(void *d, void *a, uint32_t desc)
732{
733 intptr_t oprsz = simd_oprsz(desc);
734 int shift = simd_data(desc);
735 intptr_t i;
736
737 for (i = 0; i < oprsz; i += sizeof(uint16_t)) {
738 *(uint16_t *)(d + i) = rol16(*(uint16_t *)(a + i), shift);
739 }
740 clear_high(d, oprsz, desc);
741}
742
743void HELPER(gvec_rotl32i)(void *d, void *a, uint32_t desc)
744{
745 intptr_t oprsz = simd_oprsz(desc);
746 int shift = simd_data(desc);
747 intptr_t i;
748
749 for (i = 0; i < oprsz; i += sizeof(uint32_t)) {
750 *(uint32_t *)(d + i) = rol32(*(uint32_t *)(a + i), shift);
751 }
752 clear_high(d, oprsz, desc);
753}
754
755void HELPER(gvec_rotl64i)(void *d, void *a, uint32_t desc)
756{
757 intptr_t oprsz = simd_oprsz(desc);
758 int shift = simd_data(desc);
759 intptr_t i;
760
761 for (i = 0; i < oprsz; i += sizeof(uint64_t)) {
762 *(uint64_t *)(d + i) = rol64(*(uint64_t *)(a + i), shift);
763 }
764 clear_high(d, oprsz, desc);
765}
766
767void HELPER(gvec_shl8v)(void *d, void *a, void *b, uint32_t desc)
768{
769 intptr_t oprsz = simd_oprsz(desc);
770 intptr_t i;
771
772 for (i = 0; i < oprsz; i += sizeof(uint8_t)) {
773 uint8_t sh = *(uint8_t *)(b + i) & 7;
774 *(uint8_t *)(d + i) = *(uint8_t *)(a + i) << sh;
775 }
776 clear_high(d, oprsz, desc);
777}
778
779void HELPER(gvec_shl16v)(void *d, void *a, void *b, uint32_t desc)
780{
781 intptr_t oprsz = simd_oprsz(desc);
782 intptr_t i;
783
784 for (i = 0; i < oprsz; i += sizeof(uint16_t)) {
785 uint8_t sh = *(uint16_t *)(b + i) & 15;
786 *(uint16_t *)(d + i) = *(uint16_t *)(a + i) << sh;
787 }
788 clear_high(d, oprsz, desc);
789}
790
791void HELPER(gvec_shl32v)(void *d, void *a, void *b, uint32_t desc)
792{
793 intptr_t oprsz = simd_oprsz(desc);
794 intptr_t i;
795
796 for (i = 0; i < oprsz; i += sizeof(uint32_t)) {
797 uint8_t sh = *(uint32_t *)(b + i) & 31;
798 *(uint32_t *)(d + i) = *(uint32_t *)(a + i) << sh;
799 }
800 clear_high(d, oprsz, desc);
801}
802
803void HELPER(gvec_shl64v)(void *d, void *a, void *b, uint32_t desc)
804{
805 intptr_t oprsz = simd_oprsz(desc);
806 intptr_t i;
807
808 for (i = 0; i < oprsz; i += sizeof(uint64_t)) {
809 uint8_t sh = *(uint64_t *)(b + i) & 63;
810 *(uint64_t *)(d + i) = *(uint64_t *)(a + i) << sh;
811 }
812 clear_high(d, oprsz, desc);
813}
814
815void HELPER(gvec_shr8v)(void *d, void *a, void *b, uint32_t desc)
816{
817 intptr_t oprsz = simd_oprsz(desc);
818 intptr_t i;
819
820 for (i = 0; i < oprsz; i += sizeof(uint8_t)) {
821 uint8_t sh = *(uint8_t *)(b + i) & 7;
822 *(uint8_t *)(d + i) = *(uint8_t *)(a + i) >> sh;
823 }
824 clear_high(d, oprsz, desc);
825}
826
827void HELPER(gvec_shr16v)(void *d, void *a, void *b, uint32_t desc)
828{
829 intptr_t oprsz = simd_oprsz(desc);
830 intptr_t i;
831
832 for (i = 0; i < oprsz; i += sizeof(uint16_t)) {
833 uint8_t sh = *(uint16_t *)(b + i) & 15;
834 *(uint16_t *)(d + i) = *(uint16_t *)(a + i) >> sh;
835 }
836 clear_high(d, oprsz, desc);
837}
838
839void HELPER(gvec_shr32v)(void *d, void *a, void *b, uint32_t desc)
840{
841 intptr_t oprsz = simd_oprsz(desc);
842 intptr_t i;
843
844 for (i = 0; i < oprsz; i += sizeof(uint32_t)) {
845 uint8_t sh = *(uint32_t *)(b + i) & 31;
846 *(uint32_t *)(d + i) = *(uint32_t *)(a + i) >> sh;
847 }
848 clear_high(d, oprsz, desc);
849}
850
851void HELPER(gvec_shr64v)(void *d, void *a, void *b, uint32_t desc)
852{
853 intptr_t oprsz = simd_oprsz(desc);
854 intptr_t i;
855
856 for (i = 0; i < oprsz; i += sizeof(uint64_t)) {
857 uint8_t sh = *(uint64_t *)(b + i) & 63;
858 *(uint64_t *)(d + i) = *(uint64_t *)(a + i) >> sh;
859 }
860 clear_high(d, oprsz, desc);
861}
862
863void HELPER(gvec_sar8v)(void *d, void *a, void *b, uint32_t desc)
864{
865 intptr_t oprsz = simd_oprsz(desc);
866 intptr_t i;
867
868 for (i = 0; i < oprsz; i += sizeof(int8_t)) {
869 uint8_t sh = *(uint8_t *)(b + i) & 7;
870 *(int8_t *)(d + i) = *(int8_t *)(a + i) >> sh;
871 }
872 clear_high(d, oprsz, desc);
873}
874
875void HELPER(gvec_sar16v)(void *d, void *a, void *b, uint32_t desc)
876{
877 intptr_t oprsz = simd_oprsz(desc);
878 intptr_t i;
879
880 for (i = 0; i < oprsz; i += sizeof(int16_t)) {
881 uint8_t sh = *(uint16_t *)(b + i) & 15;
882 *(int16_t *)(d + i) = *(int16_t *)(a + i) >> sh;
883 }
884 clear_high(d, oprsz, desc);
885}
886
887void HELPER(gvec_sar32v)(void *d, void *a, void *b, uint32_t desc)
888{
889 intptr_t oprsz = simd_oprsz(desc);
890 intptr_t i;
891
892 for (i = 0; i < oprsz; i += sizeof(int32_t)) {
893 uint8_t sh = *(uint32_t *)(b + i) & 31;
894 *(int32_t *)(d + i) = *(int32_t *)(a + i) >> sh;
895 }
896 clear_high(d, oprsz, desc);
897}
898
899void HELPER(gvec_sar64v)(void *d, void *a, void *b, uint32_t desc)
900{
901 intptr_t oprsz = simd_oprsz(desc);
902 intptr_t i;
903
904 for (i = 0; i < oprsz; i += sizeof(int64_t)) {
905 uint8_t sh = *(uint64_t *)(b + i) & 63;
906 *(int64_t *)(d + i) = *(int64_t *)(a + i) >> sh;
907 }
908 clear_high(d, oprsz, desc);
909}
910
911void HELPER(gvec_rotl8v)(void *d, void *a, void *b, uint32_t desc)
912{
913 intptr_t oprsz = simd_oprsz(desc);
914 intptr_t i;
915
916 for (i = 0; i < oprsz; i += sizeof(uint8_t)) {
917 uint8_t sh = *(uint8_t *)(b + i) & 7;
918 *(uint8_t *)(d + i) = rol8(*(uint8_t *)(a + i), sh);
919 }
920 clear_high(d, oprsz, desc);
921}
922
923void HELPER(gvec_rotl16v)(void *d, void *a, void *b, uint32_t desc)
924{
925 intptr_t oprsz = simd_oprsz(desc);
926 intptr_t i;
927
928 for (i = 0; i < oprsz; i += sizeof(uint16_t)) {
929 uint8_t sh = *(uint16_t *)(b + i) & 15;
930 *(uint16_t *)(d + i) = rol16(*(uint16_t *)(a + i), sh);
931 }
932 clear_high(d, oprsz, desc);
933}
934
935void HELPER(gvec_rotl32v)(void *d, void *a, void *b, uint32_t desc)
936{
937 intptr_t oprsz = simd_oprsz(desc);
938 intptr_t i;
939
940 for (i = 0; i < oprsz; i += sizeof(uint32_t)) {
941 uint8_t sh = *(uint32_t *)(b + i) & 31;
942 *(uint32_t *)(d + i) = rol32(*(uint32_t *)(a + i), sh);
943 }
944 clear_high(d, oprsz, desc);
945}
946
947void HELPER(gvec_rotl64v)(void *d, void *a, void *b, uint32_t desc)
948{
949 intptr_t oprsz = simd_oprsz(desc);
950 intptr_t i;
951
952 for (i = 0; i < oprsz; i += sizeof(uint64_t)) {
953 uint8_t sh = *(uint64_t *)(b + i) & 63;
954 *(uint64_t *)(d + i) = rol64(*(uint64_t *)(a + i), sh);
955 }
956 clear_high(d, oprsz, desc);
957}
958
959void HELPER(gvec_rotr8v)(void *d, void *a, void *b, uint32_t desc)
960{
961 intptr_t oprsz = simd_oprsz(desc);
962 intptr_t i;
963
964 for (i = 0; i < oprsz; i += sizeof(uint8_t)) {
965 uint8_t sh = *(uint8_t *)(b + i) & 7;
966 *(uint8_t *)(d + i) = ror8(*(uint8_t *)(a + i), sh);
967 }
968 clear_high(d, oprsz, desc);
969}
970
971void HELPER(gvec_rotr16v)(void *d, void *a, void *b, uint32_t desc)
972{
973 intptr_t oprsz = simd_oprsz(desc);
974 intptr_t i;
975
976 for (i = 0; i < oprsz; i += sizeof(uint16_t)) {
977 uint8_t sh = *(uint16_t *)(b + i) & 15;
978 *(uint16_t *)(d + i) = ror16(*(uint16_t *)(a + i), sh);
979 }
980 clear_high(d, oprsz, desc);
981}
982
983void HELPER(gvec_rotr32v)(void *d, void *a, void *b, uint32_t desc)
984{
985 intptr_t oprsz = simd_oprsz(desc);
986 intptr_t i;
987
988 for (i = 0; i < oprsz; i += sizeof(uint32_t)) {
989 uint8_t sh = *(uint32_t *)(b + i) & 31;
990 *(uint32_t *)(d + i) = ror32(*(uint32_t *)(a + i), sh);
991 }
992 clear_high(d, oprsz, desc);
993}
994
995void HELPER(gvec_rotr64v)(void *d, void *a, void *b, uint32_t desc)
996{
997 intptr_t oprsz = simd_oprsz(desc);
998 intptr_t i;
999
1000 for (i = 0; i < oprsz; i += sizeof(uint64_t)) {
1001 uint8_t sh = *(uint64_t *)(b + i) & 63;
1002 *(uint64_t *)(d + i) = ror64(*(uint64_t *)(a + i), sh);
1003 }
1004 clear_high(d, oprsz, desc);
1005}
1006
1007#define DO_CMP1(NAME, TYPE, OP) \
1008void HELPER(NAME)(void *d, void *a, void *b, uint32_t desc) \
1009{ \
1010 intptr_t oprsz = simd_oprsz(desc); \
1011 intptr_t i; \
1012 for (i = 0; i < oprsz; i += sizeof(TYPE)) { \
1013 *(TYPE *)(d + i) = -(*(TYPE *)(a + i) OP *(TYPE *)(b + i)); \
1014 } \
1015 clear_high(d, oprsz, desc); \
1016}
1017
1018#define DO_CMP2(SZ) \
1019 DO_CMP1(gvec_eq##SZ, uint##SZ##_t, ==) \
1020 DO_CMP1(gvec_ne##SZ, uint##SZ##_t, !=) \
1021 DO_CMP1(gvec_lt##SZ, int##SZ##_t, <) \
1022 DO_CMP1(gvec_le##SZ, int##SZ##_t, <=) \
1023 DO_CMP1(gvec_ltu##SZ, uint##SZ##_t, <) \
1024 DO_CMP1(gvec_leu##SZ, uint##SZ##_t, <=)
1025
1026DO_CMP2(8)
1027DO_CMP2(16)
1028DO_CMP2(32)
1029DO_CMP2(64)
1030
1031#undef DO_CMP1
1032#undef DO_CMP2
1033
1034void HELPER(gvec_ssadd8)(void *d, void *a, void *b, uint32_t desc)
1035{
1036 intptr_t oprsz = simd_oprsz(desc);
1037 intptr_t i;
1038
1039 for (i = 0; i < oprsz; i += sizeof(int8_t)) {
1040 int r = *(int8_t *)(a + i) + *(int8_t *)(b + i);
1041 if (r > INT8_MAX) {
1042 r = INT8_MAX;
1043 } else if (r < INT8_MIN) {
1044 r = INT8_MIN;
1045 }
1046 *(int8_t *)(d + i) = r;
1047 }
1048 clear_high(d, oprsz, desc);
1049}
1050
1051void HELPER(gvec_ssadd16)(void *d, void *a, void *b, uint32_t desc)
1052{
1053 intptr_t oprsz = simd_oprsz(desc);
1054 intptr_t i;
1055
1056 for (i = 0; i < oprsz; i += sizeof(int16_t)) {
1057 int r = *(int16_t *)(a + i) + *(int16_t *)(b + i);
1058 if (r > INT16_MAX) {
1059 r = INT16_MAX;
1060 } else if (r < INT16_MIN) {
1061 r = INT16_MIN;
1062 }
1063 *(int16_t *)(d + i) = r;
1064 }
1065 clear_high(d, oprsz, desc);
1066}
1067
1068void HELPER(gvec_ssadd32)(void *d, void *a, void *b, uint32_t desc)
1069{
1070 intptr_t oprsz = simd_oprsz(desc);
1071 intptr_t i;
1072
1073 for (i = 0; i < oprsz; i += sizeof(int32_t)) {
1074 int32_t ai = *(int32_t *)(a + i);
1075 int32_t bi = *(int32_t *)(b + i);
1076 int32_t di = ai + bi;
1077 if (((di ^ ai) &~ (ai ^ bi)) < 0) {
1078
1079 di = (di < 0 ? INT32_MAX : INT32_MIN);
1080 }
1081 *(int32_t *)(d + i) = di;
1082 }
1083 clear_high(d, oprsz, desc);
1084}
1085
1086void HELPER(gvec_ssadd64)(void *d, void *a, void *b, uint32_t desc)
1087{
1088 intptr_t oprsz = simd_oprsz(desc);
1089 intptr_t i;
1090
1091 for (i = 0; i < oprsz; i += sizeof(int64_t)) {
1092 int64_t ai = *(int64_t *)(a + i);
1093 int64_t bi = *(int64_t *)(b + i);
1094 int64_t di = ai + bi;
1095 if (((di ^ ai) &~ (ai ^ bi)) < 0) {
1096
1097 di = (di < 0 ? INT64_MAX : INT64_MIN);
1098 }
1099 *(int64_t *)(d + i) = di;
1100 }
1101 clear_high(d, oprsz, desc);
1102}
1103
1104void HELPER(gvec_sssub8)(void *d, void *a, void *b, uint32_t desc)
1105{
1106 intptr_t oprsz = simd_oprsz(desc);
1107 intptr_t i;
1108
1109 for (i = 0; i < oprsz; i += sizeof(uint8_t)) {
1110 int r = *(int8_t *)(a + i) - *(int8_t *)(b + i);
1111 if (r > INT8_MAX) {
1112 r = INT8_MAX;
1113 } else if (r < INT8_MIN) {
1114 r = INT8_MIN;
1115 }
1116 *(uint8_t *)(d + i) = r;
1117 }
1118 clear_high(d, oprsz, desc);
1119}
1120
1121void HELPER(gvec_sssub16)(void *d, void *a, void *b, uint32_t desc)
1122{
1123 intptr_t oprsz = simd_oprsz(desc);
1124 intptr_t i;
1125
1126 for (i = 0; i < oprsz; i += sizeof(int16_t)) {
1127 int r = *(int16_t *)(a + i) - *(int16_t *)(b + i);
1128 if (r > INT16_MAX) {
1129 r = INT16_MAX;
1130 } else if (r < INT16_MIN) {
1131 r = INT16_MIN;
1132 }
1133 *(int16_t *)(d + i) = r;
1134 }
1135 clear_high(d, oprsz, desc);
1136}
1137
1138void HELPER(gvec_sssub32)(void *d, void *a, void *b, uint32_t desc)
1139{
1140 intptr_t oprsz = simd_oprsz(desc);
1141 intptr_t i;
1142
1143 for (i = 0; i < oprsz; i += sizeof(int32_t)) {
1144 int32_t ai = *(int32_t *)(a + i);
1145 int32_t bi = *(int32_t *)(b + i);
1146 int32_t di = ai - bi;
1147 if (((di ^ ai) & (ai ^ bi)) < 0) {
1148
1149 di = (di < 0 ? INT32_MAX : INT32_MIN);
1150 }
1151 *(int32_t *)(d + i) = di;
1152 }
1153 clear_high(d, oprsz, desc);
1154}
1155
1156void HELPER(gvec_sssub64)(void *d, void *a, void *b, uint32_t desc)
1157{
1158 intptr_t oprsz = simd_oprsz(desc);
1159 intptr_t i;
1160
1161 for (i = 0; i < oprsz; i += sizeof(int64_t)) {
1162 int64_t ai = *(int64_t *)(a + i);
1163 int64_t bi = *(int64_t *)(b + i);
1164 int64_t di = ai - bi;
1165 if (((di ^ ai) & (ai ^ bi)) < 0) {
1166
1167 di = (di < 0 ? INT64_MAX : INT64_MIN);
1168 }
1169 *(int64_t *)(d + i) = di;
1170 }
1171 clear_high(d, oprsz, desc);
1172}
1173
1174void HELPER(gvec_usadd8)(void *d, void *a, void *b, uint32_t desc)
1175{
1176 intptr_t oprsz = simd_oprsz(desc);
1177 intptr_t i;
1178
1179 for (i = 0; i < oprsz; i += sizeof(uint8_t)) {
1180 unsigned r = *(uint8_t *)(a + i) + *(uint8_t *)(b + i);
1181 if (r > UINT8_MAX) {
1182 r = UINT8_MAX;
1183 }
1184 *(uint8_t *)(d + i) = r;
1185 }
1186 clear_high(d, oprsz, desc);
1187}
1188
1189void HELPER(gvec_usadd16)(void *d, void *a, void *b, uint32_t desc)
1190{
1191 intptr_t oprsz = simd_oprsz(desc);
1192 intptr_t i;
1193
1194 for (i = 0; i < oprsz; i += sizeof(uint16_t)) {
1195 unsigned r = *(uint16_t *)(a + i) + *(uint16_t *)(b + i);
1196 if (r > UINT16_MAX) {
1197 r = UINT16_MAX;
1198 }
1199 *(uint16_t *)(d + i) = r;
1200 }
1201 clear_high(d, oprsz, desc);
1202}
1203
1204void HELPER(gvec_usadd32)(void *d, void *a, void *b, uint32_t desc)
1205{
1206 intptr_t oprsz = simd_oprsz(desc);
1207 intptr_t i;
1208
1209 for (i = 0; i < oprsz; i += sizeof(uint32_t)) {
1210 uint32_t ai = *(uint32_t *)(a + i);
1211 uint32_t bi = *(uint32_t *)(b + i);
1212 uint32_t di = ai + bi;
1213 if (di < ai) {
1214 di = UINT32_MAX;
1215 }
1216 *(uint32_t *)(d + i) = di;
1217 }
1218 clear_high(d, oprsz, desc);
1219}
1220
1221void HELPER(gvec_usadd64)(void *d, void *a, void *b, uint32_t desc)
1222{
1223 intptr_t oprsz = simd_oprsz(desc);
1224 intptr_t i;
1225
1226 for (i = 0; i < oprsz; i += sizeof(uint64_t)) {
1227 uint64_t ai = *(uint64_t *)(a + i);
1228 uint64_t bi = *(uint64_t *)(b + i);
1229 uint64_t di = ai + bi;
1230 if (di < ai) {
1231 di = UINT64_MAX;
1232 }
1233 *(uint64_t *)(d + i) = di;
1234 }
1235 clear_high(d, oprsz, desc);
1236}
1237
1238void HELPER(gvec_ussub8)(void *d, void *a, void *b, uint32_t desc)
1239{
1240 intptr_t oprsz = simd_oprsz(desc);
1241 intptr_t i;
1242
1243 for (i = 0; i < oprsz; i += sizeof(uint8_t)) {
1244 int r = *(uint8_t *)(a + i) - *(uint8_t *)(b + i);
1245 if (r < 0) {
1246 r = 0;
1247 }
1248 *(uint8_t *)(d + i) = r;
1249 }
1250 clear_high(d, oprsz, desc);
1251}
1252
1253void HELPER(gvec_ussub16)(void *d, void *a, void *b, uint32_t desc)
1254{
1255 intptr_t oprsz = simd_oprsz(desc);
1256 intptr_t i;
1257
1258 for (i = 0; i < oprsz; i += sizeof(uint16_t)) {
1259 int r = *(uint16_t *)(a + i) - *(uint16_t *)(b + i);
1260 if (r < 0) {
1261 r = 0;
1262 }
1263 *(uint16_t *)(d + i) = r;
1264 }
1265 clear_high(d, oprsz, desc);
1266}
1267
1268void HELPER(gvec_ussub32)(void *d, void *a, void *b, uint32_t desc)
1269{
1270 intptr_t oprsz = simd_oprsz(desc);
1271 intptr_t i;
1272
1273 for (i = 0; i < oprsz; i += sizeof(uint32_t)) {
1274 uint32_t ai = *(uint32_t *)(a + i);
1275 uint32_t bi = *(uint32_t *)(b + i);
1276 uint32_t di = ai - bi;
1277 if (ai < bi) {
1278 di = 0;
1279 }
1280 *(uint32_t *)(d + i) = di;
1281 }
1282 clear_high(d, oprsz, desc);
1283}
1284
1285void HELPER(gvec_ussub64)(void *d, void *a, void *b, uint32_t desc)
1286{
1287 intptr_t oprsz = simd_oprsz(desc);
1288 intptr_t i;
1289
1290 for (i = 0; i < oprsz; i += sizeof(uint64_t)) {
1291 uint64_t ai = *(uint64_t *)(a + i);
1292 uint64_t bi = *(uint64_t *)(b + i);
1293 uint64_t di = ai - bi;
1294 if (ai < bi) {
1295 di = 0;
1296 }
1297 *(uint64_t *)(d + i) = di;
1298 }
1299 clear_high(d, oprsz, desc);
1300}
1301
1302void HELPER(gvec_smin8)(void *d, void *a, void *b, uint32_t desc)
1303{
1304 intptr_t oprsz = simd_oprsz(desc);
1305 intptr_t i;
1306
1307 for (i = 0; i < oprsz; i += sizeof(int8_t)) {
1308 int8_t aa = *(int8_t *)(a + i);
1309 int8_t bb = *(int8_t *)(b + i);
1310 int8_t dd = aa < bb ? aa : bb;
1311 *(int8_t *)(d + i) = dd;
1312 }
1313 clear_high(d, oprsz, desc);
1314}
1315
1316void HELPER(gvec_smin16)(void *d, void *a, void *b, uint32_t desc)
1317{
1318 intptr_t oprsz = simd_oprsz(desc);
1319 intptr_t i;
1320
1321 for (i = 0; i < oprsz; i += sizeof(int16_t)) {
1322 int16_t aa = *(int16_t *)(a + i);
1323 int16_t bb = *(int16_t *)(b + i);
1324 int16_t dd = aa < bb ? aa : bb;
1325 *(int16_t *)(d + i) = dd;
1326 }
1327 clear_high(d, oprsz, desc);
1328}
1329
1330void HELPER(gvec_smin32)(void *d, void *a, void *b, uint32_t desc)
1331{
1332 intptr_t oprsz = simd_oprsz(desc);
1333 intptr_t i;
1334
1335 for (i = 0; i < oprsz; i += sizeof(int32_t)) {
1336 int32_t aa = *(int32_t *)(a + i);
1337 int32_t bb = *(int32_t *)(b + i);
1338 int32_t dd = aa < bb ? aa : bb;
1339 *(int32_t *)(d + i) = dd;
1340 }
1341 clear_high(d, oprsz, desc);
1342}
1343
1344void HELPER(gvec_smin64)(void *d, void *a, void *b, uint32_t desc)
1345{
1346 intptr_t oprsz = simd_oprsz(desc);
1347 intptr_t i;
1348
1349 for (i = 0; i < oprsz; i += sizeof(int64_t)) {
1350 int64_t aa = *(int64_t *)(a + i);
1351 int64_t bb = *(int64_t *)(b + i);
1352 int64_t dd = aa < bb ? aa : bb;
1353 *(int64_t *)(d + i) = dd;
1354 }
1355 clear_high(d, oprsz, desc);
1356}
1357
1358void HELPER(gvec_smax8)(void *d, void *a, void *b, uint32_t desc)
1359{
1360 intptr_t oprsz = simd_oprsz(desc);
1361 intptr_t i;
1362
1363 for (i = 0; i < oprsz; i += sizeof(int8_t)) {
1364 int8_t aa = *(int8_t *)(a + i);
1365 int8_t bb = *(int8_t *)(b + i);
1366 int8_t dd = aa > bb ? aa : bb;
1367 *(int8_t *)(d + i) = dd;
1368 }
1369 clear_high(d, oprsz, desc);
1370}
1371
1372void HELPER(gvec_smax16)(void *d, void *a, void *b, uint32_t desc)
1373{
1374 intptr_t oprsz = simd_oprsz(desc);
1375 intptr_t i;
1376
1377 for (i = 0; i < oprsz; i += sizeof(int16_t)) {
1378 int16_t aa = *(int16_t *)(a + i);
1379 int16_t bb = *(int16_t *)(b + i);
1380 int16_t dd = aa > bb ? aa : bb;
1381 *(int16_t *)(d + i) = dd;
1382 }
1383 clear_high(d, oprsz, desc);
1384}
1385
1386void HELPER(gvec_smax32)(void *d, void *a, void *b, uint32_t desc)
1387{
1388 intptr_t oprsz = simd_oprsz(desc);
1389 intptr_t i;
1390
1391 for (i = 0; i < oprsz; i += sizeof(int32_t)) {
1392 int32_t aa = *(int32_t *)(a + i);
1393 int32_t bb = *(int32_t *)(b + i);
1394 int32_t dd = aa > bb ? aa : bb;
1395 *(int32_t *)(d + i) = dd;
1396 }
1397 clear_high(d, oprsz, desc);
1398}
1399
1400void HELPER(gvec_smax64)(void *d, void *a, void *b, uint32_t desc)
1401{
1402 intptr_t oprsz = simd_oprsz(desc);
1403 intptr_t i;
1404
1405 for (i = 0; i < oprsz; i += sizeof(int64_t)) {
1406 int64_t aa = *(int64_t *)(a + i);
1407 int64_t bb = *(int64_t *)(b + i);
1408 int64_t dd = aa > bb ? aa : bb;
1409 *(int64_t *)(d + i) = dd;
1410 }
1411 clear_high(d, oprsz, desc);
1412}
1413
1414void HELPER(gvec_umin8)(void *d, void *a, void *b, uint32_t desc)
1415{
1416 intptr_t oprsz = simd_oprsz(desc);
1417 intptr_t i;
1418
1419 for (i = 0; i < oprsz; i += sizeof(uint8_t)) {
1420 uint8_t aa = *(uint8_t *)(a + i);
1421 uint8_t bb = *(uint8_t *)(b + i);
1422 uint8_t dd = aa < bb ? aa : bb;
1423 *(uint8_t *)(d + i) = dd;
1424 }
1425 clear_high(d, oprsz, desc);
1426}
1427
1428void HELPER(gvec_umin16)(void *d, void *a, void *b, uint32_t desc)
1429{
1430 intptr_t oprsz = simd_oprsz(desc);
1431 intptr_t i;
1432
1433 for (i = 0; i < oprsz; i += sizeof(uint16_t)) {
1434 uint16_t aa = *(uint16_t *)(a + i);
1435 uint16_t bb = *(uint16_t *)(b + i);
1436 uint16_t dd = aa < bb ? aa : bb;
1437 *(uint16_t *)(d + i) = dd;
1438 }
1439 clear_high(d, oprsz, desc);
1440}
1441
1442void HELPER(gvec_umin32)(void *d, void *a, void *b, uint32_t desc)
1443{
1444 intptr_t oprsz = simd_oprsz(desc);
1445 intptr_t i;
1446
1447 for (i = 0; i < oprsz; i += sizeof(uint32_t)) {
1448 uint32_t aa = *(uint32_t *)(a + i);
1449 uint32_t bb = *(uint32_t *)(b + i);
1450 uint32_t dd = aa < bb ? aa : bb;
1451 *(uint32_t *)(d + i) = dd;
1452 }
1453 clear_high(d, oprsz, desc);
1454}
1455
1456void HELPER(gvec_umin64)(void *d, void *a, void *b, uint32_t desc)
1457{
1458 intptr_t oprsz = simd_oprsz(desc);
1459 intptr_t i;
1460
1461 for (i = 0; i < oprsz; i += sizeof(uint64_t)) {
1462 uint64_t aa = *(uint64_t *)(a + i);
1463 uint64_t bb = *(uint64_t *)(b + i);
1464 uint64_t dd = aa < bb ? aa : bb;
1465 *(uint64_t *)(d + i) = dd;
1466 }
1467 clear_high(d, oprsz, desc);
1468}
1469
1470void HELPER(gvec_umax8)(void *d, void *a, void *b, uint32_t desc)
1471{
1472 intptr_t oprsz = simd_oprsz(desc);
1473 intptr_t i;
1474
1475 for (i = 0; i < oprsz; i += sizeof(uint8_t)) {
1476 uint8_t aa = *(uint8_t *)(a + i);
1477 uint8_t bb = *(uint8_t *)(b + i);
1478 uint8_t dd = aa > bb ? aa : bb;
1479 *(uint8_t *)(d + i) = dd;
1480 }
1481 clear_high(d, oprsz, desc);
1482}
1483
1484void HELPER(gvec_umax16)(void *d, void *a, void *b, uint32_t desc)
1485{
1486 intptr_t oprsz = simd_oprsz(desc);
1487 intptr_t i;
1488
1489 for (i = 0; i < oprsz; i += sizeof(uint16_t)) {
1490 uint16_t aa = *(uint16_t *)(a + i);
1491 uint16_t bb = *(uint16_t *)(b + i);
1492 uint16_t dd = aa > bb ? aa : bb;
1493 *(uint16_t *)(d + i) = dd;
1494 }
1495 clear_high(d, oprsz, desc);
1496}
1497
1498void HELPER(gvec_umax32)(void *d, void *a, void *b, uint32_t desc)
1499{
1500 intptr_t oprsz = simd_oprsz(desc);
1501 intptr_t i;
1502
1503 for (i = 0; i < oprsz; i += sizeof(uint32_t)) {
1504 uint32_t aa = *(uint32_t *)(a + i);
1505 uint32_t bb = *(uint32_t *)(b + i);
1506 uint32_t dd = aa > bb ? aa : bb;
1507 *(uint32_t *)(d + i) = dd;
1508 }
1509 clear_high(d, oprsz, desc);
1510}
1511
1512void HELPER(gvec_umax64)(void *d, void *a, void *b, uint32_t desc)
1513{
1514 intptr_t oprsz = simd_oprsz(desc);
1515 intptr_t i;
1516
1517 for (i = 0; i < oprsz; i += sizeof(uint64_t)) {
1518 uint64_t aa = *(uint64_t *)(a + i);
1519 uint64_t bb = *(uint64_t *)(b + i);
1520 uint64_t dd = aa > bb ? aa : bb;
1521 *(uint64_t *)(d + i) = dd;
1522 }
1523 clear_high(d, oprsz, desc);
1524}
1525
1526void HELPER(gvec_bitsel)(void *d, void *a, void *b, void *c, uint32_t desc)
1527{
1528 intptr_t oprsz = simd_oprsz(desc);
1529 intptr_t i;
1530
1531 for (i = 0; i < oprsz; i += sizeof(uint64_t)) {
1532 uint64_t aa = *(uint64_t *)(a + i);
1533 uint64_t bb = *(uint64_t *)(b + i);
1534 uint64_t cc = *(uint64_t *)(c + i);
1535 *(uint64_t *)(d + i) = (bb & aa) | (cc & ~aa);
1536 }
1537 clear_high(d, oprsz, desc);
1538}
1539