OLD | NEW |
| (Empty) |
1 // Copyright 2013 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/v8.h" | |
6 | |
7 #include "src/compiler/common-operator.h" | |
8 #include "src/compiler/graph.h" | |
9 #include "src/compiler/machine-operator.h" | |
10 #include "src/compiler/node.h" | |
11 #include "src/compiler/operator.h" | |
12 #include "src/compiler/schedule.h" | |
13 #include "test/cctest/cctest.h" | |
14 | |
15 using namespace v8::internal; | |
16 using namespace v8::internal::compiler; | |
17 | |
18 static Operator dummy_operator(IrOpcode::kParameter, Operator::kNoWrite, | |
19 "dummy", 0, 0, 0, 0, 0, 0); | |
20 | |
21 TEST(TestScheduleAllocation) { | |
22 HandleAndZoneScope scope; | |
23 Schedule schedule(scope.main_zone()); | |
24 | |
25 CHECK_NE(NULL, schedule.start()); | |
26 CHECK_EQ(schedule.start(), schedule.GetBlockById(BasicBlock::Id::FromInt(0))); | |
27 } | |
28 | |
29 | |
30 TEST(TestScheduleAddNode) { | |
31 HandleAndZoneScope scope; | |
32 Schedule schedule(scope.main_zone()); | |
33 Graph graph(scope.main_zone()); | |
34 Node* n0 = graph.NewNode(&dummy_operator); | |
35 Node* n1 = graph.NewNode(&dummy_operator); | |
36 | |
37 BasicBlock* entry = schedule.start(); | |
38 schedule.AddNode(entry, n0); | |
39 schedule.AddNode(entry, n1); | |
40 | |
41 CHECK_EQ(entry, schedule.block(n0)); | |
42 CHECK_EQ(entry, schedule.block(n1)); | |
43 CHECK(schedule.SameBasicBlock(n0, n1)); | |
44 | |
45 Node* n2 = graph.NewNode(&dummy_operator); | |
46 CHECK_EQ(NULL, schedule.block(n2)); | |
47 } | |
48 | |
49 | |
50 TEST(TestScheduleAddGoto) { | |
51 HandleAndZoneScope scope; | |
52 Schedule schedule(scope.main_zone()); | |
53 | |
54 BasicBlock* entry = schedule.start(); | |
55 BasicBlock* next = schedule.NewBasicBlock(); | |
56 | |
57 schedule.AddGoto(entry, next); | |
58 | |
59 CHECK_EQ(0, static_cast<int>(entry->PredecessorCount())); | |
60 CHECK_EQ(1, static_cast<int>(entry->SuccessorCount())); | |
61 CHECK_EQ(next, entry->SuccessorAt(0)); | |
62 | |
63 CHECK_EQ(1, static_cast<int>(next->PredecessorCount())); | |
64 CHECK_EQ(entry, next->PredecessorAt(0)); | |
65 CHECK_EQ(0, static_cast<int>(next->SuccessorCount())); | |
66 } | |
67 | |
68 | |
69 TEST(TestScheduleAddBranch) { | |
70 HandleAndZoneScope scope; | |
71 Schedule schedule(scope.main_zone()); | |
72 Graph graph(scope.main_zone()); | |
73 CommonOperatorBuilder common(scope.main_zone()); | |
74 Node* n0 = graph.NewNode(&dummy_operator); | |
75 Node* b = graph.NewNode(common.Branch(), n0); | |
76 | |
77 BasicBlock* entry = schedule.start(); | |
78 BasicBlock* tblock = schedule.NewBasicBlock(); | |
79 BasicBlock* fblock = schedule.NewBasicBlock(); | |
80 | |
81 schedule.AddBranch(entry, b, tblock, fblock); | |
82 | |
83 CHECK_EQ(0, static_cast<int>(entry->PredecessorCount())); | |
84 CHECK_EQ(2, static_cast<int>(entry->SuccessorCount())); | |
85 CHECK_EQ(tblock, entry->SuccessorAt(0)); | |
86 CHECK_EQ(fblock, entry->SuccessorAt(1)); | |
87 | |
88 CHECK_EQ(1, static_cast<int>(tblock->PredecessorCount())); | |
89 CHECK_EQ(entry, tblock->PredecessorAt(0)); | |
90 CHECK_EQ(0, static_cast<int>(tblock->SuccessorCount())); | |
91 | |
92 CHECK_EQ(1, static_cast<int>(fblock->PredecessorCount())); | |
93 CHECK_EQ(entry, fblock->PredecessorAt(0)); | |
94 CHECK_EQ(0, static_cast<int>(fblock->SuccessorCount())); | |
95 } | |
96 | |
97 | |
98 TEST(TestScheduleAddReturn) { | |
99 HandleAndZoneScope scope; | |
100 Schedule schedule(scope.main_zone()); | |
101 Graph graph(scope.main_zone()); | |
102 Node* n0 = graph.NewNode(&dummy_operator); | |
103 BasicBlock* entry = schedule.start(); | |
104 schedule.AddReturn(entry, n0); | |
105 | |
106 CHECK_EQ(0, static_cast<int>(entry->PredecessorCount())); | |
107 CHECK_EQ(1, static_cast<int>(entry->SuccessorCount())); | |
108 CHECK_EQ(schedule.end(), entry->SuccessorAt(0)); | |
109 } | |
110 | |
111 | |
112 TEST(TestScheduleAddThrow) { | |
113 HandleAndZoneScope scope; | |
114 Schedule schedule(scope.main_zone()); | |
115 Graph graph(scope.main_zone()); | |
116 Node* n0 = graph.NewNode(&dummy_operator); | |
117 BasicBlock* entry = schedule.start(); | |
118 schedule.AddThrow(entry, n0); | |
119 | |
120 CHECK_EQ(0, static_cast<int>(entry->PredecessorCount())); | |
121 CHECK_EQ(1, static_cast<int>(entry->SuccessorCount())); | |
122 CHECK_EQ(schedule.end(), entry->SuccessorAt(0)); | |
123 } | |
124 | |
125 | |
126 TEST(TestScheduleInsertBranch) { | |
127 HandleAndZoneScope scope; | |
128 Schedule schedule(scope.main_zone()); | |
129 Graph graph(scope.main_zone()); | |
130 CommonOperatorBuilder common(scope.main_zone()); | |
131 Node* n0 = graph.NewNode(&dummy_operator); | |
132 Node* n1 = graph.NewNode(&dummy_operator); | |
133 Node* b = graph.NewNode(common.Branch(), n1); | |
134 | |
135 BasicBlock* entry = schedule.start(); | |
136 BasicBlock* tblock = schedule.NewBasicBlock(); | |
137 BasicBlock* fblock = schedule.NewBasicBlock(); | |
138 BasicBlock* merge = schedule.NewBasicBlock(); | |
139 schedule.AddReturn(entry, n0); | |
140 schedule.AddGoto(tblock, merge); | |
141 schedule.AddGoto(fblock, merge); | |
142 | |
143 schedule.InsertBranch(entry, merge, b, tblock, fblock); | |
144 | |
145 CHECK_EQ(0, static_cast<int>(entry->PredecessorCount())); | |
146 CHECK_EQ(2, static_cast<int>(entry->SuccessorCount())); | |
147 CHECK_EQ(tblock, entry->SuccessorAt(0)); | |
148 CHECK_EQ(fblock, entry->SuccessorAt(1)); | |
149 | |
150 CHECK_EQ(2, static_cast<int>(merge->PredecessorCount())); | |
151 CHECK_EQ(1, static_cast<int>(merge->SuccessorCount())); | |
152 CHECK_EQ(schedule.end(), merge->SuccessorAt(0)); | |
153 | |
154 CHECK_EQ(1, static_cast<int>(schedule.end()->PredecessorCount())); | |
155 CHECK_EQ(0, static_cast<int>(schedule.end()->SuccessorCount())); | |
156 CHECK_EQ(merge, schedule.end()->PredecessorAt(0)); | |
157 } | |
158 | |
159 | |
160 TEST(BuildMulNodeGraph) { | |
161 HandleAndZoneScope scope; | |
162 Schedule schedule(scope.main_zone()); | |
163 Graph graph(scope.main_zone()); | |
164 CommonOperatorBuilder common(scope.main_zone()); | |
165 // TODO(titzer): use test operators. | |
166 MachineOperatorBuilder machine(scope.main_zone()); | |
167 | |
168 Node* start = graph.NewNode(common.Start(0)); | |
169 graph.SetStart(start); | |
170 Node* param0 = graph.NewNode(common.Parameter(0), graph.start()); | |
171 Node* param1 = graph.NewNode(common.Parameter(1), graph.start()); | |
172 | |
173 Node* mul = graph.NewNode(machine.Int32Mul(), param0, param1); | |
174 Node* ret = graph.NewNode(common.Return(), mul, start); | |
175 | |
176 USE(ret); | |
177 } | |
OLD | NEW |