src/tint/transform/builtin_polyfill_test.cc

// Copyright 2022 The Tint Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#include "src/tint/transform/builtin_polyfill.h"

#include <utility>

#include "src/tint/transform/test_helper.h"

namespace tint::transform {
namespace {

using Level = BuiltinPolyfill::Level;

using BuiltinPolyfillTest = TransformTest;

TEST_F(BuiltinPolyfillTest, ShouldRunEmptyModule) {
  auto* src = R"()";

  EXPECT_FALSE(ShouldRun<BuiltinPolyfill>(src));
}

TEST_F(BuiltinPolyfillTest, EmptyModule) {
  auto* src = R"()";

  auto* expect = src;

  auto got = Run<BuiltinPolyfill>(src);

  EXPECT_EQ(expect, str(got));
}

////////////////////////////////////////////////////////////////////////////////
// countLeadingZeros
////////////////////////////////////////////////////////////////////////////////
DataMap polyfillCountLeadingZeros() {
  BuiltinPolyfill::Builtins builtins;
  builtins.count_leading_zeros = true;
  DataMap data;
  data.Add<BuiltinPolyfill::Config>(builtins);
  return data;
}

TEST_F(BuiltinPolyfillTest, ShouldRunCountLeadingZeros) {
  auto* src = R"(
fn f() {
  countLeadingZeros(0xf);
}
)";

  EXPECT_FALSE(ShouldRun<BuiltinPolyfill>(src));
  EXPECT_TRUE(ShouldRun<BuiltinPolyfill>(src, polyfillCountLeadingZeros()));
}

TEST_F(BuiltinPolyfillTest, CountLeadingZeros_i32) {
  auto* src = R"(
fn f() {
  let r : i32 = countLeadingZeros(15);
}
)";

  auto* expect = R"(
fn tint_count_leading_zeros(v : i32) -> i32 {
  var x = u32(v);
  let b16 = select(0u, 16u, (x <= 65535u));
  x = (x << b16);
  let b8 = select(0u, 8u, (x <= 16777215u));
  x = (x << b8);
  let b4 = select(0u, 4u, (x <= 268435455u));
  x = (x << b4);
  let b2 = select(0u, 2u, (x <= 1073741823u));
  x = (x << b2);
  let b1 = select(0u, 1u, (x <= 2147483647u));
  let is_zero = select(0u, 1u, (x == 0u));
  return i32((((((b16 | b8) | b4) | b2) | b1) + is_zero));
}

fn f() {
  let r : i32 = tint_count_leading_zeros(15);
}
)";

  auto got = Run<BuiltinPolyfill>(src, polyfillCountLeadingZeros());

  EXPECT_EQ(expect, str(got));
}

TEST_F(BuiltinPolyfillTest, CountLeadingZeros_u32) {
  auto* src = R"(
fn f() {
  let r : u32 = countLeadingZeros(15u);
}
)";

  auto* expect = R"(
fn tint_count_leading_zeros(v : u32) -> u32 {
  var x = u32(v);
  let b16 = select(0u, 16u, (x <= 65535u));
  x = (x << b16);
  let b8 = select(0u, 8u, (x <= 16777215u));
  x = (x << b8);
  let b4 = select(0u, 4u, (x <= 268435455u));
  x = (x << b4);
  let b2 = select(0u, 2u, (x <= 1073741823u));
  x = (x << b2);
  let b1 = select(0u, 1u, (x <= 2147483647u));
  let is_zero = select(0u, 1u, (x == 0u));
  return u32((((((b16 | b8) | b4) | b2) | b1) + is_zero));
}

fn f() {
  let r : u32 = tint_count_leading_zeros(15u);
}
)";

  auto got = Run<BuiltinPolyfill>(src, polyfillCountLeadingZeros());

  EXPECT_EQ(expect, str(got));
}

TEST_F(BuiltinPolyfillTest, CountLeadingZeros_vec3_i32) {
  auto* src = R"(
fn f() {
  let r : vec3<i32> = countLeadingZeros(vec3<i32>(15));
}
)";

  auto* expect = R"(
fn tint_count_leading_zeros(v : vec3<i32>) -> vec3<i32> {
  var x = vec3<u32>(v);
  let b16 = select(vec3<u32>(0u), vec3<u32>(16u), (x <= vec3<u32>(65535u)));
  x = (x << b16);
  let b8 = select(vec3<u32>(0u), vec3<u32>(8u), (x <= vec3<u32>(16777215u)));
  x = (x << b8);
  let b4 = select(vec3<u32>(0u), vec3<u32>(4u), (x <= vec3<u32>(268435455u)));
  x = (x << b4);
  let b2 = select(vec3<u32>(0u), vec3<u32>(2u), (x <= vec3<u32>(1073741823u)));
  x = (x << b2);
  let b1 = select(vec3<u32>(0u), vec3<u32>(1u), (x <= vec3<u32>(2147483647u)));
  let is_zero = select(vec3<u32>(0u), vec3<u32>(1u), (x == vec3<u32>(0u)));
  return vec3<i32>((((((b16 | b8) | b4) | b2) | b1) + is_zero));
}

