| // 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 |