Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(85)

Side by Side Diff: runtime/vm/intermediate_language_test.cc

Issue 328503003: Extend Range analysis to 64-bit range and mint operations (Closed) Base URL: https://dart.googlecode.com/svn/branches/bleeding_edge/dart
Patch Set: Created 6 years, 6 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
OLDNEW
1 // Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file 1 // Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file
2 // for details. All rights reserved. Use of this source code is governed by a 2 // for details. All rights reserved. Use of this source code is governed by a
3 // BSD-style license that can be found in the LICENSE file. 3 // BSD-style license that can be found in the LICENSE file.
4 4
5 #include "vm/intermediate_language.h" 5 #include "vm/intermediate_language.h"
6 #include "vm/unit_test.h" 6 #include "vm/unit_test.h"
7 7
8 namespace dart { 8 namespace dart {
9 9
10 TEST_CASE(InstructionTests) { 10 TEST_CASE(InstructionTests) {
(...skipping 104 matching lines...) Expand 10 before | Expand all | Expand 10 after
115 115
116 Range* unsatisfiable_right = new Range(RangeBoundary::PositiveInfinity(), 116 Range* unsatisfiable_right = new Range(RangeBoundary::PositiveInfinity(),
117 RangeBoundary::FromConstant(0)); 117 RangeBoundary::FromConstant(0));
118 EXPECT(unsatisfiable_right->IsUnsatisfiable()); 118 EXPECT(unsatisfiable_right->IsUnsatisfiable());
119 119
120 Range* unsatisfiable_left = new Range(RangeBoundary::FromConstant(0), 120 Range* unsatisfiable_left = new Range(RangeBoundary::FromConstant(0),
121 RangeBoundary::NegativeInfinity()); 121 RangeBoundary::NegativeInfinity());
122 EXPECT(unsatisfiable_left->IsUnsatisfiable()); 122 EXPECT(unsatisfiable_left->IsUnsatisfiable());
123 } 123 }
124 124
125
126 TEST_CASE(RangeUtils) {
127 // NULL case for IncludesNegativeInfinity().
128 EXPECT(Range::IncludesNegativeInfinity(NULL));
129
130 // [-inf, 0] case for IncludesNegativeInfinity().
131 EXPECT(Range::IncludesNegativeInfinity(
132 new Range(RangeBoundary::NegativeInfinity(),
133 RangeBoundary::FromConstant(0))));
134
135 // [0, inf] case for IncludesNegativeInfinity().
136 EXPECT(!Range::IncludesNegativeInfinity(
137 new Range(RangeBoundary::FromConstant(0),
138 RangeBoundary::PositiveInfinity())));
139
140 // NULL case for IncludesPositiveInfinity().
141 EXPECT(Range::IncludesPositiveInfinity(NULL));
142
143 // [-inf, 0] case for IncludesPositiveInfinity().
144 EXPECT(!Range::IncludesPositiveInfinity(
145 new Range(RangeBoundary::NegativeInfinity(),
146 RangeBoundary::FromConstant(0))));
147
148 // [0, inf] case for IncludesPositiveInfinity().
149 EXPECT(Range::IncludesPositiveInfinity(
150 new Range(RangeBoundary::FromConstant(0),
151 RangeBoundary::PositiveInfinity())));
152
153 // [-inf, +inf].
154 const Range& range_0 = *(new Range(RangeBoundary::NegativeInfinity(),
155 RangeBoundary::PositiveInfinity()));
156 // [-inf, -1].
157 const Range& range_a = *(new Range(RangeBoundary::NegativeInfinity(),
158 RangeBoundary::FromConstant(-1)));
159 // [-inf, 0].
160 const Range& range_b = *(new Range(RangeBoundary::NegativeInfinity(),
161 RangeBoundary::FromConstant(0)));
162 // [-inf, 1].
163 const Range& range_c = *(new Range(RangeBoundary::NegativeInfinity(),
164 RangeBoundary::FromConstant(1)));
165 // [-1, +inf]
166 const Range& range_d = *(new Range(RangeBoundary::FromConstant(-1),
167 RangeBoundary::PositiveInfinity()));
168 // [0, +inf]
169 const Range& range_e = *(new Range(RangeBoundary::FromConstant(0),
170 RangeBoundary::PositiveInfinity()));
171 // [1, +inf].
172 const Range& range_f = *(new Range(RangeBoundary::FromConstant(1),
173 RangeBoundary::PositiveInfinity()));
174 // [1, 2].
175 const Range& range_g = *(new Range(RangeBoundary::FromConstant(1),
176 RangeBoundary::FromConstant(2)));
177 // [-1, -2].
178 const Range& range_h = *(new Range(RangeBoundary::FromConstant(-1),
179 RangeBoundary::FromConstant(-2)));
180 // [-1, 1].
181 const Range& range_i = *(new Range(RangeBoundary::FromConstant(-1),
182 RangeBoundary::FromConstant(1)));
183
184 // OnlyPositiveOrZero.
185 EXPECT(!Range::OnlyPositiveOrZero(range_a, range_b));
186 EXPECT(!Range::OnlyPositiveOrZero(range_b, range_c));
187 EXPECT(!Range::OnlyPositiveOrZero(range_c, range_d));
188 EXPECT(!Range::OnlyPositiveOrZero(range_d, range_e));
189 EXPECT(Range::OnlyPositiveOrZero(range_e, range_f));
190 EXPECT(!Range::OnlyPositiveOrZero(range_d, range_d));
191 EXPECT(Range::OnlyPositiveOrZero(range_e, range_e));
192 EXPECT(Range::OnlyPositiveOrZero(range_f, range_g));
193 EXPECT(!Range::OnlyPositiveOrZero(range_g, range_h));
194 EXPECT(!Range::OnlyPositiveOrZero(range_i, range_i));
195
196 // OnlyNegativeOrZero.
197 EXPECT(Range::OnlyNegativeOrZero(range_a, range_b));
198 EXPECT(!Range::OnlyNegativeOrZero(range_b, range_c));
199 EXPECT(Range::OnlyNegativeOrZero(range_b, range_b));
200 EXPECT(!Range::OnlyNegativeOrZero(range_c, range_c));
201 EXPECT(!Range::OnlyNegativeOrZero(range_c, range_d));
202 EXPECT(!Range::OnlyNegativeOrZero(range_d, range_e));
203 EXPECT(!Range::OnlyNegativeOrZero(range_e, range_f));
204 EXPECT(!Range::OnlyNegativeOrZero(range_f, range_g));
205 EXPECT(!Range::OnlyNegativeOrZero(range_g, range_h));
206 EXPECT(Range::OnlyNegativeOrZero(range_h, range_h));
207 EXPECT(!Range::OnlyNegativeOrZero(range_i, range_i));
208
209 // [-inf, +inf].
210 EXPECT(!Range::OnlyNegativeOrZero(range_0, range_0));
211 EXPECT(!Range::OnlyPositiveOrZero(range_0, range_0));
212
213 EXPECT(Range::ConstantAbsMax(&range_0) == -Smi::kMinValue);
214 EXPECT(Range::ConstantAbsMax(&range_h) == 2);
215 EXPECT(Range::ConstantAbsMax(&range_i) == 1);
216
217 // RangeBOundary.Equals.
218 EXPECT(RangeBoundary::FromConstant(1).Equals(
219 RangeBoundary::FromConstant(1)));
220 EXPECT(!RangeBoundary::FromConstant(2).Equals(
221 RangeBoundary::FromConstant(1)));
222 EXPECT(RangeBoundary::PositiveInfinity().Equals(
223 RangeBoundary::PositiveInfinity()));
224 EXPECT(!RangeBoundary::PositiveInfinity().Equals(
225 RangeBoundary::NegativeInfinity()));
226 EXPECT(RangeBoundary::NegativeInfinity().Equals(
227 RangeBoundary::NegativeInfinity()));
228 EXPECT(!RangeBoundary::NegativeInfinity().Equals(
229 RangeBoundary::PositiveInfinity()));
230 EXPECT(!RangeBoundary::FromConstant(1).Equals(
231 RangeBoundary::NegativeInfinity()));
232 EXPECT(!RangeBoundary::FromConstant(1).Equals(
233 RangeBoundary::NegativeInfinity()));
234 EXPECT(!RangeBoundary::FromConstant(2).Equals(
235 RangeBoundary::PositiveInfinity()));
236 }
237
238
239 TEST_CASE(RangeBinaryOp) {
240 // Test that [0, +inf] + [-inf, 0] = [-inf, +inf].
241 Range* range_a = new Range(RangeBoundary::FromConstant(0),
242 RangeBoundary::PositiveInfinity());
243 EXPECT(range_a->min().ConstantValue() == 0);
244 EXPECT(range_a->max().IsPositiveInfinity());
245 Range* range_b = new Range(RangeBoundary::NegativeInfinity(),
246 RangeBoundary::FromConstant(0));
247 EXPECT(range_b->min().IsNegativeInfinity());
248 EXPECT(range_b->max().ConstantValue() == 0);
249 Range* result = Range::BinaryOp(Token::kADD,
250 range_a->min(),
251 range_a->max(),
252 range_a,
253 range_b,
254 NULL);
255 ASSERT(result != NULL);
256 EXPECT(result->min().IsNegativeInfinity());
257 EXPECT(result->max().IsPositiveInfinity());
258
259 // Test that [5, 10] + [0, 5] = [5, 15].
260 Range* range_c = new Range(RangeBoundary::FromConstant(5),
261 RangeBoundary::FromConstant(10));
262 Range* range_d = new Range(RangeBoundary::FromConstant(0),
263 RangeBoundary::FromConstant(5));
264 result = Range::BinaryOp(Token::kADD,
265 range_c->min(),
266 range_c->max(),
267 range_c,
268 range_d,
269 NULL);
270 ASSERT(result != NULL);
271 EXPECT(result->min().ConstantValue() == 5);
272 EXPECT(result->max().ConstantValue() == 15);
273
274
275 // Test that [0xff, 0xfff] & [0xf, 0xf] = [0x0, 0xf].
276 Range* range_e = new Range(RangeBoundary::FromConstant(0xff),
277 RangeBoundary::FromConstant(0xfff));
278 Range* range_f = new Range(RangeBoundary::FromConstant(0xf),
279 RangeBoundary::FromConstant(0xf));
280 result = Range::BinaryOp(Token::kBIT_AND,
281 range_e->min(),
282 range_e->max(),
283 range_e,
284 range_f,
285 Range::Unknown());
286 ASSERT(result != NULL);
287 EXPECT(result->min().ConstantValue() == 0x0);
288 EXPECT(result->max().ConstantValue() == 0xf);
289 }
290
291
292 TEST_CASE(RangeMinMax) {
293 // Constants.
294 // MIN(0, 1) == 0
295 EXPECT(RangeBoundary::Min(
296 RangeBoundary::FromConstant(0),
297 RangeBoundary::FromConstant(1)).ConstantValue() == 0);
298 // MIN(0, -1) == -1
299 EXPECT(RangeBoundary::Min(
300 RangeBoundary::FromConstant(0),
301 RangeBoundary::FromConstant(-1)).ConstantValue() == -1);
302
303 // MIN(1, 0) == 0
304 EXPECT(RangeBoundary::Min(
305 RangeBoundary::FromConstant(1),
306 RangeBoundary::FromConstant(0)).ConstantValue() == 0);
307 // MIN(-1, 0) == -1
308 EXPECT(RangeBoundary::Min(
309 RangeBoundary::FromConstant(-1),
310 RangeBoundary::FromConstant(0)).ConstantValue() == -1);
311
312 // MAX(0, 1) == 1
313 EXPECT(RangeBoundary::Max(
314 RangeBoundary::FromConstant(0),
315 RangeBoundary::FromConstant(1)).ConstantValue() == 1);
316 // MAX(0, -1) == 0
317 EXPECT(RangeBoundary::Max(
318 RangeBoundary::FromConstant(0),
319 RangeBoundary::FromConstant(-1)).ConstantValue() == 0);
320
321 // MAX(1, 0) == 1
322 EXPECT(RangeBoundary::Max(
323 RangeBoundary::FromConstant(1),
324 RangeBoundary::FromConstant(0)).ConstantValue() == 1);
325 // MAX(-1, 0) == 0
326 EXPECT(RangeBoundary::Max(
327 RangeBoundary::FromConstant(-1),
328 RangeBoundary::FromConstant(0)).ConstantValue() == 0);
329
330 // Infinities.
331 RangeBoundary n_infinity = RangeBoundary::NegativeInfinity();
332 RangeBoundary p_infinity = RangeBoundary::PositiveInfinity();
333
334 // MIN(-inf, +inf) == -inf.
335 EXPECT(RangeBoundary::Min(n_infinity, p_infinity).Equals(n_infinity));
336
337 // MIN(+inf, -inf) == -inf.
338 EXPECT(RangeBoundary::Min(p_infinity, n_infinity).Equals(n_infinity));
339
340 // MAX(-inf, +inf) == +inf.
341 EXPECT(RangeBoundary::Max(n_infinity, p_infinity).Equals(p_infinity));
342
343 // MAX(+inf, -inf) == +inf.
344 EXPECT(RangeBoundary::Max(p_infinity, n_infinity).Equals(p_infinity));
345 }
346
125 } // namespace dart 347 } // namespace dart
OLDNEW
« runtime/vm/intermediate_language.cc ('K') | « runtime/vm/intermediate_language.cc ('k') | no next file » | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698