test/opt/constant_manager_test.cpp

// Copyright (c) 2018 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#include <memory>
#include <string>
#include <vector>

#include "gtest/gtest.h"
#include "source/opt/build_module.h"
#include "source/opt/constants.h"
#include "source/opt/ir_context.h"

namespace spvtools {
namespace opt {
namespace analysis {
namespace {

using ConstantManagerTest = ::testing::Test;

TEST_F(ConstantManagerTest, GetDefiningInstruction) {
  const std::string text = R"(
%int = OpTypeInt 32 0
%1 = OpTypeStruct %int
%2 = OpTypeStruct %int
  )";

  std::unique_ptr<IRContext> context =
      BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text,
                  SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS);
  ASSERT_NE(context, nullptr);

  Type* struct_type_1 = context->get_type_mgr()->GetType(1);
  StructConstant struct_const_1(struct_type_1->AsStruct());
  Instruction* const_inst_1 =
      context->get_constant_mgr()->GetDefiningInstruction(&struct_const_1, 1);
  EXPECT_EQ(const_inst_1->type_id(), 1);

  Type* struct_type_2 = context->get_type_mgr()->GetType(2);
  StructConstant struct_const_2(struct_type_2->AsStruct());
  Instruction* const_inst_2 =
      context->get_constant_mgr()->GetDefiningInstruction(&struct_const_2, 2);
  EXPECT_EQ(const_inst_2->type_id(), 2);
}

TEST_F(ConstantManagerTest, GetDefiningInstruction2) {
  const std::string text = R"(
%int = OpTypeInt 32 0
%1 = OpTypeStruct %int
%2 = OpTypeStruct %int
%3 = OpConstantNull %1
%4 = OpConstantNull %2
  )";

  std::unique_ptr<IRContext> context =
      BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text,
                  SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS);
  ASSERT_NE(context, nullptr);

  Type* struct_type_1 = context->get_type_mgr()->GetType(1);
  NullConstant struct_const_1(struct_type_1->AsStruct());
  Instruction* const_inst_1 =
      context->get_constant_mgr()->GetDefiningInstruction(&struct_const_1, 1);
  EXPECT_EQ(const_inst_1->type_id(), 1);
  EXPECT_EQ(const_inst_1->result_id(), 3);

  Type* struct_type_2 = context->get_type_mgr()->GetType(2);
  NullConstant struct_const_2(struct_type_2->AsStruct());
  Instruction* const_inst_2 =
      context->get_constant_mgr()->GetDefiningInstruction(&struct_const_2, 2);
  EXPECT_EQ(const_inst_2->type_id(), 2);
  EXPECT_EQ(const_inst_2->result_id(), 4);
}

TEST_F(ConstantManagerTest, GetDefiningInstructionIdOverflow) {
  const std::string text = R"(
%1 = OpTypeInt 32 0
%3 = OpConstant %1 1
%4 = OpConstant %1 2
  )";

  std::unique_ptr<IRContext> context =
      BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text,
                  SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS);
  ASSERT_NE(context, nullptr);

  // Set the id bound to the max, so the new constant cannot be generated.
  context->module()->SetIdBound(context->max_id_bound());

  Type* int_type = context->get_type_mgr()->GetType(1);
  IntConstant int_constant(int_type->AsInteger(), {3});
  Instruction* inst =
      context->get_constant_mgr()->GetDefiningInstruction(&int_constant, 1);
  EXPECT_EQ(inst, nullptr);
}

