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/common-operator.h" |
5 #include "src/compiler/graph.h" | 6 #include "src/compiler/graph.h" |
6 #include "src/compiler/node.h" | 7 #include "src/compiler/node.h" |
7 #include "src/compiler/operator.h" | 8 #include "src/compiler/operator.h" |
8 #include "test/unittests/compiler/graph-reducer-unittest.h" | 9 #include "test/unittests/compiler/graph-reducer-unittest.h" |
9 #include "test/unittests/test-utils.h" | 10 #include "test/unittests/test-utils.h" |
10 | 11 |
11 using testing::_; | 12 using testing::_; |
12 using testing::DefaultValue; | 13 using testing::DefaultValue; |
| 14 using testing::ElementsAre; |
13 using testing::Return; | 15 using testing::Return; |
14 using testing::Sequence; | 16 using testing::Sequence; |
15 using testing::StrictMock; | 17 using testing::StrictMock; |
| 18 using testing::UnorderedElementsAre; |
16 | 19 |
17 namespace v8 { | 20 namespace v8 { |
18 namespace internal { | 21 namespace internal { |
19 namespace compiler { | 22 namespace compiler { |
20 | 23 |
21 namespace { | 24 namespace { |
22 | 25 |
23 struct TestOperator : public Operator { | 26 struct TestOperator : public Operator { |
24 TestOperator(Operator::Opcode opcode, Operator::Properties properties, | 27 TestOperator(Operator::Opcode opcode, Operator::Properties properties, |
25 const char* op_name, size_t value_in, size_t value_out) | 28 const char* op_name, size_t value_in, size_t value_out) |
(...skipping 231 matching lines...) Loading... |
257 DummyReducer r(&e); | 260 DummyReducer r(&e); |
258 Node* node0 = graph()->NewNode(&kOpA0); | 261 Node* node0 = graph()->NewNode(&kOpA0); |
259 Node* node1 = graph()->NewNode(&kOpA1, node0); | 262 Node* node1 = graph()->NewNode(&kOpA1, node0); |
260 EXPECT_CALL(e, Revisit(node0)); | 263 EXPECT_CALL(e, Revisit(node0)); |
261 EXPECT_CALL(e, Revisit(node1)); | 264 EXPECT_CALL(e, Revisit(node1)); |
262 EXPECT_FALSE(r.Reduce(node0).Changed()); | 265 EXPECT_FALSE(r.Reduce(node0).Changed()); |
263 EXPECT_FALSE(r.Reduce(node1).Changed()); | 266 EXPECT_FALSE(r.Reduce(node1).Changed()); |
264 } | 267 } |
265 | 268 |
266 | 269 |
| 270 namespace { |
| 271 |
| 272 struct ReplaceWithValueReducer final : public AdvancedReducer { |
| 273 explicit ReplaceWithValueReducer(Editor* editor) : AdvancedReducer(editor) {} |
| 274 Reduction Reduce(Node* node) final { return NoChange(); } |
| 275 using AdvancedReducer::ReplaceWithValue; |
| 276 }; |
| 277 |
| 278 const Operator kMockOperator(IrOpcode::kDead, Operator::kNoProperties, |
| 279 "MockOperator", 0, 0, 0, 1, 0, 0); |
| 280 const Operator kMockOpEffect(IrOpcode::kDead, Operator::kNoProperties, |
| 281 "MockOpEffect", 0, 1, 0, 1, 1, 0); |
| 282 const Operator kMockOpControl(IrOpcode::kDead, Operator::kNoProperties, |
| 283 "MockOpControl", 0, 0, 1, 1, 0, 1); |
| 284 |
| 285 const IfExceptionHint kNoHint = IfExceptionHint::kLocallyCaught; |
| 286 |
| 287 } // namespace |
| 288 |
| 289 |
| 290 TEST_F(AdvancedReducerTest, ReplaceWithValue_ValueUse) { |
| 291 CommonOperatorBuilder common(zone()); |
| 292 Node* node = graph()->NewNode(&kMockOperator); |
| 293 Node* use_value = graph()->NewNode(common.Return(), node); |
| 294 Node* replacement = graph()->NewNode(&kMockOperator); |
| 295 GraphReducer graph_reducer(graph(), nullptr, nullptr, zone()); |
| 296 ReplaceWithValueReducer r(&graph_reducer); |
| 297 r.ReplaceWithValue(node, replacement); |
| 298 EXPECT_EQ(replacement, use_value->InputAt(0)); |
| 299 EXPECT_EQ(0, node->UseCount()); |
| 300 EXPECT_EQ(1, replacement->UseCount()); |
| 301 EXPECT_THAT(replacement->uses(), ElementsAre(use_value)); |
| 302 } |
| 303 |
| 304 |
| 305 TEST_F(AdvancedReducerTest, ReplaceWithValue_EffectUse) { |
| 306 CommonOperatorBuilder common(zone()); |
| 307 Node* start = graph()->NewNode(common.Start(1)); |
| 308 Node* node = graph()->NewNode(&kMockOpEffect, start); |
| 309 Node* use_effect = graph()->NewNode(common.EffectPhi(1), node); |
| 310 Node* replacement = graph()->NewNode(&kMockOperator); |
| 311 GraphReducer graph_reducer(graph(), nullptr, nullptr, zone()); |
| 312 ReplaceWithValueReducer r(&graph_reducer); |
| 313 r.ReplaceWithValue(node, replacement); |
| 314 EXPECT_EQ(start, use_effect->InputAt(0)); |
| 315 EXPECT_EQ(0, node->UseCount()); |
| 316 EXPECT_EQ(2, start->UseCount()); |
| 317 EXPECT_EQ(0, replacement->UseCount()); |
| 318 EXPECT_THAT(start->uses(), UnorderedElementsAre(use_effect, node)); |
| 319 } |
| 320 |
| 321 |
| 322 TEST_F(AdvancedReducerTest, ReplaceWithValue_ControlUse1) { |
| 323 CommonOperatorBuilder common(zone()); |
| 324 Node* start = graph()->NewNode(common.Start(1)); |
| 325 Node* node = graph()->NewNode(&kMockOpControl, start); |
| 326 Node* success = graph()->NewNode(common.IfSuccess(), node); |
| 327 Node* use_control = graph()->NewNode(common.Merge(1), success); |
| 328 Node* replacement = graph()->NewNode(&kMockOperator); |
| 329 GraphReducer graph_reducer(graph(), nullptr, nullptr, zone()); |
| 330 ReplaceWithValueReducer r(&graph_reducer); |
| 331 r.ReplaceWithValue(node, replacement); |
| 332 EXPECT_EQ(start, use_control->InputAt(0)); |
| 333 EXPECT_EQ(0, node->UseCount()); |
| 334 EXPECT_EQ(2, start->UseCount()); |
| 335 EXPECT_EQ(0, replacement->UseCount()); |
| 336 EXPECT_THAT(start->uses(), UnorderedElementsAre(use_control, node)); |
| 337 } |
| 338 |
| 339 |
| 340 TEST_F(AdvancedReducerTest, ReplaceWithValue_ControlUse2) { |
| 341 CommonOperatorBuilder common(zone()); |
| 342 Node* start = graph()->NewNode(common.Start(1)); |
| 343 Node* dead = graph()->NewNode(&kMockOperator); |
| 344 Node* node = graph()->NewNode(&kMockOpControl, start); |
| 345 Node* success = graph()->NewNode(common.IfSuccess(), node); |
| 346 Node* exception = graph()->NewNode(common.IfException(kNoHint), node); |
| 347 Node* use_control = graph()->NewNode(common.Merge(1), success); |
| 348 Node* use_exception_control = graph()->NewNode(common.Merge(1), exception); |
| 349 Node* replacement = graph()->NewNode(&kMockOperator); |
| 350 GraphReducer graph_reducer(graph(), nullptr, dead, zone()); |
| 351 ReplaceWithValueReducer r(&graph_reducer); |
| 352 r.ReplaceWithValue(node, replacement); |
| 353 EXPECT_EQ(start, use_control->InputAt(0)); |
| 354 EXPECT_EQ(dead, use_exception_control->InputAt(0)); |
| 355 EXPECT_EQ(0, node->UseCount()); |
| 356 EXPECT_EQ(2, start->UseCount()); |
| 357 EXPECT_EQ(1, dead->UseCount()); |
| 358 EXPECT_EQ(0, replacement->UseCount()); |
| 359 EXPECT_THAT(start->uses(), UnorderedElementsAre(use_control, node)); |
| 360 EXPECT_THAT(dead->uses(), ElementsAre(use_exception_control)); |
| 361 } |
| 362 |
| 363 |
| 364 TEST_F(AdvancedReducerTest, ReplaceWithValue_ControlUse3) { |
| 365 CommonOperatorBuilder common(zone()); |
| 366 Node* start = graph()->NewNode(common.Start(1)); |
| 367 Node* dead = graph()->NewNode(&kMockOperator); |
| 368 Node* node = graph()->NewNode(&kMockOpControl, start); |
| 369 Node* success = graph()->NewNode(common.IfSuccess(), node); |
| 370 Node* exception = graph()->NewNode(common.IfException(kNoHint), node); |
| 371 Node* use_control = graph()->NewNode(common.Merge(1), success); |
| 372 Node* use_exception_value = graph()->NewNode(common.Return(), exception); |
| 373 Node* replacement = graph()->NewNode(&kMockOperator); |
| 374 GraphReducer graph_reducer(graph(), dead, nullptr, zone()); |
| 375 ReplaceWithValueReducer r(&graph_reducer); |
| 376 r.ReplaceWithValue(node, replacement); |
| 377 EXPECT_EQ(start, use_control->InputAt(0)); |
| 378 EXPECT_EQ(dead, use_exception_value->InputAt(0)); |
| 379 EXPECT_EQ(0, node->UseCount()); |
| 380 EXPECT_EQ(2, start->UseCount()); |
| 381 EXPECT_EQ(1, dead->UseCount()); |
| 382 EXPECT_EQ(0, replacement->UseCount()); |
| 383 EXPECT_THAT(start->uses(), UnorderedElementsAre(use_control, node)); |
| 384 EXPECT_THAT(dead->uses(), ElementsAre(use_exception_value)); |
| 385 } |
| 386 |
| 387 |
267 class GraphReducerTest : public TestWithZone { | 388 class GraphReducerTest : public TestWithZone { |
268 public: | 389 public: |
269 GraphReducerTest() : graph_(zone()) {} | 390 GraphReducerTest() : graph_(zone()) {} |
270 | 391 |
271 static void SetUpTestCase() { | 392 static void SetUpTestCase() { |
272 TestWithZone::SetUpTestCase(); | 393 TestWithZone::SetUpTestCase(); |
273 DefaultValue<Reduction>::Set(Reducer::NoChange()); | 394 DefaultValue<Reduction>::Set(Reducer::NoChange()); |
274 } | 395 } |
275 | 396 |
276 static void TearDownTestCase() { | 397 static void TearDownTestCase() { |
277 DefaultValue<Reduction>::Clear(); | 398 DefaultValue<Reduction>::Clear(); |
278 TestWithZone::TearDownTestCase(); | 399 TestWithZone::TearDownTestCase(); |
279 } | 400 } |
280 | 401 |
281 protected: | 402 protected: |
282 void ReduceNode(Node* node, Reducer* r) { | 403 void ReduceNode(Node* node, Reducer* r) { |
283 GraphReducer reducer(graph(), zone()); | 404 GraphReducer reducer(graph(), dead_value(), dead_control(), zone()); |
284 reducer.AddReducer(r); | 405 reducer.AddReducer(r); |
285 reducer.ReduceNode(node); | 406 reducer.ReduceNode(node); |
286 } | 407 } |
287 | 408 |
288 void ReduceNode(Node* node, Reducer* r1, Reducer* r2) { | 409 void ReduceNode(Node* node, Reducer* r1, Reducer* r2) { |
289 GraphReducer reducer(graph(), zone()); | 410 GraphReducer reducer(graph(), dead_value(), dead_control(), zone()); |
290 reducer.AddReducer(r1); | 411 reducer.AddReducer(r1); |
291 reducer.AddReducer(r2); | 412 reducer.AddReducer(r2); |
292 reducer.ReduceNode(node); | 413 reducer.ReduceNode(node); |
293 } | 414 } |
294 | 415 |
295 void ReduceNode(Node* node, Reducer* r1, Reducer* r2, Reducer* r3) { | 416 void ReduceNode(Node* node, Reducer* r1, Reducer* r2, Reducer* r3) { |
296 GraphReducer reducer(graph(), zone()); | 417 GraphReducer reducer(graph(), dead_value(), dead_control(), zone()); |
297 reducer.AddReducer(r1); | 418 reducer.AddReducer(r1); |
298 reducer.AddReducer(r2); | 419 reducer.AddReducer(r2); |
299 reducer.AddReducer(r3); | 420 reducer.AddReducer(r3); |
300 reducer.ReduceNode(node); | 421 reducer.ReduceNode(node); |
301 } | 422 } |
302 | 423 |
303 void ReduceGraph(Reducer* r1) { | 424 void ReduceGraph(Reducer* r1) { |
304 GraphReducer reducer(graph(), zone()); | 425 GraphReducer reducer(graph(), dead_value(), dead_control(), zone()); |
305 reducer.AddReducer(r1); | 426 reducer.AddReducer(r1); |
306 reducer.ReduceGraph(); | 427 reducer.ReduceGraph(); |
307 } | 428 } |
308 | 429 |
309 void ReduceGraph(Reducer* r1, Reducer* r2) { | 430 void ReduceGraph(Reducer* r1, Reducer* r2) { |
310 GraphReducer reducer(graph(), zone()); | 431 GraphReducer reducer(graph(), dead_value(), dead_control(), zone()); |
311 reducer.AddReducer(r1); | 432 reducer.AddReducer(r1); |
312 reducer.AddReducer(r2); | 433 reducer.AddReducer(r2); |
313 reducer.ReduceGraph(); | 434 reducer.ReduceGraph(); |
314 } | 435 } |
315 | 436 |
316 void ReduceGraph(Reducer* r1, Reducer* r2, Reducer* r3) { | 437 void ReduceGraph(Reducer* r1, Reducer* r2, Reducer* r3) { |
317 GraphReducer reducer(graph(), zone()); | 438 GraphReducer reducer(graph(), dead_value(), dead_control(), zone()); |
318 reducer.AddReducer(r1); | 439 reducer.AddReducer(r1); |
319 reducer.AddReducer(r2); | 440 reducer.AddReducer(r2); |
320 reducer.AddReducer(r3); | 441 reducer.AddReducer(r3); |
321 reducer.ReduceGraph(); | 442 reducer.ReduceGraph(); |
322 } | 443 } |
323 | 444 |
324 Graph* graph() { return &graph_; } | 445 Graph* graph() { return &graph_; } |
| 446 Node* dead_value() { return nullptr; } |
| 447 Node* dead_control() { return nullptr; } |
325 | 448 |
326 private: | 449 private: |
327 Graph graph_; | 450 Graph graph_; |
328 }; | 451 }; |
329 | 452 |
330 | 453 |
331 TEST_F(GraphReducerTest, NodeIsDeadAfterReplace) { | 454 TEST_F(GraphReducerTest, NodeIsDeadAfterReplace) { |
332 StrictMock<MockReducer> r; | 455 StrictMock<MockReducer> r; |
333 Node* node0 = graph()->NewNode(&kOpA0); | 456 Node* node0 = graph()->NewNode(&kOpA0); |
334 Node* node1 = graph()->NewNode(&kOpA1, node0); | 457 Node* node1 = graph()->NewNode(&kOpA1, node0); |
(...skipping 392 matching lines...) Loading... |
727 EXPECT_EQ(&kOpC0, n1->op()); | 850 EXPECT_EQ(&kOpC0, n1->op()); |
728 EXPECT_EQ(&kOpC1, end->op()); | 851 EXPECT_EQ(&kOpC1, end->op()); |
729 EXPECT_EQ(n1, end->InputAt(0)); | 852 EXPECT_EQ(n1, end->InputAt(0)); |
730 } | 853 } |
731 } | 854 } |
732 } | 855 } |
733 | 856 |
734 } // namespace compiler | 857 } // namespace compiler |
735 } // namespace internal | 858 } // namespace internal |
736 } // namespace v8 | 859 } // namespace v8 |
OLD | NEW |