OLD | NEW |
1 // Copyright 2014 the V8 project authors. All rights reserved. | 1 // Copyright 2014 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 #include "src/compiler/simplified-operator.h" | 5 #include "src/compiler/simplified-operator.h" |
6 #include "src/compiler/access-builder.h" | 6 #include "src/compiler/access-builder.h" |
7 #include "src/compiler/js-graph.h" | 7 #include "src/compiler/js-graph.h" |
8 #include "src/compiler/node-properties.h" | 8 #include "src/compiler/node-properties.h" |
9 #include "src/compiler/simplified-operator-reducer.h" | 9 #include "src/compiler/simplified-operator-reducer.h" |
10 #include "src/compiler/types.h" | 10 #include "src/compiler/types.h" |
(...skipping 79 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
90 29755, 30554, 16476817, 605431957, 832401070, 873617242, 914205764, | 90 29755, 30554, 16476817, 605431957, 832401070, 873617242, 914205764, |
91 1062628108, 1087581664, 1488498068, 1534668023, 1661587028, 1696896187, | 91 1062628108, 1087581664, 1488498068, 1534668023, 1661587028, 1696896187, |
92 1866841746, 2032089723, 2147483647}; | 92 1866841746, 2032089723, 2147483647}; |
93 | 93 |
94 | 94 |
95 const double kNaNs[] = {-std::numeric_limits<double>::quiet_NaN(), | 95 const double kNaNs[] = {-std::numeric_limits<double>::quiet_NaN(), |
96 std::numeric_limits<double>::quiet_NaN(), | 96 std::numeric_limits<double>::quiet_NaN(), |
97 bit_cast<double>(V8_UINT64_C(0x7FFFFFFFFFFFFFFF)), | 97 bit_cast<double>(V8_UINT64_C(0x7FFFFFFFFFFFFFFF)), |
98 bit_cast<double>(V8_UINT64_C(0xFFFFFFFFFFFFFFFF))}; | 98 bit_cast<double>(V8_UINT64_C(0xFFFFFFFFFFFFFFFF))}; |
99 | 99 |
| 100 const CheckForMinusZeroMode kCheckForMinusZeroModes[] = { |
| 101 CheckForMinusZeroMode::kDontCheckForMinusZero, |
| 102 CheckForMinusZeroMode::kCheckForMinusZero}; |
| 103 |
100 } // namespace | 104 } // namespace |
101 | 105 |
102 | 106 |
103 // ----------------------------------------------------------------------------- | 107 // ----------------------------------------------------------------------------- |
104 // BooleanNot | 108 // BooleanNot |
105 | 109 |
106 | 110 |
107 TEST_F(SimplifiedOperatorReducerTest, BooleanNotWithBooleanNot) { | 111 TEST_F(SimplifiedOperatorReducerTest, BooleanNotWithBooleanNot) { |
108 Node* param0 = Parameter(0); | 112 Node* param0 = Parameter(0); |
109 Reduction reduction = Reduce( | 113 Reduction reduction = Reduce( |
(...skipping 70 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
180 simplified()->ChangeTaggedToBit(), | 184 simplified()->ChangeTaggedToBit(), |
181 graph()->NewNode(simplified()->ChangeBitToTagged(), param0))); | 185 graph()->NewNode(simplified()->ChangeBitToTagged(), param0))); |
182 ASSERT_TRUE(reduction.Changed()); | 186 ASSERT_TRUE(reduction.Changed()); |
183 EXPECT_EQ(param0, reduction.replacement()); | 187 EXPECT_EQ(param0, reduction.replacement()); |
184 } | 188 } |
185 | 189 |
186 // ----------------------------------------------------------------------------- | 190 // ----------------------------------------------------------------------------- |
187 // ChangeFloat64ToTagged | 191 // ChangeFloat64ToTagged |
188 | 192 |
189 TEST_F(SimplifiedOperatorReducerTest, ChangeFloat64ToTaggedWithConstant) { | 193 TEST_F(SimplifiedOperatorReducerTest, ChangeFloat64ToTaggedWithConstant) { |
190 TRACED_FOREACH(double, n, kFloat64Values) { | 194 TRACED_FOREACH(CheckForMinusZeroMode, mode, kCheckForMinusZeroModes) { |
191 Reduction reduction = Reduce(graph()->NewNode( | 195 TRACED_FOREACH(double, n, kFloat64Values) { |
192 simplified()->ChangeFloat64ToTagged(), Float64Constant(n))); | 196 Reduction reduction = Reduce(graph()->NewNode( |
193 ASSERT_TRUE(reduction.Changed()); | 197 simplified()->ChangeFloat64ToTagged(mode), Float64Constant(n))); |
194 EXPECT_THAT(reduction.replacement(), IsNumberConstant(BitEq(n))); | 198 ASSERT_TRUE(reduction.Changed()); |
| 199 EXPECT_THAT(reduction.replacement(), IsNumberConstant(BitEq(n))); |
| 200 } |
195 } | 201 } |
196 } | 202 } |
197 | 203 |
198 // ----------------------------------------------------------------------------- | 204 // ----------------------------------------------------------------------------- |
199 // ChangeInt32ToTagged | 205 // ChangeInt32ToTagged |
200 | 206 |
201 | 207 |
202 TEST_F(SimplifiedOperatorReducerTest, ChangeInt32ToTaggedWithConstant) { | 208 TEST_F(SimplifiedOperatorReducerTest, ChangeInt32ToTaggedWithConstant) { |
203 TRACED_FOREACH(int32_t, n, kInt32Values) { | 209 TRACED_FOREACH(int32_t, n, kInt32Values) { |
204 Reduction reduction = Reduce(graph()->NewNode( | 210 Reduction reduction = Reduce(graph()->NewNode( |
205 simplified()->ChangeInt32ToTagged(), Int32Constant(n))); | 211 simplified()->ChangeInt32ToTagged(), Int32Constant(n))); |
206 ASSERT_TRUE(reduction.Changed()); | 212 ASSERT_TRUE(reduction.Changed()); |
207 EXPECT_THAT(reduction.replacement(), IsNumberConstant(BitEq(FastI2D(n)))); | 213 EXPECT_THAT(reduction.replacement(), IsNumberConstant(BitEq(FastI2D(n)))); |
208 } | 214 } |
209 } | 215 } |
210 | 216 |
211 | 217 |
212 // ----------------------------------------------------------------------------- | 218 // ----------------------------------------------------------------------------- |
213 // ChangeTaggedToFloat64 | 219 // ChangeTaggedToFloat64 |
214 | 220 |
215 | 221 |
216 TEST_F(SimplifiedOperatorReducerTest, | 222 TEST_F(SimplifiedOperatorReducerTest, |
217 ChangeTaggedToFloat64WithChangeFloat64ToTagged) { | 223 ChangeTaggedToFloat64WithChangeFloat64ToTagged) { |
218 Node* param0 = Parameter(0); | 224 Node* param0 = Parameter(0); |
219 Reduction reduction = Reduce(graph()->NewNode( | 225 TRACED_FOREACH(CheckForMinusZeroMode, mode, kCheckForMinusZeroModes) { |
220 simplified()->ChangeTaggedToFloat64(), | 226 Reduction reduction = Reduce(graph()->NewNode( |
221 graph()->NewNode(simplified()->ChangeFloat64ToTagged(), param0))); | 227 simplified()->ChangeTaggedToFloat64(), |
222 ASSERT_TRUE(reduction.Changed()); | 228 graph()->NewNode(simplified()->ChangeFloat64ToTagged(mode), param0))); |
223 EXPECT_EQ(param0, reduction.replacement()); | 229 ASSERT_TRUE(reduction.Changed()); |
| 230 EXPECT_EQ(param0, reduction.replacement()); |
| 231 } |
224 } | 232 } |
225 | 233 |
226 TEST_F(SimplifiedOperatorReducerTest, | 234 TEST_F(SimplifiedOperatorReducerTest, |
227 ChangeTaggedToFloat64WithChangeInt32ToTagged) { | 235 ChangeTaggedToFloat64WithChangeInt32ToTagged) { |
228 Node* param0 = Parameter(0); | 236 Node* param0 = Parameter(0); |
229 Reduction reduction = Reduce(graph()->NewNode( | 237 Reduction reduction = Reduce(graph()->NewNode( |
230 simplified()->ChangeTaggedToFloat64(), | 238 simplified()->ChangeTaggedToFloat64(), |
231 graph()->NewNode(simplified()->ChangeInt32ToTagged(), param0))); | 239 graph()->NewNode(simplified()->ChangeInt32ToTagged(), param0))); |
232 ASSERT_TRUE(reduction.Changed()); | 240 ASSERT_TRUE(reduction.Changed()); |
233 EXPECT_THAT(reduction.replacement(), IsChangeInt32ToFloat64(param0)); | 241 EXPECT_THAT(reduction.replacement(), IsChangeInt32ToFloat64(param0)); |
(...skipping 30 matching lines...) Expand all Loading... |
264 } | 272 } |
265 } | 273 } |
266 | 274 |
267 | 275 |
268 // ----------------------------------------------------------------------------- | 276 // ----------------------------------------------------------------------------- |
269 // ChangeTaggedToInt32 | 277 // ChangeTaggedToInt32 |
270 | 278 |
271 TEST_F(SimplifiedOperatorReducerTest, | 279 TEST_F(SimplifiedOperatorReducerTest, |
272 ChangeTaggedToInt32WithChangeFloat64ToTagged) { | 280 ChangeTaggedToInt32WithChangeFloat64ToTagged) { |
273 Node* param0 = Parameter(0); | 281 Node* param0 = Parameter(0); |
274 Reduction reduction = Reduce(graph()->NewNode( | 282 TRACED_FOREACH(CheckForMinusZeroMode, mode, kCheckForMinusZeroModes) { |
275 simplified()->ChangeTaggedToInt32(), | 283 Reduction reduction = Reduce(graph()->NewNode( |
276 graph()->NewNode(simplified()->ChangeFloat64ToTagged(), param0))); | 284 simplified()->ChangeTaggedToInt32(), |
277 ASSERT_TRUE(reduction.Changed()); | 285 graph()->NewNode(simplified()->ChangeFloat64ToTagged(mode), param0))); |
278 EXPECT_THAT(reduction.replacement(), IsChangeFloat64ToInt32(param0)); | 286 ASSERT_TRUE(reduction.Changed()); |
| 287 EXPECT_THAT(reduction.replacement(), IsChangeFloat64ToInt32(param0)); |
| 288 } |
279 } | 289 } |
280 | 290 |
281 TEST_F(SimplifiedOperatorReducerTest, | 291 TEST_F(SimplifiedOperatorReducerTest, |
282 ChangeTaggedToInt32WithChangeInt32ToTagged) { | 292 ChangeTaggedToInt32WithChangeInt32ToTagged) { |
283 Node* param0 = Parameter(0); | 293 Node* param0 = Parameter(0); |
284 Reduction reduction = Reduce(graph()->NewNode( | 294 Reduction reduction = Reduce(graph()->NewNode( |
285 simplified()->ChangeTaggedToInt32(), | 295 simplified()->ChangeTaggedToInt32(), |
286 graph()->NewNode(simplified()->ChangeInt32ToTagged(), param0))); | 296 graph()->NewNode(simplified()->ChangeInt32ToTagged(), param0))); |
287 ASSERT_TRUE(reduction.Changed()); | 297 ASSERT_TRUE(reduction.Changed()); |
288 EXPECT_EQ(param0, reduction.replacement()); | 298 EXPECT_EQ(param0, reduction.replacement()); |
289 } | 299 } |
290 | 300 |
291 | 301 |
292 // ----------------------------------------------------------------------------- | 302 // ----------------------------------------------------------------------------- |
293 // ChangeTaggedToUint32 | 303 // ChangeTaggedToUint32 |
294 | 304 |
295 TEST_F(SimplifiedOperatorReducerTest, | 305 TEST_F(SimplifiedOperatorReducerTest, |
296 ChangeTaggedToUint32WithChangeFloat64ToTagged) { | 306 ChangeTaggedToUint32WithChangeFloat64ToTagged) { |
297 Node* param0 = Parameter(0); | 307 Node* param0 = Parameter(0); |
298 Reduction reduction = Reduce(graph()->NewNode( | 308 TRACED_FOREACH(CheckForMinusZeroMode, mode, kCheckForMinusZeroModes) { |
299 simplified()->ChangeTaggedToUint32(), | 309 Reduction reduction = Reduce(graph()->NewNode( |
300 graph()->NewNode(simplified()->ChangeFloat64ToTagged(), param0))); | 310 simplified()->ChangeTaggedToUint32(), |
301 ASSERT_TRUE(reduction.Changed()); | 311 graph()->NewNode(simplified()->ChangeFloat64ToTagged(mode), param0))); |
302 EXPECT_THAT(reduction.replacement(), IsChangeFloat64ToUint32(param0)); | 312 ASSERT_TRUE(reduction.Changed()); |
| 313 EXPECT_THAT(reduction.replacement(), IsChangeFloat64ToUint32(param0)); |
| 314 } |
303 } | 315 } |
304 | 316 |
305 TEST_F(SimplifiedOperatorReducerTest, | 317 TEST_F(SimplifiedOperatorReducerTest, |
306 ChangeTaggedToUint32WithChangeUint32ToTagged) { | 318 ChangeTaggedToUint32WithChangeUint32ToTagged) { |
307 Node* param0 = Parameter(0); | 319 Node* param0 = Parameter(0); |
308 Reduction reduction = Reduce(graph()->NewNode( | 320 Reduction reduction = Reduce(graph()->NewNode( |
309 simplified()->ChangeTaggedToUint32(), | 321 simplified()->ChangeTaggedToUint32(), |
310 graph()->NewNode(simplified()->ChangeUint32ToTagged(), param0))); | 322 graph()->NewNode(simplified()->ChangeUint32ToTagged(), param0))); |
311 ASSERT_TRUE(reduction.Changed()); | 323 ASSERT_TRUE(reduction.Changed()); |
312 EXPECT_EQ(param0, reduction.replacement()); | 324 EXPECT_EQ(param0, reduction.replacement()); |
313 } | 325 } |
314 | 326 |
315 | 327 |
316 // ----------------------------------------------------------------------------- | 328 // ----------------------------------------------------------------------------- |
317 // TruncateTaggedToWord32 | 329 // TruncateTaggedToWord32 |
318 | 330 |
319 TEST_F(SimplifiedOperatorReducerTest, | 331 TEST_F(SimplifiedOperatorReducerTest, |
320 TruncateTaggedToWord3WithChangeFloat64ToTagged) { | 332 TruncateTaggedToWord3WithChangeFloat64ToTagged) { |
321 Node* param0 = Parameter(0); | 333 Node* param0 = Parameter(0); |
322 Reduction reduction = Reduce(graph()->NewNode( | 334 TRACED_FOREACH(CheckForMinusZeroMode, mode, kCheckForMinusZeroModes) { |
323 simplified()->TruncateTaggedToWord32(), | 335 Reduction reduction = Reduce(graph()->NewNode( |
324 graph()->NewNode(simplified()->ChangeFloat64ToTagged(), param0))); | 336 simplified()->TruncateTaggedToWord32(), |
325 ASSERT_TRUE(reduction.Changed()); | 337 graph()->NewNode(simplified()->ChangeFloat64ToTagged(mode), param0))); |
326 EXPECT_THAT(reduction.replacement(), IsTruncateFloat64ToWord32(param0)); | 338 ASSERT_TRUE(reduction.Changed()); |
| 339 EXPECT_THAT(reduction.replacement(), IsTruncateFloat64ToWord32(param0)); |
| 340 } |
327 } | 341 } |
328 | 342 |
329 TEST_F(SimplifiedOperatorReducerTest, TruncateTaggedToWord32WithConstant) { | 343 TEST_F(SimplifiedOperatorReducerTest, TruncateTaggedToWord32WithConstant) { |
330 TRACED_FOREACH(double, n, kFloat64Values) { | 344 TRACED_FOREACH(double, n, kFloat64Values) { |
331 Reduction reduction = Reduce(graph()->NewNode( | 345 Reduction reduction = Reduce(graph()->NewNode( |
332 simplified()->TruncateTaggedToWord32(), NumberConstant(n))); | 346 simplified()->TruncateTaggedToWord32(), NumberConstant(n))); |
333 ASSERT_TRUE(reduction.Changed()); | 347 ASSERT_TRUE(reduction.Changed()); |
334 EXPECT_THAT(reduction.replacement(), IsInt32Constant(DoubleToInt32(n))); | 348 EXPECT_THAT(reduction.replacement(), IsInt32Constant(DoubleToInt32(n))); |
335 } | 349 } |
336 } | 350 } |
(...skipping 143 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
480 Reduction reduction = Reduce( | 494 Reduction reduction = Reduce( |
481 graph()->NewNode(simplified()->ObjectIsSmi(), NumberConstant(n))); | 495 graph()->NewNode(simplified()->ObjectIsSmi(), NumberConstant(n))); |
482 ASSERT_TRUE(reduction.Changed()); | 496 ASSERT_TRUE(reduction.Changed()); |
483 EXPECT_THAT(reduction.replacement(), IsBooleanConstant(IsSmiDouble(n))); | 497 EXPECT_THAT(reduction.replacement(), IsBooleanConstant(IsSmiDouble(n))); |
484 } | 498 } |
485 } | 499 } |
486 | 500 |
487 } // namespace compiler | 501 } // namespace compiler |
488 } // namespace internal | 502 } // namespace internal |
489 } // namespace v8 | 503 } // namespace v8 |
OLD | NEW |