xref: /aosp_15_r20/external/mesa3d/src/microsoft/clc/clc_compiler_test.cpp (revision 6104692788411f58d303aa86923a9ff6ecaded22)

/*
 * Copyright © Microsoft Corporation
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice (including the next
 * paragraph) shall be included in all copies or substantial portions of the
 * Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 * IN THE SOFTWARE.
 */

#include <cmath>
#include <stdio.h>
#include <stdint.h>
#include <stdexcept>
#include <vector>

#include <unknwn.h>
#include <directx/d3d12.h>
#include <dxgi1_4.h>
#include <gtest/gtest.h>
#include <wrl.h>
#include <dxguids/dxguids.h>

#include "compute_test.h"

using std::vector;

TEST_F(ComputeTest, runtime_memcpy)
{
   struct shift { uint8_t val; uint8_t shift; uint16_t ret; };
   const char *kernel_source =
   "struct shift { uchar val; uchar shift; ushort ret; };\n\
   __kernel void main_test(__global struct shift *inout)\n\
   {\n\
      uint id = get_global_id(0);\n\
      uint id2 = id + get_global_id(1);\n\
      struct shift lc[4] = { { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 }};\n\
      lc[id] = inout[id];\n\
      inout[id2].ret = (ushort) lc[id2].val << (ushort) lc[id2].shift;\n\
   }\n";

   auto inout = ShaderArg<struct shift>({
         { 0x10, 1, 0xffff },
         { 0x20, 2, 0xffff },
         { 0x30, 3, 0xffff },
         { 0x40, 4, 0xffff },
      },
      SHADER_ARG_INOUT);
   const uint16_t expected[] = { 0x20, 0x80, 0x180, 0x400 };
   run_shader(kernel_source, inout.size(), 1, 1, inout);
   for (int i = 0; i < inout.size(); ++i)
      EXPECT_EQ(inout[i].ret, expected[i]);
}

TEST_F(ComputeTest, two_global_arrays)
{
   const char *kernel_source =
   "__kernel void main_test(__global uint *g1, __global uint *g2)\n\
   {\n\
       uint idx = get_global_id(0);\n\
       g1[idx] -= g2[idx];\n\
   }\n";
   auto g1 = ShaderArg<uint32_t>({ 10, 20, 30, 40 }, SHADER_ARG_INOUT);
   auto g2 = ShaderArg<uint32_t>({ 1, 2, 3, 4 }, SHADER_ARG_INPUT);
   const uint32_t expected[] = {
      9, 18, 27, 36
   };

   run_shader(kernel_source, g1.size(), 1, 1, g1, g2);
   for (int i = 0; i < g1.size(); ++i)
      EXPECT_EQ(g1[i], expected[i]);
}

TEST_F(ComputeTest, nested_arrays)
{
   const char *kernel_source = R"(
float4 DoMagic(float4 inValue)
{
    const float testArr[3][3] = {
        {0.1f, 0.2f, 0.3f},
        {0.4f, 0.5f, 0.6f},
        {0.7f, 0.8f, 0.9f}};
    float4 outValue = inValue;
    outValue.x = inValue.x * testArr[0][0] + inValue.y * testArr[0][1] + inValue.z * testArr[0][2];
    outValue.y = inValue.x * testArr[1][0] + inValue.y * testArr[1][1] + inValue.z * testArr[1][2];
    outValue.z = inValue.x * testArr[2][0] + inValue.y * testArr[2][1] + inValue.z * testArr[2][2];
    return outValue;
}
__kernel void main_test(__global float4 *g1, __global float4 *g2)
{
   uint idx = get_global_id(0);
   g1[idx] = DoMagic(g2[idx]);
})";
   auto g1 = ShaderArg<float>({ 10, 20, 30, 40 }, SHADER_ARG_INOUT);
   auto g2 = ShaderArg<float>({ 0.2f, 0.4f, 0.6f, 1.0f }, SHADER_ARG_INPUT);
   const float expected[] = {
      0.28f, 0.64f, 1.0f, 1.0f
   };

   run_shader(kernel_source, 1, 1, 1, g1, g2);
   for (int i = 0; i < g1.size(); ++i)
      EXPECT_FLOAT_EQ(g1[i], expected[i]);
}

/* Disabled until saturated conversions from f32->i64 fixed (mesa/mesa#3824) */
TEST_F(ComputeTest, DISABLED_i64tof32)
{
   const char *kernel_source =
   "__kernel void main_test(__global long *out, __constant long *in)\n\
   {\n\
       __local float tmp[12];\n\
       uint idx = get_global_id(0);\n\
       tmp[idx] = in[idx];\n\
       barrier(CLK_LOCAL_MEM_FENCE);\n\
       out[idx] = tmp[idx + get_global_id(1)];\n\
   }\n";
   auto in = ShaderArg<int64_t>({ 0x100000000LL,
                                  -0x100000000LL,
                                  0x7fffffffffffffffLL,
                                  0x4000004000000000LL,
                                  0x4000003fffffffffLL,
                                  0x4000004000000001LL,
                                  -1,
                                  -0x4000004000000000LL,
                                  -0x4000003fffffffffLL,
                                  -0x4000004000000001LL,
                                  0,
                                  INT64_MIN },
                                SHADER_ARG_INPUT);
   auto out = ShaderArg<int64_t>(std::vector<int64_t>(12, 0xdeadbeed), SHADER_ARG_OUTPUT);
   const int64_t expected[] = {
      0x100000000LL,
      -0x100000000LL,
      0x7fffffffffffffffLL,
      0x4000000000000000LL,
      0x4000000000000000LL,
      0x4000008000000000LL,
      -1,
      -0x4000000000000000LL,
      -0x4000000000000000LL,
      -0x4000008000000000LL,
      0,
      INT64_MIN,
   };

   run_shader(kernel_source, out.size(), 1, 1, out, in);
   for (int i = 0; i < out.size(); ++i) {
      EXPECT_EQ((int64_t)out[i], expected[i]);
   }
}
TEST_F(ComputeTest, two_constant_arrays)
{
   const char *kernel_source =
   "__kernel void main_test(__constant uint *c1, __global uint *g1, __constant uint *c2)\n\
   {\n\
       uint idx = get_global_id(0);\n\
       g1[idx] -= c1[idx] + c2[idx];\n\
   }\n";
   auto g1 = ShaderArg<uint32_t>({ 10, 20, 30, 40 }, SHADER_ARG_INOUT);
   auto c1 = ShaderArg<uint32_t>({ 1, 2, 3, 4 }, SHADER_ARG_INPUT);
   auto c2 = ShaderArg<uint32_t>(std::vector<uint32_t>(16384, 5), SHADER_ARG_INPUT);
   const uint32_t expected[] = {
      4, 13, 22, 31
   };

   run_shader(kernel_source, g1.size(), 1, 1, c1, g1, c2);
   for (int i = 0; i < g1.size(); ++i)
      EXPECT_EQ(g1[i], expected[i]);
}

TEST_F(ComputeTest, null_constant_ptr)
{
   const char *kernel_source =
   "__kernel void main_test(__global uint *g1, __constant uint *c1)\n\
   {\n\
       __constant uint fallback[] = {2, 3, 4, 5};\n\
       __constant uint *c = c1 ? c1 : fallback;\n\
       uint idx = get_global_id(0);\n\
       g1[idx] -= c[idx];\n\
   }\n";
   auto g1 = ShaderArg<uint32_t>({ 10, 20, 30, 40 }, SHADER_ARG_INOUT);
   auto c1 = ShaderArg<uint32_t>({ 1, 2, 3, 4 }, SHADER_ARG_INPUT);
   const uint32_t expected1[] = {
      9, 18, 27, 36
   };

   run_shader(kernel_source, g1.size(), 1, 1, g1, c1);
   for (int i = 0; i < g1.size(); ++i)
      EXPECT_EQ(g1[i], expected1[i]);

   const uint32_t expected2[] = {
      8, 17, 26, 35
   };

   g1 = ShaderArg<uint32_t>({ 10, 20, 30, 40 }, SHADER_ARG_INOUT);
   auto c2 = NullShaderArg();
   run_shader(kernel_source, g1.size(), 1, 1, g1, c2);
   for (int i = 0; i < g1.size(); ++i)
      EXPECT_EQ(g1[i], expected2[i]);
}

TEST_F(ComputeTest, null_global_ptr)
{
   const char *kernel_source =
   "__kernel void main_test(__global uint *g1, __global uint *g2)\n\
   {\n\
       __constant uint fallback[] = {2, 3, 4, 5};\n\
       uint idx = get_global_id(0);\n\
       g1[idx] -= g2 ? g2[idx] : fallback[idx];\n\
   }\n";
   auto g1 = ShaderArg<uint32_t>({ 10, 20, 30, 40 }, SHADER_ARG_INOUT);
   auto g2 = ShaderArg<uint32_t>({ 1, 2, 3, 4 }, SHADER_ARG_INPUT);
   const uint32_t expected1[] = {
      9, 18, 27, 36
   };

   run_shader(kernel_source, g1.size(), 1, 1, g1, g2);
   for (int i = 0; i < g1.size(); ++i)
      EXPECT_EQ(g1[i], expected1[i]);

   const uint32_t expected2[] = {
      8, 17, 26, 35
   };

   g1 = ShaderArg<uint32_t>({ 10, 20, 30, 40 }, SHADER_ARG_INOUT);
   auto g2null = NullShaderArg();
   run_shader(kernel_source, g1.size(), 1, 1, g1, g2null);
   for (int i = 0; i < g1.size(); ++i)
      EXPECT_EQ(g1[i], expected2[i]);
}

TEST_F(ComputeTest, ret_constant_ptr)
{
   struct s { uint64_t ptr; uint32_t val; };
   const char *kernel_source =
   "struct s { __constant uint *ptr; uint val; };\n\
   __kernel void main_test(__global struct s *out, __constant uint *in)\n\
   {\n\
       __constant uint foo[] = { 1, 2 };\n\
       uint idx = get_global_id(0);\n\
       if (idx == 0)\n\
          out[idx].ptr = foo;\n\
       else\n\
          out[idx].ptr = in;\n\
       out[idx].val = out[idx].ptr[idx];\n\
   }\n";
   auto out = ShaderArg<struct s>(std::vector<struct s>(2, {0xdeadbeefdeadbeef, 0}), SHADER_ARG_OUTPUT);
   auto in = ShaderArg<uint32_t>({ 3, 4 }, SHADER_ARG_INPUT);
   const uint32_t expected_val[] = {
      1, 4
   };
   const uint64_t expected_ptr[] = {
      2ull << 32, 1ull << 32
   };

   run_shader(kernel_source, out.size(), 1, 1, out, in);
   for (int i = 0; i < out.size(); ++i) {
      EXPECT_EQ(out[i].val, expected_val[i]);
      EXPECT_EQ(out[i].ptr, expected_ptr[i]);
   }
}

TEST_F(ComputeTest, ret_global_ptr)
{
   struct s { uint64_t ptr; uint32_t val; };
   const char *kernel_source =
   "struct s { __global uint *ptr; uint val; };\n\
   __kernel void main_test(__global struct s *out, __global uint *in1, __global uint *in2)\n\
   {\n\
       uint idx = get_global_id(0);\n\
       out[idx].ptr = idx ? in2 : in1;\n\
       out[idx].val = out[idx].ptr[idx];\n\
   }\n";
   auto out = ShaderArg<struct s>(std::vector<struct s>(2, {0xdeadbeefdeadbeef, 0}), SHADER_ARG_OUTPUT);
   auto in1 = ShaderArg<uint32_t>({ 1, 2 }, SHADER_ARG_INPUT);
   auto in2 = ShaderArg<uint32_t>({ 3, 4 }, SHADER_ARG_INPUT);
   const uint32_t expected_val[] = {
      1, 4
   };
   const uint64_t expected_ptr[] = {
      1ull << 32, 2ull << 32
   };

   run_shader(kernel_source, out.size(), 1, 1, out, in1, in2);
   for (int i = 0; i < out.size(); ++i) {
      EXPECT_EQ(out[i].val, expected_val[i]);
      EXPECT_EQ(out[i].ptr, expected_ptr[i]);
   }
}

TEST_F(ComputeTest, ret_local_ptr)
{
   struct s { uint64_t ptr; };
   const char *kernel_source =
   "struct s { __local uint *ptr; };\n\
   __kernel void main_test(__global struct s *out)\n\
   {\n\
       __local uint tmp[2];\n\
       uint idx = get_global_id(0);\n\
       tmp[idx] = idx;\n\
       out[idx].ptr = &tmp[idx];\n\
   }\n";
   auto out = ShaderArg<struct s>(std::vector<struct s>(2, { 0xdeadbeefdeadbeef }), SHADER_ARG_OUTPUT);
   const uint64_t expected_ptr[] = {
      0, 4,
   };

   run_shader(kernel_source, out.size(), 1, 1, out);
   for (int i = 0; i < out.size(); ++i) {
      EXPECT_EQ(out[i].ptr, expected_ptr[i]);
   }
}

