mirror of
https://github.com/KhronosGroup/SPIRV-Tools
synced 2024-11-23 04:00:05 +00:00
456cc598af
Fixes #2669 * Check capabilities when validating variables * validate load and store types * Constant check * Don't checks pointers for stores, constants and loads * Validate composite instructions * Validate conversions for 8- and 16-bit limited types * Unified tests and expanded them * Disallow OpCopyMemory * new tests and update old tests
1566 lines
50 KiB
C++
1566 lines
50 KiB
C++
// Copyright (c) 2017 Google 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.
|
|
|
|
// Tests for unique type declaration rules validator.
|
|
|
|
#include <string>
|
|
|
|
#include "gmock/gmock.h"
|
|
#include "test/unit_spirv.h"
|
|
#include "test/val/val_code_generator.h"
|
|
#include "test/val/val_fixtures.h"
|
|
|
|
namespace spvtools {
|
|
namespace val {
|
|
namespace {
|
|
|
|
using ::testing::HasSubstr;
|
|
using ::testing::Not;
|
|
using ::testing::Values;
|
|
|
|
using ValidateConversion = spvtest::ValidateBase<bool>;
|
|
|
|
std::string GenerateShaderCode(
|
|
const std::string& body,
|
|
const std::string& capabilities_and_extensions = "",
|
|
const std::string& decorations = "", const std::string& types = "",
|
|
const std::string& variables = "") {
|
|
const std::string capabilities =
|
|
R"(
|
|
OpCapability Shader
|
|
OpCapability Int64
|
|
OpCapability Float64)";
|
|
|
|
const std::string after_extension_before_decorations =
|
|
R"(
|
|
OpMemoryModel Logical GLSL450
|
|
OpEntryPoint Fragment %main "main"
|
|
OpExecutionMode %main OriginUpperLeft)";
|
|
|
|
const std::string after_decorations_before_types =
|
|
R"(
|
|
%void = OpTypeVoid
|
|
%func = OpTypeFunction %void
|
|
%bool = OpTypeBool
|
|
%f32 = OpTypeFloat 32
|
|
%u32 = OpTypeInt 32 0
|
|
%s32 = OpTypeInt 32 1
|
|
%f64 = OpTypeFloat 64
|
|
%u64 = OpTypeInt 64 0
|
|
%s64 = OpTypeInt 64 1
|
|
%boolvec2 = OpTypeVector %bool 2
|
|
%s32vec2 = OpTypeVector %s32 2
|
|
%u32vec2 = OpTypeVector %u32 2
|
|
%u64vec2 = OpTypeVector %u64 2
|
|
%f32vec2 = OpTypeVector %f32 2
|
|
%f64vec2 = OpTypeVector %f64 2
|
|
%boolvec3 = OpTypeVector %bool 3
|
|
%u32vec3 = OpTypeVector %u32 3
|
|
%u64vec3 = OpTypeVector %u64 3
|
|
%s32vec3 = OpTypeVector %s32 3
|
|
%f32vec3 = OpTypeVector %f32 3
|
|
%f64vec3 = OpTypeVector %f64 3
|
|
%boolvec4 = OpTypeVector %bool 4
|
|
%u32vec4 = OpTypeVector %u32 4
|
|
%u64vec4 = OpTypeVector %u64 4
|
|
%s32vec4 = OpTypeVector %s32 4
|
|
%f32vec4 = OpTypeVector %f32 4
|
|
%f64vec4 = OpTypeVector %f64 4
|
|
|
|
%f32_0 = OpConstant %f32 0
|
|
%f32_1 = OpConstant %f32 1
|
|
%f32_2 = OpConstant %f32 2
|
|
%f32_3 = OpConstant %f32 3
|
|
%f32_4 = OpConstant %f32 4
|
|
|
|
%s32_0 = OpConstant %s32 0
|
|
%s32_1 = OpConstant %s32 1
|
|
%s32_2 = OpConstant %s32 2
|
|
%s32_3 = OpConstant %s32 3
|
|
%s32_4 = OpConstant %s32 4
|
|
%s32_m1 = OpConstant %s32 -1
|
|
|
|
%u32_0 = OpConstant %u32 0
|
|
%u32_1 = OpConstant %u32 1
|
|
%u32_2 = OpConstant %u32 2
|
|
%u32_3 = OpConstant %u32 3
|
|
%u32_4 = OpConstant %u32 4
|
|
|
|
%f64_0 = OpConstant %f64 0
|
|
%f64_1 = OpConstant %f64 1
|
|
%f64_2 = OpConstant %f64 2
|
|
%f64_3 = OpConstant %f64 3
|
|
%f64_4 = OpConstant %f64 4
|
|
|
|
%s64_0 = OpConstant %s64 0
|
|
%s64_1 = OpConstant %s64 1
|
|
%s64_2 = OpConstant %s64 2
|
|
%s64_3 = OpConstant %s64 3
|
|
%s64_4 = OpConstant %s64 4
|
|
%s64_m1 = OpConstant %s64 -1
|
|
|
|
%u64_0 = OpConstant %u64 0
|
|
%u64_1 = OpConstant %u64 1
|
|
%u64_2 = OpConstant %u64 2
|
|
%u64_3 = OpConstant %u64 3
|
|
%u64_4 = OpConstant %u64 4
|
|
|
|
%u32vec2_01 = OpConstantComposite %u32vec2 %u32_0 %u32_1
|
|
%u32vec2_12 = OpConstantComposite %u32vec2 %u32_1 %u32_2
|
|
%u32vec3_012 = OpConstantComposite %u32vec3 %u32_0 %u32_1 %u32_2
|
|
%u32vec3_123 = OpConstantComposite %u32vec3 %u32_1 %u32_2 %u32_3
|
|
%u32vec4_0123 = OpConstantComposite %u32vec4 %u32_0 %u32_1 %u32_2 %u32_3
|
|
%u32vec4_1234 = OpConstantComposite %u32vec4 %u32_1 %u32_2 %u32_3 %u32_4
|
|
|
|
%s32vec2_01 = OpConstantComposite %s32vec2 %s32_0 %s32_1
|
|
%s32vec2_12 = OpConstantComposite %s32vec2 %s32_1 %s32_2
|
|
%s32vec3_012 = OpConstantComposite %s32vec3 %s32_0 %s32_1 %s32_2
|
|
%s32vec3_123 = OpConstantComposite %s32vec3 %s32_1 %s32_2 %s32_3
|
|
%s32vec4_0123 = OpConstantComposite %s32vec4 %s32_0 %s32_1 %s32_2 %s32_3
|
|
%s32vec4_1234 = OpConstantComposite %s32vec4 %s32_1 %s32_2 %s32_3 %s32_4
|
|
|
|
%f32vec2_01 = OpConstantComposite %f32vec2 %f32_0 %f32_1
|
|
%f32vec2_12 = OpConstantComposite %f32vec2 %f32_1 %f32_2
|
|
%f32vec3_012 = OpConstantComposite %f32vec3 %f32_0 %f32_1 %f32_2
|
|
%f32vec3_123 = OpConstantComposite %f32vec3 %f32_1 %f32_2 %f32_3
|
|
%f32vec4_0123 = OpConstantComposite %f32vec4 %f32_0 %f32_1 %f32_2 %f32_3
|
|
%f32vec4_1234 = OpConstantComposite %f32vec4 %f32_1 %f32_2 %f32_3 %f32_4
|
|
|
|
%f64vec2_01 = OpConstantComposite %f64vec2 %f64_0 %f64_1
|
|
%f64vec2_12 = OpConstantComposite %f64vec2 %f64_1 %f64_2
|
|
%f64vec3_012 = OpConstantComposite %f64vec3 %f64_0 %f64_1 %f64_2
|
|
%f64vec3_123 = OpConstantComposite %f64vec3 %f64_1 %f64_2 %f64_3
|
|
%f64vec4_0123 = OpConstantComposite %f64vec4 %f64_0 %f64_1 %f64_2 %f64_3
|
|
%f64vec4_1234 = OpConstantComposite %f64vec4 %f64_1 %f64_2 %f64_3 %f64_4
|
|
|
|
%true = OpConstantTrue %bool
|
|
%false = OpConstantFalse %bool
|
|
|
|
%f32ptr_func = OpTypePointer Function %f32)";
|
|
|
|
const std::string after_variables_before_body =
|
|
R"(
|
|
%main = OpFunction %void None %func
|
|
%main_entry = OpLabel)";
|
|
|
|
const std::string after_body =
|
|
R"(
|
|
OpReturn
|
|
OpFunctionEnd)";
|
|
|
|
return capabilities + capabilities_and_extensions +
|
|
after_extension_before_decorations + decorations +
|
|
after_decorations_before_types + types + variables +
|
|
after_variables_before_body + body + after_body;
|
|
}
|
|
|
|
std::string GenerateKernelCode(
|
|
const std::string& body,
|
|
const std::string& capabilities_and_extensions = "") {
|
|
const std::string capabilities =
|
|
R"(
|
|
OpCapability Addresses
|
|
OpCapability Kernel
|
|
OpCapability Linkage
|
|
OpCapability GenericPointer
|
|
OpCapability Int64
|
|
OpCapability Float64)";
|
|
|
|
const std::string after_extension_before_body =
|
|
R"(
|
|
OpMemoryModel Physical32 OpenCL
|
|
%void = OpTypeVoid
|
|
%func = OpTypeFunction %void
|
|
%bool = OpTypeBool
|
|
%f32 = OpTypeFloat 32
|
|
%u32 = OpTypeInt 32 0
|
|
%f64 = OpTypeFloat 64
|
|
%u64 = OpTypeInt 64 0
|
|
%boolvec2 = OpTypeVector %bool 2
|
|
%u32vec2 = OpTypeVector %u32 2
|
|
%u64vec2 = OpTypeVector %u64 2
|
|
%f32vec2 = OpTypeVector %f32 2
|
|
%f64vec2 = OpTypeVector %f64 2
|
|
%boolvec3 = OpTypeVector %bool 3
|
|
%u32vec3 = OpTypeVector %u32 3
|
|
%u64vec3 = OpTypeVector %u64 3
|
|
%f32vec3 = OpTypeVector %f32 3
|
|
%f64vec3 = OpTypeVector %f64 3
|
|
%boolvec4 = OpTypeVector %bool 4
|
|
%u32vec4 = OpTypeVector %u32 4
|
|
%u64vec4 = OpTypeVector %u64 4
|
|
%f32vec4 = OpTypeVector %f32 4
|
|
%f64vec4 = OpTypeVector %f64 4
|
|
|
|
%f32_0 = OpConstant %f32 0
|
|
%f32_1 = OpConstant %f32 1
|
|
%f32_2 = OpConstant %f32 2
|
|
%f32_3 = OpConstant %f32 3
|
|
%f32_4 = OpConstant %f32 4
|
|
|
|
%u32_0 = OpConstant %u32 0
|
|
%u32_1 = OpConstant %u32 1
|
|
%u32_2 = OpConstant %u32 2
|
|
%u32_3 = OpConstant %u32 3
|
|
%u32_4 = OpConstant %u32 4
|
|
|
|
%f64_0 = OpConstant %f64 0
|
|
%f64_1 = OpConstant %f64 1
|
|
%f64_2 = OpConstant %f64 2
|
|
%f64_3 = OpConstant %f64 3
|
|
%f64_4 = OpConstant %f64 4
|
|
|
|
%u64_0 = OpConstant %u64 0
|
|
%u64_1 = OpConstant %u64 1
|
|
%u64_2 = OpConstant %u64 2
|
|
%u64_3 = OpConstant %u64 3
|
|
%u64_4 = OpConstant %u64 4
|
|
|
|
%u32vec2_01 = OpConstantComposite %u32vec2 %u32_0 %u32_1
|
|
%u32vec2_12 = OpConstantComposite %u32vec2 %u32_1 %u32_2
|
|
%u32vec3_012 = OpConstantComposite %u32vec3 %u32_0 %u32_1 %u32_2
|
|
%u32vec3_123 = OpConstantComposite %u32vec3 %u32_1 %u32_2 %u32_3
|
|
%u32vec4_0123 = OpConstantComposite %u32vec4 %u32_0 %u32_1 %u32_2 %u32_3
|
|
%u32vec4_1234 = OpConstantComposite %u32vec4 %u32_1 %u32_2 %u32_3 %u32_4
|
|
|
|
%f32vec2_01 = OpConstantComposite %f32vec2 %f32_0 %f32_1
|
|
%f32vec2_12 = OpConstantComposite %f32vec2 %f32_1 %f32_2
|
|
%f32vec3_012 = OpConstantComposite %f32vec3 %f32_0 %f32_1 %f32_2
|
|
%f32vec3_123 = OpConstantComposite %f32vec3 %f32_1 %f32_2 %f32_3
|
|
%f32vec4_0123 = OpConstantComposite %f32vec4 %f32_0 %f32_1 %f32_2 %f32_3
|
|
%f32vec4_1234 = OpConstantComposite %f32vec4 %f32_1 %f32_2 %f32_3 %f32_4
|
|
|
|
%f64vec2_01 = OpConstantComposite %f64vec2 %f64_0 %f64_1
|
|
%f64vec2_12 = OpConstantComposite %f64vec2 %f64_1 %f64_2
|
|
%f64vec3_012 = OpConstantComposite %f64vec3 %f64_0 %f64_1 %f64_2
|
|
%f64vec3_123 = OpConstantComposite %f64vec3 %f64_1 %f64_2 %f64_3
|
|
%f64vec4_0123 = OpConstantComposite %f64vec4 %f64_0 %f64_1 %f64_2 %f64_3
|
|
%f64vec4_1234 = OpConstantComposite %f64vec4 %f64_1 %f64_2 %f64_3 %f64_4
|
|
|
|
%true = OpConstantTrue %bool
|
|
%false = OpConstantFalse %bool
|
|
|
|
%f32ptr_func = OpTypePointer Function %f32
|
|
%u32ptr_func = OpTypePointer Function %u32
|
|
%f32ptr_gen = OpTypePointer Generic %f32
|
|
%f32ptr_inp = OpTypePointer Input %f32
|
|
%f32ptr_wg = OpTypePointer Workgroup %f32
|
|
%f32ptr_cwg = OpTypePointer CrossWorkgroup %f32
|
|
|
|
%f32inp = OpVariable %f32ptr_inp Input
|
|
|
|
%main = OpFunction %void None %func
|
|
%main_entry = OpLabel)";
|
|
|
|
const std::string after_body =
|
|
R"(
|
|
OpReturn
|
|
OpFunctionEnd)";
|
|
|
|
return capabilities + capabilities_and_extensions +
|
|
after_extension_before_body + body + after_body;
|
|
}
|
|
|
|
TEST_F(ValidateConversion, ConvertFToUSuccess) {
|
|
const std::string body = R"(
|
|
%val1 = OpConvertFToU %u32 %f32_1
|
|
%val2 = OpConvertFToU %u32 %f64_0
|
|
%val3 = OpConvertFToU %u32vec2 %f32vec2_01
|
|
)";
|
|
|
|
CompileSuccessfully(GenerateShaderCode(body).c_str());
|
|
ASSERT_EQ(SPV_SUCCESS, ValidateInstructions());
|
|
}
|
|
|
|
TEST_F(ValidateConversion, ConvertFToUWrongResultType) {
|
|
const std::string body = R"(
|
|
%val = OpConvertFToU %s32 %f32_1
|
|
)";
|
|
|
|
CompileSuccessfully(GenerateShaderCode(body).c_str());
|
|
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
|
|
EXPECT_THAT(getDiagnosticString(),
|
|
HasSubstr("Expected unsigned int scalar or vector type as Result "
|
|
"Type: ConvertFToU"));
|
|
}
|
|
|
|
TEST_F(ValidateConversion, ConvertFToUWrongInputType) {
|
|
const std::string body = R"(
|
|
%val = OpConvertFToU %u32 %u32_1
|
|
)";
|
|
|
|
CompileSuccessfully(GenerateShaderCode(body).c_str());
|
|
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
|
|
EXPECT_THAT(
|
|
getDiagnosticString(),
|
|
HasSubstr("Expected input to be float scalar or vector: ConvertFToU"));
|
|
}
|
|
|
|
TEST_F(ValidateConversion, ConvertFToUDifferentDimension) {
|
|
const std::string body = R"(
|
|
%val = OpConvertFToU %u32 %f32vec2_01
|
|
)";
|
|
|
|
CompileSuccessfully(GenerateShaderCode(body).c_str());
|
|
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
|
|
EXPECT_THAT(getDiagnosticString(),
|
|
HasSubstr("Expected input to have the same dimension as Result "
|
|
"Type: ConvertFToU"));
|
|
}
|
|
|
|
TEST_F(ValidateConversion, ConvertFToSSuccess) {
|
|
const std::string body = R"(
|
|
%val1 = OpConvertFToS %s32 %f32_1
|
|
%val2 = OpConvertFToS %u32 %f64_0
|
|
%val3 = OpConvertFToS %s32vec2 %f32vec2_01
|
|
)";
|
|
|
|
CompileSuccessfully(GenerateShaderCode(body).c_str());
|
|
ASSERT_EQ(SPV_SUCCESS, ValidateInstructions());
|
|
}
|
|
|
|
TEST_F(ValidateConversion, ConvertFToSWrongResultType) {
|
|
const std::string body = R"(
|
|
%val = OpConvertFToS %bool %f32_1
|
|
)";
|
|
|
|
CompileSuccessfully(GenerateShaderCode(body).c_str());
|
|
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
|
|
EXPECT_THAT(
|
|
getDiagnosticString(),
|
|
HasSubstr(
|
|
"Expected int scalar or vector type as Result Type: ConvertFToS"));
|
|
}
|
|
|
|
TEST_F(ValidateConversion, ConvertFToSWrongInputType) {
|
|
const std::string body = R"(
|
|
%val = OpConvertFToS %s32 %u32_1
|
|
)";
|
|
|
|
CompileSuccessfully(GenerateShaderCode(body).c_str());
|
|
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
|
|
EXPECT_THAT(
|
|
getDiagnosticString(),
|
|
HasSubstr("Expected input to be float scalar or vector: ConvertFToS"));
|
|
}
|
|
|
|
TEST_F(ValidateConversion, ConvertFToSDifferentDimension) {
|
|
const std::string body = R"(
|
|
%val = OpConvertFToS %u32 %f32vec2_01
|
|
)";
|
|
|
|
CompileSuccessfully(GenerateShaderCode(body).c_str());
|
|
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
|
|
EXPECT_THAT(getDiagnosticString(),
|
|
HasSubstr("Expected input to have the same dimension as Result "
|
|
"Type: ConvertFToS"));
|
|
}
|
|
|
|
TEST_F(ValidateConversion, ConvertSToFSuccess) {
|
|
const std::string body = R"(
|
|
%val1 = OpConvertSToF %f32 %u32_1
|
|
%val2 = OpConvertSToF %f32 %s64_0
|
|
%val3 = OpConvertSToF %f32vec2 %s32vec2_01
|
|
)";
|
|
|
|
CompileSuccessfully(GenerateShaderCode(body).c_str());
|
|
ASSERT_EQ(SPV_SUCCESS, ValidateInstructions());
|
|
}
|
|
|
|
TEST_F(ValidateConversion, ConvertSToFWrongResultType) {
|
|
const std::string body = R"(
|
|
%val = OpConvertSToF %u32 %s32_1
|
|
)";
|
|
|
|
CompileSuccessfully(GenerateShaderCode(body).c_str());
|
|
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
|
|
EXPECT_THAT(
|
|
getDiagnosticString(),
|
|
HasSubstr(
|
|
"Expected float scalar or vector type as Result Type: ConvertSToF"));
|
|
}
|
|
|
|
TEST_F(ValidateConversion, ConvertSToFWrongInputType) {
|
|
const std::string body = R"(
|
|
%val = OpConvertSToF %f32 %f32_1
|
|
)";
|
|
|
|
CompileSuccessfully(GenerateShaderCode(body).c_str());
|
|
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
|
|
EXPECT_THAT(
|
|
getDiagnosticString(),
|
|
HasSubstr("Expected input to be int scalar or vector: ConvertSToF"));
|
|
}
|
|
|
|
TEST_F(ValidateConversion, ConvertSToFDifferentDimension) {
|
|
const std::string body = R"(
|
|
%val = OpConvertSToF %f32 %u32vec2_01
|
|
)";
|
|
|
|
CompileSuccessfully(GenerateShaderCode(body).c_str());
|
|
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
|
|
EXPECT_THAT(getDiagnosticString(),
|
|
HasSubstr("Expected input to have the same dimension as Result "
|
|
"Type: ConvertSToF"));
|
|
}
|
|
|
|
TEST_F(ValidateConversion, UConvertSuccess) {
|
|
const std::string body = R"(
|
|
%val1 = OpUConvert %u32 %u64_1
|
|
%val2 = OpUConvert %u64 %s32_0
|
|
%val3 = OpUConvert %u64vec2 %s32vec2_01
|
|
)";
|
|
|
|
CompileSuccessfully(GenerateShaderCode(body).c_str());
|
|
ASSERT_EQ(SPV_SUCCESS, ValidateInstructions());
|
|
}
|
|
|
|
TEST_F(ValidateConversion, UConvertWrongResultType) {
|
|
const std::string body = R"(
|
|
%val = OpUConvert %s32 %s32_1
|
|
)";
|
|
|
|
CompileSuccessfully(GenerateShaderCode(body).c_str());
|
|
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
|
|
EXPECT_THAT(getDiagnosticString(),
|
|
HasSubstr("Expected unsigned int scalar or vector type as Result "
|
|
"Type: UConvert"));
|
|
}
|
|
|
|
TEST_F(ValidateConversion, UConvertWrongInputType) {
|
|
const std::string body = R"(
|
|
%val = OpUConvert %u32 %f32_1
|
|
)";
|
|
|
|
CompileSuccessfully(GenerateShaderCode(body).c_str());
|
|
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
|
|
EXPECT_THAT(getDiagnosticString(),
|
|
HasSubstr("Expected input to be int scalar or vector: UConvert"));
|
|
}
|
|
|
|
TEST_F(ValidateConversion, UConvertDifferentDimension) {
|
|
const std::string body = R"(
|
|
%val = OpUConvert %u32 %u32vec2_01
|
|
)";
|
|
|
|
CompileSuccessfully(GenerateShaderCode(body).c_str());
|
|
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
|
|
EXPECT_THAT(getDiagnosticString(),
|
|
HasSubstr("Expected input to have the same dimension as Result "
|
|
"Type: UConvert"));
|
|
}
|
|
|
|
TEST_F(ValidateConversion, UConvertSameBitWidth) {
|
|
const std::string body = R"(
|
|
%val = OpUConvert %u32 %s32_1
|
|
)";
|
|
|
|
CompileSuccessfully(GenerateShaderCode(body).c_str());
|
|
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
|
|
EXPECT_THAT(getDiagnosticString(),
|
|
HasSubstr("Expected input to have different bit width from "
|
|
"Result Type: UConvert"));
|
|
}
|
|
|
|
TEST_F(ValidateConversion, SConvertSuccess) {
|
|
const std::string body = R"(
|
|
%val1 = OpSConvert %s32 %u64_1
|
|
%val2 = OpSConvert %s64 %s32_0
|
|
%val3 = OpSConvert %u64vec2 %s32vec2_01
|
|
)";
|
|
|
|
CompileSuccessfully(GenerateShaderCode(body).c_str());
|
|
ASSERT_EQ(SPV_SUCCESS, ValidateInstructions());
|
|
}
|
|
|
|
TEST_F(ValidateConversion, SConvertWrongResultType) {
|
|
const std::string body = R"(
|
|
%val = OpSConvert %f32 %s32_1
|
|
)";
|
|
|
|
CompileSuccessfully(GenerateShaderCode(body).c_str());
|
|
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
|
|
EXPECT_THAT(
|
|
getDiagnosticString(),
|
|
HasSubstr("Expected int scalar or vector type as Result Type: SConvert"));
|
|
}
|
|
|
|
TEST_F(ValidateConversion, SConvertWrongInputType) {
|
|
const std::string body = R"(
|
|
%val = OpSConvert %u32 %f32_1
|
|
)";
|
|
|
|
CompileSuccessfully(GenerateShaderCode(body).c_str());
|
|
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
|
|
EXPECT_THAT(getDiagnosticString(),
|
|
HasSubstr("Expected input to be int scalar or vector: SConvert"));
|
|
}
|
|
|
|
TEST_F(ValidateConversion, SConvertDifferentDimension) {
|
|
const std::string body = R"(
|
|
%val = OpSConvert %s32 %u32vec2_01
|
|
)";
|
|
|
|
CompileSuccessfully(GenerateShaderCode(body).c_str());
|
|
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
|
|
EXPECT_THAT(getDiagnosticString(),
|
|
HasSubstr("Expected input to have the same dimension as Result "
|
|
"Type: SConvert"));
|
|
}
|
|
|
|
TEST_F(ValidateConversion, SConvertSameBitWidth) {
|
|
const std::string body = R"(
|
|
%val = OpSConvert %u32 %s32_1
|
|
)";
|
|
|
|
CompileSuccessfully(GenerateShaderCode(body).c_str());
|
|
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
|
|
EXPECT_THAT(getDiagnosticString(),
|
|
HasSubstr("Expected input to have different bit width from "
|
|
"Result Type: SConvert"));
|
|
}
|
|
|
|
TEST_F(ValidateConversion, FConvertSuccess) {
|
|
const std::string body = R"(
|
|
%val1 = OpFConvert %f32 %f64_1
|
|
%val2 = OpFConvert %f64 %f32_0
|
|
%val3 = OpFConvert %f64vec2 %f32vec2_01
|
|
)";
|
|
|
|
CompileSuccessfully(GenerateShaderCode(body).c_str());
|
|
ASSERT_EQ(SPV_SUCCESS, ValidateInstructions());
|
|
}
|
|
|
|
TEST_F(ValidateConversion, FConvertWrongResultType) {
|
|
const std::string body = R"(
|
|
%val = OpFConvert %u32 %f32_1
|
|
)";
|
|
|
|
CompileSuccessfully(GenerateShaderCode(body).c_str());
|
|
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
|
|
EXPECT_THAT(
|
|
getDiagnosticString(),
|
|
HasSubstr(
|
|
"Expected float scalar or vector type as Result Type: FConvert"));
|
|
}
|
|
|
|
TEST_F(ValidateConversion, FConvertWrongInputType) {
|
|
const std::string body = R"(
|
|
%val = OpFConvert %f32 %u64_1
|
|
)";
|
|
|
|
CompileSuccessfully(GenerateShaderCode(body).c_str());
|
|
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
|
|
EXPECT_THAT(
|
|
getDiagnosticString(),
|
|
HasSubstr("Expected input to be float scalar or vector: FConvert"));
|
|
}
|
|
|
|
TEST_F(ValidateConversion, FConvertDifferentDimension) {
|
|
const std::string body = R"(
|
|
%val = OpFConvert %f64 %f32vec2_01
|
|
)";
|
|
|
|
CompileSuccessfully(GenerateShaderCode(body).c_str());
|
|
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
|
|
EXPECT_THAT(getDiagnosticString(),
|
|
HasSubstr("Expected input to have the same dimension as Result "
|
|
"Type: FConvert"));
|
|
}
|
|
|
|
TEST_F(ValidateConversion, FConvertSameBitWidth) {
|
|
const std::string body = R"(
|
|
%val = OpFConvert %f32 %f32_1
|
|
)";
|
|
|
|
CompileSuccessfully(GenerateShaderCode(body).c_str());
|
|
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
|
|
EXPECT_THAT(getDiagnosticString(),
|
|
HasSubstr("Expected input to have different bit width from "
|
|
"Result Type: FConvert"));
|
|
}
|
|
|
|
TEST_F(ValidateConversion, QuantizeToF16Success) {
|
|
const std::string body = R"(
|
|
%val1 = OpQuantizeToF16 %f32 %f32_1
|
|
%val2 = OpQuantizeToF16 %f32 %f32_0
|
|
%val3 = OpQuantizeToF16 %f32vec2 %f32vec2_01
|
|
)";
|
|
|
|
CompileSuccessfully(GenerateShaderCode(body).c_str());
|
|
ASSERT_EQ(SPV_SUCCESS, ValidateInstructions());
|
|
}
|
|
|
|
TEST_F(ValidateConversion, QuantizeToF16WrongResultType) {
|
|
const std::string body = R"(
|
|
%val = OpQuantizeToF16 %u32 %f32_1
|
|
)";
|
|
|
|
CompileSuccessfully(GenerateShaderCode(body).c_str());
|
|
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
|
|
EXPECT_THAT(
|
|
getDiagnosticString(),
|
|
HasSubstr("Expected 32-bit float scalar or vector type as Result Type: "
|
|
"QuantizeToF16"));
|
|
}
|
|
|
|
TEST_F(ValidateConversion, QuantizeToF16WrongResultTypeBitWidth) {
|
|
const std::string body = R"(
|
|
%val = OpQuantizeToF16 %u64 %f64_1
|
|
)";
|
|
|
|
CompileSuccessfully(GenerateShaderCode(body).c_str());
|
|
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
|
|
EXPECT_THAT(
|
|
getDiagnosticString(),
|
|
HasSubstr("Expected 32-bit float scalar or vector type as Result Type: "
|
|
"QuantizeToF16"));
|
|
}
|
|
|
|
TEST_F(ValidateConversion, QuantizeToF16WrongInputType) {
|
|
const std::string body = R"(
|
|
%val = OpQuantizeToF16 %f32 %f64_1
|
|
)";
|
|
|
|
CompileSuccessfully(GenerateShaderCode(body).c_str());
|
|
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
|
|
EXPECT_THAT(
|
|
getDiagnosticString(),
|
|
HasSubstr(
|
|
"Expected input type to be equal to Result Type: QuantizeToF16"));
|
|
}
|
|
|
|
TEST_F(ValidateConversion, ConvertPtrToUSuccess) {
|
|
const std::string body = R"(
|
|
%ptr = OpVariable %f32ptr_func Function
|
|
%val1 = OpConvertPtrToU %u32 %ptr
|
|
%val2 = OpConvertPtrToU %u64 %ptr
|
|
)";
|
|
|
|
CompileSuccessfully(GenerateKernelCode(body).c_str());
|
|
ASSERT_EQ(SPV_SUCCESS, ValidateInstructions());
|
|
}
|
|
|
|
TEST_F(ValidateConversion, ConvertPtrToUWrongResultType) {
|
|
const std::string body = R"(
|
|
%ptr = OpVariable %f32ptr_func Function
|
|
%val = OpConvertPtrToU %f32 %ptr
|
|
)";
|
|
|
|
CompileSuccessfully(GenerateKernelCode(body).c_str());
|
|
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
|
|
EXPECT_THAT(getDiagnosticString(),
|
|
HasSubstr("Expected unsigned int scalar type as Result Type: "
|
|
"ConvertPtrToU"));
|
|
}
|
|
|
|
TEST_F(ValidateConversion, ConvertPtrToUNotPointer) {
|
|
const std::string body = R"(
|
|
%val = OpConvertPtrToU %u32 %f32_1
|
|
)";
|
|
|
|
CompileSuccessfully(GenerateKernelCode(body).c_str());
|
|
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
|
|
EXPECT_THAT(getDiagnosticString(),
|
|
HasSubstr("Expected input to be a pointer: ConvertPtrToU"));
|
|
}
|
|
|
|
TEST_F(ValidateConversion, SatConvertSToUSuccess) {
|
|
const std::string body = R"(
|
|
%val1 = OpSatConvertSToU %u32 %u64_2
|
|
%val2 = OpSatConvertSToU %u64 %u32_1
|
|
%val3 = OpSatConvertSToU %u64vec2 %u32vec2_12
|
|
)";
|
|
|
|
CompileSuccessfully(GenerateKernelCode(body).c_str());
|
|
ASSERT_EQ(SPV_SUCCESS, ValidateInstructions());
|
|
}
|
|
|
|
TEST_F(ValidateConversion, SatConvertSToUWrongResultType) {
|
|
const std::string body = R"(
|
|
%val = OpSatConvertSToU %f32 %u32_1
|
|
)";
|
|
|
|
CompileSuccessfully(GenerateKernelCode(body).c_str());
|
|
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
|
|
EXPECT_THAT(getDiagnosticString(),
|
|
HasSubstr("Expected int scalar or vector type as Result Type: "
|
|
"SatConvertSToU"));
|
|
}
|
|
|
|
TEST_F(ValidateConversion, SatConvertSToUWrongInputType) {
|
|
const std::string body = R"(
|
|
%val = OpSatConvertSToU %u32 %f32_1
|
|
)";
|
|
|
|
CompileSuccessfully(GenerateKernelCode(body).c_str());
|
|
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
|
|
EXPECT_THAT(
|
|
getDiagnosticString(),
|
|
HasSubstr("Expected int scalar or vector as input: SatConvertSToU"));
|
|
}
|
|
|
|
TEST_F(ValidateConversion, SatConvertSToUDifferentDimension) {
|
|
const std::string body = R"(
|
|
%val = OpSatConvertSToU %u32 %u32vec2_12
|
|
)";
|
|
|
|
CompileSuccessfully(GenerateKernelCode(body).c_str());
|
|
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
|
|
EXPECT_THAT(
|
|
getDiagnosticString(),
|
|
HasSubstr("Expected input to have the same dimension as Result Type: "
|
|
"SatConvertSToU"));
|
|
}
|
|
|
|
TEST_F(ValidateConversion, ConvertUToPtrSuccess) {
|
|
const std::string body = R"(
|
|
%val1 = OpConvertUToPtr %f32ptr_func %u32_1
|
|
%val2 = OpConvertUToPtr %f32ptr_func %u64_1
|
|
)";
|
|
|
|
CompileSuccessfully(GenerateKernelCode(body).c_str());
|
|
ASSERT_EQ(SPV_SUCCESS, ValidateInstructions());
|
|
}
|
|
|
|
TEST_F(ValidateConversion, ConvertUToPtrWrongResultType) {
|
|
const std::string body = R"(
|
|
%val = OpConvertUToPtr %f32 %u32_1
|
|
)";
|
|
|
|
CompileSuccessfully(GenerateKernelCode(body).c_str());
|
|
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
|
|
EXPECT_THAT(getDiagnosticString(),
|
|
HasSubstr("Expected Result Type to be a pointer: ConvertUToPtr"));
|
|
}
|
|
|
|
TEST_F(ValidateConversion, ConvertUToPtrNotInt) {
|
|
const std::string body = R"(
|
|
%val = OpConvertUToPtr %f32ptr_func %f32_1
|
|
)";
|
|
|
|
CompileSuccessfully(GenerateKernelCode(body).c_str());
|
|
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
|
|
EXPECT_THAT(getDiagnosticString(),
|
|
HasSubstr("Expected int scalar as input: ConvertUToPtr"));
|
|
}
|
|
|
|
TEST_F(ValidateConversion, ConvertUToPtrNotIntScalar) {
|
|
const std::string body = R"(
|
|
%val = OpConvertUToPtr %f32ptr_func %u32vec2_12
|
|
)";
|
|
|
|
CompileSuccessfully(GenerateKernelCode(body).c_str());
|
|
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
|
|
EXPECT_THAT(getDiagnosticString(),
|
|
HasSubstr("Expected int scalar as input: ConvertUToPtr"));
|
|
}
|
|
|
|
TEST_F(ValidateConversion, PtrCastToGenericSuccess) {
|
|
const std::string body = R"(
|
|
%ptr_func = OpVariable %f32ptr_func Function
|
|
%val = OpPtrCastToGeneric %f32ptr_gen %ptr_func
|
|
)";
|
|
|
|
CompileSuccessfully(GenerateKernelCode(body).c_str());
|
|
ASSERT_EQ(SPV_SUCCESS, ValidateInstructions());
|
|
}
|
|
|
|
TEST_F(ValidateConversion, PtrCastToGenericWrongResultType) {
|
|
const std::string body = R"(
|
|
%ptr_func = OpVariable %f32ptr_func Function
|
|
%val = OpPtrCastToGeneric %f32 %ptr_func
|
|
)";
|
|
|
|
CompileSuccessfully(GenerateKernelCode(body).c_str());
|
|
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
|
|
EXPECT_THAT(
|
|
getDiagnosticString(),
|
|
HasSubstr("Expected Result Type to be a pointer: PtrCastToGeneric"));
|
|
}
|
|
|
|
TEST_F(ValidateConversion, PtrCastToGenericWrongResultStorageClass) {
|
|
const std::string body = R"(
|
|
%ptr_func = OpVariable %f32ptr_func Function
|
|
%val = OpPtrCastToGeneric %f32ptr_func %ptr_func
|
|
)";
|
|
|
|
CompileSuccessfully(GenerateKernelCode(body).c_str());
|
|
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
|
|
EXPECT_THAT(getDiagnosticString(),
|
|
HasSubstr("Expected Result Type to have storage class Generic: "
|
|
"PtrCastToGeneric"));
|
|
}
|
|
|
|
TEST_F(ValidateConversion, PtrCastToGenericWrongInputType) {
|
|
const std::string body = R"(
|
|
%ptr_func = OpVariable %f32ptr_func Function
|
|
%val = OpPtrCastToGeneric %f32ptr_gen %f32
|
|
)";
|
|
|
|
CompileSuccessfully(GenerateKernelCode(body).c_str());
|
|
ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
|
|
EXPECT_THAT(getDiagnosticString(), HasSubstr("Operand 4[%float] cannot be a "
|
|
"type"));
|
|
}
|
|
|
|
TEST_F(ValidateConversion, PtrCastToGenericWrongInputStorageClass) {
|
|
const std::string body = R"(
|
|
%val = OpPtrCastToGeneric %f32ptr_gen %f32inp
|
|
)";
|
|
|
|
CompileSuccessfully(GenerateKernelCode(body).c_str());
|
|
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
|
|
EXPECT_THAT(getDiagnosticString(),
|
|
HasSubstr("Expected input to have storage class Workgroup, "
|
|
"CrossWorkgroup or Function: PtrCastToGeneric"));
|
|
}
|
|
|
|
TEST_F(ValidateConversion, PtrCastToGenericPointToDifferentType) {
|
|
const std::string body = R"(
|
|
%ptr_func = OpVariable %u32ptr_func Function
|
|
%val = OpPtrCastToGeneric %f32ptr_gen %ptr_func
|
|
)";
|
|
|
|
CompileSuccessfully(GenerateKernelCode(body).c_str());
|
|
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
|
|
EXPECT_THAT(
|
|
getDiagnosticString(),
|
|
HasSubstr("Expected input and Result Type to point to the same type: "
|
|
"PtrCastToGeneric"));
|
|
}
|
|
|
|
TEST_F(ValidateConversion, GenericCastToPtrSuccess) {
|
|
const std::string body = R"(
|
|
%ptr_func = OpVariable %f32ptr_func Function
|
|
%ptr_gen = OpPtrCastToGeneric %f32ptr_gen %ptr_func
|
|
%ptr_func2 = OpGenericCastToPtr %f32ptr_func %ptr_gen
|
|
%ptr_wg = OpGenericCastToPtr %f32ptr_wg %ptr_gen
|
|
%ptr_cwg = OpGenericCastToPtr %f32ptr_cwg %ptr_gen
|
|
)";
|
|
|
|
CompileSuccessfully(GenerateKernelCode(body).c_str());
|
|
ASSERT_EQ(SPV_SUCCESS, ValidateInstructions());
|
|
}
|
|
|
|
TEST_F(ValidateConversion, GenericCastToPtrWrongResultType) {
|
|
const std::string body = R"(
|
|
%ptr_func = OpVariable %f32ptr_func Function
|
|
%ptr_gen = OpPtrCastToGeneric %f32ptr_gen %ptr_func
|
|
%ptr_func2 = OpGenericCastToPtr %f32 %ptr_gen
|
|
)";
|
|
|
|
CompileSuccessfully(GenerateKernelCode(body).c_str());
|
|
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
|
|
EXPECT_THAT(
|
|
getDiagnosticString(),
|
|
HasSubstr("Expected Result Type to be a pointer: GenericCastToPtr"));
|
|
}
|
|
|
|
TEST_F(ValidateConversion, GenericCastToPtrWrongResultStorageClass) {
|
|
const std::string body = R"(
|
|
%ptr_func = OpVariable %f32ptr_func Function
|
|
%ptr_gen = OpPtrCastToGeneric %f32ptr_gen %ptr_func
|
|
%ptr_func2 = OpGenericCastToPtr %f32ptr_gen %ptr_gen
|
|
)";
|
|
|
|
CompileSuccessfully(GenerateKernelCode(body).c_str());
|
|
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
|
|
EXPECT_THAT(getDiagnosticString(),
|
|
HasSubstr("Expected Result Type to have storage class Workgroup, "
|
|
"CrossWorkgroup or Function: GenericCastToPtr"));
|
|
}
|
|
|
|
TEST_F(ValidateConversion, GenericCastToPtrWrongInputType) {
|
|
const std::string body = R"(
|
|
%ptr_func = OpVariable %f32ptr_func Function
|
|
%ptr_gen = OpPtrCastToGeneric %f32ptr_gen %ptr_func
|
|
%ptr_func2 = OpGenericCastToPtr %f32ptr_func %f32_1
|
|
)";
|
|
|
|
CompileSuccessfully(GenerateKernelCode(body).c_str());
|
|
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
|
|
EXPECT_THAT(getDiagnosticString(),
|
|
HasSubstr("Expected input to be a pointer: GenericCastToPtr"));
|
|
}
|
|
|
|
TEST_F(ValidateConversion, GenericCastToPtrWrongInputStorageClass) {
|
|
const std::string body = R"(
|
|
%ptr_func = OpVariable %f32ptr_func Function
|
|
%ptr_func2 = OpGenericCastToPtr %f32ptr_func %ptr_func
|
|
)";
|
|
|
|
CompileSuccessfully(GenerateKernelCode(body).c_str());
|
|
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
|
|
EXPECT_THAT(getDiagnosticString(),
|
|
HasSubstr("Expected input to have storage class Generic: "
|
|
"GenericCastToPtr"));
|
|
}
|
|
|
|
TEST_F(ValidateConversion, GenericCastToPtrPointToDifferentType) {
|
|
const std::string body = R"(
|
|
%ptr_func = OpVariable %f32ptr_func Function
|
|
%ptr_gen = OpPtrCastToGeneric %f32ptr_gen %ptr_func
|
|
%ptr_func2 = OpGenericCastToPtr %u32ptr_func %ptr_gen
|
|
)";
|
|
|
|
CompileSuccessfully(GenerateKernelCode(body).c_str());
|
|
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
|
|
EXPECT_THAT(
|
|
getDiagnosticString(),
|
|
HasSubstr("Expected input and Result Type to point to the same type: "
|
|
"GenericCastToPtr"));
|
|
}
|
|
|
|
TEST_F(ValidateConversion, GenericCastToPtrExplicitSuccess) {
|
|
const std::string body = R"(
|
|
%ptr_func = OpVariable %f32ptr_func Function
|
|
%ptr_gen = OpPtrCastToGeneric %f32ptr_gen %ptr_func
|
|
%ptr_func2 = OpGenericCastToPtrExplicit %f32ptr_func %ptr_gen Function
|
|
%ptr_wg = OpGenericCastToPtrExplicit %f32ptr_wg %ptr_gen Workgroup
|
|
%ptr_cwg = OpGenericCastToPtrExplicit %f32ptr_cwg %ptr_gen CrossWorkgroup
|
|
)";
|
|
|
|
CompileSuccessfully(GenerateKernelCode(body).c_str());
|
|
ASSERT_EQ(SPV_SUCCESS, ValidateInstructions());
|
|
}
|
|
|
|
TEST_F(ValidateConversion, GenericCastToPtrExplicitWrongResultType) {
|
|
const std::string body = R"(
|
|
%ptr_func = OpVariable %f32ptr_func Function
|
|
%ptr_gen = OpPtrCastToGeneric %f32ptr_gen %ptr_func
|
|
%ptr_func2 = OpGenericCastToPtrExplicit %f32 %ptr_gen Function
|
|
)";
|
|
|
|
CompileSuccessfully(GenerateKernelCode(body).c_str());
|
|
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
|
|
EXPECT_THAT(
|
|
getDiagnosticString(),
|
|
HasSubstr(
|
|
"Expected Result Type to be a pointer: GenericCastToPtrExplicit"));
|
|
}
|
|
|
|
TEST_F(ValidateConversion, GenericCastToPtrExplicitResultStorageClassDiffers) {
|
|
const std::string body = R"(
|
|
%ptr_func = OpVariable %f32ptr_func Function
|
|
%ptr_gen = OpPtrCastToGeneric %f32ptr_gen %ptr_func
|
|
%ptr_func2 = OpGenericCastToPtrExplicit %f32ptr_func %ptr_gen Workgroup
|
|
)";
|
|
|
|
CompileSuccessfully(GenerateKernelCode(body).c_str());
|
|
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
|
|
EXPECT_THAT(getDiagnosticString(),
|
|
HasSubstr("Expected Result Type to be of target storage class: "
|
|
"GenericCastToPtrExplicit"));
|
|
}
|
|
|
|
TEST_F(ValidateConversion, GenericCastToPtrExplicitWrongResultStorageClass) {
|
|
const std::string body = R"(
|
|
%ptr_func = OpVariable %f32ptr_func Function
|
|
%ptr_gen = OpPtrCastToGeneric %f32ptr_gen %ptr_func
|
|
%ptr_func2 = OpGenericCastToPtrExplicit %f32ptr_gen %ptr_gen Generic
|
|
)";
|
|
|
|
CompileSuccessfully(GenerateKernelCode(body).c_str());
|
|
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
|
|
EXPECT_THAT(
|
|
getDiagnosticString(),
|
|
HasSubstr("Expected target storage class to be Workgroup, "
|
|
"CrossWorkgroup or Function: GenericCastToPtrExplicit"));
|
|
}
|
|
|
|
TEST_F(ValidateConversion, GenericCastToPtrExplicitWrongInputType) {
|
|
const std::string body = R"(
|
|
%ptr_func = OpVariable %f32ptr_func Function
|
|
%ptr_gen = OpPtrCastToGeneric %f32ptr_gen %ptr_func
|
|
%ptr_func2 = OpGenericCastToPtrExplicit %f32ptr_func %f32_1 Function
|
|
)";
|
|
|
|
CompileSuccessfully(GenerateKernelCode(body).c_str());
|
|
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
|
|
EXPECT_THAT(
|
|
getDiagnosticString(),
|
|
HasSubstr("Expected input to be a pointer: GenericCastToPtrExplicit"));
|
|
}
|
|
|
|
TEST_F(ValidateConversion, GenericCastToPtrExplicitWrongInputStorageClass) {
|
|
const std::string body = R"(
|
|
%ptr_func = OpVariable %f32ptr_func Function
|
|
%ptr_func2 = OpGenericCastToPtrExplicit %f32ptr_func %ptr_func Function
|
|
)";
|
|
|
|
CompileSuccessfully(GenerateKernelCode(body).c_str());
|
|
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
|
|
EXPECT_THAT(getDiagnosticString(),
|
|
HasSubstr("Expected input to have storage class Generic: "
|
|
"GenericCastToPtrExplicit"));
|
|
}
|
|
|
|
TEST_F(ValidateConversion, GenericCastToPtrExplicitPointToDifferentType) {
|
|
const std::string body = R"(
|
|
%ptr_func = OpVariable %f32ptr_func Function
|
|
%ptr_gen = OpPtrCastToGeneric %f32ptr_gen %ptr_func
|
|
%ptr_func2 = OpGenericCastToPtrExplicit %u32ptr_func %ptr_gen Function
|
|
)";
|
|
|
|
CompileSuccessfully(GenerateKernelCode(body).c_str());
|
|
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
|
|
EXPECT_THAT(
|
|
getDiagnosticString(),
|
|
HasSubstr("Expected input and Result Type to point to the same type: "
|
|
"GenericCastToPtrExplicit"));
|
|
}
|
|
|
|
TEST_F(ValidateConversion, CoopMatConversionSuccess) {
|
|
const std::string body =
|
|
R"(
|
|
OpCapability Shader
|
|
OpCapability Float16
|
|
OpCapability Int16
|
|
OpCapability CooperativeMatrixNV
|
|
OpExtension "SPV_NV_cooperative_matrix"
|
|
OpMemoryModel Logical GLSL450
|
|
OpEntryPoint GLCompute %main "main"
|
|
%void = OpTypeVoid
|
|
%func = OpTypeFunction %void
|
|
%bool = OpTypeBool
|
|
%f16 = OpTypeFloat 16
|
|
%f32 = OpTypeFloat 32
|
|
%u16 = OpTypeInt 16 0
|
|
%u32 = OpTypeInt 32 0
|
|
%s16 = OpTypeInt 16 1
|
|
%s32 = OpTypeInt 32 1
|
|
|
|
%u32_8 = OpConstant %u32 8
|
|
%subgroup = OpConstant %u32 3
|
|
|
|
%f16mat = OpTypeCooperativeMatrixNV %f16 %subgroup %u32_8 %u32_8
|
|
%f32mat = OpTypeCooperativeMatrixNV %f32 %subgroup %u32_8 %u32_8
|
|
%u16mat = OpTypeCooperativeMatrixNV %u16 %subgroup %u32_8 %u32_8
|
|
%u32mat = OpTypeCooperativeMatrixNV %u32 %subgroup %u32_8 %u32_8
|
|
%s16mat = OpTypeCooperativeMatrixNV %s16 %subgroup %u32_8 %u32_8
|
|
%s32mat = OpTypeCooperativeMatrixNV %s32 %subgroup %u32_8 %u32_8
|
|
|
|
%f16_1 = OpConstant %f16 1
|
|
%f32_1 = OpConstant %f32 1
|
|
%u16_1 = OpConstant %u16 1
|
|
%u32_1 = OpConstant %u32 1
|
|
%s16_1 = OpConstant %s16 1
|
|
%s32_1 = OpConstant %s32 1
|
|
|
|
%f16mat_1 = OpConstantComposite %f16mat %f16_1
|
|
%f32mat_1 = OpConstantComposite %f32mat %f32_1
|
|
%u16mat_1 = OpConstantComposite %u16mat %u16_1
|
|
%u32mat_1 = OpConstantComposite %u32mat %u32_1
|
|
%s16mat_1 = OpConstantComposite %s16mat %s16_1
|
|
%s32mat_1 = OpConstantComposite %s32mat %s32_1
|
|
|
|
%main = OpFunction %void None %func
|
|
%main_entry = OpLabel
|
|
|
|
%val11 = OpConvertFToU %u16mat %f16mat_1
|
|
%val12 = OpConvertFToU %u32mat %f16mat_1
|
|
%val13 = OpConvertFToS %s16mat %f16mat_1
|
|
%val14 = OpConvertFToS %s32mat %f16mat_1
|
|
%val15 = OpFConvert %f32mat %f16mat_1
|
|
|
|
%val21 = OpConvertFToU %u16mat %f32mat_1
|
|
%val22 = OpConvertFToU %u32mat %f32mat_1
|
|
%val23 = OpConvertFToS %s16mat %f32mat_1
|
|
%val24 = OpConvertFToS %s32mat %f32mat_1
|
|
%val25 = OpFConvert %f16mat %f32mat_1
|
|
|
|
%val31 = OpConvertUToF %f16mat %u16mat_1
|
|
%val32 = OpConvertUToF %f32mat %u16mat_1
|
|
%val33 = OpUConvert %u32mat %u16mat_1
|
|
%val34 = OpSConvert %s32mat %u16mat_1
|
|
|
|
%val41 = OpConvertSToF %f16mat %s16mat_1
|
|
%val42 = OpConvertSToF %f32mat %s16mat_1
|
|
%val43 = OpUConvert %u32mat %s16mat_1
|
|
%val44 = OpSConvert %s32mat %s16mat_1
|
|
|
|
OpReturn
|
|
OpFunctionEnd)";
|
|
|
|
CompileSuccessfully(body.c_str());
|
|
ASSERT_EQ(SPV_SUCCESS, ValidateInstructions());
|
|
}
|
|
|
|
TEST_F(ValidateConversion, CoopMatConversionShapesMismatchFail) {
|
|
const std::string body =
|
|
R"(
|
|
OpCapability Shader
|
|
OpCapability Float16
|
|
OpCapability Int16
|
|
OpCapability CooperativeMatrixNV
|
|
OpExtension "SPV_NV_cooperative_matrix"
|
|
OpMemoryModel Logical GLSL450
|
|
OpEntryPoint GLCompute %main "main"
|
|
%void = OpTypeVoid
|
|
%func = OpTypeFunction %void
|
|
%bool = OpTypeBool
|
|
%f16 = OpTypeFloat 16
|
|
%f32 = OpTypeFloat 32
|
|
%u16 = OpTypeInt 16 0
|
|
%u32 = OpTypeInt 32 0
|
|
%s16 = OpTypeInt 16 1
|
|
%s32 = OpTypeInt 32 1
|
|
|
|
%u32_8 = OpConstant %u32 8
|
|
%u32_4 = OpConstant %u32 4
|
|
%subgroup = OpConstant %u32 3
|
|
|
|
%f16mat = OpTypeCooperativeMatrixNV %f16 %subgroup %u32_8 %u32_8
|
|
%f32mat = OpTypeCooperativeMatrixNV %f32 %subgroup %u32_4 %u32_4
|
|
|
|
%f16_1 = OpConstant %f16 1
|
|
|
|
%f16mat_1 = OpConstantComposite %f16mat %f16_1
|
|
|
|
%main = OpFunction %void None %func
|
|
%main_entry = OpLabel
|
|
|
|
%val15 = OpFConvert %f32mat %f16mat_1
|
|
|
|
OpReturn
|
|
OpFunctionEnd)";
|
|
|
|
CompileSuccessfully(body.c_str());
|
|
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
|
|
EXPECT_THAT(
|
|
getDiagnosticString(),
|
|
HasSubstr(
|
|
"Expected rows of Matrix type and Result Type to be identical"));
|
|
}
|
|
|
|
TEST_F(ValidateConversion, CoopMatConversionShapesMismatchPass) {
|
|
const std::string body =
|
|
R"(
|
|
OpCapability Shader
|
|
OpCapability Float16
|
|
OpCapability Int16
|
|
OpCapability CooperativeMatrixNV
|
|
OpExtension "SPV_NV_cooperative_matrix"
|
|
OpMemoryModel Logical GLSL450
|
|
OpEntryPoint GLCompute %main "main"
|
|
%void = OpTypeVoid
|
|
%func = OpTypeFunction %void
|
|
%bool = OpTypeBool
|
|
%f16 = OpTypeFloat 16
|
|
%f32 = OpTypeFloat 32
|
|
%u16 = OpTypeInt 16 0
|
|
%u32 = OpTypeInt 32 0
|
|
%s16 = OpTypeInt 16 1
|
|
%s32 = OpTypeInt 32 1
|
|
|
|
%u32_8 = OpConstant %u32 8
|
|
%u32_4 = OpSpecConstant %u32 4
|
|
%subgroup = OpConstant %u32 3
|
|
|
|
%f16mat = OpTypeCooperativeMatrixNV %f16 %subgroup %u32_8 %u32_8
|
|
%f32mat = OpTypeCooperativeMatrixNV %f32 %subgroup %u32_4 %u32_4
|
|
|
|
%f16_1 = OpConstant %f16 1
|
|
|
|
%f16mat_1 = OpConstantComposite %f16mat %f16_1
|
|
|
|
%main = OpFunction %void None %func
|
|
%main_entry = OpLabel
|
|
|
|
%val15 = OpFConvert %f32mat %f16mat_1
|
|
|
|
OpReturn
|
|
OpFunctionEnd)";
|
|
|
|
CompileSuccessfully(body.c_str());
|
|
ASSERT_EQ(SPV_SUCCESS, ValidateInstructions());
|
|
}
|
|
|
|
TEST_F(ValidateConversion, BitcastSuccess) {
|
|
const std::string body = R"(
|
|
%ptr = OpVariable %f32ptr_func Function
|
|
%val1 = OpBitcast %u32 %ptr
|
|
%val2 = OpBitcast %u64 %ptr
|
|
%val3 = OpBitcast %f32ptr_func %u32_1
|
|
%val4 = OpBitcast %f32ptr_wg %u64_1
|
|
%val5 = OpBitcast %f32 %u32_1
|
|
%val6 = OpBitcast %f32vec2 %u32vec2_12
|
|
%val7 = OpBitcast %f32vec2 %u64_1
|
|
%val8 = OpBitcast %f64 %u32vec2_12
|
|
%val9 = OpBitcast %f32vec4 %f64vec2_12
|
|
)";
|
|
|
|
CompileSuccessfully(GenerateKernelCode(body).c_str());
|
|
ASSERT_EQ(SPV_SUCCESS, ValidateInstructions());
|
|
}
|
|
|
|
TEST_F(ValidateConversion, BitcastInputHasNoType) {
|
|
const std::string body = R"(
|
|
%val = OpBitcast %u32 %f32
|
|
)";
|
|
|
|
CompileSuccessfully(GenerateKernelCode(body).c_str());
|
|
ASSERT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
|
|
EXPECT_THAT(getDiagnosticString(), HasSubstr("Operand 4[%float] cannot be a "
|
|
"type"));
|
|
}
|
|
|
|
TEST_F(ValidateConversion, BitcastWrongResultType) {
|
|
const std::string body = R"(
|
|
%val = OpBitcast %bool %f32_1
|
|
)";
|
|
|
|
CompileSuccessfully(GenerateKernelCode(body).c_str());
|
|
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
|
|
EXPECT_THAT(
|
|
getDiagnosticString(),
|
|
HasSubstr("Expected Result Type to be a pointer or int or float vector "
|
|
"or scalar type: Bitcast"));
|
|
}
|
|
|
|
TEST_F(ValidateConversion, BitcastWrongInputType) {
|
|
const std::string body = R"(
|
|
%val = OpBitcast %u32 %true
|
|
)";
|
|
|
|
CompileSuccessfully(GenerateKernelCode(body).c_str());
|
|
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
|
|
EXPECT_THAT(getDiagnosticString(),
|
|
HasSubstr("Expected input to be a pointer or int or float vector "
|
|
"or scalar: Bitcast"));
|
|
}
|
|
|
|
TEST_F(ValidateConversion, BitcastPtrWrongInputType) {
|
|
const std::string body = R"(
|
|
%val = OpBitcast %u32ptr_func %f32_1
|
|
)";
|
|
|
|
CompileSuccessfully(GenerateKernelCode(body).c_str());
|
|
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
|
|
EXPECT_THAT(
|
|
getDiagnosticString(),
|
|
HasSubstr("Expected input to be a pointer or int scalar if Result Type "
|
|
"is pointer: Bitcast"));
|
|
}
|
|
|
|
TEST_F(ValidateConversion, BitcastPtrWrongResultType) {
|
|
const std::string body = R"(
|
|
%val = OpBitcast %f32 %f32inp
|
|
)";
|
|
|
|
CompileSuccessfully(GenerateKernelCode(body).c_str());
|
|
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
|
|
EXPECT_THAT(
|
|
getDiagnosticString(),
|
|
HasSubstr(
|
|
"Pointer can only be converted to another pointer or int scalar: "
|
|
"Bitcast"));
|
|
}
|
|
|
|
TEST_F(ValidateConversion, BitcastDifferentTotalBitWidth) {
|
|
const std::string body = R"(
|
|
%val = OpBitcast %f32 %u64_1
|
|
)";
|
|
|
|
CompileSuccessfully(GenerateKernelCode(body).c_str());
|
|
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
|
|
EXPECT_THAT(
|
|
getDiagnosticString(),
|
|
HasSubstr(
|
|
"Expected input to have the same total bit width as Result Type: "
|
|
"Bitcast"));
|
|
}
|
|
|
|
TEST_F(ValidateConversion, ConvertUToPtrInputIsAType) {
|
|
const std::string spirv = R"(
|
|
OpCapability Addresses
|
|
OpCapability Shader
|
|
OpCapability Linkage
|
|
OpMemoryModel Logical GLSL450
|
|
%int = OpTypeInt 32 0
|
|
%ptr_int = OpTypePointer Function %int
|
|
%void = OpTypeVoid
|
|
%voidfn = OpTypeFunction %void
|
|
%func = OpFunction %void None %voidfn
|
|
%entry = OpLabel
|
|
%1 = OpConvertUToPtr %ptr_int %int
|
|
OpReturn
|
|
OpFunctionEnd
|
|
)";
|
|
|
|
CompileSuccessfully(spirv);
|
|
EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions());
|
|
EXPECT_THAT(getDiagnosticString(), HasSubstr("Operand 1[%uint] cannot be a "
|
|
"type"));
|
|
}
|
|
|
|
TEST_F(ValidateConversion, ConvertUToPtrPSBSuccess) {
|
|
const std::string body = R"(
|
|
OpCapability PhysicalStorageBufferAddressesEXT
|
|
OpCapability Int64
|
|
OpCapability Shader
|
|
OpExtension "SPV_EXT_physical_storage_buffer"
|
|
OpMemoryModel PhysicalStorageBuffer64EXT GLSL450
|
|
OpEntryPoint Fragment %main "main"
|
|
OpExecutionMode %main OriginUpperLeft
|
|
%uint64 = OpTypeInt 64 0
|
|
%u64_1 = OpConstant %uint64 1
|
|
%ptr = OpTypePointer PhysicalStorageBufferEXT %uint64
|
|
%void = OpTypeVoid
|
|
%voidfn = OpTypeFunction %void
|
|
%main = OpFunction %void None %voidfn
|
|
%entry = OpLabel
|
|
%val1 = OpConvertUToPtr %ptr %u64_1
|
|
OpReturn
|
|
OpFunctionEnd
|
|
)";
|
|
|
|
CompileSuccessfully(body.c_str());
|
|
ASSERT_EQ(SPV_SUCCESS, ValidateInstructions());
|
|
}
|
|
|
|
TEST_F(ValidateConversion, ConvertUToPtrPSBStorageClass) {
|
|
const std::string body = R"(
|
|
OpCapability PhysicalStorageBufferAddressesEXT
|
|
OpCapability Int64
|
|
OpCapability Shader
|
|
OpExtension "SPV_EXT_physical_storage_buffer"
|
|
OpMemoryModel PhysicalStorageBuffer64EXT GLSL450
|
|
OpEntryPoint Fragment %main "main"
|
|
OpExecutionMode %main OriginUpperLeft
|
|
%uint64 = OpTypeInt 64 0
|
|
%u64_1 = OpConstant %uint64 1
|
|
%ptr = OpTypePointer Function %uint64
|
|
%void = OpTypeVoid
|
|
%voidfn = OpTypeFunction %void
|
|
%main = OpFunction %void None %voidfn
|
|
%entry = OpLabel
|
|
%val1 = OpConvertUToPtr %ptr %u64_1
|
|
%val2 = OpConvertPtrToU %uint64 %val1
|
|
OpReturn
|
|
OpFunctionEnd
|
|
)";
|
|
|
|
CompileSuccessfully(body.c_str());
|
|
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
|
|
EXPECT_THAT(getDiagnosticString(),
|
|
HasSubstr("Pointer storage class must be "
|
|
"PhysicalStorageBufferEXT: ConvertUToPtr"));
|
|
}
|
|
|
|
TEST_F(ValidateConversion, ConvertPtrToUPSBSuccess) {
|
|
const std::string body = R"(
|
|
OpCapability PhysicalStorageBufferAddressesEXT
|
|
OpCapability Int64
|
|
OpCapability Shader
|
|
OpExtension "SPV_EXT_physical_storage_buffer"
|
|
OpMemoryModel PhysicalStorageBuffer64EXT GLSL450
|
|
OpEntryPoint Fragment %main "main"
|
|
OpExecutionMode %main OriginUpperLeft
|
|
OpDecorate %val1 RestrictPointerEXT
|
|
%uint64 = OpTypeInt 64 0
|
|
%u64_1 = OpConstant %uint64 1
|
|
%ptr = OpTypePointer PhysicalStorageBufferEXT %uint64
|
|
%pptr_f = OpTypePointer Function %ptr
|
|
%void = OpTypeVoid
|
|
%voidfn = OpTypeFunction %void
|
|
%main = OpFunction %void None %voidfn
|
|
%entry = OpLabel
|
|
%val1 = OpVariable %pptr_f Function
|
|
%val2 = OpLoad %ptr %val1
|
|
%val3 = OpConvertPtrToU %uint64 %val2
|
|
OpReturn
|
|
OpFunctionEnd
|
|
)";
|
|
|
|
CompileSuccessfully(body.c_str());
|
|
ASSERT_EQ(SPV_SUCCESS, ValidateInstructions());
|
|
}
|
|
|
|
TEST_F(ValidateConversion, ConvertPtrToUPSBStorageClass) {
|
|
const std::string body = R"(
|
|
OpCapability PhysicalStorageBufferAddressesEXT
|
|
OpCapability Int64
|
|
OpCapability Shader
|
|
OpExtension "SPV_EXT_physical_storage_buffer"
|
|
OpMemoryModel PhysicalStorageBuffer64EXT GLSL450
|
|
OpEntryPoint Fragment %main "main"
|
|
OpExecutionMode %main OriginUpperLeft
|
|
%uint64 = OpTypeInt 64 0
|
|
%u64_1 = OpConstant %uint64 1
|
|
%ptr = OpTypePointer Function %uint64
|
|
%void = OpTypeVoid
|
|
%voidfn = OpTypeFunction %void
|
|
%main = OpFunction %void None %voidfn
|
|
%entry = OpLabel
|
|
%val1 = OpVariable %ptr Function
|
|
%val2 = OpConvertPtrToU %uint64 %val1
|
|
OpReturn
|
|
OpFunctionEnd
|
|
)";
|
|
|
|
CompileSuccessfully(body.c_str());
|
|
ASSERT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions());
|
|
EXPECT_THAT(getDiagnosticString(),
|
|
HasSubstr("Pointer storage class must be "
|
|
"PhysicalStorageBufferEXT: ConvertPtrToU"));
|
|
}
|
|
|
|
using ValidateSmallConversions = spvtest::ValidateBase<std::string>;
|
|
|
|
CodeGenerator GetSmallConversionsCodeGenerator() {
|
|
CodeGenerator generator;
|
|
generator.capabilities_ = R"(
|
|
OpCapability Shader
|
|
OpCapability Linkage
|
|
OpCapability UniformAndStorageBuffer16BitAccess
|
|
OpCapability UniformAndStorageBuffer8BitAccess
|
|
)";
|
|
generator.extensions_ = R"(
|
|
OpExtension "SPV_KHR_16bit_storage"
|
|
OpExtension "SPV_KHR_8bit_storage"
|
|
)";
|
|
generator.memory_model_ = "OpMemoryModel Logical GLSL450\n";
|
|
generator.before_types_ = R"(
|
|
OpDecorate %char_block Block
|
|
OpMemberDecorate %char_block 0 Offset 0
|
|
OpDecorate %short_block Block
|
|
OpMemberDecorate %short_block 0 Offset 0
|
|
OpDecorate %half_block Block
|
|
OpMemberDecorate %half_block 0 Offset 0
|
|
OpDecorate %int_block Block
|
|
OpMemberDecorate %int_block 0 Offset 0
|
|
OpDecorate %float_block Block
|
|
OpMemberDecorate %float_block 0 Offset 0
|
|
)";
|
|
generator.types_ = R"(
|
|
%void = OpTypeVoid
|
|
%int = OpTypeInt 32 0
|
|
%int_0 = OpConstant %int 0
|
|
%int_1 = OpConstant %int 1
|
|
%int2 = OpTypeVector %int 2
|
|
%float = OpTypeFloat 32
|
|
%float_0 = OpConstant %float 0
|
|
%float2 = OpTypeVector %float 2
|
|
%char = OpTypeInt 8 0
|
|
%char2 = OpTypeVector %char 2
|
|
%short = OpTypeInt 16 0
|
|
%short2 = OpTypeVector %short 2
|
|
%half = OpTypeFloat 16
|
|
%half2 = OpTypeVector %half 2
|
|
%char_block = OpTypeStruct %char2
|
|
%short_block = OpTypeStruct %short2
|
|
%half_block = OpTypeStruct %half2
|
|
%int_block = OpTypeStruct %int2
|
|
%float_block = OpTypeStruct %float2
|
|
%ptr_ssbo_char_block = OpTypePointer StorageBuffer %char_block
|
|
%ptr_ssbo_char2 = OpTypePointer StorageBuffer %char2
|
|
%ptr_ssbo_char = OpTypePointer StorageBuffer %char
|
|
%ptr_ssbo_short_block = OpTypePointer StorageBuffer %short_block
|
|
%ptr_ssbo_short2 = OpTypePointer StorageBuffer %short2
|
|
%ptr_ssbo_short = OpTypePointer StorageBuffer %short
|
|
%ptr_ssbo_half_block = OpTypePointer StorageBuffer %half_block
|
|
%ptr_ssbo_half2 = OpTypePointer StorageBuffer %half2
|
|
%ptr_ssbo_half = OpTypePointer StorageBuffer %half
|
|
%ptr_ssbo_int_block = OpTypePointer StorageBuffer %int_block
|
|
%ptr_ssbo_int2 = OpTypePointer StorageBuffer %int2
|
|
%ptr_ssbo_int = OpTypePointer StorageBuffer %int
|
|
%ptr_ssbo_float_block = OpTypePointer StorageBuffer %float_block
|
|
%ptr_ssbo_float2 = OpTypePointer StorageBuffer %float2
|
|
%ptr_ssbo_float = OpTypePointer StorageBuffer %float
|
|
%void_fn = OpTypeFunction %void
|
|
%char_var = OpVariable %ptr_ssbo_char_block StorageBuffer
|
|
%short_var = OpVariable %ptr_ssbo_short_block StorageBuffer
|
|
%half_var = OpVariable %ptr_ssbo_half_block StorageBuffer
|
|
%int_var = OpVariable %ptr_ssbo_int_block StorageBuffer
|
|
%float_var = OpVariable %ptr_ssbo_float_block StorageBuffer
|
|
)";
|
|
generator.after_types_ = R"(
|
|
%func = OpFunction %void None %void_fn
|
|
%entry = OpLabel
|
|
%char2_gep = OpAccessChain %ptr_ssbo_char2 %char_var %int_0
|
|
%ld_char2 = OpLoad %char2 %char2_gep
|
|
%char_gep = OpAccessChain %ptr_ssbo_char %char_var %int_0 %int_0
|
|
%ld_char = OpLoad %char %char_gep
|
|
%short2_gep = OpAccessChain %ptr_ssbo_short2 %short_var %int_0
|
|
%ld_short2 = OpLoad %short2 %short2_gep
|
|
%short_gep = OpAccessChain %ptr_ssbo_short %short_var %int_0 %int_0
|
|
%ld_short = OpLoad %short %short_gep
|
|
%half2_gep = OpAccessChain %ptr_ssbo_half2 %half_var %int_0
|
|
%ld_half2 = OpLoad %half2 %half2_gep
|
|
%half_gep = OpAccessChain %ptr_ssbo_half %half_var %int_0 %int_0
|
|
%ld_half = OpLoad %half %half_gep
|
|
%int2_gep = OpAccessChain %ptr_ssbo_int2 %int_var %int_0
|
|
%ld_int2 = OpLoad %int2 %int2_gep
|
|
%int_gep = OpAccessChain %ptr_ssbo_int %int_var %int_0 %int_0
|
|
%ld_int = OpLoad %int %int_gep
|
|
%float2_gep = OpAccessChain %ptr_ssbo_float2 %float_var %int_0
|
|
%ld_float2 = OpLoad %float2 %float2_gep
|
|
%float_gep = OpAccessChain %ptr_ssbo_float %float_var %int_0 %int_0
|
|
%ld_float = OpLoad %float %float_gep
|
|
)";
|
|
generator.add_at_the_end_ = R"(
|
|
OpReturn
|
|
OpFunctionEnd
|
|
)";
|
|
return generator;
|
|
}
|
|
|
|
TEST_P(ValidateSmallConversions, Instruction) {
|
|
CodeGenerator generator = GetSmallConversionsCodeGenerator();
|
|
generator.after_types_ += GetParam() + "\n";
|
|
CompileSuccessfully(generator.Build(), SPV_ENV_UNIVERSAL_1_3);
|
|
EXPECT_EQ(SPV_ERROR_INVALID_DATA,
|
|
ValidateInstructions(SPV_ENV_UNIVERSAL_1_3));
|
|
EXPECT_THAT(
|
|
getDiagnosticString(),
|
|
HasSubstr(
|
|
"8- or 16-bit types can only be used with width-only conversions"));
|
|
}
|
|
|
|
INSTANTIATE_TEST_SUITE_P(SmallConversionInstructions, ValidateSmallConversions,
|
|
Values("%inst = OpConvertFToU %char %ld_float",
|
|
"%inst = OpConvertFToU %char2 %ld_float2",
|
|
"%inst = OpConvertFToU %short %ld_float",
|
|
"%inst = OpConvertFToU %short2 %ld_float2",
|
|
"%inst = OpConvertFToU %int %ld_half",
|
|
"%inst = OpConvertFToU %int2 %ld_half2",
|
|
"%inst = OpConvertFToS %char %ld_float",
|
|
"%inst = OpConvertFToS %char2 %ld_float2",
|
|
"%inst = OpConvertFToS %short %ld_float",
|
|
"%inst = OpConvertFToS %short2 %ld_float2",
|
|
"%inst = OpConvertFToS %int %ld_half",
|
|
"%inst = OpConvertFToS %int2 %ld_half2",
|
|
"%inst = OpConvertSToF %float %ld_char",
|
|
"%inst = OpConvertSToF %float2 %ld_char2",
|
|
"%inst = OpConvertSToF %float %ld_short",
|
|
"%inst = OpConvertSToF %float2 %ld_short2",
|
|
"%inst = OpConvertSToF %half %ld_int",
|
|
"%inst = OpConvertSToF %half2 %ld_int2",
|
|
"%inst = OpConvertUToF %float %ld_char",
|
|
"%inst = OpConvertUToF %float2 %ld_char2",
|
|
"%inst = OpConvertUToF %float %ld_short",
|
|
"%inst = OpConvertUToF %float2 %ld_short2",
|
|
"%inst = OpConvertUToF %half %ld_int",
|
|
"%inst = OpConvertUToF %half2 %ld_int2",
|
|
"%inst = OpBitcast %half %ld_short",
|
|
"%inst = OpBitcast %half2 %ld_short2",
|
|
"%inst = OpBitcast %short %ld_half",
|
|
"%inst = OpBitcast %short2 %ld_half2"));
|
|
|
|
} // namespace
|
|
} // namespace val
|
|
} // namespace spvtools
|