neon_helper.c (45000B)
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/helper-proto.h" 13 #include "fpu/softfloat.h" 14 #include "vec_internal.h" 15 16 #define SIGNBIT (uint32_t)0x80000000 17 #define SIGNBIT64 ((uint64_t)1 << 63) 18 19 #define SET_QC() env->vfp.qc[0] = 1 20 21 #define NEON_TYPE1(name, type) \ 22 typedef struct \ 23 { \ 24 type v1; \ 25 } neon_##name; 26 #if HOST_BIG_ENDIAN 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 /* Unsigned saturating accumulate of signed value 240 * 241 * Op1/Rn is treated as signed 242 * Op2/Rd is treated as unsigned 243 * 244 * Explicit casting is used to ensure the correct sign extension of 245 * inputs. The result is treated as a unsigned value and saturated as such. 246 * 247 * We use a macro for the 8/16 bit cases which expects signed integers of va, 248 * vb, and vr for interim calculation and an unsigned 32 bit result value r. 249 */ 250 251 #define USATACC(bits, shift) \ 252 do { \ 253 va = sextract32(a, shift, bits); \ 254 vb = extract32(b, shift, bits); \ 255 vr = va + vb; \ 256 if (vr > UINT##bits##_MAX) { \ 257 SET_QC(); \ 258 vr = UINT##bits##_MAX; \ 259 } else if (vr < 0) { \ 260 SET_QC(); \ 261 vr = 0; \ 262 } \ 263 r = deposit32(r, shift, bits, vr); \ 264 } while (0) 265 266 uint32_t HELPER(neon_uqadd_s8)(CPUARMState *env, uint32_t a, uint32_t b) 267 { 268 int16_t va, vb, vr; 269 uint32_t r = 0; 270 271 USATACC(8, 0); 272 USATACC(8, 8); 273 USATACC(8, 16); 274 USATACC(8, 24); 275 return r; 276 } 277 278 uint32_t HELPER(neon_uqadd_s16)(CPUARMState *env, uint32_t a, uint32_t b) 279 { 280 int32_t va, vb, vr; 281 uint64_t r = 0; 282 283 USATACC(16, 0); 284 USATACC(16, 16); 285 return r; 286 } 287 288 #undef USATACC 289 290 uint32_t HELPER(neon_uqadd_s32)(CPUARMState *env, uint32_t a, uint32_t b) 291 { 292 int64_t va = (int32_t)a; 293 int64_t vb = (uint32_t)b; 294 int64_t vr = va + vb; 295 if (vr > UINT32_MAX) { 296 SET_QC(); 297 vr = UINT32_MAX; 298 } else if (vr < 0) { 299 SET_QC(); 300 vr = 0; 301 } 302 return vr; 303 } 304 305 uint64_t HELPER(neon_uqadd_s64)(CPUARMState *env, uint64_t a, uint64_t b) 306 { 307 uint64_t res; 308 res = a + b; 309 /* We only need to look at the pattern of SIGN bits to detect 310 * +ve/-ve saturation 311 */ 312 if (~a & b & ~res & SIGNBIT64) { 313 SET_QC(); 314 res = UINT64_MAX; 315 } else if (a & ~b & res & SIGNBIT64) { 316 SET_QC(); 317 res = 0; 318 } 319 return res; 320 } 321 322 /* Signed saturating accumulate of unsigned value 323 * 324 * Op1/Rn is treated as unsigned 325 * Op2/Rd is treated as signed 326 * 327 * The result is treated as a signed value and saturated as such 328 * 329 * We use a macro for the 8/16 bit cases which expects signed integers of va, 330 * vb, and vr for interim calculation and an unsigned 32 bit result value r. 331 */ 332 333 #define SSATACC(bits, shift) \ 334 do { \ 335 va = extract32(a, shift, bits); \ 336 vb = sextract32(b, shift, bits); \ 337 vr = va + vb; \ 338 if (vr > INT##bits##_MAX) { \ 339 SET_QC(); \ 340 vr = INT##bits##_MAX; \ 341 } else if (vr < INT##bits##_MIN) { \ 342 SET_QC(); \ 343 vr = INT##bits##_MIN; \ 344 } \ 345 r = deposit32(r, shift, bits, vr); \ 346 } while (0) 347 348 uint32_t HELPER(neon_sqadd_u8)(CPUARMState *env, uint32_t a, uint32_t b) 349 { 350 int16_t va, vb, vr; 351 uint32_t r = 0; 352 353 SSATACC(8, 0); 354 SSATACC(8, 8); 355 SSATACC(8, 16); 356 SSATACC(8, 24); 357 return r; 358 } 359 360 uint32_t HELPER(neon_sqadd_u16)(CPUARMState *env, uint32_t a, uint32_t b) 361 { 362 int32_t va, vb, vr; 363 uint32_t r = 0; 364 365 SSATACC(16, 0); 366 SSATACC(16, 16); 367 368 return r; 369 } 370 371 #undef SSATACC 372 373 uint32_t HELPER(neon_sqadd_u32)(CPUARMState *env, uint32_t a, uint32_t b) 374 { 375 int64_t res; 376 int64_t op1 = (uint32_t)a; 377 int64_t op2 = (int32_t)b; 378 res = op1 + op2; 379 if (res > INT32_MAX) { 380 SET_QC(); 381 res = INT32_MAX; 382 } else if (res < INT32_MIN) { 383 SET_QC(); 384 res = INT32_MIN; 385 } 386 return res; 387 } 388 389 uint64_t HELPER(neon_sqadd_u64)(CPUARMState *env, uint64_t a, uint64_t b) 390 { 391 uint64_t res; 392 res = a + b; 393 /* We only need to look at the pattern of SIGN bits to detect an overflow */ 394 if (((a & res) 395 | (~b & res) 396 | (a & ~b)) & SIGNBIT64) { 397 SET_QC(); 398 res = INT64_MAX; 399 } 400 return res; 401 } 402 403 404 #define NEON_USAT(dest, src1, src2, type) do { \ 405 uint32_t tmp = (uint32_t)src1 - (uint32_t)src2; \ 406 if (tmp != (type)tmp) { \ 407 SET_QC(); \ 408 dest = 0; \ 409 } else { \ 410 dest = tmp; \ 411 }} while(0) 412 #define NEON_FN(dest, src1, src2) NEON_USAT(dest, src1, src2, uint8_t) 413 NEON_VOP_ENV(qsub_u8, neon_u8, 4) 414 #undef NEON_FN 415 #define NEON_FN(dest, src1, src2) NEON_USAT(dest, src1, src2, uint16_t) 416 NEON_VOP_ENV(qsub_u16, neon_u16, 2) 417 #undef NEON_FN 418 #undef NEON_USAT 419 420 uint32_t HELPER(neon_qsub_u32)(CPUARMState *env, uint32_t a, uint32_t b) 421 { 422 uint32_t res = a - b; 423 if (res > a) { 424 SET_QC(); 425 res = 0; 426 } 427 return res; 428 } 429 430 uint64_t HELPER(neon_qsub_u64)(CPUARMState *env, uint64_t src1, uint64_t src2) 431 { 432 uint64_t res; 433 434 if (src1 < src2) { 435 SET_QC(); 436 res = 0; 437 } else { 438 res = src1 - src2; 439 } 440 return res; 441 } 442 443 #define NEON_SSAT(dest, src1, src2, type) do { \ 444 int32_t tmp = (uint32_t)src1 - (uint32_t)src2; \ 445 if (tmp != (type)tmp) { \ 446 SET_QC(); \ 447 if (src2 < 0) { \ 448 tmp = (1 << (sizeof(type) * 8 - 1)) - 1; \ 449 } else { \ 450 tmp = 1 << (sizeof(type) * 8 - 1); \ 451 } \ 452 } \ 453 dest = tmp; \ 454 } while(0) 455 #define NEON_FN(dest, src1, src2) NEON_SSAT(dest, src1, src2, int8_t) 456 NEON_VOP_ENV(qsub_s8, neon_s8, 4) 457 #undef NEON_FN 458 #define NEON_FN(dest, src1, src2) NEON_SSAT(dest, src1, src2, int16_t) 459 NEON_VOP_ENV(qsub_s16, neon_s16, 2) 460 #undef NEON_FN 461 #undef NEON_SSAT 462 463 uint32_t HELPER(neon_qsub_s32)(CPUARMState *env, uint32_t a, uint32_t b) 464 { 465 uint32_t res = a - b; 466 if (((res ^ a) & SIGNBIT) && ((a ^ b) & SIGNBIT)) { 467 SET_QC(); 468 res = ~(((int32_t)a >> 31) ^ SIGNBIT); 469 } 470 return res; 471 } 472 473 uint64_t HELPER(neon_qsub_s64)(CPUARMState *env, uint64_t src1, uint64_t src2) 474 { 475 uint64_t res; 476 477 res = src1 - src2; 478 if (((res ^ src1) & SIGNBIT64) && ((src1 ^ src2) & SIGNBIT64)) { 479 SET_QC(); 480 res = ((int64_t)src1 >> 63) ^ ~SIGNBIT64; 481 } 482 return res; 483 } 484 485 #define NEON_FN(dest, src1, src2) dest = (src1 + src2) >> 1 486 NEON_VOP(hadd_s8, neon_s8, 4) 487 NEON_VOP(hadd_u8, neon_u8, 4) 488 NEON_VOP(hadd_s16, neon_s16, 2) 489 NEON_VOP(hadd_u16, neon_u16, 2) 490 #undef NEON_FN 491 492 int32_t HELPER(neon_hadd_s32)(int32_t src1, int32_t src2) 493 { 494 int32_t dest; 495 496 dest = (src1 >> 1) + (src2 >> 1); 497 if (src1 & src2 & 1) 498 dest++; 499 return dest; 500 } 501 502 uint32_t HELPER(neon_hadd_u32)(uint32_t src1, uint32_t src2) 503 { 504 uint32_t dest; 505 506 dest = (src1 >> 1) + (src2 >> 1); 507 if (src1 & src2 & 1) 508 dest++; 509 return dest; 510 } 511 512 #define NEON_FN(dest, src1, src2) dest = (src1 + src2 + 1) >> 1 513 NEON_VOP(rhadd_s8, neon_s8, 4) 514 NEON_VOP(rhadd_u8, neon_u8, 4) 515 NEON_VOP(rhadd_s16, neon_s16, 2) 516 NEON_VOP(rhadd_u16, neon_u16, 2) 517 #undef NEON_FN 518 519 int32_t HELPER(neon_rhadd_s32)(int32_t src1, int32_t src2) 520 { 521 int32_t dest; 522 523 dest = (src1 >> 1) + (src2 >> 1); 524 if ((src1 | src2) & 1) 525 dest++; 526 return dest; 527 } 528 529 uint32_t HELPER(neon_rhadd_u32)(uint32_t src1, uint32_t src2) 530 { 531 uint32_t dest; 532 533 dest = (src1 >> 1) + (src2 >> 1); 534 if ((src1 | src2) & 1) 535 dest++; 536 return dest; 537 } 538 539 #define NEON_FN(dest, src1, src2) dest = (src1 - src2) >> 1 540 NEON_VOP(hsub_s8, neon_s8, 4) 541 NEON_VOP(hsub_u8, neon_u8, 4) 542 NEON_VOP(hsub_s16, neon_s16, 2) 543 NEON_VOP(hsub_u16, neon_u16, 2) 544 #undef NEON_FN 545 546 int32_t HELPER(neon_hsub_s32)(int32_t src1, int32_t src2) 547 { 548 int32_t dest; 549 550 dest = (src1 >> 1) - (src2 >> 1); 551 if ((~src1) & src2 & 1) 552 dest--; 553 return dest; 554 } 555 556 uint32_t HELPER(neon_hsub_u32)(uint32_t src1, uint32_t src2) 557 { 558 uint32_t dest; 559 560 dest = (src1 >> 1) - (src2 >> 1); 561 if ((~src1) & src2 & 1) 562 dest--; 563 return dest; 564 } 565 566 #define NEON_FN(dest, src1, src2) dest = (src1 < src2) ? src1 : src2 567 NEON_POP(pmin_s8, neon_s8, 4) 568 NEON_POP(pmin_u8, neon_u8, 4) 569 NEON_POP(pmin_s16, neon_s16, 2) 570 NEON_POP(pmin_u16, neon_u16, 2) 571 #undef NEON_FN 572 573 #define NEON_FN(dest, src1, src2) dest = (src1 > src2) ? src1 : src2 574 NEON_POP(pmax_s8, neon_s8, 4) 575 NEON_POP(pmax_u8, neon_u8, 4) 576 NEON_POP(pmax_s16, neon_s16, 2) 577 NEON_POP(pmax_u16, neon_u16, 2) 578 #undef NEON_FN 579 580 #define NEON_FN(dest, src1, src2) \ 581 (dest = do_uqrshl_bhs(src1, (int8_t)src2, 16, false, NULL)) 582 NEON_VOP(shl_u16, neon_u16, 2) 583 #undef NEON_FN 584 585 #define NEON_FN(dest, src1, src2) \ 586 (dest = do_sqrshl_bhs(src1, (int8_t)src2, 16, false, NULL)) 587 NEON_VOP(shl_s16, neon_s16, 2) 588 #undef NEON_FN 589 590 #define NEON_FN(dest, src1, src2) \ 591 (dest = do_sqrshl_bhs(src1, (int8_t)src2, 8, true, NULL)) 592 NEON_VOP(rshl_s8, neon_s8, 4) 593 #undef NEON_FN 594 595 #define NEON_FN(dest, src1, src2) \ 596 (dest = do_sqrshl_bhs(src1, (int8_t)src2, 16, true, NULL)) 597 NEON_VOP(rshl_s16, neon_s16, 2) 598 #undef NEON_FN 599 600 uint32_t HELPER(neon_rshl_s32)(uint32_t val, uint32_t shift) 601 { 602 return do_sqrshl_bhs(val, (int8_t)shift, 32, true, NULL); 603 } 604 605 uint64_t HELPER(neon_rshl_s64)(uint64_t val, uint64_t shift) 606 { 607 return do_sqrshl_d(val, (int8_t)shift, true, NULL); 608 } 609 610 #define NEON_FN(dest, src1, src2) \ 611 (dest = do_uqrshl_bhs(src1, (int8_t)src2, 8, true, NULL)) 612 NEON_VOP(rshl_u8, neon_u8, 4) 613 #undef NEON_FN 614 615 #define NEON_FN(dest, src1, src2) \ 616 (dest = do_uqrshl_bhs(src1, (int8_t)src2, 16, true, NULL)) 617 NEON_VOP(rshl_u16, neon_u16, 2) 618 #undef NEON_FN 619 620 uint32_t HELPER(neon_rshl_u32)(uint32_t val, uint32_t shift) 621 { 622 return do_uqrshl_bhs(val, (int8_t)shift, 32, true, NULL); 623 } 624 625 uint64_t HELPER(neon_rshl_u64)(uint64_t val, uint64_t shift) 626 { 627 return do_uqrshl_d(val, (int8_t)shift, true, NULL); 628 } 629 630 #define NEON_FN(dest, src1, src2) \ 631 (dest = do_uqrshl_bhs(src1, (int8_t)src2, 8, false, env->vfp.qc)) 632 NEON_VOP_ENV(qshl_u8, neon_u8, 4) 633 #undef NEON_FN 634 635 #define NEON_FN(dest, src1, src2) \ 636 (dest = do_uqrshl_bhs(src1, (int8_t)src2, 16, false, env->vfp.qc)) 637 NEON_VOP_ENV(qshl_u16, neon_u16, 2) 638 #undef NEON_FN 639 640 uint32_t HELPER(neon_qshl_u32)(CPUARMState *env, uint32_t val, uint32_t shift) 641 { 642 return do_uqrshl_bhs(val, (int8_t)shift, 32, false, env->vfp.qc); 643 } 644 645 uint64_t HELPER(neon_qshl_u64)(CPUARMState *env, uint64_t val, uint64_t shift) 646 { 647 return do_uqrshl_d(val, (int8_t)shift, false, env->vfp.qc); 648 } 649 650 #define NEON_FN(dest, src1, src2) \ 651 (dest = do_sqrshl_bhs(src1, (int8_t)src2, 8, false, env->vfp.qc)) 652 NEON_VOP_ENV(qshl_s8, neon_s8, 4) 653 #undef NEON_FN 654 655 #define NEON_FN(dest, src1, src2) \ 656 (dest = do_sqrshl_bhs(src1, (int8_t)src2, 16, false, env->vfp.qc)) 657 NEON_VOP_ENV(qshl_s16, neon_s16, 2) 658 #undef NEON_FN 659 660 uint32_t HELPER(neon_qshl_s32)(CPUARMState *env, uint32_t val, uint32_t shift) 661 { 662 return do_sqrshl_bhs(val, (int8_t)shift, 32, false, env->vfp.qc); 663 } 664 665 uint64_t HELPER(neon_qshl_s64)(CPUARMState *env, uint64_t val, uint64_t shift) 666 { 667 return do_sqrshl_d(val, (int8_t)shift, false, env->vfp.qc); 668 } 669 670 #define NEON_FN(dest, src1, src2) \ 671 (dest = do_suqrshl_bhs(src1, (int8_t)src2, 8, false, env->vfp.qc)) 672 NEON_VOP_ENV(qshlu_s8, neon_s8, 4) 673 #undef NEON_FN 674 675 #define NEON_FN(dest, src1, src2) \ 676 (dest = do_suqrshl_bhs(src1, (int8_t)src2, 16, false, env->vfp.qc)) 677 NEON_VOP_ENV(qshlu_s16, neon_s16, 2) 678 #undef NEON_FN 679 680 uint32_t HELPER(neon_qshlu_s32)(CPUARMState *env, uint32_t val, uint32_t shift) 681 { 682 return do_suqrshl_bhs(val, (int8_t)shift, 32, false, env->vfp.qc); 683 } 684 685 uint64_t HELPER(neon_qshlu_s64)(CPUARMState *env, uint64_t val, uint64_t shift) 686 { 687 return do_suqrshl_d(val, (int8_t)shift, false, env->vfp.qc); 688 } 689 690 #define NEON_FN(dest, src1, src2) \ 691 (dest = do_uqrshl_bhs(src1, (int8_t)src2, 8, true, env->vfp.qc)) 692 NEON_VOP_ENV(qrshl_u8, neon_u8, 4) 693 #undef NEON_FN 694 695 #define NEON_FN(dest, src1, src2) \ 696 (dest = do_uqrshl_bhs(src1, (int8_t)src2, 16, true, env->vfp.qc)) 697 NEON_VOP_ENV(qrshl_u16, neon_u16, 2) 698 #undef NEON_FN 699 700 uint32_t HELPER(neon_qrshl_u32)(CPUARMState *env, uint32_t val, uint32_t shift) 701 { 702 return do_uqrshl_bhs(val, (int8_t)shift, 32, true, env->vfp.qc); 703 } 704 705 uint64_t HELPER(neon_qrshl_u64)(CPUARMState *env, uint64_t val, uint64_t shift) 706 { 707 return do_uqrshl_d(val, (int8_t)shift, true, env->vfp.qc); 708 } 709 710 #define NEON_FN(dest, src1, src2) \ 711 (dest = do_sqrshl_bhs(src1, (int8_t)src2, 8, true, env->vfp.qc)) 712 NEON_VOP_ENV(qrshl_s8, neon_s8, 4) 713 #undef NEON_FN 714 715 #define NEON_FN(dest, src1, src2) \ 716 (dest = do_sqrshl_bhs(src1, (int8_t)src2, 16, true, env->vfp.qc)) 717 NEON_VOP_ENV(qrshl_s16, neon_s16, 2) 718 #undef NEON_FN 719 720 uint32_t HELPER(neon_qrshl_s32)(CPUARMState *env, uint32_t val, uint32_t shift) 721 { 722 return do_sqrshl_bhs(val, (int8_t)shift, 32, true, env->vfp.qc); 723 } 724 725 uint64_t HELPER(neon_qrshl_s64)(CPUARMState *env, uint64_t val, uint64_t shift) 726 { 727 return do_sqrshl_d(val, (int8_t)shift, true, env->vfp.qc); 728 } 729 730 uint32_t HELPER(neon_add_u8)(uint32_t a, uint32_t b) 731 { 732 uint32_t mask; 733 mask = (a ^ b) & 0x80808080u; 734 a &= ~0x80808080u; 735 b &= ~0x80808080u; 736 return (a + b) ^ mask; 737 } 738 739 uint32_t HELPER(neon_add_u16)(uint32_t a, uint32_t b) 740 { 741 uint32_t mask; 742 mask = (a ^ b) & 0x80008000u; 743 a &= ~0x80008000u; 744 b &= ~0x80008000u; 745 return (a + b) ^ mask; 746 } 747 748 #define NEON_FN(dest, src1, src2) dest = src1 + src2 749 NEON_POP(padd_u8, neon_u8, 4) 750 NEON_POP(padd_u16, neon_u16, 2) 751 #undef NEON_FN 752 753 #define NEON_FN(dest, src1, src2) dest = src1 - src2 754 NEON_VOP(sub_u8, neon_u8, 4) 755 NEON_VOP(sub_u16, neon_u16, 2) 756 #undef NEON_FN 757 758 #define NEON_FN(dest, src1, src2) dest = src1 * src2 759 NEON_VOP(mul_u8, neon_u8, 4) 760 NEON_VOP(mul_u16, neon_u16, 2) 761 #undef NEON_FN 762 763 #define NEON_FN(dest, src1, src2) dest = (src1 & src2) ? -1 : 0 764 NEON_VOP(tst_u8, neon_u8, 4) 765 NEON_VOP(tst_u16, neon_u16, 2) 766 NEON_VOP(tst_u32, neon_u32, 1) 767 #undef NEON_FN 768 769 /* Count Leading Sign/Zero Bits. */ 770 static inline int do_clz8(uint8_t x) 771 { 772 int n; 773 for (n = 8; x; n--) 774 x >>= 1; 775 return n; 776 } 777 778 static inline int do_clz16(uint16_t x) 779 { 780 int n; 781 for (n = 16; x; n--) 782 x >>= 1; 783 return n; 784 } 785 786 #define NEON_FN(dest, src, dummy) dest = do_clz8(src) 787 NEON_VOP1(clz_u8, neon_u8, 4) 788 #undef NEON_FN 789 790 #define NEON_FN(dest, src, dummy) dest = do_clz16(src) 791 NEON_VOP1(clz_u16, neon_u16, 2) 792 #undef NEON_FN 793 794 #define NEON_FN(dest, src, dummy) dest = do_clz8((src < 0) ? ~src : src) - 1 795 NEON_VOP1(cls_s8, neon_s8, 4) 796 #undef NEON_FN 797 798 #define NEON_FN(dest, src, dummy) dest = do_clz16((src < 0) ? ~src : src) - 1 799 NEON_VOP1(cls_s16, neon_s16, 2) 800 #undef NEON_FN 801 802 uint32_t HELPER(neon_cls_s32)(uint32_t x) 803 { 804 int count; 805 if ((int32_t)x < 0) 806 x = ~x; 807 for (count = 32; x; count--) 808 x = x >> 1; 809 return count - 1; 810 } 811 812 /* Bit count. */ 813 uint32_t HELPER(neon_cnt_u8)(uint32_t x) 814 { 815 x = (x & 0x55555555) + ((x >> 1) & 0x55555555); 816 x = (x & 0x33333333) + ((x >> 2) & 0x33333333); 817 x = (x & 0x0f0f0f0f) + ((x >> 4) & 0x0f0f0f0f); 818 return x; 819 } 820 821 /* Reverse bits in each 8 bit word */ 822 uint32_t HELPER(neon_rbit_u8)(uint32_t x) 823 { 824 x = ((x & 0xf0f0f0f0) >> 4) 825 | ((x & 0x0f0f0f0f) << 4); 826 x = ((x & 0x88888888) >> 3) 827 | ((x & 0x44444444) >> 1) 828 | ((x & 0x22222222) << 1) 829 | ((x & 0x11111111) << 3); 830 return x; 831 } 832 833 #define NEON_QDMULH16(dest, src1, src2, round) do { \ 834 uint32_t tmp = (int32_t)(int16_t) src1 * (int16_t) src2; \ 835 if ((tmp ^ (tmp << 1)) & SIGNBIT) { \ 836 SET_QC(); \ 837 tmp = (tmp >> 31) ^ ~SIGNBIT; \ 838 } else { \ 839 tmp <<= 1; \ 840 } \ 841 if (round) { \ 842 int32_t old = tmp; \ 843 tmp += 1 << 15; \ 844 if ((int32_t)tmp < old) { \ 845 SET_QC(); \ 846 tmp = SIGNBIT - 1; \ 847 } \ 848 } \ 849 dest = tmp >> 16; \ 850 } while(0) 851 #define NEON_FN(dest, src1, src2) NEON_QDMULH16(dest, src1, src2, 0) 852 NEON_VOP_ENV(qdmulh_s16, neon_s16, 2) 853 #undef NEON_FN 854 #define NEON_FN(dest, src1, src2) NEON_QDMULH16(dest, src1, src2, 1) 855 NEON_VOP_ENV(qrdmulh_s16, neon_s16, 2) 856 #undef NEON_FN 857 #undef NEON_QDMULH16 858 859 #define NEON_QDMULH32(dest, src1, src2, round) do { \ 860 uint64_t tmp = (int64_t)(int32_t) src1 * (int32_t) src2; \ 861 if ((tmp ^ (tmp << 1)) & SIGNBIT64) { \ 862 SET_QC(); \ 863 tmp = (tmp >> 63) ^ ~SIGNBIT64; \ 864 } else { \ 865 tmp <<= 1; \ 866 } \ 867 if (round) { \ 868 int64_t old = tmp; \ 869 tmp += (int64_t)1 << 31; \ 870 if ((int64_t)tmp < old) { \ 871 SET_QC(); \ 872 tmp = SIGNBIT64 - 1; \ 873 } \ 874 } \ 875 dest = tmp >> 32; \ 876 } while(0) 877 #define NEON_FN(dest, src1, src2) NEON_QDMULH32(dest, src1, src2, 0) 878 NEON_VOP_ENV(qdmulh_s32, neon_s32, 1) 879 #undef NEON_FN 880 #define NEON_FN(dest, src1, src2) NEON_QDMULH32(dest, src1, src2, 1) 881 NEON_VOP_ENV(qrdmulh_s32, neon_s32, 1) 882 #undef NEON_FN 883 #undef NEON_QDMULH32 884 885 uint32_t HELPER(neon_narrow_u8)(uint64_t x) 886 { 887 return (x & 0xffu) | ((x >> 8) & 0xff00u) | ((x >> 16) & 0xff0000u) 888 | ((x >> 24) & 0xff000000u); 889 } 890 891 uint32_t HELPER(neon_narrow_u16)(uint64_t x) 892 { 893 return (x & 0xffffu) | ((x >> 16) & 0xffff0000u); 894 } 895 896 uint32_t HELPER(neon_narrow_high_u8)(uint64_t x) 897 { 898 return ((x >> 8) & 0xff) | ((x >> 16) & 0xff00) 899 | ((x >> 24) & 0xff0000) | ((x >> 32) & 0xff000000); 900 } 901 902 uint32_t HELPER(neon_narrow_high_u16)(uint64_t x) 903 { 904 return ((x >> 16) & 0xffff) | ((x >> 32) & 0xffff0000); 905 } 906 907 uint32_t HELPER(neon_narrow_round_high_u8)(uint64_t x) 908 { 909 x &= 0xff80ff80ff80ff80ull; 910 x += 0x0080008000800080ull; 911 return ((x >> 8) & 0xff) | ((x >> 16) & 0xff00) 912 | ((x >> 24) & 0xff0000) | ((x >> 32) & 0xff000000); 913 } 914 915 uint32_t HELPER(neon_narrow_round_high_u16)(uint64_t x) 916 { 917 x &= 0xffff8000ffff8000ull; 918 x += 0x0000800000008000ull; 919 return ((x >> 16) & 0xffff) | ((x >> 32) & 0xffff0000); 920 } 921 922 uint32_t HELPER(neon_unarrow_sat8)(CPUARMState *env, uint64_t x) 923 { 924 uint16_t s; 925 uint8_t d; 926 uint32_t res = 0; 927 #define SAT8(n) \ 928 s = x >> n; \ 929 if (s & 0x8000) { \ 930 SET_QC(); \ 931 } else { \ 932 if (s > 0xff) { \ 933 d = 0xff; \ 934 SET_QC(); \ 935 } else { \ 936 d = s; \ 937 } \ 938 res |= (uint32_t)d << (n / 2); \ 939 } 940 941 SAT8(0); 942 SAT8(16); 943 SAT8(32); 944 SAT8(48); 945 #undef SAT8 946 return res; 947 } 948 949 uint32_t HELPER(neon_narrow_sat_u8)(CPUARMState *env, uint64_t x) 950 { 951 uint16_t s; 952 uint8_t d; 953 uint32_t res = 0; 954 #define SAT8(n) \ 955 s = x >> n; \ 956 if (s > 0xff) { \ 957 d = 0xff; \ 958 SET_QC(); \ 959 } else { \ 960 d = s; \ 961 } \ 962 res |= (uint32_t)d << (n / 2); 963 964 SAT8(0); 965 SAT8(16); 966 SAT8(32); 967 SAT8(48); 968 #undef SAT8 969 return res; 970 } 971 972 uint32_t HELPER(neon_narrow_sat_s8)(CPUARMState *env, uint64_t x) 973 { 974 int16_t s; 975 uint8_t d; 976 uint32_t res = 0; 977 #define SAT8(n) \ 978 s = x >> n; \ 979 if (s != (int8_t)s) { \ 980 d = (s >> 15) ^ 0x7f; \ 981 SET_QC(); \ 982 } else { \ 983 d = s; \ 984 } \ 985 res |= (uint32_t)d << (n / 2); 986 987 SAT8(0); 988 SAT8(16); 989 SAT8(32); 990 SAT8(48); 991 #undef SAT8 992 return res; 993 } 994 995 uint32_t HELPER(neon_unarrow_sat16)(CPUARMState *env, uint64_t x) 996 { 997 uint32_t high; 998 uint32_t low; 999 low = x; 1000 if (low & 0x80000000) { 1001 low = 0; 1002 SET_QC(); 1003 } else if (low > 0xffff) { 1004 low = 0xffff; 1005 SET_QC(); 1006 } 1007 high = x >> 32; 1008 if (high & 0x80000000) { 1009 high = 0; 1010 SET_QC(); 1011 } else if (high > 0xffff) { 1012 high = 0xffff; 1013 SET_QC(); 1014 } 1015 return low | (high << 16); 1016 } 1017 1018 uint32_t HELPER(neon_narrow_sat_u16)(CPUARMState *env, uint64_t x) 1019 { 1020 uint32_t high; 1021 uint32_t low; 1022 low = x; 1023 if (low > 0xffff) { 1024 low = 0xffff; 1025 SET_QC(); 1026 } 1027 high = x >> 32; 1028 if (high > 0xffff) { 1029 high = 0xffff; 1030 SET_QC(); 1031 } 1032 return low | (high << 16); 1033 } 1034 1035 uint32_t HELPER(neon_narrow_sat_s16)(CPUARMState *env, uint64_t x) 1036 { 1037 int32_t low; 1038 int32_t high; 1039 low = x; 1040 if (low != (int16_t)low) { 1041 low = (low >> 31) ^ 0x7fff; 1042 SET_QC(); 1043 } 1044 high = x >> 32; 1045 if (high != (int16_t)high) { 1046 high = (high >> 31) ^ 0x7fff; 1047 SET_QC(); 1048 } 1049 return (uint16_t)low | (high << 16); 1050 } 1051 1052 uint32_t HELPER(neon_unarrow_sat32)(CPUARMState *env, uint64_t x) 1053 { 1054 if (x & 0x8000000000000000ull) { 1055 SET_QC(); 1056 return 0; 1057 } 1058 if (x > 0xffffffffu) { 1059 SET_QC(); 1060 return 0xffffffffu; 1061 } 1062 return x; 1063 } 1064 1065 uint32_t HELPER(neon_narrow_sat_u32)(CPUARMState *env, uint64_t x) 1066 { 1067 if (x > 0xffffffffu) { 1068 SET_QC(); 1069 return 0xffffffffu; 1070 } 1071 return x; 1072 } 1073 1074 uint32_t HELPER(neon_narrow_sat_s32)(CPUARMState *env, uint64_t x) 1075 { 1076 if ((int64_t)x != (int32_t)x) { 1077 SET_QC(); 1078 return ((int64_t)x >> 63) ^ 0x7fffffff; 1079 } 1080 return x; 1081 } 1082 1083 uint64_t HELPER(neon_widen_u8)(uint32_t x) 1084 { 1085 uint64_t tmp; 1086 uint64_t ret; 1087 ret = (uint8_t)x; 1088 tmp = (uint8_t)(x >> 8); 1089 ret |= tmp << 16; 1090 tmp = (uint8_t)(x >> 16); 1091 ret |= tmp << 32; 1092 tmp = (uint8_t)(x >> 24); 1093 ret |= tmp << 48; 1094 return ret; 1095 } 1096 1097 uint64_t HELPER(neon_widen_s8)(uint32_t x) 1098 { 1099 uint64_t tmp; 1100 uint64_t ret; 1101 ret = (uint16_t)(int8_t)x; 1102 tmp = (uint16_t)(int8_t)(x >> 8); 1103 ret |= tmp << 16; 1104 tmp = (uint16_t)(int8_t)(x >> 16); 1105 ret |= tmp << 32; 1106 tmp = (uint16_t)(int8_t)(x >> 24); 1107 ret |= tmp << 48; 1108 return ret; 1109 } 1110 1111 uint64_t HELPER(neon_widen_u16)(uint32_t x) 1112 { 1113 uint64_t high = (uint16_t)(x >> 16); 1114 return ((uint16_t)x) | (high << 32); 1115 } 1116 1117 uint64_t HELPER(neon_widen_s16)(uint32_t x) 1118 { 1119 uint64_t high = (int16_t)(x >> 16); 1120 return ((uint32_t)(int16_t)x) | (high << 32); 1121 } 1122 1123 uint64_t HELPER(neon_addl_u16)(uint64_t a, uint64_t b) 1124 { 1125 uint64_t mask; 1126 mask = (a ^ b) & 0x8000800080008000ull; 1127 a &= ~0x8000800080008000ull; 1128 b &= ~0x8000800080008000ull; 1129 return (a + b) ^ mask; 1130 } 1131 1132 uint64_t HELPER(neon_addl_u32)(uint64_t a, uint64_t b) 1133 { 1134 uint64_t mask; 1135 mask = (a ^ b) & 0x8000000080000000ull; 1136 a &= ~0x8000000080000000ull; 1137 b &= ~0x8000000080000000ull; 1138 return (a + b) ^ mask; 1139 } 1140 1141 uint64_t HELPER(neon_paddl_u16)(uint64_t a, uint64_t b) 1142 { 1143 uint64_t tmp; 1144 uint64_t tmp2; 1145 1146 tmp = a & 0x0000ffff0000ffffull; 1147 tmp += (a >> 16) & 0x0000ffff0000ffffull; 1148 tmp2 = b & 0xffff0000ffff0000ull; 1149 tmp2 += (b << 16) & 0xffff0000ffff0000ull; 1150 return ( tmp & 0xffff) 1151 | ((tmp >> 16) & 0xffff0000ull) 1152 | ((tmp2 << 16) & 0xffff00000000ull) 1153 | ( tmp2 & 0xffff000000000000ull); 1154 } 1155 1156 uint64_t HELPER(neon_paddl_u32)(uint64_t a, uint64_t b) 1157 { 1158 uint32_t low = a + (a >> 32); 1159 uint32_t high = b + (b >> 32); 1160 return low + ((uint64_t)high << 32); 1161 } 1162 1163 uint64_t HELPER(neon_subl_u16)(uint64_t a, uint64_t b) 1164 { 1165 uint64_t mask; 1166 mask = (a ^ ~b) & 0x8000800080008000ull; 1167 a |= 0x8000800080008000ull; 1168 b &= ~0x8000800080008000ull; 1169 return (a - b) ^ mask; 1170 } 1171 1172 uint64_t HELPER(neon_subl_u32)(uint64_t a, uint64_t b) 1173 { 1174 uint64_t mask; 1175 mask = (a ^ ~b) & 0x8000000080000000ull; 1176 a |= 0x8000000080000000ull; 1177 b &= ~0x8000000080000000ull; 1178 return (a - b) ^ mask; 1179 } 1180 1181 uint64_t HELPER(neon_addl_saturate_s32)(CPUARMState *env, uint64_t a, uint64_t b) 1182 { 1183 uint32_t x, y; 1184 uint32_t low, high; 1185 1186 x = a; 1187 y = b; 1188 low = x + y; 1189 if (((low ^ x) & SIGNBIT) && !((x ^ y) & SIGNBIT)) { 1190 SET_QC(); 1191 low = ((int32_t)x >> 31) ^ ~SIGNBIT; 1192 } 1193 x = a >> 32; 1194 y = b >> 32; 1195 high = x + y; 1196 if (((high ^ x) & SIGNBIT) && !((x ^ y) & SIGNBIT)) { 1197 SET_QC(); 1198 high = ((int32_t)x >> 31) ^ ~SIGNBIT; 1199 } 1200 return low | ((uint64_t)high << 32); 1201 } 1202 1203 uint64_t HELPER(neon_addl_saturate_s64)(CPUARMState *env, uint64_t a, uint64_t b) 1204 { 1205 uint64_t result; 1206 1207 result = a + b; 1208 if (((result ^ a) & SIGNBIT64) && !((a ^ b) & SIGNBIT64)) { 1209 SET_QC(); 1210 result = ((int64_t)a >> 63) ^ ~SIGNBIT64; 1211 } 1212 return result; 1213 } 1214 1215 /* We have to do the arithmetic in a larger type than 1216 * the input type, because for example with a signed 32 bit 1217 * op the absolute difference can overflow a signed 32 bit value. 1218 */ 1219 #define DO_ABD(dest, x, y, intype, arithtype) do { \ 1220 arithtype tmp_x = (intype)(x); \ 1221 arithtype tmp_y = (intype)(y); \ 1222 dest = ((tmp_x > tmp_y) ? tmp_x - tmp_y : tmp_y - tmp_x); \ 1223 } while(0) 1224 1225 uint64_t HELPER(neon_abdl_u16)(uint32_t a, uint32_t b) 1226 { 1227 uint64_t tmp; 1228 uint64_t result; 1229 DO_ABD(result, a, b, uint8_t, uint32_t); 1230 DO_ABD(tmp, a >> 8, b >> 8, uint8_t, uint32_t); 1231 result |= tmp << 16; 1232 DO_ABD(tmp, a >> 16, b >> 16, uint8_t, uint32_t); 1233 result |= tmp << 32; 1234 DO_ABD(tmp, a >> 24, b >> 24, uint8_t, uint32_t); 1235 result |= tmp << 48; 1236 return result; 1237 } 1238 1239 uint64_t HELPER(neon_abdl_s16)(uint32_t a, uint32_t b) 1240 { 1241 uint64_t tmp; 1242 uint64_t result; 1243 DO_ABD(result, a, b, int8_t, int32_t); 1244 DO_ABD(tmp, a >> 8, b >> 8, int8_t, int32_t); 1245 result |= tmp << 16; 1246 DO_ABD(tmp, a >> 16, b >> 16, int8_t, int32_t); 1247 result |= tmp << 32; 1248 DO_ABD(tmp, a >> 24, b >> 24, int8_t, int32_t); 1249 result |= tmp << 48; 1250 return result; 1251 } 1252 1253 uint64_t HELPER(neon_abdl_u32)(uint32_t a, uint32_t b) 1254 { 1255 uint64_t tmp; 1256 uint64_t result; 1257 DO_ABD(result, a, b, uint16_t, uint32_t); 1258 DO_ABD(tmp, a >> 16, b >> 16, uint16_t, uint32_t); 1259 return result | (tmp << 32); 1260 } 1261 1262 uint64_t HELPER(neon_abdl_s32)(uint32_t a, uint32_t b) 1263 { 1264 uint64_t tmp; 1265 uint64_t result; 1266 DO_ABD(result, a, b, int16_t, int32_t); 1267 DO_ABD(tmp, a >> 16, b >> 16, int16_t, int32_t); 1268 return result | (tmp << 32); 1269 } 1270 1271 uint64_t HELPER(neon_abdl_u64)(uint32_t a, uint32_t b) 1272 { 1273 uint64_t result; 1274 DO_ABD(result, a, b, uint32_t, uint64_t); 1275 return result; 1276 } 1277 1278 uint64_t HELPER(neon_abdl_s64)(uint32_t a, uint32_t b) 1279 { 1280 uint64_t result; 1281 DO_ABD(result, a, b, int32_t, int64_t); 1282 return result; 1283 } 1284 #undef DO_ABD 1285 1286 /* Widening multiply. Named type is the source type. */ 1287 #define DO_MULL(dest, x, y, type1, type2) do { \ 1288 type1 tmp_x = x; \ 1289 type1 tmp_y = y; \ 1290 dest = (type2)((type2)tmp_x * (type2)tmp_y); \ 1291 } while(0) 1292 1293 uint64_t HELPER(neon_mull_u8)(uint32_t a, uint32_t b) 1294 { 1295 uint64_t tmp; 1296 uint64_t result; 1297 1298 DO_MULL(result, a, b, uint8_t, uint16_t); 1299 DO_MULL(tmp, a >> 8, b >> 8, uint8_t, uint16_t); 1300 result |= tmp << 16; 1301 DO_MULL(tmp, a >> 16, b >> 16, uint8_t, uint16_t); 1302 result |= tmp << 32; 1303 DO_MULL(tmp, a >> 24, b >> 24, uint8_t, uint16_t); 1304 result |= tmp << 48; 1305 return result; 1306 } 1307 1308 uint64_t HELPER(neon_mull_s8)(uint32_t a, uint32_t b) 1309 { 1310 uint64_t tmp; 1311 uint64_t result; 1312 1313 DO_MULL(result, a, b, int8_t, uint16_t); 1314 DO_MULL(tmp, a >> 8, b >> 8, int8_t, uint16_t); 1315 result |= tmp << 16; 1316 DO_MULL(tmp, a >> 16, b >> 16, int8_t, uint16_t); 1317 result |= tmp << 32; 1318 DO_MULL(tmp, a >> 24, b >> 24, int8_t, uint16_t); 1319 result |= tmp << 48; 1320 return result; 1321 } 1322 1323 uint64_t HELPER(neon_mull_u16)(uint32_t a, uint32_t b) 1324 { 1325 uint64_t tmp; 1326 uint64_t result; 1327 1328 DO_MULL(result, a, b, uint16_t, uint32_t); 1329 DO_MULL(tmp, a >> 16, b >> 16, uint16_t, uint32_t); 1330 return result | (tmp << 32); 1331 } 1332 1333 uint64_t HELPER(neon_mull_s16)(uint32_t a, uint32_t b) 1334 { 1335 uint64_t tmp; 1336 uint64_t result; 1337 1338 DO_MULL(result, a, b, int16_t, uint32_t); 1339 DO_MULL(tmp, a >> 16, b >> 16, int16_t, uint32_t); 1340 return result | (tmp << 32); 1341 } 1342 1343 uint64_t HELPER(neon_negl_u16)(uint64_t x) 1344 { 1345 uint16_t tmp; 1346 uint64_t result; 1347 result = (uint16_t)-x; 1348 tmp = -(x >> 16); 1349 result |= (uint64_t)tmp << 16; 1350 tmp = -(x >> 32); 1351 result |= (uint64_t)tmp << 32; 1352 tmp = -(x >> 48); 1353 result |= (uint64_t)tmp << 48; 1354 return result; 1355 } 1356 1357 uint64_t HELPER(neon_negl_u32)(uint64_t x) 1358 { 1359 uint32_t low = -x; 1360 uint32_t high = -(x >> 32); 1361 return low | ((uint64_t)high << 32); 1362 } 1363 1364 /* Saturating sign manipulation. */ 1365 /* ??? Make these use NEON_VOP1 */ 1366 #define DO_QABS8(x) do { \ 1367 if (x == (int8_t)0x80) { \ 1368 x = 0x7f; \ 1369 SET_QC(); \ 1370 } else if (x < 0) { \ 1371 x = -x; \ 1372 }} while (0) 1373 uint32_t HELPER(neon_qabs_s8)(CPUARMState *env, uint32_t x) 1374 { 1375 neon_s8 vec; 1376 NEON_UNPACK(neon_s8, vec, x); 1377 DO_QABS8(vec.v1); 1378 DO_QABS8(vec.v2); 1379 DO_QABS8(vec.v3); 1380 DO_QABS8(vec.v4); 1381 NEON_PACK(neon_s8, x, vec); 1382 return x; 1383 } 1384 #undef DO_QABS8 1385 1386 #define DO_QNEG8(x) do { \ 1387 if (x == (int8_t)0x80) { \ 1388 x = 0x7f; \ 1389 SET_QC(); \ 1390 } else { \ 1391 x = -x; \ 1392 }} while (0) 1393 uint32_t HELPER(neon_qneg_s8)(CPUARMState *env, uint32_t x) 1394 { 1395 neon_s8 vec; 1396 NEON_UNPACK(neon_s8, vec, x); 1397 DO_QNEG8(vec.v1); 1398 DO_QNEG8(vec.v2); 1399 DO_QNEG8(vec.v3); 1400 DO_QNEG8(vec.v4); 1401 NEON_PACK(neon_s8, x, vec); 1402 return x; 1403 } 1404 #undef DO_QNEG8 1405 1406 #define DO_QABS16(x) do { \ 1407 if (x == (int16_t)0x8000) { \ 1408 x = 0x7fff; \ 1409 SET_QC(); \ 1410 } else if (x < 0) { \ 1411 x = -x; \ 1412 }} while (0) 1413 uint32_t HELPER(neon_qabs_s16)(CPUARMState *env, uint32_t x) 1414 { 1415 neon_s16 vec; 1416 NEON_UNPACK(neon_s16, vec, x); 1417 DO_QABS16(vec.v1); 1418 DO_QABS16(vec.v2); 1419 NEON_PACK(neon_s16, x, vec); 1420 return x; 1421 } 1422 #undef DO_QABS16 1423 1424 #define DO_QNEG16(x) do { \ 1425 if (x == (int16_t)0x8000) { \ 1426 x = 0x7fff; \ 1427 SET_QC(); \ 1428 } else { \ 1429 x = -x; \ 1430 }} while (0) 1431 uint32_t HELPER(neon_qneg_s16)(CPUARMState *env, uint32_t x) 1432 { 1433 neon_s16 vec; 1434 NEON_UNPACK(neon_s16, vec, x); 1435 DO_QNEG16(vec.v1); 1436 DO_QNEG16(vec.v2); 1437 NEON_PACK(neon_s16, x, vec); 1438 return x; 1439 } 1440 #undef DO_QNEG16 1441 1442 uint32_t HELPER(neon_qabs_s32)(CPUARMState *env, uint32_t x) 1443 { 1444 if (x == SIGNBIT) { 1445 SET_QC(); 1446 x = ~SIGNBIT; 1447 } else if ((int32_t)x < 0) { 1448 x = -x; 1449 } 1450 return x; 1451 } 1452 1453 uint32_t HELPER(neon_qneg_s32)(CPUARMState *env, uint32_t x) 1454 { 1455 if (x == SIGNBIT) { 1456 SET_QC(); 1457 x = ~SIGNBIT; 1458 } else { 1459 x = -x; 1460 } 1461 return x; 1462 } 1463 1464 uint64_t HELPER(neon_qabs_s64)(CPUARMState *env, uint64_t x) 1465 { 1466 if (x == SIGNBIT64) { 1467 SET_QC(); 1468 x = ~SIGNBIT64; 1469 } else if ((int64_t)x < 0) { 1470 x = -x; 1471 } 1472 return x; 1473 } 1474 1475 uint64_t HELPER(neon_qneg_s64)(CPUARMState *env, uint64_t x) 1476 { 1477 if (x == SIGNBIT64) { 1478 SET_QC(); 1479 x = ~SIGNBIT64; 1480 } else { 1481 x = -x; 1482 } 1483 return x; 1484 } 1485 1486 /* NEON Float helpers. */ 1487 1488 /* Floating point comparisons produce an integer result. 1489 * Note that EQ doesn't signal InvalidOp for QNaNs but GE and GT do. 1490 * Softfloat routines return 0/1, which we convert to the 0/-1 Neon requires. 1491 */ 1492 uint32_t HELPER(neon_ceq_f32)(uint32_t a, uint32_t b, void *fpstp) 1493 { 1494 float_status *fpst = fpstp; 1495 return -float32_eq_quiet(make_float32(a), make_float32(b), fpst); 1496 } 1497 1498 uint32_t HELPER(neon_cge_f32)(uint32_t a, uint32_t b, void *fpstp) 1499 { 1500 float_status *fpst = fpstp; 1501 return -float32_le(make_float32(b), make_float32(a), fpst); 1502 } 1503 1504 uint32_t HELPER(neon_cgt_f32)(uint32_t a, uint32_t b, void *fpstp) 1505 { 1506 float_status *fpst = fpstp; 1507 return -float32_lt(make_float32(b), make_float32(a), fpst); 1508 } 1509 1510 uint32_t HELPER(neon_acge_f32)(uint32_t a, uint32_t b, void *fpstp) 1511 { 1512 float_status *fpst = fpstp; 1513 float32 f0 = float32_abs(make_float32(a)); 1514 float32 f1 = float32_abs(make_float32(b)); 1515 return -float32_le(f1, f0, fpst); 1516 } 1517 1518 uint32_t HELPER(neon_acgt_f32)(uint32_t a, uint32_t b, void *fpstp) 1519 { 1520 float_status *fpst = fpstp; 1521 float32 f0 = float32_abs(make_float32(a)); 1522 float32 f1 = float32_abs(make_float32(b)); 1523 return -float32_lt(f1, f0, fpst); 1524 } 1525 1526 uint64_t HELPER(neon_acge_f64)(uint64_t a, uint64_t b, void *fpstp) 1527 { 1528 float_status *fpst = fpstp; 1529 float64 f0 = float64_abs(make_float64(a)); 1530 float64 f1 = float64_abs(make_float64(b)); 1531 return -float64_le(f1, f0, fpst); 1532 } 1533 1534 uint64_t HELPER(neon_acgt_f64)(uint64_t a, uint64_t b, void *fpstp) 1535 { 1536 float_status *fpst = fpstp; 1537 float64 f0 = float64_abs(make_float64(a)); 1538 float64 f1 = float64_abs(make_float64(b)); 1539 return -float64_lt(f1, f0, fpst); 1540 } 1541 1542 #define ELEM(V, N, SIZE) (((V) >> ((N) * (SIZE))) & ((1ull << (SIZE)) - 1)) 1543 1544 void HELPER(neon_qunzip8)(void *vd, void *vm) 1545 { 1546 uint64_t *rd = vd, *rm = vm; 1547 uint64_t zd0 = rd[0], zd1 = rd[1]; 1548 uint64_t zm0 = rm[0], zm1 = rm[1]; 1549 1550 uint64_t d0 = ELEM(zd0, 0, 8) | (ELEM(zd0, 2, 8) << 8) 1551 | (ELEM(zd0, 4, 8) << 16) | (ELEM(zd0, 6, 8) << 24) 1552 | (ELEM(zd1, 0, 8) << 32) | (ELEM(zd1, 2, 8) << 40) 1553 | (ELEM(zd1, 4, 8) << 48) | (ELEM(zd1, 6, 8) << 56); 1554 uint64_t d1 = ELEM(zm0, 0, 8) | (ELEM(zm0, 2, 8) << 8) 1555 | (ELEM(zm0, 4, 8) << 16) | (ELEM(zm0, 6, 8) << 24) 1556 | (ELEM(zm1, 0, 8) << 32) | (ELEM(zm1, 2, 8) << 40) 1557 | (ELEM(zm1, 4, 8) << 48) | (ELEM(zm1, 6, 8) << 56); 1558 uint64_t m0 = ELEM(zd0, 1, 8) | (ELEM(zd0, 3, 8) << 8) 1559 | (ELEM(zd0, 5, 8) << 16) | (ELEM(zd0, 7, 8) << 24) 1560 | (ELEM(zd1, 1, 8) << 32) | (ELEM(zd1, 3, 8) << 40) 1561 | (ELEM(zd1, 5, 8) << 48) | (ELEM(zd1, 7, 8) << 56); 1562 uint64_t m1 = ELEM(zm0, 1, 8) | (ELEM(zm0, 3, 8) << 8) 1563 | (ELEM(zm0, 5, 8) << 16) | (ELEM(zm0, 7, 8) << 24) 1564 | (ELEM(zm1, 1, 8) << 32) | (ELEM(zm1, 3, 8) << 40) 1565 | (ELEM(zm1, 5, 8) << 48) | (ELEM(zm1, 7, 8) << 56); 1566 1567 rm[0] = m0; 1568 rm[1] = m1; 1569 rd[0] = d0; 1570 rd[1] = d1; 1571 } 1572 1573 void HELPER(neon_qunzip16)(void *vd, void *vm) 1574 { 1575 uint64_t *rd = vd, *rm = vm; 1576 uint64_t zd0 = rd[0], zd1 = rd[1]; 1577 uint64_t zm0 = rm[0], zm1 = rm[1]; 1578 1579 uint64_t d0 = ELEM(zd0, 0, 16) | (ELEM(zd0, 2, 16) << 16) 1580 | (ELEM(zd1, 0, 16) << 32) | (ELEM(zd1, 2, 16) << 48); 1581 uint64_t d1 = ELEM(zm0, 0, 16) | (ELEM(zm0, 2, 16) << 16) 1582 | (ELEM(zm1, 0, 16) << 32) | (ELEM(zm1, 2, 16) << 48); 1583 uint64_t m0 = ELEM(zd0, 1, 16) | (ELEM(zd0, 3, 16) << 16) 1584 | (ELEM(zd1, 1, 16) << 32) | (ELEM(zd1, 3, 16) << 48); 1585 uint64_t m1 = ELEM(zm0, 1, 16) | (ELEM(zm0, 3, 16) << 16) 1586 | (ELEM(zm1, 1, 16) << 32) | (ELEM(zm1, 3, 16) << 48); 1587 1588 rm[0] = m0; 1589 rm[1] = m1; 1590 rd[0] = d0; 1591 rd[1] = d1; 1592 } 1593 1594 void HELPER(neon_qunzip32)(void *vd, void *vm) 1595 { 1596 uint64_t *rd = vd, *rm = vm; 1597 uint64_t zd0 = rd[0], zd1 = rd[1]; 1598 uint64_t zm0 = rm[0], zm1 = rm[1]; 1599 1600 uint64_t d0 = ELEM(zd0, 0, 32) | (ELEM(zd1, 0, 32) << 32); 1601 uint64_t d1 = ELEM(zm0, 0, 32) | (ELEM(zm1, 0, 32) << 32); 1602 uint64_t m0 = ELEM(zd0, 1, 32) | (ELEM(zd1, 1, 32) << 32); 1603 uint64_t m1 = ELEM(zm0, 1, 32) | (ELEM(zm1, 1, 32) << 32); 1604 1605 rm[0] = m0; 1606 rm[1] = m1; 1607 rd[0] = d0; 1608 rd[1] = d1; 1609 } 1610 1611 void HELPER(neon_unzip8)(void *vd, void *vm) 1612 { 1613 uint64_t *rd = vd, *rm = vm; 1614 uint64_t zd = rd[0], zm = rm[0]; 1615 1616 uint64_t d0 = ELEM(zd, 0, 8) | (ELEM(zd, 2, 8) << 8) 1617 | (ELEM(zd, 4, 8) << 16) | (ELEM(zd, 6, 8) << 24) 1618 | (ELEM(zm, 0, 8) << 32) | (ELEM(zm, 2, 8) << 40) 1619 | (ELEM(zm, 4, 8) << 48) | (ELEM(zm, 6, 8) << 56); 1620 uint64_t m0 = ELEM(zd, 1, 8) | (ELEM(zd, 3, 8) << 8) 1621 | (ELEM(zd, 5, 8) << 16) | (ELEM(zd, 7, 8) << 24) 1622 | (ELEM(zm, 1, 8) << 32) | (ELEM(zm, 3, 8) << 40) 1623 | (ELEM(zm, 5, 8) << 48) | (ELEM(zm, 7, 8) << 56); 1624 1625 rm[0] = m0; 1626 rd[0] = d0; 1627 } 1628 1629 void HELPER(neon_unzip16)(void *vd, void *vm) 1630 { 1631 uint64_t *rd = vd, *rm = vm; 1632 uint64_t zd = rd[0], zm = rm[0]; 1633 1634 uint64_t d0 = ELEM(zd, 0, 16) | (ELEM(zd, 2, 16) << 16) 1635 | (ELEM(zm, 0, 16) << 32) | (ELEM(zm, 2, 16) << 48); 1636 uint64_t m0 = ELEM(zd, 1, 16) | (ELEM(zd, 3, 16) << 16) 1637 | (ELEM(zm, 1, 16) << 32) | (ELEM(zm, 3, 16) << 48); 1638 1639 rm[0] = m0; 1640 rd[0] = d0; 1641 } 1642 1643 void HELPER(neon_qzip8)(void *vd, void *vm) 1644 { 1645 uint64_t *rd = vd, *rm = vm; 1646 uint64_t zd0 = rd[0], zd1 = rd[1]; 1647 uint64_t zm0 = rm[0], zm1 = rm[1]; 1648 1649 uint64_t d0 = ELEM(zd0, 0, 8) | (ELEM(zm0, 0, 8) << 8) 1650 | (ELEM(zd0, 1, 8) << 16) | (ELEM(zm0, 1, 8) << 24) 1651 | (ELEM(zd0, 2, 8) << 32) | (ELEM(zm0, 2, 8) << 40) 1652 | (ELEM(zd0, 3, 8) << 48) | (ELEM(zm0, 3, 8) << 56); 1653 uint64_t d1 = ELEM(zd0, 4, 8) | (ELEM(zm0, 4, 8) << 8) 1654 | (ELEM(zd0, 5, 8) << 16) | (ELEM(zm0, 5, 8) << 24) 1655 | (ELEM(zd0, 6, 8) << 32) | (ELEM(zm0, 6, 8) << 40) 1656 | (ELEM(zd0, 7, 8) << 48) | (ELEM(zm0, 7, 8) << 56); 1657 uint64_t m0 = ELEM(zd1, 0, 8) | (ELEM(zm1, 0, 8) << 8) 1658 | (ELEM(zd1, 1, 8) << 16) | (ELEM(zm1, 1, 8) << 24) 1659 | (ELEM(zd1, 2, 8) << 32) | (ELEM(zm1, 2, 8) << 40) 1660 | (ELEM(zd1, 3, 8) << 48) | (ELEM(zm1, 3, 8) << 56); 1661 uint64_t m1 = ELEM(zd1, 4, 8) | (ELEM(zm1, 4, 8) << 8) 1662 | (ELEM(zd1, 5, 8) << 16) | (ELEM(zm1, 5, 8) << 24) 1663 | (ELEM(zd1, 6, 8) << 32) | (ELEM(zm1, 6, 8) << 40) 1664 | (ELEM(zd1, 7, 8) << 48) | (ELEM(zm1, 7, 8) << 56); 1665 1666 rm[0] = m0; 1667 rm[1] = m1; 1668 rd[0] = d0; 1669 rd[1] = d1; 1670 } 1671 1672 void HELPER(neon_qzip16)(void *vd, void *vm) 1673 { 1674 uint64_t *rd = vd, *rm = vm; 1675 uint64_t zd0 = rd[0], zd1 = rd[1]; 1676 uint64_t zm0 = rm[0], zm1 = rm[1]; 1677 1678 uint64_t d0 = ELEM(zd0, 0, 16) | (ELEM(zm0, 0, 16) << 16) 1679 | (ELEM(zd0, 1, 16) << 32) | (ELEM(zm0, 1, 16) << 48); 1680 uint64_t d1 = ELEM(zd0, 2, 16) | (ELEM(zm0, 2, 16) << 16) 1681 | (ELEM(zd0, 3, 16) << 32) | (ELEM(zm0, 3, 16) << 48); 1682 uint64_t m0 = ELEM(zd1, 0, 16) | (ELEM(zm1, 0, 16) << 16) 1683 | (ELEM(zd1, 1, 16) << 32) | (ELEM(zm1, 1, 16) << 48); 1684 uint64_t m1 = ELEM(zd1, 2, 16) | (ELEM(zm1, 2, 16) << 16) 1685 | (ELEM(zd1, 3, 16) << 32) | (ELEM(zm1, 3, 16) << 48); 1686 1687 rm[0] = m0; 1688 rm[1] = m1; 1689 rd[0] = d0; 1690 rd[1] = d1; 1691 } 1692 1693 void HELPER(neon_qzip32)(void *vd, void *vm) 1694 { 1695 uint64_t *rd = vd, *rm = vm; 1696 uint64_t zd0 = rd[0], zd1 = rd[1]; 1697 uint64_t zm0 = rm[0], zm1 = rm[1]; 1698 1699 uint64_t d0 = ELEM(zd0, 0, 32) | (ELEM(zm0, 0, 32) << 32); 1700 uint64_t d1 = ELEM(zd0, 1, 32) | (ELEM(zm0, 1, 32) << 32); 1701 uint64_t m0 = ELEM(zd1, 0, 32) | (ELEM(zm1, 0, 32) << 32); 1702 uint64_t m1 = ELEM(zd1, 1, 32) | (ELEM(zm1, 1, 32) << 32); 1703 1704 rm[0] = m0; 1705 rm[1] = m1; 1706 rd[0] = d0; 1707 rd[1] = d1; 1708 } 1709 1710 void HELPER(neon_zip8)(void *vd, void *vm) 1711 { 1712 uint64_t *rd = vd, *rm = vm; 1713 uint64_t zd = rd[0], zm = rm[0]; 1714 1715 uint64_t d0 = ELEM(zd, 0, 8) | (ELEM(zm, 0, 8) << 8) 1716 | (ELEM(zd, 1, 8) << 16) | (ELEM(zm, 1, 8) << 24) 1717 | (ELEM(zd, 2, 8) << 32) | (ELEM(zm, 2, 8) << 40) 1718 | (ELEM(zd, 3, 8) << 48) | (ELEM(zm, 3, 8) << 56); 1719 uint64_t m0 = ELEM(zd, 4, 8) | (ELEM(zm, 4, 8) << 8) 1720 | (ELEM(zd, 5, 8) << 16) | (ELEM(zm, 5, 8) << 24) 1721 | (ELEM(zd, 6, 8) << 32) | (ELEM(zm, 6, 8) << 40) 1722 | (ELEM(zd, 7, 8) << 48) | (ELEM(zm, 7, 8) << 56); 1723 1724 rm[0] = m0; 1725 rd[0] = d0; 1726 } 1727 1728 void HELPER(neon_zip16)(void *vd, void *vm) 1729 { 1730 uint64_t *rd = vd, *rm = vm; 1731 uint64_t zd = rd[0], zm = rm[0]; 1732 1733 uint64_t d0 = ELEM(zd, 0, 16) | (ELEM(zm, 0, 16) << 16) 1734 | (ELEM(zd, 1, 16) << 32) | (ELEM(zm, 1, 16) << 48); 1735 uint64_t m0 = ELEM(zd, 2, 16) | (ELEM(zm, 2, 16) << 16) 1736 | (ELEM(zd, 3, 16) << 32) | (ELEM(zm, 3, 16) << 48); 1737 1738 rm[0] = m0; 1739 rd[0] = d0; 1740 }