mirror of
https://github.com/KhronosGroup/SPIRV-Tools
synced 2024-11-22 11:40:05 +00:00
581279dedd
The folding rule `BitCastScalarOrVector` was incorrectly handling bitcasting to unsigned integers smaller than 32-bits. It was simply copying the entire 32-bit word containing the integer. This conflicts with the requirement in section 2.2.1 of the SPIR-V spec which states that unsigned numeric types with a bit width less than 32-bits must have the high-order bits set to 0. This change include a refactor of the bit extension code to be able to test it better, and to use it in multiple files. Fixes https://github.com/microsoft/DirectXShaderCompiler/issues/6319.
234 lines
7.7 KiB
C++
234 lines
7.7 KiB
C++
// Copyright (c) 2019 Google Inc.
|
|
//
|
|
// 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/util/bitutils.h"
|
|
|
|
#include "gmock/gmock.h"
|
|
|
|
namespace spvtools {
|
|
namespace utils {
|
|
namespace {
|
|
|
|
using BitUtilsTest = ::testing::Test;
|
|
|
|
TEST(BitUtilsTest, MutateBitsWholeWord) {
|
|
const uint32_t zero_u32 = 0;
|
|
const uint32_t max_u32 = ~0;
|
|
|
|
EXPECT_EQ(MutateBits(zero_u32, 0, 0, false), zero_u32);
|
|
EXPECT_EQ(MutateBits(max_u32, 0, 0, false), max_u32);
|
|
EXPECT_EQ(MutateBits(zero_u32, 0, 32, false), zero_u32);
|
|
EXPECT_EQ(MutateBits(zero_u32, 0, 32, true), max_u32);
|
|
EXPECT_EQ(MutateBits(max_u32, 0, 32, true), max_u32);
|
|
EXPECT_EQ(MutateBits(max_u32, 0, 32, false), zero_u32);
|
|
}
|
|
|
|
TEST(BitUtilsTest, MutateBitsLow) {
|
|
const uint32_t zero_u32 = 0;
|
|
const uint32_t one_u32 = 1;
|
|
const uint32_t max_u32 = ~0;
|
|
|
|
EXPECT_EQ(MutateBits(zero_u32, 0, 1, false), zero_u32);
|
|
EXPECT_EQ(MutateBits(zero_u32, 0, 1, true), one_u32);
|
|
EXPECT_EQ(MutateBits(max_u32, 0, 1, true), max_u32);
|
|
EXPECT_EQ(MutateBits(one_u32, 0, 32, false), zero_u32);
|
|
EXPECT_EQ(MutateBits(one_u32, 0, 1, true), one_u32);
|
|
EXPECT_EQ(MutateBits(one_u32, 0, 1, false), zero_u32);
|
|
EXPECT_EQ(MutateBits(zero_u32, 0, 3, true), uint32_t(7));
|
|
EXPECT_EQ(MutateBits(uint32_t(7), 0, 2, false), uint32_t(4));
|
|
}
|
|
|
|
TEST(BitUtilsTest, MutateBitsHigh) {
|
|
const uint8_t zero_u8 = 0;
|
|
const uint8_t one_u8 = 1;
|
|
const uint8_t max_u8 = 255;
|
|
|
|
EXPECT_EQ(MutateBits(zero_u8, 7, 0, true), zero_u8);
|
|
EXPECT_EQ(MutateBits(zero_u8, 7, 1, true), uint8_t(128));
|
|
EXPECT_EQ(MutateBits(one_u8, 7, 1, true), uint8_t(129));
|
|
EXPECT_EQ(MutateBits(max_u8, 7, 1, true), max_u8);
|
|
EXPECT_EQ(MutateBits(max_u8, 7, 1, false), uint8_t(127));
|
|
EXPECT_EQ(MutateBits(max_u8, 6, 2, true), max_u8);
|
|
EXPECT_EQ(MutateBits(max_u8, 6, 2, false), uint8_t(63));
|
|
}
|
|
|
|
TEST(BitUtilsTest, MutateBitsUint8Mid) {
|
|
const uint8_t zero_u8 = 0;
|
|
const uint8_t max_u8 = 255;
|
|
|
|
EXPECT_EQ(MutateBits(zero_u8, 1, 2, true), uint8_t(6));
|
|
EXPECT_EQ(MutateBits(max_u8, 1, 2, true), max_u8);
|
|
EXPECT_EQ(MutateBits(max_u8, 1, 2, false), uint8_t(0xF9));
|
|
EXPECT_EQ(MutateBits(zero_u8, 2, 3, true), uint8_t(0x1C));
|
|
}
|
|
|
|
TEST(BitUtilsTest, MutateBitsUint64Mid) {
|
|
const uint64_t zero_u64 = 0;
|
|
const uint64_t max_u64 = ~zero_u64;
|
|
|
|
EXPECT_EQ(MutateBits(zero_u64, 1, 2, true), uint64_t(6));
|
|
EXPECT_EQ(MutateBits(max_u64, 1, 2, true), max_u64);
|
|
EXPECT_EQ(MutateBits(max_u64, 1, 2, false), uint64_t(0xFFFFFFFFFFFFFFF9));
|
|
EXPECT_EQ(MutateBits(zero_u64, 2, 3, true), uint64_t(0x000000000000001C));
|
|
EXPECT_EQ(MutateBits(zero_u64, 2, 35, true), uint64_t(0x0000001FFFFFFFFC));
|
|
EXPECT_EQ(MutateBits(zero_u64, 36, 4, true), uint64_t(0x000000F000000000));
|
|
EXPECT_EQ(MutateBits(max_u64, 36, 4, false), uint64_t(0xFFFFFF0FFFFFFFFF));
|
|
}
|
|
|
|
TEST(BitUtilsTest, SetHighBitsUint32) {
|
|
const uint32_t zero_u32 = 0;
|
|
const uint32_t one_u32 = 1;
|
|
const uint32_t max_u32 = ~zero_u32;
|
|
|
|
EXPECT_EQ(SetHighBits(zero_u32, 0), zero_u32);
|
|
EXPECT_EQ(SetHighBits(zero_u32, 1), 0x80000000);
|
|
EXPECT_EQ(SetHighBits(one_u32, 1), 0x80000001);
|
|
EXPECT_EQ(SetHighBits(one_u32, 2), 0xC0000001);
|
|
EXPECT_EQ(SetHighBits(zero_u32, 31), 0xFFFFFFFE);
|
|
EXPECT_EQ(SetHighBits(zero_u32, 32), max_u32);
|
|
EXPECT_EQ(SetHighBits(max_u32, 32), max_u32);
|
|
}
|
|
|
|
TEST(BitUtilsTest, ClearHighBitsUint32) {
|
|
const uint32_t zero_u32 = 0;
|
|
const uint32_t one_u32 = 1;
|
|
const uint32_t max_u32 = ~zero_u32;
|
|
|
|
EXPECT_EQ(ClearHighBits(zero_u32, 0), zero_u32);
|
|
EXPECT_EQ(ClearHighBits(zero_u32, 1), zero_u32);
|
|
EXPECT_EQ(ClearHighBits(one_u32, 1), one_u32);
|
|
EXPECT_EQ(ClearHighBits(one_u32, 31), one_u32);
|
|
EXPECT_EQ(ClearHighBits(one_u32, 32), zero_u32);
|
|
EXPECT_EQ(ClearHighBits(max_u32, 0), max_u32);
|
|
EXPECT_EQ(ClearHighBits(max_u32, 1), 0x7FFFFFFF);
|
|
EXPECT_EQ(ClearHighBits(max_u32, 2), 0x3FFFFFFF);
|
|
EXPECT_EQ(ClearHighBits(max_u32, 31), one_u32);
|
|
EXPECT_EQ(ClearHighBits(max_u32, 32), zero_u32);
|
|
}
|
|
|
|
TEST(BitUtilsTest, IsBitSetAtPositionZero) {
|
|
const uint32_t zero_u32 = 0;
|
|
for (size_t i = 0; i != 32; ++i) {
|
|
EXPECT_FALSE(IsBitAtPositionSet(zero_u32, i));
|
|
}
|
|
|
|
const uint8_t zero_u8 = 0;
|
|
for (size_t i = 0; i != 8; ++i) {
|
|
EXPECT_FALSE(IsBitAtPositionSet(zero_u8, i));
|
|
}
|
|
|
|
const uint64_t zero_u64 = 0;
|
|
for (size_t i = 0; i != 64; ++i) {
|
|
EXPECT_FALSE(IsBitAtPositionSet(zero_u64, i));
|
|
}
|
|
}
|
|
|
|
TEST(BitUtilsTest, IsBitSetAtPositionOne) {
|
|
const uint32_t one_u32 = 1;
|
|
for (size_t i = 0; i != 32; ++i) {
|
|
if (i == 0) {
|
|
EXPECT_TRUE(IsBitAtPositionSet(one_u32, i));
|
|
} else {
|
|
EXPECT_FALSE(IsBitAtPositionSet(one_u32, i));
|
|
}
|
|
}
|
|
|
|
const uint32_t two_to_17_u32 = 1 << 17;
|
|
for (size_t i = 0; i != 32; ++i) {
|
|
if (i == 17) {
|
|
EXPECT_TRUE(IsBitAtPositionSet(two_to_17_u32, i));
|
|
} else {
|
|
EXPECT_FALSE(IsBitAtPositionSet(two_to_17_u32, i));
|
|
}
|
|
}
|
|
|
|
const uint8_t two_to_4_u8 = 1 << 4;
|
|
for (size_t i = 0; i != 8; ++i) {
|
|
if (i == 4) {
|
|
EXPECT_TRUE(IsBitAtPositionSet(two_to_4_u8, i));
|
|
} else {
|
|
EXPECT_FALSE(IsBitAtPositionSet(two_to_4_u8, i));
|
|
}
|
|
}
|
|
|
|
const uint64_t two_to_55_u64 = uint64_t(1) << 55;
|
|
for (size_t i = 0; i != 64; ++i) {
|
|
if (i == 55) {
|
|
EXPECT_TRUE(IsBitAtPositionSet(two_to_55_u64, i));
|
|
} else {
|
|
EXPECT_FALSE(IsBitAtPositionSet(two_to_55_u64, i));
|
|
}
|
|
}
|
|
}
|
|
|
|
TEST(BitUtilsTest, IsBitSetAtPositionAll) {
|
|
const uint32_t max_u32 = ~0;
|
|
for (size_t i = 0; i != 32; ++i) {
|
|
EXPECT_TRUE(IsBitAtPositionSet(max_u32, i));
|
|
}
|
|
|
|
const uint32_t max_u8 = ~uint8_t(0);
|
|
for (size_t i = 0; i != 8; ++i) {
|
|
EXPECT_TRUE(IsBitAtPositionSet(max_u8, i));
|
|
}
|
|
|
|
const uint64_t max_u64 = ~uint64_t(0);
|
|
for (size_t i = 0; i != 64; ++i) {
|
|
EXPECT_TRUE(IsBitAtPositionSet(max_u64, i));
|
|
}
|
|
}
|
|
|
|
struct ExtendedValueTestCase {
|
|
uint32_t input;
|
|
uint32_t bit_width;
|
|
uint32_t expected_result;
|
|
};
|
|
|
|
using SignExtendedValueTest = ::testing::TestWithParam<ExtendedValueTestCase>;
|
|
|
|
TEST_P(SignExtendedValueTest, SignExtendValue) {
|
|
const auto& tc = GetParam();
|
|
auto result = SignExtendValue(tc.input, tc.bit_width);
|
|
EXPECT_EQ(result, tc.expected_result);
|
|
}
|
|
INSTANTIATE_TEST_SUITE_P(
|
|
SignExtendValue, SignExtendedValueTest,
|
|
::testing::Values(ExtendedValueTestCase{1, 1, 0xFFFFFFFF},
|
|
ExtendedValueTestCase{1, 2, 0x1},
|
|
ExtendedValueTestCase{2, 1, 0x0},
|
|
ExtendedValueTestCase{0x8, 4, 0xFFFFFFF8},
|
|
ExtendedValueTestCase{0x8765, 16, 0xFFFF8765},
|
|
ExtendedValueTestCase{0x7765, 16, 0x7765},
|
|
ExtendedValueTestCase{0xDEADBEEF, 32, 0xDEADBEEF}));
|
|
|
|
using ZeroExtendedValueTest = ::testing::TestWithParam<ExtendedValueTestCase>;
|
|
|
|
TEST_P(ZeroExtendedValueTest, ZeroExtendValue) {
|
|
const auto& tc = GetParam();
|
|
auto result = ZeroExtendValue(tc.input, tc.bit_width);
|
|
EXPECT_EQ(result, tc.expected_result);
|
|
}
|
|
|
|
INSTANTIATE_TEST_SUITE_P(
|
|
ZeroExtendValue, ZeroExtendedValueTest,
|
|
::testing::Values(ExtendedValueTestCase{1, 1, 0x1},
|
|
ExtendedValueTestCase{1, 2, 0x1},
|
|
ExtendedValueTestCase{2, 1, 0x0},
|
|
ExtendedValueTestCase{0x8, 4, 0x8},
|
|
ExtendedValueTestCase{0xFF8765, 16, 0x8765},
|
|
ExtendedValueTestCase{0xDEADBEEF, 32, 0xDEADBEEF}));
|
|
} // namespace
|
|
} // namespace utils
|
|
} // namespace spvtools
|