← Back to branch summary

~pmdj/ubuntu/trusty/qemu/2.9+applesmc+fadtv3

« back to all changes in this revision

Viewing changes to target-arm/neon_helper.c

  • Committer: Phil Dennis-Jordan
  • Date: 2017-07-21 08:03:43 UTC
  • mfrom: (1.1.1)
  • Revision ID: phil@philjordan.eu-20170721080343-2yr2vdj7713czahv
New upstream release 2.9.0.

Show diffs side-by-side

added added

removed removed

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