| // Copyright 2023 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/core/fluent_types.h" |
| #include "src/tint/lang/spirv/writer/common/helper_test.h" |
| |
| namespace tint::spirv::writer { |
| namespace { |
| |
| using namespace tint::core::number_suffixes; // NOLINT |
| using namespace tint::core::fluent_types; // NOLINT |
| |
| TEST_F(SpirvWriterTest, Constant_Bool) { |
| b.Append(b.ir.root_block, [&] { |
| b.Var<private_, read_write>("v", true); |
| b.Var<private_, read_write>("v", false); |
| }); |
| ASSERT_TRUE(Generate()) << Error() << output_; |
| EXPECT_INST("%true = OpConstantTrue %bool"); |
| EXPECT_INST("%false = OpConstantFalse %bool"); |
| } |
| |
| TEST_F(SpirvWriterTest, Constant_I32) { |
| b.Append(b.ir.root_block, [&] { |
| b.Var<private_, read_write>("v", i32(42)); |
| b.Var<private_, read_write>("v", i32(-1)); |
| }); |
| ASSERT_TRUE(Generate()) << Error() << output_; |
| EXPECT_INST("%int_42 = OpConstant %int 42"); |
| EXPECT_INST("%int_n1 = OpConstant %int -1"); |
| } |
| |
| TEST_F(SpirvWriterTest, Constant_U32) { |
| b.Append(b.ir.root_block, [&] { |
| b.Var<private_, read_write>("v", u32(42)); |
| b.Var<private_, read_write>("v", u32(4000000000)); |
| }); |
| ASSERT_TRUE(Generate()) << Error() << output_; |
| EXPECT_INST("%uint_42 = OpConstant %uint 42"); |
| EXPECT_INST("%uint_4000000000 = OpConstant %uint 4000000000"); |
| } |
| |
| TEST_F(SpirvWriterTest, Constant_F32) { |
| b.Append(b.ir.root_block, [&] { |
| b.Var<private_, read_write>("v", f32(42)); |
| b.Var<private_, read_write>("v", f32(-1)); |
| }); |
| ASSERT_TRUE(Generate()) << Error() << output_; |
| EXPECT_INST("%float_42 = OpConstant %float 42"); |
| EXPECT_INST("%float_n1 = OpConstant %float -1"); |
| } |
| |
| TEST_F(SpirvWriterTest, Constant_F16) { |
| b.Append(b.ir.root_block, [&] { |
| b.Var<private_, read_write>("v", f16(42)); |
| b.Var<private_, read_write>("v", f16(-1)); |
| }); |
| ASSERT_TRUE(Generate()) << Error() << output_; |
| EXPECT_INST("%half_0x1_5p_5 = OpConstant %half 0x1.5p+5"); |
| EXPECT_INST("%half_n0x1p_0 = OpConstant %half -0x1p+0"); |
| } |
| |
| TEST_F(SpirvWriterTest, Constant_Vec4Bool) { |
| b.Append(b.ir.root_block, [&] { |
| b.Var<private_, read_write>("v", b.Composite(ty.vec4<bool>(), true, false, false, true)); |
| }); |
| ASSERT_TRUE(Generate()) << Error() << output_; |
| EXPECT_INST(" = OpConstantComposite %v4bool %true %false %false %true"); |
| } |
| |
| TEST_F(SpirvWriterTest, Constant_Vec2i) { |
| b.Append(b.ir.root_block, |
| [&] { b.Var<private_, read_write>("v", b.Composite(ty.vec2<i32>(), 42_i, -1_i)); }); |
| ASSERT_TRUE(Generate()) << Error() << output_; |
| EXPECT_INST(" = OpConstantComposite %v2int %int_42 %int_n1"); |
| } |
| |
| TEST_F(SpirvWriterTest, Constant_Vec3u) { |
| b.Append(b.ir.root_block, [&] { |
| b.Var<private_, read_write>("v", b.Composite(ty.vec3<u32>(), 42_u, 0_u, 4000000000_u)); |
| }); |
| ASSERT_TRUE(Generate()) << Error() << output_; |
| EXPECT_INST(" = OpConstantComposite %v3uint %uint_42 %uint_0 %uint_4000000000"); |
| } |
| |
| TEST_F(SpirvWriterTest, Constant_Vec4f) { |
| b.Append(b.ir.root_block, [&] { |
| b.Var<private_, read_write>("v", b.Composite(ty.vec4<f32>(), 42_f, 0_f, 0.25_f, -1_f)); |
| }); |
| ASSERT_TRUE(Generate()) << Error() << output_; |
| EXPECT_INST(" = OpConstantComposite %v4float %float_42 %float_0 %float_0_25 %float_n1"); |
| } |
| |
| TEST_F(SpirvWriterTest, Constant_Vec2h) { |
| b.Append(b.ir.root_block, |
| [&] { b.Var<private_, read_write>("v", b.Composite(ty.vec2<f16>(), 42_h, 0.25_h)); }); |
| ASSERT_TRUE(Generate()) << Error() << output_; |
| EXPECT_INST(" = OpConstantComposite %v2half %half_0x1_5p_5 %half_0x1pn2"); |
| } |
| |
| TEST_F(SpirvWriterTest, Constant_Mat2x3f) { |
| b.Append(b.ir.root_block, [&] { |
| b.Var<private_, read_write>("v", |
| b.Composite(ty.mat2x3<f32>(), // |
| b.Composite(ty.vec3<f32>(), 42_f, -1_f, 0.25_f), |
| b.Composite(ty.vec3<f32>(), -42_f, 0_f, -0.25_f))); |
| }); |
| ASSERT_TRUE(Generate()) << Error() << output_; |
| EXPECT_INST(R"( |
| %float_42 = OpConstant %float 42 |
| %float_n1 = OpConstant %float -1 |
| %float_0_25 = OpConstant %float 0.25 |
| %7 = OpConstantComposite %v3float %float_42 %float_n1 %float_0_25 |
| %float_n42 = OpConstant %float -42 |
| %float_0 = OpConstant %float 0 |
| %float_n0_25 = OpConstant %float -0.25 |
| %11 = OpConstantComposite %v3float %float_n42 %float_0 %float_n0_25 |
| %6 = OpConstantComposite %mat2v3float %7 %11 |
| )"); |
| } |
| |
| TEST_F(SpirvWriterTest, Constant_Mat4x2h) { |
| b.Append(b.ir.root_block, [&] { |
| b.Var<private_, read_write>("v", b.Composite(ty.mat4x2<f16>(), // |
| b.Composite(ty.vec2<f16>(), 42_h, -1_h), // |
| b.Composite(ty.vec2<f16>(), 0_h, 0.25_h), // |
| b.Composite(ty.vec2<f16>(), -42_h, 1_h), // |
| b.Composite(ty.vec2<f16>(), 0.5_h, f16(-0)))); |
| }); |
| ASSERT_TRUE(Generate()) << Error() << output_; |
| EXPECT_INST(R"( |
| %half_0x1_5p_5 = OpConstant %half 0x1.5p+5 |
| %half_n0x1p_0 = OpConstant %half -0x1p+0 |
| %7 = OpConstantComposite %v2half %half_0x1_5p_5 %half_n0x1p_0 |
| %half_0x0p_0 = OpConstant %half 0x0p+0 |
| %half_0x1pn2 = OpConstant %half 0x1p-2 |
| %10 = OpConstantComposite %v2half %half_0x0p_0 %half_0x1pn2 |
| %half_n0x1_5p_5 = OpConstant %half -0x1.5p+5 |
| %half_0x1p_0 = OpConstant %half 0x1p+0 |
| %13 = OpConstantComposite %v2half %half_n0x1_5p_5 %half_0x1p_0 |
| %half_0x1pn1 = OpConstant %half 0x1p-1 |
| %16 = OpConstantComposite %v2half %half_0x1pn1 %half_0x0p_0 |
| %6 = OpConstantComposite %mat4v2half %7 %10 %13 %16 |
| )"); |
| } |
| |
| TEST_F(SpirvWriterTest, Constant_Array_I32) { |
| b.Append(b.ir.root_block, [&] { |
| b.Var<private_, read_write>("v", b.Composite(ty.array<i32, 4>(), 1_i, 2_i, 3_i, 4_i)); |
| }); |
| ASSERT_TRUE(Generate()) << Error() << output_; |
| EXPECT_INST(" = OpConstantComposite %_arr_int_uint_4 %int_1 %int_2 %int_3 %int_4"); |
| } |
| |
| TEST_F(SpirvWriterTest, Constant_Array_Array_I32) { |
| b.Append(b.ir.root_block, [&] { |
| auto* inner = b.Composite(ty.array<i32, 4>(), 1_i, 2_i, 3_i, 4_i); |
| b.Var<private_, read_write>( |
| "v", b.Composite(ty.array(ty.array<i32, 4>(), 4), inner, inner, inner, inner)); |
| }); |
| ASSERT_TRUE(Generate()) << Error() << output_; |
| EXPECT_INST(R"( |
| %9 = OpConstantComposite %_arr_int_uint_4 %int_1 %int_2 %int_3 %int_4 |
| %8 = OpConstantComposite %_arr__arr_int_uint_4_uint_4 %9 %9 %9 %9 |
| )"); |
| } |
| |
| TEST_F(SpirvWriterTest, Constant_Array_LargeAllZero) { |
| b.Append(b.ir.root_block, |
| [&] { b.Var<private_, read_write>("v", b.Zero(ty.array<i32, 65535>())); }); |
| ASSERT_TRUE(Generate()) << Error() << output_; |
| EXPECT_INST(" = OpConstantNull %_arr_int_uint_65535"); |
| } |
| |
| TEST_F(SpirvWriterTest, Constant_Struct) { |
| b.Append(b.ir.root_block, [&] { |
| auto* str_ty = ty.Struct(mod.symbols.New("MyStruct"), { |
| {mod.symbols.New("a"), ty.i32()}, |
| {mod.symbols.New("b"), ty.u32()}, |
| {mod.symbols.New("c"), ty.f32()}, |
| }); |
| b.Var<private_, read_write>("v", b.Composite(str_ty, 1_i, 2_u, 3_f)); |
| }); |
| ASSERT_TRUE(Generate()) << Error() << output_; |
| EXPECT_INST(" = OpConstantComposite %MyStruct %int_1 %uint_2 %float_3"); |
| } |
| |
| // Test that we do not emit the same constant more than once. |
| TEST_F(SpirvWriterTest, Constant_Deduplicate) { |
| b.Append(b.ir.root_block, [&] { |
| b.Var<private_, read_write>("v", 42_i); |
| b.Var<private_, read_write>("v", 42_i); |
| b.Var<private_, read_write>("v", 42_i); |
| }); |
| ASSERT_TRUE(Generate()) << Error() << output_; |
| EXPECT_INST("%int_42 = OpConstant %int 42"); |
| } |
| |
| } // namespace |
| } // namespace tint::spirv::writer |
