| // Copyright 2015 the V8 project authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "src/compiler/access-builder.h" |
| #include "src/compiler/common-operator.h" |
| #include "src/compiler/graph.h" |
| #include "src/compiler/graph-visualizer.h" |
| #include "src/compiler/js-operator.h" |
| #include "src/compiler/node.h" |
| #include "src/compiler/opcodes.h" |
| #include "src/compiler/operator.h" |
| #include "src/compiler/schedule.h" |
| #include "src/compiler/scheduler.h" |
| #include "src/compiler/simplified-operator.h" |
| #include "src/compiler/source-position.h" |
| #include "src/compiler/verifier.h" |
| #include "test/unittests/compiler/compiler-test-utils.h" |
| #include "test/unittests/test-utils.h" |
| #include "testing/gmock/include/gmock/gmock.h" |
| |
| using testing::AnyOf; |
| |
| namespace v8 { |
| namespace internal { |
| namespace compiler { |
| |
| class SchedulerTest : public TestWithIsolateAndZone { |
| public: |
| SchedulerTest() |
| : graph_(zone()), common_(zone()), simplified_(zone()), js_(zone()) {} |
| |
| Schedule* ComputeAndVerifySchedule(size_t expected) { |
| if (FLAG_trace_turbo) { |
| OFStream os(stdout); |
| SourcePositionTable table(graph()); |
| os << AsJSON(*graph(), &table); |
| } |
| |
| Schedule* schedule = |
| Scheduler::ComputeSchedule(zone(), graph(), Scheduler::kSplitNodes); |
| |
| if (FLAG_trace_turbo_scheduler) { |
| OFStream os(stdout); |
| os << *schedule << std::endl; |
| } |
| ScheduleVerifier::Run(schedule); |
| EXPECT_EQ(expected, GetScheduledNodeCount(schedule)); |
| return schedule; |
| } |
| |
| size_t GetScheduledNodeCount(const Schedule* schedule) { |
| size_t node_count = 0; |
| for (auto block : *schedule->rpo_order()) { |
| node_count += block->NodeCount(); |
| if (block->control() != BasicBlock::kNone) ++node_count; |
| } |
| return node_count; |
| } |
| |
| Graph* graph() { return &graph_; } |
| CommonOperatorBuilder* common() { return &common_; } |
| SimplifiedOperatorBuilder* simplified() { return &simplified_; } |
| JSOperatorBuilder* js() { return &js_; } |
| |
| private: |
| Graph graph_; |
| CommonOperatorBuilder common_; |
| SimplifiedOperatorBuilder simplified_; |
| JSOperatorBuilder js_; |
| }; |
| |
| |
| class SchedulerRPOTest : public SchedulerTest { |
| public: |
| SchedulerRPOTest() {} |
| |
| // TODO(titzer): pull RPO tests out to their own file. |
| void CheckRPONumbers(BasicBlockVector* order, size_t expected, |
| bool loops_allowed) { |
| CHECK(expected == order->size()); |
| for (int i = 0; i < static_cast<int>(order->size()); i++) { |
| CHECK(order->at(i)->rpo_number() == i); |
| if (!loops_allowed) { |
| CHECK(!order->at(i)->loop_end()); |
| CHECK(!order->at(i)->loop_header()); |
| } |
| } |
| } |
| |
| void CheckLoop(BasicBlockVector* order, BasicBlock** blocks, int body_size) { |
| BasicBlock* header = blocks[0]; |
| BasicBlock* end = header->loop_end(); |
| CHECK(end); |
| CHECK_GT(end->rpo_number(), 0); |
| CHECK_EQ(body_size, end->rpo_number() - header->rpo_number()); |
| for (int i = 0; i < body_size; i++) { |
| CHECK_GE(blocks[i]->rpo_number(), header->rpo_number()); |
| CHECK_LT(blocks[i]->rpo_number(), end->rpo_number()); |
| CHECK(header->LoopContains(blocks[i])); |
| CHECK(header->IsLoopHeader() || blocks[i]->loop_header() == header); |
| } |
| if (header->rpo_number() > 0) { |
| CHECK_NE(order->at(header->rpo_number() - 1)->loop_header(), header); |
| } |
| if (end->rpo_number() < static_cast<int>(order->size())) { |
| CHECK_NE(order->at(end->rpo_number())->loop_header(), header); |
| } |
| } |
| |
| struct TestLoop { |
| int count; |
| BasicBlock** nodes; |
| BasicBlock* header() { return nodes[0]; } |
| BasicBlock* last() { return nodes[count - 1]; } |
| ~TestLoop() { delete[] nodes; } |
| }; |
| |
| TestLoop* CreateLoop(Schedule* schedule, int count) { |
| TestLoop* loop = new TestLoop(); |
| loop->count = count; |
| loop->nodes = new BasicBlock* [count]; |
| for (int i = 0; i < count; i++) { |
| loop->nodes[i] = schedule->NewBasicBlock(); |
| if (i > 0) { |
| schedule->AddSuccessorForTesting(loop->nodes[i - 1], loop->nodes[i]); |
| } |
| } |
| schedule->AddSuccessorForTesting(loop->nodes[count - 1], loop->nodes[0]); |
| return loop; |
| } |
| }; |
| |
| |
| namespace { |
| |
| const Operator kHeapConstant(IrOpcode::kHeapConstant, Operator::kPure, |
| "HeapConstant", 0, 0, 0, 1, 0, 0); |
| const Operator kIntAdd(IrOpcode::kInt32Add, Operator::kPure, "Int32Add", 2, 0, |
| 0, 1, 0, 0); |
| const Operator kMockCall(IrOpcode::kCall, Operator::kNoProperties, "MockCall", |
| 0, 0, 1, 1, 1, 2); |
| const Operator kMockTailCall(IrOpcode::kTailCall, Operator::kNoProperties, |
| "MockTailCall", 1, 1, 1, 0, 0, 1); |
| |
| } // namespace |
| |
| |
| // ----------------------------------------------------------------------------- |
| // Special reverse-post-order block ordering. |
| |
| |
| TEST_F(SchedulerRPOTest, Degenerate1) { |
| Schedule schedule(zone()); |
| BasicBlockVector* order = Scheduler::ComputeSpecialRPO(zone(), &schedule); |
| CheckRPONumbers(order, 1, false); |
| EXPECT_EQ(schedule.start(), order->at(0)); |
| } |
| |
| |
| TEST_F(SchedulerRPOTest, Degenerate2) { |
| Schedule schedule(zone()); |
| |
| schedule.AddGoto(schedule.start(), schedule.end()); |
| BasicBlockVector* order = Scheduler::ComputeSpecialRPO(zone(), &schedule); |
| CheckRPONumbers(order, 2, false); |
| EXPECT_EQ(schedule.start(), order->at(0)); |
| EXPECT_EQ(schedule.end(), order->at(1)); |
| } |
| |
| |
| TEST_F(SchedulerRPOTest, Line) { |
| for (int i = 0; i < 10; i++) { |
| Schedule schedule(zone()); |
| |
| BasicBlock* last = schedule.start(); |
| for (int j = 0; j < i; j++) { |
| BasicBlock* block = schedule.NewBasicBlock(); |
| block->set_deferred(i & 1); |
| schedule.AddGoto(last, block); |
| last = block; |
| } |
| BasicBlockVector* order = Scheduler::ComputeSpecialRPO(zone(), &schedule); |
| CheckRPONumbers(order, 1 + i, false); |
| |
| for (size_t i = 0; i < schedule.BasicBlockCount(); i++) { |
| BasicBlock* block = schedule.GetBlockById(BasicBlock::Id::FromSize(i)); |
| if (block->rpo_number() >= 0 && block->SuccessorCount() == 1) { |
| EXPECT_EQ(block->rpo_number() + 1, block->SuccessorAt(0)->rpo_number()); |
| } |
| } |
| } |
| } |
| |
| |
| TEST_F(SchedulerRPOTest, SelfLoop) { |
| Schedule schedule(zone()); |
| schedule.AddSuccessorForTesting(schedule.start(), schedule.start()); |
| BasicBlockVector* order = Scheduler::ComputeSpecialRPO(zone(), &schedule); |
| CheckRPONumbers(order, 1, true); |
| BasicBlock* loop[] = {schedule.start()}; |
| CheckLoop(order, loop, 1); |
| } |
| |
| |
| TEST_F(SchedulerRPOTest, EntryLoop) { |
| Schedule schedule(zone()); |
| BasicBlock* body = schedule.NewBasicBlock(); |
| schedule.AddSuccessorForTesting(schedule.start(), body); |
| schedule.AddSuccessorForTesting(body, schedule.start()); |
| BasicBlockVector* order = Scheduler::ComputeSpecialRPO(zone(), &schedule); |
| CheckRPONumbers(order, 2, true); |
| BasicBlock* loop[] = {schedule.start(), body}; |
| CheckLoop(order, loop, 2); |
| } |
| |
| |
| TEST_F(SchedulerRPOTest, EndLoop) { |
| Schedule schedule(zone()); |
| base::SmartPointer<TestLoop> loop1(CreateLoop(&schedule, 2)); |
| schedule.AddSuccessorForTesting(schedule.start(), loop1->header()); |
| BasicBlockVector* order = Scheduler::ComputeSpecialRPO(zone(), &schedule); |
| CheckRPONumbers(order, 3, true); |
| CheckLoop(order, loop1->nodes, loop1->count); |
| } |
| |
| |
| TEST_F(SchedulerRPOTest, EndLoopNested) { |
| Schedule schedule(zone()); |
| base::SmartPointer<TestLoop> loop1(CreateLoop(&schedule, 2)); |
| schedule.AddSuccessorForTesting(schedule.start(), loop1->header()); |
| schedule.AddSuccessorForTesting(loop1->last(), schedule.start()); |
| BasicBlockVector* order = Scheduler::ComputeSpecialRPO(zone(), &schedule); |
| CheckRPONumbers(order, 3, true); |
| CheckLoop(order, loop1->nodes, loop1->count); |
| } |
| |
| |
| TEST_F(SchedulerRPOTest, Diamond) { |
| Schedule schedule(zone()); |
| |
| BasicBlock* A = schedule.start(); |
| BasicBlock* B = schedule.NewBasicBlock(); |
| BasicBlock* C = schedule.NewBasicBlock(); |
| BasicBlock* D = schedule.end(); |
| |
| schedule.AddSuccessorForTesting(A, B); |
| schedule.AddSuccessorForTesting(A, C); |
| schedule.AddSuccessorForTesting(B, D); |
| schedule.AddSuccessorForTesting(C, D); |
| |
| BasicBlockVector* order = Scheduler::ComputeSpecialRPO(zone(), &schedule); |
| CheckRPONumbers(order, 4, false); |
| |
| EXPECT_EQ(0, A->rpo_number()); |
| EXPECT_THAT(B->rpo_number(), AnyOf(1, 2)); |
| EXPECT_THAT(C->rpo_number(), AnyOf(1, 2)); |
| EXPECT_EQ(3, D->rpo_number()); |
| } |
| |
| |
| TEST_F(SchedulerRPOTest, Loop1) { |
| Schedule schedule(zone()); |
| |
| BasicBlock* A = schedule.start(); |
| BasicBlock* B = schedule.NewBasicBlock(); |
| BasicBlock* C = schedule.NewBasicBlock(); |
| BasicBlock* D = schedule.end(); |
| |
| schedule.AddSuccessorForTesting(A, B); |
| schedule.AddSuccessorForTesting(B, C); |
| schedule.AddSuccessorForTesting(C, B); |
| schedule.AddSuccessorForTesting(C, D); |
| |
| BasicBlockVector* order = Scheduler::ComputeSpecialRPO(zone(), &schedule); |
| CheckRPONumbers(order, 4, true); |
| BasicBlock* loop[] = {B, C}; |
| CheckLoop(order, loop, 2); |
| } |
| |
| |
| TEST_F(SchedulerRPOTest, Loop2) { |
| Schedule schedule(zone()); |
| |
| BasicBlock* A = schedule.start(); |
| BasicBlock* B = schedule.NewBasicBlock(); |
| BasicBlock* C = schedule.NewBasicBlock(); |
| BasicBlock* D = schedule.end(); |
| |
| schedule.AddSuccessorForTesting(A, B); |
| schedule.AddSuccessorForTesting(B, C); |
| schedule.AddSuccessorForTesting(C, B); |
| schedule.AddSuccessorForTesting(B, D); |
| |
| BasicBlockVector* order = Scheduler::ComputeSpecialRPO(zone(), &schedule); |
| CheckRPONumbers(order, 4, true); |
| BasicBlock* loop[] = {B, C}; |
| CheckLoop(order, loop, 2); |
| } |
| |
| |
| TEST_F(SchedulerRPOTest, LoopN) { |
| for (int i = 0; i < 11; i++) { |
| Schedule schedule(zone()); |
| BasicBlock* A = schedule.start(); |
| BasicBlock* B = schedule.NewBasicBlock(); |
| BasicBlock* C = schedule.NewBasicBlock(); |
| BasicBlock* D = schedule.NewBasicBlock(); |
| BasicBlock* E = schedule.NewBasicBlock(); |
| BasicBlock* F = schedule.NewBasicBlock(); |
| BasicBlock* G = schedule.end(); |
| |
| schedule.AddSuccessorForTesting(A, B); |
| schedule.AddSuccessorForTesting(B, C); |
| schedule.AddSuccessorForTesting(C, D); |
| schedule.AddSuccessorForTesting(D, E); |
| schedule.AddSuccessorForTesting(E, F); |
| schedule.AddSuccessorForTesting(F, B); |
| schedule.AddSuccessorForTesting(B, G); |
| |
| // Throw in extra backedges from time to time. |
| if (i == 1) schedule.AddSuccessorForTesting(B, B); |
| if (i == 2) schedule.AddSuccessorForTesting(C, B); |
| if (i == 3) schedule.AddSuccessorForTesting(D, B); |
| if (i == 4) schedule.AddSuccessorForTesting(E, B); |
| if (i == 5) schedule.AddSuccessorForTesting(F, B); |
| |
| // Throw in extra loop exits from time to time. |
| if (i == 6) schedule.AddSuccessorForTesting(B, G); |
| if (i == 7) schedule.AddSuccessorForTesting(C, G); |
| if (i == 8) schedule.AddSuccessorForTesting(D, G); |
| if (i == 9) schedule.AddSuccessorForTesting(E, G); |
| if (i == 10) schedule.AddSuccessorForTesting(F, G); |
| |
| BasicBlockVector* order = Scheduler::ComputeSpecialRPO(zone(), &schedule); |
| CheckRPONumbers(order, 7, true); |
| BasicBlock* loop[] = {B, C, D, E, F}; |
| CheckLoop(order, loop, 5); |
| } |
| } |
| |
| |
| TEST_F(SchedulerRPOTest, LoopNest1) { |
| Schedule schedule(zone()); |
| |
| BasicBlock* A = schedule.start(); |
| BasicBlock* B = schedule.NewBasicBlock(); |
| BasicBlock* C = schedule.NewBasicBlock(); |
| BasicBlock* D = schedule.NewBasicBlock(); |
| BasicBlock* E = schedule.NewBasicBlock(); |
| BasicBlock* F = schedule.end(); |
| |
| schedule.AddSuccessorForTesting(A, B); |
| schedule.AddSuccessorForTesting(B, C); |
| schedule.AddSuccessorForTesting(C, D); |
| schedule.AddSuccessorForTesting(D, C); |
| schedule.AddSuccessorForTesting(D, E); |
| schedule.AddSuccessorForTesting(E, B); |
| schedule.AddSuccessorForTesting(E, F); |
| |
| BasicBlockVector* order = Scheduler::ComputeSpecialRPO(zone(), &schedule); |
| CheckRPONumbers(order, 6, true); |
| BasicBlock* loop1[] = {B, C, D, E}; |
| CheckLoop(order, loop1, 4); |
| |
| BasicBlock* loop2[] = {C, D}; |
| CheckLoop(order, loop2, 2); |
| } |
| |
| |
| TEST_F(SchedulerRPOTest, LoopNest2) { |
| Schedule schedule(zone()); |
| |
| BasicBlock* A = schedule.start(); |
| BasicBlock* B = schedule.NewBasicBlock(); |
| BasicBlock* C = schedule.NewBasicBlock(); |
| BasicBlock* D = schedule.NewBasicBlock(); |
| BasicBlock* E = schedule.NewBasicBlock(); |
| BasicBlock* F = schedule.NewBasicBlock(); |
| BasicBlock* G = schedule.NewBasicBlock(); |
| BasicBlock* H = schedule.end(); |
| |
| schedule.AddSuccessorForTesting(A, B); |
| schedule.AddSuccessorForTesting(B, C); |
| schedule.AddSuccessorForTesting(C, D); |
| schedule.AddSuccessorForTesting(D, E); |
| schedule.AddSuccessorForTesting(E, F); |
| schedule.AddSuccessorForTesting(F, G); |
| schedule.AddSuccessorForTesting(G, H); |
| |
| schedule.AddSuccessorForTesting(E, D); |
| schedule.AddSuccessorForTesting(F, C); |
| schedule.AddSuccessorForTesting(G, B); |
| |
| BasicBlockVector* order = Scheduler::ComputeSpecialRPO(zone(), &schedule); |
| CheckRPONumbers(order, 8, true); |
| BasicBlock* loop1[] = {B, C, D, E, F, G}; |
| CheckLoop(order, loop1, 6); |
| |
| BasicBlock* loop2[] = {C, D, E, F}; |
| CheckLoop(order, loop2, 4); |
| |
| BasicBlock* loop3[] = {D, E}; |
| CheckLoop(order, loop3, 2); |
| } |
| |
| |
| TEST_F(SchedulerRPOTest, LoopFollow1) { |
| Schedule schedule(zone()); |
| |
| base::SmartPointer<TestLoop> loop1(CreateLoop(&schedule, 1)); |
| base::SmartPointer<TestLoop> loop2(CreateLoop(&schedule, 1)); |
| |
| BasicBlock* A = schedule.start(); |
| BasicBlock* E = schedule.end(); |
| |
| schedule.AddSuccessorForTesting(A, loop1->header()); |
| schedule.AddSuccessorForTesting(loop1->header(), loop2->header()); |
| schedule.AddSuccessorForTesting(loop2->last(), E); |
| |
| BasicBlockVector* order = Scheduler::ComputeSpecialRPO(zone(), &schedule); |
| |
| EXPECT_EQ(schedule.BasicBlockCount(), order->size()); |
| CheckLoop(order, loop1->nodes, loop1->count); |
| CheckLoop(order, loop2->nodes, loop2->count); |
| } |
| |
| |
| TEST_F(SchedulerRPOTest, LoopFollow2) { |
| Schedule schedule(zone()); |
| |
| base::SmartPointer<TestLoop> loop1(CreateLoop(&schedule, 1)); |
| base::SmartPointer<TestLoop> loop2(CreateLoop(&schedule, 1)); |
| |
| BasicBlock* A = schedule.start(); |
| BasicBlock* S = schedule.NewBasicBlock(); |
| BasicBlock* E = schedule.end(); |
| |
| schedule.AddSuccessorForTesting(A, loop1->header()); |
| schedule.AddSuccessorForTesting(loop1->header(), S); |
| schedule.AddSuccessorForTesting(S, loop2->header()); |
| schedule.AddSuccessorForTesting(loop2->last(), E); |
| |
| BasicBlockVector* order = Scheduler::ComputeSpecialRPO(zone(), &schedule); |
| |
| EXPECT_EQ(schedule.BasicBlockCount(), order->size()); |
| CheckLoop(order, loop1->nodes, loop1->count); |
| CheckLoop(order, loop2->nodes, loop2->count); |
| } |
| |
| |
| TEST_F(SchedulerRPOTest, LoopFollowN) { |
| for (int size = 1; size < 5; size++) { |
| for (int exit = 0; exit < size; exit++) { |
| Schedule schedule(zone()); |
| base::SmartPointer<TestLoop> loop1(CreateLoop(&schedule, size)); |
| base::SmartPointer<TestLoop> loop2(CreateLoop(&schedule, size)); |
| BasicBlock* A = schedule.start(); |
| BasicBlock* E = schedule.end(); |
| |
| schedule.AddSuccessorForTesting(A, loop1->header()); |
| schedule.AddSuccessorForTesting(loop1->nodes[exit], loop2->header()); |
| schedule.AddSuccessorForTesting(loop2->nodes[exit], E); |
| BasicBlockVector* order = Scheduler::ComputeSpecialRPO(zone(), &schedule); |
| |
| EXPECT_EQ(schedule.BasicBlockCount(), order->size()); |
| CheckLoop(order, loop1->nodes, loop1->count); |
| CheckLoop(order, loop2->nodes, loop2->count); |
| } |
| } |
| } |
| |
| |
| TEST_F(SchedulerRPOTest, NestedLoopFollow1) { |
| Schedule schedule(zone()); |
| |
| base::SmartPointer<TestLoop> loop1(CreateLoop(&schedule, 1)); |
| base::SmartPointer<TestLoop> loop2(CreateLoop(&schedule, 1)); |
| |
| BasicBlock* A = schedule.start(); |
| BasicBlock* B = schedule.NewBasicBlock(); |
| BasicBlock* C = schedule.NewBasicBlock(); |
| BasicBlock* E = schedule.end(); |
| |
| schedule.AddSuccessorForTesting(A, B); |
| schedule.AddSuccessorForTesting(B, loop1->header()); |
| schedule.AddSuccessorForTesting(loop1->header(), loop2->header()); |
| schedule.AddSuccessorForTesting(loop2->last(), C); |
| schedule.AddSuccessorForTesting(C, E); |
| schedule.AddSuccessorForTesting(C, B); |
| |
| BasicBlockVector* order = Scheduler::ComputeSpecialRPO(zone(), &schedule); |
| |
| EXPECT_EQ(schedule.BasicBlockCount(), order->size()); |
| CheckLoop(order, loop1->nodes, loop1->count); |
| CheckLoop(order, loop2->nodes, loop2->count); |
| |
| BasicBlock* loop3[] = {B, loop1->nodes[0], loop2->nodes[0], C}; |
| CheckLoop(order, loop3, 4); |
| } |
| |
| |
| TEST_F(SchedulerRPOTest, LoopBackedges1) { |
| int size = 8; |
| for (int i = 0; i < size; i++) { |
| for (int j = 0; j < size; j++) { |
| Schedule schedule(zone()); |
| BasicBlock* A = schedule.start(); |
| BasicBlock* E = schedule.end(); |
| |
| base::SmartPointer<TestLoop> loop1(CreateLoop(&schedule, size)); |
| schedule.AddSuccessorForTesting(A, loop1->header()); |
| schedule.AddSuccessorForTesting(loop1->last(), E); |
| |
| schedule.AddSuccessorForTesting(loop1->nodes[i], loop1->header()); |
| schedule.AddSuccessorForTesting(loop1->nodes[j], E); |
| |
| BasicBlockVector* order = Scheduler::ComputeSpecialRPO(zone(), &schedule); |
| CheckRPONumbers(order, schedule.BasicBlockCount(), true); |
| CheckLoop(order, loop1->nodes, loop1->count); |
| } |
| } |
| } |
| |
| |
| TEST_F(SchedulerRPOTest, LoopOutedges1) { |
| int size = 8; |
| for (int i = 0; i < size; i++) { |
| for (int j = 0; j < size; j++) { |
| Schedule schedule(zone()); |
| BasicBlock* A = schedule.start(); |
| BasicBlock* D = schedule.NewBasicBlock(); |
| BasicBlock* E = schedule.end(); |
| |
| base::SmartPointer<TestLoop> loop1(CreateLoop(&schedule, size)); |
| schedule.AddSuccessorForTesting(A, loop1->header()); |
| schedule.AddSuccessorForTesting(loop1->last(), E); |
| |
| schedule.AddSuccessorForTesting(loop1->nodes[i], loop1->header()); |
| schedule.AddSuccessorForTesting(loop1->nodes[j], D); |
| schedule.AddSuccessorForTesting(D, E); |
| |
| BasicBlockVector* order = Scheduler::ComputeSpecialRPO(zone(), &schedule); |
| CheckRPONumbers(order, schedule.BasicBlockCount(), true); |
| CheckLoop(order, loop1->nodes, loop1->count); |
| } |
| } |
| } |
| |
| |
| TEST_F(SchedulerRPOTest, LoopOutedges2) { |
| int size = 8; |
| for (int i = 0; i < size; i++) { |
| Schedule schedule(zone()); |
| BasicBlock* A = schedule.start(); |
| BasicBlock* E = schedule.end(); |
| |
| base::SmartPointer<TestLoop> loop1(CreateLoop(&schedule, size)); |
| schedule.AddSuccessorForTesting(A, loop1->header()); |
| schedule.AddSuccessorForTesting(loop1->last(), E); |
| |
| for (int j = 0; j < size; j++) { |
| BasicBlock* O = schedule.NewBasicBlock(); |
| schedule.AddSuccessorForTesting(loop1->nodes[j], O); |
| schedule.AddSuccessorForTesting(O, E); |
| } |
| |
| BasicBlockVector* order = Scheduler::ComputeSpecialRPO(zone(), &schedule); |
| CheckRPONumbers(order, schedule.BasicBlockCount(), true); |
| CheckLoop(order, loop1->nodes, loop1->count); |
| } |
| } |
| |
| |
| TEST_F(SchedulerRPOTest, LoopOutloops1) { |
| int size = 8; |
| for (int i = 0; i < size; i++) { |
| Schedule schedule(zone()); |
| BasicBlock* A = schedule.start(); |
| BasicBlock* E = schedule.end(); |
| base::SmartPointer<TestLoop> loop1(CreateLoop(&schedule, size)); |
| schedule.AddSuccessorForTesting(A, loop1->header()); |
| schedule.AddSuccessorForTesting(loop1->last(), E); |
| |
| TestLoop** loopN = new TestLoop* [size]; |
| for (int j = 0; j < size; j++) { |
| loopN[j] = CreateLoop(&schedule, 2); |
| schedule.AddSuccessorForTesting(loop1->nodes[j], loopN[j]->header()); |
| schedule.AddSuccessorForTesting(loopN[j]->last(), E); |
| } |
| |
| BasicBlockVector* order = Scheduler::ComputeSpecialRPO(zone(), &schedule); |
| CheckRPONumbers(order, schedule.BasicBlockCount(), true); |
| CheckLoop(order, loop1->nodes, loop1->count); |
| |
| for (int j = 0; j < size; j++) { |
| CheckLoop(order, loopN[j]->nodes, loopN[j]->count); |
| delete loopN[j]; |
| } |
| delete[] loopN; |
| } |
| } |
| |
| |
| TEST_F(SchedulerRPOTest, LoopMultibackedge) { |
| Schedule schedule(zone()); |
| |
| BasicBlock* A = schedule.start(); |
| BasicBlock* B = schedule.NewBasicBlock(); |
| BasicBlock* C = schedule.NewBasicBlock(); |
| BasicBlock* D = schedule.NewBasicBlock(); |
| BasicBlock* E = schedule.NewBasicBlock(); |
| |
| schedule.AddSuccessorForTesting(A, B); |
| schedule.AddSuccessorForTesting(B, C); |
| schedule.AddSuccessorForTesting(B, D); |
| schedule.AddSuccessorForTesting(B, E); |
| schedule.AddSuccessorForTesting(C, B); |
| schedule.AddSuccessorForTesting(D, B); |
| schedule.AddSuccessorForTesting(E, B); |
| |
| BasicBlockVector* order = Scheduler::ComputeSpecialRPO(zone(), &schedule); |
| CheckRPONumbers(order, 5, true); |
| |
| BasicBlock* loop1[] = {B, C, D, E}; |
| CheckLoop(order, loop1, 4); |
| } |
| |
| |
| // ----------------------------------------------------------------------------- |
| // Graph end-to-end scheduling. |
| |
| |
| TEST_F(SchedulerTest, BuildScheduleEmpty) { |
| graph()->SetStart(graph()->NewNode(common()->Start(0))); |
| graph()->SetEnd(graph()->NewNode(common()->End(1), graph()->start())); |
| USE(Scheduler::ComputeSchedule(zone(), graph(), Scheduler::kNoFlags)); |
| } |
| |
| |
| TEST_F(SchedulerTest, BuildScheduleOneParameter) { |
| graph()->SetStart(graph()->NewNode(common()->Start(0))); |
| |
| Node* p1 = graph()->NewNode(common()->Parameter(0), graph()->start()); |
| Node* ret = graph()->NewNode(common()->Return(), p1, graph()->start(), |
| graph()->start()); |
| |
| graph()->SetEnd(graph()->NewNode(common()->End(1), ret)); |
| |
| USE(Scheduler::ComputeSchedule(zone(), graph(), Scheduler::kNoFlags)); |
| } |
| |
| |
| namespace { |
| |
| Node* CreateDiamond(Graph* graph, CommonOperatorBuilder* common, Node* cond) { |
| Node* tv = graph->NewNode(common->Int32Constant(6)); |
| Node* fv = graph->NewNode(common->Int32Constant(7)); |
| Node* br = graph->NewNode(common->Branch(), cond, graph->start()); |
| Node* t = graph->NewNode(common->IfTrue(), br); |
| Node* f = graph->NewNode(common->IfFalse(), br); |
| Node* m = graph->NewNode(common->Merge(2), t, f); |
| Node* phi = |
| graph->NewNode(common->Phi(MachineRepresentation::kTagged, 2), tv, fv, m); |
| return phi; |
| } |
| |
| } // namespace |
| |
| |
| TARGET_TEST_F(SchedulerTest, FloatingDiamond1) { |
| Node* start = graph()->NewNode(common()->Start(1)); |
| graph()->SetStart(start); |
| |
| Node* p0 = graph()->NewNode(common()->Parameter(0), start); |
| Node* d1 = CreateDiamond(graph(), common(), p0); |
| Node* ret = graph()->NewNode(common()->Return(), d1, start, start); |
| Node* end = graph()->NewNode(common()->End(1), ret); |
| |
| graph()->SetEnd(end); |
| |
| ComputeAndVerifySchedule(13); |
| } |
| |
| |
| TARGET_TEST_F(SchedulerTest, FloatingDiamond2) { |
| Node* start = graph()->NewNode(common()->Start(2)); |
| graph()->SetStart(start); |
| |
| Node* p0 = graph()->NewNode(common()->Parameter(0), start); |
| Node* p1 = graph()->NewNode(common()->Parameter(1), start); |
| Node* d1 = CreateDiamond(graph(), common(), p0); |
| Node* d2 = CreateDiamond(graph(), common(), p1); |
| Node* add = graph()->NewNode(&kIntAdd, d1, d2); |
| Node* ret = graph()->NewNode(common()->Return(), add, start, start); |
| Node* end = graph()->NewNode(common()->End(1), ret); |
| |
| graph()->SetEnd(end); |
| |
| ComputeAndVerifySchedule(24); |
| } |
| |
| |
| TARGET_TEST_F(SchedulerTest, FloatingDiamond3) { |
| Node* start = graph()->NewNode(common()->Start(2)); |
| graph()->SetStart(start); |
| |
| Node* p0 = graph()->NewNode(common()->Parameter(0), start); |
| Node* p1 = graph()->NewNode(common()->Parameter(1), start); |
| Node* d1 = CreateDiamond(graph(), common(), p0); |
| Node* d2 = CreateDiamond(graph(), common(), p1); |
| Node* add = graph()->NewNode(&kIntAdd, d1, d2); |
| Node* d3 = CreateDiamond(graph(), common(), add); |
| Node* ret = graph()->NewNode(common()->Return(), d3, start, start); |
| Node* end = graph()->NewNode(common()->End(1), ret); |
| |
| graph()->SetEnd(end); |
| |
| ComputeAndVerifySchedule(33); |
| } |
| |
| |
| TARGET_TEST_F(SchedulerTest, NestedFloatingDiamonds) { |
| Node* start = graph()->NewNode(common()->Start(2)); |
| graph()->SetStart(start); |
| |
| Node* p0 = graph()->NewNode(common()->Parameter(0), start); |
| |
| Node* fv = graph()->NewNode(common()->Int32Constant(7)); |
| Node* br = graph()->NewNode(common()->Branch(), p0, graph()->start()); |
| Node* t = graph()->NewNode(common()->IfTrue(), br); |
| Node* f = graph()->NewNode(common()->IfFalse(), br); |
| |
| Node* map = graph()->NewNode( |
| simplified()->LoadElement(AccessBuilder::ForFixedArrayElement()), p0, p0, |
| start, f); |
| Node* br1 = graph()->NewNode(common()->Branch(), map, graph()->start()); |
| Node* t1 = graph()->NewNode(common()->IfTrue(), br1); |
| Node* f1 = graph()->NewNode(common()->IfFalse(), br1); |
| Node* m1 = graph()->NewNode(common()->Merge(2), t1, f1); |
| Node* ttrue = graph()->NewNode(common()->Int32Constant(1)); |
| Node* ffalse = graph()->NewNode(common()->Int32Constant(0)); |
| Node* phi1 = graph()->NewNode( |
| common()->Phi(MachineRepresentation::kTagged, 2), ttrue, ffalse, m1); |
| |
| |
| Node* m = graph()->NewNode(common()->Merge(2), t, f); |
| Node* phi = graph()->NewNode(common()->Phi(MachineRepresentation::kTagged, 2), |
| fv, phi1, m); |
| Node* ephi1 = graph()->NewNode(common()->EffectPhi(2), start, map, m); |
| |
| Node* ret = graph()->NewNode(common()->Return(), phi, ephi1, start); |
| Node* end = graph()->NewNode(common()->End(1), ret); |
| |
| graph()->SetEnd(end); |
| |
| ComputeAndVerifySchedule(23); |
| } |
| |
| |
| TARGET_TEST_F(SchedulerTest, NestedFloatingDiamondWithChain) { |
| Node* start = graph()->NewNode(common()->Start(2)); |
| graph()->SetStart(start); |
| |
| Node* p0 = graph()->NewNode(common()->Parameter(0), start); |
| Node* p1 = graph()->NewNode(common()->Parameter(1), start); |
| Node* c = graph()->NewNode(common()->Int32Constant(7)); |
| |
| Node* brA1 = graph()->NewNode(common()->Branch(), p0, graph()->start()); |
| Node* tA1 = graph()->NewNode(common()->IfTrue(), brA1); |
| Node* fA1 = graph()->NewNode(common()->IfFalse(), brA1); |
| Node* mA1 = graph()->NewNode(common()->Merge(2), tA1, fA1); |
| Node* phiA1 = graph()->NewNode( |
| common()->Phi(MachineRepresentation::kTagged, 2), p0, p1, mA1); |
| |
| Node* brB1 = graph()->NewNode(common()->Branch(), p1, graph()->start()); |
| Node* tB1 = graph()->NewNode(common()->IfTrue(), brB1); |
| Node* fB1 = graph()->NewNode(common()->IfFalse(), brB1); |
| Node* mB1 = graph()->NewNode(common()->Merge(2), tB1, fB1); |
| Node* phiB1 = graph()->NewNode( |
| common()->Phi(MachineRepresentation::kTagged, 2), p0, p1, mB1); |
| |
| Node* brA2 = graph()->NewNode(common()->Branch(), phiB1, mA1); |
| Node* tA2 = graph()->NewNode(common()->IfTrue(), brA2); |
| Node* fA2 = graph()->NewNode(common()->IfFalse(), brA2); |
| Node* mA2 = graph()->NewNode(common()->Merge(2), tA2, fA2); |
| Node* phiA2 = graph()->NewNode( |
| common()->Phi(MachineRepresentation::kTagged, 2), phiB1, c, mA2); |
| |
| Node* brB2 = graph()->NewNode(common()->Branch(), phiA1, mB1); |
| Node* tB2 = graph()->NewNode(common()->IfTrue(), brB2); |
| Node* fB2 = graph()->NewNode(common()->IfFalse(), brB2); |
| Node* mB2 = graph()->NewNode(common()->Merge(2), tB2, fB2); |
| Node* phiB2 = graph()->NewNode( |
| common()->Phi(MachineRepresentation::kTagged, 2), phiA1, c, mB2); |
| |
| Node* add = graph()->NewNode(&kIntAdd, phiA2, phiB2); |
| Node* ret = graph()->NewNode(common()->Return(), add, start, start); |
| Node* end = graph()->NewNode(common()->End(1), ret); |
| |
| graph()->SetEnd(end); |
| |
| ComputeAndVerifySchedule(36); |
| } |
| |
| |
| TARGET_TEST_F(SchedulerTest, NestedFloatingDiamondWithLoop) { |
| Node* start = graph()->NewNode(common()->Start(2)); |
| graph()->SetStart(start); |
| |
| Node* p0 = graph()->NewNode(common()->Parameter(0), start); |
| |
| Node* fv = graph()->NewNode(common()->Int32Constant(7)); |
| Node* br = graph()->NewNode(common()->Branch(), p0, graph()->start()); |
| Node* t = graph()->NewNode(common()->IfTrue(), br); |
| Node* f = graph()->NewNode(common()->IfFalse(), br); |
| |
| Node* loop = graph()->NewNode(common()->Loop(2), f, start); |
| Node* ind = graph()->NewNode(common()->Phi(MachineRepresentation::kTagged, 2), |
| p0, p0, loop); |
| |
| Node* add = graph()->NewNode(&kIntAdd, ind, fv); |
| Node* br1 = graph()->NewNode(common()->Branch(), add, loop); |
| Node* t1 = graph()->NewNode(common()->IfTrue(), br1); |
| Node* f1 = graph()->NewNode(common()->IfFalse(), br1); |
| |
| loop->ReplaceInput(1, t1); // close loop. |
| ind->ReplaceInput(1, ind); // close induction variable. |
| |
| Node* m = graph()->NewNode(common()->Merge(2), t, f1); |
| Node* phi = graph()->NewNode(common()->Phi(MachineRepresentation::kTagged, 2), |
| fv, ind, m); |
| |
| Node* ret = graph()->NewNode(common()->Return(), phi, start, start); |
| Node* end = graph()->NewNode(common()->End(1), ret); |
| |
| graph()->SetEnd(end); |
| |
| ComputeAndVerifySchedule(20); |
| } |
| |
| |
| TARGET_TEST_F(SchedulerTest, LoopedFloatingDiamond1) { |
| Node* start = graph()->NewNode(common()->Start(2)); |
| graph()->SetStart(start); |
| |
| Node* p0 = graph()->NewNode(common()->Parameter(0), start); |
| |
| Node* c = graph()->NewNode(common()->Int32Constant(7)); |
| Node* loop = graph()->NewNode(common()->Loop(2), start, start); |
| Node* ind = graph()->NewNode(common()->Phi(MachineRepresentation::kTagged, 2), |
| p0, p0, loop); |
| Node* add = graph()->NewNode(&kIntAdd, ind, c); |
| |
| Node* br = graph()->NewNode(common()->Branch(), add, loop); |
| Node* t = graph()->NewNode(common()->IfTrue(), br); |
| Node* f = graph()->NewNode(common()->IfFalse(), br); |
| |
| Node* br1 = graph()->NewNode(common()->Branch(), p0, graph()->start()); |
| Node* t1 = graph()->NewNode(common()->IfTrue(), br1); |
| Node* f1 = graph()->NewNode(common()->IfFalse(), br1); |
| Node* m1 = graph()->NewNode(common()->Merge(2), t1, f1); |
| Node* phi1 = graph()->NewNode( |
| common()->Phi(MachineRepresentation::kTagged, 2), add, p0, m1); |
| |
| loop->ReplaceInput(1, t); // close loop. |
| ind->ReplaceInput(1, phi1); // close induction variable. |
| |
| Node* ret = graph()->NewNode(common()->Return(), ind, start, f); |
| Node* end = graph()->NewNode(common()->End(2), ret, f); |
| |
| graph()->SetEnd(end); |
| |
| ComputeAndVerifySchedule(20); |
| } |
| |
| |
| TARGET_TEST_F(SchedulerTest, LoopedFloatingDiamond2) { |
| Node* start = graph()->NewNode(common()->Start(2)); |
| graph()->SetStart(start); |
| |
| Node* p0 = graph()->NewNode(common()->Parameter(0), start); |
| |
| Node* c = graph()->NewNode(common()->Int32Constant(7)); |
| Node* loop = graph()->NewNode(common()->Loop(2), start, start); |
| Node* ind = graph()->NewNode(common()->Phi(MachineRepresentation::kTagged, 2), |
| p0, p0, loop); |
| |
| Node* br1 = graph()->NewNode(common()->Branch(), p0, graph()->start()); |
| Node* t1 = graph()->NewNode(common()->IfTrue(), br1); |
| Node* f1 = graph()->NewNode(common()->IfFalse(), br1); |
| Node* m1 = graph()->NewNode(common()->Merge(2), t1, f1); |
| Node* phi1 = graph()->NewNode( |
| common()->Phi(MachineRepresentation::kTagged, 2), c, ind, m1); |
| |
| Node* add = graph()->NewNode(&kIntAdd, ind, phi1); |
| |
| Node* br = graph()->NewNode(common()->Branch(), add, loop); |
| Node* t = graph()->NewNode(common()->IfTrue(), br); |
| Node* f = graph()->NewNode(common()->IfFalse(), br); |
| |
| loop->ReplaceInput(1, t); // close loop. |
| ind->ReplaceInput(1, add); // close induction variable. |
| |
| Node* ret = graph()->NewNode(common()->Return(), ind, start, f); |
| Node* end = graph()->NewNode(common()->End(2), ret, f); |
| |
| graph()->SetEnd(end); |
| |
| ComputeAndVerifySchedule(20); |
| } |
| |
| |
| TARGET_TEST_F(SchedulerTest, LoopedFloatingDiamond3) { |
| Node* start = graph()->NewNode(common()->Start(2)); |
| graph()->SetStart(start); |
| |
| Node* p0 = graph()->NewNode(common()->Parameter(0), start); |
| |
| Node* c = graph()->NewNode(common()->Int32Constant(7)); |
| Node* loop = graph()->NewNode(common()->Loop(2), start, start); |
| Node* ind = graph()->NewNode(common()->Phi(MachineRepresentation::kTagged, 2), |
| p0, p0, loop); |
| |
| Node* br1 = graph()->NewNode(common()->Branch(), p0, graph()->start()); |
| Node* t1 = graph()->NewNode(common()->IfTrue(), br1); |
| Node* f1 = graph()->NewNode(common()->IfFalse(), br1); |
| |
| Node* loop1 = graph()->NewNode(common()->Loop(2), t1, start); |
| Node* ind1 = graph()->NewNode( |
| common()->Phi(MachineRepresentation::kTagged, 2), p0, p0, loop); |
| |
| Node* add1 = graph()->NewNode(&kIntAdd, ind1, c); |
| Node* br2 = graph()->NewNode(common()->Branch(), add1, loop1); |
| Node* t2 = graph()->NewNode(common()->IfTrue(), br2); |
| Node* f2 = graph()->NewNode(common()->IfFalse(), br2); |
| |
| loop1->ReplaceInput(1, t2); // close inner loop. |
| ind1->ReplaceInput(1, ind1); // close inner induction variable. |
| |
| Node* m1 = graph()->NewNode(common()->Merge(2), f1, f2); |
| Node* phi1 = graph()->NewNode( |
| common()->Phi(MachineRepresentation::kTagged, 2), c, ind1, m1); |
| |
| Node* add = graph()->NewNode(&kIntAdd, ind, phi1); |
| |
| Node* br = graph()->NewNode(common()->Branch(), add, loop); |
| Node* t = graph()->NewNode(common()->IfTrue(), br); |
| Node* f = graph()->NewNode(common()->IfFalse(), br); |
| |
| loop->ReplaceInput(1, t); // close loop. |
| ind->ReplaceInput(1, add); // close induction variable. |
| |
| Node* ret = graph()->NewNode(common()->Return(), ind, start, f); |
| Node* end = graph()->NewNode(common()->End(2), ret, f); |
| |
| graph()->SetEnd(end); |
| |
| ComputeAndVerifySchedule(28); |
| } |
| |
| |
| TARGET_TEST_F(SchedulerTest, PhisPushedDownToDifferentBranches) { |
| Node* start = graph()->NewNode(common()->Start(2)); |
| graph()->SetStart(start); |
| |
| Node* p0 = graph()->NewNode(common()->Parameter(0), start); |
| Node* p1 = graph()->NewNode(common()->Parameter(1), start); |
| |
| Node* v1 = graph()->NewNode(common()->Int32Constant(1)); |
| Node* v2 = graph()->NewNode(common()->Int32Constant(2)); |
| Node* v3 = graph()->NewNode(common()->Int32Constant(3)); |
| Node* v4 = graph()->NewNode(common()->Int32Constant(4)); |
| Node* br = graph()->NewNode(common()->Branch(), p0, graph()->start()); |
| Node* t = graph()->NewNode(common()->IfTrue(), br); |
| Node* f = graph()->NewNode(common()->IfFalse(), br); |
| Node* m = graph()->NewNode(common()->Merge(2), t, f); |
| Node* phi = graph()->NewNode(common()->Phi(MachineRepresentation::kTagged, 2), |
| v1, v2, m); |
| Node* phi2 = graph()->NewNode( |
| common()->Phi(MachineRepresentation::kTagged, 2), v3, v4, m); |
| |
| Node* br2 = graph()->NewNode(common()->Branch(), p1, graph()->start()); |
| Node* t2 = graph()->NewNode(common()->IfTrue(), br2); |
| Node* f2 = graph()->NewNode(common()->IfFalse(), br2); |
| Node* m2 = graph()->NewNode(common()->Merge(2), t2, f2); |
| Node* phi3 = graph()->NewNode( |
| common()->Phi(MachineRepresentation::kTagged, 2), phi, phi2, m2); |
| |
| Node* ret = graph()->NewNode(common()->Return(), phi3, start, start); |
| Node* end = graph()->NewNode(common()->End(1), ret); |
| |
| graph()->SetEnd(end); |
| |
| ComputeAndVerifySchedule(24); |
| } |
| |
| |
| TARGET_TEST_F(SchedulerTest, BranchHintTrue) { |
| Node* start = graph()->NewNode(common()->Start(1)); |
| graph()->SetStart(start); |
| |
| Node* p0 = graph()->NewNode(common()->Parameter(0), start); |
| Node* tv = graph()->NewNode(common()->Int32Constant(6)); |
| Node* fv = graph()->NewNode(common()->Int32Constant(7)); |
| Node* br = graph()->NewNode(common()->Branch(BranchHint::kTrue), p0, start); |
| Node* t = graph()->NewNode(common()->IfTrue(), br); |
| Node* f = graph()->NewNode(common()->IfFalse(), br); |
| Node* m = graph()->NewNode(common()->Merge(2), t, f); |
| Node* phi = graph()->NewNode(common()->Phi(MachineRepresentation::kTagged, 2), |
| tv, fv, m); |
| Node* ret = graph()->NewNode(common()->Return(), phi, start, start); |
| Node* end = graph()->NewNode(common()->End(1), ret); |
| |
| graph()->SetEnd(end); |
| |
| Schedule* schedule = ComputeAndVerifySchedule(13); |
| // Make sure the false block is marked as deferred. |
| EXPECT_FALSE(schedule->block(t)->deferred()); |
| EXPECT_TRUE(schedule->block(f)->deferred()); |
| } |
| |
| |
| TARGET_TEST_F(SchedulerTest, BranchHintFalse) { |
| Node* start = graph()->NewNode(common()->Start(1)); |
| graph()->SetStart(start); |
| |
| Node* p0 = graph()->NewNode(common()->Parameter(0), start); |
| Node* tv = graph()->NewNode(common()->Int32Constant(6)); |
| Node* fv = graph()->NewNode(common()->Int32Constant(7)); |
| Node* br = graph()->NewNode(common()->Branch(BranchHint::kFalse), p0, start); |
| Node* t = graph()->NewNode(common()->IfTrue(), br); |
| Node* f = graph()->NewNode(common()->IfFalse(), br); |
| Node* m = graph()->NewNode(common()->Merge(2), t, f); |
| Node* phi = graph()->NewNode(common()->Phi(MachineRepresentation::kTagged, 2), |
| tv, fv, m); |
| Node* ret = graph()->NewNode(common()->Return(), phi, start, start); |
| Node* end = graph()->NewNode(common()->End(1), ret); |
| |
| graph()->SetEnd(end); |
| |
| Schedule* schedule = ComputeAndVerifySchedule(13); |
| // Make sure the true block is marked as deferred. |
| EXPECT_TRUE(schedule->block(t)->deferred()); |
| EXPECT_FALSE(schedule->block(f)->deferred()); |
| } |
| |
| |
| TARGET_TEST_F(SchedulerTest, CallException) { |
| Node* start = graph()->NewNode(common()->Start(1)); |
| graph()->SetStart(start); |
| |
| Node* p0 = graph()->NewNode(common()->Parameter(0), start); |
| Node* c1 = graph()->NewNode(&kMockCall, start); |
| Node* ok1 = graph()->NewNode(common()->IfSuccess(), c1); |
| Node* ex1 = graph()->NewNode( |
| common()->IfException(IfExceptionHint::kLocallyUncaught), c1, c1); |
| Node* c2 = graph()->NewNode(&kMockCall, ok1); |
| Node* ok2 = graph()->NewNode(common()->IfSuccess(), c2); |
| Node* ex2 = graph()->NewNode( |
| common()->IfException(IfExceptionHint::kLocallyUncaught), c2, c2); |
| Node* hdl = graph()->NewNode(common()->Merge(2), ex1, ex2); |
| Node* m = graph()->NewNode(common()->Merge(2), ok2, hdl); |
| Node* phi = graph()->NewNode(common()->Phi(MachineRepresentation::kTagged, 2), |
| c2, p0, m); |
| Node* ret = graph()->NewNode(common()->Return(), phi, start, m); |
| Node* end = graph()->NewNode(common()->End(1), ret); |
| |
| graph()->SetEnd(end); |
| |
| Schedule* schedule = ComputeAndVerifySchedule(17); |
| // Make sure the exception blocks as well as the handler are deferred. |
| EXPECT_TRUE(schedule->block(ex1)->deferred()); |
| EXPECT_TRUE(schedule->block(ex2)->deferred()); |
| EXPECT_TRUE(schedule->block(hdl)->deferred()); |
| EXPECT_FALSE(schedule->block(m)->deferred()); |
| } |
| |
| |
| TARGET_TEST_F(SchedulerTest, TailCall) { |
| Node* start = graph()->NewNode(common()->Start(1)); |
| graph()->SetStart(start); |
| |
| Node* p0 = graph()->NewNode(common()->Parameter(0), start); |
| Node* call = graph()->NewNode(&kMockTailCall, p0, start, start); |
| Node* end = graph()->NewNode(common()->End(1), call); |
| |
| graph()->SetEnd(end); |
| |
| ComputeAndVerifySchedule(4); |
| } |
| |
| |
| TARGET_TEST_F(SchedulerTest, Switch) { |
| Node* start = graph()->NewNode(common()->Start(1)); |
| graph()->SetStart(start); |
| |
| Node* p0 = graph()->NewNode(common()->Parameter(0), start); |
| Node* sw = graph()->NewNode(common()->Switch(3), p0, start); |
| Node* c0 = graph()->NewNode(common()->IfValue(0), sw); |
| Node* v0 = graph()->NewNode(common()->Int32Constant(11)); |
| Node* c1 = graph()->NewNode(common()->IfValue(1), sw); |
| Node* v1 = graph()->NewNode(common()->Int32Constant(22)); |
| Node* d = graph()->NewNode(common()->IfDefault(), sw); |
| Node* vd = graph()->NewNode(common()->Int32Constant(33)); |
| Node* m = graph()->NewNode(common()->Merge(3), c0, c1, d); |
| Node* phi = graph()->NewNode(common()->Phi(MachineRepresentation::kWord32, 3), |
| v0, v1, vd, m); |
| Node* ret = graph()->NewNode(common()->Return(), phi, start, m); |
| Node* end = graph()->NewNode(common()->End(1), ret); |
| |
| graph()->SetEnd(end); |
| |
| ComputeAndVerifySchedule(16); |
| } |
| |
| |
| TARGET_TEST_F(SchedulerTest, FloatingSwitch) { |
| Node* start = graph()->NewNode(common()->Start(1)); |
| graph()->SetStart(start); |
| |
| Node* p0 = graph()->NewNode(common()->Parameter(0), start); |
| Node* sw = graph()->NewNode(common()->Switch(3), p0, start); |
| Node* c0 = graph()->NewNode(common()->IfValue(0), sw); |
| Node* v0 = graph()->NewNode(common()->Int32Constant(11)); |
| Node* c1 = graph()->NewNode(common()->IfValue(1), sw); |
| Node* v1 = graph()->NewNode(common()->Int32Constant(22)); |
| Node* d = graph()->NewNode(common()->IfDefault(), sw); |
| Node* vd = graph()->NewNode(common()->Int32Constant(33)); |
| Node* m = graph()->NewNode(common()->Merge(3), c0, c1, d); |
| Node* phi = graph()->NewNode(common()->Phi(MachineRepresentation::kWord32, 3), |
| v0, v1, vd, m); |
| Node* ret = graph()->NewNode(common()->Return(), phi, start, start); |
| Node* end = graph()->NewNode(common()->End(1), ret); |
| |
| graph()->SetEnd(end); |
| |
| ComputeAndVerifySchedule(16); |
| } |
| |
| |
| TARGET_TEST_F(SchedulerTest, Terminate) { |
| Node* start = graph()->NewNode(common()->Start(1)); |
| graph()->SetStart(start); |
| |
| Node* loop = graph()->NewNode(common()->Loop(2), start, start); |
| loop->ReplaceInput(1, loop); // self loop, NTL. |
| |
| Node* effect = graph()->NewNode(common()->EffectPhi(2), start, start, loop); |
| effect->ReplaceInput(1, effect); // self loop. |
| |
| Node* terminate = graph()->NewNode(common()->Terminate(), effect, loop); |
| Node* end = graph()->NewNode(common()->End(1), terminate); |
| graph()->SetEnd(end); |
| |
| Schedule* schedule = ComputeAndVerifySchedule(6); |
| BasicBlock* block = schedule->block(loop); |
| EXPECT_EQ(block, schedule->block(effect)); |
| EXPECT_GE(block->rpo_number(), 0); |
| } |
| |
| } // namespace compiler |
| } // namespace internal |
| } // namespace v8 |