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