TEST_F(ConstantManagerTest, ConstantCompositeReplicateExtMapping) {
  const std::string text = R"(
OpCapability Shader
OpCapability ReplicatedCompositesEXT
OpExtension "SPV_EXT_replicated_composites"
OpMemoryModel Logical Simple
%1 = OpTypeInt 32 1
%2 = OpTypeVector %1 4
%3 = OpConstant %1 0
%4 = OpConstantCompositeReplicateEXT %2 %3
%5 = OpSpecConstantCompositeReplicateEXT %2 %3
  )";

  std::unique_ptr<IRContext> context =
      BuildModule(SPV_ENV_UNIVERSAL_1_5, nullptr, text,
                  SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS);
  ASSERT_NE(context, nullptr);

  ConstantManager* const_mgr = context->get_constant_mgr();
  const Constant* base_constant = const_mgr->FindDeclaredConstant(3);
  ASSERT_NE(base_constant, nullptr);

  const Constant* composite_constant = const_mgr->FindDeclaredConstant(4);
  ASSERT_NE(composite_constant, nullptr);
  const Vector* vector_type = composite_constant->type()->AsVector();
  ASSERT_NE(vector_type, nullptr);

  const CompositeConstant* composite =
      composite_constant->AsCompositeConstant();
  ASSERT_NE(composite, nullptr);
  ASSERT_EQ(composite->GetComponents().size(),
            static_cast<size_t>(vector_type->element_count()));
  ASSERT_FALSE(composite->GetComponents().empty());
  for (const Constant* component : composite->GetComponents()) {
    EXPECT_EQ(component, base_constant);
  }

  const Constant* spec_composite_constant = const_mgr->FindDeclaredConstant(5);
  ASSERT_NE(spec_composite_constant, nullptr);
  const Vector* spec_vector_type = spec_composite_constant->type()->AsVector();
  ASSERT_NE(spec_vector_type, nullptr);

  const CompositeConstant* spec_composite =
      spec_composite_constant->AsCompositeConstant();
  ASSERT_NE(spec_composite, nullptr);
  ASSERT_EQ(spec_composite->GetComponents().size(),
            static_cast<size_t>(spec_vector_type->element_count()));
  ASSERT_FALSE(spec_composite->GetComponents().empty());
  for (const Constant* component : spec_composite->GetComponents()) {
    EXPECT_EQ(component, base_constant);
  }
}

TEST_F(ConstantManagerTest, NullTensor) {
  const std::string text = R"(
%uint = OpTypeInt 32 0
%1 = OpConstant %uint 1
%2 = OpConstant %uint 2
%uint_5 = OpConstant %uint 5
%uint_7 = OpConstant %uint 7
%arr_uint_1 = OpTypeArray %uint %1
%arr_uint_2 = OpTypeArray %uint %2
%10 = OpConstantComposite %arr_uint_1 %uint_7
%11 = OpConstantComposite %arr_uint_2 %uint_5 %uint_7
  )";

  std::unique_ptr<IRContext> context =
      BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text,
                  SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS);
  ASSERT_NE(context, nullptr);
  const auto cstmgr = context->get_constant_mgr();

  Integer ty_uint(32, 0);

  // rank-1 with 7 elements
  TensorARM ty_tensor_r1_7(&ty_uint, 1, 10);
  auto null_tensor_r1_7 =
      cstmgr->GetNullCompositeConstant(&ty_tensor_r1_7)->AsTensorConstant();
  ASSERT_NE(null_tensor_r1_7, nullptr);
  ASSERT_EQ(null_tensor_r1_7->GetComponents().size(), 7);
  ASSERT_TRUE(null_tensor_r1_7->IsZero());

  // rank-2 with 5 elements of rank-1 type with 7 elements
  TensorARM ty_tensor_r2_5_7(&ty_uint, 2, 11);
  auto null_tensor_r2_5_7 =
      cstmgr->GetNullCompositeConstant(&ty_tensor_r2_5_7)->AsTensorConstant();
  ASSERT_NE(null_tensor_r2_5_7, nullptr);
  ASSERT_EQ(null_tensor_r2_5_7->GetComponents().size(), 5);
  ASSERT_TRUE(null_tensor_r2_5_7->IsZero());
  ASSERT_NE(null_tensor_r2_5_7->GetComponents()[0]->AsTensorConstant(),
            nullptr);
  ASSERT_TRUE(null_tensor_r2_5_7->GetComponents()[0]->type()->IsSameImpl(
      &ty_tensor_r1_7, nullptr));
}

TEST_F(ConstantManagerTest, TensorConstantFromInstruction) {
  const std::string text = R"(
OpCapability TensorsARM
OpExtension "SPV_ARM_tensors"
%1 = OpTypeInt 32 0
%2 = OpConstant %1 1
%3 = OpConstant %1 2
%4 = OpConstant %1 3
%5 = OpTypeArray %1 %2
%6 = OpConstantComposite %5 %4
%7 = OpTypeTensorARM %1 %2 %6
%8 = OpConstantComposite %7 %2 %3 %4
  )";

  std::unique_ptr<IRContext> context =
      BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text,
                  SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS);
  ASSERT_NE(context, nullptr);

  const Constant* constant =
      context->get_constant_mgr()->FindDeclaredConstant(8);
  ASSERT_NE(constant, nullptr);
  const auto* tensor_const = constant->AsTensorConstant();
  ASSERT_NE(tensor_const, nullptr);
  ASSERT_EQ(tensor_const->GetComponents().size(), 3);
  EXPECT_EQ(tensor_const->GetComponents()[0]->GetZeroExtendedValue(), 1u);
  EXPECT_EQ(tensor_const->GetComponents()[1]->GetZeroExtendedValue(), 2u);
  EXPECT_EQ(tensor_const->GetComponents()[2]->GetZeroExtendedValue(), 3u);
  EXPECT_FALSE(tensor_const->IsZero());
}

