// 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-optimizer.h" #include "test/unittests/compiler/graph-unittest.h" namespace v8 { namespace internal { namespace compiler { class DecompressionOptimizerTest : public GraphTest { public: DecompressionOptimizerTest() : GraphTest(), machine_(zone(), MachineType::PointerRepresentation(), MachineOperatorBuilder::kNoFlags) {} ~DecompressionOptimizerTest() override = default; protected: void Reduce() { DecompressionOptimizer decompression_optimizer(zone(), graph(), common(), machine()); decompression_optimizer.Reduce(); } MachineRepresentation CompressedMachRep(MachineRepresentation mach_rep) { if (mach_rep == MachineRepresentation::kTagged) { return MachineRepresentation::kCompressed; } else { DCHECK_EQ(mach_rep, MachineRepresentation::kTaggedPointer); return MachineRepresentation::kCompressedPointer; } } MachineRepresentation CompressedMachRep(MachineType type) { return CompressedMachRep(type.representation()); } MachineRepresentation LoadMachRep(Node* node) { return LoadRepresentationOf(node->op()).representation(); } StoreRepresentation CreateStoreRep(MachineType type) { return StoreRepresentation(type.representation(), WriteBarrierKind::kFullWriteBarrier); } const MachineType types[2] = {MachineType::AnyTagged(), MachineType::TaggedPointer()}; const Handle<HeapNumber> heap_constants[15] = { 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)}; MachineOperatorBuilder* machine() { return &machine_; } private: MachineOperatorBuilder machine_; }; // ----------------------------------------------------------------------------- // Direct Load into Store. TEST_F(DecompressionOptimizerTest, DirectLoadStore) { // Define variables. Node* const control = graph()->start(); Node* object = Parameter(Type::Any(), 0); Node* effect = graph()->start(); Node* index = Parameter(Type::UnsignedSmall(), 1); // Test for both AnyTagged and TaggedPointer. for (size_t i = 0; i < arraysize(types); ++i) { // Create the graph. Node* base_pointer = graph()->NewNode(machine()->Load(types[i]), object, index, effect, control); Node* value = graph()->NewNode(machine()->Load(types[i]), base_pointer, index, effect, control); graph()->SetEnd(graph()->NewNode(machine()->Store(CreateStoreRep(types[i])), object, index, value, effect, control)); // Change the nodes, and test the change. Reduce(); EXPECT_EQ(LoadMachRep(base_pointer), types[i].representation()); EXPECT_EQ(LoadMachRep(value), CompressedMachRep(types[i])); } } // ----------------------------------------------------------------------------- // Word32 Operations. TEST_F(DecompressionOptimizerTest, Word32EqualTwoDecompresses) { // Define variables. Node* const control = graph()->start(); Node* object = Parameter(Type::Any(), 0); Node* effect = graph()->start(); Node* index = Parameter(Type::UnsignedSmall(), 1); // Test for both AnyTagged and TaggedPointer, for both loads. for (size_t i = 0; i < arraysize(types); ++i) { for (size_t j = 0; j < arraysize(types); ++j) { // Create the graph. Node* load_1 = graph()->NewNode(machine()->Load(types[i]), object, index, effect, control); Node* load_2 = graph()->NewNode(machine()->Load(types[j]), object, index, effect, control); Node* equal = graph()->NewNode(machine()->Word32Equal(), load_1, load_2); graph()->SetEnd(equal); // Change the nodes, and test the change. Reduce(); EXPECT_EQ(LoadMachRep(load_1), CompressedMachRep(types[i])); EXPECT_EQ(LoadMachRep(load_2), CompressedMachRep(types[j])); } } } TEST_F(DecompressionOptimizerTest, Word32EqualDecompressAndConstant) { // Define variables. Node* const control = graph()->start(); Node* object = Parameter(Type::Any(), 0); Node* effect = graph()->start(); Node* index = Parameter(Type::UnsignedSmall(), 1); // Test for both AnyTagged and TaggedPointer. for (size_t i = 0; i < arraysize(types); ++i) { for (size_t j = 0; j < arraysize(heap_constants); ++j) { // Create the graph. Node* load = graph()->NewNode(machine()->Load(types[i]), object, index, effect, control); Node* constant = graph()->NewNode(common()->HeapConstant(heap_constants[j])); Node* equal = graph()->NewNode(machine()->Word32Equal(), load, constant); graph()->SetEnd(equal); // Change the nodes, and test the change. Reduce(); EXPECT_EQ(LoadMachRep(load), CompressedMachRep(types[i])); EXPECT_EQ(constant->opcode(), IrOpcode::kCompressedHeapConstant); } } } TEST_F(DecompressionOptimizerTest, Word32AndSmiCheck) { // Define variables. Node* const control = graph()->start(); Node* object = Parameter(Type::Any(), 0); Node* effect = graph()->start(); Node* index = Parameter(Type::UnsignedSmall(), 1); // Test for both AnyTagged and TaggedPointer. for (size_t i = 0; i < arraysize(types); ++i) { // Create the graph. Node* load = graph()->NewNode(machine()->Load(types[i]), object, index, effect, control); Node* smi_tag_mask = graph()->NewNode(common()->Int32Constant(kSmiTagMask)); Node* word32_and = graph()->NewNode(machine()->Word32And(), load, smi_tag_mask); Node* smi_tag = graph()->NewNode(common()->Int32Constant(kSmiTag)); graph()->SetEnd( graph()->NewNode(machine()->Word32Equal(), word32_and, smi_tag)); // Change the nodes, and test the change. Reduce(); EXPECT_EQ(LoadMachRep(load), CompressedMachRep(types[i])); } } TEST_F(DecompressionOptimizerTest, Word32ShlSmiTag) { // Define variables. Node* const control = graph()->start(); Node* object = Parameter(Type::Any(), 0); Node* effect = graph()->start(); Node* index = Parameter(Type::UnsignedSmall(), 1); // Test only for AnyTagged, since TaggedPointer can't be Smi tagged. // Create the graph. Node* load = graph()->NewNode(machine()->Load(MachineType::AnyTagged()), object, index, effect, control); Node* smi_shift_bits = graph()->NewNode(common()->Int32Constant(kSmiShiftSize + kSmiTagSize)); Node* word32_shl = graph()->NewNode(machine()->Word32Shl(), load, smi_shift_bits); graph()->SetEnd( graph()->NewNode(machine()->BitcastWord32ToWord64(), word32_shl)); // Change the nodes, and test the change. Reduce(); EXPECT_EQ(LoadMachRep(load), CompressedMachRep(MachineType::AnyTagged())); } TEST_F(DecompressionOptimizerTest, Word32SarSmiUntag) { // Define variables. Node* const control = graph()->start(); Node* object = Parameter(Type::Any(), 0); Node* effect = graph()->start(); Node* index = Parameter(Type::UnsignedSmall(), 1); // Test only for AnyTagged, since TaggedPointer can't be Smi tagged. // Create the graph. Node* load = graph()->NewNode(machine()->Load(MachineType::AnyTagged()), object, index, effect, control); Node* truncation = graph()->NewNode(machine()->TruncateInt64ToInt32(), load); Node* smi_shift_bits = graph()->NewNode(common()->Int32Constant(kSmiShiftSize + kSmiTagSize)); Node* word32_sar = graph()->NewNode(machine()->Word32Sar(), truncation, smi_shift_bits); graph()->SetEnd( graph()->NewNode(machine()->ChangeInt32ToInt64(), word32_sar)); // Change the nodes, and test the change. Reduce(); EXPECT_EQ(LoadMachRep(load), CompressedMachRep(MachineType::AnyTagged())); } // ----------------------------------------------------------------------------- // FrameState and TypedStateValues interaction. TEST_F(DecompressionOptimizerTest, TypedStateValues) { // 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 ZoneVector<MachineType>* types_for_state_values = graph()->zone()->New<ZoneVector<MachineType>>(number_of_inputs, graph()->zone()); SparseInputMask dense = SparseInputMask::Dense(); // Test for both AnyTagged and TaggedPointer. for (size_t i = 0; i < arraysize(types); ++i) { for (size_t j = 0; j < arraysize(heap_constants); ++j) { // Create the graph. Node* load = graph()->NewNode(machine()->Load(types[i]), object, index, effect, control); Node* constant_1 = graph()->NewNode(common()->HeapConstant(heap_constants[j])); Node* typed_state_values = graph()->NewNode( common()->TypedStateValues(types_for_state_values, dense), load, constant_1); Node* constant_2 = graph()->NewNode(common()->HeapConstant(heap_constants[j])); graph()->SetEnd(graph()->NewNode( common()->FrameState(BailoutId::None(), OutputFrameStateCombine::Ignore(), nullptr), typed_state_values, typed_state_values, typed_state_values, constant_2, UndefinedConstant(), graph()->start())); // Change the nodes, and test the change. Reduce(); EXPECT_EQ(LoadMachRep(load), CompressedMachRep(types[i])); EXPECT_EQ(constant_1->opcode(), IrOpcode::kCompressedHeapConstant); EXPECT_EQ(constant_2->opcode(), IrOpcode::kCompressedHeapConstant); } } } // ----------------------------------------------------------------------------- // Phi TEST_F(DecompressionOptimizerTest, PhiDecompressOrNot) { // 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; // Test for both AnyTagged and TaggedPointer. for (size_t i = 0; i < arraysize(types); ++i) { for (size_t j = 0; j < arraysize(heap_constants); ++j) { // Create the graph. // Base pointer Node* load_1 = graph()->NewNode(machine()->Load(types[i]), object, index, effect, control); Node* constant_1 = graph()->NewNode(common()->HeapConstant(heap_constants[j])); Node* phi_1 = graph()->NewNode( common()->Phi(types[i].representation(), number_of_inputs), load_1, constant_1, control); // Value Node* load_2 = graph()->NewNode(machine()->Load(types[i]), object, index, effect, control); Node* constant_2 = graph()->NewNode(common()->HeapConstant(heap_constants[j])); Node* phi_2 = graph()->NewNode( common()->Phi(types[i].representation(), number_of_inputs), load_2, constant_2, control); graph()->SetEnd( graph()->NewNode(machine()->Store(CreateStoreRep(types[i])), phi_1, index, phi_2, effect, control)); // Change the nodes, and test the change. Reduce(); // Base pointer should not be compressed. EXPECT_EQ(LoadMachRep(load_1), types[i].representation()); EXPECT_EQ(constant_1->opcode(), IrOpcode::kHeapConstant); EXPECT_EQ(PhiRepresentationOf(phi_1->op()), types[i].representation()); // Value should be compressed. EXPECT_EQ(LoadMachRep(load_2), CompressedMachRep(types[i])); EXPECT_EQ(constant_2->opcode(), IrOpcode::kCompressedHeapConstant); EXPECT_EQ(PhiRepresentationOf(phi_2->op()), CompressedMachRep(types[i])); } } } TEST_F(DecompressionOptimizerTest, CascadingPhi) { // 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; // Test for both AnyTagged and TaggedPointer. for (size_t i = 0; i < arraysize(types); ++i) { // Create the graph. Node* load_1 = graph()->NewNode(machine()->Load(types[i]), object, index, effect, control); Node* load_2 = graph()->NewNode(machine()->Load(types[i]), object, index, effect, control); Node* load_3 = graph()->NewNode(machine()->Load(types[i]), object, index, effect, control); Node* load_4 = graph()->NewNode(machine()->Load(types[i]), object, index, effect, control); Node* phi_1 = graph()->NewNode( common()->Phi(types[i].representation(), number_of_inputs), load_1, load_2, control); Node* phi_2 = graph()->NewNode( common()->Phi(types[i].representation(), number_of_inputs), load_3, load_4, control); Node* final_phi = graph()->NewNode( common()->Phi(types[i].representation(), number_of_inputs), phi_1, phi_2, control); // Value graph()->SetEnd(final_phi); // Change the nodes, and test the change. Reduce(); // Loads are all compressed EXPECT_EQ(LoadMachRep(load_1), CompressedMachRep(types[i])); EXPECT_EQ(LoadMachRep(load_2), CompressedMachRep(types[i])); EXPECT_EQ(LoadMachRep(load_3), CompressedMachRep(types[i])); EXPECT_EQ(LoadMachRep(load_4), CompressedMachRep(types[i])); // Phis too EXPECT_EQ(PhiRepresentationOf(phi_1->op()), CompressedMachRep(types[i])); EXPECT_EQ(PhiRepresentationOf(phi_2->op()), CompressedMachRep(types[i])); EXPECT_EQ(PhiRepresentationOf(final_phi->op()), CompressedMachRep(types[i])); } } TEST_F(DecompressionOptimizerTest, PhiWithOneCompressedAndOneTagged) { // 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; // Test for both AnyTagged and TaggedPointer. for (size_t i = 0; i < arraysize(types); ++i) { for (size_t j = 0; j < arraysize(heap_constants); ++j) { // Create the graph. // Base pointer in load_2, and phi input for value Node* load_1 = graph()->NewNode(machine()->Load(types[i]), object, index, effect, control); // load_2 blocks load_1 from being compressed. Node* load_2 = graph()->NewNode(machine()->Load(types[i]), load_1, index, effect, control); Node* phi = graph()->NewNode( common()->Phi(types[i].representation(), number_of_inputs), load_1, load_2, control); graph()->SetEnd( graph()->NewNode(machine()->Store(CreateStoreRep(types[i])), object, index, phi, effect, control)); // Change the nodes, and test the change. Reduce(); EXPECT_EQ(LoadMachRep(load_1), types[i].representation()); EXPECT_EQ(LoadMachRep(load_2), CompressedMachRep(types[i])); EXPECT_EQ(PhiRepresentationOf(phi->op()), CompressedMachRep(types[i])); } } } // ----------------------------------------------------------------------------- // Int cases. TEST_F(DecompressionOptimizerTest, Int32LessThanOrEqualFromSpeculative) { // This case tests for what SpeculativeNumberLessThanOrEqual is lowered to. // Define variables. Node* const control = graph()->start(); Node* object = Parameter(Type::Any(), 0); Node* effect = graph()->start(); Node* index = Parameter(Type::UnsignedSmall(), 1); // Test only for AnyTagged, since TaggedPointer can't be a Smi. // Create the graph. Node* load = graph()->NewNode(machine()->Load(MachineType::AnyTagged()), object, index, effect, control); Node* constant = graph()->NewNode(common()->Int64Constant(5)); graph()->SetEnd( graph()->NewNode(machine()->Int32LessThanOrEqual(), load, constant)); // Change the nodes, and test the change. Reduce(); EXPECT_EQ(LoadMachRep(load), CompressedMachRep(MachineType::AnyTagged())); } // ----------------------------------------------------------------------------- // Bitcast cases. TEST_F(DecompressionOptimizerTest, BitcastTaggedToWord) { // Define variables. Node* const control = graph()->start(); Node* object = Parameter(Type::Any(), 0); Node* effect = graph()->start(); Node* index = Parameter(Type::UnsignedSmall(), 1); // Test for both AnyTagged and TaggedPointer, for both loads. for (size_t i = 0; i < arraysize(types); ++i) { for (size_t j = 0; j < arraysize(types); ++j) { // Create the graph. Node* load_1 = graph()->NewNode(machine()->Load(types[i]), object, index, effect, control); Node* bitcast_1 = graph()->NewNode(machine()->BitcastTaggedToWord(), load_1, effect, control); Node* load_2 = graph()->NewNode(machine()->Load(types[j]), object, index, effect, control); Node* bitcast_2 = graph()->NewNode(machine()->BitcastTaggedToWord(), load_2, effect, control); Node* equal = graph()->NewNode(machine()->Word32Equal(), bitcast_1, bitcast_2); graph()->SetEnd(equal); // Change the nodes, and test the change. Reduce(); EXPECT_EQ(LoadMachRep(load_1), CompressedMachRep(types[i])); EXPECT_EQ(LoadMachRep(load_2), CompressedMachRep(types[j])); } } } TEST_F(DecompressionOptimizerTest, BitcastTaggedToWordForTagAndSmiBits) { // Define variables. Node* const control = graph()->start(); Node* object = Parameter(Type::Any(), 0); Node* effect = graph()->start(); Node* index = Parameter(Type::UnsignedSmall(), 1); // Test for both AnyTagged and TaggedPointer, for both loads. for (size_t i = 0; i < arraysize(types); ++i) { for (size_t j = 0; j < arraysize(types); ++j) { // Create the graph. Node* load_1 = graph()->NewNode(machine()->Load(types[i]), object, index, effect, control); Node* bitcast_1 = graph()->NewNode( machine()->BitcastTaggedToWordForTagAndSmiBits(), load_1); Node* load_2 = graph()->NewNode(machine()->Load(types[j]), object, index, effect, control); Node* bitcast_2 = graph()->NewNode( machine()->BitcastTaggedToWordForTagAndSmiBits(), load_2); Node* equal = graph()->NewNode(machine()->Word32Equal(), bitcast_1, bitcast_2); graph()->SetEnd(equal); // Change the nodes, and test the change. Reduce(); EXPECT_EQ(LoadMachRep(load_1), CompressedMachRep(types[i])); EXPECT_EQ(LoadMachRep(load_2), CompressedMachRep(types[j])); } } } } // namespace compiler } // namespace internal } // namespace v8