fn f() {
  let r : vec3<i32> = tint_count_leading_zeros(vec3<i32>(15));
}
)";

  auto got = Run<BuiltinPolyfill>(src, polyfillCountLeadingZeros());

  EXPECT_EQ(expect, str(got));
}

TEST_F(BuiltinPolyfillTest, CountLeadingZeros_vec3_u32) {
  auto* src = R"(
fn f() {
  let r : vec3<u32> = countLeadingZeros(vec3<u32>(15u));
}
)";

  auto* expect = R"(
fn tint_count_leading_zeros(v : vec3<u32>) -> vec3<u32> {
  var x = vec3<u32>(v);
  let b16 = select(vec3<u32>(0u), vec3<u32>(16u), (x <= vec3<u32>(65535u)));
  x = (x << b16);
  let b8 = select(vec3<u32>(0u), vec3<u32>(8u), (x <= vec3<u32>(16777215u)));
  x = (x << b8);
  let b4 = select(vec3<u32>(0u), vec3<u32>(4u), (x <= vec3<u32>(268435455u)));
  x = (x << b4);
  let b2 = select(vec3<u32>(0u), vec3<u32>(2u), (x <= vec3<u32>(1073741823u)));
  x = (x << b2);
  let b1 = select(vec3<u32>(0u), vec3<u32>(1u), (x <= vec3<u32>(2147483647u)));
  let is_zero = select(vec3<u32>(0u), vec3<u32>(1u), (x == vec3<u32>(0u)));
  return vec3<u32>((((((b16 | b8) | b4) | b2) | b1) + is_zero));
}

fn f() {
  let r : vec3<u32> = tint_count_leading_zeros(vec3<u32>(15u));
}
)";

  auto got = Run<BuiltinPolyfill>(src, polyfillCountLeadingZeros());

  EXPECT_EQ(expect, str(got));
}

////////////////////////////////////////////////////////////////////////////////
// countTrailingZeros
////////////////////////////////////////////////////////////////////////////////
DataMap polyfillCountTrailingZeros() {
  BuiltinPolyfill::Builtins builtins;
  builtins.count_trailing_zeros = true;
  DataMap data;
  data.Add<BuiltinPolyfill::Config>(builtins);
  return data;
}

TEST_F(BuiltinPolyfillTest, ShouldRunCountTrailingZeros) {
  auto* src = R"(
fn f() {
  countTrailingZeros(0xf);
}
)";

  EXPECT_FALSE(ShouldRun<BuiltinPolyfill>(src));
  EXPECT_TRUE(ShouldRun<BuiltinPolyfill>(src, polyfillCountTrailingZeros()));
}

TEST_F(BuiltinPolyfillTest, CountTrailingZeros_i32) {
  auto* src = R"(
fn f() {
  let r : i32 = countTrailingZeros(15);
}
)";

  auto* expect = R"(
fn tint_count_trailing_zeros(v : i32) -> i32 {
  var x = u32(v);
  let b16 = select(16u, 0u, bool((x & 65535u)));
  x = (x >> b16);
  let b8 = select(8u, 0u, bool((x & 255u)));
  x = (x >> b8);
  let b4 = select(4u, 0u, bool((x & 15u)));
  x = (x >> b4);
  let b2 = select(2u, 0u, bool((x & 3u)));
  x = (x >> b2);
  let b1 = select(1u, 0u, bool((x & 1u)));
  let is_zero = select(0u, 1u, (x == 0u));
  return i32((((((b16 | b8) | b4) | b2) | b1) + is_zero));
}

fn f() {
  let r : i32 = tint_count_trailing_zeros(15);
}
)";

  auto got = Run<BuiltinPolyfill>(src, polyfillCountTrailingZeros());

  EXPECT_EQ(expect, str(got));
}

TEST_F(BuiltinPolyfillTest, CountTrailingZeros_u32) {
  auto* src = R"(
fn f() {
  let r : u32 = countTrailingZeros(15u);
}
)";

  auto* expect = R"(
fn tint_count_trailing_zeros(v : u32) -> u32 {
  var x = u32(v);
  let b16 = select(16u, 0u, bool((x & 65535u)));
  x = (x >> b16);
  let b8 = select(8u, 0u, bool((x & 255u)));
  x = (x >> b8);
  let b4 = select(4u, 0u, bool((x & 15u)));
  x = (x >> b4);
  let b2 = select(2u, 0u, bool((x & 3u)));
  x = (x >> b2);
  let b1 = select(1u, 0u, bool((x & 1u)));
  let is_zero = select(0u, 1u, (x == 0u));
  return u32((((((b16 | b8) | b4) | b2) | b1) + is_zero));
}

fn f() {
  let r : u32 = tint_count_trailing_zeros(15u);
}
)";

  auto got = Run<BuiltinPolyfill>(src, polyfillCountTrailingZeros());

  EXPECT_EQ(expect, str(got));
}

TEST_F(BuiltinPolyfillTest, CountTrailingZeros_vec3_i32) {
  auto* src = R"(
fn f() {
  let r : vec3<i32> = countTrailingZeros(vec3<i32>(15));
}
)";

  auto* expect = R"(
