OLD | NEW |
1 // Copyright 2015 the V8 project authors. All rights reserved. | 1 // Copyright 2015 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 | |
6 #include "test/unittests/compiler/live-range-builder.h" | 5 #include "test/unittests/compiler/live-range-builder.h" |
7 #include "test/unittests/test-utils.h" | 6 #include "test/unittests/test-utils.h" |
8 | 7 |
9 | |
10 // TODO(mtrofin): would we want to centralize this definition? | 8 // TODO(mtrofin): would we want to centralize this definition? |
11 #ifdef DEBUG | 9 #ifdef DEBUG |
12 #define V8_ASSERT_DEBUG_DEATH(statement, regex) \ | 10 #define V8_ASSERT_DEBUG_DEATH(statement, regex) \ |
13 ASSERT_DEATH_IF_SUPPORTED(statement, regex) | 11 ASSERT_DEATH_IF_SUPPORTED(statement, regex) |
14 #define DISABLE_IN_RELEASE(Name) Name | 12 #define DISABLE_IN_RELEASE(Name) Name |
15 | 13 |
16 #else | 14 #else |
17 #define V8_ASSERT_DEBUG_DEATH(statement, regex) statement | 15 #define V8_ASSERT_DEBUG_DEATH(statement, regex) statement |
18 #define DISABLE_IN_RELEASE(Name) DISABLED_##Name | 16 #define DISABLE_IN_RELEASE(Name) DISABLED_##Name |
19 #endif // DEBUG | 17 #endif // DEBUG |
20 | 18 |
21 namespace v8 { | 19 namespace v8 { |
22 namespace internal { | 20 namespace internal { |
23 namespace compiler { | 21 namespace compiler { |
24 | 22 |
25 class LiveRangeUnitTest : public TestWithZone { | 23 class LiveRangeUnitTest : public TestWithZone { |
26 public: | 24 public: |
27 // Split helper, to avoid int->LifetimePosition conversion nuisance. | 25 // Split helper, to avoid int->LifetimePosition conversion nuisance. |
28 LiveRange* Split(LiveRange* range, int pos) { | 26 LiveRange* Split(LiveRange* range, int pos) { |
29 return range->SplitAt(LifetimePosition::FromInt(pos), zone()); | 27 return range->SplitAt(LifetimePosition::FromInt(pos), zone()); |
30 } | 28 } |
31 | 29 |
32 | |
33 TopLevelLiveRange* Splinter(TopLevelLiveRange* top, int start, int end, | 30 TopLevelLiveRange* Splinter(TopLevelLiveRange* top, int start, int end, |
34 int new_id = 0) { | 31 int new_id = 0) { |
35 if (top->splinter() == nullptr) { | 32 if (top->splinter() == nullptr) { |
36 TopLevelLiveRange* ret = new (zone()) | 33 TopLevelLiveRange* ret = new (zone()) |
37 TopLevelLiveRange(new_id, MachineRepresentation::kTagged); | 34 TopLevelLiveRange(new_id, MachineRepresentation::kTagged); |
38 top->SetSplinter(ret); | 35 top->SetSplinter(ret); |
39 } | 36 } |
40 top->Splinter(LifetimePosition::FromInt(start), | 37 top->Splinter(LifetimePosition::FromInt(start), |
41 LifetimePosition::FromInt(end), zone()); | 38 LifetimePosition::FromInt(end), zone()); |
42 return top->splinter(); | 39 return top->splinter(); |
(...skipping 20 matching lines...) Expand all Loading... |
63 while (p1 != nullptr && p2 != nullptr) { | 60 while (p1 != nullptr && p2 != nullptr) { |
64 if (p1->pos() != p2->pos()) return false; | 61 if (p1->pos() != p2->pos()) return false; |
65 p1 = p1->next(); | 62 p1 = p1->next(); |
66 p2 = p2->next(); | 63 p2 = p2->next(); |
67 } | 64 } |
68 if (p1 != nullptr || p2 != nullptr) return false; | 65 if (p1 != nullptr || p2 != nullptr) return false; |
69 return true; | 66 return true; |
70 } | 67 } |
71 }; | 68 }; |
72 | 69 |
73 | |
74 TEST_F(LiveRangeUnitTest, InvalidConstruction) { | 70 TEST_F(LiveRangeUnitTest, InvalidConstruction) { |
75 // Build a range manually, because the builder guards against empty cases. | 71 // Build a range manually, because the builder guards against empty cases. |
76 TopLevelLiveRange* range = | 72 TopLevelLiveRange* range = |
77 new (zone()) TopLevelLiveRange(1, MachineRepresentation::kTagged); | 73 new (zone()) TopLevelLiveRange(1, MachineRepresentation::kTagged); |
78 V8_ASSERT_DEBUG_DEATH( | 74 V8_ASSERT_DEBUG_DEATH( |
79 range->AddUseInterval(LifetimePosition::FromInt(0), | 75 range->AddUseInterval(LifetimePosition::FromInt(0), |
80 LifetimePosition::FromInt(0), zone()), | 76 LifetimePosition::FromInt(0), zone()), |
81 ".*"); | 77 ".*"); |
82 } | 78 } |
83 | 79 |
84 | |
85 TEST_F(LiveRangeUnitTest, SplitInvalidStart) { | 80 TEST_F(LiveRangeUnitTest, SplitInvalidStart) { |
86 TopLevelLiveRange* range = TestRangeBuilder(zone()).Build(0, 1); | 81 TopLevelLiveRange* range = TestRangeBuilder(zone()).Build(0, 1); |
87 V8_ASSERT_DEBUG_DEATH(Split(range, 0), ".*"); | 82 V8_ASSERT_DEBUG_DEATH(Split(range, 0), ".*"); |
88 } | 83 } |
89 | 84 |
90 | |
91 TEST_F(LiveRangeUnitTest, DISABLE_IN_RELEASE(InvalidSplitEnd)) { | 85 TEST_F(LiveRangeUnitTest, DISABLE_IN_RELEASE(InvalidSplitEnd)) { |
92 TopLevelLiveRange* range = TestRangeBuilder(zone()).Build(0, 1); | 86 TopLevelLiveRange* range = TestRangeBuilder(zone()).Build(0, 1); |
93 ASSERT_DEATH_IF_SUPPORTED(Split(range, 1), ".*"); | 87 ASSERT_DEATH_IF_SUPPORTED(Split(range, 1), ".*"); |
94 } | 88 } |
95 | 89 |
96 | |
97 TEST_F(LiveRangeUnitTest, DISABLE_IN_RELEASE(SplitInvalidPreStart)) { | 90 TEST_F(LiveRangeUnitTest, DISABLE_IN_RELEASE(SplitInvalidPreStart)) { |
98 TopLevelLiveRange* range = TestRangeBuilder(zone()).Build(1, 2); | 91 TopLevelLiveRange* range = TestRangeBuilder(zone()).Build(1, 2); |
99 ASSERT_DEATH_IF_SUPPORTED(Split(range, 0), ".*"); | 92 ASSERT_DEATH_IF_SUPPORTED(Split(range, 0), ".*"); |
100 } | 93 } |
101 | 94 |
102 | |
103 TEST_F(LiveRangeUnitTest, DISABLE_IN_RELEASE(SplitInvalidPostEnd)) { | 95 TEST_F(LiveRangeUnitTest, DISABLE_IN_RELEASE(SplitInvalidPostEnd)) { |
104 TopLevelLiveRange* range = TestRangeBuilder(zone()).Build(0, 1); | 96 TopLevelLiveRange* range = TestRangeBuilder(zone()).Build(0, 1); |
105 ASSERT_DEATH_IF_SUPPORTED(Split(range, 2), ".*"); | 97 ASSERT_DEATH_IF_SUPPORTED(Split(range, 2), ".*"); |
106 } | 98 } |
107 | 99 |
108 | |
109 TEST_F(LiveRangeUnitTest, SplitSingleIntervalNoUsePositions) { | 100 TEST_F(LiveRangeUnitTest, SplitSingleIntervalNoUsePositions) { |
110 TopLevelLiveRange* range = TestRangeBuilder(zone()).Build(0, 2); | 101 TopLevelLiveRange* range = TestRangeBuilder(zone()).Build(0, 2); |
111 LiveRange* child = Split(range, 1); | 102 LiveRange* child = Split(range, 1); |
112 | 103 |
113 EXPECT_NE(nullptr, range->next()); | 104 EXPECT_NE(nullptr, range->next()); |
114 EXPECT_EQ(child, range->next()); | 105 EXPECT_EQ(child, range->next()); |
115 | 106 |
116 LiveRange* expected_top = TestRangeBuilder(zone()).Build(0, 1); | 107 LiveRange* expected_top = TestRangeBuilder(zone()).Build(0, 1); |
117 LiveRange* expected_bottom = TestRangeBuilder(zone()).Build(1, 2); | 108 LiveRange* expected_bottom = TestRangeBuilder(zone()).Build(1, 2); |
118 EXPECT_TRUE(RangesMatch(expected_top, range)); | 109 EXPECT_TRUE(RangesMatch(expected_top, range)); |
119 EXPECT_TRUE(RangesMatch(expected_bottom, child)); | 110 EXPECT_TRUE(RangesMatch(expected_bottom, child)); |
120 } | 111 } |
121 | 112 |
122 | |
123 TEST_F(LiveRangeUnitTest, SplitManyIntervalNoUsePositionsBetween) { | 113 TEST_F(LiveRangeUnitTest, SplitManyIntervalNoUsePositionsBetween) { |
124 TopLevelLiveRange* range = | 114 TopLevelLiveRange* range = |
125 TestRangeBuilder(zone()).Add(0, 2).Add(4, 6).Build(); | 115 TestRangeBuilder(zone()).Add(0, 2).Add(4, 6).Build(); |
126 LiveRange* child = Split(range, 3); | 116 LiveRange* child = Split(range, 3); |
127 | 117 |
128 EXPECT_NE(nullptr, range->next()); | 118 EXPECT_NE(nullptr, range->next()); |
129 EXPECT_EQ(child, range->next()); | 119 EXPECT_EQ(child, range->next()); |
130 | 120 |
131 LiveRange* expected_top = TestRangeBuilder(zone()).Build(0, 2); | 121 LiveRange* expected_top = TestRangeBuilder(zone()).Build(0, 2); |
132 LiveRange* expected_bottom = TestRangeBuilder(zone()).Build(4, 6); | 122 LiveRange* expected_bottom = TestRangeBuilder(zone()).Build(4, 6); |
133 EXPECT_TRUE(RangesMatch(expected_top, range)); | 123 EXPECT_TRUE(RangesMatch(expected_top, range)); |
134 EXPECT_TRUE(RangesMatch(expected_bottom, child)); | 124 EXPECT_TRUE(RangesMatch(expected_bottom, child)); |
135 } | 125 } |
136 | 126 |
137 | |
138 TEST_F(LiveRangeUnitTest, SplitManyIntervalNoUsePositionsFront) { | 127 TEST_F(LiveRangeUnitTest, SplitManyIntervalNoUsePositionsFront) { |
139 TopLevelLiveRange* range = | 128 TopLevelLiveRange* range = |
140 TestRangeBuilder(zone()).Add(0, 2).Add(4, 6).Build(); | 129 TestRangeBuilder(zone()).Add(0, 2).Add(4, 6).Build(); |
141 LiveRange* child = Split(range, 1); | 130 LiveRange* child = Split(range, 1); |
142 | 131 |
143 EXPECT_NE(nullptr, range->next()); | 132 EXPECT_NE(nullptr, range->next()); |
144 EXPECT_EQ(child, range->next()); | 133 EXPECT_EQ(child, range->next()); |
145 | 134 |
146 LiveRange* expected_top = TestRangeBuilder(zone()).Build(0, 1); | 135 LiveRange* expected_top = TestRangeBuilder(zone()).Build(0, 1); |
147 LiveRange* expected_bottom = | 136 LiveRange* expected_bottom = |
148 TestRangeBuilder(zone()).Add(1, 2).Add(4, 6).Build(); | 137 TestRangeBuilder(zone()).Add(1, 2).Add(4, 6).Build(); |
149 EXPECT_TRUE(RangesMatch(expected_top, range)); | 138 EXPECT_TRUE(RangesMatch(expected_top, range)); |
150 EXPECT_TRUE(RangesMatch(expected_bottom, child)); | 139 EXPECT_TRUE(RangesMatch(expected_bottom, child)); |
151 } | 140 } |
152 | 141 |
153 | |
154 TEST_F(LiveRangeUnitTest, SplitManyIntervalNoUsePositionsAfter) { | 142 TEST_F(LiveRangeUnitTest, SplitManyIntervalNoUsePositionsAfter) { |
155 TopLevelLiveRange* range = | 143 TopLevelLiveRange* range = |
156 TestRangeBuilder(zone()).Add(0, 2).Add(4, 6).Build(); | 144 TestRangeBuilder(zone()).Add(0, 2).Add(4, 6).Build(); |
157 LiveRange* child = Split(range, 5); | 145 LiveRange* child = Split(range, 5); |
158 | 146 |
159 EXPECT_NE(nullptr, range->next()); | 147 EXPECT_NE(nullptr, range->next()); |
160 EXPECT_EQ(child, range->next()); | 148 EXPECT_EQ(child, range->next()); |
161 | 149 |
162 LiveRange* expected_top = | 150 LiveRange* expected_top = |
163 TestRangeBuilder(zone()).Add(0, 2).Add(4, 5).Build(); | 151 TestRangeBuilder(zone()).Add(0, 2).Add(4, 5).Build(); |
164 LiveRange* expected_bottom = TestRangeBuilder(zone()).Build(5, 6); | 152 LiveRange* expected_bottom = TestRangeBuilder(zone()).Build(5, 6); |
165 EXPECT_TRUE(RangesMatch(expected_top, range)); | 153 EXPECT_TRUE(RangesMatch(expected_top, range)); |
166 EXPECT_TRUE(RangesMatch(expected_bottom, child)); | 154 EXPECT_TRUE(RangesMatch(expected_bottom, child)); |
167 } | 155 } |
168 | 156 |
169 | |
170 TEST_F(LiveRangeUnitTest, SplitSingleIntervalUsePositions) { | 157 TEST_F(LiveRangeUnitTest, SplitSingleIntervalUsePositions) { |
171 TopLevelLiveRange* range = | 158 TopLevelLiveRange* range = |
172 TestRangeBuilder(zone()).Add(0, 3).AddUse(0).AddUse(2).Build(); | 159 TestRangeBuilder(zone()).Add(0, 3).AddUse(0).AddUse(2).Build(); |
173 | 160 |
174 LiveRange* child = Split(range, 1); | 161 LiveRange* child = Split(range, 1); |
175 | 162 |
176 EXPECT_NE(nullptr, range->next()); | 163 EXPECT_NE(nullptr, range->next()); |
177 EXPECT_EQ(child, range->next()); | 164 EXPECT_EQ(child, range->next()); |
178 | 165 |
179 LiveRange* expected_top = | 166 LiveRange* expected_top = |
180 TestRangeBuilder(zone()).Add(0, 1).AddUse(0).Build(); | 167 TestRangeBuilder(zone()).Add(0, 1).AddUse(0).Build(); |
181 LiveRange* expected_bottom = | 168 LiveRange* expected_bottom = |
182 TestRangeBuilder(zone()).Add(1, 3).AddUse(2).Build(); | 169 TestRangeBuilder(zone()).Add(1, 3).AddUse(2).Build(); |
183 EXPECT_TRUE(RangesMatch(expected_top, range)); | 170 EXPECT_TRUE(RangesMatch(expected_top, range)); |
184 EXPECT_TRUE(RangesMatch(expected_bottom, child)); | 171 EXPECT_TRUE(RangesMatch(expected_bottom, child)); |
185 } | 172 } |
186 | 173 |
187 | |
188 TEST_F(LiveRangeUnitTest, SplitSingleIntervalUsePositionsAtPos) { | 174 TEST_F(LiveRangeUnitTest, SplitSingleIntervalUsePositionsAtPos) { |
189 TopLevelLiveRange* range = | 175 TopLevelLiveRange* range = |
190 TestRangeBuilder(zone()).Add(0, 3).AddUse(0).AddUse(2).Build(); | 176 TestRangeBuilder(zone()).Add(0, 3).AddUse(0).AddUse(2).Build(); |
191 | 177 |
192 LiveRange* child = Split(range, 2); | 178 LiveRange* child = Split(range, 2); |
193 | 179 |
194 EXPECT_NE(nullptr, range->next()); | 180 EXPECT_NE(nullptr, range->next()); |
195 EXPECT_EQ(child, range->next()); | 181 EXPECT_EQ(child, range->next()); |
196 | 182 |
197 LiveRange* expected_top = | 183 LiveRange* expected_top = |
198 TestRangeBuilder(zone()).Add(0, 2).AddUse(0).AddUse(2).Build(); | 184 TestRangeBuilder(zone()).Add(0, 2).AddUse(0).AddUse(2).Build(); |
199 LiveRange* expected_bottom = TestRangeBuilder(zone()).Build(2, 3); | 185 LiveRange* expected_bottom = TestRangeBuilder(zone()).Build(2, 3); |
200 EXPECT_TRUE(RangesMatch(expected_top, range)); | 186 EXPECT_TRUE(RangesMatch(expected_top, range)); |
201 EXPECT_TRUE(RangesMatch(expected_bottom, child)); | 187 EXPECT_TRUE(RangesMatch(expected_bottom, child)); |
202 } | 188 } |
203 | 189 |
204 | |
205 TEST_F(LiveRangeUnitTest, SplitManyIntervalUsePositionsBetween) { | 190 TEST_F(LiveRangeUnitTest, SplitManyIntervalUsePositionsBetween) { |
206 TopLevelLiveRange* range = | 191 TopLevelLiveRange* range = |
207 TestRangeBuilder(zone()).Add(0, 2).Add(4, 6).AddUse(1).AddUse(5).Build(); | 192 TestRangeBuilder(zone()).Add(0, 2).Add(4, 6).AddUse(1).AddUse(5).Build(); |
208 LiveRange* child = Split(range, 3); | 193 LiveRange* child = Split(range, 3); |
209 | 194 |
210 EXPECT_NE(nullptr, range->next()); | 195 EXPECT_NE(nullptr, range->next()); |
211 EXPECT_EQ(child, range->next()); | 196 EXPECT_EQ(child, range->next()); |
212 | 197 |
213 LiveRange* expected_top = | 198 LiveRange* expected_top = |
214 TestRangeBuilder(zone()).Add(0, 2).AddUse(1).Build(); | 199 TestRangeBuilder(zone()).Add(0, 2).AddUse(1).Build(); |
215 LiveRange* expected_bottom = | 200 LiveRange* expected_bottom = |
216 TestRangeBuilder(zone()).Add(4, 6).AddUse(5).Build(); | 201 TestRangeBuilder(zone()).Add(4, 6).AddUse(5).Build(); |
217 EXPECT_TRUE(RangesMatch(expected_top, range)); | 202 EXPECT_TRUE(RangesMatch(expected_top, range)); |
218 EXPECT_TRUE(RangesMatch(expected_bottom, child)); | 203 EXPECT_TRUE(RangesMatch(expected_bottom, child)); |
219 } | 204 } |
220 | 205 |
221 | |
222 TEST_F(LiveRangeUnitTest, SplitManyIntervalUsePositionsAtInterval) { | 206 TEST_F(LiveRangeUnitTest, SplitManyIntervalUsePositionsAtInterval) { |
223 TopLevelLiveRange* range = | 207 TopLevelLiveRange* range = |
224 TestRangeBuilder(zone()).Add(0, 2).Add(4, 6).AddUse(1).AddUse(4).Build(); | 208 TestRangeBuilder(zone()).Add(0, 2).Add(4, 6).AddUse(1).AddUse(4).Build(); |
225 LiveRange* child = Split(range, 4); | 209 LiveRange* child = Split(range, 4); |
226 | 210 |
227 EXPECT_NE(nullptr, range->next()); | 211 EXPECT_NE(nullptr, range->next()); |
228 EXPECT_EQ(child, range->next()); | 212 EXPECT_EQ(child, range->next()); |
229 | 213 |
230 LiveRange* expected_top = | 214 LiveRange* expected_top = |
231 TestRangeBuilder(zone()).Add(0, 2).AddUse(1).Build(); | 215 TestRangeBuilder(zone()).Add(0, 2).AddUse(1).Build(); |
232 LiveRange* expected_bottom = | 216 LiveRange* expected_bottom = |
233 TestRangeBuilder(zone()).Add(4, 6).AddUse(4).Build(); | 217 TestRangeBuilder(zone()).Add(4, 6).AddUse(4).Build(); |
234 EXPECT_TRUE(RangesMatch(expected_top, range)); | 218 EXPECT_TRUE(RangesMatch(expected_top, range)); |
235 EXPECT_TRUE(RangesMatch(expected_bottom, child)); | 219 EXPECT_TRUE(RangesMatch(expected_bottom, child)); |
236 } | 220 } |
237 | 221 |
238 | |
239 TEST_F(LiveRangeUnitTest, SplitManyIntervalUsePositionsFront) { | 222 TEST_F(LiveRangeUnitTest, SplitManyIntervalUsePositionsFront) { |
240 TopLevelLiveRange* range = | 223 TopLevelLiveRange* range = |
241 TestRangeBuilder(zone()).Add(0, 2).Add(4, 6).AddUse(1).AddUse(5).Build(); | 224 TestRangeBuilder(zone()).Add(0, 2).Add(4, 6).AddUse(1).AddUse(5).Build(); |
242 LiveRange* child = Split(range, 1); | 225 LiveRange* child = Split(range, 1); |
243 | 226 |
244 EXPECT_NE(nullptr, range->next()); | 227 EXPECT_NE(nullptr, range->next()); |
245 EXPECT_EQ(child, range->next()); | 228 EXPECT_EQ(child, range->next()); |
246 | 229 |
247 LiveRange* expected_top = | 230 LiveRange* expected_top = |
248 TestRangeBuilder(zone()).Add(0, 1).AddUse(1).Build(); | 231 TestRangeBuilder(zone()).Add(0, 1).AddUse(1).Build(); |
249 LiveRange* expected_bottom = | 232 LiveRange* expected_bottom = |
250 TestRangeBuilder(zone()).Add(1, 2).Add(4, 6).AddUse(5).Build(); | 233 TestRangeBuilder(zone()).Add(1, 2).Add(4, 6).AddUse(5).Build(); |
251 EXPECT_TRUE(RangesMatch(expected_top, range)); | 234 EXPECT_TRUE(RangesMatch(expected_top, range)); |
252 EXPECT_TRUE(RangesMatch(expected_bottom, child)); | 235 EXPECT_TRUE(RangesMatch(expected_bottom, child)); |
253 } | 236 } |
254 | 237 |
255 | |
256 TEST_F(LiveRangeUnitTest, SplitManyIntervalUsePositionsAfter) { | 238 TEST_F(LiveRangeUnitTest, SplitManyIntervalUsePositionsAfter) { |
257 TopLevelLiveRange* range = | 239 TopLevelLiveRange* range = |
258 TestRangeBuilder(zone()).Add(0, 2).Add(4, 6).AddUse(1).AddUse(5).Build(); | 240 TestRangeBuilder(zone()).Add(0, 2).Add(4, 6).AddUse(1).AddUse(5).Build(); |
259 LiveRange* child = Split(range, 5); | 241 LiveRange* child = Split(range, 5); |
260 | 242 |
261 EXPECT_NE(nullptr, range->next()); | 243 EXPECT_NE(nullptr, range->next()); |
262 EXPECT_EQ(child, range->next()); | 244 EXPECT_EQ(child, range->next()); |
263 | 245 |
264 LiveRange* expected_top = | 246 LiveRange* expected_top = |
265 TestRangeBuilder(zone()).Add(0, 2).Add(4, 5).AddUse(1).AddUse(5).Build(); | 247 TestRangeBuilder(zone()).Add(0, 2).Add(4, 5).AddUse(1).AddUse(5).Build(); |
266 LiveRange* expected_bottom = TestRangeBuilder(zone()).Build(5, 6); | 248 LiveRange* expected_bottom = TestRangeBuilder(zone()).Build(5, 6); |
267 EXPECT_TRUE(RangesMatch(expected_top, range)); | 249 EXPECT_TRUE(RangesMatch(expected_top, range)); |
268 EXPECT_TRUE(RangesMatch(expected_bottom, child)); | 250 EXPECT_TRUE(RangesMatch(expected_bottom, child)); |
269 } | 251 } |
270 | 252 |
271 | |
272 TEST_F(LiveRangeUnitTest, SplinterSingleInterval) { | 253 TEST_F(LiveRangeUnitTest, SplinterSingleInterval) { |
273 TopLevelLiveRange* range = TestRangeBuilder(zone()).Build(0, 6); | 254 TopLevelLiveRange* range = TestRangeBuilder(zone()).Build(0, 6); |
274 TopLevelLiveRange* splinter = Splinter(range, 3, 5); | 255 TopLevelLiveRange* splinter = Splinter(range, 3, 5); |
275 EXPECT_EQ(nullptr, range->next()); | 256 EXPECT_EQ(nullptr, range->next()); |
276 EXPECT_EQ(nullptr, splinter->next()); | 257 EXPECT_EQ(nullptr, splinter->next()); |
277 EXPECT_EQ(range, splinter->splintered_from()); | 258 EXPECT_EQ(range, splinter->splintered_from()); |
278 | 259 |
279 TopLevelLiveRange* expected_source = | 260 TopLevelLiveRange* expected_source = |
280 TestRangeBuilder(zone()).Add(0, 3).Add(5, 6).Build(); | 261 TestRangeBuilder(zone()).Add(0, 3).Add(5, 6).Build(); |
281 TopLevelLiveRange* expected_splinter = TestRangeBuilder(zone()).Build(3, 5); | 262 TopLevelLiveRange* expected_splinter = TestRangeBuilder(zone()).Build(3, 5); |
282 EXPECT_TRUE(RangesMatch(expected_source, range)); | 263 EXPECT_TRUE(RangesMatch(expected_source, range)); |
283 EXPECT_TRUE(RangesMatch(expected_splinter, splinter)); | 264 EXPECT_TRUE(RangesMatch(expected_splinter, splinter)); |
284 } | 265 } |
285 | 266 |
286 | |
287 TEST_F(LiveRangeUnitTest, MergeSingleInterval) { | 267 TEST_F(LiveRangeUnitTest, MergeSingleInterval) { |
288 TopLevelLiveRange* original = TestRangeBuilder(zone()).Build(0, 6); | 268 TopLevelLiveRange* original = TestRangeBuilder(zone()).Build(0, 6); |
289 TopLevelLiveRange* splinter = Splinter(original, 3, 5); | 269 TopLevelLiveRange* splinter = Splinter(original, 3, 5); |
290 | 270 |
291 original->Merge(splinter, zone()); | 271 original->Merge(splinter, zone()); |
292 TopLevelLiveRange* result = TestRangeBuilder(zone()).Build(0, 6); | 272 TopLevelLiveRange* result = TestRangeBuilder(zone()).Build(0, 6); |
293 LiveRange* child_1 = Split(result, 3); | 273 LiveRange* child_1 = Split(result, 3); |
294 Split(child_1, 5); | 274 Split(child_1, 5); |
295 | 275 |
296 EXPECT_TRUE(RangesMatch(result, original)); | 276 EXPECT_TRUE(RangesMatch(result, original)); |
297 } | 277 } |
298 | 278 |
299 | |
300 TEST_F(LiveRangeUnitTest, SplinterMultipleIntervalsOutside) { | 279 TEST_F(LiveRangeUnitTest, SplinterMultipleIntervalsOutside) { |
301 TopLevelLiveRange* range = | 280 TopLevelLiveRange* range = |
302 TestRangeBuilder(zone()).Add(0, 3).Add(5, 8).Build(); | 281 TestRangeBuilder(zone()).Add(0, 3).Add(5, 8).Build(); |
303 TopLevelLiveRange* splinter = Splinter(range, 2, 6); | 282 TopLevelLiveRange* splinter = Splinter(range, 2, 6); |
304 EXPECT_EQ(nullptr, range->next()); | 283 EXPECT_EQ(nullptr, range->next()); |
305 EXPECT_EQ(nullptr, splinter->next()); | 284 EXPECT_EQ(nullptr, splinter->next()); |
306 EXPECT_EQ(range, splinter->splintered_from()); | 285 EXPECT_EQ(range, splinter->splintered_from()); |
307 | 286 |
308 TopLevelLiveRange* expected_source = | 287 TopLevelLiveRange* expected_source = |
309 TestRangeBuilder(zone()).Add(0, 2).Add(6, 8).Build(); | 288 TestRangeBuilder(zone()).Add(0, 2).Add(6, 8).Build(); |
310 TopLevelLiveRange* expected_splinter = | 289 TopLevelLiveRange* expected_splinter = |
311 TestRangeBuilder(zone()).Add(2, 3).Add(5, 6).Build(); | 290 TestRangeBuilder(zone()).Add(2, 3).Add(5, 6).Build(); |
312 EXPECT_TRUE(RangesMatch(expected_source, range)); | 291 EXPECT_TRUE(RangesMatch(expected_source, range)); |
313 EXPECT_TRUE(RangesMatch(expected_splinter, splinter)); | 292 EXPECT_TRUE(RangesMatch(expected_splinter, splinter)); |
314 } | 293 } |
315 | 294 |
316 | |
317 TEST_F(LiveRangeUnitTest, MergeMultipleIntervalsOutside) { | 295 TEST_F(LiveRangeUnitTest, MergeMultipleIntervalsOutside) { |
318 TopLevelLiveRange* original = | 296 TopLevelLiveRange* original = |
319 TestRangeBuilder(zone()).Add(0, 3).Add(5, 8).Build(); | 297 TestRangeBuilder(zone()).Add(0, 3).Add(5, 8).Build(); |
320 TopLevelLiveRange* splinter = Splinter(original, 2, 6); | 298 TopLevelLiveRange* splinter = Splinter(original, 2, 6); |
321 original->Merge(splinter, zone()); | 299 original->Merge(splinter, zone()); |
322 | 300 |
323 TopLevelLiveRange* result = | 301 TopLevelLiveRange* result = |
324 TestRangeBuilder(zone()).Add(0, 3).Add(5, 8).Build(); | 302 TestRangeBuilder(zone()).Add(0, 3).Add(5, 8).Build(); |
325 LiveRange* child_1 = Split(result, 2); | 303 LiveRange* child_1 = Split(result, 2); |
326 Split(child_1, 6); | 304 Split(child_1, 6); |
327 EXPECT_TRUE(RangesMatch(result, original)); | 305 EXPECT_TRUE(RangesMatch(result, original)); |
328 } | 306 } |
329 | 307 |
330 | |
331 TEST_F(LiveRangeUnitTest, SplinterMultipleIntervalsInside) { | 308 TEST_F(LiveRangeUnitTest, SplinterMultipleIntervalsInside) { |
332 TopLevelLiveRange* range = | 309 TopLevelLiveRange* range = |
333 TestRangeBuilder(zone()).Add(0, 3).Add(5, 8).Build(); | 310 TestRangeBuilder(zone()).Add(0, 3).Add(5, 8).Build(); |
334 V8_ASSERT_DEBUG_DEATH(Splinter(range, 3, 5), ".*"); | 311 V8_ASSERT_DEBUG_DEATH(Splinter(range, 3, 5), ".*"); |
335 } | 312 } |
336 | 313 |
337 | |
338 TEST_F(LiveRangeUnitTest, SplinterMultipleIntervalsLeft) { | 314 TEST_F(LiveRangeUnitTest, SplinterMultipleIntervalsLeft) { |
339 TopLevelLiveRange* range = | 315 TopLevelLiveRange* range = |
340 TestRangeBuilder(zone()).Add(0, 3).Add(5, 8).Build(); | 316 TestRangeBuilder(zone()).Add(0, 3).Add(5, 8).Build(); |
341 TopLevelLiveRange* splinter = Splinter(range, 2, 4); | 317 TopLevelLiveRange* splinter = Splinter(range, 2, 4); |
342 EXPECT_EQ(nullptr, range->next()); | 318 EXPECT_EQ(nullptr, range->next()); |
343 EXPECT_EQ(nullptr, splinter->next()); | 319 EXPECT_EQ(nullptr, splinter->next()); |
344 EXPECT_EQ(range, splinter->splintered_from()); | 320 EXPECT_EQ(range, splinter->splintered_from()); |
345 | 321 |
346 TopLevelLiveRange* expected_source = | 322 TopLevelLiveRange* expected_source = |
347 TestRangeBuilder(zone()).Add(0, 2).Add(5, 8).Build(); | 323 TestRangeBuilder(zone()).Add(0, 2).Add(5, 8).Build(); |
348 TopLevelLiveRange* expected_splinter = TestRangeBuilder(zone()).Build(2, 3); | 324 TopLevelLiveRange* expected_splinter = TestRangeBuilder(zone()).Build(2, 3); |
349 EXPECT_TRUE(RangesMatch(expected_source, range)); | 325 EXPECT_TRUE(RangesMatch(expected_source, range)); |
350 EXPECT_TRUE(RangesMatch(expected_splinter, splinter)); | 326 EXPECT_TRUE(RangesMatch(expected_splinter, splinter)); |
351 } | 327 } |
352 | 328 |
353 | |
354 TEST_F(LiveRangeUnitTest, MergeMultipleIntervalsLeft) { | 329 TEST_F(LiveRangeUnitTest, MergeMultipleIntervalsLeft) { |
355 TopLevelLiveRange* original = | 330 TopLevelLiveRange* original = |
356 TestRangeBuilder(zone()).Add(0, 3).Add(5, 8).Build(); | 331 TestRangeBuilder(zone()).Add(0, 3).Add(5, 8).Build(); |
357 TopLevelLiveRange* splinter = Splinter(original, 2, 4); | 332 TopLevelLiveRange* splinter = Splinter(original, 2, 4); |
358 original->Merge(splinter, zone()); | 333 original->Merge(splinter, zone()); |
359 | 334 |
360 TopLevelLiveRange* result = | 335 TopLevelLiveRange* result = |
361 TestRangeBuilder(zone()).Add(0, 3).Add(5, 8).Build(); | 336 TestRangeBuilder(zone()).Add(0, 3).Add(5, 8).Build(); |
362 Split(result, 2); | 337 Split(result, 2); |
363 EXPECT_TRUE(RangesMatch(result, original)); | 338 EXPECT_TRUE(RangesMatch(result, original)); |
364 } | 339 } |
365 | 340 |
366 | |
367 TEST_F(LiveRangeUnitTest, SplinterMultipleIntervalsRight) { | 341 TEST_F(LiveRangeUnitTest, SplinterMultipleIntervalsRight) { |
368 TopLevelLiveRange* range = | 342 TopLevelLiveRange* range = |
369 TestRangeBuilder(zone()).Add(0, 3).Add(5, 8).Build(); | 343 TestRangeBuilder(zone()).Add(0, 3).Add(5, 8).Build(); |
370 TopLevelLiveRange* splinter = Splinter(range, 4, 6); | 344 TopLevelLiveRange* splinter = Splinter(range, 4, 6); |
371 EXPECT_EQ(nullptr, range->next()); | 345 EXPECT_EQ(nullptr, range->next()); |
372 EXPECT_EQ(nullptr, splinter->next()); | 346 EXPECT_EQ(nullptr, splinter->next()); |
373 EXPECT_EQ(range, splinter->splintered_from()); | 347 EXPECT_EQ(range, splinter->splintered_from()); |
374 | 348 |
375 TopLevelLiveRange* expected_source = | 349 TopLevelLiveRange* expected_source = |
376 TestRangeBuilder(zone()).Add(0, 3).Add(6, 8).Build(); | 350 TestRangeBuilder(zone()).Add(0, 3).Add(6, 8).Build(); |
377 TopLevelLiveRange* expected_splinter = TestRangeBuilder(zone()).Build(5, 6); | 351 TopLevelLiveRange* expected_splinter = TestRangeBuilder(zone()).Build(5, 6); |
378 EXPECT_TRUE(RangesMatch(expected_source, range)); | 352 EXPECT_TRUE(RangesMatch(expected_source, range)); |
379 EXPECT_TRUE(RangesMatch(expected_splinter, splinter)); | 353 EXPECT_TRUE(RangesMatch(expected_splinter, splinter)); |
380 } | 354 } |
381 | 355 |
382 | |
383 TEST_F(LiveRangeUnitTest, SplinterMergeMultipleTimes) { | 356 TEST_F(LiveRangeUnitTest, SplinterMergeMultipleTimes) { |
384 TopLevelLiveRange* range = | 357 TopLevelLiveRange* range = |
385 TestRangeBuilder(zone()).Add(0, 3).Add(5, 10).Add(12, 16).Build(); | 358 TestRangeBuilder(zone()).Add(0, 3).Add(5, 10).Add(12, 16).Build(); |
386 Splinter(range, 4, 6); | 359 Splinter(range, 4, 6); |
387 Splinter(range, 8, 14); | 360 Splinter(range, 8, 14); |
388 TopLevelLiveRange* splinter = range->splinter(); | 361 TopLevelLiveRange* splinter = range->splinter(); |
389 EXPECT_EQ(nullptr, range->next()); | 362 EXPECT_EQ(nullptr, range->next()); |
390 EXPECT_EQ(nullptr, splinter->next()); | 363 EXPECT_EQ(nullptr, splinter->next()); |
391 EXPECT_EQ(range, splinter->splintered_from()); | 364 EXPECT_EQ(range, splinter->splintered_from()); |
392 | 365 |
393 TopLevelLiveRange* expected_source = | 366 TopLevelLiveRange* expected_source = |
394 TestRangeBuilder(zone()).Add(0, 3).Add(6, 8).Add(14, 16).Build(); | 367 TestRangeBuilder(zone()).Add(0, 3).Add(6, 8).Add(14, 16).Build(); |
395 TopLevelLiveRange* expected_splinter = | 368 TopLevelLiveRange* expected_splinter = |
396 TestRangeBuilder(zone()).Add(5, 6).Add(8, 10).Add(12, 14).Build(); | 369 TestRangeBuilder(zone()).Add(5, 6).Add(8, 10).Add(12, 14).Build(); |
397 EXPECT_TRUE(RangesMatch(expected_source, range)); | 370 EXPECT_TRUE(RangesMatch(expected_source, range)); |
398 EXPECT_TRUE(RangesMatch(expected_splinter, splinter)); | 371 EXPECT_TRUE(RangesMatch(expected_splinter, splinter)); |
399 } | 372 } |
400 | 373 |
401 | |
402 TEST_F(LiveRangeUnitTest, MergeMultipleIntervalsRight) { | 374 TEST_F(LiveRangeUnitTest, MergeMultipleIntervalsRight) { |
403 TopLevelLiveRange* original = | 375 TopLevelLiveRange* original = |
404 TestRangeBuilder(zone()).Add(0, 3).Add(5, 8).Build(); | 376 TestRangeBuilder(zone()).Add(0, 3).Add(5, 8).Build(); |
405 TopLevelLiveRange* splinter = Splinter(original, 4, 6); | 377 TopLevelLiveRange* splinter = Splinter(original, 4, 6); |
406 original->Merge(splinter, zone()); | 378 original->Merge(splinter, zone()); |
407 | 379 |
408 TopLevelLiveRange* result = | 380 TopLevelLiveRange* result = |
409 TestRangeBuilder(zone()).Add(0, 3).Add(5, 8).Build(); | 381 TestRangeBuilder(zone()).Add(0, 3).Add(5, 8).Build(); |
410 LiveRange* child_1 = Split(result, 5); | 382 LiveRange* child_1 = Split(result, 5); |
411 Split(child_1, 6); | 383 Split(child_1, 6); |
412 | 384 |
413 EXPECT_TRUE(RangesMatch(result, original)); | 385 EXPECT_TRUE(RangesMatch(result, original)); |
414 } | 386 } |
415 | 387 |
416 | |
417 TEST_F(LiveRangeUnitTest, MergeAfterSplitting) { | 388 TEST_F(LiveRangeUnitTest, MergeAfterSplitting) { |
418 TopLevelLiveRange* original = TestRangeBuilder(zone()).Build(0, 8); | 389 TopLevelLiveRange* original = TestRangeBuilder(zone()).Build(0, 8); |
419 TopLevelLiveRange* splinter = Splinter(original, 4, 6); | 390 TopLevelLiveRange* splinter = Splinter(original, 4, 6); |
420 LiveRange* original_child = Split(original, 2); | 391 LiveRange* original_child = Split(original, 2); |
421 Split(original_child, 7); | 392 Split(original_child, 7); |
422 original->Merge(splinter, zone()); | 393 original->Merge(splinter, zone()); |
423 | 394 |
424 TopLevelLiveRange* result = TestRangeBuilder(zone()).Build(0, 8); | 395 TopLevelLiveRange* result = TestRangeBuilder(zone()).Build(0, 8); |
425 LiveRange* child_1 = Split(result, 2); | 396 LiveRange* child_1 = Split(result, 2); |
426 LiveRange* child_2 = Split(child_1, 4); | 397 LiveRange* child_2 = Split(child_1, 4); |
427 LiveRange* child_3 = Split(child_2, 6); | 398 LiveRange* child_3 = Split(child_2, 6); |
428 Split(child_3, 7); | 399 Split(child_3, 7); |
429 | 400 |
430 EXPECT_TRUE(RangesMatch(result, original)); | 401 EXPECT_TRUE(RangesMatch(result, original)); |
431 } | 402 } |
432 | 403 |
433 | |
434 TEST_F(LiveRangeUnitTest, IDGeneration) { | 404 TEST_F(LiveRangeUnitTest, IDGeneration) { |
435 TopLevelLiveRange* vreg = TestRangeBuilder(zone()).Id(2).Build(0, 100); | 405 TopLevelLiveRange* vreg = TestRangeBuilder(zone()).Id(2).Build(0, 100); |
436 EXPECT_EQ(2, vreg->vreg()); | 406 EXPECT_EQ(2, vreg->vreg()); |
437 EXPECT_EQ(0, vreg->relative_id()); | 407 EXPECT_EQ(0, vreg->relative_id()); |
438 | 408 |
439 TopLevelLiveRange* splinter = | 409 TopLevelLiveRange* splinter = |
440 new (zone()) TopLevelLiveRange(101, MachineRepresentation::kTagged); | 410 new (zone()) TopLevelLiveRange(101, MachineRepresentation::kTagged); |
441 vreg->SetSplinter(splinter); | 411 vreg->SetSplinter(splinter); |
442 vreg->Splinter(LifetimePosition::FromInt(4), LifetimePosition::FromInt(12), | 412 vreg->Splinter(LifetimePosition::FromInt(4), LifetimePosition::FromInt(12), |
443 zone()); | 413 zone()); |
(...skipping 11 matching lines...) Expand all Loading... |
455 EXPECT_EQ(1, splinter->relative_id()); | 425 EXPECT_EQ(1, splinter->relative_id()); |
456 EXPECT_EQ(3, splinter_child->relative_id()); | 426 EXPECT_EQ(3, splinter_child->relative_id()); |
457 | 427 |
458 vreg->Merge(splinter, zone()); | 428 vreg->Merge(splinter, zone()); |
459 EXPECT_EQ(1, splinter->relative_id()); | 429 EXPECT_EQ(1, splinter->relative_id()); |
460 } | 430 } |
461 | 431 |
462 } // namespace compiler | 432 } // namespace compiler |
463 } // namespace internal | 433 } // namespace internal |
464 } // namespace v8 | 434 } // namespace v8 |
OLD | NEW |