TEST_F(ComputeTest, ret_private_ptr)
{
   struct s { uint64_t ptr; uint32_t value; };
   const char *kernel_source =
   "struct s { __private uint *ptr; uint value; };\n\
   __kernel void main_test(__global struct s *out)\n\
   {\n\
       uint tmp[2] = {1, 2};\n\
       uint idx = get_global_id(0);\n\
       out[idx].ptr = &tmp[idx];\n\
       out[idx].value = *out[idx].ptr;\n\
   }\n";
   auto out = ShaderArg<struct s>(std::vector<struct s>(2, { 0xdeadbeefdeadbeef }), SHADER_ARG_OUTPUT);
   const uint64_t expected_ptr[] = {
      0, 4,
   };
   const uint32_t expected_value[] = {
      1, 2
   };

   run_shader(kernel_source, out.size(), 1, 1, out);
   for (int i = 0; i < out.size(); ++i) {
      EXPECT_EQ(out[i].ptr, expected_ptr[i]);
   }
}

TEST_F(ComputeTest, globals_8bit)
{
   const char *kernel_source =
   "__kernel void main_test(__global unsigned char *inout)\n\
   {\n\
       uint idx = get_global_id(0);\n\
       inout[idx] = inout[idx] + 1;\n\
   }\n";
   auto inout = ShaderArg<uint8_t> ({ 100, 110, 120, 130 }, SHADER_ARG_INOUT);
   const uint8_t expected[] = {
      101, 111, 121, 131
   };
   run_shader(kernel_source, inout.size(), 1, 1, inout);
   for (int i = 0; i < inout.size(); ++i)
      EXPECT_EQ(inout[i], expected[i]);
}

TEST_F(ComputeTest, globals_16bit)
{
   const char *kernel_source =
   "__kernel void main_test(__global unsigned short *inout)\n\
   {\n\
       uint idx = get_global_id(0);\n\
       inout[idx] = inout[idx] + 1;\n\
   }\n";
   auto inout = ShaderArg<uint16_t> ({ 10000, 10010, 10020, 10030 }, SHADER_ARG_INOUT);
   const uint16_t expected[] = {
      10001, 10011, 10021, 10031
   };
   run_shader(kernel_source, inout.size(), 1, 1, inout);
   for (int i = 0; i < inout.size(); ++i)
      EXPECT_EQ(inout[i], expected[i]);
}

TEST_F(ComputeTest, globals_64bit)
{
   const char *kernel_source =
   "__kernel void main_test(__global unsigned long *inout)\n\
   {\n\
       uint idx = get_global_id(0);\n\
       inout[idx] = inout[idx] + 1;\n\
   }\n";
   uint64_t base = 1ull << 50;
   auto inout = ShaderArg<uint64_t>({ base, base + 10, base + 20, base + 30 },
                                    SHADER_ARG_INOUT);
   const uint64_t expected[] = {
      base + 1, base + 11, base + 21, base + 31
   };
   run_shader(kernel_source, inout.size(), 1, 1, inout);
   for (int i = 0; i < inout.size(); ++i)
      EXPECT_EQ(inout[i], expected[i]);
}

TEST_F(ComputeTest, built_ins_global_id)
{
   const char *kernel_source =
   "__kernel void main_test(__global uint *output)\n\
   {\n\
       output[get_global_id(0)] = get_global_id(0);\n\
   }\n";
   auto output = ShaderArg<uint32_t>(std::vector<uint32_t>(4, 0xdeadbeef),
                                     SHADER_ARG_OUTPUT);
   const uint32_t expected[] = {
      0, 1, 2, 3
   };

   run_shader(kernel_source, output.size(), 1, 1, output);
   for (int i = 0; i < output.size(); ++i)
      EXPECT_EQ(output[i], expected[i]);
}

TEST_F(ComputeTest, built_ins_global_id_rmw)
{
   const char *kernel_source =
   "__kernel void main_test(__global uint *output)\n\
   {\n\
       uint id = get_global_id(0);\n\
       output[id] = output[id] * (id + 1);\n\
   }\n";
   auto inout = ShaderArg<uint32_t>({0x00000001, 0x10000001, 0x00020002, 0x04010203},
                                    SHADER_ARG_INOUT);
   const uint32_t expected[] = {
      0x00000001, 0x20000002, 0x00060006, 0x1004080c
   };
   run_shader(kernel_source, inout.size(), 1, 1, inout);
   for (int i = 0; i < inout.size(); ++i)
      EXPECT_EQ(inout[i], expected[i]);
}

TEST_F(ComputeTest, types_float_basics)
{
   const char *kernel_source =
   "__kernel void main_test(__global uint *output)\n\
   {\n\
       output[get_global_id(0)] = (uint)((float)get_global_id(0) + 1.5f);\n\
   }\n";
   auto output = ShaderArg<uint32_t>(std::vector<uint32_t>(4, 0xdeadbeef),
                                     SHADER_ARG_OUTPUT);
   const uint32_t expected[] = {
      1, 2, 3, 4
   };
   run_shader(kernel_source, output.size(), 1, 1, output);
   for (int i = 0; i < output.size(); ++i)
      EXPECT_EQ(output[i], expected[i]);
}

TEST_F(ComputeTest, DISABLED_types_double_basics)
{
   /* Disabled because doubles are unsupported */
   const char *kernel_source =
   "__kernel void main_test(__global uint *output)\n\
   {\n\
       output[get_global_id(0)] = (uint)((double)get_global_id(0) + 1.5);\n\
   }\n";
   auto output = ShaderArg<uint32_t>(std::vector<uint32_t>(4, 0xdeadbeef),
                                     SHADER_ARG_OUTPUT);
   const uint32_t expected[] = {
      1, 2, 3, 4
   };
   run_shader(kernel_source, output.size(), 1, 1, output);
   for (int i = 0; i < output.size(); ++i)
      EXPECT_EQ(output[i], expected[i]);
}

TEST_F(ComputeTest, types_short_basics)
{
   const char *kernel_source =
   "__kernel void main_test(__global uint *output)\n\
   {\n\
       output[get_global_id(0)] = (uint)((short)get_global_id(0) + (short)1);\n\
   }\n";
   auto output = ShaderArg<uint32_t>(std::vector<uint32_t>(4, 0xdeadbeef),
                                     SHADER_ARG_OUTPUT);
   const uint32_t expected[] = {
      1, 2, 3, 4
   };
   run_shader(kernel_source, output.size(), 1, 1, output);
   for (int i = 0; i < output.size(); ++i)
      EXPECT_EQ(output[i], expected[i]);
}

TEST_F(ComputeTest, types_char_basics)
{
   const char *kernel_source =
   "__kernel void main_test(__global uint *output)\n\
   {\n\
       output[get_global_id(0)] = (uint)((char)get_global_id(0) + (char)1);\n\
   }\n";
   auto output = ShaderArg<uint32_t>(std::vector<uint32_t>(4, 0xdeadbeef),
                                     SHADER_ARG_OUTPUT);
   const uint32_t expected[] = {
      1, 2, 3, 4
   };
   run_shader(kernel_source, output.size(), 1, 1, output);
   for (int i = 0; i < output.size(); ++i)
      EXPECT_EQ(output[i], expected[i]);
}

TEST_F(ComputeTest, types_if_statement)
{
   const char *kernel_source =
   "__kernel void main_test(__global uint *output)\n\
   {\n\
       int idx = get_global_id(0);\n\
       if (idx > 0)\n\
           output[idx] = ~idx;\n\
       else\n\
           output[0] = 0xff;\n\
   }\n";
   auto output = ShaderArg<uint32_t>(std::vector<uint32_t>(4, 0xdeadbeef),
                                     SHADER_ARG_OUTPUT);
   const uint32_t expected[] = {
      0xff, ~1u, ~2u, ~3u
   };
   run_shader(kernel_source, output.size(), 1, 1, output);
   for (int i = 0; i < output.size(); ++i)
      EXPECT_EQ(output[i], expected[i]);
}

TEST_F(ComputeTest, types_do_while_loop)
{
   const char *kernel_source =
   "__kernel void main_test(__global uint *output)\n\
   {\n\
       int value = 1;\n\
       int i = 1, n = get_global_id(0);\n\
       do {\n\
          value *= i++;\n\
       } while (i <= n);\n\
       output[n] = value;\n\
   }\n";
   auto output = ShaderArg<uint32_t>(std::vector<uint32_t>(5, 0xdeadbeef),
                                     SHADER_ARG_OUTPUT);
   const uint32_t expected[] = {
      1, 1, 1*2, 1*2*3, 1*2*3*4
   };
   run_shader(kernel_source, output.size(), 1, 1, output);
   for (int i = 0; i < output.size(); ++i)
      EXPECT_EQ(output[i], expected[i]);
}

TEST_F(ComputeTest, types_for_loop)
{
   const char *kernel_source =
   "__kernel void main_test(__global uint *output)\n\
   {\n\
       int value = 1;\n\
       int n = get_global_id(0);\n\
       for (int i = 1; i <= n; ++i)\n\
          value *= i;\n\
       output[n] = value;\n\
   }\n";
   auto output = ShaderArg<uint32_t>(std::vector<uint32_t>(5, 0xdeadbeef),
                                     SHADER_ARG_OUTPUT);
   const uint32_t expected[] = {
      1, 1, 1*2, 1*2*3, 1*2*3*4
   };
   run_shader(kernel_source, output.size(), 1, 1, output);
   for (int i = 0; i < output.size(); ++i)
      EXPECT_EQ(output[i], expected[i]);
}

TEST_F(ComputeTest, complex_types_local_array_long)
{
   const char *kernel_source =
   "__kernel void main_test(__global ulong *inout)\n\
   {\n\
      ulong tmp[] = {\n\
         get_global_id(1) + 0x00000000,\n\
         get_global_id(1) + 0x10000001,\n\
         get_global_id(1) + 0x20000020,\n\
         get_global_id(1) + 0x30000300,\n\
      };\n\
      uint idx = get_global_id(0);\n\
      inout[idx] = tmp[idx];\n\
   }\n";
   auto inout = ShaderArg<uint64_t>({ 0, 0, 0, 0 }, SHADER_ARG_INOUT);
   const uint64_t expected[] = {
      0x00000000, 0x10000001, 0x20000020, 0x30000300,
   };
   run_shader(kernel_source, inout.size(), 1, 1, inout);
   for (int i = 0; i < inout.size(); ++i)
      EXPECT_EQ(inout[i], expected[i]);
}

TEST_F(ComputeTest, complex_types_local_array_short)
{
   const char *kernel_source =
   "__kernel void main_test(__global ushort *inout)\n\
   {\n\
      ushort tmp[] = {\n\
         get_global_id(1) + 0x00,\n\
         get_global_id(1) + 0x10,\n\
         get_global_id(1) + 0x20,\n\
         get_global_id(1) + 0x30,\n\
      };\n\
      uint idx = get_global_id(0);\n\
      inout[idx] = tmp[idx];\n\
   }\n";
   auto inout = ShaderArg<uint16_t>({ 0, 0, 0, 0 }, SHADER_ARG_INOUT);
   const uint16_t expected[] = {
      0x00, 0x10, 0x20, 0x30,
   };
   run_shader(kernel_source, inout.size(), 1, 1, inout);
   for (int i = 0; i < inout.size(); ++i)
      EXPECT_EQ(inout[i], expected[i]);
}

TEST_F(ComputeTest, complex_types_local_array_struct_vec_float_misaligned)
{
   const char *kernel_source =
   "struct has_vecs { uchar c; ushort s; float2 f; };\n\
   __kernel void main_test(__global uint *inout)\n\
   {\n\
      struct has_vecs tmp[] = {\n\
         { 10 + get_global_id(0), get_global_id(1), { 10.0f, 1.0f } },\n\
         { 19 + get_global_id(0), get_global_id(1), { 20.0f, 4.0f } },\n\
         { 28 + get_global_id(0), get_global_id(1), { 30.0f, 9.0f } },\n\
         { 37 + get_global_id(0), get_global_id(1), { 40.0f, 16.0f } },\n\
      };\n\
      uint idx = get_global_id(0);\n\
      uint mul = (tmp[idx].c + tmp[idx].s) * trunc(tmp[idx].f[0]);\n\
      inout[idx] = mul + trunc(tmp[idx].f[1]);\n\
   }\n";
   auto inout = ShaderArg<uint32_t>({ 0, 0, 0, 0 }, SHADER_ARG_INOUT);
   const uint16_t expected[] = { 101, 404, 909, 1616 };
   run_shader(kernel_source, inout.size(), 1, 1, inout);
   for (int i = 0; i < inout.size(); ++i)
      EXPECT_EQ(inout[i], expected[i]);
}

TEST_F(ComputeTest, complex_types_local_array)
{
   const char *kernel_source =
   "__kernel void main_test(__global uint *inout)\n\
   {\n\
      uint tmp[] = {\n\
         get_global_id(1) + 0x00,\n\
         get_global_id(1) + 0x10,\n\
         get_global_id(1) + 0x20,\n\
         get_global_id(1) + 0x30,\n\
      };\n\
      uint idx = get_global_id(0);\n\
      inout[idx] = tmp[idx];\n\
   }\n";
   auto inout = ShaderArg<uint32_t>({ 0, 0, 0, 0 }, SHADER_ARG_INOUT);
   const uint32_t expected[] = {
      0x00, 0x10, 0x20, 0x30,
   };
   run_shader(kernel_source, inout.size(), 1, 1, inout);
   for (int i = 0; i < inout.size(); ++i)
      EXPECT_EQ(inout[i], expected[i]);
}