fn tint_count_trailing_zeros(v : vec3<i32>) -> vec3<i32> {
  var x = vec3<u32>(v);
  let b16 = select(vec3<u32>(16u), vec3<u32>(0u), vec3<bool>((x & vec3<u32>(65535u))));
  x = (x >> b16);
  let b8 = select(vec3<u32>(8u), vec3<u32>(0u), vec3<bool>((x & vec3<u32>(255u))));
  x = (x >> b8);
  let b4 = select(vec3<u32>(4u), vec3<u32>(0u), vec3<bool>((x & vec3<u32>(15u))));
  x = (x >> b4);
  let b2 = select(vec3<u32>(2u), vec3<u32>(0u), vec3<bool>((x & vec3<u32>(3u))));
  x = (x >> b2);
  let b1 = select(vec3<u32>(1u), vec3<u32>(0u), vec3<bool>((x & vec3<u32>(1u))));
  let is_zero = select(vec3<u32>(0u), vec3<u32>(1u), (x == vec3<u32>(0u)));
  return vec3<i32>((((((b16 | b8) | b4) | b2) | b1) + is_zero));
}

fn f() {
  let r : vec3<i32> = tint_count_trailing_zeros(vec3<i32>(15));
}
)";

  auto got = Run<BuiltinPolyfill>(src, polyfillCountTrailingZeros());

  EXPECT_EQ(expect, str(got));
}

TEST_F(BuiltinPolyfillTest, CountTrailingZeros_vec3_u32) {
  auto* src = R"(
fn f() {
  let r : vec3<u32> = countTrailingZeros(vec3<u32>(15u));
}
)";

  auto* expect = R"(
fn tint_count_trailing_zeros(v : vec3<u32>) -> vec3<u32> {
  var x = vec3<u32>(v);
  let b16 = select(vec3<u32>(16u), vec3<u32>(0u), vec3<bool>((x & vec3<u32>(65535u))));
  x = (x >> b16);
  let b8 = select(vec3<u32>(8u), vec3<u32>(0u), vec3<bool>((x & vec3<u32>(255u))));
  x = (x >> b8);
  let b4 = select(vec3<u32>(4u), vec3<u32>(0u), vec3<bool>((x & vec3<u32>(15u))));
  x = (x >> b4);
  let b2 = select(vec3<u32>(2u), vec3<u32>(0u), vec3<bool>((x & vec3<u32>(3u))));
  x = (x >> b2);
  let b1 = select(vec3<u32>(1u), vec3<u32>(0u), vec3<bool>((x & vec3<u32>(1u))));
  let is_zero = select(vec3<u32>(0u), vec3<u32>(1u), (x == vec3<u32>(0u)));
  return vec3<u32>((((((b16 | b8) | b4) | b2) | b1) + is_zero));
}

fn f() {
  let r : vec3<u32> = tint_count_trailing_zeros(vec3<u32>(15u));
}
)";

  auto got = Run<BuiltinPolyfill>(src, polyfillCountTrailingZeros());

  EXPECT_EQ(expect, str(got));
}

////////////////////////////////////////////////////////////////////////////////
// extractBits
////////////////////////////////////////////////////////////////////////////////
DataMap polyfillExtractBits(Level level) {
  BuiltinPolyfill::Builtins builtins;
  builtins.extract_bits = level;
  DataMap data;
  data.Add<BuiltinPolyfill::Config>(builtins);
  return data;
}

TEST_F(BuiltinPolyfillTest, ShouldRunExtractBits) {
  auto* src = R"(
fn f() {
  extractBits(1234, 5u, 6u);
}
)";

  EXPECT_FALSE(ShouldRun<BuiltinPolyfill>(src));
  EXPECT_FALSE(
      ShouldRun<BuiltinPolyfill>(src, polyfillExtractBits(Level::kNone)));
  EXPECT_TRUE(ShouldRun<BuiltinPolyfill>(
      src, polyfillExtractBits(Level::kClampParameters)));
  EXPECT_TRUE(
      ShouldRun<BuiltinPolyfill>(src, polyfillExtractBits(Level::kFull)));
}

TEST_F(BuiltinPolyfillTest, ExtractBits_Full_i32) {
  auto* src = R"(
fn f() {
  let r : i32 = extractBits(1234, 5u, 6u);
}
)";

  auto* expect = R"(
fn tint_extract_bits(v : i32, offset : u32, count : u32) -> i32 {
  let s = min(offset, 32u);
  let e = min(32u, (s + count));
  let shl = (32u - e);
  let shr = (shl + s);
  return ((v << shl) >> shr);
}

fn f() {
  let r : i32 = tint_extract_bits(1234, 5u, 6u);
}
)";

  auto got = Run<BuiltinPolyfill>(src, polyfillExtractBits(Level::kFull));

  EXPECT_EQ(expect, str(got));
}

TEST_F(BuiltinPolyfillTest, ExtractBits_Full_u32) {
  auto* src = R"(
fn f() {
  let r : u32 = extractBits(1234u, 5u, 6u);
}
)";

  auto* expect = R"(
fn tint_extract_bits(v : u32, offset : u32, count : u32) -> u32 {
  let s = min(offset, 32u);
  let e = min(32u, (s + count));
  let shl = (32u - e);
  let shr = (shl + s);
  return ((v << shl) >> shr);
}

