blob: 9f2447543dce738a2dce4f7c1eb2caa81738b5be [file] [log] [blame]
// 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