TEST_F(ComputeTest, complex_types_global_struct_array)
{
   struct two_vals { uint32_t add; uint32_t mul; };
   const char *kernel_source =
   "struct two_vals { uint add; uint mul; };\n\
   __kernel void main_test(__global struct two_vals *in_out)\n\
   {\n\
      uint id = get_global_id(0);\n\
      in_out[id].add = in_out[id].add + id;\n\
      in_out[id].mul = in_out[id].mul * id;\n\
   }\n";
   auto inout = ShaderArg<struct two_vals>({ { 8, 8 }, { 16, 16 }, { 64, 64 }, { 65536, 65536 } },
                                           SHADER_ARG_INOUT);
   const struct two_vals expected[] = {
      { 8 + 0, 8 * 0 },
      { 16 + 1, 16 * 1 },
      { 64 + 2, 64 * 2 },
      { 65536 + 3, 65536 * 3 }
   };
   run_shader(kernel_source, inout.size(), 1, 1, inout);
   for (int i = 0; i < inout.size(); ++i) {
      EXPECT_EQ(inout[i].add, expected[i].add);
      EXPECT_EQ(inout[i].mul, expected[i].mul);
   }
}

TEST_F(ComputeTest, complex_types_global_uint2)
{
   struct uint2 { uint32_t x; uint32_t y; };
   const char *kernel_source =
   "__kernel void main_test(__global uint2 *inout)\n\
   {\n\
      uint id = get_global_id(0);\n\
      inout[id].x = inout[id].x + id;\n\
      inout[id].y = inout[id].y * id;\n\
   }\n";
   auto inout = ShaderArg<struct uint2>({ { 8, 8 }, { 16, 16 }, { 64, 64 }, { 65536, 65536 } },
                                        SHADER_ARG_INOUT);
   const struct uint2 expected[] = {
      { 8 + 0, 8 * 0 },
      { 16 + 1, 16 * 1 },
      { 64 + 2, 64 * 2 },
      { 65536 + 3, 65536 * 3 }
   };
   run_shader(kernel_source, inout.size(), 1, 1, inout);
   for (int i = 0; i < inout.size(); ++i) {
      EXPECT_EQ(inout[i].x, expected[i].x);
      EXPECT_EQ(inout[i].y, expected[i].y);
   }
}

TEST_F(ComputeTest, complex_types_global_ushort2)
{
   struct ushort2 { uint16_t x; uint16_t y; };
   const char *kernel_source =
   "__kernel void main_test(__global ushort2 *inout)\n\
   {\n\
      uint id = get_global_id(0);\n\
      inout[id].x = inout[id].x + id;\n\
      inout[id].y = inout[id].y * id;\n\
   }\n";
   auto inout = ShaderArg<struct ushort2>({ { 8, 8 }, { 16, 16 }, { 64, 64 },
                                            { (uint16_t)65536, (uint16_t)65536 } },
                                          SHADER_ARG_INOUT);
   const struct ushort2 expected[] = {
      { 8 + 0, 8 * 0 },
      { 16 + 1, 16 * 1 },
      { 64 + 2, 64 * 2 },
      { (uint16_t)(65536 + 3), (uint16_t)(65536 * 3) }
   };
   run_shader(kernel_source, inout.size(), 1, 1, inout);
   for (int i = 0; i < inout.size(); ++i) {
      EXPECT_EQ(inout[i].x, expected[i].x);
      EXPECT_EQ(inout[i].y, expected[i].y);
   }
}

TEST_F(ComputeTest, complex_types_global_uchar3)
{
   struct uchar3 { uint8_t x; uint8_t y; uint8_t z; uint8_t pad; };
   const char *kernel_source =
   "__kernel void main_test(__global uchar3 *inout)\n\
   {\n\
      uint id = get_global_id(0);\n\
      inout[id].x = inout[id].x + id;\n\
      inout[id].y = inout[id].y * id;\n\
      inout[id].z = inout[id].y + inout[id].x;\n\
   }\n";
   auto inout = ShaderArg<struct uchar3>({ { 8, 8, 8 }, { 16, 16, 16 }, { 64, 64, 64 }, { 255, 255, 255 } },
                                         SHADER_ARG_INOUT);
   const struct uchar3 expected[] = {
      { 8 + 0, 8 * 0, (8 + 0) + (8 * 0) },
      { 16 + 1, 16 * 1, (16 + 1) + (16 * 1) },
      { 64 + 2, 64 * 2, (64 + 2) + (64 * 2) },
      { (uint8_t)(255 + 3), (uint8_t)(255 * 3), (uint8_t)((255 + 3) + (255 * 3)) }
   };
   run_shader(kernel_source, inout.size(), 1, 1, inout);
   for (int i = 0; i < inout.size(); ++i) {
      EXPECT_EQ(inout[i].x, expected[i].x);
      EXPECT_EQ(inout[i].y, expected[i].y);
      EXPECT_EQ(inout[i].z, expected[i].z);
   }
}

TEST_F(ComputeTest, complex_types_constant_uchar3)
{
   struct uchar3 { uint8_t x; uint8_t y; uint8_t z; uint8_t pad; };
   const char *kernel_source =
   "__kernel void main_test(__global uchar3 *out, __constant uchar3 *in)\n\
   {\n\
      uint id = get_global_id(0);\n\
      out[id].x = in[id].x + id;\n\
      out[id].y = in[id].y * id;\n\
      out[id].z = out[id].y + out[id].x;\n\
   }\n";
   auto in = ShaderArg<struct uchar3>({ { 8, 8, 8 }, { 16, 16, 16 }, { 64, 64, 64 }, { 255, 255, 255 } },
                                      SHADER_ARG_INPUT);
   auto out = ShaderArg<struct uchar3>(std::vector<struct uchar3>(4, { 0xff, 0xff, 0xff }),
                                      SHADER_ARG_OUTPUT);
   const struct uchar3 expected[] = {
      { 8 + 0, 8 * 0, (8 + 0) + (8 * 0) },
      { 16 + 1, 16 * 1, (16 + 1) + (16 * 1) },
      { 64 + 2, 64 * 2, (64 + 2) + (64 * 2) },
      { (uint8_t)(255 + 3), (uint8_t)(255 * 3), (uint8_t)((255 + 3) + (255 * 3)) }
   };
   run_shader(kernel_source, out.size(), 1, 1, out, in);
   for (int i = 0; i < out.size(); ++i) {
      EXPECT_EQ(out[i].x, expected[i].x);
      EXPECT_EQ(out[i].y, expected[i].y);
      EXPECT_EQ(out[i].z, expected[i].z);
   }
}

TEST_F(ComputeTest, complex_types_global_uint8)
{
   struct uint8 {
      uint32_t s0; uint32_t s1; uint32_t s2; uint32_t s3;
      uint32_t s4; uint32_t s5; uint32_t s6; uint32_t s7;
   };
   const char *kernel_source =
   "__kernel void main_test(__global uint8 *inout)\n\
   {\n\
      uint id = get_global_id(0);\n\
      inout[id].s01234567 = inout[id].s01234567 * 2;\n\
   }\n";
   auto inout = ShaderArg<struct uint8>({ { 1, 2, 3, 4, 5, 6, 7, 8 } },
                                        SHADER_ARG_INOUT);
   const struct uint8 expected[] = {
      { 2, 4, 6, 8, 10, 12, 14, 16 }
   };
   run_shader(kernel_source, inout.size(), 1, 1, inout);
   for (int i = 0; i < inout.size(); ++i) {
      EXPECT_EQ(inout[i].s0, expected[i].s0);
      EXPECT_EQ(inout[i].s1, expected[i].s1);
      EXPECT_EQ(inout[i].s2, expected[i].s2);
      EXPECT_EQ(inout[i].s3, expected[i].s3);
      EXPECT_EQ(inout[i].s4, expected[i].s4);
      EXPECT_EQ(inout[i].s5, expected[i].s5);
      EXPECT_EQ(inout[i].s6, expected[i].s6);
      EXPECT_EQ(inout[i].s7, expected[i].s7);
   }
}

TEST_F(ComputeTest, complex_types_local_ulong16)
{
   struct ulong16 {
      uint64_t values[16];
   };
   const char *kernel_source =
   R"(__kernel void main_test(__global ulong16 *inout)
   {
      __local ulong16 local_array[2];
      uint id = get_global_id(0);
      local_array[id] = inout[id];
      barrier(CLK_LOCAL_MEM_FENCE);
      inout[id] = local_array[0] * 2;
   })";
   auto inout = ShaderArg<struct ulong16>({ { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 } },
                                        SHADER_ARG_INOUT);
   const struct ulong16 expected[] = {
      { 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30 }
   };
   run_shader(kernel_source, inout.size(), 1, 1, inout);
   for (int i = 0; i < inout.size(); ++i) {
      for (int j = 0; j < 16; ++j) {
         EXPECT_EQ(inout[i].values[j], expected[i].values[j]);
      }
   }
}

TEST_F(ComputeTest, complex_types_constant_uint8)
{
   struct uint8 {
      uint32_t s0; uint32_t s1; uint32_t s2; uint32_t s3;
      uint32_t s4; uint32_t s5; uint32_t s6; uint32_t s7;
   };
   const char *kernel_source =
   "__kernel void main_test(__global uint8 *out, __constant uint8 *in)\n\
   {\n\
      uint id = get_global_id(0);\n\
      out[id].s01234567 = in[id].s01234567 * 2;\n\
   }\n";
   auto in = ShaderArg<struct uint8>({ { 1, 2, 3, 4, 5, 6, 7, 8 } },
                                     SHADER_ARG_INPUT);
   auto out = ShaderArg<struct uint8>({ { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff } },
                                      SHADER_ARG_INOUT);
   const struct uint8 expected[] = {
      { 2, 4, 6, 8, 10, 12, 14, 16 }
   };
   run_shader(kernel_source, out.size(), 1, 1, out, in);
   for (int i = 0; i < out.size(); ++i) {
      EXPECT_EQ(out[i].s0, expected[i].s0);
      EXPECT_EQ(out[i].s1, expected[i].s1);
      EXPECT_EQ(out[i].s2, expected[i].s2);
      EXPECT_EQ(out[i].s3, expected[i].s3);
      EXPECT_EQ(out[i].s4, expected[i].s4);
      EXPECT_EQ(out[i].s5, expected[i].s5);
      EXPECT_EQ(out[i].s6, expected[i].s6);
      EXPECT_EQ(out[i].s7, expected[i].s7);
   }
}

TEST_F(ComputeTest, complex_types_const_array)
{
   const char *kernel_source =
   "__kernel void main_test(__global uint *output)\n\
   {\n\
       const uint foo[] = { 100, 101, 102, 103 };\n\
       output[get_global_id(0)] = foo[get_global_id(0) % 4];\n\
   }\n";
   auto output = ShaderArg<uint32_t>(std::vector<uint32_t>(4, 0xdeadbeef),
                                     SHADER_ARG_OUTPUT);
   const uint32_t expected[] = {
      100, 101, 102, 103
   };
   run_shader(kernel_source, output.size(), 1, 1, output);
   for (int i = 0; i < output.size(); ++i)
      EXPECT_EQ(output[i], expected[i]);
}

TEST_F(ComputeTest, mem_access_load_store_ordering)
{
   const char *kernel_source =
   "__kernel void main_test(__global uint *output)\n\
   {\n\
       uint foo[4];\n\
       foo[0] = 0x11111111;\n\
       foo[1] = 0x22222222;\n\
       foo[2] = 0x44444444;\n\
       foo[3] = 0x88888888;\n\
       foo[get_global_id(1)] -= 0x11111111; // foo[0] = 0 \n\
       foo[0] += get_global_id(0); // foo[0] = tid\n\
       foo[foo[get_global_id(1)]] = get_global_id(0); // foo[tid] = tid\n\
       output[get_global_id(0)] = foo[get_global_id(0)]; // output[tid] = tid\n\
   }\n";
   auto output = ShaderArg<uint32_t>(std::vector<uint32_t>(4, 0xdeadbeef),
                                     SHADER_ARG_OUTPUT);
   const uint16_t expected[] = {
      0, 1, 2, 3
   };
   run_shader(kernel_source, output.size(), 1, 1, output);
   for (int i = 0; i < output.size(); ++i)
      EXPECT_EQ(output[i], expected[i]);
}

TEST_F(ComputeTest, two_const_arrays)
{
   const char *kernel_source =
   "__kernel void main_test(__global uint *output)\n\
   {\n\
      uint id = get_global_id(0);\n\
      uint foo[4] = {100, 101, 102, 103};\n\
      uint bar[4] = {1, 2, 3, 4};\n\
      output[id] = foo[id] * bar[id];\n\
   }\n";
   auto output = ShaderArg<uint32_t>(std::vector<uint32_t>(4, 0xdeadbeef),
                                     SHADER_ARG_OUTPUT);
   const uint32_t expected[] = {
      100, 202, 306, 412
   };
   run_shader(kernel_source, output.size(), 1, 1, output);
   for (int i = 0; i < output.size(); ++i)
      EXPECT_EQ(output[i], expected[i]);
}

