src/tint/lang/spirv/reader/lower/builtins_test.cc

// Copyright 2024 The Dawn & Tint Authors
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// 1. Redistributions of source code must retain the above copyright notice, this
//    list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright notice,
//    this list of conditions and the following disclaimer in the documentation
//    and/or other materials provided with the distribution.
//
// 3. Neither the name of the copyright holder nor the names of its
//    contributors may be used to endorse or promote products derived from
//    this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

#include "src/tint/lang/spirv/reader/lower/builtins.h"

#include <string>

#include "src/tint/lang/core/ir/transform/helper_test.h"
#include "src/tint/lang/spirv/ir/builtin_call.h"

namespace tint::spirv::reader::lower {
namespace {

using namespace tint::core::fluent_types;     // NOLINT
using namespace tint::core::number_suffixes;  // NOLINT

struct SpirvReader_BuiltinsTest : public core::ir::transform::TransformTest {
  protected:
    void SetUp() override { mod.properties.Add(core::ir::Property::kAllow16BitFloats); }
};

TEST_F(SpirvReader_BuiltinsTest, Normalize_Scalar) {
    auto* a = b.FunctionParam("a", ty.f32());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a});

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.f32(), spirv::BuiltinFn::kNormalize, a);
        b.Return(ep);
    });

    auto* src = R"(
%foo = func(%a:f32):void {
  $B1: {
    %3:f32 = spirv.normalize %a
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto* expect = R"(
%foo = func(%a:f32):void {
  $B1: {
    %3:f32 = sign %a
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, Normalize_Vector) {
    auto* a = b.FunctionParam("a", ty.vec2f());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a});

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.vec2f(), spirv::BuiltinFn::kNormalize, a);
        b.Return(ep);
    });

    auto* src = R"(
%foo = func(%a:vec2<f32>):void {
  $B1: {
    %3:vec2<f32> = spirv.normalize %a
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto* expect = R"(
%foo = func(%a:vec2<f32>):void {
  $B1: {
    %3:vec2<f32> = normalize %a
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, Inverse_Mat2x2f) {
    auto* a = b.FunctionParam("a", ty.mat2x2<f32>());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a});

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.mat2x2<f32>(), spirv::BuiltinFn::kInverse, a);
        b.Return(ep);
    });

    auto* src = R"(
%foo = func(%a:mat2x2<f32>):void {
  $B1: {
    %3:mat2x2<f32> = spirv.inverse %a
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto* expect = R"(
%foo = func(%a:mat2x2<f32>):void {
  $B1: {
    %3:f32 = determinant %a
    %4:f32 = div 1.0f, %3
    %5:f32 = negation %4
    %6:f32 = access %a, 0u, 0u
    %7:f32 = access %a, 0u, 1u
    %8:f32 = access %a, 1u, 0u
    %9:f32 = access %a, 1u, 1u
    %10:f32 = mul %4, %9
    %11:f32 = mul %5, %7
    %12:f32 = mul %5, %8
    %13:f32 = mul %4, %6
    %14:vec2<f32> = construct %10, %11
    %15:vec2<f32> = construct %12, %13
    %16:mat2x2<f32> = construct %14, %15
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, Inverse_Mat2x2h) {
    auto* a = b.FunctionParam("a", ty.mat2x2<f16>());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a});

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.mat2x2<f16>(), spirv::BuiltinFn::kInverse, a);
        b.Return(ep);
    });

    auto* src = R"(
%foo = func(%a:mat2x2<f16>):void {
  $B1: {
    %3:mat2x2<f16> = spirv.inverse %a
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto* expect = R"(
%foo = func(%a:mat2x2<f16>):void {
  $B1: {
    %3:f16 = determinant %a
    %4:f16 = div 1.0h, %3
    %5:f16 = negation %4
    %6:f16 = access %a, 0u, 0u
    %7:f16 = access %a, 0u, 1u
    %8:f16 = access %a, 1u, 0u
    %9:f16 = access %a, 1u, 1u
    %10:f16 = mul %4, %9
    %11:f16 = mul %5, %7
    %12:f16 = mul %5, %8
    %13:f16 = mul %4, %6
    %14:vec2<f16> = construct %10, %11
    %15:vec2<f16> = construct %12, %13
    %16:mat2x2<f16> = construct %14, %15
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, Inverse_Mat3x3f) {
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* m = b.Let("m", b.Construct(ty.mat3x3<f32>(), b.Splat(ty.vec3f(), 10_f),
                                         b.Splat(ty.vec3f(), 20_f), b.Splat(ty.vec3f(), 30_f)));
        b.Call<spirv::ir::BuiltinCall>(ty.mat3x3<f32>(), spirv::BuiltinFn::kInverse, m);
        b.Return(ep);
    });

    auto* src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %m:mat3x3<f32> = let mat3x3<f32>(vec3<f32>(10.0f), vec3<f32>(20.0f), vec3<f32>(30.0f))
    %3:mat3x3<f32> = spirv.inverse %m
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto* expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %m:mat3x3<f32> = let mat3x3<f32>(vec3<f32>(10.0f), vec3<f32>(20.0f), vec3<f32>(30.0f))
    %3:f32 = determinant %m
    %4:f32 = div 1.0f, %3
    %5:f32 = access %m, 0u, 0u
    %6:f32 = access %m, 0u, 1u
    %7:f32 = access %m, 0u, 2u
    %8:f32 = access %m, 1u, 0u
    %9:f32 = access %m, 1u, 1u
    %10:f32 = access %m, 1u, 2u
    %11:f32 = access %m, 2u, 0u
    %12:f32 = access %m, 2u, 1u
    %13:f32 = access %m, 2u, 2u
    %14:f32 = mul %9, %13
    %15:f32 = mul %10, %12
    %16:f32 = sub %14, %15
    %17:f32 = mul %7, %12
    %18:f32 = mul %6, %13
    %19:f32 = sub %17, %18
    %20:f32 = mul %6, %10
    %21:f32 = mul %7, %9
    %22:f32 = sub %20, %21
    %23:f32 = mul %10, %11
    %24:f32 = mul %8, %13
    %25:f32 = sub %23, %24
    %26:f32 = mul %5, %13
    %27:f32 = mul %7, %11
    %28:f32 = sub %26, %27
    %29:f32 = mul %7, %8
    %30:f32 = mul %5, %10
    %31:f32 = sub %29, %30
    %32:f32 = mul %8, %12
    %33:f32 = mul %9, %11
    %34:f32 = sub %32, %33
    %35:f32 = mul %6, %11
    %36:f32 = mul %5, %12
    %37:f32 = sub %35, %36
    %38:f32 = mul %5, %9
    %39:f32 = mul %6, %8
    %40:f32 = sub %38, %39
    %41:vec3<f32> = construct %16, %19, %22
    %42:vec3<f32> = construct %25, %28, %31
    %43:vec3<f32> = construct %34, %37, %40
    %44:mat3x3<f32> = construct %41, %42, %43
    %45:mat3x3<f32> = mul %4, %44
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, Inverse_Mat3x3h) {
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* m = b.Let("m", b.Construct(ty.mat3x3<f16>(), b.Splat(ty.vec3h(), 10_h),
                                         b.Splat(ty.vec3h(), 20_h), b.Splat(ty.vec3h(), 30_h)));
        b.Call<spirv::ir::BuiltinCall>(ty.mat3x3<f16>(), spirv::BuiltinFn::kInverse, m);
        b.Return(ep);
    });

    auto* src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %m:mat3x3<f16> = let mat3x3<f16>(vec3<f16>(10.0h), vec3<f16>(20.0h), vec3<f16>(30.0h))
    %3:mat3x3<f16> = spirv.inverse %m
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto* expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %m:mat3x3<f16> = let mat3x3<f16>(vec3<f16>(10.0h), vec3<f16>(20.0h), vec3<f16>(30.0h))
    %3:f16 = determinant %m
    %4:f16 = div 1.0h, %3
    %5:f16 = access %m, 0u, 0u
    %6:f16 = access %m, 0u, 1u
    %7:f16 = access %m, 0u, 2u
    %8:f16 = access %m, 1u, 0u
    %9:f16 = access %m, 1u, 1u
    %10:f16 = access %m, 1u, 2u
    %11:f16 = access %m, 2u, 0u
    %12:f16 = access %m, 2u, 1u
    %13:f16 = access %m, 2u, 2u
    %14:f16 = mul %9, %13
    %15:f16 = mul %10, %12
    %16:f16 = sub %14, %15
    %17:f16 = mul %7, %12
    %18:f16 = mul %6, %13
    %19:f16 = sub %17, %18
    %20:f16 = mul %6, %10
    %21:f16 = mul %7, %9
    %22:f16 = sub %20, %21
    %23:f16 = mul %10, %11
    %24:f16 = mul %8, %13
    %25:f16 = sub %23, %24
    %26:f16 = mul %5, %13
    %27:f16 = mul %7, %11
    %28:f16 = sub %26, %27
    %29:f16 = mul %7, %8
    %30:f16 = mul %5, %10
    %31:f16 = sub %29, %30
    %32:f16 = mul %8, %12
    %33:f16 = mul %9, %11
    %34:f16 = sub %32, %33
    %35:f16 = mul %6, %11
    %36:f16 = mul %5, %12
    %37:f16 = sub %35, %36
    %38:f16 = mul %5, %9
    %39:f16 = mul %6, %8
    %40:f16 = sub %38, %39
    %41:vec3<f16> = construct %16, %19, %22
    %42:vec3<f16> = construct %25, %28, %31
    %43:vec3<f16> = construct %34, %37, %40
    %44:mat3x3<f16> = construct %41, %42, %43
    %45:mat3x3<f16> = mul %4, %44
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, Inverse_Mat4x4f) {
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* m = b.Let(
            "m", b.Construct(ty.mat4x4<f32>(), b.Splat(ty.vec4f(), 10_f), b.Splat(ty.vec4f(), 20_f),
                             b.Splat(ty.vec4f(), 30_f), b.Splat(ty.vec4f(), 40_f)));
        b.Call<spirv::ir::BuiltinCall>(ty.mat4x4<f32>(), spirv::BuiltinFn::kInverse, m);
        b.Return(ep);
    });

    auto* src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %m:mat4x4<f32> = let mat4x4<f32>(vec4<f32>(10.0f), vec4<f32>(20.0f), vec4<f32>(30.0f), vec4<f32>(40.0f))
    %3:mat4x4<f32> = spirv.inverse %m
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto* expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %m:mat4x4<f32> = let mat4x4<f32>(vec4<f32>(10.0f), vec4<f32>(20.0f), vec4<f32>(30.0f), vec4<f32>(40.0f))
    %3:f32 = determinant %m
    %4:f32 = div 1.0f, %3
    %5:f32 = access %m, 0u, 0u
    %6:f32 = access %m, 0u, 1u
    %7:f32 = access %m, 0u, 2u
    %8:f32 = access %m, 0u, 3u
    %9:f32 = access %m, 1u, 0u
    %10:f32 = access %m, 1u, 1u
    %11:f32 = access %m, 1u, 2u
    %12:f32 = access %m, 1u, 3u
    %13:f32 = access %m, 2u, 0u
    %14:f32 = access %m, 2u, 1u
    %15:f32 = access %m, 2u, 2u
    %16:f32 = access %m, 2u, 3u
    %17:f32 = access %m, 3u, 0u
    %18:f32 = access %m, 3u, 1u
    %19:f32 = access %m, 3u, 2u
    %20:f32 = access %m, 3u, 3u
    %21:f32 = mul %15, %20
    %22:f32 = mul %16, %19
    %23:f32 = sub %21, %22
    %24:f32 = mul %14, %20
    %25:f32 = mul %16, %18
    %26:f32 = sub %24, %25
    %27:f32 = mul %14, %19
    %28:f32 = mul %15, %18
    %29:f32 = sub %27, %28
    %30:f32 = mul %11, %20
    %31:f32 = mul %12, %19
    %32:f32 = sub %30, %31
    %33:f32 = mul %10, %20
    %34:f32 = mul %12, %18
    %35:f32 = sub %33, %34
    %36:f32 = mul %10, %19
    %37:f32 = mul %11, %18
    %38:f32 = sub %36, %37
    %39:f32 = mul %11, %16
    %40:f32 = mul %12, %15
    %41:f32 = sub %39, %40
    %42:f32 = mul %10, %16
    %43:f32 = mul %12, %14
    %44:f32 = sub %42, %43
    %45:f32 = mul %10, %15
    %46:f32 = mul %11, %14
    %47:f32 = sub %45, %46
    %48:f32 = mul %13, %20
    %49:f32 = mul %16, %17
    %50:f32 = sub %48, %49
    %51:f32 = mul %13, %19
    %52:f32 = mul %15, %17
    %53:f32 = sub %51, %52
    %54:f32 = mul %9, %20
    %55:f32 = mul %12, %17
    %56:f32 = sub %54, %55
    %57:f32 = mul %9, %19
    %58:f32 = mul %11, %17
    %59:f32 = sub %57, %58
    %60:f32 = mul %9, %16
    %61:f32 = mul %12, %13
    %62:f32 = sub %60, %61
    %63:f32 = mul %9, %15
    %64:f32 = mul %11, %13
    %65:f32 = sub %63, %64
    %66:f32 = mul %13, %18
    %67:f32 = mul %14, %17
    %68:f32 = sub %66, %67
    %69:f32 = mul %9, %18
    %70:f32 = mul %10, %17
    %71:f32 = sub %69, %70
    %72:f32 = mul %9, %14
    %73:f32 = mul %10, %13
    %74:f32 = sub %72, %73
    %75:f32 = negation %6
    %76:f32 = mul %10, %23
    %77:f32 = mul %11, %26
    %78:f32 = mul %12, %29
    %79:f32 = sub %76, %77
    %80:f32 = add %79, %78
    %81:f32 = mul %75, %23
    %82:f32 = mul %7, %26
    %83:f32 = mul %8, %29
    %84:f32 = add %81, %82
    %85:f32 = sub %84, %83
    %86:f32 = mul %6, %32
    %87:f32 = mul %7, %35
    %88:f32 = mul %8, %38
    %89:f32 = sub %86, %87
    %90:f32 = add %89, %88
    %91:f32 = mul %75, %41
    %92:f32 = mul %7, %44
    %93:f32 = mul %8, %47
    %94:f32 = add %91, %92
    %95:f32 = sub %94, %93
    %96:f32 = negation %9
    %97:f32 = negation %5
    %98:f32 = mul %96, %23
    %99:f32 = mul %11, %50
    %100:f32 = mul %12, %53
    %101:f32 = add %98, %99
    %102:f32 = sub %101, %100
    %103:f32 = mul %5, %23
    %104:f32 = mul %7, %50
    %105:f32 = mul %8, %53
    %106:f32 = sub %103, %104
    %107:f32 = add %106, %105
    %108:f32 = mul %97, %32
    %109:f32 = mul %7, %56
    %110:f32 = mul %8, %59
    %111:f32 = add %108, %109
    %112:f32 = sub %111, %110
    %113:f32 = mul %5, %41
    %114:f32 = mul %7, %62
    %115:f32 = mul %8, %65
    %116:f32 = sub %113, %114
    %117:f32 = add %116, %115
    %118:f32 = mul %9, %26
    %119:f32 = mul %10, %50
    %120:f32 = mul %12, %68
    %121:f32 = sub %118, %119
    %122:f32 = add %121, %120
    %123:f32 = mul %97, %26
    %124:f32 = mul %6, %50
    %125:f32 = mul %8, %68
    %126:f32 = add %123, %124
    %127:f32 = sub %126, %125
    %128:f32 = mul %5, %35
    %129:f32 = mul %6, %56
    %130:f32 = mul %8, %71
    %131:f32 = sub %128, %129
    %132:f32 = add %131, %130
    %133:f32 = mul %97, %44
    %134:f32 = mul %6, %62
    %135:f32 = mul %8, %74
    %136:f32 = add %133, %134
    %137:f32 = sub %136, %135
    %138:f32 = mul %96, %29
    %139:f32 = mul %10, %53
    %140:f32 = mul %11, %68
    %141:f32 = add %138, %139
    %142:f32 = sub %141, %140
    %143:f32 = mul %5, %29
    %144:f32 = mul %6, %53
    %145:f32 = mul %7, %68
    %146:f32 = sub %143, %144
    %147:f32 = add %146, %145
    %148:f32 = mul %97, %38
    %149:f32 = mul %6, %59
    %150:f32 = mul %7, %71
    %151:f32 = add %148, %149
    %152:f32 = sub %151, %150
    %153:f32 = mul %5, %47
    %154:f32 = mul %6, %65
    %155:f32 = mul %7, %74
    %156:f32 = sub %153, %154
    %157:f32 = add %156, %155
    %158:vec4<f32> = construct %80, %85, %90, %95
    %159:vec4<f32> = construct %102, %107, %112, %117
    %160:vec4<f32> = construct %122, %127, %132, %137
    %161:vec4<f32> = construct %142, %147, %152, %157
    %162:mat4x4<f32> = construct %158, %159, %160, %161
    %163:mat4x4<f32> = mul %4, %162
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, Inverse_Mat4x4h) {
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* m = b.Let(
            "m", b.Construct(ty.mat4x4<f16>(), b.Splat(ty.vec4h(), 10_h), b.Splat(ty.vec4h(), 20_h),
                             b.Splat(ty.vec4h(), 30_h), b.Splat(ty.vec4h(), 40_h)));
        b.Call<spirv::ir::BuiltinCall>(ty.mat4x4<f16>(), spirv::BuiltinFn::kInverse, m);
        b.Return(ep);
    });

    auto* src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %m:mat4x4<f16> = let mat4x4<f16>(vec4<f16>(10.0h), vec4<f16>(20.0h), vec4<f16>(30.0h), vec4<f16>(40.0h))
    %3:mat4x4<f16> = spirv.inverse %m
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto* expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %m:mat4x4<f16> = let mat4x4<f16>(vec4<f16>(10.0h), vec4<f16>(20.0h), vec4<f16>(30.0h), vec4<f16>(40.0h))
    %3:f16 = determinant %m
    %4:f16 = div 1.0h, %3
    %5:f16 = access %m, 0u, 0u
    %6:f16 = access %m, 0u, 1u
    %7:f16 = access %m, 0u, 2u
    %8:f16 = access %m, 0u, 3u
    %9:f16 = access %m, 1u, 0u
    %10:f16 = access %m, 1u, 1u
    %11:f16 = access %m, 1u, 2u
    %12:f16 = access %m, 1u, 3u
    %13:f16 = access %m, 2u, 0u
    %14:f16 = access %m, 2u, 1u
    %15:f16 = access %m, 2u, 2u
    %16:f16 = access %m, 2u, 3u
    %17:f16 = access %m, 3u, 0u
    %18:f16 = access %m, 3u, 1u
    %19:f16 = access %m, 3u, 2u
    %20:f16 = access %m, 3u, 3u
    %21:f16 = mul %15, %20
    %22:f16 = mul %16, %19
    %23:f16 = sub %21, %22
    %24:f16 = mul %14, %20
    %25:f16 = mul %16, %18
    %26:f16 = sub %24, %25
    %27:f16 = mul %14, %19
    %28:f16 = mul %15, %18
    %29:f16 = sub %27, %28
    %30:f16 = mul %11, %20
    %31:f16 = mul %12, %19
    %32:f16 = sub %30, %31
    %33:f16 = mul %10, %20
    %34:f16 = mul %12, %18
    %35:f16 = sub %33, %34
    %36:f16 = mul %10, %19
    %37:f16 = mul %11, %18
    %38:f16 = sub %36, %37
    %39:f16 = mul %11, %16
    %40:f16 = mul %12, %15
    %41:f16 = sub %39, %40
    %42:f16 = mul %10, %16
    %43:f16 = mul %12, %14
    %44:f16 = sub %42, %43
    %45:f16 = mul %10, %15
    %46:f16 = mul %11, %14
    %47:f16 = sub %45, %46
    %48:f16 = mul %13, %20
    %49:f16 = mul %16, %17
    %50:f16 = sub %48, %49
    %51:f16 = mul %13, %19
    %52:f16 = mul %15, %17
    %53:f16 = sub %51, %52
    %54:f16 = mul %9, %20
    %55:f16 = mul %12, %17
    %56:f16 = sub %54, %55
    %57:f16 = mul %9, %19
    %58:f16 = mul %11, %17
    %59:f16 = sub %57, %58
    %60:f16 = mul %9, %16
    %61:f16 = mul %12, %13
    %62:f16 = sub %60, %61
    %63:f16 = mul %9, %15
    %64:f16 = mul %11, %13
    %65:f16 = sub %63, %64
    %66:f16 = mul %13, %18
    %67:f16 = mul %14, %17
    %68:f16 = sub %66, %67
    %69:f16 = mul %9, %18
    %70:f16 = mul %10, %17
    %71:f16 = sub %69, %70
    %72:f16 = mul %9, %14
    %73:f16 = mul %10, %13
    %74:f16 = sub %72, %73
    %75:f16 = negation %6
    %76:f16 = mul %10, %23
    %77:f16 = mul %11, %26
    %78:f16 = mul %12, %29
    %79:f16 = sub %76, %77
    %80:f16 = add %79, %78
    %81:f16 = mul %75, %23
    %82:f16 = mul %7, %26
    %83:f16 = mul %8, %29
    %84:f16 = add %81, %82
    %85:f16 = sub %84, %83
    %86:f16 = mul %6, %32
    %87:f16 = mul %7, %35
    %88:f16 = mul %8, %38
    %89:f16 = sub %86, %87
    %90:f16 = add %89, %88
    %91:f16 = mul %75, %41
    %92:f16 = mul %7, %44
    %93:f16 = mul %8, %47
    %94:f16 = add %91, %92
    %95:f16 = sub %94, %93
    %96:f16 = negation %9
    %97:f16 = negation %5
    %98:f16 = mul %96, %23
    %99:f16 = mul %11, %50
    %100:f16 = mul %12, %53
    %101:f16 = add %98, %99
    %102:f16 = sub %101, %100
    %103:f16 = mul %5, %23
    %104:f16 = mul %7, %50
    %105:f16 = mul %8, %53
    %106:f16 = sub %103, %104
    %107:f16 = add %106, %105
    %108:f16 = mul %97, %32
    %109:f16 = mul %7, %56
    %110:f16 = mul %8, %59
    %111:f16 = add %108, %109
    %112:f16 = sub %111, %110
    %113:f16 = mul %5, %41
    %114:f16 = mul %7, %62
    %115:f16 = mul %8, %65
    %116:f16 = sub %113, %114
    %117:f16 = add %116, %115
    %118:f16 = mul %9, %26
    %119:f16 = mul %10, %50
    %120:f16 = mul %12, %68
    %121:f16 = sub %118, %119
    %122:f16 = add %121, %120
    %123:f16 = mul %97, %26
    %124:f16 = mul %6, %50
    %125:f16 = mul %8, %68
    %126:f16 = add %123, %124
    %127:f16 = sub %126, %125
    %128:f16 = mul %5, %35
    %129:f16 = mul %6, %56
    %130:f16 = mul %8, %71
    %131:f16 = sub %128, %129
    %132:f16 = add %131, %130
    %133:f16 = mul %97, %44
    %134:f16 = mul %6, %62
    %135:f16 = mul %8, %74
    %136:f16 = add %133, %134
    %137:f16 = sub %136, %135
    %138:f16 = mul %96, %29
    %139:f16 = mul %10, %53
    %140:f16 = mul %11, %68
    %141:f16 = add %138, %139
    %142:f16 = sub %141, %140
    %143:f16 = mul %5, %29
    %144:f16 = mul %6, %53
    %145:f16 = mul %7, %68
    %146:f16 = sub %143, %144
    %147:f16 = add %146, %145
    %148:f16 = mul %97, %38
    %149:f16 = mul %6, %59
    %150:f16 = mul %7, %71
    %151:f16 = add %148, %149
    %152:f16 = sub %151, %150
    %153:f16 = mul %5, %47
    %154:f16 = mul %6, %65
    %155:f16 = mul %7, %74
    %156:f16 = sub %153, %154
    %157:f16 = add %156, %155
    %158:vec4<f16> = construct %80, %85, %90, %95
    %159:vec4<f16> = construct %102, %107, %112, %117
    %160:vec4<f16> = construct %122, %127, %132, %137
    %161:vec4<f16> = construct %142, %147, %152, %157
    %162:mat4x4<f16> = construct %158, %159, %160, %161
    %163:mat4x4<f16> = mul %4, %162
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, SSign_Scalar_UnsignedArg) {
    auto* a = b.FunctionParam("a", ty.u32());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a});

    b.Append(ep->Block(), [&] {  //
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.i32(), spirv::BuiltinFn::kSign,
                                               Vector<core::ir::TemplateParameter, 1>{ty.i32()}, a);
        b.Return(ep);
    });

    auto* src = R"(