fn f() {
  let r : u32 = tint_extract_bits(1234u, 5u, 6u);
}
)";

  auto got = Run<BuiltinPolyfill>(src, polyfillExtractBits(Level::kFull));

  EXPECT_EQ(expect, str(got));
}

TEST_F(BuiltinPolyfillTest, ExtractBits_Full_vec3_i32) {
  auto* src = R"(
fn f() {
  let r : vec3<i32> = extractBits(vec3<i32>(1234), 5u, 6u);
}
)";

  auto* expect = R"(
fn tint_extract_bits(v : vec3<i32>, offset : u32, count : u32) -> vec3<i32> {
  let s = min(offset, 32u);
  let e = min(32u, (s + count));
  let shl = (32u - e);
  let shr = (shl + s);
  return ((v << vec3<u32>(shl)) >> vec3<u32>(shr));
}

fn f() {
  let r : vec3<i32> = tint_extract_bits(vec3<i32>(1234), 5u, 6u);
}
)";

  auto got = Run<BuiltinPolyfill>(src, polyfillExtractBits(Level::kFull));

  EXPECT_EQ(expect, str(got));
}

TEST_F(BuiltinPolyfillTest, ExtractBits_Full_vec3_u32) {
  auto* src = R"(
fn f() {
  let r : vec3<u32> = extractBits(vec3<u32>(1234u), 5u, 6u);
}
)";

  auto* expect = R"(
fn tint_extract_bits(v : vec3<u32>, offset : u32, count : u32) -> vec3<u32> {
  let s = min(offset, 32u);
  let e = min(32u, (s + count));
  let shl = (32u - e);
  let shr = (shl + s);
  return ((v << vec3<u32>(shl)) >> vec3<u32>(shr));
}

fn f() {
  let r : vec3<u32> = tint_extract_bits(vec3<u32>(1234u), 5u, 6u);
}
)";

  auto got = Run<BuiltinPolyfill>(src, polyfillExtractBits(Level::kFull));

  EXPECT_EQ(expect, str(got));
}

TEST_F(BuiltinPolyfillTest, ExtractBits_Clamp_i32) {
  auto* src = R"(
fn f() {
  let r : i32 = extractBits(1234, 5u, 6u);
}
)";

  auto* expect = R"(
fn tint_extract_bits(v : i32, offset : u32, count : u32) -> i32 {
  let s = min(offset, 32u);
  let e = min(32u, (s + count));
  return extractBits(v, s, (e - s));
}

fn f() {
  let r : i32 = tint_extract_bits(1234, 5u, 6u);
}
)";

  auto got =
      Run<BuiltinPolyfill>(src, polyfillExtractBits(Level::kClampParameters));

  EXPECT_EQ(expect, str(got));
}

TEST_F(BuiltinPolyfillTest, ExtractBits_Clamp_u32) {
  auto* src = R"(
fn f() {
  let r : u32 = extractBits(1234u, 5u, 6u);
}
)";

  auto* expect = R"(
fn tint_extract_bits(v : u32, offset : u32, count : u32) -> u32 {
  let s = min(offset, 32u);
  let e = min(32u, (s + count));
  return extractBits(v, s, (e - s));
}

fn f() {
  let r : u32 = tint_extract_bits(1234u, 5u, 6u);
}
)";

  auto got =
      Run<BuiltinPolyfill>(src, polyfillExtractBits(Level::kClampParameters));

  EXPECT_EQ(expect, str(got));
}

TEST_F(BuiltinPolyfillTest, ExtractBits_Clamp_vec3_i32) {
  auto* src = R"(
fn f() {
  let r : vec3<i32> = extractBits(vec3<i32>(1234), 5u, 6u);
}
)";

  auto* expect = R"(
fn tint_extract_bits(v : vec3<i32>, offset : u32, count : u32) -> vec3<i32> {
  let s = min(offset, 32u);
  let e = min(32u, (s + count));
  return extractBits(v, s, (e - s));
}

fn f() {
  let r : vec3<i32> = tint_extract_bits(vec3<i32>(1234), 5u, 6u);
}
)";

  auto got =
      Run<BuiltinPolyfill>(src, polyfillExtractBits(Level::kClampParameters));

  EXPECT_EQ(expect, str(got));
}

TEST_F(BuiltinPolyfillTest, ExtractBits_Clamp_vec3_u32) {
  auto* src = R"(
fn f() {
  let r : vec3<u32> = extractBits(vec3<u32>(1234u), 5u, 6u);
}
)";

  auto* expect = R"(
fn tint_extract_bits(v : vec3<u32>, offset : u32, count : u32) -> vec3<u32> {
  let s = min(offset, 32u);
  let e = min(32u, (s + count));
  return extractBits(v, s, (e - s));
}

fn f() {
  let r : vec3<u32> = tint_extract_bits(vec3<u32>(1234u), 5u, 6u);
}
)";

  auto got =
      Run<BuiltinPolyfill>(src, polyfillExtractBits(Level::kClampParameters));

  EXPECT_EQ(expect, str(got));
}