TEST_F(ComputeTest, imod_pos)
{
   const char *kernel_source =
   "__kernel void main_test(__global int *inout)\n\
   {\n\
       inout[get_global_id(0)] = inout[get_global_id(0)] % 3;\n\
   }\n";
   auto inout = ShaderArg<int32_t>({ -4, -3, -2, -1, 0, 1, 2, 3, 4 },
                                   SHADER_ARG_INOUT);
   const int32_t expected[] = {
      -1, 0, -2, -1,  0, 1, 2, 0, 1
   };
   run_shader(kernel_source, inout.size(), 1, 1, inout);
   for (int i = 0; i < inout.size(); ++i)
      EXPECT_EQ(inout[i], expected[i]);
}

TEST_F(ComputeTest, imod_neg)
{
   const char *kernel_source =
   "__kernel void main_test(__global int *inout)\n\
   {\n\
       inout[get_global_id(0)] = inout[get_global_id(0)] % -3;\n\
   }\n";
   auto inout = ShaderArg<int32_t>({ -4, -3, -2, -1, 0, 1, 2, 3, 4 },
                                   SHADER_ARG_INOUT);
   const int32_t expected[] = {
      -1, 0, -2, -1,  0, 1, 2, 0, 1
   };
   run_shader(kernel_source, inout.size(), 1, 1, inout);
   for (int i = 0; i < inout.size(); ++i)
      EXPECT_EQ(inout[i], expected[i]);
}

TEST_F(ComputeTest, umod)
{
   const char *kernel_source =
   "__kernel void main_test(__global uint *inout)\n\
   {\n\
       inout[get_global_id(0)] = inout[get_global_id(0)] % 0xfffffffc;\n\
   }\n";
   auto inout = ShaderArg<uint32_t>({ 0xfffffffa, 0xfffffffb, 0xfffffffc, 0xfffffffd, 0xfffffffe },
                                    SHADER_ARG_INOUT);
   const uint32_t expected[] = {
      0xfffffffa, 0xfffffffb, 0, 1, 2
   };
   run_shader(kernel_source, inout.size(), 1, 1, inout);
   for (int i = 0; i < inout.size(); ++i)
      EXPECT_EQ(inout[i], expected[i]);
}

TEST_F(ComputeTest, rotate)
{
   const char *kernel_source =
   "__kernel void main_test(__global uint *inout)\n\
   {\n\
       inout[get_global_id(0)] = rotate(inout[get_global_id(0)], (uint)get_global_id(0) * 4);\n\
   }\n";
   auto inout = ShaderArg<uint32_t>(std::vector<uint32_t>(4, 0xdeadbeef),
                                    SHADER_ARG_INOUT);
   const uint32_t expected[] = {
      0xdeadbeef, 0xeadbeefd, 0xadbeefde, 0xdbeefdea
   };
   run_shader(kernel_source, inout.size(), 1, 1, inout);
   for (int i = 0; i < inout.size(); ++i)
      EXPECT_EQ(inout[i], expected[i]);
}

TEST_F(ComputeTest, popcount)
{
   const char *kernel_source =
   "__kernel void main_test(__global uint *inout)\n\
   {\n\
       inout[get_global_id(0)] = popcount(inout[get_global_id(0)]);\n\
   }\n";
   auto inout = ShaderArg<uint32_t>({ 0, 0x1, 0x3, 0x101, 0x110011, ~0u },
                                    SHADER_ARG_INOUT);
   const uint32_t expected[] = {
      0, 1, 2, 2, 4, 32
   };
   run_shader(kernel_source, inout.size(), 1, 1, inout);
   for (int i = 0; i < inout.size(); ++i)
      EXPECT_EQ(inout[i], expected[i]);
}

TEST_F(ComputeTest, hadd)
{
   const char *kernel_source =
   "__kernel void main_test(__global uint *inout)\n\
   {\n\
       inout[get_global_id(0)] = hadd(inout[get_global_id(0)], 1u << 31);\n\
   }\n";
   auto inout = ShaderArg<uint32_t>({ 0, 1, 2, 3, 0xfffffffc, 0xfffffffd, 0xfffffffe, 0xffffffff },
                                    SHADER_ARG_INOUT);
   const uint32_t expected[] = {
      (1u << 31) >> 1,
      ((1u << 31) + 1) >> 1,
      ((1u << 31) + 2) >> 1,
      ((1u << 31) + 3) >> 1,
      ((1ull << 31) + 0xfffffffc) >> 1,
      ((1ull << 31) + 0xfffffffd) >> 1,
      ((1ull << 31) + 0xfffffffe) >> 1,
      ((1ull << 31) + 0xffffffff) >> 1,
   };
   run_shader(kernel_source, inout.size(), 1, 1, inout);
   for (int i = 0; i < inout.size(); ++i)
      EXPECT_EQ(inout[i], expected[i]);
}

TEST_F(ComputeTest, rhadd)
{
   const char *kernel_source =
   "__kernel void main_test(__global uint *inout)\n\
   {\n\
       inout[get_global_id(0)] = rhadd(inout[get_global_id(0)], 1u << 31);\n\
   }\n";
   auto inout = ShaderArg<uint32_t>({ 0, 1, 2, 3, 0xfffffffc, 0xfffffffd, 0xfffffffe, 0xffffffff },
                                    SHADER_ARG_INOUT);
   const uint32_t expected[] = {
      ((1u << 31) + 1) >> 1,
      ((1u << 31) + 2) >> 1,
      ((1u << 31) + 3) >> 1,
      ((1u << 31) + 4) >> 1,
      ((1ull << 31) + 0xfffffffd) >> 1,
      ((1ull << 31) + 0xfffffffe) >> 1,
      ((1ull << 31) + 0xffffffff) >> 1,
      ((1ull << 31) + (1ull << 32)) >> 1,
   };
   run_shader(kernel_source, inout.size(), 1, 1, inout);
   for (int i = 0; i < inout.size(); ++i)
      EXPECT_EQ(inout[i], expected[i]);
}

TEST_F(ComputeTest, add_sat)
{
   const char *kernel_source =
   "__kernel void main_test(__global uint *inout)\n\
   {\n\
       inout[get_global_id(0)] = add_sat(inout[get_global_id(0)], 2u);\n\
   }\n";
   auto inout = ShaderArg<uint32_t>({ 0xffffffff - 3, 0xffffffff - 2, 0xffffffff - 1, 0xffffffff },
                                    SHADER_ARG_INOUT);
   const uint32_t expected[] = {
      0xffffffff - 1, 0xffffffff, 0xffffffff, 0xffffffff
   };
   run_shader(kernel_source, inout.size(), 1, 1, inout);
   for (int i = 0; i < inout.size(); ++i)
      EXPECT_EQ(inout[i], expected[i]);
}

TEST_F(ComputeTest, sub_sat)
{
   const char *kernel_source =
   "__kernel void main_test(__global uint *inout)\n\
   {\n\
       inout[get_global_id(0)] = sub_sat(inout[get_global_id(0)], 2u);\n\
   }\n";
   auto inout = ShaderArg<uint32_t>({ 0, 1, 2, 3 }, SHADER_ARG_INOUT);
   const uint32_t expected[] = {
      0, 0, 0, 1
   };
   run_shader(kernel_source, inout.size(), 1, 1, inout);
   for (int i = 0; i < inout.size(); ++i)
      EXPECT_EQ(inout[i], expected[i]);
}

TEST_F(ComputeTest, mul_hi)
{
   const char *kernel_source =
   "__kernel void main_test(__global uint *inout)\n\
   {\n\
       inout[get_global_id(0)] = mul_hi(inout[get_global_id(0)], 1u << 31);\n\
   }\n";
   auto inout = ShaderArg<uint32_t>({ 0, 1, 2, 3, (1u << 31) }, SHADER_ARG_INOUT);
   const uint32_t expected[] = {
      0, 0, 1, 1, (1u << 30)
   };
   run_shader(kernel_source, inout.size(), 1, 1, inout);
   for (int i = 0; i < inout.size(); ++i)
      EXPECT_EQ(inout[i], expected[i]);
}

TEST_F(ComputeTest, ldexp_x)
{
   const char *kernel_source =
   "__kernel void main_test(__global float *inout)\n\
   {\n\
       inout[get_global_id(0)] = ldexp(inout[get_global_id(0)], 5);\n\
   }\n";
   auto inout = ShaderArg<float>({ 0.0f, 0.5f, 1.0f, 2.0f }, SHADER_ARG_INOUT);
   const float expected[] = {
      ldexp(0.0f, 5), ldexp(0.5f, 5), ldexp(1.0f, 5), ldexp(2.0f, 5)
   };
   run_shader(kernel_source, inout.size(), 1, 1, inout);
   for (int i = 0; i < inout.size(); ++i)
      EXPECT_FLOAT_EQ(inout[i], expected[i]);
}

TEST_F(ComputeTest, ldexp_y)
{
   const char *kernel_source =
   "__kernel void main_test(__global float *inout)\n\
   {\n\
       inout[get_global_id(0)] = ldexp(inout[get_global_id(0)], get_global_id(0));\n\
   }\n";
   auto inout = ShaderArg<float>({ 0.25f, 0.5f, 0.75f, 1.0f }, SHADER_ARG_INOUT);
   const float expected[] = {
      ldexp(0.25f, 0), ldexp(0.5f, 1), ldexp(0.75f, 2), ldexp(1.0f, 3)
   };
   run_shader(kernel_source, inout.size(), 1, 1, inout);
   for (int i = 0; i < inout.size(); ++i)
      EXPECT_FLOAT_EQ(inout[i], expected[i]);
}

TEST_F(ComputeTest, frexp_ret)
{
   const char *kernel_source =
   "__kernel void main_test(__global float *inout)\n\
   {\n\
       int exp;\n\
       inout[get_global_id(0)] = frexp(inout[get_global_id(0)], &exp);\n\
   }\n";
   auto inout = ShaderArg<float>({ 0.0f, 0.5f, 1.0f, 3.0f }, SHADER_ARG_INOUT);
   const float expected[] = {
      0.0f, 0.5f, 0.5f, 0.75f
   };
   run_shader(kernel_source, inout.size(), 1, 1, inout);
   for (int i = 0; i < inout.size(); ++i)
      EXPECT_FLOAT_EQ(inout[i], expected[i]);
}

TEST_F(ComputeTest, frexp_exp)
{
   const char *kernel_source =
   "__kernel void main_test(__global float *inout)\n\
   {\n\
       int exp;\n\
       frexp(inout[get_global_id(0)], &exp);\n\
       inout[get_global_id(0)] = (float)exp;\n\
   }\n";
   auto inout = ShaderArg<float>({ 0.0f, 0.5f, 1.0f, 3.0f }, SHADER_ARG_INOUT);
   const float expected[] = {
      0.0f, 0.0f, 1.0f, 2.0f
   };
   run_shader(kernel_source, inout.size(), 1, 1, inout);
   for (int i = 0; i < inout.size(); ++i)
      EXPECT_FLOAT_EQ(inout[i], expected[i]);
}

TEST_F(ComputeTest, clz)
{
   const char *kernel_source =
   "__kernel void main_test(__global uint *inout)\n\
   {\n\
       inout[get_global_id(0)] = clz(inout[get_global_id(0)]);\n\
   }\n";
   auto inout = ShaderArg<uint32_t>({ 0, 1, 0xffff,  (1u << 30), (1u << 31) }, SHADER_ARG_INOUT);
   const uint32_t expected[] = {
      32, 31, 16, 1, 0
   };
   run_shader(kernel_source, inout.size(), 1, 1, inout);
   for (int i = 0; i < inout.size(); ++i)
      EXPECT_FLOAT_EQ(inout[i], expected[i]);
}

TEST_F(ComputeTest, sin)
{
   struct sin_vals { float in; float clc; float native; };
   const char *kernel_source =
   "struct sin_vals { float in; float clc; float native; };\n\
   __kernel void main_test(__global struct sin_vals *inout)\n\
   {\n\
       inout[get_global_id(0)].clc = sin(inout[get_global_id(0)].in);\n\
       inout[get_global_id(0)].native = native_sin(inout[get_global_id(0)].in);\n\
   }\n";
   const vector<sin_vals> input = {
      { 0.0f, 0.0f, 0.0f },
      { 1.0f, 0.0f, 0.0f },
      { 2.0f, 0.0f, 0.0f },
      { 3.0f, 0.0f, 0.0f },
   };
   auto inout = ShaderArg<sin_vals>(input, SHADER_ARG_INOUT);
   const struct sin_vals expected[] = {
      { 0.0f, 0.0f,       0.0f       },
      { 1.0f, sin(1.0f), sin(1.0f) },
      { 2.0f, sin(2.0f), sin(2.0f) },
      { 3.0f, sin(3.0f), sin(3.0f) },
   };
   run_shader(kernel_source, inout.size(), 1, 1, inout);
   for (int i = 0; i < inout.size(); ++i) {
      EXPECT_FLOAT_EQ(inout[i].in, inout[i].in);
      EXPECT_FLOAT_EQ(inout[i].clc, inout[i].clc);
      EXPECT_NEAR(inout[i].clc, inout[i].native, 0.008f); // range from DXIL spec
   }
}

TEST_F(ComputeTest, cosh)
{
   const char *kernel_source =
   "__kernel void main_test(__global float *inout)\n\
   {\n\
       inout[get_global_id(0)] = cosh(inout[get_global_id(0)]);\n\
   }\n";
   auto inout = ShaderArg<float>({ 0.0f, 1.0f, 2.0f, 3.0f }, SHADER_ARG_INOUT);
   const float expected[] = {
      cosh(0.0f), cosh(1.0f), cosh(2.0f), cosh(3.0f)
   };
   run_shader(kernel_source, inout.size(), 1, 1, inout);
   for (int i = 0; i < inout.size(); ++i)
      EXPECT_FLOAT_EQ(inout[i], expected[i]);
}