%foo = func(%a:u32):void {
  $B1: {
    %3:i32 = spirv.sign<i32> %a
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto* expect = R"(
%foo = func(%a:u32):void {
  $B1: {
    %3:i32 = bitcast<i32> %a
    %4:i32 = sign %3
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, SSign_Scalar_UnsignedResult) {
    auto* a = b.FunctionParam("a", ty.i32());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a});

    b.Append(ep->Block(), [&] {  //
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.u32(), spirv::BuiltinFn::kSign,
                                               Vector<core::ir::TemplateParameter, 1>{ty.u32()}, a);
        b.Return(ep);
    });

    auto* src = R"(
%foo = func(%a:i32):void {
  $B1: {
    %3:u32 = spirv.sign<u32> %a
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto* expect = R"(
%foo = func(%a:i32):void {
  $B1: {
    %3:i32 = sign %a
    %4:u32 = bitcast<u32> %3
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, SSign_Scalar_UnsignedArgAndResult) {
    auto* a = b.FunctionParam("a", ty.u32());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a});

    b.Append(ep->Block(), [&] {  //
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.u32(), spirv::BuiltinFn::kSign,
                                               Vector<core::ir::TemplateParameter, 1>{ty.u32()}, a);
        b.Return(ep);
    });

    auto* src = R"(
%foo = func(%a:u32):void {
  $B1: {
    %3:u32 = spirv.sign<u32> %a
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto* expect = R"(
%foo = func(%a:u32):void {
  $B1: {
    %3:i32 = bitcast<i32> %a
    %4:i32 = sign %3
    %5:u32 = bitcast<u32> %4
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, SSign_Scalar_SignedArgAndResult) {
    auto* a = b.FunctionParam("a", ty.i32());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a});

    b.Append(ep->Block(), [&] {  //
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.i32(), spirv::BuiltinFn::kSign,
                                               Vector<core::ir::TemplateParameter, 1>{ty.i32()}, a);
        b.Return(ep);
    });

    auto* src = R"(
%foo = func(%a:i32):void {
  $B1: {
    %3:i32 = spirv.sign<i32> %a
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto* expect = R"(
%foo = func(%a:i32):void {
  $B1: {
    %3:i32 = sign %a
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, SSign_Vector_UnsignedArg) {
    auto* a = b.FunctionParam("a", ty.vec2u());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a});

    b.Append(ep->Block(), [&] {  //
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.vec2i(), spirv::BuiltinFn::kSign,
                                               Vector<core::ir::TemplateParameter, 1>{ty.i32()}, a);
        b.Return(ep);
    });

    auto* src = R"(
%foo = func(%a:vec2<u32>):void {
  $B1: {
    %3:vec2<i32> = spirv.sign<i32> %a
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto* expect = R"(
%foo = func(%a:vec2<u32>):void {
  $B1: {
    %3:vec2<i32> = bitcast<vec2<i32>> %a
    %4:vec2<i32> = sign %3
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, SSign_Vector_UnsignedResult) {
    auto* a = b.FunctionParam("a", ty.vec2i());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a});

    b.Append(ep->Block(), [&] {  //
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.vec2u(), spirv::BuiltinFn::kSign,
                                               Vector<core::ir::TemplateParameter, 1>{ty.u32()}, a);
        b.Return(ep);
    });

    auto* src = R"(
%foo = func(%a:vec2<i32>):void {
  $B1: {
    %3:vec2<u32> = spirv.sign<u32> %a
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto* expect = R"(
%foo = func(%a:vec2<i32>):void {
  $B1: {
    %3:vec2<i32> = sign %a
    %4:vec2<u32> = bitcast<vec2<u32>> %3
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, SSign_Vector_UnsignedArgAndResult) {
    auto* a = b.FunctionParam("a", ty.vec2u());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a});

    b.Append(ep->Block(), [&] {  //
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.vec2u(), spirv::BuiltinFn::kSign,
                                               Vector<core::ir::TemplateParameter, 1>{ty.u32()}, a);
        b.Return(ep);
    });

    auto* src = R"(
%foo = func(%a:vec2<u32>):void {
  $B1: {
    %3:vec2<u32> = spirv.sign<u32> %a
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto* expect = R"(
%foo = func(%a:vec2<u32>):void {
  $B1: {
    %3:vec2<i32> = bitcast<vec2<i32>> %a
    %4:vec2<i32> = sign %3
    %5:vec2<u32> = bitcast<vec2<u32>> %4
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, SSign_Vector_SignedArgAndResult) {
    auto* a = b.FunctionParam("a", ty.vec2i());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a});

    b.Append(ep->Block(), [&] {  //
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.vec2i(), spirv::BuiltinFn::kSign,
                                               Vector<core::ir::TemplateParameter, 1>{ty.i32()}, a);
        b.Return(ep);
    });

    auto* src = R"(
%foo = func(%a:vec2<i32>):void {
  $B1: {
    %3:vec2<i32> = spirv.sign<i32> %a
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto* expect = R"(
%foo = func(%a:vec2<i32>):void {
  $B1: {
    %3:vec2<i32> = sign %a
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

struct SpirvReaderParams {
    spirv::BuiltinFn fn;
    std::string spv_name;
    std::string wgsl_name;
};
[[maybe_unused]] inline std::ostream& operator<<(std::ostream& out, SpirvReaderParams c) {
    out << c.spv_name;
    return out;
}

using SpirvReader_BuiltinsTest_OneParamSigned =
    core::ir::transform::TransformTestWithParam<SpirvReaderParams>;

TEST_P(SpirvReader_BuiltinsTest_OneParamSigned, UnsignedToUnsigned) {
    auto params = GetParam();

    auto* a = b.FunctionParam("a", ty.u32());
    auto* b_param = b.FunctionParam("b", ty.vec2u());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a, b_param});

    b.Append(ep->Block(), [&] {  //
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.u32(), params.fn,
                                               Vector<core::ir::TemplateParameter, 1>{ty.u32()}, a);
        b.CallExplicit<spirv::ir::BuiltinCall>(
            ty.vec2u(), params.fn, Vector<core::ir::TemplateParameter, 1>{ty.u32()}, b_param);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:u32, %b:vec2<u32>):void {
  $B1: {
    %4:u32 = spirv.)" +
               params.spv_name + R"(<u32> %a
    %5:vec2<u32> = spirv.)" +
               params.spv_name + R"(<u32> %b
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:u32, %b:vec2<u32>):void {
  $B1: {
    %4:i32 = bitcast<i32> %a
    %5:i32 = )" + params.wgsl_name +
                  R"( %4
    %6:u32 = bitcast<u32> %5
    %7:vec2<i32> = bitcast<vec2<i32>> %b
    %8:vec2<i32> = )" +
                  params.wgsl_name + R"( %7
    %9:vec2<u32> = bitcast<vec2<u32>> %8
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_P(SpirvReader_BuiltinsTest_OneParamSigned, UnsignedToSigned) {
    auto params = GetParam();

    auto* a = b.FunctionParam("a", ty.u32());
    auto* b_param = b.FunctionParam("b", ty.vec2u());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a, b_param});

    b.Append(ep->Block(), [&] {  //
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.i32(), params.fn,
                                               Vector<core::ir::TemplateParameter, 1>{ty.i32()}, a);
        b.CallExplicit<spirv::ir::BuiltinCall>(
            ty.vec2i(), params.fn, Vector<core::ir::TemplateParameter, 1>{ty.i32()}, b_param);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:u32, %b:vec2<u32>):void {
  $B1: {
    %4:i32 = spirv.)" +
               params.spv_name + R"(<i32> %a
    %5:vec2<i32> = spirv.)" +
               params.spv_name + R"(<i32> %b
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:u32, %b:vec2<u32>):void {
  $B1: {
    %4:i32 = bitcast<i32> %a
    %5:i32 = )" + params.wgsl_name +
                  R"( %4
    %6:vec2<i32> = bitcast<vec2<i32>> %b
    %7:vec2<i32> = )" +
                  params.wgsl_name + R"( %6
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_P(SpirvReader_BuiltinsTest_OneParamSigned, SignedToSigned) {
    auto params = GetParam();

    auto* a = b.FunctionParam("a", ty.i32());
    auto* b_param = b.FunctionParam("b", ty.vec2i());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a, b_param});

    b.Append(ep->Block(), [&] {  //
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.i32(), params.fn,
                                               Vector<core::ir::TemplateParameter, 1>{ty.i32()}, a);
        b.CallExplicit<spirv::ir::BuiltinCall>(
            ty.vec2i(), params.fn, Vector<core::ir::TemplateParameter, 1>{ty.i32()}, b_param);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:i32, %b:vec2<i32>):void {
  $B1: {
    %4:i32 = spirv.)" +
               params.spv_name + R"(<i32> %a
    %5:vec2<i32> = spirv.)" +
               params.spv_name + R"(<i32> %b
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:i32, %b:vec2<i32>):void {
  $B1: {
    %4:i32 = )" + params.wgsl_name +
                  R"( %a
    %5:vec2<i32> = )" +
                  params.wgsl_name + R"( %b
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_P(SpirvReader_BuiltinsTest_OneParamSigned, SignedToUnsigned) {
    auto params = GetParam();

    auto* a = b.FunctionParam("a", ty.i32());
    auto* b_param = b.FunctionParam("b", ty.vec2i());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a, b_param});

    b.Append(ep->Block(), [&] {  //
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.u32(), params.fn,
                                               Vector<core::ir::TemplateParameter, 1>{ty.u32()}, a);
        b.CallExplicit<spirv::ir::BuiltinCall>(
            ty.vec2u(), params.fn, Vector<core::ir::TemplateParameter, 1>{ty.u32()}, b_param);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:i32, %b:vec2<i32>):void {
  $B1: {
    %4:u32 = spirv.)" +
               params.spv_name + R"(<u32> %a
    %5:vec2<u32> = spirv.)" +
               params.spv_name + R"(<u32> %b
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:i32, %b:vec2<i32>):void {
  $B1: {
    %4:i32 = )" + params.wgsl_name +
                  R"( %a
    %5:u32 = bitcast<u32> %4
    %6:vec2<i32> = )" +
                  params.wgsl_name + R"( %b
    %7:vec2<u32> = bitcast<vec2<u32>> %6
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

INSTANTIATE_TEST_SUITE_P(SpirvReader,
                         SpirvReader_BuiltinsTest_OneParamSigned,
                         ::testing::Values(SpirvReaderParams{spirv::BuiltinFn::kAbs, "abs", "abs"},
                                           SpirvReaderParams{spirv::BuiltinFn::kFindSMsb,
                                                             "find_s_msb", "firstLeadingBit"}));

using SpirvReader_BuiltinsTest_OneParamUnsigned =
    core::ir::transform::TransformTestWithParam<SpirvReaderParams>;

TEST_P(SpirvReader_BuiltinsTest_OneParamUnsigned, UnsignedToUnsigned) {
    auto params = GetParam();

    auto* a = b.FunctionParam("a", ty.u32());
    auto* b_param = b.FunctionParam("b", ty.vec2u());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a, b_param});

    b.Append(ep->Block(), [&] {  //
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.u32(), params.fn,
                                               Vector<core::ir::TemplateParameter, 1>{ty.u32()}, a);
        b.CallExplicit<spirv::ir::BuiltinCall>(
            ty.vec2u(), params.fn, Vector<core::ir::TemplateParameter, 1>{ty.u32()}, b_param);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:u32, %b:vec2<u32>):void {
  $B1: {
    %4:u32 = spirv.)" +
               params.spv_name + R"(<u32> %a
    %5:vec2<u32> = spirv.)" +
               params.spv_name + R"(<u32> %b
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:u32, %b:vec2<u32>):void {
  $B1: {
    %4:u32 = )" + params.wgsl_name +
                  R"( %a
    %5:vec2<u32> = )" +
                  params.wgsl_name + R"( %b
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_P(SpirvReader_BuiltinsTest_OneParamUnsigned, UnsignedToSigned) {
    auto params = GetParam();

    auto* a = b.FunctionParam("a", ty.u32());
    auto* b_param = b.FunctionParam("b", ty.vec2u());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a, b_param});

    b.Append(ep->Block(), [&] {  //
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.i32(), params.fn,
                                               Vector<core::ir::TemplateParameter, 1>{ty.i32()}, a);
        b.CallExplicit<spirv::ir::BuiltinCall>(
            ty.vec2i(), params.fn, Vector<core::ir::TemplateParameter, 1>{ty.i32()}, b_param);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:u32, %b:vec2<u32>):void {
  $B1: {
    %4:i32 = spirv.)" +
               params.spv_name + R"(<i32> %a
    %5:vec2<i32> = spirv.)" +
               params.spv_name + R"(<i32> %b
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:u32, %b:vec2<u32>):void {
  $B1: {
    %4:u32 = )" + params.wgsl_name +
                  R"( %a
    %5:i32 = bitcast<i32> %4
    %6:vec2<u32> = )" +
                  params.wgsl_name + R"( %b
    %7:vec2<i32> = bitcast<vec2<i32>> %6
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_P(SpirvReader_BuiltinsTest_OneParamUnsigned, SignedToSigned) {
    auto params = GetParam();

    auto* a = b.FunctionParam("a", ty.i32());
    auto* b_param = b.FunctionParam("b", ty.vec2i());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a, b_param});

    b.Append(ep->Block(), [&] {  //
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.i32(), params.fn,
                                               Vector<core::ir::TemplateParameter, 1>{ty.i32()}, a);
        b.CallExplicit<spirv::ir::BuiltinCall>(
            ty.vec2i(), params.fn, Vector<core::ir::TemplateParameter, 1>{ty.i32()}, b_param);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:i32, %b:vec2<i32>):void {
  $B1: {
    %4:i32 = spirv.)" +
               params.spv_name + R"(<i32> %a
    %5:vec2<i32> = spirv.)" +
               params.spv_name + R"(<i32> %b
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:i32, %b:vec2<i32>):void {
  $B1: {
    %4:u32 = bitcast<u32> %a
    %5:u32 = )" + params.wgsl_name +
                  R"( %4
    %6:i32 = bitcast<i32> %5
    %7:vec2<u32> = bitcast<vec2<u32>> %b
    %8:vec2<u32> = )" +
                  params.wgsl_name + R"( %7
    %9:vec2<i32> = bitcast<vec2<i32>> %8
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_P(SpirvReader_BuiltinsTest_OneParamUnsigned, SignedToUnsigned) {
    auto params = GetParam();

    auto* a = b.FunctionParam("a", ty.i32());
    auto* b_param = b.FunctionParam("b", ty.vec2i());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a, b_param});

    b.Append(ep->Block(), [&] {  //
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.u32(), params.fn,
                                               Vector<core::ir::TemplateParameter, 1>{ty.u32()}, a);
        b.CallExplicit<spirv::ir::BuiltinCall>(
            ty.vec2u(), params.fn, Vector<core::ir::TemplateParameter, 1>{ty.u32()}, b_param);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:i32, %b:vec2<i32>):void {
  $B1: {
    %4:u32 = spirv.)" +
               params.spv_name + R"(<u32> %a
    %5:vec2<u32> = spirv.)" +
               params.spv_name + R"(<u32> %b
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:i32, %b:vec2<i32>):void {
  $B1: {
    %4:u32 = bitcast<u32> %a
    %5:u32 = )" + params.wgsl_name +
                  R"( %4
    %6:vec2<u32> = bitcast<vec2<u32>> %b
    %7:vec2<u32> = )" +
                  params.wgsl_name + R"( %6
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

INSTANTIATE_TEST_SUITE_P(SpirvReader,
                         SpirvReader_BuiltinsTest_OneParamUnsigned,
                         ::testing::Values(SpirvReaderParams{spirv::BuiltinFn::kFindUMsb,
                                                             "find_u_msb", "firstLeadingBit"}));

using SpirvReader_BuiltinsTest_TwoParamSigned =
    core::ir::transform::TransformTestWithParam<SpirvReaderParams>;

TEST_P(SpirvReader_BuiltinsTest_TwoParamSigned, UnsignedToUnsigned) {
    auto& params = GetParam();

    auto* a = b.FunctionParam("a", ty.u32());
    auto* b_param = b.FunctionParam("b", ty.u32());
    auto* c = b.FunctionParam("c", ty.vec2u());
    auto* d = b.FunctionParam("d", ty.vec2u());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a, b_param, c, d});

    b.Append(ep->Block(), [&] {  //
        b.CallExplicit<spirv::ir::BuiltinCall>(
            ty.u32(), params.fn, Vector<core::ir::TemplateParameter, 1>{ty.u32()}, a, b_param);
        b.CallExplicit<spirv::ir::BuiltinCall>(
            ty.vec2u(), params.fn, Vector<core::ir::TemplateParameter, 1>{ty.u32()}, c, d);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:u32, %b:u32, %c:vec2<u32>, %d:vec2<u32>):void {
  $B1: {
    %6:u32 = spirv.)" +
               params.spv_name + R"(<u32> %a, %b
    %7:vec2<u32> = spirv.)" +
               params.spv_name + R"(<u32> %c, %d
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:u32, %b:u32, %c:vec2<u32>, %d:vec2<u32>):void {
  $B1: {
    %6:i32 = bitcast<i32> %a
    %7:i32 = bitcast<i32> %b
    %8:i32 = )" + params.wgsl_name +
                  R"( %6, %7
    %9:u32 = bitcast<u32> %8
    %10:vec2<i32> = bitcast<vec2<i32>> %c
    %11:vec2<i32> = bitcast<vec2<i32>> %d
    %12:vec2<i32> = )" +
                  params.wgsl_name + R"( %10, %11
    %13:vec2<u32> = bitcast<vec2<u32>> %12
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_P(SpirvReader_BuiltinsTest_TwoParamSigned, SignedToSigned) {
    auto params = GetParam();

    auto* a = b.FunctionParam("a", ty.i32());
    auto* b_param = b.FunctionParam("b", ty.i32());
    auto* c = b.FunctionParam("c", ty.vec2i());
    auto* d = b.FunctionParam("d", ty.vec2i());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a, b_param, c, d});

    b.Append(ep->Block(), [&] {  //
        b.CallExplicit<spirv::ir::BuiltinCall>(
            ty.i32(), params.fn, Vector<core::ir::TemplateParameter, 1>{ty.i32()}, a, b_param);
        b.CallExplicit<spirv::ir::BuiltinCall>(
            ty.vec2i(), params.fn, Vector<core::ir::TemplateParameter, 1>{ty.i32()}, c, d);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:i32, %b:i32, %c:vec2<i32>, %d:vec2<i32>):void {
  $B1: {
    %6:i32 = spirv.)" +
               params.spv_name + R"(<i32> %a, %b
    %7:vec2<i32> = spirv.)" +
               params.spv_name + R"(<i32> %c, %d
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:i32, %b:i32, %c:vec2<i32>, %d:vec2<i32>):void {
  $B1: {
    %6:i32 = )" + params.wgsl_name +
                  R"( %a, %b
    %7:vec2<i32> = )" +
                  params.wgsl_name + R"( %c, %d
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_P(SpirvReader_BuiltinsTest_TwoParamSigned, MixedToUnsigned) {
    auto params = GetParam();

    auto* a = b.FunctionParam("a", ty.i32());
    auto* b_param = b.FunctionParam("b", ty.u32());
    auto* c = b.FunctionParam("c", ty.vec2i());
    auto* d = b.FunctionParam("d", ty.vec2u());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a, b_param, c, d});

    b.Append(ep->Block(), [&] {  //
        b.CallExplicit<spirv::ir::BuiltinCall>(
            ty.u32(), params.fn, Vector<core::ir::TemplateParameter, 1>{ty.u32()}, a, b_param);
        b.CallExplicit<spirv::ir::BuiltinCall>(
            ty.vec2u(), params.fn, Vector<core::ir::TemplateParameter, 1>{ty.u32()}, c, d);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:i32, %b:u32, %c:vec2<i32>, %d:vec2<u32>):void {
  $B1: {
    %6:u32 = spirv.)" +
               params.spv_name + R"(<u32> %a, %b
    %7:vec2<u32> = spirv.)" +
               params.spv_name + R"(<u32> %c, %d
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:i32, %b:u32, %c:vec2<i32>, %d:vec2<u32>):void {
  $B1: {
    %6:i32 = bitcast<i32> %b
    %7:i32 = )" + params.wgsl_name +
                  R"( %a, %6
    %8:u32 = bitcast<u32> %7
    %9:vec2<i32> = bitcast<vec2<i32>> %d
    %10:vec2<i32> = )" +
                  params.wgsl_name + R"( %c, %9
    %11:vec2<u32> = bitcast<vec2<u32>> %10
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_P(SpirvReader_BuiltinsTest_TwoParamSigned, MixedToSigned) {
    auto params = GetParam();

    auto* a = b.FunctionParam("a", ty.u32());
    auto* b_param = b.FunctionParam("b", ty.i32());
    auto* c = b.FunctionParam("c", ty.vec2u());
    auto* d = b.FunctionParam("d", ty.vec2i());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a, b_param, c, d});

    b.Append(ep->Block(), [&] {  //
        b.CallExplicit<spirv::ir::BuiltinCall>(
            ty.i32(), params.fn, Vector<core::ir::TemplateParameter, 1>{ty.i32()}, a, b_param);
        b.CallExplicit<spirv::ir::BuiltinCall>(
            ty.vec2i(), params.fn, Vector<core::ir::TemplateParameter, 1>{ty.i32()}, c, d);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:u32, %b:i32, %c:vec2<u32>, %d:vec2<i32>):void {
  $B1: {
    %6:i32 = spirv.)" +
               params.spv_name + R"(<i32> %a, %b
    %7:vec2<i32> = spirv.)" +
               params.spv_name + R"(<i32> %c, %d
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:u32, %b:i32, %c:vec2<u32>, %d:vec2<i32>):void {
  $B1: {
    %6:i32 = bitcast<i32> %a
    %7:i32 = )" + params.wgsl_name +
                  R"( %6, %b
    %8:vec2<i32> = bitcast<vec2<i32>> %c
    %9:vec2<i32> = )" +
                  params.wgsl_name + R"( %8, %d
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

INSTANTIATE_TEST_SUITE_P(
    SpirvReader,
    SpirvReader_BuiltinsTest_TwoParamSigned,
    ::testing::Values(SpirvReaderParams{spirv::BuiltinFn::kSMax, "s_max", "max"},
                      SpirvReaderParams{spirv::BuiltinFn::kSMin, "s_min", "min"}));

using SpirvReader_BuiltinsTest_TwoParamUnsigned =
    core::ir::transform::TransformTestWithParam<SpirvReaderParams>;

TEST_P(SpirvReader_BuiltinsTest_TwoParamUnsigned, UnsignedToUnsigned) {
    auto& params = GetParam();

    auto* a = b.FunctionParam("a", ty.u32());
    auto* b_param = b.FunctionParam("b", ty.u32());
    auto* c = b.FunctionParam("c", ty.vec2u());
    auto* d = b.FunctionParam("d", ty.vec2u());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a, b_param, c, d});

    b.Append(ep->Block(), [&] {  //
        b.CallExplicit<spirv::ir::BuiltinCall>(
            ty.u32(), params.fn, Vector<core::ir::TemplateParameter, 1>{ty.u32()}, a, b_param);
        b.CallExplicit<spirv::ir::BuiltinCall>(
            ty.vec2u(), params.fn, Vector<core::ir::TemplateParameter, 1>{ty.u32()}, c, d);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:u32, %b:u32, %c:vec2<u32>, %d:vec2<u32>):void {
  $B1: {
    %6:u32 = spirv.)" +
               params.spv_name + R"(<u32> %a, %b
    %7:vec2<u32> = spirv.)" +
               params.spv_name + R"(<u32> %c, %d
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:u32, %b:u32, %c:vec2<u32>, %d:vec2<u32>):void {
  $B1: {
    %6:u32 = )" + params.wgsl_name +
                  R"( %a, %b
    %7:vec2<u32> = )" +
                  params.wgsl_name + R"( %c, %d
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_P(SpirvReader_BuiltinsTest_TwoParamUnsigned, SignedToSigned) {
    auto params = GetParam();

    auto* a = b.FunctionParam("a", ty.i32());
    auto* b_param = b.FunctionParam("b", ty.i32());
    auto* c = b.FunctionParam("c", ty.vec2i());
    auto* d = b.FunctionParam("d", ty.vec2i());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a, b_param, c, d});

    b.Append(ep->Block(), [&] {  //
        b.CallExplicit<spirv::ir::BuiltinCall>(
            ty.i32(), params.fn, Vector<core::ir::TemplateParameter, 1>{ty.i32()}, a, b_param);
        b.CallExplicit<spirv::ir::BuiltinCall>(
            ty.vec2i(), params.fn, Vector<core::ir::TemplateParameter, 1>{ty.i32()}, c, d);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:i32, %b:i32, %c:vec2<i32>, %d:vec2<i32>):void {
  $B1: {
    %6:i32 = spirv.)" +
               params.spv_name + R"(<i32> %a, %b
    %7:vec2<i32> = spirv.)" +
               params.spv_name + R"(<i32> %c, %d
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:i32, %b:i32, %c:vec2<i32>, %d:vec2<i32>):void {
  $B1: {
    %6:u32 = bitcast<u32> %a
    %7:u32 = bitcast<u32> %b
    %8:u32 = )" + params.wgsl_name +
                  R"( %6, %7
    %9:i32 = bitcast<i32> %8
    %10:vec2<u32> = bitcast<vec2<u32>> %c
    %11:vec2<u32> = bitcast<vec2<u32>> %d
    %12:vec2<u32> = )" +
                  params.wgsl_name + R"( %10, %11
    %13:vec2<i32> = bitcast<vec2<i32>> %12
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_P(SpirvReader_BuiltinsTest_TwoParamUnsigned, MixedToUnsigned) {
    auto params = GetParam();

    auto* a = b.FunctionParam("a", ty.i32());
    auto* b_param = b.FunctionParam("b", ty.u32());
    auto* c = b.FunctionParam("c", ty.vec2i());
    auto* d = b.FunctionParam("d", ty.vec2u());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a, b_param, c, d});

    b.Append(ep->Block(), [&] {  //
        b.CallExplicit<spirv::ir::BuiltinCall>(
            ty.u32(), params.fn, Vector<core::ir::TemplateParameter, 1>{ty.u32()}, a, b_param);
        b.CallExplicit<spirv::ir::BuiltinCall>(
            ty.vec2u(), params.fn, Vector<core::ir::TemplateParameter, 1>{ty.u32()}, c, d);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:i32, %b:u32, %c:vec2<i32>, %d:vec2<u32>):void {
  $B1: {
    %6:u32 = spirv.)" +
               params.spv_name + R"(<u32> %a, %b
    %7:vec2<u32> = spirv.)" +
               params.spv_name + R"(<u32> %c, %d
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:i32, %b:u32, %c:vec2<i32>, %d:vec2<u32>):void {
  $B1: {
    %6:u32 = bitcast<u32> %a
    %7:u32 = )" + params.wgsl_name +
                  R"( %6, %b
    %8:vec2<u32> = bitcast<vec2<u32>> %c
    %9:vec2<u32> = )" +
                  params.wgsl_name + R"( %8, %d
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_P(SpirvReader_BuiltinsTest_TwoParamUnsigned, MixedToSigned) {
    auto params = GetParam();

    auto* a = b.FunctionParam("a", ty.u32());
    auto* b_param = b.FunctionParam("b", ty.i32());
    auto* c = b.FunctionParam("c", ty.vec2u());
    auto* d = b.FunctionParam("d", ty.vec2i());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a, b_param, c, d});

    b.Append(ep->Block(), [&] {  //
        b.CallExplicit<spirv::ir::BuiltinCall>(
            ty.i32(), params.fn, Vector<core::ir::TemplateParameter, 1>{ty.i32()}, a, b_param);
        b.CallExplicit<spirv::ir::BuiltinCall>(
            ty.vec2i(), params.fn, Vector<core::ir::TemplateParameter, 1>{ty.i32()}, c, d);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:u32, %b:i32, %c:vec2<u32>, %d:vec2<i32>):void {
  $B1: {
    %6:i32 = spirv.)" +
               params.spv_name + R"(<i32> %a, %b
    %7:vec2<i32> = spirv.)" +
               params.spv_name + R"(<i32> %c, %d
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:u32, %b:i32, %c:vec2<u32>, %d:vec2<i32>):void {
  $B1: {
    %6:u32 = bitcast<u32> %b
    %7:u32 = )" + params.wgsl_name +
                  R"( %a, %6
    %8:i32 = bitcast<i32> %7
    %9:vec2<u32> = bitcast<vec2<u32>> %d
    %10:vec2<u32> = )" +
                  params.wgsl_name + R"( %c, %9
    %11:vec2<i32> = bitcast<vec2<i32>> %10
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

INSTANTIATE_TEST_SUITE_P(
    SpirvReader,
    SpirvReader_BuiltinsTest_TwoParamUnsigned,
    ::testing::Values(SpirvReaderParams{spirv::BuiltinFn::kUMax, "u_max", "max"},
                      SpirvReaderParams{spirv::BuiltinFn::kUMin, "u_min", "min"}));

