| // Copyright 2024 The Dawn & Tint Authors | |
| // | |
| // Redistribution and use in source and binary forms, with or without | |
| // modification, are permitted provided that the following conditions are met: | |
| // | |
| // 1. Redistributions of source code must retain the above copyright notice, this | |
| // list of conditions and the following disclaimer. | |
| // | |
| // 2. Redistributions in binary form must reproduce the above copyright notice, | |
| // this list of conditions and the following disclaimer in the documentation | |
| // and/or other materials provided with the distribution. | |
| // | |
| // 3. Neither the name of the copyright holder nor the names of its | |
| // contributors may be used to endorse or promote products derived from | |
| // this software without specific prior written permission. | |
| // | |
| // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" | |
| // AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | |
| // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE | |
| // DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE | |
| // FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | |
| // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR | |
| // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER | |
| // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, | |
| // OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | |
| // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
| #include "src/tint/lang/spirv/reader/parser/helper_test.h" | |
| namespace tint::spirv::reader { | |
| namespace { | |
| struct BinaryCase { | |
| std::string spirv_type; | |
| std::string spirv_opcode; | |
| std::string ir; | |
| }; | |
| std::string PrintBuiltinCase(testing::TestParamInfo<BinaryCase> bc) { | |
| return bc.param.spirv_opcode + "_" + bc.param.spirv_type; | |
| } | |
| using BinaryTest = SpirvParserTestWithParam<BinaryCase>; | |
| TEST_P(BinaryTest, All) { | |
| auto params = GetParam(); | |
| EXPECT_IR(R"( | |
| OpCapability Shader | |
| OpCapability Float16 | |
| OpMemoryModel Logical GLSL450 | |
| OpEntryPoint GLCompute %main "main" | |
| OpExecutionMode %main LocalSize 1 1 1 | |
| %void = OpTypeVoid | |
| %i32 = OpTypeInt 32 1 | |
| %u32 = OpTypeInt 32 0 | |
| %f16 = OpTypeFloat 16 | |
| %f32 = OpTypeFloat 32 | |
| %vec3i = OpTypeVector %i32 3 | |
| %vec4u = OpTypeVector %u32 4 | |
| %vec3h = OpTypeVector %f16 3 | |
| %vec4f = OpTypeVector %f32 4 | |
| %ep_type = OpTypeFunction %void | |
| %fn_type = OpTypeFunction %)" + | |
| params.spirv_type + " %" + params.spirv_type + " %" + params.spirv_type + R"( | |
| %main = OpFunction %void None %ep_type | |
| %main_start = OpLabel | |
| OpReturn | |
| OpFunctionEnd | |
| %foo = OpFunction %)" + | |
| params.spirv_type + " " + R"( None %fn_type | |
| %lhs = OpFunctionParameter %)" + | |
| params.spirv_type + " " + R"( | |
| %rhs = OpFunctionParameter %)" + | |
| params.spirv_type + " " + R"( | |
| %foo_start = OpLabel | |
| %result = )" + | |
| params.spirv_opcode + R"( %)" + params.spirv_type + " " + R"( %lhs %rhs | |
| OpReturnValue %result | |
| OpFunctionEnd | |
| )", | |
| R"( | |
| $B2: { | |
| )" + params.ir + | |
| R"( | |
| ret %5 | |
| } | |
| )"); | |
| } | |
| INSTANTIATE_TEST_SUITE_P(SpirvParser, | |
| BinaryTest, | |
| testing::Values( | |
| // OpFAdd | |
| BinaryCase{ | |
| "f16", | |
| "OpFAdd", | |
| "%5:f16 = add %3, %4", | |
| }, | |
| BinaryCase{ | |
| "f32", | |
| "OpFAdd", | |
| "%5:f32 = add %3, %4", | |
| }, | |
| BinaryCase{ | |
| "vec3h", | |
| "OpFAdd", | |
| "%5:vec3<f16> = add %3, %4", | |
| }, | |
| BinaryCase{ | |
| "vec4f", | |
| "OpFAdd", | |
| "%5:vec4<f32> = add %3, %4", | |
| }, | |
| // OpFSub | |
| BinaryCase{ | |
| "f16", | |
| "OpFSub", | |
| "%5:f16 = sub %3, %4", | |
| }, | |
| BinaryCase{ | |
| "f32", | |
| "OpFSub", | |
| "%5:f32 = sub %3, %4", | |
| }, | |
| BinaryCase{ | |
| "vec3h", | |
| "OpFSub", | |
| "%5:vec3<f16> = sub %3, %4", | |
| }, | |
| BinaryCase{ | |
| "vec4f", | |
| "OpFSub", | |
| "%5:vec4<f32> = sub %3, %4", | |
| }, | |
| // OpFMul | |
| BinaryCase{ | |
| "f16", | |
| "OpFMul", | |
| "%5:f16 = mul %3, %4", | |
| }, | |
| BinaryCase{ | |
| "f32", | |
| "OpFMul", | |
| "%5:f32 = mul %3, %4", | |
| }, | |
| BinaryCase{ | |
| "vec3h", | |
| "OpFMul", | |
| "%5:vec3<f16> = mul %3, %4", | |
| }, | |
| BinaryCase{ | |
| "vec4f", | |
| "OpFMul", | |
| "%5:vec4<f32> = mul %3, %4", | |
| }, | |
| // OpFDiv | |
| BinaryCase{ | |
| "f16", | |
| "OpFDiv", | |
| "%5:f16 = div %3, %4", | |
| }, | |
| BinaryCase{ | |
| "f32", | |
| "OpFDiv", | |
| "%5:f32 = div %3, %4", | |
| }, | |
| BinaryCase{ | |
| "vec3h", | |
| "OpFDiv", | |
| "%5:vec3<f16> = div %3, %4", | |
| }, | |
| BinaryCase{ | |
| "vec4f", | |
| "OpFDiv", | |
| "%5:vec4<f32> = div %3, %4", | |
| }, | |
| // OpFRem | |
| BinaryCase{ | |
| "f16", | |
| "OpFRem", | |
| "%5:f16 = mod %3, %4", | |
| }, | |
| BinaryCase{ | |
| "f32", | |
| "OpFRem", | |
| "%5:f32 = mod %3, %4", | |
| }, | |
| BinaryCase{ | |
| "vec3h", | |
| "OpFRem", | |
| "%5:vec3<f16> = mod %3, %4", | |
| }, | |
| BinaryCase{ | |
| "vec4f", | |
| "OpFRem", | |
| "%5:vec4<f32> = mod %3, %4", | |
| }, | |
| // OpIAdd | |
| BinaryCase{ | |
| "i32", | |
| "OpIAdd", | |
| "%5:i32 = add %3, %4", | |
| }, | |
| BinaryCase{ | |
| "u32", | |
| "OpIAdd", | |
| "%5:u32 = add %3, %4", | |
| }, | |
| BinaryCase{ | |
| "vec3i", | |
| "OpIAdd", | |
| "%5:vec3<i32> = add %3, %4", | |
| }, | |
| BinaryCase{ | |
| "vec4u", | |
| "OpIAdd", | |
| "%5:vec4<u32> = add %3, %4", | |
| }, | |
| // OpISub | |
| BinaryCase{ | |
| "i32", | |
| "OpISub", | |
| "%5:i32 = sub %3, %4", | |
| }, | |
| BinaryCase{ | |
| "u32", | |
| "OpISub", | |
| "%5:u32 = sub %3, %4", | |
| }, | |
| BinaryCase{ | |
| "vec3i", | |
| "OpISub", | |
| "%5:vec3<i32> = sub %3, %4", | |
| }, | |
| BinaryCase{ | |
| "vec4u", | |
| "OpISub", | |
| "%5:vec4<u32> = sub %3, %4", | |
| }, | |
| // OpIMul | |
| BinaryCase{ | |
| "i32", | |
| "OpIMul", | |
| "%5:i32 = mul %3, %4", | |
| }, | |
| BinaryCase{ | |
| "u32", | |
| "OpIMul", | |
| "%5:u32 = mul %3, %4", | |
| }, | |
| BinaryCase{ | |
| "vec3i", | |
| "OpIMul", | |
| "%5:vec3<i32> = mul %3, %4", | |
| }, | |
| BinaryCase{ | |
| "vec4u", | |
| "OpIMul", | |
| "%5:vec4<u32> = mul %3, %4", | |
| }, | |
| // OpSDiv | |
| BinaryCase{ | |
| "i32", | |
| "OpSDiv", | |
| "%5:i32 = div %3, %4", | |
| }, | |
| BinaryCase{ | |
| "u32", | |
| "OpSDiv", | |
| "%5:u32 = div %3, %4", | |
| }, | |
| BinaryCase{ | |
| "vec3i", | |
| "OpSDiv", | |
| "%5:vec3<i32> = div %3, %4", | |
| }, | |
| BinaryCase{ | |
| "vec4u", | |
| "OpSDiv", | |
| "%5:vec4<u32> = div %3, %4", | |
| }, | |
| // OpSMod | |
| BinaryCase{ | |
| "i32", | |
| "OpSMod", | |
| "%5:i32 = mod %3, %4", | |
| }, | |
| BinaryCase{ | |
| "u32", | |
| "OpSMod", | |
| "%5:u32 = mod %3, %4", | |
| }, | |
| BinaryCase{ | |
| "vec3i", | |
| "OpSMod", | |
| "%5:vec3<i32> = mod %3, %4", | |
| }, | |
| BinaryCase{ | |
| "vec4u", | |
| "OpSMod", | |
| "%5:vec4<u32> = mod %3, %4", | |
| }, | |
| // OpSRem | |
| BinaryCase{ | |
| "i32", | |
| "OpSRem", | |
| "%5:i32 = mod %3, %4", | |
| }, | |
| BinaryCase{ | |
| "u32", | |
| "OpSRem", | |
| "%5:u32 = mod %3, %4", | |
| }, | |
| BinaryCase{ | |
| "vec3i", | |
| "OpSRem", | |
| "%5:vec3<i32> = mod %3, %4", | |
| }, | |
| BinaryCase{ | |
| "vec4u", | |
| "OpSRem", | |
| "%5:vec4<u32> = mod %3, %4", | |
| }, | |
| // OpUDiv | |
| BinaryCase{ | |
| "u32", | |
| "OpUDiv", | |
| "%5:u32 = div %3, %4", | |
| }, | |
| BinaryCase{ | |
| "vec4u", | |
| "OpUDiv", | |
| "%5:vec4<u32> = div %3, %4", | |
| }, | |
| // OpUMod | |
| BinaryCase{ | |
| "u32", | |
| "OpUMod", | |
| "%5:u32 = mod %3, %4", | |
| }, | |
| BinaryCase{ | |
| "vec4u", | |
| "OpUMod", | |
| "%5:vec4<u32> = mod %3, %4", | |
| }), | |
| PrintBuiltinCase); | |
| struct VectorMatTimesCase { | |
| std::string lhs_type; | |
| std::string rhs_type; | |
| std::string res_type; | |
| std::string spirv_opcode; | |
| std::string ir; | |
| }; | |
| std::string PrintVectorMatTimesCase(testing::TestParamInfo<VectorMatTimesCase> bc) { | |
| return bc.param.spirv_opcode + "_" + bc.param.lhs_type + "_" + bc.param.rhs_type; | |
| } | |
| using VectorScalarTest = SpirvParserTestWithParam<VectorMatTimesCase>; | |
| TEST_P(VectorScalarTest, All) { | |
| auto params = GetParam(); | |
| EXPECT_IR(R"( | |
| OpCapability Shader | |
| OpCapability Float16 | |
| OpMemoryModel Logical GLSL450 | |
| OpEntryPoint GLCompute %main "main" | |
| OpExecutionMode %main LocalSize 1 1 1 | |
| %void = OpTypeVoid | |
| %f16 = OpTypeFloat 16 | |
| %f32 = OpTypeFloat 32 | |
| %vec3h = OpTypeVector %f16 3 | |
| %vec3f = OpTypeVector %f32 3 | |
| %mat3x3f = OpTypeMatrix %vec3f 3 | |
| %mat3x3h = OpTypeMatrix %vec3h 3 | |
| %ep_type = OpTypeFunction %void | |
| %fn_type = OpTypeFunction %)" + | |
| params.res_type + " %" + params.lhs_type + " %" + params.rhs_type + R"( | |
| %main = OpFunction %void None %ep_type | |
| %main_start = OpLabel | |
| OpReturn | |
| OpFunctionEnd | |
| %foo = OpFunction %)" + | |
| params.res_type + " " + R"( None %fn_type | |
| %lhs = OpFunctionParameter %)" + | |
| params.lhs_type + " " + R"( | |
| %rhs = OpFunctionParameter %)" + | |
| params.rhs_type + " " + R"( | |
| %foo_start = OpLabel | |
| %result = )" + | |
| params.spirv_opcode + R"( %)" + params.res_type + " " + R"( %lhs %rhs | |
| OpReturnValue %result | |
| OpFunctionEnd | |
| )", | |
| R"( | |
| $B2: { | |
| )" + params.ir + | |
| R"( | |
| ret %5 | |
| } | |
| )"); | |
| } | |
| INSTANTIATE_TEST_SUITE_P(SpirvParser, | |
| VectorScalarTest, | |
| testing::Values( | |
| // OpVectorTimesScalar | |
| VectorMatTimesCase{ | |
| "vec3h", | |
| "f16", | |
| "vec3h", | |
| "OpVectorTimesScalar", | |
| "%5:vec3<f16> = mul %3, %4", | |
| }, | |
| VectorMatTimesCase{ | |
| "vec3f", | |
| "f32", | |
| "vec3f", | |
| "OpVectorTimesScalar", | |
| "%5:vec3<f32> = mul %3, %4", | |
| }, | |
| // OpMatrixTimesScalar | |
| VectorMatTimesCase{ | |
| "mat3x3h", | |
| "f16", | |
| "mat3x3h", | |
| "OpMatrixTimesScalar", | |
| "%5:mat3x3<f16> = mul %3, %4", | |
| }, | |
| VectorMatTimesCase{ | |
| "mat3x3f", | |
| "f32", | |
| "mat3x3f", | |
| "OpMatrixTimesScalar", | |
| "%5:mat3x3<f32> = mul %3, %4", | |
| }, | |
| // OpMatrixTimesVector | |
| VectorMatTimesCase{ | |
| "mat3x3h", | |
| "vec3h", | |
| "vec3h", | |
| "OpMatrixTimesVector", | |
| "%5:vec3<f16> = mul %3, %4", | |
| }, | |
| VectorMatTimesCase{ | |
| "mat3x3f", | |
| "vec3f", | |
| "vec3f", | |
| "OpMatrixTimesVector", | |
| "%5:vec3<f32> = mul %3, %4", | |
| }, | |
| // OpVectorTimesMatrix | |
| VectorMatTimesCase{ | |
| "vec3h", | |
| "mat3x3h", | |
| "vec3h", | |
| "OpVectorTimesMatrix", | |
| "%5:vec3<f16> = mul %3, %4", | |
| }, | |
| VectorMatTimesCase{ | |
| "vec3f", | |
| "mat3x3f", | |
| "vec3f", | |
| "OpVectorTimesMatrix", | |
| "%5:vec3<f32> = mul %3, %4", | |
| }, | |
| // OpMatrixTimesMatrix | |
| VectorMatTimesCase{ | |
| "mat3x3h", | |
| "mat3x3h", | |
| "mat3x3h", | |
| "OpMatrixTimesMatrix", | |
| "%5:mat3x3<f16> = mul %3, %4", | |
| }, | |
| VectorMatTimesCase{ | |
| "mat3x3f", | |
| "mat3x3f", | |
| "mat3x3f", | |
| "OpMatrixTimesMatrix", | |
| "%5:mat3x3<f32> = mul %3, %4", | |
| }), | |
| PrintVectorMatTimesCase); | |
| } // namespace | |
| } // namespace tint::spirv::reader |