mirror of
https://github.com/KhronosGroup/SPIRV-Tools
synced 2024-11-23 12:10:06 +00:00
279 lines
12 KiB
C++
279 lines
12 KiB
C++
// Copyright (c) 2015-2016 The Khronos Group Inc.
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining a
|
|
// copy of this software and/or associated documentation files (the
|
|
// "Materials"), to deal in the Materials without restriction, including
|
|
// without limitation the rights to use, copy, modify, merge, publish,
|
|
// distribute, sublicense, and/or sell copies of the Materials, and to
|
|
// permit persons to whom the Materials are furnished to do so, subject to
|
|
// the following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be included
|
|
// in all copies or substantial portions of the Materials.
|
|
//
|
|
// MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS
|
|
// KHRONOS STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS
|
|
// SPECIFICATIONS AND HEADER INFORMATION ARE LOCATED AT
|
|
// https://www.khronos.org/registry/
|
|
//
|
|
// THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
|
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
|
|
// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
|
|
// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
|
|
// MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
|
|
|
|
#include "UnitSPIRV.h"
|
|
|
|
#include "gmock/gmock.h"
|
|
#include "source/operand.h"
|
|
|
|
using ::testing::Eq;
|
|
|
|
namespace {
|
|
|
|
TEST(OperandPattern, InitiallyEmpty) {
|
|
spv_operand_pattern_t empty;
|
|
EXPECT_THAT(empty, Eq(spv_operand_pattern_t{}));
|
|
EXPECT_EQ(0u, empty.size());
|
|
EXPECT_TRUE(empty.empty());
|
|
}
|
|
|
|
TEST(OperandPattern, PushFrontsAreOnTheLeft) {
|
|
spv_operand_pattern_t pattern;
|
|
|
|
pattern.push_front(SPV_OPERAND_TYPE_ID);
|
|
EXPECT_THAT(pattern, Eq(spv_operand_pattern_t{SPV_OPERAND_TYPE_ID}));
|
|
EXPECT_EQ(1u, pattern.size());
|
|
EXPECT_TRUE(!pattern.empty());
|
|
EXPECT_EQ(SPV_OPERAND_TYPE_ID, pattern.front());
|
|
|
|
pattern.push_front(SPV_OPERAND_TYPE_NONE);
|
|
EXPECT_THAT(pattern, Eq(spv_operand_pattern_t{SPV_OPERAND_TYPE_NONE,
|
|
SPV_OPERAND_TYPE_ID}));
|
|
EXPECT_EQ(2u, pattern.size());
|
|
EXPECT_TRUE(!pattern.empty());
|
|
EXPECT_EQ(SPV_OPERAND_TYPE_NONE, pattern.front());
|
|
}
|
|
|
|
TEST(OperandPattern, PopFrontsAreOnTheLeft) {
|
|
spv_operand_pattern_t pattern{SPV_OPERAND_TYPE_LITERAL_INTEGER,
|
|
SPV_OPERAND_TYPE_ID};
|
|
|
|
pattern.pop_front();
|
|
EXPECT_THAT(pattern, Eq(spv_operand_pattern_t{SPV_OPERAND_TYPE_ID}));
|
|
|
|
pattern.pop_front();
|
|
EXPECT_THAT(pattern, Eq(spv_operand_pattern_t{}));
|
|
}
|
|
|
|
// A test case for typed mask expansion
|
|
struct MaskExpansionCase {
|
|
spv_operand_type_t type;
|
|
uint32_t mask;
|
|
spv_operand_pattern_t initial;
|
|
spv_operand_pattern_t expected;
|
|
};
|
|
|
|
using MaskExpansionTest = ::testing::TestWithParam<MaskExpansionCase>;
|
|
|
|
TEST_P(MaskExpansionTest, Sample) {
|
|
spv_operand_table operandTable = nullptr;
|
|
ASSERT_EQ(SPV_SUCCESS, spvOperandTableGet(&operandTable));
|
|
|
|
spv_operand_pattern_t pattern(GetParam().initial);
|
|
spvPrependOperandTypesForMask(operandTable, GetParam().type, GetParam().mask,
|
|
&pattern);
|
|
EXPECT_THAT(pattern, Eq(GetParam().expected));
|
|
}
|
|
|
|
// These macros let us write non-trivial examples without too much text.
|
|
#define SUFFIX0 SPV_OPERAND_TYPE_NONE, SPV_OPERAND_TYPE_ID
|
|
#define SUFFIX1 \
|
|
SPV_OPERAND_TYPE_ID, SPV_OPERAND_TYPE_SAMPLER_FILTER_MODE, \
|
|
SPV_OPERAND_TYPE_STORAGE_CLASS
|
|
INSTANTIATE_TEST_CASE_P(
|
|
OperandPattern, MaskExpansionTest,
|
|
::testing::ValuesIn(std::vector<MaskExpansionCase>{
|
|
// No bits means no change.
|
|
{SPV_OPERAND_TYPE_OPTIONAL_MEMORY_ACCESS, 0, {SUFFIX0}, {SUFFIX0}},
|
|
// Unknown bits means no change.
|
|
{SPV_OPERAND_TYPE_OPTIONAL_MEMORY_ACCESS,
|
|
0xfffffffc,
|
|
{SUFFIX1},
|
|
{SUFFIX1}},
|
|
// Volatile has no operands.
|
|
{SPV_OPERAND_TYPE_OPTIONAL_MEMORY_ACCESS,
|
|
SpvMemoryAccessVolatileMask,
|
|
{SUFFIX0},
|
|
{SUFFIX0}},
|
|
// Aligned has one literal number operand.
|
|
{SPV_OPERAND_TYPE_OPTIONAL_MEMORY_ACCESS,
|
|
SpvMemoryAccessAlignedMask,
|
|
{SUFFIX1},
|
|
{SPV_OPERAND_TYPE_LITERAL_INTEGER, SUFFIX1}},
|
|
// Volatile with Aligned still has just one literal number operand.
|
|
{SPV_OPERAND_TYPE_OPTIONAL_MEMORY_ACCESS,
|
|
SpvMemoryAccessVolatileMask | SpvMemoryAccessAlignedMask,
|
|
{SUFFIX1},
|
|
{SPV_OPERAND_TYPE_LITERAL_INTEGER, SUFFIX1}},
|
|
}));
|
|
#undef SUFFIX0
|
|
#undef SUFFIX1
|
|
|
|
// Returns a vector of all operand types that can be used in a pattern.
|
|
std::vector<spv_operand_type_t> allOperandTypes() {
|
|
std::vector<spv_operand_type_t> result;
|
|
for (int i = 0; i < SPV_OPERAND_TYPE_NUM_OPERAND_TYPES; i++) {
|
|
result.push_back(spv_operand_type_t(i));
|
|
}
|
|
return result;
|
|
}
|
|
|
|
using MatchableOperandExpansionTest =
|
|
::testing::TestWithParam<spv_operand_type_t>;
|
|
|
|
TEST_P(MatchableOperandExpansionTest, MatchableOperandsDontExpand) {
|
|
const spv_operand_type_t type = GetParam();
|
|
if (!spvOperandIsVariable(type)) {
|
|
spv_operand_pattern_t pattern;
|
|
const bool did_expand = spvExpandOperandSequenceOnce(type, &pattern);
|
|
EXPECT_FALSE(did_expand);
|
|
EXPECT_THAT(pattern, Eq(spv_operand_pattern_t{}));
|
|
}
|
|
}
|
|
|
|
INSTANTIATE_TEST_CASE_P(MatchableOperandExpansion,
|
|
MatchableOperandExpansionTest,
|
|
::testing::ValuesIn(allOperandTypes()));
|
|
|
|
using VariableOperandExpansionTest =
|
|
::testing::TestWithParam<spv_operand_type_t>;
|
|
|
|
TEST_P(VariableOperandExpansionTest, NonMatchableOperandsExpand) {
|
|
const spv_operand_type_t type = GetParam();
|
|
if (spvOperandIsVariable(type)) {
|
|
spv_operand_pattern_t pattern;
|
|
const bool did_expand = spvExpandOperandSequenceOnce(type, &pattern);
|
|
EXPECT_TRUE(did_expand);
|
|
EXPECT_FALSE(pattern.empty());
|
|
// For the existing rules, the first expansion of a zero-or-more operand
|
|
// type yields a matchable operand type. This isn't strictly necessary.
|
|
EXPECT_FALSE(spvOperandIsVariable(pattern.front()));
|
|
}
|
|
}
|
|
|
|
INSTANTIATE_TEST_CASE_P(NonMatchableOperandExpansion,
|
|
VariableOperandExpansionTest,
|
|
::testing::ValuesIn(allOperandTypes()));
|
|
|
|
TEST(AlternatePatternFollowingImmediate, Empty) {
|
|
EXPECT_THAT(spvAlternatePatternFollowingImmediate({}),
|
|
Eq(spv_operand_pattern_t{SPV_OPERAND_TYPE_OPTIONAL_CIV}));
|
|
}
|
|
|
|
TEST(AlternatePatternFollowingImmediate, SingleElement) {
|
|
// Spot-check a random selection of types.
|
|
EXPECT_THAT(spvAlternatePatternFollowingImmediate(
|
|
{SPV_OPERAND_TYPE_VARIABLE_ID_LITERAL_INTEGER}),
|
|
Eq(spv_operand_pattern_t{SPV_OPERAND_TYPE_OPTIONAL_CIV}));
|
|
EXPECT_THAT(
|
|
spvAlternatePatternFollowingImmediate({SPV_OPERAND_TYPE_CAPABILITY}),
|
|
Eq(spv_operand_pattern_t{SPV_OPERAND_TYPE_OPTIONAL_CIV}));
|
|
EXPECT_THAT(
|
|
spvAlternatePatternFollowingImmediate({SPV_OPERAND_TYPE_LOOP_CONTROL}),
|
|
Eq(spv_operand_pattern_t{SPV_OPERAND_TYPE_OPTIONAL_CIV}));
|
|
EXPECT_THAT(spvAlternatePatternFollowingImmediate(
|
|
{SPV_OPERAND_TYPE_OPTIONAL_LITERAL_INTEGER}),
|
|
Eq(spv_operand_pattern_t{SPV_OPERAND_TYPE_OPTIONAL_CIV}));
|
|
EXPECT_THAT(spvAlternatePatternFollowingImmediate({SPV_OPERAND_TYPE_ID}),
|
|
Eq(spv_operand_pattern_t{SPV_OPERAND_TYPE_OPTIONAL_CIV}));
|
|
EXPECT_THAT(spvAlternatePatternFollowingImmediate(
|
|
{SPV_OPERAND_TYPE_VARIABLE_EXECUTION_MODE}),
|
|
Eq(spv_operand_pattern_t{SPV_OPERAND_TYPE_OPTIONAL_CIV}));
|
|
}
|
|
|
|
TEST(AlternatePatternFollowingImmediate, SingleResultId) {
|
|
EXPECT_THAT(
|
|
spvAlternatePatternFollowingImmediate({SPV_OPERAND_TYPE_RESULT_ID}),
|
|
Eq(spv_operand_pattern_t{SPV_OPERAND_TYPE_RESULT_ID,
|
|
SPV_OPERAND_TYPE_OPTIONAL_CIV}));
|
|
}
|
|
|
|
TEST(AlternatePatternFollowingImmediate, MultipleNonResultIds) {
|
|
EXPECT_THAT(
|
|
spvAlternatePatternFollowingImmediate(
|
|
{SPV_OPERAND_TYPE_VARIABLE_ID_LITERAL_INTEGER,
|
|
SPV_OPERAND_TYPE_CAPABILITY, SPV_OPERAND_TYPE_LOOP_CONTROL,
|
|
SPV_OPERAND_TYPE_OPTIONAL_LITERAL_INTEGER, SPV_OPERAND_TYPE_ID,
|
|
SPV_OPERAND_TYPE_VARIABLE_EXECUTION_MODE}),
|
|
Eq(spv_operand_pattern_t{SPV_OPERAND_TYPE_OPTIONAL_CIV}));
|
|
}
|
|
|
|
TEST(AlternatePatternFollowingImmediate, ResultIdFront) {
|
|
EXPECT_THAT(spvAlternatePatternFollowingImmediate(
|
|
{SPV_OPERAND_TYPE_RESULT_ID, SPV_OPERAND_TYPE_ID}),
|
|
Eq(spv_operand_pattern_t{SPV_OPERAND_TYPE_RESULT_ID,
|
|
SPV_OPERAND_TYPE_OPTIONAL_CIV}));
|
|
EXPECT_THAT(spvAlternatePatternFollowingImmediate(
|
|
{SPV_OPERAND_TYPE_RESULT_ID,
|
|
SPV_OPERAND_TYPE_FP_ROUNDING_MODE, SPV_OPERAND_TYPE_ID}),
|
|
Eq(spv_operand_pattern_t{SPV_OPERAND_TYPE_RESULT_ID,
|
|
SPV_OPERAND_TYPE_OPTIONAL_CIV}));
|
|
EXPECT_THAT(spvAlternatePatternFollowingImmediate(
|
|
{SPV_OPERAND_TYPE_RESULT_ID, SPV_OPERAND_TYPE_DIMENSIONALITY,
|
|
SPV_OPERAND_TYPE_LINKAGE_TYPE,
|
|
SPV_OPERAND_TYPE_FUNCTION_PARAMETER_ATTRIBUTE,
|
|
SPV_OPERAND_TYPE_FP_ROUNDING_MODE, SPV_OPERAND_TYPE_ID,
|
|
SPV_OPERAND_TYPE_VARIABLE_ID}),
|
|
Eq(spv_operand_pattern_t{SPV_OPERAND_TYPE_RESULT_ID,
|
|
SPV_OPERAND_TYPE_OPTIONAL_CIV}));
|
|
}
|
|
|
|
TEST(AlternatePatternFollowingImmediate, ResultIdMiddle) {
|
|
EXPECT_THAT(spvAlternatePatternFollowingImmediate(
|
|
{SPV_OPERAND_TYPE_FP_ROUNDING_MODE,
|
|
SPV_OPERAND_TYPE_RESULT_ID, SPV_OPERAND_TYPE_ID}),
|
|
Eq(spv_operand_pattern_t{SPV_OPERAND_TYPE_OPTIONAL_CIV,
|
|
SPV_OPERAND_TYPE_RESULT_ID,
|
|
SPV_OPERAND_TYPE_OPTIONAL_CIV}));
|
|
EXPECT_THAT(
|
|
spvAlternatePatternFollowingImmediate(
|
|
{SPV_OPERAND_TYPE_DIMENSIONALITY, SPV_OPERAND_TYPE_LINKAGE_TYPE,
|
|
SPV_OPERAND_TYPE_FUNCTION_PARAMETER_ATTRIBUTE,
|
|
SPV_OPERAND_TYPE_RESULT_ID, SPV_OPERAND_TYPE_FP_ROUNDING_MODE,
|
|
SPV_OPERAND_TYPE_ID, SPV_OPERAND_TYPE_VARIABLE_ID}),
|
|
Eq(spv_operand_pattern_t{
|
|
SPV_OPERAND_TYPE_OPTIONAL_CIV, SPV_OPERAND_TYPE_OPTIONAL_CIV,
|
|
SPV_OPERAND_TYPE_OPTIONAL_CIV, SPV_OPERAND_TYPE_RESULT_ID,
|
|
SPV_OPERAND_TYPE_OPTIONAL_CIV}));
|
|
}
|
|
|
|
TEST(AlternatePatternFollowingImmediate, ResultIdBack) {
|
|
EXPECT_THAT(spvAlternatePatternFollowingImmediate(
|
|
{SPV_OPERAND_TYPE_ID, SPV_OPERAND_TYPE_RESULT_ID}),
|
|
Eq(spv_operand_pattern_t{SPV_OPERAND_TYPE_OPTIONAL_CIV,
|
|
SPV_OPERAND_TYPE_RESULT_ID,
|
|
SPV_OPERAND_TYPE_OPTIONAL_CIV}));
|
|
EXPECT_THAT(spvAlternatePatternFollowingImmediate(
|
|
{SPV_OPERAND_TYPE_FP_ROUNDING_MODE, SPV_OPERAND_TYPE_ID,
|
|
SPV_OPERAND_TYPE_RESULT_ID}),
|
|
Eq(spv_operand_pattern_t{
|
|
SPV_OPERAND_TYPE_OPTIONAL_CIV, SPV_OPERAND_TYPE_OPTIONAL_CIV,
|
|
SPV_OPERAND_TYPE_RESULT_ID, SPV_OPERAND_TYPE_OPTIONAL_CIV}));
|
|
EXPECT_THAT(
|
|
spvAlternatePatternFollowingImmediate(
|
|
{SPV_OPERAND_TYPE_DIMENSIONALITY, SPV_OPERAND_TYPE_LINKAGE_TYPE,
|
|
SPV_OPERAND_TYPE_FUNCTION_PARAMETER_ATTRIBUTE,
|
|
SPV_OPERAND_TYPE_FP_ROUNDING_MODE, SPV_OPERAND_TYPE_ID,
|
|
SPV_OPERAND_TYPE_VARIABLE_ID, SPV_OPERAND_TYPE_RESULT_ID}),
|
|
Eq(spv_operand_pattern_t{
|
|
SPV_OPERAND_TYPE_OPTIONAL_CIV, SPV_OPERAND_TYPE_OPTIONAL_CIV,
|
|
SPV_OPERAND_TYPE_OPTIONAL_CIV, SPV_OPERAND_TYPE_OPTIONAL_CIV,
|
|
SPV_OPERAND_TYPE_OPTIONAL_CIV, SPV_OPERAND_TYPE_OPTIONAL_CIV,
|
|
SPV_OPERAND_TYPE_RESULT_ID, SPV_OPERAND_TYPE_OPTIONAL_CIV}));
|
|
}
|
|
|
|
} // anonymous namespace
|