TEST_F(SpirvReader_BuiltinsTest, SClamp_UnsignedToUnsigned) {
    auto* a = b.FunctionParam("a", ty.u32());
    auto* b_param = b.FunctionParam("b", ty.u32());
    auto* c = b.FunctionParam("c", ty.u32());
    auto* d = b.FunctionParam("d", ty.vec2u());
    auto* e = b.FunctionParam("e", ty.vec2u());
    auto* f = b.FunctionParam("f", ty.vec2u());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a, b_param, c, d, e, f});

    b.Append(ep->Block(), [&] {  //
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.u32(), spirv::BuiltinFn::kSClamp,
                                               Vector<core::ir::TemplateParameter, 1>{ty.u32()}, a,
                                               b_param, c);
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.vec2u(), spirv::BuiltinFn::kSClamp,
                                               Vector<core::ir::TemplateParameter, 1>{ty.u32()}, d,
                                               e, f);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:u32, %b:u32, %c:u32, %d:vec2<u32>, %e:vec2<u32>, %f:vec2<u32>):void {
  $B1: {
    %8:u32 = spirv.s_clamp<u32> %a, %b, %c
    %9:vec2<u32> = spirv.s_clamp<u32> %d, %e, %f
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:u32, %b:u32, %c:u32, %d:vec2<u32>, %e:vec2<u32>, %f:vec2<u32>):void {
  $B1: {
    %8:i32 = bitcast<i32> %a
    %9:i32 = bitcast<i32> %b
    %10:i32 = bitcast<i32> %c
    %11:i32 = clamp %8, %9, %10
    %12:u32 = bitcast<u32> %11
    %13:vec2<i32> = bitcast<vec2<i32>> %d
    %14:vec2<i32> = bitcast<vec2<i32>> %e
    %15:vec2<i32> = bitcast<vec2<i32>> %f
    %16:vec2<i32> = clamp %13, %14, %15
    %17:vec2<u32> = bitcast<vec2<u32>> %16
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, SClamp_SignedToSigned) {
    auto* a = b.FunctionParam("a", ty.i32());
    auto* b_param = b.FunctionParam("b", ty.i32());
    auto* c = b.FunctionParam("c", ty.i32());
    auto* d = b.FunctionParam("d", ty.vec2i());
    auto* e = b.FunctionParam("e", ty.vec2i());
    auto* f = b.FunctionParam("f", ty.vec2i());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a, b_param, c, d, e, f});

    b.Append(ep->Block(), [&] {  //
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.i32(), spirv::BuiltinFn::kSClamp,
                                               Vector<core::ir::TemplateParameter, 1>{ty.i32()}, a,
                                               b_param, c);
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.vec2i(), spirv::BuiltinFn::kSClamp,
                                               Vector<core::ir::TemplateParameter, 1>{ty.i32()}, d,
                                               e, f);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:i32, %b:i32, %c:i32, %d:vec2<i32>, %e:vec2<i32>, %f:vec2<i32>):void {
  $B1: {
    %8:i32 = spirv.s_clamp<i32> %a, %b, %c
    %9:vec2<i32> = spirv.s_clamp<i32> %d, %e, %f
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:i32, %b:i32, %c:i32, %d:vec2<i32>, %e:vec2<i32>, %f:vec2<i32>):void {
  $B1: {
    %8:i32 = clamp %a, %b, %c
    %9:vec2<i32> = clamp %d, %e, %f
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, SClamp_MixedToUnsigned) {
    auto* a = b.FunctionParam("a", ty.i32());
    auto* b_param = b.FunctionParam("b", ty.u32());
    auto* c = b.FunctionParam("c", ty.i32());
    auto* d = b.FunctionParam("d", ty.vec2i());
    auto* e = b.FunctionParam("e", ty.vec2u());
    auto* f = b.FunctionParam("f", ty.vec2i());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a, b_param, c, d, e, f});

    b.Append(ep->Block(), [&] {  //
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.u32(), spirv::BuiltinFn::kSClamp,
                                               Vector<core::ir::TemplateParameter, 1>{ty.u32()}, a,
                                               b_param, c);
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.vec2u(), spirv::BuiltinFn::kSClamp,
                                               Vector<core::ir::TemplateParameter, 1>{ty.u32()}, d,
                                               e, f);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:i32, %b:u32, %c:i32, %d:vec2<i32>, %e:vec2<u32>, %f:vec2<i32>):void {
  $B1: {
    %8:u32 = spirv.s_clamp<u32> %a, %b, %c
    %9:vec2<u32> = spirv.s_clamp<u32> %d, %e, %f
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:i32, %b:u32, %c:i32, %d:vec2<i32>, %e:vec2<u32>, %f:vec2<i32>):void {
  $B1: {
    %8:i32 = bitcast<i32> %b
    %9:i32 = clamp %a, %8, %c
    %10:u32 = bitcast<u32> %9
    %11:vec2<i32> = bitcast<vec2<i32>> %e
    %12:vec2<i32> = clamp %d, %11, %f
    %13:vec2<u32> = bitcast<vec2<u32>> %12
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, SClamp_MixedToSigned) {
    auto* a = b.FunctionParam("a", ty.u32());
    auto* b_param = b.FunctionParam("b", ty.i32());
    auto* c = b.FunctionParam("c", ty.u32());
    auto* d = b.FunctionParam("d", ty.vec2u());
    auto* e = b.FunctionParam("e", ty.vec2i());
    auto* f = b.FunctionParam("f", ty.vec2u());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a, b_param, c, d, e, f});

    b.Append(ep->Block(), [&] {  //
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.i32(), spirv::BuiltinFn::kSClamp,
                                               Vector<core::ir::TemplateParameter, 1>{ty.i32()}, a,
                                               b_param, c);
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.vec2i(), spirv::BuiltinFn::kSClamp,
                                               Vector<core::ir::TemplateParameter, 1>{ty.i32()}, d,
                                               e, f);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:u32, %b:i32, %c:u32, %d:vec2<u32>, %e:vec2<i32>, %f:vec2<u32>):void {
  $B1: {
    %8:i32 = spirv.s_clamp<i32> %a, %b, %c
    %9:vec2<i32> = spirv.s_clamp<i32> %d, %e, %f
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:u32, %b:i32, %c:u32, %d:vec2<u32>, %e:vec2<i32>, %f:vec2<u32>):void {
  $B1: {
    %8:i32 = bitcast<i32> %a
    %9:i32 = bitcast<i32> %c
    %10:i32 = clamp %8, %b, %9
    %11:vec2<i32> = bitcast<vec2<i32>> %d
    %12:vec2<i32> = bitcast<vec2<i32>> %f
    %13:vec2<i32> = clamp %11, %e, %12
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, UClamp_UnsignedToUnsigned) {
    auto* a = b.FunctionParam("a", ty.u32());
    auto* b_param = b.FunctionParam("b", ty.u32());
    auto* c = b.FunctionParam("c", ty.u32());
    auto* d = b.FunctionParam("d", ty.vec2u());
    auto* e = b.FunctionParam("e", ty.vec2u());
    auto* f = b.FunctionParam("f", ty.vec2u());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a, b_param, c, d, e, f});

    b.Append(ep->Block(), [&] {  //
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.u32(), spirv::BuiltinFn::kUClamp,
                                               Vector<core::ir::TemplateParameter, 1>{ty.u32()}, a,
                                               b_param, c);
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.vec2u(), spirv::BuiltinFn::kUClamp,
                                               Vector<core::ir::TemplateParameter, 1>{ty.u32()}, d,
                                               e, f);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:u32, %b:u32, %c:u32, %d:vec2<u32>, %e:vec2<u32>, %f:vec2<u32>):void {
  $B1: {
    %8:u32 = spirv.u_clamp<u32> %a, %b, %c
    %9:vec2<u32> = spirv.u_clamp<u32> %d, %e, %f
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:u32, %b:u32, %c:u32, %d:vec2<u32>, %e:vec2<u32>, %f:vec2<u32>):void {
  $B1: {
    %8:u32 = clamp %a, %b, %c
    %9:vec2<u32> = clamp %d, %e, %f
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, UClamp_SignedToSigned) {
    auto* a = b.FunctionParam("a", ty.i32());
    auto* b_param = b.FunctionParam("b", ty.i32());
    auto* c = b.FunctionParam("c", ty.i32());
    auto* d = b.FunctionParam("d", ty.vec2i());
    auto* e = b.FunctionParam("e", ty.vec2i());
    auto* f = b.FunctionParam("f", ty.vec2i());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a, b_param, c, d, e, f});

    b.Append(ep->Block(), [&] {  //
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.i32(), spirv::BuiltinFn::kUClamp,
                                               Vector<core::ir::TemplateParameter, 1>{ty.i32()}, a,
                                               b_param, c);
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.vec2i(), spirv::BuiltinFn::kUClamp,
                                               Vector<core::ir::TemplateParameter, 1>{ty.i32()}, d,
                                               e, f);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:i32, %b:i32, %c:i32, %d:vec2<i32>, %e:vec2<i32>, %f:vec2<i32>):void {
  $B1: {
    %8:i32 = spirv.u_clamp<i32> %a, %b, %c
    %9:vec2<i32> = spirv.u_clamp<i32> %d, %e, %f
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:i32, %b:i32, %c:i32, %d:vec2<i32>, %e:vec2<i32>, %f:vec2<i32>):void {
  $B1: {
    %8:u32 = bitcast<u32> %a
    %9:u32 = bitcast<u32> %b
    %10:u32 = bitcast<u32> %c
    %11:u32 = clamp %8, %9, %10
    %12:i32 = bitcast<i32> %11
    %13:vec2<u32> = bitcast<vec2<u32>> %d
    %14:vec2<u32> = bitcast<vec2<u32>> %e
    %15:vec2<u32> = bitcast<vec2<u32>> %f
    %16:vec2<u32> = clamp %13, %14, %15
    %17:vec2<i32> = bitcast<vec2<i32>> %16
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, UClamp_MixedToUnsigned) {
    auto* a = b.FunctionParam("a", ty.i32());
    auto* b_param = b.FunctionParam("b", ty.u32());
    auto* c = b.FunctionParam("c", ty.i32());
    auto* d = b.FunctionParam("d", ty.vec2i());
    auto* e = b.FunctionParam("e", ty.vec2u());
    auto* f = b.FunctionParam("f", ty.vec2i());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a, b_param, c, d, e, f});

    b.Append(ep->Block(), [&] {  //
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.u32(), spirv::BuiltinFn::kUClamp,
                                               Vector<core::ir::TemplateParameter, 1>{ty.u32()}, a,
                                               b_param, c);
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.vec2u(), spirv::BuiltinFn::kUClamp,
                                               Vector<core::ir::TemplateParameter, 1>{ty.u32()}, d,
                                               e, f);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:i32, %b:u32, %c:i32, %d:vec2<i32>, %e:vec2<u32>, %f:vec2<i32>):void {
  $B1: {
    %8:u32 = spirv.u_clamp<u32> %a, %b, %c
    %9:vec2<u32> = spirv.u_clamp<u32> %d, %e, %f
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:i32, %b:u32, %c:i32, %d:vec2<i32>, %e:vec2<u32>, %f:vec2<i32>):void {
  $B1: {
    %8:u32 = bitcast<u32> %a
    %9:u32 = bitcast<u32> %c
    %10:u32 = clamp %8, %b, %9
    %11:vec2<u32> = bitcast<vec2<u32>> %d
    %12:vec2<u32> = bitcast<vec2<u32>> %f
    %13:vec2<u32> = clamp %11, %e, %12
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, UClamp_MixedToSigned) {
    auto* a = b.FunctionParam("a", ty.u32());
    auto* b_param = b.FunctionParam("b", ty.i32());
    auto* c = b.FunctionParam("c", ty.u32());
    auto* d = b.FunctionParam("d", ty.vec2u());
    auto* e = b.FunctionParam("e", ty.vec2i());
    auto* f = b.FunctionParam("f", ty.vec2u());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a, b_param, c, d, e, f});

    b.Append(ep->Block(), [&] {  //
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.i32(), spirv::BuiltinFn::kUClamp,
                                               Vector<core::ir::TemplateParameter, 1>{ty.i32()}, a,
                                               b_param, c);
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.vec2i(), spirv::BuiltinFn::kUClamp,
                                               Vector<core::ir::TemplateParameter, 1>{ty.i32()}, d,
                                               e, f);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:u32, %b:i32, %c:u32, %d:vec2<u32>, %e:vec2<i32>, %f:vec2<u32>):void {
  $B1: {
    %8:i32 = spirv.u_clamp<i32> %a, %b, %c
    %9:vec2<i32> = spirv.u_clamp<i32> %d, %e, %f
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:u32, %b:i32, %c:u32, %d:vec2<u32>, %e:vec2<i32>, %f:vec2<u32>):void {
  $B1: {
    %8:u32 = bitcast<u32> %b
    %9:u32 = clamp %a, %8, %c
    %10:i32 = bitcast<i32> %9
    %11:vec2<u32> = bitcast<vec2<u32>> %e
    %12:vec2<u32> = clamp %d, %11, %f
    %13:vec2<i32> = bitcast<vec2<i32>> %12
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, FindILsb_SignedToSigned) {
    auto* a = b.FunctionParam("a", ty.i32());
    auto* b_param = b.FunctionParam("b", ty.vec2i());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a, b_param});

    b.Append(ep->Block(), [&] {  //
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.i32(), spirv::BuiltinFn::kFindILsb,
                                               Vector<core::ir::TemplateParameter, 1>{ty.i32()}, a);
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.vec2i(), spirv::BuiltinFn::kFindILsb,
                                               Vector<core::ir::TemplateParameter, 1>{ty.i32()},
                                               b_param);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:i32, %b:vec2<i32>):void {
  $B1: {
    %4:i32 = spirv.find_i_lsb<i32> %a
    %5:vec2<i32> = spirv.find_i_lsb<i32> %b
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:i32, %b:vec2<i32>):void {
  $B1: {
    %4:i32 = firstTrailingBit %a
    %5:vec2<i32> = firstTrailingBit %b
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, FindILsb_UnsignedToUnsigned) {
    auto* a = b.FunctionParam("a", ty.u32());
    auto* b_param = b.FunctionParam("b", ty.vec2u());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a, b_param});

    b.Append(ep->Block(), [&] {  //
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.u32(), spirv::BuiltinFn::kFindILsb,
                                               Vector<core::ir::TemplateParameter, 1>{ty.u32()}, a);
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.vec2u(), spirv::BuiltinFn::kFindILsb,
                                               Vector<core::ir::TemplateParameter, 1>{ty.u32()},
                                               b_param);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:u32, %b:vec2<u32>):void {
  $B1: {
    %4:u32 = spirv.find_i_lsb<u32> %a
    %5:vec2<u32> = spirv.find_i_lsb<u32> %b
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:u32, %b:vec2<u32>):void {
  $B1: {
    %4:u32 = firstTrailingBit %a
    %5:vec2<u32> = firstTrailingBit %b
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, FindILsb_SignedToUnsigned) {
    auto* a = b.FunctionParam("a", ty.i32());
    auto* b_param = b.FunctionParam("b", ty.vec2i());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a, b_param});

    b.Append(ep->Block(), [&] {  //
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.u32(), spirv::BuiltinFn::kFindILsb,
                                               Vector<core::ir::TemplateParameter, 1>{ty.u32()}, a);
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.vec2u(), spirv::BuiltinFn::kFindILsb,
                                               Vector<core::ir::TemplateParameter, 1>{ty.u32()},
                                               b_param);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:i32, %b:vec2<i32>):void {
  $B1: {
    %4:u32 = spirv.find_i_lsb<u32> %a
    %5:vec2<u32> = spirv.find_i_lsb<u32> %b
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:i32, %b:vec2<i32>):void {
  $B1: {
    %4:i32 = firstTrailingBit %a
    %5:u32 = bitcast<u32> %4
    %6:vec2<i32> = firstTrailingBit %b
    %7:vec2<u32> = bitcast<vec2<u32>> %6
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, FindILsb_UnsignedToSigned) {
    auto* a = b.FunctionParam("a", ty.u32());
    auto* b_param = b.FunctionParam("b", ty.vec2u());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a, b_param});

    b.Append(ep->Block(), [&] {  //
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.i32(), spirv::BuiltinFn::kFindILsb,
                                               Vector<core::ir::TemplateParameter, 1>{ty.i32()}, a);
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.vec2i(), spirv::BuiltinFn::kFindILsb,
                                               Vector<core::ir::TemplateParameter, 1>{ty.i32()},
                                               b_param);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:u32, %b:vec2<u32>):void {
  $B1: {
    %4:i32 = spirv.find_i_lsb<i32> %a
    %5:vec2<i32> = spirv.find_i_lsb<i32> %b
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:u32, %b:vec2<u32>):void {
  $B1: {
    %4:u32 = firstTrailingBit %a
    %5:i32 = bitcast<i32> %4
    %6:vec2<u32> = firstTrailingBit %b
    %7:vec2<i32> = bitcast<vec2<i32>> %6
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, Refract_Scalar) {
    auto* a = b.FunctionParam("a", ty.f32());
    auto* b_param = b.FunctionParam("b", ty.f32());
    auto* c = b.FunctionParam("c", ty.f32());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a, b_param, c});

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.f32(), spirv::BuiltinFn::kRefract, a, b_param, c);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:f32, %b:f32, %c:f32):void {
  $B1: {
    %5:f32 = spirv.refract %a, %b, %c
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:f32, %b:f32, %c:f32):void {
  $B1: {
    %5:vec2<f32> = construct %a, 0.0f
    %6:vec2<f32> = construct %b, 0.0f
    %7:vec2<f32> = refract %5, %6, %c
    %8:f32 = swizzle %7, x
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, Refract_Vector) {
    auto* a = b.FunctionParam("a", ty.vec2f());
    auto* b_param = b.FunctionParam("b", ty.vec2f());
    auto* c = b.FunctionParam("c", ty.f32());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a, b_param, c});

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.vec2f(), spirv::BuiltinFn::kRefract, a, b_param, c);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:vec2<f32>, %b:vec2<f32>, %c:f32):void {
  $B1: {
    %5:vec2<f32> = spirv.refract %a, %b, %c
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:vec2<f32>, %b:vec2<f32>, %c:f32):void {
  $B1: {
    %5:vec2<f32> = refract %a, %b, %c
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, FaceForward_Scalar) {
    auto* a = b.FunctionParam("a", ty.f32());
    auto* b_param = b.FunctionParam("b", ty.f32());
    auto* c = b.FunctionParam("c", ty.f32());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a, b_param, c});

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.f32(), spirv::BuiltinFn::kFaceForward, a, b_param, c);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:f32, %b:f32, %c:f32):void {
  $B1: {
    %5:f32 = spirv.face_forward %a, %b, %c
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:f32, %b:f32, %c:f32):void {
  $B1: {
    %5:f32 = negation %a
    %6:f32 = mul %b, %c
    %7:bool = lt %6, 0.0f
    %8:f32 = select %5, %a, %7
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, FaceForward_Vector) {
    auto* a = b.FunctionParam("a", ty.vec2f());
    auto* b_param = b.FunctionParam("b", ty.vec2f());
    auto* c = b.FunctionParam("c", ty.vec2f());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a, b_param, c});

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.vec2f(), spirv::BuiltinFn::kFaceForward, a, b_param, c);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:vec2<f32>, %b:vec2<f32>, %c:vec2<f32>):void {
  $B1: {
    %5:vec2<f32> = spirv.face_forward %a, %b, %c
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:vec2<f32>, %b:vec2<f32>, %c:vec2<f32>):void {
  $B1: {
    %5:vec2<f32> = faceForward %a, %b, %c
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, Reflect_Scalar) {
    auto* a = b.FunctionParam("a", ty.f32());
    auto* b_param = b.FunctionParam("b", ty.f32());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a, b_param});

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.f32(), spirv::BuiltinFn::kReflect, a, b_param);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:f32, %b:f32):void {
  $B1: {
    %4:f32 = spirv.reflect %a, %b
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:f32, %b:f32):void {
  $B1: {
    %4:f32 = mul %a, %b
    %5:f32 = mul %4, %b
    %6:f32 = mul %5, 2.0f
    %7:f32 = sub %a, %6
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, Reflect_Vector) {
    auto* a = b.FunctionParam("a", ty.vec2f());
    auto* b_param = b.FunctionParam("b", ty.vec2f());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a, b_param});

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.vec2f(), spirv::BuiltinFn::kReflect, a, b_param);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:vec2<f32>, %b:vec2<f32>):void {
  $B1: {
    %4:vec2<f32> = spirv.reflect %a, %b
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:vec2<f32>, %b:vec2<f32>):void {
  $B1: {
    %4:vec2<f32> = reflect %a, %b
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, Ldexp_ScalarSigned) {
    auto* a = b.FunctionParam("a", ty.f32());
    auto* b_param = b.FunctionParam("b", ty.i32());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a, b_param});

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.f32(), spirv::BuiltinFn::kLdexp, a, b_param);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:f32, %b:i32):void {
  $B1: {
    %4:f32 = spirv.ldexp %a, %b
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:f32, %b:i32):void {
  $B1: {
    %4:f32 = ldexp %a, %b
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, Ldexp_ScalarUnsigned) {
    auto* a = b.FunctionParam("a", ty.f32());
    auto* b_param = b.FunctionParam("b", ty.u32());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a, b_param});

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.f32(), spirv::BuiltinFn::kLdexp, a, b_param);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:f32, %b:u32):void {
  $B1: {
    %4:f32 = spirv.ldexp %a, %b
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:f32, %b:u32):void {
  $B1: {
    %4:i32 = bitcast<i32> %b
    %5:f32 = ldexp %a, %4
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, Ldexp_VectorUnsigned) {
    auto* a = b.FunctionParam("a", ty.vec2f());
    auto* b_param = b.FunctionParam("b", ty.vec2u());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a, b_param});

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.vec2f(), spirv::BuiltinFn::kLdexp, a, b_param);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:vec2<f32>, %b:vec2<u32>):void {
  $B1: {
    %4:vec2<f32> = spirv.ldexp %a, %b
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:vec2<f32>, %b:vec2<u32>):void {
  $B1: {
    %4:vec2<i32> = bitcast<vec2<i32>> %b
    %5:vec2<f32> = ldexp %a, %4
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, Ldexp_VectorSigned) {
    auto* a = b.FunctionParam("a", ty.vec2f());
    auto* b_param = b.FunctionParam("b", ty.vec2i());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a, b_param});

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.vec2f(), spirv::BuiltinFn::kLdexp, a, b_param);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:vec2<f32>, %b:vec2<i32>):void {
  $B1: {
    %4:vec2<f32> = spirv.ldexp %a, %b
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:vec2<f32>, %b:vec2<i32>):void {
  $B1: {
    %4:vec2<f32> = ldexp %a, %b
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, Modf_Scalar) {
    auto* a = b.FunctionParam("a", ty.f32());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a});

    b.Append(ep->Block(), [&] {  //
        auto* v = b.Var(ty.ptr<function, f32>());
        auto* res = b.Call<spirv::ir::BuiltinCall>(ty.f32(), spirv::BuiltinFn::kModf, a, v);
        b.Let(b.Multiply(res, res));
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:f32):void {
  $B1: {
    %3:ptr<function, f32, read_write> = var undef
    %4:f32 = spirv.modf %a, %3
    %5:f32 = mul %4, %4
    %6:f32 = let %5
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
__modf_result_f32 = struct @align(4) {
  fract:f32 @offset(0)
  whole:f32 @offset(4)
}

%foo = func(%a:f32):void {
  $B1: {
    %3:ptr<function, f32, read_write> = var undef
    %4:__modf_result_f32 = modf %a
    %5:f32 = access %4, 1u
    store %3, %5
    %6:f32 = access %4, 0u
    %7:f32 = mul %6, %6
    %8:f32 = let %7
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, Modf_Vector) {
    auto* a = b.FunctionParam("a", ty.vec2f());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a});

    b.Append(ep->Block(), [&] {  //
        auto* v = b.Var(ty.ptr<function, vec2<f32>>());
        auto* res = b.Call<spirv::ir::BuiltinCall>(ty.vec2f(), spirv::BuiltinFn::kModf, a, v);
        b.Let(b.Multiply(res, res));
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:vec2<f32>):void {
  $B1: {
    %3:ptr<function, vec2<f32>, read_write> = var undef
    %4:vec2<f32> = spirv.modf %a, %3
    %5:vec2<f32> = mul %4, %4
    %6:vec2<f32> = let %5
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
__modf_result_vec2_f32 = struct @align(8) {
  fract:vec2<f32> @offset(0)
  whole:vec2<f32> @offset(8)
}

%foo = func(%a:vec2<f32>):void {
  $B1: {
    %3:ptr<function, vec2<f32>, read_write> = var undef
    %4:__modf_result_vec2_f32 = modf %a
    %5:vec2<f32> = access %4, 1u
    store %3, %5
    %6:vec2<f32> = access %4, 0u
    %7:vec2<f32> = mul %6, %6
    %8:vec2<f32> = let %7
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, Frexp_ScalarSigned) {
    auto* a = b.FunctionParam("a", ty.f32());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a});

    b.Append(ep->Block(), [&] {  //
        auto* v = b.Var(ty.ptr<function, i32>());
        auto* res = b.Call<spirv::ir::BuiltinCall>(ty.f32(), spirv::BuiltinFn::kFrexp, a, v);
        b.Let(b.Multiply(res, res));
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:f32):void {
  $B1: {
    %3:ptr<function, i32, read_write> = var undef
    %4:f32 = spirv.frexp %a, %3
    %5:f32 = mul %4, %4
    %6:f32 = let %5
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
__frexp_result_f32 = struct @align(4) {
  fract:f32 @offset(0)
  exp:i32 @offset(4)
}

%foo = func(%a:f32):void {
  $B1: {
    %3:ptr<function, i32, read_write> = var undef
    %4:__frexp_result_f32 = frexp %a
    %5:i32 = access %4, 1u
    store %3, %5
    %6:f32 = access %4, 0u
    %7:f32 = mul %6, %6
    %8:f32 = let %7
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, Frexp_ScalarUnSigned) {
    auto* a = b.FunctionParam("a", ty.f32());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a});

    b.Append(ep->Block(), [&] {  //
        auto* v = b.Var(ty.ptr<function, u32>());
        auto* res = b.Call<spirv::ir::BuiltinCall>(ty.f32(), spirv::BuiltinFn::kFrexp, a, v);
        b.Let(b.Multiply(res, res));
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:f32):void {
  $B1: {
    %3:ptr<function, u32, read_write> = var undef
    %4:f32 = spirv.frexp %a, %3
    %5:f32 = mul %4, %4
    %6:f32 = let %5
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
__frexp_result_f32 = struct @align(4) {
  fract:f32 @offset(0)
  exp:i32 @offset(4)
}

%foo = func(%a:f32):void {
  $B1: {
    %3:ptr<function, u32, read_write> = var undef
    %4:__frexp_result_f32 = frexp %a
    %5:i32 = access %4, 1u
    %6:u32 = bitcast<u32> %5
    store %3, %6
    %7:f32 = access %4, 0u
    %8:f32 = mul %7, %7
    %9:f32 = let %8
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, Frexp_VectorSigned) {
    auto* a = b.FunctionParam("a", ty.vec2f());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a});

    b.Append(ep->Block(), [&] {  //
        auto* v = b.Var(ty.ptr<function, vec2<i32>>());
        auto* res = b.Call<spirv::ir::BuiltinCall>(ty.vec2f(), spirv::BuiltinFn::kFrexp, a, v);
        b.Let(b.Multiply(res, res));
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:vec2<f32>):void {
  $B1: {
    %3:ptr<function, vec2<i32>, read_write> = var undef
    %4:vec2<f32> = spirv.frexp %a, %3
    %5:vec2<f32> = mul %4, %4
    %6:vec2<f32> = let %5
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
__frexp_result_vec2_f32 = struct @align(8) {
  fract:vec2<f32> @offset(0)
  exp:vec2<i32> @offset(8)
}

%foo = func(%a:vec2<f32>):void {
  $B1: {
    %3:ptr<function, vec2<i32>, read_write> = var undef
    %4:__frexp_result_vec2_f32 = frexp %a
    %5:vec2<i32> = access %4, 1u
    store %3, %5
    %6:vec2<f32> = access %4, 0u
    %7:vec2<f32> = mul %6, %6
    %8:vec2<f32> = let %7
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, Frexp_VectorUnsigned) {
    auto* a = b.FunctionParam("a", ty.vec2f());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a});

    b.Append(ep->Block(), [&] {  //
        auto* v = b.Var(ty.ptr<function, vec2<u32>>());
        auto* res = b.Call<spirv::ir::BuiltinCall>(ty.vec2f(), spirv::BuiltinFn::kFrexp, a, v);
        b.Let(b.Multiply(res, res));
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:vec2<f32>):void {
  $B1: {
    %3:ptr<function, vec2<u32>, read_write> = var undef
    %4:vec2<f32> = spirv.frexp %a, %3
    %5:vec2<f32> = mul %4, %4
    %6:vec2<f32> = let %5
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
__frexp_result_vec2_f32 = struct @align(8) {
  fract:vec2<f32> @offset(0)
  exp:vec2<i32> @offset(8)
}

%foo = func(%a:vec2<f32>):void {
  $B1: {
    %3:ptr<function, vec2<u32>, read_write> = var undef
    %4:__frexp_result_vec2_f32 = frexp %a
    %5:vec2<i32> = access %4, 1u
    %6:vec2<u32> = bitcast<vec2<u32>> %5
    store %3, %6
    %7:vec2<f32> = access %4, 0u
    %8:vec2<f32> = mul %7, %7
    %9:vec2<f32> = let %8
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, BitCount_Scalar_UnsignedToUnsigned) {
    auto* a = b.FunctionParam("a", ty.u32());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a});

    b.Append(ep->Block(), [&] {  //
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.u32(), spirv::BuiltinFn::kBitCount,
                                               Vector<core::ir::TemplateParameter, 1>{ty.u32()}, a);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:u32):void {
  $B1: {
    %3:u32 = spirv.bit_count<u32> %a
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:u32):void {
  $B1: {
    %3:u32 = countOneBits %a
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, BitCount_Scalar_UnsignedToSigned) {
    auto* a = b.FunctionParam("a", ty.u32());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a});

    b.Append(ep->Block(), [&] {  //
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.i32(), spirv::BuiltinFn::kBitCount,
                                               Vector<core::ir::TemplateParameter, 1>{ty.i32()}, a);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:u32):void {
  $B1: {
    %3:i32 = spirv.bit_count<i32> %a
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:u32):void {
  $B1: {
    %3:u32 = countOneBits %a
    %4:i32 = bitcast<i32> %3
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, BitCount_Scalar_SignedToUnsigned) {
    auto* a = b.FunctionParam("a", ty.i32());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a});

    b.Append(ep->Block(), [&] {  //
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.u32(), spirv::BuiltinFn::kBitCount,
                                               Vector<core::ir::TemplateParameter, 1>{ty.u32()}, a);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:i32):void {
  $B1: {
    %3:u32 = spirv.bit_count<u32> %a
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:i32):void {
  $B1: {
    %3:i32 = countOneBits %a
    %4:u32 = bitcast<u32> %3
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, BitCount_Scalar_SignedToSigned) {
    auto* a = b.FunctionParam("a", ty.i32());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a});

    b.Append(ep->Block(), [&] {  //
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.i32(), spirv::BuiltinFn::kBitCount,
                                               Vector<core::ir::TemplateParameter, 1>{ty.i32()}, a);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:i32):void {
  $B1: {
    %3:i32 = spirv.bit_count<i32> %a
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:i32):void {
  $B1: {
    %3:i32 = countOneBits %a
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, BitCount_Vector_UnsignedToUnsigned) {
    auto* a = b.FunctionParam("a", ty.vec2u());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a});

    b.Append(ep->Block(), [&] {  //
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.vec2u(), spirv::BuiltinFn::kBitCount,
                                               Vector<core::ir::TemplateParameter, 1>{ty.u32()}, a);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:vec2<u32>):void {
  $B1: {
    %3:vec2<u32> = spirv.bit_count<u32> %a
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:vec2<u32>):void {
  $B1: {
    %3:vec2<u32> = countOneBits %a
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, BitCount_Vector_UnsignedToSigned) {
    auto* a = b.FunctionParam("a", ty.vec2u());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a});

    b.Append(ep->Block(), [&] {  //
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.vec2i(), spirv::BuiltinFn::kBitCount,
                                               Vector<core::ir::TemplateParameter, 1>{ty.i32()}, a);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:vec2<u32>):void {
  $B1: {
    %3:vec2<i32> = spirv.bit_count<i32> %a
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:vec2<u32>):void {
  $B1: {
    %3:vec2<u32> = countOneBits %a
    %4:vec2<i32> = bitcast<vec2<i32>> %3
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, BitCount_Vector_SignedToUnsigned) {
    auto* a = b.FunctionParam("a", ty.vec2i());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a});

    b.Append(ep->Block(), [&] {  //
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.vec2u(), spirv::BuiltinFn::kBitCount,
                                               Vector<core::ir::TemplateParameter, 1>{ty.u32()}, a);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:vec2<i32>):void {
  $B1: {
    %3:vec2<u32> = spirv.bit_count<u32> %a
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:vec2<i32>):void {
  $B1: {
    %3:vec2<i32> = countOneBits %a
    %4:vec2<u32> = bitcast<vec2<u32>> %3
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, BitCount_Vector_SignedToSigned) {
    auto* a = b.FunctionParam("a", ty.vec2i());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a});

    b.Append(ep->Block(), [&] {  //
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.vec2i(), spirv::BuiltinFn::kBitCount,
                                               Vector<core::ir::TemplateParameter, 1>{ty.i32()}, a);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:vec2<i32>):void {
  $B1: {
    %3:vec2<i32> = spirv.bit_count<i32> %a
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:vec2<i32>):void {
  $B1: {
    %3:vec2<i32> = countOneBits %a
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, BitFieldInsert_Int_UnsignedOffsetAndCount) {
    auto* a = b.FunctionParam("a", ty.i32());
    auto* b_param = b.FunctionParam("b", ty.i32());
    auto* c = b.FunctionParam("c", ty.u32());
    auto* d = b.FunctionParam("d", ty.u32());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a, b_param, c, d});

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.i32(), spirv::BuiltinFn::kBitFieldInsert, a, b_param, c,
                                       d);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:i32, %b:i32, %c:u32, %d:u32):void {
  $B1: {
    %6:i32 = spirv.bit_field_insert %a, %b, %c, %d
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:i32, %b:i32, %c:u32, %d:u32):void {
  $B1: {
    %6:i32 = insertBits %a, %b, %c, %d
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, BitFieldInsert_Int_SignedOffsetAndCount) {
    auto* a = b.FunctionParam("a", ty.i32());
    auto* b_param = b.FunctionParam("b", ty.i32());
    auto* c = b.FunctionParam("c", ty.i32());
    auto* d = b.FunctionParam("d", ty.i32());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a, b_param, c, d});

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.i32(), spirv::BuiltinFn::kBitFieldInsert, a, b_param, c,
                                       d);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:i32, %b:i32, %c:i32, %d:i32):void {
  $B1: {
    %6:i32 = spirv.bit_field_insert %a, %b, %c, %d
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:i32, %b:i32, %c:i32, %d:i32):void {
  $B1: {
    %6:u32 = bitcast<u32> %c
    %7:u32 = bitcast<u32> %d
    %8:i32 = insertBits %a, %b, %6, %7
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, BitFieldInsert_IntVector_UnsignedOffsetAndCount) {
    auto* a = b.FunctionParam("a", ty.vec2i());
    auto* b_param = b.FunctionParam("b", ty.vec2i());
    auto* c = b.FunctionParam("c", ty.u32());
    auto* d = b.FunctionParam("d", ty.u32());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a, b_param, c, d});

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.vec2i(), spirv::BuiltinFn::kBitFieldInsert, a, b_param, c,
                                       d);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:vec2<i32>, %b:vec2<i32>, %c:u32, %d:u32):void {
  $B1: {
    %6:vec2<i32> = spirv.bit_field_insert %a, %b, %c, %d
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:vec2<i32>, %b:vec2<i32>, %c:u32, %d:u32):void {
  $B1: {
    %6:vec2<i32> = insertBits %a, %b, %c, %d
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, BitFieldInsert_IntVector_SignedOffsetAndCount) {
    auto* a = b.FunctionParam("a", ty.vec2i());
    auto* b_param = b.FunctionParam("b", ty.vec2i());
    auto* c = b.FunctionParam("c", ty.i32());
    auto* d = b.FunctionParam("d", ty.i32());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a, b_param, c, d});

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.vec2i(), spirv::BuiltinFn::kBitFieldInsert, a, b_param, c,
                                       d);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:vec2<i32>, %b:vec2<i32>, %c:i32, %d:i32):void {
  $B1: {
    %6:vec2<i32> = spirv.bit_field_insert %a, %b, %c, %d
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:vec2<i32>, %b:vec2<i32>, %c:i32, %d:i32):void {
  $B1: {
    %6:u32 = bitcast<u32> %c
    %7:u32 = bitcast<u32> %d
    %8:vec2<i32> = insertBits %a, %b, %6, %7
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, BitFieldInsert_Uint_UnsignedOffsetAndCount) {
    auto* a = b.FunctionParam("a", ty.u32());
    auto* b_param = b.FunctionParam("b", ty.u32());
    auto* c = b.FunctionParam("c", ty.u32());
    auto* d = b.FunctionParam("d", ty.u32());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a, b_param, c, d});

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.u32(), spirv::BuiltinFn::kBitFieldInsert, a, b_param, c,
                                       d);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:u32, %b:u32, %c:u32, %d:u32):void {
  $B1: {
    %6:u32 = spirv.bit_field_insert %a, %b, %c, %d
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:u32, %b:u32, %c:u32, %d:u32):void {
  $B1: {
    %6:u32 = insertBits %a, %b, %c, %d
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, BitFieldInsert_Uint_SignedOffsetAndCount) {
    auto* a = b.FunctionParam("a", ty.u32());
    auto* b_param = b.FunctionParam("b", ty.u32());
    auto* c = b.FunctionParam("c", ty.i32());
    auto* d = b.FunctionParam("d", ty.i32());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a, b_param, c, d});

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.u32(), spirv::BuiltinFn::kBitFieldInsert, a, b_param, c,
                                       d);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:u32, %b:u32, %c:i32, %d:i32):void {
  $B1: {
    %6:u32 = spirv.bit_field_insert %a, %b, %c, %d
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:u32, %b:u32, %c:i32, %d:i32):void {
  $B1: {
    %6:u32 = bitcast<u32> %c
    %7:u32 = bitcast<u32> %d
    %8:u32 = insertBits %a, %b, %6, %7
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, BitFieldInsert_UintVector_UnsignedOffsetAndCount) {
    auto* a = b.FunctionParam("a", ty.vec2u());
    auto* b_param = b.FunctionParam("b", ty.vec2u());
    auto* c = b.FunctionParam("c", ty.u32());
    auto* d = b.FunctionParam("d", ty.u32());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a, b_param, c, d});

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.vec2u(), spirv::BuiltinFn::kBitFieldInsert, a, b_param, c,
                                       d);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:vec2<u32>, %b:vec2<u32>, %c:u32, %d:u32):void {
  $B1: {
    %6:vec2<u32> = spirv.bit_field_insert %a, %b, %c, %d
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:vec2<u32>, %b:vec2<u32>, %c:u32, %d:u32):void {
  $B1: {
    %6:vec2<u32> = insertBits %a, %b, %c, %d
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, BitFieldInsert_UintVector_SignedOffsetAndCount) {
    auto* a = b.FunctionParam("a", ty.vec2u());
    auto* b_param = b.FunctionParam("b", ty.vec2u());
    auto* c = b.FunctionParam("c", ty.i32());
    auto* d = b.FunctionParam("d", ty.i32());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a, b_param, c, d});

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.vec2u(), spirv::BuiltinFn::kBitFieldInsert, a, b_param, c,
                                       d);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:vec2<u32>, %b:vec2<u32>, %c:i32, %d:i32):void {
  $B1: {
    %6:vec2<u32> = spirv.bit_field_insert %a, %b, %c, %d
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:vec2<u32>, %b:vec2<u32>, %c:i32, %d:i32):void {
  $B1: {
    %6:u32 = bitcast<u32> %c
    %7:u32 = bitcast<u32> %d
    %8:vec2<u32> = insertBits %a, %b, %6, %7
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, BitFieldInsert_Uint_SignedOffsetAndUnsignedCount) {
    auto* a = b.FunctionParam("a", ty.u32());
    auto* b_param = b.FunctionParam("b", ty.u32());
    auto* c = b.FunctionParam("c", ty.i32());
    auto* d = b.FunctionParam("d", ty.u32());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a, b_param, c, d});

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.u32(), spirv::BuiltinFn::kBitFieldInsert, a, b_param, c,
                                       d);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:u32, %b:u32, %c:i32, %d:u32):void {
  $B1: {
    %6:u32 = spirv.bit_field_insert %a, %b, %c, %d
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:u32, %b:u32, %c:i32, %d:u32):void {
  $B1: {
    %6:u32 = bitcast<u32> %c
    %7:u32 = insertBits %a, %b, %6, %d
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, BitFieldSExtract_Int_UnsignedOffsetAndCount) {
    auto* a = b.FunctionParam("a", ty.i32());
    auto* b_param = b.FunctionParam("b", ty.u32());
    auto* c = b.FunctionParam("c", ty.u32());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a, b_param, c});

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.i32(), spirv::BuiltinFn::kBitFieldSExtract, a, b_param,
                                       c);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:i32, %b:u32, %c:u32):void {
  $B1: {
    %5:i32 = spirv.bit_field_s_extract %a, %b, %c
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:i32, %b:u32, %c:u32):void {
  $B1: {
    %5:i32 = extractBits %a, %b, %c
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, BitFieldSExtract_Int_SignedOffsetAndCount) {
    auto* a = b.FunctionParam("a", ty.i32());
    auto* b_param = b.FunctionParam("b", ty.i32());
    auto* c = b.FunctionParam("c", ty.i32());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a, b_param, c});

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.i32(), spirv::BuiltinFn::kBitFieldSExtract, a, b_param,
                                       c);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:i32, %b:i32, %c:i32):void {
  $B1: {
    %5:i32 = spirv.bit_field_s_extract %a, %b, %c
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:i32, %b:i32, %c:i32):void {
  $B1: {
    %5:u32 = bitcast<u32> %b
    %6:u32 = bitcast<u32> %c
    %7:i32 = extractBits %a, %5, %6
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, BitFieldSExtract_IntVector_UnsignedOffsetAndCount) {
    auto* a = b.FunctionParam("a", ty.vec2i());
    auto* b_param = b.FunctionParam("b", ty.u32());
    auto* c = b.FunctionParam("c", ty.u32());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a, b_param, c});

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.vec2i(), spirv::BuiltinFn::kBitFieldSExtract, a, b_param,
                                       c);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:vec2<i32>, %b:u32, %c:u32):void {
  $B1: {
    %5:vec2<i32> = spirv.bit_field_s_extract %a, %b, %c
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:vec2<i32>, %b:u32, %c:u32):void {
  $B1: {
    %5:vec2<i32> = extractBits %a, %b, %c
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, BitFieldSExtract_IntVector_SignedOffsetAndCount) {
    auto* a = b.FunctionParam("a", ty.vec2i());
    auto* b_param = b.FunctionParam("b", ty.i32());
    auto* c = b.FunctionParam("c", ty.i32());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a, b_param, c});

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.vec2i(), spirv::BuiltinFn::kBitFieldSExtract, a, b_param,
                                       c);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:vec2<i32>, %b:i32, %c:i32):void {
  $B1: {
    %5:vec2<i32> = spirv.bit_field_s_extract %a, %b, %c
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:vec2<i32>, %b:i32, %c:i32):void {
  $B1: {
    %5:u32 = bitcast<u32> %b
    %6:u32 = bitcast<u32> %c
    %7:vec2<i32> = extractBits %a, %5, %6
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, BitFieldSExtract_IntVector_SignedOffsetAndUnsignedCount) {
    auto* a = b.FunctionParam("a", ty.vec2i());
    auto* b_param = b.FunctionParam("b", ty.i32());
    auto* c = b.FunctionParam("c", ty.u32());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a, b_param, c});

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.vec2i(), spirv::BuiltinFn::kBitFieldSExtract, a, b_param,
                                       c);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:vec2<i32>, %b:i32, %c:u32):void {
  $B1: {
    %5:vec2<i32> = spirv.bit_field_s_extract %a, %b, %c
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:vec2<i32>, %b:i32, %c:u32):void {
  $B1: {
    %5:u32 = bitcast<u32> %b
    %6:vec2<i32> = extractBits %a, %5, %c
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, BitFieldSExtract_Uint_UnsignedOffsetAndCount) {
    auto* a = b.FunctionParam("a", ty.u32());
    auto* b_param = b.FunctionParam("b", ty.u32());
    auto* c = b.FunctionParam("c", ty.u32());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a, b_param, c});

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.u32(), spirv::BuiltinFn::kBitFieldSExtract, a, b_param,
                                       c);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:u32, %b:u32, %c:u32):void {
  $B1: {
    %5:u32 = spirv.bit_field_s_extract %a, %b, %c
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:u32, %b:u32, %c:u32):void {
  $B1: {
    %5:i32 = bitcast<i32> %a
    %6:i32 = extractBits %5, %b, %c
    %7:u32 = bitcast<u32> %6
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, BitFieldSExtract_Uint_SignedOffsetAndCount) {
    auto* a = b.FunctionParam("a", ty.u32());
    auto* b_param = b.FunctionParam("b", ty.i32());
    auto* c = b.FunctionParam("c", ty.i32());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a, b_param, c});

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.u32(), spirv::BuiltinFn::kBitFieldSExtract, a, b_param,
                                       c);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:u32, %b:i32, %c:i32):void {
  $B1: {
    %5:u32 = spirv.bit_field_s_extract %a, %b, %c
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:u32, %b:i32, %c:i32):void {
  $B1: {
    %5:i32 = bitcast<i32> %a
    %6:u32 = bitcast<u32> %b
    %7:u32 = bitcast<u32> %c
    %8:i32 = extractBits %5, %6, %7
    %9:u32 = bitcast<u32> %8
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, BitFieldSExtract_UintVector_UnsignedOffsetAndCount) {
    auto* a = b.FunctionParam("a", ty.vec2u());
    auto* b_param = b.FunctionParam("b", ty.u32());
    auto* c = b.FunctionParam("c", ty.u32());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a, b_param, c});

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.vec2u(), spirv::BuiltinFn::kBitFieldSExtract, a, b_param,
                                       c);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:vec2<u32>, %b:u32, %c:u32):void {
  $B1: {
    %5:vec2<u32> = spirv.bit_field_s_extract %a, %b, %c
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:vec2<u32>, %b:u32, %c:u32):void {
  $B1: {
    %5:vec2<i32> = bitcast<vec2<i32>> %a
    %6:vec2<i32> = extractBits %5, %b, %c
    %7:vec2<u32> = bitcast<vec2<u32>> %6
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, BitFieldSExtract_UintVector_SignedOffsetAndCount) {
    auto* a = b.FunctionParam("a", ty.vec2u());
    auto* b_param = b.FunctionParam("b", ty.i32());
    auto* c = b.FunctionParam("c", ty.i32());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a, b_param, c});

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.vec2u(), spirv::BuiltinFn::kBitFieldSExtract, a, b_param,
                                       c);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:vec2<u32>, %b:i32, %c:i32):void {
  $B1: {
    %5:vec2<u32> = spirv.bit_field_s_extract %a, %b, %c
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:vec2<u32>, %b:i32, %c:i32):void {
  $B1: {
    %5:vec2<i32> = bitcast<vec2<i32>> %a
    %6:u32 = bitcast<u32> %b
    %7:u32 = bitcast<u32> %c
    %8:vec2<i32> = extractBits %5, %6, %7
    %9:vec2<u32> = bitcast<vec2<u32>> %8
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, BitFieldSExtract_UintVector_SignedOffsetAndUnsignedCount) {
    auto* a = b.FunctionParam("a", ty.vec2u());
    auto* b_param = b.FunctionParam("b", ty.i32());
    auto* c = b.FunctionParam("c", ty.u32());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a, b_param, c});

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.vec2u(), spirv::BuiltinFn::kBitFieldSExtract, a, b_param,
                                       c);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:vec2<u32>, %b:i32, %c:u32):void {
  $B1: {
    %5:vec2<u32> = spirv.bit_field_s_extract %a, %b, %c
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:vec2<u32>, %b:i32, %c:u32):void {
  $B1: {
    %5:vec2<i32> = bitcast<vec2<i32>> %a
    %6:u32 = bitcast<u32> %b
    %7:vec2<i32> = extractBits %5, %6, %c
    %8:vec2<u32> = bitcast<vec2<u32>> %7
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, BitFieldUExtract_Uint_UnsignedOffsetAndCount) {
    auto* a = b.FunctionParam("a", ty.u32());
    auto* b_param = b.FunctionParam("b", ty.u32());
    auto* c = b.FunctionParam("c", ty.u32());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a, b_param, c});

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.u32(), spirv::BuiltinFn::kBitFieldUExtract, a, b_param,
                                       c);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:u32, %b:u32, %c:u32):void {
  $B1: {
    %5:u32 = spirv.bit_field_u_extract %a, %b, %c
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:u32, %b:u32, %c:u32):void {
  $B1: {
    %5:u32 = extractBits %a, %b, %c
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, BitFieldUExtract_Uint_SignedOffsetAndCount) {
    auto* a = b.FunctionParam("a", ty.u32());
    auto* b_param = b.FunctionParam("b", ty.i32());
    auto* c = b.FunctionParam("c", ty.i32());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a, b_param, c});

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.u32(), spirv::BuiltinFn::kBitFieldUExtract, a, b_param,
                                       c);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:u32, %b:i32, %c:i32):void {
  $B1: {
    %5:u32 = spirv.bit_field_u_extract %a, %b, %c
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:u32, %b:i32, %c:i32):void {
  $B1: {
    %5:u32 = bitcast<u32> %b
    %6:u32 = bitcast<u32> %c
    %7:u32 = extractBits %a, %5, %6
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, BitFieldUExtract_UintVector_UnsignedOffsetAndCount) {
    auto* a = b.FunctionParam("a", ty.vec2u());
    auto* b_param = b.FunctionParam("b", ty.u32());
    auto* c = b.FunctionParam("c", ty.u32());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a, b_param, c});

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.vec2u(), spirv::BuiltinFn::kBitFieldUExtract, a, b_param,
                                       c);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:vec2<u32>, %b:u32, %c:u32):void {
  $B1: {
    %5:vec2<u32> = spirv.bit_field_u_extract %a, %b, %c
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:vec2<u32>, %b:u32, %c:u32):void {
  $B1: {
    %5:vec2<u32> = extractBits %a, %b, %c
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, BitFieldUExtract_UintVector_SignedOffsetAndCount) {
    auto* a = b.FunctionParam("a", ty.vec2u());
    auto* b_param = b.FunctionParam("b", ty.i32());
    auto* c = b.FunctionParam("c", ty.i32());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a, b_param, c});

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.vec2u(), spirv::BuiltinFn::kBitFieldUExtract, a, b_param,
                                       c);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:vec2<u32>, %b:i32, %c:i32):void {
  $B1: {
    %5:vec2<u32> = spirv.bit_field_u_extract %a, %b, %c
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:vec2<u32>, %b:i32, %c:i32):void {
  $B1: {
    %5:u32 = bitcast<u32> %b
    %6:u32 = bitcast<u32> %c
    %7:vec2<u32> = extractBits %a, %5, %6
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, BitFieldUExtract_UintVector_UnsignedOffsetAndSignedCount) {
    auto* a = b.FunctionParam("a", ty.vec2u());
    auto* b_param = b.FunctionParam("b", ty.u32());
    auto* c = b.FunctionParam("c", ty.i32());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a, b_param, c});

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.vec2u(), spirv::BuiltinFn::kBitFieldUExtract, a, b_param,
                                       c);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:vec2<u32>, %b:u32, %c:i32):void {
  $B1: {
    %5:vec2<u32> = spirv.bit_field_u_extract %a, %b, %c
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:vec2<u32>, %b:u32, %c:i32):void {
  $B1: {
    %5:u32 = bitcast<u32> %c
    %6:vec2<u32> = extractBits %a, %b, %5
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, BitFieldUExtract_Int_UnsignedOffsetAndCount) {
    auto* a = b.FunctionParam("a", ty.i32());
    auto* b_param = b.FunctionParam("b", ty.u32());
    auto* c = b.FunctionParam("c", ty.u32());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a, b_param, c});

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.i32(), spirv::BuiltinFn::kBitFieldUExtract, a, b_param,
                                       c);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:i32, %b:u32, %c:u32):void {
  $B1: {
    %5:i32 = spirv.bit_field_u_extract %a, %b, %c
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:i32, %b:u32, %c:u32):void {
  $B1: {
    %5:u32 = bitcast<u32> %a
    %6:u32 = extractBits %5, %b, %c
    %7:i32 = bitcast<i32> %6
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, BitFieldUExtract_Int_SignedOffsetAndCount) {
    auto* a = b.FunctionParam("a", ty.i32());
    auto* b_param = b.FunctionParam("b", ty.i32());
    auto* c = b.FunctionParam("c", ty.i32());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a, b_param, c});

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.i32(), spirv::BuiltinFn::kBitFieldUExtract, a, b_param,
                                       c);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:i32, %b:i32, %c:i32):void {
  $B1: {
    %5:i32 = spirv.bit_field_u_extract %a, %b, %c
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:i32, %b:i32, %c:i32):void {
  $B1: {
    %5:u32 = bitcast<u32> %a
    %6:u32 = bitcast<u32> %b
    %7:u32 = bitcast<u32> %c
    %8:u32 = extractBits %5, %6, %7
    %9:i32 = bitcast<i32> %8
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, BitFieldUExtract_IntVector_UnsignedOffsetAndCount) {
    auto* a = b.FunctionParam("a", ty.vec2i());
    auto* b_param = b.FunctionParam("b", ty.u32());
    auto* c = b.FunctionParam("c", ty.u32());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a, b_param, c});

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.vec2i(), spirv::BuiltinFn::kBitFieldUExtract, a, b_param,
                                       c);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:vec2<i32>, %b:u32, %c:u32):void {
  $B1: {
    %5:vec2<i32> = spirv.bit_field_u_extract %a, %b, %c
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:vec2<i32>, %b:u32, %c:u32):void {
  $B1: {
    %5:vec2<u32> = bitcast<vec2<u32>> %a
    %6:vec2<u32> = extractBits %5, %b, %c
    %7:vec2<i32> = bitcast<vec2<i32>> %6
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, BitFieldUExtract_IntVector_SignedOffsetAndCount) {
    auto* a = b.FunctionParam("a", ty.vec2i());
    auto* b_param = b.FunctionParam("b", ty.i32());
    auto* c = b.FunctionParam("c", ty.i32());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a, b_param, c});

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.vec2i(), spirv::BuiltinFn::kBitFieldUExtract, a, b_param,
                                       c);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:vec2<i32>, %b:i32, %c:i32):void {
  $B1: {
    %5:vec2<i32> = spirv.bit_field_u_extract %a, %b, %c
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:vec2<i32>, %b:i32, %c:i32):void {
  $B1: {
    %5:vec2<u32> = bitcast<vec2<u32>> %a
    %6:u32 = bitcast<u32> %b
    %7:u32 = bitcast<u32> %c
    %8:vec2<u32> = extractBits %5, %6, %7
    %9:vec2<i32> = bitcast<vec2<i32>> %8
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, BitFieldUExtract_IntVector_UnsignedOffsetAndSignedCount) {
    auto* a = b.FunctionParam("a", ty.vec2i());
    auto* b_param = b.FunctionParam("b", ty.u32());
    auto* c = b.FunctionParam("c", ty.i32());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a, b_param, c});

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.vec2i(), spirv::BuiltinFn::kBitFieldUExtract, a, b_param,
                                       c);
        b.Return(ep);
    });

    auto src = R"(
