![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to op_neon.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / target-arm|
Return to op_neon.h CVS log | Up to [Qemu by Fabrice Bellard] / qemu / target-arm |
1.1 ! root 1: /* ! 2: * ARM NEON vector operations. ! 3: * ! 4: * Copyright (c) 2007 CodeSourcery. ! 5: * Written by Paul Brook ! 6: * ! 7: * This code is licenced under the GPL. ! 8: */ ! 9: /* Note that for NEON an "l" prefix means it is a wide operation, unlike ! 10: scalar arm ops where it means a word size operation. */ ! 11: ! 12: /* ??? NEON ops should probably have their own float status. */ ! 13: #define NFS &env->vfp.fp_status ! 14: #define NEON_OP(name) void OPPROTO op_neon_##name (void) ! 15: ! 16: NEON_OP(getreg_T0) ! 17: { ! 18: T0 = *(uint32_t *)((char *) env + PARAM1); ! 19: } ! 20: ! 21: NEON_OP(getreg_T1) ! 22: { ! 23: T1 = *(uint32_t *)((char *) env + PARAM1); ! 24: } ! 25: ! 26: NEON_OP(getreg_T2) ! 27: { ! 28: T2 = *(uint32_t *)((char *) env + PARAM1); ! 29: } ! 30: ! 31: NEON_OP(setreg_T0) ! 32: { ! 33: *(uint32_t *)((char *) env + PARAM1) = T0; ! 34: } ! 35: ! 36: NEON_OP(setreg_T1) ! 37: { ! 38: *(uint32_t *)((char *) env + PARAM1) = T1; ! 39: } ! 40: ! 41: NEON_OP(setreg_T2) ! 42: { ! 43: *(uint32_t *)((char *) env + PARAM1) = T2; ! 44: } ! 45: ! 46: #define NEON_TYPE1(name, type) \ ! 47: typedef struct \ ! 48: { \ ! 49: type v1; \ ! 50: } neon_##name; ! 51: #ifdef WORDS_BIGENDIAN ! 52: #define NEON_TYPE2(name, type) \ ! 53: typedef struct \ ! 54: { \ ! 55: type v2; \ ! 56: type v1; \ ! 57: } neon_##name; ! 58: #define NEON_TYPE4(name, type) \ ! 59: typedef struct \ ! 60: { \ ! 61: type v4; \ ! 62: type v3; \ ! 63: type v2; \ ! 64: type v1; \ ! 65: } neon_##name; ! 66: #else ! 67: #define NEON_TYPE2(name, type) \ ! 68: typedef struct \ ! 69: { \ ! 70: type v1; \ ! 71: type v2; \ ! 72: } neon_##name; ! 73: #define NEON_TYPE4(name, type) \ ! 74: typedef struct \ ! 75: { \ ! 76: type v1; \ ! 77: type v2; \ ! 78: type v3; \ ! 79: type v4; \ ! 80: } neon_##name; ! 81: #endif ! 82: ! 83: NEON_TYPE4(s8, int8_t) ! 84: NEON_TYPE4(u8, uint8_t) ! 85: NEON_TYPE2(s16, int16_t) ! 86: NEON_TYPE2(u16, uint16_t) ! 87: NEON_TYPE1(s32, int32_t) ! 88: NEON_TYPE1(u32, uint32_t) ! 89: #undef NEON_TYPE4 ! 90: #undef NEON_TYPE2 ! 91: #undef NEON_TYPE1 ! 92: ! 93: /* Copy from a uint32_t to a vector structure type. */ ! 94: #define NEON_UNPACK(vtype, dest, val) do { \ ! 95: union { \ ! 96: vtype v; \ ! 97: uint32_t i; \ ! 98: } conv_u; \ ! 99: conv_u.i = (val); \ ! 100: dest = conv_u.v; \ ! 101: } while(0) ! 102: ! 103: /* Copy from a vector structure type to a uint32_t. */ ! 104: #define NEON_PACK(vtype, dest, val) do { \ ! 105: union { \ ! 106: vtype v; \ ! 107: uint32_t i; \ ! 108: } conv_u; \ ! 109: conv_u.v = (val); \ ! 110: dest = conv_u.i; \ ! 111: } while(0) ! 112: ! 113: #define NEON_DO1 \ ! 114: NEON_FN(vdest.v1, vsrc1.v1, vsrc2.v1); ! 115: #define NEON_DO2 \ ! 116: NEON_FN(vdest.v1, vsrc1.v1, vsrc2.v1); \ ! 117: NEON_FN(vdest.v2, vsrc1.v2, vsrc2.v2); ! 118: #define NEON_DO4 \ ! 119: NEON_FN(vdest.v1, vsrc1.v1, vsrc2.v1); \ ! 120: NEON_FN(vdest.v2, vsrc1.v2, vsrc2.v2); \ ! 121: NEON_FN(vdest.v3, vsrc1.v3, vsrc2.v3); \ ! 122: NEON_FN(vdest.v4, vsrc1.v4, vsrc2.v4); ! 123: ! 124: #define NEON_VOP(name, vtype, n) \ ! 125: NEON_OP(name) \ ! 126: { \ ! 127: vtype vsrc1; \ ! 128: vtype vsrc2; \ ! 129: vtype vdest; \ ! 130: NEON_UNPACK(vtype, vsrc1, T0); \ ! 131: NEON_UNPACK(vtype, vsrc2, T1); \ ! 132: NEON_DO##n; \ ! 133: NEON_PACK(vtype, T0, vdest); \ ! 134: FORCE_RET(); \ ! 135: } ! 136: ! 137: #define NEON_VOP1(name, vtype, n) \ ! 138: NEON_OP(name) \ ! 139: { \ ! 140: vtype vsrc1; \ ! 141: vtype vdest; \ ! 142: NEON_UNPACK(vtype, vsrc1, T0); \ ! 143: NEON_DO##n; \ ! 144: NEON_PACK(vtype, T0, vdest); \ ! 145: FORCE_RET(); \ ! 146: } ! 147: ! 148: /* Pairwise operations. */ ! 149: /* For 32-bit elements each segment only contains a single element, so ! 150: the elementwise and pairwise operations are the same. */ ! 151: #define NEON_PDO2 \ ! 152: NEON_FN(vdest.v1, vsrc1.v1, vsrc1.v2); \ ! 153: NEON_FN(vdest.v2, vsrc2.v1, vsrc2.v2); ! 154: #define NEON_PDO4 \ ! 155: NEON_FN(vdest.v1, vsrc1.v1, vsrc1.v2); \ ! 156: NEON_FN(vdest.v2, vsrc1.v3, vsrc1.v4); \ ! 157: NEON_FN(vdest.v3, vsrc2.v1, vsrc2.v2); \ ! 158: NEON_FN(vdest.v4, vsrc2.v3, vsrc2.v4); \ ! 159: ! 160: #define NEON_POP(name, vtype, n) \ ! 161: NEON_OP(name) \ ! 162: { \ ! 163: vtype vsrc1; \ ! 164: vtype vsrc2; \ ! 165: vtype vdest; \ ! 166: NEON_UNPACK(vtype, vsrc1, T0); \ ! 167: NEON_UNPACK(vtype, vsrc2, T1); \ ! 168: NEON_PDO##n; \ ! 169: NEON_PACK(vtype, T0, vdest); \ ! 170: FORCE_RET(); \ ! 171: } ! 172: ! 173: #define NEON_FN(dest, src1, src2) dest = (src1 + src2) >> 1 ! 174: NEON_VOP(hadd_s8, neon_s8, 4) ! 175: NEON_VOP(hadd_u8, neon_u8, 4) ! 176: NEON_VOP(hadd_s16, neon_s16, 2) ! 177: NEON_VOP(hadd_u16, neon_u16, 2) ! 178: #undef NEON_FN ! 179: ! 180: NEON_OP(hadd_s32) ! 181: { ! 182: int32_t src1 = T0; ! 183: int32_t src2 = T1; ! 184: int32_t dest; ! 185: ! 186: dest = (src1 >> 1) + (src2 >> 1); ! 187: if (src1 & src2 & 1) ! 188: dest++; ! 189: T0 = dest; ! 190: FORCE_RET(); ! 191: } ! 192: ! 193: NEON_OP(hadd_u32) ! 194: { ! 195: uint32_t src1 = T0; ! 196: uint32_t src2 = T1; ! 197: uint32_t dest; ! 198: ! 199: dest = (src1 >> 1) + (src2 >> 1); ! 200: if (src1 & src2 & 1) ! 201: dest++; ! 202: T0 = dest; ! 203: FORCE_RET(); ! 204: } ! 205: ! 206: #define NEON_FN(dest, src1, src2) dest = (src1 + src2 + 1) >> 1 ! 207: NEON_VOP(rhadd_s8, neon_s8, 4) ! 208: NEON_VOP(rhadd_u8, neon_u8, 4) ! 209: NEON_VOP(rhadd_s16, neon_s16, 2) ! 210: NEON_VOP(rhadd_u16, neon_u16, 2) ! 211: #undef NEON_FN ! 212: ! 213: NEON_OP(rhadd_s32) ! 214: { ! 215: int32_t src1 = T0; ! 216: int32_t src2 = T1; ! 217: int32_t dest; ! 218: ! 219: dest = (src1 >> 1) + (src2 >> 1); ! 220: if ((src1 | src2) & 1) ! 221: dest++; ! 222: T0 = dest; ! 223: FORCE_RET(); ! 224: } ! 225: ! 226: NEON_OP(rhadd_u32) ! 227: { ! 228: uint32_t src1 = T0; ! 229: uint32_t src2 = T1; ! 230: uint32_t dest; ! 231: ! 232: dest = (src1 >> 1) + (src2 >> 1); ! 233: if ((src1 | src2) & 1) ! 234: dest++; ! 235: T0 = dest; ! 236: FORCE_RET(); ! 237: } ! 238: ! 239: #define NEON_FN(dest, src1, src2) dest = (src1 - src2) >> 1 ! 240: NEON_VOP(hsub_s8, neon_s8, 4) ! 241: NEON_VOP(hsub_u8, neon_u8, 4) ! 242: NEON_VOP(hsub_s16, neon_s16, 2) ! 243: NEON_VOP(hsub_u16, neon_u16, 2) ! 244: #undef NEON_FN ! 245: ! 246: NEON_OP(hsub_s32) ! 247: { ! 248: int32_t src1 = T0; ! 249: int32_t src2 = T1; ! 250: int32_t dest; ! 251: ! 252: dest = (src1 >> 1) - (src2 >> 1); ! 253: if ((~src1) & src2 & 1) ! 254: dest--; ! 255: T0 = dest; ! 256: FORCE_RET(); ! 257: } ! 258: ! 259: NEON_OP(hsub_u32) ! 260: { ! 261: uint32_t src1 = T0; ! 262: uint32_t src2 = T1; ! 263: uint32_t dest; ! 264: ! 265: dest = (src1 >> 1) - (src2 >> 1); ! 266: if ((~src1) & src2 & 1) ! 267: dest--; ! 268: T0 = dest; ! 269: FORCE_RET(); ! 270: } ! 271: ! 272: /* ??? bsl, bif and bit are all the same op, just with the oparands in a ! 273: differnet order. It's currently easier to have 3 differnt ops than ! 274: rearange the operands. */ ! 275: ! 276: /* Bitwise Select. */ ! 277: NEON_OP(bsl) ! 278: { ! 279: T0 = (T0 & T2) | (T1 & ~T2); ! 280: } ! 281: ! 282: /* Bitwise Insert If True. */ ! 283: NEON_OP(bit) ! 284: { ! 285: T0 = (T0 & T1) | (T2 & ~T1); ! 286: } ! 287: ! 288: /* Bitwise Insert If False. */ ! 289: NEON_OP(bif) ! 290: { ! 291: T0 = (T2 & T1) | (T0 & ~T1); ! 292: } ! 293: ! 294: #define NEON_USAT(dest, src1, src2, type) do { \ ! 295: uint32_t tmp = (uint32_t)src1 + (uint32_t)src2; \ ! 296: if (tmp != (type)tmp) { \ ! 297: env->QF = 1; \ ! 298: dest = ~0; \ ! 299: } else { \ ! 300: dest = tmp; \ ! 301: }} while(0) ! 302: #define NEON_FN(dest, src1, src2) NEON_USAT(dest, src1, src2, uint8_t) ! 303: NEON_VOP(qadd_u8, neon_u8, 4) ! 304: #undef NEON_FN ! 305: #define NEON_FN(dest, src1, src2) NEON_USAT(dest, src1, src2, uint16_t) ! 306: NEON_VOP(qadd_u16, neon_u16, 2) ! 307: #undef NEON_FN ! 308: #undef NEON_USAT ! 309: ! 310: #define NEON_SSAT(dest, src1, src2, type) do { \ ! 311: int32_t tmp = (uint32_t)src1 + (uint32_t)src2; \ ! 312: if (tmp != (type)tmp) { \ ! 313: env->QF = 1; \ ! 314: if (src2 > 0) { \ ! 315: tmp = (1 << (sizeof(type) * 8 - 1)) - 1; \ ! 316: } else { \ ! 317: tmp = 1 << (sizeof(type) * 8 - 1); \ ! 318: } \ ! 319: } \ ! 320: dest = tmp; \ ! 321: } while(0) ! 322: #define NEON_FN(dest, src1, src2) NEON_SSAT(dest, src1, src2, int8_t) ! 323: NEON_VOP(qadd_s8, neon_s8, 4) ! 324: #undef NEON_FN ! 325: #define NEON_FN(dest, src1, src2) NEON_SSAT(dest, src1, src2, int16_t) ! 326: NEON_VOP(qadd_s16, neon_s16, 2) ! 327: #undef NEON_FN ! 328: #undef NEON_SSAT ! 329: ! 330: #define NEON_USAT(dest, src1, src2, type) do { \ ! 331: uint32_t tmp = (uint32_t)src1 - (uint32_t)src2; \ ! 332: if (tmp != (type)tmp) { \ ! 333: env->QF = 1; \ ! 334: dest = 0; \ ! 335: } else { \ ! 336: dest = tmp; \ ! 337: }} while(0) ! 338: #define NEON_FN(dest, src1, src2) NEON_USAT(dest, src1, src2, uint8_t) ! 339: NEON_VOP(qsub_u8, neon_u8, 4) ! 340: #undef NEON_FN ! 341: #define NEON_FN(dest, src1, src2) NEON_USAT(dest, src1, src2, uint16_t) ! 342: NEON_VOP(qsub_u16, neon_u16, 2) ! 343: #undef NEON_FN ! 344: #undef NEON_USAT ! 345: ! 346: #define NEON_SSAT(dest, src1, src2, type) do { \ ! 347: int32_t tmp = (uint32_t)src1 - (uint32_t)src2; \ ! 348: if (tmp != (type)tmp) { \ ! 349: env->QF = 1; \ ! 350: if (src2 < 0) { \ ! 351: tmp = (1 << (sizeof(type) * 8 - 1)) - 1; \ ! 352: } else { \ ! 353: tmp = 1 << (sizeof(type) * 8 - 1); \ ! 354: } \ ! 355: } \ ! 356: dest = tmp; \ ! 357: } while(0) ! 358: #define NEON_FN(dest, src1, src2) NEON_SSAT(dest, src1, src2, int8_t) ! 359: NEON_VOP(qsub_s8, neon_s8, 4) ! 360: #undef NEON_FN ! 361: #define NEON_FN(dest, src1, src2) NEON_SSAT(dest, src1, src2, int16_t) ! 362: NEON_VOP(qsub_s16, neon_s16, 2) ! 363: #undef NEON_FN ! 364: #undef NEON_SSAT ! 365: ! 366: #define NEON_FN(dest, src1, src2) dest = (src1 > src2) ? ~0 : 0 ! 367: NEON_VOP(cgt_s8, neon_s8, 4) ! 368: NEON_VOP(cgt_u8, neon_u8, 4) ! 369: NEON_VOP(cgt_s16, neon_s16, 2) ! 370: NEON_VOP(cgt_u16, neon_u16, 2) ! 371: NEON_VOP(cgt_s32, neon_s32, 1) ! 372: NEON_VOP(cgt_u32, neon_u32, 1) ! 373: #undef NEON_FN ! 374: ! 375: #define NEON_FN(dest, src1, src2) dest = (src1 >= src2) ? ~0 : 0 ! 376: NEON_VOP(cge_s8, neon_s8, 4) ! 377: NEON_VOP(cge_u8, neon_u8, 4) ! 378: NEON_VOP(cge_s16, neon_s16, 2) ! 379: NEON_VOP(cge_u16, neon_u16, 2) ! 380: NEON_VOP(cge_s32, neon_s32, 1) ! 381: NEON_VOP(cge_u32, neon_u32, 1) ! 382: #undef NEON_FN ! 383: ! 384: #define NEON_FN(dest, src1, src2) do { \ ! 385: int8_t tmp; \ ! 386: tmp = (int8_t)src2; \ ! 387: if (tmp < 0) { \ ! 388: dest = src1 >> -tmp; \ ! 389: } else { \ ! 390: dest = src1 << tmp; \ ! 391: }} while (0) ! 392: NEON_VOP(shl_s8, neon_s8, 4) ! 393: NEON_VOP(shl_u8, neon_u8, 4) ! 394: NEON_VOP(shl_s16, neon_s16, 2) ! 395: NEON_VOP(shl_u16, neon_u16, 2) ! 396: NEON_VOP(shl_s32, neon_s32, 1) ! 397: NEON_VOP(shl_u32, neon_u32, 1) ! 398: #undef NEON_FN ! 399: ! 400: NEON_OP(shl_u64) ! 401: { ! 402: int8_t shift = T2; ! 403: uint64_t val = T0 | ((uint64_t)T1 << 32); ! 404: if (shift < 0) { ! 405: val >>= -shift; ! 406: } else { ! 407: val <<= shift; ! 408: } ! 409: T0 = val; ! 410: T1 = val >> 32; ! 411: FORCE_RET(); ! 412: } ! 413: ! 414: NEON_OP(shl_s64) ! 415: { ! 416: int8_t shift = T2; ! 417: int64_t val = T0 | ((uint64_t)T1 << 32); ! 418: if (shift < 0) { ! 419: val >>= -shift; ! 420: } else { ! 421: val <<= shift; ! 422: } ! 423: T0 = val; ! 424: T1 = val >> 32; ! 425: FORCE_RET(); ! 426: } ! 427: ! 428: #define NEON_FN(dest, src1, src2) do { \ ! 429: int8_t tmp; \ ! 430: tmp = (int8_t)src1; \ ! 431: if (tmp < 0) { \ ! 432: dest = (src2 + (1 << (-1 - tmp))) >> -tmp; \ ! 433: } else { \ ! 434: dest = src2 << tmp; \ ! 435: }} while (0) ! 436: ! 437: NEON_VOP(rshl_s8, neon_s8, 4) ! 438: NEON_VOP(rshl_u8, neon_u8, 4) ! 439: NEON_VOP(rshl_s16, neon_s16, 2) ! 440: NEON_VOP(rshl_u16, neon_u16, 2) ! 441: NEON_VOP(rshl_s32, neon_s32, 1) ! 442: NEON_VOP(rshl_u32, neon_u32, 1) ! 443: #undef NEON_FN ! 444: ! 445: NEON_OP(rshl_u64) ! 446: { ! 447: int8_t shift = T2; ! 448: uint64_t val = T0 | ((uint64_t)T1 << 32); ! 449: if (shift < 0) { ! 450: val = (val + ((uint64_t)1 << (-1 - shift))) >> -shift; ! 451: val >>= -shift; ! 452: } else { ! 453: val <<= shift; ! 454: } ! 455: T0 = val; ! 456: T1 = val >> 32; ! 457: FORCE_RET(); ! 458: } ! 459: ! 460: NEON_OP(rshl_s64) ! 461: { ! 462: int8_t shift = T2; ! 463: int64_t val = T0 | ((uint64_t)T1 << 32); ! 464: if (shift < 0) { ! 465: val = (val + ((int64_t)1 << (-1 - shift))) >> -shift; ! 466: } else { ! 467: val <<= shift; ! 468: } ! 469: T0 = val; ! 470: T1 = val >> 32; ! 471: FORCE_RET(); ! 472: } ! 473: ! 474: #define NEON_FN(dest, src1, src2) do { \ ! 475: int8_t tmp; \ ! 476: tmp = (int8_t)src1; \ ! 477: if (tmp < 0) { \ ! 478: dest = src2 >> -tmp; \ ! 479: } else { \ ! 480: dest = src2 << tmp; \ ! 481: if ((dest >> tmp) != src2) { \ ! 482: env->QF = 1; \ ! 483: dest = ~0; \ ! 484: } \ ! 485: }} while (0) ! 486: NEON_VOP(qshl_s8, neon_s8, 4) ! 487: NEON_VOP(qshl_s16, neon_s16, 2) ! 488: NEON_VOP(qshl_s32, neon_s32, 1) ! 489: #undef NEON_FN ! 490: ! 491: NEON_OP(qshl_s64) ! 492: { ! 493: int8_t shift = T2; ! 494: int64_t val = T0 | ((uint64_t)T1 << 32); ! 495: if (shift < 0) { ! 496: val >>= -shift; ! 497: } else { ! 498: int64_t tmp = val; ! 499: val <<= shift; ! 500: if ((val >> shift) != tmp) { ! 501: env->QF = 1; ! 502: val = (tmp >> 63) ^ 0x7fffffffffffffffULL; ! 503: } ! 504: } ! 505: T0 = val; ! 506: T1 = val >> 32; ! 507: FORCE_RET(); ! 508: } ! 509: ! 510: #define NEON_FN(dest, src1, src2) do { \ ! 511: int8_t tmp; \ ! 512: tmp = (int8_t)src1; \ ! 513: if (tmp < 0) { \ ! 514: dest = src2 >> -tmp; \ ! 515: } else { \ ! 516: dest = src2 << tmp; \ ! 517: if ((dest >> tmp) != src2) { \ ! 518: env->QF = 1; \ ! 519: dest = src2 >> 31; \ ! 520: } \ ! 521: }} while (0) ! 522: NEON_VOP(qshl_u8, neon_u8, 4) ! 523: NEON_VOP(qshl_u16, neon_u16, 2) ! 524: NEON_VOP(qshl_u32, neon_u32, 1) ! 525: #undef NEON_FN ! 526: ! 527: NEON_OP(qshl_u64) ! 528: { ! 529: int8_t shift = T2; ! 530: uint64_t val = T0 | ((uint64_t)T1 << 32); ! 531: if (shift < 0) { ! 532: val >>= -shift; ! 533: } else { ! 534: uint64_t tmp = val; ! 535: val <<= shift; ! 536: if ((val >> shift) != tmp) { ! 537: env->QF = 1; ! 538: val = ~(uint64_t)0; ! 539: } ! 540: } ! 541: T0 = val; ! 542: T1 = val >> 32; ! 543: FORCE_RET(); ! 544: } ! 545: ! 546: #define NEON_FN(dest, src1, src2) do { \ ! 547: int8_t tmp; \ ! 548: tmp = (int8_t)src1; \ ! 549: if (tmp < 0) { \ ! 550: dest = (src2 + (1 << (-1 - tmp))) >> -tmp; \ ! 551: } else { \ ! 552: dest = src2 << tmp; \ ! 553: if ((dest >> tmp) != src2) { \ ! 554: dest = ~0; \ ! 555: } \ ! 556: }} while (0) ! 557: NEON_VOP(qrshl_s8, neon_s8, 4) ! 558: NEON_VOP(qrshl_s16, neon_s16, 2) ! 559: NEON_VOP(qrshl_s32, neon_s32, 1) ! 560: #undef NEON_FN ! 561: ! 562: #define NEON_FN(dest, src1, src2) do { \ ! 563: int8_t tmp; \ ! 564: tmp = (int8_t)src1; \ ! 565: if (tmp < 0) { \ ! 566: dest = (src2 + (1 << (-1 - tmp))) >> -tmp; \ ! 567: } else { \ ! 568: dest = src2 << tmp; \ ! 569: if ((dest >> tmp) != src2) { \ ! 570: env->QF = 1; \ ! 571: dest = src2 >> 31; \ ! 572: } \ ! 573: }} while (0) ! 574: NEON_VOP(qrshl_u8, neon_u8, 4) ! 575: NEON_VOP(qrshl_u16, neon_u16, 2) ! 576: NEON_VOP(qrshl_u32, neon_u32, 1) ! 577: #undef NEON_FN ! 578: ! 579: #define NEON_FN(dest, src1, src2) dest = (src1 > src2) ? src1 : src2 ! 580: NEON_VOP(max_s8, neon_s8, 4) ! 581: NEON_VOP(max_u8, neon_u8, 4) ! 582: NEON_VOP(max_s16, neon_s16, 2) ! 583: NEON_VOP(max_u16, neon_u16, 2) ! 584: NEON_VOP(max_s32, neon_s32, 1) ! 585: NEON_VOP(max_u32, neon_u32, 1) ! 586: NEON_POP(pmax_s8, neon_s8, 4) ! 587: NEON_POP(pmax_u8, neon_u8, 4) ! 588: NEON_POP(pmax_s16, neon_s16, 2) ! 589: NEON_POP(pmax_u16, neon_u16, 2) ! 590: #undef NEON_FN ! 591: ! 592: NEON_OP(max_f32) ! 593: { ! 594: float32 f0 = vfp_itos(T0); ! 595: float32 f1 = vfp_itos(T1); ! 596: T0 = (float32_compare_quiet(f0, f1, NFS) == 1) ? T0 : T1; ! 597: FORCE_RET(); ! 598: } ! 599: ! 600: #define NEON_FN(dest, src1, src2) dest = (src1 < src2) ? src1 : src2 ! 601: NEON_VOP(min_s8, neon_s8, 4) ! 602: NEON_VOP(min_u8, neon_u8, 4) ! 603: NEON_VOP(min_s16, neon_s16, 2) ! 604: NEON_VOP(min_u16, neon_u16, 2) ! 605: NEON_VOP(min_s32, neon_s32, 1) ! 606: NEON_VOP(min_u32, neon_u32, 1) ! 607: NEON_POP(pmin_s8, neon_s8, 4) ! 608: NEON_POP(pmin_u8, neon_u8, 4) ! 609: NEON_POP(pmin_s16, neon_s16, 2) ! 610: NEON_POP(pmin_u16, neon_u16, 2) ! 611: #undef NEON_FN ! 612: ! 613: NEON_OP(min_f32) ! 614: { ! 615: float32 f0 = vfp_itos(T0); ! 616: float32 f1 = vfp_itos(T1); ! 617: T0 = (float32_compare_quiet(f0, f1, NFS) == -1) ? T0 : T1; ! 618: FORCE_RET(); ! 619: } ! 620: ! 621: #define NEON_FN(dest, src1, src2) \ ! 622: dest = (src1 > src2) ? (src1 - src2) : (src2 - src1) ! 623: NEON_VOP(abd_s8, neon_s8, 4) ! 624: NEON_VOP(abd_u8, neon_u8, 4) ! 625: NEON_VOP(abd_s16, neon_s16, 2) ! 626: NEON_VOP(abd_u16, neon_u16, 2) ! 627: NEON_VOP(abd_s32, neon_s32, 1) ! 628: NEON_VOP(abd_u32, neon_u32, 1) ! 629: #undef NEON_FN ! 630: ! 631: NEON_OP(abd_f32) ! 632: { ! 633: float32 f0 = vfp_itos(T0); ! 634: float32 f1 = vfp_itos(T1); ! 635: T0 = vfp_stoi((float32_compare_quiet(f0, f1, NFS) == 1) ! 636: ? float32_sub(f0, f1, NFS) ! 637: : float32_sub(f1, f0, NFS)); ! 638: FORCE_RET(); ! 639: } ! 640: ! 641: #define NEON_FN(dest, src1, src2) dest = src1 + src2 ! 642: NEON_VOP(add_u8, neon_u8, 4) ! 643: NEON_VOP(add_u16, neon_u16, 2) ! 644: NEON_POP(padd_u8, neon_u8, 4) ! 645: NEON_POP(padd_u16, neon_u16, 2) ! 646: #undef NEON_FN ! 647: ! 648: NEON_OP(add_f32) ! 649: { ! 650: T0 = vfp_stoi(float32_add(vfp_itos(T0), vfp_itos(T1), NFS)); ! 651: FORCE_RET(); ! 652: } ! 653: ! 654: #define NEON_FN(dest, src1, src2) dest = src1 - src2 ! 655: NEON_VOP(sub_u8, neon_u8, 4) ! 656: NEON_VOP(sub_u16, neon_u16, 2) ! 657: #undef NEON_FN ! 658: ! 659: NEON_OP(sub_f32) ! 660: { ! 661: T0 = vfp_stoi(float32_sub(vfp_itos(T0), vfp_itos(T1), NFS)); ! 662: FORCE_RET(); ! 663: } ! 664: ! 665: #define NEON_FN(dest, src1, src2) dest = src2 - src1 ! 666: NEON_VOP(rsb_u8, neon_u8, 4) ! 667: NEON_VOP(rsb_u16, neon_u16, 2) ! 668: #undef NEON_FN ! 669: ! 670: NEON_OP(rsb_f32) ! 671: { ! 672: T0 = vfp_stoi(float32_sub(vfp_itos(T1), vfp_itos(T0), NFS)); ! 673: FORCE_RET(); ! 674: } ! 675: ! 676: #define NEON_FN(dest, src1, src2) dest = src1 * src2 ! 677: NEON_VOP(mul_u8, neon_u8, 4) ! 678: NEON_VOP(mul_u16, neon_u16, 2) ! 679: #undef NEON_FN ! 680: ! 681: NEON_OP(mul_f32) ! 682: { ! 683: T0 = vfp_stoi(float32_mul(vfp_itos(T0), vfp_itos(T1), NFS)); ! 684: FORCE_RET(); ! 685: } ! 686: ! 687: NEON_OP(mul_p8) ! 688: { ! 689: T0 = helper_neon_mul_p8(T0, T1); ! 690: } ! 691: ! 692: #define NEON_FN(dest, src1, src2) dest = (src1 & src2) ? -1 : 0 ! 693: NEON_VOP(tst_u8, neon_u8, 4) ! 694: NEON_VOP(tst_u16, neon_u16, 2) ! 695: NEON_VOP(tst_u32, neon_u32, 1) ! 696: #undef NEON_FN ! 697: ! 698: #define NEON_FN(dest, src1, src2) dest = (src1 == src2) ? -1 : 0 ! 699: NEON_VOP(ceq_u8, neon_u8, 4) ! 700: NEON_VOP(ceq_u16, neon_u16, 2) ! 701: NEON_VOP(ceq_u32, neon_u32, 1) ! 702: #undef NEON_FN ! 703: ! 704: #define NEON_QDMULH16(dest, src1, src2, round) do { \ ! 705: uint32_t tmp = (int32_t)(int16_t) src1 * (int16_t) src2; \ ! 706: if ((tmp ^ (tmp << 1)) & SIGNBIT) { \ ! 707: env->QF = 1; \ ! 708: tmp = (tmp >> 31) ^ ~SIGNBIT; \ ! 709: } \ ! 710: tmp <<= 1; \ ! 711: if (round) { \ ! 712: int32_t old = tmp; \ ! 713: tmp += 1 << 15; \ ! 714: if ((int32_t)tmp < old) { \ ! 715: env->QF = 1; \ ! 716: tmp = SIGNBIT - 1; \ ! 717: } \ ! 718: } \ ! 719: dest = tmp >> 16; \ ! 720: } while(0) ! 721: #define NEON_FN(dest, src1, src2) NEON_QDMULH16(dest, src1, src2, 0) ! 722: NEON_VOP(qdmulh_s16, neon_s16, 2) ! 723: #undef NEON_FN ! 724: #define NEON_FN(dest, src1, src2) NEON_QDMULH16(dest, src1, src2, 1) ! 725: NEON_VOP(qrdmulh_s16, neon_s16, 2) ! 726: #undef NEON_FN ! 727: #undef NEON_QDMULH16 ! 728: ! 729: #define SIGNBIT64 ((uint64_t)1 << 63) ! 730: #define NEON_QDMULH32(dest, src1, src2, round) do { \ ! 731: uint64_t tmp = (int64_t)(int32_t) src1 * (int32_t) src2; \ ! 732: if ((tmp ^ (tmp << 1)) & SIGNBIT64) { \ ! 733: env->QF = 1; \ ! 734: tmp = (tmp >> 63) ^ ~SIGNBIT64; \ ! 735: } else { \ ! 736: tmp <<= 1; \ ! 737: } \ ! 738: if (round) { \ ! 739: int64_t old = tmp; \ ! 740: tmp += (int64_t)1 << 31; \ ! 741: if ((int64_t)tmp < old) { \ ! 742: env->QF = 1; \ ! 743: tmp = SIGNBIT64 - 1; \ ! 744: } \ ! 745: } \ ! 746: dest = tmp >> 32; \ ! 747: } while(0) ! 748: #define NEON_FN(dest, src1, src2) NEON_QDMULH32(dest, src1, src2, 0) ! 749: NEON_VOP(qdmulh_s32, neon_s32, 1) ! 750: #undef NEON_FN ! 751: #define NEON_FN(dest, src1, src2) NEON_QDMULH32(dest, src1, src2, 1) ! 752: NEON_VOP(qrdmulh_s32, neon_s32, 1) ! 753: #undef NEON_FN ! 754: #undef NEON_QDMULH32 ! 755: ! 756: NEON_OP(recps_f32) ! 757: { ! 758: T0 = vfp_stoi(helper_recps_f32(vfp_itos(T0), vfp_itos(T1))); ! 759: FORCE_RET(); ! 760: } ! 761: ! 762: NEON_OP(rsqrts_f32) ! 763: { ! 764: T0 = vfp_stoi(helper_rsqrts_f32(vfp_itos(T0), vfp_itos(T1))); ! 765: FORCE_RET(); ! 766: } ! 767: ! 768: /* Floating point comparisons produce an integer result. */ ! 769: #define NEON_VOP_FCMP(name, cmp) \ ! 770: NEON_OP(name) \ ! 771: { \ ! 772: if (float32_compare_quiet(vfp_itos(T0), vfp_itos(T1), NFS) cmp 0) \ ! 773: T0 = -1; \ ! 774: else \ ! 775: T0 = 0; \ ! 776: FORCE_RET(); \ ! 777: } ! 778: ! 779: NEON_VOP_FCMP(ceq_f32, ==) ! 780: NEON_VOP_FCMP(cge_f32, >=) ! 781: NEON_VOP_FCMP(cgt_f32, >) ! 782: ! 783: NEON_OP(acge_f32) ! 784: { ! 785: float32 f0 = float32_abs(vfp_itos(T0)); ! 786: float32 f1 = float32_abs(vfp_itos(T1)); ! 787: T0 = (float32_compare_quiet(f0, f1,NFS) >= 0) ? -1 : 0; ! 788: FORCE_RET(); ! 789: } ! 790: ! 791: NEON_OP(acgt_f32) ! 792: { ! 793: float32 f0 = float32_abs(vfp_itos(T0)); ! 794: float32 f1 = float32_abs(vfp_itos(T1)); ! 795: T0 = (float32_compare_quiet(f0, f1, NFS) > 0) ? -1 : 0; ! 796: FORCE_RET(); ! 797: } ! 798: ! 799: /* Narrowing instructions. The named type is the destination type. */ ! 800: NEON_OP(narrow_u8) ! 801: { ! 802: T0 = (T0 & 0xff) | ((T0 >> 8) & 0xff00) ! 803: | ((T1 << 16) & 0xff0000) | (T1 << 24); ! 804: FORCE_RET(); ! 805: } ! 806: ! 807: NEON_OP(narrow_sat_u8) ! 808: { ! 809: neon_u16 src; ! 810: neon_u8 dest; ! 811: #define SAT8(d, s) \ ! 812: if (s > 0xff) { \ ! 813: d = 0xff; \ ! 814: env->QF = 1; \ ! 815: } else { \ ! 816: d = s; \ ! 817: } ! 818: ! 819: NEON_UNPACK(neon_u16, src, T0); ! 820: SAT8(dest.v1, src.v1); ! 821: SAT8(dest.v2, src.v2); ! 822: NEON_UNPACK(neon_u16, src, T1); ! 823: SAT8(dest.v3, src.v1); ! 824: SAT8(dest.v4, src.v2); ! 825: NEON_PACK(neon_u8, T0, dest); ! 826: FORCE_RET(); ! 827: #undef SAT8 ! 828: } ! 829: ! 830: NEON_OP(narrow_sat_s8) ! 831: { ! 832: neon_s16 src; ! 833: neon_s8 dest; ! 834: #define SAT8(d, s) \ ! 835: if (s != (uint8_t)s) { \ ! 836: d = (s >> 15) ^ 0x7f; \ ! 837: env->QF = 1; \ ! 838: } else { \ ! 839: d = s; \ ! 840: } ! 841: ! 842: NEON_UNPACK(neon_s16, src, T0); ! 843: SAT8(dest.v1, src.v1); ! 844: SAT8(dest.v2, src.v2); ! 845: NEON_UNPACK(neon_s16, src, T1); ! 846: SAT8(dest.v3, src.v1); ! 847: SAT8(dest.v4, src.v2); ! 848: NEON_PACK(neon_s8, T0, dest); ! 849: FORCE_RET(); ! 850: #undef SAT8 ! 851: } ! 852: ! 853: NEON_OP(narrow_u16) ! 854: { ! 855: T0 = (T0 & 0xffff) | (T1 << 16); ! 856: } ! 857: ! 858: NEON_OP(narrow_sat_u16) ! 859: { ! 860: if (T0 > 0xffff) { ! 861: T0 = 0xffff; ! 862: env->QF = 1; ! 863: } ! 864: if (T1 > 0xffff) { ! 865: T1 = 0xffff; ! 866: env->QF = 1; ! 867: } ! 868: T0 |= T1 << 16; ! 869: FORCE_RET(); ! 870: } ! 871: ! 872: NEON_OP(narrow_sat_s16) ! 873: { ! 874: if ((int32_t)T0 != (int16_t)T0) { ! 875: T0 = ((int32_t)T0 >> 31) ^ 0x7fff; ! 876: env->QF = 1; ! 877: } ! 878: if ((int32_t)T1 != (int16_t) T1) { ! 879: T1 = ((int32_t)T1 >> 31) ^ 0x7fff; ! 880: env->QF = 1; ! 881: } ! 882: T0 = (uint16_t)T0 | (T1 << 16); ! 883: FORCE_RET(); ! 884: } ! 885: ! 886: NEON_OP(narrow_sat_u32) ! 887: { ! 888: if (T1) { ! 889: T0 = 0xffffffffu; ! 890: env->QF = 1; ! 891: } ! 892: FORCE_RET(); ! 893: } ! 894: ! 895: NEON_OP(narrow_sat_s32) ! 896: { ! 897: int32_t sign = (int32_t)T1 >> 31; ! 898: ! 899: if ((int32_t)T1 != sign) { ! 900: T0 = sign ^ 0x7fffffff; ! 901: env->QF = 1; ! 902: } ! 903: FORCE_RET(); ! 904: } ! 905: ! 906: /* Narrowing instructions. Named type is the narrow type. */ ! 907: NEON_OP(narrow_high_u8) ! 908: { ! 909: T0 = ((T0 >> 8) & 0xff) | ((T0 >> 16) & 0xff00) ! 910: | ((T1 << 8) & 0xff0000) | (T1 & 0xff000000); ! 911: FORCE_RET(); ! 912: } ! 913: ! 914: NEON_OP(narrow_high_u16) ! 915: { ! 916: T0 = (T0 >> 16) | (T1 & 0xffff0000); ! 917: FORCE_RET(); ! 918: } ! 919: ! 920: NEON_OP(narrow_high_round_u8) ! 921: { ! 922: T0 = (((T0 + 0x80) >> 8) & 0xff) | (((T0 + 0x800000) >> 16) & 0xff00) ! 923: | (((T1 + 0x80) << 8) & 0xff0000) | ((T1 + 0x800000) & 0xff000000); ! 924: FORCE_RET(); ! 925: } ! 926: ! 927: NEON_OP(narrow_high_round_u16) ! 928: { ! 929: T0 = ((T0 + 0x8000) >> 16) | ((T1 + 0x8000) & 0xffff0000); ! 930: FORCE_RET(); ! 931: } ! 932: ! 933: NEON_OP(narrow_high_round_u32) ! 934: { ! 935: if (T0 >= 0x80000000u) ! 936: T0 = T1 + 1; ! 937: else ! 938: T0 = T1; ! 939: FORCE_RET(); ! 940: } ! 941: ! 942: /* Widening instructions. Named type is source type. */ ! 943: NEON_OP(widen_s8) ! 944: { ! 945: uint32_t src; ! 946: ! 947: src = T0; ! 948: T0 = (uint16_t)(int8_t)src | ((int8_t)(src >> 8) << 16); ! 949: T1 = (uint16_t)(int8_t)(src >> 16) | ((int8_t)(src >> 24) << 16); ! 950: } ! 951: ! 952: NEON_OP(widen_u8) ! 953: { ! 954: T1 = ((T0 >> 8) & 0xff0000) | ((T0 >> 16) & 0xff); ! 955: T0 = ((T0 << 8) & 0xff0000) | (T0 & 0xff); ! 956: } ! 957: ! 958: NEON_OP(widen_s16) ! 959: { ! 960: int32_t src; ! 961: ! 962: src = T0; ! 963: T0 = (int16_t)src; ! 964: T1 = src >> 16; ! 965: } ! 966: ! 967: NEON_OP(widen_u16) ! 968: { ! 969: T1 = T0 >> 16; ! 970: T0 &= 0xffff; ! 971: } ! 972: ! 973: NEON_OP(widen_s32) ! 974: { ! 975: T1 = (int32_t)T0 >> 31; ! 976: FORCE_RET(); ! 977: } ! 978: ! 979: NEON_OP(widen_high_u8) ! 980: { ! 981: T1 = (T0 & 0xff000000) | ((T0 >> 8) & 0xff00); ! 982: T0 = ((T0 << 16) & 0xff000000) | ((T0 << 8) & 0xff00); ! 983: } ! 984: ! 985: NEON_OP(widen_high_u16) ! 986: { ! 987: T1 = T0 & 0xffff0000; ! 988: T0 <<= 16; ! 989: } ! 990: ! 991: /* Long operations. The type is the wide type. */ ! 992: NEON_OP(shll_u16) ! 993: { ! 994: int shift = PARAM1; ! 995: uint32_t mask; ! 996: ! 997: mask = 0xffff >> (16 - shift); ! 998: mask |= mask << 16; ! 999: mask = ~mask; ! 1000: ! 1001: T0 = (T0 << shift) & mask; ! 1002: T1 = (T1 << shift) & mask; ! 1003: FORCE_RET(); ! 1004: } ! 1005: ! 1006: NEON_OP(shll_u64) ! 1007: { ! 1008: int shift = PARAM1; ! 1009: ! 1010: T1 <<= shift; ! 1011: T1 |= T0 >> (32 - shift); ! 1012: T0 <<= shift; ! 1013: FORCE_RET(); ! 1014: } ! 1015: ! 1016: NEON_OP(addl_u16) ! 1017: { ! 1018: uint32_t tmp; ! 1019: uint32_t high; ! 1020: ! 1021: tmp = env->vfp.scratch[0]; ! 1022: high = (T0 >> 16) + (tmp >> 16); ! 1023: T0 = (uint16_t)(T0 + tmp); ! 1024: T0 |= (high << 16); ! 1025: tmp = env->vfp.scratch[1]; ! 1026: high = (T1 >> 16) + (tmp >> 16); ! 1027: T1 = (uint16_t)(T1 + tmp); ! 1028: T1 |= (high << 16); ! 1029: FORCE_RET(); ! 1030: } ! 1031: ! 1032: NEON_OP(addl_u32) ! 1033: { ! 1034: T0 += env->vfp.scratch[0]; ! 1035: T1 += env->vfp.scratch[1]; ! 1036: FORCE_RET(); ! 1037: } ! 1038: ! 1039: NEON_OP(addl_u64) ! 1040: { ! 1041: uint64_t tmp; ! 1042: tmp = T0 | ((uint64_t)T1 << 32); ! 1043: tmp += env->vfp.scratch[0]; ! 1044: tmp += (uint64_t)env->vfp.scratch[1] << 32; ! 1045: T0 = tmp; ! 1046: T1 = tmp >> 32; ! 1047: FORCE_RET(); ! 1048: } ! 1049: ! 1050: NEON_OP(subl_u16) ! 1051: { ! 1052: uint32_t tmp; ! 1053: uint32_t high; ! 1054: ! 1055: tmp = env->vfp.scratch[0]; ! 1056: high = (T0 >> 16) - (tmp >> 16); ! 1057: T0 = (uint16_t)(T0 - tmp); ! 1058: T0 |= (high << 16); ! 1059: tmp = env->vfp.scratch[1]; ! 1060: high = (T1 >> 16) - (tmp >> 16); ! 1061: T1 = (uint16_t)(T1 - tmp); ! 1062: T1 |= (high << 16); ! 1063: FORCE_RET(); ! 1064: } ! 1065: ! 1066: NEON_OP(subl_u32) ! 1067: { ! 1068: T0 -= env->vfp.scratch[0]; ! 1069: T1 -= env->vfp.scratch[1]; ! 1070: FORCE_RET(); ! 1071: } ! 1072: ! 1073: NEON_OP(subl_u64) ! 1074: { ! 1075: uint64_t tmp; ! 1076: tmp = T0 | ((uint64_t)T1 << 32); ! 1077: tmp -= env->vfp.scratch[0]; ! 1078: tmp -= (uint64_t)env->vfp.scratch[1] << 32; ! 1079: T0 = tmp; ! 1080: T1 = tmp >> 32; ! 1081: FORCE_RET(); ! 1082: } ! 1083: ! 1084: #define DO_ABD(dest, x, y, type) do { \ ! 1085: type tmp_x = x; \ ! 1086: type tmp_y = y; \ ! 1087: dest = ((tmp_x > tmp_y) ? tmp_x - tmp_y : tmp_y - tmp_x); \ ! 1088: } while(0) ! 1089: ! 1090: NEON_OP(abdl_u16) ! 1091: { ! 1092: uint32_t tmp; ! 1093: uint32_t low; ! 1094: uint32_t high; ! 1095: ! 1096: DO_ABD(low, T0, T1, uint8_t); ! 1097: DO_ABD(tmp, T0 >> 8, T1 >> 8, uint8_t); ! 1098: low |= tmp << 16; ! 1099: DO_ABD(high, T0 >> 16, T1 >> 16, uint8_t); ! 1100: DO_ABD(tmp, T0 >> 24, T1 >> 24, uint8_t); ! 1101: high |= tmp << 16; ! 1102: T0 = low; ! 1103: T1 = high; ! 1104: FORCE_RET(); ! 1105: } ! 1106: ! 1107: NEON_OP(abdl_s16) ! 1108: { ! 1109: uint32_t tmp; ! 1110: uint32_t low; ! 1111: uint32_t high; ! 1112: ! 1113: DO_ABD(low, T0, T1, int8_t); ! 1114: DO_ABD(tmp, T0 >> 8, T1 >> 8, int8_t); ! 1115: low |= tmp << 16; ! 1116: DO_ABD(high, T0 >> 16, T1 >> 16, int8_t); ! 1117: DO_ABD(tmp, T0 >> 24, T1 >> 24, int8_t); ! 1118: high |= tmp << 16; ! 1119: T0 = low; ! 1120: T1 = high; ! 1121: FORCE_RET(); ! 1122: } ! 1123: ! 1124: NEON_OP(abdl_u32) ! 1125: { ! 1126: uint32_t low; ! 1127: uint32_t high; ! 1128: ! 1129: DO_ABD(low, T0, T1, uint16_t); ! 1130: DO_ABD(high, T0 >> 16, T1 >> 16, uint16_t); ! 1131: T0 = low; ! 1132: T1 = high; ! 1133: FORCE_RET(); ! 1134: } ! 1135: ! 1136: NEON_OP(abdl_s32) ! 1137: { ! 1138: uint32_t low; ! 1139: uint32_t high; ! 1140: ! 1141: DO_ABD(low, T0, T1, int16_t); ! 1142: DO_ABD(high, T0 >> 16, T1 >> 16, int16_t); ! 1143: T0 = low; ! 1144: T1 = high; ! 1145: FORCE_RET(); ! 1146: } ! 1147: ! 1148: NEON_OP(abdl_u64) ! 1149: { ! 1150: DO_ABD(T0, T0, T1, uint32_t); ! 1151: T1 = 0; ! 1152: } ! 1153: ! 1154: NEON_OP(abdl_s64) ! 1155: { ! 1156: DO_ABD(T0, T0, T1, int32_t); ! 1157: T1 = 0; ! 1158: } ! 1159: #undef DO_ABD ! 1160: ! 1161: /* Widening multiple. Named type is the source type. */ ! 1162: #define DO_MULL(dest, x, y, type1, type2) do { \ ! 1163: type1 tmp_x = x; \ ! 1164: type1 tmp_y = y; \ ! 1165: dest = (type2)((type2)tmp_x * (type2)tmp_y); \ ! 1166: } while(0) ! 1167: ! 1168: NEON_OP(mull_u8) ! 1169: { ! 1170: uint32_t tmp; ! 1171: uint32_t low; ! 1172: uint32_t high; ! 1173: ! 1174: DO_MULL(low, T0, T1, uint8_t, uint16_t); ! 1175: DO_MULL(tmp, T0 >> 8, T1 >> 8, uint8_t, uint16_t); ! 1176: low |= tmp << 16; ! 1177: DO_MULL(high, T0 >> 16, T1 >> 16, uint8_t, uint16_t); ! 1178: DO_MULL(tmp, T0 >> 24, T1 >> 24, uint8_t, uint16_t); ! 1179: high |= tmp << 16; ! 1180: T0 = low; ! 1181: T1 = high; ! 1182: FORCE_RET(); ! 1183: } ! 1184: ! 1185: NEON_OP(mull_s8) ! 1186: { ! 1187: uint32_t tmp; ! 1188: uint32_t low; ! 1189: uint32_t high; ! 1190: ! 1191: DO_MULL(low, T0, T1, int8_t, uint16_t); ! 1192: DO_MULL(tmp, T0 >> 8, T1 >> 8, int8_t, uint16_t); ! 1193: low |= tmp << 16; ! 1194: DO_MULL(high, T0 >> 16, T1 >> 16, int8_t, uint16_t); ! 1195: DO_MULL(tmp, T0 >> 24, T1 >> 24, int8_t, uint16_t); ! 1196: high |= tmp << 16; ! 1197: T0 = low; ! 1198: T1 = high; ! 1199: FORCE_RET(); ! 1200: } ! 1201: ! 1202: NEON_OP(mull_u16) ! 1203: { ! 1204: uint32_t low; ! 1205: uint32_t high; ! 1206: ! 1207: DO_MULL(low, T0, T1, uint16_t, uint32_t); ! 1208: DO_MULL(high, T0 >> 16, T1 >> 16, uint16_t, uint32_t); ! 1209: T0 = low; ! 1210: T1 = high; ! 1211: FORCE_RET(); ! 1212: } ! 1213: ! 1214: NEON_OP(mull_s16) ! 1215: { ! 1216: uint32_t low; ! 1217: uint32_t high; ! 1218: ! 1219: DO_MULL(low, T0, T1, int16_t, uint32_t); ! 1220: DO_MULL(high, T0 >> 16, T1 >> 16, int16_t, uint32_t); ! 1221: T0 = low; ! 1222: T1 = high; ! 1223: FORCE_RET(); ! 1224: } ! 1225: ! 1226: NEON_OP(addl_saturate_s32) ! 1227: { ! 1228: uint32_t tmp; ! 1229: uint32_t res; ! 1230: ! 1231: tmp = env->vfp.scratch[0]; ! 1232: res = T0 + tmp; ! 1233: if (((res ^ T0) & SIGNBIT) && !((T0 ^ tmp) & SIGNBIT)) { ! 1234: env->QF = 1; ! 1235: T0 = (T0 >> 31) ^ 0x7fffffff; ! 1236: } else { ! 1237: T0 = res; ! 1238: } ! 1239: tmp = env->vfp.scratch[1]; ! 1240: res = T1 + tmp; ! 1241: if (((res ^ T1) & SIGNBIT) && !((T1 ^ tmp) & SIGNBIT)) { ! 1242: env->QF = 1; ! 1243: T1 = (T1 >> 31) ^ 0x7fffffff; ! 1244: } else { ! 1245: T1 = res; ! 1246: } ! 1247: FORCE_RET(); ! 1248: } ! 1249: ! 1250: NEON_OP(addl_saturate_s64) ! 1251: { ! 1252: uint64_t src1; ! 1253: uint64_t src2; ! 1254: uint64_t res; ! 1255: ! 1256: src1 = T0 + ((uint64_t)T1 << 32); ! 1257: src2 = env->vfp.scratch[0] + ((uint64_t)env->vfp.scratch[1] << 32); ! 1258: res = src1 + src2; ! 1259: if (((res ^ src1) & SIGNBIT64) && !((src1 ^ src2) & SIGNBIT64)) { ! 1260: env->QF = 1; ! 1261: T0 = ~(int64_t)src1 >> 63; ! 1262: T1 = T0 ^ 0x80000000; ! 1263: } else { ! 1264: T0 = res; ! 1265: T1 = res >> 32; ! 1266: } ! 1267: FORCE_RET(); ! 1268: } ! 1269: ! 1270: NEON_OP(addl_saturate_u64) ! 1271: { ! 1272: uint64_t src1; ! 1273: uint64_t src2; ! 1274: uint64_t res; ! 1275: ! 1276: src1 = T0 + ((uint64_t)T1 << 32); ! 1277: src2 = env->vfp.scratch[0] + ((uint64_t)env->vfp.scratch[1] << 32); ! 1278: res = src1 + src2; ! 1279: if (res < src1) { ! 1280: env->QF = 1; ! 1281: T0 = 0xffffffff; ! 1282: T1 = 0xffffffff; ! 1283: } else { ! 1284: T0 = res; ! 1285: T1 = res >> 32; ! 1286: } ! 1287: FORCE_RET(); ! 1288: } ! 1289: ! 1290: NEON_OP(subl_saturate_s64) ! 1291: { ! 1292: uint64_t src1; ! 1293: uint64_t src2; ! 1294: uint64_t res; ! 1295: ! 1296: src1 = T0 + ((uint64_t)T1 << 32); ! 1297: src2 = env->vfp.scratch[0] + ((uint64_t)env->vfp.scratch[1] << 32); ! 1298: res = src1 - src2; ! 1299: if (((res ^ src1) & SIGNBIT64) && ((src1 ^ src2) & SIGNBIT64)) { ! 1300: env->QF = 1; ! 1301: T0 = ~(int64_t)src1 >> 63; ! 1302: T1 = T0 ^ 0x80000000; ! 1303: } else { ! 1304: T0 = res; ! 1305: T1 = res >> 32; ! 1306: } ! 1307: FORCE_RET(); ! 1308: } ! 1309: ! 1310: NEON_OP(subl_saturate_u64) ! 1311: { ! 1312: uint64_t src1; ! 1313: uint64_t src2; ! 1314: uint64_t res; ! 1315: ! 1316: src1 = T0 + ((uint64_t)T1 << 32); ! 1317: src2 = env->vfp.scratch[0] + ((uint64_t)env->vfp.scratch[1] << 32); ! 1318: if (src1 < src2) { ! 1319: env->QF = 1; ! 1320: T0 = 0; ! 1321: T1 = 0; ! 1322: } else { ! 1323: res = src1 - src2; ! 1324: T0 = res; ! 1325: T1 = res >> 32; ! 1326: } ! 1327: FORCE_RET(); ! 1328: } ! 1329: ! 1330: NEON_OP(negl_u16) ! 1331: { ! 1332: uint32_t tmp; ! 1333: tmp = T0 >> 16; ! 1334: tmp = -tmp; ! 1335: T0 = (-T0 & 0xffff) | (tmp << 16); ! 1336: tmp = T1 >> 16; ! 1337: tmp = -tmp; ! 1338: T1 = (-T1 & 0xffff) | (tmp << 16); ! 1339: FORCE_RET(); ! 1340: } ! 1341: ! 1342: NEON_OP(negl_u32) ! 1343: { ! 1344: T0 = -T0; ! 1345: T1 = -T1; ! 1346: FORCE_RET(); ! 1347: } ! 1348: ! 1349: NEON_OP(negl_u64) ! 1350: { ! 1351: uint64_t val; ! 1352: ! 1353: val = T0 | ((uint64_t)T1 << 32); ! 1354: val = -val; ! 1355: T0 = val; ! 1356: T1 = val >> 32; ! 1357: FORCE_RET(); ! 1358: } ! 1359: ! 1360: /* Scalar operations. */ ! 1361: NEON_OP(dup_low16) ! 1362: { ! 1363: T0 = (T0 & 0xffff) | (T0 << 16); ! 1364: FORCE_RET(); ! 1365: } ! 1366: ! 1367: NEON_OP(dup_high16) ! 1368: { ! 1369: T0 = (T0 >> 16) | (T0 & 0xffff0000); ! 1370: FORCE_RET(); ! 1371: } ! 1372: ! 1373: /* Helper for VEXT */ ! 1374: NEON_OP(extract) ! 1375: { ! 1376: int shift = PARAM1; ! 1377: T0 = (T0 >> shift) | (T1 << (32 - shift)); ! 1378: FORCE_RET(); ! 1379: } ! 1380: ! 1381: /* Pairwise add long. Named type is source type. */ ! 1382: NEON_OP(paddl_s8) ! 1383: { ! 1384: int8_t src1; ! 1385: int8_t src2; ! 1386: uint16_t result; ! 1387: src1 = T0 >> 24; ! 1388: src2 = T0 >> 16; ! 1389: result = (uint16_t)src1 + src2; ! 1390: src1 = T0 >> 8; ! 1391: src2 = T0; ! 1392: T0 = (uint16_t)((uint16_t)src1 + src2) | ((uint32_t)result << 16); ! 1393: FORCE_RET(); ! 1394: } ! 1395: ! 1396: NEON_OP(paddl_u8) ! 1397: { ! 1398: uint8_t src1; ! 1399: uint8_t src2; ! 1400: uint16_t result; ! 1401: src1 = T0 >> 24; ! 1402: src2 = T0 >> 16; ! 1403: result = (uint16_t)src1 + src2; ! 1404: src1 = T0 >> 8; ! 1405: src2 = T0; ! 1406: T0 = (uint16_t)((uint16_t)src1 + src2) | ((uint32_t)result << 16); ! 1407: FORCE_RET(); ! 1408: } ! 1409: ! 1410: NEON_OP(paddl_s16) ! 1411: { ! 1412: T0 = (uint32_t)(int16_t)T0 + (uint32_t)(int16_t)(T0 >> 16); ! 1413: FORCE_RET(); ! 1414: } ! 1415: ! 1416: NEON_OP(paddl_u16) ! 1417: { ! 1418: T0 = (uint32_t)(uint16_t)T0 + (uint32_t)(uint16_t)(T0 >> 16); ! 1419: FORCE_RET(); ! 1420: } ! 1421: ! 1422: NEON_OP(paddl_s32) ! 1423: { ! 1424: int64_t tmp; ! 1425: tmp = (int64_t)(int32_t)T0 + (int64_t)(int32_t)T1; ! 1426: T0 = tmp; ! 1427: T1 = tmp >> 32; ! 1428: FORCE_RET(); ! 1429: } ! 1430: ! 1431: NEON_OP(paddl_u32) ! 1432: { ! 1433: uint64_t tmp; ! 1434: tmp = (uint64_t)T0 + (uint64_t)T1; ! 1435: T0 = tmp; ! 1436: T1 = tmp >> 32; ! 1437: FORCE_RET(); ! 1438: } ! 1439: ! 1440: /* Count Leading Sign/Zero Bits. */ ! 1441: static inline int do_clz8(uint8_t x) ! 1442: { ! 1443: int n; ! 1444: for (n = 8; x; n--) ! 1445: x >>= 1; ! 1446: return n; ! 1447: } ! 1448: ! 1449: static inline int do_clz16(uint16_t x) ! 1450: { ! 1451: int n; ! 1452: for (n = 16; x; n--) ! 1453: x >>= 1; ! 1454: return n; ! 1455: } ! 1456: ! 1457: NEON_OP(clz_u8) ! 1458: { ! 1459: uint32_t result; ! 1460: uint32_t tmp; ! 1461: ! 1462: tmp = T0; ! 1463: result = do_clz8(tmp); ! 1464: result |= do_clz8(tmp >> 8) << 8; ! 1465: result |= do_clz8(tmp >> 16) << 16; ! 1466: result |= do_clz8(tmp >> 24) << 24; ! 1467: T0 = result; ! 1468: FORCE_RET(); ! 1469: } ! 1470: ! 1471: NEON_OP(clz_u16) ! 1472: { ! 1473: uint32_t result; ! 1474: uint32_t tmp; ! 1475: tmp = T0; ! 1476: result = do_clz16(tmp); ! 1477: result |= do_clz16(tmp >> 16) << 16; ! 1478: T0 = result; ! 1479: FORCE_RET(); ! 1480: } ! 1481: ! 1482: NEON_OP(cls_s8) ! 1483: { ! 1484: uint32_t result; ! 1485: int8_t tmp; ! 1486: tmp = T0; ! 1487: result = do_clz8((tmp < 0) ? ~tmp : tmp) - 1; ! 1488: tmp = T0 >> 8; ! 1489: result |= (do_clz8((tmp < 0) ? ~tmp : tmp) - 1) << 8; ! 1490: tmp = T0 >> 16; ! 1491: result |= (do_clz8((tmp < 0) ? ~tmp : tmp) - 1) << 16; ! 1492: tmp = T0 >> 24; ! 1493: result |= (do_clz8((tmp < 0) ? ~tmp : tmp) - 1) << 24; ! 1494: T0 = result; ! 1495: FORCE_RET(); ! 1496: } ! 1497: ! 1498: NEON_OP(cls_s16) ! 1499: { ! 1500: uint32_t result; ! 1501: int16_t tmp; ! 1502: tmp = T0; ! 1503: result = do_clz16((tmp < 0) ? ~tmp : tmp) - 1; ! 1504: tmp = T0 >> 16; ! 1505: result |= (do_clz16((tmp < 0) ? ~tmp : tmp) - 1) << 16; ! 1506: T0 = result; ! 1507: FORCE_RET(); ! 1508: } ! 1509: ! 1510: NEON_OP(cls_s32) ! 1511: { ! 1512: int count; ! 1513: if ((int32_t)T0 < 0) ! 1514: T0 = ~T0; ! 1515: for (count = 32; T0 > 0; count--) ! 1516: T0 = T0 >> 1; ! 1517: T0 = count - 1; ! 1518: FORCE_RET(); ! 1519: } ! 1520: ! 1521: /* Bit count. */ ! 1522: NEON_OP(cnt_u8) ! 1523: { ! 1524: T0 = (T0 & 0x55555555) + ((T0 >> 1) & 0x55555555); ! 1525: T0 = (T0 & 0x33333333) + ((T0 >> 2) & 0x33333333); ! 1526: T0 = (T0 & 0x0f0f0f0f) + ((T0 >> 4) & 0x0f0f0f0f); ! 1527: FORCE_RET(); ! 1528: } ! 1529: ! 1530: /* Saturnating negation. */ ! 1531: /* ??? Make these use NEON_VOP1 */ ! 1532: #define DO_QABS8(x) do { \ ! 1533: if (x == (int8_t)0x80) { \ ! 1534: x = 0x7f; \ ! 1535: env->QF = 1; \ ! 1536: } else if (x < 0) { \ ! 1537: x = -x; \ ! 1538: }} while (0) ! 1539: NEON_OP(qabs_s8) ! 1540: { ! 1541: neon_s8 vec; ! 1542: NEON_UNPACK(neon_s8, vec, T0); ! 1543: DO_QABS8(vec.v1); ! 1544: DO_QABS8(vec.v2); ! 1545: DO_QABS8(vec.v3); ! 1546: DO_QABS8(vec.v4); ! 1547: NEON_PACK(neon_s8, T0, vec); ! 1548: FORCE_RET(); ! 1549: } ! 1550: #undef DO_QABS8 ! 1551: ! 1552: #define DO_QNEG8(x) do { \ ! 1553: if (x == (int8_t)0x80) { \ ! 1554: x = 0x7f; \ ! 1555: env->QF = 1; \ ! 1556: } else { \ ! 1557: x = -x; \ ! 1558: }} while (0) ! 1559: NEON_OP(qneg_s8) ! 1560: { ! 1561: neon_s8 vec; ! 1562: NEON_UNPACK(neon_s8, vec, T0); ! 1563: DO_QNEG8(vec.v1); ! 1564: DO_QNEG8(vec.v2); ! 1565: DO_QNEG8(vec.v3); ! 1566: DO_QNEG8(vec.v4); ! 1567: NEON_PACK(neon_s8, T0, vec); ! 1568: FORCE_RET(); ! 1569: } ! 1570: #undef DO_QNEG8 ! 1571: ! 1572: #define DO_QABS16(x) do { \ ! 1573: if (x == (int16_t)0x8000) { \ ! 1574: x = 0x7fff; \ ! 1575: env->QF = 1; \ ! 1576: } else if (x < 0) { \ ! 1577: x = -x; \ ! 1578: }} while (0) ! 1579: NEON_OP(qabs_s16) ! 1580: { ! 1581: neon_s16 vec; ! 1582: NEON_UNPACK(neon_s16, vec, T0); ! 1583: DO_QABS16(vec.v1); ! 1584: DO_QABS16(vec.v2); ! 1585: NEON_PACK(neon_s16, T0, vec); ! 1586: FORCE_RET(); ! 1587: } ! 1588: #undef DO_QABS16 ! 1589: ! 1590: #define DO_QNEG16(x) do { \ ! 1591: if (x == (int16_t)0x8000) { \ ! 1592: x = 0x7fff; \ ! 1593: env->QF = 1; \ ! 1594: } else { \ ! 1595: x = -x; \ ! 1596: }} while (0) ! 1597: NEON_OP(qneg_s16) ! 1598: { ! 1599: neon_s16 vec; ! 1600: NEON_UNPACK(neon_s16, vec, T0); ! 1601: DO_QNEG16(vec.v1); ! 1602: DO_QNEG16(vec.v2); ! 1603: NEON_PACK(neon_s16, T0, vec); ! 1604: FORCE_RET(); ! 1605: } ! 1606: #undef DO_QNEG16 ! 1607: ! 1608: NEON_OP(qabs_s32) ! 1609: { ! 1610: if (T0 == 0x80000000) { ! 1611: T0 = 0x7fffffff; ! 1612: env->QF = 1; ! 1613: } else if ((int32_t)T0 < 0) { ! 1614: T0 = -T0; ! 1615: } ! 1616: FORCE_RET(); ! 1617: } ! 1618: ! 1619: NEON_OP(qneg_s32) ! 1620: { ! 1621: if (T0 == 0x80000000) { ! 1622: T0 = 0x7fffffff; ! 1623: env->QF = 1; ! 1624: } else { ! 1625: T0 = -T0; ! 1626: } ! 1627: FORCE_RET(); ! 1628: } ! 1629: ! 1630: /* Unary opperations */ ! 1631: #define NEON_FN(dest, src, dummy) dest = (src < 0) ? -src : src ! 1632: NEON_VOP1(abs_s8, neon_s8, 4) ! 1633: NEON_VOP1(abs_s16, neon_s16, 2) ! 1634: NEON_OP(abs_s32) ! 1635: { ! 1636: if ((int32_t)T0 < 0) ! 1637: T0 = -T0; ! 1638: FORCE_RET(); ! 1639: } ! 1640: #undef NEON_FN ! 1641: ! 1642: /* Transpose. Argument order is rather strange to avoid special casing ! 1643: the tranlation code. ! 1644: On input T0 = rm, T1 = rd. On output T0 = rd, T1 = rm */ ! 1645: NEON_OP(trn_u8) ! 1646: { ! 1647: uint32_t rd; ! 1648: uint32_t rm; ! 1649: rd = ((T0 & 0x00ff00ff) << 8) | (T1 & 0x00ff00ff); ! 1650: rm = ((T1 & 0xff00ff00) >> 8) | (T0 & 0xff00ff00); ! 1651: T0 = rd; ! 1652: T1 = rm; ! 1653: FORCE_RET(); ! 1654: } ! 1655: ! 1656: NEON_OP(trn_u16) ! 1657: { ! 1658: uint32_t rd; ! 1659: uint32_t rm; ! 1660: rd = (T0 << 16) | (T1 & 0xffff); ! 1661: rm = (T1 >> 16) | (T0 & 0xffff0000); ! 1662: T0 = rd; ! 1663: T1 = rm; ! 1664: FORCE_RET(); ! 1665: } ! 1666: ! 1667: /* Worker routines for zip and unzip. */ ! 1668: NEON_OP(unzip_u8) ! 1669: { ! 1670: uint32_t rd; ! 1671: uint32_t rm; ! 1672: rd = (T0 & 0xff) | ((T0 >> 8) & 0xff00) ! 1673: | ((T1 << 16) & 0xff0000) | ((T1 << 8) & 0xff000000); ! 1674: rm = ((T0 >> 8) & 0xff) | ((T0 >> 16) & 0xff00) ! 1675: | ((T1 << 8) & 0xff0000) | (T1 & 0xff000000); ! 1676: T0 = rd; ! 1677: T1 = rm; ! 1678: FORCE_RET(); ! 1679: } ! 1680: ! 1681: NEON_OP(zip_u8) ! 1682: { ! 1683: uint32_t rd; ! 1684: uint32_t rm; ! 1685: rd = (T0 & 0xff) | ((T1 << 8) & 0xff00) ! 1686: | ((T0 << 16) & 0xff0000) | ((T1 << 24) & 0xff000000); ! 1687: rm = ((T0 >> 16) & 0xff) | ((T1 >> 8) & 0xff00) ! 1688: | ((T0 >> 8) & 0xff0000) | (T1 & 0xff000000); ! 1689: T0 = rd; ! 1690: T1 = rm; ! 1691: FORCE_RET(); ! 1692: } ! 1693: ! 1694: NEON_OP(zip_u16) ! 1695: { ! 1696: uint32_t tmp; ! 1697: ! 1698: tmp = (T0 & 0xffff) | (T1 << 16); ! 1699: T1 = (T1 & 0xffff0000) | (T0 >> 16); ! 1700: T0 = tmp; ! 1701: FORCE_RET(); ! 1702: } ! 1703: ! 1704: /* Reciprocal/root estimate. */ ! 1705: NEON_OP(recpe_u32) ! 1706: { ! 1707: T0 = helper_recpe_u32(T0); ! 1708: } ! 1709: ! 1710: NEON_OP(rsqrte_u32) ! 1711: { ! 1712: T0 = helper_rsqrte_u32(T0); ! 1713: } ! 1714: ! 1715: NEON_OP(recpe_f32) ! 1716: { ! 1717: FT0s = helper_recpe_f32(FT0s); ! 1718: } ! 1719: ! 1720: NEON_OP(rsqrte_f32) ! 1721: { ! 1722: FT0s = helper_rsqrte_f32(FT0s); ! 1723: } ! 1724: ! 1725: /* Table lookup. This accessed the register file directly. */ ! 1726: NEON_OP(tbl) ! 1727: { ! 1728: helper_neon_tbl(PARAM1, PARAM2); ! 1729: } ! 1730: ! 1731: NEON_OP(dup_u8) ! 1732: { ! 1733: T0 = (T0 >> PARAM1) & 0xff; ! 1734: T0 |= T0 << 8; ! 1735: T0 |= T0 << 16; ! 1736: FORCE_RET(); ! 1737: } ! 1738: ! 1739: /* Helpers for element load/store. */ ! 1740: NEON_OP(insert_elt) ! 1741: { ! 1742: int shift = PARAM1; ! 1743: uint32_t mask = PARAM2; ! 1744: T2 = (T2 & mask) | (T0 << shift); ! 1745: FORCE_RET(); ! 1746: } ! 1747: ! 1748: NEON_OP(extract_elt) ! 1749: { ! 1750: int shift = PARAM1; ! 1751: uint32_t mask = PARAM2; ! 1752: T0 = (T2 & mask) >> shift; ! 1753: FORCE_RET(); ! 1754: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.