AuroraMiddleware/SPIRV-Tools
1
0
Fork 0
mirror of https://github.com/KhronosGroup/SPIRV-Tools synced 2024-11-23 12:10:06 +00:00
Code Issues Packages Projects Releases Wiki Activity
e065c482c6
SPIRV-Tools/test/val/val_builtins_test.cpp

4127 lines
180 KiB
C++
Raw Blame History

// Copyright (c) 2018 Google LLC.
// Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights
// reserved.
//
// 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.
// Tests validation rules of GLSL.450.std and OpenCL.std extended instructions.
// Doesn't test OpenCL.std vector size 2, 3, 4, 8 or 16 rules (not supported
// by standard SPIR-V).
#include <cstring>
#include <sstream>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
#include "gmock/gmock.h"
#include "source/spirv_target_env.h"
#include "test/unit_spirv.h"
#include "test/val/val_code_generator.h"
#include "test/val/val_fixtures.h"
namespace spvtools {
namespace val {
namespace {
struct TestResult {
TestResult(spv_result_t in_validation_result = SPV_SUCCESS,
const char* in_error_str = nullptr,
const char* in_error_str2 = nullptr)
: validation_result(in_validation_result),
error_str(in_error_str),
error_str2(in_error_str2) {}
spv_result_t validation_result;
const char* error_str;
const char* error_str2;
};
using ::testing::Combine;
using ::testing::HasSubstr;
using ::testing::Not;
using ::testing::Values;
using ::testing::ValuesIn;
using ValidateBuiltIns = spvtest::ValidateBase<bool>;
using ValidateVulkanSubgroupBuiltIns =
spvtest::ValidateBase<std::tuple<const char*, const char*, const char*,
const char*, const char*, TestResult>>;
using ValidateVulkanCombineBuiltInExecutionModelDataTypeResult =
spvtest::ValidateBase<std::tuple<const char*, const char*, const char*,
const char*, const char*, TestResult>>;
using ValidateVulkanCombineBuiltInArrayedVariable = spvtest::ValidateBase<
std::tuple<const char*, const char*, const char*, const char*, TestResult>>;
using ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult =
spvtest::ValidateBase<
std::tuple<const char*, const char*, const char*, const char*,
const char*, const char*, const char*, TestResult>>;
using ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult =
spvtest::ValidateBase<std::tuple<spv_target_env, const char*, const char*,
const char*, const char*, const char*,
const char*, const char*, TestResult>>;
bool InitializerRequired(const char* const storage_class) {
return (strncmp(storage_class, "Output", 6) == 0 ||
strncmp(storage_class, "Private", 7) == 0 ||
strncmp(storage_class, "Function", 8) == 0);
}
CodeGenerator GetInMainCodeGenerator(const char* const built_in,
const char* const execution_model,
const char* const storage_class,
const char* const capabilities,
const char* const extensions,
const char* const data_type) {
CodeGenerator generator = CodeGenerator::GetDefaultShaderCodeGenerator();
if (capabilities) {
generator.capabilities_ += capabilities;
}
if (extensions) {
generator.extensions_ += extensions;
}
generator.before_types_ = "OpMemberDecorate %built_in_type 0 BuiltIn ";
generator.before_types_ += built_in;
generator.before_types_ += "\n";
std::ostringstream after_types;
after_types << "%built_in_type = OpTypeStruct " << data_type << "\n";
if (InitializerRequired(storage_class)) {
after_types << "%built_in_null = OpConstantNull %built_in_type\n";
}
after_types << "%built_in_ptr = OpTypePointer " << storage_class
<< " %built_in_type\n";
after_types << "%built_in_var = OpVariable %built_in_ptr " << storage_class;
if (InitializerRequired(storage_class)) {
after_types << " %built_in_null";
}
after_types << "\n";
after_types << "%data_ptr = OpTypePointer " << storage_class << " "
<< data_type << "\n";
generator.after_types_ = after_types.str();
EntryPoint entry_point;
entry_point.name = "main";
entry_point.execution_model = execution_model;
if (strncmp(storage_class, "Input", 5) == 0 ||
strncmp(storage_class, "Output", 6) == 0) {
entry_point.interfaces = "%built_in_var";
}
std::ostringstream execution_modes;
if (0 == std::strcmp(execution_model, "Fragment")) {
execution_modes << "OpExecutionMode %" << entry_point.name
<< " OriginUpperLeft\n";
if (0 == std::strcmp(built_in, "FragDepth")) {
execution_modes << "OpExecutionMode %" << entry_point.name
<< " DepthReplacing\n";
}
}
if (0 == std::strcmp(execution_model, "Geometry")) {
execution_modes << "OpExecutionMode %" << entry_point.name
<< " InputPoints\n";
execution_modes << "OpExecutionMode %" << entry_point.name
<< " OutputPoints\n";
}
if (0 == std::strcmp(execution_model, "GLCompute")) {
execution_modes << "OpExecutionMode %" << entry_point.name
<< " LocalSize 1 1 1\n";
}
entry_point.execution_modes = execution_modes.str();
entry_point.body = R"(
%ptr = OpAccessChain %data_ptr %built_in_var %u32_0
)";
generator.entry_points_.push_back(std::move(entry_point));
return generator;
}
TEST_P(ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, InMain) {
const char* const built_in = std::get<0>(GetParam());
const char* const execution_model = std::get<1>(GetParam());
const char* const storage_class = std::get<2>(GetParam());
const char* const data_type = std::get<3>(GetParam());
const char* const vuid = std::get<4>(GetParam());
const TestResult& test_result = std::get<5>(GetParam());
CodeGenerator generator = GetInMainCodeGenerator(
built_in, execution_model, storage_class, NULL, NULL, data_type);
CompileSuccessfully(generator.Build(), SPV_ENV_VULKAN_1_0);
ASSERT_EQ(test_result.validation_result,
ValidateInstructions(SPV_ENV_VULKAN_1_0));
if (test_result.error_str) {
EXPECT_THAT(getDiagnosticString(), HasSubstr(test_result.error_str));
}
if (test_result.error_str2) {
EXPECT_THAT(getDiagnosticString(), HasSubstr(test_result.error_str2));
}
if (vuid) {
EXPECT_THAT(getDiagnosticString(), AnyVUID(vuid));
}
}
TEST_P(
ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
InMain) {
const char* const built_in = std::get<0>(GetParam());
const char* const execution_model = std::get<1>(GetParam());
const char* const storage_class = std::get<2>(GetParam());
const char* const data_type = std::get<3>(GetParam());
const char* const capabilities = std::get<4>(GetParam());
const char* const extensions = std::get<5>(GetParam());
const char* const vuid = std::get<6>(GetParam());
const TestResult& test_result = std::get<7>(GetParam());
CodeGenerator generator =
GetInMainCodeGenerator(built_in, execution_model, storage_class,
capabilities, extensions, data_type);
CompileSuccessfully(generator.Build(), SPV_ENV_VULKAN_1_0);
ASSERT_EQ(test_result.validation_result,
ValidateInstructions(SPV_ENV_VULKAN_1_0));
if (test_result.error_str) {
EXPECT_THAT(getDiagnosticString(), HasSubstr(test_result.error_str));
}
if (test_result.error_str2) {
EXPECT_THAT(getDiagnosticString(), HasSubstr(test_result.error_str2));
}
if (vuid) {
EXPECT_THAT(getDiagnosticString(), AnyVUID(vuid));
}
}
TEST_P(
ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
InMain) {
const spv_target_env env = std::get<0>(GetParam());
const char* const built_in = std::get<1>(GetParam());
const char* const execution_model = std::get<2>(GetParam());
const char* const storage_class = std::get<3>(GetParam());
const char* const data_type = std::get<4>(GetParam());
const char* const capabilities = std::get<5>(GetParam());
const char* const extensions = std::get<6>(GetParam());
const char* const vuid = std::get<7>(GetParam());
const TestResult& test_result = std::get<8>(GetParam());
CodeGenerator generator =
GetInMainCodeGenerator(built_in, execution_model, storage_class,
capabilities, extensions, data_type);
CompileSuccessfully(generator.Build(), env);
ASSERT_EQ(test_result.validation_result, ValidateInstructions(env));
if (test_result.error_str) {
EXPECT_THAT(getDiagnosticString(), HasSubstr(test_result.error_str));
}
if (test_result.error_str2) {
EXPECT_THAT(getDiagnosticString(), HasSubstr(test_result.error_str2));
}
if (vuid) {
EXPECT_THAT(getDiagnosticString(), AnyVUID(vuid));
}
}
CodeGenerator GetInFunctionCodeGenerator(const char* const built_in,
const char* const execution_model,
const char* const storage_class,
const char* const capabilities,
const char* const extensions,
const char* const data_type) {
CodeGenerator generator = CodeGenerator::GetDefaultShaderCodeGenerator();
if (capabilities) {
generator.capabilities_ += capabilities;
}
if (extensions) {
generator.extensions_ += extensions;
}
generator.before_types_ = "OpMemberDecorate %built_in_type 0 BuiltIn ";
generator.before_types_ += built_in;
generator.before_types_ += "\n";
std::ostringstream after_types;
after_types << "%built_in_type = OpTypeStruct " << data_type << "\n";
if (InitializerRequired(storage_class)) {
after_types << "%built_in_null = OpConstantNull %built_in_type\n";
}
after_types << "%built_in_ptr = OpTypePointer " << storage_class
<< " %built_in_type\n";
after_types << "%built_in_var = OpVariable %built_in_ptr " << storage_class;
if (InitializerRequired(storage_class)) {
after_types << " %built_in_null";
}
after_types << "\n";
after_types << "%data_ptr = OpTypePointer " << storage_class << " "
<< data_type << "\n";
generator.after_types_ = after_types.str();
EntryPoint entry_point;
entry_point.name = "main";
entry_point.execution_model = execution_model;
if (strncmp(storage_class, "Input", 5) == 0 ||
strncmp(storage_class, "Output", 6) == 0) {
entry_point.interfaces = "%built_in_var";
}
std::ostringstream execution_modes;
if (0 == std::strcmp(execution_model, "Fragment")) {
execution_modes << "OpExecutionMode %" << entry_point.name
<< " OriginUpperLeft\n";
if (0 == std::strcmp(built_in, "FragDepth")) {
execution_modes << "OpExecutionMode %" << entry_point.name
<< " DepthReplacing\n";
}
}
if (0 == std::strcmp(execution_model, "Geometry")) {
execution_modes << "OpExecutionMode %" << entry_point.name
<< " InputPoints\n";
execution_modes << "OpExecutionMode %" << entry_point.name
<< " OutputPoints\n";
}
if (0 == std::strcmp(execution_model, "GLCompute")) {
execution_modes << "OpExecutionMode %" << entry_point.name
<< " LocalSize 1 1 1\n";
}
entry_point.execution_modes = execution_modes.str();
entry_point.body = R"(
%val2 = OpFunctionCall %void %foo
)";
std::string function_body = R"(
%foo = OpFunction %void None %func
%foo_entry = OpLabel
%ptr = OpAccessChain %data_ptr %built_in_var %u32_0
OpReturn
OpFunctionEnd
)";
generator.add_at_the_end_ = function_body;
generator.entry_points_.push_back(std::move(entry_point));
return generator;
}
TEST_P(ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, InFunction) {
const char* const built_in = std::get<0>(GetParam());
const char* const execution_model = std::get<1>(GetParam());
const char* const storage_class = std::get<2>(GetParam());
const char* const data_type = std::get<3>(GetParam());
const char* const vuid = std::get<4>(GetParam());
const TestResult& test_result = std::get<5>(GetParam());
CodeGenerator generator = GetInFunctionCodeGenerator(
built_in, execution_model, storage_class, NULL, NULL, data_type);
CompileSuccessfully(generator.Build(), SPV_ENV_VULKAN_1_0);
ASSERT_EQ(test_result.validation_result,
ValidateInstructions(SPV_ENV_VULKAN_1_0));
if (test_result.error_str) {
EXPECT_THAT(getDiagnosticString(), HasSubstr(test_result.error_str));
}
if (test_result.error_str2) {
EXPECT_THAT(getDiagnosticString(), HasSubstr(test_result.error_str2));
}
if (vuid) {
EXPECT_THAT(getDiagnosticString(), AnyVUID(vuid));
}
}
TEST_P(
ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
InFunction) {
const char* const built_in = std::get<0>(GetParam());
const char* const execution_model = std::get<1>(GetParam());
const char* const storage_class = std::get<2>(GetParam());
const char* const data_type = std::get<3>(GetParam());
const char* const capabilities = std::get<4>(GetParam());
const char* const extensions = std::get<5>(GetParam());
const char* const vuid = std::get<6>(GetParam());
const TestResult& test_result = std::get<7>(GetParam());
CodeGenerator generator =
GetInFunctionCodeGenerator(built_in, execution_model, storage_class,
capabilities, extensions, data_type);
CompileSuccessfully(generator.Build(), SPV_ENV_VULKAN_1_0);
ASSERT_EQ(test_result.validation_result,
ValidateInstructions(SPV_ENV_VULKAN_1_0));
if (test_result.error_str) {
EXPECT_THAT(getDiagnosticString(), HasSubstr(test_result.error_str));
}
if (test_result.error_str2) {
EXPECT_THAT(getDiagnosticString(), HasSubstr(test_result.error_str2));
}
if (vuid) {
EXPECT_THAT(getDiagnosticString(), AnyVUID(vuid));
}
}
CodeGenerator GetVariableCodeGenerator(const char* const built_in,
const char* const execution_model,
const char* const storage_class,
const char* const capabilities,
const char* const extensions,
const char* const data_type) {
CodeGenerator generator = CodeGenerator::GetDefaultShaderCodeGenerator();
if (capabilities) {
generator.capabilities_ += capabilities;
}
if (extensions) {
generator.extensions_ += extensions;
}
generator.before_types_ = "OpDecorate %built_in_var BuiltIn ";
generator.before_types_ += built_in;
generator.before_types_ += "\n";
std::ostringstream after_types;
if (InitializerRequired(storage_class)) {
after_types << "%built_in_null = OpConstantNull " << data_type << "\n";
}
after_types << "%built_in_ptr = OpTypePointer " << storage_class << " "
<< data_type << "\n";
after_types << "%built_in_var = OpVariable %built_in_ptr " << storage_class;
if (InitializerRequired(storage_class)) {
after_types << " %built_in_null";
}
after_types << "\n";
generator.after_types_ = after_types.str();
EntryPoint entry_point;
entry_point.name = "main";
entry_point.execution_model = execution_model;
if (strncmp(storage_class, "Input", 5) == 0 ||
strncmp(storage_class, "Output", 6) == 0) {
entry_point.interfaces = "%built_in_var";
}
// Any kind of reference would do.
entry_point.body = R"(
%val = OpBitcast %u32 %built_in_var
)";
std::ostringstream execution_modes;
if (0 == std::strcmp(execution_model, "Fragment")) {
execution_modes << "OpExecutionMode %" << entry_point.name
<< " OriginUpperLeft\n";
if (0 == std::strcmp(built_in, "FragDepth")) {
execution_modes << "OpExecutionMode %" << entry_point.name
<< " DepthReplacing\n";
}
}
if (0 == std::strcmp(execution_model, "Geometry")) {
execution_modes << "OpExecutionMode %" << entry_point.name
<< " InputPoints\n";
execution_modes << "OpExecutionMode %" << entry_point.name
<< " OutputPoints\n";
}
if (0 == std::strcmp(execution_model, "GLCompute")) {
execution_modes << "OpExecutionMode %" << entry_point.name
<< " LocalSize 1 1 1\n";
}
entry_point.execution_modes = execution_modes.str();
generator.entry_points_.push_back(std::move(entry_point));
return generator;
}
TEST_P(ValidateVulkanCombineBuiltInExecutionModelDataTypeResult, Variable) {
const char* const built_in = std::get<0>(GetParam());
const char* const execution_model = std::get<1>(GetParam());
const char* const storage_class = std::get<2>(GetParam());
const char* const data_type = std::get<3>(GetParam());
const char* const vuid = std::get<4>(GetParam());
const TestResult& test_result = std::get<5>(GetParam());
CodeGenerator generator = GetVariableCodeGenerator(
built_in, execution_model, storage_class, NULL, NULL, data_type);
CompileSuccessfully(generator.Build(), SPV_ENV_VULKAN_1_0);
ASSERT_EQ(test_result.validation_result,
ValidateInstructions(SPV_ENV_VULKAN_1_0));
if (test_result.error_str) {
EXPECT_THAT(getDiagnosticString(), HasSubstr(test_result.error_str));
}
if (test_result.error_str2) {
EXPECT_THAT(getDiagnosticString(), HasSubstr(test_result.error_str2));
}
if (vuid) {
EXPECT_THAT(getDiagnosticString(), AnyVUID(vuid));
}
}
TEST_P(
ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Variable) {
const char* const built_in = std::get<0>(GetParam());
const char* const execution_model = std::get<1>(GetParam());
const char* const storage_class = std::get<2>(GetParam());
const char* const data_type = std::get<3>(GetParam());
const char* const capabilities = std::get<4>(GetParam());
const char* const extensions = std::get<5>(GetParam());
const char* const vuid = std::get<6>(GetParam());
const TestResult& test_result = std::get<7>(GetParam());
CodeGenerator generator =
GetVariableCodeGenerator(built_in, execution_model, storage_class,
capabilities, extensions, data_type);
CompileSuccessfully(generator.Build(), SPV_ENV_VULKAN_1_0);
ASSERT_EQ(test_result.validation_result,
ValidateInstructions(SPV_ENV_VULKAN_1_0));
if (test_result.error_str) {
EXPECT_THAT(getDiagnosticString(), HasSubstr(test_result.error_str));
}
if (test_result.error_str2) {
EXPECT_THAT(getDiagnosticString(), HasSubstr(test_result.error_str2));
}
if (vuid) {
EXPECT_THAT(getDiagnosticString(), AnyVUID(vuid));
}
}
INSTANTIATE_TEST_SUITE_P(
ClipAndCullDistanceOutputSuccess,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("ClipDistance", "CullDistance"),
Values("Vertex", "Geometry", "TessellationControl",
"TessellationEvaluation"),
Values("Output"), Values("%f32arr2", "%f32arr4"), Values(nullptr),
Values(TestResult())));
INSTANTIATE_TEST_SUITE_P(
ClipAndCullDistanceInputSuccess,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("ClipDistance", "CullDistance"),
Values("Fragment", "Geometry", "TessellationControl",
"TessellationEvaluation"),
Values("Input"), Values("%f32arr2", "%f32arr4"), Values(nullptr),
Values(TestResult())));
INSTANTIATE_TEST_SUITE_P(
ClipAndCullDistanceInvalidStorageClass,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("ClipDistance", "CullDistance"),
Values("Vertex", "Geometry", "TessellationControl",
"TessellationEvaluation"),
Values("Private"), Values("%f32arr2", "%f32arr4"),
Values("VUID-ClipDistance-ClipDistance-04190 "
"VUID-CullDistance-CullDistance-04199"),
Values(TestResult(
SPV_ERROR_INVALID_DATA,
"to be only used for variables with Input or Output storage "
"class."))));
INSTANTIATE_TEST_SUITE_P(
ClipAndCullDistanceFragmentOutput,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("ClipDistance", "CullDistance"), Values("Fragment"),
Values("Output"), Values("%f32arr4"),
Values("VUID-ClipDistance-ClipDistance-04189 "
"VUID-CullDistance-CullDistance-04198"),
Values(TestResult(
SPV_ERROR_INVALID_DATA,
"Vulkan spec doesn't allow BuiltIn ClipDistance/CullDistance "
"to be used for variables with Output storage class if "
"execution model is Fragment.",
"which is called with execution model Fragment."))));
INSTANTIATE_TEST_SUITE_P(
VertexIdVertexInput,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(
Values("VertexId"), Values("Vertex"), Values("Input"), Values("%u32"),
Values(nullptr),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"Vulkan spec doesn't allow BuiltIn VertexId to be "
"used."))));
INSTANTIATE_TEST_SUITE_P(
ClipAndCullDistanceVertexInput,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("ClipDistance", "CullDistance"), Values("Vertex"),
Values("Input"), Values("%f32arr4"),
Values("VUID-ClipDistance-ClipDistance-04188 "
"VUID-CullDistance-CullDistance-04197"),
Values(TestResult(
SPV_ERROR_INVALID_DATA,
"Vulkan spec doesn't allow BuiltIn ClipDistance/CullDistance "
"to be used for variables with Input storage class if "
"execution model is Vertex.",
"which is called with execution model Vertex."))));
INSTANTIATE_TEST_SUITE_P(
ClipAndCullInvalidExecutionModel,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("ClipDistance", "CullDistance"), Values("GLCompute"),
Values("Input", "Output"), Values("%f32arr4"),
Values("VUID-ClipDistance-ClipDistance-04187 "
"VUID-CullDistance-CullDistance-04196"),
Values(TestResult(
SPV_ERROR_INVALID_DATA,
"to be used only with Fragment, Vertex, TessellationControl, "
"TessellationEvaluation or Geometry execution models"))));
INSTANTIATE_TEST_SUITE_P(
ClipAndCullDistanceNotArray,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("ClipDistance", "CullDistance"), Values("Fragment"),
Values("Input"), Values("%f32vec2", "%f32vec4", "%f32"),
Values("VUID-ClipDistance-ClipDistance-04191 "
"VUID-CullDistance-CullDistance-04200"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 32-bit float array",
"is not an array"))));
INSTANTIATE_TEST_SUITE_P(
ClipAndCullDistanceNotFloatArray,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("ClipDistance", "CullDistance"), Values("Fragment"),
Values("Input"), Values("%u32arr2", "%u64arr4"),
Values("VUID-ClipDistance-ClipDistance-04191 "
"VUID-CullDistance-CullDistance-04200"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 32-bit float array",
"components are not float scalar"))));
INSTANTIATE_TEST_SUITE_P(
ClipAndCullDistanceNotF32Array,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("ClipDistance", "CullDistance"), Values("Fragment"),
Values("Input"), Values("%f64arr2", "%f64arr4"),
Values("VUID-ClipDistance-ClipDistance-04191 "
"VUID-CullDistance-CullDistance-04200"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 32-bit float array",
"has components with bit width 64"))));
INSTANTIATE_TEST_SUITE_P(
FragCoordSuccess, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("FragCoord"), Values("Fragment"), Values("Input"),
Values("%f32vec4"), Values(nullptr), Values(TestResult())));
INSTANTIATE_TEST_SUITE_P(
FragCoordNotFragment,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(
Values("FragCoord"),
Values("Vertex", "GLCompute", "Geometry", "TessellationControl",
"TessellationEvaluation"),
Values("Input"), Values("%f32vec4"),
Values("VUID-FragCoord-FragCoord-04210"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"to be used only with Fragment execution model"))));
INSTANTIATE_TEST_SUITE_P(
FragCoordNotInput, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("FragCoord"), Values("Fragment"), Values("Output"),
Values("%f32vec4"), Values("VUID-FragCoord-FragCoord-04211"),
Values(TestResult(
SPV_ERROR_INVALID_DATA,
"to be only used for variables with Input storage class",
"uses storage class Output"))));
INSTANTIATE_TEST_SUITE_P(
FragCoordNotFloatVector,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("FragCoord"), Values("Fragment"), Values("Input"),
Values("%f32arr4", "%u32vec4"),
Values("VUID-FragCoord-FragCoord-04212"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 4-component 32-bit float vector",
"is not a float vector"))));
INSTANTIATE_TEST_SUITE_P(
FragCoordNotFloatVec4,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("FragCoord"), Values("Fragment"), Values("Input"),
Values("%f32vec3"), Values("VUID-FragCoord-FragCoord-04212"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 4-component 32-bit float vector",
"has 3 components"))));
INSTANTIATE_TEST_SUITE_P(
FragCoordNotF32Vec4,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("FragCoord"), Values("Fragment"), Values("Input"),
Values("%f64vec4"), Values("VUID-FragCoord-FragCoord-04212"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 4-component 32-bit float vector",
"has components with bit width 64"))));
INSTANTIATE_TEST_SUITE_P(
FragDepthSuccess, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("FragDepth"), Values("Fragment"), Values("Output"),
Values("%f32"), Values(nullptr), Values(TestResult())));
INSTANTIATE_TEST_SUITE_P(
FragDepthNotFragment,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(
Values("FragDepth"),
Values("Vertex", "GLCompute", "Geometry", "TessellationControl",
"TessellationEvaluation"),
Values("Output"), Values("%f32"),
Values("VUID-FragDepth-FragDepth-04213"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"to be used only with Fragment execution model"))));
INSTANTIATE_TEST_SUITE_P(
FragDepthNotOutput,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("FragDepth"), Values("Fragment"), Values("Input"),
Values("%f32"), Values("VUID-FragDepth-FragDepth-04214"),
Values(TestResult(
SPV_ERROR_INVALID_DATA,
"to be only used for variables with Output storage class",
"uses storage class Input"))));
INSTANTIATE_TEST_SUITE_P(
FragDepthNotFloatScalar,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("FragDepth"), Values("Fragment"), Values("Output"),
Values("%f32vec4", "%u32"),
Values("VUID-FragDepth-FragDepth-04215"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 32-bit float scalar",
"is not a float scalar"))));
INSTANTIATE_TEST_SUITE_P(
FragDepthNotF32, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("FragDepth"), Values("Fragment"), Values("Output"),
Values("%f64"), Values("VUID-FragDepth-FragDepth-04215"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 32-bit float scalar",
"has bit width 64"))));
INSTANTIATE_TEST_SUITE_P(
FrontFacingAndHelperInvocationSuccess,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("FrontFacing", "HelperInvocation"), Values("Fragment"),
Values("Input"), Values("%bool"), Values(nullptr),
Values(TestResult())));
INSTANTIATE_TEST_SUITE_P(
FrontFacingAndHelperInvocationNotFragment,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(
Values("FrontFacing", "HelperInvocation"),
Values("Vertex", "GLCompute", "Geometry", "TessellationControl",
"TessellationEvaluation"),
Values("Input"), Values("%bool"),
Values("VUID-FrontFacing-FrontFacing-04229 "
"VUID-HelperInvocation-HelperInvocation-04239"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"to be used only with Fragment execution model"))));
INSTANTIATE_TEST_SUITE_P(
FrontFacingAndHelperInvocationNotInput,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("FrontFacing", "HelperInvocation"), Values("Fragment"),
Values("Output"), Values("%bool"),
Values("VUID-FrontFacing-FrontFacing-04230 "
"VUID-HelperInvocation-HelperInvocation-04240"),
Values(TestResult(
SPV_ERROR_INVALID_DATA,
"to be only used for variables with Input storage class",
"uses storage class Output"))));
INSTANTIATE_TEST_SUITE_P(
FrontFacingAndHelperInvocationNotBool,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("FrontFacing", "HelperInvocation"), Values("Fragment"),
Values("Input"), Values("%f32", "%u32"),
Values("VUID-FrontFacing-FrontFacing-04231 "
"VUID-HelperInvocation-HelperInvocation-04241"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a bool scalar",
"is not a bool scalar"))));
INSTANTIATE_TEST_SUITE_P(
ComputeShaderInputInt32Vec3Success,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("GlobalInvocationId", "LocalInvocationId", "NumWorkgroups",
"WorkgroupId"),
Values("GLCompute"), Values("Input"), Values("%u32vec3"),
Values(nullptr), Values(TestResult())));
INSTANTIATE_TEST_SUITE_P(
ComputeShaderInputInt32Vec3NotGLCompute,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(
Values("GlobalInvocationId", "LocalInvocationId", "NumWorkgroups",
"WorkgroupId"),
Values("Vertex", "Fragment", "Geometry", "TessellationControl",
"TessellationEvaluation"),
Values("Input"), Values("%u32vec3"),
Values("VUID-GlobalInvocationId-GlobalInvocationId-04236 "
"VUID-LocalInvocationId-LocalInvocationId-04281 "
"VUID-NumWorkgroups-NumWorkgroups-04296 "
"VUID-WorkgroupId-WorkgroupId-04422"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"to be used only with GLCompute execution model"))));
INSTANTIATE_TEST_SUITE_P(
ComputeShaderInputInt32Vec3NotInput,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("GlobalInvocationId", "LocalInvocationId", "NumWorkgroups",
"WorkgroupId"),
Values("GLCompute"), Values("Output"), Values("%u32vec3"),
Values("VUID-GlobalInvocationId-GlobalInvocationId-04237 "
"VUID-LocalInvocationId-LocalInvocationId-04282 "
"VUID-NumWorkgroups-NumWorkgroups-04297 "
"VUID-WorkgroupId-WorkgroupId-04423"),
Values(TestResult(
SPV_ERROR_INVALID_DATA,
"to be only used for variables with Input storage class",
"uses storage class Output"))));
INSTANTIATE_TEST_SUITE_P(
ComputeShaderInputInt32Vec3NotIntVector,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("GlobalInvocationId", "LocalInvocationId", "NumWorkgroups",
"WorkgroupId"),
Values("GLCompute"), Values("Input"),
Values("%u32arr3", "%f32vec3"),
Values("VUID-GlobalInvocationId-GlobalInvocationId-04238 "
"VUID-LocalInvocationId-LocalInvocationId-04283 "
"VUID-NumWorkgroups-NumWorkgroups-04298 "
"VUID-WorkgroupId-WorkgroupId-04424"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 3-component 32-bit int vector",
"is not an int vector"))));
INSTANTIATE_TEST_SUITE_P(
ComputeShaderInputInt32Vec3NotIntVec3,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("GlobalInvocationId", "LocalInvocationId", "NumWorkgroups",
"WorkgroupId"),
Values("GLCompute"), Values("Input"), Values("%u32vec4"),
Values("VUID-GlobalInvocationId-GlobalInvocationId-04238 "
"VUID-LocalInvocationId-LocalInvocationId-04283 "
"VUID-NumWorkgroups-NumWorkgroups-04298 "
"VUID-WorkgroupId-WorkgroupId-04424"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 3-component 32-bit int vector",
"has 4 components"))));
INSTANTIATE_TEST_SUITE_P(
ComputeShaderInputInt32Vec3NotInt32Vec,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("GlobalInvocationId", "LocalInvocationId", "NumWorkgroups",
"WorkgroupId"),
Values("GLCompute"), Values("Input"), Values("%u64vec3"),
Values("VUID-GlobalInvocationId-GlobalInvocationId-04238 "
"VUID-LocalInvocationId-LocalInvocationId-04283 "
"VUID-NumWorkgroups-NumWorkgroups-04298 "
"VUID-WorkgroupId-WorkgroupId-04424"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 3-component 32-bit int vector",
"has components with bit width 64"))));
INSTANTIATE_TEST_SUITE_P(
InvocationIdSuccess,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("InvocationId"), Values("Geometry", "TessellationControl"),
Values("Input"), Values("%u32"), Values(nullptr),
Values(TestResult())));
INSTANTIATE_TEST_SUITE_P(
InvocationIdInvalidExecutionModel,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("InvocationId"),
Values("Vertex", "Fragment", "GLCompute", "TessellationEvaluation"),
Values("Input"), Values("%u32"),
Values("VUID-InvocationId-InvocationId-04257"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"to be used only with TessellationControl or "
"Geometry execution models"))));
INSTANTIATE_TEST_SUITE_P(
InvocationIdNotInput,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("InvocationId"), Values("Geometry", "TessellationControl"),
Values("Output"), Values("%u32"),
Values("VUID-InvocationId-InvocationId-04258"),
Values(TestResult(
SPV_ERROR_INVALID_DATA,
"to be only used for variables with Input storage class",
"uses storage class Output"))));
INSTANTIATE_TEST_SUITE_P(
InvocationIdNotIntScalar,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("InvocationId"), Values("Geometry", "TessellationControl"),
Values("Input"), Values("%f32", "%u32vec3"),
Values("VUID-InvocationId-InvocationId-04259"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 32-bit int scalar",
"is not an int scalar"))));
INSTANTIATE_TEST_SUITE_P(
InvocationIdNotInt32,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("InvocationId"), Values("Geometry", "TessellationControl"),
Values("Input"), Values("%u64"),
Values("VUID-InvocationId-InvocationId-04259"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 32-bit int scalar",
"has bit width 64"))));
INSTANTIATE_TEST_SUITE_P(
InstanceIndexSuccess,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("InstanceIndex"), Values("Vertex"), Values("Input"),
Values("%u32"), Values(nullptr), Values(TestResult())));
INSTANTIATE_TEST_SUITE_P(
InstanceIndexInvalidExecutionModel,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("InstanceIndex"),
Values("Geometry", "Fragment", "GLCompute", "TessellationControl",
"TessellationEvaluation"),
Values("Input"), Values("%u32"),
Values("VUID-InstanceIndex-InstanceIndex-04263"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"to be used only with Vertex execution model"))));
INSTANTIATE_TEST_SUITE_P(
InstanceIndexNotInput,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("InstanceIndex"), Values("Vertex"), Values("Output"),
Values("%u32"), Values("VUID-InstanceIndex-InstanceIndex-04264"),
Values(TestResult(
SPV_ERROR_INVALID_DATA,
"to be only used for variables with Input storage class",
"uses storage class Output"))));
INSTANTIATE_TEST_SUITE_P(
InstanceIndexNotIntScalar,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("InstanceIndex"), Values("Vertex"), Values("Input"),
Values("%f32", "%u32vec3"),
Values("VUID-InstanceIndex-InstanceIndex-04265"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 32-bit int scalar",
"is not an int scalar"))));
INSTANTIATE_TEST_SUITE_P(
InstanceIndexNotInt32,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("InstanceIndex"), Values("Vertex"), Values("Input"),
Values("%u64"), Values("VUID-InstanceIndex-InstanceIndex-04265"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 32-bit int scalar",
"has bit width 64"))));
INSTANTIATE_TEST_SUITE_P(
LayerAndViewportIndexInputSuccess,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("Layer", "ViewportIndex"), Values("Fragment"),
Values("Input"), Values("%u32"), Values(nullptr),
Values(TestResult())));
INSTANTIATE_TEST_SUITE_P(
LayerAndViewportIndexOutputSuccess,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("Layer", "ViewportIndex"), Values("Geometry"),
Values("Output"), Values("%u32"), Values(nullptr),
Values(TestResult())));
INSTANTIATE_TEST_SUITE_P(
LayerAndViewportIndexInvalidExecutionModel,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(
Values("Layer", "ViewportIndex"),
Values("TessellationControl", "GLCompute"), Values("Input"),
Values("%u32"),
Values("VUID-Layer-Layer-04272 VUID-ViewportIndex-ViewportIndex-04404"),
Values(
TestResult(SPV_ERROR_INVALID_DATA,
"to be used only with Vertex, TessellationEvaluation, "
"Geometry, or Fragment execution models"))));
INSTANTIATE_TEST_SUITE_P(
ViewportIndexExecutionModelEnabledByCapability,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("ViewportIndex"), Values("Vertex", "TessellationEvaluation"),
Values("Output"), Values("%u32"),
Values("VUID-ViewportIndex-ViewportIndex-04405"),
Values(TestResult(
SPV_ERROR_INVALID_DATA,
"ShaderViewportIndexLayerEXT or ShaderViewportIndex"))));
INSTANTIATE_TEST_SUITE_P(
LayerExecutionModelEnabledByCapability,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("Layer"), Values("Vertex", "TessellationEvaluation"),
Values("Output"), Values("%u32"), Values("VUID-Layer-Layer-04273"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"ShaderViewportIndexLayerEXT or ShaderLayer"))));
INSTANTIATE_TEST_SUITE_P(
LayerAndViewportIndexFragmentNotInput,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(
Values("Layer", "ViewportIndex"), Values("Fragment"), Values("Output"),
Values("%u32"),
Values("VUID-Layer-Layer-04275 VUID-ViewportIndex-ViewportIndex-04407"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"Output storage class if execution model is Fragment",
"which is called with execution model Fragment"))));
INSTANTIATE_TEST_SUITE_P(
LayerAndViewportIndexGeometryNotOutput,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(
Values("Layer", "ViewportIndex"),
Values("Vertex", "TessellationEvaluation", "Geometry"), Values("Input"),
Values("%u32"),
Values("VUID-Layer-Layer-04274 VUID-ViewportIndex-ViewportIndex-04406"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"Input storage class if execution model is Vertex, "
"TessellationEvaluation, Geometry, or MeshNV",
"which is called with execution model"))));
INSTANTIATE_TEST_SUITE_P(
LayerAndViewportIndexNotIntScalar,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(
Values("Layer", "ViewportIndex"), Values("Fragment"), Values("Input"),
Values("%f32", "%u32vec3"),
Values("VUID-Layer-Layer-04276 VUID-ViewportIndex-ViewportIndex-04408"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 32-bit int scalar",
"is not an int scalar"))));
INSTANTIATE_TEST_SUITE_P(
LayerAndViewportIndexNotInt32,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(
Values("Layer", "ViewportIndex"), Values("Fragment"), Values("Input"),
Values("%u64"),
Values("VUID-Layer-Layer-04276 VUID-ViewportIndex-ViewportIndex-04408"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 32-bit int scalar",
"has bit width 64"))));
INSTANTIATE_TEST_SUITE_P(
LayerCapability,
ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values(SPV_ENV_VULKAN_1_2), Values("Layer"), Values("Vertex"),
Values("Output"), Values("%u32"),
Values("OpCapability ShaderLayer\n"), Values(nullptr),
Values(nullptr), Values(TestResult())));
INSTANTIATE_TEST_SUITE_P(
ViewportIndexCapability,
ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values(SPV_ENV_VULKAN_1_2), Values("ViewportIndex"),
Values("Vertex"), Values("Output"), Values("%u32"),
Values("OpCapability ShaderViewportIndex\n"), Values(nullptr),
Values(nullptr), Values(TestResult())));
INSTANTIATE_TEST_SUITE_P(
PatchVerticesSuccess,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("PatchVertices"),
Values("TessellationEvaluation", "TessellationControl"),
Values("Input"), Values("%u32"), Values(nullptr),
Values(TestResult())));
INSTANTIATE_TEST_SUITE_P(
PatchVerticesInvalidExecutionModel,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("PatchVertices"),
Values("Vertex", "Fragment", "GLCompute", "Geometry"),
Values("Input"), Values("%u32"),
Values("VUID-PatchVertices-PatchVertices-04308"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"to be used only with TessellationControl or "
"TessellationEvaluation execution models"))));
INSTANTIATE_TEST_SUITE_P(
PatchVerticesNotInput,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("PatchVertices"),
Values("TessellationEvaluation", "TessellationControl"),
Values("Output"), Values("%u32"),
Values("VUID-PatchVertices-PatchVertices-04309"),
Values(TestResult(
SPV_ERROR_INVALID_DATA,
"to be only used for variables with Input storage class",
"uses storage class Output"))));
INSTANTIATE_TEST_SUITE_P(
PatchVerticesNotIntScalar,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("PatchVertices"),
Values("TessellationEvaluation", "TessellationControl"),
Values("Input"), Values("%f32", "%u32vec3"),
Values("VUID-PatchVertices-PatchVertices-04310"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 32-bit int scalar",
"is not an int scalar"))));
INSTANTIATE_TEST_SUITE_P(
PatchVerticesNotInt32,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("PatchVertices"),
Values("TessellationEvaluation", "TessellationControl"),
Values("Input"), Values("%u64"),
Values("VUID-PatchVertices-PatchVertices-04310"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 32-bit int scalar",
"has bit width 64"))));
INSTANTIATE_TEST_SUITE_P(
PointCoordSuccess, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("PointCoord"), Values("Fragment"), Values("Input"),
Values("%f32vec2"), Values(nullptr), Values(TestResult())));
INSTANTIATE_TEST_SUITE_P(
PointCoordNotFragment,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(
Values("PointCoord"),
Values("Vertex", "GLCompute", "Geometry", "TessellationControl",
"TessellationEvaluation"),
Values("Input"), Values("%f32vec2"),
Values("VUID-PointCoord-PointCoord-04311"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"to be used only with Fragment execution model"))));
INSTANTIATE_TEST_SUITE_P(
PointCoordNotInput,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("PointCoord"), Values("Fragment"), Values("Output"),
Values("%f32vec2"), Values("VUID-PointCoord-PointCoord-04312"),
Values(TestResult(
SPV_ERROR_INVALID_DATA,
"to be only used for variables with Input storage class",
"uses storage class Output"))));
INSTANTIATE_TEST_SUITE_P(
PointCoordNotFloatVector,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("PointCoord"), Values("Fragment"), Values("Input"),
Values("%f32arr2", "%u32vec2"),
Values("VUID-PointCoord-PointCoord-04313"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 2-component 32-bit float vector",
"is not a float vector"))));
INSTANTIATE_TEST_SUITE_P(
PointCoordNotFloatVec3,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("PointCoord"), Values("Fragment"), Values("Input"),
Values("%f32vec3"), Values("VUID-PointCoord-PointCoord-04313"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 2-component 32-bit float vector",
"has 3 components"))));
INSTANTIATE_TEST_SUITE_P(
PointCoordNotF32Vec4,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("PointCoord"), Values("Fragment"), Values("Input"),
Values("%f64vec2"), Values("VUID-PointCoord-PointCoord-04313"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 2-component 32-bit float vector",
"has components with bit width 64"))));
INSTANTIATE_TEST_SUITE_P(
PointSizeOutputSuccess,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("PointSize"),
Values("Vertex", "Geometry", "TessellationControl",
"TessellationEvaluation"),
Values("Output"), Values("%f32"), Values(nullptr),
Values(TestResult())));
INSTANTIATE_TEST_SUITE_P(
PointSizeInputSuccess,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("PointSize"),
Values("Geometry", "TessellationControl", "TessellationEvaluation"),
Values("Input"), Values("%f32"), Values(nullptr),
Values(TestResult())));
INSTANTIATE_TEST_SUITE_P(
PointSizeVertexInput,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("PointSize"), Values("Vertex"), Values("Input"),
Values("%f32"), Values("VUID-PointSize-PointSize-04315"),
Values(TestResult(
SPV_ERROR_INVALID_DATA,
"Vulkan spec doesn't allow BuiltIn PointSize "
"to be used for variables with Input storage class if "
"execution model is Vertex.",
"which is called with execution model Vertex."))));
INSTANTIATE_TEST_SUITE_P(
PointSizeInvalidExecutionModel,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("PointSize"), Values("GLCompute", "Fragment"),
Values("Input", "Output"), Values("%f32"),
Values("VUID-PointSize-PointSize-04314"),
Values(TestResult(
SPV_ERROR_INVALID_DATA,
"to be used only with Vertex, TessellationControl, "
"TessellationEvaluation or Geometry execution models"))));
INSTANTIATE_TEST_SUITE_P(
PointSizeNotFloatScalar,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("PointSize"), Values("Vertex"), Values("Output"),
Values("%f32vec4", "%u32"),
Values("VUID-PointSize-PointSize-04317"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 32-bit float scalar",
"is not a float scalar"))));
INSTANTIATE_TEST_SUITE_P(
PointSizeNotF32, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("PointSize"), Values("Vertex"), Values("Output"),
Values("%f64"), Values("VUID-PointSize-PointSize-04317"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 32-bit float scalar",
"has bit width 64"))));
INSTANTIATE_TEST_SUITE_P(
PositionOutputSuccess,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("Position"),
Values("Vertex", "Geometry", "TessellationControl",
"TessellationEvaluation"),
Values("Output"), Values("%f32vec4"), Values(nullptr),
Values(TestResult())));
INSTANTIATE_TEST_SUITE_P(
PositionInputSuccess,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("Position"),
Values("Geometry", "TessellationControl", "TessellationEvaluation"),
Values("Input"), Values("%f32vec4"), Values(nullptr),
Values(TestResult())));
INSTANTIATE_TEST_SUITE_P(
PositionInvalidStorageClass,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("Position"),
Values("Geometry", "TessellationControl", "TessellationEvaluation"),
Values("Private"), Values("%f32vec4"),
Values("VUID-Position-Position-04320"),
Values(TestResult(
SPV_ERROR_INVALID_DATA,
"Vulkan spec allows BuiltIn Position to be only used for "
"variables with Input or Output storage class."))));
INSTANTIATE_TEST_SUITE_P(
PositionVertexInput,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("Position"), Values("Vertex"), Values("Input"),
Values("%f32vec4"), Values("VUID-Position-Position-04319"),
Values(TestResult(
SPV_ERROR_INVALID_DATA,
"Vulkan spec doesn't allow BuiltIn Position "
"to be used for variables with Input storage class if "
"execution model is Vertex.",
"which is called with execution model Vertex."))));
INSTANTIATE_TEST_SUITE_P(
PositionInvalidExecutionModel,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("Position"), Values("GLCompute", "Fragment"),
Values("Input", "Output"), Values("%f32vec4"),
Values("VUID-Position-Position-04318"),
Values(TestResult(
SPV_ERROR_INVALID_DATA,
"to be used only with Vertex, TessellationControl, "
"TessellationEvaluation or Geometry execution models"))));
INSTANTIATE_TEST_SUITE_P(
PositionNotFloatVector,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("Position"), Values("Geometry"), Values("Input"),
Values("%f32arr4", "%u32vec4"),
Values("VUID-Position-Position-04321"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 4-component 32-bit float vector",
"is not a float vector"))));
INSTANTIATE_TEST_SUITE_P(
PositionNotFloatVec4,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("Position"), Values("Geometry"), Values("Input"),
Values("%f32vec3"), Values("VUID-Position-Position-04321"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 4-component 32-bit float vector",
"has 3 components"))));
INSTANTIATE_TEST_SUITE_P(
PositionNotF32Vec4,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("Position"), Values("Geometry"), Values("Input"),
Values("%f64vec4"), Values("VUID-Position-Position-04321"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 4-component 32-bit float vector",
"has components with bit width 64"))));
INSTANTIATE_TEST_SUITE_P(
PrimitiveIdInputSuccess,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("PrimitiveId"),
Values("Fragment", "TessellationControl", "TessellationEvaluation",
"Geometry"),
Values("Input"), Values("%u32"), Values(nullptr),
Values(TestResult())));
INSTANTIATE_TEST_SUITE_P(
PrimitiveIdOutputSuccess,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("PrimitiveId"), Values("Geometry"), Values("Output"),
Values("%u32"), Values(nullptr), Values(TestResult())));
INSTANTIATE_TEST_SUITE_P(
PrimitiveIdInvalidExecutionModel,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("PrimitiveId"), Values("Vertex", "GLCompute"),
Values("Input"), Values("%u32"),
Values("VUID-PrimitiveId-PrimitiveId-04330"),
Values(TestResult(
SPV_ERROR_INVALID_DATA,
"to be used only with Fragment, TessellationControl, "
"TessellationEvaluation, Geometry, MeshNV, IntersectionKHR, "
"AnyHitKHR, and ClosestHitKHR execution models"))));
INSTANTIATE_TEST_SUITE_P(
PrimitiveIdFragmentNotInput,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(
Values("PrimitiveId"), Values("Fragment"), Values("Output"),
Values("%u32"), Values("VUID-PrimitiveId-PrimitiveId-04334"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"Output storage class if execution model is Fragment",
"which is called with execution model Fragment"))));
INSTANTIATE_TEST_SUITE_P(
PrimitiveIdTessellationNotInput,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("PrimitiveId"),
Values("TessellationControl", "TessellationEvaluation"),
Values("Output"), Values("%u32"),
Values("VUID-PrimitiveId-PrimitiveId-04334"),
Values(TestResult(
SPV_ERROR_INVALID_DATA,
"Output storage class if execution model is Tessellation",
"which is called with execution model Tessellation"))));
INSTANTIATE_TEST_SUITE_P(
PrimitiveIdNotIntScalar,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("PrimitiveId"), Values("Fragment"), Values("Input"),
Values("%f32", "%u32vec3"),
Values("VUID-PrimitiveId-PrimitiveId-04337"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 32-bit int scalar",
"is not an int scalar"))));
INSTANTIATE_TEST_SUITE_P(
PrimitiveIdNotInt32,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("PrimitiveId"), Values("Fragment"), Values("Input"),
Values("%u64"), Values("VUID-PrimitiveId-PrimitiveId-04337"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 32-bit int scalar",
"has bit width 64"))));
INSTANTIATE_TEST_SUITE_P(
SampleIdSuccess, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("SampleId"), Values("Fragment"), Values("Input"),
Values("%u32"), Values(nullptr), Values(TestResult())));
INSTANTIATE_TEST_SUITE_P(
SampleIdInvalidExecutionModel,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(
Values("SampleId"),
Values("Vertex", "GLCompute", "Geometry", "TessellationControl",
"TessellationEvaluation"),
Values("Input"), Values("%u32"), Values("VUID-SampleId-SampleId-04354"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"to be used only with Fragment execution model"))));
INSTANTIATE_TEST_SUITE_P(
SampleIdNotInput, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(
Values("SampleId"), Values("Fragment"), Values("Output"),
Values("%u32"), Values("VUID-SampleId-SampleId-04355"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"Vulkan spec allows BuiltIn SampleId to be only used "
"for variables with Input storage class"))));
INSTANTIATE_TEST_SUITE_P(
SampleIdNotIntScalar,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("SampleId"), Values("Fragment"), Values("Input"),
Values("%f32", "%u32vec3"), Values("VUID-SampleId-SampleId-04356"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 32-bit int scalar",
"is not an int scalar"))));
INSTANTIATE_TEST_SUITE_P(
SampleIdNotInt32, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("SampleId"), Values("Fragment"), Values("Input"),
Values("%u64"), Values("VUID-SampleId-SampleId-04356"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 32-bit int scalar",
"has bit width 64"))));
INSTANTIATE_TEST_SUITE_P(
SampleMaskSuccess, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("SampleMask"), Values("Fragment"), Values("Input", "Output"),
Values("%u32arr2", "%u32arr4"), Values(nullptr),
Values(TestResult())));
INSTANTIATE_TEST_SUITE_P(
SampleMaskInvalidExecutionModel,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(
Values("SampleMask"),
Values("Vertex", "GLCompute", "Geometry", "TessellationControl",
"TessellationEvaluation"),
Values("Input"), Values("%u32arr2"),
Values("VUID-SampleMask-SampleMask-04357"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"to be used only with Fragment execution model"))));
INSTANTIATE_TEST_SUITE_P(
SampleMaskWrongStorageClass,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("SampleMask"), Values("Fragment"), Values("Workgroup"),
Values("%u32arr2"), Values("VUID-SampleMask-SampleMask-04358"),
Values(TestResult(
SPV_ERROR_INVALID_DATA,
"Vulkan spec allows BuiltIn SampleMask to be only used for "
"variables with Input or Output storage class"))));
INSTANTIATE_TEST_SUITE_P(
SampleMaskNotArray,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("SampleMask"), Values("Fragment"), Values("Input"),
Values("%f32", "%u32vec3"),
Values("VUID-SampleMask-SampleMask-04359"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 32-bit int array",
"is not an array"))));
INSTANTIATE_TEST_SUITE_P(
SampleMaskNotIntArray,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("SampleMask"), Values("Fragment"), Values("Input"),
Values("%f32arr2"), Values("VUID-SampleMask-SampleMask-04359"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 32-bit int array",
"components are not int scalar"))));
INSTANTIATE_TEST_SUITE_P(
SampleMaskNotInt32Array,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("SampleMask"), Values("Fragment"), Values("Input"),
Values("%u64arr2"), Values("VUID-SampleMask-SampleMask-04359"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 32-bit int array",
"has components with bit width 64"))));
INSTANTIATE_TEST_SUITE_P(
SamplePositionSuccess,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("SamplePosition"), Values("Fragment"), Values("Input"),
Values("%f32vec2"), Values(nullptr), Values(TestResult())));
INSTANTIATE_TEST_SUITE_P(
SamplePositionNotFragment,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(
Values("SamplePosition"),
Values("Vertex", "GLCompute", "Geometry", "TessellationControl",
"TessellationEvaluation"),
Values("Input"), Values("%f32vec2"),
Values("VUID-SamplePosition-SamplePosition-04360"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"to be used only with Fragment execution model"))));
INSTANTIATE_TEST_SUITE_P(
SamplePositionNotInput,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("SamplePosition"), Values("Fragment"), Values("Output"),
Values("%f32vec2"),
Values("VUID-SamplePosition-SamplePosition-04361"),
Values(TestResult(
SPV_ERROR_INVALID_DATA,
"to be only used for variables with Input storage class",
"uses storage class Output"))));
INSTANTIATE_TEST_SUITE_P(
SamplePositionNotFloatVector,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("SamplePosition"), Values("Fragment"), Values("Input"),
Values("%f32arr2", "%u32vec4"),
Values("VUID-SamplePosition-SamplePosition-04362"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 2-component 32-bit float vector",
"is not a float vector"))));
INSTANTIATE_TEST_SUITE_P(
SamplePositionNotFloatVec2,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("SamplePosition"), Values("Fragment"), Values("Input"),
Values("%f32vec3"),
Values("VUID-SamplePosition-SamplePosition-04362"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 2-component 32-bit float vector",
"has 3 components"))));
INSTANTIATE_TEST_SUITE_P(
SamplePositionNotF32Vec2,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("SamplePosition"), Values("Fragment"), Values("Input"),
Values("%f64vec2"),
Values("VUID-SamplePosition-SamplePosition-04362"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 2-component 32-bit float vector",
"has components with bit width 64"))));
INSTANTIATE_TEST_SUITE_P(
TessCoordSuccess, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("TessCoord"), Values("TessellationEvaluation"),
Values("Input"), Values("%f32vec3"), Values(nullptr),
Values(TestResult())));
INSTANTIATE_TEST_SUITE_P(
TessCoordNotFragment,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(
Values("TessCoord"),
Values("Vertex", "GLCompute", "Geometry", "TessellationControl",
"Fragment"),
Values("Input"), Values("%f32vec3"),
Values("VUID-TessCoord-TessCoord-04387"),
Values(TestResult(
SPV_ERROR_INVALID_DATA,
"to be used only with TessellationEvaluation execution model"))));
INSTANTIATE_TEST_SUITE_P(
TessCoordNotInput, ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("TessCoord"), Values("Fragment"), Values("Output"),
Values("%f32vec3"), Values("VUID-TessCoord-TessCoord-04388"),
Values(TestResult(
SPV_ERROR_INVALID_DATA,
"to be only used for variables with Input storage class",
"uses storage class Output"))));
INSTANTIATE_TEST_SUITE_P(
TessCoordNotFloatVector,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("TessCoord"), Values("Fragment"), Values("Input"),
Values("%f32arr3", "%u32vec4"),
Values("VUID-TessCoord-TessCoord-04389"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 3-component 32-bit float vector",
"is not a float vector"))));
INSTANTIATE_TEST_SUITE_P(
TessCoordNotFloatVec3,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("TessCoord"), Values("Fragment"), Values("Input"),
Values("%f32vec2"), Values("VUID-TessCoord-TessCoord-04389"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 3-component 32-bit float vector",
"has 2 components"))));
INSTANTIATE_TEST_SUITE_P(
TessCoordNotF32Vec3,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("TessCoord"), Values("Fragment"), Values("Input"),
Values("%f64vec3"), Values("VUID-TessCoord-TessCoord-04389"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 3-component 32-bit float vector",
"has components with bit width 64"))));
INSTANTIATE_TEST_SUITE_P(
TessLevelOuterTeseInputSuccess,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("TessLevelOuter"), Values("TessellationEvaluation"),
Values("Input"), Values("%f32arr4"), Values(nullptr),
Values(TestResult())));
INSTANTIATE_TEST_SUITE_P(
TessLevelOuterTescOutputSuccess,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("TessLevelOuter"), Values("TessellationControl"),
Values("Output"), Values("%f32arr4"), Values(nullptr),
Values(TestResult())));
INSTANTIATE_TEST_SUITE_P(
TessLevelOuterInvalidExecutionModel,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("TessLevelOuter"),
Values("Vertex", "GLCompute", "Geometry", "Fragment"),
Values("Input"), Values("%f32arr4"),
Values("VUID-TessLevelOuter-TessLevelOuter-04390"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"to be used only with TessellationControl or "
"TessellationEvaluation execution models."))));
INSTANTIATE_TEST_SUITE_P(
TessLevelOuterOutputTese,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("TessLevelOuter"), Values("TessellationEvaluation"),
Values("Output"), Values("%f32arr4"),
Values("VUID-TessLevelOuter-TessLevelOuter-04392"),
Values(TestResult(
SPV_ERROR_INVALID_DATA,
"Vulkan spec doesn't allow TessLevelOuter/TessLevelInner to be "
"used for variables with Output storage class if execution "
"model is TessellationEvaluation."))));
INSTANTIATE_TEST_SUITE_P(
TessLevelOuterInputTesc,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("TessLevelOuter"), Values("TessellationControl"),
Values("Input"), Values("%f32arr4"),
Values("VUID-TessLevelOuter-TessLevelOuter-04391"),
Values(TestResult(
SPV_ERROR_INVALID_DATA,
"Vulkan spec doesn't allow TessLevelOuter/TessLevelInner to be "
"used for variables with Input storage class if execution "
"model is TessellationControl."))));
INSTANTIATE_TEST_SUITE_P(
TessLevelOuterNotArray,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("TessLevelOuter"), Values("TessellationEvaluation"),
Values("Input"), Values("%f32vec4", "%f32"),
Values("VUID-TessLevelOuter-TessLevelOuter-04393"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 4-component 32-bit float array",
"is not an array"))));
INSTANTIATE_TEST_SUITE_P(
TessLevelOuterNotFloatArray,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("TessLevelOuter"), Values("TessellationEvaluation"),
Values("Input"), Values("%u32arr4"),
Values("VUID-TessLevelOuter-TessLevelOuter-04393"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 4-component 32-bit float array",
"components are not float scalar"))));
INSTANTIATE_TEST_SUITE_P(
TessLevelOuterNotFloatArr4,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("TessLevelOuter"), Values("TessellationEvaluation"),
Values("Input"), Values("%f32arr3"),
Values("VUID-TessLevelOuter-TessLevelOuter-04393"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 4-component 32-bit float array",
"has 3 components"))));
INSTANTIATE_TEST_SUITE_P(
TessLevelOuterNotF32Arr4,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("TessLevelOuter"), Values("TessellationEvaluation"),
Values("Input"), Values("%f64arr4"),
Values("VUID-TessLevelOuter-TessLevelOuter-04393"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 4-component 32-bit float array",
"has components with bit width 64"))));
INSTANTIATE_TEST_SUITE_P(
TessLevelInnerTeseInputSuccess,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("TessLevelInner"), Values("TessellationEvaluation"),
Values("Input"), Values("%f32arr2"), Values(nullptr),
Values(TestResult())));
INSTANTIATE_TEST_SUITE_P(
TessLevelInnerTescOutputSuccess,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("TessLevelInner"), Values("TessellationControl"),
Values("Output"), Values("%f32arr2"), Values(nullptr),
Values(TestResult())));
INSTANTIATE_TEST_SUITE_P(
TessLevelInnerInvalidExecutionModel,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("TessLevelInner"),
Values("Vertex", "GLCompute", "Geometry", "Fragment"),
Values("Input"), Values("%f32arr2"),
Values("VUID-TessLevelInner-TessLevelInner-04394"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"to be used only with TessellationControl or "
"TessellationEvaluation execution models."))));
INSTANTIATE_TEST_SUITE_P(
TessLevelInnerOutputTese,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("TessLevelInner"), Values("TessellationEvaluation"),
Values("Output"), Values("%f32arr2"),
Values("VUID-TessLevelInner-TessLevelInner-04396"),
Values(TestResult(
SPV_ERROR_INVALID_DATA,
"Vulkan spec doesn't allow TessLevelOuter/TessLevelInner to be "
"used for variables with Output storage class if execution "
"model is TessellationEvaluation."))));
INSTANTIATE_TEST_SUITE_P(
TessLevelInnerInputTesc,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("TessLevelInner"), Values("TessellationControl"),
Values("Input"), Values("%f32arr2"),
Values("VUID-TessLevelInner-TessLevelInner-04395"),
Values(TestResult(
SPV_ERROR_INVALID_DATA,
"Vulkan spec doesn't allow TessLevelOuter/TessLevelInner to be "
"used for variables with Input storage class if execution "
"model is TessellationControl."))));
INSTANTIATE_TEST_SUITE_P(
TessLevelInnerNotArray,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("TessLevelInner"), Values("TessellationEvaluation"),
Values("Input"), Values("%f32vec2", "%f32"),
Values("VUID-TessLevelInner-TessLevelInner-04397"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 2-component 32-bit float array",
"is not an array"))));
INSTANTIATE_TEST_SUITE_P(
TessLevelInnerNotFloatArray,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("TessLevelInner"), Values("TessellationEvaluation"),
Values("Input"), Values("%u32arr2"),
Values("VUID-TessLevelInner-TessLevelInner-04397"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 2-component 32-bit float array",
"components are not float scalar"))));
INSTANTIATE_TEST_SUITE_P(
TessLevelInnerNotFloatArr2,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("TessLevelInner"), Values("TessellationEvaluation"),
Values("Input"), Values("%f32arr3"),
Values("VUID-TessLevelInner-TessLevelInner-04397"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 2-component 32-bit float array",
"has 3 components"))));
INSTANTIATE_TEST_SUITE_P(
TessLevelInnerNotF32Arr2,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("TessLevelInner"), Values("TessellationEvaluation"),
Values("Input"), Values("%f64arr2"),
Values("VUID-TessLevelInner-TessLevelInner-04397"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 2-component 32-bit float array",
"has components with bit width 64"))));
INSTANTIATE_TEST_SUITE_P(
VertexIndexSuccess,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("VertexIndex"), Values("Vertex"), Values("Input"),
Values("%u32"), Values(nullptr), Values(TestResult())));
INSTANTIATE_TEST_SUITE_P(
VertexIndexInvalidExecutionModel,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("VertexIndex"),
Values("Fragment", "GLCompute", "Geometry", "TessellationControl",
"TessellationEvaluation"),
Values("Input"), Values("%u32"),
Values("VUID-VertexIndex-VertexIndex-04398"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"to be used only with Vertex execution model"))));
INSTANTIATE_TEST_SUITE_P(
VertexIndexNotInput,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(
Values("VertexIndex"), Values("Vertex"), Values("Output"),
Values("%u32"), Values("VUID-VertexIndex-VertexIndex-04399"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"Vulkan spec allows BuiltIn VertexIndex to be only "
"used for variables with Input storage class"))));
INSTANTIATE_TEST_SUITE_P(
VertexIndexNotIntScalar,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("VertexIndex"), Values("Vertex"), Values("Input"),
Values("%f32", "%u32vec3"),
Values("VUID-VertexIndex-VertexIndex-04400"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 32-bit int scalar",
"is not an int scalar"))));
INSTANTIATE_TEST_SUITE_P(
VertexIndexNotInt32,
ValidateVulkanCombineBuiltInExecutionModelDataTypeResult,
Combine(Values("VertexIndex"), Values("Vertex"), Values("Input"),
Values("%u64"), Values("VUID-VertexIndex-VertexIndex-04400"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 32-bit int scalar",
"has bit width 64"))));
INSTANTIATE_TEST_SUITE_P(
BaseInstanceOrVertexSuccess,
ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values("BaseInstance", "BaseVertex"), Values("Vertex"),
Values("Input"), Values("%u32"),
Values("OpCapability DrawParameters\n"),
Values("OpExtension \"SPV_KHR_shader_draw_parameters\"\n"),
Values(nullptr), Values(TestResult())));
INSTANTIATE_TEST_SUITE_P(
BaseInstanceOrVertexInvalidExecutionModel,
ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values("BaseInstance", "BaseVertex"),
Values("Fragment", "GLCompute", "Geometry", "TessellationControl",
"TessellationEvaluation"),
Values("Input"), Values("%u32"),
Values("OpCapability DrawParameters\n"),
Values("OpExtension \"SPV_KHR_shader_draw_parameters\"\n"),
Values("VUID-BaseInstance-BaseInstance-04181 "
"VUID-BaseVertex-BaseVertex-04184"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"to be used only with Vertex execution model"))));
INSTANTIATE_TEST_SUITE_P(
BaseInstanceOrVertexNotInput,
ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values("BaseInstance", "BaseVertex"), Values("Vertex"),
Values("Output"), Values("%u32"),
Values("OpCapability DrawParameters\n"),
Values("OpExtension \"SPV_KHR_shader_draw_parameters\"\n"),
Values("VUID-BaseInstance-BaseInstance-04182 "
"VUID-BaseVertex-BaseVertex-04185"),
Values(TestResult(SPV_ERROR_INVALID_DATA, "Vulkan spec allows",
"used for variables with Input storage class"))));
INSTANTIATE_TEST_SUITE_P(
BaseInstanceOrVertexNotIntScalar,
ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values("BaseInstance", "BaseVertex"), Values("Vertex"),
Values("Input"), Values("%f32", "%u32vec3"),
Values("OpCapability DrawParameters\n"),
Values("OpExtension \"SPV_KHR_shader_draw_parameters\"\n"),
Values("VUID-BaseInstance-BaseInstance-04183 "
"VUID-BaseVertex-BaseVertex-04186"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 32-bit int scalar",
"is not an int scalar"))));
INSTANTIATE_TEST_SUITE_P(
DrawIndexSuccess,
ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values("DrawIndex"), Values("Vertex"), Values("Input"),
Values("%u32"), Values("OpCapability DrawParameters\n"),
Values("OpExtension \"SPV_KHR_shader_draw_parameters\"\n"),
Values(nullptr), Values(TestResult())));
INSTANTIATE_TEST_SUITE_P(
DrawIndexMeshSuccess,
ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(
Values("DrawIndex"), Values("MeshNV", "TaskNV"), Values("Input"),
Values("%u32"), Values("OpCapability MeshShadingNV\n"),
Values("OpExtension \"SPV_KHR_shader_draw_parameters\"\nOpExtension "
"\"SPV_NV_mesh_shader\"\n"),
Values(nullptr), Values(TestResult())));
INSTANTIATE_TEST_SUITE_P(
DrawIndexInvalidExecutionModel,
ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values("DrawIndex"),
Values("Fragment", "GLCompute", "Geometry", "TessellationControl",
"TessellationEvaluation"),
Values("Input"), Values("%u32"),
Values("OpCapability DrawParameters\n"),
Values("OpExtension \"SPV_KHR_shader_draw_parameters\"\n"),
Values("VUID-DrawIndex-DrawIndex-04207"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"to be used only with Vertex, MeshNV, or TaskNV "
"execution model"))));
INSTANTIATE_TEST_SUITE_P(
DrawIndexNotInput,
ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values("DrawIndex"), Values("Vertex"), Values("Output"),
Values("%u32"), Values("OpCapability DrawParameters\n"),
Values("OpExtension \"SPV_KHR_shader_draw_parameters\"\n"),
Values("VUID-DrawIndex-DrawIndex-04208"),
Values(TestResult(SPV_ERROR_INVALID_DATA, "Vulkan spec allows",
"used for variables with Input storage class"))));
INSTANTIATE_TEST_SUITE_P(
DrawIndexNotIntScalar,
ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values("DrawIndex"), Values("Vertex"), Values("Input"),
Values("%f32", "%u32vec3"), Values("OpCapability DrawParameters\n"),
Values("OpExtension \"SPV_KHR_shader_draw_parameters\"\n"),
Values("VUID-DrawIndex-DrawIndex-04209"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 32-bit int scalar",
"is not an int scalar"))));
INSTANTIATE_TEST_SUITE_P(
ViewIndexSuccess,
ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values("ViewIndex"),
Values("Fragment", "Vertex", "Geometry", "TessellationControl",
"TessellationEvaluation"),
Values("Input"), Values("%u32"), Values("OpCapability MultiView\n"),
Values("OpExtension \"SPV_KHR_multiview\"\n"), Values(nullptr),
Values(TestResult())));
INSTANTIATE_TEST_SUITE_P(
ViewIndexInvalidExecutionModel,
ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values("ViewIndex"), Values("GLCompute"), Values("Input"),
Values("%u32"), Values("OpCapability MultiView\n"),
Values("OpExtension \"SPV_KHR_multiview\"\n"),
Values("VUID-ViewIndex-ViewIndex-04401"),
Values(TestResult(
SPV_ERROR_INVALID_DATA,
"to be not be used with GLCompute execution model"))));
INSTANTIATE_TEST_SUITE_P(
ViewIndexNotInput,
ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values("ViewIndex"), Values("Vertex"), Values("Output"),
Values("%u32"), Values("OpCapability MultiView\n"),
Values("OpExtension \"SPV_KHR_multiview\"\n"),
Values("VUID-ViewIndex-ViewIndex-04402"),
Values(TestResult(SPV_ERROR_INVALID_DATA, "Vulkan spec allows",
"used for variables with Input storage class"))));
INSTANTIATE_TEST_SUITE_P(
ViewIndexNotIntScalar,
ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values("ViewIndex"), Values("Vertex"), Values("Input"),
Values("%f32", "%u32vec3"), Values("OpCapability MultiView\n"),
Values("OpExtension \"SPV_KHR_multiview\"\n"),
Values("VUID-ViewIndex-ViewIndex-04403"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 32-bit int scalar",
"is not an int scalar"))));
INSTANTIATE_TEST_SUITE_P(
DeviceIndexSuccess,
ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values("DeviceIndex"),
Values("Fragment", "Vertex", "Geometry", "TessellationControl",
"TessellationEvaluation", "GLCompute"),
Values("Input"), Values("%u32"),
Values("OpCapability DeviceGroup\n"),
Values("OpExtension \"SPV_KHR_device_group\"\n"), Values(nullptr),
Values(TestResult())));
INSTANTIATE_TEST_SUITE_P(
DeviceIndexNotInput,
ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values("DeviceIndex"), Values("Fragment", "Vertex", "GLCompute"),
Values("Output"), Values("%u32"),
Values("OpCapability DeviceGroup\n"),
Values("OpExtension \"SPV_KHR_device_group\"\n"),
Values("VUID-DeviceIndex-DeviceIndex-04205"),
Values(TestResult(SPV_ERROR_INVALID_DATA, "Vulkan spec allows",
"used for variables with Input storage class"))));
INSTANTIATE_TEST_SUITE_P(
DeviceIndexNotIntScalar,
ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values("DeviceIndex"), Values("Fragment", "Vertex", "GLCompute"),
Values("Input"), Values("%f32", "%u32vec3"),
Values("OpCapability DeviceGroup\n"),
Values("OpExtension \"SPV_KHR_device_group\"\n"),
Values("VUID-DeviceIndex-DeviceIndex-04206"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 32-bit int scalar",
"is not an int scalar"))));
// Test HitKind in NV RT shaders
INSTANTIATE_TEST_SUITE_P(
HitKindNVSuccess,
ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values(SPV_ENV_VULKAN_1_2), Values("HitKindNV"),
Values("AnyHitNV", "ClosestHitNV"), Values("Input"), Values("%u32"),
Values("OpCapability RayTracingNV\n"),
Values("OpExtension \"SPV_NV_ray_tracing\"\n"), Values(nullptr),
Values(TestResult())));
// HitKind is valid in AH, CH shaders as input i32 scalar
INSTANTIATE_TEST_SUITE_P(
HitKindSuccess,
ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values(SPV_ENV_VULKAN_1_2), Values("HitKindKHR"),
Values("AnyHitKHR", "ClosestHitKHR"), Values("Input"),
Values("%u32"), Values("OpCapability RayTracingKHR\n"),
Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), Values(nullptr),
Values(TestResult())));
INSTANTIATE_TEST_SUITE_P(
HitKindNotExecutionMode,
ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values(SPV_ENV_VULKAN_1_2), Values("HitKindKHR"),
Values("Vertex", "Fragment", "TessellationControl",
"TessellationEvaluation", "Geometry", "Fragment",
"GLCompute", "RayGenerationKHR", "IntersectionKHR",
"MissKHR", "CallableKHR"),
Values("Input"), Values("%u32"),
Values("OpCapability RayTracingKHR\n"),
Values("OpExtension \"SPV_KHR_ray_tracing\"\n"),
Values("VUID-HitKindKHR-HitKindKHR-04242"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"Vulkan spec does not allow BuiltIn",
"to be used with the execution model"))));
INSTANTIATE_TEST_SUITE_P(
HitKindNotInput,
ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values(SPV_ENV_VULKAN_1_2), Values("HitKindKHR"),
Values("AnyHitKHR", "ClosestHitKHR"), Values("Output"),
Values("%u32"), Values("OpCapability RayTracingKHR\n"),
Values("OpExtension \"SPV_KHR_ray_tracing\"\n"),
Values("VUID-HitKindKHR-HitKindKHR-04243"),
Values(TestResult(SPV_ERROR_INVALID_DATA, "Vulkan spec allows",
"used for variables with Input storage class"))));
INSTANTIATE_TEST_SUITE_P(
HitKindNotIntScalar,
ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values(SPV_ENV_VULKAN_1_2), Values("HitKindKHR"),
Values("AnyHitKHR", "ClosestHitKHR"), Values("Input"),
Values("%f32", "%u32vec3"), Values("OpCapability RayTracingKHR\n"),
Values("OpExtension \"SPV_KHR_ray_tracing\"\n"),
Values("VUID-HitKindKHR-HitKindKHR-04244"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 32-bit int scalar",
"is not an int scalar"))));
// Ensure HitT is not supported in KHR RT shaders
INSTANTIATE_TEST_SUITE_P(
HitTNVNotSupportedInKHR,
ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values(SPV_ENV_VULKAN_1_2), Values("HitTNV"),
Values("AnyHitKHR", "ClosestHitKHR"), Values("Input"),
Values("%u32"), Values("OpCapability RayTracingKHR\n"),
Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), Values(nullptr),
Values(TestResult(
SPV_ERROR_INVALID_CAPABILITY,
"of MemberDecorate requires one of these capabilities"))));
// HitT is valid in AH, CH shaders as input f32 scalar (NV RT only)
INSTANTIATE_TEST_SUITE_P(
HitTNVSuccess,
ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values(SPV_ENV_VULKAN_1_2), Values("HitTNV"),
Values("AnyHitNV", "ClosestHitNV"), Values("Input"), Values("%f32"),
Values("OpCapability RayTracingNV\n"),
Values("OpExtension \"SPV_NV_ray_tracing\"\n"), Values(nullptr),
Values(TestResult())));
INSTANTIATE_TEST_SUITE_P(
HitTNVNotExecutionMode,
ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values(SPV_ENV_VULKAN_1_2), Values("HitTNV"),
Values("Vertex", "Fragment", "TessellationControl",
"TessellationEvaluation", "Geometry", "Fragment",
"GLCompute", "RayGenerationNV", "IntersectionNV", "MissNV",
"CallableNV"),
Values("Input"), Values("%f32"),
Values("OpCapability RayTracingNV\n"),
Values("OpExtension \"SPV_NV_ray_tracing\"\n"),
Values("VUID-HitTNV-HitTNV-04245"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"Vulkan spec does not allow BuiltIn",
"to be used with the execution model"))));
INSTANTIATE_TEST_SUITE_P(
HitTNVNotInput,
ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values(SPV_ENV_VULKAN_1_2), Values("HitTNV"),
Values("AnyHitNV", "ClosestHitNV"), Values("Output"),
Values("%f32"), Values("OpCapability RayTracingNV\n"),
Values("OpExtension \"SPV_NV_ray_tracing\"\n"),
Values("VUID-HitTNV-HitTNV-04246"),
Values(TestResult(SPV_ERROR_INVALID_DATA, "Vulkan spec allows",
"used for variables with Input storage class"))));
INSTANTIATE_TEST_SUITE_P(
HitTNVNotIntScalar,
ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values(SPV_ENV_VULKAN_1_2), Values("HitTNV"),
Values("AnyHitNV", "ClosestHitNV"), Values("Input"),
Values("%u32", "%f32vec3"), Values("OpCapability RayTracingNV\n"),
Values("OpExtension \"SPV_NV_ray_tracing\"\n"),
Values("VUID-HitTNV-HitTNV-04247"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 32-bit float scalar",
"is not a float scalar"))));
// InstanceCustomIndexKHR, InstanceId, PrimitiveId, RayGeometryIndexKHR are
// valid in IS, AH, CH shaders as input i32 scalars
INSTANTIATE_TEST_SUITE_P(
RTBuiltIn3StageI32Success,
ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values(SPV_ENV_VULKAN_1_2),
Values("InstanceCustomIndexKHR", "RayGeometryIndexKHR",
"InstanceId", "PrimitiveId"),
Values("AnyHitKHR", "ClosestHitKHR", "IntersectionKHR"),
Values("Input"), Values("%u32"),
Values("OpCapability RayTracingKHR\n"),
Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), Values(nullptr),
Values(TestResult())));
INSTANTIATE_TEST_SUITE_P(
RTBuiltIn3StageI32NotExecutionMode,
ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values(SPV_ENV_VULKAN_1_2),
Values("InstanceCustomIndexKHR", "RayGeometryIndexKHR",
"InstanceId"),
Values("Vertex", "Fragment", "TessellationControl",
"TessellationEvaluation", "Geometry", "Fragment",
"GLCompute", "RayGenerationKHR", "MissKHR", "CallableKHR"),
Values("Input"), Values("%u32"),
Values("OpCapability RayTracingKHR\n"),
Values("OpExtension \"SPV_KHR_ray_tracing\"\n"),
Values("VUID-InstanceCustomIndexKHR-InstanceCustomIndexKHR-04251 "
"VUID-RayGeometryIndexKHR-RayGeometryIndexKHR-04345 "
"VUID-InstanceId-InstanceId-04254 "),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"Vulkan spec does not allow BuiltIn",
"to be used with the execution model"))));
INSTANTIATE_TEST_SUITE_P(
RTBuiltIn3StageI32NotInput,
ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values(SPV_ENV_VULKAN_1_2),
Values("InstanceCustomIndexKHR", "RayGeometryIndexKHR",
"InstanceId"),
Values("AnyHitKHR", "ClosestHitKHR", "IntersectionKHR"),
Values("Output"), Values("%u32"),
Values("OpCapability RayTracingKHR\n"),
Values("OpExtension \"SPV_KHR_ray_tracing\"\n"),
Values("VUID-InstanceCustomIndexKHR-InstanceCustomIndexKHR-04252 "
"VUID-RayGeometryIndexKHR-RayGeometryIndexKHR-04346 "
"VUID-InstanceId-InstanceId-04255 "),
Values(TestResult(SPV_ERROR_INVALID_DATA, "Vulkan spec allows",
"used for variables with Input storage class"))));
INSTANTIATE_TEST_SUITE_P(
RTBuiltIn3StageI32NotIntScalar,
ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values(SPV_ENV_VULKAN_1_2),
Values("InstanceCustomIndexKHR", "RayGeometryIndexKHR",
"InstanceId"),
Values("AnyHitKHR", "ClosestHitKHR", "IntersectionKHR"),
Values("Input"), Values("%f32", "%u32vec3"),
Values("OpCapability RayTracingKHR\n"),
Values("OpExtension \"SPV_KHR_ray_tracing\"\n"),
Values("VUID-InstanceCustomIndexKHR-InstanceCustomIndexKHR-04253 "
"VUID-RayGeometryIndexKHR-RayGeometryIndexKHR-04347 "
"VUID-InstanceId-InstanceId-04256 "),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 32-bit int scalar",
"is not an int scalar"))));
// PrimitiveId needs special negative testing because it has non-RT uses
INSTANTIATE_TEST_SUITE_P(
PrimitiveIdRTNotExecutionMode,
ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values(SPV_ENV_VULKAN_1_2), Values("PrimitiveId"),
Values("RayGenerationKHR", "MissKHR", "CallableKHR"),
Values("Input"), Values("%u32"),
Values("OpCapability RayTracingKHR\n"),
Values("OpExtension \"SPV_KHR_ray_tracing\"\n"),
Values("VUID-PrimitiveId-PrimitiveId-04330"),
Values(TestResult(
SPV_ERROR_INVALID_DATA,
"to be used only with Fragment, TessellationControl, "
"TessellationEvaluation, Geometry, MeshNV, IntersectionKHR, "
"AnyHitKHR, and ClosestHitKHR execution models"))));
INSTANTIATE_TEST_SUITE_P(
PrimitiveIdRTNotInput,
ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values(SPV_ENV_VULKAN_1_2), Values("PrimitiveId"),
Values("AnyHitKHR", "ClosestHitKHR", "IntersectionKHR"),
Values("Output"), Values("%u32"),
Values("OpCapability RayTracingKHR\n"),
Values("OpExtension \"SPV_KHR_ray_tracing\"\n"),
Values("VUID-PrimitiveId-PrimitiveId-04334"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"Output storage class if execution model is "))));
INSTANTIATE_TEST_SUITE_P(
PrimitiveIdRTNotIntScalar,
ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values(SPV_ENV_VULKAN_1_2), Values("PrimitiveId"),
Values("AnyHitKHR", "ClosestHitKHR", "IntersectionKHR"),
Values("Input"), Values("%f32", "%u32vec3"),
Values("OpCapability RayTracingKHR\n"),
Values("OpExtension \"SPV_KHR_ray_tracing\"\n"),
Values("VUID-PrimitiveId-PrimitiveId-04337"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 32-bit int scalar",
"is not an int scalar"))));
// ObjectRayDirectionKHR and ObjectRayOriginKHR valid
// in IS, AH, CH shaders as input 32-bit float vec3
INSTANTIATE_TEST_SUITE_P(
ObjectRayDirectionAndOriginSuccess,
ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values(SPV_ENV_VULKAN_1_2),
Values("ObjectRayDirectionKHR", "ObjectRayOriginKHR"),
Values("AnyHitKHR", "ClosestHitKHR", "IntersectionKHR"),
Values("Input"), Values("%f32vec3"),
Values("OpCapability RayTracingKHR\n"),
Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), Values(nullptr),
Values(TestResult())));
INSTANTIATE_TEST_SUITE_P(
ObjectRayDirectionAndOriginNotExecutionMode,
ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values(SPV_ENV_VULKAN_1_2),
Values("ObjectRayDirectionKHR", "ObjectRayOriginKHR"),
Values("Vertex", "Fragment", "TessellationControl",
"TessellationEvaluation", "Geometry", "Fragment",
"GLCompute", "RayGenerationKHR", "MissKHR", "CallableKHR"),
Values("Input"), Values("%f32vec3"),
Values("OpCapability RayTracingKHR\n"),
Values("OpExtension \"SPV_KHR_ray_tracing\"\n"),
Values("VUID-ObjectRayDirectionKHR-ObjectRayDirectionKHR-04299 "
"VUID-ObjectRayOriginKHR-ObjectRayOriginKHR-04302 "),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"Vulkan spec does not allow BuiltIn",
"to be used with the execution model"))));
INSTANTIATE_TEST_SUITE_P(
ObjectRayDirectionAndOriginNotInput,
ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values(SPV_ENV_VULKAN_1_2),
Values("ObjectRayDirectionKHR", "ObjectRayOriginKHR"),
Values("AnyHitKHR", "ClosestHitKHR", "IntersectionKHR"),
Values("Output"), Values("%f32vec3"),
Values("OpCapability RayTracingKHR\n"),
Values("OpExtension \"SPV_KHR_ray_tracing\"\n"),
Values("VUID-ObjectRayDirectionKHR-ObjectRayDirectionKHR-04300 "
"VUID-ObjectRayOriginKHR-ObjectRayOriginKHR-04303 "),
Values(TestResult(SPV_ERROR_INVALID_DATA, "Vulkan spec allows",
"used for variables with Input storage class"))));
INSTANTIATE_TEST_SUITE_P(
ObjectRayDirectionAndOriginNotFloatVec3,
ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(
Values(SPV_ENV_VULKAN_1_2),
Values("ObjectRayDirectionKHR", "ObjectRayOriginKHR"),
Values("AnyHitKHR", "ClosestHitKHR", "IntersectionKHR"),
Values("Input"), Values("%u32vec3", "%f32", "%f32vec2", "%f32vec4"),
Values("OpCapability RayTracingKHR\n"),
Values("OpExtension \"SPV_KHR_ray_tracing\"\n"),
Values("VUID-ObjectRayDirectionKHR-ObjectRayDirectionKHR-04301 "
"VUID-ObjectRayOriginKHR-ObjectRayOriginKHR-04304 "),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 3-component 32-bit float vector"))));
// ObjectToWorldKHR and WorldToObjectKHR valid
// in IS, AH, CH shaders as input mat4x3
INSTANTIATE_TEST_SUITE_P(
RTObjectMatrixSuccess,
ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values(SPV_ENV_VULKAN_1_2),
Values("ObjectToWorldKHR", "WorldToObjectKHR"),
Values("AnyHitKHR", "ClosestHitKHR", "IntersectionKHR"),
Values("Input"), Values("%f32mat34"),
Values("OpCapability RayTracingKHR\n"),
Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), Values(nullptr),
Values(TestResult())));
INSTANTIATE_TEST_SUITE_P(
RTObjectMatrixNotExecutionMode,
ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values(SPV_ENV_VULKAN_1_2),
Values("ObjectToWorldKHR", "WorldToObjectKHR"),
Values("Vertex", "Fragment", "TessellationControl",
"TessellationEvaluation", "Geometry", "Fragment",
"GLCompute", "RayGenerationKHR", "MissKHR", "CallableKHR"),
Values("Input"), Values("%f32mat34"),
Values("OpCapability RayTracingKHR\n"),
Values("OpExtension \"SPV_KHR_ray_tracing\"\n"),
Values("VUID-ObjectToWorldKHR-ObjectToWorldKHR-04305 "
"VUID-WorldToObjectKHR-WorldToObjectKHR-04434 "),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"Vulkan spec does not allow BuiltIn",
"to be used with the execution model"))));
INSTANTIATE_TEST_SUITE_P(
RTObjectMatrixNotInput,
ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values(SPV_ENV_VULKAN_1_2),
Values("ObjectToWorldKHR", "WorldToObjectKHR"),
Values("AnyHitKHR", "ClosestHitKHR", "IntersectionKHR"),
Values("Output"), Values("%f32mat34"),
Values("OpCapability RayTracingKHR\n"),
Values("OpExtension \"SPV_KHR_ray_tracing\"\n"),
Values("VUID-ObjectToWorldKHR-ObjectToWorldKHR-04306 "
"VUID-WorldToObjectKHR-WorldToObjectKHR-04435 "),
Values(TestResult(SPV_ERROR_INVALID_DATA, "Vulkan spec allows",
"used for variables with Input storage class"))));
INSTANTIATE_TEST_SUITE_P(
RTObjectMatrixNotMat4x3,
ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values(SPV_ENV_VULKAN_1_2),
Values("ObjectToWorldKHR", "WorldToObjectKHR"),
Values("AnyHitKHR", "ClosestHitKHR", "IntersectionKHR"),
Values("Input"), Values("%f32mat43", "%f32mat44", "%f32vec4"),
Values("OpCapability RayTracingKHR\n"),
Values("OpExtension \"SPV_KHR_ray_tracing\"\n"),
Values("VUID-ObjectToWorldKHR-ObjectToWorldKHR-04307 "
"VUID-WorldToObjectKHR-WorldToObjectKHR-04436 "),
Values(TestResult(
SPV_ERROR_INVALID_DATA,
"variable needs to be a matrix with "
"4 columns of 3-component vectors of 32-bit floats"))));
// IncomingRayFlagsKHR is valid
// in IS, AH, CH, MS shaders as an input i32 scalar
INSTANTIATE_TEST_SUITE_P(
IncomingRayFlagsSuccess,
ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values(SPV_ENV_VULKAN_1_2), Values("IncomingRayFlagsKHR"),
Values("AnyHitKHR", "ClosestHitKHR", "IntersectionKHR", "MissKHR"),
Values("Input"), Values("%u32"),
Values("OpCapability RayTracingKHR\n"),
Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), Values(nullptr),
Values(TestResult())));
INSTANTIATE_TEST_SUITE_P(
IncomingRayFlagsNotExecutionMode,
ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values(SPV_ENV_VULKAN_1_2), Values("IncomingRayFlagsKHR"),
Values("Vertex", "Fragment", "TessellationControl",
"TessellationEvaluation", "Geometry", "Fragment",
"GLCompute", "RayGenerationKHR", "CallableKHR"),
Values("Input"), Values("%u32"),
Values("OpCapability RayTracingKHR\n"),
Values("OpExtension \"SPV_KHR_ray_tracing\"\n"),
Values("VUID-IncomingRayFlagsKHR-IncomingRayFlagsKHR-04248 "
"VUID-RayTmaxKHR-RayTmaxKHR-04348 "
"VUID-RayTminKHR-RayTminKHR-04351 "),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"Vulkan spec does not allow BuiltIn",
"to be used with the execution model"))));
INSTANTIATE_TEST_SUITE_P(
IncomingRayFlagsNotInput,
ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values(SPV_ENV_VULKAN_1_2), Values("IncomingRayFlagsKHR"),
Values("AnyHitKHR", "ClosestHitKHR", "IntersectionKHR", "MissKHR"),
Values("Output"), Values("%u32"),
Values("OpCapability RayTracingKHR\n"),
Values("OpExtension \"SPV_KHR_ray_tracing\"\n"),
Values("VUID-IncomingRayFlagsKHR-IncomingRayFlagsKHR-04249 "
"VUID-RayTmaxKHR-RayTmaxKHR-04349 "
"VUID-RayTminKHR-RayTminKHR-04352 "),
Values(TestResult(SPV_ERROR_INVALID_DATA, "Vulkan spec allows",
"used for variables with Input storage class"))));
INSTANTIATE_TEST_SUITE_P(
IncomingRayFlagsNotIntScalar,
ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values(SPV_ENV_VULKAN_1_2), Values("IncomingRayFlagsKHR"),
Values("AnyHitKHR", "ClosestHitKHR", "IntersectionKHR", "MissKHR"),
Values("Input"), Values("%f32", "%u32vec3"),
Values("OpCapability RayTracingKHR\n"),
Values("OpExtension \"SPV_KHR_ray_tracing\"\n"),
Values("VUID-IncomingRayFlagsKHR-IncomingRayFlagsKHR-04250 "
"VUID-RayTmaxKHR-RayTmaxKHR-04350 "
"VUID-RayTminKHR-RayTminKHR-04353 "),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 32-bit int scalar",
"is not an int scalar"))));
// RayTmaxKHR, RayTminKHR are all valid
// in IS, AH, CH, MS shaders as input f32 scalars
INSTANTIATE_TEST_SUITE_P(
RayTSuccess,
ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values(SPV_ENV_VULKAN_1_2), Values("RayTmaxKHR", "RayTminKHR"),
Values("AnyHitKHR", "ClosestHitKHR", "IntersectionKHR", "MissKHR"),
Values("Input"), Values("%f32"),
Values("OpCapability RayTracingKHR\n"),
Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), Values(nullptr),
Values(TestResult())));
INSTANTIATE_TEST_SUITE_P(
RayTNotExecutionMode,
ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values(SPV_ENV_VULKAN_1_2), Values("RayTmaxKHR", "RayTminKHR"),
Values("Vertex", "Fragment", "TessellationControl",
"TessellationEvaluation", "Geometry", "Fragment",
"GLCompute", "RayGenerationKHR", "CallableKHR"),
Values("Input"), Values("%f32"),
Values("OpCapability RayTracingKHR\n"),
Values("OpExtension \"SPV_KHR_ray_tracing\"\n"),
Values("VUID-IncomingRayFlagsKHR-IncomingRayFlagsKHR-04248 "
"VUID-RayTmaxKHR-RayTmaxKHR-04348 "
"VUID-RayTminKHR-RayTminKHR-04351 "),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"Vulkan spec does not allow BuiltIn",
"to be used with the execution model"))));
INSTANTIATE_TEST_SUITE_P(
RayTNotInput,
ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values(SPV_ENV_VULKAN_1_2), Values("RayTmaxKHR", "RayTminKHR"),
Values("AnyHitKHR", "ClosestHitKHR", "IntersectionKHR", "MissKHR"),
Values("Output"), Values("%f32"),
Values("OpCapability RayTracingKHR\n"),
Values("OpExtension \"SPV_KHR_ray_tracing\"\n"),
Values("VUID-IncomingRayFlagsKHR-IncomingRayFlagsKHR-04249 "
"VUID-RayTmaxKHR-RayTmaxKHR-04349 "
"VUID-RayTminKHR-RayTminKHR-04352 "),
Values(TestResult(SPV_ERROR_INVALID_DATA, "Vulkan spec allows",
"used for variables with Input storage class"))));
INSTANTIATE_TEST_SUITE_P(
RayTNotFloatScalar,
ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values(SPV_ENV_VULKAN_1_2), Values("RayTmaxKHR", "RayTminKHR"),
Values("AnyHitKHR", "ClosestHitKHR", "IntersectionKHR", "MissKHR"),
Values("Input"), Values("%u32", "%f32vec3"),
Values("OpCapability RayTracingKHR\n"),
Values("OpExtension \"SPV_KHR_ray_tracing\"\n"),
Values("VUID-IncomingRayFlagsKHR-IncomingRayFlagsKHR-04250 "
"VUID-RayTmaxKHR-RayTmaxKHR-04350 "
"VUID-RayTminKHR-RayTminKHR-04353 "),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 32-bit float scalar",
"is not a float scalar"))));
// WorldRayDirectionKHR and WorldRayOriginKHR are valid
// in IS, AH, CH, MS shaders as input 32-bit float vec3
INSTANTIATE_TEST_SUITE_P(
WorldRayDirectionAndOriginSuccess,
ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values(SPV_ENV_VULKAN_1_2),
Values("WorldRayDirectionKHR", "WorldRayOriginKHR"),
Values("AnyHitKHR", "ClosestHitKHR", "IntersectionKHR", "MissKHR"),
Values("Input"), Values("%f32vec3"),
Values("OpCapability RayTracingKHR\n"),
Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), Values(nullptr),
Values(TestResult())));
INSTANTIATE_TEST_SUITE_P(
WorldRayDirectionAndOriginNotExecutionMode,
ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values(SPV_ENV_VULKAN_1_2),
Values("WorldRayDirectionKHR", "WorldRayOriginKHR"),
Values("Vertex", "Fragment", "TessellationControl",
"TessellationEvaluation", "Geometry", "Fragment",
"GLCompute", "RayGenerationKHR", "CallableKHR"),
Values("Input"), Values("%f32vec3"),
Values("OpCapability RayTracingKHR\n"),
Values("OpExtension \"SPV_KHR_ray_tracing\"\n"),
Values("VUID-WorldRayDirectionKHR-WorldRayDirectionKHR-04428 "
"VUID-WorldRayOriginKHR-WorldRayOriginKHR-04431 "),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"Vulkan spec does not allow BuiltIn",
"to be used with the execution model"))));
INSTANTIATE_TEST_SUITE_P(
WorldRayDirectionAndOriginNotInput,
ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values(SPV_ENV_VULKAN_1_2),
Values("WorldRayDirectionKHR", "WorldRayOriginKHR"),
Values("AnyHitKHR", "ClosestHitKHR", "IntersectionKHR", "MissKHR"),
Values("Output"), Values("%f32vec3"),
Values("OpCapability RayTracingKHR\n"),
Values("OpExtension \"SPV_KHR_ray_tracing\"\n"),
Values("VUID-WorldRayDirectionKHR-WorldRayDirectionKHR-04429 "
"VUID-WorldRayOriginKHR-WorldRayOriginKHR-04432 "),
Values(TestResult(SPV_ERROR_INVALID_DATA, "Vulkan spec allows",
"used for variables with Input storage class"))));
INSTANTIATE_TEST_SUITE_P(
WorldRayDirectionAndOriginNotFloatVec3,
ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(
Values(SPV_ENV_VULKAN_1_2),
Values("WorldRayDirectionKHR", "WorldRayOriginKHR"),
Values("AnyHitKHR", "ClosestHitKHR", "IntersectionKHR", "MissKHR"),
Values("Input"), Values("%u32vec3", "%f32", "%f32vec2", "%f32vec4"),
Values("OpCapability RayTracingKHR\n"),
Values("OpExtension \"SPV_KHR_ray_tracing\"\n"),
Values("VUID-WorldRayDirectionKHR-WorldRayDirectionKHR-04430 "
"VUID-WorldRayOriginKHR-WorldRayOriginKHR-04433 "),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 3-component 32-bit float vector"))));
// LaunchIdKHR and LaunchSizeKHR are valid
// in RG, IS, AH, CH, MS shaders as input 32-bit ivec3
INSTANTIATE_TEST_SUITE_P(
LaunchRTSuccess,
ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values(SPV_ENV_VULKAN_1_2), Values("LaunchIdKHR", "LaunchSizeKHR"),
Values("RayGenerationKHR", "AnyHitKHR", "ClosestHitKHR",
"IntersectionKHR", "MissKHR", "CallableKHR"),
Values("Input"), Values("%u32vec3"),
Values("OpCapability RayTracingKHR\n"),
Values("OpExtension \"SPV_KHR_ray_tracing\"\n"), Values(nullptr),
Values(TestResult())));
INSTANTIATE_TEST_SUITE_P(
LaunchRTNotExecutionMode,
ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values(SPV_ENV_VULKAN_1_2), Values("LaunchIdKHR", "LaunchSizeKHR"),
Values("Vertex", "Fragment", "TessellationControl",
"TessellationEvaluation", "Geometry", "Fragment",
"GLCompute"),
Values("Input"), Values("%u32vec3"),
Values("OpCapability RayTracingKHR\n"),
Values("OpExtension \"SPV_KHR_ray_tracing\"\n"),
Values("VUID-LaunchIdKHR-LaunchIdKHR-04266 "
"VUID-LaunchSizeKHR-LaunchSizeKHR-04269 "),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"Vulkan spec does not allow BuiltIn",
"to be used with the execution model"))));
INSTANTIATE_TEST_SUITE_P(
LaunchRTNotInput,
ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values(SPV_ENV_VULKAN_1_2), Values("LaunchIdKHR", "LaunchSizeKHR"),
Values("RayGenerationKHR", "AnyHitKHR", "ClosestHitKHR",
"IntersectionKHR", "MissKHR", "CallableKHR"),
Values("Output"), Values("%u32vec3"),
Values("OpCapability RayTracingKHR\n"),
Values("OpExtension \"SPV_KHR_ray_tracing\"\n"),
Values("VUID-LaunchIdKHR-LaunchIdKHR-04267 "
"VUID-LaunchSizeKHR-LaunchSizeKHR-04270 "),
Values(TestResult(SPV_ERROR_INVALID_DATA, "Vulkan spec allows",
"used for variables with Input storage class"))));
INSTANTIATE_TEST_SUITE_P(
LaunchRTNotIntVec3,
ValidateGenericCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values(SPV_ENV_VULKAN_1_2), Values("LaunchIdKHR", "LaunchSizeKHR"),
Values("RayGenerationKHR", "AnyHitKHR", "ClosestHitKHR",
"IntersectionKHR", "MissKHR", "CallableKHR"),
Values("Input"), Values("%f32vec3", "%u32", "%u32vec2", "%u32vec4"),
Values("OpCapability RayTracingKHR\n"),
Values("OpExtension \"SPV_KHR_ray_tracing\"\n"),
Values("VUID-LaunchIdKHR-LaunchIdKHR-04268 "
"VUID-LaunchSizeKHR-LaunchSizeKHR-04271 "),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 3-component 32-bit int vector"))));
CodeGenerator GetArrayedVariableCodeGenerator(const char* const built_in,
const char* const execution_model,
const char* const storage_class,
const char* const data_type) {
CodeGenerator generator = CodeGenerator::GetDefaultShaderCodeGenerator();
generator.before_types_ = "OpDecorate %built_in_var BuiltIn ";
generator.before_types_ += built_in;
generator.before_types_ += "\n";
std::ostringstream after_types;
after_types << "%built_in_array = OpTypeArray " << data_type << " %u32_3\n";
if (InitializerRequired(storage_class)) {
after_types << "%built_in_array_null = OpConstantNull %built_in_array\n";
}
after_types << "%built_in_ptr = OpTypePointer " << storage_class
<< " %built_in_array\n";
after_types << "%built_in_var = OpVariable %built_in_ptr " << storage_class;
if (InitializerRequired(storage_class)) {
after_types << " %built_in_array_null";
}
after_types << "\n";
generator.after_types_ = after_types.str();
EntryPoint entry_point;
entry_point.name = "main";
entry_point.execution_model = execution_model;
entry_point.interfaces = "%built_in_var";
// Any kind of reference would do.
entry_point.body = R"(
%val = OpBitcast %u32 %built_in_var
)";
std::ostringstream execution_modes;
if (0 == std::strcmp(execution_model, "Fragment")) {
execution_modes << "OpExecutionMode %" << entry_point.name
<< " OriginUpperLeft\n";
if (0 == std::strcmp(built_in, "FragDepth")) {
execution_modes << "OpExecutionMode %" << entry_point.name
<< " DepthReplacing\n";
}
}
if (0 == std::strcmp(execution_model, "Geometry")) {
execution_modes << "OpExecutionMode %" << entry_point.name
<< " InputPoints\n";
execution_modes << "OpExecutionMode %" << entry_point.name
<< " OutputPoints\n";
}
if (0 == std::strcmp(execution_model, "GLCompute")) {
execution_modes << "OpExecutionMode %" << entry_point.name
<< " LocalSize 1 1 1\n";
}
entry_point.execution_modes = execution_modes.str();
generator.entry_points_.push_back(std::move(entry_point));
return generator;
}
TEST_P(ValidateVulkanCombineBuiltInArrayedVariable, Variable) {
const char* const built_in = std::get<0>(GetParam());
const char* const execution_model = std::get<1>(GetParam());
const char* const storage_class = std::get<2>(GetParam());
const char* const data_type = std::get<3>(GetParam());
const TestResult& test_result = std::get<4>(GetParam());
CodeGenerator generator = GetArrayedVariableCodeGenerator(
built_in, execution_model, storage_class, data_type);
CompileSuccessfully(generator.Build(), SPV_ENV_VULKAN_1_0);
ASSERT_EQ(test_result.validation_result,
ValidateInstructions(SPV_ENV_VULKAN_1_0));
if (test_result.error_str) {
EXPECT_THAT(getDiagnosticString(), HasSubstr(test_result.error_str));
}
if (test_result.error_str2) {
EXPECT_THAT(getDiagnosticString(), HasSubstr(test_result.error_str2));
}
}
INSTANTIATE_TEST_SUITE_P(PointSizeArrayedF32TessControl,
ValidateVulkanCombineBuiltInArrayedVariable,
Combine(Values("PointSize"),
Values("TessellationControl"), Values("Input"),
Values("%f32"), Values(TestResult())));
INSTANTIATE_TEST_SUITE_P(
PointSizeArrayedF64TessControl, ValidateVulkanCombineBuiltInArrayedVariable,
Combine(Values("PointSize"), Values("TessellationControl"), Values("Input"),
Values("%f64"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 32-bit float scalar",
"has bit width 64"))));
INSTANTIATE_TEST_SUITE_P(
PointSizeArrayedF32Vertex, ValidateVulkanCombineBuiltInArrayedVariable,
Combine(Values("PointSize"), Values("Vertex"), Values("Output"),
Values("%f32"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 32-bit float scalar",
"is not a float scalar"))));
INSTANTIATE_TEST_SUITE_P(PositionArrayedF32Vec4TessControl,
ValidateVulkanCombineBuiltInArrayedVariable,
Combine(Values("Position"),
Values("TessellationControl"), Values("Input"),
Values("%f32vec4"), Values(TestResult())));
INSTANTIATE_TEST_SUITE_P(
PositionArrayedF32Vec3TessControl,
ValidateVulkanCombineBuiltInArrayedVariable,
Combine(Values("Position"), Values("TessellationControl"), Values("Input"),
Values("%f32vec3"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 4-component 32-bit float vector",
"has 3 components"))));
INSTANTIATE_TEST_SUITE_P(
PositionArrayedF32Vec4Vertex, ValidateVulkanCombineBuiltInArrayedVariable,
Combine(Values("Position"), Values("Vertex"), Values("Output"),
Values("%f32vec4"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 4-component 32-bit float vector",
"is not a float vector"))));
INSTANTIATE_TEST_SUITE_P(
ClipAndCullDistanceOutputSuccess,
ValidateVulkanCombineBuiltInArrayedVariable,
Combine(Values("ClipDistance", "CullDistance"),
Values("Geometry", "TessellationControl", "TessellationEvaluation"),
Values("Output"), Values("%f32arr2", "%f32arr4"),
Values(TestResult())));
INSTANTIATE_TEST_SUITE_P(
ClipAndCullDistanceVertexInput, ValidateVulkanCombineBuiltInArrayedVariable,
Combine(Values("ClipDistance", "CullDistance"), Values("Fragment"),
Values("Input"), Values("%f32arr4"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 32-bit float array",
"components are not float scalar"))));
INSTANTIATE_TEST_SUITE_P(
ClipAndCullDistanceNotArray, ValidateVulkanCombineBuiltInArrayedVariable,
Combine(Values("ClipDistance", "CullDistance"),
Values("Geometry", "TessellationControl", "TessellationEvaluation"),
Values("Input"), Values("%f32vec2", "%f32vec4"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 32-bit float array",
"components are not float scalar"))));
INSTANTIATE_TEST_SUITE_P(
SMBuiltinsInputSuccess,
ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values("SMCountNV", "SMIDNV", "WarpsPerSMNV", "WarpIDNV"),
Values("Vertex", "Fragment", "TessellationControl",
"TessellationEvaluation", "Geometry", "GLCompute"),
Values("Input"), Values("%u32"),
Values("OpCapability ShaderSMBuiltinsNV\n"),
Values("OpExtension \"SPV_NV_shader_sm_builtins\"\n"),
Values(nullptr), Values(TestResult())));
INSTANTIATE_TEST_SUITE_P(
SMBuiltinsInputMeshSuccess,
ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(
Values("SMCountNV", "SMIDNV", "WarpsPerSMNV", "WarpIDNV"),
Values("MeshNV", "TaskNV"), Values("Input"), Values("%u32"),
Values("OpCapability ShaderSMBuiltinsNV\nOpCapability MeshShadingNV\n"),
Values("OpExtension \"SPV_NV_shader_sm_builtins\"\nOpExtension "
"\"SPV_NV_mesh_shader\"\n"),
Values(nullptr), Values(TestResult())));
INSTANTIATE_TEST_SUITE_P(
SMBuiltinsInputRaySuccess,
ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(
Values("SMCountNV", "SMIDNV", "WarpsPerSMNV", "WarpIDNV"),
Values("RayGenerationNV", "IntersectionNV", "AnyHitNV", "ClosestHitNV",
"MissNV", "CallableNV"),
Values("Input"), Values("%u32"),
Values("OpCapability ShaderSMBuiltinsNV\nOpCapability RayTracingNV\n"),
Values("OpExtension \"SPV_NV_shader_sm_builtins\"\nOpExtension "
"\"SPV_NV_ray_tracing\"\n"),
Values(nullptr), Values(TestResult())));
INSTANTIATE_TEST_SUITE_P(
SMBuiltinsNotInput,
ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values("SMCountNV", "SMIDNV", "WarpsPerSMNV", "WarpIDNV"),
Values("Vertex", "Fragment", "TessellationControl",
"TessellationEvaluation", "Geometry", "GLCompute"),
Values("Output"), Values("%u32"),
Values("OpCapability ShaderSMBuiltinsNV\n"),
Values("OpExtension \"SPV_NV_shader_sm_builtins\"\n"),
Values(nullptr),
Values(TestResult(
SPV_ERROR_INVALID_DATA,
"to be only used for variables with Input storage class",
"uses storage class Output"))));
INSTANTIATE_TEST_SUITE_P(
SMBuiltinsNotIntScalar,
ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values("SMCountNV", "SMIDNV", "WarpsPerSMNV", "WarpIDNV"),
Values("Vertex", "Fragment", "TessellationControl",
"TessellationEvaluation", "Geometry", "GLCompute"),
Values("Input"), Values("%f32", "%u32vec3"),
Values("OpCapability ShaderSMBuiltinsNV\n"),
Values("OpExtension \"SPV_NV_shader_sm_builtins\"\n"),
Values(nullptr),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 32-bit int scalar",
"is not an int scalar"))));
INSTANTIATE_TEST_SUITE_P(
SMBuiltinsNotInt32,
ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values("SMCountNV", "SMIDNV", "WarpsPerSMNV", "WarpIDNV"),
Values("Vertex", "Fragment", "TessellationControl",
"TessellationEvaluation", "Geometry", "GLCompute"),
Values("Input"), Values("%u64"),
Values("OpCapability ShaderSMBuiltinsNV\n"),
Values("OpExtension \"SPV_NV_shader_sm_builtins\"\n"),
Values(nullptr),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 32-bit int scalar",
"has bit width 64"))));
CodeGenerator GetWorkgroupSizeSuccessGenerator() {
CodeGenerator generator = CodeGenerator::GetDefaultShaderCodeGenerator();
generator.before_types_ = R"(
OpDecorate %workgroup_size BuiltIn WorkgroupSize
)";
generator.after_types_ = R"(
%workgroup_size = OpConstantComposite %u32vec3 %u32_1 %u32_1 %u32_1
)";
EntryPoint entry_point;
entry_point.name = "main";
entry_point.execution_model = "GLCompute";
entry_point.body = R"(
%copy = OpCopyObject %u32vec3 %workgroup_size
)";
generator.entry_points_.push_back(std::move(entry_point));
return generator;
}
TEST_F(ValidateBuiltIns, VulkanWorkgroupSizeSuccess) {
CodeGenerator generator = GetWorkgroupSizeSuccessGenerator();
CompileSuccessfully(generator.Build(), SPV_ENV_VULKAN_1_0);
ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_0));
}
CodeGenerator GetWorkgroupSizeFragmentGenerator() {
CodeGenerator generator = CodeGenerator::GetDefaultShaderCodeGenerator();
generator.before_types_ = R"(
OpDecorate %workgroup_size BuiltIn WorkgroupSize
)";
generator.after_types_ = R"(
%workgroup_size = OpConstantComposite %u32vec3 %u32_1 %u32_1 %u32_1
)";
EntryPoint entry_point;
entry_point.name = "main";
entry_point.execution_model = "Fragment";
entry_point.execution_modes = "OpExecutionMode %main OriginUpperLeft";
entry_point.body = R"(
%copy = OpCopyObject %u32vec3 %workgroup_size
)";
generator.entry_points_.push_back(std::move(entry_point));
return generator;
}
TEST_F(ValidateBuiltIns, VulkanWorkgroupSizeFragment) {
CodeGenerator generator = GetWorkgroupSizeFragmentGenerator();
CompileSuccessfully(generator.Build(), SPV_ENV_VULKAN_1_0);
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0));
EXPECT_THAT(getDiagnosticString(),
HasSubstr("Vulkan spec allows BuiltIn WorkgroupSize to be used "
"only with GLCompute execution model"));
EXPECT_THAT(getDiagnosticString(),
HasSubstr("is referencing ID <2> (OpConstantComposite) which is "
"decorated with BuiltIn WorkgroupSize in function <1> "
"called with execution model Fragment"));
EXPECT_THAT(getDiagnosticString(),
AnyVUID("VUID-WorkgroupSize-WorkgroupSize-04425 "
"VUID-WorkgroupSize-WorkgroupSize-04427"));
}
TEST_F(ValidateBuiltIns, WorkgroupSizeNotConstant) {
CodeGenerator generator = CodeGenerator::GetDefaultShaderCodeGenerator();
generator.before_types_ = R"(
OpDecorate %copy BuiltIn WorkgroupSize
)";
generator.after_types_ = R"(
%workgroup_size = OpConstantComposite %u32vec3 %u32_1 %u32_1 %u32_1
)";
EntryPoint entry_point;
entry_point.name = "main";
entry_point.execution_model = "GLCompute";
entry_point.body = R"(
%copy = OpCopyObject %u32vec3 %workgroup_size
)";
generator.entry_points_.push_back(std::move(entry_point));
CompileSuccessfully(generator.Build(), SPV_ENV_VULKAN_1_0);
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0));
EXPECT_THAT(
getDiagnosticString(),
HasSubstr("BuiltIns can only target variables, structs or constants"));
}
CodeGenerator GetWorkgroupSizeNotVectorGenerator() {
CodeGenerator generator = CodeGenerator::GetDefaultShaderCodeGenerator();
generator.before_types_ = R"(
OpDecorate %workgroup_size BuiltIn WorkgroupSize
)";
generator.after_types_ = R"(
%workgroup_size = OpConstant %u32 16
)";
EntryPoint entry_point;
entry_point.name = "main";
entry_point.execution_model = "GLCompute";
entry_point.body = R"(
%copy = OpCopyObject %u32 %workgroup_size
)";
generator.entry_points_.push_back(std::move(entry_point));
return generator;
}
TEST_F(ValidateBuiltIns, VulkanWorkgroupSizeNotVector) {
CodeGenerator generator = GetWorkgroupSizeNotVectorGenerator();
CompileSuccessfully(generator.Build(), SPV_ENV_VULKAN_1_0);
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0));
EXPECT_THAT(getDiagnosticString(),
HasSubstr("According to the Vulkan spec BuiltIn WorkgroupSize "
"variable needs to be a 3-component 32-bit int vector. "
"ID <2> (OpConstant) is not an int vector."));
EXPECT_THAT(getDiagnosticString(),
AnyVUID("VUID-WorkgroupSize-WorkgroupSize-04427"));
}
CodeGenerator GetWorkgroupSizeNotIntVectorGenerator() {
CodeGenerator generator = CodeGenerator::GetDefaultShaderCodeGenerator();
generator.before_types_ = R"(
OpDecorate %workgroup_size BuiltIn WorkgroupSize
)";
generator.after_types_ = R"(
%workgroup_size = OpConstantComposite %f32vec3 %f32_1 %f32_1 %f32_1
)";
EntryPoint entry_point;
entry_point.name = "main";
entry_point.execution_model = "GLCompute";
entry_point.body = R"(
%copy = OpCopyObject %f32vec3 %workgroup_size
)";
generator.entry_points_.push_back(std::move(entry_point));
return generator;
}
TEST_F(ValidateBuiltIns, VulkanWorkgroupSizeNotIntVector) {
CodeGenerator generator = GetWorkgroupSizeNotIntVectorGenerator();
CompileSuccessfully(generator.Build(), SPV_ENV_VULKAN_1_0);
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0));
EXPECT_THAT(getDiagnosticString(),
HasSubstr("According to the Vulkan spec BuiltIn WorkgroupSize "
"variable needs to be a 3-component 32-bit int vector. "
"ID <2> (OpConstantComposite) is not an int vector."));
EXPECT_THAT(getDiagnosticString(),
AnyVUID("VUID-WorkgroupSize-WorkgroupSize-04427"));
}
CodeGenerator GetWorkgroupSizeNotVec3Generator() {
CodeGenerator generator = CodeGenerator::GetDefaultShaderCodeGenerator();
generator.before_types_ = R"(
OpDecorate %workgroup_size BuiltIn WorkgroupSize
)";
generator.after_types_ = R"(
%workgroup_size = OpConstantComposite %u32vec2 %u32_1 %u32_1
)";
EntryPoint entry_point;
entry_point.name = "main";
entry_point.execution_model = "GLCompute";
entry_point.body = R"(
%copy = OpCopyObject %u32vec2 %workgroup_size
)";
generator.entry_points_.push_back(std::move(entry_point));
return generator;
}
TEST_F(ValidateBuiltIns, VulkanWorkgroupSizeNotVec3) {
CodeGenerator generator = GetWorkgroupSizeNotVec3Generator();
CompileSuccessfully(generator.Build(), SPV_ENV_VULKAN_1_0);
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0));
EXPECT_THAT(getDiagnosticString(),
HasSubstr("According to the Vulkan spec BuiltIn WorkgroupSize "
"variable needs to be a 3-component 32-bit int vector. "
"ID <2> (OpConstantComposite) has 2 components."));
EXPECT_THAT(getDiagnosticString(),
AnyVUID("VUID-WorkgroupSize-WorkgroupSize-04427"));
}
TEST_F(ValidateBuiltIns, WorkgroupSizeNotInt32Vec) {
CodeGenerator generator = CodeGenerator::GetDefaultShaderCodeGenerator();
generator.before_types_ = R"(
OpDecorate %workgroup_size BuiltIn WorkgroupSize
)";
generator.after_types_ = R"(
%workgroup_size = OpConstantComposite %u64vec3 %u64_1 %u64_1 %u64_1
)";
EntryPoint entry_point;
entry_point.name = "main";
entry_point.execution_model = "GLCompute";
entry_point.body = R"(
%copy = OpCopyObject %u64vec3 %workgroup_size
)";
generator.entry_points_.push_back(std::move(entry_point));
CompileSuccessfully(generator.Build(), SPV_ENV_VULKAN_1_0);
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0));
EXPECT_THAT(
getDiagnosticString(),
HasSubstr("According to the Vulkan spec BuiltIn WorkgroupSize variable "
"needs to be a 3-component 32-bit int vector. ID <2> "
"(OpConstantComposite) has components with bit width 64."));
EXPECT_THAT(getDiagnosticString(),
AnyVUID("VUID-WorkgroupSize-WorkgroupSize-04427"));
}
TEST_F(ValidateBuiltIns, WorkgroupSizePrivateVar) {
CodeGenerator generator = CodeGenerator::GetDefaultShaderCodeGenerator();
generator.before_types_ = R"(
OpDecorate %workgroup_size BuiltIn WorkgroupSize
)";
generator.after_types_ = R"(
%workgroup_size = OpConstantComposite %u32vec3 %u32_1 %u32_1 %u32_1
%private_ptr_u32vec3 = OpTypePointer Private %u32vec3
%var = OpVariable %private_ptr_u32vec3 Private %workgroup_size
)";
EntryPoint entry_point;
entry_point.name = "main";
entry_point.execution_model = "GLCompute";
entry_point.body = R"(
)";
generator.entry_points_.push_back(std::move(entry_point));
CompileSuccessfully(generator.Build(), SPV_ENV_VULKAN_1_0);
ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_0));
}
TEST_F(ValidateBuiltIns, GeometryPositionInOutSuccess) {
CodeGenerator generator = CodeGenerator::GetDefaultShaderCodeGenerator();
generator.before_types_ = R"(
OpDecorate %input_type Block
OpMemberDecorate %input_type 0 BuiltIn Position
OpDecorate %output_type Block
OpMemberDecorate %output_type 0 BuiltIn Position
)";
generator.after_types_ = R"(
%input_type = OpTypeStruct %f32vec4
%arrayed_input_type = OpTypeArray %input_type %u32_3
%input_ptr = OpTypePointer Input %arrayed_input_type
%input = OpVariable %input_ptr Input
%input_f32vec4_ptr = OpTypePointer Input %f32vec4
%output_type = OpTypeStruct %f32vec4
%output_ptr = OpTypePointer Output %output_type
%output = OpVariable %output_ptr Output
%output_f32vec4_ptr = OpTypePointer Output %f32vec4
)";
EntryPoint entry_point;
entry_point.name = "main";
entry_point.execution_model = "Geometry";
entry_point.interfaces = "%input %output";
entry_point.body = R"(
%input_pos = OpAccessChain %input_f32vec4_ptr %input %u32_0 %u32_0
%output_pos = OpAccessChain %output_f32vec4_ptr %output %u32_0
%pos = OpLoad %f32vec4 %input_pos
OpStore %output_pos %pos
)";
generator.entry_points_.push_back(std::move(entry_point));
generator.entry_points_[0].execution_modes =
"OpExecutionMode %main InputPoints\nOpExecutionMode %main OutputPoints\n";
CompileSuccessfully(generator.Build(), SPV_ENV_VULKAN_1_0);
ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_0));
}
TEST_F(ValidateBuiltIns, WorkgroupIdNotVec3) {
CodeGenerator generator = CodeGenerator::GetDefaultShaderCodeGenerator();
generator.before_types_ = R"(
OpDecorate %workgroup_size BuiltIn WorkgroupSize
OpDecorate %workgroup_id BuiltIn WorkgroupId
)";
generator.after_types_ = R"(
%workgroup_size = OpConstantComposite %u32vec3 %u32_1 %u32_1 %u32_1
%input_ptr = OpTypePointer Input %u32vec2
%workgroup_id = OpVariable %input_ptr Input
)";
EntryPoint entry_point;
entry_point.name = "main";
entry_point.execution_model = "GLCompute";
entry_point.interfaces = "%workgroup_id";
entry_point.body = R"(
%copy_size = OpCopyObject %u32vec3 %workgroup_size
%load_id = OpLoad %u32vec2 %workgroup_id
)";
generator.entry_points_.push_back(std::move(entry_point));
CompileSuccessfully(generator.Build(), SPV_ENV_VULKAN_1_0);
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0));
EXPECT_THAT(getDiagnosticString(),
HasSubstr("According to the Vulkan spec BuiltIn WorkgroupId "
"variable needs to be a 3-component 32-bit int vector. "
"ID <2> (OpVariable) has 2 components."));
}
TEST_F(ValidateBuiltIns, TwoBuiltInsFirstFails) {
CodeGenerator generator = CodeGenerator::GetDefaultShaderCodeGenerator();
generator.before_types_ = R"(
OpMemberDecorate %input_type 0 BuiltIn FragCoord
OpMemberDecorate %output_type 0 BuiltIn Position
)";
generator.after_types_ = R"(
%input_type = OpTypeStruct %f32vec4
%input_ptr = OpTypePointer Input %input_type
%input = OpVariable %input_ptr Input
%input_f32vec4_ptr = OpTypePointer Input %f32vec4
%output_type = OpTypeStruct %f32vec4
%output_ptr = OpTypePointer Output %output_type
%output = OpVariable %output_ptr Output
%output_f32vec4_ptr = OpTypePointer Output %f32vec4
)";
EntryPoint entry_point;
entry_point.name = "main";
entry_point.execution_model = "Geometry";
entry_point.interfaces = "%input %output";
entry_point.body = R"(
%input_pos = OpAccessChain %input_f32vec4_ptr %input %u32_0
%output_pos = OpAccessChain %output_f32vec4_ptr %output %u32_0
%pos = OpLoad %f32vec4 %input_pos
OpStore %output_pos %pos
)";
generator.entry_points_.push_back(std::move(entry_point));
generator.entry_points_[0].execution_modes =
"OpExecutionMode %main InputPoints\nOpExecutionMode %main OutputPoints\n";
CompileSuccessfully(generator.Build(), SPV_ENV_VULKAN_1_0);
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0));
EXPECT_THAT(getDiagnosticString(),
HasSubstr("Vulkan spec allows BuiltIn FragCoord to be used only "
"with Fragment execution model"));
}
TEST_F(ValidateBuiltIns, TwoBuiltInsSecondFails) {
CodeGenerator generator = CodeGenerator::GetDefaultShaderCodeGenerator();
generator.before_types_ = R"(
OpMemberDecorate %input_type 0 BuiltIn Position
OpMemberDecorate %output_type 0 BuiltIn FragCoord
)";
generator.after_types_ = R"(
%input_type = OpTypeStruct %f32vec4
%input_ptr = OpTypePointer Input %input_type
%input = OpVariable %input_ptr Input
%input_f32vec4_ptr = OpTypePointer Input %f32vec4
%output_type = OpTypeStruct %f32vec4
%output_ptr = OpTypePointer Output %output_type
%output = OpVariable %output_ptr Output
%output_f32vec4_ptr = OpTypePointer Output %f32vec4
)";
EntryPoint entry_point;
entry_point.name = "main";
entry_point.execution_model = "Geometry";
entry_point.interfaces = "%input %output";
entry_point.body = R"(
%input_pos = OpAccessChain %input_f32vec4_ptr %input %u32_0
%output_pos = OpAccessChain %output_f32vec4_ptr %output %u32_0
%pos = OpLoad %f32vec4 %input_pos
OpStore %output_pos %pos
)";
generator.entry_points_.push_back(std::move(entry_point));
generator.entry_points_[0].execution_modes =
"OpExecutionMode %main InputPoints\nOpExecutionMode %main OutputPoints\n";
CompileSuccessfully(generator.Build(), SPV_ENV_VULKAN_1_0);
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0));
EXPECT_THAT(getDiagnosticString(),
HasSubstr("Vulkan spec allows BuiltIn FragCoord to be only used "
"for variables with Input storage class"));
}
TEST_F(ValidateBuiltIns, VertexPositionVariableSuccess) {
CodeGenerator generator = CodeGenerator::GetDefaultShaderCodeGenerator();
generator.before_types_ = R"(
OpDecorate %position BuiltIn Position
)";
generator.after_types_ = R"(
%f32vec4_ptr_output = OpTypePointer Output %f32vec4
%position = OpVariable %f32vec4_ptr_output Output
)";
EntryPoint entry_point;
entry_point.name = "main";
entry_point.execution_model = "Vertex";
entry_point.interfaces = "%position";
entry_point.body = R"(
OpStore %position %f32vec4_0123
)";
generator.entry_points_.push_back(std::move(entry_point));
CompileSuccessfully(generator.Build(), SPV_ENV_VULKAN_1_0);
ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_0));
}
TEST_F(ValidateBuiltIns, FragmentPositionTwoEntryPoints) {
CodeGenerator generator = CodeGenerator::GetDefaultShaderCodeGenerator();
generator.before_types_ = R"(
OpMemberDecorate %output_type 0 BuiltIn Position
)";
generator.after_types_ = R"(
%output_type = OpTypeStruct %f32vec4
%output_ptr = OpTypePointer Output %output_type
%output = OpVariable %output_ptr Output
%output_f32vec4_ptr = OpTypePointer Output %f32vec4
)";
EntryPoint entry_point;
entry_point.name = "vmain";
entry_point.execution_model = "Vertex";
entry_point.interfaces = "%output";
entry_point.body = R"(
%val1 = OpFunctionCall %void %foo
)";
generator.entry_points_.push_back(std::move(entry_point));
entry_point.name = "fmain";
entry_point.execution_model = "Fragment";
entry_point.interfaces = "%output";
entry_point.execution_modes = "OpExecutionMode %fmain OriginUpperLeft";
entry_point.body = R"(
%val2 = OpFunctionCall %void %foo
)";
generator.entry_points_.push_back(std::move(entry_point));
generator.add_at_the_end_ = R"(
%foo = OpFunction %void None %func
%foo_entry = OpLabel
%position = OpAccessChain %output_f32vec4_ptr %output %u32_0
OpStore %position %f32vec4_0123
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(generator.Build(), SPV_ENV_VULKAN_1_0);
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0));
EXPECT_THAT(getDiagnosticString(),
HasSubstr("Vulkan spec allows BuiltIn Position to be used only "
"with Vertex, TessellationControl, "
"TessellationEvaluation or Geometry execution models"));
EXPECT_THAT(getDiagnosticString(),
HasSubstr("called with execution model Fragment"));
}
CodeGenerator GetNoDepthReplacingGenerator() {
CodeGenerator generator = CodeGenerator::GetDefaultShaderCodeGenerator();
generator.before_types_ = R"(
OpMemberDecorate %output_type 0 BuiltIn FragDepth
)";
generator.after_types_ = R"(
%output_type = OpTypeStruct %f32
%output_null = OpConstantNull %output_type
%output_ptr = OpTypePointer Output %output_type
%output = OpVariable %output_ptr Output %output_null
%output_f32_ptr = OpTypePointer Output %f32
)";
EntryPoint entry_point;
entry_point.name = "main";
entry_point.execution_model = "Fragment";
entry_point.interfaces = "%output";
entry_point.execution_modes = "OpExecutionMode %main OriginUpperLeft";
entry_point.body = R"(
%val2 = OpFunctionCall %void %foo
)";
generator.entry_points_.push_back(std::move(entry_point));
const std::string function_body = R"(
%foo = OpFunction %void None %func
%foo_entry = OpLabel
%frag_depth = OpAccessChain %output_f32_ptr %output %u32_0
OpStore %frag_depth %f32_1
OpReturn
OpFunctionEnd
)";
generator.add_at_the_end_ = function_body;
return generator;
}
TEST_F(ValidateBuiltIns, VulkanFragmentFragDepthNoDepthReplacing) {
CodeGenerator generator = GetNoDepthReplacingGenerator();
CompileSuccessfully(generator.Build(), SPV_ENV_VULKAN_1_0);
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0));
EXPECT_THAT(getDiagnosticString(),
HasSubstr("Vulkan spec requires DepthReplacing execution mode to "
"be declared when using BuiltIn FragDepth"));
EXPECT_THAT(getDiagnosticString(),
HasSubstr("VUID-FragDepth-FragDepth-04216"));
}
CodeGenerator GetOneMainHasDepthReplacingOtherHasntGenerator() {
CodeGenerator generator = CodeGenerator::GetDefaultShaderCodeGenerator();
generator.before_types_ = R"(
OpMemberDecorate %output_type 0 BuiltIn FragDepth
)";
generator.after_types_ = R"(
%output_type = OpTypeStruct %f32
%output_null = OpConstantNull %output_type
%output_ptr = OpTypePointer Output %output_type
%output = OpVariable %output_ptr Output %output_null
%output_f32_ptr = OpTypePointer Output %f32
)";
EntryPoint entry_point;
entry_point.name = "main_d_r";
entry_point.execution_model = "Fragment";
entry_point.interfaces = "%output";
entry_point.execution_modes =
"OpExecutionMode %main_d_r OriginUpperLeft\n"
"OpExecutionMode %main_d_r DepthReplacing";
entry_point.body = R"(
%val2 = OpFunctionCall %void %foo
)";
generator.entry_points_.push_back(std::move(entry_point));
entry_point.name = "main_no_d_r";
entry_point.execution_model = "Fragment";
entry_point.interfaces = "%output";
entry_point.execution_modes = "OpExecutionMode %main_no_d_r OriginUpperLeft";
entry_point.body = R"(
%val3 = OpFunctionCall %void %foo
)";
generator.entry_points_.push_back(std::move(entry_point));
const std::string function_body = R"(
%foo = OpFunction %void None %func
%foo_entry = OpLabel
%frag_depth = OpAccessChain %output_f32_ptr %output %u32_0
OpStore %frag_depth %f32_1
OpReturn
OpFunctionEnd
)";
generator.add_at_the_end_ = function_body;
return generator;
}
TEST_F(ValidateBuiltIns,
VulkanFragmentFragDepthOneMainHasDepthReplacingOtherHasnt) {
CodeGenerator generator = GetOneMainHasDepthReplacingOtherHasntGenerator();
CompileSuccessfully(generator.Build(), SPV_ENV_VULKAN_1_0);
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_0));
EXPECT_THAT(getDiagnosticString(),
HasSubstr("Vulkan spec requires DepthReplacing execution mode to "
"be declared when using BuiltIn FragDepth"));
EXPECT_THAT(getDiagnosticString(),
HasSubstr("VUID-FragDepth-FragDepth-04216"));
}
TEST_F(ValidateBuiltIns, AllowInstanceIdWithIntersectionShader) {
CodeGenerator generator = CodeGenerator::GetDefaultShaderCodeGenerator();
generator.capabilities_ += R"(
OpCapability RayTracingNV
)";
generator.extensions_ = R"(
OpExtension "SPV_NV_ray_tracing"
)";
generator.before_types_ = R"(
OpMemberDecorate %input_type 0 BuiltIn InstanceId
)";
generator.after_types_ = R"(
%input_type = OpTypeStruct %u32
%input_ptr = OpTypePointer Input %input_type
%input = OpVariable %input_ptr Input
)";
EntryPoint entry_point;
entry_point.name = "main_d_r";
entry_point.execution_model = "IntersectionNV";
entry_point.interfaces = "%input";
entry_point.body = R"(
%val2 = OpFunctionCall %void %foo
)";
generator.entry_points_.push_back(std::move(entry_point));
generator.add_at_the_end_ = R"(
%foo = OpFunction %void None %func
%foo_entry = OpLabel
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(generator.Build(), SPV_ENV_VULKAN_1_0);
EXPECT_THAT(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_0));
}
TEST_F(ValidateBuiltIns, ValidBuiltinsForMeshShader) {
CodeGenerator generator = CodeGenerator::GetDefaultShaderCodeGenerator();
generator.capabilities_ += R"(
OpCapability MeshShadingNV
)";
generator.extensions_ = R"(
OpExtension "SPV_NV_mesh_shader"
)";
generator.before_types_ = R"(
OpDecorate %gl_PrimitiveID BuiltIn PrimitiveId
OpDecorate %gl_PrimitiveID PerPrimitiveNV
OpDecorate %gl_Layer BuiltIn Layer
OpDecorate %gl_Layer PerPrimitiveNV
OpDecorate %gl_ViewportIndex BuiltIn ViewportIndex
OpDecorate %gl_ViewportIndex PerPrimitiveNV
)";
generator.after_types_ = R"(
%u32_81 = OpConstant %u32 81
%_arr_int_uint_81 = OpTypeArray %i32 %u32_81
%_ptr_Output__arr_int_uint_81 = OpTypePointer Output %_arr_int_uint_81
%gl_PrimitiveID = OpVariable %_ptr_Output__arr_int_uint_81 Output
%gl_Layer = OpVariable %_ptr_Output__arr_int_uint_81 Output
%gl_ViewportIndex = OpVariable %_ptr_Output__arr_int_uint_81 Output
)";
EntryPoint entry_point;
entry_point.name = "main_d_r";
entry_point.execution_model = "MeshNV";
entry_point.interfaces = "%gl_PrimitiveID %gl_Layer %gl_ViewportIndex";
generator.entry_points_.push_back(std::move(entry_point));
CompileSuccessfully(generator.Build(), SPV_ENV_VULKAN_1_1);
ASSERT_EQ(SPV_SUCCESS, ValidateInstructions(SPV_ENV_VULKAN_1_1));
}
TEST_F(ValidateBuiltIns, InvalidBuiltinsForMeshShader) {
CodeGenerator generator = CodeGenerator::GetDefaultShaderCodeGenerator();
generator.capabilities_ += R"(
OpCapability MeshShadingNV
)";
generator.extensions_ = R"(
OpExtension "SPV_NV_mesh_shader"
)";
generator.before_types_ = R"(
OpDecorate %gl_PrimitiveID BuiltIn PrimitiveId
OpDecorate %gl_PrimitiveID PerPrimitiveNV
OpDecorate %gl_Layer BuiltIn Layer
OpDecorate %gl_Layer PerPrimitiveNV
OpDecorate %gl_ViewportIndex BuiltIn ViewportIndex
OpDecorate %gl_ViewportIndex PerPrimitiveNV
)";
generator.after_types_ = R"(
%u32_81 = OpConstant %u32 81
%_arr_float_uint_81 = OpTypeArray %f32 %u32_81
%_ptr_Output__arr_float_uint_81 = OpTypePointer Output %_arr_float_uint_81
%gl_PrimitiveID = OpVariable %_ptr_Output__arr_float_uint_81 Output
%gl_Layer = OpVariable %_ptr_Output__arr_float_uint_81 Output
%gl_ViewportIndex = OpVariable %_ptr_Output__arr_float_uint_81 Output
)";
EntryPoint entry_point;
entry_point.name = "main_d_r";
entry_point.execution_model = "MeshNV";
entry_point.interfaces = "%gl_PrimitiveID %gl_Layer %gl_ViewportIndex";
generator.entry_points_.push_back(std::move(entry_point));
CompileSuccessfully(generator.Build(), SPV_ENV_VULKAN_1_1);
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_1));
EXPECT_THAT(getDiagnosticString(),
HasSubstr("needs to be a 32-bit int scalar"));
EXPECT_THAT(getDiagnosticString(), HasSubstr("is not an int scalar"));
}
TEST_F(ValidateBuiltIns, GetUnderlyingTypeNoAssert) {
std::string spirv = R"(
OpCapability Shader
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %4 "PSMa" %12 %17
OpExecutionMode %4 OriginUpperLeft
OpDecorate %gl_PointCoord BuiltIn PointCoord
OpDecorate %12 Location 0
OpDecorate %17 Location 0
%void = OpTypeVoid
%3 = OpTypeFunction %void
%float = OpTypeFloat 32
%v4float = OpTypeVector %float 4
%gl_PointCoord = OpTypeStruct %v4float
%_ptr_Input_v4float = OpTypePointer Input %v4float
%_ptr_Output_v4float = OpTypePointer Output %v4float
%12 = OpVariable %_ptr_Input_v4float Input
%17 = OpVariable %_ptr_Output_v4float Output
%4 = OpFunction %void None %3
%15 = OpLabel
OpReturn
OpFunctionEnd)";
CompileSuccessfully(spirv, SPV_ENV_VULKAN_1_1);
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_1));
EXPECT_THAT(getDiagnosticString(),
HasSubstr("did not find an member index to get underlying data "
"type"));
}
TEST_P(ValidateVulkanSubgroupBuiltIns, InMain) {
const char* const built_in = std::get<0>(GetParam());
const char* const execution_model = std::get<1>(GetParam());
const char* const storage_class = std::get<2>(GetParam());
const char* const data_type = std::get<3>(GetParam());
const char* const vuid = std::get<4>(GetParam());
const TestResult& test_result = std::get<5>(GetParam());
CodeGenerator generator = CodeGenerator::GetDefaultShaderCodeGenerator();
generator.capabilities_ += R"(
OpCapability GroupNonUniformBallot
)";
generator.before_types_ = "OpDecorate %built_in_var BuiltIn ";
generator.before_types_ += built_in;
generator.before_types_ += "\n";
std::ostringstream after_types;
after_types << "%built_in_ptr = OpTypePointer " << storage_class << " "
<< data_type << "\n";
after_types << "%built_in_var = OpVariable %built_in_ptr " << storage_class;
after_types << "\n";
generator.after_types_ = after_types.str();
EntryPoint entry_point;
entry_point.name = "main";
entry_point.execution_model = execution_model;
if (strncmp(storage_class, "Input", 5) == 0 ||
strncmp(storage_class, "Output", 6) == 0) {
entry_point.interfaces = "%built_in_var";
}
entry_point.body =
std::string("%ld = OpLoad ") + data_type + " %built_in_var\n";
std::ostringstream execution_modes;
if (0 == std::strcmp(execution_model, "Fragment")) {
execution_modes << "OpExecutionMode %" << entry_point.name
<< " OriginUpperLeft\n";
if (0 == std::strcmp(built_in, "FragDepth")) {
execution_modes << "OpExecutionMode %" << entry_point.name
<< " DepthReplacing\n";
}
}
if (0 == std::strcmp(execution_model, "Geometry")) {
execution_modes << "OpExecutionMode %" << entry_point.name
<< " InputPoints\n";
execution_modes << "OpExecutionMode %" << entry_point.name
<< " OutputPoints\n";
}
if (0 == std::strcmp(execution_model, "GLCompute")) {
execution_modes << "OpExecutionMode %" << entry_point.name
<< " LocalSize 1 1 1\n";
}
entry_point.execution_modes = execution_modes.str();
generator.entry_points_.push_back(std::move(entry_point));
CompileSuccessfully(generator.Build(), SPV_ENV_VULKAN_1_1);
ASSERT_EQ(test_result.validation_result,
ValidateInstructions(SPV_ENV_VULKAN_1_1));
if (test_result.error_str) {
EXPECT_THAT(getDiagnosticString(), HasSubstr(test_result.error_str));
}
if (test_result.error_str2) {
EXPECT_THAT(getDiagnosticString(), HasSubstr(test_result.error_str2));
}
if (vuid) {
EXPECT_THAT(getDiagnosticString(), AnyVUID(vuid));
}
}
INSTANTIATE_TEST_SUITE_P(
SubgroupMaskNotVec4, ValidateVulkanSubgroupBuiltIns,
Combine(Values("SubgroupEqMask", "SubgroupGeMask", "SubgroupGtMask",
"SubgroupLeMask", "SubgroupLtMask"),
Values("GLCompute"), Values("Input"), Values("%u32vec3"),
Values("VUID-SubgroupEqMask-SubgroupEqMask-04371 "
"VUID-SubgroupGeMask-SubgroupGeMask-04373 "
"VUID-SubgroupGtMask-SubgroupGtMask-04375 "
"VUID-SubgroupLeMask-SubgroupLeMask-04377 "
"VUID-SubgroupLtMask-SubgroupLtMask-04379"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 4-component 32-bit int vector"))));
INSTANTIATE_TEST_SUITE_P(
SubgroupMaskNotU32, ValidateVulkanSubgroupBuiltIns,
Combine(Values("SubgroupEqMask", "SubgroupGeMask", "SubgroupGtMask",
"SubgroupLeMask", "SubgroupLtMask"),
Values("GLCompute"), Values("Input"), Values("%f32vec4"),
Values("VUID-SubgroupEqMask-SubgroupEqMask-04371 "
"VUID-SubgroupGeMask-SubgroupGeMask-04373 "
"VUID-SubgroupGtMask-SubgroupGtMask-04375 "
"VUID-SubgroupLeMask-SubgroupLeMask-04377 "
"VUID-SubgroupLtMask-SubgroupLtMask-04379"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 4-component 32-bit int vector"))));
INSTANTIATE_TEST_SUITE_P(
SubgroupMaskNotInput, ValidateVulkanSubgroupBuiltIns,
Combine(Values("SubgroupEqMask", "SubgroupGeMask", "SubgroupGtMask",
"SubgroupLeMask", "SubgroupLtMask"),
Values("GLCompute"), Values("Output", "Workgroup", "Private"),
Values("%u32vec4"),
Values("VUID-SubgroupEqMask-SubgroupEqMask-04370 "
"VUID-SubgroupGeMask-SubgroupGeMask-04372 "
"VUID-SubgroupGtMask-SubgroupGtMask-04374 "
"VUID-SubgroupLeMask-SubgroupLeMask-04376 "
"VUID-SubgroupLtMask-SubgroupLtMask-04378"),
Values(TestResult(
SPV_ERROR_INVALID_DATA,
"to be only used for variables with Input storage class"))));
INSTANTIATE_TEST_SUITE_P(SubgroupMaskOk, ValidateVulkanSubgroupBuiltIns,
Combine(Values("SubgroupEqMask", "SubgroupGeMask",
"SubgroupGtMask", "SubgroupLeMask",
"SubgroupLtMask"),
Values("GLCompute"), Values("Input"),
Values("%u32vec4"), Values(nullptr),
Values(TestResult(SPV_SUCCESS, ""))));
TEST_F(ValidateBuiltIns, SubgroupMaskMemberDecorate) {
const std::string text = R"(
OpCapability Shader
OpCapability GroupNonUniformBallot
OpMemoryModel Logical GLSL450
OpEntryPoint GLCompute %foo "foo"
OpExecutionMode %foo LocalSize 1 1 1
OpMemberDecorate %struct 0 BuiltIn SubgroupEqMask
%void = OpTypeVoid
%int = OpTypeInt 32 0
%struct = OpTypeStruct %int
%void_fn = OpTypeFunction %void
%foo = OpFunction %void None %void_fn
%entry = OpLabel
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(text, SPV_ENV_VULKAN_1_1);
EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_1));
EXPECT_THAT(
getDiagnosticString(),
HasSubstr(
"BuiltIn SubgroupEqMask cannot be used as a member decoration"));
}
INSTANTIATE_TEST_SUITE_P(
SubgroupInvocationIdAndSizeNotU32, ValidateVulkanSubgroupBuiltIns,
Combine(
Values("SubgroupLocalInvocationId", "SubgroupSize"),
Values("GLCompute"), Values("Input"), Values("%f32"),
Values("VUID-SubgroupLocalInvocationId-SubgroupLocalInvocationId-04381 "
"VUID-SubgroupSize-SubgroupSize-04383"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 32-bit int"))));
INSTANTIATE_TEST_SUITE_P(
SubgroupInvocationIdAndSizeNotInput, ValidateVulkanSubgroupBuiltIns,
Combine(
Values("SubgroupLocalInvocationId", "SubgroupSize"),
Values("GLCompute"), Values("Output", "Workgroup", "Private"),
Values("%u32"),
Values("VUID-SubgroupLocalInvocationId-SubgroupLocalInvocationId-04380 "
"VUID-SubgroupSize-SubgroupSize-04382"),
Values(TestResult(
SPV_ERROR_INVALID_DATA,
"to be only used for variables with Input storage class"))));
INSTANTIATE_TEST_SUITE_P(
SubgroupInvocationIdAndSizeOk, ValidateVulkanSubgroupBuiltIns,
Combine(Values("SubgroupLocalInvocationId", "SubgroupSize"),
Values("GLCompute"), Values("Input"), Values("%u32"),
Values(nullptr), Values(TestResult(SPV_SUCCESS, ""))));
TEST_F(ValidateBuiltIns, SubgroupSizeMemberDecorate) {
const std::string text = R"(
OpCapability Shader
OpCapability GroupNonUniform
OpMemoryModel Logical GLSL450
OpEntryPoint GLCompute %foo "foo"
OpExecutionMode %foo LocalSize 1 1 1
OpMemberDecorate %struct 0 BuiltIn SubgroupSize
%void = OpTypeVoid
%int = OpTypeInt 32 0
%struct = OpTypeStruct %int
%void_fn = OpTypeFunction %void
%foo = OpFunction %void None %void_fn
%entry = OpLabel
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(text, SPV_ENV_VULKAN_1_1);
EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_1));
EXPECT_THAT(
getDiagnosticString(),
HasSubstr("BuiltIn SubgroupSize cannot be used as a member decoration"));
}
INSTANTIATE_TEST_SUITE_P(
SubgroupNumAndIdNotCompute, ValidateVulkanSubgroupBuiltIns,
Combine(
Values("SubgroupId", "NumSubgroups"), Values("Vertex"), Values("Input"),
Values("%u32"),
Values("VUID-SubgroupId-SubgroupId-04367 "
"VUID-NumSubgroups-NumSubgroups-04293"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"to be used only with GLCompute execution model"))));
INSTANTIATE_TEST_SUITE_P(
SubgroupNumAndIdNotU32, ValidateVulkanSubgroupBuiltIns,
Combine(Values("SubgroupId", "NumSubgroups"), Values("GLCompute"),
Values("Input"), Values("%f32"),
Values("VUID-SubgroupId-SubgroupId-04369 "
"VUID-NumSubgroups-NumSubgroups-04295"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"needs to be a 32-bit int"))));
INSTANTIATE_TEST_SUITE_P(
SubgroupNumAndIdNotInput, ValidateVulkanSubgroupBuiltIns,
Combine(Values("SubgroupId", "NumSubgroups"), Values("GLCompute"),
Values("Output", "Workgroup", "Private"), Values("%u32"),
Values("VUID-SubgroupId-SubgroupId-04368 "
"VUID-NumSubgroups-NumSubgroups-04294"),
Values(TestResult(
SPV_ERROR_INVALID_DATA,
"to be only used for variables with Input storage class"))));
INSTANTIATE_TEST_SUITE_P(SubgroupNumAndIdOk, ValidateVulkanSubgroupBuiltIns,
Combine(Values("SubgroupId", "NumSubgroups"),
Values("GLCompute"), Values("Input"),
Values("%u32"), Values(nullptr),
Values(TestResult(SPV_SUCCESS, ""))));
TEST_F(ValidateBuiltIns, SubgroupIdMemberDecorate) {
const std::string text = R"(
OpCapability Shader
OpCapability GroupNonUniform
OpMemoryModel Logical GLSL450
OpEntryPoint GLCompute %foo "foo"
OpExecutionMode %foo LocalSize 1 1 1
OpMemberDecorate %struct 0 BuiltIn SubgroupId
%void = OpTypeVoid
%int = OpTypeInt 32 0
%struct = OpTypeStruct %int
%void_fn = OpTypeFunction %void
%foo = OpFunction %void None %void_fn
%entry = OpLabel
OpReturn
OpFunctionEnd
)";
CompileSuccessfully(text, SPV_ENV_VULKAN_1_1);
EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPV_ENV_VULKAN_1_1));
EXPECT_THAT(
getDiagnosticString(),
HasSubstr("BuiltIn SubgroupId cannot be used as a member decoration"));
}
TEST_F(ValidateBuiltIns, TargetIsType) {
const std::string text = R"(
OpCapability Shader
OpCapability Linkage
OpMemoryModel Logical GLSL450
OpDecorate %void BuiltIn Position
%void = OpTypeVoid
)";
CompileSuccessfully(text);
EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
EXPECT_THAT(
getDiagnosticString(),
HasSubstr("BuiltIns can only target variables, structs or constants"));
}
TEST_F(ValidateBuiltIns, TargetIsVariable) {
const std::string text = R"(
OpCapability Shader
OpCapability Linkage
OpMemoryModel Logical GLSL450
OpDecorate %wg_var BuiltIn Position
%int = OpTypeInt 32 0
%int_wg_ptr = OpTypePointer Workgroup %int
%wg_var = OpVariable %int_wg_ptr Workgroup
)";
CompileSuccessfully(text);
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
}
TEST_F(ValidateBuiltIns, TargetIsStruct) {
const std::string text = R"(
OpCapability Shader
OpCapability Linkage
OpMemoryModel Logical GLSL450
OpDecorate %struct BuiltIn Position
%struct = OpTypeStruct
)";
CompileSuccessfully(text);
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
}
TEST_F(ValidateBuiltIns, TargetIsConstant) {
const std::string text = R"(
OpCapability Shader
OpCapability Linkage
OpMemoryModel Logical GLSL450
OpDecorate %int0 BuiltIn Position
%int = OpTypeInt 32 0
%int0 = OpConstant %int 0
)";
CompileSuccessfully(text);
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
}
TEST_F(ValidateBuiltIns, TargetIsSpecConstant) {
const std::string text = R"(
OpCapability Shader
OpCapability Linkage
OpMemoryModel Logical GLSL450
OpDecorate %int0 BuiltIn Position
%int = OpTypeInt 32 0
%int0 = OpSpecConstant %int 0
)";
CompileSuccessfully(text);
EXPECT_EQ(SPV_SUCCESS, ValidateInstructions());
}
INSTANTIATE_TEST_SUITE_P(
PrimitiveShadingRateOutputSuccess,
ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values("PrimitiveShadingRateKHR"), Values("Vertex", "Geometry"),
Values("Output"), Values("%u32"),
Values("OpCapability FragmentShadingRateKHR\n"),
Values("OpExtension \"SPV_KHR_fragment_shading_rate\"\n"),
Values(nullptr), Values(TestResult())));
INSTANTIATE_TEST_SUITE_P(
PrimitiveShadingRateMeshOutputSuccess,
ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values("PrimitiveShadingRateKHR"), Values("MeshNV"),
Values("Output"), Values("%u32"),
Values("OpCapability FragmentShadingRateKHR\nOpCapability "
"MeshShadingNV\n"),
Values("OpExtension \"SPV_KHR_fragment_shading_rate\"\nOpExtension "
"\"SPV_NV_mesh_shader\"\n"),
Values(nullptr), Values(TestResult())));
INSTANTIATE_TEST_SUITE_P(
PrimitiveShadingRateInvalidExecutionModel,
ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(
Values("PrimitiveShadingRateKHR"), Values("Fragment"), Values("Output"),
Values("%u32"), Values("OpCapability FragmentShadingRateKHR\n"),
Values("OpExtension \"SPV_KHR_fragment_shading_rate\"\n"),
Values("VUID-PrimitiveShadingRateKHR-PrimitiveShadingRateKHR-04484 "),
Values(TestResult(
SPV_ERROR_INVALID_DATA,
"Vulkan spec allows BuiltIn PrimitiveShadingRateKHR to be used "
"only with Vertex, Geometry, or MeshNV execution models."))));
INSTANTIATE_TEST_SUITE_P(
PrimitiveShadingRateInvalidStorageClass,
ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(
Values("PrimitiveShadingRateKHR"), Values("Vertex"), Values("Input"),
Values("%u32"), Values("OpCapability FragmentShadingRateKHR\n"),
Values("OpExtension \"SPV_KHR_fragment_shading_rate\"\n"),
Values("VUID-PrimitiveShadingRateKHR-PrimitiveShadingRateKHR-04485 "),
Values(TestResult(
SPV_ERROR_INVALID_DATA,
"Vulkan spec allows BuiltIn PrimitiveShadingRateKHR to be only "
"used for variables with Output storage class."))));
INSTANTIATE_TEST_SUITE_P(
PrimitiveShadingRateInvalidType,
ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(
Values("PrimitiveShadingRateKHR"), Values("Vertex"), Values("Output"),
Values("%f32"), Values("OpCapability FragmentShadingRateKHR\n"),
Values("OpExtension \"SPV_KHR_fragment_shading_rate\"\n"),
Values("VUID-PrimitiveShadingRateKHR-PrimitiveShadingRateKHR-04486 "),
Values(TestResult(
SPV_ERROR_INVALID_DATA,
"According to the Vulkan spec BuiltIn PrimitiveShadingRateKHR "
"variable needs to be a 32-bit int scalar."))));
INSTANTIATE_TEST_SUITE_P(
ShadingRateInputSuccess,
ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values("ShadingRateKHR"), Values("Fragment"), Values("Input"),
Values("%u32"), Values("OpCapability FragmentShadingRateKHR\n"),
Values("OpExtension \"SPV_KHR_fragment_shading_rate\"\n"),
Values(nullptr), Values(TestResult())));
INSTANTIATE_TEST_SUITE_P(
ShadingRateInvalidExecutionModel,
ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values("ShadingRateKHR"), Values("Vertex"), Values("Input"),
Values("%u32"), Values("OpCapability FragmentShadingRateKHR\n"),
Values("OpExtension \"SPV_KHR_fragment_shading_rate\"\n"),
Values("VUID-ShadingRateKHR-ShadingRateKHR-04490 "),
Values(TestResult(
SPV_ERROR_INVALID_DATA,
"Vulkan spec allows BuiltIn ShadingRateKHR to be used "
"only with the Fragment execution model."))));
INSTANTIATE_TEST_SUITE_P(
ShadingRateInvalidStorageClass,
ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values("ShadingRateKHR"), Values("Fragment"), Values("Output"),
Values("%u32"), Values("OpCapability FragmentShadingRateKHR\n"),
Values("OpExtension \"SPV_KHR_fragment_shading_rate\"\n"),
Values("VUID-ShadingRateKHR-ShadingRateKHR-04491 "),
Values(TestResult(
SPV_ERROR_INVALID_DATA,
"Vulkan spec allows BuiltIn ShadingRateKHR to be only "
"used for variables with Input storage class."))));
INSTANTIATE_TEST_SUITE_P(
ShadingRateInvalidType,
ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(
Values("ShadingRateKHR"), Values("Fragment"), Values("Input"),
Values("%f32"), Values("OpCapability FragmentShadingRateKHR\n"),
Values("OpExtension \"SPV_KHR_fragment_shading_rate\"\n"),
Values("VUID-ShadingRateKHR-ShadingRateKHR-04492 "),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"According to the Vulkan spec BuiltIn ShadingRateKHR "
"variable needs to be a 32-bit int scalar."))));
INSTANTIATE_TEST_SUITE_P(
FragInvocationCountInputSuccess,
ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values("FragInvocationCountEXT"), Values("Fragment"),
Values("Input"), Values("%u32"),
Values("OpCapability FragmentDensityEXT\n"),
Values("OpExtension \"SPV_EXT_fragment_invocation_density\"\n"),
Values(nullptr), Values(TestResult())));
INSTANTIATE_TEST_SUITE_P(
FragInvocationCountInvalidExecutionModel,
ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(
Values("FragInvocationCountEXT"), Values("Vertex"), Values("Input"),
Values("%u32"), Values("OpCapability FragmentDensityEXT\n"),
Values("OpExtension \"SPV_EXT_fragment_invocation_density\"\n"),
Values("VUID-FragInvocationCountEXT-FragInvocationCountEXT-04217"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"Vulkan spec allows BuiltIn FragInvocationCountEXT "
"to be used only with Fragment execution model."))));
INSTANTIATE_TEST_SUITE_P(
FragInvocationCountInvalidStorageClass,
ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values("FragInvocationCountEXT"), Values("Fragment"),
Values("Output"), Values("%u32"),
Values("OpCapability FragmentDensityEXT\n"),
Values("OpExtension \"SPV_EXT_fragment_invocation_density\"\n"),
Values("VUID-FragInvocationCountEXT-FragInvocationCountEXT-04218"),
Values(TestResult(
SPV_ERROR_INVALID_DATA,
"Vulkan spec allows BuiltIn FragInvocationCountEXT to be only "
"used for variables with Input storage class."))));
INSTANTIATE_TEST_SUITE_P(
FragInvocationCountInvalidType,
ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values("FragInvocationCountEXT"), Values("Fragment"),
Values("Input"), Values("%f32"),
Values("OpCapability FragmentDensityEXT\n"),
Values("OpExtension \"SPV_EXT_fragment_invocation_density\"\n"),
Values("VUID-FragInvocationCountEXT-FragInvocationCountEXT-04219"),
Values(TestResult(
SPV_ERROR_INVALID_DATA,
"According to the Vulkan spec BuiltIn FragInvocationCountEXT "
"variable needs to be a 32-bit int scalar."))));
INSTANTIATE_TEST_SUITE_P(
FragSizeInputSuccess,
ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values("FragSizeEXT"), Values("Fragment"), Values("Input"),
Values("%u32vec2"), Values("OpCapability FragmentDensityEXT\n"),
Values("OpExtension \"SPV_EXT_fragment_invocation_density\"\n"),
Values(nullptr), Values(TestResult())));
INSTANTIATE_TEST_SUITE_P(
FragSizeInvalidExecutionModel,
ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values("FragSizeEXT"), Values("Vertex"), Values("Input"),
Values("%u32vec2"), Values("OpCapability FragmentDensityEXT\n"),
Values("OpExtension \"SPV_EXT_fragment_invocation_density\"\n"),
Values("VUID-FragSizeEXT-FragSizeEXT-04220"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"Vulkan spec allows BuiltIn FragSizeEXT to be "
"used only with Fragment execution model."))));
INSTANTIATE_TEST_SUITE_P(
FragSizeInvalidStorageClass,
ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(
Values("FragSizeEXT"), Values("Fragment"), Values("Output"),
Values("%u32vec2"), Values("OpCapability FragmentDensityEXT\n"),
Values("OpExtension \"SPV_EXT_fragment_invocation_density\"\n"),
Values("VUID-FragSizeEXT-FragSizeEXT-04221"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"Vulkan spec allows BuiltIn FragSizeEXT to be only "
"used for variables with Input storage class."))));
INSTANTIATE_TEST_SUITE_P(
FragSizeInvalidType,
ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values("FragSizeEXT"), Values("Fragment"), Values("Input"),
Values("%u32vec3"), Values("OpCapability FragmentDensityEXT\n"),
Values("OpExtension \"SPV_EXT_fragment_invocation_density\"\n"),
Values("VUID-FragSizeEXT-FragSizeEXT-04222"),
Values(TestResult(
SPV_ERROR_INVALID_DATA,
"According to the Vulkan spec BuiltIn FragSizeEXT variable "
"needs to be a 2-component 32-bit int vector."))));
INSTANTIATE_TEST_SUITE_P(
FragStencilRefOutputSuccess,
ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values("FragStencilRefEXT"), Values("Fragment"), Values("Output"),
Values("%u32", "%u64"), Values("OpCapability StencilExportEXT\n"),
Values("OpExtension \"SPV_EXT_shader_stencil_export\"\n"),
Values(nullptr), Values(TestResult())));
INSTANTIATE_TEST_SUITE_P(
FragStencilRefInvalidExecutionModel,
ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values("FragStencilRefEXT"), Values("Vertex"), Values("Output"),
Values("%u32", "%u64"), Values("OpCapability StencilExportEXT\n"),
Values("OpExtension \"SPV_EXT_shader_stencil_export\"\n"),
Values("VUID-FragStencilRefEXT-FragStencilRefEXT-04223"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"Vulkan spec allows BuiltIn FragStencilRefEXT to "
"be used only with Fragment execution model."))));
INSTANTIATE_TEST_SUITE_P(
FragStencilRefInvalidStorageClass,
ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values("FragStencilRefEXT"), Values("Fragment"), Values("Input"),
Values("%u32", "%u64"), Values("OpCapability StencilExportEXT\n"),
Values("OpExtension \"SPV_EXT_shader_stencil_export\"\n"),
Values("VUID-FragStencilRefEXT-FragStencilRefEXT-04224"),
Values(TestResult(
SPV_ERROR_INVALID_DATA,
"Vulkan spec allows BuiltIn FragStencilRefEXT to be only used "
"for variables with Output storage class."))));
INSTANTIATE_TEST_SUITE_P(
FragStencilRefInvalidType,
ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values("FragStencilRefEXT"), Values("Fragment"), Values("Output"),
Values("%f32", "%f64", "%u32vec2"),
Values("OpCapability StencilExportEXT\n"),
Values("OpExtension \"SPV_EXT_shader_stencil_export\"\n"),
Values("VUID-FragStencilRefEXT-FragStencilRefEXT-04225"),
Values(TestResult(
SPV_ERROR_INVALID_DATA,
"According to the Vulkan spec BuiltIn FragStencilRefEXT "
"variable needs to be a int scalar."))));
INSTANTIATE_TEST_SUITE_P(
FullyCoveredEXTInputSuccess,
ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values("FullyCoveredEXT"), Values("Fragment"), Values("Input"),
Values("%bool"), Values("OpCapability FragmentFullyCoveredEXT\n"),
Values("OpExtension \"SPV_EXT_fragment_fully_covered\"\n"),
Values(nullptr), Values(TestResult())));
INSTANTIATE_TEST_SUITE_P(
FullyCoveredEXTInvalidExecutionModel,
ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values("FullyCoveredEXT"), Values("Vertex"), Values("Input"),
Values("%bool"), Values("OpCapability FragmentFullyCoveredEXT\n"),
Values("OpExtension \"SPV_EXT_fragment_fully_covered\"\n"),
Values("VUID-FullyCoveredEXT-FullyCoveredEXT-04232"),
Values(TestResult(SPV_ERROR_INVALID_DATA,
"Vulkan spec allows BuiltIn FullyCoveredEXT to "
"be used only with Fragment execution model."))));
INSTANTIATE_TEST_SUITE_P(
FullyCoveredEXTInvalidStorageClass,
ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values("FullyCoveredEXT"), Values("Fragment"), Values("Output"),
Values("%bool"), Values("OpCapability FragmentFullyCoveredEXT\n"),
Values("OpExtension \"SPV_EXT_fragment_fully_covered\"\n"),
Values("VUID-FullyCoveredEXT-FullyCoveredEXT-04233"),
Values(TestResult(
SPV_ERROR_INVALID_DATA,
"Vulkan spec allows BuiltIn FullyCoveredEXT to be only used "
"for variables with Input storage class."))));
INSTANTIATE_TEST_SUITE_P(
FullyCoveredEXTInvalidType,
ValidateVulkanCombineBuiltInExecutionModelDataTypeCapabilityExtensionResult,
Combine(Values("FullyCoveredEXT"), Values("Fragment"), Values("Input"),
Values("%f32"), Values("OpCapability FragmentFullyCoveredEXT\n"),
Values("OpExtension \"SPV_EXT_fragment_fully_covered\"\n"),
Values("VUID-FullyCoveredEXT-FullyCoveredEXT-04234"),
Values(TestResult(
SPV_ERROR_INVALID_DATA,
"According to the Vulkan spec BuiltIn FullyCoveredEXT variable "
"needs to be a bool scalar."))));
} // namespace
} // namespace val
} // namespace spvtools
Reference in New Issue View Git Blame Copy Permalink