struct TensorConstantCompositeReplicateExtCase {
  std::string opcode;
  std::string name;
};

class TensorConstantCompositeReplicateExtTest
    : public ::testing::TestWithParam<TensorConstantCompositeReplicateExtCase> {
};

std::string TensorConstantCompositeReplicateExtCaseName(
    const ::testing::TestParamInfo<TensorConstantCompositeReplicateExtCase>&
        info) {
  return info.param.name;
}

TEST_P(TensorConstantCompositeReplicateExtTest, FromInstruction) {
  const std::string text = R"(
OpCapability TensorsARM
OpCapability ReplicatedCompositesEXT
OpExtension "SPV_ARM_tensors"
OpExtension "SPV_EXT_replicated_composites"
%1 = OpTypeInt 32 0
%2 = OpConstant %1 1
%3 = OpConstant %1 2
%4 = OpTypeArray %1 %2
%5 = OpConstantComposite %4 %3
%6 = OpTypeTensorARM %1 %2 %5
%7 = )" + GetParam().opcode +
                           R"( %6 %3
  )";

  std::unique_ptr<IRContext> context =
      BuildModule(SPV_ENV_UNIVERSAL_1_5, nullptr, text,
                  SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS);
  ASSERT_NE(context, nullptr);

  const Constant* base_constant =
      context->get_constant_mgr()->FindDeclaredConstant(3);
  ASSERT_NE(base_constant, nullptr);

  const Constant* constant =
      context->get_constant_mgr()->FindDeclaredConstant(7);
  ASSERT_NE(constant, nullptr);
  const auto* tensor_const = constant->AsTensorConstant();
  ASSERT_NE(tensor_const, nullptr);
  ASSERT_EQ(tensor_const->GetComponents().size(), 2u);
  EXPECT_EQ(tensor_const->GetComponents()[0], base_constant);
  EXPECT_EQ(tensor_const->GetComponents()[1], base_constant);
  EXPECT_FALSE(tensor_const->IsZero());
}

TEST_P(TensorConstantCompositeReplicateExtTest, Rank2FromInstruction) {
  const std::string text = R"(
OpCapability TensorsARM
OpCapability ReplicatedCompositesEXT
OpExtension "SPV_ARM_tensors"
OpExtension "SPV_EXT_replicated_composites"
%1 = OpTypeInt 32 0
%2 = OpConstant %1 1
%3 = OpConstant %1 2
%4 = OpConstant %1 3
%5 = OpTypeArray %1 %2
%6 = OpTypeArray %1 %3
%7 = OpConstantComposite %5 %4
%8 = OpConstantComposite %6 %3 %4
%9 = OpTypeTensorARM %1 %2 %7
%10 = OpTypeTensorARM %1 %3 %8
%11 = OpConstantComposite %9 %2 %3 %4
%12 = )" + GetParam().opcode +
                           R"( %10 %11
  )";

  std::unique_ptr<IRContext> context =
      BuildModule(SPV_ENV_UNIVERSAL_1_5, nullptr, text,
                  SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS);
  ASSERT_NE(context, nullptr);

  const Constant* row_constant =
      context->get_constant_mgr()->FindDeclaredConstant(11);
  ASSERT_NE(row_constant, nullptr);
  const auto* row_tensor = row_constant->AsTensorConstant();
  ASSERT_NE(row_tensor, nullptr);
  ASSERT_EQ(row_tensor->GetComponents().size(), 3u);
  EXPECT_EQ(row_tensor->GetComponents()[0]->GetZeroExtendedValue(), 1u);
  EXPECT_EQ(row_tensor->GetComponents()[1]->GetZeroExtendedValue(), 2u);
  EXPECT_EQ(row_tensor->GetComponents()[2]->GetZeroExtendedValue(), 3u);

  const Constant* constant =
      context->get_constant_mgr()->FindDeclaredConstant(12);
  ASSERT_NE(constant, nullptr);
  const auto* tensor_const = constant->AsTensorConstant();
  ASSERT_NE(tensor_const, nullptr);
  ASSERT_EQ(tensor_const->GetComponents().size(), 2u);
  EXPECT_EQ(tensor_const->GetComponents()[0], row_constant);
  EXPECT_EQ(tensor_const->GetComponents()[1], row_constant);
  EXPECT_FALSE(tensor_const->IsZero());
}