////////////////////////////////////////////////////////////////////////////////
// firstLeadingBit
////////////////////////////////////////////////////////////////////////////////
DataMap polyfillFirstLeadingBit() {
  BuiltinPolyfill::Builtins builtins;
  builtins.first_leading_bit = true;
  DataMap data;
  data.Add<BuiltinPolyfill::Config>(builtins);
  return data;
}

TEST_F(BuiltinPolyfillTest, ShouldRunFirstLeadingBit) {
  auto* src = R"(
fn f() {
  firstLeadingBit(0xf);
}
)";

  EXPECT_FALSE(ShouldRun<BuiltinPolyfill>(src));
  EXPECT_TRUE(ShouldRun<BuiltinPolyfill>(src, polyfillFirstLeadingBit()));
}

TEST_F(BuiltinPolyfillTest, FirstLeadingBit_i32) {
  auto* src = R"(
fn f() {
  let r : i32 = firstLeadingBit(15);
}
)";

  auto* expect = R"(
fn tint_first_leading_bit(v : i32) -> i32 {
  var x = select(u32(v), u32(~(v)), (v < 0));
  let b16 = select(0u, 16u, bool((x & 4294901760u)));
  x = (x >> b16);
  let b8 = select(0u, 8u, bool((x & 65280u)));
  x = (x >> b8);
  let b4 = select(0u, 4u, bool((x & 240u)));
  x = (x >> b4);
  let b2 = select(0u, 2u, bool((x & 12u)));
  x = (x >> b2);
  let b1 = select(0u, 1u, bool((x & 2u)));
  let is_zero = select(0u, 4294967295u, (x == 0u));
  return i32((((((b16 | b8) | b4) | b2) | b1) | is_zero));
}

fn f() {
  let r : i32 = tint_first_leading_bit(15);
}
)";

  auto got = Run<BuiltinPolyfill>(src, polyfillFirstLeadingBit());

  EXPECT_EQ(expect, str(got));
}

TEST_F(BuiltinPolyfillTest, FirstLeadingBit_u32) {
  auto* src = R"(
fn f() {
  let r : u32 = firstLeadingBit(15u);
}
)";

  auto* expect = R"(
fn tint_first_leading_bit(v : u32) -> u32 {
  var x = v;
  let b16 = select(0u, 16u, bool((x & 4294901760u)));
  x = (x >> b16);
  let b8 = select(0u, 8u, bool((x & 65280u)));
  x = (x >> b8);
  let b4 = select(0u, 4u, bool((x & 240u)));
  x = (x >> b4);
  let b2 = select(0u, 2u, bool((x & 12u)));
  x = (x >> b2);
  let b1 = select(0u, 1u, bool((x & 2u)));
  let is_zero = select(0u, 4294967295u, (x == 0u));
  return u32((((((b16 | b8) | b4) | b2) | b1) | is_zero));
}

fn f() {
  let r : u32 = tint_first_leading_bit(15u);
}
)";

  auto got = Run<BuiltinPolyfill>(src, polyfillFirstLeadingBit());

  EXPECT_EQ(expect, str(got));
}

TEST_F(BuiltinPolyfillTest, FirstLeadingBit_vec3_i32) {
  auto* src = R"(
fn f() {
  let r : vec3<i32> = firstLeadingBit(vec3<i32>(15));
}
)";

  auto* expect = R"(
fn tint_first_leading_bit(v : vec3<i32>) -> vec3<i32> {
  var x = select(vec3<u32>(v), vec3<u32>(~(v)), (v < vec3<i32>(0)));
  let b16 = select(vec3<u32>(0u), vec3<u32>(16u), vec3<bool>((x & vec3<u32>(4294901760u))));
  x = (x >> b16);
  let b8 = select(vec3<u32>(0u), vec3<u32>(8u), vec3<bool>((x & vec3<u32>(65280u))));
  x = (x >> b8);
  let b4 = select(vec3<u32>(0u), vec3<u32>(4u), vec3<bool>((x & vec3<u32>(240u))));
  x = (x >> b4);
  let b2 = select(vec3<u32>(0u), vec3<u32>(2u), vec3<bool>((x & vec3<u32>(12u))));
  x = (x >> b2);
  let b1 = select(vec3<u32>(0u), vec3<u32>(1u), vec3<bool>((x & vec3<u32>(2u))));
  let is_zero = select(vec3<u32>(0u), vec3<u32>(4294967295u), (x == vec3<u32>(0u)));
  return vec3<i32>((((((b16 | b8) | b4) | b2) | b1) | is_zero));
}

fn f() {
  let r : vec3<i32> = tint_first_leading_bit(vec3<i32>(15));
}
)";

  auto got = Run<BuiltinPolyfill>(src, polyfillFirstLeadingBit());

  EXPECT_EQ(expect, str(got));
}

TEST_F(BuiltinPolyfillTest, FirstLeadingBit_vec3_u32) {
  auto* src = R"(
fn f() {
  let r : vec3<u32> = firstLeadingBit(vec3<u32>(15u));
}
)";

  auto* expect = R"(