TEST_F(ComputeTest, exp)
{
   const char *kernel_source =
   "__kernel void main_test(__global float *inout)\n\
   {\n\
       inout[get_global_id(0)] = native_exp(inout[get_global_id(0)]);\n\
   }\n";
   auto inout = ShaderArg<float>({ 0.0f, 1.0f, 2.0f, 3.0f }, SHADER_ARG_INOUT);
   const float expected[] = {
      exp(0.0f), exp(1.0f), exp(2.0f), exp(3.0f)
   };
   run_shader(kernel_source, inout.size(), 1, 1, inout);
   for (int i = 0; i < inout.size(); ++i)
      EXPECT_FLOAT_EQ(inout[i], expected[i]);
}

TEST_F(ComputeTest, exp10)
{
   const char *kernel_source =
   "__kernel void main_test(__global float *inout)\n\
   {\n\
       inout[get_global_id(0)] = native_exp10(inout[get_global_id(0)]);\n\
   }\n";
   auto inout = ShaderArg<float>({ 0.0f, 1.0f, 2.0f, 3.0f }, SHADER_ARG_INOUT);
   const float expected[] = {
      pow(10.0f, 0.0f), pow(10.0f, 1.0f), pow(10.0f, 2.0f), pow(10.0f, 3.0f)
   };
   run_shader(kernel_source, inout.size(), 1, 1, inout);
   for (int i = 0; i < inout.size(); ++i)
      EXPECT_FLOAT_EQ(inout[i], expected[i]);
}

TEST_F(ComputeTest, exp2)
{
   const char *kernel_source =
   "__kernel void main_test(__global float *inout)\n\
   {\n\
       inout[get_global_id(0)] = native_exp2(inout[get_global_id(0)]);\n\
   }\n";
   auto inout = ShaderArg<float>({ 0.0f, 1.0f, 2.0f, 3.0f }, SHADER_ARG_INOUT);
   const float expected[] = {
      pow(2.0f, 0.0f), pow(2.0f, 1.0f), pow(2.0f, 2.0f), pow(2.0f, 3.0f)
   };
   run_shader(kernel_source, inout.size(), 1, 1, inout);
   for (int i = 0; i < inout.size(); ++i)
      EXPECT_FLOAT_EQ(inout[i], expected[i]);
}

TEST_F(ComputeTest, log)
{
   const char *kernel_source =
   "__kernel void main_test(__global float *inout)\n\
   {\n\
       inout[get_global_id(0)] = native_log(inout[get_global_id(0)]);\n\
   }\n";
   auto inout = ShaderArg<float>({ 0.0f, 1.0f, 2.0f, 3.0f }, SHADER_ARG_INOUT);
   const float expected[] = {
      log(0.0f), log(1.0f), log(2.0f), log(3.0f)
   };
   run_shader(kernel_source, inout.size(), 1, 1, inout);
   for (int i = 0; i < inout.size(); ++i)
      EXPECT_FLOAT_EQ(inout[i], expected[i]);
}

TEST_F(ComputeTest, log10)
{
   const char *kernel_source =
   "__kernel void main_test(__global float *inout)\n\
   {\n\
       inout[get_global_id(0)] = native_log10(inout[get_global_id(0)]);\n\
   }\n";
   auto inout = ShaderArg<float>({ 0.0f, 1.0f, 2.0f, 3.0f }, SHADER_ARG_INOUT);
   const float expected[] = {
      log10(0.0f), log10(1.0f), log10(2.0f), log10(3.0f)
   };
   run_shader(kernel_source, inout.size(), 1, 1, inout);
   for (int i = 0; i < inout.size(); ++i)
      EXPECT_FLOAT_EQ(inout[i], expected[i]);
}

TEST_F(ComputeTest, log2)
{
   const char *kernel_source =
   "__kernel void main_test(__global float *inout)\n\
   {\n\
       inout[get_global_id(0)] = native_log2(inout[get_global_id(0)]);\n\
   }\n";
   auto inout = ShaderArg<float>({ 0.0f, 1.0f, 2.0f, 3.0f }, SHADER_ARG_INOUT);
   const float expected[] = {
      log(0.0f) / log(2.0f), log(1.0f) / log(2.0f), log(2.0f) / log(2.0f), log(3.0f) / log(2.0f)
   };
   run_shader(kernel_source, inout.size(), 1, 1, inout);
   for (int i = 0; i < inout.size(); ++i)
      EXPECT_FLOAT_EQ(inout[i], expected[i]);
}

TEST_F(ComputeTest, rint)
{
   const char *kernel_source =
   "__kernel void main_test(__global float *inout)\n\
   {\n\
      inout[get_global_id(0)] = rint(inout[get_global_id(0)]);\n\
   }\n";

   auto inout = ShaderArg<float>({ 0.5f, 1.5f, -0.5f, -1.5f, 1.4f }, SHADER_ARG_INOUT);
   const float expected[] = {
      0.0f, 2.0f, 0.0f, -2.0f, 1.0f,
   };
   run_shader(kernel_source, inout.size(), 1, 1, inout);
   for (int i = 0; i < inout.size(); ++i)
      EXPECT_FLOAT_EQ(inout[i], expected[i]);
}

TEST_F(ComputeTest, round)
{
   const char *kernel_source =
   "__kernel void main_test(__global float *inout)\n\
   {\n\
       inout[get_global_id(0)] = round(inout[get_global_id(0)]);\n\
   }\n";
   auto inout = ShaderArg<float>({ 0, 0.3f, -0.3f, 0.5f, -0.5f, 1.1f, -1.1f },
                                 SHADER_ARG_INOUT);
   const float expected[] = {
      0.0f, 0.0f, -0.0f, 1.0f, -1.0f, 1.0f, -1.0f
   };
   run_shader(kernel_source, inout.size(), 1, 1, inout);
   for (int i = 0; i < inout.size(); ++i)
      EXPECT_FLOAT_EQ(inout[i], expected[i]);
}

TEST_F(ComputeTest, arg_by_val)
{
   const char *kernel_source =
   "__kernel void main_test(__global float *inout, float mul)\n\
   {\n\
       inout[get_global_id(0)] = inout[get_global_id(0)] * mul;\n\
   }\n";
   auto inout = ShaderArg<float>({ 0, 0.3f, -0.3f, 0.5f, -0.5f, 1.1f, -1.1f },
                                 SHADER_ARG_INOUT);
   auto mul = ShaderArg<float>(10.0f, SHADER_ARG_INPUT);
   const float expected[] = {
      0.0f, 3.0f, -3.0f, 5.0f, -5.0f, 11.0f, -11.0f
   };
   run_shader(kernel_source, inout.size(), 1, 1, inout, mul);
   for (int i = 0; i < inout.size(); ++i)
      EXPECT_FLOAT_EQ(inout[i], expected[i]);
}

TEST_F(ComputeTest, uint8_by_val)
{
   struct uint8 {
      uint32_t s0; uint32_t s1; uint32_t s2; uint32_t s3;
      uint32_t s4; uint32_t s5; uint32_t s6; uint32_t s7;
   };
   const char *kernel_source =
   "__kernel void main_test(__global uint *out, uint8 val)\n\
   {\n\
       out[get_global_id(0)] = val.s0 + val.s1 + val.s2 + val.s3 +\n\
                               val.s4 + val.s5 + val.s6 + val.s7;\n\
   }\n";
   auto out = ShaderArg<uint32_t>({ 0 }, SHADER_ARG_OUTPUT);
   auto val = ShaderArg<struct uint8>({ {0, 1, 2, 3, 4, 5, 6, 7 }}, SHADER_ARG_INPUT);
   const uint32_t expected[] = { 0 + 1 + 2 + 3 + 4 + 5 + 6 + 7 };
   run_shader(kernel_source, out.size(), 1, 1, out, val);
   for (int i = 0; i < out.size(); ++i)
      EXPECT_EQ(out[i], expected[i]);
}

TEST_F(ComputeTest, link)
{
   const char *foo_src =
   "float foo(float in)\n\
   {\n\
       return in * in;\n\
   }\n";
   const char *kernel_source =
   "float foo(float in);\n\
   __kernel void main_test(__global float *inout)\n\
   {\n\
       inout[get_global_id(0)] = foo(inout[get_global_id(0)]);\n\
   }\n";
   std::vector<const char *> srcs = { foo_src, kernel_source };
   auto inout = ShaderArg<float>({ 2.0f }, SHADER_ARG_INOUT);
   const float expected[] = {
      4.0f,
   };
   run_shader(srcs, inout.size(), 1, 1, inout);
   for (int i = 0; i < inout.size(); ++i)
      EXPECT_EQ(inout[i], expected[i]);
}

TEST_F(ComputeTest, link_library)
{
   const char *bar_src =
   "float bar(float in)\n\
   {\n\
      return in * 5;\n\
   }\n";
   const char *foo_src =
   "float bar(float in);\n\
   float foo(float in)\n\
   {\n\
       return in * bar(in);\n\
   }\n";
   const char *kernel_source =
   "float foo(float in);\n\
   __kernel void main_test(__global float *inout)\n\
   {\n\
       inout[get_global_id(0)] = foo(inout[get_global_id(0)]);\n\
   }\n";
   std::vector<Shader> libraries = {
      compile({ bar_src, kernel_source }, {}, true),
      compile({ foo_src }, {}, true)
   };
   Shader exe = link(libraries);
   auto inout = ShaderArg<float>({ 2.0f }, SHADER_ARG_INOUT);
   const float expected[] = {
      20.0f,
   };
   run_shader(exe, { (unsigned)inout.size(), 1, 1 }, inout);
   for (int i = 0; i < inout.size(); ++i)
      EXPECT_EQ(inout[i], expected[i]);
}

TEST_F(ComputeTest, localvar)
{
   const char *kernel_source =
   "__kernel __attribute__((reqd_work_group_size(2, 1, 1)))\n\
   void main_test(__global float *inout)\n\
   {\n\
      __local float2 tmp[2];\n\
      tmp[get_local_id(0)].x = inout[get_global_id(0)] + 1;\n\
      tmp[get_local_id(0)].y = inout[get_global_id(0)] - 1;\n\
      barrier(CLK_LOCAL_MEM_FENCE);\n\
      inout[get_global_id(0)] = tmp[get_local_id(0) % 2].x * tmp[(get_local_id(0) + 1) % 2].y;\n\
   }\n";

   auto inout = ShaderArg<float>({ 2.0f, 4.0f }, SHADER_ARG_INOUT);
   const float expected[] = {
      9.0f, 5.0f
   };
   run_shader(kernel_source, inout.size(), 1, 1, inout);
   for (int i = 0; i < inout.size(); ++i)
      EXPECT_EQ(inout[i], expected[i]);
}

TEST_F(ComputeTest, localvar_uchar2)
{
   const char *kernel_source =
   "__attribute__((reqd_work_group_size(2, 1, 1)))\n\
   __kernel void main_test(__global uchar *inout)\n\
   {\n\
      __local uchar2 tmp[2];\n\
      tmp[get_local_id(0)].x = inout[get_global_id(0)] + 1;\n\
      tmp[get_local_id(0)].y = inout[get_global_id(0)] - 1;\n\
      barrier(CLK_LOCAL_MEM_FENCE);\n\
      inout[get_global_id(0)] = tmp[get_local_id(0) % 2].x * tmp[(get_local_id(0) + 1) % 2].y;\n\
   }\n";

   auto inout = ShaderArg<uint8_t>({ 2, 4 }, SHADER_ARG_INOUT);
   const uint8_t expected[] = { 9, 5 };
   run_shader(kernel_source, inout.size(), 1, 1, inout);
   for (int i = 0; i < inout.size(); ++i)
      EXPECT_EQ(inout[i], expected[i]);
}

TEST_F(ComputeTest, work_group_size_hint)
{
   const char *kernel_source =
   "__attribute__((work_group_size_hint(2, 1, 1)))\n\
   __kernel void main_test(__global uint *output)\n\
   {\n\
       output[get_global_id(0)] = get_local_id(0);\n\
   }\n";
   auto output = ShaderArg<uint32_t>(std::vector<uint32_t>(4, 0xdeadbeef),
                                     SHADER_ARG_OUTPUT);
   const uint32_t expected[] = {
      0, 1, 2, 3
   };
   run_shader(kernel_source, output.size(), 1, 1, output);
   for (int i = 0; i < output.size(); ++i)
      EXPECT_EQ(output[i], expected[i]);
}

TEST_F(ComputeTest, reqd_work_group_size)
{
   const char *kernel_source =
   "__attribute__((reqd_work_group_size(2, 1, 1)))\n\
   __kernel void main_test(__global uint *output)\n\
   {\n\
       output[get_global_id(0)] = get_local_id(0);\n\
   }\n";
   auto output = ShaderArg<uint32_t>(std::vector<uint32_t>(4, 0xdeadbeef),
                                     SHADER_ARG_OUTPUT);
   const uint32_t expected[] = {
      0, 1, 0, 1
   };
   run_shader(kernel_source, output.size(), 1, 1, output);
   for (int i = 0; i < output.size(); ++i)
      EXPECT_EQ(output[i], expected[i]);
}

