mirror of
https://github.com/KhronosGroup/SPIRV-Tools
synced 2024-11-26 13:20:05 +00:00
5a48c0da15
* Ensure same enum values have consistent extension lists * val: fix checking of capabilities The operand for an OpCapability should only be checked for the extension or core version. The InstructionPass registers a capability, and all its implied sub-capabilities before actually checking the operand to an OpCapability. * Add basic support for SPIR-V 1.5 - Adds SPV_ENV_UNIVERSAL_1_5 - Command line tools default to spv1.5 environment - SPIR-V 1.5 incorporates several extensions. Now the disassembler prefers outputing the non-EXT or non-KHR names. This requires updates to many tests, to make strings match again. - Command line tests: Expect SPIR-V 1.5 by default * Test validation of SPIR-V 1.5 incorporated extensions Starting with 1.5, incorporated features no longer require the associated OpExtension instruction.
253 lines
8.7 KiB
C++
253 lines
8.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 <vector>
|
|
|
|
#include "test/opt/pass_fixture.h"
|
|
#include "test/opt/pass_utils.h"
|
|
|
|
namespace spvtools {
|
|
namespace opt {
|
|
namespace {
|
|
|
|
using DecomposeInitializedVariablesTest = PassTest<::testing::Test>;
|
|
|
|
std::string single_entry_header = R"(OpCapability Shader
|
|
OpCapability VulkanMemoryModel
|
|
OpExtension "SPV_KHR_vulkan_memory_model"
|
|
OpMemoryModel Logical Vulkan
|
|
OpEntryPoint Vertex %1 "shader"
|
|
%uint = OpTypeInt 32 0
|
|
%uint_1 = OpConstant %uint 1
|
|
%4 = OpConstantNull %uint
|
|
%void = OpTypeVoid
|
|
%6 = OpTypeFunction %void
|
|
)";
|
|
|
|
std::string GetFunctionTest(std::string body) {
|
|
auto result = single_entry_header;
|
|
result += "%_ptr_Function_uint = OpTypePointer Function %uint\n";
|
|
result += "%1 = OpFunction %void None %6\n";
|
|
result += "%8 = OpLabel\n";
|
|
result += body + "\n";
|
|
result += "OpReturn\n";
|
|
result += "OpFunctionEnd\n";
|
|
return result;
|
|
}
|
|
|
|
TEST_F(DecomposeInitializedVariablesTest, FunctionChanged) {
|
|
std::string input = "%9 = OpVariable %_ptr_Function_uint Function %uint_1";
|
|
std::string expected = R"(%9 = OpVariable %_ptr_Function_uint Function
|
|
OpStore %9 %uint_1)";
|
|
|
|
SinglePassRunAndCheck<DecomposeInitializedVariablesPass>(
|
|
GetFunctionTest(input), GetFunctionTest(expected),
|
|
/* skip_nop = */ false);
|
|
}
|
|
|
|
TEST_F(DecomposeInitializedVariablesTest, FunctionUnchanged) {
|
|
std::string input = "%9 = OpVariable %_ptr_Function_uint Function";
|
|
|
|
SinglePassRunAndCheck<DecomposeInitializedVariablesPass>(
|
|
GetFunctionTest(input), GetFunctionTest(input), /* skip_nop = */ false);
|
|
}
|
|
|
|
TEST_F(DecomposeInitializedVariablesTest, FunctionMultipleVariables) {
|
|
std::string input = R"(%9 = OpVariable %_ptr_Function_uint Function %uint_1
|
|
%10 = OpVariable %_ptr_Function_uint Function %4)";
|
|
std::string expected = R"(%9 = OpVariable %_ptr_Function_uint Function
|
|
%10 = OpVariable %_ptr_Function_uint Function
|
|
OpStore %9 %uint_1
|
|
OpStore %10 %4)";
|
|
|
|
SinglePassRunAndCheck<DecomposeInitializedVariablesPass>(
|
|
GetFunctionTest(input), GetFunctionTest(expected),
|
|
/* skip_nop = */ false);
|
|
}
|
|
|
|
std::string GetGlobalTest(std::string storage_class, bool initialized,
|
|
bool decomposed) {
|
|
auto result = single_entry_header;
|
|
|
|
result += "%_ptr_" + storage_class + "_uint = OpTypePointer " +
|
|
storage_class + " %uint\n";
|
|
if (initialized) {
|
|
result += "%8 = OpVariable %_ptr_" + storage_class + "_uint " +
|
|
storage_class + " %4\n";
|
|
} else {
|
|
result += "%8 = OpVariable %_ptr_" + storage_class + "_uint " +
|
|
storage_class + "\n";
|
|
}
|
|
result += R"(%1 = OpFunction %void None %9
|
|
%9 = OpLabel
|
|
)";
|
|
if (decomposed) result += "OpStore %8 %4\n";
|
|
result += R"(OpReturn
|
|
OpFunctionEnd
|
|
)";
|
|
return result;
|
|
}
|
|
|
|
TEST_F(DecomposeInitializedVariablesTest, PrivateChanged) {
|
|
std::string input = GetGlobalTest("Private", true, false);
|
|
std::string expected = GetGlobalTest("Private", false, true);
|
|
SinglePassRunAndCheck<DecomposeInitializedVariablesPass>(
|
|
input, expected, /* skip_nop = */ false);
|
|
}
|
|
|
|
TEST_F(DecomposeInitializedVariablesTest, PrivateUnchanged) {
|
|
std::string input = GetGlobalTest("Private", false, false);
|
|
SinglePassRunAndCheck<DecomposeInitializedVariablesPass>(
|
|
input, input, /* skip_nop = */ false);
|
|
}
|
|
|
|
TEST_F(DecomposeInitializedVariablesTest, OutputChanged) {
|
|
std::string input = GetGlobalTest("Output", true, false);
|
|
std::string expected = GetGlobalTest("Output", false, true);
|
|
SinglePassRunAndCheck<DecomposeInitializedVariablesPass>(
|
|
input, expected, /* skip_nop = */ false);
|
|
}
|
|
|
|
TEST_F(DecomposeInitializedVariablesTest, OutputUnchanged) {
|
|
std::string input = GetGlobalTest("Output", false, false);
|
|
SinglePassRunAndCheck<DecomposeInitializedVariablesPass>(
|
|
input, input, /* skip_nop = */ false);
|
|
}
|
|
|
|
std::string multiple_entry_header = R"(OpCapability Shader
|
|
OpCapability VulkanMemoryModel
|
|
OpExtension "SPV_KHR_vulkan_memory_model"
|
|
OpMemoryModel Logical Vulkan
|
|
OpEntryPoint Vertex %1 "vertex"
|
|
OpEntryPoint Fragment %2 "fragment"
|
|
%uint = OpTypeInt 32 0
|
|
%4 = OpConstantNull %uint
|
|
%void = OpTypeVoid
|
|
%6 = OpTypeFunction %void
|
|
)";
|
|
|
|
std::string GetGlobalMultipleEntryTest(std::string storage_class,
|
|
bool initialized, bool decomposed) {
|
|
auto result = multiple_entry_header;
|
|
result += "%_ptr_" + storage_class + "_uint = OpTypePointer " +
|
|
storage_class + " %uint\n";
|
|
if (initialized) {
|
|
result += "%8 = OpVariable %_ptr_" + storage_class + "_uint " +
|
|
storage_class + " %4\n";
|
|
} else {
|
|
result += "%8 = OpVariable %_ptr_" + storage_class + "_uint " +
|
|
storage_class + "\n";
|
|
}
|
|
result += R"(%1 = OpFunction %void None %9
|
|
%9 = OpLabel
|
|
)";
|
|
if (decomposed) result += "OpStore %8 %4\n";
|
|
result += R"(OpReturn
|
|
OpFunctionEnd
|
|
%2 = OpFunction %void None %10
|
|
%10 = OpLabel
|
|
)";
|
|
if (decomposed) result += "OpStore %8 %4\n";
|
|
result += R"(OpReturn
|
|
OpFunctionEnd
|
|
)";
|
|
|
|
return result;
|
|
}
|
|
|
|
TEST_F(DecomposeInitializedVariablesTest, PrivateMultipleEntryChanged) {
|
|
std::string input = GetGlobalMultipleEntryTest("Private", true, false);
|
|
std::string expected = GetGlobalMultipleEntryTest("Private", false, true);
|
|
SinglePassRunAndCheck<DecomposeInitializedVariablesPass>(
|
|
input, expected, /* skip_nop = */ false);
|
|
}
|
|
|
|
TEST_F(DecomposeInitializedVariablesTest, PrivateMultipleEntryUnchanged) {
|
|
std::string input = GetGlobalMultipleEntryTest("Private", false, false);
|
|
SinglePassRunAndCheck<DecomposeInitializedVariablesPass>(
|
|
input, input, /* skip_nop = */ false);
|
|
}
|
|
|
|
TEST_F(DecomposeInitializedVariablesTest, OutputMultipleEntryChanged) {
|
|
std::string input = GetGlobalMultipleEntryTest("Output", true, false);
|
|
std::string expected = GetGlobalMultipleEntryTest("Output", false, true);
|
|
SinglePassRunAndCheck<DecomposeInitializedVariablesPass>(
|
|
input, expected, /* skip_nop = */ false);
|
|
}
|
|
|
|
TEST_F(DecomposeInitializedVariablesTest, OutputMultipleEntryUnchanged) {
|
|
std::string input = GetGlobalMultipleEntryTest("Output", false, false);
|
|
SinglePassRunAndCheck<DecomposeInitializedVariablesPass>(
|
|
input, input, /* skip_nop = */ false);
|
|
}
|
|
|
|
std::string GetGlobalWithNonEntryPointTest(std::string storage_class,
|
|
bool initialized, bool decomposed) {
|
|
auto result = single_entry_header;
|
|
result += "%_ptr_" + storage_class + "_uint = OpTypePointer " +
|
|
storage_class + " %uint\n";
|
|
if (initialized) {
|
|
result += "%8 = OpVariable %_ptr_" + storage_class + "_uint " +
|
|
storage_class + " %4\n";
|
|
} else {
|
|
result += "%8 = OpVariable %_ptr_" + storage_class + "_uint " +
|
|
storage_class + "\n";
|
|
}
|
|
result += R"(%1 = OpFunction %void None %9
|
|
%9 = OpLabel
|
|
)";
|
|
if (decomposed) result += "OpStore %8 %4\n";
|
|
result += R"(OpReturn
|
|
OpFunctionEnd
|
|
%10 = OpFunction %void None %11
|
|
%11 = OpLabel
|
|
OpReturn
|
|
OpFunctionEnd
|
|
)";
|
|
|
|
return result;
|
|
}
|
|
|
|
TEST_F(DecomposeInitializedVariablesTest, PrivateWithNonEntryPointChanged) {
|
|
std::string input = GetGlobalWithNonEntryPointTest("Private", true, false);
|
|
std::string expected = GetGlobalWithNonEntryPointTest("Private", false, true);
|
|
SinglePassRunAndCheck<DecomposeInitializedVariablesPass>(
|
|
input, expected, /* skip_nop = */ false);
|
|
}
|
|
|
|
TEST_F(DecomposeInitializedVariablesTest, PrivateWithNonEntryPointUnchanged) {
|
|
std::string input = GetGlobalWithNonEntryPointTest("Private", false, false);
|
|
// SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS);
|
|
SinglePassRunAndCheck<DecomposeInitializedVariablesPass>(
|
|
input, input, /* skip_nop = */ false);
|
|
}
|
|
|
|
TEST_F(DecomposeInitializedVariablesTest, OutputWithNonEntryPointChanged) {
|
|
std::string input = GetGlobalWithNonEntryPointTest("Output", true, false);
|
|
std::string expected = GetGlobalWithNonEntryPointTest("Output", false, true);
|
|
SinglePassRunAndCheck<DecomposeInitializedVariablesPass>(
|
|
input, expected, /* skip_nop = */ false);
|
|
}
|
|
|
|
TEST_F(DecomposeInitializedVariablesTest, OutputWithNonEntryPointUnchanged) {
|
|
std::string input = GetGlobalWithNonEntryPointTest("Output", false, false);
|
|
// SetAssembleOptions(SPV_TEXT_TO_BINARY_OPTION_PRESERVE_NUMERIC_IDS);
|
|
SinglePassRunAndCheck<DecomposeInitializedVariablesPass>(
|
|
input, input, /* skip_nop = */ false);
|
|
}
|
|
|
|
} // namespace
|
|
} // namespace opt
|
|
} // namespace spvtools
|