%foo = func(%a:vec2<i32>, %b:u32, %c:i32):void {
  $B1: {
    %5:vec2<i32> = spirv.bit_field_u_extract %a, %b, %c
    ret
  }
}
)";

    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%a:vec2<i32>, %b:u32, %c:i32):void {
  $B1: {
    %5:vec2<u32> = bitcast<vec2<u32>> %a
    %6:u32 = bitcast<u32> %c
    %7:vec2<u32> = extractBits %5, %b, %6
    %8:vec2<i32> = bitcast<vec2<i32>> %7
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, ConvertFToS_ScalarSigned) {
    auto* a = b.FunctionParam("a", ty.f32());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a});

    b.Append(ep->Block(), [&] {  //
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.i32(), spirv::BuiltinFn::kConvertFToS,
                                               Vector<core::ir::TemplateParameter, 1>{ty.i32()}, a);
        b.Return(ep);
    });

    auto* src = R"(
%foo = func(%a:f32):void {
  $B1: {
    %3:i32 = spirv.convert_f_to_s<i32> %a
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto* expect = R"(
%foo = func(%a:f32):void {
  $B1: {
    %3:i32 = convert %a
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, ConvertFToS_ScalarUnsigned) {
    auto* a = b.FunctionParam("a", ty.f32());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a});

    b.Append(ep->Block(), [&] {  //
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.u32(), spirv::BuiltinFn::kConvertFToS,
                                               Vector<core::ir::TemplateParameter, 1>{ty.u32()}, a);
        b.Return(ep);
    });

    auto* src = R"(
%foo = func(%a:f32):void {
  $B1: {
    %3:u32 = spirv.convert_f_to_s<u32> %a
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto* expect = R"(
%foo = func(%a:f32):void {
  $B1: {
    %3:i32 = convert %a
    %4:u32 = bitcast<u32> %3
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, ConvertFToS_VectorSigned) {
    auto* a = b.FunctionParam("a", ty.vec2f());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a});

    b.Append(ep->Block(), [&] {  //
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.vec2i(), spirv::BuiltinFn::kConvertFToS,
                                               Vector<core::ir::TemplateParameter, 1>{ty.i32()}, a);
        b.Return(ep);
    });

    auto* src = R"(
%foo = func(%a:vec2<f32>):void {
  $B1: {
    %3:vec2<i32> = spirv.convert_f_to_s<i32> %a
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto* expect = R"(
%foo = func(%a:vec2<f32>):void {
  $B1: {
    %3:vec2<i32> = convert %a
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, ConvertFToS_VectorUnsigned) {
    auto* a = b.FunctionParam("a", ty.vec2f());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a});

    b.Append(ep->Block(), [&] {  //
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.vec2u(), spirv::BuiltinFn::kConvertFToS,
                                               Vector<core::ir::TemplateParameter, 1>{ty.u32()}, a);
        b.Return(ep);
    });

    auto* src = R"(
%foo = func(%a:vec2<f32>):void {
  $B1: {
    %3:vec2<u32> = spirv.convert_f_to_s<u32> %a
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto* expect = R"(
%foo = func(%a:vec2<f32>):void {
  $B1: {
    %3:vec2<i32> = convert %a
    %4:vec2<u32> = bitcast<vec2<u32>> %3
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, ConvertSToF_ScalarSigned) {
    auto* a = b.FunctionParam("a", ty.i32());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a});

    b.Append(ep->Block(), [&] {  //
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.f32(), spirv::BuiltinFn::kConvertSToF,
                                               Vector<core::ir::TemplateParameter, 1>{ty.f32()}, a);
        b.Return(ep);
    });

    auto* src = R"(
%foo = func(%a:i32):void {
  $B1: {
    %3:f32 = spirv.convert_s_to_f<f32> %a
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto* expect = R"(
%foo = func(%a:i32):void {
  $B1: {
    %3:f32 = convert %a
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, ConvertSToF_ScalarUnsigned) {
    auto* a = b.FunctionParam("a", ty.u32());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a});

    b.Append(ep->Block(), [&] {  //
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.f32(), spirv::BuiltinFn::kConvertSToF,
                                               Vector<core::ir::TemplateParameter, 1>{ty.f32()}, a);
        b.Return(ep);
    });

    auto* src = R"(
%foo = func(%a:u32):void {
  $B1: {
    %3:f32 = spirv.convert_s_to_f<f32> %a
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto* expect = R"(
%foo = func(%a:u32):void {
  $B1: {
    %3:i32 = bitcast<i32> %a
    %4:f32 = convert %3
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, ConvertSToF_VectorSigned) {
    auto* a = b.FunctionParam("a", ty.vec2i());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a});

    b.Append(ep->Block(), [&] {  //
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.vec2f(), spirv::BuiltinFn::kConvertSToF,
                                               Vector<core::ir::TemplateParameter, 1>{ty.f32()}, a);
        b.Return(ep);
    });

    auto* src = R"(
%foo = func(%a:vec2<i32>):void {
  $B1: {
    %3:vec2<f32> = spirv.convert_s_to_f<f32> %a
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto* expect = R"(
%foo = func(%a:vec2<i32>):void {
  $B1: {
    %3:vec2<f32> = convert %a
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, ConvertSToF_VectorUnsigned) {
    auto* a = b.FunctionParam("a", ty.vec2u());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a});

    b.Append(ep->Block(), [&] {  //
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.vec2f(), spirv::BuiltinFn::kConvertSToF,
                                               Vector<core::ir::TemplateParameter, 1>{ty.f32()}, a);
        b.Return(ep);
    });

    auto* src = R"(
%foo = func(%a:vec2<u32>):void {
  $B1: {
    %3:vec2<f32> = spirv.convert_s_to_f<f32> %a
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto* expect = R"(
%foo = func(%a:vec2<u32>):void {
  $B1: {
    %3:vec2<i32> = bitcast<vec2<i32>> %a
    %4:vec2<f32> = convert %3
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, ConvertUToF_ScalarSigned) {
    auto* a = b.FunctionParam("a", ty.i32());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a});

    b.Append(ep->Block(), [&] {  //
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.f32(), spirv::BuiltinFn::kConvertUToF,
                                               Vector<core::ir::TemplateParameter, 1>{ty.f32()}, a);
        b.Return(ep);
    });

    auto* src = R"(
%foo = func(%a:i32):void {
  $B1: {
    %3:f32 = spirv.convert_u_to_f<f32> %a
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto* expect = R"(
%foo = func(%a:i32):void {
  $B1: {
    %3:u32 = bitcast<u32> %a
    %4:f32 = convert %3
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, ConvertUToF_ScalarUnsigned) {
    auto* a = b.FunctionParam("a", ty.u32());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a});

    b.Append(ep->Block(), [&] {  //
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.f32(), spirv::BuiltinFn::kConvertUToF,
                                               Vector<core::ir::TemplateParameter, 1>{ty.f32()}, a);
        b.Return(ep);
    });

    auto* src = R"(
%foo = func(%a:u32):void {
  $B1: {
    %3:f32 = spirv.convert_u_to_f<f32> %a
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto* expect = R"(
%foo = func(%a:u32):void {
  $B1: {
    %3:f32 = convert %a
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, ConvertUToF_VectorSigned) {
    auto* a = b.FunctionParam("a", ty.vec2i());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a});

    b.Append(ep->Block(), [&] {  //
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.vec2f(), spirv::BuiltinFn::kConvertUToF,
                                               Vector<core::ir::TemplateParameter, 1>{ty.f32()}, a);
        b.Return(ep);
    });

    auto* src = R"(
%foo = func(%a:vec2<i32>):void {
  $B1: {
    %3:vec2<f32> = spirv.convert_u_to_f<f32> %a
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto* expect = R"(
%foo = func(%a:vec2<i32>):void {
  $B1: {
    %3:vec2<u32> = bitcast<vec2<u32>> %a
    %4:vec2<f32> = convert %3
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, ConvertUToF_VectorUnsigned) {
    auto* a = b.FunctionParam("a", ty.vec2u());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({a});

    b.Append(ep->Block(), [&] {  //
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.vec2f(), spirv::BuiltinFn::kConvertUToF,
                                               Vector<core::ir::TemplateParameter, 1>{ty.f32()}, a);
        b.Return(ep);
    });

    auto* src = R"(
%foo = func(%a:vec2<u32>):void {
  $B1: {
    %3:vec2<f32> = spirv.convert_u_to_f<f32> %a
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto* expect = R"(
%foo = func(%a:vec2<u32>):void {
  $B1: {
    %3:vec2<f32> = convert %a
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

using SpirvReader_BitwiseTest = core::ir::transform::TransformTestWithParam<SpirvReaderParams>;

TEST_P(SpirvReader_BitwiseTest, Scalar_SignedSigned_Signed) {
    auto& params = GetParam();
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", 1_i);
        auto* y = b.Let("y", 2_i);
        b.CallExplicit<spirv::ir::BuiltinCall>(
            ty.i32(), params.fn, Vector<core::ir::TemplateParameter, 1>{ty.i32()}, x, y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:i32 = let 1i
    %y:i32 = let 2i
    %4:i32 = spirv.)" +
               params.spv_name + R"(<i32> %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:i32 = let 1i
    %y:i32 = let 2i
    %4:i32 = )" + params.wgsl_name +
                  R"( %x, %y
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_P(SpirvReader_BitwiseTest, Scalar_SignedUnsigned_Signed) {
    auto& params = GetParam();
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", 1_i);
        auto* y = b.Let("y", 8_u);
        b.CallExplicit<spirv::ir::BuiltinCall>(
            ty.i32(), params.fn, Vector<core::ir::TemplateParameter, 1>{ty.i32()}, x, y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:i32 = let 1i
    %y:u32 = let 8u
    %4:i32 = spirv.)" +
               params.spv_name + R"(<i32> %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:i32 = let 1i
    %y:u32 = let 8u
    %4:i32 = bitcast<i32> %y
    %5:i32 = )" + params.wgsl_name +
                  R"( %x, %4
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_P(SpirvReader_BitwiseTest, Scalar_UnsignedSigned_Signed) {
    auto& params = GetParam();
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", 8_u);
        auto* y = b.Let("y", 1_i);
        b.CallExplicit<spirv::ir::BuiltinCall>(
            ty.i32(), params.fn, Vector<core::ir::TemplateParameter, 1>{ty.i32()}, x, y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:u32 = let 8u
    %y:i32 = let 1i
    %4:i32 = spirv.)" +
               params.spv_name + R"(<i32> %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:u32 = let 8u
    %y:i32 = let 1i
    %4:u32 = bitcast<u32> %y
    %5:u32 = )" + params.wgsl_name +
                  R"( %x, %4
    %6:i32 = bitcast<i32> %5
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_P(SpirvReader_BitwiseTest, Scalar_UnsignedUnsigned_Signed) {
    auto& params = GetParam();
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", 8_u);
        auto* y = b.Let("y", 9_u);
        b.CallExplicit<spirv::ir::BuiltinCall>(
            ty.i32(), params.fn, Vector<core::ir::TemplateParameter, 1>{ty.i32()}, x, y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:u32 = let 8u
    %y:u32 = let 9u
    %4:i32 = spirv.)" +
               params.spv_name + R"(<i32> %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:u32 = let 8u
    %y:u32 = let 9u
    %4:u32 = )" + params.wgsl_name +
                  R"( %x, %y
    %5:i32 = bitcast<i32> %4
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_P(SpirvReader_BitwiseTest, Scalar_UnsignedUnsigned_Unsigned) {
    auto& params = GetParam();
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", 8_u);
        auto* y = b.Let("y", 9_u);
        b.CallExplicit<spirv::ir::BuiltinCall>(
            ty.u32(), params.fn, Vector<core::ir::TemplateParameter, 1>{ty.u32()}, x, y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:u32 = let 8u
    %y:u32 = let 9u
    %4:u32 = spirv.)" +
               params.spv_name + R"(<u32> %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:u32 = let 8u
    %y:u32 = let 9u
    %4:u32 = )" + params.wgsl_name +
                  R"( %x, %y
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_P(SpirvReader_BitwiseTest, Scalar_UnsignedSigned_Unsigned) {
    auto& params = GetParam();
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", 8_u);
        auto* y = b.Let("y", 1_i);
        b.CallExplicit<spirv::ir::BuiltinCall>(
            ty.u32(), params.fn, Vector<core::ir::TemplateParameter, 1>{ty.u32()}, x, y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:u32 = let 8u
    %y:i32 = let 1i
    %4:u32 = spirv.)" +
               params.spv_name + R"(<u32> %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:u32 = let 8u
    %y:i32 = let 1i
    %4:u32 = bitcast<u32> %y
    %5:u32 = )" + params.wgsl_name +
                  R"( %x, %4
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_P(SpirvReader_BitwiseTest, Scalar_SignedUnsigned_Unsigned) {
    auto& params = GetParam();
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", 1_i);
        auto* y = b.Let("y", 8_u);
        b.CallExplicit<spirv::ir::BuiltinCall>(
            ty.u32(), params.fn, Vector<core::ir::TemplateParameter, 1>{ty.u32()}, x, y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:i32 = let 1i
    %y:u32 = let 8u
    %4:u32 = spirv.)" +
               params.spv_name + R"(<u32> %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:i32 = let 1i
    %y:u32 = let 8u
    %4:i32 = bitcast<i32> %y
    %5:i32 = )" + params.wgsl_name +
                  R"( %x, %4
    %6:u32 = bitcast<u32> %5
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_P(SpirvReader_BitwiseTest, Scalar_SignedSigned_Unsigned) {
    auto& params = GetParam();
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", 1_i);
        auto* y = b.Let("y", 2_i);
        b.CallExplicit<spirv::ir::BuiltinCall>(
            ty.u32(), params.fn, Vector<core::ir::TemplateParameter, 1>{ty.u32()}, x, y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:i32 = let 1i
    %y:i32 = let 2i
    %4:u32 = spirv.)" +
               params.spv_name + R"(<u32> %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:i32 = let 1i
    %y:i32 = let 2i
    %4:i32 = )" + params.wgsl_name +
                  R"( %x, %y
    %5:u32 = bitcast<u32> %4
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_P(SpirvReader_BitwiseTest, Vector_SignedSigned_Signed) {
    auto& params = GetParam();
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", b.Splat<vec2<i32>>(1_i));
        auto* y = b.Let("y", b.Splat<vec2<i32>>(2_i));
        b.CallExplicit<spirv::ir::BuiltinCall>(
            ty.vec2i(), params.fn, Vector<core::ir::TemplateParameter, 1>{ty.i32()}, x, y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<i32> = let vec2<i32>(1i)
    %y:vec2<i32> = let vec2<i32>(2i)
    %4:vec2<i32> = spirv.)" +
               params.spv_name + R"(<i32> %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<i32> = let vec2<i32>(1i)
    %y:vec2<i32> = let vec2<i32>(2i)
    %4:vec2<i32> = )" +
                  params.wgsl_name + R"( %x, %y
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_P(SpirvReader_BitwiseTest, Vector_SignedUnsigned_Signed) {
    auto& params = GetParam();
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", b.Splat<vec2<i32>>(1_i));
        auto* y = b.Let("y", b.Splat<vec2<u32>>(8_u));
        b.CallExplicit<spirv::ir::BuiltinCall>(
            ty.vec2i(), params.fn, Vector<core::ir::TemplateParameter, 1>{ty.i32()}, x, y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<i32> = let vec2<i32>(1i)
    %y:vec2<u32> = let vec2<u32>(8u)
    %4:vec2<i32> = spirv.)" +
               params.spv_name + R"(<i32> %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<i32> = let vec2<i32>(1i)
    %y:vec2<u32> = let vec2<u32>(8u)
    %4:vec2<i32> = bitcast<vec2<i32>> %y
    %5:vec2<i32> = )" +
                  params.wgsl_name + R"( %x, %4
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_P(SpirvReader_BitwiseTest, Vector_UnsignedSigned_Signed) {
    auto& params = GetParam();
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", b.Splat<vec2<u32>>(8_u));
        auto* y = b.Let("y", b.Splat<vec2<i32>>(1_i));
        b.CallExplicit<spirv::ir::BuiltinCall>(
            ty.vec2i(), params.fn, Vector<core::ir::TemplateParameter, 1>{ty.i32()}, x, y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<u32> = let vec2<u32>(8u)
    %y:vec2<i32> = let vec2<i32>(1i)
    %4:vec2<i32> = spirv.)" +
               params.spv_name + R"(<i32> %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<u32> = let vec2<u32>(8u)
    %y:vec2<i32> = let vec2<i32>(1i)
    %4:vec2<u32> = bitcast<vec2<u32>> %y
    %5:vec2<u32> = )" +
                  params.wgsl_name + R"( %x, %4
    %6:vec2<i32> = bitcast<vec2<i32>> %5
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_P(SpirvReader_BitwiseTest, Vector_UnsignedUnsigned_Signed) {
    auto& params = GetParam();
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", b.Splat<vec2<u32>>(8_u));
        auto* y = b.Let("y", b.Splat<vec2<u32>>(9_u));
        b.CallExplicit<spirv::ir::BuiltinCall>(
            ty.vec2i(), params.fn, Vector<core::ir::TemplateParameter, 1>{ty.i32()}, x, y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<u32> = let vec2<u32>(8u)
    %y:vec2<u32> = let vec2<u32>(9u)
    %4:vec2<i32> = spirv.)" +
               params.spv_name + R"(<i32> %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<u32> = let vec2<u32>(8u)
    %y:vec2<u32> = let vec2<u32>(9u)
    %4:vec2<u32> = )" +
                  params.wgsl_name + R"( %x, %y
    %5:vec2<i32> = bitcast<vec2<i32>> %4
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_P(SpirvReader_BitwiseTest, Vector_UnsignedUnsigned_Unsigned) {
    auto& params = GetParam();
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", b.Splat<vec2<u32>>(8_u));
        auto* y = b.Let("y", b.Splat<vec2<u32>>(9_u));
        b.CallExplicit<spirv::ir::BuiltinCall>(
            ty.vec2u(), params.fn, Vector<core::ir::TemplateParameter, 1>{ty.u32()}, x, y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<u32> = let vec2<u32>(8u)
    %y:vec2<u32> = let vec2<u32>(9u)
    %4:vec2<u32> = spirv.)" +
               params.spv_name + R"(<u32> %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<u32> = let vec2<u32>(8u)
    %y:vec2<u32> = let vec2<u32>(9u)
    %4:vec2<u32> = )" +
                  params.wgsl_name + R"( %x, %y
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_P(SpirvReader_BitwiseTest, Vector_UnsignedSigned_Unsigned) {
    auto& params = GetParam();
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", b.Splat<vec2<u32>>(8_u));
        auto* y = b.Let("y", b.Splat<vec2<i32>>(1_i));
        b.CallExplicit<spirv::ir::BuiltinCall>(
            ty.vec2u(), params.fn, Vector<core::ir::TemplateParameter, 1>{ty.u32()}, x, y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<u32> = let vec2<u32>(8u)
    %y:vec2<i32> = let vec2<i32>(1i)
    %4:vec2<u32> = spirv.)" +
               params.spv_name + R"(<u32> %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<u32> = let vec2<u32>(8u)
    %y:vec2<i32> = let vec2<i32>(1i)
    %4:vec2<u32> = bitcast<vec2<u32>> %y
    %5:vec2<u32> = )" +
                  params.wgsl_name + R"( %x, %4
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_P(SpirvReader_BitwiseTest, Vector_SignedUnsigned_Unsigned) {
    auto& params = GetParam();
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", b.Splat<vec2<i32>>(1_i));
        auto* y = b.Let("y", b.Splat<vec2<u32>>(8_u));
        b.CallExplicit<spirv::ir::BuiltinCall>(
            ty.vec2u(), params.fn, Vector<core::ir::TemplateParameter, 1>{ty.u32()}, x, y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<i32> = let vec2<i32>(1i)
    %y:vec2<u32> = let vec2<u32>(8u)
    %4:vec2<u32> = spirv.)" +
               params.spv_name + R"(<u32> %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<i32> = let vec2<i32>(1i)
    %y:vec2<u32> = let vec2<u32>(8u)
    %4:vec2<i32> = bitcast<vec2<i32>> %y
    %5:vec2<i32> = )" +
                  params.wgsl_name + R"( %x, %4
    %6:vec2<u32> = bitcast<vec2<u32>> %5
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_P(SpirvReader_BitwiseTest, Vector_SignedSigned_Unsigned) {
    auto& params = GetParam();
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", b.Splat<vec2<i32>>(1_i));
        auto* y = b.Let("y", b.Splat<vec2<i32>>(2_i));
        b.CallExplicit<spirv::ir::BuiltinCall>(
            ty.vec2u(), params.fn, Vector<core::ir::TemplateParameter, 1>{ty.u32()}, x, y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<i32> = let vec2<i32>(1i)
    %y:vec2<i32> = let vec2<i32>(2i)
    %4:vec2<u32> = spirv.)" +
               params.spv_name + R"(<u32> %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<i32> = let vec2<i32>(1i)
    %y:vec2<i32> = let vec2<i32>(2i)
    %4:vec2<i32> = )" +
                  params.wgsl_name + R"( %x, %y
    %5:vec2<u32> = bitcast<vec2<u32>> %4
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}
INSTANTIATE_TEST_SUITE_P(
    SpirvReader,
    SpirvReader_BitwiseTest,
    ::testing::Values(SpirvReaderParams{spirv::BuiltinFn::kBitwiseAnd, "bitwise_and", "and"},
                      SpirvReaderParams{spirv::BuiltinFn::kBitwiseOr, "bitwise_or", "or"},
                      SpirvReaderParams{spirv::BuiltinFn::kBitwiseXor, "bitwise_xor", "xor"}));

using SpirvReader_IntegerTest = core::ir::transform::TransformTestWithParam<SpirvReaderParams>;
TEST_P(SpirvReader_IntegerTest, Scalar_SignedSigned) {
    auto param = GetParam();
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", 1_i);
        auto* y = b.Let("y", 2_i);
        b.Call<spirv::ir::BuiltinCall>(ty.bool_(), param.fn, x, y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:i32 = let 1i
    %y:i32 = let 2i
    %4:bool = spirv.)" +
               param.spv_name + R"( %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:i32 = let 1i
    %y:i32 = let 2i
    %4:bool = )" + param.wgsl_name +
                  R"( %x, %y
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_P(SpirvReader_IntegerTest, Scalar_SignedUnsigned) {
    auto param = GetParam();
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", 1_i);
        auto* y = b.Let("y", 8_u);
        b.Call<spirv::ir::BuiltinCall>(ty.bool_(), param.fn, x, y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:i32 = let 1i
    %y:u32 = let 8u
    %4:bool = spirv.)" +
               param.spv_name + R"( %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:i32 = let 1i
    %y:u32 = let 8u
    %4:i32 = bitcast<i32> %y
    %5:bool = )" + param.wgsl_name +
                  R"( %x, %4
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_P(SpirvReader_IntegerTest, Scalar_UnsignedSigned) {
    auto param = GetParam();
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", 8_u);
        auto* y = b.Let("y", 1_i);
        b.Call<spirv::ir::BuiltinCall>(ty.bool_(), param.fn, x, y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:u32 = let 8u
    %y:i32 = let 1i
    %4:bool = spirv.)" +
               param.spv_name + R"( %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:u32 = let 8u
    %y:i32 = let 1i
    %4:u32 = bitcast<u32> %y
    %5:bool = )" + param.wgsl_name +
                  R"( %x, %4
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_P(SpirvReader_IntegerTest, Scalar_UnsignedUnsigned) {
    auto param = GetParam();
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", 8_u);
        auto* y = b.Let("y", 9_u);
        b.Call<spirv::ir::BuiltinCall>(ty.bool_(), param.fn, x, y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:u32 = let 8u
    %y:u32 = let 9u
    %4:bool = spirv.)" +
               param.spv_name + R"( %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:u32 = let 8u
    %y:u32 = let 9u
    %4:bool = )" + param.wgsl_name +
                  R"( %x, %y
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_P(SpirvReader_IntegerTest, Vector_SignedSigned) {
    auto param = GetParam();
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", b.Splat<vec2<i32>>(1_i));
        auto* y = b.Let("y", b.Splat<vec2<i32>>(2_i));
        b.Call<spirv::ir::BuiltinCall>(ty.vec2<bool>(), param.fn, x, y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<i32> = let vec2<i32>(1i)
    %y:vec2<i32> = let vec2<i32>(2i)
    %4:vec2<bool> = spirv.)" +
               param.spv_name + R"( %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<i32> = let vec2<i32>(1i)
    %y:vec2<i32> = let vec2<i32>(2i)
    %4:vec2<bool> = )" +
                  param.wgsl_name + R"( %x, %y
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_P(SpirvReader_IntegerTest, Vector_SignedUnsigned) {
    auto param = GetParam();
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", b.Splat<vec2<i32>>(1_i));
        auto* y = b.Let("y", b.Splat<vec2<u32>>(8_u));
        b.Call<spirv::ir::BuiltinCall>(ty.vec2<bool>(), param.fn, x, y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<i32> = let vec2<i32>(1i)
    %y:vec2<u32> = let vec2<u32>(8u)
    %4:vec2<bool> = spirv.)" +
               param.spv_name + R"( %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<i32> = let vec2<i32>(1i)
    %y:vec2<u32> = let vec2<u32>(8u)
    %4:vec2<i32> = bitcast<vec2<i32>> %y
    %5:vec2<bool> = )" +
                  param.wgsl_name + R"( %x, %4
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_P(SpirvReader_IntegerTest, Vector_UnsignedSigned) {
    auto param = GetParam();
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", b.Splat<vec2<u32>>(8_u));
        auto* y = b.Let("y", b.Splat<vec2<i32>>(1_i));
        b.Call<spirv::ir::BuiltinCall>(ty.vec2<bool>(), param.fn, x, y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<u32> = let vec2<u32>(8u)
    %y:vec2<i32> = let vec2<i32>(1i)
    %4:vec2<bool> = spirv.)" +
               param.spv_name + R"( %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<u32> = let vec2<u32>(8u)
    %y:vec2<i32> = let vec2<i32>(1i)
    %4:vec2<u32> = bitcast<vec2<u32>> %y
    %5:vec2<bool> = )" +
                  param.wgsl_name + R"( %x, %4
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_P(SpirvReader_IntegerTest, Vector_UnsignedUnsigned) {
    auto param = GetParam();
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", b.Splat<vec2<u32>>(8_u));
        auto* y = b.Let("y", b.Splat<vec2<u32>>(9_u));
        b.Call<spirv::ir::BuiltinCall>(ty.vec2<bool>(), param.fn, x, y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<u32> = let vec2<u32>(8u)
    %y:vec2<u32> = let vec2<u32>(9u)
    %4:vec2<bool> = spirv.)" +
               param.spv_name + R"( %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<u32> = let vec2<u32>(8u)
    %y:vec2<u32> = let vec2<u32>(9u)
    %4:vec2<bool> = )" +
                  param.wgsl_name + R"( %x, %y
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}
INSTANTIATE_TEST_SUITE_P(
    SpirvReader,
    SpirvReader_IntegerTest,
    ::testing::Values(SpirvReaderParams{spirv::BuiltinFn::kEqual, "equal", "eq"},
                      SpirvReaderParams{spirv::BuiltinFn::kNotEqual, "not_equal", "neq"}));

using SpirvReader_SignedIntegerTest =
    core::ir::transform::TransformTestWithParam<SpirvReaderParams>;
TEST_P(SpirvReader_SignedIntegerTest, Scalar_SignedSigned) {
    auto param = GetParam();
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", 1_i);
        auto* y = b.Let("y", 2_i);
        b.Call<spirv::ir::BuiltinCall>(ty.bool_(), param.fn, x, y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:i32 = let 1i
    %y:i32 = let 2i
    %4:bool = spirv.)" +
               param.spv_name + R"( %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:i32 = let 1i
    %y:i32 = let 2i
    %4:bool = )" + param.wgsl_name +
                  R"( %x, %y
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_P(SpirvReader_SignedIntegerTest, Scalar_SignedUnsigned) {
    auto param = GetParam();
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", 1_i);
        auto* y = b.Let("y", 8_u);
        b.Call<spirv::ir::BuiltinCall>(ty.bool_(), param.fn, x, y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:i32 = let 1i
    %y:u32 = let 8u
    %4:bool = spirv.)" +
               param.spv_name + R"( %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:i32 = let 1i
    %y:u32 = let 8u
    %4:i32 = bitcast<i32> %y
    %5:bool = )" + param.wgsl_name +
                  R"( %x, %4
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_P(SpirvReader_SignedIntegerTest, Scalar_UnsignedSigned) {
    auto param = GetParam();
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", 8_u);
        auto* y = b.Let("y", 1_i);
        b.Call<spirv::ir::BuiltinCall>(ty.bool_(), param.fn, x, y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:u32 = let 8u
    %y:i32 = let 1i
    %4:bool = spirv.)" +
               param.spv_name + R"( %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:u32 = let 8u
    %y:i32 = let 1i
    %4:i32 = bitcast<i32> %x
    %5:bool = )" + param.wgsl_name +
                  R"( %4, %y
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_P(SpirvReader_SignedIntegerTest, Scalar_UnsignedUnsigned) {
    auto param = GetParam();
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", 8_u);
        auto* y = b.Let("y", 9_u);
        b.Call<spirv::ir::BuiltinCall>(ty.bool_(), param.fn, x, y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:u32 = let 8u
    %y:u32 = let 9u
    %4:bool = spirv.)" +
               param.spv_name + R"( %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:u32 = let 8u
    %y:u32 = let 9u
    %4:i32 = bitcast<i32> %x
    %5:i32 = bitcast<i32> %y
    %6:bool = )" + param.wgsl_name +
                  R"( %4, %5
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_P(SpirvReader_SignedIntegerTest, Vector_SignedSigned) {
    auto param = GetParam();
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", b.Splat<vec2<i32>>(1_i));
        auto* y = b.Let("y", b.Splat<vec2<i32>>(2_i));
        b.Call<spirv::ir::BuiltinCall>(ty.vec2<bool>(), param.fn, x, y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<i32> = let vec2<i32>(1i)
    %y:vec2<i32> = let vec2<i32>(2i)
    %4:vec2<bool> = spirv.)" +
               param.spv_name + R"( %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<i32> = let vec2<i32>(1i)
    %y:vec2<i32> = let vec2<i32>(2i)
    %4:vec2<bool> = )" +
                  param.wgsl_name + R"( %x, %y
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_P(SpirvReader_SignedIntegerTest, Vector_SignedUnsigned) {
    auto param = GetParam();
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", b.Splat<vec2<i32>>(1_i));
        auto* y = b.Let("y", b.Splat<vec2<u32>>(8_u));
        b.Call<spirv::ir::BuiltinCall>(ty.vec2<bool>(), param.fn, x, y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<i32> = let vec2<i32>(1i)
    %y:vec2<u32> = let vec2<u32>(8u)
    %4:vec2<bool> = spirv.)" +
               param.spv_name + R"( %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<i32> = let vec2<i32>(1i)
    %y:vec2<u32> = let vec2<u32>(8u)
    %4:vec2<i32> = bitcast<vec2<i32>> %y
    %5:vec2<bool> = )" +
                  param.wgsl_name + R"( %x, %4
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_P(SpirvReader_SignedIntegerTest, Vector_UnsignedSigned) {
    auto param = GetParam();
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", b.Splat<vec2<u32>>(8_u));
        auto* y = b.Let("y", b.Splat<vec2<i32>>(1_i));
        b.Call<spirv::ir::BuiltinCall>(ty.vec2<bool>(), param.fn, x, y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<u32> = let vec2<u32>(8u)
    %y:vec2<i32> = let vec2<i32>(1i)
    %4:vec2<bool> = spirv.)" +
               param.spv_name + R"( %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<u32> = let vec2<u32>(8u)
    %y:vec2<i32> = let vec2<i32>(1i)
    %4:vec2<i32> = bitcast<vec2<i32>> %x
    %5:vec2<bool> = )" +
                  param.wgsl_name + R"( %4, %y
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_P(SpirvReader_SignedIntegerTest, Vector_UnsignedUnsigned) {
    auto param = GetParam();
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", b.Splat<vec2<u32>>(8_u));
        auto* y = b.Let("y", b.Splat<vec2<u32>>(9_u));
        b.Call<spirv::ir::BuiltinCall>(ty.vec2<bool>(), param.fn, x, y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<u32> = let vec2<u32>(8u)
    %y:vec2<u32> = let vec2<u32>(9u)
    %4:vec2<bool> = spirv.)" +
               param.spv_name + R"( %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<u32> = let vec2<u32>(8u)
    %y:vec2<u32> = let vec2<u32>(9u)
    %4:vec2<i32> = bitcast<vec2<i32>> %x
    %5:vec2<i32> = bitcast<vec2<i32>> %y
    %6:vec2<bool> = )" +
                  param.wgsl_name + R"( %4, %5
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}
INSTANTIATE_TEST_SUITE_P(
    SpirvReader,
    SpirvReader_SignedIntegerTest,
    ::testing::Values(
        SpirvReaderParams{spirv::BuiltinFn::kSGreaterThan, "s_greater_than", "gt"},
        SpirvReaderParams{spirv::BuiltinFn::kSGreaterThanEqual, "s_greater_than_equal", "gte"},
        SpirvReaderParams{spirv::BuiltinFn::kSLessThan, "s_less_than", "lt"},
        SpirvReaderParams{spirv::BuiltinFn::kSLessThanEqual, "s_less_than_equal", "lte"}));

using SpirvReader_UnsignedIntegerTest =
    core::ir::transform::TransformTestWithParam<SpirvReaderParams>;
TEST_P(SpirvReader_UnsignedIntegerTest, Scalar_SignedSigned) {
    auto param = GetParam();
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", 1_i);
        auto* y = b.Let("y", 2_i);
        b.Call<spirv::ir::BuiltinCall>(ty.bool_(), param.fn, x, y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:i32 = let 1i
    %y:i32 = let 2i
    %4:bool = spirv.)" +
               param.spv_name + R"( %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:i32 = let 1i
    %y:i32 = let 2i
    %4:u32 = bitcast<u32> %x
    %5:u32 = bitcast<u32> %y
    %6:bool = )" + param.wgsl_name +
                  R"( %4, %5
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_P(SpirvReader_UnsignedIntegerTest, Scalar_SignedUnsigned) {
    auto param = GetParam();
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", 1_i);
        auto* y = b.Let("y", 8_u);
        b.Call<spirv::ir::BuiltinCall>(ty.bool_(), param.fn, x, y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:i32 = let 1i
    %y:u32 = let 8u
    %4:bool = spirv.)" +
               param.spv_name + R"( %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:i32 = let 1i
    %y:u32 = let 8u
    %4:u32 = bitcast<u32> %x
    %5:bool = )" + param.wgsl_name +
                  R"( %4, %y
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_P(SpirvReader_UnsignedIntegerTest, Scalar_UnsignedSigned) {
    auto param = GetParam();
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", 8_u);
        auto* y = b.Let("y", 1_i);
        b.Call<spirv::ir::BuiltinCall>(ty.bool_(), param.fn, x, y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:u32 = let 8u
    %y:i32 = let 1i
    %4:bool = spirv.)" +
               param.spv_name + R"( %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:u32 = let 8u
    %y:i32 = let 1i
    %4:u32 = bitcast<u32> %y
    %5:bool = )" + param.wgsl_name +
                  R"( %x, %4
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_P(SpirvReader_UnsignedIntegerTest, Scalar_UnsignedUnsigned) {
    auto param = GetParam();
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", 8_u);
        auto* y = b.Let("y", 9_u);
        b.Call<spirv::ir::BuiltinCall>(ty.bool_(), param.fn, x, y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:u32 = let 8u
    %y:u32 = let 9u
    %4:bool = spirv.)" +
               param.spv_name + R"( %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:u32 = let 8u
    %y:u32 = let 9u
    %4:bool = )" + param.wgsl_name +
                  R"( %x, %y
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_P(SpirvReader_UnsignedIntegerTest, Vector_SignedSigned) {
    auto param = GetParam();
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", b.Splat<vec2<i32>>(1_i));
        auto* y = b.Let("y", b.Splat<vec2<i32>>(2_i));
        b.Call<spirv::ir::BuiltinCall>(ty.vec2<bool>(), param.fn, x, y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<i32> = let vec2<i32>(1i)
    %y:vec2<i32> = let vec2<i32>(2i)
    %4:vec2<bool> = spirv.)" +
               param.spv_name + R"( %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<i32> = let vec2<i32>(1i)
    %y:vec2<i32> = let vec2<i32>(2i)
    %4:vec2<u32> = bitcast<vec2<u32>> %x
    %5:vec2<u32> = bitcast<vec2<u32>> %y
    %6:vec2<bool> = )" +
                  param.wgsl_name + R"( %4, %5
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_P(SpirvReader_UnsignedIntegerTest, Vector_SignedUnsigned) {
    auto param = GetParam();
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", b.Splat<vec2<i32>>(1_i));
        auto* y = b.Let("y", b.Splat<vec2<u32>>(8_u));
        b.Call<spirv::ir::BuiltinCall>(ty.vec2<bool>(), param.fn, x, y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<i32> = let vec2<i32>(1i)
    %y:vec2<u32> = let vec2<u32>(8u)
    %4:vec2<bool> = spirv.)" +
               param.spv_name + R"( %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<i32> = let vec2<i32>(1i)
    %y:vec2<u32> = let vec2<u32>(8u)
    %4:vec2<u32> = bitcast<vec2<u32>> %x
    %5:vec2<bool> = )" +
                  param.wgsl_name + R"( %4, %y
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_P(SpirvReader_UnsignedIntegerTest, Vector_UnsignedSigned) {
    auto param = GetParam();
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", b.Splat<vec2<u32>>(8_u));
        auto* y = b.Let("y", b.Splat<vec2<i32>>(1_i));
        b.Call<spirv::ir::BuiltinCall>(ty.vec2<bool>(), param.fn, x, y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<u32> = let vec2<u32>(8u)
    %y:vec2<i32> = let vec2<i32>(1i)
    %4:vec2<bool> = spirv.)" +
               param.spv_name + R"( %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<u32> = let vec2<u32>(8u)
    %y:vec2<i32> = let vec2<i32>(1i)
    %4:vec2<u32> = bitcast<vec2<u32>> %y
    %5:vec2<bool> = )" +
                  param.wgsl_name + R"( %x, %4
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_P(SpirvReader_UnsignedIntegerTest, Vector_UnsignedUnsigned) {
    auto param = GetParam();
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", b.Splat<vec2<u32>>(8_u));
        auto* y = b.Let("y", b.Splat<vec2<u32>>(9_u));
        b.Call<spirv::ir::BuiltinCall>(ty.vec2<bool>(), param.fn, x, y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<u32> = let vec2<u32>(8u)
    %y:vec2<u32> = let vec2<u32>(9u)
    %4:vec2<bool> = spirv.)" +
               param.spv_name + R"( %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<u32> = let vec2<u32>(8u)
    %y:vec2<u32> = let vec2<u32>(9u)
    %4:vec2<bool> = )" +
                  param.wgsl_name + R"( %x, %y
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}
INSTANTIATE_TEST_SUITE_P(
    SpirvReader,
    SpirvReader_UnsignedIntegerTest,
    ::testing::Values(
        SpirvReaderParams{spirv::BuiltinFn::kUGreaterThan, "u_greater_than", "gt"},
        SpirvReaderParams{spirv::BuiltinFn::kUGreaterThanEqual, "u_greater_than_equal", "gte"},
        SpirvReaderParams{spirv::BuiltinFn::kULessThan, "u_less_than", "lt"},
        SpirvReaderParams{spirv::BuiltinFn::kULessThanEqual, "u_less_than_equal", "lte"}));

TEST_F(SpirvReader_BuiltinsTest, ShiftLeftLogical_Scalar_UnsignedUnsigned_Unsigned) {
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", 8_u);
        auto* y = b.Let("y", 9_u);
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.u32(), spirv::BuiltinFn::kShiftLeftLogical,
                                               Vector<core::ir::TemplateParameter, 1>{ty.u32()}, x,
                                               y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:u32 = let 8u
    %y:u32 = let 9u
    %4:u32 = spirv.shift_left_logical<u32> %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:u32 = let 8u
    %y:u32 = let 9u
    %4:u32 = shl %x, %y
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, ShiftLeftLogical_Scalar_UnsignedSigned_Unsigned) {
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", 8_u);
        auto* y = b.Let("y", 1_i);
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.u32(), spirv::BuiltinFn::kShiftLeftLogical,
                                               Vector<core::ir::TemplateParameter, 1>{ty.u32()}, x,
                                               y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:u32 = let 8u
    %y:i32 = let 1i
    %4:u32 = spirv.shift_left_logical<u32> %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:u32 = let 8u
    %y:i32 = let 1i
    %4:u32 = bitcast<u32> %y
    %5:u32 = shl %x, %4
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, ShiftLeftLogical_Scalar_SignedUnsigned_Unsigned) {
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", 1_i);
        auto* y = b.Let("y", 9_u);
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.u32(), spirv::BuiltinFn::kShiftLeftLogical,
                                               Vector<core::ir::TemplateParameter, 1>{ty.u32()}, x,
                                               y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:i32 = let 1i
    %y:u32 = let 9u
    %4:u32 = spirv.shift_left_logical<u32> %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:i32 = let 1i
    %y:u32 = let 9u
    %4:i32 = shl %x, %y
    %5:u32 = bitcast<u32> %4
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, ShiftLeftLogical_Scalar_SignedSigned_Unsigned) {
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", 1_i);
        auto* y = b.Let("y", 2_i);
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.u32(), spirv::BuiltinFn::kShiftLeftLogical,
                                               Vector<core::ir::TemplateParameter, 1>{ty.u32()}, x,
                                               y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:i32 = let 1i
    %y:i32 = let 2i
    %4:u32 = spirv.shift_left_logical<u32> %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:i32 = let 1i
    %y:i32 = let 2i
    %4:u32 = bitcast<u32> %y
    %5:i32 = shl %x, %4
    %6:u32 = bitcast<u32> %5
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, ShiftLeftLogical_Scalar_UnsignedUnsigned_Signed) {
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", 8_u);
        auto* y = b.Let("y", 9_u);
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.i32(), spirv::BuiltinFn::kShiftLeftLogical,
                                               Vector<core::ir::TemplateParameter, 1>{ty.i32()}, x,
                                               y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:u32 = let 8u
    %y:u32 = let 9u
    %4:i32 = spirv.shift_left_logical<i32> %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:u32 = let 8u
    %y:u32 = let 9u
    %4:u32 = shl %x, %y
    %5:i32 = bitcast<i32> %4
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, ShiftLeftLogical_Scalar_UnsignedSigned_Signed) {
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", 8_u);
        auto* y = b.Let("y", 1_i);
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.i32(), spirv::BuiltinFn::kShiftLeftLogical,
                                               Vector<core::ir::TemplateParameter, 1>{ty.i32()}, x,
                                               y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:u32 = let 8u
    %y:i32 = let 1i
    %4:i32 = spirv.shift_left_logical<i32> %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:u32 = let 8u
    %y:i32 = let 1i
    %4:u32 = bitcast<u32> %y
    %5:u32 = shl %x, %4
    %6:i32 = bitcast<i32> %5
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, ShiftLeftLogical_Scalar_SignedUnsigned_Signed) {
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", 1_i);
        auto* y = b.Let("y", 9_u);
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.i32(), spirv::BuiltinFn::kShiftLeftLogical,
                                               Vector<core::ir::TemplateParameter, 1>{ty.i32()}, x,
                                               y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:i32 = let 1i
    %y:u32 = let 9u
    %4:i32 = spirv.shift_left_logical<i32> %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:i32 = let 1i
    %y:u32 = let 9u
    %4:i32 = shl %x, %y
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, ShiftLeftLogical_Scalar_SignedSigned_Signed) {
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", 1_i);
        auto* y = b.Let("y", 2_i);
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.i32(), spirv::BuiltinFn::kShiftLeftLogical,
                                               Vector<core::ir::TemplateParameter, 1>{ty.i32()}, x,
                                               y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:i32 = let 1i
    %y:i32 = let 2i
    %4:i32 = spirv.shift_left_logical<i32> %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:i32 = let 1i
    %y:i32 = let 2i
    %4:u32 = bitcast<u32> %y
    %5:i32 = shl %x, %4
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, ShiftLeftLogical_Vector_UnsignedUnsigned_Unsigned) {
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", b.Splat<vec2<u32>>(8_u));
        auto* y = b.Let("y", b.Splat<vec2<u32>>(9_u));
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.vec2u(), spirv::BuiltinFn::kShiftLeftLogical,
                                               Vector<core::ir::TemplateParameter, 1>{ty.u32()}, x,
                                               y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<u32> = let vec2<u32>(8u)
    %y:vec2<u32> = let vec2<u32>(9u)
    %4:vec2<u32> = spirv.shift_left_logical<u32> %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<u32> = let vec2<u32>(8u)
    %y:vec2<u32> = let vec2<u32>(9u)
    %4:vec2<u32> = shl %x, %y
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, ShiftLeftLogical_Vector_UnsignedSigned_Unsigned) {
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", b.Splat<vec2<u32>>(8_u));
        auto* y = b.Let("y", b.Splat<vec2<i32>>(1_i));
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.vec2u(), spirv::BuiltinFn::kShiftLeftLogical,
                                               Vector<core::ir::TemplateParameter, 1>{ty.u32()}, x,
                                               y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<u32> = let vec2<u32>(8u)
    %y:vec2<i32> = let vec2<i32>(1i)
    %4:vec2<u32> = spirv.shift_left_logical<u32> %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<u32> = let vec2<u32>(8u)
    %y:vec2<i32> = let vec2<i32>(1i)
    %4:vec2<u32> = bitcast<vec2<u32>> %y
    %5:vec2<u32> = shl %x, %4
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, ShiftLeftLogical_Vector_SignedUnsigned_Unsigned) {
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", b.Splat<vec2<i32>>(1_i));
        auto* y = b.Let("y", b.Splat<vec2<u32>>(9_u));
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.vec2u(), spirv::BuiltinFn::kShiftLeftLogical,
                                               Vector<core::ir::TemplateParameter, 1>{ty.u32()}, x,
                                               y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<i32> = let vec2<i32>(1i)
    %y:vec2<u32> = let vec2<u32>(9u)
    %4:vec2<u32> = spirv.shift_left_logical<u32> %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<i32> = let vec2<i32>(1i)
    %y:vec2<u32> = let vec2<u32>(9u)
    %4:vec2<i32> = shl %x, %y
    %5:vec2<u32> = bitcast<vec2<u32>> %4
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, ShiftLeftLogical_Vector_SignedSigned_Unsigned) {
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", b.Splat<vec2<i32>>(1_i));
        auto* y = b.Let("y", b.Splat<vec2<i32>>(2_i));
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.vec2u(), spirv::BuiltinFn::kShiftLeftLogical,
                                               Vector<core::ir::TemplateParameter, 1>{ty.u32()}, x,
                                               y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<i32> = let vec2<i32>(1i)
    %y:vec2<i32> = let vec2<i32>(2i)
    %4:vec2<u32> = spirv.shift_left_logical<u32> %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<i32> = let vec2<i32>(1i)
    %y:vec2<i32> = let vec2<i32>(2i)
    %4:vec2<u32> = bitcast<vec2<u32>> %y
    %5:vec2<i32> = shl %x, %4
    %6:vec2<u32> = bitcast<vec2<u32>> %5
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, ShiftLeftLogical_Vector_UnsignedUnsigned_Signed) {
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", b.Splat<vec2<u32>>(8_u));
        auto* y = b.Let("y", b.Splat<vec2<u32>>(9_u));
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.vec2i(), spirv::BuiltinFn::kShiftLeftLogical,
                                               Vector<core::ir::TemplateParameter, 1>{ty.i32()}, x,
                                               y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<u32> = let vec2<u32>(8u)
    %y:vec2<u32> = let vec2<u32>(9u)
    %4:vec2<i32> = spirv.shift_left_logical<i32> %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<u32> = let vec2<u32>(8u)
    %y:vec2<u32> = let vec2<u32>(9u)
    %4:vec2<u32> = shl %x, %y
    %5:vec2<i32> = bitcast<vec2<i32>> %4
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, ShiftLeftLogical_Vector_UnsignedSigned_Signed) {
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", b.Splat<vec2<u32>>(8_u));
        auto* y = b.Let("y", b.Splat<vec2<i32>>(1_i));
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.vec2i(), spirv::BuiltinFn::kShiftLeftLogical,
                                               Vector<core::ir::TemplateParameter, 1>{ty.i32()}, x,
                                               y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<u32> = let vec2<u32>(8u)
    %y:vec2<i32> = let vec2<i32>(1i)
    %4:vec2<i32> = spirv.shift_left_logical<i32> %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<u32> = let vec2<u32>(8u)
    %y:vec2<i32> = let vec2<i32>(1i)
    %4:vec2<u32> = bitcast<vec2<u32>> %y
    %5:vec2<u32> = shl %x, %4
    %6:vec2<i32> = bitcast<vec2<i32>> %5
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, ShiftLeftLogical_Vector_SignedUnsigned_Signed) {
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", b.Splat<vec2<i32>>(1_i));
        auto* y = b.Let("y", b.Splat<vec2<u32>>(9_u));
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.vec2i(), spirv::BuiltinFn::kShiftLeftLogical,
                                               Vector<core::ir::TemplateParameter, 1>{ty.i32()}, x,
                                               y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<i32> = let vec2<i32>(1i)
    %y:vec2<u32> = let vec2<u32>(9u)
    %4:vec2<i32> = spirv.shift_left_logical<i32> %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<i32> = let vec2<i32>(1i)
    %y:vec2<u32> = let vec2<u32>(9u)
    %4:vec2<i32> = shl %x, %y
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, ShiftLeftLogical_Vector_SignedSigned_Signed) {
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", b.Splat<vec2<i32>>(1_i));
        auto* y = b.Let("y", b.Splat<vec2<i32>>(2_i));
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.vec2i(), spirv::BuiltinFn::kShiftLeftLogical,
                                               Vector<core::ir::TemplateParameter, 1>{ty.i32()}, x,
                                               y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<i32> = let vec2<i32>(1i)
    %y:vec2<i32> = let vec2<i32>(2i)
    %4:vec2<i32> = spirv.shift_left_logical<i32> %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<i32> = let vec2<i32>(1i)
    %y:vec2<i32> = let vec2<i32>(2i)
    %4:vec2<u32> = bitcast<vec2<u32>> %y
    %5:vec2<i32> = shl %x, %4
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, ShiftRightLogical_Scalar_UnsignedUnsigned_Unsigned) {
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", 8_u);
        auto* y = b.Let("y", 9_u);
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.u32(), spirv::BuiltinFn::kShiftRightLogical,
                                               Vector<core::ir::TemplateParameter, 1>{ty.u32()}, x,
                                               y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:u32 = let 8u
    %y:u32 = let 9u
    %4:u32 = spirv.shift_right_logical<u32> %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:u32 = let 8u
    %y:u32 = let 9u
    %4:u32 = shr %x, %y
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, ShiftRightLogical_Scalar_UnsignedSigned_Unsigned) {
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", 8_u);
        auto* y = b.Let("y", 1_i);
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.u32(), spirv::BuiltinFn::kShiftRightLogical,
                                               Vector<core::ir::TemplateParameter, 1>{ty.u32()}, x,
                                               y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:u32 = let 8u
    %y:i32 = let 1i
    %4:u32 = spirv.shift_right_logical<u32> %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:u32 = let 8u
    %y:i32 = let 1i
    %4:u32 = bitcast<u32> %y
    %5:u32 = shr %x, %4
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, ShiftRightLogical_Scalar_SignedUnsigned_Unsigned) {
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", 1_i);
        auto* y = b.Let("y", 9_u);
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.u32(), spirv::BuiltinFn::kShiftRightLogical,
                                               Vector<core::ir::TemplateParameter, 1>{ty.u32()}, x,
                                               y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:i32 = let 1i
    %y:u32 = let 9u
    %4:u32 = spirv.shift_right_logical<u32> %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:i32 = let 1i
    %y:u32 = let 9u
    %4:u32 = bitcast<u32> %x
    %5:u32 = shr %4, %y
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, ShiftRightLogical_Scalar_SignedSigned_Unsigned) {
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", 1_i);
        auto* y = b.Let("y", 2_i);
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.u32(), spirv::BuiltinFn::kShiftRightLogical,
                                               Vector<core::ir::TemplateParameter, 1>{ty.u32()}, x,
                                               y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:i32 = let 1i
    %y:i32 = let 2i
    %4:u32 = spirv.shift_right_logical<u32> %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:i32 = let 1i
    %y:i32 = let 2i
    %4:u32 = bitcast<u32> %x
    %5:u32 = bitcast<u32> %y
    %6:u32 = shr %4, %5
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, ShiftRightLogical_Scalar_UnsignedUnsigned_Signed) {
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", 8_u);
        auto* y = b.Let("y", 9_u);
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.i32(), spirv::BuiltinFn::kShiftRightLogical,
                                               Vector<core::ir::TemplateParameter, 1>{ty.i32()}, x,
                                               y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:u32 = let 8u
    %y:u32 = let 9u
    %4:i32 = spirv.shift_right_logical<i32> %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:u32 = let 8u
    %y:u32 = let 9u
    %4:u32 = shr %x, %y
    %5:i32 = bitcast<i32> %4
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, ShiftRightLogical_Scalar_UnsignedSigned_Signed) {
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", 8_u);
        auto* y = b.Let("y", 1_i);
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.i32(), spirv::BuiltinFn::kShiftRightLogical,
                                               Vector<core::ir::TemplateParameter, 1>{ty.i32()}, x,
                                               y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:u32 = let 8u
    %y:i32 = let 1i
    %4:i32 = spirv.shift_right_logical<i32> %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:u32 = let 8u
    %y:i32 = let 1i
    %4:u32 = bitcast<u32> %y
    %5:u32 = shr %x, %4
    %6:i32 = bitcast<i32> %5
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, ShiftRightLogical_Scalar_SignedUnsigned_Signed) {
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", 1_i);
        auto* y = b.Let("y", 9_u);
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.i32(), spirv::BuiltinFn::kShiftRightLogical,
                                               Vector<core::ir::TemplateParameter, 1>{ty.i32()}, x,
                                               y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:i32 = let 1i
    %y:u32 = let 9u
    %4:i32 = spirv.shift_right_logical<i32> %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:i32 = let 1i
    %y:u32 = let 9u
    %4:u32 = bitcast<u32> %x
    %5:u32 = shr %4, %y
    %6:i32 = bitcast<i32> %5
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, ShiftRightLogical_Scalar_SignedSigned_Signed) {
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", 1_i);
        auto* y = b.Let("y", 2_i);
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.i32(), spirv::BuiltinFn::kShiftRightLogical,
                                               Vector<core::ir::TemplateParameter, 1>{ty.i32()}, x,
                                               y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:i32 = let 1i
    %y:i32 = let 2i
    %4:i32 = spirv.shift_right_logical<i32> %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:i32 = let 1i
    %y:i32 = let 2i
    %4:u32 = bitcast<u32> %x
    %5:u32 = bitcast<u32> %y
    %6:u32 = shr %4, %5
    %7:i32 = bitcast<i32> %6
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, ShiftRightLogical_Vector_UnsignedUnsigned_Unsigned) {
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", b.Splat<vec2<u32>>(8_u));
        auto* y = b.Let("y", b.Splat<vec2<u32>>(9_u));
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.vec2u(), spirv::BuiltinFn::kShiftRightLogical,
                                               Vector<core::ir::TemplateParameter, 1>{ty.u32()}, x,
                                               y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<u32> = let vec2<u32>(8u)
    %y:vec2<u32> = let vec2<u32>(9u)
    %4:vec2<u32> = spirv.shift_right_logical<u32> %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<u32> = let vec2<u32>(8u)
    %y:vec2<u32> = let vec2<u32>(9u)
    %4:vec2<u32> = shr %x, %y
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, ShiftRightLogical_Vector_UnsignedSigned_Unsigned) {
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", b.Splat<vec2<u32>>(8_u));
        auto* y = b.Let("y", b.Splat<vec2<i32>>(1_i));
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.vec2u(), spirv::BuiltinFn::kShiftRightLogical,
                                               Vector<core::ir::TemplateParameter, 1>{ty.u32()}, x,
                                               y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<u32> = let vec2<u32>(8u)
    %y:vec2<i32> = let vec2<i32>(1i)
    %4:vec2<u32> = spirv.shift_right_logical<u32> %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<u32> = let vec2<u32>(8u)
    %y:vec2<i32> = let vec2<i32>(1i)
    %4:vec2<u32> = bitcast<vec2<u32>> %y
    %5:vec2<u32> = shr %x, %4
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, ShiftRightLogical_Vector_SignedUnsigned_Unsigned) {
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", b.Splat<vec2<i32>>(1_i));
        auto* y = b.Let("y", b.Splat<vec2<u32>>(9_u));
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.vec2u(), spirv::BuiltinFn::kShiftRightLogical,
                                               Vector<core::ir::TemplateParameter, 1>{ty.u32()}, x,
                                               y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<i32> = let vec2<i32>(1i)
    %y:vec2<u32> = let vec2<u32>(9u)
    %4:vec2<u32> = spirv.shift_right_logical<u32> %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<i32> = let vec2<i32>(1i)
    %y:vec2<u32> = let vec2<u32>(9u)
    %4:vec2<u32> = bitcast<vec2<u32>> %x
    %5:vec2<u32> = shr %4, %y
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, ShiftRightLogical_Vector_SignedSigned_Unsigned) {
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", b.Splat<vec2<i32>>(1_i));
        auto* y = b.Let("y", b.Splat<vec2<i32>>(2_i));
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.vec2u(), spirv::BuiltinFn::kShiftRightLogical,
                                               Vector<core::ir::TemplateParameter, 1>{ty.u32()}, x,
                                               y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<i32> = let vec2<i32>(1i)
    %y:vec2<i32> = let vec2<i32>(2i)
    %4:vec2<u32> = spirv.shift_right_logical<u32> %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<i32> = let vec2<i32>(1i)
    %y:vec2<i32> = let vec2<i32>(2i)
    %4:vec2<u32> = bitcast<vec2<u32>> %x
    %5:vec2<u32> = bitcast<vec2<u32>> %y
    %6:vec2<u32> = shr %4, %5
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, ShiftRightLogical_Vector_UnsignedUnsigned_Signed) {
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", b.Splat<vec2<u32>>(8_u));
        auto* y = b.Let("y", b.Splat<vec2<u32>>(9_u));
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.vec2i(), spirv::BuiltinFn::kShiftRightLogical,
                                               Vector<core::ir::TemplateParameter, 1>{ty.i32()}, x,
                                               y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<u32> = let vec2<u32>(8u)
    %y:vec2<u32> = let vec2<u32>(9u)
    %4:vec2<i32> = spirv.shift_right_logical<i32> %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<u32> = let vec2<u32>(8u)
    %y:vec2<u32> = let vec2<u32>(9u)
    %4:vec2<u32> = shr %x, %y
    %5:vec2<i32> = bitcast<vec2<i32>> %4
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, ShiftRightLogical_Vector_UnsignedSigned_Signed) {
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", b.Splat<vec2<u32>>(8_u));
        auto* y = b.Let("y", b.Splat<vec2<i32>>(1_i));
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.vec2i(), spirv::BuiltinFn::kShiftRightLogical,
                                               Vector<core::ir::TemplateParameter, 1>{ty.i32()}, x,
                                               y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<u32> = let vec2<u32>(8u)
    %y:vec2<i32> = let vec2<i32>(1i)
    %4:vec2<i32> = spirv.shift_right_logical<i32> %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<u32> = let vec2<u32>(8u)
    %y:vec2<i32> = let vec2<i32>(1i)
    %4:vec2<u32> = bitcast<vec2<u32>> %y
    %5:vec2<u32> = shr %x, %4
    %6:vec2<i32> = bitcast<vec2<i32>> %5
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, ShiftRightLogical_Vector_SignedUnsigned_Signed) {
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", b.Splat<vec2<i32>>(1_i));
        auto* y = b.Let("y", b.Splat<vec2<u32>>(9_u));
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.vec2i(), spirv::BuiltinFn::kShiftRightLogical,
                                               Vector<core::ir::TemplateParameter, 1>{ty.i32()}, x,
                                               y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<i32> = let vec2<i32>(1i)
    %y:vec2<u32> = let vec2<u32>(9u)
    %4:vec2<i32> = spirv.shift_right_logical<i32> %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<i32> = let vec2<i32>(1i)
    %y:vec2<u32> = let vec2<u32>(9u)
    %4:vec2<u32> = bitcast<vec2<u32>> %x
    %5:vec2<u32> = shr %4, %y
    %6:vec2<i32> = bitcast<vec2<i32>> %5
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, ShiftRightLogical_Vector_SignedSigned_Signed) {
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", b.Splat<vec2<i32>>(1_i));
        auto* y = b.Let("y", b.Splat<vec2<i32>>(2_i));
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.vec2i(), spirv::BuiltinFn::kShiftRightLogical,
                                               Vector<core::ir::TemplateParameter, 1>{ty.i32()}, x,
                                               y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<i32> = let vec2<i32>(1i)
    %y:vec2<i32> = let vec2<i32>(2i)
    %4:vec2<i32> = spirv.shift_right_logical<i32> %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<i32> = let vec2<i32>(1i)
    %y:vec2<i32> = let vec2<i32>(2i)
    %4:vec2<u32> = bitcast<vec2<u32>> %x
    %5:vec2<u32> = bitcast<vec2<u32>> %y
    %6:vec2<u32> = shr %4, %5
    %7:vec2<i32> = bitcast<vec2<i32>> %6
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, ShiftRightArithmetic_Scalar_UnsignedUnsigned_Unsigned) {
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", 8_u);
        auto* y = b.Let("y", 9_u);
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.u32(), spirv::BuiltinFn::kShiftRightArithmetic,
                                               Vector<core::ir::TemplateParameter, 1>{ty.u32()}, x,
                                               y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:u32 = let 8u
    %y:u32 = let 9u
    %4:u32 = spirv.shift_right_arithmetic<u32> %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:u32 = let 8u
    %y:u32 = let 9u
    %4:i32 = bitcast<i32> %x
    %5:i32 = shr %4, %y
    %6:u32 = bitcast<u32> %5
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, ShiftRightArithmetic_Scalar_UnsignedSigned_Unsigned) {
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", 8_u);
        auto* y = b.Let("y", 1_i);
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.u32(), spirv::BuiltinFn::kShiftRightArithmetic,
                                               Vector<core::ir::TemplateParameter, 1>{ty.u32()}, x,
                                               y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:u32 = let 8u
    %y:i32 = let 1i
    %4:u32 = spirv.shift_right_arithmetic<u32> %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:u32 = let 8u
    %y:i32 = let 1i
    %4:i32 = bitcast<i32> %x
    %5:u32 = bitcast<u32> %y
    %6:i32 = shr %4, %5
    %7:u32 = bitcast<u32> %6
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, ShiftRightArithmetic_Scalar_SignedUnsigned_Unsigned) {
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", 1_i);
        auto* y = b.Let("y", 9_u);
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.u32(), spirv::BuiltinFn::kShiftRightArithmetic,
                                               Vector<core::ir::TemplateParameter, 1>{ty.u32()}, x,
                                               y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:i32 = let 1i
    %y:u32 = let 9u
    %4:u32 = spirv.shift_right_arithmetic<u32> %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:i32 = let 1i
    %y:u32 = let 9u
    %4:i32 = shr %x, %y
    %5:u32 = bitcast<u32> %4
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, ShiftRightArithmetic_Scalar_SignedSigned_Unsigned) {
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", 1_i);
        auto* y = b.Let("y", 2_i);
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.u32(), spirv::BuiltinFn::kShiftRightArithmetic,
                                               Vector<core::ir::TemplateParameter, 1>{ty.u32()}, x,
                                               y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:i32 = let 1i
    %y:i32 = let 2i
    %4:u32 = spirv.shift_right_arithmetic<u32> %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:i32 = let 1i
    %y:i32 = let 2i
    %4:u32 = bitcast<u32> %y
    %5:i32 = shr %x, %4
    %6:u32 = bitcast<u32> %5
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, ShiftRightArithmetic_Scalar_UnsignedUnsigned_Signed) {
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", 8_u);
        auto* y = b.Let("y", 9_u);
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.i32(), spirv::BuiltinFn::kShiftRightArithmetic,
                                               Vector<core::ir::TemplateParameter, 1>{ty.i32()}, x,
                                               y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:u32 = let 8u
    %y:u32 = let 9u
    %4:i32 = spirv.shift_right_arithmetic<i32> %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:u32 = let 8u
    %y:u32 = let 9u
    %4:i32 = bitcast<i32> %x
    %5:i32 = shr %4, %y
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, ShiftRightArithmetic_Scalar_UnsignedSigned_Signed) {
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", 8_u);
        auto* y = b.Let("y", 1_i);
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.i32(), spirv::BuiltinFn::kShiftRightArithmetic,
                                               Vector<core::ir::TemplateParameter, 1>{ty.i32()}, x,
                                               y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:u32 = let 8u
    %y:i32 = let 1i
    %4:i32 = spirv.shift_right_arithmetic<i32> %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:u32 = let 8u
    %y:i32 = let 1i
    %4:i32 = bitcast<i32> %x
    %5:u32 = bitcast<u32> %y
    %6:i32 = shr %4, %5
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, ShiftRightArithmetic_Scalar_SignedUnsigned_Signed) {
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", 1_i);
        auto* y = b.Let("y", 9_u);
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.i32(), spirv::BuiltinFn::kShiftRightArithmetic,
                                               Vector<core::ir::TemplateParameter, 1>{ty.i32()}, x,
                                               y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:i32 = let 1i
    %y:u32 = let 9u
    %4:i32 = spirv.shift_right_arithmetic<i32> %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:i32 = let 1i
    %y:u32 = let 9u
    %4:i32 = shr %x, %y
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, ShiftRightArithmetic_Scalar_SignedSigned_Signed) {
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", 1_i);
        auto* y = b.Let("y", 2_i);
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.i32(), spirv::BuiltinFn::kShiftRightArithmetic,
                                               Vector<core::ir::TemplateParameter, 1>{ty.i32()}, x,
                                               y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:i32 = let 1i
    %y:i32 = let 2i
    %4:i32 = spirv.shift_right_arithmetic<i32> %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:i32 = let 1i
    %y:i32 = let 2i
    %4:u32 = bitcast<u32> %y
    %5:i32 = shr %x, %4
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, ShiftRightArithmetic_Vector_UnsignedUnsigned_Unsigned) {
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", b.Splat<vec2<u32>>(8_u));
        auto* y = b.Let("y", b.Splat<vec2<u32>>(9_u));
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.vec2u(), spirv::BuiltinFn::kShiftRightArithmetic,
                                               Vector<core::ir::TemplateParameter, 1>{ty.u32()}, x,
                                               y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<u32> = let vec2<u32>(8u)
    %y:vec2<u32> = let vec2<u32>(9u)
    %4:vec2<u32> = spirv.shift_right_arithmetic<u32> %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<u32> = let vec2<u32>(8u)
    %y:vec2<u32> = let vec2<u32>(9u)
    %4:vec2<i32> = bitcast<vec2<i32>> %x
    %5:vec2<i32> = shr %4, %y
    %6:vec2<u32> = bitcast<vec2<u32>> %5
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, ShiftRightArithmetic_Vector_UnsignedSigned_Unsigned) {
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", b.Splat<vec2<u32>>(8_u));
        auto* y = b.Let("y", b.Splat<vec2<i32>>(1_i));
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.vec2u(), spirv::BuiltinFn::kShiftRightArithmetic,
                                               Vector<core::ir::TemplateParameter, 1>{ty.u32()}, x,
                                               y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<u32> = let vec2<u32>(8u)
    %y:vec2<i32> = let vec2<i32>(1i)
    %4:vec2<u32> = spirv.shift_right_arithmetic<u32> %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<u32> = let vec2<u32>(8u)
    %y:vec2<i32> = let vec2<i32>(1i)
    %4:vec2<i32> = bitcast<vec2<i32>> %x
    %5:vec2<u32> = bitcast<vec2<u32>> %y
    %6:vec2<i32> = shr %4, %5
    %7:vec2<u32> = bitcast<vec2<u32>> %6
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, ShiftRightArithmetic_Vector_SignedUnsigned_Unsigned) {
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", b.Splat<vec2<i32>>(1_i));
        auto* y = b.Let("y", b.Splat<vec2<u32>>(9_u));
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.vec2u(), spirv::BuiltinFn::kShiftRightArithmetic,
                                               Vector<core::ir::TemplateParameter, 1>{ty.u32()}, x,
                                               y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<i32> = let vec2<i32>(1i)
    %y:vec2<u32> = let vec2<u32>(9u)
    %4:vec2<u32> = spirv.shift_right_arithmetic<u32> %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<i32> = let vec2<i32>(1i)
    %y:vec2<u32> = let vec2<u32>(9u)
    %4:vec2<i32> = shr %x, %y
    %5:vec2<u32> = bitcast<vec2<u32>> %4
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, ShiftRightArithmetic_Vector_SignedSigned_Unsigned) {
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", b.Splat<vec2<i32>>(1_i));
        auto* y = b.Let("y", b.Splat<vec2<i32>>(2_i));
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.vec2u(), spirv::BuiltinFn::kShiftRightArithmetic,
                                               Vector<core::ir::TemplateParameter, 1>{ty.u32()}, x,
                                               y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<i32> = let vec2<i32>(1i)
    %y:vec2<i32> = let vec2<i32>(2i)
    %4:vec2<u32> = spirv.shift_right_arithmetic<u32> %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<i32> = let vec2<i32>(1i)
    %y:vec2<i32> = let vec2<i32>(2i)
    %4:vec2<u32> = bitcast<vec2<u32>> %y
    %5:vec2<i32> = shr %x, %4
    %6:vec2<u32> = bitcast<vec2<u32>> %5
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, ShiftRightArithmetic_Vector_UnsignedUnsigned_Signed) {
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", b.Splat<vec2<u32>>(8_u));
        auto* y = b.Let("y", b.Splat<vec2<u32>>(9_u));
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.vec2i(), spirv::BuiltinFn::kShiftRightArithmetic,
                                               Vector<core::ir::TemplateParameter, 1>{ty.i32()}, x,
                                               y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<u32> = let vec2<u32>(8u)
    %y:vec2<u32> = let vec2<u32>(9u)
    %4:vec2<i32> = spirv.shift_right_arithmetic<i32> %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<u32> = let vec2<u32>(8u)
    %y:vec2<u32> = let vec2<u32>(9u)
    %4:vec2<i32> = bitcast<vec2<i32>> %x
    %5:vec2<i32> = shr %4, %y
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, ShiftRightArithmetic_Vector_UnsignedSigned_Signed) {
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", b.Splat<vec2<u32>>(8_u));
        auto* y = b.Let("y", b.Splat<vec2<i32>>(1_i));
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.vec2i(), spirv::BuiltinFn::kShiftRightArithmetic,
                                               Vector<core::ir::TemplateParameter, 1>{ty.i32()}, x,
                                               y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<u32> = let vec2<u32>(8u)
    %y:vec2<i32> = let vec2<i32>(1i)
    %4:vec2<i32> = spirv.shift_right_arithmetic<i32> %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<u32> = let vec2<u32>(8u)
    %y:vec2<i32> = let vec2<i32>(1i)
    %4:vec2<i32> = bitcast<vec2<i32>> %x
    %5:vec2<u32> = bitcast<vec2<u32>> %y
    %6:vec2<i32> = shr %4, %5
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, ShiftRightArithmetic_Vector_SignedUnsigned_Signed) {
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", b.Splat<vec2<i32>>(1_i));
        auto* y = b.Let("y", b.Splat<vec2<u32>>(9_u));
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.vec2i(), spirv::BuiltinFn::kShiftRightArithmetic,
                                               Vector<core::ir::TemplateParameter, 1>{ty.i32()}, x,
                                               y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<i32> = let vec2<i32>(1i)
    %y:vec2<u32> = let vec2<u32>(9u)
    %4:vec2<i32> = spirv.shift_right_arithmetic<i32> %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<i32> = let vec2<i32>(1i)
    %y:vec2<u32> = let vec2<u32>(9u)
    %4:vec2<i32> = shr %x, %y
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, ShiftRightArithmetic_Vector_SignedSigned_Signed) {
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", b.Splat<vec2<i32>>(1_i));
        auto* y = b.Let("y", b.Splat<vec2<i32>>(2_i));
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.vec2i(), spirv::BuiltinFn::kShiftRightArithmetic,
                                               Vector<core::ir::TemplateParameter, 1>{ty.i32()}, x,
                                               y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<i32> = let vec2<i32>(1i)
    %y:vec2<i32> = let vec2<i32>(2i)
    %4:vec2<i32> = spirv.shift_right_arithmetic<i32> %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<i32> = let vec2<i32>(1i)
    %y:vec2<i32> = let vec2<i32>(2i)
    %4:vec2<u32> = bitcast<vec2<u32>> %y
    %5:vec2<i32> = shr %x, %4
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, SpecConstantOp_Not) {
    auto* ep = b.ComputeFunction("foo");

    mod.properties.Add(core::ir::Property::kAllowOverrides);

    b.Append(b.ir.root_block, [&] {
        auto* comp = b.CallExplicit<spirv::ir::BuiltinCall>(
            ty.i32(), spirv::BuiltinFn::kNot, Vector<core::ir::TemplateParameter, 1>{ty.i32()},
            1_i);
        b.Override("o", comp);
    });

    b.Append(ep->Block(), [&] {  //
        auto* comp = b.CallExplicit<spirv::ir::BuiltinCall>(
            ty.i32(), spirv::BuiltinFn::kNot, Vector<core::ir::TemplateParameter, 1>{ty.i32()},
            1_i);
        b.Let("l", comp);
        b.Return(ep);
    });

    auto src = R"(
$B1: {  # root
  %1:i32 = spirv.not<i32> 1i
  %o:i32 = override %1
}

%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B2: {
    %4:i32 = spirv.not<i32> 1i
    %l:i32 = let %4
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
$B1: {  # root
  %o:i32 = override -2i
}

%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B2: {
    %l:i32 = let -2i
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, Not_Scalar_Signed_Signed) {
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* l = b.Let("l", 1_i);
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.i32(), spirv::BuiltinFn::kNot,
                                               Vector<core::ir::TemplateParameter, 1>{ty.i32()}, l);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %l:i32 = let 1i
    %3:i32 = spirv.not<i32> %l
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %l:i32 = let 1i
    %3:i32 = complement %l
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, Not_Scalar_Signed_Unsigned) {
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* l = b.Let("l", 1_i);
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.u32(), spirv::BuiltinFn::kNot,
                                               Vector<core::ir::TemplateParameter, 1>{ty.u32()}, l);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %l:i32 = let 1i
    %3:u32 = spirv.not<u32> %l
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %l:i32 = let 1i
    %3:i32 = complement %l
    %4:u32 = bitcast<u32> %3
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, Not_Scalar_Unsigned_Signed) {
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* l = b.Let("l", 8_u);
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.i32(), spirv::BuiltinFn::kNot,
                                               Vector<core::ir::TemplateParameter, 1>{ty.i32()}, l);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %l:u32 = let 8u
    %3:i32 = spirv.not<i32> %l
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %l:u32 = let 8u
    %3:u32 = complement %l
    %4:i32 = bitcast<i32> %3
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, Not_Vector_Signed_Signed) {
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* l = b.Let("l", b.Splat<vec2<i32>>(1_i));
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.vec2i(), spirv::BuiltinFn::kNot,
                                               Vector<core::ir::TemplateParameter, 1>{ty.i32()}, l);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %l:vec2<i32> = let vec2<i32>(1i)
    %3:vec2<i32> = spirv.not<i32> %l
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %l:vec2<i32> = let vec2<i32>(1i)
    %3:vec2<i32> = complement %l
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, Not_Vector_Signed_Unsigned) {
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* l = b.Let("l", b.Splat<vec2<i32>>(1_i));
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.vec2u(), spirv::BuiltinFn::kNot,
                                               Vector<core::ir::TemplateParameter, 1>{ty.u32()}, l);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %l:vec2<i32> = let vec2<i32>(1i)
    %3:vec2<u32> = spirv.not<u32> %l
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %l:vec2<i32> = let vec2<i32>(1i)
    %3:vec2<i32> = complement %l
    %4:vec2<u32> = bitcast<vec2<u32>> %3
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, Not_Vector_Unsigned_Signed) {
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* l = b.Let("l", b.Splat<vec2<u32>>(8_u));
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.vec2i(), spirv::BuiltinFn::kNot,
                                               Vector<core::ir::TemplateParameter, 1>{ty.i32()}, l);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %l:vec2<u32> = let vec2<u32>(8u)
    %3:vec2<i32> = spirv.not<i32> %l
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %l:vec2<u32> = let vec2<u32>(8u)
    %3:vec2<u32> = complement %l
    %4:vec2<i32> = bitcast<vec2<i32>> %3
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, Not_Vector_Unsigned_Unsigned) {
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* l = b.Let("l", b.Splat<vec2<u32>>(8_u));
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.vec2u(), spirv::BuiltinFn::kNot,
                                               Vector<core::ir::TemplateParameter, 1>{ty.u32()}, l);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %l:vec2<u32> = let vec2<u32>(8u)
    %3:vec2<u32> = spirv.not<u32> %l
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %l:vec2<u32> = let vec2<u32>(8u)
    %3:vec2<u32> = complement %l
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, SNegate_Scalar_Signed_Signed) {
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* l = b.Let("l", 1_i);
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.i32(), spirv::BuiltinFn::kSNegate,
                                               Vector<core::ir::TemplateParameter, 1>{ty.i32()}, l);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %l:i32 = let 1i
    %3:i32 = spirv.s_negate<i32> %l
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %l:i32 = let 1i
    %3:i32 = negation %l
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, SNegate_Scalar_Signed_Unsigned) {
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* l = b.Let("l", 1_i);
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.u32(), spirv::BuiltinFn::kSNegate,
                                               Vector<core::ir::TemplateParameter, 1>{ty.u32()}, l);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %l:i32 = let 1i
    %3:u32 = spirv.s_negate<u32> %l
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %l:i32 = let 1i
    %3:i32 = negation %l
    %4:u32 = bitcast<u32> %3
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, SNegate_Scalar_Unsigned_Signed) {
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* l = b.Let("l", 8_u);
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.i32(), spirv::BuiltinFn::kSNegate,
                                               Vector<core::ir::TemplateParameter, 1>{ty.i32()}, l);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %l:u32 = let 8u
    %3:i32 = spirv.s_negate<i32> %l
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %l:u32 = let 8u
    %3:i32 = bitcast<i32> %l
    %4:i32 = negation %3
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, SNegate_Scalar_Unsigned_Unsigned) {
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* l = b.Let("l", 8_u);
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.u32(), spirv::BuiltinFn::kSNegate,
                                               Vector<core::ir::TemplateParameter, 1>{ty.u32()}, l);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %l:u32 = let 8u
    %3:u32 = spirv.s_negate<u32> %l
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %l:u32 = let 8u
    %3:i32 = bitcast<i32> %l
    %4:i32 = negation %3
    %5:u32 = bitcast<u32> %4
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, SNegate_Vector_Signed_Signed) {
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* l = b.Let("l", b.Splat<vec2<i32>>(1_i));
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.vec2i(), spirv::BuiltinFn::kSNegate,
                                               Vector<core::ir::TemplateParameter, 1>{ty.i32()}, l);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %l:vec2<i32> = let vec2<i32>(1i)
    %3:vec2<i32> = spirv.s_negate<i32> %l
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %l:vec2<i32> = let vec2<i32>(1i)
    %3:vec2<i32> = negation %l
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, SNegate_Vector_Signed_Unsigned) {
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* l = b.Let("l", b.Splat<vec2<i32>>(1_i));
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.vec2u(), spirv::BuiltinFn::kSNegate,
                                               Vector<core::ir::TemplateParameter, 1>{ty.u32()}, l);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %l:vec2<i32> = let vec2<i32>(1i)
    %3:vec2<u32> = spirv.s_negate<u32> %l
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %l:vec2<i32> = let vec2<i32>(1i)
    %3:vec2<i32> = negation %l
    %4:vec2<u32> = bitcast<vec2<u32>> %3
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, SNegate_Vector_Unsigned_Signed) {
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* l = b.Let("l", b.Splat<vec2<u32>>(8_u));
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.vec2i(), spirv::BuiltinFn::kSNegate,
                                               Vector<core::ir::TemplateParameter, 1>{ty.i32()}, l);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %l:vec2<u32> = let vec2<u32>(8u)
    %3:vec2<i32> = spirv.s_negate<i32> %l
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %l:vec2<u32> = let vec2<u32>(8u)
    %3:vec2<i32> = bitcast<vec2<i32>> %l
    %4:vec2<i32> = negation %3
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, SNegate_Vector_Unsigned_Unsigned) {
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* l = b.Let("l", b.Splat<vec2<u32>>(8_u));
        b.CallExplicit<spirv::ir::BuiltinCall>(ty.vec2u(), spirv::BuiltinFn::kSNegate,
                                               Vector<core::ir::TemplateParameter, 1>{ty.u32()}, l);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %l:vec2<u32> = let vec2<u32>(8u)
    %3:vec2<u32> = spirv.s_negate<u32> %l
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %l:vec2<u32> = let vec2<u32>(8u)
    %3:vec2<i32> = bitcast<vec2<i32>> %l
    %4:vec2<i32> = negation %3
    %5:vec2<u32> = bitcast<vec2<u32>> %4
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, FMod_Scalar) {
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", 1_f);
        auto* y = b.Let("y", 2_f);
        b.Call<spirv::ir::BuiltinCall>(ty.f32(), spirv::BuiltinFn::kFMod, x, y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:f32 = let 1.0f
    %y:f32 = let 2.0f
    %4:f32 = spirv.f_mod %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:f32 = let 1.0f
    %y:f32 = let 2.0f
    %4:f32 = div %x, %y
    %5:f32 = floor %4
    %6:f32 = mul %y, %5
    %7:f32 = sub %x, %6
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, FMod_Vector) {
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        auto* x = b.Let("x", b.Splat<vec2<f32>>(1_f));
        auto* y = b.Let("y", b.Splat<vec2<f32>>(2_f));
        b.Call<spirv::ir::BuiltinCall>(ty.vec2f(), spirv::BuiltinFn::kFMod, x, y);
        b.Return(ep);
    });

    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<f32> = let vec2<f32>(1.0f)
    %y:vec2<f32> = let vec2<f32>(2.0f)
    %4:vec2<f32> = spirv.f_mod %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec2<f32> = let vec2<f32>(1.0f)
    %y:vec2<f32> = let vec2<f32>(2.0f)
    %4:vec2<f32> = div %x, %y
    %5:vec2<f32> = floor %4
    %6:vec2<f32> = mul %y, %5
    %7:vec2<f32> = sub %x, %6
    ret
  }
}
)";

    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, Select_Scalar) {
    auto* cond = b.FunctionParam("cond", ty.bool_());
    auto* t = b.FunctionParam("t", ty.f32());
    auto* f = b.FunctionParam("f", ty.f32());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({cond, t, f});

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.f32(), spirv::BuiltinFn::kSelect, cond, t, f);
        b.Return(ep);
    });
    auto src = R"(