TEST_F(ComputeTest, image)
{
   const char* kernel_source =
   "__kernel void main_test(read_only image2d_t input, write_only image2d_t output)\n\
   {\n\
      int2 coords = (int2)(get_global_id(0), get_global_id(1));\n\
      write_imagef(output, coords, read_imagef(input, coords));\n\
   }\n";
   Shader shader = compile(std::vector<const char*>({ kernel_source }));
   validate(shader);
}

TEST_F(ComputeTest, image_two_reads)
{
   // Note: unnecessary control flow is present so that nir_opt_dead_cf kicks in, causing
   // nir_rematerialize_derefs_in_use_blocks to run. The duplicated uses ensure that the
   // per-var-deref processing works correctly.
   const char* kernel_source =
   R"(__kernel void main_test(image2d_t image, int is_float, __global float* output)
   {
      int x = get_global_id(0);
      if (is_float)
         x = get_global_id(0);
      if (is_float)
         output[x] = read_imagef(image, (int2)(0, 0)).x;
      else
         output[x] = (float)read_imagei(image, (int2)(0, 0)).x;
      if (is_float)
         output[x] = read_imagef(image, (int2)(0, 0)).x;
      else
         output[x] = (float)read_imagei(image, (int2)(0, 0)).x;
   })";
   Shader shader = compile(std::vector<const char*>({ kernel_source }));
   validate(shader);
}

TEST_F(ComputeTest, image_unused)
{
   const char* kernel_source =
   "__kernel void main_test(read_only image2d_t input, write_only image2d_t output)\n\
   {\n\
   }\n";
   Shader shader = compile(std::vector<const char*>({ kernel_source }));
   validate(shader);
}

TEST_F(ComputeTest, image_read_write)
{
   const char *kernel_source =
   R"(__kernel void main_test(read_write image2d_t image)
   {
      int2 coords = (int2)(get_global_id(0), get_global_id(1));
      write_imagef(image, coords, read_imagef(image, coords) + (float4)(1.0f, 1.0f, 1.0f, 1.0f));
   })";
   Shader shader = compile(std::vector<const char*>({ kernel_source }), { "-cl-std=cl3.0" });
   validate(shader);
}

TEST_F(ComputeTest, sampler)
{
   const char* kernel_source =
   "__kernel void main_test(image2d_t image, sampler_t sampler, __global float* output)\n\
   {\n\
      output[get_global_id(0)] = read_imagef(image, sampler, (int2)(0, 0)).x;\n\
   }\n";
   Shader shader = compile(std::vector<const char*>({ kernel_source }));
   validate(shader);
}

TEST_F(ComputeTest, image_dims)
{
   const char* kernel_source =
   "__kernel void main_test(image2d_t roimage, write_only image2d_t woimage, __global uint* output)\n\
   {\n\
      output[get_global_id(0)] = get_image_width(roimage);\n\
      output[get_global_id(0) + 1] = get_image_width(woimage);\n\
   }\n";
   Shader shader = compile(std::vector<const char*>({ kernel_source }));
   validate(shader);
}

TEST_F(ComputeTest, image_format)
{
   const char* kernel_source =
   "__kernel void main_test(image2d_t roimage, write_only image2d_t woimage, __global uint* output)\n\
   {\n\
      output[get_global_id(0)] = get_image_channel_data_type(roimage);\n\
      output[get_global_id(0) + 1] = get_image_channel_order(woimage);\n\
   }\n";
   Shader shader = compile(std::vector<const char*>({ kernel_source }));
   validate(shader);
}

TEST_F(ComputeTest, image1d_buffer_t)
{
   const char* kernel_source =
   "__kernel void main_test(read_only image1d_buffer_t input, write_only image1d_buffer_t output)\n\
   {\n\
      write_imageui(output, get_global_id(0), read_imageui(input, get_global_id(0)));\n\
   }\n";
   Shader shader = compile(std::vector<const char*>({ kernel_source }));
   validate(shader);
}

TEST_F(ComputeTest, local_ptr)
{
   struct uint2 { uint32_t x, y; };
   const char *kernel_source =
   "__kernel void main_test(__global uint *inout, __local uint2 *tmp)\n\
   {\n\
      tmp[get_local_id(0)].x = inout[get_global_id(0)] + 1;\n\
      tmp[get_local_id(0)].y = inout[get_global_id(0)] - 1;\n\
      barrier(CLK_LOCAL_MEM_FENCE);\n\
      inout[get_global_id(0)] = tmp[get_local_id(0) % 2].x * tmp[(get_local_id(0) + 1) % 2].y;\n\
   }\n";
   auto inout = ShaderArg<uint32_t>({ 2, 4 }, SHADER_ARG_INOUT);
   auto tmp = ShaderArg<struct uint2>(std::vector<struct uint2>(4096), SHADER_ARG_INPUT);
   const uint8_t expected[] = { 9, 5 };
   run_shader(kernel_source, inout.size(), 1, 1, inout, tmp);
   for (int i = 0; i < inout.size(); ++i)
      EXPECT_EQ(inout[i], expected[i]);
}

TEST_F(ComputeTest, two_local_ptrs)
{
   struct uint2 { uint32_t x, y; };
   const char *kernel_source =
   "__kernel void main_test(__global uint *inout, __local uint2 *tmp, __local uint *tmp2)\n\
   {\n\
      tmp[get_local_id(0)].x = inout[get_global_id(0)] + 1;\n\
      tmp[get_local_id(0)].y = inout[get_global_id(0)] - 1;\n\
      tmp2[get_local_id(0)] = get_global_id(0);\n\
      barrier(CLK_LOCAL_MEM_FENCE);\n\
      inout[get_global_id(0)] = tmp[get_local_id(0) % 2].x * tmp[(get_local_id(0) + 1) % 2].y + tmp2[get_local_id(0) % 2];\n\
   }\n";
   auto inout = ShaderArg<uint32_t>({ 2, 4 }, SHADER_ARG_INOUT);
   auto tmp = ShaderArg<struct uint2>(std::vector<struct uint2>(1024), SHADER_ARG_INPUT);
   auto tmp2 = ShaderArg<uint32_t>(std::vector<uint32_t>(1024), SHADER_ARG_INPUT);
   const uint8_t expected[] = { 9, 6 };
   run_shader(kernel_source, inout.size(), 1, 1, inout, tmp, tmp2);
   for (int i = 0; i < inout.size(); ++i)
      EXPECT_EQ(inout[i], expected[i]);
}

TEST_F(ComputeTest, int8_to_float)
{
   const char *kernel_source =
   "__kernel void main_test(__global char* in, __global float* out)\n\
   {\n\
      uint pos = get_global_id(0);\n\
      out[pos] = in[pos] / 100.0f;\n\
   }";
   auto in = ShaderArg<char>({ 10, 20, 30, 40 }, SHADER_ARG_INPUT);
   auto out = ShaderArg<float>(std::vector<float>(4, std::numeric_limits<float>::infinity()), SHADER_ARG_OUTPUT);
   const float expected[] = { 0.1f, 0.2f, 0.3f, 0.4f };
   run_shader(kernel_source, in.size(), 1, 1, in, out);
   for (int i = 0; i < in.size(); ++i)
      EXPECT_FLOAT_EQ(out[i], expected[i]);
}

TEST_F(ComputeTest, vec_hint_float4)
{
   const char *kernel_source =
   "__kernel __attribute__((vec_type_hint(float4))) void main_test(__global float *inout)\n\
   {\n\
      inout[get_global_id(0)] *= inout[get_global_id(1)];\n\
   }";
   Shader shader = compile({ kernel_source });
   EXPECT_EQ(shader.metadata->kernels[0].vec_hint_size, 4);
   EXPECT_EQ(shader.metadata->kernels[0].vec_hint_type, CLC_VEC_HINT_TYPE_FLOAT);
}

TEST_F(ComputeTest, vec_hint_uchar2)
{
   const char *kernel_source =
   "__kernel __attribute__((vec_type_hint(uchar2))) void main_test(__global float *inout)\n\
   {\n\
      inout[get_global_id(0)] *= inout[get_global_id(1)];\n\
   }";
   Shader shader = compile({ kernel_source });
   EXPECT_EQ(shader.metadata->kernels[0].vec_hint_size, 2);
   EXPECT_EQ(shader.metadata->kernels[0].vec_hint_type, CLC_VEC_HINT_TYPE_CHAR);
}

TEST_F(ComputeTest, vec_hint_none)
{
   const char *kernel_source =
   "__kernel void main_test(__global float *inout)\n\
   {\n\
      inout[get_global_id(0)] *= inout[get_global_id(1)];\n\
   }";
   Shader shader = compile({ kernel_source });
   EXPECT_EQ(shader.metadata->kernels[0].vec_hint_size, 0);
}

TEST_F(ComputeTest, DISABLED_debug_layer_failure)
{
   /* This is a negative test case, it intentionally triggers a failure to validate the mechanism
    * is in place, so other tests will fail if they produce debug messages
    */
   const char *kernel_source =
   "__kernel void main_test(__global float *inout, float mul)\n\
   {\n\
       inout[get_global_id(0)] = inout[get_global_id(0)] * mul;\n\
   }\n";
   auto inout = ShaderArg<float>({ 0, 0.3f, -0.3f, 0.5f, -0.5f, 1.1f, -1.1f },
                                 SHADER_ARG_INOUT);
   auto mul = ShaderArg<float>(10.0f, SHADER_ARG_INPUT);
   const float expected[] = {
      0.0f, 3.0f, -3.0f, 5.0f, -5.0f, 11.0f, -11.0f
   };
   ComPtr<ID3D12InfoQueue> info_queue;
   dev->QueryInterface(info_queue.ReleaseAndGetAddressOf());
   if (!info_queue) {
      GTEST_SKIP() << "No info queue";
      return;
   }

   info_queue->AddApplicationMessage(D3D12_MESSAGE_SEVERITY_ERROR, "This should cause the test to fail");
   run_shader(kernel_source, inout.size(), 1, 1, inout, mul);
   for (int i = 0; i < inout.size(); ++i)
      EXPECT_FLOAT_EQ(inout[i], expected[i]);
}

TEST_F(ComputeTest, compiler_defines)
{
   const char *kernel_source =
      "__kernel void main_test(__global int* out)\n\
   {\n\
      out[0] = OUT_VAL0;\n\
      out[1] = __OPENCL_C_VERSION__;\n\
   }";
   auto out = ShaderArg<int>(std::vector<int>(2, 0), SHADER_ARG_OUTPUT);
   CompileArgs compile_args = { 1, 1, 1 };
   compile_args.compiler_command_line = { "-DOUT_VAL0=5", "-cl-std=cl" };
   std::vector<RawShaderArg *> raw_args = { &out };
   run_shader({ kernel_source }, compile_args, out);
   EXPECT_EQ(out[0], 5);
   EXPECT_EQ(out[1], 100);
}

TEST_F(ComputeTest, global_atomic_add)
{
   const char *kernel_source =
   "__kernel void main_test(__global int *inout, __global int *old)\n\
   {\n\
      old[get_global_id(0)] = atomic_add(inout + get_global_id(0), 3);\n\
   }\n";
   auto inout = ShaderArg<int32_t>({ 2, 4 }, SHADER_ARG_INOUT);
   auto old = ShaderArg<int32_t>(std::vector<int32_t>(2, 0xdeadbeef), SHADER_ARG_OUTPUT);
   const int32_t expected_inout[] = { 5, 7 };
   const int32_t expected_old[] = { 2, 4 };
   run_shader(kernel_source, inout.size(), 1, 1, inout, old);
   for (int i = 0; i < inout.size(); ++i) {
      EXPECT_EQ(inout[i], expected_inout[i]);
      EXPECT_EQ(old[i], expected_old[i]);
   }
}

TEST_F(ComputeTest, global_atomic_imin)
{
   const char *kernel_source =
   "__kernel void main_test(__global int *inout, __global int *old)\n\
   {\n\
      old[get_global_id(0)] = atomic_min(inout + get_global_id(0), 1);\n\
   }\n";
   auto inout = ShaderArg<int32_t>({ 0, 2, -1 }, SHADER_ARG_INOUT);
   auto old = ShaderArg<int32_t>(std::vector<int32_t>(3, 0xdeadbeef), SHADER_ARG_OUTPUT);
   const int32_t expected_inout[] = { 0, 1, -1 };
   const int32_t expected_old[] = { 0, 2, -1 };
   run_shader(kernel_source, inout.size(), 1, 1, inout, old);
   for (int i = 0; i < inout.size(); ++i) {
      EXPECT_EQ(inout[i], expected_inout[i]);
      EXPECT_EQ(old[i], expected_old[i]);
   }
}

TEST_F(ComputeTest, global_atomic_and_or)
{
   const char *kernel_source =
   "__attribute__((reqd_work_group_size(3, 1, 1)))\n\
   __kernel void main_test(__global int *inout)\n\
   {\n\
      atomic_and(inout, ~(1 << get_global_id(0)));\n\
      atomic_or(inout, (1 << (get_global_id(0) + 4)));\n\
   }\n";
   auto inout = ShaderArg<int32_t>(0xf, SHADER_ARG_INOUT);
   const int32_t expected[] = { 0x78 };
   run_shader(kernel_source, 3, 1, 1, inout);
   for (int i = 0; i < inout.size(); ++i)
      EXPECT_EQ(inout[i], expected[i]);
}

