OLD | NEW |
(Empty) | |
| 1 // Copyright 2016 the V8 project authors. All rights reserved. |
| 2 // Use of this source code is governed by a BSD-style license that can be |
| 3 // found in the LICENSE file. |
| 4 |
| 5 #include "src/compiler/typed-optimization.h" |
| 6 #include "src/code-factory.h" |
| 7 #include "src/compilation-dependencies.h" |
| 8 #include "src/compiler/access-builder.h" |
| 9 #include "src/compiler/js-graph.h" |
| 10 #include "src/compiler/js-operator.h" |
| 11 #include "src/compiler/machine-operator.h" |
| 12 #include "src/compiler/node-properties.h" |
| 13 #include "src/compiler/operator-properties.h" |
| 14 #include "src/isolate-inl.h" |
| 15 #include "test/unittests/compiler/compiler-test-utils.h" |
| 16 #include "test/unittests/compiler/graph-unittest.h" |
| 17 #include "test/unittests/compiler/node-test-utils.h" |
| 18 #include "testing/gmock-support.h" |
| 19 |
| 20 using testing::IsNaN; |
| 21 |
| 22 namespace v8 { |
| 23 namespace internal { |
| 24 namespace compiler { |
| 25 |
| 26 namespace { |
| 27 |
| 28 const double kFloat64Values[] = { |
| 29 -V8_INFINITY, -4.23878e+275, -5.82632e+265, -6.60355e+220, |
| 30 -6.26172e+212, -2.56222e+211, -4.82408e+201, -1.84106e+157, |
| 31 -1.63662e+127, -1.55772e+100, -1.67813e+72, -2.3382e+55, |
| 32 -3.179e+30, -1.441e+09, -1.0647e+09, -7.99361e+08, |
| 33 -5.77375e+08, -2.20984e+08, -32757, -13171, |
| 34 -9970, -3984, -107, -105, |
| 35 -92, -77, -61, -0.000208163, |
| 36 -1.86685e-06, -1.17296e-10, -9.26358e-11, -5.08004e-60, |
| 37 -1.74753e-65, -1.06561e-71, -5.67879e-79, -5.78459e-130, |
| 38 -2.90989e-171, -7.15489e-243, -3.76242e-252, -1.05639e-263, |
| 39 -4.40497e-267, -2.19666e-273, -4.9998e-276, -5.59821e-278, |
| 40 -2.03855e-282, -5.99335e-283, -7.17554e-284, -3.11744e-309, |
| 41 -0.0, 0.0, 2.22507e-308, 1.30127e-270, |
| 42 7.62898e-260, 4.00313e-249, 3.16829e-233, 1.85244e-228, |
| 43 2.03544e-129, 1.35126e-110, 1.01182e-106, 5.26333e-94, |
| 44 1.35292e-90, 2.85394e-83, 1.78323e-77, 5.4967e-57, |
| 45 1.03207e-25, 4.57401e-25, 1.58738e-05, 2, |
| 46 125, 2310, 9636, 14802, |
| 47 17168, 28945, 29305, 4.81336e+07, |
| 48 1.41207e+08, 4.65962e+08, 1.40499e+09, 2.12648e+09, |
| 49 8.80006e+30, 1.4446e+45, 1.12164e+54, 2.48188e+89, |
| 50 6.71121e+102, 3.074e+112, 4.9699e+152, 5.58383e+166, |
| 51 4.30654e+172, 7.08824e+185, 9.6586e+214, 2.028e+223, |
| 52 6.63277e+243, 1.56192e+261, 1.23202e+269, 5.72883e+289, |
| 53 8.5798e+290, 1.40256e+294, 1.79769e+308, V8_INFINITY}; |
| 54 |
| 55 const double kIntegerValues[] = {-V8_INFINITY, INT_MIN, -1000.0, -42.0, |
| 56 -1.0, 0.0, 1.0, 42.0, |
| 57 1000.0, INT_MAX, UINT_MAX, V8_INFINITY}; |
| 58 |
| 59 Type* const kJSTypes[] = {Type::Undefined(), Type::Null(), Type::Boolean(), |
| 60 Type::Number(), Type::String(), Type::Object()}; |
| 61 |
| 62 } // namespace |
| 63 |
| 64 class TypedOptimizationTest : public TypedGraphTest { |
| 65 public: |
| 66 TypedOptimizationTest() |
| 67 : TypedGraphTest(3), javascript_(zone()), deps_(isolate(), zone()) {} |
| 68 ~TypedOptimizationTest() override {} |
| 69 |
| 70 protected: |
| 71 Reduction Reduce(Node* node) { |
| 72 MachineOperatorBuilder machine(zone()); |
| 73 SimplifiedOperatorBuilder simplified(zone()); |
| 74 JSGraph jsgraph(isolate(), graph(), common(), javascript(), &simplified, |
| 75 &machine); |
| 76 // TODO(titzer): mock the GraphReducer here for better unit testing. |
| 77 GraphReducer graph_reducer(zone(), graph()); |
| 78 TypedOptimization reducer(&graph_reducer, &deps_, |
| 79 TypedOptimization::kDeoptimizationEnabled, |
| 80 &jsgraph); |
| 81 return reducer.Reduce(node); |
| 82 } |
| 83 |
| 84 JSOperatorBuilder* javascript() { return &javascript_; } |
| 85 |
| 86 private: |
| 87 JSOperatorBuilder javascript_; |
| 88 CompilationDependencies deps_; |
| 89 }; |
| 90 |
| 91 TEST_F(TypedOptimizationTest, ParameterWithMinusZero) { |
| 92 { |
| 93 Reduction r = Reduce( |
| 94 Parameter(Type::Constant(factory()->minus_zero_value(), zone()))); |
| 95 ASSERT_TRUE(r.Changed()); |
| 96 EXPECT_THAT(r.replacement(), IsNumberConstant(-0.0)); |
| 97 } |
| 98 { |
| 99 Reduction r = Reduce(Parameter(Type::MinusZero())); |
| 100 ASSERT_TRUE(r.Changed()); |
| 101 EXPECT_THAT(r.replacement(), IsNumberConstant(-0.0)); |
| 102 } |
| 103 { |
| 104 Reduction r = Reduce(Parameter( |
| 105 Type::Union(Type::MinusZero(), |
| 106 Type::Constant(factory()->NewNumber(0), zone()), zone()))); |
| 107 EXPECT_FALSE(r.Changed()); |
| 108 } |
| 109 } |
| 110 |
| 111 TEST_F(TypedOptimizationTest, ParameterWithNull) { |
| 112 Handle<HeapObject> null = factory()->null_value(); |
| 113 { |
| 114 Reduction r = Reduce(Parameter(Type::Constant(null, zone()))); |
| 115 ASSERT_TRUE(r.Changed()); |
| 116 EXPECT_THAT(r.replacement(), IsHeapConstant(null)); |
| 117 } |
| 118 { |
| 119 Reduction r = Reduce(Parameter(Type::Null())); |
| 120 ASSERT_TRUE(r.Changed()); |
| 121 EXPECT_THAT(r.replacement(), IsHeapConstant(null)); |
| 122 } |
| 123 } |
| 124 |
| 125 TEST_F(TypedOptimizationTest, ParameterWithNaN) { |
| 126 const double kNaNs[] = {-std::numeric_limits<double>::quiet_NaN(), |
| 127 std::numeric_limits<double>::quiet_NaN(), |
| 128 std::numeric_limits<double>::signaling_NaN()}; |
| 129 TRACED_FOREACH(double, nan, kNaNs) { |
| 130 Handle<Object> constant = factory()->NewNumber(nan); |
| 131 Reduction r = Reduce(Parameter(Type::Constant(constant, zone()))); |
| 132 ASSERT_TRUE(r.Changed()); |
| 133 EXPECT_THAT(r.replacement(), IsNumberConstant(IsNaN())); |
| 134 } |
| 135 { |
| 136 Reduction r = |
| 137 Reduce(Parameter(Type::Constant(factory()->nan_value(), zone()))); |
| 138 ASSERT_TRUE(r.Changed()); |
| 139 EXPECT_THAT(r.replacement(), IsNumberConstant(IsNaN())); |
| 140 } |
| 141 { |
| 142 Reduction r = Reduce(Parameter(Type::NaN())); |
| 143 ASSERT_TRUE(r.Changed()); |
| 144 EXPECT_THAT(r.replacement(), IsNumberConstant(IsNaN())); |
| 145 } |
| 146 } |
| 147 |
| 148 TEST_F(TypedOptimizationTest, ParameterWithPlainNumber) { |
| 149 TRACED_FOREACH(double, value, kFloat64Values) { |
| 150 Handle<Object> constant = factory()->NewNumber(value); |
| 151 Reduction r = Reduce(Parameter(Type::Constant(constant, zone()))); |
| 152 ASSERT_TRUE(r.Changed()); |
| 153 EXPECT_THAT(r.replacement(), IsNumberConstant(value)); |
| 154 } |
| 155 TRACED_FOREACH(double, value, kIntegerValues) { |
| 156 Reduction r = Reduce(Parameter(Type::Range(value, value, zone()))); |
| 157 ASSERT_TRUE(r.Changed()); |
| 158 EXPECT_THAT(r.replacement(), IsNumberConstant(value)); |
| 159 } |
| 160 } |
| 161 |
| 162 TEST_F(TypedOptimizationTest, ParameterWithUndefined) { |
| 163 Handle<HeapObject> undefined = factory()->undefined_value(); |
| 164 { |
| 165 Reduction r = Reduce(Parameter(Type::Undefined())); |
| 166 ASSERT_TRUE(r.Changed()); |
| 167 EXPECT_THAT(r.replacement(), IsHeapConstant(undefined)); |
| 168 } |
| 169 { |
| 170 Reduction r = Reduce(Parameter(Type::Constant(undefined, zone()))); |
| 171 ASSERT_TRUE(r.Changed()); |
| 172 EXPECT_THAT(r.replacement(), IsHeapConstant(undefined)); |
| 173 } |
| 174 } |
| 175 |
| 176 TEST_F(TypedOptimizationTest, JSToBooleanWithFalsish) { |
| 177 Node* input = Parameter( |
| 178 Type::Union( |
| 179 Type::MinusZero(), |
| 180 Type::Union( |
| 181 Type::NaN(), |
| 182 Type::Union( |
| 183 Type::Null(), |
| 184 Type::Union( |
| 185 Type::Undefined(), |
| 186 Type::Union( |
| 187 Type::Undetectable(), |
| 188 Type::Union( |
| 189 Type::Constant(factory()->false_value(), zone()), |
| 190 Type::Range(0.0, 0.0, zone()), zone()), |
| 191 zone()), |
| 192 zone()), |
| 193 zone()), |
| 194 zone()), |
| 195 zone()), |
| 196 0); |
| 197 Node* context = Parameter(Type::Any(), 1); |
| 198 Reduction r = Reduce(graph()->NewNode( |
| 199 javascript()->ToBoolean(ToBooleanHint::kAny), input, context)); |
| 200 ASSERT_TRUE(r.Changed()); |
| 201 EXPECT_THAT(r.replacement(), IsFalseConstant()); |
| 202 } |
| 203 |
| 204 TEST_F(TypedOptimizationTest, JSToBooleanWithTruish) { |
| 205 Node* input = Parameter( |
| 206 Type::Union( |
| 207 Type::Constant(factory()->true_value(), zone()), |
| 208 Type::Union(Type::DetectableReceiver(), Type::Symbol(), zone()), |
| 209 zone()), |
| 210 0); |
| 211 Node* context = Parameter(Type::Any(), 1); |
| 212 Reduction r = Reduce(graph()->NewNode( |
| 213 javascript()->ToBoolean(ToBooleanHint::kAny), input, context)); |
| 214 ASSERT_TRUE(r.Changed()); |
| 215 EXPECT_THAT(r.replacement(), IsTrueConstant()); |
| 216 } |
| 217 |
| 218 TEST_F(TypedOptimizationTest, JSToBooleanWithNonZeroPlainNumber) { |
| 219 Node* input = Parameter(Type::Range(1, V8_INFINITY, zone()), 0); |
| 220 Node* context = Parameter(Type::Any(), 1); |
| 221 Reduction r = Reduce(graph()->NewNode( |
| 222 javascript()->ToBoolean(ToBooleanHint::kAny), input, context)); |
| 223 ASSERT_TRUE(r.Changed()); |
| 224 EXPECT_THAT(r.replacement(), IsTrueConstant()); |
| 225 } |
| 226 |
| 227 } // namespace compiler |
| 228 } // namespace internal |
| 229 } // namespace v8 |
OLD | NEW |