Implement remaining Boolean SIMD operations on ARM.
- Implements Select instructions using a single ARM vbsl instruction. - Renames boolean machine operators to match renamed S1xN machine types. - Implements S1xN vector logical ops, AND, OR, XOR, NOT for ARM. - Implements S1xN AnyTrue, AllTrue ops for ARM. - Eliminates unused SIMD op categories in opcodes.h. LOG=N BUG=v8:6020 Review-Url: https://codereview.chromium.org/2711863002 Cr-Commit-Position: refs/heads/master@{#43556}
This commit is contained in:
parent
91cd070769
commit
386e5a1149
@ -4123,25 +4123,43 @@ void Assembler::vcvt_u32_f32(const QwNeonRegister dst,
|
|||||||
emit(EncodeNeonVCVT(U32, dst, F32, src));
|
emit(EncodeNeonVCVT(U32, dst, F32, src));
|
||||||
}
|
}
|
||||||
|
|
||||||
// op is instr->Bits(11, 7).
|
enum UnaryOp { VABS, VABSF, VNEG, VNEGF };
|
||||||
static Instr EncodeNeonUnaryOp(int op, bool is_float, NeonSize size,
|
|
||||||
const QwNeonRegister dst,
|
static Instr EncodeNeonUnaryOp(UnaryOp op, NeonSize size, QwNeonRegister dst,
|
||||||
const QwNeonRegister src) {
|
QwNeonRegister src) {
|
||||||
DCHECK_IMPLIES(is_float, size == Neon32);
|
int op_encoding = 0;
|
||||||
|
switch (op) {
|
||||||
|
case VABS:
|
||||||
|
op_encoding = 0x6 * B7;
|
||||||
|
break;
|
||||||
|
case VABSF:
|
||||||
|
DCHECK_EQ(Neon32, size);
|
||||||
|
op_encoding = 0x6 * B7 | B10;
|
||||||
|
break;
|
||||||
|
case VNEG:
|
||||||
|
op_encoding = 0x7 * B7;
|
||||||
|
break;
|
||||||
|
case VNEGF:
|
||||||
|
DCHECK_EQ(Neon32, size);
|
||||||
|
op_encoding = 0x7 * B7 | B10;
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
UNREACHABLE();
|
||||||
|
break;
|
||||||
|
}
|
||||||
int vd, d;
|
int vd, d;
|
||||||
dst.split_code(&vd, &d);
|
dst.split_code(&vd, &d);
|
||||||
int vm, m;
|
int vm, m;
|
||||||
src.split_code(&vm, &m);
|
src.split_code(&vm, &m);
|
||||||
int F = is_float ? 1 : 0;
|
return 0x1E7U * B23 | d * B22 | 0x3 * B20 | size * B18 | B16 | vd * B12 | B6 |
|
||||||
return 0x1E7U * B23 | d * B22 | 0x3 * B20 | size * B18 | B16 | vd * B12 |
|
m * B5 | vm | op_encoding;
|
||||||
F * B10 | B8 | op * B7 | B6 | m * B5 | vm;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
void Assembler::vabs(const QwNeonRegister dst, const QwNeonRegister src) {
|
void Assembler::vabs(const QwNeonRegister dst, const QwNeonRegister src) {
|
||||||
// Qd = vabs.f<size>(Qn, Qm) SIMD floating point absolute value.
|
// Qd = vabs.f<size>(Qn, Qm) SIMD floating point absolute value.
|
||||||
// Instruction details available in ARM DDI 0406C.b, A8.8.824.
|
// Instruction details available in ARM DDI 0406C.b, A8.8.824.
|
||||||
DCHECK(IsEnabled(NEON));
|
DCHECK(IsEnabled(NEON));
|
||||||
emit(EncodeNeonUnaryOp(0x6, true, Neon32, dst, src));
|
emit(EncodeNeonUnaryOp(VABSF, Neon32, dst, src));
|
||||||
}
|
}
|
||||||
|
|
||||||
void Assembler::vabs(NeonSize size, const QwNeonRegister dst,
|
void Assembler::vabs(NeonSize size, const QwNeonRegister dst,
|
||||||
@ -4149,14 +4167,14 @@ void Assembler::vabs(NeonSize size, const QwNeonRegister dst,
|
|||||||
// Qd = vabs.s<size>(Qn, Qm) SIMD integer absolute value.
|
// Qd = vabs.s<size>(Qn, Qm) SIMD integer absolute value.
|
||||||
// Instruction details available in ARM DDI 0406C.b, A8.8.824.
|
// Instruction details available in ARM DDI 0406C.b, A8.8.824.
|
||||||
DCHECK(IsEnabled(NEON));
|
DCHECK(IsEnabled(NEON));
|
||||||
emit(EncodeNeonUnaryOp(0x6, false, size, dst, src));
|
emit(EncodeNeonUnaryOp(VABS, size, dst, src));
|
||||||
}
|
}
|
||||||
|
|
||||||
void Assembler::vneg(const QwNeonRegister dst, const QwNeonRegister src) {
|
void Assembler::vneg(const QwNeonRegister dst, const QwNeonRegister src) {
|
||||||
// Qd = vabs.f<size>(Qn, Qm) SIMD floating point negate.
|
// Qd = vabs.f<size>(Qn, Qm) SIMD floating point negate.
|
||||||
// Instruction details available in ARM DDI 0406C.b, A8.8.968.
|
// Instruction details available in ARM DDI 0406C.b, A8.8.968.
|
||||||
DCHECK(IsEnabled(NEON));
|
DCHECK(IsEnabled(NEON));
|
||||||
emit(EncodeNeonUnaryOp(0x7, true, Neon32, dst, src));
|
emit(EncodeNeonUnaryOp(VNEGF, Neon32, dst, src));
|
||||||
}
|
}
|
||||||
|
|
||||||
void Assembler::vneg(NeonSize size, const QwNeonRegister dst,
|
void Assembler::vneg(NeonSize size, const QwNeonRegister dst,
|
||||||
@ -4164,7 +4182,7 @@ void Assembler::vneg(NeonSize size, const QwNeonRegister dst,
|
|||||||
// Qd = vabs.s<size>(Qn, Qm) SIMD integer negate.
|
// Qd = vabs.s<size>(Qn, Qm) SIMD integer negate.
|
||||||
// Instruction details available in ARM DDI 0406C.b, A8.8.968.
|
// Instruction details available in ARM DDI 0406C.b, A8.8.968.
|
||||||
DCHECK(IsEnabled(NEON));
|
DCHECK(IsEnabled(NEON));
|
||||||
emit(EncodeNeonUnaryOp(0x7, false, size, dst, src));
|
emit(EncodeNeonUnaryOp(VNEG, size, dst, src));
|
||||||
}
|
}
|
||||||
|
|
||||||
void Assembler::veor(DwVfpRegister dst, DwVfpRegister src1,
|
void Assembler::veor(DwVfpRegister dst, DwVfpRegister src1,
|
||||||
@ -4184,10 +4202,9 @@ void Assembler::veor(DwVfpRegister dst, DwVfpRegister src1,
|
|||||||
|
|
||||||
enum BinaryBitwiseOp { VAND, VBIC, VBIF, VBIT, VBSL, VEOR, VORR, VORN };
|
enum BinaryBitwiseOp { VAND, VBIC, VBIF, VBIT, VBSL, VEOR, VORR, VORN };
|
||||||
|
|
||||||
static Instr EncodeNeonBinaryBitwiseOp(BinaryBitwiseOp op,
|
static Instr EncodeNeonBinaryBitwiseOp(BinaryBitwiseOp op, QwNeonRegister dst,
|
||||||
const QwNeonRegister dst,
|
QwNeonRegister src1,
|
||||||
const QwNeonRegister src1,
|
QwNeonRegister src2) {
|
||||||
const QwNeonRegister src2) {
|
|
||||||
int op_encoding = 0;
|
int op_encoding = 0;
|
||||||
switch (op) {
|
switch (op) {
|
||||||
case VBIC:
|
case VBIC:
|
||||||
@ -4336,9 +4353,8 @@ enum IntegerBinOp {
|
|||||||
};
|
};
|
||||||
|
|
||||||
static Instr EncodeNeonBinOp(IntegerBinOp op, NeonDataType dt,
|
static Instr EncodeNeonBinOp(IntegerBinOp op, NeonDataType dt,
|
||||||
const QwNeonRegister dst,
|
QwNeonRegister dst, QwNeonRegister src1,
|
||||||
const QwNeonRegister src1,
|
QwNeonRegister src2) {
|
||||||
const QwNeonRegister src2) {
|
|
||||||
int op_encoding = 0;
|
int op_encoding = 0;
|
||||||
switch (op) {
|
switch (op) {
|
||||||
case VADD:
|
case VADD:
|
||||||
@ -4390,10 +4406,8 @@ static Instr EncodeNeonBinOp(IntegerBinOp op, NeonDataType dt,
|
|||||||
n * B7 | B6 | m * B5 | vm | op_encoding;
|
n * B7 | B6 | m * B5 | vm | op_encoding;
|
||||||
}
|
}
|
||||||
|
|
||||||
static Instr EncodeNeonBinOp(IntegerBinOp op, NeonSize size,
|
static Instr EncodeNeonBinOp(IntegerBinOp op, NeonSize size, QwNeonRegister dst,
|
||||||
const QwNeonRegister dst,
|
QwNeonRegister src1, QwNeonRegister src2) {
|
||||||
const QwNeonRegister src1,
|
|
||||||
const QwNeonRegister src2) {
|
|
||||||
// Map NeonSize values to the signed values in NeonDataType, so the U bit
|
// Map NeonSize values to the signed values in NeonDataType, so the U bit
|
||||||
// will be 0.
|
// will be 0.
|
||||||
return EncodeNeonBinOp(op, static_cast<NeonDataType>(size), dst, src1, src2);
|
return EncodeNeonBinOp(op, static_cast<NeonDataType>(size), dst, src1, src2);
|
||||||
@ -4578,6 +4592,51 @@ void Assembler::vrsqrts(QwNeonRegister dst, QwNeonRegister src1,
|
|||||||
emit(EncodeNeonBinOp(VRSQRTS, dst, src1, src2));
|
emit(EncodeNeonBinOp(VRSQRTS, dst, src1, src2));
|
||||||
}
|
}
|
||||||
|
|
||||||
|
enum PairwiseOp { VPMIN, VPMAX };
|
||||||
|
|
||||||
|
static Instr EncodeNeonPairwiseOp(PairwiseOp op, NeonDataType dt,
|
||||||
|
DwVfpRegister dst, DwVfpRegister src1,
|
||||||
|
DwVfpRegister src2) {
|
||||||
|
int op_encoding = 0;
|
||||||
|
switch (op) {
|
||||||
|
case VPMIN:
|
||||||
|
op_encoding = 0xA * B8 | B4;
|
||||||
|
break;
|
||||||
|
case VPMAX:
|
||||||
|
op_encoding = 0xA * B8;
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
UNREACHABLE();
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
int vd, d;
|
||||||
|
dst.split_code(&vd, &d);
|
||||||
|
int vn, n;
|
||||||
|
src1.split_code(&vn, &n);
|
||||||
|
int vm, m;
|
||||||
|
src2.split_code(&vm, &m);
|
||||||
|
int size = NeonSz(dt);
|
||||||
|
int u = NeonU(dt);
|
||||||
|
return 0x1E4U * B23 | u * B24 | d * B22 | size * B20 | vn * B16 | vd * B12 |
|
||||||
|
n * B7 | m * B5 | vm | op_encoding;
|
||||||
|
}
|
||||||
|
|
||||||
|
void Assembler::vpmin(NeonDataType dt, DwVfpRegister dst, DwVfpRegister src1,
|
||||||
|
DwVfpRegister src2) {
|
||||||
|
DCHECK(IsEnabled(NEON));
|
||||||
|
// Dd = vpmin(Dn, Dm) SIMD integer pairwise MIN.
|
||||||
|
// Instruction details available in ARM DDI 0406C.b, A8-986.
|
||||||
|
emit(EncodeNeonPairwiseOp(VPMIN, dt, dst, src1, src2));
|
||||||
|
}
|
||||||
|
|
||||||
|
void Assembler::vpmax(NeonDataType dt, DwVfpRegister dst, DwVfpRegister src1,
|
||||||
|
DwVfpRegister src2) {
|
||||||
|
DCHECK(IsEnabled(NEON));
|
||||||
|
// Dd = vpmax(Dn, Dm) SIMD integer pairwise MAX.
|
||||||
|
// Instruction details available in ARM DDI 0406C.b, A8-986.
|
||||||
|
emit(EncodeNeonPairwiseOp(VPMAX, dt, dst, src1, src2));
|
||||||
|
}
|
||||||
|
|
||||||
void Assembler::vtst(NeonSize size, QwNeonRegister dst, QwNeonRegister src1,
|
void Assembler::vtst(NeonSize size, QwNeonRegister dst, QwNeonRegister src1,
|
||||||
QwNeonRegister src2) {
|
QwNeonRegister src2) {
|
||||||
DCHECK(IsEnabled(NEON));
|
DCHECK(IsEnabled(NEON));
|
||||||
|
@ -418,7 +418,8 @@ const QwNeonRegister q15 = { 15 };
|
|||||||
// compilation unit that includes this header doesn't use the variables.
|
// compilation unit that includes this header doesn't use the variables.
|
||||||
#define kFirstCalleeSavedDoubleReg d8
|
#define kFirstCalleeSavedDoubleReg d8
|
||||||
#define kLastCalleeSavedDoubleReg d15
|
#define kLastCalleeSavedDoubleReg d15
|
||||||
// kDoubleRegZero and kScratchDoubleReg must pair to form kScratchQuadReg.
|
// kDoubleRegZero and kScratchDoubleReg must pair to form kScratchQuadReg. SIMD
|
||||||
|
// code depends on kDoubleRegZero before kScratchDoubleReg.
|
||||||
#define kDoubleRegZero d14
|
#define kDoubleRegZero d14
|
||||||
#define kScratchDoubleReg d15
|
#define kScratchDoubleReg d15
|
||||||
// After using kScratchQuadReg, kDoubleRegZero must be reset to 0.
|
// After using kScratchQuadReg, kDoubleRegZero must be reset to 0.
|
||||||
@ -1359,6 +1360,10 @@ class Assembler : public AssemblerBase {
|
|||||||
void vmax(QwNeonRegister dst, QwNeonRegister src1, QwNeonRegister src2);
|
void vmax(QwNeonRegister dst, QwNeonRegister src1, QwNeonRegister src2);
|
||||||
void vmax(NeonDataType dt, QwNeonRegister dst,
|
void vmax(NeonDataType dt, QwNeonRegister dst,
|
||||||
QwNeonRegister src1, QwNeonRegister src2);
|
QwNeonRegister src1, QwNeonRegister src2);
|
||||||
|
void vpmin(NeonDataType dt, DwVfpRegister dst, DwVfpRegister src1,
|
||||||
|
DwVfpRegister src2);
|
||||||
|
void vpmax(NeonDataType dt, DwVfpRegister dst, DwVfpRegister src1,
|
||||||
|
DwVfpRegister src2);
|
||||||
void vshl(NeonDataType dt, QwNeonRegister dst, QwNeonRegister src, int shift);
|
void vshl(NeonDataType dt, QwNeonRegister dst, QwNeonRegister src, int shift);
|
||||||
void vshr(NeonDataType dt, QwNeonRegister dst, QwNeonRegister src, int shift);
|
void vshr(NeonDataType dt, QwNeonRegister dst, QwNeonRegister src, int shift);
|
||||||
// vrecpe and vrsqrte only support floating point lanes.
|
// vrecpe and vrsqrte only support floating point lanes.
|
||||||
|
@ -1867,10 +1867,10 @@ void Decoder::DecodeSpecialCondition(Instruction* instr) {
|
|||||||
Vm = instr->VFPMRegValue(kSimd128Precision);
|
Vm = instr->VFPMRegValue(kSimd128Precision);
|
||||||
Vn = instr->VFPNRegValue(kSimd128Precision);
|
Vn = instr->VFPNRegValue(kSimd128Precision);
|
||||||
}
|
}
|
||||||
|
int size = kBitsPerByte * (1 << instr->Bits(21, 20));
|
||||||
switch (instr->Bits(11, 8)) {
|
switch (instr->Bits(11, 8)) {
|
||||||
case 0x0: {
|
case 0x0: {
|
||||||
if (instr->Bit(4) == 1) {
|
if (instr->Bit(4) == 1) {
|
||||||
int size = kBitsPerByte * (1 << instr->Bits(21, 20));
|
|
||||||
// vqadd.s<size> Qd, Qm, Qn.
|
// vqadd.s<size> Qd, Qm, Qn.
|
||||||
out_buffer_pos_ +=
|
out_buffer_pos_ +=
|
||||||
SNPrintF(out_buffer_ + out_buffer_pos_,
|
SNPrintF(out_buffer_ + out_buffer_pos_,
|
||||||
@ -1904,7 +1904,6 @@ void Decoder::DecodeSpecialCondition(Instruction* instr) {
|
|||||||
}
|
}
|
||||||
case 0x2: {
|
case 0x2: {
|
||||||
if (instr->Bit(4) == 1) {
|
if (instr->Bit(4) == 1) {
|
||||||
int size = kBitsPerByte * (1 << instr->Bits(21, 20));
|
|
||||||
// vqsub.s<size> Qd, Qm, Qn.
|
// vqsub.s<size> Qd, Qm, Qn.
|
||||||
out_buffer_pos_ +=
|
out_buffer_pos_ +=
|
||||||
SNPrintF(out_buffer_ + out_buffer_pos_,
|
SNPrintF(out_buffer_ + out_buffer_pos_,
|
||||||
@ -1915,7 +1914,6 @@ void Decoder::DecodeSpecialCondition(Instruction* instr) {
|
|||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
case 0x3: {
|
case 0x3: {
|
||||||
int size = kBitsPerByte * (1 << instr->Bits(21, 20));
|
|
||||||
const char* op = (instr->Bit(4) == 1) ? "vcge" : "vcgt";
|
const char* op = (instr->Bit(4) == 1) ? "vcge" : "vcgt";
|
||||||
// vcge/vcgt.s<size> Qd, Qm, Qn.
|
// vcge/vcgt.s<size> Qd, Qm, Qn.
|
||||||
out_buffer_pos_ +=
|
out_buffer_pos_ +=
|
||||||
@ -1924,7 +1922,6 @@ void Decoder::DecodeSpecialCondition(Instruction* instr) {
|
|||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
case 0x6: {
|
case 0x6: {
|
||||||
int size = kBitsPerByte * (1 << instr->Bits(21, 20));
|
|
||||||
// vmin/vmax.s<size> Qd, Qm, Qn.
|
// vmin/vmax.s<size> Qd, Qm, Qn.
|
||||||
const char* op = instr->Bit(4) == 1 ? "vmin" : "vmax";
|
const char* op = instr->Bit(4) == 1 ? "vmin" : "vmax";
|
||||||
out_buffer_pos_ +=
|
out_buffer_pos_ +=
|
||||||
@ -1934,7 +1931,6 @@ void Decoder::DecodeSpecialCondition(Instruction* instr) {
|
|||||||
}
|
}
|
||||||
case 0x8: {
|
case 0x8: {
|
||||||
const char* op = (instr->Bit(4) == 0) ? "vadd" : "vtst";
|
const char* op = (instr->Bit(4) == 0) ? "vadd" : "vtst";
|
||||||
int size = kBitsPerByte * (1 << instr->Bits(21, 20));
|
|
||||||
// vadd/vtst.i<size> Qd, Qm, Qn.
|
// vadd/vtst.i<size> Qd, Qm, Qn.
|
||||||
out_buffer_pos_ +=
|
out_buffer_pos_ +=
|
||||||
SNPrintF(out_buffer_ + out_buffer_pos_, "%s.i%d q%d, q%d, q%d",
|
SNPrintF(out_buffer_ + out_buffer_pos_, "%s.i%d q%d, q%d, q%d",
|
||||||
@ -1943,7 +1939,6 @@ void Decoder::DecodeSpecialCondition(Instruction* instr) {
|
|||||||
}
|
}
|
||||||
case 0x9: {
|
case 0x9: {
|
||||||
if (instr->Bit(6) == 1 && instr->Bit(4) == 1) {
|
if (instr->Bit(6) == 1 && instr->Bit(4) == 1) {
|
||||||
int size = kBitsPerByte * (1 << instr->Bits(21, 20));
|
|
||||||
// vmul.i<size> Qd, Qm, Qn.
|
// vmul.i<size> Qd, Qm, Qn.
|
||||||
out_buffer_pos_ +=
|
out_buffer_pos_ +=
|
||||||
SNPrintF(out_buffer_ + out_buffer_pos_,
|
SNPrintF(out_buffer_ + out_buffer_pos_,
|
||||||
@ -1953,6 +1948,14 @@ void Decoder::DecodeSpecialCondition(Instruction* instr) {
|
|||||||
}
|
}
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
|
case 0xa: {
|
||||||
|
// vpmin/vpmax.s<size> Dd, Dm, Dn.
|
||||||
|
const char* op = instr->Bit(4) == 1 ? "vpmin" : "vpmax";
|
||||||
|
out_buffer_pos_ +=
|
||||||
|
SNPrintF(out_buffer_ + out_buffer_pos_, "%s.s%d d%d, d%d, d%d",
|
||||||
|
op, size, Vd, Vn, Vm);
|
||||||
|
break;
|
||||||
|
}
|
||||||
case 0xd: {
|
case 0xd: {
|
||||||
if (instr->Bit(4) == 0) {
|
if (instr->Bit(4) == 0) {
|
||||||
const char* op = (instr->Bits(21, 20) == 0) ? "vadd" : "vsub";
|
const char* op = (instr->Bits(21, 20) == 0) ? "vadd" : "vsub";
|
||||||
@ -2052,10 +2055,10 @@ void Decoder::DecodeSpecialCondition(Instruction* instr) {
|
|||||||
Vm = instr->VFPMRegValue(kSimd128Precision);
|
Vm = instr->VFPMRegValue(kSimd128Precision);
|
||||||
Vn = instr->VFPNRegValue(kSimd128Precision);
|
Vn = instr->VFPNRegValue(kSimd128Precision);
|
||||||
}
|
}
|
||||||
|
int size = kBitsPerByte * (1 << instr->Bits(21, 20));
|
||||||
switch (instr->Bits(11, 8)) {
|
switch (instr->Bits(11, 8)) {
|
||||||
case 0x0: {
|
case 0x0: {
|
||||||
if (instr->Bit(4) == 1) {
|
if (instr->Bit(4) == 1) {
|
||||||
int size = kBitsPerByte * (1 << instr->Bits(21, 20));
|
|
||||||
// vqadd.u<size> Qd, Qm, Qn.
|
// vqadd.u<size> Qd, Qm, Qn.
|
||||||
out_buffer_pos_ +=
|
out_buffer_pos_ +=
|
||||||
SNPrintF(out_buffer_ + out_buffer_pos_,
|
SNPrintF(out_buffer_ + out_buffer_pos_,
|
||||||
@ -2087,7 +2090,6 @@ void Decoder::DecodeSpecialCondition(Instruction* instr) {
|
|||||||
}
|
}
|
||||||
case 0x2: {
|
case 0x2: {
|
||||||
if (instr->Bit(4) == 1) {
|
if (instr->Bit(4) == 1) {
|
||||||
int size = kBitsPerByte * (1 << instr->Bits(21, 20));
|
|
||||||
// vqsub.u<size> Qd, Qm, Qn.
|
// vqsub.u<size> Qd, Qm, Qn.
|
||||||
out_buffer_pos_ +=
|
out_buffer_pos_ +=
|
||||||
SNPrintF(out_buffer_ + out_buffer_pos_,
|
SNPrintF(out_buffer_ + out_buffer_pos_,
|
||||||
@ -2098,7 +2100,6 @@ void Decoder::DecodeSpecialCondition(Instruction* instr) {
|
|||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
case 0x3: {
|
case 0x3: {
|
||||||
int size = kBitsPerByte * (1 << instr->Bits(21, 20));
|
|
||||||
const char* op = (instr->Bit(4) == 1) ? "vcge" : "vcgt";
|
const char* op = (instr->Bit(4) == 1) ? "vcge" : "vcgt";
|
||||||
// vcge/vcgt.u<size> Qd, Qm, Qn.
|
// vcge/vcgt.u<size> Qd, Qm, Qn.
|
||||||
out_buffer_pos_ +=
|
out_buffer_pos_ +=
|
||||||
@ -2107,7 +2108,6 @@ void Decoder::DecodeSpecialCondition(Instruction* instr) {
|
|||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
case 0x6: {
|
case 0x6: {
|
||||||
int size = kBitsPerByte * (1 << instr->Bits(21, 20));
|
|
||||||
// vmin/vmax.u<size> Qd, Qm, Qn.
|
// vmin/vmax.u<size> Qd, Qm, Qn.
|
||||||
const char* op = instr->Bit(4) == 1 ? "vmin" : "vmax";
|
const char* op = instr->Bit(4) == 1 ? "vmin" : "vmax";
|
||||||
out_buffer_pos_ +=
|
out_buffer_pos_ +=
|
||||||
@ -2116,7 +2116,6 @@ void Decoder::DecodeSpecialCondition(Instruction* instr) {
|
|||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
case 0x8: {
|
case 0x8: {
|
||||||
int size = kBitsPerByte * (1 << instr->Bits(21, 20));
|
|
||||||
if (instr->Bit(4) == 0) {
|
if (instr->Bit(4) == 0) {
|
||||||
out_buffer_pos_ +=
|
out_buffer_pos_ +=
|
||||||
SNPrintF(out_buffer_ + out_buffer_pos_,
|
SNPrintF(out_buffer_ + out_buffer_pos_,
|
||||||
@ -2128,6 +2127,14 @@ void Decoder::DecodeSpecialCondition(Instruction* instr) {
|
|||||||
}
|
}
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
|
case 0xa: {
|
||||||
|
// vpmin/vpmax.u<size> Dd, Dm, Dn.
|
||||||
|
const char* op = instr->Bit(4) == 1 ? "vpmin" : "vpmax";
|
||||||
|
out_buffer_pos_ +=
|
||||||
|
SNPrintF(out_buffer_ + out_buffer_pos_, "%s.u%d d%d, d%d, d%d",
|
||||||
|
op, size, Vd, Vn, Vm);
|
||||||
|
break;
|
||||||
|
}
|
||||||
case 0xd: {
|
case 0xd: {
|
||||||
if (instr->Bit(21) == 0 && instr->Bit(6) == 1 && instr->Bit(4) == 1) {
|
if (instr->Bit(21) == 0 && instr->Bit(6) == 1 && instr->Bit(4) == 1) {
|
||||||
// vmul.f32 Qd, Qn, Qm
|
// vmul.f32 Qd, Qn, Qm
|
||||||
|
@ -1162,6 +1162,15 @@ void MacroAssembler::ExtractLane(Register dst, QwNeonRegister src,
|
|||||||
vmov(dt, dst, double_source, double_lane);
|
vmov(dt, dst, double_source, double_lane);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
void MacroAssembler::ExtractLane(Register dst, DwVfpRegister src,
|
||||||
|
NeonDataType dt, int lane) {
|
||||||
|
int size = NeonSz(dt); // 0, 1, 2
|
||||||
|
int byte = lane << size;
|
||||||
|
int double_byte = byte & (kDoubleSize - 1);
|
||||||
|
int double_lane = double_byte >> size;
|
||||||
|
vmov(dt, dst, src, double_lane);
|
||||||
|
}
|
||||||
|
|
||||||
void MacroAssembler::ExtractLane(SwVfpRegister dst, QwNeonRegister src,
|
void MacroAssembler::ExtractLane(SwVfpRegister dst, QwNeonRegister src,
|
||||||
Register scratch, int lane) {
|
Register scratch, int lane) {
|
||||||
int s_code = src.code() * 4 + lane;
|
int s_code = src.code() * 4 + lane;
|
||||||
|
@ -563,6 +563,7 @@ class MacroAssembler: public Assembler {
|
|||||||
void VmovExtended(const MemOperand& dst, int src_code, Register scratch);
|
void VmovExtended(const MemOperand& dst, int src_code, Register scratch);
|
||||||
|
|
||||||
void ExtractLane(Register dst, QwNeonRegister src, NeonDataType dt, int lane);
|
void ExtractLane(Register dst, QwNeonRegister src, NeonDataType dt, int lane);
|
||||||
|
void ExtractLane(Register dst, DwVfpRegister src, NeonDataType dt, int lane);
|
||||||
void ExtractLane(SwVfpRegister dst, QwNeonRegister src, Register scratch,
|
void ExtractLane(SwVfpRegister dst, QwNeonRegister src, Register scratch,
|
||||||
int lane);
|
int lane);
|
||||||
void ReplaceLane(QwNeonRegister dst, QwNeonRegister src, Register src_lane,
|
void ReplaceLane(QwNeonRegister dst, QwNeonRegister src, Register src_lane,
|
||||||
|
@ -900,6 +900,18 @@ void Simulator::set_d_register(int dreg, const uint32_t* value) {
|
|||||||
memcpy(vfp_registers_ + dreg * 2, value, sizeof(*value) * 2);
|
memcpy(vfp_registers_ + dreg * 2, value, sizeof(*value) * 2);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
template <typename T>
|
||||||
|
void Simulator::get_d_register(int dreg, T* value) {
|
||||||
|
DCHECK((dreg >= 0) && (dreg < num_d_registers));
|
||||||
|
memcpy(value, vfp_registers_ + dreg * 2, kDoubleSize);
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename T>
|
||||||
|
void Simulator::set_d_register(int dreg, const T* value) {
|
||||||
|
DCHECK((dreg >= 0) && (dreg < num_d_registers));
|
||||||
|
memcpy(vfp_registers_ + dreg * 2, value, kDoubleSize);
|
||||||
|
}
|
||||||
|
|
||||||
template <typename T>
|
template <typename T>
|
||||||
void Simulator::get_q_register(int qreg, T* value) {
|
void Simulator::get_q_register(int qreg, T* value) {
|
||||||
DCHECK((qreg >= 0) && (qreg < num_q_registers));
|
DCHECK((qreg >= 0) && (qreg < num_q_registers));
|
||||||
@ -912,7 +924,6 @@ void Simulator::set_q_register(int qreg, const T* value) {
|
|||||||
memcpy(vfp_registers_ + qreg * 4, value, kSimd128Size);
|
memcpy(vfp_registers_ + qreg * 4, value, kSimd128Size);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
// Raw access to the PC register.
|
// Raw access to the PC register.
|
||||||
void Simulator::set_pc(int32_t value) {
|
void Simulator::set_pc(int32_t value) {
|
||||||
pc_modified_ = true;
|
pc_modified_ = true;
|
||||||
@ -4006,6 +4017,11 @@ T Clamp(int64_t value) {
|
|||||||
return static_cast<T>(clamped);
|
return static_cast<T>(clamped);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
template <typename T>
|
||||||
|
T MinMax(T a, T b, bool is_min) {
|
||||||
|
return is_min ? std::min(a, b) : std::max(a, b);
|
||||||
|
}
|
||||||
|
|
||||||
template <typename T>
|
template <typename T>
|
||||||
void AddSaturate(Simulator* simulator, int Vd, int Vm, int Vn) {
|
void AddSaturate(Simulator* simulator, int Vd, int Vm, int Vn) {
|
||||||
static const int kLanes = 16 / sizeof(T);
|
static const int kLanes = 16 / sizeof(T);
|
||||||
@ -4180,10 +4196,7 @@ void Simulator::DecodeSpecialCondition(Instruction* instr) {
|
|||||||
get_q_register(Vn, src1);
|
get_q_register(Vn, src1);
|
||||||
get_q_register(Vm, src2);
|
get_q_register(Vm, src2);
|
||||||
for (int i = 0; i < 16; i++) {
|
for (int i = 0; i < 16; i++) {
|
||||||
if (min)
|
src1[i] = MinMax(src1[i], src2[i], min);
|
||||||
src1[i] = std::min(src1[i], src2[i]);
|
|
||||||
else
|
|
||||||
src1[i] = std::max(src1[i], src2[i]);
|
|
||||||
}
|
}
|
||||||
set_q_register(Vd, src1);
|
set_q_register(Vd, src1);
|
||||||
break;
|
break;
|
||||||
@ -4193,10 +4206,7 @@ void Simulator::DecodeSpecialCondition(Instruction* instr) {
|
|||||||
get_q_register(Vn, src1);
|
get_q_register(Vn, src1);
|
||||||
get_q_register(Vm, src2);
|
get_q_register(Vm, src2);
|
||||||
for (int i = 0; i < 8; i++) {
|
for (int i = 0; i < 8; i++) {
|
||||||
if (min)
|
src1[i] = MinMax(src1[i], src2[i], min);
|
||||||
src1[i] = std::min(src1[i], src2[i]);
|
|
||||||
else
|
|
||||||
src1[i] = std::max(src1[i], src2[i]);
|
|
||||||
}
|
}
|
||||||
set_q_register(Vd, src1);
|
set_q_register(Vd, src1);
|
||||||
break;
|
break;
|
||||||
@ -4206,10 +4216,7 @@ void Simulator::DecodeSpecialCondition(Instruction* instr) {
|
|||||||
get_q_register(Vn, src1);
|
get_q_register(Vn, src1);
|
||||||
get_q_register(Vm, src2);
|
get_q_register(Vm, src2);
|
||||||
for (int i = 0; i < 4; i++) {
|
for (int i = 0; i < 4; i++) {
|
||||||
if (min)
|
src1[i] = MinMax(src1[i], src2[i], min);
|
||||||
src1[i] = std::min(src1[i], src2[i]);
|
|
||||||
else
|
|
||||||
src1[i] = std::max(src1[i], src2[i]);
|
|
||||||
}
|
}
|
||||||
set_q_register(Vd, src1);
|
set_q_register(Vd, src1);
|
||||||
break;
|
break;
|
||||||
@ -4344,6 +4351,48 @@ void Simulator::DecodeSpecialCondition(Instruction* instr) {
|
|||||||
}
|
}
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
|
case 0xa: {
|
||||||
|
// vpmin/vpmax.s<size> Dd, Dm, Dn.
|
||||||
|
NeonSize size = static_cast<NeonSize>(instr->Bits(21, 20));
|
||||||
|
bool min = instr->Bit(4) != 0;
|
||||||
|
switch (size) {
|
||||||
|
case Neon8: {
|
||||||
|
int8_t dst[8], src1[8], src2[8];
|
||||||
|
get_d_register(Vn, src1);
|
||||||
|
get_d_register(Vm, src2);
|
||||||
|
for (int i = 0; i < 4; i++) {
|
||||||
|
dst[i + 0] = MinMax(src1[i * 2], src1[i * 2 + 1], min);
|
||||||
|
dst[i + 4] = MinMax(src2[i * 2], src2[i * 2 + 1], min);
|
||||||
|
}
|
||||||
|
set_d_register(Vd, dst);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
case Neon16: {
|
||||||
|
int16_t dst[4], src1[4], src2[4];
|
||||||
|
get_d_register(Vn, src1);
|
||||||
|
get_d_register(Vm, src2);
|
||||||
|
for (int i = 0; i < 2; i++) {
|
||||||
|
dst[i + 0] = MinMax(src1[i * 2], src1[i * 2 + 1], min);
|
||||||
|
dst[i + 2] = MinMax(src2[i * 2], src2[i * 2 + 1], min);
|
||||||
|
}
|
||||||
|
set_d_register(Vd, dst);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
case Neon32: {
|
||||||
|
int32_t dst[2], src1[2], src2[2];
|
||||||
|
get_d_register(Vn, src1);
|
||||||
|
get_d_register(Vm, src2);
|
||||||
|
dst[0] = MinMax(src1[0], src1[1], min);
|
||||||
|
dst[1] = MinMax(src2[0], src2[1], min);
|
||||||
|
set_d_register(Vd, dst);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
default:
|
||||||
|
UNREACHABLE();
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
}
|
||||||
case 0xd: {
|
case 0xd: {
|
||||||
if (instr->Bit(4) == 0) {
|
if (instr->Bit(4) == 0) {
|
||||||
float src1[4], src2[4];
|
float src1[4], src2[4];
|
||||||
@ -4398,16 +4447,10 @@ void Simulator::DecodeSpecialCondition(Instruction* instr) {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
} else {
|
} else {
|
||||||
if (instr->Bit(21) == 1) {
|
// vmin/vmax.f32 Qd, Qm, Qn.
|
||||||
// vmin.f32 Qd, Qm, Qn.
|
bool min = instr->Bit(21) == 1;
|
||||||
for (int i = 0; i < 4; i++) {
|
for (int i = 0; i < 4; i++) {
|
||||||
src1[i] = std::min(src1[i], src2[i]);
|
src1[i] = MinMax(src1[i], src2[i], min);
|
||||||
}
|
|
||||||
} else {
|
|
||||||
// vmax.f32 Qd, Qm, Qn.
|
|
||||||
for (int i = 0; i < 4; i++) {
|
|
||||||
src1[i] = std::max(src1[i], src2[i]);
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
set_q_register(Vd, src1);
|
set_q_register(Vd, src1);
|
||||||
@ -4693,10 +4736,7 @@ void Simulator::DecodeSpecialCondition(Instruction* instr) {
|
|||||||
get_q_register(Vn, src1);
|
get_q_register(Vn, src1);
|
||||||
get_q_register(Vm, src2);
|
get_q_register(Vm, src2);
|
||||||
for (int i = 0; i < 16; i++) {
|
for (int i = 0; i < 16; i++) {
|
||||||
if (min)
|
src1[i] = MinMax(src1[i], src2[i], min);
|
||||||
src1[i] = std::min(src1[i], src2[i]);
|
|
||||||
else
|
|
||||||
src1[i] = std::max(src1[i], src2[i]);
|
|
||||||
}
|
}
|
||||||
set_q_register(Vd, src1);
|
set_q_register(Vd, src1);
|
||||||
break;
|
break;
|
||||||
@ -4706,10 +4746,7 @@ void Simulator::DecodeSpecialCondition(Instruction* instr) {
|
|||||||
get_q_register(Vn, src1);
|
get_q_register(Vn, src1);
|
||||||
get_q_register(Vm, src2);
|
get_q_register(Vm, src2);
|
||||||
for (int i = 0; i < 8; i++) {
|
for (int i = 0; i < 8; i++) {
|
||||||
if (min)
|
src1[i] = MinMax(src1[i], src2[i], min);
|
||||||
src1[i] = std::min(src1[i], src2[i]);
|
|
||||||
else
|
|
||||||
src1[i] = std::max(src1[i], src2[i]);
|
|
||||||
}
|
}
|
||||||
set_q_register(Vd, src1);
|
set_q_register(Vd, src1);
|
||||||
break;
|
break;
|
||||||
@ -4719,10 +4756,7 @@ void Simulator::DecodeSpecialCondition(Instruction* instr) {
|
|||||||
get_q_register(Vn, src1);
|
get_q_register(Vn, src1);
|
||||||
get_q_register(Vm, src2);
|
get_q_register(Vm, src2);
|
||||||
for (int i = 0; i < 4; i++) {
|
for (int i = 0; i < 4; i++) {
|
||||||
if (min)
|
src1[i] = MinMax(src1[i], src2[i], min);
|
||||||
src1[i] = std::min(src1[i], src2[i]);
|
|
||||||
else
|
|
||||||
src1[i] = std::max(src1[i], src2[i]);
|
|
||||||
}
|
}
|
||||||
set_q_register(Vd, src1);
|
set_q_register(Vd, src1);
|
||||||
break;
|
break;
|
||||||
@ -4813,6 +4847,48 @@ void Simulator::DecodeSpecialCondition(Instruction* instr) {
|
|||||||
}
|
}
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
|
case 0xa: {
|
||||||
|
// vpmin/vpmax.u<size> Dd, Dm, Dn.
|
||||||
|
NeonSize size = static_cast<NeonSize>(instr->Bits(21, 20));
|
||||||
|
bool min = instr->Bit(4) != 0;
|
||||||
|
switch (size) {
|
||||||
|
case Neon8: {
|
||||||
|
uint8_t dst[8], src1[8], src2[8];
|
||||||
|
get_d_register(Vn, src1);
|
||||||
|
get_d_register(Vm, src2);
|
||||||
|
for (int i = 0; i < 4; i++) {
|
||||||
|
dst[i + 0] = MinMax(src1[i * 2], src1[i * 2 + 1], min);
|
||||||
|
dst[i + 4] = MinMax(src2[i * 2], src2[i * 2 + 1], min);
|
||||||
|
}
|
||||||
|
set_d_register(Vd, dst);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
case Neon16: {
|
||||||
|
uint16_t dst[4], src1[4], src2[4];
|
||||||
|
get_d_register(Vn, src1);
|
||||||
|
get_d_register(Vm, src2);
|
||||||
|
for (int i = 0; i < 2; i++) {
|
||||||
|
dst[i + 0] = MinMax(src1[i * 2], src1[i * 2 + 1], min);
|
||||||
|
dst[i + 2] = MinMax(src2[i * 2], src2[i * 2 + 1], min);
|
||||||
|
}
|
||||||
|
set_d_register(Vd, dst);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
case Neon32: {
|
||||||
|
uint32_t dst[2], src1[2], src2[2];
|
||||||
|
get_d_register(Vn, src1);
|
||||||
|
get_d_register(Vm, src2);
|
||||||
|
dst[0] = MinMax(src1[0], src1[1], min);
|
||||||
|
dst[1] = MinMax(src2[0], src2[1], min);
|
||||||
|
set_d_register(Vd, dst);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
default:
|
||||||
|
UNREACHABLE();
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
}
|
||||||
case 0xd: {
|
case 0xd: {
|
||||||
if (instr->Bit(21) == 0 && instr->Bit(6) == 1 && instr->Bit(4) == 1) {
|
if (instr->Bit(21) == 0 && instr->Bit(6) == 1 && instr->Bit(4) == 1) {
|
||||||
// vmul.f32 Qd, Qn, Qm
|
// vmul.f32 Qd, Qn, Qm
|
||||||
|
@ -155,6 +155,10 @@ class Simulator {
|
|||||||
void set_d_register(int dreg, const uint32_t* value);
|
void set_d_register(int dreg, const uint32_t* value);
|
||||||
// Support for NEON.
|
// Support for NEON.
|
||||||
template <typename T>
|
template <typename T>
|
||||||
|
void get_d_register(int dreg, T* value);
|
||||||
|
template <typename T>
|
||||||
|
void set_d_register(int dreg, const T* value);
|
||||||
|
template <typename T>
|
||||||
void get_q_register(int qreg, T* value);
|
void get_q_register(int qreg, T* value);
|
||||||
template <typename T>
|
template <typename T>
|
||||||
void set_q_register(int qreg, const T* value);
|
void set_q_register(int qreg, const T* value);
|
||||||
|
@ -1636,8 +1636,7 @@ CodeGenerator::CodeGenResult CodeGenerator::AssembleArchInstruction(
|
|||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
case kArmInt32x4GreaterThanOrEqual: {
|
case kArmInt32x4GreaterThanOrEqual: {
|
||||||
Simd128Register dst = i.OutputSimd128Register();
|
__ vcge(NeonS32, i.OutputSimd128Register(), i.InputSimd128Register(0),
|
||||||
__ vcge(NeonS32, dst, i.InputSimd128Register(0),
|
|
||||||
i.InputSimd128Register(1));
|
i.InputSimd128Register(1));
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
@ -1662,8 +1661,7 @@ CodeGenerator::CodeGenResult CodeGenerator::AssembleArchInstruction(
|
|||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
case kArmUint32x4GreaterThanOrEqual: {
|
case kArmUint32x4GreaterThanOrEqual: {
|
||||||
Simd128Register dst = i.OutputSimd128Register();
|
__ vcge(NeonU32, i.OutputSimd128Register(), i.InputSimd128Register(0),
|
||||||
__ vcge(NeonU32, dst, i.InputSimd128Register(0),
|
|
||||||
i.InputSimd128Register(1));
|
i.InputSimd128Register(1));
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
@ -1748,8 +1746,7 @@ CodeGenerator::CodeGenResult CodeGenerator::AssembleArchInstruction(
|
|||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
case kArmInt16x8GreaterThanOrEqual: {
|
case kArmInt16x8GreaterThanOrEqual: {
|
||||||
Simd128Register dst = i.OutputSimd128Register();
|
__ vcge(NeonS16, i.OutputSimd128Register(), i.InputSimd128Register(0),
|
||||||
__ vcge(NeonS16, dst, i.InputSimd128Register(0),
|
|
||||||
i.InputSimd128Register(1));
|
i.InputSimd128Register(1));
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
@ -1784,8 +1781,7 @@ CodeGenerator::CodeGenResult CodeGenerator::AssembleArchInstruction(
|
|||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
case kArmUint16x8GreaterThanOrEqual: {
|
case kArmUint16x8GreaterThanOrEqual: {
|
||||||
Simd128Register dst = i.OutputSimd128Register();
|
__ vcge(NeonU16, i.OutputSimd128Register(), i.InputSimd128Register(0),
|
||||||
__ vcge(NeonU16, dst, i.InputSimd128Register(0),
|
|
||||||
i.InputSimd128Register(1));
|
i.InputSimd128Register(1));
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
@ -1869,8 +1865,7 @@ CodeGenerator::CodeGenResult CodeGenerator::AssembleArchInstruction(
|
|||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
case kArmInt8x16GreaterThanOrEqual: {
|
case kArmInt8x16GreaterThanOrEqual: {
|
||||||
Simd128Register dst = i.OutputSimd128Register();
|
__ vcge(NeonS8, i.OutputSimd128Register(), i.InputSimd128Register(0),
|
||||||
__ vcge(NeonS8, dst, i.InputSimd128Register(0),
|
|
||||||
i.InputSimd128Register(1));
|
i.InputSimd128Register(1));
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
@ -1905,8 +1900,7 @@ CodeGenerator::CodeGenResult CodeGenerator::AssembleArchInstruction(
|
|||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
case kArmUint8x16GreaterThanOrEqual: {
|
case kArmUint8x16GreaterThanOrEqual: {
|
||||||
Simd128Register dst = i.OutputSimd128Register();
|
__ vcge(NeonU8, i.OutputSimd128Register(), i.InputSimd128Register(0),
|
||||||
__ vcge(NeonU8, dst, i.InputSimd128Register(0),
|
|
||||||
i.InputSimd128Register(1));
|
i.InputSimd128Register(1));
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
@ -1934,15 +1928,69 @@ CodeGenerator::CodeGenResult CodeGenerator::AssembleArchInstruction(
|
|||||||
__ vmvn(i.OutputSimd128Register(), i.InputSimd128Register(0));
|
__ vmvn(i.OutputSimd128Register(), i.InputSimd128Register(0));
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
case kArmSimd32x4Select:
|
case kArmSimd128Select: {
|
||||||
case kArmSimd16x8Select:
|
|
||||||
case kArmSimd8x16Select: {
|
|
||||||
// vbsl clobbers the mask input so make sure it was DefineSameAsFirst.
|
// vbsl clobbers the mask input so make sure it was DefineSameAsFirst.
|
||||||
DCHECK(i.OutputSimd128Register().is(i.InputSimd128Register(0)));
|
DCHECK(i.OutputSimd128Register().is(i.InputSimd128Register(0)));
|
||||||
__ vbsl(i.OutputSimd128Register(), i.InputSimd128Register(1),
|
__ vbsl(i.OutputSimd128Register(), i.InputSimd128Register(1),
|
||||||
i.InputSimd128Register(2));
|
i.InputSimd128Register(2));
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
|
case kArmSimd1x4AnyTrue: {
|
||||||
|
const QwNeonRegister& src = i.InputSimd128Register(0);
|
||||||
|
__ vpmax(NeonU32, kScratchDoubleReg, src.low(), src.high());
|
||||||
|
__ vpmax(NeonU32, kScratchDoubleReg, kScratchDoubleReg,
|
||||||
|
kScratchDoubleReg);
|
||||||
|
__ ExtractLane(i.OutputRegister(), kScratchDoubleReg, NeonS32, 0);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
case kArmSimd1x4AllTrue: {
|
||||||
|
const QwNeonRegister& src = i.InputSimd128Register(0);
|
||||||
|
__ vpmin(NeonU32, kScratchDoubleReg, src.low(), src.high());
|
||||||
|
__ vpmin(NeonU32, kScratchDoubleReg, kScratchDoubleReg,
|
||||||
|
kScratchDoubleReg);
|
||||||
|
__ ExtractLane(i.OutputRegister(), kScratchDoubleReg, NeonS32, 0);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
case kArmSimd1x8AnyTrue: {
|
||||||
|
const QwNeonRegister& src = i.InputSimd128Register(0);
|
||||||
|
__ vpmax(NeonU16, kScratchDoubleReg, src.low(), src.high());
|
||||||
|
__ vpmax(NeonU16, kScratchDoubleReg, kScratchDoubleReg,
|
||||||
|
kScratchDoubleReg);
|
||||||
|
__ vpmax(NeonU16, kScratchDoubleReg, kScratchDoubleReg,
|
||||||
|
kScratchDoubleReg);
|
||||||
|
__ ExtractLane(i.OutputRegister(), kScratchDoubleReg, NeonS16, 0);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
case kArmSimd1x8AllTrue: {
|
||||||
|
const QwNeonRegister& src = i.InputSimd128Register(0);
|
||||||
|
__ vpmin(NeonU16, kScratchDoubleReg, src.low(), src.high());
|
||||||
|
__ vpmin(NeonU16, kScratchDoubleReg, kScratchDoubleReg,
|
||||||
|
kScratchDoubleReg);
|
||||||
|
__ vpmin(NeonU16, kScratchDoubleReg, kScratchDoubleReg,
|
||||||
|
kScratchDoubleReg);
|
||||||
|
__ ExtractLane(i.OutputRegister(), kScratchDoubleReg, NeonS16, 0);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
case kArmSimd1x16AnyTrue: {
|
||||||
|
const QwNeonRegister& src = i.InputSimd128Register(0);
|
||||||
|
__ vpmax(NeonU8, kScratchDoubleReg, src.low(), src.high());
|
||||||
|
__ vpmax(NeonU8, kScratchDoubleReg, kScratchDoubleReg, kScratchDoubleReg);
|
||||||
|
// vtst to detect any bits in the bottom 32 bits of kScratchDoubleReg.
|
||||||
|
// This saves an instruction vs. the naive sequence of vpmax.
|
||||||
|
// kDoubleRegZero is not changed, since it is 0.
|
||||||
|
__ vtst(Neon32, kScratchQuadReg, kScratchQuadReg, kScratchQuadReg);
|
||||||
|
__ ExtractLane(i.OutputRegister(), kScratchDoubleReg, NeonS32, 0);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
case kArmSimd1x16AllTrue: {
|
||||||
|
const QwNeonRegister& src = i.InputSimd128Register(0);
|
||||||
|
__ vpmin(NeonU8, kScratchDoubleReg, src.low(), src.high());
|
||||||
|
__ vpmin(NeonU8, kScratchDoubleReg, kScratchDoubleReg, kScratchDoubleReg);
|
||||||
|
__ vpmin(NeonU8, kScratchDoubleReg, kScratchDoubleReg, kScratchDoubleReg);
|
||||||
|
__ vpmin(NeonU8, kScratchDoubleReg, kScratchDoubleReg, kScratchDoubleReg);
|
||||||
|
__ ExtractLane(i.OutputRegister(), kScratchDoubleReg, NeonS8, 0);
|
||||||
|
break;
|
||||||
|
}
|
||||||
case kCheckedLoadInt8:
|
case kCheckedLoadInt8:
|
||||||
ASSEMBLE_CHECKED_LOAD_INTEGER(ldrsb);
|
ASSEMBLE_CHECKED_LOAD_INTEGER(ldrsb);
|
||||||
break;
|
break;
|
||||||
|
@ -206,9 +206,13 @@ namespace compiler {
|
|||||||
V(ArmSimd128Or) \
|
V(ArmSimd128Or) \
|
||||||
V(ArmSimd128Xor) \
|
V(ArmSimd128Xor) \
|
||||||
V(ArmSimd128Not) \
|
V(ArmSimd128Not) \
|
||||||
V(ArmSimd32x4Select) \
|
V(ArmSimd128Select) \
|
||||||
V(ArmSimd16x8Select) \
|
V(ArmSimd1x4AnyTrue) \
|
||||||
V(ArmSimd8x16Select)
|
V(ArmSimd1x4AllTrue) \
|
||||||
|
V(ArmSimd1x8AnyTrue) \
|
||||||
|
V(ArmSimd1x8AllTrue) \
|
||||||
|
V(ArmSimd1x16AnyTrue) \
|
||||||
|
V(ArmSimd1x16AllTrue)
|
||||||
|
|
||||||
// Addressing modes represent the "shape" of inputs to an instruction.
|
// Addressing modes represent the "shape" of inputs to an instruction.
|
||||||
// Many instructions support multiple addressing modes. Addressing modes
|
// Many instructions support multiple addressing modes. Addressing modes
|
||||||
|
@ -194,9 +194,13 @@ int InstructionScheduler::GetTargetInstructionFlags(
|
|||||||
case kArmSimd128Or:
|
case kArmSimd128Or:
|
||||||
case kArmSimd128Xor:
|
case kArmSimd128Xor:
|
||||||
case kArmSimd128Not:
|
case kArmSimd128Not:
|
||||||
case kArmSimd32x4Select:
|
case kArmSimd128Select:
|
||||||
case kArmSimd16x8Select:
|
case kArmSimd1x4AnyTrue:
|
||||||
case kArmSimd8x16Select:
|
case kArmSimd1x4AllTrue:
|
||||||
|
case kArmSimd1x8AnyTrue:
|
||||||
|
case kArmSimd1x8AllTrue:
|
||||||
|
case kArmSimd1x16AnyTrue:
|
||||||
|
case kArmSimd1x16AllTrue:
|
||||||
return kNoOpcodeFlags;
|
return kNoOpcodeFlags;
|
||||||
|
|
||||||
case kArmVldrF32:
|
case kArmVldrF32:
|
||||||
|
@ -2198,73 +2198,91 @@ void InstructionSelector::VisitAtomicStore(Node* node) {
|
|||||||
V(Simd1x8Zero) \
|
V(Simd1x8Zero) \
|
||||||
V(Simd1x16Zero)
|
V(Simd1x16Zero)
|
||||||
|
|
||||||
#define SIMD_UNOP_LIST(V) \
|
#define SIMD_UNOP_LIST(V) \
|
||||||
V(Float32x4FromInt32x4) \
|
V(Float32x4FromInt32x4, kArmFloat32x4FromInt32x4) \
|
||||||
V(Float32x4FromUint32x4) \
|
V(Float32x4FromUint32x4, kArmFloat32x4FromUint32x4) \
|
||||||
V(Float32x4Abs) \
|
V(Float32x4Abs, kArmFloat32x4Abs) \
|
||||||
V(Float32x4Neg) \
|
V(Float32x4Neg, kArmFloat32x4Neg) \
|
||||||
V(Int32x4FromFloat32x4) \
|
V(Int32x4FromFloat32x4, kArmInt32x4FromFloat32x4) \
|
||||||
V(Uint32x4FromFloat32x4) \
|
V(Uint32x4FromFloat32x4, kArmUint32x4FromFloat32x4) \
|
||||||
V(Int32x4Neg) \
|
V(Int32x4Neg, kArmInt32x4Neg) \
|
||||||
V(Int16x8Neg) \
|
V(Int16x8Neg, kArmInt16x8Neg) \
|
||||||
V(Int8x16Neg) \
|
V(Int8x16Neg, kArmInt8x16Neg) \
|
||||||
V(Simd128Not)
|
V(Simd128Not, kArmSimd128Not) \
|
||||||
|
V(Simd1x4Not, kArmSimd128Not) \
|
||||||
|
V(Simd1x4AnyTrue, kArmSimd1x4AnyTrue) \
|
||||||
|
V(Simd1x4AllTrue, kArmSimd1x4AllTrue) \
|
||||||
|
V(Simd1x8Not, kArmSimd128Not) \
|
||||||
|
V(Simd1x8AnyTrue, kArmSimd1x8AnyTrue) \
|
||||||
|
V(Simd1x8AllTrue, kArmSimd1x8AllTrue) \
|
||||||
|
V(Simd1x16Not, kArmSimd128Not) \
|
||||||
|
V(Simd1x16AnyTrue, kArmSimd1x16AnyTrue) \
|
||||||
|
V(Simd1x16AllTrue, kArmSimd1x16AllTrue)
|
||||||
|
|
||||||
#define SIMD_BINOP_LIST(V) \
|
#define SIMD_BINOP_LIST(V) \
|
||||||
V(Float32x4Add) \
|
V(Float32x4Add, kArmFloat32x4Add) \
|
||||||
V(Float32x4Sub) \
|
V(Float32x4Sub, kArmFloat32x4Sub) \
|
||||||
V(Float32x4Equal) \
|
V(Float32x4Equal, kArmFloat32x4Equal) \
|
||||||
V(Float32x4NotEqual) \
|
V(Float32x4NotEqual, kArmFloat32x4NotEqual) \
|
||||||
V(Int32x4Add) \
|
V(Int32x4Add, kArmInt32x4Add) \
|
||||||
V(Int32x4Sub) \
|
V(Int32x4Sub, kArmInt32x4Sub) \
|
||||||
V(Int32x4Mul) \
|
V(Int32x4Mul, kArmInt32x4Mul) \
|
||||||
V(Int32x4Min) \
|
V(Int32x4Min, kArmInt32x4Min) \
|
||||||
V(Int32x4Max) \
|
V(Int32x4Max, kArmInt32x4Max) \
|
||||||
V(Int32x4Equal) \
|
V(Int32x4Equal, kArmInt32x4Equal) \
|
||||||
V(Int32x4NotEqual) \
|
V(Int32x4NotEqual, kArmInt32x4NotEqual) \
|
||||||
V(Int32x4GreaterThan) \
|
V(Int32x4GreaterThan, kArmInt32x4GreaterThan) \
|
||||||
V(Int32x4GreaterThanOrEqual) \
|
V(Int32x4GreaterThanOrEqual, kArmInt32x4GreaterThanOrEqual) \
|
||||||
V(Uint32x4Min) \
|
V(Uint32x4Min, kArmUint32x4Min) \
|
||||||
V(Uint32x4Max) \
|
V(Uint32x4Max, kArmUint32x4Max) \
|
||||||
V(Uint32x4GreaterThan) \
|
V(Uint32x4GreaterThan, kArmUint32x4GreaterThan) \
|
||||||
V(Uint32x4GreaterThanOrEqual) \
|
V(Uint32x4GreaterThanOrEqual, kArmUint32x4GreaterThanOrEqual) \
|
||||||
V(Int16x8Add) \
|
V(Int16x8Add, kArmInt16x8Add) \
|
||||||
V(Int16x8AddSaturate) \
|
V(Int16x8AddSaturate, kArmInt16x8AddSaturate) \
|
||||||
V(Int16x8Sub) \
|
V(Int16x8Sub, kArmInt16x8Sub) \
|
||||||
V(Int16x8SubSaturate) \
|
V(Int16x8SubSaturate, kArmInt16x8SubSaturate) \
|
||||||
V(Int16x8Mul) \
|
V(Int16x8Mul, kArmInt16x8Mul) \
|
||||||
V(Int16x8Min) \
|
V(Int16x8Min, kArmInt16x8Min) \
|
||||||
V(Int16x8Max) \
|
V(Int16x8Max, kArmInt16x8Max) \
|
||||||
V(Int16x8Equal) \
|
V(Int16x8Equal, kArmInt16x8Equal) \
|
||||||
V(Int16x8NotEqual) \
|
V(Int16x8NotEqual, kArmInt16x8NotEqual) \
|
||||||
V(Int16x8GreaterThan) \
|
V(Int16x8GreaterThan, kArmInt16x8GreaterThan) \
|
||||||
V(Int16x8GreaterThanOrEqual) \
|
V(Int16x8GreaterThanOrEqual, kArmInt16x8GreaterThanOrEqual) \
|
||||||
V(Uint16x8AddSaturate) \
|
V(Uint16x8AddSaturate, kArmUint16x8AddSaturate) \
|
||||||
V(Uint16x8SubSaturate) \
|
V(Uint16x8SubSaturate, kArmUint16x8SubSaturate) \
|
||||||
V(Uint16x8Min) \
|
V(Uint16x8Min, kArmUint16x8Min) \
|
||||||
V(Uint16x8Max) \
|
V(Uint16x8Max, kArmUint16x8Max) \
|
||||||
V(Uint16x8GreaterThan) \
|
V(Uint16x8GreaterThan, kArmUint16x8GreaterThan) \
|
||||||
V(Uint16x8GreaterThanOrEqual) \
|
V(Uint16x8GreaterThanOrEqual, kArmUint16x8GreaterThanOrEqual) \
|
||||||
V(Int8x16Add) \
|
V(Int8x16Add, kArmInt8x16Add) \
|
||||||
V(Int8x16AddSaturate) \
|
V(Int8x16AddSaturate, kArmInt8x16AddSaturate) \
|
||||||
V(Int8x16Sub) \
|
V(Int8x16Sub, kArmInt8x16Sub) \
|
||||||
V(Int8x16SubSaturate) \
|
V(Int8x16SubSaturate, kArmInt8x16SubSaturate) \
|
||||||
V(Int8x16Mul) \
|
V(Int8x16Mul, kArmInt8x16Mul) \
|
||||||
V(Int8x16Min) \
|
V(Int8x16Min, kArmInt8x16Min) \
|
||||||
V(Int8x16Max) \
|
V(Int8x16Max, kArmInt8x16Max) \
|
||||||
V(Int8x16Equal) \
|
V(Int8x16Equal, kArmInt8x16Equal) \
|
||||||
V(Int8x16NotEqual) \
|
V(Int8x16NotEqual, kArmInt8x16NotEqual) \
|
||||||
V(Int8x16GreaterThan) \
|
V(Int8x16GreaterThan, kArmInt8x16GreaterThan) \
|
||||||
V(Int8x16GreaterThanOrEqual) \
|
V(Int8x16GreaterThanOrEqual, kArmInt8x16GreaterThanOrEqual) \
|
||||||
V(Uint8x16AddSaturate) \
|
V(Uint8x16AddSaturate, kArmUint8x16AddSaturate) \
|
||||||
V(Uint8x16SubSaturate) \
|
V(Uint8x16SubSaturate, kArmUint8x16SubSaturate) \
|
||||||
V(Uint8x16Min) \
|
V(Uint8x16Min, kArmUint8x16Min) \
|
||||||
V(Uint8x16Max) \
|
V(Uint8x16Max, kArmUint8x16Max) \
|
||||||
V(Uint8x16GreaterThan) \
|
V(Uint8x16GreaterThan, kArmUint8x16GreaterThan) \
|
||||||
V(Uint8x16GreaterThanOrEqual) \
|
V(Uint8x16GreaterThanOrEqual, kArmUint8x16GreaterThanOrEqual) \
|
||||||
V(Simd128And) \
|
V(Simd128And, kArmSimd128And) \
|
||||||
V(Simd128Or) \
|
V(Simd128Or, kArmSimd128Or) \
|
||||||
V(Simd128Xor)
|
V(Simd128Xor, kArmSimd128Xor) \
|
||||||
|
V(Simd1x4And, kArmSimd128And) \
|
||||||
|
V(Simd1x4Or, kArmSimd128Or) \
|
||||||
|
V(Simd1x4Xor, kArmSimd128Xor) \
|
||||||
|
V(Simd1x8And, kArmSimd128And) \
|
||||||
|
V(Simd1x8Or, kArmSimd128Or) \
|
||||||
|
V(Simd1x8Xor, kArmSimd128Xor) \
|
||||||
|
V(Simd1x16And, kArmSimd128And) \
|
||||||
|
V(Simd1x16Or, kArmSimd128Or) \
|
||||||
|
V(Simd1x16Xor, kArmSimd128Xor)
|
||||||
|
|
||||||
#define SIMD_SHIFT_OP_LIST(V) \
|
#define SIMD_SHIFT_OP_LIST(V) \
|
||||||
V(Int32x4ShiftLeftByScalar) \
|
V(Int32x4ShiftLeftByScalar) \
|
||||||
@ -2306,16 +2324,16 @@ SIMD_TYPE_LIST(SIMD_VISIT_REPLACE_LANE)
|
|||||||
SIMD_ZERO_OP_LIST(SIMD_VISIT_ZERO_OP)
|
SIMD_ZERO_OP_LIST(SIMD_VISIT_ZERO_OP)
|
||||||
#undef SIMD_VISIT_ZERO_OP
|
#undef SIMD_VISIT_ZERO_OP
|
||||||
|
|
||||||
#define SIMD_VISIT_UNOP(Name) \
|
#define SIMD_VISIT_UNOP(Name, instruction) \
|
||||||
void InstructionSelector::Visit##Name(Node* node) { \
|
void InstructionSelector::Visit##Name(Node* node) { \
|
||||||
VisitRR(this, kArm##Name, node); \
|
VisitRR(this, instruction, node); \
|
||||||
}
|
}
|
||||||
SIMD_UNOP_LIST(SIMD_VISIT_UNOP)
|
SIMD_UNOP_LIST(SIMD_VISIT_UNOP)
|
||||||
#undef SIMD_VISIT_UNOP
|
#undef SIMD_VISIT_UNOP
|
||||||
|
|
||||||
#define SIMD_VISIT_BINOP(Name) \
|
#define SIMD_VISIT_BINOP(Name, instruction) \
|
||||||
void InstructionSelector::Visit##Name(Node* node) { \
|
void InstructionSelector::Visit##Name(Node* node) { \
|
||||||
VisitRRR(this, kArm##Name, node); \
|
VisitRRR(this, instruction, node); \
|
||||||
}
|
}
|
||||||
SIMD_BINOP_LIST(SIMD_VISIT_BINOP)
|
SIMD_BINOP_LIST(SIMD_VISIT_BINOP)
|
||||||
#undef SIMD_VISIT_BINOP
|
#undef SIMD_VISIT_BINOP
|
||||||
@ -2329,7 +2347,7 @@ SIMD_SHIFT_OP_LIST(SIMD_VISIT_SHIFT_OP)
|
|||||||
|
|
||||||
#define SIMD_VISIT_SELECT_OP(format) \
|
#define SIMD_VISIT_SELECT_OP(format) \
|
||||||
void InstructionSelector::VisitSimd##format##Select(Node* node) { \
|
void InstructionSelector::VisitSimd##format##Select(Node* node) { \
|
||||||
VisitRRRR(this, kArmSimd##format##Select, node); \
|
VisitRRRR(this, kArmSimd128Select, node); \
|
||||||
}
|
}
|
||||||
SIMD_FORMAT_LIST(SIMD_VISIT_SELECT_OP)
|
SIMD_FORMAT_LIST(SIMD_VISIT_SELECT_OP)
|
||||||
#undef SIMD_VISIT_SELECT_OP
|
#undef SIMD_VISIT_SELECT_OP
|
||||||
|
@ -1637,10 +1637,46 @@ void InstructionSelector::VisitNode(Node* node) {
|
|||||||
return MarkAsSimd128(node), VisitSimd8x16Select(node);
|
return MarkAsSimd128(node), VisitSimd8x16Select(node);
|
||||||
case IrOpcode::kSimd1x4Zero:
|
case IrOpcode::kSimd1x4Zero:
|
||||||
return MarkAsSimd1x4(node), VisitSimd1x4Zero(node);
|
return MarkAsSimd1x4(node), VisitSimd1x4Zero(node);
|
||||||
|
case IrOpcode::kSimd1x4And:
|
||||||
|
return MarkAsSimd1x4(node), VisitSimd1x4And(node);
|
||||||
|
case IrOpcode::kSimd1x4Or:
|
||||||
|
return MarkAsSimd1x4(node), VisitSimd1x4Or(node);
|
||||||
|
case IrOpcode::kSimd1x4Xor:
|
||||||
|
return MarkAsSimd1x4(node), VisitSimd1x4Xor(node);
|
||||||
|
case IrOpcode::kSimd1x4Not:
|
||||||
|
return MarkAsSimd1x4(node), VisitSimd1x4Not(node);
|
||||||
|
case IrOpcode::kSimd1x4AnyTrue:
|
||||||
|
return MarkAsWord32(node), VisitSimd1x4AnyTrue(node);
|
||||||
|
case IrOpcode::kSimd1x4AllTrue:
|
||||||
|
return MarkAsWord32(node), VisitSimd1x4AllTrue(node);
|
||||||
case IrOpcode::kSimd1x8Zero:
|
case IrOpcode::kSimd1x8Zero:
|
||||||
return MarkAsSimd1x8(node), VisitSimd1x8Zero(node);
|
return MarkAsSimd1x8(node), VisitSimd1x8Zero(node);
|
||||||
|
case IrOpcode::kSimd1x8And:
|
||||||
|
return MarkAsSimd1x8(node), VisitSimd1x8And(node);
|
||||||
|
case IrOpcode::kSimd1x8Or:
|
||||||
|
return MarkAsSimd1x8(node), VisitSimd1x8Or(node);
|
||||||
|
case IrOpcode::kSimd1x8Xor:
|
||||||
|
return MarkAsSimd1x8(node), VisitSimd1x8Xor(node);
|
||||||
|
case IrOpcode::kSimd1x8Not:
|
||||||
|
return MarkAsSimd1x8(node), VisitSimd1x8Not(node);
|
||||||
|
case IrOpcode::kSimd1x8AnyTrue:
|
||||||
|
return MarkAsWord32(node), VisitSimd1x8AnyTrue(node);
|
||||||
|
case IrOpcode::kSimd1x8AllTrue:
|
||||||
|
return MarkAsWord32(node), VisitSimd1x8AllTrue(node);
|
||||||
case IrOpcode::kSimd1x16Zero:
|
case IrOpcode::kSimd1x16Zero:
|
||||||
return MarkAsSimd1x16(node), VisitSimd1x16Zero(node);
|
return MarkAsSimd1x16(node), VisitSimd1x16Zero(node);
|
||||||
|
case IrOpcode::kSimd1x16And:
|
||||||
|
return MarkAsSimd1x16(node), VisitSimd1x16And(node);
|
||||||
|
case IrOpcode::kSimd1x16Or:
|
||||||
|
return MarkAsSimd1x16(node), VisitSimd1x16Or(node);
|
||||||
|
case IrOpcode::kSimd1x16Xor:
|
||||||
|
return MarkAsSimd1x16(node), VisitSimd1x16Xor(node);
|
||||||
|
case IrOpcode::kSimd1x16Not:
|
||||||
|
return MarkAsSimd1x16(node), VisitSimd1x16Not(node);
|
||||||
|
case IrOpcode::kSimd1x16AnyTrue:
|
||||||
|
return MarkAsWord32(node), VisitSimd1x16AnyTrue(node);
|
||||||
|
case IrOpcode::kSimd1x16AllTrue:
|
||||||
|
return MarkAsWord32(node), VisitSimd1x16AllTrue(node);
|
||||||
default:
|
default:
|
||||||
V8_Fatal(__FILE__, __LINE__, "Unexpected operator #%d:%s @ node #%d",
|
V8_Fatal(__FILE__, __LINE__, "Unexpected operator #%d:%s @ node #%d",
|
||||||
node->opcode(), node->op()->mnemonic(), node->id());
|
node->opcode(), node->op()->mnemonic(), node->id());
|
||||||
@ -2254,6 +2290,42 @@ void InstructionSelector::VisitSimd32x4Select(Node* node) { UNIMPLEMENTED(); }
|
|||||||
void InstructionSelector::VisitSimd16x8Select(Node* node) { UNIMPLEMENTED(); }
|
void InstructionSelector::VisitSimd16x8Select(Node* node) { UNIMPLEMENTED(); }
|
||||||
|
|
||||||
void InstructionSelector::VisitSimd8x16Select(Node* node) { UNIMPLEMENTED(); }
|
void InstructionSelector::VisitSimd8x16Select(Node* node) { UNIMPLEMENTED(); }
|
||||||
|
|
||||||
|
void InstructionSelector::VisitSimd1x4And(Node* node) { UNIMPLEMENTED(); }
|
||||||
|
|
||||||
|
void InstructionSelector::VisitSimd1x4Or(Node* node) { UNIMPLEMENTED(); }
|
||||||
|
|
||||||
|
void InstructionSelector::VisitSimd1x4Xor(Node* node) { UNIMPLEMENTED(); }
|
||||||
|
|
||||||
|
void InstructionSelector::VisitSimd1x4Not(Node* node) { UNIMPLEMENTED(); }
|
||||||
|
|
||||||
|
void InstructionSelector::VisitSimd1x4AnyTrue(Node* node) { UNIMPLEMENTED(); }
|
||||||
|
|
||||||
|
void InstructionSelector::VisitSimd1x4AllTrue(Node* node) { UNIMPLEMENTED(); }
|
||||||
|
|
||||||
|
void InstructionSelector::VisitSimd1x8And(Node* node) { UNIMPLEMENTED(); }
|
||||||
|
|
||||||
|
void InstructionSelector::VisitSimd1x8Or(Node* node) { UNIMPLEMENTED(); }
|
||||||
|
|
||||||
|
void InstructionSelector::VisitSimd1x8Xor(Node* node) { UNIMPLEMENTED(); }
|
||||||
|
|
||||||
|
void InstructionSelector::VisitSimd1x8Not(Node* node) { UNIMPLEMENTED(); }
|
||||||
|
|
||||||
|
void InstructionSelector::VisitSimd1x8AnyTrue(Node* node) { UNIMPLEMENTED(); }
|
||||||
|
|
||||||
|
void InstructionSelector::VisitSimd1x8AllTrue(Node* node) { UNIMPLEMENTED(); }
|
||||||
|
|
||||||
|
void InstructionSelector::VisitSimd1x16And(Node* node) { UNIMPLEMENTED(); }
|
||||||
|
|
||||||
|
void InstructionSelector::VisitSimd1x16Or(Node* node) { UNIMPLEMENTED(); }
|
||||||
|
|
||||||
|
void InstructionSelector::VisitSimd1x16Xor(Node* node) { UNIMPLEMENTED(); }
|
||||||
|
|
||||||
|
void InstructionSelector::VisitSimd1x16Not(Node* node) { UNIMPLEMENTED(); }
|
||||||
|
|
||||||
|
void InstructionSelector::VisitSimd1x16AnyTrue(Node* node) { UNIMPLEMENTED(); }
|
||||||
|
|
||||||
|
void InstructionSelector::VisitSimd1x16AllTrue(Node* node) { UNIMPLEMENTED(); }
|
||||||
#endif // !V8_TARGET_ARCH_ARM
|
#endif // !V8_TARGET_ARCH_ARM
|
||||||
|
|
||||||
void InstructionSelector::VisitFinishRegion(Node* node) { EmitIdentity(node); }
|
void InstructionSelector::VisitFinishRegion(Node* node) { EmitIdentity(node); }
|
||||||
|
@ -263,12 +263,6 @@ MachineRepresentation AtomicStoreRepresentationOf(Operator const* op) {
|
|||||||
V(Uint32x4GreaterThan, Operator::kNoProperties, 2, 0, 1) \
|
V(Uint32x4GreaterThan, Operator::kNoProperties, 2, 0, 1) \
|
||||||
V(Uint32x4GreaterThanOrEqual, Operator::kNoProperties, 2, 0, 1) \
|
V(Uint32x4GreaterThanOrEqual, Operator::kNoProperties, 2, 0, 1) \
|
||||||
V(Uint32x4FromFloat32x4, Operator::kNoProperties, 1, 0, 1) \
|
V(Uint32x4FromFloat32x4, Operator::kNoProperties, 1, 0, 1) \
|
||||||
V(Bool32x4And, Operator::kAssociative | Operator::kCommutative, 2, 0, 1) \
|
|
||||||
V(Bool32x4Or, Operator::kAssociative | Operator::kCommutative, 2, 0, 1) \
|
|
||||||
V(Bool32x4Xor, Operator::kAssociative | Operator::kCommutative, 2, 0, 1) \
|
|
||||||
V(Bool32x4Not, Operator::kNoProperties, 1, 0, 1) \
|
|
||||||
V(Bool32x4AnyTrue, Operator::kNoProperties, 1, 0, 1) \
|
|
||||||
V(Bool32x4AllTrue, Operator::kNoProperties, 1, 0, 1) \
|
|
||||||
V(Int16x8Splat, Operator::kNoProperties, 1, 0, 1) \
|
V(Int16x8Splat, Operator::kNoProperties, 1, 0, 1) \
|
||||||
V(Int16x8Neg, Operator::kNoProperties, 1, 0, 1) \
|
V(Int16x8Neg, Operator::kNoProperties, 1, 0, 1) \
|
||||||
V(Int16x8Add, Operator::kCommutative, 2, 0, 1) \
|
V(Int16x8Add, Operator::kCommutative, 2, 0, 1) \
|
||||||
@ -292,12 +286,6 @@ MachineRepresentation AtomicStoreRepresentationOf(Operator const* op) {
|
|||||||
V(Uint16x8LessThanOrEqual, Operator::kNoProperties, 2, 0, 1) \
|
V(Uint16x8LessThanOrEqual, Operator::kNoProperties, 2, 0, 1) \
|
||||||
V(Uint16x8GreaterThan, Operator::kNoProperties, 2, 0, 1) \
|
V(Uint16x8GreaterThan, Operator::kNoProperties, 2, 0, 1) \
|
||||||
V(Uint16x8GreaterThanOrEqual, Operator::kNoProperties, 2, 0, 1) \
|
V(Uint16x8GreaterThanOrEqual, Operator::kNoProperties, 2, 0, 1) \
|
||||||
V(Bool16x8And, Operator::kAssociative | Operator::kCommutative, 2, 0, 1) \
|
|
||||||
V(Bool16x8Or, Operator::kAssociative | Operator::kCommutative, 2, 0, 1) \
|
|
||||||
V(Bool16x8Xor, Operator::kAssociative | Operator::kCommutative, 2, 0, 1) \
|
|
||||||
V(Bool16x8Not, Operator::kNoProperties, 1, 0, 1) \
|
|
||||||
V(Bool16x8AnyTrue, Operator::kNoProperties, 1, 0, 1) \
|
|
||||||
V(Bool16x8AllTrue, Operator::kNoProperties, 1, 0, 1) \
|
|
||||||
V(Int8x16Splat, Operator::kNoProperties, 1, 0, 1) \
|
V(Int8x16Splat, Operator::kNoProperties, 1, 0, 1) \
|
||||||
V(Int8x16Neg, Operator::kNoProperties, 1, 0, 1) \
|
V(Int8x16Neg, Operator::kNoProperties, 1, 0, 1) \
|
||||||
V(Int8x16Add, Operator::kCommutative, 2, 0, 1) \
|
V(Int8x16Add, Operator::kCommutative, 2, 0, 1) \
|
||||||
@ -321,12 +309,6 @@ MachineRepresentation AtomicStoreRepresentationOf(Operator const* op) {
|
|||||||
V(Uint8x16LessThanOrEqual, Operator::kNoProperties, 2, 0, 1) \
|
V(Uint8x16LessThanOrEqual, Operator::kNoProperties, 2, 0, 1) \
|
||||||
V(Uint8x16GreaterThan, Operator::kNoProperties, 2, 0, 1) \
|
V(Uint8x16GreaterThan, Operator::kNoProperties, 2, 0, 1) \
|
||||||
V(Uint8x16GreaterThanOrEqual, Operator::kNoProperties, 2, 0, 1) \
|
V(Uint8x16GreaterThanOrEqual, Operator::kNoProperties, 2, 0, 1) \
|
||||||
V(Bool8x16And, Operator::kAssociative | Operator::kCommutative, 2, 0, 1) \
|
|
||||||
V(Bool8x16Or, Operator::kAssociative | Operator::kCommutative, 2, 0, 1) \
|
|
||||||
V(Bool8x16Xor, Operator::kAssociative | Operator::kCommutative, 2, 0, 1) \
|
|
||||||
V(Bool8x16Not, Operator::kNoProperties, 1, 0, 1) \
|
|
||||||
V(Bool8x16AnyTrue, Operator::kNoProperties, 1, 0, 1) \
|
|
||||||
V(Bool8x16AllTrue, Operator::kNoProperties, 1, 0, 1) \
|
|
||||||
V(Simd128Load, Operator::kNoProperties, 2, 0, 1) \
|
V(Simd128Load, Operator::kNoProperties, 2, 0, 1) \
|
||||||
V(Simd128Load1, Operator::kNoProperties, 2, 0, 1) \
|
V(Simd128Load1, Operator::kNoProperties, 2, 0, 1) \
|
||||||
V(Simd128Load2, Operator::kNoProperties, 2, 0, 1) \
|
V(Simd128Load2, Operator::kNoProperties, 2, 0, 1) \
|
||||||
@ -344,8 +326,26 @@ MachineRepresentation AtomicStoreRepresentationOf(Operator const* op) {
|
|||||||
V(Simd16x8Select, Operator::kNoProperties, 3, 0, 1) \
|
V(Simd16x8Select, Operator::kNoProperties, 3, 0, 1) \
|
||||||
V(Simd8x16Select, Operator::kNoProperties, 3, 0, 1) \
|
V(Simd8x16Select, Operator::kNoProperties, 3, 0, 1) \
|
||||||
V(Simd1x4Zero, Operator::kNoProperties, 0, 0, 1) \
|
V(Simd1x4Zero, Operator::kNoProperties, 0, 0, 1) \
|
||||||
|
V(Simd1x4And, Operator::kAssociative | Operator::kCommutative, 2, 0, 1) \
|
||||||
|
V(Simd1x4Or, Operator::kAssociative | Operator::kCommutative, 2, 0, 1) \
|
||||||
|
V(Simd1x4Xor, Operator::kAssociative | Operator::kCommutative, 2, 0, 1) \
|
||||||
|
V(Simd1x4Not, Operator::kNoProperties, 1, 0, 1) \
|
||||||
|
V(Simd1x4AnyTrue, Operator::kNoProperties, 1, 0, 1) \
|
||||||
|
V(Simd1x4AllTrue, Operator::kNoProperties, 1, 0, 1) \
|
||||||
V(Simd1x8Zero, Operator::kNoProperties, 0, 0, 1) \
|
V(Simd1x8Zero, Operator::kNoProperties, 0, 0, 1) \
|
||||||
V(Simd1x16Zero, Operator::kNoProperties, 0, 0, 1)
|
V(Simd1x8And, Operator::kAssociative | Operator::kCommutative, 2, 0, 1) \
|
||||||
|
V(Simd1x8Or, Operator::kAssociative | Operator::kCommutative, 2, 0, 1) \
|
||||||
|
V(Simd1x8Xor, Operator::kAssociative | Operator::kCommutative, 2, 0, 1) \
|
||||||
|
V(Simd1x8Not, Operator::kNoProperties, 1, 0, 1) \
|
||||||
|
V(Simd1x8AnyTrue, Operator::kNoProperties, 1, 0, 1) \
|
||||||
|
V(Simd1x8AllTrue, Operator::kNoProperties, 1, 0, 1) \
|
||||||
|
V(Simd1x16Zero, Operator::kNoProperties, 0, 0, 1) \
|
||||||
|
V(Simd1x16And, Operator::kAssociative | Operator::kCommutative, 2, 0, 1) \
|
||||||
|
V(Simd1x16Or, Operator::kAssociative | Operator::kCommutative, 2, 0, 1) \
|
||||||
|
V(Simd1x16Xor, Operator::kAssociative | Operator::kCommutative, 2, 0, 1) \
|
||||||
|
V(Simd1x16Not, Operator::kNoProperties, 1, 0, 1) \
|
||||||
|
V(Simd1x16AnyTrue, Operator::kNoProperties, 1, 0, 1) \
|
||||||
|
V(Simd1x16AllTrue, Operator::kNoProperties, 1, 0, 1)
|
||||||
|
|
||||||
#define PURE_OPTIONAL_OP_LIST(V) \
|
#define PURE_OPTIONAL_OP_LIST(V) \
|
||||||
V(Word32Ctz, Operator::kNoProperties, 1, 0, 1) \
|
V(Word32Ctz, Operator::kNoProperties, 1, 0, 1) \
|
||||||
|
@ -478,13 +478,6 @@ class V8_EXPORT_PRIVATE MachineOperatorBuilder final
|
|||||||
const Operator* Uint32x4GreaterThanOrEqual();
|
const Operator* Uint32x4GreaterThanOrEqual();
|
||||||
const Operator* Uint32x4FromFloat32x4();
|
const Operator* Uint32x4FromFloat32x4();
|
||||||
|
|
||||||
const Operator* Bool32x4And();
|
|
||||||
const Operator* Bool32x4Or();
|
|
||||||
const Operator* Bool32x4Xor();
|
|
||||||
const Operator* Bool32x4Not();
|
|
||||||
const Operator* Bool32x4AnyTrue();
|
|
||||||
const Operator* Bool32x4AllTrue();
|
|
||||||
|
|
||||||
const Operator* Int16x8Splat();
|
const Operator* Int16x8Splat();
|
||||||
const Operator* Int16x8ExtractLane(int32_t);
|
const Operator* Int16x8ExtractLane(int32_t);
|
||||||
const Operator* Int16x8ReplaceLane(int32_t);
|
const Operator* Int16x8ReplaceLane(int32_t);
|
||||||
@ -515,13 +508,6 @@ class V8_EXPORT_PRIVATE MachineOperatorBuilder final
|
|||||||
const Operator* Uint16x8GreaterThan();
|
const Operator* Uint16x8GreaterThan();
|
||||||
const Operator* Uint16x8GreaterThanOrEqual();
|
const Operator* Uint16x8GreaterThanOrEqual();
|
||||||
|
|
||||||
const Operator* Bool16x8And();
|
|
||||||
const Operator* Bool16x8Or();
|
|
||||||
const Operator* Bool16x8Xor();
|
|
||||||
const Operator* Bool16x8Not();
|
|
||||||
const Operator* Bool16x8AnyTrue();
|
|
||||||
const Operator* Bool16x8AllTrue();
|
|
||||||
|
|
||||||
const Operator* Int8x16Splat();
|
const Operator* Int8x16Splat();
|
||||||
const Operator* Int8x16ExtractLane(int32_t);
|
const Operator* Int8x16ExtractLane(int32_t);
|
||||||
const Operator* Int8x16ReplaceLane(int32_t);
|
const Operator* Int8x16ReplaceLane(int32_t);
|
||||||
@ -552,13 +538,6 @@ class V8_EXPORT_PRIVATE MachineOperatorBuilder final
|
|||||||
const Operator* Uint8x16GreaterThan();
|
const Operator* Uint8x16GreaterThan();
|
||||||
const Operator* Uint8x16GreaterThanOrEqual();
|
const Operator* Uint8x16GreaterThanOrEqual();
|
||||||
|
|
||||||
const Operator* Bool8x16And();
|
|
||||||
const Operator* Bool8x16Or();
|
|
||||||
const Operator* Bool8x16Xor();
|
|
||||||
const Operator* Bool8x16Not();
|
|
||||||
const Operator* Bool8x16AnyTrue();
|
|
||||||
const Operator* Bool8x16AllTrue();
|
|
||||||
|
|
||||||
const Operator* Simd128Load();
|
const Operator* Simd128Load();
|
||||||
const Operator* Simd128Load1();
|
const Operator* Simd128Load1();
|
||||||
const Operator* Simd128Load2();
|
const Operator* Simd128Load2();
|
||||||
@ -585,8 +564,28 @@ class V8_EXPORT_PRIVATE MachineOperatorBuilder final
|
|||||||
const Operator* Simd8x16Shuffle();
|
const Operator* Simd8x16Shuffle();
|
||||||
|
|
||||||
const Operator* Simd1x4Zero();
|
const Operator* Simd1x4Zero();
|
||||||
|
const Operator* Simd1x4And();
|
||||||
|
const Operator* Simd1x4Or();
|
||||||
|
const Operator* Simd1x4Xor();
|
||||||
|
const Operator* Simd1x4Not();
|
||||||
|
const Operator* Simd1x4AnyTrue();
|
||||||
|
const Operator* Simd1x4AllTrue();
|
||||||
|
|
||||||
const Operator* Simd1x8Zero();
|
const Operator* Simd1x8Zero();
|
||||||
|
const Operator* Simd1x8And();
|
||||||
|
const Operator* Simd1x8Or();
|
||||||
|
const Operator* Simd1x8Xor();
|
||||||
|
const Operator* Simd1x8Not();
|
||||||
|
const Operator* Simd1x8AnyTrue();
|
||||||
|
const Operator* Simd1x8AllTrue();
|
||||||
|
|
||||||
const Operator* Simd1x16Zero();
|
const Operator* Simd1x16Zero();
|
||||||
|
const Operator* Simd1x16And();
|
||||||
|
const Operator* Simd1x16Or();
|
||||||
|
const Operator* Simd1x16Xor();
|
||||||
|
const Operator* Simd1x16Not();
|
||||||
|
const Operator* Simd1x16AnyTrue();
|
||||||
|
const Operator* Simd1x16AllTrue();
|
||||||
|
|
||||||
// load [base + index]
|
// load [base + index]
|
||||||
const Operator* Load(LoadRepresentation rep);
|
const Operator* Load(LoadRepresentation rep);
|
||||||
|
@ -552,171 +552,159 @@
|
|||||||
V(AtomicStore) \
|
V(AtomicStore) \
|
||||||
V(UnsafePointerAdd)
|
V(UnsafePointerAdd)
|
||||||
|
|
||||||
#define MACHINE_SIMD_RETURN_SIMD_OP_LIST(V) \
|
#define MACHINE_SIMD_OP_LIST(V) \
|
||||||
V(Float32x4Splat) \
|
V(Float32x4Splat) \
|
||||||
V(Float32x4ReplaceLane) \
|
V(Float32x4ExtractLane) \
|
||||||
V(Float32x4Abs) \
|
V(Float32x4ReplaceLane) \
|
||||||
V(Float32x4Neg) \
|
V(Float32x4Abs) \
|
||||||
V(Float32x4Sqrt) \
|
V(Float32x4Neg) \
|
||||||
V(Float32x4RecipApprox) \
|
V(Float32x4Sqrt) \
|
||||||
V(Float32x4RecipSqrtApprox) \
|
V(Float32x4RecipApprox) \
|
||||||
V(Float32x4Add) \
|
V(Float32x4RecipSqrtApprox) \
|
||||||
V(Float32x4Sub) \
|
V(Float32x4Add) \
|
||||||
V(Float32x4Mul) \
|
V(Float32x4Sub) \
|
||||||
V(Float32x4Div) \
|
V(Float32x4Mul) \
|
||||||
V(Float32x4Min) \
|
V(Float32x4Div) \
|
||||||
V(Float32x4Max) \
|
V(Float32x4Min) \
|
||||||
V(Float32x4MinNum) \
|
V(Float32x4Max) \
|
||||||
V(Float32x4MaxNum) \
|
V(Float32x4MinNum) \
|
||||||
V(Float32x4Equal) \
|
V(Float32x4MaxNum) \
|
||||||
V(Float32x4NotEqual) \
|
V(Float32x4Equal) \
|
||||||
V(Float32x4LessThan) \
|
V(Float32x4NotEqual) \
|
||||||
V(Float32x4LessThanOrEqual) \
|
V(Float32x4LessThan) \
|
||||||
V(Float32x4GreaterThan) \
|
V(Float32x4LessThanOrEqual) \
|
||||||
V(Float32x4GreaterThanOrEqual) \
|
V(Float32x4GreaterThan) \
|
||||||
V(Float32x4FromInt32x4) \
|
V(Float32x4GreaterThanOrEqual) \
|
||||||
V(Float32x4FromUint32x4) \
|
V(Float32x4FromInt32x4) \
|
||||||
V(Int32x4Splat) \
|
V(Float32x4FromUint32x4) \
|
||||||
V(Int32x4ReplaceLane) \
|
V(Int32x4Splat) \
|
||||||
V(Int32x4Neg) \
|
V(Int32x4ExtractLane) \
|
||||||
V(Int32x4Add) \
|
V(Int32x4ReplaceLane) \
|
||||||
V(Int32x4Sub) \
|
V(Int32x4Neg) \
|
||||||
V(Int32x4Mul) \
|
V(Int32x4Add) \
|
||||||
V(Int32x4Min) \
|
V(Int32x4Sub) \
|
||||||
V(Int32x4Max) \
|
V(Int32x4Mul) \
|
||||||
V(Int32x4ShiftLeftByScalar) \
|
V(Int32x4Min) \
|
||||||
V(Int32x4ShiftRightByScalar) \
|
V(Int32x4Max) \
|
||||||
V(Int32x4Equal) \
|
V(Int32x4ShiftLeftByScalar) \
|
||||||
V(Int32x4NotEqual) \
|
V(Int32x4ShiftRightByScalar) \
|
||||||
V(Int32x4LessThan) \
|
V(Int32x4Equal) \
|
||||||
V(Int32x4LessThanOrEqual) \
|
V(Int32x4NotEqual) \
|
||||||
V(Int32x4GreaterThan) \
|
V(Int32x4LessThan) \
|
||||||
V(Int32x4GreaterThanOrEqual) \
|
V(Int32x4LessThanOrEqual) \
|
||||||
V(Int32x4FromFloat32x4) \
|
V(Int32x4GreaterThan) \
|
||||||
V(Uint32x4Min) \
|
V(Int32x4GreaterThanOrEqual) \
|
||||||
V(Uint32x4Max) \
|
V(Int32x4FromFloat32x4) \
|
||||||
V(Uint32x4ShiftLeftByScalar) \
|
V(Uint32x4Min) \
|
||||||
V(Uint32x4ShiftRightByScalar) \
|
V(Uint32x4Max) \
|
||||||
V(Uint32x4LessThan) \
|
V(Uint32x4ShiftLeftByScalar) \
|
||||||
V(Uint32x4LessThanOrEqual) \
|
V(Uint32x4ShiftRightByScalar) \
|
||||||
V(Uint32x4GreaterThan) \
|
V(Uint32x4LessThan) \
|
||||||
V(Uint32x4GreaterThanOrEqual) \
|
V(Uint32x4LessThanOrEqual) \
|
||||||
V(Uint32x4FromFloat32x4) \
|
V(Uint32x4GreaterThan) \
|
||||||
V(Bool32x4And) \
|
V(Uint32x4GreaterThanOrEqual) \
|
||||||
V(Bool32x4Or) \
|
V(Uint32x4FromFloat32x4) \
|
||||||
V(Bool32x4Xor) \
|
V(Int16x8Splat) \
|
||||||
V(Bool32x4Not) \
|
V(Int16x8ExtractLane) \
|
||||||
V(Int16x8Splat) \
|
V(Int16x8ReplaceLane) \
|
||||||
V(Int16x8ReplaceLane) \
|
V(Int16x8Neg) \
|
||||||
V(Int16x8Neg) \
|
V(Int16x8Add) \
|
||||||
V(Int16x8Add) \
|
V(Int16x8AddSaturate) \
|
||||||
V(Int16x8AddSaturate) \
|
V(Int16x8Sub) \
|
||||||
V(Int16x8Sub) \
|
V(Int16x8SubSaturate) \
|
||||||
V(Int16x8SubSaturate) \
|
V(Int16x8Mul) \
|
||||||
V(Int16x8Mul) \
|
V(Int16x8Min) \
|
||||||
V(Int16x8Min) \
|
V(Int16x8Max) \
|
||||||
V(Int16x8Max) \
|
V(Int16x8ShiftLeftByScalar) \
|
||||||
V(Int16x8ShiftLeftByScalar) \
|
V(Int16x8ShiftRightByScalar) \
|
||||||
V(Int16x8ShiftRightByScalar) \
|
V(Int16x8Equal) \
|
||||||
V(Int16x8Equal) \
|
V(Int16x8NotEqual) \
|
||||||
V(Int16x8NotEqual) \
|
V(Int16x8LessThan) \
|
||||||
V(Int16x8LessThan) \
|
V(Int16x8LessThanOrEqual) \
|
||||||
V(Int16x8LessThanOrEqual) \
|
V(Int16x8GreaterThan) \
|
||||||
V(Int16x8GreaterThan) \
|
V(Int16x8GreaterThanOrEqual) \
|
||||||
V(Int16x8GreaterThanOrEqual) \
|
V(Uint16x8AddSaturate) \
|
||||||
V(Uint16x8AddSaturate) \
|
V(Uint16x8SubSaturate) \
|
||||||
V(Uint16x8SubSaturate) \
|
V(Uint16x8Min) \
|
||||||
V(Uint16x8Min) \
|
V(Uint16x8Max) \
|
||||||
V(Uint16x8Max) \
|
V(Uint16x8ShiftLeftByScalar) \
|
||||||
V(Uint16x8ShiftLeftByScalar) \
|
V(Uint16x8ShiftRightByScalar) \
|
||||||
V(Uint16x8ShiftRightByScalar) \
|
V(Uint16x8LessThan) \
|
||||||
V(Uint16x8LessThan) \
|
V(Uint16x8LessThanOrEqual) \
|
||||||
V(Uint16x8LessThanOrEqual) \
|
V(Uint16x8GreaterThan) \
|
||||||
V(Uint16x8GreaterThan) \
|
V(Uint16x8GreaterThanOrEqual) \
|
||||||
V(Uint16x8GreaterThanOrEqual) \
|
V(Int8x16Splat) \
|
||||||
V(Bool16x8And) \
|
V(Int8x16ExtractLane) \
|
||||||
V(Bool16x8Or) \
|
V(Int8x16ReplaceLane) \
|
||||||
V(Bool16x8Xor) \
|
V(Int8x16Neg) \
|
||||||
V(Bool16x8Not) \
|
V(Int8x16Add) \
|
||||||
V(Int8x16Splat) \
|
V(Int8x16AddSaturate) \
|
||||||
V(Int8x16ReplaceLane) \
|
V(Int8x16Sub) \
|
||||||
V(Int8x16Neg) \
|
V(Int8x16SubSaturate) \
|
||||||
V(Int8x16Add) \
|
V(Int8x16Mul) \
|
||||||
V(Int8x16AddSaturate) \
|
V(Int8x16Min) \
|
||||||
V(Int8x16Sub) \
|
V(Int8x16Max) \
|
||||||
V(Int8x16SubSaturate) \
|
V(Int8x16ShiftLeftByScalar) \
|
||||||
V(Int8x16Mul) \
|
V(Int8x16ShiftRightByScalar) \
|
||||||
V(Int8x16Min) \
|
V(Int8x16Equal) \
|
||||||
V(Int8x16Max) \
|
V(Int8x16NotEqual) \
|
||||||
V(Int8x16ShiftLeftByScalar) \
|
V(Int8x16LessThan) \
|
||||||
V(Int8x16ShiftRightByScalar) \
|
V(Int8x16LessThanOrEqual) \
|
||||||
V(Int8x16Equal) \
|
V(Int8x16GreaterThan) \
|
||||||
V(Int8x16NotEqual) \
|
V(Int8x16GreaterThanOrEqual) \
|
||||||
V(Int8x16LessThan) \
|
V(Uint8x16AddSaturate) \
|
||||||
V(Int8x16LessThanOrEqual) \
|
V(Uint8x16SubSaturate) \
|
||||||
V(Int8x16GreaterThan) \
|
V(Uint8x16Min) \
|
||||||
V(Int8x16GreaterThanOrEqual) \
|
V(Uint8x16Max) \
|
||||||
V(Uint8x16AddSaturate) \
|
V(Uint8x16ShiftLeftByScalar) \
|
||||||
V(Uint8x16SubSaturate) \
|
V(Uint8x16ShiftRightByScalar) \
|
||||||
V(Uint8x16Min) \
|
V(Uint8x16LessThan) \
|
||||||
V(Uint8x16Max) \
|
V(Uint8x16LessThanOrEqual) \
|
||||||
V(Uint8x16ShiftLeftByScalar) \
|
V(Uint8x16GreaterThan) \
|
||||||
V(Uint8x16ShiftRightByScalar) \
|
V(Uint8x16GreaterThanOrEqual) \
|
||||||
V(Uint8x16LessThan) \
|
V(Simd128Load) \
|
||||||
V(Uint8x16LessThanOrEqual) \
|
V(Simd128Load1) \
|
||||||
V(Uint8x16GreaterThan) \
|
V(Simd128Load2) \
|
||||||
V(Uint8x16GreaterThanOrEqual) \
|
V(Simd128Load3) \
|
||||||
V(Bool8x16And) \
|
V(Simd128Store) \
|
||||||
V(Bool8x16Or) \
|
V(Simd128Store1) \
|
||||||
V(Bool8x16Xor) \
|
V(Simd128Store2) \
|
||||||
V(Bool8x16Not) \
|
V(Simd128Store3) \
|
||||||
V(Simd128Zero) \
|
V(Simd128Zero) \
|
||||||
V(Simd128And) \
|
V(Simd128And) \
|
||||||
V(Simd128Or) \
|
V(Simd128Or) \
|
||||||
V(Simd128Xor) \
|
V(Simd128Xor) \
|
||||||
V(Simd128Not) \
|
V(Simd128Not) \
|
||||||
V(Simd32x4Select) \
|
V(Simd32x4Select) \
|
||||||
V(Simd32x4Swizzle) \
|
V(Simd32x4Swizzle) \
|
||||||
V(Simd32x4Shuffle) \
|
V(Simd32x4Shuffle) \
|
||||||
V(Simd16x8Select) \
|
V(Simd16x8Select) \
|
||||||
V(Simd16x8Swizzle) \
|
V(Simd16x8Swizzle) \
|
||||||
V(Simd16x8Shuffle) \
|
V(Simd16x8Shuffle) \
|
||||||
V(Simd8x16Select) \
|
V(Simd8x16Select) \
|
||||||
V(Simd8x16Swizzle) \
|
V(Simd8x16Swizzle) \
|
||||||
V(Simd8x16Shuffle) \
|
V(Simd8x16Shuffle) \
|
||||||
V(Simd1x4Zero) \
|
V(Simd1x4Zero) \
|
||||||
V(Simd1x8Zero) \
|
V(Simd1x4And) \
|
||||||
V(Simd1x16Zero)
|
V(Simd1x4Or) \
|
||||||
|
V(Simd1x4Xor) \
|
||||||
#define MACHINE_SIMD_RETURN_NUM_OP_LIST(V) \
|
V(Simd1x4Not) \
|
||||||
V(Float32x4ExtractLane) \
|
V(Simd1x4AnyTrue) \
|
||||||
V(Int32x4ExtractLane) \
|
V(Simd1x4AllTrue) \
|
||||||
V(Int16x8ExtractLane) \
|
V(Simd1x8Zero) \
|
||||||
V(Int8x16ExtractLane)
|
V(Simd1x8And) \
|
||||||
|
V(Simd1x8Or) \
|
||||||
#define MACHINE_SIMD_RETURN_BOOL_OP_LIST(V) \
|
V(Simd1x8Xor) \
|
||||||
V(Bool32x4AnyTrue) \
|
V(Simd1x8Not) \
|
||||||
V(Bool32x4AllTrue) \
|
V(Simd1x8AnyTrue) \
|
||||||
V(Bool16x8AnyTrue) \
|
V(Simd1x8AllTrue) \
|
||||||
V(Bool16x8AllTrue) \
|
V(Simd1x16Zero) \
|
||||||
V(Bool8x16AnyTrue) \
|
V(Simd1x16And) \
|
||||||
V(Bool8x16AllTrue)
|
V(Simd1x16Or) \
|
||||||
|
V(Simd1x16Xor) \
|
||||||
#define MACHINE_SIMD_GENERIC_OP_LIST(V) \
|
V(Simd1x16Not) \
|
||||||
V(Simd128Load) \
|
V(Simd1x16AnyTrue) \
|
||||||
V(Simd128Load1) \
|
V(Simd1x16AllTrue)
|
||||||
V(Simd128Load2) \
|
|
||||||
V(Simd128Load3) \
|
|
||||||
V(Simd128Store) \
|
|
||||||
V(Simd128Store1) \
|
|
||||||
V(Simd128Store2) \
|
|
||||||
V(Simd128Store3)
|
|
||||||
|
|
||||||
#define MACHINE_SIMD_OP_LIST(V) \
|
|
||||||
MACHINE_SIMD_RETURN_SIMD_OP_LIST(V) \
|
|
||||||
MACHINE_SIMD_RETURN_NUM_OP_LIST(V) \
|
|
||||||
MACHINE_SIMD_RETURN_BOOL_OP_LIST(V) \
|
|
||||||
MACHINE_SIMD_GENERIC_OP_LIST(V)
|
|
||||||
|
|
||||||
#define VALUE_OP_LIST(V) \
|
#define VALUE_OP_LIST(V) \
|
||||||
COMMON_OP_LIST(V) \
|
COMMON_OP_LIST(V) \
|
||||||
|
@ -3611,15 +3611,6 @@ Node* WasmGraphBuilder::SimdOp(wasm::WasmOpcode opcode,
|
|||||||
return graph()->NewNode(
|
return graph()->NewNode(
|
||||||
jsgraph()->machine()->Uint8x16GreaterThanOrEqual(), inputs[0],
|
jsgraph()->machine()->Uint8x16GreaterThanOrEqual(), inputs[0],
|
||||||
inputs[1]);
|
inputs[1]);
|
||||||
case wasm::kExprS32x4Select:
|
|
||||||
return graph()->NewNode(jsgraph()->machine()->Simd32x4Select(), inputs[0],
|
|
||||||
inputs[1], inputs[2]);
|
|
||||||
case wasm::kExprS16x8Select:
|
|
||||||
return graph()->NewNode(jsgraph()->machine()->Simd16x8Select(), inputs[0],
|
|
||||||
inputs[1], inputs[2]);
|
|
||||||
case wasm::kExprS8x16Select:
|
|
||||||
return graph()->NewNode(jsgraph()->machine()->Simd8x16Select(), inputs[0],
|
|
||||||
inputs[1], inputs[2]);
|
|
||||||
case wasm::kExprS128And:
|
case wasm::kExprS128And:
|
||||||
return graph()->NewNode(jsgraph()->machine()->Simd128And(), inputs[0],
|
return graph()->NewNode(jsgraph()->machine()->Simd128And(), inputs[0],
|
||||||
inputs[1]);
|
inputs[1]);
|
||||||
@ -3631,6 +3622,66 @@ Node* WasmGraphBuilder::SimdOp(wasm::WasmOpcode opcode,
|
|||||||
inputs[1]);
|
inputs[1]);
|
||||||
case wasm::kExprS128Not:
|
case wasm::kExprS128Not:
|
||||||
return graph()->NewNode(jsgraph()->machine()->Simd128Not(), inputs[0]);
|
return graph()->NewNode(jsgraph()->machine()->Simd128Not(), inputs[0]);
|
||||||
|
case wasm::kExprS32x4Select:
|
||||||
|
return graph()->NewNode(jsgraph()->machine()->Simd32x4Select(), inputs[0],
|
||||||
|
inputs[1], inputs[2]);
|
||||||
|
case wasm::kExprS16x8Select:
|
||||||
|
return graph()->NewNode(jsgraph()->machine()->Simd16x8Select(), inputs[0],
|
||||||
|
inputs[1], inputs[2]);
|
||||||
|
case wasm::kExprS8x16Select:
|
||||||
|
return graph()->NewNode(jsgraph()->machine()->Simd8x16Select(), inputs[0],
|
||||||
|
inputs[1], inputs[2]);
|
||||||
|
case wasm::kExprS1x4And:
|
||||||
|
return graph()->NewNode(jsgraph()->machine()->Simd1x4And(), inputs[0],
|
||||||
|
inputs[1]);
|
||||||
|
case wasm::kExprS1x4Or:
|
||||||
|
return graph()->NewNode(jsgraph()->machine()->Simd1x4Or(), inputs[0],
|
||||||
|
inputs[1]);
|
||||||
|
case wasm::kExprS1x4Xor:
|
||||||
|
return graph()->NewNode(jsgraph()->machine()->Simd1x4Xor(), inputs[0],
|
||||||
|
inputs[1]);
|
||||||
|
case wasm::kExprS1x4Not:
|
||||||
|
return graph()->NewNode(jsgraph()->machine()->Simd1x4Not(), inputs[0]);
|
||||||
|
case wasm::kExprS1x4AnyTrue:
|
||||||
|
return graph()->NewNode(jsgraph()->machine()->Simd1x4AnyTrue(),
|
||||||
|
inputs[0]);
|
||||||
|
case wasm::kExprS1x4AllTrue:
|
||||||
|
return graph()->NewNode(jsgraph()->machine()->Simd1x4AllTrue(),
|
||||||
|
inputs[0]);
|
||||||
|
case wasm::kExprS1x8And:
|
||||||
|
return graph()->NewNode(jsgraph()->machine()->Simd1x8And(), inputs[0],
|
||||||
|
inputs[1]);
|
||||||
|
case wasm::kExprS1x8Or:
|
||||||
|
return graph()->NewNode(jsgraph()->machine()->Simd1x8Or(), inputs[0],
|
||||||
|
inputs[1]);
|
||||||
|
case wasm::kExprS1x8Xor:
|
||||||
|
return graph()->NewNode(jsgraph()->machine()->Simd1x8Xor(), inputs[0],
|
||||||
|
inputs[1]);
|
||||||
|
case wasm::kExprS1x8Not:
|
||||||
|
return graph()->NewNode(jsgraph()->machine()->Simd1x8Not(), inputs[0]);
|
||||||
|
case wasm::kExprS1x8AnyTrue:
|
||||||
|
return graph()->NewNode(jsgraph()->machine()->Simd1x8AnyTrue(),
|
||||||
|
inputs[0]);
|
||||||
|
case wasm::kExprS1x8AllTrue:
|
||||||
|
return graph()->NewNode(jsgraph()->machine()->Simd1x8AllTrue(),
|
||||||
|
inputs[0]);
|
||||||
|
case wasm::kExprS1x16And:
|
||||||
|
return graph()->NewNode(jsgraph()->machine()->Simd1x16And(), inputs[0],
|
||||||
|
inputs[1]);
|
||||||
|
case wasm::kExprS1x16Or:
|
||||||
|
return graph()->NewNode(jsgraph()->machine()->Simd1x16Or(), inputs[0],
|
||||||
|
inputs[1]);
|
||||||
|
case wasm::kExprS1x16Xor:
|
||||||
|
return graph()->NewNode(jsgraph()->machine()->Simd1x16Xor(), inputs[0],
|
||||||
|
inputs[1]);
|
||||||
|
case wasm::kExprS1x16Not:
|
||||||
|
return graph()->NewNode(jsgraph()->machine()->Simd1x16Not(), inputs[0]);
|
||||||
|
case wasm::kExprS1x16AnyTrue:
|
||||||
|
return graph()->NewNode(jsgraph()->machine()->Simd1x16AnyTrue(),
|
||||||
|
inputs[0]);
|
||||||
|
case wasm::kExprS1x16AllTrue:
|
||||||
|
return graph()->NewNode(jsgraph()->machine()->Simd1x16AllTrue(),
|
||||||
|
inputs[0]);
|
||||||
default:
|
default:
|
||||||
return graph()->NewNode(UnsupportedOpcode(opcode), nullptr);
|
return graph()->NewNode(UnsupportedOpcode(opcode), nullptr);
|
||||||
}
|
}
|
||||||
|
@ -20,14 +20,17 @@ typedef Signature<ValueType> FunctionSig;
|
|||||||
#define CASE_I64_OP(name, str) CASE_OP(I64##name, "i64." str)
|
#define CASE_I64_OP(name, str) CASE_OP(I64##name, "i64." str)
|
||||||
#define CASE_F32_OP(name, str) CASE_OP(F32##name, "f32." str)
|
#define CASE_F32_OP(name, str) CASE_OP(F32##name, "f32." str)
|
||||||
#define CASE_F64_OP(name, str) CASE_OP(F64##name, "f64." str)
|
#define CASE_F64_OP(name, str) CASE_OP(F64##name, "f64." str)
|
||||||
#define CASE_S128_OP(name, str) CASE_OP(S128##name, "s128." str)
|
|
||||||
#define CASE_F32x4_OP(name, str) CASE_OP(F32x4##name, "f32x4." str)
|
#define CASE_F32x4_OP(name, str) CASE_OP(F32x4##name, "f32x4." str)
|
||||||
#define CASE_I32x4_OP(name, str) CASE_OP(I32x4##name, "i32x4." str)
|
#define CASE_I32x4_OP(name, str) CASE_OP(I32x4##name, "i32x4." str)
|
||||||
#define CASE_I16x8_OP(name, str) CASE_OP(I16x8##name, "i16x8." str)
|
#define CASE_I16x8_OP(name, str) CASE_OP(I16x8##name, "i16x8." str)
|
||||||
#define CASE_I8x16_OP(name, str) CASE_OP(I8x16##name, "i8x16." str)
|
#define CASE_I8x16_OP(name, str) CASE_OP(I8x16##name, "i8x16." str)
|
||||||
|
#define CASE_S128_OP(name, str) CASE_OP(S128##name, "s128." str)
|
||||||
#define CASE_S32x4_OP(name, str) CASE_OP(S32x4##name, "s32x4." str)
|
#define CASE_S32x4_OP(name, str) CASE_OP(S32x4##name, "s32x4." str)
|
||||||
#define CASE_S16x8_OP(name, str) CASE_OP(S16x8##name, "s16x8." str)
|
#define CASE_S16x8_OP(name, str) CASE_OP(S16x8##name, "s16x8." str)
|
||||||
#define CASE_S8x16_OP(name, str) CASE_OP(S8x16##name, "s8x16." str)
|
#define CASE_S8x16_OP(name, str) CASE_OP(S8x16##name, "s8x16." str)
|
||||||
|
#define CASE_S1x4_OP(name, str) CASE_OP(S1x4##name, "s1x4." str)
|
||||||
|
#define CASE_S1x8_OP(name, str) CASE_OP(S1x8##name, "s1x8." str)
|
||||||
|
#define CASE_S1x16_OP(name, str) CASE_OP(S1x16##name, "s1x16." str)
|
||||||
#define CASE_INT_OP(name, str) CASE_I32_OP(name, str) CASE_I64_OP(name, str)
|
#define CASE_INT_OP(name, str) CASE_I32_OP(name, str) CASE_I64_OP(name, str)
|
||||||
#define CASE_FLOAT_OP(name, str) CASE_F32_OP(name, str) CASE_F64_OP(name, str)
|
#define CASE_FLOAT_OP(name, str) CASE_F32_OP(name, str) CASE_F64_OP(name, str)
|
||||||
#define CASE_ALL_OP(name, str) CASE_FLOAT_OP(name, str) CASE_INT_OP(name, str)
|
#define CASE_ALL_OP(name, str) CASE_FLOAT_OP(name, str) CASE_INT_OP(name, str)
|
||||||
@ -202,9 +205,9 @@ const char* WasmOpcodes::OpcodeName(WasmOpcode opcode) {
|
|||||||
CASE_SIGN_OP(I8x16, AddSaturate, "add_saturate")
|
CASE_SIGN_OP(I8x16, AddSaturate, "add_saturate")
|
||||||
CASE_SIGN_OP(I16x8, SubSaturate, "sub_saturate")
|
CASE_SIGN_OP(I16x8, SubSaturate, "sub_saturate")
|
||||||
CASE_SIGN_OP(I8x16, SubSaturate, "sub_saturate")
|
CASE_SIGN_OP(I8x16, SubSaturate, "sub_saturate")
|
||||||
|
CASE_S128_OP(And, "and")
|
||||||
CASE_S128_OP(Or, "or")
|
CASE_S128_OP(Or, "or")
|
||||||
CASE_S128_OP(Xor, "xor")
|
CASE_S128_OP(Xor, "xor")
|
||||||
CASE_S128_OP(And, "and")
|
|
||||||
CASE_S128_OP(Not, "not")
|
CASE_S128_OP(Not, "not")
|
||||||
CASE_S32x4_OP(Select, "select")
|
CASE_S32x4_OP(Select, "select")
|
||||||
CASE_S32x4_OP(Swizzle, "swizzle")
|
CASE_S32x4_OP(Swizzle, "swizzle")
|
||||||
@ -215,6 +218,24 @@ const char* WasmOpcodes::OpcodeName(WasmOpcode opcode) {
|
|||||||
CASE_S8x16_OP(Select, "select")
|
CASE_S8x16_OP(Select, "select")
|
||||||
CASE_S8x16_OP(Swizzle, "swizzle")
|
CASE_S8x16_OP(Swizzle, "swizzle")
|
||||||
CASE_S8x16_OP(Shuffle, "shuffle")
|
CASE_S8x16_OP(Shuffle, "shuffle")
|
||||||
|
CASE_S1x4_OP(And, "and")
|
||||||
|
CASE_S1x4_OP(Or, "or")
|
||||||
|
CASE_S1x4_OP(Xor, "xor")
|
||||||
|
CASE_S1x4_OP(Not, "not")
|
||||||
|
CASE_S1x4_OP(AnyTrue, "any_true")
|
||||||
|
CASE_S1x4_OP(AllTrue, "all_true")
|
||||||
|
CASE_S1x8_OP(And, "and")
|
||||||
|
CASE_S1x8_OP(Or, "or")
|
||||||
|
CASE_S1x8_OP(Xor, "xor")
|
||||||
|
CASE_S1x8_OP(Not, "not")
|
||||||
|
CASE_S1x8_OP(AnyTrue, "any_true")
|
||||||
|
CASE_S1x8_OP(AllTrue, "all_true")
|
||||||
|
CASE_S1x16_OP(And, "and")
|
||||||
|
CASE_S1x16_OP(Or, "or")
|
||||||
|
CASE_S1x16_OP(Xor, "xor")
|
||||||
|
CASE_S1x16_OP(Not, "not")
|
||||||
|
CASE_S1x16_OP(AnyTrue, "any_true")
|
||||||
|
CASE_S1x16_OP(AllTrue, "all_true")
|
||||||
|
|
||||||
// Atomic operations.
|
// Atomic operations.
|
||||||
CASE_L32_OP(AtomicAdd, "atomic_add")
|
CASE_L32_OP(AtomicAdd, "atomic_add")
|
||||||
|
@ -381,7 +381,25 @@ constexpr WasmCodePosition kNoCodePosition = -1;
|
|||||||
V(S16x8Shuffle, 0xe54d, s_ss) \
|
V(S16x8Shuffle, 0xe54d, s_ss) \
|
||||||
V(S8x16Select, 0xe56a, s_s1x16ss) \
|
V(S8x16Select, 0xe56a, s_s1x16ss) \
|
||||||
V(S8x16Swizzle, 0xe56b, s_s) \
|
V(S8x16Swizzle, 0xe56b, s_s) \
|
||||||
V(S8x16Shuffle, 0xe56c, s_ss)
|
V(S8x16Shuffle, 0xe56c, s_ss) \
|
||||||
|
V(S1x4And, 0xe580, s1x4_s1x4s1x4) \
|
||||||
|
V(S1x4Or, 0xe581, s1x4_s1x4s1x4) \
|
||||||
|
V(S1x4Xor, 0xe582, s1x4_s1x4s1x4) \
|
||||||
|
V(S1x4Not, 0xe583, s1x4_s1x4) \
|
||||||
|
V(S1x4AnyTrue, 0xe584, i_s1x4) \
|
||||||
|
V(S1x4AllTrue, 0xe585, i_s1x4) \
|
||||||
|
V(S1x8And, 0xe586, s1x8_s1x8s1x8) \
|
||||||
|
V(S1x8Or, 0xe587, s1x8_s1x8s1x8) \
|
||||||
|
V(S1x8Xor, 0xe588, s1x8_s1x8s1x8) \
|
||||||
|
V(S1x8Not, 0xe589, s1x8_s1x8) \
|
||||||
|
V(S1x8AnyTrue, 0xe58a, i_s1x8) \
|
||||||
|
V(S1x8AllTrue, 0xe58b, i_s1x8) \
|
||||||
|
V(S1x16And, 0xe58c, s1x16_s1x16s1x16) \
|
||||||
|
V(S1x16Or, 0xe58d, s1x16_s1x16s1x16) \
|
||||||
|
V(S1x16Xor, 0xe58e, s1x16_s1x16s1x16) \
|
||||||
|
V(S1x16Not, 0xe58f, s1x16_s1x16) \
|
||||||
|
V(S1x16AnyTrue, 0xe590, i_s1x16) \
|
||||||
|
V(S1x16AllTrue, 0xe591, i_s1x16)
|
||||||
|
|
||||||
#define FOREACH_SIMD_1_OPERAND_OPCODE(V) \
|
#define FOREACH_SIMD_1_OPERAND_OPCODE(V) \
|
||||||
V(F32x4ExtractLane, 0xe501, _) \
|
V(F32x4ExtractLane, 0xe501, _) \
|
||||||
@ -483,19 +501,28 @@ constexpr WasmCodePosition kNoCodePosition = -1;
|
|||||||
V(f_if, kWasmF32, kWasmI32, kWasmF32) \
|
V(f_if, kWasmF32, kWasmI32, kWasmF32) \
|
||||||
V(l_il, kWasmI64, kWasmI32, kWasmI64)
|
V(l_il, kWasmI64, kWasmI32, kWasmI64)
|
||||||
|
|
||||||
#define FOREACH_SIMD_SIGNATURE(V) \
|
#define FOREACH_SIMD_SIGNATURE(V) \
|
||||||
V(s_s, kWasmS128, kWasmS128) \
|
V(s_s, kWasmS128, kWasmS128) \
|
||||||
V(s_f, kWasmS128, kWasmF32) \
|
V(s_f, kWasmS128, kWasmF32) \
|
||||||
V(s_ss, kWasmS128, kWasmS128, kWasmS128) \
|
V(s_ss, kWasmS128, kWasmS128, kWasmS128) \
|
||||||
V(s1x4_ss, kWasmS1x4, kWasmS128, kWasmS128) \
|
V(s1x4_ss, kWasmS1x4, kWasmS128, kWasmS128) \
|
||||||
V(s1x8_ss, kWasmS1x8, kWasmS128, kWasmS128) \
|
V(s1x8_ss, kWasmS1x8, kWasmS128, kWasmS128) \
|
||||||
V(s1x16_ss, kWasmS1x16, kWasmS128, kWasmS128) \
|
V(s1x16_ss, kWasmS1x16, kWasmS128, kWasmS128) \
|
||||||
V(s_i, kWasmS128, kWasmI32) \
|
V(s_i, kWasmS128, kWasmI32) \
|
||||||
V(s_si, kWasmS128, kWasmS128, kWasmI32) \
|
V(s_si, kWasmS128, kWasmS128, kWasmI32) \
|
||||||
V(i_s, kWasmI32, kWasmS128) \
|
V(i_s, kWasmI32, kWasmS128) \
|
||||||
V(s_s1x4ss, kWasmS128, kWasmS1x4, kWasmS128, kWasmS128) \
|
V(i_s1x4, kWasmI32, kWasmS1x4) \
|
||||||
V(s_s1x8ss, kWasmS128, kWasmS1x8, kWasmS128, kWasmS128) \
|
V(i_s1x8, kWasmI32, kWasmS1x8) \
|
||||||
V(s_s1x16ss, kWasmS128, kWasmS1x16, kWasmS128, kWasmS128)
|
V(i_s1x16, kWasmI32, kWasmS1x16) \
|
||||||
|
V(s_s1x4ss, kWasmS128, kWasmS1x4, kWasmS128, kWasmS128) \
|
||||||
|
V(s_s1x8ss, kWasmS128, kWasmS1x8, kWasmS128, kWasmS128) \
|
||||||
|
V(s_s1x16ss, kWasmS128, kWasmS1x16, kWasmS128, kWasmS128) \
|
||||||
|
V(s1x4_s1x4, kWasmS1x4, kWasmS1x4) \
|
||||||
|
V(s1x4_s1x4s1x4, kWasmS1x4, kWasmS1x4, kWasmS1x4) \
|
||||||
|
V(s1x8_s1x8, kWasmS1x8, kWasmS1x8) \
|
||||||
|
V(s1x8_s1x8s1x8, kWasmS1x8, kWasmS1x8, kWasmS1x8) \
|
||||||
|
V(s1x16_s1x16, kWasmS1x16, kWasmS1x16) \
|
||||||
|
V(s1x16_s1x16s1x16, kWasmS1x16, kWasmS1x16, kWasmS1x16)
|
||||||
|
|
||||||
#define FOREACH_PREFIX(V) \
|
#define FOREACH_PREFIX(V) \
|
||||||
V(Simd, 0xe5) \
|
V(Simd, 0xe5) \
|
||||||
|
@ -1227,6 +1227,10 @@ TEST(14) {
|
|||||||
CHECK_EQ(ex, t.field[2]); \
|
CHECK_EQ(ex, t.field[2]); \
|
||||||
CHECK_EQ(ex, t.field[3]);
|
CHECK_EQ(ex, t.field[3]);
|
||||||
|
|
||||||
|
#define CHECK_EQ_32X2(field, ex0, ex1) \
|
||||||
|
CHECK_EQ(ex0, t.field[0]); \
|
||||||
|
CHECK_EQ(ex1, t.field[1]);
|
||||||
|
|
||||||
#define CHECK_EQ_32X4(field, ex0, ex1, ex2, ex3) \
|
#define CHECK_EQ_32X4(field, ex0, ex1, ex2, ex3) \
|
||||||
CHECK_EQ(ex0, t.field[0]); \
|
CHECK_EQ(ex0, t.field[0]); \
|
||||||
CHECK_EQ(ex1, t.field[1]); \
|
CHECK_EQ(ex1, t.field[1]); \
|
||||||
@ -1298,6 +1302,8 @@ TEST(15) {
|
|||||||
float vdupf[4], vaddf[4], vsubf[4], vmulf[4];
|
float vdupf[4], vaddf[4], vsubf[4], vmulf[4];
|
||||||
uint32_t vmin_s8[4], vmin_u16[4], vmin_s32[4];
|
uint32_t vmin_s8[4], vmin_u16[4], vmin_s32[4];
|
||||||
uint32_t vmax_s8[4], vmax_u16[4], vmax_s32[4];
|
uint32_t vmax_s8[4], vmax_u16[4], vmax_s32[4];
|
||||||
|
uint32_t vpmin_s8[2], vpmin_u16[2], vpmin_s32[2];
|
||||||
|
uint32_t vpmax_s8[2], vpmax_u16[2], vpmax_s32[2];
|
||||||
uint32_t vadd8[4], vadd16[4], vadd32[4];
|
uint32_t vadd8[4], vadd16[4], vadd32[4];
|
||||||
uint32_t vqadd_s8[4], vqadd_u16[4], vqadd_s32[4];
|
uint32_t vqadd_s8[4], vqadd_u16[4], vqadd_s32[4];
|
||||||
uint32_t vsub8[4], vsub16[4], vsub32[4];
|
uint32_t vsub8[4], vsub16[4], vsub32[4];
|
||||||
@ -1612,6 +1618,30 @@ TEST(15) {
|
|||||||
__ add(r4, r0, Operand(static_cast<int32_t>(offsetof(T, vmax_s32))));
|
__ add(r4, r0, Operand(static_cast<int32_t>(offsetof(T, vmax_s32))));
|
||||||
__ vst1(Neon8, NeonListOperand(q2), NeonMemOperand(r4));
|
__ vst1(Neon8, NeonListOperand(q2), NeonMemOperand(r4));
|
||||||
|
|
||||||
|
// vpmin/vpmax integer.
|
||||||
|
__ mov(r4, Operand(0x03));
|
||||||
|
__ vdup(Neon16, q0, r4);
|
||||||
|
__ vdup(Neon8, q1, r4);
|
||||||
|
__ vpmin(NeonS8, d4, d0, d2);
|
||||||
|
__ vstr(d4, r0, offsetof(T, vpmin_s8));
|
||||||
|
__ vpmax(NeonS8, d4, d0, d2);
|
||||||
|
__ vstr(d4, r0, offsetof(T, vpmax_s8));
|
||||||
|
__ mov(r4, Operand(0xffff));
|
||||||
|
__ vdup(Neon32, q0, r4);
|
||||||
|
__ vdup(Neon16, q1, r4);
|
||||||
|
__ vpmin(NeonU16, d4, d0, d2);
|
||||||
|
__ vstr(d4, r0, offsetof(T, vpmin_u16));
|
||||||
|
__ vpmax(NeonU16, d4, d0, d2);
|
||||||
|
__ vstr(d4, r0, offsetof(T, vpmax_u16));
|
||||||
|
__ mov(r4, Operand(0xff));
|
||||||
|
__ veor(q0, q0, q0);
|
||||||
|
__ vmov(s0, r4);
|
||||||
|
__ vdup(Neon8, q1, r4);
|
||||||
|
__ vpmin(NeonS32, d4, d0, d2);
|
||||||
|
__ vstr(d4, r0, offsetof(T, vpmin_s32));
|
||||||
|
__ vpmax(NeonS32, d4, d0, d2);
|
||||||
|
__ vstr(d4, r0, offsetof(T, vpmax_s32));
|
||||||
|
|
||||||
// vadd (integer).
|
// vadd (integer).
|
||||||
__ mov(r4, Operand(0x81));
|
__ mov(r4, Operand(0x81));
|
||||||
__ vdup(Neon8, q0, r4);
|
__ vdup(Neon8, q0, r4);
|
||||||
@ -1992,6 +2022,15 @@ TEST(15) {
|
|||||||
// [0x000000ff, 0x000000ff, ...] and [0xffffffff, 0xffffffff, ...]
|
// [0x000000ff, 0x000000ff, ...] and [0xffffffff, 0xffffffff, ...]
|
||||||
CHECK_EQ_SPLAT(vmin_s32, 0xffffffffu);
|
CHECK_EQ_SPLAT(vmin_s32, 0xffffffffu);
|
||||||
CHECK_EQ_SPLAT(vmax_s32, 0xffu);
|
CHECK_EQ_SPLAT(vmax_s32, 0xffu);
|
||||||
|
// [0, 3, 0, 3, ...] and [3, 3, 3, 3, ...]
|
||||||
|
CHECK_EQ_32X2(vpmin_s8, 0x00000000u, 0x03030303u);
|
||||||
|
CHECK_EQ_32X2(vpmax_s8, 0x03030303u, 0x03030303u);
|
||||||
|
// [0, ffff, 0, ffff] and [ffff, ffff]
|
||||||
|
CHECK_EQ_32X2(vpmin_u16, 0x00000000u, 0xffffffffu);
|
||||||
|
CHECK_EQ_32X2(vpmax_u16, 0xffffffffu, 0xffffffffu);
|
||||||
|
// [0x000000ff, 0x00000000u] and [0xffffffff, 0xffffffff, ...]
|
||||||
|
CHECK_EQ_32X2(vpmin_s32, 0x00u, 0xffffffffu);
|
||||||
|
CHECK_EQ_32X2(vpmax_s32, 0xffu, 0xffffffffu);
|
||||||
CHECK_EQ_SPLAT(vadd8, 0x03030303u);
|
CHECK_EQ_SPLAT(vadd8, 0x03030303u);
|
||||||
CHECK_EQ_SPLAT(vadd16, 0x00030003u);
|
CHECK_EQ_SPLAT(vadd16, 0x00030003u);
|
||||||
CHECK_EQ_SPLAT(vadd32, 0x00000003u);
|
CHECK_EQ_SPLAT(vadd32, 0x00000003u);
|
||||||
|
@ -1040,6 +1040,12 @@ TEST(Neon) {
|
|||||||
"f3142670 vmin.u16 q1, q2, q8");
|
"f3142670 vmin.u16 q1, q2, q8");
|
||||||
COMPARE(vmax(NeonS32, q15, q0, q8),
|
COMPARE(vmax(NeonS32, q15, q0, q8),
|
||||||
"f260e660 vmax.s32 q15, q0, q8");
|
"f260e660 vmax.s32 q15, q0, q8");
|
||||||
|
COMPARE(vpmax(NeonS8, d0, d1, d2),
|
||||||
|
"f2010a02 vpmax.s8 d0, d1, d2");
|
||||||
|
COMPARE(vpmin(NeonU16, d1, d2, d8),
|
||||||
|
"f3121a18 vpmin.u16 d1, d2, d8");
|
||||||
|
COMPARE(vpmax(NeonS32, d15, d0, d8),
|
||||||
|
"f220fa08 vpmax.s32 d15, d0, d8");
|
||||||
COMPARE(vadd(q15, q0, q8),
|
COMPARE(vadd(q15, q0, q8),
|
||||||
"f240ed60 vadd.f32 q15, q0, q8");
|
"f240ed60 vadd.f32 q15, q0, q8");
|
||||||
COMPARE(vadd(Neon8, q0, q1, q2),
|
COMPARE(vadd(Neon8, q0, q1, q2),
|
||||||
|
@ -156,6 +156,8 @@ TEST(ExtractLane) {
|
|||||||
int32_t i8x16_high[16];
|
int32_t i8x16_high[16];
|
||||||
int32_t f32x4_low[4];
|
int32_t f32x4_low[4];
|
||||||
int32_t f32x4_high[4];
|
int32_t f32x4_high[4];
|
||||||
|
int32_t i8x16_low_d[16];
|
||||||
|
int32_t i8x16_high_d[16];
|
||||||
} T;
|
} T;
|
||||||
T t;
|
T t;
|
||||||
|
|
||||||
@ -185,6 +187,15 @@ TEST(ExtractLane) {
|
|||||||
__ str(r5, MemOperand(r0, offsetof(T, i8x16_low) + 4 * i));
|
__ str(r5, MemOperand(r0, offsetof(T, i8x16_low) + 4 * i));
|
||||||
}
|
}
|
||||||
|
|
||||||
|
for (int i = 0; i < 8; i++) {
|
||||||
|
__ mov(r4, Operand(i));
|
||||||
|
__ vdup(Neon8, q1, r4); // q1 = d2,d3
|
||||||
|
__ ExtractLane(r5, d2, NeonS8, i);
|
||||||
|
__ str(r5, MemOperand(r0, offsetof(T, i8x16_low_d) + 4 * i));
|
||||||
|
__ ExtractLane(r5, d3, NeonS8, i);
|
||||||
|
__ str(r5, MemOperand(r0, offsetof(T, i8x16_low_d) + 4 * (i + 8)));
|
||||||
|
}
|
||||||
|
|
||||||
if (CpuFeatures::IsSupported(VFP32DREGS)) {
|
if (CpuFeatures::IsSupported(VFP32DREGS)) {
|
||||||
for (int i = 0; i < 4; i++) {
|
for (int i = 0; i < 4; i++) {
|
||||||
__ mov(r4, Operand(-i));
|
__ mov(r4, Operand(-i));
|
||||||
@ -209,6 +220,15 @@ TEST(ExtractLane) {
|
|||||||
__ ExtractLane(r5, q15, NeonS8, i);
|
__ ExtractLane(r5, q15, NeonS8, i);
|
||||||
__ str(r5, MemOperand(r0, offsetof(T, i8x16_high) + 4 * i));
|
__ str(r5, MemOperand(r0, offsetof(T, i8x16_high) + 4 * i));
|
||||||
}
|
}
|
||||||
|
|
||||||
|
for (int i = 0; i < 8; i++) {
|
||||||
|
__ mov(r4, Operand(-i));
|
||||||
|
__ vdup(Neon8, q15, r4); // q1 = d30,d31
|
||||||
|
__ ExtractLane(r5, d30, NeonS8, i);
|
||||||
|
__ str(r5, MemOperand(r0, offsetof(T, i8x16_high_d) + 4 * i));
|
||||||
|
__ ExtractLane(r5, d31, NeonS8, i);
|
||||||
|
__ str(r5, MemOperand(r0, offsetof(T, i8x16_high_d) + 4 * (i + 8)));
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
__ ldm(ia_w, sp, r4.bit() | r5.bit() | pc.bit());
|
__ ldm(ia_w, sp, r4.bit() | r5.bit() | pc.bit());
|
||||||
@ -234,6 +254,10 @@ TEST(ExtractLane) {
|
|||||||
for (int i = 0; i < 16; i++) {
|
for (int i = 0; i < 16; i++) {
|
||||||
CHECK_EQ(i, t.i8x16_low[i]);
|
CHECK_EQ(i, t.i8x16_low[i]);
|
||||||
}
|
}
|
||||||
|
for (int i = 0; i < 8; i++) {
|
||||||
|
CHECK_EQ(i, t.i8x16_low_d[i]);
|
||||||
|
CHECK_EQ(i, t.i8x16_low_d[i + 8]);
|
||||||
|
}
|
||||||
if (CpuFeatures::IsSupported(VFP32DREGS)) {
|
if (CpuFeatures::IsSupported(VFP32DREGS)) {
|
||||||
for (int i = 0; i < 4; i++) {
|
for (int i = 0; i < 4; i++) {
|
||||||
CHECK_EQ(-i, t.i32x4_high[i]);
|
CHECK_EQ(-i, t.i32x4_high[i]);
|
||||||
@ -245,6 +269,10 @@ TEST(ExtractLane) {
|
|||||||
for (int i = 0; i < 16; i++) {
|
for (int i = 0; i < 16; i++) {
|
||||||
CHECK_EQ(-i, t.i8x16_high[i]);
|
CHECK_EQ(-i, t.i8x16_high[i]);
|
||||||
}
|
}
|
||||||
|
for (int i = 0; i < 8; i++) {
|
||||||
|
CHECK_EQ(-i, t.i8x16_high_d[i]);
|
||||||
|
CHECK_EQ(-i, t.i8x16_high_d[i + 8]);
|
||||||
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -212,6 +212,11 @@ T Not(T a) {
|
|||||||
return ~a;
|
return ~a;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
template <typename T>
|
||||||
|
T LogicalNot(T a) {
|
||||||
|
return a == 0 ? 1 : 0;
|
||||||
|
}
|
||||||
|
|
||||||
template <typename T>
|
template <typename T>
|
||||||
T Sqrt(T a) {
|
T Sqrt(T a) {
|
||||||
return std::sqrt(a);
|
return std::sqrt(a);
|
||||||
@ -1340,6 +1345,182 @@ WASM_EXEC_COMPILED_TEST(I8x16ShrU) {
|
|||||||
WASM_SIMD_SELECT_TEST(32x4)
|
WASM_SIMD_SELECT_TEST(32x4)
|
||||||
WASM_SIMD_SELECT_TEST(16x8)
|
WASM_SIMD_SELECT_TEST(16x8)
|
||||||
WASM_SIMD_SELECT_TEST(8x16)
|
WASM_SIMD_SELECT_TEST(8x16)
|
||||||
|
|
||||||
|
// Boolean unary operations are 'AllTrue' and 'AnyTrue', which return an integer
|
||||||
|
// result. Use relational ops on numeric vectors to create the boolean vector
|
||||||
|
// test inputs. Test inputs with all true, all false, one true, and one false.
|
||||||
|
#define WASM_SIMD_BOOL_REDUCTION_TEST(format, lanes) \
|
||||||
|
WASM_EXEC_TEST(ReductionTest##lanes) { \
|
||||||
|
FLAG_wasm_simd_prototype = true; \
|
||||||
|
WasmRunner<int32_t> r(kExecuteCompiled); \
|
||||||
|
byte zero = r.AllocateLocal(kWasmS128); \
|
||||||
|
byte one_one = r.AllocateLocal(kWasmS128); \
|
||||||
|
byte reduced = r.AllocateLocal(kWasmI32); \
|
||||||
|
BUILD(r, WASM_SET_LOCAL(zero, WASM_SIMD_I##format##_SPLAT(WASM_ZERO)), \
|
||||||
|
WASM_SET_LOCAL( \
|
||||||
|
reduced, WASM_SIMD_UNOP(kExprS1x##lanes##AnyTrue, \
|
||||||
|
WASM_SIMD_BINOP(kExprI##format##Eq, \
|
||||||
|
WASM_GET_LOCAL(zero), \
|
||||||
|
WASM_GET_LOCAL(zero)))), \
|
||||||
|
WASM_IF(WASM_I32_EQ(WASM_GET_LOCAL(reduced), WASM_ZERO), \
|
||||||
|
WASM_RETURN1(WASM_ZERO)), \
|
||||||
|
WASM_SET_LOCAL( \
|
||||||
|
reduced, WASM_SIMD_UNOP(kExprS1x##lanes##AnyTrue, \
|
||||||
|
WASM_SIMD_BINOP(kExprI##format##Ne, \
|
||||||
|
WASM_GET_LOCAL(zero), \
|
||||||
|
WASM_GET_LOCAL(zero)))), \
|
||||||
|
WASM_IF(WASM_I32_NE(WASM_GET_LOCAL(reduced), WASM_ZERO), \
|
||||||
|
WASM_RETURN1(WASM_ZERO)), \
|
||||||
|
WASM_SET_LOCAL( \
|
||||||
|
reduced, WASM_SIMD_UNOP(kExprS1x##lanes##AllTrue, \
|
||||||
|
WASM_SIMD_BINOP(kExprI##format##Eq, \
|
||||||
|
WASM_GET_LOCAL(zero), \
|
||||||
|
WASM_GET_LOCAL(zero)))), \
|
||||||
|
WASM_IF(WASM_I32_EQ(WASM_GET_LOCAL(reduced), WASM_ZERO), \
|
||||||
|
WASM_RETURN1(WASM_ZERO)), \
|
||||||
|
WASM_SET_LOCAL( \
|
||||||
|
reduced, WASM_SIMD_UNOP(kExprS1x##lanes##AllTrue, \
|
||||||
|
WASM_SIMD_BINOP(kExprI##format##Ne, \
|
||||||
|
WASM_GET_LOCAL(zero), \
|
||||||
|
WASM_GET_LOCAL(zero)))), \
|
||||||
|
WASM_IF(WASM_I32_NE(WASM_GET_LOCAL(reduced), WASM_ZERO), \
|
||||||
|
WASM_RETURN1(WASM_ZERO)), \
|
||||||
|
WASM_SET_LOCAL(one_one, \
|
||||||
|
WASM_SIMD_I##format##_REPLACE_LANE( \
|
||||||
|
lanes - 1, WASM_GET_LOCAL(zero), WASM_ONE)), \
|
||||||
|
WASM_SET_LOCAL( \
|
||||||
|
reduced, WASM_SIMD_UNOP(kExprS1x##lanes##AnyTrue, \
|
||||||
|
WASM_SIMD_BINOP(kExprI##format##Eq, \
|
||||||
|
WASM_GET_LOCAL(one_one), \
|
||||||
|
WASM_GET_LOCAL(zero)))), \
|
||||||
|
WASM_IF(WASM_I32_EQ(WASM_GET_LOCAL(reduced), WASM_ZERO), \
|
||||||
|
WASM_RETURN1(WASM_ZERO)), \
|
||||||
|
WASM_SET_LOCAL( \
|
||||||
|
reduced, WASM_SIMD_UNOP(kExprS1x##lanes##AnyTrue, \
|
||||||
|
WASM_SIMD_BINOP(kExprI##format##Ne, \
|
||||||
|
WASM_GET_LOCAL(one_one), \
|
||||||
|
WASM_GET_LOCAL(zero)))), \
|
||||||
|
WASM_IF(WASM_I32_EQ(WASM_GET_LOCAL(reduced), WASM_ZERO), \
|
||||||
|
WASM_RETURN1(WASM_ZERO)), \
|
||||||
|
WASM_SET_LOCAL( \
|
||||||
|
reduced, WASM_SIMD_UNOP(kExprS1x##lanes##AllTrue, \
|
||||||
|
WASM_SIMD_BINOP(kExprI##format##Eq, \
|
||||||
|
WASM_GET_LOCAL(one_one), \
|
||||||
|
WASM_GET_LOCAL(zero)))), \
|
||||||
|
WASM_IF(WASM_I32_NE(WASM_GET_LOCAL(reduced), WASM_ZERO), \
|
||||||
|
WASM_RETURN1(WASM_ZERO)), \
|
||||||
|
WASM_SET_LOCAL( \
|
||||||
|
reduced, WASM_SIMD_UNOP(kExprS1x##lanes##AllTrue, \
|
||||||
|
WASM_SIMD_BINOP(kExprI##format##Ne, \
|
||||||
|
WASM_GET_LOCAL(one_one), \
|
||||||
|
WASM_GET_LOCAL(zero)))), \
|
||||||
|
WASM_IF(WASM_I32_NE(WASM_GET_LOCAL(reduced), WASM_ZERO), \
|
||||||
|
WASM_RETURN1(WASM_ZERO)), \
|
||||||
|
WASM_ONE); \
|
||||||
|
CHECK_EQ(1, r.Call()); \
|
||||||
|
}
|
||||||
|
|
||||||
|
WASM_SIMD_BOOL_REDUCTION_TEST(32x4, 4)
|
||||||
|
WASM_SIMD_BOOL_REDUCTION_TEST(16x8, 8)
|
||||||
|
WASM_SIMD_BOOL_REDUCTION_TEST(8x16, 16)
|
||||||
|
|
||||||
|
#define WASM_SIMD_UNOP_HELPER(format, lanes, lane_size) \
|
||||||
|
void RunS1x##lanes##UnOpTest(WasmOpcode simd_op, \
|
||||||
|
Int##lane_size##UnOp expected_op) { \
|
||||||
|
FLAG_wasm_simd_prototype = true; \
|
||||||
|
WasmRunner<int32_t, int32_t, int32_t> r(kExecuteCompiled); \
|
||||||
|
byte a = 0; \
|
||||||
|
byte expected = 1; \
|
||||||
|
byte zero = r.AllocateLocal(kWasmS128); \
|
||||||
|
byte simd = r.AllocateLocal(kWasmS128); \
|
||||||
|
BUILD( \
|
||||||
|
r, WASM_SET_LOCAL(zero, WASM_SIMD_I##format##_SPLAT(WASM_ZERO)), \
|
||||||
|
WASM_SET_LOCAL(simd, WASM_SIMD_I##format##_SPLAT(WASM_GET_LOCAL(a))), \
|
||||||
|
WASM_SET_LOCAL( \
|
||||||
|
simd, \
|
||||||
|
WASM_SIMD_MATERIALIZE_BOOLS( \
|
||||||
|
format, WASM_SIMD_UNOP( \
|
||||||
|
simd_op, WASM_SIMD_BINOP(kExprI##format##Ne, \
|
||||||
|
WASM_GET_LOCAL(simd), \
|
||||||
|
WASM_GET_LOCAL(zero))))), \
|
||||||
|
WASM_SIMD_CHECK_SPLAT##lanes(I##format, simd, I32, expected), \
|
||||||
|
WASM_ONE); \
|
||||||
|
\
|
||||||
|
for (int i = 0; i <= 1; i++) { \
|
||||||
|
CHECK_EQ(1, r.Call(i, expected_op(i))); \
|
||||||
|
} \
|
||||||
|
}
|
||||||
|
WASM_SIMD_UNOP_HELPER(32x4, 4, 32);
|
||||||
|
WASM_SIMD_UNOP_HELPER(16x8, 8, 16);
|
||||||
|
WASM_SIMD_UNOP_HELPER(8x16, 16, 8);
|
||||||
|
#undef WASM_SIMD_UNOP_HELPER
|
||||||
|
|
||||||
|
WASM_EXEC_COMPILED_TEST(S1x4Not) { RunS1x4UnOpTest(kExprS1x4Not, LogicalNot); }
|
||||||
|
|
||||||
|
WASM_EXEC_COMPILED_TEST(S1x8Not) { RunS1x8UnOpTest(kExprS1x8Not, LogicalNot); }
|
||||||
|
|
||||||
|
WASM_EXEC_COMPILED_TEST(S1x16Not) {
|
||||||
|
RunS1x16UnOpTest(kExprS1x16Not, LogicalNot);
|
||||||
|
}
|
||||||
|
|
||||||
|
#define WASM_SIMD_BINOP_HELPER(format, lanes, lane_size) \
|
||||||
|
void RunS1x##lanes##BinOpTest(WasmOpcode simd_op, \
|
||||||
|
Int##lane_size##BinOp expected_op) { \
|
||||||
|
FLAG_wasm_simd_prototype = true; \
|
||||||
|
WasmRunner<int32_t, int32_t, int32_t, int32_t> r(kExecuteCompiled); \
|
||||||
|
byte a = 0; \
|
||||||
|
byte b = 1; \
|
||||||
|
byte expected = 2; \
|
||||||
|
byte zero = r.AllocateLocal(kWasmS128); \
|
||||||
|
byte simd0 = r.AllocateLocal(kWasmS128); \
|
||||||
|
byte simd1 = r.AllocateLocal(kWasmS128); \
|
||||||
|
BUILD( \
|
||||||
|
r, WASM_SET_LOCAL(zero, WASM_SIMD_I##format##_SPLAT(WASM_ZERO)), \
|
||||||
|
WASM_SET_LOCAL(simd0, WASM_SIMD_I##format##_SPLAT(WASM_GET_LOCAL(a))), \
|
||||||
|
WASM_SET_LOCAL(simd1, WASM_SIMD_I##format##_SPLAT(WASM_GET_LOCAL(b))), \
|
||||||
|
WASM_SET_LOCAL( \
|
||||||
|
simd1, \
|
||||||
|
WASM_SIMD_MATERIALIZE_BOOLS( \
|
||||||
|
format, \
|
||||||
|
WASM_SIMD_BINOP( \
|
||||||
|
simd_op, \
|
||||||
|
WASM_SIMD_BINOP(kExprI##format##Ne, WASM_GET_LOCAL(simd0), \
|
||||||
|
WASM_GET_LOCAL(zero)), \
|
||||||
|
WASM_SIMD_BINOP(kExprI##format##Ne, WASM_GET_LOCAL(simd1), \
|
||||||
|
WASM_GET_LOCAL(zero))))), \
|
||||||
|
WASM_SIMD_CHECK_SPLAT##lanes(I##format, simd1, I32, expected), \
|
||||||
|
WASM_ONE); \
|
||||||
|
\
|
||||||
|
for (int i = 0; i <= 1; i++) { \
|
||||||
|
for (int j = 0; j <= 1; j++) { \
|
||||||
|
CHECK_EQ(1, r.Call(i, j, expected_op(i, j))); \
|
||||||
|
} \
|
||||||
|
} \
|
||||||
|
}
|
||||||
|
|
||||||
|
WASM_SIMD_BINOP_HELPER(32x4, 4, 32);
|
||||||
|
WASM_SIMD_BINOP_HELPER(16x8, 8, 16);
|
||||||
|
WASM_SIMD_BINOP_HELPER(8x16, 16, 8);
|
||||||
|
#undef WASM_SIMD_BINOP_HELPER
|
||||||
|
|
||||||
|
WASM_EXEC_COMPILED_TEST(S1x4And) { RunS1x4BinOpTest(kExprS1x4And, And); }
|
||||||
|
|
||||||
|
WASM_EXEC_COMPILED_TEST(S1x4Or) { RunS1x4BinOpTest(kExprS1x4Or, Or); }
|
||||||
|
|
||||||
|
WASM_EXEC_COMPILED_TEST(S1x4Xor) { RunS1x4BinOpTest(kExprS1x4Xor, Xor); }
|
||||||
|
|
||||||
|
WASM_EXEC_COMPILED_TEST(S1x8And) { RunS1x8BinOpTest(kExprS1x8And, And); }
|
||||||
|
|
||||||
|
WASM_EXEC_COMPILED_TEST(S1x8Or) { RunS1x8BinOpTest(kExprS1x8Or, Or); }
|
||||||
|
|
||||||
|
WASM_EXEC_COMPILED_TEST(S1x8Xor) { RunS1x8BinOpTest(kExprS1x8Xor, Xor); }
|
||||||
|
|
||||||
|
WASM_EXEC_COMPILED_TEST(S1x16And) { RunS1x16BinOpTest(kExprS1x16And, And); }
|
||||||
|
|
||||||
|
WASM_EXEC_COMPILED_TEST(S1x16Or) { RunS1x16BinOpTest(kExprS1x16Or, Or); }
|
||||||
|
|
||||||
|
WASM_EXEC_COMPILED_TEST(S1x16Xor) { RunS1x16BinOpTest(kExprS1x16Xor, Xor); }
|
||||||
|
|
||||||
#endif // V8_TARGET_ARCH_ARM
|
#endif // V8_TARGET_ARCH_ARM
|
||||||
|
|
||||||
#if SIMD_LOWERING_TARGET
|
#if SIMD_LOWERING_TARGET
|
||||||
|
Loading…
Reference in New Issue
Block a user