fn tint_first_leading_bit(v : vec3<u32>) -> vec3<u32> {
  var x = v;
  let b16 = select(vec3<u32>(0u), vec3<u32>(16u), vec3<bool>((x & vec3<u32>(4294901760u))));
  x = (x >> b16);
  let b8 = select(vec3<u32>(0u), vec3<u32>(8u), vec3<bool>((x & vec3<u32>(65280u))));
  x = (x >> b8);
  let b4 = select(vec3<u32>(0u), vec3<u32>(4u), vec3<bool>((x & vec3<u32>(240u))));
  x = (x >> b4);
  let b2 = select(vec3<u32>(0u), vec3<u32>(2u), vec3<bool>((x & vec3<u32>(12u))));
  x = (x >> b2);
  let b1 = select(vec3<u32>(0u), vec3<u32>(1u), vec3<bool>((x & vec3<u32>(2u))));
  let is_zero = select(vec3<u32>(0u), vec3<u32>(4294967295u), (x == vec3<u32>(0u)));
  return vec3<u32>((((((b16 | b8) | b4) | b2) | b1) | is_zero));
}

fn f() {
  let r : vec3<u32> = tint_first_leading_bit(vec3<u32>(15u));
}
)";

  auto got = Run<BuiltinPolyfill>(src, polyfillFirstLeadingBit());

  EXPECT_EQ(expect, str(got));
}

////////////////////////////////////////////////////////////////////////////////
// firstTrailingBit
////////////////////////////////////////////////////////////////////////////////
DataMap polyfillFirstTrailingBit() {
  BuiltinPolyfill::Builtins builtins;
  builtins.first_trailing_bit = true;
  DataMap data;
  data.Add<BuiltinPolyfill::Config>(builtins);
  return data;
}

TEST_F(BuiltinPolyfillTest, ShouldRunFirstTrailingBit) {
  auto* src = R"(
fn f() {
  firstTrailingBit(0xf);
}
)";

  EXPECT_FALSE(ShouldRun<BuiltinPolyfill>(src));
  EXPECT_TRUE(ShouldRun<BuiltinPolyfill>(src, polyfillFirstTrailingBit()));
}

TEST_F(BuiltinPolyfillTest, FirstTrailingBit_i32) {
  auto* src = R"(
fn f() {
  let r : i32 = firstTrailingBit(15);
}
)";

  auto* expect = R"(
fn tint_first_trailing_bit(v : i32) -> i32 {
  var x = u32(v);
  let b16 = select(16u, 0u, bool((x & 65535u)));
  x = (x >> b16);
  let b8 = select(8u, 0u, bool((x & 255u)));
  x = (x >> b8);
  let b4 = select(4u, 0u, bool((x & 15u)));
  x = (x >> b4);
  let b2 = select(2u, 0u, bool((x & 3u)));
  x = (x >> b2);
  let b1 = select(1u, 0u, bool((x & 1u)));
  let is_zero = select(0u, 4294967295u, (x == 0u));
  return i32((((((b16 | b8) | b4) | b2) | b1) | is_zero));
}

fn f() {
  let r : i32 = tint_first_trailing_bit(15);
}
)";

  auto got = Run<BuiltinPolyfill>(src, polyfillFirstTrailingBit());

  EXPECT_EQ(expect, str(got));
}

TEST_F(BuiltinPolyfillTest, FirstTrailingBit_u32) {
  auto* src = R"(
fn f() {
  let r : u32 = firstTrailingBit(15u);
}
)";

  auto* expect = R"(
fn tint_first_trailing_bit(v : u32) -> u32 {
  var x = u32(v);
  let b16 = select(16u, 0u, bool((x & 65535u)));
  x = (x >> b16);
  let b8 = select(8u, 0u, bool((x & 255u)));
  x = (x >> b8);
  let b4 = select(4u, 0u, bool((x & 15u)));
  x = (x >> b4);
  let b2 = select(2u, 0u, bool((x & 3u)));
  x = (x >> b2);
  let b1 = select(1u, 0u, bool((x & 1u)));
  let is_zero = select(0u, 4294967295u, (x == 0u));
  return u32((((((b16 | b8) | b4) | b2) | b1) | is_zero));
}

fn f() {
  let r : u32 = tint_first_trailing_bit(15u);
}
)";

  auto got = Run<BuiltinPolyfill>(src, polyfillFirstTrailingBit());

  EXPECT_EQ(expect, str(got));
}

TEST_F(BuiltinPolyfillTest, FirstTrailingBit_vec3_i32) {
  auto* src = R"(
fn f() {
  let r : vec3<i32> = firstTrailingBit(vec3<i32>(15));
}
)";

  auto* expect = R"(
fn tint_first_trailing_bit(v : vec3<i32>) -> vec3<i32> {
  var x = vec3<u32>(v);
  let b16 = select(vec3<u32>(16u), vec3<u32>(0u), vec3<bool>((x & vec3<u32>(65535u))));
  x = (x >> b16);
  let b8 = select(vec3<u32>(8u), vec3<u32>(0u), vec3<bool>((x & vec3<u32>(255u))));
  x = (x >> b8);
  let b4 = select(vec3<u32>(4u), vec3<u32>(0u), vec3<bool>((x & vec3<u32>(15u))));
  x = (x >> b4);
  let b2 = select(vec3<u32>(2u), vec3<u32>(0u), vec3<bool>((x & vec3<u32>(3u))));
  x = (x >> b2);
  let b1 = select(vec3<u32>(1u), vec3<u32>(0u), vec3<bool>((x & vec3<u32>(1u))));
  let is_zero = select(vec3<u32>(0u), vec3<u32>(4294967295u), (x == vec3<u32>(0u)));
  return vec3<i32>((((((b16 | b8) | b4) | b2) | b1) | is_zero));
}

