| // 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/node-properties.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" |
| #include "testing/gmock-support.h" |
| |
| using testing::_; |
| 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(StrictMock<MockAdvancedReducerEditor>* editor, Node* node) { |
| DecompressionElimination decompression_elimination(editor, graph(), |
| machine(), common()); |
| return decompression_elimination.Reduce(node); |
| } |
| Reduction Reduce(Node* node) { |
| StrictMock<MockAdvancedReducerEditor> editor; |
| return Reduce(&editor, node); |
| } |
| Node* GetUniqueValueUse(Node* node) { |
| Node* value_use = nullptr; |
| for (Edge edge : node->use_edges()) { |
| if (NodeProperties::IsValueEdge(edge)) { |
| if (value_use) { |
| return nullptr; |
| } else { |
| value_use = edge.from(); |
| } |
| } |
| } |
| // Return the value use of node after the reduction, if there is exactly one |
| return value_use; |
| } |
| |
| const Operator* DecompressionOpFromAccess(const ElementAccess access) { |
| switch (access.machine_type.representation()) { |
| case MachineRepresentation::kCompressed: |
| return machine()->ChangeCompressedToTagged(); |
| case MachineRepresentation::kCompressedSigned: |
| return machine()->ChangeCompressedSignedToTaggedSigned(); |
| case MachineRepresentation::kCompressedPointer: |
| return machine()->ChangeCompressedPointerToTaggedPointer(); |
| default: |
| UNREACHABLE(); |
| } |
| } |
| |
| const Operator* CompressionOpFromAccess(const ElementAccess access) { |
| switch (access.machine_type.representation()) { |
| case MachineRepresentation::kCompressed: |
| return machine()->ChangeTaggedToCompressed(); |
| case MachineRepresentation::kCompressedSigned: |
| return machine()->ChangeTaggedSignedToCompressedSigned(); |
| case MachineRepresentation::kCompressedPointer: |
| return machine()->ChangeTaggedPointerToCompressedPointer(); |
| default: |
| UNREACHABLE(); |
| } |
| } |
| |
| // 'Global' accesses used to simplify the tests. |
| ElementAccess const any_access = {kTaggedBase, kTaggedSize, Type::Any(), |
| MachineType::AnyCompressed(), |
| kNoWriteBarrier}; |
| ElementAccess const signed_access = {kTaggedBase, kTaggedSize, Type::Any(), |
| MachineType::CompressedSigned(), |
| kNoWriteBarrier}; |
| ElementAccess const pointer_access = {kTaggedBase, kTaggedSize, Type::Any(), |
| MachineType::CompressedPointer(), |
| kNoWriteBarrier}; |
| const ElementAccess element_accesses[3] = {any_access, signed_access, |
| pointer_access}; |
| |
| 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); |
| |
| // Pairs of <load, store> accesses |
| const std::pair<ElementAccess, ElementAccess> accesses[] = { |
| {any_access, any_access}, {signed_access, any_access}, |
| {pointer_access, any_access}, {any_access, signed_access}, |
| {signed_access, signed_access}, {any_access, pointer_access}, |
| {pointer_access, pointer_access}}; |
| |
| for (size_t i = 0; i < arraysize(accesses); ++i) { |
| // Create the graph. |
| Node* load = graph()->NewNode(simplified()->LoadElement(accesses[i].first), |
| object, index, effect, control); |
| Node* change_to_tagged = |
| graph()->NewNode(DecompressionOpFromAccess(accesses[i].first), load); |
| Node* change_to_compressed = graph()->NewNode( |
| CompressionOpFromAccess(accesses[i].second), change_to_tagged); |
| effect = |
| graph()->NewNode(simplified()->StoreElement(accesses[i].second), object, |
| index, change_to_compressed, effect, control); |
| |
| // Reduce. |
| Reduction r = Reduce(change_to_compressed); |
| ASSERT_TRUE(r.Changed()); |
| EXPECT_EQ(load, r.replacement()); |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| // Direct Compression & Decompression |
| |
| TEST_F(DecompressionEliminationTest, BasicCompressionDecompression) { |
| // 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); |
| |
| // Pairs of <load, store> accesses |
| const std::pair<ElementAccess, ElementAccess> accesses[] = { |
| {any_access, any_access}, {signed_access, any_access}, |
| {pointer_access, any_access}, {any_access, signed_access}, |
| {signed_access, signed_access}, {any_access, pointer_access}, |
| {pointer_access, pointer_access}}; |
| |
| for (size_t i = 0; i < arraysize(accesses); ++i) { |
| // Create the graph. |
| Node* load = graph()->NewNode(simplified()->LoadElement(accesses[i].first), |
| object, index, effect, control); |
| Node* change_to_compressed = |
| graph()->NewNode(CompressionOpFromAccess(accesses[i].first), load); |
| Node* change_to_tagged = graph()->NewNode( |
| DecompressionOpFromAccess(accesses[i].second), change_to_compressed); |
| effect = graph()->NewNode(simplified()->StoreElement(accesses[i].second), |
| object, index, change_to_tagged, effect, control); |
| |
| // Reduce. |
| Reduction r = Reduce(change_to_tagged); |
| ASSERT_TRUE(r.Changed()); |
| EXPECT_EQ(load, r.replacement()); |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| // Compress after constant. |
| |
| TEST_F(DecompressionEliminationTest, CompressionAfterInt64Constant) { |
| // 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 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 access. |
| for (size_t i = 0; i < arraysize(element_accesses); ++i) { |
| // For every Int64Constant. |
| for (size_t j = 0; j < arraysize(constants); ++j) { |
| // Create the graph. |
| Node* constant = graph()->NewNode(common()->Int64Constant(constants[j])); |
| Node* change_to_compressed = graph()->NewNode( |
| CompressionOpFromAccess(element_accesses[i]), constant); |
| effect = graph()->NewNode(simplified()->StoreElement(element_accesses[i]), |
| object, index, change_to_compressed, effect, |
| control); |
| // Reduce. |
| Reduction r = Reduce(change_to_compressed); |
| ASSERT_TRUE(r.Changed()); |
| EXPECT_EQ(r.replacement()->opcode(), IrOpcode::kInt32Constant); |
| } |
| } |
| } |
| |
| TEST_F(DecompressionEliminationTest, CompressionAfterHeapConstant) { |
| // 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 Handle<HeapNumber> heap_constants[] = { |
| 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 access. |
| for (size_t i = 0; i < arraysize(element_accesses); ++i) { |
| // For every HeapNumber. |
| for (size_t j = 0; j < arraysize(heap_constants); ++j) { |
| // Create the graph. |
| Node* constant = |
| graph()->NewNode(common()->HeapConstant(heap_constants[j])); |
| Node* change_to_compressed = graph()->NewNode( |
| CompressionOpFromAccess(element_accesses[i]), constant); |
| effect = graph()->NewNode(simplified()->StoreElement(element_accesses[i]), |
| object, index, change_to_compressed, effect, |
| control); |
| // Reduce. |
| Reduction r = Reduce(change_to_compressed); |
| ASSERT_TRUE(r.Changed()); |
| EXPECT_EQ(r.replacement()->opcode(), IrOpcode::kCompressedHeapConstant); |
| } |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| // 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; |
| |
| // 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(DecompressionOpFromAccess(element_accesses[i]), load); |
| Node* phi = graph()->NewNode( |
| common()->Phi(MachineRepresentation::kTagged, number_of_inputs), |
| change_to_tagged, control); |
| |
| // Reduce. |
| StrictMock<MockAdvancedReducerEditor> editor; |
| EXPECT_CALL(editor, ReplaceWithValue(phi, _, _, _)); |
| Reduction r = Reduce(&editor, phi); |
| ASSERT_TRUE(r.Changed()); |
| |
| // Get the actual decompress after the Phi, and check against the expected |
| // one. |
| Node* decompress = GetUniqueValueUse(phi); |
| EXPECT_EQ(DecompressionOpFromAccess(element_accesses[i]), decompress->op()); |
| } |
| } |
| |
| 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; |
| |
| // 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_tagged_1 = |
| graph()->NewNode(DecompressionOpFromAccess(element_accesses[i]), load1); |
| Node* change_to_tagged_2 = |
| graph()->NewNode(DecompressionOpFromAccess(element_accesses[i]), load2); |
| Node* change_to_tagged_3 = |
| graph()->NewNode(DecompressionOpFromAccess(element_accesses[i]), load3); |
| |
| Node* phi = graph()->NewNode( |
| common()->Phi(MachineRepresentation::kTagged, number_of_inputs), |
| change_to_tagged_1, change_to_tagged_2, change_to_tagged_3, control); |
| |
| // Reduce. |
| StrictMock<MockAdvancedReducerEditor> editor; |
| EXPECT_CALL(editor, ReplaceWithValue(phi, _, _, _)); |
| Reduction r = Reduce(&editor, phi); |
| ASSERT_TRUE(r.Changed()); |
| |
| // Get the actual decompress after the Phi, and check against the expected |
| // one. |
| Node* decompress = GetUniqueValueUse(phi); |
| EXPECT_EQ(DecompressionOpFromAccess(element_accesses[i]), decompress->op()); |
| } |
| } |
| |
| 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; |
| |
| // Signed and Pointer (and not Any) accesses. |
| const ElementAccess not_any_accesses[] = {signed_access, pointer_access}; |
| |
| // For every access. |
| for (size_t i = 0; i < arraysize(not_any_accesses); ++i) { |
| // Create the graph. |
| Node* load1 = |
| graph()->NewNode(simplified()->LoadElement(not_any_accesses[i]), object, |
| index, effect, control); |
| Node* load2 = |
| graph()->NewNode(simplified()->LoadElement(not_any_accesses[i]), object, |
| index, effect, control); |
| // Note that load3 loads a CompressedAny instead of not_any_accesses[i] |
| Node* load3 = graph()->NewNode(simplified()->LoadElement(any_access), |
| object, index, effect, control); |
| Node* change_to_tagged_1 = |
| graph()->NewNode(DecompressionOpFromAccess(not_any_accesses[i]), load1); |
| Node* change_to_tagged_2 = |
| graph()->NewNode(DecompressionOpFromAccess(not_any_accesses[i]), load2); |
| Node* change_to_tagged_3 = |
| graph()->NewNode(machine()->ChangeCompressedToTagged(), load3); |
| |
| Node* phi = graph()->NewNode( |
| common()->Phi(MachineRepresentation::kTagged, number_of_inputs), |
| change_to_tagged_1, change_to_tagged_2, change_to_tagged_3, control); |
| |
| // Reduce. |
| StrictMock<MockAdvancedReducerEditor> editor; |
| EXPECT_CALL(editor, ReplaceWithValue(phi, _, _, _)); |
| Reduction r = Reduce(&editor, phi); |
| ASSERT_TRUE(r.Changed()); |
| |
| // Get the actual decompress after the Phi, and check against the expected |
| // one. |
| Node* decompress = GetUniqueValueUse(phi); |
| EXPECT_EQ(machine()->ChangeCompressedToTagged(), decompress->op()); |
| } |
| } |
| |
| 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; |
| |
| // 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_tagged_1 = |
| graph()->NewNode(DecompressionOpFromAccess(element_accesses[i]), load1); |
| Node* change_to_tagged_2 = |
| graph()->NewNode(DecompressionOpFromAccess(element_accesses[i]), load2); |
| |
| Node* phi = graph()->NewNode( |
| common()->Phi(MachineRepresentation::kTagged, number_of_inputs), |
| change_to_tagged_1, change_to_tagged_2, 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; |
| |
| // 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_tagged_1 = |
| graph()->NewNode(DecompressionOpFromAccess(signed_access), load1); |
| Node* change_to_tagged_2 = |
| graph()->NewNode(DecompressionOpFromAccess(pointer_access), load2); |
| |
| Node* phi = graph()->NewNode( |
| common()->Phi(MachineRepresentation::kTagged, number_of_inputs), |
| change_to_tagged_1, change_to_tagged_2, control); |
| |
| // Reduce. |
| StrictMock<MockAdvancedReducerEditor> editor; |
| EXPECT_CALL(editor, ReplaceWithValue(phi, _, _, _)); |
| Reduction r = Reduce(&editor, phi); |
| ASSERT_TRUE(r.Changed()); |
| |
| // Get the actual decompress after the Phi, and check against the expected |
| // one. |
| Node* decompress = GetUniqueValueUse(phi); |
| EXPECT_EQ(machine()->ChangeCompressedToTagged(), decompress->op()); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| // 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 number_of_inputs = 1; |
| const ZoneVector<MachineType>* types = |
| new (graph()->zone()->New(sizeof(ZoneVector<MachineType>))) |
| ZoneVector<MachineType>(number_of_inputs, graph()->zone()); |
| SparseInputMask dense = SparseInputMask::Dense(); |
| |
| // 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(DecompressionOpFromAccess(element_accesses[i]), load); |
| Node* typedStateValues = graph()->NewNode( |
| common()->TypedStateValues(types, dense), change_to_tagged); |
| |
| // Reduce. |
| StrictMock<MockAdvancedReducerEditor> editor; |
| DecompressionElimination decompression_elimination(&editor, graph(), |
| machine(), common()); |
| Reduction r = decompression_elimination.Reduce(typedStateValues); |
| ASSERT_TRUE(r.Changed()); |
| EXPECT_EQ(r.replacement()->InputAt(0), load); |
| } |
| } |
| |
| 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 number_of_inputs = 3; |
| const ZoneVector<MachineType>* types = |
| new (graph()->zone()->New(sizeof(ZoneVector<MachineType>))) |
| ZoneVector<MachineType>(number_of_inputs, graph()->zone()); |
| SparseInputMask dense = SparseInputMask::Dense(); |
| |
| // 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* change_to_tagged_1 = |
| graph()->NewNode(DecompressionOpFromAccess(element_accesses[i]), load1); |
| Node* load2 = |
| graph()->NewNode(simplified()->LoadElement(element_accesses[i]), object, |
| index, effect, control); |
| Node* change_to_tagged_2 = |
| graph()->NewNode(DecompressionOpFromAccess(element_accesses[i]), load2); |
| Node* typedStateValues = |
| graph()->NewNode(common()->TypedStateValues(types, dense), |
| change_to_tagged_1, load1, change_to_tagged_2); |
| |
| // Reduce. |
| StrictMock<MockAdvancedReducerEditor> editor; |
| DecompressionElimination decompression_elimination(&editor, graph(), |
| machine(), common()); |
| Reduction r = decompression_elimination.Reduce(typedStateValues); |
| ASSERT_TRUE(r.Changed()); |
| EXPECT_EQ(r.replacement()->InputAt(0), load1); |
| // Note that the input at index 1 didn't change. |
| EXPECT_EQ(r.replacement()->InputAt(1), load1); |
| EXPECT_EQ(r.replacement()->InputAt(2), load2); |
| } |
| } |
| |
| 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 number_of_inputs = 3; |
| const ZoneVector<MachineType>* types = |
| new (graph()->zone()->New(sizeof(ZoneVector<MachineType>))) |
| ZoneVector<MachineType>(number_of_inputs, graph()->zone()); |
| SparseInputMask dense = SparseInputMask::Dense(); |
| |
| // 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* change_to_tagged_1 = |
| graph()->NewNode(DecompressionOpFromAccess(element_accesses[i]), load1); |
| Node* load2 = |
| graph()->NewNode(simplified()->LoadElement(element_accesses[i]), object, |
| index, effect, control); |
| Node* change_to_tagged_2 = |
| graph()->NewNode(DecompressionOpFromAccess(element_accesses[i]), load2); |
| Node* load3 = |
| graph()->NewNode(simplified()->LoadElement(element_accesses[i]), object, |
| index, effect, control); |
| Node* change_to_tagged_3 = |
| graph()->NewNode(DecompressionOpFromAccess(element_accesses[i]), load3); |
| Node* typedStateValues = graph()->NewNode( |
| common()->TypedStateValues(types, dense), change_to_tagged_1, |
| change_to_tagged_2, change_to_tagged_3); |
| |
| // Reduce. |
| StrictMock<MockAdvancedReducerEditor> editor; |
| DecompressionElimination decompression_elimination(&editor, graph(), |
| machine(), common()); |
| Reduction r = decompression_elimination.Reduce(typedStateValues); |
| ASSERT_TRUE(r.Changed()); |
| EXPECT_EQ(r.replacement()->InputAt(0), load1); |
| EXPECT_EQ(r.replacement()->InputAt(1), load2); |
| EXPECT_EQ(r.replacement()->InputAt(2), load3); |
| } |
| } |
| |
| 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 number_of_inputs = 3; |
| const ZoneVector<MachineType>* types = |
| new (graph()->zone()->New(sizeof(ZoneVector<MachineType>))) |
| ZoneVector<MachineType>(number_of_inputs, graph()->zone()); |
| SparseInputMask dense = SparseInputMask::Dense(); |
| |
| // 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* typedStateValues = 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(typedStateValues); |
| 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); |
| |
| // For every decompression (lhs). |
| for (size_t i = 0; i < arraysize(element_accesses); ++i) { |
| // For every decompression (rhs) |
| for (size_t j = 0; j < arraysize(element_accesses); ++j) { |
| // Create the graph. |
| Node* load1 = |
| graph()->NewNode(simplified()->LoadElement(element_accesses[i]), |
| object, index, effect, control); |
| Node* change_to_tagged_1 = graph()->NewNode( |
| DecompressionOpFromAccess(element_accesses[i]), load1); |
| Node* load2 = |
| graph()->NewNode(simplified()->LoadElement(element_accesses[j]), |
| object, index, effect, control); |
| Node* change_to_tagged_2 = graph()->NewNode( |
| DecompressionOpFromAccess(element_accesses[i]), load2); |
| Node* comparison = graph()->NewNode( |
| machine()->Word64Equal(), change_to_tagged_1, change_to_tagged_2); |
| // 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); |
| |
| // For every access. (same for lhs and rhs) |
| 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(DecompressionOpFromAccess(element_accesses[i]), load); |
| Node* comparison = graph()->NewNode(machine()->Word64Equal(), |
| change_to_tagged, change_to_tagged); |
| // 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 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 i = 0; i < arraysize(element_accesses); ++i) { |
| // For every constant (rhs). |
| for (size_t j = 0; j < arraysize(constants); ++j) { |
| // Test with both (lhs, rhs) combinations. |
| for (bool lhs_is_decompression : {false, true}) { |
| // Create the graph. |
| Node* load = |
| graph()->NewNode(simplified()->LoadElement(element_accesses[i]), |
| object, index, effect, control); |
| Node* change_to_tagged = graph()->NewNode( |
| DecompressionOpFromAccess(element_accesses[i]), load); |
| Node* constant = |
| graph()->NewNode(common()->Int64Constant(constants[j])); |
| |
| Node* lhs = lhs_is_decompression ? change_to_tagged : constant; |
| Node* rhs = lhs_is_decompression ? constant : change_to_tagged; |
| 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 Handle<HeapNumber> heap_constants[] = { |
| 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 i = 0; i < arraysize(element_accesses); ++i) { |
| // For every constant (rhs). |
| for (size_t j = 0; j < arraysize(heap_constants); ++j) { |
| // Test with both (lhs, rhs) combinations. |
| for (bool lhs_is_decompression : {false, true}) { |
| // Create the graph. |
| Node* load = |
| graph()->NewNode(simplified()->LoadElement(element_accesses[i]), |
| object, index, effect, control); |
| Node* change_to_tagged = graph()->NewNode( |
| DecompressionOpFromAccess(element_accesses[i]), load); |
| Node* constant = |
| graph()->NewNode(common()->HeapConstant(heap_constants[j])); |
| |
| Node* lhs = lhs_is_decompression ? change_to_tagged : constant; |
| Node* rhs = lhs_is_decompression ? constant : change_to_tagged; |
| 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 |