%foo = func(%cond:bool, %t:f32, %f:f32):void {
  $B1: {
    %5:f32 = spirv.select %cond, %t, %f
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%cond:bool, %t:f32, %f:f32):void {
  $B1: {
    %5:f32 = select %f, %t, %cond
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, Select_Vector) {
    auto* cond = b.FunctionParam("cond", ty.vec2<bool>());
    auto* t = b.FunctionParam("t", ty.vec2f());
    auto* f = b.FunctionParam("f", ty.vec2f());
    auto* ep = b.Function("foo", ty.void_());
    ep->SetParams({cond, t, f});

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.vec2f(), spirv::BuiltinFn::kSelect, cond, t, f);
        b.Return(ep);
    });
    auto src = R"(
%foo = func(%cond:vec2<bool>, %t:vec2<f32>, %f:vec2<f32>):void {
  $B1: {
    %5:vec2<f32> = spirv.select %cond, %t, %f
    ret
  }
}
)";
    EXPECT_EQ(src, str());
    Run(Builtins);

    auto expect = R"(
%foo = func(%cond:vec2<bool>, %t:vec2<f32>, %f:vec2<f32>):void {
  $B1: {
    %5:vec2<f32> = select %f, %t, %cond
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, OuterProduct_Vector) {
    auto* ep = b.ComputeFunction("foo");

    b.Append(ep->Block(), [&] {  //
        // Call the OuterProduct builtin function
        auto* x = b.Let("x", b.Splat<vec4<f32>>(1_f));
        auto* y = b.Let("y", b.Splat<vec2<f32>>(2_f));
        b.Call<spirv::ir::BuiltinCall>(ty.mat2x4<f32>(), spirv::BuiltinFn::kOuterProduct, x, y);
        b.Return(ep);
    });

    // Expected SPIR-V source code
    auto src = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec4<f32> = let vec4<f32>(1.0f)
    %y:vec2<f32> = let vec2<f32>(2.0f)
    %4:mat2x4<f32> = spirv.outer_product %x, %y
    ret
  }
}
)";
    EXPECT_EQ(src, str());

    // Run the test
    Run(Builtins);

    // Updated expected expanded SPIR-V code after lowering
    auto expect = R"(
