Upgrade V8 to 5.1.281.57 DO NOT MERGE
FPIIM-449
Change-Id: Id981b686b4d587ac31697662eb98bb34be42ad90
(cherry picked from commit 3b9bc31999c9787eb726ecdbfd5796bfdec32a18)
diff --git a/test/cctest/compiler/test-run-machops.cc b/test/cctest/compiler/test-run-machops.cc
index fba9e0e..2bfe124 100644
--- a/test/cctest/compiler/test-run-machops.cc
+++ b/test/cctest/compiler/test-run-machops.cc
@@ -1197,7 +1197,7 @@
p1 = *j;
p2 = *j - 5;
CHECK_EQ(magic, m.Call());
- CheckDoubleEq(p1, p2);
+ CHECK_DOUBLE_EQ(p1, p2);
}
}
}
@@ -1224,7 +1224,7 @@
p1 = *j;
p2 = *j - 5;
CHECK_EQ(magic, m.Call());
- CheckDoubleEq(p1, p2);
+ CHECK_DOUBLE_EQ(p1, p2);
}
}
}
@@ -3658,10 +3658,7 @@
m.Return(m.Float32Add(m.Parameter(0), m.Parameter(1)));
FOR_FLOAT32_INPUTS(i) {
- FOR_FLOAT32_INPUTS(j) {
- volatile float expected = *i + *j;
- CheckFloatEq(expected, m.Call(*i, *j));
- }
+ FOR_FLOAT32_INPUTS(j) { CHECK_FLOAT_EQ(*i + *j, m.Call(*i, *j)); }
}
}
@@ -3672,10 +3669,7 @@
m.Return(m.Float32Sub(m.Parameter(0), m.Parameter(1)));
FOR_FLOAT32_INPUTS(i) {
- FOR_FLOAT32_INPUTS(j) {
- volatile float expected = *i - *j;
- CheckFloatEq(expected, m.Call(*i, *j));
- }
+ FOR_FLOAT32_INPUTS(j) { CHECK_FLOAT_EQ(*i - *j, m.Call(*i, *j)); }
}
}
@@ -3686,10 +3680,7 @@
m.Return(m.Float32Mul(m.Parameter(0), m.Parameter(1)));
FOR_FLOAT32_INPUTS(i) {
- FOR_FLOAT32_INPUTS(j) {
- volatile float expected = *i * *j;
- CheckFloatEq(expected, m.Call(*i, *j));
- }
+ FOR_FLOAT32_INPUTS(j) { CHECK_FLOAT_EQ(*i * *j, m.Call(*i, *j)); }
}
}
@@ -3700,10 +3691,7 @@
m.Return(m.Float32Div(m.Parameter(0), m.Parameter(1)));
FOR_FLOAT32_INPUTS(i) {
- FOR_FLOAT32_INPUTS(j) {
- volatile float expected = *i / *j;
- CheckFloatEq(expected, m.Call(*i, *j));
- }
+ FOR_FLOAT32_INPUTS(j) { CHECK_FLOAT_EQ(*i / *j, m.Call(*i, *j)); }
}
}
@@ -3714,10 +3702,7 @@
m.Return(m.Float64Add(m.Parameter(0), m.Parameter(1)));
FOR_FLOAT64_INPUTS(i) {
- FOR_FLOAT64_INPUTS(j) {
- volatile double expected = *i + *j;
- CheckDoubleEq(expected, m.Call(*i, *j));
- }
+ FOR_FLOAT64_INPUTS(j) { CHECK_DOUBLE_EQ(*i + *j, m.Call(*i, *j)); }
}
}
@@ -3728,10 +3713,7 @@
m.Return(m.Float64Sub(m.Parameter(0), m.Parameter(1)));
FOR_FLOAT64_INPUTS(i) {
- FOR_FLOAT64_INPUTS(j) {
- volatile double expected = *i - *j;
- CheckDoubleEq(expected, m.Call(*i, *j));
- }
+ FOR_FLOAT64_INPUTS(j) { CHECK_DOUBLE_EQ(*i - *j, m.Call(*i, *j)); }
}
}
@@ -3742,10 +3724,7 @@
m.Return(m.Float64Mul(m.Parameter(0), m.Parameter(1)));
FOR_FLOAT64_INPUTS(i) {
- FOR_FLOAT64_INPUTS(j) {
- volatile double expected = *i * *j;
- CheckDoubleEq(expected, m.Call(*i, *j));
- }
+ FOR_FLOAT64_INPUTS(j) { CHECK_DOUBLE_EQ(*i * *j, m.Call(*i, *j)); }
}
}
@@ -3756,10 +3735,7 @@
m.Return(m.Float64Div(m.Parameter(0), m.Parameter(1)));
FOR_FLOAT64_INPUTS(i) {
- FOR_FLOAT64_INPUTS(j) {
- volatile double expected = *i / *j;
- CheckDoubleEq(expected, m.Call(*i, *j));
- }
+ FOR_FLOAT64_INPUTS(j) { CHECK_DOUBLE_EQ(*i / *j, m.Call(*i, *j)); }
}
}
@@ -3770,7 +3746,7 @@
m.Return(m.Float64Mod(m.Parameter(0), m.Parameter(1)));
FOR_FLOAT64_INPUTS(i) {
- FOR_FLOAT64_INPUTS(j) { CheckDoubleEq(modulo(*i, *j), m.Call(*i, *j)); }
+ FOR_FLOAT64_INPUTS(j) { CHECK_DOUBLE_EQ(modulo(*i, *j), m.Call(*i, *j)); }
}
}
@@ -3816,10 +3792,7 @@
bt.AddReturn(m.Float32Add(bt.param0, bt.param1));
FOR_FLOAT32_INPUTS(pl) {
- FOR_FLOAT32_INPUTS(pr) {
- float expected = *pl + *pr;
- CheckFloatEq(expected, bt.call(*pl, *pr));
- }
+ FOR_FLOAT32_INPUTS(pr) { CHECK_FLOAT_EQ(*pl + *pr, bt.call(*pl, *pr)); }
}
}
@@ -3831,10 +3804,7 @@
bt.AddReturn(m.Float64Add(bt.param0, bt.param1));
FOR_FLOAT64_INPUTS(pl) {
- FOR_FLOAT64_INPUTS(pr) {
- double expected = *pl + *pr;
- CheckDoubleEq(expected, bt.call(*pl, *pr));
- }
+ FOR_FLOAT64_INPUTS(pr) { CHECK_DOUBLE_EQ(*pl + *pr, bt.call(*pl, *pr)); }
}
}
@@ -3848,8 +3818,7 @@
FOR_FLOAT32_INPUTS(pl) {
FOR_FLOAT32_INPUTS(pr) {
- double expected = *pl > *pr ? *pl : *pr;
- CheckDoubleEq(expected, bt.call(*pl, *pr));
+ CHECK_DOUBLE_EQ(*pl > *pr ? *pl : *pr, bt.call(*pl, *pr));
}
}
}
@@ -3864,8 +3833,7 @@
FOR_FLOAT64_INPUTS(pl) {
FOR_FLOAT64_INPUTS(pr) {
- double expected = *pl > *pr ? *pl : *pr;
- CheckDoubleEq(expected, bt.call(*pl, *pr));
+ CHECK_DOUBLE_EQ(*pl > *pr ? *pl : *pr, bt.call(*pl, *pr));
}
}
}
@@ -3880,8 +3848,7 @@
FOR_FLOAT32_INPUTS(pl) {
FOR_FLOAT32_INPUTS(pr) {
- double expected = *pl < *pr ? *pl : *pr;
- CheckDoubleEq(expected, bt.call(*pl, *pr));
+ CHECK_DOUBLE_EQ(*pl < *pr ? *pl : *pr, bt.call(*pl, *pr));
}
}
}
@@ -3896,8 +3863,7 @@
FOR_FLOAT64_INPUTS(pl) {
FOR_FLOAT64_INPUTS(pr) {
- double expected = *pl < *pr ? *pl : *pr;
- CheckDoubleEq(expected, bt.call(*pl, *pr));
+ CHECK_DOUBLE_EQ(*pl < *pr ? *pl : *pr, bt.call(*pl, *pr));
}
}
}
@@ -3910,10 +3876,7 @@
bt.AddReturn(m.Float32Sub(bt.param0, bt.param1));
FOR_FLOAT32_INPUTS(pl) {
- FOR_FLOAT32_INPUTS(pr) {
- float expected = *pl - *pr;
- CheckFloatEq(expected, bt.call(*pl, *pr));
- }
+ FOR_FLOAT32_INPUTS(pr) { CHECK_FLOAT_EQ(*pl - *pr, bt.call(*pl, *pr)); }
}
}
@@ -3923,10 +3886,7 @@
BufferedRawMachineAssemblerTester<float> m(MachineType::Float32());
m.Return(m.Float32Sub(m.Float32Constant(*i), m.Parameter(0)));
- FOR_FLOAT32_INPUTS(j) {
- volatile float expected = *i - *j;
- CheckFloatEq(expected, m.Call(*j));
- }
+ FOR_FLOAT32_INPUTS(j) { CHECK_FLOAT_EQ(*i - *j, m.Call(*j)); }
}
}
@@ -3936,10 +3896,7 @@
BufferedRawMachineAssemblerTester<float> m(MachineType::Float32());
m.Return(m.Float32Sub(m.Parameter(0), m.Float32Constant(*i)));
- FOR_FLOAT32_INPUTS(j) {
- volatile float expected = *j - *i;
- CheckFloatEq(expected, m.Call(*j));
- }
+ FOR_FLOAT32_INPUTS(j) { CHECK_FLOAT_EQ(*j - *i, m.Call(*j)); }
}
}
@@ -3949,7 +3906,7 @@
BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
m.Return(m.Float64Sub(m.Float64Constant(*i), m.Parameter(0)));
- FOR_FLOAT64_INPUTS(j) { CheckFloatEq(*i - *j, m.Call(*j)); }
+ FOR_FLOAT64_INPUTS(j) { CHECK_FLOAT_EQ(*i - *j, m.Call(*j)); }
}
}
@@ -3959,7 +3916,7 @@
BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
m.Return(m.Float64Sub(m.Parameter(0), m.Float64Constant(*i)));
- FOR_FLOAT64_INPUTS(j) { CheckFloatEq(*j - *i, m.Call(*j)); }
+ FOR_FLOAT64_INPUTS(j) { CHECK_FLOAT_EQ(*j - *i, m.Call(*j)); }
}
}
@@ -3973,7 +3930,7 @@
FOR_FLOAT64_INPUTS(pl) {
FOR_FLOAT64_INPUTS(pr) {
double expected = *pl - *pr;
- CheckDoubleEq(expected, bt.call(*pl, *pr));
+ CHECK_DOUBLE_EQ(expected, bt.call(*pl, *pr));
}
}
}
@@ -3986,10 +3943,7 @@
bt.AddReturn(m.Float32Mul(bt.param0, bt.param1));
FOR_FLOAT32_INPUTS(pl) {
- FOR_FLOAT32_INPUTS(pr) {
- float expected = *pl * *pr;
- CheckFloatEq(expected, bt.call(*pl, *pr));
- }
+ FOR_FLOAT32_INPUTS(pr) { CHECK_FLOAT_EQ(*pl * *pr, bt.call(*pl, *pr)); }
}
}
@@ -4003,7 +3957,7 @@
FOR_FLOAT64_INPUTS(pl) {
FOR_FLOAT64_INPUTS(pr) {
double expected = *pl * *pr;
- CheckDoubleEq(expected, bt.call(*pl, *pr));
+ CHECK_DOUBLE_EQ(expected, bt.call(*pl, *pr));
}
}
}
@@ -4018,7 +3972,7 @@
FOR_FLOAT64_INPUTS(i) {
FOR_FLOAT64_INPUTS(j) {
FOR_FLOAT64_INPUTS(k) {
- CheckDoubleEq((*i * *j) + *k, m.Call(*i, *j, *k));
+ CHECK_DOUBLE_EQ((*i * *j) + *k, m.Call(*i, *j, *k));
}
}
}
@@ -4034,7 +3988,7 @@
FOR_FLOAT64_INPUTS(i) {
FOR_FLOAT64_INPUTS(j) {
FOR_FLOAT64_INPUTS(k) {
- CheckDoubleEq(*i + (*j * *k), m.Call(*i, *j, *k));
+ CHECK_DOUBLE_EQ(*i + (*j * *k), m.Call(*i, *j, *k));
}
}
}
@@ -4050,7 +4004,7 @@
FOR_FLOAT64_INPUTS(i) {
FOR_FLOAT64_INPUTS(j) {
FOR_FLOAT64_INPUTS(k) {
- CheckDoubleEq((*i * *j) - *k, m.Call(*i, *j, *k));
+ CHECK_DOUBLE_EQ((*i * *j) - *k, m.Call(*i, *j, *k));
}
}
}
@@ -4066,7 +4020,7 @@
FOR_FLOAT64_INPUTS(i) {
FOR_FLOAT64_INPUTS(j) {
FOR_FLOAT64_INPUTS(k) {
- CheckDoubleEq(*i - (*j * *k), m.Call(*i, *j, *k));
+ CHECK_DOUBLE_EQ(*i - (*j * *k), m.Call(*i, *j, *k));
}
}
}
@@ -4078,7 +4032,7 @@
BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
m.Return(m.Float64Mul(m.Float64Constant(*i), m.Parameter(0)));
- FOR_FLOAT64_INPUTS(j) { CheckFloatEq(*i * *j, m.Call(*j)); }
+ FOR_FLOAT64_INPUTS(j) { CHECK_FLOAT_EQ(*i * *j, m.Call(*j)); }
}
}
@@ -4088,7 +4042,7 @@
BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
m.Return(m.Float64Mul(m.Parameter(0), m.Float64Constant(*i)));
- FOR_FLOAT64_INPUTS(j) { CheckFloatEq(*j * *i, m.Call(*j)); }
+ FOR_FLOAT64_INPUTS(j) { CHECK_FLOAT_EQ(*j * *i, m.Call(*j)); }
}
}
@@ -4100,10 +4054,7 @@
bt.AddReturn(m.Float32Div(bt.param0, bt.param1));
FOR_FLOAT32_INPUTS(pl) {
- FOR_FLOAT32_INPUTS(pr) {
- float expected = *pl / *pr;
- CheckFloatEq(expected, bt.call(*pl, *pr));
- }
+ FOR_FLOAT32_INPUTS(pr) { CHECK_FLOAT_EQ(*pl / *pr, bt.call(*pl, *pr)); }
}
}
@@ -4115,10 +4066,7 @@
bt.AddReturn(m.Float64Div(bt.param0, bt.param1));
FOR_FLOAT64_INPUTS(pl) {
- FOR_FLOAT64_INPUTS(pr) {
- double expected = *pl / *pr;
- CheckDoubleEq(expected, bt.call(*pl, *pr));
- }
+ FOR_FLOAT64_INPUTS(pr) { CHECK_DOUBLE_EQ(*pl / *pr, bt.call(*pl, *pr)); }
}
}
@@ -4130,11 +4078,7 @@
bt.AddReturn(m.Float64Mod(bt.param0, bt.param1));
FOR_FLOAT64_INPUTS(i) {
- FOR_FLOAT64_INPUTS(j) {
- double expected = modulo(*i, *j);
- double found = bt.call(*i, *j);
- CheckDoubleEq(expected, found);
- }
+ FOR_FLOAT64_INPUTS(j) { CHECK_DOUBLE_EQ(modulo(*i, *j), bt.call(*i, *j)); }
}
}
@@ -4143,7 +4087,7 @@
int32_t magic = 0x986234;
BufferedRawMachineAssemblerTester<double> m;
m.Return(m.ChangeInt32ToFloat64(m.Int32Constant(magic)));
- CheckDoubleEq(static_cast<double>(magic), m.Call());
+ CHECK_DOUBLE_EQ(static_cast<double>(magic), m.Call());
}
@@ -4151,7 +4095,7 @@
BufferedRawMachineAssemblerTester<double> m(MachineType::Int32());
m.Return(m.ChangeInt32ToFloat64(m.Parameter(0)));
- FOR_INT32_INPUTS(i) { CheckDoubleEq(static_cast<double>(*i), m.Call(*i)); }
+ FOR_INT32_INPUTS(i) { CHECK_DOUBLE_EQ(static_cast<double>(*i), m.Call(*i)); }
}
@@ -4159,7 +4103,7 @@
BufferedRawMachineAssemblerTester<double> m(MachineType::Uint32());
m.Return(m.ChangeUint32ToFloat64(m.Parameter(0)));
- FOR_UINT32_INPUTS(i) { CheckDoubleEq(static_cast<double>(*i), m.Call(*i)); }
+ FOR_UINT32_INPUTS(i) { CHECK_DOUBLE_EQ(static_cast<double>(*i), m.Call(*i)); }
}
@@ -4169,7 +4113,7 @@
FOR_FLOAT32_INPUTS(i) {
if (*i <= static_cast<float>(std::numeric_limits<int32_t>::max()) &&
*i >= static_cast<float>(std::numeric_limits<int32_t>::min())) {
- CheckFloatEq(static_cast<int32_t>(*i), m.Call(*i));
+ CHECK_FLOAT_EQ(static_cast<int32_t>(*i), m.Call(*i));
}
}
}
@@ -4193,7 +4137,7 @@
FOR_FLOAT32_INPUTS(i) {
if (*i <= static_cast<float>(std::numeric_limits<uint32_t>::max()) &&
*i >= static_cast<float>(std::numeric_limits<uint32_t>::min())) {
- CheckFloatEq(static_cast<uint32_t>(*i), m.Call(*i));
+ CHECK_FLOAT_EQ(static_cast<uint32_t>(*i), m.Call(*i));
}
}
}
@@ -4250,9 +4194,262 @@
m.Return(m.TruncateFloat64ToFloat32(m.Parameter(0)));
- FOR_FLOAT64_INPUTS(i) { CheckFloatEq(DoubleToFloat32(*i), m.Call(*i)); }
+ FOR_FLOAT64_INPUTS(i) { CHECK_FLOAT_EQ(DoubleToFloat32(*i), m.Call(*i)); }
}
+uint64_t ToInt64(uint32_t low, uint32_t high) {
+ return (static_cast<uint64_t>(high) << 32) | static_cast<uint64_t>(low);
+}
+
+#if V8_TARGET_ARCH_32_BIT && !V8_TARGET_ARCH_MIPS && !V8_TARGET_ARCH_X87
+TEST(RunInt32PairAdd) {
+ BufferedRawMachineAssemblerTester<int32_t> m(
+ MachineType::Uint32(), MachineType::Uint32(), MachineType::Uint32(),
+ MachineType::Uint32());
+
+ uint32_t high;
+ uint32_t low;
+
+ Node* PairAdd = m.Int32PairAdd(m.Parameter(0), m.Parameter(1), m.Parameter(2),
+ m.Parameter(3));
+
+ m.StoreToPointer(&low, MachineRepresentation::kWord32,
+ m.Projection(0, PairAdd));
+ m.StoreToPointer(&high, MachineRepresentation::kWord32,
+ m.Projection(1, PairAdd));
+ m.Return(m.Int32Constant(74));
+
+ FOR_UINT64_INPUTS(i) {
+ FOR_UINT64_INPUTS(j) {
+ m.Call(static_cast<uint32_t>(*i & 0xffffffff),
+ static_cast<uint32_t>(*i >> 32),
+ static_cast<uint32_t>(*j & 0xffffffff),
+ static_cast<uint32_t>(*j >> 32));
+ CHECK_EQ(*i + *j, ToInt64(low, high));
+ }
+ }
+}
+
+void TestInt32PairAddWithSharedInput(int a, int b, int c, int d) {
+ BufferedRawMachineAssemblerTester<int32_t> m(MachineType::Uint32(),
+ MachineType::Uint32());
+
+ uint32_t high;
+ uint32_t low;
+
+ Node* PairAdd = m.Int32PairAdd(m.Parameter(a), m.Parameter(b), m.Parameter(c),
+ m.Parameter(d));
+
+ m.StoreToPointer(&low, MachineRepresentation::kWord32,
+ m.Projection(0, PairAdd));
+ m.StoreToPointer(&high, MachineRepresentation::kWord32,
+ m.Projection(1, PairAdd));
+ m.Return(m.Int32Constant(74));
+
+ FOR_UINT32_INPUTS(i) {
+ FOR_UINT32_INPUTS(j) {
+ m.Call(*i, *j);
+ uint32_t inputs[] = {*i, *j};
+ CHECK_EQ(ToInt64(inputs[a], inputs[b]) + ToInt64(inputs[c], inputs[d]),
+ ToInt64(low, high));
+ }
+ }
+}
+
+TEST(RunInt32PairAddWithSharedInput) {
+ TestInt32PairAddWithSharedInput(0, 0, 0, 0);
+ TestInt32PairAddWithSharedInput(1, 0, 0, 0);
+ TestInt32PairAddWithSharedInput(0, 1, 0, 0);
+ TestInt32PairAddWithSharedInput(0, 0, 1, 0);
+ TestInt32PairAddWithSharedInput(0, 0, 0, 1);
+ TestInt32PairAddWithSharedInput(1, 1, 0, 0);
+}
+
+TEST(RunInt32PairSub) {
+ BufferedRawMachineAssemblerTester<int32_t> m(
+ MachineType::Uint32(), MachineType::Uint32(), MachineType::Uint32(),
+ MachineType::Uint32());
+
+ uint32_t high;
+ uint32_t low;
+
+ Node* PairSub = m.Int32PairSub(m.Parameter(0), m.Parameter(1), m.Parameter(2),
+ m.Parameter(3));
+
+ m.StoreToPointer(&low, MachineRepresentation::kWord32,
+ m.Projection(0, PairSub));
+ m.StoreToPointer(&high, MachineRepresentation::kWord32,
+ m.Projection(1, PairSub));
+ m.Return(m.Int32Constant(74));
+
+ FOR_UINT64_INPUTS(i) {
+ FOR_UINT64_INPUTS(j) {
+ m.Call(static_cast<uint32_t>(*i & 0xffffffff),
+ static_cast<uint32_t>(*i >> 32),
+ static_cast<uint32_t>(*j & 0xffffffff),
+ static_cast<uint32_t>(*j >> 32));
+ CHECK_EQ(*i - *j, ToInt64(low, high));
+ }
+ }
+}
+
+void TestInt32PairSubWithSharedInput(int a, int b, int c, int d) {
+ BufferedRawMachineAssemblerTester<int32_t> m(MachineType::Uint32(),
+ MachineType::Uint32());
+
+ uint32_t high;
+ uint32_t low;
+
+ Node* PairSub = m.Int32PairSub(m.Parameter(a), m.Parameter(b), m.Parameter(c),
+ m.Parameter(d));
+
+ m.StoreToPointer(&low, MachineRepresentation::kWord32,
+ m.Projection(0, PairSub));
+ m.StoreToPointer(&high, MachineRepresentation::kWord32,
+ m.Projection(1, PairSub));
+ m.Return(m.Int32Constant(74));
+
+ FOR_UINT32_INPUTS(i) {
+ FOR_UINT32_INPUTS(j) {
+ m.Call(*i, *j);
+ uint32_t inputs[] = {*i, *j};
+ CHECK_EQ(ToInt64(inputs[a], inputs[b]) - ToInt64(inputs[c], inputs[d]),
+ ToInt64(low, high));
+ }
+ }
+}
+
+TEST(RunInt32PairSubWithSharedInput) {
+ TestInt32PairSubWithSharedInput(0, 0, 0, 0);
+ TestInt32PairSubWithSharedInput(1, 0, 0, 0);
+ TestInt32PairSubWithSharedInput(0, 1, 0, 0);
+ TestInt32PairSubWithSharedInput(0, 0, 1, 0);
+ TestInt32PairSubWithSharedInput(0, 0, 0, 1);
+ TestInt32PairSubWithSharedInput(1, 1, 0, 0);
+}
+
+TEST(RunInt32PairMul) {
+ BufferedRawMachineAssemblerTester<int32_t> m(
+ MachineType::Uint32(), MachineType::Uint32(), MachineType::Uint32(),
+ MachineType::Uint32());
+
+ uint32_t high;
+ uint32_t low;
+
+ Node* PairMul = m.Int32PairMul(m.Parameter(0), m.Parameter(1), m.Parameter(2),
+ m.Parameter(3));
+
+ m.StoreToPointer(&low, MachineRepresentation::kWord32,
+ m.Projection(0, PairMul));
+ m.StoreToPointer(&high, MachineRepresentation::kWord32,
+ m.Projection(1, PairMul));
+ m.Return(m.Int32Constant(74));
+
+ FOR_UINT64_INPUTS(i) {
+ FOR_UINT64_INPUTS(j) {
+ m.Call(static_cast<uint32_t>(*i & 0xffffffff),
+ static_cast<uint32_t>(*i >> 32),
+ static_cast<uint32_t>(*j & 0xffffffff),
+ static_cast<uint32_t>(*j >> 32));
+ CHECK_EQ(*i * *j, ToInt64(low, high));
+ }
+ }
+}
+
+void TestInt32PairMulWithSharedInput(int a, int b, int c, int d) {
+ BufferedRawMachineAssemblerTester<int32_t> m(MachineType::Uint32(),
+ MachineType::Uint32());
+
+ uint32_t high;
+ uint32_t low;
+
+ Node* PairMul = m.Int32PairMul(m.Parameter(a), m.Parameter(b), m.Parameter(c),
+ m.Parameter(d));
+
+ m.StoreToPointer(&low, MachineRepresentation::kWord32,
+ m.Projection(0, PairMul));
+ m.StoreToPointer(&high, MachineRepresentation::kWord32,
+ m.Projection(1, PairMul));
+ m.Return(m.Int32Constant(74));
+
+ FOR_UINT32_INPUTS(i) {
+ FOR_UINT32_INPUTS(j) {
+ m.Call(*i, *j);
+ uint32_t inputs[] = {*i, *j};
+ CHECK_EQ(ToInt64(inputs[a], inputs[b]) * ToInt64(inputs[c], inputs[d]),
+ ToInt64(low, high));
+ }
+ }
+}
+
+TEST(RunInt32PairMulWithSharedInput) {
+ TestInt32PairMulWithSharedInput(0, 0, 0, 0);
+ TestInt32PairMulWithSharedInput(1, 0, 0, 0);
+ TestInt32PairMulWithSharedInput(0, 1, 0, 0);
+ TestInt32PairMulWithSharedInput(0, 0, 1, 0);
+ TestInt32PairMulWithSharedInput(0, 0, 0, 1);
+ TestInt32PairMulWithSharedInput(1, 1, 0, 0);
+ TestInt32PairMulWithSharedInput(0, 1, 1, 0);
+}
+
+TEST(RunWord32PairShl) {
+ BufferedRawMachineAssemblerTester<int32_t> m(
+ MachineType::Uint32(), MachineType::Uint32(), MachineType::Uint32());
+
+ uint32_t high;
+ uint32_t low;
+
+ Node* PairAdd =
+ m.Word32PairShl(m.Parameter(0), m.Parameter(1), m.Parameter(2));
+
+ m.StoreToPointer(&low, MachineRepresentation::kWord32,
+ m.Projection(0, PairAdd));
+ m.StoreToPointer(&high, MachineRepresentation::kWord32,
+ m.Projection(1, PairAdd));
+ m.Return(m.Int32Constant(74));
+
+ FOR_UINT64_INPUTS(i) {
+ for (uint32_t j = 0; j < 64; j++) {
+ m.Call(static_cast<uint32_t>(*i & 0xffffffff),
+ static_cast<uint32_t>(*i >> 32), j);
+ CHECK_EQ(*i << j, ToInt64(low, high));
+ }
+ }
+}
+
+void TestWord32PairShlWithSharedInput(int a, int b) {
+ BufferedRawMachineAssemblerTester<int32_t> m(MachineType::Uint32(),
+ MachineType::Uint32());
+
+ uint32_t high;
+ uint32_t low;
+
+ Node* PairAdd =
+ m.Word32PairShl(m.Parameter(a), m.Parameter(b), m.Parameter(1));
+
+ m.StoreToPointer(&low, MachineRepresentation::kWord32,
+ m.Projection(0, PairAdd));
+ m.StoreToPointer(&high, MachineRepresentation::kWord32,
+ m.Projection(1, PairAdd));
+ m.Return(m.Int32Constant(74));
+
+ FOR_UINT32_INPUTS(i) {
+ for (uint32_t j = 0; j < 64; j++) {
+ m.Call(*i, j);
+ uint32_t inputs[] = {*i, j};
+ CHECK_EQ(ToInt64(inputs[a], inputs[b]) << j, ToInt64(low, high));
+ }
+ }
+}
+
+TEST(RunWord32PairShlWithSharedInput) {
+ TestWord32PairShlWithSharedInput(0, 0);
+ TestWord32PairShlWithSharedInput(0, 1);
+ TestWord32PairShlWithSharedInput(1, 0);
+ TestWord32PairShlWithSharedInput(1, 1);
+}
+
+#endif
TEST(RunDeadChangeFloat64ToInt32) {
RawMachineAssemblerTester<int32_t> m;
@@ -5298,7 +5495,9 @@
m.Return(m.ChangeFloat32ToFloat64(m.Parameter(0)));
- FOR_FLOAT32_INPUTS(i) { CheckDoubleEq(static_cast<double>(*i), m.Call(*i)); }
+ FOR_FLOAT32_INPUTS(i) {
+ CHECK_DOUBLE_EQ(static_cast<double>(*i), m.Call(*i));
+ }
}
@@ -5306,7 +5505,7 @@
FOR_FLOAT32_INPUTS(i) {
BufferedRawMachineAssemblerTester<float> m;
m.Return(m.Float32Constant(*i));
- CheckFloatEq(*i, m.Call());
+ CHECK_FLOAT_EQ(*i, m.Call());
}
}
@@ -5340,7 +5539,7 @@
double expected = bit_cast<double>(
(bit_cast<uint64_t>(*i) & ~(V8_UINT64_C(0xFFFFFFFF))) |
(static_cast<uint64_t>(bit_cast<uint32_t>(*j))));
- CheckDoubleEq(expected, m.Call(*i, *j));
+ CHECK_DOUBLE_EQ(expected, m.Call(*i, *j));
}
}
}
@@ -5355,7 +5554,7 @@
uint64_t expected = (bit_cast<uint64_t>(*i) & 0xFFFFFFFF) |
(static_cast<uint64_t>(*j) << 32);
- CheckDoubleEq(bit_cast<double>(expected), m.Call(*i, *j));
+ CHECK_DOUBLE_EQ(bit_cast<double>(expected), m.Call(*i, *j));
}
}
}
@@ -5364,14 +5563,14 @@
TEST(RunFloat32Abs) {
BufferedRawMachineAssemblerTester<float> m(MachineType::Float32());
m.Return(m.Float32Abs(m.Parameter(0)));
- FOR_FLOAT32_INPUTS(i) { CheckFloatEq(std::abs(*i), m.Call(*i)); }
+ FOR_FLOAT32_INPUTS(i) { CHECK_FLOAT_EQ(std::abs(*i), m.Call(*i)); }
}
TEST(RunFloat64Abs) {
BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
m.Return(m.Float64Abs(m.Parameter(0)));
- FOR_FLOAT64_INPUTS(i) { CheckDoubleEq(std::abs(*i), m.Call(*i)); }
+ FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(std::abs(*i), m.Call(*i)); }
}
@@ -5479,7 +5678,7 @@
m.Return(m.Float32RoundDown(m.Parameter(0)));
- FOR_FLOAT32_INPUTS(i) { CheckFloatEq(floorf(*i), m.Call(*i)); }
+ FOR_FLOAT32_INPUTS(i) { CHECK_FLOAT_EQ(floorf(*i), m.Call(*i)); }
}
@@ -5489,7 +5688,7 @@
m.Return(m.Float64RoundDown(m.Parameter(0)));
- FOR_FLOAT64_INPUTS(i) { CheckDoubleEq(floor(*i), m.Call(*i)); }
+ FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(floor(*i), m.Call(*i)); }
}
@@ -5511,7 +5710,7 @@
if (!m.machine()->Float32RoundUp().IsSupported()) return;
m.Return(m.Float32RoundUp(m.Parameter(0)));
- FOR_FLOAT32_INPUTS(i) { CheckFloatEq(ceilf(*i), m.Call(*i)); }
+ FOR_FLOAT32_INPUTS(i) { CHECK_FLOAT_EQ(ceilf(*i), m.Call(*i)); }
}
@@ -5520,7 +5719,7 @@
if (!m.machine()->Float64RoundUp().IsSupported()) return;
m.Return(m.Float64RoundUp(m.Parameter(0)));
- FOR_FLOAT64_INPUTS(i) { CheckDoubleEq(ceil(*i), m.Call(*i)); }
+ FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(ceil(*i), m.Call(*i)); }
}
@@ -5529,7 +5728,7 @@
if (!m.machine()->Float32RoundTiesEven().IsSupported()) return;
m.Return(m.Float32RoundTiesEven(m.Parameter(0)));
- FOR_FLOAT32_INPUTS(i) { CheckFloatEq(nearbyint(*i), m.Call(*i)); }
+ FOR_FLOAT32_INPUTS(i) { CHECK_FLOAT_EQ(nearbyint(*i), m.Call(*i)); }
}
@@ -5538,7 +5737,7 @@
if (!m.machine()->Float64RoundTiesEven().IsSupported()) return;
m.Return(m.Float64RoundTiesEven(m.Parameter(0)));
- FOR_FLOAT64_INPUTS(i) { CheckDoubleEq(nearbyint(*i), m.Call(*i)); }
+ FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(nearbyint(*i), m.Call(*i)); }
}
@@ -5548,7 +5747,7 @@
m.Return(m.Float32RoundTruncate(m.Parameter(0)));
- FOR_FLOAT32_INPUTS(i) { CheckFloatEq(truncf(*i), m.Call(*i)); }
+ FOR_FLOAT32_INPUTS(i) { CHECK_FLOAT_EQ(truncf(*i), m.Call(*i)); }
}
@@ -5653,79 +5852,6 @@
}
#endif // USE_SIMULATOR
-template <typename T>
-void TestExternalReferenceFunction(
- BufferedRawMachineAssemblerTester<int32_t>* m, ExternalReference ref,
- T (*comparison)(T)) {
- T parameter;
-
- Node* function = m->ExternalConstant(ref);
- m->CallCFunction1(MachineType::Pointer(), MachineType::Pointer(), function,
- m->PointerConstant(¶meter));
- m->Return(m->Int32Constant(4356));
- FOR_FLOAT64_INPUTS(i) {
- parameter = *i;
- m->Call();
- CheckDoubleEq(comparison(*i), parameter);
- }
-}
-
-TEST(RunCallExternalReferenceF32Trunc) {
- BufferedRawMachineAssemblerTester<int32_t> m;
- ExternalReference ref =
- ExternalReference::f32_trunc_wrapper_function(m.isolate());
- TestExternalReferenceFunction<float>(&m, ref, truncf);
-}
-
-TEST(RunCallExternalReferenceF32Floor) {
- BufferedRawMachineAssemblerTester<int32_t> m;
- ExternalReference ref =
- ExternalReference::f32_floor_wrapper_function(m.isolate());
- TestExternalReferenceFunction<float>(&m, ref, floorf);
-}
-
-TEST(RunCallExternalReferenceF32Ceil) {
- BufferedRawMachineAssemblerTester<int32_t> m;
- ExternalReference ref =
- ExternalReference::f32_ceil_wrapper_function(m.isolate());
- TestExternalReferenceFunction<float>(&m, ref, ceilf);
-}
-
-TEST(RunCallExternalReferenceF32RoundTiesEven) {
- BufferedRawMachineAssemblerTester<int32_t> m;
- ExternalReference ref =
- ExternalReference::f32_nearest_int_wrapper_function(m.isolate());
- TestExternalReferenceFunction<float>(&m, ref, nearbyintf);
-}
-
-TEST(RunCallExternalReferenceF64Trunc) {
- BufferedRawMachineAssemblerTester<int32_t> m;
- ExternalReference ref =
- ExternalReference::f64_trunc_wrapper_function(m.isolate());
- TestExternalReferenceFunction<double>(&m, ref, trunc);
-}
-
-TEST(RunCallExternalReferenceF64Floor) {
- BufferedRawMachineAssemblerTester<int32_t> m;
- ExternalReference ref =
- ExternalReference::f64_floor_wrapper_function(m.isolate());
- TestExternalReferenceFunction<double>(&m, ref, floor);
-}
-
-TEST(RunCallExternalReferenceF64Ceil) {
- BufferedRawMachineAssemblerTester<int32_t> m;
- ExternalReference ref =
- ExternalReference::f64_ceil_wrapper_function(m.isolate());
- TestExternalReferenceFunction<double>(&m, ref, ceil);
-}
-
-TEST(RunCallExternalReferenceF64RoundTiesEven) {
- BufferedRawMachineAssemblerTester<int32_t> m;
- ExternalReference ref =
- ExternalReference::f64_nearest_int_wrapper_function(m.isolate());
- TestExternalReferenceFunction<double>(&m, ref, nearbyint);
-}
-
#if V8_TARGET_ARCH_64_BIT
// TODO(titzer): run int64 tests on all platforms when supported.
TEST(RunCheckedLoadInt64) {
@@ -5907,7 +6033,7 @@
TEST(RunTryTruncateFloat64ToUint64WithoutCheck) {
BufferedRawMachineAssemblerTester<uint64_t> m(MachineType::Float64());
- m.Return(m.TruncateFloat64ToUint64(m.Parameter(0)));
+ m.Return(m.TryTruncateFloat64ToUint64(m.Parameter(0)));
FOR_UINT64_INPUTS(j) {
double input = static_cast<double>(*j);