mirror of
https://github.com/xemu-project/xemu.git
synced 2024-11-24 20:19:44 +00:00
9ee6e8bb85
git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@3572 c046a42c-6fe2-441c-8c8c-71466251a162
1755 lines
36 KiB
C
1755 lines
36 KiB
C
/*
|
|
* ARM NEON vector operations.
|
|
*
|
|
* Copyright (c) 2007 CodeSourcery.
|
|
* Written by Paul Brook
|
|
*
|
|
* This code is licenced under the GPL.
|
|
*/
|
|
/* Note that for NEON an "l" prefix means it is a wide operation, unlike
|
|
scalar arm ops where it means a word size operation. */
|
|
|
|
/* ??? NEON ops should probably have their own float status. */
|
|
#define NFS &env->vfp.fp_status
|
|
#define NEON_OP(name) void OPPROTO op_neon_##name (void)
|
|
|
|
NEON_OP(getreg_T0)
|
|
{
|
|
T0 = *(uint32_t *)((char *) env + PARAM1);
|
|
}
|
|
|
|
NEON_OP(getreg_T1)
|
|
{
|
|
T1 = *(uint32_t *)((char *) env + PARAM1);
|
|
}
|
|
|
|
NEON_OP(getreg_T2)
|
|
{
|
|
T2 = *(uint32_t *)((char *) env + PARAM1);
|
|
}
|
|
|
|
NEON_OP(setreg_T0)
|
|
{
|
|
*(uint32_t *)((char *) env + PARAM1) = T0;
|
|
}
|
|
|
|
NEON_OP(setreg_T1)
|
|
{
|
|
*(uint32_t *)((char *) env + PARAM1) = T1;
|
|
}
|
|
|
|
NEON_OP(setreg_T2)
|
|
{
|
|
*(uint32_t *)((char *) env + PARAM1) = T2;
|
|
}
|
|
|
|
#define NEON_TYPE1(name, type) \
|
|
typedef struct \
|
|
{ \
|
|
type v1; \
|
|
} neon_##name;
|
|
#ifdef WORDS_BIGENDIAN
|
|
#define NEON_TYPE2(name, type) \
|
|
typedef struct \
|
|
{ \
|
|
type v2; \
|
|
type v1; \
|
|
} neon_##name;
|
|
#define NEON_TYPE4(name, type) \
|
|
typedef struct \
|
|
{ \
|
|
type v4; \
|
|
type v3; \
|
|
type v2; \
|
|
type v1; \
|
|
} neon_##name;
|
|
#else
|
|
#define NEON_TYPE2(name, type) \
|
|
typedef struct \
|
|
{ \
|
|
type v1; \
|
|
type v2; \
|
|
} neon_##name;
|
|
#define NEON_TYPE4(name, type) \
|
|
typedef struct \
|
|
{ \
|
|
type v1; \
|
|
type v2; \
|
|
type v3; \
|
|
type v4; \
|
|
} neon_##name;
|
|
#endif
|
|
|
|
NEON_TYPE4(s8, int8_t)
|
|
NEON_TYPE4(u8, uint8_t)
|
|
NEON_TYPE2(s16, int16_t)
|
|
NEON_TYPE2(u16, uint16_t)
|
|
NEON_TYPE1(s32, int32_t)
|
|
NEON_TYPE1(u32, uint32_t)
|
|
#undef NEON_TYPE4
|
|
#undef NEON_TYPE2
|
|
#undef NEON_TYPE1
|
|
|
|
/* Copy from a uint32_t to a vector structure type. */
|
|
#define NEON_UNPACK(vtype, dest, val) do { \
|
|
union { \
|
|
vtype v; \
|
|
uint32_t i; \
|
|
} conv_u; \
|
|
conv_u.i = (val); \
|
|
dest = conv_u.v; \
|
|
} while(0)
|
|
|
|
/* Copy from a vector structure type to a uint32_t. */
|
|
#define NEON_PACK(vtype, dest, val) do { \
|
|
union { \
|
|
vtype v; \
|
|
uint32_t i; \
|
|
} conv_u; \
|
|
conv_u.v = (val); \
|
|
dest = conv_u.i; \
|
|
} while(0)
|
|
|
|
#define NEON_DO1 \
|
|
NEON_FN(vdest.v1, vsrc1.v1, vsrc2.v1);
|
|
#define NEON_DO2 \
|
|
NEON_FN(vdest.v1, vsrc1.v1, vsrc2.v1); \
|
|
NEON_FN(vdest.v2, vsrc1.v2, vsrc2.v2);
|
|
#define NEON_DO4 \
|
|
NEON_FN(vdest.v1, vsrc1.v1, vsrc2.v1); \
|
|
NEON_FN(vdest.v2, vsrc1.v2, vsrc2.v2); \
|
|
NEON_FN(vdest.v3, vsrc1.v3, vsrc2.v3); \
|
|
NEON_FN(vdest.v4, vsrc1.v4, vsrc2.v4);
|
|
|
|
#define NEON_VOP(name, vtype, n) \
|
|
NEON_OP(name) \
|
|
{ \
|
|
vtype vsrc1; \
|
|
vtype vsrc2; \
|
|
vtype vdest; \
|
|
NEON_UNPACK(vtype, vsrc1, T0); \
|
|
NEON_UNPACK(vtype, vsrc2, T1); \
|
|
NEON_DO##n; \
|
|
NEON_PACK(vtype, T0, vdest); \
|
|
FORCE_RET(); \
|
|
}
|
|
|
|
#define NEON_VOP1(name, vtype, n) \
|
|
NEON_OP(name) \
|
|
{ \
|
|
vtype vsrc1; \
|
|
vtype vdest; \
|
|
NEON_UNPACK(vtype, vsrc1, T0); \
|
|
NEON_DO##n; \
|
|
NEON_PACK(vtype, T0, vdest); \
|
|
FORCE_RET(); \
|
|
}
|
|
|
|
/* Pairwise operations. */
|
|
/* For 32-bit elements each segment only contains a single element, so
|
|
the elementwise and pairwise operations are the same. */
|
|
#define NEON_PDO2 \
|
|
NEON_FN(vdest.v1, vsrc1.v1, vsrc1.v2); \
|
|
NEON_FN(vdest.v2, vsrc2.v1, vsrc2.v2);
|
|
#define NEON_PDO4 \
|
|
NEON_FN(vdest.v1, vsrc1.v1, vsrc1.v2); \
|
|
NEON_FN(vdest.v2, vsrc1.v3, vsrc1.v4); \
|
|
NEON_FN(vdest.v3, vsrc2.v1, vsrc2.v2); \
|
|
NEON_FN(vdest.v4, vsrc2.v3, vsrc2.v4); \
|
|
|
|
#define NEON_POP(name, vtype, n) \
|
|
NEON_OP(name) \
|
|
{ \
|
|
vtype vsrc1; \
|
|
vtype vsrc2; \
|
|
vtype vdest; \
|
|
NEON_UNPACK(vtype, vsrc1, T0); \
|
|
NEON_UNPACK(vtype, vsrc2, T1); \
|
|
NEON_PDO##n; \
|
|
NEON_PACK(vtype, T0, vdest); \
|
|
FORCE_RET(); \
|
|
}
|
|
|
|
#define NEON_FN(dest, src1, src2) dest = (src1 + src2) >> 1
|
|
NEON_VOP(hadd_s8, neon_s8, 4)
|
|
NEON_VOP(hadd_u8, neon_u8, 4)
|
|
NEON_VOP(hadd_s16, neon_s16, 2)
|
|
NEON_VOP(hadd_u16, neon_u16, 2)
|
|
#undef NEON_FN
|
|
|
|
NEON_OP(hadd_s32)
|
|
{
|
|
int32_t src1 = T0;
|
|
int32_t src2 = T1;
|
|
int32_t dest;
|
|
|
|
dest = (src1 >> 1) + (src2 >> 1);
|
|
if (src1 & src2 & 1)
|
|
dest++;
|
|
T0 = dest;
|
|
FORCE_RET();
|
|
}
|
|
|
|
NEON_OP(hadd_u32)
|
|
{
|
|
uint32_t src1 = T0;
|
|
uint32_t src2 = T1;
|
|
uint32_t dest;
|
|
|
|
dest = (src1 >> 1) + (src2 >> 1);
|
|
if (src1 & src2 & 1)
|
|
dest++;
|
|
T0 = dest;
|
|
FORCE_RET();
|
|
}
|
|
|
|
#define NEON_FN(dest, src1, src2) dest = (src1 + src2 + 1) >> 1
|
|
NEON_VOP(rhadd_s8, neon_s8, 4)
|
|
NEON_VOP(rhadd_u8, neon_u8, 4)
|
|
NEON_VOP(rhadd_s16, neon_s16, 2)
|
|
NEON_VOP(rhadd_u16, neon_u16, 2)
|
|
#undef NEON_FN
|
|
|
|
NEON_OP(rhadd_s32)
|
|
{
|
|
int32_t src1 = T0;
|
|
int32_t src2 = T1;
|
|
int32_t dest;
|
|
|
|
dest = (src1 >> 1) + (src2 >> 1);
|
|
if ((src1 | src2) & 1)
|
|
dest++;
|
|
T0 = dest;
|
|
FORCE_RET();
|
|
}
|
|
|
|
NEON_OP(rhadd_u32)
|
|
{
|
|
uint32_t src1 = T0;
|
|
uint32_t src2 = T1;
|
|
uint32_t dest;
|
|
|
|
dest = (src1 >> 1) + (src2 >> 1);
|
|
if ((src1 | src2) & 1)
|
|
dest++;
|
|
T0 = dest;
|
|
FORCE_RET();
|
|
}
|
|
|
|
#define NEON_FN(dest, src1, src2) dest = (src1 - src2) >> 1
|
|
NEON_VOP(hsub_s8, neon_s8, 4)
|
|
NEON_VOP(hsub_u8, neon_u8, 4)
|
|
NEON_VOP(hsub_s16, neon_s16, 2)
|
|
NEON_VOP(hsub_u16, neon_u16, 2)
|
|
#undef NEON_FN
|
|
|
|
NEON_OP(hsub_s32)
|
|
{
|
|
int32_t src1 = T0;
|
|
int32_t src2 = T1;
|
|
int32_t dest;
|
|
|
|
dest = (src1 >> 1) - (src2 >> 1);
|
|
if ((~src1) & src2 & 1)
|
|
dest--;
|
|
T0 = dest;
|
|
FORCE_RET();
|
|
}
|
|
|
|
NEON_OP(hsub_u32)
|
|
{
|
|
uint32_t src1 = T0;
|
|
uint32_t src2 = T1;
|
|
uint32_t dest;
|
|
|
|
dest = (src1 >> 1) - (src2 >> 1);
|
|
if ((~src1) & src2 & 1)
|
|
dest--;
|
|
T0 = dest;
|
|
FORCE_RET();
|
|
}
|
|
|
|
/* ??? bsl, bif and bit are all the same op, just with the oparands in a
|
|
differnet order. It's currently easier to have 3 differnt ops than
|
|
rearange the operands. */
|
|
|
|
/* Bitwise Select. */
|
|
NEON_OP(bsl)
|
|
{
|
|
T0 = (T0 & T2) | (T1 & ~T2);
|
|
}
|
|
|
|
/* Bitwise Insert If True. */
|
|
NEON_OP(bit)
|
|
{
|
|
T0 = (T0 & T1) | (T2 & ~T1);
|
|
}
|
|
|
|
/* Bitwise Insert If False. */
|
|
NEON_OP(bif)
|
|
{
|
|
T0 = (T2 & T1) | (T0 & ~T1);
|
|
}
|
|
|
|
#define NEON_USAT(dest, src1, src2, type) do { \
|
|
uint32_t tmp = (uint32_t)src1 + (uint32_t)src2; \
|
|
if (tmp != (type)tmp) { \
|
|
env->QF = 1; \
|
|
dest = ~0; \
|
|
} else { \
|
|
dest = tmp; \
|
|
}} while(0)
|
|
#define NEON_FN(dest, src1, src2) NEON_USAT(dest, src1, src2, uint8_t)
|
|
NEON_VOP(qadd_u8, neon_u8, 4)
|
|
#undef NEON_FN
|
|
#define NEON_FN(dest, src1, src2) NEON_USAT(dest, src1, src2, uint16_t)
|
|
NEON_VOP(qadd_u16, neon_u16, 2)
|
|
#undef NEON_FN
|
|
#undef NEON_USAT
|
|
|
|
#define NEON_SSAT(dest, src1, src2, type) do { \
|
|
int32_t tmp = (uint32_t)src1 + (uint32_t)src2; \
|
|
if (tmp != (type)tmp) { \
|
|
env->QF = 1; \
|
|
if (src2 > 0) { \
|
|
tmp = (1 << (sizeof(type) * 8 - 1)) - 1; \
|
|
} else { \
|
|
tmp = 1 << (sizeof(type) * 8 - 1); \
|
|
} \
|
|
} \
|
|
dest = tmp; \
|
|
} while(0)
|
|
#define NEON_FN(dest, src1, src2) NEON_SSAT(dest, src1, src2, int8_t)
|
|
NEON_VOP(qadd_s8, neon_s8, 4)
|
|
#undef NEON_FN
|
|
#define NEON_FN(dest, src1, src2) NEON_SSAT(dest, src1, src2, int16_t)
|
|
NEON_VOP(qadd_s16, neon_s16, 2)
|
|
#undef NEON_FN
|
|
#undef NEON_SSAT
|
|
|
|
#define NEON_USAT(dest, src1, src2, type) do { \
|
|
uint32_t tmp = (uint32_t)src1 - (uint32_t)src2; \
|
|
if (tmp != (type)tmp) { \
|
|
env->QF = 1; \
|
|
dest = 0; \
|
|
} else { \
|
|
dest = tmp; \
|
|
}} while(0)
|
|
#define NEON_FN(dest, src1, src2) NEON_USAT(dest, src1, src2, uint8_t)
|
|
NEON_VOP(qsub_u8, neon_u8, 4)
|
|
#undef NEON_FN
|
|
#define NEON_FN(dest, src1, src2) NEON_USAT(dest, src1, src2, uint16_t)
|
|
NEON_VOP(qsub_u16, neon_u16, 2)
|
|
#undef NEON_FN
|
|
#undef NEON_USAT
|
|
|
|
#define NEON_SSAT(dest, src1, src2, type) do { \
|
|
int32_t tmp = (uint32_t)src1 - (uint32_t)src2; \
|
|
if (tmp != (type)tmp) { \
|
|
env->QF = 1; \
|
|
if (src2 < 0) { \
|
|
tmp = (1 << (sizeof(type) * 8 - 1)) - 1; \
|
|
} else { \
|
|
tmp = 1 << (sizeof(type) * 8 - 1); \
|
|
} \
|
|
} \
|
|
dest = tmp; \
|
|
} while(0)
|
|
#define NEON_FN(dest, src1, src2) NEON_SSAT(dest, src1, src2, int8_t)
|
|
NEON_VOP(qsub_s8, neon_s8, 4)
|
|
#undef NEON_FN
|
|
#define NEON_FN(dest, src1, src2) NEON_SSAT(dest, src1, src2, int16_t)
|
|
NEON_VOP(qsub_s16, neon_s16, 2)
|
|
#undef NEON_FN
|
|
#undef NEON_SSAT
|
|
|
|
#define NEON_FN(dest, src1, src2) dest = (src1 > src2) ? ~0 : 0
|
|
NEON_VOP(cgt_s8, neon_s8, 4)
|
|
NEON_VOP(cgt_u8, neon_u8, 4)
|
|
NEON_VOP(cgt_s16, neon_s16, 2)
|
|
NEON_VOP(cgt_u16, neon_u16, 2)
|
|
NEON_VOP(cgt_s32, neon_s32, 1)
|
|
NEON_VOP(cgt_u32, neon_u32, 1)
|
|
#undef NEON_FN
|
|
|
|
#define NEON_FN(dest, src1, src2) dest = (src1 >= src2) ? ~0 : 0
|
|
NEON_VOP(cge_s8, neon_s8, 4)
|
|
NEON_VOP(cge_u8, neon_u8, 4)
|
|
NEON_VOP(cge_s16, neon_s16, 2)
|
|
NEON_VOP(cge_u16, neon_u16, 2)
|
|
NEON_VOP(cge_s32, neon_s32, 1)
|
|
NEON_VOP(cge_u32, neon_u32, 1)
|
|
#undef NEON_FN
|
|
|
|
#define NEON_FN(dest, src1, src2) do { \
|
|
int8_t tmp; \
|
|
tmp = (int8_t)src2; \
|
|
if (tmp < 0) { \
|
|
dest = src1 >> -tmp; \
|
|
} else { \
|
|
dest = src1 << tmp; \
|
|
}} while (0)
|
|
NEON_VOP(shl_s8, neon_s8, 4)
|
|
NEON_VOP(shl_u8, neon_u8, 4)
|
|
NEON_VOP(shl_s16, neon_s16, 2)
|
|
NEON_VOP(shl_u16, neon_u16, 2)
|
|
NEON_VOP(shl_s32, neon_s32, 1)
|
|
NEON_VOP(shl_u32, neon_u32, 1)
|
|
#undef NEON_FN
|
|
|
|
NEON_OP(shl_u64)
|
|
{
|
|
int8_t shift = T2;
|
|
uint64_t val = T0 | ((uint64_t)T1 << 32);
|
|
if (shift < 0) {
|
|
val >>= -shift;
|
|
} else {
|
|
val <<= shift;
|
|
}
|
|
T0 = val;
|
|
T1 = val >> 32;
|
|
FORCE_RET();
|
|
}
|
|
|
|
NEON_OP(shl_s64)
|
|
{
|
|
int8_t shift = T2;
|
|
int64_t val = T0 | ((uint64_t)T1 << 32);
|
|
if (shift < 0) {
|
|
val >>= -shift;
|
|
} else {
|
|
val <<= shift;
|
|
}
|
|
T0 = val;
|
|
T1 = val >> 32;
|
|
FORCE_RET();
|
|
}
|
|
|
|
#define NEON_FN(dest, src1, src2) do { \
|
|
int8_t tmp; \
|
|
tmp = (int8_t)src1; \
|
|
if (tmp < 0) { \
|
|
dest = (src2 + (1 << (-1 - tmp))) >> -tmp; \
|
|
} else { \
|
|
dest = src2 << tmp; \
|
|
}} while (0)
|
|
|
|
NEON_VOP(rshl_s8, neon_s8, 4)
|
|
NEON_VOP(rshl_u8, neon_u8, 4)
|
|
NEON_VOP(rshl_s16, neon_s16, 2)
|
|
NEON_VOP(rshl_u16, neon_u16, 2)
|
|
NEON_VOP(rshl_s32, neon_s32, 1)
|
|
NEON_VOP(rshl_u32, neon_u32, 1)
|
|
#undef NEON_FN
|
|
|
|
NEON_OP(rshl_u64)
|
|
{
|
|
int8_t shift = T2;
|
|
uint64_t val = T0 | ((uint64_t)T1 << 32);
|
|
if (shift < 0) {
|
|
val = (val + ((uint64_t)1 << (-1 - shift))) >> -shift;
|
|
val >>= -shift;
|
|
} else {
|
|
val <<= shift;
|
|
}
|
|
T0 = val;
|
|
T1 = val >> 32;
|
|
FORCE_RET();
|
|
}
|
|
|
|
NEON_OP(rshl_s64)
|
|
{
|
|
int8_t shift = T2;
|
|
int64_t val = T0 | ((uint64_t)T1 << 32);
|
|
if (shift < 0) {
|
|
val = (val + ((int64_t)1 << (-1 - shift))) >> -shift;
|
|
} else {
|
|
val <<= shift;
|
|
}
|
|
T0 = val;
|
|
T1 = val >> 32;
|
|
FORCE_RET();
|
|
}
|
|
|
|
#define NEON_FN(dest, src1, src2) do { \
|
|
int8_t tmp; \
|
|
tmp = (int8_t)src1; \
|
|
if (tmp < 0) { \
|
|
dest = src2 >> -tmp; \
|
|
} else { \
|
|
dest = src2 << tmp; \
|
|
if ((dest >> tmp) != src2) { \
|
|
env->QF = 1; \
|
|
dest = ~0; \
|
|
} \
|
|
}} while (0)
|
|
NEON_VOP(qshl_s8, neon_s8, 4)
|
|
NEON_VOP(qshl_s16, neon_s16, 2)
|
|
NEON_VOP(qshl_s32, neon_s32, 1)
|
|
#undef NEON_FN
|
|
|
|
NEON_OP(qshl_s64)
|
|
{
|
|
int8_t shift = T2;
|
|
int64_t val = T0 | ((uint64_t)T1 << 32);
|
|
if (shift < 0) {
|
|
val >>= -shift;
|
|
} else {
|
|
int64_t tmp = val;
|
|
val <<= shift;
|
|
if ((val >> shift) != tmp) {
|
|
env->QF = 1;
|
|
val = (tmp >> 63) ^ 0x7fffffffffffffffULL;
|
|
}
|
|
}
|
|
T0 = val;
|
|
T1 = val >> 32;
|
|
FORCE_RET();
|
|
}
|
|
|
|
#define NEON_FN(dest, src1, src2) do { \
|
|
int8_t tmp; \
|
|
tmp = (int8_t)src1; \
|
|
if (tmp < 0) { \
|
|
dest = src2 >> -tmp; \
|
|
} else { \
|
|
dest = src2 << tmp; \
|
|
if ((dest >> tmp) != src2) { \
|
|
env->QF = 1; \
|
|
dest = src2 >> 31; \
|
|
} \
|
|
}} while (0)
|
|
NEON_VOP(qshl_u8, neon_u8, 4)
|
|
NEON_VOP(qshl_u16, neon_u16, 2)
|
|
NEON_VOP(qshl_u32, neon_u32, 1)
|
|
#undef NEON_FN
|
|
|
|
NEON_OP(qshl_u64)
|
|
{
|
|
int8_t shift = T2;
|
|
uint64_t val = T0 | ((uint64_t)T1 << 32);
|
|
if (shift < 0) {
|
|
val >>= -shift;
|
|
} else {
|
|
uint64_t tmp = val;
|
|
val <<= shift;
|
|
if ((val >> shift) != tmp) {
|
|
env->QF = 1;
|
|
val = ~(uint64_t)0;
|
|
}
|
|
}
|
|
T0 = val;
|
|
T1 = val >> 32;
|
|
FORCE_RET();
|
|
}
|
|
|
|
#define NEON_FN(dest, src1, src2) do { \
|
|
int8_t tmp; \
|
|
tmp = (int8_t)src1; \
|
|
if (tmp < 0) { \
|
|
dest = (src2 + (1 << (-1 - tmp))) >> -tmp; \
|
|
} else { \
|
|
dest = src2 << tmp; \
|
|
if ((dest >> tmp) != src2) { \
|
|
dest = ~0; \
|
|
} \
|
|
}} while (0)
|
|
NEON_VOP(qrshl_s8, neon_s8, 4)
|
|
NEON_VOP(qrshl_s16, neon_s16, 2)
|
|
NEON_VOP(qrshl_s32, neon_s32, 1)
|
|
#undef NEON_FN
|
|
|
|
#define NEON_FN(dest, src1, src2) do { \
|
|
int8_t tmp; \
|
|
tmp = (int8_t)src1; \
|
|
if (tmp < 0) { \
|
|
dest = (src2 + (1 << (-1 - tmp))) >> -tmp; \
|
|
} else { \
|
|
dest = src2 << tmp; \
|
|
if ((dest >> tmp) != src2) { \
|
|
env->QF = 1; \
|
|
dest = src2 >> 31; \
|
|
} \
|
|
}} while (0)
|
|
NEON_VOP(qrshl_u8, neon_u8, 4)
|
|
NEON_VOP(qrshl_u16, neon_u16, 2)
|
|
NEON_VOP(qrshl_u32, neon_u32, 1)
|
|
#undef NEON_FN
|
|
|
|
#define NEON_FN(dest, src1, src2) dest = (src1 > src2) ? src1 : src2
|
|
NEON_VOP(max_s8, neon_s8, 4)
|
|
NEON_VOP(max_u8, neon_u8, 4)
|
|
NEON_VOP(max_s16, neon_s16, 2)
|
|
NEON_VOP(max_u16, neon_u16, 2)
|
|
NEON_VOP(max_s32, neon_s32, 1)
|
|
NEON_VOP(max_u32, neon_u32, 1)
|
|
NEON_POP(pmax_s8, neon_s8, 4)
|
|
NEON_POP(pmax_u8, neon_u8, 4)
|
|
NEON_POP(pmax_s16, neon_s16, 2)
|
|
NEON_POP(pmax_u16, neon_u16, 2)
|
|
#undef NEON_FN
|
|
|
|
NEON_OP(max_f32)
|
|
{
|
|
float32 f0 = vfp_itos(T0);
|
|
float32 f1 = vfp_itos(T1);
|
|
T0 = (float32_compare_quiet(f0, f1, NFS) == 1) ? T0 : T1;
|
|
FORCE_RET();
|
|
}
|
|
|
|
#define NEON_FN(dest, src1, src2) dest = (src1 < src2) ? src1 : src2
|
|
NEON_VOP(min_s8, neon_s8, 4)
|
|
NEON_VOP(min_u8, neon_u8, 4)
|
|
NEON_VOP(min_s16, neon_s16, 2)
|
|
NEON_VOP(min_u16, neon_u16, 2)
|
|
NEON_VOP(min_s32, neon_s32, 1)
|
|
NEON_VOP(min_u32, neon_u32, 1)
|
|
NEON_POP(pmin_s8, neon_s8, 4)
|
|
NEON_POP(pmin_u8, neon_u8, 4)
|
|
NEON_POP(pmin_s16, neon_s16, 2)
|
|
NEON_POP(pmin_u16, neon_u16, 2)
|
|
#undef NEON_FN
|
|
|
|
NEON_OP(min_f32)
|
|
{
|
|
float32 f0 = vfp_itos(T0);
|
|
float32 f1 = vfp_itos(T1);
|
|
T0 = (float32_compare_quiet(f0, f1, NFS) == -1) ? T0 : T1;
|
|
FORCE_RET();
|
|
}
|
|
|
|
#define NEON_FN(dest, src1, src2) \
|
|
dest = (src1 > src2) ? (src1 - src2) : (src2 - src1)
|
|
NEON_VOP(abd_s8, neon_s8, 4)
|
|
NEON_VOP(abd_u8, neon_u8, 4)
|
|
NEON_VOP(abd_s16, neon_s16, 2)
|
|
NEON_VOP(abd_u16, neon_u16, 2)
|
|
NEON_VOP(abd_s32, neon_s32, 1)
|
|
NEON_VOP(abd_u32, neon_u32, 1)
|
|
#undef NEON_FN
|
|
|
|
NEON_OP(abd_f32)
|
|
{
|
|
float32 f0 = vfp_itos(T0);
|
|
float32 f1 = vfp_itos(T1);
|
|
T0 = vfp_stoi((float32_compare_quiet(f0, f1, NFS) == 1)
|
|
? float32_sub(f0, f1, NFS)
|
|
: float32_sub(f1, f0, NFS));
|
|
FORCE_RET();
|
|
}
|
|
|
|
#define NEON_FN(dest, src1, src2) dest = src1 + src2
|
|
NEON_VOP(add_u8, neon_u8, 4)
|
|
NEON_VOP(add_u16, neon_u16, 2)
|
|
NEON_POP(padd_u8, neon_u8, 4)
|
|
NEON_POP(padd_u16, neon_u16, 2)
|
|
#undef NEON_FN
|
|
|
|
NEON_OP(add_f32)
|
|
{
|
|
T0 = vfp_stoi(float32_add(vfp_itos(T0), vfp_itos(T1), NFS));
|
|
FORCE_RET();
|
|
}
|
|
|
|
#define NEON_FN(dest, src1, src2) dest = src1 - src2
|
|
NEON_VOP(sub_u8, neon_u8, 4)
|
|
NEON_VOP(sub_u16, neon_u16, 2)
|
|
#undef NEON_FN
|
|
|
|
NEON_OP(sub_f32)
|
|
{
|
|
T0 = vfp_stoi(float32_sub(vfp_itos(T0), vfp_itos(T1), NFS));
|
|
FORCE_RET();
|
|
}
|
|
|
|
#define NEON_FN(dest, src1, src2) dest = src2 - src1
|
|
NEON_VOP(rsb_u8, neon_u8, 4)
|
|
NEON_VOP(rsb_u16, neon_u16, 2)
|
|
#undef NEON_FN
|
|
|
|
NEON_OP(rsb_f32)
|
|
{
|
|
T0 = vfp_stoi(float32_sub(vfp_itos(T1), vfp_itos(T0), NFS));
|
|
FORCE_RET();
|
|
}
|
|
|
|
#define NEON_FN(dest, src1, src2) dest = src1 * src2
|
|
NEON_VOP(mul_u8, neon_u8, 4)
|
|
NEON_VOP(mul_u16, neon_u16, 2)
|
|
#undef NEON_FN
|
|
|
|
NEON_OP(mul_f32)
|
|
{
|
|
T0 = vfp_stoi(float32_mul(vfp_itos(T0), vfp_itos(T1), NFS));
|
|
FORCE_RET();
|
|
}
|
|
|
|
NEON_OP(mul_p8)
|
|
{
|
|
T0 = helper_neon_mul_p8(T0, T1);
|
|
}
|
|
|
|
#define NEON_FN(dest, src1, src2) dest = (src1 & src2) ? -1 : 0
|
|
NEON_VOP(tst_u8, neon_u8, 4)
|
|
NEON_VOP(tst_u16, neon_u16, 2)
|
|
NEON_VOP(tst_u32, neon_u32, 1)
|
|
#undef NEON_FN
|
|
|
|
#define NEON_FN(dest, src1, src2) dest = (src1 == src2) ? -1 : 0
|
|
NEON_VOP(ceq_u8, neon_u8, 4)
|
|
NEON_VOP(ceq_u16, neon_u16, 2)
|
|
NEON_VOP(ceq_u32, neon_u32, 1)
|
|
#undef NEON_FN
|
|
|
|
#define NEON_QDMULH16(dest, src1, src2, round) do { \
|
|
uint32_t tmp = (int32_t)(int16_t) src1 * (int16_t) src2; \
|
|
if ((tmp ^ (tmp << 1)) & SIGNBIT) { \
|
|
env->QF = 1; \
|
|
tmp = (tmp >> 31) ^ ~SIGNBIT; \
|
|
} \
|
|
tmp <<= 1; \
|
|
if (round) { \
|
|
int32_t old = tmp; \
|
|
tmp += 1 << 15; \
|
|
if ((int32_t)tmp < old) { \
|
|
env->QF = 1; \
|
|
tmp = SIGNBIT - 1; \
|
|
} \
|
|
} \
|
|
dest = tmp >> 16; \
|
|
} while(0)
|
|
#define NEON_FN(dest, src1, src2) NEON_QDMULH16(dest, src1, src2, 0)
|
|
NEON_VOP(qdmulh_s16, neon_s16, 2)
|
|
#undef NEON_FN
|
|
#define NEON_FN(dest, src1, src2) NEON_QDMULH16(dest, src1, src2, 1)
|
|
NEON_VOP(qrdmulh_s16, neon_s16, 2)
|
|
#undef NEON_FN
|
|
#undef NEON_QDMULH16
|
|
|
|
#define SIGNBIT64 ((uint64_t)1 << 63)
|
|
#define NEON_QDMULH32(dest, src1, src2, round) do { \
|
|
uint64_t tmp = (int64_t)(int32_t) src1 * (int32_t) src2; \
|
|
if ((tmp ^ (tmp << 1)) & SIGNBIT64) { \
|
|
env->QF = 1; \
|
|
tmp = (tmp >> 63) ^ ~SIGNBIT64; \
|
|
} else { \
|
|
tmp <<= 1; \
|
|
} \
|
|
if (round) { \
|
|
int64_t old = tmp; \
|
|
tmp += (int64_t)1 << 31; \
|
|
if ((int64_t)tmp < old) { \
|
|
env->QF = 1; \
|
|
tmp = SIGNBIT64 - 1; \
|
|
} \
|
|
} \
|
|
dest = tmp >> 32; \
|
|
} while(0)
|
|
#define NEON_FN(dest, src1, src2) NEON_QDMULH32(dest, src1, src2, 0)
|
|
NEON_VOP(qdmulh_s32, neon_s32, 1)
|
|
#undef NEON_FN
|
|
#define NEON_FN(dest, src1, src2) NEON_QDMULH32(dest, src1, src2, 1)
|
|
NEON_VOP(qrdmulh_s32, neon_s32, 1)
|
|
#undef NEON_FN
|
|
#undef NEON_QDMULH32
|
|
|
|
NEON_OP(recps_f32)
|
|
{
|
|
T0 = vfp_stoi(helper_recps_f32(vfp_itos(T0), vfp_itos(T1)));
|
|
FORCE_RET();
|
|
}
|
|
|
|
NEON_OP(rsqrts_f32)
|
|
{
|
|
T0 = vfp_stoi(helper_rsqrts_f32(vfp_itos(T0), vfp_itos(T1)));
|
|
FORCE_RET();
|
|
}
|
|
|
|
/* Floating point comparisons produce an integer result. */
|
|
#define NEON_VOP_FCMP(name, cmp) \
|
|
NEON_OP(name) \
|
|
{ \
|
|
if (float32_compare_quiet(vfp_itos(T0), vfp_itos(T1), NFS) cmp 0) \
|
|
T0 = -1; \
|
|
else \
|
|
T0 = 0; \
|
|
FORCE_RET(); \
|
|
}
|
|
|
|
NEON_VOP_FCMP(ceq_f32, ==)
|
|
NEON_VOP_FCMP(cge_f32, >=)
|
|
NEON_VOP_FCMP(cgt_f32, >)
|
|
|
|
NEON_OP(acge_f32)
|
|
{
|
|
float32 f0 = float32_abs(vfp_itos(T0));
|
|
float32 f1 = float32_abs(vfp_itos(T1));
|
|
T0 = (float32_compare_quiet(f0, f1,NFS) >= 0) ? -1 : 0;
|
|
FORCE_RET();
|
|
}
|
|
|
|
NEON_OP(acgt_f32)
|
|
{
|
|
float32 f0 = float32_abs(vfp_itos(T0));
|
|
float32 f1 = float32_abs(vfp_itos(T1));
|
|
T0 = (float32_compare_quiet(f0, f1, NFS) > 0) ? -1 : 0;
|
|
FORCE_RET();
|
|
}
|
|
|
|
/* Narrowing instructions. The named type is the destination type. */
|
|
NEON_OP(narrow_u8)
|
|
{
|
|
T0 = (T0 & 0xff) | ((T0 >> 8) & 0xff00)
|
|
| ((T1 << 16) & 0xff0000) | (T1 << 24);
|
|
FORCE_RET();
|
|
}
|
|
|
|
NEON_OP(narrow_sat_u8)
|
|
{
|
|
neon_u16 src;
|
|
neon_u8 dest;
|
|
#define SAT8(d, s) \
|
|
if (s > 0xff) { \
|
|
d = 0xff; \
|
|
env->QF = 1; \
|
|
} else { \
|
|
d = s; \
|
|
}
|
|
|
|
NEON_UNPACK(neon_u16, src, T0);
|
|
SAT8(dest.v1, src.v1);
|
|
SAT8(dest.v2, src.v2);
|
|
NEON_UNPACK(neon_u16, src, T1);
|
|
SAT8(dest.v3, src.v1);
|
|
SAT8(dest.v4, src.v2);
|
|
NEON_PACK(neon_u8, T0, dest);
|
|
FORCE_RET();
|
|
#undef SAT8
|
|
}
|
|
|
|
NEON_OP(narrow_sat_s8)
|
|
{
|
|
neon_s16 src;
|
|
neon_s8 dest;
|
|
#define SAT8(d, s) \
|
|
if (s != (uint8_t)s) { \
|
|
d = (s >> 15) ^ 0x7f; \
|
|
env->QF = 1; \
|
|
} else { \
|
|
d = s; \
|
|
}
|
|
|
|
NEON_UNPACK(neon_s16, src, T0);
|
|
SAT8(dest.v1, src.v1);
|
|
SAT8(dest.v2, src.v2);
|
|
NEON_UNPACK(neon_s16, src, T1);
|
|
SAT8(dest.v3, src.v1);
|
|
SAT8(dest.v4, src.v2);
|
|
NEON_PACK(neon_s8, T0, dest);
|
|
FORCE_RET();
|
|
#undef SAT8
|
|
}
|
|
|
|
NEON_OP(narrow_u16)
|
|
{
|
|
T0 = (T0 & 0xffff) | (T1 << 16);
|
|
}
|
|
|
|
NEON_OP(narrow_sat_u16)
|
|
{
|
|
if (T0 > 0xffff) {
|
|
T0 = 0xffff;
|
|
env->QF = 1;
|
|
}
|
|
if (T1 > 0xffff) {
|
|
T1 = 0xffff;
|
|
env->QF = 1;
|
|
}
|
|
T0 |= T1 << 16;
|
|
FORCE_RET();
|
|
}
|
|
|
|
NEON_OP(narrow_sat_s16)
|
|
{
|
|
if ((int32_t)T0 != (int16_t)T0) {
|
|
T0 = ((int32_t)T0 >> 31) ^ 0x7fff;
|
|
env->QF = 1;
|
|
}
|
|
if ((int32_t)T1 != (int16_t) T1) {
|
|
T1 = ((int32_t)T1 >> 31) ^ 0x7fff;
|
|
env->QF = 1;
|
|
}
|
|
T0 = (uint16_t)T0 | (T1 << 16);
|
|
FORCE_RET();
|
|
}
|
|
|
|
NEON_OP(narrow_sat_u32)
|
|
{
|
|
if (T1) {
|
|
T0 = 0xffffffffu;
|
|
env->QF = 1;
|
|
}
|
|
FORCE_RET();
|
|
}
|
|
|
|
NEON_OP(narrow_sat_s32)
|
|
{
|
|
int32_t sign = (int32_t)T1 >> 31;
|
|
|
|
if ((int32_t)T1 != sign) {
|
|
T0 = sign ^ 0x7fffffff;
|
|
env->QF = 1;
|
|
}
|
|
FORCE_RET();
|
|
}
|
|
|
|
/* Narrowing instructions. Named type is the narrow type. */
|
|
NEON_OP(narrow_high_u8)
|
|
{
|
|
T0 = ((T0 >> 8) & 0xff) | ((T0 >> 16) & 0xff00)
|
|
| ((T1 << 8) & 0xff0000) | (T1 & 0xff000000);
|
|
FORCE_RET();
|
|
}
|
|
|
|
NEON_OP(narrow_high_u16)
|
|
{
|
|
T0 = (T0 >> 16) | (T1 & 0xffff0000);
|
|
FORCE_RET();
|
|
}
|
|
|
|
NEON_OP(narrow_high_round_u8)
|
|
{
|
|
T0 = (((T0 + 0x80) >> 8) & 0xff) | (((T0 + 0x800000) >> 16) & 0xff00)
|
|
| (((T1 + 0x80) << 8) & 0xff0000) | ((T1 + 0x800000) & 0xff000000);
|
|
FORCE_RET();
|
|
}
|
|
|
|
NEON_OP(narrow_high_round_u16)
|
|
{
|
|
T0 = ((T0 + 0x8000) >> 16) | ((T1 + 0x8000) & 0xffff0000);
|
|
FORCE_RET();
|
|
}
|
|
|
|
NEON_OP(narrow_high_round_u32)
|
|
{
|
|
if (T0 >= 0x80000000u)
|
|
T0 = T1 + 1;
|
|
else
|
|
T0 = T1;
|
|
FORCE_RET();
|
|
}
|
|
|
|
/* Widening instructions. Named type is source type. */
|
|
NEON_OP(widen_s8)
|
|
{
|
|
uint32_t src;
|
|
|
|
src = T0;
|
|
T0 = (uint16_t)(int8_t)src | ((int8_t)(src >> 8) << 16);
|
|
T1 = (uint16_t)(int8_t)(src >> 16) | ((int8_t)(src >> 24) << 16);
|
|
}
|
|
|
|
NEON_OP(widen_u8)
|
|
{
|
|
T1 = ((T0 >> 8) & 0xff0000) | ((T0 >> 16) & 0xff);
|
|
T0 = ((T0 << 8) & 0xff0000) | (T0 & 0xff);
|
|
}
|
|
|
|
NEON_OP(widen_s16)
|
|
{
|
|
int32_t src;
|
|
|
|
src = T0;
|
|
T0 = (int16_t)src;
|
|
T1 = src >> 16;
|
|
}
|
|
|
|
NEON_OP(widen_u16)
|
|
{
|
|
T1 = T0 >> 16;
|
|
T0 &= 0xffff;
|
|
}
|
|
|
|
NEON_OP(widen_s32)
|
|
{
|
|
T1 = (int32_t)T0 >> 31;
|
|
FORCE_RET();
|
|
}
|
|
|
|
NEON_OP(widen_high_u8)
|
|
{
|
|
T1 = (T0 & 0xff000000) | ((T0 >> 8) & 0xff00);
|
|
T0 = ((T0 << 16) & 0xff000000) | ((T0 << 8) & 0xff00);
|
|
}
|
|
|
|
NEON_OP(widen_high_u16)
|
|
{
|
|
T1 = T0 & 0xffff0000;
|
|
T0 <<= 16;
|
|
}
|
|
|
|
/* Long operations. The type is the wide type. */
|
|
NEON_OP(shll_u16)
|
|
{
|
|
int shift = PARAM1;
|
|
uint32_t mask;
|
|
|
|
mask = 0xffff >> (16 - shift);
|
|
mask |= mask << 16;
|
|
mask = ~mask;
|
|
|
|
T0 = (T0 << shift) & mask;
|
|
T1 = (T1 << shift) & mask;
|
|
FORCE_RET();
|
|
}
|
|
|
|
NEON_OP(shll_u64)
|
|
{
|
|
int shift = PARAM1;
|
|
|
|
T1 <<= shift;
|
|
T1 |= T0 >> (32 - shift);
|
|
T0 <<= shift;
|
|
FORCE_RET();
|
|
}
|
|
|
|
NEON_OP(addl_u16)
|
|
{
|
|
uint32_t tmp;
|
|
uint32_t high;
|
|
|
|
tmp = env->vfp.scratch[0];
|
|
high = (T0 >> 16) + (tmp >> 16);
|
|
T0 = (uint16_t)(T0 + tmp);
|
|
T0 |= (high << 16);
|
|
tmp = env->vfp.scratch[1];
|
|
high = (T1 >> 16) + (tmp >> 16);
|
|
T1 = (uint16_t)(T1 + tmp);
|
|
T1 |= (high << 16);
|
|
FORCE_RET();
|
|
}
|
|
|
|
NEON_OP(addl_u32)
|
|
{
|
|
T0 += env->vfp.scratch[0];
|
|
T1 += env->vfp.scratch[1];
|
|
FORCE_RET();
|
|
}
|
|
|
|
NEON_OP(addl_u64)
|
|
{
|
|
uint64_t tmp;
|
|
tmp = T0 | ((uint64_t)T1 << 32);
|
|
tmp += env->vfp.scratch[0];
|
|
tmp += (uint64_t)env->vfp.scratch[1] << 32;
|
|
T0 = tmp;
|
|
T1 = tmp >> 32;
|
|
FORCE_RET();
|
|
}
|
|
|
|
NEON_OP(subl_u16)
|
|
{
|
|
uint32_t tmp;
|
|
uint32_t high;
|
|
|
|
tmp = env->vfp.scratch[0];
|
|
high = (T0 >> 16) - (tmp >> 16);
|
|
T0 = (uint16_t)(T0 - tmp);
|
|
T0 |= (high << 16);
|
|
tmp = env->vfp.scratch[1];
|
|
high = (T1 >> 16) - (tmp >> 16);
|
|
T1 = (uint16_t)(T1 - tmp);
|
|
T1 |= (high << 16);
|
|
FORCE_RET();
|
|
}
|
|
|
|
NEON_OP(subl_u32)
|
|
{
|
|
T0 -= env->vfp.scratch[0];
|
|
T1 -= env->vfp.scratch[1];
|
|
FORCE_RET();
|
|
}
|
|
|
|
NEON_OP(subl_u64)
|
|
{
|
|
uint64_t tmp;
|
|
tmp = T0 | ((uint64_t)T1 << 32);
|
|
tmp -= env->vfp.scratch[0];
|
|
tmp -= (uint64_t)env->vfp.scratch[1] << 32;
|
|
T0 = tmp;
|
|
T1 = tmp >> 32;
|
|
FORCE_RET();
|
|
}
|
|
|
|
#define DO_ABD(dest, x, y, type) do { \
|
|
type tmp_x = x; \
|
|
type tmp_y = y; \
|
|
dest = ((tmp_x > tmp_y) ? tmp_x - tmp_y : tmp_y - tmp_x); \
|
|
} while(0)
|
|
|
|
NEON_OP(abdl_u16)
|
|
{
|
|
uint32_t tmp;
|
|
uint32_t low;
|
|
uint32_t high;
|
|
|
|
DO_ABD(low, T0, T1, uint8_t);
|
|
DO_ABD(tmp, T0 >> 8, T1 >> 8, uint8_t);
|
|
low |= tmp << 16;
|
|
DO_ABD(high, T0 >> 16, T1 >> 16, uint8_t);
|
|
DO_ABD(tmp, T0 >> 24, T1 >> 24, uint8_t);
|
|
high |= tmp << 16;
|
|
T0 = low;
|
|
T1 = high;
|
|
FORCE_RET();
|
|
}
|
|
|
|
NEON_OP(abdl_s16)
|
|
{
|
|
uint32_t tmp;
|
|
uint32_t low;
|
|
uint32_t high;
|
|
|
|
DO_ABD(low, T0, T1, int8_t);
|
|
DO_ABD(tmp, T0 >> 8, T1 >> 8, int8_t);
|
|
low |= tmp << 16;
|
|
DO_ABD(high, T0 >> 16, T1 >> 16, int8_t);
|
|
DO_ABD(tmp, T0 >> 24, T1 >> 24, int8_t);
|
|
high |= tmp << 16;
|
|
T0 = low;
|
|
T1 = high;
|
|
FORCE_RET();
|
|
}
|
|
|
|
NEON_OP(abdl_u32)
|
|
{
|
|
uint32_t low;
|
|
uint32_t high;
|
|
|
|
DO_ABD(low, T0, T1, uint16_t);
|
|
DO_ABD(high, T0 >> 16, T1 >> 16, uint16_t);
|
|
T0 = low;
|
|
T1 = high;
|
|
FORCE_RET();
|
|
}
|
|
|
|
NEON_OP(abdl_s32)
|
|
{
|
|
uint32_t low;
|
|
uint32_t high;
|
|
|
|
DO_ABD(low, T0, T1, int16_t);
|
|
DO_ABD(high, T0 >> 16, T1 >> 16, int16_t);
|
|
T0 = low;
|
|
T1 = high;
|
|
FORCE_RET();
|
|
}
|
|
|
|
NEON_OP(abdl_u64)
|
|
{
|
|
DO_ABD(T0, T0, T1, uint32_t);
|
|
T1 = 0;
|
|
}
|
|
|
|
NEON_OP(abdl_s64)
|
|
{
|
|
DO_ABD(T0, T0, T1, int32_t);
|
|
T1 = 0;
|
|
}
|
|
#undef DO_ABD
|
|
|
|
/* Widening multiple. Named type is the source type. */
|
|
#define DO_MULL(dest, x, y, type1, type2) do { \
|
|
type1 tmp_x = x; \
|
|
type1 tmp_y = y; \
|
|
dest = (type2)((type2)tmp_x * (type2)tmp_y); \
|
|
} while(0)
|
|
|
|
NEON_OP(mull_u8)
|
|
{
|
|
uint32_t tmp;
|
|
uint32_t low;
|
|
uint32_t high;
|
|
|
|
DO_MULL(low, T0, T1, uint8_t, uint16_t);
|
|
DO_MULL(tmp, T0 >> 8, T1 >> 8, uint8_t, uint16_t);
|
|
low |= tmp << 16;
|
|
DO_MULL(high, T0 >> 16, T1 >> 16, uint8_t, uint16_t);
|
|
DO_MULL(tmp, T0 >> 24, T1 >> 24, uint8_t, uint16_t);
|
|
high |= tmp << 16;
|
|
T0 = low;
|
|
T1 = high;
|
|
FORCE_RET();
|
|
}
|
|
|
|
NEON_OP(mull_s8)
|
|
{
|
|
uint32_t tmp;
|
|
uint32_t low;
|
|
uint32_t high;
|
|
|
|
DO_MULL(low, T0, T1, int8_t, uint16_t);
|
|
DO_MULL(tmp, T0 >> 8, T1 >> 8, int8_t, uint16_t);
|
|
low |= tmp << 16;
|
|
DO_MULL(high, T0 >> 16, T1 >> 16, int8_t, uint16_t);
|
|
DO_MULL(tmp, T0 >> 24, T1 >> 24, int8_t, uint16_t);
|
|
high |= tmp << 16;
|
|
T0 = low;
|
|
T1 = high;
|
|
FORCE_RET();
|
|
}
|
|
|
|
NEON_OP(mull_u16)
|
|
{
|
|
uint32_t low;
|
|
uint32_t high;
|
|
|
|
DO_MULL(low, T0, T1, uint16_t, uint32_t);
|
|
DO_MULL(high, T0 >> 16, T1 >> 16, uint16_t, uint32_t);
|
|
T0 = low;
|
|
T1 = high;
|
|
FORCE_RET();
|
|
}
|
|
|
|
NEON_OP(mull_s16)
|
|
{
|
|
uint32_t low;
|
|
uint32_t high;
|
|
|
|
DO_MULL(low, T0, T1, int16_t, uint32_t);
|
|
DO_MULL(high, T0 >> 16, T1 >> 16, int16_t, uint32_t);
|
|
T0 = low;
|
|
T1 = high;
|
|
FORCE_RET();
|
|
}
|
|
|
|
NEON_OP(addl_saturate_s32)
|
|
{
|
|
uint32_t tmp;
|
|
uint32_t res;
|
|
|
|
tmp = env->vfp.scratch[0];
|
|
res = T0 + tmp;
|
|
if (((res ^ T0) & SIGNBIT) && !((T0 ^ tmp) & SIGNBIT)) {
|
|
env->QF = 1;
|
|
T0 = (T0 >> 31) ^ 0x7fffffff;
|
|
} else {
|
|
T0 = res;
|
|
}
|
|
tmp = env->vfp.scratch[1];
|
|
res = T1 + tmp;
|
|
if (((res ^ T1) & SIGNBIT) && !((T1 ^ tmp) & SIGNBIT)) {
|
|
env->QF = 1;
|
|
T1 = (T1 >> 31) ^ 0x7fffffff;
|
|
} else {
|
|
T1 = res;
|
|
}
|
|
FORCE_RET();
|
|
}
|
|
|
|
NEON_OP(addl_saturate_s64)
|
|
{
|
|
uint64_t src1;
|
|
uint64_t src2;
|
|
uint64_t res;
|
|
|
|
src1 = T0 + ((uint64_t)T1 << 32);
|
|
src2 = env->vfp.scratch[0] + ((uint64_t)env->vfp.scratch[1] << 32);
|
|
res = src1 + src2;
|
|
if (((res ^ src1) & SIGNBIT64) && !((src1 ^ src2) & SIGNBIT64)) {
|
|
env->QF = 1;
|
|
T0 = ~(int64_t)src1 >> 63;
|
|
T1 = T0 ^ 0x80000000;
|
|
} else {
|
|
T0 = res;
|
|
T1 = res >> 32;
|
|
}
|
|
FORCE_RET();
|
|
}
|
|
|
|
NEON_OP(addl_saturate_u64)
|
|
{
|
|
uint64_t src1;
|
|
uint64_t src2;
|
|
uint64_t res;
|
|
|
|
src1 = T0 + ((uint64_t)T1 << 32);
|
|
src2 = env->vfp.scratch[0] + ((uint64_t)env->vfp.scratch[1] << 32);
|
|
res = src1 + src2;
|
|
if (res < src1) {
|
|
env->QF = 1;
|
|
T0 = 0xffffffff;
|
|
T1 = 0xffffffff;
|
|
} else {
|
|
T0 = res;
|
|
T1 = res >> 32;
|
|
}
|
|
FORCE_RET();
|
|
}
|
|
|
|
NEON_OP(subl_saturate_s64)
|
|
{
|
|
uint64_t src1;
|
|
uint64_t src2;
|
|
uint64_t res;
|
|
|
|
src1 = T0 + ((uint64_t)T1 << 32);
|
|
src2 = env->vfp.scratch[0] + ((uint64_t)env->vfp.scratch[1] << 32);
|
|
res = src1 - src2;
|
|
if (((res ^ src1) & SIGNBIT64) && ((src1 ^ src2) & SIGNBIT64)) {
|
|
env->QF = 1;
|
|
T0 = ~(int64_t)src1 >> 63;
|
|
T1 = T0 ^ 0x80000000;
|
|
} else {
|
|
T0 = res;
|
|
T1 = res >> 32;
|
|
}
|
|
FORCE_RET();
|
|
}
|
|
|
|
NEON_OP(subl_saturate_u64)
|
|
{
|
|
uint64_t src1;
|
|
uint64_t src2;
|
|
uint64_t res;
|
|
|
|
src1 = T0 + ((uint64_t)T1 << 32);
|
|
src2 = env->vfp.scratch[0] + ((uint64_t)env->vfp.scratch[1] << 32);
|
|
if (src1 < src2) {
|
|
env->QF = 1;
|
|
T0 = 0;
|
|
T1 = 0;
|
|
} else {
|
|
res = src1 - src2;
|
|
T0 = res;
|
|
T1 = res >> 32;
|
|
}
|
|
FORCE_RET();
|
|
}
|
|
|
|
NEON_OP(negl_u16)
|
|
{
|
|
uint32_t tmp;
|
|
tmp = T0 >> 16;
|
|
tmp = -tmp;
|
|
T0 = (-T0 & 0xffff) | (tmp << 16);
|
|
tmp = T1 >> 16;
|
|
tmp = -tmp;
|
|
T1 = (-T1 & 0xffff) | (tmp << 16);
|
|
FORCE_RET();
|
|
}
|
|
|
|
NEON_OP(negl_u32)
|
|
{
|
|
T0 = -T0;
|
|
T1 = -T1;
|
|
FORCE_RET();
|
|
}
|
|
|
|
NEON_OP(negl_u64)
|
|
{
|
|
uint64_t val;
|
|
|
|
val = T0 | ((uint64_t)T1 << 32);
|
|
val = -val;
|
|
T0 = val;
|
|
T1 = val >> 32;
|
|
FORCE_RET();
|
|
}
|
|
|
|
/* Scalar operations. */
|
|
NEON_OP(dup_low16)
|
|
{
|
|
T0 = (T0 & 0xffff) | (T0 << 16);
|
|
FORCE_RET();
|
|
}
|
|
|
|
NEON_OP(dup_high16)
|
|
{
|
|
T0 = (T0 >> 16) | (T0 & 0xffff0000);
|
|
FORCE_RET();
|
|
}
|
|
|
|
/* Helper for VEXT */
|
|
NEON_OP(extract)
|
|
{
|
|
int shift = PARAM1;
|
|
T0 = (T0 >> shift) | (T1 << (32 - shift));
|
|
FORCE_RET();
|
|
}
|
|
|
|
/* Pairwise add long. Named type is source type. */
|
|
NEON_OP(paddl_s8)
|
|
{
|
|
int8_t src1;
|
|
int8_t src2;
|
|
uint16_t result;
|
|
src1 = T0 >> 24;
|
|
src2 = T0 >> 16;
|
|
result = (uint16_t)src1 + src2;
|
|
src1 = T0 >> 8;
|
|
src2 = T0;
|
|
T0 = (uint16_t)((uint16_t)src1 + src2) | ((uint32_t)result << 16);
|
|
FORCE_RET();
|
|
}
|
|
|
|
NEON_OP(paddl_u8)
|
|
{
|
|
uint8_t src1;
|
|
uint8_t src2;
|
|
uint16_t result;
|
|
src1 = T0 >> 24;
|
|
src2 = T0 >> 16;
|
|
result = (uint16_t)src1 + src2;
|
|
src1 = T0 >> 8;
|
|
src2 = T0;
|
|
T0 = (uint16_t)((uint16_t)src1 + src2) | ((uint32_t)result << 16);
|
|
FORCE_RET();
|
|
}
|
|
|
|
NEON_OP(paddl_s16)
|
|
{
|
|
T0 = (uint32_t)(int16_t)T0 + (uint32_t)(int16_t)(T0 >> 16);
|
|
FORCE_RET();
|
|
}
|
|
|
|
NEON_OP(paddl_u16)
|
|
{
|
|
T0 = (uint32_t)(uint16_t)T0 + (uint32_t)(uint16_t)(T0 >> 16);
|
|
FORCE_RET();
|
|
}
|
|
|
|
NEON_OP(paddl_s32)
|
|
{
|
|
int64_t tmp;
|
|
tmp = (int64_t)(int32_t)T0 + (int64_t)(int32_t)T1;
|
|
T0 = tmp;
|
|
T1 = tmp >> 32;
|
|
FORCE_RET();
|
|
}
|
|
|
|
NEON_OP(paddl_u32)
|
|
{
|
|
uint64_t tmp;
|
|
tmp = (uint64_t)T0 + (uint64_t)T1;
|
|
T0 = tmp;
|
|
T1 = tmp >> 32;
|
|
FORCE_RET();
|
|
}
|
|
|
|
/* Count Leading Sign/Zero Bits. */
|
|
static inline int do_clz8(uint8_t x)
|
|
{
|
|
int n;
|
|
for (n = 8; x; n--)
|
|
x >>= 1;
|
|
return n;
|
|
}
|
|
|
|
static inline int do_clz16(uint16_t x)
|
|
{
|
|
int n;
|
|
for (n = 16; x; n--)
|
|
x >>= 1;
|
|
return n;
|
|
}
|
|
|
|
NEON_OP(clz_u8)
|
|
{
|
|
uint32_t result;
|
|
uint32_t tmp;
|
|
|
|
tmp = T0;
|
|
result = do_clz8(tmp);
|
|
result |= do_clz8(tmp >> 8) << 8;
|
|
result |= do_clz8(tmp >> 16) << 16;
|
|
result |= do_clz8(tmp >> 24) << 24;
|
|
T0 = result;
|
|
FORCE_RET();
|
|
}
|
|
|
|
NEON_OP(clz_u16)
|
|
{
|
|
uint32_t result;
|
|
uint32_t tmp;
|
|
tmp = T0;
|
|
result = do_clz16(tmp);
|
|
result |= do_clz16(tmp >> 16) << 16;
|
|
T0 = result;
|
|
FORCE_RET();
|
|
}
|
|
|
|
NEON_OP(cls_s8)
|
|
{
|
|
uint32_t result;
|
|
int8_t tmp;
|
|
tmp = T0;
|
|
result = do_clz8((tmp < 0) ? ~tmp : tmp) - 1;
|
|
tmp = T0 >> 8;
|
|
result |= (do_clz8((tmp < 0) ? ~tmp : tmp) - 1) << 8;
|
|
tmp = T0 >> 16;
|
|
result |= (do_clz8((tmp < 0) ? ~tmp : tmp) - 1) << 16;
|
|
tmp = T0 >> 24;
|
|
result |= (do_clz8((tmp < 0) ? ~tmp : tmp) - 1) << 24;
|
|
T0 = result;
|
|
FORCE_RET();
|
|
}
|
|
|
|
NEON_OP(cls_s16)
|
|
{
|
|
uint32_t result;
|
|
int16_t tmp;
|
|
tmp = T0;
|
|
result = do_clz16((tmp < 0) ? ~tmp : tmp) - 1;
|
|
tmp = T0 >> 16;
|
|
result |= (do_clz16((tmp < 0) ? ~tmp : tmp) - 1) << 16;
|
|
T0 = result;
|
|
FORCE_RET();
|
|
}
|
|
|
|
NEON_OP(cls_s32)
|
|
{
|
|
int count;
|
|
if ((int32_t)T0 < 0)
|
|
T0 = ~T0;
|
|
for (count = 32; T0 > 0; count--)
|
|
T0 = T0 >> 1;
|
|
T0 = count - 1;
|
|
FORCE_RET();
|
|
}
|
|
|
|
/* Bit count. */
|
|
NEON_OP(cnt_u8)
|
|
{
|
|
T0 = (T0 & 0x55555555) + ((T0 >> 1) & 0x55555555);
|
|
T0 = (T0 & 0x33333333) + ((T0 >> 2) & 0x33333333);
|
|
T0 = (T0 & 0x0f0f0f0f) + ((T0 >> 4) & 0x0f0f0f0f);
|
|
FORCE_RET();
|
|
}
|
|
|
|
/* Saturnating negation. */
|
|
/* ??? Make these use NEON_VOP1 */
|
|
#define DO_QABS8(x) do { \
|
|
if (x == (int8_t)0x80) { \
|
|
x = 0x7f; \
|
|
env->QF = 1; \
|
|
} else if (x < 0) { \
|
|
x = -x; \
|
|
}} while (0)
|
|
NEON_OP(qabs_s8)
|
|
{
|
|
neon_s8 vec;
|
|
NEON_UNPACK(neon_s8, vec, T0);
|
|
DO_QABS8(vec.v1);
|
|
DO_QABS8(vec.v2);
|
|
DO_QABS8(vec.v3);
|
|
DO_QABS8(vec.v4);
|
|
NEON_PACK(neon_s8, T0, vec);
|
|
FORCE_RET();
|
|
}
|
|
#undef DO_QABS8
|
|
|
|
#define DO_QNEG8(x) do { \
|
|
if (x == (int8_t)0x80) { \
|
|
x = 0x7f; \
|
|
env->QF = 1; \
|
|
} else { \
|
|
x = -x; \
|
|
}} while (0)
|
|
NEON_OP(qneg_s8)
|
|
{
|
|
neon_s8 vec;
|
|
NEON_UNPACK(neon_s8, vec, T0);
|
|
DO_QNEG8(vec.v1);
|
|
DO_QNEG8(vec.v2);
|
|
DO_QNEG8(vec.v3);
|
|
DO_QNEG8(vec.v4);
|
|
NEON_PACK(neon_s8, T0, vec);
|
|
FORCE_RET();
|
|
}
|
|
#undef DO_QNEG8
|
|
|
|
#define DO_QABS16(x) do { \
|
|
if (x == (int16_t)0x8000) { \
|
|
x = 0x7fff; \
|
|
env->QF = 1; \
|
|
} else if (x < 0) { \
|
|
x = -x; \
|
|
}} while (0)
|
|
NEON_OP(qabs_s16)
|
|
{
|
|
neon_s16 vec;
|
|
NEON_UNPACK(neon_s16, vec, T0);
|
|
DO_QABS16(vec.v1);
|
|
DO_QABS16(vec.v2);
|
|
NEON_PACK(neon_s16, T0, vec);
|
|
FORCE_RET();
|
|
}
|
|
#undef DO_QABS16
|
|
|
|
#define DO_QNEG16(x) do { \
|
|
if (x == (int16_t)0x8000) { \
|
|
x = 0x7fff; \
|
|
env->QF = 1; \
|
|
} else { \
|
|
x = -x; \
|
|
}} while (0)
|
|
NEON_OP(qneg_s16)
|
|
{
|
|
neon_s16 vec;
|
|
NEON_UNPACK(neon_s16, vec, T0);
|
|
DO_QNEG16(vec.v1);
|
|
DO_QNEG16(vec.v2);
|
|
NEON_PACK(neon_s16, T0, vec);
|
|
FORCE_RET();
|
|
}
|
|
#undef DO_QNEG16
|
|
|
|
NEON_OP(qabs_s32)
|
|
{
|
|
if (T0 == 0x80000000) {
|
|
T0 = 0x7fffffff;
|
|
env->QF = 1;
|
|
} else if ((int32_t)T0 < 0) {
|
|
T0 = -T0;
|
|
}
|
|
FORCE_RET();
|
|
}
|
|
|
|
NEON_OP(qneg_s32)
|
|
{
|
|
if (T0 == 0x80000000) {
|
|
T0 = 0x7fffffff;
|
|
env->QF = 1;
|
|
} else {
|
|
T0 = -T0;
|
|
}
|
|
FORCE_RET();
|
|
}
|
|
|
|
/* Unary opperations */
|
|
#define NEON_FN(dest, src, dummy) dest = (src < 0) ? -src : src
|
|
NEON_VOP1(abs_s8, neon_s8, 4)
|
|
NEON_VOP1(abs_s16, neon_s16, 2)
|
|
NEON_OP(abs_s32)
|
|
{
|
|
if ((int32_t)T0 < 0)
|
|
T0 = -T0;
|
|
FORCE_RET();
|
|
}
|
|
#undef NEON_FN
|
|
|
|
/* Transpose. Argument order is rather strange to avoid special casing
|
|
the tranlation code.
|
|
On input T0 = rm, T1 = rd. On output T0 = rd, T1 = rm */
|
|
NEON_OP(trn_u8)
|
|
{
|
|
uint32_t rd;
|
|
uint32_t rm;
|
|
rd = ((T0 & 0x00ff00ff) << 8) | (T1 & 0x00ff00ff);
|
|
rm = ((T1 & 0xff00ff00) >> 8) | (T0 & 0xff00ff00);
|
|
T0 = rd;
|
|
T1 = rm;
|
|
FORCE_RET();
|
|
}
|
|
|
|
NEON_OP(trn_u16)
|
|
{
|
|
uint32_t rd;
|
|
uint32_t rm;
|
|
rd = (T0 << 16) | (T1 & 0xffff);
|
|
rm = (T1 >> 16) | (T0 & 0xffff0000);
|
|
T0 = rd;
|
|
T1 = rm;
|
|
FORCE_RET();
|
|
}
|
|
|
|
/* Worker routines for zip and unzip. */
|
|
NEON_OP(unzip_u8)
|
|
{
|
|
uint32_t rd;
|
|
uint32_t rm;
|
|
rd = (T0 & 0xff) | ((T0 >> 8) & 0xff00)
|
|
| ((T1 << 16) & 0xff0000) | ((T1 << 8) & 0xff000000);
|
|
rm = ((T0 >> 8) & 0xff) | ((T0 >> 16) & 0xff00)
|
|
| ((T1 << 8) & 0xff0000) | (T1 & 0xff000000);
|
|
T0 = rd;
|
|
T1 = rm;
|
|
FORCE_RET();
|
|
}
|
|
|
|
NEON_OP(zip_u8)
|
|
{
|
|
uint32_t rd;
|
|
uint32_t rm;
|
|
rd = (T0 & 0xff) | ((T1 << 8) & 0xff00)
|
|
| ((T0 << 16) & 0xff0000) | ((T1 << 24) & 0xff000000);
|
|
rm = ((T0 >> 16) & 0xff) | ((T1 >> 8) & 0xff00)
|
|
| ((T0 >> 8) & 0xff0000) | (T1 & 0xff000000);
|
|
T0 = rd;
|
|
T1 = rm;
|
|
FORCE_RET();
|
|
}
|
|
|
|
NEON_OP(zip_u16)
|
|
{
|
|
uint32_t tmp;
|
|
|
|
tmp = (T0 & 0xffff) | (T1 << 16);
|
|
T1 = (T1 & 0xffff0000) | (T0 >> 16);
|
|
T0 = tmp;
|
|
FORCE_RET();
|
|
}
|
|
|
|
/* Reciprocal/root estimate. */
|
|
NEON_OP(recpe_u32)
|
|
{
|
|
T0 = helper_recpe_u32(T0);
|
|
}
|
|
|
|
NEON_OP(rsqrte_u32)
|
|
{
|
|
T0 = helper_rsqrte_u32(T0);
|
|
}
|
|
|
|
NEON_OP(recpe_f32)
|
|
{
|
|
FT0s = helper_recpe_f32(FT0s);
|
|
}
|
|
|
|
NEON_OP(rsqrte_f32)
|
|
{
|
|
FT0s = helper_rsqrte_f32(FT0s);
|
|
}
|
|
|
|
/* Table lookup. This accessed the register file directly. */
|
|
NEON_OP(tbl)
|
|
{
|
|
helper_neon_tbl(PARAM1, PARAM2);
|
|
}
|
|
|
|
NEON_OP(dup_u8)
|
|
{
|
|
T0 = (T0 >> PARAM1) & 0xff;
|
|
T0 |= T0 << 8;
|
|
T0 |= T0 << 16;
|
|
FORCE_RET();
|
|
}
|
|
|
|
/* Helpers for element load/store. */
|
|
NEON_OP(insert_elt)
|
|
{
|
|
int shift = PARAM1;
|
|
uint32_t mask = PARAM2;
|
|
T2 = (T2 & mask) | (T0 << shift);
|
|
FORCE_RET();
|
|
}
|
|
|
|
NEON_OP(extract_elt)
|
|
{
|
|
int shift = PARAM1;
|
|
uint32_t mask = PARAM2;
|
|
T0 = (T2 & mask) >> shift;
|
|
FORCE_RET();
|
|
}
|