fn f() {
  let r : vec3<i32> = tint_first_trailing_bit(vec3<i32>(15));
}
)";

  auto got = Run<BuiltinPolyfill>(src, polyfillFirstTrailingBit());

  EXPECT_EQ(expect, str(got));
}

TEST_F(BuiltinPolyfillTest, FirstTrailingBit_vec3_u32) {
  auto* src = R"(
fn f() {
  let r : vec3<u32> = firstTrailingBit(vec3<u32>(15u));
}
)";

  auto* expect = R"(
fn tint_first_trailing_bit(v : vec3<u32>) -> vec3<u32> {
  var x = vec3<u32>(v);
  let b16 = select(vec3<u32>(16u), vec3<u32>(0u), vec3<bool>((x & vec3<u32>(65535u))));
  x = (x >> b16);
  let b8 = select(vec3<u32>(8u), vec3<u32>(0u), vec3<bool>((x & vec3<u32>(255u))));
  x = (x >> b8);
  let b4 = select(vec3<u32>(4u), vec3<u32>(0u), vec3<bool>((x & vec3<u32>(15u))));
  x = (x >> b4);
  let b2 = select(vec3<u32>(2u), vec3<u32>(0u), vec3<bool>((x & vec3<u32>(3u))));
  x = (x >> b2);
  let b1 = select(vec3<u32>(1u), vec3<u32>(0u), vec3<bool>((x & vec3<u32>(1u))));
  let is_zero = select(vec3<u32>(0u), vec3<u32>(4294967295u), (x == vec3<u32>(0u)));
  return vec3<u32>((((((b16 | b8) | b4) | b2) | b1) | is_zero));
}

fn f() {
  let r : vec3<u32> = tint_first_trailing_bit(vec3<u32>(15u));
}
)";

  auto got = Run<BuiltinPolyfill>(src, polyfillFirstTrailingBit());

  EXPECT_EQ(expect, str(got));
}

////////////////////////////////////////////////////////////////////////////////
// insertBits
////////////////////////////////////////////////////////////////////////////////
DataMap polyfillInsertBits(Level level) {
  BuiltinPolyfill::Builtins builtins;
  builtins.insert_bits = level;
  DataMap data;
  data.Add<BuiltinPolyfill::Config>(builtins);
  return data;
}

TEST_F(BuiltinPolyfillTest, ShouldRunInsertBits) {
  auto* src = R"(
fn f() {
  insertBits(1234, 5678, 5u, 6u);
}
)";

  EXPECT_FALSE(ShouldRun<BuiltinPolyfill>(src));
  EXPECT_FALSE(
      ShouldRun<BuiltinPolyfill>(src, polyfillInsertBits(Level::kNone)));
  EXPECT_TRUE(ShouldRun<BuiltinPolyfill>(
      src, polyfillInsertBits(Level::kClampParameters)));
  EXPECT_TRUE(
      ShouldRun<BuiltinPolyfill>(src, polyfillInsertBits(Level::kFull)));
}

TEST_F(BuiltinPolyfillTest, InsertBits_Full_i32) {
  auto* src = R"(
fn f() {
  let r : i32 = insertBits(1234, 5678, 5u, 6u);
}
)";

  auto* expect = R"(
fn tint_insert_bits(v : i32, n : i32, offset : u32, count : u32) -> i32 {
  let s = min(offset, 32u);
  let e = min(32u, (s + count));
  let mask = (((1u << s) - 1u) ^ ((1u << e) - 1u));
  return (((n << s) & i32(mask)) | (v & i32(~(mask))));
}

fn f() {
  let r : i32 = tint_insert_bits(1234, 5678, 5u, 6u);
}
)";

  auto got = Run<BuiltinPolyfill>(src, polyfillInsertBits(Level::kFull));

  EXPECT_EQ(expect, str(got));
}

TEST_F(BuiltinPolyfillTest, InsertBits_Full_u32) {
  auto* src = R"(
fn f() {
  let r : u32 = insertBits(1234u, 5678u, 5u, 6u);
}
)";

  auto* expect = R"(
fn tint_insert_bits(v : u32, n : u32, offset : u32, count : u32) -> u32 {
  let s = min(offset, 32u);
  let e = min(32u, (s + count));
  let mask = (((1u << s) - 1u) ^ ((1u << e) - 1u));
  return (((n << s) & mask) | (v & ~(mask)));
}

fn f() {
  let r : u32 = tint_insert_bits(1234u, 5678u, 5u, 6u);
}
)";

  auto got = Run<BuiltinPolyfill>(src, polyfillInsertBits(Level::kFull));

  EXPECT_EQ(expect, str(got));
}

TEST_F(BuiltinPolyfillTest, InsertBits_Full_vec3_i32) {
  auto* src = R"(
fn f() {
  let r : vec3<i32> = insertBits(vec3<i32>(1234), vec3<i32>(5678), 5u, 6u);
}
)";

  auto* expect = R"(
