]> git.proxmox.com Git - qemu.git/blame - target-arm/neon_helper.c
projects / qemu.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
target-arm: Fix signed VQRSHL by large shift counts
[qemu.git] / target-arm / neon_helper.c
CommitLineData
e677137d
PB		 1/*
2 * ARM NEON vector operations.
3 *
4 * Copyright (c) 2007, 2008 CodeSourcery.
5 * Written by Paul Brook
6 *
7 * This code is licenced under the GNU GPL v2.
8 */
ad69471c
PB		 9#include <stdlib.h>
10#include <stdio.h>
11
12#include "cpu.h"
13#include "exec-all.h"
14#include "helpers.h"
15
16#define SIGNBIT (uint32_t)0x80000000
17#define SIGNBIT64 ((uint64_t)1 << 63)
18
19#define SET_QC() env->vfp.xregs[ARM_VFP_FPSCR] = CPSR_Q
20
21static float_status neon_float_status;
22#define NFS &neon_float_status
23
24/* Helper routines to perform bitwise copies between float and int. */
25static inline float32 vfp_itos(uint32_t i)
26{
27 union {
28 uint32_t i;
29 float32 s;
30 } v;
31
32 v.i = i;
33 return v.s;
34}
35
36static inline uint32_t vfp_stoi(float32 s)
37{
38 union {
39 uint32_t i;
40 float32 s;
41 } v;
42
43 v.s = s;
44 return v.i;
45}
46
47#define NEON_TYPE1(name, type) \
48typedef struct \
49{ \
50 type v1; \
51} neon_##name;
e2542fe2 52#ifdef HOST_WORDS_BIGENDIAN
ad69471c
PB		 53#define NEON_TYPE2(name, type) \
54typedef struct \
55{ \
56 type v2; \
57 type v1; \
58} neon_##name;
59#define NEON_TYPE4(name, type) \
60typedef struct \
61{ \
62 type v4; \
63 type v3; \
64 type v2; \
65 type v1; \
66} neon_##name;
67#else
68#define NEON_TYPE2(name, type) \
69typedef struct \
70{ \
71 type v1; \
72 type v2; \
73} neon_##name;
74#define NEON_TYPE4(name, type) \
75typedef struct \
76{ \
77 type v1; \
78 type v2; \
79 type v3; \
80 type v4; \
81} neon_##name;
82#endif
83
84NEON_TYPE4(s8, int8_t)
85NEON_TYPE4(u8, uint8_t)
86NEON_TYPE2(s16, int16_t)
87NEON_TYPE2(u16, uint16_t)
88NEON_TYPE1(s32, int32_t)
89NEON_TYPE1(u32, uint32_t)
90#undef NEON_TYPE4
91#undef NEON_TYPE2
92#undef NEON_TYPE1
93
94/* Copy from a uint32_t to a vector structure type. */
95#define NEON_UNPACK(vtype, dest, val) do { \
96 union { \
97 vtype v; \
98 uint32_t i; \
99 } conv_u; \
100 conv_u.i = (val); \
101 dest = conv_u.v; \
102 } while(0)
103
104/* Copy from a vector structure type to a uint32_t. */
105#define NEON_PACK(vtype, dest, val) do { \
106 union { \
107 vtype v; \
108 uint32_t i; \
109 } conv_u; \
110 conv_u.v = (val); \
111 dest = conv_u.i; \
112 } while(0)
113
114#define NEON_DO1 \
115 NEON_FN(vdest.v1, vsrc1.v1, vsrc2.v1);
116#define NEON_DO2 \
117 NEON_FN(vdest.v1, vsrc1.v1, vsrc2.v1); \
118 NEON_FN(vdest.v2, vsrc1.v2, vsrc2.v2);
119#define NEON_DO4 \
120 NEON_FN(vdest.v1, vsrc1.v1, vsrc2.v1); \
121 NEON_FN(vdest.v2, vsrc1.v2, vsrc2.v2); \
122 NEON_FN(vdest.v3, vsrc1.v3, vsrc2.v3); \
123 NEON_FN(vdest.v4, vsrc1.v4, vsrc2.v4);
124
125#define NEON_VOP_BODY(vtype, n) \
126{ \
127 uint32_t res; \
128 vtype vsrc1; \
129 vtype vsrc2; \
130 vtype vdest; \
131 NEON_UNPACK(vtype, vsrc1, arg1); \
132 NEON_UNPACK(vtype, vsrc2, arg2); \
133 NEON_DO##n; \
134 NEON_PACK(vtype, res, vdest); \
135 return res; \
136}
137
138#define NEON_VOP(name, vtype, n) \
139uint32_t HELPER(glue(neon_,name))(uint32_t arg1, uint32_t arg2) \
140NEON_VOP_BODY(vtype, n)
141
142#define NEON_VOP_ENV(name, vtype, n) \
143uint32_t HELPER(glue(neon_,name))(CPUState *env, uint32_t arg1, uint32_t arg2) \
144NEON_VOP_BODY(vtype, n)
145
146/* Pairwise operations. */
147/* For 32-bit elements each segment only contains a single element, so
148 the elementwise and pairwise operations are the same. */
149#define NEON_PDO2 \
150 NEON_FN(vdest.v1, vsrc1.v1, vsrc1.v2); \
151 NEON_FN(vdest.v2, vsrc2.v1, vsrc2.v2);
152#define NEON_PDO4 \
153 NEON_FN(vdest.v1, vsrc1.v1, vsrc1.v2); \
154 NEON_FN(vdest.v2, vsrc1.v3, vsrc1.v4); \
155 NEON_FN(vdest.v3, vsrc2.v1, vsrc2.v2); \
156 NEON_FN(vdest.v4, vsrc2.v3, vsrc2.v4); \
157
158#define NEON_POP(name, vtype, n) \
159uint32_t HELPER(glue(neon_,name))(uint32_t arg1, uint32_t arg2) \
160{ \
161 uint32_t res; \
162 vtype vsrc1; \
163 vtype vsrc2; \
164 vtype vdest; \
165 NEON_UNPACK(vtype, vsrc1, arg1); \
166 NEON_UNPACK(vtype, vsrc2, arg2); \
167 NEON_PDO##n; \
168 NEON_PACK(vtype, res, vdest); \
169 return res; \
170}
171
172/* Unary operators. */
173#define NEON_VOP1(name, vtype, n) \
174uint32_t HELPER(glue(neon_,name))(uint32_t arg) \
175{ \
176 vtype vsrc1; \
177 vtype vdest; \
178 NEON_UNPACK(vtype, vsrc1, arg); \
179 NEON_DO##n; \
180 NEON_PACK(vtype, arg, vdest); \
181 return arg; \
182}
183
184
185#define NEON_USAT(dest, src1, src2, type) do { \
186 uint32_t tmp = (uint32_t)src1 + (uint32_t)src2; \
187 if (tmp != (type)tmp) { \
188 SET_QC(); \
189 dest = ~0; \
190 } else { \
191 dest = tmp; \
192 }} while(0)
193#define NEON_FN(dest, src1, src2) NEON_USAT(dest, src1, src2, uint8_t)
194NEON_VOP_ENV(qadd_u8, neon_u8, 4)
195#undef NEON_FN
196#define NEON_FN(dest, src1, src2) NEON_USAT(dest, src1, src2, uint16_t)
197NEON_VOP_ENV(qadd_u16, neon_u16, 2)
198#undef NEON_FN
199#undef NEON_USAT
200
72902672
CL		 201uint32_t HELPER(neon_qadd_u32)(CPUState *env, uint32_t a, uint32_t b)
202{
203 uint32_t res = a + b;
204 if (res < a) {
205 SET_QC();
206 res = ~0;
207 }
208 return res;
209}
210
211uint64_t HELPER(neon_qadd_u64)(CPUState *env, uint64_t src1, uint64_t src2)
212{
213 uint64_t res;
214
215 res = src1 + src2;
216 if (res < src1) {
217 SET_QC();
218 res = ~(uint64_t)0;
219 }
220 return res;
221}
222
ad69471c
PB		 223#define NEON_SSAT(dest, src1, src2, type) do { \
224 int32_t tmp = (uint32_t)src1 + (uint32_t)src2; \
225 if (tmp != (type)tmp) { \
226 SET_QC(); \
227 if (src2 > 0) { \
228 tmp = (1 << (sizeof(type) * 8 - 1)) - 1; \
229 } else { \
230 tmp = 1 << (sizeof(type) * 8 - 1); \
231 } \
232 } \
233 dest = tmp; \
234 } while(0)
235#define NEON_FN(dest, src1, src2) NEON_SSAT(dest, src1, src2, int8_t)
236NEON_VOP_ENV(qadd_s8, neon_s8, 4)
237#undef NEON_FN
238#define NEON_FN(dest, src1, src2) NEON_SSAT(dest, src1, src2, int16_t)
239NEON_VOP_ENV(qadd_s16, neon_s16, 2)
240#undef NEON_FN
241#undef NEON_SSAT
242
72902672
CL		 243uint32_t HELPER(neon_qadd_s32)(CPUState *env, uint32_t a, uint32_t b)
244{
245 uint32_t res = a + b;
246 if (((res ^ a) & SIGNBIT) && !((a ^ b) & SIGNBIT)) {
247 SET_QC();
248 res = ~(((int32_t)a >> 31) ^ SIGNBIT);
249 }
250 return res;
251}
252
253uint64_t HELPER(neon_qadd_s64)(CPUState *env, uint64_t src1, uint64_t src2)
254{
255 uint64_t res;
256
257 res = src1 + src2;
258 if (((res ^ src1) & SIGNBIT64) && !((src1 ^ src2) & SIGNBIT64)) {
259 SET_QC();
260 res = ((int64_t)src1 >> 63) ^ ~SIGNBIT64;
261 }
262 return res;
263}
264
ad69471c
PB		 265#define NEON_USAT(dest, src1, src2, type) do { \
266 uint32_t tmp = (uint32_t)src1 - (uint32_t)src2; \
267 if (tmp != (type)tmp) { \
268 SET_QC(); \
269 dest = 0; \
270 } else { \
271 dest = tmp; \
272 }} while(0)
273#define NEON_FN(dest, src1, src2) NEON_USAT(dest, src1, src2, uint8_t)
274NEON_VOP_ENV(qsub_u8, neon_u8, 4)
275#undef NEON_FN
276#define NEON_FN(dest, src1, src2) NEON_USAT(dest, src1, src2, uint16_t)
277NEON_VOP_ENV(qsub_u16, neon_u16, 2)
278#undef NEON_FN
279#undef NEON_USAT
280
72902672
CL		 281uint32_t HELPER(neon_qsub_u32)(CPUState *env, uint32_t a, uint32_t b)
282{
283 uint32_t res = a - b;
284 if (res > a) {
285 SET_QC();
286 res = 0;
287 }
288 return res;
289}
290
291uint64_t HELPER(neon_qsub_u64)(CPUState *env, uint64_t src1, uint64_t src2)
292{
293 uint64_t res;
294
295 if (src1 < src2) {
296 SET_QC();
297 res = 0;
298 } else {
299 res = src1 - src2;
300 }
301 return res;
302}
303
ad69471c
PB		 304#define NEON_SSAT(dest, src1, src2, type) do { \
305 int32_t tmp = (uint32_t)src1 - (uint32_t)src2; \
306 if (tmp != (type)tmp) { \
307 SET_QC(); \
308 if (src2 < 0) { \
309 tmp = (1 << (sizeof(type) * 8 - 1)) - 1; \
310 } else { \
311 tmp = 1 << (sizeof(type) * 8 - 1); \
312 } \
313 } \
314 dest = tmp; \
315 } while(0)
316#define NEON_FN(dest, src1, src2) NEON_SSAT(dest, src1, src2, int8_t)
317NEON_VOP_ENV(qsub_s8, neon_s8, 4)
318#undef NEON_FN
319#define NEON_FN(dest, src1, src2) NEON_SSAT(dest, src1, src2, int16_t)
320NEON_VOP_ENV(qsub_s16, neon_s16, 2)
321#undef NEON_FN
322#undef NEON_SSAT
323
72902672
CL		 324uint32_t HELPER(neon_qsub_s32)(CPUState *env, uint32_t a, uint32_t b)
325{
326 uint32_t res = a - b;
327 if (((res ^ a) & SIGNBIT) && ((a ^ b) & SIGNBIT)) {
328 SET_QC();
329 res = ~(((int32_t)a >> 31) ^ SIGNBIT);
330 }
331 return res;
332}
333
334uint64_t HELPER(neon_qsub_s64)(CPUState *env, uint64_t src1, uint64_t src2)
335{
336 uint64_t res;
337
338 res = src1 - src2;
339 if (((res ^ src1) & SIGNBIT64) && ((src1 ^ src2) & SIGNBIT64)) {
340 SET_QC();
341 res = ((int64_t)src1 >> 63) ^ ~SIGNBIT64;
342 }
343 return res;
344}
345
ad69471c
PB		 346#define NEON_FN(dest, src1, src2) dest = (src1 + src2) >> 1
347NEON_VOP(hadd_s8, neon_s8, 4)
348NEON_VOP(hadd_u8, neon_u8, 4)
349NEON_VOP(hadd_s16, neon_s16, 2)
350NEON_VOP(hadd_u16, neon_u16, 2)
351#undef NEON_FN
352
353int32_t HELPER(neon_hadd_s32)(int32_t src1, int32_t src2)
354{
355 int32_t dest;
356
357 dest = (src1 >> 1) + (src2 >> 1);
358 if (src1 & src2 & 1)
359 dest++;
360 return dest;
361}
362
363uint32_t HELPER(neon_hadd_u32)(uint32_t src1, uint32_t src2)
364{
365 uint32_t dest;
366
367 dest = (src1 >> 1) + (src2 >> 1);
368 if (src1 & src2 & 1)
369 dest++;
370 return dest;
371}
372
373#define NEON_FN(dest, src1, src2) dest = (src1 + src2 + 1) >> 1
374NEON_VOP(rhadd_s8, neon_s8, 4)
375NEON_VOP(rhadd_u8, neon_u8, 4)
376NEON_VOP(rhadd_s16, neon_s16, 2)
377NEON_VOP(rhadd_u16, neon_u16, 2)
378#undef NEON_FN
379
380int32_t HELPER(neon_rhadd_s32)(int32_t src1, int32_t src2)
381{
382 int32_t dest;
383
384 dest = (src1 >> 1) + (src2 >> 1);
385 if ((src1 | src2) & 1)
386 dest++;
387 return dest;
388}
389
390uint32_t HELPER(neon_rhadd_u32)(uint32_t src1, uint32_t src2)
391{
392 uint32_t dest;
393
394 dest = (src1 >> 1) + (src2 >> 1);
395 if ((src1 | src2) & 1)
396 dest++;
397 return dest;
398}
399
400#define NEON_FN(dest, src1, src2) dest = (src1 - src2) >> 1
401NEON_VOP(hsub_s8, neon_s8, 4)
402NEON_VOP(hsub_u8, neon_u8, 4)
403NEON_VOP(hsub_s16, neon_s16, 2)
404NEON_VOP(hsub_u16, neon_u16, 2)
405#undef NEON_FN
406
407int32_t HELPER(neon_hsub_s32)(int32_t src1, int32_t src2)
408{
409 int32_t dest;
410
411 dest = (src1 >> 1) - (src2 >> 1);
412 if ((~src1) & src2 & 1)
413 dest--;
414 return dest;
415}
416
417uint32_t HELPER(neon_hsub_u32)(uint32_t src1, uint32_t src2)
418{
419 uint32_t dest;
420
421 dest = (src1 >> 1) - (src2 >> 1);
422 if ((~src1) & src2 & 1)
423 dest--;
424 return dest;
425}
426
427#define NEON_FN(dest, src1, src2) dest = (src1 > src2) ? ~0 : 0
428NEON_VOP(cgt_s8, neon_s8, 4)
429NEON_VOP(cgt_u8, neon_u8, 4)
430NEON_VOP(cgt_s16, neon_s16, 2)
431NEON_VOP(cgt_u16, neon_u16, 2)
432NEON_VOP(cgt_s32, neon_s32, 1)
433NEON_VOP(cgt_u32, neon_u32, 1)
434#undef NEON_FN
435
436#define NEON_FN(dest, src1, src2) dest = (src1 >= src2) ? ~0 : 0
437NEON_VOP(cge_s8, neon_s8, 4)
438NEON_VOP(cge_u8, neon_u8, 4)
439NEON_VOP(cge_s16, neon_s16, 2)
440NEON_VOP(cge_u16, neon_u16, 2)
441NEON_VOP(cge_s32, neon_s32, 1)
442NEON_VOP(cge_u32, neon_u32, 1)
443#undef NEON_FN
444
445#define NEON_FN(dest, src1, src2) dest = (src1 < src2) ? src1 : src2
446NEON_VOP(min_s8, neon_s8, 4)
447NEON_VOP(min_u8, neon_u8, 4)
448NEON_VOP(min_s16, neon_s16, 2)
449NEON_VOP(min_u16, neon_u16, 2)
450NEON_VOP(min_s32, neon_s32, 1)
451NEON_VOP(min_u32, neon_u32, 1)
452NEON_POP(pmin_s8, neon_s8, 4)
453NEON_POP(pmin_u8, neon_u8, 4)
454NEON_POP(pmin_s16, neon_s16, 2)
455NEON_POP(pmin_u16, neon_u16, 2)
456#undef NEON_FN
457
458#define NEON_FN(dest, src1, src2) dest = (src1 > src2) ? src1 : src2
459NEON_VOP(max_s8, neon_s8, 4)
460NEON_VOP(max_u8, neon_u8, 4)
461NEON_VOP(max_s16, neon_s16, 2)
462NEON_VOP(max_u16, neon_u16, 2)
463NEON_VOP(max_s32, neon_s32, 1)
464NEON_VOP(max_u32, neon_u32, 1)
465NEON_POP(pmax_s8, neon_s8, 4)
466NEON_POP(pmax_u8, neon_u8, 4)
467NEON_POP(pmax_s16, neon_s16, 2)
468NEON_POP(pmax_u16, neon_u16, 2)
469#undef NEON_FN
470
471#define NEON_FN(dest, src1, src2) \
472 dest = (src1 > src2) ? (src1 - src2) : (src2 - src1)
473NEON_VOP(abd_s8, neon_s8, 4)
474NEON_VOP(abd_u8, neon_u8, 4)
475NEON_VOP(abd_s16, neon_s16, 2)
476NEON_VOP(abd_u16, neon_u16, 2)
477NEON_VOP(abd_s32, neon_s32, 1)
478NEON_VOP(abd_u32, neon_u32, 1)
479#undef NEON_FN
480
481#define NEON_FN(dest, src1, src2) do { \
482 int8_t tmp; \
483 tmp = (int8_t)src2; \
50f67e95
JR		 484 if (tmp >= (ssize_t)sizeof(src1) * 8 || \
485 tmp <= -(ssize_t)sizeof(src1) * 8) { \
ad69471c
PB		 486 dest = 0; \
487 } else if (tmp < 0) { \
488 dest = src1 >> -tmp; \
489 } else { \
490 dest = src1 << tmp; \
491 }} while (0)
492NEON_VOP(shl_u8, neon_u8, 4)
493NEON_VOP(shl_u16, neon_u16, 2)
494NEON_VOP(shl_u32, neon_u32, 1)
495#undef NEON_FN
496
497uint64_t HELPER(neon_shl_u64)(uint64_t val, uint64_t shiftop)
498{
499 int8_t shift = (int8_t)shiftop;
500 if (shift >= 64 || shift <= -64) {
501 val = 0;
502 } else if (shift < 0) {
503 val >>= -shift;
504 } else {
505 val <<= shift;
506 }
507 return val;
508}
509
510#define NEON_FN(dest, src1, src2) do { \
511 int8_t tmp; \
512 tmp = (int8_t)src2; \
50f67e95 513 if (tmp >= (ssize_t)sizeof(src1) * 8) { \
ad69471c 514 dest = 0; \
50f67e95 515 } else if (tmp <= -(ssize_t)sizeof(src1) * 8) { \
ad69471c
PB		 516 dest = src1 >> (sizeof(src1) * 8 - 1); \
517 } else if (tmp < 0) { \
518 dest = src1 >> -tmp; \
519 } else { \
520 dest = src1 << tmp; \
521 }} while (0)
522NEON_VOP(shl_s8, neon_s8, 4)
523NEON_VOP(shl_s16, neon_s16, 2)
524NEON_VOP(shl_s32, neon_s32, 1)
525#undef NEON_FN
526
527uint64_t HELPER(neon_shl_s64)(uint64_t valop, uint64_t shiftop)
528{
529 int8_t shift = (int8_t)shiftop;
530 int64_t val = valop;
531 if (shift >= 64) {
532 val = 0;
533 } else if (shift <= -64) {
534 val >>= 63;
535 } else if (shift < 0) {
536 val >>= -shift;
537 } else {
538 val <<= shift;
539 }
540 return val;
541}
542
543#define NEON_FN(dest, src1, src2) do { \
544 int8_t tmp; \
545 tmp = (int8_t)src2; \
0670a7b6
PM		 546 if ((tmp >= (ssize_t)sizeof(src1) * 8) \
547 || (tmp <= -(ssize_t)sizeof(src1) * 8)) { \
ad69471c 548 dest = 0; \
ad69471c
PB		 549 } else if (tmp < 0) { \
550 dest = (src1 + (1 << (-1 - tmp))) >> -tmp; \
551 } else { \
552 dest = src1 << tmp; \
553 }} while (0)
554NEON_VOP(rshl_s8, neon_s8, 4)
555NEON_VOP(rshl_s16, neon_s16, 2)
ad69471c
PB		 556#undef NEON_FN
557
4bd4ee07
CL		 558/* The addition of the rounding constant may overflow, so we use an
559 * intermediate 64 bits accumulator. */
560uint32_t HELPER(neon_rshl_s32)(uint32_t valop, uint32_t shiftop)
561{
562 int32_t dest;
563 int32_t val = (int32_t)valop;
564 int8_t shift = (int8_t)shiftop;
565 if ((shift >= 32) || (shift <= -32)) {
566 dest = 0;
567 } else if (shift < 0) {
568 int64_t big_dest = ((int64_t)val + (1 << (-1 - shift)));
569 dest = big_dest >> -shift;
570 } else {
571 dest = val << shift;
572 }
573 return dest;
574}
575
576/* Handling addition overflow with 64 bits inputs values is more
577 * tricky than with 32 bits values. */
ad69471c
PB		 578uint64_t HELPER(neon_rshl_s64)(uint64_t valop, uint64_t shiftop)
579{
580 int8_t shift = (int8_t)shiftop;
581 int64_t val = valop;
0670a7b6 582 if ((shift >= 64) || (shift <= -64)) {
ad69471c 583 val = 0;
ad69471c 584 } else if (shift < 0) {
4bd4ee07
CL		 585 val >>= (-shift - 1);
586 if (val == INT64_MAX) {
587 /* In this case, it means that the rounding constant is 1,
588 * and the addition would overflow. Return the actual
589 * result directly. */
590 val = 0x4000000000000000LL;
591 } else {
592 val++;
593 val >>= 1;
594 }
ad69471c
PB		 595 } else {
596 val <<= shift;
597 }
598 return val;
599}
600
601#define NEON_FN(dest, src1, src2) do { \
602 int8_t tmp; \
603 tmp = (int8_t)src2; \
50f67e95
JR		 604 if (tmp >= (ssize_t)sizeof(src1) * 8 || \
605 tmp < -(ssize_t)sizeof(src1) * 8) { \
ad69471c 606 dest = 0; \
50f67e95 607 } else if (tmp == -(ssize_t)sizeof(src1) * 8) { \
b6c63b98 608 dest = src1 >> (-tmp - 1); \
ad69471c
PB		 609 } else if (tmp < 0) { \
610 dest = (src1 + (1 << (-1 - tmp))) >> -tmp; \
611 } else { \
612 dest = src1 << tmp; \
613 }} while (0)
614NEON_VOP(rshl_u8, neon_u8, 4)
615NEON_VOP(rshl_u16, neon_u16, 2)
ad69471c
PB		 616#undef NEON_FN
617
4bd4ee07
CL		 618/* The addition of the rounding constant may overflow, so we use an
619 * intermediate 64 bits accumulator. */
620uint32_t HELPER(neon_rshl_u32)(uint32_t val, uint32_t shiftop)
621{
622 uint32_t dest;
623 int8_t shift = (int8_t)shiftop;
624 if (shift >= 32 || shift < -32) {
625 dest = 0;
626 } else if (shift == -32) {
627 dest = val >> 31;
628 } else if (shift < 0) {
629 uint64_t big_dest = ((uint64_t)val + (1 << (-1 - shift)));
630 dest = big_dest >> -shift;
631 } else {
632 dest = val << shift;
633 }
634 return dest;
635}
636
637/* Handling addition overflow with 64 bits inputs values is more
638 * tricky than with 32 bits values. */
ad69471c
PB		 639uint64_t HELPER(neon_rshl_u64)(uint64_t val, uint64_t shiftop)
640{
641 int8_t shift = (uint8_t)shiftop;
51e3930f 642 if (shift >= 64 || shift < -64) {
ad69471c
PB		 643 val = 0;
644 } else if (shift == -64) {
645 /* Rounding a 1-bit result just preserves that bit. */
646 val >>= 63;
4bd4ee07
CL		 647 } else if (shift < 0) {
648 val >>= (-shift - 1);
649 if (val == UINT64_MAX) {
650 /* In this case, it means that the rounding constant is 1,
651 * and the addition would overflow. Return the actual
652 * result directly. */
653 val = 0x8000000000000000ULL;
654 } else {
655 val++;
656 val >>= 1;
657 }
ad69471c
PB		 658 } else {
659 val <<= shift;
660 }
661 return val;
662}
663
664#define NEON_FN(dest, src1, src2) do { \
665 int8_t tmp; \
666 tmp = (int8_t)src2; \
50f67e95 667 if (tmp >= (ssize_t)sizeof(src1) * 8) { \
ad69471c
PB		 668 if (src1) { \
669 SET_QC(); \
670 dest = ~0; \
671 } else { \
672 dest = 0; \
673 } \
50f67e95 674 } else if (tmp <= -(ssize_t)sizeof(src1) * 8) { \
ad69471c
PB		 675 dest = 0; \
676 } else if (tmp < 0) { \
677 dest = src1 >> -tmp; \
678 } else { \
679 dest = src1 << tmp; \
680 if ((dest >> tmp) != src1) { \
681 SET_QC(); \
682 dest = ~0; \
683 } \
684 }} while (0)
685NEON_VOP_ENV(qshl_u8, neon_u8, 4)
686NEON_VOP_ENV(qshl_u16, neon_u16, 2)
687NEON_VOP_ENV(qshl_u32, neon_u32, 1)
688#undef NEON_FN
689
690uint64_t HELPER(neon_qshl_u64)(CPUState *env, uint64_t val, uint64_t shiftop)
691{
692 int8_t shift = (int8_t)shiftop;
693 if (shift >= 64) {
694 if (val) {
695 val = ~(uint64_t)0;
696 SET_QC();
ad69471c
PB		 697 }
698 } else if (shift <= -64) {
699 val = 0;
700 } else if (shift < 0) {
701 val >>= -shift;
702 } else {
703 uint64_t tmp = val;
704 val <<= shift;
705 if ((val >> shift) != tmp) {
706 SET_QC();
707 val = ~(uint64_t)0;
708 }
709 }
710 return val;
711}
712
713#define NEON_FN(dest, src1, src2) do { \
714 int8_t tmp; \
715 tmp = (int8_t)src2; \
50f67e95 716 if (tmp >= (ssize_t)sizeof(src1) * 8) { \
a5d88f3e 717 if (src1) { \
ad69471c 718 SET_QC(); \
a5d88f3e
PM		 719 dest = (uint32_t)(1 << (sizeof(src1) * 8 - 1)); \
720 if (src1 > 0) { \
721 dest--; \
722 } \
723 } else { \
724 dest = src1; \
725 } \
50f67e95 726 } else if (tmp <= -(ssize_t)sizeof(src1) * 8) { \
ad69471c
PB		 727 dest = src1 >> 31; \
728 } else if (tmp < 0) { \
729 dest = src1 >> -tmp; \
730 } else { \
731 dest = src1 << tmp; \
732 if ((dest >> tmp) != src1) { \
733 SET_QC(); \
a5d88f3e
PM		 734 dest = (uint32_t)(1 << (sizeof(src1) * 8 - 1)); \
735 if (src1 > 0) { \
736 dest--; \
737 } \
ad69471c
PB		 738 } \
739 }} while (0)
740NEON_VOP_ENV(qshl_s8, neon_s8, 4)
741NEON_VOP_ENV(qshl_s16, neon_s16, 2)
742NEON_VOP_ENV(qshl_s32, neon_s32, 1)
743#undef NEON_FN
744
745uint64_t HELPER(neon_qshl_s64)(CPUState *env, uint64_t valop, uint64_t shiftop)
746{
747 int8_t shift = (uint8_t)shiftop;
748 int64_t val = valop;
749 if (shift >= 64) {
750 if (val) {
751 SET_QC();
eb7a3d79 752 val = (val >> 63) ^ ~SIGNBIT64;
ad69471c 753 }
4c9b70ae 754 } else if (shift <= -64) {
ad69471c
PB		 755 val >>= 63;
756 } else if (shift < 0) {
757 val >>= -shift;
758 } else {
759 int64_t tmp = val;
760 val <<= shift;
761 if ((val >> shift) != tmp) {
762 SET_QC();
763 val = (tmp >> 63) ^ ~SIGNBIT64;
764 }
765 }
766 return val;
767}
768
4ca4502c
JR		 769#define NEON_FN(dest, src1, src2) do { \
770 if (src1 & (1 << (sizeof(src1) * 8 - 1))) { \
771 SET_QC(); \
772 dest = 0; \
773 } else { \
774 int8_t tmp; \
775 tmp = (int8_t)src2; \
776 if (tmp >= (ssize_t)sizeof(src1) * 8) { \
777 if (src1) { \
778 SET_QC(); \
779 dest = ~0; \
780 } else { \
781 dest = 0; \
782 } \
783 } else if (tmp <= -(ssize_t)sizeof(src1) * 8) { \
784 dest = 0; \
785 } else if (tmp < 0) { \
786 dest = src1 >> -tmp; \
787 } else { \
788 dest = src1 << tmp; \
789 if ((dest >> tmp) != src1) { \
790 SET_QC(); \
791 dest = ~0; \
792 } \
793 } \
794 }} while (0)
795NEON_VOP_ENV(qshlu_s8, neon_u8, 4)
796NEON_VOP_ENV(qshlu_s16, neon_u16, 2)
797#undef NEON_FN
798
799uint32_t HELPER(neon_qshlu_s32)(CPUState *env, uint32_t valop, uint32_t shiftop)
800{
801 if ((int32_t)valop < 0) {
802 SET_QC();
803 return 0;
804 }
805 return helper_neon_qshl_u32(env, valop, shiftop);
806}
807
808uint64_t HELPER(neon_qshlu_s64)(CPUState *env, uint64_t valop, uint64_t shiftop)
809{
810 if ((int64_t)valop < 0) {
811 SET_QC();
812 return 0;
813 }
814 return helper_neon_qshl_u64(env, valop, shiftop);
815}
ad69471c
PB		 816
817/* FIXME: This is wrong. */
818#define NEON_FN(dest, src1, src2) do { \
819 int8_t tmp; \
820 tmp = (int8_t)src2; \
821 if (tmp < 0) { \
822 dest = (src1 + (1 << (-1 - tmp))) >> -tmp; \
823 } else { \
824 dest = src1 << tmp; \
825 if ((dest >> tmp) != src1) { \
826 SET_QC(); \
827 dest = ~0; \
828 } \
829 }} while (0)
830NEON_VOP_ENV(qrshl_u8, neon_u8, 4)
831NEON_VOP_ENV(qrshl_u16, neon_u16, 2)
ad69471c
PB		 832#undef NEON_FN
833
4bd4ee07
CL		 834/* The addition of the rounding constant may overflow, so we use an
835 * intermediate 64 bits accumulator. */
836uint32_t HELPER(neon_qrshl_u32)(CPUState *env, uint32_t val, uint32_t shiftop)
837{
838 uint32_t dest;
839 int8_t shift = (int8_t)shiftop;
840 if (shift < 0) {
841 uint64_t big_dest = ((uint64_t)val + (1 << (-1 - shift)));
842 dest = big_dest >> -shift;
843 } else {
844 dest = val << shift;
845 if ((dest >> shift) != val) {
846 SET_QC();
847 dest = ~0;
848 }
849 }
850 return dest;
851}
852
853/* Handling addition overflow with 64 bits inputs values is more
854 * tricky than with 32 bits values. */
ad69471c
PB		 855uint64_t HELPER(neon_qrshl_u64)(CPUState *env, uint64_t val, uint64_t shiftop)
856{
857 int8_t shift = (int8_t)shiftop;
858 if (shift < 0) {
4bd4ee07
CL		 859 val >>= (-shift - 1);
860 if (val == UINT64_MAX) {
861 /* In this case, it means that the rounding constant is 1,
862 * and the addition would overflow. Return the actual
863 * result directly. */
864 val = 0x8000000000000000ULL;
865 } else {
866 val++;
867 val >>= 1;
868 }
ad69471c
PB		 869 } else { \
870 uint64_t tmp = val;
871 val <<= shift;
872 if ((val >> shift) != tmp) {
873 SET_QC();
874 val = ~0;
875 }
876 }
877 return val;
878}
879
880#define NEON_FN(dest, src1, src2) do { \
881 int8_t tmp; \
882 tmp = (int8_t)src2; \
7b6ecf5b
PM		 883 if (tmp >= (ssize_t)sizeof(src1) * 8) { \
884 if (src1) { \
885 SET_QC(); \
886 dest = (1 << (sizeof(src1) * 8 - 1)); \
887 if (src1 > 0) { \
888 dest--; \
889 } \
890 } else { \
891 dest = 0; \
892 } \
893 } else if (tmp <= -(ssize_t)sizeof(src1) * 8) { \
894 dest = 0; \
895 } else if (tmp < 0) { \
ad69471c
PB		 896 dest = (src1 + (1 << (-1 - tmp))) >> -tmp; \
897 } else { \
898 dest = src1 << tmp; \
899 if ((dest >> tmp) != src1) { \
900 SET_QC(); \
960e623b
PM		 901 dest = (uint32_t)(1 << (sizeof(src1) * 8 - 1)); \
902 if (src1 > 0) { \
903 dest--; \
904 } \
ad69471c
PB		 905 } \
906 }} while (0)
907NEON_VOP_ENV(qrshl_s8, neon_s8, 4)
908NEON_VOP_ENV(qrshl_s16, neon_s16, 2)
ad69471c
PB		 909#undef NEON_FN
910
4bd4ee07
CL		 911/* The addition of the rounding constant may overflow, so we use an
912 * intermediate 64 bits accumulator. */
913uint32_t HELPER(neon_qrshl_s32)(CPUState *env, uint32_t valop, uint32_t shiftop)
914{
915 int32_t dest;
916 int32_t val = (int32_t)valop;
917 int8_t shift = (int8_t)shiftop;
7b6ecf5b
PM		 918 if (shift >= 32) {
919 if (val) {
920 SET_QC();
921 dest = (val >> 31) ^ ~SIGNBIT;
922 } else {
923 dest = 0;
924 }
925 } else if (shift <= -32) {
926 dest = 0;
927 } else if (shift < 0) {
4bd4ee07
CL		 928 int64_t big_dest = ((int64_t)val + (1 << (-1 - shift)));
929 dest = big_dest >> -shift;
930 } else {
931 dest = val << shift;
932 if ((dest >> shift) != val) {
933 SET_QC();
934 dest = (val >> 31) ^ ~SIGNBIT;
935 }
936 }
937 return dest;
938}
939
940/* Handling addition overflow with 64 bits inputs values is more
941 * tricky than with 32 bits values. */
ad69471c
PB		 942uint64_t HELPER(neon_qrshl_s64)(CPUState *env, uint64_t valop, uint64_t shiftop)
943{
944 int8_t shift = (uint8_t)shiftop;
945 int64_t val = valop;
946
7b6ecf5b
PM		 947 if (shift >= 64) {
948 if (val) {
949 SET_QC();
950 val = (val >> 63) ^ ~SIGNBIT64;
951 }
952 } else if (shift <= -64) {
953 val = 0;
954 } else if (shift < 0) {
4bd4ee07
CL		 955 val >>= (-shift - 1);
956 if (val == INT64_MAX) {
957 /* In this case, it means that the rounding constant is 1,
958 * and the addition would overflow. Return the actual
959 * result directly. */
960 val = 0x4000000000000000ULL;
961 } else {
962 val++;
963 val >>= 1;
964 }
ad69471c 965 } else {
4bd4ee07 966 int64_t tmp = val;
ad69471c
PB		 967 val <<= shift;
968 if ((val >> shift) != tmp) {
969 SET_QC();
4bd4ee07 970 val = (tmp >> 63) ^ ~SIGNBIT64;
ad69471c
PB		 971 }
972 }
973 return val;
974}
975
976uint32_t HELPER(neon_add_u8)(uint32_t a, uint32_t b)
977{
978 uint32_t mask;
979 mask = (a ^ b) & 0x80808080u;
980 a &= ~0x80808080u;
981 b &= ~0x80808080u;
982 return (a + b) ^ mask;
983}
984
985uint32_t HELPER(neon_add_u16)(uint32_t a, uint32_t b)
986{
987 uint32_t mask;
988 mask = (a ^ b) & 0x80008000u;
989 a &= ~0x80008000u;
990 b &= ~0x80008000u;
991 return (a + b) ^ mask;
992}
993
994#define NEON_FN(dest, src1, src2) dest = src1 + src2
995NEON_POP(padd_u8, neon_u8, 4)
996NEON_POP(padd_u16, neon_u16, 2)
997#undef NEON_FN
998
999#define NEON_FN(dest, src1, src2) dest = src1 - src2
1000NEON_VOP(sub_u8, neon_u8, 4)
1001NEON_VOP(sub_u16, neon_u16, 2)
1002#undef NEON_FN
1003
1004#define NEON_FN(dest, src1, src2) dest = src1 * src2
1005NEON_VOP(mul_u8, neon_u8, 4)
1006NEON_VOP(mul_u16, neon_u16, 2)
1007#undef NEON_FN
1008
1654b2d6 1009/* Polynomial multiplication is like integer multiplication except the
ad69471c
PB		 1010 partial products are XORed, not added. */
1011uint32_t HELPER(neon_mul_p8)(uint32_t op1, uint32_t op2)
1012{
1013 uint32_t mask;
1014 uint32_t result;
1015 result = 0;
1016 while (op1) {
1017 mask = 0;
1018 if (op1 & 1)
1019 mask |= 0xff;
1020 if (op1 & (1 << 8))
1021 mask |= (0xff << 8);
1022 if (op1 & (1 << 16))
1023 mask |= (0xff << 16);
1024 if (op1 & (1 << 24))
1025 mask |= (0xff << 24);
1026 result ^= op2 & mask;
1027 op1 = (op1 >> 1) & 0x7f7f7f7f;
1028 op2 = (op2 << 1) & 0xfefefefe;
1029 }
1030 return result;
1031}
1032
e5ca24cb
PM		 1033uint64_t HELPER(neon_mull_p8)(uint32_t op1, uint32_t op2)
1034{
1035 uint64_t result = 0;
1036 uint64_t mask;
1037 uint64_t op2ex = op2;
1038 op2ex = (op2ex & 0xff) |
1039 ((op2ex & 0xff00) << 8) |
1040 ((op2ex & 0xff0000) << 16) |
1041 ((op2ex & 0xff000000) << 24);
1042 while (op1) {
1043 mask = 0;
1044 if (op1 & 1) {
1045 mask |= 0xffff;
1046 }
1047 if (op1 & (1 << 8)) {
1048 mask |= (0xffffU << 16);
1049 }
1050 if (op1 & (1 << 16)) {
1051 mask |= (0xffffULL << 32);
1052 }
1053 if (op1 & (1 << 24)) {
1054 mask |= (0xffffULL << 48);
1055 }
1056 result ^= op2ex & mask;
1057 op1 = (op1 >> 1) & 0x7f7f7f7f;
1058 op2ex <<= 1;
1059 }
1060 return result;
1061}
1062
ad69471c
PB		 1063#define NEON_FN(dest, src1, src2) dest = (src1 & src2) ? -1 : 0
1064NEON_VOP(tst_u8, neon_u8, 4)
1065NEON_VOP(tst_u16, neon_u16, 2)
1066NEON_VOP(tst_u32, neon_u32, 1)
1067#undef NEON_FN
1068
1069#define NEON_FN(dest, src1, src2) dest = (src1 == src2) ? -1 : 0
1070NEON_VOP(ceq_u8, neon_u8, 4)
1071NEON_VOP(ceq_u16, neon_u16, 2)
1072NEON_VOP(ceq_u32, neon_u32, 1)
1073#undef NEON_FN
1074
1075#define NEON_FN(dest, src, dummy) dest = (src < 0) ? -src : src
1076NEON_VOP1(abs_s8, neon_s8, 4)
1077NEON_VOP1(abs_s16, neon_s16, 2)
1078#undef NEON_FN
1079
1080/* Count Leading Sign/Zero Bits. */
1081static inline int do_clz8(uint8_t x)
1082{
1083 int n;
1084 for (n = 8; x; n--)
1085 x >>= 1;
1086 return n;
1087}
1088
1089static inline int do_clz16(uint16_t x)
1090{
1091 int n;
1092 for (n = 16; x; n--)
1093 x >>= 1;
1094 return n;
1095}
1096
1097#define NEON_FN(dest, src, dummy) dest = do_clz8(src)
1098NEON_VOP1(clz_u8, neon_u8, 4)
1099#undef NEON_FN
1100
1101#define NEON_FN(dest, src, dummy) dest = do_clz16(src)
1102NEON_VOP1(clz_u16, neon_u16, 2)
1103#undef NEON_FN
1104
1105#define NEON_FN(dest, src, dummy) dest = do_clz8((src < 0) ? ~src : src) - 1
1106NEON_VOP1(cls_s8, neon_s8, 4)
1107#undef NEON_FN
1108
1109#define NEON_FN(dest, src, dummy) dest = do_clz16((src < 0) ? ~src : src) - 1
1110NEON_VOP1(cls_s16, neon_s16, 2)
1111#undef NEON_FN
1112
1113uint32_t HELPER(neon_cls_s32)(uint32_t x)
1114{
1115 int count;
1116 if ((int32_t)x < 0)
1117 x = ~x;
1118 for (count = 32; x; count--)
1119 x = x >> 1;
1120 return count - 1;
1121}
1122
1123/* Bit count. */
1124uint32_t HELPER(neon_cnt_u8)(uint32_t x)
1125{
1126 x = (x & 0x55555555) + ((x >> 1) & 0x55555555);
1127 x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
1128 x = (x & 0x0f0f0f0f) + ((x >> 4) & 0x0f0f0f0f);
1129 return x;
1130}
1131
1132#define NEON_QDMULH16(dest, src1, src2, round) do { \
1133 uint32_t tmp = (int32_t)(int16_t) src1 * (int16_t) src2; \
1134 if ((tmp ^ (tmp << 1)) & SIGNBIT) { \
1135 SET_QC(); \
1136 tmp = (tmp >> 31) ^ ~SIGNBIT; \
46eece9d
JR		 1137 } else { \
1138 tmp <<= 1; \
ad69471c 1139 } \
ad69471c
PB		 1140 if (round) { \
1141 int32_t old = tmp; \
1142 tmp += 1 << 15; \
1143 if ((int32_t)tmp < old) { \
1144 SET_QC(); \
1145 tmp = SIGNBIT - 1; \
1146 } \
1147 } \
1148 dest = tmp >> 16; \
1149 } while(0)
1150#define NEON_FN(dest, src1, src2) NEON_QDMULH16(dest, src1, src2, 0)
1151NEON_VOP_ENV(qdmulh_s16, neon_s16, 2)
1152#undef NEON_FN
1153#define NEON_FN(dest, src1, src2) NEON_QDMULH16(dest, src1, src2, 1)
1154NEON_VOP_ENV(qrdmulh_s16, neon_s16, 2)
1155#undef NEON_FN
1156#undef NEON_QDMULH16
1157
1158#define NEON_QDMULH32(dest, src1, src2, round) do { \
1159 uint64_t tmp = (int64_t)(int32_t) src1 * (int32_t) src2; \
1160 if ((tmp ^ (tmp << 1)) & SIGNBIT64) { \
1161 SET_QC(); \
1162 tmp = (tmp >> 63) ^ ~SIGNBIT64; \
1163 } else { \
1164 tmp <<= 1; \
1165 } \
1166 if (round) { \
1167 int64_t old = tmp; \
1168 tmp += (int64_t)1 << 31; \
1169 if ((int64_t)tmp < old) { \
1170 SET_QC(); \
1171 tmp = SIGNBIT64 - 1; \
1172 } \
1173 } \
1174 dest = tmp >> 32; \
1175 } while(0)
1176#define NEON_FN(dest, src1, src2) NEON_QDMULH32(dest, src1, src2, 0)
1177NEON_VOP_ENV(qdmulh_s32, neon_s32, 1)
1178#undef NEON_FN
1179#define NEON_FN(dest, src1, src2) NEON_QDMULH32(dest, src1, src2, 1)
1180NEON_VOP_ENV(qrdmulh_s32, neon_s32, 1)
1181#undef NEON_FN
1182#undef NEON_QDMULH32
1183
1184uint32_t HELPER(neon_narrow_u8)(uint64_t x)
1185{
1186 return (x & 0xffu) | ((x >> 8) & 0xff00u) | ((x >> 16) & 0xff0000u)
1187 | ((x >> 24) & 0xff000000u);
1188}
1189
1190uint32_t HELPER(neon_narrow_u16)(uint64_t x)
1191{
1192 return (x & 0xffffu) | ((x >> 16) & 0xffff0000u);
1193}
1194
1195uint32_t HELPER(neon_narrow_high_u8)(uint64_t x)
1196{
1197 return ((x >> 8) & 0xff) | ((x >> 16) & 0xff00)
1198 | ((x >> 24) & 0xff0000) | ((x >> 32) & 0xff000000);
1199}
1200
1201uint32_t HELPER(neon_narrow_high_u16)(uint64_t x)
1202{
1203 return ((x >> 16) & 0xffff) | ((x >> 32) & 0xffff0000);
1204}
1205
1206uint32_t HELPER(neon_narrow_round_high_u8)(uint64_t x)
1207{
1208 x &= 0xff80ff80ff80ff80ull;
1209 x += 0x0080008000800080ull;
1210 return ((x >> 8) & 0xff) | ((x >> 16) & 0xff00)
1211 | ((x >> 24) & 0xff0000) | ((x >> 32) & 0xff000000);
1212}
1213
1214uint32_t HELPER(neon_narrow_round_high_u16)(uint64_t x)
1215{
1216 x &= 0xffff8000ffff8000ull;
1217 x += 0x0000800000008000ull;
1218 return ((x >> 16) & 0xffff) | ((x >> 32) & 0xffff0000);
1219}
1220
af1bbf30
JR		 1221uint32_t HELPER(neon_unarrow_sat8)(CPUState *env, uint64_t x)
1222{
1223 uint16_t s;
1224 uint8_t d;
1225 uint32_t res = 0;
1226#define SAT8(n) \
1227 s = x >> n; \
1228 if (s & 0x8000) { \
1229 SET_QC(); \
1230 } else { \
1231 if (s > 0xff) { \
1232 d = 0xff; \
1233 SET_QC(); \
1234 } else { \
1235 d = s; \
1236 } \
1237 res |= (uint32_t)d << (n / 2); \
1238 }
1239
1240 SAT8(0);
1241 SAT8(16);
1242 SAT8(32);
1243 SAT8(48);
1244#undef SAT8
1245 return res;
1246}
1247
ad69471c
PB		 1248uint32_t HELPER(neon_narrow_sat_u8)(CPUState *env, uint64_t x)
1249{
1250 uint16_t s;
1251 uint8_t d;
1252 uint32_t res = 0;
1253#define SAT8(n) \
1254 s = x >> n; \
1255 if (s > 0xff) { \
1256 d = 0xff; \
1257 SET_QC(); \
1258 } else { \
1259 d = s; \
1260 } \
1261 res |= (uint32_t)d << (n / 2);
1262
1263 SAT8(0);
1264 SAT8(16);
1265 SAT8(32);
1266 SAT8(48);
1267#undef SAT8
1268 return res;
1269}
1270
1271uint32_t HELPER(neon_narrow_sat_s8)(CPUState *env, uint64_t x)
1272{
1273 int16_t s;
1274 uint8_t d;
1275 uint32_t res = 0;
1276#define SAT8(n) \
1277 s = x >> n; \
1278 if (s != (int8_t)s) { \
1279 d = (s >> 15) ^ 0x7f; \
1280 SET_QC(); \
1281 } else { \
1282 d = s; \
1283 } \
1284 res |= (uint32_t)d << (n / 2);
1285
1286 SAT8(0);
1287 SAT8(16);
1288 SAT8(32);
1289 SAT8(48);
1290#undef SAT8
1291 return res;
1292}
1293
af1bbf30
JR		 1294uint32_t HELPER(neon_unarrow_sat16)(CPUState *env, uint64_t x)
1295{
1296 uint32_t high;
1297 uint32_t low;
1298 low = x;
1299 if (low & 0x80000000) {
1300 low = 0;
1301 SET_QC();
1302 } else if (low > 0xffff) {
1303 low = 0xffff;
1304 SET_QC();
1305 }
1306 high = x >> 32;
1307 if (high & 0x80000000) {
1308 high = 0;
1309 SET_QC();
1310 } else if (high > 0xffff) {
1311 high = 0xffff;
1312 SET_QC();
1313 }
1314 return low | (high << 16);
1315}
1316
ad69471c
PB		 1317uint32_t HELPER(neon_narrow_sat_u16)(CPUState *env, uint64_t x)
1318{
1319 uint32_t high;
1320 uint32_t low;
1321 low = x;
1322 if (low > 0xffff) {
1323 low = 0xffff;
1324 SET_QC();
1325 }
1326 high = x >> 32;
1327 if (high > 0xffff) {
1328 high = 0xffff;
1329 SET_QC();
1330 }
1331 return low | (high << 16);
1332}
1333
1334uint32_t HELPER(neon_narrow_sat_s16)(CPUState *env, uint64_t x)
1335{
1336 int32_t low;
1337 int32_t high;
1338 low = x;
1339 if (low != (int16_t)low) {
1340 low = (low >> 31) ^ 0x7fff;
1341 SET_QC();
1342 }
1343 high = x >> 32;
1344 if (high != (int16_t)high) {
1345 high = (high >> 31) ^ 0x7fff;
1346 SET_QC();
1347 }
1348 return (uint16_t)low | (high << 16);
1349}
1350
af1bbf30
JR		 1351uint32_t HELPER(neon_unarrow_sat32)(CPUState *env, uint64_t x)
1352{
1353 if (x & 0x8000000000000000ull) {
1354 SET_QC();
1355 return 0;
1356 }
1357 if (x > 0xffffffffu) {
1358 SET_QC();
1359 return 0xffffffffu;
1360 }
1361 return x;
1362}
1363
ad69471c
PB		 1364uint32_t HELPER(neon_narrow_sat_u32)(CPUState *env, uint64_t x)
1365{
1366 if (x > 0xffffffffu) {
1367 SET_QC();
1368 return 0xffffffffu;
1369 }
1370 return x;
1371}
1372
1373uint32_t HELPER(neon_narrow_sat_s32)(CPUState *env, uint64_t x)
1374{
1375 if ((int64_t)x != (int32_t)x) {
1376 SET_QC();
cc2212c2 1377 return ((int64_t)x >> 63) ^ 0x7fffffff;
ad69471c
PB		 1378 }
1379 return x;
1380}
1381
1382uint64_t HELPER(neon_widen_u8)(uint32_t x)
1383{
1384 uint64_t tmp;
1385 uint64_t ret;
1386 ret = (uint8_t)x;
1387 tmp = (uint8_t)(x >> 8);
1388 ret |= tmp << 16;
1389 tmp = (uint8_t)(x >> 16);
1390 ret |= tmp << 32;
1391 tmp = (uint8_t)(x >> 24);
1392 ret |= tmp << 48;
1393 return ret;
1394}
1395
1396uint64_t HELPER(neon_widen_s8)(uint32_t x)
1397{
1398 uint64_t tmp;
1399 uint64_t ret;
1400 ret = (uint16_t)(int8_t)x;
1401 tmp = (uint16_t)(int8_t)(x >> 8);
1402 ret |= tmp << 16;
1403 tmp = (uint16_t)(int8_t)(x >> 16);
1404 ret |= tmp << 32;
1405 tmp = (uint16_t)(int8_t)(x >> 24);
1406 ret |= tmp << 48;
1407 return ret;
1408}
1409
1410uint64_t HELPER(neon_widen_u16)(uint32_t x)
1411{
1412 uint64_t high = (uint16_t)(x >> 16);
1413 return ((uint16_t)x) | (high << 32);
1414}
1415
1416uint64_t HELPER(neon_widen_s16)(uint32_t x)
1417{
1418 uint64_t high = (int16_t)(x >> 16);
1419 return ((uint32_t)(int16_t)x) | (high << 32);
1420}
1421
1422uint64_t HELPER(neon_addl_u16)(uint64_t a, uint64_t b)
1423{
1424 uint64_t mask;
1425 mask = (a ^ b) & 0x8000800080008000ull;
1426 a &= ~0x8000800080008000ull;
1427 b &= ~0x8000800080008000ull;
1428 return (a + b) ^ mask;
1429}
1430
1431uint64_t HELPER(neon_addl_u32)(uint64_t a, uint64_t b)
1432{
1433 uint64_t mask;
1434 mask = (a ^ b) & 0x8000000080000000ull;
1435 a &= ~0x8000000080000000ull;
1436 b &= ~0x8000000080000000ull;
1437 return (a + b) ^ mask;
1438}
1439
1440uint64_t HELPER(neon_paddl_u16)(uint64_t a, uint64_t b)
1441{
1442 uint64_t tmp;
1443 uint64_t tmp2;
1444
1445 tmp = a & 0x0000ffff0000ffffull;
1446 tmp += (a >> 16) & 0x0000ffff0000ffffull;
1447 tmp2 = b & 0xffff0000ffff0000ull;
1448 tmp2 += (b << 16) & 0xffff0000ffff0000ull;
1449 return ( tmp & 0xffff)
1450 | ((tmp >> 16) & 0xffff0000ull)
1451 | ((tmp2 << 16) & 0xffff00000000ull)
1452 | ( tmp2 & 0xffff000000000000ull);
1453}
1454
1455uint64_t HELPER(neon_paddl_u32)(uint64_t a, uint64_t b)
1456{
1457 uint32_t low = a + (a >> 32);
1458 uint32_t high = b + (b >> 32);
1459 return low + ((uint64_t)high << 32);
1460}
1461
1462uint64_t HELPER(neon_subl_u16)(uint64_t a, uint64_t b)
1463{
1464 uint64_t mask;
1465 mask = (a ^ ~b) & 0x8000800080008000ull;
1466 a |= 0x8000800080008000ull;
1467 b &= ~0x8000800080008000ull;
1468 return (a - b) ^ mask;
1469}
1470
1471uint64_t HELPER(neon_subl_u32)(uint64_t a, uint64_t b)
1472{
1473 uint64_t mask;
1474 mask = (a ^ ~b) & 0x8000000080000000ull;
1475 a |= 0x8000000080000000ull;
1476 b &= ~0x8000000080000000ull;
1477 return (a - b) ^ mask;
1478}
1479
1480uint64_t HELPER(neon_addl_saturate_s32)(CPUState *env, uint64_t a, uint64_t b)
1481{
1482 uint32_t x, y;
1483 uint32_t low, high;
1484
1485 x = a;
1486 y = b;
1487 low = x + y;
1488 if (((low ^ x) & SIGNBIT) && !((x ^ y) & SIGNBIT)) {
1489 SET_QC();
1490 low = ((int32_t)x >> 31) ^ ~SIGNBIT;
1491 }
1492 x = a >> 32;
1493 y = b >> 32;
1494 high = x + y;
1495 if (((high ^ x) & SIGNBIT) && !((x ^ y) & SIGNBIT)) {
1496 SET_QC();
1497 high = ((int32_t)x >> 31) ^ ~SIGNBIT;
1498 }
1499 return low | ((uint64_t)high << 32);
1500}
1501
1502uint64_t HELPER(neon_addl_saturate_s64)(CPUState *env, uint64_t a, uint64_t b)
1503{
1504 uint64_t result;
1505
1506 result = a + b;
1507 if (((result ^ a) & SIGNBIT64) && !((a ^ b) & SIGNBIT64)) {
1508 SET_QC();
1509 result = ((int64_t)a >> 63) ^ ~SIGNBIT64;
1510 }
1511 return result;
1512}
1513
1514#define DO_ABD(dest, x, y, type) do { \
1515 type tmp_x = x; \
1516 type tmp_y = y; \
1517 dest = ((tmp_x > tmp_y) ? tmp_x - tmp_y : tmp_y - tmp_x); \
1518 } while(0)
1519
1520uint64_t HELPER(neon_abdl_u16)(uint32_t a, uint32_t b)
1521{
1522 uint64_t tmp;
1523 uint64_t result;
1524 DO_ABD(result, a, b, uint8_t);
1525 DO_ABD(tmp, a >> 8, b >> 8, uint8_t);
1526 result |= tmp << 16;
1527 DO_ABD(tmp, a >> 16, b >> 16, uint8_t);
1528 result |= tmp << 32;
1529 DO_ABD(tmp, a >> 24, b >> 24, uint8_t);
1530 result |= tmp << 48;
1531 return result;
1532}
1533
1534uint64_t HELPER(neon_abdl_s16)(uint32_t a, uint32_t b)
1535{
1536 uint64_t tmp;
1537 uint64_t result;
1538 DO_ABD(result, a, b, int8_t);
1539 DO_ABD(tmp, a >> 8, b >> 8, int8_t);
1540 result |= tmp << 16;
1541 DO_ABD(tmp, a >> 16, b >> 16, int8_t);
1542 result |= tmp << 32;
1543 DO_ABD(tmp, a >> 24, b >> 24, int8_t);
1544 result |= tmp << 48;
1545 return result;
1546}
1547
1548uint64_t HELPER(neon_abdl_u32)(uint32_t a, uint32_t b)
1549{
1550 uint64_t tmp;
1551 uint64_t result;
1552 DO_ABD(result, a, b, uint16_t);
1553 DO_ABD(tmp, a >> 16, b >> 16, uint16_t);
1554 return result | (tmp << 32);
1555}
1556
1557uint64_t HELPER(neon_abdl_s32)(uint32_t a, uint32_t b)
1558{
1559 uint64_t tmp;
1560 uint64_t result;
1561 DO_ABD(result, a, b, int16_t);
1562 DO_ABD(tmp, a >> 16, b >> 16, int16_t);
1563 return result | (tmp << 32);
1564}
1565
1566uint64_t HELPER(neon_abdl_u64)(uint32_t a, uint32_t b)
1567{
1568 uint64_t result;
1569 DO_ABD(result, a, b, uint32_t);
1570 return result;
1571}
1572
1573uint64_t HELPER(neon_abdl_s64)(uint32_t a, uint32_t b)
1574{
1575 uint64_t result;
1576 DO_ABD(result, a, b, int32_t);
1577 return result;
1578}
1579#undef DO_ABD
1580
1581/* Widening multiply. Named type is the source type. */
1582#define DO_MULL(dest, x, y, type1, type2) do { \
1583 type1 tmp_x = x; \
1584 type1 tmp_y = y; \
1585 dest = (type2)((type2)tmp_x * (type2)tmp_y); \
1586 } while(0)
1587
1588uint64_t HELPER(neon_mull_u8)(uint32_t a, uint32_t b)
1589{
1590 uint64_t tmp;
1591 uint64_t result;
1592
1593 DO_MULL(result, a, b, uint8_t, uint16_t);
1594 DO_MULL(tmp, a >> 8, b >> 8, uint8_t, uint16_t);
1595 result |= tmp << 16;
1596 DO_MULL(tmp, a >> 16, b >> 16, uint8_t, uint16_t);
1597 result |= tmp << 32;
1598 DO_MULL(tmp, a >> 24, b >> 24, uint8_t, uint16_t);
1599 result |= tmp << 48;
1600 return result;
1601}
1602
1603uint64_t HELPER(neon_mull_s8)(uint32_t a, uint32_t b)
1604{
1605 uint64_t tmp;
1606 uint64_t result;
1607
1608 DO_MULL(result, a, b, int8_t, uint16_t);
1609 DO_MULL(tmp, a >> 8, b >> 8, int8_t, uint16_t);
1610 result |= tmp << 16;
1611 DO_MULL(tmp, a >> 16, b >> 16, int8_t, uint16_t);
1612 result |= tmp << 32;
1613 DO_MULL(tmp, a >> 24, b >> 24, int8_t, uint16_t);
1614 result |= tmp << 48;
1615 return result;
1616}
1617
1618uint64_t HELPER(neon_mull_u16)(uint32_t a, uint32_t b)
1619{
1620 uint64_t tmp;
1621 uint64_t result;
1622
1623 DO_MULL(result, a, b, uint16_t, uint32_t);
1624 DO_MULL(tmp, a >> 16, b >> 16, uint16_t, uint32_t);
1625 return result | (tmp << 32);
1626}
1627
1628uint64_t HELPER(neon_mull_s16)(uint32_t a, uint32_t b)
1629{
1630 uint64_t tmp;
1631 uint64_t result;
1632
1633 DO_MULL(result, a, b, int16_t, uint32_t);
1634 DO_MULL(tmp, a >> 16, b >> 16, int16_t, uint32_t);
1635 return result | (tmp << 32);
1636}
1637
1638uint64_t HELPER(neon_negl_u16)(uint64_t x)
1639{
1640 uint16_t tmp;
1641 uint64_t result;
1642 result = (uint16_t)-x;
1643 tmp = -(x >> 16);
1644 result |= (uint64_t)tmp << 16;
1645 tmp = -(x >> 32);
1646 result |= (uint64_t)tmp << 32;
1647 tmp = -(x >> 48);
1648 result |= (uint64_t)tmp << 48;
1649 return result;
1650}
1651
ad69471c
PB		 1652uint64_t HELPER(neon_negl_u32)(uint64_t x)
1653{
1654 uint32_t low = -x;
1655 uint32_t high = -(x >> 32);
1656 return low | ((uint64_t)high << 32);
1657}
1658
1659/* FIXME: There should be a native op for this. */
1660uint64_t HELPER(neon_negl_u64)(uint64_t x)
1661{
1662 return -x;
1663}
1664
1665/* Saturnating sign manuipulation. */
1666/* ??? Make these use NEON_VOP1 */
1667#define DO_QABS8(x) do { \
1668 if (x == (int8_t)0x80) { \
1669 x = 0x7f; \
1670 SET_QC(); \
1671 } else if (x < 0) { \
1672 x = -x; \
1673 }} while (0)
1674uint32_t HELPER(neon_qabs_s8)(CPUState *env, uint32_t x)
1675{
1676 neon_s8 vec;
1677 NEON_UNPACK(neon_s8, vec, x);
1678 DO_QABS8(vec.v1);
1679 DO_QABS8(vec.v2);
1680 DO_QABS8(vec.v3);
1681 DO_QABS8(vec.v4);
1682 NEON_PACK(neon_s8, x, vec);
1683 return x;
1684}
1685#undef DO_QABS8
1686
1687#define DO_QNEG8(x) do { \
1688 if (x == (int8_t)0x80) { \
1689 x = 0x7f; \
1690 SET_QC(); \
1691 } else { \
1692 x = -x; \
1693 }} while (0)
1694uint32_t HELPER(neon_qneg_s8)(CPUState *env, uint32_t x)
1695{
1696 neon_s8 vec;
1697 NEON_UNPACK(neon_s8, vec, x);
1698 DO_QNEG8(vec.v1);
1699 DO_QNEG8(vec.v2);
1700 DO_QNEG8(vec.v3);
1701 DO_QNEG8(vec.v4);
1702 NEON_PACK(neon_s8, x, vec);
1703 return x;
1704}
1705#undef DO_QNEG8
1706
1707#define DO_QABS16(x) do { \
1708 if (x == (int16_t)0x8000) { \
1709 x = 0x7fff; \
1710 SET_QC(); \
1711 } else if (x < 0) { \
1712 x = -x; \
1713 }} while (0)
1714uint32_t HELPER(neon_qabs_s16)(CPUState *env, uint32_t x)
1715{
1716 neon_s16 vec;
1717 NEON_UNPACK(neon_s16, vec, x);
1718 DO_QABS16(vec.v1);
1719 DO_QABS16(vec.v2);
1720 NEON_PACK(neon_s16, x, vec);
1721 return x;
1722}
1723#undef DO_QABS16
1724
1725#define DO_QNEG16(x) do { \
1726 if (x == (int16_t)0x8000) { \
1727 x = 0x7fff; \
1728 SET_QC(); \
1729 } else { \
1730 x = -x; \
1731 }} while (0)
1732uint32_t HELPER(neon_qneg_s16)(CPUState *env, uint32_t x)
1733{
1734 neon_s16 vec;
1735 NEON_UNPACK(neon_s16, vec, x);
1736 DO_QNEG16(vec.v1);
1737 DO_QNEG16(vec.v2);
1738 NEON_PACK(neon_s16, x, vec);
1739 return x;
1740}
1741#undef DO_QNEG16
1742
1743uint32_t HELPER(neon_qabs_s32)(CPUState *env, uint32_t x)
1744{
1745 if (x == SIGNBIT) {
1746 SET_QC();
1747 x = ~SIGNBIT;
1748 } else if ((int32_t)x < 0) {
1749 x = -x;
1750 }
1751 return x;
1752}
1753
1754uint32_t HELPER(neon_qneg_s32)(CPUState *env, uint32_t x)
1755{
1756 if (x == SIGNBIT) {
1757 SET_QC();
1758 x = ~SIGNBIT;
1759 } else {
1760 x = -x;
1761 }
1762 return x;
1763}
1764
1765/* NEON Float helpers. */
1766uint32_t HELPER(neon_min_f32)(uint32_t a, uint32_t b)
1767{
1768 float32 f0 = vfp_itos(a);
1769 float32 f1 = vfp_itos(b);
1770 return (float32_compare_quiet(f0, f1, NFS) == -1) ? a : b;
1771}
1772
1773uint32_t HELPER(neon_max_f32)(uint32_t a, uint32_t b)
1774{
1775 float32 f0 = vfp_itos(a);
1776 float32 f1 = vfp_itos(b);
1777 return (float32_compare_quiet(f0, f1, NFS) == 1) ? a : b;
1778}
1779
1780uint32_t HELPER(neon_abd_f32)(uint32_t a, uint32_t b)
1781{
1782 float32 f0 = vfp_itos(a);
1783 float32 f1 = vfp_itos(b);
1784 return vfp_stoi((float32_compare_quiet(f0, f1, NFS) == 1)
1785 ? float32_sub(f0, f1, NFS)
1786 : float32_sub(f1, f0, NFS));
1787}
1788
1789uint32_t HELPER(neon_add_f32)(uint32_t a, uint32_t b)
1790{
1791 return vfp_stoi(float32_add(vfp_itos(a), vfp_itos(b), NFS));
1792}
1793
1794uint32_t HELPER(neon_sub_f32)(uint32_t a, uint32_t b)
1795{
1796 return vfp_stoi(float32_sub(vfp_itos(a), vfp_itos(b), NFS));
1797}
1798
1799uint32_t HELPER(neon_mul_f32)(uint32_t a, uint32_t b)
1800{
1801 return vfp_stoi(float32_mul(vfp_itos(a), vfp_itos(b), NFS));
1802}
1803
1804/* Floating point comparisons produce an integer result. */
1805#define NEON_VOP_FCMP(name, cmp) \
1806uint32_t HELPER(neon_##name)(uint32_t a, uint32_t b) \
1807{ \
1808 if (float32_compare_quiet(vfp_itos(a), vfp_itos(b), NFS) cmp 0) \
1809 return ~0; \
1810 else \
1811 return 0; \
1812}
1813
1814NEON_VOP_FCMP(ceq_f32, ==)
1815NEON_VOP_FCMP(cge_f32, >=)
1816NEON_VOP_FCMP(cgt_f32, >)
1817
1818uint32_t HELPER(neon_acge_f32)(uint32_t a, uint32_t b)
1819{
1820 float32 f0 = float32_abs(vfp_itos(a));
1821 float32 f1 = float32_abs(vfp_itos(b));
1822 return (float32_compare_quiet(f0, f1,NFS) >= 0) ? ~0 : 0;
1823}
1824
1825uint32_t HELPER(neon_acgt_f32)(uint32_t a, uint32_t b)
1826{
1827 float32 f0 = float32_abs(vfp_itos(a));
1828 float32 f1 = float32_abs(vfp_itos(b));
1829 return (float32_compare_quiet(f0, f1, NFS) > 0) ? ~0 : 0;
1830}
02acedf9
PM		 1831
1832#define ELEM(V, N, SIZE) (((V) >> ((N) * (SIZE))) & ((1ull << (SIZE)) - 1))
1833
1834void HELPER(neon_qunzip8)(CPUState *env, uint32_t rd, uint32_t rm)
1835{
1836 uint64_t zm0 = float64_val(env->vfp.regs[rm]);
1837 uint64_t zm1 = float64_val(env->vfp.regs[rm + 1]);
1838 uint64_t zd0 = float64_val(env->vfp.regs[rd]);
1839 uint64_t zd1 = float64_val(env->vfp.regs[rd + 1]);
1840 uint64_t d0 = ELEM(zd0, 0, 8) | (ELEM(zd0, 2, 8) << 8)
1841 | (ELEM(zd0, 4, 8) << 16) | (ELEM(zd0, 6, 8) << 24)
1842 | (ELEM(zd1, 0, 8) << 32) | (ELEM(zd1, 2, 8) << 40)
1843 | (ELEM(zd1, 4, 8) << 48) | (ELEM(zd1, 6, 8) << 56);
1844 uint64_t d1 = ELEM(zm0, 0, 8) | (ELEM(zm0, 2, 8) << 8)
1845 | (ELEM(zm0, 4, 8) << 16) | (ELEM(zm0, 6, 8) << 24)
1846 | (ELEM(zm1, 0, 8) << 32) | (ELEM(zm1, 2, 8) << 40)
1847 | (ELEM(zm1, 4, 8) << 48) | (ELEM(zm1, 6, 8) << 56);
1848 uint64_t m0 = ELEM(zd0, 1, 8) | (ELEM(zd0, 3, 8) << 8)
1849 | (ELEM(zd0, 5, 8) << 16) | (ELEM(zd0, 7, 8) << 24)
1850 | (ELEM(zd1, 1, 8) << 32) | (ELEM(zd1, 3, 8) << 40)
1851 | (ELEM(zd1, 5, 8) << 48) | (ELEM(zd1, 7, 8) << 56);
1852 uint64_t m1 = ELEM(zm0, 1, 8) | (ELEM(zm0, 3, 8) << 8)
1853 | (ELEM(zm0, 5, 8) << 16) | (ELEM(zm0, 7, 8) << 24)
1854 | (ELEM(zm1, 1, 8) << 32) | (ELEM(zm1, 3, 8) << 40)
1855 | (ELEM(zm1, 5, 8) << 48) | (ELEM(zm1, 7, 8) << 56);
1856 env->vfp.regs[rm] = make_float64(m0);
1857 env->vfp.regs[rm + 1] = make_float64(m1);
1858 env->vfp.regs[rd] = make_float64(d0);
1859 env->vfp.regs[rd + 1] = make_float64(d1);
1860}
1861
1862void HELPER(neon_qunzip16)(CPUState *env, uint32_t rd, uint32_t rm)
1863{
1864 uint64_t zm0 = float64_val(env->vfp.regs[rm]);
1865 uint64_t zm1 = float64_val(env->vfp.regs[rm + 1]);
1866 uint64_t zd0 = float64_val(env->vfp.regs[rd]);
1867 uint64_t zd1 = float64_val(env->vfp.regs[rd + 1]);
1868 uint64_t d0 = ELEM(zd0, 0, 16) | (ELEM(zd0, 2, 16) << 16)
1869 | (ELEM(zd1, 0, 16) << 32) | (ELEM(zd1, 2, 16) << 48);
1870 uint64_t d1 = ELEM(zm0, 0, 16) | (ELEM(zm0, 2, 16) << 16)
1871 | (ELEM(zm1, 0, 16) << 32) | (ELEM(zm1, 2, 16) << 48);
1872 uint64_t m0 = ELEM(zd0, 1, 16) | (ELEM(zd0, 3, 16) << 16)
1873 | (ELEM(zd1, 1, 16) << 32) | (ELEM(zd1, 3, 16) << 48);
1874 uint64_t m1 = ELEM(zm0, 1, 16) | (ELEM(zm0, 3, 16) << 16)
1875 | (ELEM(zm1, 1, 16) << 32) | (ELEM(zm1, 3, 16) << 48);
1876 env->vfp.regs[rm] = make_float64(m0);
1877 env->vfp.regs[rm + 1] = make_float64(m1);
1878 env->vfp.regs[rd] = make_float64(d0);
1879 env->vfp.regs[rd + 1] = make_float64(d1);
1880}
1881
1882void HELPER(neon_qunzip32)(CPUState *env, uint32_t rd, uint32_t rm)
1883{
1884 uint64_t zm0 = float64_val(env->vfp.regs[rm]);
1885 uint64_t zm1 = float64_val(env->vfp.regs[rm + 1]);
1886 uint64_t zd0 = float64_val(env->vfp.regs[rd]);
1887 uint64_t zd1 = float64_val(env->vfp.regs[rd + 1]);
1888 uint64_t d0 = ELEM(zd0, 0, 32) | (ELEM(zd1, 0, 32) << 32);
1889 uint64_t d1 = ELEM(zm0, 0, 32) | (ELEM(zm1, 0, 32) << 32);
1890 uint64_t m0 = ELEM(zd0, 1, 32) | (ELEM(zd1, 1, 32) << 32);
1891 uint64_t m1 = ELEM(zm0, 1, 32) | (ELEM(zm1, 1, 32) << 32);
1892 env->vfp.regs[rm] = make_float64(m0);
1893 env->vfp.regs[rm + 1] = make_float64(m1);
1894 env->vfp.regs[rd] = make_float64(d0);
1895 env->vfp.regs[rd + 1] = make_float64(d1);
1896}
1897
1898void HELPER(neon_unzip8)(CPUState *env, uint32_t rd, uint32_t rm)
1899{
1900 uint64_t zm = float64_val(env->vfp.regs[rm]);
1901 uint64_t zd = float64_val(env->vfp.regs[rd]);
1902 uint64_t d0 = ELEM(zd, 0, 8) | (ELEM(zd, 2, 8) << 8)
1903 | (ELEM(zd, 4, 8) << 16) | (ELEM(zd, 6, 8) << 24)
1904 | (ELEM(zm, 0, 8) << 32) | (ELEM(zm, 2, 8) << 40)
1905 | (ELEM(zm, 4, 8) << 48) | (ELEM(zm, 6, 8) << 56);
1906 uint64_t m0 = ELEM(zd, 1, 8) | (ELEM(zd, 3, 8) << 8)
1907 | (ELEM(zd, 5, 8) << 16) | (ELEM(zd, 7, 8) << 24)
1908 | (ELEM(zm, 1, 8) << 32) | (ELEM(zm, 3, 8) << 40)
1909 | (ELEM(zm, 5, 8) << 48) | (ELEM(zm, 7, 8) << 56);
1910 env->vfp.regs[rm] = make_float64(m0);
1911 env->vfp.regs[rd] = make_float64(d0);
1912}
1913
1914void HELPER(neon_unzip16)(CPUState *env, uint32_t rd, uint32_t rm)
1915{
1916 uint64_t zm = float64_val(env->vfp.regs[rm]);
1917 uint64_t zd = float64_val(env->vfp.regs[rd]);
1918 uint64_t d0 = ELEM(zd, 0, 16) | (ELEM(zd, 2, 16) << 16)
1919 | (ELEM(zm, 0, 16) << 32) | (ELEM(zm, 2, 16) << 48);
1920 uint64_t m0 = ELEM(zd, 1, 16) | (ELEM(zd, 3, 16) << 16)
1921 | (ELEM(zm, 1, 16) << 32) | (ELEM(zm, 3, 16) << 48);
1922 env->vfp.regs[rm] = make_float64(m0);
1923 env->vfp.regs[rd] = make_float64(d0);
1924}
d68a6f3a
PM		 1925
1926void HELPER(neon_qzip8)(CPUState *env, uint32_t rd, uint32_t rm)
1927{
1928 uint64_t zm0 = float64_val(env->vfp.regs[rm]);
1929 uint64_t zm1 = float64_val(env->vfp.regs[rm + 1]);
1930 uint64_t zd0 = float64_val(env->vfp.regs[rd]);
1931 uint64_t zd1 = float64_val(env->vfp.regs[rd + 1]);
1932 uint64_t d0 = ELEM(zd0, 0, 8) | (ELEM(zm0, 0, 8) << 8)
1933 | (ELEM(zd0, 1, 8) << 16) | (ELEM(zm0, 1, 8) << 24)
1934 | (ELEM(zd0, 2, 8) << 32) | (ELEM(zm0, 2, 8) << 40)
1935 | (ELEM(zd0, 3, 8) << 48) | (ELEM(zm0, 3, 8) << 56);
1936 uint64_t d1 = ELEM(zd0, 4, 8) | (ELEM(zm0, 4, 8) << 8)
1937 | (ELEM(zd0, 5, 8) << 16) | (ELEM(zm0, 5, 8) << 24)
1938 | (ELEM(zd0, 6, 8) << 32) | (ELEM(zm0, 6, 8) << 40)
1939 | (ELEM(zd0, 7, 8) << 48) | (ELEM(zm0, 7, 8) << 56);
1940 uint64_t m0 = ELEM(zd1, 0, 8) | (ELEM(zm1, 0, 8) << 8)
1941 | (ELEM(zd1, 1, 8) << 16) | (ELEM(zm1, 1, 8) << 24)
1942 | (ELEM(zd1, 2, 8) << 32) | (ELEM(zm1, 2, 8) << 40)
1943 | (ELEM(zd1, 3, 8) << 48) | (ELEM(zm1, 3, 8) << 56);
1944 uint64_t m1 = ELEM(zd1, 4, 8) | (ELEM(zm1, 4, 8) << 8)
1945 | (ELEM(zd1, 5, 8) << 16) | (ELEM(zm1, 5, 8) << 24)
1946 | (ELEM(zd1, 6, 8) << 32) | (ELEM(zm1, 6, 8) << 40)
1947 | (ELEM(zd1, 7, 8) << 48) | (ELEM(zm1, 7, 8) << 56);
1948 env->vfp.regs[rm] = make_float64(m0);
1949 env->vfp.regs[rm + 1] = make_float64(m1);
1950 env->vfp.regs[rd] = make_float64(d0);
1951 env->vfp.regs[rd + 1] = make_float64(d1);
1952}
1953
1954void HELPER(neon_qzip16)(CPUState *env, uint32_t rd, uint32_t rm)
1955{
1956 uint64_t zm0 = float64_val(env->vfp.regs[rm]);
1957 uint64_t zm1 = float64_val(env->vfp.regs[rm + 1]);
1958 uint64_t zd0 = float64_val(env->vfp.regs[rd]);
1959 uint64_t zd1 = float64_val(env->vfp.regs[rd + 1]);
1960 uint64_t d0 = ELEM(zd0, 0, 16) | (ELEM(zm0, 0, 16) << 16)
1961 | (ELEM(zd0, 1, 16) << 32) | (ELEM(zm0, 1, 16) << 48);
1962 uint64_t d1 = ELEM(zd0, 2, 16) | (ELEM(zm0, 2, 16) << 16)
1963 | (ELEM(zd0, 3, 16) << 32) | (ELEM(zm0, 3, 16) << 48);
1964 uint64_t m0 = ELEM(zd1, 0, 16) | (ELEM(zm1, 0, 16) << 16)
1965 | (ELEM(zd1, 1, 16) << 32) | (ELEM(zm1, 1, 16) << 48);
1966 uint64_t m1 = ELEM(zd1, 2, 16) | (ELEM(zm1, 2, 16) << 16)
1967 | (ELEM(zd1, 3, 16) << 32) | (ELEM(zm1, 3, 16) << 48);
1968 env->vfp.regs[rm] = make_float64(m0);
1969 env->vfp.regs[rm + 1] = make_float64(m1);
1970 env->vfp.regs[rd] = make_float64(d0);
1971 env->vfp.regs[rd + 1] = make_float64(d1);
1972}
1973
1974void HELPER(neon_qzip32)(CPUState *env, uint32_t rd, uint32_t rm)
1975{
1976 uint64_t zm0 = float64_val(env->vfp.regs[rm]);
1977 uint64_t zm1 = float64_val(env->vfp.regs[rm + 1]);
1978 uint64_t zd0 = float64_val(env->vfp.regs[rd]);
1979 uint64_t zd1 = float64_val(env->vfp.regs[rd + 1]);
1980 uint64_t d0 = ELEM(zd0, 0, 32) | (ELEM(zm0, 0, 32) << 32);
1981 uint64_t d1 = ELEM(zd0, 1, 32) | (ELEM(zm0, 1, 32) << 32);
1982 uint64_t m0 = ELEM(zd1, 0, 32) | (ELEM(zm1, 0, 32) << 32);
1983 uint64_t m1 = ELEM(zd1, 1, 32) | (ELEM(zm1, 1, 32) << 32);
1984 env->vfp.regs[rm] = make_float64(m0);
1985 env->vfp.regs[rm + 1] = make_float64(m1);
1986 env->vfp.regs[rd] = make_float64(d0);
1987 env->vfp.regs[rd + 1] = make_float64(d1);
1988}
1989
1990void HELPER(neon_zip8)(CPUState *env, uint32_t rd, uint32_t rm)
1991{
1992 uint64_t zm = float64_val(env->vfp.regs[rm]);
1993 uint64_t zd = float64_val(env->vfp.regs[rd]);
1994 uint64_t d0 = ELEM(zd, 0, 8) | (ELEM(zm, 0, 8) << 8)
1995 | (ELEM(zd, 1, 8) << 16) | (ELEM(zm, 1, 8) << 24)
1996 | (ELEM(zd, 2, 8) << 32) | (ELEM(zm, 2, 8) << 40)
1997 | (ELEM(zd, 3, 8) << 48) | (ELEM(zm, 3, 8) << 56);
1998 uint64_t m0 = ELEM(zd, 4, 8) | (ELEM(zm, 4, 8) << 8)
1999 | (ELEM(zd, 5, 8) << 16) | (ELEM(zm, 5, 8) << 24)
2000 | (ELEM(zd, 6, 8) << 32) | (ELEM(zm, 6, 8) << 40)
2001 | (ELEM(zd, 7, 8) << 48) | (ELEM(zm, 7, 8) << 56);
2002 env->vfp.regs[rm] = make_float64(m0);
2003 env->vfp.regs[rd] = make_float64(d0);
2004}
2005
2006void HELPER(neon_zip16)(CPUState *env, uint32_t rd, uint32_t rm)
2007{
2008 uint64_t zm = float64_val(env->vfp.regs[rm]);
2009 uint64_t zd = float64_val(env->vfp.regs[rd]);
2010 uint64_t d0 = ELEM(zd, 0, 16) | (ELEM(zm, 0, 16) << 16)
2011 | (ELEM(zd, 1, 16) << 32) | (ELEM(zm, 1, 16) << 48);
2012 uint64_t m0 = ELEM(zd, 2, 16) | (ELEM(zm, 2, 16) << 16)
2013 | (ELEM(zd, 3, 16) << 32) | (ELEM(zm, 3, 16) << 48);
2014 env->vfp.regs[rm] = make_float64(m0);
2015 env->vfp.regs[rd] = make_float64(d0);
2016}
Qemu copy for testing