SPIRV-Tools/test/val/val_modes_test.cpp

802 lines
29 KiB
C++
Raw Normal View History

// Copyright (c) 2018 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 <sstream>
#include <string>
#include <vector>
#include "gmock/gmock.h"
#include "source/spirv_target_env.h"
#include "test/test_fixture.h"
#include "test/unit_spirv.h"
#include "test/val/val_fixtures.h"
namespace spvtools {
namespace val {
namespace {
using ::testing::Combine;
using ::testing::HasSubstr;
using ::testing::Values;
using ::testing::ValuesIn;
using ValidateMode = spvtest::ValidateBase<bool>;
const std::string kVoidFunction = R"(%void = OpTypeVoid
%void_fn = OpTypeFunction %void
%main = OpFunction %void None %void_fn
%entry = OpLabel
OpReturn
OpFunctionEnd
)";
TEST_F(ValidateMode, GLComputeNoMode) {
const std::string spirv = R"(
OpCapability Shader
OpMemoryModel Logical GLSL450
OpEntryPoint GLCompute %main "main"
)" + kVoidFunction;
CompileSuccessfully(spirv);
EXPECT_THAT(SPV_SUCCESS, ValidateInstructions());
}
TEST_F(ValidateMode, GLComputeNoModeVulkan) {
const std::string spirv = R"(
OpCapability Shader
OpMemoryModel Logical GLSL450
OpEntryPoint GLCompute %main "main"
)" + kVoidFunction;
spv_target_env env = SPV_ENV_VULKAN_1_0;
CompileSuccessfully(spirv, env);
EXPECT_THAT(SPV_ERROR_INVALID_DATA, ValidateInstructions(env));
EXPECT_THAT(
getDiagnosticString(),
HasSubstr("In the Vulkan environment, GLCompute execution model entry "
"points require either the LocalSize execution mode or an "
"object decorated with WorkgroupSize must be specified."));
}
TEST_F(ValidateMode, GLComputeNoModeVulkanWorkgroupSize) {
const std::string spirv = R"(
OpCapability Shader
OpMemoryModel Logical GLSL450
OpEntryPoint GLCompute %main "main"
OpDecorate %int3_1 BuiltIn WorkgroupSize
%int = OpTypeInt 32 0
%int3 = OpTypeVector %int 3
%int_1 = OpConstant %int 1
%int3_1 = OpConstantComposite %int3 %int_1 %int_1 %int_1
)" + kVoidFunction;
spv_target_env env = SPV_ENV_VULKAN_1_0;
CompileSuccessfully(spirv, env);
EXPECT_THAT(SPV_SUCCESS, ValidateInstructions(env));
}
TEST_F(ValidateMode, GLComputeVulkanLocalSize) {
const std::string spirv = R"(
OpCapability Shader
OpMemoryModel Logical GLSL450
OpEntryPoint GLCompute %main "main"
OpExecutionMode %main LocalSize 1 1 1
)" + kVoidFunction;
spv_target_env env = SPV_ENV_VULKAN_1_0;
CompileSuccessfully(spirv, env);
EXPECT_THAT(SPV_SUCCESS, ValidateInstructions(env));
}
TEST_F(ValidateMode, FragmentOriginLowerLeftVulkan) {
const std::string spirv = R"(
OpCapability Shader
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %main "main"
OpExecutionMode %main OriginLowerLeft
)" + kVoidFunction;
spv_target_env env = SPV_ENV_VULKAN_1_0;
CompileSuccessfully(spirv, env);
EXPECT_THAT(SPV_ERROR_INVALID_DATA, ValidateInstructions(env));
EXPECT_THAT(getDiagnosticString(),
HasSubstr("In the Vulkan environment, the OriginLowerLeft "
"execution mode must not be used."));
}
TEST_F(ValidateMode, FragmentPixelCenterIntegerVulkan) {
const std::string spirv = R"(
OpCapability Shader
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %main "main"
OpExecutionMode %main OriginUpperLeft
OpExecutionMode %main PixelCenterInteger
)" + kVoidFunction;
spv_target_env env = SPV_ENV_VULKAN_1_0;
CompileSuccessfully(spirv, env);
EXPECT_THAT(SPV_ERROR_INVALID_DATA, ValidateInstructions(env));
EXPECT_THAT(getDiagnosticString(),
HasSubstr("In the Vulkan environment, the PixelCenterInteger "
"execution mode must not be used."));
}
TEST_F(ValidateMode, GeometryNoOutputMode) {
const std::string spirv = R"(
OpCapability Geometry
OpMemoryModel Logical GLSL450
OpEntryPoint Geometry %main "main"
OpExecutionMode %main InputPoints
)" + kVoidFunction;
CompileSuccessfully(spirv);
EXPECT_THAT(SPV_ERROR_INVALID_DATA, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
HasSubstr("Geometry execution model entry points must specify "
"exactly one of OutputPoints, OutputLineStrip or "
"OutputTriangleStrip execution modes."));
}
TEST_F(ValidateMode, GeometryNoInputMode) {
const std::string spirv = R"(
OpCapability Geometry
OpMemoryModel Logical GLSL450
OpEntryPoint Geometry %main "main"
OpExecutionMode %main OutputPoints
)" + kVoidFunction;
CompileSuccessfully(spirv);
EXPECT_THAT(SPV_ERROR_INVALID_DATA, ValidateInstructions());
EXPECT_THAT(
getDiagnosticString(),
HasSubstr("Geometry execution model entry points must specify exactly "
"one of InputPoints, InputLines, InputLinesAdjacency, "
"Triangles or InputTrianglesAdjacency execution modes."));
}
TEST_F(ValidateMode, FragmentNoOrigin) {
const std::string spirv = R"(
OpCapability Shader
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %main "main"
)" + kVoidFunction;
CompileSuccessfully(spirv);
EXPECT_THAT(SPV_ERROR_INVALID_DATA, ValidateInstructions());
EXPECT_THAT(
getDiagnosticString(),
HasSubstr("Fragment execution model entry points require either an "
"OriginUpperLeft or OriginLowerLeft execution mode."));
}
TEST_F(ValidateMode, FragmentBothOrigins) {
const std::string spirv = R"(
OpCapability Shader
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %main "main"
OpExecutionMode %main OriginUpperLeft
OpExecutionMode %main OriginLowerLeft
)" + kVoidFunction;
CompileSuccessfully(spirv);
EXPECT_THAT(SPV_ERROR_INVALID_DATA, ValidateInstructions());
EXPECT_THAT(
getDiagnosticString(),
HasSubstr("Fragment execution model entry points can only specify one of "
"OriginUpperLeft or OriginLowerLeft execution modes."));
}
TEST_F(ValidateMode, FragmentDepthGreaterAndLess) {
const std::string spirv = R"(
OpCapability Shader
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %main "main"
OpExecutionMode %main OriginUpperLeft
OpExecutionMode %main DepthGreater
OpExecutionMode %main DepthLess
)" + kVoidFunction;
CompileSuccessfully(spirv);
EXPECT_THAT(SPV_ERROR_INVALID_DATA, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
HasSubstr("Fragment execution model entry points can specify at "
"most one of DepthGreater, DepthLess or DepthUnchanged "
"execution modes."));
}
TEST_F(ValidateMode, FragmentDepthGreaterAndUnchanged) {
const std::string spirv = R"(
OpCapability Shader
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %main "main"
OpExecutionMode %main OriginUpperLeft
OpExecutionMode %main DepthGreater
OpExecutionMode %main DepthUnchanged
)" + kVoidFunction;
CompileSuccessfully(spirv);
EXPECT_THAT(SPV_ERROR_INVALID_DATA, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
HasSubstr("Fragment execution model entry points can specify at "
"most one of DepthGreater, DepthLess or DepthUnchanged "
"execution modes."));
}
TEST_F(ValidateMode, FragmentDepthLessAndUnchanged) {
const std::string spirv = R"(
OpCapability Shader
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %main "main"
OpExecutionMode %main OriginUpperLeft
OpExecutionMode %main DepthLess
OpExecutionMode %main DepthUnchanged
)" + kVoidFunction;
CompileSuccessfully(spirv);
EXPECT_THAT(SPV_ERROR_INVALID_DATA, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
HasSubstr("Fragment execution model entry points can specify at "
"most one of DepthGreater, DepthLess or DepthUnchanged "
"execution modes."));
}
TEST_F(ValidateMode, FragmentAllDepths) {
const std::string spirv = R"(
OpCapability Shader
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %main "main"
OpExecutionMode %main OriginUpperLeft
OpExecutionMode %main DepthGreater
OpExecutionMode %main DepthLess
OpExecutionMode %main DepthUnchanged
)" + kVoidFunction;
CompileSuccessfully(spirv);
EXPECT_THAT(SPV_ERROR_INVALID_DATA, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
HasSubstr("Fragment execution model entry points can specify at "
"most one of DepthGreater, DepthLess or DepthUnchanged "
"execution modes."));
}
TEST_F(ValidateMode, TessellationControlSpacingEqualAndFractionalOdd) {
const std::string spirv = R"(
OpCapability Tessellation
OpMemoryModel Logical GLSL450
OpEntryPoint TessellationControl %main "main"
OpExecutionMode %main SpacingEqual
OpExecutionMode %main SpacingFractionalOdd
)" + kVoidFunction;
CompileSuccessfully(spirv);
EXPECT_THAT(SPV_ERROR_INVALID_DATA, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
HasSubstr("Tessellation execution model entry points can specify "
"at most one of SpacingEqual, SpacingFractionalOdd or "
"SpacingFractionalEven execution modes."));
}
TEST_F(ValidateMode, TessellationControlSpacingEqualAndSpacingFractionalEven) {
const std::string spirv = R"(
OpCapability Tessellation
OpMemoryModel Logical GLSL450
OpEntryPoint TessellationControl %main "main"
OpExecutionMode %main SpacingEqual
OpExecutionMode %main SpacingFractionalEven
)" + kVoidFunction;
CompileSuccessfully(spirv);
EXPECT_THAT(SPV_ERROR_INVALID_DATA, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
HasSubstr("Tessellation execution model entry points can specify "
"at most one of SpacingEqual, SpacingFractionalOdd or "
"SpacingFractionalEven execution modes."));
}
TEST_F(ValidateMode,
TessellationControlSpacingFractionalOddAndSpacingFractionalEven) {
const std::string spirv = R"(
OpCapability Tessellation
OpMemoryModel Logical GLSL450
OpEntryPoint TessellationControl %main "main"
OpExecutionMode %main SpacingFractionalOdd
OpExecutionMode %main SpacingFractionalEven
)" + kVoidFunction;
CompileSuccessfully(spirv);
EXPECT_THAT(SPV_ERROR_INVALID_DATA, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
HasSubstr("Tessellation execution model entry points can specify "
"at most one of SpacingEqual, SpacingFractionalOdd or "
"SpacingFractionalEven execution modes."));
}
TEST_F(ValidateMode, TessellationControlAllSpacing) {
const std::string spirv = R"(
OpCapability Tessellation
OpMemoryModel Logical GLSL450
OpEntryPoint TessellationControl %main "main"
OpExecutionMode %main SpacingEqual
OpExecutionMode %main SpacingFractionalOdd
OpExecutionMode %main SpacingFractionalEven
)" + kVoidFunction;
CompileSuccessfully(spirv);
EXPECT_THAT(SPV_ERROR_INVALID_DATA, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
HasSubstr("Tessellation execution model entry points can specify "
"at most one of SpacingEqual, SpacingFractionalOdd or "
"SpacingFractionalEven execution modes."));
}
TEST_F(ValidateMode,
TessellationEvaluationSpacingEqualAndSpacingFractionalOdd) {
const std::string spirv = R"(
OpCapability Tessellation
OpMemoryModel Logical GLSL450
OpEntryPoint TessellationEvaluation %main "main"
OpExecutionMode %main SpacingEqual
OpExecutionMode %main SpacingFractionalOdd
)" + kVoidFunction;
CompileSuccessfully(spirv);
EXPECT_THAT(SPV_ERROR_INVALID_DATA, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
HasSubstr("Tessellation execution model entry points can specify "
"at most one of SpacingEqual, SpacingFractionalOdd or "
"SpacingFractionalEven execution modes."));
}
TEST_F(ValidateMode,
TessellationEvaluationSpacingEqualAndSpacingFractionalEven) {
const std::string spirv = R"(
OpCapability Tessellation
OpMemoryModel Logical GLSL450
OpEntryPoint TessellationEvaluation %main "main"
OpExecutionMode %main SpacingEqual
OpExecutionMode %main SpacingFractionalEven
)" + kVoidFunction;
CompileSuccessfully(spirv);
EXPECT_THAT(SPV_ERROR_INVALID_DATA, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
HasSubstr("Tessellation execution model entry points can specify "
"at most one of SpacingEqual, SpacingFractionalOdd or "
"SpacingFractionalEven execution modes."));
}
TEST_F(ValidateMode,
TessellationEvaluationSpacingFractionalOddAndSpacingFractionalEven) {
const std::string spirv = R"(
OpCapability Tessellation
OpMemoryModel Logical GLSL450
OpEntryPoint TessellationEvaluation %main "main"
OpExecutionMode %main SpacingFractionalOdd
OpExecutionMode %main SpacingFractionalEven
)" + kVoidFunction;
CompileSuccessfully(spirv);
EXPECT_THAT(SPV_ERROR_INVALID_DATA, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
HasSubstr("Tessellation execution model entry points can specify "
"at most one of SpacingEqual, SpacingFractionalOdd or "
"SpacingFractionalEven execution modes."));
}
TEST_F(ValidateMode, TessellationEvaluationAllSpacing) {
const std::string spirv = R"(
OpCapability Tessellation
OpMemoryModel Logical GLSL450
OpEntryPoint TessellationEvaluation %main "main"
OpExecutionMode %main SpacingEqual
OpExecutionMode %main SpacingFractionalOdd
OpExecutionMode %main SpacingFractionalEven
)" + kVoidFunction;
CompileSuccessfully(spirv);
EXPECT_THAT(SPV_ERROR_INVALID_DATA, ValidateInstructions());
EXPECT_THAT(getDiagnosticString(),
HasSubstr("Tessellation execution model entry points can specify "
"at most one of SpacingEqual, SpacingFractionalOdd or "
"SpacingFractionalEven execution modes."));
}
TEST_F(ValidateMode, TessellationControlBothVertex) {
const std::string spirv = R"(
OpCapability Tessellation
OpMemoryModel Logical GLSL450
OpEntryPoint TessellationControl %main "main"
OpExecutionMode %main VertexOrderCw
OpExecutionMode %main VertexOrderCcw
)" + kVoidFunction;
CompileSuccessfully(spirv);
EXPECT_THAT(SPV_ERROR_INVALID_DATA, ValidateInstructions());
EXPECT_THAT(
getDiagnosticString(),
HasSubstr("Tessellation execution model entry points can specify at most "
"one of VertexOrderCw or VertexOrderCcw execution modes."));
}
TEST_F(ValidateMode, TessellationEvaluationBothVertex) {
const std::string spirv = R"(
OpCapability Tessellation
OpMemoryModel Logical GLSL450
OpEntryPoint TessellationEvaluation %main "main"
OpExecutionMode %main VertexOrderCw
OpExecutionMode %main VertexOrderCcw
)" + kVoidFunction;
CompileSuccessfully(spirv);
EXPECT_THAT(SPV_ERROR_INVALID_DATA, ValidateInstructions());
EXPECT_THAT(
getDiagnosticString(),
HasSubstr("Tessellation execution model entry points can specify at most "
"one of VertexOrderCw or VertexOrderCcw execution modes."));
}
using ValidateModeGeometry = spvtest::ValidateBase<std::tuple<
std::tuple<std::string, std::string, std::string, std::string, std::string>,
std::tuple<std::string, std::string, std::string>>>;
TEST_P(ValidateModeGeometry, ExecutionMode) {
std::vector<std::string> input_modes;
std::vector<std::string> output_modes;
input_modes.push_back(std::get<0>(std::get<0>(GetParam())));
input_modes.push_back(std::get<1>(std::get<0>(GetParam())));
input_modes.push_back(std::get<2>(std::get<0>(GetParam())));
input_modes.push_back(std::get<3>(std::get<0>(GetParam())));
input_modes.push_back(std::get<4>(std::get<0>(GetParam())));
output_modes.push_back(std::get<0>(std::get<1>(GetParam())));
output_modes.push_back(std::get<1>(std::get<1>(GetParam())));
output_modes.push_back(std::get<2>(std::get<1>(GetParam())));
std::ostringstream sstr;
sstr << "OpCapability Geometry\n";
sstr << "OpMemoryModel Logical GLSL450\n";
sstr << "OpEntryPoint Geometry %main \"main\"\n";
size_t num_input_modes = 0;
for (auto input : input_modes) {
if (!input.empty()) {
num_input_modes++;
sstr << "OpExecutionMode %main " << input << "\n";
}
}
size_t num_output_modes = 0;
for (auto output : output_modes) {
if (!output.empty()) {
num_output_modes++;
sstr << "OpExecutionMode %main " << output << "\n";
}
}
sstr << "%void = OpTypeVoid\n";
sstr << "%void_fn = OpTypeFunction %void\n";
sstr << "%int = OpTypeInt 32 0\n";
sstr << "%int1 = OpConstant %int 1\n";
sstr << "%main = OpFunction %void None %void_fn\n";
sstr << "%entry = OpLabel\n";
sstr << "OpReturn\n";
sstr << "OpFunctionEnd\n";
CompileSuccessfully(sstr.str());
if (num_input_modes == 1 && num_output_modes == 1) {
EXPECT_THAT(SPV_SUCCESS, ValidateInstructions());
} else {
EXPECT_THAT(SPV_ERROR_INVALID_DATA, ValidateInstructions());
if (num_input_modes != 1) {
EXPECT_THAT(getDiagnosticString(),
HasSubstr("Geometry execution model entry points must "
"specify exactly one of InputPoints, InputLines, "
"InputLinesAdjacency, Triangles or "
"InputTrianglesAdjacency execution modes."));
} else {
EXPECT_THAT(
getDiagnosticString(),
HasSubstr("Geometry execution model entry points must specify "
"exactly one of OutputPoints, OutputLineStrip or "
"OutputTriangleStrip execution modes."));
}
}
}
INSTANTIATE_TEST_CASE_P(
GeometryRequiredModes, ValidateModeGeometry,
Combine(Combine(Values("InputPoints", ""), Values("InputLines", ""),
Values("InputLinesAdjacency", ""), Values("Triangles", ""),
Values("InputTrianglesAdjacency", "")),
Combine(Values("OutputPoints", ""), Values("OutputLineStrip", ""),
Values("OutputTriangleStrip", ""))));
using ValidateModeExecution =
spvtest::ValidateBase<std::tuple<spv_result_t, std::string, std::string,
std::string, spv_target_env>>;
TEST_P(ValidateModeExecution, ExecutionMode) {
const spv_result_t expectation = std::get<0>(GetParam());
const std::string error = std::get<1>(GetParam());
const std::string model = std::get<2>(GetParam());
const std::string mode = std::get<3>(GetParam());
const spv_target_env env = std::get<4>(GetParam());
std::ostringstream sstr;
sstr << "OpCapability Shader\n";
sstr << "OpCapability Geometry\n";
sstr << "OpCapability Tessellation\n";
sstr << "OpCapability TransformFeedback\n";
if (!spvIsVulkanEnv(env)) {
sstr << "OpCapability Kernel\n";
if (env == SPV_ENV_UNIVERSAL_1_3) {
sstr << "OpCapability SubgroupDispatch\n";
}
}
sstr << "OpMemoryModel Logical GLSL450\n";
sstr << "OpEntryPoint " << model << " %main \"main\"\n";
if (mode.find("LocalSizeId") == 0 || mode.find("LocalSizeHintId") == 0 ||
mode.find("SubgroupsPerWorkgroupId") == 0) {
sstr << "OpExecutionModeId %main " << mode << "\n";
} else {
sstr << "OpExecutionMode %main " << mode << "\n";
}
if (model == "Geometry") {
if (!(mode.find("InputPoints") == 0 || mode.find("InputLines") == 0 ||
mode.find("InputLinesAdjacency") == 0 ||
mode.find("Triangles") == 0 ||
mode.find("InputTrianglesAdjacency") == 0)) {
// Exactly one of the above modes is required for Geometry shaders.
sstr << "OpExecutionMode %main InputPoints\n";
}
if (!(mode.find("OutputPoints") == 0 || mode.find("OutputLineStrip") == 0 ||
mode.find("OutputTriangleStrip") == 0)) {
// Exactly one of the above modes is required for Geometry shaders.
sstr << "OpExecutionMode %main OutputPoints\n";
}
} else if (model == "Fragment") {
if (!(mode.find("OriginUpperLeft") == 0 ||
mode.find("OriginLowerLeft") == 0)) {
// Exactly one of the above modes is required for Fragment shaders.
sstr << "OpExecutionMode %main OriginUpperLeft\n";
}
}
sstr << "%void = OpTypeVoid\n";
sstr << "%void_fn = OpTypeFunction %void\n";
sstr << "%int = OpTypeInt 32 0\n";
sstr << "%int1 = OpConstant %int 1\n";
sstr << "%main = OpFunction %void None %void_fn\n";
sstr << "%entry = OpLabel\n";
sstr << "OpReturn\n";
sstr << "OpFunctionEnd\n";
CompileSuccessfully(sstr.str(), env);
EXPECT_THAT(expectation, ValidateInstructions(env));
if (expectation != SPV_SUCCESS) {
EXPECT_THAT(getDiagnosticString(), HasSubstr(error));
}
}
INSTANTIATE_TEST_CASE_P(
ValidateModeGeometryOnlyGoodSpv10, ValidateModeExecution,
Combine(Values(SPV_SUCCESS), Values(""), Values("Geometry"),
Values("Invocations 3", "InputPoints", "InputLines",
"InputLinesAdjacency", "InputTrianglesAdjacency",
"OutputPoints", "OutputLineStrip", "OutputTriangleStrip"),
Values(SPV_ENV_UNIVERSAL_1_0)));
INSTANTIATE_TEST_CASE_P(
ValidateModeGeometryOnlyBadSpv10, ValidateModeExecution,
Combine(Values(SPV_ERROR_INVALID_DATA),
Values("Execution mode can only be used with the Geometry "
"execution model."),
Values("Fragment", "TessellationEvaluation", "TessellationControl",
"GLCompute", "Vertex", "Kernel"),
Values("Invocations 3", "InputPoints", "InputLines",
"InputLinesAdjacency", "InputTrianglesAdjacency",
"OutputPoints", "OutputLineStrip", "OutputTriangleStrip"),
Values(SPV_ENV_UNIVERSAL_1_0)));
INSTANTIATE_TEST_CASE_P(
ValidateModeTessellationOnlyGoodSpv10, ValidateModeExecution,
Combine(Values(SPV_SUCCESS), Values(""),
Values("TessellationControl", "TessellationEvaluation"),
Values("SpacingEqual", "SpacingFractionalEven",
"SpacingFractionalOdd", "VertexOrderCw", "VertexOrderCcw",
"PointMode", "Quads", "Isolines"),
Values(SPV_ENV_UNIVERSAL_1_0)));
INSTANTIATE_TEST_CASE_P(
ValidateModeTessellationOnlyBadSpv10, ValidateModeExecution,
Combine(Values(SPV_ERROR_INVALID_DATA),
Values("Execution mode can only be used with a tessellation "
"execution model."),
Values("Fragment", "Geometry", "GLCompute", "Vertex", "Kernel"),
Values("SpacingEqual", "SpacingFractionalEven",
"SpacingFractionalOdd", "VertexOrderCw", "VertexOrderCcw",
"PointMode", "Quads", "Isolines"),
Values(SPV_ENV_UNIVERSAL_1_0)));
INSTANTIATE_TEST_CASE_P(ValidateModeGeometryAndTessellationGoodSpv10,
ValidateModeExecution,
Combine(Values(SPV_SUCCESS), Values(""),
Values("TessellationControl",
"TessellationEvaluation", "Geometry"),
Values("Triangles", "OutputVertices 3"),
Values(SPV_ENV_UNIVERSAL_1_0)));
INSTANTIATE_TEST_CASE_P(
ValidateModeGeometryAndTessellationBadSpv10, ValidateModeExecution,
Combine(Values(SPV_ERROR_INVALID_DATA),
Values("Execution mode can only be used with a Geometry or "
"tessellation execution model."),
Values("Fragment", "GLCompute", "Vertex", "Kernel"),
Values("Triangles", "OutputVertices 3"),
Values(SPV_ENV_UNIVERSAL_1_0)));
INSTANTIATE_TEST_CASE_P(
ValidateModeFragmentOnlyGoodSpv10, ValidateModeExecution,
Combine(Values(SPV_SUCCESS), Values(""), Values("Fragment"),
Values("PixelCenterInteger", "OriginUpperLeft", "OriginLowerLeft",
"EarlyFragmentTests", "DepthReplacing", "DepthLess",
"DepthUnchanged"),
Values(SPV_ENV_UNIVERSAL_1_0)));
INSTANTIATE_TEST_CASE_P(
ValidateModeFragmentOnlyBadSpv10, ValidateModeExecution,
Combine(Values(SPV_ERROR_INVALID_DATA),
Values("Execution mode can only be used with the Fragment "
"execution model."),
Values("Geometry", "TessellationControl", "TessellationEvaluation",
"GLCompute", "Vertex", "Kernel"),
Values("PixelCenterInteger", "OriginUpperLeft", "OriginLowerLeft",
"EarlyFragmentTests", "DepthReplacing", "DepthLess",
"DepthUnchanged"),
Values(SPV_ENV_UNIVERSAL_1_0)));
INSTANTIATE_TEST_CASE_P(ValidateModeKernelOnlyGoodSpv13, ValidateModeExecution,
Combine(Values(SPV_SUCCESS), Values(""),
Values("Kernel"),
Values("LocalSizeHint 1 1 1", "VecTypeHint 4",
"ContractionOff",
"LocalSizeHintId %int1"),
Values(SPV_ENV_UNIVERSAL_1_3)));
INSTANTIATE_TEST_CASE_P(
ValidateModeKernelOnlyBadSpv13, ValidateModeExecution,
Combine(
Values(SPV_ERROR_INVALID_DATA),
Values(
"Execution mode can only be used with the Kernel execution model."),
Values("Geometry", "TessellationControl", "TessellationEvaluation",
"GLCompute", "Vertex", "Fragment"),
Values("LocalSizeHint 1 1 1", "VecTypeHint 4", "ContractionOff",
"LocalSizeHintId %int1"),
Values(SPV_ENV_UNIVERSAL_1_3)));
INSTANTIATE_TEST_CASE_P(
ValidateModeGLComputeAndKernelGoodSpv13, ValidateModeExecution,
Combine(Values(SPV_SUCCESS), Values(""), Values("Kernel", "GLCompute"),
Values("LocalSize 1 1 1", "LocalSizeId %int1 %int1 %int1"),
Values(SPV_ENV_UNIVERSAL_1_3)));
INSTANTIATE_TEST_CASE_P(
ValidateModeGLComputeAndKernelBadSpv13, ValidateModeExecution,
Combine(Values(SPV_ERROR_INVALID_DATA),
Values("Execution mode can only be used with a Kernel or GLCompute "
"execution model."),
Values("Geometry", "TessellationControl", "TessellationEvaluation",
"Fragment", "Vertex"),
Values("LocalSize 1 1 1", "LocalSizeId %int1 %int1 %int1"),
Values(SPV_ENV_UNIVERSAL_1_3)));
INSTANTIATE_TEST_CASE_P(
ValidateModeAllGoodSpv13, ValidateModeExecution,
Combine(Values(SPV_SUCCESS), Values(""),
Values("Kernel", "GLCompute", "Geometry", "TessellationControl",
"TessellationEvaluation", "Fragment", "Vertex"),
Values("Xfb", "Initializer", "Finalizer", "SubgroupSize 1",
"SubgroupsPerWorkgroup 1", "SubgroupsPerWorkgroupId %int1"),
Values(SPV_ENV_UNIVERSAL_1_3)));
TEST_F(ValidateModeExecution, MeshNVLocalSize) {
const std::string spirv = R"(
OpCapability Shader
OpCapability MeshShadingNV
OpExtension "SPV_NV_mesh_shader"
OpMemoryModel Logical GLSL450
OpEntryPoint MeshNV %main "main"
OpExecutionMode %main LocalSize 1 1 1
)" + kVoidFunction;
CompileSuccessfully(spirv);
EXPECT_THAT(SPV_SUCCESS, ValidateInstructions());
}
TEST_F(ValidateModeExecution, TaskNVLocalSize) {
const std::string spirv = R"(
OpCapability Shader
OpCapability MeshShadingNV
OpExtension "SPV_NV_mesh_shader"
OpMemoryModel Logical GLSL450
OpEntryPoint TaskNV %main "main"
OpExecutionMode %main LocalSize 1 1 1
)" + kVoidFunction;
CompileSuccessfully(spirv);
EXPECT_THAT(SPV_SUCCESS, ValidateInstructions());
}
TEST_F(ValidateModeExecution, MeshNVOutputPoints) {
const std::string spirv = R"(
OpCapability Shader
OpCapability MeshShadingNV
OpExtension "SPV_NV_mesh_shader"
OpMemoryModel Logical GLSL450
OpEntryPoint MeshNV %main "main"
OpExecutionMode %main OutputPoints
)" + kVoidFunction;
CompileSuccessfully(spirv);
EXPECT_THAT(SPV_SUCCESS, ValidateInstructions());
}
TEST_F(ValidateModeExecution, MeshNVOutputVertices) {
const std::string spirv = R"(
OpCapability Shader
OpCapability MeshShadingNV
OpExtension "SPV_NV_mesh_shader"
OpMemoryModel Logical GLSL450
OpEntryPoint MeshNV %main "main"
OpExecutionMode %main OutputVertices 42
)" + kVoidFunction;
CompileSuccessfully(spirv);
EXPECT_THAT(SPV_SUCCESS, ValidateInstructions());
}
TEST_F(ValidateModeExecution, MeshNVLocalSizeId) {
const std::string spirv = R"(
OpCapability Shader
OpCapability MeshShadingNV
OpExtension "SPV_NV_mesh_shader"
OpMemoryModel Logical GLSL450
OpEntryPoint MeshNV %main "main"
OpExecutionModeId %main LocalSizeId %int_1 %int_1 %int_1
%int = OpTypeInt 32 0
%int_1 = OpConstant %int 1
)" + kVoidFunction;
spv_target_env env = SPV_ENV_UNIVERSAL_1_3;
CompileSuccessfully(spirv, env);
EXPECT_THAT(SPV_SUCCESS, ValidateInstructions(env));
}
TEST_F(ValidateModeExecution, TaskNVLocalSizeId) {
const std::string spirv = R"(
OpCapability Shader
OpCapability MeshShadingNV
OpExtension "SPV_NV_mesh_shader"
OpMemoryModel Logical GLSL450
OpEntryPoint TaskNV %main "main"
OpExecutionModeId %main LocalSizeId %int_1 %int_1 %int_1
%int = OpTypeInt 32 0
%int_1 = OpConstant %int 1
)" + kVoidFunction;
spv_target_env env = SPV_ENV_UNIVERSAL_1_3;
CompileSuccessfully(spirv, env);
EXPECT_THAT(SPV_SUCCESS, ValidateInstructions(env));
}
} // namespace
} // namespace val
} // namespace spvtools