fn tint_insert_bits(v : vec3<i32>, n : vec3<i32>, offset : u32, count : u32) -> vec3<i32> {
  let s = min(offset, 32u);
  let e = min(32u, (s + count));
  let mask = (((1u << s) - 1u) ^ ((1u << e) - 1u));
  return (((n << vec3<u32>(s)) & vec3<i32>(i32(mask))) | (v & vec3<i32>(i32(~(mask)))));
}

fn f() {
  let r : vec3<i32> = tint_insert_bits(vec3<i32>(1234), vec3<i32>(5678), 5u, 6u);
}
)";

  auto got = Run<BuiltinPolyfill>(src, polyfillInsertBits(Level::kFull));

  EXPECT_EQ(expect, str(got));
}

TEST_F(BuiltinPolyfillTest, InsertBits_Full_vec3_u32) {
  auto* src = R"(
fn f() {
  let r : vec3<u32> = insertBits(vec3<u32>(1234u), vec3<u32>(5678u), 5u, 6u);
}
)";

  auto* expect = R"(
fn tint_insert_bits(v : vec3<u32>, n : vec3<u32>, offset : u32, count : u32) -> vec3<u32> {
  let s = min(offset, 32u);
  let e = min(32u, (s + count));
  let mask = (((1u << s) - 1u) ^ ((1u << e) - 1u));
  return (((n << vec3<u32>(s)) & vec3<u32>(mask)) | (v & vec3<u32>(~(mask))));
}

fn f() {
  let r : vec3<u32> = tint_insert_bits(vec3<u32>(1234u), vec3<u32>(5678u), 5u, 6u);
}
)";

  auto got = Run<BuiltinPolyfill>(src, polyfillInsertBits(Level::kFull));

  EXPECT_EQ(expect, str(got));
}

TEST_F(BuiltinPolyfillTest, InsertBits_Clamp_i32) {
  auto* src = R"(
fn f() {
  let r : i32 = insertBits(1234, 5678, 5u, 6u);
}
)";

  auto* expect = R"(
fn tint_insert_bits(v : i32, n : i32, offset : u32, count : u32) -> i32 {
  let s = min(offset, 32u);
  let e = min(32u, (s + count));
  return insertBits(v, n, s, (e - s));
}

fn f() {
  let r : i32 = tint_insert_bits(1234, 5678, 5u, 6u);
}
)";

  auto got =
      Run<BuiltinPolyfill>(src, polyfillInsertBits(Level::kClampParameters));

  EXPECT_EQ(expect, str(got));
}

TEST_F(BuiltinPolyfillTest, InsertBits_Clamp_u32) {
  auto* src = R"(
fn f() {
  let r : u32 = insertBits(1234u, 5678u, 5u, 6u);
}
)";

  auto* expect = R"(
fn tint_insert_bits(v : u32, n : u32, offset : u32, count : u32) -> u32 {
  let s = min(offset, 32u);
  let e = min(32u, (s + count));
  return insertBits(v, n, s, (e - s));
}

fn f() {
  let r : u32 = tint_insert_bits(1234u, 5678u, 5u, 6u);
}
)";

  auto got =
      Run<BuiltinPolyfill>(src, polyfillInsertBits(Level::kClampParameters));

  EXPECT_EQ(expect, str(got));
}

TEST_F(BuiltinPolyfillTest, InsertBits_Clamp_vec3_i32) {
  auto* src = R"(
fn f() {
  let r : vec3<i32> = insertBits(vec3<i32>(1234), vec3<i32>(5678), 5u, 6u);
}
)";

  auto* expect = R"(
fn tint_insert_bits(v : vec3<i32>, n : vec3<i32>, offset : u32, count : u32) -> vec3<i32> {
  let s = min(offset, 32u);
  let e = min(32u, (s + count));
  return insertBits(v, n, s, (e - s));
}

fn f() {
  let r : vec3<i32> = tint_insert_bits(vec3<i32>(1234), vec3<i32>(5678), 5u, 6u);
}
)";

  auto got =
      Run<BuiltinPolyfill>(src, polyfillInsertBits(Level::kClampParameters));

  EXPECT_EQ(expect, str(got));
}

TEST_F(BuiltinPolyfillTest, InsertBits_Clamp_vec3_u32) {
  auto* src = R"(
fn f() {
  let r : vec3<u32> = insertBits(vec3<u32>(1234u), vec3<u32>(5678u), 5u, 6u);
}
)";

  auto* expect = R"(
fn tint_insert_bits(v : vec3<u32>, n : vec3<u32>, offset : u32, count : u32) -> vec3<u32> {
  let s = min(offset, 32u);
  let e = min(32u, (s + count));
  return insertBits(v, n, s, (e - s));
}

fn f() {
  let r : vec3<u32> = tint_insert_bits(vec3<u32>(1234u), vec3<u32>(5678u), 5u, 6u);
}
)";

  auto got =
      Run<BuiltinPolyfill>(src, polyfillInsertBits(Level::kClampParameters));

  EXPECT_EQ(expect, str(got));
}

}  // namespace
}  // namespace tint::transform