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