TEST_F(ComputeTest, global_atomic_cmpxchg)
{
   const char *kernel_source =
   "__attribute__((reqd_work_group_size(2, 1, 1)))\n\
   __kernel void main_test(__global int *inout)\n\
   {\n\
      while (atomic_cmpxchg(inout, get_global_id(0), get_global_id(0) + 1) != get_global_id(0))\n\
         ;\n\
   }\n";
   auto inout = ShaderArg<int32_t>(0, SHADER_ARG_INOUT);
   const int32_t expected_inout[] = { 2 };
   run_shader(kernel_source, 2, 1, 1, inout);
   for (int i = 0; i < inout.size(); ++i)
      EXPECT_EQ(inout[i], expected_inout[i]);
}

TEST_F(ComputeTest, local_atomic_and_or)
{
   const char *kernel_source =
   "__attribute__((reqd_work_group_size(2, 1, 1)))\n\
   __kernel void main_test(__global ushort *inout)\n\
   {\n\
      __local ushort tmp;\n\
      atomic_and(&tmp, ~(0xff << (get_global_id(0) * 8)));\n\
      atomic_or(&tmp, inout[get_global_id(0)] << (get_global_id(0) * 8));\n\
      barrier(CLK_LOCAL_MEM_FENCE);\n\
      inout[get_global_id(0)] = tmp;\n\
   }\n";
   auto inout = ShaderArg<uint16_t>({ 2, 4 }, SHADER_ARG_INOUT);
   const uint16_t expected[] = { 0x402, 0x402 };
   run_shader(kernel_source, inout.size(), 1, 1, inout);
   for (int i = 0; i < inout.size(); ++i)
      EXPECT_EQ(inout[i], expected[i]);
}

TEST_F(ComputeTest, local_atomic_cmpxchg)
{
   const char *kernel_source =
   "__attribute__((reqd_work_group_size(2, 1, 1)))\n\
   __kernel void main_test(__global int *out)\n\
   {\n\
      __local uint tmp;\n\
      tmp = 0;\n\
      barrier(CLK_LOCAL_MEM_FENCE);\n\
      while (atomic_cmpxchg(&tmp, get_global_id(0), get_global_id(0) + 1) != get_global_id(0))\n\
         ;\n\
      barrier(CLK_LOCAL_MEM_FENCE);\n\
      out[0] = tmp;\n\
   }\n";

   auto out = ShaderArg<uint32_t>(0xdeadbeef, SHADER_ARG_OUTPUT);
   const uint16_t expected[] = { 2 };
   run_shader(kernel_source, 2, 1, 1, out);
   for (int i = 0; i < out.size(); ++i)
      EXPECT_EQ(out[i], expected[i]);
}

TEST_F(ComputeTest, constant_sampler)
{
   const char* kernel_source =
   "__constant sampler_t sampler = CLK_NORMALIZED_COORDS_FALSE | CLK_ADDRESS_CLAMP | CLK_FILTER_LINEAR;\n\
   __kernel void main_test(read_only image2d_t input, write_only image2d_t output)\n\
   {\n\
      int2 coordsi = (int2)(get_global_id(0), get_global_id(1));\n\
      float2 coordsf = (float2)((float)coordsi.x / get_image_width(input), (float)coordsi.y / get_image_height(input));\n\
      write_imagef(output, coordsi, \n\
         read_imagef(input, sampler, coordsf) + \n\
         read_imagef(input, sampler, coordsf + (float2)(0.1, 0.1)));\n\
   }\n";
   Shader shader = compile(std::vector<const char*>({ kernel_source }));
   validate(shader);
   EXPECT_EQ(shader.dxil->metadata.num_const_samplers, 1);
}

TEST_F(ComputeTest, hi)
{
   const char *kernel_source = R"(
   __kernel void main_test(__global char3 *srcA, __global char2 *dst)
   {
       int  tid = get_global_id(0);

       char2 tmp = srcA[tid].hi;
       dst[tid] = tmp;
   })";
   Shader shader = compile(std::vector<const char*>({ kernel_source }));
   validate(shader);
}

TEST_F(ComputeTest, system_values)
{
   const char *kernel_source =
   "__kernel void main_test(__global uint* outputs)\n\
   {\n\
      outputs[0] = get_work_dim();\n\
      outputs[1] = get_global_size(0);\n\
      outputs[2] = get_local_size(0);\n\
      outputs[3] = get_num_groups(0);\n\
      outputs[4] = get_group_id(0);\n\
      outputs[5] = get_global_offset(0);\n\
      outputs[6] = get_global_id(0);\n\
   }\n";
   auto out = ShaderArg<uint32_t>(std::vector<uint32_t>(6, 0xdeadbeef), SHADER_ARG_OUTPUT);
   const uint16_t expected[] = { 3, 1, 1, 1, 0, 0, 0, };
   CompileArgs args = { 1, 1, 1 };
   Shader shader = compile({ kernel_source });
   run_shader(shader, args, out);
   for (int i = 0; i < out.size(); ++i)
      EXPECT_EQ(out[i], expected[i]);

   args.work_props.work_dim = 2;
   args.work_props.global_offset_x = 100;
   args.work_props.group_id_offset_x = 2;
   args.work_props.group_count_total_x = 5;
   const uint32_t expected_withoffsets[] = { 2, 5, 1, 5, 2, 100, 102 };
   run_shader(shader, args, out);
   for (int i = 0; i < out.size(); ++i)
      EXPECT_EQ(out[i], expected_withoffsets[i]);
}

TEST_F(ComputeTest, convert_round_sat)
{
   const char *kernel_source =
   "__kernel void main_test(__global float *f, __global uchar *u)\n\
   {\n\
       uint idx = get_global_id(0);\n\
       u[idx] = convert_uchar_sat_rtp(f[idx]);\n\
   }\n";
   auto f = ShaderArg<float>({ -1.0f, 1.1f, 20.0f, 255.5f }, SHADER_ARG_INPUT);
   auto u = ShaderArg<uint8_t>({ 255, 0, 0, 0 }, SHADER_ARG_OUTPUT);
   const uint8_t expected[] = {
      0, 2, 20, 255
   };

   run_shader(kernel_source, f.size(), 1, 1, f, u);
   for (int i = 0; i < u.size(); ++i)
      EXPECT_EQ(u[i], expected[i]);
}

TEST_F(ComputeTest, convert_round_sat_vec)
{
   const char *kernel_source =
   "__kernel void main_test(__global float16 *f, __global uchar16 *u)\n\
   {\n\
       uint idx = get_global_id(0);\n\
       u[idx] = convert_uchar16_sat_rtp(f[idx]);\n\
   }\n";
   auto f = ShaderArg<float>({
      -1.0f, 1.1f, 20.0f, 255.5f, -1.0f, 1.1f, 20.0f, 255.5f, -1.0f, 1.1f, 20.0f, 255.5f, -1.0f, 1.1f, 20.0f, 255.5f,
      -0.5f, 1.9f, 20.0f, 254.5f, -1.0f, 1.1f, 20.0f, 255.5f, -1.0f, 1.1f, 20.0f, 255.5f, -1.0f, 1.1f, 20.0f, 255.5f,
       0.0f, 1.3f, 20.0f, 255.1f, -1.0f, 1.1f, 20.0f, 255.5f, -1.0f, 1.1f, 20.0f, 255.5f, -1.0f, 1.1f, 20.0f, 255.5f,
      -0.0f, 1.5555f, 20.0f, 254.9f, -1.0f, 1.1f, 20.0f, 255.5f, -1.0f, 1.1f, 20.0f, 255.5f, -1.0f, 1.1f, 20.0f, 255.5f,
   }, SHADER_ARG_INPUT);
   auto u = ShaderArg<uint8_t>({
      255, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0,
      255, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0,
      255, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0,
      255, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0, 255, 0, 0, 0,
   }, SHADER_ARG_OUTPUT);
   const uint8_t expected[] = {
      0, 2, 20, 255, 0, 2, 20, 255, 0, 2, 20, 255, 0, 2, 20, 255,
      0, 2, 20, 255, 0, 2, 20, 255, 0, 2, 20, 255, 0, 2, 20, 255,
      0, 2, 20, 255, 0, 2, 20, 255, 0, 2, 20, 255, 0, 2, 20, 255,
      0, 2, 20, 255, 0, 2, 20, 255, 0, 2, 20, 255, 0, 2, 20, 255,
   };

   run_shader(kernel_source, 4, 1, 1, f, u);
   for (int i = 0; i < u.size(); ++i)
      EXPECT_EQ(u[i], expected[i]);
}

TEST_F(ComputeTest, convert_char2_uchar2)
{
   const char *kernel_source =
   "__kernel void main_test( __global char2 *src, __global uchar2 *dest )\n\
   {\n\
      size_t i = get_global_id(0);\n\
      dest[i] = convert_uchar2_sat( src[i] );\n\
   }\n";

   auto c = ShaderArg<int8_t>({ -127, -4, 0, 4, 126, 127, 16, 32 }, SHADER_ARG_INPUT);
   auto u = ShaderArg<uint8_t>({ 99, 99, 99, 99, 99, 99, 99, 99 }, SHADER_ARG_OUTPUT);
   const uint8_t expected[] = { 0, 0, 0, 4, 126, 127, 16, 32 };
   run_shader(kernel_source, 4, 1, 1, c, u);
   for (int i = 0; i < u.size(); i++)
      EXPECT_EQ(u[i], expected[i]);
}

TEST_F(ComputeTest, async_copy)
{
   const char *kernel_source = R"(
   __kernel void main_test( const __global char *src, __global char *dst, __local char *localBuffer, int copiesPerWorkgroup, int copiesPerWorkItem )
   {
    int i;
    for(i=0; i<copiesPerWorkItem; i++)
        localBuffer[ get_local_id( 0 )*copiesPerWorkItem+i ] = (char)(char)0;
       barrier( CLK_LOCAL_MEM_FENCE );
       event_t event;
       event = async_work_group_copy( (__local char*)localBuffer, (__global const char*)(src+copiesPerWorkgroup*get_group_id(0)), (size_t)copiesPerWorkgroup, 0 );
       wait_group_events( 1, &event );
    for(i=0; i<copiesPerWorkItem; i++)
     dst[ get_global_id( 0 )*copiesPerWorkItem+i ] = localBuffer[ get_local_id( 0 )*copiesPerWorkItem+i ];
   })";
   Shader shader = compile({ kernel_source });
   validate(shader);
}

TEST_F(ComputeTest, packed_struct_global)
{
#pragma pack(push, 1)
   struct s { uint8_t uc; uint64_t ul; uint16_t us; };
#pragma pack(pop)

   const char *kernel_source =
   "struct __attribute__((packed)) s {uchar uc; ulong ul; ushort us; };\n\
   __kernel void main_test(__global struct s *inout, global uint *size)\n\
   {\n\
       uint idx = get_global_id(0);\n\
       inout[idx].uc = idx + 1;\n\
       inout[idx].ul = ((ulong)(idx + 1 + 0xfbfcfdfe) << 32) | 0x12345678;\n\
       inout[idx].us = ((ulong)(idx + 1 + 0xa0) << 8) | 0x12;\n\
       *size = sizeof(struct s);\n\
   }\n";
   auto inout = ShaderArg<struct s>({0, 0, 0}, SHADER_ARG_OUTPUT);
   auto size = ShaderArg<uint32_t>(0, SHADER_ARG_OUTPUT);
   const struct s expected[] = {
      { 1, 0xfbfcfdff12345678, 0xa112 }
   };

   run_shader(kernel_source, inout.size(), 1, 1, inout, size);
   for (int i = 0; i < inout.size(); ++i) {
      EXPECT_EQ(inout[i].uc, expected[i].uc);
      EXPECT_EQ(inout[i].ul, expected[i].ul);
      EXPECT_EQ(inout[i].us, expected[i].us);
   }
   EXPECT_EQ(size, sizeof(struct s));
}

TEST_F(ComputeTest, packed_struct_arg)
{
#pragma pack(push, 1)
   struct s { uint8_t uc; uint64_t ul; uint16_t us; };
#pragma pack(pop)

   const char *kernel_source =
   "struct __attribute__((packed)) s {uchar uc; ulong ul; ushort us; };\n\
   __kernel void main_test(__global struct s *out, struct s in)\n\
   {\n\
       uint idx = get_global_id(0);\n\
       out[idx].uc = in.uc + 0x12;\n\
       out[idx].ul = in.ul + 0x123456789abcdef;\n\
       out[idx].us = in.us + 0x1234;\n\
   }\n";
   auto out = ShaderArg<struct s>({0, 0, 0}, SHADER_ARG_OUTPUT);
   auto in = ShaderArg<struct s>({1, 2, 3}, SHADER_ARG_INPUT);
   const struct s expected[] = {
      { 0x12 + 1, 0x123456789abcdef + 2, 0x1234 + 3 }
   };

   run_shader(kernel_source, out.size(), 1, 1, out, in);
   for (int i = 0; i < out.size(); ++i) {
      EXPECT_EQ(out[i].uc, expected[i].uc);
      EXPECT_EQ(out[i].ul, expected[i].ul);
      EXPECT_EQ(out[i].us, expected[i].us);
   }
}

