src/tint/lang/spirv/reader/ast_parser/function_call_test.cc - dawn - Git at Google

 // Copyright 2020 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 "gmock/gmock.h"
 #include "src/tint/lang/spirv/reader/ast_parser/function.h"
 #include "src/tint/lang/spirv/reader/ast_parser/helper_test.h"
 #include "src/tint/lang/spirv/reader/ast_parser/spirv_tools_helpers_test.h"

 namespace tint::spirv::reader::ast_parser {
 namespace {

 using ::testing::Eq;
 using ::testing::HasSubstr;

 std::string Preamble() {
     return R"(
      OpCapability Shader
      OpMemoryModel Logical Simple
      OpEntryPoint Fragment %100 "x_100"
      OpExecutionMode %100 OriginUpperLeft
 )";
 }

 std::string CommonTypes() {
     return R"(
     %void = OpTypeVoid
     %voidfn = OpTypeFunction %void
     %float = OpTypeFloat 32
     %uint = OpTypeInt 32 0
     %int = OpTypeInt 32 1
     %float_0 = OpConstant %float 0.0
   )";
 }

 std::string CommonHandleTypes() {
     return R"(
     OpName %t "t"
     OpName %s "s"
     OpDecorate %t DescriptorSet 0
     OpDecorate %t Binding 0
     OpDecorate %s DescriptorSet 0
     OpDecorate %s Binding 1
     )" + CommonTypes() +
            R"(

     %v2float = OpTypeVector %float 2
     %v4float = OpTypeVector %float 4
     %v2_0 = OpConstantNull %v2float
     %sampler = OpTypeSampler
     %tex2d_f32 = OpTypeImage %float 2D 0 0 0 1 Unknown
     %sampled_image_2d_f32 = OpTypeSampledImage %tex2d_f32
     %ptr_sampler = OpTypePointer UniformConstant %sampler
     %ptr_tex2d_f32 = OpTypePointer UniformConstant %tex2d_f32

     %t = OpVariable %ptr_tex2d_f32 UniformConstant
     %s = OpVariable %ptr_sampler UniformConstant
   )";
 }

 TEST_F(SpirvASTParserTest, EmitStatement_VoidCallNoParams) {
     auto p = parser(test::Assemble(Preamble() + R"(
      %void = OpTypeVoid
      %voidfn = OpTypeFunction %void

      %50 = OpFunction %void None %voidfn
      %entry_50 = OpLabel
      OpReturn
      OpFunctionEnd

      %100 = OpFunction %void None %voidfn
      %entry = OpLabel
      %1 = OpFunctionCall %void %50
      OpReturn
      OpFunctionEnd
   )"));
     ASSERT_TRUE(p->BuildAndParseInternalModule()) << p->error();
     const auto got = test::ToString(p->program());
     const char* expect = R"(fn x_50() {
   return;
 }

 fn x_100_1() {
   x_50();
   return;
 }

 @fragment
 fn x_100() {
   x_100_1();
 }
 )";
     EXPECT_EQ(expect, got);
 }

 TEST_F(SpirvASTParserTest, EmitStatement_ScalarCallNoParams) {
     auto p = parser(test::Assemble(Preamble() + R"(
      %void = OpTypeVoid
      %voidfn = OpTypeFunction %void
      %uint = OpTypeInt 32 0
      %uintfn = OpTypeFunction %uint
      %val = OpConstant %uint 42

      %50 = OpFunction %uint None %uintfn
      %entry_50 = OpLabel
      OpReturnValue %val
      OpFunctionEnd

      %100 = OpFunction %void None %voidfn
      %entry = OpLabel
      %1 = OpFunctionCall %uint %50
      OpReturn
      OpFunctionEnd
   )"));
     ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
     tint::Vector<const ast::Statement*, 4> f100;
     {
         auto fe = p->function_emitter(100);
         EXPECT_TRUE(fe.EmitBody()) << p->error();
         f100 = fe.ast_body();
     }
     tint::Vector<const ast::Statement*, 4> f50;
     {
         auto fe = p->function_emitter(50);
         EXPECT_TRUE(fe.EmitBody()) << p->error();
         f50 = fe.ast_body();
     }
     auto program = p->program();
     EXPECT_THAT(test::ToString(program, f100), HasSubstr("let x_1 = x_50();\nreturn;"));
     EXPECT_THAT(test::ToString(program, f50), HasSubstr("return 42u;"));
 }

 TEST_F(SpirvASTParserTest, EmitStatement_ScalarCallNoParamsUsedTwice) {
     auto p = parser(test::Assemble(Preamble() + R"(
      %void = OpTypeVoid
      %voidfn = OpTypeFunction %void
      %uint = OpTypeInt 32 0
      %uintfn = OpTypeFunction %uint
      %val = OpConstant %uint 42
      %ptr_uint = OpTypePointer Function %uint

      %50 = OpFunction %uint None %uintfn
      %entry_50 = OpLabel
      OpReturnValue %val
      OpFunctionEnd

      %100 = OpFunction %void None %voidfn
      %entry = OpLabel
      %10 = OpVariable %ptr_uint Function
      %1 = OpFunctionCall %uint %50
      OpStore %10 %1
      OpStore %10 %1
      OpReturn
      OpFunctionEnd
   )"));
     ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
     tint::Vector<const ast::Statement*, 4> f100;
     {
         auto fe = p->function_emitter(100);
         EXPECT_TRUE(fe.EmitBody()) << p->error();
         f100 = fe.ast_body();
     }
     tint::Vector<const ast::Statement*, 4> f50;
     {
         auto fe = p->function_emitter(50);
         EXPECT_TRUE(fe.EmitBody()) << p->error();
         f50 = fe.ast_body();
     }
     auto program = p->program();
     EXPECT_EQ(test::ToString(program, f100), R"(var x_10 : u32;
 let x_1 = x_50();
 x_10 = x_1;
 x_10 = x_1;
 return;
 )");
     EXPECT_THAT(test::ToString(program, f50), HasSubstr("return 42u;"));
 }

 TEST_F(SpirvASTParserTest, EmitStatement_CallWithParams) {
     auto p = parser(test::Assemble(Preamble() + R"(
      %void = OpTypeVoid
      %voidfn = OpTypeFunction %void
      %uint = OpTypeInt 32 0
      %uintfn_uint_uint = OpTypeFunction %uint %uint %uint
      %val = OpConstant %uint 42
      %val2 = OpConstant %uint 84

      %50 = OpFunction %uint None %uintfn_uint_uint
      %51 = OpFunctionParameter %uint
      %52 = OpFunctionParameter %uint
      %entry_50 = OpLabel
      %sum = OpIAdd %uint %51 %52
      OpReturnValue %sum
      OpFunctionEnd

      %100 = OpFunction %void None %voidfn
      %entry = OpLabel
      %1 = OpFunctionCall %uint %50 %val %val2
      OpReturn
      OpFunctionEnd
   )"));
     ASSERT_TRUE(p->BuildAndParseInternalModule()) << p->error();
     EXPECT_TRUE(p->error().empty());
     const auto program_ast_str = test::ToString(p->program());
     const std::string expected = R"(fn x_50(x_51 : u32, x_52 : u32) -> u32 {
   return (x_51 + x_52);
 }

 fn x_100_1() {
   let x_1 = x_50(42u, 84u);
   return;
 }

 @fragment
 fn x_100() {
   x_100_1();
 }
 )";
     EXPECT_EQ(program_ast_str, expected);
 }

 std::string HelperFunctionPtrHandle() {
     return R"(
      ; This is how Glslang generates functions that take texture and sampler arguments.
      ; It passes them by pointer.
      %fn_ty = OpTypeFunction %void %ptr_tex2d_f32 %ptr_sampler

      %200 = OpFunction %void None %fn_ty
      %14 = OpFunctionParameter %ptr_tex2d_f32
      %15 = OpFunctionParameter %ptr_sampler
      %helper_entry = OpLabel
      ; access the texture, to give the handles usages.
      %helper_im = OpLoad %tex2d_f32 %14
      %helper_sam = OpLoad %sampler %15
      %helper_imsam = OpSampledImage %sampled_image_2d_f32 %helper_im %helper_sam
      %20 = OpImageSampleImplicitLod %v4float %helper_imsam %v2_0
      OpReturn
      OpFunctionEnd
      )";
 }

 std::string HelperFunctionHandle() {
     return R"(
      ; It is valid in SPIR-V to pass textures and samplers by value.
      %fn_ty = OpTypeFunction %void %tex2d_f32 %sampler

      %200 = OpFunction %void None %fn_ty
      %14 = OpFunctionParameter %tex2d_f32
      %15 = OpFunctionParameter %sampler
      %helper_entry = OpLabel
      ; access the texture, to give the handles usages.
      %helper_imsam = OpSampledImage %sampled_image_2d_f32 %14 %15
      %20 = OpImageSampleImplicitLod %v4float %helper_imsam %v2_0
      OpReturn
      OpFunctionEnd
      )";
 }

 TEST_F(SpirvASTParserTest, Emit_FunctionCall_HandlePtrParams_Direct) {
     auto assembly = Preamble() + CommonHandleTypes() + HelperFunctionPtrHandle() + R"(

      %100 = OpFunction %void None %voidfn
      %entry = OpLabel
      %1 = OpFunctionCall %void %200 %t %s
      OpReturn
      OpFunctionEnd
   )";

     auto p = parser(test::Assemble(assembly));
     ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly;
     auto fe = p->function_emitter(100);
     EXPECT_TRUE(fe.EmitBody()) << p->error();
     const auto got = test::ToString(p->program(), fe.ast_body());

     const std::string expect = R"(x_200(t, s);
 return;
 )";
     EXPECT_EQ(got, expect);
 }

 TEST_F(SpirvASTParserTest, Emit_FunctionCall_HandlePtrParams_CopyObject) {
     auto assembly = Preamble() + CommonHandleTypes() + HelperFunctionPtrHandle() + R"(

      %100 = OpFunction %void None %voidfn
      %entry = OpLabel

      %copy_t = OpCopyObject %ptr_tex2d_f32 %t
      %copy_s = OpCopyObject %ptr_sampler %s
      %1 = OpFunctionCall %void %200 %copy_t %copy_s
      OpReturn
      OpFunctionEnd
   )";

     auto p = parser(test::Assemble(assembly));
     ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
     auto fe = p->function_emitter(100);
     EXPECT_TRUE(fe.EmitBody()) << p->error();
     const auto got = test::ToString(p->program(), fe.ast_body());

     const std::string expect = R"(x_200(t, s);
 return;
 )";
     EXPECT_EQ(got, expect);
 }

 TEST_F(SpirvASTParserTest, Emit_FunctionCall_HandleParams_Load) {
     auto assembly = Preamble() + CommonHandleTypes() + HelperFunctionHandle() + R"(

      %100 = OpFunction %void None %voidfn
      %entry = OpLabel
      %im = OpLoad %tex2d_f32 %t
      %sam = OpLoad %sampler %s
      %1 = OpFunctionCall %void %200 %im %sam
      OpReturn
      OpFunctionEnd
   )";

     auto p = parser(test::Assemble(assembly));
     ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly;
     auto fe = p->function_emitter(100);
     EXPECT_TRUE(fe.EmitBody()) << p->error();
     const auto got = test::ToString(p->program(), fe.ast_body());

     const std::string expect = R"(x_200(t, s);
 return;
 )";
     EXPECT_EQ(got, expect);
 }

 TEST_F(SpirvASTParserTest, Emit_FunctionCall_HandleParams_LoadsAndCopyObject) {
     auto assembly = Preamble() + CommonHandleTypes() + HelperFunctionHandle() + R"(

      %100 = OpFunction %void None %voidfn
      %entry = OpLabel

      %copy_t = OpCopyObject %ptr_tex2d_f32 %t
      %copy_s = OpCopyObject %ptr_sampler %s
      %im = OpLoad %tex2d_f32 %copy_t
      %sam = OpLoad %sampler %copy_s
      %copy_im = OpCopyObject %tex2d_f32 %im
      %copy_sam = OpCopyObject %sampler %sam
      %1 = OpFunctionCall %void %200 %copy_im %copy_sam
      OpReturn
      OpFunctionEnd
   )";

     auto p = parser(test::Assemble(assembly));
     ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly;
     auto fe = p->function_emitter(100);
     EXPECT_TRUE(fe.EmitBody()) << p->error();
     const auto got = test::ToString(p->program(), fe.ast_body());

     const std::string expect = R"(x_200(t, s);
 return;
 )";
     EXPECT_EQ(got, expect);
 }

 }  // namespace
 }  // namespace tint::spirv::reader::ast_parser
	// Copyright 2020 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 "gmock/gmock.h"
	#include "src/tint/lang/spirv/reader/ast_parser/function.h"
	#include "src/tint/lang/spirv/reader/ast_parser/helper_test.h"
	#include "src/tint/lang/spirv/reader/ast_parser/spirv_tools_helpers_test.h"

	namespace tint::spirv::reader::ast_parser {
	namespace {

	using ::testing::Eq;
	using ::testing::HasSubstr;

	std::string Preamble() {
	return R"(
	OpCapability Shader
	OpMemoryModel Logical Simple
	OpEntryPoint Fragment %100 "x_100"
	OpExecutionMode %100 OriginUpperLeft
	)";
	}

	std::string CommonTypes() {
	return R"(
	%void = OpTypeVoid
	%voidfn = OpTypeFunction %void
	%float = OpTypeFloat 32
	%uint = OpTypeInt 32 0
	%int = OpTypeInt 32 1
	%float_0 = OpConstant %float 0.0
	)";
	}

	std::string CommonHandleTypes() {
	return R"(
	OpName %t "t"
	OpName %s "s"
	OpDecorate %t DescriptorSet 0
	OpDecorate %t Binding 0
	OpDecorate %s DescriptorSet 0
	OpDecorate %s Binding 1
	)" + CommonTypes() +
	R"(

	%v2float = OpTypeVector %float 2
	%v4float = OpTypeVector %float 4
	%v2_0 = OpConstantNull %v2float
	%sampler = OpTypeSampler
	%tex2d_f32 = OpTypeImage %float 2D 0 0 0 1 Unknown
	%sampled_image_2d_f32 = OpTypeSampledImage %tex2d_f32
	%ptr_sampler = OpTypePointer UniformConstant %sampler
	%ptr_tex2d_f32 = OpTypePointer UniformConstant %tex2d_f32

	%t = OpVariable %ptr_tex2d_f32 UniformConstant
	%s = OpVariable %ptr_sampler UniformConstant
	)";
	}

	TEST_F(SpirvASTParserTest, EmitStatement_VoidCallNoParams) {
	auto p = parser(test::Assemble(Preamble() + R"(
	%void = OpTypeVoid
	%voidfn = OpTypeFunction %void

	%50 = OpFunction %void None %voidfn
	%entry_50 = OpLabel
	OpReturn
	OpFunctionEnd

	%100 = OpFunction %void None %voidfn
	%entry = OpLabel
	%1 = OpFunctionCall %void %50
	OpReturn
	OpFunctionEnd
	)"));
	ASSERT_TRUE(p->BuildAndParseInternalModule()) << p->error();
	const auto got = test::ToString(p->program());
	const char* expect = R"(fn x_50() {
	return;
	}

	fn x_100_1() {
	x_50();
	return;
	}

	@fragment
	fn x_100() {
	x_100_1();
	}
	)";
	EXPECT_EQ(expect, got);
	}

	TEST_F(SpirvASTParserTest, EmitStatement_ScalarCallNoParams) {
	auto p = parser(test::Assemble(Preamble() + R"(
	%void = OpTypeVoid
	%voidfn = OpTypeFunction %void
	%uint = OpTypeInt 32 0
	%uintfn = OpTypeFunction %uint
	%val = OpConstant %uint 42

	%50 = OpFunction %uint None %uintfn
	%entry_50 = OpLabel
	OpReturnValue %val
	OpFunctionEnd

	%100 = OpFunction %void None %voidfn
	%entry = OpLabel
	%1 = OpFunctionCall %uint %50
	OpReturn
	OpFunctionEnd
	)"));
	ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
	tint::Vector<const ast::Statement*, 4> f100;
	{
	auto fe = p->function_emitter(100);
	EXPECT_TRUE(fe.EmitBody()) << p->error();
	f100 = fe.ast_body();
	}
	tint::Vector<const ast::Statement*, 4> f50;
	{
	auto fe = p->function_emitter(50);
	EXPECT_TRUE(fe.EmitBody()) << p->error();
	f50 = fe.ast_body();
	}
	auto program = p->program();
	EXPECT_THAT(test::ToString(program, f100), HasSubstr("let x_1 = x_50();\nreturn;"));
	EXPECT_THAT(test::ToString(program, f50), HasSubstr("return 42u;"));
	}

	TEST_F(SpirvASTParserTest, EmitStatement_ScalarCallNoParamsUsedTwice) {
	auto p = parser(test::Assemble(Preamble() + R"(
	%void = OpTypeVoid
	%voidfn = OpTypeFunction %void
	%uint = OpTypeInt 32 0
	%uintfn = OpTypeFunction %uint
	%val = OpConstant %uint 42
	%ptr_uint = OpTypePointer Function %uint

	%50 = OpFunction %uint None %uintfn
	%entry_50 = OpLabel
	OpReturnValue %val
	OpFunctionEnd

	%100 = OpFunction %void None %voidfn
	%entry = OpLabel
	%10 = OpVariable %ptr_uint Function
	%1 = OpFunctionCall %uint %50
	OpStore %10 %1
	OpStore %10 %1
	OpReturn
	OpFunctionEnd
	)"));
	ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << p->error();
	tint::Vector<const ast::Statement*, 4> f100;
	{
	auto fe = p->function_emitter(100);
	EXPECT_TRUE(fe.EmitBody()) << p->error();
	f100 = fe.ast_body();
	}
	tint::Vector<const ast::Statement*, 4> f50;
	{
	auto fe = p->function_emitter(50);
	EXPECT_TRUE(fe.EmitBody()) << p->error();
	f50 = fe.ast_body();
	}
	auto program = p->program();
	EXPECT_EQ(test::ToString(program, f100), R"(var x_10 : u32;
	let x_1 = x_50();
	x_10 = x_1;
	x_10 = x_1;
	return;
	)");
	EXPECT_THAT(test::ToString(program, f50), HasSubstr("return 42u;"));
	}

	TEST_F(SpirvASTParserTest, EmitStatement_CallWithParams) {
	auto p = parser(test::Assemble(Preamble() + R"(
	%void = OpTypeVoid
	%voidfn = OpTypeFunction %void
	%uint = OpTypeInt 32 0
	%uintfn_uint_uint = OpTypeFunction %uint %uint %uint
	%val = OpConstant %uint 42
	%val2 = OpConstant %uint 84

	%50 = OpFunction %uint None %uintfn_uint_uint
	%51 = OpFunctionParameter %uint
	%52 = OpFunctionParameter %uint
	%entry_50 = OpLabel
	%sum = OpIAdd %uint %51 %52
	OpReturnValue %sum
	OpFunctionEnd

	%100 = OpFunction %void None %voidfn
	%entry = OpLabel
	%1 = OpFunctionCall %uint %50 %val %val2
	OpReturn
	OpFunctionEnd
	)"));
	ASSERT_TRUE(p->BuildAndParseInternalModule()) << p->error();
	EXPECT_TRUE(p->error().empty());
	const auto program_ast_str = test::ToString(p->program());
	const std::string expected = R"(fn x_50(x_51 : u32, x_52 : u32) -> u32 {
	return (x_51 + x_52);
	}

	fn x_100_1() {
	let x_1 = x_50(42u, 84u);
	return;
	}

	@fragment
	fn x_100() {
	x_100_1();
	}
	)";
	EXPECT_EQ(program_ast_str, expected);
	}

	std::string HelperFunctionPtrHandle() {
	return R"(
	; This is how Glslang generates functions that take texture and sampler arguments.
	; It passes them by pointer.
	%fn_ty = OpTypeFunction %void %ptr_tex2d_f32 %ptr_sampler

	%200 = OpFunction %void None %fn_ty
	%14 = OpFunctionParameter %ptr_tex2d_f32
	%15 = OpFunctionParameter %ptr_sampler
	%helper_entry = OpLabel
	; access the texture, to give the handles usages.
	%helper_im = OpLoad %tex2d_f32 %14
	%helper_sam = OpLoad %sampler %15
	%helper_imsam = OpSampledImage %sampled_image_2d_f32 %helper_im %helper_sam
	%20 = OpImageSampleImplicitLod %v4float %helper_imsam %v2_0
	OpReturn
	OpFunctionEnd
	)";
	}

	std::string HelperFunctionHandle() {
	return R"(
	; It is valid in SPIR-V to pass textures and samplers by value.
	%fn_ty = OpTypeFunction %void %tex2d_f32 %sampler

	%200 = OpFunction %void None %fn_ty
	%14 = OpFunctionParameter %tex2d_f32
	%15 = OpFunctionParameter %sampler
	%helper_entry = OpLabel
	; access the texture, to give the handles usages.
	%helper_imsam = OpSampledImage %sampled_image_2d_f32 %14 %15
	%20 = OpImageSampleImplicitLod %v4float %helper_imsam %v2_0
	OpReturn
	OpFunctionEnd
	)";
	}

	TEST_F(SpirvASTParserTest, Emit_FunctionCall_HandlePtrParams_Direct) {
	auto assembly = Preamble() + CommonHandleTypes() + HelperFunctionPtrHandle() + R"(

	%100 = OpFunction %void None %voidfn
	%entry = OpLabel
	%1 = OpFunctionCall %void %200 %t %s
	OpReturn
	OpFunctionEnd
	)";

	auto p = parser(test::Assemble(assembly));
	ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly;
	auto fe = p->function_emitter(100);
	EXPECT_TRUE(fe.EmitBody()) << p->error();
	const auto got = test::ToString(p->program(), fe.ast_body());

	const std::string expect = R"(x_200(t, s);
	return;
	)";
	EXPECT_EQ(got, expect);
	}

	TEST_F(SpirvASTParserTest, Emit_FunctionCall_HandlePtrParams_CopyObject) {
	auto assembly = Preamble() + CommonHandleTypes() + HelperFunctionPtrHandle() + R"(

	%100 = OpFunction %void None %voidfn
	%entry = OpLabel

	%copy_t = OpCopyObject %ptr_tex2d_f32 %t
	%copy_s = OpCopyObject %ptr_sampler %s
	%1 = OpFunctionCall %void %200 %copy_t %copy_s
	OpReturn
	OpFunctionEnd
	)";

	auto p = parser(test::Assemble(assembly));
	ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions());
	auto fe = p->function_emitter(100);
	EXPECT_TRUE(fe.EmitBody()) << p->error();
	const auto got = test::ToString(p->program(), fe.ast_body());

	const std::string expect = R"(x_200(t, s);
	return;
	)";
	EXPECT_EQ(got, expect);
	}

	TEST_F(SpirvASTParserTest, Emit_FunctionCall_HandleParams_Load) {
	auto assembly = Preamble() + CommonHandleTypes() + HelperFunctionHandle() + R"(

	%100 = OpFunction %void None %voidfn
	%entry = OpLabel
	%im = OpLoad %tex2d_f32 %t
	%sam = OpLoad %sampler %s
	%1 = OpFunctionCall %void %200 %im %sam
	OpReturn
	OpFunctionEnd
	)";

	auto p = parser(test::Assemble(assembly));
	ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly;
	auto fe = p->function_emitter(100);
	EXPECT_TRUE(fe.EmitBody()) << p->error();
	const auto got = test::ToString(p->program(), fe.ast_body());

	const std::string expect = R"(x_200(t, s);
	return;
	)";
	EXPECT_EQ(got, expect);
	}

	TEST_F(SpirvASTParserTest, Emit_FunctionCall_HandleParams_LoadsAndCopyObject) {
	auto assembly = Preamble() + CommonHandleTypes() + HelperFunctionHandle() + R"(

	%100 = OpFunction %void None %voidfn
	%entry = OpLabel

	%copy_t = OpCopyObject %ptr_tex2d_f32 %t
	%copy_s = OpCopyObject %ptr_sampler %s
	%im = OpLoad %tex2d_f32 %copy_t
	%sam = OpLoad %sampler %copy_s
	%copy_im = OpCopyObject %tex2d_f32 %im
	%copy_sam = OpCopyObject %sampler %sam
	%1 = OpFunctionCall %void %200 %copy_im %copy_sam
	OpReturn
	OpFunctionEnd
	)";

	auto p = parser(test::Assemble(assembly));
	ASSERT_TRUE(p->BuildAndParseInternalModuleExceptFunctions()) << assembly;
	auto fe = p->function_emitter(100);
	EXPECT_TRUE(fe.EmitBody()) << p->error();
	const auto got = test::ToString(p->program(), fe.ast_body());

	const std::string expect = R"(x_200(t, s);
	return;
	)";
	EXPECT_EQ(got, expect);
	}

	} // namespace
	} // namespace tint::spirv::reader::ast_parser