Revision: 23293
Author: [email protected]
Date: Fri Aug 22 07:54:09 2014 UTC
Log: [turbofan] Add support for change/truncate to
MachineOperatorReducer.
TEST=compiler-unittests
[email protected]
Review URL: https://codereview.chromium.org/470633006
https://code.google.com/p/v8/source/detail?r=23293
Modified:
/branches/bleeding_edge/src/compiler/machine-operator-reducer.cc
/branches/bleeding_edge/src/compiler/machine-operator-reducer.h
/branches/bleeding_edge/test/compiler-unittests/graph-unittest.cc
/branches/bleeding_edge/test/compiler-unittests/graph-unittest.h
/branches/bleeding_edge/test/compiler-unittests/machine-operator-reducer-unittest.cc
=======================================
--- /branches/bleeding_edge/src/compiler/machine-operator-reducer.cc Thu
Aug 14 09:07:58 2014 UTC
+++ /branches/bleeding_edge/src/compiler/machine-operator-reducer.cc Fri
Aug 22 07:54:09 2014 UTC
@@ -29,22 +29,27 @@
machine_(graph->zone()) {}
-Node* MachineOperatorReducer::Int32Constant(int32_t value) {
- Node** loc = cache_->FindInt32Constant(value);
+Node* MachineOperatorReducer::Float64Constant(volatile double value) {
+ Node** loc = cache_->FindFloat64Constant(value);
if (*loc == NULL) {
- *loc = graph_->NewNode(common_.Int32Constant(value));
+ *loc = graph_->NewNode(common_.Float64Constant(value));
}
return *loc;
}
-Node* MachineOperatorReducer::Float64Constant(volatile double value) {
- Node** loc = cache_->FindFloat64Constant(value);
+Node* MachineOperatorReducer::Int32Constant(int32_t value) {
+ Node** loc = cache_->FindInt32Constant(value);
if (*loc == NULL) {
- *loc = graph_->NewNode(common_.Float64Constant(value));
+ *loc = graph_->NewNode(common_.Int32Constant(value));
}
return *loc;
}
+
+
+Node* MachineOperatorReducer::Int64Constant(int64_t value) {
+ return graph_->NewNode(common_.Int64Constant(value));
+}
// Perform constant folding and strength reduction on machine operators.
@@ -392,6 +397,50 @@
}
break;
}
+ case IrOpcode::kChangeFloat64ToInt32: {
+ Float64Matcher m(node->InputAt(0));
+ if (m.HasValue()) return ReplaceInt32(FastD2I(m.Value()));
+ if (m.IsChangeInt32ToFloat64()) return Replace(m.node()->InputAt(0));
+ break;
+ }
+ case IrOpcode::kChangeFloat64ToUint32: {
+ Float64Matcher m(node->InputAt(0));
+ if (m.HasValue()) return ReplaceInt32(FastD2UI(m.Value()));
+ if (m.IsChangeUint32ToFloat64()) return
Replace(m.node()->InputAt(0));
+ break;
+ }
+ case IrOpcode::kChangeInt32ToFloat64: {
+ Int32Matcher m(node->InputAt(0));
+ if (m.HasValue()) return ReplaceFloat64(FastI2D(m.Value()));
+ break;
+ }
+ case IrOpcode::kChangeInt32ToInt64: {
+ Int32Matcher m(node->InputAt(0));
+ if (m.HasValue()) return ReplaceInt64(m.Value());
+ break;
+ }
+ case IrOpcode::kChangeUint32ToFloat64: {
+ Uint32Matcher m(node->InputAt(0));
+ if (m.HasValue()) return ReplaceFloat64(FastUI2D(m.Value()));
+ break;
+ }
+ case IrOpcode::kChangeUint32ToUint64: {
+ Uint32Matcher m(node->InputAt(0));
+ if (m.HasValue()) return
ReplaceInt64(static_cast<uint64_t>(m.Value()));
+ break;
+ }
+ case IrOpcode::kTruncateFloat64ToInt32: {
+ Float64Matcher m(node->InputAt(0));
+ if (m.HasValue()) return ReplaceInt32(DoubleToInt32(m.Value()));
+ if (m.IsChangeInt32ToFloat64()) return Replace(m.node()->InputAt(0));
+ break;
+ }
+ case IrOpcode::kTruncateInt64ToInt32: {
+ Int64Matcher m(node->InputAt(0));
+ if (m.HasValue()) return
ReplaceInt32(static_cast<int32_t>(m.Value()));
+ if (m.IsChangeInt32ToInt64()) return Replace(m.node()->InputAt(0));
+ break;
+ }
// TODO(turbofan): strength-reduce and fold floating point operations.
default:
break;
=======================================
--- /branches/bleeding_edge/src/compiler/machine-operator-reducer.h Wed Jul
30 13:54:45 2014 UTC
+++ /branches/bleeding_edge/src/compiler/machine-operator-reducer.h Fri Aug
22 07:54:09 2014 UTC
@@ -32,17 +32,19 @@
CommonOperatorBuilder common_;
MachineOperatorBuilder machine_;
+ Node* Float64Constant(volatile double value);
Node* Int32Constant(int32_t value);
- Node* Float64Constant(volatile double value);
+ Node* Int64Constant(int64_t value);
Reduction ReplaceBool(bool value) { return ReplaceInt32(value ? 1 : 0); }
-
+ Reduction ReplaceFloat64(volatile double value) {
+ return Replace(Float64Constant(value));
+ }
Reduction ReplaceInt32(int32_t value) {
return Replace(Int32Constant(value));
}
-
- Reduction ReplaceFloat64(volatile double value) {
- return Replace(Float64Constant(value));
+ Reduction ReplaceInt64(int64_t value) {
+ return Replace(Int64Constant(value));
}
};
}
=======================================
--- /branches/bleeding_edge/test/compiler-unittests/graph-unittest.cc Fri
Aug 22 04:47:55 2014 UTC
+++ /branches/bleeding_edge/test/compiler-unittests/graph-unittest.cc Fri
Aug 22 07:54:09 2014 UTC
@@ -53,6 +53,11 @@
Node* GraphTest::Int32Constant(int32_t value) {
return graph()->NewNode(common()->Int32Constant(value));
}
+
+
+Node* GraphTest::Int64Constant(int64_t value) {
+ return graph()->NewNode(common()->Int64Constant(value));
+}
Node* GraphTest::NumberConstant(double value) {
@@ -645,6 +650,12 @@
return MakeMatcher(
new IsConstantMatcher<int32_t>(IrOpcode::kInt32Constant,
value_matcher));
}
+
+
+Matcher<Node*> IsInt64Constant(const Matcher<int64_t>& value_matcher) {
+ return MakeMatcher(
+ new IsConstantMatcher<int64_t>(IrOpcode::kInt64Constant,
value_matcher));
+}
Matcher<Node*> IsFloat64Constant(const Matcher<double>& value_matcher) {
=======================================
--- /branches/bleeding_edge/test/compiler-unittests/graph-unittest.h Fri
Aug 22 04:47:55 2014 UTC
+++ /branches/bleeding_edge/test/compiler-unittests/graph-unittest.h Fri
Aug 22 07:54:09 2014 UTC
@@ -32,6 +32,7 @@
Node* Parameter(int32_t index);
Node* Float64Constant(double value);
Node* Int32Constant(int32_t value);
+ Node* Int64Constant(int64_t value);
Node* NumberConstant(double value);
Node* HeapConstant(const PrintableUnique<HeapObject>& value);
Node* FalseConstant();
@@ -63,6 +64,7 @@
const Matcher<PrintableUnique<HeapObject> >& value_matcher);
Matcher<Node*> IsFloat64Constant(const Matcher<double>& value_matcher);
Matcher<Node*> IsInt32Constant(const Matcher<int32_t>& value_matcher);
+Matcher<Node*> IsInt64Constant(const Matcher<int64_t>& value_matcher);
Matcher<Node*> IsNumberConstant(const Matcher<double>& value_matcher);
Matcher<Node*> IsPhi(const Matcher<Node*>& value0_matcher,
const Matcher<Node*>& value1_matcher,
=======================================
---
/branches/bleeding_edge/test/compiler-unittests/machine-operator-reducer-unittest.cc
Fri Aug 22 04:47:55 2014 UTC
+++
/branches/bleeding_edge/test/compiler-unittests/machine-operator-reducer-unittest.cc
Fri Aug 22 07:54:09 2014 UTC
@@ -29,9 +29,119 @@
};
+template <typename T>
+class MachineOperatorReducerTestWithParam
+ : public MachineOperatorReducerTest,
+ public ::testing::WithParamInterface<T> {
+ public:
+ explicit MachineOperatorReducerTestWithParam(int num_parameters = 2)
+ : MachineOperatorReducerTest(num_parameters) {}
+ virtual ~MachineOperatorReducerTestWithParam() {}
+};
+
+
namespace {
-static const uint32_t kConstants[] = {
+static const double kFloat64Values[] = {
+ -V8_INFINITY, -4.23878e+275, -5.82632e+265, -6.60355e+220,
-6.26172e+212,
+ -2.56222e+211, -4.82408e+201, -1.84106e+157, -1.63662e+127,
-1.55772e+100,
+ -1.67813e+72, -2.3382e+55, -3.179e+30, -1.441e+09,
-1.0647e+09,
+ -7.99361e+08, -5.77375e+08, -2.20984e+08, -32757, -13171,
+ -9970, -3984, -107, -105, -92,
+ -77, -61, -0.000208163, -1.86685e-06,
-1.17296e-10,
+ -9.26358e-11, -5.08004e-60, -1.74753e-65, -1.06561e-71,
-5.67879e-79,
+ -5.78459e-130, -2.90989e-171, -7.15489e-243, -3.76242e-252,
-1.05639e-263,
+ -4.40497e-267, -2.19666e-273, -4.9998e-276, -5.59821e-278,
-2.03855e-282,
+ -5.99335e-283, -7.17554e-284, -3.11744e-309, -0.0, 0.0,
+ 2.22507e-308, 1.30127e-270, 7.62898e-260, 4.00313e-249,
3.16829e-233,
+ 1.85244e-228, 2.03544e-129, 1.35126e-110, 1.01182e-106,
5.26333e-94,
+ 1.35292e-90, 2.85394e-83, 1.78323e-77, 5.4967e-57,
1.03207e-25,
+ 4.57401e-25, 1.58738e-05, 2, 125, 2310,
+ 9636, 14802, 17168, 28945, 29305,
+ 4.81336e+07, 1.41207e+08, 4.65962e+08, 1.40499e+09,
2.12648e+09,
+ 8.80006e+30, 1.4446e+45, 1.12164e+54, 2.48188e+89,
6.71121e+102,
+ 3.074e+112, 4.9699e+152, 5.58383e+166, 4.30654e+172,
7.08824e+185,
+ 9.6586e+214, 2.028e+223, 6.63277e+243, 1.56192e+261,
1.23202e+269,
+ 5.72883e+289, 8.5798e+290, 1.40256e+294, 1.79769e+308,
V8_INFINITY};
+
+
+static const int32_t kInt32Values[] = {
+ -2147483647 - 1, -1914954528, -1698749618, -1578693386, -1577976073,
+ -1573998034, -1529085059, -1499540537, -1299205097, -1090814845,
+ -938186388, -806828902, -750927650, -520676892, -513661538,
+ -453036354, -433622833, -282638793, -28375, -27788,
+ -22770, -18806, -14173, -11956, -11200,
+ -10212, -8160, -3751, -2758, -1522,
+ -121, -120, -118, -117, -106,
+ -84, -80, -74, -59, -52,
+ -48, -39, -35, -17, -11,
+ -10, -9, -7, -5, 0,
+ 9, 12, 17, 23, 29,
+ 31, 33, 35, 40, 47,
+ 55, 56, 62, 64, 67,
+ 68, 69, 74, 79, 84,
+ 89, 90, 97, 104, 118,
+ 124, 126, 127, 7278, 17787,
+ 24136, 24202, 25570, 26680, 30242,
+ 32399, 420886487, 642166225, 821912648, 822577803,
+ 851385718, 1212241078, 1411419304, 1589626102, 1596437184,
+ 1876245816, 1954730266, 2008792749, 2045320228, 2147483647};
+
+
+static const int64_t kInt64Values[] = {
+ V8_INT64_C(-9223372036854775807) - 1, V8_INT64_C(-8974392461363618006),
+ V8_INT64_C(-8874367046689588135), V8_INT64_C(-8269197512118230839),
+ V8_INT64_C(-8146091527100606733), V8_INT64_C(-7550917981466150848),
+ V8_INT64_C(-7216590251577894337), V8_INT64_C(-6464086891160048440),
+ V8_INT64_C(-6365616494908257190), V8_INT64_C(-6305630541365849726),
+ V8_INT64_C(-5982222642272245453), V8_INT64_C(-5510103099058504169),
+ V8_INT64_C(-5496838675802432701), V8_INT64_C(-4047626578868642657),
+ V8_INT64_C(-4033755046900164544), V8_INT64_C(-3554299241457877041),
+ V8_INT64_C(-2482258764588614470), V8_INT64_C(-1688515425526875335),
+ V8_INT64_C(-924784137176548532), V8_INT64_C(-725316567157391307),
+ V8_INT64_C(-439022654781092241), V8_INT64_C(-105545757668917080),
+ V8_INT64_C(-2088319373), V8_INT64_C(-2073699916),
+ V8_INT64_C(-1844949911), V8_INT64_C(-1831090548),
+ V8_INT64_C(-1756711933), V8_INT64_C(-1559409497),
+ V8_INT64_C(-1281179700), V8_INT64_C(-1211513985),
+ V8_INT64_C(-1182371520), V8_INT64_C(-785934753),
+ V8_INT64_C(-767480697), V8_INT64_C(-705745662),
+ V8_INT64_C(-514362436), V8_INT64_C(-459916580),
+ V8_INT64_C(-312328082), V8_INT64_C(-302949707),
+ V8_INT64_C(-285499304), V8_INT64_C(-125701262),
+ V8_INT64_C(-95139843), V8_INT64_C(-32768),
+ V8_INT64_C(-27542), V8_INT64_C(-23600),
+ V8_INT64_C(-18582), V8_INT64_C(-17770),
+ V8_INT64_C(-9086), V8_INT64_C(-9010),
+ V8_INT64_C(-8244), V8_INT64_C(-2890),
+ V8_INT64_C(-103), V8_INT64_C(-34),
+ V8_INT64_C(-27), V8_INT64_C(-25),
+ V8_INT64_C(-9), V8_INT64_C(-7),
+ V8_INT64_C(0), V8_INT64_C(2),
+ V8_INT64_C(38), V8_INT64_C(58),
+ V8_INT64_C(65), V8_INT64_C(93),
+ V8_INT64_C(111), V8_INT64_C(1003),
+ V8_INT64_C(1267), V8_INT64_C(12797),
+ V8_INT64_C(23122), V8_INT64_C(28200),
+ V8_INT64_C(30888), V8_INT64_C(42648848),
+ V8_INT64_C(116836693), V8_INT64_C(263003643),
+ V8_INT64_C(571039860), V8_INT64_C(1079398689),
+ V8_INT64_C(1145196402), V8_INT64_C(1184846321),
+ V8_INT64_C(1758281648), V8_INT64_C(1859991374),
+ V8_INT64_C(1960251588), V8_INT64_C(2042443199),
+ V8_INT64_C(296220586027987448), V8_INT64_C(1015494173071134726),
+ V8_INT64_C(1151237951914455318), V8_INT64_C(1331941174616854174),
+ V8_INT64_C(2022020418667972654), V8_INT64_C(2450251424374977035),
+ V8_INT64_C(3668393562685561486), V8_INT64_C(4858229301215502171),
+ V8_INT64_C(4919426235170669383), V8_INT64_C(5034286595330341762),
+ V8_INT64_C(5055797915536941182), V8_INT64_C(6072389716149252074),
+ V8_INT64_C(6185309910199801210), V8_INT64_C(6297328311011094138),
+ V8_INT64_C(6932372858072165827), V8_INT64_C(8483640924987737210),
+ V8_INT64_C(8663764179455849203), V8_INT64_C(8877197042645298254),
+ V8_INT64_C(8901543506779157333), V8_INT64_C(9223372036854775807)};
+
+
+static const uint32_t kUint32Values[] = {
0x00000000, 0x00000001, 0xffffffff, 0x1b09788b, 0x04c5fce8, 0xcc0de5bf,
0x273a798e, 0x187937a3, 0xece3af83, 0x5495a16b, 0x0b668ecc, 0x11223344,
0x0000009e, 0x00000043, 0x0000af73, 0x0000116b, 0x00658ecc, 0x002b3b4c,
@@ -44,6 +154,216 @@
} // namespace
+//
-----------------------------------------------------------------------------
+// Unary operators
+
+
+namespace {
+
+struct UnaryOperator {
+ Operator* (MachineOperatorBuilder::*constructor)();
+ const char* constructor_name;
+};
+
+
+std::ostream& operator<<(std::ostream& os, const UnaryOperator& unop) {
+ return os << unop.constructor_name;
+}
+
+
+static const UnaryOperator kUnaryOperators[] = {
+
{&MachineOperatorBuilder::ChangeInt32ToFloat64, "ChangeInt32ToFloat64"},
+
{&MachineOperatorBuilder::ChangeUint32ToFloat64, "ChangeUint32ToFloat64"},
+
{&MachineOperatorBuilder::ChangeFloat64ToInt32, "ChangeFloat64ToInt32"},
+
{&MachineOperatorBuilder::ChangeFloat64ToUint32, "ChangeFloat64ToUint32"},
+ {&MachineOperatorBuilder::ChangeInt32ToInt64, "ChangeInt32ToInt64"},
+
{&MachineOperatorBuilder::ChangeUint32ToUint64, "ChangeUint32ToUint64"},
+
{&MachineOperatorBuilder::TruncateFloat64ToInt32, "TruncateFloat64ToInt32"},
+
{&MachineOperatorBuilder::TruncateInt64ToInt32, "TruncateInt64ToInt32"}};
+
+} // namespace
+
+
+typedef MachineOperatorReducerTestWithParam<UnaryOperator>
+ MachineUnaryOperatorReducerTest;
+
+
+TEST_P(MachineUnaryOperatorReducerTest, Parameter) {
+ const UnaryOperator unop = GetParam();
+ Reduction reduction =
+ Reduce(graph()->NewNode((machine()->*unop.constructor)(),
Parameter(0)));
+ EXPECT_FALSE(reduction.Changed());
+}
+
+
+INSTANTIATE_TEST_CASE_P(MachineOperatorReducerTest,
+ MachineUnaryOperatorReducerTest,
+ ::testing::ValuesIn(kUnaryOperators));
+
+
+//
-----------------------------------------------------------------------------
+// ChangeFloat64ToInt32
+
+
+TEST_F(MachineOperatorReducerTest,
+ ChangeFloat64ToInt32WithChangeInt32ToFloat64) {
+ Node* value = Parameter(0);
+ Reduction reduction = Reduce(graph()->NewNode(
+ machine()->ChangeFloat64ToInt32(),
+ graph()->NewNode(machine()->ChangeInt32ToFloat64(), value)));
+ ASSERT_TRUE(reduction.Changed());
+ EXPECT_EQ(value, reduction.replacement());
+}
+
+
+TEST_F(MachineOperatorReducerTest, ChangeFloat64ToInt32WithConstant) {
+ TRACED_FOREACH(int32_t, x, kInt32Values) {
+ Reduction reduction = Reduce(graph()->NewNode(
+ machine()->ChangeFloat64ToInt32(), Float64Constant(FastI2D(x))));
+ ASSERT_TRUE(reduction.Changed());
+ EXPECT_THAT(reduction.replacement(), IsInt32Constant(x));
+ }
+}
+
+
+//
-----------------------------------------------------------------------------
+// ChangeFloat64ToUint32
+
+
+TEST_F(MachineOperatorReducerTest,
+ ChangeFloat64ToUint32WithChangeUint32ToFloat64) {
+ Node* value = Parameter(0);
+ Reduction reduction = Reduce(graph()->NewNode(
+ machine()->ChangeFloat64ToUint32(),
+ graph()->NewNode(machine()->ChangeUint32ToFloat64(), value)));
+ ASSERT_TRUE(reduction.Changed());
+ EXPECT_EQ(value, reduction.replacement());
+}
+
+
+TEST_F(MachineOperatorReducerTest, ChangeFloat64ToUint32WithConstant) {
+ TRACED_FOREACH(uint32_t, x, kUint32Values) {
+ Reduction reduction = Reduce(graph()->NewNode(
+ machine()->ChangeFloat64ToUint32(), Float64Constant(FastUI2D(x))));
+ ASSERT_TRUE(reduction.Changed());
+ EXPECT_THAT(reduction.replacement(),
IsInt32Constant(BitCast<int32_t>(x)));
+ }
+}
+
+
+//
-----------------------------------------------------------------------------
+// ChangeInt32ToFloat64
+
+
+TEST_F(MachineOperatorReducerTest, ChangeInt32ToFloat64WithConstant) {
+ TRACED_FOREACH(int32_t, x, kInt32Values) {
+ Reduction reduction = Reduce(
+ graph()->NewNode(machine()->ChangeInt32ToFloat64(),
Int32Constant(x)));
+ ASSERT_TRUE(reduction.Changed());
+ EXPECT_THAT(reduction.replacement(), IsFloat64Constant(FastI2D(x)));
+ }
+}
+
+
+//
-----------------------------------------------------------------------------
+// ChangeInt32ToInt64
+
+
+TEST_F(MachineOperatorReducerTest, ChangeInt32ToInt64WithConstant) {
+ TRACED_FOREACH(int32_t, x, kInt32Values) {
+ Reduction reduction = Reduce(
+ graph()->NewNode(machine()->ChangeInt32ToInt64(),
Int32Constant(x)));
+ ASSERT_TRUE(reduction.Changed());
+ EXPECT_THAT(reduction.replacement(), IsInt64Constant(x));
+ }
+}
+
+
+//
-----------------------------------------------------------------------------
+// ChangeUint32ToFloat64
+
+
+TEST_F(MachineOperatorReducerTest, ChangeUint32ToFloat64WithConstant) {
+ TRACED_FOREACH(uint32_t, x, kUint32Values) {
+ Reduction reduction =
+ Reduce(graph()->NewNode(machine()->ChangeUint32ToFloat64(),
+ Int32Constant(BitCast<int32_t>(x))));
+ ASSERT_TRUE(reduction.Changed());
+ EXPECT_THAT(reduction.replacement(), IsFloat64Constant(FastUI2D(x)));
+ }
+}
+
+
+//
-----------------------------------------------------------------------------
+// ChangeUint32ToUint64
+
+
+TEST_F(MachineOperatorReducerTest, ChangeUint32ToUint64WithConstant) {
+ TRACED_FOREACH(uint32_t, x, kUint32Values) {
+ Reduction reduction = Reduce(graph()->NewNode(
+ machine()->ChangeUint32ToUint64(),
Int32Constant(BitCast<int32_t>(x))));
+ ASSERT_TRUE(reduction.Changed());
+ EXPECT_THAT(reduction.replacement(),
+
IsInt64Constant(BitCast<int64_t>(static_cast<uint64_t>(x))));
+ }
+}
+
+
+//
-----------------------------------------------------------------------------
+// TruncateFloat64ToInt32
+
+
+TEST_F(MachineOperatorReducerTest,
+ TruncateFloat64ToInt32WithChangeInt32ToFloat64) {
+ Node* value = Parameter(0);
+ Reduction reduction = Reduce(graph()->NewNode(
+ machine()->TruncateFloat64ToInt32(),
+ graph()->NewNode(machine()->ChangeInt32ToFloat64(), value)));
+ ASSERT_TRUE(reduction.Changed());
+ EXPECT_EQ(value, reduction.replacement());
+}
+
+
+TEST_F(MachineOperatorReducerTest, TruncateFloat64ToInt32WithConstant) {
+ TRACED_FOREACH(double, x, kFloat64Values) {
+ Reduction reduction = Reduce(graph()->NewNode(
+ machine()->TruncateFloat64ToInt32(), Float64Constant(x)));
+ ASSERT_TRUE(reduction.Changed());
+ EXPECT_THAT(reduction.replacement(),
IsInt32Constant(DoubleToInt32(x)));
+ }
+}
+
+
+//
-----------------------------------------------------------------------------
+// TruncateInt64ToInt32
+
+
+TEST_F(MachineOperatorReducerTest,
TruncateInt64ToInt32WithChangeInt32ToInt64) {
+ Node* value = Parameter(0);
+ Reduction reduction = Reduce(graph()->NewNode(
+ machine()->TruncateInt64ToInt32(),
+ graph()->NewNode(machine()->ChangeInt32ToInt64(), value)));
+ ASSERT_TRUE(reduction.Changed());
+ EXPECT_EQ(value, reduction.replacement());
+}
+
+
+TEST_F(MachineOperatorReducerTest, TruncateInt64ToInt32WithConstant) {
+ TRACED_FOREACH(int64_t, x, kInt64Values) {
+ Reduction reduction = Reduce(
+ graph()->NewNode(machine()->TruncateInt64ToInt32(),
Int64Constant(x)));
+ ASSERT_TRUE(reduction.Changed());
+ EXPECT_THAT(reduction.replacement(),
+ IsInt32Constant(BitCast<int32_t>(
+ static_cast<uint32_t>(BitCast<uint64_t>(x)))));
+ }
+}
+
+
+//
-----------------------------------------------------------------------------
+// Word32Ror
+
+
TEST_F(MachineOperatorReducerTest, ReduceToWord32RorWithParameters) {
Node* value = Parameter(0);
Node* shift = Parameter(1);
@@ -106,7 +426,7 @@
TEST_F(MachineOperatorReducerTest, Word32RorWithConstants) {
- TRACED_FOREACH(int32_t, x, kConstants) {
+ TRACED_FOREACH(int32_t, x, kUint32Values) {
TRACED_FORRANGE(int32_t, y, 0, 31) {
Node* node = graph()->NewNode(machine()->Word32Ror(),
Int32Constant(x),
Int32Constant(y));
--
--
v8-dev mailing list
[email protected]
http://groups.google.com/group/v8-dev
---
You received this message because you are subscribed to the Google Groups "v8-dev" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to [email protected].
For more options, visit https://groups.google.com/d/optout.
