| // Copyright 2026 LunarG Inc. | |
| // | |
| // Licensed under the Apache License, Version 2.0 (the "License"); | |
| // you may not use this file except in compliance with the License. | |
| // You may obtain a copy of the License at | |
| // | |
| // http://www.apache.org/licenses/LICENSE-2.0 | |
| // | |
| // Unless required by applicable law or agreed to in writing, software | |
| // distributed under the License is distributed on an "AS IS" BASIS, | |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| // See the License for the specific language governing permissions and | |
| // limitations under the License. | |
| #include <string> | |
| #include "gmock/gmock.h" | |
| #include "test/val/val_fixtures.h" | |
| namespace spvtools { | |
| namespace val { | |
| namespace { | |
| using ::testing::HasSubstr; | |
| using ValidateGroup = spvtest::ValidateBase<bool>; | |
| std::string GenerateShaderCode(const std::string& body, bool is_64_bit = true) { | |
| std::ostringstream ss; | |
| ss << R"( | |
| OpCapability Kernel | |
| OpCapability Addresses | |
| OpCapability Linkage | |
| OpCapability Groups | |
| OpCapability Float64 | |
| OpCapability Int64 | |
| )"; | |
| if (is_64_bit) { | |
| ss << "OpMemoryModel Physical64 OpenCL"; | |
| } else { | |
| ss << "OpMemoryModel Physical32 OpenCL"; | |
| } | |
| ss << R"( | |
| OpEntryPoint Kernel %main "main" | |
| %bool = OpTypeBool | |
| %float = OpTypeFloat 32 | |
| %float64 = OpTypeFloat 64 | |
| %uint = OpTypeInt 32 0 | |
| %uint64 = OpTypeInt 64 0 | |
| %null_uint = OpConstantNull %uint | |
| %uint_0 = OpConstant %uint 0 | |
| %uint_1 = OpConstant %uint 1 | |
| %uint_2 = OpConstant %uint 2 | |
| %uint64_1 = OpConstant %uint64 1 | |
| %float_2 = OpConstant %float 2 | |
| %uint_array = OpTypeArray %uint %uint_2 | |
| %void = OpTypeVoid | |
| %event = OpTypeEvent | |
| %null_event = OpConstantNull %event | |
| %workgroup_float_ptr = OpTypePointer Workgroup %float | |
| %workgroup_float_var = OpVariable %workgroup_float_ptr Workgroup | |
| %workgroup_bool_ptr = OpTypePointer Workgroup %bool | |
| %workgroup_bool_var = OpVariable %workgroup_bool_ptr Workgroup | |
| %cross_float_ptr = OpTypePointer CrossWorkgroup %float | |
| %cross_float_var = OpVariable %cross_float_ptr CrossWorkgroup | |
| %cross_uint_ptr = OpTypePointer CrossWorkgroup %uint | |
| %cross_uint_var = OpVariable %cross_uint_ptr CrossWorkgroup | |
| %uniform_float_ptr = OpTypePointer UniformConstant %float | |
| %uniform_float_var = OpVariable %uniform_float_ptr UniformConstant | |
| %func_event_ptr = OpTypePointer Function %event | |
| %fn = OpTypeFunction %void | |
| %true = OpConstantTrue %bool | |
| %main = OpFunction %void None %fn | |
| %label = OpLabel | |
| )"; | |
| ss << body; | |
| ss << R"( | |
| OpReturn | |
| OpFunctionEnd)"; | |
| return ss.str(); | |
| } | |
| TEST_F(ValidateGroup, AllAnyGood) { | |
| const std::string ss = R"( | |
| %x = OpGroupAll %bool %uint_2 %true | |
| %y = OpGroupAny %bool %uint_2 %true | |
| )"; | |
| CompileSuccessfully(GenerateShaderCode(ss)); | |
| EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); | |
| } | |
| TEST_F(ValidateGroup, FloatGood) { | |
| const std::string ss = R"( | |
| %a = OpGroupFAdd %float %uint_2 Reduce %float_2 | |
| %b = OpGroupFMin %float %uint_2 Reduce %float_2 | |
| %c = OpGroupFMax %float %uint_2 Reduce %float_2 | |
| )"; | |
| CompileSuccessfully(GenerateShaderCode(ss)); | |
| EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); | |
| } | |
| TEST_F(ValidateGroup, IntGood) { | |
| const std::string ss = R"( | |
| %a = OpGroupIAdd %uint %uint_2 Reduce %uint_2 | |
| %b = OpGroupSMin %uint %uint_2 Reduce %uint_2 | |
| %c = OpGroupSMax %uint %uint_2 Reduce %uint_2 | |
| %d = OpGroupUMin %uint %uint_2 Reduce %uint_2 | |
| %e = OpGroupUMax %uint %uint_2 Reduce %uint_2 | |
| )"; | |
| CompileSuccessfully(GenerateShaderCode(ss)); | |
| EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); | |
| } | |
| TEST_F(ValidateGroup, BroadcastGood) { | |
| const std::string ss = R"( | |
| %a = OpGroupBroadcast %uint %uint_2 %uint_2 %uint_0 | |
| %b = OpGroupBroadcast %float %uint_2 %float_2 %uint_0 | |
| )"; | |
| CompileSuccessfully(GenerateShaderCode(ss)); | |
| EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); | |
| } | |
| TEST_F(ValidateGroup, AllResult) { | |
| const std::string ss = R"( | |
| %x = OpGroupAll %uint %uint_2 %true | |
| )"; | |
| CompileSuccessfully(GenerateShaderCode(ss)); | |
| EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); | |
| EXPECT_THAT(getDiagnosticString(), | |
| HasSubstr("Result must be a boolean scalar type")); | |
| } | |
| TEST_F(ValidateGroup, AllPredicate) { | |
| const std::string ss = R"( | |
| %x = OpGroupAll %bool %uint_2 %uint_2 | |
| )"; | |
| CompileSuccessfully(GenerateShaderCode(ss)); | |
| EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); | |
| EXPECT_THAT(getDiagnosticString(), | |
| HasSubstr("Predicate must be a boolean scalar type")); | |
| } | |
| TEST_F(ValidateGroup, AnyResult) { | |
| const std::string ss = R"( | |
| %x = OpGroupAny %uint %uint_2 %true | |
| )"; | |
| CompileSuccessfully(GenerateShaderCode(ss)); | |
| EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); | |
| EXPECT_THAT(getDiagnosticString(), | |
| HasSubstr("Result must be a boolean scalar type")); | |
| } | |
| TEST_F(ValidateGroup, AnyPredicate) { | |
| const std::string ss = R"( | |
| %x = OpGroupAny %bool %uint_2 %uint_2 | |
| )"; | |
| CompileSuccessfully(GenerateShaderCode(ss)); | |
| EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); | |
| EXPECT_THAT(getDiagnosticString(), | |
| HasSubstr("Predicate must be a boolean scalar type")); | |
| } | |
| TEST_F(ValidateGroup, FAddWithInt) { | |
| const std::string ss = R"( | |
| %a = OpGroupFAdd %uint %uint_2 Reduce %uint_2 | |
| )"; | |
| CompileSuccessfully(GenerateShaderCode(ss)); | |
| EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); | |
| EXPECT_THAT(getDiagnosticString(), | |
| HasSubstr("Result must be a scalar or vector of float type")); | |
| } | |
| TEST_F(ValidateGroup, FMaxWidthMismatch) { | |
| const std::string ss = R"( | |
| %a = OpGroupFAdd %float64 %uint_2 Reduce %float_2 | |
| )"; | |
| CompileSuccessfully(GenerateShaderCode(ss)); | |
| EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); | |
| EXPECT_THAT(getDiagnosticString(), | |
| HasSubstr("The type of X must match the Result type")); | |
| } | |
| TEST_F(ValidateGroup, IAddWithFloat) { | |
| const std::string ss = R"( | |
| %a = OpGroupIAdd %float %uint_2 Reduce %float_2 | |
| )"; | |
| CompileSuccessfully(GenerateShaderCode(ss)); | |
| EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); | |
| EXPECT_THAT(getDiagnosticString(), | |
| HasSubstr("Result must be a scalar or vector of integer type")); | |
| } | |
| TEST_F(ValidateGroup, UMinWithArray) { | |
| const std::string ss = R"( | |
| %a = OpGroupUMin %uint_array %uint_2 Reduce %float_2 | |
| )"; | |
| CompileSuccessfully(GenerateShaderCode(ss)); | |
| EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); | |
| EXPECT_THAT(getDiagnosticString(), | |
| HasSubstr("Result must be a scalar or vector of integer type")); | |
| } | |
| TEST_F(ValidateGroup, SMaxWidthMismatch) { | |
| const std::string ss = R"( | |
| %c = OpGroupSMax %uint64 %uint_2 Reduce %uint_2 | |
| )"; | |
| CompileSuccessfully(GenerateShaderCode(ss)); | |
| EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); | |
| EXPECT_THAT(getDiagnosticString(), | |
| HasSubstr("The type of X must match the Result type")); | |
| } | |
| TEST_F(ValidateGroup, BroadcastArray) { | |
| const std::string ss = R"( | |
| %a = OpGroupBroadcast %uint_array %uint_2 %uint_2 %uint_0 | |
| )"; | |
| CompileSuccessfully(GenerateShaderCode(ss)); | |
| EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); | |
| EXPECT_THAT(getDiagnosticString(), | |
| HasSubstr("Result must be a scalar or vector of integer, " | |
| "floating-point, or boolean type")); | |
| } | |
| TEST_F(ValidateGroup, BroadcastMismatch) { | |
| const std::string ss = R"( | |
| %b = OpGroupBroadcast %uint %uint_2 %float_2 %uint_0 | |
| )"; | |
| CompileSuccessfully(GenerateShaderCode(ss)); | |
| EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); | |
| EXPECT_THAT(getDiagnosticString(), | |
| HasSubstr("The type of Value must match the Result type")); | |
| } | |
| TEST_F(ValidateGroup, AsyncCopyWaitEventsGood) { | |
| const std::string ss = R"( | |
| OpCapability Kernel | |
| OpCapability Addresses | |
| OpCapability Int64 | |
| OpCapability Int8 | |
| OpCapability Linkage | |
| OpMemoryModel Physical64 OpenCL | |
| OpEntryPoint Kernel %async_example "async_example" | |
| OpExecutionMode %async_example ContractionOff | |
| OpDecorate %26 Alignment 4 | |
| OpDecorate %29 Alignment 8 | |
| OpDecorate %async_example_local_data Alignment 4 | |
| %float = OpTypeFloat 32 | |
| %_ptr_CrossWorkgroup_float = OpTypePointer CrossWorkgroup %float | |
| %void = OpTypeVoid | |
| %5 = OpTypeFunction %void %_ptr_CrossWorkgroup_float | |
| %spirv_Event = OpTypeEvent | |
| %_ptr_Workgroup_float = OpTypePointer Workgroup %float | |
| %ulong = OpTypeInt 64 0 | |
| %uint = OpTypeInt 32 0 | |
| %_ptr_Function_spirv_Event = OpTypePointer Function %spirv_Event | |
| %uint_64 = OpConstant %uint 64 | |
| %_arr_float_uint_64 = OpTypeArray %float %uint_64 | |
| %_ptr_Workgroup__arr_float_uint_64 = OpTypePointer Workgroup %_arr_float_uint_64 | |
| %ulong_1 = OpConstant %ulong 1 | |
| %ulong_64 = OpConstant %ulong 64 | |
| %uint_1 = OpConstant %uint 1 | |
| %uint_2 = OpConstant %uint 2 | |
| %uchar = OpTypeInt 8 0 | |
| %_ptr_Function_uchar = OpTypePointer Function %uchar | |
| %async_example_local_data = OpVariable %_ptr_Workgroup__arr_float_uint_64 Workgroup | |
| %24 = OpConstantNull %spirv_Event | |
| %async_example = OpFunction %void None %5 | |
| %26 = OpFunctionParameter %_ptr_CrossWorkgroup_float | |
| %54 = OpLabel | |
| %29 = OpVariable %_ptr_Function_spirv_Event Function | |
| %30 = OpBitcast %_ptr_Workgroup_float %async_example_local_data | |
| %31 = OpBitcast %_ptr_Function_uchar %29 | |
| %32 = OpGroupAsyncCopy %spirv_Event %uint_2 %30 %26 %ulong_64 %ulong_1 %24 | |
| OpStore %29 %32 Aligned 8 | |
| OpGroupWaitEvents %uint_2 %uint_1 %29 | |
| OpReturn | |
| OpFunctionEnd | |
| )"; | |
| CompileSuccessfully(ss); | |
| EXPECT_EQ(SPV_SUCCESS, ValidateInstructions()); | |
| } | |
| TEST_F(ValidateGroup, AsyncCopyResultType) { | |
| const std::string ss = R"( | |
| %a = OpGroupAsyncCopy %uint %uint_2 %workgroup_float_var %cross_float_var %uint64_1 %uint64_1 %null_event | |
| )"; | |
| CompileSuccessfully(GenerateShaderCode(ss)); | |
| EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); | |
| EXPECT_THAT(getDiagnosticString(), | |
| HasSubstr("The result type must be OpTypeEvent")); | |
| } | |
| TEST_F(ValidateGroup, AsyncCopyDestinationPointer) { | |
| const std::string ss = R"( | |
| %a = OpGroupAsyncCopy %event %uint_2 %null_uint %cross_float_var %uint64_1 %uint64_1 %null_event | |
| )"; | |
| CompileSuccessfully(GenerateShaderCode(ss)); | |
| EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); | |
| EXPECT_THAT(getDiagnosticString(), | |
| HasSubstr("Expected Destination to be a pointer")); | |
| } | |
| TEST_F(ValidateGroup, AsyncCopyDestinationUniform) { | |
| const std::string ss = R"( | |
| %a = OpGroupAsyncCopy %event %uint_2 %uniform_float_var %cross_float_var %uint64_1 %uint64_1 %null_event | |
| )"; | |
| CompileSuccessfully(GenerateShaderCode(ss)); | |
| EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); | |
| EXPECT_THAT(getDiagnosticString(), | |
| HasSubstr("Expected Destination to be a pointer with storage " | |
| "class Workgroup or CrossWorkgroup")); | |
| } | |
| TEST_F(ValidateGroup, AsyncCopyDestinationBool) { | |
| const std::string ss = R"( | |
| %a = OpGroupAsyncCopy %event %uint_2 %workgroup_bool_var %cross_float_var %uint64_1 %uint64_1 %null_event | |
| )"; | |
| CompileSuccessfully(GenerateShaderCode(ss)); | |
| EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); | |
| EXPECT_THAT(getDiagnosticString(), | |
| HasSubstr("Expected Destination to be a pointer to scalar or " | |
| "vector of floating-point type or integer type")); | |
| } | |
| TEST_F(ValidateGroup, AsyncCopyDestinationSourceTypes) { | |
| const std::string ss = R"( | |
| %a = OpGroupAsyncCopy %event %uint_2 %workgroup_float_var %cross_uint_var %uint64_1 %uint64_1 %null_event | |
| )"; | |
| CompileSuccessfully(GenerateShaderCode(ss)); | |
| EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); | |
| EXPECT_THAT(getDiagnosticString(), | |
| HasSubstr("Expected Destination and Source to be the same type")); | |
| } | |
| TEST_F(ValidateGroup, AsyncCopyBothWorkgroup) { | |
| const std::string ss = R"( | |
| %a = OpGroupAsyncCopy %event %uint_2 %workgroup_float_var %workgroup_float_var %uint64_1 %uint64_1 %null_event | |
| )"; | |
| CompileSuccessfully(GenerateShaderCode(ss)); | |
| EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); | |
| EXPECT_THAT(getDiagnosticString(), | |
| HasSubstr("If Destination storage class is Workgroup, then the " | |
| "Source storage class must be CrossWorkgroup.")); | |
| } | |
| TEST_F(ValidateGroup, AsyncCopyBothCrossWorkgroup) { | |
| const std::string ss = R"( | |
| %a = OpGroupAsyncCopy %event %uint_2 %cross_float_var %cross_float_var %uint64_1 %uint64_1 %null_event | |
| )"; | |
| CompileSuccessfully(GenerateShaderCode(ss)); | |
| EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); | |
| EXPECT_THAT(getDiagnosticString(), | |
| HasSubstr("If Destination storage class is CrossWorkgroup, then " | |
| "the Source storage class must be Workgroup")); | |
| } | |
| TEST_F(ValidateGroup, AsyncCopyEventType) { | |
| const std::string ss = R"( | |
| %a = OpGroupAsyncCopy %event %uint_2 %workgroup_float_var %cross_float_var %uint64_1 %uint64_1 %null_uint | |
| )"; | |
| CompileSuccessfully(GenerateShaderCode(ss)); | |
| EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); | |
| EXPECT_THAT(getDiagnosticString(), | |
| HasSubstr("Expected Event to be type OpTypeEvent")); | |
| } | |
| TEST_F(ValidateGroup, AsyncCopyNumElement32Bit) { | |
| const std::string ss = R"( | |
| %a = OpGroupAsyncCopy %event %uint_2 %workgroup_float_var %cross_float_var %uint_1 %uint64_1 %null_event | |
| )"; | |
| CompileSuccessfully(GenerateShaderCode(ss)); | |
| EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); | |
| EXPECT_THAT(getDiagnosticString(), | |
| HasSubstr("NumElements must be a 64-bit int scalar when " | |
| "Addressing Model is Physical64")); | |
| } | |
| TEST_F(ValidateGroup, AsyncCopyStride32Bit) { | |
| const std::string ss = R"( | |
| %a = OpGroupAsyncCopy %event %uint_2 %workgroup_float_var %cross_float_var %uint64_1 %uint_1 %null_event | |
| )"; | |
| CompileSuccessfully(GenerateShaderCode(ss)); | |
| EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); | |
| EXPECT_THAT(getDiagnosticString(), | |
| HasSubstr("Stride must be a 64-bit int scalar when Addressing " | |
| "Model is Physical64")); | |
| } | |
| TEST_F(ValidateGroup, AsyncCopyNumElement64Bit) { | |
| const std::string ss = R"( | |
| %a = OpGroupAsyncCopy %event %uint_2 %workgroup_float_var %cross_float_var %uint64_1 %uint_1 %null_event | |
| )"; | |
| CompileSuccessfully(GenerateShaderCode(ss, false)); | |
| EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); | |
| EXPECT_THAT(getDiagnosticString(), | |
| HasSubstr("NumElements must be a 32-bit int scalar when " | |
| "Addressing Model is Physical32")); | |
| } | |
| TEST_F(ValidateGroup, AsyncCopyStride64Bit) { | |
| const std::string ss = R"( | |
| %a = OpGroupAsyncCopy %event %uint_2 %workgroup_float_var %cross_float_var %uint_1 %uint64_1 %null_event | |
| )"; | |
| CompileSuccessfully(GenerateShaderCode(ss, false)); | |
| EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); | |
| EXPECT_THAT(getDiagnosticString(), | |
| HasSubstr("Stride must be a 32-bit int scalar when Addressing " | |
| "Model is Physical32")); | |
| } | |
| TEST_F(ValidateGroup, GroupWaitEventsNumEvents) { | |
| const std::string ss = R"( | |
| %a = OpVariable %func_event_ptr Function | |
| OpGroupWaitEvents %uint_2 %uint64_1 %a | |
| )"; | |
| CompileSuccessfully(GenerateShaderCode(ss)); | |
| EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); | |
| EXPECT_THAT(getDiagnosticString(), | |
| HasSubstr("Expected Num Events to be a 32-bit int scalar")); | |
| } | |
| TEST_F(ValidateGroup, GroupWaitEventsEventList) { | |
| const std::string ss = R"( | |
| OpGroupWaitEvents %uint_2 %uint_1 %null_uint | |
| )"; | |
| CompileSuccessfully(GenerateShaderCode(ss)); | |
| EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); | |
| EXPECT_THAT(getDiagnosticString(), | |
| HasSubstr("Expected Events List to be a pointer")); | |
| } | |
| TEST_F(ValidateGroup, GroupWaitEventsEventListType) { | |
| const std::string ss = R"( | |
| OpGroupWaitEvents %uint_2 %uint_1 %uniform_float_var | |
| )"; | |
| CompileSuccessfully(GenerateShaderCode(ss)); | |
| EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions()); | |
| EXPECT_THAT(getDiagnosticString(), | |
| HasSubstr("Expected Events List to be a pointer to OpTypeEvent")); | |
| } | |
| } // namespace | |
| } // namespace val | |
| } // namespace spvtools |