TEST_P(TensorConstantCompositeReplicateExtTest,
       WithReplicatedShapeFromInstruction) {
  const std::string text = R"(
OpCapability TensorsARM
OpCapability ReplicatedCompositesEXT
OpExtension "SPV_ARM_tensors"
OpExtension "SPV_EXT_replicated_composites"
%1 = OpTypeInt 32 0
%2 = OpConstant %1 1
%3 = OpConstant %1 2
%4 = OpConstant %1 7
%5 = OpTypeArray %1 %2
%6 = OpTypeArray %1 %3
%7 = OpConstantCompositeReplicateEXT %5 %3
%8 = OpConstantCompositeReplicateEXT %6 %3
%9 = OpTypeTensorARM %1 %2 %7
%10 = OpTypeTensorARM %1 %3 %8
%11 = OpConstantCompositeReplicateEXT %9 %4
%12 = )" + GetParam().opcode +
                           R"( %10 %11
  )";

  std::unique_ptr<IRContext> context =
      BuildModule(SPV_ENV_UNIVERSAL_1_5, nullptr, text,
                  SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS);
  ASSERT_NE(context, nullptr);

  const Constant* shape_constant =
      context->get_constant_mgr()->FindDeclaredConstant(8);
  ASSERT_NE(shape_constant, nullptr);
  const auto* shape_array = shape_constant->AsArrayConstant();
  ASSERT_NE(shape_array, nullptr);
  ASSERT_EQ(shape_array->GetComponents().size(), 2u);
  EXPECT_EQ(shape_array->GetComponents()[0]->GetZeroExtendedValue(), 2u);
  EXPECT_EQ(shape_array->GetComponents()[1]->GetZeroExtendedValue(), 2u);

  const Constant* row_constant =
      context->get_constant_mgr()->FindDeclaredConstant(11);
  ASSERT_NE(row_constant, nullptr);
  const auto* row_tensor = row_constant->AsTensorConstant();
  ASSERT_NE(row_tensor, nullptr);
  ASSERT_EQ(row_tensor->GetComponents().size(), 2u);
  EXPECT_EQ(row_tensor->GetComponents()[0]->GetZeroExtendedValue(), 7u);
  EXPECT_EQ(row_tensor->GetComponents()[1]->GetZeroExtendedValue(), 7u);

  const Constant* constant =
      context->get_constant_mgr()->FindDeclaredConstant(12);
  ASSERT_NE(constant, nullptr);
  const auto* tensor_const = constant->AsTensorConstant();
  ASSERT_NE(tensor_const, nullptr);
  ASSERT_EQ(tensor_const->GetComponents().size(), 2u);
  EXPECT_EQ(tensor_const->GetComponents()[0], row_constant);
  EXPECT_EQ(tensor_const->GetComponents()[1], row_constant);
  EXPECT_FALSE(tensor_const->IsZero());
}

INSTANTIATE_TEST_SUITE_P(
    ConstantAndSpecConstant, TensorConstantCompositeReplicateExtTest,
    ::testing::ValuesIn(std::vector<TensorConstantCompositeReplicateExtCase>{
        {"OpConstantCompositeReplicateEXT", "Constant"},
        {"OpSpecConstantCompositeReplicateEXT", "SpecConstant"},
    }),
    TensorConstantCompositeReplicateExtCaseName);

TEST_F(ConstantManagerTest, NestedTensorConstantFromInstruction) {
  const std::string text = R"(
OpCapability TensorsARM
OpExtension "SPV_ARM_tensors"
%1 = OpTypeInt 32 0
%2 = OpConstant %1 1
%3 = OpConstant %1 2
%4 = OpConstant %1 3
%5 = OpConstant %1 4
%6 = OpConstant %1 5
%7 = OpConstant %1 6
%8 = OpTypeArray %1 %2
%9 = OpTypeArray %1 %3
%10 = OpConstantComposite %8 %4
%11 = OpConstantComposite %9 %3 %4
%12 = OpTypeTensorARM %1 %2 %10
%13 = OpTypeTensorARM %1 %3 %11
%14 = OpConstantComposite %12 %2 %3 %4
%15 = OpConstantComposite %12 %5 %6 %7
%16 = OpConstantComposite %13 %14 %15
  )";

  std::unique_ptr<IRContext> context =
      BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text,
                  SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS);
  ASSERT_NE(context, nullptr);

  const Constant* constant =
      context->get_constant_mgr()->FindDeclaredConstant(16);
  ASSERT_NE(constant, nullptr);
  const auto* tensor_const = constant->AsTensorConstant();
  ASSERT_NE(tensor_const, nullptr);
  ASSERT_EQ(tensor_const->GetComponents().size(), 2);

  const auto* row_0 = tensor_const->GetComponents()[0]->AsTensorConstant();
  const auto* row_1 = tensor_const->GetComponents()[1]->AsTensorConstant();
  ASSERT_NE(row_0, nullptr);
  ASSERT_NE(row_1, nullptr);
  ASSERT_EQ(row_0->GetComponents().size(), 3);
  ASSERT_EQ(row_1->GetComponents().size(), 3);
  EXPECT_EQ(row_0->GetComponents()[0]->GetZeroExtendedValue(), 1u);
  EXPECT_EQ(row_0->GetComponents()[1]->GetZeroExtendedValue(), 2u);
  EXPECT_EQ(row_0->GetComponents()[2]->GetZeroExtendedValue(), 3u);
  EXPECT_EQ(row_1->GetComponents()[0]->GetZeroExtendedValue(), 4u);
  EXPECT_EQ(row_1->GetComponents()[1]->GetZeroExtendedValue(), 5u);
  EXPECT_EQ(row_1->GetComponents()[2]->GetZeroExtendedValue(), 6u);
  EXPECT_FALSE(tensor_const->IsZero());
}

