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/code-stubs.h" | 5 #include "src/code-stubs.h" |
6 #include "src/compiler/change-lowering.h" | 6 #include "src/compiler/change-lowering.h" |
7 #include "src/compiler/js-graph.h" | 7 #include "src/compiler/js-graph.h" |
8 #include "src/compiler/linkage.h" | 8 #include "src/compiler/linkage.h" |
9 #include "src/compiler/node-properties.h" | 9 #include "src/compiler/node-properties.h" |
10 #include "src/compiler/simplified-operator.h" | 10 #include "src/compiler/simplified-operator.h" |
(...skipping 174 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
185 FieldAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize, | 185 FieldAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize, |
186 Handle<Name>::null(), Type::Any(), | 186 Handle<Name>::null(), Type::Any(), |
187 MachineType::AnyTagged()}; | 187 MachineType::AnyTagged()}; |
188 Node* p0 = Parameter(Type::TaggedPointer()); | 188 Node* p0 = Parameter(Type::TaggedPointer()); |
189 Node* p1 = Parameter(Type::TaggedSigned()); | 189 Node* p1 = Parameter(Type::TaggedSigned()); |
190 Node* store = graph()->NewNode(simplified()->StoreField(access), p0, p1, | 190 Node* store = graph()->NewNode(simplified()->StoreField(access), p0, p1, |
191 graph()->start(), graph()->start()); | 191 graph()->start(), graph()->start()); |
192 Reduction r = Reduce(store); | 192 Reduction r = Reduce(store); |
193 | 193 |
194 ASSERT_TRUE(r.Changed()); | 194 ASSERT_TRUE(r.Changed()); |
195 EXPECT_THAT( | 195 EXPECT_THAT(r.replacement(), |
196 r.replacement(), | 196 IsStore(StoreRepresentation(MachineRepresentation::kTagged, |
197 IsStore(StoreRepresentation(MachineType::AnyTagged(), kNoWriteBarrier), | 197 kNoWriteBarrier), |
198 p0, IsIntPtrConstant(access.offset - access.tag()), p1, | 198 p0, IsIntPtrConstant(access.offset - access.tag()), p1, |
199 graph()->start(), graph()->start())); | 199 graph()->start(), graph()->start())); |
200 } | 200 } |
201 | 201 |
202 | 202 |
203 TARGET_TEST_P(ChangeLoweringCommonTest, StoreFieldTagged) { | 203 TARGET_TEST_P(ChangeLoweringCommonTest, StoreFieldTagged) { |
204 FieldAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize, | 204 FieldAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize, |
205 Handle<Name>::null(), Type::Any(), | 205 Handle<Name>::null(), Type::Any(), |
206 MachineType::AnyTagged()}; | 206 MachineType::AnyTagged()}; |
207 Node* p0 = Parameter(Type::TaggedPointer()); | 207 Node* p0 = Parameter(Type::TaggedPointer()); |
208 Node* p1 = Parameter(Type::Tagged()); | 208 Node* p1 = Parameter(Type::Tagged()); |
209 Node* store = graph()->NewNode(simplified()->StoreField(access), p0, p1, | 209 Node* store = graph()->NewNode(simplified()->StoreField(access), p0, p1, |
210 graph()->start(), graph()->start()); | 210 graph()->start(), graph()->start()); |
211 Reduction r = Reduce(store); | 211 Reduction r = Reduce(store); |
212 | 212 |
213 ASSERT_TRUE(r.Changed()); | 213 ASSERT_TRUE(r.Changed()); |
214 EXPECT_THAT( | 214 EXPECT_THAT(r.replacement(), |
215 r.replacement(), | 215 IsStore(StoreRepresentation(MachineRepresentation::kTagged, |
216 IsStore(StoreRepresentation(MachineType::AnyTagged(), kFullWriteBarrier), | 216 kFullWriteBarrier), |
217 p0, IsIntPtrConstant(access.offset - access.tag()), p1, | 217 p0, IsIntPtrConstant(access.offset - access.tag()), p1, |
218 graph()->start(), graph()->start())); | 218 graph()->start(), graph()->start())); |
219 } | 219 } |
220 | 220 |
221 | 221 |
222 TARGET_TEST_P(ChangeLoweringCommonTest, LoadField) { | 222 TARGET_TEST_P(ChangeLoweringCommonTest, LoadField) { |
223 FieldAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize, | 223 FieldAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize, |
224 Handle<Name>::null(), Type::Any(), | 224 Handle<Name>::null(), Type::Any(), |
225 MachineType::AnyTagged()}; | 225 MachineType::AnyTagged()}; |
226 Node* p0 = Parameter(Type::TaggedPointer()); | 226 Node* p0 = Parameter(Type::TaggedPointer()); |
227 Node* load = graph()->NewNode(simplified()->LoadField(access), p0, | 227 Node* load = graph()->NewNode(simplified()->LoadField(access), p0, |
228 graph()->start(), graph()->start()); | 228 graph()->start(), graph()->start()); |
(...skipping 21 matching lines...) Expand all Loading... |
250 const int element_size_shift = | 250 const int element_size_shift = |
251 ElementSizeLog2Of(access.machine_type.representation()); | 251 ElementSizeLog2Of(access.machine_type.representation()); |
252 ASSERT_TRUE(r.Changed()); | 252 ASSERT_TRUE(r.Changed()); |
253 Matcher<Node*> index_match = | 253 Matcher<Node*> index_match = |
254 IsInt32Add(IsWord32Shl(p1, IsInt32Constant(element_size_shift)), | 254 IsInt32Add(IsWord32Shl(p1, IsInt32Constant(element_size_shift)), |
255 IsInt32Constant(access.header_size - access.tag())); | 255 IsInt32Constant(access.header_size - access.tag())); |
256 if (!Is32()) { | 256 if (!Is32()) { |
257 index_match = IsChangeUint32ToUint64(index_match); | 257 index_match = IsChangeUint32ToUint64(index_match); |
258 } | 258 } |
259 | 259 |
260 EXPECT_THAT( | 260 EXPECT_THAT(r.replacement(), |
261 r.replacement(), | 261 IsStore(StoreRepresentation(MachineRepresentation::kTagged, |
262 IsStore(StoreRepresentation(MachineType::AnyTagged(), kFullWriteBarrier), | 262 kFullWriteBarrier), |
263 p0, index_match, p2, graph()->start(), graph()->start())); | 263 p0, index_match, p2, graph()->start(), graph()->start())); |
264 } | 264 } |
265 | 265 |
266 | 266 |
267 TARGET_TEST_P(ChangeLoweringCommonTest, StoreElementUint8) { | 267 TARGET_TEST_P(ChangeLoweringCommonTest, StoreElementUint8) { |
268 ElementAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize, | 268 ElementAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize, |
269 Type::Signed32(), MachineType::Uint8()}; | 269 Type::Signed32(), MachineType::Uint8()}; |
270 Node* p0 = Parameter(Type::TaggedPointer()); | 270 Node* p0 = Parameter(Type::TaggedPointer()); |
271 Node* p1 = Parameter(Type::Signed32()); | 271 Node* p1 = Parameter(Type::Signed32()); |
272 Node* p2 = Parameter(Type::Signed32()); | 272 Node* p2 = Parameter(Type::Signed32()); |
273 Node* store = graph()->NewNode(simplified()->StoreElement(access), p0, p1, p2, | 273 Node* store = graph()->NewNode(simplified()->StoreElement(access), p0, p1, p2, |
274 graph()->start(), graph()->start()); | 274 graph()->start(), graph()->start()); |
275 Reduction r = Reduce(store); | 275 Reduction r = Reduce(store); |
276 | 276 |
277 ASSERT_TRUE(r.Changed()); | 277 ASSERT_TRUE(r.Changed()); |
278 Matcher<Node*> index_match = | 278 Matcher<Node*> index_match = |
279 IsInt32Add(p1, IsInt32Constant(access.header_size - access.tag())); | 279 IsInt32Add(p1, IsInt32Constant(access.header_size - access.tag())); |
280 if (!Is32()) { | 280 if (!Is32()) { |
281 index_match = IsChangeUint32ToUint64(index_match); | 281 index_match = IsChangeUint32ToUint64(index_match); |
282 } | 282 } |
283 | 283 |
284 EXPECT_THAT( | 284 EXPECT_THAT(r.replacement(), |
285 r.replacement(), | 285 IsStore(StoreRepresentation(MachineRepresentation::kWord8, |
286 IsStore(StoreRepresentation(MachineType::Uint8(), kNoWriteBarrier), p0, | 286 kNoWriteBarrier), |
287 index_match, p2, graph()->start(), graph()->start())); | 287 p0, index_match, p2, graph()->start(), graph()->start())); |
288 } | 288 } |
289 | 289 |
290 | 290 |
291 TARGET_TEST_P(ChangeLoweringCommonTest, LoadElementTagged) { | 291 TARGET_TEST_P(ChangeLoweringCommonTest, LoadElementTagged) { |
292 ElementAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize, Type::Any(), | 292 ElementAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize, Type::Any(), |
293 MachineType::AnyTagged()}; | 293 MachineType::AnyTagged()}; |
294 Node* p0 = Parameter(Type::TaggedPointer()); | 294 Node* p0 = Parameter(Type::TaggedPointer()); |
295 Node* p1 = Parameter(Type::Signed32()); | 295 Node* p1 = Parameter(Type::Signed32()); |
296 Node* load = graph()->NewNode(simplified()->LoadElement(access), p0, p1, | 296 Node* load = graph()->NewNode(simplified()->LoadElement(access), p0, p1, |
297 graph()->start(), graph()->start()); | 297 graph()->start(), graph()->start()); |
(...skipping 66 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
364 | 364 |
365 | 365 |
366 TARGET_TEST_F(ChangeLowering32Test, ChangeInt32ToTagged) { | 366 TARGET_TEST_F(ChangeLowering32Test, ChangeInt32ToTagged) { |
367 Node* value = Parameter(Type::Integral32()); | 367 Node* value = Parameter(Type::Integral32()); |
368 Node* node = graph()->NewNode(simplified()->ChangeInt32ToTagged(), value); | 368 Node* node = graph()->NewNode(simplified()->ChangeInt32ToTagged(), value); |
369 Reduction r = Reduce(node); | 369 Reduction r = Reduce(node); |
370 ASSERT_TRUE(r.Changed()); | 370 ASSERT_TRUE(r.Changed()); |
371 Capture<Node*> add, branch, heap_number, if_true; | 371 Capture<Node*> add, branch, heap_number, if_true; |
372 EXPECT_THAT( | 372 EXPECT_THAT( |
373 r.replacement(), | 373 r.replacement(), |
374 IsPhi( | 374 IsPhi(MachineRepresentation::kTagged, |
375 MachineRepresentation::kTagged, | 375 IsFinishRegion( |
376 IsFinishRegion( | 376 AllOf(CaptureEq(&heap_number), |
377 AllOf(CaptureEq(&heap_number), | 377 IsAllocateHeapNumber(_, CaptureEq(&if_true))), |
378 IsAllocateHeapNumber(_, CaptureEq(&if_true))), | 378 IsStore( |
379 IsStore( | 379 StoreRepresentation(MachineRepresentation::kFloat64, |
380 StoreRepresentation(MachineType::Float64(), kNoWriteBarrier), | 380 kNoWriteBarrier), |
381 CaptureEq(&heap_number), | 381 CaptureEq(&heap_number), |
382 IsIntPtrConstant(HeapNumber::kValueOffset - kHeapObjectTag), | 382 IsIntPtrConstant(HeapNumber::kValueOffset - kHeapObjectTag), |
383 IsChangeInt32ToFloat64(value), CaptureEq(&heap_number), | 383 IsChangeInt32ToFloat64(value), CaptureEq(&heap_number), |
384 CaptureEq(&if_true))), | 384 CaptureEq(&if_true))), |
385 IsProjection( | 385 IsProjection(0, AllOf(CaptureEq(&add), |
386 0, AllOf(CaptureEq(&add), IsInt32AddWithOverflow(value, value))), | 386 IsInt32AddWithOverflow(value, value))), |
387 IsMerge(AllOf(CaptureEq(&if_true), IsIfTrue(CaptureEq(&branch))), | 387 IsMerge(AllOf(CaptureEq(&if_true), IsIfTrue(CaptureEq(&branch))), |
388 IsIfFalse(AllOf(CaptureEq(&branch), | 388 IsIfFalse(AllOf(CaptureEq(&branch), |
389 IsBranch(IsProjection(1, CaptureEq(&add)), | 389 IsBranch(IsProjection(1, CaptureEq(&add)), |
390 graph()->start())))))); | 390 graph()->start())))))); |
391 } | 391 } |
392 | 392 |
393 | 393 |
394 TARGET_TEST_F(ChangeLowering32Test, ChangeTaggedToFloat64) { | 394 TARGET_TEST_F(ChangeLowering32Test, ChangeTaggedToFloat64) { |
395 STATIC_ASSERT(kSmiTag == 0); | 395 STATIC_ASSERT(kSmiTag == 0); |
396 STATIC_ASSERT(kSmiTagSize == 1); | 396 STATIC_ASSERT(kSmiTagSize == 1); |
397 | 397 |
398 Node* value = Parameter(Type::Number()); | 398 Node* value = Parameter(Type::Number()); |
399 Node* node = graph()->NewNode(simplified()->ChangeTaggedToFloat64(), value); | 399 Node* node = graph()->NewNode(simplified()->ChangeTaggedToFloat64(), value); |
400 Reduction r = Reduce(node); | 400 Reduction r = Reduce(node); |
(...skipping 72 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
473 Capture<Node*> branch, heap_number, if_false; | 473 Capture<Node*> branch, heap_number, if_false; |
474 EXPECT_THAT( | 474 EXPECT_THAT( |
475 r.replacement(), | 475 r.replacement(), |
476 IsPhi( | 476 IsPhi( |
477 MachineRepresentation::kTagged, | 477 MachineRepresentation::kTagged, |
478 IsWord32Shl(value, IsInt32Constant(kSmiTagSize + kSmiShiftSize)), | 478 IsWord32Shl(value, IsInt32Constant(kSmiTagSize + kSmiShiftSize)), |
479 IsFinishRegion( | 479 IsFinishRegion( |
480 AllOf(CaptureEq(&heap_number), | 480 AllOf(CaptureEq(&heap_number), |
481 IsAllocateHeapNumber(_, CaptureEq(&if_false))), | 481 IsAllocateHeapNumber(_, CaptureEq(&if_false))), |
482 IsStore( | 482 IsStore( |
483 StoreRepresentation(MachineType::Float64(), kNoWriteBarrier), | 483 StoreRepresentation(MachineRepresentation::kFloat64, |
| 484 kNoWriteBarrier), |
484 CaptureEq(&heap_number), | 485 CaptureEq(&heap_number), |
485 IsInt32Constant(HeapNumber::kValueOffset - kHeapObjectTag), | 486 IsInt32Constant(HeapNumber::kValueOffset - kHeapObjectTag), |
486 IsChangeUint32ToFloat64(value), CaptureEq(&heap_number), | 487 IsChangeUint32ToFloat64(value), CaptureEq(&heap_number), |
487 CaptureEq(&if_false))), | 488 CaptureEq(&if_false))), |
488 IsMerge(IsIfTrue(AllOf( | 489 IsMerge(IsIfTrue(AllOf( |
489 CaptureEq(&branch), | 490 CaptureEq(&branch), |
490 IsBranch(IsUint32LessThanOrEqual( | 491 IsBranch(IsUint32LessThanOrEqual( |
491 value, IsInt32Constant(Smi::kMaxValue)), | 492 value, IsInt32Constant(Smi::kMaxValue)), |
492 graph()->start()))), | 493 graph()->start()))), |
493 AllOf(CaptureEq(&if_false), IsIfFalse(CaptureEq(&branch)))))); | 494 AllOf(CaptureEq(&if_false), IsIfFalse(CaptureEq(&branch)))))); |
(...skipping 107 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
601 EXPECT_THAT( | 602 EXPECT_THAT( |
602 r.replacement(), | 603 r.replacement(), |
603 IsPhi( | 604 IsPhi( |
604 MachineRepresentation::kTagged, | 605 MachineRepresentation::kTagged, |
605 IsWord64Shl(IsChangeUint32ToUint64(value), | 606 IsWord64Shl(IsChangeUint32ToUint64(value), |
606 IsInt64Constant(kSmiTagSize + kSmiShiftSize)), | 607 IsInt64Constant(kSmiTagSize + kSmiShiftSize)), |
607 IsFinishRegion( | 608 IsFinishRegion( |
608 AllOf(CaptureEq(&heap_number), | 609 AllOf(CaptureEq(&heap_number), |
609 IsAllocateHeapNumber(_, CaptureEq(&if_false))), | 610 IsAllocateHeapNumber(_, CaptureEq(&if_false))), |
610 IsStore( | 611 IsStore( |
611 StoreRepresentation(MachineType::Float64(), kNoWriteBarrier), | 612 StoreRepresentation(MachineRepresentation::kFloat64, |
| 613 kNoWriteBarrier), |
612 CaptureEq(&heap_number), | 614 CaptureEq(&heap_number), |
613 IsInt64Constant(HeapNumber::kValueOffset - kHeapObjectTag), | 615 IsInt64Constant(HeapNumber::kValueOffset - kHeapObjectTag), |
614 IsChangeUint32ToFloat64(value), CaptureEq(&heap_number), | 616 IsChangeUint32ToFloat64(value), CaptureEq(&heap_number), |
615 CaptureEq(&if_false))), | 617 CaptureEq(&if_false))), |
616 IsMerge(IsIfTrue(AllOf( | 618 IsMerge(IsIfTrue(AllOf( |
617 CaptureEq(&branch), | 619 CaptureEq(&branch), |
618 IsBranch(IsUint32LessThanOrEqual( | 620 IsBranch(IsUint32LessThanOrEqual( |
619 value, IsInt32Constant(Smi::kMaxValue)), | 621 value, IsInt32Constant(Smi::kMaxValue)), |
620 graph()->start()))), | 622 graph()->start()))), |
621 AllOf(CaptureEq(&if_false), IsIfFalse(CaptureEq(&branch)))))); | 623 AllOf(CaptureEq(&if_false), IsIfFalse(CaptureEq(&branch)))))); |
622 } | 624 } |
623 | 625 |
624 } // namespace compiler | 626 } // namespace compiler |
625 } // namespace internal | 627 } // namespace internal |
626 } // namespace v8 | 628 } // namespace v8 |
OLD | NEW |