| // Copyright (c) 2023-2025 Arm Ltd. | |
| // | |
| // 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 "gmock/gmock.h" | |
| #include "test/unit_spirv.h" | |
| #include "test/val/val_fixtures.h" | |
| namespace spvtools { | |
| namespace val { | |
| namespace { | |
| using ::testing::ContainsRegex; | |
| using ::testing::HasSubstr; | |
| using ValidateTensor = spvtest::ValidateBase<std::string>; | |
| constexpr spv_target_env SPVENV = SPV_ENV_VULKAN_1_3; | |
| std::string GenerateModule(const std::string& body) { | |
| const std::string header = R"( | |
| OpCapability Shader | |
| OpCapability VulkanMemoryModel | |
| OpCapability Int8 | |
| OpCapability TensorsARM | |
| OpExtension "SPV_ARM_tensors" | |
| OpMemoryModel Logical Vulkan | |
| OpEntryPoint GLCompute %fnep "main" | |
| OpExecutionMode %fnep LocalSize 1 1 1 | |
| OpDecorate %tensor_var DescriptorSet 0 | |
| OpDecorate %tensor_var Binding 0 | |
| OpDecorate %tensor_var_float_unranked DescriptorSet 0 | |
| OpDecorate %tensor_var_float_unranked Binding 1 | |
| %void = OpTypeVoid | |
| %uint = OpTypeInt 32 0 | |
| %float = OpTypeFloat 32 | |
| %fnty = OpTypeFunction %void | |
| %uint_vec4 = OpTypeVector %uint 4 | |
| %uint_0 = OpConstant %uint 0 | |
| %uint_0_spec = OpSpecConstant %uint 0 | |
| %uint_1 = OpConstant %uint 1 | |
| %uint_2 = OpConstant %uint 2 | |
| %uint_3 = OpConstant %uint 3 | |
| %uint_4 = OpConstant %uint 4 | |
| %uint_42 = OpConstant %uint 42 | |
| %uint_1_bis = OpConstant %uint 1 | |
| %float_1 = OpConstant %float 1 | |
| %uint_vec4_1_1_1_1 = OpConstantComposite %uint_vec4 %uint_1 %uint_1 %uint_1 %uint_1 | |
| %uint_arr1 = OpTypeArray %uint %uint_1 | |
| %uint_arr2 = OpTypeArray %uint %uint_2 | |
| %uint_arr3 = OpTypeArray %uint %uint_3 | |
| %uint_arr4 = OpTypeArray %uint %uint_4 | |
| %float_arr4 = OpTypeArray %float %uint_4 | |
| %uint_arr4_1_1_1_1 = OpConstantComposite %uint_arr4 %uint_1 %uint_1 %uint_1 %uint_1 | |
| %uint_arr4_0_0_0_0_spec = OpSpecConstantComposite %uint_arr4 %uint_0_spec %uint_0_spec %uint_0_spec %uint_0_spec | |
| %uint_arr2_1_1 = OpConstantComposite %uint_arr2 %uint_1 %uint_1 | |
| %float_arr4_1_1_1_1 = OpConstantComposite %float_arr4 %float_1 %float_1 %float_1 %float_1 | |
| %uint_arr4_1_1_0_1 = OpConstantComposite %uint_arr4 %uint_1 %uint_1 %uint_0 %uint_1 | |
| %uint_ptr_Private = OpTypePointer Private %uint | |
| %uint_arr4_ptr_Private = OpTypePointer Private %uint_arr4 | |
| %uint_var_1 = OpVariable %uint_ptr_Private Private %uint_1 | |
| %var_uint_arr4_1_1_1_1 = OpVariable %uint_arr4_ptr_Private Private %uint_arr4_1_1_1_1 | |
| %tensor_uint_4 = OpTypeTensorARM %uint %uint_4 | |
| %tensor_uint_spec = OpTypeTensorARM %uint %uint_0_spec | |
| %tensor_float = OpTypeTensorARM %float | |
| %tensor_uint_4_ptr_UniformConstant = OpTypePointer UniformConstant %tensor_uint_4 | |
| %tensor_var = OpVariable %tensor_uint_4_ptr_UniformConstant UniformConstant | |
| %tensor_float_ptr_UniformConstant = OpTypePointer UniformConstant %tensor_float | |
| %tensor_var_float_unranked = OpVariable %tensor_float_ptr_UniformConstant UniformConstant | |
| %tensor_uint_spec_ptr_UniformConstant = OpTypePointer UniformConstant %tensor_uint_spec | |
| %tensor_var_spec_rank = OpVariable %tensor_uint_spec_ptr_UniformConstant UniformConstant | |
| )"; | |
| const std::string footer = R"( | |
| %fnep = OpFunction %void None %fnty | |
| %label = OpLabel | |
| OpReturn | |
| OpFunctionEnd | |
| )"; | |
| return header + body + footer; | |
| } | |
| // | |
| // Type tests | |
| // | |
| TEST_F(ValidateTensor, ValidTypeElementTypeOnly) { | |
| const std::string src = R"( | |
| %test_type = OpTypeTensorARM %uint | |
| )"; | |
| std::string spvasm = GenerateModule(src); | |
| CompileSuccessfully(spvasm, SPVENV); | |
| EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPVENV)); | |
| } | |
| TEST_F(ValidateTensor, InvalidTypeTensorElementTypeNotScalar) { | |
| const std::string src = R"( | |
| %test_type = OpTypeTensorARM %void | |
| )"; | |
| std::string spvasm = GenerateModule(src); | |
| CompileSuccessfully(spvasm, SPVENV); | |
| EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPVENV)); | |
| EXPECT_THAT(getDiagnosticString(), | |
| ContainsRegex("OpTypeTensorARM Element Type <id> " | |
| "'.*' is not a scalar type.*")); | |
| } | |
| TEST_F(ValidateTensor, InvalidTypeDuplicateElementTypeTensorType) { | |
| const std::string src = R"( | |
| %typeA = OpTypeTensorARM %uint | |
| %typeB = OpTypeTensorARM %uint | |
| )"; | |
| std::string spvasm = GenerateModule(src); | |
| CompileSuccessfully(spvasm, SPVENV); | |
| EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPVENV)); | |
| EXPECT_THAT( | |
| getDiagnosticString(), | |
| HasSubstr("Duplicate non-aggregate type declarations are not allowed.")); | |
| } | |
| TEST_F(ValidateTensor, ValidTypeElementTypeAndRank) { | |
| const std::string src = R"( | |
| %test_type = OpTypeTensorARM %uint %uint_1 | |
| )"; | |
| std::string spvasm = GenerateModule(src); | |
| CompileSuccessfully(spvasm, SPVENV); | |
| EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPVENV)); | |
| } | |
| TEST_F(ValidateTensor, ValidTypeElementTypeAndRankUsingSpecConstant) { | |
| const std::string src = R"( | |
| %rank_spec = OpSpecConstant %uint 0 | |
| %test_type = OpTypeTensorARM %uint %rank_spec | |
| )"; | |
| std::string spvasm = GenerateModule(src); | |
| CompileSuccessfully(spvasm, SPVENV); | |
| EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPVENV)); | |
| } | |
| TEST_F(ValidateTensor, InvalidTypeDuplicateRankedTensorType) { | |
| const std::string src = R"( | |
| %typeA = OpTypeTensorARM %uint %uint_1 | |
| %typeB = OpTypeTensorARM %uint %uint_1 | |
| )"; | |
| std::string spvasm = GenerateModule(src); | |
| CompileSuccessfully(spvasm, SPVENV); | |
| EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPVENV)); | |
| EXPECT_THAT( | |
| getDiagnosticString(), | |
| HasSubstr("Duplicate non-aggregate type declarations are not allowed.")); | |
| } | |
| TEST_F(ValidateTensor, ValidTypeEquivalentRankedTensorType) { | |
| const std::string src = R"( | |
| %typeA = OpTypeTensorARM %uint %uint_1 | |
| %typeB = OpTypeTensorARM %uint %uint_1_bis | |
| )"; | |
| std::string spvasm = GenerateModule(src); | |
| CompileSuccessfully(spvasm, SPVENV); | |
| EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPVENV)); | |
| } | |
| TEST_F(ValidateTensor, InvalidTypeRankNotConstant) { | |
| const std::string src = R"( | |
| %test_type = OpTypeTensorARM %uint %uint_var_1 | |
| )"; | |
| std::string spvasm = GenerateModule(src); | |
| CompileSuccessfully(spvasm, SPVENV); | |
| EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPVENV)); | |
| EXPECT_THAT(getDiagnosticString(), | |
| ContainsRegex("OpTypeTensorARM Rank <id> '.*' " | |
| "is not a constant instruction.*")); | |
| } | |
| TEST_F(ValidateTensor, InvalidTypeRankConstantButNotIntegerType) { | |
| const std::string src = R"( | |
| %test_type = OpTypeTensorARM %uint %float_1 | |
| )"; | |
| std::string spvasm = GenerateModule(src); | |
| CompileSuccessfully(spvasm, SPVENV); | |
| EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPVENV)); | |
| EXPECT_THAT(getDiagnosticString(), | |
| ContainsRegex("OpTypeTensorARM Rank <id> '.*' " | |
| "does not have a scalar integer type.*")); | |
| } | |
| TEST_F(ValidateTensor, InvalidTypeRankConstantIntegerTypeButNotScalar) { | |
| const std::string src = R"( | |
| %test_type = OpTypeTensorARM %uint %uint_vec4_1_1_1_1 | |
| )"; | |
| std::string spvasm = GenerateModule(src); | |
| CompileSuccessfully(spvasm, SPVENV); | |
| EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPVENV)); | |
| EXPECT_THAT(getDiagnosticString(), | |
| ContainsRegex("OpTypeTensorARM Rank <id> '.*' " | |
| "does not have a scalar integer type.*")); | |
| } | |
| TEST_F(ValidateTensor, InvalidTypeRank0) { | |
| const std::string src = R"( | |
| %test_type = OpTypeTensorARM %uint %uint_0 | |
| )"; | |
| std::string spvasm = GenerateModule(src); | |
| CompileSuccessfully(spvasm, SPVENV); | |
| EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPVENV)); | |
| EXPECT_THAT(getDiagnosticString(), | |
| ContainsRegex("OpTypeTensorARM Rank <id> '.*' must " | |
| "define a value greater than 0.*")); | |
| } | |
| TEST_F(ValidateTensor, ValidTypeElementTypeAndRankAndShape) { | |
| const std::string src = R"( | |
| %test_type = OpTypeTensorARM %uint %uint_4 %uint_arr4_1_1_1_1 | |
| )"; | |
| std::string spvasm = GenerateModule(src); | |
| CompileSuccessfully(spvasm, SPVENV); | |
| EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPVENV)); | |
| } | |
| TEST_F(ValidateTensor, ValidTypeElementTypeAndRankAndShapeUsingSpecConstant) { | |
| const std::string src = R"( | |
| %test_type = OpTypeTensorARM %uint %uint_0_spec %uint_arr4_0_0_0_0_spec | |
| )"; | |
| std::string spvasm = GenerateModule(src); | |
| CompileSuccessfully(spvasm, SPVENV); | |
| EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPVENV)); | |
| } | |
| TEST_F(ValidateTensor, InvalidTypeShapeNotConstant) { | |
| const std::string src = R"( | |
| %test_type = OpTypeTensorARM %uint %uint_4 %var_uint_arr4_1_1_1_1 | |
| )"; | |
| std::string spvasm = GenerateModule(src); | |
| CompileSuccessfully(spvasm, SPVENV); | |
| EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPVENV)); | |
| EXPECT_THAT(getDiagnosticString(), | |
| ContainsRegex("OpTypeTensorARM Shape <id> '.*' is not " | |
| "a constant instruction.*")); | |
| } | |
| TEST_F(ValidateTensor, InvalidTypeShapeConstantButNotArrayOfInteger) { | |
| const std::string src = R"( | |
| %test_type = OpTypeTensorARM %uint %uint_4 %uint_vec4_1_1_1_1 | |
| )"; | |
| std::string spvasm = GenerateModule(src); | |
| CompileSuccessfully(spvasm, SPVENV); | |
| EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPVENV)); | |
| EXPECT_THAT(getDiagnosticString(), | |
| ContainsRegex( | |
| "OpTypeTensorARM Shape <id> '.*' is not " | |
| "an array of integer type whose Length is equal to Rank.*")); | |
| } | |
| TEST_F(ValidateTensor, InvalidTypeShapeConstantArrayOfIntegerWrongLength) { | |
| const std::string src = R"( | |
| %test_type = OpTypeTensorARM %uint %uint_1 %uint_arr4_1_1_1_1 | |
| )"; | |
| std::string spvasm = GenerateModule(src); | |
| CompileSuccessfully(spvasm, SPVENV); | |
| EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPVENV)); | |
| EXPECT_THAT(getDiagnosticString(), | |
| ContainsRegex( | |
| "OpTypeTensorARM Shape <id> '.*' is not " | |
| "an array of integer type whose Length is equal to Rank.*")); | |
| } | |
| TEST_F(ValidateTensor, | |
| InvalidTypeShapeConstantArrayOfIntegerWithZeroConstituent) { | |
| const std::string src = R"( | |
| %test_type = OpTypeTensorARM %uint %uint_4 %uint_arr4_1_1_0_1 | |
| )"; | |
| std::string spvasm = GenerateModule(src); | |
| CompileSuccessfully(spvasm, SPVENV); | |
| EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPVENV)); | |
| EXPECT_THAT( | |
| getDiagnosticString(), | |
| ContainsRegex( | |
| "OpTypeTensorARM Shape constituent 2 is not greater than 0.*")); | |
| } | |
| // | |
| // Constants tests | |
| // | |
| TEST_F(ValidateTensor, ValidNullTensorConstantRank1) { | |
| const std::string src = R"( | |
| %uint_arr1_4 = OpConstantComposite %uint_arr1 %uint_4 | |
| %ts_uint_r1 = OpTypeTensorARM %uint %uint_1 %uint_arr1_4 | |
| %cst = OpConstantNull %ts_uint_r1 | |
| )"; | |
| std::string spvasm = GenerateModule(src); | |
| CompileSuccessfully(spvasm, SPVENV); | |
| EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPVENV)); | |
| } | |
| TEST_F(ValidateTensor, ValidNullTensorConstantRank4) { | |
| const std::string src = R"( | |
| %uint_arr4_2_2_2_2 = OpConstantComposite %uint_arr4 %uint_2 %uint_2 %uint_2 %uint_2 | |
| %ts_uint_r4 = OpTypeTensorARM %uint %uint_4 %uint_arr4_2_2_2_2 | |
| %cst = OpConstantNull %ts_uint_r4 | |
| )"; | |
| std::string spvasm = GenerateModule(src); | |
| CompileSuccessfully(spvasm, SPVENV); | |
| EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPVENV)); | |
| } | |
| TEST_F(ValidateTensor, InvalidNullTensorConstantRankedButNotShaped) { | |
| const std::string src = R"( | |
| %ts_uint_r1 = OpTypeTensorARM %uint %uint_1 | |
| %cst = OpConstantNull %ts_uint_r1 | |
| )"; | |
| std::string spvasm = GenerateModule(src); | |
| CompileSuccessfully(spvasm, SPVENV); | |
| EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPVENV)); | |
| EXPECT_THAT(getDiagnosticString(), | |
| ContainsRegex("OpConstantNull Result Type <id> '.*' " | |
| "cannot have a null value.*")); | |
| } | |
| TEST_F(ValidateTensor, InvalidNullTensorConstantNotRanked) { | |
| const std::string src = R"( | |
| %ts_uint_r1 = OpTypeTensorARM %uint | |
| %cst = OpConstantNull %ts_uint_r1 | |
| )"; | |
| std::string spvasm = GenerateModule(src); | |
| CompileSuccessfully(spvasm, SPVENV); | |
| EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPVENV)); | |
| EXPECT_THAT(getDiagnosticString(), | |
| ContainsRegex("OpConstantNull Result Type <id> '.*' " | |
| "cannot have a null value.*")); | |
| } | |
| TEST_F(ValidateTensor, ValidTensorConstantRank1) { | |
| const std::string src = R"( | |
| %uint_arr1_4 = OpConstantComposite %uint_arr1 %uint_4 | |
| %ts_uint_r1 = OpTypeTensorARM %uint %uint_1 %uint_arr1_4 | |
| %cst = OpConstantComposite %ts_uint_r1 %uint_42 %uint_42 %uint_42 %uint_42 | |
| )"; | |
| std::string spvasm = GenerateModule(src); | |
| CompileSuccessfully(spvasm, SPVENV); | |
| EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPVENV)); | |
| } | |
| TEST_F(ValidateTensor, ValidTensorConstantRank1SpecConstant) { | |
| const std::string src = R"( | |
| %uint_arr1_4 = OpSpecConstantComposite %uint_arr1 %uint_0_spec | |
| %ts_uint_r1 = OpTypeTensorARM %uint %uint_0_spec %uint_arr1_4 | |
| %cst = OpSpecConstantComposite %ts_uint_r1 %uint_0_spec %uint_0_spec %uint_0_spec %uint_0_spec | |
| )"; | |
| std::string spvasm = GenerateModule(src); | |
| CompileSuccessfully(spvasm, SPVENV); | |
| EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPVENV)); | |
| } | |
| TEST_F(ValidateTensor, InvalidTensorConstantRank1NotEnoughConstituents) { | |
| const std::string src = R"( | |
| %uint_arr1_4 = OpConstantComposite %uint_arr1 %uint_4 | |
| %ts_uint_r1 = OpTypeTensorARM %uint %uint_1 %uint_arr1_4 | |
| %cst = OpConstantComposite %ts_uint_r1 %uint_42 %uint_42 %uint_42 | |
| )"; | |
| std::string spvasm = GenerateModule(src); | |
| CompileSuccessfully(spvasm, SPVENV); | |
| EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPVENV)); | |
| EXPECT_THAT( | |
| getDiagnosticString(), | |
| ContainsRegex("OpConstantComposite Constituent count does not match the " | |
| "shape of Result Type <id> '.*' " | |
| "along its outermost dimension, expected 4 but got 3.*")); | |
| } | |
| TEST_F(ValidateTensor, InvalidTensorConstantRank1TooManyConstituents) { | |
| const std::string src = R"( | |
| %uint_arr1_4 = OpConstantComposite %uint_arr1 %uint_4 | |
| %ts_uint_r1 = OpTypeTensorARM %uint %uint_1 %uint_arr1_4 | |
| %cst = OpConstantComposite %ts_uint_r1 %uint_42 %uint_42 %uint_42 %uint_42 %uint_42 | |
| )"; | |
| std::string spvasm = GenerateModule(src); | |
| CompileSuccessfully(spvasm, SPVENV); | |
| EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPVENV)); | |
| EXPECT_THAT( | |
| getDiagnosticString(), | |
| ContainsRegex("OpConstantComposite Constituent count does not match the " | |
| "shape of Result Type <id> '.*' " | |
| "along its outermost dimension, expected 4 but got 5.*")); | |
| } | |
| TEST_F(ValidateTensor, | |
| InvalidTensorConstantRank1ConstituentNotConstantOrUndef) { | |
| const std::string src = R"( | |
| %uint_arr1_4 = OpConstantComposite %uint_arr1 %uint_4 | |
| %ts_uint_r1 = OpTypeTensorARM %uint %uint_1 %uint_arr1_4 | |
| %cst = OpConstantComposite %ts_uint_r1 %tensor_var %tensor_var %tensor_var %tensor_var | |
| )"; | |
| std::string spvasm = GenerateModule(src); | |
| CompileSuccessfully(spvasm, SPVENV); | |
| EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPVENV)); | |
| EXPECT_THAT(getDiagnosticString(), | |
| ContainsRegex("OpConstantComposite Constituent <id> " | |
| "'.*' is not a constant or undef.*")); | |
| } | |
| TEST_F(ValidateTensor, InvalidTensorConstantRank1WrongConstituentType) { | |
| const std::string src = R"( | |
| %uint_arr1_4 = OpConstantComposite %uint_arr1 %uint_4 | |
| %ts_uint_r1 = OpTypeTensorARM %uint %uint_1 %uint_arr1_4 | |
| %cst = OpConstantComposite %ts_uint_r1 %uint_42 %uint_42 %float_1 %uint_42 | |
| )"; | |
| std::string spvasm = GenerateModule(src); | |
| CompileSuccessfully(spvasm, SPVENV); | |
| EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPVENV)); | |
| EXPECT_THAT( | |
| getDiagnosticString(), | |
| ContainsRegex("OpConstantComposite Constituent <id> '.*' " | |
| "type does not match the element type of the tensor " | |
| ".*")); | |
| } | |
| TEST_F(ValidateTensor, ValidTensorConstantRank4) { | |
| const std::string src = R"( | |
| %uint_arr1_2 = OpConstantComposite %uint_arr1 %uint_2 | |
| %uint_arr2_2_2 = OpConstantComposite %uint_arr2 %uint_2 %uint_2 | |
| %uint_arr3_2_2_2 = OpConstantComposite %uint_arr3 %uint_2 %uint_2 %uint_2 | |
| %uint_arr4_2_2_2_2 = OpConstantComposite %uint_arr4 %uint_2 %uint_2 %uint_2 %uint_2 | |
| %ts_uint_r1 = OpTypeTensorARM %uint %uint_1 %uint_arr1_2 | |
| %ts_uint_r2 = OpTypeTensorARM %uint %uint_2 %uint_arr2_2_2 | |
| %ts_uint_r3 = OpTypeTensorARM %uint %uint_3 %uint_arr3_2_2_2 | |
| %ts_uint_r4 = OpTypeTensorARM %uint %uint_4 %uint_arr4_2_2_2_2 | |
| %cst_r1 = OpConstantComposite %ts_uint_r1 %uint_42 %uint_42 | |
| %cst_r2 = OpConstantComposite %ts_uint_r2 %cst_r1 %cst_r1 | |
| %cst_r3 = OpConstantComposite %ts_uint_r3 %cst_r2 %cst_r2 | |
| %cst_r4 = OpConstantComposite %ts_uint_r4 %cst_r3 %cst_r3 | |
| )"; | |
| std::string spvasm = GenerateModule(src); | |
| CompileSuccessfully(spvasm, SPVENV); | |
| EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPVENV)); | |
| } | |
| TEST_F(ValidateTensor, ValidTensorConstantRank2SpecConstantConstituent) { | |
| const std::string src = R"( | |
| %uint_arr1_2 = OpSpecConstantComposite %uint_arr1 %uint_0_spec | |
| %uint_arr2_2_2 = OpSpecConstantComposite %uint_arr2 %uint_0_spec %uint_0_spec | |
| %ts_uint_r1 = OpTypeTensorARM %uint %uint_0_spec %uint_arr1_2 | |
| %ts_uint_r2 = OpTypeTensorARM %uint %uint_2 %uint_arr2_2_2 | |
| %cst_r1 = OpSpecConstantComposite %ts_uint_r1 %uint_0_spec %uint_0_spec | |
| %cst_r2 = OpSpecConstantComposite %ts_uint_r2 %cst_r1 %cst_r1 | |
| )"; | |
| std::string spvasm = GenerateModule(src); | |
| CompileSuccessfully(spvasm, SPVENV); | |
| EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPVENV)); | |
| } | |
| TEST_F(ValidateTensor, InvalidTensorConstantRank2ConstituentNotATensor) { | |
| const std::string src = R"( | |
| %uint_arr1_2 = OpConstantComposite %uint_arr1 %uint_2 | |
| %uint_arr2_2_2 = OpConstantComposite %uint_arr2 %uint_2 %uint_2 | |
| %ts_uint_r1 = OpTypeTensorARM %uint %uint_1 %uint_arr1_2 | |
| %ts_uint_r2 = OpTypeTensorARM %uint %uint_2 %uint_arr2_2_2 | |
| %cst_r1 = OpConstantComposite %ts_uint_r1 %uint_42 %uint_42 | |
| %cst_r2 = OpConstantComposite %ts_uint_r2 %uint_1 %cst_r1 | |
| )"; | |
| std::string spvasm = GenerateModule(src); | |
| CompileSuccessfully(spvasm, SPVENV); | |
| EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPVENV)); | |
| EXPECT_THAT(getDiagnosticString(), | |
| ContainsRegex("OpConstantComposite Constituent <id> " | |
| "'.*' must be an OpTypeTensorARM.*")); | |
| } | |
| TEST_F(ValidateTensor, | |
| InvalidTensorConstantRank2ConstituentTensorWrongElementType) { | |
| const std::string src = R"( | |
| %uint_arr1_2 = OpConstantComposite %uint_arr1 %uint_2 | |
| %uint_arr2_2_2 = OpConstantComposite %uint_arr2 %uint_2 %uint_2 | |
| %ts_float_r1 = OpTypeTensorARM %float %uint_1 %uint_arr1_2 | |
| %ts_uint_r2 = OpTypeTensorARM %uint %uint_2 %uint_arr2_2_2 | |
| %cst_r1 = OpConstantComposite %ts_float_r1 %float_1 %float_1 | |
| %cst_r2 = OpConstantComposite %ts_uint_r2 %cst_r1 %cst_r1 | |
| )"; | |
| std::string spvasm = GenerateModule(src); | |
| CompileSuccessfully(spvasm, SPVENV); | |
| EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPVENV)); | |
| EXPECT_THAT(getDiagnosticString(), | |
| ContainsRegex("OpConstantComposite Constituent <id> " | |
| "'.*' must have the same Element Type " | |
| "as Result Type <id> .*")); | |
| } | |
| TEST_F(ValidateTensor, InvalidTensorConstantRank2ConstituentTensorWrongRank) { | |
| const std::string src = R"( | |
| %uint_arr1_2 = OpConstantComposite %uint_arr1 %uint_2 | |
| %uint_arr2_2_2 = OpConstantComposite %uint_arr2 %uint_2 %uint_2 | |
| %ts_uint_r1 = OpTypeTensorARM %uint %uint_1 %uint_arr1_2 | |
| %ts_uint_r2 = OpTypeTensorARM %uint %uint_2 %uint_arr2_2_2 | |
| %cst_r1 = OpConstantComposite %ts_uint_r1 %uint_42 %uint_42 | |
| %cst_r2 = OpConstantComposite %ts_uint_r2 %cst_r1 %cst_r1 | |
| %cst = OpConstantComposite %ts_uint_r2 %cst_r1 %cst_r2 | |
| )"; | |
| std::string spvasm = GenerateModule(src); | |
| CompileSuccessfully(spvasm, SPVENV); | |
| EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPVENV)); | |
| EXPECT_THAT(getDiagnosticString(), | |
| ContainsRegex("OpConstantComposite Constituent <id> " | |
| "'.*' must have a Rank that is " | |
| "1 less than the Rank of Result Type <id> " | |
| "'.*', expected 1 but got 2.*")); | |
| } | |
| TEST_F(ValidateTensor, InvalidTensorConstantRank2ConstituentTensorWrongShape) { | |
| const std::string src = R"( | |
| %uint_arr1_3 = OpConstantComposite %uint_arr1 %uint_3 | |
| %uint_arr2_2_2 = OpConstantComposite %uint_arr2 %uint_2 %uint_2 | |
| %ts_uint_r1 = OpTypeTensorARM %uint %uint_1 %uint_arr1_3 | |
| %ts_uint_r2 = OpTypeTensorARM %uint %uint_2 %uint_arr2_2_2 | |
| %cst_r1 = OpConstantComposite %ts_uint_r1 %uint_42 %uint_42 %uint_42 | |
| %cst_r2 = OpConstantComposite %ts_uint_r2 %cst_r1 %cst_r1 | |
| )"; | |
| std::string spvasm = GenerateModule(src); | |
| CompileSuccessfully(spvasm, SPVENV); | |
| EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPVENV)); | |
| EXPECT_THAT( | |
| getDiagnosticString(), | |
| ContainsRegex( | |
| "OpConstantComposite Constituent <id> " | |
| "'.*' must have a Shape that matches " | |
| "that of Result Type <id> '.*' along " | |
| "all inner dimensions of Result Type, expected 2 for dimension 0 of " | |
| "Constituent but got 3.*")); | |
| } | |
| // | |
| // Read tests | |
| // | |
| TEST_F(ValidateTensor, ValidTensorReadScalar) { | |
| const std::string src = R"( | |
| %fn = OpFunction %void None %fnty | |
| %label1 = OpLabel | |
| %tensor = OpLoad %tensor_uint_4 %tensor_var | |
| %val = OpTensorReadARM %uint %tensor %uint_arr4_1_1_1_1 | |
| OpReturn | |
| OpFunctionEnd | |
| )"; | |
| std::string spvasm = GenerateModule(src); | |
| CompileSuccessfully(spvasm, SPVENV); | |
| EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPVENV)); | |
| } | |
| TEST_F(ValidateTensor, ValidTensorReadArray) { | |
| const std::string src = R"( | |
| %fn = OpFunction %void None %fnty | |
| %label1 = OpLabel | |
| %tensor = OpLoad %tensor_uint_4 %tensor_var | |
| %val = OpTensorReadARM %uint_arr2 %tensor %uint_arr4_1_1_1_1 | |
| OpReturn | |
| OpFunctionEnd | |
| )"; | |
| std::string spvasm = GenerateModule(src); | |
| CompileSuccessfully(spvasm, SPVENV); | |
| EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPVENV)); | |
| } | |
| TEST_F(ValidateTensor, ValidTensorReadSpecConstantRank) { | |
| const std::string src = R"( | |
| %fn = OpFunction %void None %fnty | |
| %label1 = OpLabel | |
| %tensor = OpLoad %tensor_uint_spec %tensor_var_spec_rank | |
| %val = OpTensorReadARM %uint %tensor %uint_arr4_1_1_1_1 | |
| OpReturn | |
| OpFunctionEnd | |
| )"; | |
| std::string spvasm = GenerateModule(src); | |
| CompileSuccessfully(spvasm, SPVENV); | |
| EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPVENV)); | |
| } | |
| TEST_F(ValidateTensor, InvalidTensorReadResultTypeVoid) { | |
| const std::string src = R"( | |
| %fn = OpFunction %void None %fnty | |
| %label1 = OpLabel | |
| %tensor = OpLoad %tensor_uint_4 %tensor_var | |
| %val = OpTensorReadARM %void %tensor %uint_arr4_1_1_1_1 | |
| OpReturn | |
| OpFunctionEnd | |
| )"; | |
| std::string spvasm = GenerateModule(src); | |
| CompileSuccessfully(spvasm, SPVENV); | |
| EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPVENV)); | |
| EXPECT_THAT( | |
| getDiagnosticString(), | |
| HasSubstr( | |
| "Expected Result Type to be a scalar type or array of scalar type")); | |
| } | |
| TEST_F(ValidateTensor, InvalidTensorReadResultTypeVector) { | |
| const std::string src = R"( | |
| %fn = OpFunction %void None %fnty | |
| %label1 = OpLabel | |
| %tensor = OpLoad %tensor_uint_4 %tensor_var | |
| %val = OpTensorReadARM %uint_vec4 %tensor %uint_arr4_1_1_1_1 | |
| OpReturn | |
| OpFunctionEnd | |
| )"; | |
| std::string spvasm = GenerateModule(src); | |
| CompileSuccessfully(spvasm, SPVENV); | |
| EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPVENV)); | |
| EXPECT_THAT( | |
| getDiagnosticString(), | |
| HasSubstr( | |
| "Expected Result Type to be a scalar type or array of scalar type")); | |
| } | |
| TEST_F(ValidateTensor, | |
| InvalidTensorReadResultTypeDoesNotMatchTensorElementType) { | |
| const std::string src = R"( | |
| %fn = OpFunction %void None %fnty | |
| %label1 = OpLabel | |
| %tensor = OpLoad %tensor_uint_4 %tensor_var | |
| %val = OpTensorReadARM %float %tensor %uint_arr4_1_1_1_1 | |
| OpReturn | |
| OpFunctionEnd | |
| )"; | |
| std::string spvasm = GenerateModule(src); | |
| CompileSuccessfully(spvasm, SPVENV); | |
| EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPVENV)); | |
| EXPECT_THAT( | |
| getDiagnosticString(), | |
| HasSubstr( | |
| "Expected Result Type to be the same as the Element Type of Tensor")); | |
| } | |
| TEST_F(ValidateTensor, InvalidTensorReadTensorNotRanked) { | |
| const std::string src = R"( | |
| %fn = OpFunction %void None %fnty | |
| %label1 = OpLabel | |
| %tensor = OpLoad %tensor_float %tensor_var_float_unranked | |
| %val = OpTensorReadARM %float %tensor %uint_arr4_1_1_1_1 | |
| OpReturn | |
| OpFunctionEnd | |
| )"; | |
| std::string spvasm = GenerateModule(src); | |
| CompileSuccessfully(spvasm, SPVENV); | |
| EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPVENV)); | |
| EXPECT_THAT( | |
| getDiagnosticString(), | |
| HasSubstr( | |
| "Expected Tensor to be an OpTypeTensorARM whose Rank is specified")); | |
| } | |
| TEST_F(ValidateTensor, InvalidTensorReadCoordinatesNotArray) { | |
| const std::string src = R"( | |
| %fn = OpFunction %void None %fnty | |
| %label1 = OpLabel | |
| %tensor = OpLoad %tensor_uint_4 %tensor_var | |
| %val = OpTensorReadARM %uint %tensor %uint_1 | |
| OpReturn | |
| OpFunctionEnd | |
| )"; | |
| std::string spvasm = GenerateModule(src); | |
| CompileSuccessfully(spvasm, SPVENV); | |
| EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPVENV)); | |
| EXPECT_THAT( | |
| getDiagnosticString(), | |
| HasSubstr( | |
| "Expected Coordinates to be an array whose Element Type is an " | |
| "integer type and whose Length is equal to the Rank of Tensor.")); | |
| } | |
| TEST_F(ValidateTensor, InvalidTensorReadCoordinatesArrayNotInteger) { | |
| const std::string src = R"( | |
| %fn = OpFunction %void None %fnty | |
| %label1 = OpLabel | |
| %tensor = OpLoad %tensor_uint_4 %tensor_var | |
| %val = OpTensorReadARM %uint %tensor %float_arr4_1_1_1_1 | |
| OpReturn | |
| OpFunctionEnd | |
| )"; | |
| std::string spvasm = GenerateModule(src); | |
| CompileSuccessfully(spvasm, SPVENV); | |
| EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPVENV)); | |
| EXPECT_THAT( | |
| getDiagnosticString(), | |
| HasSubstr( | |
| "Expected Coordinates to be an array whose Element Type is an " | |
| "integer type and whose Length is equal to the Rank of Tensor.")); | |
| } | |
| TEST_F(ValidateTensor, InvalidTensorReadCoordinatesArrayIntegerWrongLength) { | |
| const std::string src = R"( | |
| %fn = OpFunction %void None %fnty | |
| %label1 = OpLabel | |
| %tensor = OpLoad %tensor_uint_4 %tensor_var | |
| %val = OpTensorReadARM %uint %tensor %uint_arr2_1_1 | |
| OpReturn | |
| OpFunctionEnd | |
| )"; | |
| std::string spvasm = GenerateModule(src); | |
| CompileSuccessfully(spvasm, SPVENV); | |
| EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPVENV)); | |
| EXPECT_THAT( | |
| getDiagnosticString(), | |
| HasSubstr( | |
| "Expected Coordinates to be an array whose Element Type is an " | |
| "integer type and whose Length is equal to the Rank of Tensor.")); | |
| } | |
| TEST_F(ValidateTensor, ValidTensorReadScalarWithNoneTensorOperands) { | |
| const std::string src = R"( | |
| %fn = OpFunction %void None %fnty | |
| %label1 = OpLabel | |
| %tensor = OpLoad %tensor_uint_4 %tensor_var | |
| %val = OpTensorReadARM %uint %tensor %uint_arr4_1_1_1_1 NoneARM | |
| OpReturn | |
| OpFunctionEnd | |
| )"; | |
| std::string spvasm = GenerateModule(src); | |
| CompileSuccessfully(spvasm, SPVENV); | |
| EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPVENV)); | |
| } | |
| TEST_F(ValidateTensor, ValidTensorReadScalarWithNontemporalTensorOperands) { | |
| const std::string src = R"( | |
| %fn = OpFunction %void None %fnty | |
| %label1 = OpLabel | |
| %tensor = OpLoad %tensor_uint_4 %tensor_var | |
| %val = OpTensorReadARM %uint %tensor %uint_arr4_1_1_1_1 NontemporalARM | |
| OpReturn | |
| OpFunctionEnd | |
| )"; | |
| std::string spvasm = GenerateModule(src); | |
| CompileSuccessfully(spvasm, SPVENV); | |
| EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPVENV)); | |
| } | |
| TEST_F(ValidateTensor, ValidTensorReadScalarOutOfBoundsValueTensorOperands) { | |
| const std::string src = R"( | |
| %fn = OpFunction %void None %fnty | |
| %label1 = OpLabel | |
| %tensor = OpLoad %tensor_uint_4 %tensor_var | |
| %val = OpTensorReadARM %uint %tensor %uint_arr4_1_1_1_1 OutOfBoundsValueARM %uint_42 | |
| OpReturn | |
| OpFunctionEnd | |
| )"; | |
| std::string spvasm = GenerateModule(src); | |
| CompileSuccessfully(spvasm, SPVENV); | |
| EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPVENV)); | |
| } | |
| TEST_F(ValidateTensor, | |
| InvalidTensorReadScalarOutOfBoundsValueTensorOperandsValueWrongType) { | |
| const std::string src = R"( | |
| %fn = OpFunction %void None %fnty | |
| %label1 = OpLabel | |
| %tensor = OpLoad %tensor_uint_4 %tensor_var | |
| %val = OpTensorReadARM %uint %tensor %uint_arr4_1_1_1_1 OutOfBoundsValueARM %float_1 | |
| OpReturn | |
| OpFunctionEnd | |
| )"; | |
| std::string spvasm = GenerateModule(src); | |
| CompileSuccessfully(spvasm, SPVENV); | |
| EXPECT_EQ(SPV_ERROR_INVALID_ID, ValidateInstructions(SPVENV)); | |
| EXPECT_THAT( | |
| getDiagnosticString(), | |
| HasSubstr( | |
| "Expected the type of the OutOfBoundsValueARM value to be the same " | |
| "as the Element Type of Tensor.")); | |
| } | |
| TEST_F(ValidateTensor, | |
| InvalidTensorReadScalarMakeElementAvailableTensorOperands) { | |
| const std::string src = R"( | |
| %fn = OpFunction %void None %fnty | |
| %label1 = OpLabel | |
| %tensor = OpLoad %tensor_uint_4 %tensor_var | |
| %val = OpTensorReadARM %uint %tensor %uint_arr4_1_1_1_1 MakeElementAvailableARM %uint_1 | |
| OpReturn | |
| OpFunctionEnd | |
| )"; | |
| std::string spvasm = GenerateModule(src); | |
| CompileSuccessfully(spvasm, SPVENV); | |
| EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPVENV)); | |
| EXPECT_THAT( | |
| getDiagnosticString(), | |
| HasSubstr( | |
| "MakeElementAvailableARM cannot be used with OpTensorReadARM.")); | |
| } | |
| TEST_F(ValidateTensor, | |
| ValidTensorReadScalarWithMakeElementVisibleTensorOperands) { | |
| const std::string src = R"( | |
| %fn = OpFunction %void None %fnty | |
| %label1 = OpLabel | |
| %tensor = OpLoad %tensor_uint_4 %tensor_var | |
| %val = OpTensorReadARM %uint %tensor %uint_arr4_1_1_1_1 MakeElementVisibleARM|NonPrivateElementARM %uint_1 | |
| OpReturn | |
| OpFunctionEnd | |
| )"; | |
| std::string spvasm = GenerateModule(src); | |
| CompileSuccessfully(spvasm, SPVENV); | |
| EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPVENV)); | |
| } | |
| TEST_F( | |
| ValidateTensor, | |
| InvalidTensorReadScalarMakeElementVisibleTensorOperandsWithoutNonPrivateElement) { | |
| const std::string src = R"( | |
| %fn = OpFunction %void None %fnty | |
| %label1 = OpLabel | |
| %tensor = OpLoad %tensor_uint_4 %tensor_var | |
| %val = OpTensorReadARM %uint %tensor %uint_arr4_1_1_1_1 MakeElementVisibleARM %uint_1 | |
| OpReturn | |
| OpFunctionEnd | |
| )"; | |
| std::string spvasm = GenerateModule(src); | |
| CompileSuccessfully(spvasm, SPVENV); | |
| EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPVENV)); | |
| EXPECT_THAT( | |
| getDiagnosticString(), | |
| HasSubstr("MakeElementAvailableARM requires NonPrivateElementARM")); | |
| } | |
| // | |
| // Write tests | |
| // | |
| TEST_F(ValidateTensor, ValidTensorWriteScalar) { | |
| const std::string src = R"( | |
| %fn = OpFunction %void None %fnty | |
| %label1 = OpLabel | |
| %tensor = OpLoad %tensor_uint_4 %tensor_var | |
| OpTensorWriteARM %tensor %uint_arr4_1_1_1_1 %uint_1 | |
| OpReturn | |
| OpFunctionEnd | |
| )"; | |
| std::string spvasm = GenerateModule(src); | |
| CompileSuccessfully(spvasm, SPVENV); | |
| EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPVENV)); | |
| } | |
| TEST_F(ValidateTensor, ValidTensorWriteArray) { | |
| const std::string src = R"( | |
| %fn = OpFunction %void None %fnty | |
| %label1 = OpLabel | |
| %tensor = OpLoad %tensor_uint_4 %tensor_var | |
| OpTensorWriteARM %tensor %uint_arr4_1_1_1_1 %uint_arr2_1_1 | |
| OpReturn | |
| OpFunctionEnd | |
| )"; | |
| std::string spvasm = GenerateModule(src); | |
| CompileSuccessfully(spvasm, SPVENV); | |
| EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPVENV)); | |
| } | |
| TEST_F(ValidateTensor, ValidTensorWriteSpecConstantRank) { | |
| const std::string src = R"( | |
| %fn = OpFunction %void None %fnty | |
| %label1 = OpLabel | |
| %tensor = OpLoad %tensor_uint_spec %tensor_var_spec_rank | |
| OpTensorWriteARM %tensor %uint_arr4_1_1_1_1 %uint_1 | |
| OpReturn | |
| OpFunctionEnd | |
| )"; | |
| std::string spvasm = GenerateModule(src); | |
| CompileSuccessfully(spvasm, SPVENV); | |
| EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPVENV)); | |
| } | |
| TEST_F(ValidateTensor, InvalidTensorWriteObjectNotScalarOrArrayOfScalar) { | |
| const std::string src = R"( | |
| %fn = OpFunction %void None %fnty | |
| %label1 = OpLabel | |
| %tensor = OpLoad %tensor_uint_4 %tensor_var | |
| OpTensorWriteARM %tensor %uint_arr4_1_1_1_1 %uint_vec4_1_1_1_1 | |
| OpReturn | |
| OpFunctionEnd | |
| )"; | |
| std::string spvasm = GenerateModule(src); | |
| CompileSuccessfully(spvasm, SPVENV); | |
| EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPVENV)); | |
| EXPECT_THAT( | |
| getDiagnosticString(), | |
| HasSubstr("Expected Object to be a scalar type or array of scalar type " | |
| "that is the same as the Element Type of Tensor.")); | |
| } | |
| TEST_F(ValidateTensor, InvalidTensorWriteObjectDoesNotMatchTensorElementType) { | |
| const std::string src = R"( | |
| %fn = OpFunction %void None %fnty | |
| %label1 = OpLabel | |
| %tensor = OpLoad %tensor_uint_4 %tensor_var | |
| OpTensorWriteARM %tensor %uint_arr4_1_1_1_1 %float_1 | |
| OpReturn | |
| OpFunctionEnd | |
| )"; | |
| std::string spvasm = GenerateModule(src); | |
| CompileSuccessfully(spvasm, SPVENV); | |
| EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPVENV)); | |
| EXPECT_THAT( | |
| getDiagnosticString(), | |
| HasSubstr("Expected Object to be a scalar type or array of scalar type " | |
| "that is the same as the Element Type of Tensor.")); | |
| } | |
| TEST_F(ValidateTensor, InvalidTensorWriteTensorNotRanked) { | |
| const std::string src = R"( | |
| %fn = OpFunction %void None %fnty | |
| %label1 = OpLabel | |
| %tensor = OpLoad %tensor_float %tensor_var_float_unranked | |
| OpTensorWriteARM %tensor %uint_arr4_1_1_1_1 %float_1 | |
| OpReturn | |
| OpFunctionEnd | |
| )"; | |
| std::string spvasm = GenerateModule(src); | |
| CompileSuccessfully(spvasm, SPVENV); | |
| EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPVENV)); | |
| EXPECT_THAT( | |
| getDiagnosticString(), | |
| HasSubstr( | |
| "Expected Tensor to be an OpTypeTensorARM whose Rank is specified")); | |
| } | |
| TEST_F(ValidateTensor, InvalidTensorWriteCoordinatesNotArray) { | |
| const std::string src = R"( | |
| %fn = OpFunction %void None %fnty | |
| %label1 = OpLabel | |
| %tensor = OpLoad %tensor_uint_4 %tensor_var | |
| OpTensorWriteARM %tensor %uint_1 %uint_1 | |
| OpReturn | |
| OpFunctionEnd | |
| )"; | |
| std::string spvasm = GenerateModule(src); | |
| CompileSuccessfully(spvasm, SPVENV); | |
| EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPVENV)); | |
| EXPECT_THAT( | |
| getDiagnosticString(), | |
| HasSubstr( | |
| "Expected Coordinates to be an array whose Element Type is an " | |
| "integer type and whose Length is equal to the Rank of Tensor.")); | |
| } | |
| TEST_F(ValidateTensor, InvalidTensorWriteCoordinatesArrayNotInteger) { | |
| const std::string src = R"( | |
| %fn = OpFunction %void None %fnty | |
| %label1 = OpLabel | |
| %tensor = OpLoad %tensor_uint_4 %tensor_var | |
| OpTensorWriteARM %tensor %float_arr4_1_1_1_1 %uint_1 | |
| OpReturn | |
| OpFunctionEnd | |
| )"; | |
| std::string spvasm = GenerateModule(src); | |
| CompileSuccessfully(spvasm, SPVENV); | |
| EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPVENV)); | |
| EXPECT_THAT( | |
| getDiagnosticString(), | |
| HasSubstr( | |
| "Expected Coordinates to be an array whose Element Type is an " | |
| "integer type and whose Length is equal to the Rank of Tensor.")); | |
| } | |
| TEST_F(ValidateTensor, InvalidTensorWriteCoordinatesArrayIntegerWrongLength) { | |
| const std::string src = R"( | |
| %fn = OpFunction %void None %fnty | |
| %label1 = OpLabel | |
| %tensor = OpLoad %tensor_uint_4 %tensor_var | |
| OpTensorWriteARM %tensor %uint_arr2_1_1 %uint_1 | |
| OpReturn | |
| OpFunctionEnd | |
| )"; | |
| std::string spvasm = GenerateModule(src); | |
| CompileSuccessfully(spvasm, SPVENV); | |
| EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPVENV)); | |
| EXPECT_THAT( | |
| getDiagnosticString(), | |
| HasSubstr( | |
| "Expected Coordinates to be an array whose Element Type is an " | |
| "integer type and whose Length is equal to the Rank of Tensor.")); | |
| } | |
| TEST_F(ValidateTensor, ValidTensorWriteScalarWithNoneTensorOperands) { | |
| const std::string src = R"( | |
| %fn = OpFunction %void None %fnty | |
| %label1 = OpLabel | |
| %tensor = OpLoad %tensor_uint_4 %tensor_var | |
| OpTensorWriteARM %tensor %uint_arr4_1_1_1_1 %uint_1 NoneARM | |
| OpReturn | |
| OpFunctionEnd | |
| )"; | |
| std::string spvasm = GenerateModule(src); | |
| CompileSuccessfully(spvasm, SPVENV); | |
| EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPVENV)); | |
| } | |
| TEST_F(ValidateTensor, ValidTensorWriteScalarWithNontemporalTensorOperands) { | |
| const std::string src = R"( | |
| %fn = OpFunction %void None %fnty | |
| %label1 = OpLabel | |
| %tensor = OpLoad %tensor_uint_4 %tensor_var | |
| OpTensorWriteARM %tensor %uint_arr4_1_1_1_1 %uint_1 NontemporalARM | |
| OpReturn | |
| OpFunctionEnd | |
| )"; | |
| std::string spvasm = GenerateModule(src); | |
| CompileSuccessfully(spvasm, SPVENV); | |
| EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPVENV)); | |
| } | |
| TEST_F(ValidateTensor, | |
| ValidTensorWriteScalarWithMakeElementAvailableTensorOperands) { | |
| const std::string src = R"( | |
| %fn = OpFunction %void None %fnty | |
| %label1 = OpLabel | |
| %tensor = OpLoad %tensor_uint_4 %tensor_var | |
| OpTensorWriteARM %tensor %uint_arr4_1_1_1_1 %uint_1 MakeElementAvailableARM|NonPrivateElementARM %uint_1 | |
| OpReturn | |
| OpFunctionEnd | |
| )"; | |
| std::string spvasm = GenerateModule(src); | |
| CompileSuccessfully(spvasm, SPVENV); | |
| EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPVENV)); | |
| } | |
| TEST_F(ValidateTensor, | |
| InvalidTensorWriteScalarWithOutOfVoundsValueTensorOperands) { | |
| const std::string src = R"( | |
| %fn = OpFunction %void None %fnty | |
| %label1 = OpLabel | |
| %tensor = OpLoad %tensor_uint_4 %tensor_var | |
| OpTensorWriteARM %tensor %uint_arr4_1_1_1_1 %uint_1 OutOfBoundsValueARM %uint_42 | |
| OpReturn | |
| OpFunctionEnd | |
| )"; | |
| std::string spvasm = GenerateModule(src); | |
| CompileSuccessfully(spvasm, SPVENV); | |
| EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPVENV)); | |
| EXPECT_THAT(getDiagnosticString(), | |
| HasSubstr("OutOfBoundsValue Tensor Operand not allowed with " | |
| "OpTensorWriteARM.")); | |
| } | |
| TEST_F(ValidateTensor, | |
| InvalidTensorWriteScalarWithMakeElementVisibleTensorOperands) { | |
| const std::string src = R"( | |
| %fn = OpFunction %void None %fnty | |
| %label1 = OpLabel | |
| %tensor = OpLoad %tensor_uint_4 %tensor_var | |
| OpTensorWriteARM %tensor %uint_arr4_1_1_1_1 %uint_1 MakeElementVisibleARM %uint_1 | |
| OpReturn | |
| OpFunctionEnd | |
| )"; | |
| std::string spvasm = GenerateModule(src); | |
| CompileSuccessfully(spvasm, SPVENV); | |
| EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPVENV)); | |
| EXPECT_THAT( | |
| getDiagnosticString(), | |
| HasSubstr("MakeElementVisibleARM not allowed with OpTensorWriteARM.")); | |
| } | |
| TEST_F( | |
| ValidateTensor, | |
| InvalidTensorWriteScalarWithMakeElementAvailableTensorOperandsWithoutNonPrivateElement) { | |
| const std::string src = R"( | |
| %fn = OpFunction %void None %fnty | |
| %label1 = OpLabel | |
| %tensor = OpLoad %tensor_uint_4 %tensor_var | |
| OpTensorWriteARM %tensor %uint_arr4_1_1_1_1 %uint_1 MakeElementAvailableARM %uint_1 | |
| OpReturn | |
| OpFunctionEnd | |
| )"; | |
| std::string spvasm = GenerateModule(src); | |
| CompileSuccessfully(spvasm, SPVENV); | |
| EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPVENV)); | |
| EXPECT_THAT( | |
| getDiagnosticString(), | |
| HasSubstr("MakeElementAvailableARM requires NonPrivateElementARM.")); | |
| } | |
| // | |
| // Query Size tests | |
| // | |
| TEST_F(ValidateTensor, ValidTensorQuerySize) { | |
| const std::string src = R"( | |
| %fn = OpFunction %void None %fnty | |
| %label1 = OpLabel | |
| %tensor = OpLoad %tensor_uint_4 %tensor_var | |
| %size = OpTensorQuerySizeARM %uint %tensor %uint_1 | |
| OpReturn | |
| OpFunctionEnd | |
| )"; | |
| std::string spvasm = GenerateModule(src); | |
| CompileSuccessfully(spvasm, SPVENV); | |
| EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPVENV)); | |
| } | |
| TEST_F(ValidateTensor, ValidTensorQuerySizeSpecConstant) { | |
| const std::string src = R"( | |
| %fn = OpFunction %void None %fnty | |
| %label1 = OpLabel | |
| %tensor = OpLoad %tensor_uint_spec %tensor_var_spec_rank | |
| %size = OpTensorQuerySizeARM %uint %tensor %uint_0_spec | |
| OpReturn | |
| OpFunctionEnd | |
| )"; | |
| std::string spvasm = GenerateModule(src); | |
| CompileSuccessfully(spvasm, SPVENV); | |
| EXPECT_EQ(SPV_SUCCESS, ValidateInstructions(SPVENV)); | |
| } | |
| TEST_F(ValidateTensor, InvalidTensorQuerySizeTensorNotRanked) { | |
| const std::string src = R"( | |
| %fn = OpFunction %void None %fnty | |
| %label1 = OpLabel | |
| %tensor = OpLoad %tensor_float %tensor_var_float_unranked | |
| %size = OpTensorQuerySizeARM %uint %tensor %uint_1 | |
| OpReturn | |
| OpFunctionEnd | |
| )"; | |
| std::string spvasm = GenerateModule(src); | |
| CompileSuccessfully(spvasm, SPVENV); | |
| EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPVENV)); | |
| EXPECT_THAT( | |
| getDiagnosticString(), | |
| HasSubstr( | |
| "Expected Tensor to be an OpTypeTensorARM whose Rank is specified")); | |
| } | |
| TEST_F(ValidateTensor, InvalidTensorQuerySizeResultNotIntegerScalarType) { | |
| const std::string src = R"( | |
| %fn = OpFunction %void None %fnty | |
| %label1 = OpLabel | |
| %tensor = OpLoad %tensor_float %tensor_var_float_unranked | |
| %size = OpTensorQuerySizeARM %float %tensor %uint_1 | |
| OpReturn | |
| OpFunctionEnd | |
| )"; | |
| std::string spvasm = GenerateModule(src); | |
| CompileSuccessfully(spvasm, SPVENV); | |
| EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPVENV)); | |
| EXPECT_THAT(getDiagnosticString(), | |
| HasSubstr("Expected Result Type to be an integer type scalar")); | |
| } | |
| TEST_F(ValidateTensor, InvalidTensorQuerySizeDimensionNotIntegerType) { | |
| const std::string src = R"( | |
| %fn = OpFunction %void None %fnty | |
| %label1 = OpLabel | |
| %tensor = OpLoad %tensor_uint_4 %tensor_var | |
| %size = OpTensorQuerySizeARM %uint %tensor %float_1 | |
| OpReturn | |
| OpFunctionEnd | |
| )"; | |
| std::string spvasm = GenerateModule(src); | |
| CompileSuccessfully(spvasm, SPVENV); | |
| EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPVENV)); | |
| EXPECT_THAT(getDiagnosticString(), | |
| HasSubstr("Dimension must come from a constant instruction of " | |
| "scalar integer type.")); | |
| } | |
| TEST_F(ValidateTensor, InvalidTensorQuerySizeDimensionNotConstant) { | |
| const std::string src = R"( | |
| %fn = OpFunction %void None %fnty | |
| %label1 = OpLabel | |
| %tensor = OpLoad %tensor_uint_4 %tensor_var | |
| %dims = OpLoad %uint_arr4 %var_uint_arr4_1_1_1_1 | |
| %dim = OpCompositeExtract %uint %dims 0 | |
| %size = OpTensorQuerySizeARM %uint %tensor %dim | |
| OpReturn | |
| OpFunctionEnd | |
| )"; | |
| std::string spvasm = GenerateModule(src); | |
| CompileSuccessfully(spvasm, SPVENV); | |
| EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPVENV)); | |
| EXPECT_THAT(getDiagnosticString(), | |
| HasSubstr("Dimension must come from a constant instruction of " | |
| "scalar integer type.")); | |
| } | |
| TEST_F(ValidateTensor, InvalidTensorQuerySizeDimension) { | |
| const std::string src = R"( | |
| %fn = OpFunction %void None %fnty | |
| %label1 = OpLabel | |
| %tensor = OpLoad %tensor_uint_4 %tensor_var | |
| %size = OpTensorQuerySizeARM %uint %tensor %uint_42 | |
| OpReturn | |
| OpFunctionEnd | |
| )"; | |
| std::string spvasm = GenerateModule(src); | |
| CompileSuccessfully(spvasm, SPVENV); | |
| EXPECT_EQ(SPV_ERROR_INVALID_DATA, ValidateInstructions(SPVENV)); | |
| EXPECT_THAT( | |
| getDiagnosticString(), | |
| HasSubstr("Dimension (42) must be less than the Rank of Tensor (4)")); | |
| } | |
| } // namespace | |
| } // namespace val | |
| } // namespace spvtools |