OLD | NEW |
1 // Copyright 2014 the V8 project authors. All rights reserved. | 1 // Copyright 2014 the V8 project authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "src/compiler/simplified-operator.h" | 5 #include "src/compiler/simplified-operator.h" |
6 #include "src/compiler/access-builder.h" | 6 #include "src/compiler/access-builder.h" |
7 #include "src/compiler/js-graph.h" | 7 #include "src/compiler/js-graph.h" |
8 #include "src/compiler/node-properties.h" | 8 #include "src/compiler/node-properties.h" |
9 #include "src/compiler/simplified-operator-reducer.h" | 9 #include "src/compiler/simplified-operator-reducer.h" |
10 #include "src/compiler/types.h" | 10 #include "src/compiler/types.h" |
(...skipping 79 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
90 29755, 30554, 16476817, 605431957, 832401070, 873617242, 914205764, | 90 29755, 30554, 16476817, 605431957, 832401070, 873617242, 914205764, |
91 1062628108, 1087581664, 1488498068, 1534668023, 1661587028, 1696896187, | 91 1062628108, 1087581664, 1488498068, 1534668023, 1661587028, 1696896187, |
92 1866841746, 2032089723, 2147483647}; | 92 1866841746, 2032089723, 2147483647}; |
93 | 93 |
94 | 94 |
95 const double kNaNs[] = {-std::numeric_limits<double>::quiet_NaN(), | 95 const double kNaNs[] = {-std::numeric_limits<double>::quiet_NaN(), |
96 std::numeric_limits<double>::quiet_NaN(), | 96 std::numeric_limits<double>::quiet_NaN(), |
97 bit_cast<double>(V8_UINT64_C(0x7FFFFFFFFFFFFFFF)), | 97 bit_cast<double>(V8_UINT64_C(0x7FFFFFFFFFFFFFFF)), |
98 bit_cast<double>(V8_UINT64_C(0xFFFFFFFFFFFFFFFF))}; | 98 bit_cast<double>(V8_UINT64_C(0xFFFFFFFFFFFFFFFF))}; |
99 | 99 |
100 const CheckForMinusZeroMode kCheckForMinusZeroModes[] = { | |
101 CheckForMinusZeroMode::kDontCheckForMinusZero, | |
102 CheckForMinusZeroMode::kCheckForMinusZero}; | |
103 | |
104 } // namespace | 100 } // namespace |
105 | 101 |
106 | 102 |
107 // ----------------------------------------------------------------------------- | 103 // ----------------------------------------------------------------------------- |
108 // BooleanNot | 104 // BooleanNot |
109 | 105 |
110 | 106 |
111 TEST_F(SimplifiedOperatorReducerTest, BooleanNotWithBooleanNot) { | 107 TEST_F(SimplifiedOperatorReducerTest, BooleanNotWithBooleanNot) { |
112 Node* param0 = Parameter(0); | 108 Node* param0 = Parameter(0); |
113 Reduction reduction = Reduce( | 109 Reduction reduction = Reduce( |
(...skipping 70 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
184 simplified()->ChangeTaggedToBit(), | 180 simplified()->ChangeTaggedToBit(), |
185 graph()->NewNode(simplified()->ChangeBitToTagged(), param0))); | 181 graph()->NewNode(simplified()->ChangeBitToTagged(), param0))); |
186 ASSERT_TRUE(reduction.Changed()); | 182 ASSERT_TRUE(reduction.Changed()); |
187 EXPECT_EQ(param0, reduction.replacement()); | 183 EXPECT_EQ(param0, reduction.replacement()); |
188 } | 184 } |
189 | 185 |
190 // ----------------------------------------------------------------------------- | 186 // ----------------------------------------------------------------------------- |
191 // ChangeFloat64ToTagged | 187 // ChangeFloat64ToTagged |
192 | 188 |
193 TEST_F(SimplifiedOperatorReducerTest, ChangeFloat64ToTaggedWithConstant) { | 189 TEST_F(SimplifiedOperatorReducerTest, ChangeFloat64ToTaggedWithConstant) { |
194 TRACED_FOREACH(CheckForMinusZeroMode, mode, kCheckForMinusZeroModes) { | 190 TRACED_FOREACH(double, n, kFloat64Values) { |
195 TRACED_FOREACH(double, n, kFloat64Values) { | 191 Reduction reduction = Reduce(graph()->NewNode( |
196 Reduction reduction = Reduce(graph()->NewNode( | 192 simplified()->ChangeFloat64ToTagged(), Float64Constant(n))); |
197 simplified()->ChangeFloat64ToTagged(mode), Float64Constant(n))); | 193 ASSERT_TRUE(reduction.Changed()); |
198 ASSERT_TRUE(reduction.Changed()); | 194 EXPECT_THAT(reduction.replacement(), IsNumberConstant(BitEq(n))); |
199 EXPECT_THAT(reduction.replacement(), IsNumberConstant(BitEq(n))); | |
200 } | |
201 } | 195 } |
202 } | 196 } |
203 | 197 |
204 // ----------------------------------------------------------------------------- | 198 // ----------------------------------------------------------------------------- |
205 // ChangeInt32ToTagged | 199 // ChangeInt32ToTagged |
206 | 200 |
207 | 201 |
208 TEST_F(SimplifiedOperatorReducerTest, ChangeInt32ToTaggedWithConstant) { | 202 TEST_F(SimplifiedOperatorReducerTest, ChangeInt32ToTaggedWithConstant) { |
209 TRACED_FOREACH(int32_t, n, kInt32Values) { | 203 TRACED_FOREACH(int32_t, n, kInt32Values) { |
210 Reduction reduction = Reduce(graph()->NewNode( | 204 Reduction reduction = Reduce(graph()->NewNode( |
211 simplified()->ChangeInt32ToTagged(), Int32Constant(n))); | 205 simplified()->ChangeInt32ToTagged(), Int32Constant(n))); |
212 ASSERT_TRUE(reduction.Changed()); | 206 ASSERT_TRUE(reduction.Changed()); |
213 EXPECT_THAT(reduction.replacement(), IsNumberConstant(BitEq(FastI2D(n)))); | 207 EXPECT_THAT(reduction.replacement(), IsNumberConstant(BitEq(FastI2D(n)))); |
214 } | 208 } |
215 } | 209 } |
216 | 210 |
217 | 211 |
218 // ----------------------------------------------------------------------------- | 212 // ----------------------------------------------------------------------------- |
219 // ChangeTaggedToFloat64 | 213 // ChangeTaggedToFloat64 |
220 | 214 |
221 | 215 |
222 TEST_F(SimplifiedOperatorReducerTest, | 216 TEST_F(SimplifiedOperatorReducerTest, |
223 ChangeTaggedToFloat64WithChangeFloat64ToTagged) { | 217 ChangeTaggedToFloat64WithChangeFloat64ToTagged) { |
224 Node* param0 = Parameter(0); | 218 Node* param0 = Parameter(0); |
225 TRACED_FOREACH(CheckForMinusZeroMode, mode, kCheckForMinusZeroModes) { | 219 Reduction reduction = Reduce(graph()->NewNode( |
226 Reduction reduction = Reduce(graph()->NewNode( | 220 simplified()->ChangeTaggedToFloat64(), |
227 simplified()->ChangeTaggedToFloat64(), | 221 graph()->NewNode(simplified()->ChangeFloat64ToTagged(), param0))); |
228 graph()->NewNode(simplified()->ChangeFloat64ToTagged(mode), param0))); | 222 ASSERT_TRUE(reduction.Changed()); |
229 ASSERT_TRUE(reduction.Changed()); | 223 EXPECT_EQ(param0, reduction.replacement()); |
230 EXPECT_EQ(param0, reduction.replacement()); | |
231 } | |
232 } | 224 } |
233 | 225 |
234 TEST_F(SimplifiedOperatorReducerTest, | 226 TEST_F(SimplifiedOperatorReducerTest, |
235 ChangeTaggedToFloat64WithChangeInt32ToTagged) { | 227 ChangeTaggedToFloat64WithChangeInt32ToTagged) { |
236 Node* param0 = Parameter(0); | 228 Node* param0 = Parameter(0); |
237 Reduction reduction = Reduce(graph()->NewNode( | 229 Reduction reduction = Reduce(graph()->NewNode( |
238 simplified()->ChangeTaggedToFloat64(), | 230 simplified()->ChangeTaggedToFloat64(), |
239 graph()->NewNode(simplified()->ChangeInt32ToTagged(), param0))); | 231 graph()->NewNode(simplified()->ChangeInt32ToTagged(), param0))); |
240 ASSERT_TRUE(reduction.Changed()); | 232 ASSERT_TRUE(reduction.Changed()); |
241 EXPECT_THAT(reduction.replacement(), IsChangeInt32ToFloat64(param0)); | 233 EXPECT_THAT(reduction.replacement(), IsChangeInt32ToFloat64(param0)); |
(...skipping 30 matching lines...) Expand all Loading... |
272 } | 264 } |
273 } | 265 } |
274 | 266 |
275 | 267 |
276 // ----------------------------------------------------------------------------- | 268 // ----------------------------------------------------------------------------- |
277 // ChangeTaggedToInt32 | 269 // ChangeTaggedToInt32 |
278 | 270 |
279 TEST_F(SimplifiedOperatorReducerTest, | 271 TEST_F(SimplifiedOperatorReducerTest, |
280 ChangeTaggedToInt32WithChangeFloat64ToTagged) { | 272 ChangeTaggedToInt32WithChangeFloat64ToTagged) { |
281 Node* param0 = Parameter(0); | 273 Node* param0 = Parameter(0); |
282 TRACED_FOREACH(CheckForMinusZeroMode, mode, kCheckForMinusZeroModes) { | 274 Reduction reduction = Reduce(graph()->NewNode( |
283 Reduction reduction = Reduce(graph()->NewNode( | 275 simplified()->ChangeTaggedToInt32(), |
284 simplified()->ChangeTaggedToInt32(), | 276 graph()->NewNode(simplified()->ChangeFloat64ToTagged(), param0))); |
285 graph()->NewNode(simplified()->ChangeFloat64ToTagged(mode), param0))); | 277 ASSERT_TRUE(reduction.Changed()); |
286 ASSERT_TRUE(reduction.Changed()); | 278 EXPECT_THAT(reduction.replacement(), IsChangeFloat64ToInt32(param0)); |
287 EXPECT_THAT(reduction.replacement(), IsChangeFloat64ToInt32(param0)); | |
288 } | |
289 } | 279 } |
290 | 280 |
291 TEST_F(SimplifiedOperatorReducerTest, | 281 TEST_F(SimplifiedOperatorReducerTest, |
292 ChangeTaggedToInt32WithChangeInt32ToTagged) { | 282 ChangeTaggedToInt32WithChangeInt32ToTagged) { |
293 Node* param0 = Parameter(0); | 283 Node* param0 = Parameter(0); |
294 Reduction reduction = Reduce(graph()->NewNode( | 284 Reduction reduction = Reduce(graph()->NewNode( |
295 simplified()->ChangeTaggedToInt32(), | 285 simplified()->ChangeTaggedToInt32(), |
296 graph()->NewNode(simplified()->ChangeInt32ToTagged(), param0))); | 286 graph()->NewNode(simplified()->ChangeInt32ToTagged(), param0))); |
297 ASSERT_TRUE(reduction.Changed()); | 287 ASSERT_TRUE(reduction.Changed()); |
298 EXPECT_EQ(param0, reduction.replacement()); | 288 EXPECT_EQ(param0, reduction.replacement()); |
299 } | 289 } |
300 | 290 |
301 | 291 |
302 // ----------------------------------------------------------------------------- | 292 // ----------------------------------------------------------------------------- |
303 // ChangeTaggedToUint32 | 293 // ChangeTaggedToUint32 |
304 | 294 |
305 TEST_F(SimplifiedOperatorReducerTest, | 295 TEST_F(SimplifiedOperatorReducerTest, |
306 ChangeTaggedToUint32WithChangeFloat64ToTagged) { | 296 ChangeTaggedToUint32WithChangeFloat64ToTagged) { |
307 Node* param0 = Parameter(0); | 297 Node* param0 = Parameter(0); |
308 TRACED_FOREACH(CheckForMinusZeroMode, mode, kCheckForMinusZeroModes) { | 298 Reduction reduction = Reduce(graph()->NewNode( |
309 Reduction reduction = Reduce(graph()->NewNode( | 299 simplified()->ChangeTaggedToUint32(), |
310 simplified()->ChangeTaggedToUint32(), | 300 graph()->NewNode(simplified()->ChangeFloat64ToTagged(), param0))); |
311 graph()->NewNode(simplified()->ChangeFloat64ToTagged(mode), param0))); | 301 ASSERT_TRUE(reduction.Changed()); |
312 ASSERT_TRUE(reduction.Changed()); | 302 EXPECT_THAT(reduction.replacement(), IsChangeFloat64ToUint32(param0)); |
313 EXPECT_THAT(reduction.replacement(), IsChangeFloat64ToUint32(param0)); | |
314 } | |
315 } | 303 } |
316 | 304 |
317 TEST_F(SimplifiedOperatorReducerTest, | 305 TEST_F(SimplifiedOperatorReducerTest, |
318 ChangeTaggedToUint32WithChangeUint32ToTagged) { | 306 ChangeTaggedToUint32WithChangeUint32ToTagged) { |
319 Node* param0 = Parameter(0); | 307 Node* param0 = Parameter(0); |
320 Reduction reduction = Reduce(graph()->NewNode( | 308 Reduction reduction = Reduce(graph()->NewNode( |
321 simplified()->ChangeTaggedToUint32(), | 309 simplified()->ChangeTaggedToUint32(), |
322 graph()->NewNode(simplified()->ChangeUint32ToTagged(), param0))); | 310 graph()->NewNode(simplified()->ChangeUint32ToTagged(), param0))); |
323 ASSERT_TRUE(reduction.Changed()); | 311 ASSERT_TRUE(reduction.Changed()); |
324 EXPECT_EQ(param0, reduction.replacement()); | 312 EXPECT_EQ(param0, reduction.replacement()); |
325 } | 313 } |
326 | 314 |
327 | 315 |
328 // ----------------------------------------------------------------------------- | 316 // ----------------------------------------------------------------------------- |
329 // TruncateTaggedToWord32 | 317 // TruncateTaggedToWord32 |
330 | 318 |
331 TEST_F(SimplifiedOperatorReducerTest, | 319 TEST_F(SimplifiedOperatorReducerTest, |
332 TruncateTaggedToWord3WithChangeFloat64ToTagged) { | 320 TruncateTaggedToWord3WithChangeFloat64ToTagged) { |
333 Node* param0 = Parameter(0); | 321 Node* param0 = Parameter(0); |
334 TRACED_FOREACH(CheckForMinusZeroMode, mode, kCheckForMinusZeroModes) { | 322 Reduction reduction = Reduce(graph()->NewNode( |
335 Reduction reduction = Reduce(graph()->NewNode( | 323 simplified()->TruncateTaggedToWord32(), |
336 simplified()->TruncateTaggedToWord32(), | 324 graph()->NewNode(simplified()->ChangeFloat64ToTagged(), param0))); |
337 graph()->NewNode(simplified()->ChangeFloat64ToTagged(mode), param0))); | 325 ASSERT_TRUE(reduction.Changed()); |
338 ASSERT_TRUE(reduction.Changed()); | 326 EXPECT_THAT(reduction.replacement(), IsTruncateFloat64ToWord32(param0)); |
339 EXPECT_THAT(reduction.replacement(), IsTruncateFloat64ToWord32(param0)); | |
340 } | |
341 } | 327 } |
342 | 328 |
343 TEST_F(SimplifiedOperatorReducerTest, TruncateTaggedToWord32WithConstant) { | 329 TEST_F(SimplifiedOperatorReducerTest, TruncateTaggedToWord32WithConstant) { |
344 TRACED_FOREACH(double, n, kFloat64Values) { | 330 TRACED_FOREACH(double, n, kFloat64Values) { |
345 Reduction reduction = Reduce(graph()->NewNode( | 331 Reduction reduction = Reduce(graph()->NewNode( |
346 simplified()->TruncateTaggedToWord32(), NumberConstant(n))); | 332 simplified()->TruncateTaggedToWord32(), NumberConstant(n))); |
347 ASSERT_TRUE(reduction.Changed()); | 333 ASSERT_TRUE(reduction.Changed()); |
348 EXPECT_THAT(reduction.replacement(), IsInt32Constant(DoubleToInt32(n))); | 334 EXPECT_THAT(reduction.replacement(), IsInt32Constant(DoubleToInt32(n))); |
349 } | 335 } |
350 } | 336 } |
(...skipping 127 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
478 Reduction reduction = Reduce( | 464 Reduction reduction = Reduce( |
479 graph()->NewNode(simplified()->ObjectIsSmi(), NumberConstant(n))); | 465 graph()->NewNode(simplified()->ObjectIsSmi(), NumberConstant(n))); |
480 ASSERT_TRUE(reduction.Changed()); | 466 ASSERT_TRUE(reduction.Changed()); |
481 EXPECT_THAT(reduction.replacement(), IsBooleanConstant(IsSmiDouble(n))); | 467 EXPECT_THAT(reduction.replacement(), IsBooleanConstant(IsSmiDouble(n))); |
482 } | 468 } |
483 } | 469 } |
484 | 470 |
485 } // namespace compiler | 471 } // namespace compiler |
486 } // namespace internal | 472 } // namespace internal |
487 } // namespace v8 | 473 } // namespace v8 |
OLD | NEW |