TEST_F(ComputeTest, packed_struct_local)
{
#pragma pack(push, 1)
   struct s { uint8_t uc; uint64_t ul; uint16_t us; };
#pragma pack(pop)

   const char *kernel_source =
   "struct __attribute__((packed)) s {uchar uc; ulong ul; ushort us; };\n\
   __kernel void main_test(__global struct s *out, __constant struct s *in)\n\
   {\n\
       uint idx = get_global_id(0);\n\
       __local struct s tmp[2];\n\
       tmp[get_local_id(0)] = in[idx];\n\
       barrier(CLK_LOCAL_MEM_FENCE);\n\
       out[idx] = tmp[(get_local_id(0) + 1) % 2];\n\
   }\n";
   auto out = ShaderArg<struct s>({{0, 0, 0}, {0, 0, 0}}, SHADER_ARG_OUTPUT);
   auto in = ShaderArg<struct s>({{1, 2, 3}, {0x12, 0x123456789abcdef, 0x1234} }, SHADER_ARG_INPUT);
   const struct s expected[] = {
      { 0x12, 0x123456789abcdef, 0x1234 },
      { 1, 2, 3 },
   };

   run_shader(kernel_source, out.size(), 1, 1, out, in);
   for (int i = 0; i < out.size(); ++i) {
      EXPECT_EQ(out[i].uc, expected[i].uc);
      EXPECT_EQ(out[i].ul, expected[i].ul);
      EXPECT_EQ(out[i].us, expected[i].us);
   }
}

TEST_F(ComputeTest, packed_struct_const)
{
#pragma pack(push, 1)
   struct s { uint8_t uc; uint64_t ul; uint16_t us; };
#pragma pack(pop)

   const char *kernel_source =
   "struct __attribute__((packed)) s {uchar uc; ulong ul; ushort us; };\n\
   __kernel void main_test(__global struct s *out, struct s in)\n\
   {\n\
       __constant struct s base[] = {\n\
          {0x12, 0x123456789abcdef, 0x1234},\n\
          {0x11, 0x123456789abcdee, 0x1233},\n\
       };\n\
       uint idx = get_global_id(0);\n\
       out[idx].uc = base[idx % 2].uc + in.uc;\n\
       out[idx].ul = base[idx % 2].ul + in.ul;\n\
       out[idx].us = base[idx % 2].us + in.us;\n\
   }\n";
   auto out = ShaderArg<struct s>(std::vector<struct s>(2, {0, 0, 0}), SHADER_ARG_OUTPUT);
   auto in = ShaderArg<struct s>({1, 2, 3}, SHADER_ARG_INPUT);
   const struct s expected[] = {
      { 0x12 + 1, 0x123456789abcdef + 2, 0x1234 + 3 },
      { 0x11 + 1, 0x123456789abcdee + 2, 0x1233 + 3 },
   };

   run_shader(kernel_source, out.size(), 1, 1, out, in);
   for (int i = 0; i < out.size(); ++i) {
      EXPECT_EQ(out[i].uc, expected[i].uc);
      EXPECT_EQ(out[i].ul, expected[i].ul);
      EXPECT_EQ(out[i].us, expected[i].us);
   }
}

TEST_F(ComputeTest, printf)
{
   const char *kernel_source = R"(
   __kernel void main_test(__global float *src, __global uint *dest)
   {
      *dest = printf("%s: %f", "Test", src[0]);
   })";

   auto src = ShaderArg<float>({ 1.0f }, SHADER_ARG_INPUT);
   auto dest = ShaderArg<uint32_t>({ 0xdeadbeef }, SHADER_ARG_OUTPUT);
   run_shader(kernel_source, 1, 1, 1, src, dest);
   EXPECT_EQ(dest[0], 0);
}

TEST_F(ComputeTest, vload_half)
{
   const char *kernel_source = R"(
   __kernel void main_test(__global half *src, __global float4 *dest)
   {
      int offset = get_global_id(0);
      dest[offset] = vload_half4(offset, src);
   })";
   auto src = ShaderArg<uint16_t>({ 0x3c00, 0x4000, 0x4200, 0x4400,
                                    0x4500, 0x4600, 0x4700, 0x4800 }, SHADER_ARG_INPUT);
   auto dest = ShaderArg<float>({ FLT_MAX, FLT_MAX, FLT_MAX, FLT_MAX,
                                  FLT_MAX, FLT_MAX, FLT_MAX, FLT_MAX }, SHADER_ARG_OUTPUT);
   run_shader(kernel_source, 2, 1, 1, src, dest);
   for (unsigned i = 0; i < 8; ++i)
      EXPECT_FLOAT_EQ(dest[i], (float)(i + 1));
}

TEST_F(ComputeTest, vstore_half)
{
   const char *kernel_source = R"(
   __kernel void main_test(__global half *dst, __global float4 *src)
   {
      int offset = get_global_id(0);
      vstore_half4(src[offset], offset, dst);
   })";
   auto dest = ShaderArg<uint16_t>({0xdead, 0xdead, 0xdead, 0xdead,
                                   0xdead, 0xdead, 0xdead, 0xdead}, SHADER_ARG_OUTPUT);
   auto src = ShaderArg<float>({ 1.0, 2.0, 3.0, 4.0,
                                  5.0, 6.0, 7.0, 8.0 }, SHADER_ARG_INPUT);
   run_shader(kernel_source, 2, 1, 1, dest, src);
   const uint16_t expected[] = { 0x3c00, 0x4000, 0x4200, 0x4400,
                                 0x4500, 0x4600, 0x4700, 0x4800 };
   for (unsigned i = 0; i < 8; ++i)
      EXPECT_EQ(dest[i], expected[i]);
}

TEST_F(ComputeTest, inline_function)
{
   const char *kernel_source = R"(
   inline float helper(float foo)
   {
      return foo * 2;
   }

   __kernel void main_test(__global float *dst, __global float *src)
   {
      *dst = helper(*src);
   })";
   auto dest = ShaderArg<float>({ NAN }, SHADER_ARG_OUTPUT);
   auto src = ShaderArg<float>({ 1.0f }, SHADER_ARG_INPUT);
   run_shader(kernel_source, 1, 1, 1, dest, src);
   EXPECT_EQ(dest[0], 2.0f);
}

TEST_F(ComputeTest, unused_arg)
{
   const char *kernel_source = R"(
   __kernel void main_test(__global int *dst, __global int *unused, __global int *src)
   {
      int i = get_global_id(0);
      dst[i] = src[i];
   })";
   auto dest = ShaderArg<int>({ -1, -1, -1, -1 }, SHADER_ARG_OUTPUT);
   auto src = ShaderArg<int>({ 1, 2, 3, 4 }, SHADER_ARG_INPUT);
   auto unused = ShaderArg<int>({ -1, -1, -1, -1 }, SHADER_ARG_INPUT);
   run_shader(kernel_source, 4, 1, 1, dest, unused, src);
   for (int i = 0; i < 4; ++i)
      EXPECT_EQ(dest[i], i + 1);
}

TEST_F(ComputeTest, spec_constant)
{
   const char *spirv_asm = R"(
               OpCapability Addresses
               OpCapability Kernel
               OpCapability Int64
          %1 = OpExtInstImport "OpenCL.std"
               OpMemoryModel Physical64 OpenCL
               OpEntryPoint Kernel %2 "main_test" %__spirv_BuiltInGlobalInvocationId
          %4 = OpString "kernel_arg_type.main_test.uint*,"
               OpSource OpenCL_C 102000
               OpName %__spirv_BuiltInGlobalInvocationId "__spirv_BuiltInGlobalInvocationId"
               OpName %output "output"
               OpName %entry "entry"
               OpName %output_addr "output.addr"
               OpName %id "id"
               OpName %call "call"
               OpName %conv "conv"
               OpName %idxprom "idxprom"
               OpName %arrayidx "arrayidx"
               OpName %add "add"
               OpName %mul "mul"
               OpName %idxprom1 "idxprom1"
               OpName %arrayidx2 "arrayidx2"
               OpDecorate %__spirv_BuiltInGlobalInvocationId BuiltIn GlobalInvocationId
               OpDecorate %__spirv_BuiltInGlobalInvocationId Constant
               OpDecorate %id Alignment 4
               OpDecorate %output_addr Alignment 8
               OpDecorate %uint_1 SpecId 1
      %ulong = OpTypeInt 64 0
       %uint = OpTypeInt 32 0
     %uint_1 = OpSpecConstant %uint 1
    %v3ulong = OpTypeVector %ulong 3
%_ptr_Input_v3ulong = OpTypePointer Input %v3ulong
       %void = OpTypeVoid
%_ptr_CrossWorkgroup_uint = OpTypePointer CrossWorkgroup %uint
         %24 = OpTypeFunction %void %_ptr_CrossWorkgroup_uint
%_ptr_Function__ptr_CrossWorkgroup_uint = OpTypePointer Function %_ptr_CrossWorkgroup_uint
%_ptr_Function_uint = OpTypePointer Function %uint
%__spirv_BuiltInGlobalInvocationId = OpVariable %_ptr_Input_v3ulong Input
          %2 = OpFunction %void DontInline %24
     %output = OpFunctionParameter %_ptr_CrossWorkgroup_uint
      %entry = OpLabel
%output_addr = OpVariable %_ptr_Function__ptr_CrossWorkgroup_uint Function
         %id = OpVariable %_ptr_Function_uint Function
               OpStore %output_addr %output Aligned 8
         %27 = OpLoad %v3ulong %__spirv_BuiltInGlobalInvocationId Aligned 32
       %call = OpCompositeExtract %ulong %27 0
       %conv = OpUConvert %uint %call
               OpStore %id %conv Aligned 4
         %28 = OpLoad %_ptr_CrossWorkgroup_uint %output_addr Aligned 8
         %29 = OpLoad %uint %id Aligned 4
    %idxprom = OpUConvert %ulong %29
   %arrayidx = OpInBoundsPtrAccessChain %_ptr_CrossWorkgroup_uint %28 %idxprom
         %30 = OpLoad %uint %arrayidx Aligned 4
         %31 = OpLoad %uint %id Aligned 4
        %add = OpIAdd %uint %31 %uint_1
        %mul = OpIMul %uint %30 %add
         %32 = OpLoad %_ptr_CrossWorkgroup_uint %output_addr Aligned 8
         %33 = OpLoad %uint %id Aligned 4
   %idxprom1 = OpUConvert %ulong %33
  %arrayidx2 = OpInBoundsPtrAccessChain %_ptr_CrossWorkgroup_uint %32 %idxprom1
               OpStore %arrayidx2 %mul Aligned 4
               OpReturn
               OpFunctionEnd)";
   Shader shader = assemble(spirv_asm);
   Shader spec_shader = specialize(shader, 1, 5);

   auto inout = ShaderArg<uint32_t>({ 0x00000001, 0x10000001, 0x00020002, 0x04010203 },
      SHADER_ARG_INOUT);
   const uint32_t expected[] = {
      0x00000005, 0x60000006, 0x000e000e, 0x20081018
   };
   CompileArgs args = { (unsigned)inout.size(), 1, 1 };
   run_shader(spec_shader, args, inout);
   for (int i = 0; i < inout.size(); ++i)
      EXPECT_EQ(inout[i], expected[i]);
}

TEST_F(ComputeTest, arg_metadata)
{
   const char *kernel_source = R"(
   __kernel void main_test(
      __global int *undec_ptr,
      __global volatile int *vol_ptr,
      __global const int *const_ptr,
      __global int *restrict restr_ptr,
      __global const int *restrict const_restr_ptr,
      __constant int *const_ptr2)
   {
   })";
   Shader shader = compile({ kernel_source });
   EXPECT_EQ(shader.metadata->kernels[0].args[0].address_qualifier, CLC_KERNEL_ARG_ADDRESS_GLOBAL);
   EXPECT_EQ(shader.metadata->kernels[0].args[0].type_qualifier, 0);
   EXPECT_EQ(shader.metadata->kernels[0].args[1].address_qualifier, CLC_KERNEL_ARG_ADDRESS_GLOBAL);
   EXPECT_EQ(shader.metadata->kernels[0].args[1].type_qualifier, CLC_KERNEL_ARG_TYPE_VOLATILE);
   EXPECT_EQ(shader.metadata->kernels[0].args[2].address_qualifier, CLC_KERNEL_ARG_ADDRESS_GLOBAL);
   EXPECT_EQ(shader.metadata->kernels[0].args[2].type_qualifier, CLC_KERNEL_ARG_TYPE_CONST);
   EXPECT_EQ(shader.metadata->kernels[0].args[3].address_qualifier, CLC_KERNEL_ARG_ADDRESS_GLOBAL);
   EXPECT_EQ(shader.metadata->kernels[0].args[3].type_qualifier, CLC_KERNEL_ARG_TYPE_RESTRICT);
   EXPECT_EQ(shader.metadata->kernels[0].args[4].address_qualifier, CLC_KERNEL_ARG_ADDRESS_GLOBAL);
   EXPECT_EQ(shader.metadata->kernels[0].args[4].type_qualifier, CLC_KERNEL_ARG_TYPE_RESTRICT | CLC_KERNEL_ARG_TYPE_CONST);
   EXPECT_EQ(shader.metadata->kernels[0].args[5].address_qualifier, CLC_KERNEL_ARG_ADDRESS_CONSTANT);
   EXPECT_EQ(shader.metadata->kernels[0].args[5].type_qualifier, CLC_KERNEL_ARG_TYPE_CONST);
}