| // 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 "src/tint/writer/spirv/spv_dump.h" |
| #include "src/tint/writer/spirv/test_helper.h" |
| |
| using namespace tint::number_suffixes; // NOLINT |
| |
| namespace tint::writer::spirv { |
| namespace { |
| |
| using SpvBuilderConstructorTest = TestHelper; |
| |
| TEST_F(SpvBuilderConstructorTest, Const) { |
| auto* c = Expr(42.2_f); |
| auto* g = GlobalVar("g", ty.f32(), c, builtin::AddressSpace::kPrivate); |
| |
| spirv::Builder& b = Build(); |
| |
| EXPECT_EQ(b.GenerateConstructorExpression(g, c), 2u); |
| ASSERT_FALSE(b.has_error()) << b.error(); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeFloat 32 |
| %2 = OpConstant %1 42.2000008 |
| )"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type) { |
| auto* t = vec3<f32>(1_f, 1_f, 3_f); |
| WrapInFunction(t); |
| |
| spirv::Builder& b = Build(); |
| |
| EXPECT_EQ(b.GenerateConstructorExpression(nullptr, t), 5u); |
| ASSERT_FALSE(b.has_error()) << b.error(); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 |
| %1 = OpTypeVector %2 3 |
| %3 = OpConstant %2 1 |
| %4 = OpConstant %2 3 |
| %5 = OpConstantComposite %1 %3 %3 %4 |
| )"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_WithCasts) { |
| auto* t = vec2<f32>(Call<f32>(1_i), Call<f32>(1_i)); |
| WrapInFunction(t); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| |
| EXPECT_EQ(b.GenerateExpression(t), 4u); |
| ASSERT_FALSE(b.has_error()) << b.error(); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 |
| %1 = OpTypeVector %2 2 |
| %3 = OpConstant %2 1 |
| %4 = OpConstantComposite %1 %3 %3 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"()"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_WithAlias) { |
| // type Int = i32 |
| // cast<Int>(2.3f) |
| |
| auto* alias = Alias("Int", ty.i32()); |
| auto* cast = Call(ty.Of(alias), 2.3_f); |
| WrapInFunction(cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_EQ(b.GenerateExpression(cast), 2u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeInt 32 1 |
| %2 = OpConstant %1 2 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"()"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_IdentifierExpression_Param) { |
| auto* var = Var("ident", ty.f32()); |
| |
| auto* t = vec2<f32>(1_f, "ident"); |
| WrapInFunction(var, t); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| ASSERT_TRUE(b.GenerateFunctionVariable(var)) << b.error(); |
| |
| EXPECT_EQ(b.GenerateExpression(t), 8u); |
| ASSERT_FALSE(b.has_error()) << b.error(); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%3 = OpTypeFloat 32 |
| %2 = OpTypePointer Function %3 |
| %4 = OpConstantNull %3 |
| %5 = OpTypeVector %3 2 |
| %6 = OpConstant %3 1 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].variables()), |
| R"(%1 = OpVariable %2 Function %4 |
| )"); |
| |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), |
| R"(%7 = OpLoad %3 %1 |
| %8 = OpCompositeConstruct %5 %6 %7 |
| )"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Vector_Bitcast_Params) { |
| auto* var = Var("v", vec3<f32>(1_f, 2_f, 3_f)); |
| auto* cast = Bitcast(ty.vec3<u32>(), var); |
| WrapInFunction(var, cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| ASSERT_TRUE(b.GenerateFunctionVariable(var)) << b.error(); |
| ASSERT_EQ(b.GenerateExpression(cast), 10u) << b.error(); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 |
| %1 = OpTypeVector %2 3 |
| %3 = OpConstant %2 1 |
| %4 = OpConstant %2 2 |
| %5 = OpConstant %2 3 |
| %6 = OpConstantComposite %1 %3 %4 %5 |
| %8 = OpTypePointer Function %1 |
| %9 = OpConstantNull %1 |
| %12 = OpTypeInt 32 0 |
| %11 = OpTypeVector %12 3 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), |
| R"(OpStore %7 %6 |
| %13 = OpLoad %1 %7 |
| %10 = OpBitcast %11 %13 |
| )"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_Bool_With_Bool) { |
| auto* cast = Call<bool>(true); |
| WrapInFunction(cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| |
| EXPECT_EQ(b.GenerateExpression(cast), 2u); |
| ASSERT_FALSE(b.has_error()) << b.error(); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeBool |
| %2 = OpConstantTrue %1 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"()"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_I32_With_I32) { |
| auto* cast = Call<i32>(2_i); |
| WrapInFunction(cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_EQ(b.GenerateExpression(cast), 2u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeInt 32 1 |
| %2 = OpConstant %1 2 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"()"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_U32_With_U32) { |
| auto* cast = Call<u32>(2_u); |
| WrapInFunction(cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_EQ(b.GenerateExpression(cast), 2u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeInt 32 0 |
| %2 = OpConstant %1 2 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"()"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_F32_With_F32) { |
| auto* cast = Call<f32>(2_f); |
| WrapInFunction(cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_EQ(b.GenerateExpression(cast), 2u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeFloat 32 |
| %2 = OpConstant %1 2 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"()"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_F16_With_F16) { |
| Enable(builtin::Extension::kF16); |
| |
| auto* cast = Call<f16>(2_h); |
| WrapInFunction(cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_EQ(b.GenerateExpression(cast), 2u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeFloat 16 |
| %2 = OpConstant %1 0x1p+1 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"()"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_Vec2_With_Bool_Literal) { |
| auto* cast = vec2<bool>(true); |
| WrapInFunction(cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_EQ(b.GenerateExpression(cast), 4u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeBool |
| %1 = OpTypeVector %2 2 |
| %3 = OpConstantTrue %2 |
| %4 = OpConstantComposite %1 %3 %3 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"()"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_Vec2_With_Bool_Var) { |
| auto* var = Var("v", Expr(true)); |
| auto* cast = vec2<bool>(var); |
| WrapInFunction(var, cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| ASSERT_TRUE(b.GenerateFunctionVariable(var)) << b.error(); |
| ASSERT_EQ(b.GenerateExpression(cast), 8u) << b.error(); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeBool |
| %2 = OpConstantTrue %1 |
| %4 = OpTypePointer Function %1 |
| %5 = OpConstantNull %1 |
| %6 = OpTypeVector %1 2 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), |
| R"(OpStore %3 %2 |
| %7 = OpLoad %1 %3 |
| %8 = OpCompositeConstruct %6 %7 %7 |
| )"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_Vec2_With_F32_Literal) { |
| auto* cast = vec2<f32>(2_f); |
| WrapInFunction(cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_EQ(b.GenerateExpression(cast), 4u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 |
| %1 = OpTypeVector %2 2 |
| %3 = OpConstant %2 2 |
| %4 = OpConstantComposite %1 %3 %3 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"()"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_Vec2_With_F16_Literal) { |
| Enable(builtin::Extension::kF16); |
| |
| auto* cast = vec2<f16>(2_h); |
| WrapInFunction(cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_EQ(b.GenerateExpression(cast), 4u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 16 |
| %1 = OpTypeVector %2 2 |
| %3 = OpConstant %2 0x1p+1 |
| %4 = OpConstantComposite %1 %3 %3 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"()"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_Vec2_With_F32_F32) { |
| auto* var = Decl(Var("x", ty.f32(), Expr(2_f))); |
| auto* cast = vec2<f32>("x", "x"); |
| WrapInFunction(var, cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_TRUE(b.GenerateStatement(var)); |
| EXPECT_EQ(b.GenerateExpression(cast), 9u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeFloat 32 |
| %2 = OpConstant %1 2 |
| %4 = OpTypePointer Function %1 |
| %5 = OpConstantNull %1 |
| %6 = OpTypeVector %1 2 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), |
| R"(OpStore %3 %2 |
| %7 = OpLoad %1 %3 |
| %8 = OpLoad %1 %3 |
| %9 = OpCompositeConstruct %6 %7 %8 |
| )"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_Vec2_With_F16_F16) { |
| Enable(builtin::Extension::kF16); |
| |
| auto* var = Decl(Var("x", ty.f16(), Expr(2_h))); |
| auto* cast = vec2<f16>("x", "x"); |
| WrapInFunction(var, cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_TRUE(b.GenerateStatement(var)); |
| EXPECT_EQ(b.GenerateExpression(cast), 9u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeFloat 16 |
| %2 = OpConstant %1 0x1p+1 |
| %4 = OpTypePointer Function %1 |
| %5 = OpConstantNull %1 |
| %6 = OpTypeVector %1 2 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), |
| R"(OpStore %3 %2 |
| %7 = OpLoad %1 %3 |
| %8 = OpLoad %1 %3 |
| %9 = OpCompositeConstruct %6 %7 %8 |
| )"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_Vec2_With_F32_F32_Const) { |
| auto* cast = vec2<f32>(1_f, 2_f); |
| WrapInFunction(cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_EQ(b.GenerateExpression(cast), 5u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 |
| %1 = OpTypeVector %2 2 |
| %3 = OpConstant %2 1 |
| %4 = OpConstant %2 2 |
| %5 = OpConstantComposite %1 %3 %4 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"()"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_Vec2_With_F16_F16_Const) { |
| Enable(builtin::Extension::kF16); |
| |
| auto* cast = vec2<f16>(1_h, 2_h); |
| WrapInFunction(cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_EQ(b.GenerateExpression(cast), 5u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 16 |
| %1 = OpTypeVector %2 2 |
| %3 = OpConstant %2 0x1p+0 |
| %4 = OpConstant %2 0x1p+1 |
| %5 = OpConstantComposite %1 %3 %4 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"()"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_Vec2_F32_With_Vec2) { |
| auto* var = Decl(Var("x", ty.vec2<f32>(), vec2<f32>(1_f, 2_f))); |
| auto* cast = vec2<f32>("x"); |
| WrapInFunction(var, cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_TRUE(b.GenerateStatement(var)); |
| EXPECT_EQ(b.GenerateExpression(cast), 10u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 |
| %1 = OpTypeVector %2 2 |
| %3 = OpConstant %2 1 |
| %4 = OpConstant %2 2 |
| %5 = OpConstantComposite %1 %3 %4 |
| %7 = OpTypePointer Function %1 |
| %8 = OpConstantNull %1 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), |
| R"(OpStore %6 %5 |
| %10 = OpLoad %1 %6 |
| )"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_Vec2_F16_With_Vec2) { |
| Enable(builtin::Extension::kF16); |
| |
| auto* var = Decl(Var("x", ty.vec2<f16>(), vec2<f16>(1_h, 2_h))); |
| auto* cast = vec2<f16>("x"); |
| WrapInFunction(var, cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_TRUE(b.GenerateStatement(var)); |
| EXPECT_EQ(b.GenerateExpression(cast), 10u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 16 |
| %1 = OpTypeVector %2 2 |
| %3 = OpConstant %2 0x1p+0 |
| %4 = OpConstant %2 0x1p+1 |
| %5 = OpConstantComposite %1 %3 %4 |
| %7 = OpTypePointer Function %1 |
| %8 = OpConstantNull %1 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), |
| R"(OpStore %6 %5 |
| %10 = OpLoad %1 %6 |
| )"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_Vec2_F32_With_Vec2_Const) { |
| auto* cast = vec2<f32>(vec2<f32>(1_f, 2_f)); |
| WrapInFunction(cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_EQ(b.GenerateExpression(cast), 5u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 |
| %1 = OpTypeVector %2 2 |
| %3 = OpConstant %2 1 |
| %4 = OpConstant %2 2 |
| %5 = OpConstantComposite %1 %3 %4 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"()"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_Vec2_F16_With_Vec2_Const) { |
| Enable(builtin::Extension::kF16); |
| |
| auto* cast = vec2<f16>(vec2<f16>(1_h, 2_h)); |
| WrapInFunction(cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_EQ(b.GenerateExpression(cast), 5u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 16 |
| %1 = OpTypeVector %2 2 |
| %3 = OpConstant %2 0x1p+0 |
| %4 = OpConstant %2 0x1p+1 |
| %5 = OpConstantComposite %1 %3 %4 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"()"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_Vec3_With_F32) { |
| auto* var = Decl(Var("x", ty.f32(), Expr(2_f))); |
| auto* cast = vec3<f32>("x", "x", "x"); |
| WrapInFunction(var, cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_TRUE(b.GenerateStatement(var)); |
| EXPECT_EQ(b.GenerateExpression(cast), 10u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeFloat 32 |
| %2 = OpConstant %1 2 |
| %4 = OpTypePointer Function %1 |
| %5 = OpConstantNull %1 |
| %6 = OpTypeVector %1 3 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), |
| R"(OpStore %3 %2 |
| %7 = OpLoad %1 %3 |
| %8 = OpLoad %1 %3 |
| %9 = OpLoad %1 %3 |
| %10 = OpCompositeConstruct %6 %7 %8 %9 |
| )"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_Vec3_With_F16) { |
| Enable(builtin::Extension::kF16); |
| |
| auto* var = Decl(Var("x", ty.f16(), Expr(2_h))); |
| auto* cast = vec3<f16>("x", "x", "x"); |
| WrapInFunction(var, cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_TRUE(b.GenerateStatement(var)); |
| EXPECT_EQ(b.GenerateExpression(cast), 10u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeFloat 16 |
| %2 = OpConstant %1 0x1p+1 |
| %4 = OpTypePointer Function %1 |
| %5 = OpConstantNull %1 |
| %6 = OpTypeVector %1 3 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), |
| R"(OpStore %3 %2 |
| %7 = OpLoad %1 %3 |
| %8 = OpLoad %1 %3 |
| %9 = OpLoad %1 %3 |
| %10 = OpCompositeConstruct %6 %7 %8 %9 |
| )"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_Vec3_With_F32_Const) { |
| auto* cast = vec3<f32>(1_f, 2_f, 3_f); |
| WrapInFunction(cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_EQ(b.GenerateExpression(cast), 6u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 |
| %1 = OpTypeVector %2 3 |
| %3 = OpConstant %2 1 |
| %4 = OpConstant %2 2 |
| %5 = OpConstant %2 3 |
| %6 = OpConstantComposite %1 %3 %4 %5 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"()"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_Vec3_With_F16_Const) { |
| Enable(builtin::Extension::kF16); |
| |
| auto* cast = vec3<f16>(1_h, 2_h, 3_h); |
| WrapInFunction(cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_EQ(b.GenerateExpression(cast), 6u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 16 |
| %1 = OpTypeVector %2 3 |
| %3 = OpConstant %2 0x1p+0 |
| %4 = OpConstant %2 0x1p+1 |
| %5 = OpConstant %2 0x1.8p+1 |
| %6 = OpConstantComposite %1 %3 %4 %5 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"()"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_Vec3_With_Bool) { |
| auto* var = Decl(Var("x", ty.bool_(), Expr(true))); |
| auto* cast = vec3<bool>("x", "x", "x"); |
| WrapInFunction(var, cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_TRUE(b.GenerateStatement(var)); |
| EXPECT_EQ(b.GenerateExpression(cast), 10u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeBool |
| %2 = OpConstantTrue %1 |
| %4 = OpTypePointer Function %1 |
| %5 = OpConstantNull %1 |
| %6 = OpTypeVector %1 3 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), |
| R"(OpStore %3 %2 |
| %7 = OpLoad %1 %3 |
| %8 = OpLoad %1 %3 |
| %9 = OpLoad %1 %3 |
| %10 = OpCompositeConstruct %6 %7 %8 %9 |
| )"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_Vec3_With_Bool_Const) { |
| auto* cast = vec3<bool>(true, false, true); |
| WrapInFunction(cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_EQ(b.GenerateExpression(cast), 5u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeBool |
| %1 = OpTypeVector %2 3 |
| %3 = OpConstantTrue %2 |
| %4 = OpConstantNull %2 |
| %5 = OpConstantComposite %1 %3 %4 %3 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"()"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_Vec3_With_F32_F32_F32) { |
| auto* var = Decl(Var("x", ty.f32(), Expr(2_f))); |
| auto* cast = vec3<f32>("x", "x", "x"); |
| WrapInFunction(var, cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_TRUE(b.GenerateStatement(var)); |
| EXPECT_EQ(b.GenerateExpression(cast), 10u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeFloat 32 |
| %2 = OpConstant %1 2 |
| %4 = OpTypePointer Function %1 |
| %5 = OpConstantNull %1 |
| %6 = OpTypeVector %1 3 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), |
| R"(OpStore %3 %2 |
| %7 = OpLoad %1 %3 |
| %8 = OpLoad %1 %3 |
| %9 = OpLoad %1 %3 |
| %10 = OpCompositeConstruct %6 %7 %8 %9 |
| )"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_Vec3_With_F16_F16_F16) { |
| Enable(builtin::Extension::kF16); |
| |
| auto* var = Decl(Var("x", ty.f16(), Expr(2_h))); |
| auto* cast = vec3<f16>("x", "x", "x"); |
| WrapInFunction(var, cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_TRUE(b.GenerateStatement(var)); |
| EXPECT_EQ(b.GenerateExpression(cast), 10u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeFloat 16 |
| %2 = OpConstant %1 0x1p+1 |
| %4 = OpTypePointer Function %1 |
| %5 = OpConstantNull %1 |
| %6 = OpTypeVector %1 3 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), |
| R"(OpStore %3 %2 |
| %7 = OpLoad %1 %3 |
| %8 = OpLoad %1 %3 |
| %9 = OpLoad %1 %3 |
| %10 = OpCompositeConstruct %6 %7 %8 %9 |
| )"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_Vec3_With_F32_F32_F32_Const) { |
| auto* cast = vec3<f32>(1_f, 2_f, 3_f); |
| WrapInFunction(cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_EQ(b.GenerateExpression(cast), 6u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 |
| %1 = OpTypeVector %2 3 |
| %3 = OpConstant %2 1 |
| %4 = OpConstant %2 2 |
| %5 = OpConstant %2 3 |
| %6 = OpConstantComposite %1 %3 %4 %5 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"()"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_Vec3_With_F16_F16_F16_Const) { |
| Enable(builtin::Extension::kF16); |
| |
| auto* cast = vec3<f16>(1_h, 2_h, 3_h); |
| WrapInFunction(cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_EQ(b.GenerateExpression(cast), 6u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 16 |
| %1 = OpTypeVector %2 3 |
| %3 = OpConstant %2 0x1p+0 |
| %4 = OpConstant %2 0x1p+1 |
| %5 = OpConstant %2 0x1.8p+1 |
| %6 = OpConstantComposite %1 %3 %4 %5 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"()"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_Vec3_With_F32_Vec2) { |
| auto* var = Decl(Var("x", ty.vec2<f32>(), vec2<f32>(2_f, 3_f))); |
| auto* cast = vec3<f32>(1_f, "x"); |
| WrapInFunction(var, cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_TRUE(b.GenerateStatement(var)); |
| EXPECT_EQ(b.GenerateExpression(cast), 14u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 |
| %1 = OpTypeVector %2 2 |
| %3 = OpConstant %2 2 |
| %4 = OpConstant %2 3 |
| %5 = OpConstantComposite %1 %3 %4 |
| %7 = OpTypePointer Function %1 |
| %8 = OpConstantNull %1 |
| %9 = OpTypeVector %2 3 |
| %10 = OpConstant %2 1 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), |
| R"(OpStore %6 %5 |
| %11 = OpLoad %1 %6 |
| %12 = OpCompositeExtract %2 %11 0 |
| %13 = OpCompositeExtract %2 %11 1 |
| %14 = OpCompositeConstruct %9 %10 %12 %13 |
| )"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_Vec3_With_F16_Vec2) { |
| Enable(builtin::Extension::kF16); |
| |
| auto* var = Decl(Var("x", ty.vec2<f16>(), vec2<f16>(2_h, 3_h))); |
| auto* cast = vec3<f16>(1_h, "x"); |
| WrapInFunction(var, cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_TRUE(b.GenerateStatement(var)); |
| EXPECT_EQ(b.GenerateExpression(cast), 14u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 16 |
| %1 = OpTypeVector %2 2 |
| %3 = OpConstant %2 0x1p+1 |
| %4 = OpConstant %2 0x1.8p+1 |
| %5 = OpConstantComposite %1 %3 %4 |
| %7 = OpTypePointer Function %1 |
| %8 = OpConstantNull %1 |
| %9 = OpTypeVector %2 3 |
| %10 = OpConstant %2 0x1p+0 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), |
| R"(OpStore %6 %5 |
| %11 = OpLoad %1 %6 |
| %12 = OpCompositeExtract %2 %11 0 |
| %13 = OpCompositeExtract %2 %11 1 |
| %14 = OpCompositeConstruct %9 %10 %12 %13 |
| )"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_Vec3_With_F32_Vec2_Const) { |
| auto* cast = vec3<f32>(1_f, vec2<f32>(2_f, 3_f)); |
| WrapInFunction(cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_EQ(b.GenerateExpression(cast), 6u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 |
| %1 = OpTypeVector %2 3 |
| %3 = OpConstant %2 1 |
| %4 = OpConstant %2 2 |
| %5 = OpConstant %2 3 |
| %6 = OpConstantComposite %1 %3 %4 %5 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"()"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_Vec3_With_F16_Vec2_Const) { |
| Enable(builtin::Extension::kF16); |
| |
| auto* cast = vec3<f16>(1_h, vec2<f16>(2_h, 3_h)); |
| WrapInFunction(cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_EQ(b.GenerateExpression(cast), 6u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 16 |
| %1 = OpTypeVector %2 3 |
| %3 = OpConstant %2 0x1p+0 |
| %4 = OpConstant %2 0x1p+1 |
| %5 = OpConstant %2 0x1.8p+1 |
| %6 = OpConstantComposite %1 %3 %4 %5 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"()"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_Vec3_With_Vec2_F32) { |
| auto* var = Decl(Var("x", ty.vec2<f32>(), vec2<f32>(1_f, 2_f))); |
| auto* cast = vec3<f32>("x", 3_f); |
| WrapInFunction(var, cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_TRUE(b.GenerateStatement(var)); |
| EXPECT_EQ(b.GenerateExpression(cast), 14u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 |
| %1 = OpTypeVector %2 2 |
| %3 = OpConstant %2 1 |
| %4 = OpConstant %2 2 |
| %5 = OpConstantComposite %1 %3 %4 |
| %7 = OpTypePointer Function %1 |
| %8 = OpConstantNull %1 |
| %9 = OpTypeVector %2 3 |
| %13 = OpConstant %2 3 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), |
| R"(OpStore %6 %5 |
| %10 = OpLoad %1 %6 |
| %11 = OpCompositeExtract %2 %10 0 |
| %12 = OpCompositeExtract %2 %10 1 |
| %14 = OpCompositeConstruct %9 %11 %12 %13 |
| )"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_Vec3_With_Vec2_F16) { |
| Enable(builtin::Extension::kF16); |
| |
| auto* var = Decl(Var("x", ty.vec2<f16>(), vec2<f16>(1_h, 2_h))); |
| auto* cast = vec3<f16>("x", 3_h); |
| WrapInFunction(var, cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_TRUE(b.GenerateStatement(var)); |
| EXPECT_EQ(b.GenerateExpression(cast), 14u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 16 |
| %1 = OpTypeVector %2 2 |
| %3 = OpConstant %2 0x1p+0 |
| %4 = OpConstant %2 0x1p+1 |
| %5 = OpConstantComposite %1 %3 %4 |
| %7 = OpTypePointer Function %1 |
| %8 = OpConstantNull %1 |
| %9 = OpTypeVector %2 3 |
| %13 = OpConstant %2 0x1.8p+1 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), |
| R"(OpStore %6 %5 |
| %10 = OpLoad %1 %6 |
| %11 = OpCompositeExtract %2 %10 0 |
| %12 = OpCompositeExtract %2 %10 1 |
| %14 = OpCompositeConstruct %9 %11 %12 %13 |
| )"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_Vec3_With_Vec2_F32_Const) { |
| auto* cast = vec3<f32>(vec2<f32>(1_f, 2_f), 3_f); |
| WrapInFunction(cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_EQ(b.GenerateExpression(cast), 6u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 |
| %1 = OpTypeVector %2 3 |
| %3 = OpConstant %2 1 |
| %4 = OpConstant %2 2 |
| %5 = OpConstant %2 3 |
| %6 = OpConstantComposite %1 %3 %4 %5 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"()"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_Vec3_With_Vec2_F16_Const) { |
| Enable(builtin::Extension::kF16); |
| |
| auto* cast = vec3<f16>(vec2<f16>(1_h, 2_h), 3_h); |
| WrapInFunction(cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_EQ(b.GenerateExpression(cast), 6u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 16 |
| %1 = OpTypeVector %2 3 |
| %3 = OpConstant %2 0x1p+0 |
| %4 = OpConstant %2 0x1p+1 |
| %5 = OpConstant %2 0x1.8p+1 |
| %6 = OpConstantComposite %1 %3 %4 %5 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"()"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_Vec3_F32_With_Vec3) { |
| auto* var = Decl(Var("x", ty.vec3<f32>(), vec3<f32>(1_f, 2_f, 3_f))); |
| auto* cast = vec3<f32>("x"); |
| WrapInFunction(var, cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_TRUE(b.GenerateStatement(var)); |
| EXPECT_EQ(b.GenerateExpression(cast), 11u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 |
| %1 = OpTypeVector %2 3 |
| %3 = OpConstant %2 1 |
| %4 = OpConstant %2 2 |
| %5 = OpConstant %2 3 |
| %6 = OpConstantComposite %1 %3 %4 %5 |
| %8 = OpTypePointer Function %1 |
| %9 = OpConstantNull %1 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), |
| R"(OpStore %7 %6 |
| %11 = OpLoad %1 %7 |
| )"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_Vec3_F16_With_Vec3) { |
| Enable(builtin::Extension::kF16); |
| |
| auto* var = Decl(Var("x", ty.vec3<f16>(), vec3<f16>(1_h, 2_h, 3_h))); |
| auto* cast = vec3<f16>("x"); |
| WrapInFunction(var, cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_TRUE(b.GenerateStatement(var)); |
| EXPECT_EQ(b.GenerateExpression(cast), 11u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 16 |
| %1 = OpTypeVector %2 3 |
| %3 = OpConstant %2 0x1p+0 |
| %4 = OpConstant %2 0x1p+1 |
| %5 = OpConstant %2 0x1.8p+1 |
| %6 = OpConstantComposite %1 %3 %4 %5 |
| %8 = OpTypePointer Function %1 |
| %9 = OpConstantNull %1 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), |
| R"(OpStore %7 %6 |
| %11 = OpLoad %1 %7 |
| )"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_Vec3_F32_With_Vec3_Const) { |
| auto* cast = vec3<f32>(vec3<f32>(1_f, 2_f, 3_f)); |
| WrapInFunction(cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_EQ(b.GenerateExpression(cast), 6u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 |
| %1 = OpTypeVector %2 3 |
| %3 = OpConstant %2 1 |
| %4 = OpConstant %2 2 |
| %5 = OpConstant %2 3 |
| %6 = OpConstantComposite %1 %3 %4 %5 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"()"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_Vec3_F16_With_Vec3_Const) { |
| Enable(builtin::Extension::kF16); |
| |
| auto* cast = vec3<f16>(vec3<f16>(1_h, 2_h, 3_h)); |
| WrapInFunction(cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_EQ(b.GenerateExpression(cast), 6u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 16 |
| %1 = OpTypeVector %2 3 |
| %3 = OpConstant %2 0x1p+0 |
| %4 = OpConstant %2 0x1p+1 |
| %5 = OpConstant %2 0x1.8p+1 |
| %6 = OpConstantComposite %1 %3 %4 %5 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"()"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_Vec4_With_Bool) { |
| auto* var = Decl(Var("x", ty.bool_(), Expr(true))); |
| auto* cast = vec4<bool>("x"); |
| WrapInFunction(var, cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_TRUE(b.GenerateStatement(var)); |
| EXPECT_EQ(b.GenerateExpression(cast), 8u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeBool |
| %2 = OpConstantTrue %1 |
| %4 = OpTypePointer Function %1 |
| %5 = OpConstantNull %1 |
| %6 = OpTypeVector %1 4 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), |
| R"(OpStore %3 %2 |
| %7 = OpLoad %1 %3 |
| %8 = OpCompositeConstruct %6 %7 %7 %7 %7 |
| )"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_Vec4_With_Bool_Const) { |
| auto* cast = vec4<bool>(true); |
| WrapInFunction(cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_EQ(b.GenerateExpression(cast), 4u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeBool |
| %1 = OpTypeVector %2 4 |
| %3 = OpConstantTrue %2 |
| %4 = OpConstantComposite %1 %3 %3 %3 %3 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"()"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_Vec4_With_F32) { |
| auto* var = Decl(Var("x", ty.f32(), Expr(2_f))); |
| auto* cast = vec4<f32>("x"); |
| WrapInFunction(var, cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_TRUE(b.GenerateStatement(var)); |
| EXPECT_EQ(b.GenerateExpression(cast), 8u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeFloat 32 |
| %2 = OpConstant %1 2 |
| %4 = OpTypePointer Function %1 |
| %5 = OpConstantNull %1 |
| %6 = OpTypeVector %1 4 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), |
| R"(OpStore %3 %2 |
| %7 = OpLoad %1 %3 |
| %8 = OpCompositeConstruct %6 %7 %7 %7 %7 |
| )"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_Vec4_With_F16) { |
| Enable(builtin::Extension::kF16); |
| |
| auto* var = Decl(Var("x", ty.f16(), Expr(2_h))); |
| auto* cast = vec4<f16>("x"); |
| WrapInFunction(var, cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_TRUE(b.GenerateStatement(var)); |
| EXPECT_EQ(b.GenerateExpression(cast), 8u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeFloat 16 |
| %2 = OpConstant %1 0x1p+1 |
| %4 = OpTypePointer Function %1 |
| %5 = OpConstantNull %1 |
| %6 = OpTypeVector %1 4 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), |
| R"(OpStore %3 %2 |
| %7 = OpLoad %1 %3 |
| %8 = OpCompositeConstruct %6 %7 %7 %7 %7 |
| )"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_Vec4_With_F32_Const) { |
| auto* cast = vec4<f32>(2_f); |
| WrapInFunction(cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_EQ(b.GenerateExpression(cast), 4u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 |
| %1 = OpTypeVector %2 4 |
| %3 = OpConstant %2 2 |
| %4 = OpConstantComposite %1 %3 %3 %3 %3 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"()"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_Vec4_With_F16_Const) { |
| Enable(builtin::Extension::kF16); |
| |
| auto* cast = vec4<f16>(2_h); |
| WrapInFunction(cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_EQ(b.GenerateExpression(cast), 4u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 16 |
| %1 = OpTypeVector %2 4 |
| %3 = OpConstant %2 0x1p+1 |
| %4 = OpConstantComposite %1 %3 %3 %3 %3 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"()"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_Vec4_With_F32_F32_F32_F32) { |
| auto* var = Decl(Var("x", ty.f32(), Expr(2_f))); |
| auto* cast = vec4<f32>("x", "x", "x", "x"); |
| WrapInFunction(var, cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_TRUE(b.GenerateStatement(var)); |
| EXPECT_EQ(b.GenerateExpression(cast), 11u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeFloat 32 |
| %2 = OpConstant %1 2 |
| %4 = OpTypePointer Function %1 |
| %5 = OpConstantNull %1 |
| %6 = OpTypeVector %1 4 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), |
| R"(OpStore %3 %2 |
| %7 = OpLoad %1 %3 |
| %8 = OpLoad %1 %3 |
| %9 = OpLoad %1 %3 |
| %10 = OpLoad %1 %3 |
| %11 = OpCompositeConstruct %6 %7 %8 %9 %10 |
| )"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_Vec4_With_F16_F16_F16_F16) { |
| Enable(builtin::Extension::kF16); |
| |
| auto* var = Decl(Var("x", ty.f16(), Expr(2_h))); |
| auto* cast = vec4<f16>("x", "x", "x", "x"); |
| WrapInFunction(var, cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_TRUE(b.GenerateStatement(var)); |
| EXPECT_EQ(b.GenerateExpression(cast), 11u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeFloat 16 |
| %2 = OpConstant %1 0x1p+1 |
| %4 = OpTypePointer Function %1 |
| %5 = OpConstantNull %1 |
| %6 = OpTypeVector %1 4 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), |
| R"(OpStore %3 %2 |
| %7 = OpLoad %1 %3 |
| %8 = OpLoad %1 %3 |
| %9 = OpLoad %1 %3 |
| %10 = OpLoad %1 %3 |
| %11 = OpCompositeConstruct %6 %7 %8 %9 %10 |
| )"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_Vec4_With_F32_F32_F32_F32_Const) { |
| auto* cast = vec4<f32>(1_f, 2_f, 3_f, 4_f); |
| WrapInFunction(cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_EQ(b.GenerateExpression(cast), 7u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 |
| %1 = OpTypeVector %2 4 |
| %3 = OpConstant %2 1 |
| %4 = OpConstant %2 2 |
| %5 = OpConstant %2 3 |
| %6 = OpConstant %2 4 |
| %7 = OpConstantComposite %1 %3 %4 %5 %6 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"()"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_Vec4_With_F16_F16_F16_F16_Const) { |
| Enable(builtin::Extension::kF16); |
| |
| auto* cast = vec4<f16>(1_h, 2_h, 3_h, 4_h); |
| WrapInFunction(cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_EQ(b.GenerateExpression(cast), 7u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 16 |
| %1 = OpTypeVector %2 4 |
| %3 = OpConstant %2 0x1p+0 |
| %4 = OpConstant %2 0x1p+1 |
| %5 = OpConstant %2 0x1.8p+1 |
| %6 = OpConstant %2 0x1p+2 |
| %7 = OpConstantComposite %1 %3 %4 %5 %6 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"()"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_Vec4_With_F32_F32_Vec2) { |
| auto* var = Decl(Var("x", ty.vec2<f32>(), vec2<f32>(1_f, 2_f))); |
| auto* cast = vec4<f32>(1_f, 2_f, "x"); |
| WrapInFunction(var, cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_TRUE(b.GenerateStatement(var)); |
| EXPECT_EQ(b.GenerateExpression(cast), 13u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 |
| %1 = OpTypeVector %2 2 |
| %3 = OpConstant %2 1 |
| %4 = OpConstant %2 2 |
| %5 = OpConstantComposite %1 %3 %4 |
| %7 = OpTypePointer Function %1 |
| %8 = OpConstantNull %1 |
| %9 = OpTypeVector %2 4 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), |
| R"(OpStore %6 %5 |
| %10 = OpLoad %1 %6 |
| %11 = OpCompositeExtract %2 %10 0 |
| %12 = OpCompositeExtract %2 %10 1 |
| %13 = OpCompositeConstruct %9 %3 %4 %11 %12 |
| )"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_Vec4_With_F16_F16_Vec2) { |
| Enable(builtin::Extension::kF16); |
| |
| auto* var = Decl(Var("x", ty.vec2<f16>(), vec2<f16>(1_h, 2_h))); |
| auto* cast = vec4<f16>(1_h, 2_h, "x"); |
| WrapInFunction(var, cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_TRUE(b.GenerateStatement(var)); |
| EXPECT_EQ(b.GenerateExpression(cast), 13u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 16 |
| %1 = OpTypeVector %2 2 |
| %3 = OpConstant %2 0x1p+0 |
| %4 = OpConstant %2 0x1p+1 |
| %5 = OpConstantComposite %1 %3 %4 |
| %7 = OpTypePointer Function %1 |
| %8 = OpConstantNull %1 |
| %9 = OpTypeVector %2 4 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), |
| R"(OpStore %6 %5 |
| %10 = OpLoad %1 %6 |
| %11 = OpCompositeExtract %2 %10 0 |
| %12 = OpCompositeExtract %2 %10 1 |
| %13 = OpCompositeConstruct %9 %3 %4 %11 %12 |
| )"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_Vec4_With_F32_F32_Vec2_Const) { |
| auto* cast = vec4<f32>(1_f, 2_f, vec2<f32>(3_f, 4_f)); |
| WrapInFunction(cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_EQ(b.GenerateExpression(cast), 7u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 |
| %1 = OpTypeVector %2 4 |
| %3 = OpConstant %2 1 |
| %4 = OpConstant %2 2 |
| %5 = OpConstant %2 3 |
| %6 = OpConstant %2 4 |
| %7 = OpConstantComposite %1 %3 %4 %5 %6 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"()"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_Vec4_With_F16_F16_Vec2_Const) { |
| Enable(builtin::Extension::kF16); |
| |
| auto* cast = vec4<f16>(1_h, 2_h, vec2<f16>(3_h, 4_h)); |
| WrapInFunction(cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_EQ(b.GenerateExpression(cast), 7u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 16 |
| %1 = OpTypeVector %2 4 |
| %3 = OpConstant %2 0x1p+0 |
| %4 = OpConstant %2 0x1p+1 |
| %5 = OpConstant %2 0x1.8p+1 |
| %6 = OpConstant %2 0x1p+2 |
| %7 = OpConstantComposite %1 %3 %4 %5 %6 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"()"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_Vec4_With_F32_Vec2_F32) { |
| auto* var = Decl(Var("x", ty.vec2<f32>(), vec2<f32>(2_f, 3_f))); |
| auto* cast = vec4<f32>(1_f, "x", 4_f); |
| WrapInFunction(var, cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_TRUE(b.GenerateStatement(var)); |
| EXPECT_EQ(b.GenerateExpression(cast), 15u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 |
| %1 = OpTypeVector %2 2 |
| %3 = OpConstant %2 2 |
| %4 = OpConstant %2 3 |
| %5 = OpConstantComposite %1 %3 %4 |
| %7 = OpTypePointer Function %1 |
| %8 = OpConstantNull %1 |
| %9 = OpTypeVector %2 4 |
| %10 = OpConstant %2 1 |
| %14 = OpConstant %2 4 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), |
| R"(OpStore %6 %5 |
| %11 = OpLoad %1 %6 |
| %12 = OpCompositeExtract %2 %11 0 |
| %13 = OpCompositeExtract %2 %11 1 |
| %15 = OpCompositeConstruct %9 %10 %12 %13 %14 |
| )"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_Vec4_With_F16_Vec2_F16) { |
| Enable(builtin::Extension::kF16); |
| |
| auto* var = Decl(Var("x", ty.vec2<f16>(), vec2<f16>(2_h, 3_h))); |
| auto* cast = vec4<f16>(1_h, "x", 4_h); |
| WrapInFunction(var, cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_TRUE(b.GenerateStatement(var)); |
| EXPECT_EQ(b.GenerateExpression(cast), 15u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 16 |
| %1 = OpTypeVector %2 2 |
| %3 = OpConstant %2 0x1p+1 |
| %4 = OpConstant %2 0x1.8p+1 |
| %5 = OpConstantComposite %1 %3 %4 |
| %7 = OpTypePointer Function %1 |
| %8 = OpConstantNull %1 |
| %9 = OpTypeVector %2 4 |
| %10 = OpConstant %2 0x1p+0 |
| %14 = OpConstant %2 0x1p+2 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), |
| R"(OpStore %6 %5 |
| %11 = OpLoad %1 %6 |
| %12 = OpCompositeExtract %2 %11 0 |
| %13 = OpCompositeExtract %2 %11 1 |
| %15 = OpCompositeConstruct %9 %10 %12 %13 %14 |
| )"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_Vec4_With_F32_Vec2_F32_Const) { |
| auto* cast = vec4<f32>(1_f, vec2<f32>(2_f, 3_f), 4_f); |
| WrapInFunction(cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_EQ(b.GenerateExpression(cast), 7u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 |
| %1 = OpTypeVector %2 4 |
| %3 = OpConstant %2 1 |
| %4 = OpConstant %2 2 |
| %5 = OpConstant %2 3 |
| %6 = OpConstant %2 4 |
| %7 = OpConstantComposite %1 %3 %4 %5 %6 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"()"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_Vec4_With_F16_Vec2_F16_Const) { |
| Enable(builtin::Extension::kF16); |
| |
| auto* cast = vec4<f16>(1_h, vec2<f16>(2_h, 3_h), 4_h); |
| WrapInFunction(cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_EQ(b.GenerateExpression(cast), 7u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 16 |
| %1 = OpTypeVector %2 4 |
| %3 = OpConstant %2 0x1p+0 |
| %4 = OpConstant %2 0x1p+1 |
| %5 = OpConstant %2 0x1.8p+1 |
| %6 = OpConstant %2 0x1p+2 |
| %7 = OpConstantComposite %1 %3 %4 %5 %6 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"()"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_Vec4_With_Vec2_F32_F32) { |
| auto* var = Decl(Var("x", ty.vec2<f32>(), vec2<f32>(1_f, 2_f))); |
| auto* cast = vec4<f32>("x", 3_f, 4_f); |
| WrapInFunction(var, cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_TRUE(b.GenerateStatement(var)); |
| EXPECT_EQ(b.GenerateExpression(cast), 15u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 |
| %1 = OpTypeVector %2 2 |
| %3 = OpConstant %2 1 |
| %4 = OpConstant %2 2 |
| %5 = OpConstantComposite %1 %3 %4 |
| %7 = OpTypePointer Function %1 |
| %8 = OpConstantNull %1 |
| %9 = OpTypeVector %2 4 |
| %13 = OpConstant %2 3 |
| %14 = OpConstant %2 4 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), |
| R"(OpStore %6 %5 |
| %10 = OpLoad %1 %6 |
| %11 = OpCompositeExtract %2 %10 0 |
| %12 = OpCompositeExtract %2 %10 1 |
| %15 = OpCompositeConstruct %9 %11 %12 %13 %14 |
| )"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_Vec4_With_Vec2_F16_F16) { |
| Enable(builtin::Extension::kF16); |
| |
| auto* var = Decl(Var("x", ty.vec2<f16>(), vec2<f16>(1_h, 2_h))); |
| auto* cast = vec4<f16>("x", 3_h, 4_h); |
| WrapInFunction(var, cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_TRUE(b.GenerateStatement(var)); |
| EXPECT_EQ(b.GenerateExpression(cast), 15u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 16 |
| %1 = OpTypeVector %2 2 |
| %3 = OpConstant %2 0x1p+0 |
| %4 = OpConstant %2 0x1p+1 |
| %5 = OpConstantComposite %1 %3 %4 |
| %7 = OpTypePointer Function %1 |
| %8 = OpConstantNull %1 |
| %9 = OpTypeVector %2 4 |
| %13 = OpConstant %2 0x1.8p+1 |
| %14 = OpConstant %2 0x1p+2 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), |
| R"(OpStore %6 %5 |
| %10 = OpLoad %1 %6 |
| %11 = OpCompositeExtract %2 %10 0 |
| %12 = OpCompositeExtract %2 %10 1 |
| %15 = OpCompositeConstruct %9 %11 %12 %13 %14 |
| )"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_Vec4_With_Vec2_F32_F32_Const) { |
| auto* cast = vec4<f32>(vec2<f32>(1_f, 2_f), 3_f, 4_f); |
| WrapInFunction(cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_EQ(b.GenerateExpression(cast), 7u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 |
| %1 = OpTypeVector %2 4 |
| %3 = OpConstant %2 1 |
| %4 = OpConstant %2 2 |
| %5 = OpConstant %2 3 |
| %6 = OpConstant %2 4 |
| %7 = OpConstantComposite %1 %3 %4 %5 %6 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"()"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_Vec4_With_Vec2_F16_F16_Const) { |
| Enable(builtin::Extension::kF16); |
| |
| auto* cast = vec4<f16>(vec2<f16>(1_h, 2_h), 3_h, 4_h); |
| WrapInFunction(cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_EQ(b.GenerateExpression(cast), 7u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 16 |
| %1 = OpTypeVector %2 4 |
| %3 = OpConstant %2 0x1p+0 |
| %4 = OpConstant %2 0x1p+1 |
| %5 = OpConstant %2 0x1.8p+1 |
| %6 = OpConstant %2 0x1p+2 |
| %7 = OpConstantComposite %1 %3 %4 %5 %6 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"()"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_Vec4_F32_With_Vec2_Vec2) { |
| auto* var = Decl(Var("x", ty.vec2<f32>(), vec2<f32>(1_f, 2_f))); |
| auto* cast = vec4<f32>("x", "x"); |
| WrapInFunction(var, cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_TRUE(b.GenerateStatement(var)); |
| EXPECT_EQ(b.GenerateExpression(cast), 16u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 |
| %1 = OpTypeVector %2 2 |
| %3 = OpConstant %2 1 |
| %4 = OpConstant %2 2 |
| %5 = OpConstantComposite %1 %3 %4 |
| %7 = OpTypePointer Function %1 |
| %8 = OpConstantNull %1 |
| %9 = OpTypeVector %2 4 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), |
| R"(OpStore %6 %5 |
| %10 = OpLoad %1 %6 |
| %11 = OpCompositeExtract %2 %10 0 |
| %12 = OpCompositeExtract %2 %10 1 |
| %13 = OpLoad %1 %6 |
| %14 = OpCompositeExtract %2 %13 0 |
| %15 = OpCompositeExtract %2 %13 1 |
| %16 = OpCompositeConstruct %9 %11 %12 %14 %15 |
| )"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_Vec4_F16_With_Vec2_Vec2) { |
| Enable(builtin::Extension::kF16); |
| |
| auto* var = Decl(Var("x", ty.vec2<f16>(), vec2<f16>(1_h, 2_h))); |
| auto* cast = vec4<f16>("x", "x"); |
| WrapInFunction(var, cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_TRUE(b.GenerateStatement(var)); |
| EXPECT_EQ(b.GenerateExpression(cast), 16u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 16 |
| %1 = OpTypeVector %2 2 |
| %3 = OpConstant %2 0x1p+0 |
| %4 = OpConstant %2 0x1p+1 |
| %5 = OpConstantComposite %1 %3 %4 |
| %7 = OpTypePointer Function %1 |
| %8 = OpConstantNull %1 |
| %9 = OpTypeVector %2 4 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), |
| R"(OpStore %6 %5 |
| %10 = OpLoad %1 %6 |
| %11 = OpCompositeExtract %2 %10 0 |
| %12 = OpCompositeExtract %2 %10 1 |
| %13 = OpLoad %1 %6 |
| %14 = OpCompositeExtract %2 %13 0 |
| %15 = OpCompositeExtract %2 %13 1 |
| %16 = OpCompositeConstruct %9 %11 %12 %14 %15 |
| )"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_Vec4_F32_With_Vec2_Vec2_Const) { |
| auto* cast = vec4<f32>(vec2<f32>(1_f, 2_f), vec2<f32>(1_f, 2_f)); |
| WrapInFunction(cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_EQ(b.GenerateExpression(cast), 5u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 |
| %1 = OpTypeVector %2 4 |
| %3 = OpConstant %2 1 |
| %4 = OpConstant %2 2 |
| %5 = OpConstantComposite %1 %3 %4 %3 %4 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"()"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_Vec4_F16_With_Vec2_Vec2_Const) { |
| Enable(builtin::Extension::kF16); |
| |
| auto* cast = vec4<f16>(vec2<f16>(1_h, 2_h), vec2<f16>(1_h, 2_h)); |
| WrapInFunction(cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_EQ(b.GenerateExpression(cast), 5u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 16 |
| %1 = OpTypeVector %2 4 |
| %3 = OpConstant %2 0x1p+0 |
| %4 = OpConstant %2 0x1p+1 |
| %5 = OpConstantComposite %1 %3 %4 %3 %4 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"()"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_Vec4_With_F32_Vec3) { |
| auto* var = Decl(Var("x", ty.vec3<f32>(), vec3<f32>(2_f, 2_f, 2_f))); |
| auto* cast = vec4<f32>(2_f, "x"); |
| WrapInFunction(var, cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_TRUE(b.GenerateStatement(var)); |
| EXPECT_EQ(b.GenerateExpression(cast), 13u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 |
| %1 = OpTypeVector %2 3 |
| %3 = OpConstant %2 2 |
| %4 = OpConstantComposite %1 %3 %3 %3 |
| %6 = OpTypePointer Function %1 |
| %7 = OpConstantNull %1 |
| %8 = OpTypeVector %2 4 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), |
| R"(OpStore %5 %4 |
| %9 = OpLoad %1 %5 |
| %10 = OpCompositeExtract %2 %9 0 |
| %11 = OpCompositeExtract %2 %9 1 |
| %12 = OpCompositeExtract %2 %9 2 |
| %13 = OpCompositeConstruct %8 %3 %10 %11 %12 |
| )"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_Vec4_With_F16_Vec3) { |
| Enable(builtin::Extension::kF16); |
| |
| auto* var = Decl(Var("x", ty.vec3<f16>(), vec3<f16>(2_h, 2_h, 2_h))); |
| auto* cast = vec4<f16>(2_h, "x"); |
| WrapInFunction(var, cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_TRUE(b.GenerateStatement(var)); |
| EXPECT_EQ(b.GenerateExpression(cast), 13u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 16 |
| %1 = OpTypeVector %2 3 |
| %3 = OpConstant %2 0x1p+1 |
| %4 = OpConstantComposite %1 %3 %3 %3 |
| %6 = OpTypePointer Function %1 |
| %7 = OpConstantNull %1 |
| %8 = OpTypeVector %2 4 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), |
| R"(OpStore %5 %4 |
| %9 = OpLoad %1 %5 |
| %10 = OpCompositeExtract %2 %9 0 |
| %11 = OpCompositeExtract %2 %9 1 |
| %12 = OpCompositeExtract %2 %9 2 |
| %13 = OpCompositeConstruct %8 %3 %10 %11 %12 |
| )"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_Vec4_With_F32_Vec3_Const) { |
| auto* cast = vec4<f32>(2_f, vec3<f32>(2_f, 2_f, 2_f)); |
| WrapInFunction(cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_EQ(b.GenerateExpression(cast), 4u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 |
| %1 = OpTypeVector %2 4 |
| %3 = OpConstant %2 2 |
| %4 = OpConstantComposite %1 %3 %3 %3 %3 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"()"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_Vec4_With_F16_Vec3_Const) { |
| Enable(builtin::Extension::kF16); |
| |
| auto* cast = vec4<f16>(2_h, vec3<f16>(2_h, 2_h, 2_h)); |
| WrapInFunction(cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_EQ(b.GenerateExpression(cast), 4u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 16 |
| %1 = OpTypeVector %2 4 |
| %3 = OpConstant %2 0x1p+1 |
| %4 = OpConstantComposite %1 %3 %3 %3 %3 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"()"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_Vec4_With_Vec3_F32) { |
| auto* var = Decl(Var("x", ty.vec3<f32>(), vec3<f32>(2_f, 2_f, 2_f))); |
| auto* cast = vec4<f32>("x", 2_f); |
| WrapInFunction(var, cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_TRUE(b.GenerateStatement(var)); |
| EXPECT_EQ(b.GenerateExpression(cast), 13u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 |
| %1 = OpTypeVector %2 3 |
| %3 = OpConstant %2 2 |
| %4 = OpConstantComposite %1 %3 %3 %3 |
| %6 = OpTypePointer Function %1 |
| %7 = OpConstantNull %1 |
| %8 = OpTypeVector %2 4 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), |
| R"(OpStore %5 %4 |
| %9 = OpLoad %1 %5 |
| %10 = OpCompositeExtract %2 %9 0 |
| %11 = OpCompositeExtract %2 %9 1 |
| %12 = OpCompositeExtract %2 %9 2 |
| %13 = OpCompositeConstruct %8 %10 %11 %12 %3 |
| )"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_Vec4_With_Vec3_F16) { |
| Enable(builtin::Extension::kF16); |
| |
| auto* var = Decl(Var("x", ty.vec3<f16>(), vec3<f16>(2_h, 2_h, 2_h))); |
| auto* cast = vec4<f16>("x", 2_h); |
| WrapInFunction(var, cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_TRUE(b.GenerateStatement(var)); |
| EXPECT_EQ(b.GenerateExpression(cast), 13u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 16 |
| %1 = OpTypeVector %2 3 |
| %3 = OpConstant %2 0x1p+1 |
| %4 = OpConstantComposite %1 %3 %3 %3 |
| %6 = OpTypePointer Function %1 |
| %7 = OpConstantNull %1 |
| %8 = OpTypeVector %2 4 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), |
| R"(OpStore %5 %4 |
| %9 = OpLoad %1 %5 |
| %10 = OpCompositeExtract %2 %9 0 |
| %11 = OpCompositeExtract %2 %9 1 |
| %12 = OpCompositeExtract %2 %9 2 |
| %13 = OpCompositeConstruct %8 %10 %11 %12 %3 |
| )"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_Vec4_With_Vec3_F32_Const) { |
| auto* cast = vec4<f32>(vec3<f32>(2_f, 2_f, 2_f), 2_f); |
| WrapInFunction(cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_EQ(b.GenerateExpression(cast), 4u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 |
| %1 = OpTypeVector %2 4 |
| %3 = OpConstant %2 2 |
| %4 = OpConstantComposite %1 %3 %3 %3 %3 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"()"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_Vec4_With_Vec3_F16_Const) { |
| Enable(builtin::Extension::kF16); |
| |
| auto* cast = vec4<f16>(vec3<f16>(2_h, 2_h, 2_h), 2_h); |
| WrapInFunction(cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_EQ(b.GenerateExpression(cast), 4u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 16 |
| %1 = OpTypeVector %2 4 |
| %3 = OpConstant %2 0x1p+1 |
| %4 = OpConstantComposite %1 %3 %3 %3 %3 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"()"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_Vec4_F32_With_Vec4) { |
| auto* value = vec4<f32>(2_f, 2_f, 2_f, 2_f); |
| auto* cast = vec4<f32>(value); |
| WrapInFunction(cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_EQ(b.GenerateExpression(cast), 4u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 |
| %1 = OpTypeVector %2 4 |
| %3 = OpConstant %2 2 |
| %4 = OpConstantComposite %1 %3 %3 %3 %3 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"()"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_Vec4_F16_With_Vec4) { |
| Enable(builtin::Extension::kF16); |
| |
| auto* value = vec4<f16>(2_h, 2_h, 2_h, 2_h); |
| auto* cast = vec4<f16>(value); |
| WrapInFunction(cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_EQ(b.GenerateExpression(cast), 4u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 16 |
| %1 = OpTypeVector %2 4 |
| %3 = OpConstant %2 0x1p+1 |
| %4 = OpConstantComposite %1 %3 %3 %3 %3 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"()"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_GlobalConst_F32_With_F32) { |
| auto* ctor = Call<f32>(2_f); |
| GlobalConst("g", ty.f32(), ctor); |
| WrapInFunction(Decl(Var("l", Expr("g")))); |
| |
| spirv::Builder& b = SanitizeAndBuild(); |
| ASSERT_TRUE(b.Build()); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeVoid |
| %1 = OpTypeFunction %2 |
| %5 = OpTypeFloat 32 |
| %6 = OpConstant %5 2 |
| %8 = OpTypePointer Function %5 |
| %9 = OpConstantNull %5 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"(OpStore %7 %6 |
| OpReturn |
| )"); |
| Validate(b); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_GlobalConst_F16_With_F16) { |
| Enable(builtin::Extension::kF16); |
| |
| auto* ctor = Call<f16>(2_h); |
| GlobalConst("g", ty.f16(), ctor); |
| WrapInFunction(Decl(Var("l", Expr("g")))); |
| |
| spirv::Builder& b = SanitizeAndBuild(); |
| ASSERT_TRUE(b.Build()); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeVoid |
| %1 = OpTypeFunction %2 |
| %5 = OpTypeFloat 16 |
| %6 = OpConstant %5 0x1p+1 |
| %8 = OpTypePointer Function %5 |
| %9 = OpConstantNull %5 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"(OpStore %7 %6 |
| OpReturn |
| )"); |
| Validate(b); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_GlobalVar_F32_With_F32) { |
| auto* ctor = Call<f32>(2_f); |
| GlobalVar("g", ty.f32(), builtin::AddressSpace::kPrivate, ctor); |
| |
| spirv::Builder& b = SanitizeAndBuild(); |
| ASSERT_TRUE(b.Build()); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeFloat 32 |
| %2 = OpConstant %1 2 |
| %4 = OpTypePointer Private %1 |
| %3 = OpVariable %4 Private %2 |
| %6 = OpTypeVoid |
| %5 = OpTypeFunction %6 |
| )"); |
| Validate(b); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_GlobalVar_F16_With_F16) { |
| Enable(builtin::Extension::kF16); |
| |
| auto* ctor = Call<f16>(2_h); |
| GlobalVar("g", ty.f16(), builtin::AddressSpace::kPrivate, ctor); |
| |
| spirv::Builder& b = SanitizeAndBuild(); |
| ASSERT_TRUE(b.Build()); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeFloat 16 |
| %2 = OpConstant %1 0x1p+1 |
| %4 = OpTypePointer Private %1 |
| %3 = OpVariable %4 Private %2 |
| %6 = OpTypeVoid |
| %5 = OpTypeFunction %6 |
| )"); |
| Validate(b); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_GlobalConst_U32_With_F32) { |
| auto* ctor = Call<u32>(1.5_f); |
| GlobalConst("g", ty.u32(), ctor); |
| WrapInFunction(Decl(Var("l", Expr("g")))); |
| |
| spirv::Builder& b = SanitizeAndBuild(); |
| ASSERT_TRUE(b.Build()); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeVoid |
| %1 = OpTypeFunction %2 |
| %5 = OpTypeInt 32 0 |
| %6 = OpConstant %5 1 |
| %8 = OpTypePointer Function %5 |
| %9 = OpConstantNull %5 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"(OpStore %7 %6 |
| OpReturn |
| )"); |
| Validate(b); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_GlobalConst_U32_With_F16) { |
| Enable(builtin::Extension::kF16); |
| |
| auto* ctor = Call<u32>(1.5_h); |
| GlobalConst("g", ty.u32(), ctor); |
| WrapInFunction(Decl(Var("l", Expr("g")))); |
| |
| spirv::Builder& b = SanitizeAndBuild(); |
| ASSERT_TRUE(b.Build()); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeVoid |
| %1 = OpTypeFunction %2 |
| %5 = OpTypeInt 32 0 |
| %6 = OpConstant %5 1 |
| %8 = OpTypePointer Function %5 |
| %9 = OpConstantNull %5 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"(OpStore %7 %6 |
| OpReturn |
| )"); |
| Validate(b); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_GlobalVar_U32_With_F32) { |
| auto* ctor = Call<u32>(1.5_f); |
| GlobalVar("g", ty.u32(), builtin::AddressSpace::kPrivate, ctor); |
| |
| spirv::Builder& b = SanitizeAndBuild(); |
| ASSERT_TRUE(b.Build()); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeInt 32 0 |
| %2 = OpConstant %1 1 |
| %4 = OpTypePointer Private %1 |
| %3 = OpVariable %4 Private %2 |
| %6 = OpTypeVoid |
| %5 = OpTypeFunction %6 |
| )"); |
| Validate(b); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_GlobalVar_U32_With_F16) { |
| Enable(builtin::Extension::kF16); |
| |
| auto* ctor = Call<u32>(1.5_h); |
| GlobalVar("g", ty.u32(), builtin::AddressSpace::kPrivate, ctor); |
| |
| spirv::Builder& b = SanitizeAndBuild(); |
| ASSERT_TRUE(b.Build()); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%1 = OpTypeInt 32 0 |
| %2 = OpConstant %1 1 |
| %4 = OpTypePointer Private %1 |
| %3 = OpVariable %4 Private %2 |
| %6 = OpTypeVoid |
| %5 = OpTypeFunction %6 |
| )"); |
| Validate(b); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_GlobalConst_Vec2_With_F32) { |
| auto* cast = vec2<f32>(2_f); |
| GlobalConst("g", ty.vec2<f32>(), cast); |
| WrapInFunction(Decl(Var("l", Expr("g")))); |
| |
| spirv::Builder& b = SanitizeAndBuild(); |
| ASSERT_TRUE(b.Build()); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeVoid |
| %1 = OpTypeFunction %2 |
| %6 = OpTypeFloat 32 |
| %5 = OpTypeVector %6 2 |
| %7 = OpConstant %6 2 |
| %8 = OpConstantComposite %5 %7 %7 |
| %10 = OpTypePointer Function %5 |
| %11 = OpConstantNull %5 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"(OpStore %9 %8 |
| OpReturn |
| )"); |
| Validate(b); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_GlobalConst_Vec2_With_F16) { |
| Enable(builtin::Extension::kF16); |
| |
| auto* cast = vec2<f16>(2_h); |
| GlobalConst("g", ty.vec2<f16>(), cast); |
| WrapInFunction(Decl(Var("l", Expr("g")))); |
| |
| spirv::Builder& b = SanitizeAndBuild(); |
| ASSERT_TRUE(b.Build()); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeVoid |
| %1 = OpTypeFunction %2 |
| %6 = OpTypeFloat 16 |
| %5 = OpTypeVector %6 2 |
| %7 = OpConstant %6 0x1p+1 |
| %8 = OpConstantComposite %5 %7 %7 |
| %10 = OpTypePointer Function %5 |
| %11 = OpConstantNull %5 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"(OpStore %9 %8 |
| OpReturn |
| )"); |
| Validate(b); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_GlobalVar_Vec2_With_F32) { |
| auto* cast = vec2<f32>(2_f); |
| auto* g = GlobalVar("g", ty.vec2<f32>(), builtin::AddressSpace::kPrivate, cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_EQ(b.GenerateConstructorExpression(g, cast), 4u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 |
| %1 = OpTypeVector %2 2 |
| %3 = OpConstant %2 2 |
| %4 = OpConstantComposite %1 %3 %3 |
| )"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_GlobalVar_Vec2_With_F16) { |
| Enable(builtin::Extension::kF16); |
| |
| auto* cast = vec2<f16>(2_h); |
| auto* g = GlobalVar("g", ty.vec2<f16>(), builtin::AddressSpace::kPrivate, cast); |
| |
| spirv::Builder& b = Build(); |
| |
| b.push_function(Function{}); |
| EXPECT_EQ(b.GenerateConstructorExpression(g, cast), 4u); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 16 |
| %1 = OpTypeVector %2 2 |
| %3 = OpConstant %2 0x1p+1 |
| %4 = OpConstantComposite %1 %3 %3 |
| )"); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_GlobalConst_Vec2_F32_With_Vec2) { |
| auto* cast = vec2<f32>(vec2<f32>(2_f, 2_f)); |
| GlobalConst("g", ty.vec2<f32>(), cast); |
| WrapInFunction(Decl(Var("l", Expr("g")))); |
| |
| spirv::Builder& b = SanitizeAndBuild(); |
| ASSERT_TRUE(b.Build()); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeVoid |
| %1 = OpTypeFunction %2 |
| %6 = OpTypeFloat 32 |
| %5 = OpTypeVector %6 2 |
| %7 = OpConstant %6 2 |
| %8 = OpConstantComposite %5 %7 %7 |
| %10 = OpTypePointer Function %5 |
| %11 = OpConstantNull %5 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"(OpStore %9 %8 |
| OpReturn |
| )"); |
| Validate(b); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_GlobalConst_Vec2_F16_With_Vec2) { |
| Enable(builtin::Extension::kF16); |
| |
| auto* cast = vec2<f16>(vec2<f16>(2_h, 2_h)); |
| GlobalConst("g", ty.vec2<f16>(), cast); |
| WrapInFunction(Decl(Var("l", Expr("g")))); |
| |
| spirv::Builder& b = SanitizeAndBuild(); |
| ASSERT_TRUE(b.Build()); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeVoid |
| %1 = OpTypeFunction %2 |
| %6 = OpTypeFloat 16 |
| %5 = OpTypeVector %6 2 |
| %7 = OpConstant %6 0x1p+1 |
| %8 = OpConstantComposite %5 %7 %7 |
| %10 = OpTypePointer Function %5 |
| %11 = OpConstantNull %5 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"(OpStore %9 %8 |
| OpReturn |
| )"); |
| Validate(b); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_GlobalVar_Vec2_F32_With_Vec2) { |
| auto* cast = vec2<f32>(vec2<f32>(2_f, 2_f)); |
| GlobalVar("a", ty.vec2<f32>(), builtin::AddressSpace::kPrivate, cast); |
| |
| spirv::Builder& b = SanitizeAndBuild(); |
| ASSERT_TRUE(b.Build()); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 |
| %1 = OpTypeVector %2 2 |
| %3 = OpConstant %2 2 |
| %4 = OpConstantComposite %1 %3 %3 |
| %6 = OpTypePointer Private %1 |
| %5 = OpVariable %6 Private %4 |
| %8 = OpTypeVoid |
| %7 = OpTypeFunction %8 |
| )"); |
| |
| Validate(b); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_GlobalVar_Vec2_F16_With_Vec2) { |
| Enable(builtin::Extension::kF16); |
| |
| auto* cast = vec2<f16>(vec2<f16>(2_h, 2_h)); |
| GlobalVar("a", ty.vec2<f16>(), builtin::AddressSpace::kPrivate, cast); |
| |
| spirv::Builder& b = SanitizeAndBuild(); |
| ASSERT_TRUE(b.Build()); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 16 |
| %1 = OpTypeVector %2 2 |
| %3 = OpConstant %2 0x1p+1 |
| %4 = OpConstantComposite %1 %3 %3 |
| %6 = OpTypePointer Private %1 |
| %5 = OpVariable %6 Private %4 |
| %8 = OpTypeVoid |
| %7 = OpTypeFunction %8 |
| )"); |
| |
| Validate(b); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_GlobalConst_Vec3_F32_With_Vec3) { |
| auto* cast = vec3<f32>(vec3<f32>(2_f, 2_f, 2_f)); |
| GlobalConst("g", ty.vec3<f32>(), cast); |
| WrapInFunction(Decl(Var("l", Expr("g")))); |
| |
| spirv::Builder& b = SanitizeAndBuild(); |
| ASSERT_TRUE(b.Build()); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeVoid |
| %1 = OpTypeFunction %2 |
| %6 = OpTypeFloat 32 |
| %5 = OpTypeVector %6 3 |
| %7 = OpConstant %6 2 |
| %8 = OpConstantComposite %5 %7 %7 %7 |
| %10 = OpTypePointer Function %5 |
| %11 = OpConstantNull %5 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"(OpStore %9 %8 |
| OpReturn |
| )"); |
| Validate(b); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_GlobalConst_Vec3_F16_With_Vec3) { |
| Enable(builtin::Extension::kF16); |
| |
| auto* cast = vec3<f16>(vec3<f16>(2_h, 2_h, 2_h)); |
| GlobalConst("g", ty.vec3<f16>(), cast); |
| WrapInFunction(Decl(Var("l", Expr("g")))); |
| |
| spirv::Builder& b = SanitizeAndBuild(); |
| ASSERT_TRUE(b.Build()); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeVoid |
| %1 = OpTypeFunction %2 |
| %6 = OpTypeFloat 16 |
| %5 = OpTypeVector %6 3 |
| %7 = OpConstant %6 0x1p+1 |
| %8 = OpConstantComposite %5 %7 %7 %7 |
| %10 = OpTypePointer Function %5 |
| %11 = OpConstantNull %5 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"(OpStore %9 %8 |
| OpReturn |
| )"); |
| Validate(b); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_GlobalVar_Vec3_F32_With_Vec3) { |
| auto* cast = vec3<f32>(vec3<f32>(2_f, 2_f, 2_f)); |
| GlobalVar("a", ty.vec3<f32>(), builtin::AddressSpace::kPrivate, cast); |
| |
| spirv::Builder& b = SanitizeAndBuild(); |
| ASSERT_TRUE(b.Build()); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 |
| %1 = OpTypeVector %2 3 |
| %3 = OpConstant %2 2 |
| %4 = OpConstantComposite %1 %3 %3 %3 |
| %6 = OpTypePointer Private %1 |
| %5 = OpVariable %6 Private %4 |
| %8 = OpTypeVoid |
| %7 = OpTypeFunction %8 |
| )"); |
| |
| Validate(b); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_GlobalVar_Vec3_F16_With_Vec3) { |
| Enable(builtin::Extension::kF16); |
| |
| auto* cast = vec3<f16>(vec3<f16>(2_h, 2_h, 2_h)); |
| GlobalVar("a", ty.vec3<f16>(), builtin::AddressSpace::kPrivate, cast); |
| |
| spirv::Builder& b = SanitizeAndBuild(); |
| ASSERT_TRUE(b.Build()); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 16 |
| %1 = OpTypeVector %2 3 |
| %3 = OpConstant %2 0x1p+1 |
| %4 = OpConstantComposite %1 %3 %3 %3 |
| %6 = OpTypePointer Private %1 |
| %5 = OpVariable %6 Private %4 |
| %8 = OpTypeVoid |
| %7 = OpTypeFunction %8 |
| )"); |
| |
| Validate(b); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_GlobalConst_Vec4_F32_With_Vec4) { |
| auto* cast = vec4<f32>(vec4<f32>(2_f, 2_f, 2_f, 2_f)); |
| GlobalConst("g", ty.vec4<f32>(), cast); |
| WrapInFunction(Decl(Var("l", Expr("g")))); |
| |
| spirv::Builder& b = SanitizeAndBuild(); |
| ASSERT_TRUE(b.Build()); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeVoid |
| %1 = OpTypeFunction %2 |
| %6 = OpTypeFloat 32 |
| %5 = OpTypeVector %6 4 |
| %7 = OpConstant %6 2 |
| %8 = OpConstantComposite %5 %7 %7 %7 %7 |
| %10 = OpTypePointer Function %5 |
| %11 = OpConstantNull %5 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"(OpStore %9 %8 |
| OpReturn |
| )"); |
| Validate(b); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_GlobalConst_Vec4_F16_With_Vec4) { |
| Enable(builtin::Extension::kF16); |
| |
| auto* cast = vec4<f16>(vec4<f16>(2_h, 2_h, 2_h, 2_h)); |
| GlobalConst("g", ty.vec4<f16>(), cast); |
| WrapInFunction(Decl(Var("l", Expr("g")))); |
| |
| spirv::Builder& b = SanitizeAndBuild(); |
| ASSERT_TRUE(b.Build()); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeVoid |
| %1 = OpTypeFunction %2 |
| %6 = OpTypeFloat 16 |
| %5 = OpTypeVector %6 4 |
| %7 = OpConstant %6 0x1p+1 |
| %8 = OpConstantComposite %5 %7 %7 %7 %7 |
| %10 = OpTypePointer Function %5 |
| %11 = OpConstantNull %5 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"(OpStore %9 %8 |
| OpReturn |
| )"); |
| Validate(b); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_GlobalVar_Vec4_F32_With_Vec4) { |
| auto* cast = vec4<f32>(vec4<f32>(2_f, 2_f, 2_f, 2_f)); |
| GlobalVar("a", ty.vec4<f32>(), builtin::AddressSpace::kPrivate, cast); |
| |
| spirv::Builder& b = SanitizeAndBuild(); |
| ASSERT_TRUE(b.Build()); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 32 |
| %1 = OpTypeVector %2 4 |
| %3 = OpConstant %2 2 |
| %4 = OpConstantComposite %1 %3 %3 %3 %3 |
| %6 = OpTypePointer Private %1 |
| %5 = OpVariable %6 Private %4 |
| %8 = OpTypeVoid |
| %7 = OpTypeFunction %8 |
| )"); |
| |
| Validate(b); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_GlobalVar_Vec4_F16_With_Vec4) { |
| Enable(builtin::Extension::kF16); |
| |
| auto* cast = vec4<f16>(vec4<f16>(2_h, 2_h, 2_h, 2_h)); |
| GlobalVar("a", ty.vec4<f16>(), builtin::AddressSpace::kPrivate, cast); |
| |
| spirv::Builder& b = SanitizeAndBuild(); |
| ASSERT_TRUE(b.Build()); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeFloat 16 |
| %1 = OpTypeVector %2 4 |
| %3 = OpConstant %2 0x1p+1 |
| %4 = OpConstantComposite %1 %3 %3 %3 %3 |
| %6 = OpTypePointer Private %1 |
| %5 = OpVariable %6 Private %4 |
| %8 = OpTypeVoid |
| %7 = OpTypeFunction %8 |
| )"); |
| |
| Validate(b); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_GlobalConst_Vec3_With_F32) { |
| auto* cast = vec3<f32>(2_f); |
| GlobalConst("g", ty.vec3<f32>(), cast); |
| WrapInFunction(Decl(Var("l", Expr("g")))); |
| |
| spirv::Builder& b = SanitizeAndBuild(); |
| ASSERT_TRUE(b.Build()); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeVoid |
| %1 = OpTypeFunction %2 |
| %6 = OpTypeFloat 32 |
| %5 = OpTypeVector %6 3 |
| %7 = OpConstant %6 2 |
| %8 = OpConstantComposite %5 %7 %7 %7 |
| %10 = OpTypePointer Function %5 |
| %11 = OpConstantNull %5 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"(OpStore %9 %8 |
| OpReturn |
| )"); |
| Validate(b); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_GlobalConst_Vec3_With_F16) { |
| Enable(builtin::Extension::kF16); |
| |
| auto* cast = vec3<f16>(2_h); |
| GlobalConst("g", ty.vec3<f16>(), cast); |
| WrapInFunction(Decl(Var("l", Expr("g")))); |
| |
| spirv::Builder& b = SanitizeAndBuild(); |
| ASSERT_TRUE(b.Build()); |
| |
| EXPECT_EQ(DumpInstructions(b.types()), R"(%2 = OpTypeVoid |
| %1 = OpTypeFunction %2 |
| %6 = OpTypeFloat 16 |
| %5 = OpTypeVector %6 3 |
| %7 = OpConstant %6 0x1p+1 |
| %8 = OpConstantComposite %5 %7 %7 %7 |
| %10 = OpTypePointer Function %5 |
| %11 = OpConstantNull %5 |
| )"); |
| EXPECT_EQ(DumpInstructions(b.functions()[0].instructions()), R"(OpStore %9 %8 |
| OpReturn |
| )"); |
| Validate(b); |
| } |
| |
| TEST_F(SpvBuilderConstructorTest, Type_GlobalVar_Vec3_With_F32) { |
| auto* cast = vec3<f32>(2_f); |
| auto* g = GlobalVar("g", ty.vec3<f32>(), builtin::AddressSpace::kPrivate, cast); |
| |
| spirv::Builder& b
|