OLD | NEW |
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 Loading... |
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 |
OLD | NEW |