243 lines
9.7 KiB
C++
243 lines
9.7 KiB
C++
// Copyright (c) 2019 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 "source/opt/constants.h"
|
|
|
|
#include <gtest/gtest-param-test.h>
|
|
|
|
#include <memory>
|
|
|
|
#include "gtest/gtest.h"
|
|
#include "source/opt/types.h"
|
|
|
|
namespace spvtools {
|
|
namespace opt {
|
|
namespace analysis {
|
|
namespace {
|
|
|
|
using ::testing::ValuesIn;
|
|
using ConstantTest = ::testing::Test;
|
|
|
|
template <typename T>
|
|
struct GetExtendedValueCase {
|
|
bool is_signed;
|
|
int width;
|
|
std::vector<uint32_t> words;
|
|
T expected_value;
|
|
};
|
|
|
|
using GetSignExtendedValueCase = GetExtendedValueCase<int64_t>;
|
|
using GetZeroExtendedValueCase = GetExtendedValueCase<uint64_t>;
|
|
|
|
using GetSignExtendedValueTest =
|
|
::testing::TestWithParam<GetSignExtendedValueCase>;
|
|
using GetZeroExtendedValueTest =
|
|
::testing::TestWithParam<GetZeroExtendedValueCase>;
|
|
using TensorComponentsTest = ::testing::TestWithParam<std::vector<uint32_t>>;
|
|
|
|
TEST_P(GetSignExtendedValueTest, Case) {
|
|
Integer type(GetParam().width, GetParam().is_signed);
|
|
IntConstant value(&type, GetParam().words);
|
|
|
|
EXPECT_EQ(GetParam().expected_value, value.GetSignExtendedValue());
|
|
}
|
|
|
|
TEST_P(GetZeroExtendedValueTest, Case) {
|
|
Integer type(GetParam().width, GetParam().is_signed);
|
|
IntConstant value(&type, GetParam().words);
|
|
|
|
EXPECT_EQ(GetParam().expected_value, value.GetZeroExtendedValue());
|
|
}
|
|
|
|
const uint32_t k32ones = ~uint32_t(0);
|
|
const uint64_t k64ones = ~uint64_t(0);
|
|
const int64_t kSBillion = 1000 * 1000 * 1000;
|
|
const uint64_t kUBillion = 1000 * 1000 * 1000;
|
|
|
|
INSTANTIATE_TEST_SUITE_P(AtMost32Bits, GetSignExtendedValueTest,
|
|
ValuesIn(std::vector<GetSignExtendedValueCase>{
|
|
// 4 bits
|
|
{false, 4, {0}, 0},
|
|
{false, 4, {7}, 7},
|
|
{false, 4, {15}, 15},
|
|
{true, 4, {0}, 0},
|
|
{true, 4, {7}, 7},
|
|
{true, 4, {0xfffffff8}, -8},
|
|
{true, 4, {k32ones}, -1},
|
|
// 16 bits
|
|
{false, 16, {0}, 0},
|
|
{false, 16, {32767}, 32767},
|
|
{false, 16, {32768}, 32768},
|
|
{false, 16, {65000}, 65000},
|
|
{true, 16, {0}, 0},
|
|
{true, 16, {32767}, 32767},
|
|
{true, 16, {0xfffffff8}, -8},
|
|
{true, 16, {k32ones}, -1},
|
|
// 32 bits
|
|
{false, 32, {0}, 0},
|
|
{false, 32, {1000000}, 1000000},
|
|
{true, 32, {0xfffffff8}, -8},
|
|
{true, 32, {k32ones}, -1},
|
|
}));
|
|
|
|
INSTANTIATE_TEST_SUITE_P(AtMost64Bits, GetSignExtendedValueTest,
|
|
ValuesIn(std::vector<GetSignExtendedValueCase>{
|
|
// 48 bits
|
|
{false, 48, {0, 0}, 0},
|
|
{false, 48, {5, 0}, 5},
|
|
{false, 48, {0xfffffff8, k32ones}, -8},
|
|
{false, 48, {k32ones, k32ones}, -1},
|
|
{false, 48, {0xdcd65000, 1}, 8 * kSBillion},
|
|
{true, 48, {0xfffffff8, k32ones}, -8},
|
|
{true, 48, {k32ones, k32ones}, -1},
|
|
{true, 48, {0xdcd65000, 1}, 8 * kSBillion},
|
|
|
|
// 64 bits
|
|
{false, 64, {12, 0}, 12},
|
|
{false, 64, {0xdcd65000, 1}, 8 * kSBillion},
|
|
{false, 48, {0xfffffff8, k32ones}, -8},
|
|
{false, 64, {k32ones, k32ones}, -1},
|
|
{true, 64, {12, 0}, 12},
|
|
{true, 64, {0xdcd65000, 1}, 8 * kSBillion},
|
|
{true, 48, {0xfffffff8, k32ones}, -8},
|
|
{true, 64, {k32ones, k32ones}, -1},
|
|
}));
|
|
|
|
INSTANTIATE_TEST_SUITE_P(AtMost32Bits, GetZeroExtendedValueTest,
|
|
ValuesIn(std::vector<GetZeroExtendedValueCase>{
|
|
// 4 bits
|
|
{false, 4, {0}, 0},
|
|
{false, 4, {7}, 7},
|
|
{false, 4, {15}, 15},
|
|
{true, 4, {0}, 0},
|
|
{true, 4, {7}, 7},
|
|
{true, 4, {0xfffffff8}, 0xfffffff8},
|
|
{true, 4, {k32ones}, k32ones},
|
|
// 16 bits
|
|
{false, 16, {0}, 0},
|
|
{false, 16, {32767}, 32767},
|
|
{false, 16, {32768}, 32768},
|
|
{false, 16, {65000}, 65000},
|
|
{true, 16, {0}, 0},
|
|
{true, 16, {32767}, 32767},
|
|
{true, 16, {0xfffffff8}, 0xfffffff8},
|
|
{true, 16, {k32ones}, k32ones},
|
|
// 32 bits
|
|
{false, 32, {0}, 0},
|
|
{false, 32, {1000000}, 1000000},
|
|
{true, 32, {0xfffffff8}, 0xfffffff8},
|
|
{true, 32, {k32ones}, k32ones},
|
|
}));
|
|
|
|
INSTANTIATE_TEST_SUITE_P(AtMost64Bits, GetZeroExtendedValueTest,
|
|
ValuesIn(std::vector<GetZeroExtendedValueCase>{
|
|
// 48 bits
|
|
{false, 48, {0, 0}, 0},
|
|
{false, 48, {5, 0}, 5},
|
|
{false, 48, {0xfffffff8, k32ones}, uint64_t(-8)},
|
|
{false, 48, {k32ones, k32ones}, uint64_t(-1)},
|
|
{false, 48, {0xdcd65000, 1}, 8 * kUBillion},
|
|
{true, 48, {0xfffffff8, k32ones}, uint64_t(-8)},
|
|
{true, 48, {k32ones, k32ones}, uint64_t(-1)},
|
|
{true, 48, {0xdcd65000, 1}, 8 * kUBillion},
|
|
|
|
// 64 bits
|
|
{false, 64, {12, 0}, 12},
|
|
{false, 64, {0xdcd65000, 1}, 8 * kUBillion},
|
|
{false, 48, {0xfffffff8, k32ones}, uint64_t(-8)},
|
|
{false, 64, {k32ones, k32ones}, k64ones},
|
|
{true, 64, {12, 0}, 12},
|
|
{true, 64, {0xdcd65000, 1}, 8 * kUBillion},
|
|
{true, 48, {0xfffffff8, k32ones}, uint64_t(-8)},
|
|
{true, 64, {k32ones, k32ones}, k64ones},
|
|
}));
|
|
|
|
TEST_P(TensorComponentsTest, TensorSimple) {
|
|
Integer ty_uint(32, 0);
|
|
TensorARM ty_tensor(&ty_uint);
|
|
|
|
std::vector<std::unique_ptr<IntConstant>> storage;
|
|
storage.reserve(GetParam().size());
|
|
std::vector<const Constant*> components;
|
|
components.reserve(GetParam().size());
|
|
|
|
for (uint32_t value : GetParam()) {
|
|
storage.emplace_back(
|
|
std::make_unique<IntConstant>(&ty_uint, std::vector<uint32_t>{value}));
|
|
components.push_back(storage.back().get());
|
|
}
|
|
|
|
TensorConstant tensor_const(&ty_tensor, components);
|
|
ASSERT_EQ(tensor_const.GetComponents().size(), GetParam().size());
|
|
|
|
bool all_zero = true;
|
|
for (size_t i = 0; i < GetParam().size(); ++i) {
|
|
const auto* int_const = tensor_const.GetComponents()[i]->AsIntConstant();
|
|
ASSERT_NE(int_const, nullptr);
|
|
EXPECT_EQ(int_const->GetZeroExtendedValue(), GetParam()[i]);
|
|
if (GetParam()[i] != 0) {
|
|
all_zero = false;
|
|
}
|
|
}
|
|
EXPECT_EQ(tensor_const.IsZero(), all_zero);
|
|
}
|
|
|
|
INSTANTIATE_TEST_SUITE_P(TensorComponentValues, TensorComponentsTest,
|
|
ValuesIn(std::vector<std::vector<uint32_t>>{
|
|
{},
|
|
{0},
|
|
{1, 2, 3},
|
|
{0, 0, 0},
|
|
{0xffffffffu, 0x80000000u, 0x7fffffffu},
|
|
}));
|
|
|
|
TEST_F(ConstantTest, TensorNull) {
|
|
Integer ty_uint(32, 0);
|
|
TensorARM ty_tensor(&ty_uint);
|
|
NullConstant null_tensor(&ty_tensor);
|
|
|
|
EXPECT_EQ(null_tensor.type(), &ty_tensor);
|
|
EXPECT_TRUE(null_tensor.IsZero());
|
|
EXPECT_NE(null_tensor.AsNullConstant(), nullptr);
|
|
EXPECT_EQ(null_tensor.AsTensorConstant(), nullptr);
|
|
|
|
auto copy = null_tensor.Copy();
|
|
ASSERT_NE(copy, nullptr);
|
|
EXPECT_EQ(copy->type(), &ty_tensor);
|
|
EXPECT_TRUE(copy->IsZero());
|
|
EXPECT_NE(copy->AsNullConstant(), nullptr);
|
|
}
|
|
|
|
TEST_F(ConstantTest, TensorCopy) {
|
|
Integer ty_uint(32, 0);
|
|
TensorARM ty_tensor(&ty_uint);
|
|
IntConstant zero(&ty_uint, std::vector<uint32_t>{0});
|
|
IntConstant one(&ty_uint, std::vector<uint32_t>{1});
|
|
std::vector<const Constant*> components = {&zero, &one};
|
|
TensorConstant tensor_const(&ty_tensor, components);
|
|
|
|
auto copy = tensor_const.Copy();
|
|
ASSERT_NE(copy, nullptr);
|
|
const auto* tensor_copy = copy->AsTensorConstant();
|
|
ASSERT_NE(tensor_copy, nullptr);
|
|
EXPECT_EQ(tensor_copy->type(), &ty_tensor);
|
|
EXPECT_EQ(tensor_copy->GetComponents(), components);
|
|
EXPECT_FALSE(tensor_copy->IsZero());
|
|
}
|
|
|
|
} // namespace
|
|
} // namespace analysis
|
|
} // namespace opt
|
|
} // namespace spvtools
|