| // Copyright 2019 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/decompression-elimination.h" |
| #include "src/compiler/simplified-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" |
| |
| using testing::StrictMock; |
| |
| namespace v8 { |
| namespace internal { |
| namespace compiler { |
| |
| class DecompressionEliminationTest : public GraphTest { |
| public: |
| DecompressionEliminationTest() |
| : GraphTest(), |
| machine_(zone(), MachineType::PointerRepresentation(), |
| MachineOperatorBuilder::kNoFlags), |
| simplified_(zone()) {} |
| ~DecompressionEliminationTest() override = default; |
| |
| protected: |
| Reduction Reduce(Node* node) { |
| StrictMock<MockAdvancedReducerEditor> editor; |
| DecompressionElimination decompression_elimination(&editor, graph(), |
| machine(), common()); |
| return decompression_elimination.Reduce(node); |
| } |
| MachineOperatorBuilder* machine() { return &machine_; } |
| SimplifiedOperatorBuilder* simplified() { return &simplified_; } |
| |
| private: |
| MachineOperatorBuilder machine_; |
| SimplifiedOperatorBuilder simplified_; |
| }; |
| |
| // ----------------------------------------------------------------------------- |
| // Direct Decompression & Compression |
| |
| TEST_F(DecompressionEliminationTest, BasicDecompressionCompression) { |
| // Skip test if pointer compression is not enabled |
| if (!COMPRESS_POINTERS_BOOL) { |
| return; |
| } |
| |
| // Define variables |
| Node* const control = graph()->start(); |
| Node* object = Parameter(Type::Any(), 0); |
| Node* effect = graph()->start(); |
| Node* index = Parameter(Type::UnsignedSmall(), 1); |
| ElementAccess const access = {kTaggedBase, kTaggedSize, Type::Any(), |
| MachineType::AnyTagged(), kNoWriteBarrier}; |
| |
| // Create the graph |
| Node* load = graph()->NewNode(simplified()->LoadElement(access), object, |
| index, effect, control); |
| Node* changeToTagged = |
| graph()->NewNode(machine()->ChangeCompressedToTagged(), load); |
| Node* changeToCompressed = |
| graph()->NewNode(machine()->ChangeTaggedToCompressed(), changeToTagged); |
| effect = graph()->NewNode(simplified()->StoreElement(access), object, index, |
| changeToCompressed, effect, control); |
| |
| // Reduce |
| Reduction r = Reduce(changeToCompressed); |
| ASSERT_TRUE(r.Changed()); |
| EXPECT_EQ(load, r.replacement()); |
| } |
| |
| TEST_F(DecompressionEliminationTest, BasicDecompressionCompressionSigned) { |
| // Skip test if pointer compression is not enabled |
| if (!COMPRESS_POINTERS_BOOL) { |
| return; |
| } |
| |
| // Define variables |
| Node* const control = graph()->start(); |
| Node* object = Parameter(Type::Any(), 0); |
| Node* effect = graph()->start(); |
| Node* index = Parameter(Type::UnsignedSmall(), 1); |
| ElementAccess const access = {kTaggedBase, kTaggedSize, Type::Any(), |
| MachineType::TaggedSigned(), kNoWriteBarrier}; |
| |
| // Create the graph |
| Node* load = graph()->NewNode(simplified()->LoadElement(access), object, |
| index, effect, control); |
| Node* changeToTagged = |
| graph()->NewNode(machine()->ChangeCompressedSignedToTaggedSigned(), load); |
| Node* changeToCompressed = graph()->NewNode( |
| machine()->ChangeTaggedSignedToCompressedSigned(), changeToTagged); |
| effect = graph()->NewNode(simplified()->StoreElement(access), object, index, |
| changeToCompressed, effect, control); |
| |
| // Reduce |
| Reduction r = Reduce(changeToCompressed); |
| ASSERT_TRUE(r.Changed()); |
| EXPECT_EQ(load, r.replacement()); |
| } |
| |
| TEST_F(DecompressionEliminationTest, BasicDecompressionCompressionPointer) { |
| // Skip test if pointer compression is not enabled |
| if (!COMPRESS_POINTERS_BOOL) { |
| return; |
| } |
| |
| // Define variables |
| Node* const control = graph()->start(); |
| Node* object = Parameter(Type::Any(), 0); |
| Node* effect = graph()->start(); |
| Node* index = Parameter(Type::UnsignedSmall(), 1); |
| ElementAccess const access = {kTaggedBase, kTaggedSize, Type::Any(), |
| MachineType::TaggedPointer(), kNoWriteBarrier}; |
| |
| // Create the graph |
| Node* load = graph()->NewNode(simplified()->LoadElement(access), object, |
| index, effect, control); |
| Node* changeToTagged = graph()->NewNode( |
| machine()->ChangeCompressedPointerToTaggedPointer(), load); |
| Node* changeToCompressed = graph()->NewNode( |
| machine()->ChangeTaggedPointerToCompressedPointer(), changeToTagged); |
| effect = graph()->NewNode(simplified()->StoreElement(access), object, index, |
| changeToCompressed, effect, control); |
| |
| // Reduce |
| Reduction r = Reduce(changeToCompressed); |
| ASSERT_TRUE(r.Changed()); |
| EXPECT_EQ(load, r.replacement()); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| // Direct Decompression & Compression - border cases |
| |
| // For example, if we are lowering a CheckedCompressedToTaggedPointer in the |
| // effect linearization phase we will change that to |
| // ChangeCompressedPointerToTaggedPointer. Then, we might end up with a chain of |
| // Parent <- ChangeCompressedPointerToTaggedPointer <- ChangeTaggedToCompressed |
| // <- Child. |
| // Similarly, we have cases with Signed instead of pointer. |
| // The following border case tests will test that the functionality is robust |
| // enough to handle that. |
| |
| TEST_F(DecompressionEliminationTest, |
| BasicDecompressionCompressionBorderCaseSigned) { |
| // Skip test if pointer compression is not enabled |
| if (!COMPRESS_POINTERS_BOOL) { |
| return; |
| } |
| |
| // Define variables |
| Node* const control = graph()->start(); |
| Node* object = Parameter(Type::Any(), 0); |
| Node* effect = graph()->start(); |
| Node* index = Parameter(Type::UnsignedSmall(), 1); |
| ElementAccess const loadAccess = {kTaggedBase, kTaggedSize, Type::Any(), |
| MachineType::AnyTagged(), kNoWriteBarrier}; |
| ElementAccess const storeAccess = {kTaggedBase, kTaggedSize, Type::Any(), |
| MachineType::TaggedSigned(), |
| kNoWriteBarrier}; |
| |
| // Create the graph |
| Node* load = graph()->NewNode(simplified()->LoadElement(loadAccess), object, |
| index, effect, control); |
| Node* changeToTagged = |
| graph()->NewNode(machine()->ChangeCompressedSignedToTaggedSigned(), load); |
| Node* changeToCompressed = |
| graph()->NewNode(machine()->ChangeTaggedToCompressed(), changeToTagged); |
| effect = graph()->NewNode(simplified()->StoreElement(storeAccess), object, |
| index, changeToCompressed, effect, control); |
| |
| // Reduce |
| Reduction r = Reduce(changeToCompressed); |
| ASSERT_TRUE(r.Changed()); |
| EXPECT_EQ(load, r.replacement()); |
| } |
| |
| TEST_F(DecompressionEliminationTest, |
| BasicDecompressionCompressionBorderCasePointer) { |
| // Skip test if pointer compression is not enabled |
| if (!COMPRESS_POINTERS_BOOL) { |
| return; |
| } |
| |
| // Define variables |
| Node* const control = graph()->start(); |
| Node* object = Parameter(Type::Any(), 0); |
| Node* effect = graph()->start(); |
| Node* index = Parameter(Type::UnsignedSmall(), 1); |
| ElementAccess const loadAccess = {kTaggedBase, kTaggedSize, Type::Any(), |
| MachineType::AnyTagged(), kNoWriteBarrier}; |
| ElementAccess const storeAccess = {kTaggedBase, kTaggedSize, Type::Any(), |
| MachineType::TaggedPointer(), |
| kNoWriteBarrier}; |
| |
| // Create the graph |
| Node* load = graph()->NewNode(simplified()->LoadElement(loadAccess), object, |
| index, effect, control); |
| Node* changeToTagged = graph()->NewNode( |
| machine()->ChangeCompressedPointerToTaggedPointer(), load); |
| Node* changeToCompressed = |
| graph()->NewNode(machine()->ChangeTaggedToCompressed(), changeToTagged); |
| effect = graph()->NewNode(simplified()->StoreElement(storeAccess), object, |
| index, changeToCompressed, effect, control); |
| |
| // Reduce |
| Reduction r = Reduce(changeToCompressed); |
| ASSERT_TRUE(r.Changed()); |
| EXPECT_EQ(load, r.replacement()); |
| } |
| |
| // We also have cases of ChangeCompressedToTagged <- |
| // ChangeTaggedPointerToCompressedPointer, where the |
| // ChangeTaggedPointerToCompressedPointer was introduced while lowering a |
| // NewConsString on effect control linearizer |
| |
| TEST_F(DecompressionEliminationTest, |
| BasicDecompressionCompressionBorderCasePointerDecompression) { |
| // Skip test if pointer compression is not enabled |
| if (!COMPRESS_POINTERS_BOOL) { |
| return; |
| } |
| |
| // Define variables |
| Node* const control = graph()->start(); |
| Node* object = Parameter(Type::Any(), 0); |
| Node* effect = graph()->start(); |
| Node* index = Parameter(Type::UnsignedSmall(), 1); |
| ElementAccess const loadAccess = {kTaggedBase, kTaggedSize, Type::Any(), |
| MachineType::TaggedPointer(), |
| kNoWriteBarrier}; |
| ElementAccess const storeAccess = {kTaggedBase, kTaggedSize, Type::Any(), |
| MachineType::AnyTagged(), kNoWriteBarrier}; |
| |
| // Create the graph |
| Node* load = graph()->NewNode(simplified()->LoadElement(loadAccess), object, |
| index, effect, control); |
| Node* changeToTagged = graph()->NewNode( |
| machine()->ChangeCompressedPointerToTaggedPointer(), load); |
| Node* changeToCompressed = |
| graph()->NewNode(machine()->ChangeTaggedToCompressed(), changeToTagged); |
| effect = graph()->NewNode(simplified()->StoreElement(storeAccess), object, |
| index, changeToCompressed, effect, control); |
| |
| // Reduce |
| Reduction r = Reduce(changeToCompressed); |
| ASSERT_TRUE(r.Changed()); |
| EXPECT_EQ(load, r.replacement()); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| // Phi |
| |
| TEST_F(DecompressionEliminationTest, PhiOneDecompress) { |
| // Skip test if pointer compression is not enabled |
| if (!COMPRESS_POINTERS_BOOL) { |
| return; |
| } |
| |
| // Define variables |
| Node* const control = graph()->start(); |
| Node* object = Parameter(Type::Any(), 0); |
| Node* effect = graph()->start(); |
| Node* index = Parameter(Type::UnsignedSmall(), 1); |
| const int number_of_inputs = 1; |
| |
| const Operator* decompression_ops[] = { |
| machine()->ChangeCompressedToTagged(), |
| machine()->ChangeCompressedSignedToTaggedSigned(), |
| machine()->ChangeCompressedPointerToTaggedPointer()}; |
| |
| const ElementAccess element_accesses[] = { |
| {kTaggedBase, kTaggedSize, Type::Any(), MachineType::AnyCompressed(), |
| kNoWriteBarrier}, |
| {kTaggedBase, kTaggedSize, Type::Any(), MachineType::TaggedSigned(), |
| kNoWriteBarrier}, |
| {kTaggedBase, kTaggedSize, Type::Any(), MachineType::TaggedPointer(), |
| kNoWriteBarrier}}; |
| |
| const IrOpcode::Value opcodes[] = { |
| IrOpcode::kChangeCompressedToTagged, |
| IrOpcode::kChangeCompressedSignedToTaggedSigned, |
| IrOpcode::kChangeCompressedPointerToTaggedPointer}; |
| |
| ASSERT_EQ(arraysize(decompression_ops), arraysize(element_accesses)); |
| ASSERT_EQ(arraysize(opcodes), arraysize(element_accesses)); |
| |
| // For every access |
| for (size_t i = 0; i < arraysize(element_accesses); ++i) { |
| // Create the graph |
| Node* load = |
| graph()->NewNode(simplified()->LoadElement(element_accesses[i]), object, |
| index, effect, control); |
| Node* change_to_tagged = graph()->NewNode(decompression_ops[i], load); |
| Node* phi = graph()->NewNode( |
| common()->Phi(MachineRepresentation::kTagged, number_of_inputs), |
| change_to_tagged, control); |
| |
| // Reduce |
| Reduction r = Reduce(phi); |
| ASSERT_TRUE(r.Changed()); |
| EXPECT_EQ(opcodes[i], r.replacement()->opcode()); |
| } |
| } |
| |
| TEST_F(DecompressionEliminationTest, PhiThreeDecompressSameRepresentation) { |
| // Skip test if pointer compression is not enabled |
| if (!COMPRESS_POINTERS_BOOL) { |
| return; |
| } |
| |
| // Define variables |
| Node* const control = graph()->start(); |
| Node* object = Parameter(Type::Any(), 0); |
| Node* effect = graph()->start(); |
| Node* index = Parameter(Type::UnsignedSmall(), 1); |
| const int number_of_inputs = 3; |
| |
| const Operator* decompression_ops[] = { |
| machine()->ChangeCompressedToTagged(), |
| machine()->ChangeCompressedSignedToTaggedSigned(), |
| machine()->ChangeCompressedPointerToTaggedPointer()}; |
| |
| const ElementAccess element_accesses[] = { |
| {kTaggedBase, kTaggedSize, Type::Any(), MachineType::AnyCompressed(), |
| kNoWriteBarrier}, |
| {kTaggedBase, kTaggedSize, Type::Any(), MachineType::CompressedSigned(), |
| kNoWriteBarrier}, |
| {kTaggedBase, kTaggedSize, Type::Any(), MachineType::CompressedPointer(), |
| kNoWriteBarrier}}; |
| |
| const IrOpcode::Value opcodes[] = { |
| IrOpcode::kChangeCompressedToTagged, |
| IrOpcode::kChangeCompressedSignedToTaggedSigned, |
| IrOpcode::kChangeCompressedPointerToTaggedPointer}; |
| |
| ASSERT_EQ(arraysize(decompression_ops), arraysize(element_accesses)); |
| ASSERT_EQ(arraysize(opcodes), arraysize(element_accesses)); |
| |
| // For every access |
| for (size_t i = 0; i < arraysize(element_accesses); ++i) { |
| // Create the graph |
| Node* load1 = |
| graph()->NewNode(simplified()->LoadElement(element_accesses[i]), object, |
| index, effect, control); |
| Node* load2 = |
| graph()->NewNode(simplified()->LoadElement(element_accesses[i]), object, |
| index, effect, control); |
| Node* load3 = |
| graph()->NewNode(simplified()->LoadElement(element_accesses[i]), object, |
| index, effect, control); |
| Node* change_to_tagged1 = graph()->NewNode(decompression_ops[i], load1); |
| Node* change_to_tagged2 = graph()->NewNode(decompression_ops[i], load2); |
| Node* change_to_tagged3 = graph()->NewNode(decompression_ops[i], load3); |
| |
| Node* phi = graph()->NewNode( |
| common()->Phi(MachineRepresentation::kTagged, number_of_inputs), |
| change_to_tagged1, change_to_tagged2, change_to_tagged3, control); |
| |
| // Reduce |
| Reduction r = Reduce(phi); |
| ASSERT_TRUE(r.Changed()); |
| EXPECT_EQ(opcodes[i], r.replacement()->opcode()); |
| } |
| } |
| |
| TEST_F(DecompressionEliminationTest, PhiThreeDecompressOneAnyRepresentation) { |
| // Skip test if pointer compression is not enabled |
| if (!COMPRESS_POINTERS_BOOL) { |
| return; |
| } |
| |
| // Define variables |
| Node* const control = graph()->start(); |
| Node* object = Parameter(Type::Any(), 0); |
| Node* effect = graph()->start(); |
| Node* index = Parameter(Type::UnsignedSmall(), 1); |
| const int number_of_inputs = 3; |
| |
| const Operator* decompression_ops[] = { |
| machine()->ChangeCompressedSignedToTaggedSigned(), |
| machine()->ChangeCompressedPointerToTaggedPointer()}; |
| |
| const ElementAccess element_accesses[] = { |
| {kTaggedBase, kTaggedSize, Type::Any(), MachineType::CompressedSigned(), |
| kNoWriteBarrier}, |
| {kTaggedBase, kTaggedSize, Type::Any(), MachineType::CompressedPointer(), |
| kNoWriteBarrier}}; |
| |
| const ElementAccess any_access = {kTaggedBase, kTaggedSize, Type::Any(), |
| MachineType::AnyCompressed(), |
| kNoWriteBarrier}; |
| |
| ASSERT_EQ(arraysize(decompression_ops), arraysize(element_accesses)); |
| |
| // For every access |
| for (size_t i = 0; i < arraysize(element_accesses); ++i) { |
| // Create the graph |
| Node* load1 = |
| graph()->NewNode(simplified()->LoadElement(element_accesses[i]), object, |
| index, effect, control); |
| Node* load2 = |
| graph()->NewNode(simplified()->LoadElement(element_accesses[i]), object, |
| index, effect, control); |
| // Note that load3 loads a CompressedAny instead of element_accesses[i] |
| Node* load3 = graph()->NewNode(simplified()->LoadElement(any_access), |
| object, index, effect, control); |
| Node* change_to_tagged1 = graph()->NewNode(decompression_ops[i], load1); |
| Node* change_to_tagged2 = graph()->NewNode(decompression_ops[i], load2); |
| Node* change_to_tagged3 = |
| graph()->NewNode(machine()->ChangeCompressedToTagged(), load3); |
| |
| Node* phi = graph()->NewNode( |
| common()->Phi(MachineRepresentation::kTagged, number_of_inputs), |
| change_to_tagged1, change_to_tagged2, change_to_tagged3, control); |
| |
| // Reduce |
| Reduction r = Reduce(phi); |
| ASSERT_TRUE(r.Changed()); |
| EXPECT_EQ(IrOpcode::kChangeCompressedToTagged, r.replacement()->opcode()); |
| } |
| } |
| |
| TEST_F(DecompressionEliminationTest, PhiThreeInputsOneNotDecompressed) { |
| // Skip test if pointer compression is not enabled |
| if (!COMPRESS_POINTERS_BOOL) { |
| return; |
| } |
| |
| // Define variables |
| Node* const control = graph()->start(); |
| Node* object = Parameter(Type::Any(), 0); |
| Node* effect = graph()->start(); |
| Node* index = Parameter(Type::UnsignedSmall(), 1); |
| const int number_of_inputs = 3; |
| |
| const Operator* decompression_ops[] = { |
| machine()->ChangeCompressedToTagged(), |
| machine()->ChangeCompressedSignedToTaggedSigned(), |
| machine()->ChangeCompressedPointerToTaggedPointer()}; |
| |
| const ElementAccess element_accesses[] = { |
| {kTaggedBase, kTaggedSize, Type::Any(), MachineType::AnyCompressed(), |
| kNoWriteBarrier}, |
| {kTaggedBase, kTaggedSize, Type::Any(), MachineType::CompressedSigned(), |
| kNoWriteBarrier}, |
| {kTaggedBase, kTaggedSize, Type::Any(), MachineType::CompressedPointer(), |
| kNoWriteBarrier}}; |
| |
| const IrOpcode::Value opcodes[] = { |
| IrOpcode::kChangeCompressedToTagged, |
| IrOpcode::kChangeCompressedSignedToTaggedSigned, |
| IrOpcode::kChangeCompressedPointerToTaggedPointer}; |
| |
| ASSERT_EQ(arraysize(decompression_ops), arraysize(element_accesses)); |
| ASSERT_EQ(arraysize(opcodes), arraysize(element_accesses)); |
| |
| // For every access |
| for (size_t i = 0; i < arraysize(element_accesses); ++i) { |
| // Create the graph |
| Node* load1 = |
| graph()->NewNode(simplified()->LoadElement(element_accesses[i]), object, |
| index, effect, control); |
| Node* load2 = |
| graph()->NewNode(simplified()->LoadElement(element_accesses[i]), object, |
| index, effect, control); |
| Node* load3 = |
| graph()->NewNode(simplified()->LoadElement(element_accesses[i]), object, |
| index, effect, control); |
| Node* change_to_tagged1 = graph()->NewNode(decompression_ops[i], load1); |
| Node* change_to_tagged2 = graph()->NewNode(decompression_ops[i], load2); |
| |
| Node* phi = graph()->NewNode( |
| common()->Phi(MachineRepresentation::kTagged, number_of_inputs), |
| change_to_tagged1, change_to_tagged2, load3, control); |
| |
| // Reduce |
| Reduction r = Reduce(phi); |
| ASSERT_FALSE(r.Changed()); |
| } |
| } |
| |
| // In the case of having one decompress Signed and one Pointer, we have to |
| // generate the conservative decompress any after the Phi. |
| TEST_F(DecompressionEliminationTest, PhiTwoDecompressesOneSignedOnePointer) { |
| // Skip test if pointer compression is not enabled |
| if (!COMPRESS_POINTERS_BOOL) { |
| return; |
| } |
| |
| // Define variables |
| Node* const control = graph()->start(); |
| Node* object = Parameter(Type::Any(), 0); |
| Node* effect = graph()->start(); |
| Node* index = Parameter(Type::UnsignedSmall(), 1); |
| const int number_of_inputs = 2; |
| const ElementAccess signed_access = {kTaggedBase, kTaggedSize, Type::Any(), |
| MachineType::CompressedSigned(), |
| kNoWriteBarrier}; |
| const ElementAccess pointer_access = {kTaggedBase, kTaggedSize, Type::Any(), |
| MachineType::CompressedPointer(), |
| kNoWriteBarrier}; |
| |
| // Create the graph |
| Node* load1 = graph()->NewNode(simplified()->LoadElement(signed_access), |
| object, index, effect, control); |
| Node* load2 = graph()->NewNode(simplified()->LoadElement(pointer_access), |
| object, index, effect, control); |
| Node* change_to_tagged1 = graph()->NewNode( |
| machine()->ChangeCompressedSignedToTaggedSigned(), load1); |
| Node* change_to_tagged2 = graph()->NewNode( |
| machine()->ChangeCompressedPointerToTaggedPointer(), load2); |
| |
| Node* phi = graph()->NewNode( |
| common()->Phi(MachineRepresentation::kTagged, number_of_inputs), |
| change_to_tagged1, change_to_tagged2, control); |
| |
| // Reduce |
| Reduction r = Reduce(phi); |
| ASSERT_TRUE(r.Changed()); |
| EXPECT_EQ(IrOpcode::kChangeCompressedToTagged, r.replacement()->opcode()); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| // TypedStateValues |
| |
| TEST_F(DecompressionEliminationTest, TypedStateValuesOneDecompress) { |
| // Skip test if pointer compression is not enabled |
| if (!COMPRESS_POINTERS_BOOL) { |
| return; |
| } |
| |
| // Define variables |
| Node* const control = graph()->start(); |
| Node* object = Parameter(Type::Any(), 0); |
| Node* effect = graph()->start(); |
| Node* index = Parameter(Type::UnsignedSmall(), 1); |
| const int numberOfInputs = 1; |
| const ZoneVector<MachineType>* types = |
| new (graph()->zone()->New(sizeof(ZoneVector<MachineType>))) |
| ZoneVector<MachineType>(numberOfInputs, graph()->zone()); |
| SparseInputMask dense = SparseInputMask::Dense(); |
| |
| const ElementAccess ElementAccesses[] = { |
| {kTaggedBase, kTaggedSize, Type::Any(), MachineType::AnyTagged(), |
| kNoWriteBarrier}, |
| {kTaggedBase, kTaggedSize, Type::Any(), MachineType::TaggedSigned(), |
| kNoWriteBarrier}, |
| {kTaggedBase, kTaggedSize, Type::Any(), MachineType::TaggedPointer(), |
| kNoWriteBarrier}}; |
| |
| // For every access |
| for (size_t i = 0; i < arraysize(ElementAccesses); ++i) { |
| // Create the graph |
| Node* load = graph()->NewNode(simplified()->LoadElement(ElementAccesses[i]), |
| object, index, effect, control); |
| Node* changeToTagged = graph()->NewNode( |
| machine()->ChangeCompressedPointerToTaggedPointer(), load); |
| Node* typedStateValuesOneDecompress = graph()->NewNode( |
| common()->TypedStateValues(types, dense), changeToTagged); |
| |
| // Reduce |
| StrictMock<MockAdvancedReducerEditor> editor; |
| DecompressionElimination decompression_elimination(&editor, graph(), |
| machine(), common()); |
| Reduction r = |
| decompression_elimination.Reduce(typedStateValuesOneDecompress); |
| ASSERT_TRUE(r.Changed()); |
| } |
| } |
| |
| TEST_F(DecompressionEliminationTest, TypedStateValuesTwoDecompresses) { |
| // Skip test if pointer compression is not enabled |
| if (!COMPRESS_POINTERS_BOOL) { |
| return; |
| } |
| |
| // Define variables |
| Node* const control = graph()->start(); |
| Node* object = Parameter(Type::Any(), 0); |
| Node* effect = graph()->start(); |
| Node* index = Parameter(Type::UnsignedSmall(), 1); |
| const int numberOfInputs = 3; |
| const ZoneVector<MachineType>* types = |
| new (graph()->zone()->New(sizeof(ZoneVector<MachineType>))) |
| ZoneVector<MachineType>(numberOfInputs, graph()->zone()); |
| SparseInputMask dense = SparseInputMask::Dense(); |
| const ElementAccess ElementAccesses[] = { |
| {kTaggedBase, kTaggedSize, Type::Any(), MachineType::AnyTagged(), |
| kNoWriteBarrier}, |
| {kTaggedBase, kTaggedSize, Type::Any(), MachineType::TaggedSigned(), |
| kNoWriteBarrier}, |
| {kTaggedBase, kTaggedSize, Type::Any(), MachineType::TaggedPointer(), |
| kNoWriteBarrier}}; |
| |
| // For every access |
| for (size_t i = 0; i < arraysize(ElementAccesses); ++i) { |
| // Create the graph |
| Node* load1 = |
| graph()->NewNode(simplified()->LoadElement(ElementAccesses[i]), object, |
| index, effect, control); |
| Node* changeToTagged1 = graph()->NewNode( |
| machine()->ChangeCompressedPointerToTaggedPointer(), load1); |
| Node* load2 = |
| graph()->NewNode(simplified()->LoadElement(ElementAccesses[i]), object, |
| index, effect, control); |
| Node* changeToTagged2 = graph()->NewNode( |
| machine()->ChangeCompressedPointerToTaggedPointer(), load2); |
| Node* typedStateValuesOneDecompress = |
| graph()->NewNode(common()->TypedStateValues(types, dense), |
| changeToTagged1, load1, changeToTagged2); |
| |
| // Reduce |
| StrictMock<MockAdvancedReducerEditor> editor; |
| DecompressionElimination decompression_elimination(&editor, graph(), |
| machine(), common()); |
| Reduction r = |
| decompression_elimination.Reduce(typedStateValuesOneDecompress); |
| ASSERT_TRUE(r.Changed()); |
| } |
| } |
| |
| TEST_F(DecompressionEliminationTest, TypedStateValuesAllDecompresses) { |
| // Skip test if pointer compression is not enabled |
| if (!COMPRESS_POINTERS_BOOL) { |
| return; |
| } |
| |
| // Define variables |
| Node* const control = graph()->start(); |
| Node* object = Parameter(Type::Any(), 0); |
| Node* effect = graph()->start(); |
| Node* index = Parameter(Type::UnsignedSmall(), 1); |
| const int numberOfInputs = 3; |
| const ZoneVector<MachineType>* types = |
| new (graph()->zone()->New(sizeof(ZoneVector<MachineType>))) |
| ZoneVector<MachineType>(numberOfInputs, graph()->zone()); |
| SparseInputMask dense = SparseInputMask::Dense(); |
| const ElementAccess ElementAccesses[] = { |
| {kTaggedBase, kTaggedSize, Type::Any(), MachineType::AnyTagged(), |
| kNoWriteBarrier}, |
| {kTaggedBase, kTaggedSize, Type::Any(), MachineType::TaggedSigned(), |
| kNoWriteBarrier}, |
| {kTaggedBase, kTaggedSize, Type::Any(), MachineType::TaggedPointer(), |
| kNoWriteBarrier}}; |
| |
| // For every access |
| for (size_t i = 0; i < arraysize(ElementAccesses); ++i) { |
| // Create the graph |
| Node* load1 = |
| graph()->NewNode(simplified()->LoadElement(ElementAccesses[i]), object, |
| index, effect, control); |
| Node* changeToTagged1 = graph()->NewNode( |
| machine()->ChangeCompressedPointerToTaggedPointer(), load1); |
| Node* load2 = |
| graph()->NewNode(simplified()->LoadElement(ElementAccesses[i]), object, |
| index, effect, control); |
| Node* changeToTagged2 = graph()->NewNode( |
| machine()->ChangeCompressedPointerToTaggedPointer(), load2); |
| Node* load3 = |
| graph()->NewNode(simplified()->LoadElement(ElementAccesses[i]), object, |
| index, effect, control); |
| Node* changeToTagged3 = graph()->NewNode( |
| machine()->ChangeCompressedPointerToTaggedPointer(), load3); |
| Node* typedStateValuesOneDecompress = |
| graph()->NewNode(common()->TypedStateValues(types, dense), |
| changeToTagged1, changeToTagged2, changeToTagged3); |
| |
| // Reduce |
| StrictMock<MockAdvancedReducerEditor> editor; |
| DecompressionElimination decompression_elimination(&editor, graph(), |
| machine(), common()); |
| Reduction r = |
| decompression_elimination.Reduce(typedStateValuesOneDecompress); |
| ASSERT_TRUE(r.Changed()); |
| } |
| } |
| |
| TEST_F(DecompressionEliminationTest, TypedStateValuesNoDecompresses) { |
| // Skip test if pointer compression is not enabled |
| if (!COMPRESS_POINTERS_BOOL) { |
| return; |
| } |
| |
| // Define variables |
| Node* const control = graph()->start(); |
| Node* object = Parameter(Type::Any(), 0); |
| Node* effect = graph()->start(); |
| Node* index = Parameter(Type::UnsignedSmall(), 1); |
| const int numberOfInputs = 3; |
| const ZoneVector<MachineType>* types = |
| new (graph()->zone()->New(sizeof(ZoneVector<MachineType>))) |
| ZoneVector<MachineType>(numberOfInputs, graph()->zone()); |
| SparseInputMask dense = SparseInputMask::Dense(); |
| const ElementAccess ElementAccesses[] = { |
| {kTaggedBase, kTaggedSize, Type::Any(), MachineType::AnyTagged(), |
| kNoWriteBarrier}, |
| {kTaggedBase, kTaggedSize, Type::Any(), MachineType::TaggedSigned(), |
| kNoWriteBarrier}, |
| {kTaggedBase, kTaggedSize, Type::Any(), MachineType::TaggedPointer(), |
| kNoWriteBarrier}}; |
| |
| // For every access |
| for (size_t i = 0; i < arraysize(ElementAccesses); ++i) { |
| // Create the graph |
| Node* load = graph()->NewNode(simplified()->LoadElement(ElementAccesses[i]), |
| object, index, effect, control); |
| Node* typedStateValuesOneDecompress = graph()->NewNode( |
| common()->TypedStateValues(types, dense), load, load, load); |
| |
| // Reduce |
| StrictMock<MockAdvancedReducerEditor> editor; |
| DecompressionElimination decompression_elimination(&editor, graph(), |
| machine(), common()); |
| Reduction r = |
| decompression_elimination.Reduce(typedStateValuesOneDecompress); |
| ASSERT_FALSE(r.Changed()); |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| // Word64Equal comparison of two decompressions |
| |
| TEST_F(DecompressionEliminationTest, TwoDecompressionWord64Equal) { |
| // Skip test if pointer compression is not enabled |
| if (!COMPRESS_POINTERS_BOOL) { |
| return; |
| } |
| |
| // Define variables |
| Node* const control = graph()->start(); |
| Node* object = Parameter(Type::Any(), 0); |
| Node* effect = graph()->start(); |
| Node* index = Parameter(Type::UnsignedSmall(), 1); |
| |
| const Operator* DecompressionOps[] = { |
| machine()->ChangeCompressedToTagged(), |
| machine()->ChangeCompressedSignedToTaggedSigned(), |
| machine()->ChangeCompressedPointerToTaggedPointer()}; |
| |
| const ElementAccess ElementAccesses[] = { |
| {kTaggedBase, kTaggedSize, Type::Any(), MachineType::AnyTagged(), |
| kNoWriteBarrier}, |
| {kTaggedBase, kTaggedSize, Type::Any(), MachineType::TaggedSigned(), |
| kNoWriteBarrier}, |
| {kTaggedBase, kTaggedSize, Type::Any(), MachineType::TaggedPointer(), |
| kNoWriteBarrier}}; |
| |
| ASSERT_EQ(arraysize(DecompressionOps), arraysize(ElementAccesses)); |
| |
| // For every decompression (lhs) |
| for (size_t j = 0; j < arraysize(DecompressionOps); ++j) { |
| // For every decompression (rhs) |
| for (size_t k = 0; k < arraysize(DecompressionOps); ++k) { |
| // Create the graph |
| Node* load1 = |
| graph()->NewNode(simplified()->LoadElement(ElementAccesses[j]), |
| object, index, effect, control); |
| Node* changeToTagged1 = graph()->NewNode(DecompressionOps[j], load1); |
| Node* load2 = |
| graph()->NewNode(simplified()->LoadElement(ElementAccesses[k]), |
| object, index, effect, control); |
| Node* changeToTagged2 = graph()->NewNode(DecompressionOps[j], load2); |
| Node* comparison = graph()->NewNode(machine()->Word64Equal(), |
| changeToTagged1, changeToTagged2); |
| // Reduce |
| Reduction r = Reduce(comparison); |
| ASSERT_TRUE(r.Changed()); |
| EXPECT_EQ(r.replacement()->opcode(), IrOpcode::kWord32Equal); |
| } |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| // Word64Equal comparison of two decompressions, where lhs == rhs |
| |
| TEST_F(DecompressionEliminationTest, TwoDecompressionWord64EqualSameInput) { |
| // Skip test if pointer compression is not enabled |
| if (!COMPRESS_POINTERS_BOOL) { |
| return; |
| } |
| |
| // Define variables |
| Node* const control = graph()->start(); |
| Node* object = Parameter(Type::Any(), 0); |
| Node* effect = graph()->start(); |
| Node* index = Parameter(Type::UnsignedSmall(), 1); |
| |
| const Operator* DecompressionOps[] = { |
| machine()->ChangeCompressedToTagged(), |
| machine()->ChangeCompressedSignedToTaggedSigned(), |
| machine()->ChangeCompressedPointerToTaggedPointer()}; |
| |
| const ElementAccess ElementAccesses[] = { |
| {kTaggedBase, kTaggedSize, Type::Any(), MachineType::AnyTagged(), |
| kNoWriteBarrier}, |
| {kTaggedBase, kTaggedSize, Type::Any(), MachineType::TaggedSigned(), |
| kNoWriteBarrier}, |
| {kTaggedBase, kTaggedSize, Type::Any(), MachineType::TaggedPointer(), |
| kNoWriteBarrier}}; |
| |
| ASSERT_EQ(arraysize(DecompressionOps), arraysize(ElementAccesses)); |
| |
| // For every decompression (same for lhs and rhs) |
| for (size_t j = 0; j < arraysize(DecompressionOps); ++j) { |
| // Create the graph |
| Node* load = graph()->NewNode(simplified()->LoadElement(ElementAccesses[j]), |
| object, index, effect, control); |
| Node* changeToTagged = graph()->NewNode(DecompressionOps[j], load); |
| Node* comparison = graph()->NewNode(machine()->Word64Equal(), |
| changeToTagged, changeToTagged); |
| // Reduce |
| Reduction r = Reduce(comparison); |
| ASSERT_TRUE(r.Changed()); |
| EXPECT_EQ(r.replacement()->opcode(), IrOpcode::kWord32Equal); |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| // Word64Equal comparison of decompress and a constant |
| |
| TEST_F(DecompressionEliminationTest, DecompressionConstantWord64Equal) { |
| // Skip test if pointer compression is not enabled |
| if (!COMPRESS_POINTERS_BOOL) { |
| return; |
| } |
| |
| // Define variables |
| Node* const control = graph()->start(); |
| Node* object = Parameter(Type::Any(), 0); |
| Node* effect = graph()->start(); |
| Node* index = Parameter(Type::UnsignedSmall(), 1); |
| |
| const Operator* DecompressionOps[] = { |
| machine()->ChangeCompressedToTagged(), |
| machine()->ChangeCompressedSignedToTaggedSigned(), |
| machine()->ChangeCompressedPointerToTaggedPointer()}; |
| |
| const ElementAccess ElementAccesses[] = { |
| {kTaggedBase, kTaggedSize, Type::Any(), MachineType::AnyTagged(), |
| kNoWriteBarrier}, |
| {kTaggedBase, kTaggedSize, Type::Any(), MachineType::TaggedSigned(), |
| kNoWriteBarrier}, |
| {kTaggedBase, kTaggedSize, Type::Any(), MachineType::TaggedPointer(), |
| kNoWriteBarrier}}; |
| |
| ASSERT_EQ(arraysize(DecompressionOps), arraysize(ElementAccesses)); |
| |
| const int64_t constants[] = {static_cast<int64_t>(0x0000000000000000), |
| static_cast<int64_t>(0x0000000000000001), |
| static_cast<int64_t>(0x0000FFFFFFFF0000), |
| static_cast<int64_t>(0x7FFFFFFFFFFFFFFF), |
| static_cast<int64_t>(0x8000000000000000), |
| static_cast<int64_t>(0x8000000000000001), |
| static_cast<int64_t>(0x8000FFFFFFFF0000), |
| static_cast<int64_t>(0x8FFFFFFFFFFFFFFF), |
| static_cast<int64_t>(0xFFFFFFFFFFFFFFFF)}; |
| |
| // For every decompression (lhs) |
| for (size_t j = 0; j < arraysize(DecompressionOps); ++j) { |
| // For every constant (rhs) |
| for (size_t k = 0; k < arraysize(constants); ++k) { |
| // Test with both (lhs, rhs) combinations |
| for (bool lhsIsDecompression : {false, true}) { |
| // Create the graph |
| Node* load = |
| graph()->NewNode(simplified()->LoadElement(ElementAccesses[j]), |
| object, index, effect, control); |
| Node* changeToTagged = graph()->NewNode(DecompressionOps[j], load); |
| Node* constant = |
| graph()->NewNode(common()->Int64Constant(constants[k])); |
| |
| Node* lhs = lhsIsDecompression ? changeToTagged : constant; |
| Node* rhs = lhsIsDecompression ? constant : changeToTagged; |
| Node* comparison = graph()->NewNode(machine()->Word64Equal(), lhs, rhs); |
| // Reduce |
| Reduction r = Reduce(comparison); |
| ASSERT_TRUE(r.Changed()); |
| EXPECT_EQ(r.replacement()->opcode(), IrOpcode::kWord32Equal); |
| } |
| } |
| } |
| } |
| |
| TEST_F(DecompressionEliminationTest, DecompressionHeapConstantWord64Equal) { |
| // Skip test if pointer compression is not enabled |
| if (!COMPRESS_POINTERS_BOOL) { |
| return; |
| } |
| |
| // Define variables |
| Node* const control = graph()->start(); |
| Node* object = Parameter(Type::Any(), 0); |
| Node* effect = graph()->start(); |
| Node* index = Parameter(Type::UnsignedSmall(), 1); |
| |
| const Operator* DecompressionOps[] = { |
| machine()->ChangeCompressedToTagged(), |
| machine()->ChangeCompressedSignedToTaggedSigned(), |
| machine()->ChangeCompressedPointerToTaggedPointer()}; |
| |
| const ElementAccess ElementAccesses[] = { |
| {kTaggedBase, kTaggedSize, Type::Any(), MachineType::AnyTagged(), |
| kNoWriteBarrier}, |
| {kTaggedBase, kTaggedSize, Type::Any(), MachineType::TaggedSigned(), |
| kNoWriteBarrier}, |
| {kTaggedBase, kTaggedSize, Type::Any(), MachineType::TaggedPointer(), |
| kNoWriteBarrier}}; |
| |
| ASSERT_EQ(arraysize(DecompressionOps), arraysize(ElementAccesses)); |
| |
| const Handle<HeapNumber> heapConstants[] = { |
| factory()->NewHeapNumber(0.0), |
| factory()->NewHeapNumber(-0.0), |
| factory()->NewHeapNumber(11.2), |
| factory()->NewHeapNumber(-11.2), |
| factory()->NewHeapNumber(3.1415 + 1.4142), |
| factory()->NewHeapNumber(3.1415 - 1.4142), |
| factory()->NewHeapNumber(0x0000000000000000), |
| factory()->NewHeapNumber(0x0000000000000001), |
| factory()->NewHeapNumber(0x0000FFFFFFFF0000), |
| factory()->NewHeapNumber(0x7FFFFFFFFFFFFFFF), |
| factory()->NewHeapNumber(0x8000000000000000), |
| factory()->NewHeapNumber(0x8000000000000001), |
| factory()->NewHeapNumber(0x8000FFFFFFFF0000), |
| factory()->NewHeapNumber(0x8FFFFFFFFFFFFFFF), |
| factory()->NewHeapNumber(0xFFFFFFFFFFFFFFFF)}; |
| |
| // For every decompression (lhs) |
| for (size_t j = 0; j < arraysize(DecompressionOps); ++j) { |
| // For every constant (rhs) |
| for (size_t k = 0; k < arraysize(heapConstants); ++k) { |
| // Test with both (lhs, rhs) combinations |
| for (bool lhsIsDecompression : {false, true}) { |
| // Create the graph |
| Node* load = |
| graph()->NewNode(simplified()->LoadElement(ElementAccesses[j]), |
| object, index, effect, control); |
| Node* changeToTagged = graph()->NewNode(DecompressionOps[j], load); |
| Node* constant = |
| graph()->NewNode(common()->HeapConstant(heapConstants[k])); |
| |
| Node* lhs = lhsIsDecompression ? changeToTagged : constant; |
| Node* rhs = lhsIsDecompression ? constant : changeToTagged; |
| Node* comparison = graph()->NewNode(machine()->Word64Equal(), lhs, rhs); |
| // Reduce |
| Reduction r = Reduce(comparison); |
| ASSERT_TRUE(r.Changed()); |
| EXPECT_EQ(r.replacement()->opcode(), IrOpcode::kWord32Equal); |
| } |
| } |
| } |
| } |
| |
| } // namespace compiler |
| } // namespace internal |
| } // namespace v8 |
