]> 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 VQSHL of signed 64 bit values by shift counts >= 64
[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
201#define NEON_SSAT(dest, src1, src2, type) do { \
202 int32_t tmp = (uint32_t)src1 + (uint32_t)src2; \
203 if (tmp != (type)tmp) { \
204 SET_QC(); \
205 if (src2 > 0) { \
206 tmp = (1 << (sizeof(type) * 8 - 1)) - 1; \
207 } else { \
208 tmp = 1 << (sizeof(type) * 8 - 1); \
209 } \
210 } \
211 dest = tmp; \
212 } while(0)
213#define NEON_FN(dest, src1, src2) NEON_SSAT(dest, src1, src2, int8_t)
214NEON_VOP_ENV(qadd_s8, neon_s8, 4)
215#undef NEON_FN
216#define NEON_FN(dest, src1, src2) NEON_SSAT(dest, src1, src2, int16_t)
217NEON_VOP_ENV(qadd_s16, neon_s16, 2)
218#undef NEON_FN
219#undef NEON_SSAT
220
221#define NEON_USAT(dest, src1, src2, type) do { \
222 uint32_t tmp = (uint32_t)src1 - (uint32_t)src2; \
223 if (tmp != (type)tmp) { \
224 SET_QC(); \
225 dest = 0; \
226 } else { \
227 dest = tmp; \
228 }} while(0)
229#define NEON_FN(dest, src1, src2) NEON_USAT(dest, src1, src2, uint8_t)
230NEON_VOP_ENV(qsub_u8, neon_u8, 4)
231#undef NEON_FN
232#define NEON_FN(dest, src1, src2) NEON_USAT(dest, src1, src2, uint16_t)
233NEON_VOP_ENV(qsub_u16, neon_u16, 2)
234#undef NEON_FN
235#undef NEON_USAT
236
237#define NEON_SSAT(dest, src1, src2, type) do { \
238 int32_t tmp = (uint32_t)src1 - (uint32_t)src2; \
239 if (tmp != (type)tmp) { \
240 SET_QC(); \
241 if (src2 < 0) { \
242 tmp = (1 << (sizeof(type) * 8 - 1)) - 1; \
243 } else { \
244 tmp = 1 << (sizeof(type) * 8 - 1); \
245 } \
246 } \
247 dest = tmp; \
248 } while(0)
249#define NEON_FN(dest, src1, src2) NEON_SSAT(dest, src1, src2, int8_t)
250NEON_VOP_ENV(qsub_s8, neon_s8, 4)
251#undef NEON_FN
252#define NEON_FN(dest, src1, src2) NEON_SSAT(dest, src1, src2, int16_t)
253NEON_VOP_ENV(qsub_s16, neon_s16, 2)
254#undef NEON_FN
255#undef NEON_SSAT
256
257#define NEON_FN(dest, src1, src2) dest = (src1 + src2) >> 1
258NEON_VOP(hadd_s8, neon_s8, 4)
259NEON_VOP(hadd_u8, neon_u8, 4)
260NEON_VOP(hadd_s16, neon_s16, 2)
261NEON_VOP(hadd_u16, neon_u16, 2)
262#undef NEON_FN
263
264int32_t HELPER(neon_hadd_s32)(int32_t src1, int32_t src2)
265{
266 int32_t dest;
267
268 dest = (src1 >> 1) + (src2 >> 1);
269 if (src1 & src2 & 1)
270 dest++;
271 return dest;
272}
273
274uint32_t HELPER(neon_hadd_u32)(uint32_t src1, uint32_t src2)
275{
276 uint32_t dest;
277
278 dest = (src1 >> 1) + (src2 >> 1);
279 if (src1 & src2 & 1)
280 dest++;
281 return dest;
282}
283
284#define NEON_FN(dest, src1, src2) dest = (src1 + src2 + 1) >> 1
285NEON_VOP(rhadd_s8, neon_s8, 4)
286NEON_VOP(rhadd_u8, neon_u8, 4)
287NEON_VOP(rhadd_s16, neon_s16, 2)
288NEON_VOP(rhadd_u16, neon_u16, 2)
289#undef NEON_FN
290
291int32_t HELPER(neon_rhadd_s32)(int32_t src1, int32_t src2)
292{
293 int32_t dest;
294
295 dest = (src1 >> 1) + (src2 >> 1);
296 if ((src1 | src2) & 1)
297 dest++;
298 return dest;
299}
300
301uint32_t HELPER(neon_rhadd_u32)(uint32_t src1, uint32_t src2)
302{
303 uint32_t dest;
304
305 dest = (src1 >> 1) + (src2 >> 1);
306 if ((src1 | src2) & 1)
307 dest++;
308 return dest;
309}
310
311#define NEON_FN(dest, src1, src2) dest = (src1 - src2) >> 1
312NEON_VOP(hsub_s8, neon_s8, 4)
313NEON_VOP(hsub_u8, neon_u8, 4)
314NEON_VOP(hsub_s16, neon_s16, 2)
315NEON_VOP(hsub_u16, neon_u16, 2)
316#undef NEON_FN
317
318int32_t HELPER(neon_hsub_s32)(int32_t src1, int32_t src2)
319{
320 int32_t dest;
321
322 dest = (src1 >> 1) - (src2 >> 1);
323 if ((~src1) & src2 & 1)
324 dest--;
325 return dest;
326}
327
328uint32_t HELPER(neon_hsub_u32)(uint32_t src1, uint32_t src2)
329{
330 uint32_t dest;
331
332 dest = (src1 >> 1) - (src2 >> 1);
333 if ((~src1) & src2 & 1)
334 dest--;
335 return dest;
336}
337
338#define NEON_FN(dest, src1, src2) dest = (src1 > src2) ? ~0 : 0
339NEON_VOP(cgt_s8, neon_s8, 4)
340NEON_VOP(cgt_u8, neon_u8, 4)
341NEON_VOP(cgt_s16, neon_s16, 2)
342NEON_VOP(cgt_u16, neon_u16, 2)
343NEON_VOP(cgt_s32, neon_s32, 1)
344NEON_VOP(cgt_u32, neon_u32, 1)
345#undef NEON_FN
346
347#define NEON_FN(dest, src1, src2) dest = (src1 >= src2) ? ~0 : 0
348NEON_VOP(cge_s8, neon_s8, 4)
349NEON_VOP(cge_u8, neon_u8, 4)
350NEON_VOP(cge_s16, neon_s16, 2)
351NEON_VOP(cge_u16, neon_u16, 2)
352NEON_VOP(cge_s32, neon_s32, 1)
353NEON_VOP(cge_u32, neon_u32, 1)
354#undef NEON_FN
355
356#define NEON_FN(dest, src1, src2) dest = (src1 < src2) ? src1 : src2
357NEON_VOP(min_s8, neon_s8, 4)
358NEON_VOP(min_u8, neon_u8, 4)
359NEON_VOP(min_s16, neon_s16, 2)
360NEON_VOP(min_u16, neon_u16, 2)
361NEON_VOP(min_s32, neon_s32, 1)
362NEON_VOP(min_u32, neon_u32, 1)
363NEON_POP(pmin_s8, neon_s8, 4)
364NEON_POP(pmin_u8, neon_u8, 4)
365NEON_POP(pmin_s16, neon_s16, 2)
366NEON_POP(pmin_u16, neon_u16, 2)
367#undef NEON_FN
368
369#define NEON_FN(dest, src1, src2) dest = (src1 > src2) ? src1 : src2
370NEON_VOP(max_s8, neon_s8, 4)
371NEON_VOP(max_u8, neon_u8, 4)
372NEON_VOP(max_s16, neon_s16, 2)
373NEON_VOP(max_u16, neon_u16, 2)
374NEON_VOP(max_s32, neon_s32, 1)
375NEON_VOP(max_u32, neon_u32, 1)
376NEON_POP(pmax_s8, neon_s8, 4)
377NEON_POP(pmax_u8, neon_u8, 4)
378NEON_POP(pmax_s16, neon_s16, 2)
379NEON_POP(pmax_u16, neon_u16, 2)
380#undef NEON_FN
381
382#define NEON_FN(dest, src1, src2) \
383 dest = (src1 > src2) ? (src1 - src2) : (src2 - src1)
384NEON_VOP(abd_s8, neon_s8, 4)
385NEON_VOP(abd_u8, neon_u8, 4)
386NEON_VOP(abd_s16, neon_s16, 2)
387NEON_VOP(abd_u16, neon_u16, 2)
388NEON_VOP(abd_s32, neon_s32, 1)
389NEON_VOP(abd_u32, neon_u32, 1)
390#undef NEON_FN
391
392#define NEON_FN(dest, src1, src2) do { \
393 int8_t tmp; \
394 tmp = (int8_t)src2; \
50f67e95
JR		 395 if (tmp >= (ssize_t)sizeof(src1) * 8 || \
396 tmp <= -(ssize_t)sizeof(src1) * 8) { \
ad69471c
PB		 397 dest = 0; \
398 } else if (tmp < 0) { \
399 dest = src1 >> -tmp; \
400 } else { \
401 dest = src1 << tmp; \
402 }} while (0)
403NEON_VOP(shl_u8, neon_u8, 4)
404NEON_VOP(shl_u16, neon_u16, 2)
405NEON_VOP(shl_u32, neon_u32, 1)
406#undef NEON_FN
407
408uint64_t HELPER(neon_shl_u64)(uint64_t val, uint64_t shiftop)
409{
410 int8_t shift = (int8_t)shiftop;
411 if (shift >= 64 || shift <= -64) {
412 val = 0;
413 } else if (shift < 0) {
414 val >>= -shift;
415 } else {
416 val <<= shift;
417 }
418 return val;
419}
420
421#define NEON_FN(dest, src1, src2) do { \
422 int8_t tmp; \
423 tmp = (int8_t)src2; \
50f67e95 424 if (tmp >= (ssize_t)sizeof(src1) * 8) { \
ad69471c 425 dest = 0; \
50f67e95 426 } else if (tmp <= -(ssize_t)sizeof(src1) * 8) { \
ad69471c
PB		 427 dest = src1 >> (sizeof(src1) * 8 - 1); \
428 } else if (tmp < 0) { \
429 dest = src1 >> -tmp; \
430 } else { \
431 dest = src1 << tmp; \
432 }} while (0)
433NEON_VOP(shl_s8, neon_s8, 4)
434NEON_VOP(shl_s16, neon_s16, 2)
435NEON_VOP(shl_s32, neon_s32, 1)
436#undef NEON_FN
437
438uint64_t HELPER(neon_shl_s64)(uint64_t valop, uint64_t shiftop)
439{
440 int8_t shift = (int8_t)shiftop;
441 int64_t val = valop;
442 if (shift >= 64) {
443 val = 0;
444 } else if (shift <= -64) {
445 val >>= 63;
446 } else if (shift < 0) {
447 val >>= -shift;
448 } else {
449 val <<= shift;
450 }
451 return val;
452}
453
454#define NEON_FN(dest, src1, src2) do { \
455 int8_t tmp; \
456 tmp = (int8_t)src2; \
50f67e95 457 if (tmp >= (ssize_t)sizeof(src1) * 8) { \
ad69471c 458 dest = 0; \
50f67e95 459 } else if (tmp < -(ssize_t)sizeof(src1) * 8) { \
cb76e138 460 dest = src1 >> (sizeof(src1) * 8 - 1); \
50f67e95 461 } else if (tmp == -(ssize_t)sizeof(src1) * 8) { \
ad69471c
PB		 462 dest = src1 >> (tmp - 1); \
463 dest++; \
cb76e138 464 dest >>= 1; \
ad69471c
PB		 465 } else if (tmp < 0) { \
466 dest = (src1 + (1 << (-1 - tmp))) >> -tmp; \
467 } else { \
468 dest = src1 << tmp; \
469 }} while (0)
470NEON_VOP(rshl_s8, neon_s8, 4)
471NEON_VOP(rshl_s16, neon_s16, 2)
472NEON_VOP(rshl_s32, neon_s32, 1)
473#undef NEON_FN
474
475uint64_t HELPER(neon_rshl_s64)(uint64_t valop, uint64_t shiftop)
476{
477 int8_t shift = (int8_t)shiftop;
478 int64_t val = valop;
479 if (shift >= 64) {
480 val = 0;
481 } else if (shift < -64) {
482 val >>= 63;
483 } else if (shift == -63) {
484 val >>= 63;
485 val++;
486 val >>= 1;
487 } else if (shift < 0) {
488 val = (val + ((int64_t)1 << (-1 - shift))) >> -shift;
489 } else {
490 val <<= shift;
491 }
492 return val;
493}
494
495#define NEON_FN(dest, src1, src2) do { \
496 int8_t tmp; \
497 tmp = (int8_t)src2; \
50f67e95
JR		 498 if (tmp >= (ssize_t)sizeof(src1) * 8 || \
499 tmp < -(ssize_t)sizeof(src1) * 8) { \
ad69471c 500 dest = 0; \
50f67e95 501 } else if (tmp == -(ssize_t)sizeof(src1) * 8) { \
ad69471c
PB		 502 dest = src1 >> (tmp - 1); \
503 } else if (tmp < 0) { \
504 dest = (src1 + (1 << (-1 - tmp))) >> -tmp; \
505 } else { \
506 dest = src1 << tmp; \
507 }} while (0)
508NEON_VOP(rshl_u8, neon_u8, 4)
509NEON_VOP(rshl_u16, neon_u16, 2)
510NEON_VOP(rshl_u32, neon_u32, 1)
511#undef NEON_FN
512
513uint64_t HELPER(neon_rshl_u64)(uint64_t val, uint64_t shiftop)
514{
515 int8_t shift = (uint8_t)shiftop;
516 if (shift >= 64 || shift < 64) {
517 val = 0;
518 } else if (shift == -64) {
519 /* Rounding a 1-bit result just preserves that bit. */
520 val >>= 63;
521 } if (shift < 0) {
522 val = (val + ((uint64_t)1 << (-1 - shift))) >> -shift;
523 val >>= -shift;
524 } else {
525 val <<= shift;
526 }
527 return val;
528}
529
530#define NEON_FN(dest, src1, src2) do { \
531 int8_t tmp; \
532 tmp = (int8_t)src2; \
50f67e95 533 if (tmp >= (ssize_t)sizeof(src1) * 8) { \
ad69471c
PB		 534 if (src1) { \
535 SET_QC(); \
536 dest = ~0; \
537 } else { \
538 dest = 0; \
539 } \
50f67e95 540 } else if (tmp <= -(ssize_t)sizeof(src1) * 8) { \
ad69471c
PB		 541 dest = 0; \
542 } else if (tmp < 0) { \
543 dest = src1 >> -tmp; \
544 } else { \
545 dest = src1 << tmp; \
546 if ((dest >> tmp) != src1) { \
547 SET_QC(); \
548 dest = ~0; \
549 } \
550 }} while (0)
551NEON_VOP_ENV(qshl_u8, neon_u8, 4)
552NEON_VOP_ENV(qshl_u16, neon_u16, 2)
553NEON_VOP_ENV(qshl_u32, neon_u32, 1)
554#undef NEON_FN
555
556uint64_t HELPER(neon_qshl_u64)(CPUState *env, uint64_t val, uint64_t shiftop)
557{
558 int8_t shift = (int8_t)shiftop;
559 if (shift >= 64) {
560 if (val) {
561 val = ~(uint64_t)0;
562 SET_QC();
563 } else {
564 val = 0;
565 }
566 } else if (shift <= -64) {
567 val = 0;
568 } else if (shift < 0) {
569 val >>= -shift;
570 } else {
571 uint64_t tmp = val;
572 val <<= shift;
573 if ((val >> shift) != tmp) {
574 SET_QC();
575 val = ~(uint64_t)0;
576 }
577 }
578 return val;
579}
580
581#define NEON_FN(dest, src1, src2) do { \
582 int8_t tmp; \
583 tmp = (int8_t)src2; \
50f67e95 584 if (tmp >= (ssize_t)sizeof(src1) * 8) { \
ad69471c
PB		 585 if (src1) \
586 SET_QC(); \
587 dest = src1 >> 31; \
50f67e95 588 } else if (tmp <= -(ssize_t)sizeof(src1) * 8) { \
ad69471c
PB		 589 dest = src1 >> 31; \
590 } else if (tmp < 0) { \
591 dest = src1 >> -tmp; \
592 } else { \
593 dest = src1 << tmp; \
594 if ((dest >> tmp) != src1) { \
595 SET_QC(); \
596 dest = src2 >> 31; \
597 } \
598 }} while (0)
599NEON_VOP_ENV(qshl_s8, neon_s8, 4)
600NEON_VOP_ENV(qshl_s16, neon_s16, 2)
601NEON_VOP_ENV(qshl_s32, neon_s32, 1)
602#undef NEON_FN
603
604uint64_t HELPER(neon_qshl_s64)(CPUState *env, uint64_t valop, uint64_t shiftop)
605{
606 int8_t shift = (uint8_t)shiftop;
607 int64_t val = valop;
608 if (shift >= 64) {
609 if (val) {
610 SET_QC();
eb7a3d79 611 val = (val >> 63) ^ ~SIGNBIT64;
ad69471c 612 }
4c9b70ae 613 } else if (shift <= -64) {
ad69471c
PB		 614 val >>= 63;
615 } else if (shift < 0) {
616 val >>= -shift;
617 } else {
618 int64_t tmp = val;
619 val <<= shift;
620 if ((val >> shift) != tmp) {
621 SET_QC();
622 val = (tmp >> 63) ^ ~SIGNBIT64;
623 }
624 }
625 return val;
626}
627
628
629/* FIXME: This is wrong. */
630#define NEON_FN(dest, src1, src2) do { \
631 int8_t tmp; \
632 tmp = (int8_t)src2; \
633 if (tmp < 0) { \
634 dest = (src1 + (1 << (-1 - tmp))) >> -tmp; \
635 } else { \
636 dest = src1 << tmp; \
637 if ((dest >> tmp) != src1) { \
638 SET_QC(); \
639 dest = ~0; \
640 } \
641 }} while (0)
642NEON_VOP_ENV(qrshl_u8, neon_u8, 4)
643NEON_VOP_ENV(qrshl_u16, neon_u16, 2)
644NEON_VOP_ENV(qrshl_u32, neon_u32, 1)
645#undef NEON_FN
646
647uint64_t HELPER(neon_qrshl_u64)(CPUState *env, uint64_t val, uint64_t shiftop)
648{
649 int8_t shift = (int8_t)shiftop;
650 if (shift < 0) {
651 val = (val + (1 << (-1 - shift))) >> -shift;
652 } else { \
653 uint64_t tmp = val;
654 val <<= shift;
655 if ((val >> shift) != tmp) {
656 SET_QC();
657 val = ~0;
658 }
659 }
660 return val;
661}
662
663#define NEON_FN(dest, src1, src2) do { \
664 int8_t tmp; \
665 tmp = (int8_t)src2; \
666 if (tmp < 0) { \
667 dest = (src1 + (1 << (-1 - tmp))) >> -tmp; \
668 } else { \
669 dest = src1 << tmp; \
670 if ((dest >> tmp) != src1) { \
671 SET_QC(); \
672 dest = src1 >> 31; \
673 } \
674 }} while (0)
675NEON_VOP_ENV(qrshl_s8, neon_s8, 4)
676NEON_VOP_ENV(qrshl_s16, neon_s16, 2)
677NEON_VOP_ENV(qrshl_s32, neon_s32, 1)
678#undef NEON_FN
679
680uint64_t HELPER(neon_qrshl_s64)(CPUState *env, uint64_t valop, uint64_t shiftop)
681{
682 int8_t shift = (uint8_t)shiftop;
683 int64_t val = valop;
684
685 if (shift < 0) {
686 val = (val + (1 << (-1 - shift))) >> -shift;
687 } else {
688 int64_t tmp = val;;
689 val <<= shift;
690 if ((val >> shift) != tmp) {
691 SET_QC();
692 val = tmp >> 31;
693 }
694 }
695 return val;
696}
697
698uint32_t HELPER(neon_add_u8)(uint32_t a, uint32_t b)
699{
700 uint32_t mask;
701 mask = (a ^ b) & 0x80808080u;
702 a &= ~0x80808080u;
703 b &= ~0x80808080u;
704 return (a + b) ^ mask;
705}
706
707uint32_t HELPER(neon_add_u16)(uint32_t a, uint32_t b)
708{
709 uint32_t mask;
710 mask = (a ^ b) & 0x80008000u;
711 a &= ~0x80008000u;
712 b &= ~0x80008000u;
713 return (a + b) ^ mask;
714}
715
716#define NEON_FN(dest, src1, src2) dest = src1 + src2
717NEON_POP(padd_u8, neon_u8, 4)
718NEON_POP(padd_u16, neon_u16, 2)
719#undef NEON_FN
720
721#define NEON_FN(dest, src1, src2) dest = src1 - src2
722NEON_VOP(sub_u8, neon_u8, 4)
723NEON_VOP(sub_u16, neon_u16, 2)
724#undef NEON_FN
725
726#define NEON_FN(dest, src1, src2) dest = src1 * src2
727NEON_VOP(mul_u8, neon_u8, 4)
728NEON_VOP(mul_u16, neon_u16, 2)
729#undef NEON_FN
730
1654b2d6 731/* Polynomial multiplication is like integer multiplication except the
ad69471c
PB		 732 partial products are XORed, not added. */
733uint32_t HELPER(neon_mul_p8)(uint32_t op1, uint32_t op2)
734{
735 uint32_t mask;
736 uint32_t result;
737 result = 0;
738 while (op1) {
739 mask = 0;
740 if (op1 & 1)
741 mask |= 0xff;
742 if (op1 & (1 << 8))
743 mask |= (0xff << 8);
744 if (op1 & (1 << 16))
745 mask |= (0xff << 16);
746 if (op1 & (1 << 24))
747 mask |= (0xff << 24);
748 result ^= op2 & mask;
749 op1 = (op1 >> 1) & 0x7f7f7f7f;
750 op2 = (op2 << 1) & 0xfefefefe;
751 }
752 return result;
753}
754
755#define NEON_FN(dest, src1, src2) dest = (src1 & src2) ? -1 : 0
756NEON_VOP(tst_u8, neon_u8, 4)
757NEON_VOP(tst_u16, neon_u16, 2)
758NEON_VOP(tst_u32, neon_u32, 1)
759#undef NEON_FN
760
761#define NEON_FN(dest, src1, src2) dest = (src1 == src2) ? -1 : 0
762NEON_VOP(ceq_u8, neon_u8, 4)
763NEON_VOP(ceq_u16, neon_u16, 2)
764NEON_VOP(ceq_u32, neon_u32, 1)
765#undef NEON_FN
766
767#define NEON_FN(dest, src, dummy) dest = (src < 0) ? -src : src
768NEON_VOP1(abs_s8, neon_s8, 4)
769NEON_VOP1(abs_s16, neon_s16, 2)
770#undef NEON_FN
771
772/* Count Leading Sign/Zero Bits. */
773static inline int do_clz8(uint8_t x)
774{
775 int n;
776 for (n = 8; x; n--)
777 x >>= 1;
778 return n;
779}
780
781static inline int do_clz16(uint16_t x)
782{
783 int n;
784 for (n = 16; x; n--)
785 x >>= 1;
786 return n;
787}
788
789#define NEON_FN(dest, src, dummy) dest = do_clz8(src)
790NEON_VOP1(clz_u8, neon_u8, 4)
791#undef NEON_FN
792
793#define NEON_FN(dest, src, dummy) dest = do_clz16(src)
794NEON_VOP1(clz_u16, neon_u16, 2)
795#undef NEON_FN
796
797#define NEON_FN(dest, src, dummy) dest = do_clz8((src < 0) ? ~src : src) - 1
798NEON_VOP1(cls_s8, neon_s8, 4)
799#undef NEON_FN
800
801#define NEON_FN(dest, src, dummy) dest = do_clz16((src < 0) ? ~src : src) - 1
802NEON_VOP1(cls_s16, neon_s16, 2)
803#undef NEON_FN
804
805uint32_t HELPER(neon_cls_s32)(uint32_t x)
806{
807 int count;
808 if ((int32_t)x < 0)
809 x = ~x;
810 for (count = 32; x; count--)
811 x = x >> 1;
812 return count - 1;
813}
814
815/* Bit count. */
816uint32_t HELPER(neon_cnt_u8)(uint32_t x)
817{
818 x = (x & 0x55555555) + ((x >> 1) & 0x55555555);
819 x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
820 x = (x & 0x0f0f0f0f) + ((x >> 4) & 0x0f0f0f0f);
821 return x;
822}
823
824#define NEON_QDMULH16(dest, src1, src2, round) do { \
825 uint32_t tmp = (int32_t)(int16_t) src1 * (int16_t) src2; \
826 if ((tmp ^ (tmp << 1)) & SIGNBIT) { \
827 SET_QC(); \
828 tmp = (tmp >> 31) ^ ~SIGNBIT; \
829 } \
830 tmp <<= 1; \
831 if (round) { \
832 int32_t old = tmp; \
833 tmp += 1 << 15; \
834 if ((int32_t)tmp < old) { \
835 SET_QC(); \
836 tmp = SIGNBIT - 1; \
837 } \
838 } \
839 dest = tmp >> 16; \
840 } while(0)
841#define NEON_FN(dest, src1, src2) NEON_QDMULH16(dest, src1, src2, 0)
842NEON_VOP_ENV(qdmulh_s16, neon_s16, 2)
843#undef NEON_FN
844#define NEON_FN(dest, src1, src2) NEON_QDMULH16(dest, src1, src2, 1)
845NEON_VOP_ENV(qrdmulh_s16, neon_s16, 2)
846#undef NEON_FN
847#undef NEON_QDMULH16
848
849#define NEON_QDMULH32(dest, src1, src2, round) do { \
850 uint64_t tmp = (int64_t)(int32_t) src1 * (int32_t) src2; \
851 if ((tmp ^ (tmp << 1)) & SIGNBIT64) { \
852 SET_QC(); \
853 tmp = (tmp >> 63) ^ ~SIGNBIT64; \
854 } else { \
855 tmp <<= 1; \
856 } \
857 if (round) { \
858 int64_t old = tmp; \
859 tmp += (int64_t)1 << 31; \
860 if ((int64_t)tmp < old) { \
861 SET_QC(); \
862 tmp = SIGNBIT64 - 1; \
863 } \
864 } \
865 dest = tmp >> 32; \
866 } while(0)
867#define NEON_FN(dest, src1, src2) NEON_QDMULH32(dest, src1, src2, 0)
868NEON_VOP_ENV(qdmulh_s32, neon_s32, 1)
869#undef NEON_FN
870#define NEON_FN(dest, src1, src2) NEON_QDMULH32(dest, src1, src2, 1)
871NEON_VOP_ENV(qrdmulh_s32, neon_s32, 1)
872#undef NEON_FN
873#undef NEON_QDMULH32
874
875uint32_t HELPER(neon_narrow_u8)(uint64_t x)
876{
877 return (x & 0xffu) | ((x >> 8) & 0xff00u) | ((x >> 16) & 0xff0000u)
878 | ((x >> 24) & 0xff000000u);
879}
880
881uint32_t HELPER(neon_narrow_u16)(uint64_t x)
882{
883 return (x & 0xffffu) | ((x >> 16) & 0xffff0000u);
884}
885
886uint32_t HELPER(neon_narrow_high_u8)(uint64_t x)
887{
888 return ((x >> 8) & 0xff) | ((x >> 16) & 0xff00)
889 | ((x >> 24) & 0xff0000) | ((x >> 32) & 0xff000000);
890}
891
892uint32_t HELPER(neon_narrow_high_u16)(uint64_t x)
893{
894 return ((x >> 16) & 0xffff) | ((x >> 32) & 0xffff0000);
895}
896
897uint32_t HELPER(neon_narrow_round_high_u8)(uint64_t x)
898{
899 x &= 0xff80ff80ff80ff80ull;
900 x += 0x0080008000800080ull;
901 return ((x >> 8) & 0xff) | ((x >> 16) & 0xff00)
902 | ((x >> 24) & 0xff0000) | ((x >> 32) & 0xff000000);
903}
904
905uint32_t HELPER(neon_narrow_round_high_u16)(uint64_t x)
906{
907 x &= 0xffff8000ffff8000ull;
908 x += 0x0000800000008000ull;
909 return ((x >> 16) & 0xffff) | ((x >> 32) & 0xffff0000);
910}
911
912uint32_t HELPER(neon_narrow_sat_u8)(CPUState *env, uint64_t x)
913{
914 uint16_t s;
915 uint8_t d;
916 uint32_t res = 0;
917#define SAT8(n) \
918 s = x >> n; \
919 if (s > 0xff) { \
920 d = 0xff; \
921 SET_QC(); \
922 } else { \
923 d = s; \
924 } \
925 res |= (uint32_t)d << (n / 2);
926
927 SAT8(0);
928 SAT8(16);
929 SAT8(32);
930 SAT8(48);
931#undef SAT8
932 return res;
933}
934
935uint32_t HELPER(neon_narrow_sat_s8)(CPUState *env, uint64_t x)
936{
937 int16_t s;
938 uint8_t d;
939 uint32_t res = 0;
940#define SAT8(n) \
941 s = x >> n; \
942 if (s != (int8_t)s) { \
943 d = (s >> 15) ^ 0x7f; \
944 SET_QC(); \
945 } else { \
946 d = s; \
947 } \
948 res |= (uint32_t)d << (n / 2);
949
950 SAT8(0);
951 SAT8(16);
952 SAT8(32);
953 SAT8(48);
954#undef SAT8
955 return res;
956}
957
958uint32_t HELPER(neon_narrow_sat_u16)(CPUState *env, uint64_t x)
959{
960 uint32_t high;
961 uint32_t low;
962 low = x;
963 if (low > 0xffff) {
964 low = 0xffff;
965 SET_QC();
966 }
967 high = x >> 32;
968 if (high > 0xffff) {
969 high = 0xffff;
970 SET_QC();
971 }
972 return low | (high << 16);
973}
974
975uint32_t HELPER(neon_narrow_sat_s16)(CPUState *env, uint64_t x)
976{
977 int32_t low;
978 int32_t high;
979 low = x;
980 if (low != (int16_t)low) {
981 low = (low >> 31) ^ 0x7fff;
982 SET_QC();
983 }
984 high = x >> 32;
985 if (high != (int16_t)high) {
986 high = (high >> 31) ^ 0x7fff;
987 SET_QC();
988 }
989 return (uint16_t)low | (high << 16);
990}
991
992uint32_t HELPER(neon_narrow_sat_u32)(CPUState *env, uint64_t x)
993{
994 if (x > 0xffffffffu) {
995 SET_QC();
996 return 0xffffffffu;
997 }
998 return x;
999}
1000
1001uint32_t HELPER(neon_narrow_sat_s32)(CPUState *env, uint64_t x)
1002{
1003 if ((int64_t)x != (int32_t)x) {
1004 SET_QC();
1005 return (x >> 63) ^ 0x7fffffff;
1006 }
1007 return x;
1008}
1009
1010uint64_t HELPER(neon_widen_u8)(uint32_t x)
1011{
1012 uint64_t tmp;
1013 uint64_t ret;
1014 ret = (uint8_t)x;
1015 tmp = (uint8_t)(x >> 8);
1016 ret |= tmp << 16;
1017 tmp = (uint8_t)(x >> 16);
1018 ret |= tmp << 32;
1019 tmp = (uint8_t)(x >> 24);
1020 ret |= tmp << 48;
1021 return ret;
1022}
1023
1024uint64_t HELPER(neon_widen_s8)(uint32_t x)
1025{
1026 uint64_t tmp;
1027 uint64_t ret;
1028 ret = (uint16_t)(int8_t)x;
1029 tmp = (uint16_t)(int8_t)(x >> 8);
1030 ret |= tmp << 16;
1031 tmp = (uint16_t)(int8_t)(x >> 16);
1032 ret |= tmp << 32;
1033 tmp = (uint16_t)(int8_t)(x >> 24);
1034 ret |= tmp << 48;
1035 return ret;
1036}
1037
1038uint64_t HELPER(neon_widen_u16)(uint32_t x)
1039{
1040 uint64_t high = (uint16_t)(x >> 16);
1041 return ((uint16_t)x) | (high << 32);
1042}
1043
1044uint64_t HELPER(neon_widen_s16)(uint32_t x)
1045{
1046 uint64_t high = (int16_t)(x >> 16);
1047 return ((uint32_t)(int16_t)x) | (high << 32);
1048}
1049
1050uint64_t HELPER(neon_addl_u16)(uint64_t a, uint64_t b)
1051{
1052 uint64_t mask;
1053 mask = (a ^ b) & 0x8000800080008000ull;
1054 a &= ~0x8000800080008000ull;
1055 b &= ~0x8000800080008000ull;
1056 return (a + b) ^ mask;
1057}
1058
1059uint64_t HELPER(neon_addl_u32)(uint64_t a, uint64_t b)
1060{
1061 uint64_t mask;
1062 mask = (a ^ b) & 0x8000000080000000ull;
1063 a &= ~0x8000000080000000ull;
1064 b &= ~0x8000000080000000ull;
1065 return (a + b) ^ mask;
1066}
1067
1068uint64_t HELPER(neon_paddl_u16)(uint64_t a, uint64_t b)
1069{
1070 uint64_t tmp;
1071 uint64_t tmp2;
1072
1073 tmp = a & 0x0000ffff0000ffffull;
1074 tmp += (a >> 16) & 0x0000ffff0000ffffull;
1075 tmp2 = b & 0xffff0000ffff0000ull;
1076 tmp2 += (b << 16) & 0xffff0000ffff0000ull;
1077 return ( tmp & 0xffff)
1078 | ((tmp >> 16) & 0xffff0000ull)
1079 | ((tmp2 << 16) & 0xffff00000000ull)
1080 | ( tmp2 & 0xffff000000000000ull);
1081}
1082
1083uint64_t HELPER(neon_paddl_u32)(uint64_t a, uint64_t b)
1084{
1085 uint32_t low = a + (a >> 32);
1086 uint32_t high = b + (b >> 32);
1087 return low + ((uint64_t)high << 32);
1088}
1089
1090uint64_t HELPER(neon_subl_u16)(uint64_t a, uint64_t b)
1091{
1092 uint64_t mask;
1093 mask = (a ^ ~b) & 0x8000800080008000ull;
1094 a |= 0x8000800080008000ull;
1095 b &= ~0x8000800080008000ull;
1096 return (a - b) ^ mask;
1097}
1098
1099uint64_t HELPER(neon_subl_u32)(uint64_t a, uint64_t b)
1100{
1101 uint64_t mask;
1102 mask = (a ^ ~b) & 0x8000000080000000ull;
1103 a |= 0x8000000080000000ull;
1104 b &= ~0x8000000080000000ull;
1105 return (a - b) ^ mask;
1106}
1107
1108uint64_t HELPER(neon_addl_saturate_s32)(CPUState *env, uint64_t a, uint64_t b)
1109{
1110 uint32_t x, y;
1111 uint32_t low, high;
1112
1113 x = a;
1114 y = b;
1115 low = x + y;
1116 if (((low ^ x) & SIGNBIT) && !((x ^ y) & SIGNBIT)) {
1117 SET_QC();
1118 low = ((int32_t)x >> 31) ^ ~SIGNBIT;
1119 }
1120 x = a >> 32;
1121 y = b >> 32;
1122 high = x + y;
1123 if (((high ^ x) & SIGNBIT) && !((x ^ y) & SIGNBIT)) {
1124 SET_QC();
1125 high = ((int32_t)x >> 31) ^ ~SIGNBIT;
1126 }
1127 return low | ((uint64_t)high << 32);
1128}
1129
1130uint64_t HELPER(neon_addl_saturate_s64)(CPUState *env, uint64_t a, uint64_t b)
1131{
1132 uint64_t result;
1133
1134 result = a + b;
1135 if (((result ^ a) & SIGNBIT64) && !((a ^ b) & SIGNBIT64)) {
1136 SET_QC();
1137 result = ((int64_t)a >> 63) ^ ~SIGNBIT64;
1138 }
1139 return result;
1140}
1141
1142#define DO_ABD(dest, x, y, type) do { \
1143 type tmp_x = x; \
1144 type tmp_y = y; \
1145 dest = ((tmp_x > tmp_y) ? tmp_x - tmp_y : tmp_y - tmp_x); \
1146 } while(0)
1147
1148uint64_t HELPER(neon_abdl_u16)(uint32_t a, uint32_t b)
1149{
1150 uint64_t tmp;
1151 uint64_t result;
1152 DO_ABD(result, a, b, uint8_t);
1153 DO_ABD(tmp, a >> 8, b >> 8, uint8_t);
1154 result |= tmp << 16;
1155 DO_ABD(tmp, a >> 16, b >> 16, uint8_t);
1156 result |= tmp << 32;
1157 DO_ABD(tmp, a >> 24, b >> 24, uint8_t);
1158 result |= tmp << 48;
1159 return result;
1160}
1161
1162uint64_t HELPER(neon_abdl_s16)(uint32_t a, uint32_t b)
1163{
1164 uint64_t tmp;
1165 uint64_t result;
1166 DO_ABD(result, a, b, int8_t);
1167 DO_ABD(tmp, a >> 8, b >> 8, int8_t);
1168 result |= tmp << 16;
1169 DO_ABD(tmp, a >> 16, b >> 16, int8_t);
1170 result |= tmp << 32;
1171 DO_ABD(tmp, a >> 24, b >> 24, int8_t);
1172 result |= tmp << 48;
1173 return result;
1174}
1175
1176uint64_t HELPER(neon_abdl_u32)(uint32_t a, uint32_t b)
1177{
1178 uint64_t tmp;
1179 uint64_t result;
1180 DO_ABD(result, a, b, uint16_t);
1181 DO_ABD(tmp, a >> 16, b >> 16, uint16_t);
1182 return result | (tmp << 32);
1183}
1184
1185uint64_t HELPER(neon_abdl_s32)(uint32_t a, uint32_t b)
1186{
1187 uint64_t tmp;
1188 uint64_t result;
1189 DO_ABD(result, a, b, int16_t);
1190 DO_ABD(tmp, a >> 16, b >> 16, int16_t);
1191 return result | (tmp << 32);
1192}
1193
1194uint64_t HELPER(neon_abdl_u64)(uint32_t a, uint32_t b)
1195{
1196 uint64_t result;
1197 DO_ABD(result, a, b, uint32_t);
1198 return result;
1199}
1200
1201uint64_t HELPER(neon_abdl_s64)(uint32_t a, uint32_t b)
1202{
1203 uint64_t result;
1204 DO_ABD(result, a, b, int32_t);
1205 return result;
1206}
1207#undef DO_ABD
1208
1209/* Widening multiply. Named type is the source type. */
1210#define DO_MULL(dest, x, y, type1, type2) do { \
1211 type1 tmp_x = x; \
1212 type1 tmp_y = y; \
1213 dest = (type2)((type2)tmp_x * (type2)tmp_y); \
1214 } while(0)
1215
1216uint64_t HELPER(neon_mull_u8)(uint32_t a, uint32_t b)
1217{
1218 uint64_t tmp;
1219 uint64_t result;
1220
1221 DO_MULL(result, a, b, uint8_t, uint16_t);
1222 DO_MULL(tmp, a >> 8, b >> 8, uint8_t, uint16_t);
1223 result |= tmp << 16;
1224 DO_MULL(tmp, a >> 16, b >> 16, uint8_t, uint16_t);
1225 result |= tmp << 32;
1226 DO_MULL(tmp, a >> 24, b >> 24, uint8_t, uint16_t);
1227 result |= tmp << 48;
1228 return result;
1229}
1230
1231uint64_t HELPER(neon_mull_s8)(uint32_t a, uint32_t b)
1232{
1233 uint64_t tmp;
1234 uint64_t result;
1235
1236 DO_MULL(result, a, b, int8_t, uint16_t);
1237 DO_MULL(tmp, a >> 8, b >> 8, int8_t, uint16_t);
1238 result |= tmp << 16;
1239 DO_MULL(tmp, a >> 16, b >> 16, int8_t, uint16_t);
1240 result |= tmp << 32;
1241 DO_MULL(tmp, a >> 24, b >> 24, int8_t, uint16_t);
1242 result |= tmp << 48;
1243 return result;
1244}
1245
1246uint64_t HELPER(neon_mull_u16)(uint32_t a, uint32_t b)
1247{
1248 uint64_t tmp;
1249 uint64_t result;
1250
1251 DO_MULL(result, a, b, uint16_t, uint32_t);
1252 DO_MULL(tmp, a >> 16, b >> 16, uint16_t, uint32_t);
1253 return result | (tmp << 32);
1254}
1255
1256uint64_t HELPER(neon_mull_s16)(uint32_t a, uint32_t b)
1257{
1258 uint64_t tmp;
1259 uint64_t result;
1260
1261 DO_MULL(result, a, b, int16_t, uint32_t);
1262 DO_MULL(tmp, a >> 16, b >> 16, int16_t, uint32_t);
1263 return result | (tmp << 32);
1264}
1265
1266uint64_t HELPER(neon_negl_u16)(uint64_t x)
1267{
1268 uint16_t tmp;
1269 uint64_t result;
1270 result = (uint16_t)-x;
1271 tmp = -(x >> 16);
1272 result |= (uint64_t)tmp << 16;
1273 tmp = -(x >> 32);
1274 result |= (uint64_t)tmp << 32;
1275 tmp = -(x >> 48);
1276 result |= (uint64_t)tmp << 48;
1277 return result;
1278}
1279
1280#include <stdio.h>
1281uint64_t HELPER(neon_negl_u32)(uint64_t x)
1282{
1283 uint32_t low = -x;
1284 uint32_t high = -(x >> 32);
1285 return low | ((uint64_t)high << 32);
1286}
1287
1288/* FIXME: There should be a native op for this. */
1289uint64_t HELPER(neon_negl_u64)(uint64_t x)
1290{
1291 return -x;
1292}
1293
1294/* Saturnating sign manuipulation. */
1295/* ??? Make these use NEON_VOP1 */
1296#define DO_QABS8(x) do { \
1297 if (x == (int8_t)0x80) { \
1298 x = 0x7f; \
1299 SET_QC(); \
1300 } else if (x < 0) { \
1301 x = -x; \
1302 }} while (0)
1303uint32_t HELPER(neon_qabs_s8)(CPUState *env, uint32_t x)
1304{
1305 neon_s8 vec;
1306 NEON_UNPACK(neon_s8, vec, x);
1307 DO_QABS8(vec.v1);
1308 DO_QABS8(vec.v2);
1309 DO_QABS8(vec.v3);
1310 DO_QABS8(vec.v4);
1311 NEON_PACK(neon_s8, x, vec);
1312 return x;
1313}
1314#undef DO_QABS8
1315
1316#define DO_QNEG8(x) do { \
1317 if (x == (int8_t)0x80) { \
1318 x = 0x7f; \
1319 SET_QC(); \
1320 } else { \
1321 x = -x; \
1322 }} while (0)
1323uint32_t HELPER(neon_qneg_s8)(CPUState *env, uint32_t x)
1324{
1325 neon_s8 vec;
1326 NEON_UNPACK(neon_s8, vec, x);
1327 DO_QNEG8(vec.v1);
1328 DO_QNEG8(vec.v2);
1329 DO_QNEG8(vec.v3);
1330 DO_QNEG8(vec.v4);
1331 NEON_PACK(neon_s8, x, vec);
1332 return x;
1333}
1334#undef DO_QNEG8
1335
1336#define DO_QABS16(x) do { \
1337 if (x == (int16_t)0x8000) { \
1338 x = 0x7fff; \
1339 SET_QC(); \
1340 } else if (x < 0) { \
1341 x = -x; \
1342 }} while (0)
1343uint32_t HELPER(neon_qabs_s16)(CPUState *env, uint32_t x)
1344{
1345 neon_s16 vec;
1346 NEON_UNPACK(neon_s16, vec, x);
1347 DO_QABS16(vec.v1);
1348 DO_QABS16(vec.v2);
1349 NEON_PACK(neon_s16, x, vec);
1350 return x;
1351}
1352#undef DO_QABS16
1353
1354#define DO_QNEG16(x) do { \
1355 if (x == (int16_t)0x8000) { \
1356 x = 0x7fff; \
1357 SET_QC(); \
1358 } else { \
1359 x = -x; \
1360 }} while (0)
1361uint32_t HELPER(neon_qneg_s16)(CPUState *env, uint32_t x)
1362{
1363 neon_s16 vec;
1364 NEON_UNPACK(neon_s16, vec, x);
1365 DO_QNEG16(vec.v1);
1366 DO_QNEG16(vec.v2);
1367 NEON_PACK(neon_s16, x, vec);
1368 return x;
1369}
1370#undef DO_QNEG16
1371
1372uint32_t HELPER(neon_qabs_s32)(CPUState *env, uint32_t x)
1373{
1374 if (x == SIGNBIT) {
1375 SET_QC();
1376 x = ~SIGNBIT;
1377 } else if ((int32_t)x < 0) {
1378 x = -x;
1379 }
1380 return x;
1381}
1382
1383uint32_t HELPER(neon_qneg_s32)(CPUState *env, uint32_t x)
1384{
1385 if (x == SIGNBIT) {
1386 SET_QC();
1387 x = ~SIGNBIT;
1388 } else {
1389 x = -x;
1390 }
1391 return x;
1392}
1393
1394/* NEON Float helpers. */
1395uint32_t HELPER(neon_min_f32)(uint32_t a, uint32_t b)
1396{
1397 float32 f0 = vfp_itos(a);
1398 float32 f1 = vfp_itos(b);
1399 return (float32_compare_quiet(f0, f1, NFS) == -1) ? a : b;
1400}
1401
1402uint32_t HELPER(neon_max_f32)(uint32_t a, uint32_t b)
1403{
1404 float32 f0 = vfp_itos(a);
1405 float32 f1 = vfp_itos(b);
1406 return (float32_compare_quiet(f0, f1, NFS) == 1) ? a : b;
1407}
1408
1409uint32_t HELPER(neon_abd_f32)(uint32_t a, uint32_t b)
1410{
1411 float32 f0 = vfp_itos(a);
1412 float32 f1 = vfp_itos(b);
1413 return vfp_stoi((float32_compare_quiet(f0, f1, NFS) == 1)
1414 ? float32_sub(f0, f1, NFS)
1415 : float32_sub(f1, f0, NFS));
1416}
1417
1418uint32_t HELPER(neon_add_f32)(uint32_t a, uint32_t b)
1419{
1420 return vfp_stoi(float32_add(vfp_itos(a), vfp_itos(b), NFS));
1421}
1422
1423uint32_t HELPER(neon_sub_f32)(uint32_t a, uint32_t b)
1424{
1425 return vfp_stoi(float32_sub(vfp_itos(a), vfp_itos(b), NFS));
1426}
1427
1428uint32_t HELPER(neon_mul_f32)(uint32_t a, uint32_t b)
1429{
1430 return vfp_stoi(float32_mul(vfp_itos(a), vfp_itos(b), NFS));
1431}
1432
1433/* Floating point comparisons produce an integer result. */
1434#define NEON_VOP_FCMP(name, cmp) \
1435uint32_t HELPER(neon_##name)(uint32_t a, uint32_t b) \
1436{ \
1437 if (float32_compare_quiet(vfp_itos(a), vfp_itos(b), NFS) cmp 0) \
1438 return ~0; \
1439 else \
1440 return 0; \
1441}
1442
1443NEON_VOP_FCMP(ceq_f32, ==)
1444NEON_VOP_FCMP(cge_f32, >=)
1445NEON_VOP_FCMP(cgt_f32, >)
1446
1447uint32_t HELPER(neon_acge_f32)(uint32_t a, uint32_t b)
1448{
1449 float32 f0 = float32_abs(vfp_itos(a));
1450 float32 f1 = float32_abs(vfp_itos(b));
1451 return (float32_compare_quiet(f0, f1,NFS) >= 0) ? ~0 : 0;
1452}
1453
1454uint32_t HELPER(neon_acgt_f32)(uint32_t a, uint32_t b)
1455{
1456 float32 f0 = float32_abs(vfp_itos(a));
1457 float32 f1 = float32_abs(vfp_itos(b));
1458 return (float32_compare_quiet(f0, f1, NFS) > 0) ? ~0 : 0;
1459}
Qemu copy for testing