| // Copyright 2018 the V8 project authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "src/compiler/redundancy-elimination.h" |
| #include "src/compiler/common-operator.h" |
| #include "test/unittests/compiler/graph-reducer-unittest.h" |
| #include "test/unittests/compiler/graph-unittest.h" |
| #include "test/unittests/compiler/node-test-utils.h" |
| #include "testing/gmock-support.h" |
| |
| using testing::_; |
| using testing::NiceMock; |
| |
| namespace v8 { |
| namespace internal { |
| namespace compiler { |
| namespace redundancy_elimination_unittest { |
| |
| class RedundancyEliminationTest : public GraphTest { |
| public: |
| explicit RedundancyEliminationTest(int num_parameters = 4) |
| : GraphTest(num_parameters), |
| reducer_(&editor_, zone()), |
| simplified_(zone()) { |
| // Initialize the {reducer_} state for the Start node. |
| reducer_.Reduce(graph()->start()); |
| |
| // Create a feedback vector with two CALL_IC slots. |
| FeedbackVectorSpec spec(zone()); |
| FeedbackSlot slot1 = spec.AddCallICSlot(); |
| FeedbackSlot slot2 = spec.AddCallICSlot(); |
| Handle<FeedbackMetadata> metadata = FeedbackMetadata::New(isolate(), &spec); |
| Handle<SharedFunctionInfo> shared = |
| isolate()->factory()->NewSharedFunctionInfoForBuiltin( |
| isolate()->factory()->empty_string(), Builtins::kIllegal); |
| shared->set_raw_outer_scope_info_or_feedback_metadata(*metadata); |
| Handle<FeedbackVector> feedback_vector = |
| FeedbackVector::New(isolate(), shared); |
| vector_slot_pairs_.push_back(VectorSlotPair()); |
| vector_slot_pairs_.push_back( |
| VectorSlotPair(feedback_vector, slot1, UNINITIALIZED)); |
| vector_slot_pairs_.push_back( |
| VectorSlotPair(feedback_vector, slot2, UNINITIALIZED)); |
| } |
| ~RedundancyEliminationTest() override = default; |
| |
| protected: |
| Reduction Reduce(Node* node) { return reducer_.Reduce(node); } |
| |
| std::vector<VectorSlotPair> const& vector_slot_pairs() const { |
| return vector_slot_pairs_; |
| } |
| SimplifiedOperatorBuilder* simplified() { return &simplified_; } |
| |
| private: |
| NiceMock<MockAdvancedReducerEditor> editor_; |
| std::vector<VectorSlotPair> vector_slot_pairs_; |
| VectorSlotPair feedback2_; |
| RedundancyElimination reducer_; |
| SimplifiedOperatorBuilder simplified_; |
| }; |
| |
| namespace { |
| |
| const CheckForMinusZeroMode kCheckForMinusZeroModes[] = { |
| CheckForMinusZeroMode::kCheckForMinusZero, |
| CheckForMinusZeroMode::kDontCheckForMinusZero, |
| }; |
| |
| const CheckTaggedInputMode kCheckTaggedInputModes[] = { |
| CheckTaggedInputMode::kNumber, CheckTaggedInputMode::kNumberOrOddball}; |
| |
| const NumberOperationHint kNumberOperationHints[] = { |
| NumberOperationHint::kSignedSmall, |
| NumberOperationHint::kSignedSmallInputs, |
| NumberOperationHint::kSigned32, |
| NumberOperationHint::kNumber, |
| NumberOperationHint::kNumberOrOddball, |
| }; |
| |
| } // namespace |
| |
| // ----------------------------------------------------------------------------- |
| // CheckBounds |
| |
| TEST_F(RedundancyEliminationTest, CheckBounds) { |
| TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) { |
| TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) { |
| Node* index = Parameter(0); |
| Node* length = Parameter(1); |
| Node* effect = graph()->start(); |
| Node* control = graph()->start(); |
| |
| Node* check1 = effect = graph()->NewNode( |
| simplified()->CheckBounds(feedback1), index, length, effect, control); |
| Reduction r1 = Reduce(check1); |
| ASSERT_TRUE(r1.Changed()); |
| EXPECT_EQ(r1.replacement(), check1); |
| |
| Node* check2 = effect = graph()->NewNode( |
| simplified()->CheckBounds(feedback2), index, length, effect, control); |
| Reduction r2 = Reduce(check2); |
| ASSERT_TRUE(r2.Changed()); |
| EXPECT_EQ(r2.replacement(), check1); |
| } |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| // CheckNumber |
| |
| TEST_F(RedundancyEliminationTest, CheckNumberSubsumedByCheckSmi) { |
| TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) { |
| TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) { |
| Node* value = Parameter(0); |
| Node* effect = graph()->start(); |
| Node* control = graph()->start(); |
| |
| Node* check1 = effect = graph()->NewNode( |
| simplified()->CheckSmi(feedback1), value, effect, control); |
| Reduction r1 = Reduce(check1); |
| ASSERT_TRUE(r1.Changed()); |
| EXPECT_EQ(r1.replacement(), check1); |
| |
| Node* check2 = effect = graph()->NewNode( |
| simplified()->CheckNumber(feedback2), value, effect, control); |
| Reduction r2 = Reduce(check2); |
| ASSERT_TRUE(r2.Changed()); |
| EXPECT_EQ(r2.replacement(), check1); |
| } |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| // CheckReceiver |
| |
| TEST_F(RedundancyEliminationTest, CheckReceiver) { |
| Node* value = Parameter(0); |
| Node* effect = graph()->start(); |
| Node* control = graph()->start(); |
| |
| Node* check1 = effect = |
| graph()->NewNode(simplified()->CheckReceiver(), value, effect, control); |
| Reduction r1 = Reduce(check1); |
| ASSERT_TRUE(r1.Changed()); |
| EXPECT_EQ(r1.replacement(), check1); |
| |
| Node* check2 = effect = |
| graph()->NewNode(simplified()->CheckReceiver(), value, effect, control); |
| Reduction r2 = Reduce(check2); |
| ASSERT_TRUE(r2.Changed()); |
| EXPECT_EQ(r2.replacement(), check1); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| // CheckReceiverOrNullOrUndefined |
| |
| TEST_F(RedundancyEliminationTest, CheckReceiverOrNullOrUndefined) { |
| Node* value = Parameter(0); |
| Node* effect = graph()->start(); |
| Node* control = graph()->start(); |
| |
| Node* check1 = effect = graph()->NewNode( |
| simplified()->CheckReceiverOrNullOrUndefined(), value, effect, control); |
| Reduction r1 = Reduce(check1); |
| ASSERT_TRUE(r1.Changed()); |
| EXPECT_EQ(r1.replacement(), check1); |
| |
| Node* check2 = effect = graph()->NewNode( |
| simplified()->CheckReceiverOrNullOrUndefined(), value, effect, control); |
| Reduction r2 = Reduce(check2); |
| ASSERT_TRUE(r2.Changed()); |
| EXPECT_EQ(r2.replacement(), check1); |
| } |
| |
| TEST_F(RedundancyEliminationTest, |
| CheckReceiverOrNullOrUndefinedSubsumedByCheckReceiver) { |
| Node* value = Parameter(0); |
| Node* effect = graph()->start(); |
| Node* control = graph()->start(); |
| |
| Node* check1 = effect = |
| graph()->NewNode(simplified()->CheckReceiver(), value, effect, control); |
| Reduction r1 = Reduce(check1); |
| ASSERT_TRUE(r1.Changed()); |
| EXPECT_EQ(r1.replacement(), check1); |
| |
| Node* check2 = effect = graph()->NewNode( |
| simplified()->CheckReceiverOrNullOrUndefined(), value, effect, control); |
| Reduction r2 = Reduce(check2); |
| ASSERT_TRUE(r2.Changed()); |
| EXPECT_EQ(r2.replacement(), check1); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| // CheckString |
| |
| TEST_F(RedundancyEliminationTest, |
| CheckStringSubsumedByCheckInternalizedString) { |
| TRACED_FOREACH(VectorSlotPair, feedback, vector_slot_pairs()) { |
| Node* value = Parameter(0); |
| Node* effect = graph()->start(); |
| Node* control = graph()->start(); |
| |
| Node* check1 = effect = graph()->NewNode( |
| simplified()->CheckInternalizedString(), value, effect, control); |
| Reduction r1 = Reduce(check1); |
| ASSERT_TRUE(r1.Changed()); |
| EXPECT_EQ(r1.replacement(), check1); |
| |
| Node* check2 = effect = graph()->NewNode( |
| simplified()->CheckString(feedback), value, effect, control); |
| Reduction r2 = Reduce(check2); |
| ASSERT_TRUE(r2.Changed()); |
| EXPECT_EQ(r2.replacement(), check1); |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| // CheckSymbol |
| |
| TEST_F(RedundancyEliminationTest, CheckSymbol) { |
| Node* value = Parameter(0); |
| Node* effect = graph()->start(); |
| Node* control = graph()->start(); |
| |
| Node* check1 = effect = |
| graph()->NewNode(simplified()->CheckSymbol(), value, effect, control); |
| Reduction r1 = Reduce(check1); |
| ASSERT_TRUE(r1.Changed()); |
| EXPECT_EQ(r1.replacement(), check1); |
| |
| Node* check2 = effect = |
| graph()->NewNode(simplified()->CheckSymbol(), value, effect, control); |
| Reduction r2 = Reduce(check2); |
| ASSERT_TRUE(r2.Changed()); |
| EXPECT_EQ(r2.replacement(), check1); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| // CheckedFloat64ToInt32 |
| |
| TEST_F(RedundancyEliminationTest, CheckedFloat64ToInt32) { |
| TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) { |
| TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) { |
| TRACED_FOREACH(CheckForMinusZeroMode, mode, kCheckForMinusZeroModes) { |
| Node* value = Parameter(0); |
| Node* effect = graph()->start(); |
| Node* control = graph()->start(); |
| |
| Node* check1 = effect = graph()->NewNode( |
| simplified()->CheckedFloat64ToInt32(mode, feedback1), value, effect, |
| control); |
| Reduction r1 = Reduce(check1); |
| ASSERT_TRUE(r1.Changed()); |
| EXPECT_EQ(r1.replacement(), check1); |
| |
| Node* check2 = effect = graph()->NewNode( |
| simplified()->CheckedFloat64ToInt32(mode, feedback2), value, effect, |
| control); |
| Reduction r2 = Reduce(check2); |
| ASSERT_TRUE(r2.Changed()); |
| EXPECT_EQ(r2.replacement(), check1); |
| } |
| } |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| // CheckedFloat64ToInt64 |
| |
| TEST_F(RedundancyEliminationTest, CheckedFloat64ToInt64) { |
| TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) { |
| TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) { |
| TRACED_FOREACH(CheckForMinusZeroMode, mode, kCheckForMinusZeroModes) { |
| Node* value = Parameter(0); |
| Node* effect = graph()->start(); |
| Node* control = graph()->start(); |
| |
| Node* check1 = effect = graph()->NewNode( |
| simplified()->CheckedFloat64ToInt64(mode, feedback1), value, effect, |
| control); |
| Reduction r1 = Reduce(check1); |
| ASSERT_TRUE(r1.Changed()); |
| EXPECT_EQ(r1.replacement(), check1); |
| |
| Node* check2 = effect = graph()->NewNode( |
| simplified()->CheckedFloat64ToInt64(mode, feedback2), value, effect, |
| control); |
| Reduction r2 = Reduce(check2); |
| ASSERT_TRUE(r2.Changed()); |
| EXPECT_EQ(r2.replacement(), check1); |
| } |
| } |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| // CheckedInt32ToTaggedSigned |
| |
| TEST_F(RedundancyEliminationTest, CheckedInt32ToTaggedSigned) { |
| TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) { |
| TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) { |
| Node* value = Parameter(0); |
| Node* effect = graph()->start(); |
| Node* control = graph()->start(); |
| |
| Node* check1 = effect = |
| graph()->NewNode(simplified()->CheckedInt32ToTaggedSigned(feedback1), |
| value, effect, control); |
| Reduction r1 = Reduce(check1); |
| ASSERT_TRUE(r1.Changed()); |
| EXPECT_EQ(r1.replacement(), check1); |
| |
| Node* check2 = effect = |
| graph()->NewNode(simplified()->CheckedInt32ToTaggedSigned(feedback2), |
| value, effect, control); |
| Reduction r2 = Reduce(check2); |
| ASSERT_TRUE(r2.Changed()); |
| EXPECT_EQ(r2.replacement(), check1); |
| } |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| // CheckedInt64ToInt32 |
| |
| TEST_F(RedundancyEliminationTest, CheckedInt64ToInt32) { |
| TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) { |
| TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) { |
| Node* value = Parameter(0); |
| Node* effect = graph()->start(); |
| Node* control = graph()->start(); |
| |
| Node* check1 = effect = graph()->NewNode( |
| simplified()->CheckedInt64ToInt32(feedback1), value, effect, control); |
| Reduction r1 = Reduce(check1); |
| ASSERT_TRUE(r1.Changed()); |
| EXPECT_EQ(r1.replacement(), check1); |
| |
| Node* check2 = effect = graph()->NewNode( |
| simplified()->CheckedInt64ToInt32(feedback2), value, effect, control); |
| Reduction r2 = Reduce(check2); |
| ASSERT_TRUE(r2.Changed()); |
| EXPECT_EQ(r2.replacement(), check1); |
| } |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| // CheckedInt64ToTaggedSigned |
| |
| TEST_F(RedundancyEliminationTest, CheckedInt64ToTaggedSigned) { |
| TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) { |
| TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) { |
| Node* value = Parameter(0); |
| Node* effect = graph()->start(); |
| Node* control = graph()->start(); |
| |
| Node* check1 = effect = |
| graph()->NewNode(simplified()->CheckedInt64ToTaggedSigned(feedback1), |
| value, effect, control); |
| Reduction r1 = Reduce(check1); |
| ASSERT_TRUE(r1.Changed()); |
| EXPECT_EQ(r1.replacement(), check1); |
| |
| Node* check2 = effect = |
| graph()->NewNode(simplified()->CheckedInt64ToTaggedSigned(feedback2), |
| value, effect, control); |
| Reduction r2 = Reduce(check2); |
| ASSERT_TRUE(r2.Changed()); |
| EXPECT_EQ(r2.replacement(), check1); |
| } |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| // CheckedTaggedSignedToInt32 |
| |
| TEST_F(RedundancyEliminationTest, CheckedTaggedSignedToInt32) { |
| TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) { |
| TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) { |
| Node* value = Parameter(0); |
| Node* effect = graph()->start(); |
| Node* control = graph()->start(); |
| |
| Node* check1 = effect = |
| graph()->NewNode(simplified()->CheckedTaggedSignedToInt32(feedback1), |
| value, effect, control); |
| Reduction r1 = Reduce(check1); |
| ASSERT_TRUE(r1.Changed()); |
| EXPECT_EQ(r1.replacement(), check1); |
| |
| Node* check2 = effect = |
| graph()->NewNode(simplified()->CheckedTaggedSignedToInt32(feedback2), |
| value, effect, control); |
| Reduction r2 = Reduce(check2); |
| ASSERT_TRUE(r2.Changed()); |
| EXPECT_EQ(r2.replacement(), check1); |
| } |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| // CheckedTaggedToFloat64 |
| |
| TEST_F(RedundancyEliminationTest, CheckedTaggedToFloat64) { |
| TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) { |
| TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) { |
| TRACED_FOREACH(CheckTaggedInputMode, mode, kCheckTaggedInputModes) { |
| Node* value = Parameter(0); |
| Node* effect = graph()->start(); |
| Node* control = graph()->start(); |
| |
| Node* check1 = effect = graph()->NewNode( |
| simplified()->CheckedTaggedToFloat64(mode, feedback1), value, |
| effect, control); |
| Reduction r1 = Reduce(check1); |
| ASSERT_TRUE(r1.Changed()); |
| EXPECT_EQ(r1.replacement(), check1); |
| |
| Node* check2 = effect = graph()->NewNode( |
| simplified()->CheckedTaggedToFloat64(mode, feedback2), value, |
| effect, control); |
| Reduction r2 = Reduce(check2); |
| ASSERT_TRUE(r2.Changed()); |
| EXPECT_EQ(r2.replacement(), check1); |
| } |
| } |
| } |
| } |
| |
| TEST_F(RedundancyEliminationTest, |
| CheckedTaggedToFloat64SubsubmedByCheckedTaggedToFloat64) { |
| TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) { |
| TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) { |
| Node* value = Parameter(0); |
| Node* effect = graph()->start(); |
| Node* control = graph()->start(); |
| |
| // If the check passed for CheckTaggedInputMode::kNumber, it'll |
| // also pass later for CheckTaggedInputMode::kNumberOrOddball. |
| Node* check1 = effect = |
| graph()->NewNode(simplified()->CheckedTaggedToFloat64( |
| CheckTaggedInputMode::kNumber, feedback1), |
| value, effect, control); |
| Reduction r1 = Reduce(check1); |
| ASSERT_TRUE(r1.Changed()); |
| EXPECT_EQ(r1.replacement(), check1); |
| |
| Node* check2 = effect = graph()->NewNode( |
| simplified()->CheckedTaggedToFloat64( |
| CheckTaggedInputMode::kNumberOrOddball, feedback2), |
| value, effect, control); |
| Reduction r2 = Reduce(check2); |
| ASSERT_TRUE(r2.Changed()); |
| EXPECT_EQ(r2.replacement(), check1); |
| } |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| // CheckedTaggedToInt32 |
| |
| TEST_F(RedundancyEliminationTest, CheckedTaggedToInt32) { |
| TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) { |
| TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) { |
| TRACED_FOREACH(CheckForMinusZeroMode, mode, kCheckForMinusZeroModes) { |
| Node* value = Parameter(0); |
| Node* effect = graph()->start(); |
| Node* control = graph()->start(); |
| |
| Node* check1 = effect = graph()->NewNode( |
| simplified()->CheckedTaggedToInt32(mode, feedback1), value, effect, |
| control); |
| Reduction r1 = Reduce(check1); |
| ASSERT_TRUE(r1.Changed()); |
| EXPECT_EQ(r1.replacement(), check1); |
| |
| Node* check2 = effect = graph()->NewNode( |
| simplified()->CheckedTaggedToInt32(mode, feedback2), value, effect, |
| control); |
| Reduction r2 = Reduce(check2); |
| ASSERT_TRUE(r2.Changed()); |
| EXPECT_EQ(r2.replacement(), check1); |
| } |
| } |
| } |
| } |
| |
| TEST_F(RedundancyEliminationTest, |
| CheckedTaggedToInt32SubsumedByCheckedTaggedSignedToInt32) { |
| TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) { |
| TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) { |
| TRACED_FOREACH(CheckForMinusZeroMode, mode, kCheckForMinusZeroModes) { |
| Node* value = Parameter(0); |
| Node* effect = graph()->start(); |
| Node* control = graph()->start(); |
| |
| Node* check1 = effect = graph()->NewNode( |
| simplified()->CheckedTaggedSignedToInt32(feedback1), value, effect, |
| control); |
| Reduction r1 = Reduce(check1); |
| ASSERT_TRUE(r1.Changed()); |
| EXPECT_EQ(r1.replacement(), check1); |
| |
| Node* check2 = effect = graph()->NewNode( |
| simplified()->CheckedTaggedToInt32(mode, feedback2), value, effect, |
| control); |
| Reduction r2 = Reduce(check2); |
| ASSERT_TRUE(r2.Changed()); |
| EXPECT_EQ(r2.replacement(), check1); |
| } |
| } |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| // CheckedTaggedToInt64 |
| |
| TEST_F(RedundancyEliminationTest, CheckedTaggedToInt64) { |
| TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) { |
| TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) { |
| TRACED_FOREACH(CheckForMinusZeroMode, mode, kCheckForMinusZeroModes) { |
| Node* value = Parameter(0); |
| Node* effect = graph()->start(); |
| Node* control = graph()->start(); |
| |
| Node* check1 = effect = graph()->NewNode( |
| simplified()->CheckedTaggedToInt64(mode, feedback1), value, effect, |
| control); |
| Reduction r1 = Reduce(check1); |
| ASSERT_TRUE(r1.Changed()); |
| EXPECT_EQ(r1.replacement(), check1); |
| |
| Node* check2 = effect = graph()->NewNode( |
| simplified()->CheckedTaggedToInt64(mode, feedback2), value, effect, |
| control); |
| Reduction r2 = Reduce(check2); |
| ASSERT_TRUE(r2.Changed()); |
| EXPECT_EQ(r2.replacement(), check1); |
| } |
| } |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| // CheckedTaggedToTaggedPointer |
| |
| TEST_F(RedundancyEliminationTest, CheckedTaggedToTaggedPointer) { |
| TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) { |
| TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) { |
| Node* value = Parameter(0); |
| Node* effect = graph()->start(); |
| Node* control = graph()->start(); |
| |
| Node* check1 = effect = graph()->NewNode( |
| simplified()->CheckedTaggedToTaggedPointer(feedback1), value, effect, |
| control); |
| Reduction r1 = Reduce(check1); |
| ASSERT_TRUE(r1.Changed()); |
| EXPECT_EQ(r1.replacement(), check1); |
| |
| Node* check2 = effect = graph()->NewNode( |
| simplified()->CheckedTaggedToTaggedPointer(feedback2), value, effect, |
| control); |
| Reduction r2 = Reduce(check2); |
| ASSERT_TRUE(r2.Changed()); |
| EXPECT_EQ(r2.replacement(), check1); |
| } |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| // CheckedTaggedToTaggedSigned |
| |
| TEST_F(RedundancyEliminationTest, CheckedTaggedToTaggedSigned) { |
| TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) { |
| TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) { |
| Node* value = Parameter(0); |
| Node* effect = graph()->start(); |
| Node* control = graph()->start(); |
| |
| Node* check1 = effect = |
| graph()->NewNode(simplified()->CheckedTaggedToTaggedSigned(feedback1), |
| value, effect, control); |
| Reduction r1 = Reduce(check1); |
| ASSERT_TRUE(r1.Changed()); |
| EXPECT_EQ(r1.replacement(), check1); |
| |
| Node* check2 = effect = |
| graph()->NewNode(simplified()->CheckedTaggedToTaggedSigned(feedback2), |
| value, effect, control); |
| Reduction r2 = Reduce(check2); |
| ASSERT_TRUE(r2.Changed()); |
| EXPECT_EQ(r2.replacement(), check1); |
| } |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| // CheckedTruncateTaggedToWord32 |
| |
| TEST_F(RedundancyEliminationTest, CheckedTruncateTaggedToWord32) { |
| TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) { |
| TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) { |
| TRACED_FOREACH(CheckTaggedInputMode, mode, kCheckTaggedInputModes) { |
| Node* value = Parameter(0); |
| Node* effect = graph()->start(); |
| Node* control = graph()->start(); |
| |
| Node* check1 = effect = graph()->NewNode( |
| simplified()->CheckedTruncateTaggedToWord32(mode, feedback1), value, |
| effect, control); |
| Reduction r1 = Reduce(check1); |
| ASSERT_TRUE(r1.Changed()); |
| EXPECT_EQ(r1.replacement(), check1); |
| |
| Node* check2 = effect = graph()->NewNode( |
| simplified()->CheckedTruncateTaggedToWord32(mode, feedback2), value, |
| effect, control); |
| Reduction r2 = Reduce(check2); |
| ASSERT_TRUE(r2.Changed()); |
| EXPECT_EQ(r2.replacement(), check1); |
| } |
| } |
| } |
| } |
| |
| TEST_F(RedundancyEliminationTest, |
| CheckedTruncateTaggedToWord32SubsumedByCheckedTruncateTaggedToWord32) { |
| TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) { |
| TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) { |
| Node* value = Parameter(0); |
| Node* effect = graph()->start(); |
| Node* control = graph()->start(); |
| |
| // If the check passed for CheckTaggedInputMode::kNumber, it'll |
| // also pass later for CheckTaggedInputMode::kNumberOrOddball. |
| Node* check1 = effect = |
| graph()->NewNode(simplified()->CheckedTruncateTaggedToWord32( |
| CheckTaggedInputMode::kNumber, feedback1), |
| value, effect, control); |
| Reduction r1 = Reduce(check1); |
| ASSERT_TRUE(r1.Changed()); |
| EXPECT_EQ(r1.replacement(), check1); |
| |
| Node* check2 = effect = graph()->NewNode( |
| simplified()->CheckedTruncateTaggedToWord32( |
| CheckTaggedInputMode::kNumberOrOddball, feedback2), |
| value, effect, control); |
| Reduction r2 = Reduce(check2); |
| ASSERT_TRUE(r2.Changed()); |
| EXPECT_EQ(r2.replacement(), check1); |
| } |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| // CheckedUint32Bounds |
| |
| TEST_F(RedundancyEliminationTest, CheckedUint32Bounds) { |
| TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) { |
| TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) { |
| Node* index = Parameter(0); |
| Node* length = Parameter(1); |
| Node* effect = graph()->start(); |
| Node* control = graph()->start(); |
| |
| Node* check1 = effect = |
| graph()->NewNode(simplified()->CheckedUint32Bounds(feedback1), index, |
| length, effect, control); |
| Reduction r1 = Reduce(check1); |
| ASSERT_TRUE(r1.Changed()); |
| EXPECT_EQ(r1.replacement(), check1); |
| |
| Node* check2 = effect = |
| graph()->NewNode(simplified()->CheckedUint32Bounds(feedback2), index, |
| length, effect, control); |
| Reduction r2 = Reduce(check2); |
| ASSERT_TRUE(r2.Changed()); |
| EXPECT_EQ(r2.replacement(), check1); |
| } |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| // CheckedUint32ToInt32 |
| |
| TEST_F(RedundancyEliminationTest, CheckedUint32ToInt32) { |
| TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) { |
| TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) { |
| Node* value = Parameter(0); |
| Node* effect = graph()->start(); |
| Node* control = graph()->start(); |
| |
| Node* check1 = effect = |
| graph()->NewNode(simplified()->CheckedUint32ToInt32(feedback1), value, |
| effect, control); |
| Reduction r1 = Reduce(check1); |
| ASSERT_TRUE(r1.Changed()); |
| EXPECT_EQ(r1.replacement(), check1); |
| |
| Node* check2 = effect = |
| graph()->NewNode(simplified()->CheckedUint32ToInt32(feedback2), value, |
| effect, control); |
| Reduction r2 = Reduce(check2); |
| ASSERT_TRUE(r2.Changed()); |
| EXPECT_EQ(r2.replacement(), check1); |
| } |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| // CheckedUint32ToTaggedSigned |
| |
| TEST_F(RedundancyEliminationTest, CheckedUint32ToTaggedSigned) { |
| TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) { |
| TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) { |
| Node* value = Parameter(0); |
| Node* effect = graph()->start(); |
| Node* control = graph()->start(); |
| |
| Node* check1 = effect = |
| graph()->NewNode(simplified()->CheckedUint32ToTaggedSigned(feedback1), |
| value, effect, control); |
| Reduction r1 = Reduce(check1); |
| ASSERT_TRUE(r1.Changed()); |
| EXPECT_EQ(r1.replacement(), check1); |
| |
| Node* check2 = effect = |
| graph()->NewNode(simplified()->CheckedUint32ToTaggedSigned(feedback2), |
| value, effect, control); |
| Reduction r2 = Reduce(check2); |
| ASSERT_TRUE(r2.Changed()); |
| EXPECT_EQ(r2.replacement(), check1); |
| } |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| // CheckedUint64Bounds |
| |
| TEST_F(RedundancyEliminationTest, CheckedUint64Bounds) { |
| TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) { |
| TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) { |
| Node* index = Parameter(0); |
| Node* length = Parameter(1); |
| Node* effect = graph()->start(); |
| Node* control = graph()->start(); |
| |
| Node* check1 = effect = |
| graph()->NewNode(simplified()->CheckedUint64Bounds(feedback1), index, |
| length, effect, control); |
| Reduction r1 = Reduce(check1); |
| ASSERT_TRUE(r1.Changed()); |
| EXPECT_EQ(r1.replacement(), check1); |
| |
| Node* check2 = effect = |
| graph()->NewNode(simplified()->CheckedUint64Bounds(feedback2), index, |
| length, effect, control); |
| Reduction r2 = Reduce(check2); |
| ASSERT_TRUE(r2.Changed()); |
| EXPECT_EQ(r2.replacement(), check1); |
| } |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| // CheckedUint64ToInt32 |
| |
| TEST_F(RedundancyEliminationTest, CheckedUint64ToInt32) { |
| TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) { |
| TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) { |
| Node* value = Parameter(0); |
| Node* effect = graph()->start(); |
| Node* control = graph()->start(); |
| |
| Node* check1 = effect = |
| graph()->NewNode(simplified()->CheckedUint64ToInt32(feedback1), value, |
| effect, control); |
| Reduction r1 = Reduce(check1); |
| ASSERT_TRUE(r1.Changed()); |
| EXPECT_EQ(r1.replacement(), check1); |
| |
| Node* check2 = effect = |
| graph()->NewNode(simplified()->CheckedUint64ToInt32(feedback2), value, |
| effect, control); |
| Reduction r2 = Reduce(check2); |
| ASSERT_TRUE(r2.Changed()); |
| EXPECT_EQ(r2.replacement(), check1); |
| } |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| // CheckedUint64ToTaggedSigned |
| |
| TEST_F(RedundancyEliminationTest, CheckedUint64ToTaggedSigned) { |
| TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) { |
| TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) { |
| Node* value = Parameter(0); |
| Node* effect = graph()->start(); |
| Node* control = graph()->start(); |
| |
| Node* check1 = effect = |
| graph()->NewNode(simplified()->CheckedUint64ToTaggedSigned(feedback1), |
| value, effect, control); |
| Reduction r1 = Reduce(check1); |
| ASSERT_TRUE(r1.Changed()); |
| EXPECT_EQ(r1.replacement(), check1); |
| |
| Node* check2 = effect = |
| graph()->NewNode(simplified()->CheckedUint64ToTaggedSigned(feedback2), |
| value, effect, control); |
| Reduction r2 = Reduce(check2); |
| ASSERT_TRUE(r2.Changed()); |
| EXPECT_EQ(r2.replacement(), check1); |
| } |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| // SpeculativeNumberEqual |
| |
| TEST_F(RedundancyEliminationTest, |
| SpeculativeNumberEqualWithCheckBoundsBetterType) { |
| Typer typer(broker(), Typer::kNoFlags, graph()); |
| TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) { |
| TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) { |
| Node* lhs = Parameter(Type::Any(), 0); |
| Node* rhs = Parameter(Type::Any(), 1); |
| Node* length = Parameter(Type::Unsigned31(), 2); |
| Node* effect = graph()->start(); |
| Node* control = graph()->start(); |
| |
| Node* check1 = effect = graph()->NewNode( |
| simplified()->CheckBounds(feedback1), lhs, length, effect, control); |
| Reduction r1 = Reduce(check1); |
| ASSERT_TRUE(r1.Changed()); |
| EXPECT_EQ(r1.replacement(), check1); |
| |
| Node* check2 = effect = graph()->NewNode( |
| simplified()->CheckBounds(feedback2), rhs, length, effect, control); |
| Reduction r2 = Reduce(check2); |
| ASSERT_TRUE(r2.Changed()); |
| EXPECT_EQ(r2.replacement(), check2); |
| |
| Node* cmp3 = effect = |
| graph()->NewNode(simplified()->SpeculativeNumberEqual( |
| NumberOperationHint::kSignedSmall), |
| lhs, rhs, effect, control); |
| Reduction r3 = Reduce(cmp3); |
| ASSERT_TRUE(r3.Changed()); |
| EXPECT_THAT(r3.replacement(), |
| IsSpeculativeNumberEqual(NumberOperationHint::kSignedSmall, |
| check1, check2, _, _)); |
| } |
| } |
| } |
| |
| TEST_F(RedundancyEliminationTest, |
| SpeculativeNumberEqualWithCheckBoundsSameType) { |
| Typer typer(broker(), Typer::kNoFlags, graph()); |
| TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) { |
| TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) { |
| Node* lhs = Parameter(Type::UnsignedSmall(), 0); |
| Node* rhs = Parameter(Type::UnsignedSmall(), 1); |
| Node* length = Parameter(Type::Unsigned31(), 2); |
| Node* effect = graph()->start(); |
| Node* control = graph()->start(); |
| |
| Node* check1 = effect = graph()->NewNode( |
| simplified()->CheckBounds(feedback1), lhs, length, effect, control); |
| Reduction r1 = Reduce(check1); |
| ASSERT_TRUE(r1.Changed()); |
| EXPECT_EQ(r1.replacement(), check1); |
| |
| Node* check2 = effect = graph()->NewNode( |
| simplified()->CheckBounds(feedback2), rhs, length, effect, control); |
| Reduction r2 = Reduce(check2); |
| ASSERT_TRUE(r2.Changed()); |
| EXPECT_EQ(r2.replacement(), check2); |
| |
| Node* cmp3 = effect = |
| graph()->NewNode(simplified()->SpeculativeNumberEqual( |
| NumberOperationHint::kSignedSmall), |
| lhs, rhs, effect, control); |
| Reduction r3 = Reduce(cmp3); |
| ASSERT_TRUE(r3.Changed()); |
| EXPECT_THAT(r3.replacement(), |
| IsSpeculativeNumberEqual(NumberOperationHint::kSignedSmall, |
| lhs, rhs, _, _)); |
| } |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| // SpeculativeNumberLessThan |
| |
| TEST_F(RedundancyEliminationTest, |
| SpeculativeNumberLessThanWithCheckBoundsBetterType) { |
| Typer typer(broker(), Typer::kNoFlags, graph()); |
| TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) { |
| TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) { |
| Node* lhs = Parameter(Type::Any(), 0); |
| Node* rhs = Parameter(Type::Any(), 1); |
| Node* length = Parameter(Type::Unsigned31(), 2); |
| Node* effect = graph()->start(); |
| Node* control = graph()->start(); |
| |
| Node* check1 = effect = graph()->NewNode( |
| simplified()->CheckBounds(feedback1), lhs, length, effect, control); |
| Reduction r1 = Reduce(check1); |
| ASSERT_TRUE(r1.Changed()); |
| EXPECT_EQ(r1.replacement(), check1); |
| |
| Node* check2 = effect = graph()->NewNode( |
| simplified()->CheckBounds(feedback2), rhs, length, effect, control); |
| Reduction r2 = Reduce(check2); |
| ASSERT_TRUE(r2.Changed()); |
| EXPECT_EQ(r2.replacement(), check2); |
| |
| Node* cmp3 = effect = |
| graph()->NewNode(simplified()->SpeculativeNumberLessThan( |
| NumberOperationHint::kSignedSmall), |
| lhs, rhs, effect, control); |
| Reduction r3 = Reduce(cmp3); |
| ASSERT_TRUE(r3.Changed()); |
| EXPECT_THAT(r3.replacement(), |
| IsSpeculativeNumberLessThan(NumberOperationHint::kSignedSmall, |
| check1, check2, _, _)); |
| } |
| } |
| } |
| |
| TEST_F(RedundancyEliminationTest, |
| SpeculativeNumberLessThanWithCheckBoundsSameType) { |
| Typer typer(broker(), Typer::kNoFlags, graph()); |
| TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) { |
| TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) { |
| Node* lhs = Parameter(Type::UnsignedSmall(), 0); |
| Node* rhs = Parameter(Type::UnsignedSmall(), 1); |
| Node* length = Parameter(Type::Unsigned31(), 2); |
| Node* effect = graph()->start(); |
| Node* control = graph()->start(); |
| |
| Node* check1 = effect = graph()->NewNode( |
| simplified()->CheckBounds(feedback1), lhs, length, effect, control); |
| Reduction r1 = Reduce(check1); |
| ASSERT_TRUE(r1.Changed()); |
| EXPECT_EQ(r1.replacement(), check1); |
| |
| Node* check2 = effect = graph()->NewNode( |
| simplified()->CheckBounds(feedback2), rhs, length, effect, control); |
| Reduction r2 = Reduce(check2); |
| ASSERT_TRUE(r2.Changed()); |
| EXPECT_EQ(r2.replacement(), check2); |
| |
| Node* cmp3 = effect = |
| graph()->NewNode(simplified()->SpeculativeNumberLessThan( |
| NumberOperationHint::kSignedSmall), |
| lhs, rhs, effect, control); |
| Reduction r3 = Reduce(cmp3); |
| ASSERT_TRUE(r3.Changed()); |
| EXPECT_THAT(r3.replacement(), |
| IsSpeculativeNumberLessThan(NumberOperationHint::kSignedSmall, |
| lhs, rhs, _, _)); |
| } |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| // SpeculativeNumberLessThanOrEqual |
| |
| TEST_F(RedundancyEliminationTest, |
| SpeculativeNumberLessThanOrEqualWithCheckBoundsBetterType) { |
| Typer typer(broker(), Typer::kNoFlags, graph()); |
| TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) { |
| TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) { |
| Node* lhs = Parameter(Type::Any(), 0); |
| Node* rhs = Parameter(Type::Any(), 1); |
| Node* length = Parameter(Type::Unsigned31(), 2); |
| Node* effect = graph()->start(); |
| Node* control = graph()->start(); |
| |
| Node* check1 = effect = graph()->NewNode( |
| simplified()->CheckBounds(feedback1), lhs, length, effect, control); |
| Reduction r1 = Reduce(check1); |
| ASSERT_TRUE(r1.Changed()); |
| EXPECT_EQ(r1.replacement(), check1); |
| |
| Node* check2 = effect = graph()->NewNode( |
| simplified()->CheckBounds(feedback2), rhs, length, effect, control); |
| Reduction r2 = Reduce(check2); |
| ASSERT_TRUE(r2.Changed()); |
| EXPECT_EQ(r2.replacement(), check2); |
| |
| Node* cmp3 = effect = |
| graph()->NewNode(simplified()->SpeculativeNumberLessThanOrEqual( |
| NumberOperationHint::kSignedSmall), |
| lhs, rhs, effect, control); |
| Reduction r3 = Reduce(cmp3); |
| ASSERT_TRUE(r3.Changed()); |
| EXPECT_THAT(r3.replacement(), |
| IsSpeculativeNumberLessThanOrEqual( |
| NumberOperationHint::kSignedSmall, check1, check2, _, _)); |
| } |
| } |
| } |
| |
| TEST_F(RedundancyEliminationTest, |
| SpeculativeNumberLessThanOrEqualWithCheckBoundsSameType) { |
| Typer typer(broker(), Typer::kNoFlags, graph()); |
| TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) { |
| TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) { |
| Node* lhs = Parameter(Type::UnsignedSmall(), 0); |
| Node* rhs = Parameter(Type::UnsignedSmall(), 1); |
| Node* length = Parameter(Type::Unsigned31(), 2); |
| Node* effect = graph()->start(); |
| Node* control = graph()->start(); |
| |
| Node* check1 = effect = graph()->NewNode( |
| simplified()->CheckBounds(feedback1), lhs, length, effect, control); |
| Reduction r1 = Reduce(check1); |
| ASSERT_TRUE(r1.Changed()); |
| EXPECT_EQ(r1.replacement(), check1); |
| |
| Node* check2 = effect = graph()->NewNode( |
| simplified()->CheckBounds(feedback2), rhs, length, effect, control); |
| Reduction r2 = Reduce(check2); |
| ASSERT_TRUE(r2.Changed()); |
| EXPECT_EQ(r2.replacement(), check2); |
| |
| Node* cmp3 = effect = |
| graph()->NewNode(simplified()->SpeculativeNumberLessThanOrEqual( |
| NumberOperationHint::kSignedSmall), |
| lhs, rhs, effect, control); |
| Reduction r3 = Reduce(cmp3); |
| ASSERT_TRUE(r3.Changed()); |
| EXPECT_THAT(r3.replacement(), |
| IsSpeculativeNumberLessThanOrEqual( |
| NumberOperationHint::kSignedSmall, lhs, rhs, _, _)); |
| } |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| // SpeculativeNumberAdd |
| |
| TEST_F(RedundancyEliminationTest, |
| SpeculativeNumberAddWithCheckBoundsBetterType) { |
| Typer typer(broker(), Typer::kNoFlags, graph()); |
| TRACED_FOREACH(VectorSlotPair, feedback, vector_slot_pairs()) { |
| TRACED_FOREACH(NumberOperationHint, hint, kNumberOperationHints) { |
| Node* lhs = Parameter(Type::Any(), 0); |
| Node* rhs = Parameter(Type::Any(), 1); |
| Node* length = Parameter(Type::Unsigned31(), 2); |
| Node* effect = graph()->start(); |
| Node* control = graph()->start(); |
| |
| Node* check1 = effect = graph()->NewNode( |
| simplified()->CheckBounds(feedback), lhs, length, effect, control); |
| Reduction r1 = Reduce(check1); |
| ASSERT_TRUE(r1.Changed()); |
| EXPECT_EQ(r1.replacement(), check1); |
| |
| Node* add2 = effect = graph()->NewNode( |
| simplified()->SpeculativeNumberAdd(hint), lhs, rhs, effect, control); |
| Reduction r2 = Reduce(add2); |
| ASSERT_TRUE(r2.Changed()); |
| EXPECT_THAT(r2.replacement(), |
| IsSpeculativeNumberAdd(hint, check1, rhs, _, _)); |
| } |
| } |
| } |
| |
| TEST_F(RedundancyEliminationTest, SpeculativeNumberAddWithCheckBoundsSameType) { |
| Typer typer(broker(), Typer::kNoFlags, graph()); |
| TRACED_FOREACH(VectorSlotPair, feedback, vector_slot_pairs()) { |
| TRACED_FOREACH(NumberOperationHint, hint, kNumberOperationHints) { |
| Node* lhs = Parameter(Type::Range(42.0, 42.0, zone()), 0); |
| Node* rhs = Parameter(Type::Any(), 0); |
| Node* length = Parameter(Type::Unsigned31(), 1); |
| Node* effect = graph()->start(); |
| Node* control = graph()->start(); |
| |
| Node* check1 = effect = graph()->NewNode( |
| simplified()->CheckBounds(feedback), lhs, length, effect, control); |
| Reduction r1 = Reduce(check1); |
| ASSERT_TRUE(r1.Changed()); |
| EXPECT_EQ(r1.replacement(), check1); |
| |
| Node* add2 = effect = graph()->NewNode( |
| simplified()->SpeculativeNumberAdd(hint), lhs, rhs, effect, control); |
| Reduction r2 = Reduce(add2); |
| ASSERT_TRUE(r2.Changed()); |
| EXPECT_THAT(r2.replacement(), |
| IsSpeculativeNumberAdd(hint, lhs, rhs, _, _)); |
| } |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| // SpeculativeNumberSubtract |
| |
| TEST_F(RedundancyEliminationTest, |
| SpeculativeNumberSubtractWithCheckBoundsBetterType) { |
| Typer typer(broker(), Typer::kNoFlags, graph()); |
| TRACED_FOREACH(VectorSlotPair, feedback, vector_slot_pairs()) { |
| TRACED_FOREACH(NumberOperationHint, hint, kNumberOperationHints) { |
| Node* lhs = Parameter(Type::Any(), 0); |
| Node* rhs = Parameter(Type::Any(), 1); |
| Node* length = Parameter(Type::Unsigned31(), 2); |
| Node* effect = graph()->start(); |
| Node* control = graph()->start(); |
| |
| Node* check1 = effect = graph()->NewNode( |
| simplified()->CheckBounds(feedback), lhs, length, effect, control); |
| Reduction r1 = Reduce(check1); |
| ASSERT_TRUE(r1.Changed()); |
| EXPECT_EQ(r1.replacement(), check1); |
| |
| Node* subtract2 = effect = |
| graph()->NewNode(simplified()->SpeculativeNumberSubtract(hint), lhs, |
| rhs, effect, control); |
| Reduction r2 = Reduce(subtract2); |
| ASSERT_TRUE(r2.Changed()); |
| EXPECT_THAT(r2.replacement(), |
| IsSpeculativeNumberSubtract(hint, check1, rhs, _, _)); |
| } |
| } |
| } |
| |
| TEST_F(RedundancyEliminationTest, |
| SpeculativeNumberSubtractWithCheckBoundsSameType) { |
| Typer typer(broker(), Typer::kNoFlags, graph()); |
| TRACED_FOREACH(VectorSlotPair, feedback, vector_slot_pairs()) { |
| TRACED_FOREACH(NumberOperationHint, hint, kNumberOperationHints) { |
| Node* lhs = Parameter(Type::Range(42.0, 42.0, zone()), 0); |
| Node* rhs = Parameter(Type::Any(), 0); |
| Node* length = Parameter(Type::Unsigned31(), 1); |
| Node* effect = graph()->start(); |
| Node* control = graph()->start(); |
| |
| Node* check1 = effect = graph()->NewNode( |
| simplified()->CheckBounds(feedback), lhs, length, effect, control); |
| Reduction r1 = Reduce(check1); |
| ASSERT_TRUE(r1.Changed()); |
| EXPECT_EQ(r1.replacement(), check1); |
| |
| Node* subtract2 = effect = |
| graph()->NewNode(simplified()->SpeculativeNumberSubtract(hint), lhs, |
| rhs, effect, control); |
| Reduction r2 = Reduce(subtract2); |
| ASSERT_TRUE(r2.Changed()); |
| EXPECT_THAT(r2.replacement(), |
| IsSpeculativeNumberSubtract(hint, lhs, rhs, _, _)); |
| } |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| // SpeculativeSafeIntegerAdd |
| |
| TEST_F(RedundancyEliminationTest, |
| SpeculativeSafeIntegerAddWithCheckBoundsBetterType) { |
| Typer typer(broker(), Typer::kNoFlags, graph()); |
| TRACED_FOREACH(VectorSlotPair, feedback, vector_slot_pairs()) { |
| TRACED_FOREACH(NumberOperationHint, hint, kNumberOperationHints) { |
| Node* lhs = Parameter(Type::Any(), 0); |
| Node* rhs = Parameter(Type::Any(), 1); |
| Node* length = Parameter(Type::Unsigned31(), 2); |
| Node* effect = graph()->start(); |
| Node* control = graph()->start(); |
| |
| Node* check1 = effect = graph()->NewNode( |
| simplified()->CheckBounds(feedback), lhs, length, effect, control); |
| Reduction r1 = Reduce(check1); |
| ASSERT_TRUE(r1.Changed()); |
| EXPECT_EQ(r1.replacement(), check1); |
| |
| Node* add2 = effect = |
| graph()->NewNode(simplified()->SpeculativeSafeIntegerAdd(hint), lhs, |
| rhs, effect, control); |
| Reduction r2 = Reduce(add2); |
| ASSERT_TRUE(r2.Changed()); |
| EXPECT_THAT(r2.replacement(), |
| IsSpeculativeSafeIntegerAdd(hint, check1, rhs, _, _)); |
| } |
| } |
| } |
| |
| TEST_F(RedundancyEliminationTest, |
| SpeculativeSafeIntegerAddWithCheckBoundsSameType) { |
| Typer typer(broker(), Typer::kNoFlags, graph()); |
| TRACED_FOREACH(VectorSlotPair, feedback, vector_slot_pairs()) { |
| TRACED_FOREACH(NumberOperationHint, hint, kNumberOperationHints) { |
| Node* lhs = Parameter(Type::Range(42.0, 42.0, zone()), 0); |
| Node* rhs = Parameter(Type::Any(), 0); |
| Node* length = Parameter(Type::Unsigned31(), 1); |
| Node* effect = graph()->start(); |
| Node* control = graph()->start(); |
| |
| Node* check1 = effect = graph()->NewNode( |
| simplified()->CheckBounds(feedback), lhs, length, effect, control); |
| Reduction r1 = Reduce(check1); |
| ASSERT_TRUE(r1.Changed()); |
| EXPECT_EQ(r1.replacement(), check1); |
| |
| Node* add2 = effect = |
| graph()->NewNode(simplified()->SpeculativeSafeIntegerAdd(hint), lhs, |
| rhs, effect, control); |
| Reduction r2 = Reduce(add2); |
| ASSERT_TRUE(r2.Changed()); |
| EXPECT_THAT(r2.replacement(), |
| IsSpeculativeSafeIntegerAdd(hint, lhs, rhs, _, _)); |
| } |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| // SpeculativeSafeIntegerSubtract |
| |
| TEST_F(RedundancyEliminationTest, |
| SpeculativeSafeIntegerSubtractWithCheckBoundsBetterType) { |
| Typer typer(broker(), Typer::kNoFlags, graph()); |
| TRACED_FOREACH(VectorSlotPair, feedback, vector_slot_pairs()) { |
| TRACED_FOREACH(NumberOperationHint, hint, kNumberOperationHints) { |
| Node* lhs = Parameter(Type::Any(), 0); |
| Node* rhs = Parameter(Type::Any(), 1); |
| Node* length = Parameter(Type::Unsigned31(), 2); |
| Node* effect = graph()->start(); |
| Node* control = graph()->start(); |
| |
| Node* check1 = effect = graph()->NewNode( |
| simplified()->CheckBounds(feedback), lhs, length, effect, control); |
| Reduction r1 = Reduce(check1); |
| ASSERT_TRUE(r1.Changed()); |
| EXPECT_EQ(r1.replacement(), check1); |
| |
| Node* subtract2 = effect = |
| graph()->NewNode(simplified()->SpeculativeSafeIntegerSubtract(hint), |
| lhs, rhs, effect, control); |
| Reduction r2 = Reduce(subtract2); |
| ASSERT_TRUE(r2.Changed()); |
| EXPECT_THAT(r2.replacement(), |
| IsSpeculativeSafeIntegerSubtract(hint, check1, rhs, _, _)); |
| } |
| } |
| } |
| |
| TEST_F(RedundancyEliminationTest, |
| SpeculativeSafeIntegerSubtractWithCheckBoundsSameType) { |
| Typer typer(broker(), Typer::kNoFlags, graph()); |
| TRACED_FOREACH(VectorSlotPair, feedback, vector_slot_pairs()) { |
| TRACED_FOREACH(NumberOperationHint, hint, kNumberOperationHints) { |
| Node* lhs = Parameter(Type::Range(42.0, 42.0, zone()), 0); |
| Node* rhs = Parameter(Type::Any(), 0); |
| Node* length = Parameter(Type::Unsigned31(), 1); |
| Node* effect = graph()->start(); |
| Node* control = graph()->start(); |
| |
| Node* check1 = effect = graph()->NewNode( |
| simplified()->CheckBounds(feedback), lhs, length, effect, control); |
| Reduction r1 = Reduce(check1); |
| ASSERT_TRUE(r1.Changed()); |
| EXPECT_EQ(r1.replacement(), check1); |
| |
| Node* subtract2 = effect = |
| graph()->NewNode(simplified()->SpeculativeSafeIntegerSubtract(hint), |
| lhs, rhs, effect, control); |
| Reduction r2 = Reduce(subtract2); |
| ASSERT_TRUE(r2.Changed()); |
| EXPECT_THAT(r2.replacement(), |
| IsSpeculativeSafeIntegerSubtract(hint, lhs, rhs, _, _)); |
| } |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| // SpeculativeToNumber |
| |
| TEST_F(RedundancyEliminationTest, |
| SpeculativeToNumberWithCheckBoundsBetterType) { |
| Typer typer(broker(), Typer::kNoFlags, graph()); |
| TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) { |
| TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) { |
| TRACED_FOREACH(NumberOperationHint, hint, kNumberOperationHints) { |
| Node* index = Parameter(Type::Any(), 0); |
| Node* length = Parameter(Type::Unsigned31(), 1); |
| Node* effect = graph()->start(); |
| Node* control = graph()->start(); |
| |
| Node* check1 = effect = |
| graph()->NewNode(simplified()->CheckBounds(feedback1), index, |
| length, effect, control); |
| Reduction r1 = Reduce(check1); |
| ASSERT_TRUE(r1.Changed()); |
| EXPECT_EQ(r1.replacement(), check1); |
| |
| Node* to_number2 = effect = |
| graph()->NewNode(simplified()->SpeculativeToNumber(hint, feedback2), |
| index, effect, control); |
| Reduction r2 = Reduce(to_number2); |
| ASSERT_TRUE(r2.Changed()); |
| EXPECT_THAT(r2.replacement(), IsSpeculativeToNumber(check1)); |
| } |
| } |
| } |
| } |
| |
| TEST_F(RedundancyEliminationTest, SpeculativeToNumberWithCheckBoundsSameType) { |
| Typer typer(broker(), Typer::kNoFlags, graph()); |
| TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) { |
| TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) { |
| TRACED_FOREACH(NumberOperationHint, hint, kNumberOperationHints) { |
| Node* index = Parameter(Type::Range(42.0, 42.0, zone()), 0); |
| Node* length = Parameter(Type::Unsigned31(), 1); |
| Node* effect = graph()->start(); |
| Node* control = graph()->start(); |
| |
| Node* check1 = effect = |
| graph()->NewNode(simplified()->CheckBounds(feedback1), index, |
| length, effect, control); |
| Reduction r1 = Reduce(check1); |
| ASSERT_TRUE(r1.Changed()); |
| EXPECT_EQ(r1.replacement(), check1); |
| |
| Node* to_number2 = effect = |
| graph()->NewNode(simplified()->SpeculativeToNumber(hint, feedback2), |
| index, effect, control); |
| Reduction r2 = Reduce(to_number2); |
| ASSERT_TRUE(r2.Changed()); |
| EXPECT_THAT(r2.replacement(), IsSpeculativeToNumber(index)); |
| } |
| } |
| } |
| } |
| |
| } // namespace redundancy_elimination_unittest |
| } // namespace compiler |
| } // namespace internal |
| } // namespace v8 |