TEST_F(ConstantManagerTest, GetDefiningInstructionForNestedTensorConstant) {
  const std::string text = R"(
OpCapability TensorsARM
OpExtension "SPV_ARM_tensors"
%1 = OpTypeInt 32 0
%2 = OpConstant %1 1
%3 = OpConstant %1 2
%4 = OpConstant %1 3
%5 = OpConstant %1 4
%6 = OpConstant %1 5
%7 = OpConstant %1 6
%8 = OpTypeArray %1 %2
%9 = OpTypeArray %1 %3
%10 = OpConstantComposite %8 %4
%11 = OpConstantComposite %9 %3 %4
%12 = OpTypeTensorARM %1 %2 %10
%13 = OpTypeTensorARM %1 %3 %11
  )";

  std::unique_ptr<IRContext> context =
      BuildModule(SPV_ENV_UNIVERSAL_1_2, nullptr, text,
                  SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS);
  ASSERT_NE(context, nullptr);

  ConstantManager* const_mgr = context->get_constant_mgr();
  Type* tensor_r1_type = context->get_type_mgr()->GetType(12);
  Type* tensor_r2_type = context->get_type_mgr()->GetType(13);
  ASSERT_NE(tensor_r1_type, nullptr);
  ASSERT_NE(tensor_r2_type, nullptr);

  const Constant* row_0 = const_mgr->GetConstant(tensor_r1_type, {2, 3, 4});
  const Constant* row_1 = const_mgr->GetConstant(tensor_r1_type, {5, 6, 7});
  ASSERT_NE(row_0, nullptr);
  ASSERT_NE(row_1, nullptr);

  Instruction* row_0_inst = const_mgr->GetDefiningInstruction(row_0, 12);
  Instruction* row_1_inst = const_mgr->GetDefiningInstruction(row_1, 12);
  ASSERT_NE(row_0_inst, nullptr);
  ASSERT_NE(row_1_inst, nullptr);
  EXPECT_EQ(row_0_inst->opcode(), spv::Op::OpConstantComposite);
  EXPECT_EQ(row_0_inst->type_id(), 12u);
  EXPECT_EQ(row_0_inst->NumInOperands(), 3u);
  EXPECT_EQ(row_0_inst->GetSingleWordInOperand(0), 2u);
  EXPECT_EQ(row_0_inst->GetSingleWordInOperand(1), 3u);
  EXPECT_EQ(row_0_inst->GetSingleWordInOperand(2), 4u);

  const Constant* tensor_const = const_mgr->GetConstant(
      tensor_r2_type, {row_0_inst->result_id(), row_1_inst->result_id()});
  ASSERT_NE(tensor_const, nullptr);

  Instruction* tensor_inst =
      const_mgr->GetDefiningInstruction(tensor_const, 13);
  ASSERT_NE(tensor_inst, nullptr);
  EXPECT_EQ(tensor_inst->opcode(), spv::Op::OpConstantComposite);
  EXPECT_EQ(tensor_inst->type_id(), 13u);
  EXPECT_EQ(tensor_inst->NumInOperands(), 2u);
  EXPECT_EQ(tensor_inst->GetSingleWordInOperand(0), row_0_inst->result_id());
  EXPECT_EQ(tensor_inst->GetSingleWordInOperand(1), row_1_inst->result_id());
}

}  // namespace
}  // namespace analysis
}  // namespace opt
}  // namespace spvtools