blob: 7747fbfa0cff4e5183344cfccb76e22a9b07b533 [file] [log] [blame] [edit]
// Copyright 2023 The Tint Authors.
//
// 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 "src/tint/lang/spirv/writer/common/helper_test.h"
namespace tint::spirv::writer {
namespace {
using namespace tint::core::fluent_types; // NOLINT
using namespace tint::number_suffixes; // NOLINT
TEST_F(SpirvWriterTest, Function_Empty) {
auto* func = b.Function("foo", ty.void_());
b.Append(func->Block(), [&] { //
b.Return(func);
});
ASSERT_TRUE(Generate()) << Error() << output_;
EXPECT_INST(R"(
%foo = OpFunction %void None %3
%4 = OpLabel
OpReturn
OpFunctionEnd
)");
}
// Test that we do not emit the same function type more than once.
TEST_F(SpirvWriterTest, Function_DeduplicateType) {
auto* func_a = b.Function("func_a", ty.void_());
b.Append(func_a->Block(), [&] { //
b.Return(func_a);
});
auto* func_b = b.Function("func_b", ty.void_());
b.Append(func_b->Block(), [&] { //
b.Return(func_b);
});
auto* func_c = b.Function("func_c", ty.void_());
b.Append(func_c->Block(), [&] { //
b.Return(func_c);
});
ASSERT_TRUE(Generate()) << Error() << output_;
EXPECT_INST(R"(
; Types, variables and constants
%void = OpTypeVoid
%3 = OpTypeFunction %void
; Function func_a
%func_a = OpFunction %void None %3
%4 = OpLabel
OpReturn
OpFunctionEnd
; Function func_b
%func_b = OpFunction %void None %3
%6 = OpLabel
OpReturn
OpFunctionEnd
; Function func_c
%func_c = OpFunction %void None %3
%8 = OpLabel
OpReturn
OpFunctionEnd
)");
}
TEST_F(SpirvWriterTest, Function_EntryPoint_Compute) {
auto* func =
b.Function("main", ty.void_(), ir::Function::PipelineStage::kCompute, {{32, 4, 1}});
b.Append(func->Block(), [&] { //
b.Return(func);
});
ASSERT_TRUE(Generate()) << Error() << output_;
EXPECT_INST(R"(
OpEntryPoint GLCompute %main "main"
OpExecutionMode %main LocalSize 32 4 1
; Debug Information
OpName %main "main" ; id %1
; Types, variables and constants
%void = OpTypeVoid
%3 = OpTypeFunction %void
; Function main
%main = OpFunction %void None %3
%4 = OpLabel
OpReturn
OpFunctionEnd
)");
}
TEST_F(SpirvWriterTest, Function_EntryPoint_Fragment) {
auto* func = b.Function("main", ty.void_(), ir::Function::PipelineStage::kFragment);
b.Append(func->Block(), [&] { //
b.Return(func);
});
ASSERT_TRUE(Generate()) << Error() << output_;
EXPECT_INST(R"(
OpEntryPoint Fragment %main "main"
OpExecutionMode %main OriginUpperLeft
; Debug Information
OpName %main "main" ; id %1
; Types, variables and constants
%void = OpTypeVoid
%3 = OpTypeFunction %void
; Function main
%main = OpFunction %void None %3
%4 = OpLabel
OpReturn
OpFunctionEnd
)");
}
TEST_F(SpirvWriterTest, Function_EntryPoint_Vertex) {
auto* func = b.Function("main", ty.void_(), ir::Function::PipelineStage::kVertex);
b.Append(func->Block(), [&] { //
b.Return(func);
});
ASSERT_TRUE(Generate()) << Error() << output_;
EXPECT_INST(R"(
OpEntryPoint Vertex %main "main"
; Debug Information
OpName %main "main" ; id %1
; Types, variables and constants
%void = OpTypeVoid
%3 = OpTypeFunction %void
; Function main
%main = OpFunction %void None %3
%4 = OpLabel
OpReturn
OpFunctionEnd
)");
}
TEST_F(SpirvWriterTest, Function_EntryPoint_Multiple) {
auto* f1 = b.Function("main1", ty.void_(), ir::Function::PipelineStage::kCompute, {{32, 4, 1}});
b.Append(f1->Block(), [&] { //
b.Return(f1);
});
auto* f2 = b.Function("main2", ty.void_(), ir::Function::PipelineStage::kCompute, {{8, 2, 16}});
b.Append(f2->Block(), [&] { //
b.Return(f2);
});
auto* f3 = b.Function("main3", ty.void_(), ir::Function::PipelineStage::kFragment);
b.Append(f3->Block(), [&] { //
b.Return(f3);
});
ASSERT_TRUE(Generate()) << Error() << output_;
EXPECT_INST(R"(
OpEntryPoint GLCompute %main1 "main1"
OpEntryPoint GLCompute %main2 "main2"
OpEntryPoint Fragment %main3 "main3"
OpExecutionMode %main1 LocalSize 32 4 1
OpExecutionMode %main2 LocalSize 8 2 16
OpExecutionMode %main3 OriginUpperLeft
; Debug Information
OpName %main1 "main1" ; id %1
OpName %main2 "main2" ; id %5
OpName %main3 "main3" ; id %7
; Types, variables and constants
%void = OpTypeVoid
%3 = OpTypeFunction %void
; Function main1
%main1 = OpFunction %void None %3
%4 = OpLabel
OpReturn
OpFunctionEnd
; Function main2
%main2 = OpFunction %void None %3
%6 = OpLabel
OpReturn
OpFunctionEnd
; Function main3
%main3 = OpFunction %void None %3
%8 = OpLabel
OpReturn
OpFunctionEnd
)");
}
TEST_F(SpirvWriterTest, Function_ReturnValue) {
auto* func = b.Function("foo", ty.i32());
b.Append(func->Block(), [&] { //
b.Return(func, 42_i);
});
ASSERT_TRUE(Generate()) << Error() << output_;
EXPECT_INST(R"(
%3 = OpTypeFunction %int
%int_42 = OpConstant %int 42
%void = OpTypeVoid
%8 = OpTypeFunction %void
; Function foo
%foo = OpFunction %int None %3
%4 = OpLabel
OpReturnValue %int_42
OpFunctionEnd
)");
}
TEST_F(SpirvWriterTest, Function_Parameters) {
auto* i32 = ty.i32();
auto* x = b.FunctionParam("x", i32);
auto* y = b.FunctionParam("y", i32);
auto* func = b.Function("foo", i32);
func->SetParams({x, y});
b.Append(func->Block(), [&] {
auto* result = b.Add(i32, x, y);
b.Return(func, result);
});
ASSERT_TRUE(Generate()) << Error() << output_;
EXPECT_INST(R"(
%5 = OpTypeFunction %int %int %int
%void = OpTypeVoid
%10 = OpTypeFunction %void
; Function foo
%foo = OpFunction %int None %5
%x = OpFunctionParameter %int
%y = OpFunctionParameter %int
%6 = OpLabel
%7 = OpIAdd %int %x %y
OpReturnValue %7
OpFunctionEnd
)");
}
TEST_F(SpirvWriterTest, Function_Call) {
auto* i32 = ty.i32();
auto* x = b.FunctionParam("x", i32);
auto* y = b.FunctionParam("y", i32);
auto* foo = b.Function("foo", i32);
foo->SetParams({x, y});
b.Append(foo->Block(), [&] {
auto* result = b.Add(i32, x, y);
b.Return(foo, result);
});
auto* bar = b.Function("bar", ty.void_());
b.Append(bar->Block(), [&] {
auto* result = b.Call(i32, foo, 2_i, 3_i);
b.Return(bar);
mod.SetName(result, "result");
});
ASSERT_TRUE(Generate()) << Error() << output_;
EXPECT_INST("%result = OpFunctionCall %int %foo %int_2 %int_3");
}
TEST_F(SpirvWriterTest, Function_Call_Void) {
auto* foo = b.Function("foo", ty.void_());
b.Append(foo->Block(), [&] { //
b.Return(foo);
});
auto* bar = b.Function("bar", ty.void_());
b.Append(bar->Block(), [&] {
auto* result = b.Call(ty.void_(), foo);
b.Return(bar);
mod.SetName(result, "result");
});
ASSERT_TRUE(Generate()) << Error() << output_;
EXPECT_INST("%result = OpFunctionCall %void %foo");
}
} // namespace
} // namespace tint::spirv::writer