%foo = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %x:vec4<f32> = let vec4<f32>(1.0f)
    %y:vec2<f32> = let vec2<f32>(2.0f)
    %4:f32 = access %y, 0u
    %5:f32 = access %x, 0u
    %6:f32 = mul %5, %4
    %7:f32 = access %x, 1u
    %8:f32 = mul %7, %4
    %9:f32 = access %x, 2u
    %10:f32 = mul %9, %4
    %11:f32 = access %x, 3u
    %12:f32 = mul %11, %4
    %13:vec4<f32> = construct %6, %8, %10, %12
    %14:f32 = access %y, 1u
    %15:f32 = access %x, 0u
    %16:f32 = mul %15, %14
    %17:f32 = access %x, 1u
    %18:f32 = mul %17, %14
    %19:f32 = access %x, 2u
    %20:f32 = mul %19, %14
    %21:f32 = access %x, 3u
    %22:f32 = mul %21, %14
    %23:vec4<f32> = construct %16, %18, %20, %22
    %24:mat2x4<f32> = construct %13, %23
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, NonUniformBroadcast_Constant_BoolScalar) {
    auto* ep = b.ComputeFunction("main");

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.bool_(), spirv::BuiltinFn::kGroupNonUniformBroadcast, 3_u,
                                       true, 1_u);
        b.Return(ep);
    });

    auto src = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:bool = spirv.group_non_uniform_broadcast 3u, true, 1u
    ret
  }
}
)";
    EXPECT_EQ(src, str());

    Run(Builtins);

    auto expect = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:u32 = subgroupBroadcast 1u, 1u
    %3:bool = convert %2
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, NonUniformBroadcast_Constant_BoolVector) {
    auto* ep = b.ComputeFunction("main");

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.vec3(ty.bool_()),
                                       spirv::BuiltinFn::kGroupNonUniformBroadcast, 3_u,
                                       b.Composite(ty.vec3(ty.bool_()), true, false, true), 1_u);
        b.Return(ep);
    });

    auto src = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:vec3<bool> = spirv.group_non_uniform_broadcast 3u, vec3<bool>(true, false, true), 1u
    ret
  }
}
)";
    EXPECT_EQ(src, str());

    Run(Builtins);

    auto expect = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:vec3<u32> = subgroupBroadcast vec3<u32>(1u, 0u, 1u), 1u
    %3:vec3<bool> = convert %2
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, NonUniformBroadcast_Constant_NumericScalar) {
    auto* ep = b.ComputeFunction("main");

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.u32(), spirv::BuiltinFn::kGroupNonUniformBroadcast, 3_u,
                                       2_u, 1_u);
        b.Return(ep);
    });

    auto src = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:u32 = spirv.group_non_uniform_broadcast 3u, 2u, 1u
    ret
  }
}
)";
    EXPECT_EQ(src, str());

    Run(Builtins);

    auto expect = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:u32 = subgroupBroadcast 2u, 1u
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, NonUniformBroadcast_Constant_NumericVector) {
    auto* ep = b.ComputeFunction("main");

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.vec3u(), spirv::BuiltinFn::kGroupNonUniformBroadcast, 3_u,
                                       b.Composite(ty.vec3u(), 2_u, 3_u, 2_u), 1_u);
        b.Return(ep);
    });

    auto src = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:vec3<u32> = spirv.group_non_uniform_broadcast 3u, vec3<u32>(2u, 3u, 2u), 1u
    ret
  }
}
)";
    EXPECT_EQ(src, str());

    Run(Builtins);

    auto expect = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:vec3<u32> = subgroupBroadcast vec3<u32>(2u, 3u, 2u), 1u
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, NonUniformBroadcastFirst_Constant_BoolScalar) {
    auto* ep = b.ComputeFunction("main");

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.bool_(), spirv::BuiltinFn::kGroupNonUniformBroadcastFirst,
                                       3_u, true);
        b.Return(ep);
    });

    auto src = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:bool = spirv.group_non_uniform_broadcast_first 3u, true
    ret
  }
}
)";
    EXPECT_EQ(src, str());

    Run(Builtins);

    auto expect = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:u32 = subgroupBroadcastFirst 1u
    %3:bool = convert %2
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, NonUniformBroadcastFirst_Constant_BoolVector) {
    auto* ep = b.ComputeFunction("main");

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.vec3(ty.bool_()),
                                       spirv::BuiltinFn::kGroupNonUniformBroadcastFirst, 3_u,
                                       b.Composite(ty.vec3(ty.bool_()), true, false, true));
        b.Return(ep);
    });

    auto src = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:vec3<bool> = spirv.group_non_uniform_broadcast_first 3u, vec3<bool>(true, false, true)
    ret
  }
}
)";
    EXPECT_EQ(src, str());

    Run(Builtins);

    auto expect = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:vec3<u32> = subgroupBroadcastFirst vec3<u32>(1u, 0u, 1u)
    %3:vec3<bool> = convert %2
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, NonUniformBroadcastFirst_Constant_NumericScalar) {
    auto* ep = b.ComputeFunction("main");

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.u32(), spirv::BuiltinFn::kGroupNonUniformBroadcastFirst,
                                       3_u, 2_u);
        b.Return(ep);
    });

    auto src = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:u32 = spirv.group_non_uniform_broadcast_first 3u, 2u
    ret
  }
}
)";
    EXPECT_EQ(src, str());

    Run(Builtins);

    auto expect = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:u32 = subgroupBroadcastFirst 2u
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, NonUniformBroadcastFirst_Constant_NumericVector) {
    auto* ep = b.ComputeFunction("main");

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.vec3u(), spirv::BuiltinFn::kGroupNonUniformBroadcastFirst,
                                       3_u, b.Composite(ty.vec3u(), 2_u, 3_u, 2_u));
        b.Return(ep);
    });

    auto src = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:vec3<u32> = spirv.group_non_uniform_broadcast_first 3u, vec3<u32>(2u, 3u, 2u)
    ret
  }
}
)";
    EXPECT_EQ(src, str());

    Run(Builtins);

    auto expect = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:vec3<u32> = subgroupBroadcastFirst vec3<u32>(2u, 3u, 2u)
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, NonUniformQuadBroadcast_Constant_BoolScalar) {
    auto* ep = b.ComputeFunction("main");

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.bool_(), spirv::BuiltinFn::kGroupNonUniformQuadBroadcast,
                                       3_u, true, 1_u);
        b.Return(ep);
    });

    auto src = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:bool = spirv.group_non_uniform_quad_broadcast 3u, true, 1u
    ret
  }
}
)";
    EXPECT_EQ(src, str());

    Run(Builtins);

    auto expect = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:u32 = quadBroadcast 1u, 1u
    %3:bool = convert %2
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, NonUniformQuadBroadcast_Constant_BoolVector) {
    auto* ep = b.ComputeFunction("main");

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.vec3(ty.bool_()),
                                       spirv::BuiltinFn::kGroupNonUniformQuadBroadcast, 3_u,
                                       b.Composite(ty.vec3(ty.bool_()), true, false, true), 1_u);
        b.Return(ep);
    });

    auto src = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:vec3<bool> = spirv.group_non_uniform_quad_broadcast 3u, vec3<bool>(true, false, true), 1u
    ret
  }
}
)";
    EXPECT_EQ(src, str());

    Run(Builtins);

    auto expect = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:vec3<u32> = quadBroadcast vec3<u32>(1u, 0u, 1u), 1u
    %3:vec3<bool> = convert %2
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, NonUniformQuadBroadcast_Constant_NumericScalar) {
    auto* ep = b.ComputeFunction("main");

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.u32(), spirv::BuiltinFn::kGroupNonUniformQuadBroadcast,
                                       3_u, 2_u, 1_u);
        b.Return(ep);
    });

    auto src = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:u32 = spirv.group_non_uniform_quad_broadcast 3u, 2u, 1u
    ret
  }
}
)";
    EXPECT_EQ(src, str());

    Run(Builtins);

    auto expect = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:u32 = quadBroadcast 2u, 1u
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, NonUniformQuadBroadcast_Constant_NumericVector) {
    auto* ep = b.ComputeFunction("main");

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.vec3u(), spirv::BuiltinFn::kGroupNonUniformQuadBroadcast,
                                       3_u, b.Composite(ty.vec3u(), 2_u, 3_u, 2_u), 1_u);
        b.Return(ep);
    });

    auto src = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:vec3<u32> = spirv.group_non_uniform_quad_broadcast 3u, vec3<u32>(2u, 3u, 2u), 1u
    ret
  }
}
)";
    EXPECT_EQ(src, str());

    Run(Builtins);

    auto expect = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:vec3<u32> = quadBroadcast vec3<u32>(2u, 3u, 2u), 1u
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, NonUniformQuadSwap_Constant_BoolScalar) {
    auto* ep = b.ComputeFunction("main");

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.bool_(), spirv::BuiltinFn::kGroupNonUniformQuadSwap, 3_u,
                                       true, 0_u);
        b.Return(ep);
    });

    auto src = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:bool = spirv.group_non_uniform_quad_swap 3u, true, 0u
    ret
  }
}
)";
    EXPECT_EQ(src, str());

    Run(Builtins);

    auto expect = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:u32 = quadSwapX 1u
    %3:bool = convert %2
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, NonUniformQuadSwap_Constant_BoolVector) {
    auto* ep = b.ComputeFunction("main");

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.vec3(ty.bool_()),
                                       spirv::BuiltinFn::kGroupNonUniformQuadSwap, 3_u,
                                       b.Composite(ty.vec3(ty.bool_()), true, false, true), 1_u);
        b.Return(ep);
    });

    auto src = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:vec3<bool> = spirv.group_non_uniform_quad_swap 3u, vec3<bool>(true, false, true), 1u
    ret
  }
}
)";
    EXPECT_EQ(src, str());

    Run(Builtins);

    auto expect = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:vec3<u32> = quadSwapY vec3<u32>(1u, 0u, 1u)
    %3:vec3<bool> = convert %2
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, NonUniformQuadSwap_Constant_NumericScalar) {
    auto* ep = b.ComputeFunction("main");

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.u32(), spirv::BuiltinFn::kGroupNonUniformQuadSwap, 3_u,
                                       2_u, 2_u);
        b.Return(ep);
    });

    auto src = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:u32 = spirv.group_non_uniform_quad_swap 3u, 2u, 2u
    ret
  }
}
)";
    EXPECT_EQ(src, str());

    Run(Builtins);

    auto expect = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:u32 = quadSwapDiagonal 2u
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, NonUniformQuadSwap_Constant_NumericVector) {
    auto* ep = b.ComputeFunction("main");

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.vec3u(), spirv::BuiltinFn::kGroupNonUniformQuadSwap, 3_u,
                                       b.Composite(ty.vec3u(), 2_u, 3_u, 2_u), 1_u);
        b.Return(ep);
    });

    auto src = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:vec3<u32> = spirv.group_non_uniform_quad_swap 3u, vec3<u32>(2u, 3u, 2u), 1u
    ret
  }
}
)";
    EXPECT_EQ(src, str());

    Run(Builtins);

    auto expect = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:vec3<u32> = quadSwapY vec3<u32>(2u, 3u, 2u)
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, NonUniformShuffle_Constant_BoolScalar) {
    auto* ep = b.ComputeFunction("main");

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.bool_(), spirv::BuiltinFn::kGroupNonUniformShuffle, 3_u,
                                       true, 1_u);
        b.Return(ep);
    });

    auto src = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:bool = spirv.group_non_uniform_shuffle 3u, true, 1u
    ret
  }
}
)";
    EXPECT_EQ(src, str());

    Run(Builtins);

    auto expect = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:u32 = subgroupShuffle 1u, 1u
    %3:bool = convert %2
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, NonUniformShuffle_Constant_BoolVector) {
    auto* ep = b.ComputeFunction("main");

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.vec3(ty.bool_()),
                                       spirv::BuiltinFn::kGroupNonUniformShuffle, 3_u,
                                       b.Composite(ty.vec3(ty.bool_()), true, false, true), 1_u);
        b.Return(ep);
    });

    auto src = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:vec3<bool> = spirv.group_non_uniform_shuffle 3u, vec3<bool>(true, false, true), 1u
    ret
  }
}
)";
    EXPECT_EQ(src, str());

    Run(Builtins);

    auto expect = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:vec3<u32> = subgroupShuffle vec3<u32>(1u, 0u, 1u), 1u
    %3:vec3<bool> = convert %2
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, NonUniformShuffle_Constant_NumericScalar) {
    auto* ep = b.ComputeFunction("main");

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.u32(), spirv::BuiltinFn::kGroupNonUniformShuffle, 3_u,
                                       2_u, 1_u);
        b.Return(ep);
    });

    auto src = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:u32 = spirv.group_non_uniform_shuffle 3u, 2u, 1u
    ret
  }
}
)";
    EXPECT_EQ(src, str());

    Run(Builtins);

    auto expect = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:u32 = subgroupShuffle 2u, 1u
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, NonUniformShuffle_Constant_NumericVector) {
    auto* ep = b.ComputeFunction("main");

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.vec3u(), spirv::BuiltinFn::kGroupNonUniformShuffle, 3_u,
                                       b.Composite(ty.vec3u(), 2_u, 3_u, 2_u), 1_u);
        b.Return(ep);
    });

    auto src = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:vec3<u32> = spirv.group_non_uniform_shuffle 3u, vec3<u32>(2u, 3u, 2u), 1u
    ret
  }
}
)";
    EXPECT_EQ(src, str());

    Run(Builtins);

    auto expect = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:vec3<u32> = subgroupShuffle vec3<u32>(2u, 3u, 2u), 1u
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, NonUniformShuffleXor_Constant_BoolScalar) {
    auto* ep = b.ComputeFunction("main");

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.bool_(), spirv::BuiltinFn::kGroupNonUniformShuffleXor,
                                       3_u, true, 1_u);
        b.Return(ep);
    });

    auto src = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:bool = spirv.group_non_uniform_shuffle_xor 3u, true, 1u
    ret
  }
}
)";
    EXPECT_EQ(src, str());

    Run(Builtins);

    auto expect = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:u32 = subgroupShuffleXor 1u, 1u
    %3:bool = convert %2
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, NonUniformShuffleXor_Constant_BoolVector) {
    auto* ep = b.ComputeFunction("main");

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.vec3(ty.bool_()),
                                       spirv::BuiltinFn::kGroupNonUniformShuffleXor, 3_u,
                                       b.Composite(ty.vec3(ty.bool_()), true, false, true), 1_u);
        b.Return(ep);
    });

    auto src = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:vec3<bool> = spirv.group_non_uniform_shuffle_xor 3u, vec3<bool>(true, false, true), 1u
    ret
  }
}
)";
    EXPECT_EQ(src, str());

    Run(Builtins);

    auto expect = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:vec3<u32> = subgroupShuffleXor vec3<u32>(1u, 0u, 1u), 1u
    %3:vec3<bool> = convert %2
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, NonUniformShuffleXor_Constant_NumericScalar) {
    auto* ep = b.ComputeFunction("main");

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.u32(), spirv::BuiltinFn::kGroupNonUniformShuffleXor, 3_u,
                                       2_u, 1_u);
        b.Return(ep);
    });

    auto src = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:u32 = spirv.group_non_uniform_shuffle_xor 3u, 2u, 1u
    ret
  }
}
)";
    EXPECT_EQ(src, str());

    Run(Builtins);

    auto expect = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:u32 = subgroupShuffleXor 2u, 1u
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, NonUniformShuffleXor_Constant_NumericVector) {
    auto* ep = b.ComputeFunction("main");

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.vec3u(), spirv::BuiltinFn::kGroupNonUniformShuffleXor,
                                       3_u, b.Composite(ty.vec3u(), 2_u, 3_u, 2_u), 1_u);
        b.Return(ep);
    });

    auto src = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:vec3<u32> = spirv.group_non_uniform_shuffle_xor 3u, vec3<u32>(2u, 3u, 2u), 1u
    ret
  }
}
)";
    EXPECT_EQ(src, str());

    Run(Builtins);

    auto expect = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:vec3<u32> = subgroupShuffleXor vec3<u32>(2u, 3u, 2u), 1u
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, NonUniformShuffleDown_Constant_BoolScalar) {
    auto* ep = b.ComputeFunction("main");

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.bool_(), spirv::BuiltinFn::kGroupNonUniformShuffleDown,
                                       3_u, true, 1_u);
        b.Return(ep);
    });

    auto src = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:bool = spirv.group_non_uniform_shuffle_down 3u, true, 1u
    ret
  }
}
)";
    EXPECT_EQ(src, str());

    Run(Builtins);

    auto expect = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:u32 = subgroupShuffleDown 1u, 1u
    %3:bool = convert %2
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, NonUniformShuffleDown_Constant_BoolVector) {
    auto* ep = b.ComputeFunction("main");

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.vec3(ty.bool_()),
                                       spirv::BuiltinFn::kGroupNonUniformShuffleDown, 3_u,
                                       b.Composite(ty.vec3(ty.bool_()), true, false, true), 1_u);
        b.Return(ep);
    });

    auto src = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:vec3<bool> = spirv.group_non_uniform_shuffle_down 3u, vec3<bool>(true, false, true), 1u
    ret
  }
}
)";
    EXPECT_EQ(src, str());

    Run(Builtins);

    auto expect = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:vec3<u32> = subgroupShuffleDown vec3<u32>(1u, 0u, 1u), 1u
    %3:vec3<bool> = convert %2
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, NonUniformShuffleDown_Constant_NumericScalar) {
    auto* ep = b.ComputeFunction("main");

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.u32(), spirv::BuiltinFn::kGroupNonUniformShuffleDown, 3_u,
                                       2_u, 1_u);
        b.Return(ep);
    });

    auto src = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:u32 = spirv.group_non_uniform_shuffle_down 3u, 2u, 1u
    ret
  }
}
)";
    EXPECT_EQ(src, str());

    Run(Builtins);

    auto expect = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:u32 = subgroupShuffleDown 2u, 1u
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, NonUniformShuffleDown_Constant_NumericVector) {
    auto* ep = b.ComputeFunction("main");

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.vec3u(), spirv::BuiltinFn::kGroupNonUniformShuffleDown,
                                       3_u, b.Composite(ty.vec3u(), 2_u, 3_u, 2_u), 1_u);
        b.Return(ep);
    });

    auto src = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:vec3<u32> = spirv.group_non_uniform_shuffle_down 3u, vec3<u32>(2u, 3u, 2u), 1u
    ret
  }
}
)";
    EXPECT_EQ(src, str());

    Run(Builtins);

    auto expect = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:vec3<u32> = subgroupShuffleDown vec3<u32>(2u, 3u, 2u), 1u
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, NonUniformShuffleUp_Constant_BoolScalar) {
    auto* ep = b.ComputeFunction("main");

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.bool_(), spirv::BuiltinFn::kGroupNonUniformShuffleUp, 3_u,
                                       true, 1_u);
        b.Return(ep);
    });

    auto src = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:bool = spirv.group_non_uniform_shuffle_up 3u, true, 1u
    ret
  }
}
)";
    EXPECT_EQ(src, str());

    Run(Builtins);

    auto expect = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:u32 = subgroupShuffleUp 1u, 1u
    %3:bool = convert %2
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, NonUniformShuffleUp_Constant_BoolVector) {
    auto* ep = b.ComputeFunction("main");

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.vec3(ty.bool_()),
                                       spirv::BuiltinFn::kGroupNonUniformShuffleUp, 3_u,
                                       b.Composite(ty.vec3(ty.bool_()), true, false, true), 1_u);
        b.Return(ep);
    });

    auto src = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:vec3<bool> = spirv.group_non_uniform_shuffle_up 3u, vec3<bool>(true, false, true), 1u
    ret
  }
}
)";
    EXPECT_EQ(src, str());

    Run(Builtins);

    auto expect = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:vec3<u32> = subgroupShuffleUp vec3<u32>(1u, 0u, 1u), 1u
    %3:vec3<bool> = convert %2
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, NonUniformShuffleUp_Constant_NumericScalar) {
    auto* ep = b.ComputeFunction("main");

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.u32(), spirv::BuiltinFn::kGroupNonUniformShuffleUp, 3_u,
                                       2_u, 1_u);
        b.Return(ep);
    });

    auto src = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:u32 = spirv.group_non_uniform_shuffle_up 3u, 2u, 1u
    ret
  }
}
)";
    EXPECT_EQ(src, str());

    Run(Builtins);

    auto expect = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:u32 = subgroupShuffleUp 2u, 1u
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, NonUniformShuffleUp_Constant_NumericVector) {
    auto* ep = b.ComputeFunction("main");

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.vec3u(), spirv::BuiltinFn::kGroupNonUniformShuffleUp, 3_u,
                                       b.Composite(ty.vec3u(), 2_u, 3_u, 2_u), 1_u);
        b.Return(ep);
    });

    auto src = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:vec3<u32> = spirv.group_non_uniform_shuffle_up 3u, vec3<u32>(2u, 3u, 2u), 1u
    ret
  }
}
)";
    EXPECT_EQ(src, str());

    Run(Builtins);

    auto expect = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:vec3<u32> = subgroupShuffleUp vec3<u32>(2u, 3u, 2u), 1u
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, NonUniformSMin_Scalar_i32) {
    auto* ep = b.ComputeFunction("main");

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.i32(), spirv::BuiltinFn::kGroupNonUniformSMin, 3_u, 0_u,
                                       1_i);
        b.Return(ep);
    });

    auto src = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:i32 = spirv.group_non_uniform_s_min 3u, 0u, 1i
    ret
  }
}
)";
    EXPECT_EQ(src, str());

    Run(Builtins);

    auto expect = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:i32 = subgroupMin 1i
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, NonUniformSMin_Vector_i32) {
    auto* ep = b.ComputeFunction("main");

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.vec3i(), spirv::BuiltinFn::kGroupNonUniformSMin, 3_u, 0_u,
                                       b.Composite(ty.vec3i(), 1_i, 3_i, 1_i));
        b.Return(ep);
    });

    auto src = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:vec3<i32> = spirv.group_non_uniform_s_min 3u, 0u, vec3<i32>(1i, 3i, 1i)
    ret
  }
}
)";
    EXPECT_EQ(src, str());

    Run(Builtins);

    auto expect = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:vec3<i32> = subgroupMin vec3<i32>(1i, 3i, 1i)
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, NonUniformSMin_Scalar_u32) {
    auto* ep = b.ComputeFunction("main");

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.u32(), spirv::BuiltinFn::kGroupNonUniformSMin, 3_u, 0_u,
                                       1_u);
        b.Return(ep);
    });

    auto src = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:u32 = spirv.group_non_uniform_s_min 3u, 0u, 1u
    ret
  }
}
)";
    EXPECT_EQ(src, str());

    Run(Builtins);

    auto expect = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:i32 = subgroupMin 1i
    %3:u32 = convert %2
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, NonUniformSMin_Vector_u32) {
    auto* ep = b.ComputeFunction("main");

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.vec3u(), spirv::BuiltinFn::kGroupNonUniformSMin, 3_u, 0_u,
                                       b.Composite(ty.vec3u(), 1_u, 3_u, 1_u));
        b.Return(ep);
    });

    auto src = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:vec3<u32> = spirv.group_non_uniform_s_min 3u, 0u, vec3<u32>(1u, 3u, 1u)
    ret
  }
}
)";
    EXPECT_EQ(src, str());

    Run(Builtins);

    auto expect = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:vec3<i32> = subgroupMin vec3<i32>(1i, 3i, 1i)
    %3:vec3<u32> = convert %2
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, NonUniformSMax_Scalar_i32) {
    auto* ep = b.ComputeFunction("main");

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.i32(), spirv::BuiltinFn::kGroupNonUniformSMax, 3_u, 0_u,
                                       1_i);
        b.Return(ep);
    });

    auto src = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:i32 = spirv.group_non_uniform_s_max 3u, 0u, 1i
    ret
  }
}
)";
    EXPECT_EQ(src, str());

    Run(Builtins);

    auto expect = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:i32 = subgroupMax 1i
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, NonUniformSMax_Vector_i32) {
    auto* ep = b.ComputeFunction("main");

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.vec3i(), spirv::BuiltinFn::kGroupNonUniformSMax, 3_u, 0_u,
                                       b.Composite(ty.vec3i(), 1_i, 3_i, 1_i));
        b.Return(ep);
    });

    auto src = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:vec3<i32> = spirv.group_non_uniform_s_max 3u, 0u, vec3<i32>(1i, 3i, 1i)
    ret
  }
}
)";
    EXPECT_EQ(src, str());

    Run(Builtins);

    auto expect = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:vec3<i32> = subgroupMax vec3<i32>(1i, 3i, 1i)
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, NonUniformSMax_Scalar_u32) {
    auto* ep = b.ComputeFunction("main");

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.u32(), spirv::BuiltinFn::kGroupNonUniformSMax, 3_u, 0_u,
                                       1_u);
        b.Return(ep);
    });

    auto src = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:u32 = spirv.group_non_uniform_s_max 3u, 0u, 1u
    ret
  }
}
)";
    EXPECT_EQ(src, str());

    Run(Builtins);

    auto expect = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:i32 = subgroupMax 1i
    %3:u32 = convert %2
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

TEST_F(SpirvReader_BuiltinsTest, NonUniformSMax_Vector_u32) {
    auto* ep = b.ComputeFunction("main");

    b.Append(ep->Block(), [&] {  //
        b.Call<spirv::ir::BuiltinCall>(ty.vec3u(), spirv::BuiltinFn::kGroupNonUniformSMax, 3_u, 0_u,
                                       b.Composite(ty.vec3u(), 1_u, 3_u, 1_u));
        b.Return(ep);
    });

    auto src = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:vec3<u32> = spirv.group_non_uniform_s_max 3u, 0u, vec3<u32>(1u, 3u, 1u)
    ret
  }
}
)";
    EXPECT_EQ(src, str());

    Run(Builtins);

    auto expect = R"(
%main = @compute @workgroup_size(1u, 1u, 1u) func():void {
  $B1: {
    %2:vec3<i32> = subgroupMax vec3<i32>(1i, 3i, 1i)
    %3:vec3<u32> = convert %2
    ret
  }
}
)";
    EXPECT_EQ(expect, str());
}

}  // namespace
}  // namespace tint::spirv::reader::lower